[ui/base;css] adding string template expression replacement

ui/base/template_expressions_unittest.cc

Index: ui/base/template_expressions_unittest.cc
diff --git a/ui/base/template_expressions_unittest.cc b/ui/base/template_expressions_unittest.cc
new file mode 100644
index 0000000000000000000000000000000000000000..3450d1e3164885651244e5c7ee90d9ca1e826cfa
--- /dev/null
+++ b/ui/base/template_expressions_unittest.cc
@@ -0,0 +1,49 @@
+// Copyright 2013 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "ui/base/template_expressions.h"
+
+#include "base/strings/utf_string_conversions.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace ui {
+
+TEST(TemplateExpressionsTest, ReplaceTemplateExpressionsPieces) {
+  std::map<base::StringPiece, std::string> substitutions;
+  substitutions["one"] = "9a";
+  substitutions["b"] = "8b";
+  substitutions["cc"] = "7c";
+  substitutions["four"] = "6d";
+  substitutions["very long with spaces"] = "5e";
+  substitutions[""] = "4f";
+  substitutions["&"] = "3g";
+  substitutions["$"] = "2h";
+  substitutions["$$"] = "1i";
+
+  EXPECT_STREQ(
+      ReplaceTemplateExpressions("${ab${cd}ef}", substitutions).c_str(), "ef}");
+  EXPECT_STREQ(ReplaceTemplateExpressions("${}", substitutions).c_str(), "4f");
+  EXPECT_STREQ(ReplaceTemplateExpressions("", substitutions).c_str(), "");

[Dan Beam, 2015/07/14 21:23:40]

it seems like you do the same thing pretty often.  why not:

  namespace {

  void CheckTemplate(const std::map<base::StringPiece, std::string>& data,
                     const char* template, const char* expected) {
    EXPECT_STREQ(expected, ReplaceTemplateExpressions(template, data).c_str());
  }

  }  // namespace

  ...

  std::map<base::StringPiece, std::string> substitutions;
  substitutions[""] = "4f";
  CheckTemplate(substitutions, "${}", "4f");

[dschuyler, 2015/07/15 00:11:04]

On why not, well it kinda feels like adding more code.  Why not go back to
EXPECT_EQ and let the base string do the string compare?  :)  I feel like I may
be misunderstanding something.  Why is converting it to a char* better than
doing the operator== compare?

[Dan Beam, 2015/07/15 16:36:25]

because you have to add a helper method?
are you asking why EXPECT_STREQ is better?  because the answer to that is "it
shows a better diff".

[dschuyler, 2015/07/15 18:47:05]

Based on the new info that the EXPECT_EQ works well, I've switched back to that.

Done.

+  EXPECT_STREQ(ReplaceTemplateExpressions(
+                   "${one}a,${b}b,${cc}c,${four}d,${very long with "
+                   "spaces}e,${}f,${&}g,${$}h,${$$}i",
+                   substitutions).c_str(),
+               "9aa,8bb,7cc,6dd,5ee,4ff,3gg,2hh,1ii");
+}
+
+TEST(TemplateExpressionsTest,
+     ReplaceTemplateExpressionsConsecutiveDollarSignsPieces) {
+  std::map<base::StringPiece, std::string> substitutions;
+  substitutions["a"] = "9a";
+  substitutions["b"] = "8b";
+  substitutions["c"] = "7c";
+  EXPECT_STREQ(ReplaceTemplateExpressions("$${a} $$${b} $$$${c} $$",
+                                          substitutions).c_str(),
+               "${a} $${b} $$${c} $");
+  EXPECT_STREQ(ReplaceTemplateExpressions("$12", substitutions).c_str(), "12");
+  EXPECT_STREQ(ReplaceTemplateExpressions("$$", substitutions).c_str(), "$");
+  EXPECT_STREQ(ReplaceTemplateExpressions("$", substitutions).c_str(), "");
+}
+
+}  // namespace ui