std::basic_ostringstream<Char> os;

os << value;

std::basic_string<Char> expected = os.str();

std::basic_string<Char> actual =

(fmt::BasicMemoryWriter<Char>() << value).str();

if (expected == actual)

return ::testing::AssertionSuccess();

return ::testing::AssertionFailure()

<< "Value of: (Writer<" << type << ">() << value).str()\n"

<< " Actual: " << actual << "\n"

<< "Expected: " << expected << "\n";

template <typename T>

::testing::AssertionResult operator()(const char *, const T &value) const {

::testing::AssertionResult result = check_write<char>(value, "char");

return result ? check_write<wchar_t>(value, "wchar_t") : result;

}

template <typename T>

::testing::AssertionResult operator()(const char *, const T &value) const {

return check_write<Char>(value, "char");

}

private:

std::string value_;

public:

explicit TestString(const char *value = "") : value_(value) {}

friend std::ostream &operator<<(std::ostream &os, const TestString &s) {

os << s.value_;

return os;

}

MemoryWriter w;

EXPECT_EQ(0u, w.size());

EXPECT_STREQ("", w.c_str());

EXPECT_EQ("", w.str());

MemoryWriter w2(std::move(w));

// Move shouldn't destroy the inline content of the first writer.

EXPECT_EQ(str, w.str());

EXPECT_EQ(str, w2.str());

MemoryWriter w;

w << "test";

check_move_writer("test", w);

// This fills the inline buffer, but doesn't cause dynamic allocation.

std::string s;

for (int i = 0; i < fmt::internal::INLINE_BUFFER_SIZE; ++i)

s += '*';

w.clear();

w << s;

check_move_writer(s, w);

const char *inline_buffer_ptr = w.data();

// Adding one more character causes the content to move from the inline to

// a dynamically allocated buffer.

w << '*';

MemoryWriter w2(std::move(w));

// Move should rip the guts of the first writer.

EXPECT_EQ(inline_buffer_ptr, w.data());

EXPECT_EQ(s + '*', w2.str());

MemoryWriter w2;

w2 = std::move(w);

// Move shouldn't destroy the inline content of the first writer.

EXPECT_EQ(str, w.str());

EXPECT_EQ(str, w2.str());

MemoryWriter w;

w << "test";

CheckMoveAssignWriter("test", w);

// This fills the inline buffer, but doesn't cause dynamic allocation.

std::string s;

for (int i = 0; i < fmt::internal::INLINE_BUFFER_SIZE; ++i)

s += '*';

w.clear();

w << s;

CheckMoveAssignWriter(s, w);

const char *inline_buffer_ptr = w.data();

// Adding one more character causes the content to move from the inline to

// a dynamically allocated buffer.

w << '*';

MemoryWriter w2;

w2 = std::move(w);

// Move should rip the guts of the first writer.

EXPECT_EQ(inline_buffer_ptr, w.data());

EXPECT_EQ(s + '*', w2.str());

typedef testing::StrictMock< MockAllocator<char> > MockAllocator;

typedef AllocatorRef<MockAllocator> TestAllocator;

MockAllocator alloc;

fmt::BasicMemoryWriter<char, TestAllocator> w((TestAllocator(&alloc)));

std::size_t size =

static_cast<std::size_t>(1.5 * fmt::internal::INLINE_BUFFER_SIZE);

std::vector<char> mem(size);

EXPECT_CALL(alloc, allocate(size)).WillOnce(testing::Return(&mem[0]));

for (int i = 0; i < fmt::internal::INLINE_BUFFER_SIZE + 1; ++i)

w << '*';

EXPECT_CALL(alloc, deallocate(&mem[0], size));

MemoryWriter w;

w << 42;

EXPECT_EQ("42", std::string(w.data(), w.size()));

MemoryWriter w;

w.write("test");

EXPECT_EQ("test", std::string(w.data(), w.size()));

CHECK_WRITE(42);

CHECK_WRITE(-42);

CHECK_WRITE(static_cast<short>(12));

CHECK_WRITE(34u);

CHECK_WRITE(std::numeric_limits<int>::min());

CHECK_WRITE(std::numeric_limits<int>::max());

CHECK_WRITE(std::numeric_limits<unsigned>::max());

CHECK_WRITE(56l);

CHECK_WRITE(78ul);

CHECK_WRITE(std::numeric_limits<long>::min());

CHECK_WRITE(std::numeric_limits<long>::max());

CHECK_WRITE(std::numeric_limits<unsigned long>::max());

CHECK_WRITE(56ll);

CHECK_WRITE(78ull);

CHECK_WRITE(std::numeric_limits<long long>::min());

CHECK_WRITE(std::numeric_limits<long long>::max());

