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 <optional>
20 #include "test/gtest_and_gmock.h"
21
22 namespace perfetto {
23 namespace base {
24 namespace {
25
26 template <size_t N>
27 struct UninitializedBuf {
UninitializedBufperfetto::base::__anon1c9e3e1a0111::UninitializedBuf28 UninitializedBuf() { memset(data, '?', sizeof(data)); }
operator char*perfetto::base::__anon1c9e3e1a0111::UninitializedBuf29 operator char*() { return data; }
30 char data[N];
31 };
32
33 using testing::ElementsAre;
34
TEST(StringUtilsTest,Lowercase)35 TEST(StringUtilsTest, Lowercase) {
36 EXPECT_EQ(Lowercase('A'), 'a');
37 EXPECT_EQ(Lowercase('a'), 'a');
38 EXPECT_EQ(Lowercase('Z'), 'z');
39 EXPECT_EQ(Lowercase('z'), 'z');
40 EXPECT_EQ(Lowercase('!'), '!');
41 }
42
TEST(StringUtilsTest,Uppercase)43 TEST(StringUtilsTest, Uppercase) {
44 EXPECT_EQ(Uppercase('A'), 'A');
45 EXPECT_EQ(Uppercase('a'), 'A');
46 EXPECT_EQ(Uppercase('Z'), 'Z');
47 EXPECT_EQ(Uppercase('z'), 'Z');
48 EXPECT_EQ(Uppercase('!'), '!');
49 }
50
TEST(StringUtilsTest,CStringToUInt32)51 TEST(StringUtilsTest, CStringToUInt32) {
52 EXPECT_EQ(CStringToUInt32("0"), std::make_optional<uint32_t>(0U));
53 EXPECT_EQ(CStringToUInt32("1"), std::make_optional<uint32_t>(1U));
54 EXPECT_EQ(CStringToUInt32("42"), std::make_optional<uint32_t>(42U));
55 EXPECT_EQ(CStringToUInt32("-42"),
56 std::make_optional<uint32_t>(static_cast<uint32_t>(-42)));
57 EXPECT_EQ(CStringToUInt32(""), std::nullopt);
58 EXPECT_EQ(CStringToUInt32("!?"), std::nullopt);
59 EXPECT_EQ(CStringToUInt32("abc"), std::nullopt);
60 EXPECT_EQ(CStringToUInt32("123 abc"), std::nullopt);
61 }
62
TEST(StringUtilsTest,CStringToInt32)63 TEST(StringUtilsTest, CStringToInt32) {
64 EXPECT_EQ(CStringToInt32("0"), std::make_optional<int32_t>(0));
65 EXPECT_EQ(CStringToInt32("1"), std::make_optional<int32_t>(1));
66 EXPECT_EQ(CStringToInt32("-42"), std::make_optional<int32_t>(-42));
67 EXPECT_EQ(CStringToInt32(""), std::nullopt);
68 EXPECT_EQ(CStringToInt32("!?"), std::nullopt);
69 EXPECT_EQ(CStringToInt32("abc"), std::nullopt);
70 EXPECT_EQ(CStringToInt32("123 abc"), std::nullopt);
71 }
72
TEST(StringUtilsTest,CStringToDouble)73 TEST(StringUtilsTest, CStringToDouble) {
74 EXPECT_DOUBLE_EQ(CStringToDouble("0").value(), 0l);
75 EXPECT_DOUBLE_EQ(CStringToDouble("1").value(), 1l);
76 EXPECT_DOUBLE_EQ(CStringToDouble("-42").value(), -42l);
77 EXPECT_DOUBLE_EQ(CStringToDouble("-42.5").value(), -42.5l);
78 EXPECT_EQ(CStringToDouble(""), std::nullopt);
79 EXPECT_EQ(CStringToDouble("!?"), std::nullopt);
80 EXPECT_EQ(CStringToDouble("abc"), std::nullopt);
81 EXPECT_EQ(CStringToDouble("123 abc"), std::nullopt);
82 }
83
TEST(StringUtilsTest,StringToUInt32)84 TEST(StringUtilsTest, StringToUInt32) {
85 EXPECT_EQ(StringToUInt32("0"), std::make_optional<uint32_t>(0U));
86 EXPECT_EQ(StringToUInt32("1"), std::make_optional<uint32_t>(1U));
87 EXPECT_EQ(StringToUInt32("42"), std::make_optional<uint32_t>(42U));
88 EXPECT_EQ(StringToUInt32("-42"),
89 std::make_optional<uint32_t>(static_cast<uint32_t>(-42)));
90 EXPECT_EQ(StringToUInt32("a", 16), std::make_optional<uint32_t>(10U));
91 EXPECT_EQ(StringToUInt32("fffffff0", 16),
92 std::make_optional<uint32_t>(0xfffffff0));
93 EXPECT_EQ(StringToUInt32(""), std::nullopt);
94 EXPECT_EQ(StringToUInt32("!?"), std::nullopt);
95 EXPECT_EQ(StringToUInt32("abc"), std::nullopt);
96 EXPECT_EQ(StringToUInt32("123 abc"), std::nullopt);
97 EXPECT_EQ(StringToUInt32("beefz", 16), std::nullopt);
98 }
99
TEST(StringUtilsTest,StringToInt32)100 TEST(StringUtilsTest, StringToInt32) {
101 EXPECT_EQ(StringToInt32("0"), std::make_optional<int32_t>(0));
102 EXPECT_EQ(StringToInt32("1"), std::make_optional<int32_t>(1));
103 EXPECT_EQ(StringToInt32("+42"), std::make_optional<int32_t>(42));
104 EXPECT_EQ(StringToInt32("+0042"), std::make_optional<int32_t>(42));
105 EXPECT_EQ(StringToInt32("-42"), std::make_optional<int32_t>(-42));
106 EXPECT_EQ(StringToInt32("42", 16), std::make_optional<int32_t>(0x42));
107 EXPECT_EQ(StringToInt32("7ffffffe", 16),
108 std::make_optional<int32_t>(0x7ffffffe));
109 EXPECT_EQ(StringToInt32(""), std::nullopt);
110 EXPECT_EQ(StringToInt32("!?"), std::nullopt);
111 EXPECT_EQ(StringToInt32("abc"), std::nullopt);
112 EXPECT_EQ(StringToInt32("123 abc"), std::nullopt);
113 EXPECT_EQ(StringToInt32("beefz", 16), std::nullopt);
114 }
115
TEST(StringUtilsTest,StringToUInt64)116 TEST(StringUtilsTest, StringToUInt64) {
117 EXPECT_EQ(StringToUInt64("0"), std::make_optional<uint64_t>(0u));
118 EXPECT_EQ(StringToUInt64("1"), std::make_optional<uint64_t>(1u));
119 EXPECT_EQ(StringToUInt64("-5000000000"),
120 std::make_optional<uint64_t>(static_cast<uint64_t>(-5000000000LL)));
121 EXPECT_EQ(StringToUInt64("5000000000"),
122 std::make_optional<uint64_t>(5000000000ULL));
123 EXPECT_EQ(StringToUInt64("7ffffffffffffffe", 16),
124 std::make_optional<uint64_t>(0x7ffffffffffffffeULL));
125 EXPECT_EQ(StringToUInt64("9ffffffffffffffe", 16),
126 std::make_optional<uint64_t>(0x9ffffffffffffffeULL));
127 EXPECT_EQ(StringToUInt64(""), std::nullopt);
128 EXPECT_EQ(StringToUInt64("abc"), std::nullopt);
129 EXPECT_EQ(StringToUInt64("beefz", 16), std::nullopt);
130 }
131
TEST(StringUtilsTest,StringToInt64)132 TEST(StringUtilsTest, StringToInt64) {
133 EXPECT_EQ(StringToInt64("0"), std::make_optional<int64_t>(0));
134 EXPECT_EQ(StringToInt64("1"), std::make_optional<int64_t>(1));
135 EXPECT_EQ(StringToInt64("-5000000000"),
136 std::make_optional<int64_t>(-5000000000LL));
137 EXPECT_EQ(StringToInt64("5000000000"),
138 std::make_optional<int64_t>(5000000000LL));
139 EXPECT_EQ(StringToInt64("7ffffffffffffffe", 16),
140 std::make_optional<int64_t>(0x7ffffffffffffffeLL));
141 EXPECT_EQ(StringToInt64("9ffffffe", 16),
142 std::make_optional<int64_t>(0x9ffffffeLL));
143 EXPECT_EQ(StringToInt64(""), std::nullopt);
144 EXPECT_EQ(StringToInt64("abc"), std::nullopt);
145 EXPECT_EQ(StringToInt64("beefz", 16), std::nullopt);
146 }
147
TEST(StringUtilsTest,StringToDouble)148 TEST(StringUtilsTest, StringToDouble) {
149 EXPECT_DOUBLE_EQ(StringToDouble("0").value(), 0l);
150 EXPECT_DOUBLE_EQ(StringToDouble("1").value(), 1l);
151 EXPECT_DOUBLE_EQ(StringToDouble("-42").value(), -42l);
152 EXPECT_DOUBLE_EQ(StringToDouble("-42.5").value(), -42.5l);
153 EXPECT_DOUBLE_EQ(StringToDouble("0.5").value(), .5l);
154 EXPECT_DOUBLE_EQ(StringToDouble(".5").value(), .5l);
155 EXPECT_EQ(StringToDouble(""), std::nullopt);
156 EXPECT_EQ(StringToDouble("!?"), std::nullopt);
157 EXPECT_EQ(StringToDouble("abc"), std::nullopt);
158 EXPECT_EQ(StringToDouble("123 abc"), std::nullopt);
159 EXPECT_EQ(StringToDouble("124,456"), std::nullopt);
160 EXPECT_EQ(StringToDouble("4 2"), std::nullopt);
161 EXPECT_EQ(StringToDouble(" - 42"), std::nullopt);
162 }
163
TEST(StringUtilsTest,StringViewToUInt32)164 TEST(StringUtilsTest, StringViewToUInt32) {
165 EXPECT_EQ(StringViewToUInt32("0"), std::make_optional<uint32_t>(0U));
166 EXPECT_EQ(StringViewToUInt32("1"), std::make_optional<uint32_t>(1U));
167 EXPECT_EQ(StringViewToUInt32("42"), std::make_optional<uint32_t>(42U));
168 EXPECT_EQ(StringViewToUInt32("-42"),
169 std::make_optional<uint32_t>(static_cast<uint32_t>(-42)));
170 EXPECT_EQ(StringViewToUInt32("a", 16), std::make_optional<uint32_t>(10U));
171 EXPECT_EQ(StringViewToUInt32("fffffff0", 16),
172 std::make_optional<uint32_t>(0xfffffff0));
173 EXPECT_EQ(StringViewToUInt32(""), std::nullopt);
174 EXPECT_EQ(StringViewToUInt32("!?"), std::nullopt);
175 EXPECT_EQ(StringViewToUInt32("abc"), std::nullopt);
176 EXPECT_EQ(StringViewToUInt32("123 abc"), std::nullopt);
177 EXPECT_EQ(StringViewToUInt32("beefz", 16), std::nullopt);
178 }
179
TEST(StringUtilsTest,StringViewToInt32)180 TEST(StringUtilsTest, StringViewToInt32) {
181 EXPECT_EQ(StringViewToInt32("0"), std::make_optional<int32_t>(0));
182 EXPECT_EQ(StringViewToInt32("1"), std::make_optional<int32_t>(1));
183 EXPECT_EQ(StringViewToInt32("+42"), std::make_optional<int32_t>(42));
184 EXPECT_EQ(StringViewToInt32("+0042"), std::make_optional<int32_t>(42));
185 EXPECT_EQ(StringViewToInt32("-42"), std::make_optional<int32_t>(-42));
186 EXPECT_EQ(StringViewToInt32("42", 16), std::make_optional<int32_t>(0x42));
187 EXPECT_EQ(StringViewToInt32("7ffffffe", 16),
188 std::make_optional<int32_t>(0x7ffffffe));
189 EXPECT_EQ(StringViewToInt32(""), std::nullopt);
190 EXPECT_EQ(StringViewToInt32("!?"), std::nullopt);
191 EXPECT_EQ(StringViewToInt32("abc"), std::nullopt);
192 EXPECT_EQ(StringViewToInt32("123 abc"), std::nullopt);
193 EXPECT_EQ(StringViewToInt32("beefz", 16), std::nullopt);
194 }
195
TEST(StringUtilsTest,StringViewToUInt64)196 TEST(StringUtilsTest, StringViewToUInt64) {
197 EXPECT_EQ(StringViewToUInt64("0"), std::make_optional<uint64_t>(0u));
198 EXPECT_EQ(StringViewToUInt64("1"), std::make_optional<uint64_t>(1u));
199 EXPECT_EQ(StringViewToUInt64("-5000000000"),
200 std::make_optional<uint64_t>(static_cast<uint64_t>(-5000000000LL)));
201 EXPECT_EQ(StringViewToUInt64("5000000000"),
202 std::make_optional<uint64_t>(5000000000ULL));
203 EXPECT_EQ(StringViewToUInt64("7ffffffffffffffe", 16),
204 std::make_optional<uint64_t>(0x7ffffffffffffffeULL));
205 EXPECT_EQ(StringViewToUInt64("9ffffffffffffffe", 16),
206 std::make_optional<uint64_t>(0x9ffffffffffffffeULL));
207 EXPECT_EQ(StringViewToUInt64(""), std::nullopt);
208 EXPECT_EQ(StringViewToUInt64("abc"), std::nullopt);
209 EXPECT_EQ(StringViewToUInt64("beefz", 16), std::nullopt);
210 }
211
TEST(StringUtilsTest,StringViewToInt64)212 TEST(StringUtilsTest, StringViewToInt64) {
213 EXPECT_EQ(StringViewToInt64("0"), std::make_optional<int64_t>(0));
214 EXPECT_EQ(StringViewToInt64("1"), std::make_optional<int64_t>(1));
215 EXPECT_EQ(StringViewToInt64("-5000000000"),
216 std::make_optional<int64_t>(-5000000000LL));
217 EXPECT_EQ(StringViewToInt64("5000000000"),
218 std::make_optional<int64_t>(5000000000LL));
219 EXPECT_EQ(StringViewToInt64("7ffffffffffffffe", 16),
220 std::make_optional<int64_t>(0x7ffffffffffffffeLL));
221 EXPECT_EQ(StringViewToInt64("9ffffffe", 16),
222 std::make_optional<int64_t>(0x9ffffffeLL));
223 EXPECT_EQ(StringViewToInt64(""), std::nullopt);
224 EXPECT_EQ(StringViewToInt64("abc"), std::nullopt);
225 EXPECT_EQ(StringViewToInt64("beefz", 16), std::nullopt);
226 }
227
228 // TODO: As of Clang 19.0 std::from_chars is unimplemented for type double
229 // despite being part of C++17 standard, and already being supported by GCC and
230 // MSVC. Enable this once we have double support in Clang.
231 // TEST(StringUtilsTest, StringViewToDouble) {
232 // EXPECT_DOUBLE_EQ(StringViewToDouble("0").value(), 0l);
233 // EXPECT_DOUBLE_EQ(StringViewToDouble("1").value(), 1l);
234 // EXPECT_DOUBLE_EQ(StringViewToDouble("-42").value(), -42l);
235 // EXPECT_DOUBLE_EQ(StringViewToDouble("-42.5").value(), -42.5l);
236 // EXPECT_DOUBLE_EQ(StringViewToDouble("0.5").value(), .5l);
237 // EXPECT_DOUBLE_EQ(StringViewToDouble(".5").value(), .5l);
238 // EXPECT_EQ(StringViewToDouble(""), std::nullopt);
239 // EXPECT_EQ(StringViewToDouble("!?"), std::nullopt);
240 // EXPECT_EQ(StringViewToDouble("abc"), std::nullopt);
241 // EXPECT_EQ(StringViewToDouble("123 abc"), std::nullopt);
242 // EXPECT_EQ(StringViewToDouble("124,456"), std::nullopt);
243 // EXPECT_EQ(StringViewToDouble("4 2"), std::nullopt);
244 // EXPECT_EQ(StringViewToDouble(" - 42"), std::nullopt);
245
TEST(StringUtilsTest,StartsWith)246 TEST(StringUtilsTest, StartsWith) {
247 EXPECT_TRUE(StartsWith("", ""));
248 EXPECT_TRUE(StartsWith("abc", ""));
249 EXPECT_TRUE(StartsWith("abc", "a"));
250 EXPECT_TRUE(StartsWith("abc", "ab"));
251 EXPECT_TRUE(StartsWith("abc", "abc"));
252 EXPECT_FALSE(StartsWith("abc", "abcd"));
253 EXPECT_FALSE(StartsWith("aa", "ab"));
254 EXPECT_FALSE(StartsWith("", "ab"));
255 }
256
TEST(StringUtilsTest,StartsWithAny)257 TEST(StringUtilsTest, StartsWithAny) {
258 EXPECT_FALSE(StartsWithAny("", {"a", "b"}));
259 EXPECT_FALSE(StartsWithAny("abcd", {}));
260 EXPECT_FALSE(StartsWithAny("", {}));
261 EXPECT_TRUE(StartsWithAny("abcd", {"ac", "ab"}));
262 EXPECT_FALSE(StartsWithAny("abcd", {"bc", "ac"}));
263 }
264
TEST(StringUtilsTest,EndsWith)265 TEST(StringUtilsTest, EndsWith) {
266 EXPECT_TRUE(EndsWith("", ""));
267 EXPECT_TRUE(EndsWith("abc", ""));
268 EXPECT_TRUE(EndsWith("abc", "c"));
269 EXPECT_TRUE(EndsWith("abc", "bc"));
270 EXPECT_TRUE(EndsWith("abc", "abc"));
271 EXPECT_FALSE(EndsWith("bcd", "abcd"));
272 EXPECT_FALSE(EndsWith("abc", "abd"));
273 EXPECT_FALSE(EndsWith("", "c"));
274 }
275
TEST(StringUtilsTest,ToHex)276 TEST(StringUtilsTest, ToHex) {
277 EXPECT_EQ(ToHex(""), "");
278 EXPECT_EQ(ToHex("abc123"), "616263313233");
279 }
280
TEST(StringUtilsTest,IntToHex)281 TEST(StringUtilsTest, IntToHex) {
282 EXPECT_EQ(IntToHexString(0), "0x00");
283 EXPECT_EQ(IntToHexString(1), "0x01");
284 EXPECT_EQ(IntToHexString(16), "0x10");
285 EXPECT_EQ(IntToHexString(4294967295), "0xffffffff");
286 }
287
TEST(StringUtilsTest,Uint64ToHex)288 TEST(StringUtilsTest, Uint64ToHex) {
289 EXPECT_EQ(Uint64ToHexString(0), "0x0");
290 EXPECT_EQ(Uint64ToHexString(1), "0x1");
291 EXPECT_EQ(Uint64ToHexString(16), "0x10");
292 EXPECT_EQ(Uint64ToHexString(18446744073709551615UL), "0xffffffffffffffff");
293 }
294
TEST(StringUtilsTest,Uint64ToHexNoPrefix)295 TEST(StringUtilsTest, Uint64ToHexNoPrefix) {
296 EXPECT_EQ(Uint64ToHexStringNoPrefix(0), "0");
297 EXPECT_EQ(Uint64ToHexStringNoPrefix(1), "1");
298 EXPECT_EQ(Uint64ToHexStringNoPrefix(16), "10");
299 EXPECT_EQ(Uint64ToHexStringNoPrefix(18446744073709551615UL),
300 "ffffffffffffffff");
301 }
302
TEST(StringUtilsTest,CaseInsensitiveEqual)303 TEST(StringUtilsTest, CaseInsensitiveEqual) {
304 EXPECT_TRUE(CaseInsensitiveEqual("", ""));
305 EXPECT_TRUE(CaseInsensitiveEqual("abc", "abc"));
306 EXPECT_TRUE(CaseInsensitiveEqual("ABC", "abc"));
307 EXPECT_TRUE(CaseInsensitiveEqual("abc", "ABC"));
308 EXPECT_FALSE(CaseInsensitiveEqual("abc", "AB"));
309 EXPECT_FALSE(CaseInsensitiveEqual("ab", "ABC"));
310 }
311
TEST(StringUtilsTest,SplitString)312 TEST(StringUtilsTest, SplitString) {
313 EXPECT_THAT(SplitString("", ":"), ElementsAre());
314 EXPECT_THAT(SplitString("a:b:c", ":"), ElementsAre("a", "b", "c"));
315 EXPECT_THAT(SplitString("a::b::c", "::"), ElementsAre("a", "b", "c"));
316 EXPECT_THAT(SplitString("::::a::b::::c::", "::"), ElementsAre("a", "b", "c"));
317 EXPECT_THAT(SplitString("abc", ":"), ElementsAre("abc"));
318 EXPECT_THAT(SplitString("abc", "::"), ElementsAre("abc"));
319 EXPECT_THAT(SplitString("abc", ":"), ElementsAre("abc"));
320 EXPECT_THAT(SplitString("abc", "::"), ElementsAre("abc"));
321 }
322
TEST(StringUtilsTest,Strip)323 TEST(StringUtilsTest, Strip) {
324 EXPECT_EQ(StripPrefix("abc", ""), "abc");
325 EXPECT_EQ(StripPrefix("abc", "a"), "bc");
326 EXPECT_EQ(StripPrefix("abc", "ab"), "c");
327 EXPECT_EQ(StripPrefix("abc", "abc"), "");
328 EXPECT_EQ(StripPrefix("abc", "abcd"), "abc");
329
330 EXPECT_EQ(StripSuffix("abc", ""), "abc");
331 EXPECT_EQ(StripSuffix("abc", "c"), "ab");
332 EXPECT_EQ(StripSuffix("abc", "bc"), "a");
333 EXPECT_EQ(StripSuffix("abc", "abc"), "");
334 EXPECT_EQ(StripSuffix("abc", "ebcd"), "abc");
335
336 EXPECT_EQ(StripChars("foobar", "", '_'), "foobar");
337 EXPECT_EQ(StripChars("foobar", "x", '_'), "foobar");
338 EXPECT_EQ(StripChars("foobar", "f", '_'), "_oobar");
339 EXPECT_EQ(StripChars("foobar", "o", '_'), "f__bar");
340 EXPECT_EQ(StripChars("foobar", "oa", '_'), "f__b_r");
341 EXPECT_EQ(StripChars("foobar", "fbr", '_'), "_oo_a_");
342 EXPECT_EQ(StripChars("foobar", "froab", '_'), "______");
343 }
344
TEST(StringUtilsTest,TrimWhitespace)345 TEST(StringUtilsTest, TrimWhitespace) {
346 EXPECT_EQ(TrimWhitespace(""), "");
347 EXPECT_EQ(TrimWhitespace(" "), "");
348 EXPECT_EQ(TrimWhitespace("\t\n"), "");
349
350 EXPECT_EQ(TrimWhitespace("\tx\n\n"), "x");
351 EXPECT_EQ(TrimWhitespace("\tx\n"), "x");
352 EXPECT_EQ(TrimWhitespace("\tx\nx\n"), "x\nx");
353 }
354
TEST(StringUtilsTest,Contains)355 TEST(StringUtilsTest, Contains) {
356 EXPECT_TRUE(Contains("", ""));
357 EXPECT_TRUE(Contains("abc", ""));
358 EXPECT_TRUE(Contains("abc", "a"));
359 EXPECT_TRUE(Contains("abc", "b"));
360 EXPECT_TRUE(Contains("abc", "c"));
361 EXPECT_TRUE(Contains("abc", "ab"));
362 EXPECT_TRUE(Contains("abc", "bc"));
363 EXPECT_TRUE(Contains("abc", "abc"));
364 EXPECT_FALSE(Contains("abc", "d"));
365 EXPECT_FALSE(Contains("abc", "ac"));
366 EXPECT_FALSE(Contains("abc", "abcd"));
367 EXPECT_FALSE(Contains("", "a"));
368 EXPECT_FALSE(Contains("", "abc"));
369 }
370
TEST(StringUtilsTest,Find)371 TEST(StringUtilsTest, Find) {
372 EXPECT_EQ(Find("", ""), 0u);
373 EXPECT_EQ(Find("", "abc"), 0u);
374 EXPECT_EQ(Find("a", "abc"), 0u);
375 EXPECT_EQ(Find("b", "abc"), 1u);
376 EXPECT_EQ(Find("c", "abc"), 2u);
377 EXPECT_EQ(Find("ab", "abc"), 0u);
378 EXPECT_EQ(Find("bc", "abc"), 1u);
379 EXPECT_EQ(Find("abc", "abc"), 0u);
380 EXPECT_EQ(Find("d", "abc"), std::string::npos);
381 EXPECT_EQ(Find("ac", "abc"), std::string::npos);
382 EXPECT_EQ(Find("abcd", "abc"), std::string::npos);
383 EXPECT_EQ(Find("a", ""), std::string::npos);
384 EXPECT_EQ(Find("abc", ""), std::string::npos);
385 }
386
TEST(StringUtilsTest,ReplaceAll)387 TEST(StringUtilsTest, ReplaceAll) {
388 EXPECT_EQ(ReplaceAll("", "a", ""), "");
389 EXPECT_EQ(ReplaceAll("", "a", "b"), "");
390 EXPECT_EQ(ReplaceAll("a", "a", "b"), "b");
391 EXPECT_EQ(ReplaceAll("aaaa", "a", "b"), "bbbb");
392 EXPECT_EQ(ReplaceAll("aaaa", "aa", "b"), "bb");
393 EXPECT_EQ(ReplaceAll("aa", "aa", "bb"), "bb");
394 EXPECT_EQ(ReplaceAll("aa", "a", "bb"), "bbbb");
395 EXPECT_EQ(ReplaceAll("abc", "a", "b"), "bbc");
396 EXPECT_EQ(ReplaceAll("abc", "c", "b"), "abb");
397 EXPECT_EQ(ReplaceAll("abc", "c", "bbb"), "abbbb");
398 }
399
TEST(StringUtilsTest,StringCopy)400 TEST(StringUtilsTest, StringCopy) {
401 // Nothing should be written when |dst_size| = 0.
402 {
403 char dst[2] = {42, 43};
404 StringCopy(dst, "12345", 0);
405 EXPECT_EQ(42, dst[0]);
406 EXPECT_EQ(43, dst[1]);
407 }
408
409 // Nominal case, len(src) < sizeof(dst).
410 {
411 UninitializedBuf<10> dst;
412 StringCopy(dst, "1234567", sizeof(dst));
413 EXPECT_STREQ(dst, "1234567");
414 }
415
416 // Edge case where we perfectly fit including the \0.
417 {
418 UninitializedBuf<8> dst;
419 StringCopy(dst, "1234567", sizeof(dst));
420 EXPECT_STREQ(dst, "1234567");
421 }
422
423 // Edge case where |dst| is smaller by one char.
424 {
425 UninitializedBuf<8> dst;
426 StringCopy(dst, "12345678", sizeof(dst));
427 EXPECT_STREQ(dst, "1234567");
428 }
429
430 // Case when |dst| is smaller than |src|.
431 {
432 UninitializedBuf<3> dst;
433 StringCopy(dst, "12345678", sizeof(dst));
434 EXPECT_STREQ(dst, "12");
435 }
436 }
437
TEST(StringUtilsTest,SprintfTrunc)438 TEST(StringUtilsTest, SprintfTrunc) {
439 {
440 UninitializedBuf<3> dst;
441 ASSERT_EQ(0u, SprintfTrunc(dst, sizeof(dst), "%s", ""));
442 EXPECT_STREQ(dst, "");
443 }
444
445 {
446 char dst[3]{'O', 'K', '\0'};
447 ASSERT_EQ(0u, SprintfTrunc(dst, 0, "whatever"));
448 EXPECT_STREQ(dst, "OK"); // dst_size == 0 shouldn't touch the buffer.
449 }
450
451 {
452 UninitializedBuf<1> dst;
453 ASSERT_EQ(0u, SprintfTrunc(dst, sizeof(dst), "whatever"));
454 EXPECT_STREQ(dst, "");
455 }
456
457 {
458 UninitializedBuf<3> dst;
459 ASSERT_EQ(1u, SprintfTrunc(dst, sizeof(dst), "1"));
460 EXPECT_STREQ(dst, "1");
461 }
462
463 {
464 UninitializedBuf<3> dst;
465 ASSERT_EQ(2u, SprintfTrunc(dst, sizeof(dst), "12"));
466 EXPECT_STREQ(dst, "12");
467 }
468
469 {
470 UninitializedBuf<3> dst;
471 ASSERT_EQ(2u, SprintfTrunc(dst, sizeof(dst), "123"));
472 EXPECT_STREQ(dst, "12");
473 }
474
475 {
476 UninitializedBuf<3> dst;
477 ASSERT_EQ(2u, SprintfTrunc(dst, sizeof(dst), "1234"));
478 EXPECT_STREQ(dst, "12");
479 }
480
481 {
482 UninitializedBuf<11> dst;
483 ASSERT_EQ(10u, SprintfTrunc(dst, sizeof(dst), "a %d b %s", 42, "foo"));
484 EXPECT_STREQ(dst, "a 42 b foo");
485 }
486 }
487
TEST(StringUtilsTest,StackString)488 TEST(StringUtilsTest, StackString) {
489 {
490 StackString<1> s("123");
491 EXPECT_EQ(0u, s.len());
492 EXPECT_STREQ("", s.c_str());
493 }
494
495 {
496 StackString<4> s("123");
497 EXPECT_EQ(3u, s.len());
498 EXPECT_STREQ("123", s.c_str());
499 EXPECT_EQ(s.ToStdString(), std::string(s.c_str()));
500 EXPECT_EQ(s.string_view().ToStdString(), s.ToStdString());
501 }
502
503 {
504 StackString<3> s("123");
505 EXPECT_EQ(2u, s.len());
506 EXPECT_STREQ("12", s.c_str());
507 EXPECT_EQ(s.ToStdString(), std::string(s.c_str()));
508 EXPECT_EQ(s.string_view().ToStdString(), s.ToStdString());
509 }
510
511 {
512 StackString<11> s("foo %d %s", 42, "bar!!!OVERFLOW");
513 EXPECT_EQ(10u, s.len());
514 EXPECT_STREQ("foo 42 bar", s.c_str());
515 EXPECT_EQ(s.ToStdString(), std::string(s.c_str()));
516 EXPECT_EQ(s.string_view().ToStdString(), s.ToStdString());
517 }
518 }
519
TEST(FindLineTest,InvalidOffset1)520 TEST(FindLineTest, InvalidOffset1) {
521 std::string str = "abc\ndef\n\nghi";
522 uint32_t offset = 3;
523
524 auto error = FindLineWithOffset(base::StringView(str), offset);
525
526 EXPECT_FALSE(error.has_value());
527 }
528
TEST(FindLineTest,InvalidOffset2)529 TEST(FindLineTest, InvalidOffset2) {
530 std::string str = "abc\ndef\n\nghi";
531 uint32_t offset = 8;
532
533 auto error = FindLineWithOffset(base::StringView(str), offset);
534
535 EXPECT_FALSE(error.has_value());
536 }
537
TEST(FindLineTest,FirstCharacter)538 TEST(FindLineTest, FirstCharacter) {
539 std::string str = "abc\ndef\n\nghi";
540 uint32_t offset = 0;
541
542 auto error = FindLineWithOffset(base::StringView(str), offset);
543
544 EXPECT_TRUE(error.has_value());
545 ASSERT_EQ(error.value().line_num, 1ul);
546 ASSERT_EQ(error.value().line_offset, 0ul);
547 ASSERT_EQ(error.value().line, "abc");
548 }
549
TEST(FindLineTest,StandardCheck)550 TEST(FindLineTest, StandardCheck) {
551 std::string str = "abc\ndef\n\nghi";
552 uint32_t offset = 5;
553
554 auto error = FindLineWithOffset(base::StringView(str), offset);
555
556 EXPECT_TRUE(error.has_value());
557 ASSERT_EQ(error.value().line_num, 2ul);
558 ASSERT_EQ(error.value().line_offset, 1ul);
559 ASSERT_EQ(error.value().line, "def");
560 }
561
TEST(FindLineTest,TwoBreakLines)562 TEST(FindLineTest, TwoBreakLines) {
563 std::string str = "abc\ndef\n\nghi";
564 uint32_t offset = 10;
565
566 auto error = FindLineWithOffset(base::StringView(str), offset);
567
568 EXPECT_TRUE(error.has_value());
569 ASSERT_EQ(error.value().line_num, 4ul);
570 ASSERT_EQ(error.value().line_offset, 1ul);
571 ASSERT_EQ(error.value().line, "ghi");
572 }
573
TEST(FindLineTest,EndsWithBreakLine)574 TEST(FindLineTest, EndsWithBreakLine) {
575 std::string str = "abc\ndef\n\nghi\n";
576 uint32_t offset = 10;
577
578 auto error = FindLineWithOffset(base::StringView(str), offset);
579
580 EXPECT_TRUE(error.has_value());
581 ASSERT_EQ(error.value().line_num, 4ul);
582 ASSERT_EQ(error.value().line_offset, 1ul);
583 ASSERT_EQ(error.value().line, "ghi");
584 }
585
586 } // namespace
587 } // namespace base
588 } // namespace perfetto
589