Mercurial > code

comparison C++/tests/Pack/main.cpp @ 334:0b576ee64d45

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
* Create brand new hierarchy * Rename DynLib to Dynlib * Remove some warnings
author David Demelier <markand@malikania.fr>
date Sun, 08 Mar 2015 14:26:33 +0100
parents C++/Tests/Pack/main.cpp@345aaeb5e0ba
children
comparison
equal deleted inserted replaced
333:412ca7a5e1ea 334:0b576ee64d45
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
19 #include <sstream>
20 #include <vector>
21
22 #include <gtest/gtest.h>
23
24 #include <Pack.h>
25
26 struct Point
27 {
28 uint32_t width{};
29 uint32_t height{};
30
31 Point() = default;
32
33 Point(uint32_t width, uint32_t height)
34 : width(width)
35 , height(height)
36 {
37 }
38
39 inline bool operator==(const Point &other) const
40 {
41 return width == other.width && height == other.height;
42 }
43 };
44
45 template <>
46 struct Pack::TypeInfo<Point> : public Pack::Serializable
47 {
48 static void serialize(PackWriter &writer, const Point &point)
49 {
50 writer << point.width << point.height;
51 }
52
53 static void unserialize(PackReader &reader, Point &point)
54 {
55 reader >> point.width >> point.height;
56 }
57 };
58
59 TEST(File, simpleLittleEndian)
60 {
61 uint8_t u8(1), r8;
62 uint16_t u16(2), r16;
63 uint32_t u32(3), r32;
64 uint64_t u64(4), r64;
65
66 remove("output.bin");
67
68 try {
69 {
70 PackFileWriter writer{"output.bin", Pack::Little};
71 writer << u8 << u16 << u32 << u64;
72 }
73
74 PackFileReader reader{"output.bin", Pack::Little};
75 reader >> r8 >> r16 >> r32 >> r64;
76
77 ASSERT_EQ(u8, r8);
78 ASSERT_EQ(u16, r16);
79 ASSERT_EQ(u32, r32);
80 ASSERT_EQ(u64, r64);
81 } catch (const std::exception &error) {
82 FAIL() << error.what();
83 }
84 }
85
86 TEST(File, simpleBigEndian)
87 {
88 uint8_t u8(1), r8;
89 uint16_t u16(2), r16;
90 uint32_t u32(3), r32;
91 uint64_t u64(4), r64;
92
93 remove("output.bin");
94
95 try {
96 {
97 PackFileWriter writer{"output.bin", Pack::Big};
98 writer << u8 << u16 << u32 << u64;
99 }
100
101 PackFileReader reader{"output.bin", Pack::Big};
102 reader >> r8 >> r16 >> r32 >> r64;
103
104 ASSERT_EQ(u8, r8);
105 ASSERT_EQ(u16, r16);
106 ASSERT_EQ(u32, r32);
107 ASSERT_EQ(u64, r64);
108 } catch (const std::exception &error) {
109 FAIL() << error.what();
110 }
111 }
112
113 TEST(File, arrayLittleEndian)
114 {
115 std::vector<uint8_t> u8 { 1, 2, 3, 4, 5, 6, 7, 8 };
116 std::vector<uint16_t> u16 { 10, 20, 30, 40, 50, 60, 70, 80 };
117 std::vector<uint32_t> u32 { 100, 200, 300, 400, 500, 600, 700, 800 };
118 std::vector<uint64_t> u64 { 1000, 2000, 3000, 4000, 5000, 6000, 7000, 8000 };
119
120 std::vector<uint8_t> r8(8);
121 std::vector<uint16_t> r16(8);
122 std::vector<uint32_t> r32(8);
123 std::vector<uint64_t> r64(8);
124
125 remove("output.bin");
126
127 try {
128 {
129 PackFileWriter writer{"output.bin", Pack::Little};
130
131 writer << u8 << u16 << u32 << u64;
132 }
133
134 PackFileReader reader{"output.bin", Pack::Little};
135
136 reader >> r8 >> r16 >> r32 >> r64;
137
138 ASSERT_EQ(u8, r8);
139 ASSERT_EQ(u16, r16);
140 ASSERT_EQ(u32, r32);
141 ASSERT_EQ(u64, r64);
142 } catch (const std::exception &error) {
143 FAIL() << error.what();
144 }
145 }
146
147 TEST(File, arrayBigEndian)
148 {
149 std::vector<uint8_t> u8 { 1, 2, 3, 4, 5, 6, 7, 8 };
150 std::vector<uint16_t> u16 { 10, 20, 30, 40, 50, 60, 70, 80 };
151 std::vector<uint32_t> u32 { 100, 200, 300, 400, 500, 600, 700, 800 };
152 std::vector<uint64_t> u64 { 1000, 2000, 3000, 4000, 5000, 6000, 7000, 8000 };
153
154 std::vector<uint8_t> r8(8);
155 std::vector<uint16_t> r16(8);
156 std::vector<uint32_t> r32(8);
157 std::vector<uint64_t> r64(8);
158
159 remove("output.bin");
160
161 try {
162 {
163 PackFileWriter writer{"output.bin", Pack::Big};
164
165 writer << u8 << u16 << u32 << u64;
166 }
167
168 PackFileReader reader{"output.bin", Pack::Big};
169
170 reader >> r8 >> r16 >> r32 >> r64;
171
172 ASSERT_EQ(u8, r8);
173 ASSERT_EQ(u16, r16);
174 ASSERT_EQ(u32, r32);
175 ASSERT_EQ(u64, r64);
176 } catch (const std::exception &error) {
177 FAIL() << error.what();
178 }
179 }
180
181 TEST(File, serializeSimpleLittleEndian)
182 {
183 Point point{200, 400};
184 Point result;
185
186 remove("output.bin");
187
188 try {
189 {
190 PackFileWriter writer{"output.bin", Pack::Little};
191
192 writer << point;
193 }
194
195 PackFileReader reader{"output.bin", Pack::Little};
196
197 reader >> result;
198
199 ASSERT_EQ(point, result);
200 } catch (const std::exception &ex) {
201 std::cerr << "warning: " << ex.what() << std::endl;
202 }
203 }
204
205 TEST(File, serializeSimpleBigEndian)
206 {
207 Point point{200, 400};
208 Point result;
209
210 remove("output.bin");
211
212 try {
213 {
214 PackFileWriter writer{"output.bin", Pack::Big};
215
216 writer << point;
217 }
218
219 PackFileReader reader{"output.bin", Pack::Big};
220
221 reader >> result;
222
223 ASSERT_EQ(point, result);
224 } catch (const std::exception &ex) {
225 std::cerr << "warning: " << ex.what() << std::endl;
226 }
227 }
228
229 TEST(File, serializeArrayLittleEndian)
230 {
231 std::vector<Point> points{{10, 20}, {30, 40}};
232 std::vector<Point> rpoints(2);
233
234 remove("output.bin");
235
236 try {
237 {
238 PackFileWriter writer{"output.bin", Pack::Little};
239
240 writer << points;
241 }
242
243 PackFileReader reader{"output.bin", Pack::Little};
244
245 reader >> rpoints;
246
247 ASSERT_EQ(points, rpoints);
248 } catch (const std::exception &ex) {
249 std::cerr << "warning: " << ex.what() << std::endl;
250 }
251 }
252
253 TEST(File, serializeArrayBigEndian)
254 {
255 std::vector<Point> points{{10, 20}, {30, 40}};
256 std::vector<Point> rpoints(2);
257
258 remove("output.bin");
259
260 try {
261 {
262 PackFileWriter writer{"output.bin", Pack::Big};
263
264 writer << points;
265 }
266
267 PackFileReader reader{"output.bin", Pack::Big};
268
269 reader >> rpoints;
270
271 ASSERT_EQ(points, rpoints);
272 } catch (const std::exception &ex) {
273 std::cerr << "warning: " << ex.what() << std::endl;
274 }
275 }
276
277 TEST(String, simpleLittleEndian)
278 {
279 uint8_t u8(1), r8;
280 uint16_t u16(2), r16;
281 uint32_t u32(3), r32;
282 uint64_t u64(4), r64;
283
284 try {
285 std::string input;
286
287 {
288 PackStringWriter writer{Pack::Little};
289 writer << u8 << u16 << u32 << u64;
290 input = writer.buffer();
291 }
292
293 PackStringReader reader{std::move(input), Pack::Little};
294 reader >> r8 >> r16 >> r32 >> r64;
295
296 ASSERT_EQ(u8, r8);
297 ASSERT_EQ(u16, r16);
298 ASSERT_EQ(u32, r32);
299 ASSERT_EQ(u64, r64);
300 } catch (const std::exception &error) {
301 FAIL() << error.what();
302 }
303 }
304
305 TEST(String, simpleBigEndian)
306 {
307 uint8_t u8(1), r8;
308 uint16_t u16(2), r16;
309 uint32_t u32(3), r32;
310 uint64_t u64(4), r64;
311
312 try {
313 std::string input;
314
315 {
316 PackStringWriter writer{Pack::Big};
317 writer << u8 << u16 << u32 << u64;
318 input = writer.buffer();
319 }
320
321 PackStringReader reader{std::move(input), Pack::Big};
322 reader >> r8 >> r16 >> r32 >> r64;
323
324 ASSERT_EQ(u8, r8);
325 ASSERT_EQ(u16, r16);
326 ASSERT_EQ(u32, r32);
327 ASSERT_EQ(u64, r64);
328 } catch (const std::exception &error) {
329 FAIL() << error.what();
330 }
331 }
332
333 TEST(String, arrayLittleEndian)
334 {
335 std::vector<uint8_t> u8 { 1, 2, 3, 4, 5, 6, 7, 8 };
336 std::vector<uint16_t> u16 { 10, 20, 30, 40, 50, 60, 70, 80 };
337 std::vector<uint32_t> u32 { 100, 200, 300, 400, 500, 600, 700, 800 };
338 std::vector<uint64_t> u64 { 1000, 2000, 3000, 4000, 5000, 6000, 7000, 8000 };
339
340 std::vector<uint8_t> r8(8);
341 std::vector<uint16_t> r16(8);
342 std::vector<uint32_t> r32(8);
343 std::vector<uint64_t> r64(8);
344
345 try {
346 std::string input;
347
348 {
349 PackStringWriter writer{Pack::Little};
350
351 writer << u8 << u16 << u32 << u64;
352 input = writer.buffer();
353 }
354
355 PackStringReader reader{std::move(input), Pack::Little};
356
357 reader >> r8 >> r16 >> r32 >> r64;
358
359 ASSERT_EQ(u8, r8);
360 ASSERT_EQ(u16, r16);
361 ASSERT_EQ(u32, r32);
362 ASSERT_EQ(u64, r64);
363 } catch (const std::exception &error) {
364 FAIL() << error.what();
365 }
366 }
367
368 TEST(String, arrayBigEndian)
369 {
370 std::vector<uint8_t> u8 { 1, 2, 3, 4, 5, 6, 7, 8 };
371 std::vector<uint16_t> u16 { 10, 20, 30, 40, 50, 60, 70, 80 };
372 std::vector<uint32_t> u32 { 100, 200, 300, 400, 500, 600, 700, 800 };
373 std::vector<uint64_t> u64 { 1000, 2000, 3000, 4000, 5000, 6000, 7000, 8000 };
374
375 std::vector<uint8_t> r8(8);
376 std::vector<uint16_t> r16(8);
377 std::vector<uint32_t> r32(8);
378 std::vector<uint64_t> r64(8);
379
380 try {
381 std::string input;
382
383 {
384 PackStringWriter writer{Pack::Big};
385
386 writer << u8 << u16 << u32 << u64;
387 input = writer.buffer();
388 }
389
390 PackStringReader reader{std::move(input), Pack::Big};
391
392 reader >> r8 >> r16 >> r32 >> r64;
393
394 ASSERT_EQ(u8, r8);
395 ASSERT_EQ(u16, r16);
396 ASSERT_EQ(u32, r32);
397 ASSERT_EQ(u64, r64);
398 } catch (const std::exception &error) {
399 FAIL() << error.what();
400 }
401 }
402
403 TEST(String, serializeSimpleLittleEndian)
404 {
405 Point point{200, 400};
406 Point result;
407
408 try {
409 std::string input;
410
411 {
412 PackStringWriter writer{Pack::Little};
413
414 writer << point;
415 input = writer.buffer();
416 }
417
418 PackStringReader reader{std::move(input), Pack::Little};
419
420 reader >> result;
421
422 ASSERT_EQ(point, result);
423 } catch (const std::exception &ex) {
424 std::cerr << "warning: " << ex.what() << std::endl;
425 }
426 }
427
428 TEST(String, serializeSimpleBigEndian)
429 {
430 Point point{200, 400};
431 Point result;
432
433 try {
434 std::string input;
435
436 {
437 PackStringWriter writer{Pack::Big};
438
439 writer << point;
440 input = writer.buffer();
441 }
442
443 PackStringReader reader{std::move(input), Pack::Big};
444
445 reader >> result;
446
447 ASSERT_EQ(point, result);
448 } catch (const std::exception &ex) {
449 std::cerr << "warning: " << ex.what() << std::endl;
450 }
451 }
452
453 TEST(String, serializeArrayLittleEndian)
454 {
455 std::vector<Point> points{{10, 20}, {30, 40}};
456 std::vector<Point> rpoints(2);
457
458 try {
459 std::string input;
460
461 {
462 PackStringWriter writer{Pack::Little};
463
464 writer << points;
465 input = writer.buffer();
466 }
467
468 PackStringReader reader{std::move(input), Pack::Little};
469
470 reader >> rpoints;
471
472 ASSERT_EQ(points, rpoints);
473 } catch (const std::exception &ex) {
474 std::cerr << "warning: " << ex.what() << std::endl;
475 }
476 }
477
478 TEST(String, serializeArrayBigEndian)
479 {
480 std::vector<Point> points{{10, 20}, {30, 40}};
481 std::vector<Point> rpoints(2);
482
483 try {
484 std::string input;
485
486 {
487 PackStringWriter writer{Pack::Big};
488
489 writer << points;
490 input = writer.buffer();
491 }
492
493 PackStringReader reader{std::move(input), Pack::Big};
494
495 reader >> rpoints;
496
497 ASSERT_EQ(points, rpoints);
498 } catch (const std::exception &ex) {
499 std::cerr << "warning: " << ex.what() << std::endl;
500 }
501 }
502
503 int main(int argc, char **argv)
504 {
505 testing::InitGoogleTest(&argc, argv);
506
507 return RUN_ALL_TESTS();
508 }