[ceph.git] / ceph / src / fmt / test / compile-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.

#include "fmt/compile.h"

#include <type_traits>

#include "fmt/chrono.h"
#include "gmock/gmock.h"
#include "gtest-extra.h"

TEST(iterator_test, counting_iterator) {
  auto it = fmt::detail::counting_iterator();
  auto prev = it++;
  EXPECT_EQ(prev.count(), 0);
  EXPECT_EQ(it.count(), 1);
  EXPECT_EQ((it + 41).count(), 42);
}

TEST(iterator_test, truncating_iterator) {
  char* p = nullptr;
  auto it = fmt::detail::truncating_iterator<char*>(p, 3);
  auto prev = it++;
  EXPECT_EQ(prev.base(), p);
  EXPECT_EQ(it.base(), p + 1);
}

TEST(iterator_test, truncating_iterator_default_construct) {
  auto it = fmt::detail::truncating_iterator<char*>();
  EXPECT_EQ(nullptr, it.base());
  EXPECT_EQ(std::size_t{0}, it.count());
}

#ifdef __cpp_lib_ranges
TEST(iterator_test, truncating_iterator_is_output_iterator) {
  static_assert(
      std::output_iterator<fmt::detail::truncating_iterator<char*>, char>);
}
#endif

TEST(iterator_test, truncating_back_inserter) {
  auto buffer = std::string();
  auto bi = std::back_inserter(buffer);
  auto it = fmt::detail::truncating_iterator<decltype(bi)>(bi, 2);
  *it++ = '4';
  *it++ = '2';
  *it++ = '1';
  EXPECT_EQ(buffer.size(), 2);
  EXPECT_EQ(buffer, "42");
}

TEST(compile_test, compile_fallback) {
  // FMT_COMPILE should fallback on runtime formatting when `if constexpr` is
  // not available.
  EXPECT_EQ("42", fmt::format(FMT_COMPILE("{}"), 42));
}

#ifdef __cpp_if_constexpr
struct test_formattable {};

FMT_BEGIN_NAMESPACE
template <> struct formatter<test_formattable> : formatter<const char*> {
  char word_spec = 'f';
  constexpr auto parse(format_parse_context& ctx) {
    auto it = ctx.begin(), end = ctx.end();
    if (it == end || *it == '}') return it;
    if (it != end && (*it == 'f' || *it == 'b')) word_spec = *it++;
    if (it != end && *it != '}') throw format_error("invalid format");
    return it;
  }
  template <typename FormatContext>
  constexpr auto format(test_formattable, FormatContext& ctx) const
      -> decltype(ctx.out()) {
    return formatter<const char*>::format(word_spec == 'f' ? "foo" : "bar",
                                          ctx);
  }
};
FMT_END_NAMESPACE

TEST(compile_test, format_default) {
  EXPECT_EQ("42", fmt::format(FMT_COMPILE("{}"), 42));
  EXPECT_EQ("42", fmt::format(FMT_COMPILE("{}"), 42u));
  EXPECT_EQ("42", fmt::format(FMT_COMPILE("{}"), 42ll));
  EXPECT_EQ("42", fmt::format(FMT_COMPILE("{}"), 42ull));
  EXPECT_EQ("true", fmt::format(FMT_COMPILE("{}"), true));
  EXPECT_EQ("x", fmt::format(FMT_COMPILE("{}"), 'x'));
  EXPECT_EQ("4.2", fmt::format(FMT_COMPILE("{}"), 4.2));
  EXPECT_EQ("foo", fmt::format(FMT_COMPILE("{}"), "foo"));
  EXPECT_EQ("foo", fmt::format(FMT_COMPILE("{}"), std::string("foo")));
  EXPECT_EQ("foo", fmt::format(FMT_COMPILE("{}"), test_formattable()));
  auto t = std::chrono::system_clock::now();
  EXPECT_EQ(fmt::format("{}", t), fmt::format(FMT_COMPILE("{}"), t));
#  ifdef __cpp_lib_byte
  EXPECT_EQ("42", fmt::format(FMT_COMPILE("{}"), std::byte{42}));
#  endif
}

TEST(compile_test, format_wide_string) {
  EXPECT_EQ(L"42", fmt::format(FMT_COMPILE(L"{}"), 42));
}

TEST(compile_test, format_specs) {
  EXPECT_EQ("42", fmt::format(FMT_COMPILE("{:x}"), 0x42));
  EXPECT_EQ("1.2 ms ",
            fmt::format(FMT_COMPILE("{:7.1%Q %q}"),
                        std::chrono::duration<double, std::milli>(1.234)));
}

TEST(compile_test, dynamic_format_specs) {
  EXPECT_EQ("foo  ", fmt::format(FMT_COMPILE("{:{}}"), "foo", 5));
  EXPECT_EQ("  3.14", fmt::format(FMT_COMPILE("{:{}.{}f}"), 3.141592, 6, 2));
  EXPECT_EQ(
      "=1.234ms=",
      fmt::format(FMT_COMPILE("{:=^{}.{}}"),
                  std::chrono::duration<double, std::milli>(1.234), 9, 3));
}

