#include "detail/tuple_types.hpp"

#include <stdx/ct_format.hpp>

#include <stdx/utility.hpp>

#include <catch2/catch_test_macros.hpp>

#include <array>

#include <limits>

#include <string_view>

#include <type_traits>

using namespace stdx::ct_string_literals;

TEST_CASE("detect string format specifiers", "[ct_format]") {

using namespace std::string_view_literals;

STATIC_CHECK(stdx::detail::count_specifiers("{}"sv) == 1u);

STATIC_CHECK(stdx::detail::count_specifiers("{} {}"sv) == 2u);

STATIC_CHECK(stdx::detail::count_specifiers("{"sv) == 0u);

STATIC_CHECK(stdx::detail::count_specifiers("{{"sv) == 0u);

STATIC_CHECK(stdx::detail::count_specifiers("{{{}"sv) == 1u);

STATIC_CHECK(stdx::detail::count_specifiers("{{}}"sv) == 0u);

STATIC_CHECK(stdx::detail::count_specifiers("{{{{"sv) == 0u);

}

TEST_CASE("split format string by specifiers", "[ct_format]") {

using namespace std::string_view_literals;

using SS = stdx::detail::split_spec;

STATIC_CHECK(stdx::detail::split_specifiers<1>("hello"sv) ==

std::array{SS{"hello"sv, 5}});

STATIC_CHECK(stdx::detail::split_specifiers<2>("{}"sv) ==

std::array{SS{"{}"sv, 0}, SS{""sv, 0}});

STATIC_CHECK(stdx::detail::split_specifiers<3>("{} {}"sv) ==

std::array{SS{"{}"sv, 0}, SS{" {}"sv, 1}, SS{""sv, 0}});

STATIC_CHECK(stdx::detail::split_specifiers<2>("{{{}"sv) ==

std::array{SS{"{{{}"sv, 2}, SS{""sv, 0}});

STATIC_CHECK(stdx::detail::split_specifiers<2>("{} hello"sv) ==

std::array{SS{"{}"sv, 0}, SS{" hello"sv, 6}});

}

TEST_CASE("extract name and format string", "[ct_format]") {

using namespace std::string_view_literals;

STATIC_CHECK(stdx::detail::extract_format1_str<"{}", 0>() ==

std::pair{"{}"_cts, ""_cts});

STATIC_CHECK(stdx::detail::extract_format1_str<"{:}", 0>() ==

std::pair{"{:}"_cts, ""_cts});

STATIC_CHECK(stdx::detail::extract_format1_str<"abc{}", 3>() ==

std::pair{"abc{}"_cts, ""_cts});

STATIC_CHECK(stdx::detail::extract_format1_str<"abc{xyz:}", 3>() ==

std::pair{"abc{:}"_cts, "xyz"_cts});

STATIC_CHECK(stdx::detail::extract_format1_str<"abc{xyz}", 3>() ==

std::pair{"abc{}"_cts, "xyz"_cts});

}

TEST_CASE("format a static string", "[ct_format]") {

STATIC_CHECK(stdx::ct_format<"Hello">() == "Hello"_fmt_res);

}

TEST_CASE("format a compile-time stringish argument (CX_VALUE)",

"[ct_format]") {

using namespace std::string_view_literals;

STATIC_REQUIRE(stdx::ct_format<"Hello {}">(CX_VALUE("world"sv)) ==

"Hello world"_fmt_res);

STATIC_REQUIRE(stdx::ct_format<"Hello {}">(CX_VALUE("world"_cts)) ==

"Hello world"_fmt_res);

STATIC_REQUIRE(stdx::ct_format<"Hello {}">(CX_VALUE("world")) ==

"Hello world"_fmt_res);

}

TEST_CASE("format a compile-time stringish argument (ct)", "[ct_format]") {

using namespace std::string_view_literals;

STATIC_REQUIRE(stdx::ct_format<"Hello {}">("world"_ctst) ==

"Hello world"_fmt_res);

STATIC_REQUIRE(stdx::ct_format<"Hello {}">(stdx::ct<"world">()) ==

"Hello world"_fmt_res);

}

