Cleanup RangeCheck class and dependencies

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 27 matching lines @@
 using base::checked_cast;
 using base::IsValueInRangeForNumericType;
 using base::IsValueNegative;
 using base::SizeT;
 using base::StrictNumeric;
 using base::MakeStrictNum;
 using base::saturated_cast;
 using base::strict_cast;
 using base::internal::MaxExponent;
 using base::internal::IntegerBitsPlusSign;
-using base::internal::RANGE_VALID;
-using base::internal::RANGE_INVALID;
-using base::internal::RANGE_OVERFLOW;
-using base::internal::RANGE_UNDERFLOW;
+using base::internal::RangeCheck;
 
 // These tests deliberately cause arithmetic boundary errors. If the compiler is
 // aggressive enough, it can const detect these errors, so we disable warnings.
 #if defined(OS_WIN)
 #pragma warning(disable : 4756)  // Arithmetic overflow.
 #pragma warning(disable : 4293)  // Invalid shift.
 #endif
 
 // This is a helper function for finding the maximum value in Src that can be
 // wholy represented as the destination floating-point type.
@@ skipping 447 matching lines @@
   SIGN_PRESERVING_NARROW,
   SIGN_TO_UNSIGN_WIDEN_OR_EQUAL,
   SIGN_TO_UNSIGN_NARROW,
   UNSIGN_TO_SIGN_NARROW_OR_EQUAL,
 };
 
 // Template covering the different conversion tests.
 template <typename Dst, typename Src, NumericConversionType conversion>
 struct TestNumericConversion {};
 
+enum RangeConstraint {
+  RANGE_VALID = 0x0,      // Value can be represented by the destination type.
+  RANGE_UNDERFLOW = 0x1,  // Value would underflow.
+  RANGE_OVERFLOW = 0x2,   // Value would overflow.
+  RANGE_INVALID = RANGE_UNDERFLOW | RANGE_OVERFLOW  // Invalid (i.e. NaN).
+};
+
+// These are some wrappers to make the tests a bit cleaner.
+constexpr RangeConstraint RangeCheckToEnum(const RangeCheck constraint) {
+  return static_cast<RangeConstraint>(
+      static_cast<int>(constraint.IsOverflowFlagSet()) << 1 |
+      static_cast<int>(constraint.IsUnderflowFlagSet()));
+}
+
 // EXPECT_EQ wrappers providing specific detail on test failures.
-#define TEST_EXPECTED_RANGE(expected, actual)                                  \
-  EXPECT_EQ(expected, base::internal::DstRangeRelationToSrcRange<Dst>(actual)) \
-      << "Conversion test: " << src << " value " << actual << " to " << dst    \
+#define TEST_EXPECTED_RANGE(expected, actual)                               \
+  EXPECT_EQ(expected,                                                       \
+            RangeCheckToEnum(                                               \
+                base::internal::DstRangeRelationToSrcRange<Dst>(actual)))   \
+      << "Conversion test: " << src << " value " << actual << " to " << dst \
       << " on line " << line
 
 template <typename Dst, typename Src>
 void TestStrictComparison() {
   using DstLimits = numeric_limits<Dst>;
   using SrcLimits = numeric_limits<Src>;
   static_assert(StrictNumeric<Src>(SrcLimits::lowest()) < DstLimits::max(), "");
   static_assert(StrictNumeric<Src>(SrcLimits::lowest()) < SrcLimits::max(), "");
   static_assert(!(StrictNumeric<Src>(SrcLimits::lowest()) >= DstLimits::max()),
                 "");
@@ skipping 631 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);
 }