Merge the std branch

2018-02-10 07:29:16 -08:00
parent 867b330966 a502decddb
commit b00053247c
57 changed files with 7517 additions and 7349 deletions
--- a/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
@@ -7,16 +7,10 @@
 # at http://code.google.com/p/googletest/wiki/FAQ for more details.
 add_library(gmock STATIC
  gmock-gtest-all.cc gmock/gmock.h gtest/gtest.h gtest/gtest-spi.h)
-target_compile_options(gmock PUBLIC ${CPP11_FLAG})
+target_compile_options(gmock PUBLIC ${CPP14_FLAG})
 target_compile_definitions(gmock PUBLIC GTEST_HAS_STD_WSTRING=1)
 target_include_directories(gmock PUBLIC .)

-# Workaround for Cygwin to make google-tests compile and run because the macro
-# _POSIX_C_SOURCE must be defined to allow fileno(), strdup(), fdopen() calls.
-if (CYGWIN)
-  target_compile_definitions(gmock PUBLIC _POSIX_C_SOURCE=200809)
-endif ()
-
 find_package(Threads)
 if (Threads_FOUND)
  target_link_libraries(gmock ${CMAKE_THREAD_LIBS_INIT})
@@ -38,6 +32,10 @@ if (CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
  target_compile_definitions(gmock PUBLIC GTEST_USE_OWN_TR1_TUPLE=1)
 endif ()

+# Silence MSVC tr1 deprecation warning in gmock.
+target_compile_definitions(gmock
+  PUBLIC _SILENCE_TR1_NAMESPACE_DEPRECATION_WARNING=0)
+
 #------------------------------------------------------------------------------
 # Build the actual library tests

@@ -86,16 +84,13 @@ function(add_fmt_test name)
 endfunction()

 add_fmt_test(assert-test)
-add_fmt_test(container-test)
 add_fmt_test(gtest-extra-test)
 add_fmt_test(format-test)
 add_fmt_test(format-impl-test)
 add_fmt_test(ostream-test)
 add_fmt_test(printf-test)
-add_fmt_test(string-test)
 add_fmt_test(time-test)
 add_fmt_test(util-test mock-allocator.h)
-add_fmt_test(macro-test)
 add_fmt_test(custom-formatter-test)

 # Enable stricter options for one test to make sure that the header is free of
@@ -106,8 +101,9 @@ endif ()

 if (HAVE_OPEN)
  add_fmt_executable(posix-mock-test
-    posix-mock-test.cc ../fmt/format.cc ../fmt/printf.cc ${TEST_MAIN_SRC})
-  target_include_directories(posix-mock-test PRIVATE ${PROJECT_SOURCE_DIR})
+    posix-mock-test.cc ../include/fmt/format.cc ${TEST_MAIN_SRC})
+  target_include_directories(
+    posix-mock-test PRIVATE ${PROJECT_SOURCE_DIR}/include)
  target_compile_definitions(posix-mock-test PRIVATE FMT_USE_FILE_DESCRIPTORS=1)
  target_link_libraries(posix-mock-test gmock)
  add_test(NAME posix-mock-test COMMAND posix-mock-test)
@@ -120,23 +116,28 @@ target_link_libraries(header-only-test gmock)
 if (TARGET fmt-header-only)
  target_link_libraries(header-only-test fmt-header-only)
 else ()
-  target_include_directories(header-only-test PRIVATE ${PROJECT_SOURCE_DIR})
+  target_include_directories(
+    header-only-test PRIVATE ${PROJECT_SOURCE_DIR}/include)
  target_compile_definitions(header-only-test PRIVATE FMT_HEADER_ONLY=1)
 endif ()

 # Test that the library can be compiled with exceptions disabled.
 check_cxx_compiler_flag(-fno-exceptions HAVE_FNO_EXCEPTIONS_FLAG)
 if (HAVE_FNO_EXCEPTIONS_FLAG)
-  add_library(noexception-test ../fmt/format.cc)
-  target_include_directories(noexception-test PRIVATE ${PROJECT_SOURCE_DIR})
+  add_library(noexception-test ../include/fmt/format.cc)
+  target_compile_options(noexception-test PUBLIC ${CPP14_FLAG})
+  target_include_directories(
+    noexception-test PRIVATE ${PROJECT_SOURCE_DIR}/include)
  target_compile_options(noexception-test PRIVATE -fno-exceptions)
 endif ()

 if (FMT_PEDANTIC)
  # Test that the library compiles without windows.h.
  if (CMAKE_SYSTEM_NAME STREQUAL "Windows")
-    add_library(no-windows-h-test ../fmt/format.cc)
-    target_include_directories(no-windows-h-test PRIVATE ${PROJECT_SOURCE_DIR})
+    add_library(no-windows-h-test ../include/fmt/format.cc)
+    target_compile_options(no-windows-h-test PUBLIC ${CPP14_FLAG})
+    target_include_directories(
+      no-windows-h-test PRIVATE ${PROJECT_SOURCE_DIR}/include)
    target_compile_definitions(no-windows-h-test PRIVATE FMT_USE_WINDOWS_H=0)
  endif ()

@@ -146,9 +147,9 @@ if (FMT_PEDANTIC)
    "${CMAKE_CURRENT_BINARY_DIR}/compile-test"
    --build-generator ${CMAKE_GENERATOR}
    --build-makeprogram ${CMAKE_MAKE_PROGRAM}
-    --build-options
+    --build-options 
    "-DCMAKE_CXX_COMPILER=${CMAKE_CXX_COMPILER}"
-    "-DCPP11_FLAG=${CPP11_FLAG}"
+    "-DCPP14_FLAG=${CPP14_FLAG}"
    "-DSUPPORTS_USER_DEFINED_LITERALS=${SUPPORTS_USER_DEFINED_LITERALS}")

  # test if the targets are findable from the build directory
@@ -161,6 +162,7 @@ if (FMT_PEDANTIC)
    --build-makeprogram ${CMAKE_MAKE_PROGRAM}
    --build-options
    "-DCMAKE_CXX_COMPILER=${CMAKE_CXX_COMPILER}"
+    "-DCPP14_FLAG=${CPP14_FLAG}"
    "-DFMT_DIR=${PROJECT_BINARY_DIR}"
    "-DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE}")

@@ -174,5 +176,6 @@ if (FMT_PEDANTIC)
    --build-makeprogram ${CMAKE_MAKE_PROGRAM}
    --build-options
    "-DCMAKE_CXX_COMPILER=${CMAKE_CXX_COMPILER}"
+    "-DCPP14_FLAG=${CPP14_FLAG}"
    "-DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE}")
 endif ()
--- a/test/add-subdirectory-test/CMakeLists.txt
+++ b/test/add-subdirectory-test/CMakeLists.txt
@@ -5,9 +5,11 @@ project(fmt-test)
 add_subdirectory(../.. fmt)

 add_executable(library-test "main.cc")
-target_link_libraries(library-test fmt::fmt)
+target_compile_options(library-test PUBLIC ${CPP14_FLAG})
+target_link_libraries(library-test fmt)

-if (TARGET fmt::fmt-header-only)
+if (TARGET fmt-header-only)
  add_executable(header-only-test "main.cc")
-  target_link_libraries(header-only-test fmt::fmt-header-only)
+  target_compile_options(header-only-test PUBLIC ${CPP14_FLAG})
+  target_link_libraries(header-only-test fmt-header-only)
 endif ()