TEST_CASE("format a compile-time integral argument (CX_VALUE)", "[ct_format]") {

STATIC_REQUIRE(stdx::ct_format<"Hello {}">(CX_VALUE(42)) ==

"Hello 42"_fmt_res);

}

TEST_CASE("format a negative compile-time integral argument (CX_VALUE)",

"[ct_format]") {

STATIC_REQUIRE(stdx::ct_format<"Hello {}">(CX_VALUE(-42)) ==

"Hello -42"_fmt_res);

}

TEST_CASE("format most negative compile-time integral argument (CX_VALUE)",

"[ct_format]") {

STATIC_REQUIRE(stdx::ct_format<"Hello {}">(

CX_VALUE(std::numeric_limits<int>::min())) ==

"Hello -2147483648"_fmt_res);

}

TEST_CASE("format zero (CX_VALUE)", "[ct_format]") {

STATIC_REQUIRE(stdx::ct_format<"Hello {}">(CX_VALUE(0)) ==

"Hello 0"_fmt_res);

}

TEST_CASE("format a char (CX_VALUE)", "[ct_format]") {

STATIC_REQUIRE(stdx::ct_format<"Hello {}orld">(CX_VALUE('w')) ==

"Hello world"_fmt_res);

}

#ifndef STDX_FREESTANDING

namespace move_test {

struct move_only {

constexpr move_only() = default;

constexpr move_only(int x) : value{x} {}

constexpr move_only(move_only &&) = default;

constexpr auto operator=(move_only &&) noexcept -> move_only & = default;

friend constexpr auto operator==(move_only const &, move_only const &)

-> bool = default;

int value;

};

[[nodiscard]] constexpr auto format_as(move_only const &) -> std::string_view {

return "17";

}

} // namespace move_test

TEST_CASE("format a move-only argument (CX_VALUE)", "[ct_format]") {

STATIC_CHECK(stdx::ct_format<"Hello {}">(

CX_VALUE(move_test::move_only{17})) == "Hello 17"_fmt_res);

}

#endif

TEST_CASE("format a compile-time integral argument (ct)", "[ct_format]") {

STATIC_REQUIRE(stdx::ct_format<"Hello {}">(stdx::ct<42>()) ==

"Hello 42"_fmt_res);

}

TEST_CASE("format a type argument (CX_VALUE)", "[ct_format]") {

STATIC_REQUIRE(stdx::ct_format<"Hello {}">(CX_VALUE(int)) ==

"Hello int"_fmt_res);

}

TEST_CASE("format a type argument (ct)", "[ct_format]") {

STATIC_REQUIRE(stdx::ct_format<"Hello {}">(stdx::ct<int>()) ==

"Hello int"_fmt_res);

}

TEST_CASE("format a compile-time argument with different base", "[ct_format]") {

STATIC_REQUIRE(stdx::ct_format<"Hello 0x{:x}">(CX_VALUE(42)) ==

"Hello 0x2a"_fmt_res);

}

#ifndef STDX_FREESTANDING

TEST_CASE("format a compile-time argument with fmt spec", "[ct_format]") {

STATIC_REQUIRE(stdx::ct_format<"Hello {:*>#6x}">(CX_VALUE(42)) ==

"Hello **0x2a"_fmt_res);

}

#endif

namespace {

enum struct E { A };

}

TEST_CASE("format a compile-time enum argument (CX_VALUE)", "[ct_format]") {

STATIC_REQUIRE(stdx::ct_format<"Hello {}">(CX_VALUE(E::A)) ==

"Hello A"_fmt_res);

}

TEST_CASE("format a compile-time enum argument (ct)", "[ct_format]") {

STATIC_REQUIRE(stdx::ct_format<"Hello {}">(stdx::ct<E::A>()) ==

"Hello A"_fmt_res);

}

