Support saturation overrides in saturated_cast

base/numerics/safe_numerics_unittest.cc

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <limits>
 #include <type_traits>
 
@@ skipping 813 matching lines @@
   return 0;
 }
 
 static_assert(
     std::is_same<decltype(TestOverload(StrictNumeric<int>())), int>::value,
     "");
 static_assert(std::is_same<decltype(TestOverload(StrictNumeric<size_t>())),
                            size_t>::value,
               "");
 
+template <typename T>
+struct CastTest1 {
+  static constexpr T HandleNaN() { return -1; }
+  static constexpr T max() { return numeric_limits<T>::max() - 1; }
+  static constexpr T HandleOverflow() { return max(); }
+  static constexpr T lowest() { return numeric_limits<T>::lowest() + 1; }
+  static constexpr T HandleUnderflow() { return lowest(); }
+};
+
+template <typename T>
+struct CastTest2 {
+  static constexpr T HandleNaN() { return 11; }
+  static constexpr T max() { return 10; }
+  static constexpr T HandleOverflow() { return max(); }
+  static constexpr T lowest() { return 1; }
+  static constexpr T HandleUnderflow() { return lowest(); }
+};
+
 TEST(SafeNumerics, CastTests) {
 // MSVC catches and warns that we're forcing saturation in these tests.
 // Since that's intentional, we need to shut this warning off.
 #if defined(COMPILER_MSVC)
 #pragma warning(disable : 4756)
 #endif
 
   int small_positive = 1;
   int small_negative = -1;
   double double_small = 1.0;
@@ skipping 42 matching lines @@
             static_cast<unsigned>(0));
   EXPECT_EQ(saturated_cast<int>(double_small),
             static_cast<int>(double_small));
   EXPECT_EQ(saturated_cast<int>(double_large), numeric_limits<int>::max());
   EXPECT_EQ(saturated_cast<float>(double_large), double_infinity);
   EXPECT_EQ(saturated_cast<float>(-double_large), -double_infinity);
   EXPECT_EQ(numeric_limits<int>::lowest(),
             saturated_cast<int>(double_small_int));
   EXPECT_EQ(numeric_limits<int>::max(), saturated_cast<int>(double_large_int));
 
+  // Test the saturated cast overrides.
+  using FloatLimits = numeric_limits<float>;
+  using IntLimits = numeric_limits<int>;
+  EXPECT_EQ(-1, (saturated_cast<int, CastTest1>(FloatLimits::quiet_NaN())));
+  EXPECT_EQ(CastTest1<int>::max(),
+            (saturated_cast<int, CastTest1>(FloatLimits::infinity())));
+  EXPECT_EQ(CastTest1<int>::max(),
+            (saturated_cast<int, CastTest1>(FloatLimits::max())));
+  EXPECT_EQ(CastTest1<int>::max(),
+            (saturated_cast<int, CastTest1>(float(IntLimits::max()))));
+  EXPECT_EQ(CastTest1<int>::lowest(),
+            (saturated_cast<int, CastTest1>(-FloatLimits::infinity())));
+  EXPECT_EQ(CastTest1<int>::lowest(),
+            (saturated_cast<int, CastTest1>(FloatLimits::lowest())));
+  EXPECT_EQ(0, (saturated_cast<int, CastTest1>(0.0)));
+  EXPECT_EQ(1, (saturated_cast<int, CastTest1>(1.0)));
+  EXPECT_EQ(-1, (saturated_cast<int, CastTest1>(-1.0)));
+  EXPECT_EQ(0, (saturated_cast<int, CastTest1>(0)));
+  EXPECT_EQ(1, (saturated_cast<int, CastTest1>(1)));
+  EXPECT_EQ(-1, (saturated_cast<int, CastTest1>(-1)));
+  EXPECT_EQ(CastTest1<int>::lowest(),
+            (saturated_cast<int, CastTest1>(float(IntLimits::lowest()))));
+  EXPECT_EQ(11, (saturated_cast<int, CastTest2>(FloatLimits::quiet_NaN())));
+  EXPECT_EQ(10, (saturated_cast<int, CastTest2>(FloatLimits::infinity())));
+  EXPECT_EQ(10, (saturated_cast<int, CastTest2>(FloatLimits::max())));
+  EXPECT_EQ(1, (saturated_cast<int, CastTest2>(-FloatLimits::infinity())));
+  EXPECT_EQ(1, (saturated_cast<int, CastTest2>(FloatLimits::lowest())));
+  EXPECT_EQ(1, (saturated_cast<int, CastTest2>(0U)));
+
   float not_a_number = std::numeric_limits<float>::infinity() -
                        std::numeric_limits<float>::infinity();
   EXPECT_TRUE(std::isnan(not_a_number));
   EXPECT_EQ(0, saturated_cast<int>(not_a_number));
 
   // Test the CheckedNumeric value extractions functions.
   auto int8_min = MakeCheckedNum(numeric_limits<int8_t>::lowest());
   auto int8_max = MakeCheckedNum(numeric_limits<int8_t>::max());
   auto double_max = MakeCheckedNum(numeric_limits<double>::max());
   static_assert(
@@ skipping 24 matching lines @@
   EXPECT_EQ(static_cast<int16_t>(numeric_limits<int8_t>::lowest()), int16_dest);
   EXPECT_FALSE(double_max.AssignIfValid(&uint8_dest));
   EXPECT_FALSE(double_max.AssignIfValid(&int16_dest));
   EXPECT_TRUE(double_max.AssignIfValid(&double_dest));
   EXPECT_EQ(numeric_limits<double>::max(), double_dest);
   EXPECT_EQ(1, checked_cast<int>(StrictNumeric<int>(1)));
   EXPECT_EQ(1, saturated_cast<int>(StrictNumeric<int>(1)));
   EXPECT_EQ(1, strict_cast<int>(StrictNumeric<int>(1)));
 }
 
