format-test.cc
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 // Check if fmt/format.h compiles with windows.h included before it. 9 #ifdef _WIN32 10 # include <windows.h> 11 #endif 12 // clang-format off 13 #include "fmt/format.h" 14 // clang-format on 15 16 #include <stdint.h> // uint32_t 17 18 #include <climits> // INT_MAX 19 #include <cmath> // std::signbit 20 #include <cstring> // std::strlen 21 #include <iterator> // std::back_inserter 22 #include <list> // std::list 23 #include <memory> // std::unique_ptr 24 #include <type_traits> // std::is_default_constructible 25 26 #include "gtest-extra.h" 27 #include "mock-allocator.h" 28 #include "util.h" 29 30 using fmt::basic_memory_buffer; 31 using fmt::format_error; 32 using fmt::memory_buffer; 33 using fmt::runtime; 34 using fmt::string_view; 35 using fmt::detail::max_value; 36 using fmt::detail::uint128_fallback; 37 38 using testing::Return; 39 using testing::StrictMock; 40 41 enum { buffer_size = 256 }; 42 43 TEST(uint128_test, ctor) { 44 auto n = uint128_fallback(); 45 EXPECT_EQ(n, 0); 46 n = uint128_fallback(42); 47 EXPECT_EQ(n, 42); 48 EXPECT_EQ(static_cast<uint64_t>(n), 42); 49 } 50 51 TEST(uint128_test, shift) { 52 auto n = uint128_fallback(42); 53 n = n << 64; 54 EXPECT_EQ(static_cast<uint64_t>(n), 0); 55 n = n >> 64; 56 EXPECT_EQ(static_cast<uint64_t>(n), 42); 57 n = n << 62; 58 EXPECT_EQ(static_cast<uint64_t>(n >> 64), 0xa); 59 EXPECT_EQ(static_cast<uint64_t>(n), 0x8000000000000000); 60 n = n >> 62; 61 EXPECT_EQ(static_cast<uint64_t>(n), 42); 62 EXPECT_EQ(uint128_fallback(1) << 112, uint128_fallback(0x1000000000000, 0)); 63 EXPECT_EQ(uint128_fallback(0x1000000000000, 0) >> 112, uint128_fallback(1)); 64 } 65 66 TEST(uint128_test, minus) { 67 auto n = uint128_fallback(42); 68 EXPECT_EQ(n - 2, 40); 69 } 70 71 TEST(uint128_test, plus_assign) { 72 auto n = uint128_fallback(32); 73 n += uint128_fallback(10); 74 EXPECT_EQ(n, 42); 75 n = uint128_fallback(max_value<uint64_t>()); 76 n += uint128_fallback(1); 77 EXPECT_EQ(n, uint128_fallback(1) << 64); 78 } 79 80 TEST(uint128_test, multiply) { 81 auto n = uint128_fallback(2251799813685247); 82 n = n * 3611864890; 83 EXPECT_EQ(static_cast<uint64_t>(n >> 64), 440901); 84 } 85 86 template <typename Float> void check_isfinite() { 87 using fmt::detail::isfinite; 88 EXPECT_TRUE(isfinite(Float(0.0))); 89 EXPECT_TRUE(isfinite(Float(42.0))); 90 EXPECT_TRUE(isfinite(Float(-42.0))); 91 EXPECT_TRUE(isfinite(Float(fmt::detail::max_value<double>()))); 92 // Use double because std::numeric_limits is broken for __float128. 93 using limits = std::numeric_limits<double>; 94 FMT_CONSTEXPR20 auto result = isfinite(Float(limits::infinity())); 95 EXPECT_FALSE(result); 96 EXPECT_FALSE(isfinite(Float(limits::infinity()))); 97 EXPECT_FALSE(isfinite(Float(-limits::infinity()))); 98 EXPECT_FALSE(isfinite(Float(limits::quiet_NaN()))); 99 EXPECT_FALSE(isfinite(Float(-limits::quiet_NaN()))); 100 } 101 102 TEST(float_test, isfinite) { 103 check_isfinite<double>(); 104 #if FMT_USE_FLOAT128 105 check_isfinite<fmt::detail::float128>(); 106 #endif 107 } 108 109 template <typename Float> void check_isnan() { 110 using fmt::detail::isnan; 111 EXPECT_FALSE(isnan(Float(0.0))); 112 EXPECT_FALSE(isnan(Float(42.0))); 113 EXPECT_FALSE(isnan(Float(-42.0))); 114 EXPECT_FALSE(isnan(Float(fmt::detail::max_value<double>()))); 115 // Use double because std::numeric_limits is broken for __float128. 116 using limits = std::numeric_limits<double>; 117 EXPECT_FALSE(isnan(Float(limits::infinity()))); 118 EXPECT_FALSE(isnan(Float(-limits::infinity()))); 119 EXPECT_TRUE(isnan(Float(limits::quiet_NaN()))); 120 EXPECT_TRUE(isnan(Float(-limits::quiet_NaN()))); 121 } 122 123 TEST(float_test, isnan) { 124 check_isnan<double>(); 125 #if FMT_USE_FLOAT128 126 check_isnan<fmt::detail::float128>(); 127 #endif 128 } 129 130 struct uint32_pair { 131 uint32_t u[2]; 132 }; 133 134 TEST(util_test, bit_cast) { 135 auto s = fmt::detail::bit_cast<uint32_pair>(uint64_t{42}); 136 EXPECT_EQ(fmt::detail::bit_cast<uint64_t>(s), 42ull); 137 s = fmt::detail::bit_cast<uint32_pair>(~uint64_t{0}); 138 EXPECT_EQ(fmt::detail::bit_cast<uint64_t>(s), ~0ull); 139 } 140 141 // Increment a number in a string. 142 void increment(char* s) { 143 for (int i = static_cast<int>(std::strlen(s)) - 1; i >= 0; --i) { 144 if (s[i] != '9') { 145 ++s[i]; 146 break; 147 } 148 s[i] = '0'; 149 } 150 } 151 152 TEST(util_test, increment) { 153 char s[10] = "123"; 154 increment(s); 155 EXPECT_STREQ("124", s); 156 s[2] = '8'; 157 increment(s); 158 EXPECT_STREQ("129", s); 159 increment(s); 160 EXPECT_STREQ("130", s); 161 s[1] = s[2] = '9'; 162 increment(s); 163 EXPECT_STREQ("200", s); 164 } 165 166 TEST(util_test, parse_nonnegative_int) { 167 auto s = fmt::string_view("10000000000"); 168 auto begin = s.begin(), end = s.end(); 169 EXPECT_EQ(fmt::detail::parse_nonnegative_int(begin, end, -1), -1); 170 s = "2147483649"; 171 begin = s.begin(); 172 end = s.end(); 173 EXPECT_EQ(fmt::detail::parse_nonnegative_int(begin, end, -1), -1); 174 } 175 176 TEST(util_test, utf8_to_utf16) { 177 auto u = fmt::detail::utf8_to_utf16("лошадка"); 178 EXPECT_EQ(L"\x043B\x043E\x0448\x0430\x0434\x043A\x0430", u.str()); 179 EXPECT_EQ(7, u.size()); 180 // U+10437 { DESERET SMALL LETTER YEE } 181 EXPECT_EQ(L"\xD801\xDC37", fmt::detail::utf8_to_utf16("𐐷").str()); 182 EXPECT_THROW_MSG(fmt::detail::utf8_to_utf16("\xc3\x28"), std::runtime_error, 183 "invalid utf8"); 184 EXPECT_THROW_MSG(fmt::detail::utf8_to_utf16(fmt::string_view("л", 1)), 185 std::runtime_error, "invalid utf8"); 186 EXPECT_EQ(L"123456", fmt::detail::utf8_to_utf16("123456").str()); 187 } 188 189 TEST(util_test, utf8_to_utf16_empty_string) { 190 auto s = std::string(); 191 auto u = fmt::detail::utf8_to_utf16(s.c_str()); 192 EXPECT_EQ(L"", u.str()); 193 EXPECT_EQ(s.size(), u.size()); 194 } 195 196 TEST(util_test, allocator_ref) { 197 using test_allocator_ref = allocator_ref<mock_allocator<int>>; 198 auto check_forwarding = [](mock_allocator<int>& alloc, 199 test_allocator_ref& ref) { 200 int mem; 201 // Check if value_type is properly defined. 202 allocator_ref<mock_allocator<int>>::value_type* ptr = &mem; 203 // Check forwarding. 204 EXPECT_CALL(alloc, allocate(42)).WillOnce(Return(ptr)); 205 ref.allocate(42); 206 EXPECT_CALL(alloc, deallocate(ptr, 42)); 207 ref.deallocate(ptr, 42); 208 }; 209 210 StrictMock<mock_allocator<int>> alloc; 211 auto ref = test_allocator_ref(&alloc); 212 // Check if allocator_ref forwards to the underlying allocator. 213 check_forwarding(alloc, ref); 214 test_allocator_ref ref2(ref); 215 check_forwarding(alloc, ref2); 216 test_allocator_ref ref3; 217 EXPECT_EQ(nullptr, ref3.get()); 218 ref3 = ref; 219 check_forwarding(alloc, ref3); 220 } 221 222 TEST(util_test, format_system_error) { 223 fmt::memory_buffer message; 224 fmt::format_system_error(message, EDOM, "test"); 225 auto ec = std::error_code(EDOM, std::generic_category()); 226 EXPECT_EQ(to_string(message), std::system_error(ec, "test").what()); 227 message = fmt::memory_buffer(); 228 229 // Check if std::allocator throws on allocating max size_t / 2 chars. 230 size_t max_size = max_value<size_t>() / 2; 231 bool throws_on_alloc = false; 232 try { 233 auto alloc = std::allocator<char>(); 234 alloc.deallocate(alloc.allocate(max_size), max_size); 235 } catch (const std::bad_alloc&) { 236 throws_on_alloc = true; 237 } 238 if (!throws_on_alloc) { 239 fmt::print("warning: std::allocator allocates {} chars\n", max_size); 240 return; 241 } 242 } 243 244 TEST(util_test, system_error) { 245 auto test_error = fmt::system_error(EDOM, "test"); 246 auto ec = std::error_code(EDOM, std::generic_category()); 247 EXPECT_STREQ(test_error.what(), std::system_error(ec, "test").what()); 248 EXPECT_EQ(test_error.code(), ec); 249 250 auto error = std::system_error(std::error_code()); 251 try { 252 throw fmt::system_error(EDOM, "test {}", "error"); 253 } catch (const std::system_error& e) { 254 error = e; 255 } 256 fmt::memory_buffer message; 257 fmt::format_system_error(message, EDOM, "test error"); 258 EXPECT_EQ(error.what(), to_string(message)); 259 EXPECT_EQ(error.code(), std::error_code(EDOM, std::generic_category())); 260 } 261 262 TEST(util_test, report_system_error) { 263 fmt::memory_buffer out; 264 fmt::format_system_error(out, EDOM, "test error"); 265 out.push_back('\n'); 266 EXPECT_WRITE(stderr, fmt::report_system_error(EDOM, "test error"), 267 to_string(out)); 268 } 269 270 TEST(memory_buffer_test, ctor) { 271 basic_memory_buffer<char, 123> buffer; 272 EXPECT_EQ(static_cast<size_t>(0), buffer.size()); 273 EXPECT_EQ(123u, buffer.capacity()); 274 } 275 276 using std_allocator = allocator_ref<std::allocator<char>>; 277 278 TEST(memory_buffer_test, move_ctor_inline_buffer) { 279 auto check_move_buffer = 280 [](const char* str, basic_memory_buffer<char, 5, std_allocator>& buffer) { 281 std::allocator<char>* alloc = buffer.get_allocator().get(); 282 basic_memory_buffer<char, 5, std_allocator> buffer2(std::move(buffer)); 283 // Move shouldn't destroy the inline content of the first buffer. 284 EXPECT_EQ(str, std::string(&buffer[0], buffer.size())); 285 EXPECT_EQ(str, std::string(&buffer2[0], buffer2.size())); 286 EXPECT_EQ(5u, buffer2.capacity()); 287 // Move should transfer allocator. 288 EXPECT_EQ(nullptr, buffer.get_allocator().get()); 289 EXPECT_EQ(alloc, buffer2.get_allocator().get()); 290 }; 291 292 auto alloc = std::allocator<char>(); 293 basic_memory_buffer<char, 5, std_allocator> buffer((std_allocator(&alloc))); 294 const char test[] = "test"; 295 buffer.append(string_view(test, 4)); 296 check_move_buffer("test", buffer); 297 // Adding one more character fills the inline buffer, but doesn't cause 298 // dynamic allocation. 299 buffer.push_back('a'); 300 check_move_buffer("testa", buffer); 301 } 302 303 TEST(memory_buffer_test, move_ctor_dynamic_buffer) { 304 auto alloc = std::allocator<char>(); 305 basic_memory_buffer<char, 4, std_allocator> buffer((std_allocator(&alloc))); 306 const char test[] = "test"; 307 buffer.append(test, test + 4); 308 const char* inline_buffer_ptr = &buffer[0]; 309 // Adding one more character causes the content to move from the inline to 310 // a dynamically allocated buffer. 311 buffer.push_back('a'); 312 basic_memory_buffer<char, 4, std_allocator> buffer2(std::move(buffer)); 313 // Move should rip the guts of the first buffer. 314 EXPECT_EQ(&buffer[0], inline_buffer_ptr); 315 EXPECT_EQ(buffer.size(), 0); 316 EXPECT_EQ(std::string(&buffer2[0], buffer2.size()), "testa"); 317 EXPECT_GT(buffer2.capacity(), 4u); 318 } 319 320 void check_move_assign_buffer(const char* str, 321 basic_memory_buffer<char, 5>& buffer) { 322 basic_memory_buffer<char, 5> buffer2; 323 buffer2 = std::move(buffer); 324 // Move shouldn't destroy the inline content of the first buffer. 325 EXPECT_EQ(str, std::string(&buffer[0], buffer.size())); 326 EXPECT_EQ(str, std::string(&buffer2[0], buffer2.size())); 327 EXPECT_EQ(5u, buffer2.capacity()); 328 } 329 330 TEST(memory_buffer_test, move_assignment) { 331 basic_memory_buffer<char, 5> buffer; 332 const char test[] = "test"; 333 buffer.append(test, test + 4); 334 check_move_assign_buffer("test", buffer); 335 // Adding one more character fills the inline buffer, but doesn't cause 336 // dynamic allocation. 337 buffer.push_back('a'); 338 check_move_assign_buffer("testa", buffer); 339 const char* inline_buffer_ptr = &buffer[0]; 340 // Adding one more character causes the content to move from the inline to 341 // a dynamically allocated buffer. 342 buffer.push_back('b'); 343 basic_memory_buffer<char, 5> buffer2; 344 buffer2 = std::move(buffer); 345 // Move should rip the guts of the first buffer. 346 EXPECT_EQ(inline_buffer_ptr, &buffer[0]); 347 EXPECT_EQ("testab", std::string(&buffer2[0], buffer2.size())); 348 EXPECT_GT(buffer2.capacity(), 5u); 349 } 350 351 TEST(memory_buffer_test, grow) { 352 typedef allocator_ref<mock_allocator<int>> Allocator; 353 mock_allocator<int> alloc; 354 basic_memory_buffer<int, 10, Allocator> buffer((Allocator(&alloc))); 355 buffer.resize(7); 356 using fmt::detail::to_unsigned; 357 for (int i = 0; i < 7; ++i) buffer[to_unsigned(i)] = i * i; 358 EXPECT_EQ(10u, buffer.capacity()); 359 int mem[20]; 360 mem[7] = 0xdead; 361 EXPECT_CALL(alloc, allocate(20)).WillOnce(Return(mem)); 362 buffer.try_reserve(20); 363 EXPECT_EQ(20u, buffer.capacity()); 364 // Check if size elements have been copied 365 for (int i = 0; i < 7; ++i) EXPECT_EQ(i * i, buffer[to_unsigned(i)]); 366 // and no more than that. 367 EXPECT_EQ(0xdead, buffer[7]); 368 EXPECT_CALL(alloc, deallocate(mem, 20)); 369 } 370 371 TEST(memory_buffer_test, allocator) { 372 using test_allocator = allocator_ref<mock_allocator<char>>; 373 basic_memory_buffer<char, 10, test_allocator> buffer; 374 EXPECT_EQ(nullptr, buffer.get_allocator().get()); 375 StrictMock<mock_allocator<char>> alloc; 376 char mem; 377 { 378 basic_memory_buffer<char, 10, test_allocator> buffer2( 379 (test_allocator(&alloc))); 380 EXPECT_EQ(&alloc, buffer2.get_allocator().get()); 381 size_t size = 2 * fmt::inline_buffer_size; 382 EXPECT_CALL(alloc, allocate(size)).WillOnce(Return(&mem)); 383 buffer2.reserve(size); 384 EXPECT_CALL(alloc, deallocate(&mem, size)); 385 } 386 } 387 388 TEST(memory_buffer_test, exception_in_deallocate) { 389 using test_allocator = allocator_ref<mock_allocator<char>>; 390 StrictMock<mock_allocator<char>> alloc; 391 basic_memory_buffer<char, 10, test_allocator> buffer( 392 (test_allocator(&alloc))); 393 size_t size = 2 * fmt::inline_buffer_size; 394 auto mem = std::vector<char>(size); 395 { 396 EXPECT_CALL(alloc, allocate(size)).WillOnce(Return(&mem[0])); 397 buffer.resize(size); 398 std::fill(&buffer[0], &buffer[0] + size, 'x'); 399 } 400 auto mem2 = std::vector<char>(2 * size); 401 { 402 EXPECT_CALL(alloc, allocate(2 * size)).WillOnce(Return(&mem2[0])); 403 auto e = std::exception(); 404 EXPECT_CALL(alloc, deallocate(&mem[0], size)).WillOnce(testing::Throw(e)); 405 EXPECT_THROW(buffer.reserve(2 * size), std::exception); 406 EXPECT_EQ(&mem2[0], &buffer[0]); 407 // Check that the data has been copied. 408 for (size_t i = 0; i < size; ++i) EXPECT_EQ('x', buffer[i]); 409 } 410 EXPECT_CALL(alloc, deallocate(&mem2[0], 2 * size)); 411 } 412 413 template <typename Allocator, size_t MaxSize> 414 class max_size_allocator : public Allocator { 415 public: 416 using typename Allocator::value_type; 417 size_t max_size() const noexcept { return MaxSize; } 418 value_type* allocate(size_t n) { 419 if (n > max_size()) { 420 throw std::length_error("size > max_size"); 421 } 422 return std::allocator_traits<Allocator>::allocate( 423 *static_cast<Allocator*>(this), n); 424 } 425 void deallocate(value_type* p, size_t n) { 426 std::allocator_traits<Allocator>::deallocate(*static_cast<Allocator*>(this), 427 p, n); 428 } 429 }; 430 431 TEST(memory_buffer_test, max_size_allocator) { 432 // 160 = 128 + 32 433 using test_allocator = max_size_allocator<std::allocator<char>, 160>; 434 basic_memory_buffer<char, 10, test_allocator> buffer; 435 buffer.resize(128); 436 // new_capacity = 128 + 128/2 = 192 > 160 437 buffer.resize(160); // Shouldn't throw. 438 } 439 440 TEST(memory_buffer_test, max_size_allocator_overflow) { 441 using test_allocator = max_size_allocator<std::allocator<char>, 160>; 442 basic_memory_buffer<char, 10, test_allocator> buffer; 443 EXPECT_THROW(buffer.resize(161), std::exception); 444 } 445 446 TEST(format_test, escape) { 447 EXPECT_EQ("{", fmt::format("{{")); 448 EXPECT_EQ("before {", fmt::format("before {{")); 449 EXPECT_EQ("{ after", fmt::format("{{ after")); 450 EXPECT_EQ("before { after", fmt::format("before {{ after")); 451 452 EXPECT_EQ("}", fmt::format("}}")); 453 EXPECT_EQ("before }", fmt::format("before }}")); 454 EXPECT_EQ("} after", fmt::format("}} after")); 455 EXPECT_EQ("before } after", fmt::format("before }} after")); 456 457 EXPECT_EQ("{}", fmt::format("{{}}")); 458 EXPECT_EQ("{42}", fmt::format("{{{0}}}", 42)); 459 } 460 461 TEST(format_test, unmatched_braces) { 462 EXPECT_THROW_MSG((void)fmt::format(runtime("{")), format_error, 463 "invalid format string"); 464 EXPECT_THROW_MSG((void)fmt::format(runtime("}")), format_error, 465 "unmatched '}' in format string"); 466 EXPECT_THROW_MSG((void)fmt::format(runtime("{0{}")), format_error, 467 "invalid format string"); 468 } 469 470 TEST(format_test, no_args) { EXPECT_EQ("test", fmt::format("test")); } 471 472 TEST(format_test, args_in_different_positions) { 473 EXPECT_EQ("42", fmt::format("{0}", 42)); 474 EXPECT_EQ("before 42", fmt::format("before {0}", 42)); 475 EXPECT_EQ("42 after", fmt::format("{0} after", 42)); 476 EXPECT_EQ("before 42 after", fmt::format("before {0} after", 42)); 477 EXPECT_EQ("answer = 42", fmt::format("{0} = {1}", "answer", 42)); 478 EXPECT_EQ("42 is the answer", fmt::format("{1} is the {0}", "answer", 42)); 479 EXPECT_EQ("abracadabra", fmt::format("{0}{1}{0}", "abra", "cad")); 480 } 481 482 TEST(format_test, arg_errors) { 483 EXPECT_THROW_MSG((void)fmt::format(runtime("{")), format_error, 484 "invalid format string"); 485 EXPECT_THROW_MSG((void)fmt::format(runtime("{?}")), format_error, 486 "invalid format string"); 487 EXPECT_THROW_MSG((void)fmt::format(runtime("{0")), format_error, 488 "invalid format string"); 489 EXPECT_THROW_MSG((void)fmt::format(runtime("{0}")), format_error, 490 "argument not found"); 491 EXPECT_THROW_MSG((void)fmt::format(runtime("{00}"), 42), format_error, 492 "invalid format string"); 493 494 char format_str[buffer_size]; 495 safe_sprintf(format_str, "{%u", INT_MAX); 496 EXPECT_THROW_MSG((void)fmt::format(runtime(format_str)), format_error, 497 "invalid format string"); 498 safe_sprintf(format_str, "{%u}", INT_MAX); 499 EXPECT_THROW_MSG((void)fmt::format(runtime(format_str)), format_error, 500 "argument not found"); 501 502 safe_sprintf(format_str, "{%u", INT_MAX + 1u); 503 EXPECT_THROW_MSG((void)fmt::format(runtime(format_str)), format_error, 504 "invalid format string"); 505 safe_sprintf(format_str, "{%u}", INT_MAX + 1u); 506 EXPECT_THROW_MSG((void)fmt::format(runtime(format_str)), format_error, 507 "argument not found"); 508 } 509 510 template <int N> struct test_format { 511 template <typename... T> 512 static std::string format(fmt::string_view fmt, const T&... args) { 513 return test_format<N - 1>::format(fmt, N - 1, args...); 514 } 515 }; 516 517 template <> struct test_format<0> { 518 template <typename... T> 519 static std::string format(fmt::string_view fmt, const T&... args) { 520 return fmt::format(runtime(fmt), args...); 521 } 522 }; 523 524 TEST(format_test, many_args) { 525 EXPECT_EQ("19", test_format<20>::format("{19}")); 526 EXPECT_THROW_MSG(test_format<20>::format("{20}"), format_error, 527 "argument not found"); 528 EXPECT_THROW_MSG(test_format<21>::format("{21}"), format_error, 529 "argument not found"); 530 using fmt::detail::max_packed_args; 531 std::string format_str = fmt::format("{{{}}}", max_packed_args + 1); 532 EXPECT_THROW_MSG(test_format<max_packed_args>::format(format_str), 533 format_error, "argument not found"); 534 } 535 536 TEST(format_test, named_arg) { 537 EXPECT_EQ("1/a/A", fmt::format("{_1}/{a_}/{A_}", fmt::arg("a_", 'a'), 538 fmt::arg("A_", "A"), fmt::arg("_1", 1))); 539 EXPECT_EQ(" -42", fmt::format("{0:{width}}", -42, fmt::arg("width", 4))); 540 EXPECT_EQ("st", 541 fmt::format("{0:.{precision}}", "str", fmt::arg("precision", 2))); 542 EXPECT_EQ("1 2", fmt::format("{} {two}", 1, fmt::arg("two", 2))); 543 EXPECT_EQ("42", 544 fmt::format("{c}", fmt::arg("a", 0), fmt::arg("b", 0), 545 fmt::arg("c", 42), fmt::arg("d", 0), fmt::arg("e", 0), 546 fmt::arg("f", 0), fmt::arg("g", 0), fmt::arg("h", 0), 547 fmt::arg("i", 0), fmt::arg("j", 0), fmt::arg("k", 0), 548 fmt::arg("l", 0), fmt::arg("m", 0), fmt::arg("n", 0), 549 fmt::arg("o", 0), fmt::arg("p", 0))); 550 EXPECT_THROW_MSG((void)fmt::format(runtime("{a}")), format_error, 551 "argument not found"); 552 EXPECT_THROW_MSG((void)fmt::format(runtime("{a}"), 42), format_error, 553 "argument not found"); 554 } 555 556 TEST(format_test, auto_arg_index) { 557 EXPECT_EQ("abc", fmt::format("{}{}{}", 'a', 'b', 'c')); 558 EXPECT_THROW_MSG((void)fmt::format(runtime("{0}{}"), 'a', 'b'), format_error, 559 "cannot switch from manual to automatic argument indexing"); 560 EXPECT_THROW_MSG((void)fmt::format(runtime("{}{0}"), 'a', 'b'), format_error, 561 "cannot switch from automatic to manual argument indexing"); 562 EXPECT_EQ("1.2", fmt::format("{:.{}}", 1.2345, 2)); 563 EXPECT_THROW_MSG((void)fmt::format(runtime("{0}:.{}"), 1.2345, 2), 564 format_error, 565 "cannot switch from manual to automatic argument indexing"); 566 EXPECT_THROW_MSG((void)fmt::format(runtime("{:.{0}}"), 1.2345, 2), 567 format_error, 568 "cannot switch from automatic to manual argument indexing"); 569 EXPECT_THROW_MSG((void)fmt::format(runtime("{}")), format_error, 570 "argument not found"); 571 } 572 573 TEST(format_test, empty_specs) { EXPECT_EQ("42", fmt::format("{0:}", 42)); } 574 575 TEST(format_test, left_align) { 576 EXPECT_EQ("42 ", fmt::format("{0:<4}", 42)); 577 EXPECT_EQ("42 ", fmt::format("{0:<4o}", 042)); 578 EXPECT_EQ("42 ", fmt::format("{0:<4x}", 0x42)); 579 EXPECT_EQ("-42 ", fmt::format("{0:<5}", -42)); 580 EXPECT_EQ("42 ", fmt::format("{0:<5}", 42u)); 581 EXPECT_EQ("-42 ", fmt::format("{0:<5}", -42l)); 582 EXPECT_EQ("42 ", fmt::format("{0:<5}", 42ul)); 583 EXPECT_EQ("-42 ", fmt::format("{0:<5}", -42ll)); 584 EXPECT_EQ("42 ", fmt::format("{0:<5}", 42ull)); 585 EXPECT_EQ("-42 ", fmt::format("{0:<5}", -42.0)); 586 EXPECT_EQ("-42 ", fmt::format("{0:<5}", -42.0l)); 587 EXPECT_EQ("c ", fmt::format("{0:<5}", 'c')); 588 EXPECT_EQ("abc ", fmt::format("{0:<5}", "abc")); 589 EXPECT_EQ("0xface ", fmt::format("{0:<8}", reinterpret_cast<void*>(0xface))); 590 } 591 592 TEST(format_test, right_align) { 593 EXPECT_EQ(" 42", fmt::format("{0:>4}", 42)); 594 EXPECT_EQ(" 42", fmt::format("{0:>4o}", 042)); 595 EXPECT_EQ(" 42", fmt::format("{0:>4x}", 0x42)); 596 EXPECT_EQ(" -42", fmt::format("{0:>5}", -42)); 597 EXPECT_EQ(" 42", fmt::format("{0:>5}", 42u)); 598 EXPECT_EQ(" -42", fmt::format("{0:>5}", -42l)); 599 EXPECT_EQ(" 42", fmt::format("{0:>5}", 42ul)); 600 EXPECT_EQ(" -42", fmt::format("{0:>5}", -42ll)); 601 EXPECT_EQ(" 42", fmt::format("{0:>5}", 42ull)); 602 EXPECT_EQ(" -42", fmt::format("{0:>5}", -42.0)); 603 EXPECT_EQ(" -42", fmt::format("{0:>5}", -42.0l)); 604 EXPECT_EQ(" c", fmt::format("{0:>5}", 'c')); 605 EXPECT_EQ(" abc", fmt::format("{0:>5}", "abc")); 606 EXPECT_EQ(" 0xface", fmt::format("{0:>8}", reinterpret_cast<void*>(0xface))); 607 } 608 609 TEST(format_test, center_align) { 610 EXPECT_EQ(" 42 ", fmt::format("{0:^5}", 42)); 611 EXPECT_EQ(" 42 ", fmt::format("{0:^5o}", 042)); 612 EXPECT_EQ(" 42 ", fmt::format("{0:^5x}", 0x42)); 613 EXPECT_EQ(" -42 ", fmt::format("{0:^5}", -42)); 614 EXPECT_EQ(" 42 ", fmt::format("{0:^5}", 42u)); 615 EXPECT_EQ(" -42 ", fmt::format("{0:^5}", -42l)); 616 EXPECT_EQ(" 42 ", fmt::format("{0:^5}", 42ul)); 617 EXPECT_EQ(" -42 ", fmt::format("{0:^5}", -42ll)); 618 EXPECT_EQ(" 42 ", fmt::format("{0:^5}", 42ull)); 619 EXPECT_EQ(" -42 ", fmt::format("{0:^5}", -42.0)); 620 EXPECT_EQ(" -42 ", fmt::format("{0:^5}", -42.0l)); 621 EXPECT_EQ(" c ", fmt::format("{0:^5}", 'c')); 622 EXPECT_EQ(" abc ", fmt::format("{0:^6}", "abc")); 623 EXPECT_EQ(" 0xface ", fmt::format("{0:^8}", reinterpret_cast<void*>(0xface))); 624 } 625 626 TEST(format_test, fill) { 627 EXPECT_THROW_MSG((void)fmt::format(runtime("{0:{<5}"), 'c'), format_error, 628 "invalid fill character '{'"); 629 EXPECT_THROW_MSG((void)fmt::format(runtime("{0:{<5}}"), 'c'), format_error, 630 "invalid fill character '{'"); 631 EXPECT_EQ("**42", fmt::format("{0:*>4}", 42)); 632 EXPECT_EQ("**-42", fmt::format("{0:*>5}", -42)); 633 EXPECT_EQ("***42", fmt::format("{0:*>5}", 42u)); 634 EXPECT_EQ("**-42", fmt::format("{0:*>5}", -42l)); 635 EXPECT_EQ("***42", fmt::format("{0:*>5}", 42ul)); 636 EXPECT_EQ("**-42", fmt::format("{0:*>5}", -42ll)); 637 EXPECT_EQ("***42", fmt::format("{0:*>5}", 42ull)); 638 EXPECT_EQ("**-42", fmt::format("{0:*>5}", -42.0)); 639 EXPECT_EQ("**-42", fmt::format("{0:*>5}", -42.0l)); 640 EXPECT_EQ("c****", fmt::format("{0:*<5}", 'c')); 641 EXPECT_EQ("abc**", fmt::format("{0:*<5}", "abc")); 642 EXPECT_EQ("**0xface", 643 fmt::format("{0:*>8}", reinterpret_cast<void*>(0xface))); 644 EXPECT_EQ("foo=", fmt::format("{:}=", "foo")); 645 EXPECT_EQ(std::string("\0\0\0*", 4), 646 fmt::format(string_view("{:\0>4}", 6), '*')); 647 EXPECT_EQ("жж42", fmt::format("{0:ж>4}", 42)); 648 EXPECT_THROW_MSG((void)fmt::format(runtime("{:\x80\x80\x80\x80\x80>}"), 0), 649 format_error, "invalid format specifier"); 650 } 651 652 TEST(format_test, plus_sign) { 653 EXPECT_EQ("+42", fmt::format("{0:+}", 42)); 654 EXPECT_EQ("-42", fmt::format("{0:+}", -42)); 655 EXPECT_EQ("+42", fmt::format("{0:+}", 42)); 656 EXPECT_THROW_MSG((void)fmt::format(runtime("{0:+}"), 42u), format_error, 657 "invalid format specifier"); 658 EXPECT_EQ("+42", fmt::format("{0:+}", 42l)); 659 EXPECT_THROW_MSG((void)fmt::format(runtime("{0:+}"), 42ul), format_error, 660 "invalid format specifier"); 661 EXPECT_EQ("+42", fmt::format("{0:+}", 42ll)); 662 #if FMT_USE_INT128 663 EXPECT_EQ("+42", fmt::format("{0:+}", __int128_t(42))); 664 #endif 665 EXPECT_THROW_MSG((void)fmt::format(runtime("{0:+}"), 42ull), format_error, 666 "invalid format specifier"); 667 EXPECT_EQ("+42", fmt::format("{0:+}", 42.0)); 668 EXPECT_EQ("+42", fmt::format("{0:+}", 42.0l)); 669 EXPECT_THROW_MSG((void)fmt::format(runtime("{0:+}"), 'c'), format_error, 670 "invalid format specifier"); 671 EXPECT_THROW_MSG((void)fmt::format(runtime("{0:+}"), "abc"), format_error, 672 "invalid format specifier"); 673 EXPECT_THROW_MSG( 674 (void)fmt::format(runtime("{0:+}"), reinterpret_cast<void*>(0x42)), 675 format_error, "invalid format specifier"); 676 } 677 678 TEST(format_test, minus_sign) { 679 EXPECT_EQ("42", fmt::format("{0:-}", 42)); 680 EXPECT_EQ("-42", fmt::format("{0:-}", -42)); 681 EXPECT_EQ("42", fmt::format("{0:-}", 42)); 682 EXPECT_THROW_MSG((void)fmt::format(runtime("{0:-}"), 42u), format_error, 683 "invalid format specifier"); 684 EXPECT_EQ("42", fmt::format("{0:-}", 42l)); 685 EXPECT_THROW_MSG((void)fmt::format(runtime("{0:-}"), 42ul), format_error, 686 "invalid format specifier"); 687 EXPECT_EQ("42", fmt::format("{0:-}", 42ll)); 688 EXPECT_THROW_MSG((void)fmt::format(runtime("{0:-}"), 42ull), format_error, 689 "invalid format specifier"); 690 EXPECT_EQ("42", fmt::format("{0:-}", 42.0)); 691 EXPECT_EQ("42", fmt::format("{0:-}", 42.0l)); 692 EXPECT_THROW_MSG((void)fmt::format(runtime("{0:-}"), 'c'), format_error, 693 "invalid format specifier"); 694 EXPECT_THROW_MSG((void)fmt::format(runtime("{0:-}"), "abc"), format_error, 695 "invalid format specifier"); 696 EXPECT_THROW_MSG( 697 (void)fmt::format(runtime("{0:-}"), reinterpret_cast<void*>(0x42)), 698 format_error, "invalid format specifier"); 699 } 700 701 TEST(format_test, space_sign) { 702 EXPECT_EQ(" 42", fmt::format("{0: }", 42)); 703 EXPECT_EQ("-42", fmt::format("{0: }", -42)); 704 EXPECT_EQ(" 42", fmt::format("{0: }", 42)); 705 EXPECT_THROW_MSG((void)fmt::format(runtime("{0: }"), 42u), format_error, 706 "invalid format specifier"); 707 EXPECT_EQ(" 42", fmt::format("{0: }", 42l)); 708 EXPECT_THROW_MSG((void)fmt::format(runtime("{0: }"), 42ul), format_error, 709 "invalid format specifier"); 710 EXPECT_EQ(" 42", fmt::format("{0: }", 42ll)); 711 EXPECT_THROW_MSG((void)fmt::format(runtime("{0: }"), 42ull), format_error, 712 "invalid format specifier"); 713 EXPECT_EQ(" 42", fmt::format("{0: }", 42.0)); 714 EXPECT_EQ(" 42", fmt::format("{0: }", 42.0l)); 715 EXPECT_THROW_MSG((void)fmt::format(runtime("{0: }"), 'c'), format_error, 716 "invalid format specifier"); 717 EXPECT_THROW_MSG((void)fmt::format(runtime("{0: }"), "abc"), format_error, 718 "invalid format specifier"); 719 EXPECT_THROW_MSG( 720 (void)fmt::format(runtime("{0: }"), reinterpret_cast<void*>(0x42)), 721 format_error, "invalid format specifier"); 722 } 723 724 TEST(format_test, hash_flag) { 725 EXPECT_EQ("42", fmt::format("{0:#}", 42)); 726 EXPECT_EQ("-42", fmt::format("{0:#}", -42)); 727 EXPECT_EQ("0b101010", fmt::format("{0:#b}", 42)); 728 EXPECT_EQ("0B101010", fmt::format("{0:#B}", 42)); 729 EXPECT_EQ("-0b101010", fmt::format("{0:#b}", -42)); 730 EXPECT_EQ("0x42", fmt::format("{0:#x}", 0x42)); 731 EXPECT_EQ("0X42", fmt::format("{0:#X}", 0x42)); 732 EXPECT_EQ("-0x42", fmt::format("{0:#x}", -0x42)); 733 EXPECT_EQ("0", fmt::format("{0:#o}", 0)); 734 EXPECT_EQ("042", fmt::format("{0:#o}", 042)); 735 EXPECT_EQ("-042", fmt::format("{0:#o}", -042)); 736 EXPECT_EQ("42", fmt::format("{0:#}", 42u)); 737 EXPECT_EQ("0x42", fmt::format("{0:#x}", 0x42u)); 738 EXPECT_EQ("042", fmt::format("{0:#o}", 042u)); 739 740 EXPECT_EQ("-42", fmt::format("{0:#}", -42l)); 741 EXPECT_EQ("0x42", fmt::format("{0:#x}", 0x42l)); 742 EXPECT_EQ("-0x42", fmt::format("{0:#x}", -0x42l)); 743 EXPECT_EQ("042", fmt::format("{0:#o}", 042l)); 744 EXPECT_EQ("-042", fmt::format("{0:#o}", -042l)); 745 EXPECT_EQ("42", fmt::format("{0:#}", 42ul)); 746 EXPECT_EQ("0x42", fmt::format("{0:#x}", 0x42ul)); 747 EXPECT_EQ("042", fmt::format("{0:#o}", 042ul)); 748 749 EXPECT_EQ("-42", fmt::format("{0:#}", -42ll)); 750 EXPECT_EQ("0x42", fmt::format("{0:#x}", 0x42ll)); 751 EXPECT_EQ("-0x42", fmt::format("{0:#x}", -0x42ll)); 752 EXPECT_EQ("042", fmt::format("{0:#o}", 042ll)); 753 EXPECT_EQ("-042", fmt::format("{0:#o}", -042ll)); 754 EXPECT_EQ("42", fmt::format("{0:#}", 42ull)); 755 EXPECT_EQ("0x42", fmt::format("{0:#x}", 0x42ull)); 756 EXPECT_EQ("042", fmt::format("{0:#o}", 042ull)); 757 758 EXPECT_EQ("-42.", fmt::format("{0:#}", -42.0)); 759 EXPECT_EQ("-42.", fmt::format("{0:#}", -42.0l)); 760 EXPECT_EQ("4.e+01", fmt::format("{:#.0e}", 42.0)); 761 EXPECT_EQ("0.", fmt::format("{:#.0f}", 0.01)); 762 EXPECT_EQ("0.50", fmt::format("{:#.2g}", 0.5)); 763 EXPECT_EQ("0.", fmt::format("{:#.0f}", 0.5)); 764 EXPECT_THROW_MSG((void)fmt::format(runtime("{0:#"), 'c'), format_error, 765 "missing '}' in format string"); 766 EXPECT_THROW_MSG((void)fmt::format(runtime("{0:#}"), 'c'), format_error, 767 "invalid format specifier for char"); 768 EXPECT_THROW_MSG((void)fmt::format(runtime("{0:#}"), "abc"), format_error, 769 "invalid format specifier"); 770 EXPECT_THROW_MSG( 771 (void)fmt::format(runtime("{0:#}"), reinterpret_cast<void*>(0x42)), 772 format_error, "invalid format specifier"); 773 } 774 775 TEST(format_test, zero_flag) { 776 EXPECT_EQ("42", fmt::format("{0:0}", 42)); 777 EXPECT_EQ("-0042", fmt::format("{0:05}", -42)); 778 EXPECT_EQ("00042", fmt::format("{0:05}", 42u)); 779 EXPECT_EQ("-0042", fmt::format("{0:05}", -42l)); 780 EXPECT_EQ("00042", fmt::format("{0:05}", 42ul)); 781 EXPECT_EQ("-0042", fmt::format("{0:05}", -42ll)); 782 EXPECT_EQ("00042", fmt::format("{0:05}", 42ull)); 783 EXPECT_EQ("-000042", fmt::format("{0:07}", -42.0)); 784 EXPECT_EQ("-000042", fmt::format("{0:07}", -42.0l)); 785 EXPECT_THROW_MSG((void)fmt::format(runtime("{0:0"), 'c'), format_error, 786 "missing '}' in format string"); 787 EXPECT_THROW_MSG((void)fmt::format(runtime("{0:05}"), 'c'), format_error, 788 "invalid format specifier for char"); 789 EXPECT_THROW_MSG((void)fmt::format(runtime("{0:05}"), "abc"), format_error, 790 "format specifier requires numeric argument"); 791 EXPECT_THROW_MSG( 792 (void)fmt::format(runtime("{0:05}"), reinterpret_cast<void*>(0x42)), 793 format_error, "format specifier requires numeric argument"); 794 } 795 796 TEST(format_test, zero_flag_and_align) { 797 // If the 0 character and an align option both appear, the 0 character is 798 // ignored. 799 EXPECT_EQ("42 ", fmt::format("{0:<05}", 42)); 800 EXPECT_EQ("-42 ", fmt::format("{0:<05}", -42)); 801 EXPECT_EQ(" 42 ", fmt::format("{0:^05}", 42)); 802 EXPECT_EQ(" -42 ", fmt::format("{0:^05}", -42)); 803 EXPECT_EQ(" 42", fmt::format("{0:>05}", 42)); 804 EXPECT_EQ(" -42", fmt::format("{0:>05}", -42)); 805 } 806 807 TEST(format_test, width) { 808 char format_str[buffer_size]; 809 safe_sprintf(format_str, "{0:%u", UINT_MAX); 810 increment(format_str + 3); 811 EXPECT_THROW_MSG((void)fmt::format(runtime(format_str), 0), format_error, 812 "number is too big"); 813 size_t size = std::strlen(format_str); 814 format_str[size] = '}'; 815 format_str[size + 1] = 0; 816 EXPECT_THROW_MSG((void)fmt::format(runtime(format_str), 0), format_error, 817 "number is too big"); 818 819 safe_sprintf(format_str, "{0:%u", INT_MAX + 1u); 820 EXPECT_THROW_MSG((void)fmt::format(runtime(format_str), 0), format_error, 821 "number is too big"); 822 safe_sprintf(format_str, "{0:%u}", INT_MAX + 1u); 823 EXPECT_THROW_MSG((void)fmt::format(runtime(format_str), 0), format_error, 824 "number is too big"); 825 EXPECT_EQ(" -42", fmt::format("{0:4}", -42)); 826 EXPECT_EQ(" 42", fmt::format("{0:5}", 42u)); 827 EXPECT_EQ(" -42", fmt::format("{0:6}", -42l)); 828 EXPECT_EQ(" 42", fmt::format("{0:7}", 42ul)); 829 EXPECT_EQ(" -42", fmt::format("{0:6}", -42ll)); 830 EXPECT_EQ(" 42", fmt::format("{0:7}", 42ull)); 831 EXPECT_EQ(" -1.23", fmt::format("{0:8}", -1.23)); 832 EXPECT_EQ(" -1.23", fmt::format("{0:9}", -1.23l)); 833 EXPECT_EQ(" 0xcafe", 834 fmt::format("{0:10}", reinterpret_cast<void*>(0xcafe))); 835 EXPECT_EQ("x ", fmt::format("{0:11}", 'x')); 836 EXPECT_EQ("str ", fmt::format("{0:12}", "str")); 837 EXPECT_EQ(fmt::format("{:*^6}", "🤡"), "**🤡**"); 838 EXPECT_EQ(fmt::format("{:*^8}", "你好"), "**你好**"); 839 EXPECT_EQ(fmt::format("{:#6}", 42.0), " 42."); 840 EXPECT_EQ(fmt::format("{:6c}", static_cast<int>('x')), "x "); 841 EXPECT_EQ(fmt::format("{:>06.0f}", 0.00884311), " 0"); 842 } 843 844 TEST(format_test, runtime_width) { 845 char format_str[buffer_size]; 846 safe_sprintf(format_str, "{0:{%u", UINT_MAX); 847 increment(format_str + 4); 848 EXPECT_THROW_MSG((void)fmt::format(runtime(format_str), 0), format_error, 849 "invalid format string"); 850 size_t size = std::strlen(format_str); 851 format_str[size] = '}'; 852 format_str[size + 1] = 0; 853 EXPECT_THROW_MSG((void)fmt::format(runtime(format_str), 0), format_error, 854 "argument not found"); 855 format_str[size + 1] = '}'; 856 format_str[size + 2] = 0; 857 EXPECT_THROW_MSG((void)fmt::format(runtime(format_str), 0), format_error, 858 "argument not found"); 859 860 EXPECT_THROW_MSG((void)fmt::format(runtime("{0:{"), 0), format_error, 861 "invalid format string"); 862 EXPECT_THROW_MSG((void)fmt::format(runtime("{0:{}"), 0), format_error, 863 "cannot switch from manual to automatic argument indexing"); 864 EXPECT_THROW_MSG((void)fmt::format(runtime("{0:{?}}"), 0), format_error, 865 "invalid format string"); 866 EXPECT_THROW_MSG((void)fmt::format(runtime("{0:{1}}"), 0), format_error, 867 "argument not found"); 868 869 EXPECT_THROW_MSG((void)fmt::format(runtime("{0:{0:}}"), 0), format_error, 870 "invalid format string"); 871 872 EXPECT_THROW_MSG((void)fmt::format(runtime("{0:{1}}"), 0, -1), format_error, 873 "negative width"); 874 EXPECT_THROW_MSG((void)fmt::format(runtime("{0:{1}}"), 0, (INT_MAX + 1u)), 875 format_error, "number is too big"); 876 EXPECT_THROW_MSG((void)fmt::format(runtime("{0:{1}}"), 0, -1l), format_error, 877 "negative width"); 878 if (fmt::detail::const_check(sizeof(long) > sizeof(int))) { 879 long value = INT_MAX; 880 EXPECT_THROW_MSG((void)fmt::format(runtime("{0:{1}}"), 0, (value + 1)), 881 format_error, "number is too big"); 882 } 883 EXPECT_THROW_MSG((void)fmt::format(runtime("{0:{1}}"), 0, (INT_MAX + 1ul)), 884 format_error, "number is too big"); 885 886 EXPECT_THROW_MSG((void)fmt::format(runtime("{0:{1}}"), 0, '0'), format_error, 887 "width is not integer"); 888 EXPECT_THROW_MSG((void)fmt::format(runtime("{0:{1}}"), 0, 0.0), format_error, 889 "width is not integer"); 890 891 EXPECT_EQ(" -42", fmt::format("{0:{1}}", -42, 4)); 892 EXPECT_EQ(" 42", fmt::format("{0:{1}}", 42u, 5)); 893 EXPECT_EQ(" -42", fmt::format("{0:{1}}", -42l, 6)); 894 EXPECT_EQ(" 42", fmt::format("{0:{1}}", 42ul, 7)); 895 EXPECT_EQ(" -42", fmt::format("{0:{1}}", -42ll, 6)); 896 EXPECT_EQ(" 42", fmt::format("{0:{1}}", 42ull, 7)); 897 EXPECT_EQ(" -1.23", fmt::format("{0:{1}}", -1.23, 8)); 898 EXPECT_EQ(" -1.23", fmt::format("{0:{1}}", -1.23l, 9)); 899 EXPECT_EQ(" 0xcafe", 900 fmt::format("{0:{1}}", reinterpret_cast<void*>(0xcafe), 10)); 901 EXPECT_EQ("x ", fmt::format("{0:{1}}", 'x', 11)); 902 EXPECT_EQ("str ", fmt::format("{0:{1}}", "str", 12)); 903 EXPECT_EQ(fmt::format("{:{}}", 42, short(4)), " 42"); 904 } 905 906 TEST(format_test, precision) { 907 char format_str[buffer_size]; 908 safe_sprintf(format_str, "{0:.%u", UINT_MAX); 909 increment(format_str + 4); 910 EXPECT_THROW_MSG((void)fmt::format(runtime(format_str), 0.0), format_error, 911 "number is too big"); 912 size_t size = std::strlen(format_str); 913 format_str[size] = '}'; 914 format_str[size + 1] = 0; 915 EXPECT_THROW_MSG((void)fmt::format(runtime(format_str), 0.0), format_error, 916 "number is too big"); 917 918 safe_sprintf(format_str, "{0:.%u", INT_MAX + 1u); 919 EXPECT_THROW_MSG((void)fmt::format(runtime(format_str), 0.0), format_error, 920 "number is too big"); 921 safe_sprintf(format_str, "{0:.%u}", INT_MAX + 1u); 922 EXPECT_THROW_MSG((void)fmt::format(runtime(format_str), 0.0), format_error, 923 "number is too big"); 924 925 EXPECT_THROW_MSG((void)fmt::format(runtime("{0:."), 0.0), format_error, 926 "invalid precision"); 927 EXPECT_THROW_MSG((void)fmt::format(runtime("{0:.}"), 0.0), format_error, 928 "invalid precision"); 929 930 EXPECT_THROW_MSG((void)fmt::format(runtime("{0:.2"), 0), format_error, 931 "invalid format specifier"); 932 EXPECT_THROW_MSG((void)fmt::format(runtime("{0:.2}"), 42), format_error, 933 "invalid format specifier"); 934 EXPECT_THROW_MSG((void)fmt::format(runtime("{0:.2f}"), 42), format_error, 935 "invalid format specifier"); 936 EXPECT_THROW_MSG((void)fmt::format(runtime("{0:.2}"), 42u), format_error, 937 "invalid format specifier"); 938 EXPECT_THROW_MSG((void)fmt::format(runtime("{0:.2f}"), 42u), format_error, 939 "invalid format specifier"); 940 EXPECT_THROW_MSG((void)fmt::format(runtime("{0:.2}"), 42l), format_error, 941 "invalid format specifier"); 942 EXPECT_THROW_MSG((void)fmt::format(runtime("{0:.2f}"), 42l), format_error, 943 "invalid format specifier"); 944 EXPECT_THROW_MSG((void)fmt::format(runtime("{0:.2}"), 42ul), format_error, 945 "invalid format specifier"); 946 EXPECT_THROW_MSG((void)fmt::format(runtime("{0:.2f}"), 42ul), format_error, 947 "invalid format specifier"); 948 EXPECT_THROW_MSG((void)fmt::format(runtime("{0:.2}"), 42ll), format_error, 949 "invalid format specifier"); 950 EXPECT_THROW_MSG((void)fmt::format(runtime("{0:.2f}"), 42ll), format_error, 951 "invalid format specifier"); 952 EXPECT_THROW_MSG((void)fmt::format(runtime("{0:.2}"), 42ull), format_error, 953 "invalid format specifier"); 954 EXPECT_THROW_MSG((void)fmt::format(runtime("{0:.2f}"), 42ull), format_error, 955 "invalid format specifier"); 956 EXPECT_THROW_MSG((void)fmt::format(runtime("{0:3.0}"), 'x'), format_error, 957 "invalid format specifier"); 958 EXPECT_EQ("1.2", fmt::format("{0:.2}", 1.2345)); 959 EXPECT_EQ("1.2", fmt::format("{0:.2}", 1.2345l)); 960 EXPECT_EQ("1.2e+56", fmt::format("{:.2}", 1.234e56)); 961 EXPECT_EQ("1.1", fmt::format("{0:.3}", 1.1)); 962 EXPECT_EQ("1e+00", fmt::format("{:.0e}", 1.0L)); 963 EXPECT_EQ(" 0.0e+00", fmt::format("{:9.1e}", 0.0)); 964 EXPECT_EQ( 965 fmt::format("{:.494}", 4.9406564584124654E-324), 966 "4.9406564584124654417656879286822137236505980261432476442558568250067550" 967 "727020875186529983636163599237979656469544571773092665671035593979639877" 968 "479601078187812630071319031140452784581716784898210368871863605699873072" 969 "305000638740915356498438731247339727316961514003171538539807412623856559" 970 "117102665855668676818703956031062493194527159149245532930545654440112748" 971 "012970999954193198940908041656332452475714786901472678015935523861155013" 972 "480352649347201937902681071074917033322268447533357208324319361e-324"); 973 EXPECT_EQ( 974 fmt::format("{:.1074f}", 1.1125369292536e-308), 975 "0.0000000000000000000000000000000000000000000000000000000000000000000000" 976 "000000000000000000000000000000000000000000000000000000000000000000000000" 977 "000000000000000000000000000000000000000000000000000000000000000000000000" 978 "000000000000000000000000000000000000000000000000000000000000000000000000" 979 "000000000000000000000111253692925360019747947051741965785554081512200979" 980 "355021686109411883779182127659725163430929750364498219730822952552570601" 981 "152163505899912777129583674906301179059298598412303893909188340988729019" 982 "014361467448914817838555156840459458527907308695109202499990850735085304" 983 "478476991912072201449236975063640913461919914396877093174125167509869762" 984 "482369631100360266123742648159508919592746619553246586039571522788247697" 985 "156360766271842991667238355464496455107749716934387136380536472531224398" 986 "559833794807213172371254492216255558078524900147957309382830827524104234" 987 "530961756787819847850302379672357738807808384667004752163416921762619527" 988 "462847642037420991432005657440259928195996762610375541867198059294212446" 989 "81962777939941034720757232455434770912461317493580281734466552734375"); 990 991 std::string outputs[] = { 992 "-0X1.41FE3FFE71C9E000000000000000000000000000000000000000000000000000000" 993 "000000000000000000000000000000000000000000000000000000000000000000000000" 994 "000000000000000000000000000000000000000000000000000000000000000000000000" 995 "000000000000000000000000000000000000000000000000000000000000000000000000" 996 "000000000000000000000000000000000000000000000000000000000000000000000000" 997 "000000000000000000000000000000000000000000000000000000000000000000000000" 998 "000000000000000000000000000000000000000000000000000000000000000000000000" 999 "000000000000000000000000000000000000000000000000000000000000000000000000" 1000 "000000000000000000000000000000000000000000000000000000000000000000000000" 1001 "000000000000000000000000000000000000000000000000000000000000000000000000" 1002 "000000000000000000000000000000000000000000000000000000000000000000000000" 1003 "000000000000000000000000000000000000000000000000000P+127", 1004 "-0XA.0FF1FFF38E4F0000000000000000000000000000000000000000000000000000000" 1005 "000000000000000000000000000000000000000000000000000000000000000000000000" 1006 "000000000000000000000000000000000000000000000000000000000000000000000000" 1007 "000000000000000000000000000000000000000000000000000000000000000000000000" 1008 "000000000000000000000000000000000000000000000000000000000000000000000000" 1009 "000000000000000000000000000000000000000000000000000000000000000000000000" 1010 "000000000000000000000000000000000000000000000000000000000000000000000000" 1011 "000000000000000000000000000000000000000000000000000000000000000000000000" 1012 "000000000000000000000000000000000000000000000000000000000000000000000000" 1013 "000000000000000000000000000000000000000000000000000000000000000000000000" 1014 "000000000000000000000000000000000000000000000000000000000000000000000000" 1015 "000000000000000000000000000000000000000000000000000P+124"}; 1016 EXPECT_THAT(outputs, 1017 testing::Contains(fmt::format("{:.838A}", -2.14001164E+38))); 1018 1019 if (std::numeric_limits<long double>::digits == 64) { 1020 auto ld = (std::numeric_limits<long double>::min)(); 1021 EXPECT_EQ(fmt::format("{:.0}", ld), "3e-4932"); 1022 EXPECT_EQ( 1023 fmt::format("{:0g}", std::numeric_limits<long double>::denorm_min()), 1024 "3.6452e-4951"); 1025 } 1026 1027 EXPECT_EQ("123.", fmt::format("{:#.0f}", 123.0)); 1028 EXPECT_EQ("1.23", fmt::format("{:.02f}", 1.234)); 1029 EXPECT_EQ("0.001", fmt::format("{:.1g}", 0.001)); 1030 EXPECT_EQ("1019666400", fmt::format("{}", 1019666432.0f)); 1031 EXPECT_EQ("1e+01", fmt::format("{:.0e}", 9.5)); 1032 EXPECT_EQ("1.0e-34", fmt::format("{:.1e}", 1e-34)); 1033 1034 EXPECT_THROW_MSG( 1035 (void)fmt::format(runtime("{0:.2}"), reinterpret_cast<void*>(0xcafe)), 1036 format_error, "invalid format specifier"); 1037 EXPECT_THROW_MSG( 1038 (void)fmt::format(runtime("{0:.2f}"), reinterpret_cast<void*>(0xcafe)), 1039 format_error, "invalid format specifier"); 1040 EXPECT_THROW_MSG((void)fmt::format(runtime("{:.{}e}"), 42.0, 1041 fmt::detail::max_value<int>()), 1042 format_error, "number is too big"); 1043 EXPECT_THROW_MSG( 1044 (void)fmt::format("{:.2147483646f}", -2.2121295195081227E+304), 1045 format_error, "number is too big"); 1046 1047 EXPECT_EQ("st", fmt::format("{0:.2}", "str")); 1048 EXPECT_EQ("вожык", fmt::format("{0:.5}", "вожыкі")); 1049 } 1050 1051 TEST(format_test, runtime_precision) { 1052 char format_str[buffer_size]; 1053 safe_sprintf(format_str, "{0:.{%u", UINT_MAX); 1054 increment(format_str + 5); 1055 EXPECT_THROW_MSG((void)fmt::format(runtime(format_str), 0.0), format_error, 1056 "invalid format string"); 1057 size_t size = std::strlen(format_str); 1058 format_str[size] = '}'; 1059 format_str[size + 1] = 0; 1060 EXPECT_THROW_MSG((void)fmt::format(runtime(format_str), 0.0), format_error, 1061 "argument not found"); 1062 format_str[size + 1] = '}'; 1063 format_str[size + 2] = 0; 1064 EXPECT_THROW_MSG((void)fmt::format(runtime(format_str), 0.0), format_error, 1065 "argument not found"); 1066 1067 EXPECT_THROW_MSG((void)fmt::format(runtime("{0:.{"), 0.0), format_error, 1068 "invalid format string"); 1069 EXPECT_THROW_MSG((void)fmt::format(runtime("{0:.{}"), 0.0), format_error, 1070 "cannot switch from manual to automatic argument indexing"); 1071 EXPECT_THROW_MSG((void)fmt::format(runtime("{0:.{?}}"), 0.0), format_error, 1072 "invalid format string"); 1073 EXPECT_THROW_MSG((void)fmt::format(runtime("{0:.{1}"), 0, 0), format_error, 1074 "invalid format specifier"); 1075 EXPECT_THROW_MSG((void)fmt::format(runtime("{0:.{1}}"), 0.0), format_error, 1076 "argument not found"); 1077 1078 EXPECT_THROW_MSG((void)fmt::format(runtime("{0:.{0:}}"), 0.0), format_error, 1079 "invalid format string"); 1080 1081 EXPECT_THROW_MSG((void)fmt::format(runtime("{0:.{1}}"), 0.0, -1), 1082 format_error, "negative precision"); 1083 EXPECT_THROW_MSG((void)fmt::format(runtime("{0:.{1}}"), 0.0, (INT_MAX + 1u)), 1084 format_error, "number is too big"); 1085 EXPECT_THROW_MSG((void)fmt::format(runtime("{0:.{1}}"), 0.0, -1l), 1086 format_error, "negative precision"); 1087 if (fmt::detail::const_check(sizeof(long) > sizeof(int))) { 1088 long value = INT_MAX; 1089 EXPECT_THROW_MSG((void)fmt::format(runtime("{0:.{1}}"), 0.0, (value + 1)), 1090 format_error, "number is too big"); 1091 } 1092 EXPECT_THROW_MSG((void)fmt::format(runtime("{0:.{1}}"), 0.0, (INT_MAX + 1ul)), 1093 format_error, "number is too big"); 1094 1095 EXPECT_THROW_MSG((void)fmt::format(runtime("{0:.{1}}"), 0.0, '0'), 1096 format_error, "precision is not integer"); 1097 EXPECT_THROW_MSG((void)fmt::format(runtime("{0:.{1}}"), 0.0, 0.0), 1098 format_error, "precision is not integer"); 1099 1100 EXPECT_THROW_MSG((void)fmt::format(runtime("{0:.{1}}"), 42, 2), format_error, 1101 "invalid format specifier"); 1102 EXPECT_THROW_MSG((void)fmt::format(runtime("{0:.{1}f}"), 42, 2), format_error, 1103 "invalid format specifier"); 1104 EXPECT_THROW_MSG((void)fmt::format(runtime("{0:.{1}}"), 42u, 2), format_error, 1105 "invalid format specifier"); 1106 EXPECT_THROW_MSG((void)fmt::format(runtime("{0:.{1}f}"), 42u, 2), 1107 format_error, "invalid format specifier"); 1108 EXPECT_THROW_MSG((void)fmt::format(runtime("{0:.{1}}"), 42l, 2), format_error, 1109 "invalid format specifier"); 1110 EXPECT_THROW_MSG((void)fmt::format(runtime("{0:.{1}f}"), 42l, 2), 1111 format_error, "invalid format specifier"); 1112 EXPECT_THROW_MSG((void)fmt::format(runtime("{0:.{1}}"), 42ul, 2), 1113 format_error, "invalid format specifier"); 1114 EXPECT_THROW_MSG((void)fmt::format(runtime("{0:.{1}f}"), 42ul, 2), 1115 format_error, "invalid format specifier"); 1116 EXPECT_THROW_MSG((void)fmt::format(runtime("{0:.{1}}"), 42ll, 2), 1117 format_error, "invalid format specifier"); 1118 EXPECT_THROW_MSG((void)fmt::format(runtime("{0:.{1}f}"), 42ll, 2), 1119 format_error, "invalid format specifier"); 1120 EXPECT_THROW_MSG((void)fmt::format(runtime("{0:.{1}}"), 42ull, 2), 1121 format_error, "invalid format specifier"); 1122 EXPECT_THROW_MSG((void)fmt::format(runtime("{0:.{1}f}"), 42ull, 2), 1123 format_error, "invalid format specifier"); 1124 EXPECT_THROW_MSG((void)fmt::format(runtime("{0:3.{1}}"), 'x', 0), 1125 format_error, "invalid format specifier"); 1126 EXPECT_EQ("1.2", fmt::format("{0:.{1}}", 1.2345, 2)); 1127 EXPECT_EQ("1.2", fmt::format("{1:.{0}}", 2, 1.2345l)); 1128 1129 EXPECT_THROW_MSG((void)fmt::format(runtime("{0:.{1}}"), 1130 reinterpret_cast<void*>(0xcafe), 2), 1131 format_error, "invalid format specifier"); 1132 EXPECT_THROW_MSG((void)fmt::format(runtime("{0:.{1}f}"), 1133 reinterpret_cast<void*>(0xcafe), 2), 1134 format_error, "invalid format specifier"); 1135 1136 EXPECT_EQ("st", fmt::format("{0:.{1}}", "str", 2)); 1137 } 1138 1139 TEST(format_test, format_bool) { 1140 EXPECT_EQ("true", fmt::format("{}", true)); 1141 EXPECT_EQ("false", fmt::format("{}", false)); 1142 EXPECT_EQ("1", fmt::format("{:d}", true)); 1143 EXPECT_EQ("true ", fmt::format("{:5}", true)); 1144 EXPECT_EQ("true", fmt::format("{:s}", true)); 1145 EXPECT_EQ("false", fmt::format("{:s}", false)); 1146 EXPECT_EQ("false ", fmt::format("{:6s}", false)); 1147 } 1148 1149 TEST(format_test, format_short) { 1150 short s = 42; 1151 EXPECT_EQ("42", fmt::format("{0:d}", s)); 1152 unsigned short us = 42; 1153 EXPECT_EQ("42", fmt::format("{0:d}", us)); 1154 } 1155 1156 template <typename T> 1157 void check_unknown_types(const T& value, const char* types, const char*) { 1158 char format_str[buffer_size]; 1159 const char* special = ".0123456789L?}"; 1160 for (int i = CHAR_MIN; i <= CHAR_MAX; ++i) { 1161 char c = static_cast<char>(i); 1162 if (std::strchr(types, c) || std::strchr(special, c) || !c) continue; 1163 safe_sprintf(format_str, "{0:10%c}", c); 1164 const char* message = "invalid format specifier"; 1165 EXPECT_THROW_MSG((void)fmt::format(runtime(format_str), value), 1166 format_error, message) 1167 << format_str << " " << message; 1168 } 1169 } 1170 1171 TEST(format_test, format_int) { 1172 EXPECT_THROW_MSG((void)fmt::format(runtime("{0:v"), 42), format_error, 1173 "invalid format specifier"); 1174 check_unknown_types(42, "bBdoxXnLc", "integer"); 1175 EXPECT_EQ("x", fmt::format("{:c}", static_cast<int>('x'))); 1176 } 1177 1178 TEST(format_test, format_bin) { 1179 EXPECT_EQ("0", fmt::format("{0:b}", 0)); 1180 EXPECT_EQ("101010", fmt::format("{0:b}", 42)); 1181 EXPECT_EQ("101010", fmt::format("{0:b}", 42u)); 1182 EXPECT_EQ("-101010", fmt::format("{0:b}", -42)); 1183 EXPECT_EQ("11000000111001", fmt::format("{0:b}", 12345)); 1184 EXPECT_EQ("10010001101000101011001111000", fmt::format("{0:b}", 0x12345678)); 1185 EXPECT_EQ("10010000101010111100110111101111", 1186 fmt::format("{0:b}", 0x90ABCDEF)); 1187 EXPECT_EQ("11111111111111111111111111111111", 1188 fmt::format("{0:b}", max_value<uint32_t>())); 1189 } 1190 1191 #if FMT_USE_INT128 1192 constexpr auto int128_max = static_cast<__int128_t>( 1193 (static_cast<__uint128_t>(1) << ((__SIZEOF_INT128__ * CHAR_BIT) - 1)) - 1); 1194 constexpr auto int128_min = -int128_max - 1; 1195 1196 constexpr auto uint128_max = ~static_cast<__uint128_t>(0); 1197 #endif 1198 1199 TEST(format_test, format_dec) { 1200 EXPECT_EQ("0", fmt::format("{0}", 0)); 1201 EXPECT_EQ("42", fmt::format("{0}", 42)); 1202 EXPECT_EQ("42>", fmt::format("{:}>", 42)); 1203 EXPECT_EQ("42", fmt::format("{0:d}", 42)); 1204 EXPECT_EQ("42", fmt::format("{0}", 42u)); 1205 EXPECT_EQ("-42", fmt::format("{0}", -42)); 1206 EXPECT_EQ("12345", fmt::format("{0}", 12345)); 1207 EXPECT_EQ("67890", fmt::format("{0}", 67890)); 1208 #if FMT_USE_INT128 1209 EXPECT_EQ("0", fmt::format("{0}", static_cast<__int128_t>(0))); 1210 EXPECT_EQ("0", fmt::format("{0}", static_cast<__uint128_t>(0))); 1211 EXPECT_EQ("9223372036854775808", 1212 fmt::format("{0}", static_cast<__int128_t>(INT64_MAX) + 1)); 1213 EXPECT_EQ("-9223372036854775809", 1214 fmt::format("{0}", static_cast<__int128_t>(INT64_MIN) - 1)); 1215 EXPECT_EQ("18446744073709551616", 1216 fmt::format("{0}", static_cast<__int128_t>(UINT64_MAX) + 1)); 1217 EXPECT_EQ("170141183460469231731687303715884105727", 1218 fmt::format("{0}", int128_max)); 1219 EXPECT_EQ("-170141183460469231731687303715884105728", 1220 fmt::format("{0}", int128_min)); 1221 EXPECT_EQ("340282366920938463463374607431768211455", 1222 fmt::format("{0}", uint128_max)); 1223 #endif 1224 1225 char buffer[buffer_size]; 1226 safe_sprintf(buffer, "%d", INT_MIN); 1227 EXPECT_EQ(buffer, fmt::format("{0}", INT_MIN)); 1228 safe_sprintf(buffer, "%d", INT_MAX); 1229 EXPECT_EQ(buffer, fmt::format("{0}", INT_MAX)); 1230 safe_sprintf(buffer, "%u", UINT_MAX); 1231 EXPECT_EQ(buffer, fmt::format("{0}", UINT_MAX)); 1232 safe_sprintf(buffer, "%ld", 0 - static_cast<unsigned long>(LONG_MIN)); 1233 EXPECT_EQ(buffer, fmt::format("{0}", LONG_MIN)); 1234 safe_sprintf(buffer, "%ld", LONG_MAX); 1235 EXPECT_EQ(buffer, fmt::format("{0}", LONG_MAX)); 1236 safe_sprintf(buffer, "%lu", ULONG_MAX); 1237 EXPECT_EQ(buffer, fmt::format("{0}", ULONG_MAX)); 1238 } 1239 1240 TEST(format_test, format_hex) { 1241 EXPECT_EQ("0", fmt::format("{0:x}", 0)); 1242 EXPECT_EQ("42", fmt::format("{0:x}", 0x42)); 1243 EXPECT_EQ("42", fmt::format("{0:x}", 0x42u)); 1244 EXPECT_EQ("-42", fmt::format("{0:x}", -0x42)); 1245 EXPECT_EQ("12345678", fmt::format("{0:x}", 0x12345678)); 1246 EXPECT_EQ("90abcdef", fmt::format("{0:x}", 0x90abcdef)); 1247 EXPECT_EQ("12345678", fmt::format("{0:X}", 0x12345678)); 1248 EXPECT_EQ("90ABCDEF", fmt::format("{0:X}", 0x90ABCDEF)); 1249 #if FMT_USE_INT128 1250 EXPECT_EQ("0", fmt::format("{0:x}", static_cast<__int128_t>(0))); 1251 EXPECT_EQ("0", fmt::format("{0:x}", static_cast<__uint128_t>(0))); 1252 EXPECT_EQ("8000000000000000", 1253 fmt::format("{0:x}", static_cast<__int128_t>(INT64_MAX) + 1)); 1254 EXPECT_EQ("-8000000000000001", 1255 fmt::format("{0:x}", static_cast<__int128_t>(INT64_MIN) - 1)); 1256 EXPECT_EQ("10000000000000000", 1257 fmt::format("{0:x}", static_cast<__int128_t>(UINT64_MAX) + 1)); 1258 EXPECT_EQ("7fffffffffffffffffffffffffffffff", 1259 fmt::format("{0:x}", int128_max)); 1260 EXPECT_EQ("-80000000000000000000000000000000", 1261 fmt::format("{0:x}", int128_min)); 1262 EXPECT_EQ("ffffffffffffffffffffffffffffffff", 1263 fmt::format("{0:x}", uint128_max)); 1264 #endif 1265 1266 char buffer[buffer_size]; 1267 safe_sprintf(buffer, "-%x", 0 - static_cast<unsigned>(INT_MIN)); 1268 EXPECT_EQ(buffer, fmt::format("{0:x}", INT_MIN)); 1269 safe_sprintf(buffer, "%x", INT_MAX); 1270 EXPECT_EQ(buffer, fmt::format("{0:x}", INT_MAX)); 1271 safe_sprintf(buffer, "%x", UINT_MAX); 1272 EXPECT_EQ(buffer, fmt::format("{0:x}", UINT_MAX)); 1273 safe_sprintf(buffer, "-%lx", 0 - static_cast<unsigned long>(LONG_MIN)); 1274 EXPECT_EQ(buffer, fmt::format("{0:x}", LONG_MIN)); 1275 safe_sprintf(buffer, "%lx", LONG_MAX); 1276 EXPECT_EQ(buffer, fmt::format("{0:x}", LONG_MAX)); 1277 safe_sprintf(buffer, "%lx", ULONG_MAX); 1278 EXPECT_EQ(buffer, fmt::format("{0:x}", ULONG_MAX)); 1279 } 1280 1281 TEST(format_test, format_oct) { 1282 EXPECT_EQ("0", fmt::format("{0:o}", 0)); 1283 EXPECT_EQ("42", fmt::format("{0:o}", 042)); 1284 EXPECT_EQ("42", fmt::format("{0:o}", 042u)); 1285 EXPECT_EQ("-42", fmt::format("{0:o}", -042)); 1286 EXPECT_EQ("12345670", fmt::format("{0:o}", 012345670)); 1287 #if FMT_USE_INT128 1288 EXPECT_EQ("0", fmt::format("{0:o}", static_cast<__int128_t>(0))); 1289 EXPECT_EQ("0", fmt::format("{0:o}", static_cast<__uint128_t>(0))); 1290 EXPECT_EQ("1000000000000000000000", 1291 fmt::format("{0:o}", static_cast<__int128_t>(INT64_MAX) + 1)); 1292 EXPECT_EQ("-1000000000000000000001", 1293 fmt::format("{0:o}", static_cast<__int128_t>(INT64_MIN) - 1)); 1294 EXPECT_EQ("2000000000000000000000", 1295 fmt::format("{0:o}", static_cast<__int128_t>(UINT64_MAX) + 1)); 1296 EXPECT_EQ("1777777777777777777777777777777777777777777", 1297 fmt::format("{0:o}", int128_max)); 1298 EXPECT_EQ("-2000000000000000000000000000000000000000000", 1299 fmt::format("{0:o}", int128_min)); 1300 EXPECT_EQ("3777777777777777777777777777777777777777777", 1301 fmt::format("{0:o}", uint128_max)); 1302 #endif 1303 1304 char buffer[buffer_size]; 1305 safe_sprintf(buffer, "-%o", 0 - static_cast<unsigned>(INT_MIN)); 1306 EXPECT_EQ(buffer, fmt::format("{0:o}", INT_MIN)); 1307 safe_sprintf(buffer, "%o", INT_MAX); 1308 EXPECT_EQ(buffer, fmt::format("{0:o}", INT_MAX)); 1309 safe_sprintf(buffer, "%o", UINT_MAX); 1310 EXPECT_EQ(buffer, fmt::format("{0:o}", UINT_MAX)); 1311 safe_sprintf(buffer, "-%lo", 0 - static_cast<unsigned long>(LONG_MIN)); 1312 EXPECT_EQ(buffer, fmt::format("{0:o}", LONG_MIN)); 1313 safe_sprintf(buffer, "%lo", LONG_MAX); 1314 EXPECT_EQ(buffer, fmt::format("{0:o}", LONG_MAX)); 1315 safe_sprintf(buffer, "%lo", ULONG_MAX); 1316 EXPECT_EQ(buffer, fmt::format("{0:o}", ULONG_MAX)); 1317 } 1318 1319 TEST(format_test, format_int_locale) { 1320 EXPECT_EQ("1234", fmt::format("{:L}", 1234)); 1321 } 1322 1323 TEST(format_test, format_float) { 1324 EXPECT_EQ("0", fmt::format("{}", 0.0f)); 1325 EXPECT_EQ("392.500000", fmt::format("{0:f}", 392.5f)); 1326 } 1327 1328 TEST(format_test, format_double) { 1329 EXPECT_EQ(fmt::format("{}", 0.0), "0"); 1330 check_unknown_types(1.2, "eEfFgGaAnL%", "double"); 1331 EXPECT_EQ(fmt::format("{:}", 0.0), "0"); 1332 EXPECT_EQ(fmt::format("{:f}", 0.0), "0.000000"); 1333 EXPECT_EQ(fmt::format("{:g}", 0.0), "0"); 1334 EXPECT_EQ(fmt::format("{:}", 392.65), "392.65"); 1335 EXPECT_EQ(fmt::format("{:g}", 392.65), "392.65"); 1336 EXPECT_EQ(fmt::format("{:G}", 392.65), "392.65"); 1337 EXPECT_EQ(fmt::format("{:g}", 4.9014e6), "4.9014e+06"); 1338 EXPECT_EQ(fmt::format("{:f}", 392.65), "392.650000"); 1339 EXPECT_EQ(fmt::format("{:F}", 392.65), "392.650000"); 1340 EXPECT_EQ(fmt::format("{:L}", 42.0), "42"); 1341 EXPECT_EQ(fmt::format("{:24a}", 4.2f), " 0x1.0cccccp+2"); 1342 EXPECT_EQ(fmt::format("{:24a}", 4.2), " 0x1.0cccccccccccdp+2"); 1343 EXPECT_EQ(fmt::format("{:<24a}", 4.2), "0x1.0cccccccccccdp+2 "); 1344 EXPECT_EQ(fmt::format("{0:e}", 392.65), "3.926500e+02"); 1345 EXPECT_EQ(fmt::format("{0:E}", 392.65), "3.926500E+02"); 1346 EXPECT_EQ(fmt::format("{0:+010.4g}", 392.65), "+0000392.6"); 1347 char buffer[buffer_size]; 1348 1349 #if FMT_CPLUSPLUS >= 201703L 1350 double xd = 0x1.ffffffffffp+2; 1351 safe_sprintf(buffer, "%.*a", 10, xd); 1352 EXPECT_EQ(fmt::format("{:.10a}", xd), buffer); 1353 safe_sprintf(buffer, "%.*a", 9, xd); 1354 EXPECT_EQ(fmt::format("{:.9a}", xd), buffer); 1355 1356 if (std::numeric_limits<long double>::digits == 64) { 1357 auto ld = 0xf.ffffffffffp-3l; 1358 EXPECT_EQ(fmt::format("{:a}", ld), "0xf.ffffffffffp-3"); 1359 EXPECT_EQ(fmt::format("{:.10a}", ld), "0xf.ffffffffffp-3"); 1360 EXPECT_EQ(fmt::format("{:.9a}", ld), "0x1.000000000p+1"); 1361 } 1362 #endif 1363 1364 if (fmt::detail::const_check(std::numeric_limits<double>::is_iec559)) { 1365 double d = (std::numeric_limits<double>::min)(); 1366 EXPECT_EQ(fmt::format("{:a}", d), "0x1p-1022"); 1367 EXPECT_EQ(fmt::format("{:#a}", d), "0x1.p-1022"); 1368 1369 d = (std::numeric_limits<double>::max)(); 1370 safe_sprintf(buffer, "%a", d); 1371 EXPECT_EQ(fmt::format("{:a}", d), buffer); 1372 1373 d = std::numeric_limits<double>::denorm_min(); 1374 EXPECT_EQ(fmt::format("{:a}", d), "0x0.0000000000001p-1022"); 1375 } 1376 1377 if (std::numeric_limits<long double>::digits == 64) { 1378 auto ld = (std::numeric_limits<long double>::min)(); 1379 EXPECT_EQ(fmt::format("{:a}", ld), "0x8p-16385"); 1380 1381 ld = (std::numeric_limits<long double>::max)(); 1382 EXPECT_EQ(fmt::format("{:a}", ld), "0xf.fffffffffffffffp+16380"); 1383 1384 ld = std::numeric_limits<long double>::denorm_min(); 1385 EXPECT_EQ(fmt::format("{:a}", ld), "0x0.000000000000001p-16382"); 1386 } 1387 1388 safe_sprintf(buffer, "%.*a", 10, 4.2); 1389 EXPECT_EQ(fmt::format("{:.10a}", 4.2), buffer); 1390 1391 EXPECT_EQ(fmt::format("{:a}", -42.0), "-0x1.5p+5"); 1392 EXPECT_EQ(fmt::format("{:A}", -42.0), "-0X1.5P+5"); 1393 1394 EXPECT_EQ(fmt::format("{:f}", 9223372036854775807.0), 1395 "9223372036854775808.000000"); 1396 } 1397 1398 TEST(format_test, precision_rounding) { 1399 EXPECT_EQ("0", fmt::format("{:.0f}", 0.0)); 1400 EXPECT_EQ("0", fmt::format("{:.0f}", 0.01)); 1401 EXPECT_EQ("0", fmt::format("{:.0f}", 0.1)); 1402 EXPECT_EQ("0.000", fmt::format("{:.3f}", 0.00049)); 1403 EXPECT_EQ("0.001", fmt::format("{:.3f}", 0.0005)); 1404 EXPECT_EQ("0.001", fmt::format("{:.3f}", 0.00149)); 1405 EXPECT_EQ("0.002", fmt::format("{:.3f}", 0.0015)); 1406 EXPECT_EQ("1.000", fmt::format("{:.3f}", 0.9999)); 1407 EXPECT_EQ("0.00123", fmt::format("{:.3}", 0.00123)); 1408 EXPECT_EQ("0.1", fmt::format("{:.16g}", 0.1)); 1409 EXPECT_EQ("1", fmt::format("{:.0}", 1.0)); 1410 EXPECT_EQ("225.51575035152063720", 1411 fmt::format("{:.17f}", 225.51575035152064)); 1412 EXPECT_EQ("-761519619559038.2", fmt::format("{:.1f}", -761519619559038.2)); 1413 EXPECT_EQ("1.9156918820264798e-56", 1414 fmt::format("{}", 1.9156918820264798e-56)); 1415 EXPECT_EQ("0.0000", fmt::format("{:.4f}", 7.2809479766055470e-15)); 1416 } 1417 1418 TEST(format_test, prettify_float) { 1419 EXPECT_EQ("0.0001", fmt::format("{}", 1e-4)); 1420 EXPECT_EQ("1e-05", fmt::format("{}", 1e-5)); 1421 EXPECT_EQ("1000000000000000", fmt::format("{}", 1e15)); 1422 EXPECT_EQ("1e+16", fmt::format("{}", 1e16)); 1423 EXPECT_EQ("9.999e-05", fmt::format("{}", 9.999e-5)); 1424 EXPECT_EQ("10000000000", fmt::format("{}", 1e10)); 1425 EXPECT_EQ("100000000000", fmt::format("{}", 1e11)); 1426 EXPECT_EQ("12340000000", fmt::format("{}", 1234e7)); 1427 EXPECT_EQ("12.34", fmt::format("{}", 1234e-2)); 1428 EXPECT_EQ("0.001234", fmt::format("{}", 1234e-6)); 1429 EXPECT_EQ("0.1", fmt::format("{}", 0.1f)); 1430 EXPECT_EQ("1.3563156e-19", fmt::format("{}", 1.35631564e-19f)); 1431 } 1432 1433 TEST(format_test, format_nan) { 1434 double nan = std::numeric_limits<double>::quiet_NaN(); 1435 EXPECT_EQ("nan", fmt::format("{}", nan)); 1436 EXPECT_EQ("+nan", fmt::format("{:+}", nan)); 1437 EXPECT_EQ(" +nan", fmt::format("{:+06}", nan)); 1438 EXPECT_EQ("+nan ", fmt::format("{:<+06}", nan)); 1439 EXPECT_EQ(" +nan ", fmt::format("{:^+06}", nan)); 1440 EXPECT_EQ(" +nan", fmt::format("{:>+06}", nan)); 1441 if (std::signbit(-nan)) { 1442 EXPECT_EQ("-nan", fmt::format("{}", -nan)); 1443 EXPECT_EQ(" -nan", fmt::format("{:+06}", -nan)); 1444 } else { 1445 fmt::print("Warning: compiler doesn't handle negative NaN correctly"); 1446 } 1447 EXPECT_EQ(" nan", fmt::format("{: }", nan)); 1448 EXPECT_EQ("NAN", fmt::format("{:F}", nan)); 1449 EXPECT_EQ("nan ", fmt::format("{:<7}", nan)); 1450 EXPECT_EQ(" nan ", fmt::format("{:^7}", nan)); 1451 EXPECT_EQ(" nan", fmt::format("{:>7}", nan)); 1452 } 1453 1454 TEST(format_test, format_infinity) { 1455 double inf = std::numeric_limits<double>::infinity(); 1456 EXPECT_EQ("inf", fmt::format("{}", inf)); 1457 EXPECT_EQ("+inf", fmt::format("{:+}", inf)); 1458 EXPECT_EQ("-inf", fmt::format("{}", -inf)); 1459 EXPECT_EQ(" +inf", fmt::format("{:+06}", inf)); 1460 EXPECT_EQ(" -inf", fmt::format("{:+06}", -inf)); 1461 EXPECT_EQ("+inf ", fmt::format("{:<+06}", inf)); 1462 EXPECT_EQ(" +inf ", fmt::format("{:^+06}", inf)); 1463 EXPECT_EQ(" +inf", fmt::format("{:>+06}", inf)); 1464 EXPECT_EQ(" inf", fmt::format("{: }", inf)); 1465 EXPECT_EQ("INF", fmt::format("{:F}", inf)); 1466 EXPECT_EQ("inf ", fmt::format("{:<7}", inf)); 1467 EXPECT_EQ(" inf ", fmt::format("{:^7}", inf)); 1468 EXPECT_EQ(" inf", fmt::format("{:>7}", inf)); 1469 } 1470 1471 TEST(format_test, format_long_double) { 1472 EXPECT_EQ("0", fmt::format("{0:}", 0.0l)); 1473 EXPECT_EQ("0.000000", fmt::format("{0:f}", 0.0l)); 1474 EXPECT_EQ("0.0", fmt::format("{:.1f}", 0.000000001l)); 1475 EXPECT_EQ("0.10", fmt::format("{:.2f}", 0.099l)); 1476 EXPECT_EQ("392.65", fmt::format("{0:}", 392.65l)); 1477 EXPECT_EQ("392.65", fmt::format("{0:g}", 392.65l)); 1478 EXPECT_EQ("392.65", fmt::format("{0:G}", 392.65l)); 1479 EXPECT_EQ("392.650000", fmt::format("{0:f}", 392.65l)); 1480 EXPECT_EQ("392.650000", fmt::format("{0:F}", 392.65l)); 1481 char buffer[buffer_size]; 1482 safe_sprintf(buffer, "%Le", 392.65l); 1483 EXPECT_EQ(buffer, fmt::format("{0:e}", 392.65l)); 1484 EXPECT_EQ("+0000392.6", fmt::format("{0:+010.4g}", 392.64l)); 1485 1486 auto ld = 3.31l; 1487 if (fmt::detail::is_double_double<decltype(ld)>::value) { 1488 safe_sprintf(buffer, "%a", static_cast<double>(ld)); 1489 EXPECT_EQ(buffer, fmt::format("{:a}", ld)); 1490 } else if (std::numeric_limits<long double>::digits == 64) { 1491 EXPECT_EQ(fmt::format("{:a}", ld), "0xd.3d70a3d70a3d70ap-2"); 1492 } 1493 } 1494 1495 TEST(format_test, format_char) { 1496 const char types[] = "cbBdoxX"; 1497 check_unknown_types('a', types, "char"); 1498 EXPECT_EQ("a", fmt::format("{0}", 'a')); 1499 EXPECT_EQ("z", fmt::format("{0:c}", 'z')); 1500 int n = 'x'; 1501 for (const char* type = types + 1; *type; ++type) { 1502 std::string format_str = fmt::format("{{:{}}}", *type); 1503 EXPECT_EQ(fmt::format(runtime(format_str), n), 1504 fmt::format(runtime(format_str), 'x')) 1505 << format_str; 1506 } 1507 EXPECT_EQ(fmt::format("{:02X}", n), fmt::format("{:02X}", 'x')); 1508 1509 EXPECT_EQ("\n", fmt::format("{}", '\n')); 1510 EXPECT_EQ("'\\n'", fmt::format("{:?}", '\n')); 1511 EXPECT_EQ("ff", fmt::format("{:x}", '\xff')); 1512 } 1513 1514 TEST(format_test, format_volatile_char) { 1515 volatile char c = 'x'; 1516 EXPECT_EQ("x", fmt::format("{}", c)); 1517 } 1518 1519 TEST(format_test, format_unsigned_char) { 1520 EXPECT_EQ("42", fmt::format("{}", static_cast<unsigned char>(42))); 1521 EXPECT_EQ("42", fmt::format("{}", static_cast<uint8_t>(42))); 1522 } 1523 1524 TEST(format_test, format_cstring) { 1525 check_unknown_types("test", "sp", "string"); 1526 EXPECT_EQ("test", fmt::format("{0}", "test")); 1527 EXPECT_EQ("test", fmt::format("{0:s}", "test")); 1528 char nonconst[] = "nonconst"; 1529 EXPECT_EQ("nonconst", fmt::format("{0}", nonconst)); 1530 EXPECT_THROW_MSG( 1531 (void)fmt::format(runtime("{0}"), static_cast<const char*>(nullptr)), 1532 format_error, "string pointer is null"); 1533 } 1534 1535 void function_pointer_test(int, double, std::string) {} 1536 1537 TEST(format_test, format_pointer) { 1538 check_unknown_types(reinterpret_cast<void*>(0x1234), "p", "pointer"); 1539 EXPECT_EQ("0x0", fmt::format("{0}", static_cast<void*>(nullptr))); 1540 EXPECT_EQ("0x1234", fmt::format("{0}", reinterpret_cast<void*>(0x1234))); 1541 EXPECT_EQ("0x1234", fmt::format("{0:p}", reinterpret_cast<void*>(0x1234))); 1542 // On CHERI (or other fat-pointer) systems, the size of a pointer is greater 1543 // than the size an integer that can hold a virtual address. There is no 1544 // portable address-as-an-integer type (yet) in C++, so we use `size_t` as 1545 // the closest equivalent for now. 1546 EXPECT_EQ("0x" + std::string(sizeof(size_t) * CHAR_BIT / 4, 'f'), 1547 fmt::format("{0}", reinterpret_cast<void*>(~uintptr_t()))); 1548 EXPECT_EQ("0x1234", 1549 fmt::format("{}", fmt::ptr(reinterpret_cast<int*>(0x1234)))); 1550 std::unique_ptr<int> up(new int(1)); 1551 EXPECT_EQ(fmt::format("{}", fmt::ptr(up.get())), 1552 fmt::format("{}", fmt::ptr(up))); 1553 struct custom_deleter { 1554 void operator()(int* p) const { delete p; } 1555 }; 1556 std::unique_ptr<int, custom_deleter> upcd(new int(1)); 1557 EXPECT_EQ(fmt::format("{}", fmt::ptr(upcd.get())), 1558 fmt::format("{}", fmt::ptr(upcd))); 1559 std::shared_ptr<int> sp(new int(1)); 1560 EXPECT_EQ(fmt::format("{}", fmt::ptr(sp.get())), 1561 fmt::format("{}", fmt::ptr(sp))); 1562 EXPECT_EQ(fmt::format("{}", fmt::detail::bit_cast<const void*>( 1563 &function_pointer_test)), 1564 fmt::format("{}", fmt::ptr(function_pointer_test))); 1565 EXPECT_EQ("0x0", fmt::format("{}", nullptr)); 1566 } 1567 1568 TEST(format_test, write_uintptr_fallback) { 1569 // Test that formatting a pointer by converting it to uint128_fallback works. 1570 // This is needed to support systems without uintptr_t. 1571 auto s = std::string(); 1572 fmt::detail::write_ptr<char>( 1573 std::back_inserter(s), 1574 fmt::detail::bit_cast<fmt::detail::uint128_fallback>( 1575 reinterpret_cast<void*>(0xface)), 1576 nullptr); 1577 EXPECT_EQ(s, "0xface"); 1578 } 1579 1580 enum class color { red, green, blue }; 1581 1582 namespace test_ns { 1583 enum class color { red, green, blue }; 1584 using fmt::enums::format_as; 1585 } // namespace test_ns 1586 1587 TEST(format_test, format_enum_class) { 1588 EXPECT_EQ(fmt::format("{}", fmt::underlying(color::red)), "0"); 1589 EXPECT_EQ(fmt::format("{}", test_ns::color::red), "0"); 1590 } 1591 1592 TEST(format_test, format_string) { 1593 EXPECT_EQ(fmt::format("{0}", std::string("test")), "test"); 1594 EXPECT_EQ(fmt::format("{0}", std::string("test")), "test"); 1595 EXPECT_EQ(fmt::format("{:?}", std::string("test")), "\"test\""); 1596 EXPECT_EQ(fmt::format("{:*^10?}", std::string("test")), "**\"test\"**"); 1597 EXPECT_EQ(fmt::format("{:?}", std::string("\test")), "\"\\test\""); 1598 EXPECT_THROW((void)fmt::format(fmt::runtime("{:x}"), std::string("test")), 1599 fmt::format_error); 1600 } 1601 1602 TEST(format_test, format_string_view) { 1603 EXPECT_EQ("test", fmt::format("{}", string_view("test"))); 1604 EXPECT_EQ("\"t\\nst\"", fmt::format("{:?}", string_view("t\nst"))); 1605 EXPECT_EQ("", fmt::format("{}", string_view())); 1606 } 1607 1608 #ifdef FMT_USE_STRING_VIEW 1609 struct string_viewable {}; 1610 1611 FMT_BEGIN_NAMESPACE 1612 template <> struct formatter<string_viewable> : formatter<std::string_view> { 1613 auto format(string_viewable, format_context& ctx) -> decltype(ctx.out()) { 1614 return formatter<std::string_view>::format("foo", ctx); 1615 } 1616 }; 1617 FMT_END_NAMESPACE 1618 1619 TEST(format_test, format_std_string_view) { 1620 EXPECT_EQ("test", fmt::format("{}", std::string_view("test"))); 1621 EXPECT_EQ("foo", fmt::format("{}", string_viewable())); 1622 } 1623 1624 struct explicitly_convertible_to_std_string_view { 1625 explicit operator std::string_view() const { return "foo"; } 1626 }; 1627 1628 template <> 1629 struct fmt::formatter<explicitly_convertible_to_std_string_view> 1630 : formatter<std::string_view> { 1631 auto format(explicitly_convertible_to_std_string_view v, format_context& ctx) 1632 -> decltype(ctx.out()) { 1633 return fmt::format_to(ctx.out(), "'{}'", std::string_view(v)); 1634 } 1635 }; 1636 1637 TEST(format_test, format_explicitly_convertible_to_std_string_view) { 1638 EXPECT_EQ("'foo'", 1639 fmt::format("{}", explicitly_convertible_to_std_string_view())); 1640 } 1641 #endif 1642 1643 class Answer {}; 1644 1645 FMT_BEGIN_NAMESPACE 1646 template <> struct formatter<date> { 1647 template <typename ParseContext> 1648 FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) { 1649 auto it = ctx.begin(); 1650 if (it != ctx.end() && *it == 'd') ++it; 1651 return it; 1652 } 1653 1654 auto format(const date& d, format_context& ctx) -> decltype(ctx.out()) { 1655 // Namespace-qualify to avoid ambiguity with std::format_to. 1656 fmt::format_to(ctx.out(), "{}-{}-{}", d.year(), d.month(), d.day()); 1657 return ctx.out(); 1658 } 1659 }; 1660 1661 template <> struct formatter<Answer> : formatter<int> { 1662 template <typename FormatContext> 1663 auto format(Answer, FormatContext& ctx) -> decltype(ctx.out()) { 1664 return formatter<int>::format(42, ctx); 1665 } 1666 }; 1667 FMT_END_NAMESPACE 1668 1669 TEST(format_test, format_custom) { 1670 EXPECT_THROW_MSG((void)fmt::format(runtime("{:s}"), date(2012, 12, 9)), 1671 format_error, "unknown format specifier"); 1672 EXPECT_EQ("42", fmt::format("{0}", Answer())); 1673 EXPECT_EQ("0042", fmt::format("{:04}", Answer())); 1674 } 1675 1676 TEST(format_test, format_to_custom) { 1677 char buf[10] = {}; 1678 auto end = fmt::format_to(buf, "{}", Answer()); 1679 EXPECT_EQ(end, buf + 2); 1680 EXPECT_STREQ(buf, "42"); 1681 } 1682 1683 TEST(format_test, format_string_from_speed_test) { 1684 EXPECT_EQ("1.2340000000:0042:+3.13:str:0x3e8:X:%", 1685 fmt::format("{0:0.10f}:{1:04}:{2:+g}:{3}:{4}:{5}:%", 1.234, 42, 1686 3.13, "str", reinterpret_cast<void*>(1000), 'X')); 1687 } 1688 1689 TEST(format_test, format_examples) { 1690 std::string message = fmt::format("The answer is {}", 42); 1691 EXPECT_EQ("The answer is 42", message); 1692 1693 EXPECT_EQ("42", fmt::format("{}", 42)); 1694 1695 memory_buffer out; 1696 fmt::format_to(std::back_inserter(out), "The answer is {}.", 42); 1697 EXPECT_EQ("The answer is 42.", to_string(out)); 1698 1699 const char* filename = "nonexistent"; 1700 FILE* ftest = safe_fopen(filename, "r"); 1701 if (ftest) fclose(ftest); 1702 int error_code = errno; 1703 EXPECT_TRUE(ftest == nullptr); 1704 EXPECT_SYSTEM_ERROR( 1705 { 1706 FILE* f = safe_fopen(filename, "r"); 1707 if (!f) 1708 throw fmt::system_error(errno, "Cannot open file '{}'", filename); 1709 fclose(f); 1710 }, 1711 error_code, "Cannot open file 'nonexistent'"); 1712 1713 EXPECT_EQ("First, thou shalt count to three", 1714 fmt::format("First, thou shalt count to {0}", "three")); 1715 EXPECT_EQ("Bring me a shrubbery", fmt::format("Bring me a {}", "shrubbery")); 1716 EXPECT_EQ("From 1 to 3", fmt::format("From {} to {}", 1, 3)); 1717 1718 char buffer[buffer_size]; 1719 safe_sprintf(buffer, "%03.2f", -1.2); 1720 EXPECT_EQ(buffer, fmt::format("{:03.2f}", -1.2)); 1721 1722 EXPECT_EQ("a, b, c", fmt::format("{0}, {1}, {2}", 'a', 'b', 'c')); 1723 EXPECT_EQ("a, b, c", fmt::format("{}, {}, {}", 'a', 'b', 'c')); 1724 EXPECT_EQ("c, b, a", fmt::format("{2}, {1}, {0}", 'a', 'b', 'c')); 1725 EXPECT_EQ("abracadabra", fmt::format("{0}{1}{0}", "abra", "cad")); 1726 1727 EXPECT_EQ("left aligned ", 1728 fmt::format("{:<30}", "left aligned")); 1729 EXPECT_EQ(" right aligned", 1730 fmt::format("{:>30}", "right aligned")); 1731 EXPECT_EQ(" centered ", 1732 fmt::format("{:^30}", "centered")); 1733 EXPECT_EQ("***********centered***********", 1734 fmt::format("{:*^30}", "centered")); 1735 1736 EXPECT_EQ("+3.140000; -3.140000", fmt::format("{:+f}; {:+f}", 3.14, -3.14)); 1737 EXPECT_EQ(" 3.140000; -3.140000", fmt::format("{: f}; {: f}", 3.14, -3.14)); 1738 EXPECT_EQ("3.140000; -3.140000", fmt::format("{:-f}; {:-f}", 3.14, -3.14)); 1739 1740 EXPECT_EQ("int: 42; hex: 2a; oct: 52", 1741 fmt::format("int: {0:d}; hex: {0:x}; oct: {0:o}", 42)); 1742 EXPECT_EQ("int: 42; hex: 0x2a; oct: 052", 1743 fmt::format("int: {0:d}; hex: {0:#x}; oct: {0:#o}", 42)); 1744 1745 EXPECT_EQ("The answer is 42", fmt::format("The answer is {}", 42)); 1746 EXPECT_THROW_MSG( 1747 (void)fmt::format(runtime("The answer is {:d}"), "forty-two"), 1748 format_error, "invalid format specifier"); 1749 1750 EXPECT_WRITE( 1751 stdout, fmt::print("{}", std::numeric_limits<double>::infinity()), "inf"); 1752 } 1753 1754 TEST(format_test, print) { 1755 EXPECT_WRITE(stdout, fmt::print("Don't {}!", "panic"), "Don't panic!"); 1756 EXPECT_WRITE(stderr, fmt::print(stderr, "Don't {}!", "panic"), 1757 "Don't panic!"); 1758 EXPECT_WRITE(stdout, fmt::println("Don't {}!", "panic"), "Don't panic!\n"); 1759 EXPECT_WRITE(stderr, fmt::println(stderr, "Don't {}!", "panic"), 1760 "Don't panic!\n"); 1761 } 1762 1763 TEST(format_test, variadic) { 1764 EXPECT_EQ("abc1", fmt::format("{}c{}", "ab", 1)); 1765 } 1766 1767 TEST(format_test, bytes) { 1768 auto s = fmt::format("{:10}", fmt::bytes("ёжик")); 1769 EXPECT_EQ("ёжик ", s); 1770 EXPECT_EQ(10, s.size()); 1771 } 1772 1773 TEST(format_test, group_digits_view) { 1774 EXPECT_EQ(fmt::format("{}", fmt::group_digits(10000000)), "10,000,000"); 1775 EXPECT_EQ(fmt::format("{:8}", fmt::group_digits(1000)), " 1,000"); 1776 } 1777 1778 enum test_enum { foo, bar }; 1779 auto format_as(test_enum e) -> int { return e; } 1780 1781 TEST(format_test, join) { 1782 using fmt::join; 1783 int v1[3] = {1, 2, 3}; 1784 auto v2 = std::vector<float>(); 1785 v2.push_back(1.2f); 1786 v2.push_back(3.4f); 1787 void* v3[2] = {&v1[0], &v1[1]}; 1788 1789 EXPECT_EQ("(1, 2, 3)", fmt::format("({})", join(v1, v1 + 3, ", "))); 1790 EXPECT_EQ("(1)", fmt::format("({})", join(v1, v1 + 1, ", "))); 1791 EXPECT_EQ("()", fmt::format("({})", join(v1, v1, ", "))); 1792 EXPECT_EQ("(001, 002, 003)", fmt::format("({:03})", join(v1, v1 + 3, ", "))); 1793 EXPECT_EQ("(+01.20, +03.40)", 1794 fmt::format("({:+06.2f})", join(v2.begin(), v2.end(), ", "))); 1795 1796 EXPECT_EQ("1, 2, 3", fmt::format("{0:{1}}", join(v1, v1 + 3, ", "), 1)); 1797 1798 EXPECT_EQ(fmt::format("{}, {}", v3[0], v3[1]), 1799 fmt::format("{}", join(v3, v3 + 2, ", "))); 1800 1801 EXPECT_EQ("(1, 2, 3)", fmt::format("({})", join(v1, ", "))); 1802 EXPECT_EQ("(+01.20, +03.40)", fmt::format("({:+06.2f})", join(v2, ", "))); 1803 1804 auto v4 = std::vector<test_enum>{foo, bar, foo}; 1805 EXPECT_EQ("0 1 0", fmt::format("{}", join(v4, " "))); 1806 } 1807 1808 #ifdef __cpp_lib_byte 1809 TEST(format_test, join_bytes) { 1810 auto v = std::vector<std::byte>{std::byte(1), std::byte(2), std::byte(3)}; 1811 EXPECT_EQ(fmt::format("{}", fmt::join(v, ", ")), "1, 2, 3"); 1812 } 1813 #endif 1814 1815 std::string vformat_message(int id, const char* format, fmt::format_args args) { 1816 auto buffer = fmt::memory_buffer(); 1817 fmt::format_to(fmt::appender(buffer), "[{}] ", id); 1818 vformat_to(fmt::appender(buffer), format, args); 1819 return to_string(buffer); 1820 } 1821 1822 template <typename... Args> 1823 std::string format_message(int id, const char* format, const Args&... args) { 1824 auto va = fmt::make_format_args(args...); 1825 return vformat_message(id, format, va); 1826 } 1827 1828 TEST(format_test, format_message_example) { 1829 EXPECT_EQ("[42] something happened", 1830 format_message(42, "{} happened", "something")); 1831 } 1832 1833 template <typename... Args> 1834 void print_error(const char* file, int line, const char* format, 1835 const Args&... args) { 1836 fmt::print("{}: {}: ", file, line); 1837 fmt::print(format, args...); 1838 } 1839 1840 TEST(format_test, unpacked_args) { 1841 EXPECT_EQ("0123456789abcdefg", 1842 fmt::format("{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}", 0, 1, 2, 3, 4, 5, 1843 6, 7, 8, 9, 'a', 'b', 'c', 'd', 'e', 'f', 'g')); 1844 } 1845 1846 constexpr char with_null[3] = {'{', '}', '\0'}; 1847 constexpr char no_null[2] = {'{', '}'}; 1848 static constexpr const char static_with_null[3] = {'{', '}', '\0'}; 1849 static constexpr const char static_no_null[2] = {'{', '}'}; 1850 1851 TEST(format_test, compile_time_string) { 1852 EXPECT_EQ("foo", fmt::format(FMT_STRING("foo"))); 1853 EXPECT_EQ("42", fmt::format(FMT_STRING("{}"), 42)); 1854 1855 #if FMT_USE_NONTYPE_TEMPLATE_ARGS 1856 using namespace fmt::literals; 1857 EXPECT_EQ("foobar", fmt::format(FMT_STRING("{foo}{bar}"), "bar"_a = "bar", 1858 "foo"_a = "foo")); 1859 EXPECT_EQ("", fmt::format(FMT_STRING(""))); 1860 EXPECT_EQ("", fmt::format(FMT_STRING(""), "arg"_a = 42)); 1861 EXPECT_EQ("42", fmt::format(FMT_STRING("{answer}"), "answer"_a = Answer())); 1862 EXPECT_EQ("1 2", fmt::format(FMT_STRING("{} {two}"), 1, "two"_a = 2)); 1863 #endif 1864 1865 (void)static_with_null; 1866 (void)static_no_null; 1867 #ifndef _MSC_VER 1868 EXPECT_EQ("42", fmt::format(FMT_STRING(static_with_null), 42)); 1869 EXPECT_EQ("42", fmt::format(FMT_STRING(static_no_null), 42)); 1870 #endif 1871 1872 (void)with_null; 1873 (void)no_null; 1874 #if FMT_CPLUSPLUS >= 201703L 1875 EXPECT_EQ("42", fmt::format(FMT_STRING(with_null), 42)); 1876 EXPECT_EQ("42", fmt::format(FMT_STRING(no_null), 42)); 1877 #endif 1878 #if defined(FMT_USE_STRING_VIEW) && FMT_CPLUSPLUS >= 201703L 1879 EXPECT_EQ("42", fmt::format(FMT_STRING(std::string_view("{}")), 42)); 1880 #endif 1881 } 1882 1883 TEST(format_test, custom_format_compile_time_string) { 1884 EXPECT_EQ("42", fmt::format(FMT_STRING("{}"), Answer())); 1885 auto answer = Answer(); 1886 EXPECT_EQ("42", fmt::format(FMT_STRING("{}"), answer)); 1887 char buf[10] = {}; 1888 fmt::format_to(buf, FMT_STRING("{}"), answer); 1889 const Answer const_answer = Answer(); 1890 EXPECT_EQ("42", fmt::format(FMT_STRING("{}"), const_answer)); 1891 } 1892 1893 #if FMT_USE_USER_DEFINED_LITERALS 1894 TEST(format_test, named_arg_udl) { 1895 using namespace fmt::literals; 1896 auto udl_a = fmt::format("{first}{second}{first}{third}", "first"_a = "abra", 1897 "second"_a = "cad", "third"_a = 99); 1898 EXPECT_EQ( 1899 fmt::format("{first}{second}{first}{third}", fmt::arg("first", "abra"), 1900 fmt::arg("second", "cad"), fmt::arg("third", 99)), 1901 udl_a); 1902 1903 EXPECT_EQ("42", fmt::format("{answer}", "answer"_a = Answer())); 1904 } 1905 #endif // FMT_USE_USER_DEFINED_LITERALS 1906 1907 TEST(format_test, enum) { EXPECT_EQ("0", fmt::format("{}", foo)); } 1908 1909 TEST(format_test, formatter_not_specialized) { 1910 static_assert(!fmt::has_formatter<fmt::formatter<test_enum>, 1911 fmt::format_context>::value, 1912 ""); 1913 } 1914 1915 #if FMT_HAS_FEATURE(cxx_strong_enums) 1916 enum big_enum : unsigned long long { big_enum_value = 5000000000ULL }; 1917 auto format_as(big_enum e) -> unsigned long long { return e; } 1918 1919 TEST(format_test, strong_enum) { 1920 EXPECT_EQ("5000000000", fmt::format("{}", big_enum_value)); 1921 } 1922 #endif 1923 1924 TEST(format_test, non_null_terminated_format_string) { 1925 EXPECT_EQ("42", fmt::format(string_view("{}foo", 2), 42)); 1926 } 1927 1928 namespace adl_test { 1929 namespace fmt { 1930 namespace detail { 1931 struct foo {}; 1932 template <typename, typename OutputIt> void write(OutputIt, foo) = delete; 1933 } // namespace detail 1934 } // namespace fmt 1935 } // namespace adl_test 1936 1937 FMT_BEGIN_NAMESPACE 1938 template <> 1939 struct formatter<adl_test::fmt::detail::foo> : formatter<std::string> { 1940 auto format(adl_test::fmt::detail::foo, format_context& ctx) 1941 -> decltype(ctx.out()) { 1942 return formatter<std::string>::format("foo", ctx); 1943 } 1944 }; 1945 FMT_END_NAMESPACE 1946 1947 TEST(format_test, to_string) { 1948 EXPECT_EQ(fmt::to_string(42), "42"); 1949 EXPECT_EQ(fmt::to_string(reinterpret_cast<void*>(0x1234)), "0x1234"); 1950 EXPECT_EQ(fmt::to_string(adl_test::fmt::detail::foo()), "foo"); 1951 EXPECT_EQ(fmt::to_string(foo), "0"); 1952 1953 #if FMT_USE_FLOAT128 1954 EXPECT_EQ(fmt::to_string(__float128(0.5)), "0.5"); 1955 #endif 1956 1957 #if defined(FMT_USE_STRING_VIEW) && FMT_CPLUSPLUS >= 201703L 1958 EXPECT_EQ(fmt::to_string(std::string_view()), ""); 1959 #endif 1960 } 1961 1962 TEST(format_test, output_iterators) { 1963 std::list<char> out; 1964 fmt::format_to(std::back_inserter(out), "{}", 42); 1965 EXPECT_EQ("42", std::string(out.begin(), out.end())); 1966 std::stringstream s; 1967 fmt::format_to(std::ostream_iterator<char>(s), "{}", 42); 1968 EXPECT_EQ("42", s.str()); 1969 } 1970 1971 TEST(format_test, formatted_size) { 1972 EXPECT_EQ(2u, fmt::formatted_size("{}", 42)); 1973 EXPECT_EQ(2u, fmt::formatted_size(std::locale(), "{}", 42)); 1974 } 1975 1976 TEST(format_test, format_to_no_args) { 1977 std::string s; 1978 fmt::format_to(std::back_inserter(s), "test"); 1979 EXPECT_EQ("test", s); 1980 } 1981 1982 TEST(format_test, format_to) { 1983 std::string s; 1984 fmt::format_to(std::back_inserter(s), "part{0}", 1); 1985 EXPECT_EQ("part1", s); 1986 fmt::format_to(std::back_inserter(s), "part{0}", 2); 1987 EXPECT_EQ("part1part2", s); 1988 } 1989 1990 TEST(format_test, format_to_memory_buffer) { 1991 auto buf = fmt::basic_memory_buffer<char, 100>(); 1992 fmt::format_to(fmt::appender(buf), "{}", "foo"); 1993 EXPECT_EQ("foo", to_string(buf)); 1994 } 1995 1996 TEST(format_test, format_to_vector) { 1997 std::vector<char> v; 1998 fmt::format_to(std::back_inserter(v), "{}", "foo"); 1999 EXPECT_EQ(string_view(v.data(), v.size()), "foo"); 2000 } 2001 2002 struct nongrowing_container { 2003 using value_type = char; 2004 void push_back(char) { throw std::runtime_error("can't take it any more"); } 2005 }; 2006 2007 TEST(format_test, format_to_propagates_exceptions) { 2008 auto c = nongrowing_container(); 2009 EXPECT_THROW(fmt::format_to(std::back_inserter(c), "{}", 42), 2010 std::runtime_error); 2011 } 2012 2013 TEST(format_test, format_to_n) { 2014 char buffer[4]; 2015 buffer[3] = 'x'; 2016 auto result = fmt::format_to_n(buffer, 3, "{}", 12345); 2017 EXPECT_EQ(5u, result.size); 2018 EXPECT_EQ(buffer + 3, result.out); 2019 EXPECT_EQ("123x", fmt::string_view(buffer, 4)); 2020 2021 result = fmt::format_to_n(buffer, 3, "{:s}", "foobar"); 2022 EXPECT_EQ(6u, result.size); 2023 EXPECT_EQ(buffer + 3, result.out); 2024 EXPECT_EQ("foox", fmt::string_view(buffer, 4)); 2025 2026 buffer[0] = 'x'; 2027 buffer[1] = 'x'; 2028 buffer[2] = 'x'; 2029 result = fmt::format_to_n(buffer, 3, "{}", 'A'); 2030 EXPECT_EQ(1u, result.size); 2031 EXPECT_EQ(buffer + 1, result.out); 2032 EXPECT_EQ("Axxx", fmt::string_view(buffer, 4)); 2033 2034 result = fmt::format_to_n(buffer, 3, "{}{} ", 'B', 'C'); 2035 EXPECT_EQ(3u, result.size); 2036 EXPECT_EQ(buffer + 3, result.out); 2037 EXPECT_EQ("BC x", fmt::string_view(buffer, 4)); 2038 2039 result = fmt::format_to_n(buffer, 4, "{}", "ABCDE"); 2040 EXPECT_EQ(5u, result.size); 2041 EXPECT_EQ("ABCD", fmt::string_view(buffer, 4)); 2042 2043 buffer[3] = 'x'; 2044 result = fmt::format_to_n(buffer, 3, "{}", std::string(1000, '*')); 2045 EXPECT_EQ(1000u, result.size); 2046 EXPECT_EQ("***x", fmt::string_view(buffer, 4)); 2047 } 2048 2049 struct test_output_iterator { 2050 char* data; 2051 2052 using iterator_category = std::output_iterator_tag; 2053 using value_type = void; 2054 using difference_type = void; 2055 using pointer = void; 2056 using reference = void; 2057 2058 test_output_iterator& operator++() { 2059 ++data; 2060 return *this; 2061 } 2062 test_output_iterator operator++(int) { 2063 auto tmp = *this; 2064 ++data; 2065 return tmp; 2066 } 2067 char& operator*() { return *data; } 2068 }; 2069 2070 TEST(format_test, format_to_n_output_iterator) { 2071 char buf[10] = {}; 2072 fmt::format_to_n(test_output_iterator{buf}, 10, "{}", 42); 2073 EXPECT_STREQ(buf, "42"); 2074 } 2075 2076 TEST(format_test, vformat_to) { 2077 using context = fmt::format_context; 2078 int n = 42; 2079 auto args = fmt::make_format_args<context>(n); 2080 auto s = std::string(); 2081 fmt::vformat_to(std::back_inserter(s), "{}", args); 2082 EXPECT_EQ("42", s); 2083 s.clear(); 2084 fmt::vformat_to(std::back_inserter(s), FMT_STRING("{}"), args); 2085 EXPECT_EQ("42", s); 2086 } 2087 2088 TEST(format_test, char_traits_is_not_ambiguous) { 2089 // Test that we don't inject detail names into the std namespace. 2090 using namespace std; 2091 auto c = char_traits<char>::char_type(); 2092 (void)c; 2093 #if FMT_CPLUSPLUS >= 201103L 2094 auto s = std::string(); 2095 auto lval = begin(s); 2096 (void)lval; 2097 #endif 2098 } 2099 2100 struct check_back_appender {}; 2101 2102 FMT_BEGIN_NAMESPACE 2103 template <> struct formatter<check_back_appender> { 2104 FMT_CONSTEXPR auto parse(format_parse_context& ctx) -> decltype(ctx.begin()) { 2105 return ctx.begin(); 2106 } 2107 2108 template <typename Context> 2109 auto format(check_back_appender, Context& ctx) -> decltype(ctx.out()) { 2110 auto out = ctx.out(); 2111 static_assert(std::is_same<decltype(++out), decltype(out)&>::value, 2112 "needs to satisfy weakly_incrementable"); 2113 *out = 'y'; 2114 return ++out; 2115 } 2116 }; 2117 FMT_END_NAMESPACE 2118 2119 TEST(format_test, back_insert_slicing) { 2120 EXPECT_EQ(fmt::format("{}", check_back_appender{}), "y"); 2121 } 2122 2123 namespace test { 2124 enum class scoped_enum_as_int {}; 2125 auto format_as(scoped_enum_as_int) -> int { return 42; } 2126 2127 enum class scoped_enum_as_string_view {}; 2128 auto format_as(scoped_enum_as_string_view) -> fmt::string_view { return "foo"; } 2129 2130 enum class scoped_enum_as_string {}; 2131 auto format_as(scoped_enum_as_string) -> std::string { return "foo"; } 2132 2133 struct struct_as_int {}; 2134 auto format_as(struct_as_int) -> int { return 42; } 2135 } // namespace test 2136 2137 TEST(format_test, format_as) { 2138 EXPECT_EQ(fmt::format("{}", test::scoped_enum_as_int()), "42"); 2139 EXPECT_EQ(fmt::format("{}", test::scoped_enum_as_string_view()), "foo"); 2140 EXPECT_EQ(fmt::format("{}", test::scoped_enum_as_string()), "foo"); 2141 EXPECT_EQ(fmt::format("{}", test::struct_as_int()), "42"); 2142 } 2143 2144 TEST(format_test, format_as_to_string) { 2145 EXPECT_EQ(fmt::to_string(test::scoped_enum_as_int()), "42"); 2146 EXPECT_EQ(fmt::to_string(test::scoped_enum_as_string_view()), "foo"); 2147 EXPECT_EQ(fmt::to_string(test::scoped_enum_as_string()), "foo"); 2148 EXPECT_EQ(fmt::to_string(test::struct_as_int()), "42"); 2149 } 2150 2151 template <typename Char, typename T> bool check_enabled_formatter() { 2152 static_assert(std::is_default_constructible<fmt::formatter<T, Char>>::value, 2153 ""); 2154 return true; 2155 } 2156 2157 template <typename Char, typename... T> void check_enabled_formatters() { 2158 auto dummy = {check_enabled_formatter<Char, T>()...}; 2159 (void)dummy; 2160 } 2161 2162 TEST(format_test, test_formatters_enabled) { 2163 check_enabled_formatters<char, bool, char, signed char, unsigned char, short, 2164 unsigned short, int, unsigned, long, unsigned long, 2165 long long, unsigned long long, float, double, 2166 long double, void*, const void*, char*, const char*, 2167 std::string, std::nullptr_t>(); 2168 check_enabled_formatters<wchar_t, bool, wchar_t, signed char, unsigned char, 2169 short, unsigned short, int, unsigned, long, 2170 unsigned long, long long, unsigned long long, float, 2171 double, long double, void*, const void*, wchar_t*, 2172 const wchar_t*, std::wstring, std::nullptr_t>(); 2173 } 2174 2175 TEST(format_int_test, data) { 2176 fmt::format_int format_int(42); 2177 EXPECT_EQ("42", std::string(format_int.data(), format_int.size())); 2178 } 2179 2180 TEST(format_int_test, format_int) { 2181 EXPECT_EQ("42", fmt::format_int(42).str()); 2182 EXPECT_EQ(2u, fmt::format_int(42).size()); 2183 EXPECT_EQ("-42", fmt::format_int(-42).str()); 2184 EXPECT_EQ(3u, fmt::format_int(-42).size()); 2185 EXPECT_EQ("42", fmt::format_int(42ul).str()); 2186 EXPECT_EQ("-42", fmt::format_int(-42l).str()); 2187 EXPECT_EQ("42", fmt::format_int(42ull).str()); 2188 EXPECT_EQ("-42", fmt::format_int(-42ll).str()); 2189 std::ostringstream os; 2190 os << max_value<int64_t>(); 2191 EXPECT_EQ(os.str(), fmt::format_int(max_value<int64_t>()).str()); 2192 } 2193 2194 #ifndef FMT_STATIC_THOUSANDS_SEPARATOR 2195 2196 # include <locale> 2197 2198 class format_facet : public fmt::format_facet<std::locale> { 2199 protected: 2200 struct int_formatter { 2201 fmt::appender out; 2202 2203 template <typename T, FMT_ENABLE_IF(fmt::detail::is_integer<T>::value)> 2204 auto operator()(T value) -> bool { 2205 fmt::format_to(out, "[{}]", value); 2206 return true; 2207 } 2208 2209 template <typename T, FMT_ENABLE_IF(!fmt::detail::is_integer<T>::value)> 2210 auto operator()(T) -> bool { 2211 return false; 2212 } 2213 }; 2214 2215 auto do_put(fmt::appender out, fmt::loc_value val, 2216 const fmt::format_specs<>&) const -> bool override; 2217 }; 2218 2219 auto format_facet::do_put(fmt::appender out, fmt::loc_value val, 2220 const fmt::format_specs<>&) const -> bool { 2221 return val.visit(int_formatter{out}); 2222 } 2223 2224 TEST(format_test, format_facet) { 2225 auto loc = std::locale(std::locale(), new format_facet()); 2226 EXPECT_EQ(fmt::format(loc, "{:L}", 42), "[42]"); 2227 EXPECT_EQ(fmt::format(loc, "{:L}", -42), "[-42]"); 2228 } 2229 2230 TEST(format_test, format_facet_separator) { 2231 // U+2019 RIGHT SINGLE QUOTATION MARK is a digit separator in the de_CH 2232 // locale. 2233 auto loc = 2234 std::locale({}, new fmt::format_facet<std::locale>("\xe2\x80\x99")); 2235 EXPECT_EQ(fmt::format(loc, "{:L}", 1000), 2236 "1\xe2\x80\x99" 2237 "000"); 2238 } 2239 2240 TEST(format_test, format_facet_grouping) { 2241 auto loc = 2242 std::locale({}, new fmt::format_facet<std::locale>(",", {1, 2, 3})); 2243 EXPECT_EQ(fmt::format(loc, "{:L}", 1234567890), "1,234,567,89,0"); 2244 } 2245 2246 TEST(format_test, format_named_arg_with_locale) { 2247 EXPECT_EQ(fmt::format(std::locale(), "{answer}", fmt::arg("answer", 42)), 2248 "42"); 2249 } 2250 2251 #endif // FMT_STATIC_THOUSANDS_SEPARATOR 2252 2253 struct convertible_to_nonconst_cstring { 2254 operator char*() const { 2255 static char c[] = "bar"; 2256 return c; 2257 } 2258 }; 2259 2260 FMT_BEGIN_NAMESPACE 2261 template <> 2262 struct formatter<convertible_to_nonconst_cstring> : formatter<char*> {}; 2263 FMT_END_NAMESPACE 2264 2265 TEST(format_test, formatter_nonconst_char) { 2266 EXPECT_EQ(fmt::format("{}", convertible_to_nonconst_cstring()), "bar"); 2267 }