Update version

- Disable templated user-defined literals when compiled under nvcc

Similarly to Intel's C++ compiler, nvcc fails to compile templated UDLs
as they both share the same parsing engine (EDG C++ Front End).  This
fixes building CUDA programs which make use of fmt.

.travis.yml

@@ -84,38 +84,38 @@ matrix:
           sources:
             - ubuntu-toolchain-r-test
       # Android
-    - language: android
-      android:
-      addons:
-        apt:
-          update: true
-      components:
-        - tools
-        - platform-tools
-        - android-21
-        - sys-img-armeabi-v7a-android-21
-      env:
-        - ANDROID=true
-      before_install:
-        - git submodule update --init --recursive
-        - sudo apt-get install wget unzip tree
-      install:
-        # Accept SDK Licenses + Install NDK
-        - yes | sdkmanager --update > /dev/null 2>&1
-        - sdkmanager ndk-bundle > /dev/null 2>&1
-        # Download Gradle 4.3.1 
-        - wget https://services.gradle.org/distributions/gradle-4.3.1-bin.zip
-        - mkdir -p gradle
-        - unzip -q -d ./gradle gradle-4.3.1-bin.zip
-        - export GRADLE=${TRAVIS_BUILD_DIR}/gradle/gradle-4.3.1/bin/gradle
-      before_script:
-        - bash $GRADLE --version
-        - cd ./support
-      script:
-        - bash $GRADLE clean assemble
-      after_success:
-        - cd ${TRAVIS_BUILD_DIR}
-        - tree ./libs
+#    - language: android
+#      android:
+#      addons:
+#        apt:
+#          update: true
+#      components:
+#        - tools
+#        - platform-tools
+#        - android-21
+#        - sys-img-armeabi-v7a-android-21
+#      env:
+#        - ANDROID=true
+#      before_install:
+#        - git submodule update --init --recursive
+#        - sudo apt-get install wget unzip tree
+#      install:
+#        # Accept SDK Licenses + Install NDK
+#        - yes | sdkmanager --update > /dev/null 2>&1
+#        - sdkmanager ndk-bundle > /dev/null 2>&1
+#        # Download Gradle 4.3.1 
+#        - wget https://services.gradle.org/distributions/gradle-4.3.1-bin.zip
+#        - mkdir -p gradle
+#        - unzip -q -d ./gradle gradle-4.3.1-bin.zip
+#        - export GRADLE=${TRAVIS_BUILD_DIR}/gradle/gradle-4.3.1/bin/gradle
+#      before_script:
+#        - bash $GRADLE --version
+#        - cd ./support
+#      script:
+#        - bash $GRADLE clean assemble
+#      after_success:
+#        - cd ${TRAVIS_BUILD_DIR}
+#        - tree ./libs
   allow_failures:
       # Errors
     - env: COMPILER=g++-4.4 BUILD=Debug STANDARD=11

ChangeLog.rst

@@ -1,3 +1,28 @@
+5.2.1 - 2018-09-21
+------------------
+
+* Fixed ``visit`` lookup issues on gcc 7 & 8
+  (`#870 <https://github.com/fmtlib/fmt/pull/870>`_).
+  Thanks `@medithe <https://github.com/medithe>`_.
+
+* Fixed linkage errors on older gcc.
+
+* Prevented ``fmt/range.h`` from specializing ``fmt::basic_string_view``
+  (`#865 <https://github.com/fmtlib/fmt/issues/865>`_,
+  `#868 <https://github.com/fmtlib/fmt/pull/868>`_).
+  Thanks `@hhggit (dual) <https://github.com/hhggit>`_.
+
+* Improved error message when formatting unknown types
+  (`#872 <https://github.com/fmtlib/fmt/pull/872>`_).
+  Thanks `@foonathan (Jonathan Müller) <https://github.com/foonathan>`_,
+
+* Disabled templated user-defined literals when compiled under nvcc
+  (`#875 <https://github.com/fmtlib/fmt/pull/875>`_).
+  Thanks `@CandyGumdrop (Candy Gumdrop) <https://github.com/CandyGumdrop>`_,
+
+* Fixed ``format_to`` formatting to ``wmemory_buffer``
+  (`#874 <https://github.com/fmtlib/fmt/issues/874>`_).
+
 5.2.0 - 2018-09-13
 ------------------
 

README.rst

@@ -108,24 +108,29 @@ Format strings can be checked at compile time:
     format_to(buf, "{:x}", 42);  // replaces itoa(42, buffer, 16)
     // access the string using to_string(buf) or buf.data()
 
-An object of any user-defined type for which there is an overloaded
-:code:`std::ostream` insertion operator (``operator<<``) can be formatted:
+Formatting of user-defined types is supported via a simple
+`extension API <http://fmtlib.net/latest/api.html#formatting-user-defined-types>`_:
 
 .. code:: c++
 
-    #include "fmt/ostream.h"
+    #include "fmt/format.h"
 
