Extend SplitStringIntoKeyValuePairs unit tests.

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 11 matching lines @@
                  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]);
-}
-
 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
+                                           ':',  // Key-value delimiter
+                                           ',',  // Key-value pair delimiter
                                            &kv_pairs));
   EXPECT_TRUE(kv_pairs.empty());
 }
 
-TEST_F(SplitStringIntoKeyValuePairsTest, EmptySecondPair) {
+TEST_F(SplitStringIntoKeyValuePairsTest, MissingKeyValueDelimiter) {
+  EXPECT_FALSE(SplitStringIntoKeyValuePairs("key1,key2:value2",
+                                            ':',  // Key-value delimiter
+                                            ',',  // Key-value pair delimiter
+                                            &kv_pairs));
+  ASSERT_EQ(2U, kv_pairs.size());
+  EXPECT_TRUE(kv_pairs[0].first.empty());
+  EXPECT_TRUE(kv_pairs[0].second.empty());
+  EXPECT_EQ("key2", kv_pairs[1].first);
+  EXPECT_EQ("value2", kv_pairs[1].second);
+}
+
+TEST_F(SplitStringIntoKeyValuePairsTest, EmptyKeyWithKeyValueDelimiter) {
+  EXPECT_TRUE(SplitStringIntoKeyValuePairs(":value1,key2:value2",
+                                           ':',  // Key-value delimiter
+                                           ',',  // Key-value pair delimiter
+                                           &kv_pairs));
+  ASSERT_EQ(2U, kv_pairs.size());
+  EXPECT_TRUE(kv_pairs[0].first.empty());
+  EXPECT_EQ("value1", kv_pairs[0].second);
+  EXPECT_EQ("key2", kv_pairs[1].first);
+  EXPECT_EQ("value2", kv_pairs[1].second);
+}
+
+TEST_F(SplitStringIntoKeyValuePairsTest, TrailingAndLeadingPairDelimiter) {
+  EXPECT_TRUE(SplitStringIntoKeyValuePairs(",key1:value1,key2:value2,",
+                                           ':',   // Key-value delimiter
+                                           ',',   // Key-value pair delimiter
+                                           &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("value2", kv_pairs[1].second);
+}
+
+TEST_F(SplitStringIntoKeyValuePairsTest, EmptyPair) {
   EXPECT_TRUE(SplitStringIntoKeyValuePairs("key1:value1,,key3:value3",
-                                           ':',   // Key-value delimiters
-                                           ',',   // Key-value pair delims
+                                           ':',   // Key-value delimiter
+                                           ',',   // Key-value pair delimiter
                                            &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
+TEST_F(SplitStringIntoKeyValuePairsTest, EmptyValue) {
+  EXPECT_FALSE(SplitStringIntoKeyValuePairs("key1:,key2:value2",
+                                            ':',   // Key-value delimiter
+                                            ',',   // Key-value pair delimiter
                                             &kv_pairs));
   ASSERT_EQ(2U, kv_pairs.size());
   EXPECT_EQ("key1", kv_pairs[0].first);
+  EXPECT_EQ("", kv_pairs[0].second);
+  EXPECT_EQ("key2", kv_pairs[1].first);
+  EXPECT_EQ("value2", kv_pairs[1].second);
+}
+
+TEST_F(SplitStringIntoKeyValuePairsTest, UntrimmedWhitespace) {
+  EXPECT_TRUE(SplitStringIntoKeyValuePairs("key1 : value1",
+                                           ':',  // Key-value delimiter
+                                           ',',  // Key-value pair delimiter
+                                           &kv_pairs));
+  ASSERT_EQ(1U, kv_pairs.size());
+  EXPECT_EQ("key1 ", kv_pairs[0].first);
+  EXPECT_EQ(" value1", kv_pairs[0].second);
+}
+
+TEST_F(SplitStringIntoKeyValuePairsTest, TrimmedWhitespace) {
+  EXPECT_TRUE(SplitStringIntoKeyValuePairs("key1:value1 , key2:value2",
+                                           ':',   // Key-value delimiter
+                                           ',',   // Key-value pair delimiter
+                                           &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);
+  EXPECT_EQ("value2", kv_pairs[1].second);
 }
 
-TEST_F(SplitStringIntoKeyValuePairsTest, DelimiterInValue) {
-  EXPECT_TRUE(SplitStringIntoKeyValuePairs("key1:va:ue1 , key2:value2",
-                                           ':',   // Key-value delimiters
-                                           ',',   // Key-value pair delims
+TEST_F(SplitStringIntoKeyValuePairsTest, MultipleKeyValueDelimiters) {
+  EXPECT_TRUE(SplitStringIntoKeyValuePairs("key1:::value1,key2:value2",
+                                           ':',   // Key-value delimiter
+                                           ',',   // Key-value pair delimiter
                                            &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("value2", kv_pairs[1].second);
+}
+
+TEST_F(SplitStringIntoKeyValuePairsTest, OnlySplitAtGivenSeparator) {
+  std::string a("a ?!@#$%^&*()_+:/{}\\\t\nb");
+  EXPECT_TRUE(SplitStringIntoKeyValuePairs(a + "X" + a + "Y" + a + "X" + a,
+                                           'X',  // Key-value delimiter
+                                           'Y',  // Key-value pair delimiter
+                                           &kv_pairs));
+  ASSERT_EQ(2U, kv_pairs.size());
+  EXPECT_EQ(a, kv_pairs[0].first);
+  EXPECT_EQ(a, kv_pairs[0].second);
+  EXPECT_EQ(a, kv_pairs[1].first);
+  EXPECT_EQ(a, kv_pairs[1].second);
+}
+
+
+TEST_F(SplitStringIntoKeyValuePairsTest, DelimiterInValue) {
+  EXPECT_TRUE(SplitStringIntoKeyValuePairs("key1:va:ue1,key2:value2",
+                                           ':',   // Key-value delimiter
+                                           ',',   // Key-value pair delimiter
+                                           &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;
 
   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");
@@ skipping 135 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