Add variadic helper functions for CheckedNumeric math operations

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/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
 
 using std::numeric_limits;
 using base::CheckedNumeric;
+using base::CheckNum;
+using base::CheckAdd;
+using base::CheckSub;
+using base::CheckMul;
+using base::CheckDiv;
+using base::CheckMod;
+using base::CheckLsh;
+using base::CheckRsh;
 using base::checked_cast;
 using base::IsValueInRangeForNumericType;
 using base::IsValueNegative;
 using base::SizeT;
 using base::StrictNumeric;
 using base::saturated_cast;
 using base::strict_cast;
 using base::internal::MaxExponent;
 using base::internal::RANGE_VALID;
 using base::internal::RANGE_INVALID;
@@ skipping 34 matching lines @@
 U GetNumericValueForTest(const CheckedNumeric<U>& src) {
   return src.state_.value();
 }
 }  // namespace internal.
 }  // namespace base.
 
 using base::internal::GetNumericValueForTest;
 
 // Helper macros to wrap displaying the conversion types and line numbers.
 #define TEST_EXPECTED_VALIDITY(expected, actual)                           \
-  EXPECT_EQ(expected, CheckedNumeric<Dst>(actual).IsValid())               \
+  EXPECT_EQ(expected, (actual).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),                                    \
-            CheckedNumeric<Dst>(actual).ValueOrDie())                      \
+  EXPECT_EQ(static_cast<Dst>(expected), (actual).Cast<Dst>().ValueOrDie()) \
       << "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 713 matching lines @@
 
   CheckedNumeric<int> too_large = std::numeric_limits<int>::max();
   EXPECT_TRUE(too_large.IsValid());
   too_large += d;
   EXPECT_FALSE(too_large.IsValid());
   too_large -= d;
   EXPECT_FALSE(too_large.IsValid());
   too_large /= d;
   EXPECT_FALSE(too_large.IsValid());
 }
+
+TEST(SafeNumerics, VariadicNumericOperations) {
+  auto a = CheckAdd(1, 2UL, CheckNum(3LL), 4).ValueOrDie();
+  EXPECT_EQ(static_cast<decltype(a)>(10), a);
+  auto b = CheckSub(CheckNum(20.0), 2UL, 4).ValueOrDie();
+  EXPECT_EQ(static_cast<decltype(b)>(14.0), b);
+  auto c = CheckMul(20.0, CheckNum(1), 5, 3UL).ValueOrDie();
+  EXPECT_EQ(static_cast<decltype(c)>(300.0), c);
+  auto d = CheckDiv(20.0, 2.0, CheckNum(5LL), -4).ValueOrDie();
+  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);

[Tom Sepez, 2016/11/23 21:37:25]

can we add a test that CheckAdd<int16_t>(0x10000, 0x10000).ValueOrDefault(42) ==
42.

+}