Allow constexpr variables of TimeDelta type.

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 705 matching lines @@
       base::TimeTicks::FromInternalValue(8635916564000);
 
   EXPECT_EQ(8635916564000,
             big_timestamp.SnappedToNextTick(phase, interval).ToInternalValue());
   EXPECT_EQ(8635916564000,
             big_timestamp.SnappedToNextTick(big_timestamp, interval)
                 .ToInternalValue());
 }
 
 TEST(TimeDelta, FromAndIn) {
-  EXPECT_TRUE(TimeDelta::FromDays(2) == TimeDelta::FromHours(48));
-  EXPECT_TRUE(TimeDelta::FromHours(3) == TimeDelta::FromMinutes(180));
-  EXPECT_TRUE(TimeDelta::FromMinutes(2) == TimeDelta::FromSeconds(120));
-  EXPECT_TRUE(TimeDelta::FromSeconds(2) == TimeDelta::FromMilliseconds(2000));
-  EXPECT_TRUE(TimeDelta::FromMilliseconds(2) ==
-              TimeDelta::FromMicroseconds(2000));
-  EXPECT_TRUE(TimeDelta::FromSecondsD(2.3) ==
-              TimeDelta::FromMilliseconds(2300));
-  EXPECT_TRUE(TimeDelta::FromMillisecondsD(2.5) ==
-              TimeDelta::FromMicroseconds(2500));
+  // static_assert also checks that the contained expression is a constant
+  // expression, meaning all its components are suitable for initializing global
+  // variables.
+  static_assert(TimeDelta::FromDays(2) == TimeDelta::FromHours(48), "");
+  static_assert(TimeDelta::FromHours(3) == TimeDelta::FromMinutes(180), "");
+  static_assert(TimeDelta::FromMinutes(2) == TimeDelta::FromSeconds(120), "");
+  static_assert(TimeDelta::FromSeconds(2) == TimeDelta::FromMilliseconds(2000),
+                "");
+  static_assert(
+      TimeDelta::FromMilliseconds(2) == TimeDelta::FromMicroseconds(2000), "");
+  static_assert(
+      TimeDelta::FromSecondsD(2.3) == TimeDelta::FromMilliseconds(2300), "");
+  static_assert(
+      TimeDelta::FromMillisecondsD(2.5) == TimeDelta::FromMicroseconds(2500),
+      "");
   EXPECT_EQ(13, TimeDelta::FromDays(13).InDays());
   EXPECT_EQ(13, TimeDelta::FromHours(13).InHours());
   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());
@@ skipping 102 matching lines @@
   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_t max_int = std::numeric_limits<int64_t>::max();
 
+  t = TimeDelta::FromSeconds(max_int / Time::kMicrosecondsPerSecond);
+  EXPECT_FALSE(t.is_max());
   t = TimeDelta::FromSeconds(max_int / Time::kMicrosecondsPerSecond + 1);
   EXPECT_TRUE(t.is_max());
 
+  t = TimeDelta::FromMilliseconds(max_int / Time::kMillisecondsPerSecond);
+  EXPECT_FALSE(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);
+  EXPECT_FALSE(IsMin(t));
   t = TimeDelta::FromSeconds(-max_int / Time::kMicrosecondsPerSecond - 1);
   EXPECT_TRUE(IsMin(t));
 
+  t = TimeDelta::FromMilliseconds(-max_int / Time::kMillisecondsPerSecond);
+  EXPECT_FALSE(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_t>::min());
   EXPECT_FALSE(IsMin(t));
 
   t = TimeDelta::FromSecondsD(std::numeric_limits<double>::infinity());
   EXPECT_TRUE(t.is_max());
 
   double max_d = max_int;
+  // Converting max_int to double changes its value.
+  EXPECT_EQ(pow(2.0, 63), max_d);
 
-  t = TimeDelta::FromSecondsD(max_d / Time::kMicrosecondsPerSecond + 1);
+  t = TimeDelta::FromSecondsD(max_d / Time::kMicrosecondsPerSecond);
   EXPECT_TRUE(t.is_max());
+  t = TimeDelta::FromSecondsD(
+      nexttoward(max_d / Time::kMicrosecondsPerSecond, 0));
+  EXPECT_FALSE(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::FromMillisecondsD(max_d / Time::kMillisecondsPerSecond);
+  EXPECT_TRUE(t.is_max()) << t;
+  t = TimeDelta::FromMillisecondsD(
+      nexttoward(max_d / Time::kMillisecondsPerSecond, 0));
+  EXPECT_FALSE(t.is_max());
 
-  t = TimeDelta::FromSecondsD(-max_d / Time::kMicrosecondsPerSecond - 1);
+  t = TimeDelta::FromSecondsD(-max_d / Time::kMicrosecondsPerSecond);
   EXPECT_TRUE(IsMin(t));
+  t = TimeDelta::FromSecondsD(
+      nexttoward(-max_d / Time::kMicrosecondsPerSecond, 0));
+  EXPECT_FALSE(IsMin(t));
 
-  t = TimeDelta::FromMillisecondsD(-max_d / Time::kMillisecondsPerSecond * 2);
-  EXPECT_TRUE(IsMin(t));
+  t = TimeDelta::FromMillisecondsD(-max_d / Time::kMillisecondsPerSecond);
+  EXPECT_TRUE(IsMin(t)) << t;
+  t = TimeDelta::FromMillisecondsD(
+      nexttoward(-max_d / Time::kMillisecondsPerSecond, 0));
+  EXPECT_FALSE(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);
@@ skipping 208 matching lines @@
 
 TEST(TimeTicksLogging, DoesNotMakeStreamBad) {
   std::ostringstream oss;
   oss << TimeTicks();
   EXPECT_TRUE(oss.good());
 }
 
 }  // namespace
 
 }  // namespace base