CHECK_WRITE(std::numeric_limits<unsigned long long>::max());

CHECK_WRITE(4.2);

CHECK_WRITE(-4.2);

CHECK_WRITE(std::numeric_limits<double>::min());

CHECK_WRITE(std::numeric_limits<double>::max());

CHECK_WRITE(4.2l);

CHECK_WRITE(-4.2l);

CHECK_WRITE(std::numeric_limits<long double>::min());

CHECK_WRITE(std::numeric_limits<long double>::max());

MemoryWriter writer;

for (int i = 0; i < 100; ++i)

writer << 1.23456789;

MemoryWriter writer;

// Fill the buffer.

for (int i = 0; i < fmt::internal::INLINE_BUFFER_SIZE; ++i)

writer << ' ';

writer << 1.2;

EXPECT_STREQ("1.2", writer.c_str() + fmt::internal::INLINE_BUFFER_SIZE);

CHECK_WRITE_CHAR("abc");

// The following line shouldn't compile:

//MemoryWriter() << L"abc";

CHECK_WRITE_WCHAR(L"abc");

// The following line shouldn't compile:

//fmt::WMemoryWriter() << "abc";

using fmt::bin;

EXPECT_EQ("1100101011111110", (MemoryWriter() << bin(0xcafe)).str());

EXPECT_EQ("1011101010111110", (MemoryWriter() << bin(0xbabeu)).str());

EXPECT_EQ("1101111010101101", (MemoryWriter() << bin(0xdeadl)).str());

EXPECT_EQ("1011111011101111", (MemoryWriter() << bin(0xbeeful)).str());

EXPECT_EQ("11001010111111101011101010111110",

(MemoryWriter() << bin(0xcafebabell)).str());

EXPECT_EQ("11011110101011011011111011101111",

(MemoryWriter() << bin(0xdeadbeefull)).str());

using fmt::oct;

EXPECT_EQ("12", (MemoryWriter() << oct(static_cast<short>(012))).str());

EXPECT_EQ("12", (MemoryWriter() << oct(012)).str());

EXPECT_EQ("34", (MemoryWriter() << oct(034u)).str());

EXPECT_EQ("56", (MemoryWriter() << oct(056l)).str());

EXPECT_EQ("70", (MemoryWriter() << oct(070ul)).str());

EXPECT_EQ("1234", (MemoryWriter() << oct(01234ll)).str());

EXPECT_EQ("5670", (MemoryWriter() << oct(05670ull)).str());

using fmt::hex;

fmt::IntFormatSpec<int, fmt::TypeSpec<'x'> > (*phex)(int value) = hex;

phex(42);

// This shouldn't compile:

//fmt::IntFormatSpec<short, fmt::TypeSpec<'x'> > (*phex2)(short value) = hex;

EXPECT_EQ("cafe", (MemoryWriter() << hex(0xcafe)).str());

EXPECT_EQ("babe", (MemoryWriter() << hex(0xbabeu)).str());

EXPECT_EQ("dead", (MemoryWriter() << hex(0xdeadl)).str());

EXPECT_EQ("beef", (MemoryWriter() << hex(0xbeeful)).str());

EXPECT_EQ("cafebabe", (MemoryWriter() << hex(0xcafebabell)).str());

EXPECT_EQ("deadbeef", (MemoryWriter() << hex(0xdeadbeefull)).str());

using fmt::hexu;

EXPECT_EQ("CAFE", (MemoryWriter() << hexu(0xcafe)).str());

EXPECT_EQ("BABE", (MemoryWriter() << hexu(0xbabeu)).str());

EXPECT_EQ("DEAD", (MemoryWriter() << hexu(0xdeadl)).str());

EXPECT_EQ("BEEF", (MemoryWriter() << hexu(0xbeeful)).str());

EXPECT_EQ("CAFEBABE", (MemoryWriter() << hexu(0xcafebabell)).str());

EXPECT_EQ("DEADBEEF", (MemoryWriter() << hexu(0xdeadbeefull)).str());

int year_, month_, day_;

public:

Date(int year, int month, int day) : year_(year), month_(month), day_(day) {}

int year() const { return year_; }

int month() const { return month_; }

int day() const { return day_; }

friend std::ostream &operator<<(std::ostream &os, const Date &d) {

os << d.year_ << '-' << d.month_ << '-' << d.day_;

return os;

}

friend std::wostream &operator<<(std::wostream &os, const Date &d) {

os << d.year_ << L'-' << d.month_ << L'-' << d.day_;

return os;

}

template <typename Char>

friend BasicWriter<Char> &operator<<(BasicWriter<Char> &f, const Date &d) {

return f << d.year_ << '-' << d.month_ << '-' << d.day_;

}

