Apply clang-format

include/fmt/core.h

@@ -725,7 +725,8 @@ struct type_constant : std::integral_constant<type, type::custom_type> {};
 
 #define FMT_TYPE_CONSTANT(Type, constant) \
   template <typename Char>                \
-  struct type_constant<Type, Char> : std::integral_constant<type, type::constant> {}
+  struct type_constant<Type, Char>        \
+      : std::integral_constant<type, type::constant> {}
 
 FMT_TYPE_CONSTANT(const named_arg_base<Char>&, named_arg_type);
 FMT_TYPE_CONSTANT(int, int_type);

include/fmt/printf.h

@@ -406,8 +406,9 @@ basic_printf_context<OutputIt, Char>::get_arg(int arg_index) {
 }
 
 template <typename OutputIt, typename Char>
-int basic_printf_context<OutputIt, Char>::parse_header(
-    const Char*& it, const Char* end, format_specs& specs) {
+int basic_printf_context<OutputIt, Char>::parse_header(const Char*& it,
+                                                       const Char* end,
+                                                       format_specs& specs) {
   int arg_index = -1;
   char_type c = *it;
   if (c >= '0' && c <= '9') {
@@ -476,8 +477,8 @@ OutputIt basic_printf_context<OutputIt, Char>::format() {
         specs.precision = parse_nonnegative_int(it, end, eh);
       } else if (c == '*') {
         ++it;
-        specs.precision =
-            static_cast<int>(visit_format_arg(internal::printf_precision_handler(), get_arg()));
+        specs.precision = static_cast<int>(
+            visit_format_arg(internal::printf_precision_handler(), get_arg()));
       } else {
         specs.precision = 0;
       }

test/core-test.cc

@@ -457,7 +457,8 @@ TEST(CoreTest, HasFormatter) {
   using context = fmt::format_context;
   static_assert(has_formatter<enabled_formatter, context>::value, "");
   static_assert(!has_formatter<disabled_formatter, context>::value, "");
-  static_assert(!has_formatter<disabled_formatter_convertible, context>::value, "");
+  static_assert(!has_formatter<disabled_formatter_convertible, context>::value,
+                "");
 }
 
 struct convertible_to_int {
@@ -616,7 +617,7 @@ TEST(FormatterTest, FormatExplicitlyConvertibleToStringView) {
   EXPECT_EQ("foo", fmt::format("{}", explicitly_convertible_to_string_view()));
 }
 
-#ifdef FMT_USE_STRING_VIEW
+#  ifdef FMT_USE_STRING_VIEW
 struct explicitly_convertible_to_std_string_view {
   explicit operator std::string_view() const { return "foo"; }
 };
@@ -625,7 +626,7 @@ TEST(FormatterTest, FormatExplicitlyConvertibleToStdStringView) {
   EXPECT_EQ("foo",
             fmt::format("{}", explicitly_convertible_to_std_string_view()));
 }
-#endif
+#  endif
 
 struct explicitly_convertible_to_wstring_view {
   explicit operator fmt::wstring_view() const { return L"foo"; }
@@ -639,9 +640,9 @@ TEST(FormatterTest, FormatExplicitlyConvertibleToWStringView) {
 
 struct disabled_rvalue_conversion {
   operator const char*() const& { return "foo"; }
-  operator const char*()& { return "foo"; }
+  operator const char*() & { return "foo"; }
   operator const char*() const&& = delete;
-  operator const char*()&& = delete;
+  operator const char*() && = delete;
 };
 
 TEST(FormatterTest, DisabledRValueConversion) {

test/format-impl-test.cc

@@ -272,8 +272,8 @@ TEST(FPTest, GetCachedPower) {
 }
 
 TEST(FPTest, GetRoundDirection) {
-  using fmt::internal::round_direction;
   using fmt::internal::get_round_direction;
+  using fmt::internal::round_direction;
   EXPECT_EQ(round_direction::down, get_round_direction(100, 50, 0));
   EXPECT_EQ(round_direction::up, get_round_direction(100, 51, 0));
   EXPECT_EQ(round_direction::down, get_round_direction(100, 40, 10));
@@ -448,8 +448,8 @@ TEST(UtilTest, CountDigits) {
 TEST(UtilTest, WriteUIntPtr) {
   fmt::memory_buffer buf;
   fmt::internal::writer writer(buf);
-  writer.write_pointer(fmt::internal::fallback_uintptr(
-                           reinterpret_cast<void*>(0xface)),
-                       nullptr);
+  writer.write_pointer(
+      fmt::internal::fallback_uintptr(reinterpret_cast<void*>(0xface)),
+      nullptr);
   EXPECT_EQ("0xface", to_string(buf));
 }

test/os-test.cc

@@ -22,7 +22,7 @@ using fmt::error_code;
 
 #ifdef _WIN32
 
-#include <windows.h>
+#  include <windows.h>
 
 TEST(UtilTest, UTF16ToUTF8) {
   std::string s = "ёжик";
@@ -267,7 +267,7 @@ TEST(BufferedFileTest, CloseError) {
 
 TEST(BufferedFileTest, Fileno) {
   buffered_file f;
-#ifndef __COVERITY__
+#  ifndef __COVERITY__
   // fileno on a null FILE pointer either crashes or returns an error.
   // Disable Coverity because this is intentional.
   EXPECT_DEATH_IF_SUPPORTED(
@@ -279,7 +279,7 @@ TEST(BufferedFileTest, Fileno) {
         }
       },
       "");
-#endif
+#  endif
   f = open_buffered_file();
   EXPECT_TRUE(f.fileno() != -1);
   file copy = file::dup(f.fileno());
@@ -431,13 +431,13 @@ TEST(FileTest, Dup) {
   EXPECT_EQ(FILE_CONTENT, read(copy, std::strlen(FILE_CONTENT)));
 }
 
-#ifndef __COVERITY__
+#  ifndef __COVERITY__
 TEST(FileTest, DupError) {
   int value = -1;
   EXPECT_SYSTEM_ERROR_NOASSERT(file::dup(value), EBADF,
                                "cannot duplicate file descriptor -1");
 }
-#endif
+#  endif
 
 TEST(FileTest, Dup2) {
   file f = open_file();
@@ -487,12 +487,12 @@ TEST(FileTest, Fdopen) {
   EXPECT_EQ(read_fd, FMT_POSIX(fileno(read_end.fdopen("r").get())));
 }
 
-#ifdef FMT_LOCALE
+#  ifdef FMT_LOCALE
 TEST(LocaleTest, Strtod) {
   fmt::Locale locale;
   const char *start = "4.2", *ptr = start;
   EXPECT_EQ(4.2, locale.strtod(ptr));
   EXPECT_EQ(start + 3, ptr);
 }
-#endif
+#  endif
 #endif  // FMT_USE_FCNTL
\ No newline at end of file

test/posix-mock-test.cc

@@ -201,17 +201,17 @@ static void write_file(fmt::cstring_view filename, fmt::string_view content) {
 using fmt::file;
 
 TEST(UtilTest, GetPageSize) {
-#ifdef _WIN32
+#  ifdef _WIN32
   SYSTEM_INFO si = {};
   GetSystemInfo(&si);
   EXPECT_EQ(si.dwPageSize, fmt::getpagesize());
-#else
+#  else
   EXPECT_EQ(sysconf(_SC_PAGESIZE), fmt::getpagesize());
   sysconf_error = true;
   EXPECT_SYSTEM_ERROR(fmt::getpagesize(), EINVAL,
                       "cannot get memory page size");
   sysconf_error = false;
-#endif
+#  endif
 }
 
 TEST(FileTest, OpenRetry) {
@@ -219,10 +219,10 @@ TEST(FileTest, OpenRetry) {
   std::unique_ptr<file> f{nullptr};
   EXPECT_RETRY(f.reset(new file("test", file::RDONLY)), open,
                "cannot open file test");
-#ifndef _WIN32
+#  ifndef _WIN32
   char c = 0;
   f->read(&c, 1);
-#endif
+#  endif
 }
 
 TEST(FileTest, CloseNoRetryInDtor) {
@@ -256,17 +256,17 @@ TEST(FileTest, Size) {
   file f("test", file::RDONLY);
   EXPECT_GE(f.size(), 0);
   EXPECT_EQ(content.size(), static_cast<unsigned long long>(f.size()));
-#ifdef _WIN32
+#  ifdef _WIN32
   fmt::memory_buffer message;
   fmt::internal::format_windows_error(message, ERROR_ACCESS_DENIED,
                                       "cannot get file size");
   fstat_sim = ERROR;
   EXPECT_THROW_MSG(f.size(), fmt::windows_error, fmt::to_string(message));
   fstat_sim = NONE;
-#else
+#  else
   f.close();
   EXPECT_SYSTEM_ERROR(f.size(), EBADF, "cannot get file attributes");
-#endif
+#  endif
 }
 
 TEST(FileTest, MaxSize) {
@@ -299,16 +299,16 @@ TEST(FileTest, WriteRetry) {
   EXPECT_RETRY(count = write_end.write("test", SIZE), write,
                "cannot write to file");
   write_end.close();
-#ifndef _WIN32
+#  ifndef _WIN32
   EXPECT_EQ(static_cast<std::streamsize>(SIZE), count);
   char buffer[SIZE + 1];
   read_end.read(buffer, SIZE);
   buffer[SIZE] = '\0';
   EXPECT_STREQ("test", buffer);
-#endif
+#  endif
 }
 
-#ifdef _WIN32
+#  ifdef _WIN32
 TEST(FileTest, ConvertReadCount) {
   file read_end, write_end;
   file::pipe(read_end, write_end);
@@ -334,7 +334,7 @@ TEST(FileTest, ConvertWriteCount) {
   write_count = 0;
   EXPECT_EQ(UINT_MAX, write_nbyte);
 }
-#endif
+#  endif
 
 TEST(FileTest, DupNoRetry) {
   int stdout_fd = FMT_POSIX(fileno(stdout));
@@ -359,11 +359,11 @@ TEST(FileTest, Dup2NoExceptRetry) {
   error_code ec;
   dup2_count = 1;
   f1.dup2(f2.descriptor(), ec);
-#ifndef _WIN32
+#  ifndef _WIN32
   EXPECT_EQ(4, dup2_count);
-#else
+#  else
   EXPECT_EQ(EINTR, ec.get());
-#endif
+#  endif
   dup2_count = 0;
 }
 
@@ -389,11 +389,11 @@ TEST(BufferedFileTest, OpenRetry) {
   std::unique_ptr<buffered_file> f{nullptr};
   EXPECT_RETRY(f.reset(new buffered_file("test", "r")), fopen,
                "cannot open file test");
-#ifndef _WIN32
+#  ifndef _WIN32
   char c = 0;
   if (fread(&c, 1, 1, f->get()) < 1)
     throw fmt::system_error(errno, "fread failed");
-#endif
+#  endif
 }
 
 TEST(BufferedFileTest, CloseNoRetryInDtor) {

test/printf-test.cc

@@ -590,7 +590,8 @@ class custom_printf_arg_formatter : public formatter_t {
       if (round(value * pow(10, specs()->precision)) == 0.0) value = 0;
   return formatter_t::operator()(value);
 }
-};
+}
+;
 
 typedef fmt::basic_format_args<context_t> format_args_t;
 

test/std-format-test.cc

@@ -29,8 +29,8 @@ TEST(StdFormatTest, Alignment) {
   string s4 = format("{:*^6}", 'x');  // s4 == "**x***"
   // Error: '=' with charT and no integer presentation type
   EXPECT_THROW(string s5 = format("{:=6}", 'x'), std::format_error);
-  string s6 = format("{:6d}", c);       // s6 == "   120"
-  string s7 = format("{:6}", true);     // s9 == "true  "
+  string s6 = format("{:6d}", c);    // s6 == "   120"
+  string s7 = format("{:6}", true);  // s9 == "true  "
   EXPECT_EQ(s0, "    42");
   EXPECT_EQ(s1, "x     ");
   EXPECT_EQ(s2, "x*****");