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