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