CL for perf tryjob

Source/wtf/MathExtrasTest.cpp

Index: Source/wtf/MathExtrasTest.cpp
diff --git a/Source/wtf/MathExtrasTest.cpp b/Source/wtf/MathExtrasTest.cpp
index 7a46ec02c1c83f9caf2db244d6b5f35089b6d58f..034573f3234dd259f4d2ba934c59994fe40d0692 100644
--- a/Source/wtf/MathExtrasTest.cpp
+++ b/Source/wtf/MathExtrasTest.cpp
@@ -88,45 +88,54 @@ TEST(MathExtrasTest, clampToIntLongLong)
     EXPECT_EQ(minInt, clampTo<int>(underflowInt));
 }
 
-TEST(MathExtrasTest, clampToIntegerFloat)
+TEST(MathExtrasTest, clampToIntFloat)
 {
-    // This test is inaccurate as floats will round the min / max integer
-    // due to the narrow mantissa. However it will properly checks within
-    // (close to the extreme) and outside the integer range.
-    float maxInt = std::numeric_limits<int>::max();
-    float minInt = std::numeric_limits<int>::min();
-    float overflowInt = maxInt * 1.1;
-    float underflowInt = minInt * 1.1;
+    float maxInt = static_cast<float>(std::numeric_limits<int>::max());
+    float minInt = static_cast<float>(std::numeric_limits<int>::min());
+    float overflowInt = maxInt * 1.1f;
+    float underflowInt = minInt * 1.1f;
 
     EXPECT_GT(overflowInt, maxInt);
     EXPECT_LT(underflowInt, minInt);
 
-    // If maxInt == 2^31 - 1 (ie on I32 architecture), the closest float used to represent it is 2^31.
-    EXPECT_NEAR(clampToInteger(maxInt), maxInt, 1);
-    EXPECT_EQ(minInt, clampToInteger(minInt));
+    EXPECT_EQ(maxInt, clampTo<int>(maxInt));
+    EXPECT_EQ(minInt, clampTo<int>(minInt));
+
+    EXPECT_EQ(maxInt, clampTo<int>(overflowInt));
+    EXPECT_EQ(minInt, clampTo<int>(underflowInt));
 
-    EXPECT_NEAR(clampToInteger(overflowInt), maxInt, 1);
-    EXPECT_EQ(minInt, clampToInteger(underflowInt));
+    // This value and the value one greater are typically represented the same
+    // way when stored in a 32-bit float.  Make sure clamping does not cause us
+    // to erroneously jump to the larger value.
+    int nearFloatPrecisionLimit = 2147483520;
+    EXPECT_EQ(nearFloatPrecisionLimit, clampTo<int>(static_cast<float>(nearFloatPrecisionLimit), 0, nearFloatPrecisionLimit + 1));
+    EXPECT_EQ(-nearFloatPrecisionLimit, clampTo<int>(static_cast<float>(-nearFloatPrecisionLimit), -nearFloatPrecisionLimit - 1, 0));
 }
 
-TEST(MathExtrasTest, clampToIntegerDouble)
+TEST(MathExtrasTest, clampToIntDouble)
 {
-    double maxInt = std::numeric_limits<int>::max();
-    double minInt = std::numeric_limits<int>::min();
-    double overflowInt = maxInt + 1;
-    double underflowInt = minInt - 1;
-
+    int maxInt = std::numeric_limits<int>::max();
+    int minInt = std::numeric_limits<int>::min();
+    double almostOverflowInt = maxInt - 0.5;
+    double overflowInt = maxInt + 0.5;
+    double almostUnderflowInt = minInt + 0.5;
+    double underflowInt = minInt - 0.5;
+
+    EXPECT_LT(almostOverflowInt, maxInt);
     EXPECT_GT(overflowInt, maxInt);
+    EXPECT_GT(almostUnderflowInt, minInt);
     EXPECT_LT(underflowInt, minInt);
 
-    EXPECT_EQ(maxInt, clampToInteger(maxInt));
-    EXPECT_EQ(minInt, clampToInteger(minInt));
+    EXPECT_EQ(maxInt, clampTo<int>(static_cast<double>(maxInt)));
+    EXPECT_EQ(minInt, clampTo<int>(static_cast<double>(minInt)));
 
-    EXPECT_EQ(clampToInteger(overflowInt), maxInt);
-    EXPECT_EQ(clampToInteger(underflowInt), minInt);
+    EXPECT_EQ(maxInt - 1, clampTo<int>(almostOverflowInt));
+    EXPECT_EQ(maxInt, clampTo<int>(overflowInt));
+    EXPECT_EQ(minInt + 1, clampTo<int>(almostUnderflowInt));
+    EXPECT_EQ(minInt, clampTo<int>(underflowInt));
 }
 
