Forgot to git add so missed a bunch of stuff

libs/format/test/container-test.cc

@@ -0,0 +1,94 @@
+/*
+ Tests of container utilities
+
+ Copyright (c) 2012 - 2016, Victor Zverovich
+ All rights reserved.
+
+ For the license information refer to format.h.
+ */
+
+#include "fmt/container.h"
+#include "gtest/gtest.h"
+
+using fmt::internal::ContainerBuffer;
+
+TEST(ContainerBufferTest, Empty) {
+  std::string data;
+  ContainerBuffer<std::string> buffer(data);
+  EXPECT_EQ(0u, buffer.size());
+  EXPECT_EQ(0u, buffer.capacity());
+}
+
+TEST(ContainerBufferTest, Reserve) {
+  std::string data;
+  ContainerBuffer<std::string> buffer(data);
+  std::size_t capacity = std::string().capacity() + 10;
+  buffer.reserve(capacity);
+  EXPECT_EQ(0u, buffer.size());
+  EXPECT_EQ(capacity, buffer.capacity());
+}
+
+TEST(ContainerBufferTest, Resize) {
+  std::string data;
+  ContainerBuffer<std::string> buffer(data);
+  std::size_t size = std::string().capacity() + 10;
+  buffer.resize(size);
+  EXPECT_EQ(size, buffer.size());
+  EXPECT_EQ(size, buffer.capacity());
+}
+
+TEST(ContainerBufferTest, Append) {
+  std::string data("Why so");
+  const std::string serious(" serious");
+  ContainerBuffer<std::string> buffer(data);
+  buffer.append(serious.c_str(), serious.c_str() + serious.length());
+  EXPECT_EQ("Why so serious", data);
+  EXPECT_EQ(data.length(), buffer.size());
+}
+
+TEST(BasicContainerWriterTest, String) {
+  std::string data;
+  fmt::BasicContainerWriter<std::string> out(data);
+  out << "The answer is " << 42 << "\n";
+  EXPECT_EQ("The answer is 42\n", data);
+  EXPECT_EQ(17u, out.size());
+}
+
+TEST(BasicContainerWriterTest, WString) {
+  std::wstring data;
+  fmt::BasicContainerWriter<std::wstring> out(data);
+  out << "The answer is " << 42 << "\n";
+  EXPECT_EQ(L"The answer is 42\n", data);
+  EXPECT_EQ(17u, out.size());
+}
+
+TEST(BasicContainerWriterTest, Vector) {
+  std::vector<char> data;
+  fmt::BasicContainerWriter<std::vector<char> > out(data);
+  out << "The answer is " << 42 << "\n";
+  EXPECT_EQ(17u, data.size());
+  EXPECT_EQ(out.size(), data.size());
+}
+
+TEST(BasicContainerWriterTest, StringAppend) {
+  std::string data("The");
+  fmt::BasicContainerWriter<std::string> out(data);
+  EXPECT_EQ(3u, data.size());
+  EXPECT_EQ(3u, out.size());
+  out << " answer is " << 42 << "\n";
+  EXPECT_EQ("The answer is 42\n", data);
+  EXPECT_EQ(17u, out.size());
+}
+
+TEST(BasicContainerWriterTest, VectorAppend) {
+  std::vector<char> data;
+  data.push_back('T');
+  data.push_back('h');
+  data.push_back('e');
+  fmt::BasicContainerWriter<std::vector<char> > out(data);
+  EXPECT_EQ(3u, data.size());
+  EXPECT_EQ(3u, out.size());
+  out << " answer is " << 42 << "\n";
+  EXPECT_EQ(17u, data.size());
+  EXPECT_EQ(17u, out.size());
+}

libs/format/test/custom-formatter-test.cc

