Add support for back_insert_iterator

test/CMakeLists.txt

@@ -85,7 +85,6 @@ 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(custom-formatter-test)

test/custom-formatter-test.cc

@@ -36,7 +36,7 @@ class CustomArgFormatter :
 std::string custom_vformat(fmt::string_view format_str, fmt::format_args args) {
   fmt::memory_buffer buffer;
   // Pass custom argument formatter as a template arg to vwrite.
-  fmt::vformat_to<CustomArgFormatter>(buffer, format_str, args);
+  fmt::do_vformat_to<CustomArgFormatter>(buffer, format_str, args);
   return std::string(buffer.data(), buffer.size());
 }
 

test/format-test.cc

@@ -88,7 +88,7 @@ void std_format(long double value, std::wstring &result) {
 template <typename Char, typename T>
 ::testing::AssertionResult check_write(const T &value, const char *type) {
   fmt::basic_memory_buffer<Char> buffer;
-  using range = fmt::internal::dynamic_range<fmt::basic_buffer<Char>>;
+  using range = fmt::internal::dynamic_range<fmt::internal::basic_buffer<Char>>;
   fmt::basic_writer<range> writer(buffer);
   writer.write(value);
   std::basic_string<Char> actual = to_string(buffer);
@@ -1224,7 +1224,7 @@ struct formatter<Date> {
   }
 
   auto format(const Date &d, context &ctx) {
-    format_range(ctx.range(), "{}-{}-{}", d.year(), d.month(), d.day());
+    format_to(ctx.begin(), "{}-{}-{}", d.year(), d.month(), d.day());
     return ctx.begin();
   }
 };
@@ -1509,7 +1509,7 @@ class mock_arg_formatter :
 
 void custom_vformat(fmt::string_view format_str, fmt::format_args args) {
   fmt::memory_buffer buffer;
-  fmt::vformat_to<mock_arg_formatter>(buffer, format_str, args);
+  fmt::do_vformat_to<mock_arg_formatter>(buffer, format_str, args);
 }
 
 template <typename... Args>
@@ -1907,3 +1907,18 @@ TEST(FormatTest, FormatStringErrors) {
                "cannot switch from automatic to manual argument indexing",
                int, int);
 }
+
+TEST(FormatTest, OutputIterator) {
+
+  std::string s;
+  fmt::format_to(std::back_inserter(s), "{}", 42);
+  std::vector<char> v;
+  fmt::format_to(std::back_inserter(v), "{}", 42);
+
+  EXPECT_EQ("42", s);
+  EXPECT_EQ("42", std::string(v.begin(), v.end()));
+}
+
+TEST(StringTest, ToString) {
+  EXPECT_EQ("42", fmt::to_string(42));
+}

test/ostream-test.cc

@@ -136,12 +136,12 @@ TEST(OStreamTest, WriteToOStreamMaxSize) {
   if (max_size <= fmt::internal::to_unsigned(max_streamsize))
     return;
 
-  struct TestBuffer : fmt::basic_buffer<char> {
-    explicit TestBuffer(std::size_t size) { resize(size); }
+  struct test_buffer : fmt::buffer {
+    explicit test_buffer(std::size_t size) { resize(size); }
     void grow(std::size_t) {}
   } buffer(max_size);
 
-  struct MockStreamBuf : std::streambuf {
+  struct mock_streambuf : std::streambuf {
     MOCK_METHOD2(xsputn, std::streamsize (const void *s, std::streamsize n));
     std::streamsize xsputn(const char *s, std::streamsize n) {
       const void *v = s;
@@ -149,16 +149,16 @@ TEST(OStreamTest, WriteToOStreamMaxSize) {
     }
   } streambuf;
 
-  struct TestOStream : std::ostream {
-    explicit TestOStream(MockStreamBuf &buffer) : std::ostream(&buffer) {}
+  struct test_ostream : std::ostream {
+    explicit test_ostream(mock_streambuf &buffer) : std::ostream(&buffer) {}
   } os(streambuf);
 
   testing::InSequence sequence;
   const char *data = 0;
   std::size_t size = max_size;
   do {
-    typedef std::make_unsigned<std::streamsize>::type UStreamSize;
-    UStreamSize n = std::min<UStreamSize>(
+    typedef std::make_unsigned<std::streamsize>::type ustreamsize;
+    ustreamsize n = std::min<ustreamsize>(
           size, fmt::internal::to_unsigned(max_streamsize));
     EXPECT_CALL(streambuf, xsputn(data, static_cast<std::streamsize>(n)))
         .WillOnce(testing::Return(max_streamsize));

test/string-test.cc

@@ -1,71 +0,0 @@
-/*
- Tests of string utilities
-
- Copyright (c) 2012 - 2016, Victor Zverovich
- All rights reserved.
-
- For the license information refer to format.h.
- */
-
-#include "fmt/string.h"
-#include "gtest/gtest.h"
-
-using fmt::string_buffer;
-
-TEST(StringBufferTest, Empty) {
-  string_buffer buffer;
-  EXPECT_EQ(0u, buffer.size());
-  EXPECT_EQ(0u, buffer.capacity());
-  std::string data;
-  // std::string may have initial capacity.
-  std::size_t capacity = data.capacity();
-  buffer.move_to(data);
-  EXPECT_EQ("", data);
-  EXPECT_EQ(capacity, data.capacity());
-}
-
-TEST(StringBufferTest, Reserve) {
-  string_buffer buffer;
-  std::size_t capacity = std::string().capacity() + 10;
-  buffer.reserve(capacity);
-  EXPECT_EQ(0u, buffer.size());
-  EXPECT_EQ(capacity, buffer.capacity());
-  std::string data;
-  buffer.move_to(data);
-  EXPECT_EQ("", data);
-}
-
-TEST(StringBufferTest, Resize) {
-  string_buffer buffer;
-  std::size_t size = std::string().capacity() + 10;
-  buffer.resize(size);
-  EXPECT_EQ(size, buffer.size());
-  EXPECT_EQ(size, buffer.capacity());
-  std::string data;
-  buffer.move_to(data);
-  EXPECT_EQ(size, data.size());
-}
-
-TEST(StringBufferTest, MoveTo) {
-  string_buffer buffer;
-  std::size_t size = std::string().capacity() + 10;
-  buffer.resize(size);
-  const char *p = &buffer[0];
-  std::string data;
-  buffer.move_to(data);
-  EXPECT_EQ(p, &data[0]);
-  EXPECT_EQ(0u, buffer.size());
-  EXPECT_EQ(0u, buffer.capacity());
-}
-
-TEST(StringBufferTest, WString) {
-  fmt::wstring_buffer out;
-  out.push_back(L'x');
-  std::wstring s;
-  out.move_to(s);
-  EXPECT_EQ(L"x", s);
-}
-
-TEST(StringTest, ToString) {
-  EXPECT_EQ("42", fmt::to_string(42));
-}

test/util-test.cc

@@ -54,7 +54,7 @@
 #undef max
 
 using fmt::basic_arg;
-using fmt::basic_buffer;
+using fmt::internal::basic_buffer;
 using fmt::basic_memory_buffer;
 using fmt::string_view;
 using fmt::internal::value;
@@ -192,7 +192,7 @@ TEST(BufferTest, Access) {
   EXPECT_EQ(11, buffer[0]);
   buffer[3] = 42;
   EXPECT_EQ(42, *(&buffer[0] + 3));
-  const fmt::basic_buffer<char> &const_buffer = buffer;
+  const basic_buffer<char> &const_buffer = buffer;
   EXPECT_EQ(42, const_buffer[3]);
 }