-TEST(MathExtrasTest, clampToFloat)
+TEST(MathExtrasTest, clampToFloatDouble)
 {
     double maxFloat = std::numeric_limits<float>::max();
     double minFloat = -maxFloat;
@@ -136,17 +145,39 @@ TEST(MathExtrasTest, clampToFloat)
     EXPECT_GT(overflowFloat, maxFloat);
     EXPECT_LT(underflowFloat, minFloat);
 
-    EXPECT_EQ(maxFloat, clampToFloat(maxFloat));
-    EXPECT_EQ(minFloat, clampToFloat(minFloat));
+    EXPECT_EQ(maxFloat, clampTo<float>(maxFloat));
+    EXPECT_EQ(minFloat, clampTo<float>(minFloat));
 
-    EXPECT_EQ(maxFloat, clampToFloat(overflowFloat));
-    EXPECT_EQ(minFloat, clampToFloat(underflowFloat));
+    EXPECT_EQ(maxFloat, clampTo<float>(overflowFloat));
+    EXPECT_EQ(minFloat, clampTo<float>(underflowFloat));
 
-    EXPECT_EQ(maxFloat, clampToFloat(std::numeric_limits<float>::infinity()));
-    EXPECT_EQ(minFloat, clampToFloat(-std::numeric_limits<float>::infinity()));
+    EXPECT_EQ(maxFloat, clampTo<float>(std::numeric_limits<float>::infinity()));
+    EXPECT_EQ(minFloat, clampTo<float>(-std::numeric_limits<float>::infinity()));
 }
 
-TEST(MathExtrasTest, clampToUnsignedLong)
+TEST(MathExtrasTest, clampToDouble)
+{
+    EXPECT_EQ(0.0, clampTo<double>(0));
+    EXPECT_EQ(0.0, clampTo<double>(0.0f));
+    EXPECT_EQ(0.0, clampTo<double>(0ULL));
+    EXPECT_EQ(3.5, clampTo<double>(std::numeric_limits<unsigned long long>::max(), 0.0, 3.5));
+}
+
+TEST(MathExtrasText, clampToLongLongDouble)
+{
+    double overflowLL = static_cast<double>(std::numeric_limits<long long>::max()) * 2;
+    EXPECT_EQ(std::numeric_limits<long long>::max(), clampTo<long long>(overflowLL));
+    EXPECT_EQ(std::numeric_limits<long long>::min(), clampTo<long long>(-overflowLL));
+}
+
+TEST(MathExtrasText, clampToUnsignedLongLongDouble)
+{
+    double overflowULL = static_cast<double>(std::numeric_limits<unsigned long long>::max()) * 2;
+    EXPECT_EQ(std::numeric_limits<unsigned long long>::max(), clampTo<unsigned long long>(overflowULL));
+    EXPECT_EQ(std::numeric_limits<unsigned long long>::min(), clampTo<unsigned long long>(-overflowULL));
+}
+
+TEST(MathExtrasTest, clampToUnsignedUnsignedLong)
 {
     if (sizeof(unsigned long) == sizeof(unsigned))
         return;
@@ -162,7 +193,7 @@ TEST(MathExtrasTest, clampToUnsignedLong)
     EXPECT_EQ(0u, clampTo<unsigned>(-1));
 }
 
-TEST(MathExtrasTest, clampToUnsignedLongLong)
+TEST(MathExtrasTest, clampToUnsignedUnsignedLongLong)
 {
     unsigned long long maxUnsigned = std::numeric_limits<unsigned>::max();
     unsigned long long overflowUnsigned = maxUnsigned + 1;
@@ -175,6 +206,36 @@ TEST(MathExtrasTest, clampToUnsignedLongLong)
     EXPECT_EQ(0u, clampTo<unsigned>(-1));
 }
 
+TEST(MathExtrasTest, clampToLongLongUnsignedLongLong)
+{
+    long long maxLongLongLL = std::numeric_limits<long long>::max();
+    unsigned long long maxLongLongULL = maxLongLongLL;
+    unsigned long long overflowLongLong = maxLongLongULL + 1;
+
+    EXPECT_GT(overflowLongLong, maxLongLongULL);
+
+    EXPECT_EQ(maxLongLongLL, clampTo<long long>(maxLongLongULL));
+    EXPECT_EQ(maxLongLongLL - 1, clampTo<long long>(maxLongLongULL - 1));
+    EXPECT_EQ(maxLongLongLL, clampTo<long long>(overflowLongLong));
+
+    EXPECT_EQ(-3LL, clampTo<long long>(2ULL, -5LL, -3LL));
+}
+
+TEST(MathExtrasTest, clampToUnsignedLongLongInt)
+{
+    EXPECT_EQ(0ULL, clampTo<unsigned long long>(-1));
+    EXPECT_EQ(0ULL, clampTo<unsigned long long>(0));
+    EXPECT_EQ(1ULL, clampTo<unsigned long long>(1));
+}
+
+TEST(MathExtrasTest, clampToUnsignedLongLongUnsignedLongLong)
+{
+    EXPECT_EQ(0ULL, clampTo<unsigned long long>(0ULL));
+    EXPECT_EQ(1ULL, clampTo<unsigned long long>(0ULL, 1ULL, 2ULL));
+    EXPECT_EQ(2ULL, clampTo<unsigned long long>(3ULL, 1ULL, 2ULL));
+    EXPECT_EQ(0xFFFFFFFFFFFFFFF5ULL, clampTo<unsigned long long>(0xFFFFFFFFFFFFFFF5ULL));
+}
+
 // Make sure that various +-inf cases are handled properly (they aren't
 // by default on VS).
 TEST(MathExtrasTest, infinityMath)