1 /* 2 * Copyright 2004-2010, Axel Dörfler, axeld@pinc-software.de. 3 * Distributed under the terms of the MIT License. 4 */ 5 6 7 #include "ByteOrderTest.h" 8 9 #include <math.h> 10 #include <string.h> 11 12 #include <ByteOrder.h> 13 14 #include <cppunit/TestCaller.h> 15 #include <cppunit/TestSuite.h> 16 17 #include <TestUtils.h> 18 19 20 using namespace CppUnit; 21 22 23 // ToDo: swap_int16() and friends don't really belong here as they are in libroot.so 24 // The tests might be messed up because of that, and don't test the real thing, as 25 // long as they don't run on Haiku itself. 26 27 28 class Swap16Test : public BTestCase { 29 public: 30 Swap16Test(std::string name = ""); 31 32 static Test *suite(void); 33 void test(void); 34 }; 35 36 37 Swap16Test::Swap16Test(std::string name) 38 : BTestCase(name) 39 { 40 } 41 42 43 Test * 44 Swap16Test::suite(void) 45 { 46 return new CppUnit::TestCaller<Swap16Test>("ByteOrderTest::Swap16Test", &Swap16Test::test); 47 } 48 49 50 void 51 Swap16Test::test(void) 52 { 53 static int16 kNull = 0; 54 static int16 kAscending = 0x1234; 55 static int16 kAscendingSwapped = 0x3412; 56 static int16 kNegative = 0xfedc; 57 static int16 kNegativeSwapped = 0xdcfe; 58 static uint16 kMix = 0xfefd; 59 static uint16 kMixSwapped = 0xfdfe; 60 61 CHK(kNull == __swap_int16(kNull)); 62 CHK(kAscendingSwapped == __swap_int16(kAscending)); 63 CHK(kNegativeSwapped == __swap_int16(kNegative)); 64 CHK(kMixSwapped == __swap_int16(kMix)); 65 } 66 67 68 // #pragma mark - 69 70 71 class Swap32Test : public BTestCase { 72 public: 73 Swap32Test(std::string name = ""); 74 75 static Test *suite(void); 76 void test(void); 77 }; 78 79 80 Swap32Test::Swap32Test(std::string name) 81 : BTestCase(name) 82 { 83 } 84 85 86 Test * 87 Swap32Test::suite(void) 88 { 89 return new CppUnit::TestCaller<Swap32Test>("ByteOrderTest::Swap32Test", &Swap32Test::test); 90 } 91 92 93 void 94 Swap32Test::test(void) 95 { 96 static int32 kNull = 0; 97 static int32 kAscending = 0x12345678; 98 static int32 kAscendingSwapped = 0x78563412; 99 static int32 kNegative = 0xfedcba98; 100 static int32 kNegativeSwapped = 0x98badcfe; 101 static uint32 kMix = 0xfefdfcfb; 102 static uint32 kMixSwapped = 0xfbfcfdfe; 103 104 CHK((uint32)kNull == __swap_int32(kNull)); 105 CHK((uint32)kAscendingSwapped == __swap_int32(kAscending)); 106 CHK((uint32)kNegativeSwapped == __swap_int32(kNegative)); 107 CHK(kMixSwapped == __swap_int32(kMix)); 108 } 109 110 111 // #pragma mark - 112 113 114 class Swap64Test : public BTestCase { 115 public: 116 Swap64Test(std::string name = ""); 117 118 static Test *suite(void); 119 void test(void); 120 }; 121 122 123 Swap64Test::Swap64Test(std::string name) 124 : BTestCase(name) 125 { 126 } 127 128 129 Test * 130 Swap64Test::suite(void) 131 { 132 return new CppUnit::TestCaller<Swap64Test>("ByteOrderTest::Swap64Test", &Swap64Test::test); 133 } 134 135 136 void 137 Swap64Test::test(void) 138 { 139 static int64 kNull = 0LL; 140 static int64 kAscending = 0x1234567890LL; 141 static int64 kAscendingSwapped = 0x0000009078563412LL; 142 static int64 kNegative = 0xfedcba9876543210LL; 143 static int64 kNegativeSwapped = 0x1032547698badcfeLL; 144 static uint64 kMix = 0xfefdLL; 145 static uint64 kMixSwapped = 0xfdfe000000000000LL; 146 147 CHK((uint64)kNull == __swap_int64(kNull)); 148 CHK((uint64)kAscendingSwapped == __swap_int64(kAscending)); 149 CHK((uint64)kNegativeSwapped == __swap_int64(kNegative)); 150 CHK(kMixSwapped == __swap_int64(kMix)); 151 } 152 153 154 // #pragma mark - 155 156 157 class SwapFloatTest : public BTestCase { 158 public: 159 SwapFloatTest(std::string name = ""); 160 161 static Test *suite(void); 162 void test(void); 163 }; 164 165 166 SwapFloatTest::SwapFloatTest(std::string name) 167 : BTestCase(name) 168 { 169 } 170 171 172 Test * 173 SwapFloatTest::suite(void) 174 { 175 return new CppUnit::TestCaller<SwapFloatTest>("ByteOrderTest::SwapFloatTest", &SwapFloatTest::test); 176 } 177 178 179 void 180 SwapFloatTest::test(void) 181 { 182 const float kNumber = 1.125; 183 const float kNaN = NAN; 184 const float kInfinity = HUGE_VALF; 185 186 CHK(kNumber == __swap_float(__swap_float(kNumber))); 187 CHK(kNaN == __swap_float(__swap_float(kNaN))); 188 CHK(kInfinity == __swap_float(__swap_float(kInfinity))); 189 } 190 191 192 // #pragma mark - 193 194 195 class SwapDoubleTest : public BTestCase { 196 public: 197 SwapDoubleTest(std::string name = ""); 198 199 static Test *suite(void); 200 void test(void); 201 }; 202 203 204 SwapDoubleTest::SwapDoubleTest(std::string name) 205 : BTestCase(name) 206 { 207 } 208 209 210 Test * 211 SwapDoubleTest::suite(void) 212 { 213 return new CppUnit::TestCaller<SwapDoubleTest>("ByteOrderTest::SwapDoubleTest", &SwapDoubleTest::test); 214 } 215 216 217 void 218 SwapDoubleTest::test(void) 219 { 220 const double kNumber = 1.125; 221 const double kNaN = NAN; 222 const double kInfinity = HUGE_VAL; 223 224 CHK(kNumber == __swap_double(__swap_double(kNumber))); 225 CHK(kNaN == __swap_double(__swap_double(kNaN))); 226 CHK(kInfinity == __swap_double(__swap_double(kInfinity))); 227 } 228 229 230 // #pragma mark - 231 232 233 class SwapDataTest : public BTestCase { 234 public: 235 SwapDataTest(std::string name = ""); 236 237 static Test *suite(void); 238 void test(void); 239 }; 240 241 242 SwapDataTest::SwapDataTest(std::string name) 243 : BTestCase(name) 244 { 245 } 246 247 248 Test * 249 SwapDataTest::suite(void) 250 { 251 return new CppUnit::TestCaller<SwapDataTest>("ByteOrderTest::SwapDataTest", &SwapDataTest::test); 252 } 253 254 255 void 256 SwapDataTest::test(void) 257 { 258 // error checking 259 char string[4]; 260 CHK(swap_data(B_STRING_TYPE, string, 4, B_SWAP_ALWAYS) == B_BAD_VALUE); 261 int32 num32 = 0; 262 CHK(swap_data(B_INT32_TYPE, &num32, 0, B_SWAP_ALWAYS) == B_BAD_VALUE); 263 CHK(swap_data(B_INT32_TYPE, NULL, 4, B_SWAP_ALWAYS) == B_BAD_VALUE); 264 #if B_HOST_IS_LENDIAN 265 CHK(swap_data(B_INT32_TYPE, NULL, 4, B_SWAP_HOST_TO_LENDIAN) == B_BAD_VALUE); 266 #else 267 CHK(swap_data(B_INT32_TYPE, NULL, 4, B_SWAP_HOST_TO_BENDIAN) == B_BAD_VALUE); 268 #endif 269 270 // algorithm checking 271 #define TEST(type, source, target) \ 272 memcpy(target, source, sizeof(source)); \ 273 for (int32 i = 0; i < 4; i++) { \ 274 if (B_HOST_IS_LENDIAN) { \ 275 swap_data(type, target, sizeof(target), B_SWAP_HOST_TO_LENDIAN); \ 276 CHK(!memcmp(target, source, sizeof(source))); \ 277 swap_data(type, target, sizeof(target), B_SWAP_LENDIAN_TO_HOST); \ 278 CHK(!memcmp(target, source, sizeof(source))); \ 279 \ 280 swap_data(type, target, sizeof(target), B_SWAP_HOST_TO_BENDIAN); \ 281 CHK(memcmp(target, source, sizeof(source))); \ 282 swap_data(type, target, sizeof(target), B_SWAP_BENDIAN_TO_HOST); \ 283 CHK(!memcmp(target, source, sizeof(source))); \ 284 } else if (B_HOST_IS_BENDIAN) { \ 285 swap_data(type, target, sizeof(target), B_SWAP_HOST_TO_BENDIAN); \ 286 CHK(!memcmp(target, source, sizeof(source))); \ 287 swap_data(type, target, sizeof(target), B_SWAP_BENDIAN_TO_HOST); \ 288 CHK(!memcmp(target, source, sizeof(source))); \ 289 \ 290 swap_data(type, target, sizeof(target), B_SWAP_HOST_TO_LENDIAN); \ 291 CHK(memcmp(target, source, sizeof(source))); \ 292 swap_data(type, target, sizeof(target), B_SWAP_LENDIAN_TO_HOST); \ 293 CHK(!memcmp(target, source, sizeof(source))); \ 294 } \ 295 \ 296 swap_data(type, target, sizeof(target), B_SWAP_ALWAYS); \ 297 CHK(memcmp(target, source, sizeof(source))); \ 298 swap_data(type, target, sizeof(target), B_SWAP_ALWAYS); \ 299 CHK(!memcmp(target, source, sizeof(source))); \ 300 } 301 302 const uint64 kArray64[] = {0x0123456789abcdefULL, 0x1234, 0x5678000000000000ULL, 0x0}; 303 uint64 array64[4]; 304 TEST(B_UINT64_TYPE, kArray64, array64); 305 306 const uint32 kArray32[] = {0x12345678, 0x1234, 0x56780000, 0x0}; 307 uint32 array32[4]; 308 TEST(B_UINT32_TYPE, kArray32, array32); 309 310 const uint16 kArray16[] = {0x1234, 0x12, 0x3400, 0x0}; 311 uint16 array16[4]; 312 TEST(B_UINT16_TYPE, kArray16, array16); 313 314 const float kArrayFloat[] = {3.4f, 0.0f, NAN, HUGE_VALF}; 315 float arrayFloat[4]; 316 TEST(B_FLOAT_TYPE, kArrayFloat, arrayFloat); 317 318 const double kArrayDouble[] = {3.42, 0.0, NAN, HUGE_VAL}; 319 double arrayDouble[4]; 320 TEST(B_DOUBLE_TYPE, kArrayDouble, arrayDouble); 321 322 #undef TEST 323 } 324 325 326 // #pragma mark - 327 328 329 class IsTypeSwappedTest : public BTestCase { 330 public: 331 IsTypeSwappedTest(std::string name = ""); 332 333 static Test *suite(void); 334 void test(void); 335 }; 336 337 338 IsTypeSwappedTest::IsTypeSwappedTest(std::string name) 339 : BTestCase(name) 340 { 341 } 342 343 344 Test * 345 IsTypeSwappedTest::suite(void) 346 { 347 return new CppUnit::TestCaller<IsTypeSwappedTest>("ByteOrderTest::IsTypeSwappedTest", &IsTypeSwappedTest::test); 348 } 349 350 351 void 352 IsTypeSwappedTest::test(void) 353 { 354 #define IS_SWAPPED(x) CHK(is_type_swapped(x)) 355 #define NOT_SWAPPED(x) CHK(!is_type_swapped(x)) 356 357 IS_SWAPPED(B_ANY_TYPE); 358 IS_SWAPPED(B_BOOL_TYPE); 359 IS_SWAPPED(B_CHAR_TYPE); 360 IS_SWAPPED(B_COLOR_8_BIT_TYPE); 361 IS_SWAPPED(B_DOUBLE_TYPE); 362 IS_SWAPPED(B_FLOAT_TYPE); 363 IS_SWAPPED(B_GRAYSCALE_8_BIT_TYPE); 364 IS_SWAPPED(B_INT64_TYPE); 365 IS_SWAPPED(B_INT32_TYPE); 366 IS_SWAPPED(B_INT16_TYPE); 367 IS_SWAPPED(B_INT8_TYPE); 368 IS_SWAPPED(B_MESSAGE_TYPE); 369 IS_SWAPPED(B_MESSENGER_TYPE); 370 IS_SWAPPED(B_MIME_TYPE); 371 IS_SWAPPED(B_MONOCHROME_1_BIT_TYPE); 372 IS_SWAPPED(B_OBJECT_TYPE); 373 IS_SWAPPED(B_OFF_T_TYPE); 374 IS_SWAPPED(B_PATTERN_TYPE); 375 IS_SWAPPED(B_POINTER_TYPE); 376 IS_SWAPPED(B_POINT_TYPE); 377 IS_SWAPPED(B_RAW_TYPE); 378 IS_SWAPPED(B_RECT_TYPE); 379 IS_SWAPPED(B_REF_TYPE); 380 IS_SWAPPED(B_RGB_32_BIT_TYPE); 381 IS_SWAPPED(B_RGB_COLOR_TYPE); 382 IS_SWAPPED(B_SIZE_T_TYPE); 383 IS_SWAPPED(B_SSIZE_T_TYPE); 384 IS_SWAPPED(B_STRING_TYPE); 385 IS_SWAPPED(B_TIME_TYPE); 386 IS_SWAPPED(B_UINT64_TYPE); 387 IS_SWAPPED(B_UINT32_TYPE); 388 IS_SWAPPED(B_UINT16_TYPE); 389 IS_SWAPPED(B_UINT8_TYPE); 390 IS_SWAPPED(B_MEDIA_PARAMETER_TYPE); 391 IS_SWAPPED(B_MEDIA_PARAMETER_WEB_TYPE); 392 IS_SWAPPED(B_MEDIA_PARAMETER_GROUP_TYPE); 393 IS_SWAPPED(B_ASCII_TYPE); 394 395 NOT_SWAPPED(' '); 396 NOT_SWAPPED('0000'); 397 NOT_SWAPPED('1111'); 398 NOT_SWAPPED('aaaa'); 399 400 #undef IS_SWAPPED 401 #undef NOT_SWAPPED 402 } 403 404 405 // #pragma mark - 406 407 408 Test * 409 ByteOrderTestSuite() 410 { 411 TestSuite *testSuite = new TestSuite(); 412 413 testSuite->addTest(new Swap16Test("__swap_int16()")); 414 testSuite->addTest(new Swap32Test("__swap_int32()")); 415 testSuite->addTest(new Swap64Test("__swap_int64()")); 416 testSuite->addTest(new SwapFloatTest("__swap_float()")); 417 testSuite->addTest(new SwapDoubleTest("__swap_double()")); 418 testSuite->addTest(new SwapDataTest("swap_data()")); 419 testSuite->addTest(new IsTypeSwappedTest("is_type_swapped()")); 420 421 return testSuite; 422 } 423 424 425 426 427 428 429 430