TEST_CASE("format multiple compile-time arguments", "[ct_format]") {

STATIC_CHECK(

stdx::ct_format<"Hello {} {}">(CX_VALUE(E::A), CX_VALUE("world")) ==

"Hello A world"_fmt_res);

}

TEST_CASE("format a runtime argument", "[ct_format]") {

constexpr auto x = 17;

constexpr auto expected =

stdx::make_format_result("Hello {}"_ctst, stdx::make_tuple(x));

CHECK(stdx::ct_format<"Hello {}">(x) == expected);

STATIC_CHECK(stdx::ct_format<"Hello {}">(x) == expected);

}

TEST_CASE("format a move-only runtime argument", "[ct_format]") {

constexpr auto expected =

stdx::make_format_result("Hello {}"_ctst, stdx::tuple{move_only{17}});

CHECK(stdx::ct_format<"Hello {}">(move_only{17}) == expected);

STATIC_CHECK(stdx::ct_format<"Hello {}">(move_only{17}) == expected);

}

TEST_CASE("format a compile-time and a runtime argument (1)", "[ct_format]") {

constexpr auto x = 17;

constexpr auto expected =

stdx::make_format_result("Hello int {}"_ctst, stdx::make_tuple(x));

CHECK(stdx::ct_format<"Hello {} {}">(CX_VALUE(int), x) == expected);

STATIC_CHECK(stdx::ct_format<"Hello {} {}">(CX_VALUE(int), x) == expected);

}

TEST_CASE("format a compile-time and a runtime argument (2)", "[ct_format]") {

STATIC_REQUIRE(

stdx::ct_format<"Hello {} {}">(42, CX_VALUE(int)) ==

stdx::make_format_result("Hello {} int"_ctst, stdx::make_tuple(42)));

}

TEST_CASE("format multiple runtime arguments", "[ct_format]") {

STATIC_CHECK(

stdx::ct_format<"Hello {} {}">(42, 17) ==

stdx::make_format_result("Hello {} {}"_ctst, stdx::make_tuple(42, 17)));

}

TEST_CASE("format multiple mixed arguments", "[ct_format]") {

using namespace std::string_view_literals;

auto b = "B"sv;

constexpr auto expected = stdx::make_format_result(

"Hello {} A {} int world"_ctst, stdx::make_tuple(42, "B"sv));

CHECK(stdx::ct_format<"Hello {} {} {} {} world">(

42, CX_VALUE("A"sv), b, CX_VALUE(int)) == expected);

STATIC_CHECK(stdx::ct_format<"Hello {} {} {} {} world">(

42, CX_VALUE("A"sv), "B"sv, CX_VALUE(int)) == expected);

}

TEST_CASE("format a format result", "[ct_format]") {

STATIC_REQUIRE(stdx::ct_format<"The value is {}.">(

stdx::ct_format<"(year={})">(2022)) ==

stdx::make_format_result("The value is (year={})."_ctst,

stdx::make_tuple(2022)));

}

TEST_CASE("format an empty format result", "[ct_format]") {

STATIC_CHECK(stdx::ct_format<"The value is {}.">("2022"_fmt_res) ==

"The value is 2022."_fmt_res);

}

namespace {

template <stdx::ct_string> constexpr auto conversion_success = true;

} // namespace

TEST_CASE("empty format_result can implicitly convert to ct_string",

"[ct_format]") {

using namespace std::string_view_literals;

STATIC_CHECK(

stdx::detail::format_convertible<decltype(stdx::ct_format<"Hello">())>);

STATIC_CHECK(stdx::detail::format_convertible<

decltype(stdx::ct_format<"Hello {}">("world"_ctst))>);

STATIC_CHECK(not stdx::detail::format_convertible<

decltype(stdx::ct_format<"Hello {}">(42))>);

STATIC_CHECK(conversion_success<stdx::ct_format<"Hello">()>);

}

