GCC Code Coverage Report
Directory: ./ Exec Total Coverage
File: test/zserio/ReflectableTest.cpp Lines: 1449 1449 100.0 %
Date: 2023-12-13 14:51:09 Branches: 21710 104754 20.7 %

Line Branch Exec Source
1
#include <string>
2
#include <functional>
3
#include <type_traits>
4
5
#include "gtest/gtest.h"
6
7
#include "zserio/ArrayTraits.h"
8
#include "zserio/BitStreamReader.h"
9
#include "zserio/BitStreamWriter.h"
10
#include "zserio/BitSizeOfCalculator.h"
11
#include "zserio/Reflectable.h"
12
#include "zserio/Vector.h"
13
14
#include "test_object/std_allocator/ReflectableBitmask.h"
15
#include "test_object/std_allocator/ReflectableEnum.h"
16
#include "test_object/std_allocator/ReflectableNested.h"
17
#include "test_object/std_allocator/ReflectableObject.h"
18
19
using test_object::std_allocator::ReflectableBitmask;
20
using test_object::std_allocator::ReflectableEnum;
21
using test_object::std_allocator::ReflectableNested;
22
using test_object::std_allocator::ReflectableObject;
23
24
using namespace std::placeholders;
25
26
namespace zserio
27
{
28
29
namespace
30
{
31
32
5
ReflectableObject createInitializedReflectableObject(const string<>& stringField,
33
        uint32_t reflectableNestedValue)
34
{
35
5
    ReflectableObject reflectableObject(stringField, ReflectableNested{reflectableNestedValue});
36
5
    reflectableObject.initializeChildren();
37
5
    return reflectableObject;
38
}
39
40
} // namespace
41
42
namespace detail
43
{
44
45
template <typename FUNC>
46
struct return_type;
47
48
template <typename R, typename CLASS, typename... ARGS>
49
struct return_type<R (CLASS::*) (ARGS...) const>
50
{
51
    using type = R;
52
};
53
54
} // namespace
55
56
220
class ReflectableTest : public ::testing::Test
57
{
58
protected:
59
    template <typename RAW_ARRAY>
60
40
    void checkArrayAnyValue(const RAW_ARRAY& rawArray, const IReflectableConstPtr& reflectable)
61
    {
62




































































40
        ASSERT_EQ(rawArray,
63
                    reflectable->getAnyValue().template get<std::reference_wrapper<const RAW_ARRAY>>().get());
64
    }
65
66
    template <typename RAW_ARRAY>
67
31
    void checkArrayAnyValue(const RAW_ARRAY& rawArray, const IReflectablePtr& reflectable)
68
    {
69




































































31
        ASSERT_EQ(rawArray,
70
                    reflectable->getAnyValue().template get<std::reference_wrapper<RAW_ARRAY>>().get());
71
    }
72
73
    template <typename RAW_ARRAY, typename REFLECTABLE_PTR, typename ELEMENT_CHECKER>
74
71
    void checkArray(const RAW_ARRAY& rawArray, const REFLECTABLE_PTR& reflectable,
75
            const ELEMENT_CHECKER& elementChecker)
76
    {
77
























































































































































































































































71
        ASSERT_TRUE(reflectable->isArray());
78
























































































































































































































































71
        ASSERT_EQ(rawArray.size(), reflectable->size());
79



































330
        for (size_t i = 0; i < rawArray.size(); ++i)
80
        {
81



































259
            if (i % 2 == 0)
82







































































141
                elementChecker(rawArray[i], reflectable->at(i));
83
            else
84




























































































































118
                elementChecker(rawArray[i], (*reflectable)[i]);
85
        }
86
87




















































































































































































































































































































































































































































































































































































































































































































142
        ASSERT_THROW(reflectable->at(rawArray.size()), CppRuntimeException);
88




















































































































































































































































































































































































































































































































































































































































































































142
        ASSERT_THROW((*reflectable)[rawArray.size()], CppRuntimeException);
89
90



































71
        checkArrayAnyValue(rawArray, reflectable);
91
92




















































































































































































































































































































































































































































































































































































































































































































142
        ASSERT_THROW(reflectable->getBool(), CppRuntimeException);
93




















































































































































































































































































































































































































































































































































































































































































































142
        ASSERT_THROW(reflectable->getInt8(), CppRuntimeException);
94




















































































































































































































































































































































































































































































































































































































































































































142
        ASSERT_THROW(reflectable->getInt16(), CppRuntimeException);
95




















































































































































































































































































































































































































































































































































































































































































































142
        ASSERT_THROW(reflectable->getInt32(), CppRuntimeException);
96




















































































































































































































































































































































































































































































































































































































































































































142
        ASSERT_THROW(reflectable->getInt64(), CppRuntimeException);
97




















































































































































































































































































































































































































































































































































































































































































































142
        ASSERT_THROW(reflectable->getUInt8(), CppRuntimeException);
98




















































































































































































































































































































































































































































































































































































































































































































142
        ASSERT_THROW(reflectable->getUInt16(), CppRuntimeException);
99




















































































































































































































































































































































































































































































































































































































































































































142
        ASSERT_THROW(reflectable->getUInt32(), CppRuntimeException);
100




















































































































































































































































































































































































































































































































































































































































































































142
        ASSERT_THROW(reflectable->getUInt64(), CppRuntimeException);
101




















































































































































































































































































































































































































































































































































































































































































































142
        ASSERT_THROW(reflectable->getFloat(), CppRuntimeException);
102




















































































































































































































































































































































































































































































































































































































































































































142
        ASSERT_THROW(reflectable->getDouble(), CppRuntimeException);
103




















































































































































































































































































































































































































































































































































































































































































































142
        ASSERT_THROW(reflectable->getBytes(), CppRuntimeException);
104




















































































































































































































































































































































































































































































































































































































































































































142
        ASSERT_THROW(reflectable->getStringView(), CppRuntimeException);
105




















































































































































































































































































































































































































































































































































































































































































































142
        ASSERT_THROW(reflectable->getBitBuffer(), CppRuntimeException);
106
107




















































































































































































































































































































































































































































































































































































































































































































142
        ASSERT_THROW(reflectable->toInt(), CppRuntimeException);
108




















































































































































































































































































































































































































































































































































































































































































































142
        ASSERT_THROW(reflectable->toUInt(), CppRuntimeException);
109




















































































































































































































































































































































































































































































































































































































































































































142
        ASSERT_THROW(reflectable->toDouble(), CppRuntimeException);
110




















































































































































































































































































































































































































































































































































































































































































































142
        ASSERT_THROW(reflectable->toString(), CppRuntimeException);
111
112































































































































































































































































































































































































































































































































































































































































142
        ASSERT_THROW(reflectable->bitSizeOf(0), CppRuntimeException);
113
114
























































































142
        BitBuffer bitBuffer(0);
115



































71
        BitStreamWriter writer(bitBuffer);
116































































































































































































































































































































































































































































































































































































































































142
        ASSERT_THROW(reflectable->write(writer), CppRuntimeException);
117
118







































































71
        checkNonCompound(reflectable);
119
    }
120
121
    template <typename T, typename REFLECTABLE_PTR, typename READ_FUNC>
122
308
    void checkWriteRead(T value, const REFLECTABLE_PTR& reflectable, const READ_FUNC& readFunc,
123
            size_t bitBufferSize)
124
    {
125




























616
        BitBuffer bitBuffer(bitBufferSize);
126




























308
        BitStreamWriter writer(bitBuffer);
127




























308
        reflectable->write(writer);
128




























308
        const size_t bitSizeOfValue = reflectable->bitSizeOf();
129








































































































































































308
        ASSERT_EQ(bitSizeOfValue, writer.getBitPosition());
130
131




























308
        BitStreamReader reader(bitBuffer);
132




































































































































































































308
        ASSERT_EQ(value, readFunc(reader));
133




































































































































































































308
        ASSERT_EQ(bitSizeOfValue, reader.getBitPosition());
134
    }
135
136
308
    void checkNonArray(const IReflectableConstPtr& reflectable)
137
    {
138




308
        ASSERT_FALSE(reflectable->isArray());
139










616
        ASSERT_THROW(reflectable->size(), CppRuntimeException);
140










616
        ASSERT_THROW(reflectable->at(0), CppRuntimeException);
141









616
        ASSERT_THROW((*reflectable)[0], CppRuntimeException);
142
    }
143
144
125
    void checkNonArray(const IReflectablePtr& reflectable)
145
    {
146

125
        checkNonArray(static_cast<IReflectableConstPtr>(reflectable));
147
148










250
        ASSERT_THROW(reflectable->at(0), CppRuntimeException);
149










250
        ASSERT_THROW((*reflectable)[0], CppRuntimeException);
150









250
        ASSERT_THROW(reflectable->resize(1), CppRuntimeException);
151










250
        ASSERT_THROW(reflectable->setAt(AnyHolder<>(), 0), CppRuntimeException);
152
    }
153
154
    template <typename REFLECTABLE_PTR>
155
368
    void checkNonCompoundConstMethods(const REFLECTABLE_PTR& reflectable)
156
    {
157




















736
        ASSERT_THROW(reflectable->getField("field"), CppRuntimeException);
158




















736
        ASSERT_THROW(reflectable->getParameter("parameter"), CppRuntimeException);
159






















736
        ASSERT_THROW(reflectable->callFunction("function"), CppRuntimeException);
160



















736
        ASSERT_THROW(reflectable->getChoice(), CppRuntimeException);
161
162







368
        ASSERT_EQ(nullptr, reflectable->find("some.field"));
163







368
        ASSERT_EQ(nullptr, (*reflectable)["some.field"]);
164
    }
165
166
153
    void checkNonCompound(const IReflectablePtr& reflectable)
167
    {
168









306
        ASSERT_THROW(reflectable->initializeChildren(), CppRuntimeException);
169










306
        ASSERT_THROW(reflectable->initialize(vector<AnyHolder<>>()), CppRuntimeException);
170










306
        ASSERT_THROW(reflectable->setField("field", AnyHolder<>{}), CppRuntimeException);
171











306
        ASSERT_THROW(reflectable->createField("field"), CppRuntimeException);
172









306
        ASSERT_THROW(reflectable->initializeOffsets(), CppRuntimeException);
173
174
153
        checkNonCompoundConstMethods(reflectable);
175
    }
176
177
215
    void checkNonCompound(const IReflectableConstPtr& reflectable)
178
    {
179
215
        checkNonCompoundConstMethods(reflectable);
180
215
    }
181
182
    template <typename T, typename REFLECTABLE_PTR, typename GETTER,
183
            typename std::enable_if<
184
                    std::is_same<T, typename detail::return_type<GETTER>::type>::value, int>::type = 0>
185
283
    void checkCppTypeGetter(T value, const REFLECTABLE_PTR& reflectable, const GETTER& getter,
186
            const char* testName, const char* getterName)
187
    {
188




































































































































283
        ASSERT_EQ(value, ((*reflectable).*getter)()) << testName << " : " << getterName;
189
    }
190
191
    template <typename T, typename REFLECTABLE_PTR, typename GETTER,
192
            typename std::enable_if<
193
                    !std::is_same<T, typename detail::return_type<GETTER>::type>::value, int>::type = 0>
194
3861
    void checkCppTypeGetter(T, const REFLECTABLE_PTR& reflectable, const GETTER& getter,
195
            const char* testName, const char* getterName)
196
    {
197





















































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































3861
        ASSERT_THROW(((*reflectable).*getter)(), CppRuntimeException) << testName << " : " << getterName;
198
    }
199
200
    template <typename REFLECTABLE_PTR, typename GETTER,
201
            typename std::enable_if<std::is_same<Span<const uint8_t>,
202
                    typename detail::return_type<GETTER>::type>::value, int>::type = 0>
203
7
    void checkCppTypeGetter(Span<const uint8_t> value, const REFLECTABLE_PTR& reflectable, const GETTER& getter,
204
            const char* testName, const char* getterName)
205
    {
206











7
        ASSERT_EQ(value.size(), ((*reflectable).*getter)().size()) << testName << " : " << getterName;
207











7
        ASSERT_EQ(value.data(), ((*reflectable).*getter)().data()) << testName << " : " << getterName;
208
    }
209
210
    template <typename REFLECTABLE_PTR, typename GETTER,
211
            typename std::enable_if<std::is_same<const BitBuffer&,
212
                    typename detail::return_type<GETTER>::type>::value, int>::type = 0>
213
7
    void checkCppTypeGetter(const BitBuffer& value, const REFLECTABLE_PTR& reflectable, const GETTER& getter,
214
            const char* testName, const char* getterName)
215
    {
216











7
        ASSERT_EQ(value, ((*reflectable).*getter)()) << testName << " : " << getterName;
217
    }
218
219
    template <typename T, typename REFLECTABLE_PTR>
220
297
    void checkCppTypeGetters(T value, const REFLECTABLE_PTR& reflectable, const char* testName)
221
    {
222















297
        checkCppTypeGetter(value, reflectable, &IReflectable::getBool, testName, "getBool");
223
224















297
        checkCppTypeGetter(value, reflectable, &IReflectable::getInt8, testName, "getInt8");
225















297
        checkCppTypeGetter(value, reflectable, &IReflectable::getInt16, testName, "getInt16");
226















297
        checkCppTypeGetter(value, reflectable, &IReflectable::getInt32, testName, "getInt32");
227















297
        checkCppTypeGetter(value, reflectable, &IReflectable::getInt64, testName, "getInt64");
228
229















297
        checkCppTypeGetter(value, reflectable, &IReflectable::getUInt8, testName, "getUInt8");
230















297
        checkCppTypeGetter(value, reflectable, &IReflectable::getUInt16, testName, "getUInt16");
231















297
        checkCppTypeGetter(value, reflectable, &IReflectable::getUInt32, testName, "getUInt32");
232















297
        checkCppTypeGetter(value, reflectable, &IReflectable::getUInt64, testName, "getUInt64");
233
234















297
        checkCppTypeGetter(value, reflectable, &IReflectable::getFloat, testName, "getFloat");
235















297
        checkCppTypeGetter(value, reflectable, &IReflectable::getDouble, testName, "getDouble");
236
237















297
        checkCppTypeGetter(value, reflectable, &IReflectable::getBytes, testName, "getBytes");
238















297
        checkCppTypeGetter(value, reflectable, &IReflectable::getStringView, testName, "getStringView");
239














297
        checkCppTypeGetter(value, reflectable, &IReflectable::getBitBuffer, testName, "getBitBuffer");
240
297
    }
241
242
    template <typename T, typename REFLECTABLE_PTR, typename GETTER, typename READ_FUNC>
243
19
    void checkFloatingPoint(T value, const REFLECTABLE_PTR& reflectable,
244
            const GETTER& getter, const READ_FUNC& readFunc, size_t bitSize = sizeof(T) * 8)
245
    {
246
















19
        ASSERT_DOUBLE_EQ(value, ((*reflectable).*getter)());
247
248

















19
        ASSERT_DOUBLE_EQ(value, reflectable->toDouble());
249







































38
        ASSERT_THROW(reflectable->toInt(), CppRuntimeException);
250







































38
        ASSERT_THROW(reflectable->toUInt(), CppRuntimeException);
251




































38
        ASSERT_THROW(reflectable->toString(), CppRuntimeException); // NOT IMPLEMENTED!
252
253
19
        checkCppTypeGetters(value, reflectable, "checkFloatingPoint");
254
255
19
        checkNonCompound(reflectable);
256
19
        checkNonArray(reflectable);
257
258
19
        checkWriteRead(value, reflectable, readFunc, bitSize);
259
    }
260
261
    template <typename T, typename REFLECTABLE_PTR, typename GETTER, typename READ_FUNC>
262
232
    void checkIntegral(T value, const REFLECTABLE_PTR& reflectable,
263
            const GETTER& getter, const READ_FUNC& readFunc, size_t bitSize, const char* testName)
264
    {
265
































































































































































232
        ASSERT_EQ(value, ((*reflectable).*getter)());
266
267
































































































































































232
        ASSERT_EQ(value, reflectable->getAnyValue().template get<T>());
268
269












































































































































232
        ASSERT_DOUBLE_EQ(static_cast<double>(value), reflectable->toDouble());
270
































































































































































232
        ASSERT_EQ(zserio::toString(value), reflectable->toString());
271
272
232
        checkCppTypeGetters(value, reflectable, testName);
273
274
232
        checkNonCompound(reflectable);
275
232
        checkNonArray(reflectable);
276
277
232
        checkWriteRead(value, reflectable, readFunc, bitSize);
278
    }
279
280
    template <typename T, typename REFLECTABLE_PTR, typename GETTER, typename READ_FUNC>
281
114
    void checkSignedIntegral(T value, const REFLECTABLE_PTR& reflectable,
282
            const GETTER& getter, const READ_FUNC& readFunc, size_t bitSize = sizeof(T) * 8)
283
    {
284
















































































114
        ASSERT_EQ(value, reflectable->toInt());
285















































































































































































228
        ASSERT_THROW(reflectable->toUInt(), CppRuntimeException);
286
287
114
        checkIntegral(value, reflectable, getter, readFunc, bitSize, "checkSignedIntegral");
288
    }
289
290
    template <typename T, typename REFLECTABLE_PTR, typename GETTER, typename READ_FUNC>
291
118
    void checkUnsignedIntegral(T value, const REFLECTABLE_PTR& reflectable,
292
            const GETTER& getter, const READ_FUNC& readFunc, size_t bitSize = sizeof(T) * 8)
293
    {
294

























































































118
        ASSERT_EQ(value, reflectable->toUInt());
295

































































































































































































236
        ASSERT_THROW(reflectable->toInt(), CppRuntimeException);
296
297
118
        checkIntegral(value, reflectable, getter, readFunc, bitSize, "checkUnsignedIntegral");
298
    }
299
300
    template <typename REFLECTABLE_PTR>
301
11
    void checkString(StringView value, const REFLECTABLE_PTR& reflectable)
302
    {
303








11
        ASSERT_EQ(value, reflectable->getAnyValue().template get<StringView>());
304
305









11
        ASSERT_EQ(toString(value), reflectable->toString());
306



















22
        ASSERT_THROW(reflectable->toInt(), CppRuntimeException);
307



















22
        ASSERT_THROW(reflectable->toUInt(), CppRuntimeException);
308


















22
        ASSERT_THROW(reflectable->toDouble(), CppRuntimeException);
309
310
11
        checkCppTypeGetters(value, reflectable, "checkString");
311
312
11
        checkNonCompound(reflectable);
313
11
        checkNonArray(reflectable);
314
315



11
        checkWriteRead(toString(value), reflectable,
316
                std::bind(&BitStreamReader::readString<>, _1, std::allocator<uint8_t>()),
317
11
                bitSizeOfVarSize(convertSizeToUInt32(value.size())) + value.size() * 8);
318
    }
319
320
    template <typename REFLECTABLE_PTR>
321
7
    void checkBitBuffer(const BitBuffer& value, const REFLECTABLE_PTR& reflectable)
322
    {
323









7
        ASSERT_EQ(value, reflectable->getAnyValue().
324
                template get<std::reference_wrapper<const BitBuffer>>().get());
325
326



















14
        ASSERT_THROW(reflectable->toString(), CppRuntimeException);
327



















14
        ASSERT_THROW(reflectable->toDouble(), CppRuntimeException);
328



















14
        ASSERT_THROW(reflectable->toInt(), CppRuntimeException);
329


















14
        ASSERT_THROW(reflectable->toUInt(), CppRuntimeException);
330
331

7
        checkCppTypeGetters(value, reflectable, "checkBitBuffer");
332
333
7
        checkNonCompound(reflectable);
334
7
        checkNonArray(reflectable);
335
336



7
        checkWriteRead(value, reflectable,
337
                std::bind(&BitStreamReader::readBitBuffer<>, _1, std::allocator<uint8_t>()),
338
7
                bitSizeOfVarSize(convertSizeToUInt32(value.getBitSize())) + value.getBitSize());
339
    }
340
341
    template <typename REFLECTABLE_PTR>
342
7
    void checkBytes(const std::vector<uint8_t>& value, const REFLECTABLE_PTR& reflectable)
343
    {
344







7
        ASSERT_EQ(value.data(), reflectable->getBytes().data());
345







7
        ASSERT_EQ(value.size(), reflectable->getBytes().size());
346


7
        auto anyValue = reflectable->getAnyValue().template get<Span<const uint8_t>>();
347






7
        ASSERT_EQ(value.data(), anyValue.data());
348







7
        ASSERT_EQ(value.size(), anyValue.size());
349
350



















14
        ASSERT_THROW(reflectable->toString(), CppRuntimeException);
351



















14
        ASSERT_THROW(reflectable->toDouble(), CppRuntimeException);
352



















14
        ASSERT_THROW(reflectable->toInt(), CppRuntimeException);
353


















14
        ASSERT_THROW(reflectable->toUInt(), CppRuntimeException);
354
355


7
        checkCppTypeGetters(Span<const uint8_t>(value), reflectable, "checkBytes");
356
357

7
        checkNonCompound(reflectable);
358

7
        checkNonArray(reflectable);
359
360
7
        const size_t bitSize = value.size() * 8;
361



7
        checkWriteRead(value, reflectable,
362
                std::bind(&BitStreamReader::readBytes<>, _1, std::allocator<uint8_t>()),
363


7
                bitSizeOfVarSize(convertSizeToUInt32(bitSize)) + bitSize);
364
    }
365
366
    template <typename REFLECTABLE_PTR>
367
11
    void checkBitmask(ReflectableBitmask bitmask, const REFLECTABLE_PTR& reflectable)
368
    {
369







11
        ASSERT_EQ(bitmask.getValue(), reflectable->getUInt8());
370
371








11
        ASSERT_EQ(bitmask, reflectable->getAnyValue().template get<ReflectableBitmask>());
372
373







11
        ASSERT_EQ(bitmask.getValue(), reflectable->toUInt());
374







11
        ASSERT_EQ(bitmask.getValue(), reflectable->toDouble());
375









11
        ASSERT_EQ(bitmask.toString(), reflectable->toString());
376


















22
        ASSERT_THROW(reflectable->toInt(), CppRuntimeException);
377
378
11
        checkCppTypeGetters(bitmask.getValue(), reflectable, "checkBitmask");
379
380
11
        checkNonCompound(reflectable);
381
11
        checkNonArray(reflectable);
382
383

11
        checkWriteRead(bitmask, reflectable,
384
11
                [](BitStreamReader& reader) {
385
                    return ReflectableBitmask(reader);
386
11
                }, 8
387
        );
388
    }
389
390
    template <typename REFLECTABLE_PTR>
391
10
    void checkEnum(ReflectableEnum enumeration, const REFLECTABLE_PTR& reflectable)
392
    {
393







10
        ASSERT_EQ(enumToValue(enumeration), reflectable->getInt8());
394
395








10
        ASSERT_EQ(enumeration, reflectable->getAnyValue().template get<ReflectableEnum>());
396
397







10
        ASSERT_EQ(enumToValue(enumeration), reflectable->toInt());
398







10
        ASSERT_EQ(enumToValue(enumeration), reflectable->toDouble());
399









10
        ASSERT_EQ(enumToString(enumeration), reflectable->toString());
400


















20
        ASSERT_THROW(reflectable->toUInt(), CppRuntimeException);
401
402
10
        checkCppTypeGetters(enumToValue(enumeration), reflectable, "checkEnum");
403
404
10
        checkNonCompound(reflectable);
405
10
        checkNonArray(reflectable);
406
407

10
        checkWriteRead(enumeration, reflectable,
408
10
                [](BitStreamReader& reader) {
409
                    return zserio::read<ReflectableEnum>(reader);
410
10
                }, 8
411
        );
412
    }
413
414
8
    void checkCompoundAnyValue(const ReflectableObject& reflectableObject,
415
            const IReflectableConstPtr& reflectable)
416
    {
417




8
        ASSERT_EQ(reflectableObject,
418
                reflectable->getAnyValue().
419
                        template get<std::reference_wrapper<const ReflectableObject>>().get());
420





8
        ASSERT_EQ(reflectableObject.getReflectableNested(),
421
                reflectable->getField("reflectableNested")->getAnyValue().
422
                        template get<std::reference_wrapper<const ReflectableNested>>().get());
423
    }
424
425
3
    void checkCompoundAnyValue(const ReflectableObject& reflectableObject,
426
            const IReflectablePtr& reflectable)
427
    {
428




3
        ASSERT_EQ(reflectableObject,
429
                reflectable->getAnyValue().
430
                        template get<std::reference_wrapper<ReflectableObject>>().get());
431





3
        ASSERT_EQ(reflectableObject.getReflectableNested(),
432
                reflectable->getField("reflectableNested")->getAnyValue().
433
                        template get<std::reference_wrapper<ReflectableNested>>().get());
434
    }
435
436
    template <typename REFLECTABLE_PTR>
437
11
    void checkCompoundConstMethods(const ReflectableObject& reflectableObject,
438
            const REFLECTABLE_PTR& reflectable)
439
    {
440









11
        ASSERT_TRUE(TypeInfoUtil::isCompound(reflectable->getTypeInfo().getSchemaType()));
441
442
        // field getter
443











11
        ASSERT_EQ(reflectableObject.getReflectableNested().getValue(),
444
                reflectable->getField("reflectableNested")->getField("value")->getUInt32());
445




















22
        ASSERT_THROW(reflectable->getField("nonexistent"), CppRuntimeException);
446





















22
        ASSERT_THROW(reflectable->getField("reflectableNested")->getField("nonexistent"), CppRuntimeException);
447
448
        // find field
449










11
        ASSERT_EQ(reflectableObject.getReflectableNested().getValue(),
450
                reflectable->find("reflectableNested.value")->toUInt());
451










11
        ASSERT_EQ(reflectableObject.getReflectableNested().getValue(),
452
                (*reflectable)["reflectableNested.value"]->toDouble());
453
454
        // find parameter
455



















11
        ASSERT_NO_THROW(reflectable->getField("reflectableNested")->getParameter("dummyParam"));
456








11
        ASSERT_EQ(13, (*reflectable)["reflectableNested.dummyParam"]->getInt32());
457



















11
        ASSERT_NO_THROW(reflectable->getField("reflectableNested")->getParameter("stringParam"));
458









11
        ASSERT_EQ(reflectableObject.getStringField(),
459
                (*reflectable)["reflectableNested.stringParam"]->toString());
460





















22
        ASSERT_THROW(reflectable->getField("reflectableNested")->getParameter("nonexistent"),
461
                CppRuntimeException);
462
463
        // find function
464










11
        ASSERT_EQ(reflectableObject.getReflectableNested().getValue(),
465
                (*reflectable)["reflectableNested.getValue"]->getUInt32());
466





















22
        ASSERT_THROW(reflectable->getField("reflectableNested")->callFunction("nonexistent"),
467
                CppRuntimeException);
468
469
        // find failed
470







11
        ASSERT_EQ(nullptr, reflectable->find("reflectableNested.nonexistent"));
471







11
        ASSERT_EQ(nullptr, reflectable->find("nonexistent"));
472







11
        ASSERT_EQ(nullptr, reflectable->find("reflectableNested.value.nonexistent"));
473







11
        ASSERT_EQ(nullptr, reflectable->find("reflectableNested.dummyParam.nonexistent"));
474







11
        ASSERT_EQ(nullptr, reflectable->find("reflectableNested.getValue.nonexistent"));
475
        // find failed because the underlying code throws
476








11
        ASSERT_EQ(nullptr, reflectable->find("reflectableNested.throwingFunction.nonexistent"));
477
478
11
        checkCompoundAnyValue(reflectableObject, reflectable);
479
480




















22
        ASSERT_THROW(reflectable->getBool(), CppRuntimeException);
481




















22
        ASSERT_THROW(reflectable->getInt8(), CppRuntimeException);
482




















22
        ASSERT_THROW(reflectable->getInt16(), CppRuntimeException);
483




















22
        ASSERT_THROW(reflectable->getInt32(), CppRuntimeException);
484




















22
        ASSERT_THROW(reflectable->getInt64(), CppRuntimeException);
485




















22
        ASSERT_THROW(reflectable->getUInt8(), CppRuntimeException);
486




















22
        ASSERT_THROW(reflectable->getUInt16(), CppRuntimeException);
487




















22
        ASSERT_THROW(reflectable->getUInt32(), CppRuntimeException);
488




















22
        ASSERT_THROW(reflectable->getUInt64(), CppRuntimeException);
489




















22
        ASSERT_THROW(reflectable->getFloat(), CppRuntimeException);
490




















22
        ASSERT_THROW(reflectable->getDouble(), CppRuntimeException);
491




















22
        ASSERT_THROW(reflectable->getBytes(), CppRuntimeException);
492




















22
        ASSERT_THROW(reflectable->getStringView(), CppRuntimeException);
493




















22
        ASSERT_THROW(reflectable->getBitBuffer(), CppRuntimeException);
494
495




















22
        ASSERT_THROW(reflectable->toInt(), CppRuntimeException);
496




















22
        ASSERT_THROW(reflectable->toUInt(), CppRuntimeException);
497




















22
        ASSERT_THROW(reflectable->toDouble(), CppRuntimeException);
498



















22
        ASSERT_THROW(reflectable->toString(), CppRuntimeException);
499
500
11
        checkNonArray(reflectable);
501
502


11
        checkWriteRead(reflectableObject, reflectable,
503
11
                [](BitStreamReader& reader) {
504
                    return ReflectableObject(reader);
505

11
                }, reflectableObject.bitSizeOf()
506
        );
507
    }
508
509
5
    void checkCompound(const ReflectableObject& reflectableObject, const IReflectableConstPtr& reflectable)
510
    {
511
5
        checkCompoundConstMethods(reflectableObject, reflectable);
512
5
    }
513
514
3
    void checkCompound(const ReflectableObject& reflectableObject, const IReflectablePtr& reflectable)
515
    {
516
3
        checkCompoundConstMethods(reflectableObject, reflectable);
517
3
        checkCompoundConstMethods(reflectableObject, static_cast<IReflectableConstPtr>(reflectable));
518
519
        // setter
520

3
        reflectable->getField("reflectableNested")->setField("value", AnyHolder<>(static_cast<uint32_t>(11)));
521




3
        ASSERT_EQ(11, reflectableObject.getReflectableNested().getValue());
522










6
        ASSERT_THROW(reflectable->setField("nonexistent", AnyHolder<>()), CppRuntimeException);
523











6
        ASSERT_THROW(reflectable->find("reflectableNested")->setField("nonexistent", AnyHolder<>()),
524
                CppRuntimeException);
525
526
        // any value
527





3
        ASSERT_EQ(reflectableObject.getReflectableNested(), reflectable->find("reflectableNested")->
528
                getAnyValue().template get<std::reference_wrapper<ReflectableNested>>().get());
529
530
3
        reflectable->createField("reflectableNested");
531




3
        ASSERT_EQ(uint32_t(), reflectableObject.getReflectableNested().getValue());
532
533

3
        reflectable->setField("reflectableNested", AnyHolder<>(ReflectableNested{42}));
534




3
        ASSERT_EQ(42, reflectableObject.getReflectableNested().getValue());
535
3
        reflectable->initializeChildren(); // keep the reflectable initialized for following tests
536
    }
537
};
538
539


802
TEST_F(ReflectableTest, boolReflectable)
540
{
541
1
    const bool value = true;
542
2
    auto reflectable = ReflectableFactory::getBool(value);
543
3
    checkUnsignedIntegral(value, reflectable, &IReflectable::getBool,
544

3
            std::bind(&BitStreamReader::readBool, _1));
545
1
}
546
547


802
TEST_F(ReflectableTest, int8Reflectable)
548
{
549
1
    const int8_t value = -12;
550
2
    auto reflectable = ReflectableFactory::getInt8(value);
551
3
    checkSignedIntegral(value, reflectable, &IReflectable::getInt8,
552

3
            std::bind(&BitStreamReader::readSignedBits, _1, 8));
553
1
}
554
555


802
TEST_F(ReflectableTest, int16Reflectable)
556
{
557
1
    const int16_t value = -1234;
558
2
    auto reflectable = ReflectableFactory::getInt16(value);
559
3
    checkSignedIntegral(value, reflectable, &IReflectable::getInt16,
560

3
            std::bind(&BitStreamReader::readSignedBits, _1, 16));
561
1
}
562
563


802
TEST_F(ReflectableTest, int32Reflectable)
564
{
565
1
    const int32_t value = -123456;
566
2
    auto reflectable = ReflectableFactory::getInt32(value);
567
3
    checkSignedIntegral(value, reflectable, &IReflectable::getInt32,
568

3
            std::bind(&BitStreamReader::readSignedBits, _1, 32));
569
1
}
570
571


802
TEST_F(ReflectableTest, int64Reflectable)
572
{
573
1
    const int64_t value = -1234567890;
574
2
    auto reflectable = ReflectableFactory::getInt64(value);
575
3
    checkSignedIntegral(value, reflectable, &IReflectable::getInt64,
576

3
            std::bind(&BitStreamReader::readSignedBits64, _1, 64));
577
1
}
578
579


802
TEST_F(ReflectableTest, uint8Reflectable)
580
{
581
1
    const uint8_t value = 0xFF;
582
2
    auto reflectable = ReflectableFactory::getUInt8(value);
583
3
    checkUnsignedIntegral(value, reflectable, &IReflectable::getUInt8,
584

3
            std::bind(&BitStreamReader::readBits, _1, 8));
585
1
}
586
587


802
TEST_F(ReflectableTest, uint16Reflectable)
588
{
589
1
    const uint16_t value = 0xFFFF;
590
2
    auto reflectable = ReflectableFactory::getUInt16(value);
591
3
    checkUnsignedIntegral(value, reflectable, &IReflectable::getUInt16,
592

3
            std::bind(&BitStreamReader::readBits, _1, 16));
593
1
}
594
595


802
TEST_F(ReflectableTest, uint32Reflectable)
596
{
597
1
    const uint32_t value = 0xFFFFFFFF;
598
2
    auto reflectable = ReflectableFactory::getUInt32(value);
599
3
    checkUnsignedIntegral(value, reflectable, &IReflectable::getUInt32,
600

3
            std::bind(&BitStreamReader::readBits, _1, 32));
601
1
}
602
603


802
TEST_F(ReflectableTest, uint64Reflectable)
604
{
605
1
    const uint64_t value = 0xFFFFFFFFFFFF;
606
2
    auto reflectable = ReflectableFactory::getUInt64(value);
607
3
    checkUnsignedIntegral(value, reflectable, &IReflectable::getUInt64,
608

3
            std::bind(&BitStreamReader::readBits64, _1, 64));
609
1
}
610
611


802
TEST_F(ReflectableTest, fixedSignedBitField5) // mapped to int8_t
612
{
613
1
    const uint8_t numBits = 5;
614
1
    const int8_t value = 15;
615
2
    auto reflectable = ReflectableFactory::getFixedSignedBitField(value, numBits);
616
2
    checkSignedIntegral(value, reflectable, &IReflectable::getInt8,
617

3
            std::bind(&BitStreamReader::readSignedBits, _1, numBits), numBits);
618
619










2
    ASSERT_THROW(ReflectableFactory::getFixedSignedBitField(value, 10), CppRuntimeException);
620
}
621
622


802
TEST_F(ReflectableTest, fixedSignedBitField15) // mapped to int16_t
623
{
624
1
    const uint8_t numBits = 15;
625
1
    const int16_t value = -15;
626
2
    auto reflectable = ReflectableFactory::getFixedSignedBitField(value, numBits);
627
2
    checkSignedIntegral(value, reflectable, &IReflectable::getInt16,
628

3
            std::bind(&BitStreamReader::readSignedBits, _1, numBits), numBits);
629
630










2
    ASSERT_THROW(ReflectableFactory::getFixedSignedBitField(value, 5), CppRuntimeException);
631










2
    ASSERT_THROW(ReflectableFactory::getFixedSignedBitField(value, 17), CppRuntimeException);
632
}
633
634


802
TEST_F(ReflectableTest, fixedSignedBitField31) // mapped to int32_t
635
{
636
1
    const uint8_t numBits = 31;
637
1
    const int32_t value = -12345678;
638
2
    auto reflectable = ReflectableFactory::getFixedSignedBitField(value, numBits);
639
2
    checkSignedIntegral(value, reflectable, &IReflectable::getInt32,
640

3
            std::bind(&BitStreamReader::readSignedBits, _1, numBits), numBits);
641
642










2
    ASSERT_THROW(ReflectableFactory::getFixedSignedBitField(value, 16), CppRuntimeException);
643










2
    ASSERT_THROW(ReflectableFactory::getFixedSignedBitField(value, 33), CppRuntimeException);
644
}
645
646


802
TEST_F(ReflectableTest, fixedSignedBitField60) // mapped to int64_t
647
{
648
1
    const uint8_t numBits = 60;
649
1
    const int64_t value = 1234567890;
650
2
    auto reflectable = ReflectableFactory::getFixedSignedBitField(value, numBits);
651
2
    checkSignedIntegral(value, reflectable, &IReflectable::getInt64,
652

3
            std::bind(&BitStreamReader::readSignedBits64, _1, numBits), numBits);
653
654










2
    ASSERT_THROW(ReflectableFactory::getFixedSignedBitField(value, 31), CppRuntimeException);
655










2
    ASSERT_THROW(ReflectableFactory::getFixedSignedBitField(value, 65), CppRuntimeException);
656
}
657
658


802
TEST_F(ReflectableTest, fixedUnsignedBitField7) // mapped to uint8_t
659
{
660
1
    const uint8_t numBits = 7;
661
1
    const uint8_t value = 0x2F;
662
2
    auto reflectable = ReflectableFactory::getFixedUnsignedBitField(value, numBits);
663
2
    checkUnsignedIntegral(value, reflectable, &IReflectable::getUInt8,
664

3
            std::bind(&BitStreamReader::readBits, _1, numBits), numBits);
665
666










2
    ASSERT_THROW(ReflectableFactory::getFixedUnsignedBitField(value, 9), CppRuntimeException);
667
}
668
669


802
TEST_F(ReflectableTest, fixedUnsignedBitField9) // mapped to uint16_t
670
{
671
1
    const uint8_t numBits = 9;
672
1
    const uint16_t value = 0x1FF;
673
2
    auto reflectable = ReflectableFactory::getFixedUnsignedBitField(value, numBits);
674
2
    checkUnsignedIntegral(value, reflectable, &IReflectable::getUInt16,
675

3
            std::bind(&BitStreamReader::readBits, _1, numBits), numBits);
676
677










2
    ASSERT_THROW(ReflectableFactory::getFixedUnsignedBitField(value, 8), CppRuntimeException);
678










2
    ASSERT_THROW(ReflectableFactory::getFixedUnsignedBitField(value, 17), CppRuntimeException);
679
}
680
681


802
TEST_F(ReflectableTest, fixedUnsignedBitField31) // mapped to uint32_t
682
{
683
1
    const uint8_t numBits = 31;
684
1
    const uint32_t value = UINT32_MAX >> 1;
685
2
    auto reflectable = ReflectableFactory::getFixedUnsignedBitField(value, numBits);
686
2
    checkUnsignedIntegral(value, reflectable, &IReflectable::getUInt32,
687

3
            std::bind(&BitStreamReader::readBits, _1, numBits), numBits);
688
689










2
    ASSERT_THROW(ReflectableFactory::getFixedUnsignedBitField(value, 16), CppRuntimeException);
690










2
    ASSERT_THROW(ReflectableFactory::getFixedUnsignedBitField(value, 33), CppRuntimeException);
691
}
692
693


802
TEST_F(ReflectableTest, fixedUnsignedBitField33) // mapped to uint64_t
694
{
695
1
    const uint8_t numBits = 33;
696
1
    const uint64_t value = static_cast<uint64_t>(UINT32_MAX) << 1U;
697
2
    auto reflectable = ReflectableFactory::getFixedUnsignedBitField(value, numBits);
698
2
    checkUnsignedIntegral(value, reflectable, &IReflectable::getUInt64,
699

3
            std::bind(&BitStreamReader::readBits64, _1, numBits), numBits);
700
701










2
    ASSERT_THROW(ReflectableFactory::getFixedUnsignedBitField(value, 32), CppRuntimeException);
702










2
    ASSERT_THROW(ReflectableFactory::getFixedUnsignedBitField(value, 65), CppRuntimeException);
703
}
704
705


802
TEST_F(ReflectableTest, dynamicSignedBitField5) // mapped to int8_t
706
{
707
1
    const uint8_t maxBitSize = 8;
708
1
    const uint8_t numBits = 5;
709
1
    const int8_t value = 15;
710
2
    auto reflectable = ReflectableFactory::getDynamicSignedBitField(value, maxBitSize, numBits);
711
2
    checkSignedIntegral(value, reflectable, &IReflectable::getInt8,
712

3
            std::bind(&BitStreamReader::readSignedBits, _1, numBits), numBits);
713
714
    // maxBitSize out of bounds
715










2
    ASSERT_THROW(ReflectableFactory::getDynamicSignedBitField(value, 9, numBits), CppRuntimeException);
716
717
    // dynamicBitSize out of bounds
718










2
    ASSERT_THROW(ReflectableFactory::getDynamicSignedBitField(value, 4, numBits), CppRuntimeException);
719
}
720
721


802
TEST_F(ReflectableTest, dynamicSignedBitField15) // mapped to int16_t
722
{
723
1
    const uint8_t maxBitSize = 16;
724
1
    const uint8_t numBits = 15;
725
1
    const int16_t value = -15;
726
2
    auto reflectable = ReflectableFactory::getDynamicSignedBitField(value, maxBitSize, numBits);
727
2
    checkSignedIntegral(value, reflectable, &IReflectable::getInt16,
728

3
            std::bind(&BitStreamReader::readSignedBits, _1, numBits), numBits);
729
730
    // maxBitSize out of bounds
731










2
    ASSERT_THROW(ReflectableFactory::getDynamicSignedBitField(value, 8, numBits), CppRuntimeException);
732










2
    ASSERT_THROW(ReflectableFactory::getDynamicSignedBitField(value, 17, numBits), CppRuntimeException);
733
734
    // dynamicBitSize out of bounds
735










2
    ASSERT_THROW(ReflectableFactory::getDynamicSignedBitField(value, 12, numBits), CppRuntimeException);
736
}
737
738


802
TEST_F(ReflectableTest, dynamicSignedBitField31) // mapped to int32_t
739
{
740
1
    const uint8_t maxBitSize = 32;
741
1
    const uint8_t numBits = 31;
742
1
    const int32_t value = -12345678;
743
2
    auto reflectable = ReflectableFactory::getDynamicSignedBitField(value, maxBitSize, numBits);
744
2
    checkSignedIntegral(value, reflectable, &IReflectable::getInt32,
745

3
            std::bind(&BitStreamReader::readSignedBits, _1, numBits), numBits);
746
747
    // maxBitSize out of bounds
748










2
    ASSERT_THROW(ReflectableFactory::getDynamicSignedBitField(value, 16, numBits), CppRuntimeException);
749










2
    ASSERT_THROW(ReflectableFactory::getDynamicSignedBitField(value, 33, numBits), CppRuntimeException);
750
751
    // dynamicBitSize out of bounds
752










2
    ASSERT_THROW(ReflectableFactory::getDynamicSignedBitField(value, 29, numBits), CppRuntimeException);
753
}
754
755


802
TEST_F(ReflectableTest, dynamicSignedBitField60) // mapped to int64_t
756
{
757
1
    const uint8_t maxBitSize = 64;
758
1
    const uint8_t numBits = 60;
759
1
    const int64_t value = 1234567890;
760
2
    auto reflectable = ReflectableFactory::getDynamicSignedBitField(value, maxBitSize, numBits);
761
2
    checkSignedIntegral(value, reflectable, &IReflectable::getInt64,
762

3
            std::bind(&BitStreamReader::readSignedBits64, _1, numBits), numBits);
763
764
    // maxBitSize out of bounds
765










2
    ASSERT_THROW(ReflectableFactory::getDynamicSignedBitField(value, 32, numBits), CppRuntimeException);
766










2
    ASSERT_THROW(ReflectableFactory::getDynamicSignedBitField(value, 65, numBits), CppRuntimeException);
767
768
    // dynamicBitSize out of bounds
769










2
    ASSERT_THROW(ReflectableFactory::getDynamicSignedBitField(value, 58, numBits), CppRuntimeException);
770
771
    // dynamic signed bit field as a type reference (maxBitSize must be 64!)
772









1
    ASSERT_NO_THROW(ReflectableFactory::getDynamicSignedBitField(value, 64));
773










2
    ASSERT_THROW(ReflectableFactory::getDynamicSignedBitField(value, 58), CppRuntimeException);
774
}
775
776


802
TEST_F(ReflectableTest, dynamicUnsignedBitField7) // mapped to uint8_t
777
{
778
1
    const uint8_t maxBitSize = 8;
779
1
    const uint8_t numBits = 7;
780
1
    const uint8_t value = 0x2F;
781
2
    auto reflectable = ReflectableFactory::getDynamicUnsignedBitField(value, maxBitSize, numBits);
782
2
    checkUnsignedIntegral(value, reflectable, &IReflectable::getUInt8,
783

3
            std::bind(&BitStreamReader::readBits, _1, numBits), numBits);
784
785
    // maxBitSize out of bounds
786










2
    ASSERT_THROW(ReflectableFactory::getDynamicUnsignedBitField(value, 9, numBits), CppRuntimeException);
787
788
    // dynamicBitSize out of bounds
789










2
    ASSERT_THROW(ReflectableFactory::getDynamicUnsignedBitField(value, 6, numBits), CppRuntimeException);
790
}
791
792


802
TEST_F(ReflectableTest, dynamicUnsignedBitField9) // mapped to uint16_t
793
{
794
1
    const uint8_t maxBitSize = 16;
795
1
    const uint8_t numBits = 9;
796
1
    const uint16_t value = 0x1FF;
797
2
    auto reflectable = ReflectableFactory::getDynamicUnsignedBitField(value, maxBitSize, numBits);
798
2
    checkUnsignedIntegral(value, reflectable, &IReflectable::getUInt16,
799

3
            std::bind(&BitStreamReader::readBits, _1, numBits), numBits);
800
801
    // maxBitSize out of bounds
802










2
    ASSERT_THROW(ReflectableFactory::getDynamicUnsignedBitField(value, 8, numBits), CppRuntimeException);
803










2
    ASSERT_THROW(ReflectableFactory::getDynamicUnsignedBitField(value, 17, numBits), CppRuntimeException);
804
805
    // dynamicBitSize out of bounds
806










2
    ASSERT_THROW(ReflectableFactory::getDynamicUnsignedBitField(value, 9, 10), CppRuntimeException);
807
}
808
809


802
TEST_F(ReflectableTest, dynamicUnsignedBitField31) // mapped to uint32_t
810
{
811
1
    const uint8_t maxBitSize = 32;
812
1
    const uint8_t numBits = 31;
813
1
    const uint32_t value = UINT32_MAX >> 1;
814
2
    auto reflectable = ReflectableFactory::getDynamicUnsignedBitField(value, maxBitSize, numBits);
815
2
    checkUnsignedIntegral(value, reflectable, &IReflectable::getUInt32,
816

3
            std::bind(&BitStreamReader::readBits, _1, numBits), numBits);
817
818
    // maxBitSize out of bounds
819










2
    ASSERT_THROW(ReflectableFactory::getDynamicUnsignedBitField(value, 16, numBits), CppRuntimeException);
820










2
    ASSERT_THROW(ReflectableFactory::getDynamicUnsignedBitField(value, 33, numBits), CppRuntimeException);
821
822
    // dynamicBitSize out of bounds
823










2
    ASSERT_THROW(ReflectableFactory::getDynamicUnsignedBitField(value, 29, numBits), CppRuntimeException);
824
}
825
826


802
TEST_F(ReflectableTest, dynamicUnsignedBitField33) // mapped to uint64_t
827
{
828
1
    const uint8_t maxBitSize = 64;
829
1
    const uint8_t numBits = 33;
830
1
    const uint64_t value = static_cast<uint64_t>(UINT32_MAX) << 1U;
831
2
    auto reflectable = ReflectableFactory::getDynamicUnsignedBitField(value, maxBitSize, numBits);
832
2
    checkUnsignedIntegral(value, reflectable, &IReflectable::getUInt64,
833

3
            std::bind(&BitStreamReader::readBits64, _1, numBits), numBits);
834
835
    // maxBitSize out of bounds
836










2
    ASSERT_THROW(ReflectableFactory::getDynamicUnsignedBitField(value, 32, numBits), CppRuntimeException);
837










2
    ASSERT_THROW(ReflectableFactory::getDynamicUnsignedBitField(value, 65, numBits), CppRuntimeException);
838
839
    // dynamicBitSize out of bounds
840










2
    ASSERT_THROW(ReflectableFactory::getDynamicUnsignedBitField(value, 33, 34), CppRuntimeException);
841
842
    // dynamic unsigned bit field as a type reference (maxBitSize must be 64!)
843









1
    ASSERT_NO_THROW(ReflectableFactory::getDynamicUnsignedBitField(value, 64));
844










2
    ASSERT_THROW(ReflectableFactory::getDynamicUnsignedBitField(value, 58), CppRuntimeException);
845
}
846
847


802
TEST_F(ReflectableTest, varint16Reflectable)
848
{
849
1
    const int16_t value = -1234;
850
2
    auto reflectable = ReflectableFactory::getVarInt16(value);
851
3
    checkSignedIntegral(value, reflectable, &IReflectable::getInt16,
852

3
            std::bind(&BitStreamReader::readVarInt16, _1), bitSizeOfVarInt16(value));
853
1
}
854
855


802
TEST_F(ReflectableTest, varint32Reflectable)
856
{
857
1
    const int32_t value = 54321;
858
2
    auto reflectable = ReflectableFactory::getVarInt32(value);
859
3
    checkSignedIntegral(value, reflectable, &IReflectable::getInt32,
860

3
            std::bind(&BitStreamReader::readVarInt32, _1), bitSizeOfVarInt32(value));
861
1
}
862
863


802
TEST_F(ReflectableTest, varint64Reflectable)
864
{
865
1
    const int64_t value = -87654321;
866
2
    auto reflectable = ReflectableFactory::getVarInt64(value);
867
3
    checkSignedIntegral(value, reflectable, &IReflectable::getInt64,
868

3
            std::bind(&BitStreamReader::readVarInt64, _1), bitSizeOfVarInt64(value));
869
1
}
870
871


802
TEST_F(ReflectableTest, varintReflectable)
872
{
873
1
    const int64_t value = INT64_MAX;
874
2
    auto reflectable = ReflectableFactory::getVarInt(value);
875
3
    checkSignedIntegral(value, reflectable, &IReflectable::getInt64,
876

3
            std::bind(&BitStreamReader::readVarInt, _1), bitSizeOfVarInt(value));
877
1
}
878
879


802
TEST_F(ReflectableTest, varuint16Reflectable)
880
{
881
1
    const uint16_t value = 1234;
882
2
    auto reflectable = ReflectableFactory::getVarUInt16(value);
883
3
    checkUnsignedIntegral(value, reflectable, &IReflectable::getUInt16,
884

3
            std::bind(&BitStreamReader::readVarUInt16, _1), bitSizeOfVarUInt16(value));
885
1
}
886
887


802
TEST_F(ReflectableTest, varuint32Reflectable)
888
{
889
1
    const uint32_t value = 0x1FFFFFFF;
890
2
    auto reflectable = ReflectableFactory::getVarUInt32(value);
891
3
    checkUnsignedIntegral(value, reflectable, &IReflectable::getUInt32,
892

3
            std::bind(&BitStreamReader::readVarUInt32, _1), bitSizeOfVarUInt32(value));
893
1
}
894
895


802
TEST_F(ReflectableTest, varuint64Reflectable)
896
{
897
1
    const uint64_t value = 4242424242;
898
2
    auto reflectable = ReflectableFactory::getVarUInt64(value);
899
3
    checkUnsignedIntegral(value, reflectable, &IReflectable::getUInt64,
900

3
            std::bind(&BitStreamReader::readVarUInt64, _1), bitSizeOfVarUInt64(value));
901
1
}
902
903


802
TEST_F(ReflectableTest, varuintReflectable)
904
{
905
1
    const uint64_t value = UINT64_MAX;
906
2
    auto reflectable = ReflectableFactory::getVarUInt(value);
907
3
    checkUnsignedIntegral(value, reflectable, &IReflectable::getUInt64,
908

3
            std::bind(&BitStreamReader::readVarUInt, _1), bitSizeOfVarUInt(value));
909
1
}
910
911


802
TEST_F(ReflectableTest, varsizeReflectable)
912
{
913
1
    const uint32_t value = (UINT32_C(1) << (7+7+7+7+3)) - 1;
914
2
    auto reflectable = ReflectableFactory::getVarSize(value);
915
3
    checkUnsignedIntegral(value, reflectable, &IReflectable::getUInt32,
916

3
            std::bind(&BitStreamReader::readVarSize, _1), bitSizeOfVarSize(value));
917
1
}
918
919


802
TEST_F(ReflectableTest, float16Reflectable)
920
{
921
1
    const float value = 2.0F;
922
2
    auto reflectable = ReflectableFactory::getFloat16(value);
923
3
    checkFloatingPoint(value, reflectable, &IReflectable::getFloat,
924

3
            std::bind(&BitStreamReader::readFloat16, _1));
925
1
}
926
927


802
TEST_F(ReflectableTest, float32Reflectable)
928
{
929
1
    const float value = 1.2F;
930
2
    auto reflectable = ReflectableFactory::getFloat32(value);
931
3
    checkFloatingPoint(value, reflectable, &IReflectable::getFloat,
932

3
            std::bind(&BitStreamReader::readFloat32, _1));
933
1
}
934
935


802
TEST_F(ReflectableTest, float64Reflectable)
936
{
937
1
    const double value = 1.2;
938
2
    auto reflectable = ReflectableFactory::getFloat64(value);
939
3
    checkFloatingPoint(value, reflectable, &IReflectable::getDouble,
940

3
            std::bind(&BitStreamReader::readFloat64, _1));
941
1
}
942
943


802
TEST_F(ReflectableTest, stringReflectable)
944
{
945
2
    const std::string value = "some longer string value to have a chance that some allocation hopefully occurs";
946
2
    auto reflectable = ReflectableFactory::getString(value);
947
1
    checkString(value, reflectable);
948
1
}
949
950


802
TEST_F(ReflectableTest, stringViewReflectable)
951
{
952
1
    auto view = makeStringView("some text as a string view");
953
2
    auto reflectable = ReflectableFactory::getString(view);
954
1
    checkString(view, reflectable);
955
1
}
956
957


802
TEST_F(ReflectableTest, bitBufferReflectable)
958
{
959

2
    const BitBuffer value = BitBuffer{std::vector<uint8_t>({0xAB, 0xF0}), 12};
960
2
    auto reflectable = ReflectableFactory::getBitBuffer(value);
961
1
    checkBitBuffer(value, reflectable);
962
1
}
963
964


802
TEST_F(ReflectableTest, bytesReflectable)
965
{
966
2
    const vector<uint8_t> value{{0, 127, 128, 255}};
967

2
    auto reflectable = ReflectableFactory::getBytes(value);
968
1
    checkBytes(value, reflectable);
969
1
}
970
971


802
TEST_F(ReflectableTest, boolConstArray)
972
{
973
2
    const auto rawArray = std::vector<bool>({true, false, true, false});
974
2
    auto reflectable = ReflectableFactory::getBoolArray(rawArray);
975
2
    checkArray(rawArray, reflectable,
976
4
            [&](bool value, const IReflectableConstPtr& elementReflectable) {
977
16
                checkUnsignedIntegral(value, elementReflectable, &IReflectable::getBool,
978

16
                        std::bind(&BitStreamReader::readBool, _1));
979
4
            }
980
1
    );
981
1
}
982
983


802
TEST_F(ReflectableTest, boolArray)
984
{
985
2
    auto rawArray = std::vector<bool>({true, false, true, false});
986
2
    auto reflectable = ReflectableFactory::getBoolArray(rawArray);
987
2
    checkArray(rawArray, reflectable,
988
4
            [&](bool value, const IReflectableConstPtr& elementReflectable) {
989
16
                checkUnsignedIntegral(value, elementReflectable, &IReflectable::getBool,
990

16
                        std::bind(&BitStreamReader::readBool, _1));
991
4
            }
992
1
    );
993
1
}
994
995


802
TEST_F(ReflectableTest, int8ConstArray)
996
{
997
2
    const auto rawArray = std::vector<int8_t>({-10, -20, 30, 40});
998

2
    auto reflectable = ReflectableFactory::getInt8Array(rawArray);
999
2
    checkArray(rawArray, reflectable,
1000
4
            [&](int8_t value, const IReflectableConstPtr& elementReflectable) {
1001
16
                checkSignedIntegral(value, elementReflectable, &IReflectable::getInt8,
1002

16
                        std::bind(&BitStreamReader::readSignedBits, _1, 8));
1003
4
            }
1004
1
    );
1005
1006
2
    auto nonConstReflectable = std::const_pointer_cast<IReflectable>(reflectable);
1007










2
    ASSERT_THROW(nonConstReflectable->getAnyValue(), CppRuntimeException);
1008
}
1009
1010


802
TEST_F(ReflectableTest, int8Array)
1011
{
1012
2
    auto rawArray = std::vector<int8_t>({-10, -20, 30, 40});
1013

2
    auto reflectable = ReflectableFactory::getInt8Array(rawArray);
1014
2
    checkArray(rawArray, reflectable,
1015
4
            [&](int8_t value, const IReflectableConstPtr& elementReflectable) {
1016
16
                checkSignedIntegral(value, elementReflectable, &IReflectable::getInt8,
1017

16
                        std::bind(&BitStreamReader::readSignedBits, _1, 8));
1018
4
            }
1019
1
    );
1020
2
    checkArray(rawArray, static_cast<IReflectableConstPtr>(reflectable),
1021
4
            [&](int8_t value, const IReflectableConstPtr& elementReflectable) {
1022
16
                checkSignedIntegral(value, elementReflectable, &IReflectable::getInt8,
1023

16
                        std::bind(&BitStreamReader::readSignedBits, _1, 8));
1024
4
            }
1025
1
    );
1026
1027
1
    reflectable->resize(0);
1028



1
    ASSERT_EQ(0, reflectable->size());
1029

1
    reflectable->append(AnyHolder<>(static_cast<int8_t>(13)));
1030



1
    ASSERT_EQ(1, reflectable->size());
1031




1
    ASSERT_EQ(13, reflectable->at(0)->getInt8());
1032

1
    reflectable->setAt(AnyHolder<>(static_cast<int8_t>(42)), 0);
1033



1
    ASSERT_EQ(1, reflectable->size());
1034




1
    ASSERT_EQ(42, reflectable->at(0)->getInt8());
1035
1
    reflectable->resize(2);
1036



1
    ASSERT_EQ(2, reflectable->size());
1037
1038
    // out of range
1039











2
    ASSERT_THROW(reflectable->setAt(AnyHolder<>(static_cast<int8_t>(-42)), 2), CppRuntimeException);
1040
}
1041
1042


802
TEST_F(ReflectableTest, int16ConstArray)
1043
{
1044
2
    const auto rawArray = std::vector<int16_t>({-100, -200, 300, 400});
1045
2
    auto reflectable = ReflectableFactory::getInt16Array(rawArray);
1046
2
    checkArray(rawArray, reflectable,
1047
4
            [&](int16_t value, const IReflectableConstPtr& elementReflectable) {
1048
16
                checkSignedIntegral(value, elementReflectable, &IReflectable::getInt16,
1049

16
                        std::bind(&BitStreamReader::readSignedBits, _1, 16));
1050
4
            }
1051
1
    );
1052
1
}
1053
1054


802
TEST_F(ReflectableTest, int16Array)
1055
{
1056
2
    auto rawArray = std::vector<int16_t>({-100, -200, 300, 400});
1057
2
    auto reflectable = ReflectableFactory::getInt16Array(rawArray);
1058
2
    checkArray(rawArray, reflectable,
1059
4
            [&](int16_t value, const IReflectableConstPtr& elementReflectable) {
1060
16
                checkSignedIntegral(value, elementReflectable, &IReflectable::getInt16,
1061

16
                        std::bind(&BitStreamReader::readSignedBits, _1, 16));
1062
4
            }
1063
1
    );
1064
1
}
1065
1066


802
TEST_F(ReflectableTest, int32ConstArray)
1067
{
1068
2
    const auto rawArray = std::vector<int32_t>({-10000, -20000, 30000, 40000});
1069
2
    auto reflectable = ReflectableFactory::getInt32Array(rawArray);
1070
2
    checkArray(rawArray, reflectable,
1071
4
            [&](int32_t value, const IReflectableConstPtr& elementReflectable) {
1072
16
                checkSignedIntegral(value, elementReflectable, &IReflectable::getInt32,
1073

16
                        std::bind(&BitStreamReader::readSignedBits, _1, 32));
1074
4
            }
1075
1
    );
1076
1
}
1077
1078


802
TEST_F(ReflectableTest, int32Array)
1079
{
1080
2
    auto rawArray = std::vector<int32_t>({-10000, -20000, 30000, 40000});
1081
2
    auto reflectable = ReflectableFactory::getInt32Array(rawArray);
1082
2
    checkArray(rawArray, reflectable,
1083
4
            [&](int32_t value, const IReflectableConstPtr& elementReflectable) {
1084
16
                checkSignedIntegral(value, elementReflectable, &IReflectable::getInt32,
1085

16
                        std::bind(&BitStreamReader::readSignedBits, _1, 32));
1086
4
            }
1087
1
    );
1088
1
}
1089
1090


802
TEST_F(ReflectableTest, int64ConstArray)
1091
{
1092
2
    const auto rawArray = std::vector<int64_t>({-10000000, -20000000, 30000000, 40000000});
1093
2
    auto reflectable = ReflectableFactory::getInt64Array(rawArray);
1094
2
    checkArray(rawArray, reflectable,
1095
4
            [&](int64_t value, const IReflectableConstPtr& elementReflectable) {
1096
16
                checkSignedIntegral(value, elementReflectable, &IReflectable::getInt64,
1097

16
                        std::bind(&BitStreamReader::readSignedBits64, _1, 64));
1098
4
            }
1099
1
    );
1100
1
}
1101
1102


802
TEST_F(ReflectableTest, int64Array)
1103
{
1104
2
    auto rawArray = std::vector<int64_t>({-10000000, -20000000, 30000000, 40000000});
1105
2
    auto reflectable = ReflectableFactory::getInt64Array(rawArray);
1106
2
    checkArray(rawArray, reflectable,
1107
4
            [&](int64_t value, const IReflectableConstPtr& elementReflectable) {
1108
16
                checkSignedIntegral(value, elementReflectable, &IReflectable::getInt64,
1109

16
                        std::bind(&BitStreamReader::readSignedBits64, _1, 64));
1110
4
            }
1111
1
    );
1112
1
}
1113
1114


802
TEST_F(ReflectableTest, uint8ConstArray)
1115
{
1116
2
    const auto rawArray = std::vector<uint8_t>({10, 20, 30, 40});
1117
2
    auto reflectable = ReflectableFactory::getUInt8Array(rawArray);
1118
2
    checkArray(rawArray, reflectable,
1119
4
            [&](uint8_t value, const IReflectableConstPtr& elementReflectable) {
1120
16
                checkUnsignedIntegral(value, elementReflectable, &IReflectable::getUInt8,
1121

16
                        std::bind(&BitStreamReader::readBits, _1, 8));
1122
4
            }
1123
1
    );
1124
1
}
1125
1126


802
TEST_F(ReflectableTest, uint8Array)
1127
{
1128
2
    auto rawArray = std::vector<uint8_t>{{10, 20, 30, 40}};
1129
2
    auto reflectable = ReflectableFactory::getUInt8Array(rawArray);
1130
2
    checkArray(rawArray, reflectable,
1131
4
            [&](uint8_t value, const IReflectablePtr& elementReflectable) {
1132
16
                checkUnsignedIntegral(value, elementReflectable, &IReflectable::getUInt8,
1133

16
                        std::bind(&BitStreamReader::readBits, _1, 8));
1134
4
            }
1135
1
    );
1136
1
}
1137
1138


802
TEST_F(ReflectableTest, uint16ConstArray)
1139
{
1140
2
    const auto rawArray = std::vector<uint16_t>({100, 200, 300, 400});
1141
2
    auto reflectable = ReflectableFactory::getUInt16Array(rawArray);
1142
2
    checkArray(rawArray, reflectable,
1143
4
            [&](uint16_t value, const IReflectableConstPtr& elementReflectable) {
1144
16
                checkUnsignedIntegral(value, elementReflectable, &IReflectable::getUInt16,
1145

16
                        std::bind(&BitStreamReader::readBits, _1, 16));
1146
4
            }
1147
1
    );
1148
1
}
1149
1150


802
TEST_F(ReflectableTest, uint16Array)
1151
{
1152
2
    auto rawArray = std::vector<uint16_t>{{100, 200, 300, 400}};
1153
2
    auto reflectable = ReflectableFactory::getUInt16Array(rawArray);
1154
2
    checkArray(rawArray, reflectable,
1155
4
            [&](uint16_t value, const IReflectablePtr& elementReflectable) {
1156
16
                checkUnsignedIntegral(value, elementReflectable, &IReflectable::getUInt16,
1157

16
                        std::bind(&BitStreamReader::readBits, _1, 16));
1158
4
            }
1159
1
    );
1160
1
}
1161
1162


802
TEST_F(ReflectableTest, uint32ConstArray)
1163
{
1164
2
    const auto rawArray = std::vector<uint32_t>({10000, 20000, 30000, 40000});
1165
2
    auto reflectable = ReflectableFactory::getUInt32Array(rawArray);
1166
2
    checkArray(rawArray, reflectable,
1167
4
            [&](uint32_t value, const IReflectableConstPtr& elementReflectable) {
1168
16
                checkUnsignedIntegral(value, elementReflectable, &IReflectable::getUInt32,
1169

16
                        std::bind(&BitStreamReader::readBits, _1, 32));
1170
4
            }
1171
1
    );
1172
1
}
1173
1174
1175
1176


802
TEST_F(ReflectableTest, uint32Array)
1177
{
1178
2
    auto rawArray = std::vector<uint32_t>{{10000, 20000, 30000, 40000}};
1179
2
    auto reflectable = ReflectableFactory::getUInt32Array(rawArray);
1180
2
    checkArray(rawArray, reflectable,
1181
4
            [&](uint32_t value, const IReflectablePtr& elementReflectable) {
1182
16
                checkUnsignedIntegral(value, elementReflectable, &IReflectable::getUInt32,
1183

16
                        std::bind(&BitStreamReader::readBits, _1, 32));
1184
4
            }
1185
1
    );
1186
1
}
1187
1188


802
TEST_F(ReflectableTest, uint64ConstArray)
1189
{
1190
2
    const auto rawArray = std::vector<uint64_t>({10000000, 20000000, 30000000, 40000000});
1191
2
    auto reflectable = ReflectableFactory::getUInt64Array(rawArray);
1192
2
    checkArray(rawArray, reflectable,
1193
4
            [&](uint64_t value, const IReflectableConstPtr& elementReflectable) {
1194
16
                checkUnsignedIntegral(value, elementReflectable, &IReflectable::getUInt64,
1195

16
                        std::bind(&BitStreamReader::readBits64, _1, 64));
1196
4
            }
1197
1
    );
1198
1
}
1199
1200


802
TEST_F(ReflectableTest, uint64Array)
1201
{
1202
2
    auto rawArray = std::vector<uint64_t>{{10000000, 20000000, 30000000, 40000000}};
1203
2
    auto reflectable = ReflectableFactory::getUInt64Array(rawArray);
1204
2
    checkArray(rawArray, reflectable,
1205
4
            [&](uint64_t value, const IReflectablePtr& elementReflectable) {
1206
16
                checkUnsignedIntegral(value, elementReflectable, &IReflectable::getUInt64,
1207

16
                        std::bind(&BitStreamReader::readBits64, _1, 64));
1208
4
            }
1209
1
    );
1210
1
}
1211
1212


802
TEST_F(ReflectableTest, fixedSignedBitField5ConstArray)
1213
{
1214
1
    const uint8_t numBits = 5;
1215
2
    const auto rawArray = std::vector<int8_t>{{-3, -1, 2, 4, 6}};
1216
2
    auto reflectable = ReflectableFactory::getFixedSignedBitFieldArray(rawArray, numBits);
1217
2
    checkArray(rawArray, reflectable,
1218
5
            [&](int8_t value, const IReflectableConstPtr& elementReflectable) {
1219
15
                checkSignedIntegral(value, elementReflectable, &IReflectable::getInt8,
1220

20
                        std::bind(&BitStreamReader::readSignedBits, _1, numBits), numBits);
1221
5
            }
1222
1
    );
1223
1
}
1224
1225


802
TEST_F(ReflectableTest, fixedSignedBitField5Array)
1226
{
1227
1
    const uint8_t numBits = 5;
1228
2
    auto rawArray = std::vector<int8_t>{{-3, -1, 2, 4, 6}};
1229

2
    auto reflectable = ReflectableFactory::getFixedSignedBitFieldArray(rawArray, numBits);
1230
2
    checkArray(rawArray, reflectable,
1231
5
            [&](int8_t value, const IReflectableConstPtr& elementReflectable) {
1232
15
                checkSignedIntegral(value, elementReflectable, &IReflectable::getInt8,
1233

20
                        std::bind(&BitStreamReader::readSignedBits, _1, numBits), numBits);
1234
5
            }
1235
1
    );
1236
2
    checkArray(rawArray, static_cast<IReflectableConstPtr>(reflectable),
1237
5
            [&](int8_t value, const IReflectableConstPtr& elementReflectable) {
1238
15
                checkSignedIntegral(value, elementReflectable, &IReflectable::getInt8,
1239

20
                        std::bind(&BitStreamReader::readSignedBits, _1, numBits), numBits);
1240
5
            }
1241
1
    );
1242
1243
1
    reflectable->resize(0);
1244



1
    ASSERT_EQ(0, reflectable->size());
1245

1
    reflectable->append(AnyHolder<>(static_cast<int8_t>(13)));
1246



1
    ASSERT_EQ(1, reflectable->size());
1247




1
    ASSERT_EQ(13, reflectable->at(0)->getInt8());
1248

1
    reflectable->setAt(AnyHolder<>(static_cast<int8_t>(42)), 0);
1249



1
    ASSERT_EQ(1, reflectable->size());
1250




1
    ASSERT_EQ(42, reflectable->at(0)->getInt8());
1251
1
    reflectable->resize(2);
1252



1
    ASSERT_EQ(2, reflectable->size());
1253
1254
    // out of range
1255











2
    ASSERT_THROW(reflectable->setAt(AnyHolder<>(static_cast<int8_t>(42)), 2), CppRuntimeException);
1256
}
1257
1258


802
TEST_F(ReflectableTest, fixedUnsignedBitField5ConstArray)
1259
{
1260
1
    const uint8_t numBits = 5;
1261
2
    const auto rawArray = std::vector<uint8_t>{{3, 1, 2, 4, 6}};
1262
2
    auto reflectable = ReflectableFactory::getFixedUnsignedBitFieldArray(rawArray, numBits);
1263
2
    checkArray(rawArray, reflectable,
1264
5
            [&](uint8_t value, const IReflectableConstPtr& elementReflectable) {
1265
15
                checkUnsignedIntegral(value, elementReflectable, &IReflectable::getUInt8,
1266

20
                        std::bind(&BitStreamReader::readBits, _1, numBits), numBits);
1267
5
            }
1268
1
    );
1269
1
}
1270
1271


802
TEST_F(ReflectableTest, fixedUnsignedBitField5Array)
1272
{
1273
1
    const uint8_t numBits = 5;
1274
2
    auto rawArray = std::vector<uint8_t>{{3, 1, 2, 4, 6}};
1275
2
    auto reflectable = ReflectableFactory::getFixedUnsignedBitFieldArray(rawArray, numBits);
1276
2
    checkArray(rawArray, reflectable,
1277
5
            [&](uint8_t value, const IReflectableConstPtr& elementReflectable) {
1278
15
                checkUnsignedIntegral(value, elementReflectable, &IReflectable::getUInt8,
1279

20
                        std::bind(&BitStreamReader::readBits, _1, numBits), numBits);
1280
5
            }
1281
1
    );
1282
1
}
1283
1284


802
TEST_F(ReflectableTest, dynamicSignedBitField5ConstArray)
1285
{
1286
1
    const uint8_t maxBitSize = 8;
1287
1
    const uint8_t numBits = 5;
1288
2
    const auto rawArray = std::vector<int8_t>{{-3, -1, 2, 4, 6}};
1289

2
    auto reflectable = ReflectableFactory::getDynamicSignedBitFieldArray(rawArray, maxBitSize, numBits);
1290
2
    checkArray(rawArray, reflectable,
1291
5
            [&](int8_t value, const IReflectableConstPtr& elementReflectable) {
1292
15
                checkSignedIntegral(value, elementReflectable, &IReflectable::getInt8,
1293

20
                        std::bind(&BitStreamReader::readSignedBits, _1, numBits), numBits);
1294
5
            }
1295
1
    );
1296
1297
2
    auto nonConstReflectable = std::const_pointer_cast<IReflectable>(reflectable);
1298










2
    ASSERT_THROW(nonConstReflectable->getAnyValue(), CppRuntimeException);
1299
}
1300
1301


802
TEST_F(ReflectableTest, dynamicSignedBitField5Array)
1302
{
1303
1
    const uint8_t maxBitSize = 8;
1304
1
    const uint8_t numBits = 5;
1305
2
    auto rawArray = std::vector<int8_t>{{-3, -1, 2, 4, 6}};
1306

2
    auto reflectable = ReflectableFactory::getDynamicSignedBitFieldArray(rawArray, maxBitSize, numBits);
1307
2
    checkArray(rawArray, reflectable,
1308
5
            [&](int8_t value, const IReflectablePtr& elementReflectable) {
1309
15
                checkSignedIntegral(value, elementReflectable, &IReflectable::getInt8,
1310

20
                        std::bind(&BitStreamReader::readSignedBits, _1, numBits), numBits);
1311
5
            }
1312
1
    );
1313
2
    checkArray(rawArray, static_cast<IReflectableConstPtr>(reflectable),
1314
5
            [&](int8_t value, const IReflectableConstPtr& elementReflectable) {
1315
15
                checkSignedIntegral(value, elementReflectable, &IReflectable::getInt8,
1316

20
                        std::bind(&BitStreamReader::readSignedBits, _1, numBits), numBits);
1317
5
            }
1318
1
    );
1319
1320
1
    reflectable->resize(0);
1321



1
    ASSERT_EQ(0, reflectable->size());
1322

1
    reflectable->append(AnyHolder<>(static_cast<int8_t>(13)));
1323



1
    ASSERT_EQ(1, reflectable->size());
1324




1
    ASSERT_EQ(13, reflectable->at(0)->getInt8());
1325

1
    reflectable->setAt(AnyHolder<>(static_cast<int8_t>(42)), 0);
1326



1
    ASSERT_EQ(1, reflectable->size());
1327




1
    ASSERT_EQ(42, reflectable->at(0)->getInt8());
1328
1
    reflectable->resize(2);
1329



1
    ASSERT_EQ(2, reflectable->size());
1330
1331
    // out of range
1332











2
    ASSERT_THROW(reflectable->setAt(AnyHolder<>(static_cast<int8_t>(42)), 2), CppRuntimeException);
1333
}
1334
1335


802
TEST_F(ReflectableTest, dynamicUnsignedBitField5ConstArray)
1336
{
1337
1
    const uint8_t maxBitSize = 8;
1338
1
    const uint8_t numBits = 5;
1339
2
    const auto rawArray = std::vector<uint8_t>{{3, 1, 2, 4, 6}};
1340
2
    auto reflectable = ReflectableFactory::getDynamicUnsignedBitFieldArray(rawArray, maxBitSize, numBits);
1341
2
    checkArray(rawArray, reflectable,
1342
5
            [&](uint8_t value, const IReflectableConstPtr& elementReflectable) {
1343
15
                checkUnsignedIntegral(value, elementReflectable, &IReflectable::getUInt8,
1344

20
                        std::bind(&BitStreamReader::readBits, _1, numBits), numBits);
1345
5
            }
1346
1
    );
1347
1
}
1348
1349


802
TEST_F(ReflectableTest, dynamicUnsignedBitField5Array)
1350
{
1351
1
    const uint8_t maxBitSize = 8;
1352
1
    const uint8_t numBits = 5;
1353
2
    auto rawArray = std::vector<uint8_t>{{3, 1, 2, 4, 6}};
1354
2
    auto reflectable = ReflectableFactory::getDynamicUnsignedBitFieldArray(rawArray, maxBitSize, numBits);
1355
2
    checkArray(rawArray, reflectable,
1356
5
            [&](uint8_t value, const IReflectableConstPtr& elementReflectable) {
1357
15
                checkUnsignedIntegral(value, elementReflectable, &IReflectable::getUInt8,
1358

20
                        std::bind(&BitStreamReader::readBits, _1, numBits), numBits);
1359
5
            }
1360
1
    );
1361
1
}
1362
1363


802
TEST_F(ReflectableTest, varint16ConstArray)
1364
{
1365
2
    const auto rawArray = std::vector<int16_t>({-10, -20, 30, 40});
1366
2
    auto reflectable = ReflectableFactory::getVarInt16Array(rawArray);
1367
2
    checkArray(rawArray, reflectable,
1368
4
            [&](int16_t value, const IReflectableConstPtr& elementReflectable) {
1369
16
                checkSignedIntegral(value, elementReflectable, &IReflectable::getInt16,
1370

16
                        std::bind(&BitStreamReader::readVarInt16, _1));
1371
4
            }
1372
1
    );
1373
1
}
1374
1375


802
TEST_F(ReflectableTest, varint16Array)
1376
{
1377
2
    auto rawArray = std::vector<int16_t>{{-10, -20, 30, 40}};
1378
2
    auto reflectable = ReflectableFactory::getVarInt16Array(rawArray);
1379
2
    checkArray(rawArray, reflectable,
1380
4
            [&](int16_t value, const IReflectablePtr& elementReflectable) {
1381
16
                checkSignedIntegral(value, elementReflectable, &IReflectable::getInt16,
1382

16
                        std::bind(&BitStreamReader::readVarInt16, _1));
1383
4
            }
1384
1
    );
1385
1
}
1386
1387


802
TEST_F(ReflectableTest, varint32ConstArray)
1388
{
1389
2
    const auto rawArray = std::vector<int32_t>({-10000, -20000, 30000, 40000});
1390
2
    auto reflectable = ReflectableFactory::getVarInt32Array(rawArray);
1391
2
    checkArray(rawArray, reflectable,
1392
4
            [&](int32_t value, const IReflectableConstPtr& elementReflectable) {
1393
16
                checkSignedIntegral(value, elementReflectable, &IReflectable::getInt32,
1394

16
                        std::bind(&BitStreamReader::readVarInt32, _1));
1395
4
            }
1396
1
    );
1397
1
}
1398
1399


802
TEST_F(ReflectableTest, varint32Array)
1400
{
1401
2
    auto rawArray = std::vector<int32_t>{{-10000, -20000, 30000, 40000}};
1402
2
    auto reflectable = ReflectableFactory::getVarInt32Array(rawArray);
1403
2
    checkArray(rawArray, reflectable,
1404
4
            [&](int32_t value, const IReflectablePtr& elementReflectable) {
1405
16
                checkSignedIntegral(value, elementReflectable, &IReflectable::getInt32,
1406

16
                        std::bind(&BitStreamReader::readVarInt32, _1));
1407
4
            }
1408
1
    );
1409
1
}
1410
1411


802
TEST_F(ReflectableTest, varint64ConstArray)
1412
{
1413
2
    const auto rawArray = std::vector<int64_t>({-10000000, -20000000, 30000000, 40000000});
1414
2
    auto reflectable = ReflectableFactory::getVarInt64Array(rawArray);
1415
2
    checkArray(rawArray, reflectable,
1416
4
            [&](int64_t value, const IReflectableConstPtr& elementReflectable) {
1417
16
                checkSignedIntegral(value, elementReflectable, &IReflectable::getInt64,
1418

16
                        std::bind(&BitStreamReader::readVarInt64, _1));
1419
4
            }
1420
1
    );
1421
1
}
1422
1423


802
TEST_F(ReflectableTest, varint64Array)
1424
{
1425
2
    auto rawArray = std::vector<int64_t>{{-10000000, -20000000, 30000000, 40000000}};
1426
2
    auto reflectable = ReflectableFactory::getVarInt64Array(rawArray);
1427
2
    checkArray(rawArray, reflectable,
1428
4
            [&](int64_t value, const IReflectablePtr& elementReflectable) {
1429
16
                checkSignedIntegral(value, elementReflectable, &IReflectable::getInt64,
1430

16
                        std::bind(&BitStreamReader::readVarInt64, _1));
1431
4
            }
1432
1
    );
1433
1
}
1434
1435


802
TEST_F(ReflectableTest, varintConstArray)
1436
{
1437
2
    const auto rawArray = std::vector<int64_t>({-10000000, -20000000, 30000000, 40000000});
1438
2
    auto reflectable = ReflectableFactory::getVarIntArray(rawArray);
1439
2
    checkArray(rawArray, reflectable,
1440
4
            [&](int64_t value, const IReflectableConstPtr& elementReflectable) {
1441
16
                checkSignedIntegral(value, elementReflectable, &IReflectable::getInt64,
1442

16
                        std::bind(&BitStreamReader::readVarInt, _1));
1443
4
            }
1444
1
    );
1445
1
}
1446
1447


802
TEST_F(ReflectableTest, varintArray)
1448
{
1449
2
    auto rawArray = std::vector<int64_t>{{-10000000, -20000000, 30000000, 40000000}};
1450
2
    auto reflectable = ReflectableFactory::getVarIntArray(rawArray);
1451
2
    checkArray(rawArray, reflectable,
1452
4
            [&](int64_t value, const IReflectablePtr& elementReflectable) {
1453
16
                checkSignedIntegral(value, elementReflectable, &IReflectable::getInt64,
1454

16
                        std::bind(&BitStreamReader::readVarInt, _1));
1455
4
            }
1456
1
    );
1457
1
}
1458
1459


802
TEST_F(ReflectableTest, varuint16ConstArray)
1460
{
1461
2
    const auto rawArray = std::vector<uint16_t>({10, 20, 30, 40});
1462
2
    auto reflectable = ReflectableFactory::getVarUInt16Array(rawArray);
1463
2
    checkArray(rawArray, reflectable,
1464
4
            [&](uint16_t value, const IReflectableConstPtr& elementReflectable) {
1465
16
                checkUnsignedIntegral(value, elementReflectable, &IReflectable::getUInt16,
1466

16
                        std::bind(&BitStreamReader::readVarUInt16, _1));
1467
4
            }
1468
1
    );
1469
1
}
1470
1471


802
TEST_F(ReflectableTest, varuint16Array)
1472
{
1473
2
    auto rawArray = std::vector<uint16_t>{{10, 20, 30, 40}};
1474
2
    auto reflectable = ReflectableFactory::getVarUInt16Array(rawArray);
1475
2
    checkArray(rawArray, reflectable,
1476
4
            [&](uint16_t value, const IReflectablePtr& elementReflectable) {
1477
16
                checkUnsignedIntegral(value, elementReflectable, &IReflectable::getUInt16,
1478

16
                        std::bind(&BitStreamReader::readVarUInt16, _1));
1479
4
            }
1480
1
    );
1481
1
}
1482
1483


802
TEST_F(ReflectableTest, varuint32ConstArray)
1484
{
1485
2
    const auto rawArray = std::vector<uint32_t>({10000, 20000, 30000, 40000});
1486
2
    auto reflectable = ReflectableFactory::getVarUInt32Array(rawArray);
1487
2
    checkArray(rawArray, reflectable,
1488
4
            [&](uint32_t value, const IReflectableConstPtr& elementReflectable) {
1489
16
                checkUnsignedIntegral(value, elementReflectable, &IReflectable::getUInt32,
1490

16
                        std::bind(&BitStreamReader::readVarUInt32, _1));
1491
4
            }
1492
1
    );
1493
1
}
1494
1495


802
TEST_F(ReflectableTest, varuint32Array)
1496
{
1497
2
    auto rawArray = std::vector<uint32_t>{{10000, 20000, 30000, 40000}};
1498
2
    auto reflectable = ReflectableFactory::getVarUInt32Array(rawArray);
1499
2
    checkArray(rawArray, reflectable,
1500
4
            [&](uint32_t value, const IReflectablePtr& elementReflectable) {
1501
16
                checkUnsignedIntegral(value, elementReflectable, &IReflectable::getUInt32,
1502

16
                        std::bind(&BitStreamReader::readVarUInt32, _1));
1503
4
            }
1504
1
    );
1505
1
}
1506
1507


802
TEST_F(ReflectableTest, varuint64ConstArray)
1508
{
1509
2
    const auto rawArray = std::vector<uint64_t>({10000, 20000, 30000, 40000});
1510
2
    auto reflectable = ReflectableFactory::getVarUInt64Array(rawArray);
1511
2
    checkArray(rawArray, reflectable,
1512
4
            [&](uint64_t value, const IReflectableConstPtr& elementReflectable) {
1513
16
                checkUnsignedIntegral(value, elementReflectable, &IReflectable::getUInt64,
1514

16
                        std::bind(&BitStreamReader::readVarUInt64, _1));
1515
4
            }
1516
1
    );
1517
1
}
1518
1519


802
TEST_F(ReflectableTest, varuint64Array)
1520
{
1521
2
    auto rawArray = std::vector<uint64_t>{{10000, 20000, 30000, 40000}};
1522
2
    auto reflectable = ReflectableFactory::getVarUInt64Array(rawArray);
1523
2
    checkArray(rawArray, reflectable,
1524
4
            [&](uint64_t value, const IReflectablePtr& elementReflectable) {
1525
16
                checkUnsignedIntegral(value, elementReflectable, &IReflectable::getUInt64,
1526

16
                        std::bind(&BitStreamReader::readVarUInt64, _1));
1527
4
            }
1528
1
    );
1529
1
}
1530
1531


802
TEST_F(ReflectableTest, varuintConstArray)
1532
{
1533
2
    const auto rawArray = std::vector<uint64_t>({10000, 20000, 30000, 40000});
1534
2
    auto reflectable = ReflectableFactory::getVarUIntArray(rawArray);
1535
2
    checkArray(rawArray, reflectable,
1536
4
            [&](uint64_t value, const IReflectableConstPtr& elementReflectable) {
1537
16
                checkUnsignedIntegral(value, elementReflectable, &IReflectable::getUInt64,
1538

16
                        std::bind(&BitStreamReader::readVarUInt, _1));
1539
4
            }
1540
1
    );
1541
1
}
1542
1543


802
TEST_F(ReflectableTest, varuintArray)
1544
{
1545
2
    auto rawArray = std::vector<uint64_t>{{10000, 20000, 30000, 40000}};
1546
2
    auto reflectable = ReflectableFactory::getVarUIntArray(rawArray);
1547
2
    checkArray(rawArray, reflectable,
1548
4
            [&](uint64_t value, const IReflectablePtr& elementReflectable) {
1549
16
                checkUnsignedIntegral(value, elementReflectable, &IReflectable::getUInt64,
1550

16
                        std::bind(&BitStreamReader::readVarUInt, _1));
1551
4
            }
1552
1
    );
1553
1
}
1554
1555


802
TEST_F(ReflectableTest, varsizeConstArray)
1556
{
1557
2
    const auto rawArray = std::vector<uint32_t>({10000, 20000, 30000, 40000});
1558
2
    auto reflectable = ReflectableFactory::getVarSizeArray(rawArray);
1559
2
    checkArray(rawArray, reflectable,
1560
4
            [&](uint32_t value, const IReflectableConstPtr& elementReflectable) {
1561
16
                checkUnsignedIntegral(value, elementReflectable, &IReflectable::getUInt32,
1562

16
                        std::bind(&BitStreamReader::readVarSize, _1));
1563
4
            }
1564
1
    );
1565
1
}
1566
1567


802
TEST_F(ReflectableTest, varsizeArray)
1568
{
1569
2
    auto rawArray = std::vector<uint32_t>{{10000, 20000, 30000, 40000}};
1570
2
    auto reflectable = ReflectableFactory::getVarSizeArray(rawArray);
1571
2
    checkArray(rawArray, reflectable,
1572
4
            [&](uint32_t value, const IReflectablePtr& elementReflectable) {
1573
16
                checkUnsignedIntegral(value, elementReflectable, &IReflectable::getUInt32,
1574

16
                        std::bind(&BitStreamReader::readVarSize, _1));
1575
4
            }
1576
1
    );
1577
1
}
1578
1579


802
TEST_F(ReflectableTest, float16ConstArray)
1580
{
1581
2
    const auto rawArray = std::vector<float>{{2.0F, 0.0F}};
1582
2
    auto reflectable = ReflectableFactory::getFloat16Array(rawArray);
1583
2
    checkArray(rawArray, reflectable,
1584
2
            [&](float value, const IReflectableConstPtr& elementReflectable) {
1585
8
                checkFloatingPoint(value, elementReflectable, &IReflectable::getFloat,
1586

8
                        std::bind(&BitStreamReader::readFloat16, _1));
1587
2
            }
1588
1
    );
1589
1
}
1590
1591


802
TEST_F(ReflectableTest, float16Array)
1592
{
1593
2
    auto rawArray = std::vector<float>{{2.0F, 0.0F}};
1594
2
    auto reflectable = ReflectableFactory::getFloat16Array(rawArray);
1595
2
    checkArray(rawArray, reflectable,
1596
2
            [&](float value, const IReflectablePtr& elementReflectable) {
1597
8
                checkFloatingPoint(value, elementReflectable, &IReflectable::getFloat,
1598

8
                        std::bind(&BitStreamReader::readFloat16, _1));
1599
2
            }
1600
1
    );
1601
1
}
1602
1603


802
TEST_F(ReflectableTest, float32ConstArray)
1604
{
1605
2
    const auto rawArray = std::vector<float>{{2.0F, 0.0F, 1.2F}};
1606
2
    auto reflectable = ReflectableFactory::getFloat32Array(rawArray);
1607
2
    checkArray(rawArray, reflectable,
1608
3
            [&](float value, const IReflectableConstPtr& elementReflectable) {
1609
12
                checkFloatingPoint(value, elementReflectable, &IReflectable::getFloat,
1610

12
                        std::bind(&BitStreamReader::readFloat32, _1));
1611
3
            }
1612
1
    );
1613
1
}
1614
1615


802
TEST_F(ReflectableTest, float32Array)
1616
{
1617
2
    auto rawArray = std::vector<float>{{2.0F, 0.0F, 1.2F}};
1618
2
    auto reflectable = ReflectableFactory::getFloat32Array(rawArray);
1619
2
    checkArray(rawArray, reflectable,
1620
3
            [&](float value, const IReflectablePtr& elementReflectable) {
1621
12
                checkFloatingPoint(value, elementReflectable, &IReflectable::getFloat,
1622

12
                        std::bind(&BitStreamReader::readFloat32, _1));
1623
3
            }
1624
1
    );
1625
1
}
1626
1627


802
TEST_F(ReflectableTest, float64ConstArray)
1628
{
1629
2
    const auto rawArray = std::vector<double>{{2.0, 0.0, 1.2}};
1630
2
    auto reflectable = ReflectableFactory::getFloat64Array(rawArray);
1631
2
    checkArray(rawArray, reflectable,
1632
3
            [&](double value, const IReflectableConstPtr& elementReflectable) {
1633
12
                checkFloatingPoint(value, elementReflectable, &IReflectable::getDouble,
1634

12
                        std::bind(&BitStreamReader::readFloat64, _1));
1635
3
            }
1636
1
    );
1637
1
}
1638
1639


802
TEST_F(ReflectableTest, float64Array)
1640
{
1641
2
    auto rawArray = std::vector<double>{{2.0, 0.0, 1.2}};
1642
2
    auto reflectable = ReflectableFactory::getFloat64Array(rawArray);
1643
2
    checkArray(rawArray, reflectable,
1644
3
            [&](double value, const IReflectablePtr& elementReflectable) {
1645
12
                checkFloatingPoint(value, elementReflectable, &IReflectable::getDouble,
1646

12
                        std::bind(&BitStreamReader::readFloat64, _1));
1647
3
            }
1648
1
    );
1649
1
}
1650
1651


802
TEST_F(ReflectableTest, stringConstArray)
1652
{
1653



2
    const auto rawArray = std::vector<std::string>{{"one", "two", "three"}};
1654

2
    auto reflectable = ReflectableFactory::getStringArray(rawArray);
1655
2
    checkArray(rawArray, reflectable,
1656
3
            [&](StringView value, const IReflectableConstPtr& elementReflectable) {
1657
3
                checkString(value, elementReflectable);
1658
3
            }
1659
1
    );
1660
1661
2
    auto nonConstReflectable = std::const_pointer_cast<IReflectable>(reflectable);
1662










2
    ASSERT_THROW(nonConstReflectable->getAnyValue(), CppRuntimeException);
1663
}
1664
1665


802
TEST_F(ReflectableTest, stringArray)
1666
{
1667



2
    auto rawArray = std::vector<std::string>{{"one", "two", "three"}};
1668

2
    auto reflectable = ReflectableFactory::getStringArray(rawArray);
1669
2
    checkArray(rawArray, reflectable,
1670
3
            [&](StringView value, const IReflectablePtr& elementReflectable) {
1671
3
                checkString(value, elementReflectable);
1672
3
            }
1673
1
    );
1674
2
    checkArray(rawArray, static_cast<IReflectableConstPtr>(reflectable),
1675
3
            [&](StringView value, const IReflectableConstPtr& elementReflectable) {
1676
3
                checkString(value, elementReflectable);
1677
3
            }
1678
1
    );
1679
1680
1
    reflectable->resize(0);
1681



1
    ASSERT_EQ(0, reflectable->size());
1682

1
    reflectable->append(AnyHolder<>(std::string("appended")));
1683



1
    ASSERT_EQ(1, reflectable->size());
1684




1
    ASSERT_EQ("appended"_sv, reflectable->at(0)->getStringView());
1685

1
    reflectable->setAt(AnyHolder<>(std::string("set")), 0);
1686



1
    ASSERT_EQ(1, reflectable->size());
1687




1
    ASSERT_EQ("set"_sv, reflectable->at(0)->getStringView());
1688
1
    reflectable->resize(2);
1689



1
    ASSERT_EQ(2, reflectable->size());
1690
1691
    // out of range
1692











2
    ASSERT_THROW(reflectable->setAt(AnyHolder<>(std::string("set")), 2), CppRuntimeException);
1693
}
1694
1695


802
TEST_F(ReflectableTest, bitBufferConstArray)
1696
{
1697



2
    const auto rawArray = std::vector<BitBuffer>{{BitBuffer({0xF8}, 5), BitBuffer({0xAB, 0xCD}, 16)}};
1698
2
    auto reflectable = ReflectableFactory::getBitBufferArray(rawArray);
1699
2
    checkArray(rawArray, reflectable,
1700
2
            [&](const BitBuffer& value, const IReflectableConstPtr& elementReflectable) {
1701
2
                checkBitBuffer(value, elementReflectable);
1702
2
            }
1703
1
    );
1704
1
}
1705
1706


802
TEST_F(ReflectableTest, bitBufferArray)
1707
{
1708



2
    auto rawArray = std::vector<BitBuffer>{{BitBuffer({0xF8}, 5), BitBuffer({0xAB, 0xCD}, 16)}};
1709

2
    auto reflectable = ReflectableFactory::getBitBufferArray(rawArray);
1710
2
    checkArray(rawArray, reflectable,
1711
2
            [&](const BitBuffer& value, const IReflectablePtr& elementReflectable) {
1712
2
                checkBitBuffer(value, elementReflectable);
1713
2
            }
1714
1
    );
1715
2
    checkArray(rawArray, static_cast<IReflectableConstPtr>(reflectable),
1716
2
            [&](const BitBuffer& value, const IReflectableConstPtr& elementReflectable) {
1717
2
                checkBitBuffer(value, elementReflectable);
1718
2
            }
1719
1
    );
1720
1721
1
    reflectable->resize(0);
1722



1
    ASSERT_EQ(0, reflectable->size());
1723

1
    reflectable->append(AnyHolder<>(BitBuffer()));
1724



1
    ASSERT_EQ(1, reflectable->size());
1725




1
    ASSERT_EQ(0, reflectable->at(0)->getBitBuffer().getBitSize());
1726


1
    reflectable->setAt(AnyHolder<>(BitBuffer({0xA0}, 4)), 0);
1727



1
    ASSERT_EQ(1, reflectable->size());
1728




1
    ASSERT_EQ(4, reflectable->at(0)->getBitBuffer().getBitSize());
1729
1
    reflectable->resize(2);
1730



1
    ASSERT_EQ(2, reflectable->size());
1731
1732
    // out of range
1733











2
    ASSERT_THROW(reflectable->setAt(AnyHolder<>(BitBuffer()), 2), CppRuntimeException);
1734
}
1735
1736


802
TEST_F(ReflectableTest, bytesConstArray)
1737
{
1738
    const auto rawArray = std::vector<std::vector<uint8_t>>{{
1739
        {{0x00, 0x01}},
1740
        {{0xFF, 0xFE}}
1741


2
    }};
1742
2
    auto reflectable = ReflectableFactory::getBytesArray(rawArray);
1743
2
    checkArray(rawArray, reflectable,
1744
2
            [&](const vector<uint8_t>& value, const IReflectableConstPtr& elementReflectable) {
1745
2
                checkBytes(value, elementReflectable);
1746
2
            }
1747
1
    );
1748
1
}
1749
1750


802
TEST_F(ReflectableTest, bytesArray)
1751
{
1752
    auto rawArray = std::vector<std::vector<uint8_t>>{{
1753
        {{0x00, 0x01}},
1754
        {{0xFF, 0xFE}}
1755


2
    }};
1756

2
    auto reflectable = ReflectableFactory::getBytesArray(rawArray);
1757
2
    checkArray(rawArray, reflectable,
1758
2
            [&](const vector<uint8_t>& value, const IReflectablePtr& elementReflectable) {
1759
2
                checkBytes(value, elementReflectable);
1760
2
            }
1761
1
    );
1762
2
    checkArray(rawArray, static_cast<IReflectableConstPtr>(reflectable),
1763
2
            [&](const vector<uint8_t>& value, const IReflectableConstPtr& elementReflectable) {
1764
2
                checkBytes(value, elementReflectable);
1765
2
            }
1766
1
    );
1767
1768
1
    reflectable->resize(0);
1769



1
    ASSERT_EQ(0, reflectable->size());
1770

1
    reflectable->append(AnyHolder<>(std::vector<uint8_t>()));
1771



1
    ASSERT_EQ(1, reflectable->size());
1772




1
    ASSERT_EQ(0, reflectable->at(0)->getBytes().size());
1773

1
    reflectable->setAt(AnyHolder<>(std::vector<uint8_t>{{0xAB, 0xCD}}), 0);
1774



1
    ASSERT_EQ(1, reflectable->size());
1775




1
    ASSERT_EQ(2, reflectable->at(0)->getBytes().size());
1776
1
    reflectable->resize(2);
1777



1
    ASSERT_EQ(2, reflectable->size());
1778
1779
    // out of range
1780











2
    ASSERT_THROW(reflectable->setAt(AnyHolder<>(std::vector<uint8_t>()), 2), CppRuntimeException);
1781
}
1782
1783


802
TEST_F(ReflectableTest, bitmaskConstReflectable)
1784
{
1785
1
    const ReflectableBitmask bitmask = ReflectableBitmask::Values::WRITE;
1786
2
    auto reflectable = bitmask.reflectable();
1787
1
    checkBitmask(bitmask, reflectable);
1788
1
}
1789
1790


802
TEST_F(ReflectableTest, bitmaskReflectable)
1791
{
1792
1
    ReflectableBitmask bitmask = ReflectableBitmask::Values::WRITE;
1793
2
    auto reflectable = bitmask.reflectable();
1794
1
    checkBitmask(bitmask, reflectable);
1795
1
}
1796
1797


802
TEST_F(ReflectableTest, bitmaskConstArray)
1798
{
1799
    const auto rawArray = std::vector<ReflectableBitmask>{{
1800
            ReflectableBitmask::Values::WRITE, ReflectableBitmask::Values::CREATE,
1801
            ReflectableBitmask::Values::READ
1802
2
    }};
1803

2
    auto reflectable = ReflectableFactory::getBitmaskArray(rawArray);
1804
2
    checkArray(rawArray, reflectable,
1805
3
            [&](ReflectableBitmask value, const IReflectableConstPtr& elementReflectable) {
1806
3
                checkBitmask(value, elementReflectable);
1807
3
            }
1808
1
    );
1809
1810
2
    auto nonConstReflectable = std::const_pointer_cast<IReflectable>(reflectable);
1811










2
    ASSERT_THROW(nonConstReflectable->getAnyValue(), CppRuntimeException);
1812
}
1813
1814


802
TEST_F(ReflectableTest, bitmaskArray)
1815
{
1816
    auto rawArray = std::vector<ReflectableBitmask>{{
1817
            ReflectableBitmask::Values::WRITE, ReflectableBitmask::Values::CREATE,
1818
            ReflectableBitmask::Values::READ
1819
2
    }};
1820

2
    auto reflectable = ReflectableFactory::getBitmaskArray(rawArray);
1821
2
    checkArray(rawArray, reflectable,
1822
3
            [&](ReflectableBitmask value, const IReflectablePtr& elementReflectable) {
1823
3
                checkBitmask(value, elementReflectable);
1824
3
            }
1825
1
    );
1826
2
    checkArray(rawArray, static_cast<IReflectableConstPtr>(reflectable),
1827
3
            [&](ReflectableBitmask value, const IReflectableConstPtr& elementReflectable) {
1828
3
                checkBitmask(value, elementReflectable);
1829
3
            }
1830
1
    );
1831
1832
1
    reflectable->resize(0);
1833



1
    ASSERT_EQ(0, reflectable->size());
1834

1
    reflectable->append(AnyHolder<>(ReflectableBitmask(ReflectableBitmask::Values::READ)));
1835



1
    ASSERT_EQ(1, reflectable->size());
1836




1
    ASSERT_EQ(ReflectableBitmask::Values::READ, ReflectableBitmask(reflectable->at(0)->getUInt8()));
1837

1
    reflectable->setAt(AnyHolder<>(ReflectableBitmask(ReflectableBitmask::Values::CREATE)), 0);
1838



1
    ASSERT_EQ(1, reflectable->size());
1839




1
    ASSERT_EQ(ReflectableBitmask::Values::CREATE, ReflectableBitmask(reflectable->at(0)->getUInt8()));
1840
1
    reflectable->resize(2);
1841



1
    ASSERT_EQ(2, reflectable->size());
1842
1843

1
    reflectable->append(AnyHolder<>(ReflectableBitmask(ReflectableBitmask::Values::WRITE).getValue()));
1844



1
    ASSERT_EQ(3, reflectable->size());
1845




1
    ASSERT_EQ(ReflectableBitmask::Values::WRITE, ReflectableBitmask(reflectable->at(2)->getUInt8()));
1846

1
    reflectable->setAt(AnyHolder<>(ReflectableBitmask(ReflectableBitmask::Values::READ).getValue()), 2);
1847



1
    ASSERT_EQ(3, reflectable->size());
1848




1
    ASSERT_EQ(ReflectableBitmask::Values::READ, ReflectableBitmask(reflectable->at(2)->getUInt8()));
1849
1850
    // out of range
1851











2
    ASSERT_THROW(reflectable->setAt(AnyHolder<>(ReflectableBitmask::Values::CREATE), 3), CppRuntimeException);
1852
}
1853
1854


802
TEST_F(ReflectableTest, enumReflectable)
1855
{
1856
1
    const ReflectableEnum enumeration = ReflectableEnum::VALUE1;
1857
2
    auto reflectable = enumReflectable(enumeration);
1858
1
    checkEnum(enumeration, reflectable);
1859
1
}
1860
1861


802
TEST_F(ReflectableTest, enumConstArray)
1862
{
1863
    const auto rawArray = std::vector<ReflectableEnum>{{ReflectableEnum::VALUE1, ReflectableEnum::VALUE2,
1864
2
            ReflectableEnum::VALUE3}};
1865

2
    auto reflectable = ReflectableFactory::getEnumArray(rawArray);
1866
2
    checkArray(rawArray, reflectable,
1867
3
            [&](ReflectableEnum value, const IReflectableConstPtr& elementReflectable) {
1868
3
                checkEnum(value, elementReflectable);
1869
3
            }
1870
1
    );
1871
1872
2
    auto nonConstReflectable = std::const_pointer_cast<IReflectable>(reflectable);
1873










2
    ASSERT_THROW(nonConstReflectable->getAnyValue(), CppRuntimeException);
1874
}
1875
1876


802
TEST_F(ReflectableTest, enumArray)
1877
{
1878
    auto rawArray = std::vector<ReflectableEnum>{{ReflectableEnum::VALUE1, ReflectableEnum::VALUE2,
1879
2
            ReflectableEnum::VALUE3}};
1880

2
    auto reflectable = ReflectableFactory::getEnumArray(rawArray);
1881
2
    checkArray(rawArray, reflectable,
1882
3
            [&](ReflectableEnum value, const IReflectablePtr& elementReflectable) {
1883
3
                checkEnum(value, elementReflectable);
1884
3
            }
1885
1
    );
1886
2
    checkArray(rawArray, static_cast<IReflectableConstPtr>(reflectable),
1887
3
            [&](ReflectableEnum value, const IReflectableConstPtr& elementReflectable) {
1888
3
                checkEnum(value, elementReflectable);
1889
3
            }
1890
1
    );
1891
1892
1
    reflectable->resize(0);
1893



1
    ASSERT_EQ(0, reflectable->size());
1894

1
    reflectable->append(AnyHolder<>(ReflectableEnum::VALUE3));
1895



1
    ASSERT_EQ(1, reflectable->size());
1896




1
    ASSERT_EQ(enumToValue(ReflectableEnum::VALUE3), reflectable->at(0)->getInt8());
1897

1
    reflectable->setAt(AnyHolder<>(ReflectableEnum::VALUE2), 0);
1898



1
    ASSERT_EQ(1, reflectable->size());
1899




1
    ASSERT_EQ(enumToValue(ReflectableEnum::VALUE2), reflectable->at(0)->getInt8());
1900
1
    reflectable->resize(2);
1901



1
    ASSERT_EQ(2, reflectable->size());
1902
1903

1
    reflectable->append(AnyHolder<>(enumToValue(ReflectableEnum::VALUE1)));
1904



1
    ASSERT_EQ(3, reflectable->size());
1905




1
    ASSERT_EQ(enumToValue(ReflectableEnum::VALUE1), reflectable->at(2)->getInt8());
1906

1
    reflectable->setAt(AnyHolder<>(enumToValue(ReflectableEnum::VALUE2)), 2);
1907



1
    ASSERT_EQ(3, reflectable->size());
1908




1
    ASSERT_EQ(enumToValue(ReflectableEnum::VALUE2), reflectable->at(2)->getInt8());
1909
1910
    // out of range
1911











2
    ASSERT_THROW(reflectable->setAt(AnyHolder<>(ReflectableEnum::VALUE2), 3), CppRuntimeException);
1912
}
1913
1914


802
TEST_F(ReflectableTest, compoundConst)
1915
{
1916
    {
1917
        const ReflectableObject reflectableObjectUninitialized = ReflectableObject{"test",
1918
2
                ReflectableNested{13}};
1919

2
        auto reflectable = reflectableObjectUninitialized.reflectable();
1920




1
        ASSERT_FALSE(reflectable->find("reflectableNested.stringParam"));
1921
    }
1922
1923

2
    const ReflectableObject reflectableObject = createInitializedReflectableObject("test", 13);
1924

2
    auto reflectable = reflectableObject.reflectable();
1925
1
    checkCompound(reflectableObject, reflectable);
1926
1927
2
    IReflectablePtr nonConstReflectable = std::const_pointer_cast<IReflectable>(reflectable);
1928









2
    ASSERT_THROW(nonConstReflectable->initializeChildren(), CppRuntimeException);
1929










2
    ASSERT_THROW(nonConstReflectable->initialize(vector<AnyHolder<>>()), CppRuntimeException);
1930









1
    ASSERT_NO_THROW(reflectable->getField("reflectableNested"));
1931










2
    ASSERT_THROW(nonConstReflectable->getField("reflectableNested"), CppRuntimeException);
1932









1
    ASSERT_NO_THROW(reflectable->getAnyValue());
1933









2
    ASSERT_THROW(nonConstReflectable->getAnyValue(), CppRuntimeException);
1934
1935

2
    IReflectableConstPtr childReflectable = reflectable->getField("reflectableNested");
1936
2
    IReflectablePtr nonConstChildReflectable =std::const_pointer_cast<IReflectable>(childReflectable);
1937










2
    ASSERT_THROW(nonConstChildReflectable->setField("value", AnyHolder<>(static_cast<uint32_t>(11))),
1938
            CppRuntimeException);
1939









1
    ASSERT_NO_THROW(childReflectable->getParameter("dummyParam"));
1940










2
    ASSERT_THROW(nonConstChildReflectable->getParameter("dummyParam"), CppRuntimeException);
1941









1
    ASSERT_NO_THROW(childReflectable->callFunction("getValue"));
1942











2
    ASSERT_THROW(nonConstChildReflectable->callFunction("getValue"), CppRuntimeException);
1943










2
    ASSERT_THROW(nonConstChildReflectable->initializeOffsets(0), CppRuntimeException);
1944
}
1945
1946


802
TEST_F(ReflectableTest, compound)
1947
{
1948
    {
1949
2
        ReflectableObject reflectableObjectUninitialized = ReflectableObject{"test", ReflectableNested{13}};
1950

2
        auto reflectable = reflectableObjectUninitialized.reflectable();
1951




1
        ASSERT_FALSE(reflectable->find("reflectableNested.stringParam"));
1952
    }
1953
1954
2
    ReflectableObject reflectableObject = ReflectableObject{"test", ReflectableNested{13}};
1955

2
    auto reflectable = reflectableObject.reflectable();
1956
1957
    // not initialized
1958










2
    ASSERT_THROW(reflectable->getField("reflectableNested")->getParameter("dummyParam"), CppRuntimeException);
1959










2
    ASSERT_THROW(reflectable->getField("reflectableNested")->getParameter("stringParam"), CppRuntimeException);
1960



1
    ASSERT_FALSE(static_cast<IReflectableConstPtr>(reflectable)->find("reflectableNested.stringParam"));
1961
1962
1
    reflectable->initializeChildren();
1963

1
    checkCompound(reflectableObject, reflectable);
1964
}
1965
1966


802
TEST_F(ReflectableTest, compoundConstArray)
1967
{
1968
2
    ReflectableObject reflectableObject1;
1969

1
    reflectableObject1 = createInitializedReflectableObject("1", 13); // to cover assignment operator
1970
    const auto rawArray = std::vector<ReflectableObject>{{
1971
        reflectableObject1,
1972
        createInitializedReflectableObject("2", 42)
1973



2
    }};
1974

2
    auto reflectable = ReflectableFactory::getCompoundArray(rawArray);
1975
2
    checkArray(rawArray, reflectable,
1976
2
            [&](const ReflectableObject& value, const IReflectableConstPtr& elementReflectable) {
1977
2
                checkCompound(value, elementReflectable);
1978
2
            }
1979
1
    );
1980
1981
2
    IReflectablePtr nonConstReflectable = std::const_pointer_cast<IReflectable>(reflectable);
1982










2
    ASSERT_THROW(nonConstReflectable->at(0), CppRuntimeException);
1983










2
    ASSERT_THROW((*nonConstReflectable)[0], CppRuntimeException);
1984










2
    ASSERT_THROW(nonConstReflectable->resize(nonConstReflectable->size() + 1), CppRuntimeException);
1985











2
    ASSERT_THROW(nonConstReflectable->setAt(AnyHolder<>(ReflectableObject{"test", ReflectableNested{0}}), 0),
1986
            CppRuntimeException);
1987












2
    ASSERT_THROW(nonConstReflectable->append(AnyHolder<>(ReflectableObject{"test", ReflectableNested{0}})),
1988
            CppRuntimeException);
1989










2
    ASSERT_THROW(nonConstReflectable->getAnyValue(), CppRuntimeException);
1990
}
1991
1992


802
TEST_F(ReflectableTest, compoundArray)
1993
{
1994
    auto rawArray = std::vector<ReflectableObject>{{
1995
        createInitializedReflectableObject("1", 13),
1996
        createInitializedReflectableObject("2", 42)
1997



2
    }};
1998

2
    auto reflectable = ReflectableFactory::getCompoundArray(rawArray);
1999
2
    checkArray(rawArray, reflectable,
2000
2
            [&](const ReflectableObject& value, const IReflectablePtr& elementReflectable) {
2001
2
                checkCompound(value, elementReflectable);
2002
2
            }
2003
1
    );
2004
2
    checkArray(rawArray, static_cast<IReflectableConstPtr>(reflectable),
2005
2
            [&](const ReflectableObject& value, const IReflectableConstPtr& elementReflectable) {
2006
2
                checkCompound(value, elementReflectable);
2007
2
            }
2008
1
    );
2009
2010

1
    reflectable->resize(reflectable->size() + 1);
2011

2
    IReflectablePtr newCompound = reflectable->at(reflectable->size() - 1);
2012



1
    ASSERT_TRUE(newCompound);
2013
2014

1
    reflectable->setAt(AnyHolder<>(ReflectableObject{"test", ReflectableNested{0}}), 0);
2015




1
    ASSERT_EQ(0, reflectable->at(0)->find("reflectableNested.value")->getUInt32());
2016

1
    reflectable->append(AnyHolder<>(ReflectableObject{"test|", ReflectableNested{1}}));
2017





1
    ASSERT_EQ(1, reflectable->at(reflectable->size() - 1)->find("reflectableNested.value")->getUInt32());
2018
2019
1
    const size_t size = reflectable->size();
2020











2
    ASSERT_THROW(reflectable->setAt(AnyHolder<>(), size), CppRuntimeException); // out of range
2021
}
2022
2023


802
TEST_F(ReflectableTest, defaultUnimplementedMethods)
2024
{
2025
1
    class Reflectable : public ReflectableBase<std::allocator<uint8_t>>
2026
    {
2027
    public:
2028
1
        using ReflectableBase<std::allocator<uint8_t>>::ReflectableBase;
2029
    };
2030
2031

2
    Reflectable reflectable(BuiltinTypeInfo<>::getUInt8());
2032









2
    ASSERT_THROW(reflectable.bitSizeOf(0), CppRuntimeException);
2033
2034

2
    BitBuffer bitBuffer(0);
2035
1
    BitStreamWriter writer(bitBuffer);
2036










2
    ASSERT_THROW(reflectable.write(writer), CppRuntimeException);
2037
2038










2
    ASSERT_THROW(reflectable.getAnyValue(), CppRuntimeException);
2039
2040
1
    const Reflectable& constReflectableRef = reflectable;
2041










2
    ASSERT_THROW(constReflectableRef.getAnyValue(), CppRuntimeException);
2042
}
2043
2044


802
TEST_F(ReflectableTest, reflectableOwner)
2045
{
2046

2
    auto reflectable = ReflectableObject::typeInfo().createInstance();
2047
2048
    // must be as the first one to initialize object
2049








1
    ASSERT_NO_THROW(reflectable->initializeChildren());
2050
2051
2
    IReflectableConstPtr constReflectable = reflectable;
2052
2053
    // same as default initialized
2054
2
    ReflectableObject defaultReflectableObject;
2055
1
    defaultReflectableObject.initializeChildren();
2056




1
    ASSERT_EQ(defaultReflectableObject,
2057
            reflectable->getAnyValue().template get<std::reference_wrapper<ReflectableObject>>().get());
2058




1
    ASSERT_EQ(defaultReflectableObject,
2059
            constReflectable->getAnyValue().template get<std::reference_wrapper<ReflectableObject>>().get());
2060
2061
    // has no type arguments
2062










2
    ASSERT_THROW(reflectable->initialize(std::vector<AnyHolder<>>()), CppRuntimeException);
2063
2064




1
    ASSERT_TRUE(TypeInfoUtil::isCompound(reflectable->getTypeInfo().getSchemaType()));
2065



1
    ASSERT_FALSE(reflectable->isArray());
2066

1
    reflectable->setField("reflectableNested", AnyHolder<>(ReflectableNested{42}));
2067




1
    ASSERT_EQ(42, reflectable->getField("reflectableNested")->getField("value")->getUInt32());
2068




1
    ASSERT_EQ(42, constReflectable->getField("reflectableNested")->getField("value")->getUInt32());
2069










2
    ASSERT_THROW(reflectable->createField("nonexistent"), CppRuntimeException);
2070










2
    ASSERT_THROW(reflectable->getParameter("nonexistent"), CppRuntimeException);
2071










2
    ASSERT_THROW(constReflectable->getParameter("nonexistent"), CppRuntimeException);
2072










2
    ASSERT_THROW(reflectable->callFunction("nonexistent"), CppRuntimeException);
2073











2
    ASSERT_THROW(constReflectable->callFunction("nonexistent"), CppRuntimeException);
2074










2
    ASSERT_THROW(reflectable->getChoice(), CppRuntimeException);
2075









2
    ASSERT_THROW(constReflectable->getChoice(), CppRuntimeException);
2076



1
    ASSERT_FALSE(reflectable->find("nonexistent"));
2077



1
    ASSERT_FALSE(constReflectable->find("nonexistent"));
2078



1
    ASSERT_FALSE((*reflectable)["nonexistent"]);
2079




1
    ASSERT_FALSE((*constReflectable)["nonexistent"]);
2080
2081










2
    ASSERT_THROW(reflectable->size(), CppRuntimeException); // not an array
2082










2
    ASSERT_THROW(reflectable->resize(0), CppRuntimeException); // not an array
2083










2
    ASSERT_THROW(reflectable->at(0), CppRuntimeException); // not an array
2084










2
    ASSERT_THROW(constReflectable->at(0), CppRuntimeException); // not an array
2085










2
    ASSERT_THROW((*reflectable)[0], CppRuntimeException); // not an array
2086









2
    ASSERT_THROW((*constReflectable)[0], CppRuntimeException); // not an array
2087










2
    ASSERT_THROW(reflectable->setAt(AnyHolder<>(), 0), CppRuntimeException); // not an array
2088











2
    ASSERT_THROW(reflectable->append(AnyHolder<>()), CppRuntimeException); // not an array
2089
2090










2
    ASSERT_THROW(reflectable->getBool(), CppRuntimeException);
2091










2
    ASSERT_THROW(reflectable->getInt8(), CppRuntimeException);
2092










2
    ASSERT_THROW(reflectable->getInt16(), CppRuntimeException);
2093










2
    ASSERT_THROW(reflectable->getInt32(), CppRuntimeException);
2094










2
    ASSERT_THROW(reflectable->getInt64(), CppRuntimeException);
2095










2
    ASSERT_THROW(reflectable->getUInt8(), CppRuntimeException);
2096










2
    ASSERT_THROW(reflectable->getUInt16(), CppRuntimeException);
2097










2
    ASSERT_THROW(reflectable->getUInt32(), CppRuntimeException);
2098










2
    ASSERT_THROW(reflectable->getUInt64(), CppRuntimeException);
2099










2
    ASSERT_THROW(reflectable->getFloat(), CppRuntimeException);
2100










2
    ASSERT_THROW(reflectable->getDouble(), CppRuntimeException);
2101










2
    ASSERT_THROW(reflectable->getBytes(), CppRuntimeException);
2102










2
    ASSERT_THROW(reflectable->getStringView(), CppRuntimeException);
2103










2
    ASSERT_THROW(reflectable->getBitBuffer(), CppRuntimeException);
2104
2105










2
    ASSERT_THROW(reflectable->toInt(), CppRuntimeException);
2106










2
    ASSERT_THROW(reflectable->toUInt(), CppRuntimeException);
2107










2
    ASSERT_THROW(reflectable->toDouble(), CppRuntimeException);
2108









2
    ASSERT_THROW(reflectable->toString(), CppRuntimeException);
2109
2110




1
    ASSERT_EQ(reflectable->bitSizeOf(), reflectable->initializeOffsets());
2111
2112








1
    ASSERT_NO_THROW(reflectable->initializeChildren());
2113
2114
1
    const size_t bitSizeOfValue = reflectable->bitSizeOf();
2115

2
    BitBuffer bitBuffer(bitSizeOfValue);
2116
1
    BitStreamWriter writer(bitBuffer);
2117
1
    reflectable->write(writer);
2118



1
    ASSERT_EQ(bitSizeOfValue, writer.getBitPosition());
2119
}
2120
2121

2394
} // namespace zserio