1 // Formatting library for C++ - formatting library 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/compile.h"
9
10 #include <type_traits>
11
12 #include "fmt/chrono.h"
13 #include "fmt/ranges.h"
14 #include "gmock/gmock.h"
15 #include "gtest-extra.h"
16
TEST(compile_test,compile_fallback)17 TEST(compile_test, compile_fallback) {
18 // FMT_COMPILE should fallback on runtime formatting when `if constexpr` is
19 // not available.
20 EXPECT_EQ("42", fmt::format(FMT_COMPILE("{}"), 42));
21 }
22
23 struct type_with_get {
24 template <int> friend void get(type_with_get);
25 };
26
27 FMT_BEGIN_NAMESPACE
28 template <> struct formatter<type_with_get> : formatter<int> {
29 template <typename FormatContext>
formatformatter30 auto format(type_with_get, FormatContext& ctx) const -> decltype(ctx.out()) {
31 return formatter<int>::format(42, ctx);
32 }
33 };
34 FMT_END_NAMESPACE
35
TEST(compile_test,compile_type_with_get)36 TEST(compile_test, compile_type_with_get) {
37 EXPECT_EQ("42", fmt::format(FMT_COMPILE("{}"), type_with_get()));
38 }
39
40 #if defined(__cpp_if_constexpr) && defined(__cpp_return_type_deduction)
41 struct test_formattable {};
42
43 FMT_BEGIN_NAMESPACE
44 template <> struct formatter<test_formattable> : formatter<const char*> {
45 char word_spec = 'f';
parseformatter46 constexpr auto parse(format_parse_context& ctx) {
47 auto it = ctx.begin(), end = ctx.end();
48 if (it == end || *it == '}') return it;
49 if (it != end && (*it == 'f' || *it == 'b')) word_spec = *it++;
50 if (it != end && *it != '}') throw format_error("invalid format");
51 return it;
52 }
53 template <typename FormatContext>
formatformatter54 constexpr auto format(test_formattable, FormatContext& ctx) const
55 -> decltype(ctx.out()) {
56 return formatter<const char*>::format(word_spec == 'f' ? "foo" : "bar",
57 ctx);
58 }
59 };
60 FMT_END_NAMESPACE
61
TEST(compile_test,format_default)62 TEST(compile_test, format_default) {
63 EXPECT_EQ("42", fmt::format(FMT_COMPILE("{}"), 42));
64 EXPECT_EQ("42", fmt::format(FMT_COMPILE("{}"), 42u));
65 EXPECT_EQ("42", fmt::format(FMT_COMPILE("{}"), 42ll));
66 EXPECT_EQ("42", fmt::format(FMT_COMPILE("{}"), 42ull));
67 EXPECT_EQ("true", fmt::format(FMT_COMPILE("{}"), true));
68 EXPECT_EQ("x", fmt::format(FMT_COMPILE("{}"), 'x'));
69 EXPECT_EQ("4.2", fmt::format(FMT_COMPILE("{}"), 4.2));
70 EXPECT_EQ("foo", fmt::format(FMT_COMPILE("{}"), "foo"));
71 EXPECT_EQ("foo", fmt::format(FMT_COMPILE("{}"), std::string("foo")));
72 EXPECT_EQ("foo", fmt::format(FMT_COMPILE("{}"), test_formattable()));
73 auto t = std::chrono::system_clock::now();
74 EXPECT_EQ(fmt::format("{}", t), fmt::format(FMT_COMPILE("{}"), t));
75 # ifdef __cpp_lib_byte
76 EXPECT_EQ("42", fmt::format(FMT_COMPILE("{}"), std::byte{42}));
77 # endif
78 }
79
TEST(compile_test,format_escape)80 TEST(compile_test, format_escape) {
81 EXPECT_EQ("\"string\"", fmt::format(FMT_COMPILE("{:?}"), "string"));
82 EXPECT_EQ("prefix \"string\"",
83 fmt::format(FMT_COMPILE("prefix {:?}"), "string"));
84 EXPECT_EQ("\"string\" suffix",
85 fmt::format(FMT_COMPILE("{:?} suffix"), "string"));
86 EXPECT_EQ("\"abc\"", fmt::format(FMT_COMPILE("{0:<5?}"), "abc"));
87 EXPECT_EQ("\"abc\" ", fmt::format(FMT_COMPILE("{0:<7?}"), "abc"));
88 }
89
TEST(compile_test,format_wide_string)90 TEST(compile_test, format_wide_string) {
91 EXPECT_EQ(L"42", fmt::format(FMT_COMPILE(L"{}"), 42));
92 }
93
TEST(compile_test,format_specs)94 TEST(compile_test, format_specs) {
95 EXPECT_EQ("42", fmt::format(FMT_COMPILE("{:x}"), 0x42));
96 EXPECT_EQ("1.2 ms ",
97 fmt::format(FMT_COMPILE("{:7.1%Q %q}"),
98 std::chrono::duration<double, std::milli>(1.234)));
99 }
100
TEST(compile_test,dynamic_format_specs)101 TEST(compile_test, dynamic_format_specs) {
102 EXPECT_EQ("foo ", fmt::format(FMT_COMPILE("{:{}}"), "foo", 5));
103 EXPECT_EQ(" 3.14", fmt::format(FMT_COMPILE("{:{}.{}f}"), 3.141592, 6, 2));
104 EXPECT_EQ(
105 "=1.234ms=",
106 fmt::format(FMT_COMPILE("{:=^{}.{}}"),
107 std::chrono::duration<double, std::milli>(1.234), 9, 3));
108 }
109
TEST(compile_test,manual_ordering)110 TEST(compile_test, manual_ordering) {
111 EXPECT_EQ("42", fmt::format(FMT_COMPILE("{0}"), 42));
112 EXPECT_EQ(" -42", fmt::format(FMT_COMPILE("{0:4}"), -42));
113 EXPECT_EQ("41 43", fmt::format(FMT_COMPILE("{0} {1}"), 41, 43));
114 EXPECT_EQ("41 43", fmt::format(FMT_COMPILE("{1} {0}"), 43, 41));
115 EXPECT_EQ("41 43", fmt::format(FMT_COMPILE("{0} {2}"), 41, 42, 43));
116 EXPECT_EQ(" 41 43", fmt::format(FMT_COMPILE("{1:{2}} {0:4}"), 43, 41, 4));
117 EXPECT_EQ("42 1.2 ms ",
118 fmt::format(FMT_COMPILE("{0} {1:7.1%Q %q}"), 42,
119 std::chrono::duration<double, std::milli>(1.234)));
120 EXPECT_EQ(
121 "true 42 42 foo 0x1234 foo",
122 fmt::format(FMT_COMPILE("{0} {1} {2} {3} {4} {5}"), true, 42, 42.0f,
123 "foo", reinterpret_cast<void*>(0x1234), test_formattable()));
124 EXPECT_EQ(L"42", fmt::format(FMT_COMPILE(L"{0}"), 42));
125 }
126
TEST(compile_test,named)127 TEST(compile_test, named) {
128 auto runtime_named_field_compiled =
129 fmt::detail::compile<decltype(fmt::arg("arg", 42))>(FMT_COMPILE("{arg}"));
130 static_assert(std::is_same_v<decltype(runtime_named_field_compiled),
131 fmt::detail::runtime_named_field<char>>);
132
133 EXPECT_EQ("42", fmt::format(FMT_COMPILE("{}"), fmt::arg("arg", 42)));
134 EXPECT_EQ("41 43", fmt::format(FMT_COMPILE("{} {}"), fmt::arg("arg", 41),
135 fmt::arg("arg", 43)));
136
137 EXPECT_EQ("foobar",
138 fmt::format(FMT_COMPILE("{a0}{a1}"), fmt::arg("a0", "foo"),
139 fmt::arg("a1", "bar")));
140 EXPECT_EQ("foobar", fmt::format(FMT_COMPILE("{}{a1}"), fmt::arg("a0", "foo"),
141 fmt::arg("a1", "bar")));
142 EXPECT_EQ("foofoo", fmt::format(FMT_COMPILE("{a0}{}"), fmt::arg("a0", "foo"),
143 fmt::arg("a1", "bar")));
144 EXPECT_EQ("foobar", fmt::format(FMT_COMPILE("{0}{a1}"), fmt::arg("a0", "foo"),
145 fmt::arg("a1", "bar")));
146 EXPECT_EQ("foobar", fmt::format(FMT_COMPILE("{a0}{1}"), fmt::arg("a0", "foo"),
147 fmt::arg("a1", "bar")));
148
149 EXPECT_EQ("foobar",
150 fmt::format(FMT_COMPILE("{}{a1}"), "foo", fmt::arg("a1", "bar")));
151 EXPECT_EQ("foobar",
152 fmt::format(FMT_COMPILE("{a0}{a1}"), fmt::arg("a1", "bar"),
153 fmt::arg("a2", "baz"), fmt::arg("a0", "foo")));
154 EXPECT_EQ(" bar foo ",
155 fmt::format(FMT_COMPILE(" {foo} {bar} "), fmt::arg("foo", "bar"),
156 fmt::arg("bar", "foo")));
157
158 EXPECT_THROW(fmt::format(FMT_COMPILE("{invalid}"), fmt::arg("valid", 42)),
159 fmt::format_error);
160
161 # if FMT_USE_NONTYPE_TEMPLATE_ARGS
162 using namespace fmt::literals;
163 auto statically_named_field_compiled =
164 fmt::detail::compile<decltype("arg"_a = 42)>(FMT_COMPILE("{arg}"));
165 static_assert(std::is_same_v<decltype(statically_named_field_compiled),
166 fmt::detail::field<char, int, 0>>);
167
168 EXPECT_EQ("41 43",
169 fmt::format(FMT_COMPILE("{a0} {a1}"), "a0"_a = 41, "a1"_a = 43));
170 EXPECT_EQ("41 43",
171 fmt::format(FMT_COMPILE("{a1} {a0}"), "a0"_a = 43, "a1"_a = 41));
172 # endif
173 }
174
TEST(compile_test,join)175 TEST(compile_test, join) {
176 unsigned char data[] = {0x1, 0x2, 0xaf};
177 EXPECT_EQ("0102af", fmt::format(FMT_COMPILE("{:02x}"), fmt::join(data, "")));
178 }
179
TEST(compile_test,format_to)180 TEST(compile_test, format_to) {
181 char buf[8];
182 auto end = fmt::format_to(buf, FMT_COMPILE("{}"), 42);
183 *end = '\0';
184 EXPECT_STREQ("42", buf);
185 end = fmt::format_to(buf, FMT_COMPILE("{:x}"), 42);
186 *end = '\0';
187 EXPECT_STREQ("2a", buf);
188 }
189
TEST(compile_test,format_to_n)190 TEST(compile_test, format_to_n) {
191 constexpr auto buffer_size = 8;
192 char buffer[buffer_size];
193 auto res = fmt::format_to_n(buffer, buffer_size, FMT_COMPILE("{}"), 42);
194 *res.out = '\0';
195 EXPECT_STREQ("42", buffer);
196 res = fmt::format_to_n(buffer, buffer_size, FMT_COMPILE("{:x}"), 42);
197 *res.out = '\0';
198 EXPECT_STREQ("2a", buffer);
199 }
200
201 # if FMT_USE_CONSTEVAL && (!FMT_MSC_VERSION || FMT_MSC_VERSION >= 1940)
TEST(compile_test,constexpr_formatted_size)202 TEST(compile_test, constexpr_formatted_size) {
203 FMT_CONSTEXPR20 size_t size = fmt::formatted_size(FMT_COMPILE("{}"), 42);
204 EXPECT_EQ(size, 2);
205 FMT_CONSTEXPR20 size_t hex_size =
206 fmt::formatted_size(FMT_COMPILE("{:x}"), 15);
207 EXPECT_EQ(hex_size, 1);
208 FMT_CONSTEXPR20 size_t binary_size =
209 fmt::formatted_size(FMT_COMPILE("{:b}"), 15);
210 EXPECT_EQ(binary_size, 4);
211 FMT_CONSTEXPR20 size_t padded_size =
212 fmt::formatted_size(FMT_COMPILE("{:*^6}"), 42);
213 EXPECT_EQ(padded_size, 6);
214 FMT_CONSTEXPR20 size_t float_size =
215 fmt::formatted_size(FMT_COMPILE("{:.3}"), 12.345);
216 EXPECT_EQ(float_size, 4);
217 FMT_CONSTEXPR20 size_t str_size =
218 fmt::formatted_size(FMT_COMPILE("{:s}"), "abc");
219 EXPECT_EQ(str_size, 3);
220 }
221 # endif
222
TEST(compile_test,text_and_arg)223 TEST(compile_test, text_and_arg) {
224 EXPECT_EQ(">>>42<<<", fmt::format(FMT_COMPILE(">>>{}<<<"), 42));
225 EXPECT_EQ("42!", fmt::format(FMT_COMPILE("{}!"), 42));
226 }
227
TEST(compile_test,unknown_format_fallback)228 TEST(compile_test, unknown_format_fallback) {
229 EXPECT_EQ(" 42 ",
230 fmt::format(FMT_COMPILE("{name:^4}"), fmt::arg("name", 42)));
231
232 std::vector<char> v;
233 fmt::format_to(std::back_inserter(v), FMT_COMPILE("{name:^4}"),
234 fmt::arg("name", 42));
235 EXPECT_EQ(" 42 ", fmt::string_view(v.data(), v.size()));
236
237 char buffer[4];
238 auto result = fmt::format_to_n(buffer, 4, FMT_COMPILE("{name:^5}"),
239 fmt::arg("name", 42));
240 EXPECT_EQ(5u, result.size);
241 EXPECT_EQ(buffer + 4, result.out);
242 EXPECT_EQ(" 42 ", fmt::string_view(buffer, 4));
243 }
244
TEST(compile_test,empty)245 TEST(compile_test, empty) { EXPECT_EQ("", fmt::format(FMT_COMPILE(""))); }
246
247 struct to_stringable {
to_string_view(to_stringable)248 friend fmt::string_view to_string_view(to_stringable) { return {}; }
249 };
250
251 FMT_BEGIN_NAMESPACE
252 template <> struct formatter<to_stringable> {
parseformatter253 auto parse(format_parse_context& ctx) const -> decltype(ctx.begin()) {
254 return ctx.begin();
255 }
256
257 template <typename FormatContext>
formatformatter258 auto format(const to_stringable&, FormatContext& ctx) -> decltype(ctx.out()) {
259 return ctx.out();
260 }
261 };
262 FMT_END_NAMESPACE
263
TEST(compile_test,to_string_and_formatter)264 TEST(compile_test, to_string_and_formatter) {
265 fmt::format(FMT_COMPILE("{}"), to_stringable());
266 }
267
TEST(compile_test,print)268 TEST(compile_test, print) {
269 EXPECT_WRITE(stdout, fmt::print(FMT_COMPILE("Don't {}!"), "panic"),
270 "Don't panic!");
271 EXPECT_WRITE(stderr, fmt::print(stderr, FMT_COMPILE("Don't {}!"), "panic"),
272 "Don't panic!");
273 }
274 #endif
275
276 #if FMT_USE_NONTYPE_TEMPLATE_ARGS
TEST(compile_test,compile_format_string_literal)277 TEST(compile_test, compile_format_string_literal) {
278 using namespace fmt::literals;
279 EXPECT_EQ("", fmt::format(""_cf));
280 EXPECT_EQ("42", fmt::format("{}"_cf, 42));
281 EXPECT_EQ(L"42", fmt::format(L"{}"_cf, 42));
282 }
283 #endif
284
285 // MSVS 2019 19.29.30145.0 - OK
286 // MSVS 2022 19.32.31332.0, 19.37.32826.1 - compile-test.cc(362,3): fatal error
287 // C1001: Internal compiler error.
288 // (compiler file
289 // 'D:\a\_work\1\s\src\vctools\Compiler\CxxFE\sl\p1\c\constexpr\constexpr.cpp',
290 // line 8635)
291 #if FMT_USE_CONSTEVAL && \
292 (!FMT_MSC_VERSION || \
293 (FMT_MSC_VERSION >= 1928 && FMT_MSC_VERSION < 1930)) && \
294 defined(__cpp_lib_is_constant_evaluated)
295 template <size_t max_string_length, typename Char = char> struct test_string {
operator ==test_string296 template <typename T> constexpr bool operator==(const T& rhs) const noexcept {
297 return fmt::basic_string_view<Char>(rhs).compare(buffer) == 0;
298 }
299 Char buffer[max_string_length]{};
300 };
301
302 template <size_t max_string_length, typename Char = char, typename... Args>
test_format(auto format,const Args &...args)303 consteval auto test_format(auto format, const Args&... args) {
304 test_string<max_string_length, Char> string{};
305 fmt::format_to(string.buffer, format, args...);
306 return string;
307 }
308
TEST(compile_time_formatting_test,bool)309 TEST(compile_time_formatting_test, bool) {
310 EXPECT_EQ("true", test_format<5>(FMT_COMPILE("{}"), true));
311 EXPECT_EQ("false", test_format<6>(FMT_COMPILE("{}"), false));
312 EXPECT_EQ("true ", test_format<6>(FMT_COMPILE("{:5}"), true));
313 EXPECT_EQ("1", test_format<2>(FMT_COMPILE("{:d}"), true));
314 }
315
TEST(compile_time_formatting_test,integer)316 TEST(compile_time_formatting_test, integer) {
317 EXPECT_EQ("42", test_format<3>(FMT_COMPILE("{}"), 42));
318 EXPECT_EQ("420", test_format<4>(FMT_COMPILE("{}"), 420));
319 EXPECT_EQ("42 42", test_format<6>(FMT_COMPILE("{} {}"), 42, 42));
320 EXPECT_EQ("42 42",
321 test_format<6>(FMT_COMPILE("{} {}"), uint32_t{42}, uint64_t{42}));
322
323 EXPECT_EQ("+42", test_format<4>(FMT_COMPILE("{:+}"), 42));
324 EXPECT_EQ("42", test_format<3>(FMT_COMPILE("{:-}"), 42));
325 EXPECT_EQ(" 42", test_format<4>(FMT_COMPILE("{: }"), 42));
326
327 EXPECT_EQ("-0042", test_format<6>(FMT_COMPILE("{:05}"), -42));
328
329 EXPECT_EQ("101010", test_format<7>(FMT_COMPILE("{:b}"), 42));
330 EXPECT_EQ("0b101010", test_format<9>(FMT_COMPILE("{:#b}"), 42));
331 EXPECT_EQ("0B101010", test_format<9>(FMT_COMPILE("{:#B}"), 42));
332 EXPECT_EQ("042", test_format<4>(FMT_COMPILE("{:#o}"), 042));
333 EXPECT_EQ("0x4a", test_format<5>(FMT_COMPILE("{:#x}"), 0x4a));
334 EXPECT_EQ("0X4A", test_format<5>(FMT_COMPILE("{:#X}"), 0x4a));
335
336 EXPECT_EQ(" 42", test_format<6>(FMT_COMPILE("{:5}"), 42));
337 EXPECT_EQ(" 42", test_format<6>(FMT_COMPILE("{:5}"), 42l));
338 EXPECT_EQ(" 42", test_format<6>(FMT_COMPILE("{:5}"), 42ll));
339 EXPECT_EQ(" 42", test_format<6>(FMT_COMPILE("{:5}"), 42ull));
340
341 EXPECT_EQ("42 ", test_format<5>(FMT_COMPILE("{:<4}"), 42));
342 EXPECT_EQ(" 42", test_format<5>(FMT_COMPILE("{:>4}"), 42));
343 EXPECT_EQ(" 42 ", test_format<5>(FMT_COMPILE("{:^4}"), 42));
344 EXPECT_EQ("**-42", test_format<6>(FMT_COMPILE("{:*>5}"), -42));
345 }
346
TEST(compile_time_formatting_test,char)347 TEST(compile_time_formatting_test, char) {
348 EXPECT_EQ("c", test_format<2>(FMT_COMPILE("{}"), 'c'));
349
350 EXPECT_EQ("c ", test_format<4>(FMT_COMPILE("{:3}"), 'c'));
351 EXPECT_EQ("99", test_format<3>(FMT_COMPILE("{:d}"), 'c'));
352 }
353
TEST(compile_time_formatting_test,string)354 TEST(compile_time_formatting_test, string) {
355 EXPECT_EQ("42", test_format<3>(FMT_COMPILE("{}"), "42"));
356 EXPECT_EQ("The answer is 42",
357 test_format<17>(FMT_COMPILE("{} is {}"), "The answer", "42"));
358
359 EXPECT_EQ("abc**", test_format<6>(FMT_COMPILE("{:*<5}"), "abc"));
360 EXPECT_EQ("**��**", test_format<9>(FMT_COMPILE("{:*^6}"), "��"));
361 }
362
TEST(compile_time_formatting_test,combination)363 TEST(compile_time_formatting_test, combination) {
364 EXPECT_EQ("420, true, answer",
365 test_format<18>(FMT_COMPILE("{}, {}, {}"), 420, true, "answer"));
366
367 EXPECT_EQ(" -42", test_format<5>(FMT_COMPILE("{:{}}"), -42, 4));
368 }
369
TEST(compile_time_formatting_test,custom_type)370 TEST(compile_time_formatting_test, custom_type) {
371 EXPECT_EQ("foo", test_format<4>(FMT_COMPILE("{}"), test_formattable()));
372 EXPECT_EQ("bar", test_format<4>(FMT_COMPILE("{:b}"), test_formattable()));
373 }
374
TEST(compile_time_formatting_test,multibyte_fill)375 TEST(compile_time_formatting_test, multibyte_fill) {
376 EXPECT_EQ("жж42", test_format<8>(FMT_COMPILE("{:ж>4}"), 42));
377 }
378 #endif
379