1 // Copyright 2012 The Chromium Authors
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/strings/string_split.h"
6
7 #include <stddef.h>
8
9 #include "base/strings/string_util.h"
10 #include "base/strings/utf_string_conversions.h"
11 #include "testing/gmock/include/gmock/gmock.h"
12 #include "testing/gtest/include/gtest/gtest.h"
13
14 using ::testing::ElementsAre;
15
16 namespace base {
17
18 class SplitStringIntoKeyValuePairsTest : public testing::Test {
19 protected:
20 base::StringPairs kv_pairs;
21 };
22
23 using SplitStringIntoKeyValuePairsUsingSubstrTest =
24 SplitStringIntoKeyValuePairsTest;
25
TEST_F(SplitStringIntoKeyValuePairsUsingSubstrTest,EmptyString)26 TEST_F(SplitStringIntoKeyValuePairsUsingSubstrTest, EmptyString) {
27 EXPECT_TRUE(
28 SplitStringIntoKeyValuePairsUsingSubstr(std::string(),
29 ':', // Key-value delimiter
30 ",", // Key-value pair delimiter
31 &kv_pairs));
32 EXPECT_TRUE(kv_pairs.empty());
33 }
34
TEST_F(SplitStringIntoKeyValuePairsUsingSubstrTest,MissingKeyValueDelimiter)35 TEST_F(SplitStringIntoKeyValuePairsUsingSubstrTest, MissingKeyValueDelimiter) {
36 EXPECT_FALSE(
37 SplitStringIntoKeyValuePairsUsingSubstr("key1,,key2:value2",
38 ':', // Key-value delimiter
39 ",,", // Key-value pair delimiter
40 &kv_pairs));
41 ASSERT_EQ(2U, kv_pairs.size());
42 EXPECT_TRUE(kv_pairs[0].first.empty());
43 EXPECT_TRUE(kv_pairs[0].second.empty());
44 EXPECT_EQ("key2", kv_pairs[1].first);
45 EXPECT_EQ("value2", kv_pairs[1].second);
46 }
47
TEST_F(SplitStringIntoKeyValuePairsUsingSubstrTest,MissingKeyValuePairDelimiter)48 TEST_F(SplitStringIntoKeyValuePairsUsingSubstrTest,
49 MissingKeyValuePairDelimiter) {
50 EXPECT_TRUE(SplitStringIntoKeyValuePairsUsingSubstr(
51 "key1:value1,,key3:value3",
52 ':', // Key-value delimiter
53 ",,,", // Key-value pair delimiter
54 &kv_pairs));
55 ASSERT_EQ(1U, kv_pairs.size());
56 EXPECT_EQ("key1", kv_pairs[0].first);
57 EXPECT_EQ("value1,,key3:value3", kv_pairs[0].second);
58 }
59
TEST_F(SplitStringIntoKeyValuePairsUsingSubstrTest,UntrimmedWhitespace)60 TEST_F(SplitStringIntoKeyValuePairsUsingSubstrTest, UntrimmedWhitespace) {
61 EXPECT_TRUE(
62 SplitStringIntoKeyValuePairsUsingSubstr("key1 : value1",
63 ':', // Key-value delimiter
64 ",", // Key-value pair delimiter
65 &kv_pairs));
66 ASSERT_EQ(1U, kv_pairs.size());
67 EXPECT_EQ("key1 ", kv_pairs[0].first);
68 EXPECT_EQ(" value1", kv_pairs[0].second);
69 }
70
TEST_F(SplitStringIntoKeyValuePairsUsingSubstrTest,OnlySplitAtGivenSeparator)71 TEST_F(SplitStringIntoKeyValuePairsUsingSubstrTest, OnlySplitAtGivenSeparator) {
72 std::string a("a ?!@#$%^&*()_+:/{}\\\t\nb");
73 EXPECT_TRUE(
74 SplitStringIntoKeyValuePairsUsingSubstr(a + "X" + a + "XY" + a + "YX" + a,
75 'X', // Key-value delimiter
76 "XY", // Key-value pair delimiter
77 &kv_pairs));
78 ASSERT_EQ(2U, kv_pairs.size());
79 EXPECT_EQ(a, kv_pairs[0].first);
80 EXPECT_EQ(a, kv_pairs[0].second);
81 EXPECT_EQ(a + 'Y', kv_pairs[1].first);
82 EXPECT_EQ(a, kv_pairs[1].second);
83 }
84
TEST_F(SplitStringIntoKeyValuePairsTest,EmptyString)85 TEST_F(SplitStringIntoKeyValuePairsTest, EmptyString) {
86 EXPECT_TRUE(SplitStringIntoKeyValuePairs(std::string(),
87 ':', // Key-value delimiter
88 ',', // Key-value pair delimiter
89 &kv_pairs));
90 EXPECT_TRUE(kv_pairs.empty());
91 }
92
TEST_F(SplitStringIntoKeyValuePairsTest,MissingKeyValueDelimiter)93 TEST_F(SplitStringIntoKeyValuePairsTest, MissingKeyValueDelimiter) {
94 EXPECT_FALSE(SplitStringIntoKeyValuePairs("key1,key2:value2",
95 ':', // Key-value delimiter
96 ',', // Key-value pair delimiter
97 &kv_pairs));
98 ASSERT_EQ(2U, kv_pairs.size());
99 EXPECT_TRUE(kv_pairs[0].first.empty());
100 EXPECT_TRUE(kv_pairs[0].second.empty());
101 EXPECT_EQ("key2", kv_pairs[1].first);
102 EXPECT_EQ("value2", kv_pairs[1].second);
103 }
104
TEST_F(SplitStringIntoKeyValuePairsTest,EmptyKeyWithKeyValueDelimiter)105 TEST_F(SplitStringIntoKeyValuePairsTest, EmptyKeyWithKeyValueDelimiter) {
106 EXPECT_TRUE(SplitStringIntoKeyValuePairs(":value1,key2:value2",
107 ':', // Key-value delimiter
108 ',', // Key-value pair delimiter
109 &kv_pairs));
110 ASSERT_EQ(2U, kv_pairs.size());
111 EXPECT_TRUE(kv_pairs[0].first.empty());
112 EXPECT_EQ("value1", kv_pairs[0].second);
113 EXPECT_EQ("key2", kv_pairs[1].first);
114 EXPECT_EQ("value2", kv_pairs[1].second);
115 }
116
TEST_F(SplitStringIntoKeyValuePairsTest,TrailingAndLeadingPairDelimiter)117 TEST_F(SplitStringIntoKeyValuePairsTest, TrailingAndLeadingPairDelimiter) {
118 EXPECT_TRUE(SplitStringIntoKeyValuePairs(",key1:value1,key2:value2,",
119 ':', // Key-value delimiter
120 ',', // Key-value pair delimiter
121 &kv_pairs));
122 ASSERT_EQ(2U, kv_pairs.size());
123 EXPECT_EQ("key1", kv_pairs[0].first);
124 EXPECT_EQ("value1", kv_pairs[0].second);
125 EXPECT_EQ("key2", kv_pairs[1].first);
126 EXPECT_EQ("value2", kv_pairs[1].second);
127 }
128
TEST_F(SplitStringIntoKeyValuePairsTest,EmptyPair)129 TEST_F(SplitStringIntoKeyValuePairsTest, EmptyPair) {
130 EXPECT_TRUE(SplitStringIntoKeyValuePairs("key1:value1,,key3:value3",
131 ':', // Key-value delimiter
132 ',', // Key-value pair delimiter
133 &kv_pairs));
134 ASSERT_EQ(2U, kv_pairs.size());
135 EXPECT_EQ("key1", kv_pairs[0].first);
136 EXPECT_EQ("value1", kv_pairs[0].second);
137 EXPECT_EQ("key3", kv_pairs[1].first);
138 EXPECT_EQ("value3", kv_pairs[1].second);
139 }
140
TEST_F(SplitStringIntoKeyValuePairsTest,EmptyValue)141 TEST_F(SplitStringIntoKeyValuePairsTest, EmptyValue) {
142 EXPECT_FALSE(SplitStringIntoKeyValuePairs("key1:,key2:value2",
143 ':', // Key-value delimiter
144 ',', // Key-value pair delimiter
145 &kv_pairs));
146 ASSERT_EQ(2U, kv_pairs.size());
147 EXPECT_EQ("key1", kv_pairs[0].first);
148 EXPECT_EQ("", kv_pairs[0].second);
149 EXPECT_EQ("key2", kv_pairs[1].first);
150 EXPECT_EQ("value2", kv_pairs[1].second);
151 }
152
TEST_F(SplitStringIntoKeyValuePairsTest,UntrimmedWhitespace)153 TEST_F(SplitStringIntoKeyValuePairsTest, UntrimmedWhitespace) {
154 EXPECT_TRUE(SplitStringIntoKeyValuePairs("key1 : value1",
155 ':', // Key-value delimiter
156 ',', // Key-value pair delimiter
157 &kv_pairs));
158 ASSERT_EQ(1U, kv_pairs.size());
159 EXPECT_EQ("key1 ", kv_pairs[0].first);
160 EXPECT_EQ(" value1", kv_pairs[0].second);
161 }
162
TEST_F(SplitStringIntoKeyValuePairsTest,TrimmedWhitespace)163 TEST_F(SplitStringIntoKeyValuePairsTest, TrimmedWhitespace) {
164 EXPECT_TRUE(SplitStringIntoKeyValuePairs("key1:value1 , key2:value2",
165 ':', // Key-value delimiter
166 ',', // Key-value pair delimiter
167 &kv_pairs));
168 ASSERT_EQ(2U, kv_pairs.size());
169 EXPECT_EQ("key1", kv_pairs[0].first);
170 EXPECT_EQ("value1", kv_pairs[0].second);
171 EXPECT_EQ("key2", kv_pairs[1].first);
172 EXPECT_EQ("value2", kv_pairs[1].second);
173 }
174
TEST_F(SplitStringIntoKeyValuePairsTest,MultipleKeyValueDelimiters)175 TEST_F(SplitStringIntoKeyValuePairsTest, MultipleKeyValueDelimiters) {
176 EXPECT_TRUE(SplitStringIntoKeyValuePairs("key1:::value1,key2:value2",
177 ':', // Key-value delimiter
178 ',', // Key-value pair delimiter
179 &kv_pairs));
180 ASSERT_EQ(2U, kv_pairs.size());
181 EXPECT_EQ("key1", kv_pairs[0].first);
182 EXPECT_EQ("value1", kv_pairs[0].second);
183 EXPECT_EQ("key2", kv_pairs[1].first);
184 EXPECT_EQ("value2", kv_pairs[1].second);
185 }
186
TEST_F(SplitStringIntoKeyValuePairsTest,OnlySplitAtGivenSeparator)187 TEST_F(SplitStringIntoKeyValuePairsTest, OnlySplitAtGivenSeparator) {
188 std::string a("a ?!@#$%^&*()_+:/{}\\\t\nb");
189 EXPECT_TRUE(SplitStringIntoKeyValuePairs(a + "X" + a + "Y" + a + "X" + a,
190 'X', // Key-value delimiter
191 'Y', // Key-value pair delimiter
192 &kv_pairs));
193 ASSERT_EQ(2U, kv_pairs.size());
194 EXPECT_EQ(a, kv_pairs[0].first);
195 EXPECT_EQ(a, kv_pairs[0].second);
196 EXPECT_EQ(a, kv_pairs[1].first);
197 EXPECT_EQ(a, kv_pairs[1].second);
198 }
199
200
TEST_F(SplitStringIntoKeyValuePairsTest,DelimiterInValue)201 TEST_F(SplitStringIntoKeyValuePairsTest, DelimiterInValue) {
202 EXPECT_TRUE(SplitStringIntoKeyValuePairs("key1:va:ue1,key2:value2",
203 ':', // Key-value delimiter
204 ',', // Key-value pair delimiter
205 &kv_pairs));
206 ASSERT_EQ(2U, kv_pairs.size());
207 EXPECT_EQ("key1", kv_pairs[0].first);
208 EXPECT_EQ("va:ue1", kv_pairs[0].second);
209 EXPECT_EQ("key2", kv_pairs[1].first);
210 EXPECT_EQ("value2", kv_pairs[1].second);
211 }
212
TEST(SplitStringUsingSubstrTest,EmptyString)213 TEST(SplitStringUsingSubstrTest, EmptyString) {
214 std::vector<std::string> results = SplitStringUsingSubstr(
215 std::string(), "DELIMITER", TRIM_WHITESPACE, SPLIT_WANT_ALL);
216 ASSERT_EQ(1u, results.size());
217 EXPECT_THAT(results, ElementsAre(""));
218 }
219
TEST(SplitStringUsingSubstrTest,EmptyDelimiter)220 TEST(SplitStringUsingSubstrTest, EmptyDelimiter) {
221 std::vector<std::string> results = SplitStringUsingSubstr(
222 "TEST", std::string(), TRIM_WHITESPACE, SPLIT_WANT_ALL);
223 ASSERT_EQ(1u, results.size());
224 EXPECT_THAT(results, ElementsAre("TEST"));
225 }
226
TEST(StringUtilTest,SplitString_Basics)227 TEST(StringUtilTest, SplitString_Basics) {
228 std::vector<std::string> r;
229
230 r = SplitString(std::string(), ",:;", KEEP_WHITESPACE, SPLIT_WANT_ALL);
231 EXPECT_TRUE(r.empty());
232
233 // Empty separator list
234 r = SplitString("hello, world", "", KEEP_WHITESPACE, SPLIT_WANT_ALL);
235 ASSERT_EQ(1u, r.size());
236 EXPECT_EQ("hello, world", r[0]);
237
238 // Should split on any of the separators.
239 r = SplitString("::,,;;", ",:;", KEEP_WHITESPACE, SPLIT_WANT_ALL);
240 ASSERT_EQ(7u, r.size());
241 for (auto str : r)
242 ASSERT_TRUE(str.empty());
243
244 r = SplitString("red, green; blue:", ",:;", TRIM_WHITESPACE,
245 SPLIT_WANT_NONEMPTY);
246 ASSERT_EQ(3u, r.size());
247 EXPECT_EQ("red", r[0]);
248 EXPECT_EQ("green", r[1]);
249 EXPECT_EQ("blue", r[2]);
250
251 // Want to split a string along whitespace sequences.
252 r = SplitString(" red green \tblue\n", " \t\n", TRIM_WHITESPACE,
253 SPLIT_WANT_NONEMPTY);
254 ASSERT_EQ(3u, r.size());
255 EXPECT_EQ("red", r[0]);
256 EXPECT_EQ("green", r[1]);
257 EXPECT_EQ("blue", r[2]);
258
259 // Weird case of splitting on spaces but not trimming.
260 r = SplitString(" red ", " ", TRIM_WHITESPACE, SPLIT_WANT_ALL);
261 ASSERT_EQ(3u, r.size());
262 EXPECT_EQ("", r[0]); // Before the first space.
263 EXPECT_EQ("red", r[1]);
264 EXPECT_EQ("", r[2]); // After the last space.
265 }
266
TEST(StringUtilTest,SplitString_WhitespaceAndResultType)267 TEST(StringUtilTest, SplitString_WhitespaceAndResultType) {
268 std::vector<std::string> r;
269
270 // Empty input handling.
271 r = SplitString(std::string(), ",", KEEP_WHITESPACE, SPLIT_WANT_ALL);
272 EXPECT_TRUE(r.empty());
273 r = SplitString(std::string(), ",", KEEP_WHITESPACE, SPLIT_WANT_NONEMPTY);
274 EXPECT_TRUE(r.empty());
275
276 // Input string is space and we're trimming.
277 r = SplitString(" ", ",", TRIM_WHITESPACE, SPLIT_WANT_ALL);
278 ASSERT_EQ(1u, r.size());
279 EXPECT_EQ("", r[0]);
280 r = SplitString(" ", ",", TRIM_WHITESPACE, SPLIT_WANT_NONEMPTY);
281 EXPECT_TRUE(r.empty());
282
283 // Test all 4 combinations of flags on ", ,".
284 r = SplitString(", ,", ",", KEEP_WHITESPACE, SPLIT_WANT_ALL);
285 ASSERT_EQ(3u, r.size());
286 EXPECT_EQ("", r[0]);
287 EXPECT_EQ(" ", r[1]);
288 EXPECT_EQ("", r[2]);
289 r = SplitString(", ,", ",", KEEP_WHITESPACE, SPLIT_WANT_NONEMPTY);
290 ASSERT_EQ(1u, r.size());
291 ASSERT_EQ(" ", r[0]);
292 r = SplitString(", ,", ",", TRIM_WHITESPACE, SPLIT_WANT_ALL);
293 ASSERT_EQ(3u, r.size());
294 EXPECT_EQ("", r[0]);
295 EXPECT_EQ("", r[1]);
296 EXPECT_EQ("", r[2]);
297 r = SplitString(", ,", ",", TRIM_WHITESPACE, SPLIT_WANT_NONEMPTY);
298 ASSERT_TRUE(r.empty());
299 }
300
TEST(SplitStringUsingSubstrTest,StringWithNoDelimiter)301 TEST(SplitStringUsingSubstrTest, StringWithNoDelimiter) {
302 std::vector<std::string> results = SplitStringUsingSubstr(
303 "alongwordwithnodelimiter", "DELIMITER", TRIM_WHITESPACE,
304 SPLIT_WANT_ALL);
305 ASSERT_EQ(1u, results.size());
306 EXPECT_THAT(results, ElementsAre("alongwordwithnodelimiter"));
307 }
308
TEST(SplitStringUsingSubstrTest,LeadingDelimitersSkipped)309 TEST(SplitStringUsingSubstrTest, LeadingDelimitersSkipped) {
310 std::vector<std::string> results = SplitStringUsingSubstr(
311 "DELIMITERDELIMITERDELIMITERoneDELIMITERtwoDELIMITERthree",
312 "DELIMITER", TRIM_WHITESPACE, SPLIT_WANT_ALL);
313 ASSERT_EQ(6u, results.size());
314 EXPECT_THAT(results, ElementsAre("", "", "", "one", "two", "three"));
315 }
316
TEST(SplitStringUsingSubstrTest,ConsecutiveDelimitersSkipped)317 TEST(SplitStringUsingSubstrTest, ConsecutiveDelimitersSkipped) {
318 std::vector<std::string> results = SplitStringUsingSubstr(
319 "unoDELIMITERDELIMITERDELIMITERdosDELIMITERtresDELIMITERDELIMITERcuatro",
320 "DELIMITER", TRIM_WHITESPACE, SPLIT_WANT_ALL);
321 ASSERT_EQ(7u, results.size());
322 EXPECT_THAT(results, ElementsAre("uno", "", "", "dos", "tres", "", "cuatro"));
323 }
324
TEST(SplitStringUsingSubstrTest,TrailingDelimitersSkipped)325 TEST(SplitStringUsingSubstrTest, TrailingDelimitersSkipped) {
326 std::vector<std::string> results = SplitStringUsingSubstr(
327 "unDELIMITERdeuxDELIMITERtroisDELIMITERquatreDELIMITERDELIMITERDELIMITER",
328 "DELIMITER", TRIM_WHITESPACE, SPLIT_WANT_ALL);
329 ASSERT_EQ(7u, results.size());
330 EXPECT_THAT(
331 results, ElementsAre("un", "deux", "trois", "quatre", "", "", ""));
332 }
333
TEST(SplitStringPieceUsingSubstrTest,StringWithNoDelimiter)334 TEST(SplitStringPieceUsingSubstrTest, StringWithNoDelimiter) {
335 std::vector<base::StringPiece> results =
336 SplitStringPieceUsingSubstr("alongwordwithnodelimiter", "DELIMITER",
337 base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
338 ASSERT_EQ(1u, results.size());
339 EXPECT_THAT(results, ElementsAre("alongwordwithnodelimiter"));
340 }
341
TEST(SplitStringPieceUsingSubstrTest,LeadingDelimitersSkipped)342 TEST(SplitStringPieceUsingSubstrTest, LeadingDelimitersSkipped) {
343 std::vector<base::StringPiece> results = SplitStringPieceUsingSubstr(
344 "DELIMITERDELIMITERDELIMITERoneDELIMITERtwoDELIMITERthree", "DELIMITER",
345 base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
346 ASSERT_EQ(6u, results.size());
347 EXPECT_THAT(results, ElementsAre("", "", "", "one", "two", "three"));
348 }
349
TEST(SplitStringPieceUsingSubstrTest,ConsecutiveDelimitersSkipped)350 TEST(SplitStringPieceUsingSubstrTest, ConsecutiveDelimitersSkipped) {
351 std::vector<base::StringPiece> results = SplitStringPieceUsingSubstr(
352 "unoDELIMITERDELIMITERDELIMITERdosDELIMITERtresDELIMITERDELIMITERcuatro",
353 "DELIMITER", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
354 ASSERT_EQ(7u, results.size());
355 EXPECT_THAT(results, ElementsAre("uno", "", "", "dos", "tres", "", "cuatro"));
356 }
357
TEST(SplitStringPieceUsingSubstrTest,TrailingDelimitersSkipped)358 TEST(SplitStringPieceUsingSubstrTest, TrailingDelimitersSkipped) {
359 std::vector<base::StringPiece> results = SplitStringPieceUsingSubstr(
360 "unDELIMITERdeuxDELIMITERtroisDELIMITERquatreDELIMITERDELIMITERDELIMITER",
361 "DELIMITER", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
362 ASSERT_EQ(7u, results.size());
363 EXPECT_THAT(results,
364 ElementsAre("un", "deux", "trois", "quatre", "", "", ""));
365 }
366
TEST(SplitStringPieceUsingSubstrTest,KeepWhitespace)367 TEST(SplitStringPieceUsingSubstrTest, KeepWhitespace) {
368 std::vector<base::StringPiece> results = SplitStringPieceUsingSubstr(
369 "un DELIMITERdeux\tDELIMITERtrois\nDELIMITERquatre", "DELIMITER",
370 base::KEEP_WHITESPACE, base::SPLIT_WANT_ALL);
371 ASSERT_EQ(4u, results.size());
372 EXPECT_THAT(results, ElementsAre("un ", "deux\t", "trois\n", "quatre"));
373 }
374
TEST(SplitStringPieceUsingSubstrTest,TrimWhitespace)375 TEST(SplitStringPieceUsingSubstrTest, TrimWhitespace) {
376 std::vector<base::StringPiece> results = SplitStringPieceUsingSubstr(
377 "un DELIMITERdeux\tDELIMITERtrois\nDELIMITERquatre", "DELIMITER",
378 base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
379 ASSERT_EQ(4u, results.size());
380 EXPECT_THAT(results, ElementsAre("un", "deux", "trois", "quatre"));
381 }
382
TEST(SplitStringPieceUsingSubstrTest,SplitWantAll)383 TEST(SplitStringPieceUsingSubstrTest, SplitWantAll) {
384 std::vector<base::StringPiece> results = SplitStringPieceUsingSubstr(
385 "unDELIMITERdeuxDELIMITERtroisDELIMITERDELIMITER", "DELIMITER",
386 base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
387 ASSERT_EQ(5u, results.size());
388 EXPECT_THAT(results, ElementsAre("un", "deux", "trois", "", ""));
389 }
390
TEST(SplitStringPieceUsingSubstrTest,SplitWantNonEmpty)391 TEST(SplitStringPieceUsingSubstrTest, SplitWantNonEmpty) {
392 std::vector<base::StringPiece> results = SplitStringPieceUsingSubstr(
393 "unDELIMITERdeuxDELIMITERtroisDELIMITERDELIMITER", "DELIMITER",
394 base::TRIM_WHITESPACE, base::SPLIT_WANT_NONEMPTY);
395 ASSERT_EQ(3u, results.size());
396 EXPECT_THAT(results, ElementsAre("un", "deux", "trois"));
397 }
398
TEST(StringSplitTest,StringSplitKeepWhitespace)399 TEST(StringSplitTest, StringSplitKeepWhitespace) {
400 std::vector<std::string> r;
401
402 r = SplitString(" ", "*", base::KEEP_WHITESPACE, base::SPLIT_WANT_ALL);
403 ASSERT_EQ(1U, r.size());
404 EXPECT_EQ(r[0], " ");
405
406 r = SplitString("\t \ta\t ", "\t", base::KEEP_WHITESPACE,
407 base::SPLIT_WANT_ALL);
408 ASSERT_EQ(4U, r.size());
409 EXPECT_EQ(r[0], "");
410 EXPECT_EQ(r[1], " ");
411 EXPECT_EQ(r[2], "a");
412 EXPECT_EQ(r[3], " ");
413
414 r = SplitString("\ta\t\nb\tcc", "\n", base::KEEP_WHITESPACE,
415 base::SPLIT_WANT_ALL);
416 ASSERT_EQ(2U, r.size());
417 EXPECT_EQ(r[0], "\ta\t");
418 EXPECT_EQ(r[1], "b\tcc");
419 }
420
TEST(StringSplitTest,SplitStringAlongWhitespace)421 TEST(StringSplitTest, SplitStringAlongWhitespace) {
422 struct TestData {
423 const char* input;
424 const size_t expected_result_count;
425 const char* output1;
426 const char* output2;
427 } data[] = {
428 { "a", 1, "a", "" },
429 { " ", 0, "", "" },
430 { " a", 1, "a", "" },
431 { " ab ", 1, "ab", "" },
432 { " ab c", 2, "ab", "c" },
433 { " ab c ", 2, "ab", "c" },
434 { " ab cd", 2, "ab", "cd" },
435 { " ab cd ", 2, "ab", "cd" },
436 { " \ta\t", 1, "a", "" },
437 { " b\ta\t", 2, "b", "a" },
438 { " b\tat", 2, "b", "at" },
439 { "b\tat", 2, "b", "at" },
440 { "b\t at", 2, "b", "at" },
441 };
442 for (const auto& i : data) {
443 std::vector<std::string> results =
444 base::SplitString(i.input, kWhitespaceASCII, base::KEEP_WHITESPACE,
445 base::SPLIT_WANT_NONEMPTY);
446 ASSERT_EQ(i.expected_result_count, results.size());
447 if (i.expected_result_count > 0)
448 ASSERT_EQ(i.output1, results[0]);
449 if (i.expected_result_count > 1)
450 ASSERT_EQ(i.output2, results[1]);
451 }
452 }
453
454 } // namespace base
455