const Date *date_;

ISO8601DateFormatter(const Date &d) : date_(&d) {}

template <typename Char>

friend BasicWriter<Char> &operator<<(

BasicWriter<Char> &w, const ISO8601DateFormatter &d) {

return w << pad(d.date_->year(), 4, '0') << '-'

<< pad(d.date_->month(), 2, '0') << '-' << pad(d.date_->day(), 2, '0');

}

using fmt::hex;

EXPECT_EQ(" cafe", (MemoryWriter() << pad(hex(0xcafe), 8)).str());

EXPECT_EQ(" babe", (MemoryWriter() << pad(hex(0xbabeu), 8)).str());

EXPECT_EQ(" dead", (MemoryWriter() << pad(hex(0xdeadl), 8)).str());

EXPECT_EQ(" beef", (MemoryWriter() << pad(hex(0xbeeful), 8)).str());

EXPECT_EQ(" dead", (MemoryWriter() << pad(hex(0xdeadll), 8)).str());

EXPECT_EQ(" beef", (MemoryWriter() << pad(hex(0xbeefull), 8)).str());

EXPECT_EQ(" 11", (MemoryWriter() << pad(11, 7)).str());

EXPECT_EQ(" 22", (MemoryWriter() << pad(22u, 7)).str());

EXPECT_EQ(" 33", (MemoryWriter() << pad(33l, 7)).str());

EXPECT_EQ(" 44", (MemoryWriter() << pad(44ul, 7)).str());

EXPECT_EQ(" 33", (MemoryWriter() << pad(33ll, 7)).str());

EXPECT_EQ(" 44", (MemoryWriter() << pad(44ull, 7)).str());

MemoryWriter w;

w.clear();

w << pad(42, 5, '0');

EXPECT_EQ("00042", w.str());

w.clear();

w << Date(2012, 12, 9);

EXPECT_EQ("2012-12-9", w.str());

w.clear();

w << iso8601(Date(2012, 1, 9));

EXPECT_EQ("2012-01-09", w.str());

EXPECT_EQ(L"test ", (WMemoryWriter() << pad(L"test", 8)).str());

EXPECT_EQ(L"test******", (WMemoryWriter() << pad(L"test", 10, '*')).str());

EXPECT_EQ(L"test******", (WMemoryWriter() << pad(L"test", 10, L'*')).str());

using namespace std;

using namespace fmt;

EXPECT_EQ("cafe", (MemoryWriter() << hex(0xcafe)).str());

EXPECT_EQ("12", (MemoryWriter() << oct(012)).str());

MemoryWriter w;

w.write("part{0}", 1);

EXPECT_EQ(strlen("part1"), w.size());

EXPECT_STREQ("part1", w.c_str());

EXPECT_STREQ("part1", w.data());

EXPECT_EQ("part1", w.str());

w.write("part{0}", 2);

EXPECT_EQ(strlen("part1part2"), w.size());

EXPECT_STREQ("part1part2", w.c_str());

EXPECT_STREQ("part1part2", w.data());

EXPECT_EQ("part1part2", w.str());

EXPECT_EQ("{", format("{{"));

EXPECT_EQ("before {", format("before {{"));

EXPECT_EQ("{ after", format("{{ after"));

EXPECT_EQ("before { after", format("before {{ after"));

EXPECT_EQ("}", format("}}"));

EXPECT_EQ("before }", format("before }}"));

EXPECT_EQ("} after", format("}} after"));

EXPECT_EQ("before } after", format("before }} after"));

EXPECT_EQ("{}", format("{{}}"));

EXPECT_EQ("{42}", format("{{{0}}}", 42));

EXPECT_THROW_MSG(format("{"), FormatError, "invalid format string");

EXPECT_THROW_MSG(format("}"), FormatError, "unmatched '}' in format string");

EXPECT_THROW_MSG(format("{0{}"), FormatError, "invalid format string");

EXPECT_EQ("42", format("{0}", 42));

EXPECT_EQ("before 42", format("before {0}", 42));

EXPECT_EQ("42 after", format("{0} after", 42));

EXPECT_EQ("before 42 after", format("before {0} after", 42));

EXPECT_EQ("answer = 42", format("{0} = {1}", "answer", 42));

EXPECT_EQ("42 is the answer", format("{1} is the {0}", "answer", 42));

EXPECT_EQ("abracadabra", format("{0}{1}{0}", "abra", "cad"));

EXPECT_THROW_MSG(format("{"), FormatError, "invalid format string");

EXPECT_THROW_MSG(format("{x}"), FormatError, "invalid format string");

EXPECT_THROW_MSG(format("{0"), FormatError, "invalid format string");

