unittests/Support/Chrono.cpp

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