blame: source/misc/embedded_libs/fmt-8.1.1/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 <climits>      // INT_MAX

#include <cmath>        // std::signbit

#include <cstring>      // std::strlen

#include <iterator>     // std::back_inserter

#include <list>         // std::list

#include <memory>       // std::unique_ptr

#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 testing::Return;

using testing::StrictMock;

enum { buffer_size = 256 };

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(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("warning: std::allocator allocates {} chars", 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(inline_buffer_ptr, &buffer[0]);

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

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

  typedef allocator_ref<mock_allocator<int>> Allocator;

  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 FMT_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, escape) {

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

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

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

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

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

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

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

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

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

  EXPECT_EQ("{42}", fmt::format("{{{0}}}", 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("test", fmt::format("test")); }

TEST(format_test, args_in_different_positions) {

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

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

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

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

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

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

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

}

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

  char format_str[buffer_size];

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

  EXPECT_THROW_MSG((void)fmt::format(runtime(format_str)), format_error,

                   "invalid format string");

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

  EXPECT_THROW_MSG((void)fmt::format(runtime(format_str)), format_error,

                   "argument not found");

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

  EXPECT_THROW_MSG((void)fmt::format(runtime(format_str)), format_error,

                   "invalid format string");

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

  EXPECT_THROW_MSG((void)fmt::format(runtime(format_str)), format_error,

                   "argument not found");

}

template <int N> struct test_format {

  template <typename... T>

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

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

  }

};

template <> struct test_format<0> {

  template <typename... T>

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

    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(" -42", fmt::format("{0:{width}}", -42, fmt::arg("width", 4)));

  EXPECT_EQ("st",

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

  EXPECT_EQ("1 2", fmt::format("{} {two}", 1, fmt::arg("two", 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");

}

TEST(format_test, auto_arg_index) {

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

  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("1.2", fmt::format("{:.{}}", 1.2345, 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("42", fmt::format("{0:}", 42)); }

TEST(format_test, left_align) {

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

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

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

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

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

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

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

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

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

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

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

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

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

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

}

TEST(format_test, right_align) {

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

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

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

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

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

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

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

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

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

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

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

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

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

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

}

TEST(format_test, center_align) {

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

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

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

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

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

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

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

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

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

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

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

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

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

  EXPECT_EQ(" 0xface ", fmt::format("{0:^8}", reinterpret_cast<void*>(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("**42", fmt::format("{0:*>4}", 42));

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

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

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

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

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

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

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

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

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

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

  EXPECT_EQ("**0xface",

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

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

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

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

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

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

                   format_error, "invalid type specifier");

}

TEST(format_test, plus_sign) {

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

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

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

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

                   "format specifier requires signed argument");

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

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

                   "format specifier requires signed argument");

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

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

                   "format specifier requires signed argument");

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

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

  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,

                   "format specifier requires numeric argument");

  EXPECT_THROW_MSG(

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

      format_error, "format specifier requires numeric argument");

}

TEST(format_test, minus_sign) {

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

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

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

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

                   "format specifier requires signed argument");

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

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

                   "format specifier requires signed argument");

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

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

                   "format specifier requires signed argument");

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

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

  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,

                   "format specifier requires numeric argument");

  EXPECT_THROW_MSG(

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

      format_error, "format specifier requires numeric argument");

}

TEST(format_test, space_sign) {

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

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

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

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

                   "format specifier requires signed argument");

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

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

                   "format specifier requires signed argument");

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

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

                   "format specifier requires signed argument");

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

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

  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,

                   "format specifier requires numeric argument");

  EXPECT_THROW_MSG(

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

      format_error, "format specifier requires numeric argument");

}

TEST(format_test, hash_flag) {

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  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,

                   "format specifier requires numeric argument");

  EXPECT_THROW_MSG(

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

      format_error, "format specifier requires numeric argument");

}

TEST(format_test, zero_flag) {

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

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

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

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

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

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

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

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

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

  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, width) {

  char format_str[buffer_size];

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

  increment(format_str + 3);

  EXPECT_THROW_MSG((void)fmt::format(runtime(format_str), 0), format_error,

                   "number is too big");

  size_t size = std::strlen(format_str);

  format_str[size] = '}';

  format_str[size + 1] = 0;

  EXPECT_THROW_MSG((void)fmt::format(runtime(format_str), 0), format_error,

                   "number is too big");

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

  EXPECT_THROW_MSG((void)fmt::format(runtime(format_str), 0), format_error,

                   "number is too big");

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

  EXPECT_THROW_MSG((void)fmt::format(runtime(format_str), 0), format_error,

                   "number is too big");

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

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

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

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

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

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

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

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

  EXPECT_EQ("    0xcafe",

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

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

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

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

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

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

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

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

}

TEST(format_test, runtime_width) {

  char format_str[buffer_size];

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

  increment(format_str + 4);

  EXPECT_THROW_MSG((void)fmt::format(runtime(format_str), 0), format_error,

                   "invalid format string");

  size_t size = std::strlen(format_str);

  format_str[size] = '}';

  format_str[size + 1] = 0;

  EXPECT_THROW_MSG((void)fmt::format(runtime(format_str), 0), format_error,

                   "argument not found");

  format_str[size + 1] = '}';

  format_str[size + 2] = 0;

  EXPECT_THROW_MSG((void)fmt::format(runtime(format_str), 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)),

                   format_error, "number is too big");

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

                   "negative width");

  if (fmt::detail::const_check(sizeof(long) > sizeof(int))) {

    long value = INT_MAX;

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

                     format_error, "number is too big");

  }

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

                   format_error, "number is too big");

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

                   "width is not integer");

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

                   "width is not integer");

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

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

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

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

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

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

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

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

  EXPECT_EQ("    0xcafe",

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

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

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

}

