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