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

base/strings/string_util_unittest.cc

 // 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 "base/strings/string_util.h"
 
 #include <math.h>
 #include <stdarg.h>
 
 #include <algorithm>
@@ skipping 865 matching lines @@
   EXPECT_FALSE(EndsWith(string16(), ASCIIToUTF16(".plugin"), true));
   EXPECT_TRUE(EndsWith(ASCIIToUTF16("Foo.plugin"), string16(), false));
   EXPECT_TRUE(EndsWith(ASCIIToUTF16("Foo.plugin"), string16(), true));
   EXPECT_TRUE(EndsWith(ASCIIToUTF16(".plugin"),
                        ASCIIToUTF16(".plugin"), false));
   EXPECT_TRUE(EndsWith(ASCIIToUTF16(".plugin"), ASCIIToUTF16(".plugin"), true));
   EXPECT_TRUE(EndsWith(string16(), string16(), false));
   EXPECT_TRUE(EndsWith(string16(), string16(), true));
 }
 
+TEST(StringUtilTest, StdStringReplaceStringPlaceholdersWithMap) {
+  std::map<std::string, std::string> subst;
+  subst.insert(std::pair<std::string, std::string>("one", "9a"));
+  subst.insert(std::pair<std::string, std::string>("b", "8b"));
+  subst.insert(std::pair<std::string, std::string>("cc", "7c"));
+  subst.insert(std::pair<std::string, std::string>("four", "6d"));
+  subst.insert(
+      std::pair<std::string, std::string>("very long with spaces", "5e"));
+  subst.insert(std::pair<std::string, std::string>("", "4f"));
+  subst.insert(std::pair<std::string, std::string>("&", "3g"));
+  subst.insert(std::pair<std::string, std::string>("$", "2h"));
+  subst.insert(std::pair<std::string, std::string>("$$", "1i"));

[Dan Beam, 2015/07/02 02:10:16]

this test brings up a good question: what should we allow as key names?  should
we allow "{"?  so ${{} is legal?

I understand this code should probably be as simple/dumb as possible about
substitution (so it's very clear how it will work), but I think this hampers
readability of templates.

I'd vote for only allowing [a-zA-Z]+ at first, therefore allowing only prettier
substitutions while reading.

[dschuyler, 2015/07/07 23:05:30]

Could that be addressed through style review prior to committing changes?  I
agree that there is value in keeping the code as simple as may be.  We do seem
to do well with code reviews, for example.

I also feel like it's the kind of thing where someone would later want
underscores and then want hyphens -- oh, and numbers.  It feels better to avoid
all those revisions and test cases.

+
+  std::string formatted = ReplaceStringPlaceholders(
+      "${one}a,${b}b,${cc}c,${four}d,${very long with "
+      "spaces}e,${}f,${&}g,${$}h,${$$}i",
+      subst);
+
+  EXPECT_EQ(formatted, "9aa,8bb,7cc,6dd,5ee,4ff,3gg,2hh,1ii");
+}
+
+TEST(StringUtilTest, ReplaceStringPlaceholdersConsecutiveDollarSignsWithMap) {
+  std::map<std::string, std::string> subst;
+  subst.insert(std::pair<std::string, std::string>("a", "9a"));
+  subst.insert(std::pair<std::string, std::string>("b", "8b"));
+  subst.insert(std::pair<std::string, std::string>("c", "7c"));
+  EXPECT_EQ(ReplaceStringPlaceholders("$${a} $$${b} $$$${c} $$", subst),
+            "${a} $${b} $$${c} $");
+  EXPECT_EQ(ReplaceStringPlaceholders("$$", subst), "$");
+  EXPECT_EQ(ReplaceStringPlaceholders("$", subst), "");
+}
+
 TEST(StringUtilTest, GetStringFWithOffsets) {
   std::vector<string16> subst;
   subst.push_back(ASCIIToUTF16("1"));
   subst.push_back(ASCIIToUTF16("2"));
   std::vector<size_t> offsets;
 
   ReplaceStringPlaceholders(ASCIIToUTF16("Hello, $1. Your number is $2."),
                             subst,
                             &offsets);
   EXPECT_EQ(2U, offsets.size());
@@ skipping 330 matching lines @@
   const std::string live = kLive;
   std::string dead = live;
   strncpy(WriteInto(&dead, 5), kDead, 4);
   EXPECT_EQ(kDead, dead);
   EXPECT_EQ(4u, dead.size());
   EXPECT_EQ(kLive, live);
   EXPECT_EQ(4u, live.size());
 }
 
 }  // namespace base