Integrate SplitString into libaddressinput.

This patch removes unnecessary functions and dependencies from SplitString
and includes it in the build of libaddressinput.

BUG=327046

Review URL: https://codereview.chromium.org/113493002

git-svn-id: http://libaddressinput.googlecode.com/svn/trunk@179 38ededc0-08b8-5190-f2ac-b31f878777ad

1 files changed, 45 insertions, 274 deletions

diff --git a/cpp/test/util/string_split_unittest.cc b/cpp/test/util/string_split_unittest.cc
index 996e22f..73ca595 100644
--- a/cpp/test/util/string_split_unittest.cc
+++ b/cpp/test/util/string_split_unittest.cc
@@ -1,318 +1,89 @@
 // 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.
+//
+// The original source code is from:
+// http://src.chromium.org/viewvc/chrome/trunk/src/base/strings/string_split_unittest.cc?revision=216633
 
-#include "base/strings/string_split.h"
+#include "util/string_split.h"
 
-#include "base/strings/utf_string_conversions.h"
-#include "testing/gmock/include/gmock/gmock.h"
-#include "testing/gtest/include/gtest/gtest.h"
+#include <string>
+#include <vector>
 
-using ::testing::ElementsAre;
-
-namespace base {
+#include <gtest/gtest.h>
 
 namespace {
 
-#if !defined(WCHAR_T_IS_UTF16)
-// Overload SplitString with a wide-char version to make it easier to
-// test the string16 version with wide character literals.
-void SplitString(const std::wstring& str,
-                 wchar_t c,
-                 std::vector<std::wstring>* result) {
-  std::vector<string16> result16;
-  SplitString(WideToUTF16(str), c, &result16);
-  for (size_t i = 0; i < result16.size(); ++i)
-    result->push_back(UTF16ToWide(result16[i]));
-}
-#endif
-
-}  // anonymous namespace
-
-class SplitStringIntoKeyValuesTest : public testing::Test {
- protected:
-  std::string key;
-  std::vector<std::string> values;
-};
-
-TEST_F(SplitStringIntoKeyValuesTest, EmptyInputMultipleValues) {
-  EXPECT_FALSE(SplitStringIntoKeyValues(std::string(),  // Empty input
-                                        '\t',           // Key separators
-                                        &key,
-                                        &values));
-  EXPECT_TRUE(key.empty());
-  EXPECT_TRUE(values.empty());
-}
-
-TEST_F(SplitStringIntoKeyValuesTest, EmptyValueInputMultipleValues) {
-  EXPECT_FALSE(SplitStringIntoKeyValues("key_with_no_value\t",
-                                        '\t',  // Key separators
-                                        &key, &values));
-  EXPECT_EQ("key_with_no_value", key);
-  EXPECT_TRUE(values.empty());
-}
-
-TEST_F(SplitStringIntoKeyValuesTest, EmptyKeyInputMultipleValues) {
-  EXPECT_TRUE(SplitStringIntoKeyValues("\tvalue for empty key",
-                                       '\t',  // Key separators
-                                       &key, &values));
-  EXPECT_TRUE(key.empty());
-  ASSERT_EQ(1U, values.size());
-}
-
-TEST_F(SplitStringIntoKeyValuesTest, KeyWithMultipleValues) {
-  EXPECT_TRUE(SplitStringIntoKeyValues("key1\tvalue1,   value2   value3",
-                                       '\t',  // Key separators
-                                       &key, &values));
-  EXPECT_EQ("key1", key);
-  ASSERT_EQ(1U, values.size());
-  EXPECT_EQ("value1,   value2   value3", values[0]);
-}
-
-TEST_F(SplitStringIntoKeyValuesTest, EmptyInputSingleValue) {
-  EXPECT_FALSE(SplitStringIntoKeyValues(std::string(),  // Empty input
-                                        '\t',           // Key separators
-                                        &key,
-                                        &values));
-  EXPECT_TRUE(key.empty());
-  EXPECT_TRUE(values.empty());
-}
-
-TEST_F(SplitStringIntoKeyValuesTest, EmptyValueInputSingleValue) {
-  EXPECT_FALSE(SplitStringIntoKeyValues("key_with_no_value\t",
-                                        '\t',  // Key separators
-                                        &key, &values));
-  EXPECT_EQ("key_with_no_value", key);
-  EXPECT_TRUE(values.empty());
-}
-
-TEST_F(SplitStringIntoKeyValuesTest, EmptyKeyInputSingleValue) {
-  EXPECT_TRUE(SplitStringIntoKeyValues("\tvalue for empty key",
-                                       '\t',  // Key separators
-                                       &key, &values));
-  EXPECT_TRUE(key.empty());
-  ASSERT_EQ(1U, values.size());
-  EXPECT_EQ("value for empty key", values[0]);
-}
-
-TEST_F(SplitStringIntoKeyValuesTest, KeyWithSingleValue) {
-  EXPECT_TRUE(SplitStringIntoKeyValues("key1\tvalue1,   value2   value3",
-                                       '\t',  // Key separators
-                                       &key, &values));
-  EXPECT_EQ("key1", key);
-  ASSERT_EQ(1U, values.size());
-  EXPECT_EQ("value1,   value2   value3", values[0]);
-}
+using i18n::addressinput::SplitString;
 
-class SplitStringIntoKeyValuePairsTest : public testing::Test {
- protected:
-  std::vector<std::pair<std::string, std::string> > kv_pairs;
-};
-
-TEST_F(SplitStringIntoKeyValuePairsTest, EmptyString) {
-  EXPECT_TRUE(SplitStringIntoKeyValuePairs(std::string(),
-                                           ':',  // Key-value delimiters
-                                           ',',  // Key-value pair delims
-                                           &kv_pairs));
-  EXPECT_TRUE(kv_pairs.empty());
-}
-
-TEST_F(SplitStringIntoKeyValuePairsTest, EmptySecondPair) {
-  EXPECT_TRUE(SplitStringIntoKeyValuePairs("key1:value1,,key3:value3",
-                                           ':',   // Key-value delimiters
-                                           ',',   // Key-value pair delims
-                                           &kv_pairs));
-  ASSERT_EQ(2U, kv_pairs.size());
-  EXPECT_EQ("key1", kv_pairs[0].first);
-  EXPECT_EQ("value1", kv_pairs[0].second);
-  EXPECT_EQ("key3", kv_pairs[1].first);
-  EXPECT_EQ("value3", kv_pairs[1].second);
-}
-
-TEST_F(SplitStringIntoKeyValuePairsTest, EmptySecondValue) {
-  EXPECT_FALSE(SplitStringIntoKeyValuePairs("key1:value1 , key2:",
-                                            ':',   // Key-value delimiters
-                                            ',',   // Key-value pair delims
-                                            &kv_pairs));
-  ASSERT_EQ(2U, kv_pairs.size());
-  EXPECT_EQ("key1", kv_pairs[0].first);
-  EXPECT_EQ("value1", kv_pairs[0].second);
-  EXPECT_EQ("key2", kv_pairs[1].first);
-  EXPECT_EQ("", kv_pairs[1].second);
-}
-
-TEST_F(SplitStringIntoKeyValuePairsTest, DelimiterInValue) {
-  EXPECT_TRUE(SplitStringIntoKeyValuePairs("key1:va:ue1 , key2:value2",
-                                           ':',   // Key-value delimiters
-                                           ',',   // Key-value pair delims
-                                           &kv_pairs));
-  ASSERT_EQ(2U, kv_pairs.size());
-  EXPECT_EQ("key1", kv_pairs[0].first);
-  EXPECT_EQ("va:ue1", kv_pairs[0].second);
-  EXPECT_EQ("key2", kv_pairs[1].first);
-  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 for SplitString
-TEST(StringUtilTest, SplitString) {
-  std::vector<std::wstring> r;
+TEST(StringSplitTest, SplitString) {
+  std::vector<std::string> r;
 
-  SplitString(std::wstring(), L',', &r);
+  SplitString(std::string(), ',', &r);
   EXPECT_EQ(0U, r.size());
-  r.clear();
 
-  SplitString(L"a,b,c", L',', &r);
+  SplitString("a,b,c", ',', &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();
+  EXPECT_EQ(r[0], "a");
+  EXPECT_EQ(r[1], "b");
+  EXPECT_EQ(r[2], "c");
 
-  SplitString(L"a, b, c", L',', &r);
+  SplitString("a, b, c", ',', &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();
+  EXPECT_EQ(r[0], "a");
+  EXPECT_EQ(r[1], " b");
+  EXPECT_EQ(r[2], " c");
 
-  SplitString(L"a,,c", L',', &r);
+  SplitString("a,,c", ',', &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();
+  EXPECT_EQ(r[0], "a");
+  EXPECT_EQ(r[1], "");
+  EXPECT_EQ(r[2], "c");
 
-  SplitString(L"   ", L'*', &r);
-  EXPECT_EQ(0U, r.size());
-  r.clear();
+  SplitString("   ", '*', &r);
+  EXPECT_EQ(1U, r.size());
 
-  SplitString(L"foo", L'*', &r);
+  SplitString("foo", '*', &r);
   ASSERT_EQ(1U, r.size());
-  EXPECT_EQ(r[0], L"foo");
-  r.clear();
+  EXPECT_EQ(r[0], "foo");
 
-  SplitString(L"foo ,", L',', &r);
+  SplitString("foo ,", ',', &r);
   ASSERT_EQ(2U, r.size());
-  EXPECT_EQ(r[0], L"foo");
-  EXPECT_EQ(r[1], L"");
-  r.clear();
+  EXPECT_EQ(r[0], "foo ");
+  EXPECT_EQ(r[1], "");
 
-  SplitString(L",", L',', &r);
+  SplitString(",", ',', &r);
   ASSERT_EQ(2U, r.size());
-  EXPECT_EQ(r[0], L"");
-  EXPECT_EQ(r[1], L"");
-  r.clear();
+  EXPECT_EQ(r[0], "");
+  EXPECT_EQ(r[1], "");
 
-  SplitString(L"\t\ta\t", L'\t', &r);
+  SplitString("\t\ta\t", '\t', &r);
   ASSERT_EQ(4U, r.size());
-  EXPECT_EQ(r[0], L"");
-  EXPECT_EQ(r[1], L"");
-  EXPECT_EQ(r[2], L"a");
-  EXPECT_EQ(r[3], L"");
-  r.clear();
+  EXPECT_EQ(r[0], "");
+  EXPECT_EQ(r[1], "");
+  EXPECT_EQ(r[2], "a");
+  EXPECT_EQ(r[3], "");
 
-  SplitString(L"\ta\t\nb\tcc", L'\n', &r);
+  SplitString("\ta\t\nb\tcc", '\n', &r);
   ASSERT_EQ(2U, r.size());
-  EXPECT_EQ(r[0], L"a");
-  EXPECT_EQ(r[1], L"b\tcc");
-  r.clear();
-}
-
-TEST(SplitStringUsingSubstrTest, StringWithNoDelimiter) {
-  std::vector<std::string> results;
-  SplitStringUsingSubstr("alongwordwithnodelimiter", "DELIMITER", &results);
-  ASSERT_EQ(1u, results.size());
-  EXPECT_THAT(results, ElementsAre("alongwordwithnodelimiter"));
-}
-
-TEST(SplitStringUsingSubstrTest, LeadingDelimitersSkipped) {
-  std::vector<std::string> results;
-  SplitStringUsingSubstr(
-      "DELIMITERDELIMITERDELIMITERoneDELIMITERtwoDELIMITERthree",
-      "DELIMITER",
-      &results);
-  ASSERT_EQ(6u, results.size());
-  EXPECT_THAT(results, ElementsAre("", "", "", "one", "two", "three"));
-}
-
-TEST(SplitStringUsingSubstrTest, ConsecutiveDelimitersSkipped) {
-  std::vector<std::string> results;
-  SplitStringUsingSubstr(
-      "unoDELIMITERDELIMITERDELIMITERdosDELIMITERtresDELIMITERDELIMITERcuatro",
-      "DELIMITER",
-      &results);
-  ASSERT_EQ(7u, results.size());
-  EXPECT_THAT(results, ElementsAre("uno", "", "", "dos", "tres", "", "cuatro"));
-}
-
-TEST(SplitStringUsingSubstrTest, TrailingDelimitersSkipped) {
-  std::vector<std::string> results;
-  SplitStringUsingSubstr(
-      "unDELIMITERdeuxDELIMITERtroisDELIMITERquatreDELIMITERDELIMITERDELIMITER",
-      "DELIMITER",
-      &results);
-  ASSERT_EQ(7u, results.size());
-  EXPECT_THAT(
-      results, ElementsAre("un", "deux", "trois", "quatre", "", "", ""));
-}
-
-TEST(StringSplitTest, StringSplitDontTrim) {
-  std::vector<std::string> r;
+  EXPECT_EQ(r[0], "\ta\t");
+  EXPECT_EQ(r[1], "b\tcc");
 
-  SplitStringDontTrim("   ", '*', &r);
+  SplitString("   ", '*', &r);
   ASSERT_EQ(1U, r.size());
   EXPECT_EQ(r[0], "   ");
 
-  SplitStringDontTrim("\t  \ta\t ", '\t', &r);
+  SplitString("\t  \ta\t ", '\t', &r);
   ASSERT_EQ(4U, r.size());
   EXPECT_EQ(r[0], "");
   EXPECT_EQ(r[1], "  ");
   EXPECT_EQ(r[2], "a");
   EXPECT_EQ(r[3], " ");
 
-  SplitStringDontTrim("\ta\t\nb\tcc", '\n', &r);
+  SplitString("\ta\t\nb\tcc", '\n', &r);
   ASSERT_EQ(2U, r.size());
   EXPECT_EQ(r[0], "\ta\t");
   EXPECT_EQ(r[1], "b\tcc");
 }
 
-TEST(StringSplitTest, SplitStringAlongWhitespace) {
-  struct TestData {
-    const char* input;
-    const size_t expected_result_count;
-    const char* output1;
-    const char* output2;
-  } data[] = {
-    { "a",       1, "a",  ""   },
-    { " ",       0, "",   ""   },
-    { " a",      1, "a",  ""   },
-    { " ab ",    1, "ab", ""   },
-    { " ab c",   2, "ab", "c"  },
-    { " ab c ",  2, "ab", "c"  },
-    { " ab cd",  2, "ab", "cd" },
-    { " ab cd ", 2, "ab", "cd" },
-    { " \ta\t",  1, "a",  ""   },
-    { " b\ta\t", 2, "b",  "a"  },
-    { " b\tat",  2, "b",  "at" },
-    { "b\tat",   2, "b",  "at" },
-    { "b\t at",  2, "b",  "at" },
-  };
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(data); ++i) {
-    std::vector<std::string> results;
-    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
+}  // namespace