TEST(compile_test, manual_ordering) {
  EXPECT_EQ("42", fmt::format(FMT_COMPILE("{0}"), 42));
  EXPECT_EQ(" -42", fmt::format(FMT_COMPILE("{0:4}"), -42));
  EXPECT_EQ("41 43", fmt::format(FMT_COMPILE("{0} {1}"), 41, 43));
  EXPECT_EQ("41 43", fmt::format(FMT_COMPILE("{1} {0}"), 43, 41));
  EXPECT_EQ("41 43", fmt::format(FMT_COMPILE("{0} {2}"), 41, 42, 43));
  EXPECT_EQ("  41   43", fmt::format(FMT_COMPILE("{1:{2}} {0:4}"), 43, 41, 4));
  EXPECT_EQ("42 1.2 ms ",
            fmt::format(FMT_COMPILE("{0} {1:7.1%Q %q}"), 42,
                        std::chrono::duration<double, std::milli>(1.234)));
  EXPECT_EQ(
      "true 42 42 foo 0x1234 foo",
      fmt::format(FMT_COMPILE("{0} {1} {2} {3} {4} {5}"), true, 42, 42.0f,
                  "foo", reinterpret_cast<void*>(0x1234), test_formattable()));
  EXPECT_EQ(L"42", fmt::format(FMT_COMPILE(L"{0}"), 42));
}

TEST(compile_test, named) {
  auto runtime_named_field_compiled =
      fmt::detail::compile<decltype(fmt::arg("arg", 42))>(FMT_COMPILE("{arg}"));
  static_assert(std::is_same_v<decltype(runtime_named_field_compiled),
                               fmt::detail::runtime_named_field<char>>);

  EXPECT_EQ("42", fmt::format(FMT_COMPILE("{}"), fmt::arg("arg", 42)));
  EXPECT_EQ("41 43", fmt::format(FMT_COMPILE("{} {}"), fmt::arg("arg", 41),
                                 fmt::arg("arg", 43)));

  EXPECT_EQ("foobar",
            fmt::format(FMT_COMPILE("{a0}{a1}"), fmt::arg("a0", "foo"),
                        fmt::arg("a1", "bar")));
  EXPECT_EQ("foobar", fmt::format(FMT_COMPILE("{}{a1}"), fmt::arg("a0", "foo"),
                                  fmt::arg("a1", "bar")));
  EXPECT_EQ("foofoo", fmt::format(FMT_COMPILE("{a0}{}"), fmt::arg("a0", "foo"),
                                  fmt::arg("a1", "bar")));
  EXPECT_EQ("foobar", fmt::format(FMT_COMPILE("{0}{a1}"), fmt::arg("a0", "foo"),
                                  fmt::arg("a1", "bar")));
  EXPECT_EQ("foobar", fmt::format(FMT_COMPILE("{a0}{1}"), fmt::arg("a0", "foo"),
                                  fmt::arg("a1", "bar")));

  EXPECT_EQ("foobar",
            fmt::format(FMT_COMPILE("{}{a1}"), "foo", fmt::arg("a1", "bar")));
  EXPECT_EQ("foobar",
            fmt::format(FMT_COMPILE("{a0}{a1}"), fmt::arg("a1", "bar"),
                        fmt::arg("a2", "baz"), fmt::arg("a0", "foo")));
  EXPECT_EQ(" bar foo ",
            fmt::format(FMT_COMPILE(" {foo} {bar} "), fmt::arg("foo", "bar"),
                        fmt::arg("bar", "foo")));

  EXPECT_THROW(fmt::format(FMT_COMPILE("{invalid}"), fmt::arg("valid", 42)),
               fmt::format_error);

#  if FMT_USE_NONTYPE_TEMPLATE_PARAMETERS
  using namespace fmt::literals;
  auto statically_named_field_compiled =
      fmt::detail::compile<decltype("arg"_a = 42)>(FMT_COMPILE("{arg}"));
  static_assert(std::is_same_v<decltype(statically_named_field_compiled),
                               fmt::detail::field<char, int, 0>>);

  EXPECT_EQ("41 43",
            fmt::format(FMT_COMPILE("{a0} {a1}"), "a0"_a = 41, "a1"_a = 43));
  EXPECT_EQ("41 43",
            fmt::format(FMT_COMPILE("{a1} {a0}"), "a0"_a = 43, "a1"_a = 41));
#  endif
}

TEST(compile_test, format_to) {
  char buf[8];
  auto end = fmt::format_to(buf, FMT_COMPILE("{}"), 42);
  *end = '\0';
  EXPECT_STREQ("42", buf);
  end = fmt::format_to(buf, FMT_COMPILE("{:x}"), 42);
  *end = '\0';
  EXPECT_STREQ("2a", buf);
}

TEST(compile_test, format_to_n) {
  constexpr auto buffer_size = 8;
  char buffer[buffer_size];
  auto res = fmt::format_to_n(buffer, buffer_size, FMT_COMPILE("{}"), 42);
  *res.out = '\0';
  EXPECT_STREQ("42", buffer);
  res = fmt::format_to_n(buffer, buffer_size, FMT_COMPILE("{:x}"), 42);
  *res.out = '\0';
  EXPECT_STREQ("2a", buffer);
}

TEST(compile_test, formatted_size) {
  EXPECT_EQ(2, fmt::formatted_size(FMT_COMPILE("{0}"), 42));
  EXPECT_EQ(5, fmt::formatted_size(FMT_COMPILE("{0:<4.2f}"), 42.0));
}

TEST(compile_test, text_and_arg) {
  EXPECT_EQ(">>>42<<<", fmt::format(FMT_COMPILE(">>>{}<<<"), 42));
  EXPECT_EQ("42!", fmt::format(FMT_COMPILE("{}!"), 42));
}

TEST(compile_test, unknown_format_fallback) {
  EXPECT_EQ(" 42 ",
            fmt::format(FMT_COMPILE("{name:^4}"), fmt::arg("name", 42)));

  std::vector<char> v;
  fmt::format_to(std::back_inserter(v), FMT_COMPILE("{name:^4}"),
                 fmt::arg("name", 42));
  EXPECT_EQ(" 42 ", fmt::string_view(v.data(), v.size()));

  char buffer[4];
  auto result = fmt::format_to_n(buffer, 4, FMT_COMPILE("{name:^5}"),
                                 fmt::arg("name", 42));
  EXPECT_EQ(5u, result.size);
  EXPECT_EQ(buffer + 4, result.out);
  EXPECT_EQ(" 42 ", fmt::string_view(buffer, 4));
}

TEST(compile_test, empty) { EXPECT_EQ("", fmt::format(FMT_COMPILE(""))); }

struct to_stringable {
  friend fmt::string_view to_string_view(to_stringable) { return {}; }
};

FMT_BEGIN_NAMESPACE
template <> struct formatter<to_stringable> {
  auto parse(format_parse_context& ctx) const -> decltype(ctx.begin()) {
    return ctx.begin();
  }

  template <typename FormatContext>
  auto format(const to_stringable&, FormatContext& ctx) -> decltype(ctx.out()) {
    return ctx.out();
  }
};
FMT_END_NAMESPACE

TEST(compile_test, to_string_and_formatter) {
  fmt::format(FMT_COMPILE("{}"), to_stringable());
}

TEST(compile_test, print) {
  EXPECT_WRITE(stdout, fmt::print(FMT_COMPILE("Don't {}!"), "panic"),
               "Don't panic!");
  EXPECT_WRITE(stderr, fmt::print(stderr, FMT_COMPILE("Don't {}!"), "panic"),
               "Don't panic!");
}
#endif

#if FMT_USE_NONTYPE_TEMPLATE_PARAMETERS
TEST(compile_test, compile_format_string_literal) {
  using namespace fmt::literals;
  EXPECT_EQ("", fmt::format(""_cf));
  EXPECT_EQ("42", fmt::format("{}"_cf, 42));
  EXPECT_EQ(L"42", fmt::format(L"{}"_cf, 42));
}
#endif

#if __cplusplus >= 202002L || \
    (__cplusplus >= 201709L && FMT_GCC_VERSION >= 1002)
template <size_t max_string_length, typename Char = char> struct test_string {
  template <typename T> constexpr bool operator==(const T& rhs) const noexcept {
    return fmt::basic_string_view<Char>(rhs).compare(buffer) == 0;
  }
  Char buffer[max_string_length]{};
};

template <size_t max_string_length, typename Char = char, typename... Args>
consteval auto test_format(auto format, const Args&... args) {
  test_string<max_string_length, Char> string{};
  fmt::format_to(string.buffer, format, args...);
  return string;
}

TEST(compile_time_formatting_test, bool) {
  EXPECT_EQ("true", test_format<5>(FMT_COMPILE("{}"), true));
  EXPECT_EQ("false", test_format<6>(FMT_COMPILE("{}"), false));
  EXPECT_EQ("true ", test_format<6>(FMT_COMPILE("{:5}"), true));
  EXPECT_EQ("1", test_format<2>(FMT_COMPILE("{:d}"), true));
}

TEST(compile_time_formatting_test, integer) {
  EXPECT_EQ("42", test_format<3>(FMT_COMPILE("{}"), 42));
  EXPECT_EQ("420", test_format<4>(FMT_COMPILE("{}"), 420));
  EXPECT_EQ("42 42", test_format<6>(FMT_COMPILE("{} {}"), 42, 42));
  EXPECT_EQ("42 42",
            test_format<6>(FMT_COMPILE("{} {}"), uint32_t{42}, uint64_t{42}));

  EXPECT_EQ("+42", test_format<4>(FMT_COMPILE("{:+}"), 42));
  EXPECT_EQ("42", test_format<3>(FMT_COMPILE("{:-}"), 42));
  EXPECT_EQ(" 42", test_format<4>(FMT_COMPILE("{: }"), 42));

  EXPECT_EQ("-0042", test_format<6>(FMT_COMPILE("{:05}"), -42));

  EXPECT_EQ("101010", test_format<7>(FMT_COMPILE("{:b}"), 42));
  EXPECT_EQ("0b101010", test_format<9>(FMT_COMPILE("{:#b}"), 42));
  EXPECT_EQ("0B101010", test_format<9>(FMT_COMPILE("{:#B}"), 42));
  EXPECT_EQ("042", test_format<4>(FMT_COMPILE("{:#o}"), 042));
  EXPECT_EQ("0x4a", test_format<5>(FMT_COMPILE("{:#x}"), 0x4a));
  EXPECT_EQ("0X4A", test_format<5>(FMT_COMPILE("{:#X}"), 0x4a));

  EXPECT_EQ("   42", test_format<6>(FMT_COMPILE("{:5}"), 42));
  EXPECT_EQ("   42", test_format<6>(FMT_COMPILE("{:5}"), 42ll));
  EXPECT_EQ("   42", test_format<6>(FMT_COMPILE("{:5}"), 42ull));

  EXPECT_EQ("42  ", test_format<5>(FMT_COMPILE("{:<4}"), 42));
  EXPECT_EQ("  42", test_format<5>(FMT_COMPILE("{:>4}"), 42));
  EXPECT_EQ(" 42 ", test_format<5>(FMT_COMPILE("{:^4}"), 42));
  EXPECT_EQ("**-42", test_format<6>(FMT_COMPILE("{:*>5}"), -42));
}

TEST(compile_time_formatting_test, char) {
  EXPECT_EQ("c", test_format<2>(FMT_COMPILE("{}"), 'c'));

  EXPECT_EQ("c  ", test_format<4>(FMT_COMPILE("{:3}"), 'c'));
  EXPECT_EQ("99", test_format<3>(FMT_COMPILE("{:d}"), 'c'));
}

TEST(compile_time_formatting_test, string) {
  EXPECT_EQ("42", test_format<3>(FMT_COMPILE("{}"), "42"));
  EXPECT_EQ("The answer is 42",
            test_format<17>(FMT_COMPILE("{} is {}"), "The answer", "42"));

  EXPECT_EQ("abc**", test_format<6>(FMT_COMPILE("{:*<5}"), "abc"));
  EXPECT_EQ("**🤡**", test_format<9>(FMT_COMPILE("{:*^6}"), "🤡"));
}

TEST(compile_time_formatting_test, combination) {
  EXPECT_EQ("420, true, answer",
            test_format<18>(FMT_COMPILE("{}, {}, {}"), 420, true, "answer"));

  EXPECT_EQ(" -42", test_format<5>(FMT_COMPILE("{:{}}"), -42, 4));
}

TEST(compile_time_formatting_test, custom_type) {
  EXPECT_EQ("foo", test_format<4>(FMT_COMPILE("{}"), test_formattable()));
  EXPECT_EQ("bar", test_format<4>(FMT_COMPILE("{:b}"), test_formattable()));
}

TEST(compile_time_formatting_test, multibyte_fill) {
  EXPECT_EQ("жж42", test_format<8>(FMT_COMPILE("{:ж>4}"), 42));
}
#endif
Commit	Line	Data
f67539c2 TL	1	// Formatting library for C++ - formatting library tests
	2	//
	3	// Copyright (c) 2012 - present, Victor Zverovich
	4	// All rights reserved.
	5	//
	6	// For the license information refer to format.h.
	7
f67539c2	8	#include "fmt/compile.h"
20effc67 TL	9
	10	#include <type_traits>
	11
	12	#include "fmt/chrono.h"
	13	#include "gmock/gmock.h"
f67539c2	14	#include "gtest-extra.h"
20effc67 TL	15
	16	TEST(iterator_test, counting_iterator) {
	17	auto it = fmt::detail::counting_iterator();
	18	auto prev = it++;
	19	EXPECT_EQ(prev.count(), 0);
	20	EXPECT_EQ(it.count(), 1);
	21	EXPECT_EQ((it + 41).count(), 42);
	22	}
	23
	24	TEST(iterator_test, truncating_iterator) {
	25	char* p = nullptr;
	26	auto it = fmt::detail::truncating_iterator<char*>(p, 3);
	27	auto prev = it++;
	28	EXPECT_EQ(prev.base(), p);
	29	EXPECT_EQ(it.base(), p + 1);
f67539c2	30	}
f67539c2	31
20effc67 TL	32	TEST(iterator_test, truncating_iterator_default_construct) {
	33	auto it = fmt::detail::truncating_iterator<char*>();
	34	EXPECT_EQ(nullptr, it.base());
	35	EXPECT_EQ(std::size_t{0}, it.count());
f67539c2 TL	36	}
f67539c2 TL	37
20effc67 TL	38	#ifdef __cpp_lib_ranges
	39	TEST(iterator_test, truncating_iterator_is_output_iterator) {
	40	static_assert(
	41	std::output_iterator<fmt::detail::truncating_iterator<char*>, char>);
f67539c2 TL	42	}
	43	#endif
	44
