Switch to standard integer types in base/.

base/time/time_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/time/time.h"
 
 #include <stdint.h>
 #include <time.h>
 #include <limits>
 #include <string>
 
 #include "base/compiler_specific.h"
 #include "base/logging.h"
+#include "base/macros.h"
 #include "base/strings/stringprintf.h"
 #include "base/threading/platform_thread.h"
 #include "build/build_config.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace base {
 
 namespace {
 
 // Specialized test fixture allowing time strings without timezones to be
@@ skipping 463 matching lines @@
 TEST_F(TimeTest, Max) {
   Time max = Time::Max();
   EXPECT_TRUE(max.is_max());
   EXPECT_EQ(max, Time::Max());
   EXPECT_GT(max, Time::Now());
   EXPECT_GT(max, Time());
 }
 
 TEST_F(TimeTest, MaxConversions) {
   Time t = Time::Max();
-  EXPECT_EQ(std::numeric_limits<int64>::max(), t.ToInternalValue());
+  EXPECT_EQ(std::numeric_limits<int64_t>::max(), t.ToInternalValue());
 
   t = Time::FromDoubleT(std::numeric_limits<double>::infinity());
   EXPECT_TRUE(t.is_max());
   EXPECT_EQ(std::numeric_limits<double>::infinity(), t.ToDoubleT());
 
   t = Time::FromJsTime(std::numeric_limits<double>::infinity());
   EXPECT_TRUE(t.is_max());
   EXPECT_EQ(std::numeric_limits<double>::infinity(), t.ToJsTime());
 
   t = Time::FromTimeT(std::numeric_limits<time_t>::max());
@@ skipping 26 matching lines @@
   t = Time::FromFileTime(ftime);
   EXPECT_TRUE(t.is_max());
   ftime = t.ToFileTime();
   EXPECT_EQ(std::numeric_limits<DWORD>::max(), ftime.dwHighDateTime);
   EXPECT_EQ(std::numeric_limits<DWORD>::max(), ftime.dwLowDateTime);
 #endif
 }
 
 #if defined(OS_MACOSX)
 TEST_F(TimeTest, TimeTOverflow) {
-  Time t = Time::FromInternalValue(std::numeric_limits<int64>::max() - 1);
+  Time t = Time::FromInternalValue(std::numeric_limits<int64_t>::max() - 1);
   EXPECT_FALSE(t.is_max());
   EXPECT_EQ(std::numeric_limits<time_t>::max(), t.ToTimeT());
 }
 #endif
 
 #if defined(OS_ANDROID)
 TEST_F(TimeTest, FromLocalExplodedCrashOnAndroid) {
   // This crashed inside Time:: FromLocalExploded() on Android 4.1.2.
   // See http://crbug.com/287821
   Time::Exploded midnight = {2013,  // year
@@ skipping 237 matching lines @@
 // We could define this separately for Time, TimeTicks and TimeDelta but the
 // definitions would be identical anyway.
 template <class Any>
 std::string AnyToString(Any any) {
   std::ostringstream oss;
   oss << any;
   return oss.str();
 }
 
 TEST(TimeDelta, Magnitude) {
-  const int64 zero = 0;
+  const int64_t zero = 0;
   EXPECT_EQ(TimeDelta::FromMicroseconds(zero),
             TimeDelta::FromMicroseconds(zero).magnitude());
 
-  const int64 one = 1;
-  const int64 negative_one = -1;
+  const int64_t one = 1;
+  const int64_t negative_one = -1;
   EXPECT_EQ(TimeDelta::FromMicroseconds(one),
             TimeDelta::FromMicroseconds(one).magnitude());
   EXPECT_EQ(TimeDelta::FromMicroseconds(one),
             TimeDelta::FromMicroseconds(negative_one).magnitude());
 
-  const int64 max_int64_minus_one = std::numeric_limits<int64>::max() - 1;
-  const int64 min_int64_plus_two = std::numeric_limits<int64>::min() + 2;
+  const int64_t max_int64_minus_one = std::numeric_limits<int64_t>::max() - 1;
+  const int64_t min_int64_plus_two = std::numeric_limits<int64_t>::min() + 2;
   EXPECT_EQ(TimeDelta::FromMicroseconds(max_int64_minus_one),
             TimeDelta::FromMicroseconds(max_int64_minus_one).magnitude());
   EXPECT_EQ(TimeDelta::FromMicroseconds(max_int64_minus_one),
             TimeDelta::FromMicroseconds(min_int64_plus_two).magnitude());
 }
 
 TEST(TimeDelta, Max) {
   TimeDelta max = TimeDelta::Max();
   EXPECT_TRUE(max.is_max());
   EXPECT_EQ(max, TimeDelta::Max());
   EXPECT_GT(max, TimeDelta::FromDays(100 * 365));
   EXPECT_GT(max, TimeDelta());
 }
 
 bool IsMin(TimeDelta delta) {
   return (-delta).is_max();
 }
 
 TEST(TimeDelta, MaxConversions) {
   TimeDelta t = TimeDelta::Max();
-  EXPECT_EQ(std::numeric_limits<int64>::max(), t.ToInternalValue());
+  EXPECT_EQ(std::numeric_limits<int64_t>::max(), t.ToInternalValue());
 
   EXPECT_EQ(std::numeric_limits<int>::max(), t.InDays());
   EXPECT_EQ(std::numeric_limits<int>::max(), t.InHours());
   EXPECT_EQ(std::numeric_limits<int>::max(), t.InMinutes());
   EXPECT_EQ(std::numeric_limits<double>::infinity(), t.InSecondsF());
-  EXPECT_EQ(std::numeric_limits<int64>::max(), t.InSeconds());
+  EXPECT_EQ(std::numeric_limits<int64_t>::max(), t.InSeconds());
   EXPECT_EQ(std::numeric_limits<double>::infinity(), t.InMillisecondsF());
-  EXPECT_EQ(std::numeric_limits<int64>::max(), t.InMilliseconds());
-  EXPECT_EQ(std::numeric_limits<int64>::max(), t.InMillisecondsRoundedUp());
+  EXPECT_EQ(std::numeric_limits<int64_t>::max(), t.InMilliseconds());
+  EXPECT_EQ(std::numeric_limits<int64_t>::max(), t.InMillisecondsRoundedUp());
 
   t = TimeDelta::FromDays(std::numeric_limits<int>::max());
   EXPECT_TRUE(t.is_max());
 
   t = TimeDelta::FromHours(std::numeric_limits<int>::max());
   EXPECT_TRUE(t.is_max());
 
   t = TimeDelta::FromMinutes(std::numeric_limits<int>::max());
   EXPECT_TRUE(t.is_max());
 
-  int64 max_int = std::numeric_limits<int64>::max();
+  int64_t max_int = std::numeric_limits<int64_t>::max();
 
   t = TimeDelta::FromSeconds(max_int / Time::kMicrosecondsPerSecond + 1);
   EXPECT_TRUE(t.is_max());
 
   t = TimeDelta::FromMilliseconds(max_int / Time::kMillisecondsPerSecond + 1);
   EXPECT_TRUE(t.is_max());
 
   t = TimeDelta::FromMicroseconds(max_int);
   EXPECT_TRUE(t.is_max());
 
   t = TimeDelta::FromSeconds(-max_int / Time::kMicrosecondsPerSecond - 1);
   EXPECT_TRUE(IsMin(t));
 
   t = TimeDelta::FromMilliseconds(-max_int / Time::kMillisecondsPerSecond - 1);
   EXPECT_TRUE(IsMin(t));
 
   t = TimeDelta::FromMicroseconds(-max_int);
   EXPECT_TRUE(IsMin(t));
 
-  t = -TimeDelta::FromMicroseconds(std::numeric_limits<int64>::min());
+  t = -TimeDelta::FromMicroseconds(std::numeric_limits<int64_t>::min());
   EXPECT_FALSE(IsMin(t));
 
   t = TimeDelta::FromSecondsD(std::numeric_limits<double>::infinity());
   EXPECT_TRUE(t.is_max());
 
   double max_d = max_int;
 
   t = TimeDelta::FromSecondsD(max_d / Time::kMicrosecondsPerSecond + 1);
   EXPECT_TRUE(t.is_max());
 
@@ skipping 229 matching lines @@
 
 TEST(TimeTicksLogging, DoesNotMakeStreamBad) {
   std::ostringstream oss;
   oss << TimeTicks();
   EXPECT_TRUE(oss.good());
 }
 
 }  // namespace
 
 }  // namespace base