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
  14 #include <iomanip>
  15
  16 #include "gtest-extra.h"
  17
  18 std::tm make_tm() {
  19   auto time = std::tm();
  20   time.tm_mday = 1;
  21   return time;
  22 }
  23
  24 std::tm make_hour(int h) {
  25   auto time = make_tm();
  26   time.tm_hour = h;
  27   return time;
  28 }
  29
  30 std::tm make_minute(int m) {
  31   auto time = make_tm();
  32   time.tm_min = m;
  33   return time;
  34 }
  35
  36 std::tm make_second(int s) {
  37   auto time = make_tm();
  38   time.tm_sec = s;
  39   return time;
  40 }
  41
  42 std::string format_tm(const std::tm& time, const char* spec,
  43                       const std::locale& loc) {
  44   auto& facet = std::use_facet<std::time_put<char>>(loc);
  45   std::ostringstream os;
  46   os.imbue(loc);
  47   facet.put(os, os, ' ', &time, spec, spec + std::strlen(spec));
  48   return os.str();
  49 }
  50
  51 TEST(TimeTest, Format) {
  52   std::tm tm = std::tm();
  53   tm.tm_year = 116;
  54   tm.tm_mon = 3;
  55   tm.tm_mday = 25;
  56   EXPECT_EQ("The date is 2016-04-25.",
  57             fmt::format("The date is {:%Y-%m-%d}.", tm));
  58 }
  59
  60 TEST(TimeTest, GrowBuffer) {
  61   std::string s = "{:";
  62   for (int i = 0; i < 30; ++i) s += "%c";
  63   s += "}\n";
  64   std::time_t t = std::time(nullptr);
  65   fmt::format(s, *std::localtime(&t));
  66 }
  67
  68 TEST(TimeTest, FormatToEmptyContainer) {
  69   std::string s;
  70   auto time = std::tm();
  71   time.tm_sec = 42;
  72   fmt::format_to(std::back_inserter(s), "{:%S}", time);
  73   EXPECT_EQ(s, "42");
  74 }
  75
  76 TEST(TimeTest, EmptyResult) { EXPECT_EQ("", fmt::format("{}", std::tm())); }
  77
  78 static bool EqualTime(const std::tm& lhs, const std::tm& rhs) {
  79   return lhs.tm_sec == rhs.tm_sec && lhs.tm_min == rhs.tm_min &&
  80          lhs.tm_hour == rhs.tm_hour && lhs.tm_mday == rhs.tm_mday &&
  81          lhs.tm_mon == rhs.tm_mon && lhs.tm_year == rhs.tm_year &&
  82          lhs.tm_wday == rhs.tm_wday && lhs.tm_yday == rhs.tm_yday &&
  83          lhs.tm_isdst == rhs.tm_isdst;
  84 }
  85
  86 TEST(TimeTest, LocalTime) {
  87   std::time_t t = std::time(nullptr);
  88   std::tm tm = *std::localtime(&t);
  89   EXPECT_TRUE(EqualTime(tm, fmt::localtime(t)));
  90 }
  91
  92 TEST(TimeTest, GMTime) {
  93   std::time_t t = std::time(nullptr);
  94   std::tm tm = *std::gmtime(&t);
  95   EXPECT_TRUE(EqualTime(tm, fmt::gmtime(t)));
  96 }
  97
  98 #define EXPECT_TIME(spec, time, duration)                 \
  99   {                                                       \
 100     std::locale loc("ja_JP.utf8");                        \
 101     EXPECT_EQ(format_tm(time, spec, loc),                 \
 102               fmt::format(loc, "{:" spec "}", duration)); \
 103   }
 104
 105 #ifndef FMT_STATIC_THOUSANDS_SEPARATOR
 106
 107 TEST(ChronoTest, FormatDefault) {
 108   EXPECT_EQ("42s", fmt::format("{}", std::chrono::seconds(42)));
 109   EXPECT_EQ("42as",
 110             fmt::format("{}", std::chrono::duration<int, std::atto>(42)));
 111   EXPECT_EQ("42fs",
 112             fmt::format("{}", std::chrono::duration<int, std::femto>(42)));
 113   EXPECT_EQ("42ps",
 114             fmt::format("{}", std::chrono::duration<int, std::pico>(42)));
 115   EXPECT_EQ("42ns", fmt::format("{}", std::chrono::nanoseconds(42)));
 116   EXPECT_EQ("42µs", fmt::format("{}", std::chrono::microseconds(42)));
 117   EXPECT_EQ("42ms", fmt::format("{}", std::chrono::milliseconds(42)));
 118   EXPECT_EQ("42cs",
 119             fmt::format("{}", std::chrono::duration<int, std::centi>(42)));
 120   EXPECT_EQ("42ds",
 121             fmt::format("{}", std::chrono::duration<int, std::deci>(42)));
 122   EXPECT_EQ("42s", fmt::format("{}", std::chrono::seconds(42)));
 123   EXPECT_EQ("42das",
 124             fmt::format("{}", std::chrono::duration<int, std::deca>(42)));
 125   EXPECT_EQ("42hs",
 126             fmt::format("{}", std::chrono::duration<int, std::hecto>(42)));
 127   EXPECT_EQ("42ks",
 128             fmt::format("{}", std::chrono::duration<int, std::kilo>(42)));
 129   EXPECT_EQ("42Ms",
 130             fmt::format("{}", std::chrono::duration<int, std::mega>(42)));
 131   EXPECT_EQ("42Gs",
 132             fmt::format("{}", std::chrono::duration<int, std::giga>(42)));
 133   EXPECT_EQ("42Ts",
 134             fmt::format("{}", std::chrono::duration<int, std::tera>(42)));
 135   EXPECT_EQ("42Ps",
 136             fmt::format("{}", std::chrono::duration<int, std::peta>(42)));
 137   EXPECT_EQ("42Es",
 138             fmt::format("{}", std::chrono::duration<int, std::exa>(42)));
 139   EXPECT_EQ("42m", fmt::format("{}", std::chrono::minutes(42)));
 140   EXPECT_EQ("42h", fmt::format("{}", std::chrono::hours(42)));
 141   EXPECT_EQ(
 142       "42[15]s",
 143       fmt::format("{}", std::chrono::duration<int, std::ratio<15, 1>>(42)));
 144   EXPECT_EQ(
 145       "42[15/4]s",
 146       fmt::format("{}", std::chrono::duration<int, std::ratio<15, 4>>(42)));
 147 }
 148
 149 TEST(ChronoTest, FormatWide) {
 150   EXPECT_EQ(L"42s", fmt::format(L"{}", std::chrono::seconds(42)));
 151   EXPECT_EQ(L"42as",
 152             fmt::format(L"{}", std::chrono::duration<int, std::atto>(42)));
 153   EXPECT_EQ(L"42fs",
 154             fmt::format(L"{}", std::chrono::duration<int, std::femto>(42)));
 155   EXPECT_EQ(L"42ps",
 156             fmt::format(L"{}", std::chrono::duration<int, std::pico>(42)));
 157   EXPECT_EQ(L"42ns", fmt::format(L"{}", std::chrono::nanoseconds(42)));
 158   EXPECT_EQ(L"42\u00B5s", fmt::format(L"{}", std::chrono::microseconds(42)));
 159   EXPECT_EQ(L"42ms", fmt::format(L"{}", std::chrono::milliseconds(42)));
 160   EXPECT_EQ(L"42cs",
 161             fmt::format(L"{}", std::chrono::duration<int, std::centi>(42)));
 162   EXPECT_EQ(L"42ds",
 163             fmt::format(L"{}", std::chrono::duration<int, std::deci>(42)));
 164   EXPECT_EQ(L"42s", fmt::format(L"{}", std::chrono::seconds(42)));
 165   EXPECT_EQ(L"42das",
 166             fmt::format(L"{}", std::chrono::duration<int, std::deca>(42)));
 167   EXPECT_EQ(L"42hs",
 168             fmt::format(L"{}", std::chrono::duration<int, std::hecto>(42)));
 169   EXPECT_EQ(L"42ks",
 170             fmt::format(L"{}", std::chrono::duration<int, std::kilo>(42)));
 171   EXPECT_EQ(L"42Ms",
 172             fmt::format(L"{}", std::chrono::duration<int, std::mega>(42)));
 173   EXPECT_EQ(L"42Gs",
 174             fmt::format(L"{}", std::chrono::duration<int, std::giga>(42)));
 175   EXPECT_EQ(L"42Ts",
 176             fmt::format(L"{}", std::chrono::duration<int, std::tera>(42)));
 177   EXPECT_EQ(L"42Ps",
 178             fmt::format(L"{}", std::chrono::duration<int, std::peta>(42)));
 179   EXPECT_EQ(L"42Es",
 180             fmt::format(L"{}", std::chrono::duration<int, std::exa>(42)));
 181   EXPECT_EQ(L"42m", fmt::format(L"{}", std::chrono::minutes(42)));
 182   EXPECT_EQ(L"42h", fmt::format(L"{}", std::chrono::hours(42)));
 183   EXPECT_EQ(
 184       L"42[15]s",
 185       fmt::format(L"{}", std::chrono::duration<int, std::ratio<15, 1>>(42)));
 186   EXPECT_EQ(
 187       L"42[15/4]s",
 188       fmt::format(L"{}", std::chrono::duration<int, std::ratio<15, 4>>(42)));
 189 }
 190
 191 TEST(ChronoTest, Align) {
 192   auto s = std::chrono::seconds(42);
 193   EXPECT_EQ("42s  ", fmt::format("{:5}", s));
 194   EXPECT_EQ("42s  ", fmt::format("{:{}}", s, 5));
 195   EXPECT_EQ("  42s", fmt::format("{:>5}", s));
 196   EXPECT_EQ("**42s**", fmt::format("{:*^7}", s));
 197   EXPECT_EQ("03:25:45    ",
 198             fmt::format("{:12%H:%M:%S}", std::chrono::seconds(12345)));
 199   EXPECT_EQ("    03:25:45",
 200             fmt::format("{:>12%H:%M:%S}", std::chrono::seconds(12345)));
 201   EXPECT_EQ("~~03:25:45~~",
 202             fmt::format("{:~^12%H:%M:%S}", std::chrono::seconds(12345)));
 203   EXPECT_EQ("03:25:45    ",
 204             fmt::format("{:{}%H:%M:%S}", std::chrono::seconds(12345), 12));
 205 }
 206
 207 TEST(ChronoTest, FormatSpecs) {
 208   EXPECT_EQ("%", fmt::format("{:%%}", std::chrono::seconds(0)));
 209   EXPECT_EQ("\n", fmt::format("{:%n}", std::chrono::seconds(0)));
 210   EXPECT_EQ("\t", fmt::format("{:%t}", std::chrono::seconds(0)));
 211   EXPECT_EQ("00", fmt::format("{:%S}", std::chrono::seconds(0)));
 212   EXPECT_EQ("00", fmt::format("{:%S}", std::chrono::seconds(60)));
 213   EXPECT_EQ("42", fmt::format("{:%S}", std::chrono::seconds(42)));
 214   EXPECT_EQ("01.234", fmt::format("{:%S}", std::chrono::milliseconds(1234)));
 215   EXPECT_EQ("00", fmt::format("{:%M}", std::chrono::minutes(0)));
 216   EXPECT_EQ("00", fmt::format("{:%M}", std::chrono::minutes(60)));
 217   EXPECT_EQ("42", fmt::format("{:%M}", std::chrono::minutes(42)));
 218   EXPECT_EQ("01", fmt::format("{:%M}", std::chrono::seconds(61)));
 219   EXPECT_EQ("00", fmt::format("{:%H}", std::chrono::hours(0)));
 220   EXPECT_EQ("00", fmt::format("{:%H}", std::chrono::hours(24)));
 221   EXPECT_EQ("14", fmt::format("{:%H}", std::chrono::hours(14)));
 222   EXPECT_EQ("01", fmt::format("{:%H}", std::chrono::minutes(61)));
 223   EXPECT_EQ("12", fmt::format("{:%I}", std::chrono::hours(0)));
 224   EXPECT_EQ("12", fmt::format("{:%I}", std::chrono::hours(12)));
 225   EXPECT_EQ("12", fmt::format("{:%I}", std::chrono::hours(24)));
 226   EXPECT_EQ("04", fmt::format("{:%I}", std::chrono::hours(4)));
 227   EXPECT_EQ("02", fmt::format("{:%I}", std::chrono::hours(14)));
 228   EXPECT_EQ("03:25:45",
 229             fmt::format("{:%H:%M:%S}", std::chrono::seconds(12345)));
 230   EXPECT_EQ("03:25", fmt::format("{:%R}", std::chrono::seconds(12345)));
 231   EXPECT_EQ("03:25:45", fmt::format("{:%T}", std::chrono::seconds(12345)));
 232   EXPECT_EQ("12345", fmt::format("{:%Q}", std::chrono::seconds(12345)));
 233   EXPECT_EQ("s", fmt::format("{:%q}", std::chrono::seconds(12345)));
 234 }
 235
 236 TEST(ChronoTest, InvalidSpecs) {
 237   auto sec = std::chrono::seconds(0);
 238   EXPECT_THROW_MSG(fmt::format("{:%a}", sec), fmt::format_error, "no date");
 239   EXPECT_THROW_MSG(fmt::format("{:%A}", sec), fmt::format_error, "no date");
 240   EXPECT_THROW_MSG(fmt::format("{:%c}", sec), fmt::format_error, "no date");
 241   EXPECT_THROW_MSG(fmt::format("{:%x}", sec), fmt::format_error, "no date");
 242   EXPECT_THROW_MSG(fmt::format("{:%Ex}", sec), fmt::format_error, "no date");
 243   EXPECT_THROW_MSG(fmt::format("{:%X}", sec), fmt::format_error, "no date");
 244   EXPECT_THROW_MSG(fmt::format("{:%EX}", sec), fmt::format_error, "no date");
 245   EXPECT_THROW_MSG(fmt::format("{:%D}", sec), fmt::format_error, "no date");
 246   EXPECT_THROW_MSG(fmt::format("{:%F}", sec), fmt::format_error, "no date");
 247   EXPECT_THROW_MSG(fmt::format("{:%Ec}", sec), fmt::format_error, "no date");
 248   EXPECT_THROW_MSG(fmt::format("{:%w}", sec), fmt::format_error, "no date");
 249   EXPECT_THROW_MSG(fmt::format("{:%u}", sec), fmt::format_error, "no date");
 250   EXPECT_THROW_MSG(fmt::format("{:%b}", sec), fmt::format_error, "no date");
 251   EXPECT_THROW_MSG(fmt::format("{:%B}", sec), fmt::format_error, "no date");
 252   EXPECT_THROW_MSG(fmt::format("{:%z}", sec), fmt::format_error, "no date");
 253   EXPECT_THROW_MSG(fmt::format("{:%Z}", sec), fmt::format_error, "no date");
 254   EXPECT_THROW_MSG(fmt::format("{:%Eq}", sec), fmt::format_error,
 255                    "invalid format");
 256   EXPECT_THROW_MSG(fmt::format("{:%Oq}", sec), fmt::format_error,
 257                    "invalid format");
 258 }
 259
 260 TEST(ChronoTest, Locale) {
 261   const char* loc_name = "ja_JP.utf8";
 262   bool has_locale = false;
 263   std::locale loc;
 264   try {
 265     loc = std::locale(loc_name);
 266     has_locale = true;
 267   } catch (const std::runtime_error&) {
 268   }
 269   if (!has_locale) {
 270     fmt::print("{} locale is missing.\n", loc_name);
 271     return;
 272   }
 273   EXPECT_TIME("%OH", make_hour(14), std::chrono::hours(14));
 274   EXPECT_TIME("%OI", make_hour(14), std::chrono::hours(14));
 275   EXPECT_TIME("%OM", make_minute(42), std::chrono::minutes(42));
 276   EXPECT_TIME("%OS", make_second(42), std::chrono::seconds(42));
 277   auto time = make_tm();
 278   time.tm_hour = 3;
 279   time.tm_min = 25;
 280   time.tm_sec = 45;
 281   auto sec = std::chrono::seconds(12345);
 282   EXPECT_TIME("%r", time, sec);
 283   EXPECT_TIME("%p", time, sec);
 284 }
 285
 286 typedef std::chrono::duration<double, std::milli> dms;
 287
 288 TEST(ChronoTest, FormatDefaultFP) {
 289   typedef std::chrono::duration<float> fs;
 290   EXPECT_EQ("1.234s", fmt::format("{}", fs(1.234)));
 291   typedef std::chrono::duration<float, std::milli> fms;
 292   EXPECT_EQ("1.234ms", fmt::format("{}", fms(1.234)));
 293   typedef std::chrono::duration<double> ds;
 294   EXPECT_EQ("1.234s", fmt::format("{}", ds(1.234)));
 295   EXPECT_EQ("1.234ms", fmt::format("{}", dms(1.234)));
 296 }
 297
 298 TEST(ChronoTest, FormatPrecision) {
 299   EXPECT_THROW_MSG(fmt::format("{:.2}", std::chrono::seconds(42)),
 300                    fmt::format_error,
 301                    "precision not allowed for this argument type");
 302   EXPECT_EQ("1.2ms", fmt::format("{:.1}", dms(1.234)));
 303   EXPECT_EQ("1.23ms", fmt::format("{:.{}}", dms(1.234), 2));
 304 }
 305
 306 TEST(ChronoTest, FormatFullSpecs) {
 307   EXPECT_EQ("1.2ms ", fmt::format("{:6.1}", dms(1.234)));
 308   EXPECT_EQ("  1.23ms", fmt::format("{:>8.{}}", dms(1.234), 2));
 309   EXPECT_EQ(" 1.2ms ", fmt::format("{:^{}.{}}", dms(1.234), 7, 1));
 310   EXPECT_EQ(" 1.23ms ", fmt::format("{0:^{2}.{1}}", dms(1.234), 2, 8));
 311   EXPECT_EQ("=1.234ms=", fmt::format("{:=^{}.{}}", dms(1.234), 9, 3));
 312   EXPECT_EQ("*1.2340ms*", fmt::format("{:*^10.4}", dms(1.234)));
 313 }
 314
 315 TEST(ChronoTest, FormatSimpleQq) {
 316   typedef std::chrono::duration<float> fs;
 317   EXPECT_EQ("1.234 s", fmt::format("{:%Q %q}", fs(1.234)));
 318   typedef std::chrono::duration<float, std::milli> fms;
 319   EXPECT_EQ("1.234 ms", fmt::format("{:%Q %q}", fms(1.234)));
 320   typedef std::chrono::duration<double> ds;
 321   EXPECT_EQ("1.234 s", fmt::format("{:%Q %q}", ds(1.234)));
 322   EXPECT_EQ("1.234 ms", fmt::format("{:%Q %q}", dms(1.234)));
 323 }
 324
 325 TEST(ChronoTest, FormatPrecisionQq) {
 326   EXPECT_THROW_MSG(fmt::format("{:.2%Q %q}", std::chrono::seconds(42)),
 327                    fmt::format_error,
 328                    "precision not allowed for this argument type");
 329   EXPECT_EQ("1.2 ms", fmt::format("{:.1%Q %q}", dms(1.234)));
 330   EXPECT_EQ("1.23 ms", fmt::format("{:.{}%Q %q}", dms(1.234), 2));
 331 }
 332
 333 TEST(ChronoTest, FormatFullSpecsQq) {
 334   EXPECT_EQ("1.2 ms ", fmt::format("{:7.1%Q %q}", dms(1.234)));
 335   EXPECT_EQ(" 1.23 ms", fmt::format("{:>8.{}%Q %q}", dms(1.234), 2));
 336   EXPECT_EQ(" 1.2 ms ", fmt::format("{:^{}.{}%Q %q}", dms(1.234), 8, 1));
 337   EXPECT_EQ(" 1.23 ms ", fmt::format("{0:^{2}.{1}%Q %q}", dms(1.234), 2, 9));
 338   EXPECT_EQ("=1.234 ms=", fmt::format("{:=^{}.{}%Q %q}", dms(1.234), 10, 3));
 339   EXPECT_EQ("*1.2340 ms*", fmt::format("{:*^11.4%Q %q}", dms(1.234)));
 340 }
 341
 342 TEST(ChronoTest, InvalidWidthId) {
 343   EXPECT_THROW(fmt::format("{:{o}", std::chrono::seconds(0)),
 344                fmt::format_error);
 345 }
 346
 347 TEST(ChronoTest, InvalidColons) {
 348   EXPECT_THROW(fmt::format("{0}=:{0::", std::chrono::seconds(0)),
 349                fmt::format_error);
 350 }
 351
 352 TEST(ChronoTest, NegativeDurations) {
 353   EXPECT_EQ("-12345", fmt::format("{:%Q}", std::chrono::seconds(-12345)));
 354   EXPECT_EQ("-03:25:45",
 355             fmt::format("{:%H:%M:%S}", std::chrono::seconds(-12345)));
 356   EXPECT_EQ("-00:01",
 357             fmt::format("{:%M:%S}", std::chrono::duration<double>(-1)));
 358   EXPECT_EQ("s", fmt::format("{:%q}", std::chrono::seconds(-12345)));
 359   EXPECT_EQ("-00.127",
 360             fmt::format("{:%S}",
 361                         std::chrono::duration<signed char, std::milli>{-127}));
 362   auto min = std::numeric_limits<int>::min();
 363   EXPECT_EQ(fmt::format("{}", min),
 364             fmt::format("{:%Q}", std::chrono::duration<int>(min)));
 365 }
 366
 367 TEST(ChronoTest, SpecialDurations) {
 368   EXPECT_EQ(
 369       "40.",
 370       fmt::format("{:%S}", std::chrono::duration<double>(1e20)).substr(0, 3));
 371   auto nan = std::numeric_limits<double>::quiet_NaN();
 372   EXPECT_EQ(
 373       "nan nan nan nan nan:nan nan",
 374       fmt::format("{:%I %H %M %S %R %r}", std::chrono::duration<double>(nan)));
 375   fmt::format("{:%S}",
 376               std::chrono::duration<float, std::atto>(1.79400457e+31f));
 377   EXPECT_EQ(fmt::format("{}", std::chrono::duration<float, std::exa>(1)),
 378             "1Es");
 379   EXPECT_EQ(fmt::format("{}", std::chrono::duration<float, std::atto>(1)),
 380             "1as");
 381   EXPECT_EQ(fmt::format("{:%R}", std::chrono::duration<char, std::mega>{2}),
 382             "03:33");
 383   EXPECT_EQ(fmt::format("{:%T}", std::chrono::duration<char, std::mega>{2}),
 384             "03:33:20");
 385 }
 386
 387 #endif  // FMT_STATIC_THOUSANDS_SEPARATOR