Base: Make TimeDelta constructors deal with overflow.

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>
@@ skipping 466 matching lines @@
   // Should be 1970-01-01 00:00:01 1 millisecond.
   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, TimeDeltaMax) {
-  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());
-}
-
-TEST_F(TimeTest, TimeDeltaMaxConversions) {
-  TimeDelta t = TimeDelta::Max();
-  EXPECT_EQ(std::numeric_limits<int64>::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<double>::infinity(), t.InMillisecondsF());
-  EXPECT_EQ(std::numeric_limits<int64>::max(), t.InMilliseconds());
-  EXPECT_EQ(std::numeric_limits<int64>::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());
-
-  t = TimeDelta::FromSeconds(std::numeric_limits<int64>::max());
-  EXPECT_TRUE(t.is_max());
-
-  t = TimeDelta::FromMilliseconds(std::numeric_limits<int64>::max());
-  EXPECT_TRUE(t.is_max());
-
-  t = TimeDelta::FromSecondsD(std::numeric_limits<double>::infinity());
-  EXPECT_TRUE(t.is_max());
-
-  t = TimeDelta::FromMillisecondsD(std::numeric_limits<double>::infinity());
-  EXPECT_TRUE(t.is_max());
-
-  t = TimeDelta::FromMicroseconds(std::numeric_limits<int64>::max());
-  EXPECT_TRUE(t.is_max());
-}
-
 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();
@@ skipping 245 matching lines @@
   EXPECT_EQ(13, TimeDelta::FromMinutes(13).InMinutes());
   EXPECT_EQ(13, TimeDelta::FromSeconds(13).InSeconds());
   EXPECT_EQ(13.0, TimeDelta::FromSeconds(13).InSecondsF());
   EXPECT_EQ(13, TimeDelta::FromMilliseconds(13).InMilliseconds());
   EXPECT_EQ(13.0, TimeDelta::FromMilliseconds(13).InMillisecondsF());
   EXPECT_EQ(13, TimeDelta::FromSecondsD(13.1).InSeconds());
   EXPECT_EQ(13.1, TimeDelta::FromSecondsD(13.1).InSecondsF());
   EXPECT_EQ(13, TimeDelta::FromMillisecondsD(13.3).InMilliseconds());
   EXPECT_EQ(13.3, TimeDelta::FromMillisecondsD(13.3).InMillisecondsF());
   EXPECT_EQ(13, TimeDelta::FromMicroseconds(13).InMicroseconds());
+  EXPECT_EQ(3.456, TimeDelta::FromMillisecondsD(3.45678).InMillisecondsF());
 }
 
 #if defined(OS_POSIX)
 TEST(TimeDelta, TimeSpecConversion) {
   struct timespec result = TimeDelta::FromSeconds(0).ToTimeSpec();
   EXPECT_EQ(result.tv_sec, 0);
   EXPECT_EQ(result.tv_nsec, 0);
 
   result = TimeDelta::FromSeconds(1).ToTimeSpec();
   EXPECT_EQ(result.tv_sec, 1);
@@ skipping 53 matching lines @@
             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;
   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<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<double>::infinity(), t.InMillisecondsF());
+  EXPECT_EQ(std::numeric_limits<int64>::max(), t.InMilliseconds());
+  EXPECT_EQ(std::numeric_limits<int64>::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();
+
+  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());
+  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());
+
+  t = TimeDelta::FromMillisecondsD(std::numeric_limits<double>::infinity());
+  EXPECT_TRUE(t.is_max());
+
+  t = TimeDelta::FromMillisecondsD(max_d / Time::kMillisecondsPerSecond * 2);
+  EXPECT_TRUE(t.is_max());
+
+  t = TimeDelta::FromSecondsD(-max_d / Time::kMicrosecondsPerSecond - 1);
+  EXPECT_TRUE(IsMin(t));
+
+  t = TimeDelta::FromMillisecondsD(-max_d / Time::kMillisecondsPerSecond * 2);
+  EXPECT_TRUE(IsMin(t));
+}
 
 TEST(TimeDelta, NumericOperators) {
   double d = 0.5;
   EXPECT_EQ(TimeDelta::FromMilliseconds(500),
             TimeDelta::FromMilliseconds(1000) * d);
   EXPECT_EQ(TimeDelta::FromMilliseconds(2000),
             TimeDelta::FromMilliseconds(1000) / d);
   EXPECT_EQ(TimeDelta::FromMilliseconds(500),
             TimeDelta::FromMilliseconds(1000) *= d);
   EXPECT_EQ(TimeDelta::FromMilliseconds(2000),
             TimeDelta::FromMilliseconds(1000) /= d);
   EXPECT_EQ(TimeDelta::FromMilliseconds(500),
             d * TimeDelta::FromMilliseconds(1000));
 
   float f = 0.5;
   EXPECT_EQ(TimeDelta::FromMilliseconds(500),
             TimeDelta::FromMilliseconds(1000) * f);
   EXPECT_EQ(TimeDelta::FromMilliseconds(2000),
             TimeDelta::FromMilliseconds(1000) / f);
   EXPECT_EQ(TimeDelta::FromMilliseconds(500),
             TimeDelta::FromMilliseconds(1000) *= f);
   EXPECT_EQ(TimeDelta::FromMilliseconds(2000),
             TimeDelta::FromMilliseconds(1000) /= f);
   EXPECT_EQ(TimeDelta::FromMilliseconds(500),
             f * TimeDelta::FromMilliseconds(1000));
 
-
   int i = 2;
   EXPECT_EQ(TimeDelta::FromMilliseconds(2000),
             TimeDelta::FromMilliseconds(1000) * i);
   EXPECT_EQ(TimeDelta::FromMilliseconds(500),
             TimeDelta::FromMilliseconds(1000) / i);
   EXPECT_EQ(TimeDelta::FromMilliseconds(2000),
             TimeDelta::FromMilliseconds(1000) *= i);
   EXPECT_EQ(TimeDelta::FromMilliseconds(500),
             TimeDelta::FromMilliseconds(1000) /= i);
   EXPECT_EQ(TimeDelta::FromMilliseconds(2000),
             i * TimeDelta::FromMilliseconds(1000));
 
   int64_t i64 = 2;
   EXPECT_EQ(TimeDelta::FromMilliseconds(2000),
             TimeDelta::FromMilliseconds(1000) * i64);
   EXPECT_EQ(TimeDelta::FromMilliseconds(500),
             TimeDelta::FromMilliseconds(1000) / i64);
   EXPECT_EQ(TimeDelta::FromMilliseconds(2000),
             TimeDelta::FromMilliseconds(1000) *= i64);
   EXPECT_EQ(TimeDelta::FromMilliseconds(500),
             TimeDelta::FromMilliseconds(1000) /= i64);
   EXPECT_EQ(TimeDelta::FromMilliseconds(2000),
             i64 * TimeDelta::FromMilliseconds(1000));
 
-
   EXPECT_EQ(TimeDelta::FromMilliseconds(500),
             TimeDelta::FromMilliseconds(1000) * 0.5);
   EXPECT_EQ(TimeDelta::FromMilliseconds(2000),
             TimeDelta::FromMilliseconds(1000) / 0.5);
   EXPECT_EQ(TimeDelta::FromMilliseconds(500),
             TimeDelta::FromMilliseconds(1000) *= 0.5);
   EXPECT_EQ(TimeDelta::FromMilliseconds(2000),
             TimeDelta::FromMilliseconds(1000) /= 0.5);
   EXPECT_EQ(TimeDelta::FromMilliseconds(500),
             0.5 * TimeDelta::FromMilliseconds(1000));
 
   EXPECT_EQ(TimeDelta::FromMilliseconds(2000),
             TimeDelta::FromMilliseconds(1000) * 2);
   EXPECT_EQ(TimeDelta::FromMilliseconds(500),
             TimeDelta::FromMilliseconds(1000) / 2);
   EXPECT_EQ(TimeDelta::FromMilliseconds(2000),
             TimeDelta::FromMilliseconds(1000) *= 2);
   EXPECT_EQ(TimeDelta::FromMilliseconds(500),
             TimeDelta::FromMilliseconds(1000) /= 2);
   EXPECT_EQ(TimeDelta::FromMilliseconds(2000),
             2 * TimeDelta::FromMilliseconds(1000));
 }
 
-bool IsMin(TimeDelta delta) {
-  return (-delta).is_max();
-}
-
 TEST(TimeDelta, Overflows) {
   // Some sanity checks.
   EXPECT_TRUE(TimeDelta::Max().is_max());
   EXPECT_TRUE(IsMin(-TimeDelta::Max()));
   EXPECT_GT(TimeDelta(), -TimeDelta::Max());
 
   TimeDelta large_delta = TimeDelta::Max() - TimeDelta::FromMilliseconds(1);
   TimeDelta large_negative = -large_delta;
   EXPECT_GT(TimeDelta(), large_negative);
   EXPECT_FALSE(large_delta.is_max());
@@ skipping 134 matching lines @@
 
 TEST(TimeTicksLogging, DoesNotMakeStreamBad) {
   std::ostringstream oss;
   oss << TimeTicks();
   EXPECT_TRUE(oss.good());
 }
 
 }  // namespace
 
 }  // namespace base