auto n = uint128();

EXPECT_EQ(n, 0);

n = uint128(42);

EXPECT_EQ(n, 42);

EXPECT_EQ(static_cast<uint64_t>(n), 42);

auto n = uint128(42);

n = n << 64;

EXPECT_EQ(static_cast<uint64_t>(n), 0);

n = n >> 64;

EXPECT_EQ(static_cast<uint64_t>(n), 42);

n = n << 62;

EXPECT_EQ(static_cast<uint64_t>(n >> 64), 0xa);

EXPECT_EQ(static_cast<uint64_t>(n), 0x8000000000000000);

n = n >> 62;

EXPECT_EQ(static_cast<uint64_t>(n), 42);

EXPECT_EQ(uint128(1) << 112, uint128(0x1000000000000, 0));

EXPECT_EQ(uint128(0x1000000000000, 0) >> 112, uint128(1));

auto n = uint128(32);

n += uint128(10);

EXPECT_EQ(n, 42);

n = uint128(max_value<uint64_t>());

n += uint128(1);

EXPECT_EQ(n, uint128(1) << 64);

auto n = uint128(2251799813685247);

n = n * 3611864890;

EXPECT_EQ(static_cast<uint64_t>(n >> 64), 440901);

using fmt::detail::isfinite;

EXPECT_TRUE(isfinite(Float(0.0)));

EXPECT_TRUE(isfinite(Float(42.0)));

EXPECT_TRUE(isfinite(Float(-42.0)));

EXPECT_TRUE(isfinite(Float(fmt::detail::max_value<double>())));

// Use double because std::numeric_limits is broken for __float128.

using limits = std::numeric_limits<double>;

FMT_CONSTEXPR20 auto result = isfinite(Float(limits::infinity()));

EXPECT_FALSE(result);

EXPECT_FALSE(isfinite(Float(limits::infinity())));

EXPECT_FALSE(isfinite(Float(-limits::infinity())));

EXPECT_FALSE(isfinite(Float(limits::quiet_NaN())));

EXPECT_FALSE(isfinite(Float(-limits::quiet_NaN())));

check_isfinite<double>();

#if FMT_USE_FLOAT128

check_isfinite<fmt::detail::float128>();

#endif

fexcept_t fe;

fegetexceptflag(&fe, FE_ALL_EXCEPT);

// No exception flags should have been set

EXPECT_TRUE(fe == 0);

using fmt::detail::isnan;

EXPECT_FALSE(isnan(Float(0.0)));

EXPECT_FALSE(isnan(Float(42.0)));

EXPECT_FALSE(isnan(Float(-42.0)));

EXPECT_FALSE(isnan(Float(fmt::detail::max_value<double>())));

// Use double because std::numeric_limits is broken for __float128.

using limits = std::numeric_limits<double>;

EXPECT_FALSE(isnan(Float(limits::infinity())));

EXPECT_FALSE(isnan(Float(-limits::infinity())));

EXPECT_TRUE(isnan(Float(limits::quiet_NaN())));

EXPECT_TRUE(isnan(Float(-limits::quiet_NaN())));

// Sanity check: make sure no error has occurred before we start

check_no_fp_exception();

// Check that no exception is raised for the non-NaN case

isnan(Float(42.0));

check_no_fp_exception();

// Check that no exception is raised for the NaN case

isnan(Float(limits::quiet_NaN()));

check_no_fp_exception();

check_isnan<double>();

#if FMT_USE_FLOAT128

check_isnan<fmt::detail::float128>();

#endif

auto s = fmt::detail::bit_cast<uint32_pair>(uint64_t{42});

EXPECT_EQ(fmt::detail::bit_cast<uint64_t>(s), 42ull);

s = fmt::detail::bit_cast<uint32_pair>(~uint64_t{0});

EXPECT_EQ(fmt::detail::bit_cast<uint64_t>(s), ~0ull);

for (int i = static_cast<int>(std::strlen(s)) - 1; i >= 0; --i) {

if (s[i] != '9') {

++s[i];

break;

}

s[i] = '0';

}

