1/* 2 Formatting library tests. 3 4 Copyright (c) 2012-2014, Victor Zverovich 5 All rights reserved. 6 7 Redistribution and use in source and binary forms, with or without 8 modification, are permitted provided that the following conditions are met: 9 10 1. Redistributions of source code must retain the above copyright notice, this 11 list of conditions and the following disclaimer. 12 2. Redistributions in binary form must reproduce the above copyright notice, 13 this list of conditions and the following disclaimer in the documentation 14 and/or other materials provided with the distribution. 15 16 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND 17 ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 18 WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 19 DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR 20 ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES 21 (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 22 LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND 23 ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 24 (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS 25 SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 26 */ 27 28#include <cctype> 29#include <cfloat> 30#include <climits> 31#include <clocale> 32#include <cmath> 33#include <cstring> 34#include <memory> 35#include <stdint.h> 36 37#if FMT_USE_TYPE_TRAITS 38# include <type_traits> 39#endif 40 41#include "gmock/gmock.h" 42 43// Test that the library compiles if None is defined to 0 as done by xlib.h. 44#define None 0 45 46struct LocaleMock { 47 static LocaleMock *instance; 48 49 MOCK_METHOD0(localeconv, lconv *()); 50} *LocaleMock::instance; 51 52namespace fmt { 53namespace std { 54using namespace ::std; 55lconv *localeconv() { 56 return LocaleMock::instance ? 57 LocaleMock::instance->localeconv() : ::std::localeconv(); 58} 59} 60} 61 62#include "fmt/format.h" 63 64#include "util.h" 65#include "mock-allocator.h" 66#include "gtest-extra.h" 67 68#undef min 69#undef max 70 71using std::size_t; 72 73using fmt::BasicWriter; 74using fmt::format; 75using fmt::FormatError; 76using fmt::StringRef; 77using fmt::CStringRef; 78using fmt::MemoryWriter; 79using fmt::WMemoryWriter; 80using fmt::pad; 81 82namespace { 83 84// Format value using the standard library. 85template <typename Char, typename T> 86void std_format(const T &value, std::basic_string<Char> &result) { 87 std::basic_ostringstream<Char> os; 88 os << value; 89 result = os.str(); 90} 91 92#ifdef __MINGW32__ 93// Workaround a bug in formatting long double in MinGW. 94void std_format(long double value, std::string &result) { 95 char buffer[100]; 96 safe_sprintf(buffer, "%Lg", value); 97 result = buffer; 98} 99void std_format(long double value, std::wstring &result) { 100 wchar_t buffer[100]; 101 swprintf(buffer, L"%Lg", value); 102 result = buffer; 103} 104#endif 105 106// Checks if writing value to BasicWriter<Char> produces the same result 107// as writing it to std::basic_ostringstream<Char>. 108template <typename Char, typename T> 109::testing::AssertionResult check_write(const T &value, const char *type) { 110 std::basic_string<Char> actual = 111 (fmt::BasicMemoryWriter<Char>() << value).str(); 112 std::basic_string<Char> expected; 113 std_format(value, expected); 114 if (expected == actual) 115 return ::testing::AssertionSuccess(); 116 return ::testing::AssertionFailure() 117 << "Value of: (Writer<" << type << ">() << value).str()\n" 118 << " Actual: " << actual << "\n" 119 << "Expected: " << expected << "\n"; 120} 121 122struct AnyWriteChecker { 123 template <typename T> 124 ::testing::AssertionResult operator()(const char *, const T &value) const { 125 ::testing::AssertionResult result = check_write<char>(value, "char"); 126 return result ? check_write<wchar_t>(value, "wchar_t") : result; 127 } 128}; 129 130template <typename Char> 131struct WriteChecker { 132 template <typename T> 133 ::testing::AssertionResult operator()(const char *, const T &value) const { 134 return check_write<Char>(value, "char"); 135 } 136}; 137 138// Checks if writing value to BasicWriter produces the same result 139// as writing it to std::ostringstream both for char and wchar_t. 140#define CHECK_WRITE(value) EXPECT_PRED_FORMAT1(AnyWriteChecker(), value) 141 142#define CHECK_WRITE_CHAR(value) \ 143 EXPECT_PRED_FORMAT1(WriteChecker<char>(), value) 144#define CHECK_WRITE_WCHAR(value) \ 145 EXPECT_PRED_FORMAT1(WriteChecker<wchar_t>(), value) 146} // namespace 147 148TEST(StringRefTest, Ctor) { 149 EXPECT_STREQ("abc", StringRef("abc").data()); 150 EXPECT_EQ(3u, StringRef("abc").size()); 151 152 EXPECT_STREQ("defg", StringRef(std::string("defg")).data()); 153 EXPECT_EQ(4u, StringRef(std::string("defg")).size()); 154} 155 156TEST(StringRefTest, ConvertToString) { 157 std::string s = StringRef("abc").to_string(); 158 EXPECT_EQ("abc", s); 159} 160 161TEST(CStringRefTest, Ctor) { 162 EXPECT_STREQ("abc", CStringRef("abc").c_str()); 163 EXPECT_STREQ("defg", CStringRef(std::string("defg")).c_str()); 164} 165 166#if FMT_USE_TYPE_TRAITS 167TEST(WriterTest, NotCopyConstructible) { 168 EXPECT_FALSE(std::is_copy_constructible<BasicWriter<char> >::value); 169} 170 171TEST(WriterTest, NotCopyAssignable) { 172 EXPECT_FALSE(std::is_copy_assignable<BasicWriter<char> >::value); 173} 174#endif 175 176TEST(WriterTest, Ctor) { 177 MemoryWriter w; 178 EXPECT_EQ(0u, w.size()); 179 EXPECT_STREQ("", w.c_str()); 180 EXPECT_EQ("", w.str()); 181} 182 183#if FMT_USE_RVALUE_REFERENCES 184 185void check_move_writer(const std::string &str, MemoryWriter &w) { 186 MemoryWriter w2(std::move(w)); 187 // Move shouldn't destroy the inline content of the first writer. 188 EXPECT_EQ(str, w.str()); 189 EXPECT_EQ(str, w2.str()); 190} 191 192TEST(WriterTest, MoveCtor) { 193 MemoryWriter w; 194 w << "test"; 195 check_move_writer("test", w); 196 // This fills the inline buffer, but doesn't cause dynamic allocation. 197 std::string s; 198 for (int i = 0; i < fmt::internal::INLINE_BUFFER_SIZE; ++i) 199 s += '*'; 200 w.clear(); 201 w << s; 202 check_move_writer(s, w); 203 const char *inline_buffer_ptr = w.data(); 204 // Adding one more character causes the content to move from the inline to 205 // a dynamically allocated buffer. 206 w << '*'; 207 MemoryWriter w2(std::move(w)); 208 // Move should rip the guts of the first writer. 209 EXPECT_EQ(inline_buffer_ptr, w.data()); 210 EXPECT_EQ(s + '*', w2.str()); 211} 212 213void CheckMoveAssignWriter(const std::string &str, MemoryWriter &w) { 214 MemoryWriter w2; 215 w2 = std::move(w); 216 // Move shouldn't destroy the inline content of the first writer. 217 EXPECT_EQ(str, w.str()); 218 EXPECT_EQ(str, w2.str()); 219} 220 221TEST(WriterTest, MoveAssignment) { 222 MemoryWriter w; 223 w << "test"; 224 CheckMoveAssignWriter("test", w); 225 // This fills the inline buffer, but doesn't cause dynamic allocation. 226 std::string s; 227 for (int i = 0; i < fmt::internal::INLINE_BUFFER_SIZE; ++i) 228 s += '*'; 229 w.clear(); 230 w << s; 231 CheckMoveAssignWriter(s, w); 232 const char *inline_buffer_ptr = w.data(); 233 // Adding one more character causes the content to move from the inline to 234 // a dynamically allocated buffer. 235 w << '*'; 236 MemoryWriter w2; 237 w2 = std::move(w); 238 // Move should rip the guts of the first writer. 239 EXPECT_EQ(inline_buffer_ptr, w.data()); 240 EXPECT_EQ(s + '*', w2.str()); 241} 242 243#endif // FMT_USE_RVALUE_REFERENCES 244 245TEST(WriterTest, Allocator) { 246 typedef testing::StrictMock< MockAllocator<char> > MockAllocator; 247 typedef AllocatorRef<MockAllocator> TestAllocator; 248 MockAllocator alloc; 249 fmt::BasicMemoryWriter<char, TestAllocator> w((TestAllocator(&alloc))); 250 std::size_t size = 251 static_cast<std::size_t>(1.5 * fmt::internal::INLINE_BUFFER_SIZE); 252 std::vector<char> mem(size); 253 EXPECT_CALL(alloc, allocate(size, 0)).WillOnce(testing::Return(&mem[0])); 254 for (int i = 0; i < fmt::internal::INLINE_BUFFER_SIZE + 1; ++i) 255 w << '*'; 256 EXPECT_CALL(alloc, deallocate(&mem[0], size)); 257} 258 259TEST(WriterTest, Data) { 260 MemoryWriter w; 261 w << 42; 262 EXPECT_EQ("42", std::string(w.data(), w.size())); 263} 264 265TEST(WriterTest, WriteWithoutArgs) { 266 MemoryWriter w; 267 w.write("test"); 268 EXPECT_EQ("test", std::string(w.data(), w.size())); 269} 270 271TEST(WriterTest, WriteInt) { 272 CHECK_WRITE(42); 273 CHECK_WRITE(-42); 274 CHECK_WRITE(static_cast<short>(12)); 275 CHECK_WRITE(34u); 276 CHECK_WRITE(std::numeric_limits<int>::min()); 277 CHECK_WRITE(std::numeric_limits<int>::max()); 278 CHECK_WRITE(std::numeric_limits<unsigned>::max()); 279} 280 281TEST(WriterTest, WriteLong) { 282 CHECK_WRITE(56l); 283 CHECK_WRITE(78ul); 284 CHECK_WRITE(std::numeric_limits<long>::min()); 285 CHECK_WRITE(std::numeric_limits<long>::max()); 286 CHECK_WRITE(std::numeric_limits<unsigned long>::max()); 287} 288 289TEST(WriterTest, WriteLongLong) { 290 CHECK_WRITE(56ll); 291 CHECK_WRITE(78ull); 292 CHECK_WRITE(std::numeric_limits<long long>::min()); 293 CHECK_WRITE(std::numeric_limits<long long>::max()); 294 CHECK_WRITE(std::numeric_limits<unsigned long long>::max()); 295} 296 297TEST(WriterTest, WriteDouble) { 298 CHECK_WRITE(4.2); 299 CHECK_WRITE(-4.2); 300 CHECK_WRITE(std::numeric_limits<double>::min()); 301 CHECK_WRITE(std::numeric_limits<double>::max()); 302} 303 304TEST(WriterTest, WriteLongDouble) { 305 CHECK_WRITE(4.2l); 306 CHECK_WRITE_CHAR(-4.2l); 307 std::wstring str; 308 std_format(4.2l, str); 309 if (str[0] != '-') 310 CHECK_WRITE_WCHAR(-4.2l); 311 else 312 fmt::print("warning: long double formatting with std::swprintf is broken"); 313 CHECK_WRITE(std::numeric_limits<long double>::min()); 314 CHECK_WRITE(std::numeric_limits<long double>::max()); 315} 316 317TEST(WriterTest, WriteDoubleAtBufferBoundary) { 318 MemoryWriter writer; 319 for (int i = 0; i < 100; ++i) 320 writer << 1.23456789; 321} 322 323TEST(WriterTest, WriteDoubleWithFilledBuffer) { 324 MemoryWriter writer; 325 // Fill the buffer. 326 for (int i = 0; i < fmt::internal::INLINE_BUFFER_SIZE; ++i) 327 writer << ' '; 328 writer << 1.2; 329 EXPECT_STREQ("1.2", writer.c_str() + fmt::internal::INLINE_BUFFER_SIZE); 330} 331 332TEST(WriterTest, WriteChar) { 333 CHECK_WRITE('a'); 334} 335 336TEST(WriterTest, WriteWideChar) { 337 CHECK_WRITE_WCHAR(L'a'); 338} 339 340TEST(WriterTest, WriteString) { 341 CHECK_WRITE_CHAR("abc"); 342 CHECK_WRITE_WCHAR("abc"); 343 // The following line shouldn't compile: 344 //MemoryWriter() << L"abc"; 345} 346 347TEST(WriterTest, WriteWideString) { 348 CHECK_WRITE_WCHAR(L"abc"); 349 // The following line shouldn't compile: 350 //fmt::WMemoryWriter() << "abc"; 351} 352 353TEST(WriterTest, bin) { 354 using fmt::bin; 355 EXPECT_EQ("1100101011111110", (MemoryWriter() << bin(0xcafe)).str()); 356 EXPECT_EQ("1011101010111110", (MemoryWriter() << bin(0xbabeu)).str()); 357 EXPECT_EQ("1101111010101101", (MemoryWriter() << bin(0xdeadl)).str()); 358 EXPECT_EQ("1011111011101111", (MemoryWriter() << bin(0xbeeful)).str()); 359 EXPECT_EQ("11001010111111101011101010111110", 360 (MemoryWriter() << bin(0xcafebabell)).str()); 361 EXPECT_EQ("11011110101011011011111011101111", 362 (MemoryWriter() << bin(0xdeadbeefull)).str()); 363} 364 365TEST(WriterTest, oct) { 366 using fmt::oct; 367 EXPECT_EQ("12", (MemoryWriter() << oct(static_cast<short>(012))).str()); 368 EXPECT_EQ("12", (MemoryWriter() << oct(012)).str()); 369 EXPECT_EQ("34", (MemoryWriter() << oct(034u)).str()); 370 EXPECT_EQ("56", (MemoryWriter() << oct(056l)).str()); 371 EXPECT_EQ("70", (MemoryWriter() << oct(070ul)).str()); 372 EXPECT_EQ("1234", (MemoryWriter() << oct(01234ll)).str()); 373 EXPECT_EQ("5670", (MemoryWriter() << oct(05670ull)).str()); 374} 375 376TEST(WriterTest, hex) { 377 using fmt::hex; 378 fmt::IntFormatSpec<int, fmt::TypeSpec<'x'> > (*phex)(int value) = hex; 379 phex(42); 380 // This shouldn't compile: 381 //fmt::IntFormatSpec<short, fmt::TypeSpec<'x'> > (*phex2)(short value) = hex; 382 383 EXPECT_EQ("cafe", (MemoryWriter() << hex(0xcafe)).str()); 384 EXPECT_EQ("babe", (MemoryWriter() << hex(0xbabeu)).str()); 385 EXPECT_EQ("dead", (MemoryWriter() << hex(0xdeadl)).str()); 386 EXPECT_EQ("beef", (MemoryWriter() << hex(0xbeeful)).str()); 387 EXPECT_EQ("cafebabe", (MemoryWriter() << hex(0xcafebabell)).str()); 388 EXPECT_EQ("deadbeef", (MemoryWriter() << hex(0xdeadbeefull)).str()); 389} 390 391TEST(WriterTest, hexu) { 392 using fmt::hexu; 393 EXPECT_EQ("CAFE", (MemoryWriter() << hexu(0xcafe)).str()); 394 EXPECT_EQ("BABE", (MemoryWriter() << hexu(0xbabeu)).str()); 395 EXPECT_EQ("DEAD", (MemoryWriter() << hexu(0xdeadl)).str()); 396 EXPECT_EQ("BEEF", (MemoryWriter() << hexu(0xbeeful)).str()); 397 EXPECT_EQ("CAFEBABE", (MemoryWriter() << hexu(0xcafebabell)).str()); 398 EXPECT_EQ("DEADBEEF", (MemoryWriter() << hexu(0xdeadbeefull)).str()); 399} 400 401template <typename Char> 402BasicWriter<Char> &operator<<(BasicWriter<Char> &f, const Date &d) { 403 return f << d.year() << '-' << d.month() << '-' << d.day(); 404} 405 406class ISO8601DateFormatter { 407 const Date *date_; 408 409public: 410 ISO8601DateFormatter(const Date &d) : date_(&d) {} 411 412 template <typename Char> 413 friend BasicWriter<Char> &operator<<( 414 BasicWriter<Char> &w, const ISO8601DateFormatter &d) { 415 return w << pad(d.date_->year(), 4, '0') << '-' 416 << pad(d.date_->month(), 2, '0') << '-' << pad(d.date_->day(), 2, '0'); 417 } 418}; 419 420ISO8601DateFormatter iso8601(const Date &d) { return ISO8601DateFormatter(d); } 421 422TEST(WriterTest, pad) { 423 using fmt::hex; 424 EXPECT_EQ(" cafe", (MemoryWriter() << pad(hex(0xcafe), 8)).str()); 425 EXPECT_EQ(" babe", (MemoryWriter() << pad(hex(0xbabeu), 8)).str()); 426 EXPECT_EQ(" dead", (MemoryWriter() << pad(hex(0xdeadl), 8)).str()); 427 EXPECT_EQ(" beef", (MemoryWriter() << pad(hex(0xbeeful), 8)).str()); 428 EXPECT_EQ(" dead", (MemoryWriter() << pad(hex(0xdeadll), 8)).str()); 429 EXPECT_EQ(" beef", (MemoryWriter() << pad(hex(0xbeefull), 8)).str()); 430 431 EXPECT_EQ(" 11", (MemoryWriter() << pad(11, 7)).str()); 432 EXPECT_EQ(" 22", (MemoryWriter() << pad(22u, 7)).str()); 433 EXPECT_EQ(" 33", (MemoryWriter() << pad(33l, 7)).str()); 434 EXPECT_EQ(" 44", (MemoryWriter() << pad(44ul, 7)).str()); 435 EXPECT_EQ(" 33", (MemoryWriter() << pad(33ll, 7)).str()); 436 EXPECT_EQ(" 44", (MemoryWriter() << pad(44ull, 7)).str()); 437 438 MemoryWriter w; 439 w.clear(); 440 w << pad(42, 5, '0'); 441 EXPECT_EQ("00042", w.str()); 442 w.clear(); 443 w << Date(2012, 12, 9); 444 EXPECT_EQ("2012-12-9", w.str()); 445 w.clear(); 446 w << iso8601(Date(2012, 1, 9)); 447 EXPECT_EQ("2012-01-09", w.str()); 448} 449 450TEST(WriterTest, PadString) { 451 EXPECT_EQ("test ", (MemoryWriter() << pad("test", 8)).str()); 452 EXPECT_EQ("test******", (MemoryWriter() << pad("test", 10, '*')).str()); 453} 454 455TEST(WriterTest, PadWString) { 456 EXPECT_EQ(L"test ", (WMemoryWriter() << pad(L"test", 8)).str()); 457 EXPECT_EQ(L"test******", (WMemoryWriter() << pad(L"test", 10, '*')).str()); 458 EXPECT_EQ(L"test******", (WMemoryWriter() << pad(L"test", 10, L'*')).str()); 459} 460 461TEST(WriterTest, NoConflictWithIOManip) { 462 using namespace std; 463 using namespace fmt; 464 EXPECT_EQ("cafe", (MemoryWriter() << hex(0xcafe)).str()); 465 EXPECT_EQ("12", (MemoryWriter() << oct(012)).str()); 466} 467 468TEST(WriterTest, Format) { 469 MemoryWriter w; 470 w.write("part{0}", 1); 471 EXPECT_EQ(strlen("part1"), w.size()); 472 EXPECT_STREQ("part1", w.c_str()); 473 EXPECT_STREQ("part1", w.data()); 474 EXPECT_EQ("part1", w.str()); 475 w.write("part{0}", 2); 476 EXPECT_EQ(strlen("part1part2"), w.size()); 477 EXPECT_STREQ("part1part2", w.c_str()); 478 EXPECT_STREQ("part1part2", w.data()); 479 EXPECT_EQ("part1part2", w.str()); 480} 481 482TEST(WriterTest, WWriter) { 483 EXPECT_EQ(L"cafe", (fmt::WMemoryWriter() << fmt::hex(0xcafe)).str()); 484} 485 486TEST(ArrayWriterTest, Ctor) { 487 char array[10] = "garbage"; 488 fmt::ArrayWriter w(array, sizeof(array)); 489 EXPECT_EQ(0u, w.size()); 490 EXPECT_STREQ("", w.c_str()); 491} 492 493TEST(ArrayWriterTest, CompileTimeSizeCtor) { 494 char array[10] = "garbage"; 495 fmt::ArrayWriter w(array); 496 EXPECT_EQ(0u, w.size()); 497 EXPECT_STREQ("", w.c_str()); 498 w.write("{:10}", 1); 499} 500 501TEST(ArrayWriterTest, Write) { 502 char array[10]; 503 fmt::ArrayWriter w(array, sizeof(array)); 504 w.write("{}", 42); 505 EXPECT_EQ("42", w.str()); 506} 507 508TEST(ArrayWriterTest, BufferOverflow) { 509 char array[10]; 510 fmt::ArrayWriter w(array, sizeof(array)); 511 w.write("{:10}", 1); 512 EXPECT_THROW_MSG(w.write("{}", 1), std::runtime_error, "buffer overflow"); 513} 514 515TEST(ArrayWriterTest, WChar) { 516 wchar_t array[10]; 517 fmt::WArrayWriter w(array); 518 w.write(L"{}", 42); 519 EXPECT_EQ(L"42", w.str()); 520} 521 522TEST(FormatterTest, Escape) { 523 EXPECT_EQ("{", format("{{")); 524 EXPECT_EQ("before {", format("before {{")); 525 EXPECT_EQ("{ after", format("{{ after")); 526 EXPECT_EQ("before { after", format("before {{ after")); 527 528 EXPECT_EQ("}", format("}}")); 529 EXPECT_EQ("before }", format("before }}")); 530 EXPECT_EQ("} after", format("}} after")); 531 EXPECT_EQ("before } after", format("before }} after")); 532 533 EXPECT_EQ("{}", format("{{}}")); 534 EXPECT_EQ("{42}", format("{{{0}}}", 42)); 535} 536 537TEST(FormatterTest, UnmatchedBraces) { 538 EXPECT_THROW_MSG(format("{"), FormatError, "invalid format string"); 539 EXPECT_THROW_MSG(format("}"), FormatError, "unmatched '}' in format string"); 540 EXPECT_THROW_MSG(format("{0{}"), FormatError, "invalid format string"); 541} 542 543TEST(FormatterTest, NoArgs) { 544 EXPECT_EQ("test", format("test")); 545} 546 547TEST(FormatterTest, ArgsInDifferentPositions) { 548 EXPECT_EQ("42", format("{0}", 42)); 549 EXPECT_EQ("before 42", format("before {0}", 42)); 550 EXPECT_EQ("42 after", format("{0} after", 42)); 551 EXPECT_EQ("before 42 after", format("before {0} after", 42)); 552 EXPECT_EQ("answer = 42", format("{0} = {1}", "answer", 42)); 553 EXPECT_EQ("42 is the answer", format("{1} is the {0}", "answer", 42)); 554 EXPECT_EQ("abracadabra", format("{0}{1}{0}", "abra", "cad")); 555} 556 557TEST(FormatterTest, ArgErrors) { 558 EXPECT_THROW_MSG(format("{"), FormatError, "invalid format string"); 559 EXPECT_THROW_MSG(format("{?}"), FormatError, "invalid format string"); 560 EXPECT_THROW_MSG(format("{0"), FormatError, "invalid format string"); 561 EXPECT_THROW_MSG(format("{0}"), FormatError, "argument index out of range"); 562 563 char format_str[BUFFER_SIZE]; 564 safe_sprintf(format_str, "{%u", INT_MAX); 565 EXPECT_THROW_MSG(format(format_str), FormatError, "invalid format string"); 566 safe_sprintf(format_str, "{%u}", INT_MAX); 567 EXPECT_THROW_MSG(format(format_str), FormatError, 568 "argument index out of range"); 569 570 safe_sprintf(format_str, "{%u", INT_MAX + 1u); 571 EXPECT_THROW_MSG(format(format_str), FormatError, "number is too big"); 572 safe_sprintf(format_str, "{%u}", INT_MAX + 1u); 573 EXPECT_THROW_MSG(format(format_str), FormatError, "number is too big"); 574} 575 576#if FMT_USE_VARIADIC_TEMPLATES 577template <int N> 578struct TestFormat { 579 template <typename... Args> 580 static std::string format(fmt::CStringRef format_str, const Args & ... args) { 581 return TestFormat<N - 1>::format(format_str, N - 1, args...); 582 } 583}; 584 585template <> 586struct TestFormat<0> { 587 template <typename... Args> 588 static std::string format(fmt::CStringRef format_str, const Args & ... args) { 589 return fmt::format(format_str, args...); 590 } 591}; 592 593TEST(FormatterTest, ManyArgs) { 594 EXPECT_EQ("19", TestFormat<20>::format("{19}")); 595 EXPECT_THROW_MSG(TestFormat<20>::format("{20}"), 596 FormatError, "argument index out of range"); 597 EXPECT_THROW_MSG(TestFormat<21>::format("{21}"), 598 FormatError, "argument index out of range"); 599 enum { MAX_PACKED_ARGS = fmt::ArgList::MAX_PACKED_ARGS }; 600 std::string format_str = fmt::format("{{{}}}", MAX_PACKED_ARGS + 1); 601 EXPECT_THROW_MSG(TestFormat<MAX_PACKED_ARGS>::format(format_str), 602 FormatError, "argument index out of range"); 603} 604#endif 605 606TEST(FormatterTest, NamedArg) { 607 EXPECT_EQ("1/a/A", format("{_1}/{a_}/{A_}", fmt::arg("a_", 'a'), 608 fmt::arg("A_", "A"), fmt::arg("_1", 1))); 609 char a = 'A', b = 'B', c = 'C'; 610 EXPECT_EQ("BB/AA/CC", format("{1}{b}/{0}{a}/{2}{c}", FMT_CAPTURE(a, b, c))); 611 EXPECT_EQ(" A", format("{a:>2}", FMT_CAPTURE(a))); 612 EXPECT_THROW_MSG(format("{a+}", FMT_CAPTURE(a)), FormatError, 613 "missing '}' in format string"); 614 EXPECT_THROW_MSG(format("{a}"), FormatError, "argument not found"); 615 EXPECT_THROW_MSG(format("{d}", FMT_CAPTURE(a, b, c)), FormatError, 616 "argument not found"); 617 EXPECT_THROW_MSG(format("{a}{}", FMT_CAPTURE(a)), 618 FormatError, "cannot switch from manual to automatic argument indexing"); 619 EXPECT_THROW_MSG(format("{}{a}", FMT_CAPTURE(a)), 620 FormatError, "cannot switch from automatic to manual argument indexing"); 621 EXPECT_EQ(" -42", format("{0:{width}}", -42, fmt::arg("width", 4))); 622 EXPECT_EQ("st", format("{0:.{precision}}", "str", fmt::arg("precision", 2))); 623 int n = 100; 624 EXPECT_EQ(L"n=100", format(L"n={n}", FMT_CAPTURE_W(n))); 625} 626 627TEST(FormatterTest, AutoArgIndex) { 628 EXPECT_EQ("abc", format("{}{}{}", 'a', 'b', 'c')); 629 EXPECT_THROW_MSG(format("{0}{}", 'a', 'b'), 630 FormatError, "cannot switch from manual to automatic argument indexing"); 631 EXPECT_THROW_MSG(format("{}{0}", 'a', 'b'), 632 FormatError, "cannot switch from automatic to manual argument indexing"); 633 EXPECT_EQ("1.2", format("{:.{}}", 1.2345, 2)); 634 EXPECT_THROW_MSG(format("{0}:.{}", 1.2345, 2), 635 FormatError, "cannot switch from manual to automatic argument indexing"); 636 EXPECT_THROW_MSG(format("{:.{0}}", 1.2345, 2), 637 FormatError, "cannot switch from automatic to manual argument indexing"); 638 EXPECT_THROW_MSG(format("{}"), FormatError, "argument index out of range"); 639} 640 641TEST(FormatterTest, EmptySpecs) { 642 EXPECT_EQ("42", format("{0:}", 42)); 643} 644 645TEST(FormatterTest, LeftAlign) { 646 EXPECT_EQ("42 ", format("{0:<4}", 42)); 647 EXPECT_EQ("42 ", format("{0:<4o}", 042)); 648 EXPECT_EQ("42 ", format("{0:<4x}", 0x42)); 649 EXPECT_EQ("-42 ", format("{0:<5}", -42)); 650 EXPECT_EQ("42 ", format("{0:<5}", 42u)); 651 EXPECT_EQ("-42 ", format("{0:<5}", -42l)); 652 EXPECT_EQ("42 ", format("{0:<5}", 42ul)); 653 EXPECT_EQ("-42 ", format("{0:<5}", -42ll)); 654 EXPECT_EQ("42 ", format("{0:<5}", 42ull)); 655 EXPECT_EQ("-42 ", format("{0:<5}", -42.0)); 656 EXPECT_EQ("-42 ", format("{0:<5}", -42.0l)); 657 EXPECT_EQ("c ", format("{0:<5}", 'c')); 658 EXPECT_EQ("abc ", format("{0:<5}", "abc")); 659 EXPECT_EQ("0xface ", format("{0:<8}", reinterpret_cast<void*>(0xface))); 660} 661 662TEST(FormatterTest, RightAlign) { 663 EXPECT_EQ(" 42", format("{0:>4}", 42)); 664 EXPECT_EQ(" 42", format("{0:>4o}", 042)); 665 EXPECT_EQ(" 42", format("{0:>4x}", 0x42)); 666 EXPECT_EQ(" -42", format("{0:>5}", -42)); 667 EXPECT_EQ(" 42", format("{0:>5}", 42u)); 668 EXPECT_EQ(" -42", format("{0:>5}", -42l)); 669 EXPECT_EQ(" 42", format("{0:>5}", 42ul)); 670 EXPECT_EQ(" -42", format("{0:>5}", -42ll)); 671 EXPECT_EQ(" 42", format("{0:>5}", 42ull)); 672 EXPECT_EQ(" -42", format("{0:>5}", -42.0)); 673 EXPECT_EQ(" -42", format("{0:>5}", -42.0l)); 674 EXPECT_EQ(" c", format("{0:>5}", 'c')); 675 EXPECT_EQ(" abc", format("{0:>5}", "abc")); 676 EXPECT_EQ(" 0xface", format("{0:>8}", reinterpret_cast<void*>(0xface))); 677} 678 679TEST(FormatterTest, NumericAlign) { 680 EXPECT_EQ(" 42", format("{0:=4}", 42)); 681 EXPECT_EQ("+ 42", format("{0:=+4}", 42)); 682 EXPECT_EQ(" 42", format("{0:=4o}", 042)); 683 EXPECT_EQ("+ 42", format("{0:=+4o}", 042)); 684 EXPECT_EQ(" 42", format("{0:=4x}", 0x42)); 685 EXPECT_EQ("+ 42", format("{0:=+4x}", 0x42)); 686 EXPECT_EQ("- 42", format("{0:=5}", -42)); 687 EXPECT_EQ(" 42", format("{0:=5}", 42u)); 688 EXPECT_EQ("- 42", format("{0:=5}", -42l)); 689 EXPECT_EQ(" 42", format("{0:=5}", 42ul)); 690 EXPECT_EQ("- 42", format("{0:=5}", -42ll)); 691 EXPECT_EQ(" 42", format("{0:=5}", 42ull)); 692 EXPECT_EQ("- 42", format("{0:=5}", -42.0)); 693 EXPECT_EQ("- 42", format("{0:=5}", -42.0l)); 694 EXPECT_THROW_MSG(format("{0:=5", 'c'), 695 FormatError, "missing '}' in format string"); 696 EXPECT_THROW_MSG(format("{0:=5}", 'c'), 697 FormatError, "invalid format specifier for char"); 698 EXPECT_THROW_MSG(format("{0:=5}", "abc"), 699 FormatError, "format specifier '=' requires numeric argument"); 700 EXPECT_THROW_MSG(format("{0:=8}", reinterpret_cast<void*>(0xface)), 701 FormatError, "format specifier '=' requires numeric argument"); 702} 703 704TEST(FormatterTest, CenterAlign) { 705 EXPECT_EQ(" 42 ", format("{0:^5}", 42)); 706 EXPECT_EQ(" 42 ", format("{0:^5o}", 042)); 707 EXPECT_EQ(" 42 ", format("{0:^5x}", 0x42)); 708 EXPECT_EQ(" -42 ", format("{0:^5}", -42)); 709 EXPECT_EQ(" 42 ", format("{0:^5}", 42u)); 710 EXPECT_EQ(" -42 ", format("{0:^5}", -42l)); 711 EXPECT_EQ(" 42 ", format("{0:^5}", 42ul)); 712 EXPECT_EQ(" -42 ", format("{0:^5}", -42ll)); 713 EXPECT_EQ(" 42 ", format("{0:^5}", 42ull)); 714 EXPECT_EQ(" -42 ", format("{0:^6}", -42.0)); 715 EXPECT_EQ(" -42 ", format("{0:^5}", -42.0l)); 716 EXPECT_EQ(" c ", format("{0:^5}", 'c')); 717 EXPECT_EQ(" abc ", format("{0:^6}", "abc")); 718 EXPECT_EQ(" 0xface ", format("{0:^8}", reinterpret_cast<void*>(0xface))); 719} 720 721TEST(FormatterTest, Fill) { 722 EXPECT_THROW_MSG(format("{0:{<5}", 'c'), 723 FormatError, "invalid fill character '{'"); 724 EXPECT_THROW_MSG(format("{0:{<5}}", 'c'), 725 FormatError, "invalid fill character '{'"); 726 EXPECT_EQ("**42", format("{0:*>4}", 42)); 727 EXPECT_EQ("**-42", format("{0:*>5}", -42)); 728 EXPECT_EQ("***42", format("{0:*>5}", 42u)); 729 EXPECT_EQ("**-42", format("{0:*>5}", -42l)); 730 EXPECT_EQ("***42", format("{0:*>5}", 42ul)); 731 EXPECT_EQ("**-42", format("{0:*>5}", -42ll)); 732 EXPECT_EQ("***42", format("{0:*>5}", 42ull)); 733 EXPECT_EQ("**-42", format("{0:*>5}", -42.0)); 734 EXPECT_EQ("**-42", format("{0:*>5}", -42.0l)); 735 EXPECT_EQ("c****", format("{0:*<5}", 'c')); 736 EXPECT_EQ("abc**", format("{0:*<5}", "abc")); 737 EXPECT_EQ("**0xface", format("{0:*>8}", reinterpret_cast<void*>(0xface))); 738} 739 740TEST(FormatterTest, PlusSign) { 741 EXPECT_EQ("+42", format("{0:+}", 42)); 742 EXPECT_EQ("-42", format("{0:+}", -42)); 743 EXPECT_EQ("+42", format("{0:+}", 42)); 744 EXPECT_THROW_MSG(format("{0:+}", 42u), 745 FormatError, "format specifier '+' requires signed argument"); 746 EXPECT_EQ("+42", format("{0:+}", 42l)); 747 EXPECT_THROW_MSG(format("{0:+}", 42ul), 748 FormatError, "format specifier '+' requires signed argument"); 749 EXPECT_EQ("+42", format("{0:+}", 42ll)); 750 EXPECT_THROW_MSG(format("{0:+}", 42ull), 751 FormatError, "format specifier '+' requires signed argument"); 752 EXPECT_EQ("+42", format("{0:+}", 42.0)); 753 EXPECT_EQ("+42", format("{0:+}", 42.0l)); 754 EXPECT_THROW_MSG(format("{0:+", 'c'), 755 FormatError, "missing '}' in format string"); 756 EXPECT_THROW_MSG(format("{0:+}", 'c'), 757 FormatError, "invalid format specifier for char"); 758 EXPECT_THROW_MSG(format("{0:+}", "abc"), 759 FormatError, "format specifier '+' requires numeric argument"); 760 EXPECT_THROW_MSG(format("{0:+}", reinterpret_cast<void*>(0x42)), 761 FormatError, "format specifier '+' requires numeric argument"); 762} 763 764TEST(FormatterTest, MinusSign) { 765 EXPECT_EQ("42", format("{0:-}", 42)); 766 EXPECT_EQ("-42", format("{0:-}", -42)); 767 EXPECT_EQ("42", format("{0:-}", 42)); 768 EXPECT_THROW_MSG(format("{0:-}", 42u), 769 FormatError, "format specifier '-' requires signed argument"); 770 EXPECT_EQ("42", format("{0:-}", 42l)); 771 EXPECT_THROW_MSG(format("{0:-}", 42ul), 772 FormatError, "format specifier '-' requires signed argument"); 773 EXPECT_EQ("42", format("{0:-}", 42ll)); 774 EXPECT_THROW_MSG(format("{0:-}", 42ull), 775 FormatError, "format specifier '-' requires signed argument"); 776 EXPECT_EQ("42", format("{0:-}", 42.0)); 777 EXPECT_EQ("42", format("{0:-}", 42.0l)); 778 EXPECT_THROW_MSG(format("{0:-", 'c'), 779 FormatError, "missing '}' in format string"); 780 EXPECT_THROW_MSG(format("{0:-}", 'c'), 781 FormatError, "invalid format specifier for char"); 782 EXPECT_THROW_MSG(format("{0:-}", "abc"), 783 FormatError, "format specifier '-' requires numeric argument"); 784 EXPECT_THROW_MSG(format("{0:-}", reinterpret_cast<void*>(0x42)), 785 FormatError, "format specifier '-' requires numeric argument"); 786} 787 788TEST(FormatterTest, SpaceSign) { 789 EXPECT_EQ(" 42", format("{0: }", 42)); 790 EXPECT_EQ("-42", format("{0: }", -42)); 791 EXPECT_EQ(" 42", format("{0: }", 42)); 792 EXPECT_THROW_MSG(format("{0: }", 42u), 793 FormatError, "format specifier ' ' requires signed argument"); 794 EXPECT_EQ(" 42", format("{0: }", 42l)); 795 EXPECT_THROW_MSG(format("{0: }", 42ul), 796 FormatError, "format specifier ' ' requires signed argument"); 797 EXPECT_EQ(" 42", format("{0: }", 42ll)); 798 EXPECT_THROW_MSG(format("{0: }", 42ull), 799 FormatError, "format specifier ' ' requires signed argument"); 800 EXPECT_EQ(" 42", format("{0: }", 42.0)); 801 EXPECT_EQ(" 42", format("{0: }", 42.0l)); 802 EXPECT_THROW_MSG(format("{0: ", 'c'), 803 FormatError, "missing '}' in format string"); 804 EXPECT_THROW_MSG(format("{0: }", 'c'), 805 FormatError, "invalid format specifier for char"); 806 EXPECT_THROW_MSG(format("{0: }", "abc"), 807 FormatError, "format specifier ' ' requires numeric argument"); 808 EXPECT_THROW_MSG(format("{0: }", reinterpret_cast<void*>(0x42)), 809 FormatError, "format specifier ' ' requires numeric argument"); 810} 811 812TEST(FormatterTest, HashFlag) { 813 EXPECT_EQ("42", format("{0:#}", 42)); 814 EXPECT_EQ("-42", format("{0:#}", -42)); 815 EXPECT_EQ("0b101010", format("{0:#b}", 42)); 816 EXPECT_EQ("0B101010", format("{0:#B}", 42)); 817 EXPECT_EQ("-0b101010", format("{0:#b}", -42)); 818 EXPECT_EQ("0x42", format("{0:#x}", 0x42)); 819 EXPECT_EQ("0X42", format("{0:#X}", 0x42)); 820 EXPECT_EQ("-0x42", format("{0:#x}", -0x42)); 821 EXPECT_EQ("042", format("{0:#o}", 042)); 822 EXPECT_EQ("-042", format("{0:#o}", -042)); 823 EXPECT_EQ("42", format("{0:#}", 42u)); 824 EXPECT_EQ("0x42", format("{0:#x}", 0x42u)); 825 EXPECT_EQ("042", format("{0:#o}", 042u)); 826 827 EXPECT_EQ("-42", format("{0:#}", -42l)); 828 EXPECT_EQ("0x42", format("{0:#x}", 0x42l)); 829 EXPECT_EQ("-0x42", format("{0:#x}", -0x42l)); 830 EXPECT_EQ("042", format("{0:#o}", 042l)); 831 EXPECT_EQ("-042", format("{0:#o}", -042l)); 832 EXPECT_EQ("42", format("{0:#}", 42ul)); 833 EXPECT_EQ("0x42", format("{0:#x}", 0x42ul)); 834 EXPECT_EQ("042", format("{0:#o}", 042ul)); 835 836 EXPECT_EQ("-42", format("{0:#}", -42ll)); 837 EXPECT_EQ("0x42", format("{0:#x}", 0x42ll)); 838 EXPECT_EQ("-0x42", format("{0:#x}", -0x42ll)); 839 EXPECT_EQ("042", format("{0:#o}", 042ll)); 840 EXPECT_EQ("-042", format("{0:#o}", -042ll)); 841 EXPECT_EQ("42", format("{0:#}", 42ull)); 842 EXPECT_EQ("0x42", format("{0:#x}", 0x42ull)); 843 EXPECT_EQ("042", format("{0:#o}", 042ull)); 844 845 EXPECT_EQ("-42.0000", format("{0:#}", -42.0)); 846 EXPECT_EQ("-42.0000", format("{0:#}", -42.0l)); 847 EXPECT_THROW_MSG(format("{0:#", 'c'), 848 FormatError, "missing '}' in format string"); 849 EXPECT_THROW_MSG(format("{0:#}", 'c'), 850 FormatError, "invalid format specifier for char"); 851 EXPECT_THROW_MSG(format("{0:#}", "abc"), 852 FormatError, "format specifier '#' requires numeric argument"); 853 EXPECT_THROW_MSG(format("{0:#}", reinterpret_cast<void*>(0x42)), 854 FormatError, "format specifier '#' requires numeric argument"); 855} 856 857TEST(FormatterTest, ZeroFlag) { 858 EXPECT_EQ("42", format("{0:0}", 42)); 859 EXPECT_EQ("-0042", format("{0:05}", -42)); 860 EXPECT_EQ("00042", format("{0:05}", 42u)); 861 EXPECT_EQ("-0042", format("{0:05}", -42l)); 862 EXPECT_EQ("00042", format("{0:05}", 42ul)); 863 EXPECT_EQ("-0042", format("{0:05}", -42ll)); 864 EXPECT_EQ("00042", format("{0:05}", 42ull)); 865 EXPECT_EQ("-0042", format("{0:05}", -42.0)); 866 EXPECT_EQ("-0042", format("{0:05}", -42.0l)); 867 EXPECT_THROW_MSG(format("{0:0", 'c'), 868 FormatError, "missing '}' in format string"); 869 EXPECT_THROW_MSG(format("{0:05}", 'c'), 870 FormatError, "invalid format specifier for char"); 871 EXPECT_THROW_MSG(format("{0:05}", "abc"), 872 FormatError, "format specifier '0' requires numeric argument"); 873 EXPECT_THROW_MSG(format("{0:05}", reinterpret_cast<void*>(0x42)), 874 FormatError, "format specifier '0' requires numeric argument"); 875} 876 877TEST(FormatterTest, Width) { 878 char format_str[BUFFER_SIZE]; 879 safe_sprintf(format_str, "{0:%u", UINT_MAX); 880 increment(format_str + 3); 881 EXPECT_THROW_MSG(format(format_str, 0), FormatError, "number is too big"); 882 std::size_t size = std::strlen(format_str); 883 format_str[size] = '}'; 884 format_str[size + 1] = 0; 885 EXPECT_THROW_MSG(format(format_str, 0), FormatError, "number is too big"); 886 887 safe_sprintf(format_str, "{0:%u", INT_MAX + 1u); 888 EXPECT_THROW_MSG(format(format_str, 0), FormatError, "number is too big"); 889 safe_sprintf(format_str, "{0:%u}", INT_MAX + 1u); 890 EXPECT_THROW_MSG(format(format_str, 0), FormatError, "number is too big"); 891 EXPECT_EQ(" -42", format("{0:4}", -42)); 892 EXPECT_EQ(" 42", format("{0:5}", 42u)); 893 EXPECT_EQ(" -42", format("{0:6}", -42l)); 894 EXPECT_EQ(" 42", format("{0:7}", 42ul)); 895 EXPECT_EQ(" -42", format("{0:6}", -42ll)); 896 EXPECT_EQ(" 42", format("{0:7}", 42ull)); 897 EXPECT_EQ(" -1.23", format("{0:8}", -1.23)); 898 EXPECT_EQ(" -1.23", format("{0:9}", -1.23l)); 899 EXPECT_EQ(" 0xcafe", format("{0:10}", reinterpret_cast<void*>(0xcafe))); 900 EXPECT_EQ("x ", format("{0:11}", 'x')); 901 EXPECT_EQ("str ", format("{0:12}", "str")); 902} 903 904TEST(FormatterTest, RuntimeWidth) { 905 char format_str[BUFFER_SIZE]; 906 safe_sprintf(format_str, "{0:{%u", UINT_MAX); 907 increment(format_str + 4); 908 EXPECT_THROW_MSG(format(format_str, 0), FormatError, "number is too big"); 909 std::size_t size = std::strlen(format_str); 910 format_str[size] = '}'; 911 format_str[size + 1] = 0; 912 EXPECT_THROW_MSG(format(format_str, 0), FormatError, "number is too big"); 913 format_str[size + 1] = '}'; 914 format_str[size + 2] = 0; 915 EXPECT_THROW_MSG(format(format_str, 0), FormatError, "number is too big"); 916 917 EXPECT_THROW_MSG(format("{0:{", 0), 918 FormatError, "invalid format string"); 919 EXPECT_THROW_MSG(format("{0:{}", 0), 920 FormatError, "cannot switch from manual to automatic argument indexing"); 921 EXPECT_THROW_MSG(format("{0:{?}}", 0), 922 FormatError, "invalid format string"); 923 EXPECT_THROW_MSG(format("{0:{1}}", 0), 924 FormatError, "argument index out of range"); 925 926 EXPECT_THROW_MSG(format("{0:{0:}}", 0), 927 FormatError, "invalid format string"); 928 929 EXPECT_THROW_MSG(format("{0:{1}}", 0, -1), 930 FormatError, "negative width"); 931 EXPECT_THROW_MSG(format("{0:{1}}", 0, (INT_MAX + 1u)), 932 FormatError, "number is too big"); 933 EXPECT_THROW_MSG(format("{0:{1}}", 0, -1l), 934 FormatError, "negative width"); 935 if (fmt::internal::const_check(sizeof(long) > sizeof(int))) { 936 long value = INT_MAX; 937 EXPECT_THROW_MSG(format("{0:{1}}", 0, (value + 1)), 938 FormatError, "number is too big"); 939 } 940 EXPECT_THROW_MSG(format("{0:{1}}", 0, (INT_MAX + 1ul)), 941 FormatError, "number is too big"); 942 943 EXPECT_THROW_MSG(format("{0:{1}}", 0, '0'), 944 FormatError, "width is not integer"); 945 EXPECT_THROW_MSG(format("{0:{1}}", 0, 0.0), 946 FormatError, "width is not integer"); 947 948 EXPECT_EQ(" -42", format("{0:{1}}", -42, 4)); 949 EXPECT_EQ(" 42", format("{0:{1}}", 42u, 5)); 950 EXPECT_EQ(" -42", format("{0:{1}}", -42l, 6)); 951 EXPECT_EQ(" 42", format("{0:{1}}", 42ul, 7)); 952 EXPECT_EQ(" -42", format("{0:{1}}", -42ll, 6)); 953 EXPECT_EQ(" 42", format("{0:{1}}", 42ull, 7)); 954 EXPECT_EQ(" -1.23", format("{0:{1}}", -1.23, 8)); 955 EXPECT_EQ(" -1.23", format("{0:{1}}", -1.23l, 9)); 956 EXPECT_EQ(" 0xcafe", 957 format("{0:{1}}", reinterpret_cast<void*>(0xcafe), 10)); 958 EXPECT_EQ("x ", format("{0:{1}}", 'x', 11)); 959 EXPECT_EQ("str ", format("{0:{1}}", "str", 12)); 960} 961 962TEST(FormatterTest, Precision) { 963 char format_str[BUFFER_SIZE]; 964 safe_sprintf(format_str, "{0:.%u", UINT_MAX); 965 increment(format_str + 4); 966 EXPECT_THROW_MSG(format(format_str, 0), FormatError, "number is too big"); 967 std::size_t size = std::strlen(format_str); 968 format_str[size] = '}'; 969 format_str[size + 1] = 0; 970 EXPECT_THROW_MSG(format(format_str, 0), FormatError, "number is too big"); 971 972 safe_sprintf(format_str, "{0:.%u", INT_MAX + 1u); 973 EXPECT_THROW_MSG(format(format_str, 0), FormatError, "number is too big"); 974 safe_sprintf(format_str, "{0:.%u}", INT_MAX + 1u); 975 EXPECT_THROW_MSG(format(format_str, 0), FormatError, "number is too big"); 976 977 EXPECT_THROW_MSG(format("{0:.", 0), 978 FormatError, "missing precision specifier"); 979 EXPECT_THROW_MSG(format("{0:.}", 0), 980 FormatError, "missing precision specifier"); 981 982 EXPECT_THROW_MSG(format("{0:.2", 0), 983 FormatError, "precision not allowed in integer format specifier"); 984 EXPECT_THROW_MSG(format("{0:.2}", 42), 985 FormatError, "precision not allowed in integer format specifier"); 986 EXPECT_THROW_MSG(format("{0:.2f}", 42), 987 FormatError, "precision not allowed in integer format specifier"); 988 EXPECT_THROW_MSG(format("{0:.2}", 42u), 989 FormatError, "precision not allowed in integer format specifier"); 990 EXPECT_THROW_MSG(format("{0:.2f}", 42u), 991 FormatError, "precision not allowed in integer format specifier"); 992 EXPECT_THROW_MSG(format("{0:.2}", 42l), 993 FormatError, "precision not allowed in integer format specifier"); 994 EXPECT_THROW_MSG(format("{0:.2f}", 42l), 995 FormatError, "precision not allowed in integer format specifier"); 996 EXPECT_THROW_MSG(format("{0:.2}", 42ul), 997 FormatError, "precision not allowed in integer format specifier"); 998 EXPECT_THROW_MSG(format("{0:.2f}", 42ul), 999 FormatError, "precision not allowed in integer format specifier"); 1000 EXPECT_THROW_MSG(format("{0:.2}", 42ll), 1001 FormatError, "precision not allowed in integer format specifier"); 1002 EXPECT_THROW_MSG(format("{0:.2f}", 42ll), 1003 FormatError, "precision not allowed in integer format specifier"); 1004 EXPECT_THROW_MSG(format("{0:.2}", 42ull), 1005 FormatError, "precision not allowed in integer format specifier"); 1006 EXPECT_THROW_MSG(format("{0:.2f}", 42ull), 1007 FormatError, "precision not allowed in integer format specifier"); 1008 EXPECT_THROW_MSG(format("{0:3.0}", 'x'), 1009 FormatError, "precision not allowed in integer format specifier"); 1010 EXPECT_EQ("1.2", format("{0:.2}", 1.2345)); 1011 EXPECT_EQ("1.2", format("{0:.2}", 1.2345l)); 1012 1013 EXPECT_THROW_MSG(format("{0:.2}", reinterpret_cast<void*>(0xcafe)), 1014 FormatError, "precision not allowed in pointer format specifier"); 1015 EXPECT_THROW_MSG(format("{0:.2f}", reinterpret_cast<void*>(0xcafe)), 1016 FormatError, "precision not allowed in pointer format specifier"); 1017 1018 EXPECT_EQ("st", format("{0:.2}", "str")); 1019} 1020 1021TEST(FormatterTest, RuntimePrecision) { 1022 char format_str[BUFFER_SIZE]; 1023 safe_sprintf(format_str, "{0:.{%u", UINT_MAX); 1024 increment(format_str + 5); 1025 EXPECT_THROW_MSG(format(format_str, 0), FormatError, "number is too big"); 1026 std::size_t size = std::strlen(format_str); 1027 format_str[size] = '}'; 1028 format_str[size + 1] = 0; 1029 EXPECT_THROW_MSG(format(format_str, 0), FormatError, "number is too big"); 1030 format_str[size + 1] = '}'; 1031 format_str[size + 2] = 0; 1032 EXPECT_THROW_MSG(format(format_str, 0), FormatError, "number is too big"); 1033 1034 EXPECT_THROW_MSG(format("{0:.{", 0), 1035 FormatError, "invalid format string"); 1036 EXPECT_THROW_MSG(format("{0:.{}", 0), 1037 FormatError, "cannot switch from manual to automatic argument indexing"); 1038 EXPECT_THROW_MSG(format("{0:.{?}}", 0), 1039 FormatError, "invalid format string"); 1040 EXPECT_THROW_MSG(format("{0:.{1}", 0, 0), 1041 FormatError, "precision not allowed in integer format specifier"); 1042 EXPECT_THROW_MSG(format("{0:.{1}}", 0), 1043 FormatError, "argument index out of range"); 1044 1045 EXPECT_THROW_MSG(format("{0:.{0:}}", 0), 1046 FormatError, "invalid format string"); 1047 1048 EXPECT_THROW_MSG(format("{0:.{1}}", 0, -1), 1049 FormatError, "negative precision"); 1050 EXPECT_THROW_MSG(format("{0:.{1}}", 0, (INT_MAX + 1u)), 1051 FormatError, "number is too big"); 1052 EXPECT_THROW_MSG(format("{0:.{1}}", 0, -1l), 1053 FormatError, "negative precision"); 1054 if (fmt::internal::const_check(sizeof(long) > sizeof(int))) { 1055 long value = INT_MAX; 1056 EXPECT_THROW_MSG(format("{0:.{1}}", 0, (value + 1)), 1057 FormatError, "number is too big"); 1058 } 1059 EXPECT_THROW_MSG(format("{0:.{1}}", 0, (INT_MAX + 1ul)), 1060 FormatError, "number is too big"); 1061 1062 EXPECT_THROW_MSG(format("{0:.{1}}", 0, '0'), 1063 FormatError, "precision is not integer"); 1064 EXPECT_THROW_MSG(format("{0:.{1}}", 0, 0.0), 1065 FormatError, "precision is not integer"); 1066 1067 EXPECT_THROW_MSG(format("{0:.{1}}", 42, 2), 1068 FormatError, "precision not allowed in integer format specifier"); 1069 EXPECT_THROW_MSG(format("{0:.{1}f}", 42, 2), 1070 FormatError, "precision not allowed in integer format specifier"); 1071 EXPECT_THROW_MSG(format("{0:.{1}}", 42u, 2), 1072 FormatError, "precision not allowed in integer format specifier"); 1073 EXPECT_THROW_MSG(format("{0:.{1}f}", 42u, 2), 1074 FormatError, "precision not allowed in integer format specifier"); 1075 EXPECT_THROW_MSG(format("{0:.{1}}", 42l, 2), 1076 FormatError, "precision not allowed in integer format specifier"); 1077 EXPECT_THROW_MSG(format("{0:.{1}f}", 42l, 2), 1078 FormatError, "precision not allowed in integer format specifier"); 1079 EXPECT_THROW_MSG(format("{0:.{1}}", 42ul, 2), 1080 FormatError, "precision not allowed in integer format specifier"); 1081 EXPECT_THROW_MSG(format("{0:.{1}f}", 42ul, 2), 1082 FormatError, "precision not allowed in integer format specifier"); 1083 EXPECT_THROW_MSG(format("{0:.{1}}", 42ll, 2), 1084 FormatError, "precision not allowed in integer format specifier"); 1085 EXPECT_THROW_MSG(format("{0:.{1}f}", 42ll, 2), 1086 FormatError, "precision not allowed in integer format specifier"); 1087 EXPECT_THROW_MSG(format("{0:.{1}}", 42ull, 2), 1088 FormatError, "precision not allowed in integer format specifier"); 1089 EXPECT_THROW_MSG(format("{0:.{1}f}", 42ull, 2), 1090 FormatError, "precision not allowed in integer format specifier"); 1091 EXPECT_THROW_MSG(format("{0:3.{1}}", 'x', 0), 1092 FormatError, "precision not allowed in integer format specifier"); 1093 EXPECT_EQ("1.2", format("{0:.{1}}", 1.2345, 2)); 1094 EXPECT_EQ("1.2", format("{1:.{0}}", 2, 1.2345l)); 1095 1096 EXPECT_THROW_MSG(format("{0:.{1}}", reinterpret_cast<void*>(0xcafe), 2), 1097 FormatError, "precision not allowed in pointer format specifier"); 1098 EXPECT_THROW_MSG(format("{0:.{1}f}", reinterpret_cast<void*>(0xcafe), 2), 1099 FormatError, "precision not allowed in pointer format specifier"); 1100 1101 EXPECT_EQ("st", format("{0:.{1}}", "str", 2)); 1102} 1103 1104template <typename T> 1105void check_unknown_types( 1106 const T &value, const char *types, const char *type_name) { 1107 char format_str[BUFFER_SIZE], message[BUFFER_SIZE]; 1108 const char *special = ".0123456789}"; 1109 for (int i = CHAR_MIN; i <= CHAR_MAX; ++i) { 1110 char c = static_cast<char>(i); 1111 if (std::strchr(types, c) || std::strchr(special, c) || !c) continue; 1112 safe_sprintf(format_str, "{0:10%c}", c); 1113 if (std::isprint(static_cast<unsigned char>(c))) { 1114 safe_sprintf(message, "unknown format code '%c' for %s", c, type_name); 1115 } else { 1116 safe_sprintf(message, "unknown format code '\\x%02x' for %s", c, 1117 type_name); 1118 } 1119 EXPECT_THROW_MSG(format(format_str, value), FormatError, message) 1120 << format_str << " " << message; 1121 } 1122} 1123 1124TEST(BoolTest, FormatBool) { 1125 EXPECT_EQ("true", format("{}", true)); 1126 EXPECT_EQ("false", format("{}", false)); 1127 EXPECT_EQ("1", format("{:d}", true)); 1128 EXPECT_EQ("true ", format("{:5}", true)); 1129 EXPECT_EQ(L"true", format(L"{}", true)); 1130} 1131 1132TEST(FormatterTest, FormatShort) { 1133 short s = 42; 1134 EXPECT_EQ("42", format("{0:d}", s)); 1135 unsigned short us = 42; 1136 EXPECT_EQ("42", format("{0:d}", us)); 1137} 1138 1139TEST(FormatterTest, FormatInt) { 1140 EXPECT_THROW_MSG(format("{0:v", 42), 1141 FormatError, "missing '}' in format string"); 1142 check_unknown_types(42, "bBdoxXn", "integer"); 1143} 1144 1145TEST(FormatterTest, FormatBin) { 1146 EXPECT_EQ("0", format("{0:b}", 0)); 1147 EXPECT_EQ("101010", format("{0:b}", 42)); 1148 EXPECT_EQ("101010", format("{0:b}", 42u)); 1149 EXPECT_EQ("-101010", format("{0:b}", -42)); 1150 EXPECT_EQ("11000000111001", format("{0:b}", 12345)); 1151 EXPECT_EQ("10010001101000101011001111000", format("{0:b}", 0x12345678)); 1152 EXPECT_EQ("10010000101010111100110111101111", format("{0:b}", 0x90ABCDEF)); 1153 EXPECT_EQ("11111111111111111111111111111111", 1154 format("{0:b}", std::numeric_limits<uint32_t>::max())); 1155} 1156 1157TEST(FormatterTest, FormatDec) { 1158 EXPECT_EQ("0", format("{0}", 0)); 1159 EXPECT_EQ("42", format("{0}", 42)); 1160 EXPECT_EQ("42", format("{0:d}", 42)); 1161 EXPECT_EQ("42", format("{0}", 42u)); 1162 EXPECT_EQ("-42", format("{0}", -42)); 1163 EXPECT_EQ("12345", format("{0}", 12345)); 1164 EXPECT_EQ("67890", format("{0}", 67890)); 1165 char buffer[BUFFER_SIZE]; 1166 safe_sprintf(buffer, "%d", INT_MIN); 1167 EXPECT_EQ(buffer, format("{0}", INT_MIN)); 1168 safe_sprintf(buffer, "%d", INT_MAX); 1169 EXPECT_EQ(buffer, format("{0}", INT_MAX)); 1170 safe_sprintf(buffer, "%u", UINT_MAX); 1171 EXPECT_EQ(buffer, format("{0}", UINT_MAX)); 1172 safe_sprintf(buffer, "%ld", 0 - static_cast<unsigned long>(LONG_MIN)); 1173 EXPECT_EQ(buffer, format("{0}", LONG_MIN)); 1174 safe_sprintf(buffer, "%ld", LONG_MAX); 1175 EXPECT_EQ(buffer, format("{0}", LONG_MAX)); 1176 safe_sprintf(buffer, "%lu", ULONG_MAX); 1177 EXPECT_EQ(buffer, format("{0}", ULONG_MAX)); 1178} 1179 1180TEST(FormatterTest, FormatHex) { 1181 EXPECT_EQ("0", format("{0:x}", 0)); 1182 EXPECT_EQ("42", format("{0:x}", 0x42)); 1183 EXPECT_EQ("42", format("{0:x}", 0x42u)); 1184 EXPECT_EQ("-42", format("{0:x}", -0x42)); 1185 EXPECT_EQ("12345678", format("{0:x}", 0x12345678)); 1186 EXPECT_EQ("90abcdef", format("{0:x}", 0x90abcdef)); 1187 EXPECT_EQ("12345678", format("{0:X}", 0x12345678)); 1188 EXPECT_EQ("90ABCDEF", format("{0:X}", 0x90ABCDEF)); 1189 1190 char buffer[BUFFER_SIZE]; 1191 safe_sprintf(buffer, "-%x", 0 - static_cast<unsigned>(INT_MIN)); 1192 EXPECT_EQ(buffer, format("{0:x}", INT_MIN)); 1193 safe_sprintf(buffer, "%x", INT_MAX); 1194 EXPECT_EQ(buffer, format("{0:x}", INT_MAX)); 1195 safe_sprintf(buffer, "%x", UINT_MAX); 1196 EXPECT_EQ(buffer, format("{0:x}", UINT_MAX)); 1197 safe_sprintf(buffer, "-%lx", 0 - static_cast<unsigned long>(LONG_MIN)); 1198 EXPECT_EQ(buffer, format("{0:x}", LONG_MIN)); 1199 safe_sprintf(buffer, "%lx", LONG_MAX); 1200 EXPECT_EQ(buffer, format("{0:x}", LONG_MAX)); 1201 safe_sprintf(buffer, "%lx", ULONG_MAX); 1202 EXPECT_EQ(buffer, format("{0:x}", ULONG_MAX)); 1203} 1204 1205TEST(FormatterTest, FormatOct) { 1206 EXPECT_EQ("0", format("{0:o}", 0)); 1207 EXPECT_EQ("42", format("{0:o}", 042)); 1208 EXPECT_EQ("42", format("{0:o}", 042u)); 1209 EXPECT_EQ("-42", format("{0:o}", -042)); 1210 EXPECT_EQ("12345670", format("{0:o}", 012345670)); 1211 char buffer[BUFFER_SIZE]; 1212 safe_sprintf(buffer, "-%o", 0 - static_cast<unsigned>(INT_MIN)); 1213 EXPECT_EQ(buffer, format("{0:o}", INT_MIN)); 1214 safe_sprintf(buffer, "%o", INT_MAX); 1215 EXPECT_EQ(buffer, format("{0:o}", INT_MAX)); 1216 safe_sprintf(buffer, "%o", UINT_MAX); 1217 EXPECT_EQ(buffer, format("{0:o}", UINT_MAX)); 1218 safe_sprintf(buffer, "-%lo", 0 - static_cast<unsigned long>(LONG_MIN)); 1219 EXPECT_EQ(buffer, format("{0:o}", LONG_MIN)); 1220 safe_sprintf(buffer, "%lo", LONG_MAX); 1221 EXPECT_EQ(buffer, format("{0:o}", LONG_MAX)); 1222 safe_sprintf(buffer, "%lo", ULONG_MAX); 1223 EXPECT_EQ(buffer, format("{0:o}", ULONG_MAX)); 1224} 1225 1226TEST(FormatterTest, FormatIntLocale) { 1227 ScopedMock<LocaleMock> mock; 1228 lconv lc = lconv(); 1229 char sep[] = "--"; 1230 lc.thousands_sep = sep; 1231 EXPECT_CALL(mock, localeconv()).Times(3).WillRepeatedly(testing::Return(&lc)); 1232 EXPECT_EQ("123", format("{:n}", 123)); 1233 EXPECT_EQ("1--234", format("{:n}", 1234)); 1234 EXPECT_EQ("1--234--567", format("{:n}", 1234567)); 1235} 1236 1237TEST(FormatterTest, FormatFloat) { 1238 EXPECT_EQ("392.500000", format("{0:f}", 392.5f)); 1239} 1240 1241TEST(FormatterTest, FormatDouble) { 1242 check_unknown_types(1.2, "eEfFgGaA", "double"); 1243 EXPECT_EQ("0", format("{0:}", 0.0)); 1244 EXPECT_EQ("0.000000", format("{0:f}", 0.0)); 1245 EXPECT_EQ("392.65", format("{0:}", 392.65)); 1246 EXPECT_EQ("392.65", format("{0:g}", 392.65)); 1247 EXPECT_EQ("392.65", format("{0:G}", 392.65)); 1248 EXPECT_EQ("392.650000", format("{0:f}", 392.65)); 1249 EXPECT_EQ("392.650000", format("{0:F}", 392.65)); 1250 char buffer[BUFFER_SIZE]; 1251 safe_sprintf(buffer, "%e", 392.65); 1252 EXPECT_EQ(buffer, format("{0:e}", 392.65)); 1253 safe_sprintf(buffer, "%E", 392.65); 1254 EXPECT_EQ(buffer, format("{0:E}", 392.65)); 1255 EXPECT_EQ("+0000392.6", format("{0:+010.4g}", 392.65)); 1256 safe_sprintf(buffer, "%a", -42.0); 1257 EXPECT_EQ(buffer, format("{:a}", -42.0)); 1258 safe_sprintf(buffer, "%A", -42.0); 1259 EXPECT_EQ(buffer, format("{:A}", -42.0)); 1260} 1261 1262TEST(FormatterTest, FormatNaN) { 1263 double nan = std::numeric_limits<double>::quiet_NaN(); 1264 EXPECT_EQ("nan", format("{}", nan)); 1265 EXPECT_EQ("+nan", format("{:+}", nan)); 1266 EXPECT_EQ(" nan", format("{: }", nan)); 1267 EXPECT_EQ("NAN", format("{:F}", nan)); 1268 EXPECT_EQ("nan ", format("{:<7}", nan)); 1269 EXPECT_EQ(" nan ", format("{:^7}", nan)); 1270 EXPECT_EQ(" nan", format("{:>7}", nan)); 1271} 1272 1273TEST(FormatterTest, FormatInfinity) { 1274 double inf = std::numeric_limits<double>::infinity(); 1275 EXPECT_EQ("inf", format("{}", inf)); 1276 EXPECT_EQ("+inf", format("{:+}", inf)); 1277 EXPECT_EQ("-inf", format("{}", -inf)); 1278 EXPECT_EQ(" inf", format("{: }", inf)); 1279 EXPECT_EQ("INF", format("{:F}", inf)); 1280 EXPECT_EQ("inf ", format("{:<7}", inf)); 1281 EXPECT_EQ(" inf ", format("{:^7}", inf)); 1282 EXPECT_EQ(" inf", format("{:>7}", inf)); 1283} 1284 1285TEST(FormatterTest, FormatLongDouble) { 1286 EXPECT_EQ("0", format("{0:}", 0.0l)); 1287 EXPECT_EQ("0.000000", format("{0:f}", 0.0l)); 1288 EXPECT_EQ("392.65", format("{0:}", 392.65l)); 1289 EXPECT_EQ("392.65", format("{0:g}", 392.65l)); 1290 EXPECT_EQ("392.65", format("{0:G}", 392.65l)); 1291 EXPECT_EQ("392.650000", format("{0:f}", 392.65l)); 1292 EXPECT_EQ("392.650000", format("{0:F}", 392.65l)); 1293 char buffer[BUFFER_SIZE]; 1294 safe_sprintf(buffer, "%Le", 392.65l); 1295 EXPECT_EQ(buffer, format("{0:e}", 392.65l)); 1296 EXPECT_EQ("+0000392.6", format("{0:+010.4g}", 392.64l)); 1297} 1298 1299TEST(FormatterTest, FormatChar) { 1300 const char types[] = "cbBdoxXn"; 1301 check_unknown_types('a', types, "char"); 1302 EXPECT_EQ("a", format("{0}", 'a')); 1303 EXPECT_EQ("z", format("{0:c}", 'z')); 1304 EXPECT_EQ(L"a", format(L"{0}", 'a')); 1305 int n = 'x'; 1306 for (const char *type = types + 1; *type; ++type) { 1307 std::string format_str = fmt::format("{{:{}}}", *type); 1308 EXPECT_EQ(fmt::format(format_str, n), fmt::format(format_str, 'x')); 1309 } 1310 EXPECT_EQ(fmt::format("{:02X}", n), fmt::format("{:02X}", 'x')); 1311} 1312 1313TEST(FormatterTest, FormatUnsignedChar) { 1314 EXPECT_EQ("42", format("{}", static_cast<unsigned char>(42))); 1315 EXPECT_EQ("42", format("{}", static_cast<uint8_t>(42))); 1316} 1317 1318TEST(FormatterTest, FormatWChar) { 1319 EXPECT_EQ(L"a", format(L"{0}", L'a')); 1320 // This shouldn't compile: 1321 //format("{}", L'a'); 1322} 1323 1324TEST(FormatterTest, FormatCString) { 1325 check_unknown_types("test", "sp", "string"); 1326 EXPECT_EQ("test", format("{0}", "test")); 1327 EXPECT_EQ("test", format("{0:s}", "test")); 1328 char nonconst[] = "nonconst"; 1329 EXPECT_EQ("nonconst", format("{0}", nonconst)); 1330 EXPECT_THROW_MSG(format("{0}", reinterpret_cast<const char*>(0)), 1331 FormatError, "string pointer is null"); 1332} 1333 1334TEST(FormatterTest, FormatSCharString) { 1335 signed char str[] = "test"; 1336 EXPECT_EQ("test", format("{0:s}", str)); 1337 const signed char *const_str = str; 1338 EXPECT_EQ("test", format("{0:s}", const_str)); 1339} 1340 1341TEST(FormatterTest, FormatUCharString) { 1342 unsigned char str[] = "test"; 1343 EXPECT_EQ("test", format("{0:s}", str)); 1344 const unsigned char *const_str = str; 1345 EXPECT_EQ("test", format("{0:s}", const_str)); 1346 unsigned char *ptr = str; 1347 EXPECT_EQ("test", format("{0:s}", ptr)); 1348} 1349 1350TEST(FormatterTest, FormatPointer) { 1351 check_unknown_types(reinterpret_cast<void*>(0x1234), "p", "pointer"); 1352 EXPECT_EQ("0x0", format("{0}", reinterpret_cast<void*>(0))); 1353 EXPECT_EQ("0x1234", format("{0}", reinterpret_cast<void*>(0x1234))); 1354 EXPECT_EQ("0x1234", format("{0:p}", reinterpret_cast<void*>(0x1234))); 1355 EXPECT_EQ("0x" + std::string(sizeof(void*) * CHAR_BIT / 4, 'f'), 1356 format("{0}", reinterpret_cast<void*>(~uintptr_t()))); 1357} 1358 1359TEST(FormatterTest, FormatString) { 1360 EXPECT_EQ("test", format("{0}", std::string("test"))); 1361} 1362 1363TEST(FormatterTest, FormatStringRef) { 1364 EXPECT_EQ("test", format("{0}", StringRef("test"))); 1365} 1366 1367TEST(FormatterTest, FormatCStringRef) { 1368 EXPECT_EQ("test", format("{0}", CStringRef("test"))); 1369} 1370 1371void format_arg(fmt::BasicFormatter<char> &f, const char *, const Date &d) { 1372 f.writer() << d.year() << '-' << d.month() << '-' << d.day(); 1373} 1374 1375TEST(FormatterTest, FormatCustom) { 1376 Date date(2012, 12, 9); 1377 EXPECT_THROW_MSG(fmt::format("{:s}", date), FormatError, 1378 "unmatched '}' in format string"); 1379} 1380 1381class Answer {}; 1382 1383template <typename Char> 1384void format_arg(fmt::BasicFormatter<Char> &f, const Char *, Answer) { 1385 f.writer() << "42"; 1386} 1387 1388TEST(FormatterTest, CustomFormat) { 1389 EXPECT_EQ("42", format("{0}", Answer())); 1390} 1391 1392TEST(FormatterTest, WideFormatString) { 1393 EXPECT_EQ(L"42", format(L"{}", 42)); 1394 EXPECT_EQ(L"4.2", format(L"{}", 4.2)); 1395 EXPECT_EQ(L"abc", format(L"{}", L"abc")); 1396 EXPECT_EQ(L"z", format(L"{}", L'z')); 1397} 1398 1399TEST(FormatterTest, FormatStringFromSpeedTest) { 1400 EXPECT_EQ("1.2340000000:0042:+3.13:str:0x3e8:X:%", 1401 format("{0:0.10f}:{1:04}:{2:+g}:{3}:{4}:{5}:%", 1402 1.234, 42, 3.13, "str", reinterpret_cast<void*>(1000), 'X')); 1403} 1404 1405TEST(FormatterTest, FormatExamples) { 1406 using fmt::hex; 1407 EXPECT_EQ("0000cafe", (MemoryWriter() << pad(hex(0xcafe), 8, '0')).str()); 1408 1409 std::string message = format("The answer is {}", 42); 1410 EXPECT_EQ("The answer is 42", message); 1411 1412 EXPECT_EQ("42", format("{}", 42)); 1413 EXPECT_EQ("42", format(std::string("{}"), 42)); 1414 1415 MemoryWriter out; 1416 out << "The answer is " << 42 << "\n"; 1417 out.write("({:+f}, {:+f})", -3.14, 3.14); 1418 EXPECT_EQ("The answer is 42\n(-3.140000, +3.140000)", out.str()); 1419 1420 { 1421 MemoryWriter writer; 1422 for (int i = 0; i < 10; i++) 1423 writer.write("{}", i); 1424 std::string s = writer.str(); // s == 0123456789 1425 EXPECT_EQ("0123456789", s); 1426 } 1427 1428 const char *filename = "nonexistent"; 1429 FILE *ftest = safe_fopen(filename, "r"); 1430 if (ftest) fclose(ftest); 1431 int error_code = errno; 1432 EXPECT_TRUE(ftest == 0); 1433 EXPECT_SYSTEM_ERROR({ 1434 FILE *f = safe_fopen(filename, "r"); 1435 if (!f) 1436 throw fmt::SystemError(errno, "Cannot open file '{}'", filename); 1437 fclose(f); 1438 }, error_code, "Cannot open file 'nonexistent'"); 1439} 1440 1441TEST(FormatterTest, Examples) { 1442 EXPECT_EQ("First, thou shalt count to three", 1443 format("First, thou shalt count to {0}", "three")); 1444 EXPECT_EQ("Bring me a shrubbery", 1445 format("Bring me a {}", "shrubbery")); 1446 EXPECT_EQ("From 1 to 3", format("From {} to {}", 1, 3)); 1447 1448 char buffer[BUFFER_SIZE]; 1449 safe_sprintf(buffer, "%03.2f", -1.2); 1450 EXPECT_EQ(buffer, format("{:03.2f}", -1.2)); 1451 1452 EXPECT_EQ("a, b, c", format("{0}, {1}, {2}", 'a', 'b', 'c')); 1453 EXPECT_EQ("a, b, c", format("{}, {}, {}", 'a', 'b', 'c')); 1454 EXPECT_EQ("c, b, a", format("{2}, {1}, {0}", 'a', 'b', 'c')); 1455 EXPECT_EQ("abracadabra", format("{0}{1}{0}", "abra", "cad")); 1456 1457 EXPECT_EQ("left aligned ", 1458 format("{:<30}", "left aligned")); 1459 EXPECT_EQ(" right aligned", 1460 format("{:>30}", "right aligned")); 1461 EXPECT_EQ(" centered ", 1462 format("{:^30}", "centered")); 1463 EXPECT_EQ("***********centered***********", 1464 format("{:*^30}", "centered")); 1465 1466 EXPECT_EQ("+3.140000; -3.140000", 1467 format("{:+f}; {:+f}", 3.14, -3.14)); 1468 EXPECT_EQ(" 3.140000; -3.140000", 1469 format("{: f}; {: f}", 3.14, -3.14)); 1470 EXPECT_EQ("3.140000; -3.140000", 1471 format("{:-f}; {:-f}", 3.14, -3.14)); 1472 1473 EXPECT_EQ("int: 42; hex: 2a; oct: 52", 1474 format("int: {0:d}; hex: {0:x}; oct: {0:o}", 42)); 1475 EXPECT_EQ("int: 42; hex: 0x2a; oct: 052", 1476 format("int: {0:d}; hex: {0:#x}; oct: {0:#o}", 42)); 1477 1478 EXPECT_EQ("The answer is 42", format("The answer is {}", 42)); 1479 EXPECT_THROW_MSG( 1480 format("The answer is {:d}", "forty-two"), FormatError, 1481 "unknown format code 'd' for string"); 1482 1483 EXPECT_EQ(L"Cyrillic letter \x42e", 1484 format(L"Cyrillic letter {}", L'\x42e')); 1485 1486 EXPECT_WRITE(stdout, 1487 fmt::print("{}", std::numeric_limits<double>::infinity()), "inf"); 1488} 1489 1490TEST(FormatIntTest, Data) { 1491 fmt::FormatInt format_int(42); 1492 EXPECT_EQ("42", std::string(format_int.data(), format_int.size())); 1493} 1494 1495TEST(FormatIntTest, FormatInt) { 1496 EXPECT_EQ("42", fmt::FormatInt(42).str()); 1497 EXPECT_EQ(2u, fmt::FormatInt(42).size()); 1498 EXPECT_EQ("-42", fmt::FormatInt(-42).str()); 1499 EXPECT_EQ(3u, fmt::FormatInt(-42).size()); 1500 EXPECT_EQ("42", fmt::FormatInt(42ul).str()); 1501 EXPECT_EQ("-42", fmt::FormatInt(-42l).str()); 1502 EXPECT_EQ("42", fmt::FormatInt(42ull).str()); 1503 EXPECT_EQ("-42", fmt::FormatInt(-42ll).str()); 1504 std::ostringstream os; 1505 os << std::numeric_limits<int64_t>::max(); 1506 EXPECT_EQ(os.str(), 1507 fmt::FormatInt(std::numeric_limits<int64_t>::max()).str()); 1508} 1509 1510template <typename T> 1511std::string format_decimal(T value) { 1512 char buffer[10]; 1513 char *ptr = buffer; 1514 fmt::format_decimal(ptr, value); 1515 return std::string(buffer, ptr); 1516} 1517 1518TEST(FormatIntTest, FormatDec) { 1519 EXPECT_EQ("-42", format_decimal(static_cast<signed char>(-42))); 1520 EXPECT_EQ("-42", format_decimal(static_cast<short>(-42))); 1521 std::ostringstream os; 1522 os << std::numeric_limits<unsigned short>::max(); 1523 EXPECT_EQ(os.str(), 1524 format_decimal(std::numeric_limits<unsigned short>::max())); 1525 EXPECT_EQ("1", format_decimal(1)); 1526 EXPECT_EQ("-1", format_decimal(-1)); 1527 EXPECT_EQ("42", format_decimal(42)); 1528 EXPECT_EQ("-42", format_decimal(-42)); 1529 EXPECT_EQ("42", format_decimal(42l)); 1530 EXPECT_EQ("42", format_decimal(42ul)); 1531 EXPECT_EQ("42", format_decimal(42ll)); 1532 EXPECT_EQ("42", format_decimal(42ull)); 1533} 1534 1535TEST(FormatTest, Print) { 1536#if FMT_USE_FILE_DESCRIPTORS 1537 EXPECT_WRITE(stdout, fmt::print("Don't {}!", "panic"), "Don't panic!"); 1538 EXPECT_WRITE(stderr, 1539 fmt::print(stderr, "Don't {}!", "panic"), "Don't panic!"); 1540#endif 1541} 1542 1543#if FMT_USE_FILE_DESCRIPTORS 1544TEST(FormatTest, PrintColored) { 1545 EXPECT_WRITE(stdout, fmt::print_colored(fmt::RED, "Hello, {}!\n", "world"), 1546 "\x1b[31mHello, world!\n\x1b[0m"); 1547} 1548#endif 1549 1550TEST(FormatTest, Variadic) { 1551 EXPECT_EQ("abc1", format("{}c{}", "ab", 1)); 1552 EXPECT_EQ(L"abc1", format(L"{}c{}", L"ab", 1)); 1553} 1554 1555template <typename T> 1556std::string str(const T &value) { 1557 return fmt::format("{}", value); 1558} 1559 1560TEST(StrTest, Convert) { 1561 EXPECT_EQ("42", str(42)); 1562 std::string s = str(Date(2012, 12, 9)); 1563 EXPECT_EQ("2012-12-9", s); 1564} 1565 1566std::string format_message(int id, const char *format, 1567 const fmt::ArgList &args) { 1568 MemoryWriter w; 1569 w.write("[{}] ", id); 1570 w.write(format, args); 1571 return w.str(); 1572} 1573 1574FMT_VARIADIC(std::string, format_message, int, const char *) 1575 1576TEST(FormatTest, FormatMessageExample) { 1577 EXPECT_EQ("[42] something happened", 1578 format_message(42, "{} happened", "something")); 1579} 1580 1581#if FMT_USE_VARIADIC_TEMPLATES 1582template<typename... Args> 1583void print_error(const char *file, int line, const char *format, 1584 const Args & ... args) { 1585 fmt::print("{}: {}: ", file, line); 1586 fmt::print(format, args...); 1587} 1588#endif 1589 1590TEST(FormatTest, MaxArgs) { 1591 EXPECT_EQ("0123456789abcde", 1592 fmt::format("{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}", 1593 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 'a', 'b', 'c', 'd', 'e')); 1594} 1595 1596#if FMT_USE_USER_DEFINED_LITERALS 1597// Passing user-defined literals directly to EXPECT_EQ causes problems 1598// with macro argument stringification (#) on some versions of GCC. 1599// Workaround: Assing the UDL result to a variable before the macro. 1600 1601using namespace fmt::literals; 1602 1603TEST(LiteralsTest, Format) { 1604 auto udl_format = "{}c{}"_format("ab", 1); 1605 EXPECT_EQ(format("{}c{}", "ab", 1), udl_format); 1606 auto udl_format_w = L"{}c{}"_format(L"ab", 1); 1607 EXPECT_EQ(format(L"{}c{}", L"ab", 1), udl_format_w); 1608} 1609 1610TEST(LiteralsTest, NamedArg) { 1611 auto udl_a = format("{first}{second}{first}{third}", 1612 "first"_a="abra", "second"_a="cad", "third"_a=99); 1613 EXPECT_EQ(format("{first}{second}{first}{third}", 1614 fmt::arg("first", "abra"), fmt::arg("second", "cad"), 1615 fmt::arg("third", 99)), 1616 udl_a); 1617 auto udl_a_w = format(L"{first}{second}{first}{third}", 1618 L"first"_a=L"abra", L"second"_a=L"cad", L"third"_a=99); 1619 EXPECT_EQ(format(L"{first}{second}{first}{third}", 1620 fmt::arg(L"first", L"abra"), fmt::arg(L"second", L"cad"), 1621 fmt::arg(L"third", 99)), 1622 udl_a_w); 1623} 1624#endif // FMT_USE_USER_DEFINED_LITERALS 1625 1626enum TestEnum { A }; 1627 1628TEST(FormatTest, Enum) { 1629 EXPECT_EQ("0", fmt::format("{}", A)); 1630} 1631 1632class MockArgFormatter : 1633 public fmt::internal::ArgFormatterBase<MockArgFormatter, char> { 1634 public: 1635 typedef fmt::internal::ArgFormatterBase<MockArgFormatter, char> Base; 1636 1637 MockArgFormatter(fmt::BasicFormatter<char, MockArgFormatter> &f, 1638 fmt::FormatSpec &s, const char *) 1639 : fmt::internal::ArgFormatterBase<MockArgFormatter, char>(f.writer(), s) { 1640 EXPECT_CALL(*this, visit_int(42)); 1641 } 1642 1643 MOCK_METHOD1(visit_int, void (int value)); 1644}; 1645 1646void custom_format(const char *format_str, fmt::ArgList args) { 1647 fmt::MemoryWriter writer; 1648 fmt::BasicFormatter<char, MockArgFormatter> formatter(args, writer); 1649 formatter.format(format_str); 1650} 1651FMT_VARIADIC(void, custom_format, const char *) 1652 1653TEST(FormatTest, CustomArgFormatter) { 1654 custom_format("{}", 42); 1655} 1656 1657void convert(int); 1658 1659// Check if there is no collision with convert function in the global namespace. 1660TEST(FormatTest, ConvertCollision) { 1661 fmt::format("{}", 42); 1662} 1663 1664