Format the code using clang-format

test/core-test.cc

@@ -11,9 +11,9 @@
 #include <functional>
 #include <iterator>
 #include <limits>
+#include <memory>
 #include <string>
 #include <type_traits>
-#include <memory>
 
 #include "test-assert.h"
 
@@ -21,7 +21,7 @@
 
 // Check if fmt/core.h compiles with windows.h included before it.
 #ifdef _WIN32
-# include <windows.h>
+#  include <windows.h>
 #endif
 
 #include "fmt/core.h"
@@ -30,9 +30,9 @@
 #undef max
 
 using fmt::basic_format_arg;
+using fmt::string_view;
 using fmt::internal::basic_buffer;
 using fmt::internal::value;
-using fmt::string_view;
 
 using testing::_;
 using testing::StrictMock;
@@ -42,24 +42,23 @@ namespace {
 struct test_struct {};
 
 template <typename Context, typename T>
-basic_format_arg<Context> make_arg(const T &value) {
+basic_format_arg<Context> make_arg(const T& value) {
   return fmt::internal::make_arg<Context>(value);
 }
 }  // namespace
 
 FMT_BEGIN_NAMESPACE
-template <typename Char>
-struct formatter<test_struct, Char> {
+template <typename Char> struct formatter<test_struct, Char> {
   template <typename ParseContext>
-  auto parse(ParseContext &ctx) -> decltype(ctx.begin()) {
+  auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
     return ctx.begin();
   }
 
   typedef std::back_insert_iterator<basic_buffer<Char>> iterator;
 
-  auto format(test_struct, basic_format_context<iterator, char> &ctx)
+  auto format(test_struct, basic_format_context<iterator, char>& ctx)
       -> decltype(ctx.out()) {
-    const Char *test = "test";
+    const Char* test = "test";
     return std::copy_n(test, std::strlen(test), ctx.out());
   }
 };
@@ -67,31 +66,29 @@ FMT_END_NAMESPACE
 
 #if !FMT_GCC_VERSION || FMT_GCC_VERSION >= 470
 TEST(BufferTest, Noncopyable) {
-  EXPECT_FALSE(std::is_copy_constructible<basic_buffer<char> >::value);
-#if !FMT_MSC_VER
+  EXPECT_FALSE(std::is_copy_constructible<basic_buffer<char>>::value);
+#  if !FMT_MSC_VER
   // std::is_copy_assignable is broken in MSVC2013.
-  EXPECT_FALSE(std::is_copy_assignable<basic_buffer<char> >::value);
-#endif
+  EXPECT_FALSE(std::is_copy_assignable<basic_buffer<char>>::value);
+#  endif
 }
 
 TEST(BufferTest, Nonmoveable) {
-  EXPECT_FALSE(std::is_move_constructible<basic_buffer<char> >::value);
-#if !FMT_MSC_VER
+  EXPECT_FALSE(std::is_move_constructible<basic_buffer<char>>::value);
+#  if !FMT_MSC_VER
   // std::is_move_assignable is broken in MSVC2013.
-  EXPECT_FALSE(std::is_move_assignable<basic_buffer<char> >::value);
-#endif
+  EXPECT_FALSE(std::is_move_assignable<basic_buffer<char>>::value);
+#  endif
 }
 #endif
 
 // A test buffer with a dummy grow method.
-template <typename T>
-struct test_buffer : basic_buffer<T> {
+template <typename T> struct test_buffer : basic_buffer<T> {
   void grow(std::size_t capacity) { this->set(FMT_NULL, capacity); }
 };
 
-template <typename T>
-struct mock_buffer : basic_buffer<T> {
-  MOCK_METHOD1(do_grow, void (std::size_t capacity));
+template <typename T> struct mock_buffer : basic_buffer<T> {
+  MOCK_METHOD1(do_grow, void(std::size_t capacity));
 
   void grow(std::size_t capacity) {
     this->set(this->data(), capacity);
@@ -99,8 +96,8 @@ struct mock_buffer : basic_buffer<T> {
   }
 
   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) { this->set(data, 0); }
+  mock_buffer(T* data, std::size_t capacity) { this->set(data, capacity); }
 };
 
 TEST(BufferTest, Ctor) {
@@ -134,9 +131,9 @@ struct dying_buffer : test_buffer<int> {
 
 TEST(BufferTest, VirtualDtor) {
   typedef StrictMock<dying_buffer> stict_mock_buffer;
-  stict_mock_buffer *mock_buffer = new stict_mock_buffer();
+  stict_mock_buffer* mock_buffer = new stict_mock_buffer();
   EXPECT_CALL(*mock_buffer, die());
-  basic_buffer<int> *buffer = mock_buffer;
+  basic_buffer<int>* buffer = mock_buffer;
   delete buffer;
 }
 
@@ -147,7 +144,7 @@ TEST(BufferTest, Access) {
   EXPECT_EQ(11, buffer[0]);
   buffer[3] = 42;
   EXPECT_EQ(42, *(&buffer[0] + 3));
-  const basic_buffer<char> &const_buffer = buffer;
+  const basic_buffer<char>& const_buffer = buffer;
   EXPECT_EQ(42, const_buffer[3]);
 }
 
@@ -182,7 +179,7 @@ TEST(BufferTest, Clear) {
 TEST(BufferTest, Append) {
   char data[15];
   mock_buffer<char> buffer(data, 10);
-  const char *test = "test";
+  const char* test = "test";
   buffer.append(test, test + 5);
   EXPECT_STREQ(test, &buffer[0]);
   EXPECT_EQ(5u, buffer.size());
@@ -197,7 +194,7 @@ TEST(BufferTest, Append) {
 TEST(BufferTest, AppendAllocatesEnoughStorage) {
   char data[19];
   mock_buffer<char> buffer(data, 10);
-  const char *test = "abcdefgh";
+  const char* test = "abcdefgh";
   buffer.resize(10);
   EXPECT_CALL(buffer, do_grow(19));
   buffer.append(test, test + 9);
@@ -211,15 +208,14 @@ TEST(ArgTest, FormatArgs) {
 struct custom_context {
   typedef char char_type;
 
-  template <typename T>
-  struct formatter_type {
+  template <typename T> struct formatter_type {
     struct type {
       template <typename ParseContext>
-      auto parse(ParseContext &ctx) -> decltype(ctx.begin()) {
+      auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
         return ctx.begin();
       }
 
-      const char *format(const T &, custom_context& ctx) {
+      const char* format(const T&, custom_context& ctx) {
         ctx.called = true;
         return FMT_NULL;
       }
@@ -231,7 +227,7 @@ struct custom_context {
   fmt::format_parse_context parse_context() {
     return fmt::format_parse_context("");
   }
-  void advance_to(const char *) {}
+  void advance_to(const char*) {}
 };
 
 TEST(ArgTest, MakeValueWithCustomContext) {
@@ -249,40 +245,35 @@ template <typename Char>
 bool operator==(custom_value<Char> lhs, custom_value<Char> rhs) {
   return lhs.value == rhs.value;
 }
-}
+}  // namespace internal
 FMT_END_NAMESPACE
 
 // Use a unique result type to make sure that there are no undesirable
 // conversions.
 struct test_result {};
 
-template <typename T>
-struct mock_visitor {
-  template <typename U>
-  struct result { typedef test_result type; };
+template <typename T> struct mock_visitor {
+  template <typename U> struct result { typedef test_result type; };
 
   mock_visitor() {
     ON_CALL(*this, visit(_)).WillByDefault(testing::Return(test_result()));
   }
 
-  MOCK_METHOD1_T(visit, test_result (T value));
-  MOCK_METHOD0_T(unexpected, void ());
+  MOCK_METHOD1_T(visit, test_result(T value));
+  MOCK_METHOD0_T(unexpected, void());
 
   test_result operator()(T value) { return visit(value); }
 
-  template <typename U>
-  test_result operator()(U) {
+  template <typename U> test_result operator()(U) {
     unexpected();
     return test_result();
   }
 };
 
-template <typename T>
-struct visit_type { typedef T Type; };
+template <typename T> struct visit_type { typedef T Type; };
 
 #define VISIT_TYPE(Type_, visit_type_) \
-  template <> \
-  struct visit_type<Type_> { typedef visit_type_ Type; }
+  template <> struct visit_type<Type_> { typedef visit_type_ Type; }
 
 VISIT_TYPE(signed char, int);
 VISIT_TYPE(unsigned char, unsigned);
@@ -299,28 +290,30 @@ VISIT_TYPE(unsigned long, unsigned long long);
 
 VISIT_TYPE(float, double);
 
-#define CHECK_ARG_(Char, expected, value) { \
-  testing::StrictMock<mock_visitor<decltype(expected)>> visitor; \
-  EXPECT_CALL(visitor, visit(expected)); \
-  typedef std::back_insert_iterator<basic_buffer<Char>> iterator; \
-  fmt::visit(visitor, \
-      make_arg<fmt::basic_format_context<iterator, Char>>(value)); \
-}
+#define CHECK_ARG_(Char, expected, value)                                   \
+  {                                                                         \
+    testing::StrictMock<mock_visitor<decltype(expected)>> visitor;          \
+    EXPECT_CALL(visitor, visit(expected));                                  \
+    typedef std::back_insert_iterator<basic_buffer<Char>> iterator;         \
+    fmt::visit(visitor,                                                     \
+               make_arg<fmt::basic_format_context<iterator, Char>>(value)); \
+  }
 
-#define CHECK_ARG(value, typename_) { \
-  typedef decltype(value) value_type; \
-  typename_ visit_type<value_type>::Type expected = value; \
-  CHECK_ARG_(char, expected, value) \
-  CHECK_ARG_(wchar_t, expected, value) \
-}
+#define CHECK_ARG(value, typename_)                          \
+  {                                                          \
+    typedef decltype(value) value_type;                      \
+    typename_ visit_type<value_type>::Type expected = value; \
+    CHECK_ARG_(char, expected, value)                        \
+    CHECK_ARG_(wchar_t, expected, value)                     \
+  }
 
-template <typename T>
-class NumericArgTest : public testing::Test {};
+template <typename T> class NumericArgTest : public testing::Test {};
 
-typedef ::testing::Types<
-  bool, signed char, unsigned char, signed, unsigned short,
-  int, unsigned, long, unsigned long, long long, unsigned long long,
-  float, double, long double> Types;
+typedef ::testing::Types<bool, signed char, unsigned char, signed,
+                         unsigned short, int, unsigned, long, unsigned long,
+                         long long, unsigned long long, float, double,
+                         long double>
+    Types;
 TYPED_TEST_CASE(NumericArgTest, Types);
 
 template <typename T>
@@ -330,7 +323,7 @@ typename std::enable_if<std::is_integral<T>::value, T>::type test_value() {
 
 template <typename T>
 typename std::enable_if<std::is_floating_point<T>::value, T>::type
-    test_value() {
+test_value() {
   return static_cast<T>(4.2);
 }
 
@@ -348,8 +341,8 @@ TEST(ArgTest, CharArg) {
 
 TEST(ArgTest, StringArg) {
   char str_data[] = "test";
-  char *str = str_data;
-  const char *cstr = str;
+  char* str = str_data;
+  const char* cstr = str;
   CHECK_ARG_(char, cstr, str);
 
   string_view sref(str);
@@ -358,8 +351,8 @@ TEST(ArgTest, StringArg) {
 
 TEST(ArgTest, WStringArg) {
   wchar_t str_data[] = L"test";
-  wchar_t *str = str_data;
-  const wchar_t *cstr = str;
+  wchar_t* str = str_data;
+  const wchar_t* cstr = str;
 
   fmt::wstring_view sref(str);
   CHECK_ARG_(wchar_t, cstr, str);
@@ -369,8 +362,8 @@ TEST(ArgTest, WStringArg) {
 }
 
 TEST(ArgTest, PointerArg) {
-  void *p = FMT_NULL;
-  const void *cp = FMT_NULL;
+  void* p = FMT_NULL;
+  const void* cp = FMT_NULL;
   CHECK_ARG_(char, cp, p);
   CHECK_ARG_(wchar_t, cp, p);
   CHECK_ARG(cp, );
@@ -384,7 +377,7 @@ struct check_custom {
       test_buffer() : fmt::internal::basic_buffer<char>(data, 0, 10) {}
       void grow(std::size_t) {}
     } buffer;
-    fmt::internal::basic_buffer<char> &base = buffer;
+    fmt::internal::basic_buffer<char>& base = buffer;
     fmt::format_context ctx(std::back_inserter(base), "", fmt::format_args());
     h.format(ctx);
     EXPECT_EQ("test", std::string(buffer.data, buffer.size()));
@@ -395,14 +388,14 @@ struct check_custom {
 TEST(ArgTest, CustomArg) {
   test_struct test;
   typedef mock_visitor<fmt::basic_format_arg<fmt::format_context>::handle>
-    visitor;
+      visitor;
   testing::StrictMock<visitor> v;
   EXPECT_CALL(v, visit(_)).WillOnce(testing::Invoke(check_custom()));
   fmt::visit(v, make_arg<fmt::format_context>(test));
 }
 
 TEST(ArgTest, VisitInvalidArg) {
-  testing::StrictMock< mock_visitor<fmt::monostate> > visitor;
+  testing::StrictMock<mock_visitor<fmt::monostate>> visitor;
   EXPECT_CALL(visitor, visit(_));
   fmt::basic_format_arg<fmt::format_context> arg;
   visit(visitor, arg);
@@ -416,9 +409,8 @@ TEST(StringViewTest, Length) {
 }
 
 // Check string_view's comparison operator.
-template <template <typename> class Op>
-void check_op() {
-  const char *inputs[] = {"foo", "fop", "fo"};
+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) {
@@ -446,7 +438,7 @@ enum basic_enum {};
 
 TEST(CoreTest, ConvertToInt) {
   EXPECT_FALSE((fmt::convert_to_int<char, char>::value));
-  EXPECT_FALSE((fmt::convert_to_int<const char *, char>::value));
+  EXPECT_FALSE((fmt::convert_to_int<const char*, char>::value));
   EXPECT_TRUE((fmt::convert_to_int<basic_enum, char>::value));
 }
 
@@ -457,31 +449,31 @@ TEST(CoreTest, IsEnumConvertibleToInt) {
 }
 
 namespace my_ns {
-template <typename Char>
-class my_string {
+template <typename Char> class my_string {
  public:
-  my_string(const Char *s) : s_(s) {}
-  const Char * data() const FMT_NOEXCEPT { return s_.data(); }
+  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(); }
   operator const Char*() const { return s_.c_str(); }
+
  private:
   std::basic_string<Char> s_;
 };
 
 template <typename Char>
-inline fmt::basic_string_view<Char>
-    to_string_view(const my_string<Char> &s) FMT_NOEXCEPT {
-  return { s.data(), s.length() };
+inline fmt::basic_string_view<Char> to_string_view(const my_string<Char>& s)
+    FMT_NOEXCEPT {
+  return {s.data(), s.length()};
 }
 
 struct non_string {};
-}
+}  // namespace my_ns
 
 namespace FakeQt {
 class QString {
  public:
-  QString(const wchar_t *s) : s_(std::make_shared<std::wstring>(s)) {}
-  const wchar_t *utf16() const FMT_NOEXCEPT { return s_->data(); }
+  QString(const wchar_t* s) : s_(std::make_shared<std::wstring>(s)) {}
+  const wchar_t* utf16() const FMT_NOEXCEPT { return s_->data(); }
   int size() const FMT_NOEXCEPT { return static_cast<int>(s_->size()); }
 #ifdef FMT_STRING_VIEW
   operator FMT_STRING_VIEW<wchar_t>() const FMT_NOEXCEPT { return *s_; }
@@ -490,15 +482,13 @@ class QString {
   std::shared_ptr<std::wstring> s_;
 };
 
-inline fmt::basic_string_view<wchar_t> to_string_view(
-    const QString &s) FMT_NOEXCEPT {
-  return {s.utf16(),
-          static_cast<std::size_t>(s.size())};
-}
+inline fmt::basic_string_view<wchar_t> to_string_view(const QString& s)
+    FMT_NOEXCEPT {
+  return {s.utf16(), static_cast<std::size_t>(s.size())};
 }
+}  // namespace FakeQt
 
-template <typename T>
-class IsStringTest : public testing::Test {};
+template <typename T> class IsStringTest : public testing::Test {};
 
 typedef ::testing::Types<char, wchar_t, char16_t, char32_t> StringCharTypes;
 TYPED_TEST_CASE(IsStringTest, StringCharTypes);
@@ -506,18 +496,18 @@ TYPED_TEST_CASE(IsStringTest, StringCharTypes);
 namespace {
 template <typename Char>
 struct derived_from_string_view : fmt::basic_string_view<Char> {};
-}
+}  // namespace
 
 TYPED_TEST(IsStringTest, IsString) {
-  EXPECT_TRUE((fmt::internal::is_string<TypeParam *>::value));
-  EXPECT_TRUE((fmt::internal::is_string<const TypeParam *>::value));
+  EXPECT_TRUE((fmt::internal::is_string<TypeParam*>::value));
+  EXPECT_TRUE((fmt::internal::is_string<const TypeParam*>::value));
   EXPECT_TRUE((fmt::internal::is_string<TypeParam[2]>::value));
   EXPECT_TRUE((fmt::internal::is_string<const TypeParam[2]>::value));
   EXPECT_TRUE((fmt::internal::is_string<std::basic_string<TypeParam>>::value));
   EXPECT_TRUE(
-        (fmt::internal::is_string<fmt::basic_string_view<TypeParam>>::value));
+      (fmt::internal::is_string<fmt::basic_string_view<TypeParam>>::value));
   EXPECT_TRUE(
-        (fmt::internal::is_string<derived_from_string_view<TypeParam>>::value));
+      (fmt::internal::is_string<derived_from_string_view<TypeParam>>::value));
 #ifdef FMT_STRING_VIEW
   EXPECT_TRUE((fmt::internal::is_string<FMT_STRING_VIEW<TypeParam>>::value));
 #endif
@@ -529,7 +519,7 @@ TYPED_TEST(IsStringTest, IsString) {
 TEST(CoreTest, Format) {
   // This should work without including fmt/format.h.
 #ifdef FMT_FORMAT_H_
-# error fmt/format.h must not be included in the core test
+#  error fmt/format.h must not be included in the core test
 #endif
   EXPECT_EQ(fmt::format("{}", 42), "42");
 }
@@ -537,7 +527,7 @@ TEST(CoreTest, Format) {
 TEST(CoreTest, FormatTo) {
   // This should work without including fmt/format.h.
 #ifdef FMT_FORMAT_H_
-# error fmt/format.h must not be included in the core test
+#  error fmt/format.h must not be included in the core test
 #endif
   std::string s;
   fmt::format_to(std::back_inserter(s), "{}", 42);
@@ -600,11 +590,12 @@ TEST(FormatterTest, FormatExplicitlyConvertibleToWStringView) {
 }
 
 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>
-  FMT_EXPLICIT operator String() const { return String("foo", 3u); }
+  template <typename String,
+            typename = typename std::enable_if<std::is_constructible<
+                String, const char*, std::size_t>::value>::type>
+  FMT_EXPLICIT operator String() const {
+    return String("foo", 3u);
+  }
 };
 
 TEST(FormatterTest, FormatExplicitlyConvertibleToStringLike) {