Rename CheckNum to MakeCheckedNum

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
 
 using std::numeric_limits;
 using base::CheckedNumeric;
 using base::IsValidForType;
 using base::ValueOrDieForType;
 using base::ValueOrDefaultForType;
-using base::CheckNum;
+using base::MakeCheckedNum;
 using base::CheckMax;
 using base::CheckMin;
 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;
@@ skipping 206 matching lines @@
   TEST_EXPECTED_VALUE(2, CheckedNumeric<Dst>(1) << 1);
   TEST_EXPECTED_FAILURE(CheckedNumeric<Dst>(1) >> (sizeof(Dst) * CHAR_BIT));
   TEST_EXPECTED_VALUE(0,
                       CheckedNumeric<Dst>(1) >> (sizeof(Dst) * CHAR_BIT - 1));
   TEST_EXPECTED_FAILURE(CheckedNumeric<Dst>(1) >> negative_one);
   TEST_EXPECTED_VALUE(1, CheckedNumeric<Dst>(1) & 1);
   TEST_EXPECTED_VALUE(0, CheckedNumeric<Dst>(1) & 0);
   TEST_EXPECTED_VALUE(0, CheckedNumeric<Dst>(0) & 1);
   TEST_EXPECTED_VALUE(0, CheckedNumeric<Dst>(1) & 0);
   TEST_EXPECTED_VALUE(std::numeric_limits<Dst>::max(),
-                      CheckNum(DstLimits::max()) & -1);
+                      MakeCheckedNum(DstLimits::max()) & -1);
   TEST_EXPECTED_VALUE(1, CheckedNumeric<Dst>(1) | 1);
   TEST_EXPECTED_VALUE(1, CheckedNumeric<Dst>(1) | 0);
   TEST_EXPECTED_VALUE(1, CheckedNumeric<Dst>(0) | 1);
   TEST_EXPECTED_VALUE(0, CheckedNumeric<Dst>(0) | 0);
   TEST_EXPECTED_VALUE(std::numeric_limits<Dst>::max(),
                       CheckedNumeric<Dst>(0) | static_cast<Dst>(-1));
   TEST_EXPECTED_VALUE(0, CheckedNumeric<Dst>(1) ^ 1);
   TEST_EXPECTED_VALUE(1, CheckedNumeric<Dst>(1) ^ 0);
   TEST_EXPECTED_VALUE(1, CheckedNumeric<Dst>(0) ^ 1);
   TEST_EXPECTED_VALUE(0, CheckedNumeric<Dst>(0) ^ 0);
@@ skipping 210 matching lines @@
                 "");
   static_assert(StrictNumeric<Src>(SrcLimits::max()) != DstLimits::lowest(),
                 "");
   static_assert(
       !(StrictNumeric<Src>(static_cast<Src>(1)) != static_cast<Dst>(1)), "");
   static_assert(
       !(StrictNumeric<Src>(static_cast<Src>(1)) == static_cast<Dst>(0)), "");
 
   // Due to differences in float handling between compilers, these aren't
   // compile-time constants everywhere. So, we use run-time tests.
