1 /*
2 * Copyright (C) 2018 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 "perfetto/ext/base/string_utils.h"
18
19 #include "test/gtest_and_gmock.h"
20
21 #include "perfetto/ext/base/optional.h"
22
23 namespace perfetto {
24 namespace base {
25 namespace {
26
27 using testing::ElementsAre;
28
TEST(StringUtilsTest,Lowercase)29 TEST(StringUtilsTest, Lowercase) {
30 EXPECT_EQ(Lowercase('A'), 'a');
31 EXPECT_EQ(Lowercase('a'), 'a');
32 EXPECT_EQ(Lowercase('Z'), 'z');
33 EXPECT_EQ(Lowercase('z'), 'z');
34 EXPECT_EQ(Lowercase('!'), '!');
35 }
36
TEST(StringUtilsTest,Uppercase)37 TEST(StringUtilsTest, Uppercase) {
38 EXPECT_EQ(Uppercase('A'), 'A');
39 EXPECT_EQ(Uppercase('a'), 'A');
40 EXPECT_EQ(Uppercase('Z'), 'Z');
41 EXPECT_EQ(Uppercase('z'), 'Z');
42 EXPECT_EQ(Uppercase('!'), '!');
43 }
44
TEST(StringUtilsTest,CStringToUInt32)45 TEST(StringUtilsTest, CStringToUInt32) {
46 EXPECT_EQ(CStringToUInt32("0"), make_optional<uint32_t>(0U));
47 EXPECT_EQ(CStringToUInt32("1"), make_optional<uint32_t>(1U));
48 EXPECT_EQ(CStringToUInt32("42"), make_optional<uint32_t>(42U));
49 EXPECT_EQ(CStringToUInt32(""), nullopt);
50 EXPECT_EQ(CStringToUInt32("!?"), nullopt);
51 EXPECT_EQ(CStringToUInt32("abc"), nullopt);
52 EXPECT_EQ(CStringToUInt32("123 abc"), nullopt);
53 }
54
TEST(StringUtilsTest,CStringToInt32)55 TEST(StringUtilsTest, CStringToInt32) {
56 EXPECT_EQ(CStringToInt32("0"), make_optional<int32_t>(0));
57 EXPECT_EQ(CStringToInt32("1"), make_optional<int32_t>(1));
58 EXPECT_EQ(CStringToInt32("-42"), make_optional<int32_t>(-42));
59 EXPECT_EQ(CStringToInt32(""), nullopt);
60 EXPECT_EQ(CStringToInt32("!?"), nullopt);
61 EXPECT_EQ(CStringToInt32("abc"), nullopt);
62 EXPECT_EQ(CStringToInt32("123 abc"), nullopt);
63 }
64
TEST(StringUtilsTest,CStringToDouble)65 TEST(StringUtilsTest, CStringToDouble) {
66 EXPECT_DOUBLE_EQ(CStringToDouble("0").value(), 0l);
67 EXPECT_DOUBLE_EQ(CStringToDouble("1").value(), 1l);
68 EXPECT_DOUBLE_EQ(CStringToDouble("-42").value(), -42l);
69 EXPECT_DOUBLE_EQ(CStringToDouble("-42.5").value(), -42.5l);
70 EXPECT_EQ(CStringToDouble(""), nullopt);
71 EXPECT_EQ(CStringToDouble("!?"), nullopt);
72 EXPECT_EQ(CStringToDouble("abc"), nullopt);
73 EXPECT_EQ(CStringToDouble("123 abc"), nullopt);
74 }
75
TEST(StringUtilsTest,StringToUInt32)76 TEST(StringUtilsTest, StringToUInt32) {
77 EXPECT_EQ(StringToUInt32("0"), make_optional<uint32_t>(0U));
78 EXPECT_EQ(StringToUInt32("1"), make_optional<uint32_t>(1U));
79 EXPECT_EQ(StringToUInt32("42"), make_optional<uint32_t>(42U));
80 EXPECT_EQ(StringToUInt32("a", 16), make_optional<uint32_t>(10U));
81 EXPECT_EQ(StringToUInt32("fffffff0", 16),
82 make_optional<uint32_t>(0xfffffff0));
83 EXPECT_EQ(StringToUInt32(""), nullopt);
84 EXPECT_EQ(StringToUInt32("!?"), nullopt);
85 EXPECT_EQ(StringToUInt32("abc"), nullopt);
86 EXPECT_EQ(StringToUInt32("123 abc"), nullopt);
87 EXPECT_EQ(StringToUInt32("beefz", 16), nullopt);
88 }
89
TEST(StringUtilsTest,StringToInt32)90 TEST(StringUtilsTest, StringToInt32) {
91 EXPECT_EQ(StringToInt32("0"), make_optional<int32_t>(0));
92 EXPECT_EQ(StringToInt32("1"), make_optional<int32_t>(1));
93 EXPECT_EQ(StringToInt32("-42"), make_optional<int32_t>(-42));
94 EXPECT_EQ(StringToInt32("42", 16), make_optional<int32_t>(0x42));
95 EXPECT_EQ(StringToInt32("7ffffffe", 16), make_optional<int32_t>(0x7ffffffe));
96 EXPECT_EQ(StringToInt32(""), nullopt);
97 EXPECT_EQ(StringToInt32("!?"), nullopt);
98 EXPECT_EQ(StringToInt32("abc"), nullopt);
99 EXPECT_EQ(StringToInt32("123 abc"), nullopt);
100 EXPECT_EQ(StringToInt32("beefz", 16), nullopt);
101 }
102
TEST(StringUtilsTest,StringToUInt64)103 TEST(StringUtilsTest, StringToUInt64) {
104 EXPECT_EQ(StringToUInt64("0"), make_optional<uint64_t>(0u));
105 EXPECT_EQ(StringToUInt64("1"), make_optional<uint64_t>(1u));
106 EXPECT_EQ(StringToUInt64("5000000000"),
107 make_optional<uint64_t>(5000000000ULL));
108 EXPECT_EQ(StringToUInt64("7ffffffffffffffe", 16),
109 make_optional<uint64_t>(0x7ffffffffffffffeULL));
110 EXPECT_EQ(StringToUInt64("9ffffffffffffffe", 16),
111 make_optional<uint64_t>(0x9ffffffffffffffeULL));
112 EXPECT_EQ(StringToUInt64(""), nullopt);
113 EXPECT_EQ(StringToUInt64("abc"), nullopt);
114 EXPECT_EQ(StringToUInt64("beefz", 16), nullopt);
115 }
116
TEST(StringUtilsTest,StringToInt64)117 TEST(StringUtilsTest, StringToInt64) {
118 EXPECT_EQ(StringToInt64("0"), make_optional<int64_t>(0));
119 EXPECT_EQ(StringToInt64("1"), make_optional<int64_t>(1));
120 EXPECT_EQ(StringToInt64("-5000000000"),
121 make_optional<int64_t>(-5000000000LL));
122 EXPECT_EQ(StringToInt64("5000000000"), make_optional<int64_t>(5000000000LL));
123 EXPECT_EQ(StringToInt64("7ffffffffffffffe", 16),
124 make_optional<int64_t>(0x7ffffffffffffffeLL));
125 EXPECT_EQ(StringToInt64("9ffffffe", 16),
126 make_optional<int64_t>(0x9ffffffeLL));
127 EXPECT_EQ(StringToInt64(""), nullopt);
128 EXPECT_EQ(StringToInt64("abc"), nullopt);
129 EXPECT_EQ(StringToInt64("beefz", 16), nullopt);
130 }
131
TEST(StringUtilsTest,StringToDouble)132 TEST(StringUtilsTest, StringToDouble) {
133 EXPECT_DOUBLE_EQ(StringToDouble("0").value(), 0l);
134 EXPECT_DOUBLE_EQ(StringToDouble("1").value(), 1l);
135 EXPECT_DOUBLE_EQ(StringToDouble("-42").value(), -42l);
136 EXPECT_DOUBLE_EQ(StringToDouble("-42.5").value(), -42.5l);
137 EXPECT_EQ(StringToDouble(""), nullopt);
138 EXPECT_EQ(StringToDouble("!?"), nullopt);
139 EXPECT_EQ(StringToDouble("abc"), nullopt);
140 EXPECT_EQ(StringToDouble("123 abc"), nullopt);
141 }
142
TEST(StringUtilsTest,StartsWith)143 TEST(StringUtilsTest, StartsWith) {
144 EXPECT_TRUE(StartsWith("", ""));
145 EXPECT_TRUE(StartsWith("abc", ""));
146 EXPECT_TRUE(StartsWith("abc", "a"));
147 EXPECT_TRUE(StartsWith("abc", "ab"));
148 EXPECT_TRUE(StartsWith("abc", "abc"));
149 EXPECT_FALSE(StartsWith("abc", "abcd"));
150 EXPECT_FALSE(StartsWith("aa", "ab"));
151 EXPECT_FALSE(StartsWith("", "ab"));
152 }
153
TEST(StringUtilsTest,EndsWith)154 TEST(StringUtilsTest, EndsWith) {
155 EXPECT_TRUE(EndsWith("", ""));
156 EXPECT_TRUE(EndsWith("abc", ""));
157 EXPECT_TRUE(EndsWith("abc", "c"));
158 EXPECT_TRUE(EndsWith("abc", "bc"));
159 EXPECT_TRUE(EndsWith("abc", "abc"));
160 EXPECT_FALSE(EndsWith("bcd", "abcd"));
161 EXPECT_FALSE(EndsWith("abc", "abd"));
162 EXPECT_FALSE(EndsWith("", "c"));
163 }
164
TEST(StringUtilsTest,ToHex)165 TEST(StringUtilsTest, ToHex) {
166 EXPECT_EQ(ToHex(""), "");
167 EXPECT_EQ(ToHex("abc123"), "616263313233");
168 }
169
TEST(StringUtilsTest,IntToHex)170 TEST(StringUtilsTest, IntToHex) {
171 EXPECT_EQ(IntToHexString(0), "0x00");
172 EXPECT_EQ(IntToHexString(1), "0x01");
173 EXPECT_EQ(IntToHexString(16), "0x10");
174 EXPECT_EQ(IntToHexString(4294967295), "0xffffffff");
175 }
176
TEST(StringUtilsTest,Uint64ToHex)177 TEST(StringUtilsTest, Uint64ToHex) {
178 EXPECT_EQ(Uint64ToHexString(0), "0x0");
179 EXPECT_EQ(Uint64ToHexString(1), "0x1");
180 EXPECT_EQ(Uint64ToHexString(16), "0x10");
181 EXPECT_EQ(Uint64ToHexString(18446744073709551615UL), "0xffffffffffffffff");
182 }
183
TEST(StringUtilsTest,Uint64ToHexNoPrefix)184 TEST(StringUtilsTest, Uint64ToHexNoPrefix) {
185 EXPECT_EQ(Uint64ToHexStringNoPrefix(0), "0");
186 EXPECT_EQ(Uint64ToHexStringNoPrefix(1), "1");
187 EXPECT_EQ(Uint64ToHexStringNoPrefix(16), "10");
188 EXPECT_EQ(Uint64ToHexStringNoPrefix(18446744073709551615UL),
189 "ffffffffffffffff");
190 }
191
TEST(StringUtilsTest,CaseInsensitiveEqual)192 TEST(StringUtilsTest, CaseInsensitiveEqual) {
193 EXPECT_TRUE(CaseInsensitiveEqual("", ""));
194 EXPECT_TRUE(CaseInsensitiveEqual("abc", "abc"));
195 EXPECT_TRUE(CaseInsensitiveEqual("ABC", "abc"));
196 EXPECT_TRUE(CaseInsensitiveEqual("abc", "ABC"));
197 EXPECT_FALSE(CaseInsensitiveEqual("abc", "AB"));
198 EXPECT_FALSE(CaseInsensitiveEqual("ab", "ABC"));
199 }
200
TEST(StringUtilsTest,SplitString)201 TEST(StringUtilsTest, SplitString) {
202 EXPECT_THAT(SplitString("", ":"), ElementsAre());
203 EXPECT_THAT(SplitString("a:b:c", ":"), ElementsAre("a", "b", "c"));
204 EXPECT_THAT(SplitString("a::b::c", "::"), ElementsAre("a", "b", "c"));
205 EXPECT_THAT(SplitString("::::a::b::::c::", "::"), ElementsAre("a", "b", "c"));
206 EXPECT_THAT(SplitString("abc", ":"), ElementsAre("abc"));
207 EXPECT_THAT(SplitString("abc", "::"), ElementsAre("abc"));
208 EXPECT_THAT(SplitString("abc", ":"), ElementsAre("abc"));
209 EXPECT_THAT(SplitString("abc", "::"), ElementsAre("abc"));
210 }
211
TEST(StringUtilsTest,Strip)212 TEST(StringUtilsTest, Strip) {
213 EXPECT_EQ(StripPrefix("abc", ""), "abc");
214 EXPECT_EQ(StripPrefix("abc", "a"), "bc");
215 EXPECT_EQ(StripPrefix("abc", "ab"), "c");
216 EXPECT_EQ(StripPrefix("abc", "abc"), "");
217 EXPECT_EQ(StripPrefix("abc", "abcd"), "abc");
218
219 EXPECT_EQ(StripSuffix("abc", ""), "abc");
220 EXPECT_EQ(StripSuffix("abc", "c"), "ab");
221 EXPECT_EQ(StripSuffix("abc", "bc"), "a");
222 EXPECT_EQ(StripSuffix("abc", "abc"), "");
223 EXPECT_EQ(StripSuffix("abc", "ebcd"), "abc");
224
225 EXPECT_EQ(StripChars("foobar", "", '_'), "foobar");
226 EXPECT_EQ(StripChars("foobar", "x", '_'), "foobar");
227 EXPECT_EQ(StripChars("foobar", "f", '_'), "_oobar");
228 EXPECT_EQ(StripChars("foobar", "o", '_'), "f__bar");
229 EXPECT_EQ(StripChars("foobar", "oa", '_'), "f__b_r");
230 EXPECT_EQ(StripChars("foobar", "fbr", '_'), "_oo_a_");
231 EXPECT_EQ(StripChars("foobar", "froab", '_'), "______");
232 }
233
TEST(StringUtilsTest,Contains)234 TEST(StringUtilsTest, Contains) {
235 EXPECT_TRUE(Contains("", ""));
236 EXPECT_TRUE(Contains("abc", ""));
237 EXPECT_TRUE(Contains("abc", "a"));
238 EXPECT_TRUE(Contains("abc", "b"));
239 EXPECT_TRUE(Contains("abc", "c"));
240 EXPECT_TRUE(Contains("abc", "ab"));
241 EXPECT_TRUE(Contains("abc", "bc"));
242 EXPECT_TRUE(Contains("abc", "abc"));
243 EXPECT_FALSE(Contains("abc", "d"));
244 EXPECT_FALSE(Contains("abc", "ac"));
245 EXPECT_FALSE(Contains("abc", "abcd"));
246 EXPECT_FALSE(Contains("", "a"));
247 EXPECT_FALSE(Contains("", "abc"));
248 }
249
TEST(StringUtilsTest,Find)250 TEST(StringUtilsTest, Find) {
251 EXPECT_EQ(Find("", ""), 0u);
252 EXPECT_EQ(Find("", "abc"), 0u);
253 EXPECT_EQ(Find("a", "abc"), 0u);
254 EXPECT_EQ(Find("b", "abc"), 1u);
255 EXPECT_EQ(Find("c", "abc"), 2u);
256 EXPECT_EQ(Find("ab", "abc"), 0u);
257 EXPECT_EQ(Find("bc", "abc"), 1u);
258 EXPECT_EQ(Find("abc", "abc"), 0u);
259 EXPECT_EQ(Find("d", "abc"), std::string::npos);
260 EXPECT_EQ(Find("ac", "abc"), std::string::npos);
261 EXPECT_EQ(Find("abcd", "abc"), std::string::npos);
262 EXPECT_EQ(Find("a", ""), std::string::npos);
263 EXPECT_EQ(Find("abc", ""), std::string::npos);
264 }
265
TEST(StringUtilsTest,ReplaceAll)266 TEST(StringUtilsTest, ReplaceAll) {
267 EXPECT_EQ(ReplaceAll("", "a", ""), "");
268 EXPECT_EQ(ReplaceAll("", "a", "b"), "");
269 EXPECT_EQ(ReplaceAll("a", "a", "b"), "b");
270 EXPECT_EQ(ReplaceAll("aaaa", "a", "b"), "bbbb");
271 EXPECT_EQ(ReplaceAll("aaaa", "aa", "b"), "bb");
272 EXPECT_EQ(ReplaceAll("aa", "aa", "bb"), "bb");
273 EXPECT_EQ(ReplaceAll("aa", "a", "bb"), "bbbb");
274 EXPECT_EQ(ReplaceAll("abc", "a", "b"), "bbc");
275 EXPECT_EQ(ReplaceAll("abc", "c", "b"), "abb");
276 EXPECT_EQ(ReplaceAll("abc", "c", "bbb"), "abbbb");
277 }
278
TEST(StringUtilsTest,TrimLeading)279 TEST(StringUtilsTest, TrimLeading) {
280 EXPECT_EQ(TrimLeading(""), "");
281 EXPECT_EQ(TrimLeading("a"), "a");
282 EXPECT_EQ(TrimLeading(" aaaa"), "aaaa");
283 EXPECT_EQ(TrimLeading(" aaaaa "), "aaaaa ");
284 }
285
286 } // namespace
287 } // namespace base
288 } // namespace perfetto
289