blame: source/misc/embedded_libs/fmt-11.0.2/test/format-test.cc

// Formatting library for C++ - formatting library tests

//

// Copyright (c) 2012 - present, Victor Zverovich

// All rights reserved.

//

// For the license information refer to format.h.

// Check if fmt/format.h compiles with windows.h included before it.

#ifdef _WIN32

#  include <windows.h>

#endif

// clang-format off

#include "fmt/format.h"

// clang-format on

#include <stdint.h>  // uint32_t

#include <cfenv>               // fegetexceptflag and FE_ALL_EXCEPT

#include <climits>             // INT_MAX

#include <cmath>               // std::signbit

#include <condition_variable>  // std::condition_variable

#include <cstring>             // std::strlen

#include <iterator>            // std::back_inserter

#include <list>                // std::list

#include <mutex>               // std::mutex

#include <string>              // std::string

#include <thread>              // std::thread

#include <type_traits>         // std::is_default_constructible

#include "gtest-extra.h"

#include "mock-allocator.h"

#include "util.h"

using fmt::basic_memory_buffer;

using fmt::format_error;

using fmt::memory_buffer;

using fmt::runtime;

using fmt::string_view;

using fmt::detail::max_value;

using fmt::detail::uint128_fallback;

using testing::Return;

using testing::StrictMock;

enum { buffer_size = 256 };

TEST(uint128_test, ctor) {

  auto n = uint128_fallback();

  EXPECT_EQ(n, 0);

  n = uint128_fallback(42);

  EXPECT_EQ(n, 42);

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

}

TEST(uint128_test, shift) {

  auto n = uint128_fallback(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_fallback(1) << 112, uint128_fallback(0x1000000000000, 0));

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

}

TEST(uint128_test, minus) {

  auto n = uint128_fallback(42);

  EXPECT_EQ(n - 2, 40);

}

TEST(uint128_test, plus_assign) {

  auto n = uint128_fallback(32);

  n += uint128_fallback(10);

  EXPECT_EQ(n, 42);

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

  n += uint128_fallback(1);

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

}

TEST(uint128_test, multiply) {

  auto n = uint128_fallback(2251799813685247);

  n = n * 3611864890;

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

}

template <typename Float> void check_isfinite() {

  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())));

}

TEST(float_test, isfinite) {

  check_isfinite<double>();

#if FMT_USE_FLOAT128

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

#endif

}

void check_no_fp_exception() {

  fexcept_t fe;

  fegetexceptflag(&fe, FE_ALL_EXCEPT);

  // No exception flags should have been set

  EXPECT_TRUE(fe == 0);

}

template <typename Float> void check_isnan() {

  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();

}

TEST(float_test, isnan) {

  check_isnan<double>();

#if FMT_USE_FLOAT128

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

#endif

}

struct uint32_pair {

  uint32_t u[2];

};

TEST(util_test, bit_cast) {

  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);

}

// Increment a number in a string.

void increment(char* s) {

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

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

      ++s[i];

      break;

    }

    s[i] = '0';

  }

}

TEST(util_test, increment) {

  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);

}

TEST(util_test, parse_nonnegative_int) {

  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);

}

TEST(format_impl_test, compute_width) {

  EXPECT_EQ(fmt::detail::compute_width("вожык"), 5);

}

TEST(util_test, utf8_to_utf16) {

  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());

}

TEST(util_test, utf8_to_utf16_empty_string) {

  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());

}

TEST(util_test, allocator_ref) {

  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);

}

TEST(util_test, format_system_error) {

  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());

  message = fmt::memory_buffer();

  // Check if std::allocator throws on allocating max size_t / 2 chars.

  size_t max_size = max_value<size_t>() / 2;

  bool throws_on_alloc = false;

  try {

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

    alloc.deallocate(alloc.allocate(max_size), max_size);

  } catch (const std::bad_alloc&) {

    throws_on_alloc = true;

  }

  if (!throws_on_alloc) {

    fmt::print(stderr, "warning: std::allocator allocates {} chars\n",

               max_size);

    return;

  }

}

TEST(util_test, system_error) {

  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()));

}

TEST(util_test, report_system_error) {

  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));

}

TEST(memory_buffer_test, ctor) {

  basic_memory_buffer<char, 123> buffer;

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

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

}

using std_allocator = allocator_ref<std::allocator<char>>;

TEST(memory_buffer_test, move_ctor_inline_buffer) {

  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(str, std::string(&buffer[0], buffer.size()));

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

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

        // Move should transfer allocator.

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

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

      };

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

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

  const char test[] = "test";

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

  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);

}

TEST(memory_buffer_test, move_ctor_dynamic_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);

}

void check_move_assign_buffer(const char* str,

                              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(str, std::string(&buffer[0], buffer.size()));

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

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

}

TEST(memory_buffer_test, move_assignment) {

  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(inline_buffer_ptr, &buffer[0]);

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

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

}

TEST(memory_buffer_test, grow) {

  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));

}

TEST(memory_buffer_test, allocator) {

  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));

  }

}

TEST(memory_buffer_test, exception_in_deallocate) {

  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));

}

template <typename Allocator, size_t MaxSize>

class max_size_allocator : public Allocator {

 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);

  }

};

TEST(memory_buffer_test, max_size_allocator) {

  // 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.

}

TEST(memory_buffer_test, max_size_allocator_overflow) {

  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);

}

TEST(format_test, exception_from_lib) {

  EXPECT_THROW_MSG(fmt::report_error("test"), format_error, "test");

}

TEST(format_test, escape) {

  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}");

}

TEST(format_test, unmatched_braces) {

  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");

}

TEST(format_test, no_args) { EXPECT_EQ(fmt::format("test"), "test"); }

TEST(format_test, args_in_different_positions) {

  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");

}

TEST(format_test, arg_errors) {

  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 <int N> struct test_format {

  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...);

  }

};

template <> struct test_format<0> {

  template <typename... T>

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

    return fmt::format(runtime(fmt), args...);

  }

};

TEST(format_test, many_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");

}

TEST(format_test, named_arg) {

  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("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");

}

TEST(format_test, auto_arg_index) {

  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");

}

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

TEST(format_test, left_align) {

  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  ");

}

TEST(format_test, right_align) {

  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");

}

TEST(format_test, center_align) {

  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 ");

}

TEST(format_test, fill) {

  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");

}

TEST(format_test, plus_sign) {

  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");

}

TEST(format_test, minus_sign) {

  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");

}

TEST(format_test, space_sign) {

  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");

}

TEST(format_test, hash_flag) {

  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,

                   "missing '}' in format string");

  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");

}

TEST(format_test, zero_flag) {

  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,

                   "missing '}' in format string");

  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");

}

TEST(format_test, zero_flag_and_align) {

  // 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");

}

TEST(format_test, width) {

  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("{:*^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");

}

TEST(format_test, runtime_width) {

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

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

                   format_error, "invalid format string");

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

                   format_error, "argument not found");

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

                   format_error, "argument not found");

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

                   "invalid format string");

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

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

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

                   "invalid format string");

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

                   "argument not found");

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

                   "invalid format string");

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

                   "negative width");

  EXPECT_THROW_MSG((void)fmt::format(runtime("{0:{1}}"), 0, (INT_MAX + 1u)),