1// Copyright (c) 2010 The Chromium Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
5#include "base/string_split.h"
6#include "testing/gmock/include/gmock/gmock.h"
7#include "testing/gtest/include/gtest/gtest.h"
8
9using ::testing::ElementsAre;
10
11namespace base {
12
13class SplitStringIntoKeyValuesTest : public testing::Test {
14 protected:
15  std::string key;
16  std::vector<std::string> values;
17};
18
19TEST_F(SplitStringIntoKeyValuesTest, EmptyInputMultipleValues) {
20  EXPECT_FALSE(SplitStringIntoKeyValues("",     // Empty input
21                                        '\t',   // Key separators
22                                        &key, &values));
23  EXPECT_TRUE(key.empty());
24  EXPECT_TRUE(values.empty());
25}
26
27TEST_F(SplitStringIntoKeyValuesTest, EmptyValueInputMultipleValues) {
28  EXPECT_FALSE(SplitStringIntoKeyValues("key_with_no_value\t",
29                                        '\t',  // Key separators
30                                        &key, &values));
31  EXPECT_EQ("key_with_no_value", key);
32  EXPECT_TRUE(values.empty());
33}
34
35TEST_F(SplitStringIntoKeyValuesTest, EmptyKeyInputMultipleValues) {
36  EXPECT_TRUE(SplitStringIntoKeyValues("\tvalue for empty key",
37                                       '\t',  // Key separators
38                                       &key, &values));
39  EXPECT_TRUE(key.empty());
40  ASSERT_EQ(1U, values.size());
41}
42
43TEST_F(SplitStringIntoKeyValuesTest, KeyWithMultipleValues) {
44  EXPECT_TRUE(SplitStringIntoKeyValues("key1\tvalue1,   value2   value3",
45                                       '\t',  // Key separators
46                                       &key, &values));
47  EXPECT_EQ("key1", key);
48  ASSERT_EQ(1U, values.size());
49  EXPECT_EQ("value1,   value2   value3", values[0]);
50}
51
52TEST_F(SplitStringIntoKeyValuesTest, EmptyInputSingleValue) {
53  EXPECT_FALSE(SplitStringIntoKeyValues("",     // Empty input
54                                        '\t',   // Key separators
55                                        &key, &values));
56  EXPECT_TRUE(key.empty());
57  EXPECT_TRUE(values.empty());
58}
59
60TEST_F(SplitStringIntoKeyValuesTest, EmptyValueInputSingleValue) {
61  EXPECT_FALSE(SplitStringIntoKeyValues("key_with_no_value\t",
62                                        '\t',  // Key separators
63                                        &key, &values));
64  EXPECT_EQ("key_with_no_value", key);
65  EXPECT_TRUE(values.empty());
66}
67
68TEST_F(SplitStringIntoKeyValuesTest, EmptyKeyInputSingleValue) {
69  EXPECT_TRUE(SplitStringIntoKeyValues("\tvalue for empty key",
70                                       '\t',  // Key separators
71                                       &key, &values));
72  EXPECT_TRUE(key.empty());
73  ASSERT_EQ(1U, values.size());
74  EXPECT_EQ("value for empty key", values[0]);
75}
76
77TEST_F(SplitStringIntoKeyValuesTest, KeyWithSingleValue) {
78  EXPECT_TRUE(SplitStringIntoKeyValues("key1\tvalue1,   value2   value3",
79                                       '\t',  // Key separators
80                                       &key, &values));
81  EXPECT_EQ("key1", key);
82  ASSERT_EQ(1U, values.size());
83  EXPECT_EQ("value1,   value2   value3", values[0]);
84}
85
86class SplitStringIntoKeyValuePairsTest : public testing::Test {
87 protected:
88  std::vector<std::pair<std::string, std::string> > kv_pairs;
89};
90
91TEST_F(SplitStringIntoKeyValuePairsTest, EmptyString) {
92  EXPECT_TRUE(SplitStringIntoKeyValuePairs("",
93                                           ':',   // Key-value delimiters
94                                           ',',   // Key-value pair delims
95                                           &kv_pairs));
96  EXPECT_TRUE(kv_pairs.empty());
97}
98
99TEST_F(SplitStringIntoKeyValuePairsTest, EmptySecondPair) {
100  EXPECT_TRUE(SplitStringIntoKeyValuePairs("key1:value1,,key3:value3",
101                                           ':',   // Key-value delimiters
102                                           ',',   // Key-value pair delims
103                                           &kv_pairs));
104  ASSERT_EQ(2U, kv_pairs.size());
105  EXPECT_EQ("key1", kv_pairs[0].first);
106  EXPECT_EQ("value1", kv_pairs[0].second);
107  EXPECT_EQ("key3", kv_pairs[1].first);
108  EXPECT_EQ("value3", kv_pairs[1].second);
109}
110
111TEST_F(SplitStringIntoKeyValuePairsTest, EmptySecondValue) {
112  EXPECT_FALSE(SplitStringIntoKeyValuePairs("key1:value1 , key2:",
113                                            ':',   // Key-value delimiters
114                                            ',',   // Key-value pair delims
115                                            &kv_pairs));
116  ASSERT_EQ(2U, kv_pairs.size());
117  EXPECT_EQ("key1", kv_pairs[0].first);
118  EXPECT_EQ("value1", kv_pairs[0].second);
119  EXPECT_EQ("key2", kv_pairs[1].first);
120  EXPECT_EQ("", kv_pairs[1].second);
121}
122
123TEST_F(SplitStringIntoKeyValuePairsTest, DelimiterInValue) {
124  EXPECT_TRUE(SplitStringIntoKeyValuePairs("key1:va:ue1 , key2:value2",
125                                           ':',   // Key-value delimiters
126                                           ',',   // Key-value pair delims
127                                           &kv_pairs));
128  ASSERT_EQ(2U, kv_pairs.size());
129  EXPECT_EQ("key1", kv_pairs[0].first);
130  EXPECT_EQ("va:ue1", kv_pairs[0].second);
131  EXPECT_EQ("key2", kv_pairs[1].first);
132  EXPECT_EQ("value2", kv_pairs[1].second);
133}
134
135TEST(SplitStringUsingSubstrTest, EmptyString) {
136  std::vector<std::string> results;
137  SplitStringUsingSubstr("", "DELIMITER", &results);
138  ASSERT_EQ(1u, results.size());
139  EXPECT_THAT(results, ElementsAre(""));
140}
141
142// Test for SplitString
143TEST(StringUtilTest, SplitString) {
144  std::vector<std::wstring> r;
145
146  SplitString(L"", L',', &r);
147  ASSERT_EQ(1U, r.size());
148  EXPECT_EQ(r[0], L"");
149  r.clear();
150
151  SplitString(L"a,b,c", L',', &r);
152  ASSERT_EQ(3U, r.size());
153  EXPECT_EQ(r[0], L"a");
154  EXPECT_EQ(r[1], L"b");
155  EXPECT_EQ(r[2], L"c");
156  r.clear();
157
158  SplitString(L"a, b, c", L',', &r);
159  ASSERT_EQ(3U, r.size());
160  EXPECT_EQ(r[0], L"a");
161  EXPECT_EQ(r[1], L"b");
162  EXPECT_EQ(r[2], L"c");
163  r.clear();
164
165  SplitString(L"a,,c", L',', &r);
166  ASSERT_EQ(3U, r.size());
167  EXPECT_EQ(r[0], L"a");
168  EXPECT_EQ(r[1], L"");
169  EXPECT_EQ(r[2], L"c");
170  r.clear();
171
172  SplitString(L"", L'*', &r);
173  ASSERT_EQ(1U, r.size());
174  EXPECT_EQ(r[0], L"");
175  r.clear();
176
177  SplitString(L"foo", L'*', &r);
178  ASSERT_EQ(1U, r.size());
179  EXPECT_EQ(r[0], L"foo");
180  r.clear();
181
182  SplitString(L"foo ,", L',', &r);
183  ASSERT_EQ(2U, r.size());
184  EXPECT_EQ(r[0], L"foo");
185  EXPECT_EQ(r[1], L"");
186  r.clear();
187
188  SplitString(L",", L',', &r);
189  ASSERT_EQ(2U, r.size());
190  EXPECT_EQ(r[0], L"");
191  EXPECT_EQ(r[1], L"");
192  r.clear();
193
194  SplitString(L"\t\ta\t", L'\t', &r);
195  ASSERT_EQ(4U, r.size());
196  EXPECT_EQ(r[0], L"");
197  EXPECT_EQ(r[1], L"");
198  EXPECT_EQ(r[2], L"a");
199  EXPECT_EQ(r[3], L"");
200  r.clear();
201
202  SplitString(L"\ta\t\nb\tcc", L'\n', &r);
203  ASSERT_EQ(2U, r.size());
204  EXPECT_EQ(r[0], L"a");
205  EXPECT_EQ(r[1], L"b\tcc");
206  r.clear();
207}
208
209TEST(SplitStringUsingSubstrTest, StringWithNoDelimiter) {
210  std::vector<std::string> results;
211  SplitStringUsingSubstr("alongwordwithnodelimiter", "DELIMITER", &results);
212  ASSERT_EQ(1u, results.size());
213  EXPECT_THAT(results, ElementsAre("alongwordwithnodelimiter"));
214}
215
216TEST(SplitStringUsingSubstrTest, LeadingDelimitersSkipped) {
217  std::vector<std::string> results;
218  SplitStringUsingSubstr(
219      "DELIMITERDELIMITERDELIMITERoneDELIMITERtwoDELIMITERthree",
220      "DELIMITER",
221      &results);
222  ASSERT_EQ(6u, results.size());
223  EXPECT_THAT(results, ElementsAre("", "", "", "one", "two", "three"));
224}
225
226TEST(SplitStringUsingSubstrTest, ConsecutiveDelimitersSkipped) {
227  std::vector<std::string> results;
228  SplitStringUsingSubstr(
229      "unoDELIMITERDELIMITERDELIMITERdosDELIMITERtresDELIMITERDELIMITERcuatro",
230      "DELIMITER",
231      &results);
232  ASSERT_EQ(7u, results.size());
233  EXPECT_THAT(results, ElementsAre("uno", "", "", "dos", "tres", "", "cuatro"));
234}
235
236TEST(SplitStringUsingSubstrTest, TrailingDelimitersSkipped) {
237  std::vector<std::string> results;
238  SplitStringUsingSubstr(
239      "unDELIMITERdeuxDELIMITERtroisDELIMITERquatreDELIMITERDELIMITERDELIMITER",
240      "DELIMITER",
241      &results);
242  ASSERT_EQ(7u, results.size());
243  EXPECT_THAT(
244      results, ElementsAre("un", "deux", "trois", "quatre", "", "", ""));
245}
246
247TEST(StringSplitTest, StringSplitDontTrim) {
248  std::vector<std::string> r;
249
250  SplitStringDontTrim("\t\ta\t", '\t', &r);
251  ASSERT_EQ(4U, r.size());
252  EXPECT_EQ(r[0], "");
253  EXPECT_EQ(r[1], "");
254  EXPECT_EQ(r[2], "a");
255  EXPECT_EQ(r[3], "");
256  r.clear();
257
258  SplitStringDontTrim("\ta\t\nb\tcc", '\n', &r);
259  ASSERT_EQ(2U, r.size());
260  EXPECT_EQ(r[0], "\ta\t");
261  EXPECT_EQ(r[1], "b\tcc");
262  r.clear();
263}
264
265TEST(StringSplitTest, SplitStringAlongWhitespace) {
266  struct TestData {
267    const std::wstring input;
268    const size_t expected_result_count;
269    const std::wstring output1;
270    const std::wstring output2;
271  } data[] = {
272    { L"a",       1, L"a",  L""   },
273    { L" ",       0, L"",   L""   },
274    { L" a",      1, L"a",  L""   },
275    { L" ab ",    1, L"ab", L""   },
276    { L" ab c",   2, L"ab", L"c"  },
277    { L" ab c ",  2, L"ab", L"c"  },
278    { L" ab cd",  2, L"ab", L"cd" },
279    { L" ab cd ", 2, L"ab", L"cd" },
280    { L" \ta\t",  1, L"a",  L""   },
281    { L" b\ta\t", 2, L"b",  L"a"  },
282    { L" b\tat",  2, L"b",  L"at" },
283    { L"b\tat",   2, L"b",  L"at" },
284    { L"b\t at",  2, L"b",  L"at" },
285  };
286  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(data); ++i) {
287    std::vector<std::wstring> results;
288    SplitStringAlongWhitespace(data[i].input, &results);
289    ASSERT_EQ(data[i].expected_result_count, results.size());
290    if (data[i].expected_result_count > 0)
291      ASSERT_EQ(data[i].output1, results[0]);
292    if (data[i].expected_result_count > 1)
293      ASSERT_EQ(data[i].output2, results[1]);
294  }
295}
296
297}  // namespace base
298