Coverage Report

Created: 2023-12-13 14:58

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