char s[10] = "123";

increment(s);

EXPECT_STREQ("124", s);

s[2] = '8';

increment(s);

EXPECT_STREQ("129", s);

increment(s);

EXPECT_STREQ("130", s);

s[1] = s[2] = '9';

increment(s);

EXPECT_STREQ("200", s);

minimal_container c;

static constexpr char str[] = "a";

fmt::detail::copy<char>(str, str + 1, std::back_inserter(c));

auto s = fmt::string_view("10000000000");

auto begin = s.begin(), end = s.end();

EXPECT_EQ(fmt::detail::parse_nonnegative_int(begin, end, -1), -1);

s = "2147483649";

begin = s.begin();

end = s.end();

EXPECT_EQ(fmt::detail::parse_nonnegative_int(begin, end, -1), -1);

auto u = fmt::detail::utf8_to_utf16("лошадка");

EXPECT_EQ(L"\x043B\x043E\x0448\x0430\x0434\x043A\x0430", u.str());

EXPECT_EQ(7, u.size());

// U+10437 { DESERET SMALL LETTER YEE }

EXPECT_EQ(L"\xD801\xDC37", fmt::detail::utf8_to_utf16("𐐷").str());

EXPECT_THROW_MSG(fmt::detail::utf8_to_utf16("\xc3\x28"), std::runtime_error,

"invalid utf8");

EXPECT_THROW_MSG(fmt::detail::utf8_to_utf16(fmt::string_view("л", 1)),

std::runtime_error, "invalid utf8");

EXPECT_EQ(L"123456", fmt::detail::utf8_to_utf16("123456").str());

auto s = std::string();

auto u = fmt::detail::utf8_to_utf16(s.c_str());

EXPECT_EQ(L"", u.str());

EXPECT_EQ(s.size(), u.size());

using test_allocator_ref = allocator_ref<mock_allocator<int>>;

auto check_forwarding = [](mock_allocator<int>& alloc,

test_allocator_ref& ref) {

int mem;

// Check if value_type is properly defined.

allocator_ref<mock_allocator<int>>::value_type* ptr = &mem;

// Check forwarding.

EXPECT_CALL(alloc, allocate(42)).WillOnce(Return(ptr));

ref.allocate(42);

EXPECT_CALL(alloc, deallocate(ptr, 42));

ref.deallocate(ptr, 42);

};

StrictMock<mock_allocator<int>> alloc;

auto ref = test_allocator_ref(&alloc);

// Check if allocator_ref forwards to the underlying allocator.

check_forwarding(alloc, ref);

test_allocator_ref ref2(ref);

check_forwarding(alloc, ref2);

test_allocator_ref ref3;

EXPECT_EQ(nullptr, ref3.get());

ref3 = ref;

check_forwarding(alloc, ref3);

fmt::memory_buffer message;

fmt::format_system_error(message, EDOM, "test");

auto ec = std::error_code(EDOM, std::generic_category());

EXPECT_EQ(to_string(message), std::system_error(ec, "test").what());

auto test_error = fmt::system_error(EDOM, "test");

auto ec = std::error_code(EDOM, std::generic_category());

EXPECT_STREQ(test_error.what(), std::system_error(ec, "test").what());

EXPECT_EQ(test_error.code(), ec);

auto error = std::system_error(std::error_code());

try {

throw fmt::system_error(EDOM, "test {}", "error");

} catch (const std::system_error& e) {

error = e;

}

fmt::memory_buffer message;

fmt::format_system_error(message, EDOM, "test error");

EXPECT_EQ(error.what(), to_string(message));

EXPECT_EQ(error.code(), std::error_code(EDOM, std::generic_category()));

fmt::memory_buffer out;

fmt::format_system_error(out, EDOM, "test error");

out.push_back('\n');

EXPECT_WRITE(stderr, fmt::report_system_error(EDOM, "test error"),

to_string(out));

basic_memory_buffer<char, 123> buffer;

