Mercurial > code
annotate C++/Tests/Pack/main.cpp @ 295:345aaeb5e0ba
Pack: fix constexpr can't be used on void return types
| author | David Demelier <markand@malikania.fr> |
|---|---|
| date | Thu, 13 Nov 2014 21:07:48 +0100 |
| parents | 7433ebe6a8b0 |
| 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 } |