Update cppfmt to current git.

vendor/Fmt/test/CMakeLists.txt

@@ -26,6 +26,16 @@ function(add_fmt_executable name)
   if (MINGW)
     target_link_libraries(${name} -static-libgcc -static-libstdc++)
   endif ()
+  # (Wstringop-overflow) - [meta-bug] bogus/missing -Wstringop-overflow warnings
+  #   https://gcc.gnu.org/bugzilla/show_bug.cgi?id=88443
+  # Bogus -Wstringop-overflow warning
+  #   https://gcc.gnu.org/bugzilla/show_bug.cgi?id=100395
+  # [10 Regression] spurious -Wstringop-overflow writing to a trailing array plus offset
+  #   https://gcc.gnu.org/bugzilla/show_bug.cgi?id=95353
+  if (CMAKE_CXX_COMPILER_ID MATCHES "GNU" AND
+      NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 7.0)
+    target_link_libraries(${name} -Wno-stringop-overflow)
+  endif ()
 endfunction()
 
 # Adds a test.
@@ -41,7 +51,7 @@ function(add_fmt_test name)
       set(PEDANTIC_COMPILE_FLAGS ${PEDANTIC_COMPILE_FLAGS} -Wno-weak-vtables)
     endif ()
   elseif (ADD_FMT_TEST_MODULE)
-    set(libs test-main test-module)
+    set(libs gtest test-module)
     set_source_files_properties(${name}.cc PROPERTIES OBJECT_DEPENDS test-module)
   else ()
     set(libs test-main fmt)
@@ -97,7 +107,7 @@ if (FMT_CAN_MODULE)
     $<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/include>)
   enable_module(test-module)
 
-  add_fmt_test(module-test MODULE)
+  add_fmt_test(module-test MODULE test-main.cc)
   if (MSVC)
     target_compile_options(test-module PRIVATE /utf-8 /Zc:__cplusplus
                            /Zc:externConstexpr /Zc:inline)

vendor/Fmt/test/args-test.cc

@@ -171,3 +171,16 @@ TEST(args_test, throw_on_copy) {
   }
   EXPECT_EQ(fmt::vformat("{}", store), "foo");
 }
+
+TEST(args_test, copy_constructor) {
+  auto store = fmt::dynamic_format_arg_store<fmt::format_context>();
+  store.push_back(fmt::arg("test1", "value1"));
+  store.push_back(fmt::arg("test2", "value2"));
+  store.push_back(fmt::arg("test3", "value3"));
+
+  auto store2 = store;
+  store2.push_back(fmt::arg("test4", "value4"));
+
+  auto result = fmt::vformat("{test1} {test2} {test3} {test4}", store2);
+  EXPECT_EQ(result, "value1 value2 value3 value4");
+}

vendor/Fmt/test/color-test.cc