EXPECT_THROW_MSG(format("{0}"), FormatError, "argument index out of range");

char format_str[BUFFER_SIZE];

safe_sprintf(format_str, "{%u", INT_MAX);

EXPECT_THROW_MSG(format(format_str), FormatError, "invalid format string");

safe_sprintf(format_str, "{%u}", INT_MAX);

EXPECT_THROW_MSG(format(format_str), FormatError,

"argument index out of range");

safe_sprintf(format_str, "{%u", INT_MAX + 1u);

EXPECT_THROW_MSG(format(format_str), FormatError, "number is too big");

safe_sprintf(format_str, "{%u}", INT_MAX + 1u);

EXPECT_THROW_MSG(format(format_str), FormatError, "number is too big");

EXPECT_EQ("abc", format("{}{}{}", 'a', 'b', 'c'));

EXPECT_THROW_MSG(format("{0}{}", 'a', 'b'),

FormatError, "cannot switch from manual to automatic argument indexing");

EXPECT_THROW_MSG(format("{}{0}", 'a', 'b'),

FormatError, "cannot switch from automatic to manual argument indexing");

EXPECT_EQ("1.2", format("{:.{}}", 1.2345, 2));

EXPECT_THROW_MSG(format("{0}:.{}", 1.2345, 2),

FormatError, "cannot switch from manual to automatic argument indexing");

EXPECT_THROW_MSG(format("{:.{0}}", 1.2345, 2),

FormatError, "cannot switch from automatic to manual argument indexing");

EXPECT_THROW_MSG(format("{}"), FormatError, "argument index out of range");

EXPECT_EQ("42 ", format("{0:<4}", 42));

EXPECT_EQ("42 ", format("{0:<4o}", 042));

EXPECT_EQ("42 ", format("{0:<4x}", 0x42));

EXPECT_EQ("-42 ", format("{0:<5}", -42));

EXPECT_EQ("42 ", format("{0:<5}", 42u));

EXPECT_EQ("-42 ", format("{0:<5}", -42l));

EXPECT_EQ("42 ", format("{0:<5}", 42ul));

EXPECT_EQ("-42 ", format("{0:<5}", -42ll));

EXPECT_EQ("42 ", format("{0:<5}", 42ull));

EXPECT_EQ("-42 ", format("{0:<5}", -42.0));

EXPECT_EQ("-42 ", format("{0:<5}", -42.0l));

EXPECT_EQ("c ", format("{0:<5}", 'c'));

EXPECT_EQ("abc ", format("{0:<5}", "abc"));

EXPECT_EQ("0xface ", format("{0:<8}", reinterpret_cast<void*>(0xface)));

EXPECT_EQ("def ", format("{0:<5}", TestString("def")));

EXPECT_EQ(" 42", format("{0:>4}", 42));

EXPECT_EQ(" 42", format("{0:>4o}", 042));

EXPECT_EQ(" 42", format("{0:>4x}", 0x42));

EXPECT_EQ(" -42", format("{0:>5}", -42));

EXPECT_EQ(" 42", format("{0:>5}", 42u));

EXPECT_EQ(" -42", format("{0:>5}", -42l));

EXPECT_EQ(" 42", format("{0:>5}", 42ul));

EXPECT_EQ(" -42", format("{0:>5}", -42ll));

EXPECT_EQ(" 42", format("{0:>5}", 42ull));

EXPECT_EQ(" -42", format("{0:>5}", -42.0));

EXPECT_EQ(" -42", format("{0:>5}", -42.0l));

EXPECT_EQ(" c", format("{0:>5}", 'c'));

EXPECT_EQ(" abc", format("{0:>5}", "abc"));

EXPECT_EQ(" 0xface", format("{0:>8}", reinterpret_cast<void*>(0xface)));

EXPECT_EQ(" def", format("{0:>5}", TestString("def")));

EXPECT_EQ(" 42", format("{0:=4}", 42));

EXPECT_EQ("+ 42", format("{0:=+4}", 42));

EXPECT_EQ(" 42", format("{0:=4o}", 042));

EXPECT_EQ("+ 42", format("{0:=+4o}", 042));

EXPECT_EQ(" 42", format("{0:=4x}", 0x42));

EXPECT_EQ("+ 42", format("{0:=+4x}", 0x42));

EXPECT_EQ("- 42", format("{0:=5}", -42));

EXPECT_EQ(" 42", format("{0:=5}", 42u));

EXPECT_EQ("- 42", format("{0:=5}", -42l));

EXPECT_EQ(" 42", format("{0:=5}", 42ul));

EXPECT_EQ("- 42", format("{0:=5}", -42ll));