TEST(format_test, precision) {

  char format_str[buffer_size];

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

  increment(format_str + 4);

  EXPECT_THROW_MSG((void)fmt::format(runtime(format_str), 0), format_error,

                   "number is too big");

  size_t size = std::strlen(format_str);

  format_str[size] = '}';

  format_str[size + 1] = 0;

  EXPECT_THROW_MSG((void)fmt::format(runtime(format_str), 0), format_error,

                   "number is too big");

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

  EXPECT_THROW_MSG((void)fmt::format(runtime(format_str), 0), format_error,

                   "number is too big");

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

  EXPECT_THROW_MSG((void)fmt::format(runtime(format_str), 0), format_error,

                   "number is too big");

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

                   "missing precision specifier");

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

                   "missing precision specifier");

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

                   "precision not allowed for this argument type");

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

                   "precision not allowed for this argument type");

  EXPECT_THROW_MSG((void)fmt::format(runtime("{0:.2f}"), 42), format_error,

                   "precision not allowed for this argument type");

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

                   "precision not allowed for this argument type");

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

                   "precision not allowed for this argument type");

  EXPECT_THROW_MSG((void)fmt::format(runtime("{0:.2}"), 42l), format_error,

                   "precision not allowed for this argument type");

  EXPECT_THROW_MSG((void)fmt::format(runtime("{0:.2f}"), 42l), format_error,

                   "precision not allowed for this argument type");

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

                   "precision not allowed for this argument type");

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

                   "precision not allowed for this argument type");

  EXPECT_THROW_MSG((void)fmt::format(runtime("{0:.2}"), 42ll), format_error,

                   "precision not allowed for this argument type");

  EXPECT_THROW_MSG((void)fmt::format(runtime("{0:.2f}"), 42ll), format_error,

                   "precision not allowed for this argument type");

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

                   "precision not allowed for this argument type");

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

                   "precision not allowed for this argument type");

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

                   "precision not allowed for this argument type");

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

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

  EXPECT_EQ("1.2e+56", fmt::format("{:.2}", 1.234e56));

  EXPECT_EQ("1.1", fmt::format("{0:.3}", 1.1));

  EXPECT_EQ("1e+00", fmt::format("{:.0e}", 1.0L));

  EXPECT_EQ("  0.0e+00", fmt::format("{:9.1e}", 0.0));

  EXPECT_EQ(

      fmt::format("{:.494}", 4.9406564584124654E-324),

      "4.9406564584124654417656879286822137236505980261432476442558568250067550"

      "727020875186529983636163599237979656469544571773092665671035593979639877"

      "479601078187812630071319031140452784581716784898210368871863605699873072"

      "305000638740915356498438731247339727316961514003171538539807412623856559"

      "117102665855668676818703956031062493194527159149245532930545654440112748"

      "012970999954193198940908041656332452475714786901472678015935523861155013"

      "480352649347201937902681071074917033322268447533357208324319361e-324");

  EXPECT_EQ(

      fmt::format("{:.1074f}", 1.1125369292536e-308),

      "0.0000000000000000000000000000000000000000000000000000000000000000000000"

      "000000000000000000000000000000000000000000000000000000000000000000000000"

      "000000000000000000000000000000000000000000000000000000000000000000000000"

      "000000000000000000000000000000000000000000000000000000000000000000000000"

      "000000000000000000000111253692925360019747947051741965785554081512200979"

      "355021686109411883779182127659725163430929750364498219730822952552570601"

      "152163505899912777129583674906301179059298598412303893909188340988729019"

      "014361467448914817838555156840459458527907308695109202499990850735085304"

      "478476991912072201449236975063640913461919914396877093174125167509869762"

      "482369631100360266123742648159508919592746619553246586039571522788247697"

      "156360766271842991667238355464496455107749716934387136380536472531224398"

      "559833794807213172371254492216255558078524900147957309382830827524104234"