Mercurial > code
annotate C++/Tests/Pack/main.cpp @ 290:7433ebe6a8b0
Pack:
* Stateful classes
* Use << and >> operators for more convenience,
* Use PackFileWriter and PackFileReader to write/read a file,
* Use PackStringWriter and PackStringReader to write/read a string,
* Pack now supports object serialization through Pack::TypeInfo<T>::(un)serialize.
author | David Demelier <markand@malikania.fr> |
---|---|
date | Thu, 13 Nov 2014 13:08:49 +0100 |
parents | b5d795389387 |
children | 345aaeb5e0ba |
rev | line source |
---|---|
223 | 1 /* |
2 * TestPack.cpp -- test the pack serializer | |
3 * | |
4 * Copyright (c) 2013, 2014 David Demelier <markand@malikania.fr> | |
5 * | |
6 * Permission to use, copy, modify, and/or distribute this software for any | |
7 * purpose with or without fee is hereby granted, provided that the above | |
8 * copyright notice and this permission notice appear in all copies. | |
9 * | |
10 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES | |
11 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF | |
12 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR | |
13 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES | |
14 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN | |
15 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF | |
16 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. | |
17 */ | |
18 | |
268 | 19 #include <sstream> |
20 #include <vector> | |
21 | |
249
3b4ae8feca1c
Switch to GoogleTest finished #285
David Demelier <markand@malikania.fr>
parents:
223
diff
changeset
|
22 #include <gtest/gtest.h> |
223 | 23 |
24 #include <Pack.h> | |
25 | |
290 | 26 struct Point |
27 { | |
28 uint32_t width{}; | |
29 uint32_t height{}; | |
30 | |
31 inline bool operator==(const Point &other) const | |
32 { | |
33 return width == other.width && height == other.height; | |
34 } | |
35 }; | |
36 | |
37 template <> | |
38 struct Pack::TypeInfo<Point> : public Pack::Serializable | |
39 { | |
40 static void serialize(PackWriter &writer, const Point &point) | |
41 { | |
42 writer << point.width << point.height; | |
43 } | |
44 | |
45 static void unserialize(PackReader &reader, Point &point) | |
46 { | |
47 reader >> point.width >> point.height; | |
48 } | |
49 }; | |
50 | |
268 | 51 TEST(File, simpleLittleEndian) |
52 { | |
53 uint8_t u8(1), r8; | |
54 uint16_t u16(2), r16; | |
55 uint32_t u32(3), r32; | |
56 uint64_t u64(4), r64; | |
57 | |
290 | 58 remove("output.bin"); |
59 | |
268 | 60 try { |
290 | 61 { |
62 PackFileWriter writer{"output.bin", Pack::Little}; | |
63 writer << u8 << u16 << u32 << u64; | |
64 } | |
268 | 65 |
290 | 66 PackFileReader reader{"output.bin", Pack::Little}; |
67 reader >> r8 >> r16 >> r32 >> r64; | |
268 | 68 |
69 ASSERT_EQ(u8, r8); | |
70 ASSERT_EQ(u16, r16); | |
71 ASSERT_EQ(u32, r32); | |
72 ASSERT_EQ(u64, r64); | |
73 } catch (const std::exception &error) { | |
74 FAIL() << error.what(); | |
75 } | |
76 } | |
77 | |
78 TEST(File, simpleBigEndian) | |
79 { | |
80 uint8_t u8(1), r8; | |
81 uint16_t u16(2), r16; | |
82 uint32_t u32(3), r32; | |
83 uint64_t u64(4), r64; | |
84 | |
290 | 85 remove("output.bin"); |
86 | |
268 | 87 try { |
290 | 88 { |
89 PackFileWriter writer{"output.bin", Pack::Big}; | |
90 writer << u8 << u16 << u32 << u64; | |
91 } | |
92 | |
93 PackFileReader reader{"output.bin", Pack::Big}; | |
94 reader >> r8 >> r16 >> r32 >> r64; | |
95 | |
96 ASSERT_EQ(u8, r8); | |
97 ASSERT_EQ(u16, r16); | |
98 ASSERT_EQ(u32, r32); | |
99 ASSERT_EQ(u64, r64); | |
100 } catch (const std::exception &error) { | |
101 FAIL() << error.what(); | |
102 } | |
103 } | |
104 | |
105 TEST(File, arrayLittleEndian) | |
106 { | |
107 std::vector<uint8_t> u8 { 1, 2, 3, 4, 5, 6, 7, 8 }; | |
108 std::vector<uint16_t> u16 { 10, 20, 30, 40, 50, 60, 70, 80 }; | |
109 std::vector<uint32_t> u32 { 100, 200, 300, 400, 500, 600, 700, 800 }; | |
110 std::vector<uint64_t> u64 { 1000, 2000, 3000, 4000, 5000, 6000, 7000, 8000 }; | |
111 | |
112 std::vector<uint8_t> r8(8); | |
113 std::vector<uint16_t> r16(8); | |
114 std::vector<uint32_t> r32(8); | |
115 std::vector<uint64_t> r64(8); | |
116 | |
117 remove("output.bin"); | |
118 | |
119 try { | |
120 { | |
121 PackFileWriter writer{"output.bin", Pack::Little}; | |
122 | |
123 writer << u8 << u16 << u32 << u64; | |
124 } | |
268 | 125 |
290 | 126 PackFileReader reader{"output.bin", Pack::Little}; |
127 | |
128 reader >> r8 >> r16 >> r32 >> r64; | |
129 | |
130 ASSERT_EQ(u8, r8); | |
131 ASSERT_EQ(u16, r16); | |
132 ASSERT_EQ(u32, r32); | |
133 ASSERT_EQ(u64, r64); | |
134 } catch (const std::exception &error) { | |
135 FAIL() << error.what(); | |
136 } | |
137 } | |
138 | |
139 TEST(File, arrayBigEndian) | |
140 { | |
141 std::vector<uint8_t> u8 { 1, 2, 3, 4, 5, 6, 7, 8 }; | |
142 std::vector<uint16_t> u16 { 10, 20, 30, 40, 50, 60, 70, 80 }; | |
143 std::vector<uint32_t> u32 { 100, 200, 300, 400, 500, 600, 700, 800 }; | |
144 std::vector<uint64_t> u64 { 1000, 2000, 3000, 4000, 5000, 6000, 7000, 8000 }; | |
145 | |
146 std::vector<uint8_t> r8(8); | |
147 std::vector<uint16_t> r16(8); | |
148 std::vector<uint32_t> r32(8); | |
149 std::vector<uint64_t> r64(8); | |
150 | |
151 remove("output.bin"); | |
152 | |
153 try { | |
154 { | |
155 PackFileWriter writer{"output.bin", Pack::Big}; | |
156 | |
157 writer << u8 << u16 << u32 << u64; | |
158 } | |
159 | |
160 PackFileReader reader{"output.bin", Pack::Big}; | |
161 | |
162 reader >> r8 >> r16 >> r32 >> r64; | |
268 | 163 |
164 ASSERT_EQ(u8, r8); | |
165 ASSERT_EQ(u16, r16); | |
166 ASSERT_EQ(u32, r32); | |
167 ASSERT_EQ(u64, r64); | |
168 } catch (const std::exception &error) { | |
169 FAIL() << error.what(); | |
170 } | |
171 } | |
172 | |
290 | 173 TEST(File, serializeSimpleLittleEndian) |
174 { | |
175 Point point{200, 400}; | |
176 Point result; | |
177 | |
178 remove("output.bin"); | |
179 | |
180 try { | |
181 { | |
182 PackFileWriter writer{"output.bin", Pack::Little}; | |
183 | |
184 writer << point; | |
185 } | |
186 | |
187 PackFileReader reader{"output.bin", Pack::Little}; | |
188 | |
189 reader >> result; | |
190 | |
191 ASSERT_EQ(point, result); | |
192 } catch (const std::exception &ex) { | |
193 std::cerr << "warning: " << ex.what() << std::endl; | |
194 } | |
195 } | |
196 | |
197 TEST(File, serializeSimpleBigEndian) | |
198 { | |
199 Point point{200, 400}; | |
200 Point result; | |
201 | |
202 remove("output.bin"); | |
203 | |
204 try { | |
205 { | |
206 PackFileWriter writer{"output.bin", Pack::Big}; | |
207 | |
208 writer << point; | |
209 } | |
210 | |
211 PackFileReader reader{"output.bin", Pack::Big}; | |
212 | |
213 reader >> result; | |
214 | |
215 ASSERT_EQ(point, result); | |
216 } catch (const std::exception &ex) { | |
217 std::cerr << "warning: " << ex.what() << std::endl; | |
218 } | |
219 } | |
220 | |
221 TEST(File, serializeArrayLittleEndian) | |
222 { | |
223 std::vector<Point> points{{10, 20}, {30, 40}}; | |
224 std::vector<Point> rpoints(2); | |
225 | |
226 remove("output.bin"); | |
227 | |
228 try { | |
229 { | |
230 PackFileWriter writer{"output.bin", Pack::Little}; | |
231 | |
232 writer << points; | |
233 } | |
234 | |
235 PackFileReader reader{"output.bin", Pack::Little}; | |
236 | |
237 reader >> rpoints; | |
238 | |
239 ASSERT_EQ(points, rpoints); | |
240 } catch (const std::exception &ex) { | |
241 std::cerr << "warning: " << ex.what() << std::endl; | |
242 } | |
243 } | |
244 | |
245 TEST(File, serializeArrayBigEndian) | |
246 { | |
247 std::vector<Point> points{{10, 20}, {30, 40}}; | |
248 std::vector<Point> rpoints(2); | |
249 | |
250 remove("output.bin"); | |
251 | |
252 try { | |
253 { | |
254 PackFileWriter writer{"output.bin", Pack::Big}; | |
255 | |
256 writer << points; | |
257 } | |
258 | |
259 PackFileReader reader{"output.bin", Pack::Big}; | |
260 | |
261 reader >> rpoints; | |
262 | |
263 ASSERT_EQ(points, rpoints); | |
264 } catch (const std::exception &ex) { | |
265 std::cerr << "warning: " << ex.what() << std::endl; | |
266 } | |
267 } | |
268 | |
268 | 269 TEST(String, simpleLittleEndian) |
223 | 270 { |
271 uint8_t u8(1), r8; | |
272 uint16_t u16(2), r16; | |
273 uint32_t u32(3), r32; | |
274 uint64_t u64(4), r64; | |
275 | |
276 try { | |
290 | 277 std::string input; |
268 | 278 |
290 | 279 { |
280 PackStringWriter writer{Pack::Little}; | |
281 writer << u8 << u16 << u32 << u64; | |
282 input = writer.buffer(); | |
283 } | |
284 | |
285 PackStringReader reader{std::move(input), Pack::Little}; | |
286 reader >> r8 >> r16 >> r32 >> r64; | |
223 | 287 |
249
3b4ae8feca1c
Switch to GoogleTest finished #285
David Demelier <markand@malikania.fr>
parents:
223
diff
changeset
|
288 ASSERT_EQ(u8, r8); |
3b4ae8feca1c
Switch to GoogleTest finished #285
David Demelier <markand@malikania.fr>
parents:
223
diff
changeset
|
289 ASSERT_EQ(u16, r16); |
3b4ae8feca1c
Switch to GoogleTest finished #285
David Demelier <markand@malikania.fr>
parents:
223
diff
changeset
|
290 ASSERT_EQ(u32, r32); |
3b4ae8feca1c
Switch to GoogleTest finished #285
David Demelier <markand@malikania.fr>
parents:
223
diff
changeset
|
291 ASSERT_EQ(u64, r64); |
268 | 292 } catch (const std::exception &error) { |
249
3b4ae8feca1c
Switch to GoogleTest finished #285
David Demelier <markand@malikania.fr>
parents:
223
diff
changeset
|
293 FAIL() << error.what(); |
3b4ae8feca1c
Switch to GoogleTest finished #285
David Demelier <markand@malikania.fr>
parents:
223
diff
changeset
|
294 } |
223 | 295 } |
296 | |
268 | 297 TEST(String, simpleBigEndian) |
223 | 298 { |
299 uint8_t u8(1), r8; | |
300 uint16_t u16(2), r16; | |
301 uint32_t u32(3), r32; | |
302 uint64_t u64(4), r64; | |
303 | |
304 try { | |
290 | 305 std::string input; |
306 | |
307 { | |
308 PackStringWriter writer{Pack::Big}; | |
309 writer << u8 << u16 << u32 << u64; | |
310 input = writer.buffer(); | |
311 } | |
312 | |
313 PackStringReader reader{std::move(input), Pack::Big}; | |
314 reader >> r8 >> r16 >> r32 >> r64; | |
315 | |
316 ASSERT_EQ(u8, r8); | |
317 ASSERT_EQ(u16, r16); | |
318 ASSERT_EQ(u32, r32); | |
319 ASSERT_EQ(u64, r64); | |
320 } catch (const std::exception &error) { | |
321 FAIL() << error.what(); | |
322 } | |
323 } | |
324 | |
325 TEST(String, arrayLittleEndian) | |
326 { | |
327 std::vector<uint8_t> u8 { 1, 2, 3, 4, 5, 6, 7, 8 }; | |
328 std::vector<uint16_t> u16 { 10, 20, 30, 40, 50, 60, 70, 80 }; | |
329 std::vector<uint32_t> u32 { 100, 200, 300, 400, 500, 600, 700, 800 }; | |
330 std::vector<uint64_t> u64 { 1000, 2000, 3000, 4000, 5000, 6000, 7000, 8000 }; | |
331 | |
332 std::vector<uint8_t> r8(8); | |
333 std::vector<uint16_t> r16(8); | |
334 std::vector<uint32_t> r32(8); | |
335 std::vector<uint64_t> r64(8); | |
336 | |
337 try { | |
338 std::string input; | |
339 | |
340 { | |
341 PackStringWriter writer{Pack::Little}; | |
268 | 342 |
290 | 343 writer << u8 << u16 << u32 << u64; |
344 input = writer.buffer(); | |
345 } | |
346 | |
347 PackStringReader reader{std::move(input), Pack::Little}; | |
348 | |
349 reader >> r8 >> r16 >> r32 >> r64; | |
350 | |
351 ASSERT_EQ(u8, r8); | |
352 ASSERT_EQ(u16, r16); | |
353 ASSERT_EQ(u32, r32); | |
354 ASSERT_EQ(u64, r64); | |
355 } catch (const std::exception &error) { | |
356 FAIL() << error.what(); | |
357 } | |
358 } | |
359 | |
360 TEST(String, arrayBigEndian) | |
361 { | |
362 std::vector<uint8_t> u8 { 1, 2, 3, 4, 5, 6, 7, 8 }; | |
363 std::vector<uint16_t> u16 { 10, 20, 30, 40, 50, 60, 70, 80 }; | |
364 std::vector<uint32_t> u32 { 100, 200, 300, 400, 500, 600, 700, 800 }; | |
365 std::vector<uint64_t> u64 { 1000, 2000, 3000, 4000, 5000, 6000, 7000, 8000 }; | |
366 | |
367 std::vector<uint8_t> r8(8); | |
368 std::vector<uint16_t> r16(8); | |
369 std::vector<uint32_t> r32(8); | |
370 std::vector<uint64_t> r64(8); | |
371 | |
372 try { | |
373 std::string input; | |
374 | |
375 { | |
376 PackStringWriter writer{Pack::Big}; | |
377 | |
378 writer << u8 << u16 << u32 << u64; | |
379 input = writer.buffer(); | |
380 } | |
381 | |
382 PackStringReader reader{std::move(input), Pack::Big}; | |
383 | |
384 reader >> r8 >> r16 >> r32 >> r64; | |
223 | 385 |
249
3b4ae8feca1c
Switch to GoogleTest finished #285
David Demelier <markand@malikania.fr>
parents:
223
diff
changeset
|
386 ASSERT_EQ(u8, r8); |
3b4ae8feca1c
Switch to GoogleTest finished #285
David Demelier <markand@malikania.fr>
parents:
223
diff
changeset
|
387 ASSERT_EQ(u16, r16); |
3b4ae8feca1c
Switch to GoogleTest finished #285
David Demelier <markand@malikania.fr>
parents:
223
diff
changeset
|
388 ASSERT_EQ(u32, r32); |
3b4ae8feca1c
Switch to GoogleTest finished #285
David Demelier <markand@malikania.fr>
parents:
223
diff
changeset
|
389 ASSERT_EQ(u64, r64); |
268 | 390 } catch (const std::exception &error) { |
391 FAIL() << error.what(); | |
392 } | |
393 } | |
394 | |
290 | 395 TEST(String, serializeSimpleLittleEndian) |
268 | 396 { |
290 | 397 Point point{200, 400}; |
398 Point result; | |
268 | 399 |
400 try { | |
290 | 401 std::string input; |
402 | |
403 { | |
404 PackStringWriter writer{Pack::Little}; | |
268 | 405 |
290 | 406 writer << point; |
407 input = writer.buffer(); | |
408 } | |
268 | 409 |
290 | 410 PackStringReader reader{std::move(input), Pack::Little}; |
268 | 411 |
290 | 412 reader >> result; |
413 | |
414 ASSERT_EQ(point, result); | |
415 } catch (const std::exception &ex) { | |
416 std::cerr << "warning: " << ex.what() << std::endl; | |
268 | 417 } |
418 } | |
419 | |
290 | 420 TEST(String, serializeSimpleBigEndian) |
268 | 421 { |
290 | 422 Point point{200, 400}; |
423 Point result; | |
424 | |
425 try { | |
426 std::string input; | |
427 | |
428 { | |
429 PackStringWriter writer{Pack::Big}; | |
430 | |
431 writer << point; | |
432 input = writer.buffer(); | |
433 } | |
268 | 434 |
290 | 435 PackStringReader reader{std::move(input), Pack::Big}; |
436 | |
437 reader >> result; | |
438 | |
439 ASSERT_EQ(point, result); | |
440 } catch (const std::exception &ex) { | |
441 std::cerr << "warning: " << ex.what() << std::endl; | |
442 } | |
443 } | |
444 | |
445 TEST(String, serializeArrayLittleEndian) | |
446 { | |
447 std::vector<Point> points{{10, 20}, {30, 40}}; | |
448 std::vector<Point> rpoints(2); | |
268 | 449 |
450 try { | |
290 | 451 std::string input; |
452 | |
453 { | |
454 PackStringWriter writer{Pack::Little}; | |
455 | |
456 writer << points; | |
457 input = writer.buffer(); | |
458 } | |
459 | |
460 PackStringReader reader{std::move(input), Pack::Little}; | |
461 | |
462 reader >> rpoints; | |
463 | |
464 ASSERT_EQ(points, rpoints); | |
465 } catch (const std::exception &ex) { | |
466 std::cerr << "warning: " << ex.what() << std::endl; | |
467 } | |
468 } | |
268 | 469 |
290 | 470 TEST(String, serializeArrayBigEndian) |
471 { | |
472 std::vector<Point> points{{10, 20}, {30, 40}}; | |
473 std::vector<Point> rpoints(2); | |
268 | 474 |
290 | 475 try { |
476 std::string input; | |
477 | |
478 { | |
479 PackStringWriter writer{Pack::Big}; | |
268 | 480 |
290 | 481 writer << points; |
482 input = writer.buffer(); | |
483 } | |
484 | |
485 PackStringReader reader{std::move(input), Pack::Big}; | |
486 | |
487 reader >> rpoints; | |
488 | |
489 ASSERT_EQ(points, rpoints); | |
490 } catch (const std::exception &ex) { | |
491 std::cerr << "warning: " << ex.what() << std::endl; | |
249
3b4ae8feca1c
Switch to GoogleTest finished #285
David Demelier <markand@malikania.fr>
parents:
223
diff
changeset
|
492 } |
223 | 493 } |
494 | |
249
3b4ae8feca1c
Switch to GoogleTest finished #285
David Demelier <markand@malikania.fr>
parents:
223
diff
changeset
|
495 int main(int argc, char **argv) |
223 | 496 { |
249
3b4ae8feca1c
Switch to GoogleTest finished #285
David Demelier <markand@malikania.fr>
parents:
223
diff
changeset
|
497 testing::InitGoogleTest(&argc, argv); |
223 | 498 |
249
3b4ae8feca1c
Switch to GoogleTest finished #285
David Demelier <markand@malikania.fr>
parents:
223
diff
changeset
|
499 return RUN_ALL_TESTS(); |
268 | 500 } |