Fixing Time::Max()'s behavior with Time::ToTimeT() and friends.

base/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.h"
 
 #include <time.h>
 
 #include "base/compiler_specific.h"
 #include "base/threading/platform_thread.h"
@@ skipping 68 matching lines @@
 
   time_t now_t_2 = our_time_2.ToTimeT();
   EXPECT_EQ(now_t_1, now_t_2);
 
   EXPECT_EQ(10, Time().FromTimeT(10).ToTimeT());
   EXPECT_EQ(10.0, Time().FromTimeT(10).ToDoubleT());
 
   // Conversions of 0 should stay 0.
   EXPECT_EQ(0, Time().ToTimeT());
   EXPECT_EQ(0, Time::FromTimeT(0).ToInternalValue());
+
+  // Conversions of Max() should stay max.
+  EXPECT_EQ(std::numeric_limits<time_t>::max(), Time::Max().ToTimeT());
+  EXPECT_EQ(std::numeric_limits<time_t>::max(),
+      Time().FromTimeT(std::numeric_limits<time_t>::max()).ToTimeT());
+  EXPECT_EQ(std::numeric_limits<int64>::max(),
+      Time::FromTimeT(std::numeric_limits<time_t>::max()).ToInternalValue());
 }
 
 // Test conversions to/from javascript time.
 TEST_F(TimeTest, JsTime) {
   Time epoch = Time::FromJsTime(0.0);
   EXPECT_EQ(epoch, Time::UnixEpoch());
   Time t = Time::FromJsTime(700000.3);
   EXPECT_EQ(700.0003, t.ToDoubleT());
   t = Time::FromDoubleT(800.73);
   EXPECT_EQ(800730.0, t.ToJsTime());
+
+  // Conversions of Max() should stay max.
+  t = Time::FromJsTime(std::numeric_limits<double>::max());
+  EXPECT_TRUE(t.is_max());
+  t = Time::Max();
+  EXPECT_EQ(std::numeric_limits<double>::max(), t.ToDoubleT());
 }
 
 #if defined(OS_POSIX)
 TEST_F(TimeTest, FromTimeVal) {
   Time now = Time::Now();
   Time also_now = Time::FromTimeVal(now.ToTimeVal());
   EXPECT_EQ(now, also_now);
 }
 #endif  // OS_POSIX
 
@@ skipping 364 matching lines @@
   EXPECT_EQ(kUnixEpochYear, exploded.year);
   EXPECT_EQ(1, exploded.month);
   EXPECT_EQ(1, exploded.day_of_month);
   EXPECT_EQ(0, exploded.hour);
   EXPECT_EQ(0, exploded.minute);
   EXPECT_EQ(1, exploded.second);
   EXPECT_EQ(1, exploded.millisecond);
 }
 
 TEST_F(TimeTest, Max) {
-  EXPECT_EQ(base::Time::Max(), base::Time::Max());
-  EXPECT_GT(base::Time::Max(), base::Time::Now());
-  EXPECT_GT(base::Time::Max(), base::Time());
+  Time max = Time::Max();
+  EXPECT_TRUE(max.is_max());
+  EXPECT_EQ(max, Time::Max());
+  EXPECT_GT(max, Time::Now());
+  EXPECT_GT(max, Time());
 }
 
 TEST(TimeTicks, Deltas) {
   for (int index = 0; index < 50; index++) {
     TimeTicks ticks_start = TimeTicks::Now();
     base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(10));
     TimeTicks ticks_stop = TimeTicks::Now();
     TimeDelta delta = ticks_stop - ticks_start;
     // Note:  Although we asked for a 10ms sleep, if the
     // time clock has a finer granularity than the Sleep()
@@ skipping 115 matching lines @@
   exploded.minute = 0;
   exploded.second = 0;
   exploded.millisecond = 0;
   Time t = Time::FromUTCExploded(exploded);
   // Unix 1970 epoch.
   EXPECT_EQ(GG_INT64_C(11644473600000000), t.ToInternalValue());
 
   // We can't test 1601 epoch, since the system time functions on Linux
   // only compute years starting from 1900.
 }