EXPECT_EQ(" 42", format("{0:=5}", 42ull));

EXPECT_EQ("- 42", format("{0:=5}", -42.0));

EXPECT_EQ("- 42", format("{0:=5}", -42.0l));

EXPECT_THROW_MSG(format("{0:=5", 'c'),

FormatError, "missing '}' in format string");

EXPECT_THROW_MSG(format("{0:=5}", 'c'),

FormatError, "invalid format specifier for char");

EXPECT_THROW_MSG(format("{0:=5}", "abc"),

FormatError, "format specifier '=' requires numeric argument");

EXPECT_THROW_MSG(format("{0:=8}", reinterpret_cast<void*>(0xface)),

FormatError, "format specifier '=' requires numeric argument");

EXPECT_THROW_MSG(format("{0:=5}", TestString("def")),

FormatError, "format specifier '=' requires numeric argument");

EXPECT_EQ(" 42 ", format("{0:^5}", 42));

EXPECT_EQ(" 42 ", format("{0:^5o}", 042));

EXPECT_EQ(" 42 ", format("{0:^5x}", 0x42));

EXPECT_EQ(" -42 ", format("{0:^5}", -42));

EXPECT_EQ(" 42 ", format("{0:^5}", 42u));

EXPECT_EQ(" -42 ", format("{0:^5}", -42l));

EXPECT_EQ(" 42 ", format("{0:^5}", 42ul));

EXPECT_EQ(" -42 ", format("{0:^5}", -42ll));

EXPECT_EQ(" 42 ", format("{0:^5}", 42ull));

EXPECT_EQ(" -42 ", format("{0:^6}", -42.0));

EXPECT_EQ(" -42 ", format("{0:^5}", -42.0l));

EXPECT_EQ(" c ", format("{0:^5}", 'c'));

EXPECT_EQ(" abc ", format("{0:^6}", "abc"));

EXPECT_EQ(" 0xface ", format("{0:^8}", reinterpret_cast<void*>(0xface)));

EXPECT_EQ(" def ", format("{0:^5}", TestString("def")));

EXPECT_THROW_MSG(format("{0:{<5}", 'c'),

FormatError, "invalid fill character '{'");

EXPECT_THROW_MSG(format("{0:{<5}}", 'c'),

FormatError, "invalid fill character '{'");

EXPECT_EQ("**42", format("{0:*>4}", 42));

EXPECT_EQ("**-42", format("{0:*>5}", -42));

EXPECT_EQ("***42", format("{0:*>5}", 42u));

EXPECT_EQ("**-42", format("{0:*>5}", -42l));

EXPECT_EQ("***42", format("{0:*>5}", 42ul));

EXPECT_EQ("**-42", format("{0:*>5}", -42ll));

EXPECT_EQ("***42", format("{0:*>5}", 42ull));

EXPECT_EQ("**-42", format("{0:*>5}", -42.0));

EXPECT_EQ("**-42", format("{0:*>5}", -42.0l));

EXPECT_EQ("c****", format("{0:*<5}", 'c'));

EXPECT_EQ("abc**", format("{0:*<5}", "abc"));

EXPECT_EQ("**0xface", format("{0:*>8}", reinterpret_cast<void*>(0xface)));

EXPECT_EQ("def**", format("{0:*<5}", TestString("def")));

EXPECT_EQ("+42", format("{0:+}", 42));

EXPECT_EQ("-42", format("{0:+}", -42));

EXPECT_EQ("+42", format("{0:+}", 42));

EXPECT_THROW_MSG(format("{0:+}", 42u),

FormatError, "format specifier '+' requires signed argument");

EXPECT_EQ("+42", format("{0:+}", 42l));

EXPECT_THROW_MSG(format("{0:+}", 42ul),

FormatError, "format specifier '+' requires signed argument");

EXPECT_EQ("+42", format("{0:+}", 42ll));

EXPECT_THROW_MSG(format("{0:+}", 42ull),

FormatError, "format specifier '+' requires signed argument");

EXPECT_EQ("+42", format("{0:+}", 42.0));

EXPECT_EQ("+42", format("{0:+}", 42.0l));

EXPECT_THROW_MSG(format("{0:+", 'c'),

FormatError, "missing '}' in format string");

EXPECT_THROW_MSG(format("{0:+}", 'c'),

FormatError, "invalid format specifier for char");

EXPECT_THROW_MSG(format("{0:+}", "abc"),

FormatError, "format specifier '+' requires numeric argument");

EXPECT_THROW_MSG(format("{0:+}", reinterpret_cast<void*>(0x42)),

FormatError, "format specifier '+' requires numeric argument");