TEST_CASE("empty format_result can explicitly convert to ct_string",

"[ct_format]") {

using namespace std::string_view_literals;

STATIC_CHECK(+stdx::ct_format<"Hello">() == "Hello"_cts);

}

namespace {

template <typename T, T...> struct string_constant {

private:

friend constexpr auto operator==(string_constant const &,

string_constant const &) -> bool = default;

};

template <class T, T... Ls, T... Rs>

[[nodiscard]] constexpr auto operator+(string_constant<T, Ls...>,

string_constant<T, Rs...>) noexcept

-> string_constant<T, Ls..., Rs...> {

return {};

}

} // namespace

TEST_CASE("format_to a different type (compile-time value)", "[ct_format]") {

using namespace std::string_view_literals;

constexpr auto expected =

stdx::make_format_result(string_constant<char, 'A'>{});

STATIC_CHECK(stdx::ct_format<"{}", string_constant>(CX_VALUE("A"sv)) ==

expected);

}

TEST_CASE("format_to a different type (runtime value)", "[ct_format]") {

using namespace std::string_view_literals;

constexpr auto expected = stdx::make_format_result(

string_constant<char, '{', '}'>{}, stdx::tuple{17});

CHECK(stdx::ct_format<"{}", string_constant>(17) == expected);

STATIC_CHECK(stdx::ct_format<"{}", string_constant>(17) == expected);

}

TEST_CASE("format a string-type argument", "[ct_format]") {

STATIC_CHECK(stdx::ct_format<"Hello {}!">(string_constant<char, 'A'>{}) ==

"Hello A!"_fmt_res);

}

TEST_CASE("format a format result with different type", "[ct_format]") {

constexpr auto expected = stdx::make_format_result(

string_constant<char, 'A', 'B', '{', '}', 'C', 'D'>{},

stdx::tuple{2022});

STATIC_CHECK(stdx::ct_format<"A{}D", string_constant>(

stdx::ct_format<"B{}C", string_constant>(2022)) ==

expected);

}

TEST_CASE("format multiple mixed arguments with different type",

"[ct_format]") {

using namespace std::string_view_literals;

auto b = "B"sv;

constexpr auto expected = stdx::make_format_result(

stdx::ct_string_to_type<"Hello {} A {} int world"_cts,

string_constant>(),

stdx::tuple{42, "B"sv});

CHECK(stdx::ct_format<"Hello {} {} {} {} world", string_constant>(

42, CX_VALUE("A"sv), b, CX_VALUE(int)) == expected);

STATIC_CHECK(stdx::ct_format<"Hello {} {} {} {} world", string_constant>(

42, CX_VALUE("A"sv), "B"sv, CX_VALUE(int)) == expected);

}

TEST_CASE("num fmt specifiers", "[ct_format]") {

STATIC_REQUIRE(stdx::num_fmt_specifiers<"{}"> == 1u);

STATIC_REQUIRE(stdx::num_fmt_specifiers<"{} {}"> == 2u);

}

namespace user {

struct S {

int x;

};

constexpr auto ct_format_as(S const &s) {

return stdx::ct_format<"S: {}">(s.x);

}

} // namespace user

TEST_CASE("user-defined formatting", "[ct_format]") {

constexpr auto expected =

stdx::make_format_result("Hello S: {}"_ctst, stdx::tuple{17});

auto r = stdx::ct_format<"Hello {}">(user::S{17});

CHECK(r == expected);

}

TEST_CASE("FORMAT with no arguments", "[ct_format]") {

STATIC_CHECK(STDX_CT_FORMAT("Hello") == "Hello"_fmt_res);

}

TEST_CASE("FORMAT a compile-time string argument", "[ct_format]") {

STATIC_CHECK(STDX_CT_FORMAT("Hello {}", "world") == "Hello world"_fmt_res);

}

TEST_CASE("FORMAT a compile-time int argument", "[ct_format]") {

STATIC_REQUIRE(STDX_CT_FORMAT("Hello {}", 17) == "Hello 17"_fmt_res);

}

