ceph/src/fmt/test/chrono-test.cc

   1 // Formatting library for C++ - time formatting tests
   2 //
   3 // Copyright (c) 2012 - present, Victor Zverovich
   4 // All rights reserved.
   5 //
   6 // For the license information refer to format.h.
   7
   8 #ifdef WIN32
   9 #  define _CRT_SECURE_NO_WARNINGS
  10 #endif
  11
  12 #include "fmt/chrono.h"
  13 #include "gtest-extra.h"
  14
  15 #include <iomanip>
  16
  17 std::tm make_tm() {
  18   auto time = std::tm();
  19   time.tm_mday = 1;
  20   return time;
  21 }
  22
  23 std::tm make_hour(int h) {
  24   auto time = make_tm();
  25   time.tm_hour = h;
  26   return time;
  27 }
  28
  29 std::tm make_minute(int m) {
  30   auto time = make_tm();
  31   time.tm_min = m;
  32   return time;
  33 }
  34
  35 std::tm make_second(int s) {
  36   auto time = make_tm();
  37   time.tm_sec = s;
  38   return time;
  39 }
  40
  41 std::string format_tm(const std::tm& time, const char* spec,
  42                       const std::locale& loc) {
  43   auto& facet = std::use_facet<std::time_put<char>>(loc);
  44   std::ostringstream os;
  45   os.imbue(loc);
  46   facet.put(os, os, ' ', &time, spec, spec + std::strlen(spec));
  47   return os.str();
  48 }
  49
  50 TEST(TimeTest, Format) {
  51   std::tm tm = std::tm();
  52   tm.tm_year = 116;
  53   tm.tm_mon = 3;
  54   tm.tm_mday = 25;
  55   EXPECT_EQ("The date is 2016-04-25.",
  56             fmt::format("The date is {:%Y-%m-%d}.", tm));
  57 }
  58
  59 TEST(TimeTest, GrowBuffer) {
  60   std::string s = "{:";
  61   for (int i = 0; i < 30; ++i) s += "%c";
  62   s += "}\n";
  63   std::time_t t = std::time(FMT_NULL);
  64   fmt::format(s, *std::localtime(&t));
  65 }
  66
  67 TEST(TimeTest, FormatToEmptyContainer) {
  68   std::string s;
  69   auto time = std::tm();
  70   time.tm_sec = 42;
  71   fmt::format_to(std::back_inserter(s), "{:%S}", time);
  72   EXPECT_EQ(s, "42");
  73 }
  74
  75 TEST(TimeTest, EmptyResult) { EXPECT_EQ("", fmt::format("{}", std::tm())); }
  76
  77 static bool EqualTime(const std::tm& lhs, const std::tm& rhs) {
  78   return lhs.tm_sec == rhs.tm_sec && lhs.tm_min == rhs.tm_min &&
  79          lhs.tm_hour == rhs.tm_hour && lhs.tm_mday == rhs.tm_mday &&
  80          lhs.tm_mon == rhs.tm_mon && lhs.tm_year == rhs.tm_year &&
  81          lhs.tm_wday == rhs.tm_wday && lhs.tm_yday == rhs.tm_yday &&
  82          lhs.tm_isdst == rhs.tm_isdst;
  83 }
  84
  85 TEST(TimeTest, LocalTime) {
  86   std::time_t t = std::time(FMT_NULL);
  87   std::tm tm = *std::localtime(&t);
  88   EXPECT_TRUE(EqualTime(tm, fmt::localtime(t)));
  89 }
  90
  91 TEST(TimeTest, GMTime) {
  92   std::time_t t = std::time(FMT_NULL);
  93   std::tm tm = *std::gmtime(&t);
  94   EXPECT_TRUE(EqualTime(tm, fmt::gmtime(t)));
  95 }
  96
  97 #define EXPECT_TIME(spec, time, duration)                 \
  98   {                                                       \
  99     std::locale loc("ja_JP.utf8");                        \
 100     EXPECT_EQ(format_tm(time, spec, loc),                 \
 101               fmt::format(loc, "{:" spec "}", duration)); \
 102   }
 103
 104 #ifndef FMT_STATIC_THOUSANDS_SEPARATOR
 105
 106 TEST(ChronoTest, FormatDefault) {
 107   EXPECT_EQ("42s", fmt::format("{}", std::chrono::seconds(42)));
 108   EXPECT_EQ("42as",
 109             fmt::format("{}", std::chrono::duration<int, std::atto>(42)));
 110   EXPECT_EQ("42fs",
 111             fmt::format("{}", std::chrono::duration<int, std::femto>(42)));
 112   EXPECT_EQ("42ps",
 113             fmt::format("{}", std::chrono::duration<int, std::pico>(42)));
 114   EXPECT_EQ("42ns", fmt::format("{}", std::chrono::nanoseconds(42)));
 115   EXPECT_EQ("42µs", fmt::format("{}", std::chrono::microseconds(42)));
 116   EXPECT_EQ("42ms", fmt::format("{}", std::chrono::milliseconds(42)));
 117   EXPECT_EQ("42cs",
 118             fmt::format("{}", std::chrono::duration<int, std::centi>(42)));
 119   EXPECT_EQ("42ds",
 120             fmt::format("{}", std::chrono::duration<int, std::deci>(42)));
 121   EXPECT_EQ("42s", fmt::format("{}", std::chrono::seconds(42)));
 122   EXPECT_EQ("42das",
 123             fmt::format("{}", std::chrono::duration<int, std::deca>(42)));
 124   EXPECT_EQ("42hs",
 125             fmt::format("{}", std::chrono::duration<int, std::hecto>(42)));
 126   EXPECT_EQ("42ks",
 127             fmt::format("{}", std::chrono::duration<int, std::kilo>(42)));
 128   EXPECT_EQ("42Ms",
 129             fmt::format("{}", std::chrono::duration<int, std::mega>(42)));
 130   EXPECT_EQ("42Gs",
 131             fmt::format("{}", std::chrono::duration<int, std::giga>(42)));
 132   EXPECT_EQ("42Ts",
 133             fmt::format("{}", std::chrono::duration<int, std::tera>(42)));
 134   EXPECT_EQ("42Ps",
 135             fmt::format("{}", std::chrono::duration<int, std::peta>(42)));
 136   EXPECT_EQ("42Es",
 137             fmt::format("{}", std::chrono::duration<int, std::exa>(42)));
 138   EXPECT_EQ("42m", fmt::format("{}", std::chrono::minutes(42)));
 139   EXPECT_EQ("42h", fmt::format("{}", std::chrono::hours(42)));
 140   EXPECT_EQ(
 141       "42[15]s",
 142       fmt::format("{}", std::chrono::duration<int, std::ratio<15, 1>>(42)));
 143   EXPECT_EQ(
 144       "42[15/4]s",
 145       fmt::format("{}", std::chrono::duration<int, std::ratio<15, 4>>(42)));
 146 }
 147
 148 TEST(ChronoTest, Align) {
 149   auto s = std::chrono::seconds(42);
 150   EXPECT_EQ("42s  ", fmt::format("{:5}", s));
 151   EXPECT_EQ("42s  ", fmt::format("{:{}}", s, 5));
 152   EXPECT_EQ("  42s", fmt::format("{:>5}", s));
 153   EXPECT_EQ("**42s**", fmt::format("{:*^7}", s));
 154   EXPECT_EQ("03:25:45    ",
 155             fmt::format("{:12%H:%M:%S}", std::chrono::seconds(12345)));
 156   EXPECT_EQ("    03:25:45",
 157             fmt::format("{:>12%H:%M:%S}", std::chrono::seconds(12345)));
 158   EXPECT_EQ("~~03:25:45~~",
 159             fmt::format("{:~^12%H:%M:%S}", std::chrono::seconds(12345)));
 160   EXPECT_EQ("03:25:45    ",
 161             fmt::format("{:{}%H:%M:%S}", std::chrono::seconds(12345), 12));
 162 }
 163
 164 TEST(ChronoTest, FormatSpecs) {
 165   EXPECT_EQ("%", fmt::format("{:%%}", std::chrono::seconds(0)));
 166   EXPECT_EQ("\n", fmt::format("{:%n}", std::chrono::seconds(0)));
 167   EXPECT_EQ("\t", fmt::format("{:%t}", std::chrono::seconds(0)));
 168   EXPECT_EQ("00", fmt::format("{:%S}", std::chrono::seconds(0)));
 169   EXPECT_EQ("00", fmt::format("{:%S}", std::chrono::seconds(60)));
 170   EXPECT_EQ("42", fmt::format("{:%S}", std::chrono::seconds(42)));
 171   EXPECT_EQ("01.234", fmt::format("{:%S}", std::chrono::milliseconds(1234)));
 172   EXPECT_EQ("00", fmt::format("{:%M}", std::chrono::minutes(0)));
 173   EXPECT_EQ("00", fmt::format("{:%M}", std::chrono::minutes(60)));
 174   EXPECT_EQ("42", fmt::format("{:%M}", std::chrono::minutes(42)));
 175   EXPECT_EQ("01", fmt::format("{:%M}", std::chrono::seconds(61)));
 176   EXPECT_EQ("00", fmt::format("{:%H}", std::chrono::hours(0)));
 177   EXPECT_EQ("00", fmt::format("{:%H}", std::chrono::hours(24)));
 178   EXPECT_EQ("14", fmt::format("{:%H}", std::chrono::hours(14)));
 179   EXPECT_EQ("01", fmt::format("{:%H}", std::chrono::minutes(61)));
 180   EXPECT_EQ("12", fmt::format("{:%I}", std::chrono::hours(0)));
 181   EXPECT_EQ("12", fmt::format("{:%I}", std::chrono::hours(12)));
 182   EXPECT_EQ("12", fmt::format("{:%I}", std::chrono::hours(24)));
 183   EXPECT_EQ("04", fmt::format("{:%I}", std::chrono::hours(4)));
 184   EXPECT_EQ("02", fmt::format("{:%I}", std::chrono::hours(14)));
 185   EXPECT_EQ("03:25:45",
 186             fmt::format("{:%H:%M:%S}", std::chrono::seconds(12345)));
 187   EXPECT_EQ("03:25", fmt::format("{:%R}", std::chrono::seconds(12345)));
 188   EXPECT_EQ("03:25:45", fmt::format("{:%T}", std::chrono::seconds(12345)));
 189   EXPECT_EQ("12345", fmt::format("{:%Q}", std::chrono::seconds(12345)));
 190   EXPECT_EQ("s", fmt::format("{:%q}", std::chrono::seconds(12345)));
 191 }
 192
 193 TEST(ChronoTest, InvalidSpecs) {
 194   auto sec = std::chrono::seconds(0);
 195   EXPECT_THROW_MSG(fmt::format("{:%a}", sec), fmt::format_error, "no date");
 196   EXPECT_THROW_MSG(fmt::format("{:%A}", sec), fmt::format_error, "no date");
 197   EXPECT_THROW_MSG(fmt::format("{:%c}", sec), fmt::format_error, "no date");
 198   EXPECT_THROW_MSG(fmt::format("{:%x}", sec), fmt::format_error, "no date");
 199   EXPECT_THROW_MSG(fmt::format("{:%Ex}", sec), fmt::format_error, "no date");
 200   EXPECT_THROW_MSG(fmt::format("{:%X}", sec), fmt::format_error, "no date");
 201   EXPECT_THROW_MSG(fmt::format("{:%EX}", sec), fmt::format_error, "no date");
 202   EXPECT_THROW_MSG(fmt::format("{:%D}", sec), fmt::format_error, "no date");
 203   EXPECT_THROW_MSG(fmt::format("{:%F}", sec), fmt::format_error, "no date");
 204   EXPECT_THROW_MSG(fmt::format("{:%Ec}", sec), fmt::format_error, "no date");
 205   EXPECT_THROW_MSG(fmt::format("{:%w}", sec), fmt::format_error, "no date");
 206   EXPECT_THROW_MSG(fmt::format("{:%u}", sec), fmt::format_error, "no date");
 207   EXPECT_THROW_MSG(fmt::format("{:%b}", sec), fmt::format_error, "no date");
 208   EXPECT_THROW_MSG(fmt::format("{:%B}", sec), fmt::format_error, "no date");
 209   EXPECT_THROW_MSG(fmt::format("{:%z}", sec), fmt::format_error, "no date");
 210   EXPECT_THROW_MSG(fmt::format("{:%Z}", sec), fmt::format_error, "no date");
 211   EXPECT_THROW_MSG(fmt::format("{:%Eq}", sec), fmt::format_error,
 212                    "invalid format");
 213   EXPECT_THROW_MSG(fmt::format("{:%Oq}", sec), fmt::format_error,
 214                    "invalid format");
 215 }
 216
 217 TEST(ChronoTest, Locale) {
 218   const char* loc_name = "ja_JP.utf8";
 219   bool has_locale = false;
 220   std::locale loc;
 221   try {
 222     loc = std::locale(loc_name);
 223     has_locale = true;
 224   } catch (const std::runtime_error&) {
 225   }
 226   if (!has_locale) {
 227     fmt::print("{} locale is missing.\n", loc_name);
 228     return;
 229   }
 230   EXPECT_TIME("%OH", make_hour(14), std::chrono::hours(14));
 231   EXPECT_TIME("%OI", make_hour(14), std::chrono::hours(14));
 232   EXPECT_TIME("%OM", make_minute(42), std::chrono::minutes(42));
 233   EXPECT_TIME("%OS", make_second(42), std::chrono::seconds(42));
 234   auto time = make_tm();
 235   time.tm_hour = 3;
 236   time.tm_min = 25;
 237   time.tm_sec = 45;
 238   auto sec = std::chrono::seconds(12345);
 239   EXPECT_TIME("%r", time, sec);
 240   EXPECT_TIME("%p", time, sec);
 241 }
 242
 243 typedef std::chrono::duration<double, std::milli> dms;
 244
 245 TEST(ChronoTest, FormatDefaultFP) {
 246   typedef std::chrono::duration<float> fs;
 247   EXPECT_EQ("1.234s", fmt::format("{}", fs(1.234)));
 248   typedef std::chrono::duration<float, std::milli> fms;
 249   EXPECT_EQ("1.234ms", fmt::format("{}", fms(1.234)));
 250   typedef std::chrono::duration<double> ds;
 251   EXPECT_EQ("1.234s", fmt::format("{}", ds(1.234)));
 252   EXPECT_EQ("1.234ms", fmt::format("{}", dms(1.234)));
 253 }
 254
 255 TEST(ChronoTest, FormatPrecision) {
 256   EXPECT_THROW_MSG(fmt::format("{:.2}", std::chrono::seconds(42)),
 257                    fmt::format_error,
 258                    "precision not allowed for this argument type");
 259   EXPECT_EQ("1.2ms", fmt::format("{:.1}", dms(1.234)));
 260   EXPECT_EQ("1.23ms", fmt::format("{:.{}}", dms(1.234), 2));
 261 }
 262
 263 TEST(ChronoTest, FormatFullSpecs) {
 264   EXPECT_EQ("1.2ms ", fmt::format("{:6.1}", dms(1.234)));
 265   EXPECT_EQ("  1.23ms", fmt::format("{:>8.{}}", dms(1.234), 2));
 266   EXPECT_EQ(" 1.2ms ", fmt::format("{:^{}.{}}", dms(1.234), 7, 1));
 267   EXPECT_EQ(" 1.23ms ", fmt::format("{0:^{2}.{1}}", dms(1.234), 2, 8));
 268   EXPECT_EQ("=1.234ms=", fmt::format("{:=^{}.{}}", dms(1.234), 9, 3));
 269   EXPECT_EQ("*1.2340ms*", fmt::format("{:*^10.4}", dms(1.234)));
 270 }
 271
 272 TEST(ChronoTest, FormatSimpleQq) {
 273   typedef std::chrono::duration<float> fs;
 274   EXPECT_EQ("1.234 s", fmt::format("{:%Q %q}", fs(1.234)));
 275   typedef std::chrono::duration<float, std::milli> fms;
 276   EXPECT_EQ("1.234 ms", fmt::format("{:%Q %q}", fms(1.234)));
 277   typedef std::chrono::duration<double> ds;
 278   EXPECT_EQ("1.234 s", fmt::format("{:%Q %q}", ds(1.234)));
 279   EXPECT_EQ("1.234 ms", fmt::format("{:%Q %q}", dms(1.234)));
 280 }
 281
 282 TEST(ChronoTest, FormatPrecisionQq) {
 283   EXPECT_THROW_MSG(fmt::format("{:.2%Q %q}", std::chrono::seconds(42)),
 284                    fmt::format_error,
 285                    "precision not allowed for this argument type");
 286   EXPECT_EQ("1.2 ms", fmt::format("{:.1%Q %q}", dms(1.234)));
 287   EXPECT_EQ("1.23 ms", fmt::format("{:.{}%Q %q}", dms(1.234), 2));
 288 }
 289
 290 TEST(ChronoTest, FormatFullSpecsQq) {
 291   EXPECT_EQ("1.2 ms ", fmt::format("{:7.1%Q %q}", dms(1.234)));
 292   EXPECT_EQ(" 1.23 ms", fmt::format("{:>8.{}%Q %q}", dms(1.234), 2));
 293   EXPECT_EQ(" 1.2 ms ", fmt::format("{:^{}.{}%Q %q}", dms(1.234), 8, 1));
 294   EXPECT_EQ(" 1.23 ms ", fmt::format("{0:^{2}.{1}%Q %q}", dms(1.234), 2, 9));
 295   EXPECT_EQ("=1.234 ms=", fmt::format("{:=^{}.{}%Q %q}", dms(1.234), 10, 3));
 296   EXPECT_EQ("*1.2340 ms*", fmt::format("{:*^11.4%Q %q}", dms(1.234)));
 297 }
 298
 299 #endif  // FMT_STATIC_THOUSANDS_SEPARATOR