1 // 2 // ByteOrderTest.cpp 3 // 4 // Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH. 5 // and Contributors. 6 // 7 // SPDX-License-Identifier: BSL-1.0 8 // 9 10 11 #include "ByteOrderTest.h" 12 #include "CppUnit/TestCaller.h" 13 #include "CppUnit/TestSuite.h" 14 #include "Poco/ByteOrder.h" 15 16 17 using Poco::ByteOrder; 18 using Poco::Int16; 19 using Poco::UInt16; 20 using Poco::Int32; 21 using Poco::UInt32; 22 #if defined(POCO_HAVE_INT64) 23 using Poco::Int64; 24 using Poco::UInt64; 25 #endif 26 27 ByteOrderTest(const std::string & name)28ByteOrderTest::ByteOrderTest(const std::string& name): CppUnit::TestCase(name) 29 { 30 } 31 32 ~ByteOrderTest()33ByteOrderTest::~ByteOrderTest() 34 { 35 } 36 37 testByteOrderFlip()38void ByteOrderTest::testByteOrderFlip() 39 { 40 { 41 Int16 norm = (Int16) 0xAABB; 42 Int16 flip = ByteOrder::flipBytes(norm); 43 assertTrue (UInt16(flip) == 0xBBAA); 44 flip = ByteOrder::flipBytes(flip); 45 assertTrue (flip == norm); 46 } 47 { 48 UInt16 norm = (UInt16) 0xAABB; 49 UInt16 flip = ByteOrder::flipBytes(norm); 50 assertTrue (flip == 0xBBAA); 51 flip = ByteOrder::flipBytes(flip); 52 assertTrue (flip == norm); 53 } 54 { 55 Int32 norm = 0xAABBCCDD; 56 Int32 flip = ByteOrder::flipBytes(norm); 57 assertTrue (UInt32(flip) == 0xDDCCBBAA); 58 flip = ByteOrder::flipBytes(flip); 59 assertTrue (flip == norm); 60 } 61 { 62 UInt32 norm = 0xAABBCCDD; 63 UInt32 flip = ByteOrder::flipBytes(norm); 64 assertTrue (flip == 0xDDCCBBAA); 65 flip = ByteOrder::flipBytes(flip); 66 assertTrue (flip == norm); 67 } 68 #if defined(POCO_HAVE_INT64) 69 { 70 Int64 norm = (Int64(0x8899AABB) << 32) + 0xCCDDEEFF; 71 Int64 flip = ByteOrder::flipBytes(norm); 72 assertTrue (flip == (Int64(0xFFEEDDCC) << 32) + 0xBBAA9988); 73 flip = ByteOrder::flipBytes(flip); 74 assertTrue (flip == norm); 75 } 76 { 77 UInt64 norm = (UInt64(0x8899AABB) << 32) + 0xCCDDEEFF; 78 UInt64 flip = ByteOrder::flipBytes(norm); 79 assertTrue (flip == (UInt64(0xFFEEDDCC) << 32) + 0xBBAA9988); 80 flip = ByteOrder::flipBytes(flip); 81 assertTrue (flip == norm); 82 } 83 #endif 84 } 85 86 testByteOrderBigEndian()87void ByteOrderTest::testByteOrderBigEndian() 88 { 89 #if defined(POCO_ARCH_BIG_ENDIAN) 90 // 91 // big-endian systems 92 // 93 { 94 Int16 norm = 4; 95 Int16 flip = ByteOrder::toBigEndian(norm); 96 assertTrue (norm == flip); 97 } 98 { 99 UInt16 norm = 4; 100 UInt16 flip = ByteOrder::toBigEndian(norm); 101 assertTrue (norm == flip); 102 } 103 { 104 Int32 norm = 4; 105 Int32 flip = ByteOrder::toBigEndian(norm); 106 assertTrue (norm == flip); 107 } 108 { 109 UInt32 norm = 4; 110 UInt32 flip = ByteOrder::toBigEndian(norm); 111 assertTrue (norm == flip); 112 } 113 #if defined(POCO_HAVE_INT64) 114 { 115 Int64 norm = 4; 116 Int64 flip = ByteOrder::toBigEndian(norm); 117 assertTrue (norm == flip); 118 } 119 { 120 UInt64 norm = 4; 121 UInt64 flip = ByteOrder::toBigEndian(norm); 122 assertTrue (norm == flip); 123 } 124 #endif 125 126 { 127 Int16 norm = 4; 128 Int16 flip = ByteOrder::fromBigEndian(norm); 129 assertTrue (norm == flip); 130 } 131 { 132 UInt16 norm = 4; 133 UInt16 flip = ByteOrder::fromBigEndian(norm); 134 assertTrue (norm == flip); 135 } 136 { 137 Int32 norm = 4; 138 Int32 flip = ByteOrder::fromBigEndian(norm); 139 assertTrue (norm == flip); 140 } 141 { 142 UInt32 norm = 4; 143 UInt32 flip = ByteOrder::fromBigEndian(norm); 144 assertTrue (norm == flip); 145 } 146 #if defined(POCO_HAVE_INT64) 147 { 148 Int64 norm = 4; 149 Int64 flip = ByteOrder::fromBigEndian(norm); 150 assertTrue (norm == flip); 151 } 152 { 153 UInt64 norm = 4; 154 UInt64 flip = ByteOrder::fromBigEndian(norm); 155 assertTrue (norm == flip); 156 } 157 #endif 158 #else 159 // 160 // little-endian systems 161 // 162 { 163 Int16 norm = 4; 164 Int16 flip = ByteOrder::toBigEndian(norm); 165 assertTrue (norm != flip); 166 flip = ByteOrder::flipBytes(flip); 167 assertTrue (norm == flip); 168 } 169 { 170 UInt16 norm = 4; 171 UInt16 flip = ByteOrder::toBigEndian(norm); 172 assertTrue (norm != flip); 173 flip = ByteOrder::flipBytes(flip); 174 assertTrue (norm == flip); 175 } 176 { 177 Int32 norm = 4; 178 Int32 flip = ByteOrder::toBigEndian(norm); 179 assertTrue (norm != flip); 180 flip = ByteOrder::flipBytes(flip); 181 assertTrue (norm == flip); 182 } 183 { 184 UInt32 norm = 4; 185 UInt32 flip = ByteOrder::toBigEndian(norm); 186 assertTrue (norm != flip); 187 flip = ByteOrder::flipBytes(flip); 188 assertTrue (norm == flip); 189 } 190 #if defined(POCO_HAVE_INT64) 191 { 192 Int64 norm = 4; 193 Int64 flip = ByteOrder::toBigEndian(norm); 194 assertTrue (norm != flip); 195 flip = ByteOrder::flipBytes(flip); 196 assertTrue (norm == flip); 197 } 198 { 199 UInt64 norm = 4; 200 UInt64 flip = ByteOrder::toBigEndian(norm); 201 assertTrue (norm != flip); 202 flip = ByteOrder::flipBytes(flip); 203 assertTrue (norm == flip); 204 } 205 #endif 206 207 { 208 Int16 norm = 4; 209 Int16 flip = ByteOrder::fromBigEndian(norm); 210 assertTrue (norm != flip); 211 flip = ByteOrder::flipBytes(flip); 212 assertTrue (norm == flip); 213 } 214 { 215 UInt16 norm = 4; 216 UInt16 flip = ByteOrder::fromBigEndian(norm); 217 assertTrue (norm != flip); 218 flip = ByteOrder::flipBytes(flip); 219 assertTrue (norm == flip); 220 } 221 { 222 Int32 norm = 4; 223 Int32 flip = ByteOrder::fromBigEndian(norm); 224 assertTrue (norm != flip); 225 flip = ByteOrder::flipBytes(flip); 226 assertTrue (norm == flip); 227 } 228 { 229 UInt32 norm = 4; 230 UInt32 flip = ByteOrder::fromBigEndian(norm); 231 assertTrue (norm != flip); 232 flip = ByteOrder::flipBytes(flip); 233 assertTrue (norm == flip); 234 } 235 #if defined(POCO_HAVE_INT64) 236 { 237 Int64 norm = 4; 238 Int64 flip = ByteOrder::fromBigEndian(norm); 239 assertTrue (norm != flip); 240 flip = ByteOrder::flipBytes(flip); 241 assertTrue (norm == flip); 242 } 243 { 244 UInt64 norm = 4; 245 UInt64 flip = ByteOrder::fromBigEndian(norm); 246 assertTrue (norm != flip); 247 flip = ByteOrder::flipBytes(flip); 248 assertTrue (norm == flip); 249 } 250 #endif 251 #endif 252 } 253 254 testByteOrderLittleEndian()255void ByteOrderTest::testByteOrderLittleEndian() 256 { 257 #if defined(POCO_ARCH_LITTLE_ENDIAN) 258 // 259 // big-endian systems 260 // 261 { 262 Int16 norm = 4; 263 Int16 flip = ByteOrder::toLittleEndian(norm); 264 assertTrue (norm == flip); 265 } 266 { 267 UInt16 norm = 4; 268 UInt16 flip = ByteOrder::toLittleEndian(norm); 269 assertTrue (norm == flip); 270 } 271 { 272 Int32 norm = 4; 273 Int32 flip = ByteOrder::toLittleEndian(norm); 274 assertTrue (norm == flip); 275 } 276 { 277 UInt32 norm = 4; 278 UInt32 flip = ByteOrder::toLittleEndian(norm); 279 assertTrue (norm == flip); 280 } 281 #if defined(POCO_HAVE_INT64) 282 { 283 Int64 norm = 4; 284 Int64 flip = ByteOrder::toLittleEndian(norm); 285 assertTrue (norm == flip); 286 } 287 { 288 UInt64 norm = 4; 289 UInt64 flip = ByteOrder::toLittleEndian(norm); 290 assertTrue (norm == flip); 291 } 292 #endif 293 294 { 295 Int16 norm = 4; 296 Int16 flip = ByteOrder::toLittleEndian(norm); 297 assertTrue (norm == flip); 298 } 299 { 300 UInt16 norm = 4; 301 UInt16 flip = ByteOrder::toLittleEndian(norm); 302 assertTrue (norm == flip); 303 } 304 { 305 Int32 norm = 4; 306 Int32 flip = ByteOrder::toLittleEndian(norm); 307 assertTrue (norm == flip); 308 } 309 { 310 UInt32 norm = 4; 311 UInt32 flip = ByteOrder::toLittleEndian(norm); 312 assertTrue (norm == flip); 313 } 314 #if defined(POCO_HAVE_INT64) 315 { 316 Int64 norm = 4; 317 Int64 flip = ByteOrder::toLittleEndian(norm); 318 assertTrue (norm == flip); 319 } 320 { 321 UInt64 norm = 4; 322 UInt64 flip = ByteOrder::toLittleEndian(norm); 323 assertTrue (norm == flip); 324 } 325 #endif 326 #else 327 // 328 // little-endian systems 329 // 330 { 331 Int16 norm = 4; 332 Int16 flip = ByteOrder::toLittleEndian(norm); 333 assertTrue (norm != flip); 334 flip = ByteOrder::flipBytes(flip); 335 assertTrue (norm == flip); 336 } 337 { 338 UInt16 norm = 4; 339 UInt16 flip = ByteOrder::toLittleEndian(norm); 340 assertTrue (norm != flip); 341 flip = ByteOrder::flipBytes(flip); 342 assertTrue (norm == flip); 343 } 344 { 345 Int32 norm = 4; 346 Int32 flip = ByteOrder::toLittleEndian(norm); 347 assertTrue (norm != flip); 348 flip = ByteOrder::flipBytes(flip); 349 assertTrue (norm == flip); 350 } 351 { 352 UInt32 norm = 4; 353 UInt32 flip = ByteOrder::toLittleEndian(norm); 354 assertTrue (norm != flip); 355 flip = ByteOrder::flipBytes(flip); 356 assertTrue (norm == flip); 357 } 358 #if defined(POCO_HAVE_INT64) 359 { 360 Int64 norm = 4; 361 Int64 flip = ByteOrder::toLittleEndian(norm); 362 assertTrue (norm != flip); 363 flip = ByteOrder::flipBytes(flip); 364 assertTrue (norm == flip); 365 } 366 { 367 UInt64 norm = 4; 368 UInt64 flip = ByteOrder::toLittleEndian(norm); 369 assertTrue (norm != flip); 370 flip = ByteOrder::flipBytes(flip); 371 assertTrue (norm == flip); 372 } 373 #endif 374 375 { 376 Int16 norm = 4; 377 Int16 flip = ByteOrder::fromLittleEndian(norm); 378 assertTrue (norm != flip); 379 flip = ByteOrder::flipBytes(flip); 380 assertTrue (norm == flip); 381 } 382 { 383 UInt16 norm = 4; 384 UInt16 flip = ByteOrder::fromLittleEndian(norm); 385 assertTrue (norm != flip); 386 flip = ByteOrder::flipBytes(flip); 387 assertTrue (norm == flip); 388 } 389 { 390 Int32 norm = 4; 391 Int32 flip = ByteOrder::fromLittleEndian(norm); 392 assertTrue (norm != flip); 393 flip = ByteOrder::flipBytes(flip); 394 assertTrue (norm == flip); 395 } 396 { 397 UInt32 norm = 4; 398 UInt32 flip = ByteOrder::fromLittleEndian(norm); 399 assertTrue (norm != flip); 400 flip = ByteOrder::flipBytes(flip); 401 assertTrue (norm == flip); 402 } 403 #if defined(POCO_HAVE_INT64) 404 { 405 Int64 norm = 4; 406 Int64 flip = ByteOrder::fromLittleEndian(norm); 407 assertTrue (norm != flip); 408 flip = ByteOrder::flipBytes(flip); 409 assertTrue (norm == flip); 410 } 411 { 412 UInt64 norm = 4; 413 UInt64 flip = ByteOrder::fromLittleEndian(norm); 414 assertTrue (norm != flip); 415 flip = ByteOrder::flipBytes(flip); 416 assertTrue (norm == flip); 417 } 418 #endif 419 #endif 420 } 421 422 testByteOrderNetwork()423void ByteOrderTest::testByteOrderNetwork() 424 { 425 #if defined(POCO_ARCH_BIG_ENDIAN) 426 // 427 // big-endian systems 428 // 429 { 430 Int16 norm = 4; 431 Int16 flip = ByteOrder::toNetwork(norm); 432 assertTrue (norm == flip); 433 } 434 { 435 UInt16 norm = 4; 436 UInt16 flip = ByteOrder::toNetwork(norm); 437 assertTrue (norm == flip); 438 } 439 { 440 Int32 norm = 4; 441 Int32 flip = ByteOrder::toNetwork(norm); 442 assertTrue (norm == flip); 443 } 444 { 445 UInt32 norm = 4; 446 UInt32 flip = ByteOrder::toNetwork(norm); 447 assertTrue (norm == flip); 448 } 449 #if defined(POCO_HAVE_INT64) 450 { 451 Int64 norm = 4; 452 Int64 flip = ByteOrder::toNetwork(norm); 453 assertTrue (norm == flip); 454 } 455 { 456 UInt64 norm = 4; 457 UInt64 flip = ByteOrder::toNetwork(norm); 458 assertTrue (norm == flip); 459 } 460 #endif 461 462 { 463 Int16 norm = 4; 464 Int16 flip = ByteOrder::fromNetwork(norm); 465 assertTrue (norm == flip); 466 } 467 { 468 UInt16 norm = 4; 469 UInt16 flip = ByteOrder::fromNetwork(norm); 470 assertTrue (norm == flip); 471 } 472 { 473 Int32 norm = 4; 474 Int32 flip = ByteOrder::fromNetwork(norm); 475 assertTrue (norm == flip); 476 } 477 { 478 UInt32 norm = 4; 479 UInt32 flip = ByteOrder::fromNetwork(norm); 480 assertTrue (norm == flip); 481 } 482 #if defined(POCO_HAVE_INT64) 483 { 484 Int64 norm = 4; 485 Int64 flip = ByteOrder::fromNetwork(norm); 486 assertTrue (norm == flip); 487 } 488 { 489 UInt64 norm = 4; 490 UInt64 flip = ByteOrder::fromNetwork(norm); 491 assertTrue (norm == flip); 492 } 493 #endif 494 #else 495 // 496 // little-endian systems 497 // 498 { 499 Int16 norm = 4; 500 Int16 flip = ByteOrder::toNetwork(norm); 501 assertTrue (norm != flip); 502 flip = ByteOrder::flipBytes(flip); 503 assertTrue (norm == flip); 504 } 505 { 506 UInt16 norm = 4; 507 UInt16 flip = ByteOrder::toNetwork(norm); 508 assertTrue (norm != flip); 509 flip = ByteOrder::flipBytes(flip); 510 assertTrue (norm == flip); 511 } 512 { 513 Int32 norm = 4; 514 Int32 flip = ByteOrder::toNetwork(norm); 515 assertTrue (norm != flip); 516 flip = ByteOrder::flipBytes(flip); 517 assertTrue (norm == flip); 518 } 519 { 520 UInt32 norm = 4; 521 UInt32 flip = ByteOrder::toNetwork(norm); 522 assertTrue (norm != flip); 523 flip = ByteOrder::flipBytes(flip); 524 assertTrue (norm == flip); 525 } 526 #if defined(POCO_HAVE_INT64) 527 { 528 Int64 norm = 4; 529 Int64 flip = ByteOrder::toNetwork(norm); 530 assertTrue (norm != flip); 531 flip = ByteOrder::flipBytes(flip); 532 assertTrue (norm == flip); 533 } 534 { 535 UInt64 norm = 4; 536 UInt64 flip = ByteOrder::toNetwork(norm); 537 assertTrue (norm != flip); 538 flip = ByteOrder::flipBytes(flip); 539 assertTrue (norm == flip); 540 } 541 #endif 542 543 { 544 Int16 norm = 4; 545 Int16 flip = ByteOrder::fromNetwork(norm); 546 assertTrue (norm != flip); 547 flip = ByteOrder::flipBytes(flip); 548 assertTrue (norm == flip); 549 } 550 { 551 UInt16 norm = 4; 552 UInt16 flip = ByteOrder::fromNetwork(norm); 553 assertTrue (norm != flip); 554 flip = ByteOrder::flipBytes(flip); 555 assertTrue (norm == flip); 556 } 557 { 558 Int32 norm = 4; 559 Int32 flip = ByteOrder::fromNetwork(norm); 560 assertTrue (norm != flip); 561 flip = ByteOrder::flipBytes(flip); 562 assertTrue (norm == flip); 563 } 564 { 565 UInt32 norm = 4; 566 UInt32 flip = ByteOrder::fromNetwork(norm); 567 assertTrue (norm != flip); 568 flip = ByteOrder::flipBytes(flip); 569 assertTrue (norm == flip); 570 } 571 #if defined(POCO_HAVE_INT64) 572 { 573 Int64 norm = 4; 574 Int64 flip = ByteOrder::fromNetwork(norm); 575 assertTrue (norm != flip); 576 flip = ByteOrder::flipBytes(flip); 577 assertTrue (norm == flip); 578 } 579 { 580 UInt64 norm = 4; 581 UInt64 flip = ByteOrder::fromNetwork(norm); 582 assertTrue (norm != flip); 583 flip = ByteOrder::flipBytes(flip); 584 assertTrue (norm == flip); 585 } 586 #endif 587 #endif 588 } 589 590 setUp()591void ByteOrderTest::setUp() 592 { 593 } 594 595 tearDown()596void ByteOrderTest::tearDown() 597 { 598 } 599 600 suite()601CppUnit::Test* ByteOrderTest::suite() 602 { 603 CppUnit::TestSuite* pSuite = new CppUnit::TestSuite("ByteOrderTest"); 604 605 CppUnit_addTest(pSuite, ByteOrderTest, testByteOrderFlip); 606 CppUnit_addTest(pSuite, ByteOrderTest, testByteOrderBigEndian); 607 CppUnit_addTest(pSuite, ByteOrderTest, testByteOrderLittleEndian); 608 CppUnit_addTest(pSuite, ByteOrderTest, testByteOrderNetwork); 609 610 return pSuite; 611 } 612