@@ -0,0 +1,68 @@
+/*
+ Custom argument formatter tests
+
+ Copyright (c) 2016, Victor Zverovich
+ All rights reserved.
+
+ For the license information refer to format.h.
+ */
+
+#include "fmt/printf.h"
+#include "gtest-extra.h"
+
+using fmt::BasicPrintfArgFormatter;
+
+// A custom argument formatter that doesn't print `-` for floating-point values
+// rounded to 0.
+class CustomArgFormatter
+  : public fmt::BasicArgFormatter<CustomArgFormatter, char> {
+ public:
+  CustomArgFormatter(fmt::BasicFormatter<char, CustomArgFormatter> &f,
+                     fmt::FormatSpec &s, const char *fmt)
+  : fmt::BasicArgFormatter<CustomArgFormatter, char>(f, s, fmt) {}
+
+  void visit_double(double value) {
+    if (round(value * pow(10, spec().precision())) == 0)
+      value = 0;
+    fmt::BasicArgFormatter<CustomArgFormatter, char>::visit_double(value);
+  }
+};
+
+// A custom argument formatter that doesn't print `-` for floating-point values
+// rounded to 0.
+class CustomPrintfArgFormatter :
+    public BasicPrintfArgFormatter<CustomPrintfArgFormatter, char> {
+ public:
+  typedef BasicPrintfArgFormatter<CustomPrintfArgFormatter, char> Base;
+
+  CustomPrintfArgFormatter(fmt::BasicWriter<char> &w, fmt::FormatSpec &spec)
+  : Base(w, spec) {}
+
+  void visit_double(double value) {
+    if (round(value * pow(10, spec().precision())) == 0)
+      value = 0;
+    Base::visit_double(value);
+  }
+};
+
+std::string custom_format(const char *format_str, fmt::ArgList args) {
+  fmt::MemoryWriter writer;
+  // Pass custom argument formatter as a template arg to BasicFormatter.
+  fmt::BasicFormatter<char, CustomArgFormatter> formatter(args, writer);
+  formatter.format(format_str);
+  return writer.str();
+}
+FMT_VARIADIC(std::string, custom_format, const char *)
+
+std::string custom_sprintf(const char* format_str, fmt::ArgList args){
+  fmt::MemoryWriter writer;
+  fmt::PrintfFormatter<char, CustomPrintfArgFormatter> formatter(args, writer);
+  formatter.format(format_str);
+  return writer.str();
+}
+FMT_VARIADIC(std::string, custom_sprintf, const char*);
+
+TEST(CustomFormatterTest, Format) {
+  EXPECT_EQ("0.00", custom_format("{:.2f}", -.00001));
+  EXPECT_EQ("0.00", custom_sprintf("%.2f", -.00001));
+}

libs/format/test/string-test.cc

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

libs/format/test/time-test.cc

@@ -0,0 +1,60 @@
+/*
+ Time formatting tests
+
+ Copyright (c) 2012 - 2016, Victor Zverovich
+ All rights reserved.
+
+ For the license information refer to format.h.
+ */
+#ifdef WIN32
+#define _CRT_SECURE_NO_WARNINGS
+#endif
+
+#include "gmock/gmock.h"
+#include "fmt/time.h"
+
+TEST(TimeTest, Format) {
+  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(TimeTest, GrowBuffer) {
+  std::string s = "{:";
+  for (int i = 0; i < 30; ++i)
+    s += "%c";
+  s += "}\n";
+  std::time_t t = std::time(0);
+  fmt::format(s, *std::localtime(&t));
+}
+
+TEST(TimeTest, EmptyResult) {
+  EXPECT_EQ("", fmt::format("{}", std::tm()));
+}
+
+bool EqualTime(const std::tm &lhs, const std::tm &rhs) {
+  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(TimeTest, LocalTime) {
+  std::time_t t = std::time(0);
+  std::tm tm = *std::localtime(&t);
+  EXPECT_TRUE(EqualTime(tm, fmt::localtime(t)));
+}
+
+TEST(TimeTest, GMTime) {
+  std::time_t t = std::time(0);
+  std::tm tm = *std::gmtime(&t);
+  EXPECT_TRUE(EqualTime(tm, fmt::gmtime(t)));
+}