Add new SplitString backend.

base/strings/string_split_unittest.cc

 // Copyright (c) 2012 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_split.h"
 
 #include "base/strings/utf_string_conversions.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
@@ skipping 151 matching lines @@
   EXPECT_EQ("value2", kv_pairs[1].second);
 }
 
 TEST(SplitStringUsingSubstrTest, EmptyString) {
   std::vector<std::string> results;
   SplitStringUsingSubstr(std::string(), "DELIMITER", &results);
   ASSERT_EQ(1u, results.size());
   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);
   EXPECT_EQ(0U, r.size());
   r.clear();
 
   SplitString(L"a,b,c", L',', &r);
   ASSERT_EQ(3U, r.size());
   EXPECT_EQ(r[0], L"a");
   EXPECT_EQ(r[1], L"b");
   EXPECT_EQ(r[2], L"c");
   r.clear();
 
   SplitString(L"a, b, c", L',', &r);
   ASSERT_EQ(3U, r.size());
   EXPECT_EQ(r[0], L"a");
   EXPECT_EQ(r[1], L"b");
   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"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();
 
   SplitString(L"foo", L'*', &r);
   ASSERT_EQ(1U, r.size());
   EXPECT_EQ(r[0], L"foo");
   r.clear();
 
   SplitString(L"foo ,", L',', &r);
@@ skipping 54 matching lines @@
   std::vector<std::string> results;
   SplitStringUsingSubstr(
       "unDELIMITERdeuxDELIMITERtroisDELIMITERquatreDELIMITERDELIMITERDELIMITER",
       "DELIMITER",
       &results);
   ASSERT_EQ(7u, results.size());
   EXPECT_THAT(
       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;
 
   SplitStringDontTrim("   ", '*', &r);
   ASSERT_EQ(1U, r.size());
   EXPECT_EQ(r[0], "   ");
 
   SplitStringDontTrim("\t  \ta\t ", '\t', &r);
   ASSERT_EQ(4U, r.size());
   EXPECT_EQ(r[0], "");
@@ skipping 33 matching lines @@
     SplitStringAlongWhitespace(data[i].input, &results);
     ASSERT_EQ(data[i].expected_result_count, results.size());
     if (data[i].expected_result_count > 0)
       ASSERT_EQ(data[i].output1, results[0]);
     if (data[i].expected_result_count > 1)
       ASSERT_EQ(data[i].output2, results[1]);
   }
 }
 
 }  // namespace base