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