1 /*
2 * Copyright (c) 2025 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "common_components/base/c_string.h"
17 #include "common_components/tests/test_helper.h"
18
19 using namespace common;
20 namespace common::test {
21 class CStringTest : public common::test::BaseTestWithScope {
22 };
23
HWTEST_F_L0(CStringTest,ParseTimeFromEnvTest)24 HWTEST_F_L0(CStringTest, ParseTimeFromEnvTest)
25 {
26 CString env;
27
28 env = "s";
29 EXPECT_EQ(CString::ParseTimeFromEnv(env), static_cast<size_t>(0));
30
31 env = "5s";
32 EXPECT_EQ(CString::ParseTimeFromEnv(env), static_cast<size_t>(5 * 1000UL * 1000 * 1000));
33
34 env = "10ns";
35 EXPECT_EQ(CString::ParseTimeFromEnv(env), static_cast<size_t>(10));
36
37 env = "20us";
38 EXPECT_EQ(CString::ParseTimeFromEnv(env), static_cast<size_t>(20 * 1000));
39
40 env = "30ms";
41 EXPECT_EQ(CString::ParseTimeFromEnv(env), static_cast<size_t>(30 * 1000 * 1000));
42
43 env = "40xyz";
44 EXPECT_EQ(CString::ParseTimeFromEnv(env), static_cast<size_t>(0));
45
46 env = "abcms";
47 EXPECT_EQ(CString::ParseTimeFromEnv(env), static_cast<size_t>(0));
48 }
49
HWTEST_F_L0(CStringTest,ParseNumFromEnvTest)50 HWTEST_F_L0(CStringTest, ParseNumFromEnvTest)
51 {
52 CString env;
53
54 env = "123 456";
55 EXPECT_EQ(CString::ParseNumFromEnv(env), 123456);
56
57 env = "-123";
58 EXPECT_EQ(CString::ParseNumFromEnv(env), -123);
59
60 env = "abc";
61 EXPECT_EQ(CString::ParseNumFromEnv(env), 0);
62
63 env = "";
64 EXPECT_EQ(CString::ParseNumFromEnv(env), 0);
65
66 env = "+123";
67 EXPECT_EQ(CString::ParseNumFromEnv(env), 0);
68 }
69
HWTEST_F_L0(CStringTest,ParsePosNumFromEnvTest)70 HWTEST_F_L0(CStringTest, ParsePosNumFromEnvTest)
71 {
72 CString env;
73
74 env = "123";
75 EXPECT_EQ(CString::ParsePosNumFromEnv(env), static_cast<size_t>(123));
76
77 env = "+456";
78 EXPECT_EQ(CString::ParsePosNumFromEnv(env), static_cast<size_t>(456));
79
80 env = "";
81 EXPECT_EQ(CString::ParsePosNumFromEnv(env), static_cast<size_t>(0));
82
83 env = "0";
84 EXPECT_EQ(CString::ParsePosNumFromEnv(env), static_cast<size_t>(0));
85
86 env = "12a3";
87 EXPECT_EQ(CString::ParsePosNumFromEnv(env), static_cast<size_t>(0));
88
89 env = "-123";
90 EXPECT_EQ(CString::ParsePosNumFromEnv(env), static_cast<size_t>(0));
91 }
92
HWTEST_F_L0(CStringTest,ParsePosDecFromEnvTest)93 HWTEST_F_L0(CStringTest, ParsePosDecFromEnvTest)
94 {
95 CString env;
96
97 env = "123.45";
98 EXPECT_EQ(CString::ParsePosDecFromEnv(env), 123.45);
99
100 env = "+456.78";
101 EXPECT_EQ(CString::ParsePosDecFromEnv(env), 456.78);
102
103 env = "";
104 EXPECT_EQ(CString::ParsePosDecFromEnv(env), 0.0);
105
106 env = "0";
107 EXPECT_EQ(CString::ParsePosDecFromEnv(env), 0.0);
108
109 env = "12.3.4";
110 EXPECT_EQ(CString::ParsePosDecFromEnv(env), 0.0);
111
112 env = "-123.45";
113 EXPECT_EQ(CString::ParsePosDecFromEnv(env), 0.0);
114 }
115
HWTEST_F_L0(CStringTest,WhileLoopCoverageTest)116 HWTEST_F_L0(CStringTest, WhileLoopCoverageTest)
117 {
118 CString str = "hello world hello panda";
119 CString target = "hello";
120 CString replacement = "hi";
121 str.ReplaceAll(replacement, target);
122 EXPECT_STREQ(str.Str(), "hillo world hillo panda");
123
124 CString str1 = "hello world";
125 CString target1 = "notfound";
126 CString replacement1 = "replace";
127 str1.ReplaceAll(replacement1, target1);
128 EXPECT_STREQ(str1.Str(), "hello world");
129 }
130
HWTEST_F_L0(CStringTest,RemoveBlankSpaceTest)131 HWTEST_F_L0(CStringTest, RemoveBlankSpaceTest)
132 {
133 CString emptyStr = "";
134 CString result1 = emptyStr.RemoveBlankSpace();
135 EXPECT_STREQ(result1.Str(), "");
136
137 CString noSpaceStr = "HelloWorld";
138 CString result2 = noSpaceStr.RemoveBlankSpace();
139 EXPECT_STREQ(result2.Str(), "HelloWorld");
140
141 CString withSpaceStr = "This is a test string";
142 CString result3 = withSpaceStr.RemoveBlankSpace();
143 EXPECT_STREQ(result3.Str(), "Thisisateststring");
144
145 CString allSpaceStr = " ";
146 CString result4 = allSpaceStr.RemoveBlankSpace();
147 EXPECT_STREQ(result4.Str(), "");
148 }
149
HWTEST_F_L0(CStringTest,ParseSizeFromEnvTest)150 HWTEST_F_L0(CStringTest, ParseSizeFromEnvTest)
151 {
152 EXPECT_EQ(CString::ParseSizeFromEnv("1"), static_cast<size_t>(0));
153 EXPECT_EQ(CString::ParseSizeFromEnv("abcgb"), static_cast<size_t>(0));
154 EXPECT_EQ(CString::ParseSizeFromEnv("1024kb"), static_cast<size_t>(1024));
155 EXPECT_EQ(CString::ParseSizeFromEnv("5mb"), static_cast<size_t>(5 * 1024));
156 EXPECT_EQ(CString::ParseSizeFromEnv("2GB"), static_cast<size_t>(2 * 1024 * 1024));
157 EXPECT_EQ(CString::ParseSizeFromEnv("10tb"), static_cast<size_t>(0));
158 }
159
HWTEST_F_L0(CStringTest,IsPosDecimalTest)160 HWTEST_F_L0(CStringTest, IsPosDecimalTest)
161 {
162 EXPECT_FALSE(CString::IsPosDecimal(""));
163 EXPECT_FALSE(CString::IsPosDecimal("+"));
164 EXPECT_FALSE(CString::IsPosDecimal("0"));
165 EXPECT_FALSE(CString::IsPosDecimal("abc"));
166 EXPECT_FALSE(CString::IsPosDecimal("-1.5"));
167 EXPECT_FALSE(CString::IsPosDecimal("0"));
168 EXPECT_TRUE(CString::IsPosDecimal("123.45"));
169 }
170
HWTEST_F_L0(CStringTest,IsNumberTest)171 HWTEST_F_L0(CStringTest, IsNumberTest)
172 {
173 EXPECT_FALSE(CString::IsNumber(""));
174 EXPECT_FALSE(CString::IsNumber("abc"));
175 EXPECT_FALSE(CString::IsNumber("12a3"));
176
177 EXPECT_TRUE(CString::IsNumber("123"));
178 EXPECT_TRUE(CString::IsNumber("-456"));
179 }
180
HWTEST_F_L0(CStringTest,IsPosNumberTest)181 HWTEST_F_L0(CStringTest, IsPosNumberTest)
182 {
183 EXPECT_FALSE(CString::IsPosNumber(""));
184 EXPECT_FALSE(CString::IsPosNumber("+"));
185 EXPECT_FALSE(CString::IsPosNumber("0"));
186 EXPECT_FALSE(CString::IsPosNumber("abc"));
187 EXPECT_FALSE(CString::IsPosNumber("-123"));
188
189 EXPECT_TRUE(CString::IsPosNumber("123"));
190 EXPECT_TRUE(CString::IsPosNumber("+123"));
191 }
192
HWTEST_F_L0(CStringTest,SubStrTest)193 HWTEST_F_L0(CStringTest, SubStrTest)
194 {
195 CString str("abcdef");
196 EXPECT_EQ(std::string(str.SubStr(2, 3).Str()), "cde");
197 EXPECT_EQ(std::string(str.SubStr(2, 0).Str()), "");
198 EXPECT_EQ(std::string(str.SubStr(4, 3).Str()), "");
199 EXPECT_EQ(std::string(str.SubStr(10).Str()), "");
200 EXPECT_EQ(std::string(str.SubStr(2).Str()), "cdef");
201 }
202
HWTEST_F_L0(CStringTest,SplitTest)203 HWTEST_F_L0(CStringTest, SplitTest)
204 {
205 CString emptySource("");
206 auto tokens = CString::Split(emptySource, ',');
207 EXPECT_TRUE(tokens.empty());
208
209 CString normalSource("a,b,c");
210 tokens = CString::Split(normalSource, ',');
211 ASSERT_EQ(tokens.size(), static_cast<size_t>(3));
212 EXPECT_EQ(std::string(tokens[0].Str()), "a");
213 EXPECT_EQ(std::string(tokens[1].Str()), "b");
214 EXPECT_EQ(std::string(tokens[2].Str()), "c");
215 }
216
HWTEST_F_L0(CStringTest,FIndandRfindTest)217 HWTEST_F_L0(CStringTest, FIndandRfindTest)
218 {
219 CString str("hello world");
220
221 EXPECT_EQ(str.Find("hello", 20), -1);
222 EXPECT_EQ(str.Find("world", 6), 6);
223
224 EXPECT_EQ(str.Find('h', 20), -1);
225 EXPECT_EQ(str.Find('o', 4), 4);
226
227 EXPECT_EQ(str.RFind("xyz"), -1);
228 CString multiStr("abababa");
229 EXPECT_EQ(multiStr.RFind("aba"), 4);
230 }
231
HWTEST_F_L0(CStringTest,TruncateAndInsertTest)232 HWTEST_F_L0(CStringTest, TruncateAndInsertTest)
233 {
234 CString str("hello world");
235
236 EXPECT_EQ(&str.Truncate(20), &str);
237 EXPECT_EQ(&str.Insert(20, "abc"), &str);
238 EXPECT_EQ(&str.Insert(0, ""), &str);
239 }
240
HWTEST_F_L0(CStringTest,EnsureSpaceTest)241 HWTEST_F_L0(CStringTest, EnsureSpaceTest)
242 {
243 CString str("hello");
244
245 str.EnsureSpace(0);
246 EXPECT_EQ(str.Length(), static_cast<size_t>(5));
247 str.EnsureSpace(5);
248 EXPECT_EQ(str.Length(), static_cast<size_t>(5));
249 }
250
HWTEST_F_L0(CStringTest,ConstructTest)251 HWTEST_F_L0(CStringTest, ConstructTest)
252 {
253 CString str1(0, 'a');
254 EXPECT_EQ(str1.Length(), static_cast<size_t>(0));
255 EXPECT_EQ(str1.Str()[0], '\0');
256
257 CString str2(20, 'b');
258 EXPECT_EQ(str2.Length(), static_cast<size_t>(20));
259
260 CString src("test string");
261 CString dst;
262 dst = src;
263 EXPECT_STREQ(dst.Str(), "test string");
264 EXPECT_EQ(dst.Length(), strlen("test string"));
265
266 CString another("new content");
267 another = src;
268 EXPECT_STREQ(another.Str(), "test string");
269
270 CString emptyStr;
271 CString nonEmptyStr("abc");
272 nonEmptyStr = emptyStr;
273 EXPECT_EQ(nonEmptyStr.Length(), static_cast<size_t>(0));
274 EXPECT_EQ(nonEmptyStr.Str()[0], '\0');
275 }
276
HWTEST_F_L0(CStringTest,FormatStringBasicTest)277 HWTEST_F_L0(CStringTest, FormatStringBasicTest)
278 {
279 CString result = CString::FormatString("Hello, %s!", "World");
280 EXPECT_STREQ(result.Str(), "Hello, World!");
281 }
282
HWTEST_F_L0(CStringTest,FormatString_InvalidArguments_ReturnsError)283 HWTEST_F_L0(CStringTest, FormatString_InvalidArguments_ReturnsError)
284 {
285 CString result = CString::FormatString("%n", nullptr);
286 EXPECT_STREQ(result.Str(), "invalid arguments for FormatString");
287 }
288
HWTEST_F_L0(CStringTest,InsertMiddle_Success)289 HWTEST_F_L0(CStringTest, InsertMiddle_Success)
290 {
291 CString str("helloworld");
292 EXPECT_STREQ(str.Insert(5, ", ").Str(), "hello, world");
293 }
294
HWTEST_F_L0(CStringTest,TruncateValidIndex_Success)295 HWTEST_F_L0(CStringTest, TruncateValidIndex_Success)
296 {
297 CString str("hello world");
298 EXPECT_STREQ(str.Truncate(5).Str(), "hello");
299 EXPECT_EQ(str.Length(), static_cast<size_t>(5));
300 }
301
HWTEST_F_L0(CStringTest,GetStr_NonEmptyString_ReturnsCorrect)302 HWTEST_F_L0(CStringTest, GetStr_NonEmptyString_ReturnsCorrect)
303 {
304 CString str("test string");
305 EXPECT_STREQ(str.GetStr(), "test string");
306 }
307
HWTEST_F_L0(CStringTest,CombineWithEmptyString_ReturnsOriginal)308 HWTEST_F_L0(CStringTest, CombineWithEmptyString_ReturnsOriginal)
309 {
310 CString str("original");
311 CString emptyStr;
312 CString combined = str.Combine(emptyStr);
313 EXPECT_STREQ(combined.Str(), "original");
314 EXPECT_EQ(combined.Length(), str.Length());
315 }
316
HWTEST_F_L0(CStringTest,CombineWithEmptyCStr_ReturnsOriginal)317 HWTEST_F_L0(CStringTest, CombineWithEmptyCStr_ReturnsOriginal)
318 {
319 CString str("original");
320 const char* emptyCStr = "";
321 CString combined = str.Combine(emptyCStr);
322 EXPECT_STREQ(combined.Str(), "original");
323 EXPECT_EQ(combined.Length(), str.Length());
324 }
325
HWTEST_F_L0(CStringTest,AppendNullptr_NoChange)326 HWTEST_F_L0(CStringTest, AppendNullptr_NoChange)
327 {
328 CString str("original");
329 str.Append(nullptr, 5);
330 EXPECT_STREQ(str.Str(), "original");
331 EXPECT_EQ(str.Length(), strlen("original"));
332 }
333
HWTEST_F_L0(CStringTest,AppendZeroLength_NoChange)334 HWTEST_F_L0(CStringTest, AppendZeroLength_NoChange)
335 {
336 CString str("test");
337 CString emptyStr;
338
339 str.Append(emptyStr, 0);
340
341 EXPECT_STREQ(str.Str(), "test");
342 EXPECT_EQ(str.Length(), strlen("test"));
343 }
344
HWTEST_F_L0(CStringTest,AppendSelf_ValidResult)345 HWTEST_F_L0(CStringTest, AppendSelf_ValidResult)
346 {
347 CString str("abc");
348 str.Append(str.Str(), str.Length());
349 EXPECT_STREQ(str.Str(), "abcabc");
350 EXPECT_EQ(str.Length(), strlen("abcabc"));
351 }
352
HWTEST_F_L0(CStringTest,AppendEmptyCString_NoChange)353 HWTEST_F_L0(CStringTest, AppendEmptyCString_NoChange)
354 {
355 CString str("original");
356 CString emptyStr;
357 str.Append(emptyStr);
358 EXPECT_STREQ(str.Str(), "original");
359 EXPECT_EQ(str.Length(), strlen("original"));
360 }
361
HWTEST_F_L0(CStringTest,AppendEmptyCStringZeroLength_NoChange)362 HWTEST_F_L0(CStringTest, AppendEmptyCStringZeroLength_NoChange)
363 {
364 CString str("test");
365 CString emptyStr;
366
367 str.Append(emptyStr, 0);
368
369 EXPECT_STREQ(str.Str(), "test");
370 EXPECT_EQ(str.Length(), strlen("test"));
371 }
372
HWTEST_F_L0(CStringTest,AppendValidCString_CorrectResult)373 HWTEST_F_L0(CStringTest, AppendValidCString_CorrectResult)
374 {
375 CString str("hello");
376 CString addStr(" world!");
377 str.Append(addStr, strlen(addStr.Str()));
378 EXPECT_STREQ(str.Str(), "hello world!");
379 EXPECT_EQ(str.Length(), strlen("hello world!"));
380 }
381
HWTEST_F_L0(CStringTest,EnsureMultipleCalls_CapacityGrowsCorrectly)382 HWTEST_F_L0(CStringTest, EnsureMultipleCalls_CapacityGrowsCorrectly)
383 {
384 CString str("initial");
385 char* firstPtr = str.GetStr();
386
387 str.EnsureSpace(16);
388 char* secondPtr = str.GetStr();
389
390 EXPECT_NE(firstPtr, secondPtr);
391
392 str.EnsureSpace(100);
393 char* thirdPtr = str.GetStr();
394
395 EXPECT_NE(secondPtr, thirdPtr);
396 EXPECT_EQ(str.Length(), strlen("initial"));
397 EXPECT_STREQ(str.SubStr(0, str.Length()).Str(), "initial");
398 }
399
HWTEST_F_L0(CStringTest,CStringSubscriptOperatorTest)400 HWTEST_F_L0(CStringTest, CStringSubscriptOperatorTest)
401 {
402 const CString constStr("hello world");
403 EXPECT_EQ(constStr[0], 'h');
404
405 CString mutableStr("mutable");
406 mutableStr[0] = 'M';
407 EXPECT_EQ(mutableStr[0], 'M');
408 }
409 }