EXPECT_EQ(static_cast<size_t>(0), buffer.size());

EXPECT_EQ(123u, buffer.capacity());

auto check_move_buffer =

[](const char* str, basic_memory_buffer<char, 5, std_allocator>& buffer) {

std::allocator<char>* alloc = buffer.get_allocator().get();

basic_memory_buffer<char, 5, std_allocator> buffer2(std::move(buffer));

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

EXPECT_EQ(std::string(buffer.data(), buffer.size()), str);

EXPECT_EQ(std::string(&buffer2[0], buffer2.size()), str);

EXPECT_EQ(buffer2.capacity(), 5u);

// Move should transfer allocator.

EXPECT_EQ(buffer.get_allocator().get(), nullptr);

EXPECT_EQ(buffer2.get_allocator().get(), alloc);

};

auto alloc = std::allocator<char>();

basic_memory_buffer<char, 5, std_allocator> buffer((std_allocator(&alloc)));

buffer.append(string_view("test"));

check_move_buffer("test", buffer);

// Adding one more character fills the inline buffer, but doesn't cause

// dynamic allocation.

buffer.push_back('a');

check_move_buffer("testa", buffer);

auto alloc = std::allocator<char>();

basic_memory_buffer<char, 4, std_allocator> buffer((std_allocator(&alloc)));

const char test[] = "test";

buffer.append(test, test + 4);

const char* inline_buffer_ptr = &buffer[0];

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

// a dynamically allocated buffer.

buffer.push_back('a');

basic_memory_buffer<char, 4, std_allocator> buffer2(std::move(buffer));

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

EXPECT_EQ(&buffer[0], inline_buffer_ptr);

EXPECT_EQ(buffer.size(), 0);

EXPECT_EQ(std::string(&buffer2[0], buffer2.size()), "testa");

EXPECT_GT(buffer2.capacity(), 4u);

auto check_move_buffer =

[](const char* str,

basic_memory_buffer<char, 5, std_allocator_noprop>& buffer) {

std::allocator<char>* original_alloc_ptr = buffer.get_allocator().get();

const char* original_data_ptr = &buffer[0];

basic_memory_buffer<char, 5, std_allocator_noprop> buffer2(

std::move(buffer));

const char* new_data_ptr = &buffer2[0];

EXPECT_NE(new_data_ptr, original_data_ptr);

EXPECT_EQ(std::string(buffer.data(), buffer.size()), str);

EXPECT_EQ(std::string(buffer2.data(), buffer2.size()), str);

EXPECT_EQ(buffer2.capacity(), 5u);

// Allocators should NOT be transferred; they remain distinct instances.

// The original buffer's allocator pointer should still be valid (not

// nullptr).

EXPECT_EQ(buffer.get_allocator().get(), original_alloc_ptr);

EXPECT_NE(buffer2.get_allocator().get(), original_alloc_ptr);

};

auto alloc = std::allocator<char>();

basic_memory_buffer<char, 5, std_allocator_noprop> buffer(

(std_allocator_noprop(&alloc)));

buffer.append(string_view("test", 4));

check_move_buffer("test", buffer);

buffer.push_back('a');

check_move_buffer("testa", buffer);

auto alloc = std::allocator<char>();

basic_memory_buffer<char, 4, std_allocator_noprop> buffer(

(std_allocator_noprop(&alloc)));

const char test[] = "test";

buffer.append(test, test + 4);

const char* inline_buffer_ptr = &buffer[0];

buffer.push_back('a');

EXPECT_NE(buffer.data(), inline_buffer_ptr);

std::allocator<char>* original_alloc_ptr = buffer.get_allocator().get();

basic_memory_buffer<char, 4, std_allocator_noprop> buffer2;

buffer2 = std::move(buffer);

EXPECT_EQ(std::string(buffer2.data(), buffer2.size()), "testa");

EXPECT_GT(buffer2.capacity(), 4u);

EXPECT_NE(buffer2.data(), inline_buffer_ptr);

