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