From 8c99ec07386fb2fc386e339f661880ccad957135 Mon Sep 17 00:00:00 2001
From: stryku <stryku2393@gmail.com>
Date: Tue, 27 Nov 2018 11:52:00 +0100
Subject: [PATCH] Implemented fmt::prepare()

Implementation of fmt::prepare() function and features around it.
---
 CMakeLists.txt             |    2 +-
 include/fmt/chrono.h       |   14 +-
 include/fmt/color.h        |   15 +-
 include/fmt/core.h         |   30 +-
 include/fmt/format.h       |  252 +++---
 include/fmt/prepare.h      |  814 ++++++++++++++++++
 test/CMakeLists.txt        |    6 +
 test/common-format-test.cc | 1621 ++++++++++++++++++++++++++++++++++++
 test/format-test.cc        | 1063 +----------------------
 test/ostream-test.cc       |    2 +-
 test/prepare-test.cc       |  643 ++++++++++++++
 11 files changed, 3301 insertions(+), 1161 deletions(-)
 create mode 100644 include/fmt/prepare.h
 create mode 100644 test/common-format-test.cc
 create mode 100644 test/prepare-test.cc

diff --git a/CMakeLists.txt b/CMakeLists.txt
index ce9dbf95..b6ff7251 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -140,7 +140,7 @@ endfunction()
 
 # Define the fmt library, its includes and the needed defines.
 add_headers(FMT_HEADERS chrono.h color.h core.h format.h format-inl.h locale.h
-                        ostream.h printf.h time.h ranges.h)
+                        ostream.h prepare.h printf.h time.h ranges.h)
 set(FMT_SOURCES src/format.cc)
 if (HAVE_OPEN)
   add_headers(FMT_HEADERS posix.h)
