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