OLD | NEW |
1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | 1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "base/strings/string_split.h" | 5 #include "base/strings/string_split.h" |
6 | 6 |
| 7 #include "base/strings/string_util.h" |
7 #include "base/strings/utf_string_conversions.h" | 8 #include "base/strings/utf_string_conversions.h" |
8 #include "testing/gmock/include/gmock/gmock.h" | 9 #include "testing/gmock/include/gmock/gmock.h" |
9 #include "testing/gtest/include/gtest/gtest.h" | 10 #include "testing/gtest/include/gtest/gtest.h" |
10 | 11 |
11 using ::testing::ElementsAre; | 12 using ::testing::ElementsAre; |
12 | 13 |
13 namespace base { | 14 namespace base { |
14 | 15 |
15 namespace { | |
16 | |
17 #if !defined(WCHAR_T_IS_UTF16) | |
18 // Overload SplitString with a wide-char version to make it easier to | |
19 // test the string16 version with wide character literals. | |
20 void SplitString(const std::wstring& str, | |
21 wchar_t c, | |
22 std::vector<std::wstring>* result) { | |
23 std::vector<string16> result16; | |
24 SplitString(WideToUTF16(str), c, &result16); | |
25 for (size_t i = 0; i < result16.size(); ++i) | |
26 result->push_back(UTF16ToWide(result16[i])); | |
27 } | |
28 #endif | |
29 | |
30 } // anonymous namespace | |
31 | |
32 class SplitStringIntoKeyValuePairsTest : public testing::Test { | 16 class SplitStringIntoKeyValuePairsTest : public testing::Test { |
33 protected: | 17 protected: |
34 base::StringPairs kv_pairs; | 18 base::StringPairs kv_pairs; |
35 }; | 19 }; |
36 | 20 |
37 TEST_F(SplitStringIntoKeyValuePairsTest, EmptyString) { | 21 TEST_F(SplitStringIntoKeyValuePairsTest, EmptyString) { |
38 EXPECT_TRUE(SplitStringIntoKeyValuePairs(std::string(), | 22 EXPECT_TRUE(SplitStringIntoKeyValuePairs(std::string(), |
39 ':', // Key-value delimiter | 23 ':', // Key-value delimiter |
40 ',', // Key-value pair delimiter | 24 ',', // Key-value pair delimiter |
41 &kv_pairs)); | 25 &kv_pairs)); |
(...skipping 194 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
236 ASSERT_EQ(" ", r[0]); | 220 ASSERT_EQ(" ", r[0]); |
237 r = SplitString(", ,", ",", TRIM_WHITESPACE, SPLIT_WANT_ALL); | 221 r = SplitString(", ,", ",", TRIM_WHITESPACE, SPLIT_WANT_ALL); |
238 ASSERT_EQ(3u, r.size()); | 222 ASSERT_EQ(3u, r.size()); |
239 EXPECT_EQ("", r[0]); | 223 EXPECT_EQ("", r[0]); |
240 EXPECT_EQ("", r[1]); | 224 EXPECT_EQ("", r[1]); |
241 EXPECT_EQ("", r[2]); | 225 EXPECT_EQ("", r[2]); |
242 r = SplitString(", ,", ",", TRIM_WHITESPACE, SPLIT_WANT_NONEMPTY); | 226 r = SplitString(", ,", ",", TRIM_WHITESPACE, SPLIT_WANT_NONEMPTY); |
243 ASSERT_TRUE(r.empty()); | 227 ASSERT_TRUE(r.empty()); |
244 } | 228 } |
245 | 229 |
246 TEST(StringUtilTest, SplitString_Legacy) { | |
247 std::vector<std::wstring> r; | |
248 | |
249 SplitString(std::wstring(), L',', &r); | |
250 EXPECT_EQ(0U, r.size()); | |
251 r.clear(); | |
252 | |
253 SplitString(L"a,b,c", L',', &r); | |
254 ASSERT_EQ(3U, r.size()); | |
255 EXPECT_EQ(r[0], L"a"); | |
256 EXPECT_EQ(r[1], L"b"); | |
257 EXPECT_EQ(r[2], L"c"); | |
258 r.clear(); | |
259 | |
260 SplitString(L"a, b, c", L',', &r); | |
261 ASSERT_EQ(3U, r.size()); | |
262 EXPECT_EQ(r[0], L"a"); | |
263 EXPECT_EQ(r[1], L"b"); | |
264 EXPECT_EQ(r[2], L"c"); | |
265 r.clear(); | |
266 | |
267 SplitString(L"a,,c", L',', &r); | |
268 ASSERT_EQ(3U, r.size()); | |
269 EXPECT_EQ(r[0], L"a"); | |
270 EXPECT_EQ(r[1], L""); | |
271 EXPECT_EQ(r[2], L"c"); | |
272 r.clear(); | |
273 | |
274 SplitString(L"a, ,c", L',', &r); | |
275 ASSERT_EQ(3U, r.size()); | |
276 EXPECT_EQ(r[0], L"a"); | |
277 EXPECT_EQ(r[1], L""); | |
278 EXPECT_EQ(r[2], L"c"); | |
279 r.clear(); | |
280 | |
281 SplitString(L" ", L'*', &r); | |
282 EXPECT_EQ(0U, r.size()); | |
283 r.clear(); | |
284 | |
285 SplitString(L"foo", L'*', &r); | |
286 ASSERT_EQ(1U, r.size()); | |
287 EXPECT_EQ(r[0], L"foo"); | |
288 r.clear(); | |
289 | |
290 SplitString(L"foo ,", L',', &r); | |
291 ASSERT_EQ(2U, r.size()); | |
292 EXPECT_EQ(r[0], L"foo"); | |
293 EXPECT_EQ(r[1], L""); | |
294 r.clear(); | |
295 | |
296 SplitString(L",", L',', &r); | |
297 ASSERT_EQ(2U, r.size()); | |
298 EXPECT_EQ(r[0], L""); | |
299 EXPECT_EQ(r[1], L""); | |
300 r.clear(); | |
301 | |
302 SplitString(L"\t\ta\t", L'\t', &r); | |
303 ASSERT_EQ(4U, r.size()); | |
304 EXPECT_EQ(r[0], L""); | |
305 EXPECT_EQ(r[1], L""); | |
306 EXPECT_EQ(r[2], L"a"); | |
307 EXPECT_EQ(r[3], L""); | |
308 r.clear(); | |
309 | |
310 SplitString(L"\ta\t\nb\tcc", L'\n', &r); | |
311 ASSERT_EQ(2U, r.size()); | |
312 EXPECT_EQ(r[0], L"a"); | |
313 EXPECT_EQ(r[1], L"b\tcc"); | |
314 r.clear(); | |
315 } | |
316 | |
317 TEST(SplitStringUsingSubstrTest, StringWithNoDelimiter) { | 230 TEST(SplitStringUsingSubstrTest, StringWithNoDelimiter) { |
318 std::vector<std::string> results; | 231 std::vector<std::string> results; |
319 SplitStringUsingSubstr("alongwordwithnodelimiter", "DELIMITER", &results); | 232 SplitStringUsingSubstr("alongwordwithnodelimiter", "DELIMITER", &results); |
320 ASSERT_EQ(1u, results.size()); | 233 ASSERT_EQ(1u, results.size()); |
321 EXPECT_THAT(results, ElementsAre("alongwordwithnodelimiter")); | 234 EXPECT_THAT(results, ElementsAre("alongwordwithnodelimiter")); |
322 } | 235 } |
323 | 236 |
324 TEST(SplitStringUsingSubstrTest, LeadingDelimitersSkipped) { | 237 TEST(SplitStringUsingSubstrTest, LeadingDelimitersSkipped) { |
325 std::vector<std::string> results; | 238 std::vector<std::string> results; |
326 SplitStringUsingSubstr( | 239 SplitStringUsingSubstr( |
(...skipping 18 matching lines...) Expand all Loading... |
345 std::vector<std::string> results; | 258 std::vector<std::string> results; |
346 SplitStringUsingSubstr( | 259 SplitStringUsingSubstr( |
347 "unDELIMITERdeuxDELIMITERtroisDELIMITERquatreDELIMITERDELIMITERDELIMITER", | 260 "unDELIMITERdeuxDELIMITERtroisDELIMITERquatreDELIMITERDELIMITERDELIMITER", |
348 "DELIMITER", | 261 "DELIMITER", |
349 &results); | 262 &results); |
350 ASSERT_EQ(7u, results.size()); | 263 ASSERT_EQ(7u, results.size()); |
351 EXPECT_THAT( | 264 EXPECT_THAT( |
352 results, ElementsAre("un", "deux", "trois", "quatre", "", "", "")); | 265 results, ElementsAre("un", "deux", "trois", "quatre", "", "", "")); |
353 } | 266 } |
354 | 267 |
355 TEST(StringSplitTest, StringSplitDontTrim) { | 268 TEST(StringSplitTest, StringSplitKeepWhitespace) { |
356 std::vector<std::string> r; | 269 std::vector<std::string> r; |
357 | 270 |
358 SplitStringDontTrim(" ", '*', &r); | 271 r = SplitString(" ", "*", base::KEEP_WHITESPACE, base::SPLIT_WANT_ALL); |
359 ASSERT_EQ(1U, r.size()); | 272 ASSERT_EQ(1U, r.size()); |
360 EXPECT_EQ(r[0], " "); | 273 EXPECT_EQ(r[0], " "); |
361 | 274 |
362 SplitStringDontTrim("\t \ta\t ", '\t', &r); | 275 r = SplitString("\t \ta\t ", "\t", base::KEEP_WHITESPACE, |
| 276 base::SPLIT_WANT_ALL); |
363 ASSERT_EQ(4U, r.size()); | 277 ASSERT_EQ(4U, r.size()); |
364 EXPECT_EQ(r[0], ""); | 278 EXPECT_EQ(r[0], ""); |
365 EXPECT_EQ(r[1], " "); | 279 EXPECT_EQ(r[1], " "); |
366 EXPECT_EQ(r[2], "a"); | 280 EXPECT_EQ(r[2], "a"); |
367 EXPECT_EQ(r[3], " "); | 281 EXPECT_EQ(r[3], " "); |
368 | 282 |
369 SplitStringDontTrim("\ta\t\nb\tcc", '\n', &r); | 283 r = SplitString("\ta\t\nb\tcc", "\n", base::KEEP_WHITESPACE, |
| 284 base::SPLIT_WANT_ALL); |
370 ASSERT_EQ(2U, r.size()); | 285 ASSERT_EQ(2U, r.size()); |
371 EXPECT_EQ(r[0], "\ta\t"); | 286 EXPECT_EQ(r[0], "\ta\t"); |
372 EXPECT_EQ(r[1], "b\tcc"); | 287 EXPECT_EQ(r[1], "b\tcc"); |
373 } | 288 } |
374 | 289 |
375 TEST(StringSplitTest, SplitStringAlongWhitespace) { | 290 TEST(StringSplitTest, SplitStringAlongWhitespace) { |
376 struct TestData { | 291 struct TestData { |
377 const char* input; | 292 const char* input; |
378 const size_t expected_result_count; | 293 const size_t expected_result_count; |
379 const char* output1; | 294 const char* output1; |
380 const char* output2; | 295 const char* output2; |
381 } data[] = { | 296 } data[] = { |
382 { "a", 1, "a", "" }, | 297 { "a", 1, "a", "" }, |
383 { " ", 0, "", "" }, | 298 { " ", 0, "", "" }, |
384 { " a", 1, "a", "" }, | 299 { " a", 1, "a", "" }, |
385 { " ab ", 1, "ab", "" }, | 300 { " ab ", 1, "ab", "" }, |
386 { " ab c", 2, "ab", "c" }, | 301 { " ab c", 2, "ab", "c" }, |
387 { " ab c ", 2, "ab", "c" }, | 302 { " ab c ", 2, "ab", "c" }, |
388 { " ab cd", 2, "ab", "cd" }, | 303 { " ab cd", 2, "ab", "cd" }, |
389 { " ab cd ", 2, "ab", "cd" }, | 304 { " ab cd ", 2, "ab", "cd" }, |
390 { " \ta\t", 1, "a", "" }, | 305 { " \ta\t", 1, "a", "" }, |
391 { " b\ta\t", 2, "b", "a" }, | 306 { " b\ta\t", 2, "b", "a" }, |
392 { " b\tat", 2, "b", "at" }, | 307 { " b\tat", 2, "b", "at" }, |
393 { "b\tat", 2, "b", "at" }, | 308 { "b\tat", 2, "b", "at" }, |
394 { "b\t at", 2, "b", "at" }, | 309 { "b\t at", 2, "b", "at" }, |
395 }; | 310 }; |
396 for (size_t i = 0; i < arraysize(data); ++i) { | 311 for (size_t i = 0; i < arraysize(data); ++i) { |
397 std::vector<std::string> results; | 312 std::vector<std::string> results = base::SplitString( |
398 SplitStringAlongWhitespace(data[i].input, &results); | 313 data[i].input, kWhitespaceASCII, base::KEEP_WHITESPACE, |
| 314 base::SPLIT_WANT_NONEMPTY); |
399 ASSERT_EQ(data[i].expected_result_count, results.size()); | 315 ASSERT_EQ(data[i].expected_result_count, results.size()); |
400 if (data[i].expected_result_count > 0) | 316 if (data[i].expected_result_count > 0) |
401 ASSERT_EQ(data[i].output1, results[0]); | 317 ASSERT_EQ(data[i].output1, results[0]); |
402 if (data[i].expected_result_count > 1) | 318 if (data[i].expected_result_count > 1) |
403 ASSERT_EQ(data[i].output2, results[1]); | 319 ASSERT_EQ(data[i].output2, results[1]); |
404 } | 320 } |
405 } | 321 } |
406 | 322 |
407 } // namespace base | 323 } // namespace base |
OLD | NEW |