diff --git a/include/fmt/chrono.h b/include/fmt/chrono.h
index 209cdc25..593530a3 100644
--- a/include/fmt/chrono.h
+++ b/include/fmt/chrono.h
@@ -372,15 +372,15 @@ template <typename Rep, typename Period, typename Char>
 struct formatter<std::chrono::duration<Rep, Period>, Char> {
  private:
   align_spec spec;
-  internal::arg_ref<Char> width_ref;
+  typedef internal::arg_ref<Char> arg_ref_type;
+  arg_ref_type width_ref;
   mutable basic_string_view<Char> format_str;
   typedef std::chrono::duration<Rep, Period> duration;
 
   struct spec_handler {
     formatter &f;
     basic_parse_context<Char> &context;
-
-    typedef internal::arg_ref<Char> arg_ref_type;
+    basic_string_view<Char> format_str;
 
     template <typename Id>
     FMT_CONSTEXPR arg_ref_type make_arg_ref(Id arg_id) {
@@ -388,6 +388,12 @@ struct formatter<std::chrono::duration<Rep, Period>, Char> {
       return arg_ref_type(arg_id);
     }
 
+    FMT_CONSTEXPR arg_ref_type make_arg_ref(basic_string_view<Char> arg_id) {
+      context.check_arg_id(arg_id);
+      const auto str_val = internal::string_view_metadata(format_str, arg_id);
+      return arg_ref_type(str_val);
+    }
+
     FMT_CONSTEXPR arg_ref_type make_arg_ref(internal::auto_id) {
       return arg_ref_type(context.next_arg_id());
     }
@@ -410,7 +416,7 @@ struct formatter<std::chrono::duration<Rep, Period>, Char> {
       -> decltype(ctx.begin()) {
     auto begin = ctx.begin(), end = ctx.end();
     if (begin == end) return begin;
-    spec_handler handler{*this, ctx};
+    spec_handler handler{*this, ctx, format_str};
     begin = internal::parse_align(begin, end, handler);
     if (begin == end) return begin;
     begin = internal::parse_width(begin, end, handler);
diff --git a/include/fmt/color.h b/include/fmt/color.h
index f38455a4..08eafec2 100644
--- a/include/fmt/color.h
+++ b/include/fmt/color.h
@@ -221,14 +221,13 @@ enum class emphasis : uint8_t {
 // We use rgb as name because some editors will show it as color direct in the
 // editor.
 struct rgb {
-  FMT_CONSTEXPR_DECL rgb() : r(0), g(0), b(0) {}
-  FMT_CONSTEXPR_DECL rgb(uint8_t r_, uint8_t g_, uint8_t b_)
-    : r(r_), g(g_), b(b_) {}
-  FMT_CONSTEXPR_DECL rgb(uint32_t hex)
-    : r((hex >> 16) & 0xFF), g((hex >> 8) & 0xFF), b((hex) & 0xFF) {}
-  FMT_CONSTEXPR_DECL rgb(color hex)
-    : r((uint32_t(hex) >> 16) & 0xFF), g((uint32_t(hex) >> 8) & 0xFF),
-      b(uint32_t(hex) & 0xFF) {}
+  FMT_CONSTEXPR rgb() : r(0), g(0), b(0) {}
+  FMT_CONSTEXPR rgb(uint8_t r_, uint8_t g_, uint8_t b_) : r(r_), g(g_), b(b_) {}
+  FMT_CONSTEXPR rgb(uint32_t hex)
+      : r((hex >> 16) & 0xFF), g((hex >> 8) & 0xFF), b((hex)&0xFF) {}
+  FMT_CONSTEXPR rgb(color hex)
+      : r((uint32_t(hex) >> 16) & 0xFF), g((uint32_t(hex) >> 8) & 0xFF),
+        b(uint32_t(hex) & 0xFF) {}
   uint8_t r;
   uint8_t g;
   uint8_t b;
diff --git a/include/fmt/core.h b/include/fmt/core.h
index 85503b4a..f4d80b65 100644
--- a/include/fmt/core.h
+++ b/include/fmt/core.h
@@ -454,9 +454,11 @@ template <typename Char>
 inline basic_string_view<Char>
   to_string_view(basic_string_view<Char> s) { return s; }
 
-template <typename Char>
+template <typename Char, typename Traits, typename Allocator>
 inline basic_string_view<Char>
-  to_string_view(const std::basic_string<Char> &s) { return s; }
+to_string_view(const std::basic_string<Char, Traits, Allocator> &s) {
+  return {s.data(), s.size()};
+}
 
 template <typename Char>
 inline basic_string_view<Char> to_string_view(const Char *s) { return s; }
@@ -504,6 +506,8 @@ template <typename T, typename Char, typename Enable = void>
 struct convert_to_int: std::integral_constant<
   bool, !std::is_arithmetic<T>::value && std::is_convertible<T, int>::value> {};
 
+template <typename Char> struct basic_format_specs;
+
 namespace internal {
 
 struct dummy_string_view { typedef void char_type; };
@@ -877,16 +881,18 @@ FMT_CONSTEXPR typename internal::result_of<Visitor(int)>::type
 template <typename Char, typename ErrorHandler = internal::error_handler>
 class basic_parse_context : private ErrorHandler {
  private:
-  basic_string_view<Char> format_str_;
-  int next_arg_id_;
+   basic_string_view<Char> primary_format_str_;
+   basic_string_view<Char> format_str_;
+   int next_arg_id_;
 
  public:
   typedef Char char_type;
   typedef typename basic_string_view<Char>::iterator iterator;
 
-  explicit FMT_CONSTEXPR basic_parse_context(
-      basic_string_view<Char> format_str, ErrorHandler eh = ErrorHandler())
-    : ErrorHandler(eh), format_str_(format_str), next_arg_id_(0) {}
+  explicit FMT_CONSTEXPR basic_parse_context(basic_string_view<Char> format_str,
+                                             ErrorHandler eh = ErrorHandler())
+      : ErrorHandler(eh), primary_format_str_(format_str),
+        format_str_(format_str), next_arg_id_(0) {}
 
   // Returns an iterator to the beginning of the format string range being
   // parsed.
@@ -913,13 +919,17 @@ class basic_parse_context : private ErrorHandler {
     next_arg_id_ = -1;
     return true;
   }
-  void check_arg_id(basic_string_view<Char>) {}
+
+  FMT_CONSTEXPR void check_arg_id(basic_string_view<Char>) {}
 
   FMT_CONSTEXPR void on_error(const char *message) {
     ErrorHandler::on_error(message);
   }
 
   FMT_CONSTEXPR ErrorHandler error_handler() const { return *this; }
+  FMT_CONSTEXPR basic_string_view<Char> primary_format() const {
+    return primary_format_str_;
+  }
 };
 
 typedef basic_parse_context<char> format_parse_context;
@@ -1038,6 +1048,10 @@ class context_base {
   void advance_to(iterator it) { out_ = it; }
 
   locale_ref locale() { return loc_; }
+
+  basic_string_view<Char> primary_format() const {
+    return parse_context_.primary_format();
+  }
 };
 
 template <typename Context, typename T>
diff --git a/include/fmt/format.h b/include/fmt/format.h
index 1bb24a52..20bc65c1 100644
--- a/include/fmt/format.h
+++ b/include/fmt/format.h
@@ -81,6 +81,16 @@
 # define FMT_SECURE_SCL 0
 #endif
 
+// Check whether we can use unrestricted unions (e.g. unions with non-PODs
+// members). If no, use struct.
+#ifndef FMT_UNRESTRICTED_UNION
+#if (FMT_MSC_VER >= 1900 || FMT_GCC_VERSION >= 406 || FMT_CLANG_VERSION >= 303)
+#define FMT_UNRESTRICTED_UNION union
+#else
+#define FMT_UNRESTRICTED_UNION struct
+#endif
+#endif
+
 #if FMT_SECURE_SCL
 # include <iterator>
 #endif
@@ -1104,6 +1114,7 @@ struct core_format_specs {
 
   FMT_CONSTEXPR core_format_specs() : precision(-1), flags(0), type(0) {}
   FMT_CONSTEXPR bool has(unsigned f) const { return (flags & f) != 0; }
+  FMT_CONSTEXPR bool has_precision() const { return precision != -1; }
 };
 
 // Format specifiers.
@@ -1585,68 +1596,79 @@ class specs_setter {
   basic_format_specs<Char> &specs_;
 };
 
+template <typename ErrorHandler> class numeric_specs_checker {
+public:
+  FMT_CONSTEXPR numeric_specs_checker(ErrorHandler &eh, internal::type arg_type)
+      : error_handler_(eh), arg_type_(arg_type) {}
+  FMT_CONSTEXPR void require_numeric_argument() {
+    if (!is_arithmetic(arg_type_)) {
+      error_handler_.on_error("format specifier requires numeric argument");
+    }
+  }
+  FMT_CONSTEXPR void check_sign() {
+    require_numeric_argument();
+    if (is_integral(arg_type_) && arg_type_ != int_type &&
+        arg_type_ != long_long_type && arg_type_ != internal::char_type) {
+      error_handler_.on_error("format specifier requires signed argument");
+    }
+  }
+  FMT_CONSTEXPR void check_precision() {
+    if (is_integral(arg_type_) || arg_type_ == internal::pointer_type) {
+      error_handler_.on_error("precision not allowed for this argument type");
+    }
+  }
+
+private:
+  ErrorHandler &error_handler_;
+  internal::type arg_type_;
+};
+
 // A format specifier handler that checks if specifiers are consistent with the
 // argument type.
 template <typename Handler>
 class specs_checker : public Handler {
  public:
-  FMT_CONSTEXPR specs_checker(const Handler& handler, internal::type arg_type)
-    : Handler(handler), arg_type_(arg_type) {}
+   FMT_CONSTEXPR specs_checker(const Handler &handler, internal::type arg_type)
+       : Handler(handler), checker_(*this, arg_type) {}
 
-  FMT_CONSTEXPR specs_checker(const specs_checker &other)
-    : Handler(other), arg_type_(other.arg_type_) {}
+   FMT_CONSTEXPR specs_checker(const specs_checker &other)
+       : Handler(other), checker_(*this, other.arg_type_) {}
 
-  FMT_CONSTEXPR void on_align(alignment align) {
-    if (align == ALIGN_NUMERIC)
-      require_numeric_argument();
-    Handler::on_align(align);
+   FMT_CONSTEXPR void on_align(alignment align) {
+     if (align == ALIGN_NUMERIC)
+       checker_.require_numeric_argument();
+     Handler::on_align(align);
   }
 
   FMT_CONSTEXPR void on_plus() {
-    check_sign();
+    checker_.check_sign();
     Handler::on_plus();
   }
 
   FMT_CONSTEXPR void on_minus() {
-    check_sign();
+    checker_.check_sign();
     Handler::on_minus();
   }
 
   FMT_CONSTEXPR void on_space() {
-    check_sign();
+    checker_.check_sign();
     Handler::on_space();
   }
 
   FMT_CONSTEXPR void on_hash() {
-    require_numeric_argument();
+    checker_.require_numeric_argument();
     Handler::on_hash();
   }
 
   FMT_CONSTEXPR void on_zero() {
-    require_numeric_argument();
+    checker_.require_numeric_argument();
     Handler::on_zero();
   }
 
-  FMT_CONSTEXPR void end_precision() {
-    if (is_integral(arg_type_) || arg_type_ == pointer_type)
-      this->on_error("precision not allowed for this argument type");
-  }
+  FMT_CONSTEXPR void end_precision() { checker_.check_precision(); }
 
- private:
-  FMT_CONSTEXPR void require_numeric_argument() {
-    if (!is_arithmetic(arg_type_))
-      this->on_error("format specifier requires numeric argument");
-  }
-
-  FMT_CONSTEXPR void check_sign() {
-    require_numeric_argument();
-    if (is_integral(arg_type_) && arg_type_ != int_type &&
-        arg_type_ != long_long_type && arg_type_ != internal::char_type) {
-      this->on_error("format specifier requires signed argument");
-    }
-  }
-
-  internal::type arg_type_;
+private:
+  numeric_specs_checker<Handler> checker_;
 };
 
 template <template <typename> class Handler, typename T,
@@ -1702,28 +1724,53 @@ class specs_handler: public specs_setter<typename Context::char_type> {
   Context &context_;
 };
 
+struct string_view_metadata {
+  FMT_CONSTEXPR string_view_metadata() : offset_(0u), size_(0u) {}
+  template <typename Char>
+  FMT_CONSTEXPR string_view_metadata(basic_string_view<Char> primary_string,
+                                     basic_string_view<Char> view)
+      : offset_(view.data() - primary_string.data()), size_(view.size()) {}
+  FMT_CONSTEXPR string_view_metadata(std::size_t offset, std::size_t size)
+      : offset_(offset), size_(size) {}
+  template <typename S>
+  FMT_CONSTEXPR typename std::enable_if<internal::is_string<S>::value,
+                                        basic_string_view<FMT_CHAR(S)>>::type
+  to_view(S &&str) const {
+    const auto view = to_string_view(str);
+    return basic_string_view<FMT_CHAR(S)>(view.data() + offset_, size_);
+  }
+
+  std::size_t offset_;
+  std::size_t size_;
+};
+
 // An argument reference.
 template <typename Char>
 struct arg_ref {
   enum Kind { NONE, INDEX, NAME };
+  typedef Char char_type;
 
-  FMT_CONSTEXPR arg_ref() : kind(NONE), index(0) {}
-  FMT_CONSTEXPR explicit arg_ref(unsigned index) : kind(INDEX), index(index) {}
-  explicit arg_ref(basic_string_view<Char> nm) : kind(NAME) {
-    name = {nm.data(), nm.size()};
-  }
+  FMT_CONSTEXPR arg_ref() : kind(NONE), val() {}
+  FMT_CONSTEXPR explicit arg_ref(unsigned index) : kind(INDEX), val(index) {}
+  FMT_CONSTEXPR explicit arg_ref(string_view_metadata name)
+      : kind(NAME), val(name) {}
 
   FMT_CONSTEXPR arg_ref &operator=(unsigned idx) {
     kind = INDEX;
-    index = idx;
+    val.index = idx;
     return *this;
   }
 
   Kind kind;
-  union {
+  FMT_UNRESTRICTED_UNION value {
+    FMT_CONSTEXPR value() : index(0u) {}
+    FMT_CONSTEXPR value(unsigned id) : index(id) {}
+    FMT_CONSTEXPR value(string_view_metadata n) : name(n) {}
+
     unsigned index;
-    string_value<Char> name;  // This is not string_view because of gcc 4.4.
-  };
+    string_view_metadata name;
+  }
+  val;
 };
 
 // Format specifiers with width and precision resolved at formatting rather
@@ -1737,19 +1784,19 @@ struct dynamic_format_specs : basic_format_specs<Char> {
 
 // Format spec handler that saves references to arguments representing dynamic
 // width and precision to be resolved at formatting time.
-template <typename ParseContext>
-class dynamic_specs_handler :
-    public specs_setter<typename ParseContext::char_type> {
- public:
+template <typename Specs, typename ParseContext>
+class dynamic_specs_handler
+    : public specs_setter<typename ParseContext::char_type> {
+
+public:
   typedef typename ParseContext::char_type char_type;
 
-  FMT_CONSTEXPR dynamic_specs_handler(
-      dynamic_format_specs<char_type> &specs, ParseContext &ctx)
-    : specs_setter<char_type>(specs), specs_(specs), context_(ctx) {}
+private:
+  typedef arg_ref<typename ParseContext::char_type> arg_ref_type;
 
-  FMT_CONSTEXPR dynamic_specs_handler(const dynamic_specs_handler &other)
-    : specs_setter<char_type>(other),
-      specs_(other.specs_), context_(other.context_) {}
+public:
+  FMT_CONSTEXPR dynamic_specs_handler(Specs &specs, ParseContext &ctx)
+      : specs_setter<char_type>(specs), specs_(specs), context_(ctx) {}
 
   template <typename Id>
   FMT_CONSTEXPR void on_dynamic_width(Id arg_id) {
@@ -1766,19 +1813,24 @@ class dynamic_specs_handler :
   }
 
  private:
-  typedef arg_ref<char_type> arg_ref_type;
-
-  template <typename Id>
-  FMT_CONSTEXPR arg_ref_type make_arg_ref(Id arg_id) {
-    context_.check_arg_id(arg_id);
-    return arg_ref_type(arg_id);
+   FMT_CONSTEXPR arg_ref_type make_arg_ref(unsigned arg_id) {
+     context_.check_arg_id(arg_id);
+     return arg_ref_type(arg_id);
   }
 
   FMT_CONSTEXPR arg_ref_type make_arg_ref(auto_id) {
     return arg_ref_type(context_.next_arg_id());
   }
 
-  dynamic_format_specs<char_type> &specs_;
+  FMT_CONSTEXPR arg_ref_type make_arg_ref(basic_string_view<char_type> arg_id) {
+    context_.check_arg_id(arg_id);
+    const auto id_metadata =
+        string_view_metadata(context_.primary_format(), arg_id);
+    return arg_ref_type(id_metadata);
+  }
+
+private:
+  Specs &specs_;
   ParseContext &context_;
 };
 
@@ -2131,21 +2183,22 @@ struct format_type :
   std::integral_constant<bool, get_type<Context, T>::value != custom_type> {};
 
 template <template <typename> class Handler, typename Spec, typename Context>
-void handle_dynamic_spec(
-    Spec &value, arg_ref<typename Context::char_type> ref, Context &ctx) {
+void handle_dynamic_spec(Spec &value, arg_ref<typename Context::char_type> ref,
+                         Context &ctx) {
   typedef typename Context::char_type char_type;
+  typedef arg_ref<char_type> arg_ref_type;
   switch (ref.kind) {
-  case arg_ref<char_type>::NONE:
+  case arg_ref_type::NONE:
     break;
-  case arg_ref<char_type>::INDEX:
-    internal::set_dynamic_spec<Handler>(
-          value, ctx.get_arg(ref.index), ctx.error_handler());
-    break;
-  case arg_ref<char_type>::NAME:
-    internal::set_dynamic_spec<Handler>(
-          value, ctx.get_arg({ref.name.value, ref.name.size}),
-          ctx.error_handler());
+  case arg_ref_type::INDEX:
+    internal::set_dynamic_spec<Handler>(value, ctx.get_arg(ref.val.index),
+                                        ctx.error_handler());
     break;
+  case arg_ref_type::NAME: {
+    const auto arg_id = ref.val.name.to_view(ctx.primary_format());
+    internal::set_dynamic_spec<Handler>(value, ctx.get_arg(arg_id),
+                                        ctx.error_handler());
+  } break;
   }
 }
 }  // namespace internal
@@ -2925,7 +2978,9 @@ struct formatter<
   // terminating '}'.
   template <typename ParseContext>
   FMT_CONSTEXPR typename ParseContext::iterator parse(ParseContext &ctx) {
-    typedef internal::dynamic_specs_handler<ParseContext> handler_type;
+    typedef internal::dynamic_specs_handler<
+        internal::dynamic_format_specs<Char>, ParseContext>
+        handler_type;
     auto type = internal::get_type<
       typename buffer_context<Char>::type, T>::value;
     internal::specs_checker<handler_type>
@@ -3011,33 +3066,42 @@ class dynamic_formatter {
     void on_hash() {}
   };
 
- public:
+  typedef internal::dynamic_format_specs<Char> dynamic_specs;
+
+public:
   template <typename ParseContext>
   auto parse(ParseContext &ctx) -> decltype(ctx.begin()) {
+    typedef internal::dynamic_specs_handler<
+        internal::dynamic_format_specs<Char>, ParseContext>
+        handler_type;
+    handler_type handler(specs_, ctx);
     // Checks are deferred to formatting time when the argument type is known.
-    internal::dynamic_specs_handler<ParseContext> handler(specs_, ctx);
     return parse_format_specs(ctx.begin(), ctx.end(), handler);
   }
 
   template <typename T, typename FormatContext>
   auto format(const T &val, FormatContext &ctx) -> decltype(ctx.out()) {
+    basic_format_specs<Char> specs;
     handle_specs(ctx);
-    internal::specs_checker<null_handler>
-        checker(null_handler(), internal::get_type<FormatContext, T>::value);
-    checker.on_align(specs_.align());
-    if (specs_.flags == 0);  // Do nothing.
-    else if (specs_.has(SIGN_FLAG))
-      specs_.has(PLUS_FLAG) ? checker.on_plus() : checker.on_space();
-    else if (specs_.has(MINUS_FLAG))
+    specs = specs_;
+
+    internal::specs_checker<null_handler> checker(
+        null_handler(), internal::get_type<FormatContext, T>::value);
+    checker.on_align(specs.align());
+    if (specs.flags == 0)
+      ; // Do nothing.
+    else if (specs.has(SIGN_FLAG))
+      specs.has(PLUS_FLAG) ? checker.on_plus() : checker.on_space();
+    else if (specs.has(MINUS_FLAG))
       checker.on_minus();
-    else if (specs_.has(HASH_FLAG))
+    else if (specs.has(HASH_FLAG))
       checker.on_hash();
-    if (specs_.precision != -1)
+    if (specs.precision != -1)
       checker.end_precision();
     typedef output_range<typename FormatContext::iterator,
                          typename FormatContext::char_type> range;
-    visit_format_arg(arg_formatter<range>(ctx, &specs_),
-               internal::make_arg<FormatContext>(val));
+    visit_format_arg(arg_formatter<range>(ctx, &specs),
+                     internal::make_arg<FormatContext>(val));
     return ctx.out();
   }
 
@@ -3050,7 +3114,7 @@ class dynamic_formatter {
       specs_.precision, specs_.precision_ref, ctx);
   }
 
-  internal::dynamic_format_specs<Char> specs_;
+  dynamic_specs specs_;
 };
 
 template <typename Range, typename Char>
@@ -3510,16 +3574,16 @@ operator"" _a(const wchar_t *s, std::size_t) { return {s}; }
 #endif // FMT_USE_USER_DEFINED_LITERALS
 FMT_END_NAMESPACE
 
-#define FMT_STRING(s) [] { \
-    typedef typename std::remove_cv<std::remove_pointer< \
-      typename std::decay<decltype(s)>::type>::type>::type ct; \
-    struct str : fmt::compile_string { \
-      typedef ct char_type; \
-      FMT_CONSTEXPR operator fmt::basic_string_view<ct>() const { \
-        return {s, sizeof(s) / sizeof(ct) - 1}; \
-      } \
-    }; \
-    return str{}; \
+#define FMT_STRING(s)                                                          \
+  [] {                                                                         \
+    struct str : fmt::compile_string {                                         \
+      typedef typename std::remove_cv<std::remove_pointer<                     \
+          typename std::decay<decltype(s)>::type>::type>::type char_type;      \
+      FMT_CONSTEXPR operator fmt::basic_string_view<char_type>() const {       \
+        return {s, sizeof(s) / sizeof(char_type) - 1};                         \
+      }                                                                        \
+    };                                                                         \
+    return str{};                                                              \
   }()
 
 #if defined(FMT_STRING_ALIAS) && FMT_STRING_ALIAS
diff --git a/include/fmt/prepare.h b/include/fmt/prepare.h
new file mode 100644
index 00000000..e08f367f
--- /dev/null
+++ b/include/fmt/prepare.h
@@ -0,0 +1,814 @@
+/*
+ Formatting library for C++
+
+ Copyright (c) 2012 - present, Victor Zverovich
+ All rights reserved.
+
+ Redistribution and use in source and binary forms, with or without
+ modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice, this
+    list of conditions and the following disclaimer.
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef FMT_PREPARE_H_
+#define FMT_PREPARE_H_
+
+#ifndef FMT_HAS_CONSTRUCTIBLE_TRAITS
+#define FMT_HAS_CONSTRUCTIBLE_TRAITS                                           \
+  (FMT_GCC_VERSION >= 407 || FMT_CLANG_VERSION || FMT_MSC_VER)
+#endif
+
+#include "format.h"
+
+#include <vector>
+
+FMT_BEGIN_NAMESPACE
+
+template <typename Char> struct format_part {
+public:
+  struct named_argument_id {
+    FMT_CONSTEXPR named_argument_id(internal::string_view_metadata id)
+        : id(id) {}
+    internal::string_view_metadata id;
+  };
+
+  struct argument_id {
+    FMT_CONSTEXPR argument_id() : argument_id(0u) {}
+
+    FMT_CONSTEXPR argument_id(unsigned id)
+        : which(which_arg_id::index), val(id) {}
+
+    FMT_CONSTEXPR argument_id(internal::string_view_metadata id)
+        : which(which_arg_id::named_index), val(id) {}
+
+    enum class which_arg_id { index, named_index };
+
+    which_arg_id which;
+
+    FMT_UNRESTRICTED_UNION value {
+      FMT_CONSTEXPR value() : index(0u) {}
+      FMT_CONSTEXPR value(unsigned id) : index(id) {}
+      FMT_CONSTEXPR value(internal::string_view_metadata id)
+          : named_index(id) {}
+
+      unsigned index;
+      internal::string_view_metadata named_index;
+    }
+    val;
+  };
+
+  struct specification {
+    FMT_CONSTEXPR specification() : arg_id(0u) {}
+    FMT_CONSTEXPR specification(unsigned id) : arg_id(id) {}
+
+    FMT_CONSTEXPR specification(internal::string_view_metadata id)
+        : arg_id(id) {}
+
+    argument_id arg_id;
+    internal::dynamic_format_specs<Char> parsed_specs;
+  };
+
+  FMT_CONSTEXPR format_part()
+      : which(which_value::argument_id), end_of_argument_id(0u), val(0u) {}
+
+  FMT_CONSTEXPR format_part(internal::string_view_metadata text)
+      : which(which_value::text), end_of_argument_id(0u), val(text) {}
+
+  FMT_CONSTEXPR format_part(unsigned id)
+      : which(which_value::argument_id), end_of_argument_id(0u), val(id) {}
+
+  FMT_CONSTEXPR format_part(named_argument_id arg_id)
+      : which(which_value::named_argument_id), end_of_argument_id(0u),
+        val(arg_id) {}
+
+  FMT_CONSTEXPR format_part(specification spec)
+      : which(which_value::specification), end_of_argument_id(0u), val(spec) {}
+
+  enum class which_value {
+    argument_id,
+    named_argument_id,
+    text,
+    specification
+  };
+
+  which_value which;
+  std::size_t end_of_argument_id;
+  FMT_UNRESTRICTED_UNION value {
+    FMT_CONSTEXPR value() : arg_id(0u) {}
+    FMT_CONSTEXPR value(unsigned id) : arg_id(id) {}
+    FMT_CONSTEXPR value(named_argument_id named_id)
+        : named_arg_id(named_id.id) {}
+    FMT_CONSTEXPR value(internal::string_view_metadata t) : text(t) {}
+    FMT_CONSTEXPR value(specification s) : spec(s) {}
+    unsigned arg_id;
+    internal::string_view_metadata named_arg_id;
+    internal::string_view_metadata text;
+    specification spec;
+  }
+  val;
+};
+
+namespace internal {
+template <typename Char, typename PartsContainer>
+class format_preparation_handler : public internal::error_handler {
+private:
+  typedef format_part<Char> part;
+
+public:
+  typedef internal::null_terminating_iterator<Char> iterator;
+
+  FMT_CONSTEXPR format_preparation_handler(basic_string_view<Char> format,
+                                           PartsContainer &parts)
+      : parts_(parts), format_(format), parse_context_(format) {}
+
+  FMT_CONSTEXPR void on_text(const Char *begin, const Char *end) {
+    if (begin == end) {
+      return;
+    }
+    const auto offset = begin - format_.data();
+    const auto size = end - begin;
+    parts_.add(part(string_view_metadata(offset, size)));
+  }
+
+  FMT_CONSTEXPR void on_arg_id() {
+    parts_.add(part(parse_context_.next_arg_id()));
+  }
+
+  FMT_CONSTEXPR void on_arg_id(unsigned id) {
+    parse_context_.check_arg_id(id);
+    parts_.add(part(id));
+  }
+
+  FMT_CONSTEXPR void on_arg_id(basic_string_view<Char> id) {
+    const auto view = string_view_metadata(format_, id);
+    const auto arg_id = typename part::named_argument_id(view);
+    parts_.add(part(arg_id));
+  }
+
+  FMT_CONSTEXPR void on_replacement_field(const Char *ptr) {
+    auto last_part = parts_.last();
+    last_part.end_of_argument_id = ptr - format_.begin();
+    parts_.substitute_last(last_part);
+  }
+
+  FMT_CONSTEXPR const Char *on_format_specs(const Char *begin,
+                                            const Char *end) {
+    const auto specs_offset = to_unsigned(begin - format_.begin());
+
+    typedef internal::dynamic_format_specs<Char> prepared_specs;
+    typedef basic_parse_context<Char> parse_context;
+    prepared_specs parsed_specs;
+    dynamic_specs_handler<prepared_specs, parse_context> handler(
+        parsed_specs, parse_context_);
+    begin = parse_format_specs(begin, end, handler);
+
+    if (*begin != '}') {
+      on_error("missing '}' in format string");
+    }
+
+    const auto last_part = parts_.last();
+
+    auto specs = last_part.which == part::which_value::argument_id
+                     ? typename part::specification(last_part.val.arg_id)
+                     : typename part::specification(last_part.val.named_arg_id);
+
+    specs.parsed_specs = parsed_specs;
+
+    auto new_part = part(specs);
+    new_part.end_of_argument_id = specs_offset;
+
+    parts_.substitute_last(new_part);
+
+    return begin;
+  }
+
+private:
+  PartsContainer &parts_;
+  basic_string_view<Char> format_;
+  basic_parse_context<Char> parse_context_;
+};
+
+template <typename ErrorHandler> class parsed_specs_checker {
+public:
+  FMT_CONSTEXPR parsed_specs_checker(ErrorHandler &error_handler,
+                                     internal::type arg_type)
+      : checker_(error_handler, arg_type) {}
+
+  template <typename Char>
+  FMT_CONSTEXPR void check(const basic_format_specs<Char> &specs) {
+    if (specs.align_ == ALIGN_NUMERIC) {
+      checker_.require_numeric_argument();
+    }
+
+    if (specs.has(PLUS_FLAG | MINUS_FLAG | SIGN_FLAG)) {
+      checker_.check_sign();
+    }
+
+    if (specs.has(HASH_FLAG)) {
+      checker_.require_numeric_argument();
+    }
+
+    if (specs.has_precision()) {
+      checker_.check_precision();
+    }
+  }
+
+private:
+  numeric_specs_checker<ErrorHandler> checker_;
+};
+
+template <typename Format, typename PreparedPartsProvider, typename... Args>
+class prepared_format {
+public:
+  typedef FMT_CHAR(Format) char_type;
+  typedef format_part<char_type> format_part_t;
+  typedef internal::checked_args<Format, Args...> checked_args;
+
+  prepared_format(Format f)
+      : format_(std::move(f)), parts_provider_(to_string_view(format_)) {}
+
+  prepared_format() = delete;
+
+  std::size_t formatted_size(const Args &... args) const {
+    const auto it = this->format_to(counting_iterator<char_type>(), args...);
+    return it.count();
+  }
+
+  template <typename OutputIt>
+  inline typename std::enable_if<internal::is_output_iterator<OutputIt>::value,
+                                 format_to_n_result<OutputIt>>::type
+  format_to_n(OutputIt out, unsigned n, const Args &... args) const {
+    format_arg_store<typename format_to_n_context<OutputIt, char_type>::type,
+                     Args...>
+        as(args...);
+
+    typedef truncating_iterator<OutputIt> trunc_it;
+    typedef output_range<trunc_it, char_type> range;
+    range r(trunc_it(out, n));
+    auto it = this->vformat_to(
+        r, typename format_to_n_args<OutputIt, char_type>::type(as));
+    return {it.base(), it.count()};
+  }
+
+  std::basic_string<char_type> format(const Args &... args) const {
+    basic_memory_buffer<char_type> buffer;
+    typedef back_insert_range<internal::basic_buffer<char_type>> range;
+    this->vformat_to(range(buffer), *checked_args(format_, args...));
+    return to_string(buffer);
+  }
+
+  template <typename Container>
+  inline typename std::enable_if<is_contiguous<Container>::value,
+                                 std::back_insert_iterator<Container>>::type
+  format_to(std::back_insert_iterator<Container> out,
+            const Args &... args) const {
+    internal::container_buffer<Container> buffer(internal::get_container(out));
+    typedef back_insert_range<internal::basic_buffer<char_type>> range;
+    this->vformat_to(range(buffer), *checked_args(format_, args...));
+    return out;
+  }
+
+  template <typename OutputIt>
+  inline OutputIt format_to(OutputIt out, const Args &... args) const {
+    typedef typename format_context_t<OutputIt, char_type>::type context;
+    typedef output_range<OutputIt, char_type> range;
+    format_arg_store<context, Args...> as(args...);
+    return this->vformat_to(range(out), basic_format_args<context>(as));
+  }
+
+  template <std::size_t SIZE = inline_buffer_size>
+  inline typename buffer_context<char_type>::type::iterator
+  format_to(basic_memory_buffer<char_type, SIZE> &buf,
+            const Args &... args) const {
+    typedef back_insert_range<internal::basic_buffer<char_type>> range;
+    return this->vformat_to(range(buf), *checked_args(format_, args...));
+  }
+
+private:
+  template <typename Range, typename Context>
+  typename Context::iterator vformat_to(Range out,
+                                        basic_format_args<Context> args) const {
+    const auto format_view = internal::to_string_view(format_);
+    Context ctx(out.begin(), format_view, args);
+
+    const auto &parts = parts_provider_.parts();
+    for (auto part_it = parts.begin(); part_it != parts.end(); ++part_it) {
+      const auto &part = *part_it;
+      const auto &value = part.val;
+
+      switch (part.which) {
+      case format_part_t::which_value::text: {
+        const auto text = value.text.to_view(format_view);
+        auto out = ctx.out();
+        auto &&it = internal::reserve(out, text.size());
+        it = std::copy_n(text.begin(), text.size(), it);
+        ctx.advance_to(out);
+      } break;
+
+      case format_part_t::which_value::argument_id: {
+        advance_parse_context_to_specification(ctx, part);
+        format_arg<Range>(ctx, value.arg_id);
+      } break;
+
+      case format_part_t::which_value::named_argument_id: {
+        advance_parse_context_to_specification(ctx, part);
+        const auto named_arg_id = value.named_arg_id.to_view(format_view);
+        format_arg<Range>(ctx, named_arg_id);
+      } break;
+      case format_part_t::which_value::specification: {
+        const auto &arg_id_value = value.spec.arg_id.val;
+        const auto arg =
+            value.spec.arg_id.which ==
+                    format_part_t::argument_id::which_arg_id::index
+                ? ctx.get_arg(arg_id_value.index)
+                : ctx.get_arg(arg_id_value.named_index.to_view(format_));
+
+        auto specs = value.spec.parsed_specs;
+
+        handle_dynamic_spec<internal::width_checker>(specs.width_,
+                                                     specs.width_ref, ctx);
+        handle_dynamic_spec<internal::precision_checker>(
+            specs.precision, specs.precision_ref, ctx);
+
+        internal::error_handler h;
+        parsed_specs_checker<internal::error_handler> checker(h, arg.type());
+        checker.check(specs);
+        advance_parse_context_to_specification(ctx, part);
+        ctx.advance_to(
+            visit_format_arg(arg_formatter<Range>(ctx, &specs), arg));
+      } break;
+      }
+    }
+
+    return ctx.out();
+  }
+
+  template <typename Context>
+  void advance_parse_context_to_specification(Context &ctx,
+                                              const format_part_t &part) const {
+    const auto view = to_string_view(format_);
+    const auto specification_begin = view.data() + part.end_of_argument_id;
+    ctx.parse_context().advance_to(specification_begin);
+  }
+
+  template <typename Range, typename Context, typename Id>
+  void format_arg(Context &ctx, Id arg_id) const {
+    ctx.parse_context().check_arg_id(arg_id);
+    const auto stopped_at =
+        visit_format_arg(arg_formatter<Range>(ctx), ctx.get_arg(arg_id));
+    ctx.advance_to(stopped_at);
+  }
+
+private:
+  Format format_;
+  PreparedPartsProvider parts_provider_;
+};
+
+template <typename Format> class compiletime_prepared_parts_type_provider {
+private:
+  typedef FMT_CHAR(Format) char_type;
+
+  class count_handler {
+  private:
+    typedef internal::null_terminating_iterator<char_type> iterator;
+
+  public:
+    FMT_CONSTEXPR count_handler() : counter_(0u) {}
+
+    FMT_CONSTEXPR void on_text(const char_type *begin, const char_type *end) {
+      if (begin != end) {
+        ++counter_;
+      }
+    }
+
+    FMT_CONSTEXPR void on_arg_id() { ++counter_; }
+    FMT_CONSTEXPR void on_arg_id(unsigned) { ++counter_; }
+    FMT_CONSTEXPR void on_arg_id(basic_string_view<char_type>) { ++counter_; }
+
+    FMT_CONSTEXPR void on_replacement_field(const char_type *) {}
+
+    FMT_CONSTEXPR const char_type *on_format_specs(const char_type *begin,
+                                                   const char_type *end) {
+      return find_matching_brace(begin, end);
+    }
+
+    FMT_CONSTEXPR void on_error(const char *) {}
+
+    FMT_CONSTEXPR unsigned result() const { return counter_; }
+
+  private:
+    FMT_CONSTEXPR const char_type *find_matching_brace(const char_type *begin,
+                                                       const char_type *end) {
+      FMT_CONSTEXPR_DECL const basic_string_view<char_type> text = Format{};
+      unsigned braces_counter{0u};
+      for (; begin != end; ++begin) {
+        if (*begin == '{') {
+          ++braces_counter;
+        } else if (*begin == '}') {
+          if (braces_counter == 0u) {
+            break;
+          }
+          --braces_counter;
+        }
+      }
+
+      return begin;
+    }
+
+  private:
+    unsigned counter_;
+  };
+
+  static FMT_CONSTEXPR unsigned count_parts() {
+    FMT_CONSTEXPR_DECL const auto text = to_string_view(Format{});
+    count_handler handler;
+    internal::parse_format_string</*IS_CONSTEXPR=*/true>(text, handler);
+    return handler.result();
+  }
+
+// Workaround for old compilers. Compiletime parts preparation will not be
+// performed with them anyway.
+#if FMT_USE_CONSTEXPR
+  static FMT_CONSTEXPR_DECL const unsigned number_of_format_parts =
+      compiletime_prepared_parts_type_provider::count_parts();
+#else
+  static const unsigned number_of_format_parts = 0u;
+#endif
+
+public:
+  template <unsigned N> struct format_parts_array {
+    typedef format_part<char_type> value_type;
+
+    FMT_CONSTEXPR format_parts_array() : arr{} {}
+
+    FMT_CONSTEXPR value_type &operator[](unsigned ind) { return arr[ind]; }
+
+    FMT_CONSTEXPR const value_type *begin() const { return arr; }
+
+    FMT_CONSTEXPR const value_type *end() const { return begin() + N; }
+
+  private:
+    value_type arr[N];
+  };
+
+  struct empty {
+    // Parts preparator will search for it
+    typedef format_part<char_type> value_type;
+  };
+
+  typedef typename std::conditional<static_cast<bool>(number_of_format_parts),
+                                    format_parts_array<number_of_format_parts>,
+                                    empty>::type type;
+};
+
+template <typename Parts> class compiletime_prepared_parts_collector {
+private:
+  typedef typename Parts::value_type format_part;
+
+public:
+  FMT_CONSTEXPR explicit compiletime_prepared_parts_collector(Parts &parts)
+      : parts_{parts}, counter_{0u} {}
+
+  FMT_CONSTEXPR void add(format_part part) { parts_[counter_++] = part; }
+
+  FMT_CONSTEXPR void substitute_last(format_part part) {
+    parts_[counter_ - 1] = part;
+  }
+
+  FMT_CONSTEXPR format_part last() { return parts_[counter_ - 1]; }
+
+private:
+  Parts &parts_;
+  unsigned counter_;
+};
+
+template <typename PartsContainer, typename Char>
+FMT_CONSTEXPR PartsContainer prepare_parts(basic_string_view<Char> format) {
+  PartsContainer parts;
+  internal::parse_format_string</*IS_CONSTEXPR=*/false>(
+      format, format_preparation_handler<Char, PartsContainer>(format, parts));
+  return parts;
+}
+
+template <typename PartsContainer, typename Char>
+FMT_CONSTEXPR PartsContainer
+prepare_compiletime_parts(basic_string_view<Char> format) {
+  typedef compiletime_prepared_parts_collector<PartsContainer> collector;
+
+  PartsContainer parts;
+  collector c(parts);
+  internal::parse_format_string</*IS_CONSTEXPR=*/true>(
+      format, format_preparation_handler<Char, collector>(format, c));
+  return parts;
+}
+
+template <typename PartsContainer> class runtime_parts_provider {
+public:
+  runtime_parts_provider() = delete;
+  template <typename Char>
+  runtime_parts_provider(basic_string_view<Char> format)
+      : parts_(prepare_parts<PartsContainer>(format)) {}
+
+  const PartsContainer &parts() const { return parts_; }
+
+private:
+  PartsContainer parts_;
+};
+
+template <typename Format, typename PartsContainer>
+struct compiletime_parts_provider {
+  compiletime_parts_provider() = delete;
+  template <typename Char>
+  FMT_CONSTEXPR compiletime_parts_provider(basic_string_view<Char>) {}
+
+  const PartsContainer &parts() const {
+    static FMT_CONSTEXPR_DECL const PartsContainer prepared_parts =
+        prepare_compiletime_parts<PartsContainer>(
+            internal::to_string_view(Format{}));
+
+    return prepared_parts;
+  }
+};
+
+template <typename PartsContainer>
+struct parts_container_concept_check : std::true_type {
+#if FMT_HAS_CONSTRUCTIBLE_TRAITS
+  static_assert(std::is_copy_constructible<PartsContainer>::value,
+                "PartsContainer is not copy constructible");
+  static_assert(std::is_move_constructible<PartsContainer>::value,
+                "PartsContainer is not move constructible");
+#endif
+
+  template <typename T, typename = void>
+  struct has_format_part_type : std::false_type {};
+  template <typename T>
+  struct has_format_part_type<
+      T, typename void_<typename T::format_part_type>::type> : std::true_type {
+  };
+
+  static_assert(has_format_part_type<PartsContainer>::value,
+                "PartsContainer doesn't provide format_part_type typedef");
+
+  struct check_second {};
+  struct check_first : check_second {};
+
+  template <typename T> static std::false_type has_add_check(check_second);
+  template <typename T>
+  static decltype(declval<T>().add(declval<typename T::format_part_type>()),
+                  std::true_type()) has_add_check(check_first);
+  typedef decltype(has_add_check<PartsContainer>(check_first())) has_add;
+  static_assert(has_add::value, "PartsContainer doesn't provide add() method");
+
+  template <typename T> static std::false_type has_last_check(check_second);
+  template <typename T>
+  static decltype(declval<T>().last(),
+                  std::true_type()) has_last_check(check_first);
+  typedef decltype(has_last_check<PartsContainer>(check_first())) has_last;
+  static_assert(has_last::value,
+                "PartsContainer doesn't provide last() method");
+
+  template <typename T>
+  static std::false_type has_substitute_last_check(check_second);
+  template <typename T>
+  static decltype(
+      declval<T>().substitute_last(declval<typename T::format_part_type>()),
+      std::true_type()) has_substitute_last_check(check_first);
+  typedef decltype(has_substitute_last_check<PartsContainer>(
+      check_first())) has_substitute_last;
+  static_assert(has_substitute_last::value,
+                "PartsContainer doesn't provide substitute_last() method");
+
+  template <typename T> static std::false_type has_begin_check(check_second);
+  template <typename T>
+  static decltype(declval<T>().begin(),
+                  std::true_type()) has_begin_check(check_first);
+  typedef decltype(has_begin_check<PartsContainer>(check_first())) has_begin;
+  static_assert(has_begin::value,
+                "PartsContainer doesn't provide begin() method");
+
+  template <typename T> static std::false_type has_end_check(check_second);
+  template <typename T>
+  static decltype(declval<T>().end(),
+                  std::true_type()) has_end_check(check_first);
+  typedef decltype(has_end_check<PartsContainer>(check_first())) has_end;
+  static_assert(has_end::value, "PartsContainer doesn't provide end() method");
+};
+
+template <bool IS_CONSTEXPR, typename Format, typename /*PartsContainer*/>
+struct parts_provider_type {
+  typedef compiletime_parts_provider<
+      Format, typename compiletime_prepared_parts_type_provider<Format>::type>
+      type;
+};
+
+template <typename Format, typename PartsContainer>
+struct parts_provider_type</*IS_CONSTEXPR=*/false, Format, PartsContainer> {
+  static_assert(parts_container_concept_check<PartsContainer>::value,
+                "Parts container doesn't meet the concept");
+  typedef runtime_parts_provider<PartsContainer> type;
+};
+
+template <typename Format, typename PreparedPartsContainer, typename... Args>
+struct basic_prepared_format {
+  typedef internal::prepared_format<Format,
+                                    typename internal::parts_provider_type<
+                                        is_compile_string<Format>::value,
+                                        Format, PreparedPartsContainer>::type,
+                                    Args...>
+      type;
+};
+
+template <typename Char>
+std::basic_string<Char> to_runtime_format(basic_string_view<Char> format) {
+  return std::basic_string<Char>(format.begin(), format.size());
+}
+
+template <typename Char>
+std::basic_string<Char> to_runtime_format(const Char *format) {
+  return std::basic_string<Char>(format);
+}
+
+template <typename Char, typename Container = std::vector<format_part<Char>>>
+class parts_container {
+public:
+  typedef format_part<Char> format_part_type;
+
+  void add(format_part_type part) { parts_.push_back(std::move(part)); }
+
+  void substitute_last(format_part_type part) {
+    parts_.back() = std::move(part);
+  }
+
+  format_part_type last() { return parts_.back(); }
+
+  auto begin() -> decltype(internal::declval<Container>().begin()) {
+    return parts_.begin();
+  }
+
+  auto begin() const -> decltype(internal::declval<const Container>().begin()) {
+    return parts_.begin();
+  }
+
+  auto end() -> decltype(internal::declval<Container>().end()) {
+    return parts_.end();
+  }
+
+  auto end() const -> decltype(internal::declval<const Container>().end()) {
+    return parts_.end();
+  }
+
+private:
+  Container parts_;
+};
+
+// Delegate preparing to preparator, to take advantage of a partial
+// specialization.
+template <typename Format, typename... Args> struct preparator {
+  typedef parts_container<FMT_CHAR(Format)> container;
+  typedef typename basic_prepared_format<Format, container, Args...>::type
+      prepared_format_type;
+
+  static auto prepare(Format format) -> prepared_format_type {
+    return prepared_format_type(std::move(format));
+  }
+};
+
+template <typename PassedFormat, typename PreparedFormatFormat,
+          typename PartsContainer, typename... Args>
+struct preparator<PassedFormat, prepared_format<PreparedFormatFormat,
+                                                PartsContainer, Args...>> {
+  typedef prepared_format<PreparedFormatFormat, PartsContainer, Args...>
+      prepared_format_type;
+
+  static auto prepare(PassedFormat format) -> prepared_format_type {
+    return prepared_format_type(std::move(format));
+  }
+};
+
+struct compiletime_format_tag {};
+struct runtime_format_tag {};
+
+template <typename Format> struct format_tag {
+  typedef typename std::conditional<is_compile_string<Format>::value,
+                                    compiletime_format_tag,
+                                    runtime_format_tag>::type type;
+};
+
+#if FMT_USE_CONSTEXPR
+template <typename Format, typename... Args>
+auto do_prepare(runtime_format_tag, Format format) {
+  return preparator<Format, Args...>::prepare(std::move(format));
+}
+
+template <typename Format, typename... Args>
+FMT_CONSTEXPR auto do_prepare(compiletime_format_tag, const Format &format) {
+  return typename basic_prepared_format<Format, void, Args...>::type(format);
+}
+#else
+template <typename Format, typename... Args>
+auto do_prepare(const Format &format)
+    -> decltype(preparator<Format, Args...>::prepare(format)) {
+  return preparator<Format, Args...>::prepare(format);
+}
+#endif
+} // namespace internal
+
+template <typename Char, typename Container = std::vector<format_part<Char>>>
+struct parts_container {
+  typedef internal::parts_container<Char, Container> type;
+};
+
+template <typename Format, typename PartsContainer, typename... Args>
+struct basic_prepared_format {
+  typedef typename internal::basic_prepared_format<Format, PartsContainer,
+                                                   Args...>::type type;
+};
+
+template <typename... Args> struct prepared_format {
+  typedef typename basic_prepared_format<
+      std::string, typename parts_container<char>::type, Args...>::type type;
+};
+
+template <typename... Args> struct wprepared_format {
+  typedef
+      typename basic_prepared_format<std::wstring,
+                                     typename parts_container<wchar_t>::type,
+                                     Args...>::type type;
+};
+
+#if FMT_USE_ALIAS_TEMPLATES
+
+template <typename Char, typename Container = std::vector<format_part<Char>>>
+using parts_container_t = typename parts_container<Char, Container>::type;
+
+template <typename Format, typename PreparedPartsContainer, typename... Args>
+using basic_prepared_format_t =
+    typename basic_prepared_format<Format, PreparedPartsContainer,
+                                   Args...>::type;
+
+template <typename... Args>
+using prepared_format_t =
+    basic_prepared_format_t<std::string, parts_container<char>, Args...>;
+
+template <typename... Args>
+using wprepared_format_t =
+    basic_prepared_format_t<std::wstring, parts_container<wchar_t>, Args...>;
+
+#endif
+
+#if FMT_USE_CONSTEXPR
+
+template <typename... Args, typename Format>
+FMT_CONSTEXPR auto prepare(Format format) {
+  return internal::do_prepare<Format, Args...>(
+      typename internal::format_tag<Format>::type{}, std::move(format));
+}
+#else
+
+template <typename... Args, typename Format>
+auto prepare(Format format) ->
+    typename internal::preparator<Format, Args...>::prepared_format_type {
+  return internal::preparator<Format, Args...>::prepare(std::move(format));
+}
+#endif
+
+template <typename... Args, typename Char>
+auto prepare(const Char *format) ->
+    typename internal::preparator<std::basic_string<Char>,
+                                  Args...>::prepared_format_type {
+  return prepare<Args...>(internal::to_runtime_format(format));
+}
+
+template <typename... Args, typename Char, unsigned N>
+auto prepare(const Char(format)[N]) ->
+    typename internal::preparator<std::basic_string<Char>,
+                                  Args...>::prepared_format_type {
+  const auto view = basic_string_view<Char>(format, N);
+  return prepare<Args...>(internal::to_runtime_format(view));
+}
+
+template <typename... Args, typename Char>
+auto prepare(basic_string_view<Char> format) ->
+    typename internal::preparator<std::basic_string<Char>,
+                                  Args...>::prepared_format_type {
+  return prepare<Args...>(internal::to_runtime_format(format));
+}
+
+FMT_END_NAMESPACE
+
+#endif // FMT_PREPARE_H_
diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
index 70e19db7..6cb6305d 100644
--- a/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
@@ -80,11 +80,16 @@ function(add_fmt_test name)
   if (FMT_PEDANTIC)
     target_compile_options(${name} PRIVATE ${PEDANTIC_COMPILE_FLAGS})
   endif ()
+  if (MSVC)
+    target_compile_options(${name} PRIVATE "/bigobj")
+  endif(MSVC)
+
   target_include_directories(${name} SYSTEM PUBLIC gtest gmock)
   add_test(NAME ${name} COMMAND ${name})
 endfunction()
 
 add_fmt_test(assert-test)
+add_fmt_test(common-format-test)
 add_fmt_test(chrono-test)
 add_fmt_test(core-test)
 add_fmt_test(gtest-extra-test)
@@ -94,6 +99,7 @@ if (NOT (MSVC AND BUILD_SHARED_LIBS))
 endif ()
 add_fmt_test(locale-test)
 add_fmt_test(ostream-test)
+add_fmt_test(prepare-test)
 add_fmt_test(printf-test)
 add_fmt_test(time-test)
 add_fmt_test(custom-formatter-test)
diff --git a/test/common-format-test.cc b/test/common-format-test.cc
new file mode 100644
index 00000000..d737085c
--- /dev/null
+++ b/test/common-format-test.cc
@@ -0,0 +1,1621 @@
+// Formatting library for C++ - formatting library tests
+//
+// Copyright (c) 2012 - present, Victor Zverovich
+// All rights reserved.
+//
+// For the license information refer to format.h.
+
+#include <cctype>
+#include <cfloat>
+#include <climits>
+#include <cmath>
+#include <cstring>
+#include <list>
+#include <memory>
+#include <stdint.h>
+#include <string>
+
+// Check if fmt/prepare.h compiles with windows.h included before it.
+#ifdef _WIN32
+#include <windows.h>
+#endif
+
+#include "fmt/prepare.h"
+#include "gmock.h"
+#include "gtest-extra.h"
+#include "util.h"
+
+#undef ERROR
+#undef min
+#undef max
+
+using fmt::format_error;
+using fmt::string_view;
+
+#define TEST_FMT_CHAR(S) typename fmt::internal::char_t<S>::type
+
+namespace {
+template <typename Format>
+static std::basic_string<TEST_FMT_CHAR(Format)>
+get_runtime_format(Format &&format_str) {
+  const auto format_view = fmt::internal::to_string_view(format_str);
+  return std::basic_string<TEST_FMT_CHAR(Format)>(format_view.begin(),
+                                                  format_view.size());
+}
+}
+
+// A wrapper that simply forwards format string as a compile string to
+// fmt::format*() functions.
+struct CompiletimeFormatFunctionWrapper {
+  template <typename Format, typename... Args>
+  static std::basic_string<TEST_FMT_CHAR(Format)>
+  format(const Format &format_str, const Args &... args) {
+    return fmt::format(format_str, args...);
+  }
+
+  template <typename S, typename... Args,
+            std::size_t SIZE = fmt::inline_buffer_size,
+            typename Char = typename fmt::internal::char_t<S>::type>
+  static inline typename fmt::buffer_context<Char>::type::iterator
+  format_to(fmt::basic_memory_buffer<Char, SIZE> &buf, const S &format_str,
+            const Args &... args) {
+    return fmt::format_to(buf, format_str, args...);
+  }
+
+  template <typename OutputIt, typename S, typename... Args>
+  static typename std::enable_if<
+      fmt::internal::is_string<S>::value &&
+          fmt::internal::is_output_iterator<OutputIt>::value,
+      OutputIt>::type
+  format_to(OutputIt out, const S &format_str, const Args &... args) {
+    return fmt::format_to(out, format_str, args...);
+  }
+
+  template <typename Container, typename S, typename... Args>
+  static typename std::enable_if<fmt::is_contiguous<Container>::value &&
+                                     fmt::internal::is_string<S>::value,
+                                 std::back_insert_iterator<Container>>::type
+  format_to(std::back_insert_iterator<Container> out, const S &format_str,
+            const Args &... args) {
+    return fmt::format_to(out, format_str, args...);
+  }
+
+  template <typename Out, typename Format, typename... Args>
+  static auto format_to_n(Out out, std::size_t n, Format &&format_str,
+                          const Args &... args)
+      -> fmt::format_to_n_result<Out> {
+    return fmt::format_to_n(std::forward<Out>(out), n, format_str, args...);
+  }
+
+  template <typename Format, typename... Args>
+  static std::size_t formatted_size(const Format &format_str,
+                                    const Args &... args) {
+    return fmt::formatted_size(format_str, args...);
+  }
+};
+
+// A wrapper that converts the format string from a compile string to a
+// std::basic_string and passes it to fmt::format*() functions.
+struct RuntimeFormatFunctionWrapper {
+  template <typename Format, typename... Args>
+  static std::basic_string<TEST_FMT_CHAR(Format)>
+  format(const Format &format_str, const Args &... args) {
+    return fmt::format(get_runtime_format(format_str), args...);
+  }
+
+  template <typename S, typename... Args,
+            std::size_t SIZE = fmt::inline_buffer_size,
+            typename Char = typename fmt::internal::char_t<S>::type>
+  static inline typename fmt::buffer_context<Char>::type::iterator
+  format_to(fmt::basic_memory_buffer<Char, SIZE> &buf, const S &format_str,
+            const Args &... args) {
+    return fmt::format_to(buf, get_runtime_format(format_str), args...);
+  }
+
+  template <typename OutputIt, typename S, typename... Args>
+  static typename std::enable_if<
+      fmt::internal::is_string<S>::value &&
+          fmt::internal::is_output_iterator<OutputIt>::value,
+      OutputIt>::type
+  format_to(OutputIt out, const S &format_str, const Args &... args) {
+    return fmt::format_to(out, get_runtime_format(format_str), args...);
+  }
+
+  template <typename Container, typename S, typename... Args>
+  static typename std::enable_if<fmt::is_contiguous<Container>::value &&
+                                     fmt::internal::is_string<S>::value,
+                                 std::back_insert_iterator<Container>>::type
+  format_to(std::back_insert_iterator<Container> out, const S &format_str,
+            const Args &... args) {
+    return fmt::format_to(out, get_runtime_format(format_str), args...);
+  }
+
+  template <typename Out, typename Format, typename... Args>
+  static auto format_to_n(Out out, std::size_t n, Format &&format_str,
+                          const Args &... args)
+      -> fmt::format_to_n_result<Out> {
+    return fmt::format_to_n(std::forward<Out>(out), n,
+                            get_runtime_format(format_str), args...);
+  }
+
+  template <typename Format, typename... Args>
+  static std::size_t formatted_size(const Format &format_str,
+                                    const Args &... args) {
+    return fmt::formatted_size(get_runtime_format(format_str), args...);
+  }
+};
+
+// A wrapper that converts the format string from a compile string to a
+// std::basic_string and passes it to fmt::prepare() function.
+class RuntimePreparedFormatWrapper {
+public:
+  template <typename Format, typename... Args>
+  static std::basic_string<TEST_FMT_CHAR(Format)>
+  format(const Format &format_str, const Args &... args) {
+    auto formatter = fmt::prepare<Args...>(get_runtime_format(format_str));
+    return formatter.format(args...);
+  }
+
+  template <typename S, typename... Args,
+            std::size_t SIZE = fmt::inline_buffer_size,
+            typename Char = typename fmt::internal::char_t<S>::type>
+  static typename fmt::buffer_context<Char>::type::iterator
+  format_to(fmt::basic_memory_buffer<Char, SIZE> &buf, const S &format_str,
+            const Args &... args) {
+    auto formatter = fmt::prepare<Args...>(get_runtime_format(format_str));
+    return formatter.format_to(buf, args...);
+  }
+
+  template <typename OutputIt, typename S, typename... Args>
+  static typename std::enable_if<
+      fmt::internal::is_string<S>::value &&
+          fmt::internal::is_output_iterator<OutputIt>::value,
+      OutputIt>::type
+  format_to(OutputIt out, const S &format_str, const Args &... args) {
+    auto formatter = fmt::prepare<Args...>(get_runtime_format(format_str));
+    return formatter.format_to(out, args...);
+  }
+
+  template <typename Container, typename S, typename... Args>
+  static typename std::enable_if<fmt::is_contiguous<Container>::value &&
+                                     fmt::internal::is_string<S>::value,
+                                 std::back_insert_iterator<Container>>::type
+  format_to(std::back_insert_iterator<Container> out, const S &format_str,
+            const Args &... args) {
+    auto formatter = fmt::prepare<Args...>(get_runtime_format(format_str));
+    return formatter.format_to(out, args...);
+  }
+
+  template <typename Out, typename Format, typename... Args>
+  static auto format_to_n(Out out, std::size_t n, const Format &format_str,
+                          const Args &... args)
+      -> fmt::format_to_n_result<Out> {
+    auto formatter = fmt::prepare<Args...>(get_runtime_format(format_str));
+    return formatter.format_to_n(std::forward<Out>(out),
+                                 static_cast<unsigned>(n), args...);
+  }
+
+  template <typename Format, typename... Args>
+  static std::size_t formatted_size(const Format &format_str,
+                                    const Args &... args) {
+    auto formatter = fmt::prepare<Args...>(get_runtime_format(format_str));
+    return formatter.formatted_size(args...);
+  }
+};
+
+// A wrapper that simply forwards format string as a compile string to
+// fmt::prepare() function.
+struct CompiletimePreparedFormatWrapper {
+  template <typename Format, typename... Args>
+  static std::basic_string<TEST_FMT_CHAR(Format)>
+  format(const Format &format_str, const Args &... args) {
+    auto formatter = fmt::prepare<Args...>(format_str);
+    return formatter.format(args...);
+  }
+
+  template <typename S, typename... Args,
+            std::size_t SIZE = fmt::inline_buffer_size,
+            typename Char = typename fmt::internal::char_t<S>::type>
+  static typename fmt::buffer_context<Char>::type::iterator
+  format_to(fmt::basic_memory_buffer<Char, SIZE> &buf, const S &format_str,
+            const Args &... args) {
+    auto formatter = fmt::prepare<Args...>(format_str);
+    return formatter.format_to(buf, args...);
+  }
+
+  template <typename OutputIt, typename S, typename... Args>
+  static typename std::enable_if<
+      fmt::internal::is_string<S>::value &&
+          fmt::internal::is_output_iterator<OutputIt>::value,
+      OutputIt>::type
+  format_to(OutputIt out, const S &format_str, const Args &... args) {
+    auto formatter = fmt::prepare<Args...>(format_str);
+    return formatter.format_to(out, args...);
+  }
+
+  template <typename Container, typename S, typename... Args>
+  static typename std::enable_if<fmt::is_contiguous<Container>::value &&
+                                     fmt::internal::is_string<S>::value,
+                                 std::back_insert_iterator<Container>>::type
+  format_to(std::back_insert_iterator<Container> out, const S &format_str,
+            const Args &... args) {
+    auto formatter = fmt::prepare<Args...>(format_str);
+    return formatter.format_to(out, args...);
+  }
+
+  template <typename Format, typename... Args>
+  static std::size_t formatted_size(const Format &format_str,
+                                    const Args &... args) {
+    auto formatter = fmt::prepare<Args...>(format_str);
+    return formatter.formatted_size(args...);
+  }
+
+  template <typename Out, typename Format, typename... Args>
+  static auto format_to_n(Out out, std::size_t n, const Format &format_str,
+                          const Args &... args)
+      -> fmt::format_to_n_result<Out> {
+    auto formatter = fmt::prepare<Args...>(format_str);
+    return formatter.format_to_n(std::forward<Out>(out),
+                                 static_cast<unsigned>(n), args...);
+  }
+};
+
+#if FMT_USE_CONSTEXPR
+// We could make a typedef for it, but the GCC 4.4 has problem to compile a
+// TYPED_TEST_CASE with a typename: TYPED_TEST_CASE(Test, typename Foo::type)
+#define ALL_WRAPPERS                                                           \
+  ::testing::Types<CompiletimeFormatFunctionWrapper, \
+RuntimeFormatFunctionWrapper,                                                  \
+                   \
+RuntimePreparedFormatWrapper,                                                  \
+                   \
+CompiletimePreparedFormatWrapper>
+
+#define FMT(s) FMT_STRING(s)
+
+#else
+#define ALL_WRAPPERS                                                           \
+  ::testing::Types<RuntimeFormatFunctionWrapper, \
+RuntimePreparedFormatWrapper>
+
+#define FMT(s) s
+#endif
+
+#define RUNTIME_WRAPPERS                                                       \
+  ::testing::Types<RuntimeFormatFunctionWrapper, \
+RuntimePreparedFormatWrapper>
+
+#define FORMAT_FUNCTION_WRAPPERS                                               \
+  ::testing::Types<CompiletimeFormatFunctionWrapper,                           \
+                   RuntimeFormatFunctionWrapper>
+#define RUNTIME_FORMAT_FUNCTION_WRAPPERS                                       \
+  ::testing::Types<RuntimeFormatFunctionWrapper>
+
+template <typename T> class FormatToTest : public ::testing::Test {};
+TYPED_TEST_CASE(FormatToTest, ALL_WRAPPERS);
+
+template <typename T> class FormatterTest : public ::testing::Test {};
+TYPED_TEST_CASE(FormatterTest, ALL_WRAPPERS);
+
+template <typename T> class RuntimeFormattersTest : public ::testing::Test {};
+TYPED_TEST_CASE(RuntimeFormattersTest, RUNTIME_WRAPPERS);
+
+template <typename T> class FormatterThrowTest : public ::testing::Test {};
+TYPED_TEST_CASE(FormatterThrowTest, RUNTIME_WRAPPERS);
+
+template <typename T> class FormatFunctionTest : public ::testing::Test {};
+TYPED_TEST_CASE(FormatFunctionTest, FORMAT_FUNCTION_WRAPPERS);
+
+template <typename T>
+class RuntimeFormatFunctionTest : public ::testing::Test {};
+TYPED_TEST_CASE(RuntimeFormatFunctionTest, RUNTIME_FORMAT_FUNCTION_WRAPPERS);
+
+TYPED_TEST(FormatToTest, FormatWithoutArgs) {
+  std::string s;
+  TypeParam::format_to(std::back_inserter(s), FMT("test"));
+  EXPECT_EQ("test", s);
+}
+
+TYPED_TEST(FormatToTest, MultipleFormatToBackOfContainer) {
+  std::string s;
+  TypeParam::format_to(std::back_inserter(s), FMT("part{0}"), 1);
+  EXPECT_EQ("part1", s);
+  TypeParam::format_to(std::back_inserter(s), FMT("part{0}"), 2);
+  EXPECT_EQ("part1part2", s);
+}
+
+TYPED_TEST(FormatToTest, WideString) {
+  std::vector<wchar_t> buf;
+  TypeParam::format_to(std::back_inserter(buf), FMT(L"{}{}"), 42, L'\0');
+  EXPECT_STREQ(buf.data(), L"42");
+}
+
+TYPED_TEST(FormatToTest,
+           FormatToNonbackInsertIteratorWithSignAndNumericAlignment) {
+  char buffer[16] = {};
+  TypeParam::format_to(fmt::internal::make_checked(buffer, 16), FMT("{: =+}"),
+                       42.0);
+  EXPECT_STREQ("+42", buffer);
+}
+
+TYPED_TEST(FormatToTest, FormatToMemoryBuffer) {
+  fmt::basic_memory_buffer<char, 100> buffer;
+  TypeParam::format_to(buffer, FMT("{}"), "foo");
+  EXPECT_EQ("foo", to_string(buffer));
+  fmt::wmemory_buffer wbuffer;
+  TypeParam::format_to(wbuffer, FMT(L"{}"), L"foo");
+  EXPECT_EQ(L"foo", to_string(wbuffer));
+}
+
+TYPED_TEST(FormatterTest, Escape) {
+  EXPECT_EQ("{", TypeParam::format(FMT("{{")));
+  EXPECT_EQ("before {", TypeParam::format(FMT("before {{")));
+  EXPECT_EQ("{ after", TypeParam::format(FMT("{{ after")));
+  EXPECT_EQ("before { after", TypeParam::format(FMT("before {{ after")));
+
+  EXPECT_EQ("}", TypeParam::format(FMT("}}")));
+  EXPECT_EQ("before }", TypeParam::format(FMT("before }}")));
+  EXPECT_EQ("} after", TypeParam::format(FMT("}} after")));
+  EXPECT_EQ("before } after", TypeParam::format(FMT("before }} after")));
+
+  EXPECT_EQ("{}", TypeParam::format(FMT("{{}}")));
+  EXPECT_EQ("{42}", TypeParam::format(FMT("{{{0}}}"), 42));
+}
+
+TYPED_TEST(FormatterTest, NoArgs) {
+  EXPECT_EQ("test", TypeParam::format(FMT("test")));
+}
+
+TYPED_TEST(FormatterTest, ArgsInDifferentPositions) {
+  EXPECT_EQ("42", TypeParam::format(FMT("{0}"), 42));
+  EXPECT_EQ("before 42", TypeParam::format(FMT("before {0}"), 42));
+  EXPECT_EQ("42 after", TypeParam::format(FMT("{0} after"), 42));
+  EXPECT_EQ("before 42 after", TypeParam::format(FMT("before {0} after"), 42));
+  EXPECT_EQ("answer = 42", TypeParam::format(FMT("{0} = {1}"), "answer", 42));
+  EXPECT_EQ("42 is the answer",
+            TypeParam::format(FMT("{1} is the {0}"), "answer", 42));
+  EXPECT_EQ("abracadabra", TypeParam::format(FMT("{0}{1}{0}"), "abra", "cad"));
+}
+
+TYPED_TEST(FormatterThrowTest, UnmatchedBraces) {
+  EXPECT_THROW_MSG(TypeParam::format("{"), format_error,
+                   "invalid format string");
+  EXPECT_THROW_MSG(TypeParam::format("}"), format_error,
+                   "unmatched '}' in format string");
+  EXPECT_THROW_MSG(TypeParam::format("{0{}"), format_error,
+                   "invalid format string");
+}
+
+TYPED_TEST(FormatterThrowTest, ArgErrors) {
+  EXPECT_THROW_MSG(TypeParam::format("{"), format_error,
+                   "invalid format string");
+  EXPECT_THROW_MSG(TypeParam::format("{?}"), format_error,
+                   "invalid format string");
+  EXPECT_THROW_MSG(TypeParam::format("{0"), format_error,
+                   "invalid format string");
+  EXPECT_THROW_MSG(TypeParam::format("{0}"), format_error,
+                   "argument index out of range");
+
+  char format_str[BUFFER_SIZE];
+  safe_sprintf(format_str, "{%u", INT_MAX);
+  EXPECT_THROW_MSG(TypeParam::format(format_str), format_error,
+                   "invalid format string");
+  safe_sprintf(format_str, "{%u}", INT_MAX);
+  EXPECT_THROW_MSG(TypeParam::format(format_str), format_error,
+                   "argument index out of range");
+
+  safe_sprintf(format_str, "{%u", INT_MAX + 1u);
+  EXPECT_THROW_MSG(TypeParam::format(format_str), format_error,
+                   "number is too big");
+  safe_sprintf(format_str, "{%u}", INT_MAX + 1u);
+  EXPECT_THROW_MSG(TypeParam::format(format_str), format_error,
+                   "number is too big");
+}
+
+template <typename Wrapper, int N> struct TestFormat {
+  template <typename... Args>
+  static std::string format(fmt::string_view format_str, const Args &... args) {
+    return TestFormat<Wrapper, N - 1>::format(format_str, N - 1, args...);
+  }
+};
+
+template <typename Wrapper> struct TestFormat<Wrapper, 0> {
+  template <typename... Args>
+  static std::string format(fmt::string_view format_str, const Args &... args) {
+    return Wrapper::format(format_str, args...);
+  }
+};
+
+TYPED_TEST(FormatterTest, ManyArgs) {
+  typedef TestFormat<TypeParam, 20> test_format_20;
+  EXPECT_EQ("19", test_format_20::format(FMT("{19}")));
+}
+
+TYPED_TEST(FormatterThrowTest, ManyArgs) {
+  typedef TestFormat<TypeParam, 20> test_format_20;
+  EXPECT_THROW_MSG(test_format_20::format("{20}"), format_error,
+                   "argument index out of range");
+
+  typedef TestFormat<TypeParam, 21> test_format_21;
+  EXPECT_THROW_MSG(test_format_21::format("{21}"), format_error,
+                   "argument index out of range");
+  enum { max_packed_args = fmt::internal::max_packed_args };
+  std::string format_str = fmt::format("{{{}}}", max_packed_args + 1);
+  typedef TestFormat<TypeParam, max_packed_args> test_format_max;
+  EXPECT_THROW_MSG(test_format_max::format(format_str), format_error,
+                   "argument index out of range");
+}
+
+TYPED_TEST(FormatterThrowTest, NamedArg) {
+  EXPECT_THROW_MSG(TypeParam::format("{a}"), format_error,
+                   "argument not found");
+}
+
+TYPED_TEST(FormatterTest, NamedArg) {
+  EXPECT_EQ("1/a/A",
+            TypeParam::format(FMT("{_1}/{a_}/{A_}"), fmt::arg("a_", 'a'),
+                              fmt::arg("A_", "A"), fmt::arg("_1", 1)));
+  EXPECT_EQ(" -42",
+            TypeParam::format(FMT("{0:{width}}"), -42, fmt::arg("width", 4)));
+  EXPECT_EQ("st", TypeParam::format(FMT("{0:.{precision}}"), "str",
+                                    fmt::arg("precision", 2)));
+  EXPECT_EQ("1 2", TypeParam::format(FMT("{} {two}"), 1, fmt::arg("two", 2)));
+  EXPECT_EQ("42", TypeParam::format(
+                      FMT("{c}"), fmt::arg("a", 0), fmt::arg("b", 0),
+                      fmt::arg("c", 42), fmt::arg("d", 0), fmt::arg("e", 0),
+                      fmt::arg("f", 0), fmt::arg("g", 0), fmt::arg("h", 0),
+                      fmt::arg("i", 0), fmt::arg("j", 0), fmt::arg("k", 0),
+                      fmt::arg("l", 0), fmt::arg("m", 0), fmt::arg("n", 0),
+                      fmt::arg("o", 0), fmt::arg("p", 0)));
+}
+
+TYPED_TEST(FormatterTest, AutoArgIndex) {
+  EXPECT_EQ("abc", TypeParam::format(FMT("{}{}{}"), 'a', 'b', 'c'));
+  EXPECT_EQ("1.2", TypeParam::format(FMT("{:.{}}"), 1.2345, 2));
+}
+
+TYPED_TEST(FormatterThrowTest, AutoArgIndex) {
+  EXPECT_THROW_MSG(TypeParam::format("{0}{}", 'a', 'b'), format_error,
+                   "cannot switch from manual to automatic argument indexing");
+  EXPECT_THROW_MSG(TypeParam::format("{}{0}", 'a', 'b'), format_error,
+                   "cannot switch from automatic to manual argument indexing");
+  EXPECT_THROW_MSG(TypeParam::format("{0}:.{}", 1.2345, 2), format_error,
+                   "cannot switch from manual to automatic argument indexing");
+  EXPECT_THROW_MSG(TypeParam::format("{:.{0}}", 1.2345, 2), format_error,
+                   "cannot switch from automatic to manual argument indexing");
+  EXPECT_THROW_MSG(TypeParam::format("{}"), format_error,
+                   "argument index out of range");
+}
+
+TYPED_TEST(FormatterTest, EmptySpecs) {
+  EXPECT_EQ("42", TypeParam::format(FMT("{0:}"), 42));
+}
+
+TYPED_TEST(FormatterTest, LeftAlign) {
+  EXPECT_EQ("42  ", TypeParam::format(FMT("{0:<4}"), 42));
+  EXPECT_EQ("42  ", TypeParam::format(FMT("{0:<4o}"), 042));
+  EXPECT_EQ("42  ", TypeParam::format(FMT("{0:<4x}"), 0x42));
+  EXPECT_EQ("-42  ", TypeParam::format(FMT("{0:<5}"), -42));
+  EXPECT_EQ("42   ", TypeParam::format(FMT("{0:<5}"), 42u));
+  EXPECT_EQ("-42  ", TypeParam::format(FMT("{0:<5}"), -42l));
+  EXPECT_EQ("42   ", TypeParam::format(FMT("{0:<5}"), 42ul));
+  EXPECT_EQ("-42  ", TypeParam::format(FMT("{0:<5}"), -42ll));
+  EXPECT_EQ("42   ", TypeParam::format(FMT("{0:<5}"), 42ull));
+  EXPECT_EQ("-42  ", TypeParam::format(FMT("{0:<5}"), -42.0));
+  EXPECT_EQ("-42  ", TypeParam::format(FMT("{0:<5}"), -42.0l));
+  EXPECT_EQ("c    ", TypeParam::format(FMT("{0:<5}"), 'c'));
+  EXPECT_EQ("abc  ", TypeParam::format(FMT("{0:<5}"), "abc"));
+  EXPECT_EQ("0xface  ",
+            TypeParam::format(FMT("{0:<8}"), reinterpret_cast<void *>(0xface)));
+}
+
+TYPED_TEST(FormatterTest, RightAlign) {
+  EXPECT_EQ("  42", TypeParam::format(FMT("{0:>4}"), 42));
+  EXPECT_EQ("  42", TypeParam::format(FMT("{0:>4o}"), 042));
+  EXPECT_EQ("  42", TypeParam::format(FMT("{0:>4x}"), 0x42));
+  EXPECT_EQ("  -42", TypeParam::format(FMT("{0:>5}"), -42));
+  EXPECT_EQ("   42", TypeParam::format(FMT("{0:>5}"), 42u));
+  EXPECT_EQ("  -42", TypeParam::format(FMT("{0:>5}"), -42l));
+  EXPECT_EQ("   42", TypeParam::format(FMT("{0:>5}"), 42ul));
+  EXPECT_EQ("  -42", TypeParam::format(FMT("{0:>5}"), -42ll));
+  EXPECT_EQ("   42", TypeParam::format(FMT("{0:>5}"), 42ull));
+  EXPECT_EQ("  -42", TypeParam::format(FMT("{0:>5}"), -42.0));
+  EXPECT_EQ("  -42", TypeParam::format(FMT("{0:>5}"), -42.0l));
+  EXPECT_EQ("    c", TypeParam::format(FMT("{0:>5}"), 'c'));
+  EXPECT_EQ("  abc", TypeParam::format(FMT("{0:>5}"), "abc"));
+  EXPECT_EQ("  0xface",
+            TypeParam::format(FMT("{0:>8}"), reinterpret_cast<void *>(0xface)));
+}
+
+TYPED_TEST(FormatterTest, NumericAlign) {
+  EXPECT_EQ("  42", TypeParam::format(FMT("{0:=4}"), 42));
+  EXPECT_EQ("+ 42", TypeParam::format(FMT("{0:=+4}"), 42));
+  EXPECT_EQ("  42", TypeParam::format(FMT("{0:=4o}"), 042));
+  EXPECT_EQ("+ 42", TypeParam::format(FMT("{0:=+4o}"), 042));
+  EXPECT_EQ("  42", TypeParam::format(FMT("{0:=4x}"), 0x42));
+  EXPECT_EQ("+ 42", TypeParam::format(FMT("{0:=+4x}"), 0x42));
+  EXPECT_EQ("-  42", TypeParam::format(FMT("{0:=5}"), -42));
+  EXPECT_EQ("   42", TypeParam::format(FMT("{0:=5}"), 42u));
+  EXPECT_EQ("-  42", TypeParam::format(FMT("{0:=5}"), -42l));
+  EXPECT_EQ("   42", TypeParam::format(FMT("{0:=5}"), 42ul));
+  EXPECT_EQ("-  42", TypeParam::format(FMT("{0:=5}"), -42ll));
+  EXPECT_EQ("   42", TypeParam::format(FMT("{0:=5}"), 42ull));
+  EXPECT_EQ("-  42", TypeParam::format(FMT("{0:=5}"), -42.0));
+  EXPECT_EQ("-  42", TypeParam::format(FMT("{0:=5}"), -42.0l));
+  EXPECT_EQ(" 1", TypeParam::format(FMT("{:= }"), 1.0));
+}
+
+TYPED_TEST(FormatterThrowTest, NumericAlign) {
+  EXPECT_THROW_MSG(TypeParam::format("{0:=5", 'c'), format_error,
+                   "missing '}' in format string");
+  EXPECT_THROW_MSG(TypeParam::format("{0:=5}", 'c'), format_error,
+                   "invalid format specifier for char");
+  EXPECT_THROW_MSG(TypeParam::format("{0:=5}", "abc"), format_error,
+                   "format specifier requires numeric argument");
+  EXPECT_THROW_MSG(
+      TypeParam::format("{0:=8}", reinterpret_cast<void *>(0xface)),
+      format_error, "format specifier requires numeric argument");
+}
+
+TYPED_TEST(FormatterTest, CenterAlign) {
+  EXPECT_EQ(" 42  ", TypeParam::format(FMT("{0:^5}"), 42));
+  EXPECT_EQ(" 42  ", TypeParam::format(FMT("{0:^5o}"), 042));
+  EXPECT_EQ(" 42  ", TypeParam::format(FMT("{0:^5x}"), 0x42));
+  EXPECT_EQ(" -42 ", TypeParam::format(FMT("{0:^5}"), -42));
+  EXPECT_EQ(" 42  ", TypeParam::format(FMT("{0:^5}"), 42u));
+  EXPECT_EQ(" -42 ", TypeParam::format(FMT("{0:^5}"), -42l));
+  EXPECT_EQ(" 42  ", TypeParam::format(FMT("{0:^5}"), 42ul));
+  EXPECT_EQ(" -42 ", TypeParam::format(FMT("{0:^5}"), -42ll));
+  EXPECT_EQ(" 42  ", TypeParam::format(FMT("{0:^5}"), 42ull));
+  EXPECT_EQ(" -42  ", TypeParam::format(FMT("{0:^6}"), -42.0));
+  EXPECT_EQ(" -42 ", TypeParam::format(FMT("{0:^5}"), -42.0l));
+  EXPECT_EQ("  c  ", TypeParam::format(FMT("{0:^5}"), 'c'));
+  EXPECT_EQ(" abc  ", TypeParam::format(FMT("{0:^6}"), "abc"));
+  EXPECT_EQ(" 0xface ",
+            TypeParam::format(FMT("{0:^8}"), reinterpret_cast<void *>(0xface)));
+}
+
+TYPED_TEST(FormatterThrowTest, Fill) {
+  EXPECT_THROW_MSG(TypeParam::format("{0:{<5}", 'c'), format_error,
+                   "invalid fill character '{'");
+  EXPECT_THROW_MSG(TypeParam::format("{0:{<5}}", 'c'), format_error,
+                   "invalid fill character '{'");
+}
+
+TYPED_TEST(FormatterTest, Fill) {
+  EXPECT_EQ("**42", TypeParam::format(FMT("{0:*>4}"), 42));
+  EXPECT_EQ("**-42", TypeParam::format(FMT("{0:*>5}"), -42));
+  EXPECT_EQ("***42", TypeParam::format(FMT("{0:*>5}"), 42u));
+  EXPECT_EQ("**-42", TypeParam::format(FMT("{0:*>5}"), -42l));
+  EXPECT_EQ("***42", TypeParam::format(FMT("{0:*>5}"), 42ul));
+  EXPECT_EQ("**-42", TypeParam::format(FMT("{0:*>5}"), -42ll));
+  EXPECT_EQ("***42", TypeParam::format(FMT("{0:*>5}"), 42ull));
+  EXPECT_EQ("**-42", TypeParam::format(FMT("{0:*>5}"), -42.0));
+  EXPECT_EQ("**-42", TypeParam::format(FMT("{0:*>5}"), -42.0l));
+  EXPECT_EQ("c****", TypeParam::format(FMT("{0:*<5}"), 'c'));
+  EXPECT_EQ("abc**", TypeParam::format(FMT("{0:*<5}"), "abc"));
+  EXPECT_EQ("**0xface", TypeParam::format(FMT("{0:*>8}"),
+                                          reinterpret_cast<void *>(0xface)));
+  EXPECT_EQ("foo=", TypeParam::format(FMT("{:}="), "foo"));
+}
+
+TYPED_TEST(FormatterThrowTest, PlusSign) {
+  EXPECT_THROW_MSG(TypeParam::format("{0:+}", 42u), format_error,
+                   "format specifier requires signed argument");
+  EXPECT_THROW_MSG(TypeParam::format("{0:+}", 42ul), format_error,
+                   "format specifier requires signed argument");
+  EXPECT_THROW_MSG(TypeParam::format("{0:+}", 42ull), format_error,
+                   "format specifier requires signed argument");
+  EXPECT_THROW_MSG(TypeParam::format("{0:+", 'c'), format_error,
+                   "missing '}' in format string");
+  EXPECT_THROW_MSG(TypeParam::format("{0:+}", 'c'), format_error,
+                   "invalid format specifier for char");
+  EXPECT_THROW_MSG(TypeParam::format("{0:+}", "abc"), format_error,
+                   "format specifier requires numeric argument");
+  EXPECT_THROW_MSG(TypeParam::format("{0:+}", reinterpret_cast<void *>(0x42)),
+                   format_error, "format specifier requires numeric argument");
+}
+
+TYPED_TEST(FormatterTest, PlusSign) {
+  EXPECT_EQ("+42", TypeParam::format(FMT("{0:+}"), 42));
+  EXPECT_EQ("-42", TypeParam::format(FMT("{0:+}"), -42));
+  EXPECT_EQ("+42", TypeParam::format(FMT("{0:+}"), 42));
+  EXPECT_EQ("+42", TypeParam::format(FMT("{0:+}"), 42l));
+  EXPECT_EQ("+42", TypeParam::format(FMT("{0:+}"), 42ll));
+  EXPECT_EQ("+42", TypeParam::format(FMT("{0:+}"), 42.0));
+  EXPECT_EQ("+42", TypeParam::format(FMT("{0:+}"), 42.0l));
+}
+
+TYPED_TEST(FormatterThrowTest, MinusSign) {
+  EXPECT_THROW_MSG(TypeParam::format("{0:-}", 42u), format_error,
+                   "format specifier requires signed argument");
+  EXPECT_THROW_MSG(TypeParam::format("{0:-}", 42ul), format_error,
+                   "format specifier requires signed argument");
+  EXPECT_THROW_MSG(TypeParam::format("{0:-}", 42ull), format_error,
+                   "format specifier requires signed argument");
+  EXPECT_THROW_MSG(TypeParam::format("{0:-", 'c'), format_error,
+                   "missing '}' in format string");
+  EXPECT_THROW_MSG(TypeParam::format("{0:-}", 'c'), format_error,
+                   "invalid format specifier for char");
+  EXPECT_THROW_MSG(TypeParam::format("{0:-}", "abc"), format_error,
+                   "format specifier requires numeric argument");
+  EXPECT_THROW_MSG(TypeParam::format("{0:-}", reinterpret_cast<void *>(0x42)),
+                   format_error, "format specifier requires numeric argument");
+}
+
+TYPED_TEST(FormatterTest, MinusSign) {
+  EXPECT_EQ("42", TypeParam::format(FMT("{0:-}"), 42));
+  EXPECT_EQ("-42", TypeParam::format(FMT("{0:-}"), -42));
+  EXPECT_EQ("42", TypeParam::format(FMT("{0:-}"), 42));
+  EXPECT_EQ("42", TypeParam::format(FMT("{0:-}"), 42l));
+  EXPECT_EQ("42", TypeParam::format(FMT("{0:-}"), 42ll));
+  EXPECT_EQ("42", TypeParam::format(FMT("{0:-}"), 42.0));
+  EXPECT_EQ("42", TypeParam::format(FMT("{0:-}"), 42.0l));
+}
+
+TYPED_TEST(FormatterThrowTest, SpaceSign) {
+  EXPECT_THROW_MSG(TypeParam::format("{0: }", 42u), format_error,
+                   "format specifier requires signed argument");
+  EXPECT_THROW_MSG(TypeParam::format("{0: }", 42ul), format_error,
+                   "format specifier requires signed argument");
+  EXPECT_THROW_MSG(TypeParam::format("{0: }", 42ull), format_error,
+                   "format specifier requires signed argument");
+  EXPECT_THROW_MSG(TypeParam::format("{0: ", 'c'), format_error,
+                   "missing '}' in format string");
+  EXPECT_THROW_MSG(TypeParam::format("{0: }", 'c'), format_error,
+                   "invalid format specifier for char");
+  EXPECT_THROW_MSG(TypeParam::format("{0: }", "abc"), format_error,
+                   "format specifier requires numeric argument");
+  EXPECT_THROW_MSG(TypeParam::format("{0: }", reinterpret_cast<void *>(0x42)),
+                   format_error, "format specifier requires numeric argument");
+}
+
+TYPED_TEST(FormatterTest, SpaceSign) {
+  EXPECT_EQ(" 42", TypeParam::format(FMT("{0: }"), 42));
+  EXPECT_EQ("-42", TypeParam::format(FMT("{0: }"), -42));
+  EXPECT_EQ(" 42", TypeParam::format(FMT("{0: }"), 42));
+  EXPECT_EQ(" 42", TypeParam::format(FMT("{0: }"), 42l));
+  EXPECT_EQ(" 42", TypeParam::format(FMT("{0: }"), 42ll));
+  EXPECT_EQ(" 42", TypeParam::format(FMT("{0: }"), 42.0));
+  EXPECT_EQ(" 42", TypeParam::format(FMT("{0: }"), 42.0l));
+}
+
+TYPED_TEST(FormatterThrowTest, HashFlag) {
+  EXPECT_THROW_MSG(TypeParam::format("{0:#", 'c'), format_error,
+                   "missing '}' in format string");
+  EXPECT_THROW_MSG(TypeParam::format("{0:#}", 'c'), format_error,
+                   "invalid format specifier for char");
+  EXPECT_THROW_MSG(TypeParam::format("{0:#}", "abc"), format_error,
+                   "format specifier requires numeric argument");
+  EXPECT_THROW_MSG(TypeParam::format("{0:#}", reinterpret_cast<void *>(0x42)),
+                   format_error, "format specifier requires numeric argument");
+}
+
+TYPED_TEST(FormatterTest, HashFlag) {
+  EXPECT_EQ("42", TypeParam::format(FMT("{0:#}"), 42));
+  EXPECT_EQ("-42", TypeParam::format(FMT("{0:#}"), -42));
+  EXPECT_EQ("0b101010", TypeParam::format(FMT("{0:#b}"), 42));
+  EXPECT_EQ("0B101010", TypeParam::format(FMT("{0:#B}"), 42));
+  EXPECT_EQ("-0b101010", TypeParam::format(FMT("{0:#b}"), -42));
+  EXPECT_EQ("0x42", TypeParam::format(FMT("{0:#x}"), 0x42));
+  EXPECT_EQ("0X42", TypeParam::format(FMT("{0:#X}"), 0x42));
+  EXPECT_EQ("-0x42", TypeParam::format(FMT("{0:#x}"), -0x42));
+  EXPECT_EQ("042", TypeParam::format(FMT("{0:#o}"), 042));
+  EXPECT_EQ("-042", TypeParam::format(FMT("{0:#o}"), -042));
+  EXPECT_EQ("42", TypeParam::format(FMT("{0:#}"), 42u));
+  EXPECT_EQ("0x42", TypeParam::format(FMT("{0:#x}"), 0x42u));
+  EXPECT_EQ("042", TypeParam::format(FMT("{0:#o}"), 042u));
+
+  EXPECT_EQ("-42", TypeParam::format(FMT("{0:#}"), -42l));
+  EXPECT_EQ("0x42", TypeParam::format(FMT("{0:#x}"), 0x42l));
+  EXPECT_EQ("-0x42", TypeParam::format(FMT("{0:#x}"), -0x42l));
+  EXPECT_EQ("042", TypeParam::format(FMT("{0:#o}"), 042l));
+  EXPECT_EQ("-042", TypeParam::format(FMT("{0:#o}"), -042l));
+  EXPECT_EQ("42", TypeParam::format(FMT("{0:#}"), 42ul));
+  EXPECT_EQ("0x42", TypeParam::format(FMT("{0:#x}"), 0x42ul));
+  EXPECT_EQ("042", TypeParam::format(FMT("{0:#o}"), 042ul));
+
+  EXPECT_EQ("-42", TypeParam::format(FMT("{0:#}"), -42ll));
+  EXPECT_EQ("0x42", TypeParam::format(FMT("{0:#x}"), 0x42ll));
+  EXPECT_EQ("-0x42", TypeParam::format(FMT("{0:#x}"), -0x42ll));
+  EXPECT_EQ("042", TypeParam::format(FMT("{0:#o}"), 042ll));
+  EXPECT_EQ("-042", TypeParam::format(FMT("{0:#o}"), -042ll));
+  EXPECT_EQ("42", TypeParam::format(FMT("{0:#}"), 42ull));
+  EXPECT_EQ("0x42", TypeParam::format(FMT("{0:#x}"), 0x42ull));
+  EXPECT_EQ("042", TypeParam::format(FMT("{0:#o}"), 042ull));
+
+  if (FMT_USE_GRISU)
+    EXPECT_EQ("-42.0", TypeParam::format(FMT("{0:#}"), -42.0));
+  else
+    EXPECT_EQ("-42.0000", TypeParam::format(FMT("{0:#}"), -42.0));
+
+  EXPECT_EQ("-42.0000", TypeParam::format(FMT("{0:#}"), -42.0l));
+}
+
+TYPED_TEST(FormatterThrowTest, ZeroFlag) {
+  EXPECT_THROW_MSG(TypeParam::format("{0:0", 'c'), format_error,
+                   "missing '}' in format string");
+  EXPECT_THROW_MSG(TypeParam::format("{0:05}", 'c'), format_error,
+                   "invalid format specifier for char");
+  EXPECT_THROW_MSG(TypeParam::format("{0:05}", "abc"), format_error,
+                   "format specifier requires numeric argument");
+  EXPECT_THROW_MSG(TypeParam::format("{0:05}", reinterpret_cast<void *>(0x42)),
+                   format_error, "format specifier requires numeric argument");
+}
+
+TYPED_TEST(FormatterTest, ZeroFlag) {
+  EXPECT_EQ("42", TypeParam::format(FMT("{0:0}"), 42));
+  EXPECT_EQ("-0042", TypeParam::format(FMT("{0:05}"), -42));
+  EXPECT_EQ("00042", TypeParam::format(FMT("{0:05}"), 42u));
+  EXPECT_EQ("-0042", TypeParam::format(FMT("{0:05}"), -42l));
+  EXPECT_EQ("00042", TypeParam::format(FMT("{0:05}"), 42ul));
+  EXPECT_EQ("-0042", TypeParam::format(FMT("{0:05}"), -42ll));
+  EXPECT_EQ("00042", TypeParam::format(FMT("{0:05}"), 42ull));
+  EXPECT_EQ("-0042", TypeParam::format(FMT("{0:05}"), -42.0));
+  EXPECT_EQ("-0042", TypeParam::format(FMT("{0:05}"), -42.0l));
+}
+
+TYPED_TEST(FormatterThrowTest, Width) {
+  char format_str[BUFFER_SIZE];
+  safe_sprintf(format_str, "{0:%u", UINT_MAX);
+  increment(format_str + 3);
+  EXPECT_THROW_MSG(TypeParam::format(format_str, 0), format_error,
+                   "number is too big");
+  std::size_t size = std::strlen(format_str);
+  format_str[size] = '}';
+  format_str[size + 1] = 0;
+  EXPECT_THROW_MSG(TypeParam::format(format_str, 0), format_error,
+                   "number is too big");
+
+  safe_sprintf(format_str, "{0:%u", INT_MAX + 1u);
+  EXPECT_THROW_MSG(TypeParam::format(format_str, 0), format_error,
+                   "number is too big");
+  safe_sprintf(format_str, "{0:%u}", INT_MAX + 1u);
+  EXPECT_THROW_MSG(TypeParam::format(format_str, 0), format_error,
+                   "number is too big");
+}
+
+TYPED_TEST(FormatterTest, Width) {
+  EXPECT_EQ(" -42", TypeParam::format(FMT("{0:4}"), -42));
+  EXPECT_EQ("   42", TypeParam::format(FMT("{0:5}"), 42u));
+  EXPECT_EQ("   -42", TypeParam::format(FMT("{0:6}"), -42l));
+  EXPECT_EQ("     42", TypeParam::format(FMT("{0:7}"), 42ul));
+  EXPECT_EQ("   -42", TypeParam::format(FMT("{0:6}"), -42ll));
+  EXPECT_EQ("     42", TypeParam::format(FMT("{0:7}"), 42ull));
+  EXPECT_EQ("   -1.23", TypeParam::format(FMT("{0:8}"), -1.23));
+  EXPECT_EQ("    -1.23", TypeParam::format(FMT("{0:9}"), -1.23l));
+  EXPECT_EQ("    0xcafe",
+            TypeParam::format(FMT("{0:10}"), reinterpret_cast<void *>(0xcafe)));
+  EXPECT_EQ("x          ", TypeParam::format(FMT("{0:11}"), 'x'));
+  EXPECT_EQ("str         ", TypeParam::format(FMT("{0:12}"), "str"));
+}
+
+TYPED_TEST(FormatterThrowTest, RuntimeWidth) {
+  char format_str[BUFFER_SIZE];
+  safe_sprintf(format_str, "{0:{%u", UINT_MAX);
+  increment(format_str + 4);
+  EXPECT_THROW_MSG(TypeParam::format(format_str, 0), format_error,
+                   "number is too big");
+  std::size_t size = std::strlen(format_str);
+  format_str[size] = '}';
+  format_str[size + 1] = 0;
+  EXPECT_THROW_MSG(TypeParam::format(format_str, 0), format_error,
+                   "number is too big");
+  format_str[size + 1] = '}';
+  format_str[size + 2] = 0;
+  EXPECT_THROW_MSG(TypeParam::format(format_str, 0), format_error,
+                   "number is too big");
+
+  EXPECT_THROW_MSG(TypeParam::format("{0:{", 0), format_error,
+                   "invalid format string");
+  EXPECT_THROW_MSG(TypeParam::format("{0:{}", 0), format_error,
+                   "cannot switch from manual to automatic argument indexing");
+  EXPECT_THROW_MSG(TypeParam::format("{0:{?}}", 0), format_error,
+                   "invalid format string");
+  EXPECT_THROW_MSG(TypeParam::format("{0:{1}}", 0), format_error,
+                   "argument index out of range");
+
+  EXPECT_THROW_MSG(TypeParam::format("{0:{0:}}", 0), format_error,
+                   "invalid format string");
+
+  EXPECT_THROW_MSG(TypeParam::format("{0:{1}}", 0, -1), format_error,
+                   "negative width");
+  EXPECT_THROW_MSG(TypeParam::format("{0:{1}}", 0, (INT_MAX + 1u)),
+                   format_error, "number is too big");
+  EXPECT_THROW_MSG(TypeParam::format("{0:{1}}", 0, -1l), format_error,
+                   "negative width");
+  if (fmt::internal::const_check(sizeof(long) > sizeof(int))) {
+    long value = INT_MAX;
+    EXPECT_THROW_MSG(TypeParam::format("{0:{1}}", 0, (value + 1)), format_error,
+                     "number is too big");
+  }
+  EXPECT_THROW_MSG(TypeParam::format("{0:{1}}", 0, (INT_MAX + 1ul)),
+                   format_error, "number is too big");
+
+  EXPECT_THROW_MSG(TypeParam::format("{0:{1}}", 0, '0'), format_error,
+                   "width is not integer");
+  EXPECT_THROW_MSG(TypeParam::format("{0:{1}}", 0, 0.0), format_error,
+                   "width is not integer");
+}
+
+TYPED_TEST(FormatterTest, RuntimeWidth) {
+  EXPECT_EQ(" -42", TypeParam::format(FMT("{0:{1}}"), -42, 4));
+  EXPECT_EQ("   42", TypeParam::format(FMT("{0:{1}}"), 42u, 5));
+  EXPECT_EQ("   -42", TypeParam::format(FMT("{0:{1}}"), -42l, 6));
+  EXPECT_EQ("     42", TypeParam::format(FMT("{0:{1}}"), 42ul, 7));
+  EXPECT_EQ("   -42", TypeParam::format(FMT("{0:{1}}"), -42ll, 6));
+  EXPECT_EQ("     42", TypeParam::format(FMT("{0:{1}}"), 42ull, 7));
+  EXPECT_EQ("   -1.23", TypeParam::format(FMT("{0:{1}}"), -1.23, 8));
+  EXPECT_EQ("    -1.23", TypeParam::format(FMT("{0:{1}}"), -1.23l, 9));
+  EXPECT_EQ(
+      "    0xcafe",
+      TypeParam::format(FMT("{0:{1}}"), reinterpret_cast<void *>(0xcafe), 10));
+  EXPECT_EQ("x          ", TypeParam::format(FMT("{0:{1}}"), 'x', 11));
+  EXPECT_EQ("str         ", TypeParam::format(FMT("{0:{1}}"), "str", 12));
+}
+
+// These two tests need to be separated. They throw exceptions with different
+// messages.
+// prepare(..) throws at preparation time, when arguments are not known, thus it
+// cannot know if precision is allowed for given argument type
+TEST(PreparedFormatterTest, PrecisionMissingBraceInFormatString) {
+  EXPECT_THROW_MSG(fmt::prepare<int>("{0:.2"), format_error,
+                   "missing '}' in format string");
+}
+
+TEST(FormatterTest, PrecisionNotAllowedArgumentTypeInMalformedFormat) {
+  EXPECT_THROW_MSG(fmt::format("{0:.2", 0), format_error,
+                   "precision not allowed for this argument type");
+}
+
+TYPED_TEST(FormatterThrowTest, Precision) {
+  char format_str[BUFFER_SIZE];
+  safe_sprintf(format_str, "{0:.%u", UINT_MAX);
+  increment(format_str + 4);
+  EXPECT_THROW_MSG(TypeParam::format(format_str, 0), format_error,
+                   "number is too big");
+  std::size_t size = std::strlen(format_str);
+  format_str[size] = '}';
+  format_str[size + 1] = 0;
+  EXPECT_THROW_MSG(TypeParam::format(format_str, 0), format_error,
+                   "number is too big");
+
+  safe_sprintf(format_str, "{0:.%u", INT_MAX + 1u);
+  EXPECT_THROW_MSG(TypeParam::format(format_str, 0), format_error,
+                   "number is too big");
+  safe_sprintf(format_str, "{0:.%u}", INT_MAX + 1u);
+  EXPECT_THROW_MSG(TypeParam::format(format_str, 0), format_error,
+                   "number is too big");
+
+  EXPECT_THROW_MSG(TypeParam::format("{0:.", 0), format_error,
+                   "missing precision specifier");
+  EXPECT_THROW_MSG(TypeParam::format("{0:.}", 0), format_error,
+                   "missing precision specifier");
+
+  EXPECT_THROW_MSG(TypeParam::format("{0:.2}", 42), format_error,
+                   "precision not allowed for this argument type");
+  EXPECT_THROW_MSG(TypeParam::format("{0:.2f}", 42), format_error,
+                   "precision not allowed for this argument type");
+  EXPECT_THROW_MSG(TypeParam::format("{0:.2}", 42u), format_error,
+                   "precision not allowed for this argument type");
+  EXPECT_THROW_MSG(TypeParam::format("{0:.2f}", 42u), format_error,
+                   "precision not allowed for this argument type");
+  EXPECT_THROW_MSG(TypeParam::format("{0:.2}", 42l), format_error,
+                   "precision not allowed for this argument type");
+  EXPECT_THROW_MSG(TypeParam::format("{0:.2f}", 42l), format_error,
+                   "precision not allowed for this argument type");
+  EXPECT_THROW_MSG(TypeParam::format("{0:.2}", 42ul), format_error,
+                   "precision not allowed for this argument type");
+  EXPECT_THROW_MSG(TypeParam::format("{0:.2f}", 42ul), format_error,
+                   "precision not allowed for this argument type");
+  EXPECT_THROW_MSG(TypeParam::format("{0:.2}", 42ll), format_error,
+                   "precision not allowed for this argument type");
+  EXPECT_THROW_MSG(TypeParam::format("{0:.2f}", 42ll), format_error,
+                   "precision not allowed for this argument type");
+  EXPECT_THROW_MSG(TypeParam::format("{0:.2}", 42ull), format_error,
+                   "precision not allowed for this argument type");
+  EXPECT_THROW_MSG(TypeParam::format("{0:.2f}", 42ull), format_error,
+                   "precision not allowed for this argument type");
+  EXPECT_THROW_MSG(TypeParam::format("{0:3.0}", 'x'), format_error,
+                   "precision not allowed for this argument type");
+
+  EXPECT_THROW_MSG(
+      TypeParam::format("{0:.2}", reinterpret_cast<void *>(0xcafe)),
+      format_error, "precision not allowed for this argument type");
+  EXPECT_THROW_MSG(
+      TypeParam::format("{0:.2f}", reinterpret_cast<void *>(0xcafe)),
+      format_error, "precision not allowed for this argument type");
+}
+
+TYPED_TEST(FormatterTest, Precision) {
+  EXPECT_EQ("1.2", TypeParam::format(FMT("{0:.2}"), 1.2345));
+  EXPECT_EQ("1.2", TypeParam::format(FMT("{0:.2}"), 1.2345l));
+  EXPECT_EQ("st", TypeParam::format(FMT("{0:.2}"), "str"));
+}
+
+// These two tests need to be separated. They throw exceptions with different
+// messages.
+// prepare(..) throws at preparation time, when arguments are not known, thus it
+// cannot know if precision is allowed for given argument type
+TEST(PreparedFormatterTest, RuntimePrecisionMissingBraceInFormatString) {
+  EXPECT_THROW_MSG(fmt::prepare<int>("{0:.{1}"), format_error,
+                   "missing '}' in format string");
+}
+
+TEST(FormatterTest, RuntimePrecisionNotAllowedArgumentTypeInMalformedFormat) {
+  EXPECT_THROW_MSG(fmt::format("{0:.{1}", 0, 0), format_error,
+                   "precision not allowed for this argument type");
+}
+
+TYPED_TEST(FormatterThrowTest, RuntimePrecision) {
+  char format_str[BUFFER_SIZE];
+  safe_sprintf(format_str, "{0:.{%u", UINT_MAX);
+  increment(format_str + 5);
+  EXPECT_THROW_MSG(TypeParam::format(format_str, 0), format_error,
+                   "number is too big");
+  std::size_t size = std::strlen(format_str);
+  format_str[size] = '}';
+  format_str[size + 1] = 0;
+  EXPECT_THROW_MSG(TypeParam::format(format_str, 0), format_error,
+                   "number is too big");
+  format_str[size + 1] = '}';
+  format_str[size + 2] = 0;
+  EXPECT_THROW_MSG(TypeParam::format(format_str, 0), format_error,
+                   "number is too big");
+
+  EXPECT_THROW_MSG(TypeParam::format("{0:.{", 0), format_error,
+                   "invalid format string");
+  EXPECT_THROW_MSG(TypeParam::format("{0:.{}", 0), format_error,
+                   "cannot switch from manual to automatic argument indexing");
+  EXPECT_THROW_MSG(TypeParam::format("{0:.{?}}", 0), format_error,
+                   "invalid format string");
+  EXPECT_THROW_MSG(TypeParam::format("{0:.{1}}", 0), format_error,
+                   "argument index out of range");
+
+  EXPECT_THROW_MSG(TypeParam::format("{0:.{0:}}", 0), format_error,
+                   "invalid format string");
+
+  EXPECT_THROW_MSG(TypeParam::format("{0:.{1}}", 0, -1), format_error,
+                   "negative precision");
+  EXPECT_THROW_MSG(TypeParam::format("{0:.{1}}", 0, (INT_MAX + 1u)),
+                   format_error, "number is too big");
+  EXPECT_THROW_MSG(TypeParam::format("{0:.{1}}", 0, -1l), format_error,
+                   "negative precision");
+  if (fmt::internal::const_check(sizeof(long) > sizeof(int))) {
+    long value = INT_MAX;
+    EXPECT_THROW_MSG(TypeParam::format("{0:.{1}}", 0, (value + 1)),
+                     format_error, "number is too big");
+  }
+  EXPECT_THROW_MSG(TypeParam::format("{0:.{1}}", 0, (INT_MAX + 1ul)),
+                   format_error, "number is too big");
+
+  EXPECT_THROW_MSG(TypeParam::format("{0:.{1}}", 0, '0'), format_error,
+                   "precision is not integer");
+  EXPECT_THROW_MSG(TypeParam::format("{0:.{1}}", 0, 0.0), format_error,
+                   "precision is not integer");
+
+  EXPECT_THROW_MSG(TypeParam::format("{0:.{1}}", 42, 2), format_error,
+                   "precision not allowed for this argument type");
+  EXPECT_THROW_MSG(TypeParam::format("{0:.{1}f}", 42, 2), format_error,
+                   "precision not allowed for this argument type");
+  EXPECT_THROW_MSG(TypeParam::format("{0:.{1}}", 42u, 2), format_error,
+                   "precision not allowed for this argument type");
+  EXPECT_THROW_MSG(TypeParam::format("{0:.{1}f}", 42u, 2), format_error,
+                   "precision not allowed for this argument type");
+  EXPECT_THROW_MSG(TypeParam::format("{0:.{1}}", 42l, 2), format_error,
+                   "precision not allowed for this argument type");
+  EXPECT_THROW_MSG(TypeParam::format("{0:.{1}f}", 42l, 2), format_error,
+                   "precision not allowed for this argument type");
+  EXPECT_THROW_MSG(TypeParam::format("{0:.{1}}", 42ul, 2), format_error,
+                   "precision not allowed for this argument type");
+  EXPECT_THROW_MSG(TypeParam::format("{0:.{1}f}", 42ul, 2), format_error,
+                   "precision not allowed for this argument type");
+  EXPECT_THROW_MSG(TypeParam::format("{0:.{1}}", 42ll, 2), format_error,
+                   "precision not allowed for this argument type");
+  EXPECT_THROW_MSG(TypeParam::format("{0:.{1}f}", 42ll, 2), format_error,
+                   "precision not allowed for this argument type");
+  EXPECT_THROW_MSG(TypeParam::format("{0:.{1}}", 42ull, 2), format_error,
+                   "precision not allowed for this argument type");
+  EXPECT_THROW_MSG(TypeParam::format("{0:.{1}f}", 42ull, 2), format_error,
+                   "precision not allowed for this argument type");
+  EXPECT_THROW_MSG(TypeParam::format("{0:3.{1}}", 'x', 0), format_error,
+                   "precision not allowed for this argument type");
+
+  EXPECT_THROW_MSG(
+      TypeParam::format("{0:.{1}}", reinterpret_cast<void *>(0xcafe), 2),
+      format_error, "precision not allowed for this argument type");
+  EXPECT_THROW_MSG(
+      TypeParam::format("{0:.{1}f}", reinterpret_cast<void *>(0xcafe), 2),
+      format_error, "precision not allowed for this argument type");
+}
+
+TYPED_TEST(FormatterTest, RuntimePrecision) {
+  EXPECT_EQ("1.2", TypeParam::format(FMT("{0:.{1}}"), 1.2345, 2));
+  EXPECT_EQ("1.2", TypeParam::format(FMT("{1:.{0}}"), 2, 1.2345l));
+  EXPECT_EQ("st", TypeParam::format(FMT("{0:.{1}}"), "str", 2));
+}
+
+TYPED_TEST(FormatterTest, FormatBool) {
+  EXPECT_EQ("true", TypeParam::format(FMT("{}"), true));
+  EXPECT_EQ("false", TypeParam::format(FMT("{}"), false));
+  EXPECT_EQ("1", TypeParam::format(FMT("{:d}"), true));
+  EXPECT_EQ("true ", TypeParam::format(FMT("{:5}"), true));
+  EXPECT_EQ(L"true", TypeParam::format(FMT(L"{}"), true));
+}
+
+TYPED_TEST(FormatterTest, FormatShort) {
+  short s = 42;
+  EXPECT_EQ("42", TypeParam::format(FMT("{0:d}"), s));
+  unsigned short us = 42;
+  EXPECT_EQ("42", TypeParam::format(FMT("{0:d}"), us));
+}
+
+template <typename FormatWrapper, typename T>
+void check_unknown_types(const T &value, const char *types, const char *) {
+  char format_str[BUFFER_SIZE];
+  const char *special = ".0123456789}";
+  for (int i = CHAR_MIN; i <= CHAR_MAX; ++i) {
+    char c = static_cast<char>(i);
+    if (std::strchr(types, c) || std::strchr(special, c) || !c)
+      continue;
+    safe_sprintf(format_str, "{0:10%c}", c);
+    const char *message = "invalid type specifier";
+    EXPECT_THROW_MSG(FormatWrapper::format(format_str, value), format_error,
+                     message)
+        << format_str << " " << message;
+  }
+}
+
+TYPED_TEST(FormatterThrowTest, FormatInt) {
+  EXPECT_THROW_MSG(TypeParam::format("{0:v", 42), format_error,
+                   "missing '}' in format string");
+  check_unknown_types<TypeParam>(42, "bBdoxXn", "integer");
+}
+
+TYPED_TEST(FormatterTest, FormatBin) {
+  EXPECT_EQ("0", TypeParam::format(FMT("{0:b}"), 0));
+  EXPECT_EQ("101010", TypeParam::format(FMT("{0:b}"), 42));
+  EXPECT_EQ("101010", TypeParam::format(FMT("{0:b}"), 42u));
+  EXPECT_EQ("-101010", TypeParam::format(FMT("{0:b}"), -42));
+  EXPECT_EQ("11000000111001", TypeParam::format(FMT("{0:b}"), 12345));
+  EXPECT_EQ("10010001101000101011001111000",
+            TypeParam::format(FMT("{0:b}"), 0x12345678));
+  EXPECT_EQ("10010000101010111100110111101111",
+            TypeParam::format(FMT("{0:b}"), 0x90ABCDEF));
+  EXPECT_EQ(
+      "11111111111111111111111111111111",
+      TypeParam::format(FMT("{0:b}"), std::numeric_limits<uint32_t>::max()));
+}
+
+TYPED_TEST(FormatterTest, FormatDec) {
+  EXPECT_EQ("0", TypeParam::format(FMT("{0}"), 0));
+  EXPECT_EQ("42", TypeParam::format(FMT("{0}"), 42));
+  EXPECT_EQ("42", TypeParam::format(FMT("{0:d}"), 42));
+  EXPECT_EQ("42", TypeParam::format(FMT("{0}"), 42u));
+  EXPECT_EQ("-42", TypeParam::format(FMT("{0}"), -42));
+  EXPECT_EQ("12345", TypeParam::format(FMT("{0}"), 12345));
+  EXPECT_EQ("67890", TypeParam::format(FMT("{0}"), 67890));
+  char buffer[BUFFER_SIZE];
+  safe_sprintf(buffer, "%d", INT_MIN);
+  EXPECT_EQ(buffer, TypeParam::format(FMT("{0}"), INT_MIN));
+  safe_sprintf(buffer, "%d", INT_MAX);
+  EXPECT_EQ(buffer, TypeParam::format(FMT("{0}"), INT_MAX));
+  safe_sprintf(buffer, "%u", UINT_MAX);
+  EXPECT_EQ(buffer, TypeParam::format(FMT("{0}"), UINT_MAX));
+  safe_sprintf(buffer, "%ld", 0 - static_cast<unsigned long>(LONG_MIN));
+  EXPECT_EQ(buffer, TypeParam::format(FMT("{0}"), LONG_MIN));
+  safe_sprintf(buffer, "%ld", LONG_MAX);
+  EXPECT_EQ(buffer, TypeParam::format(FMT("{0}"), LONG_MAX));
+  safe_sprintf(buffer, "%lu", ULONG_MAX);
+  EXPECT_EQ(buffer, TypeParam::format(FMT("{0}"), ULONG_MAX));
+}
+
+TYPED_TEST(FormatterTest, FormatHex) {
+  EXPECT_EQ("0", TypeParam::format(FMT("{0:x}"), 0));
+  EXPECT_EQ("42", TypeParam::format(FMT("{0:x}"), 0x42));
+  EXPECT_EQ("42", TypeParam::format(FMT("{0:x}"), 0x42u));
+  EXPECT_EQ("-42", TypeParam::format(FMT("{0:x}"), -0x42));
+  EXPECT_EQ("12345678", TypeParam::format(FMT("{0:x}"), 0x12345678));
+  EXPECT_EQ("90abcdef", TypeParam::format(FMT("{0:x}"), 0x90abcdef));
+  EXPECT_EQ("12345678", TypeParam::format(FMT("{0:X}"), 0x12345678));
+  EXPECT_EQ("90ABCDEF", TypeParam::format(FMT("{0:X}"), 0x90ABCDEF));
+
+  char buffer[BUFFER_SIZE];
+  safe_sprintf(buffer, "-%x", 0 - static_cast<unsigned>(INT_MIN));
+  EXPECT_EQ(buffer, TypeParam::format(FMT("{0:x}"), INT_MIN));
+  safe_sprintf(buffer, "%x", INT_MAX);
+  EXPECT_EQ(buffer, TypeParam::format(FMT("{0:x}"), INT_MAX));
+  safe_sprintf(buffer, "%x", UINT_MAX);
+  EXPECT_EQ(buffer, TypeParam::format(FMT("{0:x}"), UINT_MAX));
+  safe_sprintf(buffer, "-%lx", 0 - static_cast<unsigned long>(LONG_MIN));
+  EXPECT_EQ(buffer, TypeParam::format(FMT("{0:x}"), LONG_MIN));
+  safe_sprintf(buffer, "%lx", LONG_MAX);
+  EXPECT_EQ(buffer, TypeParam::format(FMT("{0:x}"), LONG_MAX));
+  safe_sprintf(buffer, "%lx", ULONG_MAX);
+  EXPECT_EQ(buffer, TypeParam::format(FMT("{0:x}"), ULONG_MAX));
+}
+
+TYPED_TEST(FormatterTest, FormatOct) {
+  EXPECT_EQ("0", TypeParam::format(FMT("{0:o}"), 0));
+  EXPECT_EQ("42", TypeParam::format(FMT("{0:o}"), 042));
+  EXPECT_EQ("42", TypeParam::format(FMT("{0:o}"), 042u));
+  EXPECT_EQ("-42", TypeParam::format(FMT("{0:o}"), -042));
+  EXPECT_EQ("12345670", TypeParam::format(FMT("{0:o}"), 012345670));
+  char buffer[BUFFER_SIZE];
+  safe_sprintf(buffer, "-%o", 0 - static_cast<unsigned>(INT_MIN));
+  EXPECT_EQ(buffer, TypeParam::format(FMT("{0:o}"), INT_MIN));
+  safe_sprintf(buffer, "%o", INT_MAX);
+  EXPECT_EQ(buffer, TypeParam::format(FMT("{0:o}"), INT_MAX));
+  safe_sprintf(buffer, "%o", UINT_MAX);
+  EXPECT_EQ(buffer, TypeParam::format(FMT("{0:o}"), UINT_MAX));
+  safe_sprintf(buffer, "-%lo", 0 - static_cast<unsigned long>(LONG_MIN));
+  EXPECT_EQ(buffer, TypeParam::format(FMT("{0:o}"), LONG_MIN));
+  safe_sprintf(buffer, "%lo", LONG_MAX);
+  EXPECT_EQ(buffer, TypeParam::format(FMT("{0:o}"), LONG_MAX));
+  safe_sprintf(buffer, "%lo", ULONG_MAX);
+  EXPECT_EQ(buffer, TypeParam::format(FMT("{0:o}"), ULONG_MAX));
+}
+
+TYPED_TEST(FormatterTest, FormatIntLocale) {
+  EXPECT_EQ("123", TypeParam::format(FMT("{0:n}"), 123));
+  EXPECT_EQ("1,234", TypeParam::format(FMT("{0:n}"), 1234));
+  EXPECT_EQ("1,234,567", TypeParam::format(FMT("{0:n}"), 1234567));
+  EXPECT_EQ(
+      "4,294,967,295",
+      TypeParam::format(FMT("{0:n}"), std::numeric_limits<uint32_t>::max()));
+}
+
+struct ConvertibleToLongLong {
+  operator long long() const { return 1LL << 32; }
+};
+
+TYPED_TEST(FormatterTest, FormatConvertibleToLongLong) {
+  EXPECT_EQ("100000000",
+            TypeParam::format(FMT("{0:x}"), ConvertibleToLongLong()));
+}
+
+TYPED_TEST(FormatterTest, FormatFloat) {
+  EXPECT_EQ("392.500000", TypeParam::format(FMT("{0:f}"), 392.5f));
+}
+
+TYPED_TEST(FormatterThrowTest, FormatDouble) {
+  check_unknown_types<TypeParam>(1.2, "eEfFgGaA", "double");
+}
+
+TYPED_TEST(FormatterTest, FormatDouble) {
+  EXPECT_EQ("0", TypeParam::format(FMT("{0:}"), 0.0));
+  EXPECT_EQ("0.000000", TypeParam::format(FMT("{0:f}"), 0.0));
+  EXPECT_EQ("392.65", TypeParam::format(FMT("{0:}"), 392.65));
+  EXPECT_EQ("392.65", TypeParam::format(FMT("{0:g}"), 392.65));
+  EXPECT_EQ("392.65", TypeParam::format(FMT("{0:G}"), 392.65));
+  EXPECT_EQ("392.650000", TypeParam::format(FMT("{0:f}"), 392.65));
+  EXPECT_EQ("392.650000", TypeParam::format(FMT("{0:F}"), 392.65));
+  char buffer[BUFFER_SIZE];
+  safe_sprintf(buffer, "%e", 392.65);
+  EXPECT_EQ(buffer, TypeParam::format(FMT("{0:e}"), 392.65));
+  safe_sprintf(buffer, "%E", 392.65);
+  EXPECT_EQ(buffer, TypeParam::format(FMT("{0:E}"), 392.65));
+  EXPECT_EQ("+0000392.6", TypeParam::format(FMT("{0:+010.4g}"), 392.65));
+  safe_sprintf(buffer, "%a", -42.0);
+  EXPECT_EQ(buffer, TypeParam::format(FMT("{:a}"), -42.0));
+  safe_sprintf(buffer, "%A", -42.0);
+  EXPECT_EQ(buffer, TypeParam::format(FMT("{:A}"), -42.0));
+}
+
+TYPED_TEST(FormatterTest, FormatDoubleBigPrecision) {
+  // sprintf with big precision is broken in MSVC2013, so only test on Grisu.
+  if (FMT_USE_GRISU) {
+    const auto result1 = TypeParam::format(FMT("0.{:0<1000}"), "");
+    const auto result2 = TypeParam::format(FMT("{:.1000f}"), 0.0);
+    EXPECT_EQ(result1, result2);
+  }
+}
+
+TYPED_TEST(FormatterTest, FormatNaN) {
+  double nan = std::numeric_limits<double>::quiet_NaN();
+  EXPECT_EQ("nan", TypeParam::format(FMT("{}"), nan));
+  EXPECT_EQ("+nan", TypeParam::format(FMT("{:+}"), nan));
+  EXPECT_EQ(" nan", TypeParam::format(FMT("{: }"), nan));
+  EXPECT_EQ("NAN", TypeParam::format(FMT("{:F}"), nan));
+  EXPECT_EQ("nan    ", TypeParam::format(FMT("{:<7}"), nan));
+  EXPECT_EQ("  nan  ", TypeParam::format(FMT("{:^7}"), nan));
+  EXPECT_EQ("    nan", TypeParam::format(FMT("{:>7}"), nan));
+}
+
+TYPED_TEST(FormatterTest, FormatInfinity) {
+  double inf = std::numeric_limits<double>::infinity();
+  EXPECT_EQ("inf", TypeParam::format(FMT("{}"), inf));
+  EXPECT_EQ("+inf", TypeParam::format(FMT("{:+}"), inf));
+  EXPECT_EQ("-inf", TypeParam::format(FMT("{}"), -inf));
+  EXPECT_EQ(" inf", TypeParam::format(FMT("{: }"), inf));
+  EXPECT_EQ("INF", TypeParam::format(FMT("{:F}"), inf));
+  EXPECT_EQ("inf    ", TypeParam::format(FMT("{:<7}"), inf));
+  EXPECT_EQ("  inf  ", TypeParam::format(FMT("{:^7}"), inf));
+  EXPECT_EQ("    inf", TypeParam::format(FMT("{:>7}"), inf));
+}
+
+TYPED_TEST(FormatterTest, FormatLongDouble) {
+  EXPECT_EQ("0", TypeParam::format(FMT("{0:}"), 0.0l));
+  EXPECT_EQ("0.000000", TypeParam::format(FMT("{0:f}"), 0.0l));
+  EXPECT_EQ("392.65", TypeParam::format(FMT("{0:}"), 392.65l));
+  EXPECT_EQ("392.65", TypeParam::format(FMT("{0:g}"), 392.65l));
+  EXPECT_EQ("392.65", TypeParam::format(FMT("{0:G}"), 392.65l));
+  EXPECT_EQ("392.650000", TypeParam::format(FMT("{0:f}"), 392.65l));
+  EXPECT_EQ("392.650000", TypeParam::format(FMT("{0:F}"), 392.65l));
+  char buffer[BUFFER_SIZE];
+  safe_sprintf(buffer, "%Le", 392.65l);
+  EXPECT_EQ(buffer, TypeParam::format(FMT("{0:e}"), 392.65l));
+  EXPECT_EQ("+0000392.6", TypeParam::format(FMT("{0:+010.4g}"), 392.64l));
+}
+TYPED_TEST(FormatterThrowTest, FormatChar) {
+  const char types[] = "cbBdoxXn";
+  check_unknown_types<TypeParam>('a', types, "char");
+}
+
+TYPED_TEST(FormatterTest, FormatChar) {
+  EXPECT_EQ("a", TypeParam::format(FMT("{0}"), 'a'));
+  EXPECT_EQ("z", TypeParam::format(FMT("{0:c}"), 'z'));
+  EXPECT_EQ(L"a", TypeParam::format(FMT(L"{0}"), 'a'));
+
+  int x = 'x';
+  auto result = TypeParam::format(FMT("{:b}"), x);
+  EXPECT_EQ(result, TypeParam::format(FMT("{:b}"), 'x'));
+  result = TypeParam::format(FMT("{:B}"), x);
+  EXPECT_EQ(result, TypeParam::format(FMT("{:B}"), 'x'));
+  result = TypeParam::format(FMT("{:d}"), x);
+  EXPECT_EQ(result, TypeParam::format(FMT("{:d}"), 'x'));
+  result = TypeParam::format(FMT("{:o}"), x);
+  EXPECT_EQ(result, TypeParam::format(FMT("{:o}"), 'x'));
+  result = TypeParam::format(FMT("{:x}"), x);
+  EXPECT_EQ(result, TypeParam::format(FMT("{:x}"), 'x'));
+  result = TypeParam::format(FMT("{:X}"), x);
+  EXPECT_EQ(result, TypeParam::format(FMT("{:X}"), 'x'));
+  result = TypeParam::format(FMT("{:n}"), x);
+  EXPECT_EQ(result, TypeParam::format(FMT("{:n}"), 'x'));
+  result = TypeParam::format(FMT("{:02X}"), x);
+  EXPECT_EQ(result, TypeParam::format(FMT("{:02X}"), 'x'));
+}
+
+TYPED_TEST(FormatterTest, FormatUnsignedChar) {
+  EXPECT_EQ("42", TypeParam::format(FMT("{}"), static_cast<unsigned char>(42)));
+  EXPECT_EQ("42", TypeParam::format(FMT("{}"), static_cast<uint8_t>(42)));
+}
+
+TYPED_TEST(FormatterTest, FormatWChar) {
+  EXPECT_EQ(L"a", TypeParam::format(FMT(L"{0}"), L'a'));
+  // This shouldn't compile:
+  // format("{}", L'a');
+}
+TYPED_TEST(FormatterThrowTest, FormatCString) {
+  check_unknown_types<TypeParam>("test", "sp", "string");
+  EXPECT_THROW_MSG(
+      TypeParam::format("{0}", static_cast<const char *>(FMT_NULL)),
+      format_error, "string pointer is null");
+}
+
+TYPED_TEST(FormatterTest, FormatCString) {
+  EXPECT_EQ("test", TypeParam::format(FMT("{0}"), "test"));
+  EXPECT_EQ("test", TypeParam::format(FMT("{0:s}"), "test"));
+  char nonconst[] = "nonconst";
+  EXPECT_EQ("nonconst", TypeParam::format(FMT("{0}"), nonconst));
+}
+
+// FormatUCharString and FormatUCharString workaround for GCC < 4.7 bug #20140
+TEST(FormatterTest, FormatSCharString) {
+  signed char str[] = "test";
+  EXPECT_EQ("test", fmt::format("{0:s}", str));
+  {
+    auto prepared = fmt::prepare<signed char *>("{0:s}");
+    EXPECT_EQ("test", prepared.format(str));
+  }
+#if FMT_USE_CONSTEXPR
+  {
+    auto prepared = fmt::prepare<signed char *>(FMT("{0:s}"));
+    EXPECT_EQ("test", prepared.format(str));
+  }
+#endif
+
+  const signed char *const_str = str;
+  EXPECT_EQ("test", fmt::format("{0:s}", const_str));
+  {
+    auto prepared = fmt::prepare<const signed char *>("{0:s}");
+    EXPECT_EQ("test", prepared.format(const_str));
+  }
+#if FMT_USE_CONSTEXPR
+  {
+    auto prepared = fmt::prepare<const signed char *>(FMT("{0:s}"));
+    EXPECT_EQ("test", prepared.format(const_str));
+  }
+#endif
+}
+
+TEST(FormatterTest, FormatUCharString) {
+  unsigned char str[] = "test";
+  EXPECT_EQ("test", fmt::format("{0:s}", str));
+  {
+    auto prepared = fmt::prepare<unsigned char *>("{0:s}");
+    EXPECT_EQ("test", prepared.format(str));
+  }
+#if FMT_USE_CONSTEXPR
+  {
+    auto prepared = fmt::prepare<unsigned char *>(FMT("{0:s}"));
+    EXPECT_EQ("test", prepared.format(str));
+  }
+#endif
+
+  const unsigned char *const_str = str;
+  EXPECT_EQ("test", fmt::format("{0:s}", str));
+  {
+    auto prepared = fmt::prepare<const unsigned char *>("{0:s}");
+    EXPECT_EQ("test", prepared.format(str));
+  }
+#if FMT_USE_CONSTEXPR
+  {
+    auto prepared = fmt::prepare<const unsigned char *>(FMT("{0:s}"));
+    EXPECT_EQ("test", prepared.format(str));
+  }
+#endif
+
+  unsigned char *ptr = str;
+  EXPECT_EQ("test", fmt::format("{0:s}", str));
+  {
+    auto prepared = fmt::prepare<unsigned char *>("{0:s}");
+    EXPECT_EQ("test", prepared.format(str));
+  }
+#if FMT_USE_CONSTEXPR
+  {
+    auto prepared = fmt::prepare<unsigned char *>(FMT("{0:s}"));
+    EXPECT_EQ("test", prepared.format(str));
+  }
+#endif
+}
+TYPED_TEST(FormatterThrowTest, FormatPointer) {
+  check_unknown_types<TypeParam>(reinterpret_cast<void *>(0x1234), "p",
+                                 "pointer");
+}
+
+TYPED_TEST(FormatterTest, FormatPointer) {
+  EXPECT_EQ("0x0",
+            TypeParam::format(FMT("{0}"), static_cast<void *>(FMT_NULL)));
+  EXPECT_EQ("0x1234",
+            TypeParam::format(FMT("{0}"), reinterpret_cast<void *>(0x1234)));
+  EXPECT_EQ("0x1234",
+            TypeParam::format(FMT("{0:p}"), reinterpret_cast<void *>(0x1234)));
+  EXPECT_EQ(
+      "0x" + std::string(sizeof(void *) * CHAR_BIT / 4, 'f'),
+      TypeParam::format(FMT("{0}"), reinterpret_cast<void *>(~uintptr_t())));
+  EXPECT_EQ("0x1234",
+            TypeParam::format(FMT("{}"), reinterpret_cast<void *>(0x1234)));
+#if FMT_USE_NULLPTR
+  EXPECT_EQ("0x0", TypeParam::format(FMT("{}"), FMT_NULL));
+#endif
+}
+
+TYPED_TEST(FormatterTest, FormatString) {
+  EXPECT_EQ("test", TypeParam::format(FMT("{0}"), std::string("test")));
+}
+
+TYPED_TEST(FormatterTest, FormatStringView) {
+  EXPECT_EQ("test", TypeParam::format(FMT("{}"), string_view("test")));
+  EXPECT_EQ("", TypeParam::format(FMT("{}"), string_view()));
+}
+
+#ifdef FMT_USE_STD_STRING_VIEW
+TYPED_TEST(FormatterTest, FormatStdStringView) {
+  EXPECT_EQ("test", TypeParam::format(FMT("{}"), std::string_view("test")));
+}
+#endif
+
+FMT_BEGIN_NAMESPACE
+template <> struct formatter<Date> {
+  template <typename ParseContext>
+  FMT_CONSTEXPR auto parse(ParseContext &ctx) -> decltype(ctx.begin()) {
+    auto it = ctx.begin();
+    if (*it == 'd') {
+      return ++it;
+    }
+    return it;
+  }
+
+  auto format(const Date &d, format_context &ctx) -> decltype(ctx.out()) {
+    format_to(ctx.out(), "{}-{}-{}", d.year(), d.month(), d.day());
+    return ctx.out();
+  }
+};
+FMT_END_NAMESPACE
+
+// This test should be enabled for fmt::prepare() wrappers once it will support
+// custom types formatting.
+TYPED_TEST(RuntimeFormatFunctionTest, FormatCustom) {
+  Date date(2012, 12, 9);
+  EXPECT_THROW_MSG(TypeParam::format("{:s}", date), format_error,
+                   "unknown format specifier");
+}
+
+class Answer {};
+
+FMT_BEGIN_NAMESPACE
+template <> struct formatter<Answer> : formatter<int> {
+  template <typename FormatContext>
+  auto format(Answer, FormatContext &ctx) -> decltype(ctx.begin()) {
+    return formatter<int>::format(42, ctx);
+  }
+};
+FMT_END_NAMESPACE
+
+// This test should be enabled for fmt::prepare() wrappers once it will support
+// custom types formatting.
+TYPED_TEST(RuntimeFormatFunctionTest, CustomFormat) {
+  EXPECT_EQ("42", TypeParam::format(FMT("{0}"), Answer()));
+  EXPECT_EQ("0042", TypeParam::format(FMT("{:04}"), Answer()));
+}
+
+// This test should be enabled for fmt::prepare() wrappers once it will support
+// custom types formatting.
+TYPED_TEST(RuntimeFormatFunctionTest, CustomFormatTo) {
+  char buf[10] = {};
+  auto end = &*TypeParam::format_to(fmt::internal::make_checked(buf, 10),
+                                    FMT("{}"), Answer());
+  EXPECT_EQ(end, buf + 2);
+  EXPECT_STREQ(buf, "42");
+}
+
+TYPED_TEST(FormatterTest, WideFormatString) {
+  EXPECT_EQ(L"42", TypeParam::format(FMT(L"{}"), 42));
+  EXPECT_EQ(L"4.2", TypeParam::format(FMT(L"{}"), 4.2));
+  EXPECT_EQ(L"abc", TypeParam::format(FMT(L"{}"), L"abc"));
+  EXPECT_EQ(L"z", TypeParam::format(FMT(L"{}"), L'z'));
+}
+
+TYPED_TEST(FormatterTest, FormatStringFromSpeedTest) {
+  EXPECT_EQ("1.2340000000:0042:+3.13:str:0x3e8:X:%",
+            TypeParam::format(FMT("{0:0.10f}:{1:04}:{2:+g}:{3}:{4}:{5}:%"),
+                              1.234, 42, 3.13, "str",
+                              reinterpret_cast<void *>(1000), 'X'));
+}
+
+// This test should be enabled for fmt::prepare() wrappers once it will support
+// custom types formatting.
+TYPED_TEST(FormatFunctionTest, JoinArg) {
+  using fmt::join;
+  int v1[3] = {1, 2, 3};
+  std::vector<float> v2;
+  v2.push_back(1.2f);
+  v2.push_back(3.4f);
+  void *v3[2] = {&v1[0], &v1[1]};
+
+  EXPECT_EQ("(1, 2, 3)",
+            TypeParam::format(FMT("({})"), join(v1, v1 + 3, ", ")));
+  EXPECT_EQ("(1)", TypeParam::format(FMT("({})"), join(v1, v1 + 1, ", ")));
+  EXPECT_EQ("()", TypeParam::format(FMT("({})"), join(v1, v1, ", ")));
+  EXPECT_EQ("(001, 002, 003)",
+            TypeParam::format(FMT("({:03})"), join(v1, v1 + 3, ", ")));
+  EXPECT_EQ(
+      "(+01.20, +03.40)",
+      TypeParam::format(FMT("({:+06.2f})"), join(v2.begin(), v2.end(), ", ")));
+
+  EXPECT_EQ(L"(1, 2, 3)",
+            TypeParam::format(FMT(L"({})"), join(v1, v1 + 3, L", ")));
+  EXPECT_EQ("1, 2, 3",
+            TypeParam::format(FMT("{0:{1}}"), join(v1, v1 + 3, ", "), 1));
+
+  const auto result = TypeParam::format(FMT("{}, {}"), v3[0], v3[1]);
+  EXPECT_EQ(result, TypeParam::format(FMT("{}"), join(v3, v3 + 2, ", ")));
+
+#if FMT_USE_TRAILING_RETURN && (!FMT_GCC_VERSION || FMT_GCC_VERSION >= 405)
+  EXPECT_EQ("(1, 2, 3)", TypeParam::format(FMT("({})"), join(v1, ", ")));
+  EXPECT_EQ("(+01.20, +03.40)",
+            TypeParam::format(FMT("({:+06.2f})"), join(v2, ", ")));
+#endif
+}
+
+TYPED_TEST(FormatterTest, UnpackedArgs) {
+  EXPECT_EQ("0123456789abcdefg",
+            TypeParam::format(FMT("{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}"), 0, 1,
+                              2, 3, 4, 5, 6, 7, 8, 9, 'a', 'b', 'c', 'd', 'e',
+                              'f', 'g'));
+}
+
+enum TestEnum { A };
+
+TYPED_TEST(FormatterTest, Enum) {
+  EXPECT_EQ("0", TypeParam::format(FMT("{}"), A));
+}
+
+TEST(FormatTest, NonNullTerminatedFormatString) {
+  EXPECT_EQ("42", format(string_view("{}foo", 2), 42));
+
+  {
+    auto prepared_formatter = fmt::prepare<int>(string_view("{}foo", 2));
+    const auto result = prepared_formatter.format(42);
+    EXPECT_EQ("42", result);
+  }
+}
+
+struct variant {
+  enum { INT, STRING } type;
+  explicit variant(int) : type(INT) {}
+  explicit variant(const char *) : type(STRING) {}
+};
+
+FMT_BEGIN_NAMESPACE
+template <> struct formatter<variant> : dynamic_formatter<> {
+  template <typename FormatContext>
+  auto format(variant value, FormatContext &ctx) -> decltype(ctx.out()) {
+    if (value.type == variant::INT)
+      return dynamic_formatter<>::format(42, ctx);
+    return dynamic_formatter<>::format("foo", ctx);
+  }
+};
+FMT_END_NAMESPACE
+
+// This test should be enabled for fmt::prepare() wrappers once it will support
+// custom types formatting.
+TYPED_TEST(RuntimeFormatFunctionTest, DynamicFormatter) {
+  auto num = variant(42);
+  auto str = variant("foo");
+  EXPECT_THROW_MSG(TypeParam::format("{0:{}}", num), format_error,
+                   "cannot switch from manual to automatic argument indexing");
+  EXPECT_THROW_MSG(TypeParam::format("{:{0}}", num), format_error,
+                   "cannot switch from automatic to manual argument indexing");
+  EXPECT_THROW_MSG(TypeParam::format("{:=}", str), format_error,
+                   "format specifier requires numeric argument");
+  EXPECT_THROW_MSG(TypeParam::format("{:+}", str), format_error,
+                   "format specifier requires numeric argument");
+  EXPECT_THROW_MSG(TypeParam::format("{:-}", str), format_error,
+                   "format specifier requires numeric argument");
+  EXPECT_THROW_MSG(TypeParam::format("{: }", str), format_error,
+                   "format specifier requires numeric argument");
+  EXPECT_THROW_MSG(TypeParam::format("{:#}", str), format_error,
+                   "format specifier requires numeric argument");
+  EXPECT_THROW_MSG(TypeParam::format("{:0}", str), format_error,
+                   "format specifier requires numeric argument");
+  EXPECT_THROW_MSG(TypeParam::format("{:.2}", num), format_error,
+                   "precision not allowed for this argument type");
+  EXPECT_EQ("42", TypeParam::format(FMT("{:d}"), num));
+  EXPECT_EQ("foo", TypeParam::format(FMT("{:s}"), str));
+  EXPECT_EQ(" 42 foo ", TypeParam::format(FMT("{:{}} {:{}}"), num, 3, str, 4));
+}
+
+#if FMT_USE_USER_DEFINED_LITERALS
+TYPED_TEST(RuntimeFormattersTest, U8StringViewLiteral) {
+  using namespace fmt::literals;
+  fmt::u8string_view s = "ab"_u;
+  EXPECT_EQ(s.size(), 2u);
+  const fmt::char8_t *data = s.data();
+  EXPECT_EQ(data[0], 'a');
+  EXPECT_EQ(data[1], 'b');
+  EXPECT_EQ("**🤡**"_u, TypeParam::format("{:*^5}"_u, "🤡"_u));
+}
+#endif
+
+TYPED_TEST(RuntimeFormattersTest, FormatU8String) {
+  EXPECT_EQ(fmt::u8string_view("42"),
+            TypeParam::format(fmt::u8string_view("{}"), 42));
+}
+
+TYPED_TEST(FormatterTest, FormattedSize) {
+  EXPECT_EQ(2u, TypeParam::formatted_size(FMT("{}"), 42));
+}
+
+TYPED_TEST(FormatterTest, FormatToN) {
+  char buffer[4];
+  buffer[3] = 'x';
+  auto result = TypeParam::format_to_n(buffer, 3, FMT("{}"), 12345);
+  EXPECT_EQ(5u, result.size);
+  EXPECT_EQ(buffer + 3, result.out);
+  EXPECT_EQ("123x", fmt::string_view(buffer, 4));
+  result = TypeParam::format_to_n(buffer, 3, FMT("{:s}"), "foobar");
+  EXPECT_EQ(6u, result.size);
+  EXPECT_EQ(buffer + 3, result.out);
+  EXPECT_EQ("foox", fmt::string_view(buffer, 4));
+}
+
+TYPED_TEST(FormatterTest, WideFormatToN) {
+  wchar_t buffer[4];
+  buffer[3] = L'x';
+  const auto result = TypeParam::format_to_n(buffer, 3, FMT(L"{}"), 12345);
+  EXPECT_EQ(5u, result.size);
+  EXPECT_EQ(buffer + 3, result.out);
+  EXPECT_EQ(L"123x", fmt::wstring_view(buffer, 4));
+}
diff --git a/test/format-test.cc b/test/format-test.cc
index 2ce513b2..3b672cb9 100644
--- a/test/format-test.cc
+++ b/test/format-test.cc
@@ -699,901 +699,6 @@ TEST(WriterTest, WriteWideString) {
   //std::declval<fmt::basic_writer<fmt::wbuffer>>().write("abc");
 }
 
-TEST(FormatToTest, FormatWithoutArgs) {
-  std::string s;
-  fmt::format_to(std::back_inserter(s), "test");
-  EXPECT_EQ("test", s);
-}
-
-TEST(FormatToTest, Format) {
-  std::string s;
-  fmt::format_to(std::back_inserter(s), "part{0}", 1);
-  EXPECT_EQ("part1", s);
-  fmt::format_to(std::back_inserter(s), "part{0}", 2);
-  EXPECT_EQ("part1part2", s);
-}
-
-TEST(FormatToTest, WideString) {
-  std::vector<wchar_t> buf;
-  fmt::format_to(std::back_inserter(buf), L"{}{}", 42, L'\0');
-  EXPECT_STREQ(buf.data(), L"42");
-}
-
-TEST(FormatToTest, FormatToNonbackInsertIteratorWithSignAndNumericAlignment) {
-  char buffer[16] = {};
-  fmt::format_to(fmt::internal::make_checked(buffer, 16), "{: =+}", 42.0);
-  EXPECT_STREQ("+42", buffer);
-}
-
-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) {
-  EXPECT_EQ("{", format("{{"));
-  EXPECT_EQ("before {", format("before {{"));
-  EXPECT_EQ("{ after", format("{{ after"));
-  EXPECT_EQ("before { after", format("before {{ after"));
-
-  EXPECT_EQ("}", format("}}"));
-  EXPECT_EQ("before }", format("before }}"));
-  EXPECT_EQ("} after", format("}} after"));
-  EXPECT_EQ("before } after", format("before }} after"));
-
-  EXPECT_EQ("{}", format("{{}}"));
-  EXPECT_EQ("{42}", format("{{{0}}}", 42));
-}
-
-TEST(FormatterTest, UnmatchedBraces) {
-  EXPECT_THROW_MSG(format("{"), format_error, "invalid format string");
-  EXPECT_THROW_MSG(format("}"), format_error, "unmatched '}' in format string");
-  EXPECT_THROW_MSG(format("{0{}"), format_error, "invalid format string");
-}
-
-TEST(FormatterTest, NoArgs) {
-  EXPECT_EQ("test", format("test"));
-}
-
-TEST(FormatterTest, ArgsInDifferentPositions) {
-  EXPECT_EQ("42", format("{0}", 42));
-  EXPECT_EQ("before 42", format("before {0}", 42));
-  EXPECT_EQ("42 after", format("{0} after", 42));
-  EXPECT_EQ("before 42 after", format("before {0} after", 42));
-  EXPECT_EQ("answer = 42", format("{0} = {1}", "answer", 42));
-  EXPECT_EQ("42 is the answer", format("{1} is the {0}", "answer", 42));
-  EXPECT_EQ("abracadabra", format("{0}{1}{0}", "abra", "cad"));
-}
-
-TEST(FormatterTest, ArgErrors) {
-  EXPECT_THROW_MSG(format("{"), format_error, "invalid format string");
-  EXPECT_THROW_MSG(format("{?}"), format_error, "invalid format string");
-  EXPECT_THROW_MSG(format("{0"), format_error, "invalid format string");
-  EXPECT_THROW_MSG(format("{0}"), format_error, "argument index out of range");
-  EXPECT_THROW_MSG(format("{00}", 42), format_error, "invalid format string");
-
-  char format_str[BUFFER_SIZE];
-  safe_sprintf(format_str, "{%u", INT_MAX);
-  EXPECT_THROW_MSG(format(format_str), format_error, "invalid format string");
-  safe_sprintf(format_str, "{%u}", INT_MAX);
-  EXPECT_THROW_MSG(format(format_str), format_error,
-      "argument index out of range");
-
-  safe_sprintf(format_str, "{%u", INT_MAX + 1u);
-  EXPECT_THROW_MSG(format(format_str), format_error, "number is too big");
-  safe_sprintf(format_str, "{%u}", INT_MAX + 1u);
-  EXPECT_THROW_MSG(format(format_str), format_error, "number is too big");
-}
-
-template <int N>
-struct TestFormat {
-  template <typename... Args>
-  static std::string format(fmt::string_view format_str, const Args &... args) {
-    return TestFormat<N - 1>::format(format_str, N - 1, args...);
-  }
-};
-
-template <>
-struct TestFormat<0> {
-  template <typename... Args>
-  static std::string format(fmt::string_view format_str, const Args &... args) {
-    return fmt::format(format_str, args...);
-  }
-};
-
-TEST(FormatterTest, ManyArgs) {
-  EXPECT_EQ("19", TestFormat<20>::format("{19}"));
-  EXPECT_THROW_MSG(TestFormat<20>::format("{20}"),
-                   format_error, "argument index out of range");
-  EXPECT_THROW_MSG(TestFormat<21>::format("{21}"),
-                   format_error, "argument index out of range");
-  enum { max_packed_args = fmt::internal::max_packed_args };
-  std::string format_str = fmt::format("{{{}}}", max_packed_args + 1);
-  EXPECT_THROW_MSG(TestFormat<max_packed_args>::format(format_str),
-                   format_error, "argument index out of range");
-}
-
-TEST(FormatterTest, NamedArg) {
-  EXPECT_EQ("1/a/A", format("{_1}/{a_}/{A_}", fmt::arg("a_", 'a'),
-                            fmt::arg("A_", "A"), fmt::arg("_1", 1)));
-  EXPECT_THROW_MSG(format("{a}"), format_error, "argument not found");
-  EXPECT_EQ(" -42", format("{0:{width}}", -42, fmt::arg("width", 4)));
-  EXPECT_EQ("st", format("{0:.{precision}}", "str", fmt::arg("precision", 2)));
-  EXPECT_EQ("1 2", format("{} {two}", 1, fmt::arg("two", 2)));
-  EXPECT_EQ("42", format("{c}",
-        fmt::arg("a", 0), fmt::arg("b", 0), fmt::arg("c", 42), fmt::arg("d", 0),
-        fmt::arg("e", 0), fmt::arg("f", 0), fmt::arg("g", 0), fmt::arg("h", 0),
-        fmt::arg("i", 0), fmt::arg("j", 0), fmt::arg("k", 0), fmt::arg("l", 0),
-        fmt::arg("m", 0), fmt::arg("n", 0), fmt::arg("o", 0), fmt::arg("p", 0)));
-}
-
-TEST(FormatterTest, AutoArgIndex) {
-  EXPECT_EQ("abc", format("{}{}{}", 'a', 'b', 'c'));
-  EXPECT_THROW_MSG(format("{0}{}", 'a', 'b'),
-      format_error, "cannot switch from manual to automatic argument indexing");
-  EXPECT_THROW_MSG(format("{}{0}", 'a', 'b'),
-      format_error, "cannot switch from automatic to manual argument indexing");
-  EXPECT_EQ("1.2", format("{:.{}}", 1.2345, 2));
-  EXPECT_THROW_MSG(format("{0}:.{}", 1.2345, 2),
-      format_error, "cannot switch from manual to automatic argument indexing");
-  EXPECT_THROW_MSG(format("{:.{0}}", 1.2345, 2),
-      format_error, "cannot switch from automatic to manual argument indexing");
-  EXPECT_THROW_MSG(format("{}"), format_error, "argument index out of range");
-}
-
-TEST(FormatterTest, EmptySpecs) {
-  EXPECT_EQ("42", format("{0:}", 42));
-}
-
-TEST(FormatterTest, LeftAlign) {
-  EXPECT_EQ("42  ", format("{0:<4}", 42));
-  EXPECT_EQ("42  ", format("{0:<4o}", 042));
-  EXPECT_EQ("42  ", format("{0:<4x}", 0x42));
-  EXPECT_EQ("-42  ", format("{0:<5}", -42));
-  EXPECT_EQ("42   ", format("{0:<5}", 42u));
-  EXPECT_EQ("-42  ", format("{0:<5}", -42l));
-  EXPECT_EQ("42   ", format("{0:<5}", 42ul));
-  EXPECT_EQ("-42  ", format("{0:<5}", -42ll));
-  EXPECT_EQ("42   ", format("{0:<5}", 42ull));
-  EXPECT_EQ("-42  ", format("{0:<5}", -42.0));
-  EXPECT_EQ("-42  ", format("{0:<5}", -42.0l));
-  EXPECT_EQ("c    ", format("{0:<5}", 'c'));
-  EXPECT_EQ("abc  ", format("{0:<5}", "abc"));
-  EXPECT_EQ("0xface  ", format("{0:<8}", reinterpret_cast<void*>(0xface)));
-}
-
-TEST(FormatterTest, RightAlign) {
-  EXPECT_EQ("  42", format("{0:>4}", 42));
-  EXPECT_EQ("  42", format("{0:>4o}", 042));
-  EXPECT_EQ("  42", format("{0:>4x}", 0x42));
-  EXPECT_EQ("  -42", format("{0:>5}", -42));
-  EXPECT_EQ("   42", format("{0:>5}", 42u));
-  EXPECT_EQ("  -42", format("{0:>5}", -42l));
-  EXPECT_EQ("   42", format("{0:>5}", 42ul));
-  EXPECT_EQ("  -42", format("{0:>5}", -42ll));
-  EXPECT_EQ("   42", format("{0:>5}", 42ull));
-  EXPECT_EQ("  -42", format("{0:>5}", -42.0));
-  EXPECT_EQ("  -42", format("{0:>5}", -42.0l));
-  EXPECT_EQ("    c", format("{0:>5}", 'c'));
-  EXPECT_EQ("  abc", format("{0:>5}", "abc"));
-  EXPECT_EQ("  0xface", format("{0:>8}", reinterpret_cast<void*>(0xface)));
-}
-
-TEST(FormatterTest, NumericAlign) {
-  EXPECT_EQ("  42", format("{0:=4}", 42));
-  EXPECT_EQ("+ 42", format("{0:=+4}", 42));
-  EXPECT_EQ("  42", format("{0:=4o}", 042));
-  EXPECT_EQ("+ 42", format("{0:=+4o}", 042));
-  EXPECT_EQ("  42", format("{0:=4x}", 0x42));
-  EXPECT_EQ("+ 42", format("{0:=+4x}", 0x42));
-  EXPECT_EQ("-  42", format("{0:=5}", -42));
-  EXPECT_EQ("   42", format("{0:=5}", 42u));
-  EXPECT_EQ("-  42", format("{0:=5}", -42l));
-  EXPECT_EQ("   42", format("{0:=5}", 42ul));
-  EXPECT_EQ("-  42", format("{0:=5}", -42ll));
-  EXPECT_EQ("   42", format("{0:=5}", 42ull));
-  EXPECT_EQ("-  42", format("{0:=5}", -42.0));
-  EXPECT_EQ("-  42", format("{0:=5}", -42.0l));
-  EXPECT_THROW_MSG(format("{0:=5", 'c'),
-      format_error, "missing '}' in format string");
-  EXPECT_THROW_MSG(format("{0:=5}", 'c'),
-      format_error, "invalid format specifier for char");
-  EXPECT_THROW_MSG(format("{0:=5}", "abc"),
-      format_error, "format specifier requires numeric argument");
-  EXPECT_THROW_MSG(format("{0:=8}", reinterpret_cast<void*>(0xface)),
-      format_error, "format specifier requires numeric argument");
-  EXPECT_EQ(" 1", fmt::format("{:= }", 1.0));
-}
-
-TEST(FormatterTest, CenterAlign) {
-  EXPECT_EQ(" 42  ", format("{0:^5}", 42));
-  EXPECT_EQ(" 42  ", format("{0:^5o}", 042));
-  EXPECT_EQ(" 42  ", format("{0:^5x}", 0x42));
-  EXPECT_EQ(" -42 ", format("{0:^5}", -42));
-  EXPECT_EQ(" 42  ", format("{0:^5}", 42u));
-  EXPECT_EQ(" -42 ", format("{0:^5}", -42l));
-  EXPECT_EQ(" 42  ", format("{0:^5}", 42ul));
-  EXPECT_EQ(" -42 ", format("{0:^5}", -42ll));
-  EXPECT_EQ(" 42  ", format("{0:^5}", 42ull));
-  EXPECT_EQ(" -42  ", format("{0:^6}", -42.0));
-  EXPECT_EQ(" -42 ", format("{0:^5}", -42.0l));
-  EXPECT_EQ("  c  ", format("{0:^5}", 'c'));
-  EXPECT_EQ(" abc  ", format("{0:^6}", "abc"));
-  EXPECT_EQ(" 0xface ", format("{0:^8}", reinterpret_cast<void*>(0xface)));
-}
-
-TEST(FormatterTest, Fill) {
-  EXPECT_THROW_MSG(format("{0:{<5}", 'c'),
-      format_error, "invalid fill character '{'");
-  EXPECT_THROW_MSG(format("{0:{<5}}", 'c'),
-      format_error, "invalid fill character '{'");
-  EXPECT_EQ("**42", format("{0:*>4}", 42));
-  EXPECT_EQ("**-42", format("{0:*>5}", -42));
-  EXPECT_EQ("***42", format("{0:*>5}", 42u));
-  EXPECT_EQ("**-42", format("{0:*>5}", -42l));
-  EXPECT_EQ("***42", format("{0:*>5}", 42ul));
-  EXPECT_EQ("**-42", format("{0:*>5}", -42ll));
-  EXPECT_EQ("***42", format("{0:*>5}", 42ull));
-  EXPECT_EQ("**-42", format("{0:*>5}", -42.0));
-  EXPECT_EQ("**-42", format("{0:*>5}", -42.0l));
-  EXPECT_EQ("c****", format("{0:*<5}", 'c'));
-  EXPECT_EQ("abc**", format("{0:*<5}", "abc"));
-  EXPECT_EQ("**0xface", format("{0:*>8}", reinterpret_cast<void*>(0xface)));
-  EXPECT_EQ("foo=", format("{:}=", "foo"));
-  EXPECT_EQ(std::string("\0\0\0*", 4), format(string_view("{:\0>4}", 6), '*'));
-}
-
-TEST(FormatterTest, PlusSign) {
-  EXPECT_EQ("+42", format("{0:+}", 42));
-  EXPECT_EQ("-42", format("{0:+}", -42));
-  EXPECT_EQ("+42", format("{0:+}", 42));
-  EXPECT_THROW_MSG(format("{0:+}", 42u),
-      format_error, "format specifier requires signed argument");
-  EXPECT_EQ("+42", format("{0:+}", 42l));
-  EXPECT_THROW_MSG(format("{0:+}", 42ul),
-      format_error, "format specifier requires signed argument");
-  EXPECT_EQ("+42", format("{0:+}", 42ll));
-  EXPECT_THROW_MSG(format("{0:+}", 42ull),
-      format_error, "format specifier requires signed argument");
-  EXPECT_EQ("+42", format("{0:+}", 42.0));
-  EXPECT_EQ("+42", format("{0:+}", 42.0l));
-  EXPECT_THROW_MSG(format("{0:+", 'c'),
-      format_error, "missing '}' in format string");
-  EXPECT_THROW_MSG(format("{0:+}", 'c'),
-      format_error, "invalid format specifier for char");
-  EXPECT_THROW_MSG(format("{0:+}", "abc"),
-      format_error, "format specifier requires numeric argument");
-  EXPECT_THROW_MSG(format("{0:+}", reinterpret_cast<void*>(0x42)),
-      format_error, "format specifier requires numeric argument");
-}
-
-TEST(FormatterTest, MinusSign) {
-  EXPECT_EQ("42", format("{0:-}", 42));
-  EXPECT_EQ("-42", format("{0:-}", -42));
-  EXPECT_EQ("42", format("{0:-}", 42));
-  EXPECT_THROW_MSG(format("{0:-}", 42u),
-      format_error, "format specifier requires signed argument");
-  EXPECT_EQ("42", format("{0:-}", 42l));
-  EXPECT_THROW_MSG(format("{0:-}", 42ul),
-      format_error, "format specifier requires signed argument");
-  EXPECT_EQ("42", format("{0:-}", 42ll));
-  EXPECT_THROW_MSG(format("{0:-}", 42ull),
-      format_error, "format specifier requires signed argument");
-  EXPECT_EQ("42", format("{0:-}", 42.0));
-  EXPECT_EQ("42", format("{0:-}", 42.0l));
-  EXPECT_THROW_MSG(format("{0:-", 'c'),
-      format_error, "missing '}' in format string");
-  EXPECT_THROW_MSG(format("{0:-}", 'c'),
-      format_error, "invalid format specifier for char");
-  EXPECT_THROW_MSG(format("{0:-}", "abc"),
-      format_error, "format specifier requires numeric argument");
-  EXPECT_THROW_MSG(format("{0:-}", reinterpret_cast<void*>(0x42)),
-      format_error, "format specifier requires numeric argument");
-}
-
-TEST(FormatterTest, SpaceSign) {
-  EXPECT_EQ(" 42", format("{0: }", 42));
-  EXPECT_EQ("-42", format("{0: }", -42));
-  EXPECT_EQ(" 42", format("{0: }", 42));
-  EXPECT_THROW_MSG(format("{0: }", 42u),
-      format_error, "format specifier requires signed argument");
-  EXPECT_EQ(" 42", format("{0: }", 42l));
-  EXPECT_THROW_MSG(format("{0: }", 42ul),
-      format_error, "format specifier requires signed argument");
-  EXPECT_EQ(" 42", format("{0: }", 42ll));
-  EXPECT_THROW_MSG(format("{0: }", 42ull),
-      format_error, "format specifier requires signed argument");
-  EXPECT_EQ(" 42", format("{0: }", 42.0));
-  EXPECT_EQ(" 42", format("{0: }", 42.0l));
-  EXPECT_THROW_MSG(format("{0: ", 'c'),
-      format_error, "missing '}' in format string");
-  EXPECT_THROW_MSG(format("{0: }", 'c'),
-      format_error, "invalid format specifier for char");
-  EXPECT_THROW_MSG(format("{0: }", "abc"),
-      format_error, "format specifier requires numeric argument");
-  EXPECT_THROW_MSG(format("{0: }", reinterpret_cast<void*>(0x42)),
-      format_error, "format specifier requires numeric argument");
-}
-
-TEST(FormatterTest, HashFlag) {
-  EXPECT_EQ("42", format("{0:#}", 42));
-  EXPECT_EQ("-42", format("{0:#}", -42));
-  EXPECT_EQ("0b101010", format("{0:#b}", 42));
-  EXPECT_EQ("0B101010", format("{0:#B}", 42));
-  EXPECT_EQ("-0b101010", format("{0:#b}", -42));
-  EXPECT_EQ("0x42", format("{0:#x}", 0x42));
-  EXPECT_EQ("0X42", format("{0:#X}", 0x42));
-  EXPECT_EQ("-0x42", format("{0:#x}", -0x42));
-  EXPECT_EQ("042", format("{0:#o}", 042));
-  EXPECT_EQ("-042", format("{0:#o}", -042));
-  EXPECT_EQ("42", format("{0:#}", 42u));
-  EXPECT_EQ("0x42", format("{0:#x}", 0x42u));
-  EXPECT_EQ("042", format("{0:#o}", 042u));
-
-  EXPECT_EQ("-42", format("{0:#}", -42l));
-  EXPECT_EQ("0x42", format("{0:#x}", 0x42l));
-  EXPECT_EQ("-0x42", format("{0:#x}", -0x42l));
-  EXPECT_EQ("042", format("{0:#o}", 042l));
-  EXPECT_EQ("-042", format("{0:#o}", -042l));
-  EXPECT_EQ("42", format("{0:#}", 42ul));
-  EXPECT_EQ("0x42", format("{0:#x}", 0x42ul));
-  EXPECT_EQ("042", format("{0:#o}", 042ul));
-
-  EXPECT_EQ("-42", format("{0:#}", -42ll));
-  EXPECT_EQ("0x42", format("{0:#x}", 0x42ll));
-  EXPECT_EQ("-0x42", format("{0:#x}", -0x42ll));
-  EXPECT_EQ("042", format("{0:#o}", 042ll));
-  EXPECT_EQ("-042", format("{0:#o}", -042ll));
-  EXPECT_EQ("42", format("{0:#}", 42ull));
-  EXPECT_EQ("0x42", format("{0:#x}", 0x42ull));
-  EXPECT_EQ("042", format("{0:#o}", 042ull));
-
-  if (FMT_USE_GRISU)
-    EXPECT_EQ("-42.0", format("{0:#}", -42.0));
-  else
-    EXPECT_EQ("-42.0000", format("{0:#}", -42.0));
-  EXPECT_EQ("-42.0000", format("{0:#}", -42.0l));
-  EXPECT_THROW_MSG(format("{0:#", 'c'),
-      format_error, "missing '}' in format string");
-  EXPECT_THROW_MSG(format("{0:#}", 'c'),
-      format_error, "invalid format specifier for char");
-  EXPECT_THROW_MSG(format("{0:#}", "abc"),
-      format_error, "format specifier requires numeric argument");
-  EXPECT_THROW_MSG(format("{0:#}", reinterpret_cast<void*>(0x42)),
-      format_error, "format specifier requires numeric argument");
-}
-
-TEST(FormatterTest, ZeroFlag) {
-  EXPECT_EQ("42", format("{0:0}", 42));
-  EXPECT_EQ("-0042", format("{0:05}", -42));
-  EXPECT_EQ("00042", format("{0:05}", 42u));
-  EXPECT_EQ("-0042", format("{0:05}", -42l));
-  EXPECT_EQ("00042", format("{0:05}", 42ul));
-  EXPECT_EQ("-0042", format("{0:05}", -42ll));
-  EXPECT_EQ("00042", format("{0:05}", 42ull));
-  EXPECT_EQ("-0042", format("{0:05}", -42.0));
-  EXPECT_EQ("-0042", format("{0:05}", -42.0l));
-  EXPECT_THROW_MSG(format("{0:0", 'c'),
-      format_error, "missing '}' in format string");
-  EXPECT_THROW_MSG(format("{0:05}", 'c'),
-      format_error, "invalid format specifier for char");
-  EXPECT_THROW_MSG(format("{0:05}", "abc"),
-      format_error, "format specifier requires numeric argument");
-  EXPECT_THROW_MSG(format("{0:05}", reinterpret_cast<void*>(0x42)),
-      format_error, "format specifier requires numeric argument");
-}
-
-TEST(FormatterTest, Width) {
-  char format_str[BUFFER_SIZE];
-  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);
-  format_str[size] = '}';
-  format_str[size + 1] = 0;
-  EXPECT_THROW_MSG(format(format_str, 0), format_error, "number is too big");
-
-  safe_sprintf(format_str, "{0:%u", INT_MAX + 1u);
-  EXPECT_THROW_MSG(format(format_str, 0), format_error, "number is too big");
-  safe_sprintf(format_str, "{0:%u}", INT_MAX + 1u);
-  EXPECT_THROW_MSG(format(format_str, 0), format_error, "number is too big");
-  EXPECT_EQ(" -42", format("{0:4}", -42));
-  EXPECT_EQ("   42", format("{0:5}", 42u));
-  EXPECT_EQ("   -42", format("{0:6}", -42l));
-  EXPECT_EQ("     42", format("{0:7}", 42ul));
-  EXPECT_EQ("   -42", format("{0:6}", -42ll));
-  EXPECT_EQ("     42", format("{0:7}", 42ull));
-  EXPECT_EQ("   -1.23", format("{0:8}", -1.23));
-  EXPECT_EQ("    -1.23", format("{0:9}", -1.23l));
-  EXPECT_EQ("    0xcafe", format("{0:10}", reinterpret_cast<void*>(0xcafe)));
-  EXPECT_EQ("x          ", format("{0:11}", 'x'));
-  EXPECT_EQ("str         ", format("{0:12}", "str"));
-}
-
-TEST(FormatterTest, RuntimeWidth) {
-  char format_str[BUFFER_SIZE];
-  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);
-  format_str[size] = '}';
-  format_str[size + 1] = 0;
-  EXPECT_THROW_MSG(format(format_str, 0), format_error, "number is too big");
-  format_str[size + 1] = '}';
-  format_str[size + 2] = 0;
-  EXPECT_THROW_MSG(format(format_str, 0), format_error, "number is too big");
-
-  EXPECT_THROW_MSG(format("{0:{", 0),
-      format_error, "invalid format string");
-  EXPECT_THROW_MSG(format("{0:{}", 0),
-      format_error, "cannot switch from manual to automatic argument indexing");
-  EXPECT_THROW_MSG(format("{0:{?}}", 0),
-      format_error, "invalid format string");
-  EXPECT_THROW_MSG(format("{0:{1}}", 0),
-      format_error, "argument index out of range");
-
-  EXPECT_THROW_MSG(format("{0:{0:}}", 0),
-      format_error, "invalid format string");
-
-  EXPECT_THROW_MSG(format("{0:{1}}", 0, -1),
-      format_error, "negative width");
-  EXPECT_THROW_MSG(format("{0:{1}}", 0, (INT_MAX + 1u)),
-      format_error, "number is too big");
-  EXPECT_THROW_MSG(format("{0:{1}}", 0, -1l),
-      format_error, "negative width");
-  if (fmt::internal::const_check(sizeof(long) > sizeof(int))) {
-    long value = INT_MAX;
-    EXPECT_THROW_MSG(format("{0:{1}}", 0, (value + 1)),
-        format_error, "number is too big");
-  }
-  EXPECT_THROW_MSG(format("{0:{1}}", 0, (INT_MAX + 1ul)),
-      format_error, "number is too big");
-
-  EXPECT_THROW_MSG(format("{0:{1}}", 0, '0'),
-      format_error, "width is not integer");
-  EXPECT_THROW_MSG(format("{0:{1}}", 0, 0.0),
-      format_error, "width is not integer");
-
-  EXPECT_EQ(" -42", format("{0:{1}}", -42, 4));
-  EXPECT_EQ("   42", format("{0:{1}}", 42u, 5));
-  EXPECT_EQ("   -42", format("{0:{1}}", -42l, 6));
-  EXPECT_EQ("     42", format("{0:{1}}", 42ul, 7));
-  EXPECT_EQ("   -42", format("{0:{1}}", -42ll, 6));
-  EXPECT_EQ("     42", format("{0:{1}}", 42ull, 7));
-  EXPECT_EQ("   -1.23", format("{0:{1}}", -1.23, 8));
-  EXPECT_EQ("    -1.23", format("{0:{1}}", -1.23l, 9));
-  EXPECT_EQ("    0xcafe",
-            format("{0:{1}}", reinterpret_cast<void*>(0xcafe), 10));
-  EXPECT_EQ("x          ", format("{0:{1}}", 'x', 11));
-  EXPECT_EQ("str         ", format("{0:{1}}", "str", 12));
-}
-
-TEST(FormatterTest, Precision) {
-  char format_str[BUFFER_SIZE];
-  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);
-  format_str[size] = '}';
-  format_str[size + 1] = 0;
-  EXPECT_THROW_MSG(format(format_str, 0), format_error, "number is too big");
-
-  safe_sprintf(format_str, "{0:.%u", INT_MAX + 1u);
-  EXPECT_THROW_MSG(format(format_str, 0), format_error, "number is too big");
-  safe_sprintf(format_str, "{0:.%u}", INT_MAX + 1u);
-  EXPECT_THROW_MSG(format(format_str, 0), format_error, "number is too big");
-
-  EXPECT_THROW_MSG(format("{0:.", 0),
-      format_error, "missing precision specifier");
-  EXPECT_THROW_MSG(format("{0:.}", 0),
-      format_error, "missing precision specifier");
-
-  EXPECT_THROW_MSG(format("{0:.2", 0),
-      format_error, "precision not allowed for this argument type");
-  EXPECT_THROW_MSG(format("{0:.2}", 42),
-      format_error, "precision not allowed for this argument type");
-  EXPECT_THROW_MSG(format("{0:.2f}", 42),
-      format_error, "precision not allowed for this argument type");
-  EXPECT_THROW_MSG(format("{0:.2}", 42u),
-      format_error, "precision not allowed for this argument type");
-  EXPECT_THROW_MSG(format("{0:.2f}", 42u),
-      format_error, "precision not allowed for this argument type");
-  EXPECT_THROW_MSG(format("{0:.2}", 42l),
-      format_error, "precision not allowed for this argument type");
-  EXPECT_THROW_MSG(format("{0:.2f}", 42l),
-      format_error, "precision not allowed for this argument type");
-  EXPECT_THROW_MSG(format("{0:.2}", 42ul),
-      format_error, "precision not allowed for this argument type");
-  EXPECT_THROW_MSG(format("{0:.2f}", 42ul),
-      format_error, "precision not allowed for this argument type");
-  EXPECT_THROW_MSG(format("{0:.2}", 42ll),
-      format_error, "precision not allowed for this argument type");
-  EXPECT_THROW_MSG(format("{0:.2f}", 42ll),
-      format_error, "precision not allowed for this argument type");
-  EXPECT_THROW_MSG(format("{0:.2}", 42ull),
-      format_error, "precision not allowed for this argument type");
-  EXPECT_THROW_MSG(format("{0:.2f}", 42ull),
-      format_error, "precision not allowed for this argument type");
-  EXPECT_THROW_MSG(format("{0:3.0}", 'x'),
-      format_error, "precision not allowed for this argument type");
-  EXPECT_EQ("1.2", format("{0:.2}", 1.2345));
-  EXPECT_EQ("1.2", format("{0:.2}", 1.2345l));
-
-  EXPECT_THROW_MSG(format("{0:.2}", reinterpret_cast<void*>(0xcafe)),
-      format_error, "precision not allowed for this argument type");
-  EXPECT_THROW_MSG(format("{0:.2f}", reinterpret_cast<void*>(0xcafe)),
-      format_error, "precision not allowed for this argument type");
-
-  EXPECT_EQ("st", format("{0:.2}", "str"));
-}
-
-TEST(FormatterTest, RuntimePrecision) {
-  char format_str[BUFFER_SIZE];
-  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);
-  format_str[size] = '}';
-  format_str[size + 1] = 0;
-  EXPECT_THROW_MSG(format(format_str, 0), format_error, "number is too big");
-  format_str[size + 1] = '}';
-  format_str[size + 2] = 0;
-  EXPECT_THROW_MSG(format(format_str, 0), format_error, "number is too big");
-
-  EXPECT_THROW_MSG(format("{0:.{", 0),
-      format_error, "invalid format string");
-  EXPECT_THROW_MSG(format("{0:.{}", 0),
-      format_error, "cannot switch from manual to automatic argument indexing");
-  EXPECT_THROW_MSG(format("{0:.{?}}", 0),
-      format_error, "invalid format string");
-  EXPECT_THROW_MSG(format("{0:.{1}", 0, 0),
-      format_error, "precision not allowed for this argument type");
-  EXPECT_THROW_MSG(format("{0:.{1}}", 0),
-      format_error, "argument index out of range");
-
-  EXPECT_THROW_MSG(format("{0:.{0:}}", 0),
-      format_error, "invalid format string");
-
-  EXPECT_THROW_MSG(format("{0:.{1}}", 0, -1),
-      format_error, "negative precision");
-  EXPECT_THROW_MSG(format("{0:.{1}}", 0, (INT_MAX + 1u)),
-      format_error, "number is too big");
-  EXPECT_THROW_MSG(format("{0:.{1}}", 0, -1l),
-      format_error, "negative precision");
-  if (fmt::internal::const_check(sizeof(long) > sizeof(int))) {
-    long value = INT_MAX;
-    EXPECT_THROW_MSG(format("{0:.{1}}", 0, (value + 1)),
-        format_error, "number is too big");
-  }
-  EXPECT_THROW_MSG(format("{0:.{1}}", 0, (INT_MAX + 1ul)),
-      format_error, "number is too big");
-
-  EXPECT_THROW_MSG(format("{0:.{1}}", 0, '0'),
-      format_error, "precision is not integer");
-  EXPECT_THROW_MSG(format("{0:.{1}}", 0, 0.0),
-      format_error, "precision is not integer");
-
-  EXPECT_THROW_MSG(format("{0:.{1}}", 42, 2),
-      format_error, "precision not allowed for this argument type");
-  EXPECT_THROW_MSG(format("{0:.{1}f}", 42, 2),
-      format_error, "precision not allowed for this argument type");
-  EXPECT_THROW_MSG(format("{0:.{1}}", 42u, 2),
-      format_error, "precision not allowed for this argument type");
-  EXPECT_THROW_MSG(format("{0:.{1}f}", 42u, 2),
-      format_error, "precision not allowed for this argument type");
-  EXPECT_THROW_MSG(format("{0:.{1}}", 42l, 2),
-      format_error, "precision not allowed for this argument type");
-  EXPECT_THROW_MSG(format("{0:.{1}f}", 42l, 2),
-      format_error, "precision not allowed for this argument type");
-  EXPECT_THROW_MSG(format("{0:.{1}}", 42ul, 2),
-      format_error, "precision not allowed for this argument type");
-  EXPECT_THROW_MSG(format("{0:.{1}f}", 42ul, 2),
-      format_error, "precision not allowed for this argument type");
-  EXPECT_THROW_MSG(format("{0:.{1}}", 42ll, 2),
-      format_error, "precision not allowed for this argument type");
-  EXPECT_THROW_MSG(format("{0:.{1}f}", 42ll, 2),
-      format_error, "precision not allowed for this argument type");
-  EXPECT_THROW_MSG(format("{0:.{1}}", 42ull, 2),
-      format_error, "precision not allowed for this argument type");
-  EXPECT_THROW_MSG(format("{0:.{1}f}", 42ull, 2),
-      format_error, "precision not allowed for this argument type");
-  EXPECT_THROW_MSG(format("{0:3.{1}}", 'x', 0),
-      format_error, "precision not allowed for this argument type");
-  EXPECT_EQ("1.2", format("{0:.{1}}", 1.2345, 2));
-  EXPECT_EQ("1.2", format("{1:.{0}}", 2, 1.2345l));
-
-  EXPECT_THROW_MSG(format("{0:.{1}}", reinterpret_cast<void*>(0xcafe), 2),
-      format_error, "precision not allowed for this argument type");
-  EXPECT_THROW_MSG(format("{0:.{1}f}", reinterpret_cast<void*>(0xcafe), 2),
-      format_error, "precision not allowed for this argument type");
-
-  EXPECT_EQ("st", format("{0:.{1}}", "str", 2));
-}
-
-template <typename T>
-void check_unknown_types(const T &value, const char *types, const char *) {
-  char format_str[BUFFER_SIZE];
-  const char *special = ".0123456789}";
-  for (int i = CHAR_MIN; i <= CHAR_MAX; ++i) {
-    char c = static_cast<char>(i);
-    if (std::strchr(types, c) || std::strchr(special, c) || !c) continue;
-    safe_sprintf(format_str, "{0:10%c}", c);
-    const char *message = "invalid type specifier";
-    EXPECT_THROW_MSG(format(format_str, value), format_error, message)
-      << format_str << " " << message;
-  }
-}
-
-TEST(BoolTest, FormatBool) {
-  EXPECT_EQ("true", format("{}", true));
-  EXPECT_EQ("false", format("{}", false));
-  EXPECT_EQ("1", format("{:d}", true));
-  EXPECT_EQ("true ", format("{:5}", true));
-  EXPECT_EQ(L"true", format(L"{}", true));
-}
-
-TEST(FormatterTest, FormatShort) {
-  short s = 42;
-  EXPECT_EQ("42", format("{0:d}", s));
-  unsigned short us = 42;
-  EXPECT_EQ("42", format("{0:d}", us));
-}
-
-TEST(FormatterTest, FormatInt) {
-  EXPECT_THROW_MSG(format("{0:v", 42),
-      format_error, "missing '}' in format string");
-  check_unknown_types(42, "bBdoxXn", "integer");
-}
-
-TEST(FormatterTest, FormatBin) {
-  EXPECT_EQ("0", format("{0:b}", 0));
-  EXPECT_EQ("101010", format("{0:b}", 42));
-  EXPECT_EQ("101010", format("{0:b}", 42u));
-  EXPECT_EQ("-101010", format("{0:b}", -42));
-  EXPECT_EQ("11000000111001", format("{0:b}", 12345));
-  EXPECT_EQ("10010001101000101011001111000", format("{0:b}", 0x12345678));
-  EXPECT_EQ("10010000101010111100110111101111", format("{0:b}", 0x90ABCDEF));
-  EXPECT_EQ("11111111111111111111111111111111",
-            format("{0:b}", std::numeric_limits<uint32_t>::max()));
-}
-
-TEST(FormatterTest, FormatDec) {
-  EXPECT_EQ("0", format("{0}", 0));
-  EXPECT_EQ("42", format("{0}", 42));
-  EXPECT_EQ("42", format("{0:d}", 42));
-  EXPECT_EQ("42", format("{0}", 42u));
-  EXPECT_EQ("-42", format("{0}", -42));
-  EXPECT_EQ("12345", format("{0}", 12345));
-  EXPECT_EQ("67890", format("{0}", 67890));
-  char buffer[BUFFER_SIZE];
-  safe_sprintf(buffer, "%d", INT_MIN);
-  EXPECT_EQ(buffer, format("{0}", INT_MIN));
-  safe_sprintf(buffer, "%d", INT_MAX);
-  EXPECT_EQ(buffer, format("{0}", INT_MAX));
-  safe_sprintf(buffer, "%u", UINT_MAX);
-  EXPECT_EQ(buffer, format("{0}", UINT_MAX));
-  safe_sprintf(buffer, "%ld", 0 - static_cast<unsigned long>(LONG_MIN));
-  EXPECT_EQ(buffer, format("{0}", LONG_MIN));
-  safe_sprintf(buffer, "%ld", LONG_MAX);
-  EXPECT_EQ(buffer, format("{0}", LONG_MAX));
-  safe_sprintf(buffer, "%lu", ULONG_MAX);
-  EXPECT_EQ(buffer, format("{0}", ULONG_MAX));
-}
-
-TEST(FormatterTest, FormatHex) {
-  EXPECT_EQ("0", format("{0:x}", 0));
-  EXPECT_EQ("42", format("{0:x}", 0x42));
-  EXPECT_EQ("42", format("{0:x}", 0x42u));
-  EXPECT_EQ("-42", format("{0:x}", -0x42));
-  EXPECT_EQ("12345678", format("{0:x}", 0x12345678));
-  EXPECT_EQ("90abcdef", format("{0:x}", 0x90abcdef));
-  EXPECT_EQ("12345678", format("{0:X}", 0x12345678));
-  EXPECT_EQ("90ABCDEF", format("{0:X}", 0x90ABCDEF));
-
-  char buffer[BUFFER_SIZE];
-  safe_sprintf(buffer, "-%x", 0 - static_cast<unsigned>(INT_MIN));
-  EXPECT_EQ(buffer, format("{0:x}", INT_MIN));
-  safe_sprintf(buffer, "%x", INT_MAX);
-  EXPECT_EQ(buffer, format("{0:x}", INT_MAX));
-  safe_sprintf(buffer, "%x", UINT_MAX);
-  EXPECT_EQ(buffer, format("{0:x}", UINT_MAX));
-  safe_sprintf(buffer, "-%lx", 0 - static_cast<unsigned long>(LONG_MIN));
-  EXPECT_EQ(buffer, format("{0:x}", LONG_MIN));
-  safe_sprintf(buffer, "%lx", LONG_MAX);
-  EXPECT_EQ(buffer, format("{0:x}", LONG_MAX));
-  safe_sprintf(buffer, "%lx", ULONG_MAX);
-  EXPECT_EQ(buffer, format("{0:x}", ULONG_MAX));
-}
-
-TEST(FormatterTest, FormatOct) {
-  EXPECT_EQ("0", format("{0:o}", 0));
-  EXPECT_EQ("42", format("{0:o}", 042));
-  EXPECT_EQ("42", format("{0:o}", 042u));
-  EXPECT_EQ("-42", format("{0:o}", -042));
-  EXPECT_EQ("12345670", format("{0:o}", 012345670));
-  char buffer[BUFFER_SIZE];
-  safe_sprintf(buffer, "-%o", 0 - static_cast<unsigned>(INT_MIN));
-  EXPECT_EQ(buffer, format("{0:o}", INT_MIN));
-  safe_sprintf(buffer, "%o", INT_MAX);
-  EXPECT_EQ(buffer, format("{0:o}", INT_MAX));
-  safe_sprintf(buffer, "%o", UINT_MAX);
-  EXPECT_EQ(buffer, format("{0:o}", UINT_MAX));
-  safe_sprintf(buffer, "-%lo", 0 - static_cast<unsigned long>(LONG_MIN));
-  EXPECT_EQ(buffer, format("{0:o}", LONG_MIN));
-  safe_sprintf(buffer, "%lo", LONG_MAX);
-  EXPECT_EQ(buffer, format("{0:o}", LONG_MAX));
-  safe_sprintf(buffer, "%lo", ULONG_MAX);
-  EXPECT_EQ(buffer, format("{0:o}", ULONG_MAX));
-}
-
-TEST(FormatterTest, FormatIntLocale) {
-  EXPECT_EQ("123", format("{:n}", 123));
-  EXPECT_EQ("1,234", format("{:n}", 1234));
-  EXPECT_EQ("1,234,567", format("{:n}", 1234567));
-  EXPECT_EQ("4,294,967,295",
-            format("{:n}", std::numeric_limits<uint32_t>::max()));
-}
-
-struct ConvertibleToLongLong {
-  operator long long() const { return 1LL << 32; }
-};
-
-TEST(FormatterTest, FormatConvertibleToLongLong) {
-  EXPECT_EQ("100000000", format("{:x}", ConvertibleToLongLong()));
-}
-
-TEST(FormatterTest, FormatFloat) {
-  EXPECT_EQ("392.500000", format("{0:f}", 392.5f));
-}
-
-TEST(FormatterTest, FormatDouble) {
-  check_unknown_types(1.2, "eEfFgGaA", "double");
-  EXPECT_EQ("0", format("{:}", 0.0));
-  EXPECT_EQ("0.000000", format("{:f}", 0.0));
-  EXPECT_EQ("0", format("{:g}", 0.0));
-  EXPECT_EQ("392.65", format("{:}", 392.65));
-  EXPECT_EQ("392.65", format("{:g}", 392.65));
-  EXPECT_EQ("392.65", format("{:G}", 392.65));
-  EXPECT_EQ("392.650000", format("{:f}", 392.65));
-  EXPECT_EQ("392.650000", format("{:F}", 392.65));
-  char buffer[BUFFER_SIZE];
-  safe_sprintf(buffer, "%e", 392.65);
-  EXPECT_EQ(buffer, format("{0:e}", 392.65));
-  safe_sprintf(buffer, "%E", 392.65);
-  EXPECT_EQ(buffer, format("{0:E}", 392.65));
-  EXPECT_EQ("+0000392.6", format("{0:+010.4g}", 392.65));
-  safe_sprintf(buffer, "%a", -42.0);
-  EXPECT_EQ(buffer, format("{:a}", -42.0));
-  safe_sprintf(buffer, "%A", -42.0);
-  EXPECT_EQ(buffer, format("{:A}", -42.0));
-}
-
-TEST(FormatterTest, FormatDoubleBigPrecision) {
-  // sprintf with big precision is broken in MSVC2013, so only test on Grisu.
-  if (FMT_USE_GRISU)
-    EXPECT_EQ(format("0.{:0<1000}", ""), format("{:.1000f}", 0.0));
-}
-
-TEST(FormatterTest, FormatNaN) {
-  double nan = std::numeric_limits<double>::quiet_NaN();
-  EXPECT_EQ("nan", format("{}", nan));
-  EXPECT_EQ("+nan", format("{:+}", nan));
-  EXPECT_EQ(" nan", format("{: }", nan));
-  EXPECT_EQ("NAN", format("{:F}", nan));
-  EXPECT_EQ("nan    ", format("{:<7}", nan));
-  EXPECT_EQ("  nan  ", format("{:^7}", nan));
-  EXPECT_EQ("    nan", format("{:>7}", nan));
-}
-
-TEST(FormatterTest, FormatInfinity) {
-  double inf = std::numeric_limits<double>::infinity();
-  EXPECT_EQ("inf", format("{}", inf));
-  EXPECT_EQ("+inf", format("{:+}", inf));
-  EXPECT_EQ("-inf", format("{}", -inf));
-  EXPECT_EQ(" inf", format("{: }", inf));
-  EXPECT_EQ("INF", format("{:F}", inf));
-  EXPECT_EQ("inf    ", format("{:<7}", inf));
-  EXPECT_EQ("  inf  ", format("{:^7}", inf));
-  EXPECT_EQ("    inf", format("{:>7}", inf));
-}
-
-TEST(FormatterTest, FormatLongDouble) {
-  EXPECT_EQ("0", format("{0:}", 0.0l));
-  EXPECT_EQ("0.000000", format("{0:f}", 0.0l));
-  EXPECT_EQ("392.65", format("{0:}", 392.65l));
-  EXPECT_EQ("392.65", format("{0:g}", 392.65l));
-  EXPECT_EQ("392.65", format("{0:G}", 392.65l));
-  EXPECT_EQ("392.650000", format("{0:f}", 392.65l));
-  EXPECT_EQ("392.650000", format("{0:F}", 392.65l));
-  char buffer[BUFFER_SIZE];
-  safe_sprintf(buffer, "%Le", 392.65l);
-  EXPECT_EQ(buffer, format("{0:e}", 392.65l));
-  EXPECT_EQ("+0000392.6", format("{0:+010.4g}", 392.64l));
-}
-
-TEST(FormatterTest, FormatChar) {
-  const char types[] = "cbBdoxXn";
-  check_unknown_types('a', types, "char");
-  EXPECT_EQ("a", format("{0}", 'a'));
-  EXPECT_EQ("z", format("{0:c}", 'z'));
-  EXPECT_EQ(L"a", format(L"{0}", 'a'));
-  int n = 'x';
-  for (const char *type = types + 1; *type; ++type) {
-    std::string format_str = fmt::format("{{:{}}}", *type);
-    EXPECT_EQ(fmt::format(format_str, n), fmt::format(format_str, 'x'));
-  }
-  EXPECT_EQ(fmt::format("{:02X}", n), fmt::format("{:02X}", 'x'));
-}
-
-TEST(FormatterTest, FormatUnsignedChar) {
-  EXPECT_EQ("42", format("{}", static_cast<unsigned char>(42)));
-  EXPECT_EQ("42", format("{}", static_cast<uint8_t>(42)));
-}
-
-TEST(FormatterTest, FormatWChar) {
-  EXPECT_EQ(L"a", format(L"{0}", L'a'));
-  // This shouldn't compile:
-  //format("{}", L'a');
-}
-
-TEST(FormatterTest, FormatCString) {
-  check_unknown_types("test", "sp", "string");
-  EXPECT_EQ("test", format("{0}", "test"));
-  EXPECT_EQ("test", format("{0:s}", "test"));
-  char nonconst[] = "nonconst";
-  EXPECT_EQ("nonconst", format("{0}", nonconst));
-  EXPECT_THROW_MSG(format("{0}", static_cast<const char*>(FMT_NULL)),
-      format_error, "string pointer is null");
-}
-
-TEST(FormatterTest, FormatSCharString) {
-  signed char str[] = "test";
-  EXPECT_EQ("test", format("{0:s}", str));
-  const signed char *const_str = str;
-  EXPECT_EQ("test", format("{0:s}", const_str));
-}
-
-TEST(FormatterTest, FormatUCharString) {
-  unsigned char str[] = "test";
-  EXPECT_EQ("test", format("{0:s}", str));
-  const unsigned char *const_str = str;
-  EXPECT_EQ("test", format("{0:s}", const_str));
-  unsigned char *ptr = str;
-  EXPECT_EQ("test", format("{0:s}", ptr));
-}
-
-TEST(FormatterTest, FormatPointer) {
-  check_unknown_types(reinterpret_cast<void*>(0x1234), "p", "pointer");
-  EXPECT_EQ("0x0", format("{0}", static_cast<void*>(FMT_NULL)));
-  EXPECT_EQ("0x1234", format("{0}", reinterpret_cast<void*>(0x1234)));
-  EXPECT_EQ("0x1234", format("{0:p}", reinterpret_cast<void*>(0x1234)));
-  EXPECT_EQ("0x" + std::string(sizeof(void*) * CHAR_BIT / 4, 'f'),
-      format("{0}", reinterpret_cast<void*>(~uintptr_t())));
-  EXPECT_EQ("0x1234", format("{}", fmt::ptr(reinterpret_cast<int*>(0x1234))));
-#if FMT_USE_NULLPTR
-  EXPECT_EQ("0x0", format("{}", FMT_NULL));
-#endif
-}
-
-TEST(FormatterTest, FormatString) {
-  EXPECT_EQ("test", format("{0}", std::string("test")));
-}
-
-TEST(FormatterTest, FormatStringView) {
-  EXPECT_EQ("test", format("{}", string_view("test")));
-  EXPECT_EQ("", format("{}", string_view()));
-}
-
-#ifdef FMT_USE_STD_STRING_VIEW
-TEST(FormatterTest, FormatStdStringView) {
-  EXPECT_EQ("test", format("{0}", std::string_view("test")));
-}
-#endif
-
 FMT_BEGIN_NAMESPACE
 template <>
 struct formatter<Date> {
@@ -1612,50 +717,6 @@ struct formatter<Date> {
 };
 FMT_END_NAMESPACE
 
-TEST(FormatterTest, FormatCustom) {
-  Date date(2012, 12, 9);
-  EXPECT_THROW_MSG(fmt::format("{:s}", date), format_error,
-                   "unknown format specifier");
-}
-
-class Answer {};
-
-FMT_BEGIN_NAMESPACE
-template <>
-struct formatter<Answer> : formatter<int> {
-  template <typename FormatContext>
-  auto format(Answer, FormatContext &ctx) -> decltype(ctx.out()) {
-    return formatter<int>::format(42, ctx);
-  }
-};
-FMT_END_NAMESPACE
-
-TEST(FormatterTest, CustomFormat) {
-  EXPECT_EQ("42", format("{0}", Answer()));
-  EXPECT_EQ("0042", format("{:04}", Answer()));
-}
-
-TEST(FormatterTest, CustomFormatTo) {
-  char buf[10] = {};
-  auto end = &*fmt::format_to(
-        fmt::internal::make_checked(buf, 10), "{}", Answer());
-  EXPECT_EQ(end, buf + 2);
-  EXPECT_STREQ(buf, "42");
-}
-
-TEST(FormatterTest, WideFormatString) {
-  EXPECT_EQ(L"42", format(L"{}", 42));
-  EXPECT_EQ(L"4.2", format(L"{}", 4.2));
-  EXPECT_EQ(L"abc", format(L"{}", L"abc"));
-  EXPECT_EQ(L"z", format(L"{}", L'z'));
-}
-
-TEST(FormatterTest, FormatStringFromSpeedTest) {
-  EXPECT_EQ("1.2340000000:0042:+3.13:str:0x3e8:X:%",
-      format("{0:0.10f}:{1:04}:{2:+g}:{3}:{4}:{5}:%",
-          1.234, 42, 3.13, "str", reinterpret_cast<void*>(1000), 'X'));
-}
-
 TEST(FormatterTest, FormatExamples) {
   std::string message = format("The answer is {}", 42);
   EXPECT_EQ("The answer is 42", message);
@@ -1802,33 +863,6 @@ TEST(FormatTest, Dynamic) {
   EXPECT_EQ("42 and abc1 and 1.2", result);
 }
 
-TEST(FormatTest, JoinArg) {
-  using fmt::join;
-  int v1[3] = { 1, 2, 3 };
-  std::vector<float> v2;
-  v2.push_back(1.2f);
-  v2.push_back(3.4f);
-  void *v3[2] = { &v1[0], &v1[1] };
-
-  EXPECT_EQ("(1, 2, 3)", format("({})", join(v1, v1 + 3, ", ")));
-  EXPECT_EQ("(1)", format("({})", join(v1, v1 + 1, ", ")));
-  EXPECT_EQ("()", format("({})", join(v1, v1, ", ")));
-  EXPECT_EQ("(001, 002, 003)", format("({:03})", join(v1, v1 + 3, ", ")));
-  EXPECT_EQ("(+01.20, +03.40)",
-            format("({:+06.2f})", join(v2.begin(), v2.end(), ", ")));
-
-  EXPECT_EQ(L"(1, 2, 3)", format(L"({})", join(v1, v1 + 3, L", ")));
-  EXPECT_EQ("1, 2, 3", format("{0:{1}}", join(v1, v1 + 3, ", "), 1));
-
-  EXPECT_EQ(format("{}, {}", v3[0], v3[1]),
-            format("{}", join(v3, v3 + 2, ", ")));
-
-#if FMT_USE_TRAILING_RETURN && (!FMT_GCC_VERSION || FMT_GCC_VERSION >= 405)
-  EXPECT_EQ("(1, 2, 3)", format("({})", join(v1, ", ")));
-  EXPECT_EQ("(+01.20, +03.40)", format("({:+06.2f})", join(v2, ", ")));
-#endif
-}
-
 template <typename T>
 std::string str(const T &value) {
   return fmt::format("{}", value);
@@ -1865,13 +899,6 @@ void print_error(const char *file, int line, const char *format,
   fmt::print(format, args...);
 }
 
-TEST(FormatTest, UnpackedArgs) {
-  EXPECT_EQ("0123456789abcdefg",
-            fmt::format("{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}",
-                        0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 'a', 'b', 'c', 'd', 'e',
-                        'f', 'g'));
-}
-
 #if FMT_USE_USER_DEFINED_LITERALS
 // Passing user-defined literals directly to EXPECT_EQ causes problems
 // with macro argument stringification (#) on some versions of GCC.
@@ -1911,10 +938,6 @@ TEST(FormatTest, UdlTemplate) {
 
 enum TestEnum { A };
 
-TEST(FormatTest, Enum) {
-  EXPECT_EQ("0", fmt::format("{}", A));
-}
-
 TEST(FormatTest, EnumFormatterUnambiguous) {
   fmt::formatter<TestEnum> f;
   ASSERT_GE(sizeof(f), 0); // use f to avoid compiler warning
@@ -1979,53 +1002,12 @@ TEST(FormatTest, CustomArgFormatter) {
   custom_format("{}", 42);
 }
 
-TEST(FormatTest, NonNullTerminatedFormatString) {
-  EXPECT_EQ("42", format(string_view("{}foo", 2), 42));
-}
-
 struct variant {
   enum {INT, STRING} type;
   explicit variant(int) : type(INT) {}
   explicit variant(const char *) : type(STRING) {}
 };
 
-FMT_BEGIN_NAMESPACE
-template <>
-struct formatter<variant> : dynamic_formatter<> {
-  auto format(variant value, format_context& ctx) -> decltype(ctx.out()) {
-    if (value.type == variant::INT)
-      return dynamic_formatter<>::format(42, ctx);
-    return dynamic_formatter<>::format("foo", ctx);
-  }
-};
-FMT_END_NAMESPACE
-
-TEST(FormatTest, DynamicFormatter) {
-  auto num = variant(42);
-  auto str = variant("foo");
-  EXPECT_EQ("42", format("{:d}", num));
-  EXPECT_EQ("foo", format("{:s}", str));
-  EXPECT_EQ(" 42 foo ", format("{:{}} {:{}}", num, 3, str, 4));
-  EXPECT_THROW_MSG(format("{0:{}}", num),
-      format_error, "cannot switch from manual to automatic argument indexing");
-  EXPECT_THROW_MSG(format("{:{0}}", num),
-      format_error, "cannot switch from automatic to manual argument indexing");
-  EXPECT_THROW_MSG(format("{:=}", str),
-      format_error, "format specifier requires numeric argument");
-  EXPECT_THROW_MSG(format("{:+}", str),
-      format_error, "format specifier requires numeric argument");
-  EXPECT_THROW_MSG(format("{:-}", str),
-      format_error, "format specifier requires numeric argument");
-  EXPECT_THROW_MSG(format("{: }", str),
-      format_error, "format specifier requires numeric argument");
-  EXPECT_THROW_MSG(format("{:#}", str),
-      format_error, "format specifier requires numeric argument");
-  EXPECT_THROW_MSG(format("{:0}", str),
-      format_error, "format specifier requires numeric argument");
-  EXPECT_THROW_MSG(format("{:.2}", num),
-      format_error, "precision not allowed for this argument type");
-}
-
 TEST(FormatTest, ToString) {
   EXPECT_EQ("42", fmt::to_string(42));
   EXPECT_EQ("0x1234", fmt::to_string(reinterpret_cast<void*>(0x1234)));
@@ -2111,14 +1093,15 @@ TEST(FormatTest, ConstexprParseArgID) {
 
 struct test_format_specs_handler {
   enum Result { NONE, PLUS, MINUS, SPACE, HASH, ZERO, ERROR };
+  typedef fmt::internal::arg_ref<char> arg_ref;
   Result res = NONE;
 
   fmt::alignment align_ = fmt::ALIGN_DEFAULT;
   char fill = 0;
   unsigned width = 0;
-  fmt::internal::arg_ref<char> width_ref;
+  arg_ref width_ref;
   unsigned precision = 0;
-  fmt::internal::arg_ref<char> precision_ref;
+  arg_ref precision_ref;
   char type = 0;
 
   // Workaround for MSVC2017 bug that results in "expression did not evaluate
@@ -2172,9 +1155,9 @@ TEST(FormatTest, ConstexprParseFormatSpecs) {
   static_assert(parse_test_specs("#").res == handler::HASH, "");
   static_assert(parse_test_specs("0").res == handler::ZERO, "");
   static_assert(parse_test_specs("42").width == 42, "");
-  static_assert(parse_test_specs("{42}").width_ref.index == 42, "");
+  static_assert(parse_test_specs("{42}").width_ref.val.index == 42, "");
   static_assert(parse_test_specs(".42").precision == 42, "");
-  static_assert(parse_test_specs(".{42}").precision_ref.index == 42, "");
+  static_assert(parse_test_specs(".{42}").precision_ref.val.index == 42, "");
   static_assert(parse_test_specs("d").type == 'd', "");
   static_assert(parse_test_specs("{<").res == handler::ERROR, "");
 }
@@ -2200,6 +1183,9 @@ struct test_context {
 
   FMT_CONSTEXPR test_context &parse_context() { return *this; }
   FMT_CONSTEXPR test_context error_handler() { return *this; }
+  FMT_CONSTEXPR fmt::basic_string_view<char> primary_format() {
+    return {"", 0u};
+  }
 };
 
 template <size_t N>
@@ -2231,9 +1217,11 @@ TEST(FormatTest, ConstexprSpecsHandler) {
 template <size_t N>
 FMT_CONSTEXPR fmt::internal::dynamic_format_specs<char>
     parse_dynamic_specs(const char (&s)[N]) {
-  fmt::internal::dynamic_format_specs<char> specs;
+  typedef fmt::internal::dynamic_format_specs<char> dynamic_specs;
+  dynamic_specs specs;
   test_context ctx{};
-  fmt::internal::dynamic_specs_handler<test_context> h(specs, ctx);
+  fmt::internal::dynamic_specs_handler<dynamic_specs, test_context> h(specs,
+                                                                      ctx);
   parse_format_specs(s, s + N, h);
   return specs;
 }
@@ -2247,11 +1235,11 @@ TEST(FormatTest, ConstexprDynamicSpecsHandler) {
   static_assert(parse_dynamic_specs("#").has(fmt::HASH_FLAG), "");
   static_assert(parse_dynamic_specs("0").align() == fmt::ALIGN_NUMERIC, "");
   static_assert(parse_dynamic_specs("42").width() == 42, "");
-  static_assert(parse_dynamic_specs("{}").width_ref.index == 33, "");
-  static_assert(parse_dynamic_specs("{42}").width_ref.index == 42, "");
+  static_assert(parse_dynamic_specs("{}").width_ref.val.index == 33, "");
+  static_assert(parse_dynamic_specs("{42}").width_ref.val.index == 42, "");
   static_assert(parse_dynamic_specs(".42").precision == 42, "");
-  static_assert(parse_dynamic_specs(".{}").precision_ref.index == 33, "");
-  static_assert(parse_dynamic_specs(".{42}").precision_ref.index == 42, "");
+  static_assert(parse_dynamic_specs(".{}").precision_ref.val.index == 33, "");
+  static_assert(parse_dynamic_specs(".{42}").precision_ref.val.index == 42, "");
   static_assert(parse_dynamic_specs("d").type == 'd', "");
 }
 
@@ -2273,9 +1261,9 @@ TEST(FormatTest, ConstexprSpecsChecker) {
   static_assert(check_specs("#").res == handler::HASH, "");
   static_assert(check_specs("0").res == handler::ZERO, "");
   static_assert(check_specs("42").width == 42, "");
-  static_assert(check_specs("{42}").width_ref.index == 42, "");
+  static_assert(check_specs("{42}").width_ref.val.index == 42, "");
   static_assert(check_specs(".42").precision == 42, "");
-  static_assert(check_specs(".{42}").precision_ref.index == 42, "");
+  static_assert(check_specs(".{42}").precision_ref.val.index == 42, "");
   static_assert(check_specs("d").type == 'd', "");
   static_assert(check_specs("{<").res == handler::ERROR, "");
 }
@@ -2455,18 +1443,3 @@ TEST(FormatTest, ConstructU8StringViewFromDataAndSize) {
   EXPECT_EQ(data[2], 'o');
 }
 
-#if FMT_USE_USER_DEFINED_LITERALS
-TEST(FormatTest, U8StringViewLiteral) {
-  using namespace fmt::literals;
-  fmt::u8string_view s = "ab"_u;
-  EXPECT_EQ(s.size(), 2u);
-  const fmt::char8_t *data = s.data();
-  EXPECT_EQ(data[0], 'a');
-  EXPECT_EQ(data[1], 'b');
-  EXPECT_EQ(format("{:*^5}"_u, "🤡"_u), "**🤡**"_u);
-}
-#endif
-
-TEST(FormatTest, FormatU8String) {
-  EXPECT_EQ(format(fmt::u8string_view("{}"), 42), fmt::u8string_view("42"));
-}
diff --git a/test/ostream-test.cc b/test/ostream-test.cc
index b93fedc6..1b1951dd 100644
--- a/test/ostream-test.cc
+++ b/test/ostream-test.cc
@@ -154,7 +154,7 @@ TEST(OStreamTest, WriteToOStreamMaxSize) {
     EXPECT_CALL(streambuf, xsputn(data, static_cast<std::streamsize>(n)))
         .WillOnce(testing::Return(max_streamsize));
     data += n;
-    size -= n;
+    size -= static_cast<std::size_t>(n);
   } while (size != 0);
   fmt::internal::write(os, buffer);
 }
diff --git a/test/prepare-test.cc b/test/prepare-test.cc
new file mode 100644
index 00000000..d1d671e6
--- /dev/null
+++ b/test/prepare-test.cc
@@ -0,0 +1,643 @@
+// Formatting library for C++ - formatting library tests
+//
+// Copyright (c) 2012 - present, Victor Zverovich
+// All rights reserved.
+//
+// For the license information refer to prepare.h.
+
+#include <cctype>
+#include <cfloat>
+#include <climits>
+#include <cmath>
+#include <cstring>
+#include <deque>
+#include <list>
+#include <memory>
+#include <stdint.h>
+#include <string>
+
+// Check if fmt/prepare.h compiles with windows.h included before it.
+#ifdef _WIN32
+#include <windows.h>
+#endif
+
+#include "fmt/prepare.h"
+#include "gmock.h"
+#include "gtest-extra.h"
+#include "mock-allocator.h"
+#include "util.h"
+
+#undef ERROR
+#undef min
+#undef max
+
+using testing::Return;
+using testing::StrictMock;
+
+class mock_parts_collector {
+public:
+  MOCK_METHOD1(add, void(fmt::format_part<char>));
+  MOCK_METHOD1(substitute_last, void(fmt::format_part<char>));
+  MOCK_METHOD0(last, fmt::format_part<char>());
+};
+
+FMT_BEGIN_NAMESPACE
+bool operator==(const internal::string_view_metadata &lhs,
+                const internal::string_view_metadata &rhs) {
+  return std::tie(lhs.offset_, lhs.size_) == std::tie(rhs.offset_, rhs.size_);
+}
+bool operator!=(const internal::string_view_metadata &lhs,
+                const internal::string_view_metadata &rhs) {
+  return !(lhs == rhs);
+}
+
+bool operator==(const format_part<char>::specification &lhs,
+                const format_part<char>::specification &rhs) {
+  if (lhs.arg_id.which != rhs.arg_id.which) {
+    return false;
+  }
+
+  typedef format_part<char>::argument_id::which_arg_id which_arg_id;
+  switch (lhs.arg_id.which) {
+  case which_arg_id::index: {
+    if (lhs.arg_id.val.index != rhs.arg_id.val.index) {
+      return false;
+    }
+  } break;
+  case which_arg_id::named_index: {
+    if (lhs.arg_id.val.named_index != rhs.arg_id.val.named_index) {
+      return false;
+    }
+  } break;
+  }
+
+  return std::tie(lhs.parsed_specs.width_, lhs.parsed_specs.fill_,
+                  lhs.parsed_specs.align_, lhs.parsed_specs.precision,
+                  lhs.parsed_specs.flags, lhs.parsed_specs.type) ==
+         std::tie(rhs.parsed_specs.width_, rhs.parsed_specs.fill_,
+                  rhs.parsed_specs.align_, rhs.parsed_specs.precision,
+                  rhs.parsed_specs.flags, rhs.parsed_specs.type);
+}
+
+bool operator!=(const format_part<char>::specification &lhs,
+                const format_part<char>::specification &rhs) {
+  return !(lhs == rhs);
+}
+
+bool operator==(const format_part<char> &lhs,
+                const fmt::format_part<char> &rhs) {
+  typedef format_part<char>::which_value which_value;
+
+  if (lhs.which != rhs.which ||
+      lhs.end_of_argument_id != rhs.end_of_argument_id) {
+    return false;
+  }
+
+  switch (lhs.which) {
+  case which_value::argument_id: {
+    return lhs.val.arg_id == rhs.val.arg_id;
+  }
+
+  case which_value::named_argument_id: {
+    return lhs.val.named_arg_id == rhs.val.named_arg_id;
+  }
+
+  case which_value::text: {
+    return lhs.val.text == rhs.val.text;
+  }
+
+  case which_value::specification: {
+    return lhs.val.spec == rhs.val.spec;
+  }
+  }
+
+  return false;
+}
+
+bool operator!=(const fmt::format_part<char> &lhs,
+                const fmt::format_part<char> &rhs) {
+  return !(lhs == rhs);
+}
+FMT_END_NAMESPACE
+
+TEST(PrepareTest, FormatPart_ComparisonOperators) {
+  typedef fmt::format_part<char> format_part;
+  typedef fmt::internal::dynamic_format_specs<char> prepared_specs;
+
+  {
+    const auto part = format_part(0u);
+    const auto other = format_part(0u);
+    EXPECT_EQ(part, other);
+  }
+  {
+    const auto lhs = format_part(0u);
+    const auto rhs = format_part(1u);
+    EXPECT_NE(lhs, rhs);
+  }
+  {
+    const auto lhs = format_part(fmt::internal::string_view_metadata(0, 42));
+    const auto rhs = format_part(fmt::internal::string_view_metadata(0, 42));
+    EXPECT_EQ(lhs, rhs);
+  }
+  {
+    const auto lhs = format_part(fmt::internal::string_view_metadata(0, 42));
+    const auto rhs = format_part(fmt::internal::string_view_metadata(0, 4422));
+    EXPECT_NE(lhs, rhs);
+  }
+  {
+    auto lhs = format_part(0u);
+    auto rhs = format_part(fmt::internal::string_view_metadata(0, 42));
+    EXPECT_NE(lhs, rhs);
+    rhs = format_part(fmt::internal::string_view_metadata(0, 0));
+    EXPECT_NE(lhs, rhs);
+  }
+  {
+    auto lhs = format_part(0u);
+    lhs.end_of_argument_id = 42;
+    auto rhs = format_part(0u);
+    rhs.end_of_argument_id = 42;
+    EXPECT_EQ(lhs, rhs);
+    rhs.end_of_argument_id = 13;
+    EXPECT_NE(lhs, rhs);
+  }
+  {
+    const auto specs_argument_id = 0u;
+    const auto specs_named_argument_id =
+        fmt::internal::string_view_metadata(0, 42);
+    auto specs = format_part::specification(0u);
+    auto lhs = format_part(specs);
+    auto rhs = format_part(specs);
+    EXPECT_EQ(lhs, rhs);
+
+    const auto specs_text = fmt::string_view("<10");
+    specs.parsed_specs = prepared_specs();
+    lhs = format_part(specs);
+    rhs = format_part(specs);
+    EXPECT_EQ(lhs, rhs);
+
+    specs = format_part::specification(specs_named_argument_id);
+    lhs = format_part(specs);
+    rhs = format_part(specs);
+    EXPECT_EQ(lhs, rhs);
+
+    specs.parsed_specs = prepared_specs();
+    lhs = format_part(specs);
+    rhs = format_part(specs);
+    EXPECT_EQ(lhs, rhs);
+
+    auto lhs_spec = format_part::specification(specs_argument_id);
+    auto rhs_spec = format_part::specification(specs_named_argument_id);
+    lhs = format_part(lhs_spec);
+    rhs = format_part(rhs_spec);
+    EXPECT_NE(lhs, rhs);
+
+    const auto lhs_specs_text = fmt::string_view("<10");
+    const auto rhs_specs_text = fmt::string_view("<42");
+    lhs_spec = format_part::specification(specs_argument_id);
+    rhs_spec = format_part::specification(specs_argument_id);
+    lhs_spec.parsed_specs.precision = 1;
+    rhs_spec.parsed_specs.precision = 2;
+    lhs = format_part(lhs_spec);
+    rhs = format_part(rhs_spec);
+    EXPECT_NE(lhs, rhs);
+  }
+  {
+    const auto specs_text = fmt::string_view{"<10"};
+    const auto specs_argument_id = 0u;
+    const auto specs_named_argument_id =
+        fmt::internal::string_view_metadata(0, 42);
+    auto specs = format_part::specification(specs_argument_id);
+    auto lhs = format_part(specs);
+    auto rhs = format_part(0u);
+    auto rhs2 = format_part(fmt::internal::string_view_metadata(0, 42));
+    EXPECT_NE(lhs, rhs);
+    EXPECT_NE(lhs, rhs2);
+
+    specs.parsed_specs = prepared_specs();
+    lhs = format_part{specs};
+    EXPECT_NE(lhs, rhs);
+    EXPECT_NE(lhs, rhs2);
+
+    specs = format_part::specification(specs_named_argument_id);
+    EXPECT_NE(lhs, rhs);
+    EXPECT_NE(lhs, rhs2);
+
+    specs.parsed_specs = prepared_specs();
+    lhs = format_part(specs);
+    EXPECT_NE(lhs, rhs);
+    EXPECT_NE(lhs, rhs2);
+  }
+}
+
+TEST(PrepareTest, FormatPreparationHandler_OnText_AddsPartWithText) {
+  typedef fmt::format_part<char> format_part;
+  typedef StrictMock<mock_parts_collector> parts_mock;
+
+  parts_mock parts;
+  const auto format = fmt::internal::to_string_view("text");
+  fmt::internal::format_preparation_handler<char, parts_mock> handler(format,
+                                                                      parts);
+
+  const auto expected_text = fmt::internal::string_view_metadata(
+      0u, static_cast<unsigned>(format.size()));
+  EXPECT_CALL(parts, add(format_part(expected_text)));
+
+  handler.on_text(format.begin(), format.end());
+}
+
+TEST(PrepareTest, FormatPreparationHandler_OnArgId_AddsPartWithIncrementedId) {
+  typedef fmt::format_part<char> format_part;
+  typedef StrictMock<mock_parts_collector> parts_mock;
+
+  parts_mock parts;
+  const auto format = fmt::internal::to_string_view("");
+  fmt::internal::format_preparation_handler<char, parts_mock> handler(format,
+                                                                      parts);
+
+  const auto expected_first_arg_id = 0u;
+  const auto expected_second_arg_id = 1u;
+  EXPECT_CALL(parts, add(format_part(expected_first_arg_id)));
+  EXPECT_CALL(parts, add(format_part(expected_second_arg_id)));
+
+  handler.on_arg_id();
+  handler.on_arg_id();
+}
+
+TEST(PrepareTest, FormatPreparationHandler_OnArgId_AddsPartWithPassedId) {
+  typedef fmt::format_part<char> format_part;
+  typedef StrictMock<mock_parts_collector> parts_mock;
+
+  parts_mock parts;
+  const auto format = fmt::internal::to_string_view("");
+  fmt::internal::format_preparation_handler<char, parts_mock> handler(format,
+                                                                      parts);
+
+  const auto expected_first_arg_id = 2u;
+  const auto expected_second_arg_id = 0u;
+  const auto expected_third_arg_id = 1u;
+  EXPECT_CALL(parts, add(format_part(expected_first_arg_id)));
+  EXPECT_CALL(parts, add(format_part(expected_second_arg_id)));
+  EXPECT_CALL(parts, add(format_part(expected_third_arg_id)));
+
+  handler.on_arg_id(expected_first_arg_id);
+  handler.on_arg_id(expected_second_arg_id);
+  handler.on_arg_id(expected_third_arg_id);
+}
+
+TEST(PrepareTest, FormatPreparationHandler_OnArgId_AddsPartWithPassedNamedId) {
+  typedef fmt::format_part<char> format_part;
+  typedef format_part::named_argument_id named_argument_id;
+  typedef StrictMock<mock_parts_collector> parts_mock;
+
+  parts_mock parts;
+  const auto format = fmt::internal::to_string_view("0123456789");
+  fmt::internal::format_preparation_handler<char, parts_mock> handler(format,
+                                                                      parts);
+
+  const auto expected_first_arg_id = fmt::string_view(format.data(), 1);
+  const auto expected_first_arg_view_metadata =
+      fmt::internal::string_view_metadata(0, 1);
+  const auto expected_second_arg_id = fmt::string_view(format.data() + 3, 2);
+  const auto expected_second_arg_view_metadata =
+      fmt::internal::string_view_metadata(3, 2);
+  const auto expected_third_arg_id = fmt::string_view(format.data() + 6, 3);
+  const auto expected_third_arg_view_metadata =
+      fmt::internal::string_view_metadata(6, 3);
+  EXPECT_CALL(parts, add(format_part(
+                         named_argument_id(expected_first_arg_view_metadata))));
+  EXPECT_CALL(
+      parts,
+      add(format_part(named_argument_id(expected_second_arg_view_metadata))));
+  EXPECT_CALL(parts, add(format_part(
+                         named_argument_id(expected_third_arg_view_metadata))));
+
+  handler.on_arg_id(expected_first_arg_id);
+  handler.on_arg_id(expected_second_arg_id);
+  handler.on_arg_id(expected_third_arg_id);
+}
+
+TEST(PrepareTest,
+     FormatPreparationHandler_OnReplacementField_SetsEndOfArgumentId) {
+  typedef fmt::format_part<char> format_part;
+  typedef StrictMock<mock_parts_collector> parts_mock;
+
+  const auto format = fmt::internal::to_string_view("{:<}");
+  parts_mock parts;
+
+  const auto last_part = format_part(0u);
+  EXPECT_CALL(parts, last()).WillOnce(Return(last_part));
+
+  auto expected_substitution_part = last_part;
+  expected_substitution_part.end_of_argument_id = 1;
+  EXPECT_CALL(parts, substitute_last(expected_substitution_part));
+
+  fmt::internal::format_preparation_handler<char, parts_mock> handler(format,
+                                                                      parts);
+
+  handler.on_replacement_field(format.data() + 1);
+}
+
+TEST(
+    PrepareTest,
+    FormatPreparationHandlerLastPartArgIndex_OnFormatSpecs_UpdatesLastAddedPart) {
+  typedef fmt::format_part<char> format_part;
+  typedef StrictMock<mock_parts_collector> parts_mock;
+
+  parts_mock parts;
+  const auto specification_test_text = fmt::internal::to_string_view("{:<10}");
+  const auto specification_offset = 2u;
+  const auto specification_begin_it =
+      specification_test_text.begin() + specification_offset;
+  fmt::internal::format_preparation_handler<char, parts_mock> handler(
+      specification_test_text, parts);
+
+  const auto last_part = format_part(0u);
+  format_part::specification expected_specification(0u);
+  fmt::internal::dynamic_format_specs<char> specs{};
+  specs.align_ = fmt::alignment::ALIGN_LEFT;
+  specs.width_ = 10;
+  expected_specification.parsed_specs = specs;
+
+  auto expected_substitution_part = format_part(expected_specification);
+  expected_substitution_part.end_of_argument_id = specification_offset;
+
+  EXPECT_CALL(parts, last()).WillOnce(Return(last_part));
+  EXPECT_CALL(parts, substitute_last(expected_substitution_part));
+
+  handler.on_format_specs(specification_begin_it,
+                          specification_test_text.end());
+}
+
+TEST(
+    PrepareTest,
+    FormatPreparationHandlerLastPartNamedArgIndex_OnFormatSpecs_UpdatesLastAddedPart) {
+  typedef fmt::format_part<char> format_part;
+  typedef StrictMock<mock_parts_collector> parts_mock;
+
+  parts_mock parts;
+  const auto specification_test_text = fmt::internal::to_string_view("{:<10}");
+  const auto specification_offset = 2u;
+  const auto specification_begin_it =
+      specification_test_text.begin() + specification_offset;
+  fmt::internal::format_preparation_handler<char, parts_mock> handler(
+      specification_test_text, parts);
+
+  const auto arg_id = fmt::internal::string_view_metadata(0, 42);
+  const auto last_part = format_part(format_part::named_argument_id(arg_id));
+  format_part::specification expected_specification(arg_id);
+  fmt::internal::dynamic_format_specs<char> specs{};
+  specs.align_ = fmt::alignment::ALIGN_LEFT;
+  specs.width_ = 10;
+  expected_specification.parsed_specs = specs;
+
+  auto expected_substitution_part = format_part(expected_specification);
+  expected_substitution_part.end_of_argument_id = specification_offset;
+
+  EXPECT_CALL(parts, last()).WillOnce(Return(last_part));
+  EXPECT_CALL(parts, substitute_last(expected_substitution_part));
+
+  handler.on_format_specs(specification_begin_it,
+                          specification_test_text.end());
+}
+
+// compiletime_prepared_parts_type_provider is useful only with relaxed
+// constexpr.
+#if FMT_USE_CONSTEXPR
+template <unsigned EXPECTED_PARTS_COUNT, typename Format>
+void check_prepared_parts_type(Format format) {
+  typedef fmt::internal::compiletime_prepared_parts_type_provider<decltype(
+      format)>
+      provider;
+  typedef typename provider::template format_parts_array<EXPECTED_PARTS_COUNT>
+      expected_parts_type;
+  static_assert(
+      std::is_same<typename provider::type, expected_parts_type>::value,
+      "CompileTimePreparedPartsTypeProvider test failed");
+}
+
+TEST(PrepareTest, CompileTimePreparedPartsTypeProvider) {
+  check_prepared_parts_type<1u>(FMT_STRING("text"));
+  check_prepared_parts_type<1u>(FMT_STRING("{}"));
+  check_prepared_parts_type<2u>(FMT_STRING("text{}"));
+  check_prepared_parts_type<2u>(FMT_STRING("{}text"));
+  check_prepared_parts_type<3u>(FMT_STRING("text{}text"));
+  check_prepared_parts_type<3u>(FMT_STRING("{:{}.{}} {:{}}"));
+
+  check_prepared_parts_type<3u>(FMT_STRING("{{{}}}"));  // '{', 'argument', '}'
+  check_prepared_parts_type<2u>(FMT_STRING("text{{"));  // 'text', '{'
+  check_prepared_parts_type<3u>(FMT_STRING("text{{ ")); // 'text', '{', ' '
+  check_prepared_parts_type<2u>(FMT_STRING("}}text"));  // '}', text
+  check_prepared_parts_type<2u>(FMT_STRING("text}}text")); // 'text}', 'text'
+  check_prepared_parts_type<4u>(
+      FMT_STRING("text{{}}text")); // 'text', '{', '}', 'text'
+}
+#endif
+
+// Use the struct instead of a function to workaround GCC 4.4's 'sorry,
+// unimplemented: mangling template_id_expr' issue.
+template <typename... Args> struct copied_prepared_format_creator {
+  static decltype(fmt::prepare<Args...>(fmt::internal::declval<std::string>()))
+  make(std::string format_str) {
+    auto prepared_format = fmt::prepare<Args...>(std::move(format_str));
+    auto copied_prepared_format = prepared_format;
+    prepared_format = fmt::prepare<Args...>("");
+
+    return copied_prepared_format;
+  }
+};
+
+TEST(PrepareTest, CopyPreparedFormat_InternalStringViewsAreNotInvalidated) {
+  auto prepared = copied_prepared_format_creator<int, std::string>::make(
+      "before {} middle {} after");
+  EXPECT_EQ("before 42 middle text after", prepared.format(42, "text"));
+
+  prepared = copied_prepared_format_creator<int, std::string>::make(
+      "before {0} middle {1} after");
+  EXPECT_EQ("before 42 middle text after", prepared.format(42, "text"));
+
+  {
+    typedef decltype(fmt::arg("first", 42)) argument0;
+    typedef decltype(fmt::arg("second", "text")) argument1;
+    auto named_prepared =
+        copied_prepared_format_creator<argument0, argument1>::make(
+            "before {first} middle {second} after");
+    EXPECT_EQ("before 42 middle text after",
+              named_prepared.format(fmt::arg("first", 42),
+                                    fmt::arg("second", "text")));
+  }
+  {
+    typedef decltype(fmt::arg("value", "12345")) argument0;
+    typedef decltype(fmt::arg("width", 10)) argument1;
+    auto named_prepared =
+        copied_prepared_format_creator<argument0, argument1>::make(
+            ">>>{value:>{width}}<<<");
+    EXPECT_EQ(">>>     12345<<<",
+              named_prepared.format(fmt::arg("value", "12345"),
+                                    fmt::arg("width", 10)));
+  }
+}
+
+TEST(PepareTest, ReusedPreparedFormatType) {
+  typedef fmt::prepared_format<std::string, int>::type prepared_format;
+
+  prepared_format prepared = fmt::prepare<prepared_format>("The {} is {}.");
+  EXPECT_EQ("The answer is 42.", prepared.format("answer", 42));
+  prepared = fmt::prepare<prepared_format>("40 {} 2 = {}");
+  EXPECT_EQ("40 + 2 = 42", prepared.format("+", 42));
+}
+
+TEST(PrepareTest, UserProvidedPartsContainerUnderlyingContainer) {
+  typedef fmt::format_part<char> format_part;
+  typedef fmt::parts_container<char, std::list<format_part>>::type
+      parts_container;
+  typedef fmt::basic_prepared_format<std::string, parts_container, std::string,
+                                     int>::type prepared_format;
+
+  prepared_format prepared = fmt::prepare<prepared_format>("The {} is {}.");
+  EXPECT_EQ("The answer is 42.", prepared.format("answer", 42));
+  prepared = fmt::prepare<prepared_format>("40 {} 2 = {}");
+  EXPECT_EQ("40 + 2 = 42", prepared.format("+", 42));
+}
+
+class custom_parts_container {
+public:
+  typedef fmt::format_part<char> format_part_type;
+
+private:
+  typedef std::deque<format_part_type> parts;
+
+public:
+  void add(format_part_type part) { parts_.push_back(std::move(part)); }
+
+  void substitute_last(format_part_type part) {
+    parts_.back() = std::move(part);
+  }
+
+  format_part_type last() { return parts_.back(); }
+
+  auto begin() -> decltype(fmt::internal::declval<parts>().begin()) {
+    return parts_.begin();
+  }
+
+  auto begin() const
+      -> decltype(fmt::internal::declval<const parts>().begin()) {
+    return parts_.begin();
+  }
+
+  auto end() -> decltype(fmt::internal::declval<parts>().begin()) {
+    return parts_.end();
+  }
+
+  auto end() const -> decltype(fmt::internal::declval<const parts>().begin()) {
+    return parts_.end();
+  }
+
+private:
+  parts parts_;
+};
+
+TEST(PrepareTest, UserProvidedPartsContainer) {
+  typedef fmt::basic_prepared_format<std::string, custom_parts_container,
+                                     std::string, int>::type prepared_format;
+
+  prepared_format prepared = fmt::prepare<prepared_format>("The {} is {}.");
+  EXPECT_EQ("The answer is 42.", prepared.format("answer", 42));
+  prepared = fmt::prepare<prepared_format>("40 {} 2 = {}");
+  EXPECT_EQ("40 + 2 = 42", prepared.format("+", 42));
+}
+
+TEST(PrepareTest, PassConstCharPointerFormat) {
+  const char *c_format = "test {}";
+  const auto prepared = fmt::prepare<int>(c_format);
+  EXPECT_EQ("test 42", prepared.format(42));
+  const wchar_t *wc_format = L"test {}";
+  const auto wprepared = fmt::prepare<int>(wc_format);
+  EXPECT_EQ(L"test 42", wprepared.format(42));
+}
+
+TEST(PrepareTest, PassCharArrayFormat) {
+  char c_format[] = "test {}";
+  const auto prepared = fmt::prepare<int>(c_format);
+  EXPECT_EQ("test 42", prepared.format(42));
+  wchar_t wc_format[] = L"test {}";
+  const auto wprepared = fmt::prepare<int>(wc_format);
+  EXPECT_EQ(L"test 42", wprepared.format(42));
+}
+
+TEST(PrepareTest, PassConstCharArrayFormat) {
+  const char c_format[] = "test {}";
+  const auto prepared = fmt::prepare<int>(c_format);
+  EXPECT_EQ("test 42", prepared.format(42));
+  const wchar_t wc_format[] = L"test {}";
+  const auto wprepared = fmt::prepare<int>(wc_format);
+  EXPECT_EQ(L"test 42", wprepared.format(42));
+}
+
+TEST(PrepareTest, PassStringLiteralFormat) {
+  const auto prepared = fmt::prepare<int>("test {}");
+  EXPECT_EQ("test 42", prepared.format(42));
+  const auto wprepared = fmt::prepare<int>(L"test {}");
+  EXPECT_EQ(L"test 42", wprepared.format(42));
+}
+
+TEST(PrepareTest, PassStringViewFormat) {
+  const auto prepared =
+      fmt::prepare<int>(fmt::basic_string_view<char>("test {}"));
+  EXPECT_EQ("test 42", prepared.format(42));
+  const auto wprepared =
+      fmt::prepare<int>(fmt::basic_string_view<wchar_t>(L"test {}"));
+  EXPECT_EQ(L"test 42", wprepared.format(42));
+}
+
+TEST(PrepareTest, PassBasicStringFormat) {
+  const auto prepared = fmt::prepare<int>(std::string("test {}"));
+  EXPECT_EQ("test 42", prepared.format(42));
+  const auto wprepared = fmt::prepare<int>(std::wstring(L"test {}"));
+  EXPECT_EQ(L"test 42", wprepared.format(42));
+}
+
+#if FMT_USE_CONSTEXPR
+TEST(PrepareTest, PassCompileString) {
+  const auto prepared = fmt::prepare<int>(FMT_STRING("test {}"));
+  EXPECT_EQ("test 42", prepared.format(42));
+  const auto wprepared = fmt::prepare<int>(FMT_STRING(L"test {}"));
+  EXPECT_EQ(L"test 42", wprepared.format(42));
+}
+#endif
+
+template <typename T> struct user_allocator {
+  typedef T value_type;
+  typedef value_type *pointer;
+  typedef const value_type *const_pointer;
+  typedef value_type &reference;
+  typedef const value_type &const_reference;
+  typedef std::size_t size_type;
+  typedef std::ptrdiff_t difference_type;
+
+  template <typename U> struct rebind { typedef user_allocator<U> other; };
+
+  user_allocator() = default;
+  ~user_allocator() = default;
+  template <typename U> user_allocator(const user_allocator<U> &) {}
+
+  pointer allocate(size_type cnt,
+                   typename std::allocator<void>::const_pointer = 0) {
+    return new value_type[cnt];
+  }
+
+  void deallocate(pointer p, size_type cnt) { delete[] p; }
+
+  void construct(pointer p, const value_type &val) { new (p) value_type(val); }
+
+  void destroy(pointer p) { (*p).~value_type(); }
+
+  bool operator==(const user_allocator &other) const { return true; }
+  bool operator!=(const user_allocator &other) const { return false; }
+};
+
+TEST(PrepareTest, PassUserTypeFormat) {
+  typedef std::basic_string<char, std::char_traits<char>, user_allocator<char>>
+      user_format;
+  const auto prepared = fmt::prepare<int>(user_format("test {}"));
+  EXPECT_EQ("test 42", prepared.format(42));
+}