EXPECT_THROW_MSG(format("{0:+}", TestString()),

FormatError, "format specifier '+' requires numeric argument");

EXPECT_EQ("42", format("{0:-}", 42));

EXPECT_EQ("-42", format("{0:-}", -42));

EXPECT_EQ("42", format("{0:-}", 42));

EXPECT_THROW_MSG(format("{0:-}", 42u),

FormatError, "format specifier '-' requires signed argument");

EXPECT_EQ("42", format("{0:-}", 42l));

EXPECT_THROW_MSG(format("{0:-}", 42ul),

FormatError, "format specifier '-' requires signed argument");

EXPECT_EQ("42", format("{0:-}", 42ll));

EXPECT_THROW_MSG(format("{0:-}", 42ull),

FormatError, "format specifier '-' requires signed argument");

EXPECT_EQ("42", format("{0:-}", 42.0));

EXPECT_EQ("42", format("{0:-}", 42.0l));

EXPECT_THROW_MSG(format("{0:-", 'c'),

FormatError, "missing '}' in format string");

EXPECT_THROW_MSG(format("{0:-}", 'c'),

FormatError, "invalid format specifier for char");

EXPECT_THROW_MSG(format("{0:-}", "abc"),

FormatError, "format specifier '-' requires numeric argument");

EXPECT_THROW_MSG(format("{0:-}", reinterpret_cast<void*>(0x42)),

FormatError, "format specifier '-' requires numeric argument");

EXPECT_THROW_MSG(format("{0:-}", TestString()),

FormatError, "format specifier '-' requires numeric argument");

EXPECT_EQ(" 42", format("{0: }", 42));

EXPECT_EQ("-42", format("{0: }", -42));

EXPECT_EQ(" 42", format("{0: }", 42));

EXPECT_THROW_MSG(format("{0: }", 42u),

FormatError, "format specifier ' ' requires signed argument");

EXPECT_EQ(" 42", format("{0: }", 42l));

EXPECT_THROW_MSG(format("{0: }", 42ul),

FormatError, "format specifier ' ' requires signed argument");

EXPECT_EQ(" 42", format("{0: }", 42ll));

EXPECT_THROW_MSG(format("{0: }", 42ull),

FormatError, "format specifier ' ' requires signed argument");

EXPECT_EQ(" 42", format("{0: }", 42.0));

EXPECT_EQ(" 42", format("{0: }", 42.0l));

EXPECT_THROW_MSG(format("{0: ", 'c'),

FormatError, "missing '}' in format string");

EXPECT_THROW_MSG(format("{0: }", 'c'),

FormatError, "invalid format specifier for char");

EXPECT_THROW_MSG(format("{0: }", "abc"),

FormatError, "format specifier ' ' requires numeric argument");

EXPECT_THROW_MSG(format("{0: }", reinterpret_cast<void*>(0x42)),

FormatError, "format specifier ' ' requires numeric argument");

EXPECT_THROW_MSG(format("{0: }", TestString()),

FormatError, "format specifier ' ' requires numeric argument");

EXPECT_EQ("42", format("{0:#}", 42));

EXPECT_EQ("-42", format("{0:#}", -42));

EXPECT_EQ("0b101010", format("{0:#b}", 42));

EXPECT_EQ("0B101010", format("{0:#B}", 42));

EXPECT_EQ("-0b101010", format("{0:#b}", -42));

EXPECT_EQ("0x42", format("{0:#x}", 0x42));

EXPECT_EQ("0X42", format("{0:#X}", 0x42));

EXPECT_EQ("-0x42", format("{0:#x}", -0x42));

EXPECT_EQ("042", format("{0:#o}", 042));

EXPECT_EQ("-042", format("{0:#o}", -042));

EXPECT_EQ("42", format("{0:#}", 42u));

EXPECT_EQ("0x42", format("{0:#x}", 0x42u));

EXPECT_EQ("042", format("{0:#o}", 042u));

EXPECT_EQ("-42", format("{0:#}", -42l));

EXPECT_EQ("0x42", format("{0:#x}", 0x42l));

EXPECT_EQ("-0x42", format("{0:#x}", -0x42l));

EXPECT_EQ("042", format("{0:#o}", 042l));

EXPECT_EQ("-042", format("{0:#o}", -042l));

EXPECT_EQ("42", format("{0:#}", 42ul));

EXPECT_EQ("0x42", format("{0:#x}", 0x42ul));

EXPECT_EQ("042", format("{0:#o}", 042ul));

EXPECT_EQ("-42", format("{0:#}", -42ll));

EXPECT_EQ("0x42", format("{0:#x}", 0x42ll));

EXPECT_EQ("-0x42", format("{0:#x}", -0x42ll));

