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
make_tm()17 std::tm make_tm() {
18 auto time = std::tm();
19 time.tm_mday = 1;
20 return time;
21 }
22
make_hour(int h)23 std::tm make_hour(int h) {
24 auto time = make_tm();
25 time.tm_hour = h;
26 return time;
27 }
28
make_minute(int m)29 std::tm make_minute(int m) {
30 auto time = make_tm();
31 time.tm_min = m;
32 return time;
33 }
34
make_second(int s)35 std::tm make_second(int s) {
36 auto time = make_tm();
37 time.tm_sec = s;
38 return time;
39 }
40
format_tm(const std::tm & time,const char * spec,const std::locale & loc)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
TEST(TimeTest,Format)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
TEST(TimeTest,GrowBuffer)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(nullptr);
64 fmt::format(s, *std::localtime(&t));
65 }
66
TEST(TimeTest,FormatToEmptyContainer)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
TEST(TimeTest,EmptyResult)75 TEST(TimeTest, EmptyResult) { EXPECT_EQ("", fmt::format("{}", std::tm())); }
76
EqualTime(const std::tm & lhs,const std::tm & rhs)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
TEST(TimeTest,LocalTime)85 TEST(TimeTest, LocalTime) {
86 std::time_t t = std::time(nullptr);
87 std::tm tm = *std::localtime(&t);
88 EXPECT_TRUE(EqualTime(tm, fmt::localtime(t)));
89 }
90
TEST(TimeTest,GMTime)91 TEST(TimeTest, GMTime) {
92 std::time_t t = std::time(nullptr);
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
TEST(ChronoTest,FormatDefault)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
TEST(ChronoTest,Align)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
TEST(ChronoTest,FormatSpecs)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
TEST(ChronoTest,InvalidSpecs)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
TEST(ChronoTest,Locale)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
TEST(ChronoTest,FormatDefaultFP)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
TEST(ChronoTest,FormatPrecision)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
TEST(ChronoTest,FormatFullSpecs)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
TEST(ChronoTest,FormatSimpleQq)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
TEST(ChronoTest,FormatPrecisionQq)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
TEST(ChronoTest,FormatFullSpecsQq)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
TEST(ChronoTest,InvalidWidthId)299 TEST(ChronoTest, InvalidWidthId) {
300 EXPECT_THROW(fmt::format("{:{o}", std::chrono::seconds(0)),
301 fmt::format_error);
302 }
303
TEST(ChronoTest,InvalidColons)304 TEST(ChronoTest, InvalidColons) {
305 EXPECT_THROW(fmt::format("{0}=:{0::", std::chrono::seconds(0)),
306 fmt::format_error);
307 }
308
TEST(ChronoTest,NegativeDurations)309 TEST(ChronoTest, NegativeDurations) {
310 EXPECT_EQ("-12345", fmt::format("{:%Q}", std::chrono::seconds(-12345)));
311 EXPECT_EQ("-03:25:45",
312 fmt::format("{:%H:%M:%S}", std::chrono::seconds(-12345)));
313 EXPECT_EQ("-00:01",
314 fmt::format("{:%M:%S}", std::chrono::duration<double>(-1)));
315 EXPECT_EQ("s", fmt::format("{:%q}", std::chrono::seconds(-12345)));
316 EXPECT_EQ("-00.127",
317 fmt::format("{:%S}",
318 std::chrono::duration<signed char, std::milli>{-127}));
319 auto min = std::numeric_limits<int>::min();
320 EXPECT_EQ(fmt::format("{}", min),
321 fmt::format("{:%Q}", std::chrono::duration<int>(min)));
322 }
323
TEST(ChronoTest,SpecialDurations)324 TEST(ChronoTest, SpecialDurations) {
325 EXPECT_EQ(
326 "40.",
327 fmt::format("{:%S}", std::chrono::duration<double>(1e20)).substr(0, 3));
328 auto nan = std::numeric_limits<double>::quiet_NaN();
329 EXPECT_EQ(
330 "nan nan nan nan nan:nan nan",
331 fmt::format("{:%I %H %M %S %R %r}", std::chrono::duration<double>(nan)));
332 fmt::format("{:%S}",
333 std::chrono::duration<float, std::atto>(1.79400457e+31f));
334 EXPECT_EQ(fmt::format("{}", std::chrono::duration<float, std::exa>(1)),
335 "1Es");
336 EXPECT_EQ(fmt::format("{}", std::chrono::duration<float, std::atto>(1)),
337 "1as");
338 EXPECT_EQ(fmt::format("{:%R}", std::chrono::duration<char, std::mega>{2}),
339 "03:33");
340 EXPECT_EQ(fmt::format("{:%T}", std::chrono::duration<char, std::mega>{2}),
341 "03:33:20");
342 }
343
344 #endif // FMT_STATIC_THOUSANDS_SEPARATOR
345