Remove kuint64max.

net/base/int128_unittest.cc

 // Copyright (c) 2012 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 "base/basictypes.h"
+#include <limits>
+
 #include "base/logging.h"
 #include "net/base/int128.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
-
 TEST(Int128, AllTests) {
   uint128 zero(0);
   uint128 one(1);
   uint128 one_2arg(0, 1);
   uint128 two(0, 2);
   uint128 three(0, 3);
   uint128 big(2000, 2);
   uint128 big_minus_one(2000, 1);
   uint128 bigger(2001, 1);
   uint128 biggest(kuint128max);
   uint128 high_low(1, 0);
-  uint128 low_high(0, kuint64max);
+  uint128 low_high(0, std::numeric_limits<uint64_t>::max());

[mmenke, 2015/12/07 16:06:51]

Should probably include stdint.h in this file, too.

[Avi (use Gerrit), 2015/12/07 16:30:06]

Done.

   EXPECT_LT(one, two);
   EXPECT_GT(two, one);
   EXPECT_LT(one, big);
   EXPECT_LT(one, big);
   EXPECT_EQ(one, one_2arg);
   EXPECT_NE(one, two);
   EXPECT_GT(big, one);
   EXPECT_GE(big, two);
   EXPECT_GE(big, big_minus_one);
   EXPECT_GT(big, big_minus_one);
@@ skipping 18 matching lines @@
   EXPECT_EQ(big, big << 0);
   EXPECT_EQ(big, big >> 0);
   EXPECT_GT(big << 1, big);
   EXPECT_LT(big >> 1, big);
   EXPECT_EQ(big, (big << 10) >> 10);
   EXPECT_EQ(big, (big >> 1) << 1);
   EXPECT_EQ(one, (one << 80) >> 80);
   EXPECT_EQ(zero, (one >> 80) << 80);
   EXPECT_EQ(zero, big >> 128);
   EXPECT_EQ(zero, big << 128);
-  EXPECT_EQ(Uint128High64(biggest), kuint64max);
-  EXPECT_EQ(Uint128Low64(biggest), kuint64max);
+  EXPECT_EQ(Uint128High64(biggest), std::numeric_limits<uint64_t>::max());
+  EXPECT_EQ(Uint128Low64(biggest), std::numeric_limits<uint64_t>::max());
   EXPECT_EQ(zero + one, one);
   EXPECT_EQ(one + one, two);
   EXPECT_EQ(big_minus_one + one, big);
   EXPECT_EQ(one - one, zero);
   EXPECT_EQ(one - zero, one);
   EXPECT_EQ(zero - one, biggest);
   EXPECT_EQ(big - big, zero);
   EXPECT_EQ(big - one, big_minus_one);
-  EXPECT_EQ(big + kuint64max, bigger);
+  EXPECT_EQ(big + std::numeric_limits<uint64_t>::max(), bigger);
   EXPECT_EQ(biggest + 1, zero);
   EXPECT_EQ(zero - 1, biggest);
   EXPECT_EQ(high_low - one, low_high);
   EXPECT_EQ(low_high + one, high_low);
   EXPECT_EQ(Uint128High64((uint128(1) << 64) - 1), 0u);
-  EXPECT_EQ(Uint128Low64((uint128(1) << 64) - 1), kuint64max);
+  EXPECT_EQ(Uint128Low64((uint128(1) << 64) - 1),
+            std::numeric_limits<uint64_t>::max());
   EXPECT_TRUE(!!one);
   EXPECT_TRUE(!!high_low);
   EXPECT_FALSE(!!zero);
   EXPECT_FALSE(!one);
   EXPECT_FALSE(!high_low);
   EXPECT_TRUE(!zero);
   EXPECT_TRUE(zero == 0);
   EXPECT_FALSE(zero != 0);
   EXPECT_FALSE(one == 0);
   EXPECT_TRUE(one != 0);
@@ skipping 162 matching lines @@
   uint128 x1(1, 2);
   uint128 x2(2, 4);
   x1 += x1;
   EXPECT_EQ(x2, x1);
 
   uint128 x3(1, 1ull << 63);
   uint128 x4(3, 0);
   x3 += x3;
   EXPECT_EQ(x4, x3);
 }