1 /*
2 * Copyright (c) 2021 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 <gtest/gtest.h>
17 #include "string_ex.h"
18 #include <iostream>
19 #include <securec.h>
20
21 using namespace testing::ext;
22 using namespace std;
23
24 namespace OHOS {
25 namespace {
26 class UtilsStringTest : public testing::Test
27 {
28 public :
29 static void SetUpTestCase(void);
30 static void TearDownTestCase(void);
31 void SetUp();
32 void TearDown();
33 };
34
SetUpTestCase(void)35 void UtilsStringTest::SetUpTestCase(void)
36 {
37 }
38
TearDownTestCase(void)39 void UtilsStringTest::TearDownTestCase(void)
40 {
41 }
42
SetUp(void)43 void UtilsStringTest::SetUp(void)
44 {
45 }
46
TearDown(void)47 void UtilsStringTest::TearDown(void)
48 {
49 }
50
51 /*
52 * Feature: string_ex
53 * Function: UpperStr
54 * SubFunction: NA
55 * FunctionPoints:
56 * EnvConditions: NA
57 * CaseDescription: test for convert all letters of str to uppercase
58 */
59 HWTEST_F(UtilsStringTest, test_strupper_01, TestSize.Level0)
60 {
61 string strBase = "strbase";
62 string strTemp = "STRBASE";
63 string result = UpperStr(strBase);
64 EXPECT_EQ(result, strTemp);
65
66 strBase = "StrBase";
67 result = UpperStr(strBase);
68 EXPECT_EQ(result, strTemp);
69 }
70
71 HWTEST_F(UtilsStringTest, test_strupper_02, TestSize.Level0)
72 {
73 string strBase = "";
74 string strTemp = "";
75 string result = UpperStr(strBase);
76 EXPECT_EQ(result, strTemp);
77 }
78
79 /*
80 * Feature: string_ex
81 * Function: LowerStr
82 * SubFunction: NA
83 * FunctionPoints:
84 * EnvConditions: NA
85 * CaseDescription: test for convert all letters of str to lowercase
86 */
87 HWTEST_F(UtilsStringTest, test_strlower_01, TestSize.Level0)
88 {
89 string strBase = "STRbase";
90 string strTemp = "strbase";
91 string result = LowerStr(strBase);
92 EXPECT_EQ(result, strTemp);
93
94 strBase = "StrBase";
95 result = LowerStr(strBase);
96 EXPECT_EQ(result, strTemp);
97 }
98
99 HWTEST_F(UtilsStringTest, test_strlower_02, TestSize.Level0)
100 {
101 string strBase = "";
102 string strTemp = "";
103 string result = LowerStr(strBase);
104 EXPECT_EQ(result, strTemp);
105 }
106
107 /*
108 * Feature: string_ex
109 * Function: ReplaceStr
110 * SubFunction: NA
111 * FunctionPoints:
112 * EnvConditions: NA
113 * CaseDescription: test for replace src with dst int strBase
114 */
115 HWTEST_F(UtilsStringTest, test_strreplace_01, TestSize.Level0)
116 {
117 string strBase = "test for replace";
118 string src = "for";
119 string dst = "with";
120 string strTemp = "test with replace";
121 string result = ReplaceStr(strBase, src, dst);
122 EXPECT_EQ(result, strTemp);
123
124 src = "test for replace";
125 dst = "test";
126 strTemp = "test";
127 result = ReplaceStr(strBase, src, dst);
128 EXPECT_EQ(result, strTemp);
129
130 src = "";
131 dst = "test";
132 result = ReplaceStr(strBase, src, dst);
133 EXPECT_EQ(result, strBase);
134
135 src = "for";
136 dst = "";
137 strTemp = "test replace";
138 result = ReplaceStr(strBase, src, dst);
139 EXPECT_EQ(result, strTemp);
140 }
141
142 /*
143 * Feature: string_ex
144 * Function: TrimStr
145 * SubFunction: NA
146 * FunctionPoints:
147 * EnvConditions: NA
148 * CaseDescription: test for trim str front and end
149 */
150 HWTEST_F(UtilsStringTest, test_strtrim_01, TestSize.Level0)
151 {
152 string strBase = " test for trim ";
153 string strTemp = "test for trim";
154 string result = TrimStr(strBase);
155 EXPECT_EQ(result, strTemp);
156 }
157
158 HWTEST_F(UtilsStringTest, test_strtrim_02, TestSize.Level0)
159 {
160 string strBase = "test";
161 string strTemp = "es";
162 string result = TrimStr(strBase, 't');
163 EXPECT_EQ(result, strTemp);
164 }
165
166 /*
167 * Feature: string_ex
168 * Function: SplitStr
169 * SubFunction: NA
170 * FunctionPoints:
171 * EnvConditions: NA
172 * CaseDescription: test for split str by strSep
173 */
174 HWTEST_F(UtilsStringTest, test_strsplit_01, TestSize.Level0)
175 {
176 string strBase = "test for split";
177 string strSep = " ";
178 string splitResult[3] = { "test", "for", "split" };
179 vector<string> strsRet;
180 SplitStr(strBase, strSep, strsRet);
181
182 for (int i = 0; i < 3; i++)
183 {
184 EXPECT_EQ(splitResult[i], strsRet[i]);
185 }
186 }
187
188 HWTEST_F(UtilsStringTest, test_strsplit_02, TestSize.Level0)
189 {
190 string strBase = "test for split";
191 string strSep = "for";
192 string splitResult[2] = { "test", "split" };
193 vector<string> strsRet;
194 SplitStr(strBase, strSep, strsRet);
195
196 for (int i = 0; i < 2; i++)
197 {
198 EXPECT_EQ(splitResult[i], strsRet[i]);
199 }
200
201 splitResult[0] = "test ";
202 splitResult[1] = " split";
203 SplitStr(strBase, strSep, strsRet, false, false);
204 for (int i = 0; i < 2; i++)
205 {
206 EXPECT_EQ(splitResult[i], strsRet[i]);
207 }
208 }
209
210 HWTEST_F(UtilsStringTest, test_strsplit_03, TestSize.Level0)
211 {
212 string strBase = "test for for split";
213 string strSep = "for";
214 string splitResult[3] = { "test", "", "split" };
215 vector<string> strsRet;
216 SplitStr(strBase, strSep, strsRet, true);
217 for (int i = 0; i < (int)strsRet.size(); i++)
218 {
219 EXPECT_EQ(splitResult[i], strsRet[i]);
220 }
221 }
222
223 /*
224 * Feature: string_ex
225 * Function: SplitStr
226 * SubFunction: NA
227 * FunctionPoints:
228 * EnvConditions: NA
229 * CaseDescription: test splitting a null string with a null seperator
230 */
231 HWTEST_F(UtilsStringTest, test_strsplit_04, TestSize.Level0)
232 {
233 string strBase = "";
234 string strSep = "";
235 vector<string> strsRet1;
236 SplitStr(strBase, strSep, strsRet1);
237 EXPECT_EQ(strsRet1.size(), 0);
238 vector<string> strsRet2;
239 SplitStr(strBase, strSep, strsRet2, true);
240 EXPECT_EQ(strsRet2[0], "");
241 }
242
243 /*
244 * Feature: string_ex
245 * Function: IsNumericStr
246 * SubFunction: NA
247 * FunctionPoints:
248 * EnvConditions: NA
249 * CaseDescription: test for judge all characters of the string are numbers
250 */
251 HWTEST_F(UtilsStringTest, test_strisnumeric_01, TestSize.Level0)
252 {
253 string strBase = "1234556";
254 bool result = IsNumericStr(strBase);
255 EXPECT_EQ(result, true);
256
257 strBase = "1234,a";
258 result = IsNumericStr(strBase);
259 EXPECT_EQ(result, false);
260
261 strBase = "";
262 result = IsNumericStr(strBase);
263 EXPECT_EQ(result, false);
264 }
265
266 /*
267 * Feature: string_ex
268 * Function: IsAlphaStr
269 * SubFunction: NA
270 * FunctionPoints:
271 * EnvConditions: NA
272 * CaseDescription: test for judge all characters of the string are alphabet
273 */
274 HWTEST_F(UtilsStringTest, test_strisalpha_01, TestSize.Level0)
275 {
276 string strBase = "1234556";
277 bool result = IsAlphaStr(strBase);
278 EXPECT_EQ(result, false);
279
280 strBase = "Acedafe";
281 result = IsAlphaStr(strBase);
282 EXPECT_EQ(result, true);
283
284 strBase = "Acedafe ";
285 result = IsAlphaStr(strBase);
286 EXPECT_EQ(result, false);
287
288 strBase = "Acedafe3";
289 result = IsAlphaStr(strBase);
290 EXPECT_EQ(result, false);
291
292 strBase = "";
293 result = IsAlphaStr(strBase);
294 EXPECT_EQ(result, false);
295 }
296
297 /*
298 * Feature: string_ex
299 * Function: IsUpperStr
300 * SubFunction: NA
301 * FunctionPoints:
302 * EnvConditions: NA
303 * CaseDescription: test for judge all characters of the string are uppercase
304 */
305 HWTEST_F(UtilsStringTest, test_IsUpperStr_01, TestSize.Level0)
306 {
307 string strBase = "ABSEFAD";
308 bool result = IsUpperStr(strBase);
309 EXPECT_EQ(result, true);
310
311 strBase = "Afaefadf";
312 result = IsUpperStr(strBase);
313 EXPECT_EQ(result, false);
314
315 strBase = "12e13eaefd ";
316 result = IsUpperStr(strBase);
317 EXPECT_EQ(result, false);
318
319 strBase = "";
320 result = IsUpperStr(strBase);
321 EXPECT_EQ(result, false);
322 }
323
324 /*
325 * Feature: string_ex
326 * Function: IsLowerStr
327 * SubFunction: NA
328 * FunctionPoints:
329 * EnvConditions: NA
330 * CaseDescription: test for judge all characters of the string are lowercase
331 */
332 HWTEST_F(UtilsStringTest, test_IsLowerStr_01, TestSize.Level0)
333 {
334 string strBase = "testlower";
335 bool result = IsLowerStr(strBase);
336 EXPECT_EQ(result, true);
337
338 strBase = "AAFDeadfkl";
339 result = IsLowerStr(strBase);
340 EXPECT_EQ(result, false);
341
342 strBase = "12e";
343 result = IsLowerStr(strBase);
344 EXPECT_EQ(result, false);
345
346 strBase = "";
347 result = IsLowerStr(strBase);
348 EXPECT_EQ(result, false);
349 }
350
351 /*
352 * Feature: string_ex
353 * Function: IsSubStr
354 * SubFunction: NA
355 * FunctionPoints:
356 * EnvConditions: NA
357 * CaseDescription: test for judge the sub_str in base_str
358 */
359 HWTEST_F(UtilsStringTest, test_IsSubStr_01, TestSize.Level0)
360 {
361 string strBase = "test for issubstr";
362 string strSub = "for";
363 bool result = IsSubStr(strBase, strSub);
364 EXPECT_EQ(result, true);
365
366 strBase = "";
367 strSub = "";
368 result = IsSubStr(strBase, strSub);
369 EXPECT_EQ(result, false);
370
371 strSub = "fori";
372 result = IsSubStr(strBase, strSub);
373 EXPECT_EQ(result, false);
374 }
375
376 /*
377 * Feature: string_ex
378 * Function: IsSameTextStr
379 * SubFunction: NA
380 * FunctionPoints:
381 * EnvConditions: NA
382 * CaseDescription: test for judge the strFirst's letter is same with strSecond
383 */
384 HWTEST_F(UtilsStringTest, test_IsSameTextStr_01, TestSize.Level0)
385 {
386 string strFirst = "Test For StrSameText";
387 string strSecond = "test for strsametext";
388 bool result = IsSameTextStr(strFirst, strSecond);
389 EXPECT_EQ(result, true);
390
391 strSecond = "test for strsametex";
392 result = IsSameTextStr(strFirst, strSecond);
393 EXPECT_EQ(result, false);
394 }
395
396 /*
397 * Feature: string_ex
398 * Function: ToString
399 * SubFunction: NA
400 * FunctionPoints:
401 * EnvConditions: NA
402 * CaseDescription: test for convert int to str
403 */
404 HWTEST_F(UtilsStringTest, test_ToString_01, TestSize.Level0)
405 {
406 int ivalue = 12345;
407 string strValue = "12345";
408 string result = ToString(ivalue);
409 EXPECT_EQ(result, strValue);
410
411 ivalue = -15;
412 result = ToString(ivalue);
413 EXPECT_EQ(result, "-15");
414 }
415
416 /*
417 * Feature: string_ex
418 * Function: StrToInt
419 * SubFunction: NA
420 * FunctionPoints:
421 * EnvConditions: NA
422 * CaseDescription: test for convert str to int
423 */
424 HWTEST_F(UtilsStringTest, test_StrToInt_01, TestSize.Level0)
425 {
426 string strValue = "12345";
427 int iValue = 0;
428 bool result = StrToInt(strValue, iValue);
429 EXPECT_EQ(result, true);
430 EXPECT_EQ(iValue, 12345);
431
432 strValue = "123r54";
433 result = StrToInt(strValue, iValue);
434 EXPECT_EQ(result, false);
435 }
436
437 HWTEST_F(UtilsStringTest, test_StrToInt_02, TestSize.Level0)
438 {
439 string strValue = "-12345";
440 int iValue = 0;
441 bool result = StrToInt(strValue, iValue);
442 EXPECT_EQ(result, true);
443 EXPECT_EQ(iValue, -12345);
444
445 strValue = "123= 54";
446 result = StrToInt(strValue, iValue);
447 EXPECT_EQ(result, false);
448
449 string strvalue2;
450 result = StrToInt(strvalue2, iValue);
451 EXPECT_EQ(result, false);
452 }
453
454 HWTEST_F(UtilsStringTest, test_StrToInt_03, TestSize.Level0)
455 {
456 string strValue = "2147483648";
457 int ivalue = 0;
458 bool result = StrToInt(strValue, ivalue);
459 EXPECT_EQ(result, false);
460 }
461
462 HWTEST_F(UtilsStringTest, test_StrToInt_04, TestSize.Level0)
463 {
464 string strValue = " ";
465 int iValue = 0;
466 bool result = StrToInt(strValue, iValue);
467 EXPECT_EQ(result, false);
468 }
469
470 HWTEST_F(UtilsStringTest, test_strcovertfailed_01, TestSize.Level0)
471 {
472 char test[] = {192, 157, 47, 106, 97, 18, 97, 47, 115, 1, 2};
473 string strValue(test);
474
475 bool ret = IsAsciiString(strValue);
476 EXPECT_EQ(ret, false);
477
478 strValue = "1234";
479 ret = IsAsciiString(strValue);
480 EXPECT_EQ(ret, true);
481
482 strValue = "abcde";
483 ret = IsAsciiString(strValue);
484 EXPECT_EQ(ret, true);
485 }
486
487
488 HWTEST_F(UtilsStringTest, test_strcovert_01, TestSize.Level0)
489 {
490 string strValue = "hello world!";
491 u16string str16 = Str8ToStr16(strValue);
492 EXPECT_EQ(0, strValue.compare(Str16ToStr8(str16)));
493 }
494
495 HWTEST_F(UtilsStringTest, test_strcovert_02, TestSize.Level0)
496 {
497 string str8Value = "hello world!";
498 u16string str16Result = u"hello world!";
499 u16string str16Value = Str8ToStr16(str8Value);
500 EXPECT_EQ(0, str16Result.compare(str16Value));
501
502 str16Result = u"你好";
503 string str8Result = Str16ToStr8(str16Result);
504 str16Value = Str8ToStr16(str8Result);
505 EXPECT_EQ(0, str16Result.compare(str16Value));
506
507
508 str16Result = u"某某技术有限公司";
509 str8Result = Str16ToStr8(str16Result);
510 str16Value = Str8ToStr16(str8Result);
511 EXPECT_EQ(0, str16Result.compare(str16Value));
512 }
513
514 HWTEST_F(UtilsStringTest, test_strcovert_03, TestSize.Level0)
515 {
516 string str8Value = "1234567890!@#$%^&*().";
517 u16string str16Result = u"1234567890!@#$%^&*().";
518 u16string str16Value = Str8ToStr16(str8Value);
519 EXPECT_EQ(0, str16Result.compare(str16Value));
520
521 string str8Result = Str16ToStr8(str16Value);
522 EXPECT_EQ(0, str8Result.compare(str8Value));
523 }
524
525 HWTEST_F(UtilsStringTest, test_strcovert_04, TestSize.Level0)
526 {
527 string str8Value = "1234567890!@#$%^&*().qazxswedcvfr,./;'][";
528 u16string str16Result = u"1234567890!@#$%^&*().qazxswedcvfr,./;'][";
529 u16string str16Value = Str8ToStr16(str8Value);
530 EXPECT_EQ(0, str16Result.compare(str16Value));
531
532 string str8Result = Str16ToStr8(str16Value);
533 EXPECT_EQ(0, str8Result.compare(str8Value));
534 }
535
536 HWTEST_F(UtilsStringTest, test_getintstrcovert_01, TestSize.Level0)
537 {
538 u16string str16Value = u"你好";
539 string str8Result = Str16ToStr8(str16Value);
540 int str8Length = str8Result.length();
541 int bufferLen = 255;
542 char buffer[bufferLen];
543 memset_s(buffer, sizeof(buffer), 0, sizeof(buffer));
544 int int8Result = Char16ToChar8(str16Value, buffer, bufferLen);
545
546 EXPECT_EQ(0, str8Result.compare(buffer));
547 EXPECT_EQ(str8Length + 1, int8Result);
548 }
549
550 HWTEST_F(UtilsStringTest, test_getintstrcovert_02, TestSize.Level0)
551 {
552 u16string str16Value = u"某某技术有限公司";
553 string str8Result = Str16ToStr8(str16Value);
554 int str8Length = str8Result.length();
555 int bufferLen = 255;
556 char buffer[bufferLen];
557 memset_s(buffer, sizeof(buffer), 0, sizeof(buffer));
558 int int8Result = Char16ToChar8(str16Value, buffer, bufferLen);
559
560 EXPECT_EQ(0, str8Result.compare(buffer));
561 EXPECT_EQ(str8Length + 1, int8Result);
562 }
563
564 HWTEST_F(UtilsStringTest, test_getintstrcovert_03, TestSize.Level0)
565 {
566 u16string str16Value = u"hello world!";
567 string str8Result = Str16ToStr8(str16Value);
568 int str8Length = str8Result.length();
569 int bufferLen = 255;
570 char buffer[bufferLen];
571 memset_s(buffer, sizeof(buffer), 0, sizeof(buffer));
572 int int8Result = Char16ToChar8(str16Value, buffer, bufferLen);
573
574 EXPECT_EQ(0, str8Result.compare(buffer));
575 EXPECT_EQ(str8Length + 1, int8Result);
576 }
577
578 HWTEST_F(UtilsStringTest, test_getintstrcovert_04, TestSize.Level0)
579 {
580 u16string str16Value = u"1234567890!@#$%^&*().";
581 string str8Result = Str16ToStr8(str16Value);
582 int str8Length = str8Result.length();
583 int bufferLen = 255;
584 char buffer[bufferLen];
585 memset_s(buffer, sizeof(buffer), 0, sizeof(buffer));
586 int int8Result = Char16ToChar8(str16Value, buffer, bufferLen);
587
588 EXPECT_EQ(0, str8Result.compare(buffer));
589 EXPECT_EQ(str8Length + 1, int8Result);
590 }
591
592 HWTEST_F(UtilsStringTest, test_getsubstr_01, TestSize.Level0)
593 {
594 string strBase = "test for {sub str} {sub str1}";
595 string left = "{";
596 string right = "}";
597 string strResult = "sub str";
598 string strValue;
599 string::size_type pos = GetFirstSubStrBetween(strBase, left, right, strValue);
600 EXPECT_EQ(17, (int)pos);
601 EXPECT_EQ(strResult, strValue);
602
603 strBase = "test for sub str} {sub str1}";
604 strResult = "sub str1";
605 pos = GetFirstSubStrBetween(strBase, left, right, strValue);
606 EXPECT_EQ(27, (int)pos);
607 EXPECT_EQ(strResult, strValue);
608 }
609
610 HWTEST_F(UtilsStringTest, test_getsubstr_02, TestSize.Level0)
611 {
612 string strBase = "test for} {sub str {sub str1";
613 string left = "{";
614 string right = "}";
615 string strValue;
616 string::size_type pos = GetFirstSubStrBetween(strBase, left, right, strValue);
617 EXPECT_EQ(pos, string::npos);
618 }
619
620
621 HWTEST_F(UtilsStringTest, test_getsubstr_03, TestSize.Level0)
622 {
623 string strBase = "test for {sub str} {sub str1}";
624 string left = "{";
625 string right = "}";
626 string strResult[2] = { "sub str", "sub str1" };
627 vector<string> strValue;
628 GetSubStrBetween(strBase, left, right, strValue);
629 for (int i = 0; i < 2; i++) {
630 EXPECT_EQ(strResult[i], strValue[i]);
631 }
632 }
633
634 HWTEST_F(UtilsStringTest, test_getsubstr_04, TestSize.Level0)
635 {
636 string strBase = "test for } {sub str {sub str1";
637 string left = "{";
638 string right = "}";
639 string strResult[2] = { "sub str", "sub str1" };
640 vector<string> strValue;
641 GetSubStrBetween(strBase, left, right, strValue);
642 EXPECT_EQ(0, static_cast<int>(strValue.size()));
643 }
644
645 HWTEST_F(UtilsStringTest, DexToHexString_01, TestSize.Level0)
646 {
647 string result = DexToHexString(0);
648 EXPECT_EQ(result, "0");
649
650 result = DexToHexString(14);
651 EXPECT_EQ(result, "E");
652
653 result = DexToHexString(14, false);
654 EXPECT_EQ(result, "e");
655
656 result = DexToHexString(-14, false);
657 EXPECT_EQ(result, "fffffff2");
658
659 result = DexToHexString(-14);
660 EXPECT_EQ(result, "FFFFFFF2");
661
662 result = DexToHexString(11259375);
663 EXPECT_EQ(result, "ABCDEF");
664
665 result = DexToHexString(11259375, false);
666 EXPECT_EQ(result, "abcdef");
667 }
668 } // namespace
669 } // namespace OHOS