Coverage Report

Created: 2024-04-30 09:35

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