-    class Date {
-      int year_, month_, day_;
-     public:
-      Date(int year, int month, int day) : year_(year), month_(month), day_(day) {}
+    struct date {
+      int year, month, day;
+    };
 
-      friend std::ostream &operator<<(std::ostream &os, const Date &d) {
-        return os << d.year_ << '-' << d.month_ << '-' << d.day_;
+    template <>
+    struct fmt::formatter<date> {
+      template <typename ParseContext>
+      constexpr auto parse(ParseContext &ctx) { return ctx.begin(); }
+
+      template <typename FormatContext>
+      auto format(const date &d, FormatContext &ctx) {
+        return format_to(ctx.begin(), "{}-{}-{}", d.year, d.month, d.day);
       }
     };
 
-    std::string s = fmt::format("The date is {}", Date(2012, 12, 9));
+    std::string s = fmt::format("The date is {}", date{2012, 12, 9});
     // s == "The date is 2012-12-9"
 
 You can create your own functions similar to `format

doc/api.rst

@@ -132,7 +132,7 @@ customize the formatted output.
 
 You can also reuse existing formatters, for example::
 
-  enum color {red, green, blue};
+  enum class color {red, green, blue};
 
   template <>
   struct fmt::formatter<color>: formatter<string_view> {
@@ -141,9 +141,9 @@ You can also reuse existing formatters, for example::
     auto format(color c, FormatContext &ctx) {
       string_view name = "unknown";
       switch (c) {
-      case red:   name = "red"; break;
-      case green: name = "green"; break;
-      case blue:  name = "blue"; break;
+      case color::red:   name = "red"; break;
+      case color::green: name = "green"; break;
+      case color::blue:  name = "blue"; break;
       }
       return formatter<string_view>::format(name, ctx);
     }

doc/build.py

@@ -6,7 +6,7 @@ import errno, os, shutil, sys, tempfile
 from subprocess import check_call, check_output, CalledProcessError, Popen, PIPE
 from distutils.version import LooseVersion
 
-versions = ['1.0.0', '1.1.0', '2.0.0', '3.0.2', '4.0.0', '4.1.0', '5.0.0', '5.1.0', '5.2.0']
+versions = ['1.0.0', '1.1.0', '2.0.0', '3.0.2', '4.0.0', '4.1.0', '5.0.0', '5.1.0', '5.2.0', '5.2.1']
 
 def pip_install(package, commit=None, **kwargs):
   "Install package using pip."
@@ -91,7 +91,8 @@ def build_docs(version='dev', **kwargs):
                           FMT_USE_USER_DEFINED_LITERALS=1 \
                           FMT_API= \
                           "FMT_BEGIN_NAMESPACE=namespace fmt {{" \
-                          "FMT_END_NAMESPACE=}}"
+                          "FMT_END_NAMESPACE=}}" \
+                          "FMT_STRING_ALIAS=1"
       EXCLUDE_SYMBOLS   = fmt::internal::* StringValue write_str
     '''.format(include_dir, doxyxml_dir).encode('UTF-8'))
   if p.returncode != 0:

include/fmt/core.h

@@ -16,7 +16,7 @@
 #include <type_traits>
 
 // The fmt library version in the form major * 10000 + minor * 100 + patch.
-#define FMT_VERSION 50200
+#define FMT_VERSION 50201
 
 #ifdef __has_feature
 # define FMT_HAS_FEATURE(x) __has_feature(x)
@@ -340,9 +340,22 @@ class basic_format_arg;
 template <typename Context>
 class basic_format_args;
 
+template <typename T>
+struct no_formatter_error : std::false_type {};
+
 // A formatter for objects of type T.
 template <typename T, typename Char = char, typename Enable = void>
-struct formatter;
+struct formatter {
+  static_assert(no_formatter_error<T>::value,
+    "don't know how to format the type, include fmt/ostream.h if it provides "
+    "an operator<< that should be used");
+
+  // The following functions are not defined intentionally.
+  template <typename ParseContext>
+  typename ParseContext::iterator parse(ParseContext &);
+  template <typename FormatContext>
+  auto format(const T &val, FormatContext &ctx) -> decltype(ctx.out());
+};
 
 template <typename T, typename Char, typename Enable = void>
 struct convert_to_int {
@@ -755,6 +768,54 @@ class basic_format_arg {
   bool is_arithmetic() const { return internal::is_arithmetic(type_); }
 };
 
+struct monostate {};
+
+/**
+  \rst
+  Visits an argument dispatching to the appropriate visit method based on
+  the argument type. For example, if the argument type is ``double`` then
+  ``vis(value)`` will be called with the value of type ``double``.
+  \endrst
+ */
+template <typename Visitor, typename Context>
+FMT_CONSTEXPR typename internal::result_of<Visitor(int)>::type
+    visit(Visitor &&vis, const basic_format_arg<Context> &arg) {
+  typedef typename Context::char_type char_type;
+  switch (arg.type_) {
+  case internal::none_type:
+    break;
+  case internal::named_arg_type:
+    FMT_ASSERT(false, "invalid argument type");
+    break;
+  case internal::int_type:
+    return vis(arg.value_.int_value);
+  case internal::uint_type:
+    return vis(arg.value_.uint_value);
+  case internal::long_long_type:
+    return vis(arg.value_.long_long_value);
+  case internal::ulong_long_type:
+    return vis(arg.value_.ulong_long_value);
+  case internal::bool_type:
+    return vis(arg.value_.int_value != 0);
+  case internal::char_type:
+    return vis(static_cast<char_type>(arg.value_.int_value));
+  case internal::double_type:
+    return vis(arg.value_.double_value);
+  case internal::long_double_type:
+    return vis(arg.value_.long_double_value);
+  case internal::cstring_type:
+    return vis(arg.value_.string.value);
+  case internal::string_type:
+    return vis(basic_string_view<char_type>(
+                 arg.value_.string.value, arg.value_.string.size));
+  case internal::pointer_type:
+    return vis(arg.value_.pointer);
+  case internal::custom_type:
+    return vis(typename basic_format_arg<Context>::handle(arg.value_.custom));
+  }
+  return vis(monostate());
+}
+
 // Parsing context consisting of a format string range being parsed and an
 // argument counter for automatic indexing.
 template <typename Char, typename ErrorHandler = internal::error_handler>
@@ -1382,8 +1443,7 @@ inline std::basic_string<
   typedef typename buffer_context<char_t>::type context_t;
   format_arg_store<context_t, Args...> as{args...};
   return internal::vformat(
-        basic_string_view<char_t>(format_str),
-        basic_format_args<context_t>(as));
+      basic_string_view<char_t>(format_str), basic_format_args<context_t>(as));
 }
 
 FMT_API void vprint(std::FILE *f, string_view format_str, format_args args);

include/fmt/format.h

@@ -51,6 +51,12 @@
 # define FMT_ICC_VERSION 0
 #endif
 
+#ifdef __NVCC__
+# define FMT_CUDA_VERSION (__CUDACC_VER_MAJOR__ * 100 + __CUDACC_VER_MINOR__)
+#else
+# define FMT_CUDA_VERSION 0
+#endif
+
 #include "core.h"
 
 #if FMT_GCC_VERSION >= 406 || FMT_CLANG_VERSION
@@ -114,17 +120,23 @@ FMT_END_NAMESPACE
 #endif
 
 #ifndef FMT_USE_USER_DEFINED_LITERALS
-// For Intel's compiler both it and the system gcc/msc must support UDLs.
+// For Intel's compiler and NVIDIA's compiler both it and the system gcc/msc
+// must support UDLs.
 # if (FMT_HAS_FEATURE(cxx_user_literals) || \
       FMT_GCC_VERSION >= 407 || FMT_MSC_VER >= 1900) && \
-      (!FMT_ICC_VERSION || FMT_ICC_VERSION >= 1500)
+      (!(FMT_ICC_VERSION || FMT_CUDA_VERSION) || \
+       FMT_ICC_VERSION >= 1500 || FMT_CUDA_VERSION >= 700)
 #  define FMT_USE_USER_DEFINED_LITERALS 1
 # else
 #  define FMT_USE_USER_DEFINED_LITERALS 0
 # endif
 #endif
 
-#if FMT_USE_USER_DEFINED_LITERALS && FMT_ICC_VERSION == 0 && \
+// EDG C++ Front End based compilers (icc, nvcc) do not currently support UDL
+// templates.
+#if FMT_USE_USER_DEFINED_LITERALS && \
+    FMT_ICC_VERSION == 0 && \
+    FMT_CUDA_VERSION == 0 && \
     ((FMT_GCC_VERSION >= 600 && __cplusplus >= 201402L) || \
     (defined(FMT_CLANG_VERSION) && FMT_CLANG_VERSION >= 304))
 # define FMT_UDL_TEMPLATE 1
@@ -1154,54 +1166,6 @@ template <typename T = void>
 struct null {};
 }  // namespace internal
 
-struct monostate {};
-
-/**
-  \rst
-  Visits an argument dispatching to the appropriate visit method based on
-  the argument type. For example, if the argument type is ``double`` then
-  ``vis(value)`` will be called with the value of type ``double``.
-  \endrst
- */
-template <typename Visitor, typename Context>
-FMT_CONSTEXPR typename internal::result_of<Visitor(int)>::type
-    visit(Visitor &&vis, const basic_format_arg<Context> &arg) {
-  typedef typename Context::char_type char_type;
-  switch (arg.type_) {
-  case internal::none_type:
-    break;
-  case internal::named_arg_type:
-    FMT_ASSERT(false, "invalid argument type");
-    break;
-  case internal::int_type:
-    return vis(arg.value_.int_value);
-  case internal::uint_type:
-    return vis(arg.value_.uint_value);
-  case internal::long_long_type:
-    return vis(arg.value_.long_long_value);
-  case internal::ulong_long_type:
-    return vis(arg.value_.ulong_long_value);
-  case internal::bool_type:
-    return vis(arg.value_.int_value != 0);
-  case internal::char_type:
-    return vis(static_cast<char_type>(arg.value_.int_value));
-  case internal::double_type:
-    return vis(arg.value_.double_value);
-  case internal::long_double_type:
-    return vis(arg.value_.long_double_value);
-  case internal::cstring_type:
-    return vis(arg.value_.string.value);
-  case internal::string_type:
-    return vis(basic_string_view<char_type>(
-                 arg.value_.string.value, arg.value_.string.size));
-  case internal::pointer_type:
-    return vis(arg.value_.pointer);
-  case internal::custom_type:
-    return vis(typename basic_format_arg<Context>::handle(arg.value_.custom));
-  }
-  return vis(monostate());
-}
-
 enum alignment {
   ALIGN_DEFAULT, ALIGN_LEFT, ALIGN_RIGHT, ALIGN_CENTER, ALIGN_NUMERIC
 };
@@ -3231,8 +3195,8 @@ struct formatter<
       specs_.precision_, specs_.precision_ref, ctx);
     typedef output_range<typename FormatContext::iterator,
                          typename FormatContext::char_type> range_type;
-    return visit(arg_formatter<range_type>(ctx, &specs_),
-                 internal::make_arg<FormatContext>(val));
+    return fmt::visit(arg_formatter<range_type>(ctx, &specs_),
+                      internal::make_arg<FormatContext>(val));
   }
 
  private:
@@ -3292,8 +3256,8 @@ class dynamic_formatter {
       checker.end_precision();
     typedef output_range<typename FormatContext::iterator,
                          typename FormatContext::char_type> range;
-    visit(arg_formatter<range>(ctx, &specs_),
-          internal::make_arg<FormatContext>(val));
+    fmt::visit(arg_formatter<range>(ctx, &specs_),
+               internal::make_arg<FormatContext>(val));
     return ctx.out();
   }
 
@@ -3493,16 +3457,17 @@ inline wformat_context::iterator vformat_to(
   return vformat_to<arg_formatter<range>>(buf, format_str, args);
 }
 
-template <typename String, typename... Args,
-          std::size_t SIZE = inline_buffer_size>
-inline format_context::iterator format_to(
-    basic_memory_buffer<char, SIZE> &buf, const String &format_str,
+template <
+    typename String, typename... Args,
+    std::size_t SIZE = inline_buffer_size,
+    typename Char = typename internal::format_string_traits<String>::char_type>
+inline typename buffer_context<Char>::type::iterator format_to(
+    basic_memory_buffer<Char, SIZE> &buf, const String &format_str,
     const Args & ... args) {
   internal::check_format_string<Args...>(format_str);
-  typedef typename internal::format_string_traits<String>::char_type char_t;
   return vformat_to(
-        buf, basic_string_view<char_t>(format_str),
-        make_format_args<typename buffer_context<char_t>::type>(args...));
+        buf, basic_string_view<Char>(format_str),
+        make_format_args<typename buffer_context<Char>::type>(args...));
 }
 
 template <typename OutputIt, typename Char = char>
@@ -3725,10 +3690,13 @@ FMT_END_NAMESPACE
 #if defined(FMT_STRING_ALIAS) && FMT_STRING_ALIAS
 /**
   \rst
-  Constructs a compile-time format string.
+  Constructs a compile-time format string. This macro is disabled by default to
+  prevent potential name collisions. To enable it define ``FMT_STRING_ALIAS`` to
+  1 before including ``fmt/format.h``.
 
   **Example**::
 
+    #define FMT_STRING_ALIAS 1
     #include <fmt/format.h>
     // A compile-time error because 'd' is an invalid specifier for strings.
     std::string s = format(fmt("{:d}"), "foo");

include/fmt/printf.h

@@ -133,7 +133,7 @@ class arg_converter: public function<void> {
 // unsigned).
 template <typename T, typename Context, typename Char>
 void convert_arg(basic_format_arg<Context> &arg, Char type) {
-  visit(arg_converter<T, Context>(arg, type), arg);
+  fmt::visit(arg_converter<T, Context>(arg, type), arg);
 }
 
 // Converts an integer argument to char for printf.
@@ -454,7 +454,7 @@ unsigned basic_printf_context<OutputIt, Char, AF>::parse_header(
   } else if (*it == '*') {
     ++it;
     spec.width_ =
-        visit(internal::printf_width_handler<char_type>(spec), get_arg(it));
+        fmt::visit(internal::printf_width_handler<char_type>(spec), get_arg(it));
   }
   return arg_index;
 }
@@ -490,14 +490,14 @@ void basic_printf_context<OutputIt, Char, AF>::format() {
       } else if (*it == '*') {
         ++it;
         spec.precision_ =
-            visit(internal::printf_precision_handler(), get_arg(it));
+            fmt::visit(internal::printf_precision_handler(), get_arg(it));
       } else {
         spec.precision_ = 0;
       }
     }
 
     format_arg arg = get_arg(it, arg_index);
-    if (spec.flag(HASH_FLAG) && visit(internal::is_zero_int(), arg))
+    if (spec.flag(HASH_FLAG) && fmt::visit(internal::is_zero_int(), arg))
       spec.flags_ &= ~internal::to_unsigned<int>(HASH_FLAG);
     if (spec.fill_ == '0') {
       if (arg.is_arithmetic())
@@ -551,7 +551,7 @@ void basic_printf_context<OutputIt, Char, AF>::format() {
         break;
       case 'c':
         // TODO: handle wchar_t better?
-        visit(internal::char_converter<basic_printf_context>(arg), arg);
+        fmt::visit(internal::char_converter<basic_printf_context>(arg), arg);
         break;
       }
     }
@@ -559,7 +559,7 @@ void basic_printf_context<OutputIt, Char, AF>::format() {
     start = it;
 
     // Format argument.
-    visit(AF(buffer, spec, *this), arg);
+    fmt::visit(AF(buffer, spec, *this), arg);
   }
   buffer.append(pointer_from(start), pointer_from(it));
 }

include/fmt/ranges.h

@@ -87,6 +87,9 @@ class is_like_std_string {
     !std::is_void<decltype(check<T>(FMT_NULL))>::value;
 };
 
+template <typename Char>
+struct is_like_std_string<fmt::basic_string_view<Char>> : std::true_type {};
+
 template <typename... Ts>
 struct conditional_helper {};
 

src/format.cc

@@ -14,33 +14,40 @@ template struct internal::basic_data<void>;
 
 template FMT_API char internal::thousands_sep(locale_provider *lp);
 
+template void internal::basic_buffer<char>::append(const char *, const char *);
+
 template void basic_fixed_buffer<char>::grow(std::size_t);
 
 template void internal::arg_map<format_context>::init(
     const basic_format_args<format_context> &args);
 
 template FMT_API int internal::char_traits<char>::format_float(
-    char *buffer, std::size_t size, const char *format, int precision,
-    double value);
+    char *, std::size_t, const char *, int, double);
 
 template FMT_API int internal::char_traits<char>::format_float(
-    char *buffer, std::size_t size, const char *format, int precision,
-    long double value);
+    char *, std::size_t, const char *, int, long double);
+
+template FMT_API std::string internal::vformat<char>(
+    string_view, basic_format_args<format_context>);
 
 // Explicit instantiations for wchar_t.
 
-template FMT_API wchar_t internal::thousands_sep(locale_provider *lp);
+template FMT_API wchar_t internal::thousands_sep(locale_provider *);
+
+template void internal::basic_buffer<wchar_t>::append(
+    const wchar_t *, const wchar_t *);
 
 template void basic_fixed_buffer<wchar_t>::grow(std::size_t);
 
 template void internal::arg_map<wformat_context>::init(
-    const basic_format_args<wformat_context> &args);
+    const basic_format_args<wformat_context> &);
 
 template FMT_API int internal::char_traits<wchar_t>::format_float(
-    wchar_t *buffer, std::size_t size, const wchar_t *format,
-    int precision, double value);
+    wchar_t *, std::size_t, const wchar_t *, int, double);
 
 template FMT_API int internal::char_traits<wchar_t>::format_float(
-    wchar_t *buffer, std::size_t size, const wchar_t *format,
-    int precision, long double value);
+    wchar_t *, std::size_t, const wchar_t *, int, long double);
+
+template FMT_API std::wstring internal::vformat<wchar_t>(
+    wstring_view, basic_format_args<wformat_context>);
 FMT_END_NAMESPACE

support/rst2md.py

@@ -109,6 +109,30 @@ class Translator(nodes.NodeVisitor):
     def depart_image(self, node):
         pass
 
+    def write_row(self, row, widths):
+        for i, entry in enumerate(row):
+            text = entry[0][0] if len(entry) > 0 else ''
+            if i != 0:
+                self.write('|')
+            self.write('{:{}}'.format(text, widths[i]))
+        self.write('\n')
+
+    def visit_table(self, node):
+        table = node.children[0]
+        colspecs = table[:-2]
+        thead = table[-2]
+        tbody = table[-1]
+        widths = [int(cs['colwidth']) for cs in colspecs]
+        sep = '|'.join(['-' * w for w in widths]) + '\n'
+        self.write('\n\n')
+        self.write_row(thead[0], widths)
+        self.write(sep)
+        for row in tbody:
+            self.write_row(row, widths)
+        raise nodes.SkipChildren
+
+    def depart_table(self, node):
+        pass
 
 class MDWriter(writers.Writer):
     """GitHub-flavored markdown writer"""

test/CMakeLists.txt

@@ -85,9 +85,9 @@ function(add_fmt_test name)
 endfunction()
 
 add_fmt_test(assert-test)
-add_fmt_test(core-test mock-allocator.h)
+add_fmt_test(core-test)
 add_fmt_test(gtest-extra-test)
-add_fmt_test(format-test)
+add_fmt_test(format-test mock-allocator.h)
 add_fmt_test(format-impl-test)
 add_fmt_test(ostream-test)
 add_fmt_test(printf-test)

test/core-test.cc

@@ -1,28 +1,24 @@
-// Formatting library for C++ - utility tests
+// Formatting library for C++ - core tests
 //
 // Copyright (c) 2012 - present, Victor Zverovich
 // All rights reserved.
 //
 // For the license information refer to format.h.
 
-#include "test-assert.h"
-
-#include <cfloat>
+#include <algorithm>
 #include <climits>
 #include <cstring>
 #include <functional>
+#include <iterator>
 #include <limits>
+#include <string>
+#include <type_traits>
 
-#if FMT_USE_TYPE_TRAITS
-# include <type_traits>
-#endif
+#include "test-assert.h"
 
 #include "gmock.h"
-#include "gtest-extra.h"
-#include "mock-allocator.h"
-#include "util.h"
 
-// Check if format.h compiles with windows.h included.
+// Check if fmt/core.h compiles with windows.h included before it.
 #ifdef _WIN32
 # include <windows.h>
 #endif
@@ -34,17 +30,15 @@
 
 using fmt::basic_format_arg;
 using fmt::internal::basic_buffer;
-using fmt::basic_memory_buffer;
-using fmt::string_view;
 using fmt::internal::value;
+using fmt::string_view;
 
 using testing::_;
-using testing::Return;
 using testing::StrictMock;
 
 namespace {
 
-struct Test {};
+struct test_struct {};
 
 template <typename Context, typename T>
 basic_format_arg<Context> make_arg(const T &value) {
@@ -54,7 +48,7 @@ basic_format_arg<Context> make_arg(const T &value) {
 
 FMT_BEGIN_NAMESPACE
 template <typename Char>
-struct formatter<Test, Char> {
+struct formatter<test_struct, Char> {
   template <typename ParseContext>
   auto parse(ParseContext &ctx) -> decltype(ctx.begin()) {
     return ctx.begin();
@@ -62,7 +56,7 @@ struct formatter<Test, Char> {
 
   typedef std::back_insert_iterator<basic_buffer<Char>> iterator;
 
-  auto format(Test, basic_format_context<iterator, char> &ctx)
+  auto format(test_struct, basic_format_context<iterator, char> &ctx)
       -> decltype(ctx.out()) {
     const Char *test = "test";
     return std::copy_n(test, std::strlen(test), ctx.out());
@@ -70,52 +64,30 @@ struct formatter<Test, Char> {
 };
 FMT_END_NAMESPACE
 
-static void CheckForwarding(
-    MockAllocator<int> &alloc, AllocatorRef<MockAllocator<int>> &ref) {
-  int mem;
-  // Check if value_type is properly defined.
-  AllocatorRef< MockAllocator<int> >::value_type *ptr = &mem;
-  // Check forwarding.
-  EXPECT_CALL(alloc, allocate(42)).WillOnce(Return(ptr));
-  ref.allocate(42);
-  EXPECT_CALL(alloc, deallocate(ptr, 42));
-  ref.deallocate(ptr, 42);
-}
-
-TEST(AllocatorTest, AllocatorRef) {
-  StrictMock< MockAllocator<int> > alloc;
-  typedef AllocatorRef< MockAllocator<int> > TestAllocatorRef;
-  TestAllocatorRef ref(&alloc);
-  // Check if AllocatorRef forwards to the underlying allocator.
-  CheckForwarding(alloc, ref);
-  TestAllocatorRef ref2(ref);
-  CheckForwarding(alloc, ref2);
-  TestAllocatorRef ref3;
-  EXPECT_EQ(nullptr, ref3.get());
-  ref3 = ref;
-  CheckForwarding(alloc, ref3);
-}
-
-#if FMT_USE_TYPE_TRAITS
 TEST(BufferTest, Noncopyable) {
   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
 }
 
 TEST(BufferTest, Nonmoveable) {
   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
+}
 
 // A test buffer with a dummy grow method.
 template <typename T>
-struct TestBuffer : basic_buffer<T> {
+struct test_buffer : basic_buffer<T> {
   void grow(std::size_t capacity) { this->set(nullptr, capacity); }
 };
 
 template <typename T>
-struct MockBuffer : basic_buffer<T> {
+struct mock_buffer : basic_buffer<T> {
   MOCK_METHOD1(do_grow, void (std::size_t capacity));
 
   void grow(std::size_t capacity) {
@@ -123,21 +95,21 @@ struct MockBuffer : basic_buffer<T> {
     do_grow(capacity);
   }
 
-  MockBuffer() {}
-  MockBuffer(T *data) { this->set(data, 0); }
-  MockBuffer(T *data, std::size_t capacity) { this->set(data, capacity); }
+  mock_buffer() {}
+  mock_buffer(T *data) { this->set(data, 0); }
+  mock_buffer(T *data, std::size_t capacity) { this->set(data, capacity); }
 };
 
 TEST(BufferTest, Ctor) {
   {
-    MockBuffer<int> buffer;
+    mock_buffer<int> buffer;
     EXPECT_EQ(nullptr, &buffer[0]);
     EXPECT_EQ(static_cast<size_t>(0), buffer.size());
     EXPECT_EQ(static_cast<size_t>(0), buffer.capacity());
   }
   {
     int dummy;
-    MockBuffer<int> buffer(&dummy);
+    mock_buffer<int> buffer(&dummy);
     EXPECT_EQ(&dummy, &buffer[0]);
     EXPECT_EQ(static_cast<size_t>(0), buffer.size());
     EXPECT_EQ(static_cast<size_t>(0), buffer.capacity());
@@ -145,21 +117,21 @@ TEST(BufferTest, Ctor) {
   {
     int dummy;
     std::size_t capacity = std::numeric_limits<std::size_t>::max();
-    MockBuffer<int> buffer(&dummy, capacity);
+    mock_buffer<int> buffer(&dummy, capacity);
     EXPECT_EQ(&dummy, &buffer[0]);
     EXPECT_EQ(static_cast<size_t>(0), buffer.size());
     EXPECT_EQ(capacity, buffer.capacity());
   }
 }
 
-struct DyingBuffer : TestBuffer<int> {
+struct dying_buffer : test_buffer<int> {
   MOCK_METHOD0(die, void());
-  ~DyingBuffer() { die(); }
+  ~dying_buffer() { die(); }
 };
 
 TEST(BufferTest, VirtualDtor) {
-  typedef StrictMock<DyingBuffer> StictMockBuffer;
-  StictMockBuffer *mock_buffer = new StictMockBuffer();
+  typedef StrictMock<dying_buffer> stict_mock_buffer;
+  stict_mock_buffer *mock_buffer = new stict_mock_buffer();
   EXPECT_CALL(*mock_buffer, die());
   basic_buffer<int> *buffer = mock_buffer;
   delete buffer;
@@ -167,7 +139,7 @@ TEST(BufferTest, VirtualDtor) {
 
 TEST(BufferTest, Access) {
   char data[10];
-  MockBuffer<char> buffer(data, sizeof(data));
+  mock_buffer<char> buffer(data, sizeof(data));
   buffer[0] = 11;
   EXPECT_EQ(11, buffer[0]);
   buffer[3] = 42;
@@ -178,7 +150,7 @@ TEST(BufferTest, Access) {
 
 TEST(BufferTest, Resize) {
   char data[123];
-  MockBuffer<char> buffer(data, sizeof(data));
+  mock_buffer<char> buffer(data, sizeof(data));
   buffer[10] = 42;
   EXPECT_EQ(42, buffer[10]);
   buffer.resize(20);
@@ -197,7 +169,7 @@ TEST(BufferTest, Resize) {
 }
 
 TEST(BufferTest, Clear) {
-  TestBuffer<char> buffer;
+  test_buffer<char> buffer;
   buffer.resize(20);
   buffer.resize(0);
   EXPECT_EQ(static_cast<size_t>(0), buffer.size());
@@ -206,7 +178,7 @@ TEST(BufferTest, Clear) {
 
 TEST(BufferTest, Append) {
   char data[15];
-  MockBuffer<char> buffer(data, 10);
+  mock_buffer<char> buffer(data, 10);
   const char *test = "test";
   buffer.append(test, test + 5);
   EXPECT_STREQ(test, &buffer[0]);
@@ -221,202 +193,14 @@ TEST(BufferTest, Append) {
 
 TEST(BufferTest, AppendAllocatesEnoughStorage) {
   char data[19];
-  MockBuffer<char> buffer(data, 10);
+  mock_buffer<char> buffer(data, 10);
   const char *test = "abcdefgh";
   buffer.resize(10);
   EXPECT_CALL(buffer, do_grow(19));
   buffer.append(test, test + 9);
 }
 
-TEST(MemoryBufferTest, Ctor) {
-  basic_memory_buffer<char, 123> buffer;
-  EXPECT_EQ(static_cast<size_t>(0), buffer.size());
-  EXPECT_EQ(123u, buffer.capacity());
-}
-
-typedef AllocatorRef< std::allocator<char> > TestAllocator;
-
-static void check_move_buffer(const char *str,
-                       basic_memory_buffer<char, 5, TestAllocator> &buffer) {
-  std::allocator<char> *alloc = buffer.get_allocator().get();
-  basic_memory_buffer<char, 5, TestAllocator> buffer2(std::move(buffer));
-  // Move shouldn't destroy the inline content of the first buffer.
-  EXPECT_EQ(str, std::string(&buffer[0], buffer.size()));
-  EXPECT_EQ(str, std::string(&buffer2[0], buffer2.size()));
-  EXPECT_EQ(5u, buffer2.capacity());
-  // Move should transfer allocator.
-  EXPECT_EQ(nullptr, buffer.get_allocator().get());
-  EXPECT_EQ(alloc, buffer2.get_allocator().get());
-}
-
-TEST(MemoryBufferTest, MoveCtor) {
-  std::allocator<char> alloc;
-  basic_memory_buffer<char, 5, TestAllocator> buffer((TestAllocator(&alloc)));
-  const char test[] = "test";
-  buffer.append(test, test + 4);
-  check_move_buffer("test", buffer);
-  // Adding one more character fills the inline buffer, but doesn't cause
-  // dynamic allocation.
-  buffer.push_back('a');
-  check_move_buffer("testa", buffer);
-  const char *inline_buffer_ptr = &buffer[0];
-  // Adding one more character causes the content to move from the inline to
-  // a dynamically allocated buffer.
-  buffer.push_back('b');
-  basic_memory_buffer<char, 5, TestAllocator> buffer2(std::move(buffer));
-  // Move should rip the guts of the first buffer.
-  EXPECT_EQ(inline_buffer_ptr, &buffer[0]);
-  EXPECT_EQ("testab", std::string(&buffer2[0], buffer2.size()));
-  EXPECT_GT(buffer2.capacity(), 5u);
-}
-
-static void check_move_assign_buffer(
-    const char *str, basic_memory_buffer<char, 5> &buffer) {
-  basic_memory_buffer<char, 5> buffer2;
-  buffer2 = std::move(buffer);
-  // Move shouldn't destroy the inline content of the first buffer.
-  EXPECT_EQ(str, std::string(&buffer[0], buffer.size()));
-  EXPECT_EQ(str, std::string(&buffer2[0], buffer2.size()));
-  EXPECT_EQ(5u, buffer2.capacity());
-}
-
-TEST(MemoryBufferTest, MoveAssignment) {
-  basic_memory_buffer<char, 5> buffer;
-  const char test[] = "test";
-  buffer.append(test, test + 4);
-  check_move_assign_buffer("test", buffer);
-  // Adding one more character fills the inline buffer, but doesn't cause
-  // dynamic allocation.
-  buffer.push_back('a');
-  check_move_assign_buffer("testa", buffer);
-  const char *inline_buffer_ptr = &buffer[0];
-  // Adding one more character causes the content to move from the inline to
-  // a dynamically allocated buffer.
-  buffer.push_back('b');
-  basic_memory_buffer<char, 5> buffer2;
-  buffer2 = std::move(buffer);
-  // Move should rip the guts of the first buffer.
-  EXPECT_EQ(inline_buffer_ptr, &buffer[0]);
-  EXPECT_EQ("testab", std::string(&buffer2[0], buffer2.size()));
-  EXPECT_GT(buffer2.capacity(), 5u);
-}
-
-TEST(MemoryBufferTest, Grow) {
-  typedef AllocatorRef< MockAllocator<int> > Allocator;
-  typedef basic_memory_buffer<int, 10, Allocator> Base;
-  MockAllocator<int> alloc;
-  struct TestMemoryBuffer : Base {
-    TestMemoryBuffer(Allocator alloc) : Base(alloc) {}
-    void grow(std::size_t size) { Base::grow(size); }
-  } buffer((Allocator(&alloc)));
-  buffer.resize(7);
-  using fmt::internal::to_unsigned;
-  for (int i = 0; i < 7; ++i)
-    buffer[to_unsigned(i)] = i * i;
-  EXPECT_EQ(10u, buffer.capacity());
-  int mem[20];
-  mem[7] = 0xdead;
-  EXPECT_CALL(alloc, allocate(20)).WillOnce(Return(mem));
-  buffer.grow(20);
-  EXPECT_EQ(20u, buffer.capacity());
-  // Check if size elements have been copied
-  for (int i = 0; i < 7; ++i)
-    EXPECT_EQ(i * i, buffer[to_unsigned(i)]);
-  // and no more than that.
-  EXPECT_EQ(0xdead, buffer[7]);
-  EXPECT_CALL(alloc, deallocate(mem, 20));
-}
-
-TEST(MemoryBufferTest, Allocator) {
-  typedef AllocatorRef< MockAllocator<char> > TestAllocator;
-  basic_memory_buffer<char, 10, TestAllocator> buffer;
-  EXPECT_EQ(nullptr, buffer.get_allocator().get());
-  StrictMock< MockAllocator<char> > alloc;
-  char mem;
-  {
-    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;
-    EXPECT_CALL(alloc, allocate(size)).WillOnce(Return(&mem));
-    buffer2.reserve(size);
-    EXPECT_CALL(alloc, deallocate(&mem, size));
-  }
-}
-
-TEST(MemoryBufferTest, ExceptionInDeallocate) {
-  typedef AllocatorRef< MockAllocator<char> > TestAllocator;
-  StrictMock< MockAllocator<char> > alloc;
-  basic_memory_buffer<char, 10, TestAllocator> buffer((TestAllocator(&alloc)));
-  std::size_t size = 2 * fmt::inline_buffer_size;
-  std::vector<char> mem(size);
-  {
-    EXPECT_CALL(alloc, allocate(size)).WillOnce(Return(&mem[0]));
-    buffer.resize(size);
-    std::fill(&buffer[0], &buffer[0] + size, 'x');
-  }
-  std::vector<char> mem2(2 * size);
-  {
-    EXPECT_CALL(alloc, allocate(2 * size)).WillOnce(Return(&mem2[0]));
-    std::exception e;
-    EXPECT_CALL(alloc, deallocate(&mem[0], size)).WillOnce(testing::Throw(e));
-    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]);
-  }
-  EXPECT_CALL(alloc, deallocate(&mem2[0], 2 * size));
-}
-
-TEST(FixedBufferTest, Ctor) {
-  char array[10] = "garbage";
-  fmt::basic_fixed_buffer<char> buffer(array, sizeof(array));
-  EXPECT_EQ(static_cast<size_t>(0), buffer.size());
-  EXPECT_EQ(10u, buffer.capacity());
-  EXPECT_EQ(array, buffer.data());
-}
-
-TEST(FixedBufferTest, CompileTimeSizeCtor) {
-  char array[10] = "garbage";
-  fmt::basic_fixed_buffer<char> buffer(array);
-  EXPECT_EQ(static_cast<size_t>(0), buffer.size());
-  EXPECT_EQ(10u, buffer.capacity());
-  EXPECT_EQ(array, buffer.data());
-}
-
-TEST(FixedBufferTest, BufferOverflow) {
-  char array[10];
-  fmt::basic_fixed_buffer<char> buffer(array);
-  buffer.resize(10);
-  EXPECT_THROW_MSG(buffer.resize(11), std::runtime_error, "buffer overflow");
-}
-
-struct uint32_pair {
-  uint32_t u[2];
-};
-
-TEST(UtilTest, BitCast) {
-  auto s = fmt::internal::bit_cast<uint32_pair>(uint64_t{42});
-  EXPECT_EQ(fmt::internal::bit_cast<uint64_t>(s), 42ull);
-  s = fmt::internal::bit_cast<uint32_pair>(uint64_t(~0ull));
-  EXPECT_EQ(fmt::internal::bit_cast<uint64_t>(s), ~0ull);
-}
-
-TEST(UtilTest, Increment) {
-  char s[10] = "123";
-  increment(s);
-  EXPECT_STREQ("124", s);
-  s[2] = '8';
-  increment(s);
-  EXPECT_STREQ("129", s);
-  increment(s);
-  EXPECT_STREQ("130", s);
-  s[1] = s[2] = '9';
-  increment(s);
-  EXPECT_STREQ("200", s);
-}
-
-TEST(UtilTest, FormatArgs) {
+TEST(ArgTest, FormatArgs) {
   fmt::format_args args;
   EXPECT_FALSE(args.get(1));
 }
@@ -445,8 +229,8 @@ struct custom_context {
   void advance_to(const char *) {}
 };
 
-TEST(UtilTest, MakeValueWithCustomFormatter) {
-  ::Test t;
+TEST(ArgTest, MakeValueWithCustomContext) {
+  test_struct t;
   fmt::internal::value<custom_context> arg =
       fmt::internal::make_value<custom_context>(t);
   custom_context ctx = {false};
@@ -456,7 +240,6 @@ TEST(UtilTest, MakeValueWithCustomFormatter) {
 
 FMT_BEGIN_NAMESPACE
 namespace internal {
-
 template <typename Char>
 bool operator==(custom_value<Char> lhs, custom_value<Char> rhs) {
   return lhs.value == rhs.value;
@@ -466,32 +249,35 @@ FMT_END_NAMESPACE
 
 // Use a unique result type to make sure that there are no undesirable
 // conversions.
-struct Result {};
+struct test_result {};
 
 template <typename T>
-struct MockVisitor: fmt::internal::function<Result> {
-  MockVisitor() {
-    ON_CALL(*this, visit(_)).WillByDefault(Return(Result()));
+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, Result (T value));
+  MOCK_METHOD1_T(visit, test_result (T value));
   MOCK_METHOD0_T(unexpected, void ());
 
-  Result operator()(T value) { return visit(value); }
+  test_result operator()(T value) { return visit(value); }
 
   template <typename U>
-  Result operator()(U) {
+  test_result operator()(U) {
     unexpected();
-    return Result();
+    return test_result();
   }
 };
 
 template <typename T>
-struct VisitType { typedef T Type; };
+struct visit_type { typedef T Type; };
 
-#define VISIT_TYPE(Type_, VisitType_) \
+#define VISIT_TYPE(Type_, visit_type_) \
   template <> \
-  struct VisitType<Type_> { typedef VisitType_ Type; }
+  struct visit_type<Type_> { typedef visit_type_ Type; }
 
 VISIT_TYPE(signed char, int);
 VISIT_TYPE(unsigned char, unsigned);
@@ -509,7 +295,7 @@ VISIT_TYPE(unsigned long, unsigned long long);
 VISIT_TYPE(float, double);
 
 #define CHECK_ARG_(Char, expected, value) { \
-  testing::StrictMock<MockVisitor<decltype(expected)>> visitor; \
+  testing::StrictMock<mock_visitor<decltype(expected)>> visitor; \
   EXPECT_CALL(visitor, visit(expected)); \
   typedef std::back_insert_iterator<basic_buffer<Char>> iterator; \
   fmt::visit(visitor, \
@@ -518,7 +304,7 @@ VISIT_TYPE(float, double);
 
 #define CHECK_ARG(value, typename_) { \
   typedef decltype(value) value_type; \
-  typename_ VisitType<value_type>::Type expected = value; \
+  typename_ visit_type<value_type>::Type expected = value; \
   CHECK_ARG_(char, expected, value) \
   CHECK_ARG_(wchar_t, expected, value) \
 }
@@ -549,13 +335,13 @@ TYPED_TEST(NumericArgTest, MakeAndVisit) {
   CHECK_ARG(std::numeric_limits<TypeParam>::max(), typename);
 }
 
-TEST(UtilTest, CharArg) {
+TEST(ArgTest, CharArg) {
   CHECK_ARG_(char, 'a', 'a');
   CHECK_ARG_(wchar_t, L'a', 'a');
   CHECK_ARG_(wchar_t, L'a', L'a');
 }
 
-TEST(UtilTest, StringArg) {
+TEST(ArgTest, StringArg) {
   char str_data[] = "test";
   char *str = str_data;
   const char *cstr = str;
@@ -565,7 +351,7 @@ TEST(UtilTest, StringArg) {
   CHECK_ARG_(char, sref, std::string(str));
 }
 
-TEST(UtilTest, WStringArg) {
+TEST(ArgTest, WStringArg) {
   wchar_t str_data[] = L"test";
   wchar_t *str = str_data;
   const wchar_t *cstr = str;
@@ -577,7 +363,7 @@ TEST(UtilTest, WStringArg) {
   CHECK_ARG_(wchar_t, sref, fmt::wstring_view(str));
 }
 
-TEST(UtilTest, PointerArg) {
+TEST(ArgTest, PointerArg) {
   void *p = nullptr;
   const void *cp = nullptr;
   CHECK_ARG_(char, cp, p);
@@ -586,56 +372,47 @@ TEST(UtilTest, PointerArg) {
 }
 
 struct check_custom {
-  Result operator()(fmt::basic_format_arg<fmt::format_context>::handle h) const {
-    fmt::memory_buffer buffer;
+  test_result operator()(
+      fmt::basic_format_arg<fmt::format_context>::handle h) const {
+    struct test_buffer : fmt::internal::basic_buffer<char> {
+      char data[10];
+      test_buffer() : basic_buffer(data, 0, 10) {}
+      void grow(std::size_t) {}
+    } 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()));
-    return Result();
+    EXPECT_EQ("test", std::string(buffer.data, buffer.size()));
+    return test_result();
   }
 };
 
-TEST(UtilTest, CustomArg) {
-  ::Test test;
-  typedef MockVisitor<fmt::basic_format_arg<fmt::format_context>::handle>
+TEST(ArgTest, CustomArg) {
+  test_struct test;
+  typedef mock_visitor<fmt::basic_format_arg<fmt::format_context>::handle>
     visitor;
   testing::StrictMock<visitor> v;
   EXPECT_CALL(v, visit(_)).WillOnce(testing::Invoke(check_custom()));
   fmt::visit(v, make_arg<fmt::format_context>(test));
 }
 
-TEST(ArgVisitorTest, VisitInvalidArg) {
-  typedef MockVisitor<fmt::monostate> Visitor;
-  testing::StrictMock<Visitor> visitor;
+TEST(ArgTest, VisitInvalidArg) {
+  testing::StrictMock< mock_visitor<fmt::monostate> > visitor;
   EXPECT_CALL(visitor, visit(_));
   fmt::basic_format_arg<fmt::format_context> arg;
   visit(visitor, arg);
 }
 
-// Tests fmt::internal::count_digits for integer type Int.
-template <typename Int>
-void test_count_digits() {
-  for (Int i = 0; i < 10; ++i)
-    EXPECT_EQ(1u, fmt::internal::count_digits(i));
-  for (Int i = 1, n = 1,
-      end = std::numeric_limits<Int>::max() / 10; n <= end; ++i) {
-    n *= 10;
-    EXPECT_EQ(i, fmt::internal::count_digits(n - 1));
-    EXPECT_EQ(i + 1, fmt::internal::count_digits(n));
-  }
-}
-
-TEST(UtilTest, StringRef) {
+TEST(StringViewTest, Length) {
   // Test that StringRef::size() returns string length, not buffer size.
   char str[100] = "some string";
   EXPECT_EQ(std::strlen(str), string_view(str).size());
   EXPECT_LT(std::strlen(str), sizeof(str));
 }
 
-// Check StringRef's comparison operator.
+// Check string_view's comparison operator.
 template <template <typename> class Op>
-void CheckOp() {
+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) {
@@ -646,249 +423,38 @@ void CheckOp() {
   }
 }
 
-TEST(UtilTest, StringRefCompare) {
-  EXPECT_EQ(0, string_view("foo").compare(string_view("foo")));
+TEST(StringViewTest, Compare) {
+  EXPECT_EQ(string_view("foo").compare(string_view("foo")), 0);
   EXPECT_GT(string_view("fop").compare(string_view("foo")), 0);
   EXPECT_LT(string_view("foo").compare(string_view("fop")), 0);
   EXPECT_GT(string_view("foo").compare(string_view("fo")), 0);
   EXPECT_LT(string_view("fo").compare(string_view("foo")), 0);
-  CheckOp<std::equal_to>();
-  CheckOp<std::not_equal_to>();
-  CheckOp<std::less>();
-  CheckOp<std::less_equal>();
-  CheckOp<std::greater>();
-  CheckOp<std::greater_equal>();
+  check_op<std::equal_to>();
+  check_op<std::not_equal_to>();
+  check_op<std::less>();
+  check_op<std::less_equal>();
+  check_op<std::greater>();
+  check_op<std::greater_equal>();
 }
 
-TEST(UtilTest, CountDigits) {
-  test_count_digits<uint32_t>();
-  test_count_digits<uint64_t>();
-}
+enum basic_enum {};
 
-#ifdef _WIN32
-TEST(UtilTest, UTF16ToUTF8) {
-  std::string s = "ёжик";
-  fmt::internal::utf16_to_utf8 u(L"\x0451\x0436\x0438\x043A");
-  EXPECT_EQ(s, u.str());
-  EXPECT_EQ(s.size(), u.size());
-}
-
-TEST(UtilTest, UTF16ToUTF8EmptyString) {
-  std::string s = "";
-  fmt::internal::utf16_to_utf8 u(L"");
-  EXPECT_EQ(s, u.str());
-  EXPECT_EQ(s.size(), u.size());
-}
-
-TEST(UtilTest, UTF8ToUTF16) {
-  std::string s = "лошадка";
-  fmt::internal::utf8_to_utf16 u(s.c_str());
-  EXPECT_EQ(L"\x043B\x043E\x0448\x0430\x0434\x043A\x0430", u.str());
-  EXPECT_EQ(7, u.size());
-}
-
-TEST(UtilTest, UTF8ToUTF16EmptyString) {
-  std::string s = "";
-  fmt::internal::utf8_to_utf16 u(s.c_str());
-  EXPECT_EQ(L"", u.str());
-  EXPECT_EQ(s.size(), u.size());
-}
-
-template <typename Converter, typename Char>
-void check_utf_conversion_error(
-        const char *message,
-        fmt::basic_string_view<Char> str = fmt::basic_string_view<Char>(0, 1)) {
-  fmt::memory_buffer out;
-  fmt::internal::format_windows_error(out, ERROR_INVALID_PARAMETER, message);
-  fmt::system_error error(0, "");
-  try {
-    (Converter)(str);
-  } catch (const fmt::system_error &e) {
-    error = e;
-  }
-  EXPECT_EQ(ERROR_INVALID_PARAMETER, error.error_code());
-  EXPECT_EQ(fmt::to_string(out), error.what());
-}
-
-TEST(UtilTest, UTF16ToUTF8Error) {
-  check_utf_conversion_error<fmt::internal::utf16_to_utf8, wchar_t>(
-      "cannot convert string from UTF-16 to UTF-8");
-}
-
-TEST(UtilTest, UTF8ToUTF16Error) {
-  const char *message = "cannot convert string from UTF-8 to UTF-16";
-  check_utf_conversion_error<fmt::internal::utf8_to_utf16, char>(message);
-  check_utf_conversion_error<fmt::internal::utf8_to_utf16, char>(
-    message, fmt::string_view("foo", INT_MAX + 1u));
-}
-
-TEST(UtilTest, UTF16ToUTF8Convert) {
-  fmt::internal::utf16_to_utf8 u;
-  EXPECT_EQ(ERROR_INVALID_PARAMETER, u.convert(fmt::wstring_view(0, 1)));
-  EXPECT_EQ(ERROR_INVALID_PARAMETER,
-            u.convert(fmt::wstring_view(L"foo", INT_MAX + 1u)));
-}
-#endif  // _WIN32
-
-typedef void (*FormatErrorMessage)(
-        fmt::internal::buffer &out, int error_code, string_view message);
-
-template <typename Error>
-void check_throw_error(int error_code, FormatErrorMessage format) {
-  fmt::system_error error(0, "");
-  try {
-    throw Error(error_code, "test {}", "error");
-  } catch (const fmt::system_error &e) {
-    error = e;
-  }
-  fmt::memory_buffer message;
-  format(message, error_code, "test error");
-  EXPECT_EQ(to_string(message), error.what());
-  EXPECT_EQ(error_code, error.error_code());
-}
-
-TEST(UtilTest, FormatSystemError) {
-  fmt::memory_buffer message;
-  fmt::format_system_error(message, EDOM, "test");
-  EXPECT_EQ(fmt::format("test: {}", get_system_error(EDOM)),
-            to_string(message));
-  message = fmt::memory_buffer();
-
-  // Check if std::allocator throws on allocating max size_t / 2 chars.
-  size_t max_size = std::numeric_limits<size_t>::max() / 2;
-  bool throws_on_alloc = false;
-  try {
-    std::allocator<char> alloc;
-    alloc.deallocate(alloc.allocate(max_size), max_size);
-  } catch (const std::bad_alloc&) {
-    throws_on_alloc = true;
-  }
-  if (!throws_on_alloc) {
-    fmt::print("warning: std::allocator allocates {} chars", max_size);
-    return;
-  }
-  fmt::format_system_error(message, EDOM, fmt::string_view(nullptr, max_size));
-  EXPECT_EQ(fmt::format("error {}", EDOM), to_string(message));
-}
-
-TEST(UtilTest, SystemError) {
-  fmt::system_error e(EDOM, "test");
-  EXPECT_EQ(fmt::format("test: {}", get_system_error(EDOM)), e.what());
-  EXPECT_EQ(EDOM, e.error_code());
-  check_throw_error<fmt::system_error>(EDOM, fmt::format_system_error);
-}
-
-TEST(UtilTest, ReportSystemError) {
-  fmt::memory_buffer out;
-  fmt::format_system_error(out, EDOM, "test error");
-  out.push_back('\n');
-  EXPECT_WRITE(stderr, fmt::report_system_error(EDOM, "test error"),
-               to_string(out));
-}
-
-#ifdef _WIN32
-
-TEST(UtilTest, FormatWindowsError) {
-  LPWSTR message = 0;
-  FormatMessageW(FORMAT_MESSAGE_ALLOCATE_BUFFER |
-      FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, 0,
-      ERROR_FILE_EXISTS, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
-      reinterpret_cast<LPWSTR>(&message), 0, 0);
-  fmt::internal::utf16_to_utf8 utf8_message(message);
-  LocalFree(message);
-  fmt::memory_buffer actual_message;
-  fmt::internal::format_windows_error(
-      actual_message, ERROR_FILE_EXISTS, "test");
-  EXPECT_EQ(fmt::format("test: {}", utf8_message.str()),
-      fmt::to_string(actual_message));
-  actual_message.resize(0);
-  fmt::internal::format_windows_error(
-        actual_message, ERROR_FILE_EXISTS,
-        fmt::string_view(0, std::numeric_limits<size_t>::max()));
-  EXPECT_EQ(fmt::format("error {}", ERROR_FILE_EXISTS),
-            fmt::to_string(actual_message));
-}
-
-TEST(UtilTest, FormatLongWindowsError) {
-  LPWSTR message = 0;
-  // this error code is not available on all Windows platforms and
-  // Windows SDKs, so do not fail the test if the error string cannot
-  // be retrieved.
-  const int provisioning_not_allowed = 0x80284013L /*TBS_E_PROVISIONING_NOT_ALLOWED*/;
-  if (FormatMessageW(FORMAT_MESSAGE_ALLOCATE_BUFFER |
-      FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, 0,
-      static_cast<DWORD>(provisioning_not_allowed),
-      MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
-      reinterpret_cast<LPWSTR>(&message), 0, 0) == 0) {
-    return;
-  }
-  fmt::internal::utf16_to_utf8 utf8_message(message);
-  LocalFree(message);
-  fmt::memory_buffer actual_message;
-  fmt::internal::format_windows_error(
-      actual_message, provisioning_not_allowed, "test");
-  EXPECT_EQ(fmt::format("test: {}", utf8_message.str()),
-      fmt::to_string(actual_message));
-}
-
-TEST(UtilTest, WindowsError) {
-  check_throw_error<fmt::windows_error>(
-      ERROR_FILE_EXISTS, fmt::internal::format_windows_error);
-}
-
-TEST(UtilTest, ReportWindowsError) {
-  fmt::memory_buffer out;
-  fmt::internal::format_windows_error(out, ERROR_FILE_EXISTS, "test error");
-  out.push_back('\n');
-  EXPECT_WRITE(stderr,
-      fmt::report_windows_error(ERROR_FILE_EXISTS, "test error"),
-               fmt::to_string(out));
-}
-
-#endif  // _WIN32
-
-enum TestEnum2 {};
-
-TEST(UtilTest, ConvertToInt) {
+TEST(CoreTest, ConvertToInt) {
   EXPECT_FALSE((fmt::convert_to_int<char, char>::value));
   EXPECT_FALSE((fmt::convert_to_int<const char *, char>::value));
-  EXPECT_TRUE((fmt::convert_to_int<TestEnum2, char>::value));
+  EXPECT_TRUE((fmt::convert_to_int<basic_enum, char>::value));
 }
 
-#if FMT_USE_ENUM_BASE
-enum TestEnum : char {TestValue};
-TEST(UtilTest, IsEnumConvertibleToInt) {
-  EXPECT_TRUE((fmt::convert_to_int<TestEnum, char>::value));
+enum enum_with_underlying_type : char {};
+
+TEST(CoreTest, IsEnumConvertibleToInt) {
+  EXPECT_TRUE((fmt::convert_to_int<enum_with_underlying_type, char>::value));
 }
+
+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
 #endif
-
-TEST(UtilTest, ParseNonnegativeInt) {
-  if (std::numeric_limits<int>::max() !=
-      static_cast<int>(static_cast<unsigned>(1) << 31)) {
-    fmt::print("Skipping parse_nonnegative_int test\n");
-    return;
-  }
-  const char *s = "10000000000";
-  EXPECT_THROW_MSG(
-        parse_nonnegative_int(s, fmt::internal::error_handler()),
-        fmt::format_error, "number is too big");
-  s = "2147483649";
-  EXPECT_THROW_MSG(
-        parse_nonnegative_int(s, fmt::internal::error_handler()),
-        fmt::format_error, "number is too big");
-}
-
-TEST(IteratorTest, CountingIterator) {
-  fmt::internal::counting_iterator<char> it;
-  auto prev = it++;
-  EXPECT_EQ(prev.count(), 0);
-  EXPECT_EQ(it.count(), 1);
-}
-
-TEST(IteratorTest, TruncatingIterator) {
-  char *p = FMT_NULL;
-  fmt::internal::truncating_iterator<char*> it(p, 3);
-  auto prev = it++;
-  EXPECT_EQ(prev.base(), p);
-  EXPECT_EQ(it.base(), p + 1);
+  EXPECT_EQ(fmt::format("{}", 42), "42");
 }

test/folly/Range.h

@@ -1,17 +0,0 @@
-// A folly::StringPiece stub.
-
-#include <cstring>
-
-namespace folly {
-class StringPiece {
- public:
-  explicit StringPiece(const char *s) : data_(s), size_(std::strlen(s)) {}
-
-  const char* data() const { return "foo"; }
-  size_t size() const { return 3; }
-
- private:
-  const char *data_;
-  size_t size_;
-};
-}

test/format-test.cc

@@ -14,17 +14,24 @@
 #include <memory>
 #include <stdint.h>
 
+// Check if fmt/format.h compiles with windows.h included before it.
+#ifdef _WIN32
+# include <windows.h>
+#endif
+
 #include "fmt/format.h"
 #include "gmock.h"
 #include "gtest-extra.h"
 #include "mock-allocator.h"
 #include "util.h"
 
+#undef ERROR
 #undef min
 #undef max
 
 using std::size_t;
 
+using fmt::basic_memory_buffer;
 using fmt::basic_writer;
 using fmt::format;
 using fmt::format_error;
@@ -32,6 +39,9 @@ using fmt::string_view;
 using fmt::memory_buffer;
 using fmt::wmemory_buffer;
 
+using testing::Return;
+using testing::StrictMock;
+
 namespace {
 
 // Format value using the standard library.
@@ -101,6 +111,451 @@ struct WriteChecker {
   EXPECT_PRED_FORMAT1(WriteChecker<wchar_t>(), value)
 }  // namespace
 
+// Tests fmt::internal::count_digits for integer type Int.
+template <typename Int>
+void test_count_digits() {
+  for (Int i = 0; i < 10; ++i)
+    EXPECT_EQ(1u, fmt::internal::count_digits(i));
+  for (Int i = 1, n = 1,
+      end = std::numeric_limits<Int>::max() / 10; n <= end; ++i) {
+    n *= 10;
+    EXPECT_EQ(i, fmt::internal::count_digits(n - 1));
+    EXPECT_EQ(i + 1, fmt::internal::count_digits(n));
+  }
+}
+
+TEST(UtilTest, CountDigits) {
+  test_count_digits<uint32_t>();
+  test_count_digits<uint64_t>();
+}
+
+struct uint32_pair {
+  uint32_t u[2];
+};
+
+TEST(UtilTest, BitCast) {
+  auto s = fmt::internal::bit_cast<uint32_pair>(uint64_t{42});
+  EXPECT_EQ(fmt::internal::bit_cast<uint64_t>(s), 42ull);
+  s = fmt::internal::bit_cast<uint32_pair>(uint64_t(~0ull));
+  EXPECT_EQ(fmt::internal::bit_cast<uint64_t>(s), ~0ull);
+}
+
+TEST(UtilTest, Increment) {
+  char s[10] = "123";
+  increment(s);
+  EXPECT_STREQ("124", s);
+  s[2] = '8';
+  increment(s);
+  EXPECT_STREQ("129", s);
+  increment(s);
+  EXPECT_STREQ("130", s);
+  s[1] = s[2] = '9';
+  increment(s);
+  EXPECT_STREQ("200", s);
+}
+
+TEST(UtilTest, ParseNonnegativeInt) {
+  if (std::numeric_limits<int>::max() !=
+      static_cast<int>(static_cast<unsigned>(1) << 31)) {
+    fmt::print("Skipping parse_nonnegative_int test\n");
+    return;
+  }
+  const char *s = "10000000000";
+  EXPECT_THROW_MSG(
+        parse_nonnegative_int(s, fmt::internal::error_handler()),
+        fmt::format_error, "number is too big");
+  s = "2147483649";
+  EXPECT_THROW_MSG(
+        parse_nonnegative_int(s, fmt::internal::error_handler()),
+        fmt::format_error, "number is too big");
+}
+
+TEST(IteratorTest, CountingIterator) {
+  fmt::internal::counting_iterator<char> it;
+  auto prev = it++;
+  EXPECT_EQ(prev.count(), 0);
+  EXPECT_EQ(it.count(), 1);
+}
+
+TEST(IteratorTest, TruncatingIterator) {
+  char *p = FMT_NULL;
+  fmt::internal::truncating_iterator<char*> it(p, 3);
+  auto prev = it++;
+  EXPECT_EQ(prev.base(), p);
+  EXPECT_EQ(it.base(), p + 1);
+}
+
+TEST(MemoryBufferTest, Ctor) {
+  basic_memory_buffer<char, 123> buffer;
+  EXPECT_EQ(static_cast<size_t>(0), buffer.size());
+  EXPECT_EQ(123u, buffer.capacity());
+}
+
+static void check_forwarding(
+    mock_allocator<int> &alloc, allocator_ref<mock_allocator<int>> &ref) {
+  int mem;
+  // Check if value_type is properly defined.
+  allocator_ref< mock_allocator<int> >::value_type *ptr = &mem;
+  // Check forwarding.
+  EXPECT_CALL(alloc, allocate(42)).WillOnce(testing::Return(ptr));
+  ref.allocate(42);
+  EXPECT_CALL(alloc, deallocate(ptr, 42));
+  ref.deallocate(ptr, 42);
+}
+
+TEST(AllocatorTest, allocator_ref) {
+  StrictMock< mock_allocator<int> > alloc;
+  typedef allocator_ref< mock_allocator<int> > test_allocator_ref;
+  test_allocator_ref ref(&alloc);
+  // Check if allocator_ref forwards to the underlying allocator.
+  check_forwarding(alloc, ref);
+  test_allocator_ref ref2(ref);
+  check_forwarding(alloc, ref2);
+  test_allocator_ref ref3;
+  EXPECT_EQ(nullptr, ref3.get());
+  ref3 = ref;
+  check_forwarding(alloc, ref3);
+}
+
+typedef allocator_ref< std::allocator<char> > TestAllocator;
+
+static void check_move_buffer(const char *str,
+                       basic_memory_buffer<char, 5, TestAllocator> &buffer) {
+  std::allocator<char> *alloc = buffer.get_allocator().get();
+  basic_memory_buffer<char, 5, TestAllocator> buffer2(std::move(buffer));
+  // Move shouldn't destroy the inline content of the first buffer.
+  EXPECT_EQ(str, std::string(&buffer[0], buffer.size()));
+  EXPECT_EQ(str, std::string(&buffer2[0], buffer2.size()));
+  EXPECT_EQ(5u, buffer2.capacity());
+  // Move should transfer allocator.
+  EXPECT_EQ(nullptr, buffer.get_allocator().get());
+  EXPECT_EQ(alloc, buffer2.get_allocator().get());
+}
+
+TEST(MemoryBufferTest, MoveCtor) {
+  std::allocator<char> alloc;
+  basic_memory_buffer<char, 5, TestAllocator> buffer((TestAllocator(&alloc)));
+  const char test[] = "test";
+  buffer.append(test, test + 4);
+  check_move_buffer("test", buffer);
+  // Adding one more character fills the inline buffer, but doesn't cause
+  // dynamic allocation.
+  buffer.push_back('a');
+  check_move_buffer("testa", buffer);
+  const char *inline_buffer_ptr = &buffer[0];
+  // Adding one more character causes the content to move from the inline to
+  // a dynamically allocated buffer.
+  buffer.push_back('b');
+  basic_memory_buffer<char, 5, TestAllocator> buffer2(std::move(buffer));
+  // Move should rip the guts of the first buffer.
+  EXPECT_EQ(inline_buffer_ptr, &buffer[0]);
+  EXPECT_EQ("testab", std::string(&buffer2[0], buffer2.size()));
+  EXPECT_GT(buffer2.capacity(), 5u);
+}
+
+static void check_move_assign_buffer(
+    const char *str, basic_memory_buffer<char, 5> &buffer) {
+  basic_memory_buffer<char, 5> buffer2;
+  buffer2 = std::move(buffer);
+  // Move shouldn't destroy the inline content of the first buffer.
+  EXPECT_EQ(str, std::string(&buffer[0], buffer.size()));
+  EXPECT_EQ(str, std::string(&buffer2[0], buffer2.size()));
+  EXPECT_EQ(5u, buffer2.capacity());
+}
+
+TEST(MemoryBufferTest, MoveAssignment) {
+  basic_memory_buffer<char, 5> buffer;
+  const char test[] = "test";
+  buffer.append(test, test + 4);
+  check_move_assign_buffer("test", buffer);
+  // Adding one more character fills the inline buffer, but doesn't cause
+  // dynamic allocation.
+  buffer.push_back('a');
+  check_move_assign_buffer("testa", buffer);
+  const char *inline_buffer_ptr = &buffer[0];
+  // Adding one more character causes the content to move from the inline to
+  // a dynamically allocated buffer.
+  buffer.push_back('b');
+  basic_memory_buffer<char, 5> buffer2;
+  buffer2 = std::move(buffer);
+  // Move should rip the guts of the first buffer.
+  EXPECT_EQ(inline_buffer_ptr, &buffer[0]);
+  EXPECT_EQ("testab", std::string(&buffer2[0], buffer2.size()));
+  EXPECT_GT(buffer2.capacity(), 5u);
+}
+
+TEST(MemoryBufferTest, Grow) {
+  typedef allocator_ref< mock_allocator<int> > Allocator;
+  typedef basic_memory_buffer<int, 10, Allocator> Base;
+  mock_allocator<int> alloc;
+  struct TestMemoryBuffer : Base {
+    TestMemoryBuffer(Allocator alloc) : Base(alloc) {}
+    void grow(std::size_t size) { Base::grow(size); }
+  } buffer((Allocator(&alloc)));
+  buffer.resize(7);
+  using fmt::internal::to_unsigned;
+  for (int i = 0; i < 7; ++i)
+    buffer[to_unsigned(i)] = i * i;
+  EXPECT_EQ(10u, buffer.capacity());
+  int mem[20];
+  mem[7] = 0xdead;
+  EXPECT_CALL(alloc, allocate(20)).WillOnce(Return(mem));
+  buffer.grow(20);
+  EXPECT_EQ(20u, buffer.capacity());
+  // Check if size elements have been copied
+  for (int i = 0; i < 7; ++i)
+    EXPECT_EQ(i * i, buffer[to_unsigned(i)]);
+  // and no more than that.
+  EXPECT_EQ(0xdead, buffer[7]);
+  EXPECT_CALL(alloc, deallocate(mem, 20));
+}
+
+TEST(MemoryBufferTest, Allocator) {
+  typedef allocator_ref< mock_allocator<char> > TestAllocator;
+  basic_memory_buffer<char, 10, TestAllocator> buffer;
+  EXPECT_EQ(nullptr, buffer.get_allocator().get());
+  StrictMock< mock_allocator<char> > alloc;
+  char mem;
+  {
+    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;
+    EXPECT_CALL(alloc, allocate(size)).WillOnce(Return(&mem));
+    buffer2.reserve(size);
+    EXPECT_CALL(alloc, deallocate(&mem, size));
+  }
+}
+
+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;
+  std::vector<char> mem(size);
+  {
+    EXPECT_CALL(alloc, allocate(size)).WillOnce(Return(&mem[0]));
+    buffer.resize(size);
+    std::fill(&buffer[0], &buffer[0] + size, 'x');
+  }
+  std::vector<char> mem2(2 * size);
+  {
+    EXPECT_CALL(alloc, allocate(2 * size)).WillOnce(Return(&mem2[0]));
+    std::exception e;
+    EXPECT_CALL(alloc, deallocate(&mem[0], size)).WillOnce(testing::Throw(e));
+    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]);
+  }
+  EXPECT_CALL(alloc, deallocate(&mem2[0], 2 * size));
+}
+
+TEST(FixedBufferTest, Ctor) {
+  char array[10] = "garbage";
+  fmt::basic_fixed_buffer<char> buffer(array, sizeof(array));
+  EXPECT_EQ(static_cast<size_t>(0), buffer.size());
+  EXPECT_EQ(10u, buffer.capacity());
+  EXPECT_EQ(array, buffer.data());
+}
+
+TEST(FixedBufferTest, CompileTimeSizeCtor) {
+  char array[10] = "garbage";
+  fmt::basic_fixed_buffer<char> buffer(array);
+  EXPECT_EQ(static_cast<size_t>(0), buffer.size());
+  EXPECT_EQ(10u, buffer.capacity());
+  EXPECT_EQ(array, buffer.data());
+}
+
+TEST(FixedBufferTest, BufferOverflow) {
+  char array[10];
+  fmt::basic_fixed_buffer<char> buffer(array);
+  buffer.resize(10);
+  EXPECT_THROW_MSG(buffer.resize(11), std::runtime_error, "buffer overflow");
+}
+
+#ifdef _WIN32
+TEST(UtilTest, UTF16ToUTF8) {
+  std::string s = "ёжик";
+  fmt::internal::utf16_to_utf8 u(L"\x0451\x0436\x0438\x043A");
+  EXPECT_EQ(s, u.str());
+  EXPECT_EQ(s.size(), u.size());
+}
+
+TEST(UtilTest, UTF16ToUTF8EmptyString) {
+  std::string s = "";
+  fmt::internal::utf16_to_utf8 u(L"");
+  EXPECT_EQ(s, u.str());
+  EXPECT_EQ(s.size(), u.size());
+}
+
+TEST(UtilTest, UTF8ToUTF16) {
+  std::string s = "лошадка";
+  fmt::internal::utf8_to_utf16 u(s.c_str());
+  EXPECT_EQ(L"\x043B\x043E\x0448\x0430\x0434\x043A\x0430", u.str());
+  EXPECT_EQ(7, u.size());
+}
+
+TEST(UtilTest, UTF8ToUTF16EmptyString) {
+  std::string s = "";
+  fmt::internal::utf8_to_utf16 u(s.c_str());
+  EXPECT_EQ(L"", u.str());
+  EXPECT_EQ(s.size(), u.size());
+}
+
+template <typename Converter, typename Char>
+void check_utf_conversion_error(
+        const char *message,
+        fmt::basic_string_view<Char> str = fmt::basic_string_view<Char>(0, 1)) {
+  fmt::memory_buffer out;
+  fmt::internal::format_windows_error(out, ERROR_INVALID_PARAMETER, message);
+  fmt::system_error error(0, "");
+  try {
+    (Converter)(str);
+  } catch (const fmt::system_error &e) {
+    error = e;
+  }
+  EXPECT_EQ(ERROR_INVALID_PARAMETER, error.error_code());
+  EXPECT_EQ(fmt::to_string(out), error.what());
+}
+
+TEST(UtilTest, UTF16ToUTF8Error) {
+  check_utf_conversion_error<fmt::internal::utf16_to_utf8, wchar_t>(
+      "cannot convert string from UTF-16 to UTF-8");
+}
+
+TEST(UtilTest, UTF8ToUTF16Error) {
+  const char *message = "cannot convert string from UTF-8 to UTF-16";
+  check_utf_conversion_error<fmt::internal::utf8_to_utf16, char>(message);
+  check_utf_conversion_error<fmt::internal::utf8_to_utf16, char>(
+    message, fmt::string_view("foo", INT_MAX + 1u));
+}
+
+TEST(UtilTest, UTF16ToUTF8Convert) {
+  fmt::internal::utf16_to_utf8 u;
+  EXPECT_EQ(ERROR_INVALID_PARAMETER, u.convert(fmt::wstring_view(0, 1)));
+  EXPECT_EQ(ERROR_INVALID_PARAMETER,
+            u.convert(fmt::wstring_view(L"foo", INT_MAX + 1u)));
+}
+#endif  // _WIN32
+
+typedef void (*FormatErrorMessage)(
+        fmt::internal::buffer &out, int error_code, string_view message);
+
+template <typename Error>
+void check_throw_error(int error_code, FormatErrorMessage format) {
+  fmt::system_error error(0, "");
+  try {
+    throw Error(error_code, "test {}", "error");
+  } catch (const fmt::system_error &e) {
+    error = e;
+  }
+  fmt::memory_buffer message;
+  format(message, error_code, "test error");
+  EXPECT_EQ(to_string(message), error.what());
+  EXPECT_EQ(error_code, error.error_code());
+}
+
+TEST(UtilTest, FormatSystemError) {
+  fmt::memory_buffer message;
+  fmt::format_system_error(message, EDOM, "test");
+  EXPECT_EQ(fmt::format("test: {}", get_system_error(EDOM)),
+            to_string(message));
+  message = fmt::memory_buffer();
+
+  // Check if std::allocator throws on allocating max size_t / 2 chars.
+  size_t max_size = std::numeric_limits<size_t>::max() / 2;
+  bool throws_on_alloc = false;
+  try {
+    std::allocator<char> alloc;
+    alloc.deallocate(alloc.allocate(max_size), max_size);
+  } catch (const std::bad_alloc&) {
+    throws_on_alloc = true;
+  }
+  if (!throws_on_alloc) {
+    fmt::print("warning: std::allocator allocates {} chars", max_size);
+    return;
+  }
+  fmt::format_system_error(message, EDOM, fmt::string_view(nullptr, max_size));
+  EXPECT_EQ(fmt::format("error {}", EDOM), to_string(message));
+}
+
+TEST(UtilTest, SystemError) {
+  fmt::system_error e(EDOM, "test");
+  EXPECT_EQ(fmt::format("test: {}", get_system_error(EDOM)), e.what());
+  EXPECT_EQ(EDOM, e.error_code());
+  check_throw_error<fmt::system_error>(EDOM, fmt::format_system_error);
+}
+
+TEST(UtilTest, ReportSystemError) {
+  fmt::memory_buffer out;
+  fmt::format_system_error(out, EDOM, "test error");
+  out.push_back('\n');
+  EXPECT_WRITE(stderr, fmt::report_system_error(EDOM, "test error"),
+               to_string(out));
+}
+
+#ifdef _WIN32
+
+TEST(UtilTest, FormatWindowsError) {
+  LPWSTR message = 0;
+  FormatMessageW(FORMAT_MESSAGE_ALLOCATE_BUFFER |
+      FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, 0,
+      ERROR_FILE_EXISTS, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
+      reinterpret_cast<LPWSTR>(&message), 0, 0);
+  fmt::internal::utf16_to_utf8 utf8_message(message);
+  LocalFree(message);
+  fmt::memory_buffer actual_message;
+  fmt::internal::format_windows_error(
+      actual_message, ERROR_FILE_EXISTS, "test");
+  EXPECT_EQ(fmt::format("test: {}", utf8_message.str()),
+      fmt::to_string(actual_message));
+  actual_message.resize(0);
+  fmt::internal::format_windows_error(
+        actual_message, ERROR_FILE_EXISTS,
+        fmt::string_view(0, std::numeric_limits<size_t>::max()));
+  EXPECT_EQ(fmt::format("error {}", ERROR_FILE_EXISTS),
+            fmt::to_string(actual_message));
+}
+
+TEST(UtilTest, FormatLongWindowsError) {
+  LPWSTR message = 0;
+  // this error code is not available on all Windows platforms and
+  // Windows SDKs, so do not fail the test if the error string cannot
+  // be retrieved.
+  const int provisioning_not_allowed = 0x80284013L /*TBS_E_PROVISIONING_NOT_ALLOWED*/;
+  if (FormatMessageW(FORMAT_MESSAGE_ALLOCATE_BUFFER |
+      FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, 0,
+      static_cast<DWORD>(provisioning_not_allowed),
+      MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
+      reinterpret_cast<LPWSTR>(&message), 0, 0) == 0) {
+    return;
+  }
+  fmt::internal::utf16_to_utf8 utf8_message(message);
+  LocalFree(message);
+  fmt::memory_buffer actual_message;
+  fmt::internal::format_windows_error(
+      actual_message, provisioning_not_allowed, "test");
+  EXPECT_EQ(fmt::format("test: {}", utf8_message.str()),
+      fmt::to_string(actual_message));
+}
+
+TEST(UtilTest, WindowsError) {
+  check_throw_error<fmt::windows_error>(
+      ERROR_FILE_EXISTS, fmt::internal::format_windows_error);
+}
+
+TEST(UtilTest, ReportWindowsError) {
+  fmt::memory_buffer out;
+  fmt::internal::format_windows_error(out, ERROR_FILE_EXISTS, "test error");
+  out.push_back('\n');
+  EXPECT_WRITE(stderr,
+      fmt::report_windows_error(ERROR_FILE_EXISTS, "test error"),
+               fmt::to_string(out));
+}
+
+#endif  // _WIN32
+
 TEST(StringViewTest, Ctor) {
   EXPECT_STREQ("abc", string_view("abc").data());
   EXPECT_EQ(3u, string_view("abc").size());
@@ -237,6 +692,9 @@ TEST(FormatToTest, FormatToMemoryBuffer) {
   fmt::basic_memory_buffer<char, 100> buffer;
   fmt::format_to(buffer, "{}", "foo");
   EXPECT_EQ("foo", to_string(buffer));
+  fmt::wmemory_buffer wbuffer;
+  fmt::format_to(wbuffer, L"{}", L"foo");
+  EXPECT_EQ(L"foo", to_string(wbuffer));
 }
 
 TEST(FormatterTest, Escape) {

test/mock-allocator.h

@@ -9,23 +9,24 @@
 #define FMT_MOCK_ALLOCATOR_H_
 
 #include "gmock.h"
+#include "fmt/format.h"
 
 template <typename T>
-class MockAllocator {
+class mock_allocator {
  public:
-  MockAllocator() {}
-  MockAllocator(const MockAllocator &) {}
+  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));
 };
 
 template <typename Allocator>
-class AllocatorRef {
+class allocator_ref {
  private:
   Allocator *alloc_;
 
-  void move(AllocatorRef &other) {
+  void move(allocator_ref &other) {
     alloc_ = other.alloc_;
     other.alloc_ = nullptr;
   }
@@ -33,18 +34,18 @@ class AllocatorRef {
  public:
   typedef typename Allocator::value_type value_type;
 
-  explicit AllocatorRef(Allocator *alloc = nullptr) : alloc_(alloc) {}
+  explicit allocator_ref(Allocator *alloc = nullptr) : alloc_(alloc) {}
 
-  AllocatorRef(const AllocatorRef &other) : alloc_(other.alloc_) {}
-  AllocatorRef(AllocatorRef &&other) { move(other); }
+  allocator_ref(const allocator_ref &other) : alloc_(other.alloc_) {}
+  allocator_ref(allocator_ref &&other) { move(other); }
 
-  AllocatorRef& operator=(AllocatorRef &&other) {
+  allocator_ref& operator=(allocator_ref &&other) {
     assert(this != &other);
     move(other);
     return *this;
   }
 
-  AllocatorRef& operator=(const AllocatorRef &other) {
+  allocator_ref& operator=(const allocator_ref &other) {
     alloc_ = other.alloc_;
     return *this;
   }

test/test-assert.h

@@ -5,23 +5,22 @@
 //
 // For the license information refer to format.h.
 
-#ifndef FMT_TEST_ASSERT_H
-#define FMT_TEST_ASSERT_H
+#ifndef FMT_TEST_ASSERT_H_
+#define FMT_TEST_ASSERT_H_
 
 #include <stdexcept>
+#include "gtest.h"
 
-class AssertionFailure : public std::logic_error {
+class assertion_failure : public std::logic_error {
  public:
-  explicit AssertionFailure(const char *message) : std::logic_error(message) {}
+  explicit assertion_failure(const char *message) : std::logic_error(message) {}
 };
 
 #define FMT_ASSERT(condition, message) \
-  if (!(condition)) throw AssertionFailure(message);
-
-#include "gtest-extra.h"
+  if (!(condition)) throw assertion_failure(message);
 
 // Expects an assertion failure.
 #define EXPECT_ASSERT(stmt, message) \
-  EXPECT_THROW_MSG(stmt, AssertionFailure, message)
+  FMT_TEST_THROW_(stmt, assertion_failure, message, GTEST_NONFATAL_FAILURE_)
 
-#endif  // FMT_TEST_ASSERT_H
+#endif  // FMT_TEST_ASSERT_H_