Coverage Report

Created: 2025-07-31 16:33

test/zserio/ReflectableUtilTest.cpp
Line
Count
Source
1
#include <cmath>
2
3
#include "gtest/gtest.h"
4
#include "test_object/std_allocator/ReflectableUtilBitmask.h"
5
#include "test_object/std_allocator/ReflectableUtilEnum.h"
6
#include "test_object/std_allocator/ReflectableUtilUnion.h"
7
#include "zserio/ReflectableData.h"
8
#include "zserio/ReflectableUtil.h"
9
#include "zserio/TypeInfo.h"
10
11
using test_object::std_allocator::ReflectableUtilBitmask;
12
using test_object::std_allocator::ReflectableUtilChoice;
13
using test_object::std_allocator::ReflectableUtilEnum;
14
using test_object::std_allocator::ReflectableUtilObject;
15
using test_object::std_allocator::ReflectableUtilUnion;
16
17
namespace zserio
18
{
19
20
TEST(ReflectableUtilTest, unequalTypeInfo)
21
1
{
22
1
    ASSERT_FALSE(ReflectableUtil::equal(reflectable(Bool(false)), reflectable(UInt8(13))));
23
1
    ASSERT_FALSE(ReflectableUtil::equal(reflectable(Int8(0)), reflectable(Int16(0))));
24
1
    ASSERT_FALSE(ReflectableUtil::equal(reflectable(Int8(0)), reflectable(UInt8(0))));
25
1
    ASSERT_FALSE(ReflectableUtil::equal(reflectable(UInt64(0)), reflectable(VarSize(0))));
26
1
    ASSERT_FALSE(ReflectableUtil::equal(reflectable(Int8(0)), reflectable(Float32(0.0))));
27
1
    ASSERT_FALSE(ReflectableUtil::equal(reflectable(Float16(0.0F)), reflectable(Float32(0.0F))));
28
1
    ASSERT_FALSE(ReflectableUtil::equal(reflectable(String("")), reflectable(Int8(0))));
29
1
    ASSERT_FALSE(ReflectableUtil::equal(reflectable(BitBuffer(BitBuffer())), reflectable(String(""))));
30
1
}
31
32
TEST(ReflectableUtilTest, equalsNullValues)
33
1
{
34
1
    ASSERT_TRUE(ReflectableUtil::equal(nullptr, nullptr));
35
1
    ASSERT_FALSE(ReflectableUtil::equal(reflectable(Bool(false)), nullptr));
36
1
    ASSERT_FALSE(ReflectableUtil::equal(nullptr, reflectable(Int8(0))));
37
1
}
38
39
TEST(ReflectableUtilTest, equalBools)
40
1
{
41
1
    ASSERT_TRUE(ReflectableUtil::equal(reflectable(Bool(true)), reflectable(Bool(true))));
42
1
    ASSERT_FALSE(ReflectableUtil::equal(reflectable(Bool(false)), reflectable(Bool(true))));
43
1
    ASSERT_FALSE(ReflectableUtil::equal(reflectable(Bool(true)), reflectable(Bool(false))));
44
1
}
45
46
TEST(ReflectableUtilTest, equalSingedIntegrals)
47
1
{
48
1
    ASSERT_TRUE(ReflectableUtil::equal(reflectable(Int8(INT8_MIN)), reflectable(Int8(INT8_MIN))));
49
1
    ASSERT_TRUE(ReflectableUtil::equal(reflectable(Int8(INT8_MAX)), reflectable(Int8(INT8_MAX))));
50
1
    ASSERT_FALSE(ReflectableUtil::equal(reflectable(Int8(-1)), reflectable(Int8(0))));
51
1
    ASSERT_FALSE(ReflectableUtil::equal(reflectable(Int8(INT8_MIN)), reflectable(Int8(INT8_MAX))));
52
53
1
    ASSERT_TRUE(ReflectableUtil::equal(reflectable(Int16(INT16_MIN)), reflectable(Int16(INT16_MIN))));
54
1
    ASSERT_TRUE(ReflectableUtil::equal(reflectable(Int16(INT16_MAX)), reflectable(Int16(INT16_MAX))));
55
1
    ASSERT_FALSE(ReflectableUtil::equal(reflectable(Int16(-1)), reflectable(Int16(0))));
56
1
    ASSERT_FALSE(ReflectableUtil::equal(reflectable(Int16(INT16_MIN)), reflectable(Int16(INT16_MAX))));
57
58
1
    ASSERT_TRUE(ReflectableUtil::equal(reflectable(Int32(INT32_MIN)), reflectable(Int32(INT32_MIN))));
59
1
    ASSERT_TRUE(ReflectableUtil::equal(reflectable(Int32(INT32_MAX)), reflectable(Int32(INT32_MAX))));
60
1
    ASSERT_FALSE(ReflectableUtil::equal(reflectable(Int32(-1)), reflectable(Int32(0))));
61
1
    ASSERT_FALSE(ReflectableUtil::equal(reflectable(Int32(INT32_MIN)), reflectable(Int32(INT32_MAX))));
62
63
1
    ASSERT_TRUE(ReflectableUtil::equal(reflectable(Int64(INT64_MIN)), reflectable(Int64(INT64_MIN))));
64
1
    ASSERT_TRUE(ReflectableUtil::equal(reflectable(Int64(INT64_MAX)), reflectable(Int64(INT64_MAX))));
65
1
    ASSERT_FALSE(ReflectableUtil::equal(reflectable(Int64(-1)), reflectable(Int64(0))));
66
1
    ASSERT_FALSE(ReflectableUtil::equal(reflectable(Int64(INT64_MIN)), reflectable(Int64(INT64_MAX))));
67
1
}
68
69
TEST(ReflectableUtilTest, equalUnsignedIntegrals)
70
1
{
71
1
    ASSERT_TRUE(ReflectableUtil::equal(reflectable(UInt8(0)), reflectable(UInt8(0))));
72
1
    ASSERT_TRUE(ReflectableUtil::equal(reflectable(UInt8(UINT8_MAX)), reflectable(UInt8(UINT8_MAX))));
73
1
    ASSERT_FALSE(ReflectableUtil::equal(reflectable(UInt8(0)), reflectable(UInt8(1))));
74
1
    ASSERT_FALSE(ReflectableUtil::equal(reflectable(UInt8(0)), reflectable(UInt8(UINT8_MAX))));
75
76
1
    ASSERT_TRUE(ReflectableUtil::equal(reflectable(UInt16(0)), reflectable(UInt16(0))));
77
1
    ASSERT_TRUE(ReflectableUtil::equal(reflectable(UInt16(UINT16_MAX)), reflectable(UInt16(UINT16_MAX))));
78
1
    ASSERT_FALSE(ReflectableUtil::equal(reflectable(UInt16(0)), reflectable(UInt16(1))));
79
1
    ASSERT_FALSE(ReflectableUtil::equal(reflectable(UInt16(0)), reflectable(UInt16(UINT16_MAX))));
80
81
1
    ASSERT_TRUE(ReflectableUtil::equal(reflectable(UInt32(0)), reflectable(UInt32(0))));
82
1
    ASSERT_TRUE(ReflectableUtil::equal(reflectable(UInt32(UINT32_MAX)), reflectable(UInt32(UINT32_MAX))));
83
1
    ASSERT_FALSE(ReflectableUtil::equal(reflectable(UInt32(0)), reflectable(UInt32(1))));
84
1
    ASSERT_FALSE(ReflectableUtil::equal(reflectable(UInt32(0)), reflectable(UInt32(UINT32_MAX))));
85
86
1
    ASSERT_TRUE(ReflectableUtil::equal(reflectable(UInt64(0)), reflectable(UInt64(0))));
87
1
    ASSERT_TRUE(ReflectableUtil::equal(reflectable(UInt64(UINT64_MAX)), reflectable(UInt64(UINT64_MAX))));
88
1
    ASSERT_FALSE(ReflectableUtil::equal(reflectable(UInt64(0)), reflectable(UInt64(1))));
89
1
    ASSERT_FALSE(ReflectableUtil::equal(reflectable(UInt64(0)), reflectable(UInt64(UINT64_MAX))));
90
1
}
91
92
TEST(ReflectableUtilTest, equalFloatingPoints)
93
1
{
94
1
    ASSERT_TRUE(ReflectableUtil::equal(reflectable(Float16(0.0F)), reflectable(Float16(0.0F))));
95
1
    ASSERT_FALSE(ReflectableUtil::equal(reflectable(Float16(-1.0F)), reflectable(Float16(1.0F))));
96
97
1
    ASSERT_TRUE(ReflectableUtil::equal(reflectable(Float32(0.0F)), reflectable(Float32(0.0F))));
98
1
    ASSERT_FALSE(ReflectableUtil::equal(reflectable(Float32(-1.0F)), reflectable(Float32(1.0F))));
99
100
1
    ASSERT_TRUE(ReflectableUtil::equal(reflectable(Float64(0.0)), reflectable(Float64(0.0))));
101
1
    ASSERT_FALSE(ReflectableUtil::equal(reflectable(Float64(-1.0)), reflectable(Float64(1.0))));
102
103
1
    ASSERT_TRUE(ReflectableUtil::equal(reflectable(Float64(std::numeric_limits<double>::epsilon())),
104
1
            reflectable(Float64(std::numeric_limits<double>::epsilon()))));
105
1
    ASSERT_TRUE(ReflectableUtil::equal(reflectable(Float64(std::numeric_limits<double>::min())),
106
1
            reflectable(Float64(std::numeric_limits<double>::min()))));
107
108
1
    ASSERT_TRUE(ReflectableUtil::equal(
109
1
            reflectable(Float64(1.0 + std::numeric_limits<double>::epsilon())), reflectable(Float64(1.0))));
110
1
    ASSERT_TRUE(ReflectableUtil::equal(reflectable(Float64(std::numeric_limits<double>::denorm_min() * 2)),
111
1
            reflectable(Float64(std::numeric_limits<double>::denorm_min()))));
112
113
1
    ASSERT_TRUE(ReflectableUtil::equal(
114
1
            reflectable(Float64(static_cast<double>(NAN))), reflectable(Float64(static_cast<double>(NAN)))));
115
1
    ASSERT_TRUE(ReflectableUtil::equal(reflectable(Float64(static_cast<double>(INFINITY))),
116
1
            reflectable(Float64(static_cast<double>(INFINITY)))));
117
1
    ASSERT_TRUE(ReflectableUtil::equal(reflectable(Float64(-static_cast<double>(INFINITY))),
118
1
            reflectable(Float64(-static_cast<double>(INFINITY)))));
119
120
1
    ASSERT_FALSE(ReflectableUtil::equal(
121
1
            reflectable(Float64(0.0)), reflectable(Float64(static_cast<double>(INFINITY)))));
122
1
    ASSERT_FALSE(ReflectableUtil::equal(
123
1
            reflectable(Float64(static_cast<double>(INFINITY))), reflectable(Float64(0.0))));
124
125
1
    ASSERT_FALSE(
126
1
            ReflectableUtil::equal(reflectable(Float64(0.0)), reflectable(Float64(static_cast<double>(NAN)))));
127
1
    ASSERT_FALSE(
128
1
            ReflectableUtil::equal(reflectable(Float64(static_cast<double>(NAN))), reflectable(Float64(0.0))));
129
130
1
    ASSERT_FALSE(ReflectableUtil::equal(reflectable(Float64(static_cast<double>(NAN))),
131
1
            reflectable(Float64(static_cast<double>(INFINITY)))));
132
1
    ASSERT_FALSE(ReflectableUtil::equal(reflectable(Float64(static_cast<double>(INFINITY))),
133
1
            reflectable(Float64(static_cast<double>(NAN)))));
134
135
1
    ASSERT_FALSE(ReflectableUtil::equal(reflectable(Float64(static_cast<double>(INFINITY))),
136
1
            reflectable(Float64(-static_cast<double>(INFINITY)))));
137
1
    ASSERT_FALSE(ReflectableUtil::equal(reflectable(Float64(-static_cast<double>(INFINITY))),
138
1
            reflectable(Float64(static_cast<double>(INFINITY)))));
139
1
}
140
141
TEST(ReflectableUtilTest, equalStrings)
142
1
{
143
1
    ASSERT_TRUE(ReflectableUtil::equal(reflectable(String("")), reflectable(String(""))));
144
1
    ASSERT_TRUE(ReflectableUtil::equal(reflectable(String("test")), reflectable(String("test"))));
145
1
    ASSERT_FALSE(ReflectableUtil::equal(reflectable(String("")), reflectable(String("a"))));
146
1
    ASSERT_FALSE(ReflectableUtil::equal(reflectable(String("1")), reflectable(String(""))));
147
1
    ASSERT_FALSE(ReflectableUtil::equal(reflectable(String("test")), reflectable(String("test2"))));
148
1
}
149
150
TEST(ReflectableUtilTest, equalBitBuffers)
151
1
{
152
1
    ASSERT_TRUE(
153
1
            ReflectableUtil::equal(reflectable(BitBuffer(BitBuffer())), reflectable(BitBuffer(BitBuffer()))));
154
1
    ASSERT_TRUE(ReflectableUtil::equal(
155
1
            reflectable(BitBuffer(BitBuffer({0xAB}, 8))), reflectable(BitBuffer(BitBuffer({0xAB}, 8)))));
156
1
    ASSERT_FALSE(ReflectableUtil::equal(
157
1
            reflectable(BitBuffer(BitBuffer({0xAB}, 8))), reflectable(BitBuffer(BitBuffer()))));
158
1
}
159
160
TEST(ReflectableUtilTest, equalBytes)
161
1
{
162
1
    Vector<uint8_t> bytesData1{{0xCA, 0xFE}};
163
1
    Vector<uint8_t> bytesData2{{0xCA, 0xDE}};
164
1
    Vector<uint8_t> bytesEmpty;
165
166
1
    ASSERT_TRUE(ReflectableUtil::equal(reflectable(Bytes(bytesEmpty)), reflectable(Bytes(bytesEmpty))));
167
1
    ASSERT_TRUE(ReflectableUtil::equal(reflectable(Bytes(bytesData1)), reflectable(Bytes(bytesData1))));
168
1
    ASSERT_FALSE(ReflectableUtil::equal(reflectable(Bytes(bytesData1)), reflectable(Bytes(bytesEmpty))));
169
1
    ASSERT_FALSE(ReflectableUtil::equal(reflectable(Bytes(bytesData1)), reflectable(Bytes(bytesData2))));
170
1
}
171
172
TEST(ReflectableUtilTest, equalEnums)
173
1
{
174
1
    const ReflectableUtilEnum oneEnum = ReflectableUtilEnum::ONE;
175
1
    const ReflectableUtilEnum twoEnum = ReflectableUtilEnum::TWO;
176
177
1
    ASSERT_TRUE(ReflectableUtil::equal(reflectable(oneEnum), reflectable(oneEnum)));
178
1
    ASSERT_TRUE(ReflectableUtil::equal(reflectable(twoEnum), reflectable(twoEnum)));
179
1
    ASSERT_FALSE(ReflectableUtil::equal(reflectable(oneEnum), reflectable(twoEnum)));
180
1
}
181
182
TEST(ReflectableUtilTest, equalBitmasks)
183
1
{
184
1
    const ReflectableUtilBitmask readBitmask = ReflectableUtilBitmask::Values::READ;
185
1
    const ReflectableUtilBitmask writeBitmask = ReflectableUtilBitmask::Values::WRITE;
186
187
1
    ASSERT_TRUE(ReflectableUtil::equal(reflectable(readBitmask), reflectable(readBitmask)));
188
1
    ASSERT_TRUE(ReflectableUtil::equal(reflectable(writeBitmask), reflectable(writeBitmask)));
189
1
    ASSERT_FALSE(ReflectableUtil::equal(reflectable(writeBitmask), reflectable(readBitmask)));
190
1
}
191
192
TEST(ReflectableUtilTest, equalCompounds)
193
1
{
194
1
    ReflectableUtilUnion compound1 = ReflectableUtilUnion();
195
1
    compound1.emplace<ReflectableUtilUnion::Tag::reflectableUtilEnum>(ReflectableUtilEnum::ONE);
196
197
1
    ReflectableUtilUnion compound2 = ReflectableUtilUnion();
198
1
    compound2.emplace<ReflectableUtilUnion::Tag::reflectableUtilEnum>(ReflectableUtilEnum::TWO);
199
200
1
    ReflectableUtilUnion compound3 = ReflectableUtilUnion();
201
1
    compound3.emplace<ReflectableUtilUnion::Tag::reflectableUtilBitmask>(ReflectableUtilBitmask::Values::READ);
202
203
1
    ReflectableUtilUnion compound4 = ReflectableUtilUnion();
204
1
    compound4.emplace<ReflectableUtilUnion::Tag::reflectableUtilObject>(
205
1
            ReflectableUtilObject(0, ReflectableUtilChoice()));
206
207
1
    ReflectableUtilUnion compound5 = ReflectableUtilUnion();
208
1
    compound5.emplace<ReflectableUtilUnion::Tag::reflectableUtilObject>(
209
1
            ReflectableUtilObject(1, ReflectableUtilChoice()));
210
1
    compound5.get<ReflectableUtilUnion::Tag::reflectableUtilObject>()
211
1
            .reflectableUtilChoice.emplace<ReflectableUtilChoice::Tag::array>(std::vector<UInt32>());
212
213
1
    ReflectableUtilUnion compound6 = ReflectableUtilUnion();
214
1
    compound6.emplace<ReflectableUtilUnion::Tag::reflectableUtilObject>(
215
1
            ReflectableUtilObject(1, ReflectableUtilChoice()));
216
1
    compound6.get<ReflectableUtilUnion::Tag::reflectableUtilObject>()
217
1
            .reflectableUtilChoice.emplace<ReflectableUtilChoice::Tag::array>(std::vector<UInt32>{{1, 2, 3}});
218
219
1
    ASSERT_TRUE(ReflectableUtil::equal(reflectable(compound1), reflectable(compound1)));
220
1
    ASSERT_TRUE(ReflectableUtil::equal(reflectable(compound2), reflectable(compound2)));
221
1
    ASSERT_TRUE(ReflectableUtil::equal(reflectable(compound3), reflectable(compound3)));
222
1
    ASSERT_TRUE(ReflectableUtil::equal(reflectable(compound4), reflectable(compound4)));
223
1
    ASSERT_TRUE(ReflectableUtil::equal(reflectable(compound5), reflectable(compound5)));
224
1
    ASSERT_TRUE(ReflectableUtil::equal(reflectable(compound6), reflectable(compound6)));
225
226
1
    ASSERT_FALSE(ReflectableUtil::equal(reflectable(compound1), reflectable(compound2)));
227
1
    ASSERT_FALSE(ReflectableUtil::equal(reflectable(compound1), reflectable(compound3)));
228
1
    ASSERT_FALSE(ReflectableUtil::equal(reflectable(compound1), reflectable(compound4)));
229
1
    ASSERT_FALSE(ReflectableUtil::equal(reflectable(compound1), reflectable(compound5)));
230
1
    ASSERT_FALSE(ReflectableUtil::equal(reflectable(compound1), reflectable(compound6)));
231
232
    // unequal fields in choice
233
1
    ASSERT_FALSE(ReflectableUtil::equal(reflectable(compound5), reflectable(compound6)));
234
235
    // array and not array
236
1
    std::vector<ReflectableUtilUnion> compoundArray(1);
237
1
    ASSERT_FALSE(ReflectableUtil::equal(reflectable(compound1), reflectableArray(compoundArray)));
238
1
    ASSERT_FALSE(ReflectableUtil::equal(reflectableArray(compoundArray), reflectable(compound1)));
239
1
}
240
241
TEST(ReflectableUtilTest, equalArrays)
242
1
{
243
1
    std::vector<UInt32> array1 = {1, 2, 3};
244
1
    std::vector<UInt32> array2 = {1, 2, 4};
245
1
    std::vector<UInt32> array3 = {1, 2};
246
247
1
    auto array1Reflectable = reflectableArray(array1);
248
1
    auto array2Reflectable = reflectableArray(array2);
249
1
    auto array3Reflectable = reflectableArray(array3);
250
251
1
    ASSERT_TRUE(ReflectableUtil::equal(array1Reflectable, array1Reflectable));
252
1
    ASSERT_TRUE(ReflectableUtil::equal(array2Reflectable, array2Reflectable));
253
1
    ASSERT_TRUE(ReflectableUtil::equal(array3Reflectable, array3Reflectable));
254
255
1
    ASSERT_FALSE(ReflectableUtil::equal(array1Reflectable, array2Reflectable));
256
1
    ASSERT_FALSE(ReflectableUtil::equal(array1Reflectable, array3Reflectable));
257
1
}
258
259
TEST(ReflectableUtilTest, equalWrong)
260
1
{
261
1
    using allocator_type = ::std::allocator<uint8_t>;
262
1
    class WrongTypeInfo : public detail::TypeInfoBase<allocator_type>
263
1
    {
264
1
    public:
265
1
        WrongTypeInfo(std::string_view schemaName, SchemaType schemaType, CppType cppType) :
266
2
                TypeInfoBase(schemaName, schemaType, cppType)
267
2
        {}
268
1
    };
269
270
1
    const WrongTypeInfo wrongTypeInfo = {"int<>", SchemaType::DYNAMIC_SIGNED_BITFIELD, CppType::PUBSUB};
271
1
    const WrongTypeInfo wrongTypeInfoDiffName = {"diff", SchemaType::DYNAMIC_SIGNED_BITFIELD, CppType::PUBSUB};
272
273
1
    class Reflectable : public ::zserio::detail::ReflectableDataAllocatorHolderBase<allocator_type>
274
1
    {
275
1
    public:
276
1
        explicit Reflectable(
277
1
                const detail::TypeInfoBase<allocator_type>& typeInfo, const allocator_type& allocator) :
278
2
                ::zserio::detail::ReflectableDataAllocatorHolderBase<allocator_type>(typeInfo, allocator)
279
2
        {}
280
1
    };
281
282
1
    auto wrongReflectable =
283
1
            std::allocate_shared<Reflectable>(allocator_type(), wrongTypeInfo, allocator_type());
284
1
    auto wrongReflectableDiffName =
285
1
            std::allocate_shared<Reflectable>(allocator_type(), wrongTypeInfoDiffName, allocator_type());
286
287
1
    ASSERT_THROW(ReflectableUtil::equal(wrongReflectable, wrongReflectable), CppRuntimeException);
288
1
    ASSERT_FALSE(ReflectableUtil::equal(wrongReflectable, wrongReflectableDiffName));
289
1
}
290
291
TEST(ReflectableUtilTest, getValueArithmeticType)
292
1
{
293
1
    ASSERT_FALSE(ReflectableUtil::getValue<Bool>(reflectable(Bool(false))));
294
295
1
    ASSERT_EQ(1, ReflectableUtil::getValue<UInt8>(reflectable(UInt8(1))));
296
1
    ASSERT_EQ(12, ReflectableUtil::getValue<UInt16>(reflectable(UInt16(12))));
297
1
    ASSERT_EQ(123, ReflectableUtil::getValue<UInt32>(reflectable(UInt32(123))));
298
1
    ASSERT_EQ(1234, ReflectableUtil::getValue<UInt64>(reflectable(UInt64(1234))));
299
300
1
    ASSERT_EQ(-1, ReflectableUtil::getValue<Int8>(reflectable(Int8(-1))));
301
1
    ASSERT_EQ(-12, ReflectableUtil::getValue<Int16>(reflectable(Int16(-12))));
302
1
    ASSERT_EQ(-123, ReflectableUtil::getValue<Int32>(reflectable(Int32(-123))));
303
1
    ASSERT_EQ(-1234, ReflectableUtil::getValue<Int64>(reflectable(Int64(-1234))));
304
305
1
    ASSERT_EQ(12, ReflectableUtil::getValue<VarUInt16>(reflectable(VarUInt16(12))));
306
1
    ASSERT_EQ(123, ReflectableUtil::getValue<VarUInt32>(reflectable(VarUInt32(123))));
307
1
    ASSERT_EQ(1234, ReflectableUtil::getValue<VarUInt64>(reflectable(VarUInt64(1234))));
308
1
    ASSERT_EQ(UINT64_MAX, ReflectableUtil::getValue<VarUInt>(reflectable(VarUInt(UINT64_MAX))));
309
310
1
    ASSERT_EQ(-12, ReflectableUtil::getValue<VarInt16>(reflectable(VarInt16(-12))));
311
1
    ASSERT_EQ(-123, ReflectableUtil::getValue<VarInt32>(reflectable(VarInt32(-123))));
312
1
    ASSERT_EQ(-1234, ReflectableUtil::getValue<VarInt64>(reflectable(VarInt64(-1234))));
313
1
    ASSERT_EQ(INT64_MIN, ReflectableUtil::getValue<VarInt>(reflectable(VarInt(INT64_MIN))));
314
1
    ASSERT_EQ(INT64_MAX, ReflectableUtil::getValue<VarInt>(reflectable(VarInt(INT64_MAX))));
315
316
1
    ASSERT_EQ(0, ReflectableUtil::getValue<VarSize>(reflectable(VarSize(0))));
317
318
1
    ASSERT_EQ(1.0F, ReflectableUtil::getValue<Float16>(reflectable(Float16(1.0F))));
319
1
    ASSERT_EQ(3.5F, ReflectableUtil::getValue<Float32>(reflectable(Float32(3.5F))));
320
1
    ASSERT_EQ(9.875, ReflectableUtil::getValue<Float64>(reflectable(Float64(9.875))));
321
1
}
322
323
TEST(ReflectableUtilTest, getValueString)
324
1
{
325
1
    ASSERT_EQ("test", ReflectableUtil::getValue<std::string_view>(reflectable(String("test"))));
326
1
}
327
328
TEST(ReflectableUtilTest, getValueBitBuffer)
329
1
{
330
1
    const BitBuffer bitBuffer;
331
1
    auto reflectablePtr = reflectable(bitBuffer);
332
1
    const BitBuffer& bitBufferRef = ReflectableUtil::getValue<BitBuffer>(reflectablePtr);
333
1
    ASSERT_EQ(bitBuffer, bitBufferRef);
334
1
}
335
336
TEST(ReflectableUtilTest, getValueEnum)
337
1
{
338
1
    ReflectableUtilEnum reflectableUtilEnum = ReflectableUtilEnum::ONE;
339
1
    auto reflectablePtr = reflectable(reflectableUtilEnum);
340
1
    ASSERT_EQ(reflectableUtilEnum, ReflectableUtil::getValue<ReflectableUtilEnum>(reflectablePtr));
341
1
}
342
343
TEST(ReflectableUtilTest, getValueBitmask)
344
1
{
345
1
    ReflectableUtilBitmask reflectableUtilBitmask = ReflectableUtilBitmask::Values::READ;
346
1
    auto reflectablePtr = reflectable(reflectableUtilBitmask);
347
1
    ASSERT_EQ(reflectableUtilBitmask, ReflectableUtil::getValue<ReflectableUtilBitmask>(reflectablePtr));
348
1
}
349
350
TEST(ReflectableUtilTest, getValueCompound)
351
1
{
352
1
    ReflectableUtilUnion reflectableUtilUnion;
353
1
    auto reflectablePtr = reflectable(reflectableUtilUnion);
354
1
    ASSERT_EQ(&reflectableUtilUnion, &ReflectableUtil::getValue<ReflectableUtilUnion>(reflectablePtr));
355
356
1
    ReflectableUtilUnion& reflectableUtilUnionRef =
357
1
            ReflectableUtil::getValue<ReflectableUtilUnion>(reflectablePtr);
358
1
    reflectableUtilUnionRef.emplace<ReflectableUtilUnion::Tag::reflectableUtilBitmask>(
359
1
            ReflectableUtilBitmask::Values::WRITE);
360
1
    ASSERT_EQ(ReflectableUtilBitmask::Values::WRITE,
361
1
            reflectableUtilUnion.get<ReflectableUtilUnion::Tag::reflectableUtilBitmask>());
362
363
1
    auto constReflectable = reflectable(static_cast<const ReflectableUtilUnion&>(reflectableUtilUnion));
364
1
    const ReflectableUtilUnion& reflectableUtilUnionConstRef =
365
1
            ReflectableUtil::getValue<ReflectableUtilUnion>(constReflectable);
366
1
    ASSERT_EQ(ReflectableUtilBitmask::Values::WRITE,
367
1
            reflectableUtilUnionConstRef.get<ReflectableUtilUnion::Tag::reflectableUtilBitmask>());
368
1
    ASSERT_EQ(&reflectableUtilUnion, &reflectableUtilUnionConstRef);
369
1
}
370
371
TEST(ReflectableUtilTest, getValueBuiltinArray)
372
1
{
373
1
    std::vector<UInt8> uint8Array{{1, 2, 3}};
374
1
    auto reflectablePtr = reflectableArray(uint8Array);
375
1
    std::vector<UInt8>& uint8ArrayRef = ReflectableUtil::getValue<std::vector<UInt8>>(reflectablePtr);
376
1
    ASSERT_EQ(&uint8Array, &uint8ArrayRef);
377
378
1
    auto constReflectable = reflectableArray(static_cast<const std::vector<UInt8>&>(uint8Array));
379
1
    const std::vector<UInt8>& uint8ArrayConstRef =
380
1
            ReflectableUtil::getValue<std::vector<UInt8>>(constReflectable);
381
1
    ASSERT_EQ(&uint8Array, &uint8ArrayConstRef);
382
1
}
383
384
TEST(ReflectableUtilTest, getValueCompoundArray)
385
1
{
386
1
    std::vector<ReflectableUtilUnion> reflectableUtilUnionArray;
387
1
    auto reflectablePtr = reflectableArray(reflectableUtilUnionArray);
388
1
    std::vector<ReflectableUtilUnion>& reflectableUtilUnionArrayRef =
389
1
            ReflectableUtil::getValue<std::vector<ReflectableUtilUnion>>(reflectablePtr);
390
1
    ASSERT_EQ(&reflectableUtilUnionArray, &reflectableUtilUnionArrayRef);
391
1
}
392
393
} // namespace zserio