Coverage Report

Created: 2024-07-18 11:41

test/zserio/SerializeUtilTest.cpp
Line
Count
Source
1
#include <array>
2
3
#include "gtest/gtest.h"
4
#include "test_object/polymorphic_allocator/SerializeEnum.h"
5
#include "test_object/polymorphic_allocator/SerializeNested.h"
6
#include "test_object/polymorphic_allocator/SerializeObject.h"
7
#include "test_object/std_allocator/SerializeEnum.h"
8
#include "test_object/std_allocator/SerializeNested.h"
9
#include "test_object/std_allocator/SerializeObject.h"
10
#include "zserio/Enums.h"
11
#include "zserio/SerializeUtil.h"
12
#include "zserio/pmr/PolymorphicAllocator.h"
13
14
namespace zserio
15
{
16
17
TEST(SerializeUtilTest, serializeEnum)
18
1
{
19
    // without allocator
20
1
    {
21
1
        const test_object::std_allocator::SerializeEnum serializeEnum =
22
1
                test_object::std_allocator::SerializeEnum::VALUE3;
23
1
        const BitBuffer bitBuffer = serialize(serializeEnum);
24
1
        ASSERT_EQ(8, bitBuffer.getBitSize());
25
1
        ASSERT_EQ(0x02, bitBuffer.getData()[0]);
26
1
    }
27
28
    // with std allocator
29
1
    {
30
1
        const std::allocator<uint8_t> allocator;
31
1
        const test_object::std_allocator::SerializeEnum serializeEnum =
32
1
                test_object::std_allocator::SerializeEnum::VALUE3;
33
1
        const BitBuffer bitBuffer = serialize(serializeEnum, allocator);
34
1
        ASSERT_EQ(8, bitBuffer.getBitSize());
35
1
        ASSERT_EQ(0x02, bitBuffer.getData()[0]);
36
1
    }
37
38
    // with polymorphic allocator
39
1
    {
40
1
        const pmr::PropagatingPolymorphicAllocator<> allocator;
41
1
        const test_object::polymorphic_allocator::SerializeEnum serializeEnum =
42
1
                test_object::polymorphic_allocator::SerializeEnum::VALUE3;
43
1
        const BasicBitBuffer<pmr::PropagatingPolymorphicAllocator<>> bitBuffer =
44
1
                serialize(serializeEnum, allocator);
45
1
        ASSERT_EQ(8, bitBuffer.getBitSize());
46
1
        ASSERT_EQ(0x02, bitBuffer.getData()[0]);
47
1
    }
48
1
}
49
50
TEST(SerializeUtilTest, serializeParameterizedObject)
51
1
{
52
1
    const int8_t param = 0x12;
53
1
    const uint8_t offset = 0;
54
1
    const uint32_t optionalValue = 0xDEADCAFE;
55
1
    {
56
        // without allocator
57
1
        test_object::std_allocator::SerializeNested serializeNested(offset, optionalValue);
58
1
        const BitBuffer bitBuffer = serialize(serializeNested, param);
59
1
        ASSERT_EQ(40, bitBuffer.getBitSize());
60
1
        ASSERT_EQ(0x01, bitBuffer.getData()[0]);
61
1
        ASSERT_EQ(0xDE, bitBuffer.getData()[1]);
62
1
        ASSERT_EQ(0xAD, bitBuffer.getData()[2]);
63
1
        ASSERT_EQ(0xCA, bitBuffer.getData()[3]);
64
1
        ASSERT_EQ(0xFE, bitBuffer.getData()[4]);
65
1
    }
66
67
1
    {
68
        // with std allocator
69
1
        const std::allocator<uint8_t> allocator;
70
1
        test_object::std_allocator::SerializeNested serializeNested(offset, optionalValue, allocator);
71
1
        const BitBuffer bitBuffer = serialize(serializeNested, allocator, param);
72
1
        ASSERT_EQ(40, bitBuffer.getBitSize());
73
1
        ASSERT_EQ(0x01, bitBuffer.getData()[0]);
74
1
        ASSERT_EQ(0xDE, bitBuffer.getData()[1]);
75
1
        ASSERT_EQ(0xAD, bitBuffer.getData()[2]);
76
1
        ASSERT_EQ(0xCA, bitBuffer.getData()[3]);
77
1
        ASSERT_EQ(0xFE, bitBuffer.getData()[4]);
78
1
    }
79
80
1
    {
81
        // with polymorphic allocator
82
1
        const pmr::PropagatingPolymorphicAllocator<> allocator;
83
1
        test_object::polymorphic_allocator::SerializeNested serializeNested(offset, optionalValue, allocator);
84
1
        const BasicBitBuffer<pmr::PropagatingPolymorphicAllocator<>> bitBuffer =
85
1
                serialize(serializeNested, allocator, param);
86
1
        ASSERT_EQ(40, bitBuffer.getBitSize());
87
1
        ASSERT_EQ(0x01, bitBuffer.getData()[0]);
88
1
        ASSERT_EQ(0xDE, bitBuffer.getData()[1]);
89
1
        ASSERT_EQ(0xAD, bitBuffer.getData()[2]);
90
1
        ASSERT_EQ(0xCA, bitBuffer.getData()[3]);
91
1
        ASSERT_EQ(0xFE, bitBuffer.getData()[4]);
92
1
    }
93
1
}
94
95
TEST(SerializeUtilTest, serializeObject)
96
1
{
97
1
    const int8_t param = 0x12;
98
1
    const uint8_t offset = 0;
99
1
    const uint32_t optionalValue = 0xDEADCAFE;
100
1
    {
101
        // without allocator
102
1
        test_object::std_allocator::SerializeNested serializeNested(offset, optionalValue);
103
1
        test_object::std_allocator::SerializeObject serializeObject(param, serializeNested);
104
1
        const BitBuffer bitBuffer = serialize(serializeObject);
105
1
        ASSERT_EQ(48, bitBuffer.getBitSize());
106
1
        ASSERT_EQ(0x12, bitBuffer.getData()[0]);
107
1
        ASSERT_EQ(0x02, bitBuffer.getData()[1]);
108
1
        ASSERT_EQ(0xDE, bitBuffer.getData()[2]);
109
1
        ASSERT_EQ(0xAD, bitBuffer.getData()[3]);
110
1
        ASSERT_EQ(0xCA, bitBuffer.getData()[4]);
111
1
        ASSERT_EQ(0xFE, bitBuffer.getData()[5]);
112
1
    }
113
114
1
    {
115
        // with std allocator
116
1
        const std::allocator<uint8_t> allocator;
117
1
        test_object::std_allocator::SerializeNested serializeNested(offset, optionalValue, allocator);
118
1
        test_object::std_allocator::SerializeObject serializeObject(param, serializeNested, allocator);
119
1
        const BitBuffer bitBuffer = serialize(serializeObject, allocator);
120
1
        ASSERT_EQ(48, bitBuffer.getBitSize());
121
1
        ASSERT_EQ(0x12, bitBuffer.getData()[0]);
122
1
        ASSERT_EQ(0x02, bitBuffer.getData()[1]);
123
1
        ASSERT_EQ(0xDE, bitBuffer.getData()[2]);
124
1
        ASSERT_EQ(0xAD, bitBuffer.getData()[3]);
125
1
        ASSERT_EQ(0xCA, bitBuffer.getData()[4]);
126
1
        ASSERT_EQ(0xFE, bitBuffer.getData()[5]);
127
1
    }
128
129
1
    {
130
        // with polymorphic allocator
131
1
        const pmr::PropagatingPolymorphicAllocator<> allocator;
132
1
        test_object::polymorphic_allocator::SerializeNested serializeNested(offset, optionalValue, allocator);
133
1
        test_object::polymorphic_allocator::SerializeObject serializeObject(param, serializeNested, allocator);
134
1
        const BasicBitBuffer<pmr::PropagatingPolymorphicAllocator<>> bitBuffer =
135
1
                serialize(serializeObject, allocator);
136
1
        ASSERT_EQ(48, bitBuffer.getBitSize());
137
1
        ASSERT_EQ(0x12, bitBuffer.getData()[0]);
138
1
        ASSERT_EQ(0x02, bitBuffer.getData()[1]);
139
1
        ASSERT_EQ(0xDE, bitBuffer.getData()[2]);
140
1
        ASSERT_EQ(0xAD, bitBuffer.getData()[3]);
141
1
        ASSERT_EQ(0xCA, bitBuffer.getData()[4]);
142
1
        ASSERT_EQ(0xFE, bitBuffer.getData()[5]);
143
1
    }
144
1
}
145
146
TEST(SerializeUtilTest, deserializeEnum)
147
1
{
148
1
    const std::array<uint8_t, 1> buffer = {0x02};
149
    // without allocator
150
1
    {
151
1
        const BitBuffer bitBuffer(buffer.data(), buffer.size() * 8);
152
1
        const test_object::std_allocator::SerializeEnum serializeEnum =
153
1
                deserialize<test_object::std_allocator::SerializeEnum>(bitBuffer);
154
1
        ASSERT_EQ(test_object::std_allocator::SerializeEnum::VALUE3, serializeEnum);
155
1
    }
156
157
    // with std allocator
158
1
    {
159
1
        const std::allocator<uint8_t> allocator;
160
1
        const BitBuffer bitBuffer(buffer.data(), buffer.size() * 8, allocator);
161
1
        const test_object::std_allocator::SerializeEnum serializeEnum =
162
1
                deserialize<test_object::std_allocator::SerializeEnum>(bitBuffer);
163
1
        ASSERT_EQ(test_object::std_allocator::SerializeEnum::VALUE3, serializeEnum);
164
1
    }
165
166
    // with polymorphic allocator
167
1
    {
168
1
        const pmr::PropagatingPolymorphicAllocator<> allocator;
169
1
        const BasicBitBuffer<pmr::PropagatingPolymorphicAllocator<>> bitBuffer(
170
1
                buffer.data(), buffer.size() * 8, allocator);
171
1
        const test_object::polymorphic_allocator::SerializeEnum serializeEnum =
172
1
                deserialize<test_object::polymorphic_allocator::SerializeEnum>(bitBuffer);
173
1
        ASSERT_EQ(test_object::polymorphic_allocator::SerializeEnum::VALUE3, serializeEnum);
174
1
    }
175
1
}
176
177
TEST(SerializeUtilTest, deserializeNestedObject)
178
1
{
179
1
    const std::array<uint8_t, 5> buffer = {0x01, 0xDE, 0xAD, 0xCA, 0xFE};
180
1
    const int8_t param = 0x12;
181
    // without allocator
182
1
    {
183
1
        const BitBuffer bitBuffer(buffer.data(), buffer.size() * 8);
184
1
        const test_object::std_allocator::SerializeNested serializeNested =
185
1
                deserialize<test_object::std_allocator::SerializeNested>(bitBuffer, param);
186
1
        ASSERT_EQ(param, serializeNested.getParam());
187
1
        ASSERT_EQ(0x01, serializeNested.getOffset());
188
1
        ASSERT_EQ(0xDEADCAFE, serializeNested.getOptionalValue());
189
190
1
        const BitBuffer wrongBitBuffer(buffer.data(), buffer.size() * 8 - 1);
191
1
        ASSERT_THROW(deserialize<test_object::std_allocator::SerializeNested>(wrongBitBuffer, param),
192
1
                CppRuntimeException);
193
1
    }
194
195
    // with std allocator
196
1
    {
197
1
        const std::allocator<uint8_t> allocator;
198
1
        const BitBuffer bitBuffer(buffer.data(), buffer.size() * 8, allocator);
199
1
        const test_object::std_allocator::SerializeNested serializeNested =
200
1
                deserialize<test_object::std_allocator::SerializeNested>(bitBuffer, param, allocator);
201
1
        ASSERT_EQ(param, serializeNested.getParam());
202
1
        ASSERT_EQ(0x01, serializeNested.getOffset());
203
1
        ASSERT_EQ(0xDEADCAFE, serializeNested.getOptionalValue());
204
205
1
        const BitBuffer wrongBitBuffer(buffer.data(), buffer.size() * 8 - 1, allocator);
206
1
        ASSERT_THROW(deserialize<test_object::std_allocator::SerializeNested>(wrongBitBuffer, param, allocator),
207
1
                CppRuntimeException);
208
1
    }
209
210
    // with polymorphic allocator
211
1
    {
212
1
        const pmr::PropagatingPolymorphicAllocator<> allocator;
213
1
        const BasicBitBuffer<pmr::PropagatingPolymorphicAllocator<>> bitBuffer(
214
1
                buffer.data(), buffer.size() * 8, allocator);
215
1
        const test_object::polymorphic_allocator::SerializeNested serializeNested =
216
1
                deserialize<test_object::polymorphic_allocator::SerializeNested>(bitBuffer, param, allocator);
217
1
        ASSERT_EQ(param, serializeNested.getParam());
218
1
        ASSERT_EQ(0x01, serializeNested.getOffset());
219
1
        ASSERT_EQ(0xDEADCAFE, serializeNested.getOptionalValue());
220
221
1
        const BasicBitBuffer<pmr::PropagatingPolymorphicAllocator<>> wrongBitBuffer(
222
1
                buffer.data(), buffer.size() * 8 - 1, allocator);
223
1
        ASSERT_THROW(deserialize<test_object::polymorphic_allocator::SerializeNested>(
224
1
                             wrongBitBuffer, param, allocator),
225
1
                CppRuntimeException);
226
1
    }
227
1
}
228
229
TEST(SerializeUtilTest, deserializeObject)
230
1
{
231
1
    const std::array<uint8_t, 6> buffer = {0x12, 0x02, 0xDE, 0xAD, 0xCA, 0xFE};
232
    // without allocator
233
1
    {
234
1
        const BitBuffer bitBuffer(buffer.data(), buffer.size() * 8);
235
1
        const test_object::std_allocator::SerializeObject serializeObject =
236
1
                deserialize<test_object::std_allocator::SerializeObject>(bitBuffer);
237
1
        ASSERT_EQ(0x12, serializeObject.getParam());
238
1
        const test_object::std_allocator::SerializeNested& serializeNested = serializeObject.getNested();
239
1
        ASSERT_EQ(0x12, serializeNested.getParam());
240
1
        ASSERT_EQ(0x02, serializeNested.getOffset());
241
1
        ASSERT_EQ(0xDEADCAFE, serializeNested.getOptionalValue());
242
1
    }
243
244
    // with std allocator
245
1
    {
246
1
        const std::allocator<uint8_t> allocator;
247
1
        const BitBuffer bitBuffer(buffer.data(), buffer.size() * 8, allocator);
248
1
        const test_object::std_allocator::SerializeObject serializeObject =
249
1
                deserialize<test_object::std_allocator::SerializeObject>(bitBuffer, allocator);
250
1
        ASSERT_EQ(0x12, serializeObject.getParam());
251
1
        const test_object::std_allocator::SerializeNested& serializeNested = serializeObject.getNested();
252
1
        ASSERT_EQ(0x12, serializeNested.getParam());
253
1
        ASSERT_EQ(0x02, serializeNested.getOffset());
254
1
        ASSERT_EQ(0xDEADCAFE, serializeNested.getOptionalValue());
255
1
    }
256
257
    // with polymorphic allocator
258
1
    {
259
1
        const pmr::PropagatingPolymorphicAllocator<> allocator;
260
1
        const BasicBitBuffer<pmr::PropagatingPolymorphicAllocator<>> bitBuffer(
261
1
                buffer.data(), buffer.size() * 8, allocator);
262
1
        const test_object::polymorphic_allocator::SerializeObject serializeObject =
263
1
                deserialize<test_object::polymorphic_allocator::SerializeObject>(bitBuffer, allocator);
264
1
        ASSERT_EQ(0x12, serializeObject.getParam());
265
1
        const test_object::polymorphic_allocator::SerializeNested& serializeNested =
266
1
                serializeObject.getNested();
267
1
        ASSERT_EQ(0x12, serializeNested.getParam());
268
1
        ASSERT_EQ(0x02, serializeNested.getOffset());
269
1
        ASSERT_EQ(0xDEADCAFE, serializeNested.getOptionalValue());
270
1
    }
271
1
}
272
273
TEST(SerializeUtilTest, serializeEnumToBytes)
274
1
{
275
    // without allocator
276
1
    {
277
1
        const test_object::std_allocator::SerializeEnum serializeEnum =
278
1
                test_object::std_allocator::SerializeEnum::VALUE3;
279
1
        const vector<uint8_t> buffer = serializeToBytes(serializeEnum);
280
1
        ASSERT_EQ(1, buffer.size());
281
1
        ASSERT_EQ(0x02, buffer[0]);
282
1
    }
283
284
    // with std allocator
285
1
    {
286
1
        const std::allocator<uint8_t> allocator;
287
1
        const test_object::std_allocator::SerializeEnum serializeEnum =
288
1
                test_object::std_allocator::SerializeEnum::VALUE3;
289
1
        const vector<uint8_t> buffer = serializeToBytes(serializeEnum, allocator);
290
1
        ASSERT_EQ(1, buffer.size());
291
1
        ASSERT_EQ(0x02, buffer[0]);
292
1
    }
293
294
    // with polymorphic allocator
295
1
    {
296
1
        const pmr::PropagatingPolymorphicAllocator<> allocator;
297
1
        const test_object::polymorphic_allocator::SerializeEnum serializeEnum =
298
1
                test_object::polymorphic_allocator::SerializeEnum::VALUE3;
299
1
        const vector<uint8_t, pmr::PropagatingPolymorphicAllocator<>> buffer =
300
1
                serializeToBytes(serializeEnum, allocator);
301
1
        ASSERT_EQ(1, buffer.size());
302
1
        ASSERT_EQ(0x02, buffer[0]);
303
1
    }
304
1
}
305
306
TEST(SerializeUtilTest, serializeParameterizedObjectToBytes)
307
1
{
308
1
    const int8_t param = 0x12;
309
1
    const uint8_t offset = 0;
310
1
    const uint32_t optionalValue = 0xDEADCAFE;
311
1
    {
312
        // without allocator
313
1
        test_object::std_allocator::SerializeNested serializeNested(offset, optionalValue);
314
1
        const vector<uint8_t> buffer = serializeToBytes(serializeNested, param);
315
1
        ASSERT_EQ(5, buffer.size());
316
1
        ASSERT_EQ(0x01, buffer[0]);
317
1
        ASSERT_EQ(0xDE, buffer[1]);
318
1
        ASSERT_EQ(0xAD, buffer[2]);
319
1
        ASSERT_EQ(0xCA, buffer[3]);
320
1
        ASSERT_EQ(0xFE, buffer[4]);
321
1
    }
322
323
1
    {
324
        // with std allocator
325
1
        const std::allocator<uint8_t> allocator;
326
1
        test_object::std_allocator::SerializeNested serializeNested(offset, optionalValue, allocator);
327
1
        const vector<uint8_t> buffer = serializeToBytes(serializeNested, allocator, param);
328
1
        ASSERT_EQ(5, buffer.size());
329
1
        ASSERT_EQ(0x01, buffer[0]);
330
1
        ASSERT_EQ(0xDE, buffer[1]);
331
1
        ASSERT_EQ(0xAD, buffer[2]);
332
1
        ASSERT_EQ(0xCA, buffer[3]);
333
1
        ASSERT_EQ(0xFE, buffer[4]);
334
1
    }
335
336
1
    {
337
        // with polymorphic allocator
338
1
        const pmr::PropagatingPolymorphicAllocator<> allocator;
339
1
        test_object::polymorphic_allocator::SerializeNested serializeNested(offset, optionalValue, allocator);
340
1
        const vector<uint8_t, pmr::PropagatingPolymorphicAllocator<>> buffer =
341
1
                serializeToBytes(serializeNested, allocator, param);
342
1
        ASSERT_EQ(5, buffer.size());
343
1
        ASSERT_EQ(0x01, buffer[0]);
344
1
        ASSERT_EQ(0xDE, buffer[1]);
345
1
        ASSERT_EQ(0xAD, buffer[2]);
346
1
        ASSERT_EQ(0xCA, buffer[3]);
347
1
        ASSERT_EQ(0xFE, buffer[4]);
348
1
    }
349
1
}
350
351
TEST(SerializeUtilTest, serializeObjectToBytes)
352
1
{
353
1
    const int8_t param = 0x12;
354
1
    const uint8_t offset = 0;
355
1
    const uint32_t optionalValue = 0xDEADCAFE;
356
1
    {
357
        // without allocator
358
1
        test_object::std_allocator::SerializeNested serializeNested(offset, optionalValue);
359
1
        test_object::std_allocator::SerializeObject serializeObject(param, serializeNested);
360
1
        const vector<uint8_t> buffer = serializeToBytes(serializeObject);
361
1
        ASSERT_EQ(6, buffer.size());
362
1
        ASSERT_EQ(0x12, buffer[0]);
363
1
        ASSERT_EQ(0x02, buffer[1]);
364
1
        ASSERT_EQ(0xDE, buffer[2]);
365
1
        ASSERT_EQ(0xAD, buffer[3]);
366
1
        ASSERT_EQ(0xCA, buffer[4]);
367
1
        ASSERT_EQ(0xFE, buffer[5]);
368
1
    }
369
370
1
    {
371
        // with std allocator
372
1
        const std::allocator<uint8_t> allocator;
373
1
        test_object::std_allocator::SerializeNested serializeNested(offset, optionalValue, allocator);
374
1
        test_object::std_allocator::SerializeObject serializeObject(param, serializeNested, allocator);
375
1
        const vector<uint8_t> buffer = serializeToBytes(serializeObject, allocator);
376
1
        ASSERT_EQ(6, buffer.size());
377
1
        ASSERT_EQ(0x12, buffer[0]);
378
1
        ASSERT_EQ(0x02, buffer[1]);
379
1
        ASSERT_EQ(0xDE, buffer[2]);
380
1
        ASSERT_EQ(0xAD, buffer[3]);
381
1
        ASSERT_EQ(0xCA, buffer[4]);
382
1
        ASSERT_EQ(0xFE, buffer[5]);
383
1
    }
384
385
1
    {
386
        // with polymorphic allocator
387
1
        const pmr::PropagatingPolymorphicAllocator<> allocator;
388
1
        test_object::polymorphic_allocator::SerializeNested serializeNested(offset, optionalValue, allocator);
389
1
        test_object::polymorphic_allocator::SerializeObject serializeObject(param, serializeNested, allocator);
390
1
        const vector<uint8_t, pmr::PropagatingPolymorphicAllocator<>> buffer =
391
1
                serializeToBytes(serializeObject, allocator);
392
1
        ASSERT_EQ(6, buffer.size());
393
1
        ASSERT_EQ(0x12, buffer[0]);
394
1
        ASSERT_EQ(0x02, buffer[1]);
395
1
        ASSERT_EQ(0xDE, buffer[2]);
396
1
        ASSERT_EQ(0xAD, buffer[3]);
397
1
        ASSERT_EQ(0xCA, buffer[4]);
398
1
        ASSERT_EQ(0xFE, buffer[5]);
399
1
    }
400
1
}
401
402
TEST(SerializeUtilTest, deserializeEnumFromBytes)
403
1
{
404
    // without allocator
405
1
    {
406
1
        const vector<uint8_t> buffer({0x02});
407
1
        const test_object::std_allocator::SerializeEnum serializeEnum =
408
1
                deserializeFromBytes<test_object::std_allocator::SerializeEnum>(buffer);
409
1
        ASSERT_EQ(test_object::std_allocator::SerializeEnum::VALUE3, serializeEnum);
410
1
    }
411
412
    // with std allocator
413
1
    {
414
1
        const std::allocator<uint8_t> allocator;
415
1
        const vector<uint8_t> buffer({0x02}, allocator);
416
1
        const test_object::std_allocator::SerializeEnum serializeEnum =
417
1
                deserializeFromBytes<test_object::std_allocator::SerializeEnum>(buffer);
418
1
        ASSERT_EQ(test_object::std_allocator::SerializeEnum::VALUE3, serializeEnum);
419
1
    }
420
421
    // with polymorphic allocator
422
1
    {
423
1
        const pmr::PropagatingPolymorphicAllocator<> allocator;
424
1
        const vector<uint8_t, pmr::PropagatingPolymorphicAllocator<>> buffer({0x02}, allocator);
425
1
        const test_object::polymorphic_allocator::SerializeEnum serializeEnum =
426
1
                deserializeFromBytes<test_object::polymorphic_allocator::SerializeEnum>(buffer);
427
1
        ASSERT_EQ(test_object::polymorphic_allocator::SerializeEnum::VALUE3, serializeEnum);
428
1
    }
429
1
}
430
431
TEST(SerializeUtilTest, deserializeNestedObjectFromBytes)
432
1
{
433
1
    const int8_t param = 0x12;
434
    // without allocator
435
1
    {
436
1
        const vector<uint8_t> buffer({0x01, 0xDE, 0xAD, 0xCA, 0xFE});
437
1
        const test_object::std_allocator::SerializeNested serializeNested =
438
1
                deserializeFromBytes<test_object::std_allocator::SerializeNested>(buffer, param);
439
1
        ASSERT_EQ(param, serializeNested.getParam());
440
1
        ASSERT_EQ(0x01, serializeNested.getOffset());
441
1
        ASSERT_EQ(0xDEADCAFE, serializeNested.getOptionalValue());
442
443
1
        const vector<uint8_t> wrongBuffer = {0x00, 0xDE, 0xAD, 0xCA, 0xFE};
444
1
        ASSERT_THROW(deserializeFromBytes<test_object::std_allocator::SerializeNested>(wrongBuffer, param),
445
1
                CppRuntimeException);
446
1
    }
447
448
    // with std allocator
449
1
    {
450
1
        const std::allocator<uint8_t> allocator;
451
1
        const vector<uint8_t> buffer({0x01, 0xDE, 0xAD, 0xCA, 0xFE}, allocator);
452
1
        const test_object::std_allocator::SerializeNested serializeNested =
453
1
                deserializeFromBytes<test_object::std_allocator::SerializeNested>(buffer, param, allocator);
454
1
        ASSERT_EQ(param, serializeNested.getParam());
455
1
        ASSERT_EQ(0x01, serializeNested.getOffset());
456
1
        ASSERT_EQ(0xDEADCAFE, serializeNested.getOptionalValue());
457
458
1
        const vector<uint8_t> wrongBuffer = {0x00, 0xDE, 0xAD, 0xCA, 0xFE};
459
1
        ASSERT_THROW(deserializeFromBytes<test_object::std_allocator::SerializeNested>(wrongBuffer, param),
460
1
                CppRuntimeException);
461
1
    }
462
463
    // with polymorphic allocator
464
1
    {
465
1
        const pmr::PropagatingPolymorphicAllocator<> allocator;
466
1
        const vector<uint8_t, pmr::PropagatingPolymorphicAllocator<>> buffer(
467
1
                {0x01, 0xDE, 0xAD, 0xCA, 0xFE}, allocator);
468
1
        const test_object::polymorphic_allocator::SerializeNested serializeNested =
469
1
                deserializeFromBytes<test_object::polymorphic_allocator::SerializeNested>(
470
1
                        buffer, param, allocator);
471
1
        ASSERT_EQ(param, serializeNested.getParam());
472
1
        ASSERT_EQ(0x01, serializeNested.getOffset());
473
1
        ASSERT_EQ(0xDEADCAFE, serializeNested.getOptionalValue());
474
475
1
        const vector<uint8_t> wrongBuffer = {0x00, 0xDE, 0xAD, 0xCA, 0xFE};
476
1
        ASSERT_THROW(
477
1
                deserializeFromBytes<test_object::polymorphic_allocator::SerializeNested>(wrongBuffer, param),
478
1
                CppRuntimeException);
479
1
    }
480
1
}
481
482
TEST(SerializeUtilTest, deserializeObjectFromBytes)
483
1
{
484
    // without allocator
485
1
    {
486
1
        const vector<uint8_t> buffer({0x12, 0x02, 0xDE, 0xAD, 0xCA, 0xFE});
487
1
        const test_object::std_allocator::SerializeObject serializeObject =
488
1
                deserializeFromBytes<test_object::std_allocator::SerializeObject>(buffer);
489
1
        ASSERT_EQ(0x12, serializeObject.getParam());
490
1
        const test_object::std_allocator::SerializeNested& serializeNested = serializeObject.getNested();
491
1
        ASSERT_EQ(0x12, serializeNested.getParam());
492
1
        ASSERT_EQ(0x02, serializeNested.getOffset());
493
1
        ASSERT_EQ(0xDEADCAFE, serializeNested.getOptionalValue());
494
1
    }
495
496
    // with std allocator
497
1
    {
498
1
        const std::allocator<uint8_t> allocator;
499
1
        const vector<uint8_t> buffer({0x12, 0x02, 0xDE, 0xAD, 0xCA, 0xFE}, allocator);
500
1
        const test_object::std_allocator::SerializeObject serializeObject =
501
1
                deserializeFromBytes<test_object::std_allocator::SerializeObject>(buffer, allocator);
502
1
        ASSERT_EQ(0x12, serializeObject.getParam());
503
1
        const test_object::std_allocator::SerializeNested& serializeNested = serializeObject.getNested();
504
1
        ASSERT_EQ(0x12, serializeNested.getParam());
505
1
        ASSERT_EQ(0x02, serializeNested.getOffset());
506
1
        ASSERT_EQ(0xDEADCAFE, serializeNested.getOptionalValue());
507
1
    }
508
509
    // with polymorphic allocator
510
1
    {
511
1
        const pmr::PropagatingPolymorphicAllocator<> allocator;
512
1
        const vector<uint8_t, pmr::PropagatingPolymorphicAllocator<>> buffer(
513
1
                {0x12, 0x02, 0xDE, 0xAD, 0xCA, 0xFE}, allocator);
514
1
        const test_object::polymorphic_allocator::SerializeObject serializeObject =
515
1
                deserializeFromBytes<test_object::polymorphic_allocator::SerializeObject>(buffer, allocator);
516
1
        ASSERT_EQ(0x12, serializeObject.getParam());
517
1
        const test_object::polymorphic_allocator::SerializeNested& serializeNested =
518
1
                serializeObject.getNested();
519
1
        ASSERT_EQ(0x12, serializeNested.getParam());
520
1
        ASSERT_EQ(0x02, serializeNested.getOffset());
521
1
        ASSERT_EQ(0xDEADCAFE, serializeNested.getOptionalValue());
522
1
    }
523
1
}
524
525
TEST(SerializeUtilTest, serializeToFileFromFile)
526
1
{
527
1
    const int8_t param = 0x12;
528
1
    const uint8_t offset = 0;
529
1
    const uint32_t optionalValue = 0xDEADCAFE;
530
1
    const std::string fileName = "SerializationTest.bin";
531
1
    {
532
        // without allocator
533
1
        test_object::std_allocator::SerializeNested serializeNested(offset, optionalValue);
534
1
        test_object::std_allocator::SerializeObject serializeObject(param, serializeNested);
535
1
        serializeToFile(serializeObject, fileName);
536
1
        const test_object::std_allocator::SerializeObject readSerializeObject =
537
1
                deserializeFromFile<test_object::std_allocator::SerializeObject>(fileName);
538
1
        ASSERT_EQ(serializeObject, readSerializeObject);
539
1
    }
540
541
1
    {
542
        // with std allocator
543
1
        const std::allocator<uint8_t> allocator;
544
1
        test_object::std_allocator::SerializeNested serializeNested(offset, optionalValue, allocator);
545
1
        test_object::std_allocator::SerializeObject serializeObject(param, serializeNested, allocator);
546
1
        serializeToFile(serializeObject, fileName);
547
1
        const test_object::std_allocator::SerializeObject readSerializeObject =
548
1
                deserializeFromFile<test_object::std_allocator::SerializeObject>(fileName);
549
1
        ASSERT_EQ(serializeObject, readSerializeObject);
550
1
    }
551
552
1
    {
553
        // with polymorphic allocator
554
1
        const pmr::PropagatingPolymorphicAllocator<> allocator;
555
1
        test_object::polymorphic_allocator::SerializeNested serializeNested(offset, optionalValue, allocator);
556
1
        test_object::polymorphic_allocator::SerializeObject serializeObject(param, serializeNested, allocator);
557
1
        serializeToFile(serializeObject, fileName);
558
1
        const test_object::polymorphic_allocator::SerializeObject readSerializeObject =
559
1
                deserializeFromFile<test_object::polymorphic_allocator::SerializeObject>(fileName);
560
1
        ASSERT_EQ(serializeObject, readSerializeObject);
561
1
    }
562
1
}
563
564
} // namespace zserio