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 <cctype>
9 #include <cfloat>
10 #include <climits>
11 #include <cmath>
12 #include <cstring>
13 #include <list>
14 #include <memory>
15 #include <string>
16 #include <stdint.h>
17
18 // Check if fmt/format.h compiles with windows.h included before it.
19 #ifdef _WIN32
20 # include <windows.h>
21 #endif
22
23 #include "fmt/format.h"
24 #include "gmock.h"
25 #include "gtest-extra.h"
26 #include "mock-allocator.h"
27 #include "util.h"
28
29 #undef ERROR
30 #undef min
31 #undef max
32
33 using std::size_t;
34
35 using fmt::basic_memory_buffer;
36 using fmt::basic_writer;
37 using fmt::format;
38 using fmt::format_error;
39 using fmt::string_view;
40 using fmt::memory_buffer;
41 using fmt::wmemory_buffer;
42
43 using testing::Return;
44 using testing::StrictMock;
45
46 namespace {
47
48 #if !FMT_GCC_VERSION || FMT_GCC_VERSION >= 408
49 template <typename Char, typename T>
check_enabled_formatter()50 bool check_enabled_formatter() {
51 static_assert(
52 std::is_default_constructible<fmt::formatter<T, Char>>::value, "");
53 return true;
54 }
55
56 template <typename Char, typename... T>
check_enabled_formatters()57 void check_enabled_formatters() {
58 auto dummy = {check_enabled_formatter<Char, T>()...};
59 (void)dummy;
60 }
61
TEST(FormatterTest,TestFormattersEnabled)62 TEST(FormatterTest, TestFormattersEnabled) {
63 check_enabled_formatters<char,
64 bool, char, signed char, unsigned char, short, unsigned short,
65 int, unsigned, long, unsigned long, long long, unsigned long long,
66 float, double, long double, void*, const void*,
67 char*, const char*, std::string>();
68 check_enabled_formatters<wchar_t,
69 bool, wchar_t, signed char, unsigned char, short, unsigned short,
70 int, unsigned, long, unsigned long, long long, unsigned long long,
71 float, double, long double, void*, const void*,
72 wchar_t*, const wchar_t*, std::wstring>();
73 #if FMT_USE_NULLPTR
74 check_enabled_formatters<char, std::nullptr_t>();
75 check_enabled_formatters<wchar_t, std::nullptr_t>();
76 #endif
77 }
78 #endif
79
80 // Format value using the standard library.
81 template <typename Char, typename T>
std_format(const T & value,std::basic_string<Char> & result)82 void std_format(const T &value, std::basic_string<Char> &result) {
83 std::basic_ostringstream<Char> os;
84 os << value;
85 result = os.str();
86 }
87
88 #ifdef __MINGW32__
89 // Workaround a bug in formatting long double in MinGW.
std_format(long double value,std::string & result)90 void std_format(long double value, std::string &result) {
91 char buffer[100];
92 safe_sprintf(buffer, "%Lg", value);
93 result = buffer;
94 }
std_format(long double value,std::wstring & result)95 void std_format(long double value, std::wstring &result) {
96 wchar_t buffer[100];
97 swprintf(buffer, L"%Lg", value);
98 result = buffer;
99 }
100 #endif
101
102 // Checks if writing value to BasicWriter<Char> produces the same result
103 // as writing it to std::basic_ostringstream<Char>.
104 template <typename Char, typename T>
check_write(const T & value,const char * type)105 ::testing::AssertionResult check_write(const T &value, const char *type) {
106 fmt::basic_memory_buffer<Char> buffer;
107 typedef fmt::back_insert_range<fmt::internal::basic_buffer<Char>> range;
108 fmt::basic_writer<range> writer(buffer);
109 writer.write(value);
110 std::basic_string<Char> actual = to_string(buffer);
111 std::basic_string<Char> expected;
112 std_format(value, expected);
113 if (expected == actual)
114 return ::testing::AssertionSuccess();
115 return ::testing::AssertionFailure()
116 << "Value of: (Writer<" << type << ">() << value).str()\n"
117 << " Actual: " << actual << "\n"
118 << "Expected: " << expected << "\n";
119 }
120
121 struct AnyWriteChecker {
122 template <typename T>
operator ()__anonc26c3c580111::AnyWriteChecker123 ::testing::AssertionResult operator()(const char *, const T &value) const {
124 ::testing::AssertionResult result = check_write<char>(value, "char");
125 return result ? check_write<wchar_t>(value, "wchar_t") : result;
126 }
127 };
128
129 template <typename Char>
130 struct WriteChecker {
131 template <typename T>
operator ()__anonc26c3c580111::WriteChecker132 ::testing::AssertionResult operator()(const char *, const T &value) const {
133 return check_write<Char>(value, "char");
134 }
135 };
136
137 // Checks if writing value to BasicWriter produces the same result
138 // as writing it to std::ostringstream both for char and wchar_t.
139 #define CHECK_WRITE(value) EXPECT_PRED_FORMAT1(AnyWriteChecker(), value)
140
141 #define CHECK_WRITE_CHAR(value) \
142 EXPECT_PRED_FORMAT1(WriteChecker<char>(), value)
143 #define CHECK_WRITE_WCHAR(value) \
144 EXPECT_PRED_FORMAT1(WriteChecker<wchar_t>(), value)
145 } // namespace
146
147 // Tests fmt::internal::count_digits for integer type Int.
148 template <typename Int>
test_count_digits()149 void test_count_digits() {
150 for (Int i = 0; i < 10; ++i)
151 EXPECT_EQ(1u, fmt::internal::count_digits(i));
152 for (Int i = 1, n = 1,
153 end = std::numeric_limits<Int>::max() / 10; n <= end; ++i) {
154 n *= 10;
155 EXPECT_EQ(i, fmt::internal::count_digits(n - 1));
156 EXPECT_EQ(i + 1, fmt::internal::count_digits(n));
157 }
158 }
159
TEST(UtilTest,CountDigits)160 TEST(UtilTest, CountDigits) {
161 test_count_digits<uint32_t>();
162 test_count_digits<uint64_t>();
163 }
164
165 struct uint32_pair {
166 uint32_t u[2];
167 };
168
TEST(UtilTest,BitCast)169 TEST(UtilTest, BitCast) {
170 auto s = fmt::internal::bit_cast<uint32_pair>(uint64_t{42});
171 EXPECT_EQ(fmt::internal::bit_cast<uint64_t>(s), 42ull);
172 s = fmt::internal::bit_cast<uint32_pair>(uint64_t(~0ull));
173 EXPECT_EQ(fmt::internal::bit_cast<uint64_t>(s), ~0ull);
174 }
175
TEST(UtilTest,Increment)176 TEST(UtilTest, Increment) {
177 char s[10] = "123";
178 increment(s);
179 EXPECT_STREQ("124", s);
180 s[2] = '8';
181 increment(s);
182 EXPECT_STREQ("129", s);
183 increment(s);
184 EXPECT_STREQ("130", s);
185 s[1] = s[2] = '9';
186 increment(s);
187 EXPECT_STREQ("200", s);
188 }
189
TEST(UtilTest,ParseNonnegativeInt)190 TEST(UtilTest, ParseNonnegativeInt) {
191 if (std::numeric_limits<int>::max() !=
192 static_cast<int>(static_cast<unsigned>(1) << 31)) {
193 fmt::print("Skipping parse_nonnegative_int test\n");
194 return;
195 }
196 fmt::string_view s = "10000000000";
197 auto begin = s.begin(), end = s.end();
198 EXPECT_THROW_MSG(
199 parse_nonnegative_int(begin, end, fmt::internal::error_handler()),
200 fmt::format_error, "number is too big");
201 s = "2147483649";
202 begin = s.begin();
203 end = s.end();
204 EXPECT_THROW_MSG(
205 parse_nonnegative_int(begin, end, fmt::internal::error_handler()),
206 fmt::format_error, "number is too big");
207 }
208
TEST(IteratorTest,CountingIterator)209 TEST(IteratorTest, CountingIterator) {
210 fmt::internal::counting_iterator<char> it;
211 auto prev = it++;
212 EXPECT_EQ(prev.count(), 0);
213 EXPECT_EQ(it.count(), 1);
214 }
215
TEST(IteratorTest,TruncatingIterator)216 TEST(IteratorTest, TruncatingIterator) {
217 char *p = FMT_NULL;
218 fmt::internal::truncating_iterator<char*> it(p, 3);
219 auto prev = it++;
220 EXPECT_EQ(prev.base(), p);
221 EXPECT_EQ(it.base(), p + 1);
222 }
223
TEST(IteratorTest,TruncatingBackInserter)224 TEST(IteratorTest, TruncatingBackInserter) {
225 std::string buffer;
226 auto bi = std::back_inserter(buffer);
227 fmt::internal::truncating_iterator<decltype(bi)> it(bi, 2);
228 *it++ = '4';
229 *it++ = '2';
230 *it++ = '1';
231 EXPECT_EQ(buffer.size(), 2);
232 EXPECT_EQ(buffer, "42");
233 }
234
TEST(IteratorTest,IsOutputIterator)235 TEST(IteratorTest, IsOutputIterator) {
236 EXPECT_TRUE(fmt::internal::is_output_iterator<char*>::value);
237 EXPECT_FALSE(fmt::internal::is_output_iterator<const char*>::value);
238 EXPECT_FALSE(fmt::internal::is_output_iterator<std::string>::value);
239 EXPECT_TRUE(fmt::internal::is_output_iterator<
240 std::back_insert_iterator<std::string>>::value);
241 EXPECT_TRUE(fmt::internal::is_output_iterator<
242 std::string::iterator>::value);
243 EXPECT_FALSE(fmt::internal::is_output_iterator<
244 std::string::const_iterator>::value);
245 EXPECT_FALSE(fmt::internal::is_output_iterator<std::list<char>>::value);
246 EXPECT_TRUE(fmt::internal::is_output_iterator<
247 std::list<char>::iterator>::value);
248 EXPECT_FALSE(fmt::internal::is_output_iterator<
249 std::list<char>::const_iterator>::value);
250 EXPECT_FALSE(fmt::internal::is_output_iterator<uint32_pair>::value);
251 }
252
TEST(MemoryBufferTest,Ctor)253 TEST(MemoryBufferTest, Ctor) {
254 basic_memory_buffer<char, 123> buffer;
255 EXPECT_EQ(static_cast<size_t>(0), buffer.size());
256 EXPECT_EQ(123u, buffer.capacity());
257 }
258
check_forwarding(mock_allocator<int> & alloc,allocator_ref<mock_allocator<int>> & ref)259 static void check_forwarding(
260 mock_allocator<int> &alloc, allocator_ref<mock_allocator<int>> &ref) {
261 int mem;
262 // Check if value_type is properly defined.
263 allocator_ref< mock_allocator<int> >::value_type *ptr = &mem;
264 // Check forwarding.
265 EXPECT_CALL(alloc, allocate(42)).WillOnce(testing::Return(ptr));
266 ref.allocate(42);
267 EXPECT_CALL(alloc, deallocate(ptr, 42));
268 ref.deallocate(ptr, 42);
269 }
270
TEST(AllocatorTest,allocator_ref)271 TEST(AllocatorTest, allocator_ref) {
272 StrictMock< mock_allocator<int> > alloc;
273 typedef allocator_ref< mock_allocator<int> > test_allocator_ref;
274 test_allocator_ref ref(&alloc);
275 // Check if allocator_ref forwards to the underlying allocator.
276 check_forwarding(alloc, ref);
277 test_allocator_ref ref2(ref);
278 check_forwarding(alloc, ref2);
279 test_allocator_ref ref3;
280 EXPECT_EQ(FMT_NULL, ref3.get());
281 ref3 = ref;
282 check_forwarding(alloc, ref3);
283 }
284
285 typedef allocator_ref< std::allocator<char> > TestAllocator;
286
check_move_buffer(const char * str,basic_memory_buffer<char,5,TestAllocator> & buffer)287 static void check_move_buffer(const char *str,
288 basic_memory_buffer<char, 5, TestAllocator> &buffer) {
289 std::allocator<char> *alloc = buffer.get_allocator().get();
290 basic_memory_buffer<char, 5, TestAllocator> buffer2(std::move(buffer));
291 // Move shouldn't destroy the inline content of the first buffer.
292 EXPECT_EQ(str, std::string(&buffer[0], buffer.size()));
293 EXPECT_EQ(str, std::string(&buffer2[0], buffer2.size()));
294 EXPECT_EQ(5u, buffer2.capacity());
295 // Move should transfer allocator.
296 EXPECT_EQ(FMT_NULL, buffer.get_allocator().get());
297 EXPECT_EQ(alloc, buffer2.get_allocator().get());
298 }
299
TEST(MemoryBufferTest,MoveCtor)300 TEST(MemoryBufferTest, MoveCtor) {
301 std::allocator<char> alloc;
302 basic_memory_buffer<char, 5, TestAllocator> buffer((TestAllocator(&alloc)));
303 const char test[] = "test";
304 buffer.append(test, test + 4);
305 check_move_buffer("test", buffer);
306 // Adding one more character fills the inline buffer, but doesn't cause
307 // dynamic allocation.
308 buffer.push_back('a');
309 check_move_buffer("testa", buffer);
310 const char *inline_buffer_ptr = &buffer[0];
311 // Adding one more character causes the content to move from the inline to
312 // a dynamically allocated buffer.
313 buffer.push_back('b');
314 basic_memory_buffer<char, 5, TestAllocator> buffer2(std::move(buffer));
315 // Move should rip the guts of the first buffer.
316 EXPECT_EQ(inline_buffer_ptr, &buffer[0]);
317 EXPECT_EQ("testab", std::string(&buffer2[0], buffer2.size()));
318 EXPECT_GT(buffer2.capacity(), 5u);
319 }
320
check_move_assign_buffer(const char * str,basic_memory_buffer<char,5> & buffer)321 static void check_move_assign_buffer(
322 const char *str, basic_memory_buffer<char, 5> &buffer) {
323 basic_memory_buffer<char, 5> buffer2;
324 buffer2 = std::move(buffer);
325 // Move shouldn't destroy the inline content of the first buffer.
326 EXPECT_EQ(str, std::string(&buffer[0], buffer.size()));
327 EXPECT_EQ(str, std::string(&buffer2[0], buffer2.size()));
328 EXPECT_EQ(5u, buffer2.capacity());
329 }
330
TEST(MemoryBufferTest,MoveAssignment)331 TEST(MemoryBufferTest, MoveAssignment) {
332 basic_memory_buffer<char, 5> buffer;
333 const char test[] = "test";
334 buffer.append(test, test + 4);
335 check_move_assign_buffer("test", buffer);
336 // Adding one more character fills the inline buffer, but doesn't cause
337 // dynamic allocation.
338 buffer.push_back('a');
339 check_move_assign_buffer("testa", buffer);
340 const char *inline_buffer_ptr = &buffer[0];
341 // Adding one more character causes the content to move from the inline to
342 // a dynamically allocated buffer.
343 buffer.push_back('b');
344 basic_memory_buffer<char, 5> buffer2;
345 buffer2 = std::move(buffer);
346 // Move should rip the guts of the first buffer.
347 EXPECT_EQ(inline_buffer_ptr, &buffer[0]);
348 EXPECT_EQ("testab", std::string(&buffer2[0], buffer2.size()));
349 EXPECT_GT(buffer2.capacity(), 5u);
350 }
351
TEST(MemoryBufferTest,Grow)352 TEST(MemoryBufferTest, Grow) {
353 typedef allocator_ref< mock_allocator<int> > Allocator;
354 typedef basic_memory_buffer<int, 10, Allocator> Base;
355 mock_allocator<int> alloc;
356 struct TestMemoryBuffer : Base {
357 TestMemoryBuffer(Allocator alloc) : Base(alloc) {}
358 void grow(std::size_t size) { Base::grow(size); }
359 } buffer((Allocator(&alloc)));
360 buffer.resize(7);
361 using fmt::internal::to_unsigned;
362 for (int i = 0; i < 7; ++i)
363 buffer[to_unsigned(i)] = i * i;
364 EXPECT_EQ(10u, buffer.capacity());
365 int mem[20];
366 mem[7] = 0xdead;
367 EXPECT_CALL(alloc, allocate(20)).WillOnce(Return(mem));
368 buffer.grow(20);
369 EXPECT_EQ(20u, buffer.capacity());
370 // Check if size elements have been copied
371 for (int i = 0; i < 7; ++i)
372 EXPECT_EQ(i * i, buffer[to_unsigned(i)]);
373 // and no more than that.
374 EXPECT_EQ(0xdead, buffer[7]);
375 EXPECT_CALL(alloc, deallocate(mem, 20));
376 }
377
TEST(MemoryBufferTest,Allocator)378 TEST(MemoryBufferTest, Allocator) {
379 typedef allocator_ref< mock_allocator<char> > TestAllocator;
380 basic_memory_buffer<char, 10, TestAllocator> buffer;
381 EXPECT_EQ(FMT_NULL, buffer.get_allocator().get());
382 StrictMock< mock_allocator<char> > alloc;
383 char mem;
384 {
385 basic_memory_buffer<char, 10, TestAllocator> buffer2((TestAllocator(&alloc)));
386 EXPECT_EQ(&alloc, buffer2.get_allocator().get());
387 std::size_t size = 2 * fmt::inline_buffer_size;
388 EXPECT_CALL(alloc, allocate(size)).WillOnce(Return(&mem));
389 buffer2.reserve(size);
390 EXPECT_CALL(alloc, deallocate(&mem, size));
391 }
392 }
393
TEST(MemoryBufferTest,ExceptionInDeallocate)394 TEST(MemoryBufferTest, ExceptionInDeallocate) {
395 typedef allocator_ref< mock_allocator<char> > TestAllocator;
396 StrictMock< mock_allocator<char> > alloc;
397 basic_memory_buffer<char, 10, TestAllocator> buffer((TestAllocator(&alloc)));
398 std::size_t size = 2 * fmt::inline_buffer_size;
399 std::vector<char> mem(size);
400 {
401 EXPECT_CALL(alloc, allocate(size)).WillOnce(Return(&mem[0]));
402 buffer.resize(size);
403 std::fill(&buffer[0], &buffer[0] + size, 'x');
404 }
405 std::vector<char> mem2(2 * size);
406 {
407 EXPECT_CALL(alloc, allocate(2 * size)).WillOnce(Return(&mem2[0]));
408 std::exception e;
409 EXPECT_CALL(alloc, deallocate(&mem[0], size)).WillOnce(testing::Throw(e));
410 EXPECT_THROW(buffer.reserve(2 * size), std::exception);
411 EXPECT_EQ(&mem2[0], &buffer[0]);
412 // Check that the data has been copied.
413 for (std::size_t i = 0; i < size; ++i)
414 EXPECT_EQ('x', buffer[i]);
415 }
416 EXPECT_CALL(alloc, deallocate(&mem2[0], 2 * size));
417 }
418
419 #ifdef _WIN32
TEST(UtilTest,UTF16ToUTF8)420 TEST(UtilTest, UTF16ToUTF8) {
421 std::string s = "ёжик";
422 fmt::internal::utf16_to_utf8 u(L"\x0451\x0436\x0438\x043A");
423 EXPECT_EQ(s, u.str());
424 EXPECT_EQ(s.size(), u.size());
425 }
426
TEST(UtilTest,UTF16ToUTF8EmptyString)427 TEST(UtilTest, UTF16ToUTF8EmptyString) {
428 std::string s = "";
429 fmt::internal::utf16_to_utf8 u(L"");
430 EXPECT_EQ(s, u.str());
431 EXPECT_EQ(s.size(), u.size());
432 }
433
TEST(UtilTest,UTF8ToUTF16)434 TEST(UtilTest, UTF8ToUTF16) {
435 std::string s = "лошадка";
436 fmt::internal::utf8_to_utf16 u(s.c_str());
437 EXPECT_EQ(L"\x043B\x043E\x0448\x0430\x0434\x043A\x0430", u.str());
438 EXPECT_EQ(7, u.size());
439 }
440
TEST(UtilTest,UTF8ToUTF16EmptyString)441 TEST(UtilTest, UTF8ToUTF16EmptyString) {
442 std::string s = "";
443 fmt::internal::utf8_to_utf16 u(s.c_str());
444 EXPECT_EQ(L"", u.str());
445 EXPECT_EQ(s.size(), u.size());
446 }
447
448 template <typename Converter, typename Char>
check_utf_conversion_error(const char * message,fmt::basic_string_view<Char> str=fmt::basic_string_view<Char> (0,1))449 void check_utf_conversion_error(
450 const char *message,
451 fmt::basic_string_view<Char> str = fmt::basic_string_view<Char>(0, 1)) {
452 fmt::memory_buffer out;
453 fmt::internal::format_windows_error(out, ERROR_INVALID_PARAMETER, message);
454 fmt::system_error error(0, "");
455 try {
456 (Converter)(str);
457 } catch (const fmt::system_error &e) {
458 error = e;
459 }
460 EXPECT_EQ(ERROR_INVALID_PARAMETER, error.error_code());
461 EXPECT_EQ(fmt::to_string(out), error.what());
462 }
463
TEST(UtilTest,UTF16ToUTF8Error)464 TEST(UtilTest, UTF16ToUTF8Error) {
465 check_utf_conversion_error<fmt::internal::utf16_to_utf8, wchar_t>(
466 "cannot convert string from UTF-16 to UTF-8");
467 }
468
TEST(UtilTest,UTF8ToUTF16Error)469 TEST(UtilTest, UTF8ToUTF16Error) {
470 const char *message = "cannot convert string from UTF-8 to UTF-16";
471 check_utf_conversion_error<fmt::internal::utf8_to_utf16, char>(message);
472 check_utf_conversion_error<fmt::internal::utf8_to_utf16, char>(
473 message, fmt::string_view("foo", INT_MAX + 1u));
474 }
475
TEST(UtilTest,UTF16ToUTF8Convert)476 TEST(UtilTest, UTF16ToUTF8Convert) {
477 fmt::internal::utf16_to_utf8 u;
478 EXPECT_EQ(ERROR_INVALID_PARAMETER, u.convert(fmt::wstring_view(0, 1)));
479 EXPECT_EQ(ERROR_INVALID_PARAMETER,
480 u.convert(fmt::wstring_view(L"foo", INT_MAX + 1u)));
481 }
482 #endif // _WIN32
483
484 typedef void (*FormatErrorMessage)(
485 fmt::internal::buffer &out, int error_code, string_view message);
486
487 template <typename Error>
check_throw_error(int error_code,FormatErrorMessage format)488 void check_throw_error(int error_code, FormatErrorMessage format) {
489 fmt::system_error error(0, "");
490 try {
491 throw Error(error_code, "test {}", "error");
492 } catch (const fmt::system_error &e) {
493 error = e;
494 }
495 fmt::memory_buffer message;
496 format(message, error_code, "test error");
497 EXPECT_EQ(to_string(message), error.what());
498 EXPECT_EQ(error_code, error.error_code());
499 }
500
TEST(UtilTest,FormatSystemError)501 TEST(UtilTest, FormatSystemError) {
502 fmt::memory_buffer message;
503 fmt::format_system_error(message, EDOM, "test");
504 EXPECT_EQ(fmt::format("test: {}", get_system_error(EDOM)),
505 to_string(message));
506 message = fmt::memory_buffer();
507
508 // Check if std::allocator throws on allocating max size_t / 2 chars.
509 size_t max_size = std::numeric_limits<size_t>::max() / 2;
510 bool throws_on_alloc = false;
511 try {
512 std::allocator<char> alloc;
513 alloc.deallocate(alloc.allocate(max_size), max_size);
514 } catch (const std::bad_alloc&) {
515 throws_on_alloc = true;
516 }
517 if (!throws_on_alloc) {
518 fmt::print("warning: std::allocator allocates {} chars", max_size);
519 return;
520 }
521 fmt::format_system_error(message, EDOM, fmt::string_view(FMT_NULL, max_size));
522 EXPECT_EQ(fmt::format("error {}", EDOM), to_string(message));
523 }
524
TEST(UtilTest,SystemError)525 TEST(UtilTest, SystemError) {
526 fmt::system_error e(EDOM, "test");
527 EXPECT_EQ(fmt::format("test: {}", get_system_error(EDOM)), e.what());
528 EXPECT_EQ(EDOM, e.error_code());
529 check_throw_error<fmt::system_error>(EDOM, fmt::format_system_error);
530 }
531
TEST(UtilTest,ReportSystemError)532 TEST(UtilTest, ReportSystemError) {
533 fmt::memory_buffer out;
534 fmt::format_system_error(out, EDOM, "test error");
535 out.push_back('\n');
536 EXPECT_WRITE(stderr, fmt::report_system_error(EDOM, "test error"),
537 to_string(out));
538 }
539
540 #ifdef _WIN32
541
TEST(UtilTest,FormatWindowsError)542 TEST(UtilTest, FormatWindowsError) {
543 LPWSTR message = 0;
544 FormatMessageW(FORMAT_MESSAGE_ALLOCATE_BUFFER |
545 FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, 0,
546 ERROR_FILE_EXISTS, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
547 reinterpret_cast<LPWSTR>(&message), 0, 0);
548 fmt::internal::utf16_to_utf8 utf8_message(message);
549 LocalFree(message);
550 fmt::memory_buffer actual_message;
551 fmt::internal::format_windows_error(
552 actual_message, ERROR_FILE_EXISTS, "test");
553 EXPECT_EQ(fmt::format("test: {}", utf8_message.str()),
554 fmt::to_string(actual_message));
555 actual_message.resize(0);
556 fmt::internal::format_windows_error(
557 actual_message, ERROR_FILE_EXISTS,
558 fmt::string_view(0, std::numeric_limits<size_t>::max()));
559 EXPECT_EQ(fmt::format("error {}", ERROR_FILE_EXISTS),
560 fmt::to_string(actual_message));
561 }
562
TEST(UtilTest,FormatLongWindowsError)563 TEST(UtilTest, FormatLongWindowsError) {
564 LPWSTR message = 0;
565 // this error code is not available on all Windows platforms and
566 // Windows SDKs, so do not fail the test if the error string cannot
567 // be retrieved.
568 const int provisioning_not_allowed = 0x80284013L /*TBS_E_PROVISIONING_NOT_ALLOWED*/;
569 if (FormatMessageW(FORMAT_MESSAGE_ALLOCATE_BUFFER |
570 FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, 0,
571 static_cast<DWORD>(provisioning_not_allowed),
572 MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
573 reinterpret_cast<LPWSTR>(&message), 0, 0) == 0) {
574 return;
575 }
576 fmt::internal::utf16_to_utf8 utf8_message(message);
577 LocalFree(message);
578 fmt::memory_buffer actual_message;
579 fmt::internal::format_windows_error(
580 actual_message, provisioning_not_allowed, "test");
581 EXPECT_EQ(fmt::format("test: {}", utf8_message.str()),
582 fmt::to_string(actual_message));
583 }
584
TEST(UtilTest,WindowsError)585 TEST(UtilTest, WindowsError) {
586 check_throw_error<fmt::windows_error>(
587 ERROR_FILE_EXISTS, fmt::internal::format_windows_error);
588 }
589
TEST(UtilTest,ReportWindowsError)590 TEST(UtilTest, ReportWindowsError) {
591 fmt::memory_buffer out;
592 fmt::internal::format_windows_error(out, ERROR_FILE_EXISTS, "test error");
593 out.push_back('\n');
594 EXPECT_WRITE(stderr,
595 fmt::report_windows_error(ERROR_FILE_EXISTS, "test error"),
596 fmt::to_string(out));
597 }
598
599 #endif // _WIN32
600
TEST(StringViewTest,Ctor)601 TEST(StringViewTest, Ctor) {
602 EXPECT_STREQ("abc", string_view("abc").data());
603 EXPECT_EQ(3u, string_view("abc").size());
604
605 EXPECT_STREQ("defg", string_view(std::string("defg")).data());
606 EXPECT_EQ(4u, string_view(std::string("defg")).size());
607 }
608
TEST(WriterTest,Data)609 TEST(WriterTest, Data) {
610 memory_buffer buf;
611 fmt::writer w(buf);
612 w.write(42);
613 EXPECT_EQ("42", to_string(buf));
614 }
615
TEST(WriterTest,WriteInt)616 TEST(WriterTest, WriteInt) {
617 CHECK_WRITE(42);
618 CHECK_WRITE(-42);
619 CHECK_WRITE(static_cast<short>(12));
620 CHECK_WRITE(34u);
621 CHECK_WRITE(std::numeric_limits<int>::min());
622 CHECK_WRITE(std::numeric_limits<int>::max());
623 CHECK_WRITE(std::numeric_limits<unsigned>::max());
624 }
625
TEST(WriterTest,WriteLong)626 TEST(WriterTest, WriteLong) {
627 CHECK_WRITE(56l);
628 CHECK_WRITE(78ul);
629 CHECK_WRITE(std::numeric_limits<long>::min());
630 CHECK_WRITE(std::numeric_limits<long>::max());
631 CHECK_WRITE(std::numeric_limits<unsigned long>::max());
632 }
633
TEST(WriterTest,WriteLongLong)634 TEST(WriterTest, WriteLongLong) {
635 CHECK_WRITE(56ll);
636 CHECK_WRITE(78ull);
637 CHECK_WRITE(std::numeric_limits<long long>::min());
638 CHECK_WRITE(std::numeric_limits<long long>::max());
639 CHECK_WRITE(std::numeric_limits<unsigned long long>::max());
640 }
641
TEST(WriterTest,WriteDouble)642 TEST(WriterTest, WriteDouble) {
643 CHECK_WRITE(4.2);
644 CHECK_WRITE(-4.2);
645 CHECK_WRITE(std::numeric_limits<double>::min());
646 CHECK_WRITE(std::numeric_limits<double>::max());
647 }
648
TEST(WriterTest,WriteLongDouble)649 TEST(WriterTest, WriteLongDouble) {
650 CHECK_WRITE(4.2l);
651 CHECK_WRITE_CHAR(-4.2l);
652 std::wstring str;
653 std_format(4.2l, str);
654 if (str[0] != '-')
655 CHECK_WRITE_WCHAR(-4.2l);
656 else
657 fmt::print("warning: long double formatting with std::swprintf is broken");
658 CHECK_WRITE(std::numeric_limits<long double>::min());
659 CHECK_WRITE(std::numeric_limits<long double>::max());
660 }
661
TEST(WriterTest,WriteDoubleAtBufferBoundary)662 TEST(WriterTest, WriteDoubleAtBufferBoundary) {
663 memory_buffer buf;
664 fmt::writer writer(buf);
665 for (int i = 0; i < 100; ++i)
666 writer.write(1.23456789);
667 }
668
TEST(WriterTest,WriteDoubleWithFilledBuffer)669 TEST(WriterTest, WriteDoubleWithFilledBuffer) {
670 memory_buffer buf;
671 fmt::writer writer(buf);
672 // Fill the buffer.
673 for (int i = 0; i < fmt::inline_buffer_size; ++i)
674 writer.write(' ');
675 writer.write(1.2);
676 fmt::string_view sv(buf.data(), buf.size());
677 sv.remove_prefix(fmt::inline_buffer_size);
678 EXPECT_EQ("1.2", sv);
679 }
680
TEST(WriterTest,WriteChar)681 TEST(WriterTest, WriteChar) {
682 CHECK_WRITE('a');
683 }
684
TEST(WriterTest,WriteWideChar)685 TEST(WriterTest, WriteWideChar) {
686 CHECK_WRITE_WCHAR(L'a');
687 }
688
TEST(WriterTest,WriteString)689 TEST(WriterTest, WriteString) {
690 CHECK_WRITE_CHAR("abc");
691 CHECK_WRITE_WCHAR("abc");
692 // The following line shouldn't compile:
693 //std::declval<fmt::basic_writer<fmt::buffer>>().write(L"abc");
694 }
695
TEST(WriterTest,WriteWideString)696 TEST(WriterTest, WriteWideString) {
697 CHECK_WRITE_WCHAR(L"abc");
698 // The following line shouldn't compile:
699 //std::declval<fmt::basic_writer<fmt::wbuffer>>().write("abc");
700 }
701
TEST(FormatToTest,FormatWithoutArgs)702 TEST(FormatToTest, FormatWithoutArgs) {
703 std::string s;
704 fmt::format_to(std::back_inserter(s), "test");
705 EXPECT_EQ("test", s);
706 }
707
TEST(FormatToTest,Format)708 TEST(FormatToTest, Format) {
709 std::string s;
710 fmt::format_to(std::back_inserter(s), "part{0}", 1);
711 EXPECT_EQ("part1", s);
712 fmt::format_to(std::back_inserter(s), "part{0}", 2);
713 EXPECT_EQ("part1part2", s);
714 }
715
TEST(FormatToTest,WideString)716 TEST(FormatToTest, WideString) {
717 std::vector<wchar_t> buf;
718 fmt::format_to(std::back_inserter(buf), L"{}{}", 42, L'\0');
719 EXPECT_STREQ(buf.data(), L"42");
720 }
721
TEST(FormatToTest,FormatToNonbackInsertIteratorWithSignAndNumericAlignment)722 TEST(FormatToTest, FormatToNonbackInsertIteratorWithSignAndNumericAlignment) {
723 char buffer[16] = {};
724 fmt::format_to(fmt::internal::make_checked(buffer, 16), "{: =+}", 42.0);
725 EXPECT_STREQ("+42", buffer);
726 }
727
TEST(FormatToTest,FormatToMemoryBuffer)728 TEST(FormatToTest, FormatToMemoryBuffer) {
729 fmt::basic_memory_buffer<char, 100> buffer;
730 fmt::format_to(buffer, "{}", "foo");
731 EXPECT_EQ("foo", to_string(buffer));
732 fmt::wmemory_buffer wbuffer;
733 fmt::format_to(wbuffer, L"{}", L"foo");
734 EXPECT_EQ(L"foo", to_string(wbuffer));
735 }
736
TEST(FormatterTest,Escape)737 TEST(FormatterTest, Escape) {
738 EXPECT_EQ("{", format("{{"));
739 EXPECT_EQ("before {", format("before {{"));
740 EXPECT_EQ("{ after", format("{{ after"));
741 EXPECT_EQ("before { after", format("before {{ after"));
742
743 EXPECT_EQ("}", format("}}"));
744 EXPECT_EQ("before }", format("before }}"));
745 EXPECT_EQ("} after", format("}} after"));
746 EXPECT_EQ("before } after", format("before }} after"));
747
748 EXPECT_EQ("{}", format("{{}}"));
749 EXPECT_EQ("{42}", format("{{{0}}}", 42));
750 }
751
TEST(FormatterTest,UnmatchedBraces)752 TEST(FormatterTest, UnmatchedBraces) {
753 EXPECT_THROW_MSG(format("{"), format_error, "invalid format string");
754 EXPECT_THROW_MSG(format("}"), format_error, "unmatched '}' in format string");
755 EXPECT_THROW_MSG(format("{0{}"), format_error, "invalid format string");
756 }
757
TEST(FormatterTest,NoArgs)758 TEST(FormatterTest, NoArgs) {
759 EXPECT_EQ("test", format("test"));
760 }
761
TEST(FormatterTest,ArgsInDifferentPositions)762 TEST(FormatterTest, ArgsInDifferentPositions) {
763 EXPECT_EQ("42", format("{0}", 42));
764 EXPECT_EQ("before 42", format("before {0}", 42));
765 EXPECT_EQ("42 after", format("{0} after", 42));
766 EXPECT_EQ("before 42 after", format("before {0} after", 42));
767 EXPECT_EQ("answer = 42", format("{0} = {1}", "answer", 42));
768 EXPECT_EQ("42 is the answer", format("{1} is the {0}", "answer", 42));
769 EXPECT_EQ("abracadabra", format("{0}{1}{0}", "abra", "cad"));
770 }
771
TEST(FormatterTest,ArgErrors)772 TEST(FormatterTest, ArgErrors) {
773 EXPECT_THROW_MSG(format("{"), format_error, "invalid format string");
774 EXPECT_THROW_MSG(format("{?}"), format_error, "invalid format string");
775 EXPECT_THROW_MSG(format("{0"), format_error, "invalid format string");
776 EXPECT_THROW_MSG(format("{0}"), format_error, "argument index out of range");
777 EXPECT_THROW_MSG(format("{00}", 42), format_error, "invalid format string");
778
779 char format_str[BUFFER_SIZE];
780 safe_sprintf(format_str, "{%u", INT_MAX);
781 EXPECT_THROW_MSG(format(format_str), format_error, "invalid format string");
782 safe_sprintf(format_str, "{%u}", INT_MAX);
783 EXPECT_THROW_MSG(format(format_str), format_error,
784 "argument index out of range");
785
786 safe_sprintf(format_str, "{%u", INT_MAX + 1u);
787 EXPECT_THROW_MSG(format(format_str), format_error, "number is too big");
788 safe_sprintf(format_str, "{%u}", INT_MAX + 1u);
789 EXPECT_THROW_MSG(format(format_str), format_error, "number is too big");
790 }
791
792 template <int N>
793 struct TestFormat {
794 template <typename... Args>
formatTestFormat795 static std::string format(fmt::string_view format_str, const Args &... args) {
796 return TestFormat<N - 1>::format(format_str, N - 1, args...);
797 }
798 };
799
800 template <>
801 struct TestFormat<0> {
802 template <typename... Args>
formatTestFormat803 static std::string format(fmt::string_view format_str, const Args &... args) {
804 return fmt::format(format_str, args...);
805 }
806 };
807
TEST(FormatterTest,ManyArgs)808 TEST(FormatterTest, ManyArgs) {
809 EXPECT_EQ("19", TestFormat<20>::format("{19}"));
810 EXPECT_THROW_MSG(TestFormat<20>::format("{20}"),
811 format_error, "argument index out of range");
812 EXPECT_THROW_MSG(TestFormat<21>::format("{21}"),
813 format_error, "argument index out of range");
814 enum { max_packed_args = fmt::internal::max_packed_args };
815 std::string format_str = fmt::format("{{{}}}", max_packed_args + 1);
816 EXPECT_THROW_MSG(TestFormat<max_packed_args>::format(format_str),
817 format_error, "argument index out of range");
818 }
819
TEST(FormatterTest,NamedArg)820 TEST(FormatterTest, NamedArg) {
821 EXPECT_EQ("1/a/A", format("{_1}/{a_}/{A_}", fmt::arg("a_", 'a'),
822 fmt::arg("A_", "A"), fmt::arg("_1", 1)));
823 EXPECT_THROW_MSG(format("{a}"), format_error, "argument not found");
824 EXPECT_EQ(" -42", format("{0:{width}}", -42, fmt::arg("width", 4)));
825 EXPECT_EQ("st", format("{0:.{precision}}", "str", fmt::arg("precision", 2)));
826 EXPECT_EQ("1 2", format("{} {two}", 1, fmt::arg("two", 2)));
827 EXPECT_EQ("42", format("{c}",
828 fmt::arg("a", 0), fmt::arg("b", 0), fmt::arg("c", 42), fmt::arg("d", 0),
829 fmt::arg("e", 0), fmt::arg("f", 0), fmt::arg("g", 0), fmt::arg("h", 0),
830 fmt::arg("i", 0), fmt::arg("j", 0), fmt::arg("k", 0), fmt::arg("l", 0),
831 fmt::arg("m", 0), fmt::arg("n", 0), fmt::arg("o", 0), fmt::arg("p", 0)));
832 }
833
TEST(FormatterTest,AutoArgIndex)834 TEST(FormatterTest, AutoArgIndex) {
835 EXPECT_EQ("abc", format("{}{}{}", 'a', 'b', 'c'));
836 EXPECT_THROW_MSG(format("{0}{}", 'a', 'b'),
837 format_error, "cannot switch from manual to automatic argument indexing");
838 EXPECT_THROW_MSG(format("{}{0}", 'a', 'b'),
839 format_error, "cannot switch from automatic to manual argument indexing");
840 EXPECT_EQ("1.2", format("{:.{}}", 1.2345, 2));
841 EXPECT_THROW_MSG(format("{0}:.{}", 1.2345, 2),
842 format_error, "cannot switch from manual to automatic argument indexing");
843 EXPECT_THROW_MSG(format("{:.{0}}", 1.2345, 2),
844 format_error, "cannot switch from automatic to manual argument indexing");
845 EXPECT_THROW_MSG(format("{}"), format_error, "argument index out of range");
846 }
847
TEST(FormatterTest,EmptySpecs)848 TEST(FormatterTest, EmptySpecs) {
849 EXPECT_EQ("42", format("{0:}", 42));
850 }
851
TEST(FormatterTest,LeftAlign)852 TEST(FormatterTest, LeftAlign) {
853 EXPECT_EQ("42 ", format("{0:<4}", 42));
854 EXPECT_EQ("42 ", format("{0:<4o}", 042));
855 EXPECT_EQ("42 ", format("{0:<4x}", 0x42));
856 EXPECT_EQ("-42 ", format("{0:<5}", -42));
857 EXPECT_EQ("42 ", format("{0:<5}", 42u));
858 EXPECT_EQ("-42 ", format("{0:<5}", -42l));
859 EXPECT_EQ("42 ", format("{0:<5}", 42ul));
860 EXPECT_EQ("-42 ", format("{0:<5}", -42ll));
861 EXPECT_EQ("42 ", format("{0:<5}", 42ull));
862 EXPECT_EQ("-42 ", format("{0:<5}", -42.0));
863 EXPECT_EQ("-42 ", format("{0:<5}", -42.0l));
864 EXPECT_EQ("c ", format("{0:<5}", 'c'));
865 EXPECT_EQ("abc ", format("{0:<5}", "abc"));
866 EXPECT_EQ("0xface ", format("{0:<8}", reinterpret_cast<void*>(0xface)));
867 }
868
TEST(FormatterTest,RightAlign)869 TEST(FormatterTest, RightAlign) {
870 EXPECT_EQ(" 42", format("{0:>4}", 42));
871 EXPECT_EQ(" 42", format("{0:>4o}", 042));
872 EXPECT_EQ(" 42", format("{0:>4x}", 0x42));
873 EXPECT_EQ(" -42", format("{0:>5}", -42));
874 EXPECT_EQ(" 42", format("{0:>5}", 42u));
875 EXPECT_EQ(" -42", format("{0:>5}", -42l));
876 EXPECT_EQ(" 42", format("{0:>5}", 42ul));
877 EXPECT_EQ(" -42", format("{0:>5}", -42ll));
878 EXPECT_EQ(" 42", format("{0:>5}", 42ull));
879 EXPECT_EQ(" -42", format("{0:>5}", -42.0));
880 EXPECT_EQ(" -42", format("{0:>5}", -42.0l));
881 EXPECT_EQ(" c", format("{0:>5}", 'c'));
882 EXPECT_EQ(" abc", format("{0:>5}", "abc"));
883 EXPECT_EQ(" 0xface", format("{0:>8}", reinterpret_cast<void*>(0xface)));
884 }
885
TEST(FormatterTest,NumericAlign)886 TEST(FormatterTest, NumericAlign) {
887 EXPECT_EQ(" 42", format("{0:=4}", 42));
888 EXPECT_EQ("+ 42", format("{0:=+4}", 42));
889 EXPECT_EQ(" 42", format("{0:=4o}", 042));
890 EXPECT_EQ("+ 42", format("{0:=+4o}", 042));
891 EXPECT_EQ(" 42", format("{0:=4x}", 0x42));
892 EXPECT_EQ("+ 42", format("{0:=+4x}", 0x42));
893 EXPECT_EQ("- 42", format("{0:=5}", -42));
894 EXPECT_EQ(" 42", format("{0:=5}", 42u));
895 EXPECT_EQ("- 42", format("{0:=5}", -42l));
896 EXPECT_EQ(" 42", format("{0:=5}", 42ul));
897 EXPECT_EQ("- 42", format("{0:=5}", -42ll));
898 EXPECT_EQ(" 42", format("{0:=5}", 42ull));
899 EXPECT_EQ("- 42", format("{0:=5}", -42.0));
900 EXPECT_EQ("- 42", format("{0:=5}", -42.0l));
901 EXPECT_THROW_MSG(format("{0:=5", 'c'),
902 format_error, "missing '}' in format string");
903 EXPECT_THROW_MSG(format("{0:=5}", 'c'),
904 format_error, "invalid format specifier for char");
905 EXPECT_THROW_MSG(format("{0:=5}", "abc"),
906 format_error, "format specifier requires numeric argument");
907 EXPECT_THROW_MSG(format("{0:=8}", reinterpret_cast<void*>(0xface)),
908 format_error, "format specifier requires numeric argument");
909 EXPECT_EQ(" 1", fmt::format("{:= }", 1.0));
910 }
911
TEST(FormatterTest,CenterAlign)912 TEST(FormatterTest, CenterAlign) {
913 EXPECT_EQ(" 42 ", format("{0:^5}", 42));
914 EXPECT_EQ(" 42 ", format("{0:^5o}", 042));
915 EXPECT_EQ(" 42 ", format("{0:^5x}", 0x42));
916 EXPECT_EQ(" -42 ", format("{0:^5}", -42));
917 EXPECT_EQ(" 42 ", format("{0:^5}", 42u));
918 EXPECT_EQ(" -42 ", format("{0:^5}", -42l));
919 EXPECT_EQ(" 42 ", format("{0:^5}", 42ul));
920 EXPECT_EQ(" -42 ", format("{0:^5}", -42ll));
921 EXPECT_EQ(" 42 ", format("{0:^5}", 42ull));
922 EXPECT_EQ(" -42 ", format("{0:^6}", -42.0));
923 EXPECT_EQ(" -42 ", format("{0:^5}", -42.0l));
924 EXPECT_EQ(" c ", format("{0:^5}", 'c'));
925 EXPECT_EQ(" abc ", format("{0:^6}", "abc"));
926 EXPECT_EQ(" 0xface ", format("{0:^8}", reinterpret_cast<void*>(0xface)));
927 }
928
TEST(FormatterTest,Fill)929 TEST(FormatterTest, Fill) {
930 EXPECT_THROW_MSG(format("{0:{<5}", 'c'),
931 format_error, "invalid fill character '{'");
932 EXPECT_THROW_MSG(format("{0:{<5}}", 'c'),
933 format_error, "invalid fill character '{'");
934 EXPECT_EQ("**42", format("{0:*>4}", 42));
935 EXPECT_EQ("**-42", format("{0:*>5}", -42));
936 EXPECT_EQ("***42", format("{0:*>5}", 42u));
937 EXPECT_EQ("**-42", format("{0:*>5}", -42l));
938 EXPECT_EQ("***42", format("{0:*>5}", 42ul));
939 EXPECT_EQ("**-42", format("{0:*>5}", -42ll));
940 EXPECT_EQ("***42", format("{0:*>5}", 42ull));
941 EXPECT_EQ("**-42", format("{0:*>5}", -42.0));
942 EXPECT_EQ("**-42", format("{0:*>5}", -42.0l));
943 EXPECT_EQ("c****", format("{0:*<5}", 'c'));
944 EXPECT_EQ("abc**", format("{0:*<5}", "abc"));
945 EXPECT_EQ("**0xface", format("{0:*>8}", reinterpret_cast<void*>(0xface)));
946 EXPECT_EQ("foo=", format("{:}=", "foo"));
947 EXPECT_EQ(std::string("\0\0\0*", 4), format(string_view("{:\0>4}", 6), '*'));
948 }
949
TEST(FormatterTest,PlusSign)950 TEST(FormatterTest, PlusSign) {
951 EXPECT_EQ("+42", format("{0:+}", 42));
952 EXPECT_EQ("-42", format("{0:+}", -42));
953 EXPECT_EQ("+42", format("{0:+}", 42));
954 EXPECT_THROW_MSG(format("{0:+}", 42u),
955 format_error, "format specifier requires signed argument");
956 EXPECT_EQ("+42", format("{0:+}", 42l));
957 EXPECT_THROW_MSG(format("{0:+}", 42ul),
958 format_error, "format specifier requires signed argument");
959 EXPECT_EQ("+42", format("{0:+}", 42ll));
960 EXPECT_THROW_MSG(format("{0:+}", 42ull),
961 format_error, "format specifier requires signed argument");
962 EXPECT_EQ("+42", format("{0:+}", 42.0));
963 EXPECT_EQ("+42", format("{0:+}", 42.0l));
964 EXPECT_THROW_MSG(format("{0:+", 'c'),
965 format_error, "missing '}' in format string");
966 EXPECT_THROW_MSG(format("{0:+}", 'c'),
967 format_error, "invalid format specifier for char");
968 EXPECT_THROW_MSG(format("{0:+}", "abc"),
969 format_error, "format specifier requires numeric argument");
970 EXPECT_THROW_MSG(format("{0:+}", reinterpret_cast<void*>(0x42)),
971 format_error, "format specifier requires numeric argument");
972 }
973
TEST(FormatterTest,MinusSign)974 TEST(FormatterTest, MinusSign) {
975 EXPECT_EQ("42", format("{0:-}", 42));
976 EXPECT_EQ("-42", format("{0:-}", -42));
977 EXPECT_EQ("42", format("{0:-}", 42));
978 EXPECT_THROW_MSG(format("{0:-}", 42u),
979 format_error, "format specifier requires signed argument");
980 EXPECT_EQ("42", format("{0:-}", 42l));
981 EXPECT_THROW_MSG(format("{0:-}", 42ul),
982 format_error, "format specifier requires signed argument");
983 EXPECT_EQ("42", format("{0:-}", 42ll));
984 EXPECT_THROW_MSG(format("{0:-}", 42ull),
985 format_error, "format specifier requires signed argument");
986 EXPECT_EQ("42", format("{0:-}", 42.0));
987 EXPECT_EQ("42", format("{0:-}", 42.0l));
988 EXPECT_THROW_MSG(format("{0:-", 'c'),
989 format_error, "missing '}' in format string");
990 EXPECT_THROW_MSG(format("{0:-}", 'c'),
991 format_error, "invalid format specifier for char");
992 EXPECT_THROW_MSG(format("{0:-}", "abc"),
993 format_error, "format specifier requires numeric argument");
994 EXPECT_THROW_MSG(format("{0:-}", reinterpret_cast<void*>(0x42)),
995 format_error, "format specifier requires numeric argument");
996 }
997
TEST(FormatterTest,SpaceSign)998 TEST(FormatterTest, SpaceSign) {
999 EXPECT_EQ(" 42", format("{0: }", 42));
1000 EXPECT_EQ("-42", format("{0: }", -42));
1001 EXPECT_EQ(" 42", format("{0: }", 42));
1002 EXPECT_THROW_MSG(format("{0: }", 42u),
1003 format_error, "format specifier requires signed argument");
1004 EXPECT_EQ(" 42", format("{0: }", 42l));
1005 EXPECT_THROW_MSG(format("{0: }", 42ul),
1006 format_error, "format specifier requires signed argument");
1007 EXPECT_EQ(" 42", format("{0: }", 42ll));
1008 EXPECT_THROW_MSG(format("{0: }", 42ull),
1009 format_error, "format specifier requires signed argument");
1010 EXPECT_EQ(" 42", format("{0: }", 42.0));
1011 EXPECT_EQ(" 42", format("{0: }", 42.0l));
1012 EXPECT_THROW_MSG(format("{0: ", 'c'),
1013 format_error, "missing '}' in format string");
1014 EXPECT_THROW_MSG(format("{0: }", 'c'),
1015 format_error, "invalid format specifier for char");
1016 EXPECT_THROW_MSG(format("{0: }", "abc"),
1017 format_error, "format specifier requires numeric argument");
1018 EXPECT_THROW_MSG(format("{0: }", reinterpret_cast<void*>(0x42)),
1019 format_error, "format specifier requires numeric argument");
1020 }
1021
TEST(FormatterTest,HashFlag)1022 TEST(FormatterTest, HashFlag) {
1023 EXPECT_EQ("42", format("{0:#}", 42));
1024 EXPECT_EQ("-42", format("{0:#}", -42));
1025 EXPECT_EQ("0b101010", format("{0:#b}", 42));
1026 EXPECT_EQ("0B101010", format("{0:#B}", 42));
1027 EXPECT_EQ("-0b101010", format("{0:#b}", -42));
1028 EXPECT_EQ("0x42", format("{0:#x}", 0x42));
1029 EXPECT_EQ("0X42", format("{0:#X}", 0x42));
1030 EXPECT_EQ("-0x42", format("{0:#x}", -0x42));
1031 EXPECT_EQ("042", format("{0:#o}", 042));
1032 EXPECT_EQ("-042", format("{0:#o}", -042));
1033 EXPECT_EQ("42", format("{0:#}", 42u));
1034 EXPECT_EQ("0x42", format("{0:#x}", 0x42u));
1035 EXPECT_EQ("042", format("{0:#o}", 042u));
1036
1037 EXPECT_EQ("-42", format("{0:#}", -42l));
1038 EXPECT_EQ("0x42", format("{0:#x}", 0x42l));
1039 EXPECT_EQ("-0x42", format("{0:#x}", -0x42l));
1040 EXPECT_EQ("042", format("{0:#o}", 042l));
1041 EXPECT_EQ("-042", format("{0:#o}", -042l));
1042 EXPECT_EQ("42", format("{0:#}", 42ul));
1043 EXPECT_EQ("0x42", format("{0:#x}", 0x42ul));
1044 EXPECT_EQ("042", format("{0:#o}", 042ul));
1045
1046 EXPECT_EQ("-42", format("{0:#}", -42ll));
1047 EXPECT_EQ("0x42", format("{0:#x}", 0x42ll));
1048 EXPECT_EQ("-0x42", format("{0:#x}", -0x42ll));
1049 EXPECT_EQ("042", format("{0:#o}", 042ll));
1050 EXPECT_EQ("-042", format("{0:#o}", -042ll));
1051 EXPECT_EQ("42", format("{0:#}", 42ull));
1052 EXPECT_EQ("0x42", format("{0:#x}", 0x42ull));
1053 EXPECT_EQ("042", format("{0:#o}", 042ull));
1054
1055 if (FMT_USE_GRISU)
1056 EXPECT_EQ("-42.0", format("{0:#}", -42.0));
1057 else
1058 EXPECT_EQ("-42.0000", format("{0:#}", -42.0));
1059 EXPECT_EQ("-42.0000", format("{0:#}", -42.0l));
1060 EXPECT_THROW_MSG(format("{0:#", 'c'),
1061 format_error, "missing '}' in format string");
1062 EXPECT_THROW_MSG(format("{0:#}", 'c'),
1063 format_error, "invalid format specifier for char");
1064 EXPECT_THROW_MSG(format("{0:#}", "abc"),
1065 format_error, "format specifier requires numeric argument");
1066 EXPECT_THROW_MSG(format("{0:#}", reinterpret_cast<void*>(0x42)),
1067 format_error, "format specifier requires numeric argument");
1068 }
1069
TEST(FormatterTest,ZeroFlag)1070 TEST(FormatterTest, ZeroFlag) {
1071 EXPECT_EQ("42", format("{0:0}", 42));
1072 EXPECT_EQ("-0042", format("{0:05}", -42));
1073 EXPECT_EQ("00042", format("{0:05}", 42u));
1074 EXPECT_EQ("-0042", format("{0:05}", -42l));
1075 EXPECT_EQ("00042", format("{0:05}", 42ul));
1076 EXPECT_EQ("-0042", format("{0:05}", -42ll));
1077 EXPECT_EQ("00042", format("{0:05}", 42ull));
1078 EXPECT_EQ("-0042", format("{0:05}", -42.0));
1079 EXPECT_EQ("-0042", format("{0:05}", -42.0l));
1080 EXPECT_THROW_MSG(format("{0:0", 'c'),
1081 format_error, "missing '}' in format string");
1082 EXPECT_THROW_MSG(format("{0:05}", 'c'),
1083 format_error, "invalid format specifier for char");
1084 EXPECT_THROW_MSG(format("{0:05}", "abc"),
1085 format_error, "format specifier requires numeric argument");
1086 EXPECT_THROW_MSG(format("{0:05}", reinterpret_cast<void*>(0x42)),
1087 format_error, "format specifier requires numeric argument");
1088 }
1089
TEST(FormatterTest,Width)1090 TEST(FormatterTest, Width) {
1091 char format_str[BUFFER_SIZE];
1092 safe_sprintf(format_str, "{0:%u", UINT_MAX);
1093 increment(format_str + 3);
1094 EXPECT_THROW_MSG(format(format_str, 0), format_error, "number is too big");
1095 std::size_t size = std::strlen(format_str);
1096 format_str[size] = '}';
1097 format_str[size + 1] = 0;
1098 EXPECT_THROW_MSG(format(format_str, 0), format_error, "number is too big");
1099
1100 safe_sprintf(format_str, "{0:%u", INT_MAX + 1u);
1101 EXPECT_THROW_MSG(format(format_str, 0), format_error, "number is too big");
1102 safe_sprintf(format_str, "{0:%u}", INT_MAX + 1u);
1103 EXPECT_THROW_MSG(format(format_str, 0), format_error, "number is too big");
1104 EXPECT_EQ(" -42", format("{0:4}", -42));
1105 EXPECT_EQ(" 42", format("{0:5}", 42u));
1106 EXPECT_EQ(" -42", format("{0:6}", -42l));
1107 EXPECT_EQ(" 42", format("{0:7}", 42ul));
1108 EXPECT_EQ(" -42", format("{0:6}", -42ll));
1109 EXPECT_EQ(" 42", format("{0:7}", 42ull));
1110 EXPECT_EQ(" -1.23", format("{0:8}", -1.23));
1111 EXPECT_EQ(" -1.23", format("{0:9}", -1.23l));
1112 EXPECT_EQ(" 0xcafe", format("{0:10}", reinterpret_cast<void*>(0xcafe)));
1113 EXPECT_EQ("x ", format("{0:11}", 'x'));
1114 EXPECT_EQ("str ", format("{0:12}", "str"));
1115 }
1116
TEST(FormatterTest,RuntimeWidth)1117 TEST(FormatterTest, RuntimeWidth) {
1118 char format_str[BUFFER_SIZE];
1119 safe_sprintf(format_str, "{0:{%u", UINT_MAX);
1120 increment(format_str + 4);
1121 EXPECT_THROW_MSG(format(format_str, 0), format_error, "number is too big");
1122 std::size_t size = std::strlen(format_str);
1123 format_str[size] = '}';
1124 format_str[size + 1] = 0;
1125 EXPECT_THROW_MSG(format(format_str, 0), format_error, "number is too big");
1126 format_str[size + 1] = '}';
1127 format_str[size + 2] = 0;
1128 EXPECT_THROW_MSG(format(format_str, 0), format_error, "number is too big");
1129
1130 EXPECT_THROW_MSG(format("{0:{", 0),
1131 format_error, "invalid format string");
1132 EXPECT_THROW_MSG(format("{0:{}", 0),
1133 format_error, "cannot switch from manual to automatic argument indexing");
1134 EXPECT_THROW_MSG(format("{0:{?}}", 0),
1135 format_error, "invalid format string");
1136 EXPECT_THROW_MSG(format("{0:{1}}", 0),
1137 format_error, "argument index out of range");
1138
1139 EXPECT_THROW_MSG(format("{0:{0:}}", 0),
1140 format_error, "invalid format string");
1141
1142 EXPECT_THROW_MSG(format("{0:{1}}", 0, -1),
1143 format_error, "negative width");
1144 EXPECT_THROW_MSG(format("{0:{1}}", 0, (INT_MAX + 1u)),
1145 format_error, "number is too big");
1146 EXPECT_THROW_MSG(format("{0:{1}}", 0, -1l),
1147 format_error, "negative width");
1148 if (fmt::internal::const_check(sizeof(long) > sizeof(int))) {
1149 long value = INT_MAX;
1150 EXPECT_THROW_MSG(format("{0:{1}}", 0, (value + 1)),
1151 format_error, "number is too big");
1152 }
1153 EXPECT_THROW_MSG(format("{0:{1}}", 0, (INT_MAX + 1ul)),
1154 format_error, "number is too big");
1155
1156 EXPECT_THROW_MSG(format("{0:{1}}", 0, '0'),
1157 format_error, "width is not integer");
1158 EXPECT_THROW_MSG(format("{0:{1}}", 0, 0.0),
1159 format_error, "width is not integer");
1160
1161 EXPECT_EQ(" -42", format("{0:{1}}", -42, 4));
1162 EXPECT_EQ(" 42", format("{0:{1}}", 42u, 5));
1163 EXPECT_EQ(" -42", format("{0:{1}}", -42l, 6));
1164 EXPECT_EQ(" 42", format("{0:{1}}", 42ul, 7));
1165 EXPECT_EQ(" -42", format("{0:{1}}", -42ll, 6));
1166 EXPECT_EQ(" 42", format("{0:{1}}", 42ull, 7));
1167 EXPECT_EQ(" -1.23", format("{0:{1}}", -1.23, 8));
1168 EXPECT_EQ(" -1.23", format("{0:{1}}", -1.23l, 9));
1169 EXPECT_EQ(" 0xcafe",
1170 format("{0:{1}}", reinterpret_cast<void*>(0xcafe), 10));
1171 EXPECT_EQ("x ", format("{0:{1}}", 'x', 11));
1172 EXPECT_EQ("str ", format("{0:{1}}", "str", 12));
1173 }
1174
TEST(FormatterTest,Precision)1175 TEST(FormatterTest, Precision) {
1176 char format_str[BUFFER_SIZE];
1177 safe_sprintf(format_str, "{0:.%u", UINT_MAX);
1178 increment(format_str + 4);
1179 EXPECT_THROW_MSG(format(format_str, 0), format_error, "number is too big");
1180 std::size_t size = std::strlen(format_str);
1181 format_str[size] = '}';
1182 format_str[size + 1] = 0;
1183 EXPECT_THROW_MSG(format(format_str, 0), format_error, "number is too big");
1184
1185 safe_sprintf(format_str, "{0:.%u", INT_MAX + 1u);
1186 EXPECT_THROW_MSG(format(format_str, 0), format_error, "number is too big");
1187 safe_sprintf(format_str, "{0:.%u}", INT_MAX + 1u);
1188 EXPECT_THROW_MSG(format(format_str, 0), format_error, "number is too big");
1189
1190 EXPECT_THROW_MSG(format("{0:.", 0),
1191 format_error, "missing precision specifier");
1192 EXPECT_THROW_MSG(format("{0:.}", 0),
1193 format_error, "missing precision specifier");
1194
1195 EXPECT_THROW_MSG(format("{0:.2", 0),
1196 format_error, "precision not allowed for this argument type");
1197 EXPECT_THROW_MSG(format("{0:.2}", 42),
1198 format_error, "precision not allowed for this argument type");
1199 EXPECT_THROW_MSG(format("{0:.2f}", 42),
1200 format_error, "precision not allowed for this argument type");
1201 EXPECT_THROW_MSG(format("{0:.2}", 42u),
1202 format_error, "precision not allowed for this argument type");
1203 EXPECT_THROW_MSG(format("{0:.2f}", 42u),
1204 format_error, "precision not allowed for this argument type");
1205 EXPECT_THROW_MSG(format("{0:.2}", 42l),
1206 format_error, "precision not allowed for this argument type");
1207 EXPECT_THROW_MSG(format("{0:.2f}", 42l),
1208 format_error, "precision not allowed for this argument type");
1209 EXPECT_THROW_MSG(format("{0:.2}", 42ul),
1210 format_error, "precision not allowed for this argument type");
1211 EXPECT_THROW_MSG(format("{0:.2f}", 42ul),
1212 format_error, "precision not allowed for this argument type");
1213 EXPECT_THROW_MSG(format("{0:.2}", 42ll),
1214 format_error, "precision not allowed for this argument type");
1215 EXPECT_THROW_MSG(format("{0:.2f}", 42ll),
1216 format_error, "precision not allowed for this argument type");
1217 EXPECT_THROW_MSG(format("{0:.2}", 42ull),
1218 format_error, "precision not allowed for this argument type");
1219 EXPECT_THROW_MSG(format("{0:.2f}", 42ull),
1220 format_error, "precision not allowed for this argument type");
1221 EXPECT_THROW_MSG(format("{0:3.0}", 'x'),
1222 format_error, "precision not allowed for this argument type");
1223 EXPECT_EQ("1.2", format("{0:.2}", 1.2345));
1224 EXPECT_EQ("1.2", format("{0:.2}", 1.2345l));
1225
1226 EXPECT_THROW_MSG(format("{0:.2}", reinterpret_cast<void*>(0xcafe)),
1227 format_error, "precision not allowed for this argument type");
1228 EXPECT_THROW_MSG(format("{0:.2f}", reinterpret_cast<void*>(0xcafe)),
1229 format_error, "precision not allowed for this argument type");
1230
1231 EXPECT_EQ("st", format("{0:.2}", "str"));
1232 }
1233
TEST(FormatterTest,RuntimePrecision)1234 TEST(FormatterTest, RuntimePrecision) {
1235 char format_str[BUFFER_SIZE];
1236 safe_sprintf(format_str, "{0:.{%u", UINT_MAX);
1237 increment(format_str + 5);
1238 EXPECT_THROW_MSG(format(format_str, 0), format_error, "number is too big");
1239 std::size_t size = std::strlen(format_str);
1240 format_str[size] = '}';
1241 format_str[size + 1] = 0;
1242 EXPECT_THROW_MSG(format(format_str, 0), format_error, "number is too big");
1243 format_str[size + 1] = '}';
1244 format_str[size + 2] = 0;
1245 EXPECT_THROW_MSG(format(format_str, 0), format_error, "number is too big");
1246
1247 EXPECT_THROW_MSG(format("{0:.{", 0),
1248 format_error, "invalid format string");
1249 EXPECT_THROW_MSG(format("{0:.{}", 0),
1250 format_error, "cannot switch from manual to automatic argument indexing");
1251 EXPECT_THROW_MSG(format("{0:.{?}}", 0),
1252 format_error, "invalid format string");
1253 EXPECT_THROW_MSG(format("{0:.{1}", 0, 0),
1254 format_error, "precision not allowed for this argument type");
1255 EXPECT_THROW_MSG(format("{0:.{1}}", 0),
1256 format_error, "argument index out of range");
1257
1258 EXPECT_THROW_MSG(format("{0:.{0:}}", 0),
1259 format_error, "invalid format string");
1260
1261 EXPECT_THROW_MSG(format("{0:.{1}}", 0, -1),
1262 format_error, "negative precision");
1263 EXPECT_THROW_MSG(format("{0:.{1}}", 0, (INT_MAX + 1u)),
1264 format_error, "number is too big");
1265 EXPECT_THROW_MSG(format("{0:.{1}}", 0, -1l),
1266 format_error, "negative precision");
1267 if (fmt::internal::const_check(sizeof(long) > sizeof(int))) {
1268 long value = INT_MAX;
1269 EXPECT_THROW_MSG(format("{0:.{1}}", 0, (value + 1)),
1270 format_error, "number is too big");
1271 }
1272 EXPECT_THROW_MSG(format("{0:.{1}}", 0, (INT_MAX + 1ul)),
1273 format_error, "number is too big");
1274
1275 EXPECT_THROW_MSG(format("{0:.{1}}", 0, '0'),
1276 format_error, "precision is not integer");
1277 EXPECT_THROW_MSG(format("{0:.{1}}", 0, 0.0),
1278 format_error, "precision is not integer");
1279
1280 EXPECT_THROW_MSG(format("{0:.{1}}", 42, 2),
1281 format_error, "precision not allowed for this argument type");
1282 EXPECT_THROW_MSG(format("{0:.{1}f}", 42, 2),
1283 format_error, "precision not allowed for this argument type");
1284 EXPECT_THROW_MSG(format("{0:.{1}}", 42u, 2),
1285 format_error, "precision not allowed for this argument type");
1286 EXPECT_THROW_MSG(format("{0:.{1}f}", 42u, 2),
1287 format_error, "precision not allowed for this argument type");
1288 EXPECT_THROW_MSG(format("{0:.{1}}", 42l, 2),
1289 format_error, "precision not allowed for this argument type");
1290 EXPECT_THROW_MSG(format("{0:.{1}f}", 42l, 2),
1291 format_error, "precision not allowed for this argument type");
1292 EXPECT_THROW_MSG(format("{0:.{1}}", 42ul, 2),
1293 format_error, "precision not allowed for this argument type");
1294 EXPECT_THROW_MSG(format("{0:.{1}f}", 42ul, 2),
1295 format_error, "precision not allowed for this argument type");
1296 EXPECT_THROW_MSG(format("{0:.{1}}", 42ll, 2),
1297 format_error, "precision not allowed for this argument type");
1298 EXPECT_THROW_MSG(format("{0:.{1}f}", 42ll, 2),
1299 format_error, "precision not allowed for this argument type");
1300 EXPECT_THROW_MSG(format("{0:.{1}}", 42ull, 2),
1301 format_error, "precision not allowed for this argument type");
1302 EXPECT_THROW_MSG(format("{0:.{1}f}", 42ull, 2),
1303 format_error, "precision not allowed for this argument type");
1304 EXPECT_THROW_MSG(format("{0:3.{1}}", 'x', 0),
1305 format_error, "precision not allowed for this argument type");
1306 EXPECT_EQ("1.2", format("{0:.{1}}", 1.2345, 2));
1307 EXPECT_EQ("1.2", format("{1:.{0}}", 2, 1.2345l));
1308
1309 EXPECT_THROW_MSG(format("{0:.{1}}", reinterpret_cast<void*>(0xcafe), 2),
1310 format_error, "precision not allowed for this argument type");
1311 EXPECT_THROW_MSG(format("{0:.{1}f}", reinterpret_cast<void*>(0xcafe), 2),
1312 format_error, "precision not allowed for this argument type");
1313
1314 EXPECT_EQ("st", format("{0:.{1}}", "str", 2));
1315 }
1316
1317 template <typename T>
check_unknown_types(const T & value,const char * types,const char *)1318 void check_unknown_types(const T &value, const char *types, const char *) {
1319 char format_str[BUFFER_SIZE];
1320 const char *special = ".0123456789}";
1321 for (int i = CHAR_MIN; i <= CHAR_MAX; ++i) {
1322 char c = static_cast<char>(i);
1323 if (std::strchr(types, c) || std::strchr(special, c) || !c) continue;
1324 safe_sprintf(format_str, "{0:10%c}", c);
1325 const char *message = "invalid type specifier";
1326 EXPECT_THROW_MSG(format(format_str, value), format_error, message)
1327 << format_str << " " << message;
1328 }
1329 }
1330
TEST(BoolTest,FormatBool)1331 TEST(BoolTest, FormatBool) {
1332 EXPECT_EQ("true", format("{}", true));
1333 EXPECT_EQ("false", format("{}", false));
1334 EXPECT_EQ("1", format("{:d}", true));
1335 EXPECT_EQ("true ", format("{:5}", true));
1336 EXPECT_EQ(L"true", format(L"{}", true));
1337 }
1338
TEST(FormatterTest,FormatShort)1339 TEST(FormatterTest, FormatShort) {
1340 short s = 42;
1341 EXPECT_EQ("42", format("{0:d}", s));
1342 unsigned short us = 42;
1343 EXPECT_EQ("42", format("{0:d}", us));
1344 }
1345
TEST(FormatterTest,FormatInt)1346 TEST(FormatterTest, FormatInt) {
1347 EXPECT_THROW_MSG(format("{0:v", 42),
1348 format_error, "missing '}' in format string");
1349 check_unknown_types(42, "bBdoxXn", "integer");
1350 }
1351
TEST(FormatterTest,FormatBin)1352 TEST(FormatterTest, FormatBin) {
1353 EXPECT_EQ("0", format("{0:b}", 0));
1354 EXPECT_EQ("101010", format("{0:b}", 42));
1355 EXPECT_EQ("101010", format("{0:b}", 42u));
1356 EXPECT_EQ("-101010", format("{0:b}", -42));
1357 EXPECT_EQ("11000000111001", format("{0:b}", 12345));
1358 EXPECT_EQ("10010001101000101011001111000", format("{0:b}", 0x12345678));
1359 EXPECT_EQ("10010000101010111100110111101111", format("{0:b}", 0x90ABCDEF));
1360 EXPECT_EQ("11111111111111111111111111111111",
1361 format("{0:b}", std::numeric_limits<uint32_t>::max()));
1362 }
1363
TEST(FormatterTest,FormatDec)1364 TEST(FormatterTest, FormatDec) {
1365 EXPECT_EQ("0", format("{0}", 0));
1366 EXPECT_EQ("42", format("{0}", 42));
1367 EXPECT_EQ("42", format("{0:d}", 42));
1368 EXPECT_EQ("42", format("{0}", 42u));
1369 EXPECT_EQ("-42", format("{0}", -42));
1370 EXPECT_EQ("12345", format("{0}", 12345));
1371 EXPECT_EQ("67890", format("{0}", 67890));
1372 char buffer[BUFFER_SIZE];
1373 safe_sprintf(buffer, "%d", INT_MIN);
1374 EXPECT_EQ(buffer, format("{0}", INT_MIN));
1375 safe_sprintf(buffer, "%d", INT_MAX);
1376 EXPECT_EQ(buffer, format("{0}", INT_MAX));
1377 safe_sprintf(buffer, "%u", UINT_MAX);
1378 EXPECT_EQ(buffer, format("{0}", UINT_MAX));
1379 safe_sprintf(buffer, "%ld", 0 - static_cast<unsigned long>(LONG_MIN));
1380 EXPECT_EQ(buffer, format("{0}", LONG_MIN));
1381 safe_sprintf(buffer, "%ld", LONG_MAX);
1382 EXPECT_EQ(buffer, format("{0}", LONG_MAX));
1383 safe_sprintf(buffer, "%lu", ULONG_MAX);
1384 EXPECT_EQ(buffer, format("{0}", ULONG_MAX));
1385 }
1386
TEST(FormatterTest,FormatHex)1387 TEST(FormatterTest, FormatHex) {
1388 EXPECT_EQ("0", format("{0:x}", 0));
1389 EXPECT_EQ("42", format("{0:x}", 0x42));
1390 EXPECT_EQ("42", format("{0:x}", 0x42u));
1391 EXPECT_EQ("-42", format("{0:x}", -0x42));
1392 EXPECT_EQ("12345678", format("{0:x}", 0x12345678));
1393 EXPECT_EQ("90abcdef", format("{0:x}", 0x90abcdef));
1394 EXPECT_EQ("12345678", format("{0:X}", 0x12345678));
1395 EXPECT_EQ("90ABCDEF", format("{0:X}", 0x90ABCDEF));
1396
1397 char buffer[BUFFER_SIZE];
1398 safe_sprintf(buffer, "-%x", 0 - static_cast<unsigned>(INT_MIN));
1399 EXPECT_EQ(buffer, format("{0:x}", INT_MIN));
1400 safe_sprintf(buffer, "%x", INT_MAX);
1401 EXPECT_EQ(buffer, format("{0:x}", INT_MAX));
1402 safe_sprintf(buffer, "%x", UINT_MAX);
1403 EXPECT_EQ(buffer, format("{0:x}", UINT_MAX));
1404 safe_sprintf(buffer, "-%lx", 0 - static_cast<unsigned long>(LONG_MIN));
1405 EXPECT_EQ(buffer, format("{0:x}", LONG_MIN));
1406 safe_sprintf(buffer, "%lx", LONG_MAX);
1407 EXPECT_EQ(buffer, format("{0:x}", LONG_MAX));
1408 safe_sprintf(buffer, "%lx", ULONG_MAX);
1409 EXPECT_EQ(buffer, format("{0:x}", ULONG_MAX));
1410 }
1411
TEST(FormatterTest,FormatOct)1412 TEST(FormatterTest, FormatOct) {
1413 EXPECT_EQ("0", format("{0:o}", 0));
1414 EXPECT_EQ("42", format("{0:o}", 042));
1415 EXPECT_EQ("42", format("{0:o}", 042u));
1416 EXPECT_EQ("-42", format("{0:o}", -042));
1417 EXPECT_EQ("12345670", format("{0:o}", 012345670));
1418 char buffer[BUFFER_SIZE];
1419 safe_sprintf(buffer, "-%o", 0 - static_cast<unsigned>(INT_MIN));
1420 EXPECT_EQ(buffer, format("{0:o}", INT_MIN));
1421 safe_sprintf(buffer, "%o", INT_MAX);
1422 EXPECT_EQ(buffer, format("{0:o}", INT_MAX));
1423 safe_sprintf(buffer, "%o", UINT_MAX);
1424 EXPECT_EQ(buffer, format("{0:o}", UINT_MAX));
1425 safe_sprintf(buffer, "-%lo", 0 - static_cast<unsigned long>(LONG_MIN));
1426 EXPECT_EQ(buffer, format("{0:o}", LONG_MIN));
1427 safe_sprintf(buffer, "%lo", LONG_MAX);
1428 EXPECT_EQ(buffer, format("{0:o}", LONG_MAX));
1429 safe_sprintf(buffer, "%lo", ULONG_MAX);
1430 EXPECT_EQ(buffer, format("{0:o}", ULONG_MAX));
1431 }
1432
TEST(FormatterTest,FormatIntLocale)1433 TEST(FormatterTest, FormatIntLocale) {
1434 EXPECT_EQ("123", format("{:n}", 123));
1435 EXPECT_EQ("1,234", format("{:n}", 1234));
1436 EXPECT_EQ("1,234,567", format("{:n}", 1234567));
1437 EXPECT_EQ("4,294,967,295",
1438 format("{:n}", std::numeric_limits<uint32_t>::max()));
1439 }
1440
1441 struct ConvertibleToLongLong {
operator long longConvertibleToLongLong1442 operator long long() const { return 1LL << 32; }
1443 };
1444
TEST(FormatterTest,FormatConvertibleToLongLong)1445 TEST(FormatterTest, FormatConvertibleToLongLong) {
1446 EXPECT_EQ("100000000", format("{:x}", ConvertibleToLongLong()));
1447 }
1448
TEST(FormatterTest,FormatFloat)1449 TEST(FormatterTest, FormatFloat) {
1450 EXPECT_EQ("392.500000", format("{0:f}", 392.5f));
1451 }
1452
TEST(FormatterTest,FormatDouble)1453 TEST(FormatterTest, FormatDouble) {
1454 check_unknown_types(1.2, "eEfFgGaA", "double");
1455 EXPECT_EQ("0", format("{:}", 0.0));
1456 EXPECT_EQ("0.000000", format("{:f}", 0.0));
1457 EXPECT_EQ("0", format("{:g}", 0.0));
1458 EXPECT_EQ("392.65", format("{:}", 392.65));
1459 EXPECT_EQ("392.65", format("{:g}", 392.65));
1460 EXPECT_EQ("392.65", format("{:G}", 392.65));
1461 EXPECT_EQ("392.650000", format("{:f}", 392.65));
1462 EXPECT_EQ("392.650000", format("{:F}", 392.65));
1463 char buffer[BUFFER_SIZE];
1464 safe_sprintf(buffer, "%e", 392.65);
1465 EXPECT_EQ(buffer, format("{0:e}", 392.65));
1466 safe_sprintf(buffer, "%E", 392.65);
1467 EXPECT_EQ(buffer, format("{0:E}", 392.65));
1468 EXPECT_EQ("+0000392.6", format("{0:+010.4g}", 392.65));
1469 safe_sprintf(buffer, "%a", -42.0);
1470 EXPECT_EQ(buffer, format("{:a}", -42.0));
1471 safe_sprintf(buffer, "%A", -42.0);
1472 EXPECT_EQ(buffer, format("{:A}", -42.0));
1473 }
1474
TEST(FormatterTest,FormatDoubleBigPrecision)1475 TEST(FormatterTest, FormatDoubleBigPrecision) {
1476 // sprintf with big precision is broken in MSVC2013, so only test on Grisu.
1477 if (FMT_USE_GRISU)
1478 EXPECT_EQ(format("0.{:0<1000}", ""), format("{:.1000f}", 0.0));
1479 }
1480
TEST(FormatterTest,FormatNaN)1481 TEST(FormatterTest, FormatNaN) {
1482 double nan = std::numeric_limits<double>::quiet_NaN();
1483 EXPECT_EQ("nan", format("{}", nan));
1484 EXPECT_EQ("+nan", format("{:+}", nan));
1485 EXPECT_EQ(" nan", format("{: }", nan));
1486 EXPECT_EQ("NAN", format("{:F}", nan));
1487 EXPECT_EQ("nan ", format("{:<7}", nan));
1488 EXPECT_EQ(" nan ", format("{:^7}", nan));
1489 EXPECT_EQ(" nan", format("{:>7}", nan));
1490 }
1491
TEST(FormatterTest,FormatInfinity)1492 TEST(FormatterTest, FormatInfinity) {
1493 double inf = std::numeric_limits<double>::infinity();
1494 EXPECT_EQ("inf", format("{}", inf));
1495 EXPECT_EQ("+inf", format("{:+}", inf));
1496 EXPECT_EQ("-inf", format("{}", -inf));
1497 EXPECT_EQ(" inf", format("{: }", inf));
1498 EXPECT_EQ("INF", format("{:F}", inf));
1499 EXPECT_EQ("inf ", format("{:<7}", inf));
1500 EXPECT_EQ(" inf ", format("{:^7}", inf));
1501 EXPECT_EQ(" inf", format("{:>7}", inf));
1502 }
1503
TEST(FormatterTest,FormatLongDouble)1504 TEST(FormatterTest, FormatLongDouble) {
1505 EXPECT_EQ("0", format("{0:}", 0.0l));
1506 EXPECT_EQ("0.000000", format("{0:f}", 0.0l));
1507 EXPECT_EQ("392.65", format("{0:}", 392.65l));
1508 EXPECT_EQ("392.65", format("{0:g}", 392.65l));
1509 EXPECT_EQ("392.65", format("{0:G}", 392.65l));
1510 EXPECT_EQ("392.650000", format("{0:f}", 392.65l));
1511 EXPECT_EQ("392.650000", format("{0:F}", 392.65l));
1512 char buffer[BUFFER_SIZE];
1513 safe_sprintf(buffer, "%Le", 392.65l);
1514 EXPECT_EQ(buffer, format("{0:e}", 392.65l));
1515 EXPECT_EQ("+0000392.6", format("{0:+010.4g}", 392.64l));
1516 }
1517
TEST(FormatterTest,FormatChar)1518 TEST(FormatterTest, FormatChar) {
1519 const char types[] = "cbBdoxXn";
1520 check_unknown_types('a', types, "char");
1521 EXPECT_EQ("a", format("{0}", 'a'));
1522 EXPECT_EQ("z", format("{0:c}", 'z'));
1523 EXPECT_EQ(L"a", format(L"{0}", 'a'));
1524 int n = 'x';
1525 for (const char *type = types + 1; *type; ++type) {
1526 std::string format_str = fmt::format("{{:{}}}", *type);
1527 EXPECT_EQ(fmt::format(format_str, n), fmt::format(format_str, 'x'));
1528 }
1529 EXPECT_EQ(fmt::format("{:02X}", n), fmt::format("{:02X}", 'x'));
1530 }
1531
TEST(FormatterTest,FormatUnsignedChar)1532 TEST(FormatterTest, FormatUnsignedChar) {
1533 EXPECT_EQ("42", format("{}", static_cast<unsigned char>(42)));
1534 EXPECT_EQ("42", format("{}", static_cast<uint8_t>(42)));
1535 }
1536
TEST(FormatterTest,FormatWChar)1537 TEST(FormatterTest, FormatWChar) {
1538 EXPECT_EQ(L"a", format(L"{0}", L'a'));
1539 // This shouldn't compile:
1540 //format("{}", L'a');
1541 }
1542
TEST(FormatterTest,FormatCString)1543 TEST(FormatterTest, FormatCString) {
1544 check_unknown_types("test", "sp", "string");
1545 EXPECT_EQ("test", format("{0}", "test"));
1546 EXPECT_EQ("test", format("{0:s}", "test"));
1547 char nonconst[] = "nonconst";
1548 EXPECT_EQ("nonconst", format("{0}", nonconst));
1549 EXPECT_THROW_MSG(format("{0}", static_cast<const char*>(FMT_NULL)),
1550 format_error, "string pointer is null");
1551 }
1552
TEST(FormatterTest,FormatSCharString)1553 TEST(FormatterTest, FormatSCharString) {
1554 signed char str[] = "test";
1555 EXPECT_EQ("test", format("{0:s}", str));
1556 const signed char *const_str = str;
1557 EXPECT_EQ("test", format("{0:s}", const_str));
1558 }
1559
TEST(FormatterTest,FormatUCharString)1560 TEST(FormatterTest, FormatUCharString) {
1561 unsigned char str[] = "test";
1562 EXPECT_EQ("test", format("{0:s}", str));
1563 const unsigned char *const_str = str;
1564 EXPECT_EQ("test", format("{0:s}", const_str));
1565 unsigned char *ptr = str;
1566 EXPECT_EQ("test", format("{0:s}", ptr));
1567 }
1568
TEST(FormatterTest,FormatPointer)1569 TEST(FormatterTest, FormatPointer) {
1570 check_unknown_types(reinterpret_cast<void*>(0x1234), "p", "pointer");
1571 EXPECT_EQ("0x0", format("{0}", static_cast<void*>(FMT_NULL)));
1572 EXPECT_EQ("0x1234", format("{0}", reinterpret_cast<void*>(0x1234)));
1573 EXPECT_EQ("0x1234", format("{0:p}", reinterpret_cast<void*>(0x1234)));
1574 EXPECT_EQ("0x" + std::string(sizeof(void*) * CHAR_BIT / 4, 'f'),
1575 format("{0}", reinterpret_cast<void*>(~uintptr_t())));
1576 EXPECT_EQ("0x1234", format("{}", fmt::ptr(reinterpret_cast<int*>(0x1234))));
1577 #if FMT_USE_NULLPTR
1578 EXPECT_EQ("0x0", format("{}", FMT_NULL));
1579 #endif
1580 }
1581
TEST(FormatterTest,FormatString)1582 TEST(FormatterTest, FormatString) {
1583 EXPECT_EQ("test", format("{0}", std::string("test")));
1584 }
1585
TEST(FormatterTest,FormatStringView)1586 TEST(FormatterTest, FormatStringView) {
1587 EXPECT_EQ("test", format("{}", string_view("test")));
1588 EXPECT_EQ("", format("{}", string_view()));
1589 }
1590
1591 #ifdef FMT_USE_STD_STRING_VIEW
TEST(FormatterTest,FormatStdStringView)1592 TEST(FormatterTest, FormatStdStringView) {
1593 EXPECT_EQ("test", format("{0}", std::string_view("test")));
1594 }
1595 #endif
1596
1597 FMT_BEGIN_NAMESPACE
1598 template <>
1599 struct formatter<Date> {
1600 template <typename ParseContext>
parseformatter1601 FMT_CONSTEXPR auto parse(ParseContext &ctx) -> decltype(ctx.begin()) {
1602 auto it = ctx.begin();
1603 if (*it == 'd')
1604 ++it;
1605 return it;
1606 }
1607
formatformatter1608 auto format(const Date &d, format_context &ctx) -> decltype(ctx.out()) {
1609 format_to(ctx.out(), "{}-{}-{}", d.year(), d.month(), d.day());
1610 return ctx.out();
1611 }
1612 };
1613 FMT_END_NAMESPACE
1614
TEST(FormatterTest,FormatCustom)1615 TEST(FormatterTest, FormatCustom) {
1616 Date date(2012, 12, 9);
1617 EXPECT_THROW_MSG(fmt::format("{:s}", date), format_error,
1618 "unknown format specifier");
1619 }
1620
1621 class Answer {};
1622
1623 FMT_BEGIN_NAMESPACE
1624 template <>
1625 struct formatter<Answer> : formatter<int> {
1626 template <typename FormatContext>
formatformatter1627 auto format(Answer, FormatContext &ctx) -> decltype(ctx.out()) {
1628 return formatter<int>::format(42, ctx);
1629 }
1630 };
1631 FMT_END_NAMESPACE
1632
TEST(FormatterTest,CustomFormat)1633 TEST(FormatterTest, CustomFormat) {
1634 EXPECT_EQ("42", format("{0}", Answer()));
1635 EXPECT_EQ("0042", format("{:04}", Answer()));
1636 }
1637
TEST(FormatterTest,CustomFormatTo)1638 TEST(FormatterTest, CustomFormatTo) {
1639 char buf[10] = {};
1640 auto end = &*fmt::format_to(
1641 fmt::internal::make_checked(buf, 10), "{}", Answer());
1642 EXPECT_EQ(end, buf + 2);
1643 EXPECT_STREQ(buf, "42");
1644 }
1645
TEST(FormatterTest,WideFormatString)1646 TEST(FormatterTest, WideFormatString) {
1647 EXPECT_EQ(L"42", format(L"{}", 42));
1648 EXPECT_EQ(L"4.2", format(L"{}", 4.2));
1649 EXPECT_EQ(L"abc", format(L"{}", L"abc"));
1650 EXPECT_EQ(L"z", format(L"{}", L'z'));
1651 }
1652
TEST(FormatterTest,FormatStringFromSpeedTest)1653 TEST(FormatterTest, FormatStringFromSpeedTest) {
1654 EXPECT_EQ("1.2340000000:0042:+3.13:str:0x3e8:X:%",
1655 format("{0:0.10f}:{1:04}:{2:+g}:{3}:{4}:{5}:%",
1656 1.234, 42, 3.13, "str", reinterpret_cast<void*>(1000), 'X'));
1657 }
1658
TEST(FormatterTest,FormatExamples)1659 TEST(FormatterTest, FormatExamples) {
1660 std::string message = format("The answer is {}", 42);
1661 EXPECT_EQ("The answer is 42", message);
1662
1663 EXPECT_EQ("42", format("{}", 42));
1664 EXPECT_EQ("42", format(std::string("{}"), 42));
1665
1666 memory_buffer out;
1667 format_to(out, "The answer is {}.", 42);
1668 EXPECT_EQ("The answer is 42.", to_string(out));
1669
1670 const char *filename = "nonexistent";
1671 FILE *ftest = safe_fopen(filename, "r");
1672 if (ftest) fclose(ftest);
1673 int error_code = errno;
1674 EXPECT_TRUE(ftest == FMT_NULL);
1675 EXPECT_SYSTEM_ERROR({
1676 FILE *f = safe_fopen(filename, "r");
1677 if (!f)
1678 throw fmt::system_error(errno, "Cannot open file '{}'", filename);
1679 fclose(f);
1680 }, error_code, "Cannot open file 'nonexistent'");
1681 }
1682
TEST(FormatterTest,Examples)1683 TEST(FormatterTest, Examples) {
1684 EXPECT_EQ("First, thou shalt count to three",
1685 format("First, thou shalt count to {0}", "three"));
1686 EXPECT_EQ("Bring me a shrubbery",
1687 format("Bring me a {}", "shrubbery"));
1688 EXPECT_EQ("From 1 to 3", format("From {} to {}", 1, 3));
1689
1690 char buffer[BUFFER_SIZE];
1691 safe_sprintf(buffer, "%03.2f", -1.2);
1692 EXPECT_EQ(buffer, format("{:03.2f}", -1.2));
1693
1694 EXPECT_EQ("a, b, c", format("{0}, {1}, {2}", 'a', 'b', 'c'));
1695 EXPECT_EQ("a, b, c", format("{}, {}, {}", 'a', 'b', 'c'));
1696 EXPECT_EQ("c, b, a", format("{2}, {1}, {0}", 'a', 'b', 'c'));
1697 EXPECT_EQ("abracadabra", format("{0}{1}{0}", "abra", "cad"));
1698
1699 EXPECT_EQ("left aligned ",
1700 format("{:<30}", "left aligned"));
1701 EXPECT_EQ(" right aligned",
1702 format("{:>30}", "right aligned"));
1703 EXPECT_EQ(" centered ",
1704 format("{:^30}", "centered"));
1705 EXPECT_EQ("***********centered***********",
1706 format("{:*^30}", "centered"));
1707
1708 EXPECT_EQ("+3.140000; -3.140000",
1709 format("{:+f}; {:+f}", 3.14, -3.14));
1710 EXPECT_EQ(" 3.140000; -3.140000",
1711 format("{: f}; {: f}", 3.14, -3.14));
1712 EXPECT_EQ("3.140000; -3.140000",
1713 format("{:-f}; {:-f}", 3.14, -3.14));
1714
1715 EXPECT_EQ("int: 42; hex: 2a; oct: 52",
1716 format("int: {0:d}; hex: {0:x}; oct: {0:o}", 42));
1717 EXPECT_EQ("int: 42; hex: 0x2a; oct: 052",
1718 format("int: {0:d}; hex: {0:#x}; oct: {0:#o}", 42));
1719
1720 EXPECT_EQ("The answer is 42", format("The answer is {}", 42));
1721 EXPECT_THROW_MSG(
1722 format("The answer is {:d}", "forty-two"), format_error,
1723 "invalid type specifier");
1724
1725 EXPECT_EQ(L"Cyrillic letter \x42e",
1726 format(L"Cyrillic letter {}", L'\x42e'));
1727
1728 EXPECT_WRITE(stdout,
1729 fmt::print("{}", std::numeric_limits<double>::infinity()), "inf");
1730 }
1731
TEST(FormatIntTest,Data)1732 TEST(FormatIntTest, Data) {
1733 fmt::format_int format_int(42);
1734 EXPECT_EQ("42", std::string(format_int.data(), format_int.size()));
1735 }
1736
TEST(FormatIntTest,FormatInt)1737 TEST(FormatIntTest, FormatInt) {
1738 EXPECT_EQ("42", fmt::format_int(42).str());
1739 EXPECT_EQ(2u, fmt::format_int(42).size());
1740 EXPECT_EQ("-42", fmt::format_int(-42).str());
1741 EXPECT_EQ(3u, fmt::format_int(-42).size());
1742 EXPECT_EQ("42", fmt::format_int(42ul).str());
1743 EXPECT_EQ("-42", fmt::format_int(-42l).str());
1744 EXPECT_EQ("42", fmt::format_int(42ull).str());
1745 EXPECT_EQ("-42", fmt::format_int(-42ll).str());
1746 std::ostringstream os;
1747 os << std::numeric_limits<int64_t>::max();
1748 EXPECT_EQ(os.str(),
1749 fmt::format_int(std::numeric_limits<int64_t>::max()).str());
1750 }
1751
1752 template <typename T>
format_decimal(T value)1753 std::string format_decimal(T value) {
1754 char buffer[10];
1755 char *ptr = buffer;
1756 fmt::format_decimal(ptr, value);
1757 return std::string(buffer, ptr);
1758 }
1759
TEST(FormatIntTest,FormatDec)1760 TEST(FormatIntTest, FormatDec) {
1761 EXPECT_EQ("-42", format_decimal(static_cast<signed char>(-42)));
1762 EXPECT_EQ("-42", format_decimal(static_cast<short>(-42)));
1763 std::ostringstream os;
1764 os << std::numeric_limits<unsigned short>::max();
1765 EXPECT_EQ(os.str(),
1766 format_decimal(std::numeric_limits<unsigned short>::max()));
1767 EXPECT_EQ("1", format_decimal(1));
1768 EXPECT_EQ("-1", format_decimal(-1));
1769 EXPECT_EQ("42", format_decimal(42));
1770 EXPECT_EQ("-42", format_decimal(-42));
1771 EXPECT_EQ("42", format_decimal(42l));
1772 EXPECT_EQ("42", format_decimal(42ul));
1773 EXPECT_EQ("42", format_decimal(42ll));
1774 EXPECT_EQ("42", format_decimal(42ull));
1775 }
1776
TEST(FormatTest,Print)1777 TEST(FormatTest, Print) {
1778 #if FMT_USE_FILE_DESCRIPTORS
1779 EXPECT_WRITE(stdout, fmt::print("Don't {}!", "panic"), "Don't panic!");
1780 EXPECT_WRITE(stderr,
1781 fmt::print(stderr, "Don't {}!", "panic"), "Don't panic!");
1782 #endif
1783 }
1784
TEST(FormatTest,Variadic)1785 TEST(FormatTest, Variadic) {
1786 EXPECT_EQ("abc1", format("{}c{}", "ab", 1));
1787 EXPECT_EQ(L"abc1", format(L"{}c{}", L"ab", 1));
1788 }
1789
TEST(FormatTest,Dynamic)1790 TEST(FormatTest, Dynamic) {
1791 typedef fmt::format_context ctx;
1792 std::vector<fmt::basic_format_arg<ctx>> args;
1793 args.emplace_back(fmt::internal::make_arg<ctx>(42));
1794 args.emplace_back(fmt::internal::make_arg<ctx>("abc1"));
1795 args.emplace_back(fmt::internal::make_arg<ctx>(1.2f));
1796
1797 std::string result = fmt::vformat("{} and {} and {}",
1798 fmt::basic_format_args<ctx>(
1799 args.data(),
1800 static_cast<unsigned>(args.size())));
1801
1802 EXPECT_EQ("42 and abc1 and 1.2", result);
1803 }
1804
TEST(FormatTest,JoinArg)1805 TEST(FormatTest, JoinArg) {
1806 using fmt::join;
1807 int v1[3] = { 1, 2, 3 };
1808 std::vector<float> v2;
1809 v2.push_back(1.2f);
1810 v2.push_back(3.4f);
1811 void *v3[2] = { &v1[0], &v1[1] };
1812
1813 EXPECT_EQ("(1, 2, 3)", format("({})", join(v1, v1 + 3, ", ")));
1814 EXPECT_EQ("(1)", format("({})", join(v1, v1 + 1, ", ")));
1815 EXPECT_EQ("()", format("({})", join(v1, v1, ", ")));
1816 EXPECT_EQ("(001, 002, 003)", format("({:03})", join(v1, v1 + 3, ", ")));
1817 EXPECT_EQ("(+01.20, +03.40)",
1818 format("({:+06.2f})", join(v2.begin(), v2.end(), ", ")));
1819
1820 EXPECT_EQ(L"(1, 2, 3)", format(L"({})", join(v1, v1 + 3, L", ")));
1821 EXPECT_EQ("1, 2, 3", format("{0:{1}}", join(v1, v1 + 3, ", "), 1));
1822
1823 EXPECT_EQ(format("{}, {}", v3[0], v3[1]),
1824 format("{}", join(v3, v3 + 2, ", ")));
1825
1826 #if FMT_USE_TRAILING_RETURN && (!FMT_GCC_VERSION || FMT_GCC_VERSION >= 405)
1827 EXPECT_EQ("(1, 2, 3)", format("({})", join(v1, ", ")));
1828 EXPECT_EQ("(+01.20, +03.40)", format("({:+06.2f})", join(v2, ", ")));
1829 #endif
1830 }
1831
1832 template <typename T>
str(const T & value)1833 std::string str(const T &value) {
1834 return fmt::format("{}", value);
1835 }
1836
TEST(StrTest,Convert)1837 TEST(StrTest, Convert) {
1838 EXPECT_EQ("42", str(42));
1839 std::string s = str(Date(2012, 12, 9));
1840 EXPECT_EQ("2012-12-9", s);
1841 }
1842
vformat_message(int id,const char * format,fmt::format_args args)1843 std::string vformat_message(int id, const char *format, fmt::format_args args) {
1844 fmt::memory_buffer buffer;
1845 format_to(buffer, "[{}] ", id);
1846 vformat_to(buffer, format, args);
1847 return to_string(buffer);
1848 }
1849
1850 template <typename... Args>
format_message(int id,const char * format,const Args &...args)1851 std::string format_message(int id, const char *format, const Args & ... args) {
1852 auto va = fmt::make_format_args(args...);
1853 return vformat_message(id, format, va);
1854 }
1855
TEST(FormatTest,FormatMessageExample)1856 TEST(FormatTest, FormatMessageExample) {
1857 EXPECT_EQ("[42] something happened",
1858 format_message(42, "{} happened", "something"));
1859 }
1860
1861 template<typename... Args>
print_error(const char * file,int line,const char * format,const Args &...args)1862 void print_error(const char *file, int line, const char *format,
1863 const Args & ... args) {
1864 fmt::print("{}: {}: ", file, line);
1865 fmt::print(format, args...);
1866 }
1867
TEST(FormatTest,UnpackedArgs)1868 TEST(FormatTest, UnpackedArgs) {
1869 EXPECT_EQ("0123456789abcdefg",
1870 fmt::format("{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}",
1871 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 'a', 'b', 'c', 'd', 'e',
1872 'f', 'g'));
1873 }
1874
1875 #if FMT_USE_USER_DEFINED_LITERALS
1876 // Passing user-defined literals directly to EXPECT_EQ causes problems
1877 // with macro argument stringification (#) on some versions of GCC.
1878 // Workaround: Assing the UDL result to a variable before the macro.
1879
1880 using namespace fmt::literals;
1881
TEST(LiteralsTest,Format)1882 TEST(LiteralsTest, Format) {
1883 auto udl_format = "{}c{}"_format("ab", 1);
1884 EXPECT_EQ(format("{}c{}", "ab", 1), udl_format);
1885 auto udl_format_w = L"{}c{}"_format(L"ab", 1);
1886 EXPECT_EQ(format(L"{}c{}", L"ab", 1), udl_format_w);
1887 }
1888
TEST(LiteralsTest,NamedArg)1889 TEST(LiteralsTest, NamedArg) {
1890 auto udl_a = format("{first}{second}{first}{third}",
1891 "first"_a="abra", "second"_a="cad", "third"_a=99);
1892 EXPECT_EQ(format("{first}{second}{first}{third}",
1893 fmt::arg("first", "abra"), fmt::arg("second", "cad"),
1894 fmt::arg("third", 99)),
1895 udl_a);
1896 auto udl_a_w = format(L"{first}{second}{first}{third}",
1897 L"first"_a=L"abra", L"second"_a=L"cad", L"third"_a=99);
1898 EXPECT_EQ(format(L"{first}{second}{first}{third}",
1899 fmt::arg(L"first", L"abra"), fmt::arg(L"second", L"cad"),
1900 fmt::arg(L"third", 99)),
1901 udl_a_w);
1902 }
1903
TEST(FormatTest,UdlTemplate)1904 TEST(FormatTest, UdlTemplate) {
1905 EXPECT_EQ("foo", "foo"_format());
1906 EXPECT_EQ(" 42", "{0:10}"_format(42));
1907 EXPECT_EQ("42", fmt::format(FMT_STRING("{}"), 42));
1908 EXPECT_EQ(L"42", fmt::format(FMT_STRING(L"{}"), 42));
1909 }
1910 #endif // FMT_USE_USER_DEFINED_LITERALS
1911
1912 enum TestEnum { A };
1913
TEST(FormatTest,Enum)1914 TEST(FormatTest, Enum) {
1915 EXPECT_EQ("0", fmt::format("{}", A));
1916 }
1917
TEST(FormatTest,EnumFormatterUnambiguous)1918 TEST(FormatTest, EnumFormatterUnambiguous) {
1919 fmt::formatter<TestEnum> f;
1920 ASSERT_GE(sizeof(f), 0); // use f to avoid compiler warning
1921 }
1922
1923 #if FMT_HAS_FEATURE(cxx_strong_enums)
1924 enum TestFixedEnum : short { B };
1925
TEST(FormatTest,FixedEnum)1926 TEST(FormatTest, FixedEnum) {
1927 EXPECT_EQ("0", fmt::format("{}", B));
1928 }
1929 #endif
1930
1931 typedef fmt::back_insert_range<fmt::internal::buffer> buffer_range;
1932
1933 class mock_arg_formatter:
1934 public fmt::internal::function<
1935 fmt::internal::arg_formatter_base<buffer_range>::iterator>,
1936 public fmt::internal::arg_formatter_base<buffer_range> {
1937 private:
1938 MOCK_METHOD1(call, void (long long value));
1939
1940 public:
1941 typedef fmt::internal::arg_formatter_base<buffer_range> base;
1942 typedef buffer_range range;
1943
mock_arg_formatter(fmt::format_context & ctx,fmt::format_specs * s=FMT_NULL)1944 mock_arg_formatter(fmt::format_context &ctx, fmt::format_specs *s = FMT_NULL)
1945 : base(fmt::internal::get_container(ctx.out()), s, ctx.locale()) {
1946 EXPECT_CALL(*this, call(42));
1947 }
1948
1949 template <typename T>
1950 typename std::enable_if<std::is_integral<T>::value, iterator>::type
operator ()(T value)1951 operator()(T value) {
1952 call(value);
1953 return base::operator()(value);
1954 }
1955
1956 template <typename T>
1957 typename std::enable_if<!std::is_integral<T>::value, iterator>::type
operator ()(T value)1958 operator()(T value) {
1959 return base::operator()(value);
1960 }
1961
operator ()(fmt::basic_format_arg<fmt::format_context>::handle)1962 iterator operator()(fmt::basic_format_arg<fmt::format_context>::handle) {
1963 return base::operator()(fmt::monostate());
1964 }
1965 };
1966
custom_vformat(fmt::string_view format_str,fmt::format_args args)1967 static void custom_vformat(fmt::string_view format_str, fmt::format_args args) {
1968 fmt::memory_buffer buffer;
1969 fmt::vformat_to<mock_arg_formatter>(buffer, format_str, args);
1970 }
1971
1972 template <typename... Args>
custom_format(const char * format_str,const Args &...args)1973 void custom_format(const char *format_str, const Args & ... args) {
1974 auto va = fmt::make_format_args(args...);
1975 return custom_vformat(format_str, va);
1976 }
1977
TEST(FormatTest,CustomArgFormatter)1978 TEST(FormatTest, CustomArgFormatter) {
1979 custom_format("{}", 42);
1980 }
1981
TEST(FormatTest,NonNullTerminatedFormatString)1982 TEST(FormatTest, NonNullTerminatedFormatString) {
1983 EXPECT_EQ("42", format(string_view("{}foo", 2), 42));
1984 }
1985
1986 struct variant {
1987 enum {INT, STRING} type;
variantvariant1988 explicit variant(int) : type(INT) {}
variantvariant1989 explicit variant(const char *) : type(STRING) {}
1990 };
1991
1992 FMT_BEGIN_NAMESPACE
1993 template <>
1994 struct formatter<variant> : dynamic_formatter<> {
formatformatter1995 auto format(variant value, format_context& ctx) -> decltype(ctx.out()) {
1996 if (value.type == variant::INT)
1997 return dynamic_formatter<>::format(42, ctx);
1998 return dynamic_formatter<>::format("foo", ctx);
1999 }
2000 };
2001 FMT_END_NAMESPACE
2002
TEST(FormatTest,DynamicFormatter)2003 TEST(FormatTest, DynamicFormatter) {
2004 auto num = variant(42);
2005 auto str = variant("foo");
2006 EXPECT_EQ("42", format("{:d}", num));
2007 EXPECT_EQ("foo", format("{:s}", str));
2008 EXPECT_EQ(" 42 foo ", format("{:{}} {:{}}", num, 3, str, 4));
2009 EXPECT_THROW_MSG(format("{0:{}}", num),
2010 format_error, "cannot switch from manual to automatic argument indexing");
2011 EXPECT_THROW_MSG(format("{:{0}}", num),
2012 format_error, "cannot switch from automatic to manual argument indexing");
2013 EXPECT_THROW_MSG(format("{:=}", str),
2014 format_error, "format specifier requires numeric argument");
2015 EXPECT_THROW_MSG(format("{:+}", str),
2016 format_error, "format specifier requires numeric argument");
2017 EXPECT_THROW_MSG(format("{:-}", str),
2018 format_error, "format specifier requires numeric argument");
2019 EXPECT_THROW_MSG(format("{: }", str),
2020 format_error, "format specifier requires numeric argument");
2021 EXPECT_THROW_MSG(format("{:#}", str),
2022 format_error, "format specifier requires numeric argument");
2023 EXPECT_THROW_MSG(format("{:0}", str),
2024 format_error, "format specifier requires numeric argument");
2025 EXPECT_THROW_MSG(format("{:.2}", num),
2026 format_error, "precision not allowed for this argument type");
2027 }
2028
TEST(FormatTest,ToString)2029 TEST(FormatTest, ToString) {
2030 EXPECT_EQ("42", fmt::to_string(42));
2031 EXPECT_EQ("0x1234", fmt::to_string(reinterpret_cast<void*>(0x1234)));
2032 }
2033
TEST(FormatTest,ToWString)2034 TEST(FormatTest, ToWString) {
2035 EXPECT_EQ(L"42", fmt::to_wstring(42));
2036 }
2037
TEST(FormatTest,OutputIterators)2038 TEST(FormatTest, OutputIterators) {
2039 std::list<char> out;
2040 fmt::format_to(std::back_inserter(out), "{}", 42);
2041 EXPECT_EQ("42", std::string(out.begin(), out.end()));
2042 std::stringstream s;
2043 fmt::format_to(std::ostream_iterator<char>(s), "{}", 42);
2044 EXPECT_EQ("42", s.str());
2045 }
2046
TEST(FormatTest,FormattedSize)2047 TEST(FormatTest, FormattedSize) {
2048 EXPECT_EQ(2u, fmt::formatted_size("{}", 42));
2049 }
2050
TEST(FormatTest,FormatToN)2051 TEST(FormatTest, FormatToN) {
2052 char buffer[4];
2053 buffer[3] = 'x';
2054 auto result = fmt::format_to_n(buffer, 3, "{}", 12345);
2055 EXPECT_EQ(5u, result.size);
2056 EXPECT_EQ(buffer + 3, result.out);
2057 EXPECT_EQ("123x", fmt::string_view(buffer, 4));
2058 result = fmt::format_to_n(buffer, 3, "{:s}", "foobar");
2059 EXPECT_EQ(6u, result.size);
2060 EXPECT_EQ(buffer + 3, result.out);
2061 EXPECT_EQ("foox", fmt::string_view(buffer, 4));
2062 }
2063
TEST(FormatTest,WideFormatToN)2064 TEST(FormatTest, WideFormatToN) {
2065 wchar_t buffer[4];
2066 buffer[3] = L'x';
2067 auto result = fmt::format_to_n(buffer, 3, L"{}", 12345);
2068 EXPECT_EQ(5u, result.size);
2069 EXPECT_EQ(buffer + 3, result.out);
2070 EXPECT_EQ(L"123x", fmt::wstring_view(buffer, 4));
2071 }
2072
2073 #if FMT_USE_CONSTEXPR
2074 struct test_arg_id_handler {
2075 enum result { NONE, EMPTY, INDEX, NAME, ERROR };
2076 result res = NONE;
2077 unsigned index = 0;
2078 string_view name;
2079
operator ()test_arg_id_handler2080 FMT_CONSTEXPR void operator()() { res = EMPTY; }
2081
operator ()test_arg_id_handler2082 FMT_CONSTEXPR void operator()(unsigned i) {
2083 res = INDEX;
2084 index = i;
2085 }
2086
operator ()test_arg_id_handler2087 FMT_CONSTEXPR void operator()(string_view n) {
2088 res = NAME;
2089 name = n;
2090 }
2091
on_errortest_arg_id_handler2092 FMT_CONSTEXPR void on_error(const char *) { res = ERROR; }
2093 };
2094
2095 template <size_t N>
parse_arg_id(const char (& s)[N])2096 FMT_CONSTEXPR test_arg_id_handler parse_arg_id(const char (&s)[N]) {
2097 test_arg_id_handler h;
2098 fmt::internal::parse_arg_id(s, s + N, h);
2099 return h;
2100 }
2101
TEST(FormatTest,ConstexprParseArgID)2102 TEST(FormatTest, ConstexprParseArgID) {
2103 static_assert(parse_arg_id(":").res == test_arg_id_handler::EMPTY, "");
2104 static_assert(parse_arg_id("}").res == test_arg_id_handler::EMPTY, "");
2105 static_assert(parse_arg_id("42:").res == test_arg_id_handler::INDEX, "");
2106 static_assert(parse_arg_id("42:").index == 42, "");
2107 static_assert(parse_arg_id("foo:").res == test_arg_id_handler::NAME, "");
2108 static_assert(parse_arg_id("foo:").name.size() == 3, "");
2109 static_assert(parse_arg_id("!").res == test_arg_id_handler::ERROR, "");
2110 }
2111
2112 struct test_format_specs_handler {
2113 enum Result { NONE, PLUS, MINUS, SPACE, HASH, ZERO, ERROR };
2114 Result res = NONE;
2115
2116 fmt::alignment align_ = fmt::ALIGN_DEFAULT;
2117 char fill = 0;
2118 unsigned width = 0;
2119 fmt::internal::arg_ref<char> width_ref;
2120 unsigned precision = 0;
2121 fmt::internal::arg_ref<char> precision_ref;
2122 char type = 0;
2123
2124 // Workaround for MSVC2017 bug that results in "expression did not evaluate
2125 // to a constant" with compiler-generated copy ctor.
test_format_specs_handlertest_format_specs_handler2126 FMT_CONSTEXPR test_format_specs_handler() {}
test_format_specs_handlertest_format_specs_handler2127 FMT_CONSTEXPR test_format_specs_handler(const test_format_specs_handler &other)
2128 : res(other.res), align_(other.align_), fill(other.fill),
2129 width(other.width), width_ref(other.width_ref),
2130 precision(other.precision), precision_ref(other.precision_ref),
2131 type(other.type) {}
2132
on_aligntest_format_specs_handler2133 FMT_CONSTEXPR void on_align(fmt::alignment a) { align_ = a; }
on_filltest_format_specs_handler2134 FMT_CONSTEXPR void on_fill(char f) { fill = f; }
on_plustest_format_specs_handler2135 FMT_CONSTEXPR void on_plus() { res = PLUS; }
on_minustest_format_specs_handler2136 FMT_CONSTEXPR void on_minus() { res = MINUS; }
on_spacetest_format_specs_handler2137 FMT_CONSTEXPR void on_space() { res = SPACE; }
on_hashtest_format_specs_handler2138 FMT_CONSTEXPR void on_hash() { res = HASH; }
on_zerotest_format_specs_handler2139 FMT_CONSTEXPR void on_zero() { res = ZERO; }
2140
on_widthtest_format_specs_handler2141 FMT_CONSTEXPR void on_width(unsigned w) { width = w; }
on_dynamic_widthtest_format_specs_handler2142 FMT_CONSTEXPR void on_dynamic_width(fmt::internal::auto_id) {}
on_dynamic_widthtest_format_specs_handler2143 FMT_CONSTEXPR void on_dynamic_width(unsigned index) { width_ref = index; }
on_dynamic_widthtest_format_specs_handler2144 FMT_CONSTEXPR void on_dynamic_width(string_view) {}
2145
on_precisiontest_format_specs_handler2146 FMT_CONSTEXPR void on_precision(unsigned p) { precision = p; }
on_dynamic_precisiontest_format_specs_handler2147 FMT_CONSTEXPR void on_dynamic_precision(fmt::internal::auto_id) {}
on_dynamic_precisiontest_format_specs_handler2148 FMT_CONSTEXPR void on_dynamic_precision(unsigned index) {
2149 precision_ref = index;
2150 }
on_dynamic_precisiontest_format_specs_handler2151 FMT_CONSTEXPR void on_dynamic_precision(string_view) {}
2152
end_precisiontest_format_specs_handler2153 FMT_CONSTEXPR void end_precision() {}
on_typetest_format_specs_handler2154 FMT_CONSTEXPR void on_type(char t) { type = t; }
on_errortest_format_specs_handler2155 FMT_CONSTEXPR void on_error(const char *) { res = ERROR; }
2156 };
2157
2158 template <size_t N>
parse_test_specs(const char (& s)[N])2159 FMT_CONSTEXPR test_format_specs_handler parse_test_specs(const char (&s)[N]) {
2160 test_format_specs_handler h;
2161 fmt::internal::parse_format_specs(s, s + N, h);
2162 return h;
2163 }
2164
TEST(FormatTest,ConstexprParseFormatSpecs)2165 TEST(FormatTest, ConstexprParseFormatSpecs) {
2166 typedef test_format_specs_handler handler;
2167 static_assert(parse_test_specs("<").align_ == fmt::ALIGN_LEFT, "");
2168 static_assert(parse_test_specs("*^").fill == '*', "");
2169 static_assert(parse_test_specs("+").res == handler::PLUS, "");
2170 static_assert(parse_test_specs("-").res == handler::MINUS, "");
2171 static_assert(parse_test_specs(" ").res == handler::SPACE, "");
2172 static_assert(parse_test_specs("#").res == handler::HASH, "");
2173 static_assert(parse_test_specs("0").res == handler::ZERO, "");
2174 static_assert(parse_test_specs("42").width == 42, "");
2175 static_assert(parse_test_specs("{42}").width_ref.index == 42, "");
2176 static_assert(parse_test_specs(".42").precision == 42, "");
2177 static_assert(parse_test_specs(".{42}").precision_ref.index == 42, "");
2178 static_assert(parse_test_specs("d").type == 'd', "");
2179 static_assert(parse_test_specs("{<").res == handler::ERROR, "");
2180 }
2181
2182 struct test_context {
2183 typedef char char_type;
2184
next_argtest_context2185 FMT_CONSTEXPR fmt::basic_format_arg<test_context> next_arg() {
2186 return fmt::internal::make_arg<test_context>(11);
2187 }
2188
2189 template <typename Id>
get_argtest_context2190 FMT_CONSTEXPR fmt::basic_format_arg<test_context> get_arg(Id) {
2191 return fmt::internal::make_arg<test_context>(22);
2192 }
2193
2194 template <typename Id>
check_arg_idtest_context2195 FMT_CONSTEXPR void check_arg_id(Id) {}
2196
next_arg_idtest_context2197 FMT_CONSTEXPR unsigned next_arg_id() { return 33; }
2198
on_errortest_context2199 void on_error(const char *) {}
2200
parse_contexttest_context2201 FMT_CONSTEXPR test_context &parse_context() { return *this; }
error_handlertest_context2202 FMT_CONSTEXPR test_context error_handler() { return *this; }
2203 };
2204
2205 template <size_t N>
parse_specs(const char (& s)[N])2206 FMT_CONSTEXPR fmt::format_specs parse_specs(const char (&s)[N]) {
2207 fmt::format_specs specs;
2208 test_context ctx{};
2209 fmt::internal::specs_handler<test_context> h(specs, ctx);
2210 parse_format_specs(s, s + N, h);
2211 return specs;
2212 }
2213
TEST(FormatTest,ConstexprSpecsHandler)2214 TEST(FormatTest, ConstexprSpecsHandler) {
2215 static_assert(parse_specs("<").align() == fmt::ALIGN_LEFT, "");
2216 static_assert(parse_specs("*^").fill() == '*', "");
2217 static_assert(parse_specs("+").has(fmt::PLUS_FLAG), "");
2218 static_assert(parse_specs("-").has(fmt::MINUS_FLAG), "");
2219 static_assert(parse_specs(" ").has(fmt::SIGN_FLAG), "");
2220 static_assert(parse_specs("#").has(fmt::HASH_FLAG), "");
2221 static_assert(parse_specs("0").align() == fmt::ALIGN_NUMERIC, "");
2222 static_assert(parse_specs("42").width() == 42, "");
2223 static_assert(parse_specs("{}").width() == 11, "");
2224 static_assert(parse_specs("{0}").width() == 22, "");
2225 static_assert(parse_specs(".42").precision == 42, "");
2226 static_assert(parse_specs(".{}").precision == 11, "");
2227 static_assert(parse_specs(".{0}").precision == 22, "");
2228 static_assert(parse_specs("d").type == 'd', "");
2229 }
2230
2231 template <size_t N>
2232 FMT_CONSTEXPR fmt::internal::dynamic_format_specs<char>
parse_dynamic_specs(const char (& s)[N])2233 parse_dynamic_specs(const char (&s)[N]) {
2234 fmt::internal::dynamic_format_specs<char> specs;
2235 test_context ctx{};
2236 fmt::internal::dynamic_specs_handler<test_context> h(specs, ctx);
2237 parse_format_specs(s, s + N, h);
2238 return specs;
2239 }
2240
TEST(FormatTest,ConstexprDynamicSpecsHandler)2241 TEST(FormatTest, ConstexprDynamicSpecsHandler) {
2242 static_assert(parse_dynamic_specs("<").align() == fmt::ALIGN_LEFT, "");
2243 static_assert(parse_dynamic_specs("*^").fill() == '*', "");
2244 static_assert(parse_dynamic_specs("+").has(fmt::PLUS_FLAG), "");
2245 static_assert(parse_dynamic_specs("-").has(fmt::MINUS_FLAG), "");
2246 static_assert(parse_dynamic_specs(" ").has(fmt::SIGN_FLAG), "");
2247 static_assert(parse_dynamic_specs("#").has(fmt::HASH_FLAG), "");
2248 static_assert(parse_dynamic_specs("0").align() == fmt::ALIGN_NUMERIC, "");
2249 static_assert(parse_dynamic_specs("42").width() == 42, "");
2250 static_assert(parse_dynamic_specs("{}").width_ref.index == 33, "");
2251 static_assert(parse_dynamic_specs("{42}").width_ref.index == 42, "");
2252 static_assert(parse_dynamic_specs(".42").precision == 42, "");
2253 static_assert(parse_dynamic_specs(".{}").precision_ref.index == 33, "");
2254 static_assert(parse_dynamic_specs(".{42}").precision_ref.index == 42, "");
2255 static_assert(parse_dynamic_specs("d").type == 'd', "");
2256 }
2257
2258 template <size_t N>
check_specs(const char (& s)[N])2259 FMT_CONSTEXPR test_format_specs_handler check_specs(const char (&s)[N]) {
2260 fmt::internal::specs_checker<test_format_specs_handler>
2261 checker(test_format_specs_handler(), fmt::internal::double_type);
2262 parse_format_specs(s, s + N, checker);
2263 return checker;
2264 }
2265
TEST(FormatTest,ConstexprSpecsChecker)2266 TEST(FormatTest, ConstexprSpecsChecker) {
2267 typedef test_format_specs_handler handler;
2268 static_assert(check_specs("<").align_ == fmt::ALIGN_LEFT, "");
2269 static_assert(check_specs("*^").fill == '*', "");
2270 static_assert(check_specs("+").res == handler::PLUS, "");
2271 static_assert(check_specs("-").res == handler::MINUS, "");
2272 static_assert(check_specs(" ").res == handler::SPACE, "");
2273 static_assert(check_specs("#").res == handler::HASH, "");
2274 static_assert(check_specs("0").res == handler::ZERO, "");
2275 static_assert(check_specs("42").width == 42, "");
2276 static_assert(check_specs("{42}").width_ref.index == 42, "");
2277 static_assert(check_specs(".42").precision == 42, "");
2278 static_assert(check_specs(".{42}").precision_ref.index == 42, "");
2279 static_assert(check_specs("d").type == 'd', "");
2280 static_assert(check_specs("{<").res == handler::ERROR, "");
2281 }
2282
2283 struct test_format_string_handler {
on_texttest_format_string_handler2284 FMT_CONSTEXPR void on_text(const char *, const char *) {}
2285
on_arg_idtest_format_string_handler2286 FMT_CONSTEXPR void on_arg_id() {}
2287
2288 template <typename T>
on_arg_idtest_format_string_handler2289 FMT_CONSTEXPR void on_arg_id(T) {}
2290
on_replacement_fieldtest_format_string_handler2291 FMT_CONSTEXPR void on_replacement_field(const char *) {}
2292
on_format_specstest_format_string_handler2293 FMT_CONSTEXPR const char *on_format_specs(const char *begin, const char*) {
2294 return begin;
2295 }
2296
on_errortest_format_string_handler2297 FMT_CONSTEXPR void on_error(const char *) { error = true; }
2298
2299 bool error = false;
2300 };
2301
2302 template <size_t N>
parse_string(const char (& s)[N])2303 FMT_CONSTEXPR bool parse_string(const char (&s)[N]) {
2304 test_format_string_handler h;
2305 fmt::internal::parse_format_string<true>(fmt::string_view(s, N - 1), h);
2306 return !h.error;
2307 }
2308
TEST(FormatTest,ConstexprParseFormatString)2309 TEST(FormatTest, ConstexprParseFormatString) {
2310 static_assert(parse_string("foo"), "");
2311 static_assert(!parse_string("}"), "");
2312 static_assert(parse_string("{}"), "");
2313 static_assert(parse_string("{42}"), "");
2314 static_assert(parse_string("{foo}"), "");
2315 static_assert(parse_string("{:}"), "");
2316 }
2317
2318 struct test_error_handler {
2319 const char *&error;
2320
test_error_handlertest_error_handler2321 FMT_CONSTEXPR test_error_handler(const char *&err): error(err) {}
2322
test_error_handlertest_error_handler2323 FMT_CONSTEXPR test_error_handler(const test_error_handler &other)
2324 : error(other.error) {}
2325
on_errortest_error_handler2326 FMT_CONSTEXPR void on_error(const char *message) {
2327 if (!error)
2328 error = message;
2329 }
2330 };
2331
len(const char * s)2332 FMT_CONSTEXPR size_t len(const char *s) {
2333 size_t len = 0;
2334 while (*s++)
2335 ++len;
2336 return len;
2337 }
2338
equal(const char * s1,const char * s2)2339 FMT_CONSTEXPR bool equal(const char *s1, const char *s2) {
2340 if (!s1 || !s2)
2341 return s1 == s2;
2342 while (*s1 && *s1 == *s2) {
2343 ++s1;
2344 ++s2;
2345 }
2346 return *s1 == *s2;
2347 }
2348
2349 template <typename... Args>
test_error(const char * fmt,const char * expected_error)2350 FMT_CONSTEXPR bool test_error(const char *fmt, const char *expected_error) {
2351 const char *actual_error = FMT_NULL;
2352 fmt::internal::do_check_format_string<char, test_error_handler, Args...>(
2353 string_view(fmt, len(fmt)), test_error_handler(actual_error));
2354 return equal(actual_error, expected_error);
2355 }
2356
2357 #define EXPECT_ERROR_NOARGS(fmt, error) \
2358 static_assert(test_error(fmt, error), "")
2359 #define EXPECT_ERROR(fmt, error, ...) \
2360 static_assert(test_error<__VA_ARGS__>(fmt, error), "")
2361
TEST(FormatTest,FormatStringErrors)2362 TEST(FormatTest, FormatStringErrors) {
2363 EXPECT_ERROR_NOARGS("foo", FMT_NULL);
2364 EXPECT_ERROR_NOARGS("}", "unmatched '}' in format string");
2365 EXPECT_ERROR("{0:s", "unknown format specifier", Date);
2366 #ifndef _MSC_VER
2367 // This causes an internal compiler error in MSVC2017.
2368 EXPECT_ERROR("{0:=5", "unknown format specifier", int);
2369 EXPECT_ERROR("{:{<}", "invalid fill character '{'", int);
2370 EXPECT_ERROR("{:10000000000}", "number is too big", int);
2371 EXPECT_ERROR("{:.10000000000}", "number is too big", int);
2372 EXPECT_ERROR_NOARGS("{:x}", "argument index out of range");
2373 EXPECT_ERROR("{:=}", "format specifier requires numeric argument",
2374 const char *);
2375 EXPECT_ERROR("{:+}", "format specifier requires numeric argument",
2376 const char *);
2377 EXPECT_ERROR("{:-}", "format specifier requires numeric argument",
2378 const char *);
2379 EXPECT_ERROR("{:#}", "format specifier requires numeric argument",
2380 const char *);
2381 EXPECT_ERROR("{: }", "format specifier requires numeric argument",
2382 const char *);
2383 EXPECT_ERROR("{:0}", "format specifier requires numeric argument",
2384 const char *);
2385 EXPECT_ERROR("{:+}", "format specifier requires signed argument", unsigned);
2386 EXPECT_ERROR("{:-}", "format specifier requires signed argument", unsigned);
2387 EXPECT_ERROR("{: }", "format specifier requires signed argument", unsigned);
2388 EXPECT_ERROR("{:.2}", "precision not allowed for this argument type", int);
2389 EXPECT_ERROR("{:s}", "invalid type specifier", int);
2390 EXPECT_ERROR("{:s}", "invalid type specifier", bool);
2391 EXPECT_ERROR("{:s}", "invalid type specifier", char);
2392 EXPECT_ERROR("{:+}", "invalid format specifier for char", char);
2393 EXPECT_ERROR("{:s}", "invalid type specifier", double);
2394 EXPECT_ERROR("{:d}", "invalid type specifier", const char *);
2395 EXPECT_ERROR("{:d}", "invalid type specifier", std::string);
2396 EXPECT_ERROR("{:s}", "invalid type specifier", void *);
2397 #endif
2398 EXPECT_ERROR("{foo", "missing '}' in format string", int);
2399 EXPECT_ERROR_NOARGS("{10000000000}", "number is too big");
2400 EXPECT_ERROR_NOARGS("{0x}", "invalid format string");
2401 EXPECT_ERROR_NOARGS("{-}", "invalid format string");
2402 EXPECT_ERROR("{:{0x}}", "invalid format string", int);
2403 EXPECT_ERROR("{:{-}}", "invalid format string", int);
2404 EXPECT_ERROR("{:.{0x}}", "invalid format string", int);
2405 EXPECT_ERROR("{:.{-}}", "invalid format string", int);
2406 EXPECT_ERROR("{:.x}", "missing precision specifier", int);
2407 EXPECT_ERROR_NOARGS("{}", "argument index out of range");
2408 EXPECT_ERROR("{1}", "argument index out of range", int);
2409 EXPECT_ERROR("{1}{}",
2410 "cannot switch from manual to automatic argument indexing",
2411 int, int);
2412 EXPECT_ERROR("{}{1}",
2413 "cannot switch from automatic to manual argument indexing",
2414 int, int);
2415 }
2416
TEST(FormatTest,VFormatTo)2417 TEST(FormatTest, VFormatTo) {
2418 typedef fmt::format_context context;
2419 fmt::basic_format_arg<context> arg = fmt::internal::make_arg<context>(42);
2420 fmt::basic_format_args<context> args(&arg, 1);
2421 std::string s;
2422 fmt::vformat_to(std::back_inserter(s), "{}", args);
2423 EXPECT_EQ("42", s);
2424 s.clear();
2425 fmt::vformat_to(std::back_inserter(s), FMT_STRING("{}"), args);
2426 EXPECT_EQ("42", s);
2427
2428 typedef fmt::wformat_context wcontext;
2429 fmt::basic_format_arg<wcontext> warg = fmt::internal::make_arg<wcontext>(42);
2430 fmt::basic_format_args<wcontext> wargs(&warg, 1);
2431 std::wstring w;
2432 fmt::vformat_to(std::back_inserter(w), L"{}", wargs);
2433 EXPECT_EQ(L"42", w);
2434 w.clear();
2435 fmt::vformat_to(std::back_inserter(w), FMT_STRING(L"{}"), wargs);
2436 EXPECT_EQ(L"42", w);
2437 }
2438
2439 #endif // FMT_USE_CONSTEXPR
2440
TEST(FormatTest,ConstructU8StringViewFromCString)2441 TEST(FormatTest, ConstructU8StringViewFromCString) {
2442 fmt::u8string_view s("ab");
2443 EXPECT_EQ(s.size(), 2u);
2444 const fmt::char8_t *data = s.data();
2445 EXPECT_EQ(data[0], 'a');
2446 EXPECT_EQ(data[1], 'b');
2447 }
2448
TEST(FormatTest,ConstructU8StringViewFromDataAndSize)2449 TEST(FormatTest, ConstructU8StringViewFromDataAndSize) {
2450 fmt::u8string_view s("foobar", 3);
2451 EXPECT_EQ(s.size(), 3u);
2452 const fmt::char8_t *data = s.data();
2453 EXPECT_EQ(data[0], 'f');
2454 EXPECT_EQ(data[1], 'o');
2455 EXPECT_EQ(data[2], 'o');
2456 }
2457
2458 #if FMT_USE_USER_DEFINED_LITERALS
TEST(FormatTest,U8StringViewLiteral)2459 TEST(FormatTest, U8StringViewLiteral) {
2460 using namespace fmt::literals;
2461 fmt::u8string_view s = "ab"_u;
2462 EXPECT_EQ(s.size(), 2u);
2463 const fmt::char8_t *data = s.data();
2464 EXPECT_EQ(data[0], 'a');
2465 EXPECT_EQ(data[1], 'b');
2466 EXPECT_EQ(format("{:*^5}"_u, ""_u), "****"_u);
2467 }
2468 #endif
2469
TEST(FormatTest,FormatU8String)2470 TEST(FormatTest, FormatU8String) {
2471 EXPECT_EQ(format(fmt::u8string_view("{}"), 42), fmt::u8string_view("42"));
2472 }
2473