20effc67 TL	45	TEST(iterator_test, truncating_back_inserter) {
	46	auto buffer = std::string();
	47	auto bi = std::back_inserter(buffer);
	48	auto it = fmt::detail::truncating_iterator<decltype(bi)>(bi, 2);
	49	*it++ = '4';
	50	*it++ = '2';
	51	*it++ = '1';
	52	EXPECT_EQ(buffer.size(), 2);
	53	EXPECT_EQ(buffer, "42");
	54	}
	55
	56	TEST(compile_test, compile_fallback) {
	57	// FMT_COMPILE should fallback on runtime formatting when `if constexpr` is
	58	// not available.
	59	EXPECT_EQ("42", fmt::format(FMT_COMPILE("{}"), 42));
	60	}
	61
	62	#ifdef __cpp_if_constexpr
	63	struct test_formattable {};
	64
	65	FMT_BEGIN_NAMESPACE
	66	template <> struct formatter<test_formattable> : formatter<const char*> {
	67	char word_spec = 'f';
	68	constexpr auto parse(format_parse_context& ctx) {
	69	auto it = ctx.begin(), end = ctx.end();
	70	if (it == end \|\| *it == '}') return it;
	71	if (it != end && (it == 'f' \|\| it == 'b')) word_spec = *it++;
	72	if (it != end && *it != '}') throw format_error("invalid format");
	73	return it;
	74	}
	75	template <typename FormatContext>
	76	constexpr auto format(test_formattable, FormatContext& ctx) const
	77	-> decltype(ctx.out()) {
	78	return formatter<const char*>::format(word_spec == 'f' ? "foo" : "bar",
	79	ctx);
	80	}
	81	};
	82	FMT_END_NAMESPACE
	83
	84	TEST(compile_test, format_default) {
	85	EXPECT_EQ("42", fmt::format(FMT_COMPILE("{}"), 42));
	86	EXPECT_EQ("42", fmt::format(FMT_COMPILE("{}"), 42u));
	87	EXPECT_EQ("42", fmt::format(FMT_COMPILE("{}"), 42ll));
	88	EXPECT_EQ("42", fmt::format(FMT_COMPILE("{}"), 42ull));
	89	EXPECT_EQ("true", fmt::format(FMT_COMPILE("{}"), true));
	90	EXPECT_EQ("x", fmt::format(FMT_COMPILE("{}"), 'x'));
	91	EXPECT_EQ("4.2", fmt::format(FMT_COMPILE("{}"), 4.2));
	92	EXPECT_EQ("foo", fmt::format(FMT_COMPILE("{}"), "foo"));
	93	EXPECT_EQ("foo", fmt::format(FMT_COMPILE("{}"), std::string("foo")));
	94	EXPECT_EQ("foo", fmt::format(FMT_COMPILE("{}"), test_formattable()));
	95	auto t = std::chrono::system_clock::now();
	96	EXPECT_EQ(fmt::format("{}", t), fmt::format(FMT_COMPILE("{}"), t));
	97	# ifdef __cpp_lib_byte
	98	EXPECT_EQ("42", fmt::format(FMT_COMPILE("{}"), std::byte{42}));
	99	# endif
f67539c2 TL	100	}
f67539c2 TL	101
20effc67 TL	102	TEST(compile_test, format_wide_string) {
20effc67 TL	103	EXPECT_EQ(L"42", fmt::format(FMT_COMPILE(L"{}"), 42));
f67539c2 TL	104	}
f67539c2 TL	105
20effc67 TL	106	TEST(compile_test, format_specs) {
	107	EXPECT_EQ("42", fmt::format(FMT_COMPILE("{:x}"), 0x42));
	108	EXPECT_EQ("1.2 ms ",
	109	fmt::format(FMT_COMPILE("{:7.1%Q %q}"),
	110	std::chrono::duration<double, std::milli>(1.234)));
f67539c2 TL	111	}
f67539c2 TL	112
20effc67 TL	113	TEST(compile_test, dynamic_format_specs) {
	114	EXPECT_EQ("foo ", fmt::format(FMT_COMPILE("{:{}}"), "foo", 5));
	115	EXPECT_EQ(" 3.14", fmt::format(FMT_COMPILE("{:{}.{}f}"), 3.141592, 6, 2));
	116	EXPECT_EQ(
	117	"=1.234ms=",
	118	fmt::format(FMT_COMPILE("{:=^{}.{}}"),
	119	std::chrono::duration<double, std::milli>(1.234), 9, 3));
f67539c2 TL	120	}
f67539c2 TL	121
20effc67 TL	122	TEST(compile_test, manual_ordering) {
	123	EXPECT_EQ("42", fmt::format(FMT_COMPILE("{0}"), 42));
	124	EXPECT_EQ(" -42", fmt::format(FMT_COMPILE("{0:4}"), -42));
	125	EXPECT_EQ("41 43", fmt::format(FMT_COMPILE("{0} {1}"), 41, 43));
	126	EXPECT_EQ("41 43", fmt::format(FMT_COMPILE("{1} {0}"), 43, 41));
	127	EXPECT_EQ("41 43", fmt::format(FMT_COMPILE("{0} {2}"), 41, 42, 43));
	128	EXPECT_EQ(" 41 43", fmt::format(FMT_COMPILE("{1:{2}} {0:4}"), 43, 41, 4));
	129	EXPECT_EQ("42 1.2 ms ",
	130	fmt::format(FMT_COMPILE("{0} {1:7.1%Q %q}"), 42,
	131	std::chrono::duration<double, std::milli>(1.234)));
	132	EXPECT_EQ(
	133	"true 42 42 foo 0x1234 foo",
	134	fmt::format(FMT_COMPILE("{0} {1} {2} {3} {4} {5}"), true, 42, 42.0f,
	135	"foo", reinterpret_cast<void*>(0x1234), test_formattable()));
	136	EXPECT_EQ(L"42", fmt::format(FMT_COMPILE(L"{0}"), 42));
f67539c2 TL	137	}
f67539c2 TL	138
20effc67 TL	139	TEST(compile_test, named) {
	140	auto runtime_named_field_compiled =
	141	fmt::detail::compile<decltype(fmt::arg("arg", 42))>(FMT_COMPILE("{arg}"));
	142	static_assert(std::is_same_v<decltype(runtime_named_field_compiled),
	143	fmt::detail::runtime_named_field<char>>);
	144
	145	EXPECT_EQ("42", fmt::format(FMT_COMPILE("{}"), fmt::arg("arg", 42)));
	146	EXPECT_EQ("41 43", fmt::format(FMT_COMPILE("{} {}"), fmt::arg("arg", 41),
	147	fmt::arg("arg", 43)));
	148
	149	EXPECT_EQ("foobar",
	150	fmt::format(FMT_COMPILE("{a0}{a1}"), fmt::arg("a0", "foo"),
	151	fmt::arg("a1", "bar")));
	152	EXPECT_EQ("foobar", fmt::format(FMT_COMPILE("{}{a1}"), fmt::arg("a0", "foo"),
	153	fmt::arg("a1", "bar")));
	154	EXPECT_EQ("foofoo", fmt::format(FMT_COMPILE("{a0}{}"), fmt::arg("a0", "foo"),
	155	fmt::arg("a1", "bar")));
	156	EXPECT_EQ("foobar", fmt::format(FMT_COMPILE("{0}{a1}"), fmt::arg("a0", "foo"),
	157	fmt::arg("a1", "bar")));
	158	EXPECT_EQ("foobar", fmt::format(FMT_COMPILE("{a0}{1}"), fmt::arg("a0", "foo"),
	159	fmt::arg("a1", "bar")));
	160
	161	EXPECT_EQ("foobar",
	162	fmt::format(FMT_COMPILE("{}{a1}"), "foo", fmt::arg("a1", "bar")));
	163	EXPECT_EQ("foobar",
	164	fmt::format(FMT_COMPILE("{a0}{a1}"), fmt::arg("a1", "bar"),
	165	fmt::arg("a2", "baz"), fmt::arg("a0", "foo")));
	166	EXPECT_EQ(" bar foo ",
	167	fmt::format(FMT_COMPILE(" {foo} {bar} "), fmt::arg("foo", "bar"),
	168	fmt::arg("bar", "foo")));
	169
	170	EXPECT_THROW(fmt::format(FMT_COMPILE("{invalid}"), fmt::arg("valid", 42)),
	171	fmt::format_error);
	172
	173	# if FMT_USE_NONTYPE_TEMPLATE_PARAMETERS
	174	using namespace fmt::literals;
	175	auto statically_named_field_compiled =
	176	fmt::detail::compile<decltype("arg"_a = 42)>(FMT_COMPILE("{arg}"));
	177	static_assert(std::is_same_v<decltype(statically_named_field_compiled),
	178	fmt::detail::field<char, int, 0>>);
	179
	180	EXPECT_EQ("41 43",
	181	fmt::format(FMT_COMPILE("{a0} {a1}"), "a0"_a = 41, "a1"_a = 43));
	182	EXPECT_EQ("41 43",
	183	fmt::format(FMT_COMPILE("{a1} {a0}"), "a0"_a = 43, "a1"_a = 41));
	184	# endif
	185	}
	186
	187	TEST(compile_test, format_to) {
	188	char buf[8];
	189	auto end = fmt::format_to(buf, FMT_COMPILE("{}"), 42);
	190	*end = '\0';
	191	EXPECT_STREQ("42", buf);
	192	end = fmt::format_to(buf, FMT_COMPILE("{:x}"), 42);
	193	*end = '\0';
	194	EXPECT_STREQ("2a", buf);
	195	}
	196
	197	TEST(compile_test, format_to_n) {
	198	constexpr auto buffer_size = 8;
	199	char buffer[buffer_size];
	200	auto res = fmt::format_to_n(buffer, buffer_size, FMT_COMPILE("{}"), 42);
	201	*res.out = '\0';
	202	EXPECT_STREQ("42", buffer);
203	res = fmt::format_to_n(buffer, buffer_size, FMT_COMPILE("{:x}"), 42);
204	*res.out = '\0';
205	EXPECT_STREQ("2a", buffer);
206	}
207
208	TEST(compile_test, formatted_size) {
209	EXPECT_EQ(2, fmt::formatted_size(FMT_COMPILE("{0}"), 42));
210	EXPECT_EQ(5, fmt::formatted_size(FMT_COMPILE("{0:<4.2f}"), 42.0));
211	}
212
213	TEST(compile_test, text_and_arg) {
214	EXPECT_EQ(">>>42<<<", fmt::format(FMT_COMPILE(">>>{}<<<"), 42));
215	EXPECT_EQ("42!", fmt::format(FMT_COMPILE("{}!"), 42));
216	}
217
218	TEST(compile_test, unknown_format_fallback) {
219	EXPECT_EQ(" 42 ",
220	fmt::format(FMT_COMPILE("{name:^4}"), fmt::arg("name", 42)));
221
222	std::vector<char> v;
223	fmt::format_to(std::back_inserter(v), FMT_COMPILE("{name:^4}"),
224	fmt::arg("name", 42));
225	EXPECT_EQ(" 42 ", fmt::string_view(v.data(), v.size()));
226
227	char buffer[4];
228	auto result = fmt::format_to_n(buffer, 4, FMT_COMPILE("{name:^5}"),
229	fmt::arg("name", 42));
230	EXPECT_EQ(5u, result.size);
231	EXPECT_EQ(buffer + 4, result.out);
232	EXPECT_EQ(" 42 ", fmt::string_view(buffer, 4));
233	}
234
235	TEST(compile_test, empty) { EXPECT_EQ("", fmt::format(FMT_COMPILE(""))); }
236
237	struct to_stringable {
238	friend fmt::string_view to_string_view(to_stringable) { return {}; }
239	};
f67539c2 TL	240
f67539c2 TL	241	FMT_BEGIN_NAMESPACE
20effc67 TL	242	template <> struct formatter<to_stringable> {
	243	auto parse(format_parse_context& ctx) const -> decltype(ctx.begin()) {
	244	return ctx.begin();
	245	}
	246
	247	template <typename FormatContext>
	248	auto format(const to_stringable&, FormatContext& ctx) -> decltype(ctx.out()) {
	249	return ctx.out();
f67539c2 TL	250	}
	251	};
	252	FMT_END_NAMESPACE
	253
