Refactor xchar tests to use xchar_helpers for format_to and format_to_n

Author: sunmy2019

test/xchar-test.cc

@@ -98,23 +98,51 @@ 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 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);                                              \
-  }
+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_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)
+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);
+}
 
-#undef DEFINE_FORMAT_TO_TEST
+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);
+}
 
 TEST(xchar_test, compile_time_string_format_to) {
   std::wstring ws;
@@ -139,39 +167,31 @@ TEST(xchar_test, format_as) {
   EXPECT_EQ(fmt::format(L"{}", test::struct_as_wstring_view()), L"foo");
 }
 
-#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
+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));
+}
 
-#undef U32LIT
-#undef U16LIT
-#undef WLIT
 
 TEST(xchar_test, wchar_format_to_n_runtime) {
   wchar_t buffer[4];