Revert "Refactor xchar tests to use xchar_helpers for format_to and format_to_n"

This reverts commit dab57dc.

Author: sunmy2019

test/xchar-test.cc

@@ -98,51 +98,23 @@ TEST(xchar_test, compile_time_string) {
 #endif
 }
 
-template <typename Char> struct xchar_helpers;
-
-#define DEFINE_XCHAR_HELPERS(CHAR_TYPE, LIT)                            \
-  template <> struct xchar_helpers<CHAR_TYPE> {                         \
-    static constexpr const CHAR_TYPE* fmt1() { return LIT("{}"); }      \
-    static constexpr const CHAR_TYPE* fmt2() { return LIT("{}{}"); }    \
-    static constexpr const CHAR_TYPE* fmt2sp() { return LIT("{}{} "); } \
-    static constexpr const CHAR_TYPE* s123x() { return LIT("123x"); }   \
-    static constexpr const CHAR_TYPE* sAxxx() { return LIT("Axxx"); }   \
-    static constexpr const CHAR_TYPE* sBCx() { return LIT("BC x"); }    \
-  }
-
 #define WLIT(x) L##x
 #define U16LIT(x) u##x
 #define U32LIT(x) U##x
 
-DEFINE_XCHAR_HELPERS(wchar_t, WLIT);
-DEFINE_XCHAR_HELPERS(char16_t, U16LIT);
-DEFINE_XCHAR_HELPERS(char32_t, U32LIT);
-
-#undef U32LIT
-#undef U16LIT
-#undef WLIT
-#undef DEFINE_XCHAR_HELPERS
-
-template <typename Char> class xchar_format_test : public testing::Test {};
-
-using wide_char_types = testing::Types<wchar_t, char16_t, char32_t>;
-TYPED_TEST_SUITE(xchar_format_test, wide_char_types);
+#define DEFINE_FORMAT_TO_TEST(SUITE, NAME, CHAR_TYPE, LIT)                 \
+  TEST(SUITE, NAME) {                                                      \
+    auto buf = std::vector<CHAR_TYPE>();                                   \
+    fmt::format_to(std::back_inserter(buf), LIT("{}{}"), 42, LIT('\0'));   \
+    auto expected = std::vector<CHAR_TYPE>{LIT('4'), LIT('2'), LIT('\0')}; \
+    EXPECT_EQ(buf, expected);                                              \
+  }
 
-TYPED_TEST(xchar_format_test, format_to) {
-  using H = xchar_helpers<TypeParam>;
-  auto buf = std::vector<TypeParam>();
-  fmt::format_to(std::back_inserter(buf), H::fmt2(), 42, TypeParam('\0'));
-  auto expected =
-      std::vector<TypeParam>{TypeParam('4'), TypeParam('2'), TypeParam('\0')};
-  EXPECT_EQ(buf, expected);
-}
+DEFINE_FORMAT_TO_TEST(xchar_test, wchar_format_to, wchar_t, WLIT)
+DEFINE_FORMAT_TO_TEST(xchar_test, char16_format_to, char16_t, U16LIT)
+DEFINE_FORMAT_TO_TEST(xchar_test, char32_format_to, char32_t, U32LIT)
 
-TEST(xchar_test, wchar_format_to_runtime) {
-  auto buf = std::vector<wchar_t>();
-  fmt::format_to(std::back_inserter(buf), fmt::runtime(L"{}{}"), 42, L'\0');
-  auto expected = std::vector<wchar_t>{L'4', L'2', L'\0'};
-  EXPECT_EQ(buf, expected);
-}
+#undef DEFINE_FORMAT_TO_TEST
 
 TEST(xchar_test, compile_time_string_format_to) {
   std::wstring ws;
@@ -167,31 +139,39 @@ TEST(xchar_test, format_as) {
   EXPECT_EQ(fmt::format(L"{}", test::struct_as_wstring_view()), L"foo");
 }
 
-TYPED_TEST(xchar_format_test, format_to_n) {
-  using H = xchar_helpers<TypeParam>;
-  TypeParam buffer[4];
-  buffer[3] = TypeParam('x');
-  auto result = fmt::format_to_n(buffer, 3, H::fmt1(), 12345);
-  EXPECT_EQ(5u, result.size);
-  EXPECT_EQ(buffer + 3, result.out);
-  EXPECT_EQ(std::basic_string<TypeParam>(H::s123x()),
-            std::basic_string<TypeParam>(buffer, 4));
-  buffer[0] = TypeParam('x');
-  buffer[1] = TypeParam('x');
-  buffer[2] = TypeParam('x');
-  result = fmt::format_to_n(buffer, 3, H::fmt1(), TypeParam('A'));
-  EXPECT_EQ(1u, result.size);
-  EXPECT_EQ(buffer + 1, result.out);
-  EXPECT_EQ(std::basic_string<TypeParam>(H::sAxxx()),
-            std::basic_string<TypeParam>(buffer, 4));
-  result =
-      fmt::format_to_n(buffer, 3, H::fmt2sp(), TypeParam('B'), TypeParam('C'));
-  EXPECT_EQ(3u, result.size);
-  EXPECT_EQ(buffer + 3, result.out);
-  EXPECT_EQ(std::basic_string<TypeParam>(H::sBCx()),
-            std::basic_string<TypeParam>(buffer, 4));
-}
+#define DEFINE_FORMAT_TO_N_TEST(SUITE, NAME, CHAR_TYPE, LIT)                \
+  TEST(SUITE, NAME) {                                                       \
+    CHAR_TYPE buffer[4];                                                    \
+    buffer[3] = LIT('x');                                                   \
+    auto result = fmt::format_to_n(buffer, 3, LIT("{}"), 12345);            \
+    EXPECT_EQ(5u, result.size);                                             \
+    EXPECT_EQ(buffer + 3, result.out);                                      \
+    EXPECT_EQ(std::basic_string<CHAR_TYPE>(LIT("123x")),                    \
+              std::basic_string<CHAR_TYPE>(buffer, 4));                     \
+    buffer[0] = LIT('x');                                                   \
+    buffer[1] = LIT('x');                                                   \
+    buffer[2] = LIT('x');                                                   \
+    result = fmt::format_to_n(buffer, 3, LIT("{}"), LIT('A'));              \
+    EXPECT_EQ(1u, result.size);                                             \
+    EXPECT_EQ(buffer + 1, result.out);                                      \
+    EXPECT_EQ(std::basic_string<CHAR_TYPE>(LIT("Axxx")),                    \
+              std::basic_string<CHAR_TYPE>(buffer, 4));                     \
+    result = fmt::format_to_n(buffer, 3, LIT("{}{} "), LIT('B'), LIT('C')); \
+    EXPECT_EQ(3u, result.size);                                             \
+    EXPECT_EQ(buffer + 3, result.out);                                      \
+    EXPECT_EQ(std::basic_string<CHAR_TYPE>(LIT("BC x")),                    \
+              std::basic_string<CHAR_TYPE>(buffer, 4));                     \
+  }
+
+DEFINE_FORMAT_TO_N_TEST(xchar_test, wchar_format_to_n, wchar_t, WLIT)
+DEFINE_FORMAT_TO_N_TEST(xchar_test, char16_format_to_n, char16_t, U16LIT)
+DEFINE_FORMAT_TO_N_TEST(xchar_test, char32_format_to_n, char32_t, U32LIT)
+
+#undef DEFINE_FORMAT_TO_N_TEST
 
+#undef U32LIT
+#undef U16LIT
+#undef WLIT
 
 TEST(xchar_test, wchar_format_to_n_runtime) {
   wchar_t buffer[4];