Mercurial > minori

comparison dep/fmt/test/printf-test.cc @ 343:1faa72660932

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
*: transfer back to cmake from autotools autotools just made lots of things more complicated than they should have and many things broke (i.e. translations)
author Paper <paper@paper.us.eu.org>
date Thu, 20 Jun 2024 05:56:06 -0400
parents
children
comparison
equal deleted inserted replaced
342:adb79bdde329 343:1faa72660932
1 // Formatting library for C++ - printf 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/printf.h"
9
10 #include <cctype>
11 #include <climits>
12 #include <cstring>
13
14 #include "fmt/xchar.h"
15 #include "gtest-extra.h"
16 #include "util.h"
17
18 using fmt::format;
19 using fmt::format_error;
20 using fmt::detail::max_value;
21
22 const unsigned big_num = INT_MAX + 1u;
23
24 // Makes format string argument positional.
25 static std::string make_positional(fmt::string_view format) {
26 std::string s(format.data(), format.size());
27 s.replace(s.find('%'), 1, "%1$");
28 return s;
29 }
30
31 static std::wstring make_positional(fmt::basic_string_view<wchar_t> format) {
32 std::wstring s(format.data(), format.size());
33 s.replace(s.find(L'%'), 1, L"%1$");
34 return s;
35 }
36
37 // A wrapper around fmt::sprintf to workaround bogus warnings about invalid
38 // format strings in MSVC.
39 template <typename... Args>
40 std::string test_sprintf(fmt::string_view format, const Args&... args) {
41 return fmt::sprintf(format, args...);
42 }
43 template <typename... Args>
44 std::wstring test_sprintf(fmt::basic_string_view<wchar_t> format,
45 const Args&... args) {
46 return fmt::sprintf(format, args...);
47 }
48
49 #define EXPECT_PRINTF(expected_output, format, arg) \
50 EXPECT_EQ(expected_output, test_sprintf(format, arg)) \
51 << "format: " << format; \
52 EXPECT_EQ(expected_output, fmt::sprintf(make_positional(format), arg))
53
54 TEST(printf_test, no_args) {
55 EXPECT_EQ("test", test_sprintf("test"));
56 EXPECT_EQ(L"test", fmt::sprintf(L"test"));
57 }
58
59 TEST(printf_test, escape) {
60 EXPECT_EQ("%", test_sprintf("%%"));
61 EXPECT_EQ("before %", test_sprintf("before %%"));
62 EXPECT_EQ("% after", test_sprintf("%% after"));
63 EXPECT_EQ("before % after", test_sprintf("before %% after"));
64 EXPECT_EQ("%s", test_sprintf("%%s"));
65 EXPECT_EQ(L"%", fmt::sprintf(L"%%"));
66 EXPECT_EQ(L"before %", fmt::sprintf(L"before %%"));
67 EXPECT_EQ(L"% after", fmt::sprintf(L"%% after"));
68 EXPECT_EQ(L"before % after", fmt::sprintf(L"before %% after"));
69 EXPECT_EQ(L"%s", fmt::sprintf(L"%%s"));
70 }
71
72 TEST(printf_test, positional_args) {
73 EXPECT_EQ("42", test_sprintf("%1$d", 42));
74 EXPECT_EQ("before 42", test_sprintf("before %1$d", 42));
75 EXPECT_EQ("42 after", test_sprintf("%1$d after", 42));
76 EXPECT_EQ("before 42 after", test_sprintf("before %1$d after", 42));
77 EXPECT_EQ("answer = 42", test_sprintf("%1$s = %2$d", "answer", 42));
78 EXPECT_EQ("42 is the answer", test_sprintf("%2$d is the %1$s", "answer", 42));
79 EXPECT_EQ("abracadabra", test_sprintf("%1$s%2$s%1$s", "abra", "cad"));
80 }
81
82 TEST(printf_test, automatic_arg_indexing) {
83 EXPECT_EQ("abc", test_sprintf("%c%c%c", 'a', 'b', 'c'));
84 }
85
86 TEST(printf_test, number_is_too_big_in_arg_index) {
87 EXPECT_THROW_MSG(test_sprintf(format("%{}$", big_num)), format_error,
88 "argument not found");
89 EXPECT_THROW_MSG(test_sprintf(format("%{}$d", big_num)), format_error,
90 "argument not found");
91 }
92
93 TEST(printf_test, switch_arg_indexing) {
94 EXPECT_THROW_MSG(test_sprintf("%1$d%", 1, 2), format_error,
95 "cannot switch from manual to automatic argument indexing");
96 EXPECT_THROW_MSG(test_sprintf(format("%1$d%{}d", big_num), 1, 2),
97 format_error, "number is too big");
98 EXPECT_THROW_MSG(test_sprintf("%1$d%d", 1, 2), format_error,
99 "cannot switch from manual to automatic argument indexing");
100
101 EXPECT_THROW_MSG(test_sprintf("%d%1$", 1, 2), format_error,
102 "cannot switch from automatic to manual argument indexing");
103 EXPECT_THROW_MSG(test_sprintf(format("%d%{}$d", big_num), 1, 2), format_error,
104 "cannot switch from automatic to manual argument indexing");
105 EXPECT_THROW_MSG(test_sprintf("%d%1$d", 1, 2), format_error,
106 "cannot switch from automatic to manual argument indexing");
107
108 // Indexing errors override width errors.
109 EXPECT_THROW_MSG(test_sprintf(format("%d%1${}d", big_num), 1, 2),
110 format_error, "number is too big");
111 EXPECT_THROW_MSG(test_sprintf(format("%1$d%{}d", big_num), 1, 2),
112 format_error, "number is too big");
113 }
114
115 TEST(printf_test, invalid_arg_index) {
116 EXPECT_THROW_MSG(test_sprintf("%0$d", 42), format_error,
117 "argument not found");
118 EXPECT_THROW_MSG(test_sprintf("%2$d", 42), format_error,
119 "argument not found");
120 EXPECT_THROW_MSG(test_sprintf(format("%{}$d", INT_MAX), 42), format_error,
121 "argument not found");
122
123 EXPECT_THROW_MSG(test_sprintf("%2$", 42), format_error, "argument not found");
124 EXPECT_THROW_MSG(test_sprintf(format("%{}$d", big_num), 42), format_error,
125 "argument not found");
126 }
127
128 TEST(printf_test, default_align_right) {
129 EXPECT_PRINTF(" 42", "%5d", 42);
130 EXPECT_PRINTF(" abc", "%5s", "abc");
131 }
132
133 TEST(printf_test, zero_flag) {
134 EXPECT_PRINTF("00042", "%05d", 42);
135 EXPECT_PRINTF("-0042", "%05d", -42);
136
137 EXPECT_PRINTF("00042", "%05d", 42);
138 EXPECT_PRINTF("-0042", "%05d", -42);
139 EXPECT_PRINTF("-004.2", "%06g", -4.2);
140
141 EXPECT_PRINTF("+00042", "%00+6d", 42);
142
143 EXPECT_PRINTF(" 42", "%05.d", 42);
144 EXPECT_PRINTF(" 0042", "%05.4d", 42);
145
146 // '0' flag is ignored for non-numeric types.
147 EXPECT_PRINTF(" x", "%05c", 'x');
148 }
149
150 TEST(printf_test, plus_flag) {
151 EXPECT_PRINTF("+42", "%+d", 42);
152 EXPECT_PRINTF("-42", "%+d", -42);
153 EXPECT_PRINTF("+0042", "%+05d", 42);
154 EXPECT_PRINTF("+0042", "%0++5d", 42);
155
156 // '+' flag is ignored for non-numeric types.
157 EXPECT_PRINTF("x", "%+c", 'x');
158
159 // '+' flag wins over space flag
160 EXPECT_PRINTF("+42", "%+ d", 42);
161 EXPECT_PRINTF("-42", "%+ d", -42);
162 EXPECT_PRINTF("+42", "% +d", 42);
163 EXPECT_PRINTF("-42", "% +d", -42);
164 EXPECT_PRINTF("+0042", "% +05d", 42);
165 EXPECT_PRINTF("+0042", "%0+ 5d", 42);
166
167 // '+' flag and space flag are both ignored for non-numeric types.
168 EXPECT_PRINTF("x", "%+ c", 'x');
169 EXPECT_PRINTF("x", "% +c", 'x');
170 }
171
172 TEST(printf_test, minus_flag) {
173 EXPECT_PRINTF("abc ", "%-5s", "abc");
174 EXPECT_PRINTF("abc ", "%0--5s", "abc");
175
176 EXPECT_PRINTF("7 ", "%-5d", 7);
177 EXPECT_PRINTF("97 ", "%-5hhi", 'a');
178 EXPECT_PRINTF("a ", "%-5c", 'a');
179
180 // '0' flag is ignored if '-' flag is given
181 EXPECT_PRINTF("7 ", "%-05d", 7);
182 EXPECT_PRINTF("7 ", "%0-5d", 7);
183 EXPECT_PRINTF("a ", "%-05c", 'a');
184 EXPECT_PRINTF("a ", "%0-5c", 'a');
185 EXPECT_PRINTF("97 ", "%-05hhi", 'a');
186 EXPECT_PRINTF("97 ", "%0-5hhi", 'a');
187
188 // '-' and space flag don't interfere
189 EXPECT_PRINTF(" 42", "%- d", 42);
190 }
191
192 TEST(printf_test, space_flag) {
193 EXPECT_PRINTF(" 42", "% d", 42);
194 EXPECT_PRINTF("-42", "% d", -42);
195 EXPECT_PRINTF(" 0042", "% 05d", 42);
196 EXPECT_PRINTF(" 0042", "%0 5d", 42);
197
198 // ' ' flag is ignored for non-numeric types.
199 EXPECT_PRINTF("x", "% c", 'x');
200 }
201
202 TEST(printf_test, hash_flag) {
203 EXPECT_PRINTF("042", "%#o", 042);
204 EXPECT_PRINTF(fmt::format("0{:o}", static_cast<unsigned>(-042)), "%#o", -042);
205 EXPECT_PRINTF("0", "%#o", 0);
206
207 EXPECT_PRINTF("0x42", "%#x", 0x42);
208 EXPECT_PRINTF("0X42", "%#X", 0x42);
209 EXPECT_PRINTF(fmt::format("0x{:x}", static_cast<unsigned>(-0x42)), "%#x",
210 -0x42);
211 EXPECT_PRINTF("0", "%#x", 0);
212
213 EXPECT_PRINTF("0x0042", "%#06x", 0x42);
214 EXPECT_PRINTF("0x0042", "%0##6x", 0x42);
215
216 EXPECT_PRINTF("-42.000000", "%#f", -42.0);
217 EXPECT_PRINTF("-42.000000", "%#F", -42.0);
218
219 char buffer[256];
220 safe_sprintf(buffer, "%#e", -42.0);
221 EXPECT_PRINTF(buffer, "%#e", -42.0);
222 safe_sprintf(buffer, "%#E", -42.0);
223 EXPECT_PRINTF(buffer, "%#E", -42.0);
224
225 EXPECT_PRINTF("-42.0000", "%#g", -42.0);
226 EXPECT_PRINTF("-42.0000", "%#G", -42.0);
227
228 EXPECT_PRINTF("0x1.p+4", "%#a", 16.0);
229 EXPECT_PRINTF("0X1.P+4", "%#A", 16.0);
230
231 // '#' flag is ignored for non-numeric types.
232 EXPECT_PRINTF("x", "%#c", 'x');
233 }
234
235 TEST(printf_test, width) {
236 EXPECT_PRINTF(" abc", "%5s", "abc");
237
238 // Width cannot be specified twice.
239 EXPECT_THROW_MSG(test_sprintf("%5-5d", 42), format_error,
240 "invalid format specifier");
241
242 EXPECT_THROW_MSG(test_sprintf(format("%{}d", big_num), 42), format_error,
243 "number is too big");
244 EXPECT_THROW_MSG(test_sprintf(format("%1${}d", big_num), 42), format_error,
245 "number is too big");
246 }
247
248 TEST(printf_test, dynamic_width) {
249 EXPECT_EQ(" 42", test_sprintf("%*d", 5, 42));
250 EXPECT_EQ("42 ", test_sprintf("%*d", -5, 42));
251 EXPECT_THROW_MSG(test_sprintf("%*d", 5.0, 42), format_error,
252 "width is not integer");
253 EXPECT_THROW_MSG(test_sprintf("%*d"), format_error, "argument not found");
254 EXPECT_THROW_MSG(test_sprintf("%*d", big_num, 42), format_error,
255 "number is too big");
256 }
257
258 TEST(printf_test, int_precision) {
259 EXPECT_PRINTF("00042", "%.5d", 42);
260 EXPECT_PRINTF("-00042", "%.5d", -42);
261 EXPECT_PRINTF("00042", "%.5x", 0x42);
262 EXPECT_PRINTF("0x00042", "%#.5x", 0x42);
263 EXPECT_PRINTF("00042", "%.5o", 042);
264 EXPECT_PRINTF("00042", "%#.5o", 042);
265
266 EXPECT_PRINTF(" 00042", "%7.5d", 42);
267 EXPECT_PRINTF(" 00042", "%7.5x", 0x42);
268 EXPECT_PRINTF(" 0x00042", "%#10.5x", 0x42);
269 EXPECT_PRINTF(" 00042", "%7.5o", 042);
270 EXPECT_PRINTF(" 00042", "%#10.5o", 042);
271
272 EXPECT_PRINTF("00042 ", "%-7.5d", 42);
273 EXPECT_PRINTF("00042 ", "%-7.5x", 0x42);
274 EXPECT_PRINTF("0x00042 ", "%-#10.5x", 0x42);
275 EXPECT_PRINTF("00042 ", "%-7.5o", 042);
276 EXPECT_PRINTF("00042 ", "%-#10.5o", 042);
277 }
278
279 TEST(printf_test, float_precision) {
280 char buffer[256];
281 safe_sprintf(buffer, "%.3e", 1234.5678);
282 EXPECT_PRINTF(buffer, "%.3e", 1234.5678);
283 EXPECT_PRINTF("1234.568", "%.3f", 1234.5678);
284 EXPECT_PRINTF("1.23e+03", "%.3g", 1234.5678);
285 safe_sprintf(buffer, "%.3a", 1234.5678);
286 EXPECT_PRINTF(buffer, "%.3a", 1234.5678);
287 }
288
289 TEST(printf_test, string_precision) {
290 char test[] = {'H', 'e', 'l', 'l', 'o'};
291 EXPECT_EQ(fmt::sprintf("%.4s", test), "Hell");
292 }
293
294 TEST(printf_test, ignore_precision_for_non_numeric_arg) {
295 EXPECT_PRINTF("abc", "%.5s", "abc");
296 }
297
298 TEST(printf_test, dynamic_precision) {
299 EXPECT_EQ("00042", test_sprintf("%.*d", 5, 42));
300 EXPECT_EQ("42", test_sprintf("%.*d", -5, 42));
301 EXPECT_THROW_MSG(test_sprintf("%.*d", 5.0, 42), format_error,
302 "precision is not integer");
303 EXPECT_THROW_MSG(test_sprintf("%.*d"), format_error, "argument not found");
304 EXPECT_THROW_MSG(test_sprintf("%.*d", big_num, 42), format_error,
305 "number is too big");
306 if (sizeof(long long) != sizeof(int)) {
307 long long prec = static_cast<long long>(INT_MIN) - 1;
308 EXPECT_THROW_MSG(test_sprintf("%.*d", prec, 42), format_error,
309 "number is too big");
310 }
311 }
312
313 template <typename T> struct make_signed { using type = T; };
314
315 #define SPECIALIZE_MAKE_SIGNED(T, S) \
316 template <> struct make_signed<T> { using type = S; }
317
318 SPECIALIZE_MAKE_SIGNED(char, signed char);
319 SPECIALIZE_MAKE_SIGNED(unsigned char, signed char);
320 SPECIALIZE_MAKE_SIGNED(unsigned short, short);
321 SPECIALIZE_MAKE_SIGNED(unsigned, int);
322 SPECIALIZE_MAKE_SIGNED(unsigned long, long);
323 SPECIALIZE_MAKE_SIGNED(unsigned long long, long long);
324
325 // Test length format specifier ``length_spec``.
326 template <typename T, typename U>
327 void test_length(const char* length_spec, U value) {
328 long long signed_value = 0;
329 unsigned long long unsigned_value = 0;
330 // Apply integer promotion to the argument.
331 unsigned long long max = max_value<U>();
332 using fmt::detail::const_check;
333 if (const_check(max <= static_cast<unsigned>(max_value<int>()))) {
334 signed_value = static_cast<int>(value);
335 unsigned_value = static_cast<unsigned long long>(value);
336 } else if (const_check(max <= max_value<unsigned>())) {
337 signed_value = static_cast<unsigned>(value);
338 unsigned_value = static_cast<unsigned long long>(value);
339 }
340 if (sizeof(U) <= sizeof(int) && sizeof(int) < sizeof(T)) {
341 signed_value = static_cast<long long>(value);
342 unsigned_value = static_cast<unsigned long long>(
343 static_cast<typename std::make_unsigned<unsigned>::type>(value));
344 } else {
345 signed_value = static_cast<typename make_signed<T>::type>(value);
346 unsigned_value = static_cast<typename std::make_unsigned<T>::type>(value);
347 }
348 std::ostringstream os;
349 os << signed_value;
350 EXPECT_PRINTF(os.str(), fmt::format("%{}d", length_spec), value);
351 EXPECT_PRINTF(os.str(), fmt::format("%{}i", length_spec), value);
352 os.str("");
353 os << unsigned_value;
354 EXPECT_PRINTF(os.str(), fmt::format("%{}u", length_spec), value);
355 os.str("");
356 os << std::oct << unsigned_value;
357 EXPECT_PRINTF(os.str(), fmt::format("%{}o", length_spec), value);
358 os.str("");
359 os << std::hex << unsigned_value;
360 EXPECT_PRINTF(os.str(), fmt::format("%{}x", length_spec), value);
361 os.str("");
362 os << std::hex << std::uppercase << unsigned_value;
363 EXPECT_PRINTF(os.str(), fmt::format("%{}X", length_spec), value);
364 }
365
366 template <typename T> void test_length(const char* length_spec) {
367 T min = std::numeric_limits<T>::min(), max = max_value<T>();
368 test_length<T>(length_spec, 42);
369 test_length<T>(length_spec, -42);
370 test_length<T>(length_spec, min);
371 test_length<T>(length_spec, max);
372 long long long_long_min = std::numeric_limits<long long>::min();
373 if (static_cast<long long>(min) > long_long_min)
374 test_length<T>(length_spec, static_cast<long long>(min) - 1);
375 unsigned long long long_long_max = max_value<long long>();
376 if (static_cast<unsigned long long>(max) < long_long_max)
377 test_length<T>(length_spec, static_cast<long long>(max) + 1);
378 test_length<T>(length_spec, std::numeric_limits<short>::min());
379 test_length<T>(length_spec, max_value<unsigned short>());
380 test_length<T>(length_spec, std::numeric_limits<int>::min());
381 test_length<T>(length_spec, max_value<int>());
382 test_length<T>(length_spec, std::numeric_limits<unsigned>::min());
383 test_length<T>(length_spec, max_value<unsigned>());
384 test_length<T>(length_spec, std::numeric_limits<long long>::min());
385 test_length<T>(length_spec, max_value<long long>());
386 test_length<T>(length_spec, std::numeric_limits<unsigned long long>::min());
387 test_length<T>(length_spec, max_value<unsigned long long>());
388 }
389
390 TEST(printf_test, length) {
391 test_length<char>("hh");
392 test_length<signed char>("hh");
393 test_length<unsigned char>("hh");
394 test_length<short>("h");
395 test_length<unsigned short>("h");
396 test_length<long>("l");
397 test_length<unsigned long>("l");
398 test_length<long long>("ll");
399 test_length<unsigned long long>("ll");
400 test_length<intmax_t>("j");
401 test_length<size_t>("z");
402 test_length<std::ptrdiff_t>("t");
403 long double max = max_value<long double>();
404 EXPECT_PRINTF(fmt::format("{:.6}", max), "%g", max);
405 EXPECT_PRINTF(fmt::format("{:.6}", max), "%Lg", max);
406 }
407
408 TEST(printf_test, bool) { EXPECT_PRINTF("1", "%d", true); }
409
410 TEST(printf_test, int) {
411 EXPECT_PRINTF("-42", "%d", -42);
412 EXPECT_PRINTF("-42", "%i", -42);
413 unsigned u = 0 - 42u;
414 EXPECT_PRINTF(fmt::format("{}", u), "%u", -42);
415 EXPECT_PRINTF(fmt::format("{:o}", u), "%o", -42);
416 EXPECT_PRINTF(fmt::format("{:x}", u), "%x", -42);
417 EXPECT_PRINTF(fmt::format("{:X}", u), "%X", -42);
418 }
419
420 TEST(printf_test, long_long) {
421 // fmt::printf allows passing long long arguments to %d without length
422 // specifiers.
423 long long max = max_value<long long>();
424 EXPECT_PRINTF(fmt::format("{}", max), "%d", max);
425 }
426
427 TEST(printf_test, float) {
428 EXPECT_PRINTF("392.650000", "%f", 392.65);
429 EXPECT_PRINTF("392.65", "%.2f", 392.65);
430 EXPECT_PRINTF("392.6", "%.1f", 392.65);
431 EXPECT_PRINTF("393", "%.f", 392.65);
432 EXPECT_PRINTF("392.650000", "%F", 392.65);
433 char buffer[256];
434 safe_sprintf(buffer, "%e", 392.65);
435 EXPECT_PRINTF(buffer, "%e", 392.65);
436 safe_sprintf(buffer, "%E", 392.65);
437 EXPECT_PRINTF(buffer, "%E", 392.65);
438 EXPECT_PRINTF("392.65", "%g", 392.65);
439 EXPECT_PRINTF("392.65", "%G", 392.65);
440 EXPECT_PRINTF("392", "%g", 392.0);
441 EXPECT_PRINTF("392", "%G", 392.0);
442 EXPECT_PRINTF("4.56e-07", "%g", 0.000000456);
443 safe_sprintf(buffer, "%a", -392.65);
444 EXPECT_EQ(buffer, format("{:a}", -392.65));
445 safe_sprintf(buffer, "%A", -392.65);
446 EXPECT_EQ(buffer, format("{:A}", -392.65));
447 }
448
449 TEST(printf_test, inf) {
450 double inf = std::numeric_limits<double>::infinity();
451 for (const char* type = "fega"; *type; ++type) {
452 EXPECT_PRINTF("inf", fmt::format("%{}", *type), inf);
453 char upper = static_cast<char>(std::toupper(*type));
454 EXPECT_PRINTF("INF", fmt::format("%{}", upper), inf);
455 }
456 }
457
458 TEST(printf_test, char) {
459 EXPECT_PRINTF("x", "%c", 'x');
460 int max = max_value<int>();
461 EXPECT_PRINTF(fmt::format("{}", static_cast<char>(max)), "%c", max);
462 // EXPECT_PRINTF("x", "%lc", L'x');
463 EXPECT_PRINTF(L"x", L"%c", L'x');
464 EXPECT_PRINTF(fmt::format(L"{}", static_cast<wchar_t>(max)), L"%c", max);
465 }
466
467 TEST(printf_test, string) {
468 EXPECT_PRINTF("abc", "%s", "abc");
469 const char* null_str = nullptr;
470 EXPECT_PRINTF("(null)", "%s", null_str);
471 EXPECT_PRINTF(" (null)", "%10s", null_str);
472 EXPECT_PRINTF(L"abc", L"%s", L"abc");
473 const wchar_t* null_wstr = nullptr;
474 EXPECT_PRINTF(L"(null)", L"%s", null_wstr);
475 EXPECT_PRINTF(L" (null)", L"%10s", null_wstr);
476 }
477
478 TEST(printf_test, pointer) {
479 int n;
480 void* p = &n;
481 EXPECT_PRINTF(fmt::format("{}", p), "%p", p);
482 p = nullptr;
483 EXPECT_PRINTF("(nil)", "%p", p);
484 EXPECT_PRINTF(" (nil)", "%10p", p);
485 const char* s = "test";
486 EXPECT_PRINTF(fmt::format("{:p}", s), "%p", s);
487 const char* null_str = nullptr;
488 EXPECT_PRINTF("(nil)", "%p", null_str);
489
490 p = &n;
491 EXPECT_PRINTF(fmt::format(L"{}", p), L"%p", p);
492 p = nullptr;
493 EXPECT_PRINTF(L"(nil)", L"%p", p);
494 EXPECT_PRINTF(L" (nil)", L"%10p", p);
495 const wchar_t* w = L"test";
496 EXPECT_PRINTF(fmt::format(L"{:p}", w), L"%p", w);
497 const wchar_t* null_wstr = nullptr;
498 EXPECT_PRINTF(L"(nil)", L"%p", null_wstr);
499 }
500
501 enum test_enum { answer = 42 };
502 auto format_as(test_enum e) -> int { return e; }
503
504 TEST(printf_test, enum) {
505 EXPECT_PRINTF("42", "%d", answer);
506 volatile test_enum volatile_enum = answer;
507 EXPECT_PRINTF("42", "%d", volatile_enum);
508 }
509
510 #if FMT_USE_FCNTL
511 TEST(printf_test, examples) {
512 const char* weekday = "Thursday";
513 const char* month = "August";
514 int day = 21;
515 EXPECT_WRITE(stdout, fmt::printf("%1$s, %3$d %2$s", weekday, month, day),
516 "Thursday, 21 August");
517 }
518
519 TEST(printf_test, printf_error) {
520 fmt::file read_end, write_end;
521 fmt::file::pipe(read_end, write_end);
522 int result = fmt::fprintf(read_end.fdopen("r").get(), "test");
523 EXPECT_LT(result, 0);
524 }
525 #endif
526
527 TEST(printf_test, wide_string) {
528 EXPECT_EQ(L"abc", fmt::sprintf(L"%s", L"abc"));
529 }
530
531 TEST(printf_test, vprintf) {
532 int n = 42;
533 auto store = fmt::format_arg_store<fmt::printf_context, int>(n);
534 auto args = fmt::basic_format_args<fmt::printf_context>(store);
535 EXPECT_EQ(fmt::vsprintf(fmt::string_view("%d"), args), "42");
536 EXPECT_WRITE(stdout, fmt::vfprintf(stdout, fmt::string_view("%d"), args),
537 "42");
538 }
539
540 template <typename... Args>
541 void check_format_string_regression(fmt::string_view s, const Args&... args) {
542 fmt::sprintf(s, args...);
543 }
544
545 TEST(printf_test, check_format_string_regression) {
546 check_format_string_regression("%c%s", 'x', "");
547 }
548
549 TEST(printf_test, fixed_large_exponent) {
550 EXPECT_EQ("1000000000000000000000", fmt::sprintf("%.*f", -13, 1e21));
551 }
552
553 TEST(printf_test, make_printf_args) {
554 EXPECT_EQ("[42] something happened",
555 fmt::vsprintf(fmt::string_view("[%d] %s happened"),
556 {fmt::make_printf_args(42, "something")}));
557 EXPECT_EQ(L"[42] something happened",
558 fmt::vsprintf(fmt::basic_string_view<wchar_t>(L"[%d] %s happened"),
559 {fmt::make_wprintf_args(42, L"something")}));
560 }