EXPECT_EQ(buffer.get_allocator().get(), original_alloc_ptr);

EXPECT_NE(buffer2.get_allocator().get(), original_alloc_ptr);

basic_memory_buffer<char, 5>& buffer) {

basic_memory_buffer<char, 5> buffer2;

buffer2 = std::move(buffer);

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

EXPECT_EQ(std::string(&buffer[0], buffer.size()), str);

EXPECT_EQ(std::string(&buffer2[0], buffer2.size()), str);

EXPECT_EQ(buffer2.capacity(), 5u);

basic_memory_buffer<char, 5> buffer;

const char test[] = "test";

buffer.append(test, test + 4);

check_move_assign_buffer("test", buffer);

// Adding one more character fills the inline buffer, but doesn't cause

// dynamic allocation.

buffer.push_back('a');

check_move_assign_buffer("testa", buffer);

const char* inline_buffer_ptr = &buffer[0];

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

// a dynamically allocated buffer.

buffer.push_back('b');

basic_memory_buffer<char, 5> buffer2;

buffer2 = std::move(buffer);

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

EXPECT_EQ(buffer.data(), inline_buffer_ptr);

EXPECT_EQ(std::string(buffer2.data(), buffer2.size()), "testab");

EXPECT_GT(buffer2.capacity(), 5u);

using allocator = allocator_ref<mock_allocator<int>>;

mock_allocator<int> alloc;

basic_memory_buffer<int, 10, allocator> buffer((allocator(&alloc)));

buffer.resize(7);

using fmt::detail::to_unsigned;

for (int i = 0; i < 7; ++i) buffer[to_unsigned(i)] = i * i;

EXPECT_EQ(10u, buffer.capacity());

int mem[20];

mem[7] = 0xdead;

EXPECT_CALL(alloc, allocate(20)).WillOnce(Return(mem));

buffer.try_reserve(20);

EXPECT_EQ(20u, buffer.capacity());

// Check if size elements have been copied

for (int i = 0; i < 7; ++i) EXPECT_EQ(i * i, buffer[to_unsigned(i)]);

// and no more than that.

EXPECT_EQ(0xdead, buffer[7]);

EXPECT_CALL(alloc, deallocate(mem, 20));

using test_allocator = allocator_ref<mock_allocator<char>>;

basic_memory_buffer<char, 10, test_allocator> buffer;

EXPECT_EQ(nullptr, buffer.get_allocator().get());

StrictMock<mock_allocator<char>> alloc;

char mem;

{

basic_memory_buffer<char, 10, test_allocator> buffer2(

(test_allocator(&alloc)));

EXPECT_EQ(&alloc, buffer2.get_allocator().get());

size_t size = 2 * fmt::inline_buffer_size;

EXPECT_CALL(alloc, allocate(size)).WillOnce(Return(&mem));

buffer2.reserve(size);

EXPECT_CALL(alloc, deallocate(&mem, size));

}

using test_allocator = allocator_ref<mock_allocator<char>>;

StrictMock<mock_allocator<char>> alloc;

basic_memory_buffer<char, 10, test_allocator> buffer(

(test_allocator(&alloc)));

size_t size = 2 * fmt::inline_buffer_size;

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

{

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

buffer.resize(size);

std::fill(&buffer[0], &buffer[0] + size, 'x');

}

auto mem2 = std::vector<char>(2 * size);

{

EXPECT_CALL(alloc, allocate(2 * size)).WillOnce(Return(&mem2[0]));

auto e = std::exception();

EXPECT_CALL(alloc, deallocate(&mem[0], size)).WillOnce(testing::Throw(e));

EXPECT_THROW(buffer.reserve(2 * size), std::exception);

EXPECT_EQ(&mem2[0], &buffer[0]);

// Check that the data has been copied.

for (size_t i = 0; i < size; ++i) EXPECT_EQ('x', buffer[i]);

}

EXPECT_CALL(alloc, deallocate(&mem2[0], 2 * size));

public:

using typename Allocator::value_type;

size_t max_size() const noexcept { return MaxSize; }

value_type* allocate(size_t n) {

if (n > max_size()) {

throw std::length_error("size > max_size");

}

return std::allocator_traits<Allocator>::allocate(

*static_cast<Allocator*>(this), n);

}

void deallocate(value_type* p, size_t n) {

std::allocator_traits<Allocator>::deallocate(*static_cast<Allocator*>(this),

p, n);

}

// 160 = 128 + 32

using test_allocator = max_size_allocator<std::allocator<char>, 160>;

basic_memory_buffer<char, 10, test_allocator> buffer;

buffer.resize(128);

// new_capacity = 128 + 128/2 = 192 > 160

buffer.resize(160); // Shouldn't throw.

using test_allocator = max_size_allocator<std::allocator<char>, 160>;

basic_memory_buffer<char, 10, test_allocator> buffer;

EXPECT_THROW(buffer.resize(161), std::exception);

fmt::memory_buffer buf;

using iterator = decltype(std::back_inserter(buf));

EXPECT_TRUE(fmt::detail::is_back_insert_iterator<iterator>::value);

auto p =

fmt::detail::bit_cast<fmt::detail::uintptr_t>(fmt::detail::digits2(0));

EXPECT_EQ(p % 2, 0);

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

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

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

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

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

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

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

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

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

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

EXPECT_THROW_MSG((void)fmt::format(runtime("{")), format_error,

"invalid format string");

EXPECT_THROW_MSG((void)fmt::format(runtime("}")), format_error,

"unmatched '}' in format string");

EXPECT_THROW_MSG((void)fmt::format(runtime("{0{}")), format_error,

"invalid format string");

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

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

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

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

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

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

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

EXPECT_THROW_MSG((void)fmt::format(runtime("{")), format_error,

"invalid format string");

EXPECT_THROW_MSG((void)fmt::format(runtime("{?}")), format_error,

"invalid format string");

EXPECT_THROW_MSG((void)fmt::format(runtime("{0")), format_error,

"invalid format string");

EXPECT_THROW_MSG((void)fmt::format(runtime("{0}")), format_error,

"argument not found");

EXPECT_THROW_MSG((void)fmt::format(runtime("{00}"), 42), format_error,

"invalid format string");

auto int_max = std::to_string(INT_MAX);

EXPECT_THROW_MSG((void)fmt::format(runtime("{" + int_max)), format_error,

"invalid format string");

EXPECT_THROW_MSG((void)fmt::format(runtime("{" + int_max + "}")),

format_error, "argument not found");

auto int_maxer = std::to_string(INT_MAX + 1u);

EXPECT_THROW_MSG((void)fmt::format(runtime("{" + int_maxer)), format_error,

"invalid format string");

EXPECT_THROW_MSG((void)fmt::format(runtime("{" + int_maxer + "}")),

format_error, "argument not found");

template <typename... T>

static auto format(fmt::string_view fmt, const T&... args) -> std::string {

return test_format<N - 1>::format(fmt, N - 1, args...);

}

EXPECT_EQ("19", test_format<20>::format("{19}"));

EXPECT_THROW_MSG(test_format<20>::format("{20}"), format_error,

"argument not found");

EXPECT_THROW_MSG(test_format<21>::format("{21}"), format_error,

"argument not found");

using fmt::detail::max_packed_args;

std::string format_str = fmt::format("{{{}}}", max_packed_args + 1);

EXPECT_THROW_MSG(test_format<max_packed_args>::format(format_str),

format_error, "argument not found");

EXPECT_EQ("1/a/A", fmt::format("{_1}/{a_}/{A_}", fmt::arg("a_", 'a'),

fmt::arg("A_", "A"), fmt::arg("_1", 1)));

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

EXPECT_EQ(fmt::format("{value:{width}}", fmt::arg("value", -42),

fmt::arg("width", 4)),

" -42");

EXPECT_EQ("st",

fmt::format("{0:.{precision}}", "str", fmt::arg("precision", 2)));

EXPECT_EQ(fmt::format("{} {two}", 1, fmt::arg("two", 2)), "1 2");

EXPECT_EQ("42",

fmt::format("{c}", fmt::arg("a", 0), fmt::arg("b", 0),

fmt::arg("c", 42), fmt::arg("d", 0), fmt::arg("e", 0),

fmt::arg("f", 0), fmt::arg("g", 0), fmt::arg("h", 0),

fmt::arg("i", 0), fmt::arg("j", 0), fmt::arg("k", 0),

fmt::arg("l", 0), fmt::arg("m", 0), fmt::arg("n", 0),

fmt::arg("o", 0), fmt::arg("p", 0)));

EXPECT_THROW_MSG((void)fmt::format(runtime("{a}")), format_error,

"argument not found");

EXPECT_THROW_MSG((void)fmt::format(runtime("{a}"), 42), format_error,

"argument not found");

EXPECT_THROW_MSG((void)fmt::format(runtime("{a} {}"), fmt::arg("a", 2), 42),

format_error,

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

EXPECT_THROW_MSG(

(void)fmt::format("{a}", fmt::arg("a", 1), fmt::arg("a", 10)),

format_error, "duplicate named arg");

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

EXPECT_THROW_MSG((void)fmt::format(runtime("{0}{}"), 'a', 'b'), format_error,

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

EXPECT_THROW_MSG((void)fmt::format(runtime("{}{0}"), 'a', 'b'), format_error,

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

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

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

format_error,

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

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

format_error,

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

EXPECT_THROW_MSG((void)fmt::format(runtime("{}")), format_error,

"argument not found");

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

EXPECT_THROW_MSG((void)fmt::format(runtime("{0:{<5}"), 'c'), format_error,

"invalid fill character '{'");

EXPECT_THROW_MSG((void)fmt::format(runtime("{0:{<5}}"), 'c'), format_error,

"invalid fill character '{'");

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

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

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

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

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

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

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

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

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

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

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

EXPECT_EQ("**0xface",

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

EXPECT_EQ(fmt::format("{:}=", "foo"), "foo=");

EXPECT_EQ(std::string("\0\0\0*", 4),

fmt::format(string_view("{:\0>4}", 6), '*'));

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

EXPECT_THROW_MSG((void)fmt::format(runtime("{:\x80\x80\x80\x80\x80>}"), 0),

format_error, "invalid format specifier");

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

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

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

EXPECT_THROW_MSG((void)fmt::format(runtime("{0:+}"), 42u), format_error,

"invalid format specifier");

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

EXPECT_THROW_MSG((void)fmt::format(runtime("{0:+}"), 42ul), format_error,

"invalid format specifier");

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

#if FMT_USE_INT128

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

#endif

EXPECT_THROW_MSG((void)fmt::format(runtime("{0:+}"), 42ull), format_error,

"invalid format specifier");

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

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

EXPECT_THROW_MSG((void)fmt::format(runtime("{0:+}"), 'c'), format_error,

"invalid format specifier");

EXPECT_THROW_MSG((void)fmt::format(runtime("{0:+}"), "abc"), format_error,

"invalid format specifier");

EXPECT_THROW_MSG(

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

format_error, "invalid format specifier");

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

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

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

EXPECT_THROW_MSG((void)fmt::format(runtime("{0:-}"), 42u), format_error,

"invalid format specifier");

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

EXPECT_THROW_MSG((void)fmt::format(runtime("{0:-}"), 42ul), format_error,

"invalid format specifier");

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

EXPECT_THROW_MSG((void)fmt::format(runtime("{0:-}"), 42ull), format_error,

"invalid format specifier");

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

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

EXPECT_THROW_MSG((void)fmt::format(runtime("{0:-}"), 'c'), format_error,

"invalid format specifier");

EXPECT_THROW_MSG((void)fmt::format(runtime("{0:-}"), "abc"), format_error,

"invalid format specifier");

EXPECT_THROW_MSG(

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

format_error, "invalid format specifier");

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

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

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

EXPECT_THROW_MSG((void)fmt::format(runtime("{0: }"), 42u), format_error,

"invalid format specifier");

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

EXPECT_THROW_MSG((void)fmt::format(runtime("{0: }"), 42ul), format_error,

"invalid format specifier");

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

EXPECT_THROW_MSG((void)fmt::format(runtime("{0: }"), 42ull), format_error,

"invalid format specifier");

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

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

EXPECT_THROW_MSG((void)fmt::format(runtime("{0: }"), 'c'), format_error,

"invalid format specifier");

EXPECT_THROW_MSG((void)fmt::format(runtime("{0: }"), "abc"), format_error,

"invalid format specifier");

EXPECT_THROW_MSG(

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

format_error, "invalid format specifier");

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

EXPECT_EQ(fmt::format("{:#.0e}", 42.0), "4.e+01");

EXPECT_EQ(fmt::format("{:#.0f}", 0.01), "0.");

EXPECT_EQ(fmt::format("{:#.2g}", 0.5), "0.50");

EXPECT_EQ(fmt::format("{:#.0f}", 0.5), "0.");

EXPECT_THROW_MSG((void)fmt::format(runtime("{0:#"), 'c'), format_error,

"invalid format specifier for char");

EXPECT_THROW_MSG((void)fmt::format(runtime("{0:#}"), 'c'), format_error,

"invalid format specifier for char");

EXPECT_THROW_MSG((void)fmt::format(runtime("{0:#}"), "abc"), format_error,

"invalid format specifier");

EXPECT_THROW_MSG(

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

format_error, "invalid format specifier");

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

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

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

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

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

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

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

EXPECT_EQ(fmt::format("{0:07}", -42.0), "-000042");

EXPECT_EQ(fmt::format("{0:07}", -42.0l), "-000042");

EXPECT_THROW_MSG((void)fmt::format(runtime("{0:0"), 'c'), format_error,

"invalid format specifier for char");

EXPECT_THROW_MSG((void)fmt::format(runtime("{0:05}"), 'c'), format_error,

"invalid format specifier for char");

EXPECT_THROW_MSG((void)fmt::format(runtime("{0:05}"), "abc"), format_error,

"format specifier requires numeric argument");

EXPECT_THROW_MSG(

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

format_error, "format specifier requires numeric argument");

// If the 0 character and an align option both appear, the 0 character is

// ignored.

EXPECT_EQ(fmt::format("{:<05}", 42), "42 ");

EXPECT_EQ(fmt::format("{:<05}", -42), "-42 ");

EXPECT_EQ(fmt::format("{:^05}", 42), " 42 ");

EXPECT_EQ(fmt::format("{:^05}", -42), " -42 ");

EXPECT_EQ(fmt::format("{:>05}", 42), " 42");

EXPECT_EQ(fmt::format("{:>05}", -42), " -42");

auto int_maxer = std::to_string(INT_MAX + 1u);

EXPECT_THROW_MSG((void)fmt::format(runtime("{:" + int_maxer), 0),

format_error, "number is too big");

EXPECT_THROW_MSG((void)fmt::format(runtime("{:" + int_maxer + "}"), 0),

format_error, "number is too big");

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

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

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

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

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

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

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

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

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

" 0xcafe");

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

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

EXPECT_EQ(fmt::format("{:*^5}", "🤡"), "*🤡**");

EXPECT_EQ(fmt::format("{:*^6}", "🤡"), "**🤡**");

EXPECT_EQ(fmt::format("{:*^8}", "你好"), "**你好**");

EXPECT_EQ(fmt::format("{:#6}", 42.0), " 42.");

EXPECT_EQ(fmt::format("{:6c}", static_cast<int>('x')), "x ");

EXPECT_EQ(fmt::format("{:>06.0f}", 0.00884311), " 0");

EXPECT_EQ(fmt::format("{:?}", ""), R"("")");

EXPECT_EQ(fmt::format("{:*<5.0?}", "\n"), R"(*****)");