Add a C++ native StringFormat (#1289)

* Add StringFormat
* Use StringFormat

3 files changed, 147 insertions, 37 deletions

diff --git a/Firestore/core/test/firebase/firestore/util/CMakeLists.txt b/Firestore/core/test/firebase/firestore/util/CMakeLists.txt
index ea80ea2..c133e23 100644
--- a/Firestore/core/test/firebase/firestore/util/CMakeLists.txt
+++ b/Firestore/core/test/firebase/firestore/util/CMakeLists.txt
@@ -129,6 +129,7 @@ cc_test(
     status_test.cc
     status_test_util.h
     statusor_test.cc
+    string_format_test.cc
     string_printf_test.cc
     string_util_test.cc
   DEPENDS
diff --git a/Firestore/core/test/firebase/firestore/util/comparison_test.cc b/Firestore/core/test/firebase/firestore/util/comparison_test.cc
index a03aec8..317a830 100644
--- a/Firestore/core/test/firebase/firestore/util/comparison_test.cc
+++ b/Firestore/core/test/firebase/firestore/util/comparison_test.cc
@@ -16,11 +16,10 @@
 
 #include "Firestore/core/src/firebase/firestore/util/comparison.h"
 
-#include <cinttypes>
 #include <cmath>
 #include <limits>
 
-#include "Firestore/core/src/firebase/firestore/util/string_printf.h"
+#include "Firestore/core/src/firebase/firestore/util/string_format.h"
 #include "gtest/gtest.h"
 
 namespace firebase {
@@ -84,47 +83,47 @@ TEST(Comparison, DoubleCompare) {
   ASSERT_SAME(Compare<double>(-0, 0));
 }
 
-#define ASSERT_BIT_EQUALS(expected, actual)                 \
-  do {                                                      \
-    uint64_t expectedBits = DoubleBits(expected);           \
-    uint64_t actualBits = DoubleBits(actual);               \
-    if (expectedBits != actualBits) {                       \
-      std::string message = StringPrintf(                   \
-          "Expected <%f> to compare equal to <%f> "         \
-          "with bits <%" PRIu64 "> equal to <%" PRIu64 ">", \
-          actual, expected, actualBits, expectedBits);      \
-      FAIL() << message;                                    \
-    }                                                       \
+#define ASSERT_BIT_EQUALS(expected, actual)            \
+  do {                                                 \
+    uint64_t expectedBits = DoubleBits(expected);      \
+    uint64_t actualBits = DoubleBits(actual);          \
+    if (expectedBits != actualBits) {                  \
+      std::string message = StringFormat(              \
+          "Expected <%s> to compare equal to <%s> "    \
+          "with bits <%s> equal to <%s>",              \
+          actual, expected, actualBits, expectedBits); \
+      FAIL() << message;                               \
+    }                                                  \
   } while (0);
 
-#define ASSERT_MIXED_SAME(doubleValue, longValue)                              \
-  do {                                                                         \
-    ComparisonResult result = CompareMixedNumber(doubleValue, longValue);      \
-    if (result != ComparisonResult::Same) {                                    \
-      std::string message = StringPrintf(                                      \
-          "Expected <%f> to compare equal to <%lld>", doubleValue, longValue); \
-      FAIL() << message;                                                       \
-    }                                                                          \
+#define ASSERT_MIXED_SAME(doubleValue, longValue)                            \
+  do {                                                                       \
+    ComparisonResult result = CompareMixedNumber(doubleValue, longValue);    \
+    if (result != ComparisonResult::Same) {                                  \
+      std::string message = StringFormat(                                    \
+          "Expected <%s> to compare equal to <%s>", doubleValue, longValue); \
+      FAIL() << message;                                                     \
+    }                                                                        \
   } while (0);
 
-#define ASSERT_MIXED_DESCENDING(doubleValue, longValue)                        \
-  do {                                                                         \
-    ComparisonResult result = CompareMixedNumber(doubleValue, longValue);      \
-    if (result != ComparisonResult::Descending) {                              \
-      std::string message = StringPrintf(                                      \
-          "Expected <%f> to compare equal to <%lld>", doubleValue, longValue); \
-      FAIL() << message;                                                       \
-    }                                                                          \
+#define ASSERT_MIXED_DESCENDING(doubleValue, longValue)                      \
+  do {                                                                       \
+    ComparisonResult result = CompareMixedNumber(doubleValue, longValue);    \
+    if (result != ComparisonResult::Descending) {                            \
+      std::string message = StringFormat(                                    \
+          "Expected <%s> to compare equal to <%s>", doubleValue, longValue); \
+      FAIL() << message;                                                     \
+    }                                                                        \
   } while (0);
 
-#define ASSERT_MIXED_ASCENDING(doubleValue, longValue)                         \
-  do {                                                                         \
-    ComparisonResult result = CompareMixedNumber(doubleValue, longValue);      \
-    if (result != ComparisonResult::Ascending) {                               \
-      std::string message = StringPrintf(                                      \
-          "Expected <%f> to compare equal to <%lld>", doubleValue, longValue); \
-      FAIL() << message;                                                       \
-    }                                                                          \
+#define ASSERT_MIXED_ASCENDING(doubleValue, longValue)                       \
+  do {                                                                       \
+    ComparisonResult result = CompareMixedNumber(doubleValue, longValue);    \
+    if (result != ComparisonResult::Ascending) {                             \
+      std::string message = StringFormat(                                    \
+          "Expected <%s> to compare equal to <%s>", doubleValue, longValue); \
+      FAIL() << message;                                                     \
+    }                                                                        \
   } while (0);
 
 TEST(Comparison, MixedNumberCompare) {
diff --git a/Firestore/core/test/firebase/firestore/util/string_format_test.cc b/Firestore/core/test/firebase/firestore/util/string_format_test.cc
new file mode 100644
index 0000000..f0ec20d
--- /dev/null
+++ b/Firestore/core/test/firebase/firestore/util/string_format_test.cc
@@ -0,0 +1,110 @@
+/*
+ * Copyright 2018 Google
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "Firestore/core/src/firebase/firestore/util/string_format.h"
+
+#include "absl/strings/string_view.h"
+#include "gtest/gtest.h"
+
+namespace firebase {
+namespace firestore {
+namespace util {
+
+TEST(StringFormatTest, Empty) {
+  EXPECT_EQ("", StringFormat(""));
+  EXPECT_EQ("", StringFormat("%s", std::string().c_str()));
+  EXPECT_EQ("", StringFormat("%s", ""));
+}
+
+TEST(StringFormatTest, CString) {
+  EXPECT_EQ("Hello World", StringFormat("Hello %s", "World"));
+  EXPECT_EQ("Hello World", StringFormat("%s World", "Hello"));
+  EXPECT_EQ("Hello World", StringFormat("Hello%sWorld", " "));
+
+  const char* value = "World";
+  EXPECT_EQ("Hello World", StringFormat("Hello %s", value));
+
+  value = nullptr;
+  EXPECT_EQ("Hello null", StringFormat("Hello %s", value));
+}
+
+TEST(StringFormatTest, String) {
+  EXPECT_EQ("Hello World", StringFormat("Hello %s", std::string{"World"}));
+
+  std::string value{"World"};
+  EXPECT_EQ("Hello World", StringFormat("Hello %s", value));
+}
+
+TEST(StringFormatTest, StringView) {
+  EXPECT_EQ("Hello World",
+            StringFormat("Hello %s", absl::string_view{"World"}));
+  EXPECT_EQ("Hello World",
+            StringFormat("%s World", absl::string_view{"Hello"}));
+  EXPECT_EQ("Hello World",
+            StringFormat("Hello%sWorld", absl::string_view{" "}));
+}
+
+TEST(StringFormatTest, Int) {
+  std::string value = StringFormat("Hello %s", 123);
+  EXPECT_EQ("Hello 123", value);
+}
+
+TEST(StringFormatTest, Float) {
+  std::string value = StringFormat("Hello %s", 1.5);
+  EXPECT_EQ("Hello 1.5", value);
+}
+
+TEST(StringFormatTest, Bool) {
+  EXPECT_EQ("Hello true", StringFormat("Hello %s", true));
+  EXPECT_EQ("Hello false", StringFormat("Hello %s", false));
+}
+
+TEST(StringFormatTest, Pointer) {
+  // pointers implicitly convert to bool. Make sure this doesn't happen in
+  // this API.
+  int value = 4;
+  EXPECT_NE("Hello true", StringFormat("Hello %s", &value));
+  EXPECT_EQ("Hello null", StringFormat("Hello %s", nullptr));
+}
+
+TEST(StringFormatTest, Mixed) {
+  EXPECT_EQ("string=World, bool=true, int=42, float=1.5",
+            StringFormat("string=%s, bool=%s, int=%s, float=%s", "World", true,
+                         42, 1.5));
+  EXPECT_EQ("World%true%42%1.5",
+            StringFormat("%s%%%s%%%s%%%s", "World", true, 42, 1.5));
+}
+
+TEST(StringFormatTest, Literal) {
+  EXPECT_EQ("Hello %", StringFormat("Hello %%"));
+  EXPECT_EQ("% World", StringFormat("%% World"));
+}
+
+TEST(StringFormatTest, Invalid) {
+  EXPECT_EQ("Hello <invalid>", StringFormat("Hello %@", 42));
+}
+
+TEST(StringFormatTest, Missing) {
+  EXPECT_EQ("Hello <missing>", StringFormat("Hello %s"));
+}
+
+TEST(StringFormatTest, Excess) {
+  EXPECT_EQ("Hello World", StringFormat("Hello %s", "World", 42));
+}
+
+}  //  namespace util
+}  //  namespace firestore
+}  //  namespace firebase