20effc67 TL	254	TEST(compile_test, to_string_and_formatter) {
20effc67 TL	255	fmt::format(FMT_COMPILE("{}"), to_stringable());
f67539c2 TL	256	}
f67539c2 TL	257
20effc67 TL	258	TEST(compile_test, print) {
	259	EXPECT_WRITE(stdout, fmt::print(FMT_COMPILE("Don't {}!"), "panic"),
	260	"Don't panic!");
	261	EXPECT_WRITE(stderr, fmt::print(stderr, FMT_COMPILE("Don't {}!"), "panic"),
	262	"Don't panic!");
f67539c2	263	}
20effc67 TL	264	#endif
	265
	266	#if FMT_USE_NONTYPE_TEMPLATE_PARAMETERS
	267	TEST(compile_test, compile_format_string_literal) {
	268	using namespace fmt::literals;
	269	EXPECT_EQ("", fmt::format(""_cf));
	270	EXPECT_EQ("42", fmt::format("{}"_cf, 42));
	271	EXPECT_EQ(L"42", fmt::format(L"{}"_cf, 42));
	272	}
	273	#endif
	274
	275	#if __cplusplus >= 202002L \|\| \
	276	(__cplusplus >= 201709L && FMT_GCC_VERSION >= 1002)
	277	template <size_t max_string_length, typename Char = char> struct test_string {
	278	template <typename T> constexpr bool operator==(const T& rhs) const noexcept {
	279	return fmt::basic_string_view<Char>(rhs).compare(buffer) == 0;
	280	}
	281	Char buffer[max_string_length]{};
	282	};
	283
	284	template <size_t max_string_length, typename Char = char, typename... Args>
	285	consteval auto test_format(auto format, const Args&... args) {
	286	test_string<max_string_length, Char> string{};
	287	fmt::format_to(string.buffer, format, args...);
	288	return string;
	289	}
	290
	291	TEST(compile_time_formatting_test, bool) {
	292	EXPECT_EQ("true", test_format<5>(FMT_COMPILE("{}"), true));
	293	EXPECT_EQ("false", test_format<6>(FMT_COMPILE("{}"), false));
	294	EXPECT_EQ("true ", test_format<6>(FMT_COMPILE("{:5}"), true));
	295	EXPECT_EQ("1", test_format<2>(FMT_COMPILE("{:d}"), true));
	296	}
	297
	298	TEST(compile_time_formatting_test, integer) {
	299	EXPECT_EQ("42", test_format<3>(FMT_COMPILE("{}"), 42));
	300	EXPECT_EQ("420", test_format<4>(FMT_COMPILE("{}"), 420));
	301	EXPECT_EQ("42 42", test_format<6>(FMT_COMPILE("{} {}"), 42, 42));
	302	EXPECT_EQ("42 42",
	303	test_format<6>(FMT_COMPILE("{} {}"), uint32_t{42}, uint64_t{42}));
	304
	305	EXPECT_EQ("+42", test_format<4>(FMT_COMPILE("{:+}"), 42));
	306	EXPECT_EQ("42", test_format<3>(FMT_COMPILE("{:-}"), 42));
	307	EXPECT_EQ(" 42", test_format<4>(FMT_COMPILE("{: }"), 42));
	308
	309	EXPECT_EQ("-0042", test_format<6>(FMT_COMPILE("{:05}"), -42));
	310
	311	EXPECT_EQ("101010", test_format<7>(FMT_COMPILE("{:b}"), 42));
	312	EXPECT_EQ("0b101010", test_format<9>(FMT_COMPILE("{:#b}"), 42));
	313	EXPECT_EQ("0B101010", test_format<9>(FMT_COMPILE("{:#B}"), 42));
	314	EXPECT_EQ("042", test_format<4>(FMT_COMPILE("{:#o}"), 042));
	315	EXPECT_EQ("0x4a", test_format<5>(FMT_COMPILE("{:#x}"), 0x4a));
	316	EXPECT_EQ("0X4A", test_format<5>(FMT_COMPILE("{:#X}"), 0x4a));
	317
	318	EXPECT_EQ(" 42", test_format<6>(FMT_COMPILE("{:5}"), 42));
	319	EXPECT_EQ(" 42", test_format<6>(FMT_COMPILE("{:5}"), 42ll));
	320	EXPECT_EQ(" 42", test_format<6>(FMT_COMPILE("{:5}"), 42ull));
	321
	322	EXPECT_EQ("42 ", test_format<5>(FMT_COMPILE("{:<4}"), 42));
	323	EXPECT_EQ(" 42", test_format<5>(FMT_COMPILE("{:>4}"), 42));
	324	EXPECT_EQ(" 42 ", test_format<5>(FMT_COMPILE("{:^4}"), 42));
	325	EXPECT_EQ("*-42", test_format<6>(FMT_COMPILE("{:>5}"), -42));
	326	}
	327
