xref: /aosp_15_r20/external/fmtlib/test/chrono-test.cc (revision 5c90c05cd622c0a81b57953a4d343e0e489f2e08) 
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 #include "fmt/chrono.h"
9 
10 #include <algorithm>
11 #include <ctime>
12 #include <vector>
13 
14 #include "gtest-extra.h"  // EXPECT_THROW_MSG
15 #include "util.h"         // get_locale
16 
17 using fmt::runtime;
18 using testing::Contains;
19 
20 template <typename Duration>
21 using sys_time = std::chrono::time_point<std::chrono::system_clock, Duration>;
22 
23 #if defined(__MINGW32__) && !defined(_UCRT)
24 // Only C89 conversion specifiers when using MSVCRT instead of UCRT
25 #  define FMT_HAS_C99_STRFTIME 0
26 #else
27 #  define FMT_HAS_C99_STRFTIME 1
28 #endif
29 
30 #if defined(__cpp_lib_chrono) && __cpp_lib_chrono >= 201907L
31 using days = std::chrono::days;
32 #else
33 using days = std::chrono::duration<std::chrono::hours::rep, std::ratio<86400>>;
34 #endif
35 
make_tm()36 auto make_tm() -> std::tm {
37   auto time = std::tm();
38   time.tm_mday = 1;
39   return time;
40 }
41 
make_hour(int h)42 auto make_hour(int h) -> std::tm {
43   auto time = make_tm();
44   time.tm_hour = h;
45   return time;
46 }
47 
make_minute(int m)48 auto make_minute(int m) -> std::tm {
49   auto time = make_tm();
50   time.tm_min = m;
51   return time;
52 }
53 
make_second(int s)54 auto make_second(int s) -> std::tm {
55   auto time = make_tm();
56   time.tm_sec = s;
57   return time;
58 }
59 
system_strftime(const std::string & format,const std::tm * timeptr,std::locale * locptr=nullptr)60 std::string system_strftime(const std::string& format, const std::tm* timeptr,
61                             std::locale* locptr = nullptr) {
62   auto loc = locptr ? *locptr : std::locale::classic();
63   auto& facet = std::use_facet<std::time_put<char>>(loc);
64   std::ostringstream os;
65   os.imbue(loc);
66   facet.put(os, os, ' ', timeptr, format.c_str(),
67             format.c_str() + format.size());
68 #ifdef _WIN32
69   // Workaround a bug in older versions of Universal CRT.
70   auto str = os.str();
71   if (str == "-0000") str = "+0000";
72   return str;
73 #else
74   return os.str();
75 #endif
76 }
77 
make_tm(int year,int mon,int mday,int hour,int min,int sec)78 FMT_CONSTEXPR std::tm make_tm(int year, int mon, int mday, int hour, int min,
79                               int sec) {
80   auto tm = std::tm();
81   tm.tm_sec = sec;
82   tm.tm_min = min;
83   tm.tm_hour = hour;
84   tm.tm_mday = mday;
85   tm.tm_mon = mon - 1;
86   tm.tm_year = year - 1900;
87   return tm;
88 }
89 
TEST(chrono_test,format_tm)90 TEST(chrono_test, format_tm) {
91   auto tm = std::tm();
92   tm.tm_year = 116;
93   tm.tm_mon = 3;
94   tm.tm_mday = 25;
95   tm.tm_hour = 11;
96   tm.tm_min = 22;
97   tm.tm_sec = 33;
98   EXPECT_EQ(fmt::format("The date is {:%Y-%m-%d %H:%M:%S}.", tm),
99             "The date is 2016-04-25 11:22:33.");
100   EXPECT_EQ(fmt::format("{:%Y}", tm), "2016");
101   EXPECT_EQ(fmt::format("{:%C}", tm), "20");
102   EXPECT_EQ(fmt::format("{:%C%y}", tm), fmt::format("{:%Y}", tm));
103   EXPECT_EQ(fmt::format("{:%e}", tm), "25");
104   EXPECT_EQ(fmt::format("{:%D}", tm), "04/25/16");
105   EXPECT_EQ(fmt::format("{:%F}", tm), "2016-04-25");
106   EXPECT_EQ(fmt::format("{:%T}", tm), "11:22:33");
107 
108   // Short year
109   tm.tm_year = 999 - 1900;
110   tm.tm_mon = 0;   // for %G
111   tm.tm_mday = 2;  // for %G
112   tm.tm_wday = 3;  // for %G
113   tm.tm_yday = 1;  // for %G
114   EXPECT_EQ(fmt::format("{:%Y}", tm), "0999");
115   EXPECT_EQ(fmt::format("{:%C%y}", tm), "0999");
116   EXPECT_EQ(fmt::format("{:%G}", tm), "0999");
117 
118   tm.tm_year = 27 - 1900;
119   EXPECT_EQ(fmt::format("{:%Y}", tm), "0027");
120   EXPECT_EQ(fmt::format("{:%C%y}", tm), "0027");
121 
122   // Overflow year
123   tm.tm_year = 2147483647;
124   EXPECT_EQ(fmt::format("{:%Y}", tm), "2147485547");
125 
126   tm.tm_year = -2147483648;
127   EXPECT_EQ(fmt::format("{:%Y}", tm), "-2147481748");
128 
129   // for week on the year
130   // https://www.cl.cam.ac.uk/~mgk25/iso-time.html
131   std::vector<std::tm> tm_list = {
132       make_tm(1975, 12, 29, 12, 14, 16),  // W01
133       make_tm(1977, 1, 2, 12, 14, 16),    // W53
134       make_tm(1999, 12, 27, 12, 14, 16),  // W52
135       make_tm(1999, 12, 31, 12, 14, 16),  // W52
136       make_tm(2000, 1, 1, 12, 14, 16),    // W52
137       make_tm(2000, 1, 2, 12, 14, 16),    // W52
138       make_tm(2000, 1, 3, 12, 14, 16)     // W1
139   };
140 
141 #if !FMT_HAS_C99_STRFTIME
142   GTEST_SKIP() << "Skip the rest of this test because it relies on strftime() "
143                   "conforming to C99, but on this platform, MINGW + MSVCRT, "
144                   "the function conforms only to C89.";
145 #endif
146 
147   const std::string iso_week_spec = "%Y-%m-%d: %G %g %V";
148   for (auto ctm : tm_list) {
149     // Calculate tm_yday, tm_wday, etc.
150     std::time_t t = std::mktime(&ctm);
151     tm = *std::localtime(&t);
152 
153     auto fmt_spec = fmt::format("{{:{}}}", iso_week_spec);
154     EXPECT_EQ(system_strftime(iso_week_spec, &tm),
155               fmt::format(fmt::runtime(fmt_spec), tm));
156   }
157 
158   // Every day from 1970-01-01
159   std::time_t time_now = std::time(nullptr);
160   for (std::time_t t = 6 * 3600; t < time_now; t += 86400) {
161     tm = *std::localtime(&t);
162 
163     auto fmt_spec = fmt::format("{{:{}}}", iso_week_spec);
164     EXPECT_EQ(system_strftime(iso_week_spec, &tm),
165               fmt::format(fmt::runtime(fmt_spec), tm));
166   }
167 }
168 
169 // MSVC:
170 //  minkernel\crts\ucrt\src\appcrt\time\wcsftime.cpp(971) : Assertion failed:
171 //  timeptr->tm_year >= -1900 && timeptr->tm_year <= 8099
172 #ifndef _WIN32
TEST(chrono_test,format_tm_future)173 TEST(chrono_test, format_tm_future) {
174   auto tm = std::tm();
175   tm.tm_year = 10445;  // 10000+ years
176   tm.tm_mon = 3;
177   tm.tm_mday = 25;
178   tm.tm_hour = 11;
179   tm.tm_min = 22;
180   tm.tm_sec = 33;
181   EXPECT_EQ(fmt::format("The date is {:%Y-%m-%d %H:%M:%S}.", tm),
182             "The date is 12345-04-25 11:22:33.");
183   EXPECT_EQ(fmt::format("{:%Y}", tm), "12345");
184   EXPECT_EQ(fmt::format("{:%C}", tm), "123");
185   EXPECT_EQ(fmt::format("{:%C%y}", tm), fmt::format("{:%Y}", tm));
186   EXPECT_EQ(fmt::format("{:%D}", tm), "04/25/45");
187   EXPECT_EQ(fmt::format("{:%F}", tm), "12345-04-25");
188   EXPECT_EQ(fmt::format("{:%T}", tm), "11:22:33");
189 }
190 
TEST(chrono_test,format_tm_past)191 TEST(chrono_test, format_tm_past) {
192   auto tm = std::tm();
193   tm.tm_year = -2001;
194   tm.tm_mon = 3;
195   tm.tm_mday = 25;
196   tm.tm_hour = 11;
197   tm.tm_min = 22;
198   tm.tm_sec = 33;
199   EXPECT_EQ(fmt::format("The date is {:%Y-%m-%d %H:%M:%S}.", tm),
200             "The date is -101-04-25 11:22:33.");
201   EXPECT_EQ(fmt::format("{:%Y}", tm), "-101");
202 
203   // macOS  %C - "-1"
204   // Linux  %C - "-2"
205   // fmt    %C - "-1"
206   EXPECT_EQ(fmt::format("{:%C}", tm), "-1");
207   EXPECT_EQ(fmt::format("{:%C%y}", tm), fmt::format("{:%Y}", tm));
208 
209   // macOS  %D - "04/25/01" (%y)
210   // Linux  %D - "04/25/99" (%y)
211   // fmt    %D - "04/25/01" (%y)
212   EXPECT_EQ(fmt::format("{:%D}", tm), "04/25/01");
213 
214   EXPECT_EQ(fmt::format("{:%F}", tm), "-101-04-25");
215   EXPECT_EQ(fmt::format("{:%T}", tm), "11:22:33");
216 
217   tm.tm_year = -1901;  // -1
218   EXPECT_EQ(fmt::format("{:%Y}", tm), "-001");
219   EXPECT_EQ(fmt::format("{:%C%y}", tm), fmt::format("{:%Y}", tm));
220 
221   tm.tm_year = -1911;  // -11
222   EXPECT_EQ(fmt::format("{:%Y}", tm), "-011");
223   EXPECT_EQ(fmt::format("{:%C%y}", tm), fmt::format("{:%Y}", tm));
224 }
225 #endif
226 
TEST(chrono_test,grow_buffer)227 TEST(chrono_test, grow_buffer) {
228   auto s = std::string("{:");
229   for (int i = 0; i < 30; ++i) s += "%c";
230   s += "}\n";
231   auto t = std::time(nullptr);
232   (void)fmt::format(fmt::runtime(s), *std::localtime(&t));
233 }
234 
TEST(chrono_test,format_to_empty_container)235 TEST(chrono_test, format_to_empty_container) {
236   auto time = std::tm();
237   time.tm_sec = 42;
238   auto s = std::string();
239   fmt::format_to(std::back_inserter(s), "{:%S}", time);
240   EXPECT_EQ(s, "42");
241 }
242 
TEST(chrono_test,empty_result)243 TEST(chrono_test, empty_result) { EXPECT_EQ(fmt::format("{}", std::tm()), ""); }
244 
equal(const std::tm & lhs,const std::tm & rhs)245 auto equal(const std::tm& lhs, const std::tm& rhs) -> bool {
246   return lhs.tm_sec == rhs.tm_sec && lhs.tm_min == rhs.tm_min &&
247          lhs.tm_hour == rhs.tm_hour && lhs.tm_mday == rhs.tm_mday &&
248          lhs.tm_mon == rhs.tm_mon && lhs.tm_year == rhs.tm_year &&
249          lhs.tm_wday == rhs.tm_wday && lhs.tm_yday == rhs.tm_yday &&
250          lhs.tm_isdst == rhs.tm_isdst;
251 }
252 
TEST(chrono_test,gmtime)253 TEST(chrono_test, gmtime) {
254   auto t = std::time(nullptr);
255   auto tm = *std::gmtime(&t);
256   EXPECT_TRUE(equal(tm, fmt::gmtime(t)));
257 }
258 
259 template <typename TimePoint>
strftime_full_utc(TimePoint tp)260 auto strftime_full_utc(TimePoint tp) -> std::string {
261   auto t = std::chrono::system_clock::to_time_t(tp);
262   auto tm = *std::gmtime(&t);
263   return system_strftime("%Y-%m-%d %H:%M:%S", &tm);
264 }
265 
TEST(chrono_test,system_clock_time_point)266 TEST(chrono_test, system_clock_time_point) {
267   auto t1 = std::chrono::time_point_cast<std::chrono::seconds>(
268       std::chrono::system_clock::now());
269   EXPECT_EQ(strftime_full_utc(t1), fmt::format("{:%Y-%m-%d %H:%M:%S}", t1));
270   EXPECT_EQ(strftime_full_utc(t1), fmt::format("{}", t1));
271   EXPECT_EQ(strftime_full_utc(t1), fmt::format("{:}", t1));
272 
273   auto t2 = sys_time<std::chrono::seconds>(std::chrono::seconds(42));
274   EXPECT_EQ(strftime_full_utc(t2), fmt::format("{:%Y-%m-%d %H:%M:%S}", t2));
275 
276   std::vector<std::string> spec_list = {
277       "%%",  "%n",  "%t",  "%Y",  "%EY", "%y",  "%Oy", "%Ey", "%C",
278       "%EC", "%G",  "%g",  "%b",  "%h",  "%B",  "%m",  "%Om", "%U",
279       "%OU", "%W",  "%OW", "%V",  "%OV", "%j",  "%d",  "%Od", "%e",
280       "%Oe", "%a",  "%A",  "%w",  "%Ow", "%u",  "%Ou", "%H",  "%OH",
281       "%I",  "%OI", "%M",  "%OM", "%S",  "%OS", "%x",  "%Ex", "%X",
282       "%EX", "%D",  "%F",  "%R",  "%T",  "%p"};
283 #ifndef _WIN32
284   // Disabled on Windows because these formats are not consistent among
285   // platforms.
286   spec_list.insert(spec_list.end(), {"%c", "%Ec", "%r"});
287 #elif !FMT_HAS_C99_STRFTIME
288   // Only C89 conversion specifiers when using MSVCRT instead of UCRT
289   spec_list = {"%%", "%Y", "%y", "%b", "%B", "%m", "%U", "%W", "%j", "%d",
290                "%a", "%A", "%w", "%H", "%I", "%M", "%S", "%x", "%X", "%p"};
291 #endif
292   spec_list.push_back("%Y-%m-%d %H:%M:%S");
293 
294   for (const auto& spec : spec_list) {
295     auto t = std::chrono::system_clock::to_time_t(t1);
296     auto tm = *std::gmtime(&t);
297 
298     auto sys_output = system_strftime(spec, &tm);
299 
300     auto fmt_spec = fmt::format("{{:{}}}", spec);
301     EXPECT_EQ(sys_output, fmt::format(fmt::runtime(fmt_spec), t1));
302     EXPECT_EQ(sys_output, fmt::format(fmt::runtime(fmt_spec), tm));
303   }
304 
305   // Timezone formatters tests makes sense for localtime.
306 #if FMT_HAS_C99_STRFTIME
307   spec_list = {"%z", "%Z"};
308 #else
309   spec_list = {"%Z"};
310 #endif
311   for (const auto& spec : spec_list) {
312     auto t = std::chrono::system_clock::to_time_t(t1);
313     auto tm = *std::localtime(&t);
314 
315     auto sys_output = system_strftime(spec, &tm);
316 
317     auto fmt_spec = fmt::format("{{:{}}}", spec);
318     EXPECT_EQ(sys_output, fmt::format(fmt::runtime(fmt_spec), tm));
319 
320     if (spec == "%z") {
321       sys_output.insert(sys_output.end() - 2, 1, ':');
322       EXPECT_EQ(sys_output, fmt::format("{:%Ez}", tm));
323       EXPECT_EQ(sys_output, fmt::format("{:%Oz}", tm));
324     }
325   }
326 
327   // Separate tests for UTC, since std::time_put can use local time and ignoring
328   // the timezone in std::tm (if it presents on platform).
329   if (fmt::detail::has_member_data_tm_zone<std::tm>::value) {
330     auto t = std::chrono::system_clock::to_time_t(t1);
331     auto tm = *std::gmtime(&t);
332 
333     std::vector<std::string> tz_names = {"GMT", "UTC"};
334     EXPECT_THAT(tz_names, Contains(fmt::format("{:%Z}", t1)));
335     EXPECT_THAT(tz_names, Contains(fmt::format("{:%Z}", tm)));
336   }
337 
338   if (fmt::detail::has_member_data_tm_gmtoff<std::tm>::value) {
339     auto t = std::chrono::system_clock::to_time_t(t1);
340     auto tm = *std::gmtime(&t);
341 
342     EXPECT_EQ(fmt::format("{:%z}", t1), "+0000");
343     EXPECT_EQ(fmt::format("{:%z}", tm), "+0000");
344 
345     EXPECT_EQ(fmt::format("{:%Ez}", t1), "+00:00");
346     EXPECT_EQ(fmt::format("{:%Ez}", tm), "+00:00");
347 
348     EXPECT_EQ(fmt::format("{:%Oz}", t1), "+00:00");
349     EXPECT_EQ(fmt::format("{:%Oz}", tm), "+00:00");
350   }
351 }
352 
353 #if FMT_USE_LOCAL_TIME
354 
TEST(chrono_test,localtime)355 TEST(chrono_test, localtime) {
356   auto t = std::time(nullptr);
357   auto tm = *std::localtime(&t);
358   EXPECT_TRUE(equal(tm, fmt::localtime(t)));
359 }
360 
361 template <typename Duration>
strftime_full_local(std::chrono::local_time<Duration> tp)362 auto strftime_full_local(std::chrono::local_time<Duration> tp) -> std::string {
363   auto t = std::chrono::system_clock::to_time_t(
364       std::chrono::current_zone()->to_sys(tp));
365   auto tm = *std::localtime(&t);
366   return system_strftime("%Y-%m-%d %H:%M:%S", &tm);
367 }
368 
TEST(chrono_test,local_system_clock_time_point)369 TEST(chrono_test, local_system_clock_time_point) {
370 #  ifdef _WIN32
371   return;  // Not supported on Windows.
372 #  endif
373   auto t1 = std::chrono::time_point_cast<std::chrono::seconds>(
374       std::chrono::current_zone()->to_local(std::chrono::system_clock::now()));
375   EXPECT_EQ(strftime_full_local(t1), fmt::format("{:%Y-%m-%d %H:%M:%S}", t1));
376   EXPECT_EQ(strftime_full_local(t1), fmt::format("{}", t1));
377   EXPECT_EQ(strftime_full_local(t1), fmt::format("{:}", t1));
378   using time_point = std::chrono::local_time<std::chrono::seconds>;
379   auto t2 = time_point(std::chrono::seconds(86400 + 42));
380   EXPECT_EQ(strftime_full_local(t2), fmt::format("{:%Y-%m-%d %H:%M:%S}", t2));
381 
382   std::vector<std::string> spec_list = {
383       "%%",  "%n",  "%t",  "%Y",  "%EY", "%y",  "%Oy", "%Ey", "%C",
384       "%EC", "%G",  "%g",  "%b",  "%h",  "%B",  "%m",  "%Om", "%U",
385       "%OU", "%W",  "%OW", "%V",  "%OV", "%j",  "%d",  "%Od", "%e",
386       "%Oe", "%a",  "%A",  "%w",  "%Ow", "%u",  "%Ou", "%H",  "%OH",
387       "%I",  "%OI", "%M",  "%OM", "%S",  "%OS", "%x",  "%Ex", "%X",
388       "%EX", "%D",  "%F",  "%R",  "%T",  "%p",  "%z",  "%Z"};
389 #  ifndef _WIN32
390   // Disabled on Windows because these formats are not consistent among
391   // platforms.
392   spec_list.insert(spec_list.end(), {"%c", "%Ec", "%r"});
393 #  elif !FMT_HAS_C99_STRFTIME
394   // Only C89 conversion specifiers when using MSVCRT instead of UCRT
395   spec_list = {"%%", "%Y", "%y", "%b", "%B", "%m", "%U", "%W", "%j", "%d", "%a",
396                "%A", "%w", "%H", "%I", "%M", "%S", "%x", "%X", "%p", "%Z"};
397 #  endif
398   spec_list.push_back("%Y-%m-%d %H:%M:%S");
399 
400   for (const auto& spec : spec_list) {
401     auto t = std::chrono::system_clock::to_time_t(
402         std::chrono::current_zone()->to_sys(t1));
403     auto tm = *std::localtime(&t);
404 
405     auto sys_output = system_strftime(spec, &tm);
406 
407     auto fmt_spec = fmt::format("{{:{}}}", spec);
408     EXPECT_EQ(sys_output, fmt::format(fmt::runtime(fmt_spec), t1));
409     EXPECT_EQ(sys_output, fmt::format(fmt::runtime(fmt_spec), tm));
410   }
411 
412   if (std::find(spec_list.cbegin(), spec_list.cend(), "%z") !=
413       spec_list.cend()) {
414     auto t = std::chrono::system_clock::to_time_t(
415         std::chrono::current_zone()->to_sys(t1));
416     auto tm = *std::localtime(&t);
417 
418     auto sys_output = system_strftime("%z", &tm);
419     sys_output.insert(sys_output.end() - 2, 1, ':');
420 
421     EXPECT_EQ(sys_output, fmt::format("{:%Ez}", t1));
422     EXPECT_EQ(sys_output, fmt::format("{:%Ez}", tm));
423 
424     EXPECT_EQ(sys_output, fmt::format("{:%Oz}", t1));
425     EXPECT_EQ(sys_output, fmt::format("{:%Oz}", tm));
426   }
427 }
428 
429 #endif  // FMT_USE_LOCAL_TIME
430 
431 #ifndef FMT_STATIC_THOUSANDS_SEPARATOR
432 
TEST(chrono_test,format_default)433 TEST(chrono_test, format_default) {
434   EXPECT_EQ(fmt::format("{}", std::chrono::seconds(42)), "42s");
435   EXPECT_EQ(fmt::format("{}", std::chrono::duration<int, std::atto>(42)),
436             "42as");
437   EXPECT_EQ(fmt::format("{}", std::chrono::duration<int, std::femto>(42)),
438             "42fs");
439   EXPECT_EQ(fmt::format("{}", std::chrono::duration<int, std::pico>(42)),
440             "42ps");
441   EXPECT_EQ(fmt::format("{}", std::chrono::nanoseconds(42)), "42ns");
442   EXPECT_EQ(fmt::format("{}", std::chrono::microseconds(42)), "42µs");
443   EXPECT_EQ(fmt::format("{}", std::chrono::milliseconds(42)), "42ms");
444   EXPECT_EQ(fmt::format("{}", std::chrono::duration<int, std::centi>(42)),
445             "42cs");
446   EXPECT_EQ(fmt::format("{}", std::chrono::duration<int, std::deci>(42)),
447             "42ds");
448   EXPECT_EQ(fmt::format("{}", std::chrono::seconds(42)), "42s");
449   EXPECT_EQ(fmt::format("{}", std::chrono::duration<int, std::deca>(42)),
450             "42das");
451   EXPECT_EQ(fmt::format("{}", std::chrono::duration<int, std::hecto>(42)),
452             "42hs");
453   EXPECT_EQ(fmt::format("{}", std::chrono::duration<int, std::kilo>(42)),
454             "42ks");
455   EXPECT_EQ(fmt::format("{}", std::chrono::duration<int, std::mega>(42)),
456             "42Ms");
457   EXPECT_EQ(fmt::format("{}", std::chrono::duration<int, std::giga>(42)),
458             "42Gs");
459   EXPECT_EQ(fmt::format("{}", std::chrono::duration<int, std::tera>(42)),
460             "42Ts");
461   EXPECT_EQ(fmt::format("{}", std::chrono::duration<int, std::peta>(42)),
462             "42Ps");
463   EXPECT_EQ(fmt::format("{}", std::chrono::duration<int, std::exa>(42)),
464             "42Es");
465   EXPECT_EQ(fmt::format("{}", std::chrono::minutes(42)), "42min");
466   EXPECT_EQ(fmt::format("{}", std::chrono::hours(42)), "42h");
467   EXPECT_EQ(fmt::format("{}", days(42)), "42d");
468   EXPECT_EQ(
469       fmt::format("{}", std::chrono::duration<int, std::ratio<15, 1>>(42)),
470       "42[15]s");
471   EXPECT_EQ(
472       fmt::format("{}", std::chrono::duration<int, std::ratio<15, 4>>(42)),
473       "42[15/4]s");
474 }
475 
TEST(chrono_test,duration_align)476 TEST(chrono_test, duration_align) {
477   auto s = std::chrono::seconds(42);
478   EXPECT_EQ(fmt::format("{:5}", s), "42s  ");
479   EXPECT_EQ(fmt::format("{:{}}", s, 5), "42s  ");
480   EXPECT_EQ(fmt::format("{:>5}", s), "  42s");
481   EXPECT_EQ(fmt::format("{:*^7}", s), "**42s**");
482   EXPECT_EQ(fmt::format("{:12%H:%M:%S}", std::chrono::seconds(12345)),
483             "03:25:45    ");
484   EXPECT_EQ(fmt::format("{:>12%H:%M:%S}", std::chrono::seconds(12345)),
485             "    03:25:45");
486   EXPECT_EQ(fmt::format("{:~^12%H:%M:%S}", std::chrono::seconds(12345)),
487             "~~03:25:45~~");
488   EXPECT_EQ(fmt::format("{:{}%H:%M:%S}", std::chrono::seconds(12345), 12),
489             "03:25:45    ");
490 }
491 
TEST(chrono_test,tm_align)492 TEST(chrono_test, tm_align) {
493   auto t = make_tm(1975, 12, 29, 12, 14, 16);
494   EXPECT_EQ(fmt::format("{:%F %T}", t), "1975-12-29 12:14:16");
495   EXPECT_EQ(fmt::format("{:30%F %T}", t), "1975-12-29 12:14:16           ");
496   EXPECT_EQ(fmt::format("{:{}%F %T}", t, 30), "1975-12-29 12:14:16           ");
497   EXPECT_EQ(fmt::format("{:<30%F %T}", t), "1975-12-29 12:14:16           ");
498   EXPECT_EQ(fmt::format("{:^30%F %T}", t), "     1975-12-29 12:14:16      ");
499   EXPECT_EQ(fmt::format("{:>30%F %T}", t), "           1975-12-29 12:14:16");
500 
501   EXPECT_EQ(fmt::format("{:*<30%F %T}", t), "1975-12-29 12:14:16***********");
502   EXPECT_EQ(fmt::format("{:*^30%F %T}", t), "*****1975-12-29 12:14:16******");
503   EXPECT_EQ(fmt::format("{:*>30%F %T}", t), "***********1975-12-29 12:14:16");
504 }
505 
TEST(chrono_test,tp_align)506 TEST(chrono_test, tp_align) {
507   auto tp = std::chrono::time_point_cast<std::chrono::microseconds>(
508       std::chrono::system_clock::from_time_t(0));
509   EXPECT_EQ(fmt::format("{:%M:%S}", tp), "00:00.000000");
510   EXPECT_EQ(fmt::format("{:15%M:%S}", tp), "00:00.000000   ");
511   EXPECT_EQ(fmt::format("{:{}%M:%S}", tp, 15), "00:00.000000   ");
512   EXPECT_EQ(fmt::format("{:<15%M:%S}", tp), "00:00.000000   ");
513   EXPECT_EQ(fmt::format("{:^15%M:%S}", tp), " 00:00.000000  ");
514   EXPECT_EQ(fmt::format("{:>15%M:%S}", tp), "   00:00.000000");
515 
516   EXPECT_EQ(fmt::format("{:*<15%M:%S}", tp), "00:00.000000***");
517   EXPECT_EQ(fmt::format("{:*^15%M:%S}", tp), "*00:00.000000**");
518   EXPECT_EQ(fmt::format("{:*>15%M:%S}", tp), "***00:00.000000");
519 }
520 
TEST(chrono_test,format_specs)521 TEST(chrono_test, format_specs) {
522   EXPECT_EQ(fmt::format("{:%%}", std::chrono::seconds(0)), "%");
523   EXPECT_EQ(fmt::format("{:%n}", std::chrono::seconds(0)), "\n");
524   EXPECT_EQ(fmt::format("{:%t}", std::chrono::seconds(0)), "\t");
525   EXPECT_EQ(fmt::format("{:%S}", std::chrono::seconds(0)), "00");
526   EXPECT_EQ(fmt::format("{:%S}", std::chrono::seconds(60)), "00");
527   EXPECT_EQ(fmt::format("{:%S}", std::chrono::seconds(42)), "42");
528   EXPECT_EQ(fmt::format("{:%S}", std::chrono::milliseconds(1234)), "01.234");
529   EXPECT_EQ(fmt::format("{:%M}", std::chrono::minutes(0)), "00");
530   EXPECT_EQ(fmt::format("{:%M}", std::chrono::minutes(60)), "00");
531   EXPECT_EQ(fmt::format("{:%M}", std::chrono::minutes(42)), "42");
532   EXPECT_EQ(fmt::format("{:%M}", std::chrono::seconds(61)), "01");
533   EXPECT_EQ(fmt::format("{:%H}", std::chrono::hours(0)), "00");
534   EXPECT_EQ(fmt::format("{:%H}", std::chrono::hours(24)), "00");
535   EXPECT_EQ(fmt::format("{:%H}", std::chrono::hours(14)), "14");
536   EXPECT_EQ(fmt::format("{:%H}", std::chrono::minutes(61)), "01");
537   EXPECT_EQ(fmt::format("{:%I}", std::chrono::hours(0)), "12");
538   EXPECT_EQ(fmt::format("{:%I}", std::chrono::hours(12)), "12");
539   EXPECT_EQ(fmt::format("{:%I}", std::chrono::hours(24)), "12");
540   EXPECT_EQ(fmt::format("{:%I}", std::chrono::hours(4)), "04");
541   EXPECT_EQ(fmt::format("{:%I}", std::chrono::hours(14)), "02");
542   EXPECT_EQ(fmt::format("{:%j}", days(12)), "12");
543   EXPECT_EQ(fmt::format("{:%j}", days(12345)), "12345");
544   EXPECT_EQ(fmt::format("{:%j}", std::chrono::hours(12345 * 24 + 12)), "12345");
545   EXPECT_EQ(fmt::format("{:%H:%M:%S}", std::chrono::seconds(12345)),
546             "03:25:45");
547   EXPECT_EQ(fmt::format("{:%R}", std::chrono::seconds(12345)), "03:25");
548   EXPECT_EQ(fmt::format("{:%T}", std::chrono::seconds(12345)), "03:25:45");
549   EXPECT_EQ(fmt::format("{:%Q}", std::chrono::seconds(12345)), "12345");
550   EXPECT_EQ(fmt::format("{:%q}", std::chrono::seconds(12345)), "s");
551 }
552 
TEST(chrono_test,invalid_specs)553 TEST(chrono_test, invalid_specs) {
554   auto sec = std::chrono::seconds(0);
555   EXPECT_THROW_MSG((void)fmt::format(runtime("{:%a}"), sec), fmt::format_error,
556                    "no date");
557   EXPECT_THROW_MSG((void)fmt::format(runtime("{:%A}"), sec), fmt::format_error,
558                    "no date");
559   EXPECT_THROW_MSG((void)fmt::format(runtime("{:%c}"), sec), fmt::format_error,
560                    "no date");
561   EXPECT_THROW_MSG((void)fmt::format(runtime("{:%x}"), sec), fmt::format_error,
562                    "no date");
563   EXPECT_THROW_MSG((void)fmt::format(runtime("{:%Ex}"), sec), fmt::format_error,
564                    "no date");
565   EXPECT_THROW_MSG((void)fmt::format(runtime("{:%X}"), sec), fmt::format_error,
566                    "no date");
567   EXPECT_THROW_MSG((void)fmt::format(runtime("{:%EX}"), sec), fmt::format_error,
568                    "no date");
569   EXPECT_THROW_MSG((void)fmt::format(runtime("{:%D}"), sec), fmt::format_error,
570                    "no date");
571   EXPECT_THROW_MSG((void)fmt::format(runtime("{:%F}"), sec), fmt::format_error,
572                    "no date");
573   EXPECT_THROW_MSG((void)fmt::format(runtime("{:%Ec}"), sec), fmt::format_error,
574                    "no date");
575   EXPECT_THROW_MSG((void)fmt::format(runtime("{:%w}"), sec), fmt::format_error,
576                    "no date");
577   EXPECT_THROW_MSG((void)fmt::format(runtime("{:%u}"), sec), fmt::format_error,
578                    "no date");
579   EXPECT_THROW_MSG((void)fmt::format(runtime("{:%b}"), sec), fmt::format_error,
580                    "no date");
581   EXPECT_THROW_MSG((void)fmt::format(runtime("{:%B}"), sec), fmt::format_error,
582                    "no date");
583   EXPECT_THROW_MSG((void)fmt::format(runtime("{:%z}"), sec), fmt::format_error,
584                    "no date");
585   EXPECT_THROW_MSG((void)fmt::format(runtime("{:%Z}"), sec), fmt::format_error,
586                    "no date");
587   EXPECT_THROW_MSG((void)fmt::format(runtime("{:%Eq}"), sec), fmt::format_error,
588                    "invalid format");
589   EXPECT_THROW_MSG((void)fmt::format(runtime("{:%Oq}"), sec), fmt::format_error,
590                    "invalid format");
591   EXPECT_THROW_MSG((void)fmt::format(runtime("{:abc}"), sec), fmt::format_error,
592                    "invalid format");
593   EXPECT_THROW_MSG((void)fmt::format(runtime("{:.2f}"), sec), fmt::format_error,
594                    "invalid format");
595 }
596 
format_tm(const std::tm & time,fmt::string_view spec,const std::locale & loc)597 auto format_tm(const std::tm& time, fmt::string_view spec,
598                const std::locale& loc) -> std::string {
599   auto& facet = std::use_facet<std::time_put<char>>(loc);
600   std::ostringstream os;
601   os.imbue(loc);
602   facet.put(os, os, ' ', &time, spec.begin(), spec.end());
603   return os.str();
604 }
605 
TEST(chrono_test,locale)606 TEST(chrono_test, locale) {
607   auto loc = get_locale("ja_JP.utf8");
608   if (loc == std::locale::classic()) return;
609 #  define EXPECT_TIME(spec, time, duration)                     \
610     {                                                           \
611       auto jp_loc = std::locale("ja_JP.utf8");                  \
612       EXPECT_EQ(format_tm(time, spec, jp_loc),                  \
613                 fmt::format(jp_loc, "{:L" spec "}", duration)); \
614     }
615   EXPECT_TIME("%OH", make_hour(14), std::chrono::hours(14));
616   EXPECT_TIME("%OI", make_hour(14), std::chrono::hours(14));
617   EXPECT_TIME("%OM", make_minute(42), std::chrono::minutes(42));
618   EXPECT_TIME("%OS", make_second(42), std::chrono::seconds(42));
619   auto time = make_tm();
620   time.tm_hour = 3;
621   time.tm_min = 25;
622   time.tm_sec = 45;
623   auto sec = std::chrono::seconds(12345);
624   EXPECT_TIME("%r", time, sec);
625   EXPECT_TIME("%p", time, sec);
626 }
627 
628 using dms = std::chrono::duration<double, std::milli>;
629 
TEST(chrono_test,format_default_fp)630 TEST(chrono_test, format_default_fp) {
631   EXPECT_EQ(fmt::format("{}", std::chrono::duration<float>(1.234)), "1.234s");
632   EXPECT_EQ(fmt::format("{}", std::chrono::duration<float, std::milli>(1.234)),
633             "1.234ms");
634   EXPECT_EQ(fmt::format("{}", std::chrono::duration<double>(1.234)), "1.234s");
635   EXPECT_EQ(fmt::format("{}", dms(1.234)), "1.234ms");
636 }
637 
TEST(chrono_test,format_precision)638 TEST(chrono_test, format_precision) {
639   EXPECT_THROW_MSG(
640       (void)fmt::format(runtime("{:.2%Q}"), std::chrono::seconds(42)),
641       fmt::format_error, "precision not allowed for this argument type");
642   EXPECT_EQ(fmt::format("{:.0}", dms(1.234)), "1ms");
643   EXPECT_EQ(fmt::format("{:.1}", dms(1.234)), "1.2ms");
644   EXPECT_EQ(fmt::format("{:.{}}", dms(1.234), 2), "1.23ms");
645 
646   EXPECT_EQ(fmt::format("{:.0}", dms(12.56)), "13ms");
647   EXPECT_EQ(fmt::format("{:.1}", dms(12.56)), "12.6ms");
648   EXPECT_EQ(fmt::format("{:.2}", dms(12.56)), "12.56ms");
649 }
650 
TEST(chrono_test,format_full_specs)651 TEST(chrono_test, format_full_specs) {
652   EXPECT_EQ(fmt::format("{:6.0}", dms(1.234)), "1ms   ");
653   EXPECT_EQ(fmt::format("{:6.1}", dms(1.234)), "1.2ms ");
654   EXPECT_EQ(fmt::format("{:>8.{}}", dms(1.234), 2), "  1.23ms");
655   EXPECT_EQ(fmt::format("{:^{}.{}}", dms(1.234), 7, 1), " 1.2ms ");
656   EXPECT_EQ(fmt::format("{0:^{2}.{1}}", dms(1.234), 2, 8), " 1.23ms ");
657   EXPECT_EQ(fmt::format("{:=^{}.{}}", dms(1.234), 9, 3), "=1.234ms=");
658   EXPECT_EQ(fmt::format("{:*^10.4}", dms(1.234)), "*1.2340ms*");
659 
660   EXPECT_EQ(fmt::format("{:6.0}", dms(12.56)), "13ms  ");
661   EXPECT_EQ(fmt::format("{:>8.{}}", dms(12.56), 0), "    13ms");
662   EXPECT_EQ(fmt::format("{:^{}.{}}", dms(12.56), 6, 0), " 13ms ");
663   EXPECT_EQ(fmt::format("{0:^{2}.{1}}", dms(12.56), 0, 8), "  13ms  ");
664   EXPECT_EQ(fmt::format("{:=^{}.{}}", dms(12.56), 9, 0), "==13ms===");
665   EXPECT_EQ(fmt::format("{:*^10.0}", dms(12.56)), "***13ms***");
666 }
667 
TEST(chrono_test,format_simple_q)668 TEST(chrono_test, format_simple_q) {
669   EXPECT_EQ(fmt::format("{:%Q %q}", std::chrono::duration<float>(1.234)),
670             "1.234 s");
671   EXPECT_EQ(
672       fmt::format("{:%Q %q}", std::chrono::duration<float, std::milli>(1.234)),
673       "1.234 ms");
674   EXPECT_EQ(fmt::format("{:%Q %q}", std::chrono::duration<double>(1.234)),
675             "1.234 s");
676   EXPECT_EQ(fmt::format("{:%Q %q}", dms(1.234)), "1.234 ms");
677 }
678 
TEST(chrono_test,format_precision_q)679 TEST(chrono_test, format_precision_q) {
680   EXPECT_THROW_MSG(
681       (void)fmt::format(runtime("{:.2%Q %q}"), std::chrono::seconds(42)),
682       fmt::format_error, "precision not allowed for this argument type");
683   EXPECT_EQ(fmt::format("{:.1%Q %q}", dms(1.234)), "1.2 ms");
684   EXPECT_EQ(fmt::format("{:.{}%Q %q}", dms(1.234), 2), "1.23 ms");
685 }
686 
TEST(chrono_test,format_full_specs_q)687 TEST(chrono_test, format_full_specs_q) {
688   EXPECT_EQ(fmt::format("{:7.0%Q %q}", dms(1.234)), "1 ms   ");
689   EXPECT_EQ(fmt::format("{:7.1%Q %q}", dms(1.234)), "1.2 ms ");
690   EXPECT_EQ(fmt::format("{:>8.{}%Q %q}", dms(1.234), 2), " 1.23 ms");
691   EXPECT_EQ(fmt::format("{:^{}.{}%Q %q}", dms(1.234), 8, 1), " 1.2 ms ");
692   EXPECT_EQ(fmt::format("{0:^{2}.{1}%Q %q}", dms(1.234), 2, 9), " 1.23 ms ");
693   EXPECT_EQ(fmt::format("{:=^{}.{}%Q %q}", dms(1.234), 10, 3), "=1.234 ms=");
694   EXPECT_EQ(fmt::format("{:*^11.4%Q %q}", dms(1.234)), "*1.2340 ms*");
695 
696   EXPECT_EQ(fmt::format("{:7.0%Q %q}", dms(12.56)), "13 ms  ");
697   EXPECT_EQ(fmt::format("{:>8.{}%Q %q}", dms(12.56), 0), "   13 ms");
698   EXPECT_EQ(fmt::format("{:^{}.{}%Q %q}", dms(12.56), 8, 0), " 13 ms  ");
699   EXPECT_EQ(fmt::format("{0:^{2}.{1}%Q %q}", dms(12.56), 0, 9), "  13 ms  ");
700   EXPECT_EQ(fmt::format("{:=^{}.{}%Q %q}", dms(12.56), 9, 0), "==13 ms==");
701   EXPECT_EQ(fmt::format("{:*^11.0%Q %q}", dms(12.56)), "***13 ms***");
702 }
703 
TEST(chrono_test,invalid_width_id)704 TEST(chrono_test, invalid_width_id) {
705   EXPECT_THROW((void)fmt::format(runtime("{:{o}"), std::chrono::seconds(0)),
706                fmt::format_error);
707 }
708 
TEST(chrono_test,invalid_colons)709 TEST(chrono_test, invalid_colons) {
710   EXPECT_THROW((void)fmt::format(runtime("{0}=:{0::"), std::chrono::seconds(0)),
711                fmt::format_error);
712 }
713 
TEST(chrono_test,negative_durations)714 TEST(chrono_test, negative_durations) {
715   EXPECT_EQ(fmt::format("{:%Q}", std::chrono::seconds(-12345)), "-12345");
716   EXPECT_EQ(fmt::format("{:%H:%M:%S}", std::chrono::seconds(-12345)),
717             "-03:25:45");
718   EXPECT_EQ(fmt::format("{:%M:%S}", std::chrono::duration<double>(-1)),
719             "-00:01");
720   EXPECT_EQ(fmt::format("{:%q}", std::chrono::seconds(-12345)), "s");
721   EXPECT_EQ(fmt::format("{:%S}",
722                         std::chrono::duration<signed char, std::milli>(-127)),
723             "-00.127");
724   auto min = std::numeric_limits<int>::min();
725   EXPECT_EQ(fmt::format("{}", min),
726             fmt::format("{:%Q}", std::chrono::duration<int>(min)));
727 }
728 
TEST(chrono_test,special_durations)729 TEST(chrono_test, special_durations) {
730   EXPECT_EQ(fmt::format("{:%S}", std::chrono::duration<double>(1e20)), "40");
731   auto nan = std::numeric_limits<double>::quiet_NaN();
732   EXPECT_EQ(
733       fmt::format("{:%I %H %M %S %R %r}", std::chrono::duration<double>(nan)),
734       "nan nan nan nan nan:nan nan");
735   EXPECT_EQ(fmt::format("{}", std::chrono::duration<float, std::exa>(1)),
736             "1Es");
737   EXPECT_EQ(fmt::format("{}", std::chrono::duration<float, std::atto>(1)),
738             "1as");
739   EXPECT_EQ(fmt::format("{:%R}", std::chrono::duration<char, std::mega>{2}),
740             "03:33");
741   EXPECT_EQ(fmt::format("{:%T}", std::chrono::duration<char, std::mega>{2}),
742             "03:33:20");
743   EXPECT_EQ(
744       fmt::format("{:.3%S}", std::chrono::duration<float, std::pico>(1.234e12)),
745       "01.234");
746 }
747 
TEST(chrono_test,unsigned_duration)748 TEST(chrono_test, unsigned_duration) {
749   EXPECT_EQ(fmt::format("{}", std::chrono::duration<unsigned>(42)), "42s");
750 }
751 
TEST(chrono_test,weekday)752 TEST(chrono_test, weekday) {
753   auto loc = get_locale("es_ES.UTF-8");
754   std::locale::global(loc);
755 
756   auto sat = fmt::weekday(6);
757 
758   auto tm = std::tm();
759   tm.tm_wday = static_cast<int>(sat.c_encoding());
760 
761   EXPECT_EQ(fmt::format("{}", sat), "Sat");
762   EXPECT_EQ(fmt::format("{:%a}", sat), "Sat");
763   EXPECT_EQ(fmt::format("{:%A}", sat), "Saturday");
764   EXPECT_EQ(fmt::format("{:%a}", tm), "Sat");
765 
766   if (loc != std::locale::classic()) {
767     auto saturdays = std::vector<std::string>{"sáb", "sá.", "sáb."};
768     EXPECT_THAT(saturdays, Contains(fmt::format(loc, "{:L}", sat)));
769     EXPECT_THAT(saturdays, Contains(fmt::format(loc, "{:%a}", sat)));
770     EXPECT_THAT(saturdays, Contains(fmt::format(loc, "{:%a}", tm)));
771   }
772 }
773 
TEST(chrono_test,cpp20_duration_subsecond_support)774 TEST(chrono_test, cpp20_duration_subsecond_support) {
775   using attoseconds = std::chrono::duration<long long, std::atto>;
776   // Check that 18 digits of subsecond precision are supported.
777   EXPECT_EQ(fmt::format("{:%S}", attoseconds{999999999999999999}),
778             "00.999999999999999999");
779   EXPECT_EQ(fmt::format("{:%S}", attoseconds{673231113420148734}),
780             "00.673231113420148734");
781   EXPECT_EQ(fmt::format("{:%S}", attoseconds{-673231113420148734}),
782             "-00.673231113420148734");
783   EXPECT_EQ(fmt::format("{:%S}", std::chrono::nanoseconds{13420148734}),
784             "13.420148734");
785   EXPECT_EQ(fmt::format("{:%S}", std::chrono::nanoseconds{-13420148734}),
786             "-13.420148734");
787   EXPECT_EQ(fmt::format("{:%S}", std::chrono::milliseconds{1234}), "01.234");
788   // Check subsecond presision modifier.
789   EXPECT_EQ(fmt::format("{:.6%S}", std::chrono::nanoseconds{1234}),
790             "00.000001");
791   EXPECT_EQ(fmt::format("{:.18%S}", std::chrono::nanoseconds{1234}),
792             "00.000001234000000000");
793   EXPECT_EQ(fmt::format("{:.{}%S}", std::chrono::nanoseconds{1234}, 6),
794             "00.000001");
795   EXPECT_EQ(fmt::format("{:.6%S}", std::chrono::milliseconds{1234}),
796             "01.234000");
797   EXPECT_EQ(fmt::format("{:.6%S}", std::chrono::milliseconds{-1234}),
798             "-01.234000");
799   EXPECT_EQ(fmt::format("{:.2%S}", std::chrono::milliseconds{12345}), "12.34");
800   EXPECT_EQ(fmt::format("{:.2%S}", std::chrono::milliseconds{12375}), "12.37");
801   EXPECT_EQ(fmt::format("{:.2%S}", std::chrono::milliseconds{-12375}),
802             "-12.37");
803   EXPECT_EQ(fmt::format("{:.0%S}", std::chrono::milliseconds{12054}), "12");
804   EXPECT_EQ(fmt::format("{:.2%S}", std::chrono::milliseconds{99999}), "39.99");
805   EXPECT_EQ(fmt::format("{:.2%S}", std::chrono::milliseconds{1000}), "01.00");
806   EXPECT_EQ(fmt::format("{:.3%S}", std::chrono::milliseconds{1}), "00.001");
807   EXPECT_EQ(fmt::format("{:.3%S}", std::chrono::seconds{1234}), "34.000");
808   EXPECT_EQ(fmt::format("{:.3%S}", std::chrono::hours{1234}), "00.000");
809   EXPECT_EQ(fmt::format("{:.5%S}", dms(1.234)), "00.00123");
810   EXPECT_EQ(fmt::format("{:.8%S}", dms(1.234)), "00.00123400");
811   {
812     // Check that {:%H:%M:%S} is equivalent to {:%T}.
813     auto dur = std::chrono::milliseconds{3601234};
814     auto formatted_dur = fmt::format("{:%T}", dur);
815     EXPECT_EQ(formatted_dur, "01:00:01.234");
816     EXPECT_EQ(fmt::format("{:%H:%M:%S}", dur), formatted_dur);
817     EXPECT_EQ(fmt::format("{:.6%H:%M:%S}", dur), "01:00:01.234000");
818   }
819   using nanoseconds_dbl = std::chrono::duration<double, std::nano>;
820   EXPECT_EQ(fmt::format("{:%S}", nanoseconds_dbl{-123456789}), "-00.123456789");
821   EXPECT_EQ(fmt::format("{:%S}", nanoseconds_dbl{9123456789}), "09.123456789");
822   // Verify that only the seconds part is extracted and printed.
823   EXPECT_EQ(fmt::format("{:%S}", nanoseconds_dbl{99123456789}), "39.123456789");
824   EXPECT_EQ(fmt::format("{:%S}", nanoseconds_dbl{99123000000}), "39.123000000");
825   {
826     // Now the hour is printed, and we also test if negative doubles work.
827     auto dur = nanoseconds_dbl{-99123456789};
828     auto formatted_dur = fmt::format("{:%T}", dur);
829     EXPECT_EQ(formatted_dur, "-00:01:39.123456789");
830     EXPECT_EQ(fmt::format("{:%H:%M:%S}", dur), formatted_dur);
831     EXPECT_EQ(fmt::format("{:.3%H:%M:%S}", dur), "-00:01:39.123");
832   }
833   // Check that durations with precision greater than std::chrono::seconds have
834   // fixed precision, and print zeros even if there is no fractional part.
835   EXPECT_EQ(fmt::format("{:%S}", std::chrono::microseconds{7000000}),
836             "07.000000");
837   EXPECT_EQ(fmt::format("{:%S}",
838                         std::chrono::duration<long long, std::ratio<1, 3>>(1)),
839             "00.333333");
840   EXPECT_EQ(fmt::format("{:%S}",
841                         std::chrono::duration<long long, std::ratio<1, 7>>(1)),
842             "00.142857");
843 
844   EXPECT_EQ(
845       fmt::format("{:%S}",
846                   std::chrono::duration<signed char, std::ratio<1, 100>>(0x80)),
847       "-01.28");
848 
849   EXPECT_EQ(
850       fmt::format("{:%M:%S}",
851                   std::chrono::duration<short, std::ratio<1, 100>>(0x8000)),
852       "-05:27.68");
853 
854   // Check that floating point seconds with ratio<1,1> are printed.
855   EXPECT_EQ(fmt::format("{:%S}", std::chrono::duration<double>{1.5}),
856             "01.500000");
857   EXPECT_EQ(fmt::format("{:%M:%S}", std::chrono::duration<double>{-61.25}),
858             "-01:01.250000");
859 }
860 
861 #endif  // FMT_STATIC_THOUSANDS_SEPARATOR
862 
863 // Disable the utc_clock test for windows, as the icu.dll used for tzdb
864 // (time zone database) is not shipped with many windows versions.
865 #if FMT_USE_UTC_TIME && !defined(_WIN32)
TEST(chrono_test,utc_clock)866 TEST(chrono_test, utc_clock) {
867   auto t1 = std::chrono::system_clock::now();
868   auto t1_utc = std::chrono::utc_clock::from_sys(t1);
869   EXPECT_EQ(fmt::format("{:%Y-%m-%d %H:%M:%S}", t1),
870             fmt::format("{:%Y-%m-%d %H:%M:%S}", t1_utc));
871 }
872 #endif
873 
TEST(chrono_test,timestamp_ratios)874 TEST(chrono_test, timestamp_ratios) {
875   auto t1 =
876       sys_time<std::chrono::milliseconds>(std::chrono::milliseconds(67890));
877   EXPECT_EQ(fmt::format("{:%M:%S}", t1), "01:07.890");
878 
879   auto t2 = sys_time<std::chrono::minutes>(std::chrono::minutes(7));
880   EXPECT_EQ(fmt::format("{:%M:%S}", t2), "07:00");
881 
882   auto t3 = sys_time<std::chrono::duration<int, std::ratio<9>>>(
883       std::chrono::duration<int, std::ratio<9>>(7));
884   EXPECT_EQ(fmt::format("{:%M:%S}", t3), "01:03");
885 
886   auto t4 = sys_time<std::chrono::duration<int, std::ratio<63>>>(
887       std::chrono::duration<int, std::ratio<63>>(1));
888   EXPECT_EQ(fmt::format("{:%M:%S}", t4), "01:03");
889 
890   if (sizeof(time_t) > 4) {
891     auto tp =
892         sys_time<std::chrono::milliseconds>(std::chrono::seconds(32503680000));
893     EXPECT_EQ(fmt::format("{:%Y-%m-%d}", tp), "3000-01-01");
894   }
895 
896   if (FMT_SAFE_DURATION_CAST) {
897     using years = std::chrono::duration<std::int64_t, std::ratio<31556952>>;
898     auto tp = sys_time<years>(years(std::numeric_limits<std::int64_t>::max()));
899     EXPECT_THROW_MSG((void)fmt::format("{:%Y-%m-%d}", tp), fmt::format_error,
900                      "cannot format duration");
901   }
902 }
903 
TEST(chrono_test,timestamp_sub_seconds)904 TEST(chrono_test, timestamp_sub_seconds) {
905   auto t1 = sys_time<std::chrono::duration<long long, std::ratio<1, 3>>>(
906       std::chrono::duration<long long, std::ratio<1, 3>>(4));
907   EXPECT_EQ(fmt::format("{:%S}", t1), "01.333333");
908 
909   auto t2 = sys_time<std::chrono::duration<double, std::ratio<1, 3>>>(
910       std::chrono::duration<double, std::ratio<1, 3>>(4));
911   EXPECT_EQ(fmt::format("{:%S}", t2), "01.333333");
912 
913   auto t3 = sys_time<std::chrono::seconds>(std::chrono::seconds(2));
914   EXPECT_EQ(fmt::format("{:%S}", t3), "02");
915 
916   auto t4 = sys_time<std::chrono::duration<double>>(
917       std::chrono::duration<double, std::ratio<1, 1>>(9.5));
918   EXPECT_EQ(fmt::format("{:%S}", t4), "09.500000");
919 
920   auto t5 = sys_time<std::chrono::duration<double>>(
921       std::chrono::duration<double, std::ratio<1, 1>>(9));
922   EXPECT_EQ(fmt::format("{:%S}", t5), "09");
923 
924   auto t6 = sys_time<std::chrono::milliseconds>(std::chrono::seconds(1) +
925                                                 std::chrono::milliseconds(120));
926   EXPECT_EQ(fmt::format("{:%S}", t6), "01.120");
927 
928   auto t7 =
929       sys_time<std::chrono::microseconds>(std::chrono::microseconds(1234567));
930   EXPECT_EQ(fmt::format("{:%S}", t7), "01.234567");
931 
932   auto t8 =
933       sys_time<std::chrono::nanoseconds>(std::chrono::nanoseconds(123456789));
934   EXPECT_EQ(fmt::format("{:%S}", t8), "00.123456789");
935 
936   auto t9 = std::chrono::time_point_cast<std::chrono::nanoseconds>(
937       std::chrono::system_clock::now());
938   auto t9_sec = std::chrono::time_point_cast<std::chrono::seconds>(t9);
939   auto t9_sub_sec_part = fmt::format("{0:09}", (t9 - t9_sec).count());
940   EXPECT_EQ(fmt::format("{}.{}", strftime_full_utc(t9_sec), t9_sub_sec_part),
941             fmt::format("{:%Y-%m-%d %H:%M:%S}", t9));
942   EXPECT_EQ(fmt::format("{}.{}", strftime_full_utc(t9_sec), t9_sub_sec_part),
943             fmt::format("{:%Y-%m-%d %T}", t9));
944 
945   auto t10 =
946       sys_time<std::chrono::milliseconds>(std::chrono::milliseconds(2000));
947   EXPECT_EQ(fmt::format("{:%S}", t10), "02.000");
948 
949   auto epoch = sys_time<std::chrono::milliseconds>();
950   auto d = std::chrono::milliseconds(250);
951   EXPECT_EQ(fmt::format("{:%S}", epoch - d), "59.750");
952   EXPECT_EQ(fmt::format("{:%S}", epoch), "00.000");
953   EXPECT_EQ(fmt::format("{:%S}", epoch + d), "00.250");
954 }
955 
TEST(chrono_test,glibc_extensions)956 TEST(chrono_test, glibc_extensions) {
957   EXPECT_THROW_MSG((void)fmt::format(runtime("{:%0}"), std::chrono::seconds()),
958                    fmt::format_error, "invalid format");
959   EXPECT_THROW_MSG((void)fmt::format(runtime("{:%_}"), std::chrono::seconds()),
960                    fmt::format_error, "invalid format");
961   EXPECT_THROW_MSG((void)fmt::format(runtime("{:%-}"), std::chrono::seconds()),
962                    fmt::format_error, "invalid format");
963 
964   {
965     const auto d = std::chrono::hours(1) + std::chrono::minutes(2) +
966                    std::chrono::seconds(3);
967 
968     EXPECT_EQ(fmt::format("{:%I,%H,%M,%S}", d), "01,01,02,03");
969     EXPECT_EQ(fmt::format("{:%_I,%_H,%_M,%_S}", d), " 1, 1, 2, 3");
970     EXPECT_EQ(fmt::format("{:%-I,%-H,%-M,%-S}", d), "1,1,2,3");
971     EXPECT_EQ(fmt::format("{:%-I,%H,%M,%S}", d), "1,01,02,03");
972 
973     EXPECT_EQ(fmt::format("{:%OI,%OH,%OM,%OS}", d), "01,01,02,03");
974     EXPECT_EQ(fmt::format("{:%_OI,%_OH,%_OM,%_OS}", d), " 1, 1, 2, 3");
975     EXPECT_EQ(fmt::format("{:%-OI,%-OH,%-OM,%-OS}", d), "1,1,2,3");
976   }
977 
978   {
979     const auto tm = make_tm(1970, 1, 1, 1, 2, 3);
980     EXPECT_EQ(fmt::format("{:%I,%H,%M,%S}", tm), "01,01,02,03");
981     EXPECT_EQ(fmt::format("{:%_I,%_H,%_M,%_S}", tm), " 1, 1, 2, 3");
982     EXPECT_EQ(fmt::format("{:%-I,%-H,%-M,%-S}", tm), "1,1,2,3");
983 
984     EXPECT_EQ(fmt::format("{:%OI,%OH,%OM,%OS}", tm), "01,01,02,03");
985     EXPECT_EQ(fmt::format("{:%_OI,%_OH,%_OM,%_OS}", tm), " 1, 1, 2, 3");
986     EXPECT_EQ(fmt::format("{:%-OI,%-OH,%-OM,%-OS}", tm), "1,1,2,3");
987   }
988 
989   {
990     const auto d = std::chrono::seconds(3) + std::chrono::milliseconds(140);
991     EXPECT_EQ(fmt::format("{:%S}", d), "03.140");
992     EXPECT_EQ(fmt::format("{:%_S}", d), " 3.140");
993     EXPECT_EQ(fmt::format("{:%-S}", d), "3.140");
994   }
995 
996   {
997     auto d = std::chrono::duration<double>(3.14);
998     EXPECT_EQ(fmt::format("{:%S}", d), "03.140000");
999     EXPECT_EQ(fmt::format("{:%_S}", d), " 3.140000");
1000     EXPECT_EQ(fmt::format("{:%-S}", d), "3.140000");
1001   }
1002 
1003   {
1004     auto t = std::tm();
1005     t.tm_yday = 7;
1006     EXPECT_EQ(fmt::format("{:%U,%W,%V}", t), "02,01,01");
1007     EXPECT_EQ(fmt::format("{:%_U,%_W,%_V}", t), " 2, 1, 1");
1008     EXPECT_EQ(fmt::format("{:%-U,%-W,%-V}", t), "2,1,1");
1009 
1010     EXPECT_EQ(fmt::format("{:%j}", t), "008");
1011     EXPECT_EQ(fmt::format("{:%_j}", t), "  8");
1012     EXPECT_EQ(fmt::format("{:%-j}", t), "8");
1013   }
1014 
1015   {
1016     auto t = std::tm();
1017     t.tm_mday = 7;
1018     EXPECT_EQ(fmt::format("{:%d}", t), "07");
1019     EXPECT_EQ(fmt::format("{:%_d}", t), " 7");
1020     EXPECT_EQ(fmt::format("{:%-d}", t), "7");
1021 
1022     EXPECT_EQ(fmt::format("{:%e}", t), " 7");
1023   }
1024 
1025   {
1026     auto t = std::tm();
1027     t.tm_year = 7 - 1900;
1028     EXPECT_EQ(fmt::format("{:%Y}", t), "0007");
1029     EXPECT_EQ(fmt::format("{:%_Y}", t), "   7");
1030     EXPECT_EQ(fmt::format("{:%-Y}", t), "7");
1031   }
1032 
1033   {
1034     auto t = std::tm();
1035     t.tm_year = -5 - 1900;
1036     EXPECT_EQ(fmt::format( "{:%Y}", t), "-005");
1037     EXPECT_EQ(fmt::format("{:%_Y}", t), "  -5");
1038     EXPECT_EQ(fmt::format("{:%-Y}", t), "-5");
1039   }
1040 
1041   {
1042     auto t = std::tm();
1043     t.tm_mon = 7 - 1;
1044     EXPECT_EQ(fmt::format("{:%m}", t), "07");
1045     EXPECT_EQ(fmt::format("{:%_m}", t), " 7");
1046     EXPECT_EQ(fmt::format("{:%-m}", t), "7");
1047   }
1048 
1049 
1050 }
1051 
TEST(chrono_test,out_of_range)1052 TEST(chrono_test, out_of_range) {
1053   auto d = std::chrono::duration<unsigned long, std::giga>(538976288);
1054   EXPECT_THROW((void)fmt::format("{:%j}", d), fmt::format_error);
1055 }
1056 
TEST(chrono_test,year_month_day)1057 TEST(chrono_test, year_month_day) {
1058   auto loc = get_locale("es_ES.UTF-8");
1059   std::locale::global(loc);
1060 
1061   auto year = fmt::year(2024);
1062   auto month = fmt::month(1);
1063   auto day = fmt::day(1);
1064   auto ymd = fmt::year_month_day(year, month, day);
1065 
1066   EXPECT_EQ(fmt::format("{}", year), "2024");
1067   EXPECT_EQ(fmt::format("{:%Y}", year), "2024");
1068   EXPECT_EQ(fmt::format("{:%y}", year), "24");
1069 
1070   EXPECT_EQ(fmt::format("{}", month), "Jan");
1071   EXPECT_EQ(fmt::format("{:%m}", month), "01");
1072   EXPECT_EQ(fmt::format("{:%b}", month), "Jan");
1073   EXPECT_EQ(fmt::format("{:%B}", month), "January");
1074 
1075   EXPECT_EQ(fmt::format("{}", day), "01");
1076   EXPECT_EQ(fmt::format("{:%d}", day), "01");
1077 
1078   EXPECT_EQ(fmt::format("{}", ymd), "2024-01-01");
1079   EXPECT_EQ(fmt::format("{:%Y-%m-%d}", ymd), "2024-01-01");
1080   EXPECT_EQ(fmt::format("{:%Y-%b-%d}", ymd), "2024-Jan-01");
1081   EXPECT_EQ(fmt::format("{:%Y-%B-%d}", ymd), "2024-January-01");
1082 
1083   if (loc != std::locale::classic()) {
1084     auto months = std::vector<std::string>{"ene.", "ene"};
1085     EXPECT_THAT(months, Contains(fmt::format(loc, "{:L}", month)));
1086     EXPECT_THAT(months, Contains(fmt::format(loc, "{:%b}", month)));
1087   }
1088 }
1089