1 /*
2  * Copyright (c) 2022-2024 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 
18 #include "netmanager_base_common_utils.h"
19 
20 namespace OHOS {
21 namespace NetManagerStandard {
22 namespace {
23 using namespace testing::ext;
24 constexpr const char *TEST_TEXT = "adfsjfjkfk^#$ajf!@!#$#kjd nck?fgnf<kdjnf>kjask?.fcnvdkjfn kjdkj.,.vd";
25 constexpr const char *SPLIT = "?";
26 constexpr const char *TEST_IP = "155.153.144.154";
27 constexpr const char *TEST_IPV4 = "534/6::45/144.15:4::44";
28 constexpr const char *TEST_DOMAIN1 = "123445";
29 constexpr const char *TEST_DOMAIN2 = ".com";
30 constexpr const char *TEST_DOMAIN3 = "test.com";
31 constexpr const char *TEST_DOMAIN4 = "testcom";
32 constexpr const char *TEST_DOMAIN5 = "com.test";
33 constexpr const char *TEST_DOMAIN6 = "test.co.uk";
34 constexpr const char *TEST_DOMAIN7 = "test.com.com";
35 constexpr const char *TEST_DOMAIN8 = "test1.test2.test3.test4.test5.com";
36 constexpr const char *DEFAULT_IPV6_ANY_INIT_ADDR = "::";
37 
38 const std::string TEST_DOMAIN9 = "www.test.com";
39 const std::string TEST_DOMAIN10 = "*";
40 const std::string TEST_DOMAIN11 = "";
41 const std::string TEST_DOMAIN12 = "*.test.*";
42 const std::string TEST_DOMAIN13 = "*.test./{*";
43 
44 constexpr int32_t MAX_IPV6_PREFIX_LENGTH = 128;
45 constexpr uint32_t ADDREDD_LEN = 16;
46 constexpr int32_t BIT_32 = 32;
47 constexpr int32_t BIT_24 = 24;
48 constexpr int32_t BIT_16 = 16;
49 constexpr int32_t BIT_8 = 8;
50 } // namespace
51 class UtNetmanagerBaseCommon : public testing::Test {
52 public:
53     static void SetUpTestCase();
54     static void TearDownTestCase();
55     void SetUp();
56     void TearDown();
57 };
SetUpTestCase()58 void UtNetmanagerBaseCommon::SetUpTestCase() {}
59 
TearDownTestCase()60 void UtNetmanagerBaseCommon::TearDownTestCase() {}
61 
SetUp()62 void UtNetmanagerBaseCommon::SetUp() {}
63 
TearDown()64 void UtNetmanagerBaseCommon::TearDown() {}
65 
66 /**
67  * @tc.name: UtNetmanagerBaseCommon001
68  * @tc.desc: Test UtNetmanagerBaseCommon ForkExec.
69  * @tc.type: FUNC
70  */
71 HWTEST_F(UtNetmanagerBaseCommon, UtNetmanagerBaseCommon001, TestSize.Level1)
72 {
73     std::string out;
74     CommonUtils::ForkExec("/system/bin/ls -a", &out);
75     ASSERT_FALSE(out.empty());
76     std::cout << "out: " << out << std::endl;
77 }
78 
79 /**
80  * @tc.name: UtNetmanagerBaseCommon002
81  * @tc.desc: Test UtNetmanagerBaseCommon ForkExec.
82  * @tc.type: FUNC
83  */
84 HWTEST_F(UtNetmanagerBaseCommon, UtNetmanagerBaseCommon002, TestSize.Level1)
85 {
86     std::string out;
87     CommonUtils::ForkExec("/system/bin/ls -l", &out);
88     ASSERT_FALSE(out.empty());
89     std::cout << "out: " << out << std::endl;
90 }
91 
92 /**
93  * @tc.name: UtNetmanagerBaseCommon003
94  * @tc.desc: Test UtNetmanagerBaseCommon ForkExec.
95  * @tc.type: FUNC
96  */
97 HWTEST_F(UtNetmanagerBaseCommon, UtNetmanagerBaseCommon003, TestSize.Level1)
98 {
99     CommonUtils::ForkExec("/system/bin/mount -o rw,remount /");
100     CommonUtils::ForkExec("/system/bin/mkdir uttest");
101     std::string out;
102     CommonUtils::ForkExec("/system/bin/ls -a", &out);
103     ASSERT_TRUE(out.find("uttest") != std::string::npos);
104     CommonUtils::ForkExec("/system/bin/rm -rf uttest");
105 }
106 
107 /**
108  * @tc.name: SplitTest001
109  * @tc.desc: Test UtNetmanagerBaseCommon Split.
110  * @tc.type: FUNC
111  */
112 HWTEST_F(UtNetmanagerBaseCommon, SplitTest001, TestSize.Level1)
113 {
114     std::vector<std::string> result = CommonUtils::Split(TEST_TEXT, SPLIT);
115     ASSERT_FALSE(result.empty());
116 }
117 
118 /**
119  * @tc.name: SplitTest002
120  * @tc.desc: Test UtNetmanagerBaseCommon Split.
121  * @tc.type: FUNC
122  */
123 HWTEST_F(UtNetmanagerBaseCommon, SplitTest002, TestSize.Level1)
124 {
125     std::vector<std::string> result = CommonUtils::Split({}, SPLIT);
126     ASSERT_TRUE(result.empty());
127 }
128 
129 /**
130  * @tc.name: StripTest001
131  * @tc.desc: Test UtNetmanagerBaseCommon Strip.
132  * @tc.type: FUNC
133  */
134 HWTEST_F(UtNetmanagerBaseCommon, StripTest001, TestSize.Level1)
135 {
136     auto result = CommonUtils::Strip(TEST_TEXT, '?');
137     ASSERT_FALSE(result.empty());
138 }
139 
140 /**
141  * @tc.name: IsValidIPV4Test001
142  * @tc.desc: Test UtNetmanagerBaseCommon IsValidIPV4.
143  * @tc.type: FUNC
144  */
145 HWTEST_F(UtNetmanagerBaseCommon, IsValidIPV4Test001, TestSize.Level1)
146 {
147     auto result = CommonUtils::IsValidIPV4(TEST_TEXT);
148     ASSERT_FALSE(result);
149 }
150 
151 /**
152  * @tc.name: IsValidIPV4Test002
153  * @tc.desc: Test UtNetmanagerBaseCommon IsValidIPV4.
154  * @tc.type: FUNC
155  */
156 HWTEST_F(UtNetmanagerBaseCommon, IsValidIPV4Test002, TestSize.Level1)
157 {
158     auto result = CommonUtils::IsValidIPV4({});
159     ASSERT_FALSE(result);
160 }
161 
162 /**
163  * @tc.name: IsValidIPV6Test001
164  * @tc.desc: Test UtNetmanagerBaseCommon IsValidIPV6.
165  * @tc.type: FUNC
166  */
167 HWTEST_F(UtNetmanagerBaseCommon, IsValidIPV6Test001, TestSize.Level1)
168 {
169     auto result = CommonUtils::IsValidIPV6(TEST_TEXT);
170     ASSERT_FALSE(result);
171 }
172 
173 /**
174  * @tc.name: IsValidIPV6Test002
175  * @tc.desc: Test UtNetmanagerBaseCommon IsValidIPV6.
176  * @tc.type: FUNC
177  */
178 HWTEST_F(UtNetmanagerBaseCommon, IsValidIPV6Test002, TestSize.Level1)
179 {
180     auto result = CommonUtils::IsValidIPV6({});
181     ASSERT_FALSE(result);
182 }
183 
184 /**
185  * @tc.name: GetAddrFamilyTest001
186  * @tc.desc: Test UtNetmanagerBaseCommon GetAddrFamily.
187  * @tc.type: FUNC
188  */
189 HWTEST_F(UtNetmanagerBaseCommon, GetAddrFamilyTest001, TestSize.Level1)
190 {
191     auto result = CommonUtils::GetAddrFamily(TEST_IP);
192     ASSERT_NE(result, 0);
193 }
194 
195 /**
196  * @tc.name: GetMaskLengthTest001
197  * @tc.desc: Test UtNetmanagerBaseCommon GetMaskLength.
198  * @tc.type: FUNC
199  */
200 HWTEST_F(UtNetmanagerBaseCommon, GetMaskLengthTest001, TestSize.Level1)
201 {
202     auto result = CommonUtils::GetMaskLength(TEST_TEXT);
203     ASSERT_NE(result, 0);
204 }
205 
206 /**
207  * @tc.name: ConvertIpv4AddressTest001
208  * @tc.desc: Test UtNetmanagerBaseCommon ConvertIpv4Address.
209  * @tc.type: FUNC
210  */
211 HWTEST_F(UtNetmanagerBaseCommon, ConvertIpv4AddressTest001, TestSize.Level1)
212 {
213     auto result = CommonUtils::ConvertIpv4Address(0);
214     ASSERT_TRUE(result.empty());
215 }
216 
217 /**
218  * @tc.name: ConvertIpv4AddressTest002
219  * @tc.desc: Test UtNetmanagerBaseCommon ConvertIpv4Address.
220  * @tc.type: FUNC
221  */
222 HWTEST_F(UtNetmanagerBaseCommon, ConvertIpv4AddressTest002, TestSize.Level1)
223 {
224     auto result = CommonUtils::ConvertIpv4Address(ADDREDD_LEN);
225     ASSERT_FALSE(result.empty());
226 }
227 
228 /**
229  * @tc.name: ConvertIpv4AddressTest003
230  * @tc.desc: Test UtNetmanagerBaseCommon ConvertIpv4Address.
231  * @tc.type: FUNC
232  */
233 HWTEST_F(UtNetmanagerBaseCommon, ConvertIpv4AddressTest003, TestSize.Level1)
234 {
235     auto result = CommonUtils::ConvertIpv4Address(TEST_IP);
236     ASSERT_NE(result, static_cast<uint32_t>(0));
237 }
238 
239 /**
240  * @tc.name: ConvertIpv4AddressTest004
241  * @tc.desc: Test UtNetmanagerBaseCommon ConvertIpv4Address.
242  * @tc.type: FUNC
243  */
244 HWTEST_F(UtNetmanagerBaseCommon, ConvertIpv4AddressTest004, TestSize.Level1)
245 {
246     std::string addr;
247     auto result = CommonUtils::ConvertIpv4Address(addr);
248     ASSERT_EQ(result, static_cast<uint32_t>(0));
249 }
250 
251 /**
252  * @tc.name: Ipv4PrefixLenTest001
253  * @tc.desc: Test UtNetmanagerBaseCommon ConvertIpv4Address.
254  * @tc.type: FUNC
255  */
256 HWTEST_F(UtNetmanagerBaseCommon, Ipv4PrefixLenTest001, TestSize.Level1)
257 {
258     std::string addr;
259     auto result = CommonUtils::ConvertIpv4Address(addr);
260     ASSERT_EQ(result, static_cast<uint32_t>(0));
261 }
262 
263 /**
264  * @tc.name: Ipv4PrefixLenTest002
265  * @tc.desc: Test UtNetmanagerBaseCommon ConvertIpv4Address.
266  * @tc.type: FUNC
267  */
268 HWTEST_F(UtNetmanagerBaseCommon, Ipv4PrefixLenTest002, TestSize.Level1)
269 {
270     auto result = CommonUtils::ConvertIpv4Address(TEST_IP);
271     ASSERT_NE(result, static_cast<uint32_t>(0));
272 }
273 
274 /**
275  * @tc.name: ParseIntTest001
276  * @tc.desc: Test UtNetmanagerBaseCommon ParseInt.
277  * @tc.type: FUNC
278  */
279 HWTEST_F(UtNetmanagerBaseCommon, ParseIntTest001, TestSize.Level1)
280 {
281     std::string testStr = "123";
282     int32_t value = 0;
283     auto result = CommonUtils::ParseInt(testStr, &value);
284     ASSERT_NE(value, 0);
285     ASSERT_TRUE(result);
286 }
287 
288 /**
289  * @tc.name: ParseIntTest002
290  * @tc.desc: Test UtNetmanagerBaseCommon ParseInt.
291  * @tc.type: FUNC
292  */
293 HWTEST_F(UtNetmanagerBaseCommon, ParseIntTest002, TestSize.Level1)
294 {
295     std::string testStr = "abcdfagdshrfsth";
296     int32_t value = 0;
297     auto result = CommonUtils::ParseInt(testStr, &value);
298     ASSERT_EQ(value, 0);
299     ASSERT_FALSE(result);
300 }
301 
302 /**
303  * @tc.name: ParseIntTest003
304  * @tc.desc: Test UtNetmanagerBaseCommon ParseInt.
305  * @tc.type: FUNC
306  */
307 HWTEST_F(UtNetmanagerBaseCommon, ParseIntTest003, TestSize.Level1)
308 {
309     std::string testStr = "44514564121561456745456891564564894";
310     int32_t value = 0;
311     auto result = CommonUtils::ParseInt(testStr, &value);
312     ASSERT_EQ(value, 0);
313     ASSERT_FALSE(result);
314 }
315 
316 /**
317  * @tc.name: ParseIntTest004
318  * @tc.desc: Test UtNetmanagerBaseCommon ParseInt.
319  * @tc.type: FUNC
320  */
321 HWTEST_F(UtNetmanagerBaseCommon, ParseIntTest004, TestSize.Level1)
322 {
323     std::string testStr = "-156423456123512423456146";
324     int32_t value = 0;
325     auto result = CommonUtils::ParseInt(testStr, &value);
326     ASSERT_EQ(value, 0);
327     ASSERT_FALSE(result);
328 }
329 
330 /**
331  * @tc.name: ConvertToInt64Test001
332  * @tc.desc: Test UtNetmanagerBaseCommon ConvertToInt64.
333  * @tc.type: FUNC
334  */
335 HWTEST_F(UtNetmanagerBaseCommon, ConvertToInt64Test001, TestSize.Level1)
336 {
337     std::string testStr = "145689";
338     auto result = CommonUtils::ConvertToInt64(testStr);
339     ASSERT_NE(result, 0);
340 }
341 
342 /**
343  * @tc.name: ToAnonymousIpTest001
344  * @tc.desc: Test UtNetmanagerBaseCommon ToAnonymousIp.
345  * @tc.type: FUNC
346  */
347 HWTEST_F(UtNetmanagerBaseCommon, ToAnonymousIpTest001, TestSize.Level1)
348 {
349     auto result = CommonUtils::ToAnonymousIp(TEST_IPV4);
350     ASSERT_FALSE(result.empty());
351 }
352 
353 /**
354  * @tc.name: ToAnonymousIpTest002
355  * @tc.desc: Test UtNetmanagerBaseCommon ToAnonymousIp.
356  * @tc.type: FUNC
357  */
358 HWTEST_F(UtNetmanagerBaseCommon, ToAnonymousIpTest002, TestSize.Level1)
359 {
360     auto result = CommonUtils::ToAnonymousIp(TEST_IP);
361     ASSERT_FALSE(result.empty());
362 }
363 
364 /*
365  * @tc.name: ToAnonymousIpTest003
366  * @tc.desc: Test UtNetmanagerBaseCommon ToAnonymousIp.
367  * @tc.type: FUNC
368  */
369 HWTEST_F(UtNetmanagerBaseCommon, ToAnonymousIpTest003, TestSize.Level1)
370 {
371     auto result = CommonUtils::ToAnonymousIp({});
372     ASSERT_TRUE(result.empty());
373 }
374 
375 /**
376  * @tc.name: StrToIntTest001
377  * @tc.desc: Test UtNetmanagerBaseCommon StrToInt.
378  * @tc.type: FUNC
379  */
380 HWTEST_F(UtNetmanagerBaseCommon, StrToIntTest001, TestSize.Level1)
381 {
382     std::string testStr = "145689";
383     auto result = CommonUtils::StrToInt(testStr);
384     ASSERT_NE(result, 0);
385 }
386 
387 /**
388  * @tc.name: StrToUintTest001
389  * @tc.desc: Test UtNetmanagerBaseCommon StrToUint.
390  * @tc.type: FUNC
391  */
392 HWTEST_F(UtNetmanagerBaseCommon, StrToUintTest001, TestSize.Level1)
393 {
394     std::string testStr = "145689";
395     auto result = CommonUtils::StrToUint(testStr);
396     ASSERT_NE(result, static_cast<uint32_t>(0));
397 }
398 
399 /**
400  * @tc.name: StrToBoolTest001
401  * @tc.desc: Test UtNetmanagerBaseCommon StrToBool.
402  * @tc.type: FUNC
403  */
404 HWTEST_F(UtNetmanagerBaseCommon, StrToBoolTest001, TestSize.Level1)
405 {
406     std::string testStr = "145689";
407     auto result = CommonUtils::StrToBool(testStr);
408     ASSERT_TRUE(result);
409 }
410 
411 /**
412  * @tc.name: StrToLongTest001
413  * @tc.desc: Test UtNetmanagerBaseCommon StrToUint.
414  * @tc.type: FUNC
415  */
416 HWTEST_F(UtNetmanagerBaseCommon, StrToLongTest001, TestSize.Level1)
417 {
418     std::string testStr = "145689";
419     auto result = CommonUtils::StrToLong(testStr);
420     ASSERT_NE(result, 0);
421 }
422 
423 /**
424  * @tc.name: IsValidDomainTest001
425  * @tc.desc: Test UtNetmanagerBaseCommon IsValidDomain.
426  * @tc.type: FUNC
427  */
428 HWTEST_F(UtNetmanagerBaseCommon, IsValidDomainTest001, TestSize.Level1)
429 {
430     auto result = CommonUtils::IsValidDomain(TEST_DOMAIN1);
431     ASSERT_FALSE(result);
432 }
433 
434 /**
435  * @tc.name: IsValidDomainTest002
436  * @tc.desc: Test UtNetmanagerBaseCommon IsValidDomain.
437  * @tc.type: FUNC
438  */
439 HWTEST_F(UtNetmanagerBaseCommon, IsValidDomainTest002, TestSize.Level1)
440 {
441     auto result = CommonUtils::IsValidDomain(TEST_DOMAIN2);
442     ASSERT_FALSE(result);
443 }
444 
445 /**
446  * @tc.name: IsValidDomainTest003
447  * @tc.desc: Test UtNetmanagerBaseCommon IsValidDomain.
448  * @tc.type: FUNC
449  */
450 HWTEST_F(UtNetmanagerBaseCommon, IsValidDomainTest003, TestSize.Level1)
451 {
452     auto result = CommonUtils::IsValidDomain(TEST_DOMAIN3);
453     ASSERT_TRUE(result);
454 }
455 
456 /**
457  * @tc.name: IsValidDomainTest004
458  * @tc.desc: Test UtNetmanagerBaseCommon IsValidDomain.
459  * @tc.type: FUNC
460  */
461 HWTEST_F(UtNetmanagerBaseCommon, IsValidDomainTest004, TestSize.Level1)
462 {
463     auto result = CommonUtils::IsValidDomain(TEST_DOMAIN4);
464     ASSERT_FALSE(result);
465 }
466 
467 /**
468  * @tc.name: IsValidDomainTest005
469  * @tc.desc: Test UtNetmanagerBaseCommon IsValidDomain.
470  * @tc.type: FUNC
471  */
472 HWTEST_F(UtNetmanagerBaseCommon, IsValidDomainTest005, TestSize.Level1)
473 {
474     auto result = CommonUtils::IsValidDomain(TEST_DOMAIN5);
475     ASSERT_FALSE(result);
476 }
477 
478 /**
479  * @tc.name: IsValidDomainTest006
480  * @tc.desc: Test UtNetmanagerBaseCommon IsValidDomain.
481  * @tc.type: FUNC
482  */
483 HWTEST_F(UtNetmanagerBaseCommon, IsValidDomainTest006, TestSize.Level1)
484 {
485     auto result = CommonUtils::IsValidDomain(TEST_DOMAIN6);
486     ASSERT_TRUE(result);
487 }
488 
489 /**
490  * @tc.name: IsValidDomainTest007
491  * @tc.desc: Test UtNetmanagerBaseCommon IsValidDomain.
492  * @tc.type: FUNC
493  */
494 HWTEST_F(UtNetmanagerBaseCommon, IsValidDomainTest007, TestSize.Level1)
495 {
496     auto result = CommonUtils::IsValidDomain(TEST_DOMAIN7);
497     ASSERT_FALSE(result);
498 }
499 
500 /**
501  * @tc.name: IsValidDomainTest008
502  * @tc.desc: Test UtNetmanagerBaseCommon IsValidDomain.
503  * @tc.type: FUNC
504  */
505 HWTEST_F(UtNetmanagerBaseCommon, IsValidDomainTest008, TestSize.Level1)
506 {
507     auto result = CommonUtils::IsValidDomain(TEST_DOMAIN8);
508     ASSERT_FALSE(result);
509 }
510 
511 /**
512  * @tc.name: ToLowerTest008
513  * @tc.desc: Test UtNetmanagerBaseCommon ToLower.
514  * @tc.type: FUNC
515  */
516 HWTEST_F(UtNetmanagerBaseCommon, ToLowerTest008, TestSize.Level1)
517 {
518     std::string res = "HeLLo worLd";
519     auto result = CommonUtils::ToLower(res);
520     EXPECT_EQ(result, "hello world");
521 }
522 
523 /**
524  * @tc.name: GetMaskByLengthTest008
525  * @tc.desc: Test UtNetmanagerBaseCommon GetMaskByLength.
526  * @tc.type: FUNC
527  */
528 HWTEST_F(UtNetmanagerBaseCommon, GetMaskByLengthTest008, TestSize.Level1)
529 {
530     uint32_t length = 8;
531     auto result = CommonUtils::GetMaskByLength(length);
532     EXPECT_NE(result, "255.255.255.0");
533 }
534 
535 /**
536  * @tc.name: Ipv4PrefixLenTest008
537  * @tc.desc: Test UtNetmanagerBaseCommon Ipv4PrefixLen.
538  * @tc.type: FUNC
539  */
540 HWTEST_F(UtNetmanagerBaseCommon, Ipv4PrefixLenTest008, TestSize.Level1)
541 {
542     std::string ip = {};
543     auto result = CommonUtils::Ipv4PrefixLen(ip);
544     EXPECT_EQ(result, 0);
545     ip = "192.168.0";
546     result = CommonUtils::Ipv4PrefixLen(ip);
547     EXPECT_EQ(result, 0);
548     ip = "255.255.255.255";
549     result = CommonUtils::Ipv4PrefixLen(ip);
550     EXPECT_EQ(result, BIT_32);
551     ip = "255.255.255.0";
552     result = CommonUtils::Ipv4PrefixLen(ip);
553     EXPECT_EQ(result, BIT_24);
554     ip = "255.255.0.0";
555     result = CommonUtils::Ipv4PrefixLen(ip);
556     EXPECT_EQ(result, BIT_16);
557     ip = "255.0.0.0";
558     result = CommonUtils::Ipv4PrefixLen(ip);
559     EXPECT_EQ(result, BIT_8);
560     ip = "255.192.0.0";
561     result = CommonUtils::Ipv4PrefixLen(ip);
562     EXPECT_EQ(result, 10);
563 }
564 
565 /**
566  * @tc.name: StrToUint64Test008
567  * @tc.desc: Test UtNetmanagerBaseCommon StrToUint64.
568  * @tc.type: FUNC
569  */
570 HWTEST_F(UtNetmanagerBaseCommon, StrToUint64Test008, TestSize.Level1)
571 {
572     std::string value = {};
573     uint64_t defaultErr = 0;
574     auto result = CommonUtils::StrToUint64(value, defaultErr);
575     EXPECT_EQ(result, defaultErr);
576     value = "100";
577     uint64_t value2 = 100;
578     result = CommonUtils::StrToUint64(value, defaultErr);
579     EXPECT_EQ(result, value2);
580 }
581 
582 HWTEST_F(UtNetmanagerBaseCommon, Trim, TestSize.Level2)
583 {
584     std::string str = "    trim   ";
585     std::string strResult = CommonUtils::Trim(str);
586     EXPECT_STREQ(strResult.c_str(), "trim");
587 }
588 
589 HWTEST_F(UtNetmanagerBaseCommon, UrlRegexParse001, TestSize.Level2)
590 {
591     bool isMatch = CommonUtils::UrlRegexParse(TEST_DOMAIN9, TEST_DOMAIN10);
592     EXPECT_EQ(isMatch, true);
593 }
594 
595 HWTEST_F(UtNetmanagerBaseCommon, UrlRegexParse002, TestSize.Level2)
596 {
597     bool isMatch = CommonUtils::UrlRegexParse(TEST_DOMAIN9, TEST_DOMAIN11);
598     EXPECT_EQ(isMatch, false);
599 }
600 
601 HWTEST_F(UtNetmanagerBaseCommon, UrlRegexParse003, TestSize.Level2)
602 {
603     bool isMatch = CommonUtils::UrlRegexParse(TEST_DOMAIN9, TEST_DOMAIN12);
604     EXPECT_EQ(isMatch, true);
605 }
606 
607 HWTEST_F(UtNetmanagerBaseCommon, UrlRegexParse004, TestSize.Level2)
608 {
609     bool isMatch = CommonUtils::UrlRegexParse(TEST_DOMAIN9, TEST_DOMAIN9);
610     EXPECT_EQ(isMatch, true);
611 }
612 
613 HWTEST_F(UtNetmanagerBaseCommon, IsUrlRegexValid001, TestSize.Level2)
614 {
615     bool isValid = CommonUtils::IsUrlRegexValid(TEST_DOMAIN12);
616     EXPECT_EQ(isValid, true);
617 }
618 
619 HWTEST_F(UtNetmanagerBaseCommon, IsUrlRegexValid002, TestSize.Level2)
620 {
621     bool isValid = CommonUtils::IsUrlRegexValid(TEST_DOMAIN13);
622     EXPECT_EQ(isValid, false);
623 }
624 
625 HWTEST_F(UtNetmanagerBaseCommon, GetIpv6Prefix001, TestSize.Level2)
626 {
627     std::string ipv6Addr = TEST_IP;
628     uint8_t prefixLen = MAX_IPV6_PREFIX_LENGTH;
629     auto result = CommonUtils::GetIpv6Prefix(ipv6Addr, prefixLen);
630     EXPECT_EQ(result, ipv6Addr);
631 
632     prefixLen = MAX_IPV6_PREFIX_LENGTH - 1;
633     result = CommonUtils::GetIpv6Prefix(ipv6Addr, prefixLen);
634     EXPECT_EQ(result, DEFAULT_IPV6_ANY_INIT_ADDR);
635 }
636 
637 HWTEST_F(UtNetmanagerBaseCommon, Ipv6PrefixLen001, TestSize.Level2)
638 {
639     std::string ip = "";
640     auto result = CommonUtils::Ipv6PrefixLen(ip);
641     EXPECT_EQ(result, 0);
642 
643     result = CommonUtils::Ipv6PrefixLen(TEST_IP);
644     EXPECT_EQ(result, 0);
645 }
646 
647 HWTEST_F(UtNetmanagerBaseCommon, HasInternetPermission001, TestSize.Level2)
648 {
649     bool result = CommonUtils::HasInternetPermission();
650     EXPECT_TRUE(result);
651 }
652 
653 HWTEST_F(UtNetmanagerBaseCommon, CheckIfaceName001, TestSize.Level2)
654 {
655     std::string name = "";
656     bool result = CommonUtils::CheckIfaceName(name);
657     EXPECT_FALSE(result);
658 
659     name = TEST_TEXT;
660     result = CommonUtils::CheckIfaceName(name);
661     EXPECT_FALSE(result);
662 }
663 } // namespace NetManagerStandard
664 } // namespace OHOS
665