EXPECT_EQ("042", format("{0:#o}", 042ll));

EXPECT_EQ("-042", format("{0:#o}", -042ll));

EXPECT_EQ("42", format("{0:#}", 42ull));

EXPECT_EQ("0x42", format("{0:#x}", 0x42ull));

EXPECT_EQ("042", format("{0:#o}", 042ull));

EXPECT_EQ("-42.0000", format("{0:#}", -42.0));

EXPECT_EQ("-42.0000", format("{0:#}", -42.0l));

EXPECT_THROW_MSG(format("{0:#", 'c'),

FormatError, "missing '}' in format string");

EXPECT_THROW_MSG(format("{0:#}", 'c'),

FormatError, "invalid format specifier for char");

EXPECT_THROW_MSG(format("{0:#}", "abc"),

FormatError, "format specifier '#' requires numeric argument");

EXPECT_THROW_MSG(format("{0:#}", reinterpret_cast<void*>(0x42)),

FormatError, "format specifier '#' requires numeric argument");

EXPECT_THROW_MSG(format("{0:#}", TestString()),

FormatError, "format specifier '#' requires numeric argument");

EXPECT_EQ("42", format("{0:0}", 42));

EXPECT_EQ("-0042", format("{0:05}", -42));

EXPECT_EQ("00042", format("{0:05}", 42u));

EXPECT_EQ("-0042", format("{0:05}", -42l));

EXPECT_EQ("00042", format("{0:05}", 42ul));

EXPECT_EQ("-0042", format("{0:05}", -42ll));

EXPECT_EQ("00042", format("{0:05}", 42ull));

EXPECT_EQ("-0042", format("{0:05}", -42.0));

EXPECT_EQ("-0042", format("{0:05}", -42.0l));

EXPECT_THROW_MSG(format("{0:0", 'c'),

FormatError, "missing '}' in format string");

EXPECT_THROW_MSG(format("{0:05}", 'c'),

FormatError, "invalid format specifier for char");

EXPECT_THROW_MSG(format("{0:05}", "abc"),

FormatError, "format specifier '0' requires numeric argument");

EXPECT_THROW_MSG(format("{0:05}", reinterpret_cast<void*>(0x42)),

FormatError, "format specifier '0' requires numeric argument");

EXPECT_THROW_MSG(format("{0:05}", TestString()),

FormatError, "format specifier '0' requires numeric argument");

char format_str[BUFFER_SIZE];

safe_sprintf(format_str, "{0:%u", UINT_MAX);

increment(format_str + 3);

EXPECT_THROW_MSG(format(format_str, 0), FormatError, "number is too big");

std::size_t size = std::strlen(format_str);

format_str[size] = '}';

format_str[size + 1] = 0;

EXPECT_THROW_MSG(format(format_str, 0), FormatError, "number is too big");

safe_sprintf(format_str, "{0:%u", INT_MAX + 1u);

EXPECT_THROW_MSG(format(format_str, 0), FormatError, "number is too big");

safe_sprintf(format_str, "{0:%u}", INT_MAX + 1u);

EXPECT_THROW_MSG(format(format_str, 0), FormatError, "number is too big");

EXPECT_EQ(" -42", format("{0:4}", -42));

EXPECT_EQ(" 42", format("{0:5}", 42u));

EXPECT_EQ(" -42", format("{0:6}", -42l));

EXPECT_EQ(" 42", format("{0:7}", 42ul));

EXPECT_EQ(" -42", format("{0:6}", -42ll));

EXPECT_EQ(" 42", format("{0:7}", 42ull));

EXPECT_EQ(" -1.23", format("{0:8}", -1.23));

EXPECT_EQ(" -1.23", format("{0:9}", -1.23l));

EXPECT_EQ(" 0xcafe", format("{0:10}", reinterpret_cast<void*>(0xcafe)));

EXPECT_EQ("x ", format("{0:11}", 'x'));

EXPECT_EQ("str ", format("{0:12}", "str"));

EXPECT_EQ("test ", format("{0:13}", TestString("test")));

char format_str[BUFFER_SIZE];

safe_sprintf(format_str, "{0:.%u", UINT_MAX);

increment(format_str + 4);

EXPECT_THROW_MSG(format(format_str, 0), FormatError, "number is too big");

std::size_t size = std::strlen(format_str);

format_str[size] = '}';

format_str[size + 1] = 0;

EXPECT_THROW_MSG(format(format_str, 0), FormatError, "number is too big");

safe_sprintf(format_str, "{0:.%u", INT_MAX + 1u);

EXPECT_THROW_MSG(format(format_str, 0), FormatError, "number is too big");

safe_sprintf(format_str, "{0:.%u}", INT_MAX + 1u);