-TEST(SafeNumerics, SaturatedCastChecks) {
-  float not_a_number = std::numeric_limits<float>::infinity() -
-                       std::numeric_limits<float>::infinity();
-  EXPECT_TRUE(std::isnan(not_a_number));
-  EXPECT_DEATH_IF_SUPPORTED(
-      (saturated_cast<int, base::CheckOnFailure>(not_a_number)),
-      "");
-}
-
 TEST(SafeNumerics, IsValueInRangeForNumericType) {
   EXPECT_TRUE(IsValueInRangeForNumericType<uint32_t>(0));
   EXPECT_TRUE(IsValueInRangeForNumericType<uint32_t>(1));
   EXPECT_TRUE(IsValueInRangeForNumericType<uint32_t>(2));
   EXPECT_FALSE(IsValueInRangeForNumericType<uint32_t>(-1));
   EXPECT_TRUE(IsValueInRangeForNumericType<uint32_t>(0xffffffffu));
   EXPECT_TRUE(IsValueInRangeForNumericType<uint32_t>(UINT64_C(0xffffffff)));
   EXPECT_FALSE(IsValueInRangeForNumericType<uint32_t>(UINT64_C(0x100000000)));
   EXPECT_FALSE(IsValueInRangeForNumericType<uint32_t>(UINT64_C(0x100000001)));
   EXPECT_FALSE(IsValueInRangeForNumericType<uint32_t>(
@@ skipping 97 matching lines @@
   EXPECT_EQ(static_cast<decltype(d)::type>(-.5), d);
   auto e = CheckMod(MakeCheckedNum(20), 3).ValueOrDie();
   EXPECT_EQ(static_cast<decltype(e)::type>(2), e);
   auto f = CheckLsh(1, MakeCheckedNum(2)).ValueOrDie();
   EXPECT_EQ(static_cast<decltype(f)::type>(4), f);
   auto g = CheckRsh(4, MakeCheckedNum(2)).ValueOrDie();
   EXPECT_EQ(static_cast<decltype(g)::type>(1), g);
   auto h = CheckRsh(CheckAdd(1, 1, 1, 1), CheckSub(4, 2)).ValueOrDie();
   EXPECT_EQ(static_cast<decltype(h)::type>(1), h);
 }