Coverage Report

Created: 2024-07-18 11:41

test/zserio/ReflectableTest.cpp
Line
Count
Source
1
#include <functional>
2
#include <string>
3
#include <type_traits>
4
5
#include "gtest/gtest.h"
6
#include "test_object/std_allocator/ReflectableBitmask.h"
7
#include "test_object/std_allocator/ReflectableEnum.h"
8
#include "test_object/std_allocator/ReflectableNested.h"
9
#include "test_object/std_allocator/ReflectableObject.h"
10
#include "zserio/ArrayTraits.h"
11
#include "zserio/BitSizeOfCalculator.h"
12
#include "zserio/BitStreamReader.h"
13
#include "zserio/BitStreamWriter.h"
14
#include "zserio/Reflectable.h"
15
#include "zserio/Vector.h"
16
17
using test_object::std_allocator::ReflectableBitmask;
18
using test_object::std_allocator::ReflectableEnum;
19
using test_object::std_allocator::ReflectableNested;
20
using test_object::std_allocator::ReflectableObject;
21
22
using namespace std::placeholders;
23
24
namespace zserio
25
{
26
27
namespace
28
{
29
30
ReflectableObject createInitializedReflectableObject(
31
        const string<>& stringField, uint32_t reflectableNestedValue)
32
5
{
33
5
    ReflectableObject reflectableObject(stringField, ReflectableNested{reflectableNestedValue});
34
5
    reflectableObject.initializeChildren();
35
5
    return reflectableObject;
36
5
}
37
38
} // namespace
39
40
namespace detail
41
{
42
43
template <typename FUNC>
44
struct return_type;
45
46
template <typename R, typename CLASS, typename... ARGS>
47
struct return_type<R (CLASS::*)(ARGS...) const>
48
{
49
    using type = R;
50
};
51
52
} // namespace detail
53
54
class ReflectableTest : public ::testing::Test
55
{
56
protected:
57
    template <typename RAW_ARRAY>
58
    void checkArrayAnyValue(const RAW_ARRAY& rawArray, const IReflectableConstPtr& reflectable)
59
40
    {
60
40
        ASSERT_EQ(rawArray,
61
40
                reflectable->getAnyValue().template get<std::reference_wrapper<const RAW_ARRAY>>().get());
62
40
    }
63
64
    template <typename RAW_ARRAY>
65
    void checkArrayAnyValue(const RAW_ARRAY& rawArray, const IReflectablePtr& reflectable)
66
31
    {
67
31
        ASSERT_EQ(rawArray, reflectable->getAnyValue().template get<std::reference_wrapper<RAW_ARRAY>>().get());
68
31
    }
69
70
    template <typename RAW_ARRAY, typename REFLECTABLE_PTR, typename ELEMENT_CHECKER>
71
    void checkArray(const RAW_ARRAY& rawArray, const REFLECTABLE_PTR& reflectable,
72
            const ELEMENT_CHECKER& elementChecker)
73
71
    {
74
71
        ASSERT_TRUE(reflectable->isArray());
75
71
        ASSERT_EQ(rawArray.size(), reflectable->size());
76
330
        
for (size_t i = 0; 71
i < rawArray.size();
++i259
)
77
259
        {
78
259
            if (i % 2 == 0)
79
141
            {
80
141
                elementChecker(rawArray[i], reflectable->at(i));
81
141
            }
82
118
            else
83
118
            {
84
118
                elementChecker(rawArray[i], (*reflectable)[i]);
85
118
            }
86
259
        }
87
88
71
        ASSERT_THROW(reflectable->at(rawArray.size()), CppRuntimeException);
89
71
        ASSERT_THROW((*reflectable)[rawArray.size()], CppRuntimeException);
90
91
71
        checkArrayAnyValue(rawArray, reflectable);
92
93
71
        ASSERT_THROW(reflectable->getBool(), CppRuntimeException);
94
71
        ASSERT_THROW(reflectable->getInt8(), CppRuntimeException);
95
71
        ASSERT_THROW(reflectable->getInt16(), CppRuntimeException);
96
71
        ASSERT_THROW(reflectable->getInt32(), CppRuntimeException);
97
71
        ASSERT_THROW(reflectable->getInt64(), CppRuntimeException);
98
71
        ASSERT_THROW(reflectable->getUInt8(), CppRuntimeException);
99
71
        ASSERT_THROW(reflectable->getUInt16(), CppRuntimeException);
100
71
        ASSERT_THROW(reflectable->getUInt32(), CppRuntimeException);
101
71
        ASSERT_THROW(reflectable->getUInt64(), CppRuntimeException);
102
71
        ASSERT_THROW(reflectable->getFloat(), CppRuntimeException);
103
71
        ASSERT_THROW(reflectable->getDouble(), CppRuntimeException);
104
71
        ASSERT_THROW(reflectable->getBytes(), CppRuntimeException);
105
71
        ASSERT_THROW(reflectable->getStringView(), CppRuntimeException);
106
71
        ASSERT_THROW(reflectable->getBitBuffer(), CppRuntimeException);
107
108
71
        ASSERT_THROW(reflectable->toInt(), CppRuntimeException);
109
71
        ASSERT_THROW(reflectable->toUInt(), CppRuntimeException);
110
71
        ASSERT_THROW(reflectable->toDouble(), CppRuntimeException);
111
71
        ASSERT_THROW(reflectable->toString(), CppRuntimeException);
112
113
71
        ASSERT_THROW(reflectable->bitSizeOf(0), CppRuntimeException);
114
115
71
        BitBuffer bitBuffer(0);
116
71
        BitStreamWriter writer(bitBuffer);
117
71
        ASSERT_THROW(reflectable->write(writer), CppRuntimeException);
118
119
71
        checkNonCompound(reflectable);
120
71
    }
121
122
    template <typename T, typename REFLECTABLE_PTR, typename READ_FUNC>
123
    void checkWriteRead(
124
            T value, const REFLECTABLE_PTR& reflectable, const READ_FUNC& readFunc, size_t bitBufferSize)
125
308
    {
126
308
        BitBuffer bitBuffer(bitBufferSize);
127
308
        BitStreamWriter writer(bitBuffer);
128
308
        reflectable->write(writer);
129
308
        const size_t bitSizeOfValue = reflectable->bitSizeOf();
130
308
        ASSERT_EQ(bitSizeOfValue, writer.getBitPosition());
131
132
308
        BitStreamReader reader(bitBuffer);
133
308
        ASSERT_EQ(value, readFunc(reader));
134
308
        ASSERT_EQ(bitSizeOfValue, reader.getBitPosition());
135
308
    }
136
137
    void checkNonArray(const IReflectableConstPtr& reflectable)
138
308
    {
139
308
        ASSERT_FALSE(reflectable->isArray());
140
308
        ASSERT_THROW(reflectable->size(), CppRuntimeException);
141
308
        ASSERT_THROW(reflectable->at(0), CppRuntimeException);
142
308
        ASSERT_THROW((*reflectable)[0], CppRuntimeException);
143
308
    }
144
145
    void checkNonArray(const IReflectablePtr& reflectable)
146
125
    {
147
125
        checkNonArray(static_cast<IReflectableConstPtr>(reflectable));
148
149
125
        ASSERT_THROW(reflectable->at(0), CppRuntimeException);
150
125
        ASSERT_THROW((*reflectable)[0], CppRuntimeException);
151
125
        ASSERT_THROW(reflectable->resize(1), CppRuntimeException);
152
125
        ASSERT_THROW(reflectable->setAt(AnyHolder<>(), 0), CppRuntimeException);
153
125
    }
154
155
    template <typename REFLECTABLE_PTR>
156
    void checkNonCompoundConstMethods(const REFLECTABLE_PTR& reflectable)
157
368
    {
158
368
        ASSERT_THROW(reflectable->getField("field"), CppRuntimeException);
159
368
        ASSERT_THROW(reflectable->getParameter("parameter"), CppRuntimeException);
160
368
        ASSERT_THROW(reflectable->callFunction("function"), CppRuntimeException);
161
368
        ASSERT_THROW(reflectable->getChoice(), CppRuntimeException);
162
163
368
        ASSERT_EQ(nullptr, reflectable->find("some.field"));
164
368
        ASSERT_EQ(nullptr, (*reflectable)["some.field"]);
165
368
    }
166
167
    void checkNonCompound(const IReflectablePtr& reflectable)
168
153
    {
169
153
        ASSERT_THROW(reflectable->initializeChildren(), CppRuntimeException);
170
153
        ASSERT_THROW(reflectable->initialize(vector<AnyHolder<>>()), CppRuntimeException);
171
153
        ASSERT_THROW(reflectable->setField("field", AnyHolder<>{}), CppRuntimeException);
172
153
        ASSERT_THROW(reflectable->createField("field"), CppRuntimeException);
173
153
        ASSERT_THROW(reflectable->initializeOffsets(), CppRuntimeException);
174
175
153
        checkNonCompoundConstMethods(reflectable);
176
153
    }
177
178
    void checkNonCompound(const IReflectableConstPtr& reflectable)
179
215
    {
180
215
        checkNonCompoundConstMethods(reflectable);
181
215
    }
182
183
    template <typename T, typename REFLECTABLE_PTR, typename GETTER,
184
            typename std::enable_if<std::is_same<T, typename detail::return_type<GETTER>::type>::value,
185
                    int>::type = 0>
186
    void checkCppTypeGetter(T value, const REFLECTABLE_PTR& reflectable, const GETTER& getter,
187
            const char* testName, const char* getterName)
188
283
    {
189
566
        ASSERT_EQ(value, ((*reflectable).*getter)()) << testName << " : " << getterName;
190
283
    }
191
192
    template <typename T, typename REFLECTABLE_PTR, typename GETTER,
193
            typename std::enable_if<!std::is_same<T, typename detail::return_type<GETTER>::type>::value,
194
                    int>::type = 0>
195
    void checkCppTypeGetter(T, const REFLECTABLE_PTR& reflectable, const GETTER& getter, const char* testName,
196
            const char* getterName)
197
3.86k
    {
198
7.72k
        ASSERT_THROW(((*reflectable).*getter)(), CppRuntimeException) << testName << " : " << getterName;
199
3.86k
    }
200
201
    template <typename REFLECTABLE_PTR, typename GETTER,
202
            typename std::enable_if<
203
                    std::is_same<Span<const uint8_t>, typename detail::return_type<GETTER>::type>::value,
204
                    int>::type = 0>
205
    void checkCppTypeGetter(Span<const uint8_t> value, const REFLECTABLE_PTR& reflectable, const GETTER& getter,
206
            const char* testName, const char* getterName)
207
7
    {
208
14
        ASSERT_EQ(value.size(), ((*reflectable).*getter)().size()) << testName << " : " << getterName;
209
14
        ASSERT_EQ(value.data(), ((*reflectable).*getter)().data()) << testName << " : " << getterName;
210
7
    }
211
212
    template <typename REFLECTABLE_PTR, typename GETTER,
213
            typename std::enable_if<
214
                    std::is_same<const BitBuffer&, typename detail::return_type<GETTER>::type>::value,
215
                    int>::type = 0>
216
    void checkCppTypeGetter(const BitBuffer& value, const REFLECTABLE_PTR& reflectable, const GETTER& getter,
217
            const char* testName, const char* getterName)
218
7
    {
219
14
        ASSERT_EQ(value, ((*reflectable).*getter)()) << testName << " : " << getterName;
220
7
    }
221
222
    template <typename T, typename REFLECTABLE_PTR>
223
    void checkCppTypeGetters(T value, const REFLECTABLE_PTR& reflectable, const char* testName)
224
297
    {
225
297
        checkCppTypeGetter(value, reflectable, &IReflectable::getBool, testName, "getBool");
226
227
297
        checkCppTypeGetter(value, reflectable, &IReflectable::getInt8, testName, "getInt8");
228
297
        checkCppTypeGetter(value, reflectable, &IReflectable::getInt16, testName, "getInt16");
229
297
        checkCppTypeGetter(value, reflectable, &IReflectable::getInt32, testName, "getInt32");
230
297
        checkCppTypeGetter(value, reflectable, &IReflectable::getInt64, testName, "getInt64");
231
232
297
        checkCppTypeGetter(value, reflectable, &IReflectable::getUInt8, testName, "getUInt8");
233
297
        checkCppTypeGetter(value, reflectable, &IReflectable::getUInt16, testName, "getUInt16");
234
297
        checkCppTypeGetter(value, reflectable, &IReflectable::getUInt32, testName, "getUInt32");
235
297
        checkCppTypeGetter(value, reflectable, &IReflectable::getUInt64, testName, "getUInt64");
236
237
297
        checkCppTypeGetter(value, reflectable, &IReflectable::getFloat, testName, "getFloat");
238
297
        checkCppTypeGetter(value, reflectable, &IReflectable::getDouble, testName, "getDouble");
239
240
297
        checkCppTypeGetter(value, reflectable, &IReflectable::getBytes, testName, "getBytes");
241
297
        checkCppTypeGetter(value, reflectable, &IReflectable::getStringView, testName, "getStringView");
242
297
        checkCppTypeGetter(value, reflectable, &IReflectable::getBitBuffer, testName, "getBitBuffer");
243
297
    }
244
245
    template <typename T, typename REFLECTABLE_PTR, typename GETTER, typename READ_FUNC>
246
    void checkFloatingPoint(T value, const REFLECTABLE_PTR& reflectable, const GETTER& getter,
247
            const READ_FUNC& readFunc, size_t bitSize = sizeof(T) * 8)
248
19
    {
249
19
        ASSERT_DOUBLE_EQ(value, ((*reflectable).*getter)());
250
251
19
        ASSERT_DOUBLE_EQ(value, reflectable->toDouble());
252
19
        ASSERT_THROW(reflectable->toInt(), CppRuntimeException);
253
19
        ASSERT_THROW(reflectable->toUInt(), CppRuntimeException);
254
19
        ASSERT_THROW(reflectable->toString(), CppRuntimeException); // NOT IMPLEMENTED!
255
256
19
        checkCppTypeGetters(value, reflectable, "checkFloatingPoint");
257
258
19
        checkNonCompound(reflectable);
259
19
        checkNonArray(reflectable);
260
261
19
        checkWriteRead(value, reflectable, readFunc, bitSize);
262
19
    }
263
264
    template <typename T, typename REFLECTABLE_PTR, typename GETTER, typename READ_FUNC>
265
    void checkIntegral(T value, const REFLECTABLE_PTR& reflectable, const GETTER& getter,
266
            const READ_FUNC& readFunc, size_t bitSize, const char* testName)
267
232
    {
268
232
        ASSERT_EQ(value, ((*reflectable).*getter)());
269
270
232
        ASSERT_EQ(value, reflectable->getAnyValue().template get<T>());
271
272
232
        ASSERT_DOUBLE_EQ(static_cast<double>(value), reflectable->toDouble());
273
232
        ASSERT_EQ(zserio::toString(value), reflectable->toString());
274
275
232
        checkCppTypeGetters(value, reflectable, testName);
276
277
232
        checkNonCompound(reflectable);
278
232
        checkNonArray(reflectable);
279
280
232
        checkWriteRead(value, reflectable, readFunc, bitSize);
281
232
    }
282
283
    template <typename T, typename REFLECTABLE_PTR, typename GETTER, typename READ_FUNC>
284
    void checkSignedIntegral(T value, const REFLECTABLE_PTR& reflectable, const GETTER& getter,
285
            const READ_FUNC& readFunc, size_t bitSize = sizeof(T) * 8)
286
114
    {
287
114
        ASSERT_EQ(value, reflectable->toInt());
288
114
        ASSERT_THROW(reflectable->toUInt(), CppRuntimeException);
289
290
114
        checkIntegral(value, reflectable, getter, readFunc, bitSize, "checkSignedIntegral");
291
114
    }
292
293
    template <typename T, typename REFLECTABLE_PTR, typename GETTER, typename READ_FUNC>
294
    void checkUnsignedIntegral(T value, const REFLECTABLE_PTR& reflectable, const GETTER& getter,
295
            const READ_FUNC& readFunc, size_t bitSize = sizeof(T) * 8)
296
118
    {
297
118
        ASSERT_EQ(value, reflectable->toUInt());
298
118
        ASSERT_THROW(reflectable->toInt(), CppRuntimeException);
299
300
118
        checkIntegral(value, reflectable, getter, readFunc, bitSize, "checkUnsignedIntegral");
301
118
    }
302
303
    template <typename REFLECTABLE_PTR>
304
    void checkString(StringView value, const REFLECTABLE_PTR& reflectable)
305
11
    {
306
11
        ASSERT_EQ(value, reflectable->getAnyValue().template get<StringView>());
307
308
11
        ASSERT_EQ(toString(value), reflectable->toString());
309
11
        ASSERT_THROW(reflectable->toInt(), CppRuntimeException);
310
11
        ASSERT_THROW(reflectable->toUInt(), CppRuntimeException);
311
11
        ASSERT_THROW(reflectable->toDouble(), CppRuntimeException);
312
313
11
        checkCppTypeGetters(value, reflectable, "checkString");
314
315
11
        checkNonCompound(reflectable);
316
11
        checkNonArray(reflectable);
317
318
11
        checkWriteRead(toString(value), reflectable,
319
11
                std::bind(&BitStreamReader::readString<>, _1, std::allocator<uint8_t>()),
320
11
                bitSizeOfVarSize(convertSizeToUInt32(value.size())) + value.size() * 8);
321
11
    }
322
323
    template <typename REFLECTABLE_PTR>
324
    void checkBitBuffer(const BitBuffer& value, const REFLECTABLE_PTR& reflectable)
325
7
    {
326
7
        ASSERT_EQ(value,
327
7
                reflectable->getAnyValue().template get<std::reference_wrapper<const BitBuffer>>().get());
328
329
7
        ASSERT_THROW(reflectable->toString(), CppRuntimeException);
330
7
        ASSERT_THROW(reflectable->toDouble(), CppRuntimeException);
331
7
        ASSERT_THROW(reflectable->toInt(), CppRuntimeException);
332
7
        ASSERT_THROW(reflectable->toUInt(), CppRuntimeException);
333
334
7
        checkCppTypeGetters(value, reflectable, "checkBitBuffer");
335
336
7
        checkNonCompound(reflectable);
337
7
        checkNonArray(reflectable);
338
339
7
        checkWriteRead(value, reflectable,
340
7
                std::bind(&BitStreamReader::readBitBuffer<>, _1, std::allocator<uint8_t>()),
341
7
                bitSizeOfVarSize(convertSizeToUInt32(value.getBitSize())) + value.getBitSize());
342
7
    }
343
344
    template <typename REFLECTABLE_PTR>
345
    void checkBytes(const std::vector<uint8_t>& value, const REFLECTABLE_PTR& reflectable)
346
7
    {
347
7
        ASSERT_EQ(value.data(), reflectable->getBytes().data());
348
7
        ASSERT_EQ(value.size(), reflectable->getBytes().size());
349
7
        auto anyValue = reflectable->getAnyValue().template get<Span<const uint8_t>>();
350
7
        ASSERT_EQ(value.data(), anyValue.data());
351
7
        ASSERT_EQ(value.size(), anyValue.size());
352
353
7
        ASSERT_THROW(reflectable->toString(), CppRuntimeException);
354
7
        ASSERT_THROW(reflectable->toDouble(), CppRuntimeException);
355
7
        ASSERT_THROW(reflectable->toInt(), CppRuntimeException);
356
7
        ASSERT_THROW(reflectable->toUInt(), CppRuntimeException);
357
358
7
        checkCppTypeGetters(Span<const uint8_t>(value), reflectable, "checkBytes");
359
360
7
        checkNonCompound(reflectable);
361
7
        checkNonArray(reflectable);
362
363
7
        const size_t bitSize = value.size() * 8;
364
7
        checkWriteRead(value, reflectable,
365
7
                std::bind(&BitStreamReader::readBytes<>, _1, std::allocator<uint8_t>()),
366
7
                bitSizeOfVarSize(convertSizeToUInt32(bitSize)) + bitSize);
367
7
    }
368
369
    template <typename REFLECTABLE_PTR>
370
    void checkBitmask(ReflectableBitmask bitmask, const REFLECTABLE_PTR& reflectable)
371
11
    {
372
11
        ASSERT_EQ(bitmask.getValue(), reflectable->getUInt8());
373
374
11
        ASSERT_EQ(bitmask, reflectable->getAnyValue().template get<ReflectableBitmask>());
375
376
11
        ASSERT_EQ(bitmask.getValue(), reflectable->toUInt());
377
11
        ASSERT_EQ(bitmask.getValue(), reflectable->toDouble());
378
11
        ASSERT_EQ(bitmask.toString(), reflectable->toString());
379
11
        ASSERT_THROW(reflectable->toInt(), CppRuntimeException);
380
381
11
        checkCppTypeGetters(bitmask.getValue(), reflectable, "checkBitmask");
382
383
11
        checkNonCompound(reflectable);
384
11
        checkNonArray(reflectable);
385
386
11
        checkWriteRead(
387
11
                bitmask, reflectable, [](BitStreamReader& reader) { return ReflectableBitmask(reader); }, 8);
388
11
    }
389
390
    template <typename REFLECTABLE_PTR>
391
    void checkEnum(ReflectableEnum enumeration, const REFLECTABLE_PTR& reflectable)
392
10
    {
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
10
        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(
408
10
                enumeration, reflectable,
409
10
                [](BitStreamReader& reader) { return zserio::read<ReflectableEnum>(reader); }, 8);
410
10
    }
411
412
    void checkCompoundAnyValue(
413
            const ReflectableObject& reflectableObject, const IReflectableConstPtr& reflectable)
414
8
    {
415
8
        ASSERT_EQ(reflectableObject,
416
8
                reflectable->getAnyValue()
417
8
                        .template get<std::reference_wrapper<const ReflectableObject>>()
418
8
                        .get());
419
8
        ASSERT_EQ(reflectableObject.getReflectableNested(),
420
8
                reflectable->getField("reflectableNested")
421
8
                        ->getAnyValue()
422
8
                        .template get<std::reference_wrapper<const ReflectableNested>>()
423
8
                        .get());
424
8
    }
425
426
    void checkCompoundAnyValue(const ReflectableObject& reflectableObject, const IReflectablePtr& reflectable)
427
3
    {
428
3
        ASSERT_EQ(reflectableObject,
429
3
                reflectable->getAnyValue().template get<std::reference_wrapper<ReflectableObject>>().get());
430
3
        ASSERT_EQ(reflectableObject.getReflectableNested(),
431
3
                reflectable->getField("reflectableNested")
432
3
                        ->getAnyValue()
433
3
                        .template get<std::reference_wrapper<ReflectableNested>>()
434
3
                        .get());
435
3
    }
436
437
    template <typename REFLECTABLE_PTR>
438
    void checkCompoundConstMethods(
439
            const ReflectableObject& reflectableObject, const REFLECTABLE_PTR& reflectable)
440
11
    {
441
11
        ASSERT_TRUE(TypeInfoUtil::isCompound(reflectable->getTypeInfo().getSchemaType()));
442
443
        // field getter
444
11
        ASSERT_EQ(reflectableObject.getReflectableNested().getValue(),
445
11
                reflectable->getField("reflectableNested")->getField("value")->getUInt32());
446
11
        ASSERT_THROW(reflectable->getField("nonexistent"), CppRuntimeException);
447
11
        ASSERT_THROW(reflectable->getField("reflectableNested")->getField("nonexistent"), CppRuntimeException);
448
449
        // find field
450
11
        ASSERT_EQ(reflectableObject.getReflectableNested().getValue(),
451
11
                reflectable->find("reflectableNested.value")->toUInt());
452
11
        ASSERT_EQ(reflectableObject.getReflectableNested().getValue(),
453
11
                (*reflectable)["reflectableNested.value"]->toDouble());
454
455
        // find parameter
456
11
        ASSERT_NO_THROW(reflectable->getField("reflectableNested")->getParameter("dummyParam"));
457
11
        ASSERT_EQ(13, (*reflectable)["reflectableNested.dummyParam"]->getInt32());
458
11
        ASSERT_NO_THROW(reflectable->getField("reflectableNested")->getParameter("stringParam"));
459
11
        ASSERT_EQ(reflectableObject.getStringField(),
460
11
                (*reflectable)["reflectableNested.stringParam"]->toString());
461
11
        ASSERT_THROW(
462
11
                reflectable->getField("reflectableNested")->getParameter("nonexistent"), CppRuntimeException);
463
464
        // find function
465
11
        ASSERT_EQ(reflectableObject.getReflectableNested().getValue(),
466
11
                (*reflectable)["reflectableNested.getValue"]->getUInt32());
467
11
        ASSERT_THROW(
468
11
                reflectable->getField("reflectableNested")->callFunction("nonexistent"), CppRuntimeException);
469
470
        // find failed
471
11
        ASSERT_EQ(nullptr, reflectable->find("reflectableNested.nonexistent"));
472
11
        ASSERT_EQ(nullptr, reflectable->find("nonexistent"));
473
11
        ASSERT_EQ(nullptr, reflectable->find("reflectableNested.value.nonexistent"));
474
11
        ASSERT_EQ(nullptr, reflectable->find("reflectableNested.dummyParam.nonexistent"));
475
11
        ASSERT_EQ(nullptr, reflectable->find("reflectableNested.getValue.nonexistent"));
476
        // find failed because the underlying code throws
477
11
        ASSERT_EQ(nullptr, reflectable->find("reflectableNested.throwingFunction.nonexistent"));
478
479
11
        checkCompoundAnyValue(reflectableObject, reflectable);
480
481
11
        ASSERT_THROW(reflectable->getBool(), CppRuntimeException);
482
11
        ASSERT_THROW(reflectable->getInt8(), CppRuntimeException);
483
11
        ASSERT_THROW(reflectable->getInt16(), CppRuntimeException);
484
11
        ASSERT_THROW(reflectable->getInt32(), CppRuntimeException);
485
11
        ASSERT_THROW(reflectable->getInt64(), CppRuntimeException);
486
11
        ASSERT_THROW(reflectable->getUInt8(), CppRuntimeException);
487
11
        ASSERT_THROW(reflectable->getUInt16(), CppRuntimeException);
488
11
        ASSERT_THROW(reflectable->getUInt32(), CppRuntimeException);
489
11
        ASSERT_THROW(reflectable->getUInt64(), CppRuntimeException);
490
11
        ASSERT_THROW(reflectable->getFloat(), CppRuntimeException);
491
11
        ASSERT_THROW(reflectable->getDouble(), CppRuntimeException);
492
11
        ASSERT_THROW(reflectable->getBytes(), CppRuntimeException);
493
11
        ASSERT_THROW(reflectable->getStringView(), CppRuntimeException);
494
11
        ASSERT_THROW(reflectable->getBitBuffer(), CppRuntimeException);
495
496
11
        ASSERT_THROW(reflectable->toInt(), CppRuntimeException);
497
11
        ASSERT_THROW(reflectable->toUInt(), CppRuntimeException);
498
11
        ASSERT_THROW(reflectable->toDouble(), CppRuntimeException);
499
11
        ASSERT_THROW(reflectable->toString(), CppRuntimeException);
500
501
11
        checkNonArray(reflectable);
502
503
11
        checkWriteRead(
504
11
                reflectableObject, reflectable,
505
11
                [](BitStreamReader& reader) { return ReflectableObject(reader); },
506
11
                reflectableObject.bitSizeOf());
507
11
    }
508
509
    void checkCompound(const ReflectableObject& reflectableObject, const IReflectableConstPtr& reflectable)
510
5
    {
511
5
        checkCompoundConstMethods(reflectableObject, reflectable);
512
5
    }
513
514
    void checkCompound(const ReflectableObject& reflectableObject, const IReflectablePtr& reflectable)
515
3
    {
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
3
        ASSERT_THROW(reflectable->setField("nonexistent", AnyHolder<>()), CppRuntimeException);
523
3
        ASSERT_THROW(reflectable->find("reflectableNested")->setField("nonexistent", AnyHolder<>()),
524
3
                CppRuntimeException);
525
526
        // any value
527
3
        ASSERT_EQ(reflectableObject.getReflectableNested(),
528
3
                reflectable->find("reflectableNested")
529
3
                        ->getAnyValue()
530
3
                        .template get<std::reference_wrapper<ReflectableNested>>()
531
3
                        .get());
532
533
3
        reflectable->createField("reflectableNested");
534
3
        ASSERT_EQ(uint32_t(), reflectableObject.getReflectableNested().getValue());
535
536
3
        reflectable->setField("reflectableNested", AnyHolder<>(ReflectableNested{42}));
537
3
        ASSERT_EQ(42, reflectableObject.getReflectableNested().getValue());
538
3
        reflectable->initializeChildren(); // keep the reflectable initialized for following tests
539
3
    }
540
};
541
542
TEST_F(ReflectableTest, boolReflectable)
543
1
{
544
1
    const bool value = true;
545
1
    auto reflectable = ReflectableFactory::getBool(value);
546
1
    checkUnsignedIntegral(
547
1
            value, reflectable, &IReflectable::getBool, std::bind(&BitStreamReader::readBool, _1));
548
1
}
549
550
TEST_F(ReflectableTest, int8Reflectable)
551
1
{
552
1
    const int8_t value = -12;
553
1
    auto reflectable = ReflectableFactory::getInt8(value);
554
1
    checkSignedIntegral(
555
1
            value, reflectable, &IReflectable::getInt8, std::bind(&BitStreamReader::readSignedBits, _1, 8));
556
1
}
557
558
TEST_F(ReflectableTest, int16Reflectable)
559
1
{
560
1
    const int16_t value = -1234;
561
1
    auto reflectable = ReflectableFactory::getInt16(value);
562
1
    checkSignedIntegral(
563
1
            value, reflectable, &IReflectable::getInt16, std::bind(&BitStreamReader::readSignedBits, _1, 16));
564
1
}
565
566
TEST_F(ReflectableTest, int32Reflectable)
567
1
{
568
1
    const int32_t value = -123456;
569
1
    auto reflectable = ReflectableFactory::getInt32(value);
570
1
    checkSignedIntegral(
571
1
            value, reflectable, &IReflectable::getInt32, std::bind(&BitStreamReader::readSignedBits, _1, 32));
572
1
}
573
574
TEST_F(ReflectableTest, int64Reflectable)
575
1
{
576
1
    const int64_t value = -1234567890;
577
1
    auto reflectable = ReflectableFactory::getInt64(value);
578
1
    checkSignedIntegral(
579
1
            value, reflectable, &IReflectable::getInt64, std::bind(&BitStreamReader::readSignedBits64, _1, 64));
580
1
}
581
582
TEST_F(ReflectableTest, uint8Reflectable)
583
1
{
584
1
    const uint8_t value = 0xFF;
585
1
    auto reflectable = ReflectableFactory::getUInt8(value);
586
1
    checkUnsignedIntegral(
587
1
            value, reflectable, &IReflectable::getUInt8, std::bind(&BitStreamReader::readBits, _1, 8));
588
1
}
589
590
TEST_F(ReflectableTest, uint16Reflectable)
591
1
{
592
1
    const uint16_t value = 0xFFFF;
593
1
    auto reflectable = ReflectableFactory::getUInt16(value);
594
1
    checkUnsignedIntegral(
595
1
            value, reflectable, &IReflectable::getUInt16, std::bind(&BitStreamReader::readBits, _1, 16));
596
1
}
597
598
TEST_F(ReflectableTest, uint32Reflectable)
599
1
{
600
1
    const uint32_t value = 0xFFFFFFFF;
601
1
    auto reflectable = ReflectableFactory::getUInt32(value);
602
1
    checkUnsignedIntegral(
603
1
            value, reflectable, &IReflectable::getUInt32, std::bind(&BitStreamReader::readBits, _1, 32));
604
1
}
605
606
TEST_F(ReflectableTest, uint64Reflectable)
607
1
{
608
1
    const uint64_t value = 0xFFFFFFFFFFFF;
609
1
    auto reflectable = ReflectableFactory::getUInt64(value);
610
1
    checkUnsignedIntegral(
611
1
            value, reflectable, &IReflectable::getUInt64, std::bind(&BitStreamReader::readBits64, _1, 64));
612
1
}
613
614
TEST_F(ReflectableTest, fixedSignedBitField5) // mapped to int8_t
615
1
{
616
1
    const uint8_t numBits = 5;
617
1
    const int8_t value = 15;
618
1
    auto reflectable = ReflectableFactory::getFixedSignedBitField(value, numBits);
619
1
    checkSignedIntegral(value, reflectable, &IReflectable::getInt8,
620
1
            std::bind(&BitStreamReader::readSignedBits, _1, numBits), numBits);
621
622
1
    ASSERT_THROW(ReflectableFactory::getFixedSignedBitField(value, 10), CppRuntimeException);
623
1
}
624
625
TEST_F(ReflectableTest, fixedSignedBitField15) // mapped to int16_t
626
1
{
627
1
    const uint8_t numBits = 15;
628
1
    const int16_t value = -15;
629
1
    auto reflectable = ReflectableFactory::getFixedSignedBitField(value, numBits);
630
1
    checkSignedIntegral(value, reflectable, &IReflectable::getInt16,
631
1
            std::bind(&BitStreamReader::readSignedBits, _1, numBits), numBits);
632
633
1
    ASSERT_THROW(ReflectableFactory::getFixedSignedBitField(value, 5), CppRuntimeException);
634
1
    ASSERT_THROW(ReflectableFactory::getFixedSignedBitField(value, 17), CppRuntimeException);
635
1
}
636
637
TEST_F(ReflectableTest, fixedSignedBitField31) // mapped to int32_t
638
1
{
639
1
    const uint8_t numBits = 31;
640
1
    const int32_t value = -12345678;
641
1
    auto reflectable = ReflectableFactory::getFixedSignedBitField(value, numBits);
642
1
    checkSignedIntegral(value, reflectable, &IReflectable::getInt32,
643
1
            std::bind(&BitStreamReader::readSignedBits, _1, numBits), numBits);
644
645
1
    ASSERT_THROW(ReflectableFactory::getFixedSignedBitField(value, 16), CppRuntimeException);
646
1
    ASSERT_THROW(ReflectableFactory::getFixedSignedBitField(value, 33), CppRuntimeException);
647
1
}
648
649
TEST_F(ReflectableTest, fixedSignedBitField60) // mapped to int64_t
650
1
{
651
1
    const uint8_t numBits = 60;
652
1
    const int64_t value = 1234567890;
653
1
    auto reflectable = ReflectableFactory::getFixedSignedBitField(value, numBits);
654
1
    checkSignedIntegral(value, reflectable, &IReflectable::getInt64,
655
1
            std::bind(&BitStreamReader::readSignedBits64, _1, numBits), numBits);
656
657
1
    ASSERT_THROW(ReflectableFactory::getFixedSignedBitField(value, 31), CppRuntimeException);
658
1
    ASSERT_THROW(ReflectableFactory::getFixedSignedBitField(value, 65), CppRuntimeException);
659
1
}
660
661
TEST_F(ReflectableTest, fixedUnsignedBitField7) // mapped to uint8_t
662
1
{
663
1
    const uint8_t numBits = 7;
664
1
    const uint8_t value = 0x2F;
665
1
    auto reflectable = ReflectableFactory::getFixedUnsignedBitField(value, numBits);
666
1
    checkUnsignedIntegral(value, reflectable, &IReflectable::getUInt8,
667
1
            std::bind(&BitStreamReader::readBits, _1, numBits), numBits);
668
669
1
    ASSERT_THROW(ReflectableFactory::getFixedUnsignedBitField(value, 9), CppRuntimeException);
670
1
}
671
672
TEST_F(ReflectableTest, fixedUnsignedBitField9) // mapped to uint16_t
673
1
{
674
1
    const uint8_t numBits = 9;
675
1
    const uint16_t value = 0x1FF;
676
1
    auto reflectable = ReflectableFactory::getFixedUnsignedBitField(value, numBits);
677
1
    checkUnsignedIntegral(value, reflectable, &IReflectable::getUInt16,
678
1
            std::bind(&BitStreamReader::readBits, _1, numBits), numBits);
679
680
1
    ASSERT_THROW(ReflectableFactory::getFixedUnsignedBitField(value, 8), CppRuntimeException);
681
1
    ASSERT_THROW(ReflectableFactory::getFixedUnsignedBitField(value, 17), CppRuntimeException);
682
1
}
683
684
TEST_F(ReflectableTest, fixedUnsignedBitField31) // mapped to uint32_t
685
1
{
686
1
    const uint8_t numBits = 31;
687
1
    const uint32_t value = UINT32_MAX >> 1;
688
1
    auto reflectable = ReflectableFactory::getFixedUnsignedBitField(value, numBits);
689
1
    checkUnsignedIntegral(value, reflectable, &IReflectable::getUInt32,
690
1
            std::bind(&BitStreamReader::readBits, _1, numBits), numBits);
691
692
1
    ASSERT_THROW(ReflectableFactory::getFixedUnsignedBitField(value, 16), CppRuntimeException);
693
1
    ASSERT_THROW(ReflectableFactory::getFixedUnsignedBitField(value, 33), CppRuntimeException);
694
1
}
695
696
TEST_F(ReflectableTest, fixedUnsignedBitField33) // mapped to uint64_t
697
1
{
698
1
    const uint8_t numBits = 33;
699
1
    const uint64_t value = static_cast<uint64_t>(UINT32_MAX) << 1U;
700
1
    auto reflectable = ReflectableFactory::getFixedUnsignedBitField(value, numBits);
701
1
    checkUnsignedIntegral(value, reflectable, &IReflectable::getUInt64,
702
1
            std::bind(&BitStreamReader::readBits64, _1, numBits), numBits);
703
704
1
    ASSERT_THROW(ReflectableFactory::getFixedUnsignedBitField(value, 32), CppRuntimeException);
705
1
    ASSERT_THROW(ReflectableFactory::getFixedUnsignedBitField(value, 65), CppRuntimeException);
706
1
}
707
708
TEST_F(ReflectableTest, dynamicSignedBitField5) // mapped to int8_t
709
1
{
710
1
    const uint8_t maxBitSize = 8;
711
1
    const uint8_t numBits = 5;
712
1
    const int8_t value = 15;
713
1
    auto reflectable = ReflectableFactory::getDynamicSignedBitField(value, maxBitSize, numBits);
714
1
    checkSignedIntegral(value, reflectable, &IReflectable::getInt8,
715
1
            std::bind(&BitStreamReader::readSignedBits, _1, numBits), numBits);
716
717
    // maxBitSize out of bounds
718
1
    ASSERT_THROW(ReflectableFactory::getDynamicSignedBitField(value, 9, numBits), CppRuntimeException);
719
720
    // dynamicBitSize out of bounds
721
1
    ASSERT_THROW(ReflectableFactory::getDynamicSignedBitField(value, 4, numBits), CppRuntimeException);
722
1
}
723
724
TEST_F(ReflectableTest, dynamicSignedBitField15) // mapped to int16_t
725
1
{
726
1
    const uint8_t maxBitSize = 16;
727
1
    const uint8_t numBits = 15;
728
1
    const int16_t value = -15;
729
1
    auto reflectable = ReflectableFactory::getDynamicSignedBitField(value, maxBitSize, numBits);
730
1
    checkSignedIntegral(value, reflectable, &IReflectable::getInt16,
731
1
            std::bind(&BitStreamReader::readSignedBits, _1, numBits), numBits);
732
733
    // maxBitSize out of bounds
734
1
    ASSERT_THROW(ReflectableFactory::getDynamicSignedBitField(value, 8, numBits), CppRuntimeException);
735
1
    ASSERT_THROW(ReflectableFactory::getDynamicSignedBitField(value, 17, numBits), CppRuntimeException);
736
737
    // dynamicBitSize out of bounds
738
1
    ASSERT_THROW(ReflectableFactory::getDynamicSignedBitField(value, 12, numBits), CppRuntimeException);
739
1
}
740
741
TEST_F(ReflectableTest, dynamicSignedBitField31) // mapped to int32_t
742
1
{
743
1
    const uint8_t maxBitSize = 32;
744
1
    const uint8_t numBits = 31;
745
1
    const int32_t value = -12345678;
746
1
    auto reflectable = ReflectableFactory::getDynamicSignedBitField(value, maxBitSize, numBits);
747
1
    checkSignedIntegral(value, reflectable, &IReflectable::getInt32,
748
1
            std::bind(&BitStreamReader::readSignedBits, _1, numBits), numBits);
749
750
    // maxBitSize out of bounds
751
1
    ASSERT_THROW(ReflectableFactory::getDynamicSignedBitField(value, 16, numBits), CppRuntimeException);
752
1
    ASSERT_THROW(ReflectableFactory::getDynamicSignedBitField(value, 33, numBits), CppRuntimeException);
753
754
    // dynamicBitSize out of bounds
755
1
    ASSERT_THROW(ReflectableFactory::getDynamicSignedBitField(value, 29, numBits), CppRuntimeException);
756
1
}
757
758
TEST_F(ReflectableTest, dynamicSignedBitField60) // mapped to int64_t
759
1
{
760
1
    const uint8_t maxBitSize = 64;
761
1
    const uint8_t numBits = 60;
762
1
    const int64_t value = 1234567890;
763
1
    auto reflectable = ReflectableFactory::getDynamicSignedBitField(value, maxBitSize, numBits);
764
1
    checkSignedIntegral(value, reflectable, &IReflectable::getInt64,
765
1
            std::bind(&BitStreamReader::readSignedBits64, _1, numBits), numBits);
766
767
    // maxBitSize out of bounds
768
1
    ASSERT_THROW(ReflectableFactory::getDynamicSignedBitField(value, 32, numBits), CppRuntimeException);
769
1
    ASSERT_THROW(ReflectableFactory::getDynamicSignedBitField(value, 65, numBits), CppRuntimeException);
770
771
    // dynamicBitSize out of bounds
772
1
    ASSERT_THROW(ReflectableFactory::getDynamicSignedBitField(value, 58, numBits), CppRuntimeException);
773
774
    // dynamic signed bit field as a type reference (maxBitSize must be 64!)
775
1
    ASSERT_NO_THROW(ReflectableFactory::getDynamicSignedBitField(value, 64));
776
1
    ASSERT_THROW(ReflectableFactory::getDynamicSignedBitField(value, 58), CppRuntimeException);
777
1
}
778
779
TEST_F(ReflectableTest, dynamicUnsignedBitField7) // mapped to uint8_t
780
1
{
781
1
    const uint8_t maxBitSize = 8;
782
1
    const uint8_t numBits = 7;
783
1
    const uint8_t value = 0x2F;
784
1
    auto reflectable = ReflectableFactory::getDynamicUnsignedBitField(value, maxBitSize, numBits);
785
1
    checkUnsignedIntegral(value, reflectable, &IReflectable::getUInt8,
786
1
            std::bind(&BitStreamReader::readBits, _1, numBits), numBits);
787
788
    // maxBitSize out of bounds
789
1
    ASSERT_THROW(ReflectableFactory::getDynamicUnsignedBitField(value, 9, numBits), CppRuntimeException);
790
791
    // dynamicBitSize out of bounds
792
1
    ASSERT_THROW(ReflectableFactory::getDynamicUnsignedBitField(value, 6, numBits), CppRuntimeException);
793
1
}
794
795
TEST_F(ReflectableTest, dynamicUnsignedBitField9) // mapped to uint16_t
796
1
{
797
1
    const uint8_t maxBitSize = 16;
798
1
    const uint8_t numBits = 9;
799
1
    const uint16_t value = 0x1FF;
800
1
    auto reflectable = ReflectableFactory::getDynamicUnsignedBitField(value, maxBitSize, numBits);
801
1
    checkUnsignedIntegral(value, reflectable, &IReflectable::getUInt16,
802
1
            std::bind(&BitStreamReader::readBits, _1, numBits), numBits);
803
804
    // maxBitSize out of bounds
805
1
    ASSERT_THROW(ReflectableFactory::getDynamicUnsignedBitField(value, 8, numBits), CppRuntimeException);
806
1
    ASSERT_THROW(ReflectableFactory::getDynamicUnsignedBitField(value, 17, numBits), CppRuntimeException);
807
808
    // dynamicBitSize out of bounds
809
1
    ASSERT_THROW(ReflectableFactory::getDynamicUnsignedBitField(value, 9, 10), CppRuntimeException);
810
1
}
811
812
TEST_F(ReflectableTest, dynamicUnsignedBitField31) // mapped to uint32_t
813
1
{
814
1
    const uint8_t maxBitSize = 32;
815
1
    const uint8_t numBits = 31;
816
1
    const uint32_t value = UINT32_MAX >> 1;
817
1
    auto reflectable = ReflectableFactory::getDynamicUnsignedBitField(value, maxBitSize, numBits);
818
1
    checkUnsignedIntegral(value, reflectable, &IReflectable::getUInt32,
819
1
            std::bind(&BitStreamReader::readBits, _1, numBits), numBits);
820
821
    // maxBitSize out of bounds
822
1
    ASSERT_THROW(ReflectableFactory::getDynamicUnsignedBitField(value, 16, numBits), CppRuntimeException);
823
1
    ASSERT_THROW(ReflectableFactory::getDynamicUnsignedBitField(value, 33, numBits), CppRuntimeException);
824
825
    // dynamicBitSize out of bounds
826
1
    ASSERT_THROW(ReflectableFactory::getDynamicUnsignedBitField(value, 29, numBits), CppRuntimeException);
827
1
}
828
829
TEST_F(ReflectableTest, dynamicUnsignedBitField33) // mapped to uint64_t
830
1
{
831
1
    const uint8_t maxBitSize = 64;
832
1
    const uint8_t numBits = 33;
833
1
    const uint64_t value = static_cast<uint64_t>(UINT32_MAX) << 1U;
834
1
    auto reflectable = ReflectableFactory::getDynamicUnsignedBitField(value, maxBitSize, numBits);
835
1
    checkUnsignedIntegral(value, reflectable, &IReflectable::getUInt64,
836
1
            std::bind(&BitStreamReader::readBits64, _1, numBits), numBits);
837
838
    // maxBitSize out of bounds
839
1
    ASSERT_THROW(ReflectableFactory::getDynamicUnsignedBitField(value, 32, numBits), CppRuntimeException);
840
1
    ASSERT_THROW(ReflectableFactory::getDynamicUnsignedBitField(value, 65, numBits), CppRuntimeException);
841
842
    // dynamicBitSize out of bounds
843
1
    ASSERT_THROW(ReflectableFactory::getDynamicUnsignedBitField(value, 33, 34), CppRuntimeException);
844
845
    // dynamic unsigned bit field as a type reference (maxBitSize must be 64!)
846
1
    ASSERT_NO_THROW(ReflectableFactory::getDynamicUnsignedBitField(value, 64));
847
1
    ASSERT_THROW(ReflectableFactory::getDynamicUnsignedBitField(value, 58), CppRuntimeException);
848
1
}
849
850
TEST_F(ReflectableTest, varint16Reflectable)
851
1
{
852
1
    const int16_t value = -1234;
853
1
    auto reflectable = ReflectableFactory::getVarInt16(value);
854
1
    checkSignedIntegral(value, reflectable, &IReflectable::getInt16,
855
1
            std::bind(&BitStreamReader::readVarInt16, _1), bitSizeOfVarInt16(value));
856
1
}
857
858
TEST_F(ReflectableTest, varint32Reflectable)
859
1
{
860
1
    const int32_t value = 54321;
861
1
    auto reflectable = ReflectableFactory::getVarInt32(value);
862
1
    checkSignedIntegral(value, reflectable, &IReflectable::getInt32,
863
1
            std::bind(&BitStreamReader::readVarInt32, _1), bitSizeOfVarInt32(value));
864
1
}
865
866
TEST_F(ReflectableTest, varint64Reflectable)
867
1
{
868
1
    const int64_t value = -87654321;
869
1
    auto reflectable = ReflectableFactory::getVarInt64(value);
870
1
    checkSignedIntegral(value, reflectable, &IReflectable::getInt64,
871
1
            std::bind(&BitStreamReader::readVarInt64, _1), bitSizeOfVarInt64(value));
872
1
}
873
874
TEST_F(ReflectableTest, varintReflectable)
875
1
{
876
1
    const int64_t value = INT64_MAX;
877
1
    auto reflectable = ReflectableFactory::getVarInt(value);
878
1
    checkSignedIntegral(value, reflectable, &IReflectable::getInt64,
879
1
            std::bind(&BitStreamReader::readVarInt, _1), bitSizeOfVarInt(value));
880
1
}
881
882
TEST_F(ReflectableTest, varuint16Reflectable)
883
1
{
884
1
    const uint16_t value = 1234;
885
1
    auto reflectable = ReflectableFactory::getVarUInt16(value);
886
1
    checkUnsignedIntegral(value, reflectable, &IReflectable::getUInt16,
887
1
            std::bind(&BitStreamReader::readVarUInt16, _1), bitSizeOfVarUInt16(value));
888
1
}
889
890
TEST_F(ReflectableTest, varuint32Reflectable)
891
1
{
892
1
    const uint32_t value = 0x1FFFFFFF;
893
1
    auto reflectable = ReflectableFactory::getVarUInt32(value);
894
1
    checkUnsignedIntegral(value, reflectable, &IReflectable::getUInt32,
895
1
            std::bind(&BitStreamReader::readVarUInt32, _1), bitSizeOfVarUInt32(value));
896
1
}
897
898
TEST_F(ReflectableTest, varuint64Reflectable)
899
1
{
900
1
    const uint64_t value = 4242424242;
901
1
    auto reflectable = ReflectableFactory::getVarUInt64(value);
902
1
    checkUnsignedIntegral(value, reflectable, &IReflectable::getUInt64,
903
1
            std::bind(&BitStreamReader::readVarUInt64, _1), bitSizeOfVarUInt64(value));
904
1
}
905
906
TEST_F(ReflectableTest, varuintReflectable)
907
1
{
908
1
    const uint64_t value = UINT64_MAX;
909
1
    auto reflectable = ReflectableFactory::getVarUInt(value);
910
1
    checkUnsignedIntegral(value, reflectable, &IReflectable::getUInt64,
911
1
            std::bind(&BitStreamReader::readVarUInt, _1), bitSizeOfVarUInt(value));
912
1
}
913
914
TEST_F(ReflectableTest, varsizeReflectable)
915
1
{
916
1
    const uint32_t value = (UINT32_C(1) << (7 + 7 + 7 + 7 + 3)) - 1;
917
1
    auto reflectable = ReflectableFactory::getVarSize(value);
918
1
    checkUnsignedIntegral(value, reflectable, &IReflectable::getUInt32,
919
1
            std::bind(&BitStreamReader::readVarSize, _1), bitSizeOfVarSize(value));
920
1
}
921
922
TEST_F(ReflectableTest, float16Reflectable)
923
1
{
924
1
    const float value = 2.0F;
925
1
    auto reflectable = ReflectableFactory::getFloat16(value);
926
1
    checkFloatingPoint(
927
1
            value, reflectable, &IReflectable::getFloat, std::bind(&BitStreamReader::readFloat16, _1));
928
1
}
929
930
TEST_F(ReflectableTest, float32Reflectable)
931
1
{
932
1
    const float value = 1.2F;
933
1
    auto reflectable = ReflectableFactory::getFloat32(value);
934
1
    checkFloatingPoint(
935
1
            value, reflectable, &IReflectable::getFloat, std::bind(&BitStreamReader::readFloat32, _1));
936
1
}
937
938
TEST_F(ReflectableTest, float64Reflectable)
939
1
{
940
1
    const double value = 1.2;
941
1
    auto reflectable = ReflectableFactory::getFloat64(value);
942
1
    checkFloatingPoint(
943
1
            value, reflectable, &IReflectable::getDouble, std::bind(&BitStreamReader::readFloat64, _1));
944
1
}
945
946
TEST_F(ReflectableTest, stringReflectable)
947
1
{
948
1
    const std::string value = "some longer string value to have a chance that some allocation hopefully occurs";
949
1
    auto reflectable = ReflectableFactory::getString(value);
950
1
    checkString(value, reflectable);
951
1
}
952
953
TEST_F(ReflectableTest, stringViewReflectable)
954
1
{
955
1
    auto view = makeStringView("some text as a string view");
956
1
    auto reflectable = ReflectableFactory::getString(view);
957
1
    checkString(view, reflectable);
958
1
}
959
960
TEST_F(ReflectableTest, bitBufferReflectable)
961
1
{
962
1
    const BitBuffer value = BitBuffer{std::vector<uint8_t>({0xAB, 0xF0}), 12};
963
1
    auto reflectable = ReflectableFactory::getBitBuffer(value);
964
1
    checkBitBuffer(value, reflectable);
965
1
}
966
967
TEST_F(ReflectableTest, bytesReflectable)
968
1
{
969
1
    const vector<uint8_t> value{{0, 127, 128, 255}};
970
1
    auto reflectable = ReflectableFactory::getBytes(value);
971
1
    checkBytes(value, reflectable);
972
1
}
973
974
TEST_F(ReflectableTest, boolConstArray)
975
1
{
976
1
    const auto rawArray = std::vector<bool>({true, false, true, false});
977
1
    auto reflectable = ReflectableFactory::getBoolArray(rawArray);
978
4
    checkArray(rawArray, reflectable, [&](bool value, const IReflectableConstPtr& elementReflectable) {
979
4
        checkUnsignedIntegral(
980
4
                value, elementReflectable, &IReflectable::getBool, std::bind(&BitStreamReader::readBool, _1));
981
4
    });
982
1
}
983
984
TEST_F(ReflectableTest, boolArray)
985
1
{
986
1
    auto rawArray = std::vector<bool>({true, false, true, false});
987
1
    auto reflectable = ReflectableFactory::getBoolArray(rawArray);
988
4
    checkArray(rawArray, reflectable, [&](bool value, const IReflectableConstPtr& elementReflectable) {
989
4
        checkUnsignedIntegral(
990
4
                value, elementReflectable, &IReflectable::getBool, std::bind(&BitStreamReader::readBool, _1));
991
4
    });
992
1
}
993
994
TEST_F(ReflectableTest, int8ConstArray)
995
1
{
996
1
    const auto rawArray = std::vector<int8_t>({-10, -20, 30, 40});
997
1
    auto reflectable = ReflectableFactory::getInt8Array(rawArray);
998
4
    checkArray(rawArray, reflectable, [&](int8_t value, const IReflectableConstPtr& elementReflectable) {
999
4
        checkSignedIntegral(value, elementReflectable, &IReflectable::getInt8,
1000
4
                std::bind(&BitStreamReader::readSignedBits, _1, 8));
1001
4
    });
1002
1003
1
    auto nonConstReflectable = std::const_pointer_cast<IReflectable>(reflectable);
1004
1
    ASSERT_THROW(nonConstReflectable->getAnyValue(), CppRuntimeException);
1005
1
}
1006
1007
TEST_F(ReflectableTest, int8Array)
1008
1
{
1009
1
    auto rawArray = std::vector<int8_t>({-10, -20, 30, 40});
1010
1
    auto reflectable = ReflectableFactory::getInt8Array(rawArray);
1011
4
    checkArray(rawArray, reflectable, [&](int8_t value, const IReflectableConstPtr& elementReflectable) {
1012
4
        checkSignedIntegral(value, elementReflectable, &IReflectable::getInt8,
1013
4
                std::bind(&BitStreamReader::readSignedBits, _1, 8));
1014
4
    });
1015
1
    checkArray(rawArray, static_cast<IReflectableConstPtr>(reflectable),
1016
4
            [&](int8_t value, const IReflectableConstPtr& elementReflectable) {
1017
4
                checkSignedIntegral(value, elementReflectable, &IReflectable::getInt8,
1018
4
                        std::bind(&BitStreamReader::readSignedBits, _1, 8));
1019
4
            });
1020
1021
1
    reflectable->resize(0);
1022
1
    ASSERT_EQ(0, reflectable->size());
1023
1
    reflectable->append(AnyHolder<>(static_cast<int8_t>(13)));
1024
1
    ASSERT_EQ(1, reflectable->size());
1025
1
    ASSERT_EQ(13, reflectable->at(0)->getInt8());
1026
1
    reflectable->setAt(AnyHolder<>(static_cast<int8_t>(42)), 0);
1027
1
    ASSERT_EQ(1, reflectable->size());
1028
1
    ASSERT_EQ(42, reflectable->at(0)->getInt8());
1029
1
    reflectable->resize(2);
1030
1
    ASSERT_EQ(2, reflectable->size());
1031
1032
    // out of range
1033
1
    ASSERT_THROW(reflectable->setAt(AnyHolder<>(static_cast<int8_t>(-42)), 2), CppRuntimeException);
1034
1
}
1035
1036
TEST_F(ReflectableTest, int16ConstArray)
1037
1
{
1038
1
    const auto rawArray = std::vector<int16_t>({-100, -200, 300, 400});
1039
1
    auto reflectable = ReflectableFactory::getInt16Array(rawArray);
1040
4
    checkArray(rawArray, reflectable, [&](int16_t value, const IReflectableConstPtr& elementReflectable) {
1041
4
        checkSignedIntegral(value, elementReflectable, &IReflectable::getInt16,
1042
4
                std::bind(&BitStreamReader::readSignedBits, _1, 16));
1043
4
    });
1044
1
}
1045
1046
TEST_F(ReflectableTest, int16Array)
1047
1
{
1048
1
    auto rawArray = std::vector<int16_t>({-100, -200, 300, 400});
1049
1
    auto reflectable = ReflectableFactory::getInt16Array(rawArray);
1050
4
    checkArray(rawArray, reflectable, [&](int16_t value, const IReflectableConstPtr& elementReflectable) {
1051
4
        checkSignedIntegral(value, elementReflectable, &IReflectable::getInt16,
1052
4
                std::bind(&BitStreamReader::readSignedBits, _1, 16));
1053
4
    });
1054
1
}
1055
1056
TEST_F(ReflectableTest, int32ConstArray)
1057
1
{
1058
1
    const auto rawArray = std::vector<int32_t>({-10000, -20000, 30000, 40000});
1059
1
    auto reflectable = ReflectableFactory::getInt32Array(rawArray);
1060
4
    checkArray(rawArray, reflectable, [&](int32_t value, const IReflectableConstPtr& elementReflectable) {
1061
4
        checkSignedIntegral(value, elementReflectable, &IReflectable::getInt32,
1062
4
                std::bind(&BitStreamReader::readSignedBits, _1, 32));
1063
4
    });
1064
1
}
1065
1066
TEST_F(ReflectableTest, int32Array)
1067
1
{
1068
1
    auto rawArray = std::vector<int32_t>({-10000, -20000, 30000, 40000});
1069
1
    auto reflectable = ReflectableFactory::getInt32Array(rawArray);
1070
4
    checkArray(rawArray, reflectable, [&](int32_t value, const IReflectableConstPtr& elementReflectable) {
1071
4
        checkSignedIntegral(value, elementReflectable, &IReflectable::getInt32,
1072
4
                std::bind(&BitStreamReader::readSignedBits, _1, 32));
1073
4
    });
1074
1
}
1075
1076
TEST_F(ReflectableTest, int64ConstArray)
1077
1
{
1078
1
    const auto rawArray = std::vector<int64_t>({-10000000, -20000000, 30000000, 40000000});
1079
1
    auto reflectable = ReflectableFactory::getInt64Array(rawArray);
1080
4
    checkArray(rawArray, reflectable, [&](int64_t value, const IReflectableConstPtr& elementReflectable) {
1081
4
        checkSignedIntegral(value, elementReflectable, &IReflectable::getInt64,
1082
4
                std::bind(&BitStreamReader::readSignedBits64, _1, 64));
1083
4
    });
1084
1
}
1085
1086
TEST_F(ReflectableTest, int64Array)
1087
1
{
1088
1
    auto rawArray = std::vector<int64_t>({-10000000, -20000000, 30000000, 40000000});
1089
1
    auto reflectable = ReflectableFactory::getInt64Array(rawArray);
1090
4
    checkArray(rawArray, reflectable, [&](int64_t value, const IReflectableConstPtr& elementReflectable) {
1091
4
        checkSignedIntegral(value, elementReflectable, &IReflectable::getInt64,
1092
4
                std::bind(&BitStreamReader::readSignedBits64, _1, 64));
1093
4
    });
1094
1
}
1095
1096
TEST_F(ReflectableTest, uint8ConstArray)
1097
1
{
1098
1
    const auto rawArray = std::vector<uint8_t>({10, 20, 30, 40});
1099
1
    auto reflectable = ReflectableFactory::getUInt8Array(rawArray);
1100
4
    checkArray(rawArray, reflectable, [&](uint8_t value, const IReflectableConstPtr& elementReflectable) {
1101
4
        checkUnsignedIntegral(value, elementReflectable, &IReflectable::getUInt8,
1102
4
                std::bind(&BitStreamReader::readBits, _1, 8));
1103
4
    });
1104
1
}
1105
1106
TEST_F(ReflectableTest, uint8Array)
1107
1
{
1108
1
    auto rawArray = std::vector<uint8_t>{{10, 20, 30, 40}};
1109
1
    auto reflectable = ReflectableFactory::getUInt8Array(rawArray);
1110
4
    checkArray(rawArray, reflectable, [&](uint8_t value, const IReflectablePtr& elementReflectable) {
1111
4
        checkUnsignedIntegral(value, elementReflectable, &IReflectable::getUInt8,
1112
4
                std::bind(&BitStreamReader::readBits, _1, 8));
1113
4
    });
1114
1
}
1115
1116
TEST_F(ReflectableTest, uint16ConstArray)
1117
1
{
1118
1
    const auto rawArray = std::vector<uint16_t>({100, 200, 300, 400});
1119
1
    auto reflectable = ReflectableFactory::getUInt16Array(rawArray);
1120
4
    checkArray(rawArray, reflectable, [&](uint16_t value, const IReflectableConstPtr& elementReflectable) {
1121
4
        checkUnsignedIntegral(value, elementReflectable, &IReflectable::getUInt16,
1122
4
                std::bind(&BitStreamReader::readBits, _1, 16));
1123
4
    });
1124
1
}
1125
1126
TEST_F(ReflectableTest, uint16Array)
1127
1
{
1128
1
    auto rawArray = std::vector<uint16_t>{{100, 200, 300, 400}};
1129
1
    auto reflectable = ReflectableFactory::getUInt16Array(rawArray);
1130
4
    checkArray(rawArray, reflectable, [&](uint16_t value, const IReflectablePtr& elementReflectable) {
1131
4
        checkUnsignedIntegral(value, elementReflectable, &IReflectable::getUInt16,
1132
4
                std::bind(&BitStreamReader::readBits, _1, 16));
1133
4
    });
1134
1
}
1135
1136
TEST_F(ReflectableTest, uint32ConstArray)
1137
1
{
1138
1
    const auto rawArray = std::vector<uint32_t>({10000, 20000, 30000, 40000});
1139
1
    auto reflectable = ReflectableFactory::getUInt32Array(rawArray);
1140
4
    checkArray(rawArray, reflectable, [&](uint32_t value, const IReflectableConstPtr& elementReflectable) {
1141
4
        checkUnsignedIntegral(value, elementReflectable, &IReflectable::getUInt32,
1142
4
                std::bind(&BitStreamReader::readBits, _1, 32));
1143
4
    });
1144
1
}
1145
1146
TEST_F(ReflectableTest, uint32Array)
1147
1
{
1148
1
    auto rawArray = std::vector<uint32_t>{{10000, 20000, 30000, 40000}};
1149
1
    auto reflectable = ReflectableFactory::getUInt32Array(rawArray);
1150
4
    checkArray(rawArray, reflectable, [&](uint32_t value, const IReflectablePtr& elementReflectable) {
1151
4
        checkUnsignedIntegral(value, elementReflectable, &IReflectable::getUInt32,
1152
4
                std::bind(&BitStreamReader::readBits, _1, 32));
1153
4
    });
1154
1
}
1155
1156
TEST_F(ReflectableTest, uint64ConstArray)
1157
1
{
1158
1
    const auto rawArray = std::vector<uint64_t>({10000000, 20000000, 30000000, 40000000});
1159
1
    auto reflectable = ReflectableFactory::getUInt64Array(rawArray);
1160
4
    checkArray(rawArray, reflectable, [&](uint64_t value, const IReflectableConstPtr& elementReflectable) {
1161
4
        checkUnsignedIntegral(value, elementReflectable, &IReflectable::getUInt64,
1162
4
                std::bind(&BitStreamReader::readBits64, _1, 64));
1163
4
    });
1164
1
}
1165
1166
TEST_F(ReflectableTest, uint64Array)
1167
1
{
1168
1
    auto rawArray = std::vector<uint64_t>{{10000000, 20000000, 30000000, 40000000}};
1169
1
    auto reflectable = ReflectableFactory::getUInt64Array(rawArray);
1170
4
    checkArray(rawArray, reflectable, [&](uint64_t value, const IReflectablePtr& elementReflectable) {
1171
4
        checkUnsignedIntegral(value, elementReflectable, &IReflectable::getUInt64,
1172
4
                std::bind(&BitStreamReader::readBits64, _1, 64));
1173
4
    });
1174
1
}
1175
1176
TEST_F(ReflectableTest, fixedSignedBitField5ConstArray)
1177
1
{
1178
1
    const uint8_t numBits = 5;
1179
1
    const auto rawArray = std::vector<int8_t>{{-3, -1, 2, 4, 6}};
1180
1
    auto reflectable = ReflectableFactory::getFixedSignedBitFieldArray(rawArray, numBits);
1181
5
    checkArray(rawArray, reflectable, [&](int8_t value, const IReflectableConstPtr& elementReflectable) {
1182
5
        checkSignedIntegral(value, elementReflectable, &IReflectable::getInt8,
1183
5
                std::bind(&BitStreamReader::readSignedBits, _1, numBits), numBits);
1184
5
    });
1185
1
}
1186
1187
TEST_F(ReflectableTest, fixedSignedBitField5Array)
1188
1
{
1189
1
    const uint8_t numBits = 5;
1190
1
    auto rawArray = std::vector<int8_t>{{-3, -1, 2, 4, 6}};
1191
1
    auto reflectable = ReflectableFactory::getFixedSignedBitFieldArray(rawArray, numBits);
1192
5
    checkArray(rawArray, reflectable, [&](int8_t value, const IReflectableConstPtr& elementReflectable) {
1193
5
        checkSignedIntegral(value, elementReflectable, &IReflectable::getInt8,
1194
5
                std::bind(&BitStreamReader::readSignedBits, _1, numBits), numBits);
1195
5
    });
1196
1
    checkArray(rawArray, static_cast<IReflectableConstPtr>(reflectable),
1197
5
            [&](int8_t value, const IReflectableConstPtr& elementReflectable) {
1198
5
                checkSignedIntegral(value, elementReflectable, &IReflectable::getInt8,
1199
5
                        std::bind(&BitStreamReader::readSignedBits, _1, numBits), numBits);
1200
5
            });
1201
1202
1
    reflectable->resize(0);
1203
1
    ASSERT_EQ(0, reflectable->size());
1204
1
    reflectable->append(AnyHolder<>(static_cast<int8_t>(13)));
1205
1
    ASSERT_EQ(1, reflectable->size());
1206
1
    ASSERT_EQ(13, reflectable->at(0)->getInt8());
1207
1
    reflectable->setAt(AnyHolder<>(static_cast<int8_t>(42)), 0);
1208
1
    ASSERT_EQ(1, reflectable->size());
1209
1
    ASSERT_EQ(42, reflectable->at(0)->getInt8());
1210
1
    reflectable->resize(2);
1211
1
    ASSERT_EQ(2, reflectable->size());
1212
1213
    // out of range
1214
1
    ASSERT_THROW(reflectable->setAt(AnyHolder<>(static_cast<int8_t>(42)), 2), CppRuntimeException);
1215
1
}
1216
1217
TEST_F(ReflectableTest, fixedUnsignedBitField5ConstArray)
1218
1
{
1219
1
    const uint8_t numBits = 5;
1220
1
    const auto rawArray = std::vector<uint8_t>{{3, 1, 2, 4, 6}};
1221
1
    auto reflectable = ReflectableFactory::getFixedUnsignedBitFieldArray(rawArray, numBits);
1222
5
    checkArray(rawArray, reflectable, [&](uint8_t value, const IReflectableConstPtr& elementReflectable) {
1223
5
        checkUnsignedIntegral(value, elementReflectable, &IReflectable::getUInt8,
1224
5
                std::bind(&BitStreamReader::readBits, _1, numBits), numBits);
1225
5
    });
1226
1
}
1227
1228
TEST_F(ReflectableTest, fixedUnsignedBitField5Array)
1229
1
{
1230
1
    const uint8_t numBits = 5;
1231
1
    auto rawArray = std::vector<uint8_t>{{3, 1, 2, 4, 6}};
1232
1
    auto reflectable = ReflectableFactory::getFixedUnsignedBitFieldArray(rawArray, numBits);
1233
5
    checkArray(rawArray, reflectable, [&](uint8_t value, const IReflectableConstPtr& elementReflectable) {
1234
5
        checkUnsignedIntegral(value, elementReflectable, &IReflectable::getUInt8,
1235
5
                std::bind(&BitStreamReader::readBits, _1, numBits), numBits);
1236
5
    });
1237
1
}
1238
1239
TEST_F(ReflectableTest, dynamicSignedBitField5ConstArray)
1240
1
{
1241
1
    const uint8_t maxBitSize = 8;
1242
1
    const uint8_t numBits = 5;
1243
1
    const auto rawArray = std::vector<int8_t>{{-3, -1, 2, 4, 6}};
1244
1
    auto reflectable = ReflectableFactory::getDynamicSignedBitFieldArray(rawArray, maxBitSize, numBits);
1245
5
    checkArray(rawArray, reflectable, [&](int8_t value, const IReflectableConstPtr& elementReflectable) {
1246
5
        checkSignedIntegral(value, elementReflectable, &IReflectable::getInt8,
1247
5
                std::bind(&BitStreamReader::readSignedBits, _1, numBits), numBits);
1248
5
    });
1249
1250
1
    auto nonConstReflectable = std::const_pointer_cast<IReflectable>(reflectable);
1251
1
    ASSERT_THROW(nonConstReflectable->getAnyValue(), CppRuntimeException);
1252
1
}
1253
1254
TEST_F(ReflectableTest, dynamicSignedBitField5Array)
1255
1
{
1256
1
    const uint8_t maxBitSize = 8;
1257
1
    const uint8_t numBits = 5;
1258
1
    auto rawArray = std::vector<int8_t>{{-3, -1, 2, 4, 6}};
1259
1
    auto reflectable = ReflectableFactory::getDynamicSignedBitFieldArray(rawArray, maxBitSize, numBits);
1260
5
    checkArray(rawArray, reflectable, [&](int8_t value, const IReflectablePtr& elementReflectable) {
1261
5
        checkSignedIntegral(value, elementReflectable, &IReflectable::getInt8,
1262
5
                std::bind(&BitStreamReader::readSignedBits, _1, numBits), numBits);
1263
5
    });
1264
1
    checkArray(rawArray, static_cast<IReflectableConstPtr>(reflectable),
1265
5
            [&](int8_t value, const IReflectableConstPtr& elementReflectable) {
1266
5
                checkSignedIntegral(value, elementReflectable, &IReflectable::getInt8,
1267
5
                        std::bind(&BitStreamReader::readSignedBits, _1, numBits), numBits);
1268
5
            });
1269
1270
1
    reflectable->resize(0);
1271
1
    ASSERT_EQ(0, reflectable->size());
1272
1
    reflectable->append(AnyHolder<>(static_cast<int8_t>(13)));
1273
1
    ASSERT_EQ(1, reflectable->size());
1274
1
    ASSERT_EQ(13, reflectable->at(0)->getInt8());
1275
1
    reflectable->setAt(AnyHolder<>(static_cast<int8_t>(42)), 0);
1276
1
    ASSERT_EQ(1, reflectable->size());
1277
1
    ASSERT_EQ(42, reflectable->at(0)->getInt8());
1278
1
    reflectable->resize(2);
1279
1
    ASSERT_EQ(2, reflectable->size());
1280
1281
    // out of range
1282
1
    ASSERT_THROW(reflectable->setAt(AnyHolder<>(static_cast<int8_t>(42)), 2), CppRuntimeException);
1283
1
}
1284
1285
TEST_F(ReflectableTest, dynamicUnsignedBitField5ConstArray)
1286
1
{
1287
1
    const uint8_t maxBitSize = 8;
1288
1
    const uint8_t numBits = 5;
1289
1
    const auto rawArray = std::vector<uint8_t>{{3, 1, 2, 4, 6}};
1290
1
    auto reflectable = ReflectableFactory::getDynamicUnsignedBitFieldArray(rawArray, maxBitSize, numBits);
1291
5
    checkArray(rawArray, reflectable, [&](uint8_t value, const IReflectableConstPtr& elementReflectable) {
1292
5
        checkUnsignedIntegral(value, elementReflectable, &IReflectable::getUInt8,
1293
5
                std::bind(&BitStreamReader::readBits, _1, numBits), numBits);
1294
5
    });
1295
1
}
1296
1297
TEST_F(ReflectableTest, dynamicUnsignedBitField5Array)
1298
1
{
1299
1
    const uint8_t maxBitSize = 8;
1300
1
    const uint8_t numBits = 5;
1301
1
    auto rawArray = std::vector<uint8_t>{{3, 1, 2, 4, 6}};
1302
1
    auto reflectable = ReflectableFactory::getDynamicUnsignedBitFieldArray(rawArray, maxBitSize, numBits);
1303
5
    checkArray(rawArray, reflectable, [&](uint8_t value, const IReflectableConstPtr& elementReflectable) {
1304
5
        checkUnsignedIntegral(value, elementReflectable, &IReflectable::getUInt8,
1305
5
                std::bind(&BitStreamReader::readBits, _1, numBits), numBits);
1306
5
    });
1307
1
}
1308
1309
TEST_F(ReflectableTest, varint16ConstArray)
1310
1
{
1311
1
    const auto rawArray = std::vector<int16_t>({-10, -20, 30, 40});
1312
1
    auto reflectable = ReflectableFactory::getVarInt16Array(rawArray);
1313
4
    checkArray(rawArray, reflectable, [&](int16_t value, const IReflectableConstPtr& elementReflectable) {
1314
4
        checkSignedIntegral(value, elementReflectable, &IReflectable::getInt16,
1315
4
                std::bind(&BitStreamReader::readVarInt16, _1));
1316
4
    });
1317
1
}
1318
1319
TEST_F(ReflectableTest, varint16Array)
1320
1
{
1321
1
    auto rawArray = std::vector<int16_t>{{-10, -20, 30, 40}};
1322
1
    auto reflectable = ReflectableFactory::getVarInt16Array(rawArray);
1323
4
    checkArray(rawArray, reflectable, [&](int16_t value, const IReflectablePtr& elementReflectable) {
1324
4
        checkSignedIntegral(value, elementReflectable, &IReflectable::getInt16,
1325
4
                std::bind(&BitStreamReader::readVarInt16, _1));
1326
4
    });
1327
1
}
1328
1329
TEST_F(ReflectableTest, varint32ConstArray)
1330
1
{
1331
1
    const auto rawArray = std::vector<int32_t>({-10000, -20000, 30000, 40000});
1332
1
    auto reflectable = ReflectableFactory::getVarInt32Array(rawArray);
1333
4
    checkArray(rawArray, reflectable, [&](int32_t value, const IReflectableConstPtr& elementReflectable) {
1334
4
        checkSignedIntegral(value, elementReflectable, &IReflectable::getInt32,
1335
4
                std::bind(&BitStreamReader::readVarInt32, _1));
1336
4
    });
1337
1
}
1338
1339
TEST_F(ReflectableTest, varint32Array)
1340
1
{
1341
1
    auto rawArray = std::vector<int32_t>{{-10000, -20000, 30000, 40000}};
1342
1
    auto reflectable = ReflectableFactory::getVarInt32Array(rawArray);
1343
4
    checkArray(rawArray, reflectable, [&](int32_t value, const IReflectablePtr& elementReflectable) {
1344
4
        checkSignedIntegral(value, elementReflectable, &IReflectable::getInt32,
1345
4
                std::bind(&BitStreamReader::readVarInt32, _1));
1346
4
    });
1347
1
}
1348
1349
TEST_F(ReflectableTest, varint64ConstArray)
1350
1
{
1351
1
    const auto rawArray = std::vector<int64_t>({-10000000, -20000000, 30000000, 40000000});
1352
1
    auto reflectable = ReflectableFactory::getVarInt64Array(rawArray);
1353
4
    checkArray(rawArray, reflectable, [&](int64_t value, const IReflectableConstPtr& elementReflectable) {
1354
4
        checkSignedIntegral(value, elementReflectable, &IReflectable::getInt64,
1355
4
                std::bind(&BitStreamReader::readVarInt64, _1));
1356
4
    });
1357
1
}
1358
1359
TEST_F(ReflectableTest, varint64Array)
1360
1
{
1361
1
    auto rawArray = std::vector<int64_t>{{-10000000, -20000000, 30000000, 40000000}};
1362
1
    auto reflectable = ReflectableFactory::getVarInt64Array(rawArray);
1363
4
    checkArray(rawArray, reflectable, [&](int64_t value, const IReflectablePtr& elementReflectable) {
1364
4
        checkSignedIntegral(value, elementReflectable, &IReflectable::getInt64,
1365
4
                std::bind(&BitStreamReader::readVarInt64, _1));
1366
4
    });
1367
1
}
1368
1369
TEST_F(ReflectableTest, varintConstArray)
1370
1
{
1371
1
    const auto rawArray = std::vector<int64_t>({-10000000, -20000000, 30000000, 40000000});
1372
1
    auto reflectable = ReflectableFactory::getVarIntArray(rawArray);
1373
4
    checkArray(rawArray, reflectable, [&](int64_t value, const IReflectableConstPtr& elementReflectable) {
1374
4
        checkSignedIntegral(value, elementReflectable, &IReflectable::getInt64,
1375
4
                std::bind(&BitStreamReader::readVarInt, _1));
1376
4
    });
1377
1
}
1378
1379
TEST_F(ReflectableTest, varintArray)
1380
1
{
1381
1
    auto rawArray = std::vector<int64_t>{{-10000000, -20000000, 30000000, 40000000}};
1382
1
    auto reflectable = ReflectableFactory::getVarIntArray(rawArray);
1383
4
    checkArray(rawArray, reflectable, [&](int64_t value, const IReflectablePtr& elementReflectable) {
1384
4
        checkSignedIntegral(value, elementReflectable, &IReflectable::getInt64,
1385
4
                std::bind(&BitStreamReader::readVarInt, _1));
1386
4
    });
1387
1
}
1388
1389
TEST_F(ReflectableTest, varuint16ConstArray)
1390
1
{
1391
1
    const auto rawArray = std::vector<uint16_t>({10, 20, 30, 40});
1392
1
    auto reflectable = ReflectableFactory::getVarUInt16Array(rawArray);
1393
4
    checkArray(rawArray, reflectable, [&](uint16_t value, const IReflectableConstPtr& elementReflectable) {
1394
4
        checkUnsignedIntegral(value, elementReflectable, &IReflectable::getUInt16,
1395
4
                std::bind(&BitStreamReader::readVarUInt16, _1));
1396
4
    });
1397
1
}
1398
1399
TEST_F(ReflectableTest, varuint16Array)
1400
1
{
1401
1
    auto rawArray = std::vector<uint16_t>{{10, 20, 30, 40}};
1402
1
    auto reflectable = ReflectableFactory::getVarUInt16Array(rawArray);
1403
4
    checkArray(rawArray, reflectable, [&](uint16_t value, const IReflectablePtr& elementReflectable) {
1404
4
        checkUnsignedIntegral(value, elementReflectable, &IReflectable::getUInt16,
1405
4
                std::bind(&BitStreamReader::readVarUInt16, _1));
1406
4
    });
1407
1
}
1408
1409
TEST_F(ReflectableTest, varuint32ConstArray)
1410
1
{
1411
1
    const auto rawArray = std::vector<uint32_t>({10000, 20000, 30000, 40000});
1412
1
    auto reflectable = ReflectableFactory::getVarUInt32Array(rawArray);
1413
4
    checkArray(rawArray, reflectable, [&](uint32_t value, const IReflectableConstPtr& elementReflectable) {
1414
4
        checkUnsignedIntegral(value, elementReflectable, &IReflectable::getUInt32,
1415
4
                std::bind(&BitStreamReader::readVarUInt32, _1));
1416
4
    });
1417
1
}
1418
1419
TEST_F(ReflectableTest, varuint32Array)
1420
1
{
1421
1
    auto rawArray = std::vector<uint32_t>{{10000, 20000, 30000, 40000}};
1422
1
    auto reflectable = ReflectableFactory::getVarUInt32Array(rawArray);
1423
4
    checkArray(rawArray, reflectable, [&](uint32_t value, const IReflectablePtr& elementReflectable) {
1424
4
        checkUnsignedIntegral(value, elementReflectable, &IReflectable::getUInt32,
1425
4
                std::bind(&BitStreamReader::readVarUInt32, _1));
1426
4
    });
1427
1
}
1428
1429
TEST_F(ReflectableTest, varuint64ConstArray)
1430
1
{
1431
1
    const auto rawArray = std::vector<uint64_t>({10000, 20000, 30000, 40000});
1432
1
    auto reflectable = ReflectableFactory::getVarUInt64Array(rawArray);
1433
4
    checkArray(rawArray, reflectable, [&](uint64_t value, const IReflectableConstPtr& elementReflectable) {
1434
4
        checkUnsignedIntegral(value, elementReflectable, &IReflectable::getUInt64,
1435
4
                std::bind(&BitStreamReader::readVarUInt64, _1));
1436
4
    });
1437
1
}
1438
1439
TEST_F(ReflectableTest, varuint64Array)
1440
1
{
1441
1
    auto rawArray = std::vector<uint64_t>{{10000, 20000, 30000, 40000}};
1442
1
    auto reflectable = ReflectableFactory::getVarUInt64Array(rawArray);
1443
4
    checkArray(rawArray, reflectable, [&](uint64_t value, const IReflectablePtr& elementReflectable) {
1444
4
        checkUnsignedIntegral(value, elementReflectable, &IReflectable::getUInt64,
1445
4
                std::bind(&BitStreamReader::readVarUInt64, _1));
1446
4
    });
1447
1
}
1448
1449
TEST_F(ReflectableTest, varuintConstArray)
1450
1
{
1451
1
    const auto rawArray = std::vector<uint64_t>({10000, 20000, 30000, 40000});
1452
1
    auto reflectable = ReflectableFactory::getVarUIntArray(rawArray);
1453
4
    checkArray(rawArray, reflectable, [&](uint64_t value, const IReflectableConstPtr& elementReflectable) {
1454
4
        checkUnsignedIntegral(value, elementReflectable, &IReflectable::getUInt64,
1455
4
                std::bind(&BitStreamReader::readVarUInt, _1));
1456
4
    });
1457
1
}
1458
1459
TEST_F(ReflectableTest, varuintArray)
1460
1
{
1461
1
    auto rawArray = std::vector<uint64_t>{{10000, 20000, 30000, 40000}};
1462
1
    auto reflectable = ReflectableFactory::getVarUIntArray(rawArray);
1463
4
    checkArray(rawArray, reflectable, [&](uint64_t value, const IReflectablePtr& elementReflectable) {
1464
4
        checkUnsignedIntegral(value, elementReflectable, &IReflectable::getUInt64,
1465
4
                std::bind(&BitStreamReader::readVarUInt, _1));
1466
4
    });
1467
1
}
1468
1469
TEST_F(ReflectableTest, varsizeConstArray)
1470
1
{
1471
1
    const auto rawArray = std::vector<uint32_t>({10000, 20000, 30000, 40000});
1472
1
    auto reflectable = ReflectableFactory::getVarSizeArray(rawArray);
1473
4
    checkArray(rawArray, reflectable, [&](uint32_t value, const IReflectableConstPtr& elementReflectable) {
1474
4
        checkUnsignedIntegral(value, elementReflectable, &IReflectable::getUInt32,
1475
4
                std::bind(&BitStreamReader::readVarSize, _1));
1476
4
    });
1477
1
}
1478
1479
TEST_F(ReflectableTest, varsizeArray)
1480
1
{
1481
1
    auto rawArray = std::vector<uint32_t>{{10000, 20000, 30000, 40000}};
1482
1
    auto reflectable = ReflectableFactory::getVarSizeArray(rawArray);
1483
4
    checkArray(rawArray, reflectable, [&](uint32_t value, const IReflectablePtr& elementReflectable) {
1484
4
        checkUnsignedIntegral(value, elementReflectable, &IReflectable::getUInt32,
1485
4
                std::bind(&BitStreamReader::readVarSize, _1));
1486
4
    });
1487
1
}
1488
1489
TEST_F(ReflectableTest, float16ConstArray)
1490
1
{
1491
1
    const auto rawArray = std::vector<float>{{2.0F, 0.0F}};
1492
1
    auto reflectable = ReflectableFactory::getFloat16Array(rawArray);
1493
2
    checkArray(rawArray, reflectable, [&](float value, const IReflectableConstPtr& elementReflectable) {
1494
2
        checkFloatingPoint(value, elementReflectable, &IReflectable::getFloat,
1495
2
                std::bind(&BitStreamReader::readFloat16, _1));
1496
2
    });
1497
1
}
1498
1499
TEST_F(ReflectableTest, float16Array)
1500
1
{
1501
1
    auto rawArray = std::vector<float>{{2.0F, 0.0F}};
1502
1
    auto reflectable = ReflectableFactory::getFloat16Array(rawArray);
1503
2
    checkArray(rawArray, reflectable, [&](float value, const IReflectablePtr& elementReflectable) {
1504
2
        checkFloatingPoint(value, elementReflectable, &IReflectable::getFloat,
1505
2
                std::bind(&BitStreamReader::readFloat16, _1));
1506
2
    });
1507
1
}
1508
1509
TEST_F(ReflectableTest, float32ConstArray)
1510
1
{
1511
1
    const auto rawArray = std::vector<float>{{2.0F, 0.0F, 1.2F}};
1512
1
    auto reflectable = ReflectableFactory::getFloat32Array(rawArray);
1513
3
    checkArray(rawArray, reflectable, [&](float value, const IReflectableConstPtr& elementReflectable) {
1514
3
        checkFloatingPoint(value, elementReflectable, &IReflectable::getFloat,
1515
3
                std::bind(&BitStreamReader::readFloat32, _1));
1516
3
    });
1517
1
}
1518
1519
TEST_F(ReflectableTest, float32Array)
1520
1
{
1521
1
    auto rawArray = std::vector<float>{{2.0F, 0.0F, 1.2F}};
1522
1
    auto reflectable = ReflectableFactory::getFloat32Array(rawArray);
1523
3
    checkArray(rawArray, reflectable, [&](float value, const IReflectablePtr& elementReflectable) {
1524
3
        checkFloatingPoint(value, elementReflectable, &IReflectable::getFloat,
1525
3
                std::bind(&BitStreamReader::readFloat32, _1));
1526
3
    });
1527
1
}
1528
1529
TEST_F(ReflectableTest, float64ConstArray)
1530
1
{
1531
1
    const auto rawArray = std::vector<double>{{2.0, 0.0, 1.2}};
1532
1
    auto reflectable = ReflectableFactory::getFloat64Array(rawArray);
1533
3
    checkArray(rawArray, reflectable, [&](double value, const IReflectableConstPtr& elementReflectable) {
1534
3
        checkFloatingPoint(value, elementReflectable, &IReflectable::getDouble,
1535
3
                std::bind(&BitStreamReader::readFloat64, _1));
1536
3
    });
1537
1
}
1538
1539
TEST_F(ReflectableTest, float64Array)
1540
1
{
1541
1
    auto rawArray = std::vector<double>{{2.0, 0.0, 1.2}};
1542
1
    auto reflectable = ReflectableFactory::getFloat64Array(rawArray);
1543
3
    checkArray(rawArray, reflectable, [&](double value, const IReflectablePtr& elementReflectable) {
1544
3
        checkFloatingPoint(value, elementReflectable, &IReflectable::getDouble,
1545
3
                std::bind(&BitStreamReader::readFloat64, _1));
1546
3
    });
1547
1
}
1548
1549
TEST_F(ReflectableTest, stringConstArray)
1550
1
{
1551
1
    const auto rawArray = std::vector<std::string>{{"one", "two", "three"}};
1552
1
    auto reflectable = ReflectableFactory::getStringArray(rawArray);
1553
3
    checkArray(rawArray, reflectable, [&](StringView value, const IReflectableConstPtr& elementReflectable) {
1554
3
        checkString(value, elementReflectable);
1555
3
    });
1556
1557
1
    auto nonConstReflectable = std::const_pointer_cast<IReflectable>(reflectable);
1558
1
    ASSERT_THROW(nonConstReflectable->getAnyValue(), CppRuntimeException);
1559
1
}
1560
1561
TEST_F(ReflectableTest, stringArray)
1562
1
{
1563
1
    auto rawArray = std::vector<std::string>{{"one", "two", "three"}};
1564
1
    auto reflectable = ReflectableFactory::getStringArray(rawArray);
1565
3
    checkArray(rawArray, reflectable, [&](StringView value, const IReflectablePtr& elementReflectable) {
1566
3
        checkString(value, elementReflectable);
1567
3
    });
1568
1
    checkArray(rawArray, static_cast<IReflectableConstPtr>(reflectable),
1569
3
            [&](StringView value, const IReflectableConstPtr& elementReflectable) {
1570
3
                checkString(value, elementReflectable);
1571
3
            });
1572
1573
1
    reflectable->resize(0);
1574
1
    ASSERT_EQ(0, reflectable->size());
1575
1
    reflectable->append(AnyHolder<>(std::string("appended")));
1576
1
    ASSERT_EQ(1, reflectable->size());
1577
1
    ASSERT_EQ("appended"_sv, reflectable->at(0)->getStringView());
1578
1
    reflectable->setAt(AnyHolder<>(std::string("set")), 0);
1579
1
    ASSERT_EQ(1, reflectable->size());
1580
1
    ASSERT_EQ("set"_sv, reflectable->at(0)->getStringView());
1581
1
    reflectable->resize(2);
1582
1
    ASSERT_EQ(2, reflectable->size());
1583
1584
    // out of range
1585
1
    ASSERT_THROW(reflectable->setAt(AnyHolder<>(std::string("set")), 2), CppRuntimeException);
1586
1
}
1587
1588
TEST_F(ReflectableTest, bitBufferConstArray)
1589
1
{
1590
1
    const auto rawArray = std::vector<BitBuffer>{{BitBuffer({0xF8}, 5), BitBuffer({0xAB, 0xCD}, 16)}};
1591
1
    auto reflectable = ReflectableFactory::getBitBufferArray(rawArray);
1592
1
    checkArray(
1593
2
            rawArray, reflectable, [&](const BitBuffer& value, const IReflectableConstPtr& elementReflectable) {
1594
2
                checkBitBuffer(value, elementReflectable);
1595
2
            });
1596
1
}
1597
1598
TEST_F(ReflectableTest, bitBufferArray)
1599
1
{
1600
1
    auto rawArray = std::vector<BitBuffer>{{BitBuffer({0xF8}, 5), BitBuffer({0xAB, 0xCD}, 16)}};
1601
1
    auto reflectable = ReflectableFactory::getBitBufferArray(rawArray);
1602
2
    checkArray(rawArray, reflectable, [&](const BitBuffer& value, const IReflectablePtr& elementReflectable) {
1603
2
        checkBitBuffer(value, elementReflectable);
1604
2
    });
1605
1
    checkArray(rawArray, static_cast<IReflectableConstPtr>(reflectable),
1606
2
            [&](const BitBuffer& value, const IReflectableConstPtr& elementReflectable) {
1607
2
                checkBitBuffer(value, elementReflectable);
1608
2
            });
1609
1610
1
    reflectable->resize(0);
1611
1
    ASSERT_EQ(0, reflectable->size());
1612
1
    reflectable->append(AnyHolder<>(BitBuffer()));
1613
1
    ASSERT_EQ(1, reflectable->size());
1614
1
    ASSERT_EQ(0, reflectable->at(0)->getBitBuffer().getBitSize());
1615
1
    reflectable->setAt(AnyHolder<>(BitBuffer({0xA0}, 4)), 0);
1616
1
    ASSERT_EQ(1, reflectable->size());
1617
1
    ASSERT_EQ(4, reflectable->at(0)->getBitBuffer().getBitSize());
1618
1
    reflectable->resize(2);
1619
1
    ASSERT_EQ(2, reflectable->size());
1620
1621
    // out of range
1622
1
    ASSERT_THROW(reflectable->setAt(AnyHolder<>(BitBuffer()), 2), CppRuntimeException);
1623
1
}
1624
1625
TEST_F(ReflectableTest, bytesConstArray)
1626
1
{
1627
1
    const auto rawArray = std::vector<std::vector<uint8_t>>{{{{0x00, 0x01}}, {{0xFF, 0xFE}}}};
1628
1
    auto reflectable = ReflectableFactory::getBytesArray(rawArray);
1629
1
    checkArray(rawArray, reflectable,
1630
2
            [&](const vector<uint8_t>& value, const IReflectableConstPtr& elementReflectable) {
1631
2
                checkBytes(value, elementReflectable);
1632
2
            });
1633
1
}
1634
1635
TEST_F(ReflectableTest, bytesArray)
1636
1
{
1637
1
    auto rawArray = std::vector<std::vector<uint8_t>>{{{{0x00, 0x01}}, {{0xFF, 0xFE}}}};
1638
1
    auto reflectable = ReflectableFactory::getBytesArray(rawArray);
1639
1
    checkArray(rawArray, reflectable,
1640
2
            [&](const vector<uint8_t>& value, const IReflectablePtr& elementReflectable) {
1641
2
                checkBytes(value, elementReflectable);
1642
2
            });
1643
1
    checkArray(rawArray, static_cast<IReflectableConstPtr>(reflectable),
1644
2
            [&](const vector<uint8_t>& value, const IReflectableConstPtr& elementReflectable) {
1645
2
                checkBytes(value, elementReflectable);
1646
2
            });
1647
1648
1
    reflectable->resize(0);
1649
1
    ASSERT_EQ(0, reflectable->size());
1650
1
    reflectable->append(AnyHolder<>(std::vector<uint8_t>()));
1651
1
    ASSERT_EQ(1, reflectable->size());
1652
1
    ASSERT_EQ(0, reflectable->at(0)->getBytes().size());
1653
1
    reflectable->setAt(AnyHolder<>(std::vector<uint8_t>{{0xAB, 0xCD}}), 0);
1654
1
    ASSERT_EQ(1, reflectable->size());
1655
1
    ASSERT_EQ(2, reflectable->at(0)->getBytes().size());
1656
1
    reflectable->resize(2);
1657
1
    ASSERT_EQ(2, reflectable->size());
1658
1659
    // out of range
1660
1
    ASSERT_THROW(reflectable->setAt(AnyHolder<>(std::vector<uint8_t>()), 2), CppRuntimeException);
1661
1
}
1662
1663
TEST_F(ReflectableTest, bitmaskConstReflectable)
1664
1
{
1665
1
    const ReflectableBitmask bitmask = ReflectableBitmask::Values::WRITE;
1666
1
    auto reflectable = bitmask.reflectable();
1667
1
    checkBitmask(bitmask, reflectable);
1668
1
}
1669
1670
TEST_F(ReflectableTest, bitmaskReflectable)
1671
1
{
1672
1
    ReflectableBitmask bitmask = ReflectableBitmask::Values::WRITE;
1673
1
    auto reflectable = bitmask.reflectable();
1674
1
    checkBitmask(bitmask, reflectable);
1675
1
}
1676
1677
TEST_F(ReflectableTest, bitmaskConstArray)
1678
1
{
1679
1
    const auto rawArray = std::vector<ReflectableBitmask>{{ReflectableBitmask::Values::WRITE,
1680
1
            ReflectableBitmask::Values::CREATE, ReflectableBitmask::Values::READ}};
1681
1
    auto reflectable = ReflectableFactory::getBitmaskArray(rawArray);
1682
1
    checkArray(rawArray, reflectable,
1683
3
            [&](ReflectableBitmask value, const IReflectableConstPtr& elementReflectable) {
1684
3
                checkBitmask(value, elementReflectable);
1685
3
            });
1686
1687
1
    auto nonConstReflectable = std::const_pointer_cast<IReflectable>(reflectable);
1688
1
    ASSERT_THROW(nonConstReflectable->getAnyValue(), CppRuntimeException);
1689
1
}
1690
1691
TEST_F(ReflectableTest, bitmaskArray)
1692
1
{
1693
1
    auto rawArray = std::vector<ReflectableBitmask>{{ReflectableBitmask::Values::WRITE,
1694
1
            ReflectableBitmask::Values::CREATE, ReflectableBitmask::Values::READ}};
1695
1
    auto reflectable = ReflectableFactory::getBitmaskArray(rawArray);
1696
3
    checkArray(rawArray, reflectable, [&](ReflectableBitmask value, const IReflectablePtr& elementReflectable) {
1697
3
        checkBitmask(value, elementReflectable);
1698
3
    });
1699
1
    checkArray(rawArray, static_cast<IReflectableConstPtr>(reflectable),
1700
3
            [&](ReflectableBitmask value, const IReflectableConstPtr& elementReflectable) {
1701
3
                checkBitmask(value, elementReflectable);
1702
3
            });
1703
1704
1
    reflectable->resize(0);
1705
1
    ASSERT_EQ(0, reflectable->size());
1706
1
    reflectable->append(AnyHolder<>(ReflectableBitmask(ReflectableBitmask::Values::READ)));
1707
1
    ASSERT_EQ(1, reflectable->size());
1708
1
    ASSERT_EQ(ReflectableBitmask::Values::READ, ReflectableBitmask(reflectable->at(0)->getUInt8()));
1709
1
    reflectable->setAt(AnyHolder<>(ReflectableBitmask(ReflectableBitmask::Values::CREATE)), 0);
1710
1
    ASSERT_EQ(1, reflectable->size());
1711
1
    ASSERT_EQ(ReflectableBitmask::Values::CREATE, ReflectableBitmask(reflectable->at(0)->getUInt8()));
1712
1
    reflectable->resize(2);
1713
1
    ASSERT_EQ(2, reflectable->size());
1714
1715
1
    reflectable->append(AnyHolder<>(ReflectableBitmask(ReflectableBitmask::Values::WRITE).getValue()));
1716
1
    ASSERT_EQ(3, reflectable->size());
1717
1
    ASSERT_EQ(ReflectableBitmask::Values::WRITE, ReflectableBitmask(reflectable->at(2)->getUInt8()));
1718
1
    reflectable->setAt(AnyHolder<>(ReflectableBitmask(ReflectableBitmask::Values::READ).getValue()), 2);
1719
1
    ASSERT_EQ(3, reflectable->size());
1720
1
    ASSERT_EQ(ReflectableBitmask::Values::READ, ReflectableBitmask(reflectable->at(2)->getUInt8()));
1721
1722
    // out of range
1723
1
    ASSERT_THROW(reflectable->setAt(AnyHolder<>(ReflectableBitmask::Values::CREATE), 3), CppRuntimeException);
1724
1
}
1725
1726
TEST_F(ReflectableTest, enumReflectable)
1727
1
{
1728
1
    const ReflectableEnum enumeration = ReflectableEnum::VALUE1;
1729
1
    auto reflectable = enumReflectable(enumeration);
1730
1
    checkEnum(enumeration, reflectable);
1731
1
}
1732
1733
TEST_F(ReflectableTest, enumConstArray)
1734
1
{
1735
1
    const auto rawArray = std::vector<ReflectableEnum>{
1736
1
            {ReflectableEnum::VALUE1, ReflectableEnum::VALUE2, ReflectableEnum::VALUE3}};
1737
1
    auto reflectable = ReflectableFactory::getEnumArray(rawArray);
1738
1
    checkArray(
1739
3
            rawArray, reflectable, [&](ReflectableEnum value, const IReflectableConstPtr& elementReflectable) {
1740
3
                checkEnum(value, elementReflectable);
1741
3
            });
1742
1743
1
    auto nonConstReflectable = std::const_pointer_cast<IReflectable>(reflectable);
1744
1
    ASSERT_THROW(nonConstReflectable->getAnyValue(), CppRuntimeException);
1745
1
}
1746
1747
TEST_F(ReflectableTest, enumArray)
1748
1
{
1749
1
    auto rawArray = std::vector<ReflectableEnum>{
1750
1
            {ReflectableEnum::VALUE1, ReflectableEnum::VALUE2, ReflectableEnum::VALUE3}};
1751
1
    auto reflectable = ReflectableFactory::getEnumArray(rawArray);
1752
3
    checkArray(rawArray, reflectable, [&](ReflectableEnum value, const IReflectablePtr& elementReflectable) {
1753
3
        checkEnum(value, elementReflectable);
1754
3
    });
1755
1
    checkArray(rawArray, static_cast<IReflectableConstPtr>(reflectable),
1756
3
            [&](ReflectableEnum value, const IReflectableConstPtr& elementReflectable) {
1757
3
                checkEnum(value, elementReflectable);
1758
3
            });
1759
1760
1
    reflectable->resize(0);
1761
1
    ASSERT_EQ(0, reflectable->size());
1762
1
    reflectable->append(AnyHolder<>(ReflectableEnum::VALUE3));
1763
1
    ASSERT_EQ(1, reflectable->size());
1764
1
    ASSERT_EQ(enumToValue(ReflectableEnum::VALUE3), reflectable->at(0)->getInt8());
1765
1
    reflectable->setAt(AnyHolder<>(ReflectableEnum::VALUE2), 0);
1766
1
    ASSERT_EQ(1, reflectable->size());
1767
1
    ASSERT_EQ(enumToValue(ReflectableEnum::VALUE2), reflectable->at(0)->getInt8());
1768
1
    reflectable->resize(2);
1769
1
    ASSERT_EQ(2, reflectable->size());
1770
1771
1
    reflectable->append(AnyHolder<>(enumToValue(ReflectableEnum::VALUE1)));
1772
1
    ASSERT_EQ(3, reflectable->size());
1773
1
    ASSERT_EQ(enumToValue(ReflectableEnum::VALUE1), reflectable->at(2)->getInt8());
1774
1
    reflectable->setAt(AnyHolder<>(enumToValue(ReflectableEnum::VALUE2)), 2);
1775
1
    ASSERT_EQ(3, reflectable->size());
1776
1
    ASSERT_EQ(enumToValue(ReflectableEnum::VALUE2), reflectable->at(2)->getInt8());
1777
1778
    // out of range
1779
1
    ASSERT_THROW(reflectable->setAt(AnyHolder<>(ReflectableEnum::VALUE2), 3), CppRuntimeException);
1780
1
}
1781
1782
TEST_F(ReflectableTest, compoundConst)
1783
1
{
1784
1
    {
1785
1
        const ReflectableObject reflectableObjectUninitialized =
1786
1
                ReflectableObject{"test", ReflectableNested{13}};
1787
1
        auto reflectable = reflectableObjectUninitialized.reflectable();
1788
1
        ASSERT_FALSE(reflectable->find("reflectableNested.stringParam"));
1789
1
    }
1790
1791
1
    const ReflectableObject reflectableObject = createInitializedReflectableObject("test", 13);
1792
1
    auto reflectable = reflectableObject.reflectable();
1793
1
    checkCompound(reflectableObject, reflectable);
1794
1795
1
    IReflectablePtr nonConstReflectable = std::const_pointer_cast<IReflectable>(reflectable);
1796
1
    ASSERT_THROW(nonConstReflectable->initializeChildren(), CppRuntimeException);
1797
1
    ASSERT_THROW(nonConstReflectable->initialize(vector<AnyHolder<>>()), CppRuntimeException);
1798
1
    ASSERT_NO_THROW(reflectable->getField("reflectableNested"));
1799
1
    ASSERT_THROW(nonConstReflectable->getField("reflectableNested"), CppRuntimeException);
1800
1
    ASSERT_NO_THROW(reflectable->getAnyValue());
1801
1
    ASSERT_THROW(nonConstReflectable->getAnyValue(), CppRuntimeException);
1802
1803
1
    IReflectableConstPtr childReflectable = reflectable->getField("reflectableNested");
1804
1
    IReflectablePtr nonConstChildReflectable = std::const_pointer_cast<IReflectable>(childReflectable);
1805
1
    ASSERT_THROW(nonConstChildReflectable->setField("value", AnyHolder<>(static_cast<uint32_t>(11))),
1806
1
            CppRuntimeException);
1807
1
    ASSERT_NO_THROW(childReflectable->getParameter("dummyParam"));
1808
1
    ASSERT_THROW(nonConstChildReflectable->getParameter("dummyParam"), CppRuntimeException);
1809
1
    ASSERT_NO_THROW(childReflectable->callFunction("getValue"));
1810
1
    ASSERT_THROW(nonConstChildReflectable->callFunction("getValue"), CppRuntimeException);
1811
1
    ASSERT_THROW(nonConstChildReflectable->initializeOffsets(0), CppRuntimeException);
1812
1
}
1813
1814
TEST_F(ReflectableTest, compound)
1815
1
{
1816
1
    {
1817
1
        ReflectableObject reflectableObjectUninitialized = ReflectableObject{"test", ReflectableNested{13}};
1818
1
        auto reflectable = reflectableObjectUninitialized.reflectable();
1819
1
        ASSERT_FALSE(reflectable->find("reflectableNested.stringParam"));
1820
1
    }
1821
1822
1
    ReflectableObject reflectableObject = ReflectableObject{"test", ReflectableNested{13}};
1823
1
    auto reflectable = reflectableObject.reflectable();
1824
1825
    // not initialized
1826
1
    ASSERT_THROW(reflectable->getField("reflectableNested")->getParameter("dummyParam"), CppRuntimeException);
1827
1
    ASSERT_THROW(reflectable->getField("reflectableNested")->getParameter("stringParam"), CppRuntimeException);
1828
1
    ASSERT_FALSE(static_cast<IReflectableConstPtr>(reflectable)->find("reflectableNested.stringParam"));
1829
1830
1
    reflectable->initializeChildren();
1831
1
    checkCompound(reflectableObject, reflectable);
1832
1
}
1833
1834
TEST_F(ReflectableTest, compoundConstArray)
1835
1
{
1836
1
    ReflectableObject reflectableObject1;
1837
1
    reflectableObject1 = createInitializedReflectableObject("1", 13); // to cover assignment operator
1838
1
    const auto rawArray =
1839
1
            std::vector<ReflectableObject>{{reflectableObject1, createInitializedReflectableObject("2", 42)}};
1840
1
    auto reflectable = ReflectableFactory::getCompoundArray(rawArray);
1841
1
    checkArray(rawArray, reflectable,
1842
2
            [&](const ReflectableObject& value, const IReflectableConstPtr& elementReflectable) {
1843
2
                checkCompound(value, elementReflectable);
1844
2
            });
1845
1846
1
    IReflectablePtr nonConstReflectable = std::const_pointer_cast<IReflectable>(reflectable);
1847
1
    ASSERT_THROW(nonConstReflectable->at(0), CppRuntimeException);
1848
1
    ASSERT_THROW((*nonConstReflectable)[0], CppRuntimeException);
1849
1
    ASSERT_THROW(nonConstReflectable->resize(nonConstReflectable->size() + 1), CppRuntimeException);
1850
1
    ASSERT_THROW(nonConstReflectable->setAt(AnyHolder<>(ReflectableObject{"test", ReflectableNested{0}}), 0),
1851
1
            CppRuntimeException);
1852
1
    ASSERT_THROW(nonConstReflectable->append(AnyHolder<>(ReflectableObject{"test", ReflectableNested{0}})),
1853
1
            CppRuntimeException);
1854
1
    ASSERT_THROW(nonConstReflectable->getAnyValue(), CppRuntimeException);
1855
1
}
1856
1857
TEST_F(ReflectableTest, compoundArray)
1858
1
{
1859
1
    auto rawArray = std::vector<ReflectableObject>{
1860
1
            {createInitializedReflectableObject("1", 13), createInitializedReflectableObject("2", 42)}};
1861
1
    auto reflectable = ReflectableFactory::getCompoundArray(rawArray);
1862
1
    checkArray(rawArray, reflectable,
1863
2
            [&](const ReflectableObject& value, const IReflectablePtr& elementReflectable) {
1864
2
                checkCompound(value, elementReflectable);
1865
2
            });
1866
1
    checkArray(rawArray, static_cast<IReflectableConstPtr>(reflectable),
1867
2
            [&](const ReflectableObject& value, const IReflectableConstPtr& elementReflectable) {
1868
2
                checkCompound(value, elementReflectable);
1869
2
            });
1870
1871
1
    reflectable->resize(reflectable->size() + 1);
1872
1
    IReflectablePtr newCompound = reflectable->at(reflectable->size() - 1);
1873
1
    ASSERT_TRUE(newCompound);
1874
1875
1
    reflectable->setAt(AnyHolder<>(ReflectableObject{"test", ReflectableNested{0}}), 0);
1876
1
    ASSERT_EQ(0, reflectable->at(0)->find("reflectableNested.value")->getUInt32());
1877
1
    reflectable->append(AnyHolder<>(ReflectableObject{"test|", ReflectableNested{1}}));
1878
1
    ASSERT_EQ(1, reflectable->at(reflectable->size() - 1)->find("reflectableNested.value")->getUInt32());
1879
1880
1
    const size_t size = reflectable->size();
1881
1
    ASSERT_THROW(reflectable->setAt(AnyHolder<>(), size), CppRuntimeException); // out of range
1882
1
}
1883
1884
TEST_F(ReflectableTest, defaultUnimplementedMethods)
1885
1
{
1886
1
    class Reflectable : public ReflectableBase<std::allocator<uint8_t>>
1887
1
    {
1888
1
    public:
1889
1
        using ReflectableBase<std::allocator<uint8_t>>::ReflectableBase;
1890
1
    };
1891
1892
1
    Reflectable reflectable(BuiltinTypeInfo<>::getUInt8());
1893
1
    ASSERT_THROW(reflectable.bitSizeOf(0), CppRuntimeException);
1894
1895
1
    BitBuffer bitBuffer(0);
1896
1
    BitStreamWriter writer(bitBuffer);
1897
1
    ASSERT_THROW(reflectable.write(writer), CppRuntimeException);
1898
1899
1
    ASSERT_THROW(reflectable.getAnyValue(), CppRuntimeException);
1900
1901
1
    const Reflectable& constReflectableRef = reflectable;
1902
1
    ASSERT_THROW(constReflectableRef.getAnyValue(), CppRuntimeException);
1903
1
}
1904
1905
TEST_F(ReflectableTest, reflectableOwner)
1906
1
{
1907
1
    auto reflectable = ReflectableObject::typeInfo().createInstance();
1908
1909
    // must be as the first one to initialize object
1910
1
    ASSERT_NO_THROW(reflectable->initializeChildren());
1911
1912
1
    IReflectableConstPtr constReflectable = reflectable;
1913
1914
    // same as default initialized
1915
1
    ReflectableObject defaultReflectableObject;
1916
1
    defaultReflectableObject.initializeChildren();
1917
1
    ASSERT_EQ(defaultReflectableObject,
1918
1
            reflectable->getAnyValue().template get<std::reference_wrapper<ReflectableObject>>().get());
1919
1
    ASSERT_EQ(defaultReflectableObject,
1920
1
            constReflectable->getAnyValue().template get<std::reference_wrapper<ReflectableObject>>().get());
1921
1922
    // has no type arguments
1923
1
    ASSERT_THROW(reflectable->initialize(std::vector<AnyHolder<>>()), CppRuntimeException);
1924
1925
1
    ASSERT_TRUE(TypeInfoUtil::isCompound(reflectable->getTypeInfo().getSchemaType()));
1926
1
    ASSERT_FALSE(reflectable->isArray());
1927
1
    reflectable->setField("reflectableNested", AnyHolder<>(ReflectableNested{42}));
1928
1
    ASSERT_EQ(42, reflectable->getField("reflectableNested")->getField("value")->getUInt32());
1929
1
    ASSERT_EQ(42, constReflectable->getField("reflectableNested")->getField("value")->getUInt32());
1930
1
    ASSERT_THROW(reflectable->createField("nonexistent"), CppRuntimeException);
1931
1
    ASSERT_THROW(reflectable->getParameter("nonexistent"), CppRuntimeException);
1932
1
    ASSERT_THROW(constReflectable->getParameter("nonexistent"), CppRuntimeException);
1933
1
    ASSERT_THROW(reflectable->callFunction("nonexistent"), CppRuntimeException);
1934
1
    ASSERT_THROW(constReflectable->callFunction("nonexistent"), CppRuntimeException);
1935
1
    ASSERT_THROW(reflectable->getChoice(), CppRuntimeException);
1936
1
    ASSERT_THROW(constReflectable->getChoice(), CppRuntimeException);
1937
1
    ASSERT_FALSE(reflectable->find("nonexistent"));
1938
1
    ASSERT_FALSE(constReflectable->find("nonexistent"));
1939
1
    ASSERT_FALSE((*reflectable)["nonexistent"]);
1940
1
    ASSERT_FALSE((*constReflectable)["nonexistent"]);
1941
1942
1
    ASSERT_THROW(reflectable->size(), CppRuntimeException); // not an array
1943
1
    ASSERT_THROW(reflectable->resize(0), CppRuntimeException); // not an array
1944
1
    ASSERT_THROW(reflectable->at(0), CppRuntimeException); // not an array
1945
1
    ASSERT_THROW(constReflectable->at(0), CppRuntimeException); // not an array
1946
1
    ASSERT_THROW((*reflectable)[0], CppRuntimeException); // not an array
1947
1
    ASSERT_THROW((*constReflectable)[0], CppRuntimeException); // not an array
1948
1
    ASSERT_THROW(reflectable->setAt(AnyHolder<>(), 0), CppRuntimeException); // not an array
1949
1
    ASSERT_THROW(reflectable->append(AnyHolder<>()), CppRuntimeException); // not an array
1950
1951
1
    ASSERT_THROW(reflectable->getBool(), CppRuntimeException);
1952
1
    ASSERT_THROW(reflectable->getInt8(), CppRuntimeException);
1953
1
    ASSERT_THROW(reflectable->getInt16(), CppRuntimeException);
1954
1
    ASSERT_THROW(reflectable->getInt32(), CppRuntimeException);
1955
1
    ASSERT_THROW(reflectable->getInt64(), CppRuntimeException);
1956
1
    ASSERT_THROW(reflectable->getUInt8(), CppRuntimeException);
1957
1
    ASSERT_THROW(reflectable->getUInt16(), CppRuntimeException);
1958
1
    ASSERT_THROW(reflectable->getUInt32(), CppRuntimeException);
1959
1
    ASSERT_THROW(reflectable->getUInt64(), CppRuntimeException);
1960
1
    ASSERT_THROW(reflectable->getFloat(), CppRuntimeException);
1961
1
    ASSERT_THROW(reflectable->getDouble(), CppRuntimeException);
1962
1
    ASSERT_THROW(reflectable->getBytes(), CppRuntimeException);
1963
1
    ASSERT_THROW(reflectable->getStringView(), CppRuntimeException);
1964
1
    ASSERT_THROW(reflectable->getBitBuffer(), CppRuntimeException);
1965
1966
1
    ASSERT_THROW(reflectable->toInt(), CppRuntimeException);
1967
1
    ASSERT_THROW(reflectable->toUInt(), CppRuntimeException);
1968
1
    ASSERT_THROW(reflectable->toDouble(), CppRuntimeException);
1969
1
    ASSERT_THROW(reflectable->toString(), CppRuntimeException);
1970
1971
1
    ASSERT_EQ(reflectable->bitSizeOf(), reflectable->initializeOffsets());
1972
1973
1
    ASSERT_NO_THROW(reflectable->initializeChildren());
1974
1975
1
    const size_t bitSizeOfValue = reflectable->bitSizeOf();
1976
1
    BitBuffer bitBuffer(bitSizeOfValue);
1977
1
    BitStreamWriter writer(bitBuffer);
1978
1
    reflectable->write(writer);
1979
1
    ASSERT_EQ(bitSizeOfValue, writer.getBitPosition());
1980
1
}
1981
1982
} // namespace zserio