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