-  EXPECT_EQ(SrcLimits::max(),
-            CheckNum(SrcLimits::max()).Max(DstLimits::lowest()).ValueOrDie());
-  EXPECT_EQ(DstLimits::max(),
-            CheckNum(SrcLimits::lowest()).Max(DstLimits::max()).ValueOrDie());
-  EXPECT_EQ(DstLimits::lowest(),
-            CheckNum(SrcLimits::max()).Min(DstLimits::lowest()).ValueOrDie());
-  EXPECT_EQ(SrcLimits::lowest(),
-            CheckNum(SrcLimits::lowest()).Min(DstLimits::max()).ValueOrDie());
-  EXPECT_EQ(SrcLimits::lowest(), CheckMin(MakeStrictNum(1), CheckNum(0),
+  EXPECT_EQ(
+      SrcLimits::max(),
+      MakeCheckedNum(SrcLimits::max()).Max(DstLimits::lowest()).ValueOrDie());
+  EXPECT_EQ(
+      DstLimits::max(),
+      MakeCheckedNum(SrcLimits::lowest()).Max(DstLimits::max()).ValueOrDie());
+  EXPECT_EQ(
+      DstLimits::lowest(),
+      MakeCheckedNum(SrcLimits::max()).Min(DstLimits::lowest()).ValueOrDie());
+  EXPECT_EQ(
+      SrcLimits::lowest(),
+      MakeCheckedNum(SrcLimits::lowest()).Min(DstLimits::max()).ValueOrDie());
+  EXPECT_EQ(SrcLimits::lowest(), CheckMin(MakeStrictNum(1), MakeCheckedNum(0),
                                           DstLimits::max(), SrcLimits::lowest())
                                      .ValueOrDie());
-  EXPECT_EQ(DstLimits::max(), CheckMax(MakeStrictNum(1), CheckNum(0),
+  EXPECT_EQ(DstLimits::max(), CheckMax(MakeStrictNum(1), MakeCheckedNum(0),
                                        DstLimits::max(), SrcLimits::lowest())
                                   .ValueOrDie());
 }
 
 template <typename Dst, typename Src>
 struct TestNumericConversion<Dst, Src, SIGN_PRESERVING_VALUE_PRESERVING> {
   static void Test(const char *dst, const char *src, int line) {
     typedef numeric_limits<Src> SrcLimits;
     typedef numeric_limits<Dst> DstLimits;
                    // Integral to floating.
@@ skipping 353 matching lines @@
   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());
+  auto int8_min = MakeCheckedNum(numeric_limits<int8_t>::min());
+  auto int8_max = MakeCheckedNum(numeric_limits<int8_t>::max());
+  auto double_max = MakeCheckedNum(numeric_limits<double>::max());
   static_assert(
       std::is_same<int16_t,
                    decltype(int8_min.ValueOrDie<int16_t>())::type>::value,
       "ValueOrDie returning incorrect type.");
   static_assert(
       std::is_same<int16_t,
                    decltype(int8_min.ValueOrDefault<int16_t>(0))::type>::value,
       "ValueOrDefault returning incorrect type.");
   EXPECT_FALSE(IsValidForType<uint8_t>(int8_min));
   EXPECT_TRUE(IsValidForType<uint8_t>(int8_max));
@@ skipping 124 matching lines @@
   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();
+  auto a = CheckAdd(1, 2UL, MakeCheckedNum(3LL), 4).ValueOrDie();
   EXPECT_EQ(static_cast<decltype(a)::type>(10), a);
-  auto b = CheckSub(CheckNum(20.0), 2UL, 4).ValueOrDie();
+  auto b = CheckSub(MakeCheckedNum(20.0), 2UL, 4).ValueOrDie();
   EXPECT_EQ(static_cast<decltype(b)::type>(14.0), b);
-  auto c = CheckMul(20.0, CheckNum(1), 5, 3UL).ValueOrDie();
+  auto c = CheckMul(20.0, MakeCheckedNum(1), 5, 3UL).ValueOrDie();
   EXPECT_EQ(static_cast<decltype(c)::type>(300.0), c);
-  auto d = CheckDiv(20.0, 2.0, CheckNum(5LL), -4).ValueOrDie();
+  auto d = CheckDiv(20.0, 2.0, MakeCheckedNum(5LL), -4).ValueOrDie();
   EXPECT_EQ(static_cast<decltype(d)::type>(-.5), d);
-  auto e = CheckMod(CheckNum(20), 3).ValueOrDie();
+  auto e = CheckMod(MakeCheckedNum(20), 3).ValueOrDie();
   EXPECT_EQ(static_cast<decltype(e)::type>(2), e);
-  auto f = CheckLsh(1, CheckNum(2)).ValueOrDie();
+  auto f = CheckLsh(1, MakeCheckedNum(2)).ValueOrDie();
   EXPECT_EQ(static_cast<decltype(f)::type>(4), f);
-  auto g = CheckRsh(4, CheckNum(2)).ValueOrDie();
+  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);
 }