328	TEST(compile_time_formatting_test, char) {
329	EXPECT_EQ("c", test_format<2>(FMT_COMPILE("{}"), 'c'));
330
331	EXPECT_EQ("c ", test_format<4>(FMT_COMPILE("{:3}"), 'c'));
332	EXPECT_EQ("99", test_format<3>(FMT_COMPILE("{:d}"), 'c'));
333	}
334
335	TEST(compile_time_formatting_test, string) {
336	EXPECT_EQ("42", test_format<3>(FMT_COMPILE("{}"), "42"));
337	EXPECT_EQ("The answer is 42",
338	test_format<17>(FMT_COMPILE("{} is {}"), "The answer", "42"));
339
340	EXPECT_EQ("abc*", test_format<6>(FMT_COMPILE("{:<5}"), "abc"));
341	EXPECT_EQ("🤡", test_format<9>(FMT_COMPILE("{:*^6}"), "🤡"));
342	}
343
344	TEST(compile_time_formatting_test, combination) {
345	EXPECT_EQ("420, true, answer",
346	test_format<18>(FMT_COMPILE("{}, {}, {}"), 420, true, "answer"));
347
348	EXPECT_EQ(" -42", test_format<5>(FMT_COMPILE("{:{}}"), -42, 4));
349	}
350
351	TEST(compile_time_formatting_test, custom_type) {
352	EXPECT_EQ("foo", test_format<4>(FMT_COMPILE("{}"), test_formattable()));
353	EXPECT_EQ("bar", test_format<4>(FMT_COMPILE("{:b}"), test_formattable()));
354	}
355
356	TEST(compile_time_formatting_test, multibyte_fill) {
357	EXPECT_EQ("жж42", test_format<8>(FMT_COMPILE("{:ж>4}"), 42));
358	}
359	#endif