Merge commit '2abfcd02f1868bc12b5b0934101d2845c41e3cf5' into dev

external/fmt/test/std-test.cc

@@ -35,6 +35,11 @@ TEST(std_test, path) {
                                    L"\x0447\x044B\x043D\x0430")),
             "Шчучыншчына");
   EXPECT_EQ(fmt::format("{}", path(L"\xd800")), "<EFBFBD>");
+  EXPECT_EQ(fmt::format("{}", path(L"HEAD \xd800 TAIL")), "HEAD <20> TAIL");
+  EXPECT_EQ(fmt::format("{}", path(L"HEAD \xD83D\xDE00 TAIL")),
+            "HEAD \xF0\x9F\x98\x80 TAIL");
+  EXPECT_EQ(fmt::format("{}", path(L"HEAD \xD83D\xD83D\xDE00 TAIL")),
+            "HEAD <20>\xF0\x9F\x98\x80 TAIL");
   EXPECT_EQ(fmt::format("{:?}", path(L"\xd800")), "\"\\ud800\"");
 #  endif
 }
@@ -65,6 +70,37 @@ TEST(std_test, thread_id) {
   EXPECT_FALSE(fmt::format("{}", std::this_thread::get_id()).empty());
 }
 
+TEST(std_test, complex) {
+  using limits = std::numeric_limits<double>;
+  EXPECT_EQ(fmt::format("{}", std::complex<double>(1, limits::quiet_NaN())),
+            "(1+nan i)");
+  EXPECT_EQ(fmt::format("{}", std::complex<double>(1, -limits::infinity())),
+            "(1-inf i)");
+
+  EXPECT_EQ(fmt::format("{}", std::complex<int>(1, 2)), "(1+2i)");
+
+  EXPECT_EQ(fmt::format("{}", std::complex<double>(1, 2.2)), "(1+2.2i)");
+  EXPECT_EQ(fmt::format("{}", std::complex<double>(1, -2.2)), "(1-2.2i)");
+  EXPECT_EQ(fmt::format("{}", std::complex<double>(0, 2.2)), "2.2i");
+  EXPECT_EQ(fmt::format("{}", std::complex<double>(0, -2.2)), "-2.2i");
+
+  EXPECT_EQ(fmt::format("{:+}", std::complex<double>(0, 2.2)), "+2.2i");
+  EXPECT_EQ(fmt::format("{:+}", std::complex<double>(0, -2.2)), "-2.2i");
+  EXPECT_EQ(fmt::format("{:+}", std::complex<double>(1, -2.2)), "(+1-2.2i)");
+  EXPECT_EQ(fmt::format("{:+}", std::complex<double>(1, 2.2)), "(+1+2.2i)");
+  EXPECT_EQ(fmt::format("{: }", std::complex<double>(1, 2.2)), "( 1+2.2i)");
+  EXPECT_EQ(fmt::format("{: }", std::complex<double>(1, -2.2)), "( 1-2.2i)");
+
+  EXPECT_EQ(fmt::format("{:>20.2f}", std::complex<double>(1, 2.2)),
+            "        (1.00+2.20i)");
+  EXPECT_EQ(fmt::format("{:<20.2f}", std::complex<double>(1, 2.2)),
+            "(1.00+2.20i)        ");
+  EXPECT_EQ(fmt::format("{:<20.2f}", std::complex<double>(1, -2.2)),
+            "(1.00-2.20i)        ");
+  EXPECT_EQ(fmt::format("{:<{}.{}f}", std::complex<double>(1, -2.2), 20, 2),
+            "(1.00-2.20i)        ");
+}
+
 #ifdef __cpp_lib_source_location
 TEST(std_test, source_location) {
   std::source_location loc = std::source_location::current();
@@ -102,6 +138,36 @@ TEST(std_test, optional) {
 #endif
 }
 
+TEST(std_test, expected) {
+#ifdef __cpp_lib_expected
+  EXPECT_EQ(fmt::format("{}", std::expected<void, int>{}), "expected()");
+  EXPECT_EQ(fmt::format("{}", std::expected<int, int>{1}), "expected(1)");
+  EXPECT_EQ(fmt::format("{}", std::expected<int, int>{std::unexpected(1)}),
+            "unexpected(1)");
+  EXPECT_EQ(fmt::format("{}", std::expected<std::string, int>{"test"}),
+            "expected(\"test\")");
+  EXPECT_EQ(fmt::format(
+                "{}", std::expected<int, std::string>{std::unexpected("test")}),
+            "unexpected(\"test\")");
+  EXPECT_EQ(fmt::format("{}", std::expected<char, int>{'a'}), "expected('a')");
+  EXPECT_EQ(fmt::format("{}", std::expected<int, char>{std::unexpected('a')}),
+            "unexpected('a')");
+
+  struct unformattable1 {};
+  struct unformattable2 {};
+  EXPECT_FALSE((fmt::is_formattable<unformattable1>::value));
+  EXPECT_FALSE((fmt::is_formattable<unformattable2>::value));
+  EXPECT_FALSE((fmt::is_formattable<
+                std::expected<unformattable1, unformattable2>>::value));
+  EXPECT_FALSE(
+      (fmt::is_formattable<std::expected<unformattable1, int>>::value));
+  EXPECT_FALSE(
+      (fmt::is_formattable<std::expected<int, unformattable2>>::value));
+  EXPECT_TRUE((fmt::is_formattable<std::expected<int, int>>::value));
+  EXPECT_TRUE((fmt::is_formattable<std::expected<void, int>>::value));
+#endif
+}
+
 namespace my_nso {
 enum class my_number {
   one,
@@ -199,9 +265,13 @@ TEST(std_test, variant) {
 }
 
 TEST(std_test, error_code) {
+  auto& generic = std::generic_category();
   EXPECT_EQ("generic:42",
-            fmt::format(FMT_STRING("{0}"),
-                        std::error_code(42, std::generic_category())));
+            fmt::format(FMT_STRING("{0}"), std::error_code(42, generic)));
+  EXPECT_EQ("  generic:42",
+            fmt::format(FMT_STRING("{:>12}"), std::error_code(42, generic)));
+  EXPECT_EQ("generic:42  ",
+            fmt::format(FMT_STRING("{:12}"), std::error_code(42, generic)));
   EXPECT_EQ("system:42",
             fmt::format(FMT_STRING("{0}"),
                         std::error_code(42, fmt::system_category())));
@@ -265,6 +335,13 @@ TEST(std_test, exception) {
 #endif
 }
 
+#if FMT_USE_RTTI
+TEST(std_test, type_info) {
+  EXPECT_EQ(fmt::format("{}", typeid(std::runtime_error)),
+            "std::runtime_error");
+}
+#endif
+
 TEST(std_test, format_bit_reference) {
   std::bitset<2> bs(1);
   EXPECT_EQ(fmt::format("{} {}", bs[0], bs[1]), "true false");
@@ -322,3 +399,8 @@ TEST(std_test, format_shared_ptr) {
   EXPECT_EQ(fmt::format("{}", fmt::ptr(sp.get())),
             fmt::format("{}", fmt::ptr(sp)));
 }
+
+TEST(std_test, format_reference_wrapper) {
+  int num = 35;
+  EXPECT_EQ("35", fmt::to_string(std::cref(num)));
+}