TEST_CASE("FORMAT a type argument", "[ct_format]") {

STATIC_REQUIRE(STDX_CT_FORMAT("Hello {}", int) == "Hello int"_fmt_res);

}

TEST_CASE("FORMAT a constexpr ct_string argument", "[ct_format]") {

constexpr static auto S = "world"_cts;

STATIC_REQUIRE(STDX_CT_FORMAT("Hello {}", S) == "Hello world"_fmt_res);

}

TEST_CASE("FORMAT a cts_t argument", "[ct_format]") {

auto S = "world"_ctst;

STATIC_REQUIRE(STDX_CT_FORMAT("Hello {}", S) == "Hello world"_fmt_res);

}

TEST_CASE("FORMAT a format_result argument", "[ct_format]") {

constexpr auto expected = stdx::make_format_result(

"The value is (year={})."_ctst, stdx::tuple{2022});

auto S = stdx::ct_format<"(year={})">(2022);

CHECK(STDX_CT_FORMAT("The value is {}.", S) == expected);

}

TEST_CASE("FORMAT an empty format_result argument", "[ct_format]") {

auto S = "world"_fmt_res;

STATIC_REQUIRE(STDX_CT_FORMAT("Hello {}", S) == "Hello world"_fmt_res);

}

TEST_CASE("FORMAT a constexpr int argument", "[ct_format]") {

constexpr static auto I = 17;

STATIC_REQUIRE(STDX_CT_FORMAT("Hello {}", I) == "Hello 17"_fmt_res);

}

#ifdef __clang__

TEST_CASE("FORMAT a constexpr nonstatic string_view argument", "[ct_format]") {

constexpr auto S = std::string_view{"world"};

constexpr auto expected =

stdx::make_format_result("Hello {}"_ctst, stdx::make_tuple(S));

STATIC_REQUIRE(STDX_CT_FORMAT("Hello {}", S) == expected);

}

#endif

TEST_CASE("FORMAT a constexpr string_view argument", "[ct_format]") {

constexpr static auto S = std::string_view{"world"};

STATIC_REQUIRE(STDX_CT_FORMAT("Hello {}", S) == "Hello world"_fmt_res);

}

TEST_CASE("FORMAT an integral_constant argument", "[ct_format]") {

auto I = std::integral_constant<unsigned int, 17u>{};

STATIC_REQUIRE(STDX_CT_FORMAT("Hello {}", I) == "Hello 17"_fmt_res);

}

#ifdef __clang__

namespace {

struct expression_test {

int f(int x) { return x; }

};

} // namespace

TEST_CASE("FORMAT non-constexpr expression", "[utility]") {

auto x = 17;

constexpr auto expected =

stdx::make_format_result("Hello {}"_ctst, stdx::make_tuple(17));

CHECK(STDX_CT_FORMAT("Hello {}", expression_test{}.f(x)) == expected);

}

#endif

TEST_CASE("format a named runtime argument", "[ct_format]") {

constexpr auto x = 17;

using expected_named_t = stdx::type_list<stdx::named_arg<"x", int, 0>>;

constexpr auto expected = stdx::make_format_result<expected_named_t>(

"Hello {}"_ctst, stdx::make_tuple(x));

CHECK(stdx::ct_format<"Hello {x}">(x) == expected);

STATIC_CHECK(stdx::ct_format<"Hello {x}">(x) == expected);

}

TEST_CASE("format two named runtime arguments", "[ct_format]") {

constexpr auto x = 17;

constexpr auto y = 18;

using expected_named_t = stdx::type_list<stdx::named_arg<"x", int, 0>,

stdx::named_arg<"y", int, 1>>;

constexpr auto expected = stdx::make_format_result<expected_named_t>(

"Hello {} {}"_ctst, stdx::make_tuple(x, y));

CHECK(stdx::ct_format<"Hello {x} {y}">(x, y) == expected);

STATIC_CHECK(stdx::ct_format<"Hello {x} {y}">(x, y) == expected);

}

