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/utf_string_conversions.h" | 7 #include "base/utf_string_conversions.h" |
8 #include "testing/gmock/include/gmock/gmock.h" | 8 #include "testing/gmock/include/gmock/gmock.h" |
9 #include "testing/gtest/include/gtest/gtest.h" | 9 #include "testing/gtest/include/gtest/gtest.h" |
10 | 10 |
(...skipping 18 matching lines...) Expand all Loading... |
29 | 29 |
30 } // anonymous namespace | 30 } // anonymous namespace |
31 | 31 |
32 class SplitStringIntoKeyValuesTest : public testing::Test { | 32 class SplitStringIntoKeyValuesTest : public testing::Test { |
33 protected: | 33 protected: |
34 std::string key; | 34 std::string key; |
35 std::vector<std::string> values; | 35 std::vector<std::string> values; |
36 }; | 36 }; |
37 | 37 |
38 TEST_F(SplitStringIntoKeyValuesTest, EmptyInputMultipleValues) { | 38 TEST_F(SplitStringIntoKeyValuesTest, EmptyInputMultipleValues) { |
39 EXPECT_FALSE(SplitStringIntoKeyValues("", // Empty input | 39 EXPECT_FALSE(SplitStringIntoKeyValues(std::string(), // Empty input |
40 '\t', // Key separators | 40 '\t', // Key separators |
41 &key, &values)); | 41 &key, |
| 42 &values)); |
42 EXPECT_TRUE(key.empty()); | 43 EXPECT_TRUE(key.empty()); |
43 EXPECT_TRUE(values.empty()); | 44 EXPECT_TRUE(values.empty()); |
44 } | 45 } |
45 | 46 |
46 TEST_F(SplitStringIntoKeyValuesTest, EmptyValueInputMultipleValues) { | 47 TEST_F(SplitStringIntoKeyValuesTest, EmptyValueInputMultipleValues) { |
47 EXPECT_FALSE(SplitStringIntoKeyValues("key_with_no_value\t", | 48 EXPECT_FALSE(SplitStringIntoKeyValues("key_with_no_value\t", |
48 '\t', // Key separators | 49 '\t', // Key separators |
49 &key, &values)); | 50 &key, &values)); |
50 EXPECT_EQ("key_with_no_value", key); | 51 EXPECT_EQ("key_with_no_value", key); |
51 EXPECT_TRUE(values.empty()); | 52 EXPECT_TRUE(values.empty()); |
(...skipping 10 matching lines...) Expand all Loading... |
62 TEST_F(SplitStringIntoKeyValuesTest, KeyWithMultipleValues) { | 63 TEST_F(SplitStringIntoKeyValuesTest, KeyWithMultipleValues) { |
63 EXPECT_TRUE(SplitStringIntoKeyValues("key1\tvalue1, value2 value3", | 64 EXPECT_TRUE(SplitStringIntoKeyValues("key1\tvalue1, value2 value3", |
64 '\t', // Key separators | 65 '\t', // Key separators |
65 &key, &values)); | 66 &key, &values)); |
66 EXPECT_EQ("key1", key); | 67 EXPECT_EQ("key1", key); |
67 ASSERT_EQ(1U, values.size()); | 68 ASSERT_EQ(1U, values.size()); |
68 EXPECT_EQ("value1, value2 value3", values[0]); | 69 EXPECT_EQ("value1, value2 value3", values[0]); |
69 } | 70 } |
70 | 71 |
71 TEST_F(SplitStringIntoKeyValuesTest, EmptyInputSingleValue) { | 72 TEST_F(SplitStringIntoKeyValuesTest, EmptyInputSingleValue) { |
72 EXPECT_FALSE(SplitStringIntoKeyValues("", // Empty input | 73 EXPECT_FALSE(SplitStringIntoKeyValues(std::string(), // Empty input |
73 '\t', // Key separators | 74 '\t', // Key separators |
74 &key, &values)); | 75 &key, |
| 76 &values)); |
75 EXPECT_TRUE(key.empty()); | 77 EXPECT_TRUE(key.empty()); |
76 EXPECT_TRUE(values.empty()); | 78 EXPECT_TRUE(values.empty()); |
77 } | 79 } |
78 | 80 |
79 TEST_F(SplitStringIntoKeyValuesTest, EmptyValueInputSingleValue) { | 81 TEST_F(SplitStringIntoKeyValuesTest, EmptyValueInputSingleValue) { |
80 EXPECT_FALSE(SplitStringIntoKeyValues("key_with_no_value\t", | 82 EXPECT_FALSE(SplitStringIntoKeyValues("key_with_no_value\t", |
81 '\t', // Key separators | 83 '\t', // Key separators |
82 &key, &values)); | 84 &key, &values)); |
83 EXPECT_EQ("key_with_no_value", key); | 85 EXPECT_EQ("key_with_no_value", key); |
84 EXPECT_TRUE(values.empty()); | 86 EXPECT_TRUE(values.empty()); |
(...skipping 16 matching lines...) Expand all Loading... |
101 ASSERT_EQ(1U, values.size()); | 103 ASSERT_EQ(1U, values.size()); |
102 EXPECT_EQ("value1, value2 value3", values[0]); | 104 EXPECT_EQ("value1, value2 value3", values[0]); |
103 } | 105 } |
104 | 106 |
105 class SplitStringIntoKeyValuePairsTest : public testing::Test { | 107 class SplitStringIntoKeyValuePairsTest : public testing::Test { |
106 protected: | 108 protected: |
107 std::vector<std::pair<std::string, std::string> > kv_pairs; | 109 std::vector<std::pair<std::string, std::string> > kv_pairs; |
108 }; | 110 }; |
109 | 111 |
110 TEST_F(SplitStringIntoKeyValuePairsTest, EmptyString) { | 112 TEST_F(SplitStringIntoKeyValuePairsTest, EmptyString) { |
111 EXPECT_TRUE(SplitStringIntoKeyValuePairs("", | 113 EXPECT_TRUE(SplitStringIntoKeyValuePairs(std::string(), |
112 ':', // Key-value delimiters | 114 ':', // Key-value delimiters |
113 ',', // Key-value pair delims | 115 ',', // Key-value pair delims |
114 &kv_pairs)); | 116 &kv_pairs)); |
115 EXPECT_TRUE(kv_pairs.empty()); | 117 EXPECT_TRUE(kv_pairs.empty()); |
116 } | 118 } |
117 | 119 |
118 TEST_F(SplitStringIntoKeyValuePairsTest, EmptySecondPair) { | 120 TEST_F(SplitStringIntoKeyValuePairsTest, EmptySecondPair) { |
119 EXPECT_TRUE(SplitStringIntoKeyValuePairs("key1:value1,,key3:value3", | 121 EXPECT_TRUE(SplitStringIntoKeyValuePairs("key1:value1,,key3:value3", |
120 ':', // Key-value delimiters | 122 ':', // Key-value delimiters |
121 ',', // Key-value pair delims | 123 ',', // Key-value pair delims |
122 &kv_pairs)); | 124 &kv_pairs)); |
123 ASSERT_EQ(2U, kv_pairs.size()); | 125 ASSERT_EQ(2U, kv_pairs.size()); |
(...skipping 22 matching lines...) Expand all Loading... |
146 &kv_pairs)); | 148 &kv_pairs)); |
147 ASSERT_EQ(2U, kv_pairs.size()); | 149 ASSERT_EQ(2U, kv_pairs.size()); |
148 EXPECT_EQ("key1", kv_pairs[0].first); | 150 EXPECT_EQ("key1", kv_pairs[0].first); |
149 EXPECT_EQ("va:ue1", kv_pairs[0].second); | 151 EXPECT_EQ("va:ue1", kv_pairs[0].second); |
150 EXPECT_EQ("key2", kv_pairs[1].first); | 152 EXPECT_EQ("key2", kv_pairs[1].first); |
151 EXPECT_EQ("value2", kv_pairs[1].second); | 153 EXPECT_EQ("value2", kv_pairs[1].second); |
152 } | 154 } |
153 | 155 |
154 TEST(SplitStringUsingSubstrTest, EmptyString) { | 156 TEST(SplitStringUsingSubstrTest, EmptyString) { |
155 std::vector<std::string> results; | 157 std::vector<std::string> results; |
156 SplitStringUsingSubstr("", "DELIMITER", &results); | 158 SplitStringUsingSubstr(std::string(), "DELIMITER", &results); |
157 ASSERT_EQ(1u, results.size()); | 159 ASSERT_EQ(1u, results.size()); |
158 EXPECT_THAT(results, ElementsAre("")); | 160 EXPECT_THAT(results, ElementsAre("")); |
159 } | 161 } |
160 | 162 |
161 // Test for SplitString | 163 // Test for SplitString |
162 TEST(StringUtilTest, SplitString) { | 164 TEST(StringUtilTest, SplitString) { |
163 std::vector<std::wstring> r; | 165 std::vector<std::wstring> r; |
164 | 166 |
165 SplitString(L"", L',', &r); | 167 SplitString(std::wstring(), L',', &r); |
166 EXPECT_EQ(0U, r.size()); | 168 EXPECT_EQ(0U, r.size()); |
167 r.clear(); | 169 r.clear(); |
168 | 170 |
169 SplitString(L"a,b,c", L',', &r); | 171 SplitString(L"a,b,c", L',', &r); |
170 ASSERT_EQ(3U, r.size()); | 172 ASSERT_EQ(3U, r.size()); |
171 EXPECT_EQ(r[0], L"a"); | 173 EXPECT_EQ(r[0], L"a"); |
172 EXPECT_EQ(r[1], L"b"); | 174 EXPECT_EQ(r[1], L"b"); |
173 EXPECT_EQ(r[2], L"c"); | 175 EXPECT_EQ(r[2], L"c"); |
174 r.clear(); | 176 r.clear(); |
175 | 177 |
(...skipping 131 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
307 SplitStringAlongWhitespace(data[i].input, &results); | 309 SplitStringAlongWhitespace(data[i].input, &results); |
308 ASSERT_EQ(data[i].expected_result_count, results.size()); | 310 ASSERT_EQ(data[i].expected_result_count, results.size()); |
309 if (data[i].expected_result_count > 0) | 311 if (data[i].expected_result_count > 0) |
310 ASSERT_EQ(data[i].output1, results[0]); | 312 ASSERT_EQ(data[i].output1, results[0]); |
311 if (data[i].expected_result_count > 1) | 313 if (data[i].expected_result_count > 1) |
312 ASSERT_EQ(data[i].output2, results[1]); | 314 ASSERT_EQ(data[i].output2, results[1]); |
313 } | 315 } |
314 } | 316 } |
315 | 317 |
316 } // namespace base | 318 } // namespace base |
OLD | NEW |