--- a/test/assert-test.cc
+++ b/test/assert-test.cc
@@ -25,7 +25,7 @@
 SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

-#include "fmt/format.h"
+#include "fmt/core.h"
 #include "gtest/gtest.h"

 #if GTEST_HAS_DEATH_TEST
--- a/test/compile-test/CMakeLists.txt
+++ b/test/compile-test/CMakeLists.txt
@@ -3,8 +3,8 @@
 cmake_minimum_required(VERSION 2.8)

 include(CheckCXXSourceCompiles)
-set(CMAKE_REQUIRED_INCLUDES ${CMAKE_CURRENT_SOURCE_DIR}/../..)
-set(CMAKE_REQUIRED_FLAGS ${CPP11_FLAG})
+set(CMAKE_REQUIRED_INCLUDES ${CMAKE_CURRENT_SOURCE_DIR}/../../include)
+set(CMAKE_REQUIRED_FLAGS ${CPP14_FLAG})

 function (generate_source result fragment)
  set(${result} "
@@ -63,9 +63,6 @@ expect_compile_error("fmt::MemoryWriter() << fmt::pad(42, 5, L' ');")
 # Formatting a wide character with a narrow format string is forbidden.
 expect_compile_error("fmt::format(\"{}\", L'a';")

-expect_compile("FMT_STATIC_ASSERT(true, \"this should never happen\");")
-expect_compile_error("FMT_STATIC_ASSERT(0 > 1, \"oops\");")
-
 # Make sure that compiler features detected in the header
 # match the features detected in CMake.
 if (SUPPORTS_USER_DEFINED_LITERALS)
--- a/test/custom-formatter-test.cc
+++ b/test/custom-formatter-test.cc
@@ -10,59 +10,43 @@
 #include "fmt/printf.h"
 #include "gtest-extra.h"

-using fmt::BasicPrintfArgFormatter;
+using fmt::printf_arg_formatter;

 // A custom argument formatter that doesn't print `-` for floating-point values
 // rounded to 0.
-class CustomArgFormatter
-  : public fmt::BasicArgFormatter<CustomArgFormatter, char> {
+class CustomArgFormatter :
+    public fmt::arg_formatter<fmt::back_insert_range<fmt::internal::buffer>> {
 public:
-  CustomArgFormatter(fmt::BasicFormatter<char, CustomArgFormatter> &f,
-                     fmt::FormatSpec &s, const char *fmt)
-  : fmt::BasicArgFormatter<CustomArgFormatter, char>(f, s, fmt) {}
+  using range = fmt::back_insert_range<fmt::internal::buffer>;
+  using iterator = decltype(std::declval<range>().begin());
+  using base = fmt::arg_formatter<range>;

-  void visit_double(double value) {
+  CustomArgFormatter(fmt::basic_context<iterator, char> &ctx,
+                     fmt::format_specs &s)
+  : base(ctx, s) {}
+
+  using base::operator();
+
+  void operator()(double value) {
    if (round(value * pow(10, spec().precision())) == 0)
      value = 0;
-    fmt::BasicArgFormatter<CustomArgFormatter, char>::visit_double(value);
+    base::operator()(value);
  }
 };

-// A custom argument formatter that doesn't print `-` for floating-point values
-// rounded to 0.
-class CustomPrintfArgFormatter :
-    public BasicPrintfArgFormatter<CustomPrintfArgFormatter, char> {
- public:
-  typedef BasicPrintfArgFormatter<CustomPrintfArgFormatter, char> Base;
-
-  CustomPrintfArgFormatter(fmt::BasicWriter<char> &w, fmt::FormatSpec &spec)
-  : Base(w, spec) {}
-
-  void visit_double(double value) {
-    if (round(value * pow(10, spec().precision())) == 0)
-      value = 0;
-    Base::visit_double(value);
-  }
-};
-
-std::string custom_format(const char *format_str, fmt::ArgList args) {
-  fmt::MemoryWriter writer;
-  // Pass custom argument formatter as a template arg to BasicFormatter.
-  fmt::BasicFormatter<char, CustomArgFormatter> formatter(args, writer);
-  formatter.format(format_str);
-  return writer.str();
+std::string custom_vformat(fmt::string_view format_str, fmt::format_args args) {
+  fmt::memory_buffer buffer;
+  // Pass custom argument formatter as a template arg to vwrite.
+  fmt::do_vformat_to<CustomArgFormatter>(buffer, format_str, args);
+  return std::string(buffer.data(), buffer.size());
 }
-FMT_VARIADIC(std::string, custom_format, const char *)

-std::string custom_sprintf(const char* format_str, fmt::ArgList args){
-  fmt::MemoryWriter writer;
-  fmt::PrintfFormatter<char, CustomPrintfArgFormatter> formatter(args, writer);
-  formatter.format(format_str);
-  return writer.str();
+template <typename... Args>
+std::string custom_format(const char *format_str, const Args & ... args) {
+  auto va = fmt::make_args(args...);
+  return custom_vformat(format_str, va);
 }
-FMT_VARIADIC(std::string, custom_sprintf, const char*);

 TEST(CustomFormatterTest, Format) {
  EXPECT_EQ("0.00", custom_format("{:.2f}", -.00001));
-  EXPECT_EQ("0.00", custom_sprintf("%.2f", -.00001));
 }
--- a/test/find-package-test/CMakeLists.txt
+++ b/test/find-package-test/CMakeLists.txt
@@ -5,9 +5,11 @@ project(fmt-test)
 find_package(FMT REQUIRED)

 add_executable(library-test main.cc)
-target_link_libraries(library-test fmt::fmt)
+target_compile_options(library-test PUBLIC ${CPP14_FLAG})
+target_link_libraries(library-test fmt)

-if (TARGET fmt::fmt-header-only)
+if (TARGET fmt-header-only)
  add_executable(header-only-test main.cc)
-  target_link_libraries(header-only-test fmt::fmt-header-only)
+  target_compile_options(header-only-test PUBLIC ${CPP14_FLAG})
+  target_link_libraries(header-only-test fmt-header-only)
 endif ()
--- a/test/format-impl-test.cc
+++ b/test/format-impl-test.cc
@@ -29,9 +29,9 @@
 #undef FMT_SHARED
 #include "test-assert.h"

-// Include *.cc instead of *.h to test implementation-specific stuff.
+// Include format.cc instead of format.h to test implementation-specific stuff.
 #include "fmt/format.cc"
-#include "fmt/printf.cc"
+#include "fmt/printf.h"

 #include <algorithm>
 #include <cstring>
@@ -43,18 +43,29 @@
 #undef min
 #undef max

+template <typename T>
+struct ValueExtractor {
+  T operator()(T value) {
+    return value;
+  }
+
+  template <typename U>
+  T operator()(U) {
+    throw std::runtime_error(fmt::format("invalid type {}", typeid(U).name()));
+    return T();
+  }
+};
+
 TEST(FormatTest, ArgConverter) {
-  using fmt::internal::Arg;
-  Arg arg = Arg();
-  arg.type = Arg::LONG_LONG;
-  arg.long_long_value = std::numeric_limits<fmt::LongLong>::max();
-  fmt::internal::ArgConverter<fmt::LongLong>(arg, 'd').visit(arg);
-  EXPECT_EQ(Arg::LONG_LONG, arg.type);
+  long long value = std::numeric_limits<long long>::max();
+  auto arg = fmt::internal::make_arg<fmt::context>(value);
+  visit(fmt::internal::ArgConverter<long long, fmt::context>(arg, 'd'), arg);
+  EXPECT_EQ(value, visit(ValueExtractor<long long>(), arg));
 }

 TEST(FormatTest, FormatNegativeNaN) {
  double nan = std::numeric_limits<double>::quiet_NaN();
-  if (fmt::internal::FPUtil::isnegative(-nan))
+  if (fmt::internal::fputil::isnegative(-nan))
    EXPECT_EQ("-nan", fmt::format("{}", -nan));
  else
    fmt::print("Warning: compiler doesn't handle negative NaN correctly");
@@ -95,33 +106,33 @@ TEST(FormatTest, StrError) {
 TEST(FormatTest, FormatErrorCode) {
  std::string msg = "error 42", sep = ": ";
  {
-    fmt::MemoryWriter w;
-    w << "garbage";
-    fmt::format_error_code(w, 42, "test");
-    EXPECT_EQ("test: " + msg, w.str());
+    fmt::memory_buffer buffer;
+    format_to(buffer, "garbage");
+    fmt::format_error_code(buffer, 42, "test");
+    EXPECT_EQ("test: " + msg, to_string(buffer));
  }
  {
-    fmt::MemoryWriter w;
+    fmt::memory_buffer buffer;
    std::string prefix(
        fmt::internal::INLINE_BUFFER_SIZE - msg.size() - sep.size() + 1, 'x');
-    fmt::format_error_code(w, 42, prefix);
-    EXPECT_EQ(msg, w.str());
+    fmt::format_error_code(buffer, 42, prefix);
+    EXPECT_EQ(msg, to_string(buffer));
  }
  int codes[] = {42, -1};
  for (std::size_t i = 0, n = sizeof(codes) / sizeof(*codes); i < n; ++i) {
    // Test maximum buffer size.
    msg = fmt::format("error {}", codes[i]);
-    fmt::MemoryWriter w;
+    fmt::memory_buffer buffer;
    std::string prefix(
        fmt::internal::INLINE_BUFFER_SIZE - msg.size() - sep.size(), 'x');
-    fmt::format_error_code(w, codes[i], prefix);
-    EXPECT_EQ(prefix + sep + msg, w.str());
+    fmt::format_error_code(buffer, codes[i], prefix);
+    EXPECT_EQ(prefix + sep + msg, to_string(buffer));
    std::size_t size = fmt::internal::INLINE_BUFFER_SIZE;
-    EXPECT_EQ(size, w.size());
-    w.clear();
+    EXPECT_EQ(size, buffer.size());
+    buffer.resize(0);
    // Test with a message that doesn't fit into the buffer.
    prefix += 'x';
-    fmt::format_error_code(w, codes[i], prefix);
-    EXPECT_EQ(msg, w.str());
+    fmt::format_error_code(buffer, codes[i], prefix);
+    EXPECT_EQ(msg, to_string(buffer));
  }
 }
--- a/test/format-test.cc
+++ b/test/format-test.cc
--- a/test/gmock/gmock.h
+++ b/test/gmock/gmock.h
@@ -825,8 +825,9 @@ template <typename T> struct DecayArray<T[]> {
 // crashes).
 template <typename T>
 inline T Invalid() {
+  void *p = NULL;
  return const_cast<typename remove_reference<T>::type&>(
-      *static_cast<volatile typename remove_reference<T>::type*>(NULL));
+      *static_cast<volatile typename remove_reference<T>::type*>(p));
 }
 template <>
 inline void Invalid<void>() {}
--- a/test/gtest-extra-test.cc
+++ b/test/gtest-extra-test.cc
@@ -78,7 +78,7 @@ void throw_exception() {
 }

 void throw_system_error() {
-  throw fmt::SystemError(EDOM, "test");
+  throw fmt::system_error(EDOM, "test");
 }

 // Tests that when EXPECT_THROW_MSG fails, it evaluates its message argument
@@ -207,11 +207,11 @@ TEST(ExpectThrowTest, DoesNotGenerateUnreachableCodeWarning) {
 // EXPECT_SYSTEM_ERROR macro.
 TEST(ExpectSystemErrorTest, DoesNotGenerateUnreachableCodeWarning) {
  int n = 0;
-  EXPECT_SYSTEM_ERROR(throw fmt::SystemError(EDOM, "test"), EDOM, "test");
+  EXPECT_SYSTEM_ERROR(throw fmt::system_error(EDOM, "test"), EDOM, "test");
  EXPECT_NONFATAL_FAILURE(EXPECT_SYSTEM_ERROR(n++, EDOM, ""), "");
  EXPECT_NONFATAL_FAILURE(EXPECT_SYSTEM_ERROR(throw 1, EDOM, ""), "");
  EXPECT_NONFATAL_FAILURE(EXPECT_SYSTEM_ERROR(
-      throw fmt::SystemError(EDOM, "aaa"), EDOM, "bbb"), "");
+      throw fmt::system_error(EDOM, "aaa"), EDOM, "bbb"), "");
 }

 TEST(AssertionSyntaxTest, ExceptionAssertionBehavesLikeSingleStatement) {
@@ -268,10 +268,10 @@ TEST(ExpectTest, EXPECT_SYSTEM_ERROR) {
  EXPECT_NONFATAL_FAILURE(
      EXPECT_SYSTEM_ERROR(throw_exception(), EDOM, "test"),
      "Expected: throw_exception() throws an exception of "
-      "type fmt::SystemError.\n  Actual: it throws a different type.");
+      "type fmt::system_error.\n  Actual: it throws a different type.");
  EXPECT_NONFATAL_FAILURE(
      EXPECT_SYSTEM_ERROR(do_nothing(), EDOM, "test"),
-      "Expected: do_nothing() throws an exception of type fmt::SystemError.\n"
+      "Expected: do_nothing() throws an exception of type fmt::system_error.\n"
      "  Actual: it throws nothing.");
  EXPECT_NONFATAL_FAILURE(
      EXPECT_SYSTEM_ERROR(throw_system_error(), EDOM, "other"),
@@ -319,9 +319,9 @@ TEST(StreamingAssertionsTest, EXPECT_WRITE) {
 }

 TEST(UtilTest, FormatSystemError) {
-  fmt::MemoryWriter out;
+  fmt::memory_buffer out;
  fmt::format_system_error(out, EDOM, "test message");
-  EXPECT_EQ(out.str(), format_system_error(EDOM, "test message"));
+  EXPECT_EQ(to_string(out), format_system_error(EDOM, "test message"));
 }

 #if FMT_USE_FILE_DESCRIPTORS
--- a/test/gtest-extra.cc
+++ b/test/gtest-extra.cc
@@ -38,7 +38,7 @@ void OutputRedirect::flush() {
  int result = 0;
  FMT_RETRY(result, fflush(file_));
  if (result != 0)
-    throw fmt::SystemError(errno, "cannot flush stream");
+    throw fmt::system_error(errno, "cannot flush stream");
 }

 void OutputRedirect::restore() {
@@ -103,8 +103,8 @@ std::string read(File &f, std::size_t count) {

 #endif  // FMT_USE_FILE_DESCRIPTORS

-std::string format_system_error(int error_code, fmt::StringRef message) {
-  fmt::MemoryWriter out;
-  fmt::format_system_error(out, error_code, message);
-  return out.str();
+std::string format_system_error(int error_code, fmt::string_view message) {
+  fmt::memory_buffer out;
+  format_system_error(out, error_code, message);
+  return to_string(out);
 }
--- a/test/gtest-extra.h
+++ b/test/gtest-extra.h
@@ -31,7 +31,7 @@
 #include <string>
 #include <gmock/gmock.h>

-#include "fmt/format.h"
+#include "fmt/core.h"

 #ifndef FMT_USE_FILE_DESCRIPTORS
 # define FMT_USE_FILE_DESCRIPTORS 0
@@ -81,10 +81,10 @@
  FMT_TEST_THROW_(statement, expected_exception, \
      expected_message, GTEST_NONFATAL_FAILURE_)

-std::string format_system_error(int error_code, fmt::StringRef message);
+std::string format_system_error(int error_code, fmt::string_view message);

 #define EXPECT_SYSTEM_ERROR(statement, error_code, message) \
-  EXPECT_THROW_MSG(statement, fmt::SystemError, \
+  EXPECT_THROW_MSG(statement, fmt::system_error, \
      format_system_error(error_code, message))

 #if FMT_USE_FILE_DESCRIPTORS
--- a/test/header-only-test.cc
+++ b/test/header-only-test.cc
@@ -1,3 +1,3 @@
 // Header-only configuration test

-#include "fmt/format.h"
+#include "fmt/core.h"
--- a/test/header-only-test2.cc
+++ b/test/header-only-test2.cc
@@ -1,3 +1,3 @@
 // Additional translation unit for the header-only configuration test

-#include "fmt/format.h"
+#include "fmt/core.h"
--- a/test/macro-test.cc
+++ b/test/macro-test.cc
@@ -1,115 +0,0 @@
-/*
- Tests of variadic function emulation macros.
-
- Copyright (c) 2012-2014, 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.
- */
-
-#include <utility>
-#include <gtest/gtest.h>
-
-#define FMT_USE_VARIADIC_TEMPLATES 0
-#include "fmt/format.h"
-
-#define IDENTITY(x) x
-
-TEST(UtilTest, Gen) {
-  int values[] = {FMT_GEN(10, IDENTITY)};
-  for (int i = 0; i < 10; ++i)
-    EXPECT_EQ(i, values[i]);
-}
-
-#define MAKE_PAIR(x, y) std::make_pair(x, y)
-
-TEST(UtilTest, ForEach) {
-  std::pair<char, int> values[] = {
-      FMT_FOR_EACH10(MAKE_PAIR, 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j')
-  };
-  for (int i = 0; i < 10; ++i) {
-    EXPECT_EQ('a' + i, values[i].first);
-    EXPECT_EQ(i, values[i].second);
-  }
-}
-
-TEST(UtilTest, NArg) {
-  EXPECT_EQ(1, FMT_NARG(a));
-  EXPECT_EQ(2, FMT_NARG(a, b));
-  EXPECT_EQ(3, FMT_NARG(a, b, c));
-  EXPECT_EQ(4, FMT_NARG(a, b, c, d));
-  EXPECT_EQ(5, FMT_NARG(a, b, c, d, e));
-  EXPECT_EQ(6, FMT_NARG(a, b, c, d, e, f));
-  EXPECT_EQ(7, FMT_NARG(a, b, c, d, e, f, g));
-  EXPECT_EQ(8, FMT_NARG(a, b, c, d, e, f, g, h));
-  EXPECT_EQ(9, FMT_NARG(a, b, c, d, e, f, g, h, i));
-  EXPECT_EQ(10, FMT_NARG(a, b, c, d, e, f, g, h, i, j));
-}
-
-int result;
-
-#define MAKE_TEST(func) \
-  void func(const char *, const fmt::ArgList &args) { \
-    result = 0; \
-    for (unsigned i = 0; args[i].type; ++i) \
-      result += args[i].int_value; \
-  }
-
-MAKE_TEST(test_func)
-
-typedef char Char;
-FMT_WRAP1(test_func, const char *, 1)
-
-TEST(UtilTest, Wrap1) {
-  result = 0;
-  test_func("", 42);
-  EXPECT_EQ(42, result);
-}
-
-MAKE_TEST(test_variadic_void)
-FMT_VARIADIC_VOID(test_variadic_void, const char *)
-
-TEST(UtilTest, VariadicVoid) {
-  result = 0;
-  test_variadic_void("", 10, 20, 30, 40, 50, 60, 70, 80, 90, 100);
-  EXPECT_EQ(550, result);
-}
-
-template <int>
-struct S {};
-
-#define GET_TYPE(n) S<n>
-
-int test_variadic(FMT_GEN(10, GET_TYPE), const fmt::ArgList &args) { \
-  int result = 0; \
-  for (unsigned i = 0; args[i].type; ++i) \
-    result += args[i].int_value; \
-  return result;
-}
-FMT_VARIADIC(int, test_variadic,
-    S<0>, S<1>, S<2>, S<3>, S<4>, S<5>, S<6>, S<7>, S<8>, S<9>)
-
-#define MAKE_ARG(n) S<n>()
-
-TEST(UtilTest, Variadic) {
-  EXPECT_EQ(550, test_variadic(FMT_GEN(10, MAKE_ARG),
-      10, 20, 30, 40, 50, 60, 70, 80, 90, 100));
-}
--- a/test/mock-allocator.h
+++ b/test/mock-allocator.h
@@ -36,8 +36,8 @@ class MockAllocator {
  MockAllocator() {}
  MockAllocator(const MockAllocator &) {}
  typedef T value_type;
-  MOCK_METHOD2_T(allocate, T *(std::size_t n, const void *h));
-  MOCK_METHOD2_T(deallocate, void (T *p, std::size_t n));
+  MOCK_METHOD1_T(allocate, T* (std::size_t n));
+  MOCK_METHOD2_T(deallocate, void (T* p, std::size_t n));
 };

 template <typename Allocator>
@@ -78,14 +78,10 @@ class AllocatorRef {

  Allocator *get() const { return alloc_; }

-  value_type *allocate(std::size_t n,  const void *h) {
-#if FMT_USE_ALLOCATOR_TRAITS
-    return std::allocator_traits<Allocator>::allocate(*alloc_, n, h);
-#else
-    return alloc_->allocate(n, h);
-#endif
+  value_type* allocate(std::size_t n) {
+    return fmt::internal::allocate(*alloc_, n);
  }
-  void deallocate(value_type *p, std::size_t n) { alloc_->deallocate(p, n); }
+  void deallocate(value_type* p, std::size_t n) { alloc_->deallocate(p, n); }
 };

 #endif  // FMT_MOCK_ALLOCATOR_H_
--- a/test/ostream-test.cc
+++ b/test/ostream-test.cc
@@ -33,7 +33,7 @@
 #include "util.h"

 using fmt::format;
-using fmt::FormatError;
+using fmt::format_error;

 std::ostream &operator<<(std::ostream &os, const Date &d) {
  os << d.year() << '-' << d.month() << '-' << d.day();
@@ -53,25 +53,26 @@ std::ostream &operator<<(std::ostream &os, TestEnum) {
 enum TestEnum2 {A};

 TEST(OStreamTest, Enum) {
-  EXPECT_FALSE(fmt::internal::ConvertToInt<TestEnum>::value);
+  EXPECT_FALSE(fmt::internal::convert_to_int<TestEnum>::value);
  EXPECT_EQ("TestEnum", fmt::format("{}", TestEnum()));
  EXPECT_EQ("0", fmt::format("{}", A));
 }

-struct TestArgFormatter : fmt::BasicArgFormatter<TestArgFormatter, char> {
-  TestArgFormatter(fmt::BasicFormatter<char, TestArgFormatter> &f,
-                   fmt::FormatSpec &s, const char *fmt)
-    : fmt::BasicArgFormatter<TestArgFormatter, char>(f, s, fmt) {}
+using range = fmt::back_insert_range<fmt::internal::buffer>;
+
+struct test_arg_formatter: fmt::arg_formatter<range> {
+  test_arg_formatter(fmt::context &ctx, fmt::format_specs &s)
+    : fmt::arg_formatter<range>(ctx, s) {}
 };

 TEST(OStreamTest, CustomArg) {
-  fmt::MemoryWriter writer;
-  typedef fmt::BasicFormatter<char, TestArgFormatter> Formatter;
-  Formatter formatter(fmt::ArgList(), writer);
-  fmt::FormatSpec spec;
-  TestArgFormatter af(formatter, spec, "}");
-  af.visit(fmt::internal::MakeArg<Formatter>(TestEnum()));
-  EXPECT_EQ("TestEnum", writer.str());
+  fmt::memory_buffer buffer;
+  fmt::internal::buffer &base = buffer;
+  fmt::context ctx(std::back_inserter(base), "", fmt::format_args());
+  fmt::format_specs spec;
+  test_arg_formatter af(ctx, spec);
+  visit(af, fmt::internal::make_arg<fmt::context>(TestEnum()));
+  EXPECT_EQ("TestEnum", std::string(buffer.data(), buffer.size()));
 }

 TEST(OStreamTest, Format) {
@@ -87,19 +88,19 @@ TEST(OStreamTest, FormatSpecs) {
  EXPECT_EQ("def  ", format("{0:<5}", TestString("def")));
  EXPECT_EQ("  def", format("{0:>5}", TestString("def")));
  EXPECT_THROW_MSG(format("{0:=5}", TestString("def")),
-      FormatError, "format specifier '=' requires numeric argument");
+      format_error, "format specifier requires numeric argument");
  EXPECT_EQ(" def ", format("{0:^5}", TestString("def")));
  EXPECT_EQ("def**", format("{0:*<5}", TestString("def")));
  EXPECT_THROW_MSG(format("{0:+}", TestString()),
-      FormatError, "format specifier '+' requires numeric argument");
+      format_error, "format specifier requires numeric argument");
  EXPECT_THROW_MSG(format("{0:-}", TestString()),
-      FormatError, "format specifier '-' requires numeric argument");
+      format_error, "format specifier requires numeric argument");
  EXPECT_THROW_MSG(format("{0: }", TestString()),
-      FormatError, "format specifier ' ' requires numeric argument");
+      format_error, "format specifier requires numeric argument");
  EXPECT_THROW_MSG(format("{0:#}", TestString()),
-      FormatError, "format specifier '#' requires numeric argument");
+      format_error, "format specifier requires numeric argument");
  EXPECT_THROW_MSG(format("{0:05}", TestString()),
-      FormatError, "format specifier '0' requires numeric argument");
+      format_error, "format specifier requires numeric argument");
  EXPECT_EQ("test         ", format("{0:13}", TestString("test")));
  EXPECT_EQ("test         ", format("{0:{1}}", TestString("test"), 13));
  EXPECT_EQ("te", format("{0:.2}", TestString("test")));
@@ -123,9 +124,10 @@ TEST(OStreamTest, Print) {

 TEST(OStreamTest, WriteToOStream) {
  std::ostringstream os;
-  fmt::MemoryWriter w;
-  w << "foo";
-  fmt::internal::write(os, w);
+  fmt::memory_buffer buffer;
+  const char *foo = "foo";
+  buffer.append(foo, foo + std::strlen(foo));
+  fmt::internal::write(os, buffer);
  EXPECT_EQ("foo", os.str());
 }

@@ -135,55 +137,34 @@ TEST(OStreamTest, WriteToOStreamMaxSize) {
  if (max_size <= fmt::internal::to_unsigned(max_streamsize))
    return;

-  class TestWriter : public fmt::BasicWriter<char> {
-   private:
-    struct TestBuffer : fmt::Buffer<char> {
-      explicit TestBuffer(std::size_t size) { size_ = size; }
-      void grow(std::size_t) {}
-    } buffer_;
-   public:
-    explicit TestWriter(std::size_t size)
-      : fmt::BasicWriter<char>(buffer_), buffer_(size) {}
-  } w(max_size);
+  struct test_buffer : fmt::internal::buffer {
+    explicit test_buffer(std::size_t size) { resize(size); }
+    void grow(std::size_t) {}
+  } buffer(max_size);

-  struct MockStreamBuf : std::streambuf {
+  struct mock_streambuf : std::streambuf {
    MOCK_METHOD2(xsputn, std::streamsize (const void *s, std::streamsize n));
    std::streamsize xsputn(const char *s, std::streamsize n) {
      const void *v = s;
      return xsputn(v, n);
    }
-  } buffer;
+  } streambuf;

-  struct TestOStream : std::ostream {
-    explicit TestOStream(MockStreamBuf &buffer) : std::ostream(&buffer) {}
-  } os(buffer);
+  struct test_ostream : std::ostream {
+    explicit test_ostream(mock_streambuf &buffer) : std::ostream(&buffer) {}
+  } os(streambuf);

  testing::InSequence sequence;
  const char *data = 0;
  std::size_t size = max_size;
  do {
-    typedef fmt::internal::MakeUnsigned<std::streamsize>::Type UStreamSize;
-    UStreamSize n = std::min<UStreamSize>(
+    typedef std::make_unsigned<std::streamsize>::type ustreamsize;
+    ustreamsize n = std::min<ustreamsize>(
          size, fmt::internal::to_unsigned(max_streamsize));
-    EXPECT_CALL(buffer, xsputn(data, static_cast<std::streamsize>(n)))
+    EXPECT_CALL(streambuf, xsputn(data, static_cast<std::streamsize>(n)))
        .WillOnce(testing::Return(max_streamsize));
    data += n;
    size -= static_cast<std::size_t>(n);
  } while (size != 0);
-  fmt::internal::write(os, w);
-}
-
-struct ConvertibleToInt {
-  template <typename ValueType>
-  operator ValueType() const {
-    return 0;
-  }
-
-  friend std::ostream &operator<<(std::ostream &o, ConvertibleToInt) {
-    return o << "foo";
-  }
-};
-
-TEST(FormatTest, FormatConvertibleToInt) {
-  EXPECT_EQ("foo", fmt::format("{}", ConvertibleToInt()));
+  fmt::internal::write(os, buffer);
 }
--- a/test/posix-mock-test.cc
+++ b/test/posix-mock-test.cc
@@ -213,17 +213,11 @@ int (test::fileno)(FILE *stream) {
 # define EXPECT_EQ_POSIX(expected, actual)
 #endif

-void write_file(fmt::CStringRef filename, fmt::StringRef content) {
+void write_file(fmt::cstring_view filename, fmt::string_view content) {
  fmt::BufferedFile f(filename, "w");
  f.print("{}", content);
 }

-TEST(UtilTest, StaticAssert) {
-  FMT_STATIC_ASSERT(true, "success");
-  // Static assertion failure is tested in compile-test because it causes
-  // a compile-time error.
-}
-
 TEST(UtilTest, GetPageSize) {
 #ifdef _WIN32
  SYSTEM_INFO si = {};
@@ -277,13 +271,13 @@ TEST(FileTest, Size) {
  write_file("test", content);
  File f("test", File::RDONLY);
  EXPECT_GE(f.size(), 0);
-  EXPECT_EQ(content.size(), static_cast<fmt::ULongLong>(f.size()));
+  EXPECT_EQ(content.size(), static_cast<unsigned long long>(f.size()));
 #ifdef _WIN32
-  fmt::MemoryWriter message;
+  fmt::memory_buffer message;
  fmt::internal::format_windows_error(
      message, ERROR_ACCESS_DENIED, "cannot get file size");
  fstat_sim = ERROR;
-  EXPECT_THROW_MSG(f.size(), fmt::WindowsError, message.str());
+  EXPECT_THROW_MSG(f.size(), fmt::windows_error, fmt::to_string(message));
  fstat_sim = NONE;
 #else
  f.close();
@@ -340,7 +334,7 @@ TEST(FileTest, ConvertReadCount) {
    ++size;
  read_count = 1;
  read_nbyte = 0;
-  EXPECT_THROW(read_end.read(&c, size), fmt::SystemError);
+  EXPECT_THROW(read_end.read(&c, size), fmt::system_error);
  read_count = 0;
  EXPECT_EQ(UINT_MAX, read_nbyte);
 }
@@ -354,7 +348,7 @@ TEST(FileTest, ConvertWriteCount) {
    ++size;
  write_count = 1;
  write_nbyte = 0;
-  EXPECT_THROW(write_end.write(&c, size), fmt::SystemError);
+  EXPECT_THROW(write_end.write(&c, size), fmt::system_error);
  write_count = 0;
  EXPECT_EQ(UINT_MAX, write_nbyte);
 }
@@ -415,7 +409,7 @@ TEST(BufferedFileTest, OpenRetry) {
 #ifndef _WIN32
  char c = 0;
  if (fread(&c, 1, 1, f->get()) < 1)
-    throw fmt::SystemError(errno, "fread failed");
+    throw fmt::system_error(errno, "fread failed");
 #endif
 }

--- a/test/posix-test.cc
+++ b/test/posix-test.cc
@@ -65,7 +65,7 @@ File open_file() {
 }

 // Attempts to write a string to a file.
-void write(File &f, fmt::StringRef s) {
+void write(File &f, fmt::string_view s) {
  std::size_t num_chars_left = s.size();
  const char *ptr = s.data();
  do {
@@ -173,7 +173,7 @@ TEST(BufferedFileTest, Fileno) {
  EXPECT_DEATH_IF_SUPPORTED({
    try {
      f.fileno();
-    } catch (fmt::SystemError) {
+    } catch (fmt::system_error) {
      std::exit(1);
    }
  }, "");
--- a/test/printf-test.cc
+++ b/test/printf-test.cc
@@ -29,19 +29,19 @@
 #include <climits>
 #include <cstring>

+#include "fmt/core.h"
 #include "fmt/printf.h"
-#include "fmt/format.h"
 #include "gtest-extra.h"
 #include "util.h"

 using fmt::format;
-using fmt::FormatError;
+using fmt::format_error;

 const unsigned BIG_NUM = INT_MAX + 1u;

 // Makes format string argument positional.
-std::string make_positional(fmt::StringRef format) {
-  std::string s(format.to_string());
+std::string make_positional(fmt::string_view format) {
+  std::string s(format.data(), format.size());
  s.replace(s.find('%'), 1, "%1$");
  return s;
 }
@@ -80,45 +80,45 @@ TEST(PrintfTest, AutomaticArgIndexing) {

 TEST(PrintfTest, NumberIsTooBigInArgIndex) {
  EXPECT_THROW_MSG(fmt::sprintf(format("%{}$", BIG_NUM)),
-      FormatError, "number is too big");
+      format_error, "number is too big");
  EXPECT_THROW_MSG(fmt::sprintf(format("%{}$d", BIG_NUM)),
-      FormatError, "number is too big");
+      format_error, "number is too big");
 }

 TEST(PrintfTest, SwitchArgIndexing) {
  EXPECT_THROW_MSG(fmt::sprintf("%1$d%", 1, 2),
-      FormatError, "invalid format string");
+      format_error, "cannot switch from manual to automatic argument indexing");
  EXPECT_THROW_MSG(fmt::sprintf(format("%1$d%{}d", BIG_NUM), 1, 2),
-      FormatError, "number is too big");
+      format_error, "number is too big");
  EXPECT_THROW_MSG(fmt::sprintf("%1$d%d", 1, 2),
-      FormatError, "cannot switch from manual to automatic argument indexing");
+      format_error, "cannot switch from manual to automatic argument indexing");

  EXPECT_THROW_MSG(fmt::sprintf("%d%1$", 1, 2),
-      FormatError, "invalid format string");
+      format_error, "cannot switch from automatic to manual argument indexing");
  EXPECT_THROW_MSG(fmt::sprintf(format("%d%{}$d", BIG_NUM), 1, 2),
-      FormatError, "number is too big");
+      format_error, "number is too big");
  EXPECT_THROW_MSG(fmt::sprintf("%d%1$d", 1, 2),
-      FormatError, "cannot switch from automatic to manual argument indexing");
+      format_error, "cannot switch from automatic to manual argument indexing");

  // Indexing errors override width errors.
  EXPECT_THROW_MSG(fmt::sprintf(format("%d%1${}d", BIG_NUM), 1, 2),
-      FormatError, "number is too big");
+      format_error, "number is too big");
  EXPECT_THROW_MSG(fmt::sprintf(format("%1$d%{}d", BIG_NUM), 1, 2),
-      FormatError, "number is too big");
+      format_error, "number is too big");
 }

 TEST(PrintfTest, InvalidArgIndex) {
-  EXPECT_THROW_MSG(fmt::sprintf("%0$d", 42), FormatError,
+  EXPECT_THROW_MSG(fmt::sprintf("%0$d", 42), format_error,
      "argument index out of range");
-  EXPECT_THROW_MSG(fmt::sprintf("%2$d", 42), FormatError,
+  EXPECT_THROW_MSG(fmt::sprintf("%2$d", 42), format_error,
      "argument index out of range");
  EXPECT_THROW_MSG(fmt::sprintf(format("%{}$d", INT_MAX), 42),
-      FormatError, "argument index out of range");
+      format_error, "argument index out of range");

  EXPECT_THROW_MSG(fmt::sprintf("%2$", 42),
-      FormatError, "invalid format string");
+      format_error, "argument index out of range");
  EXPECT_THROW_MSG(fmt::sprintf(format("%{}$d", BIG_NUM), 42),
-      FormatError, "number is too big");
+      format_error, "number is too big");
 }

 TEST(PrintfTest, DefaultAlignRight) {
@@ -137,7 +137,7 @@ TEST(PrintfTest, ZeroFlag) {
  EXPECT_PRINTF("+00042", "%00+6d", 42);

  // '0' flag is ignored for non-numeric types.
-  EXPECT_PRINTF("    x", "%05c", 'x');
+  EXPECT_PRINTF("0000x", "%05c", 'x');
 }

 TEST(PrintfTest, PlusFlag) {
@@ -202,27 +202,25 @@ TEST(PrintfTest, HashFlag) {

 TEST(PrintfTest, Width) {
  EXPECT_PRINTF("  abc", "%5s", "abc");
-  EXPECT_PRINTF("  -42", "%5s", "-42");
-  EXPECT_PRINTF("  0.123456", "%10s", 0.123456);

  // Width cannot be specified twice.
-  EXPECT_THROW_MSG(fmt::sprintf("%5-5d", 42), FormatError,
-      "unknown format code '-' for integer");
+  EXPECT_THROW_MSG(fmt::sprintf("%5-5d", 42), format_error,
+      "invalid type specifier");

  EXPECT_THROW_MSG(fmt::sprintf(format("%{}d", BIG_NUM), 42),
-      FormatError, "number is too big");
+      format_error, "number is too big");
  EXPECT_THROW_MSG(fmt::sprintf(format("%1${}d", BIG_NUM), 42),
-      FormatError, "number is too big");
+      format_error, "number is too big");
 }

 TEST(PrintfTest, DynamicWidth) {
  EXPECT_EQ("   42", fmt::sprintf("%*d", 5, 42));
  EXPECT_EQ("42   ", fmt::sprintf("%*d", -5, 42));
-  EXPECT_THROW_MSG(fmt::sprintf("%*d", 5.0, 42), FormatError,
+  EXPECT_THROW_MSG(fmt::sprintf("%*d", 5.0, 42), format_error,
      "width is not integer");
-  EXPECT_THROW_MSG(fmt::sprintf("%*d"), FormatError,
+  EXPECT_THROW_MSG(fmt::sprintf("%*d"), format_error,
      "argument index out of range");
-  EXPECT_THROW_MSG(fmt::sprintf("%*d", BIG_NUM, 42), FormatError,
+  EXPECT_THROW_MSG(fmt::sprintf("%*d", BIG_NUM, 42), format_error,
      "number is too big");
 }

@@ -265,41 +263,41 @@ TEST(PrintfTest, IgnorePrecisionForNonNumericArg) {
 TEST(PrintfTest, DynamicPrecision) {
  EXPECT_EQ("00042", fmt::sprintf("%.*d", 5, 42));
  EXPECT_EQ("42", fmt::sprintf("%.*d", -5, 42));
-  EXPECT_THROW_MSG(fmt::sprintf("%.*d", 5.0, 42), FormatError,
+  EXPECT_THROW_MSG(fmt::sprintf("%.*d", 5.0, 42), format_error,
      "precision is not integer");
-  EXPECT_THROW_MSG(fmt::sprintf("%.*d"), FormatError,
+  EXPECT_THROW_MSG(fmt::sprintf("%.*d"), format_error,
      "argument index out of range");
-  EXPECT_THROW_MSG(fmt::sprintf("%.*d", BIG_NUM, 42), FormatError,
+  EXPECT_THROW_MSG(fmt::sprintf("%.*d", BIG_NUM, 42), format_error,
      "number is too big");
-  if (sizeof(fmt::LongLong) != sizeof(int)) {
-    fmt::LongLong prec = static_cast<fmt::LongLong>(INT_MIN) - 1;
-    EXPECT_THROW_MSG(fmt::sprintf("%.*d", prec, 42), FormatError,
+  if (sizeof(long long) != sizeof(int)) {
+    long long prec = static_cast<long long>(INT_MIN) - 1;
+    EXPECT_THROW_MSG(fmt::sprintf("%.*d", prec, 42), format_error,
        "number is too big");
 }
 }

 template <typename T>
-struct MakeSigned { typedef T Type; };
+struct make_signed { typedef T type; };

 #define SPECIALIZE_MAKE_SIGNED(T, S) \
  template <> \
-  struct MakeSigned<T> { typedef S Type; }
+  struct make_signed<T> { typedef S type; }

 SPECIALIZE_MAKE_SIGNED(char, signed char);
 SPECIALIZE_MAKE_SIGNED(unsigned char, signed char);
 SPECIALIZE_MAKE_SIGNED(unsigned short, short);
 SPECIALIZE_MAKE_SIGNED(unsigned, int);
 SPECIALIZE_MAKE_SIGNED(unsigned long, long);
-SPECIALIZE_MAKE_SIGNED(fmt::ULongLong, fmt::LongLong);
+SPECIALIZE_MAKE_SIGNED(unsigned long long, long long);

 // Test length format specifier ``length_spec``.
 template <typename T, typename U>
 void TestLength(const char *length_spec, U value) {
-  fmt::LongLong signed_value = 0;
-  fmt::ULongLong unsigned_value = 0;
+  long long signed_value = 0;
+  unsigned long long unsigned_value = 0;
  // Apply integer promotion to the argument.
  using std::numeric_limits;
-  fmt::ULongLong max = numeric_limits<U>::max();
+  unsigned long long max = numeric_limits<U>::max();
  using fmt::internal::const_check;
  if (const_check(max <= static_cast<unsigned>(numeric_limits<int>::max()))) {
    signed_value = static_cast<int>(value);
@@ -308,13 +306,13 @@ void TestLength(const char *length_spec, U value) {
    signed_value = static_cast<unsigned>(value);
    unsigned_value = static_cast<unsigned>(value);
  }
-  using fmt::internal::MakeUnsigned;
  if (sizeof(U) <= sizeof(int) && sizeof(int) < sizeof(T)) {
-    signed_value = static_cast<fmt::LongLong>(value);
-    unsigned_value = static_cast<typename MakeUnsigned<unsigned>::Type>(value);
+    signed_value = static_cast<long long>(value);
+    unsigned_value =
+        static_cast<typename std::make_unsigned<unsigned>::type>(value);
  } else {
-    signed_value = static_cast<typename MakeSigned<T>::Type>(value);
-    unsigned_value = static_cast<typename MakeUnsigned<T>::Type>(value);
+    signed_value = static_cast<typename make_signed<T>::type>(value);
+    unsigned_value = static_cast<typename std::make_unsigned<T>::type>(value);
  }
  std::ostringstream os;
  os << signed_value;
@@ -341,20 +339,20 @@ void TestLength(const char *length_spec) {
  TestLength<T>(length_spec, -42);
  TestLength<T>(length_spec, min);
  TestLength<T>(length_spec, max);
-  TestLength<T>(length_spec, fmt::LongLong(min) - 1);
-  fmt::ULongLong long_long_max = std::numeric_limits<fmt::LongLong>::max();
-  if (static_cast<fmt::ULongLong>(max) < long_long_max)
-    TestLength<T>(length_spec, fmt::LongLong(max) + 1);
+  TestLength<T>(length_spec, static_cast<long long>(min) - 1);
+  unsigned long long long_long_max = std::numeric_limits<long long>::max();
+  if (static_cast<unsigned long long>(max) < long_long_max)
+    TestLength<T>(length_spec, static_cast<long long>(max) + 1);
  TestLength<T>(length_spec, std::numeric_limits<short>::min());
  TestLength<T>(length_spec, std::numeric_limits<unsigned short>::max());
  TestLength<T>(length_spec, std::numeric_limits<int>::min());
  TestLength<T>(length_spec, std::numeric_limits<int>::max());
  TestLength<T>(length_spec, std::numeric_limits<unsigned>::min());
  TestLength<T>(length_spec, std::numeric_limits<unsigned>::max());
-  TestLength<T>(length_spec, std::numeric_limits<fmt::LongLong>::min());
-  TestLength<T>(length_spec, std::numeric_limits<fmt::LongLong>::max());
-  TestLength<T>(length_spec, std::numeric_limits<fmt::ULongLong>::min());
-  TestLength<T>(length_spec, std::numeric_limits<fmt::ULongLong>::max());
+  TestLength<T>(length_spec, std::numeric_limits<long long>::min());
+  TestLength<T>(length_spec, std::numeric_limits<long long>::max());
+  TestLength<T>(length_spec, std::numeric_limits<unsigned long long>::min());
+  TestLength<T>(length_spec, std::numeric_limits<unsigned long long>::max());
 }

 TEST(PrintfTest, Length) {
@@ -365,8 +363,8 @@ TEST(PrintfTest, Length) {
  TestLength<unsigned short>("h");
  TestLength<long>("l");
  TestLength<unsigned long>("l");
-  TestLength<fmt::LongLong>("ll");
-  TestLength<fmt::ULongLong>("ll");
+  TestLength<long long>("ll");
+  TestLength<unsigned long long>("ll");
  TestLength<intmax_t>("j");
  TestLength<std::size_t>("z");
  TestLength<std::ptrdiff_t>("t");
@@ -383,19 +381,17 @@ TEST(PrintfTest, Bool) {
 TEST(PrintfTest, Int) {
  EXPECT_PRINTF("-42", "%d", -42);
  EXPECT_PRINTF("-42", "%i", -42);
-  EXPECT_PRINTF("-42", "%s", -42);
  unsigned u = 0 - 42u;
  EXPECT_PRINTF(fmt::format("{}", u), "%u", -42);
  EXPECT_PRINTF(fmt::format("{:o}", u), "%o", -42);
  EXPECT_PRINTF(fmt::format("{:x}", u), "%x", -42);
  EXPECT_PRINTF(fmt::format("{:X}", u), "%X", -42);
-  EXPECT_PRINTF(fmt::format("{}", u), "%s", u);
 }

-TEST(PrintfTest, LongLong) {
+TEST(PrintfTest, long_long) {
  // fmt::printf allows passing long long arguments to %d without length
  // specifiers.
-  fmt::LongLong max = std::numeric_limits<fmt::LongLong>::max();
+  long long max = std::numeric_limits<long long>::max();
  EXPECT_PRINTF(fmt::format("{}", max), "%d", max);
 }

@@ -405,7 +401,6 @@ TEST(PrintfTest, Float) {
  EXPECT_PRINTF("392.6", "%.1f", 392.65);
  EXPECT_PRINTF("393", "%.f", 392.65);
  EXPECT_PRINTF("392.650000", "%F", 392.65);
-  EXPECT_PRINTF("392.65", "%s", 392.65);
  char buffer[BUFFER_SIZE];
  safe_sprintf(buffer, "%e", 392.65);
  EXPECT_PRINTF(buffer, "%e", 392.65);
@@ -430,7 +425,6 @@ TEST(PrintfTest, Inf) {

 TEST(PrintfTest, Char) {
  EXPECT_PRINTF("x", "%c", 'x');
-  EXPECT_PRINTF("x", "%s", 'x');
  int max = std::numeric_limits<int>::max();
  EXPECT_PRINTF(fmt::format("{}", static_cast<char>(max)), "%c", max);
  //EXPECT_PRINTF("x", "%lc", L'x');
@@ -449,17 +443,13 @@ TEST(PrintfTest, Pointer) {
  int n;
  void *p = &n;
  EXPECT_PRINTF(fmt::format("{}", p), "%p", p);
-  EXPECT_PRINTF(fmt::format("{}", p), "%s", p);
  p = 0;
  EXPECT_PRINTF("(nil)", "%p", p);
  EXPECT_PRINTF("     (nil)", "%10p", p);
-  EXPECT_PRINTF("(nil)", "%s", p);
-  EXPECT_PRINTF("     (nil)", "%10s", p);
  const char *s = "test";
  EXPECT_PRINTF(fmt::format("{:p}", s), "%p", s);
  const char *null_str = 0;
  EXPECT_PRINTF("(nil)", "%p", null_str);
-  EXPECT_PRINTF("(null)", "%s", null_str);
 }

 TEST(PrintfTest, Location) {
@@ -503,9 +493,3 @@ TEST(PrintfTest, OStream) {
  EXPECT_EQ("Don't panic!", os.str());
  EXPECT_EQ(12, ret);
 }
-
-TEST(PrintfTest, Writer) {
-  fmt::MemoryWriter writer;
-  printf(writer, "%d", 42);
-  EXPECT_EQ("42", writer.str());
-}
--- a/test/string-test.cc
+++ b/test/string-test.cc
@@ -1,84 +0,0 @@
-/*
- Tests of string utilities
-
- Copyright (c) 2012 - 2016, Victor Zverovich
- All rights reserved.
-
- For the license information refer to format.h.
- */
-
-#include "fmt/string.h"
-#include "gtest/gtest.h"
-
-using fmt::internal::StringBuffer;
-
-TEST(StringBufferTest, Empty) {
-  StringBuffer<char> buffer;
-  EXPECT_EQ(0u, buffer.size());
-  EXPECT_EQ(0u, buffer.capacity());
-  std::string data;
-  // std::string may have initial capacity.
-  std::size_t capacity = data.capacity();
-  buffer.move_to(data);
-  EXPECT_EQ("", data);
-  EXPECT_EQ(capacity, data.capacity());
-}
-
-TEST(StringBufferTest, Reserve) {
-  StringBuffer<char> buffer;
-  std::size_t capacity = std::string().capacity() + 10;
-  buffer.reserve(capacity);
-  EXPECT_EQ(0u, buffer.size());
-  EXPECT_EQ(capacity, buffer.capacity());
-  std::string data;
-  buffer.move_to(data);
-  EXPECT_EQ("", data);
-}
-
-TEST(StringBufferTest, Resize) {
-  StringBuffer<char> buffer;
-  std::size_t size = std::string().capacity() + 10;
-  buffer.resize(size);
-  EXPECT_EQ(size, buffer.size());
-  EXPECT_EQ(size, buffer.capacity());
-  std::string data;
-  buffer.move_to(data);
-  EXPECT_EQ(size, data.size());
-}
-
-TEST(StringBufferTest, MoveTo) {
-  StringBuffer<char> buffer;
-  std::size_t size = std::string().capacity() + 10;
-  buffer.resize(size);
-  const char *p = &buffer[0];
-  std::string data;
-  buffer.move_to(data);
-  EXPECT_EQ(p, &data[0]);
-  EXPECT_EQ(0u, buffer.size());
-  EXPECT_EQ(0u, buffer.capacity());
-}
-
-TEST(StringWriterTest, MoveTo) {
-  fmt::StringWriter out;
-  out << "The answer is " << 42 << "\n";
-  std::string s;
-  out.move_to(s);
-  EXPECT_EQ("The answer is 42\n", s);
-  EXPECT_EQ(0u, out.size());
-}
-
-TEST(StringWriterTest, WString) {
-  fmt::WStringWriter out;
-  out << "The answer is " << 42 << "\n";
-  std::wstring s;
-  out.move_to(s);
-  EXPECT_EQ(L"The answer is 42\n", s);
-}
-
-TEST(StringTest, ToString) {
-  EXPECT_EQ("42", fmt::to_string(42));
-}
-
-TEST(StringTest, ToWString) {
-  EXPECT_EQ(L"42", fmt::to_wstring(42));
-}
--- a/test/time-test.cc
+++ b/test/time-test.cc
@@ -6,6 +6,7 @@

 For the license information refer to format.h.
 */
+
 #ifdef WIN32
 #define _CRT_SECURE_NO_WARNINGS
 #endif
--- a/test/util-test.cc
+++ b/test/util-test.cc