base/safe_numerics_unittest.cc

   1 // Copyright 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include <stddef.h>
   6 #include <stdint.h>
   7
   8 #include <limits>
   9 #include <type_traits>
  10
  11 #include "base/compiler_specific.h"
  12 #include "build/build_config.h"
  13
  14 // WARNING: This block must come before the base/numerics headers are included.
  15 // These tests deliberately cause arithmetic boundary errors. If the compiler is
  16 // aggressive enough, it can const detect these errors, so we disable warnings.
  17 #if defined(OS_WIN)
  18 #pragma warning(disable : 4756)  // Arithmetic overflow.
  19 #pragma warning(disable : 4293)  // Invalid shift.
  20 #endif
  21
  22 // This may not need to come before the base/numerics headers, but let's keep
  23 // it close to the MSVC equivalent.
  24 #if defined(__clang__)
  25 #pragma clang diagnostic push
  26 #pragma clang diagnostic ignored "-Winteger-overflow"
  27 #endif
  28
  29 #include "base/logging.h"
  30 #include "base/numerics/safe_conversions.h"
  31 #include "base/numerics/safe_math.h"
  32 #include "base/test/gtest_util.h"
  33 #include "testing/gtest/include/gtest/gtest.h"
  34
  35 #if defined(COMPILER_MSVC) && defined(ARCH_CPU_32_BITS)
  36 #include <mmintrin.h>
  37 #endif
  38
  39 namespace base {
  40 namespace internal {
  41
  42 using std::numeric_limits;
  43
  44 // This is a helper function for finding the maximum value in Src that can be
  45 // wholy represented as the destination floating-point type.
  46 template <typename Dst, typename Src>
  47 Dst GetMaxConvertibleToFloat() {
  48   using DstLimits = numeric_limits<Dst>;
  49   using SrcLimits = numeric_limits<Src>;
  50   static_assert(SrcLimits::is_specialized, "Source must be numeric.");
  51   static_assert(DstLimits::is_specialized, "Destination must be numeric.");
  52   CHECK(DstLimits::is_iec559);
  53
  54   if (SrcLimits::digits <= DstLimits::digits &&
  55       MaxExponent<Src>::value <= MaxExponent<Dst>::value)
  56     return SrcLimits::max();
  57   Src max = SrcLimits::max() / 2 + (SrcLimits::is_integer ? 1 : 0);
  58   while (max != static_cast<Src>(static_cast<Dst>(max))) {
  59     max /= 2;
  60   }
  61   return static_cast<Dst>(max);
  62 }
  63
  64 // Test corner case promotions used
  65 static_assert(IsIntegerArithmeticSafe<int32_t, int8_t, int8_t>::value, "");
  66 static_assert(IsIntegerArithmeticSafe<int32_t, int16_t, int8_t>::value, "");
  67 static_assert(IsIntegerArithmeticSafe<int32_t, int8_t, int16_t>::value, "");
  68 static_assert(!IsIntegerArithmeticSafe<int32_t, int32_t, int8_t>::value, "");
  69 static_assert(BigEnoughPromotion<int16_t, int8_t>::is_contained, "");
  70 static_assert(BigEnoughPromotion<int32_t, uint32_t>::is_contained, "");
  71 static_assert(BigEnoughPromotion<intmax_t, int8_t>::is_contained, "");
  72 static_assert(!BigEnoughPromotion<uintmax_t, int8_t>::is_contained, "");
  73 static_assert(
  74     std::is_same<BigEnoughPromotion<int16_t, int8_t>::type, int16_t>::value,
  75     "");
  76 static_assert(
  77     std::is_same<BigEnoughPromotion<int32_t, uint32_t>::type, int64_t>::value,
  78     "");
  79 static_assert(
  80     std::is_same<BigEnoughPromotion<intmax_t, int8_t>::type, intmax_t>::value,
  81     "");
  82 static_assert(
  83     std::is_same<BigEnoughPromotion<uintmax_t, int8_t>::type, uintmax_t>::value,
  84     "");
  85 static_assert(BigEnoughPromotion<int16_t, int8_t>::is_contained, "");
  86 static_assert(BigEnoughPromotion<int32_t, uint32_t>::is_contained, "");
  87 static_assert(BigEnoughPromotion<intmax_t, int8_t>::is_contained, "");
  88 static_assert(!BigEnoughPromotion<uintmax_t, int8_t>::is_contained, "");
  89 static_assert(
  90     std::is_same<FastIntegerArithmeticPromotion<int16_t, int8_t>::type,
  91                  int32_t>::value,
  92     "");
  93 static_assert(
  94     std::is_same<FastIntegerArithmeticPromotion<int32_t, uint32_t>::type,
  95                  int64_t>::value,
  96     "");
  97 static_assert(
  98     std::is_same<FastIntegerArithmeticPromotion<intmax_t, int8_t>::type,
  99                  intmax_t>::value,
 100     "");
 101 static_assert(
 102     std::is_same<FastIntegerArithmeticPromotion<uintmax_t, int8_t>::type,
 103                  uintmax_t>::value,
 104     "");
 105 static_assert(FastIntegerArithmeticPromotion<int16_t, int8_t>::is_contained,
 106               "");
 107 static_assert(FastIntegerArithmeticPromotion<int32_t, uint32_t>::is_contained,
 108               "");
 109 static_assert(!FastIntegerArithmeticPromotion<intmax_t, int8_t>::is_contained,
 110               "");
 111 static_assert(!FastIntegerArithmeticPromotion<uintmax_t, int8_t>::is_contained,
 112               "");
 113
 114 template <typename U>
 115 U GetNumericValueForTest(const CheckedNumeric<U>& src) {
 116   return src.state_.value();
 117 }
 118
 119 template <typename U>
 120 U GetNumericValueForTest(const ClampedNumeric<U>& src) {
 121   return static_cast<U>(src);
 122 }
 123
 124 template <typename U>
 125 U GetNumericValueForTest(const U& src) {
 126   return src;
 127 }
 128
 129 // Logs the ValueOrDie() failure instead of crashing.
 130 struct LogOnFailure {
 131   template <typename T>
 132   static T HandleFailure() {
 133     LOG(WARNING) << "ValueOrDie() failed unexpectedly.";
 134     return T();
 135   }
 136 };
 137
 138 template <typename T>
 139 constexpr T GetValue(const T& src) {
 140   return src;
 141 }
 142
 143 template <typename T, typename U>
 144 constexpr T GetValueAsDest(const U& src) {
 145   return static_cast<T>(src);
 146 }
 147
 148 template <typename T>
 149 constexpr T GetValue(const CheckedNumeric<T>& src) {
 150   return src.template ValueOrDie<T, LogOnFailure>();
 151 }
 152
 153 template <typename T, typename U>
 154 constexpr T GetValueAsDest(const CheckedNumeric<U>& src) {
 155   return src.template ValueOrDie<T, LogOnFailure>();
 156 }
 157
 158 template <typename T>
 159 constexpr T GetValue(const ClampedNumeric<T>& src) {
 160   return static_cast<T>(src);
 161 }
 162
 163 template <typename T, typename U>
 164 constexpr T GetValueAsDest(const ClampedNumeric<U>& src) {
 165   return static_cast<T>(src);
 166 }
 167
 168 // Helper macros to wrap displaying the conversion types and line numbers.
 169 #define TEST_EXPECTED_VALIDITY(expected, actual)                           \
 170   EXPECT_EQ(expected, (actual).template Cast<Dst>().IsValid())             \
 171       << "Result test: Value " << GetNumericValueForTest(actual) << " as " \
 172       << dst << " on line " << line
 173
 174 #define TEST_EXPECTED_SUCCESS(actual) TEST_EXPECTED_VALIDITY(true, actual)
 175 #define TEST_EXPECTED_FAILURE(actual) TEST_EXPECTED_VALIDITY(false, actual)
 176
 177 // We have to handle promotions, so infer the underlying type below from actual.
 178 #define TEST_EXPECTED_VALUE(expected, actual)                               \
 179   EXPECT_EQ(GetValue(expected), GetValueAsDest<decltype(expected)>(actual)) \
 180       << "Result test: Value " << GetNumericValueForTest(actual) << " as "  \
 181       << dst << " on line " << line
 182
 183 // Test the simple pointer arithmetic overrides.
 184 template <typename Dst>
 185 void TestStrictPointerMath() {
 186   Dst dummy_value = 0;
 187   Dst* dummy_ptr = &dummy_value;
 188   static const Dst kDummyOffset = 2;  // Don't want to go too far.
 189   EXPECT_EQ(dummy_ptr + kDummyOffset,
 190             dummy_ptr + StrictNumeric<Dst>(kDummyOffset));
 191   EXPECT_EQ(dummy_ptr - kDummyOffset,
 192             dummy_ptr - StrictNumeric<Dst>(kDummyOffset));
 193   EXPECT_NE(dummy_ptr, dummy_ptr + StrictNumeric<Dst>(kDummyOffset));
 194   EXPECT_NE(dummy_ptr, dummy_ptr - StrictNumeric<Dst>(kDummyOffset));
 195   EXPECT_DEATH_IF_SUPPORTED(
 196       dummy_ptr + StrictNumeric<size_t>(std::numeric_limits<size_t>::max()),
 197       "");
 198 }
 199
 200 // Signed integer arithmetic.
 201 template <typename Dst>
 202 static void TestSpecializedArithmetic(
 203     const char* dst,
 204     int line,
 205     typename std::enable_if<numeric_limits<Dst>::is_integer &&
 206                                 numeric_limits<Dst>::is_signed,
 207                             int>::type = 0) {
 208   using DstLimits = SaturationDefaultLimits<Dst>;
 209   TEST_EXPECTED_FAILURE(-CheckedNumeric<Dst>(DstLimits::lowest()));
 210   TEST_EXPECTED_FAILURE(CheckedNumeric<Dst>(DstLimits::lowest()).Abs());
 211   TEST_EXPECTED_VALUE(1, CheckedNumeric<Dst>(-1).Abs());
 212   TEST_EXPECTED_VALUE(DstLimits::max(),
 213                       MakeCheckedNum(-DstLimits::max()).Abs());
 214
 215   TEST_EXPECTED_VALUE(DstLimits::Overflow(),
 216                       -ClampedNumeric<Dst>(DstLimits::lowest()));
 217   TEST_EXPECTED_VALUE(DstLimits::Overflow(),
 218                       ClampedNumeric<Dst>(DstLimits::lowest()).Abs());
 219   TEST_EXPECTED_VALUE(1, ClampedNumeric<Dst>(-1).Abs());
 220   TEST_EXPECTED_VALUE(DstLimits::max(),
 221                       MakeClampedNum(-DstLimits::max()).Abs());
 222
 223   TEST_EXPECTED_SUCCESS(CheckedNumeric<Dst>(DstLimits::max()) + -1);
 224   TEST_EXPECTED_FAILURE(CheckedNumeric<Dst>(DstLimits::lowest()) + -1);
 225   TEST_EXPECTED_FAILURE(CheckedNumeric<Dst>(DstLimits::lowest()) +
 226                         DstLimits::lowest());
 227
 228   TEST_EXPECTED_VALUE(DstLimits::max() - 1,
 229                       ClampedNumeric<Dst>(DstLimits::max()) + -1);
 230   TEST_EXPECTED_VALUE(DstLimits::Underflow(),
 231                       ClampedNumeric<Dst>(DstLimits::lowest()) + -1);
 232   TEST_EXPECTED_VALUE(
 233       DstLimits::Underflow(),
 234       ClampedNumeric<Dst>(DstLimits::lowest()) + DstLimits::lowest());
 235
 236   TEST_EXPECTED_FAILURE(CheckedNumeric<Dst>(DstLimits::lowest()) - 1);
 237   TEST_EXPECTED_SUCCESS(CheckedNumeric<Dst>(DstLimits::lowest()) - -1);
 238   TEST_EXPECTED_FAILURE(CheckedNumeric<Dst>(DstLimits::max()) -
 239                         DstLimits::lowest());
 240   TEST_EXPECTED_FAILURE(CheckedNumeric<Dst>(DstLimits::lowest()) -
 241                         DstLimits::max());
 242
 243   TEST_EXPECTED_VALUE(DstLimits::Underflow(),
 244                       ClampedNumeric<Dst>(DstLimits::lowest()) - 1);
 245   TEST_EXPECTED_VALUE(DstLimits::lowest() + 1,
 246                       ClampedNumeric<Dst>(DstLimits::lowest()) - -1);
 247   TEST_EXPECTED_VALUE(
 248       DstLimits::Overflow(),
 249       ClampedNumeric<Dst>(DstLimits::max()) - DstLimits::lowest());
 250   TEST_EXPECTED_VALUE(
 251       DstLimits::Underflow(),
 252       ClampedNumeric<Dst>(DstLimits::lowest()) - DstLimits::max());
 253
 254   TEST_EXPECTED_FAILURE(CheckedNumeric<Dst>(DstLimits::lowest()) * 2);
 255   TEST_EXPECTED_VALUE(DstLimits::Underflow(),
 256                       ClampedNumeric<Dst>(DstLimits::lowest()) * 2);
 257
 258   TEST_EXPECTED_FAILURE(CheckedNumeric<Dst>(DstLimits::lowest()) / -1);
 259   TEST_EXPECTED_VALUE(0, CheckedNumeric<Dst>(-1) / 2);
 260   TEST_EXPECTED_FAILURE(CheckedNumeric<Dst>(DstLimits::lowest()) * -1);
 261   TEST_EXPECTED_VALUE(DstLimits::max(),
 262                       CheckedNumeric<Dst>(DstLimits::lowest() + 1) * Dst(-1));
 263   TEST_EXPECTED_VALUE(DstLimits::max(),
 264                       CheckedNumeric<Dst>(-1) * Dst(DstLimits::lowest() + 1));
 265   TEST_EXPECTED_VALUE(DstLimits::lowest(),
 266                       CheckedNumeric<Dst>(DstLimits::lowest()) * Dst(1));
 267   TEST_EXPECTED_VALUE(DstLimits::lowest(),
 268                       CheckedNumeric<Dst>(1) * Dst(DstLimits::lowest()));
 269   TEST_EXPECTED_VALUE(
 270       typename std::make_unsigned<Dst>::type(0) - DstLimits::lowest(),
 271       MakeCheckedNum(DstLimits::lowest()).UnsignedAbs());
 272   TEST_EXPECTED_VALUE(DstLimits::max(),
 273                       MakeCheckedNum(DstLimits::max()).UnsignedAbs());
 274   TEST_EXPECTED_VALUE(0, CheckedNumeric<Dst>(0).UnsignedAbs());
 275   TEST_EXPECTED_VALUE(1, CheckedNumeric<Dst>(1).UnsignedAbs());
 276   TEST_EXPECTED_VALUE(1, CheckedNumeric<Dst>(-1).UnsignedAbs());
 277
 278   TEST_EXPECTED_VALUE(DstLimits::Overflow(),
 279                       ClampedNumeric<Dst>(DstLimits::lowest()) / -1);
 280   TEST_EXPECTED_VALUE(0, ClampedNumeric<Dst>(-1) / 2);
 281   TEST_EXPECTED_VALUE(DstLimits::Overflow(),
 282                       ClampedNumeric<Dst>(DstLimits::lowest()) * -1);
 283   TEST_EXPECTED_VALUE(DstLimits::max(),
 284                       ClampedNumeric<Dst>(DstLimits::lowest() + 1) * Dst(-1));
 285   TEST_EXPECTED_VALUE(DstLimits::max(),
 286                       ClampedNumeric<Dst>(-1) * Dst(DstLimits::lowest() + 1));
 287   TEST_EXPECTED_VALUE(DstLimits::lowest(),
 288                       ClampedNumeric<Dst>(DstLimits::lowest()) * Dst(1));
 289   TEST_EXPECTED_VALUE(DstLimits::lowest(),
 290                       ClampedNumeric<Dst>(1) * Dst(DstLimits::lowest()));
 291   TEST_EXPECTED_VALUE(
 292       typename std::make_unsigned<Dst>::type(0) - DstLimits::lowest(),
 293       MakeClampedNum(DstLimits::lowest()).UnsignedAbs());
 294   TEST_EXPECTED_VALUE(DstLimits::max(),
 295                       MakeClampedNum(DstLimits::max()).UnsignedAbs());
 296   TEST_EXPECTED_VALUE(0, ClampedNumeric<Dst>(0).UnsignedAbs());
 297   TEST_EXPECTED_VALUE(1, ClampedNumeric<Dst>(1).UnsignedAbs());
 298   TEST_EXPECTED_VALUE(1, ClampedNumeric<Dst>(-1).UnsignedAbs());
 299
 300   // Modulus is legal only for integers.
 301   TEST_EXPECTED_VALUE(0, CheckedNumeric<Dst>(0) % 2);
 302   TEST_EXPECTED_VALUE(0, CheckedNumeric<Dst>(0) % 1);
 303   TEST_EXPECTED_VALUE(0, CheckedNumeric<Dst>(0) % -1);
 304   TEST_EXPECTED_VALUE(0, CheckedNumeric<Dst>(0) % -2);
 305   TEST_EXPECTED_VALUE(1, CheckedNumeric<Dst>(1) % 2);
 306   TEST_EXPECTED_VALUE(0, CheckedNumeric<Dst>(1) % 1);
 307   TEST_EXPECTED_VALUE(0, CheckedNumeric<Dst>(1) % -1);
 308   TEST_EXPECTED_VALUE(1, CheckedNumeric<Dst>(1) % -2);
 309   TEST_EXPECTED_VALUE(-1, CheckedNumeric<Dst>(-1) % 2);
 310   TEST_EXPECTED_VALUE(0, CheckedNumeric<Dst>(-1) % 1);
 311   TEST_EXPECTED_VALUE(0, CheckedNumeric<Dst>(-1) % -1);
 312   TEST_EXPECTED_VALUE(-1, CheckedNumeric<Dst>(-1) % -2);
 313   TEST_EXPECTED_VALUE(0, CheckedNumeric<Dst>(DstLimits::lowest()) % 2);
 314   TEST_EXPECTED_VALUE(0, CheckedNumeric<Dst>(DstLimits::lowest()) % 1);
 315   TEST_EXPECTED_VALUE(0, CheckedNumeric<Dst>(DstLimits::lowest()) % -1);
 316   TEST_EXPECTED_VALUE(0, CheckedNumeric<Dst>(DstLimits::lowest()) % -2);
 317   TEST_EXPECTED_VALUE(1, CheckedNumeric<Dst>(DstLimits::max()) % 2);
 318   TEST_EXPECTED_VALUE(0, CheckedNumeric<Dst>(DstLimits::max()) % 1);
 319   TEST_EXPECTED_VALUE(0, CheckedNumeric<Dst>(DstLimits::max()) % -1);
 320   TEST_EXPECTED_VALUE(1, CheckedNumeric<Dst>(DstLimits::max()) % -2);
 321   // Test all the different modulus combinations.
 322   TEST_EXPECTED_VALUE(0, CheckedNumeric<Dst>(1) % CheckedNumeric<Dst>(1));
 323   TEST_EXPECTED_VALUE(0, 1 % CheckedNumeric<Dst>(1));
 324   TEST_EXPECTED_VALUE(0, CheckedNumeric<Dst>(1) % 1);
 325   CheckedNumeric<Dst> checked_dst = 1;
 326   TEST_EXPECTED_VALUE(0, checked_dst %= 1);
 327   // Test that div by 0 is avoided but returns invalid result.
 328   TEST_EXPECTED_FAILURE(CheckedNumeric<Dst>(1) % 0);
 329   // Test bit shifts.
 330   volatile Dst negative_one = -1;
 331   TEST_EXPECTED_FAILURE(CheckedNumeric<Dst>(1) << negative_one);
 332   TEST_EXPECTED_FAILURE(CheckedNumeric<Dst>(1)
 333                         << (IntegerBitsPlusSign<Dst>::value - 1));
 334   TEST_EXPECTED_FAILURE(CheckedNumeric<Dst>(0)
 335                         << IntegerBitsPlusSign<Dst>::value);
 336   TEST_EXPECTED_FAILURE(CheckedNumeric<Dst>(DstLimits::max()) << 1);
 337   TEST_EXPECTED_VALUE(
 338       static_cast<Dst>(1) << (IntegerBitsPlusSign<Dst>::value - 2),
 339       CheckedNumeric<Dst>(1) << (IntegerBitsPlusSign<Dst>::value - 2));
 340   TEST_EXPECTED_VALUE(0, CheckedNumeric<Dst>(0)
 341                              << (IntegerBitsPlusSign<Dst>::value - 1));
 342   TEST_EXPECTED_VALUE(1, CheckedNumeric<Dst>(1) << 0);
 343   TEST_EXPECTED_VALUE(2, CheckedNumeric<Dst>(1) << 1);
 344   TEST_EXPECTED_FAILURE(CheckedNumeric<Dst>(1) >>
 345                         IntegerBitsPlusSign<Dst>::value);
 346   TEST_EXPECTED_VALUE(
 347       0, CheckedNumeric<Dst>(1) >> (IntegerBitsPlusSign<Dst>::value - 1));
 348   TEST_EXPECTED_FAILURE(CheckedNumeric<Dst>(1) >> negative_one);
 349
 350   // Modulus is legal only for integers.
 351   TEST_EXPECTED_VALUE(0, ClampedNumeric<Dst>(0) % 2);
 352   TEST_EXPECTED_VALUE(0, ClampedNumeric<Dst>(0) % 1);
 353   TEST_EXPECTED_VALUE(0, ClampedNumeric<Dst>(0) % -1);
 354   TEST_EXPECTED_VALUE(0, ClampedNumeric<Dst>(0) % -2);
 355   TEST_EXPECTED_VALUE(1, ClampedNumeric<Dst>(1) % 2);
 356   TEST_EXPECTED_VALUE(0, ClampedNumeric<Dst>(1) % 1);
 357   TEST_EXPECTED_VALUE(0, ClampedNumeric<Dst>(1) % -1);
 358   TEST_EXPECTED_VALUE(1, ClampedNumeric<Dst>(1) % -2);
 359   TEST_EXPECTED_VALUE(-1, ClampedNumeric<Dst>(-1) % 2);
 360   TEST_EXPECTED_VALUE(0, ClampedNumeric<Dst>(-1) % 1);
 361   TEST_EXPECTED_VALUE(0, ClampedNumeric<Dst>(-1) % -1);
 362   TEST_EXPECTED_VALUE(-1, ClampedNumeric<Dst>(-1) % -2);
 363   TEST_EXPECTED_VALUE(0, ClampedNumeric<Dst>(DstLimits::lowest()) % 2);
 364   TEST_EXPECTED_VALUE(0, ClampedNumeric<Dst>(DstLimits::lowest()) % 1);
 365   TEST_EXPECTED_VALUE(0, ClampedNumeric<Dst>(DstLimits::lowest()) % -1);
 366   TEST_EXPECTED_VALUE(0, ClampedNumeric<Dst>(DstLimits::lowest()) % -2);
 367   TEST_EXPECTED_VALUE(1, ClampedNumeric<Dst>(DstLimits::max()) % 2);
 368   TEST_EXPECTED_VALUE(0, ClampedNumeric<Dst>(DstLimits::max()) % 1);
 369   TEST_EXPECTED_VALUE(0, ClampedNumeric<Dst>(DstLimits::max()) % -1);
 370   TEST_EXPECTED_VALUE(1, ClampedNumeric<Dst>(DstLimits::max()) % -2);
 371   // Test all the different modulus combinations.
 372   TEST_EXPECTED_VALUE(0, ClampedNumeric<Dst>(1) % ClampedNumeric<Dst>(1));
 373   TEST_EXPECTED_VALUE(0, 1 % ClampedNumeric<Dst>(1));
 374   TEST_EXPECTED_VALUE(0, ClampedNumeric<Dst>(1) % 1);
 375   ClampedNumeric<Dst> clamped_dst = 1;
 376   TEST_EXPECTED_VALUE(0, clamped_dst %= 1);
 377   TEST_EXPECTED_VALUE(Dst(1), ClampedNumeric<Dst>(1) % 0);
 378   // Test bit shifts.
 379   TEST_EXPECTED_VALUE(DstLimits::Overflow(),
 380                       ClampedNumeric<Dst>(1)
 381                           << (IntegerBitsPlusSign<Dst>::value - 1U));
 382   TEST_EXPECTED_VALUE(Dst(0), ClampedNumeric<Dst>(0)
 383                                   << (IntegerBitsPlusSign<Dst>::value + 0U));
 384   TEST_EXPECTED_VALUE(DstLimits::Overflow(),
 385                       ClampedNumeric<Dst>(DstLimits::max()) << 1U);
 386   TEST_EXPECTED_VALUE(
 387       static_cast<Dst>(1) << (IntegerBitsPlusSign<Dst>::value - 2U),
 388       ClampedNumeric<Dst>(1) << (IntegerBitsPlusSign<Dst>::value - 2U));
 389   TEST_EXPECTED_VALUE(0, ClampedNumeric<Dst>(0)
 390                              << (IntegerBitsPlusSign<Dst>::value - 1U));
 391   TEST_EXPECTED_VALUE(1, ClampedNumeric<Dst>(1) << 0U);
 392   TEST_EXPECTED_VALUE(2, ClampedNumeric<Dst>(1) << 1U);
 393   TEST_EXPECTED_VALUE(
 394       0, ClampedNumeric<Dst>(1) >> (IntegerBitsPlusSign<Dst>::value + 0U));
 395   TEST_EXPECTED_VALUE(
 396       0, ClampedNumeric<Dst>(1) >> (IntegerBitsPlusSign<Dst>::value - 1U));
 397   TEST_EXPECTED_VALUE(
 398       -1, ClampedNumeric<Dst>(-1) >> (IntegerBitsPlusSign<Dst>::value - 1U));
 399   TEST_EXPECTED_VALUE(-1, ClampedNumeric<Dst>(DstLimits::lowest()) >>
 400                               (IntegerBitsPlusSign<Dst>::value - 0U));
 401
 402   TestStrictPointerMath<Dst>();
 403 }
 404
 405 // Unsigned integer arithmetic.
 406 template <typename Dst>
 407 static void TestSpecializedArithmetic(
 408     const char* dst,
 409     int line,
 410     typename std::enable_if<numeric_limits<Dst>::is_integer &&
 411                                 !numeric_limits<Dst>::is_signed,
 412                             int>::type = 0) {
 413   using DstLimits = SaturationDefaultLimits<Dst>;
 414   TEST_EXPECTED_SUCCESS(-CheckedNumeric<Dst>(DstLimits::lowest()));
 415   TEST_EXPECTED_SUCCESS(CheckedNumeric<Dst>(DstLimits::lowest()).Abs());
 416   TEST_EXPECTED_FAILURE(CheckedNumeric<Dst>(DstLimits::lowest()) + -1);
 417   TEST_EXPECTED_FAILURE(CheckedNumeric<Dst>(DstLimits::lowest()) - 1);
 418   TEST_EXPECTED_VALUE(0, CheckedNumeric<Dst>(DstLimits::lowest()) * 2);
 419   TEST_EXPECTED_VALUE(0, CheckedNumeric<Dst>(1) / 2);
 420   TEST_EXPECTED_SUCCESS(CheckedNumeric<Dst>(DstLimits::lowest()).UnsignedAbs());
 421   TEST_EXPECTED_SUCCESS(
 422       CheckedNumeric<typename std::make_signed<Dst>::type>(
 423           std::numeric_limits<typename std::make_signed<Dst>::type>::lowest())
 424           .UnsignedAbs());
 425   TEST_EXPECTED_VALUE(DstLimits::lowest(),
 426                       MakeCheckedNum(DstLimits::lowest()).UnsignedAbs());
 427   TEST_EXPECTED_VALUE(DstLimits::max(),
 428                       MakeCheckedNum(DstLimits::max()).UnsignedAbs());
 429   TEST_EXPECTED_VALUE(0, CheckedNumeric<Dst>(0).UnsignedAbs());
 430   TEST_EXPECTED_VALUE(1, CheckedNumeric<Dst>(1).UnsignedAbs());
 431
 432   TEST_EXPECTED_VALUE(0, -ClampedNumeric<Dst>(DstLimits::lowest()));
 433   TEST_EXPECTED_VALUE(0, ClampedNumeric<Dst>(DstLimits::lowest()).Abs());
 434   TEST_EXPECTED_VALUE(DstLimits::Underflow(),
 435                       ClampedNumeric<Dst>(DstLimits::lowest()) + -1);
 436   TEST_EXPECTED_VALUE(DstLimits::Underflow(),
 437                       ClampedNumeric<Dst>(DstLimits::lowest()) - 1);
 438   TEST_EXPECTED_VALUE(0, ClampedNumeric<Dst>(DstLimits::lowest()) * 2);
 439   TEST_EXPECTED_VALUE(0, ClampedNumeric<Dst>(1) / 2);
 440   TEST_EXPECTED_VALUE(0,
 441                       ClampedNumeric<Dst>(DstLimits::lowest()).UnsignedAbs());
 442   TEST_EXPECTED_VALUE(
 443       as_unsigned(
 444           std::numeric_limits<typename std::make_signed<Dst>::type>::lowest()),
 445       ClampedNumeric<typename std::make_signed<Dst>::type>(
 446           std::numeric_limits<typename std::make_signed<Dst>::type>::lowest())
 447           .UnsignedAbs());
 448   TEST_EXPECTED_VALUE(DstLimits::lowest(),
 449                       MakeClampedNum(DstLimits::lowest()).UnsignedAbs());
 450   TEST_EXPECTED_VALUE(DstLimits::max(),
 451                       MakeClampedNum(DstLimits::max()).UnsignedAbs());
 452   TEST_EXPECTED_VALUE(0, ClampedNumeric<Dst>(0).UnsignedAbs());
 453   TEST_EXPECTED_VALUE(1, ClampedNumeric<Dst>(1).UnsignedAbs());
 454
 455   // Modulus is legal only for integers.
 456   TEST_EXPECTED_VALUE(0, CheckedNumeric<Dst>() % 1);
 457   TEST_EXPECTED_VALUE(0, CheckedNumeric<Dst>(1) % 1);
 458   TEST_EXPECTED_VALUE(1, CheckedNumeric<Dst>(1) % 2);
 459   TEST_EXPECTED_VALUE(0, CheckedNumeric<Dst>(DstLimits::lowest()) % 2);
 460   TEST_EXPECTED_VALUE(1, CheckedNumeric<Dst>(DstLimits::max()) % 2);
 461   // Test all the different modulus combinations.
 462   TEST_EXPECTED_VALUE(0, CheckedNumeric<Dst>(1) % CheckedNumeric<Dst>(1));
 463   TEST_EXPECTED_VALUE(0, 1 % CheckedNumeric<Dst>(1));
 464   TEST_EXPECTED_VALUE(0, CheckedNumeric<Dst>(1) % 1);
 465   CheckedNumeric<Dst> checked_dst = 1;
 466   TEST_EXPECTED_VALUE(0, checked_dst %= 1);
 467   // Test that div by 0 is avoided but returns invalid result.
 468   TEST_EXPECTED_FAILURE(CheckedNumeric<Dst>(1) % 0);
 469   TEST_EXPECTED_FAILURE(CheckedNumeric<Dst>(1)
 470                         << IntegerBitsPlusSign<Dst>::value);
 471   // Test bit shifts.
 472   volatile int negative_one = -1;
 473   TEST_EXPECTED_FAILURE(CheckedNumeric<Dst>(1) << negative_one);
 474   TEST_EXPECTED_FAILURE(CheckedNumeric<Dst>(1)
 475                         << IntegerBitsPlusSign<Dst>::value);
 476   TEST_EXPECTED_FAILURE(CheckedNumeric<Dst>(0)
 477                         << IntegerBitsPlusSign<Dst>::value);
 478   TEST_EXPECTED_FAILURE(CheckedNumeric<Dst>(DstLimits::max()) << 1);
 479   TEST_EXPECTED_VALUE(
 480       static_cast<Dst>(1) << (IntegerBitsPlusSign<Dst>::value - 1),
 481       CheckedNumeric<Dst>(1) << (IntegerBitsPlusSign<Dst>::value - 1));
 482   TEST_EXPECTED_VALUE(1, CheckedNumeric<Dst>(1) << 0);
 483   TEST_EXPECTED_VALUE(2, CheckedNumeric<Dst>(1) << 1);
 484   TEST_EXPECTED_FAILURE(CheckedNumeric<Dst>(1) >>
 485                         IntegerBitsPlusSign<Dst>::value);
 486   TEST_EXPECTED_VALUE(
 487       0, CheckedNumeric<Dst>(1) >> (IntegerBitsPlusSign<Dst>::value - 1));
 488   TEST_EXPECTED_FAILURE(CheckedNumeric<Dst>(1) >> negative_one);
 489   TEST_EXPECTED_VALUE(1, CheckedNumeric<Dst>(1) & 1);
 490   TEST_EXPECTED_VALUE(0, CheckedNumeric<Dst>(1) & 0);
 491   TEST_EXPECTED_VALUE(0, CheckedNumeric<Dst>(0) & 1);
 492   TEST_EXPECTED_VALUE(0, CheckedNumeric<Dst>(1) & 0);
 493   TEST_EXPECTED_VALUE(std::numeric_limits<Dst>::max(),
 494                       MakeCheckedNum(DstLimits::max()) & -1);
 495   TEST_EXPECTED_VALUE(1, CheckedNumeric<Dst>(1) | 1);
 496   TEST_EXPECTED_VALUE(1, CheckedNumeric<Dst>(1) | 0);
 497   TEST_EXPECTED_VALUE(1, CheckedNumeric<Dst>(0) | 1);
 498   TEST_EXPECTED_VALUE(0, CheckedNumeric<Dst>(0) | 0);
 499   TEST_EXPECTED_VALUE(std::numeric_limits<Dst>::max(),
 500                       CheckedNumeric<Dst>(0) | static_cast<Dst>(-1));
 501   TEST_EXPECTED_VALUE(0, CheckedNumeric<Dst>(1) ^ 1);
 502   TEST_EXPECTED_VALUE(1, CheckedNumeric<Dst>(1) ^ 0);
 503   TEST_EXPECTED_VALUE(1, CheckedNumeric<Dst>(0) ^ 1);
 504   TEST_EXPECTED_VALUE(0, CheckedNumeric<Dst>(0) ^ 0);
 505   TEST_EXPECTED_VALUE(std::numeric_limits<Dst>::max(),
 506                       CheckedNumeric<Dst>(0) ^ static_cast<Dst>(-1));
 507   TEST_EXPECTED_VALUE(DstLimits::max(), ~CheckedNumeric<Dst>(0));
 508
 509   // Modulus is legal only for integers.
 510   TEST_EXPECTED_VALUE(0, ClampedNumeric<Dst>() % 1);
 511   TEST_EXPECTED_VALUE(0, ClampedNumeric<Dst>(1) % 1);
 512   TEST_EXPECTED_VALUE(1, ClampedNumeric<Dst>(1) % 2);
 513   TEST_EXPECTED_VALUE(0, ClampedNumeric<Dst>(DstLimits::lowest()) % 2);
 514   TEST_EXPECTED_VALUE(1, ClampedNumeric<Dst>(DstLimits::max()) % 2);
 515   // Test all the different modulus combinations.
 516   TEST_EXPECTED_VALUE(0, ClampedNumeric<Dst>(1) % ClampedNumeric<Dst>(1));
 517   TEST_EXPECTED_VALUE(0, 1 % ClampedNumeric<Dst>(1));
 518   TEST_EXPECTED_VALUE(0, ClampedNumeric<Dst>(1) % 1);
 519   ClampedNumeric<Dst> clamped_dst = 1;
 520   TEST_EXPECTED_VALUE(0, clamped_dst %= 1);
 521   // Test that div by 0 is avoided but returns invalid result.
 522   TEST_EXPECTED_VALUE(Dst(1), ClampedNumeric<Dst>(1) % 0);
 523   // Test bit shifts.
 524   TEST_EXPECTED_VALUE(DstLimits::Overflow(),
 525                       ClampedNumeric<Dst>(1)
 526                           << as_unsigned(IntegerBitsPlusSign<Dst>::value));
 527   TEST_EXPECTED_VALUE(Dst(0), ClampedNumeric<Dst>(0) << as_unsigned(
 528                                   IntegerBitsPlusSign<Dst>::value));
 529   TEST_EXPECTED_VALUE(DstLimits::Overflow(),
 530                       ClampedNumeric<Dst>(DstLimits::max()) << 1U);
 531   TEST_EXPECTED_VALUE(
 532       static_cast<Dst>(1) << (IntegerBitsPlusSign<Dst>::value - 1U),
 533       ClampedNumeric<Dst>(1) << (IntegerBitsPlusSign<Dst>::value - 1U));
 534   TEST_EXPECTED_VALUE(1, ClampedNumeric<Dst>(1) << 0U);
 535   TEST_EXPECTED_VALUE(2, ClampedNumeric<Dst>(1) << 1U);
 536   TEST_EXPECTED_VALUE(0, ClampedNumeric<Dst>(1) >>
 537                              as_unsigned(IntegerBitsPlusSign<Dst>::value));
 538   TEST_EXPECTED_VALUE(
 539       0, ClampedNumeric<Dst>(1) >> (IntegerBitsPlusSign<Dst>::value - 1U));
 540   TEST_EXPECTED_VALUE(1, ClampedNumeric<Dst>(1) & 1);
 541   TEST_EXPECTED_VALUE(0, ClampedNumeric<Dst>(1) & 0);
 542   TEST_EXPECTED_VALUE(0, ClampedNumeric<Dst>(0) & 1);
 543   TEST_EXPECTED_VALUE(0, ClampedNumeric<Dst>(1) & 0);
 544   TEST_EXPECTED_VALUE(std::numeric_limits<Dst>::max(),
 545                       MakeClampedNum(DstLimits::max()) & -1);
 546   TEST_EXPECTED_VALUE(1, ClampedNumeric<Dst>(1) | 1);
 547   TEST_EXPECTED_VALUE(1, ClampedNumeric<Dst>(1) | 0);
 548   TEST_EXPECTED_VALUE(1, ClampedNumeric<Dst>(0) | 1);
 549   TEST_EXPECTED_VALUE(0, ClampedNumeric<Dst>(0) | 0);
 550   TEST_EXPECTED_VALUE(std::numeric_limits<Dst>::max(),
 551                       ClampedNumeric<Dst>(0) | static_cast<Dst>(-1));
 552   TEST_EXPECTED_VALUE(0, ClampedNumeric<Dst>(1) ^ 1);
 553   TEST_EXPECTED_VALUE(1, ClampedNumeric<Dst>(1) ^ 0);
 554   TEST_EXPECTED_VALUE(1, ClampedNumeric<Dst>(0) ^ 1);
 555   TEST_EXPECTED_VALUE(0, ClampedNumeric<Dst>(0) ^ 0);
 556   TEST_EXPECTED_VALUE(std::numeric_limits<Dst>::max(),
 557                       ClampedNumeric<Dst>(0) ^ static_cast<Dst>(-1));
 558   TEST_EXPECTED_VALUE(DstLimits::max(), ~ClampedNumeric<Dst>(0));
 559
 560   TestStrictPointerMath<Dst>();
 561 }
 562
 563 // Floating point arithmetic.
 564 template <typename Dst>
 565 void TestSpecializedArithmetic(
 566     const char* dst,
 567     int line,
 568     typename std::enable_if<numeric_limits<Dst>::is_iec559, int>::type = 0) {
 569   using DstLimits = SaturationDefaultLimits<Dst>;
 570   TEST_EXPECTED_SUCCESS(-CheckedNumeric<Dst>(DstLimits::lowest()));
 571
 572   TEST_EXPECTED_SUCCESS(CheckedNumeric<Dst>(DstLimits::lowest()).Abs());
 573   TEST_EXPECTED_VALUE(1, CheckedNumeric<Dst>(-1).Abs());
 574
 575   TEST_EXPECTED_SUCCESS(CheckedNumeric<Dst>(DstLimits::lowest()) + -1);
 576   TEST_EXPECTED_SUCCESS(CheckedNumeric<Dst>(DstLimits::max()) + 1);
 577   TEST_EXPECTED_FAILURE(CheckedNumeric<Dst>(DstLimits::lowest()) +
 578                         DstLimits::lowest());
 579
 580   TEST_EXPECTED_FAILURE(CheckedNumeric<Dst>(DstLimits::max()) -
 581                         DstLimits::lowest());
 582   TEST_EXPECTED_FAILURE(CheckedNumeric<Dst>(DstLimits::lowest()) -
 583                         DstLimits::max());
 584
 585   TEST_EXPECTED_FAILURE(CheckedNumeric<Dst>(DstLimits::lowest()) * 2);
 586
 587   TEST_EXPECTED_VALUE(-0.5, CheckedNumeric<Dst>(-1.0) / 2);
 588
 589   TEST_EXPECTED_VALUE(DstLimits::max(),
 590                       -ClampedNumeric<Dst>(DstLimits::lowest()));
 591
 592   TEST_EXPECTED_VALUE(DstLimits::max(),
 593                       ClampedNumeric<Dst>(DstLimits::lowest()).Abs());
 594   TEST_EXPECTED_VALUE(1, ClampedNumeric<Dst>(-1).Abs());
 595
 596   TEST_EXPECTED_VALUE(DstLimits::lowest() - 1,
 597                       ClampedNumeric<Dst>(DstLimits::lowest()) + -1);
 598   TEST_EXPECTED_VALUE(DstLimits::max() + 1,
 599                       ClampedNumeric<Dst>(DstLimits::max()) + 1);
 600   TEST_EXPECTED_VALUE(
 601       DstLimits::Underflow(),
 602       ClampedNumeric<Dst>(DstLimits::lowest()) + DstLimits::lowest());
 603
 604   TEST_EXPECTED_VALUE(
 605       DstLimits::Overflow(),
 606       ClampedNumeric<Dst>(DstLimits::max()) - DstLimits::lowest());
 607   TEST_EXPECTED_VALUE(
 608       DstLimits::Underflow(),
 609       ClampedNumeric<Dst>(DstLimits::lowest()) - DstLimits::max());
 610
 611   TEST_EXPECTED_VALUE(DstLimits::Underflow(),
 612                       ClampedNumeric<Dst>(DstLimits::lowest()) * 2);
 613
 614   TEST_EXPECTED_VALUE(-0.5, ClampedNumeric<Dst>(-1.0) / 2);
 615 }
 616
 617 // Generic arithmetic tests.
 618 template <typename Dst>
 619 static void TestArithmetic(const char* dst, int line) {
 620   using DstLimits = SaturationDefaultLimits<Dst>;
 621
 622   EXPECT_EQ(true, CheckedNumeric<Dst>().IsValid());
 623   EXPECT_EQ(false, CheckedNumeric<Dst>(CheckedNumeric<Dst>(DstLimits::max()) *
 624                                        DstLimits::max())
 625                        .IsValid());
 626   EXPECT_EQ(static_cast<Dst>(0), CheckedNumeric<Dst>().ValueOrDie());
 627   EXPECT_EQ(static_cast<Dst>(0), CheckedNumeric<Dst>().ValueOrDefault(1));
 628   EXPECT_EQ(static_cast<Dst>(1),
 629             CheckedNumeric<Dst>(CheckedNumeric<Dst>(DstLimits::max()) *
 630                                 DstLimits::max())
 631                 .ValueOrDefault(1));
 632
 633   // Test the operator combinations.
 634   TEST_EXPECTED_VALUE(2, CheckedNumeric<Dst>(1) + CheckedNumeric<Dst>(1));
 635   TEST_EXPECTED_VALUE(0, CheckedNumeric<Dst>(1) - CheckedNumeric<Dst>(1));
 636   TEST_EXPECTED_VALUE(1, CheckedNumeric<Dst>(1) * CheckedNumeric<Dst>(1));
 637   TEST_EXPECTED_VALUE(1, CheckedNumeric<Dst>(1) / CheckedNumeric<Dst>(1));
 638   TEST_EXPECTED_VALUE(2, 1 + CheckedNumeric<Dst>(1));
 639   TEST_EXPECTED_VALUE(0, 1 - CheckedNumeric<Dst>(1));
 640   TEST_EXPECTED_VALUE(1, 1 * CheckedNumeric<Dst>(1));
 641   TEST_EXPECTED_VALUE(1, 1 / CheckedNumeric<Dst>(1));
 642   TEST_EXPECTED_VALUE(2, CheckedNumeric<Dst>(1) + 1);
 643   TEST_EXPECTED_VALUE(0, CheckedNumeric<Dst>(1) - 1);
 644   TEST_EXPECTED_VALUE(1, CheckedNumeric<Dst>(1) * 1);
 645   TEST_EXPECTED_VALUE(1, CheckedNumeric<Dst>(1) / 1);
 646   CheckedNumeric<Dst> checked_dst = 1;
 647   TEST_EXPECTED_VALUE(2, checked_dst += 1);
 648   checked_dst = 1;
 649   TEST_EXPECTED_VALUE(0, checked_dst -= 1);
 650   checked_dst = 1;
 651   TEST_EXPECTED_VALUE(1, checked_dst *= 1);
 652   checked_dst = 1;
 653   TEST_EXPECTED_VALUE(1, checked_dst /= 1);
 654
 655   TEST_EXPECTED_VALUE(2, ClampedNumeric<Dst>(1) + ClampedNumeric<Dst>(1));
 656   TEST_EXPECTED_VALUE(0, ClampedNumeric<Dst>(1) - ClampedNumeric<Dst>(1));
 657   TEST_EXPECTED_VALUE(1, ClampedNumeric<Dst>(1) * ClampedNumeric<Dst>(1));
 658   TEST_EXPECTED_VALUE(1, ClampedNumeric<Dst>(1) / ClampedNumeric<Dst>(1));
 659   TEST_EXPECTED_VALUE(2, 1 + ClampedNumeric<Dst>(1));
 660   TEST_EXPECTED_VALUE(0, 1 - ClampedNumeric<Dst>(1));
 661   TEST_EXPECTED_VALUE(1, 1 * ClampedNumeric<Dst>(1));
 662   TEST_EXPECTED_VALUE(1, 1 / ClampedNumeric<Dst>(1));
 663   TEST_EXPECTED_VALUE(2, ClampedNumeric<Dst>(1) + 1);
 664   TEST_EXPECTED_VALUE(0, ClampedNumeric<Dst>(1) - 1);
 665   TEST_EXPECTED_VALUE(1, ClampedNumeric<Dst>(1) * 1);
 666   TEST_EXPECTED_VALUE(1, ClampedNumeric<Dst>(1) / 1);
 667   ClampedNumeric<Dst> clamped_dst = 1;
 668   TEST_EXPECTED_VALUE(2, clamped_dst += 1);
 669   clamped_dst = 1;
 670   TEST_EXPECTED_VALUE(0, clamped_dst -= 1);
 671   clamped_dst = 1;
 672   TEST_EXPECTED_VALUE(1, clamped_dst *= 1);
 673   clamped_dst = 1;
 674   TEST_EXPECTED_VALUE(1, clamped_dst /= 1);
 675
 676   // Generic negation.
 677   if (DstLimits::is_signed) {
 678     TEST_EXPECTED_VALUE(0, -CheckedNumeric<Dst>());
 679     TEST_EXPECTED_VALUE(-1, -CheckedNumeric<Dst>(1));
 680     TEST_EXPECTED_VALUE(1, -CheckedNumeric<Dst>(-1));
 681     TEST_EXPECTED_VALUE(static_cast<Dst>(DstLimits::max() * -1),
 682                         -CheckedNumeric<Dst>(DstLimits::max()));
 683
 684     TEST_EXPECTED_VALUE(0, -ClampedNumeric<Dst>());
 685     TEST_EXPECTED_VALUE(-1, -ClampedNumeric<Dst>(1));
 686     TEST_EXPECTED_VALUE(1, -ClampedNumeric<Dst>(-1));
 687     TEST_EXPECTED_VALUE(static_cast<Dst>(DstLimits::max() * -1),
 688                         -ClampedNumeric<Dst>(DstLimits::max()));
 689
 690     // The runtime paths for saturated negation differ significantly from what
 691     // gets evaluated at compile-time. Making this test volatile forces the
 692     // compiler to generate code rather than fold constant expressions.
 693     volatile Dst value = Dst(0);
 694     TEST_EXPECTED_VALUE(0, -MakeClampedNum(value));
 695     value = Dst(1);
 696     TEST_EXPECTED_VALUE(-1, -MakeClampedNum(value));
 697     value = Dst(2);
 698     TEST_EXPECTED_VALUE(-2, -MakeClampedNum(value));
 699     value = Dst(-1);
 700     TEST_EXPECTED_VALUE(1, -MakeClampedNum(value));
 701     value = Dst(-2);
 702     TEST_EXPECTED_VALUE(2, -MakeClampedNum(value));
 703     value = DstLimits::max();
 704     TEST_EXPECTED_VALUE(Dst(DstLimits::max() * -1), -MakeClampedNum(value));
 705     value = Dst(-1 * DstLimits::max());
 706     TEST_EXPECTED_VALUE(DstLimits::max(), -MakeClampedNum(value));
 707     value = DstLimits::lowest();
 708     TEST_EXPECTED_VALUE(DstLimits::max(), -MakeClampedNum(value));
 709   }
 710
 711   // Generic absolute value.
 712   TEST_EXPECTED_VALUE(0, CheckedNumeric<Dst>().Abs());
 713   TEST_EXPECTED_VALUE(1, CheckedNumeric<Dst>(1).Abs());
 714   TEST_EXPECTED_VALUE(DstLimits::max(),
 715                       CheckedNumeric<Dst>(DstLimits::max()).Abs());
 716
 717   TEST_EXPECTED_VALUE(0, ClampedNumeric<Dst>().Abs());
 718   TEST_EXPECTED_VALUE(1, ClampedNumeric<Dst>(1).Abs());
 719   TEST_EXPECTED_VALUE(DstLimits::max(),
 720                       ClampedNumeric<Dst>(DstLimits::max()).Abs());
 721
 722   // Generic addition.
 723   TEST_EXPECTED_VALUE(1, (CheckedNumeric<Dst>() + 1));
 724   TEST_EXPECTED_VALUE(2, (CheckedNumeric<Dst>(1) + 1));
 725   if (numeric_limits<Dst>::is_signed)
 726     TEST_EXPECTED_VALUE(0, (CheckedNumeric<Dst>(-1) + 1));
 727   TEST_EXPECTED_SUCCESS(CheckedNumeric<Dst>(DstLimits::lowest()) + 1);
 728   TEST_EXPECTED_FAILURE(CheckedNumeric<Dst>(DstLimits::max()) +
 729                         DstLimits::max());
 730
 731   TEST_EXPECTED_VALUE(1, (ClampedNumeric<Dst>() + 1));
 732   TEST_EXPECTED_VALUE(2, (ClampedNumeric<Dst>(1) + 1));
 733   if (numeric_limits<Dst>::is_signed)
 734     TEST_EXPECTED_VALUE(0, (ClampedNumeric<Dst>(-1) + 1));
 735   TEST_EXPECTED_VALUE(DstLimits::lowest() + 1,
 736                       ClampedNumeric<Dst>(DstLimits::lowest()) + 1);
 737   TEST_EXPECTED_VALUE(DstLimits::Overflow(),
 738                       ClampedNumeric<Dst>(DstLimits::max()) + DstLimits::max());
 739
 740   // Generic subtraction.
 741   TEST_EXPECTED_VALUE(0, (CheckedNumeric<Dst>(1) - 1));
 742   TEST_EXPECTED_SUCCESS(CheckedNumeric<Dst>(DstLimits::max()) - 1);
 743   if (numeric_limits<Dst>::is_signed) {
 744     TEST_EXPECTED_VALUE(-1, (CheckedNumeric<Dst>() - 1));
 745     TEST_EXPECTED_VALUE(-2, (CheckedNumeric<Dst>(-1) - 1));
 746   } else {
 747     TEST_EXPECTED_FAILURE(CheckedNumeric<Dst>(DstLimits::max()) - -1);
 748   }
 749
 750   TEST_EXPECTED_VALUE(0, (ClampedNumeric<Dst>(1) - 1));
 751   TEST_EXPECTED_VALUE(DstLimits::max() - 1,
 752                       ClampedNumeric<Dst>(DstLimits::max()) - 1);
 753   if (numeric_limits<Dst>::is_signed) {
 754     TEST_EXPECTED_VALUE(-1, (ClampedNumeric<Dst>() - 1));
 755     TEST_EXPECTED_VALUE(-2, (ClampedNumeric<Dst>(-1) - 1));
 756   } else {
 757     TEST_EXPECTED_VALUE(DstLimits::max(),
 758                         ClampedNumeric<Dst>(DstLimits::max()) - -1);
 759   }
 760
 761   // Generic multiplication.
 762   TEST_EXPECTED_VALUE(0, (CheckedNumeric<Dst>() * 1));
 763   TEST_EXPECTED_VALUE(1, (CheckedNumeric<Dst>(1) * 1));
 764   TEST_EXPECTED_VALUE(0, (CheckedNumeric<Dst>(0) * 0));
 765   if (numeric_limits<Dst>::is_signed) {
 766     TEST_EXPECTED_VALUE(0, (CheckedNumeric<Dst>(-1) * 0));
 767     TEST_EXPECTED_VALUE(0, (CheckedNumeric<Dst>(0) * -1));
 768     TEST_EXPECTED_VALUE(-2, (CheckedNumeric<Dst>(-1) * 2));
 769   } else {
 770     TEST_EXPECTED_FAILURE(CheckedNumeric<Dst>(DstLimits::max()) * -2);
 771     TEST_EXPECTED_FAILURE(CheckedNumeric<Dst>(DstLimits::max()) *
 772                           CheckedNumeric<uintmax_t>(-2));
 773   }
 774   TEST_EXPECTED_FAILURE(CheckedNumeric<Dst>(DstLimits::max()) *
 775                         DstLimits::max());
 776
 777   TEST_EXPECTED_VALUE(0, (ClampedNumeric<Dst>() * 1));
 778   TEST_EXPECTED_VALUE(1, (ClampedNumeric<Dst>(1) * 1));
 779   TEST_EXPECTED_VALUE(0, (ClampedNumeric<Dst>(0) * 0));
 780   if (numeric_limits<Dst>::is_signed) {
 781     TEST_EXPECTED_VALUE(0, (ClampedNumeric<Dst>(-1) * 0));
 782     TEST_EXPECTED_VALUE(0, (ClampedNumeric<Dst>(0) * -1));
 783     TEST_EXPECTED_VALUE(-2, (ClampedNumeric<Dst>(-1) * 2));
 784   } else {
 785     TEST_EXPECTED_VALUE(DstLimits::Underflow(),
 786                         ClampedNumeric<Dst>(DstLimits::max()) * -2);
 787     TEST_EXPECTED_VALUE(0, ClampedNumeric<Dst>(DstLimits::max()) *
 788                                ClampedNumeric<uintmax_t>(-2));
 789   }
 790   TEST_EXPECTED_VALUE(DstLimits::Overflow(),
 791                       ClampedNumeric<Dst>(DstLimits::max()) * DstLimits::max());
 792
 793   // Generic division.
 794   TEST_EXPECTED_VALUE(0, CheckedNumeric<Dst>() / 1);
 795   TEST_EXPECTED_VALUE(1, CheckedNumeric<Dst>(1) / 1);
 796   TEST_EXPECTED_VALUE(DstLimits::lowest() / 2,
 797                       CheckedNumeric<Dst>(DstLimits::lowest()) / 2);
 798   TEST_EXPECTED_VALUE(DstLimits::max() / 2,
 799                       CheckedNumeric<Dst>(DstLimits::max()) / 2);
 800   TEST_EXPECTED_FAILURE(CheckedNumeric<Dst>(1) / 0);
 801
 802   TEST_EXPECTED_VALUE(0, ClampedNumeric<Dst>() / 1);
 803   TEST_EXPECTED_VALUE(1, ClampedNumeric<Dst>(1) / 1);
 804   TEST_EXPECTED_VALUE(DstLimits::lowest() / 2,
 805                       ClampedNumeric<Dst>(DstLimits::lowest()) / 2);
 806   TEST_EXPECTED_VALUE(DstLimits::max() / 2,
 807                       ClampedNumeric<Dst>(DstLimits::max()) / 2);
 808   TEST_EXPECTED_VALUE(DstLimits::Overflow(), ClampedNumeric<Dst>(1) / 0);
 809   TEST_EXPECTED_VALUE(DstLimits::Underflow(), ClampedNumeric<Dst>(-1) / 0);
 810   TEST_EXPECTED_VALUE(0, ClampedNumeric<Dst>(0) / 0);
 811
 812   TestSpecializedArithmetic<Dst>(dst, line);
 813 }
 814
 815 // Helper macro to wrap displaying the conversion types and line numbers.
 816 #define TEST_ARITHMETIC(Dst) TestArithmetic<Dst>(#Dst, __LINE__)
 817
 818 TEST(SafeNumerics, SignedIntegerMath) {
 819   TEST_ARITHMETIC(int8_t);
 820   TEST_ARITHMETIC(int16_t);
 821   TEST_ARITHMETIC(int);
 822   TEST_ARITHMETIC(intptr_t);
 823   TEST_ARITHMETIC(intmax_t);
 824 }
 825
 826 TEST(SafeNumerics, UnsignedIntegerMath) {
 827   TEST_ARITHMETIC(uint8_t);
 828   TEST_ARITHMETIC(uint16_t);
 829   TEST_ARITHMETIC(unsigned int);
 830   TEST_ARITHMETIC(uintptr_t);
 831   TEST_ARITHMETIC(uintmax_t);
 832 }
 833
 834 TEST(SafeNumerics, FloatingPointMath) {
 835   TEST_ARITHMETIC(float);
 836   TEST_ARITHMETIC(double);
 837 }
 838
 839 // Enumerates the five different conversions types we need to test.
 840 enum NumericConversionType {
 841   SIGN_PRESERVING_VALUE_PRESERVING,
 842   SIGN_PRESERVING_NARROW,
 843   SIGN_TO_UNSIGN_WIDEN_OR_EQUAL,
 844   SIGN_TO_UNSIGN_NARROW,
 845   UNSIGN_TO_SIGN_NARROW_OR_EQUAL,
 846 };
 847
 848 // Template covering the different conversion tests.
 849 template <typename Dst, typename Src, NumericConversionType conversion>
 850 struct TestNumericConversion {};
 851
 852 enum RangeConstraint {
 853   RANGE_VALID = 0x0,      // Value can be represented by the destination type.
 854   RANGE_UNDERFLOW = 0x1,  // Value would underflow.
 855   RANGE_OVERFLOW = 0x2,   // Value would overflow.
 856   RANGE_INVALID = RANGE_UNDERFLOW | RANGE_OVERFLOW  // Invalid (i.e. NaN).
 857 };
 858
 859 // These are some wrappers to make the tests a bit cleaner.
 860 constexpr RangeConstraint RangeCheckToEnum(const RangeCheck constraint) {
 861   return static_cast<RangeConstraint>(
 862       static_cast<int>(constraint.IsOverflowFlagSet()) << 1 |
 863       static_cast<int>(constraint.IsUnderflowFlagSet()));
 864 }
 865
 866 // EXPECT_EQ wrappers providing specific detail on test failures.
 867 #define TEST_EXPECTED_RANGE(expected, actual)                               \
 868   EXPECT_EQ(expected,                                                       \
 869             RangeCheckToEnum(DstRangeRelationToSrcRange<Dst>(actual)))      \
 870       << "Conversion test: " << src << " value " << actual << " to " << dst \
 871       << " on line " << line
 872
 873 template <typename Dst, typename Src>
 874 void TestStrictComparison(const char* dst, const char* src, int line) {
 875   using DstLimits = numeric_limits<Dst>;
 876   using SrcLimits = numeric_limits<Src>;
 877   static_assert(StrictNumeric<Src>(SrcLimits::lowest()) < DstLimits::max(), "");
 878   static_assert(StrictNumeric<Src>(SrcLimits::lowest()) < SrcLimits::max(), "");
 879   static_assert(!(StrictNumeric<Src>(SrcLimits::lowest()) >= DstLimits::max()),
 880                 "");
 881   static_assert(!(StrictNumeric<Src>(SrcLimits::lowest()) >= SrcLimits::max()),
 882                 "");
 883   static_assert(StrictNumeric<Src>(SrcLimits::lowest()) <= DstLimits::max(),
 884                 "");
 885   static_assert(StrictNumeric<Src>(SrcLimits::lowest()) <= SrcLimits::max(),
 886                 "");
 887   static_assert(!(StrictNumeric<Src>(SrcLimits::lowest()) > DstLimits::max()),
 888                 "");
 889   static_assert(!(StrictNumeric<Src>(SrcLimits::lowest()) > SrcLimits::max()),
 890                 "");
 891   static_assert(StrictNumeric<Src>(SrcLimits::max()) > DstLimits::lowest(), "");
 892   static_assert(StrictNumeric<Src>(SrcLimits::max()) > SrcLimits::lowest(), "");
 893   static_assert(!(StrictNumeric<Src>(SrcLimits::max()) <= DstLimits::lowest()),
 894                 "");
 895   static_assert(!(StrictNumeric<Src>(SrcLimits::max()) <= SrcLimits::lowest()),
 896                 "");
 897   static_assert(StrictNumeric<Src>(SrcLimits::max()) >= DstLimits::lowest(),
 898                 "");
 899   static_assert(StrictNumeric<Src>(SrcLimits::max()) >= SrcLimits::lowest(),
 900                 "");
 901   static_assert(!(StrictNumeric<Src>(SrcLimits::max()) < DstLimits::lowest()),
 902                 "");
 903   static_assert(!(StrictNumeric<Src>(SrcLimits::max()) < SrcLimits::lowest()),
 904                 "");
 905   static_assert(StrictNumeric<Src>(static_cast<Src>(1)) == static_cast<Dst>(1),
 906                 "");
 907   static_assert(StrictNumeric<Src>(static_cast<Src>(1)) != static_cast<Dst>(0),
 908                 "");
 909   static_assert(StrictNumeric<Src>(SrcLimits::max()) != static_cast<Dst>(0),
 910                 "");
 911   static_assert(StrictNumeric<Src>(SrcLimits::max()) != DstLimits::lowest(),
 912                 "");
 913   static_assert(
 914       !(StrictNumeric<Src>(static_cast<Src>(1)) != static_cast<Dst>(1)), "");
 915   static_assert(
 916       !(StrictNumeric<Src>(static_cast<Src>(1)) == static_cast<Dst>(0)), "");
 917
 918   // Due to differences in float handling between compilers, these aren't
 919   // compile-time constants everywhere. So, we use run-time tests.
 920   EXPECT_EQ(
 921       SrcLimits::max(),
 922       MakeCheckedNum(SrcLimits::max()).Max(DstLimits::lowest()).ValueOrDie());
 923   EXPECT_EQ(
 924       DstLimits::max(),
 925       MakeCheckedNum(SrcLimits::lowest()).Max(DstLimits::max()).ValueOrDie());
 926   EXPECT_EQ(
 927       DstLimits::lowest(),
 928       MakeCheckedNum(SrcLimits::max()).Min(DstLimits::lowest()).ValueOrDie());
 929   EXPECT_EQ(
 930       SrcLimits::lowest(),
 931       MakeCheckedNum(SrcLimits::lowest()).Min(DstLimits::max()).ValueOrDie());
 932   EXPECT_EQ(SrcLimits::lowest(), CheckMin(MakeStrictNum(1), MakeCheckedNum(0),
 933                                           DstLimits::max(), SrcLimits::lowest())
 934                                      .ValueOrDie());
 935   EXPECT_EQ(DstLimits::max(), CheckMax(MakeStrictNum(1), MakeCheckedNum(0),
 936                                        DstLimits::max(), SrcLimits::lowest())
 937                                   .ValueOrDie());
 938
 939   EXPECT_EQ(SrcLimits::max(),
 940             MakeClampedNum(SrcLimits::max()).Max(DstLimits::lowest()));
 941   EXPECT_EQ(DstLimits::max(),
 942             MakeClampedNum(SrcLimits::lowest()).Max(DstLimits::max()));
 943   EXPECT_EQ(DstLimits::lowest(),
 944             MakeClampedNum(SrcLimits::max()).Min(DstLimits::lowest()));
 945   EXPECT_EQ(SrcLimits::lowest(),
 946             MakeClampedNum(SrcLimits::lowest()).Min(DstLimits::max()));
 947   EXPECT_EQ(SrcLimits::lowest(),
 948             ClampMin(MakeStrictNum(1), MakeClampedNum(0), DstLimits::max(),
 949                      SrcLimits::lowest()));
 950   EXPECT_EQ(DstLimits::max(), ClampMax(MakeStrictNum(1), MakeClampedNum(0),
 951                                        DstLimits::max(), SrcLimits::lowest()));
 952
 953   if (IsValueInRangeForNumericType<Dst>(SrcLimits::max())) {
 954     TEST_EXPECTED_VALUE(Dst(SrcLimits::max()), (CommonMax<Dst, Src>()));
 955     TEST_EXPECTED_VALUE(Dst(SrcLimits::max()),
 956                         (CommonMaxOrMin<Dst, Src>(false)));
 957   } else {
 958     TEST_EXPECTED_VALUE(DstLimits::max(), (CommonMax<Dst, Src>()));
 959     TEST_EXPECTED_VALUE(DstLimits::max(), (CommonMaxOrMin<Dst, Src>(false)));
 960   }
 961
 962   if (IsValueInRangeForNumericType<Dst>(SrcLimits::lowest())) {
 963     TEST_EXPECTED_VALUE(Dst(SrcLimits::lowest()), (CommonMin<Dst, Src>()));
 964     TEST_EXPECTED_VALUE(Dst(SrcLimits::lowest()),
 965                         (CommonMaxOrMin<Dst, Src>(true)));
 966   } else {
 967     TEST_EXPECTED_VALUE(DstLimits::lowest(), (CommonMin<Dst, Src>()));
 968     TEST_EXPECTED_VALUE(DstLimits::lowest(), (CommonMaxOrMin<Dst, Src>(true)));
 969   }
 970 }
 971
 972 template <typename Dst, typename Src>
 973 struct TestNumericConversion<Dst, Src, SIGN_PRESERVING_VALUE_PRESERVING> {
 974   static void Test(const char* dst, const char* src, int line) {
 975     using SrcLimits = SaturationDefaultLimits<Src>;
 976     using DstLimits = SaturationDefaultLimits<Dst>;
 977     // Integral to floating.
 978     static_assert((DstLimits::is_iec559 && SrcLimits::is_integer) ||
 979                       // Not floating to integral and...
 980                       (!(DstLimits::is_integer && SrcLimits::is_iec559) &&
 981                        // Same sign, same numeric, source is narrower or same.
 982                        ((SrcLimits::is_signed == DstLimits::is_signed &&
 983                          MaxExponent<Dst>::value >= MaxExponent<Src>::value) ||
 984                         // Or signed destination and source is smaller
 985                         (DstLimits::is_signed &&
 986                          MaxExponent<Dst>::value >= MaxExponent<Src>::value))),
 987                   "Comparison must be sign preserving and value preserving");
 988
 989     TestStrictComparison<Dst, Src>(dst, src, line);
 990
 991     const CheckedNumeric<Dst> checked_dst = SrcLimits::max();
 992     const ClampedNumeric<Dst> clamped_dst = SrcLimits::max();
 993     TEST_EXPECTED_SUCCESS(checked_dst);
 994     TEST_EXPECTED_VALUE(Dst(SrcLimits::max()), clamped_dst);
 995     if (MaxExponent<Dst>::value > MaxExponent<Src>::value) {
 996       if (MaxExponent<Dst>::value >= MaxExponent<Src>::value * 2 - 1) {
 997         // At least twice larger type.
 998         TEST_EXPECTED_SUCCESS(SrcLimits::max() * checked_dst);
 999         TEST_EXPECTED_VALUE(SrcLimits::max() * clamped_dst,
1000                             Dst(SrcLimits::max()) * Dst(SrcLimits::max()));
1001       } else {  // Larger, but not at least twice as large.
1002         TEST_EXPECTED_FAILURE(SrcLimits::max() * checked_dst);
1003         TEST_EXPECTED_SUCCESS(checked_dst + 1);
1004         TEST_EXPECTED_VALUE(DstLimits::Overflow(),
1005                             SrcLimits::max() * clamped_dst);
1006         TEST_EXPECTED_VALUE(Dst(SrcLimits::max()) + Dst(1),
1007                             clamped_dst + Dst(1));
1008       }
1009     } else {  // Same width type.
1010       TEST_EXPECTED_FAILURE(checked_dst + 1);
1011       TEST_EXPECTED_VALUE(DstLimits::Overflow(), clamped_dst + Dst(1));
1012     }
1013
1014     TEST_EXPECTED_RANGE(RANGE_VALID, SrcLimits::max());
1015     TEST_EXPECTED_RANGE(RANGE_VALID, static_cast<Src>(1));
1016     if (SrcLimits::is_iec559) {
1017       TEST_EXPECTED_RANGE(RANGE_VALID, SrcLimits::max() * static_cast<Src>(-1));
1018       TEST_EXPECTED_RANGE(RANGE_OVERFLOW, SrcLimits::infinity());
1019       TEST_EXPECTED_RANGE(RANGE_UNDERFLOW, SrcLimits::infinity() * -1);
1020       TEST_EXPECTED_RANGE(RANGE_INVALID, SrcLimits::quiet_NaN());
1021     } else if (numeric_limits<Src>::is_signed) {
1022       // This block reverses the Src to Dst relationship so we don't have to
1023       // complicate the test macros.
1024       if (!std::is_same<Src, Dst>::value) {
1025         TEST_EXPECTED_SUCCESS(CheckDiv(SrcLimits::lowest(), Dst(-1)));
1026       }
1027       TEST_EXPECTED_RANGE(RANGE_VALID, static_cast<Src>(-1));
1028       TEST_EXPECTED_RANGE(RANGE_VALID, SrcLimits::lowest());
1029     }
1030   }
1031 };
1032
1033 template <typename Dst, typename Src>
1034 struct TestNumericConversion<Dst, Src, SIGN_PRESERVING_NARROW> {
1035   static void Test(const char* dst, const char* src, int line) {
1036     using SrcLimits = SaturationDefaultLimits<Src>;
1037     using DstLimits = SaturationDefaultLimits<Dst>;
1038     static_assert(SrcLimits::is_signed == DstLimits::is_signed,
1039                   "Destination and source sign must be the same");
1040     static_assert(MaxExponent<Dst>::value <= MaxExponent<Src>::value,
1041                   "Destination must be narrower than source");
1042
1043     TestStrictComparison<Dst, Src>(dst, src, line);
1044
1045     const CheckedNumeric<Dst> checked_dst;
1046     TEST_EXPECTED_FAILURE(checked_dst + SrcLimits::max());
1047     TEST_EXPECTED_VALUE(1, checked_dst + Src(1));
1048     TEST_EXPECTED_FAILURE(checked_dst - SrcLimits::max());
1049
1050     ClampedNumeric<Dst> clamped_dst;
1051     TEST_EXPECTED_VALUE(DstLimits::Overflow(), clamped_dst + SrcLimits::max());
1052     TEST_EXPECTED_VALUE(1, clamped_dst + Src(1));
1053     TEST_EXPECTED_VALUE(DstLimits::Underflow(), clamped_dst - SrcLimits::max());
1054     clamped_dst += SrcLimits::max();
1055     TEST_EXPECTED_VALUE(DstLimits::Overflow(), clamped_dst);
1056     clamped_dst = DstLimits::max();
1057     clamped_dst += SrcLimits::max();
1058     TEST_EXPECTED_VALUE(DstLimits::Overflow(), clamped_dst);
1059     clamped_dst = DstLimits::max();
1060     clamped_dst -= SrcLimits::max();
1061     TEST_EXPECTED_VALUE(DstLimits::Underflow(), clamped_dst);
1062     clamped_dst = 0;
1063
1064     TEST_EXPECTED_RANGE(RANGE_OVERFLOW, SrcLimits::max());
1065     TEST_EXPECTED_RANGE(RANGE_VALID, static_cast<Src>(1));
1066     if (SrcLimits::is_iec559) {
1067       TEST_EXPECTED_RANGE(RANGE_UNDERFLOW, SrcLimits::max() * -1);
1068       TEST_EXPECTED_RANGE(RANGE_VALID, static_cast<Src>(-1));
1069       TEST_EXPECTED_RANGE(RANGE_OVERFLOW, SrcLimits::infinity());
1070       TEST_EXPECTED_RANGE(RANGE_UNDERFLOW, SrcLimits::infinity() * -1);
1071       TEST_EXPECTED_RANGE(RANGE_INVALID, SrcLimits::quiet_NaN());
1072       if (DstLimits::is_integer) {
1073         if (SrcLimits::digits < DstLimits::digits) {
1074           TEST_EXPECTED_RANGE(RANGE_OVERFLOW,
1075                               static_cast<Src>(DstLimits::max()));
1076         } else {
1077           TEST_EXPECTED_RANGE(RANGE_VALID, static_cast<Src>(DstLimits::max()));
1078         }
1079         TEST_EXPECTED_RANGE(
1080             RANGE_VALID,
1081             static_cast<Src>(GetMaxConvertibleToFloat<Src, Dst>()));
1082         TEST_EXPECTED_RANGE(RANGE_VALID, static_cast<Src>(DstLimits::lowest()));
1083       }
1084     } else if (SrcLimits::is_signed) {
1085       TEST_EXPECTED_VALUE(-1, checked_dst - static_cast<Src>(1));
1086       TEST_EXPECTED_VALUE(-1, clamped_dst - static_cast<Src>(1));
1087       TEST_EXPECTED_VALUE(Src(Src(0) - DstLimits::lowest()),
1088                           ClampDiv(DstLimits::lowest(), Src(-1)));
1089       TEST_EXPECTED_RANGE(RANGE_UNDERFLOW, SrcLimits::lowest());
1090       TEST_EXPECTED_RANGE(RANGE_VALID, static_cast<Src>(-1));
1091     } else {
1092       TEST_EXPECTED_FAILURE(checked_dst - static_cast<Src>(1));
1093       TEST_EXPECTED_VALUE(Dst(0), clamped_dst - static_cast<Src>(1));
1094       TEST_EXPECTED_RANGE(RANGE_VALID, SrcLimits::lowest());
1095     }
1096   }
1097 };
1098
1099 template <typename Dst, typename Src>
1100 struct TestNumericConversion<Dst, Src, SIGN_TO_UNSIGN_WIDEN_OR_EQUAL> {
1101   static void Test(const char* dst, const char* src, int line) {
1102     using SrcLimits = SaturationDefaultLimits<Src>;
1103     using DstLimits = SaturationDefaultLimits<Dst>;
1104     static_assert(MaxExponent<Dst>::value >= MaxExponent<Src>::value,
1105                   "Destination must be equal or wider than source.");
1106     static_assert(SrcLimits::is_signed, "Source must be signed");
1107     static_assert(!DstLimits::is_signed, "Destination must be unsigned");
1108
1109     TestStrictComparison<Dst, Src>(dst, src, line);
1110
1111     const CheckedNumeric<Dst> checked_dst;
1112     TEST_EXPECTED_VALUE(SrcLimits::max(), checked_dst + SrcLimits::max());
1113     TEST_EXPECTED_FAILURE(checked_dst + static_cast<Src>(-1));
1114     TEST_EXPECTED_SUCCESS(checked_dst * static_cast<Src>(-1));
1115     TEST_EXPECTED_FAILURE(checked_dst + SrcLimits::lowest());
1116     TEST_EXPECTED_VALUE(Dst(0), CheckDiv(Dst(0), Src(-1)));
1117
1118     const ClampedNumeric<Dst> clamped_dst;
1119     TEST_EXPECTED_VALUE(SrcLimits::max(), clamped_dst + SrcLimits::max());
1120     TEST_EXPECTED_VALUE(DstLimits::Underflow(),
1121                         clamped_dst + static_cast<Src>(-1));
1122     TEST_EXPECTED_VALUE(0, clamped_dst * static_cast<Src>(-1));
1123     TEST_EXPECTED_VALUE(DstLimits::Underflow(),
1124                         clamped_dst + SrcLimits::lowest());
1125
1126     TEST_EXPECTED_RANGE(RANGE_UNDERFLOW, SrcLimits::lowest());
1127     TEST_EXPECTED_RANGE(RANGE_VALID, SrcLimits::max());
1128     TEST_EXPECTED_RANGE(RANGE_VALID, static_cast<Src>(1));
1129     TEST_EXPECTED_RANGE(RANGE_UNDERFLOW, static_cast<Src>(-1));
1130   }
1131 };
1132
1133 template <typename Dst, typename Src>
1134 struct TestNumericConversion<Dst, Src, SIGN_TO_UNSIGN_NARROW> {
1135   static void Test(const char* dst, const char* src, int line) {
1136     using SrcLimits = SaturationDefaultLimits<Src>;
1137     using DstLimits = SaturationDefaultLimits<Dst>;
1138     static_assert(MaxExponent<Dst>::value < MaxExponent<Src>::value,
1139                   "Destination must be narrower than source.");
1140     static_assert(SrcLimits::is_signed, "Source must be signed.");
1141     static_assert(!DstLimits::is_signed, "Destination must be unsigned.");
1142
1143     TestStrictComparison<Dst, Src>(dst, src, line);
1144
1145     const CheckedNumeric<Dst> checked_dst;
1146     TEST_EXPECTED_VALUE(1, checked_dst + static_cast<Src>(1));
1147     TEST_EXPECTED_FAILURE(checked_dst + SrcLimits::max());
1148     TEST_EXPECTED_FAILURE(checked_dst + static_cast<Src>(-1));
1149     TEST_EXPECTED_FAILURE(checked_dst + SrcLimits::lowest());
1150
1151     ClampedNumeric<Dst> clamped_dst;
1152     TEST_EXPECTED_VALUE(1, clamped_dst + static_cast<Src>(1));
1153     TEST_EXPECTED_VALUE(DstLimits::Overflow(), clamped_dst + SrcLimits::max());
1154     TEST_EXPECTED_VALUE(DstLimits::Underflow(),
1155                         clamped_dst + static_cast<Src>(-1));
1156     TEST_EXPECTED_VALUE(DstLimits::Underflow(),
1157                         clamped_dst + SrcLimits::lowest());
1158     clamped_dst += SrcLimits::max();
1159     TEST_EXPECTED_VALUE(DstLimits::Overflow(), clamped_dst);
1160     clamped_dst = DstLimits::max();
1161     clamped_dst += SrcLimits::max();
1162     TEST_EXPECTED_VALUE(DstLimits::Overflow(), clamped_dst);
1163     clamped_dst = DstLimits::max();
1164     clamped_dst -= SrcLimits::max();
1165     TEST_EXPECTED_VALUE(DstLimits::Underflow(), clamped_dst);
1166     clamped_dst = 0;
1167
1168     TEST_EXPECTED_RANGE(RANGE_OVERFLOW, SrcLimits::max());
1169     TEST_EXPECTED_RANGE(RANGE_VALID, static_cast<Src>(1));
1170     TEST_EXPECTED_RANGE(RANGE_UNDERFLOW, static_cast<Src>(-1));
1171
1172     // Additional saturation tests.
1173     EXPECT_EQ(DstLimits::max(), saturated_cast<Dst>(SrcLimits::max()));
1174     EXPECT_EQ(DstLimits::lowest(), saturated_cast<Dst>(SrcLimits::lowest()));
1175
1176     if (SrcLimits::is_iec559) {
1177       EXPECT_EQ(Dst(0), saturated_cast<Dst>(SrcLimits::quiet_NaN()));
1178
1179       TEST_EXPECTED_RANGE(RANGE_UNDERFLOW, SrcLimits::max() * -1);
1180       TEST_EXPECTED_RANGE(RANGE_OVERFLOW, SrcLimits::infinity());
1181       TEST_EXPECTED_RANGE(RANGE_UNDERFLOW, SrcLimits::infinity() * -1);
1182       TEST_EXPECTED_RANGE(RANGE_INVALID, SrcLimits::quiet_NaN());
1183       if (DstLimits::is_integer) {
1184         if (SrcLimits::digits < DstLimits::digits) {
1185           TEST_EXPECTED_RANGE(RANGE_OVERFLOW,
1186                               static_cast<Src>(DstLimits::max()));
1187         } else {
1188           TEST_EXPECTED_RANGE(RANGE_VALID, static_cast<Src>(DstLimits::max()));
1189         }
1190         TEST_EXPECTED_RANGE(
1191             RANGE_VALID,
1192             static_cast<Src>(GetMaxConvertibleToFloat<Src, Dst>()));
1193         TEST_EXPECTED_RANGE(RANGE_VALID, static_cast<Src>(DstLimits::lowest()));
1194       }
1195     } else {
1196       TEST_EXPECTED_RANGE(RANGE_UNDERFLOW, SrcLimits::lowest());
1197     }
1198   }
1199 };
1200
1201 template <typename Dst, typename Src>
1202 struct TestNumericConversion<Dst, Src, UNSIGN_TO_SIGN_NARROW_OR_EQUAL> {
1203   static void Test(const char* dst, const char* src, int line) {
1204     using SrcLimits = SaturationDefaultLimits<Src>;
1205     using DstLimits = SaturationDefaultLimits<Dst>;
1206     static_assert(MaxExponent<Dst>::value <= MaxExponent<Src>::value,
1207                   "Destination must be narrower or equal to source.");
1208     static_assert(!SrcLimits::is_signed, "Source must be unsigned.");
1209     static_assert(DstLimits::is_signed, "Destination must be signed.");
1210
1211     TestStrictComparison<Dst, Src>(dst, src, line);
1212
1213     const CheckedNumeric<Dst> checked_dst;
1214     TEST_EXPECTED_VALUE(1, checked_dst + static_cast<Src>(1));
1215     TEST_EXPECTED_FAILURE(checked_dst + SrcLimits::max());
1216     TEST_EXPECTED_VALUE(SrcLimits::lowest(), checked_dst + SrcLimits::lowest());
1217
1218     const ClampedNumeric<Dst> clamped_dst;
1219     TEST_EXPECTED_VALUE(1, clamped_dst + static_cast<Src>(1));
1220     TEST_EXPECTED_VALUE(DstLimits::Overflow(), clamped_dst + SrcLimits::max());
1221     TEST_EXPECTED_VALUE(SrcLimits::lowest(), clamped_dst + SrcLimits::lowest());
1222
1223     TEST_EXPECTED_RANGE(RANGE_VALID, SrcLimits::lowest());
1224     TEST_EXPECTED_RANGE(RANGE_OVERFLOW, SrcLimits::max());
1225     TEST_EXPECTED_RANGE(RANGE_VALID, static_cast<Src>(1));
1226
1227     // Additional saturation tests.
1228     EXPECT_EQ(DstLimits::max(), saturated_cast<Dst>(SrcLimits::max()));
1229     EXPECT_EQ(Dst(0), saturated_cast<Dst>(SrcLimits::lowest()));
1230   }
1231 };
1232
1233 // Helper macro to wrap displaying the conversion types and line numbers
1234 #define TEST_NUMERIC_CONVERSION(d, s, t) \
1235   TestNumericConversion<d, s, t>::Test(#d, #s, __LINE__)
1236
1237 TEST(SafeNumerics, IntMinOperations) {
1238   TEST_NUMERIC_CONVERSION(int8_t, int8_t, SIGN_PRESERVING_VALUE_PRESERVING);
1239   TEST_NUMERIC_CONVERSION(uint8_t, uint8_t, SIGN_PRESERVING_VALUE_PRESERVING);
1240
1241   TEST_NUMERIC_CONVERSION(int8_t, int16_t, SIGN_PRESERVING_NARROW);
1242   TEST_NUMERIC_CONVERSION(int8_t, int, SIGN_PRESERVING_NARROW);
1243   TEST_NUMERIC_CONVERSION(uint8_t, uint16_t, SIGN_PRESERVING_NARROW);
1244   TEST_NUMERIC_CONVERSION(uint8_t, unsigned int, SIGN_PRESERVING_NARROW);
1245   TEST_NUMERIC_CONVERSION(int8_t, float, SIGN_PRESERVING_NARROW);
1246
1247   TEST_NUMERIC_CONVERSION(uint8_t, int8_t, SIGN_TO_UNSIGN_WIDEN_OR_EQUAL);
1248
1249   TEST_NUMERIC_CONVERSION(uint8_t, int16_t, SIGN_TO_UNSIGN_NARROW);
1250   TEST_NUMERIC_CONVERSION(uint8_t, int, SIGN_TO_UNSIGN_NARROW);
1251   TEST_NUMERIC_CONVERSION(uint8_t, intmax_t, SIGN_TO_UNSIGN_NARROW);
1252   TEST_NUMERIC_CONVERSION(uint8_t, float, SIGN_TO_UNSIGN_NARROW);
1253
1254   TEST_NUMERIC_CONVERSION(int8_t, uint16_t, UNSIGN_TO_SIGN_NARROW_OR_EQUAL);
1255   TEST_NUMERIC_CONVERSION(int8_t, unsigned int, UNSIGN_TO_SIGN_NARROW_OR_EQUAL);
1256   TEST_NUMERIC_CONVERSION(int8_t, uintmax_t, UNSIGN_TO_SIGN_NARROW_OR_EQUAL);
1257 }
1258
1259 TEST(SafeNumerics, Int16Operations) {
1260   TEST_NUMERIC_CONVERSION(int16_t, int16_t, SIGN_PRESERVING_VALUE_PRESERVING);
1261   TEST_NUMERIC_CONVERSION(uint16_t, uint16_t, SIGN_PRESERVING_VALUE_PRESERVING);
1262
1263   TEST_NUMERIC_CONVERSION(int16_t, int, SIGN_PRESERVING_NARROW);
1264   TEST_NUMERIC_CONVERSION(uint16_t, unsigned int, SIGN_PRESERVING_NARROW);
1265   TEST_NUMERIC_CONVERSION(int16_t, float, SIGN_PRESERVING_NARROW);
1266
1267   TEST_NUMERIC_CONVERSION(uint16_t, int16_t, SIGN_TO_UNSIGN_WIDEN_OR_EQUAL);
1268
1269   TEST_NUMERIC_CONVERSION(uint16_t, int, SIGN_TO_UNSIGN_NARROW);
1270   TEST_NUMERIC_CONVERSION(uint16_t, intmax_t, SIGN_TO_UNSIGN_NARROW);
1271   TEST_NUMERIC_CONVERSION(uint16_t, float, SIGN_TO_UNSIGN_NARROW);
1272
1273   TEST_NUMERIC_CONVERSION(int16_t, unsigned int,
1274                           UNSIGN_TO_SIGN_NARROW_OR_EQUAL);
1275   TEST_NUMERIC_CONVERSION(int16_t, uintmax_t, UNSIGN_TO_SIGN_NARROW_OR_EQUAL);
1276 }
1277
1278 TEST(SafeNumerics, IntOperations) {
1279   TEST_NUMERIC_CONVERSION(int, int, SIGN_PRESERVING_VALUE_PRESERVING);
1280   TEST_NUMERIC_CONVERSION(unsigned int, unsigned int,
1281                           SIGN_PRESERVING_VALUE_PRESERVING);
1282   TEST_NUMERIC_CONVERSION(int, int8_t, SIGN_PRESERVING_VALUE_PRESERVING);
1283   TEST_NUMERIC_CONVERSION(unsigned int, uint8_t,
1284                           SIGN_PRESERVING_VALUE_PRESERVING);
1285   TEST_NUMERIC_CONVERSION(int, uint8_t, SIGN_PRESERVING_VALUE_PRESERVING);
1286
1287   TEST_NUMERIC_CONVERSION(int, intmax_t, SIGN_PRESERVING_NARROW);
1288   TEST_NUMERIC_CONVERSION(unsigned int, uintmax_t, SIGN_PRESERVING_NARROW);
1289   TEST_NUMERIC_CONVERSION(int, float, SIGN_PRESERVING_NARROW);
1290   TEST_NUMERIC_CONVERSION(int, double, SIGN_PRESERVING_NARROW);
1291
1292   TEST_NUMERIC_CONVERSION(unsigned int, int, SIGN_TO_UNSIGN_WIDEN_OR_EQUAL);
1293   TEST_NUMERIC_CONVERSION(unsigned int, int8_t, SIGN_TO_UNSIGN_WIDEN_OR_EQUAL);
1294
1295   TEST_NUMERIC_CONVERSION(unsigned int, intmax_t, SIGN_TO_UNSIGN_NARROW);
1296   TEST_NUMERIC_CONVERSION(unsigned int, float, SIGN_TO_UNSIGN_NARROW);
1297   TEST_NUMERIC_CONVERSION(unsigned int, double, SIGN_TO_UNSIGN_NARROW);
1298
1299   TEST_NUMERIC_CONVERSION(int, unsigned int, UNSIGN_TO_SIGN_NARROW_OR_EQUAL);
1300   TEST_NUMERIC_CONVERSION(int, uintmax_t, UNSIGN_TO_SIGN_NARROW_OR_EQUAL);
1301 }
1302
1303 TEST(SafeNumerics, IntMaxOperations) {
1304   TEST_NUMERIC_CONVERSION(intmax_t, intmax_t, SIGN_PRESERVING_VALUE_PRESERVING);
1305   TEST_NUMERIC_CONVERSION(uintmax_t, uintmax_t,
1306                           SIGN_PRESERVING_VALUE_PRESERVING);
1307   TEST_NUMERIC_CONVERSION(intmax_t, int, SIGN_PRESERVING_VALUE_PRESERVING);
1308   TEST_NUMERIC_CONVERSION(uintmax_t, unsigned int,
1309                           SIGN_PRESERVING_VALUE_PRESERVING);
1310   TEST_NUMERIC_CONVERSION(intmax_t, unsigned int,
1311                           SIGN_PRESERVING_VALUE_PRESERVING);
1312   TEST_NUMERIC_CONVERSION(intmax_t, uint8_t, SIGN_PRESERVING_VALUE_PRESERVING);
1313
1314   TEST_NUMERIC_CONVERSION(intmax_t, float, SIGN_PRESERVING_NARROW);
1315   TEST_NUMERIC_CONVERSION(intmax_t, double, SIGN_PRESERVING_NARROW);
1316
1317   TEST_NUMERIC_CONVERSION(uintmax_t, int, SIGN_TO_UNSIGN_WIDEN_OR_EQUAL);
1318   TEST_NUMERIC_CONVERSION(uintmax_t, int8_t, SIGN_TO_UNSIGN_WIDEN_OR_EQUAL);
1319
1320   TEST_NUMERIC_CONVERSION(uintmax_t, float, SIGN_TO_UNSIGN_NARROW);
1321   TEST_NUMERIC_CONVERSION(uintmax_t, double, SIGN_TO_UNSIGN_NARROW);
1322
1323   TEST_NUMERIC_CONVERSION(intmax_t, uintmax_t, UNSIGN_TO_SIGN_NARROW_OR_EQUAL);
1324 }
1325
1326 TEST(SafeNumerics, FloatOperations) {
1327   TEST_NUMERIC_CONVERSION(float, intmax_t, SIGN_PRESERVING_VALUE_PRESERVING);
1328   TEST_NUMERIC_CONVERSION(float, uintmax_t, SIGN_PRESERVING_VALUE_PRESERVING);
1329   TEST_NUMERIC_CONVERSION(float, int, SIGN_PRESERVING_VALUE_PRESERVING);
1330   TEST_NUMERIC_CONVERSION(float, unsigned int,
1331                           SIGN_PRESERVING_VALUE_PRESERVING);
1332
1333   TEST_NUMERIC_CONVERSION(float, double, SIGN_PRESERVING_NARROW);
1334 }
1335
1336 TEST(SafeNumerics, DoubleOperations) {
1337   TEST_NUMERIC_CONVERSION(double, intmax_t, SIGN_PRESERVING_VALUE_PRESERVING);
1338   TEST_NUMERIC_CONVERSION(double, uintmax_t, SIGN_PRESERVING_VALUE_PRESERVING);
1339   TEST_NUMERIC_CONVERSION(double, int, SIGN_PRESERVING_VALUE_PRESERVING);
1340   TEST_NUMERIC_CONVERSION(double, unsigned int,
1341                           SIGN_PRESERVING_VALUE_PRESERVING);
1342 }
1343
1344 TEST(SafeNumerics, SizeTOperations) {
1345   TEST_NUMERIC_CONVERSION(size_t, int, SIGN_TO_UNSIGN_WIDEN_OR_EQUAL);
1346   TEST_NUMERIC_CONVERSION(int, size_t, UNSIGN_TO_SIGN_NARROW_OR_EQUAL);
1347 }
1348
1349 // A one-off test to ensure StrictNumeric won't resolve to an incorrect type.
1350 // If this fails we'll just get a compiler error on an ambiguous overload.
1351 int TestOverload(int) {  // Overload fails.
1352   return 0;
1353 }
1354 uint8_t TestOverload(uint8_t) {  // Overload fails.
1355   return 0;
1356 }
1357 size_t TestOverload(size_t) {  // Overload succeeds.
1358   return 0;
1359 }
1360
1361 static_assert(
1362     std::is_same<decltype(TestOverload(StrictNumeric<int>())), int>::value,
1363     "");
1364 static_assert(std::is_same<decltype(TestOverload(StrictNumeric<size_t>())),
1365                            size_t>::value,
1366               "");
1367
1368 template <typename T>
1369 struct CastTest1 {
1370   static constexpr T NaN() { return -1; }
1371   static constexpr T max() { return numeric_limits<T>::max() - 1; }
1372   static constexpr T Overflow() { return max(); }
1373   static constexpr T lowest() { return numeric_limits<T>::lowest() + 1; }
1374   static constexpr T Underflow() { return lowest(); }
1375 };
1376
1377 template <typename T>
1378 struct CastTest2 {
1379   static constexpr T NaN() { return 11; }
1380   static constexpr T max() { return 10; }
1381   static constexpr T Overflow() { return max(); }
1382   static constexpr T lowest() { return 1; }
1383   static constexpr T Underflow() { return lowest(); }
1384 };
1385
1386 TEST(SafeNumerics, CastTests) {
1387 // MSVC catches and warns that we're forcing saturation in these tests.
1388 // Since that's intentional, we need to shut this warning off.
1389 #if defined(COMPILER_MSVC)
1390 #pragma warning(disable : 4756)
1391 #endif
1392
1393   int small_positive = 1;
1394   int small_negative = -1;
1395   double double_small = 1.0;
1396   double double_large = numeric_limits<double>::max();
1397   double double_infinity = numeric_limits<float>::infinity();
1398   double double_large_int = numeric_limits<int>::max();
1399   double double_small_int = numeric_limits<int>::lowest();
1400
1401   // Just test that the casts compile, since the other tests cover logic.
1402   EXPECT_EQ(0, checked_cast<int>(static_cast<size_t>(0)));
1403   EXPECT_EQ(0, strict_cast<int>(static_cast<char>(0)));
1404   EXPECT_EQ(0, strict_cast<int>(static_cast<unsigned char>(0)));
1405   EXPECT_EQ(0U, strict_cast<unsigned>(static_cast<unsigned char>(0)));
1406   EXPECT_EQ(1ULL, static_cast<uint64_t>(StrictNumeric<size_t>(1U)));
1407   EXPECT_EQ(1ULL, static_cast<uint64_t>(SizeT(1U)));
1408   EXPECT_EQ(1U, static_cast<size_t>(StrictNumeric<unsigned>(1U)));
1409
1410   EXPECT_TRUE(CheckedNumeric<uint64_t>(StrictNumeric<unsigned>(1U)).IsValid());
1411   EXPECT_TRUE(CheckedNumeric<int>(StrictNumeric<unsigned>(1U)).IsValid());
1412   EXPECT_FALSE(CheckedNumeric<unsigned>(StrictNumeric<int>(-1)).IsValid());
1413
1414   EXPECT_TRUE(IsValueNegative(-1));
1415   EXPECT_TRUE(IsValueNegative(numeric_limits<int>::lowest()));
1416   EXPECT_FALSE(IsValueNegative(numeric_limits<unsigned>::lowest()));
1417   EXPECT_TRUE(IsValueNegative(numeric_limits<double>::lowest()));
1418   EXPECT_FALSE(IsValueNegative(0));
1419   EXPECT_FALSE(IsValueNegative(1));
1420   EXPECT_FALSE(IsValueNegative(0u));
1421   EXPECT_FALSE(IsValueNegative(1u));
1422   EXPECT_FALSE(IsValueNegative(numeric_limits<int>::max()));
1423   EXPECT_FALSE(IsValueNegative(numeric_limits<unsigned>::max()));
1424   EXPECT_FALSE(IsValueNegative(numeric_limits<double>::max()));
1425
1426   // These casts and coercions will fail to compile:
1427   // EXPECT_EQ(0, strict_cast<int>(static_cast<size_t>(0)));
1428   // EXPECT_EQ(0, strict_cast<size_t>(static_cast<int>(0)));
1429   // EXPECT_EQ(1ULL, StrictNumeric<size_t>(1));
1430   // EXPECT_EQ(1, StrictNumeric<size_t>(1U));
1431
1432   // Test various saturation corner cases.
1433   EXPECT_EQ(saturated_cast<int>(small_negative),
1434             static_cast<int>(small_negative));
1435   EXPECT_EQ(saturated_cast<int>(small_positive),
1436             static_cast<int>(small_positive));
1437   EXPECT_EQ(saturated_cast<unsigned>(small_negative), static_cast<unsigned>(0));
1438   EXPECT_EQ(saturated_cast<int>(double_small), static_cast<int>(double_small));
1439   EXPECT_EQ(saturated_cast<int>(double_large), numeric_limits<int>::max());
1440   EXPECT_EQ(saturated_cast<float>(double_large), double_infinity);
1441   EXPECT_EQ(saturated_cast<float>(-double_large), -double_infinity);
1442   EXPECT_EQ(numeric_limits<int>::lowest(),
1443             saturated_cast<int>(double_small_int));
1444   EXPECT_EQ(numeric_limits<int>::max(), saturated_cast<int>(double_large_int));
1445
1446   // Test the saturated cast overrides.
1447   using FloatLimits = numeric_limits<float>;
1448   using IntLimits = numeric_limits<int>;
1449   EXPECT_EQ(-1, (saturated_cast<int, CastTest1>(FloatLimits::quiet_NaN())));
1450   EXPECT_EQ(CastTest1<int>::max(),
1451             (saturated_cast<int, CastTest1>(FloatLimits::infinity())));
1452   EXPECT_EQ(CastTest1<int>::max(),
1453             (saturated_cast<int, CastTest1>(FloatLimits::max())));
1454   EXPECT_EQ(CastTest1<int>::max(),
1455             (saturated_cast<int, CastTest1>(float(IntLimits::max()))));
1456   EXPECT_EQ(CastTest1<int>::lowest(),
1457             (saturated_cast<int, CastTest1>(-FloatLimits::infinity())));
1458   EXPECT_EQ(CastTest1<int>::lowest(),
1459             (saturated_cast<int, CastTest1>(FloatLimits::lowest())));
1460   EXPECT_EQ(0, (saturated_cast<int, CastTest1>(0.0)));
1461   EXPECT_EQ(1, (saturated_cast<int, CastTest1>(1.0)));
1462   EXPECT_EQ(-1, (saturated_cast<int, CastTest1>(-1.0)));
1463   EXPECT_EQ(0, (saturated_cast<int, CastTest1>(0)));
1464   EXPECT_EQ(1, (saturated_cast<int, CastTest1>(1)));
1465   EXPECT_EQ(-1, (saturated_cast<int, CastTest1>(-1)));
1466   EXPECT_EQ(CastTest1<int>::lowest(),
1467             (saturated_cast<int, CastTest1>(float(IntLimits::lowest()))));
1468   EXPECT_EQ(11, (saturated_cast<int, CastTest2>(FloatLimits::quiet_NaN())));
1469   EXPECT_EQ(10, (saturated_cast<int, CastTest2>(FloatLimits::infinity())));
1470   EXPECT_EQ(10, (saturated_cast<int, CastTest2>(FloatLimits::max())));
1471   EXPECT_EQ(1, (saturated_cast<int, CastTest2>(-FloatLimits::infinity())));
1472   EXPECT_EQ(1, (saturated_cast<int, CastTest2>(FloatLimits::lowest())));
1473   EXPECT_EQ(1, (saturated_cast<int, CastTest2>(0U)));
1474
1475   float not_a_number = std::numeric_limits<float>::infinity() -
1476                        std::numeric_limits<float>::infinity();
1477   EXPECT_TRUE(std::isnan(not_a_number));
1478   EXPECT_EQ(0, saturated_cast<int>(not_a_number));
1479
1480   // Test the CheckedNumeric value extractions functions.
1481   auto int8_min = MakeCheckedNum(numeric_limits<int8_t>::lowest());
1482   auto int8_max = MakeCheckedNum(numeric_limits<int8_t>::max());
1483   auto double_max = MakeCheckedNum(numeric_limits<double>::max());
1484   static_assert(
1485       std::is_same<int16_t,
1486                    decltype(int8_min.ValueOrDie<int16_t>())::type>::value,
1487       "ValueOrDie returning incorrect type.");
1488   static_assert(
1489       std::is_same<int16_t,
1490                    decltype(int8_min.ValueOrDefault<int16_t>(0))::type>::value,
1491       "ValueOrDefault returning incorrect type.");
1492   EXPECT_FALSE(IsValidForType<uint8_t>(int8_min));
1493   EXPECT_TRUE(IsValidForType<uint8_t>(int8_max));
1494   EXPECT_EQ(static_cast<int>(numeric_limits<int8_t>::lowest()),
1495             ValueOrDieForType<int>(int8_min));
1496   EXPECT_TRUE(IsValidForType<uint32_t>(int8_max));
1497   EXPECT_EQ(static_cast<int>(numeric_limits<int8_t>::max()),
1498             ValueOrDieForType<int>(int8_max));
1499   EXPECT_EQ(0, ValueOrDefaultForType<int>(double_max, 0));
1500   uint8_t uint8_dest = 0;
1501   int16_t int16_dest = 0;
1502   double double_dest = 0;
1503   EXPECT_TRUE(int8_max.AssignIfValid(&uint8_dest));
1504   EXPECT_EQ(static_cast<uint8_t>(numeric_limits<int8_t>::max()), uint8_dest);
1505   EXPECT_FALSE(int8_min.AssignIfValid(&uint8_dest));
1506   EXPECT_TRUE(int8_max.AssignIfValid(&int16_dest));
1507   EXPECT_EQ(static_cast<int16_t>(numeric_limits<int8_t>::max()), int16_dest);
1508   EXPECT_TRUE(int8_min.AssignIfValid(&int16_dest));
1509   EXPECT_EQ(static_cast<int16_t>(numeric_limits<int8_t>::lowest()), int16_dest);
1510   EXPECT_FALSE(double_max.AssignIfValid(&uint8_dest));
1511   EXPECT_FALSE(double_max.AssignIfValid(&int16_dest));
1512   EXPECT_TRUE(double_max.AssignIfValid(&double_dest));
1513   EXPECT_EQ(numeric_limits<double>::max(), double_dest);
1514   EXPECT_EQ(1, checked_cast<int>(StrictNumeric<int>(1)));
1515   EXPECT_EQ(1, saturated_cast<int>(StrictNumeric<int>(1)));
1516   EXPECT_EQ(1, strict_cast<int>(StrictNumeric<int>(1)));
1517
1518   enum class EnumTest { kOne = 1 };
1519   EXPECT_EQ(1, checked_cast<int>(EnumTest::kOne));
1520   EXPECT_EQ(1, saturated_cast<int>(EnumTest::kOne));
1521   EXPECT_EQ(1, strict_cast<int>(EnumTest::kOne));
1522 }
1523
1524 TEST(SafeNumerics, IsValueInRangeForNumericType) {
1525   EXPECT_TRUE(IsValueInRangeForNumericType<uint32_t>(0));
1526   EXPECT_TRUE(IsValueInRangeForNumericType<uint32_t>(1));
1527   EXPECT_TRUE(IsValueInRangeForNumericType<uint32_t>(2));
1528   EXPECT_FALSE(IsValueInRangeForNumericType<uint32_t>(-1));
1529   EXPECT_TRUE(IsValueInRangeForNumericType<uint32_t>(0xffffffffu));
1530   EXPECT_TRUE(IsValueInRangeForNumericType<uint32_t>(UINT64_C(0xffffffff)));
1531   EXPECT_FALSE(IsValueInRangeForNumericType<uint32_t>(UINT64_C(0x100000000)));
1532   EXPECT_FALSE(IsValueInRangeForNumericType<uint32_t>(UINT64_C(0x100000001)));
1533   EXPECT_FALSE(IsValueInRangeForNumericType<uint32_t>(
1534       std::numeric_limits<int32_t>::lowest()));
1535   EXPECT_FALSE(IsValueInRangeForNumericType<uint32_t>(
1536       std::numeric_limits<int64_t>::lowest()));
1537
1538   // Converting to integer types will discard the fractional part first, so -0.9
1539   // will be truncated to -0.0.
1540   EXPECT_TRUE(IsValueInRangeForNumericType<uint32_t>(-0.9));
1541   EXPECT_FALSE(IsValueInRangeForNumericType<uint32_t>(-1.0));
1542
1543   EXPECT_TRUE(IsValueInRangeForNumericType<int32_t>(0));
1544   EXPECT_TRUE(IsValueInRangeForNumericType<int32_t>(1));
1545   EXPECT_TRUE(IsValueInRangeForNumericType<int32_t>(2));
1546   EXPECT_TRUE(IsValueInRangeForNumericType<int32_t>(-1));
1547   EXPECT_TRUE(IsValueInRangeForNumericType<int32_t>(0x7fffffff));
1548   EXPECT_TRUE(IsValueInRangeForNumericType<int32_t>(0x7fffffffu));
1549   EXPECT_FALSE(IsValueInRangeForNumericType<int32_t>(0x80000000u));
1550   EXPECT_FALSE(IsValueInRangeForNumericType<int32_t>(0xffffffffu));
1551   EXPECT_FALSE(IsValueInRangeForNumericType<int32_t>(INT64_C(0x80000000)));
1552   EXPECT_FALSE(IsValueInRangeForNumericType<int32_t>(INT64_C(0xffffffff)));
1553   EXPECT_FALSE(IsValueInRangeForNumericType<int32_t>(INT64_C(0x100000000)));
1554   EXPECT_TRUE(IsValueInRangeForNumericType<int32_t>(
1555       std::numeric_limits<int32_t>::lowest()));
1556   EXPECT_TRUE(IsValueInRangeForNumericType<int32_t>(
1557       static_cast<int64_t>(std::numeric_limits<int32_t>::lowest())));
1558   EXPECT_FALSE(IsValueInRangeForNumericType<int32_t>(
1559       static_cast<int64_t>(std::numeric_limits<int32_t>::lowest()) - 1));
1560   EXPECT_FALSE(IsValueInRangeForNumericType<int32_t>(
1561       std::numeric_limits<int64_t>::lowest()));
1562
1563   EXPECT_TRUE(IsValueInRangeForNumericType<uint64_t>(0));
1564   EXPECT_TRUE(IsValueInRangeForNumericType<uint64_t>(1));
1565   EXPECT_TRUE(IsValueInRangeForNumericType<uint64_t>(2));
1566   EXPECT_FALSE(IsValueInRangeForNumericType<uint64_t>(-1));
1567   EXPECT_TRUE(IsValueInRangeForNumericType<uint64_t>(0xffffffffu));
1568   EXPECT_TRUE(IsValueInRangeForNumericType<uint64_t>(UINT64_C(0xffffffff)));
1569   EXPECT_TRUE(IsValueInRangeForNumericType<uint64_t>(UINT64_C(0x100000000)));
1570   EXPECT_TRUE(IsValueInRangeForNumericType<uint64_t>(UINT64_C(0x100000001)));
1571   EXPECT_FALSE(IsValueInRangeForNumericType<uint64_t>(
1572       std::numeric_limits<int32_t>::lowest()));
1573   EXPECT_FALSE(IsValueInRangeForNumericType<uint64_t>(INT64_C(-1)));
1574   EXPECT_FALSE(IsValueInRangeForNumericType<uint64_t>(
1575       std::numeric_limits<int64_t>::lowest()));
1576
1577   // Converting to integer types will discard the fractional part first, so -0.9
1578   // will be truncated to -0.0.
1579   EXPECT_TRUE(IsValueInRangeForNumericType<uint64_t>(-0.9));
1580   EXPECT_FALSE(IsValueInRangeForNumericType<uint64_t>(-1.0));
1581
1582   EXPECT_TRUE(IsValueInRangeForNumericType<int64_t>(0));
1583   EXPECT_TRUE(IsValueInRangeForNumericType<int64_t>(1));
1584   EXPECT_TRUE(IsValueInRangeForNumericType<int64_t>(2));
1585   EXPECT_TRUE(IsValueInRangeForNumericType<int64_t>(-1));
1586   EXPECT_TRUE(IsValueInRangeForNumericType<int64_t>(0x7fffffff));
1587   EXPECT_TRUE(IsValueInRangeForNumericType<int64_t>(0x7fffffffu));
1588   EXPECT_TRUE(IsValueInRangeForNumericType<int64_t>(0x80000000u));
1589   EXPECT_TRUE(IsValueInRangeForNumericType<int64_t>(0xffffffffu));
1590   EXPECT_TRUE(IsValueInRangeForNumericType<int64_t>(INT64_C(0x80000000)));
1591   EXPECT_TRUE(IsValueInRangeForNumericType<int64_t>(INT64_C(0xffffffff)));
1592   EXPECT_TRUE(IsValueInRangeForNumericType<int64_t>(INT64_C(0x100000000)));
1593   EXPECT_TRUE(
1594       IsValueInRangeForNumericType<int64_t>(INT64_C(0x7fffffffffffffff)));
1595   EXPECT_TRUE(
1596       IsValueInRangeForNumericType<int64_t>(UINT64_C(0x7fffffffffffffff)));
1597   EXPECT_FALSE(
1598       IsValueInRangeForNumericType<int64_t>(UINT64_C(0x8000000000000000)));
1599   EXPECT_FALSE(
1600       IsValueInRangeForNumericType<int64_t>(UINT64_C(0xffffffffffffffff)));
1601   EXPECT_TRUE(IsValueInRangeForNumericType<int64_t>(
1602       std::numeric_limits<int32_t>::lowest()));
1603   EXPECT_TRUE(IsValueInRangeForNumericType<int64_t>(
1604       static_cast<int64_t>(std::numeric_limits<int32_t>::lowest())));
1605   EXPECT_TRUE(IsValueInRangeForNumericType<int64_t>(
1606       std::numeric_limits<int64_t>::lowest()));
1607 }
1608
1609 TEST(SafeNumerics, CompoundNumericOperations) {
1610   CheckedNumeric<int> a = 1;
1611   CheckedNumeric<int> b = 2;
1612   CheckedNumeric<int> c = 3;
1613   CheckedNumeric<int> d = 4;
1614   a += b;
1615   EXPECT_EQ(3, a.ValueOrDie());
1616   a -= c;
1617   EXPECT_EQ(0, a.ValueOrDie());
1618   d /= b;
1619   EXPECT_EQ(2, d.ValueOrDie());
1620   d *= d;
1621   EXPECT_EQ(4, d.ValueOrDie());
1622   d *= 0.5;
1623   EXPECT_EQ(2, d.ValueOrDie());
1624
1625   CheckedNumeric<int> too_large = std::numeric_limits<int>::max();
1626   EXPECT_TRUE(too_large.IsValid());
1627   too_large += d;
1628   EXPECT_FALSE(too_large.IsValid());
1629   too_large -= d;
1630   EXPECT_FALSE(too_large.IsValid());
1631   too_large /= d;
1632   EXPECT_FALSE(too_large.IsValid());
1633 }
1634
1635 TEST(SafeNumerics, VariadicNumericOperations) {
1636   {  // Synthetic scope to avoid variable naming collisions.
1637     auto a = CheckAdd(1, 2UL, MakeCheckedNum(3LL), 4).ValueOrDie();
1638     EXPECT_EQ(static_cast<decltype(a)::type>(10), a);
1639     auto b = CheckSub(MakeCheckedNum(20.0), 2UL, 4).ValueOrDie();
1640     EXPECT_EQ(static_cast<decltype(b)::type>(14.0), b);
1641     auto c = CheckMul(20.0, MakeCheckedNum(1), 5, 3UL).ValueOrDie();
1642     EXPECT_EQ(static_cast<decltype(c)::type>(300.0), c);
1643     auto d = CheckDiv(20.0, 2.0, MakeCheckedNum(5LL), -4).ValueOrDie();
1644     EXPECT_EQ(static_cast<decltype(d)::type>(-.5), d);
1645     auto e = CheckMod(MakeCheckedNum(20), 3).ValueOrDie();
1646     EXPECT_EQ(static_cast<decltype(e)::type>(2), e);
1647     auto f = CheckLsh(1, MakeCheckedNum(2)).ValueOrDie();
1648     EXPECT_EQ(static_cast<decltype(f)::type>(4), f);
1649     auto g = CheckRsh(4, MakeCheckedNum(2)).ValueOrDie();
1650     EXPECT_EQ(static_cast<decltype(g)::type>(1), g);
1651     auto h = CheckRsh(CheckAdd(1, 1, 1, 1), CheckSub(4, 2)).ValueOrDie();
1652     EXPECT_EQ(static_cast<decltype(h)::type>(1), h);
1653   }
1654
1655   {
1656     auto a = ClampAdd(1, 2UL, MakeClampedNum(3LL), 4);
1657     EXPECT_EQ(static_cast<decltype(a)::type>(10), a);
1658     auto b = ClampSub(MakeClampedNum(20.0), 2UL, 4);
1659     EXPECT_EQ(static_cast<decltype(b)::type>(14.0), b);
1660     auto c = ClampMul(20.0, MakeClampedNum(1), 5, 3UL);
1661     EXPECT_EQ(static_cast<decltype(c)::type>(300.0), c);
1662     auto d = ClampDiv(20.0, 2.0, MakeClampedNum(5LL), -4);
1663     EXPECT_EQ(static_cast<decltype(d)::type>(-.5), d);
1664     auto e = ClampMod(MakeClampedNum(20), 3);
1665     EXPECT_EQ(static_cast<decltype(e)::type>(2), e);
1666     auto f = ClampLsh(1, MakeClampedNum(2U));
1667     EXPECT_EQ(static_cast<decltype(f)::type>(4), f);
1668     auto g = ClampRsh(4, MakeClampedNum(2U));
1669     EXPECT_EQ(static_cast<decltype(g)::type>(1), g);
1670     auto h = ClampRsh(ClampAdd(1, 1, 1, 1), ClampSub(4U, 2));
1671     EXPECT_EQ(static_cast<decltype(h)::type>(1), h);
1672   }
1673 }
1674
1675 TEST(SafeNumerics, CeilInt) {
1676   constexpr float kMax = static_cast<float>(std::numeric_limits<int>::max());
1677   constexpr float kMin = std::numeric_limits<int>::min();
1678   constexpr float kInfinity = std::numeric_limits<float>::infinity();
1679   constexpr float kNaN = std::numeric_limits<float>::quiet_NaN();
1680
1681   constexpr int kIntMax = std::numeric_limits<int>::max();
1682   constexpr int kIntMin = std::numeric_limits<int>::min();
1683
1684   EXPECT_EQ(kIntMax, ClampCeil(kInfinity));
1685   EXPECT_EQ(kIntMax, ClampCeil(kMax));
1686   EXPECT_EQ(kIntMax, ClampCeil(kMax + 100.0f));
1687   EXPECT_EQ(0, ClampCeil(kNaN));
1688
1689   EXPECT_EQ(-100, ClampCeil(-100.5f));
1690   EXPECT_EQ(0, ClampCeil(0.0f));
1691   EXPECT_EQ(101, ClampCeil(100.5f));
1692
1693   EXPECT_EQ(kIntMin, ClampCeil(-kInfinity));
1694   EXPECT_EQ(kIntMin, ClampCeil(kMin));
1695   EXPECT_EQ(kIntMin, ClampCeil(kMin - 100.0f));
1696   EXPECT_EQ(0, ClampCeil(-kNaN));
1697 }
1698
1699 TEST(SafeNumerics, FloorInt) {
1700   constexpr float kMax = static_cast<float>(std::numeric_limits<int>::max());
1701   constexpr float kMin = std::numeric_limits<int>::min();
1702   constexpr float kInfinity = std::numeric_limits<float>::infinity();
1703   constexpr float kNaN = std::numeric_limits<float>::quiet_NaN();
1704
1705   constexpr int kIntMax = std::numeric_limits<int>::max();
1706   constexpr int kIntMin = std::numeric_limits<int>::min();
1707
1708   EXPECT_EQ(kIntMax, ClampFloor(kInfinity));
1709   EXPECT_EQ(kIntMax, ClampFloor(kMax));
1710   EXPECT_EQ(kIntMax, ClampFloor(kMax + 100.0f));
1711   EXPECT_EQ(0, ClampFloor(kNaN));
1712
1713   EXPECT_EQ(-101, ClampFloor(-100.5f));
1714   EXPECT_EQ(0, ClampFloor(0.0f));
1715   EXPECT_EQ(100, ClampFloor(100.5f));
1716
1717   EXPECT_EQ(kIntMin, ClampFloor(-kInfinity));
1718   EXPECT_EQ(kIntMin, ClampFloor(kMin));
1719   EXPECT_EQ(kIntMin, ClampFloor(kMin - 100.0f));
1720   EXPECT_EQ(0, ClampFloor(-kNaN));
1721 }
1722
1723 TEST(SafeNumerics, RoundInt) {
1724   constexpr float kMax = static_cast<float>(std::numeric_limits<int>::max());
1725   constexpr float kMin = std::numeric_limits<int>::min();
1726   constexpr float kInfinity = std::numeric_limits<float>::infinity();
1727   constexpr float kNaN = std::numeric_limits<float>::quiet_NaN();
1728
1729   constexpr int kIntMax = std::numeric_limits<int>::max();
1730   constexpr int kIntMin = std::numeric_limits<int>::min();
1731
1732   EXPECT_EQ(kIntMax, ClampRound(kInfinity));
1733   EXPECT_EQ(kIntMax, ClampRound(kMax));
1734   EXPECT_EQ(kIntMax, ClampRound(kMax + 100.0f));
1735   EXPECT_EQ(0, ClampRound(kNaN));
1736
1737   EXPECT_EQ(-100, ClampRound(-100.1f));
1738   EXPECT_EQ(-101, ClampRound(-100.5f));
1739   EXPECT_EQ(-101, ClampRound(-100.9f));
1740   EXPECT_EQ(0, ClampRound(0.0f));
1741   EXPECT_EQ(100, ClampRound(100.1f));
1742   EXPECT_EQ(101, ClampRound(100.5f));
1743   EXPECT_EQ(101, ClampRound(100.9f));
1744
1745   EXPECT_EQ(kIntMin, ClampRound(-kInfinity));
1746   EXPECT_EQ(kIntMin, ClampRound(kMin));
1747   EXPECT_EQ(kIntMin, ClampRound(kMin - 100.0f));
1748   EXPECT_EQ(0, ClampRound(-kNaN));
1749 }
1750
1751 TEST(SafeNumerics, Int64) {
1752   constexpr double kMax =
1753       static_cast<double>(std::numeric_limits<int64_t>::max());
1754   constexpr double kMin = std::numeric_limits<int64_t>::min();
1755   constexpr double kInfinity = std::numeric_limits<double>::infinity();
1756   constexpr double kNaN = std::numeric_limits<double>::quiet_NaN();
1757
1758   constexpr int64_t kInt64Max = std::numeric_limits<int64_t>::max();
1759   constexpr int64_t kInt64Min = std::numeric_limits<int64_t>::min();
1760
1761   EXPECT_EQ(kInt64Max, ClampFloor<int64_t>(kInfinity));
1762   EXPECT_EQ(kInt64Max, ClampCeil<int64_t>(kInfinity));
1763   EXPECT_EQ(kInt64Max, ClampRound<int64_t>(kInfinity));
1764   EXPECT_EQ(kInt64Max, ClampFloor<int64_t>(kMax));
1765   EXPECT_EQ(kInt64Max, ClampCeil<int64_t>(kMax));
1766   EXPECT_EQ(kInt64Max, ClampRound<int64_t>(kMax));
1767   EXPECT_EQ(kInt64Max, ClampFloor<int64_t>(kMax + 100.0));
1768   EXPECT_EQ(kInt64Max, ClampCeil<int64_t>(kMax + 100.0));
1769   EXPECT_EQ(kInt64Max, ClampRound<int64_t>(kMax + 100.0));
1770   EXPECT_EQ(0, ClampFloor<int64_t>(kNaN));
1771   EXPECT_EQ(0, ClampCeil<int64_t>(kNaN));
1772   EXPECT_EQ(0, ClampRound<int64_t>(kNaN));
1773
1774   EXPECT_EQ(kInt64Min, ClampFloor<int64_t>(-kInfinity));
1775   EXPECT_EQ(kInt64Min, ClampCeil<int64_t>(-kInfinity));
1776   EXPECT_EQ(kInt64Min, ClampRound<int64_t>(-kInfinity));
1777   EXPECT_EQ(kInt64Min, ClampFloor<int64_t>(kMin));
1778   EXPECT_EQ(kInt64Min, ClampCeil<int64_t>(kMin));
1779   EXPECT_EQ(kInt64Min, ClampRound<int64_t>(kMin));
1780   EXPECT_EQ(kInt64Min, ClampFloor<int64_t>(kMin - 100.0));
1781   EXPECT_EQ(kInt64Min, ClampCeil<int64_t>(kMin - 100.0));
1782   EXPECT_EQ(kInt64Min, ClampRound<int64_t>(kMin - 100.0));
1783   EXPECT_EQ(0, ClampFloor<int64_t>(-kNaN));
1784   EXPECT_EQ(0, ClampCeil<int64_t>(-kNaN));
1785   EXPECT_EQ(0, ClampRound<int64_t>(-kNaN));
1786 }
1787
1788 #if defined(__clang__)
1789 #pragma clang diagnostic pop  // -Winteger-overflow
1790 #endif
1791
1792 }  // namespace internal
1793 }  // namespace base