[Support] Fix SaturatingMultiply<T>() to be correct (and fast), Re-enable Unit Tests

[oota-llvm.git] / unittests / Support / MathExtrasTest.cpp

diff --git a/unittests/Support/MathExtrasTest.cpp b/unittests/Support/MathExtrasTest.cpp
index 8adde02ed4ee1b6fac8041014ae921f85bf77827..fa12f750407badf90af4fdc0f547fb8d42602755 100644 (file)
--- a/unittests/Support/MathExtrasTest.cpp
+++ b/unittests/Support/MathExtrasTest.cpp
@@ -193,15 +193,11 @@ TEST(MathExtras, RoundUpToAlignment) {
 template<typename T>
 void SaturatingAddTestHelper()
 {
-  EXPECT_EQ(static_cast<T>(3),
-            SaturatingAdd(static_cast<T>(1), static_cast<T>(2)));
-  EXPECT_EQ(std::numeric_limits<T>::max(),
-            SaturatingAdd(std::numeric_limits<T>::max(), static_cast<T>(1)));
-  EXPECT_EQ(std::numeric_limits<T>::max(),
-            SaturatingAdd(static_cast<T>(1), std::numeric_limits<T>::max()));
-  EXPECT_EQ(std::numeric_limits<T>::max(),
-            SaturatingAdd(std::numeric_limits<T>::max(),
-                          std::numeric_limits<T>::max()));
+  const T Max = std::numeric_limits<T>::max();
+  EXPECT_EQ(T(3), SaturatingAdd(T(1), T(2)));
+  EXPECT_EQ(Max, SaturatingAdd(Max, T(1)));
+  EXPECT_EQ(Max, SaturatingAdd(T(1), Max));
+  EXPECT_EQ(Max, SaturatingAdd(Max, Max));
 }
 
 TEST(MathExtras, SaturatingAdd) {
@@ -214,21 +210,42 @@ TEST(MathExtras, SaturatingAdd) {
 template<typename T>
 void SaturatingMultiplyTestHelper()
 {
-  EXPECT_EQ(static_cast<T>(0),
-            SaturatingMultiply(static_cast<T>(1), static_cast<T>(0)));
-  EXPECT_EQ(static_cast<T>(0),
-            SaturatingMultiply(static_cast<T>(0), static_cast<T>(1)));
-  EXPECT_EQ(static_cast<T>(6),
-            SaturatingMultiply(static_cast<T>(2), static_cast<T>(3)));
-  EXPECT_EQ(std::numeric_limits<T>::max(),
-            SaturatingMultiply(std::numeric_limits<T>::max(),
-                               static_cast<T>(2)));
-  EXPECT_EQ(std::numeric_limits<T>::max(),
-            SaturatingMultiply(static_cast<T>(2),
-                               std::numeric_limits<T>::max()));
-  EXPECT_EQ(std::numeric_limits<T>::max(),
-            SaturatingMultiply(std::numeric_limits<T>::max(),
-                          std::numeric_limits<T>::max()));
+  const T Max = std::numeric_limits<T>::max();
+
+  // Test basic multiplication.
+  EXPECT_EQ(T(6), SaturatingMultiply(T(2), T(3)));
+  EXPECT_EQ(T(6), SaturatingMultiply(T(3), T(2)));
+
+  // Test multiplication by zero.
+  EXPECT_EQ(T(0), SaturatingMultiply(T(0), T(0)));
+  EXPECT_EQ(T(0), SaturatingMultiply(T(1), T(0)));
+  EXPECT_EQ(T(0), SaturatingMultiply(T(0), T(1)));
+  EXPECT_EQ(T(0), SaturatingMultiply(Max, T(0)));
+  EXPECT_EQ(T(0), SaturatingMultiply(T(0), Max));
+
+  // Test multiplication by maximum value.
+  EXPECT_EQ(Max, SaturatingMultiply(Max, T(2)));
+  EXPECT_EQ(Max, SaturatingMultiply(T(2),Max));
+  EXPECT_EQ(Max, SaturatingMultiply(Max, Max));
+
+  // Test interesting boundary conditions for algorithm -
+  // ((1 << A) - 1) * ((1 << B) + K) for K in [-1, 0, 1]
+  // and A + B == std::numeric_limits<T>::digits.
+  // We expect overflow iff A > B and K = 1.
+  const int Digits = std::numeric_limits<T>::digits;
+  for (int A = 1, B = Digits - 1; B >= 1; ++A, --B) {
+    for (int K = -1; K <= 1; ++K) {
+      T X = (T(1) << A) - T(1);
+      T Y = (T(1) << B) + K;
+      bool OverflowExpected = A > B && K == 1;
+
+      if(OverflowExpected) {
+        EXPECT_EQ(Max, SaturatingMultiply(X, Y));
+      } else {
+        EXPECT_EQ(X * Y, SaturatingMultiply(X, Y));
+      }
+    }
+  }
 }
 
 TEST(MathExtras, SaturatingMultiply) {