1 //===- unittests/Support/MathExtrasTest.cpp - math utils tests ------------===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 9 #include "llvm/Support/MathExtras.h" 10 #include "gtest/gtest.h" 11 12 using namespace llvm; 13 14 namespace { 15 16 TEST(MathExtras, countTrailingZeros) { 17 uint8_t Z8 = 0; 18 uint16_t Z16 = 0; 19 uint32_t Z32 = 0; 20 uint64_t Z64 = 0; 21 EXPECT_EQ(8u, countTrailingZeros(Z8)); 22 EXPECT_EQ(16u, countTrailingZeros(Z16)); 23 EXPECT_EQ(32u, countTrailingZeros(Z32)); 24 EXPECT_EQ(64u, countTrailingZeros(Z64)); 25 26 uint8_t NZ8 = 42; 27 uint16_t NZ16 = 42; 28 uint32_t NZ32 = 42; 29 uint64_t NZ64 = 42; 30 EXPECT_EQ(1u, countTrailingZeros(NZ8)); 31 EXPECT_EQ(1u, countTrailingZeros(NZ16)); 32 EXPECT_EQ(1u, countTrailingZeros(NZ32)); 33 EXPECT_EQ(1u, countTrailingZeros(NZ64)); 34 } 35 36 TEST(MathExtras, countLeadingZeros) { 37 uint8_t Z8 = 0; 38 uint16_t Z16 = 0; 39 uint32_t Z32 = 0; 40 uint64_t Z64 = 0; 41 EXPECT_EQ(8u, countLeadingZeros(Z8)); 42 EXPECT_EQ(16u, countLeadingZeros(Z16)); 43 EXPECT_EQ(32u, countLeadingZeros(Z32)); 44 EXPECT_EQ(64u, countLeadingZeros(Z64)); 45 46 uint8_t NZ8 = 42; 47 uint16_t NZ16 = 42; 48 uint32_t NZ32 = 42; 49 uint64_t NZ64 = 42; 50 EXPECT_EQ(2u, countLeadingZeros(NZ8)); 51 EXPECT_EQ(10u, countLeadingZeros(NZ16)); 52 EXPECT_EQ(26u, countLeadingZeros(NZ32)); 53 EXPECT_EQ(58u, countLeadingZeros(NZ64)); 54 55 EXPECT_EQ(8u, countLeadingZeros(0x00F000FFu)); 56 EXPECT_EQ(8u, countLeadingZeros(0x00F12345u)); 57 for (unsigned i = 0; i <= 30; ++i) { 58 EXPECT_EQ(31 - i, countLeadingZeros(1u << i)); 59 } 60 61 EXPECT_EQ(8u, countLeadingZeros(0x00F1234500F12345ULL)); 62 EXPECT_EQ(1u, countLeadingZeros(1ULL << 62)); 63 for (unsigned i = 0; i <= 62; ++i) { 64 EXPECT_EQ(63 - i, countLeadingZeros(1ULL << i)); 65 } 66 } 67 68 TEST(MathExtras, onesMask) { 69 EXPECT_EQ(0U, maskLeadingOnes<uint8_t>(0)); 70 EXPECT_EQ(0U, maskTrailingOnes<uint8_t>(0)); 71 EXPECT_EQ(0U, maskLeadingOnes<uint16_t>(0)); 72 EXPECT_EQ(0U, maskTrailingOnes<uint16_t>(0)); 73 EXPECT_EQ(0U, maskLeadingOnes<uint32_t>(0)); 74 EXPECT_EQ(0U, maskTrailingOnes<uint32_t>(0)); 75 EXPECT_EQ(0U, maskLeadingOnes<uint64_t>(0)); 76 EXPECT_EQ(0U, maskTrailingOnes<uint64_t>(0)); 77 78 EXPECT_EQ(0x00000003U, maskTrailingOnes<uint32_t>(2U)); 79 EXPECT_EQ(0xC0000000U, maskLeadingOnes<uint32_t>(2U)); 80 81 EXPECT_EQ(0x000007FFU, maskTrailingOnes<uint32_t>(11U)); 82 EXPECT_EQ(0xFFE00000U, maskLeadingOnes<uint32_t>(11U)); 83 84 EXPECT_EQ(0xFFFFFFFFU, maskTrailingOnes<uint32_t>(32U)); 85 EXPECT_EQ(0xFFFFFFFFU, maskLeadingOnes<uint32_t>(32U)); 86 EXPECT_EQ(0xFFFFFFFFFFFFFFFFULL, maskTrailingOnes<uint64_t>(64U)); 87 EXPECT_EQ(0xFFFFFFFFFFFFFFFFULL, maskLeadingOnes<uint64_t>(64U)); 88 89 EXPECT_EQ(0x0000FFFFFFFFFFFFULL, maskTrailingOnes<uint64_t>(48U)); 90 EXPECT_EQ(0xFFFFFFFFFFFF0000ULL, maskLeadingOnes<uint64_t>(48U)); 91 } 92 93 TEST(MathExtras, findFirstSet) { 94 uint8_t Z8 = 0; 95 uint16_t Z16 = 0; 96 uint32_t Z32 = 0; 97 uint64_t Z64 = 0; 98 EXPECT_EQ(0xFFULL, findFirstSet(Z8)); 99 EXPECT_EQ(0xFFFFULL, findFirstSet(Z16)); 100 EXPECT_EQ(0xFFFFFFFFULL, findFirstSet(Z32)); 101 EXPECT_EQ(0xFFFFFFFFFFFFFFFFULL, findFirstSet(Z64)); 102 103 uint8_t NZ8 = 42; 104 uint16_t NZ16 = 42; 105 uint32_t NZ32 = 42; 106 uint64_t NZ64 = 42; 107 EXPECT_EQ(1u, findFirstSet(NZ8)); 108 EXPECT_EQ(1u, findFirstSet(NZ16)); 109 EXPECT_EQ(1u, findFirstSet(NZ32)); 110 EXPECT_EQ(1u, findFirstSet(NZ64)); 111 } 112 113 TEST(MathExtras, findLastSet) { 114 uint8_t Z8 = 0; 115 uint16_t Z16 = 0; 116 uint32_t Z32 = 0; 117 uint64_t Z64 = 0; 118 EXPECT_EQ(0xFFULL, findLastSet(Z8)); 119 EXPECT_EQ(0xFFFFULL, findLastSet(Z16)); 120 EXPECT_EQ(0xFFFFFFFFULL, findLastSet(Z32)); 121 EXPECT_EQ(0xFFFFFFFFFFFFFFFFULL, findLastSet(Z64)); 122 123 uint8_t NZ8 = 42; 124 uint16_t NZ16 = 42; 125 uint32_t NZ32 = 42; 126 uint64_t NZ64 = 42; 127 EXPECT_EQ(5u, findLastSet(NZ8)); 128 EXPECT_EQ(5u, findLastSet(NZ16)); 129 EXPECT_EQ(5u, findLastSet(NZ32)); 130 EXPECT_EQ(5u, findLastSet(NZ64)); 131 } 132 133 TEST(MathExtras, isIntN) { 134 EXPECT_TRUE(isIntN(16, 32767)); 135 EXPECT_FALSE(isIntN(16, 32768)); 136 } 137 138 TEST(MathExtras, isUIntN) { 139 EXPECT_TRUE(isUIntN(16, 65535)); 140 EXPECT_FALSE(isUIntN(16, 65536)); 141 EXPECT_TRUE(isUIntN(1, 0)); 142 EXPECT_TRUE(isUIntN(6, 63)); 143 } 144 145 TEST(MathExtras, maxIntN) { 146 EXPECT_EQ(32767, maxIntN(16)); 147 EXPECT_EQ(2147483647, maxIntN(32)); 148 EXPECT_EQ(std::numeric_limits<int32_t>::max(), maxIntN(32)); 149 EXPECT_EQ(std::numeric_limits<int64_t>::max(), maxIntN(64)); 150 } 151 152 TEST(MathExtras, minIntN) { 153 EXPECT_EQ(-32768LL, minIntN(16)); 154 EXPECT_EQ(-64LL, minIntN(7)); 155 EXPECT_EQ(std::numeric_limits<int32_t>::min(), minIntN(32)); 156 EXPECT_EQ(std::numeric_limits<int64_t>::min(), minIntN(64)); 157 } 158 159 TEST(MathExtras, maxUIntN) { 160 EXPECT_EQ(0xffffULL, maxUIntN(16)); 161 EXPECT_EQ(0xffffffffULL, maxUIntN(32)); 162 EXPECT_EQ(0xffffffffffffffffULL, maxUIntN(64)); 163 EXPECT_EQ(1ULL, maxUIntN(1)); 164 EXPECT_EQ(0x0fULL, maxUIntN(4)); 165 } 166 167 TEST(MathExtras, reverseBits) { 168 uint8_t NZ8 = 42; 169 uint16_t NZ16 = 42; 170 uint32_t NZ32 = 42; 171 uint64_t NZ64 = 42; 172 EXPECT_EQ(0x54ULL, reverseBits(NZ8)); 173 EXPECT_EQ(0x5400ULL, reverseBits(NZ16)); 174 EXPECT_EQ(0x54000000ULL, reverseBits(NZ32)); 175 EXPECT_EQ(0x5400000000000000ULL, reverseBits(NZ64)); 176 } 177 178 TEST(MathExtras, isShiftedMask_32) { 179 EXPECT_FALSE(isShiftedMask_32(0x01010101)); 180 EXPECT_TRUE(isShiftedMask_32(0xf0000000)); 181 EXPECT_TRUE(isShiftedMask_32(0xffff0000)); 182 EXPECT_TRUE(isShiftedMask_32(0xff << 1)); 183 } 184 185 TEST(MathExtras, isShiftedMask_64) { 186 EXPECT_FALSE(isShiftedMask_64(0x0101010101010101ull)); 187 EXPECT_TRUE(isShiftedMask_64(0xf000000000000000ull)); 188 EXPECT_TRUE(isShiftedMask_64(0xffff000000000000ull)); 189 EXPECT_TRUE(isShiftedMask_64(0xffull << 55)); 190 } 191 192 TEST(MathExtras, isPowerOf2_32) { 193 EXPECT_FALSE(isPowerOf2_32(0)); 194 EXPECT_TRUE(isPowerOf2_32(1 << 6)); 195 EXPECT_TRUE(isPowerOf2_32(1 << 12)); 196 EXPECT_FALSE(isPowerOf2_32((1 << 19) + 3)); 197 EXPECT_FALSE(isPowerOf2_32(0xABCDEF0)); 198 } 199 200 TEST(MathExtras, isPowerOf2_64) { 201 EXPECT_FALSE(isPowerOf2_64(0)); 202 EXPECT_TRUE(isPowerOf2_64(1LL << 46)); 203 EXPECT_TRUE(isPowerOf2_64(1LL << 12)); 204 EXPECT_FALSE(isPowerOf2_64((1LL << 53) + 3)); 205 EXPECT_FALSE(isPowerOf2_64(0xABCDEF0ABCDEF0LL)); 206 } 207 208 TEST(MathExtras, PowerOf2Ceil) { 209 EXPECT_EQ(0U, PowerOf2Ceil(0U)); 210 EXPECT_EQ(8U, PowerOf2Ceil(8U)); 211 EXPECT_EQ(8U, PowerOf2Ceil(7U)); 212 } 213 214 TEST(MathExtras, PowerOf2Floor) { 215 EXPECT_EQ(0U, PowerOf2Floor(0U)); 216 EXPECT_EQ(8U, PowerOf2Floor(8U)); 217 EXPECT_EQ(4U, PowerOf2Floor(7U)); 218 } 219 220 TEST(MathExtras, CTLog2) { 221 EXPECT_EQ(CTLog2<1ULL << 0>(), 0U); 222 EXPECT_EQ(CTLog2<1ULL << 1>(), 1U); 223 EXPECT_EQ(CTLog2<1ULL << 2>(), 2U); 224 EXPECT_EQ(CTLog2<1ULL << 3>(), 3U); 225 EXPECT_EQ(CTLog2<1ULL << 4>(), 4U); 226 EXPECT_EQ(CTLog2<1ULL << 5>(), 5U); 227 EXPECT_EQ(CTLog2<1ULL << 6>(), 6U); 228 EXPECT_EQ(CTLog2<1ULL << 7>(), 7U); 229 EXPECT_EQ(CTLog2<1ULL << 8>(), 8U); 230 EXPECT_EQ(CTLog2<1ULL << 9>(), 9U); 231 EXPECT_EQ(CTLog2<1ULL << 10>(), 10U); 232 EXPECT_EQ(CTLog2<1ULL << 11>(), 11U); 233 EXPECT_EQ(CTLog2<1ULL << 12>(), 12U); 234 EXPECT_EQ(CTLog2<1ULL << 13>(), 13U); 235 EXPECT_EQ(CTLog2<1ULL << 14>(), 14U); 236 EXPECT_EQ(CTLog2<1ULL << 15>(), 15U); 237 } 238 239 TEST(MathExtras, countLeadingOnes) { 240 for (int i = 30; i >= 0; --i) { 241 // Start with all ones and unset some bit. 242 EXPECT_EQ(31u - i, countLeadingOnes(0xFFFFFFFF ^ (1 << i))); 243 } 244 for (int i = 62; i >= 0; --i) { 245 // Start with all ones and unset some bit. 246 EXPECT_EQ(63u - i, countLeadingOnes(0xFFFFFFFFFFFFFFFFULL ^ (1LL << i))); 247 } 248 for (int i = 30; i >= 0; --i) { 249 // Start with all ones and unset some bit. 250 EXPECT_EQ(31u - i, countLeadingOnes(0xFFFFFFFF ^ (1 << i))); 251 } 252 } 253 254 TEST(MathExtras, FloatBits) { 255 static const float kValue = 5632.34f; 256 EXPECT_FLOAT_EQ(kValue, BitsToFloat(FloatToBits(kValue))); 257 } 258 259 TEST(MathExtras, DoubleBits) { 260 static const double kValue = 87987234.983498; 261 EXPECT_DOUBLE_EQ(kValue, BitsToDouble(DoubleToBits(kValue))); 262 } 263 264 TEST(MathExtras, MinAlign) { 265 EXPECT_EQ(1u, MinAlign(2, 3)); 266 EXPECT_EQ(2u, MinAlign(2, 4)); 267 EXPECT_EQ(1u, MinAlign(17, 64)); 268 EXPECT_EQ(256u, MinAlign(256, 512)); 269 } 270 271 TEST(MathExtras, NextPowerOf2) { 272 EXPECT_EQ(4u, NextPowerOf2(3)); 273 EXPECT_EQ(16u, NextPowerOf2(15)); 274 EXPECT_EQ(256u, NextPowerOf2(128)); 275 } 276 277 TEST(MathExtras, alignTo) { 278 EXPECT_EQ(8u, alignTo(5, 8)); 279 EXPECT_EQ(24u, alignTo(17, 8)); 280 EXPECT_EQ(0u, alignTo(~0LL, 8)); 281 282 EXPECT_EQ(7u, alignTo(5, 8, 7)); 283 EXPECT_EQ(17u, alignTo(17, 8, 1)); 284 EXPECT_EQ(3u, alignTo(~0LL, 8, 3)); 285 EXPECT_EQ(552u, alignTo(321, 255, 42)); 286 } 287 288 template<typename T> 289 void SaturatingAddTestHelper() 290 { 291 const T Max = std::numeric_limits<T>::max(); 292 bool ResultOverflowed; 293 294 EXPECT_EQ(T(3), SaturatingAdd(T(1), T(2))); 295 EXPECT_EQ(T(3), SaturatingAdd(T(1), T(2), &ResultOverflowed)); 296 EXPECT_FALSE(ResultOverflowed); 297 298 EXPECT_EQ(Max, SaturatingAdd(Max, T(1))); 299 EXPECT_EQ(Max, SaturatingAdd(Max, T(1), &ResultOverflowed)); 300 EXPECT_TRUE(ResultOverflowed); 301 302 EXPECT_EQ(Max, SaturatingAdd(T(1), T(Max - 1))); 303 EXPECT_EQ(Max, SaturatingAdd(T(1), T(Max - 1), &ResultOverflowed)); 304 EXPECT_FALSE(ResultOverflowed); 305 306 EXPECT_EQ(Max, SaturatingAdd(T(1), Max)); 307 EXPECT_EQ(Max, SaturatingAdd(T(1), Max, &ResultOverflowed)); 308 EXPECT_TRUE(ResultOverflowed); 309 310 EXPECT_EQ(Max, SaturatingAdd(Max, Max)); 311 EXPECT_EQ(Max, SaturatingAdd(Max, Max, &ResultOverflowed)); 312 EXPECT_TRUE(ResultOverflowed); 313 } 314 315 TEST(MathExtras, SaturatingAdd) { 316 SaturatingAddTestHelper<uint8_t>(); 317 SaturatingAddTestHelper<uint16_t>(); 318 SaturatingAddTestHelper<uint32_t>(); 319 SaturatingAddTestHelper<uint64_t>(); 320 } 321 322 template<typename T> 323 void SaturatingMultiplyTestHelper() 324 { 325 const T Max = std::numeric_limits<T>::max(); 326 bool ResultOverflowed; 327 328 // Test basic multiplication. 329 EXPECT_EQ(T(6), SaturatingMultiply(T(2), T(3))); 330 EXPECT_EQ(T(6), SaturatingMultiply(T(2), T(3), &ResultOverflowed)); 331 EXPECT_FALSE(ResultOverflowed); 332 333 EXPECT_EQ(T(6), SaturatingMultiply(T(3), T(2))); 334 EXPECT_EQ(T(6), SaturatingMultiply(T(3), T(2), &ResultOverflowed)); 335 EXPECT_FALSE(ResultOverflowed); 336 337 // Test multiplication by zero. 338 EXPECT_EQ(T(0), SaturatingMultiply(T(0), T(0))); 339 EXPECT_EQ(T(0), SaturatingMultiply(T(0), T(0), &ResultOverflowed)); 340 EXPECT_FALSE(ResultOverflowed); 341 342 EXPECT_EQ(T(0), SaturatingMultiply(T(1), T(0))); 343 EXPECT_EQ(T(0), SaturatingMultiply(T(1), T(0), &ResultOverflowed)); 344 EXPECT_FALSE(ResultOverflowed); 345 346 EXPECT_EQ(T(0), SaturatingMultiply(T(0), T(1))); 347 EXPECT_EQ(T(0), SaturatingMultiply(T(0), T(1), &ResultOverflowed)); 348 EXPECT_FALSE(ResultOverflowed); 349 350 EXPECT_EQ(T(0), SaturatingMultiply(Max, T(0))); 351 EXPECT_EQ(T(0), SaturatingMultiply(Max, T(0), &ResultOverflowed)); 352 EXPECT_FALSE(ResultOverflowed); 353 354 EXPECT_EQ(T(0), SaturatingMultiply(T(0), Max)); 355 EXPECT_EQ(T(0), SaturatingMultiply(T(0), Max, &ResultOverflowed)); 356 EXPECT_FALSE(ResultOverflowed); 357 358 // Test multiplication by maximum value. 359 EXPECT_EQ(Max, SaturatingMultiply(Max, T(2))); 360 EXPECT_EQ(Max, SaturatingMultiply(Max, T(2), &ResultOverflowed)); 361 EXPECT_TRUE(ResultOverflowed); 362 363 EXPECT_EQ(Max, SaturatingMultiply(T(2), Max)); 364 EXPECT_EQ(Max, SaturatingMultiply(T(2), Max, &ResultOverflowed)); 365 EXPECT_TRUE(ResultOverflowed); 366 367 EXPECT_EQ(Max, SaturatingMultiply(Max, Max)); 368 EXPECT_EQ(Max, SaturatingMultiply(Max, Max, &ResultOverflowed)); 369 EXPECT_TRUE(ResultOverflowed); 370 371 // Test interesting boundary conditions for algorithm - 372 // ((1 << A) - 1) * ((1 << B) + K) for K in [-1, 0, 1] 373 // and A + B == std::numeric_limits<T>::digits. 374 // We expect overflow iff A > B and K = 1. 375 const int Digits = std::numeric_limits<T>::digits; 376 for (int A = 1, B = Digits - 1; B >= 1; ++A, --B) { 377 for (int K = -1; K <= 1; ++K) { 378 T X = (T(1) << A) - T(1); 379 T Y = (T(1) << B) + K; 380 bool OverflowExpected = A > B && K == 1; 381 382 if(OverflowExpected) { 383 EXPECT_EQ(Max, SaturatingMultiply(X, Y)); 384 EXPECT_EQ(Max, SaturatingMultiply(X, Y, &ResultOverflowed)); 385 EXPECT_TRUE(ResultOverflowed); 386 } else { 387 EXPECT_EQ(X * Y, SaturatingMultiply(X, Y)); 388 EXPECT_EQ(X * Y, SaturatingMultiply(X, Y, &ResultOverflowed)); 389 EXPECT_FALSE(ResultOverflowed); 390 } 391 } 392 } 393 } 394 395 TEST(MathExtras, SaturatingMultiply) { 396 SaturatingMultiplyTestHelper<uint8_t>(); 397 SaturatingMultiplyTestHelper<uint16_t>(); 398 SaturatingMultiplyTestHelper<uint32_t>(); 399 SaturatingMultiplyTestHelper<uint64_t>(); 400 } 401 402 template<typename T> 403 void SaturatingMultiplyAddTestHelper() 404 { 405 const T Max = std::numeric_limits<T>::max(); 406 bool ResultOverflowed; 407 408 // Test basic multiply-add. 409 EXPECT_EQ(T(16), SaturatingMultiplyAdd(T(2), T(3), T(10))); 410 EXPECT_EQ(T(16), SaturatingMultiplyAdd(T(2), T(3), T(10), &ResultOverflowed)); 411 EXPECT_FALSE(ResultOverflowed); 412 413 // Test multiply overflows, add doesn't overflow 414 EXPECT_EQ(Max, SaturatingMultiplyAdd(Max, Max, T(0), &ResultOverflowed)); 415 EXPECT_TRUE(ResultOverflowed); 416 417 // Test multiply doesn't overflow, add overflows 418 EXPECT_EQ(Max, SaturatingMultiplyAdd(T(1), T(1), Max, &ResultOverflowed)); 419 EXPECT_TRUE(ResultOverflowed); 420 421 // Test multiply-add with Max as operand 422 EXPECT_EQ(Max, SaturatingMultiplyAdd(T(1), T(1), Max, &ResultOverflowed)); 423 EXPECT_TRUE(ResultOverflowed); 424 425 EXPECT_EQ(Max, SaturatingMultiplyAdd(T(1), Max, T(1), &ResultOverflowed)); 426 EXPECT_TRUE(ResultOverflowed); 427 428 EXPECT_EQ(Max, SaturatingMultiplyAdd(Max, Max, T(1), &ResultOverflowed)); 429 EXPECT_TRUE(ResultOverflowed); 430 431 EXPECT_EQ(Max, SaturatingMultiplyAdd(Max, Max, Max, &ResultOverflowed)); 432 EXPECT_TRUE(ResultOverflowed); 433 434 // Test multiply-add with 0 as operand 435 EXPECT_EQ(T(1), SaturatingMultiplyAdd(T(1), T(1), T(0), &ResultOverflowed)); 436 EXPECT_FALSE(ResultOverflowed); 437 438 EXPECT_EQ(T(1), SaturatingMultiplyAdd(T(1), T(0), T(1), &ResultOverflowed)); 439 EXPECT_FALSE(ResultOverflowed); 440 441 EXPECT_EQ(T(1), SaturatingMultiplyAdd(T(0), T(0), T(1), &ResultOverflowed)); 442 EXPECT_FALSE(ResultOverflowed); 443 444 EXPECT_EQ(T(0), SaturatingMultiplyAdd(T(0), T(0), T(0), &ResultOverflowed)); 445 EXPECT_FALSE(ResultOverflowed); 446 447 } 448 449 TEST(MathExtras, SaturatingMultiplyAdd) { 450 SaturatingMultiplyAddTestHelper<uint8_t>(); 451 SaturatingMultiplyAddTestHelper<uint16_t>(); 452 SaturatingMultiplyAddTestHelper<uint32_t>(); 453 SaturatingMultiplyAddTestHelper<uint64_t>(); 454 } 455 456 TEST(MathExtras, IsShiftedUInt) { 457 EXPECT_TRUE((isShiftedUInt<1, 0>(0))); 458 EXPECT_TRUE((isShiftedUInt<1, 0>(1))); 459 EXPECT_FALSE((isShiftedUInt<1, 0>(2))); 460 EXPECT_FALSE((isShiftedUInt<1, 0>(3))); 461 EXPECT_FALSE((isShiftedUInt<1, 0>(0x8000000000000000))); 462 EXPECT_TRUE((isShiftedUInt<1, 63>(0x8000000000000000))); 463 EXPECT_TRUE((isShiftedUInt<2, 62>(0xC000000000000000))); 464 EXPECT_FALSE((isShiftedUInt<2, 62>(0xE000000000000000))); 465 466 // 0x201 is ten bits long and has a 1 in the MSB and LSB. 467 EXPECT_TRUE((isShiftedUInt<10, 5>(uint64_t(0x201) << 5))); 468 EXPECT_FALSE((isShiftedUInt<10, 5>(uint64_t(0x201) << 4))); 469 EXPECT_FALSE((isShiftedUInt<10, 5>(uint64_t(0x201) << 6))); 470 } 471 472 TEST(MathExtras, IsShiftedInt) { 473 EXPECT_TRUE((isShiftedInt<1, 0>(0))); 474 EXPECT_TRUE((isShiftedInt<1, 0>(-1))); 475 EXPECT_FALSE((isShiftedInt<1, 0>(2))); 476 EXPECT_FALSE((isShiftedInt<1, 0>(3))); 477 EXPECT_FALSE((isShiftedInt<1, 0>(0x8000000000000000))); 478 EXPECT_TRUE((isShiftedInt<1, 63>(0x8000000000000000))); 479 EXPECT_TRUE((isShiftedInt<2, 62>(0xC000000000000000))); 480 EXPECT_FALSE((isShiftedInt<2, 62>(0xE000000000000000))); 481 482 // 0x201 is ten bits long and has a 1 in the MSB and LSB. 483 EXPECT_TRUE((isShiftedInt<11, 5>(int64_t(0x201) << 5))); 484 EXPECT_FALSE((isShiftedInt<11, 5>(int64_t(0x201) << 3))); 485 EXPECT_FALSE((isShiftedInt<11, 5>(int64_t(0x201) << 6))); 486 EXPECT_TRUE((isShiftedInt<11, 5>(-(int64_t(0x201) << 5)))); 487 EXPECT_FALSE((isShiftedInt<11, 5>(-(int64_t(0x201) << 3)))); 488 EXPECT_FALSE((isShiftedInt<11, 5>(-(int64_t(0x201) << 6)))); 489 490 EXPECT_TRUE((isShiftedInt<6, 10>(-(int64_t(1) << 15)))); 491 EXPECT_FALSE((isShiftedInt<6, 10>(int64_t(1) << 15))); 492 } 493 494 template <typename T> 495 class OverflowTest : public ::testing::Test { }; 496 497 using OverflowTestTypes = ::testing::Types<signed char, short, int, long, 498 long long>; 499 500 TYPED_TEST_SUITE(OverflowTest, OverflowTestTypes, ); 501 502 TYPED_TEST(OverflowTest, AddNoOverflow) { 503 TypeParam Result; 504 EXPECT_FALSE(AddOverflow<TypeParam>(1, 2, Result)); 505 EXPECT_EQ(Result, TypeParam(3)); 506 } 507 508 TYPED_TEST(OverflowTest, AddOverflowToNegative) { 509 TypeParam Result; 510 auto MaxValue = std::numeric_limits<TypeParam>::max(); 511 EXPECT_TRUE(AddOverflow<TypeParam>(MaxValue, MaxValue, Result)); 512 EXPECT_EQ(Result, TypeParam(-2)); 513 } 514 515 TYPED_TEST(OverflowTest, AddOverflowToMin) { 516 TypeParam Result; 517 auto MaxValue = std::numeric_limits<TypeParam>::max(); 518 EXPECT_TRUE(AddOverflow<TypeParam>(MaxValue, TypeParam(1), Result)); 519 EXPECT_EQ(Result, std::numeric_limits<TypeParam>::min()); 520 } 521 522 TYPED_TEST(OverflowTest, AddOverflowToZero) { 523 TypeParam Result; 524 auto MinValue = std::numeric_limits<TypeParam>::min(); 525 EXPECT_TRUE(AddOverflow<TypeParam>(MinValue, MinValue, Result)); 526 EXPECT_EQ(Result, TypeParam(0)); 527 } 528 529 TYPED_TEST(OverflowTest, AddOverflowToMax) { 530 TypeParam Result; 531 auto MinValue = std::numeric_limits<TypeParam>::min(); 532 EXPECT_TRUE(AddOverflow<TypeParam>(MinValue, TypeParam(-1), Result)); 533 EXPECT_EQ(Result, std::numeric_limits<TypeParam>::max()); 534 } 535 536 TYPED_TEST(OverflowTest, SubNoOverflow) { 537 TypeParam Result; 538 EXPECT_FALSE(SubOverflow<TypeParam>(1, 2, Result)); 539 EXPECT_EQ(Result, TypeParam(-1)); 540 } 541 542 TYPED_TEST(OverflowTest, SubOverflowToMax) { 543 TypeParam Result; 544 auto MinValue = std::numeric_limits<TypeParam>::min(); 545 EXPECT_TRUE(SubOverflow<TypeParam>(0, MinValue, Result)); 546 EXPECT_EQ(Result, MinValue); 547 } 548 549 TYPED_TEST(OverflowTest, SubOverflowToMin) { 550 TypeParam Result; 551 auto MinValue = std::numeric_limits<TypeParam>::min(); 552 EXPECT_TRUE(SubOverflow<TypeParam>(0, MinValue, Result)); 553 EXPECT_EQ(Result, MinValue); 554 } 555 556 TYPED_TEST(OverflowTest, SubOverflowToNegative) { 557 TypeParam Result; 558 auto MaxValue = std::numeric_limits<TypeParam>::max(); 559 auto MinValue = std::numeric_limits<TypeParam>::min(); 560 EXPECT_TRUE(SubOverflow<TypeParam>(MaxValue, MinValue, Result)); 561 EXPECT_EQ(Result, TypeParam(-1)); 562 } 563 564 TYPED_TEST(OverflowTest, SubOverflowToPositive) { 565 TypeParam Result; 566 auto MaxValue = std::numeric_limits<TypeParam>::max(); 567 auto MinValue = std::numeric_limits<TypeParam>::min(); 568 EXPECT_TRUE(SubOverflow<TypeParam>(MinValue, MaxValue, Result)); 569 EXPECT_EQ(Result, TypeParam(1)); 570 } 571 572 TYPED_TEST(OverflowTest, MulNoOverflow) { 573 TypeParam Result; 574 EXPECT_FALSE(MulOverflow<TypeParam>(1, 2, Result)); 575 EXPECT_EQ(Result, 2); 576 EXPECT_FALSE(MulOverflow<TypeParam>(-1, 3, Result)); 577 EXPECT_EQ(Result, -3); 578 EXPECT_FALSE(MulOverflow<TypeParam>(4, -2, Result)); 579 EXPECT_EQ(Result, -8); 580 EXPECT_FALSE(MulOverflow<TypeParam>(-6, -5, Result)); 581 EXPECT_EQ(Result, 30); 582 } 583 584 TYPED_TEST(OverflowTest, MulNoOverflowToMax) { 585 TypeParam Result; 586 auto MaxValue = std::numeric_limits<TypeParam>::max(); 587 auto MinValue = std::numeric_limits<TypeParam>::min(); 588 EXPECT_FALSE(MulOverflow<TypeParam>(MinValue + 1, -1, Result)); 589 EXPECT_EQ(Result, MaxValue); 590 } 591 592 TYPED_TEST(OverflowTest, MulOverflowToMin) { 593 TypeParam Result; 594 auto MinValue = std::numeric_limits<TypeParam>::min(); 595 EXPECT_TRUE(MulOverflow<TypeParam>(MinValue, -1, Result)); 596 EXPECT_EQ(Result, MinValue); 597 } 598 599 TYPED_TEST(OverflowTest, MulOverflowMax) { 600 TypeParam Result; 601 auto MinValue = std::numeric_limits<TypeParam>::min(); 602 auto MaxValue = std::numeric_limits<TypeParam>::max(); 603 EXPECT_TRUE(MulOverflow<TypeParam>(MinValue, MinValue, Result)); 604 EXPECT_EQ(Result, 0); 605 EXPECT_TRUE(MulOverflow<TypeParam>(MaxValue, MaxValue, Result)); 606 EXPECT_EQ(Result, 1); 607 } 608 609 TYPED_TEST(OverflowTest, MulResultZero) { 610 TypeParam Result; 611 EXPECT_FALSE(MulOverflow<TypeParam>(4, 0, Result)); 612 EXPECT_EQ(Result, TypeParam(0)); 613 EXPECT_FALSE(MulOverflow<TypeParam>(-5, 0, Result)); 614 EXPECT_EQ(Result, TypeParam(0)); 615 EXPECT_FALSE(MulOverflow<TypeParam>(0, 5, Result)); 616 EXPECT_EQ(Result, TypeParam(0)); 617 EXPECT_FALSE(MulOverflow<TypeParam>(0, -5, Result)); 618 EXPECT_EQ(Result, TypeParam(0)); 619 } 620 621 } // namespace 622