CL for perf tryjob

Source/wtf/MathExtrasTest.cpp

 /*
  * Copyright (C) 2012 Intel Corporation
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 70 matching lines @@
     EXPECT_GT(overflowInt, maxInt);
     EXPECT_LT(underflowInt, 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));
 }
 
-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_NEAR(clampToInteger(overflowInt), maxInt, 1);
-    EXPECT_EQ(minInt, clampToInteger(underflowInt));
+    EXPECT_EQ(maxInt, clampTo<int>(overflowInt));
+    EXPECT_EQ(minInt, clampTo<int>(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;
     double overflowFloat = maxFloat * 1.1;
     double underflowFloat = minFloat * 1.1;
 
     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;
 
     unsigned long maxUnsigned = std::numeric_limits<unsigned>::max();
     unsigned long overflowUnsigned = maxUnsigned + 1;
 
     EXPECT_GT(overflowUnsigned, maxUnsigned);
 
     EXPECT_EQ(maxUnsigned, clampTo<unsigned>(maxUnsigned));
 
     EXPECT_EQ(maxUnsigned, clampTo<unsigned>(overflowUnsigned));
     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;
 
     EXPECT_GT(overflowUnsigned, maxUnsigned);
 
     EXPECT_EQ(maxUnsigned, clampTo<unsigned>(maxUnsigned));
 
     EXPECT_EQ(maxUnsigned, clampTo<unsigned>(overflowUnsigned));
     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)
 {
     double posInf = std::numeric_limits<double>::infinity();
     double negInf = -std::numeric_limits<double>::infinity();
     double nan = std::numeric_limits<double>::quiet_NaN();
 
     EXPECT_EQ(M_PI_4, atan2(posInf, posInf));
     EXPECT_EQ(3.0 * M_PI_4, atan2(posInf, negInf));
     EXPECT_EQ(-M_PI_4, atan2(negInf, posInf));
     EXPECT_EQ(-3.0 * M_PI_4, atan2(negInf, negInf));
 
     EXPECT_EQ(0.0, fmod(0.0, posInf));
     EXPECT_EQ(7.0, fmod(7.0, posInf));
     EXPECT_EQ(-7.0, fmod(-7.0, posInf));
     EXPECT_EQ(0.0, fmod(0.0, negInf));
     EXPECT_EQ(7.0, fmod(7.0, negInf));
     EXPECT_EQ(-7.0, fmod(-7.0, negInf));
 
     EXPECT_EQ(1.0, pow(5.0, 0.0));
     EXPECT_EQ(1.0, pow(-5.0, 0.0));
     EXPECT_EQ(1.0, pow(nan, 0.0));
 }
 
 } // namespace