1 /*
2 * Copyright (C) 2015 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 #include "android-base/strings.h"
18
19 #include <gtest/gtest.h>
20
21 #include <string>
22 #include <vector>
23 #include <set>
24 #include <unordered_set>
25
TEST(strings,split_empty)26 TEST(strings, split_empty) {
27 std::vector<std::string> parts = android::base::Split("", ",");
28 ASSERT_EQ(1U, parts.size());
29 ASSERT_EQ("", parts[0]);
30 }
31
TEST(strings,split_single)32 TEST(strings, split_single) {
33 std::vector<std::string> parts = android::base::Split("foo", ",");
34 ASSERT_EQ(1U, parts.size());
35 ASSERT_EQ("foo", parts[0]);
36 }
37
TEST(strings,split_simple)38 TEST(strings, split_simple) {
39 std::vector<std::string> parts = android::base::Split("foo,bar,baz", ",");
40 ASSERT_EQ(3U, parts.size());
41 ASSERT_EQ("foo", parts[0]);
42 ASSERT_EQ("bar", parts[1]);
43 ASSERT_EQ("baz", parts[2]);
44 }
45
TEST(strings,split_with_empty_part)46 TEST(strings, split_with_empty_part) {
47 std::vector<std::string> parts = android::base::Split("foo,,bar", ",");
48 ASSERT_EQ(3U, parts.size());
49 ASSERT_EQ("foo", parts[0]);
50 ASSERT_EQ("", parts[1]);
51 ASSERT_EQ("bar", parts[2]);
52 }
53
TEST(strings,split_with_trailing_empty_part)54 TEST(strings, split_with_trailing_empty_part) {
55 std::vector<std::string> parts = android::base::Split("foo,bar,", ",");
56 ASSERT_EQ(3U, parts.size());
57 ASSERT_EQ("foo", parts[0]);
58 ASSERT_EQ("bar", parts[1]);
59 ASSERT_EQ("", parts[2]);
60 }
61
TEST(strings,split_null_char)62 TEST(strings, split_null_char) {
63 std::vector<std::string> parts =
64 android::base::Split(std::string("foo\0bar", 7), std::string("\0", 1));
65 ASSERT_EQ(2U, parts.size());
66 ASSERT_EQ("foo", parts[0]);
67 ASSERT_EQ("bar", parts[1]);
68 }
69
TEST(strings,split_any)70 TEST(strings, split_any) {
71 std::vector<std::string> parts = android::base::Split("foo:bar,baz", ",:");
72 ASSERT_EQ(3U, parts.size());
73 ASSERT_EQ("foo", parts[0]);
74 ASSERT_EQ("bar", parts[1]);
75 ASSERT_EQ("baz", parts[2]);
76 }
77
TEST(strings,split_any_with_empty_part)78 TEST(strings, split_any_with_empty_part) {
79 std::vector<std::string> parts = android::base::Split("foo:,bar", ",:");
80 ASSERT_EQ(3U, parts.size());
81 ASSERT_EQ("foo", parts[0]);
82 ASSERT_EQ("", parts[1]);
83 ASSERT_EQ("bar", parts[2]);
84 }
85
TEST(strings,tokenize_empty)86 TEST(strings, tokenize_empty) {
87 std::vector<std::string> parts = android::base::Tokenize("", " ");
88 ASSERT_EQ(0U, parts.size());
89 }
90
TEST(strings,tokenize_all_delimiter)91 TEST(strings, tokenize_all_delimiter) {
92 std::vector<std::string> parts = android::base::Tokenize(" \t ", " \t");
93 ASSERT_EQ(0U, parts.size());
94 }
95
TEST(strings,tokenize_trivial)96 TEST(strings, tokenize_trivial) {
97 std::vector<std::string> parts = android::base::Tokenize("foo", "\t");
98 ASSERT_EQ(1U, parts.size());
99 ASSERT_EQ("foo", parts[0]);
100 }
101
TEST(strings,tokenize_single)102 TEST(strings, tokenize_single) {
103 std::vector<std::string> parts = android::base::Tokenize("foo\t", "\t");
104 ASSERT_EQ(1U, parts.size());
105 ASSERT_EQ("foo", parts[0]);
106 }
107
TEST(strings,tokenize_simple)108 TEST(strings, tokenize_simple) {
109 std::vector<std::string> parts = android::base::Tokenize("foo bar baz", " ");
110 ASSERT_EQ(3U, parts.size());
111 ASSERT_EQ("foo", parts[0]);
112 ASSERT_EQ("bar", parts[1]);
113 ASSERT_EQ("baz", parts[2]);
114 }
115
TEST(strings,tokenize_any)116 TEST(strings, tokenize_any) {
117 std::vector<std::string> parts = android::base::Tokenize("foo \tbar\t\t baz", " \t");
118 ASSERT_EQ(3U, parts.size());
119 ASSERT_EQ("foo", parts[0]);
120 ASSERT_EQ("bar", parts[1]);
121 ASSERT_EQ("baz", parts[2]);
122 }
123
TEST(strings,tokenize_beginning_trailing_delimiters)124 TEST(strings, tokenize_beginning_trailing_delimiters) {
125 std::vector<std::string> parts = android::base::Tokenize(" foo bar baz \t", " \t");
126 ASSERT_EQ(3U, parts.size());
127 ASSERT_EQ("foo", parts[0]);
128 ASSERT_EQ("bar", parts[1]);
129 ASSERT_EQ("baz", parts[2]);
130 }
131
TEST(strings,trim_empty)132 TEST(strings, trim_empty) {
133 ASSERT_EQ("", android::base::Trim(""));
134 }
135
TEST(strings,trim_already_trimmed)136 TEST(strings, trim_already_trimmed) {
137 ASSERT_EQ("foo", android::base::Trim("foo"));
138 }
139
TEST(strings,trim_left)140 TEST(strings, trim_left) {
141 ASSERT_EQ("foo", android::base::Trim(" foo"));
142 }
143
TEST(strings,trim_right)144 TEST(strings, trim_right) {
145 ASSERT_EQ("foo", android::base::Trim("foo "));
146 }
147
TEST(strings,trim_both)148 TEST(strings, trim_both) {
149 ASSERT_EQ("foo", android::base::Trim(" foo "));
150 }
151
TEST(strings,trim_no_trim_middle)152 TEST(strings, trim_no_trim_middle) {
153 ASSERT_EQ("foo bar", android::base::Trim("foo bar"));
154 }
155
TEST(strings,trim_other_whitespace)156 TEST(strings, trim_other_whitespace) {
157 ASSERT_EQ("foo", android::base::Trim("\v\tfoo\n\f"));
158 }
159
TEST(strings,trim_build_implicit_string_conversion)160 TEST(strings, trim_build_implicit_string_conversion) {
161 struct Foo {
162 operator std::string() { return " foo "; }
163 explicit operator std::string_view() { return " foo "; }
164 };
165 ASSERT_EQ("foo", android::base::Trim(Foo()));
166 }
167
TEST(strings,trim_build_implicit_string_view_conversion)168 TEST(strings, trim_build_implicit_string_view_conversion) {
169 struct Foo {
170 explicit operator std::string() { return " foo "; }
171 operator std::string_view() { return " foo "; }
172 };
173 ASSERT_EQ("foo", android::base::Trim(Foo()));
174 }
175
TEST(strings,join_nothing)176 TEST(strings, join_nothing) {
177 std::vector<std::string> list = {};
178 ASSERT_EQ("", android::base::Join(list, ','));
179 }
180
TEST(strings,join_single)181 TEST(strings, join_single) {
182 std::vector<std::string> list = {"foo"};
183 ASSERT_EQ("foo", android::base::Join(list, ','));
184 }
185
TEST(strings,join_simple)186 TEST(strings, join_simple) {
187 std::vector<std::string> list = {"foo", "bar", "baz"};
188 ASSERT_EQ("foo,bar,baz", android::base::Join(list, ','));
189 }
190
TEST(strings,join_separator_in_vector)191 TEST(strings, join_separator_in_vector) {
192 std::vector<std::string> list = {",", ","};
193 ASSERT_EQ(",,,", android::base::Join(list, ','));
194 }
195
TEST(strings,join_single_int)196 TEST(strings, join_single_int) {
197 ASSERT_EQ("42", android::base::Join(std::vector{42}, ','));
198 }
199
TEST(strings,join_simple_ints)200 TEST(strings, join_simple_ints) {
201 std::set<int> list = {1, 2, 3};
202 ASSERT_EQ("1,2,3", android::base::Join(list, ','));
203 }
204
TEST(strings,join_unordered_set)205 TEST(strings, join_unordered_set) {
206 std::unordered_set<int> list = {1, 2};
207 ASSERT_TRUE("1,2" == android::base::Join(list, ',') ||
208 "2,1" == android::base::Join(list, ','));
209 }
210
TEST(strings,StartsWith_empty)211 TEST(strings, StartsWith_empty) {
212 ASSERT_FALSE(android::base::StartsWith("", "foo"));
213 ASSERT_TRUE(android::base::StartsWith("", ""));
214 }
215
TEST(strings,StartsWithIgnoreCase_empty)216 TEST(strings, StartsWithIgnoreCase_empty) {
217 ASSERT_FALSE(android::base::StartsWithIgnoreCase("", "foo"));
218 ASSERT_TRUE(android::base::StartsWithIgnoreCase("", ""));
219 }
220
TEST(strings,StartsWith_simple)221 TEST(strings, StartsWith_simple) {
222 ASSERT_TRUE(android::base::StartsWith("foo", ""));
223 ASSERT_TRUE(android::base::StartsWith("foo", "f"));
224 ASSERT_TRUE(android::base::StartsWith("foo", "fo"));
225 ASSERT_TRUE(android::base::StartsWith("foo", "foo"));
226 }
227
TEST(strings,StartsWithIgnoreCase_simple)228 TEST(strings, StartsWithIgnoreCase_simple) {
229 ASSERT_TRUE(android::base::StartsWithIgnoreCase("foo", ""));
230 ASSERT_TRUE(android::base::StartsWithIgnoreCase("foo", "f"));
231 ASSERT_TRUE(android::base::StartsWithIgnoreCase("foo", "F"));
232 ASSERT_TRUE(android::base::StartsWithIgnoreCase("foo", "fo"));
233 ASSERT_TRUE(android::base::StartsWithIgnoreCase("foo", "fO"));
234 ASSERT_TRUE(android::base::StartsWithIgnoreCase("foo", "Fo"));
235 ASSERT_TRUE(android::base::StartsWithIgnoreCase("foo", "FO"));
236 ASSERT_TRUE(android::base::StartsWithIgnoreCase("foo", "foo"));
237 ASSERT_TRUE(android::base::StartsWithIgnoreCase("foo", "foO"));
238 ASSERT_TRUE(android::base::StartsWithIgnoreCase("foo", "fOo"));
239 ASSERT_TRUE(android::base::StartsWithIgnoreCase("foo", "fOO"));
240 ASSERT_TRUE(android::base::StartsWithIgnoreCase("foo", "Foo"));
241 ASSERT_TRUE(android::base::StartsWithIgnoreCase("foo", "FoO"));
242 ASSERT_TRUE(android::base::StartsWithIgnoreCase("foo", "FOo"));
243 ASSERT_TRUE(android::base::StartsWithIgnoreCase("foo", "FOO"));
244 }
245
TEST(strings,StartsWith_prefix_too_long)246 TEST(strings, StartsWith_prefix_too_long) {
247 ASSERT_FALSE(android::base::StartsWith("foo", "foobar"));
248 }
249
TEST(strings,StartsWithIgnoreCase_prefix_too_long)250 TEST(strings, StartsWithIgnoreCase_prefix_too_long) {
251 ASSERT_FALSE(android::base::StartsWithIgnoreCase("foo", "foobar"));
252 ASSERT_FALSE(android::base::StartsWithIgnoreCase("foo", "FOOBAR"));
253 }
254
TEST(strings,StartsWith_contains_prefix)255 TEST(strings, StartsWith_contains_prefix) {
256 ASSERT_FALSE(android::base::StartsWith("foobar", "oba"));
257 ASSERT_FALSE(android::base::StartsWith("foobar", "bar"));
258 }
259
TEST(strings,StartsWithIgnoreCase_contains_prefix)260 TEST(strings, StartsWithIgnoreCase_contains_prefix) {
261 ASSERT_FALSE(android::base::StartsWithIgnoreCase("foobar", "oba"));
262 ASSERT_FALSE(android::base::StartsWithIgnoreCase("foobar", "OBA"));
263 ASSERT_FALSE(android::base::StartsWithIgnoreCase("foobar", "bar"));
264 ASSERT_FALSE(android::base::StartsWithIgnoreCase("foobar", "BAR"));
265 }
266
TEST(strings,StartsWith_char)267 TEST(strings, StartsWith_char) {
268 ASSERT_FALSE(android::base::StartsWith("", 'f'));
269 ASSERT_TRUE(android::base::StartsWith("foo", 'f'));
270 ASSERT_FALSE(android::base::StartsWith("foo", 'o'));
271 }
272
TEST(strings,EndsWith_empty)273 TEST(strings, EndsWith_empty) {
274 ASSERT_FALSE(android::base::EndsWith("", "foo"));
275 ASSERT_TRUE(android::base::EndsWith("", ""));
276 }
277
TEST(strings,EndsWithIgnoreCase_empty)278 TEST(strings, EndsWithIgnoreCase_empty) {
279 ASSERT_FALSE(android::base::EndsWithIgnoreCase("", "foo"));
280 ASSERT_FALSE(android::base::EndsWithIgnoreCase("", "FOO"));
281 ASSERT_TRUE(android::base::EndsWithIgnoreCase("", ""));
282 }
283
TEST(strings,EndsWith_simple)284 TEST(strings, EndsWith_simple) {
285 ASSERT_TRUE(android::base::EndsWith("foo", ""));
286 ASSERT_TRUE(android::base::EndsWith("foo", "o"));
287 ASSERT_TRUE(android::base::EndsWith("foo", "oo"));
288 ASSERT_TRUE(android::base::EndsWith("foo", "foo"));
289 }
290
TEST(strings,EndsWithIgnoreCase_simple)291 TEST(strings, EndsWithIgnoreCase_simple) {
292 ASSERT_TRUE(android::base::EndsWithIgnoreCase("foo", ""));
293 ASSERT_TRUE(android::base::EndsWithIgnoreCase("foo", "o"));
294 ASSERT_TRUE(android::base::EndsWithIgnoreCase("foo", "O"));
295 ASSERT_TRUE(android::base::EndsWithIgnoreCase("foo", "oo"));
296 ASSERT_TRUE(android::base::EndsWithIgnoreCase("foo", "oO"));
297 ASSERT_TRUE(android::base::EndsWithIgnoreCase("foo", "Oo"));
298 ASSERT_TRUE(android::base::EndsWithIgnoreCase("foo", "OO"));
299 ASSERT_TRUE(android::base::EndsWithIgnoreCase("foo", "foo"));
300 ASSERT_TRUE(android::base::EndsWithIgnoreCase("foo", "foO"));
301 ASSERT_TRUE(android::base::EndsWithIgnoreCase("foo", "fOo"));
302 ASSERT_TRUE(android::base::EndsWithIgnoreCase("foo", "fOO"));
303 ASSERT_TRUE(android::base::EndsWithIgnoreCase("foo", "Foo"));
304 ASSERT_TRUE(android::base::EndsWithIgnoreCase("foo", "FoO"));
305 ASSERT_TRUE(android::base::EndsWithIgnoreCase("foo", "FOo"));
306 ASSERT_TRUE(android::base::EndsWithIgnoreCase("foo", "FOO"));
307 }
308
TEST(strings,EndsWith_prefix_too_long)309 TEST(strings, EndsWith_prefix_too_long) {
310 ASSERT_FALSE(android::base::EndsWith("foo", "foobar"));
311 }
312
TEST(strings,EndsWithIgnoreCase_prefix_too_long)313 TEST(strings, EndsWithIgnoreCase_prefix_too_long) {
314 ASSERT_FALSE(android::base::EndsWithIgnoreCase("foo", "foobar"));
315 ASSERT_FALSE(android::base::EndsWithIgnoreCase("foo", "FOOBAR"));
316 }
317
TEST(strings,EndsWith_contains_prefix)318 TEST(strings, EndsWith_contains_prefix) {
319 ASSERT_FALSE(android::base::EndsWith("foobar", "oba"));
320 ASSERT_FALSE(android::base::EndsWith("foobar", "foo"));
321 }
322
TEST(strings,EndsWithIgnoreCase_contains_prefix)323 TEST(strings, EndsWithIgnoreCase_contains_prefix) {
324 ASSERT_FALSE(android::base::EndsWithIgnoreCase("foobar", "OBA"));
325 ASSERT_FALSE(android::base::EndsWithIgnoreCase("foobar", "FOO"));
326 }
327
TEST(strings,StartsWith_std_string)328 TEST(strings, StartsWith_std_string) {
329 ASSERT_TRUE(android::base::StartsWith("hello", std::string{"hell"}));
330 ASSERT_FALSE(android::base::StartsWith("goodbye", std::string{"hell"}));
331 }
332
TEST(strings,StartsWithIgnoreCase_std_string)333 TEST(strings, StartsWithIgnoreCase_std_string) {
334 ASSERT_TRUE(android::base::StartsWithIgnoreCase("HeLlO", std::string{"hell"}));
335 ASSERT_FALSE(android::base::StartsWithIgnoreCase("GoOdByE", std::string{"hell"}));
336 }
337
TEST(strings,EndsWith_std_string)338 TEST(strings, EndsWith_std_string) {
339 ASSERT_TRUE(android::base::EndsWith("hello", std::string{"lo"}));
340 ASSERT_FALSE(android::base::EndsWith("goodbye", std::string{"lo"}));
341 }
342
TEST(strings,EndsWithIgnoreCase_std_string)343 TEST(strings, EndsWithIgnoreCase_std_string) {
344 ASSERT_TRUE(android::base::EndsWithIgnoreCase("HeLlO", std::string{"lo"}));
345 ASSERT_FALSE(android::base::EndsWithIgnoreCase("GoOdByE", std::string{"lo"}));
346 }
347
TEST(strings,EndsWith_char)348 TEST(strings, EndsWith_char) {
349 ASSERT_FALSE(android::base::EndsWith("", 'o'));
350 ASSERT_TRUE(android::base::EndsWith("foo", 'o'));
351 ASSERT_FALSE(android::base::EndsWith("foo", "f"));
352 }
353
TEST(strings,EqualsIgnoreCase)354 TEST(strings, EqualsIgnoreCase) {
355 ASSERT_TRUE(android::base::EqualsIgnoreCase("foo", "FOO"));
356 ASSERT_TRUE(android::base::EqualsIgnoreCase("FOO", "foo"));
357 ASSERT_FALSE(android::base::EqualsIgnoreCase("foo", "bar"));
358 ASSERT_FALSE(android::base::EqualsIgnoreCase("foo", "fool"));
359 }
360
TEST(strings,ubsan_28729303)361 TEST(strings, ubsan_28729303) {
362 android::base::Split("/dev/null", ":");
363 }
364
TEST(strings,ConsumePrefix)365 TEST(strings, ConsumePrefix) {
366 std::string_view s{"foo.bar"};
367 ASSERT_FALSE(android::base::ConsumePrefix(&s, "bar."));
368 ASSERT_EQ("foo.bar", s);
369 ASSERT_TRUE(android::base::ConsumePrefix(&s, "foo."));
370 ASSERT_EQ("bar", s);
371 }
372
TEST(strings,ConsumeSuffix)373 TEST(strings, ConsumeSuffix) {
374 std::string_view s{"foo.bar"};
375 ASSERT_FALSE(android::base::ConsumeSuffix(&s, ".foo"));
376 ASSERT_EQ("foo.bar", s);
377 ASSERT_TRUE(android::base::ConsumeSuffix(&s, ".bar"));
378 ASSERT_EQ("foo", s);
379 }
380
TEST(strings,StringReplace_false)381 TEST(strings, StringReplace_false) {
382 // No change.
383 ASSERT_EQ("abcabc", android::base::StringReplace("abcabc", "z", "Z", false));
384 ASSERT_EQ("", android::base::StringReplace("", "z", "Z", false));
385 ASSERT_EQ("abcabc", android::base::StringReplace("abcabc", "", "Z", false));
386
387 // Equal lengths.
388 ASSERT_EQ("Abcabc", android::base::StringReplace("abcabc", "a", "A", false));
389 ASSERT_EQ("aBcabc", android::base::StringReplace("abcabc", "b", "B", false));
390 ASSERT_EQ("abCabc", android::base::StringReplace("abcabc", "c", "C", false));
391
392 // Longer replacement.
393 ASSERT_EQ("foobcabc", android::base::StringReplace("abcabc", "a", "foo", false));
394 ASSERT_EQ("afoocabc", android::base::StringReplace("abcabc", "b", "foo", false));
395 ASSERT_EQ("abfooabc", android::base::StringReplace("abcabc", "c", "foo", false));
396
397 // Shorter replacement.
398 ASSERT_EQ("xxyz", android::base::StringReplace("abcxyz", "abc", "x", false));
399 ASSERT_EQ("axyz", android::base::StringReplace("abcxyz", "bcx", "x", false));
400 ASSERT_EQ("abcx", android::base::StringReplace("abcxyz", "xyz", "x", false));
401 }
402
TEST(strings,StringReplace_true)403 TEST(strings, StringReplace_true) {
404 // No change.
405 ASSERT_EQ("abcabc", android::base::StringReplace("abcabc", "z", "Z", true));
406 ASSERT_EQ("", android::base::StringReplace("", "z", "Z", true));
407 ASSERT_EQ("abcabc", android::base::StringReplace("abcabc", "", "Z", true));
408
409 // Equal lengths.
410 ASSERT_EQ("AbcAbc", android::base::StringReplace("abcabc", "a", "A", true));
411 ASSERT_EQ("aBcaBc", android::base::StringReplace("abcabc", "b", "B", true));
412 ASSERT_EQ("abCabC", android::base::StringReplace("abcabc", "c", "C", true));
413
414 // Longer replacement.
415 ASSERT_EQ("foobcfoobc", android::base::StringReplace("abcabc", "a", "foo", true));
416 ASSERT_EQ("afoocafooc", android::base::StringReplace("abcabc", "b", "foo", true));
417 ASSERT_EQ("abfooabfoo", android::base::StringReplace("abcabc", "c", "foo", true));
418
419 // Shorter replacement.
420 ASSERT_EQ("xxyzx", android::base::StringReplace("abcxyzabc", "abc", "x", true));
421 ASSERT_EQ("<xx>", android::base::StringReplace("<abcabc>", "abc", "x", true));
422 }
423
TEST(strings,ErrnoNumberAsString)424 TEST(strings, ErrnoNumberAsString) {
425 EXPECT_EQ("No such file or directory", android::base::ErrnoNumberAsString(ENOENT));
426 }
427