@@ -20,10 +20,16 @@ TEST(color_test, format) {
       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::faint, "faint"), "\x1b[2mfaint\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::blink, "blink"), "\x1b[5mblink\x1b[0m");
+  EXPECT_EQ(fmt::format(fmt::emphasis::reverse, "reverse"),
+            "\x1b[7mreverse\x1b[0m");
+  EXPECT_EQ(fmt::format(fmt::emphasis::conceal, "conceal"),
+            "\x1b[8mconceal\x1b[0m");
   EXPECT_EQ(fmt::format(fmt::emphasis::strikethrough, "strikethrough"),
             "\x1b[9mstrikethrough\x1b[0m");
   EXPECT_EQ(

vendor/Fmt/test/core-test.cc

@@ -151,7 +151,9 @@ TEST(buffer_test, indestructible) {
 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)); }
+  void grow(size_t capacity) override {
+    this->set(this->data(), do_grow(capacity));
+  }
 
   mock_buffer(T* data = nullptr, size_t buf_capacity = 0) {
     this->set(data, buf_capacity);
@@ -452,7 +454,7 @@ struct check_custom {
     struct test_buffer final : fmt::detail::buffer<char> {
       char data[10];
       test_buffer() : fmt::detail::buffer<char>(data, 0, 10) {}
-      void grow(size_t) {}
+      void grow(size_t) override {}
     } buffer;
     auto parse_ctx = fmt::format_parse_context("");
     auto ctx = fmt::format_context(fmt::detail::buffer_appender<char>(buffer),
@@ -845,3 +847,43 @@ TEST(core_test, adl) {
   fmt::print("{}", s);
   fmt::print(stdout, "{}", s);
 }
+
+struct const_formattable {};
+struct nonconst_formattable {};
+
+FMT_BEGIN_NAMESPACE
+template <> struct formatter<const_formattable> {
+  auto parse(format_parse_context& ctx) -> decltype(ctx.begin()) {
+    return ctx.begin();
+  }
+
+  auto format(const const_formattable&, format_context& ctx)
+      -> decltype(ctx.out()) {
+    auto test = string_view("test");
+    return std::copy_n(test.data(), test.size(), ctx.out());
+  }
+};
+
+template <> struct formatter<nonconst_formattable> {
+  auto parse(format_parse_context& ctx) -> decltype(ctx.begin()) {
+    return ctx.begin();
+  }
+
+  auto format(nonconst_formattable&, 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(core_test, is_const_formattable) {
+  EXPECT_TRUE((fmt::detail::is_const_formattable<const_formattable,
+                                                 fmt::format_context>()));
+  EXPECT_FALSE((fmt::detail::is_const_formattable<nonconst_formattable,
+                                                  fmt::format_context>()));
+}
+
+TEST(core_test, format_nonconst) {
+  EXPECT_EQ(fmt::format("{}", nonconst_formattable()), "test");
+}

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

@@ -13,8 +13,8 @@ void invoke_inner(fmt::string_view format_str, Rep rep) {
 #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);
+    auto buf = fmt::memory_buffer();
+    fmt::format_to(std::back_inserter(buf), format_str, value);
 #endif
   } catch (std::exception&) {
   }

vendor/Fmt/test/gtest-extra.cc

@@ -32,11 +32,10 @@ output_redirect::~output_redirect() FMT_NOEXCEPT {
 }
 
 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_));
+  do {
+    result = fflush(file_);
+  } while (result == EOF && errno == EINTR);
   if (result != 0) throw fmt::system_error(errno, "cannot flush stream");
 }
 

vendor/Fmt/test/gtest-extra.h

@@ -12,7 +12,12 @@
 
 #include <string>
 
+#ifdef FMT_MODULE_TEST
+import fmt;
+#else
 #include "fmt/os.h"
+#endif // FMG_MODULE_TEST
+
 #include "gmock/gmock.h"
 
 #define FMT_TEST_THROW_(statement, expected_exception, expected_message, fail) \
@@ -129,6 +134,7 @@ class suppress_assert {
   ~suppress_assert() {
     _set_invalid_parameter_handler(original_handler_);
     _CrtSetReportMode(_CRT_ASSERT, original_report_mode_);
+    (void)original_report_mode_;
   }
 };
 

vendor/Fmt/test/module-test.cc

@@ -15,6 +15,8 @@
 #  define FMT_HIDE_MODULE_BUGS
 #endif
 
+#define FMT_MODULE_TEST
+
 #include <bit>
 #include <chrono>
 #include <exception>
@@ -35,18 +37,30 @@
 #  define FMT_USE_FCNTL 0
 #endif
 #define FMT_NOEXCEPT noexcept
+#if defined(_WIN32) && !defined(__MINGW32__)
+#  define FMT_POSIX(call) _##call
+#else
+#  define FMT_POSIX(call) call
+#endif
+#define FMT_OS_H_  // don't pull in os.h directly or indirectly
 
 import fmt;
 
 // check for macros leaking from BMI
 static bool macro_leaked =
-#if defined(FMT_CORE_H_) || defined(FMT_FORMAT_H)
+#if defined(FMT_CORE_H_) || defined(FMT_FORMAT_H_)
     true;
 #else
     false;
 #endif
 
-#include "gtest-extra.h"
+// Include sources to pick up functions and classes from the module rather than
+// from the non-modular library which is baked into the 'test-main' library.
+// This averts linker problems:
+// - strong ownership model: missing linker symbols
+// - weak ownership model: duplicate linker symbols
+#include "gtest-extra.cc"
+#include "util.cc"
 
 // an implicitly exported namespace must be visible [module.interface]/2.2
 TEST(module_test, namespace) {

vendor/Fmt/test/os-test.cc

@@ -41,9 +41,9 @@ TEST(util_test, utf16_to_utf8_empty_string) {
 }
 
 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)) {
+void check_utf_conversion_error(const char* message,
+                                fmt::basic_string_view<Char> str =
+                                    fmt::basic_string_view<Char>(nullptr, 1)) {
   fmt::memory_buffer out;
   fmt::detail::format_windows_error(out, ERROR_INVALID_PARAMETER, message);
   auto error = std::system_error(std::error_code());
@@ -63,7 +63,7 @@ TEST(util_test, utf16_to_utf8_error) {
 
 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(nullptr, 1)));
   EXPECT_EQ(ERROR_INVALID_PARAMETER,
             u.convert(wstring_view(L"foo", INT_MAX + 1u)));
 }
@@ -81,12 +81,12 @@ TEST(os_test, format_std_error_code) {
 }
 
 TEST(os_test, format_windows_error) {
-  LPWSTR message = 0;
+  LPWSTR message = nullptr;
   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);
+      nullptr, ERROR_FILE_EXISTS, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
+      reinterpret_cast<LPWSTR>(&message), 0, nullptr);
   fmt::detail::utf16_to_utf8 utf8_message(wstring_view(message, result - 2));
   LocalFree(message);
   fmt::memory_buffer actual_message;
@@ -97,17 +97,17 @@ TEST(os_test, format_windows_error) {
 }
 
 TEST(os_test, format_long_windows_error) {
-  LPWSTR message = 0;
+  LPWSTR message = nullptr;
   // 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);
+  auto result = FormatMessageW(
+      FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM |
+          FORMAT_MESSAGE_IGNORE_INSERTS,
+      nullptr, static_cast<DWORD>(provisioning_not_allowed),
+      MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
+      reinterpret_cast<LPWSTR>(&message), 0, nullptr);
   if (result == 0) {
     LocalFree(message);
     return;
@@ -336,6 +336,14 @@ TEST(ostream_test, truncate) {
   EXPECT_EQ("foo", read(in, 4));
 }
 
+TEST(ostream_test, flush) {
+  auto out = fmt::output_file("test-file");
+  out.print("x");
+  out.flush();
+  auto in = fmt::file("test-file", file::RDONLY);
+  EXPECT_READ(in, "x");
+}
+
 TEST(file_test, default_ctor) {
   file f;
   EXPECT_EQ(-1, f.descriptor());

vendor/Fmt/test/ostream-test.cc

@@ -115,12 +115,12 @@ TEST(ostream_test, write_to_ostream_max_size) {
   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) {}
+    void grow(size_t) override {}
   } 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) {
+    std::streamsize xsputn(const char* s, std::streamsize n) override {
       const void* v = s;
       return xsputn(v, n);
     }

vendor/Fmt/test/ranges-test.cc

@@ -262,3 +262,16 @@ TEST(ranges_test, join_range) {
   EXPECT_EQ(fmt::format("{}", fmt::join(z, ",")), "0,0,0");
 }
 #endif  // FMT_RANGES_TEST_ENABLE_JOIN
+
+TEST(ranges_test, escape_string) {
+  using vec = std::vector<std::string>;
+  EXPECT_EQ(fmt::format("{}", vec{"\n\r\t\"\\"}), "[\"\\n\\r\\t\\\"\\\\\"]");
+  EXPECT_EQ(fmt::format("{}", vec{"\x07"}), "[\"\\x07\"]");
+  EXPECT_EQ(fmt::format("{}", vec{"\x7f"}), "[\"\\x7f\"]");
+
+  // Unassigned Unicode code points.
+  if (fmt::detail::is_utf8()) {
+    EXPECT_EQ(fmt::format("{}", vec{"\xf0\xaa\x9b\x9e"}), "[\"\\U0002a6de\"]");
+    EXPECT_EQ(fmt::format("{}", vec{"\xf4\x8f\xbf\xbf"}), "[\"\\U0010ffff\"]");
+  }
+}

vendor/Fmt/test/test-main.cc

@@ -35,6 +35,7 @@ int main(int argc, char** argv) {
   _CrtSetReportFile(_CRT_ASSERT, _CRTDBG_FILE_STDERR);
   try {
     testing::InitGoogleTest(&argc, argv);
+    testing::FLAGS_gtest_death_test_style = "threadsafe";
     return RUN_ALL_TESTS();
   } catch (...) {
     // Catch all exceptions to make Coverity happy.

vendor/Fmt/test/util.h

@@ -10,7 +10,11 @@
 #include <locale>
 #include <string>
 
+#ifdef FMT_MODULE_TEST
+import fmt;
+#else
 #include "fmt/os.h"
+#endif // FMT_MODULE_TEST
 
 #ifdef _MSC_VER
 #  define FMT_VSNPRINTF vsprintf_s
@@ -34,7 +38,7 @@ 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;
+  FILE* f = nullptr;
   errno = fopen_s(&f, filename, mode);
   return f;
 #else

vendor/Fmt/test/xchar-test.cc

@@ -301,10 +301,12 @@ template <typename Char> struct small_grouping : std::numpunct<Char> {
   Char do_thousands_sep() const override { return ','; }
 };
 
-TEST(locale_test, double_decimal_point) {
+TEST(locale_test, localized_double) {
   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));
+  EXPECT_EQ("1~234?5", fmt::format(loc, "{:L}", 1234.5));
+  EXPECT_EQ("12~000", fmt::format(loc, "{:L}", 12000.0));
 }
 
 TEST(locale_test, format) {