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 |