TEST_CASE("format two runtime arguments, only one named", "[ct_format]") {

constexpr auto x = 17;

constexpr auto y = 18;

using expected_named_t = stdx::type_list<stdx::named_arg<"y", int, 1>>;

constexpr auto expected = stdx::make_format_result<expected_named_t>(

"Hello {} {}"_ctst, stdx::make_tuple(x, y));

CHECK(stdx::ct_format<"Hello {} {y}">(x, y) == expected);

STATIC_CHECK(stdx::ct_format<"Hello {} {y}">(x, y) == expected);

}

TEST_CASE("format a named compile-time argument", "[ct_format]") {

using expected_named_t = stdx::type_list<stdx::named_arg<"x", int, 6, 8>>;

constexpr auto expected =

stdx::make_format_result<expected_named_t>("Hello 17"_ctst);

STATIC_CHECK(STDX_CT_FORMAT("Hello {x}", 17) == expected);

}

TEST_CASE("format two named compile-time arguments", "[ct_format]") {

using expected_named_t = stdx::type_list<stdx::named_arg<"x", int, 6, 8>,

stdx::named_arg<"y", int, 9, 11>>;

constexpr auto expected =

stdx::make_format_result<expected_named_t>("Hello 17 18"_ctst);

STATIC_CHECK(STDX_CT_FORMAT("Hello {x} {y}", 17, 18) == expected);

}

TEST_CASE("format two compile-time arguments, only one named", "[ct_format]") {

using expected_named_t = stdx::type_list<stdx::named_arg<"y", int, 9, 11>>;

constexpr auto expected =

stdx::make_format_result<expected_named_t>("Hello 17 18"_ctst);

STATIC_CHECK(STDX_CT_FORMAT("Hello {} {y}", 17, 18) == expected);

}

TEST_CASE("format mixed named arguments (1)", "[ct_format]") {

using expected_named_t = stdx::type_list<stdx::named_arg<"x", int, 6, 8>,

stdx::named_arg<"y", int, 0>>;

constexpr auto expected = stdx::make_format_result<expected_named_t>(

"Hello 17 {}"_ctst, stdx::tuple{18});

auto y = 18;

CHECK(STDX_CT_FORMAT("Hello {x} {y}", 17, y) == expected);

}

TEST_CASE("format mixed named arguments (2)", "[ct_format]") {

using expected_named_t = stdx::type_list<stdx::named_arg<"x", int, 0>,

stdx::named_arg<"y", int, 9, 11>>;

constexpr auto expected = stdx::make_format_result<expected_named_t>(

"Hello {} 18"_ctst, stdx::tuple{17});

auto x = 17;

CHECK(STDX_CT_FORMAT("Hello {x} {y}", x, 18) == expected);

}

TEST_CASE("format mixed named arguments (3)", "[ct_format]") {

using expected_named_t = stdx::type_list<

stdx::named_arg<"a", int, 0>, stdx::named_arg<"b", int, 9, 11>,

stdx::named_arg<"c", int, 1>, stdx::named_arg<"d", int, 15, 17>>;

constexpr auto expected = stdx::make_format_result<expected_named_t>(

"Hello {} 18 {} 20"_ctst, stdx::tuple{17, 19});

auto x = 17;

auto y = 19;

CHECK(STDX_CT_FORMAT("Hello {a} {b} {c} {d}", x, 18, y, 20) == expected);

}

TEST_CASE("format mixed named and unnamed arguments", "[ct_format]") {

using expected_named_t = stdx::type_list<

stdx::named_arg<"a", int, 0>, stdx::named_arg<"b", int, 9, 11>,

stdx::named_arg<"c", int, 2>, stdx::named_arg<"d", int, 21, 23>>;

constexpr auto expected = stdx::make_format_result<expected_named_t>(

"Hello {} 18 {} 20 {} 22"_ctst, stdx::tuple{17, 19, 21});

auto x = 17;

auto y = 19;

auto z = 21;

CHECK(STDX_CT_FORMAT("Hello {a} {b} {} {} {c} {d}", x, 18, y, 20, z, 22) ==

expected);

}

