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, CTLog2) { 147 EXPECT_EQ(CTLog2<1ULL << 0>(), 0U); 148 EXPECT_EQ(CTLog2<1ULL << 1>(), 1U); 149 EXPECT_EQ(CTLog2<1ULL << 2>(), 2U); 150 EXPECT_EQ(CTLog2<1ULL << 3>(), 3U); 151 EXPECT_EQ(CTLog2<1ULL << 4>(), 4U); 152 EXPECT_EQ(CTLog2<1ULL << 5>(), 5U); 153 EXPECT_EQ(CTLog2<1ULL << 6>(), 6U); 154 EXPECT_EQ(CTLog2<1ULL << 7>(), 7U); 155 EXPECT_EQ(CTLog2<1ULL << 8>(), 8U); 156 EXPECT_EQ(CTLog2<1ULL << 9>(), 9U); 157 EXPECT_EQ(CTLog2<1ULL << 10>(), 10U); 158 EXPECT_EQ(CTLog2<1ULL << 11>(), 11U); 159 EXPECT_EQ(CTLog2<1ULL << 12>(), 12U); 160 EXPECT_EQ(CTLog2<1ULL << 13>(), 13U); 161 EXPECT_EQ(CTLog2<1ULL << 14>(), 14U); 162 EXPECT_EQ(CTLog2<1ULL << 15>(), 15U); 163 } 164 165 TEST(MathExtras, MinAlign) { 166 EXPECT_EQ(1u, MinAlign(2, 3)); 167 EXPECT_EQ(2u, MinAlign(2, 4)); 168 EXPECT_EQ(1u, MinAlign(17, 64)); 169 EXPECT_EQ(256u, MinAlign(256, 512)); 170 } 171 172 TEST(MathExtras, NextPowerOf2) { 173 EXPECT_EQ(4u, NextPowerOf2(3)); 174 EXPECT_EQ(16u, NextPowerOf2(15)); 175 EXPECT_EQ(256u, NextPowerOf2(128)); 176 } 177 178 TEST(MathExtras, alignTo) { 179 EXPECT_EQ(8u, alignTo(5, 8)); 180 EXPECT_EQ(24u, alignTo(17, 8)); 181 EXPECT_EQ(0u, alignTo(~0LL, 8)); 182 183 EXPECT_EQ(7u, alignTo(5, 8, 7)); 184 EXPECT_EQ(17u, alignTo(17, 8, 1)); 185 EXPECT_EQ(3u, alignTo(~0LL, 8, 3)); 186 EXPECT_EQ(552u, alignTo(321, 255, 42)); 187 } 188 189 template <typename T> void SaturatingAddTestHelper() { 190 const T Max = std::numeric_limits<T>::max(); 191 bool ResultOverflowed; 192 193 EXPECT_EQ(T(3), SaturatingAdd(T(1), T(2))); 194 EXPECT_EQ(T(3), SaturatingAdd(T(1), T(2), &ResultOverflowed)); 195 EXPECT_FALSE(ResultOverflowed); 196 197 EXPECT_EQ(Max, SaturatingAdd(Max, T(1))); 198 EXPECT_EQ(Max, SaturatingAdd(Max, T(1), &ResultOverflowed)); 199 EXPECT_TRUE(ResultOverflowed); 200 201 EXPECT_EQ(Max, SaturatingAdd(T(1), T(Max - 1))); 202 EXPECT_EQ(Max, SaturatingAdd(T(1), T(Max - 1), &ResultOverflowed)); 203 EXPECT_FALSE(ResultOverflowed); 204 205 EXPECT_EQ(Max, SaturatingAdd(T(1), Max)); 206 EXPECT_EQ(Max, SaturatingAdd(T(1), Max, &ResultOverflowed)); 207 EXPECT_TRUE(ResultOverflowed); 208 209 EXPECT_EQ(Max, SaturatingAdd(Max, Max)); 210 EXPECT_EQ(Max, SaturatingAdd(Max, Max, &ResultOverflowed)); 211 EXPECT_TRUE(ResultOverflowed); 212 213 EXPECT_EQ(T(6), SaturatingAdd(T(1), T(2), T(3))); 214 EXPECT_EQ(T(6), SaturatingAdd(T(1), T(2), T(3), &ResultOverflowed)); 215 EXPECT_FALSE(ResultOverflowed); 216 217 EXPECT_EQ(T(10), SaturatingAdd(T(1), T(2), T(3), T(4))); 218 EXPECT_EQ(T(10), SaturatingAdd(T(1), T(2), T(3), T(4), &ResultOverflowed)); 219 EXPECT_FALSE(ResultOverflowed); 220 221 EXPECT_EQ(Max, SaturatingAdd(Max, T(0), T(0))); 222 EXPECT_EQ(Max, SaturatingAdd(Max, T(0), T(0), &ResultOverflowed)); 223 EXPECT_FALSE(ResultOverflowed); 224 225 EXPECT_EQ(Max, SaturatingAdd(T(0), T(0), Max)); 226 EXPECT_EQ(Max, SaturatingAdd(T(0), T(0), Max, &ResultOverflowed)); 227 EXPECT_FALSE(ResultOverflowed); 228 229 EXPECT_EQ(Max, SaturatingAdd(Max, T(0), T(1))); 230 EXPECT_EQ(Max, SaturatingAdd(Max, T(0), T(1), &ResultOverflowed)); 231 EXPECT_TRUE(ResultOverflowed); 232 233 EXPECT_EQ(Max, SaturatingAdd(T(0), T(1), Max)); 234 EXPECT_EQ(Max, SaturatingAdd(T(0), T(1), Max, &ResultOverflowed)); 235 EXPECT_TRUE(ResultOverflowed); 236 237 EXPECT_EQ(Max, SaturatingAdd(T(1), T(Max - 2), T(1))); 238 EXPECT_EQ(Max, SaturatingAdd(T(1), T(Max - 2), T(1), &ResultOverflowed)); 239 EXPECT_FALSE(ResultOverflowed); 240 241 EXPECT_EQ(Max, SaturatingAdd(T(1), T(1), T(Max - 2))); 242 EXPECT_EQ(Max, SaturatingAdd(T(1), T(1), T(Max - 2), &ResultOverflowed)); 243 EXPECT_FALSE(ResultOverflowed); 244 245 EXPECT_EQ(Max, SaturatingAdd(Max, Max, Max)); 246 EXPECT_EQ(Max, SaturatingAdd(Max, Max, Max, &ResultOverflowed)); 247 EXPECT_TRUE(ResultOverflowed); 248 } 249 250 TEST(MathExtras, SaturatingAdd) { 251 SaturatingAddTestHelper<uint8_t>(); 252 SaturatingAddTestHelper<uint16_t>(); 253 SaturatingAddTestHelper<uint32_t>(); 254 SaturatingAddTestHelper<uint64_t>(); 255 } 256 257 template<typename T> 258 void SaturatingMultiplyTestHelper() 259 { 260 const T Max = std::numeric_limits<T>::max(); 261 bool ResultOverflowed; 262 263 // Test basic multiplication. 264 EXPECT_EQ(T(6), SaturatingMultiply(T(2), T(3))); 265 EXPECT_EQ(T(6), SaturatingMultiply(T(2), T(3), &ResultOverflowed)); 266 EXPECT_FALSE(ResultOverflowed); 267 268 EXPECT_EQ(T(6), SaturatingMultiply(T(3), T(2))); 269 EXPECT_EQ(T(6), SaturatingMultiply(T(3), T(2), &ResultOverflowed)); 270 EXPECT_FALSE(ResultOverflowed); 271 272 // Test multiplication by zero. 273 EXPECT_EQ(T(0), SaturatingMultiply(T(0), T(0))); 274 EXPECT_EQ(T(0), SaturatingMultiply(T(0), T(0), &ResultOverflowed)); 275 EXPECT_FALSE(ResultOverflowed); 276 277 EXPECT_EQ(T(0), SaturatingMultiply(T(1), T(0))); 278 EXPECT_EQ(T(0), SaturatingMultiply(T(1), T(0), &ResultOverflowed)); 279 EXPECT_FALSE(ResultOverflowed); 280 281 EXPECT_EQ(T(0), SaturatingMultiply(T(0), T(1))); 282 EXPECT_EQ(T(0), SaturatingMultiply(T(0), T(1), &ResultOverflowed)); 283 EXPECT_FALSE(ResultOverflowed); 284 285 EXPECT_EQ(T(0), SaturatingMultiply(Max, T(0))); 286 EXPECT_EQ(T(0), SaturatingMultiply(Max, T(0), &ResultOverflowed)); 287 EXPECT_FALSE(ResultOverflowed); 288 289 EXPECT_EQ(T(0), SaturatingMultiply(T(0), Max)); 290 EXPECT_EQ(T(0), SaturatingMultiply(T(0), Max, &ResultOverflowed)); 291 EXPECT_FALSE(ResultOverflowed); 292 293 // Test multiplication by maximum value. 294 EXPECT_EQ(Max, SaturatingMultiply(Max, T(2))); 295 EXPECT_EQ(Max, SaturatingMultiply(Max, T(2), &ResultOverflowed)); 296 EXPECT_TRUE(ResultOverflowed); 297 298 EXPECT_EQ(Max, SaturatingMultiply(T(2), Max)); 299 EXPECT_EQ(Max, SaturatingMultiply(T(2), Max, &ResultOverflowed)); 300 EXPECT_TRUE(ResultOverflowed); 301 302 EXPECT_EQ(Max, SaturatingMultiply(Max, Max)); 303 EXPECT_EQ(Max, SaturatingMultiply(Max, Max, &ResultOverflowed)); 304 EXPECT_TRUE(ResultOverflowed); 305 306 // Test interesting boundary conditions for algorithm - 307 // ((1 << A) - 1) * ((1 << B) + K) for K in [-1, 0, 1] 308 // and A + B == std::numeric_limits<T>::digits. 309 // We expect overflow iff A > B and K = 1. 310 const int Digits = std::numeric_limits<T>::digits; 311 for (int A = 1, B = Digits - 1; B >= 1; ++A, --B) { 312 for (int K = -1; K <= 1; ++K) { 313 T X = (T(1) << A) - T(1); 314 T Y = (T(1) << B) + K; 315 bool OverflowExpected = A > B && K == 1; 316 317 if(OverflowExpected) { 318 EXPECT_EQ(Max, SaturatingMultiply(X, Y)); 319 EXPECT_EQ(Max, SaturatingMultiply(X, Y, &ResultOverflowed)); 320 EXPECT_TRUE(ResultOverflowed); 321 } else { 322 EXPECT_EQ(X * Y, SaturatingMultiply(X, Y)); 323 EXPECT_EQ(X * Y, SaturatingMultiply(X, Y, &ResultOverflowed)); 324 EXPECT_FALSE(ResultOverflowed); 325 } 326 } 327 } 328 } 329 330 TEST(MathExtras, SaturatingMultiply) { 331 SaturatingMultiplyTestHelper<uint8_t>(); 332 SaturatingMultiplyTestHelper<uint16_t>(); 333 SaturatingMultiplyTestHelper<uint32_t>(); 334 SaturatingMultiplyTestHelper<uint64_t>(); 335 } 336 337 template<typename T> 338 void SaturatingMultiplyAddTestHelper() 339 { 340 const T Max = std::numeric_limits<T>::max(); 341 bool ResultOverflowed; 342 343 // Test basic multiply-add. 344 EXPECT_EQ(T(16), SaturatingMultiplyAdd(T(2), T(3), T(10))); 345 EXPECT_EQ(T(16), SaturatingMultiplyAdd(T(2), T(3), T(10), &ResultOverflowed)); 346 EXPECT_FALSE(ResultOverflowed); 347 348 // Test multiply overflows, add doesn't overflow 349 EXPECT_EQ(Max, SaturatingMultiplyAdd(Max, Max, T(0), &ResultOverflowed)); 350 EXPECT_TRUE(ResultOverflowed); 351 352 // Test multiply doesn't overflow, add overflows 353 EXPECT_EQ(Max, SaturatingMultiplyAdd(T(1), T(1), Max, &ResultOverflowed)); 354 EXPECT_TRUE(ResultOverflowed); 355 356 // Test multiply-add with Max as operand 357 EXPECT_EQ(Max, SaturatingMultiplyAdd(T(1), T(1), Max, &ResultOverflowed)); 358 EXPECT_TRUE(ResultOverflowed); 359 360 EXPECT_EQ(Max, SaturatingMultiplyAdd(T(1), Max, T(1), &ResultOverflowed)); 361 EXPECT_TRUE(ResultOverflowed); 362 363 EXPECT_EQ(Max, SaturatingMultiplyAdd(Max, Max, T(1), &ResultOverflowed)); 364 EXPECT_TRUE(ResultOverflowed); 365 366 EXPECT_EQ(Max, SaturatingMultiplyAdd(Max, Max, Max, &ResultOverflowed)); 367 EXPECT_TRUE(ResultOverflowed); 368 369 // Test multiply-add with 0 as operand 370 EXPECT_EQ(T(1), SaturatingMultiplyAdd(T(1), T(1), T(0), &ResultOverflowed)); 371 EXPECT_FALSE(ResultOverflowed); 372 373 EXPECT_EQ(T(1), SaturatingMultiplyAdd(T(1), T(0), T(1), &ResultOverflowed)); 374 EXPECT_FALSE(ResultOverflowed); 375 376 EXPECT_EQ(T(1), SaturatingMultiplyAdd(T(0), T(0), T(1), &ResultOverflowed)); 377 EXPECT_FALSE(ResultOverflowed); 378 379 EXPECT_EQ(T(0), SaturatingMultiplyAdd(T(0), T(0), T(0), &ResultOverflowed)); 380 EXPECT_FALSE(ResultOverflowed); 381 382 } 383 384 TEST(MathExtras, SaturatingMultiplyAdd) { 385 SaturatingMultiplyAddTestHelper<uint8_t>(); 386 SaturatingMultiplyAddTestHelper<uint16_t>(); 387 SaturatingMultiplyAddTestHelper<uint32_t>(); 388 SaturatingMultiplyAddTestHelper<uint64_t>(); 389 } 390 391 TEST(MathExtras, IsShiftedUInt) { 392 EXPECT_TRUE((isShiftedUInt<1, 0>(0))); 393 EXPECT_TRUE((isShiftedUInt<1, 0>(1))); 394 EXPECT_FALSE((isShiftedUInt<1, 0>(2))); 395 EXPECT_FALSE((isShiftedUInt<1, 0>(3))); 396 EXPECT_FALSE((isShiftedUInt<1, 0>(0x8000000000000000))); 397 EXPECT_TRUE((isShiftedUInt<1, 63>(0x8000000000000000))); 398 EXPECT_TRUE((isShiftedUInt<2, 62>(0xC000000000000000))); 399 EXPECT_FALSE((isShiftedUInt<2, 62>(0xE000000000000000))); 400 401 // 0x201 is ten bits long and has a 1 in the MSB and LSB. 402 EXPECT_TRUE((isShiftedUInt<10, 5>(uint64_t(0x201) << 5))); 403 EXPECT_FALSE((isShiftedUInt<10, 5>(uint64_t(0x201) << 4))); 404 EXPECT_FALSE((isShiftedUInt<10, 5>(uint64_t(0x201) << 6))); 405 } 406 407 TEST(MathExtras, IsShiftedInt) { 408 EXPECT_TRUE((isShiftedInt<1, 0>(0))); 409 EXPECT_TRUE((isShiftedInt<1, 0>(-1))); 410 EXPECT_FALSE((isShiftedInt<1, 0>(2))); 411 EXPECT_FALSE((isShiftedInt<1, 0>(3))); 412 EXPECT_FALSE((isShiftedInt<1, 0>(0x8000000000000000))); 413 EXPECT_TRUE((isShiftedInt<1, 63>(0x8000000000000000))); 414 EXPECT_TRUE((isShiftedInt<2, 62>(0xC000000000000000))); 415 EXPECT_FALSE((isShiftedInt<2, 62>(0xE000000000000000))); 416 417 // 0x201 is ten bits long and has a 1 in the MSB and LSB. 418 EXPECT_TRUE((isShiftedInt<11, 5>(int64_t(0x201) << 5))); 419 EXPECT_FALSE((isShiftedInt<11, 5>(int64_t(0x201) << 3))); 420 EXPECT_FALSE((isShiftedInt<11, 5>(int64_t(0x201) << 6))); 421 EXPECT_TRUE((isShiftedInt<11, 5>(-(int64_t(0x201) << 5)))); 422 EXPECT_FALSE((isShiftedInt<11, 5>(-(int64_t(0x201) << 3)))); 423 EXPECT_FALSE((isShiftedInt<11, 5>(-(int64_t(0x201) << 6)))); 424 425 EXPECT_TRUE((isShiftedInt<6, 10>(-(int64_t(1) << 15)))); 426 EXPECT_FALSE((isShiftedInt<6, 10>(int64_t(1) << 15))); 427 } 428 429 template <typename T> 430 class OverflowTest : public ::testing::Test { }; 431 432 using OverflowTestTypes = ::testing::Types<signed char, short, int, long, 433 long long>; 434 435 TYPED_TEST_SUITE(OverflowTest, OverflowTestTypes, ); 436 437 TYPED_TEST(OverflowTest, AddNoOverflow) { 438 TypeParam Result; 439 EXPECT_FALSE(AddOverflow<TypeParam>(1, 2, Result)); 440 EXPECT_EQ(Result, TypeParam(3)); 441 } 442 443 TYPED_TEST(OverflowTest, AddOverflowToNegative) { 444 TypeParam Result; 445 auto MaxValue = std::numeric_limits<TypeParam>::max(); 446 EXPECT_TRUE(AddOverflow<TypeParam>(MaxValue, MaxValue, Result)); 447 EXPECT_EQ(Result, TypeParam(-2)); 448 } 449 450 TYPED_TEST(OverflowTest, AddOverflowToMin) { 451 TypeParam Result; 452 auto MaxValue = std::numeric_limits<TypeParam>::max(); 453 EXPECT_TRUE(AddOverflow<TypeParam>(MaxValue, TypeParam(1), Result)); 454 EXPECT_EQ(Result, std::numeric_limits<TypeParam>::min()); 455 } 456 457 TYPED_TEST(OverflowTest, AddOverflowToZero) { 458 TypeParam Result; 459 auto MinValue = std::numeric_limits<TypeParam>::min(); 460 EXPECT_TRUE(AddOverflow<TypeParam>(MinValue, MinValue, Result)); 461 EXPECT_EQ(Result, TypeParam(0)); 462 } 463 464 TYPED_TEST(OverflowTest, AddOverflowToMax) { 465 TypeParam Result; 466 auto MinValue = std::numeric_limits<TypeParam>::min(); 467 EXPECT_TRUE(AddOverflow<TypeParam>(MinValue, TypeParam(-1), Result)); 468 EXPECT_EQ(Result, std::numeric_limits<TypeParam>::max()); 469 } 470 471 TYPED_TEST(OverflowTest, SubNoOverflow) { 472 TypeParam Result; 473 EXPECT_FALSE(SubOverflow<TypeParam>(1, 2, Result)); 474 EXPECT_EQ(Result, TypeParam(-1)); 475 } 476 477 TYPED_TEST(OverflowTest, SubOverflowToMax) { 478 TypeParam Result; 479 auto MinValue = std::numeric_limits<TypeParam>::min(); 480 EXPECT_TRUE(SubOverflow<TypeParam>(0, MinValue, Result)); 481 EXPECT_EQ(Result, MinValue); 482 } 483 484 TYPED_TEST(OverflowTest, SubOverflowToMin) { 485 TypeParam Result; 486 auto MinValue = std::numeric_limits<TypeParam>::min(); 487 EXPECT_TRUE(SubOverflow<TypeParam>(0, MinValue, Result)); 488 EXPECT_EQ(Result, MinValue); 489 } 490 491 TYPED_TEST(OverflowTest, SubOverflowToNegative) { 492 TypeParam Result; 493 auto MaxValue = std::numeric_limits<TypeParam>::max(); 494 auto MinValue = std::numeric_limits<TypeParam>::min(); 495 EXPECT_TRUE(SubOverflow<TypeParam>(MaxValue, MinValue, Result)); 496 EXPECT_EQ(Result, TypeParam(-1)); 497 } 498 499 TYPED_TEST(OverflowTest, SubOverflowToPositive) { 500 TypeParam Result; 501 auto MaxValue = std::numeric_limits<TypeParam>::max(); 502 auto MinValue = std::numeric_limits<TypeParam>::min(); 503 EXPECT_TRUE(SubOverflow<TypeParam>(MinValue, MaxValue, Result)); 504 EXPECT_EQ(Result, TypeParam(1)); 505 } 506 507 TYPED_TEST(OverflowTest, MulNoOverflow) { 508 TypeParam Result; 509 EXPECT_FALSE(MulOverflow<TypeParam>(1, 2, Result)); 510 EXPECT_EQ(Result, 2); 511 EXPECT_FALSE(MulOverflow<TypeParam>(-1, 3, Result)); 512 EXPECT_EQ(Result, -3); 513 EXPECT_FALSE(MulOverflow<TypeParam>(4, -2, Result)); 514 EXPECT_EQ(Result, -8); 515 EXPECT_FALSE(MulOverflow<TypeParam>(-6, -5, Result)); 516 EXPECT_EQ(Result, 30); 517 } 518 519 TYPED_TEST(OverflowTest, MulNoOverflowToMax) { 520 TypeParam Result; 521 auto MaxValue = std::numeric_limits<TypeParam>::max(); 522 auto MinValue = std::numeric_limits<TypeParam>::min(); 523 EXPECT_FALSE(MulOverflow<TypeParam>(MinValue + 1, -1, Result)); 524 EXPECT_EQ(Result, MaxValue); 525 } 526 527 TYPED_TEST(OverflowTest, MulOverflowToMin) { 528 TypeParam Result; 529 auto MinValue = std::numeric_limits<TypeParam>::min(); 530 EXPECT_TRUE(MulOverflow<TypeParam>(MinValue, -1, Result)); 531 EXPECT_EQ(Result, MinValue); 532 } 533 534 TYPED_TEST(OverflowTest, MulOverflowMax) { 535 TypeParam Result; 536 auto MinValue = std::numeric_limits<TypeParam>::min(); 537 auto MaxValue = std::numeric_limits<TypeParam>::max(); 538 EXPECT_TRUE(MulOverflow<TypeParam>(MinValue, MinValue, Result)); 539 EXPECT_EQ(Result, 0); 540 EXPECT_TRUE(MulOverflow<TypeParam>(MaxValue, MaxValue, Result)); 541 EXPECT_EQ(Result, 1); 542 } 543 544 TYPED_TEST(OverflowTest, MulResultZero) { 545 TypeParam Result; 546 EXPECT_FALSE(MulOverflow<TypeParam>(4, 0, Result)); 547 EXPECT_EQ(Result, TypeParam(0)); 548 EXPECT_FALSE(MulOverflow<TypeParam>(-5, 0, Result)); 549 EXPECT_EQ(Result, TypeParam(0)); 550 EXPECT_FALSE(MulOverflow<TypeParam>(0, 5, Result)); 551 EXPECT_EQ(Result, TypeParam(0)); 552 EXPECT_FALSE(MulOverflow<TypeParam>(0, -5, Result)); 553 EXPECT_EQ(Result, TypeParam(0)); 554 } 555 556 } // namespace 557