1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4
5 #include "base/time/time.h"
6
7 #include <stdint.h>
8 #include <time.h>
9
10 #include <limits>
11 #include <string>
12
13 #include "base/build_time.h"
14 #include "base/check_op.h"
15 #include "base/compiler_specific.h"
16 #include "base/stl_util.h"
17 #include "base/strings/stringprintf.h"
18 #include "base/test/gtest_util.h"
19 #include "base/threading/platform_thread.h"
20 #include "base/time/time_override.h"
21 #include "build/build_config.h"
22 #include "testing/gmock/include/gmock/gmock.h"
23 #include "testing/gtest/include/gtest/gtest.h"
24
25 #if defined(OS_ANDROID)
26 #include "base/android/jni_android.h"
27 #elif defined(OS_FUCHSIA)
28 #include "base/test/icu_test_util.h"
29 #elif defined(OS_WIN)
30 #include <windows.h>
31 #endif
32
33 namespace base {
34
35 namespace {
36
37 #if defined(OS_FUCHSIA)
38 // Hawaii does not observe daylight saving time, which is useful for having a
39 // constant offset when faking the time zone.
40 const char kHonoluluTimeZoneId[] = "Pacific/Honolulu";
41 const int kHonoluluOffsetHours = -10;
42 const int kHonoluluOffsetSeconds = kHonoluluOffsetHours * 60 * 60;
43 #endif
44
TEST(TimeTestOutOfBounds,FromExplodedOutOfBoundsTime)45 TEST(TimeTestOutOfBounds, FromExplodedOutOfBoundsTime) {
46 // FromUTCExploded must set time to Time(0) and failure, if the day is set to
47 // 31 on a 28-30 day month. Test |exploded| returns Time(0) on 31st of
48 // February and 31st of April. New implementation handles this.
49
50 const struct DateTestData {
51 Time::Exploded explode;
52 bool is_valid;
53 } kDateTestData[] = {
54 // 31st of February
55 {{2016, 2, 0, 31, 12, 30, 0, 0}, true},
56 // 31st of April
57 {{2016, 4, 0, 31, 8, 43, 0, 0}, true},
58 // Negative month
59 {{2016, -5, 0, 2, 4, 10, 0, 0}, false},
60 // Negative date of month
61 {{2016, 6, 0, -15, 2, 50, 0, 0}, false},
62 // Negative hours
63 {{2016, 7, 0, 10, -11, 29, 0, 0}, false},
64 // Negative minutes
65 {{2016, 3, 0, 14, 10, -29, 0, 0}, false},
66 // Negative seconds
67 {{2016, 10, 0, 25, 7, 47, -30, 0}, false},
68 // Negative milliseconds
69 {{2016, 10, 0, 25, 7, 47, 20, -500}, false},
70 // Hours are too large
71 {{2016, 7, 0, 10, 26, 29, 0, 0}, false},
72 // Minutes are too large
73 {{2016, 3, 0, 14, 10, 78, 0, 0}, false},
74 // Seconds are too large
75 {{2016, 10, 0, 25, 7, 47, 234, 0}, false},
76 // Milliseconds are too large
77 {{2016, 10, 0, 25, 6, 31, 23, 1643}, false},
78 // Test overflow. Time is valid, but overflow case
79 // results in Time(0).
80 {{9840633, 1, 0, 1, 1, 1, 0, 0}, true},
81 // Underflow will fail as well.
82 {{-9840633, 1, 0, 1, 1, 1, 0, 0}, true},
83 // Test integer overflow and underflow cases for the values themselves.
84 {{std::numeric_limits<int>::min(), 1, 0, 1, 1, 1, 0, 0}, true},
85 {{std::numeric_limits<int>::max(), 1, 0, 1, 1, 1, 0, 0}, true},
86 {{2016, std::numeric_limits<int>::min(), 0, 1, 1, 1, 0, 0}, false},
87 {{2016, std::numeric_limits<int>::max(), 0, 1, 1, 1, 0, 0}, false},
88 };
89
90 for (const auto& test : kDateTestData) {
91 EXPECT_EQ(test.explode.HasValidValues(), test.is_valid);
92
93 base::Time result;
94 EXPECT_FALSE(base::Time::FromUTCExploded(test.explode, &result));
95 EXPECT_TRUE(result.is_null());
96 EXPECT_FALSE(base::Time::FromLocalExploded(test.explode, &result));
97 EXPECT_TRUE(result.is_null());
98 }
99 }
100
101 // Specialized test fixture allowing time strings without timezones to be
102 // tested by comparing them to a known time in the local zone.
103 // See also pr_time_unittests.cc
104 class TimeTest : public testing::Test {
105 protected:
106 #if defined(OS_FUCHSIA)
107 // POSIX local time functions always use UTC on Fuchsia. As this is not very
108 // interesting for any "local" tests, set a different default ICU timezone for
109 // the test. This only affects code that uses ICU, such as Exploded time.
110 // Chicago is a non-Pacific time zone known to observe daylight saving time.
TimeTest()111 TimeTest() : chicago_time_("America/Chicago") {}
112 test::ScopedRestoreDefaultTimezone chicago_time_;
113 #endif
114
SetUp()115 void SetUp() override {
116 // Use mktime to get a time_t, and turn it into a PRTime by converting
117 // seconds to microseconds. Use 15th Oct 2007 12:45:00 local. This
118 // must be a time guaranteed to be outside of a DST fallback hour in
119 // any timezone.
120 struct tm local_comparison_tm = {
121 0, // second
122 45, // minute
123 12, // hour
124 15, // day of month
125 10 - 1, // month
126 2007 - 1900, // year
127 0, // day of week (ignored, output only)
128 0, // day of year (ignored, output only)
129 -1 // DST in effect, -1 tells mktime to figure it out
130 };
131
132 time_t converted_time = mktime(&local_comparison_tm);
133 ASSERT_GT(converted_time, 0);
134 comparison_time_local_ = Time::FromTimeT(converted_time);
135
136 // time_t representation of 15th Oct 2007 12:45:00 PDT
137 comparison_time_pdt_ = Time::FromTimeT(1192477500);
138 }
139
140 Time comparison_time_local_;
141 Time comparison_time_pdt_;
142 };
143
144 // Test conversion to/from TimeDeltas elapsed since the Windows epoch.
145 // Conversions should be idempotent and non-lossy.
TEST_F(TimeTest,DeltaSinceWindowsEpoch)146 TEST_F(TimeTest, DeltaSinceWindowsEpoch) {
147 const TimeDelta delta = TimeDelta::FromMicroseconds(123);
148 EXPECT_EQ(delta,
149 Time::FromDeltaSinceWindowsEpoch(delta).ToDeltaSinceWindowsEpoch());
150
151 const Time now = Time::Now();
152 const Time actual =
153 Time::FromDeltaSinceWindowsEpoch(now.ToDeltaSinceWindowsEpoch());
154 EXPECT_EQ(now, actual);
155
156 // Null times should remain null after a round-trip conversion. This is an
157 // important invariant for the common use case of serialization +
158 // deserialization.
159 const Time should_be_null =
160 Time::FromDeltaSinceWindowsEpoch(Time().ToDeltaSinceWindowsEpoch());
161 EXPECT_TRUE(should_be_null.is_null());
162 }
163
164 // Test conversion to/from time_t.
TEST_F(TimeTest,TimeT)165 TEST_F(TimeTest, TimeT) {
166 EXPECT_EQ(10, Time().FromTimeT(10).ToTimeT());
167 EXPECT_EQ(10.0, Time().FromTimeT(10).ToDoubleT());
168
169 // Conversions of 0 should stay 0.
170 EXPECT_EQ(0, Time().ToTimeT());
171 EXPECT_EQ(0, Time::FromTimeT(0).ToInternalValue());
172 }
173
174 // Test conversions to/from time_t and exploding/unexploding (utc time).
TEST_F(TimeTest,UTCTimeT)175 TEST_F(TimeTest, UTCTimeT) {
176 // C library time and exploded time.
177 time_t now_t_1 = time(nullptr);
178 struct tm tms;
179 #if defined(OS_WIN)
180 gmtime_s(&tms, &now_t_1);
181 #elif defined(OS_POSIX) || defined(OS_FUCHSIA)
182 gmtime_r(&now_t_1, &tms);
183 #endif
184
185 // Convert to ours.
186 Time our_time_1 = Time::FromTimeT(now_t_1);
187 Time::Exploded exploded;
188 our_time_1.UTCExplode(&exploded);
189
190 // This will test both our exploding and our time_t -> Time conversion.
191 EXPECT_EQ(tms.tm_year + 1900, exploded.year);
192 EXPECT_EQ(tms.tm_mon + 1, exploded.month);
193 EXPECT_EQ(tms.tm_mday, exploded.day_of_month);
194 EXPECT_EQ(tms.tm_hour, exploded.hour);
195 EXPECT_EQ(tms.tm_min, exploded.minute);
196 EXPECT_EQ(tms.tm_sec, exploded.second);
197
198 // Convert exploded back to the time struct.
199 Time our_time_2;
200 EXPECT_TRUE(Time::FromUTCExploded(exploded, &our_time_2));
201 EXPECT_TRUE(our_time_1 == our_time_2);
202
203 time_t now_t_2 = our_time_2.ToTimeT();
204 EXPECT_EQ(now_t_1, now_t_2);
205 }
206
207 // Test conversions to/from time_t and exploding/unexploding (local time).
TEST_F(TimeTest,LocalTimeT)208 TEST_F(TimeTest, LocalTimeT) {
209 // C library time and exploded time.
210 time_t now_t_1 = time(nullptr);
211 struct tm tms;
212
213 #if defined(OS_WIN)
214 localtime_s(&tms, &now_t_1);
215 #elif defined(OS_POSIX)
216 localtime_r(&now_t_1, &tms);
217 #elif defined(OS_FUCHSIA)
218 // POSIX local time functions always use UTC on Fuchsia, so set a known time
219 // zone and manually obtain the local |tms| values by using an adjusted input.
220 test::ScopedRestoreDefaultTimezone honolulu_time(kHonoluluTimeZoneId);
221 time_t adjusted_now_t_1 = now_t_1 + kHonoluluOffsetSeconds;
222 localtime_r(&adjusted_now_t_1, &tms);
223 #endif
224
225 // Convert to ours.
226 Time our_time_1 = Time::FromTimeT(now_t_1);
227 Time::Exploded exploded;
228 our_time_1.LocalExplode(&exploded);
229
230 // This will test both our exploding and our time_t -> Time conversion.
231 EXPECT_EQ(tms.tm_year + 1900, exploded.year);
232 EXPECT_EQ(tms.tm_mon + 1, exploded.month);
233 EXPECT_EQ(tms.tm_mday, exploded.day_of_month);
234 EXPECT_EQ(tms.tm_hour, exploded.hour);
235 EXPECT_EQ(tms.tm_min, exploded.minute);
236 EXPECT_EQ(tms.tm_sec, exploded.second);
237
238 // Convert exploded back to the time struct.
239 Time our_time_2;
240 EXPECT_TRUE(Time::FromLocalExploded(exploded, &our_time_2));
241 EXPECT_TRUE(our_time_1 == our_time_2);
242
243 time_t now_t_2 = our_time_2.ToTimeT();
244 EXPECT_EQ(now_t_1, now_t_2);
245 }
246
247 // Test conversions to/from javascript time.
TEST_F(TimeTest,JsTime)248 TEST_F(TimeTest, JsTime) {
249 Time epoch = Time::FromJsTime(0.0);
250 EXPECT_EQ(epoch, Time::UnixEpoch());
251 Time t = Time::FromJsTime(700000.3);
252 EXPECT_EQ(700.0003, t.ToDoubleT());
253 t = Time::FromDoubleT(800.73);
254 EXPECT_EQ(800730.0, t.ToJsTime());
255
256 // 1601-01-01 isn't round-trip with ToJsTime().
257 const double kWindowsEpoch = -11644473600000.0;
258 Time time = Time::FromJsTime(kWindowsEpoch);
259 EXPECT_TRUE(time.is_null());
260 EXPECT_NE(kWindowsEpoch, time.ToJsTime());
261 EXPECT_EQ(kWindowsEpoch, time.ToJsTimeIgnoringNull());
262 }
263
264 #if defined(OS_POSIX) || defined(OS_FUCHSIA)
TEST_F(TimeTest,FromTimeVal)265 TEST_F(TimeTest, FromTimeVal) {
266 Time now = Time::Now();
267 Time also_now = Time::FromTimeVal(now.ToTimeVal());
268 EXPECT_EQ(now, also_now);
269 }
270 #endif // defined(OS_POSIX) || defined(OS_FUCHSIA)
271
TEST_F(TimeTest,FromExplodedWithMilliseconds)272 TEST_F(TimeTest, FromExplodedWithMilliseconds) {
273 // Some platform implementations of FromExploded are liable to drop
274 // milliseconds if we aren't careful.
275 Time now = Time::NowFromSystemTime();
276 Time::Exploded exploded1 = {0};
277 now.UTCExplode(&exploded1);
278 exploded1.millisecond = 500;
279 Time time;
280 EXPECT_TRUE(Time::FromUTCExploded(exploded1, &time));
281 Time::Exploded exploded2 = {0};
282 time.UTCExplode(&exploded2);
283 EXPECT_EQ(exploded1.millisecond, exploded2.millisecond);
284 }
285
TEST_F(TimeTest,ZeroIsSymmetric)286 TEST_F(TimeTest, ZeroIsSymmetric) {
287 Time zero_time(Time::FromTimeT(0));
288 EXPECT_EQ(0, zero_time.ToTimeT());
289
290 EXPECT_EQ(0.0, zero_time.ToDoubleT());
291 }
292
293 // Note that this test does not check whether the implementation correctly
294 // accounts for the local time zone.
TEST_F(TimeTest,LocalExplode)295 TEST_F(TimeTest, LocalExplode) {
296 Time a = Time::Now();
297 Time::Exploded exploded;
298 a.LocalExplode(&exploded);
299
300 Time b;
301 EXPECT_TRUE(Time::FromLocalExploded(exploded, &b));
302
303 // The exploded structure doesn't have microseconds, and on Mac & Linux, the
304 // internal OS conversion uses seconds, which will cause truncation. So we
305 // can only make sure that the delta is within one second.
306 EXPECT_LT(a - b, TimeDelta::FromSeconds(1));
307 }
308
TEST_F(TimeTest,UTCExplode)309 TEST_F(TimeTest, UTCExplode) {
310 Time a = Time::Now();
311 Time::Exploded exploded;
312 a.UTCExplode(&exploded);
313
314 Time b;
315 EXPECT_TRUE(Time::FromUTCExploded(exploded, &b));
316
317 // The exploded structure doesn't have microseconds, and on Mac & Linux, the
318 // internal OS conversion uses seconds, which will cause truncation. So we
319 // can only make sure that the delta is within one second.
320 EXPECT_LT(a - b, TimeDelta::FromSeconds(1));
321 }
322
TEST_F(TimeTest,UTCMidnight)323 TEST_F(TimeTest, UTCMidnight) {
324 Time::Exploded exploded;
325 Time::Now().UTCMidnight().UTCExplode(&exploded);
326 EXPECT_EQ(0, exploded.hour);
327 EXPECT_EQ(0, exploded.minute);
328 EXPECT_EQ(0, exploded.second);
329 EXPECT_EQ(0, exploded.millisecond);
330 }
331
332 // Note that this test does not check whether the implementation correctly
333 // accounts for the local time zone.
TEST_F(TimeTest,LocalMidnight)334 TEST_F(TimeTest, LocalMidnight) {
335 Time::Exploded exploded;
336 Time::Now().LocalMidnight().LocalExplode(&exploded);
337 EXPECT_EQ(0, exploded.hour);
338 EXPECT_EQ(0, exploded.minute);
339 EXPECT_EQ(0, exploded.second);
340 EXPECT_EQ(0, exploded.millisecond);
341 }
342
343 // These tests require the ability to fake the local time zone.
344 #if defined(OS_FUCHSIA)
TEST_F(TimeTest,LocalExplodeIsLocal)345 TEST_F(TimeTest, LocalExplodeIsLocal) {
346 // Set the default time zone to a zone with an offset different from UTC.
347 test::ScopedRestoreDefaultTimezone honolulu_time(kHonoluluTimeZoneId);
348
349 // The member contains useful values for this test, which uses it as UTC.
350 Time comparison_time_utc(comparison_time_local_);
351
352 Time::Exploded utc_exploded;
353 comparison_time_utc.UTCExplode(&utc_exploded);
354
355 Time::Exploded local_exploded;
356 comparison_time_utc.LocalExplode(&local_exploded);
357
358 // The year, month, and day are the same because the (negative) offset is
359 // smaller than the hour in the test time. Similarly, there is no underflow
360 // for hour.
361 EXPECT_EQ(utc_exploded.year, local_exploded.year);
362 EXPECT_EQ(utc_exploded.month, local_exploded.month);
363 EXPECT_EQ(utc_exploded.day_of_week, local_exploded.day_of_week);
364 EXPECT_EQ(utc_exploded.day_of_month, local_exploded.day_of_month);
365 EXPECT_EQ(utc_exploded.hour + kHonoluluOffsetHours, local_exploded.hour);
366 EXPECT_EQ(utc_exploded.minute, local_exploded.minute);
367 EXPECT_EQ(utc_exploded.second, local_exploded.second);
368 EXPECT_EQ(utc_exploded.millisecond, local_exploded.millisecond);
369
370 Time time_from_local_exploded;
371 EXPECT_TRUE(
372 Time::FromLocalExploded(local_exploded, &time_from_local_exploded));
373
374 EXPECT_EQ(comparison_time_utc, time_from_local_exploded);
375
376 // Unexplode the local time using the non-local method.
377 // The resulting time should be offset hours earlier.
378 Time time_from_utc_exploded;
379 EXPECT_TRUE(Time::FromUTCExploded(local_exploded, &time_from_utc_exploded));
380 EXPECT_EQ(comparison_time_utc + TimeDelta::FromHours(kHonoluluOffsetHours),
381 time_from_utc_exploded);
382 }
383
TEST_F(TimeTest,LocalMidnightIsLocal)384 TEST_F(TimeTest, LocalMidnightIsLocal) {
385 // Set the default time zone to a zone with an offset different from UTC.
386 test::ScopedRestoreDefaultTimezone honolulu_time(kHonoluluTimeZoneId);
387
388 // The member contains useful values for this test, which uses it as UTC.
389 Time comparison_time_utc(comparison_time_local_);
390
391 Time::Exploded utc_midnight_exploded;
392 comparison_time_utc.UTCMidnight().UTCExplode(&utc_midnight_exploded);
393
394 // Local midnight exploded in UTC will have an offset hour instead of 0.
395 Time::Exploded local_midnight_utc_exploded;
396 comparison_time_utc.LocalMidnight().UTCExplode(&local_midnight_utc_exploded);
397
398 // The year, month, and day are the same because the (negative) offset is
399 // smaller than the hour in the test time and thus both midnights round down
400 // on the same day.
401 EXPECT_EQ(utc_midnight_exploded.year, local_midnight_utc_exploded.year);
402 EXPECT_EQ(utc_midnight_exploded.month, local_midnight_utc_exploded.month);
403 EXPECT_EQ(utc_midnight_exploded.day_of_week,
404 local_midnight_utc_exploded.day_of_week);
405 EXPECT_EQ(utc_midnight_exploded.day_of_month,
406 local_midnight_utc_exploded.day_of_month);
407 EXPECT_EQ(0, utc_midnight_exploded.hour);
408 EXPECT_EQ(0 - kHonoluluOffsetHours, local_midnight_utc_exploded.hour);
409 EXPECT_EQ(0, local_midnight_utc_exploded.minute);
410 EXPECT_EQ(0, local_midnight_utc_exploded.second);
411 EXPECT_EQ(0, local_midnight_utc_exploded.millisecond);
412
413 // Local midnight exploded in local time will have no offset.
414 Time::Exploded local_midnight_exploded;
415 comparison_time_utc.LocalMidnight().LocalExplode(&local_midnight_exploded);
416
417 EXPECT_EQ(utc_midnight_exploded.year, local_midnight_exploded.year);
418 EXPECT_EQ(utc_midnight_exploded.month, local_midnight_exploded.month);
419 EXPECT_EQ(utc_midnight_exploded.day_of_week,
420 local_midnight_exploded.day_of_week);
421 EXPECT_EQ(utc_midnight_exploded.day_of_month,
422 local_midnight_exploded.day_of_month);
423 EXPECT_EQ(0, local_midnight_exploded.hour);
424 EXPECT_EQ(0, local_midnight_exploded.minute);
425 EXPECT_EQ(0, local_midnight_exploded.second);
426 EXPECT_EQ(0, local_midnight_exploded.millisecond);
427 }
428 #endif // defined(OS_FUCHSIA)
429
TEST_F(TimeTest,ParseTimeTest1)430 TEST_F(TimeTest, ParseTimeTest1) {
431 time_t current_time = 0;
432 time(¤t_time);
433
434 struct tm local_time = {};
435 char time_buf[64] = {};
436 #if defined(OS_WIN)
437 localtime_s(&local_time, ¤t_time);
438 asctime_s(time_buf, base::size(time_buf), &local_time);
439 #elif defined(OS_POSIX) || defined(OS_FUCHSIA)
440 localtime_r(¤t_time, &local_time);
441 asctime_r(&local_time, time_buf);
442 #endif
443
444 Time parsed_time;
445 EXPECT_TRUE(Time::FromString(time_buf, &parsed_time));
446 EXPECT_EQ(current_time, parsed_time.ToTimeT());
447 }
448
TEST_F(TimeTest,DayOfWeekSunday)449 TEST_F(TimeTest, DayOfWeekSunday) {
450 Time time;
451 EXPECT_TRUE(Time::FromString("Sun, 06 May 2012 12:00:00 GMT", &time));
452 Time::Exploded exploded;
453 time.UTCExplode(&exploded);
454 EXPECT_EQ(0, exploded.day_of_week);
455 }
456
TEST_F(TimeTest,DayOfWeekWednesday)457 TEST_F(TimeTest, DayOfWeekWednesday) {
458 Time time;
459 EXPECT_TRUE(Time::FromString("Wed, 09 May 2012 12:00:00 GMT", &time));
460 Time::Exploded exploded;
461 time.UTCExplode(&exploded);
462 EXPECT_EQ(3, exploded.day_of_week);
463 }
464
TEST_F(TimeTest,DayOfWeekSaturday)465 TEST_F(TimeTest, DayOfWeekSaturday) {
466 Time time;
467 EXPECT_TRUE(Time::FromString("Sat, 12 May 2012 12:00:00 GMT", &time));
468 Time::Exploded exploded;
469 time.UTCExplode(&exploded);
470 EXPECT_EQ(6, exploded.day_of_week);
471 }
472
TEST_F(TimeTest,ParseTimeTest2)473 TEST_F(TimeTest, ParseTimeTest2) {
474 Time parsed_time;
475 EXPECT_TRUE(Time::FromString("Mon, 15 Oct 2007 19:45:00 GMT", &parsed_time));
476 EXPECT_EQ(comparison_time_pdt_, parsed_time);
477 }
478
TEST_F(TimeTest,ParseTimeTest3)479 TEST_F(TimeTest, ParseTimeTest3) {
480 Time parsed_time;
481 EXPECT_TRUE(Time::FromString("15 Oct 07 12:45:00", &parsed_time));
482 EXPECT_EQ(comparison_time_local_, parsed_time);
483 }
484
TEST_F(TimeTest,ParseTimeTest4)485 TEST_F(TimeTest, ParseTimeTest4) {
486 Time parsed_time;
487 EXPECT_TRUE(Time::FromString("15 Oct 07 19:45 GMT", &parsed_time));
488 EXPECT_EQ(comparison_time_pdt_, parsed_time);
489 }
490
TEST_F(TimeTest,ParseTimeTest5)491 TEST_F(TimeTest, ParseTimeTest5) {
492 Time parsed_time;
493 EXPECT_TRUE(Time::FromString("Mon Oct 15 12:45 PDT 2007", &parsed_time));
494 EXPECT_EQ(comparison_time_pdt_, parsed_time);
495 }
496
TEST_F(TimeTest,ParseTimeTest6)497 TEST_F(TimeTest, ParseTimeTest6) {
498 Time parsed_time;
499 EXPECT_TRUE(Time::FromString("Monday, Oct 15, 2007 12:45 PM", &parsed_time));
500 EXPECT_EQ(comparison_time_local_, parsed_time);
501 }
502
TEST_F(TimeTest,ParseTimeTest7)503 TEST_F(TimeTest, ParseTimeTest7) {
504 Time parsed_time;
505 EXPECT_TRUE(Time::FromString("10/15/07 12:45:00 PM", &parsed_time));
506 EXPECT_EQ(comparison_time_local_, parsed_time);
507 }
508
TEST_F(TimeTest,ParseTimeTest8)509 TEST_F(TimeTest, ParseTimeTest8) {
510 Time parsed_time;
511 EXPECT_TRUE(Time::FromString("15-OCT-2007 12:45pm", &parsed_time));
512 EXPECT_EQ(comparison_time_local_, parsed_time);
513 }
514
TEST_F(TimeTest,ParseTimeTest9)515 TEST_F(TimeTest, ParseTimeTest9) {
516 Time parsed_time;
517 EXPECT_TRUE(Time::FromString("16 Oct 2007 4:45-JST (Tuesday)", &parsed_time));
518 EXPECT_EQ(comparison_time_pdt_, parsed_time);
519 }
520
TEST_F(TimeTest,ParseTimeTest10)521 TEST_F(TimeTest, ParseTimeTest10) {
522 Time parsed_time;
523 EXPECT_TRUE(Time::FromString("15/10/07 12:45", &parsed_time));
524 EXPECT_EQ(parsed_time, comparison_time_local_);
525 }
526
527 // Test some of edge cases around epoch, etc.
TEST_F(TimeTest,ParseTimeTestEpoch0)528 TEST_F(TimeTest, ParseTimeTestEpoch0) {
529 Time parsed_time;
530
531 // time_t == epoch == 0
532 EXPECT_TRUE(Time::FromString("Thu Jan 01 01:00:00 +0100 1970",
533 &parsed_time));
534 EXPECT_EQ(0, parsed_time.ToTimeT());
535 EXPECT_TRUE(Time::FromString("Thu Jan 01 00:00:00 GMT 1970",
536 &parsed_time));
537 EXPECT_EQ(0, parsed_time.ToTimeT());
538 }
539
TEST_F(TimeTest,ParseTimeTestEpoch1)540 TEST_F(TimeTest, ParseTimeTestEpoch1) {
541 Time parsed_time;
542
543 // time_t == 1 second after epoch == 1
544 EXPECT_TRUE(Time::FromString("Thu Jan 01 01:00:01 +0100 1970",
545 &parsed_time));
546 EXPECT_EQ(1, parsed_time.ToTimeT());
547 EXPECT_TRUE(Time::FromString("Thu Jan 01 00:00:01 GMT 1970",
548 &parsed_time));
549 EXPECT_EQ(1, parsed_time.ToTimeT());
550 }
551
TEST_F(TimeTest,ParseTimeTestEpoch2)552 TEST_F(TimeTest, ParseTimeTestEpoch2) {
553 Time parsed_time;
554
555 // time_t == 2 seconds after epoch == 2
556 EXPECT_TRUE(Time::FromString("Thu Jan 01 01:00:02 +0100 1970",
557 &parsed_time));
558 EXPECT_EQ(2, parsed_time.ToTimeT());
559 EXPECT_TRUE(Time::FromString("Thu Jan 01 00:00:02 GMT 1970",
560 &parsed_time));
561 EXPECT_EQ(2, parsed_time.ToTimeT());
562 }
563
TEST_F(TimeTest,ParseTimeTestEpochNeg1)564 TEST_F(TimeTest, ParseTimeTestEpochNeg1) {
565 Time parsed_time;
566
567 // time_t == 1 second before epoch == -1
568 EXPECT_TRUE(Time::FromString("Thu Jan 01 00:59:59 +0100 1970",
569 &parsed_time));
570 EXPECT_EQ(-1, parsed_time.ToTimeT());
571 EXPECT_TRUE(Time::FromString("Wed Dec 31 23:59:59 GMT 1969",
572 &parsed_time));
573 EXPECT_EQ(-1, parsed_time.ToTimeT());
574 }
575
576 // If time_t is 32 bits, a date after year 2038 will overflow time_t and
577 // cause timegm() to return -1. The parsed time should not be 1 second
578 // before epoch.
TEST_F(TimeTest,ParseTimeTestEpochNotNeg1)579 TEST_F(TimeTest, ParseTimeTestEpochNotNeg1) {
580 Time parsed_time;
581
582 EXPECT_TRUE(Time::FromString("Wed Dec 31 23:59:59 GMT 2100",
583 &parsed_time));
584 EXPECT_NE(-1, parsed_time.ToTimeT());
585 }
586
TEST_F(TimeTest,ParseTimeTestEpochNeg2)587 TEST_F(TimeTest, ParseTimeTestEpochNeg2) {
588 Time parsed_time;
589
590 // time_t == 2 seconds before epoch == -2
591 EXPECT_TRUE(Time::FromString("Thu Jan 01 00:59:58 +0100 1970",
592 &parsed_time));
593 EXPECT_EQ(-2, parsed_time.ToTimeT());
594 EXPECT_TRUE(Time::FromString("Wed Dec 31 23:59:58 GMT 1969",
595 &parsed_time));
596 EXPECT_EQ(-2, parsed_time.ToTimeT());
597 }
598
TEST_F(TimeTest,ParseTimeTestEpoch1960)599 TEST_F(TimeTest, ParseTimeTestEpoch1960) {
600 Time parsed_time;
601
602 // time_t before Epoch, in 1960
603 EXPECT_TRUE(Time::FromString("Wed Jun 29 19:40:01 +0100 1960",
604 &parsed_time));
605 EXPECT_EQ(-299999999, parsed_time.ToTimeT());
606 EXPECT_TRUE(Time::FromString("Wed Jun 29 18:40:01 GMT 1960",
607 &parsed_time));
608 EXPECT_EQ(-299999999, parsed_time.ToTimeT());
609 EXPECT_TRUE(Time::FromString("Wed Jun 29 17:40:01 GMT 1960",
610 &parsed_time));
611 EXPECT_EQ(-300003599, parsed_time.ToTimeT());
612 }
613
TEST_F(TimeTest,ParseTimeTestEmpty)614 TEST_F(TimeTest, ParseTimeTestEmpty) {
615 Time parsed_time;
616 EXPECT_FALSE(Time::FromString("", &parsed_time));
617 }
618
TEST_F(TimeTest,ParseTimeTestInvalidString)619 TEST_F(TimeTest, ParseTimeTestInvalidString) {
620 Time parsed_time;
621 EXPECT_FALSE(Time::FromString("Monday morning 2000", &parsed_time));
622 }
623
624 // Adapted from Abseil's TEST(Duration, ParseDuration):
625 // https://cs.chromium.org/chromium/src/third_party/abseil-cpp/absl/time/duration_test.cc?l=1660&rcl=93c58ec988d77f4277f9c9d237d3507991fbd719
TEST_F(TimeTest,ParseTimeDeltaTest)626 TEST_F(TimeTest, ParseTimeDeltaTest) {
627 // No specified unit. Should only work for zero and infinity.
628 EXPECT_EQ(TimeDelta::FromString("0"), TimeDelta());
629 EXPECT_EQ(TimeDelta::FromString("+0"), TimeDelta());
630 EXPECT_EQ(TimeDelta::FromString("-0"), TimeDelta());
631
632 EXPECT_EQ(TimeDelta::FromString("inf"), TimeDelta::Max());
633 EXPECT_EQ(TimeDelta::FromString("+inf"), TimeDelta::Max());
634 EXPECT_EQ(TimeDelta::FromString("-inf"), TimeDelta::Min());
635 EXPECT_EQ(TimeDelta::FromString("infBlah"), nullopt);
636
637 // Illegal input forms.
638 EXPECT_EQ(TimeDelta::FromString(""), nullopt);
639 EXPECT_EQ(TimeDelta::FromString("0.0"), nullopt);
640 EXPECT_EQ(TimeDelta::FromString(".0"), nullopt);
641 EXPECT_EQ(TimeDelta::FromString("."), nullopt);
642 EXPECT_EQ(TimeDelta::FromString("01"), nullopt);
643 EXPECT_EQ(TimeDelta::FromString("1"), nullopt);
644 EXPECT_EQ(TimeDelta::FromString("-1"), nullopt);
645 EXPECT_EQ(TimeDelta::FromString("2"), nullopt);
646 EXPECT_EQ(TimeDelta::FromString("2 s"), nullopt);
647 EXPECT_EQ(TimeDelta::FromString(".s"), nullopt);
648 EXPECT_EQ(TimeDelta::FromString("-.s"), nullopt);
649 EXPECT_EQ(TimeDelta::FromString("s"), nullopt);
650 EXPECT_EQ(TimeDelta::FromString(" 2s"), nullopt);
651 EXPECT_EQ(TimeDelta::FromString("2s "), nullopt);
652 EXPECT_EQ(TimeDelta::FromString(" 2s "), nullopt);
653 EXPECT_EQ(TimeDelta::FromString("2mt"), nullopt);
654 EXPECT_EQ(TimeDelta::FromString("1e3s"), nullopt);
655
656 // One unit type.
657 EXPECT_EQ(TimeDelta::FromString("1ns"), TimeDelta::FromNanoseconds(1));
658 EXPECT_EQ(TimeDelta::FromString("1us"), TimeDelta::FromMicroseconds(1));
659 EXPECT_EQ(TimeDelta::FromString("1ms"), TimeDelta::FromMilliseconds(1));
660 EXPECT_EQ(TimeDelta::FromString("1s"), TimeDelta::FromSeconds(1));
661 EXPECT_EQ(TimeDelta::FromString("2m"), TimeDelta::FromMinutes(2));
662 EXPECT_EQ(TimeDelta::FromString("2h"), TimeDelta::FromHours(2));
663
664 // Huge counts of a unit. 9223372036854775807 == 2^63 - 1.
665 EXPECT_EQ(TimeDelta::FromString("9223372036854775807us"),
666 TimeDelta::FromMicroseconds(9223372036854775807));
667 EXPECT_EQ(TimeDelta::FromString("-9223372036854775807us"),
668 TimeDelta::FromMicroseconds(-9223372036854775807));
669
670 // Overflow count. Note the "93" at the beginning (instead of "92").
671 EXPECT_EQ(TimeDelta::FromString("9323372036854775807us"), base::nullopt);
672 // Overflow overall duration.
673 EXPECT_EQ(TimeDelta::FromString("9323372036854s"), TimeDelta::Max());
674 EXPECT_EQ(TimeDelta::FromString("-9323372036854s"), TimeDelta::Min());
675
676 // Multiple units.
677 EXPECT_EQ(TimeDelta::FromString("2h3m4s"), TimeDelta::FromHours(2) +
678 TimeDelta::FromMinutes(3) +
679 TimeDelta::FromSeconds(4));
680 EXPECT_EQ(TimeDelta::FromString("3m4s5us"),
681 TimeDelta::FromMinutes(3) + TimeDelta::FromSeconds(4) +
682 TimeDelta::FromMicroseconds(5));
683 EXPECT_EQ(TimeDelta::FromString("2h3m4s5ms6us7ns"),
684 TimeDelta::FromHours(2) + TimeDelta::FromMinutes(3) +
685 TimeDelta::FromSeconds(4) + TimeDelta::FromMilliseconds(5) +
686 TimeDelta::FromMicroseconds(6) + TimeDelta::FromNanoseconds(7));
687
688 // Multiple units out of order.
689 EXPECT_EQ(TimeDelta::FromString("2us3m4s5h"),
690 TimeDelta::FromHours(5) + TimeDelta::FromMinutes(3) +
691 TimeDelta::FromSeconds(4) + TimeDelta::FromMicroseconds(2));
692
693 // Fractional values of units.
694 EXPECT_EQ(TimeDelta::FromString("1.5ns"),
695 1.5 * TimeDelta::FromNanoseconds(1));
696 EXPECT_EQ(TimeDelta::FromString("1.5us"),
697 1.5 * TimeDelta::FromMicroseconds(1));
698 EXPECT_EQ(TimeDelta::FromString("1.5ms"),
699 1.5 * TimeDelta::FromMilliseconds(1));
700 EXPECT_EQ(TimeDelta::FromString("1.5s"), 1.5 * TimeDelta::FromSeconds(1));
701 EXPECT_EQ(TimeDelta::FromString("1.5m"), 1.5 * TimeDelta::FromMinutes(1));
702 EXPECT_EQ(TimeDelta::FromString("1.5h"), 1.5 * TimeDelta::FromHours(1));
703
704 // Huge fractional counts of a unit.
705 EXPECT_EQ(TimeDelta::FromString("0.4294967295s"),
706 TimeDelta::FromNanoseconds(429496729) +
707 TimeDelta::FromNanoseconds(1) / 2);
708 EXPECT_EQ(TimeDelta::FromString("0.429496729501234567890123456789s"),
709 TimeDelta::FromNanoseconds(429496729) +
710 TimeDelta::FromNanoseconds(1) / 2);
711
712 // Negative durations.
713 EXPECT_EQ(TimeDelta::FromString("-1s"), TimeDelta::FromSeconds(-1));
714 EXPECT_EQ(TimeDelta::FromString("-1m"), TimeDelta::FromMinutes(-1));
715 EXPECT_EQ(TimeDelta::FromString("-1h"), TimeDelta::FromHours(-1));
716
717 EXPECT_EQ(TimeDelta::FromString("-1h2s"),
718 -(TimeDelta::FromHours(1) + TimeDelta::FromSeconds(2)));
719 EXPECT_EQ(TimeDelta::FromString("1h-2s"), nullopt);
720 EXPECT_EQ(TimeDelta::FromString("-1h-2s"), nullopt);
721 EXPECT_EQ(TimeDelta::FromString("-1h -2s"), nullopt);
722 }
723
TEST_F(TimeTest,ExplodeBeforeUnixEpoch)724 TEST_F(TimeTest, ExplodeBeforeUnixEpoch) {
725 static const int kUnixEpochYear = 1970; // In case this changes (ha!).
726 Time t;
727 Time::Exploded exploded;
728
729 t = Time::UnixEpoch() - TimeDelta::FromMicroseconds(1);
730 t.UTCExplode(&exploded);
731 EXPECT_TRUE(exploded.HasValidValues());
732 // Should be 1969-12-31 23:59:59 999 milliseconds (and 999 microseconds).
733 EXPECT_EQ(kUnixEpochYear - 1, exploded.year);
734 EXPECT_EQ(12, exploded.month);
735 EXPECT_EQ(31, exploded.day_of_month);
736 EXPECT_EQ(23, exploded.hour);
737 EXPECT_EQ(59, exploded.minute);
738 EXPECT_EQ(59, exploded.second);
739 EXPECT_EQ(999, exploded.millisecond);
740
741 t = Time::UnixEpoch() - TimeDelta::FromMicroseconds(999);
742 t.UTCExplode(&exploded);
743 EXPECT_TRUE(exploded.HasValidValues());
744 // Should be 1969-12-31 23:59:59 999 milliseconds (and 1 microsecond).
745 EXPECT_EQ(kUnixEpochYear - 1, exploded.year);
746 EXPECT_EQ(12, exploded.month);
747 EXPECT_EQ(31, exploded.day_of_month);
748 EXPECT_EQ(23, exploded.hour);
749 EXPECT_EQ(59, exploded.minute);
750 EXPECT_EQ(59, exploded.second);
751 EXPECT_EQ(999, exploded.millisecond);
752
753 t = Time::UnixEpoch() - TimeDelta::FromMicroseconds(1000);
754 t.UTCExplode(&exploded);
755 EXPECT_TRUE(exploded.HasValidValues());
756 // Should be 1969-12-31 23:59:59 999 milliseconds.
757 EXPECT_EQ(kUnixEpochYear - 1, exploded.year);
758 EXPECT_EQ(12, exploded.month);
759 EXPECT_EQ(31, exploded.day_of_month);
760 EXPECT_EQ(23, exploded.hour);
761 EXPECT_EQ(59, exploded.minute);
762 EXPECT_EQ(59, exploded.second);
763 EXPECT_EQ(999, exploded.millisecond);
764
765 t = Time::UnixEpoch() - TimeDelta::FromMicroseconds(1001);
766 t.UTCExplode(&exploded);
767 EXPECT_TRUE(exploded.HasValidValues());
768 // Should be 1969-12-31 23:59:59 998 milliseconds (and 999 microseconds).
769 EXPECT_EQ(kUnixEpochYear - 1, exploded.year);
770 EXPECT_EQ(12, exploded.month);
771 EXPECT_EQ(31, exploded.day_of_month);
772 EXPECT_EQ(23, exploded.hour);
773 EXPECT_EQ(59, exploded.minute);
774 EXPECT_EQ(59, exploded.second);
775 EXPECT_EQ(998, exploded.millisecond);
776
777 t = Time::UnixEpoch() - TimeDelta::FromMilliseconds(1000);
778 t.UTCExplode(&exploded);
779 EXPECT_TRUE(exploded.HasValidValues());
780 // Should be 1969-12-31 23:59:59.
781 EXPECT_EQ(kUnixEpochYear - 1, exploded.year);
782 EXPECT_EQ(12, exploded.month);
783 EXPECT_EQ(31, exploded.day_of_month);
784 EXPECT_EQ(23, exploded.hour);
785 EXPECT_EQ(59, exploded.minute);
786 EXPECT_EQ(59, exploded.second);
787 EXPECT_EQ(0, exploded.millisecond);
788
789 t = Time::UnixEpoch() - TimeDelta::FromMilliseconds(1001);
790 t.UTCExplode(&exploded);
791 EXPECT_TRUE(exploded.HasValidValues());
792 // Should be 1969-12-31 23:59:58 999 milliseconds.
793 EXPECT_EQ(kUnixEpochYear - 1, exploded.year);
794 EXPECT_EQ(12, exploded.month);
795 EXPECT_EQ(31, exploded.day_of_month);
796 EXPECT_EQ(23, exploded.hour);
797 EXPECT_EQ(59, exploded.minute);
798 EXPECT_EQ(58, exploded.second);
799 EXPECT_EQ(999, exploded.millisecond);
800
801 // Make sure we still handle at/after Unix epoch correctly.
802 t = Time::UnixEpoch();
803 t.UTCExplode(&exploded);
804 EXPECT_TRUE(exploded.HasValidValues());
805 // Should be 1970-12-31 00:00:00 0 milliseconds.
806 EXPECT_EQ(kUnixEpochYear, exploded.year);
807 EXPECT_EQ(1, exploded.month);
808 EXPECT_EQ(1, exploded.day_of_month);
809 EXPECT_EQ(0, exploded.hour);
810 EXPECT_EQ(0, exploded.minute);
811 EXPECT_EQ(0, exploded.second);
812 EXPECT_EQ(0, exploded.millisecond);
813
814 t = Time::UnixEpoch() + TimeDelta::FromMicroseconds(1);
815 t.UTCExplode(&exploded);
816 EXPECT_TRUE(exploded.HasValidValues());
817 // Should be 1970-01-01 00:00:00 0 milliseconds (and 1 microsecond).
818 EXPECT_EQ(kUnixEpochYear, exploded.year);
819 EXPECT_EQ(1, exploded.month);
820 EXPECT_EQ(1, exploded.day_of_month);
821 EXPECT_EQ(0, exploded.hour);
822 EXPECT_EQ(0, exploded.minute);
823 EXPECT_EQ(0, exploded.second);
824 EXPECT_EQ(0, exploded.millisecond);
825
826 t = Time::UnixEpoch() + TimeDelta::FromMicroseconds(999);
827 t.UTCExplode(&exploded);
828 EXPECT_TRUE(exploded.HasValidValues());
829 // Should be 1970-01-01 00:00:00 0 milliseconds (and 999 microseconds).
830 EXPECT_EQ(kUnixEpochYear, exploded.year);
831 EXPECT_EQ(1, exploded.month);
832 EXPECT_EQ(1, exploded.day_of_month);
833 EXPECT_EQ(0, exploded.hour);
834 EXPECT_EQ(0, exploded.minute);
835 EXPECT_EQ(0, exploded.second);
836 EXPECT_EQ(0, exploded.millisecond);
837
838 t = Time::UnixEpoch() + TimeDelta::FromMicroseconds(1000);
839 t.UTCExplode(&exploded);
840 EXPECT_TRUE(exploded.HasValidValues());
841 // Should be 1970-01-01 00:00:00 1 millisecond.
842 EXPECT_EQ(kUnixEpochYear, exploded.year);
843 EXPECT_EQ(1, exploded.month);
844 EXPECT_EQ(1, exploded.day_of_month);
845 EXPECT_EQ(0, exploded.hour);
846 EXPECT_EQ(0, exploded.minute);
847 EXPECT_EQ(0, exploded.second);
848 EXPECT_EQ(1, exploded.millisecond);
849
850 t = Time::UnixEpoch() + TimeDelta::FromMilliseconds(1000);
851 t.UTCExplode(&exploded);
852 EXPECT_TRUE(exploded.HasValidValues());
853 // Should be 1970-01-01 00:00:01.
854 EXPECT_EQ(kUnixEpochYear, exploded.year);
855 EXPECT_EQ(1, exploded.month);
856 EXPECT_EQ(1, exploded.day_of_month);
857 EXPECT_EQ(0, exploded.hour);
858 EXPECT_EQ(0, exploded.minute);
859 EXPECT_EQ(1, exploded.second);
860 EXPECT_EQ(0, exploded.millisecond);
861
862 t = Time::UnixEpoch() + TimeDelta::FromMilliseconds(1001);
863 t.UTCExplode(&exploded);
864 EXPECT_TRUE(exploded.HasValidValues());
865 // Should be 1970-01-01 00:00:01 1 millisecond.
866 EXPECT_EQ(kUnixEpochYear, exploded.year);
867 EXPECT_EQ(1, exploded.month);
868 EXPECT_EQ(1, exploded.day_of_month);
869 EXPECT_EQ(0, exploded.hour);
870 EXPECT_EQ(0, exploded.minute);
871 EXPECT_EQ(1, exploded.second);
872 EXPECT_EQ(1, exploded.millisecond);
873 }
874
TEST_F(TimeTest,Max)875 TEST_F(TimeTest, Max) {
876 Time max = Time::Max();
877 EXPECT_TRUE(max.is_max());
878 EXPECT_EQ(max, Time::Max());
879 EXPECT_GT(max, Time::Now());
880 EXPECT_GT(max, Time());
881 }
882
TEST_F(TimeTest,MaxConversions)883 TEST_F(TimeTest, MaxConversions) {
884 Time t = Time::Max();
885 EXPECT_EQ(std::numeric_limits<int64_t>::max(), t.ToInternalValue());
886
887 t = Time::FromDoubleT(std::numeric_limits<double>::infinity());
888 EXPECT_TRUE(t.is_max());
889 EXPECT_EQ(std::numeric_limits<double>::infinity(), t.ToDoubleT());
890
891 t = Time::FromJsTime(std::numeric_limits<double>::infinity());
892 EXPECT_TRUE(t.is_max());
893 EXPECT_EQ(std::numeric_limits<double>::infinity(), t.ToJsTime());
894
895 t = Time::FromTimeT(std::numeric_limits<time_t>::max());
896 EXPECT_TRUE(t.is_max());
897 EXPECT_EQ(std::numeric_limits<time_t>::max(), t.ToTimeT());
898
899 #if defined(OS_POSIX) || defined(OS_FUCHSIA)
900 struct timeval tval;
901 tval.tv_sec = std::numeric_limits<time_t>::max();
902 tval.tv_usec = static_cast<suseconds_t>(Time::kMicrosecondsPerSecond) - 1;
903 t = Time::FromTimeVal(tval);
904 EXPECT_TRUE(t.is_max());
905 tval = t.ToTimeVal();
906 EXPECT_EQ(std::numeric_limits<time_t>::max(), tval.tv_sec);
907 EXPECT_EQ(static_cast<suseconds_t>(Time::kMicrosecondsPerSecond) - 1,
908 tval.tv_usec);
909 #endif
910
911 #if defined(OS_APPLE)
912 t = Time::FromCFAbsoluteTime(std::numeric_limits<CFAbsoluteTime>::infinity());
913 EXPECT_TRUE(t.is_max());
914 EXPECT_EQ(std::numeric_limits<CFAbsoluteTime>::infinity(),
915 t.ToCFAbsoluteTime());
916 #endif
917
918 #if defined(OS_WIN)
919 FILETIME ftime;
920 ftime.dwHighDateTime = std::numeric_limits<DWORD>::max();
921 ftime.dwLowDateTime = std::numeric_limits<DWORD>::max();
922 t = Time::FromFileTime(ftime);
923 EXPECT_TRUE(t.is_max());
924 ftime = t.ToFileTime();
925 EXPECT_EQ(std::numeric_limits<DWORD>::max(), ftime.dwHighDateTime);
926 EXPECT_EQ(std::numeric_limits<DWORD>::max(), ftime.dwLowDateTime);
927 #endif
928 }
929
930 #if defined(OS_APPLE)
TEST_F(TimeTest,TimeTOverflow)931 TEST_F(TimeTest, TimeTOverflow) {
932 Time t = Time::FromInternalValue(std::numeric_limits<int64_t>::max() - 1);
933 EXPECT_FALSE(t.is_max());
934 EXPECT_EQ(std::numeric_limits<time_t>::max(), t.ToTimeT());
935 }
936 #endif
937
938 #if defined(OS_ANDROID)
TEST_F(TimeTest,FromLocalExplodedCrashOnAndroid)939 TEST_F(TimeTest, FromLocalExplodedCrashOnAndroid) {
940 // This crashed inside Time:: FromLocalExploded() on Android 4.1.2.
941 // See http://crbug.com/287821
942 Time::Exploded midnight = {2013, // year
943 10, // month
944 0, // day_of_week
945 13, // day_of_month
946 0, // hour
947 0, // minute
948 0, // second
949 };
950 // The string passed to putenv() must be a char* and the documentation states
951 // that it 'becomes part of the environment', so use a static buffer.
952 static char buffer[] = "TZ=America/Santiago";
953 putenv(buffer);
954 tzset();
955 Time t;
956 EXPECT_TRUE(Time::FromLocalExploded(midnight, &t));
957 EXPECT_EQ(1381633200, t.ToTimeT());
958 }
959 #endif // OS_ANDROID
960
961 // Regression test for https://crbug.com/1104442
TEST_F(TimeTest,Explode_Y10KCompliance)962 TEST_F(TimeTest, Explode_Y10KCompliance) {
963 constexpr int kDaysPerYear = 365;
964 constexpr int64_t kHalfYearInMicros =
965 TimeDelta::FromDays(kDaysPerYear / 2).InMicroseconds();
966
967 // The Y2038 issue occurs when a 32-bit signed integer overflows.
968 constexpr int64_t kYear2038MicrosOffset =
969 Time::kTimeTToMicrosecondsOffset +
970 (std::numeric_limits<int32_t>::max() * Time::kMicrosecondsPerSecond);
971
972 // 1 March 10000 at noon.
973 constexpr int64_t kYear10000YearsOffset = 10000 - 1970;
974 constexpr int kExtraLeapDaysOverThoseYears = 1947;
975 constexpr int kDaysFromJanToMar10000 = 31 + 29;
976 constexpr int64_t kMarch10000MicrosOffset =
977 Time::kTimeTToMicrosecondsOffset +
978 TimeDelta::FromDays(kYear10000YearsOffset * kDaysPerYear +
979 kExtraLeapDaysOverThoseYears + kDaysFromJanToMar10000)
980 .InMicroseconds() +
981 TimeDelta::FromHours(12).InMicroseconds();
982
983 // Windows uses a 64-bit signed integer type that reperesents the number of
984 // 1/10 microsecond ticks.
985 constexpr int64_t kWindowsMaxMicrosOffset =
986 std::numeric_limits<int64_t>::max() / 10;
987
988 // ICU's Calendar API uses double values. Thus, the maximum supported value is
989 // the maximum integer that can be represented by a double.
990 static_assert(std::numeric_limits<double>::radix == 2, "");
991 constexpr int64_t kMaxIntegerAsDoubleMillis =
992 int64_t{1} << std::numeric_limits<double>::digits;
993 constexpr int64_t kIcuMaxMicrosOffset =
994 Time::kTimeTToMicrosecondsOffset +
995 (kMaxIntegerAsDoubleMillis * Time::kMicrosecondsPerMillisecond + 999);
996
997 const auto make_time = [](int64_t micros) {
998 return Time::FromDeltaSinceWindowsEpoch(
999 TimeDelta::FromMicroseconds(micros));
1000 };
1001
1002 const struct TestCase {
1003 Time time;
1004 Time::Exploded expected;
1005 } kTestCases[] = {
1006 // A very long time ago.
1007 {Time::Min(), Time::Exploded{-290677, 12, 4, 23, 19, 59, 5, 224}},
1008
1009 // Before/On/After 1 Jan 1601.
1010 {make_time(-kHalfYearInMicros),
1011 Time::Exploded{1600, 7, 1, 3, 0, 0, 0, 0}},
1012 {make_time(0), Time::Exploded{1601, 1, 1, 1, 0, 0, 0, 0}},
1013 {make_time(kHalfYearInMicros), Time::Exploded{1601, 7, 1, 2, 0, 0, 0, 0}},
1014
1015 // Before/On/After 1 Jan 1970.
1016 {make_time(Time::kTimeTToMicrosecondsOffset - kHalfYearInMicros),
1017 Time::Exploded{1969, 7, 4, 3, 0, 0, 0, 0}},
1018 {make_time(Time::kTimeTToMicrosecondsOffset),
1019 Time::Exploded{1970, 1, 4, 1, 0, 0, 0, 0}},
1020 {make_time(Time::kTimeTToMicrosecondsOffset + kHalfYearInMicros),
1021 Time::Exploded{1970, 7, 4, 2, 0, 0, 0, 0}},
1022
1023 // Before/On/After 19 January 2038.
1024 {make_time(kYear2038MicrosOffset - kHalfYearInMicros),
1025 Time::Exploded{2037, 7, 2, 21, 3, 14, 7, 0}},
1026 {make_time(kYear2038MicrosOffset),
1027 Time::Exploded{2038, 1, 2, 19, 3, 14, 7, 0}},
1028 {make_time(kYear2038MicrosOffset + kHalfYearInMicros),
1029 Time::Exploded{2038, 7, 2, 20, 3, 14, 7, 0}},
1030
1031 // Before/On/After 1 March 10000 at noon.
1032 {make_time(kMarch10000MicrosOffset - kHalfYearInMicros),
1033 Time::Exploded{9999, 9, 3, 1, 12, 0, 0, 0}},
1034 {make_time(kMarch10000MicrosOffset),
1035 Time::Exploded{10000, 3, 3, 1, 12, 0, 0, 0}},
1036 {make_time(kMarch10000MicrosOffset + kHalfYearInMicros),
1037 Time::Exploded{10000, 8, 3, 30, 12, 0, 0, 0}},
1038
1039 // Before/On/After Windows Max (14 September 30828).
1040 {make_time(kWindowsMaxMicrosOffset - kHalfYearInMicros),
1041 Time::Exploded{30828, 3, 4, 16, 2, 48, 5, 477}},
1042 {make_time(kWindowsMaxMicrosOffset),
1043 Time::Exploded{30828, 9, 4, 14, 2, 48, 5, 477}},
1044 {make_time(kWindowsMaxMicrosOffset + kHalfYearInMicros),
1045 Time::Exploded{30829, 3, 4, 15, 2, 48, 5, 477}},
1046
1047 // Before/On/After ICU Max.
1048 {make_time(kIcuMaxMicrosOffset - kHalfYearInMicros),
1049 Time::Exploded{287396, 4, 3, 13, 8, 59, 0, 992}},
1050 {make_time(kIcuMaxMicrosOffset),
1051 Time::Exploded{287396, 10, 3, 12, 8, 59, 0, 992}},
1052 {make_time(kIcuMaxMicrosOffset + kHalfYearInMicros),
1053 Time::Exploded{287397, 4, 3, 12, 8, 59, 0, 992}},
1054
1055 // A very long time from now.
1056 {Time::Max(), Time::Exploded{293878, 1, 4, 10, 4, 0, 54, 775}},
1057 };
1058
1059 for (const TestCase& test_case : kTestCases) {
1060 SCOPED_TRACE(testing::Message() << "Time: " << test_case.time);
1061
1062 Time::Exploded exploded = {};
1063 test_case.time.UTCExplode(&exploded);
1064
1065 // Confirm the implementation provides a correct conversion for all inputs
1066 // within the guaranteed range (as discussed in the header comments). If an
1067 // implementation provides a result for inputs outside the guaranteed range,
1068 // the result must still be correct.
1069 if (exploded.HasValidValues()) {
1070 EXPECT_EQ(test_case.expected.year, exploded.year);
1071 EXPECT_EQ(test_case.expected.month, exploded.month);
1072 EXPECT_EQ(test_case.expected.day_of_week, exploded.day_of_week);
1073 EXPECT_EQ(test_case.expected.day_of_month, exploded.day_of_month);
1074 EXPECT_EQ(test_case.expected.hour, exploded.hour);
1075 EXPECT_EQ(test_case.expected.minute, exploded.minute);
1076 EXPECT_EQ(test_case.expected.second, exploded.second);
1077 EXPECT_EQ(test_case.expected.millisecond, exploded.millisecond);
1078 } else {
1079 // The implementation could not provide a conversion. That is only allowed
1080 // for inputs outside the guaranteed range.
1081 const bool is_in_range =
1082 test_case.time >= make_time(0) &&
1083 test_case.time <= make_time(kWindowsMaxMicrosOffset);
1084 EXPECT_FALSE(is_in_range);
1085 }
1086 }
1087 }
1088
TEST_F(TimeTest,FromExploded_MinMax)1089 TEST_F(TimeTest, FromExploded_MinMax) {
1090 Time::Exploded exploded = {0};
1091 exploded.month = 1;
1092 exploded.day_of_month = 1;
1093
1094 Time parsed_time;
1095
1096 if (Time::kExplodedMinYear != std::numeric_limits<int>::min()) {
1097 exploded.year = Time::kExplodedMinYear;
1098 EXPECT_TRUE(Time::FromUTCExploded(exploded, &parsed_time));
1099 #if defined(OS_POSIX) || defined(OS_FUCHSIA)
1100 // On Windows, January 1, 1601 00:00:00 is actually the null time.
1101 EXPECT_FALSE(parsed_time.is_null());
1102 #endif
1103
1104 #if !defined(OS_ANDROID) && !defined(OS_APPLE)
1105 // The dates earlier than |kExplodedMinYear| that don't work are OS version
1106 // dependent on Android and Mac (for example, macOS 10.13 seems to support
1107 // dates before 1902).
1108 exploded.year--;
1109 EXPECT_FALSE(Time::FromUTCExploded(exploded, &parsed_time));
1110 EXPECT_TRUE(parsed_time.is_null());
1111 #endif
1112 }
1113
1114 if (Time::kExplodedMaxYear != std::numeric_limits<int>::max()) {
1115 exploded.year = Time::kExplodedMaxYear;
1116 exploded.month = 12;
1117 exploded.day_of_month = 31;
1118 exploded.hour = 23;
1119 exploded.minute = 59;
1120 exploded.second = 59;
1121 exploded.millisecond = 999;
1122 EXPECT_TRUE(Time::FromUTCExploded(exploded, &parsed_time));
1123 EXPECT_FALSE(parsed_time.is_null());
1124
1125 exploded.year++;
1126 EXPECT_FALSE(Time::FromUTCExploded(exploded, &parsed_time));
1127 EXPECT_TRUE(parsed_time.is_null());
1128 }
1129 }
1130
1131 class TimeOverride {
1132 public:
Now()1133 static Time Now() {
1134 now_time_ += TimeDelta::FromSeconds(1);
1135 return now_time_;
1136 }
1137
1138 static Time now_time_;
1139 };
1140
1141 // static
1142 Time TimeOverride::now_time_;
1143
1144 #if defined(OS_FUCHSIA)
1145 // TODO(https://crbug.com/1060357): Enable when RTC flake is fixed.
1146 #define MAYBE_NowOverride DISABLED_NowOverride
1147 #else
1148 #define MAYBE_NowOverride NowOverride
1149 #endif
1150
TEST_F(TimeTest,MAYBE_NowOverride)1151 TEST_F(TimeTest, MAYBE_NowOverride) {
1152 TimeOverride::now_time_ = Time::UnixEpoch();
1153
1154 // Choose a reference time that we know to be in the past but close to now.
1155 Time build_time = GetBuildTime();
1156
1157 // Override is not active. All Now() methods should return a time greater than
1158 // the build time.
1159 EXPECT_LT(build_time, Time::Now());
1160 EXPECT_GT(Time::Max(), Time::Now());
1161 EXPECT_LT(build_time, subtle::TimeNowIgnoringOverride());
1162 EXPECT_GT(Time::Max(), subtle::TimeNowIgnoringOverride());
1163 EXPECT_LT(build_time, Time::NowFromSystemTime());
1164 EXPECT_GT(Time::Max(), Time::NowFromSystemTime());
1165 EXPECT_LT(build_time, subtle::TimeNowFromSystemTimeIgnoringOverride());
1166 EXPECT_GT(Time::Max(), subtle::TimeNowFromSystemTimeIgnoringOverride());
1167
1168 {
1169 // Set override.
1170 subtle::ScopedTimeClockOverrides overrides(&TimeOverride::Now, nullptr,
1171 nullptr);
1172
1173 // Overridden value is returned and incremented when Now() or
1174 // NowFromSystemTime() is called.
1175 EXPECT_EQ(Time::UnixEpoch() + TimeDelta::FromSeconds(1), Time::Now());
1176 EXPECT_EQ(Time::UnixEpoch() + TimeDelta::FromSeconds(2), Time::Now());
1177 EXPECT_EQ(Time::UnixEpoch() + TimeDelta::FromSeconds(3),
1178 Time::NowFromSystemTime());
1179 EXPECT_EQ(Time::UnixEpoch() + TimeDelta::FromSeconds(4),
1180 Time::NowFromSystemTime());
1181
1182 // IgnoringOverride methods still return real time.
1183 EXPECT_LT(build_time, subtle::TimeNowIgnoringOverride());
1184 EXPECT_GT(Time::Max(), subtle::TimeNowIgnoringOverride());
1185 EXPECT_LT(build_time, subtle::TimeNowFromSystemTimeIgnoringOverride());
1186 EXPECT_GT(Time::Max(), subtle::TimeNowFromSystemTimeIgnoringOverride());
1187
1188 // IgnoringOverride methods didn't call NowOverrideClock::Now().
1189 EXPECT_EQ(Time::UnixEpoch() + TimeDelta::FromSeconds(5), Time::Now());
1190 EXPECT_EQ(Time::UnixEpoch() + TimeDelta::FromSeconds(6),
1191 Time::NowFromSystemTime());
1192 }
1193
1194 // All methods return real time again.
1195 EXPECT_LT(build_time, Time::Now());
1196 EXPECT_GT(Time::Max(), Time::Now());
1197 EXPECT_LT(build_time, subtle::TimeNowIgnoringOverride());
1198 EXPECT_GT(Time::Max(), subtle::TimeNowIgnoringOverride());
1199 EXPECT_LT(build_time, Time::NowFromSystemTime());
1200 EXPECT_GT(Time::Max(), Time::NowFromSystemTime());
1201 EXPECT_LT(build_time, subtle::TimeNowFromSystemTimeIgnoringOverride());
1202 EXPECT_GT(Time::Max(), subtle::TimeNowFromSystemTimeIgnoringOverride());
1203 }
1204
1205 #undef MAYBE_NowOverride
1206
1207 #if defined(OS_FUCHSIA)
TEST(ZxTimeTest,ToFromConversions)1208 TEST(ZxTimeTest, ToFromConversions) {
1209 Time unix_epoch = Time::UnixEpoch();
1210 EXPECT_EQ(unix_epoch.ToZxTime(), 0);
1211 EXPECT_EQ(Time::FromZxTime(6000000000),
1212 unix_epoch + TimeDelta::FromSeconds(6));
1213
1214 TimeTicks ticks_now = TimeTicks::Now();
1215 EXPECT_GE(ticks_now.ToZxTime(), 0);
1216 TimeTicks ticks_later = ticks_now + TimeDelta::FromSeconds(2);
1217 EXPECT_EQ((ticks_later.ToZxTime() - ticks_now.ToZxTime()), 2000000000);
1218 EXPECT_EQ(TimeTicks::FromZxTime(3000000000),
1219 TimeTicks() + TimeDelta::FromSeconds(3));
1220
1221 EXPECT_EQ(TimeDelta().ToZxDuration(), 0);
1222 EXPECT_EQ(TimeDelta::FromZxDuration(0), TimeDelta());
1223
1224 EXPECT_EQ(TimeDelta::FromSeconds(2).ToZxDuration(), 2000000000);
1225 EXPECT_EQ(TimeDelta::FromZxDuration(4000000000), TimeDelta::FromSeconds(4));
1226 }
1227 #endif // defined(OS_FUCHSIA)
1228
TEST(TimeTicks,Deltas)1229 TEST(TimeTicks, Deltas) {
1230 for (int index = 0; index < 50; index++) {
1231 TimeTicks ticks_start = TimeTicks::Now();
1232 base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(10));
1233 TimeTicks ticks_stop = TimeTicks::Now();
1234 TimeDelta delta = ticks_stop - ticks_start;
1235 // Note: Although we asked for a 10ms sleep, if the
1236 // time clock has a finer granularity than the Sleep()
1237 // clock, it is quite possible to wakeup early. Here
1238 // is how that works:
1239 // Time(ms timer) Time(us timer)
1240 // 5 5010
1241 // 6 6010
1242 // 7 7010
1243 // 8 8010
1244 // 9 9000
1245 // Elapsed 4ms 3990us
1246 //
1247 // Unfortunately, our InMilliseconds() function truncates
1248 // rather than rounds. We should consider fixing this
1249 // so that our averages come out better.
1250 EXPECT_GE(delta.InMilliseconds(), 9);
1251 EXPECT_GE(delta.InMicroseconds(), 9000);
1252 EXPECT_EQ(delta.InSeconds(), 0);
1253 }
1254 }
1255
HighResClockTest(TimeTicks (* GetTicks)())1256 static void HighResClockTest(TimeTicks (*GetTicks)()) {
1257 // IsHighResolution() is false on some systems. Since the product still works
1258 // even if it's false, it makes this entire test questionable.
1259 if (!TimeTicks::IsHighResolution())
1260 return;
1261
1262 // Why do we loop here?
1263 // We're trying to measure that intervals increment in a VERY small amount
1264 // of time -- less than 15ms. Unfortunately, if we happen to have a
1265 // context switch in the middle of our test, the context switch could easily
1266 // exceed our limit. So, we iterate on this several times. As long as we're
1267 // able to detect the fine-granularity timers at least once, then the test
1268 // has succeeded.
1269
1270 const int kTargetGranularityUs = 15000; // 15ms
1271
1272 bool success = false;
1273 int retries = 100; // Arbitrary.
1274 TimeDelta delta;
1275 while (!success && retries--) {
1276 TimeTicks ticks_start = GetTicks();
1277 // Loop until we can detect that the clock has changed. Non-HighRes timers
1278 // will increment in chunks, e.g. 15ms. By spinning until we see a clock
1279 // change, we detect the minimum time between measurements.
1280 do {
1281 delta = GetTicks() - ticks_start;
1282 } while (delta.InMilliseconds() == 0);
1283
1284 if (delta.InMicroseconds() <= kTargetGranularityUs)
1285 success = true;
1286 }
1287
1288 // In high resolution mode, we expect to see the clock increment
1289 // in intervals less than 15ms.
1290 EXPECT_TRUE(success);
1291 }
1292
TEST(TimeTicks,HighRes)1293 TEST(TimeTicks, HighRes) {
1294 HighResClockTest(&TimeTicks::Now);
1295 }
1296
1297 class TimeTicksOverride {
1298 public:
Now()1299 static TimeTicks Now() {
1300 now_ticks_ += TimeDelta::FromSeconds(1);
1301 return now_ticks_;
1302 }
1303
1304 static TimeTicks now_ticks_;
1305 };
1306
1307 // static
1308 TimeTicks TimeTicksOverride::now_ticks_;
1309
TEST(TimeTicks,NowOverride)1310 TEST(TimeTicks, NowOverride) {
1311 TimeTicksOverride::now_ticks_ = TimeTicks::Min();
1312
1313 // Override is not active. All Now() methods should return a sensible value.
1314 EXPECT_LT(TimeTicks::Min(), TimeTicks::UnixEpoch());
1315 EXPECT_LT(TimeTicks::UnixEpoch(), TimeTicks::Now());
1316 EXPECT_GT(TimeTicks::Max(), TimeTicks::Now());
1317 EXPECT_LT(TimeTicks::UnixEpoch(), subtle::TimeTicksNowIgnoringOverride());
1318 EXPECT_GT(TimeTicks::Max(), subtle::TimeTicksNowIgnoringOverride());
1319
1320 {
1321 // Set override.
1322 subtle::ScopedTimeClockOverrides overrides(nullptr, &TimeTicksOverride::Now,
1323 nullptr);
1324
1325 // Overridden value is returned and incremented when Now() is called.
1326 EXPECT_EQ(TimeTicks::Min() + TimeDelta::FromSeconds(1), TimeTicks::Now());
1327 EXPECT_EQ(TimeTicks::Min() + TimeDelta::FromSeconds(2), TimeTicks::Now());
1328
1329 // NowIgnoringOverride() still returns real ticks.
1330 EXPECT_LT(TimeTicks::UnixEpoch(), subtle::TimeTicksNowIgnoringOverride());
1331 EXPECT_GT(TimeTicks::Max(), subtle::TimeTicksNowIgnoringOverride());
1332
1333 // IgnoringOverride methods didn't call NowOverrideTickClock::NowTicks().
1334 EXPECT_EQ(TimeTicks::Min() + TimeDelta::FromSeconds(3), TimeTicks::Now());
1335 }
1336
1337 // All methods return real ticks again.
1338 EXPECT_LT(TimeTicks::UnixEpoch(), TimeTicks::Now());
1339 EXPECT_GT(TimeTicks::Max(), TimeTicks::Now());
1340 EXPECT_LT(TimeTicks::UnixEpoch(), subtle::TimeTicksNowIgnoringOverride());
1341 EXPECT_GT(TimeTicks::Max(), subtle::TimeTicksNowIgnoringOverride());
1342 }
1343
1344 class ThreadTicksOverride {
1345 public:
Now()1346 static ThreadTicks Now() {
1347 now_ticks_ += TimeDelta::FromSeconds(1);
1348 return now_ticks_;
1349 }
1350
1351 static ThreadTicks now_ticks_;
1352 };
1353
1354 // static
1355 ThreadTicks ThreadTicksOverride::now_ticks_;
1356
1357 // IOS doesn't support ThreadTicks::Now().
1358 #if defined(OS_IOS)
1359 #define MAYBE_NowOverride DISABLED_NowOverride
1360 #else
1361 #define MAYBE_NowOverride NowOverride
1362 #endif
TEST(ThreadTicks,MAYBE_NowOverride)1363 TEST(ThreadTicks, MAYBE_NowOverride) {
1364 ThreadTicksOverride::now_ticks_ = ThreadTicks::Min();
1365
1366 // Override is not active. All Now() methods should return a sensible value.
1367 ThreadTicks initial_thread_ticks = ThreadTicks::Now();
1368 EXPECT_LE(initial_thread_ticks, ThreadTicks::Now());
1369 EXPECT_GT(ThreadTicks::Max(), ThreadTicks::Now());
1370 EXPECT_LE(initial_thread_ticks, subtle::ThreadTicksNowIgnoringOverride());
1371 EXPECT_GT(ThreadTicks::Max(), subtle::ThreadTicksNowIgnoringOverride());
1372
1373 {
1374 // Set override.
1375 subtle::ScopedTimeClockOverrides overrides(nullptr, nullptr,
1376 &ThreadTicksOverride::Now);
1377
1378 // Overridden value is returned and incremented when Now() is called.
1379 EXPECT_EQ(ThreadTicks::Min() + TimeDelta::FromSeconds(1),
1380 ThreadTicks::Now());
1381 EXPECT_EQ(ThreadTicks::Min() + TimeDelta::FromSeconds(2),
1382 ThreadTicks::Now());
1383
1384 // NowIgnoringOverride() still returns real ticks.
1385 EXPECT_LE(initial_thread_ticks, subtle::ThreadTicksNowIgnoringOverride());
1386 EXPECT_GT(ThreadTicks::Max(), subtle::ThreadTicksNowIgnoringOverride());
1387
1388 // IgnoringOverride methods didn't call NowOverrideTickClock::NowTicks().
1389 EXPECT_EQ(ThreadTicks::Min() + TimeDelta::FromSeconds(3),
1390 ThreadTicks::Now());
1391 }
1392
1393 // All methods return real ticks again.
1394 EXPECT_LE(initial_thread_ticks, ThreadTicks::Now());
1395 EXPECT_GT(ThreadTicks::Max(), ThreadTicks::Now());
1396 EXPECT_LE(initial_thread_ticks, subtle::ThreadTicksNowIgnoringOverride());
1397 EXPECT_GT(ThreadTicks::Max(), subtle::ThreadTicksNowIgnoringOverride());
1398 }
1399
TEST(ThreadTicks,ThreadNow)1400 TEST(ThreadTicks, ThreadNow) {
1401 if (ThreadTicks::IsSupported()) {
1402 ThreadTicks::WaitUntilInitialized();
1403 TimeTicks begin = TimeTicks::Now();
1404 ThreadTicks begin_thread = ThreadTicks::Now();
1405 // Make sure that ThreadNow value is non-zero.
1406 EXPECT_GT(begin_thread, ThreadTicks());
1407 // Sleep for 10 milliseconds to get the thread de-scheduled.
1408 base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(10));
1409 ThreadTicks end_thread = ThreadTicks::Now();
1410 TimeTicks end = TimeTicks::Now();
1411 TimeDelta delta = end - begin;
1412 TimeDelta delta_thread = end_thread - begin_thread;
1413 // Make sure that some thread time have elapsed.
1414 EXPECT_GE(delta_thread.InMicroseconds(), 0);
1415 // But the thread time is at least 9ms less than clock time.
1416 TimeDelta difference = delta - delta_thread;
1417 EXPECT_GE(difference.InMicroseconds(), 9000);
1418 }
1419 }
1420
TEST(TimeTicks,SnappedToNextTickBasic)1421 TEST(TimeTicks, SnappedToNextTickBasic) {
1422 base::TimeTicks phase = base::TimeTicks::FromInternalValue(4000);
1423 base::TimeDelta interval = base::TimeDelta::FromMicroseconds(1000);
1424 base::TimeTicks timestamp;
1425
1426 // Timestamp in previous interval.
1427 timestamp = base::TimeTicks::FromInternalValue(3500);
1428 EXPECT_EQ(4000,
1429 timestamp.SnappedToNextTick(phase, interval).ToInternalValue());
1430
1431 // Timestamp in next interval.
1432 timestamp = base::TimeTicks::FromInternalValue(4500);
1433 EXPECT_EQ(5000,
1434 timestamp.SnappedToNextTick(phase, interval).ToInternalValue());
1435
1436 // Timestamp multiple intervals before.
1437 timestamp = base::TimeTicks::FromInternalValue(2500);
1438 EXPECT_EQ(3000,
1439 timestamp.SnappedToNextTick(phase, interval).ToInternalValue());
1440
1441 // Timestamp multiple intervals after.
1442 timestamp = base::TimeTicks::FromInternalValue(6500);
1443 EXPECT_EQ(7000,
1444 timestamp.SnappedToNextTick(phase, interval).ToInternalValue());
1445
1446 // Timestamp on previous interval.
1447 timestamp = base::TimeTicks::FromInternalValue(3000);
1448 EXPECT_EQ(3000,
1449 timestamp.SnappedToNextTick(phase, interval).ToInternalValue());
1450
1451 // Timestamp on next interval.
1452 timestamp = base::TimeTicks::FromInternalValue(5000);
1453 EXPECT_EQ(5000,
1454 timestamp.SnappedToNextTick(phase, interval).ToInternalValue());
1455
1456 // Timestamp equal to phase.
1457 timestamp = base::TimeTicks::FromInternalValue(4000);
1458 EXPECT_EQ(4000,
1459 timestamp.SnappedToNextTick(phase, interval).ToInternalValue());
1460 }
1461
TEST(TimeTicks,SnappedToNextTickOverflow)1462 TEST(TimeTicks, SnappedToNextTickOverflow) {
1463 // int(big_timestamp / interval) < 0, so this causes a crash if the number of
1464 // intervals elapsed is attempted to be stored in an int.
1465 base::TimeTicks phase = base::TimeTicks::FromInternalValue(0);
1466 base::TimeDelta interval = base::TimeDelta::FromMicroseconds(4000);
1467 base::TimeTicks big_timestamp =
1468 base::TimeTicks::FromInternalValue(8635916564000);
1469
1470 EXPECT_EQ(8635916564000,
1471 big_timestamp.SnappedToNextTick(phase, interval).ToInternalValue());
1472 EXPECT_EQ(8635916564000,
1473 big_timestamp.SnappedToNextTick(big_timestamp, interval)
1474 .ToInternalValue());
1475 }
1476
1477 #if defined(OS_ANDROID)
TEST(TimeTicks,Android_FromUptimeMillis_ClocksMatch)1478 TEST(TimeTicks, Android_FromUptimeMillis_ClocksMatch) {
1479 JNIEnv* const env = android::AttachCurrentThread();
1480 android::ScopedJavaLocalRef<jclass> clazz(
1481 android::GetClass(env, "android/os/SystemClock"));
1482 ASSERT_TRUE(clazz.obj());
1483 const jmethodID method_id =
1484 android::MethodID::Get<android::MethodID::TYPE_STATIC>(
1485 env, clazz.obj(), "uptimeMillis", "()J");
1486 ASSERT_FALSE(!method_id);
1487 // Subtract 1ms from the expected lower bound to allow millisecon-level
1488 // truncation performed in uptimeMillis().
1489 const TimeTicks lower_bound_ticks =
1490 TimeTicks::Now() - TimeDelta::FromMilliseconds(1);
1491 const TimeTicks converted_ticks = TimeTicks::FromUptimeMillis(
1492 env->CallStaticLongMethod(clazz.obj(), method_id));
1493 const TimeTicks upper_bound_ticks = TimeTicks::Now();
1494 EXPECT_LE(lower_bound_ticks, converted_ticks);
1495 EXPECT_GE(upper_bound_ticks, converted_ticks);
1496 }
1497 #endif // OS_ANDROID
1498
TEST(TimeDelta,FromAndIn)1499 TEST(TimeDelta, FromAndIn) {
1500 // static_assert also checks that the contained expression is a constant
1501 // expression, meaning all its components are suitable for initializing global
1502 // variables.
1503 static_assert(TimeDelta::FromDays(2) == TimeDelta::FromHours(48), "");
1504 static_assert(TimeDelta::FromHours(3) == TimeDelta::FromMinutes(180), "");
1505 static_assert(TimeDelta::FromMinutes(2) == TimeDelta::FromSeconds(120), "");
1506 static_assert(TimeDelta::FromSeconds(2) == TimeDelta::FromMilliseconds(2000),
1507 "");
1508 static_assert(
1509 TimeDelta::FromMilliseconds(2) == TimeDelta::FromMicroseconds(2000), "");
1510 static_assert(
1511 TimeDelta::FromSecondsD(2.3) == TimeDelta::FromMilliseconds(2300), "");
1512 static_assert(
1513 TimeDelta::FromMillisecondsD(2.5) == TimeDelta::FromMicroseconds(2500),
1514 "");
1515 EXPECT_EQ(TimeDelta::FromDays(13).InDays(), 13);
1516 static_assert(TimeDelta::FromHours(13).InHours() == 13, "");
1517 static_assert(TimeDelta::FromMinutes(13).InMinutes() == 13, "");
1518 EXPECT_EQ(TimeDelta::FromSeconds(13).InSeconds(), 13);
1519 EXPECT_EQ(TimeDelta::FromSeconds(13).InSecondsF(), 13.0);
1520 EXPECT_EQ(TimeDelta::FromMilliseconds(13).InMilliseconds(), 13);
1521 EXPECT_EQ(TimeDelta::FromMilliseconds(13).InMillisecondsF(), 13.0);
1522 EXPECT_EQ(TimeDelta::FromSecondsD(13.1).InSeconds(), 13);
1523 EXPECT_EQ(TimeDelta::FromSecondsD(13.1).InSecondsF(), 13.1);
1524 EXPECT_EQ(TimeDelta::FromMillisecondsD(13.3).InMilliseconds(), 13);
1525 EXPECT_EQ(TimeDelta::FromMillisecondsD(13.3).InMillisecondsF(), 13.3);
1526 static_assert(TimeDelta::FromMicroseconds(13).InMicroseconds() == 13, "");
1527 static_assert(TimeDelta::FromMicrosecondsD(13.3).InMicroseconds() == 13, "");
1528 EXPECT_EQ(TimeDelta::FromMillisecondsD(3.45678).InMillisecondsF(), 3.456);
1529 static_assert(TimeDelta::FromNanoseconds(12345).InNanoseconds() == 12000, "");
1530 static_assert(TimeDelta::FromNanosecondsD(12345.678).InNanoseconds() == 12000,
1531 "");
1532 }
1533
TEST(TimeDelta,InRoundsTowardsZero)1534 TEST(TimeDelta, InRoundsTowardsZero) {
1535 EXPECT_EQ(TimeDelta::FromHours(23).InDays(), 0);
1536 EXPECT_EQ(TimeDelta::FromHours(-23).InDays(), 0);
1537 static_assert(TimeDelta::FromMinutes(59).InHours() == 0, "");
1538 static_assert(TimeDelta::FromMinutes(-59).InHours() == 0, "");
1539 static_assert(TimeDelta::FromSeconds(59).InMinutes() == 0, "");
1540 static_assert(TimeDelta::FromSeconds(-59).InMinutes() == 0, "");
1541 EXPECT_EQ(TimeDelta::FromMilliseconds(999).InSeconds(), 0);
1542 EXPECT_EQ(TimeDelta::FromMilliseconds(-999).InSeconds(), 0);
1543 EXPECT_EQ(TimeDelta::FromMicroseconds(999).InMilliseconds(), 0);
1544 EXPECT_EQ(TimeDelta::FromMicroseconds(-999).InMilliseconds(), 0);
1545 }
1546
TEST(TimeDelta,InDaysFloored)1547 TEST(TimeDelta, InDaysFloored) {
1548 EXPECT_EQ(TimeDelta::FromHours(-25).InDaysFloored(), -2);
1549 EXPECT_EQ(TimeDelta::FromHours(-24).InDaysFloored(), -1);
1550 EXPECT_EQ(TimeDelta::FromHours(-23).InDaysFloored(), -1);
1551
1552 EXPECT_EQ(TimeDelta::FromHours(-1).InDaysFloored(), -1);
1553 EXPECT_EQ(TimeDelta::FromHours(0).InDaysFloored(), 0);
1554 EXPECT_EQ(TimeDelta::FromHours(1).InDaysFloored(), 0);
1555
1556 EXPECT_EQ(TimeDelta::FromHours(23).InDaysFloored(), 0);
1557 EXPECT_EQ(TimeDelta::FromHours(24).InDaysFloored(), 1);
1558 EXPECT_EQ(TimeDelta::FromHours(25).InDaysFloored(), 1);
1559 }
1560
TEST(TimeDelta,InMillisecondsRoundedUp)1561 TEST(TimeDelta, InMillisecondsRoundedUp) {
1562 EXPECT_EQ(TimeDelta::FromMicroseconds(-1001).InMillisecondsRoundedUp(), -1);
1563 EXPECT_EQ(TimeDelta::FromMicroseconds(-1000).InMillisecondsRoundedUp(), -1);
1564 EXPECT_EQ(TimeDelta::FromMicroseconds(-999).InMillisecondsRoundedUp(), 0);
1565
1566 EXPECT_EQ(TimeDelta::FromMicroseconds(-1).InMillisecondsRoundedUp(), 0);
1567 EXPECT_EQ(TimeDelta::FromMicroseconds(0).InMillisecondsRoundedUp(), 0);
1568 EXPECT_EQ(TimeDelta::FromMicroseconds(1).InMillisecondsRoundedUp(), 1);
1569
1570 EXPECT_EQ(TimeDelta::FromMicroseconds(999).InMillisecondsRoundedUp(), 1);
1571 EXPECT_EQ(TimeDelta::FromMicroseconds(1000).InMillisecondsRoundedUp(), 1);
1572 EXPECT_EQ(TimeDelta::FromMicroseconds(1001).InMillisecondsRoundedUp(), 2);
1573 }
1574
1575 // Check that near-min/max values saturate rather than overflow when converted
1576 // lossily with InXXX() functions. Only integral hour, minute, and nanosecond
1577 // conversions are checked, since those are the only cases where the return type
1578 // is small enough for saturation or overflow to occur.
TEST(TimeDelta,InXXXOverflow)1579 TEST(TimeDelta, InXXXOverflow) {
1580 constexpr TimeDelta kLargeDelta =
1581 TimeDelta::FromMicroseconds(std::numeric_limits<int64_t>::max() - 1);
1582 static_assert(!kLargeDelta.is_max(), "");
1583 static_assert(std::numeric_limits<int>::max() == kLargeDelta.InHours(), "");
1584 static_assert(std::numeric_limits<int>::max() == kLargeDelta.InMinutes(), "");
1585 static_assert(
1586 std::numeric_limits<int64_t>::max() == kLargeDelta.InNanoseconds(), "");
1587
1588 constexpr TimeDelta kLargeNegative =
1589 TimeDelta::FromMicroseconds(std::numeric_limits<int64_t>::min() + 1);
1590 static_assert(!kLargeNegative.is_min(), "");
1591 static_assert(std::numeric_limits<int>::min() == kLargeNegative.InHours(),
1592 "");
1593 static_assert(std::numeric_limits<int>::min() == kLargeNegative.InMinutes(),
1594 "");
1595 static_assert(
1596 std::numeric_limits<int64_t>::min() == kLargeNegative.InNanoseconds(),
1597 "");
1598 }
1599
1600 #if defined(OS_POSIX) || defined(OS_FUCHSIA)
TEST(TimeDelta,TimeSpecConversion)1601 TEST(TimeDelta, TimeSpecConversion) {
1602 TimeDelta delta = TimeDelta::FromSeconds(0);
1603 struct timespec result = delta.ToTimeSpec();
1604 EXPECT_EQ(result.tv_sec, 0);
1605 EXPECT_EQ(result.tv_nsec, 0);
1606 EXPECT_EQ(delta, TimeDelta::FromTimeSpec(result));
1607
1608 delta = TimeDelta::FromSeconds(1);
1609 result = delta.ToTimeSpec();
1610 EXPECT_EQ(result.tv_sec, 1);
1611 EXPECT_EQ(result.tv_nsec, 0);
1612 EXPECT_EQ(delta, TimeDelta::FromTimeSpec(result));
1613
1614 delta = TimeDelta::FromMicroseconds(1);
1615 result = delta.ToTimeSpec();
1616 EXPECT_EQ(result.tv_sec, 0);
1617 EXPECT_EQ(result.tv_nsec, 1000);
1618 EXPECT_EQ(delta, TimeDelta::FromTimeSpec(result));
1619
1620 delta = TimeDelta::FromMicroseconds(Time::kMicrosecondsPerSecond + 1);
1621 result = delta.ToTimeSpec();
1622 EXPECT_EQ(result.tv_sec, 1);
1623 EXPECT_EQ(result.tv_nsec, 1000);
1624 EXPECT_EQ(delta, TimeDelta::FromTimeSpec(result));
1625 }
1626 #endif // defined(OS_POSIX) || defined(OS_FUCHSIA)
1627
1628 // Our internal time format is serialized in things like databases, so it's
1629 // important that it's consistent across all our platforms. We use the 1601
1630 // Windows epoch as the internal format across all platforms.
TEST(TimeDelta,WindowsEpoch)1631 TEST(TimeDelta, WindowsEpoch) {
1632 Time::Exploded exploded;
1633 exploded.year = 1970;
1634 exploded.month = 1;
1635 exploded.day_of_week = 0; // Should be unusued.
1636 exploded.day_of_month = 1;
1637 exploded.hour = 0;
1638 exploded.minute = 0;
1639 exploded.second = 0;
1640 exploded.millisecond = 0;
1641 Time t;
1642 EXPECT_TRUE(Time::FromUTCExploded(exploded, &t));
1643 // Unix 1970 epoch.
1644 EXPECT_EQ(INT64_C(11644473600000000), t.ToInternalValue());
1645
1646 // We can't test 1601 epoch, since the system time functions on Linux
1647 // only compute years starting from 1900.
1648 }
1649
TEST(TimeDelta,Hz)1650 TEST(TimeDelta, Hz) {
1651 static_assert(TimeDelta::FromHz(1) == TimeDelta::FromSeconds(1), "");
1652 EXPECT_EQ(TimeDelta::FromHz(0), TimeDelta::Max());
1653 static_assert(TimeDelta::FromHz(-1) == TimeDelta::FromSeconds(-1), "");
1654 static_assert(TimeDelta::FromHz(1000) == TimeDelta::FromMilliseconds(1), "");
1655 static_assert(TimeDelta::FromHz(0.5) == TimeDelta::FromSeconds(2), "");
1656 EXPECT_EQ(TimeDelta::FromHz(std::numeric_limits<double>::infinity()),
1657 TimeDelta());
1658
1659 static_assert(TimeDelta::FromSeconds(1).ToHz() == 1, "");
1660 EXPECT_EQ(TimeDelta::Max().ToHz(), 0);
1661 static_assert(TimeDelta::FromSeconds(-1).ToHz() == -1, "");
1662 static_assert(TimeDelta::FromMilliseconds(1).ToHz() == 1000, "");
1663 static_assert(TimeDelta::FromSeconds(2).ToHz() == 0.5, "");
1664 EXPECT_EQ(TimeDelta().ToHz(), std::numeric_limits<double>::infinity());
1665
1666 // 60 Hz can't be represented exactly.
1667 EXPECT_NE(TimeDelta::FromHz(60) * 60, TimeDelta::FromSeconds(1));
1668 EXPECT_NE(TimeDelta::FromHz(60).ToHz(), 60);
1669 EXPECT_EQ(base::ClampRound(TimeDelta::FromHz(60).ToHz()), 60);
1670 }
1671
1672 // We could define this separately for Time, TimeTicks and TimeDelta but the
1673 // definitions would be identical anyway.
1674 template <class Any>
AnyToString(Any any)1675 std::string AnyToString(Any any) {
1676 std::ostringstream oss;
1677 oss << any;
1678 return oss.str();
1679 }
1680
TEST(TimeDelta,Magnitude)1681 TEST(TimeDelta, Magnitude) {
1682 constexpr int64_t zero = 0;
1683 static_assert(TimeDelta::FromMicroseconds(zero) ==
1684 TimeDelta::FromMicroseconds(zero).magnitude(),
1685 "");
1686
1687 constexpr int64_t one = 1;
1688 constexpr int64_t negative_one = -1;
1689 static_assert(TimeDelta::FromMicroseconds(one) ==
1690 TimeDelta::FromMicroseconds(one).magnitude(),
1691 "");
1692 static_assert(TimeDelta::FromMicroseconds(one) ==
1693 TimeDelta::FromMicroseconds(negative_one).magnitude(),
1694 "");
1695
1696 constexpr int64_t max_int64_minus_one =
1697 std::numeric_limits<int64_t>::max() - 1;
1698 constexpr int64_t min_int64_plus_two =
1699 std::numeric_limits<int64_t>::min() + 2;
1700 static_assert(
1701 TimeDelta::FromMicroseconds(max_int64_minus_one) ==
1702 TimeDelta::FromMicroseconds(max_int64_minus_one).magnitude(),
1703 "");
1704 static_assert(TimeDelta::FromMicroseconds(max_int64_minus_one) ==
1705 TimeDelta::FromMicroseconds(min_int64_plus_two).magnitude(),
1706 "");
1707
1708 static_assert(TimeDelta::Max() == TimeDelta::Min().magnitude(), "");
1709 }
1710
TEST(TimeDelta,ZeroMinMax)1711 TEST(TimeDelta, ZeroMinMax) {
1712 constexpr TimeDelta kZero;
1713 static_assert(kZero.is_zero(), "");
1714
1715 constexpr TimeDelta kMax = TimeDelta::Max();
1716 static_assert(kMax.is_max(), "");
1717 static_assert(kMax == TimeDelta::Max(), "");
1718 static_assert(kMax > TimeDelta::FromDays(100 * 365), "");
1719 static_assert(kMax > kZero, "");
1720
1721 constexpr TimeDelta kMin = TimeDelta::Min();
1722 static_assert(kMin.is_min(), "");
1723 static_assert(kMin == TimeDelta::Min(), "");
1724 static_assert(kMin < TimeDelta::FromDays(-100 * 365), "");
1725 static_assert(kMin < kZero, "");
1726 }
1727
TEST(TimeDelta,MaxConversions)1728 TEST(TimeDelta, MaxConversions) {
1729 // static_assert also confirms constexpr works as intended.
1730 constexpr TimeDelta kMax = TimeDelta::Max();
1731 static_assert(kMax.ToInternalValue() == std::numeric_limits<int64_t>::max(),
1732 "");
1733 EXPECT_EQ(kMax.InDays(), std::numeric_limits<int>::max());
1734 static_assert(kMax.InHours() == std::numeric_limits<int>::max(), "");
1735 static_assert(kMax.InMinutes() == std::numeric_limits<int>::max(), "");
1736 EXPECT_EQ(kMax.InSecondsF(), std::numeric_limits<double>::infinity());
1737 EXPECT_EQ(kMax.InSeconds(), std::numeric_limits<int64_t>::max());
1738 EXPECT_EQ(kMax.InMillisecondsF(), std::numeric_limits<double>::infinity());
1739 EXPECT_EQ(kMax.InMilliseconds(), std::numeric_limits<int64_t>::max());
1740 EXPECT_EQ(kMax.InMillisecondsRoundedUp(), std::numeric_limits<int64_t>::max());
1741
1742 static_assert(TimeDelta::FromDays(std::numeric_limits<int>::max()).is_max(),
1743 "");
1744
1745 static_assert(TimeDelta::FromHours(std::numeric_limits<int>::max()).is_max(),
1746 "");
1747
1748 static_assert(
1749 TimeDelta::FromMinutes(std::numeric_limits<int>::max()).is_max(), "");
1750
1751 constexpr int64_t max_int = std::numeric_limits<int64_t>::max();
1752 constexpr int64_t min_int = std::numeric_limits<int64_t>::min();
1753
1754 static_assert(
1755 TimeDelta::FromSeconds(max_int / Time::kMicrosecondsPerSecond + 1)
1756 .is_max(),
1757 "");
1758
1759 static_assert(
1760 TimeDelta::FromMilliseconds(max_int / Time::kMillisecondsPerSecond + 1)
1761 .is_max(),
1762 "");
1763
1764 static_assert(TimeDelta::FromMicroseconds(max_int).is_max(), "");
1765
1766 static_assert(
1767 TimeDelta::FromSeconds(min_int / Time::kMicrosecondsPerSecond - 1)
1768 .is_min(),
1769 "");
1770
1771 static_assert(
1772 TimeDelta::FromMilliseconds(min_int / Time::kMillisecondsPerSecond - 1)
1773 .is_min(),
1774 "");
1775
1776 static_assert(TimeDelta::FromMicroseconds(min_int).is_min(), "");
1777
1778 static_assert(
1779 TimeDelta::FromMicroseconds(std::numeric_limits<int64_t>::min()).is_min(),
1780 "");
1781
1782 // Floating point arithmetic resulting in infinity isn't constexpr in C++14.
1783 EXPECT_TRUE(TimeDelta::FromSecondsD(std::numeric_limits<double>::infinity())
1784 .is_max());
1785
1786 // Note that max_int/min_int will be rounded when converted to doubles - they
1787 // can't be exactly represented.
1788 constexpr double max_d = static_cast<double>(max_int);
1789 constexpr double min_d = static_cast<double>(min_int);
1790
1791 static_assert(
1792 TimeDelta::FromSecondsD(max_d / Time::kMicrosecondsPerSecond + 1)
1793 .is_max(),
1794 "");
1795
1796 static_assert(
1797 TimeDelta::FromMicrosecondsD(max_d).is_max(),
1798 "Make sure that 2^63 correctly gets clamped to `max` (crbug.com/612601)");
1799
1800 // Floating point arithmetic resulting in infinity isn't constexpr in C++14.
1801 EXPECT_TRUE(
1802 TimeDelta::FromMillisecondsD(std::numeric_limits<double>::infinity())
1803 .is_max());
1804
1805 static_assert(
1806 TimeDelta::FromMillisecondsD(max_d / Time::kMillisecondsPerSecond * 2)
1807 .is_max(),
1808 "");
1809
1810 static_assert(
1811 TimeDelta::FromSecondsD(min_d / Time::kMicrosecondsPerSecond - 1)
1812 .is_min(),
1813 "");
1814
1815 static_assert(
1816 TimeDelta::FromMillisecondsD(min_d / Time::kMillisecondsPerSecond * 2)
1817 .is_min(),
1818 "");
1819 }
1820
TEST(TimeDelta,MinConversions)1821 TEST(TimeDelta, MinConversions) {
1822 constexpr TimeDelta kMin = TimeDelta::Min();
1823
1824 EXPECT_EQ(kMin.InDays(), std::numeric_limits<int>::min());
1825 static_assert(kMin.InHours() == std::numeric_limits<int>::min(), "");
1826 static_assert(kMin.InMinutes() == std::numeric_limits<int>::min(), "");
1827 EXPECT_EQ(kMin.InSecondsF(), -std::numeric_limits<double>::infinity());
1828 EXPECT_EQ(kMin.InSeconds(), std::numeric_limits<int64_t>::min());
1829 EXPECT_EQ(kMin.InMillisecondsF(), -std::numeric_limits<double>::infinity());
1830 EXPECT_EQ(kMin.InMilliseconds(), std::numeric_limits<int64_t>::min());
1831 EXPECT_EQ(kMin.InMillisecondsRoundedUp(),
1832 std::numeric_limits<int64_t>::min());
1833 }
1834
TEST(TimeDelta,NumericOperators)1835 TEST(TimeDelta, NumericOperators) {
1836 constexpr double d = 0.5;
1837 EXPECT_EQ(TimeDelta::FromMilliseconds(500),
1838 (TimeDelta::FromMilliseconds(1000) * d));
1839 static_assert(TimeDelta::FromMilliseconds(2000) ==
1840 (TimeDelta::FromMilliseconds(1000) / d),
1841 "");
1842 EXPECT_EQ(TimeDelta::FromMilliseconds(500),
1843 (TimeDelta::FromMilliseconds(1000) *= d));
1844 static_assert(TimeDelta::FromMilliseconds(2000) ==
1845 (TimeDelta::FromMilliseconds(1000) /= d),
1846 "");
1847 EXPECT_EQ(TimeDelta::FromMilliseconds(500),
1848 (d * TimeDelta::FromMilliseconds(1000)));
1849
1850 constexpr float f = 0.5;
1851 EXPECT_EQ(TimeDelta::FromMilliseconds(500),
1852 (TimeDelta::FromMilliseconds(1000) * f));
1853 static_assert(TimeDelta::FromMilliseconds(2000) ==
1854 (TimeDelta::FromMilliseconds(1000) / f),
1855 "");
1856 EXPECT_EQ(TimeDelta::FromMilliseconds(500),
1857 (TimeDelta::FromMilliseconds(1000) *= f));
1858 static_assert(TimeDelta::FromMilliseconds(2000) ==
1859 (TimeDelta::FromMilliseconds(1000) /= f),
1860 "");
1861 EXPECT_EQ(TimeDelta::FromMilliseconds(500),
1862 (f * TimeDelta::FromMilliseconds(1000)));
1863
1864 constexpr int i = 2;
1865 EXPECT_EQ(TimeDelta::FromMilliseconds(2000),
1866 (TimeDelta::FromMilliseconds(1000) * i));
1867 static_assert(TimeDelta::FromMilliseconds(500) ==
1868 (TimeDelta::FromMilliseconds(1000) / i),
1869 "");
1870 EXPECT_EQ(TimeDelta::FromMilliseconds(2000),
1871 (TimeDelta::FromMilliseconds(1000) *= i));
1872 static_assert(TimeDelta::FromMilliseconds(500) ==
1873 (TimeDelta::FromMilliseconds(1000) /= i),
1874 "");
1875 EXPECT_EQ(TimeDelta::FromMilliseconds(2000),
1876 (i * TimeDelta::FromMilliseconds(1000)));
1877
1878 constexpr int64_t i64 = 2;
1879 EXPECT_EQ(TimeDelta::FromMilliseconds(2000),
1880 (TimeDelta::FromMilliseconds(1000) * i64));
1881 static_assert(TimeDelta::FromMilliseconds(500) ==
1882 (TimeDelta::FromMilliseconds(1000) / i64),
1883 "");
1884 EXPECT_EQ(TimeDelta::FromMilliseconds(2000),
1885 (TimeDelta::FromMilliseconds(1000) *= i64));
1886 static_assert(TimeDelta::FromMilliseconds(500) ==
1887 (TimeDelta::FromMilliseconds(1000) /= i64),
1888 "");
1889 EXPECT_EQ(TimeDelta::FromMilliseconds(2000),
1890 (i64 * TimeDelta::FromMilliseconds(1000)));
1891
1892 EXPECT_EQ(TimeDelta::FromMilliseconds(500),
1893 (TimeDelta::FromMilliseconds(1000) * 0.5));
1894 static_assert(TimeDelta::FromMilliseconds(2000) ==
1895 (TimeDelta::FromMilliseconds(1000) / 0.5),
1896 "");
1897 EXPECT_EQ(TimeDelta::FromMilliseconds(500),
1898 (TimeDelta::FromMilliseconds(1000) *= 0.5));
1899 static_assert(TimeDelta::FromMilliseconds(2000) ==
1900 (TimeDelta::FromMilliseconds(1000) /= 0.5),
1901 "");
1902 EXPECT_EQ(TimeDelta::FromMilliseconds(500),
1903 (0.5 * TimeDelta::FromMilliseconds(1000)));
1904
1905 EXPECT_EQ(TimeDelta::FromMilliseconds(2000),
1906 (TimeDelta::FromMilliseconds(1000) * 2));
1907 static_assert(TimeDelta::FromMilliseconds(500) ==
1908 (TimeDelta::FromMilliseconds(1000) / 2),
1909 "");
1910 EXPECT_EQ(TimeDelta::FromMilliseconds(2000),
1911 (TimeDelta::FromMilliseconds(1000) *= 2));
1912 static_assert(TimeDelta::FromMilliseconds(500) ==
1913 (TimeDelta::FromMilliseconds(1000) /= 2),
1914 "");
1915 EXPECT_EQ(TimeDelta::FromMilliseconds(2000),
1916 (2 * TimeDelta::FromMilliseconds(1000)));
1917 }
1918
1919 // Basic test of operators between TimeDeltas (without overflow -- next test
1920 // handles overflow).
TEST(TimeDelta,TimeDeltaOperators)1921 TEST(TimeDelta, TimeDeltaOperators) {
1922 constexpr TimeDelta kElevenSeconds = TimeDelta::FromSeconds(11);
1923 constexpr TimeDelta kThreeSeconds = TimeDelta::FromSeconds(3);
1924
1925 static_assert(TimeDelta::FromSeconds(14) == kElevenSeconds + kThreeSeconds,
1926 "");
1927 static_assert(TimeDelta::FromSeconds(14) == kThreeSeconds + kElevenSeconds,
1928 "");
1929 static_assert(TimeDelta::FromSeconds(8) == kElevenSeconds - kThreeSeconds,
1930 "");
1931 static_assert(TimeDelta::FromSeconds(-8) == kThreeSeconds - kElevenSeconds,
1932 "");
1933 static_assert(11.0 / 3.0 == kElevenSeconds / kThreeSeconds, "");
1934 static_assert(3.0 / 11.0 == kThreeSeconds / kElevenSeconds, "");
1935 static_assert(3 == kElevenSeconds.IntDiv(kThreeSeconds), "");
1936 static_assert(0 == kThreeSeconds.IntDiv(kElevenSeconds), "");
1937 static_assert(TimeDelta::FromSeconds(2) == kElevenSeconds % kThreeSeconds,
1938 "");
1939 }
1940
TEST(TimeDelta,Overflows)1941 TEST(TimeDelta, Overflows) {
1942 // Some sanity checks. static_asserts used where possible to verify constexpr
1943 // evaluation at the same time.
1944 static_assert(TimeDelta::Max().is_max(), "");
1945 static_assert(-TimeDelta::Max() < TimeDelta(), "");
1946 static_assert(-TimeDelta::Max() == TimeDelta::Min(), "");
1947 static_assert(TimeDelta() > -TimeDelta::Max(), "");
1948
1949 static_assert(TimeDelta::Min().is_min(), "");
1950 static_assert(-TimeDelta::Min() > TimeDelta(), "");
1951 static_assert(-TimeDelta::Min() == TimeDelta::Max(), "");
1952 static_assert(TimeDelta() < -TimeDelta::Min(), "");
1953
1954 constexpr TimeDelta kLargeDelta =
1955 TimeDelta::Max() - TimeDelta::FromMilliseconds(1);
1956 constexpr TimeDelta kLargeNegative = -kLargeDelta;
1957 static_assert(TimeDelta() > kLargeNegative, "");
1958 static_assert(!kLargeDelta.is_max(), "");
1959 static_assert(!(-kLargeNegative).is_min(), "");
1960
1961 // Test +, -, * and / operators.
1962 constexpr TimeDelta kOneSecond = TimeDelta::FromSeconds(1);
1963 static_assert((kLargeDelta + kOneSecond).is_max(), "");
1964 static_assert((kLargeNegative + (-kOneSecond)).is_min(), "");
1965 static_assert((kLargeNegative - kOneSecond).is_min(), "");
1966 static_assert((kLargeDelta - (-kOneSecond)).is_max(), "");
1967 static_assert((kLargeDelta * 2).is_max(), "");
1968 static_assert((kLargeDelta * -2).is_min(), "");
1969 EXPECT_TRUE((kLargeDelta / 0.5).is_max());
1970 EXPECT_TRUE((kLargeDelta / -0.5).is_min());
1971
1972 #if !defined(OS_BSD)
1973 static_assert(
1974 TimeDelta::Max() / kOneSecond == std::numeric_limits<double>::infinity(),
1975 "");
1976 static_assert(TimeDelta::Max() / -kOneSecond ==
1977 -std::numeric_limits<double>::infinity(),
1978 "");
1979 static_assert(
1980 TimeDelta::Min() / kOneSecond == -std::numeric_limits<double>::infinity(),
1981 "");
1982 static_assert(
1983 TimeDelta::Min() / -kOneSecond == std::numeric_limits<double>::infinity(),
1984 "");
1985 static_assert(TimeDelta::Max().IntDiv(kOneSecond) ==
1986 std::numeric_limits<int64_t>::max(),
1987 "");
1988 static_assert(TimeDelta::Max().IntDiv(-kOneSecond) ==
1989 std::numeric_limits<int64_t>::min(),
1990 "");
1991 static_assert(TimeDelta::Min().IntDiv(kOneSecond) ==
1992 std::numeric_limits<int64_t>::min(),
1993 "");
1994 static_assert(TimeDelta::Min().IntDiv(-kOneSecond) ==
1995 std::numeric_limits<int64_t>::max(),
1996 "");
1997 static_assert(TimeDelta::Max() % kOneSecond == TimeDelta::Max(), "");
1998 static_assert(TimeDelta::Max() % -kOneSecond == TimeDelta::Max(), "");
1999 static_assert(TimeDelta::Min() % kOneSecond == TimeDelta::Min(), "");
2000 static_assert(TimeDelta::Min() % -kOneSecond == TimeDelta::Min(), "");
2001 #endif
2002
2003 // Division by zero.
2004 static_assert((kOneSecond / 0).is_max(), "");
2005 static_assert((-kOneSecond / 0).is_min(), "");
2006 static_assert((TimeDelta::Max() / 0).is_max(), "");
2007 static_assert((TimeDelta::Min() / 0).is_min(), "");
2008 EXPECT_EQ(std::numeric_limits<double>::infinity(), kOneSecond / TimeDelta());
2009 EXPECT_EQ(-std::numeric_limits<double>::infinity(),
2010 -kOneSecond / TimeDelta());
2011 EXPECT_EQ(std::numeric_limits<double>::infinity(),
2012 TimeDelta::Max() / TimeDelta());
2013 EXPECT_EQ(-std::numeric_limits<double>::infinity(),
2014 TimeDelta::Min() / TimeDelta());
2015 static_assert(
2016 kOneSecond.IntDiv(TimeDelta()) == std::numeric_limits<int64_t>::max(),
2017 "");
2018 static_assert(
2019 (-kOneSecond).IntDiv(TimeDelta()) == std::numeric_limits<int64_t>::min(),
2020 "");
2021 static_assert(TimeDelta::Max().IntDiv(TimeDelta()) ==
2022 std::numeric_limits<int64_t>::max(),
2023 "");
2024 static_assert(TimeDelta::Min().IntDiv(TimeDelta()) ==
2025 std::numeric_limits<int64_t>::min(),
2026 "");
2027 static_assert(kOneSecond % TimeDelta() == kOneSecond, "");
2028 static_assert(-kOneSecond % TimeDelta() == -kOneSecond, "");
2029 static_assert(TimeDelta::Max() % TimeDelta() == TimeDelta::Max(), "");
2030 static_assert(TimeDelta::Min() % TimeDelta() == TimeDelta::Min(), "");
2031
2032 // Division by infinity.
2033 static_assert(kLargeDelta / TimeDelta::Min() == 0, "");
2034 static_assert(kLargeDelta / TimeDelta::Max() == 0, "");
2035 static_assert(kLargeNegative / TimeDelta::Min() == 0, "");
2036 static_assert(kLargeNegative / TimeDelta::Max() == 0, "");
2037 static_assert(kLargeDelta.IntDiv(TimeDelta::Min()) == 0, "");
2038 static_assert(kLargeDelta.IntDiv(TimeDelta::Max()) == 0, "");
2039 static_assert(kLargeNegative.IntDiv(TimeDelta::Min()) == 0, "");
2040 static_assert(kLargeNegative.IntDiv(TimeDelta::Max()) == 0, "");
2041 static_assert(kOneSecond % TimeDelta::Min() == kOneSecond, "");
2042 static_assert(kOneSecond % TimeDelta::Max() == kOneSecond, "");
2043
2044 // Test that double conversions overflow to infinity.
2045 EXPECT_EQ((kLargeDelta + kOneSecond).InSecondsF(),
2046 std::numeric_limits<double>::infinity());
2047 EXPECT_EQ((kLargeDelta + kOneSecond).InMillisecondsF(),
2048 std::numeric_limits<double>::infinity());
2049 EXPECT_EQ((kLargeDelta + kOneSecond).InMicrosecondsF(),
2050 std::numeric_limits<double>::infinity());
2051
2052 // Test op=.
2053 TimeDelta delta = kLargeDelta;
2054 delta += kOneSecond;
2055 EXPECT_TRUE(delta.is_max());
2056 delta = kLargeNegative;
2057 delta += -kOneSecond;
2058 EXPECT_TRUE(delta.is_min());
2059
2060 delta = kLargeNegative;
2061 delta -= kOneSecond;
2062 EXPECT_TRUE(delta.is_min());
2063 delta = kLargeDelta;
2064 delta -= -kOneSecond;
2065 EXPECT_TRUE(delta.is_max());
2066
2067 delta = kLargeDelta;
2068 delta *= 2;
2069 EXPECT_TRUE(delta.is_max());
2070 delta = kLargeNegative;
2071 delta *= 1.5;
2072 EXPECT_TRUE(delta.is_min());
2073
2074 delta = kLargeDelta;
2075 delta /= 0.5;
2076 EXPECT_TRUE(delta.is_max());
2077 delta = kLargeNegative;
2078 delta /= 0.5;
2079 EXPECT_TRUE(delta.is_min());
2080
2081 delta = kOneSecond;
2082 delta %= TimeDelta::Max();
2083 EXPECT_EQ(kOneSecond, delta);
2084 delta = kOneSecond;
2085 delta %= TimeDelta();
2086 EXPECT_EQ(kOneSecond, delta);
2087
2088 // Test operations with Time and TimeTicks.
2089 EXPECT_TRUE((kLargeDelta + Time::Now()).is_max());
2090 EXPECT_TRUE((kLargeDelta + TimeTicks::Now()).is_max());
2091 EXPECT_TRUE((Time::Now() + kLargeDelta).is_max());
2092 EXPECT_TRUE((TimeTicks::Now() + kLargeDelta).is_max());
2093
2094 Time time_now = Time::Now();
2095 EXPECT_EQ(kOneSecond, (time_now + kOneSecond) - time_now);
2096 EXPECT_EQ(-kOneSecond, (time_now - kOneSecond) - time_now);
2097
2098 TimeTicks ticks_now = TimeTicks::Now();
2099 EXPECT_EQ(-kOneSecond, (ticks_now - kOneSecond) - ticks_now);
2100 EXPECT_EQ(kOneSecond, (ticks_now + kOneSecond) - ticks_now);
2101 }
2102
TEST(TimeDelta,CeilToMultiple)2103 TEST(TimeDelta, CeilToMultiple) {
2104 for (const auto interval :
2105 {TimeDelta::FromSeconds(10), TimeDelta::FromSeconds(-10)}) {
2106 SCOPED_TRACE(interval);
2107 EXPECT_EQ(TimeDelta().CeilToMultiple(interval), TimeDelta());
2108 EXPECT_EQ(TimeDelta::FromSeconds(1).CeilToMultiple(interval),
2109 TimeDelta::FromSeconds(10));
2110 EXPECT_EQ(TimeDelta::FromSeconds(9).CeilToMultiple(interval),
2111 TimeDelta::FromSeconds(10));
2112 EXPECT_EQ(TimeDelta::FromSeconds(10).CeilToMultiple(interval),
2113 TimeDelta::FromSeconds(10));
2114 EXPECT_EQ(TimeDelta::FromSeconds(15).CeilToMultiple(interval),
2115 TimeDelta::FromSeconds(20));
2116 EXPECT_EQ(TimeDelta::FromSeconds(20).CeilToMultiple(interval),
2117 TimeDelta::FromSeconds(20));
2118 EXPECT_EQ(TimeDelta::Max().CeilToMultiple(interval), TimeDelta::Max());
2119 EXPECT_EQ(TimeDelta::FromSeconds(-1).CeilToMultiple(interval), TimeDelta());
2120 EXPECT_EQ(TimeDelta::FromSeconds(-9).CeilToMultiple(interval), TimeDelta());
2121 EXPECT_EQ(TimeDelta::FromSeconds(-10).CeilToMultiple(interval),
2122 TimeDelta::FromSeconds(-10));
2123 EXPECT_EQ(TimeDelta::FromSeconds(-15).CeilToMultiple(interval),
2124 TimeDelta::FromSeconds(-10));
2125 EXPECT_EQ(TimeDelta::FromSeconds(-20).CeilToMultiple(interval),
2126 TimeDelta::FromSeconds(-20));
2127 EXPECT_EQ(TimeDelta::Min().CeilToMultiple(interval), TimeDelta::Min());
2128 }
2129
2130 for (const auto interval : {TimeDelta::Max(), TimeDelta::Min()}) {
2131 SCOPED_TRACE(interval);
2132 EXPECT_EQ(TimeDelta().CeilToMultiple(interval), TimeDelta());
2133 EXPECT_EQ(TimeDelta::FromSeconds(1).CeilToMultiple(interval),
2134 TimeDelta::Max());
2135 EXPECT_EQ(TimeDelta::FromSeconds(9).CeilToMultiple(interval),
2136 TimeDelta::Max());
2137 EXPECT_EQ(TimeDelta::FromSeconds(10).CeilToMultiple(interval),
2138 TimeDelta::Max());
2139 EXPECT_EQ(TimeDelta::FromSeconds(15).CeilToMultiple(interval),
2140 TimeDelta::Max());
2141 EXPECT_EQ(TimeDelta::FromSeconds(20).CeilToMultiple(interval),
2142 TimeDelta::Max());
2143 EXPECT_EQ(TimeDelta::Max().CeilToMultiple(interval), TimeDelta::Max());
2144 EXPECT_EQ(TimeDelta::FromSeconds(-1).CeilToMultiple(interval), TimeDelta());
2145 EXPECT_EQ(TimeDelta::FromSeconds(-9).CeilToMultiple(interval), TimeDelta());
2146 EXPECT_EQ(TimeDelta::FromSeconds(-10).CeilToMultiple(interval),
2147 TimeDelta());
2148 EXPECT_EQ(TimeDelta::FromSeconds(-15).CeilToMultiple(interval),
2149 TimeDelta());
2150 EXPECT_EQ(TimeDelta::FromSeconds(-20).CeilToMultiple(interval),
2151 TimeDelta());
2152 EXPECT_EQ(TimeDelta::Min().CeilToMultiple(interval), TimeDelta::Min());
2153 }
2154 }
2155
TEST(TimeDelta,FloorToMultiple)2156 TEST(TimeDelta, FloorToMultiple) {
2157 for (const auto interval :
2158 {TimeDelta::FromSeconds(10), TimeDelta::FromSeconds(-10)}) {
2159 SCOPED_TRACE(interval);
2160 EXPECT_EQ(TimeDelta().FloorToMultiple(interval), TimeDelta());
2161 EXPECT_EQ(TimeDelta::FromSeconds(1).FloorToMultiple(interval), TimeDelta());
2162 EXPECT_EQ(TimeDelta::FromSeconds(9).FloorToMultiple(interval), TimeDelta());
2163 EXPECT_EQ(TimeDelta::FromSeconds(10).FloorToMultiple(interval),
2164 TimeDelta::FromSeconds(10));
2165 EXPECT_EQ(TimeDelta::FromSeconds(15).FloorToMultiple(interval),
2166 TimeDelta::FromSeconds(10));
2167 EXPECT_EQ(TimeDelta::FromSeconds(20).FloorToMultiple(interval),
2168 TimeDelta::FromSeconds(20));
2169 EXPECT_EQ(TimeDelta::Max().FloorToMultiple(interval), TimeDelta::Max());
2170 EXPECT_EQ(TimeDelta::FromSeconds(-1).FloorToMultiple(interval),
2171 TimeDelta::FromSeconds(-10));
2172 EXPECT_EQ(TimeDelta::FromSeconds(-9).FloorToMultiple(interval),
2173 TimeDelta::FromSeconds(-10));
2174 EXPECT_EQ(TimeDelta::FromSeconds(-10).FloorToMultiple(interval),
2175 TimeDelta::FromSeconds(-10));
2176 EXPECT_EQ(TimeDelta::FromSeconds(-15).FloorToMultiple(interval),
2177 TimeDelta::FromSeconds(-20));
2178 EXPECT_EQ(TimeDelta::FromSeconds(-20).FloorToMultiple(interval),
2179 TimeDelta::FromSeconds(-20));
2180 EXPECT_EQ(TimeDelta::Min().FloorToMultiple(interval), TimeDelta::Min());
2181 }
2182
2183 for (const auto interval : {TimeDelta::Max(), TimeDelta::Min()}) {
2184 SCOPED_TRACE(interval);
2185 EXPECT_EQ(TimeDelta().FloorToMultiple(interval), TimeDelta());
2186 EXPECT_EQ(TimeDelta::FromSeconds(1).FloorToMultiple(interval), TimeDelta());
2187 EXPECT_EQ(TimeDelta::FromSeconds(9).FloorToMultiple(interval), TimeDelta());
2188 EXPECT_EQ(TimeDelta::FromSeconds(10).FloorToMultiple(interval),
2189 TimeDelta());
2190 EXPECT_EQ(TimeDelta::FromSeconds(15).FloorToMultiple(interval),
2191 TimeDelta());
2192 EXPECT_EQ(TimeDelta::FromSeconds(20).FloorToMultiple(interval),
2193 TimeDelta());
2194 EXPECT_EQ(TimeDelta::Max().FloorToMultiple(interval), TimeDelta::Max());
2195 EXPECT_EQ(TimeDelta::FromSeconds(-1).FloorToMultiple(interval),
2196 TimeDelta::Min());
2197 EXPECT_EQ(TimeDelta::FromSeconds(-9).FloorToMultiple(interval),
2198 TimeDelta::Min());
2199 EXPECT_EQ(TimeDelta::FromSeconds(-10).FloorToMultiple(interval),
2200 TimeDelta::Min());
2201 EXPECT_EQ(TimeDelta::FromSeconds(-15).FloorToMultiple(interval),
2202 TimeDelta::Min());
2203 EXPECT_EQ(TimeDelta::FromSeconds(-20).FloorToMultiple(interval),
2204 TimeDelta::Min());
2205 EXPECT_EQ(TimeDelta::Min().FloorToMultiple(interval), TimeDelta::Min());
2206 }
2207 }
2208
TEST(TimeDelta,RoundToMultiple)2209 TEST(TimeDelta, RoundToMultiple) {
2210 for (const auto interval :
2211 {TimeDelta::FromSeconds(10), TimeDelta::FromSeconds(-10)}) {
2212 SCOPED_TRACE(interval);
2213 EXPECT_EQ(TimeDelta().RoundToMultiple(interval), TimeDelta());
2214 EXPECT_EQ(TimeDelta::FromSeconds(1).RoundToMultiple(interval), TimeDelta());
2215 EXPECT_EQ(TimeDelta::FromSeconds(9).RoundToMultiple(interval),
2216 TimeDelta::FromSeconds(10));
2217 EXPECT_EQ(TimeDelta::FromSeconds(10).RoundToMultiple(interval),
2218 TimeDelta::FromSeconds(10));
2219 EXPECT_EQ(TimeDelta::FromSeconds(15).RoundToMultiple(interval),
2220 TimeDelta::FromSeconds(20));
2221 EXPECT_EQ(TimeDelta::FromSeconds(20).RoundToMultiple(interval),
2222 TimeDelta::FromSeconds(20));
2223 EXPECT_EQ(TimeDelta::Max().RoundToMultiple(interval), TimeDelta::Max());
2224 EXPECT_EQ(TimeDelta::FromSeconds(-1).RoundToMultiple(interval),
2225 TimeDelta());
2226 EXPECT_EQ(TimeDelta::FromSeconds(-9).RoundToMultiple(interval),
2227 TimeDelta::FromSeconds(-10));
2228 EXPECT_EQ(TimeDelta::FromSeconds(-10).RoundToMultiple(interval),
2229 TimeDelta::FromSeconds(-10));
2230 EXPECT_EQ(TimeDelta::FromSeconds(-15).RoundToMultiple(interval),
2231 TimeDelta::FromSeconds(-20));
2232 EXPECT_EQ(TimeDelta::FromSeconds(-20).RoundToMultiple(interval),
2233 TimeDelta::FromSeconds(-20));
2234 EXPECT_EQ(TimeDelta::Min().RoundToMultiple(interval), TimeDelta::Min());
2235 }
2236
2237 for (const auto interval : {TimeDelta::Max(), TimeDelta::Min()}) {
2238 SCOPED_TRACE(interval);
2239 EXPECT_EQ(TimeDelta().RoundToMultiple(interval), TimeDelta());
2240 EXPECT_EQ(TimeDelta::FromSeconds(1).RoundToMultiple(interval), TimeDelta());
2241 EXPECT_EQ(TimeDelta::FromSeconds(9).RoundToMultiple(interval), TimeDelta());
2242 EXPECT_EQ(TimeDelta::FromSeconds(10).RoundToMultiple(interval),
2243 TimeDelta());
2244 EXPECT_EQ(TimeDelta::FromSeconds(15).RoundToMultiple(interval),
2245 TimeDelta());
2246 EXPECT_EQ(TimeDelta::FromSeconds(20).RoundToMultiple(interval),
2247 TimeDelta());
2248 EXPECT_EQ(TimeDelta::Max().RoundToMultiple(interval), TimeDelta::Max());
2249 EXPECT_EQ(TimeDelta::FromSeconds(-1).RoundToMultiple(interval),
2250 TimeDelta());
2251 EXPECT_EQ(TimeDelta::FromSeconds(-9).RoundToMultiple(interval),
2252 TimeDelta());
2253 EXPECT_EQ(TimeDelta::FromSeconds(-10).RoundToMultiple(interval),
2254 TimeDelta());
2255 EXPECT_EQ(TimeDelta::FromSeconds(-15).RoundToMultiple(interval),
2256 TimeDelta());
2257 EXPECT_EQ(TimeDelta::FromSeconds(-20).RoundToMultiple(interval),
2258 TimeDelta());
2259 EXPECT_EQ(TimeDelta::Min().RoundToMultiple(interval), TimeDelta::Min());
2260 }
2261 }
2262
TEST(TimeBase,AddSubDeltaSaturates)2263 TEST(TimeBase, AddSubDeltaSaturates) {
2264 constexpr TimeTicks kLargeTimeTicks =
2265 TimeTicks::FromInternalValue(std::numeric_limits<int64_t>::max() - 1);
2266
2267 constexpr TimeTicks kLargeNegativeTimeTicks =
2268 TimeTicks::FromInternalValue(std::numeric_limits<int64_t>::min() + 1);
2269
2270 EXPECT_TRUE((kLargeTimeTicks + TimeDelta::Max()).is_max())
2271 << (kLargeTimeTicks + TimeDelta::Max());
2272 EXPECT_TRUE((kLargeNegativeTimeTicks + TimeDelta::Max()).is_max())
2273 << (kLargeNegativeTimeTicks + TimeDelta::Max());
2274 EXPECT_TRUE((kLargeTimeTicks - TimeDelta::Max()).is_min())
2275 << (kLargeTimeTicks - TimeDelta::Max());
2276 EXPECT_TRUE((kLargeNegativeTimeTicks - TimeDelta::Max()).is_min())
2277 << (kLargeNegativeTimeTicks - TimeDelta::Max());
2278 EXPECT_TRUE((TimeTicks() + TimeDelta::Max()).is_max())
2279 << (TimeTicks() + TimeDelta::Max());
2280 EXPECT_TRUE((TimeTicks() - TimeDelta::Max()).is_min())
2281 << (TimeTicks() - TimeDelta::Max());
2282 EXPECT_TRUE((TimeTicks::Now() + TimeDelta::Max()).is_max())
2283 << (TimeTicks::Now() + TimeDelta::Max());
2284 EXPECT_TRUE((TimeTicks::Now() - TimeDelta::Max()).is_min())
2285 << (TimeTicks::Now() - TimeDelta::Max());
2286
2287 EXPECT_TRUE((kLargeTimeTicks + TimeDelta::Min()).is_min())
2288 << (kLargeTimeTicks + TimeDelta::Min());
2289 EXPECT_TRUE((kLargeNegativeTimeTicks + TimeDelta::Min()).is_min())
2290 << (kLargeNegativeTimeTicks + TimeDelta::Min());
2291 EXPECT_TRUE((kLargeTimeTicks - TimeDelta::Min()).is_max())
2292 << (kLargeTimeTicks - TimeDelta::Min());
2293 EXPECT_TRUE((kLargeNegativeTimeTicks - TimeDelta::Min()).is_max())
2294 << (kLargeNegativeTimeTicks - TimeDelta::Min());
2295 EXPECT_TRUE((TimeTicks() + TimeDelta::Min()).is_min())
2296 << (TimeTicks() + TimeDelta::Min());
2297 EXPECT_TRUE((TimeTicks() - TimeDelta::Min()).is_max())
2298 << (TimeTicks() - TimeDelta::Min());
2299 EXPECT_TRUE((TimeTicks::Now() + TimeDelta::Min()).is_min())
2300 << (TimeTicks::Now() + TimeDelta::Min());
2301 EXPECT_TRUE((TimeTicks::Now() - TimeDelta::Min()).is_max())
2302 << (TimeTicks::Now() - TimeDelta::Min());
2303 }
2304
TEST(TimeBase,AddSubInfinities)2305 TEST(TimeBase, AddSubInfinities) {
2306 // CHECK when adding opposite signs or subtracting same sign.
2307 EXPECT_CHECK_DEATH({ TimeTicks::Min() + TimeDelta::Max(); });
2308 EXPECT_CHECK_DEATH({ TimeTicks::Max() + TimeDelta::Min(); });
2309 EXPECT_CHECK_DEATH({ TimeTicks::Min() - TimeDelta::Min(); });
2310 EXPECT_CHECK_DEATH({ TimeTicks::Max() - TimeDelta::Max(); });
2311
2312 // Saturates when adding same sign or subtracting opposite signs.
2313 EXPECT_TRUE((TimeTicks::Max() + TimeDelta::Max()).is_max());
2314 EXPECT_TRUE((TimeTicks::Min() + TimeDelta::Min()).is_min());
2315 EXPECT_TRUE((TimeTicks::Max() - TimeDelta::Min()).is_max());
2316 EXPECT_TRUE((TimeTicks::Min() - TimeDelta::Max()).is_min());
2317 }
2318
TestTimeTicksConstexprCopyAssignment()2319 constexpr TimeTicks TestTimeTicksConstexprCopyAssignment() {
2320 TimeTicks a = TimeTicks::FromInternalValue(12345);
2321 TimeTicks b;
2322 b = a;
2323 return b;
2324 }
2325
TEST(TimeTicks,ConstexprAndTriviallyCopiable)2326 TEST(TimeTicks, ConstexprAndTriviallyCopiable) {
2327 // "Trivially copyable" is necessary for use in std::atomic<TimeTicks>.
2328 static_assert(std::is_trivially_copyable<TimeTicks>(), "");
2329
2330 // Copy ctor.
2331 constexpr TimeTicks a = TimeTicks::FromInternalValue(12345);
2332 constexpr TimeTicks b{a};
2333 static_assert(a.ToInternalValue() == b.ToInternalValue(), "");
2334
2335 // Copy assignment.
2336 static_assert(a.ToInternalValue() ==
2337 TestTimeTicksConstexprCopyAssignment().ToInternalValue(),
2338 "");
2339 }
2340
TestThreadTicksConstexprCopyAssignment()2341 constexpr ThreadTicks TestThreadTicksConstexprCopyAssignment() {
2342 ThreadTicks a = ThreadTicks::FromInternalValue(12345);
2343 ThreadTicks b;
2344 b = a;
2345 return b;
2346 }
2347
TEST(ThreadTicks,ConstexprAndTriviallyCopiable)2348 TEST(ThreadTicks, ConstexprAndTriviallyCopiable) {
2349 // "Trivially copyable" is necessary for use in std::atomic<ThreadTicks>.
2350 static_assert(std::is_trivially_copyable<ThreadTicks>(), "");
2351
2352 // Copy ctor.
2353 constexpr ThreadTicks a = ThreadTicks::FromInternalValue(12345);
2354 constexpr ThreadTicks b{a};
2355 static_assert(a.ToInternalValue() == b.ToInternalValue(), "");
2356
2357 // Copy assignment.
2358 static_assert(a.ToInternalValue() ==
2359 TestThreadTicksConstexprCopyAssignment().ToInternalValue(),
2360 "");
2361 }
2362
TestTimeDeltaConstexprCopyAssignment()2363 constexpr TimeDelta TestTimeDeltaConstexprCopyAssignment() {
2364 TimeDelta a = TimeDelta::FromSeconds(1);
2365 TimeDelta b;
2366 b = a;
2367 return b;
2368 }
2369
TEST(TimeDelta,ConstexprAndTriviallyCopiable)2370 TEST(TimeDelta, ConstexprAndTriviallyCopiable) {
2371 // "Trivially copyable" is necessary for use in std::atomic<TimeDelta>.
2372 static_assert(std::is_trivially_copyable<TimeDelta>(), "");
2373
2374 // Copy ctor.
2375 constexpr TimeDelta a = TimeDelta::FromSeconds(1);
2376 constexpr TimeDelta b{a};
2377 static_assert(a == b, "");
2378
2379 // Copy assignment.
2380 static_assert(a == TestTimeDeltaConstexprCopyAssignment(), "");
2381 }
2382
TEST(TimeDeltaLogging,DCheckEqCompiles)2383 TEST(TimeDeltaLogging, DCheckEqCompiles) {
2384 DCHECK_EQ(TimeDelta(), TimeDelta());
2385 }
2386
TEST(TimeDeltaLogging,EmptyIsZero)2387 TEST(TimeDeltaLogging, EmptyIsZero) {
2388 constexpr TimeDelta kZero;
2389 EXPECT_EQ("0 s", AnyToString(kZero));
2390 }
2391
TEST(TimeDeltaLogging,FiveHundredMs)2392 TEST(TimeDeltaLogging, FiveHundredMs) {
2393 constexpr TimeDelta kFiveHundredMs = TimeDelta::FromMilliseconds(500);
2394 EXPECT_EQ("0.5 s", AnyToString(kFiveHundredMs));
2395 }
2396
TEST(TimeDeltaLogging,MinusTenSeconds)2397 TEST(TimeDeltaLogging, MinusTenSeconds) {
2398 constexpr TimeDelta kMinusTenSeconds = TimeDelta::FromSeconds(-10);
2399 EXPECT_EQ("-10 s", AnyToString(kMinusTenSeconds));
2400 }
2401
TEST(TimeDeltaLogging,DoesNotMessUpFormattingFlags)2402 TEST(TimeDeltaLogging, DoesNotMessUpFormattingFlags) {
2403 std::ostringstream oss;
2404 std::ios_base::fmtflags flags_before = oss.flags();
2405 oss << TimeDelta();
2406 EXPECT_EQ(flags_before, oss.flags());
2407 }
2408
TEST(TimeDeltaLogging,DoesNotMakeStreamBad)2409 TEST(TimeDeltaLogging, DoesNotMakeStreamBad) {
2410 std::ostringstream oss;
2411 oss << TimeDelta();
2412 EXPECT_TRUE(oss.good());
2413 }
2414
TEST(TimeLogging,DCheckEqCompiles)2415 TEST(TimeLogging, DCheckEqCompiles) {
2416 DCHECK_EQ(Time(), Time());
2417 }
2418
TEST(TimeLogging,ChromeBirthdate)2419 TEST(TimeLogging, ChromeBirthdate) {
2420 Time birthdate;
2421 ASSERT_TRUE(Time::FromString("Tue, 02 Sep 2008 09:42:18 GMT", &birthdate));
2422 EXPECT_EQ("2008-09-02 09:42:18.000 UTC", AnyToString(birthdate));
2423 }
2424
TEST(TimeLogging,DoesNotMessUpFormattingFlags)2425 TEST(TimeLogging, DoesNotMessUpFormattingFlags) {
2426 std::ostringstream oss;
2427 std::ios_base::fmtflags flags_before = oss.flags();
2428 oss << Time();
2429 EXPECT_EQ(flags_before, oss.flags());
2430 }
2431
TEST(TimeLogging,DoesNotMakeStreamBad)2432 TEST(TimeLogging, DoesNotMakeStreamBad) {
2433 std::ostringstream oss;
2434 oss << Time();
2435 EXPECT_TRUE(oss.good());
2436 }
2437
TEST(TimeTicksLogging,DCheckEqCompiles)2438 TEST(TimeTicksLogging, DCheckEqCompiles) {
2439 DCHECK_EQ(TimeTicks(), TimeTicks());
2440 }
2441
TEST(TimeTicksLogging,ZeroTime)2442 TEST(TimeTicksLogging, ZeroTime) {
2443 TimeTicks zero;
2444 EXPECT_EQ("0 bogo-microseconds", AnyToString(zero));
2445 }
2446
TEST(TimeTicksLogging,FortyYearsLater)2447 TEST(TimeTicksLogging, FortyYearsLater) {
2448 TimeTicks forty_years_later =
2449 TimeTicks() + TimeDelta::FromDays(365.25 * 40);
2450 EXPECT_EQ("1262304000000000 bogo-microseconds",
2451 AnyToString(forty_years_later));
2452 }
2453
TEST(TimeTicksLogging,DoesNotMessUpFormattingFlags)2454 TEST(TimeTicksLogging, DoesNotMessUpFormattingFlags) {
2455 std::ostringstream oss;
2456 std::ios_base::fmtflags flags_before = oss.flags();
2457 oss << TimeTicks();
2458 EXPECT_EQ(flags_before, oss.flags());
2459 }
2460
TEST(TimeTicksLogging,DoesNotMakeStreamBad)2461 TEST(TimeTicksLogging, DoesNotMakeStreamBad) {
2462 std::ostringstream oss;
2463 oss << TimeTicks();
2464 EXPECT_TRUE(oss.good());
2465 }
2466
2467 } // namespace
2468
2469 } // namespace base
2470