Update fmt lib, add recast, wip on recast pathfinder interface (broken atm)

libs/format/test/CMakeLists.txt

@@ -56,11 +56,19 @@ 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)
-  add_executable(${name} ${name}.cc ${ARGN})
+  add_fmt_executable(${name} ${name}.cc ${ARGN})
   target_link_libraries(${name} test-main)
+
   # define if certain c++ features can be used
   target_compile_definitions(${name} PRIVATE
     FMT_USE_TYPE_TRAITS=$<BOOL:${SUPPORTS_TYPE_TRAITS}>
@@ -72,13 +80,17 @@ function(add_fmt_test name)
 endfunction()
 
 add_fmt_test(assert-test)
+add_fmt_test(container-test)
 add_fmt_test(gtest-extra-test)
 add_fmt_test(format-test)
 add_fmt_test(format-impl-test)
 add_fmt_test(ostream-test)
 add_fmt_test(printf-test)
+add_fmt_test(string-test)
+add_fmt_test(time-test)
 add_fmt_test(util-test mock-allocator.h)
 add_fmt_test(macro-test)
+add_fmt_test(custom-formatter-test)
 
 # Enable stricter options for one test to make sure that the header is free of
 # warnings.
@@ -87,7 +99,8 @@ if (FMT_PEDANTIC AND MSVC)
 endif ()
 
 if (HAVE_OPEN)
-  add_executable(posix-mock-test posix-mock-test.cc ../fmt/format.cc ${TEST_MAIN_SRC})
+  add_fmt_executable(posix-mock-test
+    posix-mock-test.cc ../fmt/format.cc ../fmt/printf.cc ${TEST_MAIN_SRC})
   target_include_directories(posix-mock-test PRIVATE ${PROJECT_SOURCE_DIR})
   target_compile_definitions(posix-mock-test PRIVATE FMT_USE_FILE_DESCRIPTORS=1)
   target_link_libraries(posix-mock-test gmock)
@@ -95,7 +108,7 @@ if (HAVE_OPEN)
   add_fmt_test(posix-test)
 endif ()
 
-add_executable(header-only-test
+add_fmt_executable(header-only-test
   header-only-test.cc header-only-test2.cc test-main.cc)
 target_link_libraries(header-only-test gmock)
 if (TARGET fmt-header-only)
@@ -109,6 +122,7 @@ endif ()
 check_cxx_compiler_flag(-fno-exceptions HAVE_FNO_EXCEPTIONS_FLAG)
 if (HAVE_FNO_EXCEPTIONS_FLAG)
   add_library(noexception-test ../fmt/format.cc)
+  target_include_directories(noexception-test PRIVATE ${PROJECT_SOURCE_DIR})
   target_compile_options(noexception-test PRIVATE -fno-exceptions)
 endif ()
 
@@ -116,6 +130,7 @@ if (FMT_PEDANTIC)
   # Test that the library compiles without windows.h.
   if (CMAKE_SYSTEM_NAME STREQUAL "Windows")
     add_library(no-windows-h-test ../fmt/format.cc)
+    target_include_directories(no-windows-h-test PRIVATE ${PROJECT_SOURCE_DIR})
     target_compile_definitions(no-windows-h-test PRIVATE FMT_USE_WINDOWS_H=0)
   endif ()
 
@@ -125,7 +140,7 @@ if (FMT_PEDANTIC)
     "${CMAKE_CURRENT_BINARY_DIR}/compile-test"
     --build-generator ${CMAKE_GENERATOR}
     --build-makeprogram ${CMAKE_MAKE_PROGRAM}
-    --build-options 
+    --build-options
     "-DCMAKE_CXX_COMPILER=${CMAKE_CXX_COMPILER}"
     "-DCPP11_FLAG=${CPP11_FLAG}"
     "-DSUPPORTS_USER_DEFINED_LITERALS=${SUPPORTS_USER_DEFINED_LITERALS}")

libs/format/test/add-subdirectory-test/CMakeLists.txt

@@ -5,9 +5,9 @@ project(fmt-test)
 add_subdirectory(../.. fmt)
 
 add_executable(library-test "main.cc")
-target_link_libraries(library-test fmt)
+target_link_libraries(library-test fmt::fmt)
 
-if (TARGET fmt-header-only)
+if (TARGET fmt::fmt-header-only)
   add_executable(header-only-test "main.cc")
-  target_link_libraries(header-only-test fmt-header-only)
+  target_link_libraries(header-only-test fmt::fmt-header-only)
 endif ()

libs/format/test/find-package-test/CMakeLists.txt

@@ -5,9 +5,9 @@ project(fmt-test)
 find_package(FMT REQUIRED)
 
 add_executable(library-test main.cc)
-target_link_libraries(library-test fmt)
+target_link_libraries(library-test fmt::fmt)
 
-if (TARGET fmt-header-only)
+if (TARGET fmt::fmt-header-only)
   add_executable(header-only-test main.cc)
-  target_link_libraries(header-only-test fmt-header-only)
+  target_link_libraries(header-only-test fmt::fmt-header-only)
 endif ()

libs/format/test/format-impl-test.cc

@@ -26,10 +26,12 @@
  */
 
 #define FMT_NOEXCEPT
+#undef FMT_SHARED
 #include "test-assert.h"
 
-// Include format.cc instead of format.h to test implementation-specific stuff.
+// Include *.cc instead of *.h to test implementation-specific stuff.
 #include "fmt/format.cc"
+#include "fmt/printf.cc"
 
 #include <algorithm>
 #include <cstring>
@@ -46,7 +48,7 @@ TEST(FormatTest, ArgConverter) {
   Arg arg = Arg();
   arg.type = Arg::LONG_LONG;
   arg.long_long_value = std::numeric_limits<fmt::LongLong>::max();
-  fmt::ArgConverter<fmt::LongLong>(arg, 'd').visit(arg);
+  fmt::internal::ArgConverter<fmt::LongLong>(arg, 'd').visit(arg);
   EXPECT_EQ(Arg::LONG_LONG, arg.type);
 }
 

libs/format/test/format-test.cc

@@ -43,8 +43,23 @@
 // Test that the library compiles if None is defined to 0 as done by xlib.h.
 #define None 0
 
+struct LocaleMock {
+  static LocaleMock *instance;
+
+  MOCK_METHOD0(localeconv, lconv *());
+} *LocaleMock::instance;
+
+namespace fmt {
+namespace std {
+using namespace ::std;
+lconv *localeconv() {
+  return LocaleMock::instance ?
+        LocaleMock::instance->localeconv() : ::std::localeconv();
+}
+}
+}
+
 #include "fmt/format.h"
-#include "fmt/time.h"
 
 #include "util.h"
 #include "mock-allocator.h"
@@ -235,7 +250,7 @@ TEST(WriterTest, Allocator) {
   std::size_t size =
       static_cast<std::size_t>(1.5 * fmt::internal::INLINE_BUFFER_SIZE);
   std::vector<char> mem(size);
-  EXPECT_CALL(alloc, allocate(size)).WillOnce(testing::Return(&mem[0]));
+  EXPECT_CALL(alloc, allocate(size, 0)).WillOnce(testing::Return(&mem[0]));
   for (int i = 0; i < fmt::internal::INLINE_BUFFER_SIZE + 1; ++i)
     w << '*';
   EXPECT_CALL(alloc, deallocate(&mem[0], size));
@@ -917,7 +932,7 @@ TEST(FormatterTest, RuntimeWidth) {
       FormatError, "number is too big");
   EXPECT_THROW_MSG(format("{0:{1}}", 0, -1l),
       FormatError, "negative width");
-  if (fmt::internal::check(sizeof(long) > sizeof(int))) {
+  if (fmt::internal::const_check(sizeof(long) > sizeof(int))) {
     long value = INT_MAX;
     EXPECT_THROW_MSG(format("{0:{1}}", 0, (value + 1)),
         FormatError, "number is too big");
@@ -1036,7 +1051,7 @@ TEST(FormatterTest, RuntimePrecision) {
       FormatError, "number is too big");
   EXPECT_THROW_MSG(format("{0:.{1}}", 0, -1l),
       FormatError, "negative precision");
-  if (fmt::internal::check(sizeof(long) > sizeof(int))) {
+  if (fmt::internal::const_check(sizeof(long) > sizeof(int))) {
     long value = INT_MAX;
     EXPECT_THROW_MSG(format("{0:.{1}}", 0, (value + 1)),
         FormatError, "number is too big");
@@ -1209,13 +1224,24 @@ TEST(FormatterTest, FormatOct) {
 }
 
 TEST(FormatterTest, FormatIntLocale) {
-#ifndef _WIN32
-  const char *locale = "en_US.utf-8";
-#else
-  const char *locale = "English_United States";
-#endif
-  std::setlocale(LC_ALL, locale);
-  EXPECT_EQ("1,234,567", format("{:n}", 1234567));
+  ScopedMock<LocaleMock> mock;
+  lconv lc = lconv();
+  char sep[] = "--";
+  lc.thousands_sep = sep;
+  EXPECT_CALL(mock, localeconv()).Times(3).WillRepeatedly(testing::Return(&lc));
+  EXPECT_EQ("123", format("{:n}", 123));
+  EXPECT_EQ("1--234", format("{:n}", 1234));
+  EXPECT_EQ("1--234--567", format("{:n}", 1234567));
+}
+
+struct ConvertibleToLongLong {
+  operator fmt::LongLong() const {
+    return fmt::LongLong(1) << 32;
+  }
+};
+
+TEST(FormatterTest, FormatConvertibleToLongLong) {
+  EXPECT_EQ("100000000", format("{:x}", ConvertibleToLongLong()));
 }
 
 TEST(FormatterTest, FormatFloat) {
@@ -1327,6 +1353,8 @@ TEST(FormatterTest, FormatUCharString) {
   EXPECT_EQ("test", format("{0:s}", str));
   const unsigned char *const_str = str;
   EXPECT_EQ("test", format("{0:s}", const_str));
+  unsigned char *ptr = str;
+  EXPECT_EQ("test", format("{0:s}", ptr));
 }
 
 TEST(FormatterTest, FormatPointer) {
@@ -1350,7 +1378,7 @@ TEST(FormatterTest, FormatCStringRef) {
   EXPECT_EQ("test", format("{0}", CStringRef("test")));
 }
 
-void format(fmt::BasicFormatter<char> &f, const char *, const Date &d) {
+void format_arg(fmt::BasicFormatter<char> &f, const char *, const Date &d) {
   f.writer() << d.year() << '-' << d.month() << '-' << d.day();
 }
 
@@ -1363,7 +1391,7 @@ TEST(FormatterTest, FormatCustom) {
 class Answer {};
 
 template <typename Char>
-void format(fmt::BasicFormatter<Char> &f, const Char *, Answer) {
+void format_arg(fmt::BasicFormatter<Char> &f, const Char *, Answer) {
   f.writer() << "42";
 }
 
@@ -1534,13 +1562,25 @@ TEST(FormatTest, Variadic) {
   EXPECT_EQ(L"abc1", format(L"{}c{}", L"ab", 1));
 }
 
-TEST(FormatTest, Time) {
-  std::tm tm = std::tm();
-  tm.tm_year = 116;
-  tm.tm_mon  = 3;
-  tm.tm_mday = 25;
-  EXPECT_EQ("The date is 2016-04-25.",
-            fmt::format("The date is {:%Y-%m-%d}.", tm));
+TEST(FormatTest, JoinArg) {
+  using fmt::join;
+  int v1[3] = { 1, 2, 3 };
+  std::vector<float> v2;
+  v2.push_back(1.2f);
+  v2.push_back(3.4f);
+
+  EXPECT_EQ("(1, 2, 3)", format("({})", join(v1 + 0, v1 + 3, ", ")));
+  EXPECT_EQ("(1)", format("({})", join(v1 + 0, v1 + 1, ", ")));
+  EXPECT_EQ("()", format("({})", join(v1 + 0, v1 + 0, ", ")));
+  EXPECT_EQ("(001, 002, 003)", format("({:03})", join(v1 + 0, v1 + 3, ", ")));
+  EXPECT_EQ("(+01.20, +03.40)", format("({:+06.2f})", join(v2.begin(), v2.end(), ", ")));
+
+  EXPECT_EQ(L"(1, 2, 3)", format(L"({})", join(v1 + 0, v1 + 3, L", ")));
+
+#if FMT_HAS_GXX_CXX11
+  EXPECT_EQ("(1, 2, 3)", format("({})", join(v1, ", ")));
+  EXPECT_EQ("(+01.20, +03.40)", format("({:+06.2f})", join(v2, ", ")));
+#endif
 }
 
 template <typename T>
@@ -1644,3 +1684,10 @@ FMT_VARIADIC(void, custom_format, const char *)
 TEST(FormatTest, CustomArgFormatter) {
   custom_format("{}", 42);
 }
+
+void convert(int);
+
+// Check if there is no collision with convert function in the global namespace.
+TEST(FormatTest, ConvertCollision) {
+  fmt::format("{}", 42);
+}

libs/format/test/gmock/gmock.h

@@ -10090,8 +10090,9 @@ class FunctionMockerBase : public UntypedFunctionMockerBase {
   // threads concurrently.
   Result InvokeWith(const ArgumentTuple& args)
         GTEST_LOCK_EXCLUDED_(g_gmock_mutex) {
-    return static_cast<const ResultHolder*>(
-        this->UntypedInvokeWith(&args))->GetValueAndDelete();
+    const ResultHolder *rh = static_cast<const ResultHolder*>(
+                this->UntypedInvokeWith(&args));
+    return rh ? rh->GetValueAndDelete() : Result();
   }
 
   // Adds and returns a default action spec for this mock function.

libs/format/test/gtest-extra-test.cc

@@ -320,7 +320,7 @@ TEST(StreamingAssertionsTest, EXPECT_WRITE) {
 
 TEST(UtilTest, FormatSystemError) {
   fmt::MemoryWriter out;
-  fmt::internal::format_system_error(out, EDOM, "test message");
+  fmt::format_system_error(out, EDOM, "test message");
   EXPECT_EQ(out.str(), format_system_error(EDOM, "test message"));
 }
 

libs/format/test/gtest-extra.cc

@@ -105,6 +105,6 @@ std::string read(File &f, std::size_t count) {
 
 std::string format_system_error(int error_code, fmt::StringRef message) {
   fmt::MemoryWriter out;
-  fmt::internal::format_system_error(out, error_code, message);
+  fmt::format_system_error(out, error_code, message);
   return out.str();
 }

libs/format/test/gtest-extra.h

@@ -29,7 +29,7 @@
 #define FMT_GTEST_EXTRA_H_
 
 #include <string>
-#include <gtest/gtest.h>
+#include <gmock/gmock.h>
 
 #include "fmt/format.h"
 
@@ -172,4 +172,10 @@ std::string read(fmt::File &f, std::size_t count);
 
 #endif  // FMT_USE_FILE_DESCRIPTORS
 
+template <typename Mock>
+struct ScopedMock : testing::StrictMock<Mock> {
+  ScopedMock() { Mock::instance = this; }
+  ~ScopedMock() { Mock::instance = 0; }
+};
+
 #endif  // FMT_GTEST_EXTRA_H_

libs/format/test/gtest/gtest.h

@@ -2823,7 +2823,11 @@ inline int IsATTY(int /* fd */) { return 0; }
 inline int IsATTY(int fd) { return _isatty(fd); }
 #  endif  // GTEST_OS_WINDOWS_MOBILE
 inline int StrCaseCmp(const char* s1, const char* s2) {
-  return _stricmp(s1, s2);
+#  if _EMULATE_GLIBC
+    return strcasecmp(s1, s2);
+#  else
+    return _stricmp(s1, s2);
+#  endif
 }
 inline char* StrDup(const char* src) { return _strdup(src); }
 # endif  // __BORLANDC__

libs/format/test/mock-allocator.h

@@ -36,8 +36,8 @@ class MockAllocator {
   MockAllocator() {}
   MockAllocator(const MockAllocator &) {}
   typedef T value_type;
-  MOCK_METHOD1_T(allocate, T* (std::size_t n));
-  MOCK_METHOD2_T(deallocate, void (T* p, std::size_t n));
+  MOCK_METHOD2_T(allocate, T *(std::size_t n, const T *h));
+  MOCK_METHOD2_T(deallocate, void (T *p, std::size_t n));
 };
 
 template <typename Allocator>
@@ -78,8 +78,10 @@ class AllocatorRef {
 
   Allocator *get() const { return alloc_; }
 
-  value_type* allocate(std::size_t n) { return alloc_->allocate(n); }
-  void deallocate(value_type* p, std::size_t n) { alloc_->deallocate(p, n); }
+  value_type *allocate(std::size_t n,  const value_type *h) {
+    return alloc_->allocate(n, h);
+  }
+  void deallocate(value_type *p, std::size_t n) { alloc_->deallocate(p, n); }
 };
 
 #endif  // FMT_MOCK_ALLOCATOR_H_

libs/format/test/ostream-test.cc

@@ -25,7 +25,7 @@
  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#include "fmt/ostream.cc"
+#include "fmt/ostream.h"
 
 #include <sstream>
 #include "gmock/gmock.h"
@@ -35,13 +35,6 @@
 using fmt::format;
 using fmt::FormatError;
 
-template <typename Char>
-std::basic_ostream<Char> &operator<<(
-    std::basic_ostream<Char> &os, const BasicTestString<Char> &s) {
-  os << s.value();
-  return os;
-}
-
 std::ostream &operator<<(std::ostream &os, const Date &d) {
   os << d.year() << '-' << d.month() << '-' << d.day();
   return os;
@@ -128,22 +121,11 @@ TEST(OStreamTest, Print) {
   EXPECT_EQ("Don't panic!", os.str());
 }
 
-TEST(OStreamTest, PrintfCustom) {
-  EXPECT_EQ("abc", fmt::sprintf("%s", TestString("abc")));
-}
-
-TEST(OStreamTest, FPrintf) {
-  std::ostringstream os;
-  int ret = fmt::fprintf(os, "Don't %s!", "panic");
-  EXPECT_EQ("Don't panic!", os.str());
-  EXPECT_EQ(12, ret);
-}
-
 TEST(OStreamTest, WriteToOStream) {
   std::ostringstream os;
   fmt::MemoryWriter w;
   w << "foo";
-  fmt::write(os, w);
+  fmt::internal::write(os, w);
   EXPECT_EQ("foo", os.str());
 }
 
@@ -188,5 +170,5 @@ TEST(OStreamTest, WriteToOStreamMaxSize) {
     data += n;
     size -= static_cast<std::size_t>(n);
   } while (size != 0);
-  fmt::write(os, w);
+  fmt::internal::write(os, w);
 }

libs/format/test/posix-mock-test.cc

@@ -453,12 +453,6 @@ TEST(BufferedFileTest, FilenoNoRetry) {
   fileno_count = 0;
 }
 
-template <typename Mock>
-struct ScopedMock : testing::StrictMock<Mock> {
-  ScopedMock() { Mock::instance = this; }
-  ~ScopedMock() { Mock::instance = 0; }
-};
-
 struct TestMock {
   static TestMock *instance;
 } *TestMock::instance;
@@ -508,7 +502,7 @@ LocaleType newlocale(int category_mask, const char *locale, LocaleType base) {
   return LocaleMock::instance->newlocale(category_mask, locale, base);
 }
 
-#ifdef __APPLE__
+#if defined(__APPLE__) || defined(__FreeBSD__)
 typedef int FreeLocaleResult;
 #else
 typedef void FreeLocaleResult;

libs/format/test/posix-test.cc

@@ -232,7 +232,7 @@ TEST(FileTest, MoveAssignmentClosesFile) {
 File OpenBufferedFile(int &fd) {
   File f = open_file();
   fd = f.descriptor();
-  return std::move(f);
+  return f;
 }
 
 TEST(FileTest, MoveFromTemporaryInCtor) {

libs/format/test/printf-test.cc

@@ -29,6 +29,7 @@
 #include <climits>
 #include <cstring>
 
+#include "fmt/printf.h"
 #include "fmt/format.h"
 #include "gtest-extra.h"
 #include "util.h"
@@ -201,6 +202,8 @@ TEST(PrintfTest, HashFlag) {
 
 TEST(PrintfTest, Width) {
   EXPECT_PRINTF("  abc", "%5s", "abc");
+  EXPECT_PRINTF("  -42", "%5s", "-42");
+  EXPECT_PRINTF("  0.123456", "%10s", 0.123456);
 
   // Width cannot be specified twice.
   EXPECT_THROW_MSG(fmt::sprintf("%5-5d", 42), FormatError,
@@ -295,12 +298,13 @@ void TestLength(const char *length_spec, U value) {
   fmt::LongLong signed_value = 0;
   fmt::ULongLong unsigned_value = 0;
   // Apply integer promotion to the argument.
-  fmt::ULongLong max = std::numeric_limits<U>::max();
-  using fmt::internal::check;
-  if (check(max <= static_cast<unsigned>(std::numeric_limits<int>::max()))) {
+  using std::numeric_limits;
+  fmt::ULongLong max = numeric_limits<U>::max();
+  using fmt::internal::const_check;
+  if (const_check(max <= static_cast<unsigned>(numeric_limits<int>::max()))) {
     signed_value = static_cast<int>(value);
     unsigned_value = static_cast<unsigned>(value);
-  } else if (check(max <= std::numeric_limits<unsigned>::max())) {
+  } else if (const_check(max <= numeric_limits<unsigned>::max())) {
     signed_value = static_cast<unsigned>(value);
     unsigned_value = static_cast<unsigned>(value);
   }
@@ -379,11 +383,13 @@ TEST(PrintfTest, Bool) {
 TEST(PrintfTest, Int) {
   EXPECT_PRINTF("-42", "%d", -42);
   EXPECT_PRINTF("-42", "%i", -42);
+  EXPECT_PRINTF("-42", "%s", -42);
   unsigned u = 0 - 42u;
   EXPECT_PRINTF(fmt::format("{}", u), "%u", -42);
   EXPECT_PRINTF(fmt::format("{:o}", u), "%o", -42);
   EXPECT_PRINTF(fmt::format("{:x}", u), "%x", -42);
   EXPECT_PRINTF(fmt::format("{:X}", u), "%X", -42);
+  EXPECT_PRINTF(fmt::format("{}", u), "%s", u);
 }
 
 TEST(PrintfTest, LongLong) {
@@ -395,7 +401,11 @@ TEST(PrintfTest, LongLong) {
 
 TEST(PrintfTest, 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);
+  EXPECT_PRINTF("392.65", "%s", 392.65);
   char buffer[BUFFER_SIZE];
   safe_sprintf(buffer, "%e", 392.65);
   EXPECT_PRINTF(buffer, "%e", 392.65);
@@ -420,6 +430,7 @@ TEST(PrintfTest, Inf) {
 
 TEST(PrintfTest, Char) {
   EXPECT_PRINTF("x", "%c", 'x');
+  EXPECT_PRINTF("x", "%s", 'x');
   int max = std::numeric_limits<int>::max();
   EXPECT_PRINTF(fmt::format("{}", static_cast<char>(max)), "%c", max);
   //EXPECT_PRINTF("x", "%lc", L'x');
@@ -438,13 +449,17 @@ TEST(PrintfTest, Pointer) {
   int n;
   void *p = &n;
   EXPECT_PRINTF(fmt::format("{}", p), "%p", p);
+  EXPECT_PRINTF(fmt::format("{}", p), "%s", p);
   p = 0;
   EXPECT_PRINTF("(nil)", "%p", p);
   EXPECT_PRINTF("     (nil)", "%10p", p);
+  EXPECT_PRINTF("(nil)", "%s", p);
+  EXPECT_PRINTF("     (nil)", "%10s", p);
   const char *s = "test";
   EXPECT_PRINTF(fmt::format("{:p}", s), "%p", s);
   const char *null_str = 0;
   EXPECT_PRINTF("(nil)", "%p", null_str);
+  EXPECT_PRINTF("(null)", "%s", null_str);
 }
 
 TEST(PrintfTest, Location) {
@@ -477,3 +492,20 @@ TEST(PrintfTest, PrintfError) {
 TEST(PrintfTest, WideString) {
   EXPECT_EQ(L"abc", fmt::sprintf(L"%s", L"abc"));
 }
+
+TEST(PrintfTest, PrintfCustom) {
+  EXPECT_EQ("abc", fmt::sprintf("%s", TestString("abc")));
+}
+
+TEST(PrintfTest, OStream) {
+  std::ostringstream os;
+  int ret = fmt::fprintf(os, "Don't %s!", "panic");
+  EXPECT_EQ("Don't panic!", os.str());
+  EXPECT_EQ(12, ret);
+}
+
+TEST(PrintfTest, Writer) {
+  fmt::MemoryWriter writer;
+  printf(writer, "%d", 42);
+  EXPECT_EQ("42", writer.str());
+}

libs/format/test/util-test.cc

@@ -64,7 +64,7 @@ namespace {
 struct Test {};
 
 template <typename Char>
-void format(fmt::BasicFormatter<Char> &f, const Char *, Test) {
+void format_arg(fmt::BasicFormatter<Char> &f, const Char *, Test) {
   f.writer() << "test";
 }
 
@@ -83,8 +83,8 @@ void CheckForwarding(
   // Check if value_type is properly defined.
   AllocatorRef< MockAllocator<int> >::value_type *ptr = &mem;
   // Check forwarding.
-  EXPECT_CALL(alloc, allocate(42)).WillOnce(Return(ptr));
-  ref.allocate(42);
+  EXPECT_CALL(alloc, allocate(42, 0)).WillOnce(Return(ptr));
+  ref.allocate(42, 0);
   EXPECT_CALL(alloc, deallocate(ptr, 42));
   ref.deallocate(ptr, 42);
 }
@@ -339,7 +339,7 @@ TEST(MemoryBufferTest, Grow) {
   EXPECT_EQ(10u, buffer.capacity());
   int mem[20];
   mem[7] = 0xdead;
-  EXPECT_CALL(alloc, allocate(20)).WillOnce(Return(mem));
+  EXPECT_CALL(alloc, allocate(20, 0)).WillOnce(Return(mem));
   buffer.grow(20);
   EXPECT_EQ(20u, buffer.capacity());
   // Check if size elements have been copied
@@ -360,7 +360,7 @@ TEST(MemoryBufferTest, Allocator) {
     MemoryBuffer<char, 10, TestAllocator> buffer2((TestAllocator(&alloc)));
     EXPECT_EQ(&alloc, buffer2.get_allocator().get());
     std::size_t size = 2 * fmt::internal::INLINE_BUFFER_SIZE;
-    EXPECT_CALL(alloc, allocate(size)).WillOnce(Return(&mem));
+    EXPECT_CALL(alloc, allocate(size, 0)).WillOnce(Return(&mem));
     buffer2.reserve(size);
     EXPECT_CALL(alloc, deallocate(&mem, size));
   }
@@ -373,13 +373,13 @@ TEST(MemoryBufferTest, ExceptionInDeallocate) {
   std::size_t size = 2 * fmt::internal::INLINE_BUFFER_SIZE;
   std::vector<char> mem(size);
   {
-    EXPECT_CALL(alloc, allocate(size)).WillOnce(Return(&mem[0]));
+    EXPECT_CALL(alloc, allocate(size, 0)).WillOnce(Return(&mem[0]));
     buffer.resize(size);
     std::fill(&buffer[0], &buffer[0] + size, 'x');
   }
   std::vector<char> mem2(2 * size);
   {
-    EXPECT_CALL(alloc, allocate(2 * size)).WillOnce(Return(&mem2[0]));
+    EXPECT_CALL(alloc, allocate(2 * size, 0)).WillOnce(Return(&mem2[0]));
     std::exception e;
     EXPECT_CALL(alloc, deallocate(&mem[0], size)).WillOnce(testing::Throw(e));
     EXPECT_THROW(buffer.reserve(2 * size), std::exception);
@@ -581,7 +581,7 @@ struct CustomFormatter {
   typedef char Char;
 };
 
-void format(CustomFormatter &, const char *&s, const Test &) {
+void format_arg(CustomFormatter &, const char *&s, const Test &) {
   s = "custom_format";
 }
 
@@ -708,7 +708,7 @@ TEST(ArgVisitorTest, VisitUnhandledArg) {
 
 TEST(ArgVisitorTest, VisitInvalidArg) {
   Arg arg = Arg();
-  arg.type = static_cast<Arg::Type>(Arg::CUSTOM + 1);
+  arg.type = static_cast<Arg::Type>(Arg::NONE);
   EXPECT_ASSERT(TestVisitor().visit(arg), "invalid argument type");
 }
 
@@ -834,10 +834,10 @@ void check_throw_error(int error_code, FormatErrorMessage format) {
 
 TEST(UtilTest, FormatSystemError) {
   fmt::MemoryWriter message;
-  fmt::internal::format_system_error(message, EDOM, "test");
+  fmt::format_system_error(message, EDOM, "test");
   EXPECT_EQ(fmt::format("test: {}", get_system_error(EDOM)), message.str());
   message.clear();
-  fmt::internal::format_system_error(
+  fmt::format_system_error(
         message, EDOM, fmt::StringRef(0, std::numeric_limits<size_t>::max()));
   EXPECT_EQ(fmt::format("error {}", EDOM), message.str());
 }
@@ -846,12 +846,12 @@ TEST(UtilTest, SystemError) {
   fmt::SystemError e(EDOM, "test");
   EXPECT_EQ(fmt::format("test: {}", get_system_error(EDOM)), e.what());
   EXPECT_EQ(EDOM, e.error_code());
-  check_throw_error<fmt::SystemError>(EDOM, fmt::internal::format_system_error);
+  check_throw_error<fmt::SystemError>(EDOM, fmt::format_system_error);
 }
 
 TEST(UtilTest, ReportSystemError) {
   fmt::MemoryWriter out;
-  fmt::internal::format_system_error(out, EDOM, "test error");
+  fmt::format_system_error(out, EDOM, "test error");
   out << '\n';
   EXPECT_WRITE(stderr, fmt::report_system_error(EDOM, "test error"), out.str());
 }
@@ -956,3 +956,17 @@ TEST(UtilTest, Conditional) {
   fmt::internal::Conditional<false, int, char>::type *pc = &c;
   (void)pc;
 }
+
+struct TestLConv {
+  char *thousands_sep;
+};
+
+struct EmptyLConv {};
+
+TEST(UtilTest, ThousandsSep) {
+  char foo[] = "foo";
+  TestLConv lc = {foo};
+  EXPECT_EQ("foo", fmt::internal::thousands_sep(&lc).to_string());
+  EmptyLConv empty_lc;
+  EXPECT_EQ("", fmt::internal::thousands_sep(&empty_lc));
+}

libs/format/test/util.h

@@ -87,6 +87,13 @@ const Char BasicTestString<Char>::EMPTY[] = {0};
 typedef BasicTestString<char> TestString;
 typedef BasicTestString<wchar_t> TestWString;
 
+template <typename Char>
+std::basic_ostream<Char> &operator<<(
+    std::basic_ostream<Char> &os, const BasicTestString<Char> &s) {
+  os << s.value();
+  return os;
+}
+
 class Date {
   int year_, month_, day_;
  public: