Consistently namespace qualify size_t

include/fmt/chrono.h

@@ -387,13 +387,13 @@ inline std::tm gmtime(std::time_t time) {
 }
 
 namespace internal {
-inline std::size_t strftime(char* str, std::size_t count, const char* format,
-                            const std::tm* time) {
+inline size_t strftime(char* str, size_t count, const char* format,
+                       const std::tm* time) {
   return std::strftime(str, count, format, time);
 }
 
-inline std::size_t strftime(wchar_t* str, std::size_t count,
-                            const wchar_t* format, const std::tm* time) {
+inline size_t strftime(wchar_t* str, size_t count, const wchar_t* format,
+                       const std::tm* time) {
   return std::wcsftime(str, count, format, time);
 }
 }  // namespace internal
@@ -414,11 +414,10 @@ template <typename Char> struct formatter<std::tm, Char> {
   template <typename FormatContext>
   auto format(const std::tm& tm, FormatContext& ctx) -> decltype(ctx.out()) {
     basic_memory_buffer<Char> buf;
-    std::size_t start = buf.size();
+    size_t start = buf.size();
     for (;;) {
-      std::size_t size = buf.capacity() - start;
-      std::size_t count =
-          internal::strftime(&buf[start], size, &tm_format[0], &tm);
+      size_t size = buf.capacity() - start;
+      size_t count = internal::strftime(&buf[start], size, &tm_format[0], &tm);
       if (count != 0) {
         buf.resize(start + count);
         break;
@@ -430,7 +429,7 @@ template <typename Char> struct formatter<std::tm, Char> {
         // https://github.com/fmtlib/fmt/issues/367
         break;
       }
-      const std::size_t MIN_GROWTH = 10;
+      const size_t MIN_GROWTH = 10;
       buf.reserve(buf.capacity() + (size > MIN_GROWTH ? size : MIN_GROWTH));
     }
     return std::copy(buf.begin(), buf.end(), ctx.out());

include/fmt/color.h

@@ -364,7 +364,7 @@ template <typename Char> struct ansi_color_escape {
       // 10 more.
       if (is_background) value += 10u;
 
-      std::size_t index = 0;
+      size_t index = 0;
       buffer[index++] = static_cast<Char>('\x1b');
       buffer[index++] = static_cast<Char>('[');
 
@@ -398,7 +398,7 @@ template <typename Char> struct ansi_color_escape {
     if (em_bits & static_cast<uint8_t>(emphasis::strikethrough))
       em_codes[3] = 9;
 
-    std::size_t index = 0;
+    size_t index = 0;
     for (int i = 0; i < 4; ++i) {
       if (!em_codes[i]) continue;
       buffer[index++] = static_cast<Char>('\x1b');

include/fmt/compile.h

@@ -586,7 +586,7 @@ format_to_n_result<OutputIt> format_to_n(OutputIt out, size_t n,
 }
 
 template <typename CompiledFormat, typename... Args>
-std::size_t formatted_size(const CompiledFormat& cf, const Args&... args) {
+size_t formatted_size(const CompiledFormat& cf, const Args&... args) {
   return format_to(internal::counting_iterator(), cf, args...).count();
 }
 

include/fmt/core.h

@@ -630,27 +630,27 @@ namespace internal {
 template <typename T> class buffer {
  private:
   T* ptr_;
-  std::size_t size_;
-  std::size_t capacity_;
+  size_t size_;
+  size_t capacity_;
 
  protected:
   // Don't initialize ptr_ since it is not accessed to save a few cycles.
   FMT_SUPPRESS_MSC_WARNING(26495)
-  buffer(std::size_t sz) FMT_NOEXCEPT : size_(sz), capacity_(sz) {}
+  buffer(size_t sz) FMT_NOEXCEPT : size_(sz), capacity_(sz) {}
 
-  buffer(T* p = nullptr, std::size_t sz = 0, std::size_t cap = 0) FMT_NOEXCEPT
+  buffer(T* p = nullptr, size_t sz = 0, size_t cap = 0) FMT_NOEXCEPT
       : ptr_(p),
         size_(sz),
         capacity_(cap) {}
 
   /** Sets the buffer data and capacity. */
-  void set(T* buf_data, std::size_t buf_capacity) FMT_NOEXCEPT {
+  void set(T* buf_data, size_t buf_capacity) FMT_NOEXCEPT {
     ptr_ = buf_data;
     capacity_ = buf_capacity;
   }
 
   /** Increases the buffer capacity to hold at least *capacity* elements. */
-  virtual void grow(std::size_t capacity) = 0;
+  virtual void grow(size_t capacity) = 0;
 
  public:
   using value_type = T;
@@ -667,10 +667,10 @@ template <typename T> class buffer {
   const T* end() const FMT_NOEXCEPT { return ptr_ + size_; }
 
   /** Returns the size of this buffer. */
-  std::size_t size() const FMT_NOEXCEPT { return size_; }
+  size_t size() const FMT_NOEXCEPT { return size_; }
 
   /** Returns the capacity of this buffer. */
-  std::size_t capacity() const FMT_NOEXCEPT { return capacity_; }
+  size_t capacity() const FMT_NOEXCEPT { return capacity_; }
 
   /** Returns a pointer to the buffer data. */
   T* data() FMT_NOEXCEPT { return ptr_; }
@@ -681,7 +681,7 @@ template <typename T> class buffer {
   /**
     Resizes the buffer. If T is a POD type new elements may not be initialized.
    */
-  void resize(std::size_t new_size) {
+  void resize(size_t new_size) {
     reserve(new_size);
     size_ = new_size;
   }
@@ -690,7 +690,7 @@ template <typename T> class buffer {
   void clear() { size_ = 0; }
 
   /** Reserves space to store at least *capacity* elements. */
-  void reserve(std::size_t new_capacity) {
+  void reserve(size_t new_capacity) {
     if (new_capacity > capacity_) grow(new_capacity);
   }
 
@@ -715,7 +715,7 @@ class container_buffer : public buffer<typename Container::value_type> {
   Container& container_;
 
  protected:
-  void grow(std::size_t capacity) FMT_OVERRIDE {
+  void grow(size_t capacity) FMT_OVERRIDE {
     container_.resize(capacity);
     this->set(&container_[0], capacity);
   }
@@ -869,12 +869,12 @@ constexpr bool is_arithmetic_type(type t) {
 
 template <typename Char> struct string_value {
   const Char* data;
-  std::size_t size;
+  size_t size;
 };
 
 template <typename Char> struct named_arg_value {
   const named_arg_info<Char>* data;
-  std::size_t size;
+  size_t size;
 };
 
 template <typename Context> struct custom_value {

include/fmt/format-inl.h

@@ -41,7 +41,7 @@
 // Dummy implementations of strerror_r and strerror_s called if corresponding
 // system functions are not available.
 inline fmt::internal::null<> strerror_r(int, char*, ...) { return {}; }
-inline fmt::internal::null<> strerror_s(char*, std::size_t, ...) { return {}; }
+inline fmt::internal::null<> strerror_s(char*, size_t, ...) { return {}; }
 
 FMT_BEGIN_NAMESPACE
 namespace internal {
@@ -76,14 +76,14 @@ inline int fmt_snprintf(char* buffer, size_t size, const char* format, ...) {
 //   other  - failure
 // Buffer should be at least of size 1.
 FMT_FUNC int safe_strerror(int error_code, char*& buffer,
-                           std::size_t buffer_size) FMT_NOEXCEPT {
+                           size_t buffer_size) FMT_NOEXCEPT {
   FMT_ASSERT(buffer != nullptr && buffer_size != 0, "invalid buffer");
 
   class dispatcher {
    private:
     int error_code_;
     char*& buffer_;
-    std::size_t buffer_size_;
+    size_t buffer_size_;
 
     // A noop assignment operator to avoid bogus warnings.
     void operator=(const dispatcher&) {}
@@ -128,7 +128,7 @@ FMT_FUNC int safe_strerror(int error_code, char*& buffer,
 #endif
 
    public:
-    dispatcher(int err_code, char*& buf, std::size_t buf_size)
+    dispatcher(int err_code, char*& buf, size_t buf_size)
         : error_code_(err_code), buffer_(buf), buffer_size_(buf_size) {}
 
     int run() { return handle(strerror_r(error_code_, buffer_, buffer_size_)); }
@@ -145,7 +145,7 @@ FMT_FUNC void format_error_code(internal::buffer<char>& out, int error_code,
   static const char SEP[] = ": ";
   static const char ERROR_STR[] = "error ";
   // Subtract 2 to account for terminating null characters in SEP and ERROR_STR.
-  std::size_t error_code_size = sizeof(SEP) + sizeof(ERROR_STR) - 2;
+  size_t error_code_size = sizeof(SEP) + sizeof(ERROR_STR) - 2;
   auto abs_value = static_cast<uint32_or_64_or_128_t<int>>(error_code);
   if (internal::is_negative(error_code)) {
     abs_value = 0 - abs_value;

include/fmt/os.h

@@ -313,10 +313,10 @@ class file {
   FMT_API long long size() const;
 
   // Attempts to read count bytes from the file into the specified buffer.
-  FMT_API std::size_t read(void* buffer, std::size_t count);
+  FMT_API size_t read(void* buffer, size_t count);
 
   // Attempts to write count bytes from the specified buffer to the file.
-  FMT_API std::size_t write(const void* buffer, std::size_t count);
+  FMT_API size_t write(const void* buffer, size_t count);
 
   // Duplicates a file descriptor with the dup function and returns
   // the duplicate as a file object.

include/fmt/posix.h

 #include "os.h"
-#warning "fmt/posix.h is deprecated; use fmt/os.h instead"
\ No newline at end of file
+#warning "fmt/posix.h is deprecated; use fmt/os.h instead"

include/fmt/printf.h

@@ -508,7 +508,8 @@ OutputIt basic_printf_context<OutputIt, Char>::format() {
       auto str_end = str + specs.precision;
       auto nul = std::find(str, str_end, Char());
       arg = internal::make_arg<basic_printf_context>(basic_string_view<Char>(
-          str, internal::to_unsigned(nul != str_end ? nul - str : specs.precision)));
+          str,
+          internal::to_unsigned(nul != str_end ? nul - str : specs.precision)));
     }
     if (specs.alt && visit_format_arg(internal::is_zero_int(), arg))
       specs.alt = false;
@@ -546,7 +547,7 @@ OutputIt basic_printf_context<OutputIt, Char>::format() {
       convert_arg<intmax_t>(arg, t);
       break;
     case 'z':
-      convert_arg<std::size_t>(arg, t);
+      convert_arg<size_t>(arg, t);
       break;
     case 't':
       convert_arg<std::ptrdiff_t>(arg, t);
@@ -651,7 +652,7 @@ inline int vfprintf(
     basic_format_args<basic_printf_context_t<type_identity_t<Char>>> args) {
   basic_memory_buffer<Char> buffer;
   vprintf(buffer, to_string_view(format), args);
-  std::size_t size = buffer.size();
+  size_t size = buffer.size();
   return std::fwrite(buffer.data(), sizeof(Char), size, f) < size
              ? -1
              : static_cast<int>(size);

include/fmt/ranges.h

@@ -33,7 +33,7 @@ template <typename Char> struct formatting_base {
 
 template <typename Char, typename Enable = void>
 struct formatting_range : formatting_base<Char> {
-  static FMT_CONSTEXPR_DECL const std::size_t range_length_limit =
+  static FMT_CONSTEXPR_DECL const size_t range_length_limit =
       FMT_RANGE_OUTPUT_LENGTH_LIMIT;  // output only up to N items from the
                                       // range.
   Char prefix;
@@ -118,26 +118,24 @@ template <typename T> class is_tuple_like_ {
 #if defined(__cpp_lib_integer_sequence) || FMT_MSC_VER >= 1900
 template <typename T, T... N>
 using integer_sequence = std::integer_sequence<T, N...>;
-template <std::size_t... N> using index_sequence = std::index_sequence<N...>;
-template <std::size_t N>
-using make_index_sequence = std::make_index_sequence<N>;
+template <size_t... N> using index_sequence = std::index_sequence<N...>;
+template <size_t N> using make_index_sequence = std::make_index_sequence<N>;
 #else
 template <typename T, T... N> struct integer_sequence {
   using value_type = T;
 
-  static FMT_CONSTEXPR std::size_t size() { return sizeof...(N); }
+  static FMT_CONSTEXPR size_t size() { return sizeof...(N); }
 };
 
-template <std::size_t... N>
-using index_sequence = integer_sequence<std::size_t, N...>;
+template <size_t... N> using index_sequence = integer_sequence<size_t, N...>;
 
-template <typename T, std::size_t N, T... Ns>
+template <typename T, size_t N, T... Ns>
 struct make_integer_sequence : make_integer_sequence<T, N - 1, N - 1, Ns...> {};
 template <typename T, T... Ns>
 struct make_integer_sequence<T, 0, Ns...> : integer_sequence<T, Ns...> {};
 
-template <std::size_t N>
-using make_index_sequence = make_integer_sequence<std::size_t, N>;
+template <size_t N>
+using make_index_sequence = make_integer_sequence<size_t, N>;
 #endif
 
 template <class Tuple, class F, size_t... Is>
@@ -212,7 +210,7 @@ struct formatter<TupleT, Char, enable_if_t<fmt::is_tuple_like<TupleT>::value>> {
     }
 
     formatting_tuple<Char>& formatting;
-    std::size_t& i;
+    size_t& i;
     typename std::add_lvalue_reference<decltype(
         std::declval<FormatContext>().out())>::type out;
   };
@@ -228,7 +226,7 @@ struct formatter<TupleT, Char, enable_if_t<fmt::is_tuple_like<TupleT>::value>> {
   template <typename FormatContext = format_context>
   auto format(const TupleT& values, FormatContext& ctx) -> decltype(ctx.out()) {
     auto out = ctx.out();
-    std::size_t i = 0;
+    size_t i = 0;
     internal::copy(formatting.prefix, out);
 
     internal::for_each(values, format_each<FormatContext>{formatting, i, out});
@@ -263,7 +261,7 @@ struct formatter<RangeT, Char,
   typename FormatContext::iterator format(const RangeT& values,
                                           FormatContext& ctx) {
     auto out = internal::copy(formatting.prefix, ctx.out());
-    std::size_t i = 0;
+    size_t i = 0;
     for (auto it = values.begin(), end = values.end(); it != end; ++it) {
       if (i > 0) {
         if (formatting.add_prepostfix_space) *out++ = ' ';

test/chrono-test.cc

@@ -10,10 +10,11 @@
 #endif
 
 #include "fmt/chrono.h"
-#include "gtest-extra.h"
 
 #include <iomanip>
 
+#include "gtest-extra.h"
+
 std::tm make_tm() {
   auto time = std::tm();
   time.tm_mday = 1;

test/color-test.cc

@@ -6,6 +6,7 @@
 // For the license information refer to format.h.
 
 #include "fmt/color.h"
+
 #include "gtest-extra.h"
 
 TEST(ColorsTest, ColorsPrint) {

test/compile-test.cc

@@ -6,6 +6,7 @@
 // For the license information refer to format.h.
 
 #include <stdint.h>
+
 #include <cctype>
 #include <cfloat>
 #include <climits>

test/core-test.cc

@@ -83,20 +83,20 @@ TEST(BufferTest, Nonmoveable) {
 
 // A test buffer with a dummy grow method.
 template <typename T> struct test_buffer : buffer<T> {
-  void grow(std::size_t capacity) { this->set(nullptr, capacity); }
+  void grow(size_t capacity) { this->set(nullptr, capacity); }
 };
 
 template <typename T> struct mock_buffer : buffer<T> {
-  MOCK_METHOD1(do_grow, void(std::size_t capacity));
+  MOCK_METHOD1(do_grow, void(size_t capacity));
 
-  void grow(std::size_t capacity) {
+  void grow(size_t capacity) {
     this->set(this->data(), capacity);
     do_grow(capacity);
   }
 
   mock_buffer() {}
   mock_buffer(T* data) { this->set(data, 0); }
-  mock_buffer(T* data, std::size_t capacity) { this->set(data, capacity); }
+  mock_buffer(T* data, size_t capacity) { this->set(data, capacity); }
 };
 
 TEST(BufferTest, Ctor) {
@@ -115,7 +115,7 @@ TEST(BufferTest, Ctor) {
   }
   {
     int dummy;
-    std::size_t capacity = std::numeric_limits<std::size_t>::max();
+    size_t capacity = std::numeric_limits<size_t>::max();
     mock_buffer<int> buffer(&dummy, capacity);
     EXPECT_EQ(&dummy, &buffer[0]);
     EXPECT_EQ(static_cast<size_t>(0), buffer.size());
@@ -375,7 +375,7 @@ struct check_custom {
     struct test_buffer : fmt::internal::buffer<char> {
       char data[10];
       test_buffer() : fmt::internal::buffer<char>(data, 0, 10) {}
-      void grow(std::size_t) {}
+      void grow(size_t) {}
     } buffer;
     fmt::internal::buffer<char>& base = buffer;
     fmt::format_parse_context parse_ctx("");
@@ -496,9 +496,9 @@ TEST(StringViewTest, Length) {
 // Check string_view's comparison operator.
 template <template <typename> class Op> void check_op() {
   const char* inputs[] = {"foo", "fop", "fo"};
-  std::size_t num_inputs = sizeof(inputs) / sizeof(*inputs);
-  for (std::size_t i = 0; i < num_inputs; ++i) {
-    for (std::size_t j = 0; j < num_inputs; ++j) {
+  size_t num_inputs = sizeof(inputs) / sizeof(*inputs);
+  for (size_t i = 0; i < num_inputs; ++i) {
+    for (size_t j = 0; j < num_inputs; ++j) {
       string_view lhs(inputs[i]), rhs(inputs[j]);
       EXPECT_EQ(Op<int>()(lhs.compare(rhs), 0), Op<string_view>()(lhs, rhs));
     }
@@ -584,7 +584,7 @@ template <typename Char> class my_string {
  public:
   my_string(const Char* s) : s_(s) {}
   const Char* data() const FMT_NOEXCEPT { return s_.data(); }
-  std::size_t length() const FMT_NOEXCEPT { return s_.size(); }
+  size_t length() const FMT_NOEXCEPT { return s_.size(); }
   operator const Char*() const { return s_.c_str(); }
 
  private:

test/format-impl-test.cc

@@ -376,7 +376,7 @@ TEST(FormatTest, StrError) {
   int result =
       fmt::internal::safe_strerror(error_code, message = buffer, BUFFER_SIZE);
   EXPECT_EQ(result, 0);
-  std::size_t message_size = std::strlen(message);
+  size_t message_size = std::strlen(message);
   EXPECT_GE(BUFFER_SIZE - 1u, message_size);
   EXPECT_EQ(get_system_error(error_code), message);
 
@@ -408,14 +408,14 @@ TEST(FormatTest, FormatErrorCode) {
     EXPECT_EQ(msg, to_string(buffer));
   }
   int codes[] = {42, -1};
-  for (std::size_t i = 0, n = sizeof(codes) / sizeof(*codes); i < n; ++i) {
+  for (size_t i = 0, n = sizeof(codes) / sizeof(*codes); i < n; ++i) {
     // Test maximum buffer size.
     msg = fmt::format("error {}", codes[i]);
     fmt::memory_buffer buffer;
     std::string prefix(fmt::inline_buffer_size - msg.size() - sep.size(), 'x');
     fmt::internal::format_error_code(buffer, codes[i], prefix);
     EXPECT_EQ(prefix + sep + msg, to_string(buffer));
-    std::size_t size = fmt::inline_buffer_size;
+    size_t size = fmt::inline_buffer_size;
     EXPECT_EQ(size, buffer.size());
     buffer.resize(0);
     // Test with a message that doesn't fit into the buffer.

test/format-test.cc

@@ -36,8 +36,6 @@
 
 #undef ERROR
 
-using std::size_t;
-
 using fmt::basic_memory_buffer;
 using fmt::format;
 using fmt::format_error;
@@ -299,7 +297,7 @@ TEST(MemoryBufferTest, Grow) {
   mock_allocator<int> alloc;
   struct TestMemoryBuffer : Base {
     TestMemoryBuffer(Allocator alloc) : Base(alloc) {}
-    void grow(std::size_t size) { Base::grow(size); }
+    void grow(size_t size) { Base::grow(size); }
   } buffer((Allocator(&alloc)));
   buffer.resize(7);
   using fmt::internal::to_unsigned;
@@ -327,7 +325,7 @@ TEST(MemoryBufferTest, Allocator) {
     basic_memory_buffer<char, 10, TestAllocator> buffer2(
         (TestAllocator(&alloc)));
     EXPECT_EQ(&alloc, buffer2.get_allocator().get());
-    std::size_t size = 2 * fmt::inline_buffer_size;
+    size_t size = 2 * fmt::inline_buffer_size;
     EXPECT_CALL(alloc, allocate(size)).WillOnce(Return(&mem));
     buffer2.reserve(size);
     EXPECT_CALL(alloc, deallocate(&mem, size));
@@ -338,7 +336,7 @@ TEST(MemoryBufferTest, ExceptionInDeallocate) {
   typedef allocator_ref<mock_allocator<char>> TestAllocator;
   StrictMock<mock_allocator<char>> alloc;
   basic_memory_buffer<char, 10, TestAllocator> buffer((TestAllocator(&alloc)));
-  std::size_t size = 2 * fmt::inline_buffer_size;
+  size_t size = 2 * fmt::inline_buffer_size;
   std::vector<char> mem(size);
   {
     EXPECT_CALL(alloc, allocate(size)).WillOnce(Return(&mem[0]));
@@ -353,7 +351,7 @@ TEST(MemoryBufferTest, ExceptionInDeallocate) {
     EXPECT_THROW(buffer.reserve(2 * size), std::exception);
     EXPECT_EQ(&mem2[0], &buffer[0]);
     // Check that the data has been copied.
-    for (std::size_t i = 0; i < size; ++i) EXPECT_EQ('x', buffer[i]);
+    for (size_t i = 0; i < size; ++i) EXPECT_EQ('x', buffer[i]);
   }
   EXPECT_CALL(alloc, deallocate(&mem2[0], 2 * size));
 }
@@ -608,9 +606,7 @@ TEST(FormatterTest, RightAlign) {
 }
 
 #if FMT_NUMERIC_ALIGN
-TEST(FormatterTest, NumericAlign) {
-  EXPECT_EQ("0042", format("{0:=4}", 42));
-}
+TEST(FormatterTest, NumericAlign) { EXPECT_EQ("0042", format("{0:=4}", 42)); }
 #endif
 
 TEST(FormatterTest, CenterAlign) {
@@ -801,7 +797,7 @@ TEST(FormatterTest, Width) {
   safe_sprintf(format_str, "{0:%u", UINT_MAX);
   increment(format_str + 3);
   EXPECT_THROW_MSG(format(format_str, 0), format_error, "number is too big");
-  std::size_t size = std::strlen(format_str);
+  size_t size = std::strlen(format_str);
   format_str[size] = '}';
   format_str[size + 1] = 0;
   EXPECT_THROW_MSG(format(format_str, 0), format_error, "number is too big");
@@ -831,7 +827,7 @@ TEST(FormatterTest, RuntimeWidth) {
   safe_sprintf(format_str, "{0:{%u", UINT_MAX);
   increment(format_str + 4);
   EXPECT_THROW_MSG(format(format_str, 0), format_error, "number is too big");
-  std::size_t size = std::strlen(format_str);
+  size_t size = std::strlen(format_str);
   format_str[size] = '}';
   format_str[size + 1] = 0;
   EXPECT_THROW_MSG(format(format_str, 0), format_error, "number is too big");
@@ -884,7 +880,7 @@ TEST(FormatterTest, Precision) {
   safe_sprintf(format_str, "{0:.%u", UINT_MAX);
   increment(format_str + 4);
   EXPECT_THROW_MSG(format(format_str, 0), format_error, "number is too big");
-  std::size_t size = std::strlen(format_str);
+  size_t size = std::strlen(format_str);
   format_str[size] = '}';
   format_str[size + 1] = 0;
   EXPECT_THROW_MSG(format(format_str, 0), format_error, "number is too big");
@@ -976,7 +972,7 @@ TEST(FormatterTest, RuntimePrecision) {
   safe_sprintf(format_str, "{0:.{%u", UINT_MAX);
   increment(format_str + 5);
   EXPECT_THROW_MSG(format(format_str, 0), format_error, "number is too big");
-  std::size_t size = std::strlen(format_str);
+  size_t size = std::strlen(format_str);
   format_str[size] = '}';
   format_str[size + 1] = 0;
   EXPECT_THROW_MSG(format(format_str, 0), format_error, "number is too big");
@@ -1463,7 +1459,7 @@ class QString {
 };
 
 fmt::basic_string_view<wchar_t> to_string_view(const QString& s) FMT_NOEXCEPT {
-  return {s.utf16(), static_cast<std::size_t>(s.size())};
+  return {s.utf16(), static_cast<size_t>(s.size())};
 }
 }  // namespace fake_qt
 

test/fuzzing/chrono_duration.cpp

@@ -25,7 +25,7 @@ void invoke_inner(fmt::string_view formatstring, const Item item) {
 
 // Item is the underlying type for duration (int, long etc)
 template <typename Item>
-void invoke_outer(const uint8_t* Data, std::size_t Size, const int scaling) {
+void invoke_outer(const uint8_t* Data, size_t Size, const int scaling) {
   // always use a fixed location of the data
   using fmt_fuzzer::Nfixed;
 
@@ -97,7 +97,7 @@ void invoke_outer(const uint8_t* Data, std::size_t Size, const int scaling) {
   // doit_impl<Item,std::yotta>(buf.data(),item);
 }
 
-extern "C" int LLVMFuzzerTestOneInput(const uint8_t* Data, std::size_t Size) {
+extern "C" int LLVMFuzzerTestOneInput(const uint8_t* Data, size_t Size) {
   if (Size <= 4) {
     return 0;
   }

test/fuzzing/main.cpp

@@ -4,7 +4,7 @@
 #include <vector>
 #include "fuzzer_common.h"
 
-extern "C" int LLVMFuzzerTestOneInput(const uint8_t* Data, std::size_t Size);
+extern "C" int LLVMFuzzerTestOneInput(const uint8_t* Data, size_t Size);
 int main(int argc, char* argv[]) {
   for (int i = 1; i < argc; ++i) {
     std::ifstream in(argv[i]);
@@ -13,7 +13,7 @@ int main(int argc, char* argv[]) {
     const auto pos = in.tellg();
     assert(pos >= 0);
     in.seekg(0, std::ios_base::beg);
-    std::vector<char> buf(static_cast<std::size_t>(pos));
+    std::vector<char> buf(static_cast<size_t>(pos));
     in.read(buf.data(), static_cast<long>(buf.size()));
     assert(in.gcount() == pos);
     LLVMFuzzerTestOneInput(fmt_fuzzer::as_bytes(buf.data()), buf.size());

test/fuzzing/named_arg.cpp

@@ -10,7 +10,7 @@
 #include "fuzzer_common.h"
 
 template <typename Item1>
-void invoke_fmt(const uint8_t* Data, std::size_t Size, unsigned int argsize) {
+void invoke_fmt(const uint8_t* Data, size_t Size, unsigned int argsize) {
   constexpr auto N1 = sizeof(Item1);
   static_assert(N1 <= fmt_fuzzer::Nfixed, "Nfixed too small");
   if (Size <= fmt_fuzzer::Nfixed) {
@@ -105,7 +105,7 @@ template <typename Callback> void invoke(int index, Callback callback) {
   }
 }
 
-extern "C" int LLVMFuzzerTestOneInput(const uint8_t* Data, std::size_t Size) {
+extern "C" int LLVMFuzzerTestOneInput(const uint8_t* Data, size_t Size) {
   if (Size <= 3) {
     return 0;
   }

test/fuzzing/one_arg.cpp

@@ -13,7 +13,7 @@
 using fmt_fuzzer::Nfixed;
 
 template <typename Item>
-void invoke_fmt(const uint8_t* Data, std::size_t Size) {
+void invoke_fmt(const uint8_t* Data, size_t Size) {
   constexpr auto N = sizeof(Item);
   static_assert(N <= Nfixed, "Nfixed is too small");
   if (Size <= Nfixed) {
@@ -40,7 +40,7 @@ void invoke_fmt(const uint8_t* Data, std::size_t Size) {
 #endif
 }
 
-void invoke_fmt_time(const uint8_t* Data, std::size_t Size) {
+void invoke_fmt_time(const uint8_t* Data, size_t Size) {
   using Item = std::time_t;
   constexpr auto N = sizeof(Item);
   static_assert(N <= Nfixed, "Nfixed too small");
@@ -69,7 +69,7 @@ void invoke_fmt_time(const uint8_t* Data, std::size_t Size) {
   }
 }
 
-extern "C" int LLVMFuzzerTestOneInput(const uint8_t* Data, std::size_t Size) {
+extern "C" int LLVMFuzzerTestOneInput(const uint8_t* Data, size_t Size) {
   if (Size <= 3) {
     return 0;
   }

test/fuzzing/sprintf.cpp

@@ -10,7 +10,7 @@
 using fmt_fuzzer::Nfixed;
 
 template <typename Item1, typename Item2>
-void invoke_fmt(const uint8_t* Data, std::size_t Size) {
+void invoke_fmt(const uint8_t* Data, size_t Size) {
   constexpr auto N1 = sizeof(Item1);
   constexpr auto N2 = sizeof(Item2);
   static_assert(N1 <= Nfixed, "size1 exceeded");
@@ -90,7 +90,7 @@ template <typename Callback> void invoke(int index, Callback callback) {
   }
 }
 
-extern "C" int LLVMFuzzerTestOneInput(const uint8_t* Data, std::size_t Size) {
+extern "C" int LLVMFuzzerTestOneInput(const uint8_t* Data, size_t Size) {
   if (Size <= 3) {
     return 0;
   }

test/fuzzing/two_args.cpp

@@ -10,7 +10,7 @@
 constexpr auto Nfixed = fmt_fuzzer::Nfixed;
 
 template <typename Item1, typename Item2>
-void invoke_fmt(const uint8_t* Data, std::size_t Size) {
+void invoke_fmt(const uint8_t* Data, size_t Size) {
   constexpr auto N1 = sizeof(Item1);
   constexpr auto N2 = sizeof(Item2);
   static_assert(N1 <= Nfixed, "size1 exceeded");
@@ -86,7 +86,7 @@ template <typename Callback> void invoke(int index, Callback callback) {
   }
 }
 
-extern "C" int LLVMFuzzerTestOneInput(const uint8_t* Data, std::size_t Size) {
+extern "C" int LLVMFuzzerTestOneInput(const uint8_t* Data, size_t Size) {
   if (Size <= 3) {
     return 0;
   }

test/gmock-gtest-all.cc

@@ -344,6 +344,7 @@ class GTEST_API_ SingleFailureChecker {
 #  include <sys/mman.h>  // NOLINT
 #  include <sys/time.h>  // NOLINT
 #  include <unistd.h>    // NOLINT
+
 #  include <string>
 
 #elif GTEST_OS_SYMBIAN
@@ -7728,6 +7729,7 @@ InternalRunDeathTestFlag* ParseInternalRunDeathTestFlag() {
 #  include <sys/syslimits.h>
 #else
 #  include <limits.h>
+
 #  include <climits>  // Some Linux distributions define PATH_MAX here.
 #endif                // GTEST_OS_WINDOWS_MOBILE
 
@@ -8899,6 +8901,7 @@ const char* StringFromGTestEnv(const char* flag, const char* default_value) {
 
 #include <ctype.h>
 #include <stdio.h>
+
 #include <ostream>  // NOLINT
 #include <string>
 
@@ -9494,6 +9497,7 @@ const char* TypedTestCasePState::VerifyRegisteredTestNames(
 // This file implements cardinalities.
 
 #include <limits.h>
+
 #include <ostream>  // NOLINT
 #include <sstream>
 #include <string>
@@ -9646,6 +9650,7 @@ GTEST_API_ Cardinality Exactly(int n) { return Between(n, n); }
 // USE THEM IN USER CODE.
 
 #include <ctype.h>
+
 #include <ostream>  // NOLINT
 #include <string>
 
@@ -9808,6 +9813,7 @@ GTEST_API_ void Log(LogSeverity severity, const string& message,
 // utilities for defining matchers.
 
 #include <string.h>
+
 #include <sstream>
 #include <string>
 
@@ -10291,6 +10297,7 @@ bool UnorderedElementsAreMatcherImplBase::
 // EXPECT_CALL).
 
 #include <stdlib.h>
+
 #include <iostream>  // NOLINT
 #include <map>
 #include <set>

test/gtest-extra-test.cc

@@ -8,6 +8,7 @@
 #include "gtest-extra.h"
 
 #include <gtest/gtest-spi.h>
+
 #include <algorithm>
 #include <cstring>
 #include <memory>
@@ -167,22 +168,24 @@ TEST_F(SingleEvaluationTest, FailedEXPECT_WRITE) {
 // Tests that assertion arguments are evaluated exactly once.
 TEST_F(SingleEvaluationTest, WriteTests) {
   // successful EXPECT_WRITE
-  EXPECT_WRITE(stdout,
-               {  // NOLINT
-                 a_++;
-                 std::printf("test");
-               },
-               (b_++, "test"));
+  EXPECT_WRITE(
+      stdout,
+      {  // NOLINT
+        a_++;
+        std::printf("test");
+      },
+      (b_++, "test"));
   EXPECT_EQ(1, a_);
   EXPECT_EQ(1, b_);
 
   // failed EXPECT_WRITE
-  EXPECT_NONFATAL_FAILURE(EXPECT_WRITE(stdout,
-                                       {  // NOLINT
-                                         a_++;
-                                         std::printf("test");
-                                       },
-                                       (b_++, "other")),
+  EXPECT_NONFATAL_FAILURE(EXPECT_WRITE(
+                              stdout,
+                              {  // NOLINT
+                                a_++;
+                                std::printf("test");
+                              },
+                              (b_++, "other")),
                           "Actual: test");
   EXPECT_EQ(2, a_);
   EXPECT_EQ(2, b_);
@@ -417,16 +420,17 @@ TEST(OutputRedirectTest, ErrorInDtor) {
   std::unique_ptr<OutputRedirect> redir(new OutputRedirect(f.get()));
   // Put a character in a file buffer.
   EXPECT_EQ('x', fputc('x', f.get()));
-  EXPECT_WRITE(stderr,
-               {
-                 // The close function must be called inside EXPECT_WRITE,
-                 // otherwise the system may recycle closed file descriptor when
-                 // redirecting the output in EXPECT_STDERR and the second close
-                 // will break output redirection.
-                 FMT_POSIX(close(write_fd));
-                 SUPPRESS_ASSERT(redir.reset(nullptr));
-               },
-               format_system_error(EBADF, "cannot flush stream"));
+  EXPECT_WRITE(
+      stderr,
+      {
+        // The close function must be called inside EXPECT_WRITE,
+        // otherwise the system may recycle closed file descriptor when
+        // redirecting the output in EXPECT_STDERR and the second close
+        // will break output redirection.
+        FMT_POSIX(close(write_fd));
+        SUPPRESS_ASSERT(redir.reset(nullptr));
+      },
+      format_system_error(EBADF, "cannot flush stream"));
   write_copy.dup2(write_fd);  // "undo" close or dtor of buffered_file will fail
 }
 

test/gtest-extra.cc

@@ -57,7 +57,7 @@ std::string OutputRedirect::restore_and_read() {
   if (read_end_.descriptor() == -1) return content;  // Already read.
   enum { BUFFER_SIZE = 4096 };
   char buffer[BUFFER_SIZE];
-  std::size_t count = 0;
+  size_t count = 0;
   do {
     count = read_end_.read(buffer, BUFFER_SIZE);
     content.append(buffer, count);
@@ -66,9 +66,9 @@ std::string OutputRedirect::restore_and_read() {
   return content;
 }
 
-std::string read(file& f, std::size_t count) {
+std::string read(file& f, size_t count) {
   std::string buffer(count, '\0');
-  std::size_t n = 0, offset = 0;
+  size_t n = 0, offset = 0;
   do {
     n = f.read(&buffer[offset], count - offset);
     // We can't read more than size_t bytes since count has type size_t.

test/gtest-extra.h

@@ -9,8 +9,9 @@
 #define FMT_GTEST_EXTRA_H_
 
 #include <string>
-#include "gmock.h"
+
 #include "fmt/os.h"
+#include "gmock.h"
 
 #define FMT_TEST_THROW_(statement, expected_exception, expected_message, fail) \
   GTEST_AMBIGUOUS_ELSE_BLOCKER_                                                \
@@ -137,7 +138,7 @@ class SuppressAssert {
     EXPECT_SYSTEM_ERROR(SUPPRESS_ASSERT(statement), error_code, message)
 
 // Attempts to read count characters from a file.
-std::string read(fmt::file& f, std::size_t count);
+std::string read(fmt::file& f, size_t count);
 
 #  define EXPECT_READ(file, expected_content) \
     EXPECT_EQ(expected_content, read(file, std::strlen(expected_content)))

test/locale-test.cc

@@ -6,6 +6,7 @@
 // For the license information refer to format.h.
 
 #include "fmt/locale.h"
+
 #include "gmock.h"
 
 using fmt::internal::max_value;

test/mock-allocator.h

@@ -16,8 +16,8 @@ template <typename T> class mock_allocator {
   mock_allocator() {}
   mock_allocator(const mock_allocator&) {}
   typedef T value_type;
-  MOCK_METHOD1_T(allocate, T*(std::size_t n));
-  MOCK_METHOD2_T(deallocate, void(T* p, std::size_t n));
+  MOCK_METHOD1_T(allocate, T*(size_t n));
+  MOCK_METHOD2_T(deallocate, void(T* p, size_t n));
 };
 
 template <typename Allocator> class allocator_ref {
@@ -51,10 +51,10 @@ template <typename Allocator> class allocator_ref {
  public:
   Allocator* get() const { return alloc_; }
 
-  value_type* allocate(std::size_t n) {
+  value_type* allocate(size_t n) {
     return std::allocator_traits<Allocator>::allocate(*alloc_, n);
   }
-  void deallocate(value_type* p, std::size_t n) { alloc_->deallocate(p, n); }
+  void deallocate(value_type* p, size_t n) { alloc_->deallocate(p, n); }
 };
 
 #endif  // FMT_MOCK_ALLOCATOR_H_

test/os-test.cc

@@ -5,11 +5,12 @@
 //
 // For the license information refer to format.h.
 
+#include "fmt/os.h"
+
 #include <cstdlib>  // std::exit
 #include <cstring>
 #include <memory>
 
-#include "fmt/os.h"
 #include "gtest-extra.h"
 #include "util.h"
 
@@ -164,10 +165,10 @@ static file open_file() {
 
 // Attempts to write a string to a file.
 static void write(file& f, fmt::string_view s) {
-  std::size_t num_chars_left = s.size();
+  size_t num_chars_left = s.size();
   const char* ptr = s.data();
   do {
-    std::size_t count = f.write(ptr, num_chars_left);
+    size_t count = f.write(ptr, num_chars_left);
     ptr += count;
     // We can't write more than size_t bytes since num_chars_left
     // has type size_t.
@@ -238,16 +239,17 @@ TEST(BufferedFileTest, CloseFileInDtor) {
 
 TEST(BufferedFileTest, CloseErrorInDtor) {
   std::unique_ptr<buffered_file> f(new buffered_file(open_buffered_file()));
-  EXPECT_WRITE(stderr,
-               {
-                 // The close function must be called inside EXPECT_WRITE,
-                 // otherwise the system may recycle closed file descriptor when
-                 // redirecting the output in EXPECT_STDERR and the second close
-                 // will break output redirection.
-                 FMT_POSIX(close(f->fileno()));
-                 SUPPRESS_ASSERT(f.reset(nullptr));
-               },
-               format_system_error(EBADF, "cannot close file") + "\n");
+  EXPECT_WRITE(
+      stderr,
+      {
+        // The close function must be called inside EXPECT_WRITE,
+        // otherwise the system may recycle closed file descriptor when
+        // redirecting the output in EXPECT_STDERR and the second close
+        // will break output redirection.
+        FMT_POSIX(close(f->fileno()));
+        SUPPRESS_ASSERT(f.reset(nullptr));
+      },
+      format_system_error(EBADF, "cannot close file") + "\n");
 }
 
 TEST(BufferedFileTest, Close) {
@@ -369,16 +371,17 @@ TEST(FileTest, CloseFileInDtor) {
 
 TEST(FileTest, CloseErrorInDtor) {
   std::unique_ptr<file> f(new file(open_file()));
-  EXPECT_WRITE(stderr,
-               {
-                 // The close function must be called inside EXPECT_WRITE,
-                 // otherwise the system may recycle closed file descriptor when
-                 // redirecting the output in EXPECT_STDERR and the second close
-                 // will break output redirection.
-                 FMT_POSIX(close(f->descriptor()));
-                 SUPPRESS_ASSERT(f.reset(nullptr));
-               },
-               format_system_error(EBADF, "cannot close file") + "\n");
+  EXPECT_WRITE(
+      stderr,
+      {
+        // The close function must be called inside EXPECT_WRITE,
+        // otherwise the system may recycle closed file descriptor when
+        // redirecting the output in EXPECT_STDERR and the second close
+        // will break output redirection.
+        FMT_POSIX(close(f->descriptor()));
+        SUPPRESS_ASSERT(f.reset(nullptr));
+      },
+      format_system_error(EBADF, "cannot close file") + "\n");
 }
 
 TEST(FileTest, Close) {
@@ -495,4 +498,4 @@ TEST(LocaleTest, Strtod) {
   EXPECT_EQ(start + 3, ptr);
 }
 #  endif
-#endif  // FMT_USE_FCNTL
\ No newline at end of file
+#endif  // FMT_USE_FCNTL

test/ostream-test.cc

@@ -145,13 +145,13 @@ TEST(OStreamTest, WriteToOStream) {
 }
 
 TEST(OStreamTest, WriteToOStreamMaxSize) {
-  std::size_t max_size = fmt::internal::max_value<std::size_t>();
+  size_t max_size = fmt::internal::max_value<size_t>();
   std::streamsize max_streamsize = fmt::internal::max_value<std::streamsize>();
   if (max_size <= fmt::internal::to_unsigned(max_streamsize)) return;
 
   struct test_buffer : fmt::internal::buffer<char> {
-    explicit test_buffer(std::size_t size) { resize(size); }
-    void grow(std::size_t) {}
+    explicit test_buffer(size_t size) { resize(size); }
+    void grow(size_t) {}
   } buffer(max_size);
 
   struct mock_streambuf : std::streambuf {
@@ -258,7 +258,7 @@ TEST(OStreamTest, DisableBuiltinOStreamOperators) {
 struct explicitly_convertible_to_string_like {
   template <typename String,
             typename = typename std::enable_if<std::is_constructible<
-                String, const char*, std::size_t>::value>::type>
+                String, const char*, size_t>::value>::type>
   explicit operator String() const {
     return String("foo", 3u);
   }

test/posix-mock-test.cc

@@ -49,8 +49,8 @@ int pipe_count;
 int fopen_count;
 int fclose_count;
 int fileno_count;
-std::size_t read_nbyte;
-std::size_t write_nbyte;
+size_t read_nbyte;
+size_t write_nbyte;
 bool sysconf_error;
 
 enum { NONE, MAX_SIZE, ERROR } fstat_sim;
@@ -288,7 +288,7 @@ TEST(FileTest, ReadRetry) {
   write_end.write("test", SIZE);
   write_end.close();
   char buffer[SIZE];
-  std::size_t count = 0;
+  size_t count = 0;
   EXPECT_RETRY(count = read_end.read(buffer, SIZE), read,
                "cannot read from file");
   EXPECT_EQ_POSIX(static_cast<std::streamsize>(SIZE), count);
@@ -298,7 +298,7 @@ TEST(FileTest, WriteRetry) {
   file read_end, write_end;
   file::pipe(read_end, write_end);
   enum { SIZE = 4 };
-  std::size_t count = 0;
+  size_t count = 0;
   EXPECT_RETRY(count = write_end.write("test", SIZE), write,
                "cannot write to file");
   write_end.close();
@@ -316,8 +316,8 @@ TEST(FileTest, ConvertReadCount) {
   file read_end, write_end;
   file::pipe(read_end, write_end);
   char c;
-  std::size_t size = UINT_MAX;
-  if (sizeof(unsigned) != sizeof(std::size_t)) ++size;
+  size_t size = UINT_MAX;
+  if (sizeof(unsigned) != sizeof(size_t)) ++size;
   read_count = 1;
   read_nbyte = 0;
   EXPECT_THROW(read_end.read(&c, size), fmt::system_error);
@@ -329,8 +329,8 @@ TEST(FileTest, ConvertWriteCount) {
   file read_end, write_end;
   file::pipe(read_end, write_end);
   char c;
-  std::size_t size = UINT_MAX;
-  if (sizeof(unsigned) != sizeof(std::size_t)) ++size;
+  size_t size = UINT_MAX;
+  if (sizeof(unsigned) != sizeof(size_t)) ++size;
   write_count = 1;
   write_nbyte = 0;
   EXPECT_THROW(write_end.write(&c, size), fmt::system_error);

test/printf-test.cc

@@ -119,8 +119,7 @@ TEST(PrintfTest, InvalidArgIndex) {
   EXPECT_THROW_MSG(test_sprintf(format("%{}$d", INT_MAX), 42), format_error,
                    "argument not found");
 
-  EXPECT_THROW_MSG(test_sprintf("%2$", 42), format_error,
-                   "argument not found");
+  EXPECT_THROW_MSG(test_sprintf("%2$", 42), format_error, "argument not found");
   EXPECT_THROW_MSG(test_sprintf(format("%{}$d", BIG_NUM), 42), format_error,
                    "number is too big");
 }
@@ -222,8 +221,7 @@ TEST(PrintfTest, DynamicWidth) {
   EXPECT_EQ("42   ", test_sprintf("%*d", -5, 42));
   EXPECT_THROW_MSG(test_sprintf("%*d", 5.0, 42), format_error,
                    "width is not integer");
-  EXPECT_THROW_MSG(test_sprintf("%*d"), format_error,
-                   "argument not found");
+  EXPECT_THROW_MSG(test_sprintf("%*d"), format_error, "argument not found");
   EXPECT_THROW_MSG(test_sprintf("%*d", BIG_NUM, 42), format_error,
                    "number is too big");
 }
@@ -273,8 +271,7 @@ TEST(PrintfTest, DynamicPrecision) {
   EXPECT_EQ("42", test_sprintf("%.*d", -5, 42));
   EXPECT_THROW_MSG(test_sprintf("%.*d", 5.0, 42), format_error,
                    "precision is not integer");
-  EXPECT_THROW_MSG(test_sprintf("%.*d"), format_error,
-                   "argument not found");
+  EXPECT_THROW_MSG(test_sprintf("%.*d"), format_error, "argument not found");
   EXPECT_THROW_MSG(test_sprintf("%.*d", BIG_NUM, 42), format_error,
                    "number is too big");
   if (sizeof(long long) != sizeof(int)) {
@@ -372,7 +369,7 @@ TEST(PrintfTest, Length) {
   TestLength<long long>("ll");
   TestLength<unsigned long long>("ll");
   TestLength<intmax_t>("j");
-  TestLength<std::size_t>("z");
+  TestLength<size_t>("z");
   TestLength<std::ptrdiff_t>("t");
   long double max = max_value<long double>();
   EXPECT_PRINTF(fmt::format("{:.6}", max), "%g", max);

test/ranges-test.cc

@@ -79,7 +79,7 @@ TEST(RangesTest, JoinInitializerList) {
 struct my_struct {
   int32_t i;
   std::string str;  // can throw
-  template <std::size_t N> decltype(auto) get() const noexcept {
+  template <size_t N> decltype(auto) get() const noexcept {
     if constexpr (N == 0)
       return i;
     else if constexpr (N == 1)
@@ -87,16 +87,15 @@ struct my_struct {
   }
 };
 
-template <std::size_t N> decltype(auto) get(const my_struct& s) noexcept {
+template <size_t N> decltype(auto) get(const my_struct& s) noexcept {
   return s.get<N>();
 }
 
 namespace std {
 
-template <>
-struct tuple_size<my_struct> : std::integral_constant<std::size_t, 2> {};
+template <> struct tuple_size<my_struct> : std::integral_constant<size_t, 2> {};
 
-template <std::size_t N> struct tuple_element<N, my_struct> {
+template <size_t N> struct tuple_element<N, my_struct> {
   using type = decltype(std::declval<my_struct>().get<N>());
 };
 

test/scan-test.cc

@@ -5,12 +5,14 @@
 //
 // For the license information refer to format.h.
 
+#include "scan.h"
+
 #include <time.h>
+
 #include <climits>
 
 #include "gmock.h"
 #include "gtest-extra.h"
-#include "scan.h"
 
 TEST(ScanTest, ReadText) {
   fmt::string_view s = "foo";

test/std-format-test.cc

 #include <format>
+
 #include "gtest.h"
 
 TEST(StdFormatTest, Escaping) {

test/test-assert.h

@@ -9,6 +9,7 @@
 #define FMT_TEST_ASSERT_H_
 
 #include <stdexcept>
+
 #include "gtest.h"
 
 class assertion_failure : public std::logic_error {

test/test-main.cc

@@ -6,6 +6,7 @@
 // For the license information refer to format.h.
 
 #include <cstdlib>
+
 #include "gtest.h"
 
 #ifdef _WIN32

test/util.cc

@@ -6,6 +6,7 @@
 // For the license information refer to format.h.
 
 #include "util.h"
+
 #include <cstring>
 
 void increment(char* s) {

test/util.h

@@ -19,7 +19,7 @@ enum { BUFFER_SIZE = 256 };
 #  define FMT_VSNPRINTF vsnprintf
 #endif
 
-template <std::size_t SIZE>
+template <size_t SIZE>
 void safe_sprintf(char (&buffer)[SIZE], const char* format, ...) {
   std::va_list args;
   va_start(args, format);