1 | //===- llvm/unittest/Support/Chrono.cpp - Time utilities tests ------------===// |
2 | // |
3 | // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. |
4 | // See https://llvm.org/LICENSE.txt for license information. |
5 | // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception |
6 | // |
7 | //===----------------------------------------------------------------------===// |
8 | |
9 | #include "llvm/Support/Chrono.h" |
10 | #include "llvm/Support/FormatVariadic.h" |
11 | #include "gtest/gtest.h" |
12 | |
13 | using namespace llvm; |
14 | using namespace llvm::sys; |
15 | using namespace std::chrono; |
16 | |
17 | namespace { |
18 | |
19 | TEST(Chrono, TimeTConversion) { |
20 | EXPECT_EQ(time_t(0), toTimeT(toTimePoint(time_t(0)))); |
21 | EXPECT_EQ(time_t(1), toTimeT(toTimePoint(time_t(1)))); |
22 | EXPECT_EQ(time_t(47), toTimeT(toTimePoint(time_t(47)))); |
23 | |
24 | TimePoint<> TP; |
25 | EXPECT_EQ(TP, toTimePoint(toTimeT(TP))); |
26 | TP += seconds(1); |
27 | EXPECT_EQ(TP, toTimePoint(toTimeT(TP))); |
28 | TP += hours(47); |
29 | EXPECT_EQ(TP, toTimePoint(toTimeT(TP))); |
30 | } |
31 | |
32 | TEST(Chrono, TimePointFormat) { |
33 | using namespace std::chrono; |
34 | struct tm TM {}; |
35 | TM.tm_year = 106; |
36 | TM.tm_mon = 0; |
37 | TM.tm_mday = 2; |
38 | TM.tm_hour = 15; |
39 | TM.tm_min = 4; |
40 | TM.tm_sec = 5; |
41 | TM.tm_isdst = -1; |
42 | TimePoint<> T = |
43 | system_clock::from_time_t(t: mktime(tp: &TM)) + nanoseconds(123456789); |
44 | TimePoint<> T2 = |
45 | system_clock::from_time_t(t: mktime(tp: &TM)) + nanoseconds(23456789); |
46 | |
47 | // operator<< uses the format YYYY-MM-DD HH:MM:SS.NNNNNNNNN |
48 | std::string S; |
49 | raw_string_ostream OS(S); |
50 | OS << T; |
51 | EXPECT_EQ("2006-01-02 15:04:05.123456789" , OS.str()); |
52 | S.clear(); |
53 | OS << T2; |
54 | EXPECT_EQ("2006-01-02 15:04:05.023456789" , OS.str()); |
55 | |
56 | // formatv default style matches operator<<. |
57 | EXPECT_EQ("2006-01-02 15:04:05.123456789" , formatv("{0}" , T).str()); |
58 | EXPECT_EQ("2006-01-02 15:04:05.023456789" , formatv("{0}" , T2).str()); |
59 | // formatv supports strftime-style format strings. |
60 | EXPECT_EQ("15:04:05" , formatv("{0:%H:%M:%S}" , T).str()); |
61 | // formatv supports our strftime extensions for sub-second precision. |
62 | EXPECT_EQ("123" , formatv("{0:%L}" , T).str()); |
63 | EXPECT_EQ("123456" , formatv("{0:%f}" , T).str()); |
64 | EXPECT_EQ("123456789" , formatv("{0:%N}" , T).str()); |
65 | // our extensions don't interfere with %% escaping. |
66 | EXPECT_EQ("%foo" , formatv("{0:%%foo}" , T).str()); |
67 | } |
68 | |
69 | // Test that toTimePoint and toTimeT can be called with a arguments with varying |
70 | // precisions. |
71 | TEST(Chrono, ImplicitConversions) { |
72 | std::time_t TimeT = 47; |
73 | TimePoint<seconds> Sec = toTimePoint(T: TimeT); |
74 | TimePoint<milliseconds> Milli = toTimePoint(T: TimeT); |
75 | TimePoint<microseconds> Micro = toTimePoint(T: TimeT); |
76 | TimePoint<nanoseconds> Nano = toTimePoint(T: TimeT); |
77 | EXPECT_EQ(Sec, Milli); |
78 | EXPECT_EQ(Sec, Micro); |
79 | EXPECT_EQ(Sec, Nano); |
80 | EXPECT_EQ(TimeT, toTimeT(Sec)); |
81 | EXPECT_EQ(TimeT, toTimeT(Milli)); |
82 | EXPECT_EQ(TimeT, toTimeT(Micro)); |
83 | EXPECT_EQ(TimeT, toTimeT(Nano)); |
84 | } |
85 | |
86 | TEST(Chrono, DurationFormat) { |
87 | EXPECT_EQ("1 h" , formatv("{0}" , hours(1)).str()); |
88 | EXPECT_EQ("1 m" , formatv("{0}" , minutes(1)).str()); |
89 | EXPECT_EQ("1 s" , formatv("{0}" , seconds(1)).str()); |
90 | EXPECT_EQ("1 ms" , formatv("{0}" , milliseconds(1)).str()); |
91 | EXPECT_EQ("1 us" , formatv("{0}" , microseconds(1)).str()); |
92 | EXPECT_EQ("1 ns" , formatv("{0}" , nanoseconds(1)).str()); |
93 | |
94 | EXPECT_EQ("1 s" , formatv("{0:+}" , seconds(1)).str()); |
95 | EXPECT_EQ("1" , formatv("{0:-}" , seconds(1)).str()); |
96 | |
97 | EXPECT_EQ("1000 ms" , formatv("{0:ms}" , seconds(1)).str()); |
98 | EXPECT_EQ("1000000 us" , formatv("{0:us}" , seconds(1)).str()); |
99 | EXPECT_EQ("1000" , formatv("{0:ms-}" , seconds(1)).str()); |
100 | |
101 | EXPECT_EQ("1,000 ms" , formatv("{0:+n}" , milliseconds(1000)).str()); |
102 | EXPECT_EQ("0x3e8" , formatv("{0:-x}" , milliseconds(1000)).str()); |
103 | EXPECT_EQ("010" , formatv("{0:-3}" , milliseconds(10)).str()); |
104 | EXPECT_EQ("10,000" , formatv("{0:ms-n}" , seconds(10)).str()); |
105 | |
106 | EXPECT_EQ("1.00 s" , formatv("{0}" , duration<float>(1)).str()); |
107 | EXPECT_EQ("0.123 s" , formatv("{0:+3}" , duration<float>(0.123f)).str()); |
108 | EXPECT_EQ("1.230e-01 s" , formatv("{0:+e3}" , duration<float>(0.123f)).str()); |
109 | |
110 | typedef duration<float, std::ratio<60 * 60 * 24 * 14, 1000000>> |
111 | microfortnights; |
112 | EXPECT_EQ("1.00" , formatv("{0:-}" , microfortnights(1)).str()); |
113 | EXPECT_EQ("1209.60 ms" , formatv("{0:ms}" , microfortnights(1)).str()); |
114 | } |
115 | |
116 | } // anonymous namespace |
117 | |