TEST_CASE("format a named argument with format spec", "[ct_format]") {

using expected_named_t = stdx::type_list<stdx::named_arg<"a", int, 6, 7>>;

constexpr auto expected =

stdx::make_format_result<expected_named_t>("Hello a"_ctst);

STATIC_CHECK(STDX_CT_FORMAT("Hello {a:x}", 10) == expected);

}

TEST_CASE("format a format_result with named rt argument (1/normal)",

"[ct_format]") {

using expected_named_t = stdx::type_list<stdx::named_arg<"y", int, 0>>;

constexpr auto expected = stdx::make_format_result<expected_named_t>(

"The value is (year={})."_ctst, stdx::tuple{2022});

auto S = stdx::ct_format<"(year={y})">(2022);

CHECK(STDX_CT_FORMAT("The value is {}.", S) == expected);

}

TEST_CASE("format a format_result with named rt argument (2/after rt arg)",

"[ct_format]") {

using expected_named_t = stdx::type_list<stdx::named_arg<"y", int, 1>>;

constexpr auto expected = stdx::make_format_result<expected_named_t>(

"The value is {} (year={})."_ctst, stdx::tuple{17, 2022});

auto S = stdx::ct_format<"(year={y})">(2022);

auto x = 17;

CHECK(STDX_CT_FORMAT("The value is {} {}.", x, S) == expected);

}

TEST_CASE("format a format_result with named rt argument (3/after ct arg)",

"[ct_format]") {

using expected_named_t = stdx::type_list<stdx::named_arg<"y", int, 0>>;

constexpr auto expected = stdx::make_format_result<expected_named_t>(

"The value is 17 (year={})."_ctst, stdx::tuple{2022});

auto S = stdx::ct_format<"(year={y})">(2022);

CHECK(STDX_CT_FORMAT("The value is {} {}.", 17, S) == expected);

}

TEST_CASE("format a format_result with named ct argument (1/normal)",

"[ct_format]") {

using expected_named_t = stdx::type_list<stdx::named_arg<"y", int, 19, 23>>;

constexpr auto expected = stdx::make_format_result<expected_named_t>(

"The value is (year=2022)."_ctst);

STDX_PRAGMA(diagnostic push)

STDX_PRAGMA(diagnostic ignored "-Wshadow")

CHECK(STDX_CT_FORMAT("The value is {}.",

STDX_CT_FORMAT("(year={y})", 2022)) == expected);

STDX_PRAGMA(diagnostic pop)

}

TEST_CASE("format a format_result with named ct argument (2/after ct arg)",

"[ct_format]") {

using expected_named_t = stdx::type_list<stdx::named_arg<"y", int, 22, 26>>;

constexpr auto expected = stdx::make_format_result<expected_named_t>(

"The value is 17 (year=2022)."_ctst);

STDX_PRAGMA(diagnostic push)

STDX_PRAGMA(diagnostic ignored "-Wshadow")

CHECK(STDX_CT_FORMAT("The value is {} {}.", 17,

STDX_CT_FORMAT("(year={y})", 2022)) == expected);

STDX_PRAGMA(diagnostic pop)

}

TEST_CASE("format a format_result with named ct argument (2/after rt arg)",

"[ct_format]") {

using expected_named_t = stdx::type_list<stdx::named_arg<"y", int, 22, 26>>;

constexpr auto expected = stdx::make_format_result<expected_named_t>(

"The value is {} (year=2022)."_ctst, stdx::tuple{17});

auto x = 17;

STDX_PRAGMA(diagnostic push)

STDX_PRAGMA(diagnostic ignored "-Wshadow")

CHECK(STDX_CT_FORMAT("The value is {} {}.", x,

STDX_CT_FORMAT("(year={y})", 2022)) == expected);

STDX_PRAGMA(diagnostic pop)

}