Add new SplitString backend.

base/strings/string_split_unittest.cc

Index: base/strings/string_split_unittest.cc
diff --git a/base/strings/string_split_unittest.cc b/base/strings/string_split_unittest.cc
index 32bbe28b65f2f160c837d9d9b11e31e08b19c4c3..b635beccc29c399f44f08d9997a2fb3042dafaaa 100644
--- a/base/strings/string_split_unittest.cc
+++ b/base/strings/string_split_unittest.cc
@@ -169,7 +169,81 @@ TEST(SplitStringUsingSubstrTest, EmptyString) {
   EXPECT_THAT(results, ElementsAre(""));
 }
 
-TEST(StringUtilTest, SplitString) {
+TEST(StringUtilTest, SplitString_Basics) {
+  std::vector<std::string> r;
+
+  r = SplitString(std::string(), ",:;", KEEP_WHITESPACE, SPLIT_WANT_ALL);
+  EXPECT_TRUE(r.empty());
+
+  // Empty separator list
+  r = SplitString("hello, world", "", KEEP_WHITESPACE, SPLIT_WANT_ALL);
+  ASSERT_EQ(1u, r.size());
+  EXPECT_EQ("hello, world", r[0]);
+
+  // Should split on any of the separators.
+  r = SplitString("::,,;;", ",:;", KEEP_WHITESPACE, SPLIT_WANT_ALL);
+  ASSERT_EQ(7u, r.size());
+  for (auto str : r)
+    ASSERT_TRUE(str.empty());
+
+  r = SplitString("red, green; blue:", ",:;", TRIM_WHITESPACE,
+                  SPLIT_WANT_NONEMPTY);
+  ASSERT_EQ(3u, r.size());
+  EXPECT_EQ("red", r[0]);
+  EXPECT_EQ("green", r[1]);
+  EXPECT_EQ("blue", r[2]);
+
+  // Want to split a string along whitespace sequences.
+  r = SplitString("  red green   \tblue\n", " \t\n", TRIM_WHITESPACE,
+                  SPLIT_WANT_NONEMPTY);
+  ASSERT_EQ(3u, r.size());
+  EXPECT_EQ("red", r[0]);
+  EXPECT_EQ("green", r[1]);
+  EXPECT_EQ("blue", r[2]);
+
+  // Weird case of splitting on spaces but not trimming.
+  r = SplitString(" red ", " ", TRIM_WHITESPACE, SPLIT_WANT_ALL);
+  ASSERT_EQ(3u, r.size());
+  EXPECT_EQ("", r[0]);  // Before the first space.
+  EXPECT_EQ("red", r[1]);
+  EXPECT_EQ("", r[2]);  // After the last space.
+}
+
+TEST(StringUtilTest, SplitString_WhitespaceAndResultType) {
+  std::vector<std::string> r;
+
+  // Empty input handling.
+  r = SplitString(std::string(), ",", KEEP_WHITESPACE, SPLIT_WANT_ALL);
+  EXPECT_TRUE(r.empty());
+  r = SplitString(std::string(), ",", KEEP_WHITESPACE, SPLIT_WANT_NONEMPTY);
+  EXPECT_TRUE(r.empty());
+
+  // Input string is space and we're trimming.
+  r = SplitString(" ", ",", TRIM_WHITESPACE, SPLIT_WANT_ALL);
+  ASSERT_EQ(1u, r.size());
+  EXPECT_EQ("", r[0]);
+  r = SplitString(" ", ",", TRIM_WHITESPACE, SPLIT_WANT_NONEMPTY);
+  EXPECT_TRUE(r.empty());
+
+  // Test all 4 combinations of flags on ", ,".
+  r = SplitString(", ,", ",", KEEP_WHITESPACE, SPLIT_WANT_ALL);
+  ASSERT_EQ(3u, r.size());
+  EXPECT_EQ("", r[0]);
+  EXPECT_EQ(" ", r[1]);
+  EXPECT_EQ("", r[2]);
+  r = SplitString(", ,", ",", KEEP_WHITESPACE, SPLIT_WANT_NONEMPTY);
+  ASSERT_EQ(1u, r.size());
+  ASSERT_EQ(" ", r[0]);
+  r = SplitString(", ,", ",", TRIM_WHITESPACE, SPLIT_WANT_ALL);
+  ASSERT_EQ(3u, r.size());
+  EXPECT_EQ("", r[0]);
+  EXPECT_EQ("", r[1]);
+  EXPECT_EQ("", r[2]);
+  r = SplitString(", ,", ",", TRIM_WHITESPACE, SPLIT_WANT_NONEMPTY);
+  ASSERT_TRUE(r.empty());
+}
+
+TEST(StringUtilTest, SplitString_Legacy) {
   std::vector<std::wstring> r;
 
   SplitString(std::wstring(), L',', &r);
@@ -197,6 +271,13 @@ TEST(StringUtilTest, SplitString) {
   EXPECT_EQ(r[2], L"c");
   r.clear();
 
+  SplitString(L"a, ,c", L',', &r);
+  ASSERT_EQ(3U, r.size());
+  EXPECT_EQ(r[0], L"a");
+  EXPECT_EQ(r[1], L"");
+  EXPECT_EQ(r[2], L"c");
+  r.clear();
+
   SplitString(L"   ", L'*', &r);
   EXPECT_EQ(0U, r.size());
   r.clear();
@@ -271,6 +352,88 @@ TEST(SplitStringUsingSubstrTest, TrailingDelimitersSkipped) {
       results, ElementsAre("un", "deux", "trois", "quatre", "", "", ""));
 }
 
+/*

[danakj, 2015/06/11 23:58:35]

New test commented out?

[brettw, 2015/06/12 17:37:08]

I removed this. This was the Tokenize unit test (a previous version of the patch
had removed it from string_util_unittest). The current patch opts to keep the
current Tokenize unit tests unchanged to verify backwards-compat. When I remove
Tokenize(), I'll check if those tests cover any interesting cases that the other
StringPiece ones don't.

+TEST(StringUtilTest, SplitStringUsingSet) {
+  std::vector<std::string> r;
+
+  SplitStringUsingSet(std::string("This is a string"), std::string(" "), &r);
+  ASSERT_EQ(4U, r.size());
+  EXPECT_EQ(r[0], std::string("This"));
+  EXPECT_EQ(r[1], std::string("is"));
+  EXPECT_EQ(r[2], std::string("a"));
+  EXPECT_EQ(r[3], std::string("string"));
+  r.clear();
+
+  SplitStringUsingSet(std::string("one,two,three"), std::string(","), &r);
+  ASSERT_EQ(3U, r.size());
+  EXPECT_EQ(r[0], std::string("one"));
+  EXPECT_EQ(r[1], std::string("two"));
+  EXPECT_EQ(r[2], std::string("three"));
+  r.clear();
+
+  SplitStringUsingSet(std::string("one,two:three;four"), std::string(",:"), &r);
+  ASSERT_EQ(3U, r.size());
+  EXPECT_EQ(r[0], std::string("one"));
+  EXPECT_EQ(r[1], std::string("two"));
+  EXPECT_EQ(r[2], std::string("three;four"));
+  r.clear();
+
+  SplitStringUsingSet(std::string("one,two:three;four"), std::string(";,:"),
+                      &r);
+  ASSERT_EQ(4U, r.size());
+  EXPECT_EQ(r[0], std::string("one"));
+  EXPECT_EQ(r[1], std::string("two"));
+  EXPECT_EQ(r[2], std::string("three"));
+  EXPECT_EQ(r[3], std::string("four"));
+  r.clear();
+
+  SplitStringUsingSet(std::string("one, two, three"), std::string(","), &r);
+  ASSERT_EQ(3U, r.size());
+  EXPECT_EQ(r[0], std::string("one"));
+  EXPECT_EQ(r[1], std::string(" two"));
+  EXPECT_EQ(r[2], std::string(" three"));
+  r.clear();
+
+  SplitStringUsingSet(std::string("one, two, three, "), std::string(","), &r);
+  ASSERT_EQ(4U, r.size());
+  EXPECT_EQ(r[0], std::string("one"));
+  EXPECT_EQ(r[1], std::string(" two"));
+  EXPECT_EQ(r[2], std::string(" three"));
+  EXPECT_EQ(r[3], std::string(" "));
+  r.clear();
+
+  SplitStringUsingSet(std::string("one, two, three,"), std::string(","), &r);
+  ASSERT_EQ(3U, r.size());
+  EXPECT_EQ(r[0], std::string("one"));
+  EXPECT_EQ(r[1], std::string(" two"));
+  EXPECT_EQ(r[2], std::string(" three"));
+  r.clear();
+
+  SplitStringUsingSet(std::string(), std::string(","), &r);
+  ASSERT_EQ(0U, r.size());
+  r.clear();
+
+  SplitStringUsingSet(std::string(","), std::string(","), &r);
+  ASSERT_EQ(0U, r.size());
+  r.clear();
+
+  SplitStringUsingSet(std::string(",;:."), std::string(".:;,"), &r);
+  ASSERT_EQ(0U, r.size());
+  r.clear();
+
+  SplitStringUsingSet(std::string("\t\ta\t"), std::string("\t"), &r);
+  ASSERT_EQ(1U, r.size());
+  EXPECT_EQ(r[0], std::string("a"));
+  r.clear();
+
+  SplitStringUsingSet(std::string("\ta\t\nb\tcc"), std::string("\n"), &r);
+  ASSERT_EQ(2U, r.size());
+  EXPECT_EQ(r[0], std::string("\ta\t"));
+  EXPECT_EQ(r[1], std::string("b\tcc"));
+  r.clear();
+}
+*/
+
 TEST(StringSplitTest, StringSplitDontTrim) {
   std::vector<std::string> r;