Support overriding the CheckedNumeric value extraction functions

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>
 
 #include "base/compiler_specific.h"
+#include "base/logging.h"
 #include "base/numerics/safe_conversions.h"
 #include "base/numerics/safe_math.h"
 #include "base/test/gtest_util.h"
 #include "build/build_config.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 #if defined(COMPILER_MSVC) && defined(ARCH_CPU_32_BITS)
 #include <mmintrin.h>
 #endif
 
@@ skipping 52 matching lines @@
 namespace internal {
 template <typename U>
 U GetNumericValueForTest(const CheckedNumeric<U>& src) {
   return src.state_.value();
 }
 }  // namespace internal.
 }  // namespace base.
 
 using base::internal::GetNumericValueForTest;
 
+// Logs the ValueOrDie() failure instead of crashing.
+struct LogOnFailure {
+  template <typename T>
+  static T HandleFailure() {
+    LOG(WARNING) << "ValueOrDie() failed unexpectedly.";
+    return T();
+  }
+};
+
 // Helper macros to wrap displaying the conversion types and line numbers.
 #define TEST_EXPECTED_VALIDITY(expected, actual)                           \
   EXPECT_EQ(expected, (actual).template Cast<Dst>().IsValid())             \
       << "Result test: Value " << GetNumericValueForTest(actual) << " as " \
       << dst << " on line " << line
 
 #define TEST_EXPECTED_SUCCESS(actual) TEST_EXPECTED_VALIDITY(true, actual)
 #define TEST_EXPECTED_FAILURE(actual) TEST_EXPECTED_VALIDITY(false, actual)
 
 #define TEST_EXPECTED_VALUE(expected, actual)                              \
   EXPECT_EQ(static_cast<Dst>(expected),                                    \
-            (actual).template Cast<Dst>().ValueOrDie())                    \
+            ((actual)                                                      \
+                 .template Cast<Dst>()                                     \
+                 .template ValueOrDie<Dst, LogOnFailure>()))               \
       << "Result test: Value " << GetNumericValueForTest(actual) << " as " \
       << dst << " on line " << line
 
 // Signed integer arithmetic.
 template <typename Dst>
 static void TestSpecializedArithmetic(
     const char* dst,
     int line,
     typename std::enable_if<numeric_limits<Dst>::is_integer &&
                                 numeric_limits<Dst>::is_signed,
@@ skipping 604 matching lines @@
   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>::min(), saturated_cast<int>(double_small_int));
   EXPECT_EQ(numeric_limits<int>::max(), saturated_cast<int>(double_large_int));
 
   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 = CheckNum(numeric_limits<int8_t>::min());
+  auto int8_max = CheckNum(numeric_limits<int8_t>::max());
+  auto double_max = CheckNum(numeric_limits<double>::max());
+  static_assert(
+      std::is_same<int16_t, decltype(int8_min.ValueOrDie<int16_t>())>::value,
+      "ValueOrDie returning incorrect type.");
+  static_assert(
+      std::is_same<int16_t,
+                   decltype(int8_min.ValueOrDefault<int16_t>(0))>::value,
+      "ValueOrDefault returning incorrect type.");
+  static_assert(
+      std::is_same<float, decltype(double_max.ValueFloating<float>())>::value,
+      "ValueFloating returning incorrect type.");
+  EXPECT_FALSE(int8_min.template IsValid<uint8_t>());
+  EXPECT_TRUE(int8_max.template IsValid<uint8_t>());
+  EXPECT_EQ(static_cast<int>(numeric_limits<int8_t>::min()),
+            int8_min.template ValueOrDie<int>());
+  EXPECT_TRUE(int8_max.template IsValid<uint32_t>());
+  EXPECT_EQ(static_cast<int>(numeric_limits<int8_t>::max()),
+            int8_max.template ValueOrDie<int>());
 }
 
 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)),
       "");
 }
@@ skipping 108 matching lines @@
   EXPECT_EQ(static_cast<decltype(d)>(-.5), d);
   auto e = CheckMod(CheckNum(20), 3).ValueOrDie();
   EXPECT_EQ(static_cast<decltype(e)>(2), e);
   auto f = CheckLsh(1, CheckNum(2)).ValueOrDie();
   EXPECT_EQ(static_cast<decltype(f)>(4), f);
   auto g = CheckRsh(4, CheckNum(2)).ValueOrDie();
   EXPECT_EQ(static_cast<decltype(g)>(1), g);
   auto h = CheckRsh(CheckAdd(1, 1, 1, 1), CheckSub(4, 2)).ValueOrDie();
   EXPECT_EQ(static_cast<decltype(h)>(1), h);
 }