Use default cpp fmt build script.

vendor/Fmt/test/CMakeLists.txt

@@ -0,0 +1,247 @@
+add_subdirectory(gtest)
+
+set(TEST_MAIN_SRC test-main.cc gtest-extra.cc gtest-extra.h util.cc)
+add_library(test-main STATIC ${TEST_MAIN_SRC})
+target_include_directories(test-main PUBLIC
+  $<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/include>)
+target_link_libraries(test-main gtest)
+
+include(CheckCXXCompilerFlag)
+
+# Workaround GTest bug https://github.com/google/googletest/issues/705.
+check_cxx_compiler_flag(
+  -fno-delete-null-pointer-checks HAVE_FNO_DELETE_NULL_POINTER_CHECKS)
+if (HAVE_FNO_DELETE_NULL_POINTER_CHECKS)
+  target_compile_options(test-main PUBLIC -fno-delete-null-pointer-checks)
+endif ()
+
+# Use less strict pedantic flags for the tests because GMock doesn't compile
+# cleanly with -pedantic and -std=c++98.
+if (CMAKE_COMPILER_IS_GNUCXX OR (CMAKE_CXX_COMPILER_ID MATCHES "Clang"))
+    #set(PEDANTIC_COMPILE_FLAGS -Wall -Wextra -Wno-long-long -Wno-variadic-macros)
+endif ()
+
+function(add_fmt_executable name)
+  add_executable(${name} ${ARGN})
+  if (MINGW)
+    target_link_libraries(${name} -static-libgcc -static-libstdc++)
+  endif ()
+endfunction()
+
+# Adds a test.
+# Usage: add_fmt_test(name srcs...)
+function(add_fmt_test name)
+  cmake_parse_arguments(ADD_FMT_TEST "HEADER_ONLY;MODULE" "" "" ${ARGN})
+
+  set(sources ${name}.cc ${ADD_FMT_TEST_UNPARSED_ARGUMENTS})
+  if (ADD_FMT_TEST_HEADER_ONLY)
+    set(sources ${sources} ${TEST_MAIN_SRC} ../src/os.cc)
+    set(libs gtest fmt-header-only)
+    if (CMAKE_CXX_COMPILER_ID MATCHES "Clang")
+      set(PEDANTIC_COMPILE_FLAGS ${PEDANTIC_COMPILE_FLAGS} -Wno-weak-vtables)
+    endif ()
+  elseif (ADD_FMT_TEST_MODULE)
+    set(libs test-main test-module)
+    set_source_files_properties(${name}.cc PROPERTIES OBJECT_DEPENDS test-module)
+  else ()
+    set(libs test-main fmt)
+  endif ()
+  add_fmt_executable(${name} ${sources})
+  target_link_libraries(${name} ${libs})
+
+  # Define if certain C++ features can be used.
+  if (FMT_PEDANTIC)
+    target_compile_options(${name} PRIVATE ${PEDANTIC_COMPILE_FLAGS})
+  endif ()
+  if (FMT_WERROR)
+    target_compile_options(${name} PRIVATE ${WERROR_FLAG})
+  endif ()
+  add_test(NAME ${name} COMMAND ${name})
+endfunction()
+
+add_fmt_test(args-test)
+add_fmt_test(assert-test)
+add_fmt_test(chrono-test)
+add_fmt_test(color-test)
+add_fmt_test(core-test)
+add_fmt_test(gtest-extra-test)
+add_fmt_test(format-test mock-allocator.h)
+if (MSVC)
+  target_compile_options(format-test PRIVATE /bigobj)
+endif ()
+if (NOT (MSVC AND BUILD_SHARED_LIBS))
+  add_fmt_test(format-impl-test HEADER_ONLY header-only-test.cc)
+endif ()
+add_fmt_test(ostream-test)
+add_fmt_test(compile-test)
+add_fmt_test(printf-test)
+add_fmt_test(ranges-test)
+add_fmt_test(scan-test)
+add_fmt_test(unicode-test HEADER_ONLY)
+if (MSVC)
+  target_compile_options(unicode-test PRIVATE /utf-8)
+endif ()
+add_fmt_test(xchar-test)
+add_fmt_test(enforce-checks-test)
+target_compile_definitions(enforce-checks-test PRIVATE
+                           -DFMT_ENFORCE_COMPILE_STRING)
+
+if (FMT_CAN_MODULE)
+  # The tests need {fmt} to be compiled as traditional library
+  # because of visibility of implementation details.
+  # If module support is present the module tests require a
+  # test-only module to be built from {fmt}
+  add_library(test-module OBJECT ${CMAKE_SOURCE_DIR}/src/fmt.cc)
+  target_compile_features(test-module PUBLIC ${FMT_REQUIRED_FEATURES})
+  target_include_directories(test-module PUBLIC
+    $<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/include>)
+  enable_module(test-module)
+
+  add_fmt_test(module-test MODULE)
+  if (MSVC)
+    target_compile_options(test-module PRIVATE /utf-8 /Zc:__cplusplus
+                           /Zc:externConstexpr /Zc:inline)
+    target_compile_options(module-test PRIVATE /utf-8 /Zc:__cplusplus
+                           /Zc:externConstexpr /Zc:inline)
+  endif ()
+endif ()
+
+if (NOT DEFINED MSVC_STATIC_RUNTIME AND MSVC)
+  foreach (flag_var
+			 CMAKE_CXX_FLAGS CMAKE_CXX_FLAGS_DEBUG CMAKE_CXX_FLAGS_RELEASE
+			 CMAKE_CXX_FLAGS_MINSIZEREL CMAKE_CXX_FLAGS_RELWITHDEBINFO)
+	if (${flag_var} MATCHES "^(/|-)(MT|MTd)")
+	  set(MSVC_STATIC_RUNTIME ON)
+	  break()
+	endif()
+  endforeach()
+endif()
+
+if (NOT MSVC_STATIC_RUNTIME)
+  add_fmt_executable(posix-mock-test
+    posix-mock-test.cc ../src/format.cc ${TEST_MAIN_SRC})
+  target_include_directories(
+    posix-mock-test PRIVATE ${PROJECT_SOURCE_DIR}/include)
+  target_link_libraries(posix-mock-test gtest)
+  if (FMT_PEDANTIC)
+    target_compile_options(posix-mock-test PRIVATE ${PEDANTIC_COMPILE_FLAGS})
+  endif ()
+  if (HAVE_STRTOD_L)
+    target_compile_definitions(posix-mock-test PRIVATE FMT_LOCALE)
+  endif ()
+  add_test(NAME posix-mock-test COMMAND posix-mock-test)
+  add_fmt_test(os-test)
+endif ()
+
+message(STATUS "FMT_PEDANTIC: ${FMT_PEDANTIC}")
+
+if (FMT_PEDANTIC AND CXX_STANDARD LESS 20)
+  # MSVC fails to compile GMock when C++17 is enabled.
+  if (FMT_HAS_VARIANT AND NOT MSVC)
+    add_fmt_test(std-format-test)
+    set_property(TARGET std-format-test PROPERTY CXX_STANDARD 17)
+  endif ()
+
+  # Test that the library can be compiled with exceptions disabled.
+  # -fno-exception is broken in icc: https://github.com/fmtlib/fmt/issues/822.
+  if (NOT CMAKE_CXX_COMPILER_ID STREQUAL "Intel")
+    check_cxx_compiler_flag(-fno-exceptions HAVE_FNO_EXCEPTIONS_FLAG)
+  endif ()
+  if (HAVE_FNO_EXCEPTIONS_FLAG)
+    add_library(noexception-test ../src/format.cc)
+    target_include_directories(
+      noexception-test PRIVATE ${PROJECT_SOURCE_DIR}/include)
+    target_compile_options(noexception-test PRIVATE -fno-exceptions)
+    if (FMT_PEDANTIC)
+      target_compile_options(noexception-test PRIVATE ${PEDANTIC_COMPILE_FLAGS})
+    endif ()
+  endif ()
+
+  # Test that the library compiles without locale.
+  add_library(nolocale-test ../src/format.cc)
+  target_include_directories(
+    nolocale-test PRIVATE ${PROJECT_SOURCE_DIR}/include)
+  target_compile_definitions(
+    nolocale-test PRIVATE FMT_STATIC_THOUSANDS_SEPARATOR=1)
+
+  add_test(compile-error-test ${CMAKE_CTEST_COMMAND}
+    --build-and-test
+    "${CMAKE_CURRENT_SOURCE_DIR}/compile-error-test"
+    "${CMAKE_CURRENT_BINARY_DIR}/compile-error-test"
+    --build-generator ${CMAKE_GENERATOR}
+    --build-makeprogram ${CMAKE_MAKE_PROGRAM}
+    --build-options
+    "-DCMAKE_CXX_COMPILER=${CMAKE_CXX_COMPILER}"
+    "-DCMAKE_CXX_STANDARD=${CMAKE_CXX_STANDARD}"
+    "-DCXX_STANDARD_FLAG=${CXX_STANDARD_FLAG}"
+    "-DPEDANTIC_COMPILE_FLAGS=${PEDANTIC_COMPILE_FLAGS}"
+    "-DSUPPORTS_USER_DEFINED_LITERALS=${SUPPORTS_USER_DEFINED_LITERALS}")
+endif ()
+
+# These tests are disabled on Windows because they take too long.
+if (FMT_PEDANTIC AND NOT WIN32)
+  # Test if the targets are found from the build directory.
+  add_test(find-package-test ${CMAKE_CTEST_COMMAND}
+    -C ${CMAKE_BUILD_TYPE}
+    --build-and-test
+    "${CMAKE_CURRENT_SOURCE_DIR}/find-package-test"
+    "${CMAKE_CURRENT_BINARY_DIR}/find-package-test"
+    --build-generator ${CMAKE_GENERATOR}
+    --build-makeprogram ${CMAKE_MAKE_PROGRAM}
+    --build-options
+    "-DCMAKE_CXX_COMPILER=${CMAKE_CXX_COMPILER}"
+    "-DCMAKE_CXX_FLAGS=${CMAKE_CXX_FLAGS}"
+    "-DCMAKE_CXX_STANDARD=${CMAKE_CXX_STANDARD}"
+    "-DFMT_DIR=${PROJECT_BINARY_DIR}"
+    "-DPEDANTIC_COMPILE_FLAGS=${PEDANTIC_COMPILE_FLAGS}"
+    "-DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE}")
+
+  # Test if the targets are found when add_subdirectory is used.
+  add_test(add-subdirectory-test ${CMAKE_CTEST_COMMAND}
+    -C ${CMAKE_BUILD_TYPE}
+    --build-and-test
+    "${CMAKE_CURRENT_SOURCE_DIR}/add-subdirectory-test"
+    "${CMAKE_CURRENT_BINARY_DIR}/add-subdirectory-test"
+    --build-generator ${CMAKE_GENERATOR}
+    --build-makeprogram ${CMAKE_MAKE_PROGRAM}
+    --build-options
+    "-DCMAKE_CXX_COMPILER=${CMAKE_CXX_COMPILER}"
+    "-DCMAKE_CXX_STANDARD=${CMAKE_CXX_STANDARD}"
+    "-DPEDANTIC_COMPILE_FLAGS=${PEDANTIC_COMPILE_FLAGS}"
+    "-DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE}")
+endif ()
+
+# This test are disabled on Windows because it is only *NIX issue.
+if (FMT_PEDANTIC AND NOT WIN32)
+  add_test(static-export-test ${CMAKE_CTEST_COMMAND}
+    -C ${CMAKE_BUILD_TYPE}
+    --build-and-test
+    "${CMAKE_CURRENT_SOURCE_DIR}/static-export-test"
+    "${CMAKE_CURRENT_BINARY_DIR}/static-export-test"
+    --build-generator ${CMAKE_GENERATOR}
+    --build-makeprogram ${CMAKE_MAKE_PROGRAM}
+    --build-options
+    "-DCMAKE_CXX_COMPILER=${CMAKE_CXX_COMPILER}"
+    "-DCMAKE_CXX_STANDARD=${CMAKE_CXX_STANDARD}"
+    "-DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE}")
+endif ()
+
+# Activate optional CUDA tests if CUDA is found. For version selection see
+# https://docs.nvidia.com/cuda/cuda-c-programming-guide/index.html#cpp14-language-features
+if (FMT_CUDA_TEST)
+  if (${CMAKE_VERSION} VERSION_LESS 3.15)
+    find_package(CUDA 9.0)
+  else ()
+    include(CheckLanguage)
+    check_language(CUDA)
+    if (CMAKE_CUDA_COMPILER)
+      enable_language(CUDA OPTIONAL)
+      set(CUDA_FOUND TRUE)
+    endif ()
+  endif ()
+
+  if (CUDA_FOUND)
+    add_subdirectory(cuda-test)
+    add_test(NAME cuda-test COMMAND fmt-in-cuda-test)
+  endif ()
+endif ()

vendor/Fmt/test/add-subdirectory-test/CMakeLists.txt

@@ -0,0 +1,17 @@
+cmake_minimum_required(VERSION 3.1...3.18)
+
+project(fmt-test CXX)
+
+add_subdirectory(../.. fmt)
+
+add_executable(library-test main.cc)
+target_include_directories(library-test PUBLIC SYSTEM .)
+target_compile_options(library-test PRIVATE ${PEDANTIC_COMPILE_FLAGS})
+target_link_libraries(library-test fmt::fmt)
+
+if (TARGET fmt::fmt-header-only)
+  add_executable(header-only-test main.cc)
+  target_include_directories(header-only-test PUBLIC SYSTEM .)
+  target_compile_options(header-only-test PRIVATE ${PEDANTIC_COMPILE_FLAGS})
+  target_link_libraries(header-only-test fmt::fmt-header-only)
+endif ()

vendor/Fmt/test/add-subdirectory-test/main.cc

@@ -0,0 +1,5 @@
+#include "fmt/core.h"
+
+int main(int argc, char** argv) {
+  for (int i = 0; i < argc; ++i) fmt::print("{}: {}\n", i, argv[i]);
+}

vendor/Fmt/test/args-test.cc

@@ -0,0 +1,173 @@
+// Formatting library for C++ - dynamic argument store tests
+//
+// Copyright (c) 2012 - present, Victor Zverovich
+// All rights reserved.
+//
+// For the license information refer to format.h.
+
+#include "fmt/args.h"
+
+#include "gtest/gtest.h"
+
+TEST(args_test, basic) {
+  auto store = fmt::dynamic_format_arg_store<fmt::format_context>();
+  store.push_back(42);
+  store.push_back("abc1");
+  store.push_back(1.5f);
+  EXPECT_EQ("42 and abc1 and 1.5", fmt::vformat("{} and {} and {}", store));
+}
+
+TEST(args_test, strings_and_refs) {
+  // Unfortunately the tests are compiled with old ABI so strings use COW.
+  auto store = fmt::dynamic_format_arg_store<fmt::format_context>();
+  char str[] = "1234567890";
+  store.push_back(str);
+  store.push_back(std::cref(str));
+  store.push_back(fmt::string_view{str});
+  str[0] = 'X';
+
+  auto result = fmt::vformat("{} and {} and {}", store);
+  EXPECT_EQ("1234567890 and X234567890 and X234567890", result);
+}
+
+struct custom_type {
+  int i = 0;
+};
+
+FMT_BEGIN_NAMESPACE
+template <> struct formatter<custom_type> {
+  auto parse(format_parse_context& ctx) const -> decltype(ctx.begin()) {
+    return ctx.begin();
+  }
+
+  template <typename FormatContext>
+  auto format(const custom_type& p, FormatContext& ctx) -> decltype(ctx.out()) {
+    return format_to(ctx.out(), "cust={}", p.i);
+  }
+};
+FMT_END_NAMESPACE
+
+TEST(args_test, custom_format) {
+  auto store = fmt::dynamic_format_arg_store<fmt::format_context>();
+  auto c = custom_type();
+  store.push_back(c);
+  ++c.i;
+  store.push_back(c);
+  ++c.i;
+  store.push_back(std::cref(c));
+  ++c.i;
+  auto result = fmt::vformat("{} and {} and {}", store);
+  EXPECT_EQ("cust=0 and cust=1 and cust=3", result);
+}
+
+struct to_stringable {
+  friend fmt::string_view to_string_view(to_stringable) { return {}; }
+};
+
+FMT_BEGIN_NAMESPACE
+template <> struct formatter<to_stringable> {
+  auto parse(format_parse_context& ctx) const -> decltype(ctx.begin()) {
+    return ctx.begin();
+  }
+
+  auto format(to_stringable, format_context& ctx) -> decltype(ctx.out()) {
+    return ctx.out();
+  }
+};
+FMT_END_NAMESPACE
+
+TEST(args_test, to_string_and_formatter) {
+  auto store = fmt::dynamic_format_arg_store<fmt::format_context>();
+  auto s = to_stringable();
+  store.push_back(s);
+  store.push_back(std::cref(s));
+  fmt::vformat("", store);
+}
+
+TEST(args_test, named_int) {
+  auto store = fmt::dynamic_format_arg_store<fmt::format_context>();
+  store.push_back(fmt::arg("a1", 42));
+  EXPECT_EQ("42", fmt::vformat("{a1}", store));
+}
+
+TEST(args_test, named_strings) {
+  auto store = fmt::dynamic_format_arg_store<fmt::format_context>();
+  char str[] = "1234567890";
+  store.push_back(fmt::arg("a1", str));
+  store.push_back(fmt::arg("a2", std::cref(str)));
+  str[0] = 'X';
+  EXPECT_EQ("1234567890 and X234567890", fmt::vformat("{a1} and {a2}", store));
+}
+
+TEST(args_test, named_arg_by_ref) {
+  auto store = fmt::dynamic_format_arg_store<fmt::format_context>();
+  char band[] = "Rolling Stones";
+  store.push_back(fmt::arg("band", std::cref(band)));
+  band[9] = 'c';  // Changing band affects the output.
+  EXPECT_EQ(fmt::vformat("{band}", store), "Rolling Scones");
+}
+
+TEST(args_test, named_custom_format) {
+  auto store = fmt::dynamic_format_arg_store<fmt::format_context>();
+  auto c = custom_type();
+  store.push_back(fmt::arg("c1", c));
+  ++c.i;
+  store.push_back(fmt::arg("c2", c));
+  ++c.i;
+  store.push_back(fmt::arg("c_ref", std::cref(c)));
+  ++c.i;
+  auto result = fmt::vformat("{c1} and {c2} and {c_ref}", store);
+  EXPECT_EQ("cust=0 and cust=1 and cust=3", result);
+}
+
+TEST(args_test, clear) {
+  auto store = fmt::dynamic_format_arg_store<fmt::format_context>();
+  store.push_back(42);
+
+  auto result = fmt::vformat("{}", store);
+  EXPECT_EQ("42", result);
+
+  store.push_back(43);
+  result = fmt::vformat("{} and {}", store);
+  EXPECT_EQ("42 and 43", result);
+
+  store.clear();
+  store.push_back(44);
+  result = fmt::vformat("{}", store);
+  EXPECT_EQ("44", result);
+}
+
+TEST(args_test, reserve) {
+  auto store = fmt::dynamic_format_arg_store<fmt::format_context>();
+  store.reserve(2, 1);
+  store.push_back(1.5f);
+  store.push_back(fmt::arg("a1", 42));
+  auto result = fmt::vformat("{a1} and {}", store);
+  EXPECT_EQ("42 and 1.5", result);
+}
+
+struct copy_throwable {
+  copy_throwable() {}
+  copy_throwable(const copy_throwable&) { throw "deal with it"; }
+};
+
+FMT_BEGIN_NAMESPACE
+template <> struct formatter<copy_throwable> {
+  auto parse(format_parse_context& ctx) const -> decltype(ctx.begin()) {
+    return ctx.begin();
+  }
+  auto format(copy_throwable, format_context& ctx) -> decltype(ctx.out()) {
+    return ctx.out();
+  }
+};
+FMT_END_NAMESPACE
+
+TEST(args_test, throw_on_copy) {
+  auto store = fmt::dynamic_format_arg_store<fmt::format_context>();
+  store.push_back(std::string("foo"));
+  try {
+    store.push_back(copy_throwable());
+  } catch (...) {
+  }
+  EXPECT_EQ(fmt::vformat("{}", store), "foo");
+}

vendor/Fmt/test/assert-test.cc

@@ -0,0 +1,31 @@
+// Formatting library for C++ - FMT_ASSERT test
+//
+// It is a separate test to minimize the number of EXPECT_DEBUG_DEATH checks
+// which are slow on some platforms. In other tests FMT_ASSERT is made to throw
+// an exception which is much faster and easier to check.
+//
+// Copyright (c) 2012 - present, Victor Zverovich
+// All rights reserved.
+//
+// For the license information refer to format.h.
+
+#include "fmt/core.h"
+#include "gtest/gtest.h"
+
+TEST(assert_test, fail) {
+#if GTEST_HAS_DEATH_TEST
+  EXPECT_DEBUG_DEATH(FMT_ASSERT(false, "don't panic!"), "don't panic!");
+#else
+  fmt::print("warning: death tests are not supported\n");
+#endif
+}
+
+TEST(assert_test, dangling_else) {
+  bool test_condition = false;
+  bool executed_else = false;
+  if (test_condition)
+    FMT_ASSERT(true, "");
+  else
+    executed_else = true;
+  EXPECT_TRUE(executed_else);
+}

vendor/Fmt/test/chrono-test.cc

@@ -0,0 +1,385 @@
+// Formatting library for C++ - time formatting tests
+//
+// Copyright (c) 2012 - present, Victor Zverovich
+// All rights reserved.
+//
+// For the license information refer to format.h.
+
+#include "fmt/chrono.h"
+
+#include "gtest-extra.h"  // EXPECT_THROW_MSG
+#include "util.h"         // get_locale
+
+using fmt::runtime;
+
+using testing::Contains;
+
+auto make_tm() -> std::tm {
+  auto time = std::tm();
+  time.tm_mday = 1;
+  return time;
+}
+
+auto make_hour(int h) -> std::tm {
+  auto time = make_tm();
+  time.tm_hour = h;
+  return time;
+}
+
+auto make_minute(int m) -> std::tm {
+  auto time = make_tm();
+  time.tm_min = m;
+  return time;
+}
+
+auto make_second(int s) -> std::tm {
+  auto time = make_tm();
+  time.tm_sec = s;
+  return time;
+}
+
+TEST(chrono_test, format_tm) {
+  auto tm = std::tm();
+  tm.tm_year = 116;
+  tm.tm_mon = 3;
+  tm.tm_mday = 25;
+  tm.tm_hour = 11;
+  tm.tm_min = 22;
+  tm.tm_sec = 33;
+  EXPECT_EQ(fmt::format("The date is {:%Y-%m-%d %H:%M:%S}.", tm),
+            "The date is 2016-04-25 11:22:33.");
+}
+
+TEST(chrono_test, grow_buffer) {
+  auto s = std::string("{:");
+  for (int i = 0; i < 30; ++i) s += "%c";
+  s += "}\n";
+  auto t = std::time(nullptr);
+  fmt::format(fmt::runtime(s), *std::localtime(&t));
+}
+
+TEST(chrono_test, format_to_empty_container) {
+  auto time = std::tm();
+  time.tm_sec = 42;
+  auto s = std::string();
+  fmt::format_to(std::back_inserter(s), "{:%S}", time);
+  EXPECT_EQ(s, "42");
+}
+
+TEST(chrono_test, empty_result) { EXPECT_EQ(fmt::format("{}", std::tm()), ""); }
+
+auto equal(const std::tm& lhs, const std::tm& rhs) -> bool {
+  return lhs.tm_sec == rhs.tm_sec && lhs.tm_min == rhs.tm_min &&
+         lhs.tm_hour == rhs.tm_hour && lhs.tm_mday == rhs.tm_mday &&
+         lhs.tm_mon == rhs.tm_mon && lhs.tm_year == rhs.tm_year &&
+         lhs.tm_wday == rhs.tm_wday && lhs.tm_yday == rhs.tm_yday &&
+         lhs.tm_isdst == rhs.tm_isdst;
+}
+
+TEST(chrono_test, localtime) {
+  auto t = std::time(nullptr);
+  auto tm = *std::localtime(&t);
+  EXPECT_TRUE(equal(tm, fmt::localtime(t)));
+}
+
+TEST(chrono_test, gmtime) {
+  auto t = std::time(nullptr);
+  auto tm = *std::gmtime(&t);
+  EXPECT_TRUE(equal(tm, fmt::gmtime(t)));
+}
+
+template <typename TimePoint> auto strftime(TimePoint tp) -> std::string {
+  auto t = std::chrono::system_clock::to_time_t(tp);
+  auto tm = *std::localtime(&t);
+  char output[256] = {};
+  std::strftime(output, sizeof(output), "%Y-%m-%d %H:%M:%S", &tm);
+  return output;
+}
+
+TEST(chrono_test, time_point) {
+  auto t1 = std::chrono::system_clock::now();
+  EXPECT_EQ(strftime(t1), fmt::format("{:%Y-%m-%d %H:%M:%S}", t1));
+  EXPECT_EQ(strftime(t1), fmt::format("{}", t1));
+  using time_point =
+      std::chrono::time_point<std::chrono::system_clock, std::chrono::seconds>;
+  auto t2 = time_point(std::chrono::seconds(42));
+  EXPECT_EQ(strftime(t2), fmt::format("{:%Y-%m-%d %H:%M:%S}", t2));
+}
+
+#ifndef FMT_STATIC_THOUSANDS_SEPARATOR
+
+TEST(chrono_test, format_default) {
+  EXPECT_EQ("42s", fmt::format("{}", std::chrono::seconds(42)));
+  EXPECT_EQ("42as",
+            fmt::format("{}", std::chrono::duration<int, std::atto>(42)));
+  EXPECT_EQ("42fs",
+            fmt::format("{}", std::chrono::duration<int, std::femto>(42)));
+  EXPECT_EQ("42ps",
+            fmt::format("{}", std::chrono::duration<int, std::pico>(42)));
+  EXPECT_EQ("42ns", fmt::format("{}", std::chrono::nanoseconds(42)));
+  EXPECT_EQ("42µs", fmt::format("{}", std::chrono::microseconds(42)));
+  EXPECT_EQ("42ms", fmt::format("{}", std::chrono::milliseconds(42)));
+  EXPECT_EQ("42cs",
+            fmt::format("{}", std::chrono::duration<int, std::centi>(42)));
+  EXPECT_EQ("42ds",
+            fmt::format("{}", std::chrono::duration<int, std::deci>(42)));
+  EXPECT_EQ("42s", fmt::format("{}", std::chrono::seconds(42)));
+  EXPECT_EQ("42das",
+            fmt::format("{}", std::chrono::duration<int, std::deca>(42)));
+  EXPECT_EQ("42hs",
+            fmt::format("{}", std::chrono::duration<int, std::hecto>(42)));
+  EXPECT_EQ("42ks",
+            fmt::format("{}", std::chrono::duration<int, std::kilo>(42)));
+  EXPECT_EQ("42Ms",
+            fmt::format("{}", std::chrono::duration<int, std::mega>(42)));
+  EXPECT_EQ("42Gs",
+            fmt::format("{}", std::chrono::duration<int, std::giga>(42)));
+  EXPECT_EQ("42Ts",
+            fmt::format("{}", std::chrono::duration<int, std::tera>(42)));
+  EXPECT_EQ("42Ps",
+            fmt::format("{}", std::chrono::duration<int, std::peta>(42)));
+  EXPECT_EQ("42Es",
+            fmt::format("{}", std::chrono::duration<int, std::exa>(42)));
+  EXPECT_EQ("42m", fmt::format("{}", std::chrono::minutes(42)));
+  EXPECT_EQ("42h", fmt::format("{}", std::chrono::hours(42)));
+  EXPECT_EQ(
+      "42[15]s",
+      fmt::format("{}", std::chrono::duration<int, std::ratio<15, 1>>(42)));
+  EXPECT_EQ(
+      "42[15/4]s",
+      fmt::format("{}", std::chrono::duration<int, std::ratio<15, 4>>(42)));
+}
+
+TEST(chrono_test, align) {
+  auto s = std::chrono::seconds(42);
+  EXPECT_EQ("42s  ", fmt::format("{:5}", s));
+  EXPECT_EQ("42s  ", fmt::format("{:{}}", s, 5));
+  EXPECT_EQ("  42s", fmt::format("{:>5}", s));
+  EXPECT_EQ("**42s**", fmt::format("{:*^7}", s));
+  EXPECT_EQ("03:25:45    ",
+            fmt::format("{:12%H:%M:%S}", std::chrono::seconds(12345)));
+  EXPECT_EQ("    03:25:45",
+            fmt::format("{:>12%H:%M:%S}", std::chrono::seconds(12345)));
+  EXPECT_EQ("~~03:25:45~~",
+            fmt::format("{:~^12%H:%M:%S}", std::chrono::seconds(12345)));
+  EXPECT_EQ("03:25:45    ",
+            fmt::format("{:{}%H:%M:%S}", std::chrono::seconds(12345), 12));
+}
+
+TEST(chrono_test, format_specs) {
+  EXPECT_EQ("%", fmt::format("{:%%}", std::chrono::seconds(0)));
+  EXPECT_EQ("\n", fmt::format("{:%n}", std::chrono::seconds(0)));
+  EXPECT_EQ("\t", fmt::format("{:%t}", std::chrono::seconds(0)));
+  EXPECT_EQ("00", fmt::format("{:%S}", std::chrono::seconds(0)));
+  EXPECT_EQ("00", fmt::format("{:%S}", std::chrono::seconds(60)));
+  EXPECT_EQ("42", fmt::format("{:%S}", std::chrono::seconds(42)));
+  EXPECT_EQ("01.234", fmt::format("{:%S}", std::chrono::milliseconds(1234)));
+  EXPECT_EQ("00", fmt::format("{:%M}", std::chrono::minutes(0)));
+  EXPECT_EQ("00", fmt::format("{:%M}", std::chrono::minutes(60)));
+  EXPECT_EQ("42", fmt::format("{:%M}", std::chrono::minutes(42)));
+  EXPECT_EQ("01", fmt::format("{:%M}", std::chrono::seconds(61)));
+  EXPECT_EQ("00", fmt::format("{:%H}", std::chrono::hours(0)));
+  EXPECT_EQ("00", fmt::format("{:%H}", std::chrono::hours(24)));
+  EXPECT_EQ("14", fmt::format("{:%H}", std::chrono::hours(14)));
+  EXPECT_EQ("01", fmt::format("{:%H}", std::chrono::minutes(61)));
+  EXPECT_EQ("12", fmt::format("{:%I}", std::chrono::hours(0)));
+  EXPECT_EQ("12", fmt::format("{:%I}", std::chrono::hours(12)));
+  EXPECT_EQ("12", fmt::format("{:%I}", std::chrono::hours(24)));
+  EXPECT_EQ("04", fmt::format("{:%I}", std::chrono::hours(4)));
+  EXPECT_EQ("02", fmt::format("{:%I}", std::chrono::hours(14)));
+  EXPECT_EQ("03:25:45",
+            fmt::format("{:%H:%M:%S}", std::chrono::seconds(12345)));
+  EXPECT_EQ("03:25", fmt::format("{:%R}", std::chrono::seconds(12345)));
+  EXPECT_EQ("03:25:45", fmt::format("{:%T}", std::chrono::seconds(12345)));
+  EXPECT_EQ("12345", fmt::format("{:%Q}", std::chrono::seconds(12345)));
+  EXPECT_EQ("s", fmt::format("{:%q}", std::chrono::seconds(12345)));
+}
+
+TEST(chrono_test, invalid_specs) {
+  auto sec = std::chrono::seconds(0);
+  EXPECT_THROW_MSG(fmt::format(runtime("{:%a}"), sec), fmt::format_error,
+                   "no date");
+  EXPECT_THROW_MSG(fmt::format(runtime("{:%A}"), sec), fmt::format_error,
+                   "no date");
+  EXPECT_THROW_MSG(fmt::format(runtime("{:%c}"), sec), fmt::format_error,
+                   "no date");
+  EXPECT_THROW_MSG(fmt::format(runtime("{:%x}"), sec), fmt::format_error,
+                   "no date");
+  EXPECT_THROW_MSG(fmt::format(runtime("{:%Ex}"), sec), fmt::format_error,
+                   "no date");
+  EXPECT_THROW_MSG(fmt::format(runtime("{:%X}"), sec), fmt::format_error,
+                   "no date");
+  EXPECT_THROW_MSG(fmt::format(runtime("{:%EX}"), sec), fmt::format_error,
+                   "no date");
+  EXPECT_THROW_MSG(fmt::format(runtime("{:%D}"), sec), fmt::format_error,
+                   "no date");
+  EXPECT_THROW_MSG(fmt::format(runtime("{:%F}"), sec), fmt::format_error,
+                   "no date");
+  EXPECT_THROW_MSG(fmt::format(runtime("{:%Ec}"), sec), fmt::format_error,
+                   "no date");
+  EXPECT_THROW_MSG(fmt::format(runtime("{:%w}"), sec), fmt::format_error,
+                   "no date");
+  EXPECT_THROW_MSG(fmt::format(runtime("{:%u}"), sec), fmt::format_error,
+                   "no date");
+  EXPECT_THROW_MSG(fmt::format(runtime("{:%b}"), sec), fmt::format_error,
+                   "no date");
+  EXPECT_THROW_MSG(fmt::format(runtime("{:%B}"), sec), fmt::format_error,
+                   "no date");
+  EXPECT_THROW_MSG(fmt::format(runtime("{:%z}"), sec), fmt::format_error,
+                   "no date");
+  EXPECT_THROW_MSG(fmt::format(runtime("{:%Z}"), sec), fmt::format_error,
+                   "no date");
+  EXPECT_THROW_MSG(fmt::format(runtime("{:%Eq}"), sec), fmt::format_error,
+                   "invalid format");
+  EXPECT_THROW_MSG(fmt::format(runtime("{:%Oq}"), sec), fmt::format_error,
+                   "invalid format");
+}
+
+auto format_tm(const std::tm& time, fmt::string_view spec,
+               const std::locale& loc) -> std::string {
+  auto& facet = std::use_facet<std::time_put<char>>(loc);
+  std::ostringstream os;
+  os.imbue(loc);
+  facet.put(os, os, ' ', &time, spec.begin(), spec.end());
+  return os.str();
+}
+
+TEST(chrono_test, locale) {
+  auto loc = get_locale("ja_JP.utf8");
+  if (loc == std::locale::classic()) return;
+#  define EXPECT_TIME(spec, time, duration)                     \
+    {                                                           \
+      auto jp_loc = std::locale("ja_JP.utf8");                  \
+      EXPECT_EQ(format_tm(time, spec, jp_loc),                  \
+                fmt::format(jp_loc, "{:L" spec "}", duration)); \
+    }
+  EXPECT_TIME("%OH", make_hour(14), std::chrono::hours(14));
+  EXPECT_TIME("%OI", make_hour(14), std::chrono::hours(14));
+  EXPECT_TIME("%OM", make_minute(42), std::chrono::minutes(42));
+  EXPECT_TIME("%OS", make_second(42), std::chrono::seconds(42));
+  auto time = make_tm();
+  time.tm_hour = 3;
+  time.tm_min = 25;
+  time.tm_sec = 45;
+  auto sec = std::chrono::seconds(12345);
+  EXPECT_TIME("%r", time, sec);
+  EXPECT_TIME("%p", time, sec);
+}
+
+using dms = std::chrono::duration<double, std::milli>;
+
+TEST(chrono_test, format_default_fp) {
+  typedef std::chrono::duration<float> fs;
+  EXPECT_EQ("1.234s", fmt::format("{}", fs(1.234)));
+  typedef std::chrono::duration<float, std::milli> fms;
+  EXPECT_EQ("1.234ms", fmt::format("{}", fms(1.234)));
+  typedef std::chrono::duration<double> ds;
+  EXPECT_EQ("1.234s", fmt::format("{}", ds(1.234)));
+  EXPECT_EQ("1.234ms", fmt::format("{}", dms(1.234)));
+}
+
+TEST(chrono_test, format_precision) {
+  EXPECT_THROW_MSG(fmt::format(runtime("{:.2}"), std::chrono::seconds(42)),
+                   fmt::format_error,
+                   "precision not allowed for this argument type");
+  EXPECT_EQ("1.2ms", fmt::format("{:.1}", dms(1.234)));
+  EXPECT_EQ("1.23ms", fmt::format("{:.{}}", dms(1.234), 2));
+}
+
+TEST(chrono_test, format_full_specs) {
+  EXPECT_EQ("1.2ms ", fmt::format("{:6.1}", dms(1.234)));
+  EXPECT_EQ("  1.23ms", fmt::format("{:>8.{}}", dms(1.234), 2));
+  EXPECT_EQ(" 1.2ms ", fmt::format("{:^{}.{}}", dms(1.234), 7, 1));
+  EXPECT_EQ(" 1.23ms ", fmt::format("{0:^{2}.{1}}", dms(1.234), 2, 8));
+  EXPECT_EQ("=1.234ms=", fmt::format("{:=^{}.{}}", dms(1.234), 9, 3));
+  EXPECT_EQ("*1.2340ms*", fmt::format("{:*^10.4}", dms(1.234)));
+}
+
+TEST(chrono_test, format_simple_q) {
+  typedef std::chrono::duration<float> fs;
+  EXPECT_EQ("1.234 s", fmt::format("{:%Q %q}", fs(1.234)));
+  typedef std::chrono::duration<float, std::milli> fms;
+  EXPECT_EQ("1.234 ms", fmt::format("{:%Q %q}", fms(1.234)));
+  typedef std::chrono::duration<double> ds;
+  EXPECT_EQ("1.234 s", fmt::format("{:%Q %q}", ds(1.234)));
+  EXPECT_EQ("1.234 ms", fmt::format("{:%Q %q}", dms(1.234)));
+}
+
+TEST(chrono_test, format_precision_q) {
+  EXPECT_THROW_MSG(fmt::format(runtime("{:.2%Q %q}"), std::chrono::seconds(42)),
+                   fmt::format_error,
+                   "precision not allowed for this argument type");
+  EXPECT_EQ("1.2 ms", fmt::format("{:.1%Q %q}", dms(1.234)));
+  EXPECT_EQ("1.23 ms", fmt::format("{:.{}%Q %q}", dms(1.234), 2));
+}
+
+TEST(chrono_test, format_full_specs_q) {
+  EXPECT_EQ("1.2 ms ", fmt::format("{:7.1%Q %q}", dms(1.234)));
+  EXPECT_EQ(" 1.23 ms", fmt::format("{:>8.{}%Q %q}", dms(1.234), 2));
+  EXPECT_EQ(" 1.2 ms ", fmt::format("{:^{}.{}%Q %q}", dms(1.234), 8, 1));
+  EXPECT_EQ(" 1.23 ms ", fmt::format("{0:^{2}.{1}%Q %q}", dms(1.234), 2, 9));
+  EXPECT_EQ("=1.234 ms=", fmt::format("{:=^{}.{}%Q %q}", dms(1.234), 10, 3));
+  EXPECT_EQ("*1.2340 ms*", fmt::format("{:*^11.4%Q %q}", dms(1.234)));
+}
+
+TEST(chrono_test, invalid_width_id) {
+  EXPECT_THROW(fmt::format(runtime("{:{o}"), std::chrono::seconds(0)),
+               fmt::format_error);
+}
+
+TEST(chrono_test, invalid_colons) {
+  EXPECT_THROW(fmt::format(runtime("{0}=:{0::"), std::chrono::seconds(0)),
+               fmt::format_error);
+}
+
+TEST(chrono_test, negative_durations) {
+  EXPECT_EQ("-12345", fmt::format("{:%Q}", std::chrono::seconds(-12345)));
+  EXPECT_EQ("-03:25:45",
+            fmt::format("{:%H:%M:%S}", std::chrono::seconds(-12345)));
+  EXPECT_EQ("-00:01",
+            fmt::format("{:%M:%S}", std::chrono::duration<double>(-1)));
+  EXPECT_EQ("s", fmt::format("{:%q}", std::chrono::seconds(-12345)));
+  EXPECT_EQ("-00.127",
+            fmt::format("{:%S}",
+                        std::chrono::duration<signed char, std::milli>{-127}));
+  auto min = std::numeric_limits<int>::min();
+  EXPECT_EQ(fmt::format("{}", min),
+            fmt::format("{:%Q}", std::chrono::duration<int>(min)));
+}
+
+TEST(chrono_test, special_durations) {
+  EXPECT_EQ(
+      "40.",
+      fmt::format("{:%S}", std::chrono::duration<double>(1e20)).substr(0, 3));
+  auto nan = std::numeric_limits<double>::quiet_NaN();
+  EXPECT_EQ(
+      "nan nan nan nan nan:nan nan",
+      fmt::format("{:%I %H %M %S %R %r}", std::chrono::duration<double>(nan)));
+  fmt::format("{:%S}",
+              std::chrono::duration<float, std::atto>(1.79400457e+31f));
+  EXPECT_EQ(fmt::format("{}", std::chrono::duration<float, std::exa>(1)),
+            "1Es");
+  EXPECT_EQ(fmt::format("{}", std::chrono::duration<float, std::atto>(1)),
+            "1as");
+  EXPECT_EQ(fmt::format("{:%R}", std::chrono::duration<char, std::mega>{2}),
+            "03:33");
+  EXPECT_EQ(fmt::format("{:%T}", std::chrono::duration<char, std::mega>{2}),
+            "03:33:20");
+}
+
+TEST(chrono_test, unsigned_duration) {
+  EXPECT_EQ("42s", fmt::format("{}", std::chrono::duration<unsigned>(42)));
+}
+
+TEST(chrono_test, weekday) {
+  auto loc = get_locale("ru_RU.UTF-8");
+  std::locale::global(loc);
+  auto mon = fmt::weekday(1);
+  EXPECT_EQ(fmt::format("{}", mon), "Mon");
+  if (loc != std::locale::classic()) {
+    EXPECT_THAT((std::vector<std::string>{"пн", "Пн", "пнд", "Пнд"}),
+                Contains(fmt::format(loc, "{:L}", mon)));
+  }
+}
+
+#endif  // FMT_STATIC_THOUSANDS_SEPARATOR

vendor/Fmt/test/color-test.cc

@@ -0,0 +1,60 @@
+// Formatting library for C++ - color tests
+//
+// Copyright (c) 2012 - present, Victor Zverovich
+// All rights reserved.
+//
+// For the license information refer to format.h.
+
+#include "fmt/color.h"
+
+#include <iterator>  // std::back_inserter
+
+#include "gtest-extra.h"  // EXPECT_WRITE
+
+TEST(color_test, format) {
+  EXPECT_EQ(fmt::format(fg(fmt::rgb(255, 20, 30)), "rgb(255,20,30)"),
+            "\x1b[38;2;255;020;030mrgb(255,20,30)\x1b[0m");
+  EXPECT_EQ(fmt::format(fg(fmt::color::blue), "blue"),
+            "\x1b[38;2;000;000;255mblue\x1b[0m");
+  EXPECT_EQ(
+      fmt::format(fg(fmt::color::blue) | bg(fmt::color::red), "two color"),
+      "\x1b[38;2;000;000;255m\x1b[48;2;255;000;000mtwo color\x1b[0m");
+  EXPECT_EQ(fmt::format(fmt::emphasis::bold, "bold"), "\x1b[1mbold\x1b[0m");
+  EXPECT_EQ(fmt::format(fmt::emphasis::italic, "italic"),
+            "\x1b[3mitalic\x1b[0m");
+  EXPECT_EQ(fmt::format(fmt::emphasis::underline, "underline"),
+            "\x1b[4munderline\x1b[0m");
+  EXPECT_EQ(fmt::format(fmt::emphasis::strikethrough, "strikethrough"),
+            "\x1b[9mstrikethrough\x1b[0m");
+  EXPECT_EQ(
+      fmt::format(fg(fmt::color::blue) | fmt::emphasis::bold, "blue/bold"),
+      "\x1b[1m\x1b[38;2;000;000;255mblue/bold\x1b[0m");
+  EXPECT_EQ(fmt::format(fmt::emphasis::bold, "bold error"),
+            "\x1b[1mbold error\x1b[0m");
+  EXPECT_EQ(fmt::format(fg(fmt::color::blue), "blue log"),
+            "\x1b[38;2;000;000;255mblue log\x1b[0m");
+  EXPECT_EQ(fmt::format(fmt::text_style(), "hi"), "hi");
+  EXPECT_EQ(fmt::format(fg(fmt::terminal_color::red), "tred"),
+            "\x1b[31mtred\x1b[0m");
+  EXPECT_EQ(fmt::format(bg(fmt::terminal_color::cyan), "tcyan"),
+            "\x1b[46mtcyan\x1b[0m");
+  EXPECT_EQ(fmt::format(fg(fmt::terminal_color::bright_green), "tbgreen"),
+            "\x1b[92mtbgreen\x1b[0m");
+  EXPECT_EQ(fmt::format(bg(fmt::terminal_color::bright_magenta), "tbmagenta"),
+            "\x1b[105mtbmagenta\x1b[0m");
+  EXPECT_EQ(fmt::format(fg(fmt::terminal_color::red), "{}", "foo"),
+            "\x1b[31mfoo\x1b[0m");
+}
+
+TEST(color_test, format_to) {
+  auto out = std::string();
+  fmt::format_to(std::back_inserter(out), fg(fmt::rgb(255, 20, 30)),
+                 "rgb(255,20,30){}{}{}", 1, 2, 3);
+  EXPECT_EQ(fmt::to_string(out),
+            "\x1b[38;2;255;020;030mrgb(255,20,30)123\x1b[0m");
+}
+
+TEST(color_test, print) {
+  EXPECT_WRITE(stdout, fmt::print(fg(fmt::rgb(255, 20, 30)), "rgb(255,20,30)"),
+               "\x1b[38;2;255;020;030mrgb(255,20,30)\x1b[0m");
+}

vendor/Fmt/test/compile-error-test/CMakeLists.txt

@@ -0,0 +1,79 @@
+# Test if compile errors are produced where necessary.
+
+cmake_minimum_required(VERSION 3.1...3.18)
+
+include(CheckCXXSourceCompiles)
+include(CheckCXXCompilerFlag)
+
+set(CMAKE_REQUIRED_INCLUDES ${CMAKE_CURRENT_SOURCE_DIR}/../../include)
+set(CMAKE_REQUIRED_FLAGS ${CXX_STANDARD_FLAG} ${PEDANTIC_COMPILE_FLAGS})
+
+function (generate_source result fragment)
+  set(${result} "
+  #define FMT_HEADER_ONLY 1
+  #include \"fmt/format.h\"
+  int main() {
+    ${fragment}
+  }
+  " PARENT_SCOPE)
+endfunction ()
+
+function (expect_compile code)
+  generate_source(source "${code}")
+  check_cxx_source_compiles("${source}" compiles)
+  if (NOT compiles)
+    set(error_msg "Compile error for: ${code}")
+  endif ()
+  # Unset the CMake cache variable compiles. Otherwise the compile test will
+  # just use cached information next time it runs.
+  unset(compiles CACHE)
+  if (error_msg)
+    message(FATAL_ERROR ${error_msg})
+  endif ()
+endfunction ()
+
+function (expect_compile_error code)
+  generate_source(source "${code}")
+  check_cxx_source_compiles("${source}" compiles)
+  if (compiles)
+    set(error_msg "No compile error for: ${code}")
+  endif ()
+  # Unset the CMake cache variable compiles. Otherwise the compile test will
+  # just use cached information next time it runs.
+  unset(compiles CACHE)
+  if (error_msg)
+    message(FATAL_ERROR ${error_msg})
+  endif ()
+endfunction ()
+
+# check if the source file skeleton compiles
+expect_compile("")
+
+# Formatting a wide character with a narrow format string is forbidden.
+expect_compile_error("fmt::format(\"{}\", L'a');")
+
+# Formatting a wide string with a narrow format string is forbidden.
+expect_compile_error("fmt::format(\"{}\", L\"foo\");")
+
+# Formatting a narrow string with a wide format string is forbidden because
+# mixing UTF-8 with UTF-16/32 can result in an invalid output.
+expect_compile_error("fmt::format(L\"{}\", \"foo\");")
+
+# Formatting a wide string with a narrow format string is forbidden.
+expect_compile_error("
+  struct S {
+    operator std::string() const { return std::string(); }
+  };
+  fmt::format(\"{}\", S());
+")
+
+# Make sure that compiler features detected in the header
+# match the features detected in CMake.
+if (SUPPORTS_USER_DEFINED_LITERALS)
+  set(supports_udl 1)
+else ()
+  set(supports_udl 0)
+endif ()
+expect_compile("#if FMT_USE_USER_DEFINED_LITERALS != ${supports_udl}
+                # error
+                #endif")

vendor/Fmt/test/compile-test.cc

@@ -0,0 +1,359 @@
+// 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 "fmt/compile.h"
+
+#include <type_traits>
+
+#include "fmt/chrono.h"
+#include "gmock/gmock.h"
+#include "gtest-extra.h"
+
+TEST(iterator_test, counting_iterator) {
+  auto it = fmt::detail::counting_iterator();
+  auto prev = it++;
+  EXPECT_EQ(prev.count(), 0);
+  EXPECT_EQ(it.count(), 1);
+  EXPECT_EQ((it + 41).count(), 42);
+}
+
+TEST(iterator_test, truncating_iterator) {
+  char* p = nullptr;
+  auto it = fmt::detail::truncating_iterator<char*>(p, 3);
+  auto prev = it++;
+  EXPECT_EQ(prev.base(), p);
+  EXPECT_EQ(it.base(), p + 1);
+}
+
+TEST(iterator_test, truncating_iterator_default_construct) {
+  auto it = fmt::detail::truncating_iterator<char*>();
+  EXPECT_EQ(nullptr, it.base());
+  EXPECT_EQ(std::size_t{0}, it.count());
+}
+
+#ifdef __cpp_lib_ranges
+TEST(iterator_test, truncating_iterator_is_output_iterator) {
+  static_assert(
+      std::output_iterator<fmt::detail::truncating_iterator<char*>, char>);
+}
+#endif
+
+TEST(iterator_test, truncating_back_inserter) {
+  auto buffer = std::string();
+  auto bi = std::back_inserter(buffer);
+  auto it = fmt::detail::truncating_iterator<decltype(bi)>(bi, 2);
+  *it++ = '4';
+  *it++ = '2';
+  *it++ = '1';
+  EXPECT_EQ(buffer.size(), 2);
+  EXPECT_EQ(buffer, "42");
+}
+
+TEST(compile_test, compile_fallback) {
+  // FMT_COMPILE should fallback on runtime formatting when `if constexpr` is
+  // not available.
+  EXPECT_EQ("42", fmt::format(FMT_COMPILE("{}"), 42));
+}
+
+#ifdef __cpp_if_constexpr
+struct test_formattable {};
+
+FMT_BEGIN_NAMESPACE
+template <> struct formatter<test_formattable> : formatter<const char*> {
+  char word_spec = 'f';
+  constexpr auto parse(format_parse_context& ctx) {
+    auto it = ctx.begin(), end = ctx.end();
+    if (it == end || *it == '}') return it;
+    if (it != end && (*it == 'f' || *it == 'b')) word_spec = *it++;
+    if (it != end && *it != '}') throw format_error("invalid format");
+    return it;
+  }
+  template <typename FormatContext>
+  constexpr auto format(test_formattable, FormatContext& ctx) const
+      -> decltype(ctx.out()) {
+    return formatter<const char*>::format(word_spec == 'f' ? "foo" : "bar",
+                                          ctx);
+  }
+};
+FMT_END_NAMESPACE
+
+TEST(compile_test, format_default) {
+  EXPECT_EQ("42", fmt::format(FMT_COMPILE("{}"), 42));
+  EXPECT_EQ("42", fmt::format(FMT_COMPILE("{}"), 42u));
+  EXPECT_EQ("42", fmt::format(FMT_COMPILE("{}"), 42ll));
+  EXPECT_EQ("42", fmt::format(FMT_COMPILE("{}"), 42ull));
+  EXPECT_EQ("true", fmt::format(FMT_COMPILE("{}"), true));
+  EXPECT_EQ("x", fmt::format(FMT_COMPILE("{}"), 'x'));
+  EXPECT_EQ("4.2", fmt::format(FMT_COMPILE("{}"), 4.2));
+  EXPECT_EQ("foo", fmt::format(FMT_COMPILE("{}"), "foo"));
+  EXPECT_EQ("foo", fmt::format(FMT_COMPILE("{}"), std::string("foo")));
+  EXPECT_EQ("foo", fmt::format(FMT_COMPILE("{}"), test_formattable()));
+  auto t = std::chrono::system_clock::now();
+  EXPECT_EQ(fmt::format("{}", t), fmt::format(FMT_COMPILE("{}"), t));
+#  ifdef __cpp_lib_byte
+  EXPECT_EQ("42", fmt::format(FMT_COMPILE("{}"), std::byte{42}));
+#  endif
+}
+
+TEST(compile_test, format_wide_string) {
+  EXPECT_EQ(L"42", fmt::format(FMT_COMPILE(L"{}"), 42));
+}
+
+TEST(compile_test, format_specs) {
+  EXPECT_EQ("42", fmt::format(FMT_COMPILE("{:x}"), 0x42));
+  EXPECT_EQ("1.2 ms ",
+            fmt::format(FMT_COMPILE("{:7.1%Q %q}"),
+                        std::chrono::duration<double, std::milli>(1.234)));
+}
+
+TEST(compile_test, dynamic_format_specs) {
+  EXPECT_EQ("foo  ", fmt::format(FMT_COMPILE("{:{}}"), "foo", 5));
+  EXPECT_EQ("  3.14", fmt::format(FMT_COMPILE("{:{}.{}f}"), 3.141592, 6, 2));
+  EXPECT_EQ(
+      "=1.234ms=",
+      fmt::format(FMT_COMPILE("{:=^{}.{}}"),
+                  std::chrono::duration<double, std::milli>(1.234), 9, 3));
+}
+
+TEST(compile_test, manual_ordering) {
+  EXPECT_EQ("42", fmt::format(FMT_COMPILE("{0}"), 42));
+  EXPECT_EQ(" -42", fmt::format(FMT_COMPILE("{0:4}"), -42));
+  EXPECT_EQ("41 43", fmt::format(FMT_COMPILE("{0} {1}"), 41, 43));
+  EXPECT_EQ("41 43", fmt::format(FMT_COMPILE("{1} {0}"), 43, 41));
+  EXPECT_EQ("41 43", fmt::format(FMT_COMPILE("{0} {2}"), 41, 42, 43));
+  EXPECT_EQ("  41   43", fmt::format(FMT_COMPILE("{1:{2}} {0:4}"), 43, 41, 4));
+  EXPECT_EQ("42 1.2 ms ",
+            fmt::format(FMT_COMPILE("{0} {1:7.1%Q %q}"), 42,
+                        std::chrono::duration<double, std::milli>(1.234)));
+  EXPECT_EQ(
+      "true 42 42 foo 0x1234 foo",
+      fmt::format(FMT_COMPILE("{0} {1} {2} {3} {4} {5}"), true, 42, 42.0f,
+                  "foo", reinterpret_cast<void*>(0x1234), test_formattable()));
+  EXPECT_EQ(L"42", fmt::format(FMT_COMPILE(L"{0}"), 42));
+}
+
+TEST(compile_test, named) {
+  auto runtime_named_field_compiled =
+      fmt::detail::compile<decltype(fmt::arg("arg", 42))>(FMT_COMPILE("{arg}"));
+  static_assert(std::is_same_v<decltype(runtime_named_field_compiled),
+                               fmt::detail::runtime_named_field<char>>);
+
+  EXPECT_EQ("42", fmt::format(FMT_COMPILE("{}"), fmt::arg("arg", 42)));
+  EXPECT_EQ("41 43", fmt::format(FMT_COMPILE("{} {}"), fmt::arg("arg", 41),
+                                 fmt::arg("arg", 43)));
+
+  EXPECT_EQ("foobar",
+            fmt::format(FMT_COMPILE("{a0}{a1}"), fmt::arg("a0", "foo"),
+                        fmt::arg("a1", "bar")));
+  EXPECT_EQ("foobar", fmt::format(FMT_COMPILE("{}{a1}"), fmt::arg("a0", "foo"),
+                                  fmt::arg("a1", "bar")));
+  EXPECT_EQ("foofoo", fmt::format(FMT_COMPILE("{a0}{}"), fmt::arg("a0", "foo"),
+                                  fmt::arg("a1", "bar")));
+  EXPECT_EQ("foobar", fmt::format(FMT_COMPILE("{0}{a1}"), fmt::arg("a0", "foo"),
+                                  fmt::arg("a1", "bar")));
+  EXPECT_EQ("foobar", fmt::format(FMT_COMPILE("{a0}{1}"), fmt::arg("a0", "foo"),
+                                  fmt::arg("a1", "bar")));
+
+  EXPECT_EQ("foobar",
+            fmt::format(FMT_COMPILE("{}{a1}"), "foo", fmt::arg("a1", "bar")));
+  EXPECT_EQ("foobar",
+            fmt::format(FMT_COMPILE("{a0}{a1}"), fmt::arg("a1", "bar"),
+                        fmt::arg("a2", "baz"), fmt::arg("a0", "foo")));
+  EXPECT_EQ(" bar foo ",
+            fmt::format(FMT_COMPILE(" {foo} {bar} "), fmt::arg("foo", "bar"),
+                        fmt::arg("bar", "foo")));
+
+  EXPECT_THROW(fmt::format(FMT_COMPILE("{invalid}"), fmt::arg("valid", 42)),
+               fmt::format_error);
+
+#  if FMT_USE_NONTYPE_TEMPLATE_PARAMETERS
+  using namespace fmt::literals;
+  auto statically_named_field_compiled =
+      fmt::detail::compile<decltype("arg"_a = 42)>(FMT_COMPILE("{arg}"));
+  static_assert(std::is_same_v<decltype(statically_named_field_compiled),
+                               fmt::detail::field<char, int, 0>>);
+
+  EXPECT_EQ("41 43",
+            fmt::format(FMT_COMPILE("{a0} {a1}"), "a0"_a = 41, "a1"_a = 43));
+  EXPECT_EQ("41 43",
+            fmt::format(FMT_COMPILE("{a1} {a0}"), "a0"_a = 43, "a1"_a = 41));
+#  endif
+}
+
+TEST(compile_test, format_to) {
+  char buf[8];
+  auto end = fmt::format_to(buf, FMT_COMPILE("{}"), 42);
+  *end = '\0';
+  EXPECT_STREQ("42", buf);
+  end = fmt::format_to(buf, FMT_COMPILE("{:x}"), 42);
+  *end = '\0';
+  EXPECT_STREQ("2a", buf);
+}
+
+TEST(compile_test, format_to_n) {
+  constexpr auto buffer_size = 8;
+  char buffer[buffer_size];
+  auto res = fmt::format_to_n(buffer, buffer_size, FMT_COMPILE("{}"), 42);
+  *res.out = '\0';
+  EXPECT_STREQ("42", buffer);
+  res = fmt::format_to_n(buffer, buffer_size, FMT_COMPILE("{:x}"), 42);
+  *res.out = '\0';
+  EXPECT_STREQ("2a", buffer);
+}
+
+TEST(compile_test, formatted_size) {
+  EXPECT_EQ(2, fmt::formatted_size(FMT_COMPILE("{0}"), 42));
+  EXPECT_EQ(5, fmt::formatted_size(FMT_COMPILE("{0:<4.2f}"), 42.0));
+}
+
+TEST(compile_test, text_and_arg) {
+  EXPECT_EQ(">>>42<<<", fmt::format(FMT_COMPILE(">>>{}<<<"), 42));
+  EXPECT_EQ("42!", fmt::format(FMT_COMPILE("{}!"), 42));
+}
+
+TEST(compile_test, unknown_format_fallback) {
+  EXPECT_EQ(" 42 ",
+            fmt::format(FMT_COMPILE("{name:^4}"), fmt::arg("name", 42)));
+
+  std::vector<char> v;
+  fmt::format_to(std::back_inserter(v), FMT_COMPILE("{name:^4}"),
+                 fmt::arg("name", 42));
+  EXPECT_EQ(" 42 ", fmt::string_view(v.data(), v.size()));
+
+  char buffer[4];
+  auto result = fmt::format_to_n(buffer, 4, FMT_COMPILE("{name:^5}"),
+                                 fmt::arg("name", 42));
+  EXPECT_EQ(5u, result.size);
+  EXPECT_EQ(buffer + 4, result.out);
+  EXPECT_EQ(" 42 ", fmt::string_view(buffer, 4));
+}
+
+TEST(compile_test, empty) { EXPECT_EQ("", fmt::format(FMT_COMPILE(""))); }
+
+struct to_stringable {
+  friend fmt::string_view to_string_view(to_stringable) { return {}; }
+};
+
+FMT_BEGIN_NAMESPACE
+template <> struct formatter<to_stringable> {
+  auto parse(format_parse_context& ctx) const -> decltype(ctx.begin()) {
+    return ctx.begin();
+  }
+
+  template <typename FormatContext>
+  auto format(const to_stringable&, FormatContext& ctx) -> decltype(ctx.out()) {
+    return ctx.out();
+  }
+};
+FMT_END_NAMESPACE
+
+TEST(compile_test, to_string_and_formatter) {
+  fmt::format(FMT_COMPILE("{}"), to_stringable());
+}
+
+TEST(compile_test, print) {
+  EXPECT_WRITE(stdout, fmt::print(FMT_COMPILE("Don't {}!"), "panic"),
+               "Don't panic!");
+  EXPECT_WRITE(stderr, fmt::print(stderr, FMT_COMPILE("Don't {}!"), "panic"),
+               "Don't panic!");
+}
+#endif
+
+#if FMT_USE_NONTYPE_TEMPLATE_PARAMETERS
+TEST(compile_test, compile_format_string_literal) {
+  using namespace fmt::literals;
+  EXPECT_EQ("", fmt::format(""_cf));
+  EXPECT_EQ("42", fmt::format("{}"_cf, 42));
+  EXPECT_EQ(L"42", fmt::format(L"{}"_cf, 42));
+}
+#endif
+
+#if __cplusplus >= 202002L || \
+    (__cplusplus >= 201709L && FMT_GCC_VERSION >= 1002)
+template <size_t max_string_length, typename Char = char> struct test_string {
+  template <typename T> constexpr bool operator==(const T& rhs) const noexcept {
+    return fmt::basic_string_view<Char>(rhs).compare(buffer) == 0;
+  }
+  Char buffer[max_string_length]{};
+};
+
+template <size_t max_string_length, typename Char = char, typename... Args>
+consteval auto test_format(auto format, const Args&... args) {
+  test_string<max_string_length, Char> string{};
+  fmt::format_to(string.buffer, format, args...);
+  return string;
+}
+
+TEST(compile_time_formatting_test, bool) {
+  EXPECT_EQ("true", test_format<5>(FMT_COMPILE("{}"), true));
+  EXPECT_EQ("false", test_format<6>(FMT_COMPILE("{}"), false));
+  EXPECT_EQ("true ", test_format<6>(FMT_COMPILE("{:5}"), true));
+  EXPECT_EQ("1", test_format<2>(FMT_COMPILE("{:d}"), true));
+}
+
+TEST(compile_time_formatting_test, integer) {
+  EXPECT_EQ("42", test_format<3>(FMT_COMPILE("{}"), 42));
+  EXPECT_EQ("420", test_format<4>(FMT_COMPILE("{}"), 420));
+  EXPECT_EQ("42 42", test_format<6>(FMT_COMPILE("{} {}"), 42, 42));
+  EXPECT_EQ("42 42",
+            test_format<6>(FMT_COMPILE("{} {}"), uint32_t{42}, uint64_t{42}));
+
+  EXPECT_EQ("+42", test_format<4>(FMT_COMPILE("{:+}"), 42));
+  EXPECT_EQ("42", test_format<3>(FMT_COMPILE("{:-}"), 42));
+  EXPECT_EQ(" 42", test_format<4>(FMT_COMPILE("{: }"), 42));
+
+  EXPECT_EQ("-0042", test_format<6>(FMT_COMPILE("{:05}"), -42));
+
+  EXPECT_EQ("101010", test_format<7>(FMT_COMPILE("{:b}"), 42));
+  EXPECT_EQ("0b101010", test_format<9>(FMT_COMPILE("{:#b}"), 42));
+  EXPECT_EQ("0B101010", test_format<9>(FMT_COMPILE("{:#B}"), 42));
+  EXPECT_EQ("042", test_format<4>(FMT_COMPILE("{:#o}"), 042));
+  EXPECT_EQ("0x4a", test_format<5>(FMT_COMPILE("{:#x}"), 0x4a));
+  EXPECT_EQ("0X4A", test_format<5>(FMT_COMPILE("{:#X}"), 0x4a));
+
+  EXPECT_EQ("   42", test_format<6>(FMT_COMPILE("{:5}"), 42));
+  EXPECT_EQ("   42", test_format<6>(FMT_COMPILE("{:5}"), 42ll));
+  EXPECT_EQ("   42", test_format<6>(FMT_COMPILE("{:5}"), 42ull));
+
+  EXPECT_EQ("42  ", test_format<5>(FMT_COMPILE("{:<4}"), 42));
+  EXPECT_EQ("  42", test_format<5>(FMT_COMPILE("{:>4}"), 42));
+  EXPECT_EQ(" 42 ", test_format<5>(FMT_COMPILE("{:^4}"), 42));
+  EXPECT_EQ("**-42", test_format<6>(FMT_COMPILE("{:*>5}"), -42));
+}
+
+TEST(compile_time_formatting_test, char) {
+  EXPECT_EQ("c", test_format<2>(FMT_COMPILE("{}"), 'c'));
+
+  EXPECT_EQ("c  ", test_format<4>(FMT_COMPILE("{:3}"), 'c'));
+  EXPECT_EQ("99", test_format<3>(FMT_COMPILE("{:d}"), 'c'));
+}
+
+TEST(compile_time_formatting_test, string) {
+  EXPECT_EQ("42", test_format<3>(FMT_COMPILE("{}"), "42"));
+  EXPECT_EQ("The answer is 42",
+            test_format<17>(FMT_COMPILE("{} is {}"), "The answer", "42"));
+
+  EXPECT_EQ("abc**", test_format<6>(FMT_COMPILE("{:*<5}"), "abc"));
+  EXPECT_EQ("**🤡**", test_format<9>(FMT_COMPILE("{:*^6}"), "🤡"));
+}
+
+TEST(compile_time_formatting_test, combination) {
+  EXPECT_EQ("420, true, answer",
+            test_format<18>(FMT_COMPILE("{}, {}, {}"), 420, true, "answer"));
+
+  EXPECT_EQ(" -42", test_format<5>(FMT_COMPILE("{:{}}"), -42, 4));
+}
+
+TEST(compile_time_formatting_test, custom_type) {
+  EXPECT_EQ("foo", test_format<4>(FMT_COMPILE("{}"), test_formattable()));
+  EXPECT_EQ("bar", test_format<4>(FMT_COMPILE("{:b}"), test_formattable()));
+}
+
+TEST(compile_time_formatting_test, multibyte_fill) {
+  EXPECT_EQ("жж42", test_format<8>(FMT_COMPILE("{:ж>4}"), 42));
+}
+#endif

vendor/Fmt/test/core-test.cc

@@ -0,0 +1,847 @@
+// Formatting library for C++ - core tests
+//
+// Copyright (c) 2012 - present, Victor Zverovich
+// All rights reserved.
+//
+// For the license information refer to format.h.
+
+// clang-format off
+#include "test-assert.h"
+// clang-format on
+
+#include "fmt/core.h"
+
+#include <algorithm>    // std::copy_n
+#include <climits>      // INT_MAX
+#include <cstring>      // std::strlen
+#include <functional>   // std::equal_to
+#include <iterator>     // std::back_insert_iterator
+#include <limits>       // std::numeric_limits
+#include <string>       // std::string
+#include <type_traits>  // std::is_same
+
+#include "gmock/gmock.h"
+
+using fmt::string_view;
+using fmt::detail::buffer;
+
+using testing::_;
+using testing::Invoke;
+using testing::Return;
+
+#ifdef FMT_FORMAT_H_
+#  error core-test includes format.h
+#endif
+
+TEST(string_view_test, value_type) {
+  static_assert(std::is_same<string_view::value_type, char>::value, "");
+}
+
+TEST(string_view_test, ctor) {
+  EXPECT_STREQ("abc", fmt::string_view("abc").data());
+  EXPECT_EQ(3u, fmt::string_view("abc").size());
+
+  EXPECT_STREQ("defg", fmt::string_view(std::string("defg")).data());
+  EXPECT_EQ(4u, fmt::string_view(std::string("defg")).size());
+}
+
+TEST(string_view_test, length) {
+  // Test that string_view::size() returns string length, not buffer size.
+  char str[100] = "some string";
+  EXPECT_EQ(std::strlen(str), string_view(str).size());
+  EXPECT_LT(std::strlen(str), sizeof(str));
+}
+
+// Check string_view's comparison operator.
+template <template <typename> class Op> void check_op() {
+  const char* inputs[] = {"foo", "fop", "fo"};
+  size_t num_inputs = sizeof(inputs) / sizeof(*inputs);
+  for (size_t i = 0; i < num_inputs; ++i) {
+    for (size_t j = 0; j < num_inputs; ++j) {
+      string_view lhs(inputs[i]), rhs(inputs[j]);
+      EXPECT_EQ(Op<int>()(lhs.compare(rhs), 0), Op<string_view>()(lhs, rhs));
+    }
+  }
+}
+
+TEST(string_view_test, compare) {
+  EXPECT_EQ(string_view("foo").compare(string_view("foo")), 0);
+  EXPECT_GT(string_view("fop").compare(string_view("foo")), 0);
+  EXPECT_LT(string_view("foo").compare(string_view("fop")), 0);
+  EXPECT_GT(string_view("foo").compare(string_view("fo")), 0);
+  EXPECT_LT(string_view("fo").compare(string_view("foo")), 0);
+  check_op<std::equal_to>();
+  check_op<std::not_equal_to>();
+  check_op<std::less>();
+  check_op<std::less_equal>();
+  check_op<std::greater>();
+  check_op<std::greater_equal>();
+}
+
+namespace test_ns {
+template <typename Char> class test_string {
+ private:
+  std::basic_string<Char> s_;
+
+ public:
+  test_string(const Char* s) : s_(s) {}
+  const Char* data() const { return s_.data(); }
+  size_t length() const { return s_.size(); }
+  operator const Char*() const { return s_.c_str(); }
+};
+
+template <typename Char>
+fmt::basic_string_view<Char> to_string_view(const test_string<Char>& s) {
+  return {s.data(), s.length()};
+}
+}  // namespace test_ns
+
+TEST(core_test, is_output_iterator) {
+  EXPECT_TRUE((fmt::detail::is_output_iterator<char*, char>::value));
+  EXPECT_FALSE((fmt::detail::is_output_iterator<const char*, char>::value));
+  EXPECT_FALSE((fmt::detail::is_output_iterator<std::string, char>::value));
+  EXPECT_TRUE(
+      (fmt::detail::is_output_iterator<std::back_insert_iterator<std::string>,
+                                       char>::value));
+  EXPECT_TRUE(
+      (fmt::detail::is_output_iterator<std::string::iterator, char>::value));
+  EXPECT_FALSE((fmt::detail::is_output_iterator<std::string::const_iterator,
+                                                char>::value));
+}
+
+TEST(core_test, buffer_appender) {
+  // back_insert_iterator is not default-constructible before C++20, so
+  // buffer_appender can only be default-constructible when back_insert_iterator
+  // is.
+  static_assert(
+      std::is_default_constructible<
+          std::back_insert_iterator<fmt::detail::buffer<char>>>::value ==
+          std::is_default_constructible<
+              fmt::detail::buffer_appender<char>>::value,
+      "");
+
+#ifdef __cpp_lib_ranges
+  static_assert(std::output_iterator<fmt::detail::buffer_appender<char>, char>);
+#endif
+}
+
+#if !FMT_GCC_VERSION || FMT_GCC_VERSION >= 470
+TEST(buffer_test, noncopyable) {
+  EXPECT_FALSE(std::is_copy_constructible<buffer<char>>::value);
+#  if !FMT_MSC_VER
+  // std::is_copy_assignable is broken in MSVC2013.
+  EXPECT_FALSE(std::is_copy_assignable<buffer<char>>::value);
+#  endif
+}
+
+TEST(buffer_test, nonmoveable) {
+  EXPECT_FALSE(std::is_move_constructible<buffer<char>>::value);
+#  if !FMT_MSC_VER
+  // std::is_move_assignable is broken in MSVC2013.
+  EXPECT_FALSE(std::is_move_assignable<buffer<char>>::value);
+#  endif
+}
+#endif
+
+TEST(buffer_test, indestructible) {
+  static_assert(!std::is_destructible<fmt::detail::buffer<int>>(),
+                "buffer's destructor is protected");
+}
+
+template <typename T> struct mock_buffer final : buffer<T> {
+  MOCK_METHOD1(do_grow, size_t(size_t capacity));
+
+  void grow(size_t capacity) { this->set(this->data(), do_grow(capacity)); }
+
+  mock_buffer(T* data = nullptr, size_t buf_capacity = 0) {
+    this->set(data, buf_capacity);
+    ON_CALL(*this, do_grow(_)).WillByDefault(Invoke([](size_t capacity) {
+      return capacity;
+    }));
+  }
+};
+
+TEST(buffer_test, ctor) {
+  {
+    mock_buffer<int> buffer;
+    EXPECT_EQ(nullptr, buffer.data());
+    EXPECT_EQ(static_cast<size_t>(0), buffer.size());
+    EXPECT_EQ(static_cast<size_t>(0), buffer.capacity());
+  }
+  {
+    int dummy;
+    mock_buffer<int> buffer(&dummy);
+    EXPECT_EQ(&dummy, &buffer[0]);
+    EXPECT_EQ(static_cast<size_t>(0), buffer.size());
+    EXPECT_EQ(static_cast<size_t>(0), buffer.capacity());
+  }
+  {
+    int dummy;
+    size_t capacity = std::numeric_limits<size_t>::max();
+    mock_buffer<int> buffer(&dummy, capacity);
+    EXPECT_EQ(&dummy, &buffer[0]);
+    EXPECT_EQ(static_cast<size_t>(0), buffer.size());
+    EXPECT_EQ(capacity, buffer.capacity());
+  }
+}
+
+TEST(buffer_test, access) {
+  char data[10];
+  mock_buffer<char> buffer(data, sizeof(data));
+  buffer[0] = 11;
+  EXPECT_EQ(11, buffer[0]);
+  buffer[3] = 42;
+  EXPECT_EQ(42, *(&buffer[0] + 3));
+  const fmt::detail::buffer<char>& const_buffer = buffer;
+  EXPECT_EQ(42, const_buffer[3]);
+}
+
+TEST(buffer_test, try_resize) {
+  char data[123];
+  mock_buffer<char> buffer(data, sizeof(data));
+  buffer[10] = 42;
+  EXPECT_EQ(42, buffer[10]);
+  buffer.try_resize(20);
+  EXPECT_EQ(20u, buffer.size());
+  EXPECT_EQ(123u, buffer.capacity());
+  EXPECT_EQ(42, buffer[10]);
+  buffer.try_resize(5);
+  EXPECT_EQ(5u, buffer.size());
+  EXPECT_EQ(123u, buffer.capacity());
+  EXPECT_EQ(42, buffer[10]);
+  // Check if try_resize calls grow.
+  EXPECT_CALL(buffer, do_grow(124));
+  buffer.try_resize(124);
+  EXPECT_CALL(buffer, do_grow(200));
+  buffer.try_resize(200);
+}
+
+TEST(buffer_test, try_resize_partial) {
+  char data[10];
+  mock_buffer<char> buffer(data, sizeof(data));
+  EXPECT_CALL(buffer, do_grow(20)).WillOnce(Return(15));
+  buffer.try_resize(20);
+  EXPECT_EQ(buffer.capacity(), 15);
+  EXPECT_EQ(buffer.size(), 15);
+}
+
+TEST(buffer_test, clear) {
+  mock_buffer<char> buffer;
+  EXPECT_CALL(buffer, do_grow(20));
+  buffer.try_resize(20);
+  buffer.try_resize(0);
+  EXPECT_EQ(static_cast<size_t>(0), buffer.size());
+  EXPECT_EQ(20u, buffer.capacity());
+}
+
+TEST(buffer_test, append) {
+  char data[15];
+  mock_buffer<char> buffer(data, 10);
+  auto test = "test";
+  buffer.append(test, test + 5);
+  EXPECT_STREQ(test, &buffer[0]);
+  EXPECT_EQ(5u, buffer.size());
+  buffer.try_resize(10);
+  EXPECT_CALL(buffer, do_grow(12));
+  buffer.append(test, test + 2);
+  EXPECT_EQ('t', buffer[10]);
+  EXPECT_EQ('e', buffer[11]);
+  EXPECT_EQ(12u, buffer.size());
+}
+
+TEST(buffer_test, append_partial) {
+  char data[10];
+  mock_buffer<char> buffer(data, sizeof(data));
+  testing::InSequence seq;
+  EXPECT_CALL(buffer, do_grow(15)).WillOnce(Return(10));
+  EXPECT_CALL(buffer, do_grow(15)).WillOnce(Invoke([&buffer](size_t) {
+    EXPECT_EQ(fmt::string_view(buffer.data(), buffer.size()), "0123456789");
+    buffer.clear();
+    return 10;
+  }));
+  auto test = "0123456789abcde";
+  buffer.append(test, test + 15);
+}
+
+TEST(buffer_test, append_allocates_enough_storage) {
+  char data[19];
+  mock_buffer<char> buffer(data, 10);
+  auto test = "abcdefgh";
+  buffer.try_resize(10);
+  EXPECT_CALL(buffer, do_grow(19));
+  buffer.append(test, test + 9);
+}
+
+struct custom_context {
+  using char_type = char;
+  using parse_context_type = fmt::format_parse_context;
+
+  bool called = false;
+
+  template <typename T> struct formatter_type {
+    auto parse(fmt::format_parse_context& ctx) -> decltype(ctx.begin()) {
+      return ctx.begin();
+    }
+
+    const char* format(const T&, custom_context& ctx) {
+      ctx.called = true;
+      return nullptr;
+    }
+  };
+
+  void advance_to(const char*) {}
+};
+
+struct test_struct {};
+
+FMT_BEGIN_NAMESPACE
+template <typename Char> struct formatter<test_struct, Char> {
+  auto parse(format_parse_context& ctx) -> decltype(ctx.begin()) {
+    return ctx.begin();
+  }
+
+  auto format(test_struct, format_context& ctx) -> decltype(ctx.out()) {
+    auto test = string_view("test");
+    return std::copy_n(test.data(), test.size(), ctx.out());
+  }
+};
+FMT_END_NAMESPACE
+
+TEST(arg_test, format_args) {
+  auto args = fmt::format_args();
+  EXPECT_FALSE(args.get(1));
+}
+
+TEST(arg_test, make_value_with_custom_context) {
+  auto t = test_struct();
+  fmt::detail::value<custom_context> arg(
+      fmt::detail::arg_mapper<custom_context>().map(t));
+  auto ctx = custom_context();
+  auto parse_ctx = fmt::format_parse_context("");
+  arg.custom.format(&t, parse_ctx, ctx);
+  EXPECT_TRUE(ctx.called);
+}
+
+// Use a unique result type to make sure that there are no undesirable
+// conversions.
+struct test_result {};
+
+template <typename T> struct mock_visitor {
+  template <typename U> struct result { using type = test_result; };
+
+  mock_visitor() {
+    ON_CALL(*this, visit(_)).WillByDefault(Return(test_result()));
+  }
+
+  MOCK_METHOD1_T(visit, test_result(T value));
+  MOCK_METHOD0_T(unexpected, void());
+
+  test_result operator()(T value) { return visit(value); }
+
+  template <typename U> test_result operator()(U) {
+    unexpected();
+    return test_result();
+  }
+};
+
+template <typename T> struct visit_type { using type = T; };
+
+#define VISIT_TYPE(type_, visit_type_) \
+  template <> struct visit_type<type_> { using type = visit_type_; }
+
+VISIT_TYPE(signed char, int);
+VISIT_TYPE(unsigned char, unsigned);
+VISIT_TYPE(short, int);
+VISIT_TYPE(unsigned short, unsigned);
+
+#if LONG_MAX == INT_MAX
+VISIT_TYPE(long, int);
+VISIT_TYPE(unsigned long, unsigned);
+#else
+VISIT_TYPE(long, long long);
+VISIT_TYPE(unsigned long, unsigned long long);
+#endif
+
+#define CHECK_ARG(Char, expected, value)                                  \
+  {                                                                       \
+    testing::StrictMock<mock_visitor<decltype(expected)>> visitor;        \
+    EXPECT_CALL(visitor, visit(expected));                                \
+    using iterator = std::back_insert_iterator<buffer<Char>>;             \
+    fmt::visit_format_arg(                                                \
+        visitor,                                                          \
+        fmt::detail::make_arg<fmt::basic_format_context<iterator, Char>>( \
+            value));                                                      \
+  }
+
+#define CHECK_ARG_SIMPLE(value)                             \
+  {                                                         \
+    using value_type = decltype(value);                     \
+    typename visit_type<value_type>::type expected = value; \
+    CHECK_ARG(char, expected, value)                        \
+    CHECK_ARG(wchar_t, expected, value)                     \
+  }
+
+template <typename T> class numeric_arg_test : public testing::Test {};
+
+using types =
+    testing::Types<bool, signed char, unsigned char, short, unsigned short, int,
+                   unsigned, long, unsigned long, long long, unsigned long long,
+                   float, double, long double>;
+TYPED_TEST_SUITE(numeric_arg_test, types);
+
+template <typename T, fmt::enable_if_t<std::is_integral<T>::value, int> = 0>
+T test_value() {
+  return static_cast<T>(42);
+}
+
+template <typename T,
+          fmt::enable_if_t<std::is_floating_point<T>::value, int> = 0>
+T test_value() {
+  return static_cast<T>(4.2);
+}
+
+TYPED_TEST(numeric_arg_test, make_and_visit) {
+  CHECK_ARG_SIMPLE(test_value<TypeParam>());
+  CHECK_ARG_SIMPLE(std::numeric_limits<TypeParam>::min());
+  CHECK_ARG_SIMPLE(std::numeric_limits<TypeParam>::max());
+}
+
+namespace fmt {
+template <> struct is_char<wchar_t> : std::true_type {};
+}  // namespace fmt
+
+TEST(arg_test, char_arg) {
+  CHECK_ARG(char, 'a', 'a');
+  CHECK_ARG(wchar_t, L'a', 'a');
+  CHECK_ARG(wchar_t, L'a', L'a');
+}
+
+TEST(arg_test, string_arg) {
+  char str_data[] = "test";
+  char* str = str_data;
+  const char* cstr = str;
+  CHECK_ARG(char, cstr, str);
+
+  auto sv = fmt::string_view(str);
+  CHECK_ARG(char, sv, std::string(str));
+}
+
+TEST(arg_test, wstring_arg) {
+  wchar_t str_data[] = L"test";
+  wchar_t* str = str_data;
+  const wchar_t* cstr = str;
+
+  auto sv = fmt::basic_string_view<wchar_t>(str);
+  CHECK_ARG(wchar_t, cstr, str);
+  CHECK_ARG(wchar_t, cstr, cstr);
+  CHECK_ARG(wchar_t, sv, std::wstring(str));
+  CHECK_ARG(wchar_t, sv, fmt::basic_string_view<wchar_t>(str));
+}
+
+TEST(arg_test, pointer_arg) {
+  void* p = nullptr;
+  const void* cp = nullptr;
+  CHECK_ARG(char, cp, p);
+  CHECK_ARG(wchar_t, cp, p);
+  CHECK_ARG_SIMPLE(cp);
+}
+
+struct check_custom {
+  test_result operator()(
+      fmt::basic_format_arg<fmt::format_context>::handle h) const {
+    struct test_buffer final : fmt::detail::buffer<char> {
+      char data[10];
+      test_buffer() : fmt::detail::buffer<char>(data, 0, 10) {}
+      void grow(size_t) {}
+    } buffer;
+    auto parse_ctx = fmt::format_parse_context("");
+    auto ctx = fmt::format_context(fmt::detail::buffer_appender<char>(buffer),
+                                   fmt::format_args());
+    h.format(parse_ctx, ctx);
+    EXPECT_EQ("test", std::string(buffer.data, buffer.size()));
+    return test_result();
+  }
+};
+
+TEST(arg_test, custom_arg) {
+  auto test = test_struct();
+  using visitor =
+      mock_visitor<fmt::basic_format_arg<fmt::format_context>::handle>;
+  testing::StrictMock<visitor> v;
+  EXPECT_CALL(v, visit(_)).WillOnce(Invoke(check_custom()));
+  fmt::visit_format_arg(v, fmt::detail::make_arg<fmt::format_context>(test));
+}
+
+TEST(arg_test, visit_invalid_arg) {
+  testing::StrictMock<mock_visitor<fmt::monostate>> visitor;
+  EXPECT_CALL(visitor, visit(_));
+  auto arg = fmt::basic_format_arg<fmt::format_context>();
+  fmt::visit_format_arg(visitor, arg);
+}
+
+#if FMT_USE_CONSTEXPR
+
+enum class arg_id_result { none, empty, index, name, error };
+struct test_arg_id_handler {
+  arg_id_result res = arg_id_result::none;
+  int index = 0;
+  string_view name;
+
+  constexpr void operator()() { res = arg_id_result::empty; }
+
+  constexpr void operator()(int i) {
+    res = arg_id_result::index;
+    index = i;
+  }
+
+  constexpr void operator()(string_view n) {
+    res = arg_id_result::name;
+    name = n;
+  }
+
+  constexpr void on_error(const char*) { res = arg_id_result::error; }
+};
+
+template <size_t N>
+constexpr test_arg_id_handler parse_arg_id(const char (&s)[N]) {
+  test_arg_id_handler h;
+  fmt::detail::parse_arg_id(s, s + N, h);
+  return h;
+}
+
+TEST(format_test, constexpr_parse_arg_id) {
+  static_assert(parse_arg_id(":").res == arg_id_result::empty, "");
+  static_assert(parse_arg_id("}").res == arg_id_result::empty, "");
+  static_assert(parse_arg_id("42:").res == arg_id_result::index, "");
+  static_assert(parse_arg_id("42:").index == 42, "");
+  static_assert(parse_arg_id("foo:").res == arg_id_result::name, "");
+  static_assert(parse_arg_id("foo:").name.size() == 3, "");
+  static_assert(parse_arg_id("!").res == arg_id_result::error, "");
+}
+
+struct test_format_specs_handler {
+  enum result { none, hash, zero, loc, error };
+  result res = none;
+
+  fmt::align_t alignment = fmt::align::none;
+  fmt::sign_t sign = fmt::sign::none;
+  char fill = 0;
+  int width = 0;
+  fmt::detail::arg_ref<char> width_ref;
+  int precision = 0;
+  fmt::detail::arg_ref<char> precision_ref;
+  char type = 0;
+
+  // Workaround for MSVC2017 bug that results in "expression did not evaluate
+  // to a constant" with compiler-generated copy ctor.
+  constexpr test_format_specs_handler() {}
+  constexpr test_format_specs_handler(const test_format_specs_handler& other) =
+      default;
+
+  constexpr void on_align(fmt::align_t a) { alignment = a; }
+  constexpr void on_fill(fmt::string_view f) { fill = f[0]; }
+  constexpr void on_sign(fmt::sign_t s) { sign = s; }
+  constexpr void on_hash() { res = hash; }
+  constexpr void on_zero() { res = zero; }
+  constexpr void on_localized() { res = loc; }
+
+  constexpr void on_width(int w) { width = w; }
+  constexpr void on_dynamic_width(fmt::detail::auto_id) {}
+  constexpr void on_dynamic_width(int index) { width_ref = index; }
+  constexpr void on_dynamic_width(string_view) {}
+
+  constexpr void on_precision(int p) { precision = p; }
+  constexpr void on_dynamic_precision(fmt::detail::auto_id) {}
+  constexpr void on_dynamic_precision(int index) { precision_ref = index; }
+  constexpr void on_dynamic_precision(string_view) {}
+
+  constexpr void end_precision() {}
+  constexpr void on_type(char t) { type = t; }
+  constexpr void on_error(const char*) { res = error; }
+};
+
+template <size_t N>
+constexpr test_format_specs_handler parse_test_specs(const char (&s)[N]) {
+  auto h = test_format_specs_handler();
+  fmt::detail::parse_format_specs(s, s + N, h);
+  return h;
+}
+
+TEST(core_test, constexpr_parse_format_specs) {
+  using handler = test_format_specs_handler;
+  static_assert(parse_test_specs("<").alignment == fmt::align::left, "");
+  static_assert(parse_test_specs("*^").fill == '*', "");
+  static_assert(parse_test_specs("+").sign == fmt::sign::plus, "");
+  static_assert(parse_test_specs("-").sign == fmt::sign::minus, "");
+  static_assert(parse_test_specs(" ").sign == fmt::sign::space, "");
+  static_assert(parse_test_specs("#").res == handler::hash, "");
+  static_assert(parse_test_specs("0").res == handler::zero, "");
+  static_assert(parse_test_specs("L").res == handler::loc, "");
+  static_assert(parse_test_specs("42").width == 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.val.index == 42, "");
+  static_assert(parse_test_specs("d").type == 'd', "");
+  static_assert(parse_test_specs("{<").res == handler::error, "");
+}
+
+struct test_parse_context {
+  using char_type = char;
+
+  constexpr int next_arg_id() { return 11; }
+  template <typename Id> FMT_CONSTEXPR void check_arg_id(Id) {}
+
+  constexpr const char* begin() { return nullptr; }
+  constexpr const char* end() { return nullptr; }
+
+  void on_error(const char*) {}
+};
+
+template <size_t N>
+constexpr fmt::detail::dynamic_format_specs<char> parse_dynamic_specs(
+    const char (&s)[N]) {
+  auto specs = fmt::detail::dynamic_format_specs<char>();
+  auto ctx = test_parse_context();
+  auto h = fmt::detail::dynamic_specs_handler<test_parse_context>(specs, ctx);
+  parse_format_specs(s, s + N, h);
+  return specs;
+}
+
+TEST(format_test, constexpr_dynamic_specs_handler) {
+  static_assert(parse_dynamic_specs("<").align == fmt::align::left, "");
+  static_assert(parse_dynamic_specs("*^").fill[0] == '*', "");
+  static_assert(parse_dynamic_specs("+").sign == fmt::sign::plus, "");
+  static_assert(parse_dynamic_specs("-").sign == fmt::sign::minus, "");
+  static_assert(parse_dynamic_specs(" ").sign == fmt::sign::space, "");
+  static_assert(parse_dynamic_specs("#").alt, "");
+  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.val.index == 11, "");
+  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.val.index == 11, "");
+  static_assert(parse_dynamic_specs(".{42}").precision_ref.val.index == 42, "");
+  static_assert(parse_dynamic_specs("d").type == 'd', "");
+}
+
+template <size_t N>
+constexpr test_format_specs_handler check_specs(const char (&s)[N]) {
+  fmt::detail::specs_checker<test_format_specs_handler> checker(
+      test_format_specs_handler(), fmt::detail::type::double_type);
+  parse_format_specs(s, s + N, checker);
+  return checker;
+}
+
+TEST(format_test, constexpr_specs_checker) {
+  using handler = test_format_specs_handler;
+  static_assert(check_specs("<").alignment == fmt::align::left, "");
+  static_assert(check_specs("*^").fill == '*', "");
+  static_assert(check_specs("+").sign == fmt::sign::plus, "");
+  static_assert(check_specs("-").sign == fmt::sign::minus, "");
+  static_assert(check_specs(" ").sign == fmt::sign::space, "");
+  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.val.index == 42, "");
+  static_assert(check_specs(".42").precision == 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, "");
+}
+
+struct test_format_string_handler {
+  constexpr void on_text(const char*, const char*) {}
+
+  constexpr int on_arg_id() { return 0; }
+
+  template <typename T> constexpr int on_arg_id(T) { return 0; }
+
+  constexpr void on_replacement_field(int, const char*) {}
+
+  constexpr const char* on_format_specs(int, const char* begin, const char*) {
+    return begin;
+  }
+
+  constexpr void on_error(const char*) { error = true; }
+
+  bool error = false;
+};
+
+template <size_t N> constexpr bool parse_string(const char (&s)[N]) {
+  auto h = test_format_string_handler();
+  fmt::detail::parse_format_string<true>(fmt::string_view(s, N - 1), h);
+  return !h.error;
+}
+
+TEST(format_test, constexpr_parse_format_string) {
+  static_assert(parse_string("foo"), "");
+  static_assert(!parse_string("}"), "");
+  static_assert(parse_string("{}"), "");
+  static_assert(parse_string("{42}"), "");
+  static_assert(parse_string("{foo}"), "");
+  static_assert(parse_string("{:}"), "");
+}
+#endif  // FMT_USE_CONSTEXPR
+
+struct enabled_formatter {};
+struct disabled_formatter {};
+struct disabled_formatter_convertible {
+  operator int() const { return 42; }
+};
+
+FMT_BEGIN_NAMESPACE
+template <> struct formatter<enabled_formatter> {
+  auto parse(format_parse_context& ctx) -> decltype(ctx.begin()) {
+    return ctx.begin();
+  }
+  auto format(enabled_formatter, format_context& ctx) -> decltype(ctx.out()) {
+    return ctx.out();
+  }
+};
+FMT_END_NAMESPACE
+
+TEST(core_test, has_formatter) {
+  using fmt::has_formatter;
+  using context = fmt::format_context;
+  static_assert(has_formatter<enabled_formatter, context>::value, "");
+  static_assert(!has_formatter<disabled_formatter, context>::value, "");
+  static_assert(!has_formatter<disabled_formatter_convertible, context>::value,
+                "");
+}
+
+TEST(core_test, is_formattable) {
+  static_assert(fmt::is_formattable<enabled_formatter>::value, "");
+  static_assert(!fmt::is_formattable<disabled_formatter>::value, "");
+  static_assert(fmt::is_formattable<disabled_formatter_convertible>::value, "");
+}
+
+TEST(core_test, format) { EXPECT_EQ(fmt::format("{}", 42), "42"); }
+
+TEST(core_test, format_to) {
+  std::string s;
+  fmt::format_to(std::back_inserter(s), "{}", 42);
+  EXPECT_EQ(s, "42");
+}
+
+struct convertible_to_int {
+  operator int() const { return 42; }
+};
+
+struct convertible_to_c_string {
+  operator const char*() const { return "foo"; }
+};
+
+FMT_BEGIN_NAMESPACE
+template <> struct formatter<convertible_to_int> {
+  auto parse(format_parse_context& ctx) -> decltype(ctx.begin()) {
+    return ctx.begin();
+  }
+  auto format(convertible_to_int, format_context& ctx) -> decltype(ctx.out()) {
+    return std::copy_n("foo", 3, ctx.out());
+  }
+};
+
+template <> struct formatter<convertible_to_c_string> {
+  FMT_CONSTEXPR auto parse(format_parse_context& ctx) -> decltype(ctx.begin()) {
+    return ctx.begin();
+  }
+  auto format(convertible_to_c_string, format_context& ctx)
+      -> decltype(ctx.out()) {
+    return std::copy_n("bar", 3, ctx.out());
+  }
+};
+FMT_END_NAMESPACE
+
+TEST(core_test, formatter_overrides_implicit_conversion) {
+  EXPECT_EQ(fmt::format("{}", convertible_to_int()), "foo");
+  EXPECT_EQ(fmt::format("{}", convertible_to_c_string()), "bar");
+}
+
+// Test that check is not found by ADL.
+template <typename T> void check(T);
+TEST(core_test, adl_check) {
+  EXPECT_EQ(fmt::format("{}", test_struct()), "test");
+}
+
+TEST(core_test, to_string_view_foreign_strings) {
+  using namespace test_ns;
+  EXPECT_EQ(to_string_view(test_string<char>("42")), "42");
+  fmt::detail::type type =
+      fmt::detail::mapped_type_constant<test_string<char>,
+                                        fmt::format_context>::value;
+  EXPECT_EQ(type, fmt::detail::type::string_type);
+}
+
+struct implicitly_convertible_to_string {
+  operator std::string() const { return "foo"; }
+};
+
+struct implicitly_convertible_to_string_view {
+  operator fmt::string_view() const { return "foo"; }
+};
+
+TEST(core_test, format_implicitly_convertible_to_string_view) {
+  EXPECT_EQ("foo", fmt::format("{}", implicitly_convertible_to_string_view()));
+}
+
+// std::is_constructible is broken in MSVC until version 2015.
+#if !FMT_MSC_VER || FMT_MSC_VER >= 1900
+struct explicitly_convertible_to_string_view {
+  explicit operator fmt::string_view() const { return "foo"; }
+};
+
+TEST(core_test, format_explicitly_convertible_to_string_view) {
+  EXPECT_EQ("foo", fmt::format("{}", explicitly_convertible_to_string_view()));
+}
+
+#  ifdef FMT_USE_STRING_VIEW
+struct explicitly_convertible_to_std_string_view {
+  explicit operator std::string_view() const { return "foo"; }
+};
+
+TEST(core_test, format_explicitly_convertible_to_std_string_view) {
+  EXPECT_EQ("foo",
+            fmt::format("{}", explicitly_convertible_to_std_string_view()));
+}
+#  endif
+#endif
+
+struct convertible_to_long_long {
+  operator long long() const { return 1LL << 32; }
+};
+
+TEST(format_test, format_convertible_to_long_long) {
+  EXPECT_EQ("100000000", fmt::format("{:x}", convertible_to_long_long()));
+}
+
+struct disabled_rvalue_conversion {
+  operator const char*() const& { return "foo"; }
+  operator const char*() & { return "foo"; }
+  operator const char*() const&& = delete;
+  operator const char*() && = delete;
+};
+
+TEST(core_test, disabled_rvalue_conversion) {
+  EXPECT_EQ("foo", fmt::format("{}", disabled_rvalue_conversion()));
+}
+
+namespace adl_test {
+template <typename... T> void make_format_args(const T&...) = delete;
+
+struct string : std::string {};
+}  // namespace adl_test
+
+// Test that formatting functions compile when make_format_args is found by ADL.
+TEST(core_test, adl) {
+  // Only check compilation and don't run the code to avoid polluting the output
+  // and since the output is tested elsewhere.
+  if (fmt::detail::const_check(true)) return;
+  auto s = adl_test::string();
+  char buf[10];
+  fmt::format("{}", s);
+  fmt::format_to(buf, "{}", s);
+  fmt::format_to_n(buf, 10, "{}", s);
+  fmt::formatted_size("{}", s);
+  fmt::print("{}", s);
+  fmt::print(stdout, "{}", s);
+}

vendor/Fmt/test/cuda-test/CMakeLists.txt

@@ -0,0 +1,73 @@
+# We can find some usecases which follow the guide of CMake which uses
+# `enable_language(CUDA)` instead of `find_package(CUDA)` and let the CMake
+# built-in functions use NVCC.
+
+# See: https://cmake.org/cmake/help/latest/module/FindCUDA.html#replacement
+#
+# However, this requires CMake version 3.10 or higher and we can't be sure most
+# of the CUDA projects are using those.
+#
+# This test relies on `find_package(CUDA)` in the parent CMake config.
+
+# These can be updated when NVCC becomes ready for C++ 17 features
+# https://docs.nvidia.com/cuda/cuda-c-programming-guide/index.html#cpp14-language-features
+set(CMAKE_CUDA_STANDARD 14)
+set(CMAKE_CUDA_STANDARD_REQUIRED 14)
+
+# In this test, we assume that the user is going to compile CUDA source code
+# with some libraries (fmt in this case).
+#
+# In addition to that, this test invokes both the C++ host compiler and NVCC
+# by providing another (non-CUDA) C++ source code.
+if (${CMAKE_VERSION} VERSION_LESS 3.15)
+  # https://docs.nvidia.com/cuda/cuda-compiler-driver-nvcc/index.html
+  list(APPEND CUDA_NVCC_FLAGS "-std=c++14")
+  if (MSVC)
+    # This is the solution of pytorch:
+    # https://github.com/pytorch/pytorch/pull/7118
+    list(APPEND CUDA_NVCC_FLAGS "-Xcompiler" "/std:c++14")
+    list(APPEND CUDA_NVCC_FLAGS "-Xcompiler" "/Zc:__cplusplus")
+    # for the reason of this -Xcompiler options, see below.
+  endif ()
+  cuda_add_executable(fmt-in-cuda-test cuda-cpp14.cu cpp14.cc)
+  target_compile_features(fmt-in-cuda-test PRIVATE cxx_std_14)
+  if (MSVC)
+    # This part is for (non-CUDA) C++ code. MSVC can define incorrect
+    # `__cplusplus` macro. Fix for the issue is to use additional compiler flag. 
+    #
+    # See Also:
+    # https://devblogs.microsoft.com/cppblog/msvc-now-correctly-reports-__cplusplus/
+    # https://github.com/Microsoft/vscode-cpptools/issues/2595
+    target_compile_options(fmt-in-cuda-test PRIVATE /Zc:__cplusplus /permissive-)
+  endif ()
+else()
+  # now using a "new" way of handling CUDA
+  add_executable(fmt-in-cuda-test cuda-cpp14.cu cpp14.cc)
+  set_target_properties(fmt-in-cuda-test PROPERTIES CUDA_SEPARABLE_COMPILATION ON)
+  target_compile_features(fmt-in-cuda-test PRIVATE cxx_std_14)
+  if (MSVC)
+    # with MSVC, 'cxx_std_14' will only propagate to the host code (MSVC), but will
+    # not set __cplusplus correctly anyway, while nvcc will ignore it.
+    # If specified for nvcc on the command line as '-std=c++14' nvcc will emit this
+    # message instead:
+    # nvcc warning : The -std=c++14 flag is not supported with the configured host
+    #                compiler. Flag will be ignored.
+    set_property(SOURCE cuda-cpp14.cu APPEND PROPERTY
+      COMPILE_OPTIONS -Xcompiler /std:c++14 -Xcompiler /Zc:__cplusplus)
+    set_property(SOURCE cpp14.cc APPEND PROPERTY
+      COMPILE_OPTIONS /std:c++14 /Zc:__cplusplus)
+  endif()
+endif()
+
+get_target_property(IN_USE_CUDA_STANDARD fmt-in-cuda-test CUDA_STANDARD)
+message(STATUS "cuda_standard:          ${IN_USE_CUDA_STANDARD}")
+
+get_target_property(IN_USE_CUDA_STANDARD_REQUIRED
+    fmt-in-cuda-test CUDA_STANDARD_REQUIRED)
+message(STATUS "cuda_standard_required: ${IN_USE_CUDA_STANDARD_REQUIRED}")
+
+# We don't use PUBLIC or other keyword for reasons explained in the
+# CUDA_LINK_LIBRARIES_KEYWORD section in
+# https://cmake.org/cmake/help/latest/module/FindCUDA.html
+target_link_libraries(fmt-in-cuda-test fmt::fmt)
+

vendor/Fmt/test/cuda-test/cpp14.cc

@@ -0,0 +1,11 @@
+#include <fmt/core.h>
+
+// The purpose of this part is to ensure NVCC's host compiler also supports
+// the standard version. See 'cuda-cpp14.cu'.
+//
+// https://en.cppreference.com/w/cpp/preprocessor/replace#Predefined_macros
+static_assert(__cplusplus >= 201402L, "expect C++ 2014 for host compiler");
+
+auto make_message_cpp() -> std::string {
+  return fmt::format("host compiler \t: __cplusplus == {}", __cplusplus);
+}

vendor/Fmt/test/cuda-test/cuda-cpp14.cu

@@ -0,0 +1,28 @@
+//  Direct NVCC command line example:
+//
+//  nvcc ./cuda-cpp14.cu -x cu -I"../include" -l"fmtd" -L"../build/Debug" \
+//       -std=c++14 -Xcompiler /std:c++14 -Xcompiler /Zc:__cplusplus
+
+// Ensure that we are using the latest C++ standard for NVCC
+// The version is C++14
+//
+// https://docs.nvidia.com/cuda/cuda-c-programming-guide/index.html#c-cplusplus-language-support
+// https://en.cppreference.com/w/cpp/preprocessor/replace#Predefined_macros
+static_assert(__cplusplus >= 201402L, "expect C++ 2014 for nvcc");
+
+#include <fmt/core.h>
+
+#include <cuda.h>
+#include <iostream>
+
+extern auto make_message_cpp() -> std::string;
+extern auto make_message_cuda() -> std::string;
+
+int main() {
+  std::cout << make_message_cuda() << std::endl;
+  std::cout << make_message_cpp() << std::endl;
+}
+
+auto make_message_cuda() -> std::string {
+  return fmt::format("nvcc compiler \t: __cplusplus == {}", __cplusplus);
+}

vendor/Fmt/test/enforce-checks-test.cc

@@ -0,0 +1,62 @@
+// 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 <iterator>
+#include <vector>
+
+#include "fmt/chrono.h"
+#include "fmt/color.h"
+#include "fmt/format.h"
+#include "fmt/ostream.h"
+#include "fmt/ranges.h"
+#include "fmt/xchar.h"
+
+// Exercise the API to verify that everything we expect to can compile.
+void test_format_api() {
+  fmt::format(FMT_STRING("{}"), 42);
+  fmt::format(FMT_STRING(L"{}"), 42);
+  fmt::format(FMT_STRING("noop"));
+
+  fmt::to_string(42);
+  fmt::to_wstring(42);
+
+  std::vector<char> out;
+  fmt::format_to(std::back_inserter(out), FMT_STRING("{}"), 42);
+
+  char buffer[4];
+  fmt::format_to_n(buffer, 3, FMT_STRING("{}"), 12345);
+
+  wchar_t wbuffer[4];
+  fmt::format_to_n(wbuffer, 3, FMT_STRING(L"{}"), 12345);
+}
+
+void test_chrono() {
+  fmt::format(FMT_STRING("{}"), std::chrono::seconds(42));
+  fmt::format(FMT_STRING(L"{}"), std::chrono::seconds(42));
+}
+
+void test_text_style() {
+  fmt::print(fg(fmt::rgb(255, 20, 30)), FMT_STRING("{}"), "rgb(255,20,30)");
+  fmt::format(fg(fmt::rgb(255, 20, 30)), FMT_STRING("{}"), "rgb(255,20,30)");
+
+  fmt::text_style ts = fg(fmt::rgb(255, 20, 30));
+  std::string out;
+  fmt::format_to(std::back_inserter(out), ts,
+                 FMT_STRING("rgb(255,20,30){}{}{}"), 1, 2, 3);
+}
+
+void test_range() {
+  std::vector<char> hello = {'h', 'e', 'l', 'l', 'o'};
+  fmt::format(FMT_STRING("{}"), hello);
+}
+
+int main() {
+  test_format_api();
+  test_chrono();
+  test_text_style();
+  test_range();
+}

vendor/Fmt/test/find-package-test/CMakeLists.txt

@@ -0,0 +1,17 @@
+cmake_minimum_required(VERSION 3.1...3.18)
+
+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 PRIVATE ${PEDANTIC_COMPILE_FLAGS})
+target_include_directories(library-test PUBLIC SYSTEM .)
+
+if (TARGET fmt::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 PRIVATE ${PEDANTIC_COMPILE_FLAGS})
+  target_include_directories(header-only-test PUBLIC SYSTEM .)
+endif ()

vendor/Fmt/test/find-package-test/main.cc

@@ -0,0 +1,6 @@
+#include "fmt/format.h"
+
+int main(int argc, char** argv) {
+  for(int i = 0; i < argc; ++i)
+    fmt::print("{}: {}\n", i, argv[i]);
+}

vendor/Fmt/test/format

@@ -0,0 +1,856 @@
+// Formatting library for C++ - the standard API implementation
+//
+// Copyright (c) 2012 - present, Victor Zverovich
+// All rights reserved.
+//
+// For the license information refer to format.h.
+
+#ifndef FMT_FORMAT_
+#define FMT_FORMAT_
+
+#include <algorithm>
+#include <cassert>
+#include <variant>
+#include "fmt/format.h"
+
+// This implementation verifies the correctness of the standard API proposed in
+// P0645 Text Formatting and is optimized for copy-pasting from the paper, not
+// for efficiency or readability. An efficient implementation should not use
+// std::variant and should store packed argument type tags separately from
+// values in basic_format_args for small number of arguments.
+
+namespace std {
+template<class T>
+constexpr bool Integral = is_integral_v<T>;
+
+template <class O>
+  using iter_difference_t = ptrdiff_t;
+}
+
+// https://fmt.dev/Text%20Formatting.html#format.syn
+namespace std {
+  // [format.error], class format_error
+  class format_error;
+
+  // [format.formatter], formatter
+  template<class charT> class basic_format_parse_context;
+  using format_parse_context = basic_format_parse_context<char>;
+  using wformat_parse_context = basic_format_parse_context<wchar_t>;
+  
+  template<class Out, class charT> class basic_format_context;
+  using format_context = basic_format_context<
+    /* unspecified */ fmt::detail::buffer_appender<char>, char>;
+  using wformat_context = basic_format_context<
+    /* unspecified */ fmt::detail::buffer_appender<wchar_t>, wchar_t>;
+
+  template<class T, class charT = char> struct formatter {
+    formatter() = delete;
+  };
+  
+  // [format.arguments], arguments
+  template<class Context> class basic_format_arg;
+
+  template<class Visitor, class Context>
+    /* see below */ auto visit_format_arg(Visitor&& vis, basic_format_arg<Context> arg);
+
+  template<class Context, class... Args> struct format_arg_store; // exposition only
+
+  template<class Context> class basic_format_args;
+  using format_args = basic_format_args<format_context>;
+  using wformat_args = basic_format_args<wformat_context>;
+
+  template<class Out, class charT>
+    using format_args_t = basic_format_args<basic_format_context<Out, charT>>;
+
+  template<class Context = format_context, class... Args>
+    format_arg_store<Context, Args...>
+      make_format_args(const Args&... args);
+  template<class... Args>
+    format_arg_store<wformat_context, Args...>
+      make_wformat_args(const Args&... args);
+
+  // [format.functions], formatting functions
+  template<class... Args>
+    string format(string_view fmt, const Args&... args);
+  template<class... Args>
+    wstring format(wstring_view fmt, const Args&... args);
+
+  string vformat(string_view fmt, format_args args);
+  wstring vformat(wstring_view fmt, wformat_args args);
+
+  template<class Out, class... Args>
+    Out format_to(Out out, string_view fmt, const Args&... args);
+  template<class Out, class... Args>
+    Out format_to(Out out, wstring_view fmt, const Args&... args);
+
+  template<class Out>
+    Out vformat_to(Out out, string_view fmt, format_args_t<fmt::type_identity_t<Out>, char> args);
+  template<class Out>
+    Out vformat_to(Out out, wstring_view fmt, format_args_t<fmt::type_identity_t<Out>, wchar_t> args);
+
+  template<class Out>
+    struct format_to_n_result {
+      Out out;
+      iter_difference_t<Out> size;
+    };
+  
+  template<class Out, class... Args>
+    format_to_n_result<Out> format_to_n(Out out, iter_difference_t<Out> n,
+                                        string_view fmt, const Args&... args);
+  template<class Out, class... Args>
+    format_to_n_result<Out> format_to_n(Out out, iter_difference_t<Out> n,
+                                        wstring_view fmt, const Args&... args);
+
+  template<class... Args>
+    size_t formatted_size(string_view fmt, const Args&... args);
+  template<class... Args>
+    size_t formatted_size(wstring_view fmt, const Args&... args);
+}
+
+// https://fmt.dev/Text%20Formatting.html#format.error
+namespace std {
+  class format_error : public runtime_error {
+  public:
+    explicit format_error(const string& what_arg) : runtime_error(what_arg) {}
+    explicit format_error(const char* what_arg) : runtime_error(what_arg) {}
+  };
+}
+
+namespace std {
+namespace detail {
+struct error_handler {
+  // This function is intentionally not constexpr to give a compile-time error.
+  void on_error(const char* message) {
+    throw std::format_error(message);
+  }
+};
+}
+}
+
+// https://fmt.dev/Text%20Formatting.html#format.parse_context
+namespace std {
+  template<class charT>
+  class basic_format_parse_context {
+  public:
+    using char_type = charT;
+    using const_iterator = typename basic_string_view<charT>::const_iterator;
+    using iterator = const_iterator;
+
+  private:
+    iterator begin_;                              // exposition only
+    iterator end_;                                // exposition only
+    enum indexing { unknown, manual, automatic }; // exposition only
+    indexing indexing_;                           // exposition only
+    size_t next_arg_id_;                          // exposition only
+    size_t num_args_;                             // exposition only
+
+  public:
+    explicit constexpr basic_format_parse_context(basic_string_view<charT> fmt,
+                                                  size_t num_args = 0) noexcept;
+    basic_format_parse_context(const basic_format_parse_context&) = delete;
+    basic_format_parse_context& operator=(const basic_format_parse_context&) = delete;
+
+    constexpr const_iterator begin() const noexcept;
+    constexpr const_iterator end() const noexcept;
+    constexpr void advance_to(const_iterator it);
+
+    constexpr size_t next_arg_id();
+    constexpr void check_arg_id(size_t id);
+
+    // Implementation detail:
+    constexpr void check_arg_id(fmt::string_view) {}
+    detail::error_handler error_handler() const { return {}; }
+    void on_error(const char* msg) { error_handler().on_error(msg); }
+  };
+}
+
+namespace std {
+template<class charT>
+/* explicit */ constexpr basic_format_parse_context<charT>::
+                   basic_format_parse_context(basic_string_view<charT> fmt,
+                                              size_t num_args) noexcept
+: begin_(fmt.begin()), end_(fmt.end()), indexing_(unknown), next_arg_id_(0), num_args_(num_args) {}
+
+template<class charT>
+constexpr typename basic_format_parse_context<charT>::const_iterator basic_format_parse_context<charT>::begin() const noexcept { return begin_; }
+
+template<class charT>
+constexpr typename basic_format_parse_context<charT>::const_iterator basic_format_parse_context<charT>::end() const noexcept { return end_; }
+
+template<class charT>
+constexpr void basic_format_parse_context<charT>::advance_to(typename basic_format_parse_context<charT>::iterator it) { begin_ = it; }
+
+template<class charT>
+constexpr size_t basic_format_parse_context<charT>::next_arg_id() {
+  if (indexing_ == manual)
+    throw format_error("manual to automatic indexing");
+  if (indexing_ == unknown)
+    indexing_ = automatic;
+  return next_arg_id_++;
+}
+
+template<class charT>
+constexpr void basic_format_parse_context<charT>::check_arg_id(size_t id) {
+  // clang doesn't support __builtin_is_constant_evaluated yet
+  //if (!(!__builtin_is_constant_evaluated() || id < num_args_))
+  //  throw format_error(invalid index is out of range");
+  if (indexing_ == automatic)
+    throw format_error("automatic to manual indexing");
+  if (indexing_ == unknown)
+    indexing_ = manual;
+}
+}
+
+// https://fmt.dev/Text%20Formatting.html#format.context
+namespace std {
+  template<class Out, class charT>
+  class basic_format_context {
+    basic_format_args<basic_format_context> args_; // exposition only
+    Out out_;                                      // exposition only
+
+  public:
+    using iterator = Out;
+    using char_type = charT;
+    template<class T> using formatter_type = formatter<T, charT>;
+
+    basic_format_arg<basic_format_context> arg(size_t id) const;
+
+    iterator out();
+    void advance_to(iterator it);
+
+    // Implementation details:
+    using format_arg = basic_format_arg<basic_format_context>;
+    basic_format_context(Out out, basic_format_args<basic_format_context> args, fmt::detail::locale_ref)
+    : args_(args), out_(out) {}
+    detail::error_handler error_handler() const { return {}; }
+    basic_format_arg<basic_format_context> arg(fmt::basic_string_view<charT>) const {
+      return {}; // unused: named arguments are not supported yet
+    }
+    void on_error(const char* msg) { error_handler().on_error(msg); }
+  };
+}
+
+namespace std {
+template<class O, class charT>
+basic_format_arg<basic_format_context<O, charT>> basic_format_context<O, charT>::arg(size_t id) const { return args_.get(id); }
+
+template<class O, class charT>
+typename basic_format_context<O, charT>::iterator basic_format_context<O, charT>::out() { return out_; }
+
+template<class O, class charT>
+void basic_format_context<O, charT>::advance_to(typename basic_format_context<O, charT>::iterator it) { out_ = it; }
+}
+
+namespace std {
+namespace detail {
+template <typename T>
+constexpr bool is_standard_integer_v =
+    std::is_same_v<T, signed char> ||
+    std::is_same_v<T, short int> ||
+    std::is_same_v<T, int> ||
+    std::is_same_v<T, long int> ||
+    std::is_same_v<T, long long int>;
+
+template <typename T>
+constexpr bool is_standard_unsigned_integer_v =
+    std::is_same_v<T, unsigned char> ||
+    std::is_same_v<T, unsigned short int> ||
+    std::is_same_v<T, unsigned int> ||
+    std::is_same_v<T, unsigned long int> ||
+    std::is_same_v<T, unsigned long long int>;
+
+template <typename T, typename Char> struct formatter;
+}
+}
+
+// https://fmt.dev/Text%20Formatting.html#format.arg
+namespace std {
+  template<class Context>
+  class basic_format_arg {
+  public:
+    class handle;
+
+  private:
+    using char_type = typename Context::char_type;                       // exposition only
+
+    variant<monostate, bool, char_type,
+            int, unsigned int, long long int, unsigned long long int,
+            double, long double,
+            const char_type*, basic_string_view<char_type>,
+            const void*, handle> value;                                  // exposition only
+
+    template<typename T,
+      typename = enable_if_t<
+        std::is_same_v<T, bool> ||
+        std::is_same_v<T, char_type> ||
+        (std::is_same_v<T, char> && std::is_same_v<char_type, wchar_t>) ||
+        detail::is_standard_integer_v<T> ||
+        detail::is_standard_unsigned_integer_v<T> ||
+        sizeof(typename Context::template formatter_type<T>().format(declval<const T&>(), declval<Context&>())) != 0
+    >> explicit basic_format_arg(const T& v) noexcept; // exposition only
+    explicit basic_format_arg(float n) noexcept;                         // exposition only
+    explicit basic_format_arg(double n) noexcept;                        // exposition only
+    explicit basic_format_arg(long double n) noexcept;                   // exposition only
+    explicit basic_format_arg(const char_type* s);                       // exposition only
+
+    template<class traits>
+      explicit basic_format_arg(
+        basic_string_view<char_type, traits> s) noexcept;                // exposition only
+
+    template<class traits, class Allocator>
+      explicit basic_format_arg(
+        const basic_string<char_type, traits, Allocator>& s) noexcept;   // exposition only
+
+    explicit basic_format_arg(nullptr_t) noexcept;                       // exposition only
+
+    template<class T, typename = enable_if_t<is_void_v<T>>>
+      explicit basic_format_arg(const T* p) noexcept;                    // exposition only
+
+    // Fails due to a bug in clang
+    //template<class Visitor, class Ctx>
+    //  friend auto visit_format_arg(Visitor&& vis,
+    //                                    basic_format_arg<Ctx> arg);           // exposition only
+
+    friend auto get_value(basic_format_arg arg) {
+      return arg.value;
+    }
+
+    template <typename T, typename Char> friend struct detail::formatter;
+
+    template<class Ctx, class... Args>
+      friend format_arg_store<Ctx, Args...>
+        make_format_args(const Args&... args);                           // exposition only
+
+  public:
+    basic_format_arg() noexcept;
+
+    explicit operator bool() const noexcept;
+  };
+}
+
+namespace std {
+template<class Context>
+basic_format_arg<Context>::basic_format_arg() noexcept {}
+
+template<class Context>
+template<class T, typename> /* explicit */ basic_format_arg<Context>::basic_format_arg(const T& v) noexcept {
+  if constexpr (std::is_same_v<T, bool> || std::is_same_v<T, char_type>)
+    value = v;
+  else if constexpr (std::is_same_v<T, char> && std::is_same_v<char_type, wchar_t>)
+    value = static_cast<wchar_t>(v);
+  else if constexpr (detail::is_standard_integer_v<T> && sizeof(T) <= sizeof(int))
+    value = static_cast<int>(v);
+  else if constexpr (detail::is_standard_unsigned_integer_v<T> && sizeof(T) <= sizeof(unsigned))
+    value = static_cast<unsigned>(v);
+  else if constexpr (detail::is_standard_integer_v<T>)
+    value = static_cast<long long int>(v);
+  else if constexpr (detail::is_standard_unsigned_integer_v<T>)
+    value = static_cast<unsigned long long int>(v);
+  else if constexpr (sizeof(typename Context::template formatter_type<T>().format(declval<const T&>(), declval<Context&>())) != 0)
+    value = handle(v);
+}
+
+template<class Context>
+/* explicit */ basic_format_arg<Context>::basic_format_arg(float n) noexcept
+  : value(static_cast<double>(n)) {}
+
+template<class Context>
+/* explicit */ basic_format_arg<Context>::basic_format_arg(double n) noexcept
+  : value(n) {}
+
+template<class Context>
+/* explicit */ basic_format_arg<Context>::basic_format_arg(long double n) noexcept
+  : value(n) {}
+
+template<class Context>
+/* explicit */ basic_format_arg<Context>::basic_format_arg(const typename basic_format_arg<Context>::char_type* s)
+  : value(s) {
+  assert(s != nullptr);
+}
+
+template<class Context>
+template<class traits>
+/* explicit */ basic_format_arg<Context>::basic_format_arg(basic_string_view<char_type, traits> s) noexcept
+  : value(s) {}
+
+template<class Context>
+template<class traits, class Allocator>
+/* explicit */ basic_format_arg<Context>::basic_format_arg(
+    const basic_string<char_type, traits, Allocator>& s) noexcept
+  : value(basic_string_view<char_type>(s.data(), s.size())) {}
+
+
+template<class Context>
+/* explicit */ basic_format_arg<Context>::basic_format_arg(nullptr_t) noexcept
+  : value(static_cast<const void*>(nullptr)) {}
+
+template<class Context>
+template<class T, typename> /* explicit */ basic_format_arg<Context>::basic_format_arg(const T* p) noexcept
+  : value(p) {}
+
+template<class Context>
+/* explicit */ basic_format_arg<Context>::operator bool() const noexcept {
+    return !holds_alternative<monostate>(value);
+}
+}
+
+namespace std {
+  template<class Context>
+  class basic_format_arg<Context>::handle {
+    const void* ptr_;                                         // exposition only
+    void (*format_)(basic_format_parse_context<char_type>&,
+                    Context&, const void*);                   // exposition only
+
+    template<class T> explicit handle(const T& val) noexcept; // exposition only
+
+    friend class basic_format_arg<Context>;                   // exposition only
+
+  public:
+    void format(basic_format_parse_context<char_type>&, Context& ctx) const;
+  };
+}
+
+namespace std {
+template<class Context>
+template<class T> /* explicit */ basic_format_arg<Context>::handle::handle(const T& val) noexcept
+  : ptr_(&val), format_([](basic_format_parse_context<char_type>& parse_ctx, Context& format_ctx, const void* ptr) {
+    typename Context::template formatter_type<T> f;
+    parse_ctx.advance_to(f.parse(parse_ctx));
+    format_ctx.advance_to(f.format(*static_cast<const T*>(ptr), format_ctx));
+  }) {}
+
+template<class Context>
+void basic_format_arg<Context>::handle::format(basic_format_parse_context<char_type>& parse_ctx, Context& format_ctx) const {
+  format_(parse_ctx, format_ctx, ptr_);
+}
+
+// https://fmt.dev/Text%20Formatting.html#format.visit
+template<class Visitor, class Context>
+  auto visit_format_arg(Visitor&& vis, basic_format_arg<Context> arg) {
+    return visit(vis, get_value(arg));
+  }
+}
+
+// https://fmt.dev/Text%20Formatting.html#format.store
+namespace std {
+  template<class Context, class... Args>
+  struct format_arg_store { // exposition only
+    array<basic_format_arg<Context>, sizeof...(Args)> args;
+  };
+}
+
+// https://fmt.dev/Text%20Formatting.html#format.basic_args
+namespace std {
+  template<class Context>
+  class basic_format_args {
+    size_t size_;                           // exposition only
+    const basic_format_arg<Context>* data_; // exposition only
+
+  public:
+    basic_format_args() noexcept;
+
+    template<class... Args>
+      basic_format_args(const format_arg_store<Context, Args...>& store) noexcept;
+
+    basic_format_arg<Context> get(size_t i) const noexcept;
+  };
+}
+
+namespace std {
+
+template<class Context>
+basic_format_args<Context>::basic_format_args() noexcept : size_(0) {}
+
+template<class Context>
+template<class... Args>
+  basic_format_args<Context>::basic_format_args(const format_arg_store<Context, Args...>& store) noexcept
+  : size_(sizeof...(Args)), data_(store.args.data()) {}
+
+template<class Context>
+basic_format_arg<Context> basic_format_args<Context>::get(size_t i) const noexcept {
+  return i < size_ ? data_[i] : basic_format_arg<Context>();
+}
+}
+
+namespace std {
+// https://fmt.dev/Text%20Formatting.html#format.make_args
+template<class Context /*= format_context*/, class... Args>
+  format_arg_store<Context, Args...> make_format_args(const Args&... args) {
+    return {basic_format_arg<Context>(args)...};
+  }
+
+// https://fmt.dev/Text%20Formatting.html#format.make_wargs
+template<class... Args>
+  format_arg_store<wformat_context, Args...> make_wformat_args(const Args&... args) {
+    return make_format_args<wformat_context>(args...);
+  }
+}
+
+namespace std {
+namespace detail {
+
+template <typename OutputIt, typename Char>
+class arg_formatter
+    : public fmt::detail::arg_formatter_base<OutputIt, Char, error_handler> {
+ private:
+  using char_type = Char;
+  using base = fmt::detail::arg_formatter_base<OutputIt, Char, error_handler>;
+  using format_context = std::basic_format_context<OutputIt, Char>;
+  using parse_context = basic_format_parse_context<Char>;
+
+  parse_context* parse_ctx_;
+  format_context& ctx_;
+
+ public:
+  using iterator = OutputIt;
+  using format_specs = typename base::format_specs;
+
+  /**
+    \rst
+    Constructs an argument formatter object.
+    *ctx* is a reference to the formatting context,
+    *spec* contains format specifier information for standard argument types.
+    \endrst
+   */
+  arg_formatter(format_context& ctx, parse_context* parse_ctx = nullptr, fmt::format_specs* spec = nullptr)
+      : base(ctx.out(), spec, {}), parse_ctx_(parse_ctx), ctx_(ctx) {}
+
+  using base::operator();
+
+  /** Formats an argument of a user-defined type. */
+  iterator operator()(typename std::basic_format_arg<format_context>::handle handle) {
+    handle.format(*parse_ctx_, ctx_);
+    return this->out();
+  }
+
+  iterator operator()(monostate) {
+    throw format_error("");
+  }
+};
+
+template <typename Context>
+inline fmt::detail::type get_type(basic_format_arg<Context> arg) {
+  return visit_format_arg([&] (auto val) {
+    using char_type = typename Context::char_type;
+    using T = decltype(val);
+    if (std::is_same_v<T, monostate>)
+      return fmt::detail::type::none_type;
+    if (std::is_same_v<T, bool>)
+      return fmt::detail::type::bool_type;
+    if (std::is_same_v<T, char_type>)
+      return fmt::detail::type::char_type;
+    if (std::is_same_v<T, int>)
+      return fmt::detail::type::int_type;
+    if (std::is_same_v<T, unsigned int>)
+      return fmt::detail::type::uint_type;
+    if (std::is_same_v<T, long long int>)
+      return fmt::detail::type::long_long_type;
+    if (std::is_same_v<T, unsigned long long int>)
+      return fmt::detail::type::ulong_long_type;
+    if (std::is_same_v<T, double>)
+      return fmt::detail::type::double_type;
+    if (std::is_same_v<T, long double>)
+      return fmt::detail::type::long_double_type;
+    if (std::is_same_v<T, const char_type*>)
+      return fmt::detail::type::cstring_type;
+    if (std::is_same_v<T, basic_string_view<char_type>>)
+      return fmt::detail::type::string_type;
+    if (std::is_same_v<T, const void*>)
+      return fmt::detail::type::pointer_type;
+    assert(get_value(arg).index() == 12);
+    return fmt::detail::type::custom_type;
+  }, arg);
+}
+
+template <typename Context>
+class custom_formatter {
+ private:
+  using parse_context = basic_format_parse_context<typename Context::char_type>;
+  parse_context& parse_ctx_;
+  Context& format_ctx_;
+
+ public:
+  custom_formatter(parse_context& parse_ctx, Context& ctx) : parse_ctx_(parse_ctx), format_ctx_(ctx) {}
+
+  bool operator()(typename basic_format_arg<Context>::handle h) const {
+    h.format(parse_ctx_, format_ctx_);
+    return true;
+  }
+
+  template <typename T> bool operator()(T) const { return false; }
+};
+
+template <typename ArgFormatter, typename Char, typename Context>
+struct format_handler : detail::error_handler {
+  using iterator = typename ArgFormatter::iterator;
+
+  format_handler(iterator out, basic_string_view<Char> str,
+                 basic_format_args<Context> format_args,
+                 fmt::detail::locale_ref loc)
+      : parse_ctx(str), context(out, format_args, loc) {}
+
+  void on_text(const Char* begin, const Char* end) {
+    auto size = fmt::detail::to_unsigned(end - begin);
+    auto out = context.out();
+    auto&& it = fmt::detail::reserve(out, size);
+    it = std::copy_n(begin, size, it);
+    context.advance_to(out);
+  }
+
+  int on_arg_id() { return parse_ctx.next_arg_id(); }
+  int on_arg_id(unsigned id) { return parse_ctx.check_arg_id(id), id; }
+  int on_arg_id(fmt::basic_string_view<Char>) { return 0; }
+
+  void on_replacement_field(int id, const Char* p) {
+    auto arg = context.arg(id);
+    parse_ctx.advance_to(parse_ctx.begin() + (p  - &*parse_ctx.begin()));
+    custom_formatter<Context> f(parse_ctx, context);
+    if (!visit_format_arg(f, arg))
+      context.advance_to(visit_format_arg(ArgFormatter(context, &parse_ctx), arg));
+  }
+
+  const Char* on_format_specs(int id, const Char* begin, const Char* end) {
+    auto arg = context.arg(id);
+    parse_ctx.advance_to(parse_ctx.begin() + (begin - &*parse_ctx.begin()));
+    custom_formatter<Context> f(parse_ctx, context);
+    if (visit_format_arg(f, arg)) return &*parse_ctx.begin();
+    fmt::basic_format_specs<Char> specs;
+    using fmt::detail::specs_handler;
+    using parse_context = basic_format_parse_context<Char>;
+    fmt::detail::specs_checker<specs_handler<parse_context, Context>> handler(
+        specs_handler<parse_context, Context>(specs, parse_ctx, context), get_type(arg));
+    begin = parse_format_specs(begin, end, handler);
+    if (begin == end || *begin != '}') on_error("missing '}' in format string");
+    parse_ctx.advance_to(parse_ctx.begin() + (begin - &*parse_ctx.begin()));
+    context.advance_to(visit_format_arg(ArgFormatter(context, &parse_ctx, &specs), arg));
+    return begin;
+  }
+
+  basic_format_parse_context<Char> parse_ctx;
+  Context context;
+};
+
+template <typename T, typename Char>
+struct formatter {
+  // Parses format specifiers stopping either at the end of the range or at the
+  // terminating '}'.
+  template <typename ParseContext>
+  FMT_CONSTEXPR typename ParseContext::iterator parse(ParseContext& ctx) {
+    namespace detail = fmt::detail;
+    typedef detail::dynamic_specs_handler<ParseContext> handler_type;
+    auto type = detail::mapped_type_constant<T, fmt::buffer_context<Char>>::value;
+    detail::specs_checker<handler_type> handler(handler_type(specs_, ctx),
+                                                  type);
+    auto it = parse_format_specs(ctx.begin(), ctx.end(), handler);
+    auto type_spec = specs_.type;
+    auto eh = ctx.error_handler();
+    switch (type) {
+    case detail::type::none_type:
+      FMT_ASSERT(false, "invalid argument type");
+      break;
+    case detail::type::int_type:
+    case detail::type::uint_type:
+    case detail::type::long_long_type:
+    case detail::type::ulong_long_type:
+    case detail::type::bool_type:
+      handle_int_type_spec(type_spec,
+                           detail::int_type_checker<decltype(eh)>(eh));
+      break;
+    case detail::type::char_type:
+      handle_char_specs(
+          &specs_, detail::char_specs_checker<decltype(eh)>(type_spec, eh));
+      break;
+    case detail::type::double_type:
+    case detail::type::long_double_type:
+      detail::parse_float_type_spec(specs_, eh);
+      break;
+    case detail::type::cstring_type:
+      detail::handle_cstring_type_spec(
+          type_spec, detail::cstring_type_checker<decltype(eh)>(eh));
+      break;
+    case detail::type::string_type:
+      detail::check_string_type_spec(type_spec, eh);
+      break;
+    case detail::type::pointer_type:
+      detail::check_pointer_type_spec(type_spec, eh);
+      break;
+    case detail::type::custom_type:
+      // Custom format specifiers should be checked in parse functions of
+      // formatter specializations.
+      break;
+    }
+    return it;
+  }
+
+  template <typename FormatContext>
+  auto format(const T& val, FormatContext& ctx) -> decltype(ctx.out()) {
+    fmt::detail::handle_dynamic_spec<fmt::detail::width_checker>(
+        specs_.width, specs_.width_ref, ctx);
+    fmt::detail::handle_dynamic_spec<fmt::detail::precision_checker>(
+        specs_.precision, specs_.precision_ref, ctx);
+    using af = arg_formatter<typename FormatContext::iterator,
+                             typename FormatContext::char_type>;
+    return visit_format_arg(af(ctx, nullptr, &specs_),
+                            basic_format_arg<FormatContext>(val));
+  }
+
+ private:
+  fmt::detail::dynamic_format_specs<Char> specs_;
+};
+}  // namespace detail
+
+// https://fmt.dev/Text%20Formatting.html#format.functions
+template<class... Args>
+  string format(string_view fmt, const Args&... args) {
+    return vformat(fmt, make_format_args(args...));
+  }
+
+template<class... Args>
+  wstring format(wstring_view fmt, const Args&... args) {
+    return vformat(fmt, make_wformat_args(args...));
+  }
+
+string vformat(string_view fmt, format_args args) {
+  fmt::memory_buffer mbuf;
+  fmt::detail::buffer<char>& buf = mbuf;
+  using af = detail::arg_formatter<fmt::format_context::iterator, char>;
+  detail::format_handler<af, char, format_context>
+    h(fmt::detail::buffer_appender<char>(buf), fmt, args, {});
+  fmt::detail::parse_format_string<false>(fmt::to_string_view(fmt), h);
+  return to_string(mbuf);
+}
+
+wstring vformat(wstring_view fmt, wformat_args args);
+
+template<class Out, class... Args>
+  Out format_to(Out out, string_view fmt, const Args&... args) {
+    using context = basic_format_context<Out, decltype(fmt)::value_type>;
+    return vformat_to(out, fmt, make_format_args<context>(args...));
+  }
+
+template<class Out, class... Args>
+  Out format_to(Out out, wstring_view fmt, const Args&... args) {
+    using context = basic_format_context<Out, decltype(fmt)::value_type>;
+    return vformat_to(out, fmt, make_format_args<context>(args...));
+  }
+
+template<class Out>
+  Out vformat_to(Out out, string_view fmt, format_args_t<fmt::type_identity_t<Out>, char> args) {
+    using af = detail::arg_formatter<Out, char>;
+    detail::format_handler<af, char, basic_format_context<Out, char>>
+      h(out, fmt, args, {});
+    fmt::detail::parse_format_string<false>(fmt::to_string_view(fmt), h);
+    return h.context.out();
+  }
+
+template<class Out>
+  Out vformat_to(Out out, wstring_view fmt, format_args_t<fmt::type_identity_t<Out>, wchar_t> args);
+
+template<class Out, class... Args>
+  format_to_n_result<Out> format_to_n(Out out, iter_difference_t<Out> n,
+                                      string_view fmt, const Args&... args);
+template<class Out, class... Args>
+  format_to_n_result<Out> format_to_n(Out out, iter_difference_t<Out> n,
+                                      wstring_view fmt, const Args&... args);
+
+template<class... Args>
+  size_t formatted_size(string_view fmt, const Args&... args);
+template<class... Args>
+  size_t formatted_size(wstring_view fmt, const Args&... args);
+
+#define charT char
+
+template<> struct formatter<charT, charT> : detail::formatter<charT, charT> {};
+
+template<> struct formatter<char, wchar_t>;
+
+template<> struct formatter<charT*, charT> : detail::formatter<const charT*, charT> {};
+
+template<> struct formatter<const charT*, charT> : detail::formatter<const charT*, charT> {};
+
+template<size_t N> struct formatter<const charT[N], charT>
+      : detail::formatter<std::basic_string_view<charT>, charT> {};
+
+template<class traits, class Allocator>
+  struct formatter<basic_string<charT, traits, Allocator>, charT>
+      : detail::formatter<std::basic_string_view<charT>, charT> {};
+
+template<class traits>
+  struct formatter<basic_string_view<charT, traits>, charT>
+      : detail::formatter<std::basic_string_view<charT>, charT> {};
+
+template <> struct formatter<nullptr_t, charT> : detail::formatter<const void*, charT> {};
+template <> struct formatter<void*, charT> : detail::formatter<const void*, charT> {};
+template <> struct formatter<const void*, charT> : detail::formatter<const void*, charT> {};
+template <> struct formatter<bool, charT> : detail::formatter<bool, charT> {};
+
+template <> struct formatter<signed char, charT> : detail::formatter<int, charT> {};
+template <> struct formatter<short, charT> : detail::formatter<int, charT> {};
+template <> struct formatter<int, charT> : detail::formatter<int, charT> {};
+template <> struct formatter<long, charT>
+      : detail::formatter<std::conditional_t<sizeof(long) == sizeof(int), int, long long>, charT> {};
+template <> struct formatter<long long, charT> : detail::formatter<long long, charT> {};
+template <> struct formatter<unsigned char, charT> : detail::formatter<unsigned int, charT> {};
+template <> struct formatter<unsigned short, charT> : detail::formatter<unsigned int, charT> {};
+template <> struct formatter<unsigned int, charT> : detail::formatter<unsigned int, charT> {};
+template <> struct formatter<unsigned long, charT>
+      : detail::formatter<std::conditional_t<sizeof(long) == sizeof(int), unsigned, unsigned long long>, charT> {};
+template <> struct formatter<unsigned long long, charT> : detail::formatter<unsigned long long, charT> {};
+
+template <> struct formatter<float, charT> : detail::formatter<double, charT> {};
+template <> struct formatter<double, charT> : detail::formatter<double, charT> {};
+template <> struct formatter<long double, charT> : detail::formatter<long double, charT> {};
+
+#undef charT
+
+#define charT wchar_t
+
+template<> struct formatter<charT, charT> : detail::formatter<charT, charT> {};
+
+template<> struct formatter<char, wchar_t> : detail::formatter<charT, charT> {};
+
+template<> struct formatter<charT*, charT> : detail::formatter<const charT*, charT> {};
+
+template<> struct formatter<const charT*, charT> : detail::formatter<const charT*, charT> {};
+
+template<size_t N> struct formatter<const charT[N], charT>
+      : detail::formatter<std::basic_string_view<charT>, charT> {};
+
+template<class traits, class Allocator>
+  struct formatter<std::basic_string<charT, traits, Allocator>, charT>
+      : detail::formatter<std::basic_string_view<charT>, charT> {};
+
+template<class traits>
+  struct formatter<std::basic_string_view<charT, traits>, charT>
+      : detail::formatter<std::basic_string_view<charT>, charT> {};
+
+template <> struct formatter<nullptr_t, charT> : detail::formatter<const void*, charT> {};
+template <> struct formatter<void*, charT> : detail::formatter<const void*, charT> {};
+template <> struct formatter<const void*, charT> : detail::formatter<const void*, charT> {};
+template <> struct formatter<bool, charT> : detail::formatter<bool, charT> {};
+
+template <> struct formatter<signed char, charT> : detail::formatter<int, charT> {};
+template <> struct formatter<short, charT> : detail::formatter<int, charT> {};
+template <> struct formatter<int, charT> : detail::formatter<int, charT> {};
+template <> struct formatter<long, charT>
+      : detail::formatter<std::conditional_t<sizeof(long) == sizeof(int), int, long long>, charT> {};
+template <> struct formatter<long long, charT> : detail::formatter<long long, charT> {};
+template <> struct formatter<unsigned char, charT> : detail::formatter<unsigned int, charT> {};
+template <> struct formatter<unsigned short, charT> : detail::formatter<unsigned int, charT> {};
+template <> struct formatter<unsigned int, charT> : detail::formatter<unsigned int, charT> {};
+template <> struct formatter<unsigned long, charT>
+      : detail::formatter<std::conditional_t<sizeof(long) == sizeof(int), unsigned, unsigned long long>, charT> {};
+template <> struct formatter<unsigned long long, charT> : detail::formatter<unsigned long long, charT> {};
+
+template <> struct formatter<float, charT> : detail::formatter<double, charT> {};
+template <> struct formatter<double, charT> : detail::formatter<double, charT> {};
+template <> struct formatter<long double, charT> : detail::formatter<long double, charT> {};
+
+#undef charT
+
+  template<> struct formatter<const wchar_t, char> {
+    formatter() = delete;
+  };
+}
+
+#endif  // FMT_FORMAT_

vendor/Fmt/test/format-impl-test.cc

@@ -0,0 +1,380 @@
+// Formatting library for C++ - formatting library implementation tests
+//
+// Copyright (c) 2012 - present, Victor Zverovich
+// All rights reserved.
+//
+// For the license information refer to format.h.
+
+#include <algorithm>
+#include <cstring>
+
+// clang-format off
+#include "test-assert.h"
+// clang-format on
+
+#include "fmt/format.h"
+#include "gmock/gmock.h"
+#include "util.h"
+
+using fmt::detail::bigint;
+using fmt::detail::fp;
+using fmt::detail::max_value;
+
+static_assert(!std::is_copy_constructible<bigint>::value, "");
+static_assert(!std::is_copy_assignable<bigint>::value, "");
+
+TEST(bigint_test, construct) {
+  EXPECT_EQ("", fmt::format("{}", bigint()));
+  EXPECT_EQ("42", fmt::format("{}", bigint(0x42)));
+  EXPECT_EQ("123456789abcedf0", fmt::format("{}", bigint(0x123456789abcedf0)));
+}
+
+TEST(bigint_test, compare) {
+  bigint n1(42);
+  bigint n2(42);
+  EXPECT_EQ(compare(n1, n2), 0);
+  n2 <<= 32;
+  EXPECT_LT(compare(n1, n2), 0);
+  bigint n3(43);
+  EXPECT_LT(compare(n1, n3), 0);
+  EXPECT_GT(compare(n3, n1), 0);
+  bigint n4(42 * 0x100000001);
+  EXPECT_LT(compare(n2, n4), 0);
+  EXPECT_GT(compare(n4, n2), 0);
+}
+
+TEST(bigint_test, add_compare) {
+  EXPECT_LT(
+      add_compare(bigint(0xffffffff), bigint(0xffffffff), bigint(1) <<= 64), 0);
+  EXPECT_LT(add_compare(bigint(1) <<= 32, bigint(1), bigint(1) <<= 96), 0);
+  EXPECT_GT(add_compare(bigint(1) <<= 32, bigint(0), bigint(0xffffffff)), 0);
+  EXPECT_GT(add_compare(bigint(0), bigint(1) <<= 32, bigint(0xffffffff)), 0);
+  EXPECT_GT(add_compare(bigint(42), bigint(1), bigint(42)), 0);
+  EXPECT_GT(add_compare(bigint(0xffffffff), bigint(1), bigint(0xffffffff)), 0);
+  EXPECT_LT(add_compare(bigint(10), bigint(10), bigint(22)), 0);
+  EXPECT_LT(add_compare(bigint(0x100000010), bigint(0x100000010),
+                        bigint(0x300000010)),
+            0);
+  EXPECT_GT(add_compare(bigint(0x1ffffffff), bigint(0x100000002),
+                        bigint(0x300000000)),
+            0);
+  EXPECT_EQ(add_compare(bigint(0x1ffffffff), bigint(0x100000002),
+                        bigint(0x300000001)),
+            0);
+  EXPECT_LT(add_compare(bigint(0x1ffffffff), bigint(0x100000002),
+                        bigint(0x300000002)),
+            0);
+  EXPECT_LT(add_compare(bigint(0x1ffffffff), bigint(0x100000002),
+                        bigint(0x300000003)),
+            0);
+}
+
+TEST(bigint_test, shift_left) {
+  bigint n(0x42);
+  n <<= 0;
+  EXPECT_EQ("42", fmt::format("{}", n));
+  n <<= 1;
+  EXPECT_EQ("84", fmt::format("{}", n));
+  n <<= 25;
+  EXPECT_EQ("108000000", fmt::format("{}", n));
+}
+
+TEST(bigint_test, multiply) {
+  bigint n(0x42);
+  EXPECT_THROW(n *= 0, assertion_failure);
+  n *= 1;
+  EXPECT_EQ("42", fmt::format("{}", n));
+  n *= 2;
+  EXPECT_EQ("84", fmt::format("{}", n));
+  n *= 0x12345678;
+  EXPECT_EQ("962fc95e0", fmt::format("{}", n));
+  bigint bigmax(max_value<uint32_t>());
+  bigmax *= max_value<uint32_t>();
+  EXPECT_EQ("fffffffe00000001", fmt::format("{}", bigmax));
+  bigmax.assign(max_value<uint64_t>());
+  bigmax *= max_value<uint64_t>();
+  EXPECT_EQ("fffffffffffffffe0000000000000001", fmt::format("{}", bigmax));
+}
+
+TEST(bigint_test, accumulator) {
+  fmt::detail::accumulator acc;
+  EXPECT_EQ(acc.lower, 0);
+  EXPECT_EQ(acc.upper, 0);
+  acc.upper = 12;
+  acc.lower = 34;
+  EXPECT_EQ(static_cast<uint32_t>(acc), 34);
+  acc += 56;
+  EXPECT_EQ(acc.lower, 90);
+  acc += max_value<uint64_t>();
+  EXPECT_EQ(acc.upper, 13);
+  EXPECT_EQ(acc.lower, 89);
+  acc >>= 32;
+  EXPECT_EQ(acc.upper, 0);
+  EXPECT_EQ(acc.lower, 13 * 0x100000000);
+}
+
+TEST(bigint_test, square) {
+  bigint n0(0);
+  n0.square();
+  EXPECT_EQ("0", fmt::format("{}", n0));
+  bigint n1(0x100);
+  n1.square();
+  EXPECT_EQ("10000", fmt::format("{}", n1));
+  bigint n2(0xfffffffff);
+  n2.square();
+  EXPECT_EQ("ffffffffe000000001", fmt::format("{}", n2));
+  bigint n3(max_value<uint64_t>());
+  n3.square();
+  EXPECT_EQ("fffffffffffffffe0000000000000001", fmt::format("{}", n3));
+  bigint n4;
+  n4.assign_pow10(10);
+  EXPECT_EQ("2540be400", fmt::format("{}", n4));
+}
+
+TEST(bigint_test, divmod_assign_zero_divisor) {
+  bigint zero(0);
+  EXPECT_THROW(bigint(0).divmod_assign(zero), assertion_failure);
+  EXPECT_THROW(bigint(42).divmod_assign(zero), assertion_failure);
+}
+
+TEST(bigint_test, divmod_assign_self) {
+  bigint n(100);
+  EXPECT_THROW(n.divmod_assign(n), assertion_failure);
+}
+
+TEST(bigint_test, divmod_assign_unaligned) {
+  // (42 << 340) / pow(10, 100):
+  bigint n1(42);
+  n1 <<= 340;
+  bigint n2;
+  n2.assign_pow10(100);
+  int result = n1.divmod_assign(n2);
+  EXPECT_EQ(result, 9406);
+  EXPECT_EQ("10f8353019583bfc29ffc8f564e1b9f9d819dbb4cf783e4507eca1539220p96",
+            fmt::format("{}", n1));
+}
+
+TEST(bigint_test, divmod_assign) {
+  // 100 / 10:
+  bigint n1(100);
+  int result = n1.divmod_assign(bigint(10));
+  EXPECT_EQ(result, 10);
+  EXPECT_EQ("0", fmt::format("{}", n1));
+  // pow(10, 100) / (42 << 320):
+  n1.assign_pow10(100);
+  result = n1.divmod_assign(bigint(42) <<= 320);
+  EXPECT_EQ(result, 111);
+  EXPECT_EQ("13ad2594c37ceb0b2784c4ce0bf38ace408e211a7caab24308a82e8f10p96",
+            fmt::format("{}", n1));
+  // 42 / 100:
+  bigint n2(42);
+  n1.assign_pow10(2);
+  result = n2.divmod_assign(n1);
+  EXPECT_EQ(result, 0);
+  EXPECT_EQ("2a", fmt::format("{}", n2));
+}
+
+template <bool is_iec559> void run_double_tests() {
+  fmt::print("warning: double is not IEC559, skipping FP tests\n");
+}
+
+template <> void run_double_tests<true>() {
+  // Construct from double.
+  EXPECT_EQ(fp(1.23), fp(0x13ae147ae147aeu, -52));
+}
+
+TEST(fp_test, double_tests) {
+  run_double_tests<std::numeric_limits<double>::is_iec559>();
+}
+
+TEST(fp_test, normalize) {
+  const auto v = fp(0xbeef, 42);
+  auto normalized = normalize(v);
+  EXPECT_EQ(0xbeef000000000000, normalized.f);
+  EXPECT_EQ(-6, normalized.e);
+}
+
+TEST(fp_test, multiply) {
+  auto v = fp(123ULL << 32, 4) * fp(56ULL << 32, 7);
+  EXPECT_EQ(v.f, 123u * 56u);
+  EXPECT_EQ(v.e, 4 + 7 + 64);
+  v = fp(123ULL << 32, 4) * fp(567ULL << 31, 8);
+  EXPECT_EQ(v.f, (123 * 567 + 1u) / 2);
+  EXPECT_EQ(v.e, 4 + 8 + 64);
+}
+
+TEST(fp_test, get_cached_power) {
+  using limits = std::numeric_limits<double>;
+  for (auto exp = limits::min_exponent; exp <= limits::max_exponent; ++exp) {
+    int dec_exp = 0;
+    auto fp = fmt::detail::get_cached_power(exp, dec_exp);
+    bigint exact, cache(fp.f);
+    if (dec_exp >= 0) {
+      exact.assign_pow10(dec_exp);
+      if (fp.e <= 0)
+        exact <<= -fp.e;
+      else
+        cache <<= fp.e;
+      exact.align(cache);
+      cache.align(exact);
+      auto exact_str = fmt::format("{}", exact);
+      auto cache_str = fmt::format("{}", cache);
+      EXPECT_EQ(exact_str.size(), cache_str.size());
+      EXPECT_EQ(exact_str.substr(0, 15), cache_str.substr(0, 15));
+      int diff = cache_str[15] - exact_str[15];
+      if (diff == 1)
+        EXPECT_GT(exact_str[16], '8');
+      else
+        EXPECT_EQ(diff, 0);
+    } else {
+      cache.assign_pow10(-dec_exp);
+      cache *= fp.f + 1;  // Inexact check.
+      exact.assign(1);
+      exact <<= -fp.e;
+      exact.align(cache);
+      auto exact_str = fmt::format("{}", exact);
+      auto cache_str = fmt::format("{}", cache);
+      EXPECT_EQ(exact_str.size(), cache_str.size());
+      EXPECT_EQ(exact_str.substr(0, 16), cache_str.substr(0, 16));
+    }
+  }
+}
+
+TEST(fp_test, dragonbox_max_k) {
+  using fmt::detail::dragonbox::floor_log10_pow2;
+  using float_info = fmt::detail::dragonbox::float_info<float>;
+  EXPECT_EQ(fmt::detail::const_check(float_info::max_k),
+            float_info::kappa - floor_log10_pow2(float_info::min_exponent -
+                                                 float_info::significand_bits));
+  using double_info = fmt::detail::dragonbox::float_info<double>;
+  EXPECT_EQ(
+      fmt::detail::const_check(double_info::max_k),
+      double_info::kappa - floor_log10_pow2(double_info::min_exponent -
+                                            double_info::significand_bits));
+}
+
+TEST(fp_test, get_round_direction) {
+  using fmt::detail::get_round_direction;
+  using fmt::detail::round_direction;
+  EXPECT_EQ(round_direction::down, get_round_direction(100, 50, 0));
+  EXPECT_EQ(round_direction::up, get_round_direction(100, 51, 0));
+  EXPECT_EQ(round_direction::down, get_round_direction(100, 40, 10));
+  EXPECT_EQ(round_direction::up, get_round_direction(100, 60, 10));
+  for (size_t i = 41; i < 60; ++i)
+    EXPECT_EQ(round_direction::unknown, get_round_direction(100, i, 10));
+  uint64_t max = max_value<uint64_t>();
+  EXPECT_THROW(get_round_direction(100, 100, 0), assertion_failure);
+  EXPECT_THROW(get_round_direction(100, 0, 100), assertion_failure);
+  EXPECT_THROW(get_round_direction(100, 0, 50), assertion_failure);
+  // Check that remainder + error doesn't overflow.
+  EXPECT_EQ(round_direction::up, get_round_direction(max, max - 1, 2));
+  // Check that 2 * (remainder + error) doesn't overflow.
+  EXPECT_EQ(round_direction::unknown,
+            get_round_direction(max, max / 2 + 1, max / 2));
+  // Check that remainder - error doesn't overflow.
+  EXPECT_EQ(round_direction::unknown, get_round_direction(100, 40, 41));
+  // Check that 2 * (remainder - error) doesn't overflow.
+  EXPECT_EQ(round_direction::up, get_round_direction(max, max - 1, 1));
+}
+
+TEST(fp_test, fixed_handler) {
+  struct handler : fmt::detail::fixed_handler {
+    char buffer[10];
+    handler(int prec = 0) : fmt::detail::fixed_handler() {
+      buf = buffer;
+      precision = prec;
+    }
+  };
+  int exp = 0;
+  handler().on_digit('0', 100, 99, 0, exp, false);
+  EXPECT_THROW(handler().on_digit('0', 100, 100, 0, exp, false),
+               assertion_failure);
+  namespace digits = fmt::detail::digits;
+  EXPECT_EQ(handler(1).on_digit('0', 100, 10, 10, exp, false), digits::error);
+  // Check that divisor - error doesn't overflow.
+  EXPECT_EQ(handler(1).on_digit('0', 100, 10, 101, exp, false), digits::error);
+  // Check that 2 * error doesn't overflow.
+  uint64_t max = max_value<uint64_t>();
+  EXPECT_EQ(handler(1).on_digit('0', max, 10, max - 1, exp, false),
+            digits::error);
+}
+
+TEST(fp_test, grisu_format_compiles_with_on_ieee_double) {
+  fmt::memory_buffer buf;
+  format_float(0.42, -1, fmt::detail::float_specs(), buf);
+}
+
+TEST(format_impl_test, format_error_code) {
+  std::string msg = "error 42", sep = ": ";
+  {
+    fmt::memory_buffer buffer;
+    format_to(fmt::appender(buffer), "garbage");
+    fmt::detail::format_error_code(buffer, 42, "test");
+    EXPECT_EQ("test: " + msg, to_string(buffer));
+  }
+  {
+    fmt::memory_buffer buffer;
+    auto prefix =
+        std::string(fmt::inline_buffer_size - msg.size() - sep.size() + 1, 'x');
+    fmt::detail::format_error_code(buffer, 42, prefix);
+    EXPECT_EQ(msg, to_string(buffer));
+  }
+  int codes[] = {42, -1};
+  for (size_t i = 0, n = sizeof(codes) / sizeof(*codes); i < n; ++i) {
+    // Test maximum buffer size.
+    msg = fmt::format("error {}", codes[i]);
+    fmt::memory_buffer buffer;
+    auto prefix =
+        std::string(fmt::inline_buffer_size - msg.size() - sep.size(), 'x');
+    fmt::detail::format_error_code(buffer, codes[i], prefix);
+    EXPECT_EQ(prefix + sep + msg, to_string(buffer));
+    size_t size = fmt::inline_buffer_size;
+    EXPECT_EQ(size, buffer.size());
+    buffer.resize(0);
+    // Test with a message that doesn't fit into the buffer.
+    prefix += 'x';
+    fmt::detail::format_error_code(buffer, codes[i], prefix);
+    EXPECT_EQ(msg, to_string(buffer));
+  }
+}
+
+TEST(format_impl_test, compute_width) {
+  EXPECT_EQ(4,
+            fmt::detail::compute_width(
+                fmt::basic_string_view<fmt::detail::char8_type>(
+                    reinterpret_cast<const fmt::detail::char8_type*>("ёжик"))));
+}
+
+// Tests fmt::detail::count_digits for integer type Int.
+template <typename Int> void test_count_digits() {
+  for (Int i = 0; i < 10; ++i) EXPECT_EQ(1u, fmt::detail::count_digits(i));
+  for (Int i = 1, n = 1, end = max_value<Int>() / 10; n <= end; ++i) {
+    n *= 10;
+    EXPECT_EQ(i, fmt::detail::count_digits(n - 1));
+    EXPECT_EQ(i + 1, fmt::detail::count_digits(n));
+  }
+}
+
+TEST(format_impl_test, count_digits) {
+  test_count_digits<uint32_t>();
+  test_count_digits<uint64_t>();
+}
+
+TEST(format_impl_test, write_fallback_uintptr) {
+  std::string s;
+  fmt::detail::write_ptr<char>(
+      std::back_inserter(s),
+      fmt::detail::fallback_uintptr(reinterpret_cast<void*>(0xface)), nullptr);
+  EXPECT_EQ(s, "0xface");
+}
+
+#ifdef _WIN32
+#  include <windows.h>
+#endif
+
+#ifdef _WIN32
+TEST(format_impl_test, write_console_signature) {
+  decltype(WriteConsoleW)* p = fmt::detail::WriteConsoleW;
+  (void)p;
+}
+#endif

vendor/Fmt/test/fuzzing/CMakeLists.txt

@@ -0,0 +1,30 @@
+# Copyright (c) 2019, Paul Dreik
+# License: see LICENSE.rst in the fmt root directory
+
+# Link in the main function. Useful for reproducing, kcov, gdb, afl, valgrind.
+# (Note that libFuzzer can also reproduce, just pass it the files.)
+option(FMT_FUZZ_LINKMAIN "Enables the reproduce mode, instead of libFuzzer" On)
+
+# For oss-fuzz - insert $LIB_FUZZING_ENGINE into the link flags, but only for
+# the fuzz targets, otherwise the CMake configuration step fails.
+set(FMT_FUZZ_LDFLAGS "" CACHE STRING "LDFLAGS for the fuzz targets")
+
+# Adds a binary for reproducing, i.e. no fuzzing, just enables replaying data
+# through the fuzzers.
+function(add_fuzzer source)
+  get_filename_component(basename ${source} NAME_WE)
+  set(name ${basename}-fuzzer)
+  add_executable(${name} ${source} fuzzer-common.h)
+  if (FMT_FUZZ_LINKMAIN)
+    target_sources(${name} PRIVATE main.cc)
+  endif ()
+  target_link_libraries(${name} PRIVATE fmt)
+  if (FMT_FUZZ_LDFLAGS)
+    target_link_libraries(${name} PRIVATE ${FMT_FUZZ_LDFLAGS})
+  endif ()
+  target_compile_features(${name} PRIVATE cxx_generic_lambdas)
+endfunction()
+
+foreach (source chrono-duration.cc float.cc named-arg.cc one-arg.cc two-args.cc)
+  add_fuzzer(${source})
+endforeach ()

vendor/Fmt/test/fuzzing/README.md

@@ -0,0 +1,25 @@
+# Running the fuzzers locally
+
+There is a [helper script](build.sh) to build the fuzzers, which has only been
+tested on Debian and Ubuntu linux so far. There should be no problems fuzzing on
+Windows (using clang>=8) or on Mac, but the script will probably not work out of
+the box.
+
+Something along
+```sh
+mkdir build
+cd build
+export CXX=clang++
+export CXXFLAGS="-fsanitize=fuzzer-no-link -DFUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION= -g"
+cmake .. -DFMT_SAFE_DURATION_CAST=On -DFMT_FUZZ=On -DFMT_FUZZ_LINKMAIN=Off -DFMT_FUZZ_LDFLAGS="-fsanitize=fuzzer"
+cmake --build .
+```
+should work to build the fuzzers for all platforms which clang supports.
+
+Execute a fuzzer with for instance
+```sh
+cd build
+export UBSAN_OPTIONS=halt_on_error=1
+mkdir out_chrono
+bin/fuzzer_chrono_duration out_chrono
+```

vendor/Fmt/test/fuzzing/build.sh

@@ -0,0 +1,88 @@
+#!/bin/sh
+#
+# Creates fuzzer builds of various kinds
+# - oss-fuzz emulated mode (makes sure a simulated invocation by oss-fuzz works)
+# - libFuzzer build (you will need clang)
+# - afl build (you will need afl)
+#
+#
+# Copyright (c) 2019 Paul Dreik
+#
+# For the license information refer to format.h.
+
+set -e
+me=$(basename $0)
+root=$(readlink -f "$(dirname "$0")/../..")
+
+
+echo $me: root=$root
+
+here=$(pwd)
+
+CXXFLAGSALL="-DFUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION= -g"
+CMAKEFLAGSALL="$root -GNinja -DCMAKE_BUILD_TYPE=Debug -DFMT_DOC=Off -DFMT_TEST=Off -DFMT_FUZZ=On -DCMAKE_CXX_STANDARD=17"
+
+# For performance analysis of the fuzzers.
+builddir=$here/build-fuzzers-perfanalysis
+mkdir -p $builddir
+cd $builddir
+CXX="ccache g++" CXXFLAGS="$CXXFLAGSALL -g" cmake \
+$CMAKEFLAGSALL \
+-DFMT_FUZZ_LINKMAIN=On \
+-DCMAKE_BUILD_TYPE=Release
+
+cmake --build $builddir
+
+# Builds the fuzzers as oss-fuzz does.
+builddir=$here/build-fuzzers-ossfuzz
+mkdir -p $builddir
+cd $builddir
+CXX="clang++" \
+CXXFLAGS="$CXXFLAGSALL -fsanitize=fuzzer-no-link" cmake \
+cmake $CMAKEFLAGSALL \
+-DFMT_FUZZ_LINKMAIN=Off \
+-DFMT_FUZZ_LDFLAGS="-fsanitize=fuzzer"
+
+cmake --build $builddir
+
+
+# Builds fuzzers for local fuzzing with libfuzzer with asan+usan.
+builddir=$here/build-fuzzers-libfuzzer
+mkdir -p $builddir
+cd $builddir
+CXX="clang++" \
+CXXFLAGS="$CXXFLAGSALL -fsanitize=fuzzer-no-link,address,undefined" cmake \
+cmake $CMAKEFLAGSALL \
+-DFMT_FUZZ_LINKMAIN=Off \
+-DFMT_FUZZ_LDFLAGS="-fsanitize=fuzzer"
+
+cmake --build $builddir
+
+# Builds a fast fuzzer for making coverage fast.
+builddir=$here/build-fuzzers-fast
+mkdir -p $builddir
+cd $builddir
+CXX="clang++" \
+CXXFLAGS="$CXXFLAGSALL -fsanitize=fuzzer-no-link -O3" cmake \
+cmake $CMAKEFLAGSALL \
+-DFMT_FUZZ_LINKMAIN=Off \
+-DFMT_FUZZ_LDFLAGS="-fsanitize=fuzzer" \
+ -DCMAKE_BUILD_TYPE=Release
+
+cmake --build $builddir
+
+
+# Builds fuzzers for local fuzzing with afl.
+builddir=$here/build-fuzzers-afl
+mkdir -p $builddir
+cd $builddir
+CXX="afl-g++" \
+CXXFLAGS="$CXXFLAGSALL -fsanitize=address,undefined" \
+cmake $CMAKEFLAGSALL \
+-DFMT_FUZZ_LINKMAIN=On
+
+cmake --build $builddir
+
+
+echo $me: all good
+

vendor/Fmt/test/fuzzing/chrono-duration.cc

@@ -0,0 +1,135 @@
+// Copyright (c) 2019, Paul Dreik
+// For the license information refer to format.h.
+
+#include <cstdint>
+#include <fmt/chrono.h>
+
+#include "fuzzer-common.h"
+
+template <typename Period, typename Rep>
+void invoke_inner(fmt::string_view format_str, Rep rep) {
+  auto value = std::chrono::duration<Rep, Period>(rep);
+  try {
+#if FMT_FUZZ_FORMAT_TO_STRING
+    std::string message = fmt::format(format_str, value);
+#else
+    fmt::memory_buffer buf;
+    fmt::format_to(buf, format_str, value);
+#endif
+  } catch (std::exception&) {
+  }
+}
+
+// Rep is a duration's representation type.
+template <typename Rep>
+void invoke_outer(const uint8_t* data, size_t size, int period) {
+  // Always use a fixed location of the data.
+  static_assert(sizeof(Rep) <= fixed_size, "fixed size is too small");
+  if (size <= fixed_size + 1) return;
+
+  const Rep rep = assign_from_buf<Rep>(data);
+  data += fixed_size;
+  size -= fixed_size;
+
+  // data is already allocated separately in libFuzzer so reading past the end 
+  // will most likely be detected anyway.
+  const auto format_str = fmt::string_view(as_chars(data), size);
+
+  // yocto, zepto, zetta and yotta are not handled.
+  switch (period) {
+  case 1:
+    invoke_inner<std::atto>(format_str, rep);
+    break;
+  case 2:
+    invoke_inner<std::femto>(format_str, rep);
+    break;
+  case 3:
+    invoke_inner<std::pico>(format_str, rep);
+    break;
+  case 4:
+    invoke_inner<std::nano>(format_str, rep);
+    break;
+  case 5:
+    invoke_inner<std::micro>(format_str, rep);
+    break;
+  case 6:
+    invoke_inner<std::milli>(format_str, rep);
+    break;
+  case 7:
+    invoke_inner<std::centi>(format_str, rep);
+    break;
+  case 8:
+    invoke_inner<std::deci>(format_str, rep);
+    break;
+  case 9:
+    invoke_inner<std::deca>(format_str, rep);
+    break;
+  case 10:
+    invoke_inner<std::kilo>(format_str, rep);
+    break;
+  case 11:
+    invoke_inner<std::mega>(format_str, rep);
+    break;
+  case 12:
+    invoke_inner<std::giga>(format_str, rep);
+    break;
+  case 13:
+    invoke_inner<std::tera>(format_str, rep);
+    break;
+  case 14:
+    invoke_inner<std::peta>(format_str, rep);
+    break;
+  case 15:
+    invoke_inner<std::exa>(format_str, rep);
+    break;
+  }
+}
+
+extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
+  if (size <= 4)  return 0;
+
+  const auto representation = data[0];
+  const auto period = data[1];
+  data += 2;
+  size -= 2;
+
+  switch (representation) {
+  case 1:
+    invoke_outer<char>(data, size, period);
+    break;
+  case 2:
+    invoke_outer<signed char>(data, size, period);
+    break;
+  case 3:
+    invoke_outer<unsigned char>(data, size, period);
+    break;
+  case 4:
+    invoke_outer<short>(data, size, period);
+    break;
+  case 5:
+    invoke_outer<unsigned short>(data, size, period);
+    break;
+  case 6:
+    invoke_outer<int>(data, size, period);
+    break;
+  case 7:
+    invoke_outer<unsigned int>(data, size, period);
+    break;
+  case 8:
+    invoke_outer<long>(data, size, period);
+    break;
+  case 9:
+    invoke_outer<unsigned long>(data, size, period);
+    break;
+  case 10:
+    invoke_outer<float>(data, size, period);
+    break;
+  case 11:
+    invoke_outer<double>(data, size, period);
+    break;
+  case 12:
+    invoke_outer<long double>(data, size, period);
+    break;
+  }
+  return 0;
+}

vendor/Fmt/test/fuzzing/float.cc

@@ -0,0 +1,39 @@
+// A fuzzer for floating-point formatter.
+// For the license information refer to format.h.
+
+#include <cstdint>
+#include <cstdlib>
+#include <stdexcept>
+#include <limits>
+#include <fmt/format.h>
+
+#include "fuzzer-common.h"
+
+void check_round_trip(fmt::string_view format_str, double value) {
+  auto buffer = fmt::memory_buffer();
+  fmt::format_to(buffer, format_str, value);
+
+  if (std::isnan(value)) {
+    auto nan = std::signbit(value) ? "-nan" : "nan";
+    if (fmt::string_view(buffer.data(), buffer.size()) != nan)
+      throw std::runtime_error("round trip failure");
+    return;
+  }
+
+  buffer.push_back('\0');
+  char* ptr = nullptr;
+  if (std::strtod(buffer.data(), &ptr) != value)
+    throw std::runtime_error("round trip failure");
+  if (ptr + 1 != buffer.end())
+    throw std::runtime_error("unparsed output");
+}
+
+extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
+  if (size <= sizeof(double) || !std::numeric_limits<double>::is_iec559)
+    return 0;
+  check_round_trip("{}", assign_from_buf<double>(data));
+  // A larger than necessary precision is used to trigger the fallback
+  // formatter.
+  check_round_trip("{:.50g}", assign_from_buf<double>(data));
+  return 0;
+}

vendor/Fmt/test/fuzzing/fuzzer-common.h

@@ -0,0 +1,75 @@
+// Copyright (c) 2019, Paul Dreik
+// For the license information refer to format.h.
+
+#ifndef FUZZER_COMMON_H
+#define FUZZER_COMMON_H
+
+#include <cstdint>      // std::uint8_t
+#include <cstring>      // memcpy
+#include <vector>
+
+#include <fmt/core.h>
+
+// One can format to either a string, or a buffer. The latter is faster, but
+// one may be interested in formatting to a string instead to verify it works
+// as intended. To avoid a combinatoric explosion, select this at compile time
+// instead of dynamically from the fuzz data.
+#define FMT_FUZZ_FORMAT_TO_STRING 0
+
+// If {fmt} is given a buffer that is separately allocated, chances that address
+// sanitizer detects out of bound reads is much higher. However, it slows down
+// the fuzzing.
+#define FMT_FUZZ_SEPARATE_ALLOCATION 1
+
+// The size of the largest possible type in use.
+// To let the the fuzzer mutation be efficient at cross pollinating between
+// different types, use a fixed size format. The same bit pattern, interpreted
+// as another type, is likely interesting.
+constexpr auto fixed_size = 16;
+
+// Casts data to a char pointer.
+template <typename T> inline const char* as_chars(const T* data) {
+  return reinterpret_cast<const char*>(data);
+}
+
+// Casts data to a byte pointer.
+template <typename T> inline const std::uint8_t* as_bytes(const T* data) {
+  return reinterpret_cast<const std::uint8_t*>(data);
+}
+
+// Blits bytes from data to form an (assumed trivially constructible) object
+// of type Item.
+template <class Item> inline Item assign_from_buf(const std::uint8_t* data) {
+  auto item = Item();
+  std::memcpy(&item, data, sizeof(Item));
+  return item;
+}
+
+// Reads a boolean value by looking at the first byte from data.
+template <> inline bool assign_from_buf<bool>(const std::uint8_t* data) {
+  return *data != 0;
+}
+
+struct data_to_string {
+#if FMT_FUZZ_SEPARATE_ALLOCATION
+  std::vector<char> buffer;
+
+  data_to_string(const uint8_t* data, size_t size, bool add_terminator = false)
+      : buffer(size + (add_terminator ? 1 : 0)) {
+    std::memcpy(buffer.data(), data, size);
+  }
+
+  fmt::string_view get() const { return {buffer.data(), buffer.size()}; }
+#else
+  fmt::string_view sv;
+
+  data_to_string(const uint8_t* data, size_t size, bool = false)
+      : str(as_chars(data), size) {}
+
+  fmt::string_view get() const { return sv; }
+#endif
+
+  const char* data() const { return get().data(); }
+};
+
+#endif  // FUZZER_COMMON_H

vendor/Fmt/test/fuzzing/main.cc

@@ -0,0 +1,22 @@
+#include <cassert>
+#include <fstream>
+#include <vector>
+
+#include "fuzzer-common.h"
+
+extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size);
+
+int main(int argc, char** argv) {
+  for (int i = 1; i < argc; ++i) {
+    std::ifstream in(argv[i]);
+    assert(in);
+    in.seekg(0, std::ios_base::end);
+    const auto size = in.tellg();
+    assert(size >= 0);
+    in.seekg(0, std::ios_base::beg);
+    std::vector<char> buf(static_cast<size_t>(size));
+    in.read(buf.data(), size);
+    assert(in.gcount() == size);
+    LLVMFuzzerTestOneInput(as_bytes(buf.data()), buf.size());
+  }
+}

vendor/Fmt/test/fuzzing/named-arg.cc

@@ -0,0 +1,100 @@
+// Copyright (c) 2019, Paul Dreik
+// For the license information refer to format.h.
+
+#include <cstdint>
+#include <type_traits>
+#include <vector>
+#include <fmt/chrono.h>
+
+#include "fuzzer-common.h"
+
+template <typename T>
+void invoke_fmt(const uint8_t* data, size_t size, unsigned arg_name_size) {
+  static_assert(sizeof(T) <= fixed_size, "fixed_size too small");
+  if (size <= fixed_size) return;
+  const T value = assign_from_buf<T>(data);
+  data += fixed_size;
+  size -= fixed_size;
+
+  if (arg_name_size <= 0 || arg_name_size >= size) return;
+  data_to_string arg_name(data, arg_name_size, true);
+  data += arg_name_size;
+  size -= arg_name_size;
+
+  data_to_string format_str(data, size);
+  try {
+#if FMT_FUZZ_FORMAT_TO_STRING
+    std::string message =
+      fmt::format(format_str.get(), fmt::arg(arg_name.data(), value));
+#else
+    fmt::memory_buffer out;
+    fmt::format_to(out, format_str.get(), fmt::arg(arg_name.data(), value));
+#endif
+  } catch (std::exception&) {
+  }
+}
+
+// For dynamic dispatching to an explicit instantiation.
+template <typename Callback> void invoke(int type, Callback callback) {
+  switch (type) {
+  case 0:
+    callback(bool());
+    break;
+  case 1:
+    callback(char());
+    break;
+  case 2:
+    using sc = signed char;
+    callback(sc());
+    break;
+  case 3:
+    using uc = unsigned char;
+    callback(uc());
+    break;
+  case 4:
+    callback(short());
+    break;
+  case 5:
+    using us = unsigned short;
+    callback(us());
+    break;
+  case 6:
+    callback(int());
+    break;
+  case 7:
+    callback(unsigned());
+    break;
+  case 8:
+    callback(long());
+    break;
+  case 9:
+    using ul = unsigned long;
+    callback(ul());
+    break;
+  case 10:
+    callback(float());
+    break;
+  case 11:
+    callback(double());
+    break;
+  case 12:
+    using LD = long double;
+    callback(LD());
+    break;
+  }
+}
+
+extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
+  if (size <= 3) return 0;
+
+  // Switch types depending on the first byte of the input.
+  const auto type = data[0] & 0x0F;
+  const unsigned arg_name_size = (data[0] & 0xF0) >> 4;
+  data++;
+  size--;
+
+  invoke(type, [=](auto arg) {
+    invoke_fmt<decltype(arg)>(data, size, arg_name_size);
+  });
+  return 0;
+}

vendor/Fmt/test/fuzzing/one-arg.cc

@@ -0,0 +1,91 @@
+// Copyright (c) 2019, Paul Dreik
+// For the license information refer to format.h.
+
+#include <cstdint>
+#include <exception>
+#include <fmt/chrono.h>
+
+#include "fuzzer-common.h"
+
+template <typename T, typename Repr>
+const T* from_repr(const Repr& r) { return &r; }
+
+template <>
+const std::tm* from_repr<std::tm>(const std::time_t& t) {
+  return std::localtime(&t);
+}
+
+template <typename T, typename Repr = T>
+void invoke_fmt(const uint8_t* data, size_t size) {
+  static_assert(sizeof(Repr) <= fixed_size, "Nfixed is too small");
+  if (size <= fixed_size) return;
+  auto repr = assign_from_buf<Repr>(data);
+  const T* value = from_repr<T>(repr);
+  if (!value) return;
+  data += fixed_size;
+  size -= fixed_size;
+  data_to_string format_str(data, size);
+  try {
+#if FMT_FUZZ_FORMAT_TO_STRING
+    std::string message = fmt::format(format_str.get(), *value);
+#else
+    fmt::memory_buffer message;
+    fmt::format_to(message, format_str.get(), *value);
+#endif
+  } catch (std::exception&) {
+  }
+}
+
+extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
+  if (size <= 3) return 0;
+
+  const auto first = data[0];
+  data++;
+  size--;
+
+  switch (first) {
+  case 0:
+    invoke_fmt<bool>(data, size);
+    break;
+  case 1:
+    invoke_fmt<char>(data, size);
+    break;
+  case 2:
+    invoke_fmt<unsigned char>(data, size);
+    break;
+  case 3:
+    invoke_fmt<signed char>(data, size);
+    break;
+  case 4:
+    invoke_fmt<short>(data, size);
+    break;
+  case 5:
+    invoke_fmt<unsigned short>(data, size);
+    break;
+  case 6:
+    invoke_fmt<int>(data, size);
+    break;
+  case 7:
+    invoke_fmt<unsigned int>(data, size);
+    break;
+  case 8:
+    invoke_fmt<long>(data, size);
+    break;
+  case 9:
+    invoke_fmt<unsigned long>(data, size);
+    break;
+  case 10:
+    invoke_fmt<float>(data, size);
+    break;
+  case 11:
+    invoke_fmt<double>(data, size);
+    break;
+  case 12:
+    invoke_fmt<long double>(data, size);
+    break;
+  case 13:
+    invoke_fmt<std::tm, std::time_t>(data, size);
+    break;
+  }
+  return 0;
+}

vendor/Fmt/test/fuzzing/two-args.cc

@@ -0,0 +1,105 @@
+// Copyright (c) 2019, Paul Dreik
+// For the license information refer to format.h.
+
+#include <cstdint>
+#include <exception>
+#include <string>
+#include <fmt/format.h>
+
+#include "fuzzer-common.h"
+
+template <typename Item1, typename Item2>
+void invoke_fmt(const uint8_t* data, size_t size) {
+  static_assert(sizeof(Item1) <= fixed_size, "size1 exceeded");
+  static_assert(sizeof(Item2) <= fixed_size, "size2 exceeded");
+  if (size <= fixed_size + fixed_size) return;
+
+  const Item1 item1 = assign_from_buf<Item1>(data);
+  data += fixed_size;
+  size -= fixed_size;
+
+  const Item2 item2 = assign_from_buf<Item2>(data);
+  data += fixed_size;
+  size -= fixed_size;
+
+  auto format_str = fmt::string_view(as_chars(data), size);
+#if FMT_FUZZ_FORMAT_TO_STRING
+  std::string message = fmt::format(format_str, item1, item2);
+#else
+  fmt::memory_buffer message;
+  fmt::format_to(message, format_str, item1, item2);
+#endif
+}
+
+// For dynamic dispatching to an explicit instantiation.
+template <typename Callback> void invoke(int index, Callback callback) {
+  switch (index) {
+  case 0:
+    callback(bool());
+    break;
+  case 1:
+    callback(char());
+    break;
+  case 2:
+    using sc = signed char;
+    callback(sc());
+    break;
+  case 3:
+    using uc = unsigned char;
+    callback(uc());
+    break;
+  case 4:
+    callback(short());
+    break;
+  case 5:
+    using us = unsigned short;
+    callback(us());
+    break;
+  case 6:
+    callback(int());
+    break;
+  case 7:
+    callback(unsigned());
+    break;
+  case 8:
+    callback(long());
+    break;
+  case 9:
+    using ul = unsigned long;
+    callback(ul());
+    break;
+  case 10:
+    callback(float());
+    break;
+  case 11:
+    callback(double());
+    break;
+  case 12:
+    using LD = long double;
+    callback(LD());
+    break;
+  case 13:
+    using ptr = void*;
+    callback(ptr());
+    break;
+  }
+}
+
+extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
+  if (size <= 3) return 0;
+
+  // Switch types depending on the first byte of the input.
+  const auto type1 = data[0] & 0x0F;
+  const auto type2 = (data[0] & 0xF0) >> 4;
+  data++;
+  size--;
+  try {
+    invoke(type1, [=](auto param1) {
+      invoke(type2, [=](auto param2) {
+        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
+      });
+    });
+  } catch (std::exception&) {
+  }
+  return 0;
+}

vendor/Fmt/test/gtest-extra-test.cc

@@ -0,0 +1,413 @@
+// Formatting library for C++ - tests of custom Google Test assertions
+//
+// Copyright (c) 2012 - present, Victor Zverovich
+// All rights reserved.
+//
+// For the license information refer to format.h.
+
+#include "gtest-extra.h"
+
+#include <gtest/gtest-spi.h>
+
+#include <cstring>
+#include <memory>
+#include <stdexcept>
+
+#include "fmt/os.h"
+#include "util.h"
+
+// Tests that assertion macros evaluate their arguments exactly once.
+namespace {
+class single_evaluation_test : public ::testing::Test {
+ protected:
+  single_evaluation_test() {
+    p_ = s_;
+    a_ = 0;
+    b_ = 0;
+  }
+
+  static const char* const s_;
+  static const char* p_;
+
+  static int a_;
+  static int b_;
+};
+}  // namespace
+
+const char* const single_evaluation_test::s_ = "01234";
+const char* single_evaluation_test::p_;
+int single_evaluation_test::a_;
+int single_evaluation_test::b_;
+
+void do_nothing() {}
+
+FMT_NORETURN void throw_exception() { throw std::runtime_error("test"); }
+
+FMT_NORETURN void throw_system_error() {
+  throw fmt::system_error(EDOM, "test");
+}
+
+// Tests that when EXPECT_THROW_MSG fails, it evaluates its message argument
+// exactly once.
+TEST_F(single_evaluation_test, failed_expect_throw_msg) {
+  EXPECT_NONFATAL_FAILURE(
+      EXPECT_THROW_MSG(throw_exception(), std::exception, p_++), "01234");
+  EXPECT_EQ(s_ + 1, p_);
+}
+
+// Tests that when EXPECT_SYSTEM_ERROR fails, it evaluates its message argument
+// exactly once.
+TEST_F(single_evaluation_test, failed_expect_system_error) {
+  EXPECT_NONFATAL_FAILURE(EXPECT_SYSTEM_ERROR(throw_system_error(), EDOM, p_++),
+                          "01234");
+  EXPECT_EQ(s_ + 1, p_);
+}
+
+// Tests that assertion arguments are evaluated exactly once.
+TEST_F(single_evaluation_test, exception_tests) {
+  // successful EXPECT_THROW_MSG
+  EXPECT_THROW_MSG(
+      {  // NOLINT
+        a_++;
+        throw_exception();
+      },
+      std::exception, (b_++, "test"));
+  EXPECT_EQ(1, a_);
+  EXPECT_EQ(1, b_);
+
+  // failed EXPECT_THROW_MSG, throws different type
+  EXPECT_NONFATAL_FAILURE(EXPECT_THROW_MSG(
+                              {  // NOLINT
+                                a_++;
+                                throw_exception();
+                              },
+                              std::logic_error, (b_++, "test")),
+                          "throws a different type");
+  EXPECT_EQ(2, a_);
+  EXPECT_EQ(2, b_);
+
+  // failed EXPECT_THROW_MSG, throws an exception with different message
+  EXPECT_NONFATAL_FAILURE(EXPECT_THROW_MSG(
+                              {  // NOLINT
+                                a_++;
+                                throw_exception();
+                              },
+                              std::exception, (b_++, "other")),
+                          "throws an exception with a different message");
+  EXPECT_EQ(3, a_);
+  EXPECT_EQ(3, b_);
+
+  // failed EXPECT_THROW_MSG, throws nothing
+  EXPECT_NONFATAL_FAILURE(
+      EXPECT_THROW_MSG(a_++, std::exception, (b_++, "test")), "throws nothing");
+  EXPECT_EQ(4, a_);
+  EXPECT_EQ(4, b_);
+}
+
+TEST_F(single_evaluation_test, system_error_tests) {
+  // successful EXPECT_SYSTEM_ERROR
+  EXPECT_SYSTEM_ERROR(
+      {  // NOLINT
+        a_++;
+        throw_system_error();
+      },
+      EDOM, (b_++, "test"));
+  EXPECT_EQ(1, a_);
+  EXPECT_EQ(1, b_);
+
+  // failed EXPECT_SYSTEM_ERROR, throws different type
+  EXPECT_NONFATAL_FAILURE(EXPECT_SYSTEM_ERROR(
+                              {  // NOLINT
+                                a_++;
+                                throw_exception();
+                              },
+                              EDOM, (b_++, "test")),
+                          "throws a different type");
+  EXPECT_EQ(2, a_);
+  EXPECT_EQ(2, b_);
+
+  // failed EXPECT_SYSTEM_ERROR, throws an exception with different message
+  EXPECT_NONFATAL_FAILURE(EXPECT_SYSTEM_ERROR(
+                              {  // NOLINT
+                                a_++;
+                                throw_system_error();
+                              },
+                              EDOM, (b_++, "other")),
+                          "throws an exception with a different message");
+  EXPECT_EQ(3, a_);
+  EXPECT_EQ(3, b_);
+
+  // failed EXPECT_SYSTEM_ERROR, throws nothing
+  EXPECT_NONFATAL_FAILURE(EXPECT_SYSTEM_ERROR(a_++, EDOM, (b_++, "test")),
+                          "throws nothing");
+  EXPECT_EQ(4, a_);
+  EXPECT_EQ(4, b_);
+}
+
+#if FMT_USE_FCNTL
+// Tests that when EXPECT_WRITE fails, it evaluates its message argument
+// exactly once.
+TEST_F(single_evaluation_test, failed_expect_write) {
+  EXPECT_NONFATAL_FAILURE(EXPECT_WRITE(stdout, std::printf("test"), p_++),
+                          "01234");
+  EXPECT_EQ(s_ + 1, p_);
+}
+
+// Tests that assertion arguments are evaluated exactly once.
+TEST_F(single_evaluation_test, write_tests) {
+  // successful EXPECT_WRITE
+  EXPECT_WRITE(
+      stdout,
+      {  // NOLINT
+        a_++;
+        std::printf("test");
+      },
+      (b_++, "test"));
+  EXPECT_EQ(1, a_);
+  EXPECT_EQ(1, b_);
+
+  // failed EXPECT_WRITE
+  EXPECT_NONFATAL_FAILURE(EXPECT_WRITE(
+                              stdout,
+                              {  // NOLINT
+                                a_++;
+                                std::printf("test");
+                              },
+                              (b_++, "other")),
+                          "Actual: test");
+  EXPECT_EQ(2, a_);
+  EXPECT_EQ(2, b_);
+}
+
+// Tests EXPECT_WRITE.
+TEST(gtest_extra_test, expect_write) {
+  EXPECT_WRITE(stdout, do_nothing(), "");
+  EXPECT_WRITE(stdout, std::printf("test"), "test");
+  EXPECT_WRITE(stderr, std::fprintf(stderr, "test"), "test");
+  EXPECT_NONFATAL_FAILURE(EXPECT_WRITE(stdout, std::printf("that"), "this"),
+                          "Expected: this\n"
+                          "  Actual: that");
+}
+
+TEST(gtest_extra_test, expect_write_streaming) {
+  EXPECT_WRITE(stdout, std::printf("test"), "test") << "unexpected failure";
+  EXPECT_NONFATAL_FAILURE(EXPECT_WRITE(stdout, std::printf("test"), "other")
+                              << "expected failure",
+                          "expected failure");
+}
+#endif  // FMT_USE_FCNTL
+
+// Tests that the compiler will not complain about unreachable code in the
+// EXPECT_THROW_MSG macro.
+TEST(gtest_extra_test, expect_throw_no_unreachable_code_warning) {
+  int n = 0;
+  using std::runtime_error;
+  EXPECT_THROW_MSG(throw runtime_error(""), runtime_error, "");
+  EXPECT_NONFATAL_FAILURE(EXPECT_THROW_MSG(n++, runtime_error, ""), "");
+  EXPECT_NONFATAL_FAILURE(EXPECT_THROW_MSG(throw 1, runtime_error, ""), "");
+  EXPECT_NONFATAL_FAILURE(
+      EXPECT_THROW_MSG(throw runtime_error("a"), runtime_error, "b"), "");
+}
+
+// Tests that the compiler will not complain about unreachable code in the
+// EXPECT_SYSTEM_ERROR macro.
+TEST(gtest_extra_test, expect_system_error_no_unreachable_code_warning) {
+  int n = 0;
+  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::system_error(EDOM, "aaa"), EDOM, "bbb"),
+      "");
+}
+
+TEST(gtest_extra_test, expect_throw_behaves_like_single_statement) {
+  if (::testing::internal::AlwaysFalse())
+    EXPECT_THROW_MSG(do_nothing(), std::exception, "");
+
+  if (::testing::internal::AlwaysTrue())
+    EXPECT_THROW_MSG(throw_exception(), std::exception, "test");
+  else
+    do_nothing();
+}
+
+TEST(gtest_extra_test, expect_system_error_behaves_like_single_statement) {
+  if (::testing::internal::AlwaysFalse())
+    EXPECT_SYSTEM_ERROR(do_nothing(), EDOM, "");
+
+  if (::testing::internal::AlwaysTrue())
+    EXPECT_SYSTEM_ERROR(throw_system_error(), EDOM, "test");
+  else
+    do_nothing();
+}
+
+TEST(gtest_extra_test, expect_write_behaves_like_single_statement) {
+  if (::testing::internal::AlwaysFalse())
+    EXPECT_WRITE(stdout, std::printf("x"), "x");
+
+  if (::testing::internal::AlwaysTrue())
+    EXPECT_WRITE(stdout, std::printf("x"), "x");
+  else
+    do_nothing();
+}
+
+// Tests EXPECT_THROW_MSG.
+TEST(gtest_extra_test, expect_throw_msg) {
+  EXPECT_THROW_MSG(throw_exception(), std::exception, "test");
+  EXPECT_NONFATAL_FAILURE(
+      EXPECT_THROW_MSG(throw_exception(), std::logic_error, "test"),
+      "Expected: throw_exception() throws an exception of "
+      "type std::logic_error.\n  Actual: it throws a different type.");
+  EXPECT_NONFATAL_FAILURE(
+      EXPECT_THROW_MSG(do_nothing(), std::exception, "test"),
+      "Expected: do_nothing() throws an exception of type std::exception.\n"
+      "  Actual: it throws nothing.");
+  EXPECT_NONFATAL_FAILURE(
+      EXPECT_THROW_MSG(throw_exception(), std::exception, "other"),
+      "throw_exception() throws an exception with a different message.\n"
+      "Expected: other\n"
+      "  Actual: test");
+}
+
+// Tests EXPECT_SYSTEM_ERROR.
+TEST(gtest_extra_test, expect_system_error) {
+  EXPECT_SYSTEM_ERROR(throw_system_error(), EDOM, "test");
+  EXPECT_NONFATAL_FAILURE(
+      EXPECT_SYSTEM_ERROR(throw_exception(), EDOM, "test"),
+      "Expected: throw_exception() throws an exception of "
+      "type std::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 std::system_error.\n"
+      "  Actual: it throws nothing.");
+  EXPECT_NONFATAL_FAILURE(
+      EXPECT_SYSTEM_ERROR(throw_system_error(), EDOM, "other"),
+      fmt::format(
+          "throw_system_error() throws an exception with a different message.\n"
+          "Expected: {}\n"
+          "  Actual: {}",
+          system_error_message(EDOM, "other"),
+          system_error_message(EDOM, "test")));
+}
+
+TEST(gtest_extra_test, expect_throw_msg_streaming) {
+  EXPECT_THROW_MSG(throw_exception(), std::exception, "test")
+      << "unexpected failure";
+  EXPECT_NONFATAL_FAILURE(
+      EXPECT_THROW_MSG(throw_exception(), std::exception, "other")
+          << "expected failure",
+      "expected failure");
+}
+
+TEST(gtest_extra_test, expect_system_error_streaming) {
+  EXPECT_SYSTEM_ERROR(throw_system_error(), EDOM, "test")
+      << "unexpected failure";
+  EXPECT_NONFATAL_FAILURE(
+      EXPECT_SYSTEM_ERROR(throw_system_error(), EDOM, "other")
+          << "expected failure",
+      "expected failure");
+}
+
+#if FMT_USE_FCNTL
+
+using fmt::buffered_file;
+using fmt::file;
+
+TEST(output_redirect_test, scoped_redirect) {
+  file read_end, write_end;
+  file::pipe(read_end, write_end);
+  {
+    buffered_file file(write_end.fdopen("w"));
+    std::fprintf(file.get(), "[[[");
+    {
+      output_redirect redir(file.get());
+      std::fprintf(file.get(), "censored");
+    }
+    std::fprintf(file.get(), "]]]");
+  }
+  EXPECT_READ(read_end, "[[[]]]");
+}
+
+// Test that output_redirect handles errors in flush correctly.
+TEST(output_redirect_test, flush_error_in_ctor) {
+  file read_end, write_end;
+  file::pipe(read_end, write_end);
+  int write_fd = write_end.descriptor();
+  file write_copy = write_end.dup(write_fd);
+  buffered_file f = write_end.fdopen("w");
+  // Put a character in a file buffer.
+  EXPECT_EQ('x', fputc('x', f.get()));
+  FMT_POSIX(close(write_fd));
+  std::unique_ptr<output_redirect> redir{nullptr};
+  EXPECT_SYSTEM_ERROR_NOASSERT(redir.reset(new output_redirect(f.get())), EBADF,
+                               "cannot flush stream");
+  redir.reset(nullptr);
+  write_copy.dup2(write_fd);  // "undo" close or dtor will fail
+}
+
+TEST(output_redirect_test, dup_error_in_ctor) {
+  buffered_file f = open_buffered_file();
+  int fd = (f.fileno)();
+  file copy = file::dup(fd);
+  FMT_POSIX(close(fd));
+  std::unique_ptr<output_redirect> redir{nullptr};
+  EXPECT_SYSTEM_ERROR_NOASSERT(
+      redir.reset(new output_redirect(f.get())), EBADF,
+      fmt::format("cannot duplicate file descriptor {}", fd));
+  copy.dup2(fd);  // "undo" close or dtor will fail
+}
+
+TEST(output_redirect_test, restore_and_read) {
+  file read_end, write_end;
+  file::pipe(read_end, write_end);
+  buffered_file file(write_end.fdopen("w"));
+  std::fprintf(file.get(), "[[[");
+  output_redirect redir(file.get());
+  std::fprintf(file.get(), "censored");
+  EXPECT_EQ("censored", redir.restore_and_read());
+  EXPECT_EQ("", redir.restore_and_read());
+  std::fprintf(file.get(), "]]]");
+  file = buffered_file();
+  EXPECT_READ(read_end, "[[[]]]");
+}
+
+// Test that OutputRedirect handles errors in flush correctly.
+TEST(output_redirect_test, flush_error_in_restore_and_read) {
+  file read_end, write_end;
+  file::pipe(read_end, write_end);
+  int write_fd = write_end.descriptor();
+  file write_copy = write_end.dup(write_fd);
+  buffered_file f = write_end.fdopen("w");
+  output_redirect redir(f.get());
+  // Put a character in a file buffer.
+  EXPECT_EQ('x', fputc('x', f.get()));
+  FMT_POSIX(close(write_fd));
+  EXPECT_SYSTEM_ERROR_NOASSERT(redir.restore_and_read(), EBADF,
+                               "cannot flush stream");
+  write_copy.dup2(write_fd);  // "undo" close or dtor will fail
+}
+
+TEST(output_redirect_test, error_in_dtor) {
+  file read_end, write_end;
+  file::pipe(read_end, write_end);
+  int write_fd = write_end.descriptor();
+  file write_copy = write_end.dup(write_fd);
+  buffered_file f = write_end.fdopen("w");
+  std::unique_ptr<output_redirect> redir(new output_redirect(f.get()));
+  // Put a character in a file buffer.
+  EXPECT_EQ('x', fputc('x', f.get()));
+  EXPECT_WRITE(
+      stderr,
+      {
+        // The close function must be called inside EXPECT_WRITE,
+        // otherwise the system may recycle closed file descriptor when
+        // redirecting the output in EXPECT_STDERR and the second close
+        // will break output redirection.
+        FMT_POSIX(close(write_fd));
+        SUPPRESS_ASSERT(redir.reset(nullptr));
+      },
+      system_error_message(EBADF, "cannot flush stream"));
+  write_copy.dup2(write_fd);  // "undo" close or dtor of buffered_file will fail
+}
+
+#endif  // FMT_USE_FCNTL

vendor/Fmt/test/gtest-extra.cc

@@ -0,0 +1,81 @@
+// Formatting library for C++ - custom Google Test assertions
+//
+// Copyright (c) 2012 - present, Victor Zverovich
+// All rights reserved.
+//
+// For the license information refer to format.h.
+
+#include "gtest-extra.h"
+
+#if FMT_USE_FCNTL
+
+using fmt::file;
+
+output_redirect::output_redirect(FILE* f) : file_(f) {
+  flush();
+  int fd = FMT_POSIX(fileno(f));
+  // Create a file object referring to the original file.
+  original_ = file::dup(fd);
+  // Create a pipe.
+  file write_end;
+  file::pipe(read_end_, write_end);
+  // Connect the passed FILE object to the write end of the pipe.
+  write_end.dup2(fd);
+}
+
+output_redirect::~output_redirect() FMT_NOEXCEPT {
+  try {
+    restore();
+  } catch (const std::exception& e) {
+    std::fputs(e.what(), stderr);
+  }
+}
+
+void output_redirect::flush() {
+#  if EOF != -1
+#    error "FMT_RETRY assumes return value of -1 indicating failure"
+#  endif
+  int result = 0;
+  FMT_RETRY(result, fflush(file_));
+  if (result != 0) throw fmt::system_error(errno, "cannot flush stream");
+}
+
+void output_redirect::restore() {
+  if (original_.descriptor() == -1) return;  // Already restored.
+  flush();
+  // Restore the original file.
+  original_.dup2(FMT_POSIX(fileno(file_)));
+  original_.close();
+}
+
+std::string output_redirect::restore_and_read() {
+  // Restore output.
+  restore();
+
+  // Read everything from the pipe.
+  std::string content;
+  if (read_end_.descriptor() == -1) return content;  // Already read.
+  enum { BUFFER_SIZE = 4096 };
+  char buffer[BUFFER_SIZE];
+  size_t count = 0;
+  do {
+    count = read_end_.read(buffer, BUFFER_SIZE);
+    content.append(buffer, count);
+  } while (count != 0);
+  read_end_.close();
+  return content;
+}
+
+std::string read(file& f, size_t count) {
+  std::string buffer(count, '\0');
+  size_t n = 0, offset = 0;
+  do {
+    n = f.read(&buffer[offset], count - offset);
+    // We can't read more than size_t bytes since count has type size_t.
+    offset += n;
+  } while (offset < count && n != 0);
+  buffer.resize(offset);
+  return buffer;
+}
+
+#endif  // FMT_USE_FCNTL

vendor/Fmt/test/gtest-extra.h

@@ -0,0 +1,164 @@
+// Formatting library for C++ - custom Google Test assertions
+//
+// Copyright (c) 2012 - present, Victor Zverovich
+// All rights reserved.
+//
+// For the license information refer to format.h.
+
+#ifndef FMT_GTEST_EXTRA_H_
+#define FMT_GTEST_EXTRA_H_
+
+#include <stdlib.h>  // _invalid_parameter_handler
+
+#include <string>
+
+#include "fmt/os.h"
+#include "gmock/gmock.h"
+
+#define FMT_TEST_THROW_(statement, expected_exception, expected_message, fail) \
+  GTEST_AMBIGUOUS_ELSE_BLOCKER_                                                \
+  if (::testing::AssertionResult gtest_ar = ::testing::AssertionSuccess()) {   \
+    std::string gtest_expected_message = expected_message;                     \
+    bool gtest_caught_expected = false;                                        \
+    try {                                                                      \
+      GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement);               \
+    } catch (expected_exception const& e) {                                    \
+      if (gtest_expected_message != e.what()) {                                \
+        gtest_ar << #statement                                                 \
+            " throws an exception with a different message.\n"                 \
+                 << "Expected: " << gtest_expected_message << "\n"             \
+                 << "  Actual: " << e.what();                                  \
+        goto GTEST_CONCAT_TOKEN_(gtest_label_testthrow_, __LINE__);            \
+      }                                                                        \
+      gtest_caught_expected = true;                                            \
+    } catch (...) {                                                            \
+      gtest_ar << "Expected: " #statement                                      \
+                  " throws an exception of type " #expected_exception          \
+                  ".\n  Actual: it throws a different type.";                  \
+      goto GTEST_CONCAT_TOKEN_(gtest_label_testthrow_, __LINE__);              \
+    }                                                                          \
+    if (!gtest_caught_expected) {                                              \
+      gtest_ar << "Expected: " #statement                                      \
+                  " throws an exception of type " #expected_exception          \
+                  ".\n  Actual: it throws nothing.";                           \
+      goto GTEST_CONCAT_TOKEN_(gtest_label_testthrow_, __LINE__);              \
+    }                                                                          \
+  } else                                                                       \
+    GTEST_CONCAT_TOKEN_(gtest_label_testthrow_, __LINE__)                      \
+        : fail(gtest_ar.failure_message())
+
+// Tests that the statement throws the expected exception and the exception's
+// what() method returns expected message.
+#define EXPECT_THROW_MSG(statement, expected_exception, expected_message) \
+  FMT_TEST_THROW_(statement, expected_exception, expected_message,        \
+                  GTEST_NONFATAL_FAILURE_)
+
+inline std::string system_error_message(int error_code,
+                                        const std::string& message) {
+  auto ec = std::error_code(error_code, std::generic_category());
+  return std::system_error(ec, message).what();
+}
+
+#define EXPECT_SYSTEM_ERROR(statement, error_code, message) \
+  EXPECT_THROW_MSG(statement, std::system_error,            \
+                   system_error_message(error_code, message))
+
+#if FMT_USE_FCNTL
+
+// Captures file output by redirecting it to a pipe.
+// The output it can handle is limited by the pipe capacity.
+class output_redirect {
+ private:
+  FILE* file_;
+  fmt::file original_;  // Original file passed to redirector.
+  fmt::file read_end_;  // Read end of the pipe where the output is redirected.
+
+  void flush();
+  void restore();
+
+ public:
+  explicit output_redirect(FILE* file);
+  ~output_redirect() FMT_NOEXCEPT;
+
+  output_redirect(const output_redirect&) = delete;
+  void operator=(const output_redirect&) = delete;
+
+  // Restores the original file, reads output from the pipe into a string
+  // and returns it.
+  std::string restore_and_read();
+};
+
+#  define FMT_TEST_WRITE_(statement, expected_output, file, fail)              \
+    GTEST_AMBIGUOUS_ELSE_BLOCKER_                                              \
+    if (::testing::AssertionResult gtest_ar = ::testing::AssertionSuccess()) { \
+      std::string gtest_expected_output = expected_output;                     \
+      output_redirect gtest_redir(file);                                       \
+      GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement);               \
+      std::string gtest_output = gtest_redir.restore_and_read();               \
+      if (gtest_output != gtest_expected_output) {                             \
+        gtest_ar << #statement " produces different output.\n"                 \
+                 << "Expected: " << gtest_expected_output << "\n"              \
+                 << "  Actual: " << gtest_output;                              \
+        goto GTEST_CONCAT_TOKEN_(gtest_label_testthrow_, __LINE__);            \
+      }                                                                        \
+    } else                                                                     \
+      GTEST_CONCAT_TOKEN_(gtest_label_testthrow_, __LINE__)                    \
+          : fail(gtest_ar.failure_message())
+
+// Tests that the statement writes the expected output to file.
+#  define EXPECT_WRITE(file, statement, expected_output) \
+    FMT_TEST_WRITE_(statement, expected_output, file, GTEST_NONFATAL_FAILURE_)
+
+#  ifdef _MSC_VER
+
+// Suppresses Windows assertions on invalid file descriptors, making
+// POSIX functions return proper error codes instead of crashing on Windows.
+class suppress_assert {
+ private:
+  _invalid_parameter_handler original_handler_;
+  int original_report_mode_;
+
+  static void handle_invalid_parameter(const wchar_t*, const wchar_t*,
+                                       const wchar_t*, unsigned, uintptr_t) {}
+
+ public:
+  suppress_assert()
+      : original_handler_(
+            _set_invalid_parameter_handler(handle_invalid_parameter)),
+        original_report_mode_(_CrtSetReportMode(_CRT_ASSERT, 0)) {}
+  ~suppress_assert() {
+    _set_invalid_parameter_handler(original_handler_);
+    _CrtSetReportMode(_CRT_ASSERT, original_report_mode_);
+  }
+};
+
+#    define SUPPRESS_ASSERT(statement) \
+      {                                \
+        suppress_assert sa;            \
+        statement;                     \
+      }
+#  else
+#    define SUPPRESS_ASSERT(statement) statement
+#  endif  // _MSC_VER
+
+#  define EXPECT_SYSTEM_ERROR_NOASSERT(statement, error_code, message) \
+    EXPECT_SYSTEM_ERROR(SUPPRESS_ASSERT(statement), error_code, message)
+
+// Attempts to read count characters from a file.
+std::string read(fmt::file& f, size_t count);
+
+#  define EXPECT_READ(file, expected_content) \
+    EXPECT_EQ(expected_content,               \
+              read(file, fmt::string_view(expected_content).size()))
+
+#else
+#  define EXPECT_WRITE(file, statement, expected_output) \
+    do {                                                 \
+      (void)(file);                                      \
+      (void)(statement);                                 \
+      (void)(expected_output);                           \
+      SUCCEED();                                         \
+    } while (false)
+#endif  // FMT_USE_FCNTL
+
+#endif  // FMT_GTEST_EXTRA_H_

vendor/Fmt/test/gtest/CMakeLists.txt

@@ -0,0 +1,31 @@
+#------------------------------------------------------------------------------
+# Build the google test library
+
+# We compile Google Test ourselves instead of using pre-compiled libraries.
+# See the Google Test FAQ "Why is it not recommended to install a
+# pre-compiled copy of Google Test (for example, into /usr/local)?"
+# at http://code.google.com/p/googletest/wiki/FAQ for more details.
+add_library(gtest STATIC
+  gmock-gtest-all.cc gmock/gmock.h gtest/gtest.h gtest/gtest-spi.h)
+target_compile_definitions(gtest PUBLIC GTEST_HAS_STD_WSTRING=1)
+target_include_directories(gtest SYSTEM PUBLIC .)
+
+find_package(Threads)
+if (Threads_FOUND)
+  target_link_libraries(gtest ${CMAKE_THREAD_LIBS_INIT})
+else ()
+  target_compile_definitions(gtest PUBLIC GTEST_HAS_PTHREAD=0)
+endif ()
+
+if (MSVC)
+  # Disable MSVC warnings of _CRT_INSECURE_DEPRECATE functions.
+  target_compile_definitions(gtest PRIVATE _CRT_SECURE_NO_WARNINGS)
+  if (CMAKE_CXX_COMPILER_ID MATCHES "Clang")
+    # Disable MSVC warnings of POSIX functions.
+    target_compile_options(gtest PUBLIC -Wno-deprecated-declarations)
+  endif ()
+endif ()
+
+# Silence MSVC tr1 deprecation warning in gmock.
+target_compile_definitions(gtest
+  PUBLIC _SILENCE_TR1_NAMESPACE_DEPRECATION_WARNING=1)

vendor/Fmt/test/gtest/gtest/gtest-spi.h

@@ -0,0 +1,238 @@
+// Copyright 2007, Google Inc.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * 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.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// 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.
+
+//
+// Utilities for testing Google Test itself and code that uses Google Test
+// (e.g. frameworks built on top of Google Test).
+
+// GOOGLETEST_CM0004 DO NOT DELETE
+
+#ifndef GOOGLETEST_INCLUDE_GTEST_GTEST_SPI_H_
+#define GOOGLETEST_INCLUDE_GTEST_GTEST_SPI_H_
+
+#include "gtest/gtest.h"
+
+GTEST_DISABLE_MSC_WARNINGS_PUSH_(4251 \
+/* class A needs to have dll-interface to be used by clients of class B */)
+
+namespace testing {
+
+// This helper class can be used to mock out Google Test failure reporting
+// so that we can test Google Test or code that builds on Google Test.
+//
+// An object of this class appends a TestPartResult object to the
+// TestPartResultArray object given in the constructor whenever a Google Test
+// failure is reported. It can either intercept only failures that are
+// generated in the same thread that created this object or it can intercept
+// all generated failures. The scope of this mock object can be controlled with
+// the second argument to the two arguments constructor.
+class GTEST_API_ ScopedFakeTestPartResultReporter
+    : public TestPartResultReporterInterface {
+ public:
+  // The two possible mocking modes of this object.
+  enum InterceptMode {
+    INTERCEPT_ONLY_CURRENT_THREAD,  // Intercepts only thread local failures.
+    INTERCEPT_ALL_THREADS           // Intercepts all failures.
+  };
+
+  // The c'tor sets this object as the test part result reporter used
+  // by Google Test.  The 'result' parameter specifies where to report the
+  // results. This reporter will only catch failures generated in the current
+  // thread. DEPRECATED
+  explicit ScopedFakeTestPartResultReporter(TestPartResultArray* result);
+
+  // Same as above, but you can choose the interception scope of this object.
+  ScopedFakeTestPartResultReporter(InterceptMode intercept_mode,
+                                   TestPartResultArray* result);
+
+  // The d'tor restores the previous test part result reporter.
+  ~ScopedFakeTestPartResultReporter() override;
+
+  // Appends the TestPartResult object to the TestPartResultArray
+  // received in the constructor.
+  //
+  // This method is from the TestPartResultReporterInterface
+  // interface.
+  void ReportTestPartResult(const TestPartResult& result) override;
+
+ private:
+  void Init();
+
+  const InterceptMode intercept_mode_;
+  TestPartResultReporterInterface* old_reporter_;
+  TestPartResultArray* const result_;
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(ScopedFakeTestPartResultReporter);
+};
+
+namespace internal {
+
+// A helper class for implementing EXPECT_FATAL_FAILURE() and
+// EXPECT_NONFATAL_FAILURE().  Its destructor verifies that the given
+// TestPartResultArray contains exactly one failure that has the given
+// type and contains the given substring.  If that's not the case, a
+// non-fatal failure will be generated.
+class GTEST_API_ SingleFailureChecker {
+ public:
+  // The constructor remembers the arguments.
+  SingleFailureChecker(const TestPartResultArray* results,
+                       TestPartResult::Type type, const std::string& substr);
+  ~SingleFailureChecker();
+ private:
+  const TestPartResultArray* const results_;
+  const TestPartResult::Type type_;
+  const std::string substr_;
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(SingleFailureChecker);
+};
+
+}  // namespace internal
+
+}  // namespace testing
+
+GTEST_DISABLE_MSC_WARNINGS_POP_()  //  4251
+
+// A set of macros for testing Google Test assertions or code that's expected
+// to generate Google Test fatal failures.  It verifies that the given
+// statement will cause exactly one fatal Google Test failure with 'substr'
+// being part of the failure message.
+//
+// There are two different versions of this macro. EXPECT_FATAL_FAILURE only
+// affects and considers failures generated in the current thread and
+// EXPECT_FATAL_FAILURE_ON_ALL_THREADS does the same but for all threads.
+//
+// The verification of the assertion is done correctly even when the statement
+// throws an exception or aborts the current function.
+//
+// Known restrictions:
+//   - 'statement' cannot reference local non-static variables or
+//     non-static members of the current object.
+//   - 'statement' cannot return a value.
+//   - You cannot stream a failure message to this macro.
+//
+// Note that even though the implementations of the following two
+// macros are much alike, we cannot refactor them to use a common
+// helper macro, due to some peculiarity in how the preprocessor
+// works.  The AcceptsMacroThatExpandsToUnprotectedComma test in
+// gtest_unittest.cc will fail to compile if we do that.
+#define EXPECT_FATAL_FAILURE(statement, substr) \
+  do { \
+    class GTestExpectFatalFailureHelper {\
+     public:\
+      static void Execute() { statement; }\
+    };\
+    ::testing::TestPartResultArray gtest_failures;\
+    ::testing::internal::SingleFailureChecker gtest_checker(\
+        &gtest_failures, ::testing::TestPartResult::kFatalFailure, (substr));\
+    {\
+      ::testing::ScopedFakeTestPartResultReporter gtest_reporter(\
+          ::testing::ScopedFakeTestPartResultReporter:: \
+          INTERCEPT_ONLY_CURRENT_THREAD, &gtest_failures);\
+      GTestExpectFatalFailureHelper::Execute();\
+    }\
+  } while (::testing::internal::AlwaysFalse())
+
+#define EXPECT_FATAL_FAILURE_ON_ALL_THREADS(statement, substr) \
+  do { \
+    class GTestExpectFatalFailureHelper {\
+     public:\
+      static void Execute() { statement; }\
+    };\
+    ::testing::TestPartResultArray gtest_failures;\
+    ::testing::internal::SingleFailureChecker gtest_checker(\
+        &gtest_failures, ::testing::TestPartResult::kFatalFailure, (substr));\
+    {\
+      ::testing::ScopedFakeTestPartResultReporter gtest_reporter(\
+          ::testing::ScopedFakeTestPartResultReporter:: \
+          INTERCEPT_ALL_THREADS, &gtest_failures);\
+      GTestExpectFatalFailureHelper::Execute();\
+    }\
+  } while (::testing::internal::AlwaysFalse())
+
+// A macro for testing Google Test assertions or code that's expected to
+// generate Google Test non-fatal failures.  It asserts that the given
+// statement will cause exactly one non-fatal Google Test failure with 'substr'
+// being part of the failure message.
+//
+// There are two different versions of this macro. EXPECT_NONFATAL_FAILURE only
+// affects and considers failures generated in the current thread and
+// EXPECT_NONFATAL_FAILURE_ON_ALL_THREADS does the same but for all threads.
+//
+// 'statement' is allowed to reference local variables and members of
+// the current object.
+//
+// The verification of the assertion is done correctly even when the statement
+// throws an exception or aborts the current function.
+//
+// Known restrictions:
+//   - You cannot stream a failure message to this macro.
+//
+// Note that even though the implementations of the following two
+// macros are much alike, we cannot refactor them to use a common
+// helper macro, due to some peculiarity in how the preprocessor
+// works.  If we do that, the code won't compile when the user gives
+// EXPECT_NONFATAL_FAILURE() a statement that contains a macro that
+// expands to code containing an unprotected comma.  The
+// AcceptsMacroThatExpandsToUnprotectedComma test in gtest_unittest.cc
+// catches that.
+//
+// For the same reason, we have to write
+//   if (::testing::internal::AlwaysTrue()) { statement; }
+// instead of
+//   GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement)
+// to avoid an MSVC warning on unreachable code.
+#define EXPECT_NONFATAL_FAILURE(statement, substr) \
+  do {\
+    ::testing::TestPartResultArray gtest_failures;\
+    ::testing::internal::SingleFailureChecker gtest_checker(\
+        &gtest_failures, ::testing::TestPartResult::kNonFatalFailure, \
+        (substr));\
+    {\
+      ::testing::ScopedFakeTestPartResultReporter gtest_reporter(\
+          ::testing::ScopedFakeTestPartResultReporter:: \
+          INTERCEPT_ONLY_CURRENT_THREAD, &gtest_failures);\
+      if (::testing::internal::AlwaysTrue()) { statement; }\
+    }\
+  } while (::testing::internal::AlwaysFalse())
+
+#define EXPECT_NONFATAL_FAILURE_ON_ALL_THREADS(statement, substr) \
+  do {\
+    ::testing::TestPartResultArray gtest_failures;\
+    ::testing::internal::SingleFailureChecker gtest_checker(\
+        &gtest_failures, ::testing::TestPartResult::kNonFatalFailure, \
+        (substr));\
+    {\
+      ::testing::ScopedFakeTestPartResultReporter gtest_reporter(\
+          ::testing::ScopedFakeTestPartResultReporter::INTERCEPT_ALL_THREADS, \
+          &gtest_failures);\
+      if (::testing::internal::AlwaysTrue()) { statement; }\
+    }\
+  } while (::testing::internal::AlwaysFalse())
+
+#endif  // GOOGLETEST_INCLUDE_GTEST_GTEST_SPI_H_

vendor/Fmt/test/header-only-test.cc

@@ -0,0 +1,7 @@
+// Header-only configuration test
+
+#include "fmt/core.h"
+
+#ifndef FMT_HEADER_ONLY
+#  error "Not in the header-only mode."
+#endif

vendor/Fmt/test/mock-allocator.h

@@ -0,0 +1,64 @@
+// Formatting library for C++ - mock allocator
+//
+// Copyright (c) 2012 - present, Victor Zverovich
+// All rights reserved.
+//
+// For the license information refer to format.h.
+
+#ifndef FMT_MOCK_ALLOCATOR_H_
+#define FMT_MOCK_ALLOCATOR_H_
+
+#include <assert.h>  // assert
+#include <stddef.h>  // size_t
+
+#include <memory>  // std::allocator_traits
+
+#include "gmock/gmock.h"
+
+template <typename T> class mock_allocator {
+ public:
+  mock_allocator() {}
+  mock_allocator(const mock_allocator&) {}
+  using value_type = T;
+  MOCK_METHOD1_T(allocate, T*(size_t n));
+  MOCK_METHOD2_T(deallocate, void(T* p, size_t n));
+};
+
+template <typename Allocator> class allocator_ref {
+ private:
+  Allocator* alloc_;
+
+  void move(allocator_ref& other) {
+    alloc_ = other.alloc_;
+    other.alloc_ = nullptr;
+  }
+
+ public:
+  using value_type = typename Allocator::value_type;
+
+  explicit allocator_ref(Allocator* alloc = nullptr) : alloc_(alloc) {}
+
+  allocator_ref(const allocator_ref& other) : alloc_(other.alloc_) {}
+  allocator_ref(allocator_ref&& other) { move(other); }
+
+  allocator_ref& operator=(allocator_ref&& other) {
+    assert(this != &other);
+    move(other);
+    return *this;
+  }
+
+  allocator_ref& operator=(const allocator_ref& other) {
+    alloc_ = other.alloc_;
+    return *this;
+  }
+
+ public:
+  Allocator* get() const { return alloc_; }
+
+  value_type* allocate(size_t n) {
+    return std::allocator_traits<Allocator>::allocate(*alloc_, n);
+  }
+  void deallocate(value_type* p, size_t n) { alloc_->deallocate(p, n); }
+};
+
+#endif  // FMT_MOCK_ALLOCATOR_H_

vendor/Fmt/test/module-test.cc

@@ -0,0 +1,565 @@
+// Formatting library for C++ - module tests
+//
+// Copyright (c) 2012 - present, Victor Zverovich
+// All rights reserved.
+//
+// For the license information refer to format.h.
+//
+// Copyright (c) 2021 - present, Daniela Engert
+// All Rights Reserved
+// {fmt} module.
+
+#ifdef _MSC_FULL_VER
+// hide some implementation bugs in msvc
+// that are not essential to users of the module.
+#  define FMT_HIDE_MODULE_BUGS
+#endif
+
+#include <bit>
+#include <chrono>
+#include <exception>
+#include <iterator>
+#include <locale>
+#include <memory>
+#include <ostream>
+#include <string>
+#include <string_view>
+#include <system_error>
+
+#if (__has_include(<fcntl.h>) || defined(__APPLE__) || \
+     defined(__linux__)) &&                              \
+    (!defined(WINAPI_FAMILY) || (WINAPI_FAMILY == WINAPI_FAMILY_DESKTOP_APP))
+#  include <fcntl.h>
+#  define FMT_USE_FCNTL 1
+#else
+#  define FMT_USE_FCNTL 0
+#endif
+#define FMT_NOEXCEPT noexcept
+
+import fmt;
+
+// check for macros leaking from BMI
+static bool macro_leaked =
+#if defined(FMT_CORE_H_) || defined(FMT_FORMAT_H)
+    true;
+#else
+    false;
+#endif
+
+#include "gtest-extra.h"
+
+// an implicitly exported namespace must be visible [module.interface]/2.2
+TEST(module_test, namespace) {
+  using namespace fmt;
+  using namespace fmt::literals;
+  ASSERT_TRUE(true);
+}
+
+namespace detail {
+bool oops_detail_namespace_is_visible;
+}
+
+namespace fmt {
+bool namespace_detail_invisible() {
+#if defined(FMT_HIDE_MODULE_BUGS) && defined(_MSC_FULL_VER) && \
+    _MSC_FULL_VER <= 192930129
+  // bug in msvc up to 16.11-pre1:
+  // the namespace is visible even when it is neither
+  // implicitly nor explicitly exported
+  return true;
+#else
+  using namespace detail;
+  // this fails to compile if fmt::detail is visible
+  return !oops_detail_namespace_is_visible;
+#endif
+}
+}  // namespace fmt
+
+// the non-exported namespace 'detail' must be invisible [module.interface]/2
+TEST(module_test, detail_namespace) {
+  EXPECT_TRUE(fmt::namespace_detail_invisible());
+}
+
+// macros must not be imported from a *named* module  [cpp.import]/5.1
+TEST(module_test, macros) {
+#if defined(FMT_HIDE_MODULE_BUGS) && defined(_MSC_FULL_VER) && \
+    _MSC_FULL_VER <= 192930129
+  // bug in msvc up to 16.11-pre1:
+  // include-guard macros leak from BMI
+  // and even worse: they cannot be #undef-ined
+  macro_leaked = false;
+#endif
+  EXPECT_FALSE(macro_leaked);
+}
+
+// The following is less about functional testing (that's done elsewhere)
+// but rather visibility of all client-facing overloads, reachability of
+// non-exported entities, name lookup and overload resolution within
+// template instantitions.
+// Excercise all exported entities of the API at least once.
+// Instantiate as many code paths as possible.
+
+TEST(module_test, to_string) {
+  EXPECT_EQ("42", fmt::to_string(42));
+  EXPECT_EQ("42", fmt::to_string(42.0));
+
+  EXPECT_EQ(L"42", fmt::to_wstring(42));
+  EXPECT_EQ(L"42", fmt::to_wstring(42.0));
+}
+
+TEST(module_test, format) {
+  EXPECT_EQ("42", fmt::format("{:}", 42));
+  EXPECT_EQ("-42", fmt::format("{0}", -42.0));
+
+  EXPECT_EQ(L"42", fmt::format(L"{:}", 42));
+  EXPECT_EQ(L"-42", fmt::format(L"{0}", -42.0));
+}
+
+TEST(module_test, format_to) {
+  std::string s;
+  fmt::format_to(std::back_inserter(s), "{}", 42);
+  EXPECT_EQ("42", s);
+
+  char buffer[4] = {0};
+  fmt::format_to(buffer, "{}", 42);
+  EXPECT_EQ("42", std::string_view(buffer));
+
+  fmt::memory_buffer mb;
+  fmt::format_to(mb, "{}", 42);
+  EXPECT_EQ("42", std::string_view(buffer));
+
+  std::wstring w;
+  fmt::format_to(std::back_inserter(w), L"{}", 42);
+  EXPECT_EQ(L"42", w);
+
+  wchar_t wbuffer[4] = {0};
+  fmt::format_to(wbuffer, L"{}", 42);
+  EXPECT_EQ(L"42", std::wstring_view(wbuffer));
+
+  fmt::wmemory_buffer wb;
+  fmt::format_to(wb, L"{}", 42);
+  EXPECT_EQ(L"42", std::wstring_view(wbuffer));
+}
+
+TEST(module_test, formatted_size) {
+  EXPECT_EQ(2u, fmt::formatted_size("{}", 42));
+  EXPECT_EQ(2u, fmt::formatted_size(L"{}", 42));
+}
+
+TEST(module_test, format_to_n) {
+  std::string s;
+  auto result = fmt::format_to_n(std::back_inserter(s), 1, "{}", 42);
+  EXPECT_EQ(2u, result.size);
+  char buffer[4] = {0};
+  fmt::format_to_n(buffer, 3, "{}", 12345);
+
+  std::wstring w;
+  auto wresult = fmt::format_to_n(std::back_inserter(w), 1, L"{}", 42);
+  EXPECT_EQ(2u, wresult.size);
+  wchar_t wbuffer[4] = {0};
+  fmt::format_to_n(wbuffer, 3, L"{}", 12345);
+}
+
+TEST(module_test, format_args) {
+  auto no_args = fmt::format_args();
+  EXPECT_FALSE(no_args.get(1));
+
+  fmt::basic_format_args args = fmt::make_format_args(42);
+  EXPECT_TRUE(args.max_size() > 0);
+  auto arg0 = args.get(0);
+  EXPECT_TRUE(arg0);
+  decltype(arg0) arg_none;
+  EXPECT_FALSE(arg_none);
+  EXPECT_TRUE(arg0.type() != arg_none.type());
+}
+
+TEST(module_test, wformat_args) {
+  auto no_args = fmt::wformat_args();
+  EXPECT_FALSE(no_args.get(1));
+  fmt::basic_format_args args = fmt::make_wformat_args(42);
+  EXPECT_TRUE(args.get(0));
+}
+
+TEST(module_test, checked_format_args) {
+  fmt::basic_format_args args = fmt::make_args_checked<int>("{}", 42);
+  EXPECT_TRUE(args.get(0));
+  fmt::basic_format_args wargs = fmt::make_args_checked<int>(L"{}", 42);
+  EXPECT_TRUE(wargs.get(0));
+}
+
+TEST(module_test, dynamic_format_args) {
+  fmt::dynamic_format_arg_store<fmt::format_context> dyn_store;
+  dyn_store.push_back(fmt::arg("a42", 42));
+  fmt::basic_format_args args = dyn_store;
+  EXPECT_FALSE(args.get(3));
+  EXPECT_TRUE(args.get(fmt::string_view("a42")));
+
+  fmt::dynamic_format_arg_store<fmt::wformat_context> wdyn_store;
+  wdyn_store.push_back(fmt::arg(L"a42", 42));
+  fmt::basic_format_args wargs = wdyn_store;
+  EXPECT_FALSE(wargs.get(3));
+  EXPECT_TRUE(wargs.get(fmt::wstring_view(L"a42")));
+}
+
+TEST(module_test, vformat) {
+  EXPECT_EQ("42", fmt::vformat("{}", fmt::make_format_args(42)));
+  EXPECT_EQ(L"42", fmt::vformat(fmt::to_string_view(L"{}"),
+                                fmt::make_wformat_args(42)));
+}
+
+TEST(module_test, vformat_to) {
+  auto store = fmt::make_format_args(42);
+  std::string s;
+  fmt::vformat_to(std::back_inserter(s), "{}", store);
+  EXPECT_EQ("42", s);
+
+  char buffer[4] = {0};
+  fmt::vformat_to(buffer, "{:}", store);
+  EXPECT_EQ("42", std::string_view(buffer));
+
+  auto wstore = fmt::make_wformat_args(42);
+  std::wstring w;
+  fmt::vformat_to(std::back_inserter(w), L"{}", wstore);
+  EXPECT_EQ(L"42", w);
+
+  wchar_t wbuffer[4] = {0};
+  fmt::vformat_to(wbuffer, L"{:}", wstore);
+  EXPECT_EQ(L"42", std::wstring_view(wbuffer));
+}
+
+TEST(module_test, vformat_to_n) {
+  auto store = fmt::make_format_args(12345);
+  std::string s;
+  auto result = fmt::vformat_to_n(std::back_inserter(s), 1, "{}", store);
+  char buffer[4] = {0};
+  fmt::vformat_to_n(buffer, 3, "{:}", store);
+
+  auto wstore = fmt::make_wformat_args(12345);
+  std::wstring w;
+  auto wresult = fmt::vformat_to_n(std::back_inserter(w), 1,
+                                   fmt::to_string_view(L"{}"), wstore);
+  wchar_t wbuffer[4] = {0};
+  fmt::vformat_to_n(wbuffer, 3, fmt::to_string_view(L"{:}"), wstore);
+}
+
+std::string as_string(std::wstring_view text) {
+  return {reinterpret_cast<const char*>(text.data()),
+          text.size() * sizeof(text[0])};
+}
+
+TEST(module_test, print) {
+  EXPECT_WRITE(stdout, fmt::print("{}µ", 42), "42µ");
+  EXPECT_WRITE(stderr, fmt::print(stderr, "{}µ", 4.2), "4.2µ");
+  if (false) {
+    EXPECT_WRITE(stdout, fmt::print(L"{}µ", 42), as_string(L"42µ"));
+    EXPECT_WRITE(stderr, fmt::print(stderr, L"{}µ", 4.2), as_string(L"4.2µ"));
+  }
+}
+
+TEST(module_test, vprint) {
+  EXPECT_WRITE(stdout, fmt::vprint("{:}µ", fmt::make_format_args(42)), "42µ");
+  EXPECT_WRITE(stderr, fmt::vprint(stderr, "{}", fmt::make_format_args(4.2)),
+               "4.2");
+  if (false) {
+    EXPECT_WRITE(stdout, fmt::vprint(L"{:}µ", fmt::make_wformat_args(42)),
+                 as_string(L"42µ"));
+    EXPECT_WRITE(stderr, fmt::vprint(stderr, L"{}", fmt::make_wformat_args(42)),
+                 as_string(L"42"));
+  }
+}
+
+TEST(module_test, named_args) {
+  EXPECT_EQ("42", fmt::format("{answer}", fmt::arg("answer", 42)));
+  EXPECT_EQ(L"42", fmt::format(L"{answer}", fmt::arg(L"answer", 42)));
+}
+
+TEST(module_test, literals) {
+  using namespace fmt::literals;
+  EXPECT_EQ("42", fmt::format("{answer}", "answer"_a = 42));
+  EXPECT_EQ("42", "{}"_format(42));
+  EXPECT_EQ(L"42", fmt::format(L"{answer}", L"answer"_a = 42));
+  EXPECT_EQ(L"42", L"{}"_format(42));
+}
+
+TEST(module_test, locale) {
+  auto store = fmt::make_format_args(4.2);
+  const auto classic = std::locale::classic();
+  EXPECT_EQ("4.2", fmt::format(classic, "{:L}", 4.2));
+  EXPECT_EQ("4.2", fmt::vformat(classic, "{:L}", store));
+  std::string s;
+  fmt::vformat_to(std::back_inserter(s), classic, "{:L}", store);
+  EXPECT_EQ("4.2", s);
+  EXPECT_EQ("4.2", fmt::format("{:L}", 4.2));
+
+  auto wstore = fmt::make_wformat_args(4.2);
+  EXPECT_EQ(L"4.2", fmt::format(classic, L"{:L}", 4.2));
+  EXPECT_EQ(L"4.2", fmt::vformat(classic, L"{:L}", wstore));
+  std::wstring w;
+  fmt::vformat_to(std::back_inserter(w), classic, L"{:L}", wstore);
+  EXPECT_EQ(L"4.2", w);
+  EXPECT_EQ(L"4.2", fmt::format(L"{:L}", 4.2));
+}
+
+TEST(module_test, string_view) {
+  fmt::string_view nsv("fmt");
+  EXPECT_EQ("fmt", nsv);
+  EXPECT_TRUE(fmt::string_view("fmt") == nsv);
+
+  fmt::wstring_view wsv(L"fmt");
+  EXPECT_EQ(L"fmt", wsv);
+  EXPECT_TRUE(fmt::wstring_view(L"fmt") == wsv);
+}
+
+TEST(module_test, memory_buffer) {
+  fmt::basic_memory_buffer<char, fmt::inline_buffer_size> buffer;
+  fmt::format_to(buffer, "{}", "42");
+  EXPECT_EQ("42", to_string(buffer));
+  fmt::memory_buffer nbuffer(std::move(buffer));
+  EXPECT_EQ("42", to_string(nbuffer));
+  buffer = std::move(nbuffer);
+  EXPECT_EQ("42", to_string(buffer));
+  nbuffer.clear();
+  EXPECT_EQ(0u, to_string(nbuffer).size());
+
+  fmt::wmemory_buffer wbuffer;
+  EXPECT_EQ(0u, to_string(wbuffer).size());
+}
+
+TEST(module_test, is_char) {
+  EXPECT_TRUE(fmt::is_char<char>());
+  EXPECT_TRUE(fmt::is_char<wchar_t>());
+  EXPECT_TRUE(fmt::is_char<char8_t>());
+  EXPECT_TRUE(fmt::is_char<char16_t>());
+  EXPECT_TRUE(fmt::is_char<char32_t>());
+  EXPECT_FALSE(fmt::is_char<signed char>());
+}
+
+TEST(module_test, ptr) {
+  uintptr_t answer = 42;
+  auto p = std::bit_cast<int*>(answer);
+  EXPECT_EQ("0x2a", fmt::to_string(fmt::ptr(p)));
+  std::unique_ptr<int> up(p);
+  EXPECT_EQ("0x2a", fmt::to_string(fmt::ptr(up)));
+  up.release();
+  auto sp = std::make_shared<int>(0);
+  p = sp.get();
+  EXPECT_EQ(fmt::to_string(fmt::ptr(p)), fmt::to_string(fmt::ptr(sp)));
+}
+
+TEST(module_test, errors) {
+  auto store = fmt::make_format_args(42);
+  EXPECT_THROW(throw fmt::format_error("oops"), std::exception);
+  EXPECT_THROW(throw fmt::vsystem_error(0, "{}", store), std::system_error);
+  EXPECT_THROW(throw fmt::system_error(0, "{}", 42), std::system_error);
+
+  fmt::memory_buffer buffer;
+  fmt::format_system_error(buffer, 0, "oops");
+  auto oops = to_string(buffer);
+  EXPECT_TRUE(oops.size() > 0);
+  EXPECT_WRITE(stderr, fmt::report_system_error(0, "oops"), oops + '\n');
+
+#ifdef _WIN32
+  EXPECT_THROW(throw fmt::vwindows_error(0, "{}", store), std::system_error);
+  EXPECT_THROW(throw fmt::windows_error(0, "{}", 42), std::system_error);
+  output_redirect redirect(stderr);
+  fmt::report_windows_error(0, "oops");
+  EXPECT_TRUE(redirect.restore_and_read().size() > 0);
+#endif
+}
+
+TEST(module_test, error_code) {
+  EXPECT_EQ("generic:42",
+            fmt::format("{0}", std::error_code(42, std::generic_category())));
+  EXPECT_EQ("system:42",
+            fmt::format("{0}", std::error_code(42, fmt::system_category())));
+  EXPECT_EQ(L"generic:42",
+            fmt::format(L"{0}", std::error_code(42, std::generic_category())));
+}
+
+TEST(module_test, format_int) {
+  fmt::format_int sanswer(42);
+  EXPECT_EQ("42", fmt::string_view(sanswer.data(), sanswer.size()));
+  fmt::format_int uanswer(42u);
+  EXPECT_EQ("42", fmt::string_view(uanswer.data(), uanswer.size()));
+}
+
+struct test_formatter : fmt::formatter<char> {
+  bool check() { return true; }
+};
+
+struct test_dynamic_formatter : fmt::dynamic_formatter<> {
+  bool check() { return true; }
+};
+
+TEST(module_test, formatter) {
+  EXPECT_TRUE(test_formatter{}.check());
+  EXPECT_TRUE(test_dynamic_formatter{}.check());
+}
+
+TEST(module_test, join) {
+  int arr[3] = {1, 2, 3};
+  std::vector<double> vec{1.0, 2.0, 3.0};
+  std::initializer_list<int> il{1, 2, 3};
+  auto sep = fmt::to_string_view(", ");
+  EXPECT_EQ("1, 2, 3", to_string(fmt::join(arr + 0, arr + 3, sep)));
+  EXPECT_EQ("1, 2, 3", to_string(fmt::join(arr, sep)));
+  EXPECT_EQ("1, 2, 3", to_string(fmt::join(vec.begin(), vec.end(), sep)));
+  EXPECT_EQ("1, 2, 3", to_string(fmt::join(vec, sep)));
+  EXPECT_EQ("1, 2, 3", to_string(fmt::join(il, sep)));
+
+  auto wsep = fmt::to_string_view(L", ");
+  EXPECT_EQ(L"1, 2, 3", fmt::format(L"{}", fmt::join(arr + 0, arr + 3, wsep)));
+  EXPECT_EQ(L"1, 2, 3", fmt::format(L"{}", fmt::join(arr, wsep)));
+  EXPECT_EQ(L"1, 2, 3", fmt::format(L"{}", fmt::join(il, wsep)));
+}
+
+TEST(module_test, time) {
+  auto time_now = std::time(nullptr);
+  EXPECT_TRUE(fmt::localtime(time_now).tm_year > 120);
+  EXPECT_TRUE(fmt::gmtime(time_now).tm_year > 120);
+  auto chrono_now = std::chrono::system_clock::now();
+  EXPECT_TRUE(fmt::localtime(chrono_now).tm_year > 120);
+  EXPECT_TRUE(fmt::gmtime(chrono_now).tm_year > 120);
+}
+
+TEST(module_test, time_point) {
+  auto now = std::chrono::system_clock::now();
+  std::string_view past("2021-05-20 10:30:15");
+  EXPECT_TRUE(past < fmt::format("{:%Y-%m-%d %H:%M:%S}", now));
+  std::wstring_view wpast(L"2021-05-20 10:30:15");
+  EXPECT_TRUE(wpast < fmt::format(L"{:%Y-%m-%d %H:%M:%S}", now));
+}
+
+TEST(module_test, time_duration) {
+  using us = std::chrono::duration<double, std::micro>;
+  EXPECT_EQ("42s", fmt::format("{}", std::chrono::seconds{42}));
+  EXPECT_EQ("4.2µs", fmt::format("{:3.1}", us{4.234}));
+  EXPECT_EQ("4.2µs", fmt::format(std::locale::classic(), "{:L}", us{4.2}));
+
+  EXPECT_EQ(L"42s", fmt::format(L"{}", std::chrono::seconds{42}));
+  EXPECT_EQ(L"4.2µs", fmt::format(L"{:3.1}", us{4.234}));
+  EXPECT_EQ(L"4.2µs", fmt::format(std::locale::classic(), L"{:L}", us{4.2}));
+}
+
+TEST(module_test, weekday) {
+  EXPECT_EQ("Monday",
+            std::format(std::locale::classic(), "{:%A}", fmt::weekday(1)));
+}
+
+TEST(module_test, to_string_view) {
+  using fmt::to_string_view;
+  fmt::string_view nsv{to_string_view("42")};
+  EXPECT_EQ("42", nsv);
+  fmt::wstring_view wsv{to_string_view(L"42")};
+  EXPECT_EQ(L"42", wsv);
+}
+
+TEST(module_test, printf) {
+  EXPECT_WRITE(stdout, fmt::printf("%f", 42.123456), "42.123456");
+  EXPECT_WRITE(stdout, fmt::printf("%d", 42), "42");
+  if (false) {
+    EXPECT_WRITE(stdout, fmt::printf(L"%f", 42.123456),
+                 as_string(L"42.123456"));
+    EXPECT_WRITE(stdout, fmt::printf(L"%d", 42), as_string(L"42"));
+  }
+}
+
+TEST(module_test, fprintf) {
+  EXPECT_WRITE(stderr, fmt::fprintf(stderr, "%d", 42), "42");
+  std::ostringstream os;
+  fmt::fprintf(os, "%s", "bla");
+  EXPECT_EQ("bla", os.str());
+
+  EXPECT_WRITE(stderr, fmt::fprintf(stderr, L"%d", 42), as_string(L"42"));
+  std::wostringstream ws;
+  fmt::fprintf(ws, L"%s", L"bla");
+  EXPECT_EQ(L"bla", ws.str());
+}
+
+TEST(module_test, sprintf) {
+  EXPECT_EQ("42", fmt::sprintf("%d", 42));
+  EXPECT_EQ(L"42", fmt::sprintf(L"%d", 42));
+}
+
+TEST(module_test, vprintf) {
+  EXPECT_WRITE(stdout, fmt::vprintf("%d", fmt::make_printf_args(42)), "42");
+  if (false) {
+    EXPECT_WRITE(stdout, fmt::vprintf(L"%d", fmt::make_wprintf_args(42)),
+                 as_string(L"42"));
+  }
+}
+
+TEST(module_test, vfprintf) {
+  auto args = fmt::make_printf_args(42);
+  EXPECT_WRITE(stderr, fmt::vfprintf(stderr, "%d", args), "42");
+  std::ostringstream os;
+  fmt::vfprintf(os, "%d", args);
+  EXPECT_EQ("42", os.str());
+  auto wargs = fmt::make_wprintf_args(42);
+  if (false) {
+    EXPECT_WRITE(stderr, fmt::vfprintf(stderr, L"%d", wargs), as_string(L"42"));
+  }
+  std::wostringstream ws;
+  fmt::vfprintf(ws, L"%d", wargs);
+  EXPECT_EQ(L"42", ws.str());
+}
+
+TEST(module_test, vsprintf) {
+  EXPECT_EQ("42", fmt::vsprintf("%d", fmt::make_printf_args(42)));
+  EXPECT_EQ(L"42", fmt::vsprintf(L"%d", fmt::make_wprintf_args(42)));
+}
+
+TEST(module_test, color) {
+  auto fg_check = fg(fmt::rgb(255, 200, 30));
+  auto bg_check = bg(fmt::color::dark_slate_gray) | fmt::emphasis::italic;
+  auto emphasis_check = fmt::emphasis::underline | fmt::emphasis::bold;
+  EXPECT_EQ("\x1B[30m42\x1B[0m",
+            fmt::format(fg(fmt::terminal_color::black), "{}", 42));
+  EXPECT_EQ(L"\x1B[30m42\x1B[0m",
+            fmt::format(fg(fmt::terminal_color::black), L"{}", 42));
+}
+
+TEST(module_test, cstring_view) {
+  auto s = "fmt";
+  EXPECT_EQ(s, fmt::cstring_view(s).c_str());
+  auto w = L"fmt";
+  EXPECT_EQ(w, fmt::wcstring_view(w).c_str());
+}
+
+TEST(module_test, buffered_file) {
+  EXPECT_TRUE(fmt::buffered_file{}.get() == nullptr);
+}
+
+TEST(module_test, output_file) {
+  fmt::ostream out = fmt::output_file("module-test", fmt::buffer_size = 1);
+  out.close();
+}
+
+struct custom_context {
+  using char_type = char;
+  using parse_context_type = fmt::format_parse_context;
+};
+
+TEST(module_test, custom_context) {
+  fmt::basic_format_arg<custom_context> custom_arg;
+  EXPECT_TRUE(!custom_arg);
+}
+
+struct disabled_formatter {};
+
+TEST(module_test, has_formatter) {
+  EXPECT_FALSE(
+      (fmt::has_formatter<disabled_formatter, fmt::format_context>::value));
+}
+
+TEST(module_test, is_formattable) {
+  EXPECT_FALSE(fmt::is_formattable<disabled_formatter>::value);
+}
+
+TEST(module_test, compile_format_string) {
+  using namespace fmt::literals;
+  EXPECT_EQ("42", fmt::format("{0:x}"_cf, 0x42));
+  EXPECT_EQ(L"42", fmt::format(L"{:}"_cf, 42));
+  EXPECT_EQ("4.2", fmt::format("{arg:3.1f}"_cf, "arg"_a = 4.2));
+  EXPECT_EQ(L" 42", fmt::format(L"{arg:>3}"_cf, L"arg"_a = L"42"));
+}

vendor/Fmt/test/os-test.cc

@@ -0,0 +1,552 @@
+// Formatting library for C++ - tests of the OS-specific functionality
+//
+// Copyright (c) 2012 - present, Victor Zverovich
+// All rights reserved.
+//
+// For the license information refer to format.h.
+
+#include "fmt/os.h"
+
+#include <cstdlib>  // std::exit
+#include <cstring>
+#include <memory>
+
+#include "gtest-extra.h"
+#include "util.h"
+
+#ifdef fileno
+#  undef fileno
+#endif
+
+using fmt::buffered_file;
+using testing::HasSubstr;
+using wstring_view = fmt::basic_string_view<wchar_t>;
+
+#ifdef _WIN32
+
+#  include <windows.h>
+
+TEST(util_test, utf16_to_utf8) {
+  auto s = std::string("ёжик");
+  fmt::detail::utf16_to_utf8 u(L"\x0451\x0436\x0438\x043A");
+  EXPECT_EQ(s, u.str());
+  EXPECT_EQ(s.size(), u.size());
+}
+
+TEST(util_test, utf16_to_utf8_empty_string) {
+  std::string s = "";
+  fmt::detail::utf16_to_utf8 u(L"");
+  EXPECT_EQ(s, u.str());
+  EXPECT_EQ(s.size(), u.size());
+}
+
+template <typename Converter, typename Char>
+void check_utf_conversion_error(
+    const char* message,
+    fmt::basic_string_view<Char> str = fmt::basic_string_view<Char>(0, 1)) {
+  fmt::memory_buffer out;
+  fmt::detail::format_windows_error(out, ERROR_INVALID_PARAMETER, message);
+  auto error = std::system_error(std::error_code());
+  try {
+    (Converter)(str);
+  } catch (const std::system_error& e) {
+    error = e;
+  }
+  EXPECT_EQ(ERROR_INVALID_PARAMETER, error.code().value());
+  EXPECT_THAT(error.what(), HasSubstr(fmt::to_string(out)));
+}
+
+TEST(util_test, utf16_to_utf8_error) {
+  check_utf_conversion_error<fmt::detail::utf16_to_utf8, wchar_t>(
+      "cannot convert string from UTF-16 to UTF-8");
+}
+
+TEST(util_test, utf16_to_utf8_convert) {
+  fmt::detail::utf16_to_utf8 u;
+  EXPECT_EQ(ERROR_INVALID_PARAMETER, u.convert(wstring_view(0, 1)));
+  EXPECT_EQ(ERROR_INVALID_PARAMETER,
+            u.convert(wstring_view(L"foo", INT_MAX + 1u)));
+}
+
+TEST(os_test, format_std_error_code) {
+  EXPECT_EQ("generic:42",
+            fmt::format(FMT_STRING("{0}"),
+                        std::error_code(42, std::generic_category())));
+  EXPECT_EQ("system:42",
+            fmt::format(FMT_STRING("{0}"),
+                        std::error_code(42, fmt::system_category())));
+  EXPECT_EQ("system:-42",
+            fmt::format(FMT_STRING("{0}"),
+                        std::error_code(-42, fmt::system_category())));
+}
+
+TEST(os_test, format_windows_error) {
+  LPWSTR message = 0;
+  auto result = FormatMessageW(
+      FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM |
+          FORMAT_MESSAGE_IGNORE_INSERTS,
+      0, ERROR_FILE_EXISTS, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
+      reinterpret_cast<LPWSTR>(&message), 0, 0);
+  fmt::detail::utf16_to_utf8 utf8_message(wstring_view(message, result - 2));
+  LocalFree(message);
+  fmt::memory_buffer actual_message;
+  fmt::detail::format_windows_error(actual_message, ERROR_FILE_EXISTS, "test");
+  EXPECT_EQ(fmt::format("test: {}", utf8_message.str()),
+            fmt::to_string(actual_message));
+  actual_message.resize(0);
+}
+
+TEST(os_test, format_long_windows_error) {
+  LPWSTR message = 0;
+  // this error code is not available on all Windows platforms and
+  // Windows SDKs, so do not fail the test if the error string cannot
+  // be retrieved.
+  int provisioning_not_allowed = 0x80284013L;  // TBS_E_PROVISIONING_NOT_ALLOWED
+  auto result = FormatMessageW(FORMAT_MESSAGE_ALLOCATE_BUFFER |
+                                   FORMAT_MESSAGE_FROM_SYSTEM |
+                                   FORMAT_MESSAGE_IGNORE_INSERTS,
+                               0, static_cast<DWORD>(provisioning_not_allowed),
+                               MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
+                               reinterpret_cast<LPWSTR>(&message), 0, 0);
+  if (result == 0) {
+    LocalFree(message);
+    return;
+  }
+  fmt::detail::utf16_to_utf8 utf8_message(wstring_view(message, result - 2));
+  LocalFree(message);
+  fmt::memory_buffer actual_message;
+  fmt::detail::format_windows_error(actual_message, provisioning_not_allowed,
+                                    "test");
+  EXPECT_EQ(fmt::format("test: {}", utf8_message.str()),
+            fmt::to_string(actual_message));
+}
+
+TEST(os_test, windows_error) {
+  auto error = std::system_error(std::error_code());
+  try {
+    throw fmt::windows_error(ERROR_FILE_EXISTS, "test {}", "error");
+  } catch (const std::system_error& e) {
+    error = e;
+  }
+  fmt::memory_buffer message;
+  fmt::detail::format_windows_error(message, ERROR_FILE_EXISTS, "test error");
+  EXPECT_THAT(error.what(), HasSubstr(to_string(message)));
+  EXPECT_EQ(ERROR_FILE_EXISTS, error.code().value());
+}
+
+TEST(os_test, report_windows_error) {
+  fmt::memory_buffer out;
+  fmt::detail::format_windows_error(out, ERROR_FILE_EXISTS, "test error");
+  out.push_back('\n');
+  EXPECT_WRITE(stderr,
+               fmt::report_windows_error(ERROR_FILE_EXISTS, "test error"),
+               fmt::to_string(out));
+}
+
+#endif  // _WIN32
+
+#if FMT_USE_FCNTL
+
+using fmt::file;
+
+bool isclosed(int fd) {
+  char buffer;
+  auto result = std::streamsize();
+  SUPPRESS_ASSERT(result = FMT_POSIX(read(fd, &buffer, 1)));
+  return result == -1 && errno == EBADF;
+}
+
+// Opens a file for reading.
+file open_file() {
+  file read_end, write_end;
+  file::pipe(read_end, write_end);
+  write_end.write(file_content, std::strlen(file_content));
+  write_end.close();
+  return read_end;
+}
+
+// Attempts to write a string to a file.
+void write(file& f, fmt::string_view s) {
+  size_t num_chars_left = s.size();
+  const char* ptr = s.data();
+  do {
+    size_t count = f.write(ptr, num_chars_left);
+    ptr += count;
+    // We can't write more than size_t bytes since num_chars_left
+    // has type size_t.
+    num_chars_left -= count;
+  } while (num_chars_left != 0);
+}
+
+TEST(buffered_file_test, default_ctor) {
+  auto f = buffered_file();
+  EXPECT_TRUE(f.get() == nullptr);
+}
+
+TEST(buffered_file_test, move_ctor) {
+  buffered_file bf = open_buffered_file();
+  FILE* fp = bf.get();
+  EXPECT_TRUE(fp != nullptr);
+  buffered_file bf2(std::move(bf));
+  EXPECT_EQ(fp, bf2.get());
+  EXPECT_TRUE(bf.get() == nullptr);
+}
+
+TEST(buffered_file_test, move_assignment) {
+  buffered_file bf = open_buffered_file();
+  FILE* fp = bf.get();
+  EXPECT_TRUE(fp != nullptr);
+  buffered_file bf2;
+  bf2 = std::move(bf);
+  EXPECT_EQ(fp, bf2.get());
+  EXPECT_TRUE(bf.get() == nullptr);
+}
+
+TEST(buffered_file_test, move_assignment_closes_file) {
+  buffered_file bf = open_buffered_file();
+  buffered_file bf2 = open_buffered_file();
+  int old_fd = bf2.fileno();
+  bf2 = std::move(bf);
+  EXPECT_TRUE(isclosed(old_fd));
+}
+
+TEST(buffered_file_test, move_from_temporary_in_ctor) {
+  FILE* fp = nullptr;
+  buffered_file f = open_buffered_file(&fp);
+  EXPECT_EQ(fp, f.get());
+}
+
+TEST(buffered_file_test, move_from_temporary_in_assignment) {
+  FILE* fp = nullptr;
+  auto f = buffered_file();
+  f = open_buffered_file(&fp);
+  EXPECT_EQ(fp, f.get());
+}
+
+TEST(buffered_file_test, move_from_temporary_in_assignment_closes_file) {
+  buffered_file f = open_buffered_file();
+  int old_fd = f.fileno();
+  f = open_buffered_file();
+  EXPECT_TRUE(isclosed(old_fd));
+}
+
+TEST(buffered_file_test, close_file_in_dtor) {
+  int fd = 0;
+  {
+    buffered_file f = open_buffered_file();
+    fd = f.fileno();
+  }
+  EXPECT_TRUE(isclosed(fd));
+}
+
+TEST(buffered_file_test, close_error_in_dtor) {
+  auto f =
+      std::unique_ptr<buffered_file>(new buffered_file(open_buffered_file()));
+  EXPECT_WRITE(
+      stderr,
+      {
+        // The close function must be called inside EXPECT_WRITE,
+        // otherwise the system may recycle closed file descriptor when
+        // redirecting the output in EXPECT_STDERR and the second close
+        // will break output redirection.
+        FMT_POSIX(close(f->fileno()));
+        SUPPRESS_ASSERT(f.reset(nullptr));
+      },
+      system_error_message(EBADF, "cannot close file") + "\n");
+}
+
+TEST(buffered_file_test, close) {
+  buffered_file f = open_buffered_file();
+  int fd = f.fileno();
+  f.close();
+  EXPECT_TRUE(f.get() == nullptr);
+  EXPECT_TRUE(isclosed(fd));
+}
+
+TEST(buffered_file_test, close_error) {
+  buffered_file f = open_buffered_file();
+  FMT_POSIX(close(f.fileno()));
+  EXPECT_SYSTEM_ERROR_NOASSERT(f.close(), EBADF, "cannot close file");
+  EXPECT_TRUE(f.get() == nullptr);
+}
+
+TEST(buffered_file_test, fileno) {
+  auto f = open_buffered_file();
+  EXPECT_TRUE(f.fileno() != -1);
+  file copy = file::dup(f.fileno());
+  EXPECT_READ(copy, file_content);
+}
+
+TEST(ostream_test, move) {
+  fmt::ostream out = fmt::output_file("test-file");
+  fmt::ostream moved(std::move(out));
+  moved.print("hello");
+}
+
+TEST(ostream_test, move_while_holding_data) {
+  {
+    fmt::ostream out = fmt::output_file("test-file");
+    out.print("Hello, ");
+    fmt::ostream moved(std::move(out));
+    moved.print("world!\n");
+  }
+  {
+    file in("test-file", file::RDONLY);
+    EXPECT_READ(in, "Hello, world!\n");
+  }
+}
+
+TEST(ostream_test, print) {
+  fmt::ostream out = fmt::output_file("test-file");
+  out.print("The answer is {}.\n",
+            fmt::join(std::initializer_list<int>{42}, ", "));
+  out.close();
+  file in("test-file", file::RDONLY);
+  EXPECT_READ(in, "The answer is 42.\n");
+}
+
+TEST(ostream_test, buffer_boundary) {
+  auto str = std::string(4096, 'x');
+  fmt::ostream out = fmt::output_file("test-file");
+  out.print("{}", str);
+  out.print("{}", str);
+  out.close();
+  file in("test-file", file::RDONLY);
+  EXPECT_READ(in, str + str);
+}
+
+TEST(ostream_test, buffer_size) {
+  fmt::ostream out = fmt::output_file("test-file", fmt::buffer_size = 1);
+  out.print("{}", "foo");
+  out.close();
+  file in("test-file", file::RDONLY);
+  EXPECT_READ(in, "foo");
+}
+
+TEST(ostream_test, truncate) {
+  {
+    fmt::ostream out = fmt::output_file("test-file");
+    out.print("0123456789");
+  }
+  {
+    fmt::ostream out = fmt::output_file("test-file");
+    out.print("foo");
+  }
+  file in("test-file", file::RDONLY);
+  EXPECT_EQ("foo", read(in, 4));
+}
+
+TEST(file_test, default_ctor) {
+  file f;
+  EXPECT_EQ(-1, f.descriptor());
+}
+
+TEST(file_test, open_buffered_file_in_ctor) {
+  FILE* fp = safe_fopen("test-file", "w");
+  std::fputs(file_content, fp);
+  std::fclose(fp);
+  file f("test-file", file::RDONLY);
+  // Check if the file is open by reading one character from it.
+  char buffer;
+  bool isopen = FMT_POSIX(read(f.descriptor(), &buffer, 1)) == 1;
+  ASSERT_TRUE(isopen);
+}
+
+TEST(file_test, open_buffered_file_error) {
+  EXPECT_SYSTEM_ERROR(file("nonexistent", file::RDONLY), ENOENT,
+                      "cannot open file nonexistent");
+}
+
+TEST(file_test, move_ctor) {
+  file f = open_file();
+  int fd = f.descriptor();
+  EXPECT_NE(-1, fd);
+  file f2(std::move(f));
+  EXPECT_EQ(fd, f2.descriptor());
+  EXPECT_EQ(-1, f.descriptor());
+}
+
+TEST(file_test, move_assignment) {
+  file f = open_file();
+  int fd = f.descriptor();
+  EXPECT_NE(-1, fd);
+  file f2;
+  f2 = std::move(f);
+  EXPECT_EQ(fd, f2.descriptor());
+  EXPECT_EQ(-1, f.descriptor());
+}
+
+TEST(file_test, move_assignment_closes_file) {
+  file f = open_file();
+  file f2 = open_file();
+  int old_fd = f2.descriptor();
+  f2 = std::move(f);
+  EXPECT_TRUE(isclosed(old_fd));
+}
+
+file open_buffered_file(int& fd) {
+  file f = open_file();
+  fd = f.descriptor();
+  return f;
+}
+
+TEST(file_test, move_from_temporary_in_ctor) {
+  int fd = 0xdead;
+  file f(open_buffered_file(fd));
+  EXPECT_EQ(fd, f.descriptor());
+}
+
+TEST(file_test, move_from_temporary_in_assignment) {
+  int fd = 0xdead;
+  file f;
+  f = open_buffered_file(fd);
+  EXPECT_EQ(fd, f.descriptor());
+}
+
+TEST(file_test, move_from_temporary_in_assignment_closes_file) {
+  int fd = 0xdead;
+  file f = open_file();
+  int old_fd = f.descriptor();
+  f = open_buffered_file(fd);
+  EXPECT_TRUE(isclosed(old_fd));
+}
+
+TEST(file_test, close_file_in_dtor) {
+  int fd = 0;
+  {
+    file f = open_file();
+    fd = f.descriptor();
+  }
+  EXPECT_TRUE(isclosed(fd));
+}
+
+TEST(file_test, close_error_in_dtor) {
+  std::unique_ptr<file> f(new file(open_file()));
+  EXPECT_WRITE(
+      stderr,
+      {
+        // The close function must be called inside EXPECT_WRITE,
+        // otherwise the system may recycle closed file descriptor when
+        // redirecting the output in EXPECT_STDERR and the second close
+        // will break output redirection.
+        FMT_POSIX(close(f->descriptor()));
+        SUPPRESS_ASSERT(f.reset(nullptr));
+      },
+      system_error_message(EBADF, "cannot close file") + "\n");
+}
+
+TEST(file_test, close) {
+  file f = open_file();
+  int fd = f.descriptor();
+  f.close();
+  EXPECT_EQ(-1, f.descriptor());
+  EXPECT_TRUE(isclosed(fd));
+}
+
+TEST(file_test, close_error) {
+  file f = open_file();
+  FMT_POSIX(close(f.descriptor()));
+  EXPECT_SYSTEM_ERROR_NOASSERT(f.close(), EBADF, "cannot close file");
+  EXPECT_EQ(-1, f.descriptor());
+}
+
+TEST(file_test, read) {
+  file f = open_file();
+  EXPECT_READ(f, file_content);
+}
+
+TEST(file_test, read_error) {
+  file f("test-file", file::WRONLY);
+  char buf;
+  // We intentionally read from a file opened in the write-only mode to
+  // cause error.
+  EXPECT_SYSTEM_ERROR(f.read(&buf, 1), EBADF, "cannot read from file");
+}
+
+TEST(file_test, write) {
+  file read_end, write_end;
+  file::pipe(read_end, write_end);
+  write(write_end, "test");
+  write_end.close();
+  EXPECT_READ(read_end, "test");
+}
+
+TEST(file_test, write_error) {
+  file f("test-file", file::RDONLY);
+  // We intentionally write to a file opened in the read-only mode to
+  // cause error.
+  EXPECT_SYSTEM_ERROR(f.write(" ", 1), EBADF, "cannot write to file");
+}
+
+TEST(file_test, dup) {
+  file f = open_file();
+  file copy = file::dup(f.descriptor());
+  EXPECT_NE(f.descriptor(), copy.descriptor());
+  EXPECT_EQ(file_content, read(copy, std::strlen(file_content)));
+}
+
+#  ifndef __COVERITY__
+TEST(file_test, dup_error) {
+  int value = -1;
+  EXPECT_SYSTEM_ERROR_NOASSERT(file::dup(value), EBADF,
+                               "cannot duplicate file descriptor -1");
+}
+#  endif
+
+TEST(file_test, dup2) {
+  file f = open_file();
+  file copy = open_file();
+  f.dup2(copy.descriptor());
+  EXPECT_NE(f.descriptor(), copy.descriptor());
+  EXPECT_READ(copy, file_content);
+}
+
+TEST(file_test, dup2_error) {
+  file f = open_file();
+  EXPECT_SYSTEM_ERROR_NOASSERT(
+      f.dup2(-1), EBADF,
+      fmt::format("cannot duplicate file descriptor {} to -1", f.descriptor()));
+}
+
+TEST(file_test, dup2_noexcept) {
+  file f = open_file();
+  file copy = open_file();
+  std::error_code ec;
+  f.dup2(copy.descriptor(), ec);
+  EXPECT_EQ(ec.value(), 0);
+  EXPECT_NE(f.descriptor(), copy.descriptor());
+  EXPECT_READ(copy, file_content);
+}
+
+TEST(file_test, dup2_noexcept_error) {
+  file f = open_file();
+  std::error_code ec;
+  SUPPRESS_ASSERT(f.dup2(-1, ec));
+  EXPECT_EQ(EBADF, ec.value());
+}
+
+TEST(file_test, pipe) {
+  file read_end, write_end;
+  file::pipe(read_end, write_end);
+  EXPECT_NE(-1, read_end.descriptor());
+  EXPECT_NE(-1, write_end.descriptor());
+  write(write_end, "test");
+  EXPECT_READ(read_end, "test");
+}
+
+TEST(file_test, fdopen) {
+  file read_end, write_end;
+  file::pipe(read_end, write_end);
+  int read_fd = read_end.descriptor();
+  EXPECT_EQ(read_fd, FMT_POSIX(fileno(read_end.fdopen("r").get())));
+}
+
+#  ifdef FMT_LOCALE
+TEST(locale_test, strtod) {
+  fmt::locale loc;
+  const char *start = "4.2", *ptr = start;
+  EXPECT_EQ(4.2, loc.strtod(ptr));
+  EXPECT_EQ(start + 3, ptr);
+}
+#  endif
+#endif  // FMT_USE_FCNTL

vendor/Fmt/test/ostream-test.cc

@@ -0,0 +1,282 @@
+// Formatting library for C++ - std::ostream support tests
+//
+// Copyright (c) 2012 - present, Victor Zverovich
+// All rights reserved.
+//
+// For the license information refer to format.h.
+
+#include "fmt/format.h"
+
+using fmt::runtime;
+
+struct test {};
+
+// Test that there is no issues with specializations when fmt/ostream.h is
+// included after fmt/format.h.
+namespace fmt {
+template <> struct formatter<test> : formatter<int> {
+  auto format(const test&, format_context& ctx) -> decltype(ctx.out()) {
+    return formatter<int>::format(42, ctx);
+  }
+};
+}  // namespace fmt
+
+#include <sstream>
+
+#include "fmt/ostream.h"
+#include "fmt/ranges.h"
+#include "gmock/gmock.h"
+#include "gtest-extra.h"
+#include "util.h"
+
+std::ostream& operator<<(std::ostream& os, const date& d) {
+  os << d.year() << '-' << d.month() << '-' << d.day();
+  return os;
+}
+
+std::wostream& operator<<(std::wostream& os, const date& d) {
+  os << d.year() << L'-' << d.month() << L'-' << d.day();
+  return os;
+}
+
+// Make sure that overloaded comma operators do no harm to is_streamable.
+struct type_with_comma_op {};
+template <typename T> void operator,(type_with_comma_op, const T&);
+template <typename T> type_with_comma_op operator<<(T&, const date&);
+
+enum streamable_enum {};
+
+std::ostream& operator<<(std::ostream& os, streamable_enum) {
+  return os << "streamable_enum";
+}
+
+enum unstreamable_enum {};
+
+TEST(ostream_test, enum) {
+  EXPECT_EQ("streamable_enum", fmt::format("{}", streamable_enum()));
+  EXPECT_EQ("0", fmt::format("{}", unstreamable_enum()));
+}
+
+TEST(ostream_test, format) {
+  EXPECT_EQ("a string", fmt::format("{0}", test_string("a string")));
+  EXPECT_EQ("The date is 2012-12-9",
+            fmt::format("The date is {0}", date(2012, 12, 9)));
+}
+
+TEST(ostream_test, format_specs) {
+  using fmt::format_error;
+  EXPECT_EQ("def  ", fmt::format("{0:<5}", test_string("def")));
+  EXPECT_EQ("  def", fmt::format("{0:>5}", test_string("def")));
+  EXPECT_EQ(" def ", fmt::format("{0:^5}", test_string("def")));
+  EXPECT_EQ("def**", fmt::format("{0:*<5}", test_string("def")));
+  EXPECT_THROW_MSG(fmt::format(runtime("{0:+}"), test_string()), format_error,
+                   "format specifier requires numeric argument");
+  EXPECT_THROW_MSG(fmt::format(runtime("{0:-}"), test_string()), format_error,
+                   "format specifier requires numeric argument");
+  EXPECT_THROW_MSG(fmt::format(runtime("{0: }"), test_string()), format_error,
+                   "format specifier requires numeric argument");
+  EXPECT_THROW_MSG(fmt::format(runtime("{0:#}"), test_string()), format_error,
+                   "format specifier requires numeric argument");
+  EXPECT_THROW_MSG(fmt::format(runtime("{0:05}"), test_string()), format_error,
+                   "format specifier requires numeric argument");
+  EXPECT_EQ("test         ", fmt::format("{0:13}", test_string("test")));
+  EXPECT_EQ("test         ", fmt::format("{0:{1}}", test_string("test"), 13));
+  EXPECT_EQ("te", fmt::format("{0:.2}", test_string("test")));
+  EXPECT_EQ("te", fmt::format("{0:.{1}}", test_string("test"), 2));
+}
+
+struct empty_test {};
+std::ostream& operator<<(std::ostream& os, empty_test) { return os << ""; }
+
+TEST(ostream_test, empty_custom_output) {
+  EXPECT_EQ("", fmt::format("{}", empty_test()));
+}
+
+TEST(ostream_test, print) {
+  std::ostringstream os;
+  fmt::print(os, "Don't {}!", "panic");
+  EXPECT_EQ("Don't panic!", os.str());
+}
+
+TEST(ostream_test, write_to_ostream) {
+  std::ostringstream os;
+  fmt::memory_buffer buffer;
+  const char* foo = "foo";
+  buffer.append(foo, foo + std::strlen(foo));
+  fmt::detail::write_buffer(os, buffer);
+  EXPECT_EQ("foo", os.str());
+}
+
+TEST(ostream_test, write_to_ostream_max_size) {
+  auto max_size = fmt::detail::max_value<size_t>();
+  auto max_streamsize = fmt::detail::max_value<std::streamsize>();
+  if (max_size <= fmt::detail::to_unsigned(max_streamsize)) return;
+
+  struct test_buffer final : fmt::detail::buffer<char> {
+    explicit test_buffer(size_t size)
+        : fmt::detail::buffer<char>(nullptr, size, size) {}
+    void grow(size_t) {}
+  } buffer(max_size);
+
+  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);
+    }
+  } streambuf;
+
+  struct test_ostream : std::ostream {
+    explicit test_ostream(mock_streambuf& output_buffer)
+        : std::ostream(&output_buffer) {}
+  } os(streambuf);
+
+  testing::InSequence sequence;
+  const char* data = nullptr;
+  using ustreamsize = std::make_unsigned<std::streamsize>::type;
+  ustreamsize size = max_size;
+  do {
+    auto n = std::min(size, fmt::detail::to_unsigned(max_streamsize));
+    EXPECT_CALL(streambuf, xsputn(data, static_cast<std::streamsize>(n)))
+        .WillOnce(testing::Return(max_streamsize));
+    data += n;
+    size -= n;
+  } while (size != 0);
+  fmt::detail::write_buffer(os, buffer);
+}
+
+TEST(ostream_test, join) {
+  int v[3] = {1, 2, 3};
+  EXPECT_EQ("1, 2, 3", fmt::format("{}", fmt::join(v, v + 3, ", ")));
+}
+
+TEST(ostream_test, join_fallback_formatter) {
+  auto strs = std::vector<test_string>{test_string("foo"), test_string("bar")};
+  EXPECT_EQ("foo, bar", fmt::format("{}", fmt::join(strs, ", ")));
+}
+
+#if FMT_USE_CONSTEXPR
+TEST(ostream_test, constexpr_string) {
+  EXPECT_EQ("42", format(FMT_STRING("{}"), std::string("42")));
+  EXPECT_EQ("a string", format(FMT_STRING("{0}"), test_string("a string")));
+}
+#endif
+
+namespace fmt_test {
+struct abc {};
+
+template <typename Output> Output& operator<<(Output& out, abc) {
+  return out << "abc";
+}
+}  // namespace fmt_test
+
+template <typename T> struct test_template {};
+
+template <typename T>
+std::ostream& operator<<(std::ostream& os, test_template<T>) {
+  return os << 1;
+}
+
+namespace fmt {
+template <typename T> struct formatter<test_template<T>> : formatter<int> {
+  auto format(test_template<T>, format_context& ctx) -> decltype(ctx.out()) {
+    return formatter<int>::format(2, ctx);
+  }
+};
+}  // namespace fmt
+
+TEST(ostream_test, template) {
+  EXPECT_EQ("2", fmt::format("{}", test_template<int>()));
+}
+
+TEST(ostream_test, format_to_n) {
+  char buffer[4];
+  buffer[3] = 'x';
+  auto result = fmt::format_to_n(buffer, 3, "{}", fmt_test::abc());
+  EXPECT_EQ(3u, result.size);
+  EXPECT_EQ(buffer + 3, result.out);
+  EXPECT_EQ("abcx", fmt::string_view(buffer, 4));
+  result = fmt::format_to_n(buffer, 3, "x{}y", fmt_test::abc());
+  EXPECT_EQ(5u, result.size);
+  EXPECT_EQ(buffer + 3, result.out);
+  EXPECT_EQ("xabx", fmt::string_view(buffer, 4));
+}
+
+template <typename T> struct convertible {
+  T value;
+  explicit convertible(const T& val) : value(val) {}
+  operator T() const { return value; }
+};
+
+TEST(ostream_test, disable_builtin_ostream_operators) {
+  EXPECT_EQ("42", fmt::format("{:d}", convertible<unsigned short>(42)));
+  EXPECT_EQ("foo", fmt::format("{}", convertible<const char*>("foo")));
+}
+
+struct explicitly_convertible_to_string_like {
+  template <typename String,
+            typename = typename std::enable_if<std::is_constructible<
+                String, const char*, size_t>::value>::type>
+  explicit operator String() const {
+    return String("foo", 3u);
+  }
+};
+
+std::ostream& operator<<(std::ostream& os,
+                         explicitly_convertible_to_string_like) {
+  return os << "bar";
+}
+
+TEST(ostream_test, format_explicitly_convertible_to_string_like) {
+  EXPECT_EQ("bar", fmt::format("{}", explicitly_convertible_to_string_like()));
+}
+
+#ifdef FMT_USE_STRING_VIEW
+struct explicitly_convertible_to_std_string_view {
+  explicit operator fmt::detail::std_string_view<char>() const {
+    return {"foo", 3u};
+  }
+};
+
+std::ostream& operator<<(std::ostream& os,
+                         explicitly_convertible_to_std_string_view) {
+  return os << "bar";
+}
+
+TEST(ostream_test, format_explicitly_convertible_to_std_string_view) {
+  EXPECT_EQ("bar", fmt::format("{}", explicitly_convertible_to_string_like()));
+}
+#endif  // FMT_USE_STRING_VIEW
+
+struct streamable_and_convertible_to_bool {
+  operator bool() const { return true; }
+};
+
+std::ostream& operator<<(std::ostream& os, streamable_and_convertible_to_bool) {
+  return os << "foo";
+}
+
+TEST(ostream_test, format_convertible_to_bool) {
+  EXPECT_EQ("foo", fmt::format("{}", streamable_and_convertible_to_bool()));
+}
+
+struct copyfmt_test {};
+
+std::ostream& operator<<(std::ostream& os, copyfmt_test) {
+  std::ios ios(nullptr);
+  ios.copyfmt(os);
+  return os << "foo";
+}
+
+TEST(ostream_test, copyfmt) {
+  EXPECT_EQ("foo", fmt::format("{}", copyfmt_test()));
+}
+
+TEST(ostream_test, to_string) {
+  EXPECT_EQ("abc", fmt::to_string(fmt_test::abc()));
+}
+
+TEST(ostream_test, range) {
+  auto strs = std::vector<test_string>{test_string("foo"), test_string("bar")};
+  EXPECT_EQ("[foo, bar]", fmt::format("{}", strs));
+}

vendor/Fmt/test/posix-mock-test.cc

@@ -0,0 +1,566 @@
+// Tests of the C++ interface to POSIX functions that require mocks
+//
+// Copyright (c) 2012 - present, Victor Zverovich
+// All rights reserved.
+//
+// For the license information refer to format.h.
+
+// Disable bogus MSVC warnings.
+#ifndef _CRT_SECURE_NO_WARNINGS
+#  define _CRT_SECURE_NO_WARNINGS
+#endif
+
+#include "posix-mock.h"
+
+#include <errno.h>
+#include <fcntl.h>
+
+#include <climits>
+#include <memory>
+
+#include "../src/os.cc"
+
+#ifdef _WIN32
+#  include <io.h>
+#  undef max
+#endif
+
+#include "gmock/gmock.h"
+#include "gtest-extra.h"
+#include "util.h"
+
+using fmt::buffered_file;
+
+using testing::_;
+using testing::Return;
+using testing::StrEq;
+
+template <typename Mock> struct scoped_mock : testing::StrictMock<Mock> {
+  scoped_mock() { Mock::instance = this; }
+  ~scoped_mock() { Mock::instance = nullptr; }
+};
+
+namespace {
+int open_count;
+int close_count;
+int dup_count;
+int dup2_count;
+int fdopen_count;
+int read_count;
+int write_count;
+int pipe_count;
+int fopen_count;
+int fclose_count;
+int fileno_count;
+size_t read_nbyte;
+size_t write_nbyte;
+bool sysconf_error;
+
+enum { none, max_size, error } fstat_sim;
+}  // namespace
+
+#define EMULATE_EINTR(func, error_result) \
+  if (func##_count != 0) {                \
+    if (func##_count++ != 3) {            \
+      errno = EINTR;                      \
+      return error_result;                \
+    }                                     \
+  }
+
+#ifndef _MSC_VER
+int test::open(const char* path, int oflag, int mode) {
+  EMULATE_EINTR(open, -1);
+  return ::open(path, oflag, mode);
+}
+#else
+errno_t test::sopen_s(int* pfh, const char* filename, int oflag, int shflag,
+                      int pmode) {
+  EMULATE_EINTR(open, EINTR);
+  return _sopen_s(pfh, filename, oflag, shflag, pmode);
+}
+#endif
+
+#ifndef _WIN32
+
+long test::sysconf(int name) {
+  long result = ::sysconf(name);
+  if (!sysconf_error) return result;
+  // Simulate an error.
+  errno = EINVAL;
+  return -1;
+}
+
+static off_t max_file_size() { return std::numeric_limits<off_t>::max(); }
+
+int test::fstat(int fd, struct stat* buf) {
+  int result = ::fstat(fd, buf);
+  if (fstat_sim == max_size) buf->st_size = max_file_size();
+  return result;
+}
+
+#else
+
+static LONGLONG max_file_size() { return std::numeric_limits<LONGLONG>::max(); }
+
+DWORD test::GetFileSize(HANDLE hFile, LPDWORD lpFileSizeHigh) {
+  if (fstat_sim == error) {
+    SetLastError(ERROR_ACCESS_DENIED);
+    return INVALID_FILE_SIZE;
+  }
+  if (fstat_sim == max_size) {
+    DWORD max = std::numeric_limits<DWORD>::max();
+    *lpFileSizeHigh = max >> 1;
+    return max;
+  }
+  return ::GetFileSize(hFile, lpFileSizeHigh);
+}
+
+#endif
+
+int test::close(int fildes) {
+  // Close the file first because close shouldn't be retried.
+  int result = ::FMT_POSIX(close(fildes));
+  EMULATE_EINTR(close, -1);
+  return result;
+}
+
+int test::dup(int fildes) {
+  EMULATE_EINTR(dup, -1);
+  return ::FMT_POSIX(dup(fildes));
+}
+
+int test::dup2(int fildes, int fildes2) {
+  EMULATE_EINTR(dup2, -1);
+  return ::FMT_POSIX(dup2(fildes, fildes2));
+}
+
+FILE* test::fdopen(int fildes, const char* mode) {
+  EMULATE_EINTR(fdopen, nullptr);
+  return ::FMT_POSIX(fdopen(fildes, mode));
+}
+
+test::ssize_t test::read(int fildes, void* buf, test::size_t nbyte) {
+  read_nbyte = nbyte;
+  EMULATE_EINTR(read, -1);
+  return ::FMT_POSIX(read(fildes, buf, nbyte));
+}
+
+test::ssize_t test::write(int fildes, const void* buf, test::size_t nbyte) {
+  write_nbyte = nbyte;
+  EMULATE_EINTR(write, -1);
+  return ::FMT_POSIX(write(fildes, buf, nbyte));
+}
+
+#ifndef _WIN32
+int test::pipe(int fildes[2]) {
+  EMULATE_EINTR(pipe, -1);
+  return ::pipe(fildes);
+}
+#else
+int test::pipe(int* pfds, unsigned psize, int textmode) {
+  EMULATE_EINTR(pipe, -1);
+  return _pipe(pfds, psize, textmode);
+}
+#endif
+
+FILE* test::fopen(const char* filename, const char* mode) {
+  EMULATE_EINTR(fopen, nullptr);
+  return ::fopen(filename, mode);
+}
+
+int test::fclose(FILE* stream) {
+  EMULATE_EINTR(fclose, EOF);
+  return ::fclose(stream);
+}
+
+int(test::fileno)(FILE* stream) {
+  EMULATE_EINTR(fileno, -1);
+#ifdef fileno
+  return FMT_POSIX(fileno(stream));
+#else
+  return ::FMT_POSIX(fileno(stream));
+#endif
+}
+
+#ifndef _WIN32
+#  define EXPECT_RETRY(statement, func, message) \
+    func##_count = 1;                            \
+    statement;                                   \
+    EXPECT_EQ(4, func##_count);                  \
+    func##_count = 0;
+#  define EXPECT_EQ_POSIX(expected, actual) EXPECT_EQ(expected, actual)
+#else
+#  define EXPECT_RETRY(statement, func, message)    \
+    func##_count = 1;                               \
+    EXPECT_SYSTEM_ERROR(statement, EINTR, message); \
+    func##_count = 0;
+#  define EXPECT_EQ_POSIX(expected, actual)
+#endif
+
+#if FMT_USE_FCNTL
+void write_file(fmt::cstring_view filename, fmt::string_view content) {
+  fmt::buffered_file f(filename, "w");
+  f.print("{}", content);
+}
+
+using fmt::file;
+
+TEST(os_test, getpagesize) {
+#  ifdef _WIN32
+  SYSTEM_INFO si = {};
+  GetSystemInfo(&si);
+  EXPECT_EQ(si.dwPageSize, fmt::getpagesize());
+#  else
+  EXPECT_EQ(sysconf(_SC_PAGESIZE), fmt::getpagesize());
+  sysconf_error = true;
+  EXPECT_SYSTEM_ERROR(fmt::getpagesize(), EINVAL,
+                      "cannot get memory page size");
+  sysconf_error = false;
+#  endif
+}
+
+TEST(file_test, open_retry) {
+  write_file("temp", "there must be something here");
+  std::unique_ptr<file> f{nullptr};
+  EXPECT_RETRY(f.reset(new file("temp", file::RDONLY)), open,
+               "cannot open file temp");
+#  ifndef _WIN32
+  char c = 0;
+  f->read(&c, 1);
+#  endif
+}
+
+TEST(file_test, close_no_retry_in_dtor) {
+  file read_end, write_end;
+  file::pipe(read_end, write_end);
+  std::unique_ptr<file> f(new file(std::move(read_end)));
+  int saved_close_count = 0;
+  EXPECT_WRITE(
+      stderr,
+      {
+        close_count = 1;
+        f.reset(nullptr);
+        saved_close_count = close_count;
+        close_count = 0;
+      },
+      system_error_message(EINTR, "cannot close file") + "\n");
+  EXPECT_EQ(2, saved_close_count);
+}
+
+TEST(file_test, close_no_retry) {
+  file read_end, write_end;
+  file::pipe(read_end, write_end);
+  close_count = 1;
+  EXPECT_SYSTEM_ERROR(read_end.close(), EINTR, "cannot close file");
+  EXPECT_EQ(2, close_count);
+  close_count = 0;
+}
+
+TEST(file_test, size) {
+  std::string content = "top secret, destroy before reading";
+  write_file("temp", content);
+  file f("temp", file::RDONLY);
+  EXPECT_GE(f.size(), 0);
+  EXPECT_EQ(content.size(), static_cast<unsigned long long>(f.size()));
+#  ifdef _WIN32
+  auto error_code = std::error_code();
+  fstat_sim = error;
+  try {
+    f.size();
+  } catch (const std::system_error& e) {
+    error_code = e.code();
+  }
+  fstat_sim = none;
+  EXPECT_EQ(error_code,
+            std::error_code(ERROR_ACCESS_DENIED, fmt::system_category()));
+#  else
+  f.close();
+  EXPECT_SYSTEM_ERROR(f.size(), EBADF, "cannot get file attributes");
+#  endif
+}
+
+TEST(file_test, max_size) {
+  write_file("temp", "");
+  file f("temp", file::RDONLY);
+  fstat_sim = max_size;
+  EXPECT_GE(f.size(), 0);
+  EXPECT_EQ(max_file_size(), f.size());
+  fstat_sim = none;
+}
+
+TEST(file_test, read_retry) {
+  file read_end, write_end;
+  file::pipe(read_end, write_end);
+  enum { SIZE = 4 };
+  write_end.write("test", SIZE);
+  write_end.close();
+  char buffer[SIZE];
+  size_t count = 0;
+  EXPECT_RETRY(count = read_end.read(buffer, SIZE), read,
+               "cannot read from file");
+  EXPECT_EQ_POSIX(static_cast<std::streamsize>(SIZE), count);
+}
+
+TEST(file_test, write_retry) {
+  file read_end, write_end;
+  file::pipe(read_end, write_end);
+  enum { SIZE = 4 };
+  size_t count = 0;
+  EXPECT_RETRY(count = write_end.write("test", SIZE), write,
+               "cannot write to file");
+  write_end.close();
+#  ifndef _WIN32
+  EXPECT_EQ(static_cast<std::streamsize>(SIZE), count);
+  char buffer[SIZE + 1];
+  read_end.read(buffer, SIZE);
+  buffer[SIZE] = '\0';
+  EXPECT_STREQ("test", buffer);
+#  endif
+}
+
+#  ifdef _WIN32
+TEST(file_test, convert_read_count) {
+  file read_end, write_end;
+  file::pipe(read_end, write_end);
+  char c;
+  size_t size = UINT_MAX;
+  if (sizeof(unsigned) != sizeof(size_t)) ++size;
+  read_count = 1;
+  read_nbyte = 0;
+  EXPECT_THROW(read_end.read(&c, size), std::system_error);
+  read_count = 0;
+  EXPECT_EQ(UINT_MAX, read_nbyte);
+}
+
+TEST(file_test, convert_write_count) {
+  file read_end, write_end;
+  file::pipe(read_end, write_end);
+  char c;
+  size_t size = UINT_MAX;
+  if (sizeof(unsigned) != sizeof(size_t)) ++size;
+  write_count = 1;
+  write_nbyte = 0;
+  EXPECT_THROW(write_end.write(&c, size), std::system_error);
+  write_count = 0;
+  EXPECT_EQ(UINT_MAX, write_nbyte);
+}
+#  endif
+
+TEST(file_test, dup_no_retry) {
+  int stdout_fd = FMT_POSIX(fileno(stdout));
+  dup_count = 1;
+  EXPECT_SYSTEM_ERROR(
+      file::dup(stdout_fd), EINTR,
+      fmt::format("cannot duplicate file descriptor {}", stdout_fd));
+  dup_count = 0;
+}
+
+TEST(file_test, dup2_retry) {
+  int stdout_fd = FMT_POSIX(fileno(stdout));
+  file f1 = file::dup(stdout_fd), f2 = file::dup(stdout_fd);
+  EXPECT_RETRY(f1.dup2(f2.descriptor()), dup2,
+               fmt::format("cannot duplicate file descriptor {} to {}",
+                           f1.descriptor(), f2.descriptor()));
+}
+
+TEST(file_test, dup2_no_except_retry) {
+  int stdout_fd = FMT_POSIX(fileno(stdout));
+  file f1 = file::dup(stdout_fd), f2 = file::dup(stdout_fd);
+  std::error_code ec;
+  dup2_count = 1;
+  f1.dup2(f2.descriptor(), ec);
+#  ifndef _WIN32
+  EXPECT_EQ(4, dup2_count);
+#  else
+  EXPECT_EQ(EINTR, ec.value());
+#  endif
+  dup2_count = 0;
+}
+
+TEST(file_test, pipe_no_retry) {
+  file read_end, write_end;
+  pipe_count = 1;
+  EXPECT_SYSTEM_ERROR(file::pipe(read_end, write_end), EINTR,
+                      "cannot create pipe");
+  pipe_count = 0;
+}
+
+TEST(file_test, fdopen_no_retry) {
+  file read_end, write_end;
+  file::pipe(read_end, write_end);
+  fdopen_count = 1;
+  EXPECT_SYSTEM_ERROR(read_end.fdopen("r"), EINTR,
+                      "cannot associate stream with file descriptor");
+  fdopen_count = 0;
+}
+
+TEST(buffered_file_test, open_retry) {
+  write_file("temp", "there must be something here");
+  std::unique_ptr<buffered_file> f{nullptr};
+  EXPECT_RETRY(f.reset(new buffered_file("temp", "r")), fopen,
+               "cannot open file temp");
+#  ifndef _WIN32
+  char c = 0;
+  if (fread(&c, 1, 1, f->get()) < 1)
+    throw fmt::system_error(errno, "fread failed");
+#  endif
+}
+
+TEST(buffered_file_test, close_no_retry_in_dtor) {
+  file read_end, write_end;
+  file::pipe(read_end, write_end);
+  std::unique_ptr<buffered_file> f(new buffered_file(read_end.fdopen("r")));
+  int saved_fclose_count = 0;
+  EXPECT_WRITE(
+      stderr,
+      {
+        fclose_count = 1;
+        f.reset(nullptr);
+        saved_fclose_count = fclose_count;
+        fclose_count = 0;
+      },
+      system_error_message(EINTR, "cannot close file") + "\n");
+  EXPECT_EQ(2, saved_fclose_count);
+}
+
+TEST(buffered_file_test, close_no_retry) {
+  file read_end, write_end;
+  file::pipe(read_end, write_end);
+  buffered_file f = read_end.fdopen("r");
+  fclose_count = 1;
+  EXPECT_SYSTEM_ERROR(f.close(), EINTR, "cannot close file");
+  EXPECT_EQ(2, fclose_count);
+  fclose_count = 0;
+}
+
+TEST(buffered_file_test, fileno_no_retry) {
+  file read_end, write_end;
+  file::pipe(read_end, write_end);
+  buffered_file f = read_end.fdopen("r");
+  fileno_count = 1;
+  EXPECT_SYSTEM_ERROR((f.fileno)(), EINTR, "cannot get file descriptor");
+  EXPECT_EQ(2, fileno_count);
+  fileno_count = 0;
+}
+#endif  // FMT_USE_FCNTL
+
+struct test_mock {
+  static test_mock* instance;
+} * test_mock::instance;
+
+TEST(scoped_mock, scope) {
+  {
+    scoped_mock<test_mock> mock;
+    EXPECT_EQ(&mock, test_mock::instance);
+    test_mock& copy = mock;
+    static_cast<void>(copy);
+  }
+  EXPECT_EQ(nullptr, test_mock::instance);
+}
+
+#ifdef FMT_LOCALE
+
+using locale_type = fmt::locale::type;
+
+struct locale_mock {
+  static locale_mock* instance;
+  MOCK_METHOD3(newlocale, locale_type(int category_mask, const char* locale,
+                                      locale_type base));
+  MOCK_METHOD1(freelocale, void(locale_type locale));
+
+  MOCK_METHOD3(strtod_l,
+               double(const char* nptr, char** endptr, locale_type locale));
+} * locale_mock::instance;
+
+#  ifdef _MSC_VER
+#    pragma warning(push)
+#    pragma warning(disable : 4273)
+#    ifdef __clang__
+#      pragma clang diagnostic push
+#      pragma clang diagnostic ignored "-Winconsistent-dllimport"
+#    endif
+
+_locale_t _create_locale(int category, const char* locale) {
+  return locale_mock::instance->newlocale(category, locale, 0);
+}
+
+void _free_locale(_locale_t locale) {
+  locale_mock::instance->freelocale(locale);
+}
+
+double _strtod_l(const char* nptr, char** endptr, _locale_t locale) {
+  return locale_mock::instance->strtod_l(nptr, endptr, locale);
+}
+#    ifdef __clang__
+#      pragma clang diagnostic pop
+#    endif
+#    pragma warning(pop)
+#  endif
+
+#  if defined(__THROW) && \
+      ((FMT_GCC_VERSION > 0 && FMT_GCC_VERSION <= 408) || defined(__e2k__))
+#    define FMT_LOCALE_THROW __THROW
+#  else
+#    define FMT_LOCALE_THROW
+#  endif
+
+#  if defined(__APPLE__) || \
+      (defined(__FreeBSD__) && __FreeBSD_version < 1200002)
+typedef int FreeLocaleResult;
+#  else
+typedef void FreeLocaleResult;
+#  endif
+
+FreeLocaleResult freelocale(locale_type locale) FMT_LOCALE_THROW {
+  locale_mock::instance->freelocale(locale);
+  return FreeLocaleResult();
+}
+
+double strtod_l(const char* nptr, char** endptr,
+                locale_type locale) FMT_LOCALE_THROW {
+  return locale_mock::instance->strtod_l(nptr, endptr, locale);
+}
+
+#  undef FMT_LOCALE_THROW
+
+#  ifndef _WIN32
+locale_t test::newlocale(int category_mask, const char* locale, locale_t base) {
+  return locale_mock::instance->newlocale(category_mask, locale, base);
+}
+
+TEST(locale_test, locale_mock) {
+  scoped_mock<locale_mock> mock;
+  auto locale = reinterpret_cast<locale_type>(11);
+  EXPECT_CALL(mock, newlocale(222, StrEq("foo"), locale));
+  FMT_SYSTEM(newlocale(222, "foo", locale));
+}
+#  endif
+
+TEST(locale_test, locale) {
+#  ifndef LC_NUMERIC_MASK
+  enum { LC_NUMERIC_MASK = LC_NUMERIC };
+#  endif
+  scoped_mock<locale_mock> mock;
+  auto impl = reinterpret_cast<locale_type>(42);
+  EXPECT_CALL(mock, newlocale(LC_NUMERIC_MASK, StrEq("C"), nullptr))
+      .WillOnce(Return(impl));
+  EXPECT_CALL(mock, freelocale(impl));
+  fmt::locale loc;
+  EXPECT_EQ(impl, loc.get());
+}
+
+TEST(locale_test, strtod) {
+  scoped_mock<locale_mock> mock;
+  EXPECT_CALL(mock, newlocale(_, _, _))
+      .WillOnce(Return(reinterpret_cast<locale_type>(42)));
+  EXPECT_CALL(mock, freelocale(_));
+  fmt::locale loc;
+  const char* str = "4.2";
+  char end = 'x';
+  EXPECT_CALL(mock, strtod_l(str, _, loc.get()))
+      .WillOnce(testing::DoAll(testing::SetArgPointee<1>(&end), Return(777)));
+  EXPECT_EQ(777, loc.strtod(str));
+  EXPECT_EQ(&end, str);
+}
+
+#endif  // FMT_LOCALE

vendor/Fmt/test/posix-mock.h

@@ -0,0 +1,77 @@
+// Formatting library for C++ - mocks of POSIX functions
+//
+// Copyright (c) 2012 - present, Victor Zverovich
+// All rights reserved.
+//
+// For the license information refer to format.h.
+
+#ifndef FMT_POSIX_TEST_H
+#define FMT_POSIX_TEST_H
+
+#include <errno.h>
+#include <locale.h>
+#include <stdio.h>
+#ifdef __APPLE__
+#  include <xlocale.h>
+#endif
+
+#ifdef _WIN32
+#  include <windows.h>
+#else
+#  include <sys/param.h>  // for FreeBSD version
+#  include <sys/types.h>  // for ssize_t
+#endif
+
+#ifndef _MSC_VER
+struct stat;
+#endif
+
+namespace test {
+
+#ifndef _MSC_VER
+// Size type for read and write.
+typedef size_t size_t;
+typedef ssize_t ssize_t;
+int open(const char* path, int oflag, int mode);
+int fstat(int fd, struct stat* buf);
+#else
+typedef unsigned size_t;
+typedef int ssize_t;
+errno_t sopen_s(int* pfh, const char* filename, int oflag, int shflag,
+                int pmode);
+#endif
+
+#ifndef _WIN32
+long sysconf(int name);
+#else
+DWORD GetFileSize(HANDLE hFile, LPDWORD lpFileSizeHigh);
+#endif
+
+int close(int fildes);
+
+int dup(int fildes);
+int dup2(int fildes, int fildes2);
+
+FILE* fdopen(int fildes, const char* mode);
+
+ssize_t read(int fildes, void* buf, size_t nbyte);
+ssize_t write(int fildes, const void* buf, size_t nbyte);
+
+#ifndef _WIN32
+int pipe(int fildes[2]);
+#else
+int pipe(int* pfds, unsigned psize, int textmode);
+#endif
+
+FILE* fopen(const char* filename, const char* mode);
+int fclose(FILE* stream);
+int(fileno)(FILE* stream);
+
+#if defined(FMT_LOCALE) && !defined(_WIN32)
+locale_t newlocale(int category_mask, const char* locale, locale_t base);
+#endif
+}  // namespace test
+
+#define FMT_SYSTEM(call) test::call
+
+#endif  // FMT_POSIX_TEST_H

vendor/Fmt/test/printf-test.cc

@@ -0,0 +1,594 @@
+// Formatting library for C++ - printf tests
+//
+// Copyright (c) 2012 - present, Victor Zverovich
+// All rights reserved.
+//
+// For the license information refer to format.h.
+
+#include "fmt/printf.h"
+
+#include <cctype>
+#include <climits>
+#include <cstring>
+
+#include "fmt/ostream.h"
+#include "fmt/xchar.h"
+#include "gtest-extra.h"
+#include "util.h"
+
+using fmt::format;
+using fmt::format_error;
+using fmt::detail::max_value;
+
+const unsigned big_num = INT_MAX + 1u;
+
+// Makes format string argument positional.
+static std::string make_positional(fmt::string_view format) {
+  std::string s(format.data(), format.size());
+  s.replace(s.find('%'), 1, "%1$");
+  return s;
+}
+
+static std::wstring make_positional(fmt::basic_string_view<wchar_t> format) {
+  std::wstring s(format.data(), format.size());
+  s.replace(s.find(L'%'), 1, L"%1$");
+  return s;
+}
+
+// A wrapper around fmt::sprintf to workaround bogus warnings about invalid
+// format strings in MSVC.
+template <typename... Args>
+std::string test_sprintf(fmt::string_view format, const Args&... args) {
+  return fmt::sprintf(format, args...);
+}
+template <typename... Args>
+std::wstring test_sprintf(fmt::basic_string_view<wchar_t> format,
+                          const Args&... args) {
+  return fmt::sprintf(format, args...);
+}
+
+#define EXPECT_PRINTF(expected_output, format, arg)     \
+  EXPECT_EQ(expected_output, test_sprintf(format, arg)) \
+      << "format: " << format;                          \
+  EXPECT_EQ(expected_output, fmt::sprintf(make_positional(format), arg))
+
+TEST(printf_test, no_args) {
+  EXPECT_EQ("test", test_sprintf("test"));
+  EXPECT_EQ(L"test", fmt::sprintf(L"test"));
+}
+
+TEST(printf_test, escape) {
+  EXPECT_EQ("%", test_sprintf("%%"));
+  EXPECT_EQ("before %", test_sprintf("before %%"));
+  EXPECT_EQ("% after", test_sprintf("%% after"));
+  EXPECT_EQ("before % after", test_sprintf("before %% after"));
+  EXPECT_EQ("%s", test_sprintf("%%s"));
+  EXPECT_EQ(L"%", fmt::sprintf(L"%%"));
+  EXPECT_EQ(L"before %", fmt::sprintf(L"before %%"));
+  EXPECT_EQ(L"% after", fmt::sprintf(L"%% after"));
+  EXPECT_EQ(L"before % after", fmt::sprintf(L"before %% after"));
+  EXPECT_EQ(L"%s", fmt::sprintf(L"%%s"));
+}
+
+TEST(printf_test, positional_args) {
+  EXPECT_EQ("42", test_sprintf("%1$d", 42));
+  EXPECT_EQ("before 42", test_sprintf("before %1$d", 42));
+  EXPECT_EQ("42 after", test_sprintf("%1$d after", 42));
+  EXPECT_EQ("before 42 after", test_sprintf("before %1$d after", 42));
+  EXPECT_EQ("answer = 42", test_sprintf("%1$s = %2$d", "answer", 42));
+  EXPECT_EQ("42 is the answer", test_sprintf("%2$d is the %1$s", "answer", 42));
+  EXPECT_EQ("abracadabra", test_sprintf("%1$s%2$s%1$s", "abra", "cad"));
+}
+
+TEST(printf_test, automatic_arg_indexing) {
+  EXPECT_EQ("abc", test_sprintf("%c%c%c", 'a', 'b', 'c'));
+}
+
+TEST(printf_test, number_is_too_big_in_arg_index) {
+  EXPECT_THROW_MSG(test_sprintf(format("%{}$", big_num)), format_error,
+                   "argument not found");
+  EXPECT_THROW_MSG(test_sprintf(format("%{}$d", big_num)), format_error,
+                   "argument not found");
+}
+
+TEST(printf_test, switch_arg_indexing) {
+  EXPECT_THROW_MSG(test_sprintf("%1$d%", 1, 2), format_error,
+                   "cannot switch from manual to automatic argument indexing");
+  EXPECT_THROW_MSG(test_sprintf(format("%1$d%{}d", big_num), 1, 2),
+                   format_error, "number is too big");
+  EXPECT_THROW_MSG(test_sprintf("%1$d%d", 1, 2), format_error,
+                   "cannot switch from manual to automatic argument indexing");
+
+  EXPECT_THROW_MSG(test_sprintf("%d%1$", 1, 2), format_error,
+                   "cannot switch from automatic to manual argument indexing");
+  EXPECT_THROW_MSG(test_sprintf(format("%d%{}$d", big_num), 1, 2), format_error,
+                   "cannot switch from automatic to manual argument indexing");
+  EXPECT_THROW_MSG(test_sprintf("%d%1$d", 1, 2), format_error,
+                   "cannot switch from automatic to manual argument indexing");
+
+  // Indexing errors override width errors.
+  EXPECT_THROW_MSG(test_sprintf(format("%d%1${}d", big_num), 1, 2),
+                   format_error, "number is too big");
+  EXPECT_THROW_MSG(test_sprintf(format("%1$d%{}d", big_num), 1, 2),
+                   format_error, "number is too big");
+}
+
+TEST(printf_test, invalid_arg_index) {
+  EXPECT_THROW_MSG(test_sprintf("%0$d", 42), format_error,
+                   "argument not found");
+  EXPECT_THROW_MSG(test_sprintf("%2$d", 42), format_error,
+                   "argument not found");
+  EXPECT_THROW_MSG(test_sprintf(format("%{}$d", INT_MAX), 42), format_error,
+                   "argument not found");
+
+  EXPECT_THROW_MSG(test_sprintf("%2$", 42), format_error, "argument not found");
+  EXPECT_THROW_MSG(test_sprintf(format("%{}$d", big_num), 42), format_error,
+                   "argument not found");
+}
+
+TEST(printf_test, default_align_right) {
+  EXPECT_PRINTF("   42", "%5d", 42);
+  EXPECT_PRINTF("  abc", "%5s", "abc");
+}
+
+TEST(printf_test, zero_flag) {
+  EXPECT_PRINTF("00042", "%05d", 42);
+  EXPECT_PRINTF("-0042", "%05d", -42);
+
+  EXPECT_PRINTF("00042", "%05d", 42);
+  EXPECT_PRINTF("-0042", "%05d", -42);
+  EXPECT_PRINTF("-004.2", "%06g", -4.2);
+
+  EXPECT_PRINTF("+00042", "%00+6d", 42);
+
+  EXPECT_PRINTF("   42", "%05.d", 42);
+  EXPECT_PRINTF(" 0042", "%05.4d", 42);
+
+  // '0' flag is ignored for non-numeric types.
+  EXPECT_PRINTF("    x", "%05c", 'x');
+}
+
+TEST(printf_test, plus_flag) {
+  EXPECT_PRINTF("+42", "%+d", 42);
+  EXPECT_PRINTF("-42", "%+d", -42);
+  EXPECT_PRINTF("+0042", "%+05d", 42);
+  EXPECT_PRINTF("+0042", "%0++5d", 42);
+
+  // '+' flag is ignored for non-numeric types.
+  EXPECT_PRINTF("x", "%+c", 'x');
+
+  // '+' flag wins over space flag
+  EXPECT_PRINTF("+42", "%+ d", 42);
+  EXPECT_PRINTF("-42", "%+ d", -42);
+  EXPECT_PRINTF("+42", "% +d", 42);
+  EXPECT_PRINTF("-42", "% +d", -42);
+  EXPECT_PRINTF("+0042", "% +05d", 42);
+  EXPECT_PRINTF("+0042", "%0+ 5d", 42);
+
+  // '+' flag and space flag are both ignored for non-numeric types.
+  EXPECT_PRINTF("x", "%+ c", 'x');
+  EXPECT_PRINTF("x", "% +c", 'x');
+}
+
+TEST(printf_test, minus_flag) {
+  EXPECT_PRINTF("abc  ", "%-5s", "abc");
+  EXPECT_PRINTF("abc  ", "%0--5s", "abc");
+
+  EXPECT_PRINTF("7    ", "%-5d", 7);
+  EXPECT_PRINTF("97   ", "%-5hhi", 'a');
+  EXPECT_PRINTF("a    ", "%-5c", 'a');
+
+  // '0' flag is ignored if '-' flag is given
+  EXPECT_PRINTF("7    ", "%-05d", 7);
+  EXPECT_PRINTF("7    ", "%0-5d", 7);
+  EXPECT_PRINTF("a    ", "%-05c", 'a');
+  EXPECT_PRINTF("a    ", "%0-5c", 'a');
+  EXPECT_PRINTF("97   ", "%-05hhi", 'a');
+  EXPECT_PRINTF("97   ", "%0-5hhi", 'a');
+
+  // '-' and space flag don't interfere
+  EXPECT_PRINTF(" 42", "%- d", 42);
+}
+
+TEST(printf_test, space_flag) {
+  EXPECT_PRINTF(" 42", "% d", 42);
+  EXPECT_PRINTF("-42", "% d", -42);
+  EXPECT_PRINTF(" 0042", "% 05d", 42);
+  EXPECT_PRINTF(" 0042", "%0  5d", 42);
+
+  // ' ' flag is ignored for non-numeric types.
+  EXPECT_PRINTF("x", "% c", 'x');
+}
+
+TEST(printf_test, hash_flag) {
+  EXPECT_PRINTF("042", "%#o", 042);
+  EXPECT_PRINTF(fmt::format("0{:o}", static_cast<unsigned>(-042)), "%#o", -042);
+  EXPECT_PRINTF("0", "%#o", 0);
+
+  EXPECT_PRINTF("0x42", "%#x", 0x42);
+  EXPECT_PRINTF("0X42", "%#X", 0x42);
+  EXPECT_PRINTF(fmt::format("0x{:x}", static_cast<unsigned>(-0x42)), "%#x",
+                -0x42);
+  EXPECT_PRINTF("0", "%#x", 0);
+
+  EXPECT_PRINTF("0x0042", "%#06x", 0x42);
+  EXPECT_PRINTF("0x0042", "%0##6x", 0x42);
+
+  EXPECT_PRINTF("-42.000000", "%#f", -42.0);
+  EXPECT_PRINTF("-42.000000", "%#F", -42.0);
+
+  char buffer[256];
+  safe_sprintf(buffer, "%#e", -42.0);
+  EXPECT_PRINTF(buffer, "%#e", -42.0);
+  safe_sprintf(buffer, "%#E", -42.0);
+  EXPECT_PRINTF(buffer, "%#E", -42.0);
+
+  EXPECT_PRINTF("-42.0000", "%#g", -42.0);
+  EXPECT_PRINTF("-42.0000", "%#G", -42.0);
+
+  safe_sprintf(buffer, "%#a", 16.0);
+  EXPECT_PRINTF(buffer, "%#a", 16.0);
+  safe_sprintf(buffer, "%#A", 16.0);
+  EXPECT_PRINTF(buffer, "%#A", 16.0);
+
+  // '#' flag is ignored for non-numeric types.
+  EXPECT_PRINTF("x", "%#c", 'x');
+}
+
+TEST(printf_test, width) {
+  EXPECT_PRINTF("  abc", "%5s", "abc");
+
+  // Width cannot be specified twice.
+  EXPECT_THROW_MSG(test_sprintf("%5-5d", 42), format_error,
+                   "invalid type specifier");
+
+  EXPECT_THROW_MSG(test_sprintf(format("%{}d", big_num), 42), format_error,
+                   "number is too big");
+  EXPECT_THROW_MSG(test_sprintf(format("%1${}d", big_num), 42), format_error,
+                   "number is too big");
+}
+
+TEST(printf_test, dynamic_width) {
+  EXPECT_EQ("   42", test_sprintf("%*d", 5, 42));
+  EXPECT_EQ("42   ", test_sprintf("%*d", -5, 42));
+  EXPECT_THROW_MSG(test_sprintf("%*d", 5.0, 42), format_error,
+                   "width is not integer");
+  EXPECT_THROW_MSG(test_sprintf("%*d"), format_error, "argument not found");
+  EXPECT_THROW_MSG(test_sprintf("%*d", big_num, 42), format_error,
+                   "number is too big");
+}
+
+TEST(printf_test, int_precision) {
+  EXPECT_PRINTF("00042", "%.5d", 42);
+  EXPECT_PRINTF("-00042", "%.5d", -42);
+  EXPECT_PRINTF("00042", "%.5x", 0x42);
+  EXPECT_PRINTF("0x00042", "%#.5x", 0x42);
+  EXPECT_PRINTF("00042", "%.5o", 042);
+  EXPECT_PRINTF("00042", "%#.5o", 042);
+
+  EXPECT_PRINTF("  00042", "%7.5d", 42);
+  EXPECT_PRINTF("  00042", "%7.5x", 0x42);
+  EXPECT_PRINTF("   0x00042", "%#10.5x", 0x42);
+  EXPECT_PRINTF("  00042", "%7.5o", 042);
+  EXPECT_PRINTF("     00042", "%#10.5o", 042);
+
+  EXPECT_PRINTF("00042  ", "%-7.5d", 42);
+  EXPECT_PRINTF("00042  ", "%-7.5x", 0x42);
+  EXPECT_PRINTF("0x00042   ", "%-#10.5x", 0x42);
+  EXPECT_PRINTF("00042  ", "%-7.5o", 042);
+  EXPECT_PRINTF("00042     ", "%-#10.5o", 042);
+}
+
+TEST(printf_test, float_precision) {
+  char buffer[256];
+  safe_sprintf(buffer, "%.3e", 1234.5678);
+  EXPECT_PRINTF(buffer, "%.3e", 1234.5678);
+  EXPECT_PRINTF("1234.568", "%.3f", 1234.5678);
+  EXPECT_PRINTF("1.23e+03", "%.3g", 1234.5678);
+  safe_sprintf(buffer, "%.3a", 1234.5678);
+  EXPECT_PRINTF(buffer, "%.3a", 1234.5678);
+}
+
+TEST(printf_test, string_precision) {
+  char test[] = {'H', 'e', 'l', 'l', 'o'};
+  EXPECT_EQ(fmt::sprintf("%.4s", test), "Hell");
+}
+
+TEST(printf_test, ignore_precision_for_non_numeric_arg) {
+  EXPECT_PRINTF("abc", "%.5s", "abc");
+}
+
+TEST(printf_test, dynamic_precision) {
+  EXPECT_EQ("00042", test_sprintf("%.*d", 5, 42));
+  EXPECT_EQ("42", test_sprintf("%.*d", -5, 42));
+  EXPECT_THROW_MSG(test_sprintf("%.*d", 5.0, 42), format_error,
+                   "precision is not integer");
+  EXPECT_THROW_MSG(test_sprintf("%.*d"), format_error, "argument not found");
+  EXPECT_THROW_MSG(test_sprintf("%.*d", big_num, 42), format_error,
+                   "number is too big");
+  if (sizeof(long long) != sizeof(int)) {
+    long long prec = static_cast<long long>(INT_MIN) - 1;
+    EXPECT_THROW_MSG(test_sprintf("%.*d", prec, 42), format_error,
+                     "number is too big");
+  }
+}
+
+template <typename T> struct make_signed { typedef T type; };
+
+#define SPECIALIZE_MAKE_SIGNED(T, S) \
+  template <> 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(unsigned long long, long long);
+
+// Test length format specifier ``length_spec``.
+template <typename T, typename U>
+void test_length(const char* length_spec, U value) {
+  long long signed_value = 0;
+  unsigned long long unsigned_value = 0;
+  // Apply integer promotion to the argument.
+  unsigned long long max = max_value<U>();
+  using fmt::detail::const_check;
+  if (const_check(max <= static_cast<unsigned>(max_value<int>()))) {
+    signed_value = static_cast<int>(value);
+    unsigned_value = static_cast<unsigned long long>(value);
+  } else if (const_check(max <= max_value<unsigned>())) {
+    signed_value = static_cast<unsigned>(value);
+    unsigned_value = static_cast<unsigned long long>(value);
+  }
+  if (sizeof(U) <= sizeof(int) && sizeof(int) < sizeof(T)) {
+    signed_value = static_cast<long long>(value);
+    unsigned_value = static_cast<unsigned long long>(
+        static_cast<typename std::make_unsigned<unsigned>::type>(value));
+  } else {
+    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;
+  EXPECT_PRINTF(os.str(), fmt::format("%{}d", length_spec), value);
+  EXPECT_PRINTF(os.str(), fmt::format("%{}i", length_spec), value);
+  os.str("");
+  os << unsigned_value;
+  EXPECT_PRINTF(os.str(), fmt::format("%{}u", length_spec), value);
+  os.str("");
+  os << std::oct << unsigned_value;
+  EXPECT_PRINTF(os.str(), fmt::format("%{}o", length_spec), value);
+  os.str("");
+  os << std::hex << unsigned_value;
+  EXPECT_PRINTF(os.str(), fmt::format("%{}x", length_spec), value);
+  os.str("");
+  os << std::hex << std::uppercase << unsigned_value;
+  EXPECT_PRINTF(os.str(), fmt::format("%{}X", length_spec), value);
+}
+
+template <typename T> void test_length(const char* length_spec) {
+  T min = std::numeric_limits<T>::min(), max = max_value<T>();
+  test_length<T>(length_spec, 42);
+  test_length<T>(length_spec, -42);
+  test_length<T>(length_spec, min);
+  test_length<T>(length_spec, max);
+  long long long_long_min = std::numeric_limits<long long>::min();
+  if (static_cast<long long>(min) > long_long_min)
+    test_length<T>(length_spec, static_cast<long long>(min) - 1);
+  unsigned long long long_long_max = max_value<long long>();
+  if (static_cast<unsigned long long>(max) < long_long_max)
+    test_length<T>(length_spec, static_cast<long long>(max) + 1);
+  test_length<T>(length_spec, std::numeric_limits<short>::min());
+  test_length<T>(length_spec, max_value<unsigned short>());
+  test_length<T>(length_spec, std::numeric_limits<int>::min());
+  test_length<T>(length_spec, max_value<int>());
+  test_length<T>(length_spec, std::numeric_limits<unsigned>::min());
+  test_length<T>(length_spec, max_value<unsigned>());
+  test_length<T>(length_spec, std::numeric_limits<long long>::min());
+  test_length<T>(length_spec, max_value<long long>());
+  test_length<T>(length_spec, std::numeric_limits<unsigned long long>::min());
+  test_length<T>(length_spec, max_value<unsigned long long>());
+}
+
+TEST(printf_test, length) {
+  test_length<char>("hh");
+  test_length<signed char>("hh");
+  test_length<unsigned char>("hh");
+  test_length<short>("h");
+  test_length<unsigned short>("h");
+  test_length<long>("l");
+  test_length<unsigned long>("l");
+  test_length<long long>("ll");
+  test_length<unsigned long long>("ll");
+  test_length<intmax_t>("j");
+  test_length<size_t>("z");
+  test_length<std::ptrdiff_t>("t");
+  long double max = max_value<long double>();
+  EXPECT_PRINTF(fmt::format("{:.6}", max), "%g", max);
+  EXPECT_PRINTF(fmt::format("{:.6}", max), "%Lg", max);
+}
+
+TEST(printf_test, bool) {
+  EXPECT_PRINTF("1", "%d", true);
+  EXPECT_PRINTF("true", "%s", true);
+}
+
+TEST(printf_test, int) {
+  EXPECT_PRINTF("-42", "%d", -42);
+  EXPECT_PRINTF("-42", "%i", -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);
+}
+
+TEST(printf_test, long_long) {
+  // fmt::printf allows passing long long arguments to %d without length
+  // specifiers.
+  long long max = max_value<long long>();
+  EXPECT_PRINTF(fmt::format("{}", max), "%d", max);
+}
+
+TEST(printf_test, float) {
+  EXPECT_PRINTF("392.650000", "%f", 392.65);
+  EXPECT_PRINTF("392.65", "%.2f", 392.65);
+  EXPECT_PRINTF("392.6", "%.1f", 392.65);
+  EXPECT_PRINTF("393", "%.f", 392.65);
+  EXPECT_PRINTF("392.650000", "%F", 392.65);
+  char buffer[256];
+  safe_sprintf(buffer, "%e", 392.65);
+  EXPECT_PRINTF(buffer, "%e", 392.65);
+  safe_sprintf(buffer, "%E", 392.65);
+  EXPECT_PRINTF(buffer, "%E", 392.65);
+  EXPECT_PRINTF("392.65", "%g", 392.65);
+  EXPECT_PRINTF("392.65", "%G", 392.65);
+  EXPECT_PRINTF("392", "%g", 392.0);
+  EXPECT_PRINTF("392", "%G", 392.0);
+  EXPECT_PRINTF("4.56e-07", "%g", 0.000000456);
+  safe_sprintf(buffer, "%a", -392.65);
+  EXPECT_EQ(buffer, format("{:a}", -392.65));
+  safe_sprintf(buffer, "%A", -392.65);
+  EXPECT_EQ(buffer, format("{:A}", -392.65));
+}
+
+TEST(printf_test, inf) {
+  double inf = std::numeric_limits<double>::infinity();
+  for (const char* type = "fega"; *type; ++type) {
+    EXPECT_PRINTF("inf", fmt::format("%{}", *type), inf);
+    char upper = static_cast<char>(std::toupper(*type));
+    EXPECT_PRINTF("INF", fmt::format("%{}", upper), inf);
+  }
+}
+
+TEST(printf_test, char) {
+  EXPECT_PRINTF("x", "%c", 'x');
+  int max = max_value<int>();
+  EXPECT_PRINTF(fmt::format("{}", static_cast<char>(max)), "%c", max);
+  // EXPECT_PRINTF("x", "%lc", L'x');
+  EXPECT_PRINTF(L"x", L"%c", L'x');
+  EXPECT_PRINTF(fmt::format(L"{}", static_cast<wchar_t>(max)), L"%c", max);
+}
+
+TEST(printf_test, string) {
+  EXPECT_PRINTF("abc", "%s", "abc");
+  const char* null_str = nullptr;
+  EXPECT_PRINTF("(null)", "%s", null_str);
+  EXPECT_PRINTF("    (null)", "%10s", null_str);
+  EXPECT_PRINTF(L"abc", L"%s", L"abc");
+  const wchar_t* null_wstr = nullptr;
+  EXPECT_PRINTF(L"(null)", L"%s", null_wstr);
+  EXPECT_PRINTF(L"    (null)", L"%10s", null_wstr);
+}
+
+TEST(printf_test, uchar_string) {
+  unsigned char str[] = "test";
+  unsigned char* pstr = str;
+  EXPECT_EQ("test", fmt::sprintf("%s", pstr));
+}
+
+TEST(printf_test, pointer) {
+  int n;
+  void* p = &n;
+  EXPECT_PRINTF(fmt::format("{}", p), "%p", p);
+  p = nullptr;
+  EXPECT_PRINTF("(nil)", "%p", p);
+  EXPECT_PRINTF("     (nil)", "%10p", p);
+  const char* s = "test";
+  EXPECT_PRINTF(fmt::format("{:p}", s), "%p", s);
+  const char* null_str = nullptr;
+  EXPECT_PRINTF("(nil)", "%p", null_str);
+
+  p = &n;
+  EXPECT_PRINTF(fmt::format(L"{}", p), L"%p", p);
+  p = nullptr;
+  EXPECT_PRINTF(L"(nil)", L"%p", p);
+  EXPECT_PRINTF(L"     (nil)", L"%10p", p);
+  const wchar_t* w = L"test";
+  EXPECT_PRINTF(fmt::format(L"{:p}", w), L"%p", w);
+  const wchar_t* null_wstr = nullptr;
+  EXPECT_PRINTF(L"(nil)", L"%p", null_wstr);
+}
+
+enum test_enum { answer = 42 };
+
+TEST(printf_test, enum) {
+  EXPECT_PRINTF("42", "%d", answer);
+  volatile test_enum volatile_enum = answer;
+  EXPECT_PRINTF("42", "%d", volatile_enum);
+}
+
+#if FMT_USE_FCNTL
+TEST(printf_test, examples) {
+  const char* weekday = "Thursday";
+  const char* month = "August";
+  int day = 21;
+  EXPECT_WRITE(stdout, fmt::printf("%1$s, %3$d %2$s", weekday, month, day),
+               "Thursday, 21 August");
+}
+
+TEST(printf_test, printf_error) {
+  fmt::file read_end, write_end;
+  fmt::file::pipe(read_end, write_end);
+  int result = fmt::fprintf(read_end.fdopen("r").get(), "test");
+  EXPECT_LT(result, 0);
+}
+#endif
+
+TEST(printf_test, wide_string) {
+  EXPECT_EQ(L"abc", fmt::sprintf(L"%s", L"abc"));
+}
+
+TEST(printf_test, printf_custom) {
+  EXPECT_EQ("abc", test_sprintf("%s", test_string("abc")));
+}
+
+TEST(printf_test, vprintf) {
+  fmt::format_arg_store<fmt::printf_context, int> as{42};
+  fmt::basic_format_args<fmt::printf_context> args(as);
+  EXPECT_EQ(fmt::vsprintf("%d", args), "42");
+  EXPECT_WRITE(stdout, fmt::vprintf("%d", args), "42");
+  EXPECT_WRITE(stdout, fmt::vfprintf(stdout, "%d", args), "42");
+}
+
+template <typename... Args>
+void check_format_string_regression(fmt::string_view s, const Args&... args) {
+  fmt::sprintf(s, args...);
+}
+
+TEST(printf_test, check_format_string_regression) {
+  check_format_string_regression("%c%s", 'x', "");
+}
+
+TEST(printf_test, fixed_large_exponent) {
+  EXPECT_EQ("1000000000000000000000", fmt::sprintf("%.*f", -13, 1e21));
+}
+
+TEST(printf_test, vsprintf_make_args_example) {
+  fmt::format_arg_store<fmt::printf_context, int, const char*> as{42,
+                                                                  "something"};
+  fmt::basic_format_args<fmt::printf_context> args(as);
+  EXPECT_EQ("[42] something happened", fmt::vsprintf("[%d] %s happened", args));
+  auto as2 = fmt::make_printf_args(42, "something");
+  fmt::basic_format_args<fmt::printf_context> args2(as2);
+  EXPECT_EQ("[42] something happened",
+            fmt::vsprintf("[%d] %s happened", args2));
+  EXPECT_EQ("[42] something happened",
+            fmt::vsprintf("[%d] %s happened",
+                          {fmt::make_printf_args(42, "something")}));
+}
+
+TEST(printf_test, vsprintf_make_wargs_example) {
+  fmt::format_arg_store<fmt::wprintf_context, int, const wchar_t*> as{
+      42, L"something"};
+  fmt::basic_format_args<fmt::wprintf_context> args(as);
+  EXPECT_EQ(L"[42] something happened",
+            fmt::vsprintf(L"[%d] %s happened", args));
+  auto as2 = fmt::make_wprintf_args(42, L"something");
+  fmt::basic_format_args<fmt::wprintf_context> args2(as2);
+  EXPECT_EQ(L"[42] something happened",
+            fmt::vsprintf(L"[%d] %s happened", args2));
+  EXPECT_EQ(L"[42] something happened",
+            fmt::vsprintf(L"[%d] %s happened",
+                          {fmt::make_wprintf_args(42, L"something")}));
+}

vendor/Fmt/test/ranges-test.cc

@@ -0,0 +1,264 @@
+// Formatting library for C++ - the core API
+//
+// Copyright (c) 2012 - present, Victor Zverovich
+// All rights reserved.
+//
+// For the license information refer to format.h.
+//
+// Copyright (c) 2018 - present, Remotion (Igor Schulz)
+// All Rights Reserved
+// {fmt} support for ranges, containers and types tuple interface.
+
+#include "fmt/ranges.h"
+
+#include <map>
+#include <string>
+#include <vector>
+
+#include "gtest/gtest.h"
+
+#if !FMT_GCC_VERSION || FMT_GCC_VERSION >= 601
+#  define FMT_RANGES_TEST_ENABLE_C_STYLE_ARRAY
+#endif
+
+#if !FMT_MSC_VER || FMT_MSC_VER > 1910
+#  define FMT_RANGES_TEST_ENABLE_JOIN
+#  define FMT_RANGES_TEST_ENABLE_FORMAT_STRUCT
+#endif
+
+#ifdef FMT_RANGES_TEST_ENABLE_C_STYLE_ARRAY
+TEST(ranges_test, format_array) {
+  int arr[] = {1, 2, 3, 5, 7, 11};
+  EXPECT_EQ(fmt::format("{}", arr), "[1, 2, 3, 5, 7, 11]");
+}
+
+TEST(ranges_test, format_2d_array) {
+  int arr[][2] = {{1, 2}, {3, 5}, {7, 11}};
+  EXPECT_EQ(fmt::format("{}", arr), "[[1, 2], [3, 5], [7, 11]]");
+}
+
+TEST(ranges_test, format_array_of_literals) {
+  const char* arr[] = {"1234", "abcd"};
+  EXPECT_EQ(fmt::format("{}", arr), "[\"1234\", \"abcd\"]");
+}
+#endif  // FMT_RANGES_TEST_ENABLE_C_STYLE_ARRAY
+
+TEST(ranges_test, format_vector) {
+  auto v = std::vector<int>{1, 2, 3, 5, 7, 11};
+  EXPECT_EQ(fmt::format("{}", v), "[1, 2, 3, 5, 7, 11]");
+}
+
+TEST(ranges_test, format_vector2) {
+  auto v = std::vector<std::vector<int>>{{1, 2}, {3, 5}, {7, 11}};
+  EXPECT_EQ(fmt::format("{}", v), "[[1, 2], [3, 5], [7, 11]]");
+}
+
+TEST(ranges_test, format_map) {
+  auto m = std::map<std::string, int>{{"one", 1}, {"two", 2}};
+  EXPECT_EQ(fmt::format("{}", m), "[(\"one\", 1), (\"two\", 2)]");
+}
+
+TEST(ranges_test, format_pair) {
+  auto p = std::pair<int, float>(42, 1.5f);
+  EXPECT_EQ(fmt::format("{}", p), "(42, 1.5)");
+}
+
+TEST(ranges_test, format_tuple) {
+  auto t =
+      std::tuple<int, float, std::string, char>(42, 1.5f, "this is tuple", 'i');
+  EXPECT_EQ(fmt::format("{}", t), "(42, 1.5, \"this is tuple\", 'i')");
+  EXPECT_EQ(fmt::format("{}", std::tuple<>()), "()");
+}
+
+#ifdef FMT_RANGES_TEST_ENABLE_FORMAT_STRUCT
+struct tuple_like {
+  int i;
+  std::string str;
+
+  template <size_t N> fmt::enable_if_t<N == 0, int> get() const noexcept {
+    return i;
+  }
+  template <size_t N>
+  fmt::enable_if_t<N == 1, fmt::string_view> get() const noexcept {
+    return str;
+  }
+};
+
+template <size_t N>
+auto get(const tuple_like& t) noexcept -> decltype(t.get<N>()) {
+  return t.get<N>();
+}
+
+namespace std {
+template <>
+struct tuple_size<tuple_like> : std::integral_constant<size_t, 2> {};
+
+template <size_t N> struct tuple_element<N, tuple_like> {
+  using type = decltype(std::declval<tuple_like>().get<N>());
+};
+}  // namespace std
+
+TEST(ranges_test, format_struct) {
+  auto t = tuple_like{42, "foo"};
+  EXPECT_EQ(fmt::format("{}", t), "(42, \"foo\")");
+}
+#endif  // FMT_RANGES_TEST_ENABLE_FORMAT_STRUCT
+
+TEST(ranges_test, format_to) {
+  char buf[10];
+  auto end = fmt::format_to(buf, "{}", std::vector<int>{1, 2, 3});
+  *end = '\0';
+  EXPECT_STREQ(buf, "[1, 2, 3]");
+}
+
+struct path_like {
+  const path_like* begin() const;
+  const path_like* end() const;
+
+  operator std::string() const;
+};
+
+TEST(ranges_test, path_like) {
+  EXPECT_FALSE((fmt::is_range<path_like, char>::value));
+}
+
+#ifdef FMT_USE_STRING_VIEW
+struct string_like {
+  const char* begin();
+  const char* end();
+  explicit operator fmt::string_view() const { return "foo"; }
+  explicit operator std::string_view() const { return "foo"; }
+};
+
+TEST(ranges_test, format_string_like) {
+  EXPECT_EQ(fmt::format("{}", string_like()), "foo");
+}
+#endif  // FMT_USE_STRING_VIEW
+
+// A range that provides non-const only begin()/end() to test fmt::join handles
+// that.
+//
+// Some ranges (e.g. those produced by range-v3's views::filter()) can cache
+// information during iteration so they only provide non-const begin()/end().
+template <typename T> class non_const_only_range {
+ private:
+  std::vector<T> vec;
+
+ public:
+  using const_iterator = typename ::std::vector<T>::const_iterator;
+
+  template <typename... Args>
+  explicit non_const_only_range(Args&&... args)
+      : vec(std::forward<Args>(args)...) {}
+
+  const_iterator begin() { return vec.begin(); }
+  const_iterator end() { return vec.end(); }
+};
+
+template <typename T> class noncopyable_range {
+ private:
+  std::vector<T> vec;
+
+ public:
+  using const_iterator = typename ::std::vector<T>::const_iterator;
+
+  template <typename... Args>
+  explicit noncopyable_range(Args&&... args)
+      : vec(std::forward<Args>(args)...) {}
+
+  noncopyable_range(noncopyable_range const&) = delete;
+  noncopyable_range(noncopyable_range&) = delete;
+
+  const_iterator begin() const { return vec.begin(); }
+  const_iterator end() const { return vec.end(); }
+};
+
+TEST(ranges_test, range) {
+  noncopyable_range<int> w(3u, 0);
+  EXPECT_EQ(fmt::format("{}", w), "[0, 0, 0]");
+  EXPECT_EQ(fmt::format("{}", noncopyable_range<int>(3u, 0)), "[0, 0, 0]");
+
+  non_const_only_range<int> x(3u, 0);
+  EXPECT_EQ(fmt::format("{}", x), "[0, 0, 0]");
+  EXPECT_EQ(fmt::format("{}", non_const_only_range<int>(3u, 0)), "[0, 0, 0]");
+
+  auto y = std::vector<int>(3u, 0);
+  EXPECT_EQ(fmt::format("{}", y), "[0, 0, 0]");
+  EXPECT_EQ(fmt::format("{}", std::vector<int>(3u, 0)), "[0, 0, 0]");
+
+  const auto z = std::vector<int>(3u, 0);
+  EXPECT_EQ(fmt::format("{}", z), "[0, 0, 0]");
+}
+
+#if !FMT_MSC_VER || FMT_MSC_VER >= 1927
+struct unformattable {};
+
+TEST(ranges_test, unformattable_range) {
+  EXPECT_FALSE((fmt::has_formatter<std::vector<unformattable>,
+                                   fmt::format_context>::value));
+}
+#endif
+
+#ifdef FMT_RANGES_TEST_ENABLE_JOIN
+TEST(ranges_test, join_tuple) {
+  // Value tuple args.
+  auto t1 = std::tuple<char, int, float>('a', 1, 2.0f);
+  EXPECT_EQ(fmt::format("({})", fmt::join(t1, ", ")), "(a, 1, 2)");
+
+  // Testing lvalue tuple args.
+  int x = 4;
+  auto t2 = std::tuple<char, int&>('b', x);
+  EXPECT_EQ(fmt::format("{}", fmt::join(t2, " + ")), "b + 4");
+
+  // Empty tuple.
+  auto t3 = std::tuple<>();
+  EXPECT_EQ(fmt::format("{}", fmt::join(t3, "|")), "");
+
+  // Single element tuple.
+  auto t4 = std::tuple<float>(4.0f);
+  EXPECT_EQ(fmt::format("{}", fmt::join(t4, "/")), "4");
+}
+
+TEST(ranges_test, join_initializer_list) {
+  EXPECT_EQ(fmt::format("{}", fmt::join({1, 2, 3}, ", ")), "1, 2, 3");
+  EXPECT_EQ(fmt::format("{}", fmt::join({"fmt", "rocks", "!"}, " ")),
+            "fmt rocks !");
+}
+
+struct zstring_sentinel {};
+
+bool operator==(const char* p, zstring_sentinel) { return *p == '\0'; }
+bool operator!=(const char* p, zstring_sentinel) { return *p != '\0'; }
+
+struct zstring {
+  const char* p;
+  const char* begin() const { return p; }
+  zstring_sentinel end() const { return {}; }
+};
+
+TEST(ranges_test, join_sentinel) {
+  auto hello = zstring{"hello"};
+  EXPECT_EQ(fmt::format("{}", hello), "['h', 'e', 'l', 'l', 'o']");
+  EXPECT_EQ(fmt::format("{}", fmt::join(hello, "_")), "h_e_l_l_o");
+}
+
+TEST(ranges_test, join_range) {
+  noncopyable_range<int> w(3u, 0);
+  EXPECT_EQ(fmt::format("{}", fmt::join(w, ",")), "0,0,0");
+  EXPECT_EQ(fmt::format("{}", fmt::join(noncopyable_range<int>(3u, 0), ",")),
+            "0,0,0");
+
+  non_const_only_range<int> x(3u, 0);
+  EXPECT_EQ(fmt::format("{}", fmt::join(x, ",")), "0,0,0");
+  EXPECT_EQ(fmt::format("{}", fmt::join(non_const_only_range<int>(3u, 0), ",")),
+            "0,0,0");
+
+  auto y = std::vector<int>(3u, 0);
+  EXPECT_EQ(fmt::format("{}", fmt::join(y, ",")), "0,0,0");
+  EXPECT_EQ(fmt::format("{}", fmt::join(std::vector<int>(3u, 0), ",")),
+            "0,0,0");
+
+  const auto z = std::vector<int>(3u, 0);
+  EXPECT_EQ(fmt::format("{}", fmt::join(z, ",")), "0,0,0");
+}
+#endif  // FMT_RANGES_TEST_ENABLE_JOIN

vendor/Fmt/test/scan-test.cc

@@ -0,0 +1,116 @@
+// Formatting library for C++ - scanning API test
+//
+// Copyright (c) 2019 - present, Victor Zverovich
+// All rights reserved.
+//
+// For the license information refer to format.h.
+
+#include "scan.h"
+
+#include <time.h>
+
+#include <climits>
+
+#include "gmock/gmock.h"
+#include "gtest-extra.h"
+
+TEST(scan_test, read_text) {
+  auto s = fmt::string_view("foo");
+  auto end = fmt::scan(s, "foo");
+  EXPECT_EQ(end, s.end());
+  EXPECT_THROW_MSG(fmt::scan("fob", "foo"), fmt::format_error, "invalid input");
+}
+
+TEST(scan_test, read_int) {
+  auto n = int();
+  fmt::scan("42", "{}", n);
+  EXPECT_EQ(n, 42);
+  fmt::scan("-42", "{}", n);
+  EXPECT_EQ(n, -42);
+}
+
+TEST(scan_test, read_longlong) {
+  long long n = 0;
+  fmt::scan("42", "{}", n);
+  EXPECT_EQ(n, 42);
+  fmt::scan("-42", "{}", n);
+  EXPECT_EQ(n, -42);
+}
+
+TEST(scan_test, read_uint) {
+  auto n = unsigned();
+  fmt::scan("42", "{}", n);
+  EXPECT_EQ(n, 42);
+  EXPECT_THROW_MSG(fmt::scan("-42", "{}", n), fmt::format_error,
+                   "invalid input");
+}
+
+TEST(scan_test, read_ulonglong) {
+  unsigned long long n = 0;
+  fmt::scan("42", "{}", n);
+  EXPECT_EQ(n, 42);
+  EXPECT_THROW_MSG(fmt::scan("-42", "{}", n), fmt::format_error,
+                   "invalid input");
+}
+
+TEST(scan_test, read_string) {
+  auto s = std::string();
+  fmt::scan("foo", "{}", s);
+  EXPECT_EQ(s, "foo");
+}
+
+TEST(scan_test, read_string_view) {
+  auto s = fmt::string_view();
+  fmt::scan("foo", "{}", s);
+  EXPECT_EQ(s, "foo");
+}
+
+#ifndef _WIN32
+namespace fmt {
+template <> struct scanner<tm> {
+  std::string format;
+
+  scan_parse_context::iterator parse(scan_parse_context& ctx) {
+    auto it = ctx.begin();
+    if (it != ctx.end() && *it == ':') ++it;
+    auto end = it;
+    while (end != ctx.end() && *end != '}') ++end;
+    format.reserve(detail::to_unsigned(end - it + 1));
+    format.append(it, end);
+    format.push_back('\0');
+    return end;
+  }
+
+  template <class ScanContext>
+  typename ScanContext::iterator scan(tm& t, ScanContext& ctx) {
+    auto result = strptime(ctx.begin(), format.c_str(), &t);
+    if (!result) throw format_error("failed to parse time");
+    return result;
+  }
+};
+}  // namespace fmt
+
+TEST(scan_test, read_custom) {
+  auto input = "Date: 1985-10-25";
+  auto t = tm();
+  fmt::scan(input, "Date: {0:%Y-%m-%d}", t);
+  EXPECT_EQ(t.tm_year, 85);
+  EXPECT_EQ(t.tm_mon, 9);
+  EXPECT_EQ(t.tm_mday, 25);
+}
+#endif
+
+TEST(scan_test, invalid_format) {
+  EXPECT_THROW_MSG(fmt::scan("", "{}"), fmt::format_error,
+                   "argument index out of range");
+  EXPECT_THROW_MSG(fmt::scan("", "{"), fmt::format_error,
+                   "invalid format string");
+}
+
+TEST(scan_test, example) {
+  auto key = std::string();
+  auto value = int();
+  fmt::scan("answer = 42", "{} = {}", key, value);
+  EXPECT_EQ(key, "answer");
+  EXPECT_EQ(value, 42);
+}

vendor/Fmt/test/scan.h

@@ -0,0 +1,241 @@
+// Formatting library for C++ - scanning API proof of concept
+//
+// Copyright (c) 2019 - present, Victor Zverovich
+// All rights reserved.
+//
+// For the license information refer to format.h.
+
+#include <array>
+#include <cassert>
+#include <climits>
+
+#include "fmt/format.h"
+
+FMT_BEGIN_NAMESPACE
+template <typename T, typename Char = char> struct scanner {
+  // A deleted default constructor indicates a disabled scanner.
+  scanner() = delete;
+};
+
+class scan_parse_context {
+ private:
+  string_view format_;
+
+ public:
+  using iterator = string_view::iterator;
+
+  explicit FMT_CONSTEXPR scan_parse_context(string_view format)
+      : format_(format) {}
+
+  FMT_CONSTEXPR iterator begin() const { return format_.begin(); }
+  FMT_CONSTEXPR iterator end() const { return format_.end(); }
+
+  void advance_to(iterator it) {
+    format_.remove_prefix(detail::to_unsigned(it - begin()));
+  }
+};
+
+struct scan_context {
+ private:
+  string_view input_;
+
+ public:
+  using iterator = const char*;
+
+  explicit scan_context(string_view input) : input_(input) {}
+
+  iterator begin() const { return input_.data(); }
+  iterator end() const { return begin() + input_.size(); }
+
+  void advance_to(iterator it) {
+    input_.remove_prefix(detail::to_unsigned(it - begin()));
+  }
+};
+
+namespace detail {
+enum class scan_type {
+  none_type,
+  int_type,
+  uint_type,
+  long_long_type,
+  ulong_long_type,
+  string_type,
+  string_view_type,
+  custom_type
+};
+
+struct custom_scan_arg {
+  void* value;
+  void (*scan)(void* arg, scan_parse_context& parse_ctx, scan_context& ctx);
+};
+
+class scan_arg {
+ public:
+  scan_type type;
+  union {
+    int* int_value;
+    unsigned* uint_value;
+    long long* long_long_value;
+    unsigned long long* ulong_long_value;
+    std::string* string;
+    fmt::string_view* string_view;
+    custom_scan_arg custom;
+    // TODO: more types
+  };
+
+  scan_arg() : type(scan_type::none_type) {}
+  scan_arg(int& value) : type(scan_type::int_type), int_value(&value) {}
+  scan_arg(unsigned& value) : type(scan_type::uint_type), uint_value(&value) {}
+  scan_arg(long long& value)
+      : type(scan_type::long_long_type), long_long_value(&value) {}
+  scan_arg(unsigned long long& value)
+      : type(scan_type::ulong_long_type), ulong_long_value(&value) {}
+  scan_arg(std::string& value) : type(scan_type::string_type), string(&value) {}
+  scan_arg(fmt::string_view& value)
+      : type(scan_type::string_view_type), string_view(&value) {}
+  template <typename T> scan_arg(T& value) : type(scan_type::custom_type) {
+    custom.value = &value;
+    custom.scan = scan_custom_arg<T>;
+  }
+
+ private:
+  template <typename T>
+  static void scan_custom_arg(void* arg, scan_parse_context& parse_ctx,
+                              scan_context& ctx) {
+    scanner<T> s;
+    parse_ctx.advance_to(s.parse(parse_ctx));
+    ctx.advance_to(s.scan(*static_cast<T*>(arg), ctx));
+  }
+};
+}  // namespace detail
+
+struct scan_args {
+  int size;
+  const detail::scan_arg* data;
+
+  template <size_t N>
+  scan_args(const std::array<detail::scan_arg, N>& store)
+      : size(N), data(store.data()) {
+    static_assert(N < INT_MAX, "too many arguments");
+  }
+};
+
+namespace detail {
+
+struct scan_handler : error_handler {
+ private:
+  scan_parse_context parse_ctx_;
+  scan_context scan_ctx_;
+  scan_args args_;
+  int next_arg_id_;
+  scan_arg arg_;
+
+  template <typename T = unsigned> T read_uint() {
+    T value = 0;
+    auto it = scan_ctx_.begin(), end = scan_ctx_.end();
+    while (it != end) {
+      char c = *it++;
+      if (c < '0' || c > '9') on_error("invalid input");
+      // TODO: check overflow
+      value = value * 10 + static_cast<unsigned>(c - '0');
+    }
+    scan_ctx_.advance_to(it);
+    return value;
+  }
+
+  template <typename T = int> T read_int() {
+    auto it = scan_ctx_.begin(), end = scan_ctx_.end();
+    bool negative = it != end && *it == '-';
+    if (negative) ++it;
+    scan_ctx_.advance_to(it);
+    const auto value = read_uint<typename std::make_unsigned<T>::type>();
+    if (negative) return -static_cast<T>(value);
+    return static_cast<T>(value);
+  }
+
+ public:
+  scan_handler(string_view format, string_view input, scan_args args)
+      : parse_ctx_(format), scan_ctx_(input), args_(args), next_arg_id_(0) {}
+
+  const char* pos() const { return scan_ctx_.begin(); }
+
+  void on_text(const char* begin, const char* end) {
+    auto size = to_unsigned(end - begin);
+    auto it = scan_ctx_.begin();
+    if (it + size > scan_ctx_.end() ||
+        !std::equal(begin, end, make_checked(it, size))) {
+      on_error("invalid input");
+    }
+    scan_ctx_.advance_to(it + size);
+  }
+
+  FMT_CONSTEXPR int on_arg_id() { return on_arg_id(next_arg_id_++); }
+  FMT_CONSTEXPR int on_arg_id(int id) {
+    if (id >= args_.size) on_error("argument index out of range");
+    arg_ = args_.data[id];
+    return id;
+  }
+  FMT_CONSTEXPR int on_arg_id(string_view id) {
+    if (id.data()) on_error("invalid format");
+    return 0;
+  }
+
+  void on_replacement_field(int, const char*) {
+    auto it = scan_ctx_.begin(), end = scan_ctx_.end();
+    switch (arg_.type) {
+    case scan_type::int_type:
+      *arg_.int_value = read_int();
+      break;
+    case scan_type::uint_type:
+      *arg_.uint_value = read_uint();
+      break;
+    case scan_type::long_long_type:
+      *arg_.long_long_value = read_int<long long>();
+      break;
+    case scan_type::ulong_long_type:
+      *arg_.ulong_long_value = read_uint<unsigned long long>();
+      break;
+    case scan_type::string_type:
+      while (it != end && *it != ' ') arg_.string->push_back(*it++);
+      scan_ctx_.advance_to(it);
+      break;
+    case scan_type::string_view_type: {
+      auto s = it;
+      while (it != end && *it != ' ') ++it;
+      *arg_.string_view = fmt::string_view(s, to_unsigned(it - s));
+      scan_ctx_.advance_to(it);
+      break;
+    }
+    case scan_type::none_type:
+    case scan_type::custom_type:
+      assert(false);
+    }
+  }
+
+  const char* on_format_specs(int, const char* begin, const char*) {
+    if (arg_.type != scan_type::custom_type) return begin;
+    parse_ctx_.advance_to(begin);
+    arg_.custom.scan(arg_.custom.value, parse_ctx_, scan_ctx_);
+    return parse_ctx_.begin();
+  }
+};
+}  // namespace detail
+
+template <typename... Args>
+std::array<detail::scan_arg, sizeof...(Args)> make_scan_args(Args&... args) {
+  return {{args...}};
+}
+
+string_view::iterator vscan(string_view input, string_view format_str,
+                            scan_args args) {
+  detail::scan_handler h(format_str, input, args);
+  detail::parse_format_string<false>(format_str, h);
+  return input.begin() + (h.pos() - &*input.begin());
+}
+
+template <typename... Args>
+string_view::iterator scan(string_view input, string_view format_str,
+                           Args&... args) {
+  return vscan(input, format_str, make_scan_args(args...));
+}
+FMT_END_NAMESPACE

vendor/Fmt/test/static-export-test/CMakeLists.txt

@@ -0,0 +1,30 @@
+cmake_minimum_required(VERSION 3.1...3.18)
+
+project(fmt-link CXX)
+
+set(BUILD_SHARED_LIBS OFF)
+set(CMAKE_VISIBILITY_INLINES_HIDDEN TRUE)
+set(CMAKE_CXX_VISIBILITY_PRESET "hidden")
+
+# Broken LTO on GCC 4
+if (CMAKE_COMPILER_IS_GNUCXX AND CMAKE_CXX_COMPILER_VERSION VERSION_LESS 5)
+  set(BROKEN_LTO ON)
+endif ()
+
+if (NOT BROKEN_LTO AND CMAKE_VERSION VERSION_GREATER "3.8")
+  # CMake 3.9+
+  include(CheckIPOSupported)
+  check_ipo_supported(RESULT HAVE_IPO)
+  if (HAVE_IPO)
+    set(CMAKE_INTERPROCEDURAL_OPTIMIZATION TRUE)
+  endif ()
+endif ()
+
+add_subdirectory(../.. fmt)
+set_property(TARGET fmt PROPERTY POSITION_INDEPENDENT_CODE ON)
+
+add_library(library-test SHARED library.cc)
+target_link_libraries(library-test PRIVATE fmt::fmt)
+
+add_executable(exe-test main.cc)
+target_link_libraries(exe-test PRIVATE library-test)

vendor/Fmt/test/static-export-test/library.cc

@@ -0,0 +1,5 @@
+#include <fmt/compile.h>
+
+__attribute__((visibility("default"))) std::string foo() {
+  return fmt::format(FMT_COMPILE("foo bar {}"), 4242);
+}

vendor/Fmt/test/static-export-test/main.cc

@@ -0,0 +1,6 @@
+#include <iostream>
+#include <string>
+
+extern std::string foo();
+
+int main() { std::cout << foo() << std::endl; }

vendor/Fmt/test/std-format-test.cc

@@ -0,0 +1,161 @@
+#include <format>
+
+#include "gtest/gtest.h"
+
+TEST(std_format_test, escaping) {
+  using namespace std;
+  string s = format("{0}-{{", 8);  // s == "8-{"
+  EXPECT_EQ(s, "8-{");
+}
+
+TEST(std_format_test, indexing) {
+  using namespace std;
+  string s0 = format("{} to {}", "a", "b");    // OK: automatic indexing
+  string s1 = format("{1} to {0}", "a", "b");  // OK: manual indexing
+  EXPECT_EQ(s0, "a to b");
+  EXPECT_EQ(s1, "b to a");
+  // Error: mixing automatic and manual indexing
+  EXPECT_THROW(string s2 = format("{0} to {}", "a", "b"), std::format_error);
+  // Error: mixing automatic and manual indexing
+  EXPECT_THROW(string s3 = format("{} to {1}", "a", "b"), std::format_error);
+}
+
+TEST(std_format_test, alignment) {
+  using namespace std;
+  char c = 120;
+  string s0 = format("{:6}", 42);     // s0 == "    42"
+  string s1 = format("{:6}", 'x');    // s1 == "x     "
+  string s2 = format("{:*<6}", 'x');  // s2 == "x*****"
+  string s3 = format("{:*>6}", 'x');  // s3 == "*****x"
+  string s4 = format("{:*^6}", 'x');  // s4 == "**x***"
+  // Error: '=' with charT and no integer presentation type
+  EXPECT_THROW(string s5 = format("{:=6}", 'x'), std::format_error);
+  string s6 = format("{:6d}", c);    // s6 == "   120"
+  string s7 = format("{:6}", true);  // s9 == "true  "
+  EXPECT_EQ(s0, "    42");
+  EXPECT_EQ(s1, "x     ");
+  EXPECT_EQ(s2, "x*****");
+  EXPECT_EQ(s3, "*****x");
+  EXPECT_EQ(s4, "**x***");
+  EXPECT_EQ(s6, "   120");
+  EXPECT_EQ(s7, "true  ");
+}
+
+TEST(std_format_test, float) {
+  using namespace std;
+  double inf = numeric_limits<double>::infinity();
+  double nan = numeric_limits<double>::quiet_NaN();
+  string s0 = format("{0:} {0:+} {0:-} {0: }", 1);   // s0 == "1 +1 1  1"
+  string s1 = format("{0:} {0:+} {0:-} {0: }", -1);  // s1 == "-1 -1 -1 -1"
+  string s2 =
+      format("{0:} {0:+} {0:-} {0: }", inf);  // s2 == "inf +inf inf  inf"
+  string s3 =
+      format("{0:} {0:+} {0:-} {0: }", nan);  // s3 == "nan +nan nan  nan"
+  EXPECT_EQ(s0, "1 +1 1  1");
+  EXPECT_EQ(s1, "-1 -1 -1 -1");
+  EXPECT_EQ(s2, "inf +inf inf  inf");
+  EXPECT_EQ(s3, "nan +nan nan  nan");
+}
+
+TEST(std_format_test, int) {
+  using namespace std;
+  string s0 = format("{}", 42);                       // s0 == "42"
+  string s1 = format("{0:b} {0:d} {0:o} {0:x}", 42);  // s1 == "101010 42 52 2a"
+  string s2 = format("{0:#x} {0:#X}", 42);            // s2 == "0x2a 0X2A"
+  string s3 = format("{:L}", 1234);  // s3 == "1234" (depends on the locale)
+  EXPECT_EQ(s0, "42");
+  EXPECT_EQ(s1, "101010 42 52 2a");
+  EXPECT_EQ(s2, "0x2a 0X2A");
+  EXPECT_EQ(s3, "1234");
+}
+
+#include <format>
+
+enum color { red, green, blue };
+
+const char* color_names[] = {"red", "green", "blue"};
+
+template <> struct std::formatter<color> : std::formatter<const char*> {
+  auto format(color c, format_context& ctx) {
+    return formatter<const char*>::format(color_names[c], ctx);
+  }
+};
+
+struct err {};
+
+TEST(std_format_test, formatter) {
+  std::string s0 = std::format("{}", 42);  // OK: library-provided formatter
+  // std::string s1 = std::format("{}", L"foo"); // Ill-formed: disabled
+  // formatter
+  std::string s2 = std::format("{}", red);  // OK: user-provided formatter
+  // std::string s3 = std::format("{}", err{});  // Ill-formed: disabled
+  // formatter
+  EXPECT_EQ(s0, "42");
+  EXPECT_EQ(s2, "red");
+}
+
+struct S {
+  int value;
+};
+
+template <> struct std::formatter<S> {
+  size_t width_arg_id = 0;
+
+  // Parses a width argument id in the format { <digit> }.
+  constexpr auto parse(format_parse_context& ctx) {
+    constexpr auto is_ascii_digit = [](const char c) {
+      return c >= '0' && c <= '9';
+    };
+
+    auto iter = ctx.begin();
+    // auto get_char = [&]() { return iter != ctx.end() ? *iter : 0; };
+    auto get_char = [&]() { return iter != ctx.end() ? *iter : '\0'; };
+    if (get_char() != '{') return iter;
+    ++iter;
+    char c = get_char();
+    if (!is_ascii_digit(c) || (++iter, get_char()) != '}')
+      throw format_error("invalid format");
+    width_arg_id = fmt::detail::to_unsigned(c - '0');
+    ctx.check_arg_id(width_arg_id);
+    return ++iter;
+  }
+
+  // Formats S with width given by the argument width_arg_id.
+  auto format(S s, format_context& ctx) {
+    int width = visit_format_arg(
+        [](auto value) -> int {
+          using type = decltype(value);
+          if constexpr (!is_integral_v<type> || is_same_v<type, bool>)
+            throw format_error("width is not integral");
+          // else if (value < 0 || value > numeric_limits<int>::max())
+          else if (fmt::detail::is_negative(value) ||
+                   value > numeric_limits<int>::max())
+            throw format_error("invalid width");
+          else
+            return static_cast<int>(value);
+        },
+        ctx.arg(width_arg_id));
+    return format_to(ctx.out(), "{0:{1}}", s.value, width);
+  }
+};
+
+TEST(std_format_test, parsing) {
+  std::string s = std::format("{0:{1}}", S{42}, 10);  // s == "        42"
+  EXPECT_EQ(s, "        42");
+}
+
+#if FMT_USE_INT128
+template <> struct std::formatter<__int128_t> : std::formatter<long long> {
+  auto format(__int128_t n, format_context& ctx) {
+    // Format as a long long since we only want to check if it is possible to
+    // specialize formatter for __int128_t.
+    return formatter<long long>::format(static_cast<long long>(n), ctx);
+  }
+};
+
+TEST(std_format_test, int128) {
+  __int128_t n = 42;
+  auto s = std::format("{}", n);
+  EXPECT_EQ(s, "42");
+}
+#endif  // FMT_USE_INT128

vendor/Fmt/test/test-assert.h

@@ -0,0 +1,39 @@
+// Formatting library for C++ - test version of FMT_ASSERT
+//
+// Copyright (c) 2012 - present, Victor Zverovich
+// All rights reserved.
+//
+// For the license information refer to format.h.
+
+#ifndef FMT_TEST_ASSERT_H_
+#define FMT_TEST_ASSERT_H_
+
+#include <stdexcept>
+
+void throw_assertion_failure(const char* message);
+#define FMT_ASSERT(condition, message) \
+  if (!(condition)) throw_assertion_failure(message);
+
+#include "gtest/gtest.h"
+
+class assertion_failure : public std::logic_error {
+ public:
+  explicit assertion_failure(const char* message) : std::logic_error(message) {}
+
+ private:
+  virtual void avoid_weak_vtable();
+};
+
+void assertion_failure::avoid_weak_vtable() {}
+
+// We use a separate function (rather than throw directly from FMT_ASSERT) to
+// avoid GCC's -Wterminate warning when FMT_ASSERT is used in a destructor.
+inline void throw_assertion_failure(const char* message) {
+  throw assertion_failure(message);
+}
+
+// Expects an assertion failure.
+#define EXPECT_ASSERT(stmt, message) \
+  FMT_TEST_THROW_(stmt, assertion_failure, message, GTEST_NONFATAL_FAILURE_)
+
+#endif  // FMT_TEST_ASSERT_H_

vendor/Fmt/test/test-main.cc

@@ -0,0 +1,43 @@
+// Formatting library for C++ - test main function.
+//
+// Copyright (c) 2012 - present, Victor Zverovich
+// All rights reserved.
+//
+// For the license information refer to format.h.
+
+#include <cstdlib>
+
+#include "gtest/gtest.h"
+
+#ifdef _WIN32
+#  include <windows.h>
+#endif
+
+#ifdef _MSC_VER
+#  include <crtdbg.h>
+#else
+#  define _CrtSetReportFile(a, b)
+#  define _CrtSetReportMode(a, b)
+#endif
+
+int main(int argc, char** argv) {
+#ifdef _WIN32
+  // Don't display any error dialogs. This also suppresses message boxes
+  // on assertion failures in MinGW where _set_error_mode/CrtSetReportMode
+  // doesn't help.
+  SetErrorMode(SEM_FAILCRITICALERRORS | SEM_NOGPFAULTERRORBOX |
+               SEM_NOOPENFILEERRORBOX);
+#endif
+  // Disable message boxes on assertion failures.
+  _CrtSetReportMode(_CRT_ERROR, _CRTDBG_MODE_FILE | _CRTDBG_MODE_DEBUG);
+  _CrtSetReportFile(_CRT_ERROR, _CRTDBG_FILE_STDERR);
+  _CrtSetReportMode(_CRT_ASSERT, _CRTDBG_MODE_FILE | _CRTDBG_MODE_DEBUG);
+  _CrtSetReportFile(_CRT_ASSERT, _CRTDBG_FILE_STDERR);
+  try {
+    testing::InitGoogleTest(&argc, argv);
+    return RUN_ALL_TESTS();
+  } catch (...) {
+    // Catch all exceptions to make Coverity happy.
+  }
+  return EXIT_FAILURE;
+}

vendor/Fmt/test/unicode-test.cc

@@ -0,0 +1,48 @@
+// Formatting library for C++ - Unicode tests
+//
+// Copyright (c) 2012 - present, Victor Zverovich
+// All rights reserved.
+//
+// For the license information refer to format.h.
+
+#include <iomanip>
+#include <locale>
+#include <vector>
+
+#include "fmt/chrono.h"
+#include "gmock/gmock.h"
+#include "util.h"  // get_locale
+
+using testing::Contains;
+
+TEST(unicode_test, is_utf8) { EXPECT_TRUE(fmt::detail::is_utf8()); }
+
+TEST(unicode_test, legacy_locale) {
+  auto loc = get_locale("ru_RU.CP1251", "Russian.1251");
+  if (loc == std::locale::classic()) return;
+
+  auto s = std::string();
+  try {
+    s = fmt::format(loc, "День недели: {:L}", fmt::weekday(1));
+  } catch (const fmt::format_error& e) {
+    // Formatting can fail due to an unsupported encoding.
+    fmt::print("Format error: {}\n", e.what());
+    return;
+  }
+
+#if !FMT_GCC_VERSION || FMT_GCC_VERSION >= 500
+  auto&& os = std::ostringstream();
+  os.imbue(loc);
+  auto tm = std::tm();
+  tm.tm_wday = 1;
+  os << std::put_time(&tm, "%a");
+  auto wd = os.str();
+  if (wd == "??") {
+    EXPECT_EQ(s, "День недели: ??");
+    fmt::print("std::locale gives ?? as a weekday.\n");
+    return;
+  }
+#endif
+  EXPECT_THAT((std::vector<std::string>{"День недели: пн", "День недели: Пн"}),
+              Contains(s));
+}

vendor/Fmt/test/util.cc

@@ -0,0 +1,46 @@
+// Formatting library for C++ - test utilities
+//
+// Copyright (c) 2012 - present, Victor Zverovich
+// All rights reserved.
+//
+// For the license information refer to format.h.
+
+#include "util.h"
+
+#include <cstring>
+
+const char* const file_content = "Don't panic!";
+
+fmt::buffered_file open_buffered_file(FILE** fp) {
+#if FMT_USE_FCNTL
+  fmt::file read_end, write_end;
+  fmt::file::pipe(read_end, write_end);
+  write_end.write(file_content, std::strlen(file_content));
+  write_end.close();
+  fmt::buffered_file f = read_end.fdopen("r");
+  if (fp) *fp = f.get();
+#else
+  fmt::buffered_file f("test-file", "w");
+  fputs(file_content, f.get());
+  if (fp) *fp = f.get();
+#endif
+  return f;
+}
+
+std::locale do_get_locale(const char* name) {
+  try {
+    return std::locale(name);
+  } catch (const std::runtime_error&) {
+  }
+  return std::locale::classic();
+}
+
+std::locale get_locale(const char* name, const char* alt_name) {
+  auto loc = do_get_locale(name);
+  if (loc == std::locale::classic() && alt_name) {
+    loc = do_get_locale(alt_name);
+  }
+  if (loc == std::locale::classic())
+    fmt::print(stderr, "{} locale is missing.\n", name);
+  return loc;
+}

vendor/Fmt/test/util.h

@@ -0,0 +1,81 @@
+// Formatting library for C++ - test utilities
+//
+// Copyright (c) 2012 - present, Victor Zverovich
+// All rights reserved.
+//
+// For the license information refer to format.h.
+
+#include <cstdarg>
+#include <cstdio>
+#include <locale>
+#include <string>
+
+#include "fmt/os.h"
+
+#ifdef _MSC_VER
+#  define FMT_VSNPRINTF vsprintf_s
+#else
+#  define FMT_VSNPRINTF vsnprintf
+#endif
+
+template <size_t SIZE>
+void safe_sprintf(char (&buffer)[SIZE], const char* format, ...) {
+  std::va_list args;
+  va_start(args, format);
+  FMT_VSNPRINTF(buffer, SIZE, format, args);
+  va_end(args);
+}
+
+extern const char* const file_content;
+
+// Opens a buffered file for reading.
+fmt::buffered_file open_buffered_file(FILE** fp = nullptr);
+
+inline FILE* safe_fopen(const char* filename, const char* mode) {
+#if defined(_WIN32) && !defined(__MINGW32__)
+  // Fix MSVC warning about "unsafe" fopen.
+  FILE* f = 0;
+  errno = fopen_s(&f, filename, mode);
+  return f;
+#else
+  return std::fopen(filename, mode);
+#endif
+}
+
+template <typename Char> class basic_test_string {
+ private:
+  std::basic_string<Char> value_;
+
+  static const Char empty[];
+
+ public:
+  explicit basic_test_string(const Char* value = empty) : value_(value) {}
+
+  const std::basic_string<Char>& value() const { return value_; }
+};
+
+template <typename Char> const Char basic_test_string<Char>::empty[] = {0};
+
+typedef basic_test_string<char> test_string;
+typedef basic_test_string<wchar_t> test_wstring;
+
+template <typename Char>
+std::basic_ostream<Char>& operator<<(std::basic_ostream<Char>& os,
+                                     const basic_test_string<Char>& s) {
+  os << s.value();
+  return os;
+}
+
+class date {
+  int year_, month_, day_;
+
+ public:
+  date(int year, int month, int day) : year_(year), month_(month), day_(day) {}
+
+  int year() const { return year_; }
+  int month() const { return month_; }
+  int day() const { return day_; }
+};
+
+// Returns a locale with the given name if available or classic locale othewise.
+std::locale get_locale(const char* name, const char* alt_name = nullptr);

vendor/Fmt/test/xchar-test.cc

@@ -0,0 +1,427 @@
+// 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 "fmt/xchar.h"
+
+#include <complex>
+
+#include "fmt/chrono.h"
+#include "fmt/color.h"
+#include "fmt/ostream.h"
+#include "fmt/ranges.h"
+#include "gtest/gtest.h"
+
+using fmt::detail::max_value;
+
+namespace test_ns {
+template <typename Char> class test_string {
+ private:
+  std::basic_string<Char> s_;
+
+ public:
+  test_string(const Char* s) : s_(s) {}
+  const Char* data() const { return s_.data(); }
+  size_t length() const { return s_.size(); }
+  operator const Char*() const { return s_.c_str(); }
+};
+
+template <typename Char>
+fmt::basic_string_view<Char> to_string_view(const test_string<Char>& s) {
+  return {s.data(), s.length()};
+}
+
+struct non_string {};
+}  // namespace test_ns
+
+template <typename T> class is_string_test : public testing::Test {};
+
+using string_char_types = testing::Types<char, wchar_t, char16_t, char32_t>;
+TYPED_TEST_SUITE(is_string_test, string_char_types);
+
+template <typename Char>
+struct derived_from_string_view : fmt::basic_string_view<Char> {};
+
+TYPED_TEST(is_string_test, is_string) {
+  EXPECT_TRUE(fmt::detail::is_string<TypeParam*>::value);
+  EXPECT_TRUE(fmt::detail::is_string<const TypeParam*>::value);
+  EXPECT_TRUE(fmt::detail::is_string<TypeParam[2]>::value);
+  EXPECT_TRUE(fmt::detail::is_string<const TypeParam[2]>::value);
+  EXPECT_TRUE(fmt::detail::is_string<std::basic_string<TypeParam>>::value);
+  EXPECT_TRUE(fmt::detail::is_string<fmt::basic_string_view<TypeParam>>::value);
+  EXPECT_TRUE(
+      fmt::detail::is_string<derived_from_string_view<TypeParam>>::value);
+  using fmt_string_view = fmt::detail::std_string_view<TypeParam>;
+  EXPECT_TRUE(std::is_empty<fmt_string_view>::value !=
+              fmt::detail::is_string<fmt_string_view>::value);
+  EXPECT_TRUE(fmt::detail::is_string<test_ns::test_string<TypeParam>>::value);
+  EXPECT_FALSE(fmt::detail::is_string<test_ns::non_string>::value);
+}
+
+// std::is_constructible is broken in MSVC until version 2015.
+#if !FMT_MSC_VER || FMT_MSC_VER >= 1900
+struct explicitly_convertible_to_wstring_view {
+  explicit operator fmt::wstring_view() const { return L"foo"; }
+};
+
+TEST(xchar_test, format_explicitly_convertible_to_wstring_view) {
+  EXPECT_EQ(L"foo",
+            fmt::format(L"{}", explicitly_convertible_to_wstring_view()));
+}
+#endif
+
+TEST(xchar_test, format) {
+  EXPECT_EQ(L"42", fmt::format(L"{}", 42));
+  EXPECT_EQ(L"4.2", fmt::format(L"{}", 4.2));
+  EXPECT_EQ(L"abc", fmt::format(L"{}", L"abc"));
+  EXPECT_EQ(L"z", fmt::format(L"{}", L'z'));
+  EXPECT_THROW(fmt::format(L"{:*\x343E}", 42), fmt::format_error);
+  EXPECT_EQ(L"true", fmt::format(L"{}", true));
+  EXPECT_EQ(L"a", fmt::format(L"{0}", 'a'));
+  EXPECT_EQ(L"a", fmt::format(L"{0}", L'a'));
+  EXPECT_EQ(L"Cyrillic letter \x42e",
+            fmt::format(L"Cyrillic letter {}", L'\x42e'));
+  EXPECT_EQ(L"abc1", fmt::format(L"{}c{}", L"ab", 1));
+}
+
+TEST(xchar_test, compile_time_string) {
+#if defined(FMT_USE_STRING_VIEW) && __cplusplus >= 201703L
+  EXPECT_EQ(L"42", fmt::format(FMT_STRING(std::wstring_view(L"{}")), 42));
+#endif
+}
+
+#if __cplusplus > 201103L
+struct custom_char {
+  int value;
+  custom_char() = default;
+
+  template <typename T>
+  constexpr custom_char(T val) : value(static_cast<int>(val)) {}
+
+  operator int() const { return value; }
+};
+
+int to_ascii(custom_char c) { return c; }
+
+FMT_BEGIN_NAMESPACE
+template <> struct is_char<custom_char> : std::true_type {};
+FMT_END_NAMESPACE
+
+TEST(xchar_test, format_custom_char) {
+  const custom_char format[] = {'{', '}', 0};
+  auto result = fmt::format(format, custom_char('x'));
+  EXPECT_EQ(result.size(), 1);
+  EXPECT_EQ(result[0], custom_char('x'));
+}
+#endif
+
+// Convert a char8_t string to std::string. Otherwise GTest will insist on
+// inserting `char8_t` NTBS into a `char` stream which is disabled by P1423.
+template <typename S> std::string from_u8str(const S& str) {
+  return std::string(str.begin(), str.end());
+}
+
+TEST(xchar_test, format_utf8_precision) {
+  using str_type = std::basic_string<fmt::detail::char8_type>;
+  auto format =
+      str_type(reinterpret_cast<const fmt::detail::char8_type*>(u8"{:.4}"));
+  auto str = str_type(reinterpret_cast<const fmt::detail::char8_type*>(
+      u8"caf\u00e9s"));  // cafés
+  auto result = fmt::format(format, str);
+  EXPECT_EQ(fmt::detail::compute_width(result), 4);
+  EXPECT_EQ(result.size(), 5);
+  EXPECT_EQ(from_u8str(result), from_u8str(str.substr(0, 5)));
+}
+
+TEST(xchar_test, format_to) {
+  auto buf = std::vector<wchar_t>();
+  fmt::format_to(std::back_inserter(buf), L"{}{}", 42, L'\0');
+  EXPECT_STREQ(buf.data(), L"42");
+}
+
+TEST(xchar_test, vformat_to) {
+  using wcontext = fmt::wformat_context;
+  fmt::basic_format_arg<wcontext> warg = fmt::detail::make_arg<wcontext>(42);
+  auto wargs = fmt::basic_format_args<wcontext>(&warg, 1);
+  auto w = std::wstring();
+  fmt::vformat_to(std::back_inserter(w), L"{}", wargs);
+  EXPECT_EQ(L"42", w);
+  w.clear();
+  fmt::vformat_to(std::back_inserter(w), FMT_STRING(L"{}"), wargs);
+  EXPECT_EQ(L"42", w);
+}
+
+TEST(format_test, wide_format_to_n) {
+  wchar_t buffer[4];
+  buffer[3] = L'x';
+  auto result = fmt::format_to_n(buffer, 3, L"{}", 12345);
+  EXPECT_EQ(5u, result.size);
+  EXPECT_EQ(buffer + 3, result.out);
+  EXPECT_EQ(L"123x", fmt::wstring_view(buffer, 4));
+  buffer[0] = L'x';
+  buffer[1] = L'x';
+  buffer[2] = L'x';
+  result = fmt::format_to_n(buffer, 3, L"{}", L'A');
+  EXPECT_EQ(1u, result.size);
+  EXPECT_EQ(buffer + 1, result.out);
+  EXPECT_EQ(L"Axxx", fmt::wstring_view(buffer, 4));
+  result = fmt::format_to_n(buffer, 3, L"{}{} ", L'B', L'C');
+  EXPECT_EQ(3u, result.size);
+  EXPECT_EQ(buffer + 3, result.out);
+  EXPECT_EQ(L"BC x", fmt::wstring_view(buffer, 4));
+}
+
+#if FMT_USE_USER_DEFINED_LITERALS
+TEST(xchar_test, format_udl) {
+  using namespace fmt::literals;
+  EXPECT_EQ(L"{}c{}"_format(L"ab", 1), fmt::format(L"{}c{}", L"ab", 1));
+}
+
+TEST(xchar_test, named_arg_udl) {
+  using namespace fmt::literals;
+  auto udl_a =
+      fmt::format(L"{first}{second}{first}{third}", L"first"_a = L"abra",
+                  L"second"_a = L"cad", L"third"_a = 99);
+  EXPECT_EQ(
+      fmt::format(L"{first}{second}{first}{third}", fmt::arg(L"first", L"abra"),
+                  fmt::arg(L"second", L"cad"), fmt::arg(L"third", 99)),
+      udl_a);
+}
+#endif  // FMT_USE_USER_DEFINED_LITERALS
+
+TEST(xchar_test, print) {
+  // Check that the wide print overload compiles.
+  if (fmt::detail::const_check(false)) fmt::print(L"test");
+}
+
+TEST(xchar_test, join) {
+  int v[3] = {1, 2, 3};
+  EXPECT_EQ(fmt::format(L"({})", fmt::join(v, v + 3, L", ")), L"(1, 2, 3)");
+  auto t = std::tuple<wchar_t, int, float>('a', 1, 2.0f);
+  EXPECT_EQ(fmt::format(L"({})", fmt::join(t, L", ")), L"(a, 1, 2)");
+}
+
+enum streamable_enum {};
+
+std::wostream& operator<<(std::wostream& os, streamable_enum) {
+  return os << L"streamable_enum";
+}
+
+enum unstreamable_enum {};
+
+TEST(xchar_test, enum) {
+  EXPECT_EQ(L"streamable_enum", fmt::format(L"{}", streamable_enum()));
+  EXPECT_EQ(L"0", fmt::format(L"{}", unstreamable_enum()));
+}
+
+TEST(xchar_test, sign_not_truncated) {
+  wchar_t format_str[] = {
+      L'{', L':',
+      '+' | static_cast<wchar_t>(1 << fmt::detail::num_bits<char>()), L'}', 0};
+  EXPECT_THROW(fmt::format(format_str, 42), fmt::format_error);
+}
+
+namespace fake_qt {
+class QString {
+ public:
+  QString(const wchar_t* s) : s_(s) {}
+  const wchar_t* utf16() const FMT_NOEXCEPT { return s_.data(); }
+  int size() const FMT_NOEXCEPT { return static_cast<int>(s_.size()); }
+
+ private:
+  std::wstring s_;
+};
+
+fmt::basic_string_view<wchar_t> to_string_view(const QString& s) FMT_NOEXCEPT {
+  return {s.utf16(), static_cast<size_t>(s.size())};
+}
+}  // namespace fake_qt
+
+TEST(format_test, format_foreign_strings) {
+  using fake_qt::QString;
+  EXPECT_EQ(fmt::format(QString(L"{}"), 42), L"42");
+  EXPECT_EQ(fmt::format(QString(L"{}"), QString(L"42")), L"42");
+}
+
+TEST(xchar_test, chrono) {
+  auto tm = std::tm();
+  tm.tm_year = 116;
+  tm.tm_mon = 3;
+  tm.tm_mday = 25;
+  tm.tm_hour = 11;
+  tm.tm_min = 22;
+  tm.tm_sec = 33;
+  EXPECT_EQ(fmt::format("The date is {:%Y-%m-%d %H:%M:%S}.", tm),
+            "The date is 2016-04-25 11:22:33.");
+  EXPECT_EQ(L"42s", fmt::format(L"{}", std::chrono::seconds(42)));
+}
+
+TEST(xchar_test, color) {
+  EXPECT_EQ(fmt::format(fg(fmt::rgb(255, 20, 30)), L"rgb(255,20,30) wide"),
+            L"\x1b[38;2;255;020;030mrgb(255,20,30) wide\x1b[0m");
+}
+
+TEST(xchar_test, ostream) {
+  std::wostringstream wos;
+  fmt::print(wos, L"Don't {}!", L"panic");
+  EXPECT_EQ(L"Don't panic!", wos.str());
+}
+
+TEST(xchar_test, to_wstring) { EXPECT_EQ(L"42", fmt::to_wstring(42)); }
+
+#ifndef FMT_STATIC_THOUSANDS_SEPARATOR
+template <typename Char> struct numpunct : std::numpunct<Char> {
+ protected:
+  Char do_decimal_point() const override { return '?'; }
+  std::string do_grouping() const override { return "\03"; }
+  Char do_thousands_sep() const override { return '~'; }
+};
+
+template <typename Char> struct no_grouping : std::numpunct<Char> {
+ protected:
+  Char do_decimal_point() const override { return '.'; }
+  std::string do_grouping() const override { return ""; }
+  Char do_thousands_sep() const override { return ','; }
+};
+
+template <typename Char> struct special_grouping : std::numpunct<Char> {
+ protected:
+  Char do_decimal_point() const override { return '.'; }
+  std::string do_grouping() const override { return "\03\02"; }
+  Char do_thousands_sep() const override { return ','; }
+};
+
+template <typename Char> struct small_grouping : std::numpunct<Char> {
+ protected:
+  Char do_decimal_point() const override { return '.'; }
+  std::string do_grouping() const override { return "\01"; }
+  Char do_thousands_sep() const override { return ','; }
+};
+
+TEST(locale_test, double_decimal_point) {
+  auto loc = std::locale(std::locale(), new numpunct<char>());
+  EXPECT_EQ("1?23", fmt::format(loc, "{:L}", 1.23));
+  EXPECT_EQ("1?230000", fmt::format(loc, "{:Lf}", 1.23));
+}
+
+TEST(locale_test, format) {
+  auto loc = std::locale(std::locale(), new numpunct<char>());
+  EXPECT_EQ("1234567", fmt::format(std::locale(), "{:L}", 1234567));
+  EXPECT_EQ("1~234~567", fmt::format(loc, "{:L}", 1234567));
+  EXPECT_EQ("-1~234~567", fmt::format(loc, "{:L}", -1234567));
+  EXPECT_EQ("-256", fmt::format(loc, "{:L}", -256));
+  fmt::format_arg_store<fmt::format_context, int> as{1234567};
+  EXPECT_EQ("1~234~567", fmt::vformat(loc, "{:L}", fmt::format_args(as)));
+  auto s = std::string();
+  fmt::format_to(std::back_inserter(s), loc, "{:L}", 1234567);
+  EXPECT_EQ("1~234~567", s);
+
+  auto no_grouping_loc = std::locale(std::locale(), new no_grouping<char>());
+  EXPECT_EQ("1234567", fmt::format(no_grouping_loc, "{:L}", 1234567));
+
+  auto special_grouping_loc =
+      std::locale(std::locale(), new special_grouping<char>());
+  EXPECT_EQ("1,23,45,678", fmt::format(special_grouping_loc, "{:L}", 12345678));
+  EXPECT_EQ("12,345", fmt::format(special_grouping_loc, "{:L}", 12345));
+
+  auto small_grouping_loc =
+      std::locale(std::locale(), new small_grouping<char>());
+  EXPECT_EQ("4,2,9,4,9,6,7,2,9,5",
+            fmt::format(small_grouping_loc, "{:L}", max_value<uint32_t>()));
+}
+
+TEST(locale_test, format_detault_align) {
+  auto loc = std::locale({}, new special_grouping<char>());
+  EXPECT_EQ("  12,345", fmt::format(loc, "{:8L}", 12345));
+}
+
+TEST(locale_test, format_plus) {
+  auto loc = std::locale({}, new special_grouping<char>());
+  EXPECT_EQ("+100", fmt::format(loc, "{:+L}", 100));
+}
+
+TEST(locale_test, wformat) {
+  auto loc = std::locale(std::locale(), new numpunct<wchar_t>());
+  EXPECT_EQ(L"1234567", fmt::format(std::locale(), L"{:L}", 1234567));
+  EXPECT_EQ(L"1~234~567", fmt::format(loc, L"{:L}", 1234567));
+  using wcontext = fmt::buffer_context<wchar_t>;
+  fmt::format_arg_store<wcontext, int> as{1234567};
+  EXPECT_EQ(L"1~234~567",
+            fmt::vformat(loc, L"{:L}", fmt::basic_format_args<wcontext>(as)));
+  EXPECT_EQ(L"1234567", fmt::format(std::locale("C"), L"{:L}", 1234567));
+
+  auto no_grouping_loc = std::locale(std::locale(), new no_grouping<wchar_t>());
+  EXPECT_EQ(L"1234567", fmt::format(no_grouping_loc, L"{:L}", 1234567));
+
+  auto special_grouping_loc =
+      std::locale(std::locale(), new special_grouping<wchar_t>());
+  EXPECT_EQ(L"1,23,45,678",
+            fmt::format(special_grouping_loc, L"{:L}", 12345678));
+
+  auto small_grouping_loc =
+      std::locale(std::locale(), new small_grouping<wchar_t>());
+  EXPECT_EQ(L"4,2,9,4,9,6,7,2,9,5",
+            fmt::format(small_grouping_loc, L"{:L}", max_value<uint32_t>()));
+}
+
+TEST(locale_test, double_formatter) {
+  auto loc = std::locale(std::locale(), new special_grouping<char>());
+  auto f = fmt::formatter<int>();
+  auto parse_ctx = fmt::format_parse_context("L");
+  f.parse(parse_ctx);
+  char buf[10] = {};
+  fmt::basic_format_context<char*, char> format_ctx(
+      buf, {}, fmt::detail::locale_ref(loc));
+  *f.format(12345, format_ctx) = 0;
+  EXPECT_STREQ("12,345", buf);
+}
+
+FMT_BEGIN_NAMESPACE
+template <class charT> struct formatter<std::complex<double>, charT> {
+ private:
+  detail::dynamic_format_specs<char> specs_;
+
+ public:
+  FMT_CONSTEXPR typename basic_format_parse_context<charT>::iterator parse(
+      basic_format_parse_context<charT>& ctx) {
+    using handler_type =
+        detail::dynamic_specs_handler<basic_format_parse_context<charT>>;
+    detail::specs_checker<handler_type> handler(handler_type(specs_, ctx),
+                                                detail::type::string_type);
+    auto it = parse_format_specs(ctx.begin(), ctx.end(), handler);
+    detail::parse_float_type_spec(specs_, ctx.error_handler());
+    return it;
+  }
+
+  template <class FormatContext>
+  typename FormatContext::iterator format(const std::complex<double>& c,
+                                          FormatContext& ctx) {
+    detail::handle_dynamic_spec<detail::precision_checker>(
+        specs_.precision, specs_.precision_ref, ctx);
+    auto specs = std::string();
+    if (specs_.precision > 0) specs = fmt::format(".{}", specs_.precision);
+    if (specs_.type) specs += specs_.type;
+    auto real = fmt::format(ctx.locale().template get<std::locale>(),
+                            fmt::runtime("{:" + specs + "}"), c.real());
+    auto imag = fmt::format(ctx.locale().template get<std::locale>(),
+                            fmt::runtime("{:" + specs + "}"), c.imag());
+    auto fill_align_width = std::string();
+    if (specs_.width > 0) fill_align_width = fmt::format(">{}", specs_.width);
+    return format_to(ctx.out(), runtime("{:" + fill_align_width + "}"),
+                     c.real() != 0 ? fmt::format("({}+{}i)", real, imag)
+                                   : fmt::format("{}i", imag));
+  }
+};
+FMT_END_NAMESPACE
+
+TEST(locale_test, complex) {
+  std::string s = fmt::format("{}", std::complex<double>(1, 2));
+  EXPECT_EQ(s, "(1+2i)");
+  EXPECT_EQ(fmt::format("{:.2f}", std::complex<double>(1, 2)), "(1.00+2.00i)");
+  EXPECT_EQ(fmt::format("{:8}", std::complex<double>(1, 2)), "  (1+2i)");
+}
+
+#endif  // FMT_STATIC_THOUSANDS_SEPARATOR