Mercurial > code
annotate C++/tests/Pack/main.cpp @ 334:0b576ee64d45
* 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 |
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 | |
295
345aaeb5e0ba
Pack: fix constexpr can't be used on void return types
David Demelier <markand@malikania.fr>
parents:
290
diff
changeset
|
31 Point() = default; |
345aaeb5e0ba
Pack: fix constexpr can't be used on void return types
David Demelier <markand@malikania.fr>
parents:
290
diff
changeset
|
32 |
345aaeb5e0ba
Pack: fix constexpr can't be used on void return types
David Demelier <markand@malikania.fr>
parents:
290
diff
changeset
|
33 Point(uint32_t width, uint32_t height) |
345aaeb5e0ba
Pack: fix constexpr can't be used on void return types
David Demelier <markand@malikania.fr>
parents:
290
diff
changeset
|
34 : width(width) |
345aaeb5e0ba
Pack: fix constexpr can't be used on void return types
David Demelier <markand@malikania.fr>
parents:
290
diff
changeset
|
35 , height(height) |
345aaeb5e0ba
Pack: fix constexpr can't be used on void return types
David Demelier <markand@malikania.fr>
parents:
290
diff
changeset
|
36 { |
345aaeb5e0ba
Pack: fix constexpr can't be used on void return types
David Demelier <markand@malikania.fr>
parents:
290
diff
changeset
|
37 } |
345aaeb5e0ba
Pack: fix constexpr can't be used on void return types
David Demelier <markand@malikania.fr>
parents:
290
diff
changeset
|
38 |
290 | 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 | |
268 | 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 | |
290 | 66 remove("output.bin"); |
67 | |
268 | 68 try { |
290 | 69 { |
70 PackFileWriter writer{"output.bin", Pack::Little}; | |
71 writer << u8 << u16 << u32 << u64; | |
72 } | |
268 | 73 |
290 | 74 PackFileReader reader{"output.bin", Pack::Little}; |
75 reader >> r8 >> r16 >> r32 >> r64; | |
268 | 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 | |
290 | 93 remove("output.bin"); |
94 | |
268 | 95 try { |
290 | 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 } | |
268 | 133 |
290 | 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; | |
268 | 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 | |
290 | 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 | |
268 | 277 TEST(String, simpleLittleEndian) |
223 | 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 { | |
290 | 285 std::string input; |
268 | 286 |
290 | 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; | |
223 | 295 |
249
3b4ae8feca1c
Switch to GoogleTest finished #285
David Demelier <markand@malikania.fr>
parents:
223
diff
changeset
|
296 ASSERT_EQ(u8, r8); |
3b4ae8feca1c
Switch to GoogleTest finished #285
David Demelier <markand@malikania.fr>
parents:
223
diff
changeset
|
297 ASSERT_EQ(u16, r16); |
3b4ae8feca1c
Switch to GoogleTest finished #285
David Demelier <markand@malikania.fr>
parents:
223
diff
changeset
|
298 ASSERT_EQ(u32, r32); |
3b4ae8feca1c
Switch to GoogleTest finished #285
David Demelier <markand@malikania.fr>
parents:
223
diff
changeset
|
299 ASSERT_EQ(u64, r64); |
268 | 300 } catch (const std::exception &error) { |
249
3b4ae8feca1c
Switch to GoogleTest finished #285
David Demelier <markand@malikania.fr>
parents:
223
diff
changeset
|
301 FAIL() << error.what(); |
3b4ae8feca1c
Switch to GoogleTest finished #285
David Demelier <markand@malikania.fr>
parents:
223
diff
changeset
|
302 } |
223 | 303 } |
304 | |
268 | 305 TEST(String, simpleBigEndian) |
223 | 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 { | |
290 | 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}; | |
268 | 350 |
290 | 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; | |
223 | 393 |
249
3b4ae8feca1c
Switch to GoogleTest finished #285
David Demelier <markand@malikania.fr>
parents:
223
diff
changeset
|
394 ASSERT_EQ(u8, r8); |
3b4ae8feca1c
Switch to GoogleTest finished #285
David Demelier <markand@malikania.fr>
parents:
223
diff
changeset
|
395 ASSERT_EQ(u16, r16); |
3b4ae8feca1c
Switch to GoogleTest finished #285
David Demelier <markand@malikania.fr>
parents:
223
diff
changeset
|
396 ASSERT_EQ(u32, r32); |
3b4ae8feca1c
Switch to GoogleTest finished #285
David Demelier <markand@malikania.fr>
parents:
223
diff
changeset
|
397 ASSERT_EQ(u64, r64); |
268 | 398 } catch (const std::exception &error) { |
399 FAIL() << error.what(); | |
400 } | |
401 } | |
402 | |
290 | 403 TEST(String, serializeSimpleLittleEndian) |
268 | 404 { |
290 | 405 Point point{200, 400}; |
406 Point result; | |
268 | 407 |
408 try { | |
290 | 409 std::string input; |
410 | |
411 { | |
412 PackStringWriter writer{Pack::Little}; | |
268 | 413 |
290 | 414 writer << point; |
415 input = writer.buffer(); | |
416 } | |
268 | 417 |
290 | 418 PackStringReader reader{std::move(input), Pack::Little}; |
268 | 419 |
290 | 420 reader >> result; |
421 | |
422 ASSERT_EQ(point, result); | |
423 } catch (const std::exception &ex) { | |
424 std::cerr << "warning: " << ex.what() << std::endl; | |
268 | 425 } |
426 } | |
427 | |
290 | 428 TEST(String, serializeSimpleBigEndian) |
268 | 429 { |
290 | 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 } | |
268 | 442 |
290 | 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); | |
268 | 457 |
458 try { | |
290 | 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 } | |
268 | 477 |
290 | 478 TEST(String, serializeArrayBigEndian) |
479 { | |
480 std::vector<Point> points{{10, 20}, {30, 40}}; | |
481 std::vector<Point> rpoints(2); | |
268 | 482 |
290 | 483 try { |
484 std::string input; | |
485 | |
486 { | |
487 PackStringWriter writer{Pack::Big}; | |
268 | 488 |
290 | 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; | |
249
3b4ae8feca1c
Switch to GoogleTest finished #285
David Demelier <markand@malikania.fr>
parents:
223
diff
changeset
|
500 } |
223 | 501 } |
502 | |
249
3b4ae8feca1c
Switch to GoogleTest finished #285
David Demelier <markand@malikania.fr>
parents:
223
diff
changeset
|
503 int main(int argc, char **argv) |
223 | 504 { |
249
3b4ae8feca1c
Switch to GoogleTest finished #285
David Demelier <markand@malikania.fr>
parents:
223
diff
changeset
|
505 testing::InitGoogleTest(&argc, argv); |
223 | 506 |
249
3b4ae8feca1c
Switch to GoogleTest finished #285
David Demelier <markand@malikania.fr>
parents:
223
diff
changeset
|
507 return RUN_ALL_TESTS(); |
268 | 508 } |