EXPECT_THROW_MSG(format(format_str, 0), FormatError, "number is too big");

EXPECT_THROW_MSG(format("{0:.", 0),

FormatError, "missing precision specifier");

EXPECT_THROW_MSG(format("{0:.}", 0),

FormatError, "missing precision specifier");

EXPECT_THROW_MSG(format("{0:.2", 0),

FormatError, "precision not allowed in integer format specifier");

EXPECT_THROW_MSG(format("{0:.2}", 42),

FormatError, "precision not allowed in integer format specifier");

EXPECT_THROW_MSG(format("{0:.2f}", 42),

FormatError, "precision not allowed in integer format specifier");

EXPECT_THROW_MSG(format("{0:.2}", 42u),

FormatError, "precision not allowed in integer format specifier");

EXPECT_THROW_MSG(format("{0:.2f}", 42u),

FormatError, "precision not allowed in integer format specifier");

EXPECT_THROW_MSG(format("{0:.2}", 42l),

FormatError, "precision not allowed in integer format specifier");

EXPECT_THROW_MSG(format("{0:.2f}", 42l),

FormatError, "precision not allowed in integer format specifier");

EXPECT_THROW_MSG(format("{0:.2}", 42ul),

FormatError, "precision not allowed in integer format specifier");

EXPECT_THROW_MSG(format("{0:.2f}", 42ul),

FormatError, "precision not allowed in integer format specifier");

EXPECT_THROW_MSG(format("{0:.2}", 42ll),

FormatError, "precision not allowed in integer format specifier");

EXPECT_THROW_MSG(format("{0:.2f}", 42ll),

FormatError, "precision not allowed in integer format specifier");

EXPECT_THROW_MSG(format("{0:.2}", 42ull),

FormatError, "precision not allowed in integer format specifier");

EXPECT_THROW_MSG(format("{0:.2f}", 42ull),

FormatError, "precision not allowed in integer format specifier");

EXPECT_EQ("1.2", format("{0:.2}", 1.2345));

EXPECT_EQ("1.2", format("{0:.2}", 1.2345l));

EXPECT_THROW_MSG(format("{0:.2}", reinterpret_cast<void*>(0xcafe)),

FormatError, "precision not allowed in pointer format specifier");

EXPECT_THROW_MSG(format("{0:.2f}", reinterpret_cast<void*>(0xcafe)),

FormatError, "precision not allowed in pointer format specifier");

EXPECT_EQ(" ", format("{0:3.0}", 'x'));

EXPECT_EQ("st", format("{0:.2}", "str"));

EXPECT_EQ("te", format("{0:.2}", TestString("test")));

char format_str[BUFFER_SIZE];

safe_sprintf(format_str, "{0:.{%u", UINT_MAX);

increment(format_str + 5);

EXPECT_THROW_MSG(format(format_str, 0), FormatError, "number is too big");

std::size_t size = std::strlen(format_str);

format_str[size] = '}';

format_str[size + 1] = 0;

EXPECT_THROW_MSG(format(format_str, 0), FormatError, "number is too big");

format_str[size + 1] = '}';

format_str[size + 2] = 0;

EXPECT_THROW_MSG(format(format_str, 0), FormatError, "number is too big");

EXPECT_THROW_MSG(format("{0:.{", 0),

FormatError, "invalid format string");

EXPECT_THROW_MSG(format("{0:.{}", 0),

FormatError, "cannot switch from manual to automatic argument indexing");

EXPECT_THROW_MSG(format("{0:.{x}}", 0),

FormatError, "invalid format string");

EXPECT_THROW_MSG(format("{0:.{1}", 0, 0),

FormatError, "precision not allowed in integer format specifier");

EXPECT_THROW_MSG(format("{0:.{1}}", 0),

FormatError, "argument index out of range");

EXPECT_THROW_MSG(format("{0:.{0:}}", 0),

FormatError, "invalid format string");

EXPECT_THROW_MSG(format("{0:.{1}}", 0, -1),

FormatError, "negative precision");

EXPECT_THROW_MSG(format("{0:.{1}}", 0, (INT_MAX + 1u)),

FormatError, "number is too big");

EXPECT_THROW_MSG(format("{0:.{1}}", 0, -1l),

FormatError, "negative precision");

if (sizeof(long) > sizeof(int)) {

long value = INT_MAX;

EXPECT_THROW_MSG(format("{0:.{1}}", 0, (value + 1)),

FormatError, "number is too big");

}

EXPECT_THROW_MSG(format("{0:.{1}}", 0, (INT_MAX + 1ul)),

FormatError, "number is too big");

EXPECT_THROW_MSG(format("{0:.{1}}", 0, '0'),