--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/dep/fmt/test/std-test.cc	Thu Jun 20 05:56:06 2024 -0400
@@ -0,0 +1,306 @@
+// Formatting library for C++ - tests of formatters for standard library types
+//
+// Copyright (c) 2012 - present, Victor Zverovich
+// All rights reserved.
+//
+// For the license information refer to format.h.
+
+#include "fmt/std.h"
+
+#include <bitset>
+#include <stdexcept>
+#include <string>
+#include <vector>
+
+#include "fmt/os.h"  // fmt::system_category
+#include "fmt/ranges.h"
+#include "gtest-extra.h"  // StartsWith
+
+#ifdef __cpp_lib_filesystem
+TEST(std_test, path) {
+  using std::filesystem::path;
+  EXPECT_EQ(fmt::format("{}", path("/usr/bin")), "/usr/bin");
+  EXPECT_EQ(fmt::format("{:?}", path("/usr/bin")), "\"/usr/bin\"");
+  EXPECT_EQ(fmt::format("{:8}", path("foo")), "foo     ");
+
+  EXPECT_EQ(fmt::format("{}", path("foo\"bar")), "foo\"bar");
+  EXPECT_EQ(fmt::format("{:?}", path("foo\"bar")), "\"foo\\\"bar\"");
+
+  EXPECT_EQ(fmt::format("{:g}", path("/usr/bin")), "/usr/bin");
+#  ifdef _WIN32
+  EXPECT_EQ(fmt::format("{}", path("C:\\foo")), "C:\\foo");
+  EXPECT_EQ(fmt::format("{:g}", path("C:\\foo")), "C:/foo");
+
+  EXPECT_EQ(fmt::format("{}", path(L"\x0428\x0447\x0443\x0447\x044B\x043D\x0448"
+                                   L"\x0447\x044B\x043D\x0430")),
+            "Шчучыншчына");
+  EXPECT_EQ(fmt::format("{}", path(L"\xd800")), "�");
+  EXPECT_EQ(fmt::format("{:?}", path(L"\xd800")), "\"\\ud800\"");
+#  endif
+}
+
+// Test ambiguity problem described in #2954.
+TEST(ranges_std_test, format_vector_path) {
+  auto p = std::filesystem::path("foo/bar.txt");
+  auto c = std::vector<std::string>{"abc", "def"};
+  EXPECT_EQ(fmt::format("path={}, range={}", p, c),
+            "path=foo/bar.txt, range=[\"abc\", \"def\"]");
+}
+
+// Test that path is not escaped twice in the debug mode.
+TEST(ranges_std_test, format_quote_path) {
+  auto vec =
+      std::vector<std::filesystem::path>{"path1/file1.txt", "path2/file2.txt"};
+  EXPECT_EQ(fmt::format("{}", vec),
+            "[\"path1/file1.txt\", \"path2/file2.txt\"]");
+#  ifdef __cpp_lib_optional
+  auto o = std::optional<std::filesystem::path>("path/file.txt");
+  EXPECT_EQ(fmt::format("{}", o), "optional(\"path/file.txt\")");
+  EXPECT_EQ(fmt::format("{:?}", o), "optional(\"path/file.txt\")");
+#  endif
+}
+#endif
+
+TEST(std_test, thread_id) {
+  EXPECT_FALSE(fmt::format("{}", std::this_thread::get_id()).empty());
+}
+
+#ifdef __cpp_lib_source_location
+TEST(std_test, source_location) {
+  std::source_location loc = std::source_location::current();
+  EXPECT_EQ(fmt::format("{}", loc),
+            fmt::format("{}:{}:{}: {}", loc.file_name(), loc.line(),
+                        loc.column(), loc.function_name()));
+}
+#endif
+
+TEST(std_test, optional) {
+#ifdef __cpp_lib_optional
+  EXPECT_EQ(fmt::format("{}", std::optional<int>{}), "none");
+  EXPECT_EQ(fmt::format("{}", std::pair{1, "second"}), "(1, \"second\")");
+  EXPECT_EQ(fmt::format("{}", std::vector{std::optional{1}, std::optional{2},
+                                          std::optional{3}}),
+            "[optional(1), optional(2), optional(3)]");
+  EXPECT_EQ(
+      fmt::format("{}", std::optional<std::optional<const char*>>{{"nested"}}),
+      "optional(optional(\"nested\"))");
+  EXPECT_EQ(
+      fmt::format("{:<{}}", std::optional{std::string{"left aligned"}}, 30),
+      "optional(\"left aligned\"                )");
+  EXPECT_EQ(
+      fmt::format("{::d}", std::optional{std::vector{'h', 'e', 'l', 'l', 'o'}}),
+      "optional([104, 101, 108, 108, 111])");
+  EXPECT_EQ(fmt::format("{}", std::optional{std::string{"string"}}),
+            "optional(\"string\")");
+  EXPECT_EQ(fmt::format("{}", std::optional{'C'}), "optional(\'C\')");
+  EXPECT_EQ(fmt::format("{:.{}f}", std::optional{3.14}, 1), "optional(3.1)");
+
+  struct unformattable {};
+  EXPECT_FALSE((fmt::is_formattable<unformattable>::value));
+  EXPECT_FALSE((fmt::is_formattable<std::optional<unformattable>>::value));
+  EXPECT_TRUE((fmt::is_formattable<std::optional<int>>::value));
+#endif
+}
+
+namespace my_nso {
+enum class my_number {
+  one,
+  two,
+};
+auto format_as(my_number number) -> fmt::string_view {
+  return number == my_number::one ? "first" : "second";
+}
+
+class my_class {
+ public:
+  int av;
+
+ private:
+  friend auto format_as(const my_class& elm) -> std::string {
+    return fmt::to_string(elm.av);
+  }
+};
+}  // namespace my_nso
+TEST(std_test, optional_format_as) {
+#ifdef __cpp_lib_optional
+  EXPECT_EQ(fmt::format("{}", std::optional<my_nso::my_number>{}), "none");
+  EXPECT_EQ(fmt::format("{}", std::optional{my_nso::my_number::one}),
+            "optional(\"first\")");
+  EXPECT_EQ(fmt::format("{}", std::optional<my_nso::my_class>{}), "none");
+  EXPECT_EQ(fmt::format("{}", std::optional{my_nso::my_class{7}}),
+            "optional(\"7\")");
+#endif
+}
+
+struct throws_on_move {
+  throws_on_move() = default;
+
+  [[noreturn]] throws_on_move(throws_on_move&&) {
+    throw std::runtime_error("Thrown by throws_on_move");
+  }
+
+  throws_on_move(const throws_on_move&) = default;
+};
+
+namespace fmt {
+template <> struct formatter<throws_on_move> : formatter<string_view> {
+  auto format(const throws_on_move&, format_context& ctx) const
+      -> decltype(ctx.out()) {
+    string_view str("<throws_on_move>");
+    return formatter<string_view>::format(str, ctx);
+  }
+};
+}  // namespace fmt
+
+TEST(std_test, variant) {
+#ifdef __cpp_lib_variant
+  EXPECT_EQ(fmt::format("{}", std::monostate{}), "monostate");
+  using V0 = std::variant<int, float, std::string, char>;
+  V0 v0(42);
+  V0 v1(1.5f);
+  V0 v2("hello");
+  V0 v3('i');
+  EXPECT_EQ(fmt::format("{}", v0), "variant(42)");
+  EXPECT_EQ(fmt::format("{}", v1), "variant(1.5)");
+  EXPECT_EQ(fmt::format("{}", v2), "variant(\"hello\")");
+  EXPECT_EQ(fmt::format("{}", v3), "variant('i')");
+
+  struct unformattable {};
+  EXPECT_FALSE((fmt::is_formattable<unformattable>::value));
+  EXPECT_FALSE((fmt::is_formattable<std::variant<unformattable>>::value));
+  EXPECT_FALSE((fmt::is_formattable<std::variant<unformattable, int>>::value));
+  EXPECT_FALSE((fmt::is_formattable<std::variant<int, unformattable>>::value));
+  EXPECT_FALSE(
+      (fmt::is_formattable<std::variant<unformattable, unformattable>>::value));
+  EXPECT_TRUE((fmt::is_formattable<std::variant<int, float>>::value));
+
+  using V1 = std::variant<std::monostate, std::string, std::string>;
+  V1 v4{};
+  V1 v5{std::in_place_index<1>, "yes, this is variant"};
+
+  EXPECT_EQ(fmt::format("{}", v4), "variant(monostate)");
+  EXPECT_EQ(fmt::format("{}", v5), "variant(\"yes, this is variant\")");
+
+  volatile int i = 42;  // Test compile error before GCC 11 described in #3068.
+  EXPECT_EQ(fmt::format("{}", i), "42");
+
+  std::variant<std::monostate, throws_on_move> v6;
+
+  try {
+    throws_on_move thrower;
+    v6.emplace<throws_on_move>(std::move(thrower));
+  } catch (const std::runtime_error&) {
+  }
+  // v6 is now valueless by exception
+
+  EXPECT_EQ(fmt::format("{}", v6), "variant(valueless by exception)");
+
+#endif
+}
+
+TEST(std_test, error_code) {
+  EXPECT_EQ("generic:42",
+            fmt::format(FMT_STRING("{0}"),
+                        std::error_code(42, std::generic_category())));
+  EXPECT_EQ("system:42",
+            fmt::format(FMT_STRING("{0}"),
+                        std::error_code(42, fmt::system_category())));
+  EXPECT_EQ("system:-42",
+            fmt::format(FMT_STRING("{0}"),
+                        std::error_code(-42, fmt::system_category())));
+}
+
+template <typename Catch> void exception_test() {
+  try {
+    throw std::runtime_error("Test Exception");
+  } catch (const Catch& ex) {
+    EXPECT_EQ("Test Exception", fmt::format("{}", ex));
+    EXPECT_EQ("std::runtime_error: Test Exception", fmt::format("{:t}", ex));
+  }
+}
+
+namespace my_ns1 {
+namespace my_ns2 {
+struct my_exception : public std::exception {
+ private:
+  std::string msg;
+
+ public:
+  my_exception(const std::string& s) : msg(s) {}
+  const char* what() const noexcept override;
+};
+const char* my_exception::what() const noexcept { return msg.c_str(); }
+}  // namespace my_ns2
+}  // namespace my_ns1
+
+TEST(std_test, exception) {
+  using testing::StartsWith;
+  exception_test<std::exception>();
+  exception_test<std::runtime_error>();
+
+  try {
+    using namespace my_ns1::my_ns2;
+    throw my_exception("My Exception");
+  } catch (const std::exception& ex) {
+    EXPECT_EQ("my_ns1::my_ns2::my_exception: My Exception",
+              fmt::format("{:t}", ex));
+    EXPECT_EQ("My Exception", fmt::format("{:}", ex));
+  }
+
+  try {
+    throw std::system_error(std::error_code(), "message");
+  } catch (const std::system_error& ex) {
+    EXPECT_THAT(fmt::format("{:t}", ex), StartsWith("std::system_error: "));
+  }
+
+#ifdef __cpp_lib_filesystem
+  // Tests that the inline namespace is stripped out, e.g.
+  // std::filesystem::__cxx11::* -> std::filesystem::*.
+  try {
+    throw std::filesystem::filesystem_error("message", std::error_code());
+  } catch (const std::filesystem::filesystem_error& ex) {
+    EXPECT_THAT(fmt::format("{:t}", ex),
+                StartsWith("std::filesystem::filesystem_error: "));
+  }
+#endif
+}
+
+TEST(std_test, format_bit_reference) {
+  std::bitset<2> bs(1);
+  EXPECT_EQ(fmt::format("{} {}", bs[0], bs[1]), "true false");
+  std::vector<bool> v = {true, false};
+  EXPECT_EQ(fmt::format("{} {}", v[0], v[1]), "true false");
+}
+
+TEST(std_test, format_const_bit_reference) {
+  const std::bitset<2> bs(1);
+  EXPECT_EQ(fmt::format("{} {}", bs[0], bs[1]), "true false");
+  const std::vector<bool> v = {true, false};
+  EXPECT_EQ(fmt::format("{} {}", v[0], v[1]), "true false");
+}
+
+TEST(std_test, format_bitset) {
+  auto bs = std::bitset<6>(42);
+  EXPECT_EQ(fmt::format("{}", bs), "101010");
+  EXPECT_EQ(fmt::format("{:0>8}", bs), "00101010");
+  EXPECT_EQ(fmt::format("{:-^12}", bs), "---101010---");
+}
+
+TEST(std_test, format_atomic) {
+  std::atomic<bool> b(false);
+  EXPECT_EQ(fmt::format("{}", b), "false");
+
+  const std::atomic<bool> cb(true);
+  EXPECT_EQ(fmt::format("{}", cb), "true");
+}
+
+#ifdef __cpp_lib_atomic_flag_test
+TEST(std_test, format_atomic_flag) {
+  std::atomic_flag f = ATOMIC_FLAG_INIT;
+  (void)f.test_and_set();
+  EXPECT_EQ(fmt::format("{}", f), "true");
+
+  const std::atomic_flag cf = ATOMIC_FLAG_INIT;
+  EXPECT_EQ(fmt::format("{}", cf), "false");
+}
+#endif  // __cpp_lib_atomic_flag_test