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
22using namespace testing::ext;
23using namespace std;
24
25namespace OHOS {
26namespace {
27class UtilsStringTest : public testing::Test
28{
29public :
30    static void SetUpTestCase(void);
31    static void TearDownTestCase(void);
32    void SetUp();
33    void TearDown();
34};
35
36void UtilsStringTest::SetUpTestCase(void)
37{
38}
39
40void UtilsStringTest::TearDownTestCase(void)
41{
42}
43
44void UtilsStringTest::SetUp(void)
45{
46}
47
48void 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*/
60HWTEST_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
72HWTEST_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*/
88HWTEST_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
100HWTEST_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*/
116HWTEST_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*/
151HWTEST_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
159HWTEST_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*/
175HWTEST_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
189HWTEST_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
211HWTEST_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*/
232HWTEST_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*/
252HWTEST_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*/
275HWTEST_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*/
306HWTEST_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*/
333HWTEST_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*/
360HWTEST_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*/
385HWTEST_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*/
405HWTEST_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*/
425HWTEST_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
438HWTEST_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
455HWTEST_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
463HWTEST_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
471HWTEST_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
489HWTEST_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
496HWTEST_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
515HWTEST_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
526HWTEST_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
537HWTEST_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
551HWTEST_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
565HWTEST_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
579HWTEST_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
593HWTEST_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
611HWTEST_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
622HWTEST_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
635HWTEST_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
646HWTEST_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
670HWTEST_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