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(mktime(&TM)) + nanoseconds(123456789); 44 TimePoint<> T2 = 45 system_clock::from_time_t(mktime(&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", S); 52 S.clear(); 53 OS << T2; 54 EXPECT_EQ("2006-01-02 15:04:05.023456789", S); 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(TimeT); 74 TimePoint<milliseconds> Milli = toTimePoint(TimeT); 75 TimePoint<microseconds> Micro = toTimePoint(TimeT); 76 TimePoint<nanoseconds> Nano = toTimePoint(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