1 /*
2 * Copyright (c) 2022 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 "UTTest_dm_anonymous.h"
17 #include <iterator>
18
19 namespace OHOS {
20 namespace DistributedHardware {
21 constexpr const char* FIELD_CREDENTIAL_DATA = "credentialData";
SetUp()22 void DmAnonymousTest::SetUp()
23 {
24 }
TearDown()25 void DmAnonymousTest::TearDown()
26 {
27 }
SetUpTestCase()28 void DmAnonymousTest::SetUpTestCase()
29 {
30 }
TearDownTestCase()31 void DmAnonymousTest::TearDownTestCase()
32 {
33 }
34
35 namespace {
36 /**
37 * @tc.name: GetAnonyString_001
38 * @tc.desc: Return size of anony string
39 * @tc.type: FUNC
40 * @tc.require: AR000GHSJK
41 */
42 HWTEST_F(DmAnonymousTest, GetAnonyString_001, testing::ext::TestSize.Level0)
43 {
44 const std::string value = "valueTest";
45 std::string str = GetAnonyString(value);
46 int32_t ret = str.size();
47 EXPECT_EQ(ret, 8);
48 }
49
50 /**
51 * @tc.name: GetAnonyString_002
52 * @tc.desc: Return size of anony string
53 * @tc.type: FUNC
54 * @tc.require: AR000GHSJK
55 */
56 HWTEST_F(DmAnonymousTest, GetAnonyString_002, testing::ext::TestSize.Level0)
57 {
58 const std::string value = "va";
59 std::string str = GetAnonyString(value);
60 int32_t ret = str.size();
61 EXPECT_EQ(ret, 6);
62 }
63
64 /**
65 * @tc.name: GetAnonyString_003
66 * @tc.desc: Return size of anony string
67 * @tc.type: FUNC
68 * @tc.require: AR000GHSJK
69 */
70 HWTEST_F(DmAnonymousTest, GetAnonyString_003, testing::ext::TestSize.Level0)
71 {
72 const std::string value = "ohos.distributedhardware.devicemanager.resident";
73 std::string str = GetAnonyString(value);
74 int32_t ret = str.size();
75 EXPECT_EQ(ret, 14);
76 }
77
78 /**
79 * @tc.name: GetAnonyInt32_001
80 * @tc.desc: Return size of anony string
81 * @tc.type: FUNC
82 * @tc.require: AR000GHSJK
83 */
84 HWTEST_F(DmAnonymousTest, GetAnonyInt32_001, testing::ext::TestSize.Level0)
85 {
86 const int32_t value = 1;
87 std::string str = GetAnonyInt32(value);
88 int32_t ret = str.size();
89 EXPECT_EQ(ret, 1);
90 }
91
92 /**
93 * @tc.name: GetAnonyInt32_002
94 * @tc.desc: Return size of anony string
95 * @tc.type: FUNC
96 * @tc.require: AR000GHSJK
97 */
98 HWTEST_F(DmAnonymousTest, GetAnonyInt32_002, testing::ext::TestSize.Level0)
99 {
100 const int32_t value = 12;
101 std::string str = GetAnonyInt32(value);
102 int32_t ret = str.size();
103 EXPECT_EQ(ret, 2);
104 }
105
106 /**
107 * @tc.name: GetAnonyInt32_003
108 * @tc.desc: Return size of anony string
109 * @tc.type: FUNC
110 * @tc.require: AR000GHSJK
111 */
112 HWTEST_F(DmAnonymousTest, GetAnonyInt32_003, testing::ext::TestSize.Level0)
113 {
114 const int32_t value = 123456;
115 std::string str = GetAnonyInt32(value);
116 int32_t ret = str.size();
117 EXPECT_EQ(ret, 6);
118 }
119
120 /**
121 * @tc.name: IsNumberString_001
122 * @tc.desc: Return false if the string is not a number
123 * @tc.type: FUNC
124 * @tc.require: AR000GHSJK
125 */
126 HWTEST_F(DmAnonymousTest, IsNumberString_001, testing::ext::TestSize.Level0)
127 {
128 const std::string inputString = "";
129 bool ret = IsNumberString(inputString);
130 EXPECT_EQ(ret, false);
131 }
132
133 /**
134 * @tc.name: IsNumberString_002
135 * @tc.desc: Return false if the string is not a number
136 * @tc.type: FUNC
137 * @tc.require: AR000GHSJK
138 */
139 HWTEST_F(DmAnonymousTest, IsNumberString_002, testing::ext::TestSize.Level0)
140 {
141 const std::string inputString = "123inputstring";
142 bool ret = IsNumberString(inputString);
143 EXPECT_EQ(ret, false);
144 }
145
146 /**
147 * @tc.name: IsNumberString_003
148 * @tc.desc: Return true if the string is a number
149 * @tc.type: FUNC
150 * @tc.require: AR000GHSJK
151 */
152 HWTEST_F(DmAnonymousTest, IsNumberString_003, testing::ext::TestSize.Level0)
153 {
154 const std::string inputString = "25633981";
155 bool ret = IsNumberString(inputString);
156 EXPECT_EQ(ret, true);
157 }
158
159 /**
160 * @tc.name: GetErrorString_001
161 * @tc.desc: Return true if the string is a number
162 * @tc.type: FUNC
163 * @tc.require: AR000GHSJK
164 */
165 HWTEST_F(DmAnonymousTest, GetErrorString_001, testing::ext::TestSize.Level0)
166 {
167 int failedReason = 96929744;
168 std::string errorMessage = "dm process execution failed...";
169 std::string ret = GetErrorString(failedReason);
170 EXPECT_EQ(ret, errorMessage);
171 }
172
173 /**
174 * @tc.name: IsString_001
175 * @tc.desc: Return true
176 * @tc.type: FUNC
177 * @tc.require: AR000GHSJK
178 */
179 HWTEST_F(DmAnonymousTest, IsString_001, testing::ext::TestSize.Level0)
180 {
181 std::string str = R"(
182 {
183 "pinToken" : "IsString"
184 }
185 )";
186 JsonObject jsonObj(str);
187 bool ret = IsString(jsonObj, PIN_TOKEN);
188 EXPECT_EQ(ret, true);
189 }
190
191 /**
192 * @tc.name: IsString_002
193 * @tc.desc: Return false
194 * @tc.type: FUNC
195 * @tc.require: AR000GHSJK
196 */
197 HWTEST_F(DmAnonymousTest, IsString_002, testing::ext::TestSize.Level0)
198 {
199 std::string str = R"(
200 {
201 "pinToken" : 123
202 }
203 )";
204 JsonObject jsonObj(str);
205 bool ret = IsString(jsonObj, PIN_TOKEN);
206 EXPECT_EQ(ret, false);
207 }
208
209 /**
210 * @tc.name: IsInt32_001
211 * @tc.desc: Return true
212 * @tc.type: FUNC
213 * @tc.require: AR000GHSJK
214 */
215 HWTEST_F(DmAnonymousTest, IsInt32_001, testing::ext::TestSize.Level0)
216 {
217 std::string str = R"(
218 {
219 "AUTHTYPE" : 369
220 }
221 )";
222 JsonObject jsonObj(str);
223 bool ret = IsInt32(jsonObj, TAG_AUTH_TYPE);
224 EXPECT_EQ(ret, true);
225 }
226
227 /**
228 * @tc.name: IsInt32_002
229 * @tc.desc: Return false
230 * @tc.type: FUNC
231 * @tc.require: AR000GHSJK
232 */
233 HWTEST_F(DmAnonymousTest, IsInt32_002, testing::ext::TestSize.Level0)
234 {
235 std::string str = R"(
236 {
237 "AUTHTYPE" : "authtypeTest"
238 }
239 )";
240 JsonObject jsonObj(str);
241 bool ret = IsInt32(jsonObj, TAG_AUTH_TYPE);
242 EXPECT_EQ(ret, false);
243 }
244
245 /**
246 * @tc.name: IsUint32_001
247 * @tc.desc: Return false
248 * @tc.type: FUNC
249 * @tc.require: AR000GHSJK
250 */
251 HWTEST_F(DmAnonymousTest, IsUint32_001, testing::ext::TestSize.Level0)
252 {
253 std::string str = R"(
254 {
255 "AUTHTYPE" : "authtypeTest"
256 }
257 )";
258 JsonObject jsonObj(str);
259 bool ret = IsUint32(jsonObj, TAG_AUTH_TYPE);
260 EXPECT_EQ(ret, false);
261 }
262
263 /**
264 * @tc.name: IsInt64_001
265 * @tc.desc: Return true
266 * @tc.type: FUNC
267 * @tc.require: AR000GHSJK
268 */
269 HWTEST_F(DmAnonymousTest, IsInt64_001, testing::ext::TestSize.Level0)
270 {
271 std::string str = R"(
272 {
273 "REQUESTID" : 789
274 }
275 )";
276 JsonObject jsonObj(str);
277 bool ret = IsInt64(jsonObj, TAG_REQUEST_ID);
278 EXPECT_EQ(ret, true);
279 }
280
281 /**
282 * @tc.name: IsInt64_002
283 * @tc.desc: Return false
284 * @tc.type: FUNC
285 * @tc.require: AR000GHSJK
286 */
287 HWTEST_F(DmAnonymousTest, IsInt64_002, testing::ext::TestSize.Level0)
288 {
289 std::string str = R"(
290 {
291 "REQUESTID" : "requestidTest"
292 }
293 )";
294 JsonObject jsonObj(str);
295 bool ret = IsInt64(jsonObj, TAG_REQUEST_ID);
296 EXPECT_EQ(ret, false);
297 }
298
299 /**
300 * @tc.name: IsArray_001
301 * @tc.desc: Return true
302 * @tc.type: FUNC
303 * @tc.require: AR000GHSJK
304 */
305 HWTEST_F(DmAnonymousTest, IsArray_001, testing::ext::TestSize.Level0)
306 {
307 std::string str = R"(
308 {
309 "authType" : 1,
310 "userId" : "123",
311 "credentialData" :
312 [
313 {
314 "credentialType" : 1,
315 "credentialId" : "104",
316 "authCode" : "1234567812345678123456781234567812345678123456781234567812345678",
317 "serverPk" : "",
318 "pkInfoSignature" : "",
319 "pkInfo" : "",
320 "peerDeviceId" : ""
321 }
322 ]
323 }
324 )";
325 JsonObject jsonObj(str);
326 bool ret = IsArray(jsonObj, FIELD_CREDENTIAL_DATA);
327 EXPECT_EQ(ret, true);
328 }
329
330 /**
331 * @tc.name: IsArray_002
332 * @tc.desc: Return false
333 * @tc.type: FUNC
334 * @tc.require: AR000GHSJK
335 */
336 HWTEST_F(DmAnonymousTest, IsArray_002, testing::ext::TestSize.Level0)
337 {
338 std::string str = R"(
339 {
340 "authType" : 1,
341 "userId" : "123",
342 "credentialData" : "credentialDataTest"
343 }
344 )";
345 JsonObject jsonObj(str);
346 bool ret = IsArray(jsonObj, FIELD_CREDENTIAL_DATA);
347 EXPECT_EQ(ret, false);
348 }
349
350 /**
351 * @tc.name: IsBool_001
352 * @tc.desc: Return true
353 * @tc.type: FUNC
354 * @tc.require: AR000GHSJK
355 */
356 HWTEST_F(DmAnonymousTest, IsBool_001, testing::ext::TestSize.Level0)
357 {
358 std::string str = R"(
359 {
360 "CRYPTOSUPPORT" : false,
361 "userId" : "123",
362 "credentialData" : "credentialDataTest"
363 }
364 )";
365 JsonObject jsonObj(str);
366 bool ret = IsBool(jsonObj, TAG_CRYPTO_SUPPORT);
367 EXPECT_EQ(ret, true);
368 }
369
370 /**
371 * @tc.name: IsBool_002
372 * @tc.desc: Return false
373 * @tc.type: FUNC
374 * @tc.require: AR000GHSJK
375 */
376 HWTEST_F(DmAnonymousTest, IsBool_002, testing::ext::TestSize.Level0)
377 {
378 std::string str = R"(
379 {
380 "CRYPTOSUPPORT" : "cryptosupportTest",
381 "userId" : "123",
382 "credentialData" : "credentialDataTest"
383 }
384 )";
385 JsonObject jsonObj(str);
386 bool ret = IsBool(jsonObj, TAG_CRYPTO_SUPPORT);
387 EXPECT_EQ(ret, false);
388 }
389
390 /**
391 * @tc.name: ConvertCharArray2String_001
392 * @tc.desc: Return false
393 * @tc.type: FUNC
394 * @tc.require: AR000GHSJK
395 */
396 HWTEST_F(DmAnonymousTest, ConvertCharArray2String_001, testing::ext::TestSize.Level0)
397 {
398 constexpr uint32_t maxMessageLen = 40 * 1024 * 1024;
399 char *srcData = nullptr;
400 uint32_t srcLen = 0;
401 std::string ret = ConvertCharArray2String(srcData, srcLen);
402 EXPECT_EQ(ret, "");
403 ret = ConvertCharArray2String(srcData, maxMessageLen + 1);
404 EXPECT_EQ(ret, "");
405 char srcData2[20] = {"1234"};
406 ret = ConvertCharArray2String(srcData2, maxMessageLen + 1);
407 EXPECT_EQ(ret, "");
408 uint32_t srcLen2 = 20;
409 ret = ConvertCharArray2String(srcData2, srcLen);
410 EXPECT_EQ(ret, "");
411 ret = ConvertCharArray2String(srcData, srcLen2);
412 EXPECT_EQ(ret, "");
413 ret = ConvertCharArray2String(srcData2, srcLen2);
414 EXPECT_EQ(ret, "1234");
415 }
416
417 HWTEST_F(DmAnonymousTest, StringToInt_001, testing::ext::TestSize.Level0)
418 {
419 std::string str = "12344";
420 int32_t base = 10;
421 int32_t ret = StringToInt(str, base);
422 EXPECT_EQ(ret, 12344);
423 }
424
425 HWTEST_F(DmAnonymousTest, StringToInt_002, testing::ext::TestSize.Level0)
426 {
427 std::string str;
428 int32_t base = 10;
429 int32_t ret = StringToInt(str, base);
430 EXPECT_EQ(ret, 0);
431 }
432
433 HWTEST_F(DmAnonymousTest, StringToInt64_001, testing::ext::TestSize.Level0)
434 {
435 std::string str;
436 int32_t base = 10;
437 int64_t ret = StringToInt64(str, base);
438 EXPECT_EQ(ret, 0);
439 }
440
441
442 HWTEST_F(DmAnonymousTest, ParseMapFromJsonString_001, testing::ext::TestSize.Level0)
443 {
444 std::string jsonStr = R"(
445 {
446 "authType" : 1,
447 "userId" : "123",
448 "credentialData" :
449 [
450 {
451 "CRYPTOSUPPORT" : "cryptosupportTest",
452 "credentialType" : 1,
453 "credentialId" : "104",
454 "authCode" : "1234567812345678123456781234567812345678123456781234567812345678",
455 "serverPk" : "hello",
456 "pkInfoSignature" : "world",
457 "pkInfo" : "pkginfo",
458 "peerDeviceId" : "3515656546"
459 }
460 ]
461 }
462 )";
463 std::map<std::string, std::string> paramMap;
464 JsonObject jsonObj(jsonStr);
465 ParseMapFromJsonString(jsonStr, paramMap);
466 EXPECT_GE(paramMap.size(), 0);
467 }
468
469 HWTEST_F(DmAnonymousTest, ParseMapFromJsonString_002, testing::ext::TestSize.Level0)
470 {
471 std::string jsonStr = R"(
472 {
473 "authType" : 1,
474 "userId" : "123",
475 "credentialData" :
476 [
477 {
478 "CRYPTOSUPPORT" : "cryptosupportTest",
479 "credentialType" : 1,
480 "credentialId" : "104",
481 "authCode" : "1234567812345678123456781234567812345678123456781234567812345678",
482 "serverPk" : "hello",
483 "pkInfoSignature" : "world",
484 "pkInfo" : "pkginfo",
485 "peerDeviceId" : "3515656546"
486 }
487 ]
488 )";
489 std::map<std::string, std::string> paramMap;
490 JsonObject jsonObj(jsonStr);
491 ParseMapFromJsonString(jsonStr, paramMap);
492 EXPECT_EQ(paramMap.size(), 0);
493 }
494
495 HWTEST_F(DmAnonymousTest, ParseMapFromJsonString_003, testing::ext::TestSize.Level0)
496 {
497 std::string jsonStr = "";
498 std::map<std::string, std::string> paramMap;
499 JsonObject jsonObj(jsonStr);
500 ParseMapFromJsonString(jsonStr, paramMap);
501 EXPECT_EQ(paramMap.size(), 0);
502 }
503
504 HWTEST_F(DmAnonymousTest, GetAnonyStringList_001, testing::ext::TestSize.Level0)
505 {
506 std::string value = "valueTest";
507 std::vector<std::string> valueVec;
508 valueVec.push_back(value);
509 std::string str = GetAnonyStringList(valueVec);
510 auto ret = str.size();
511 EXPECT_GE(ret, 0);
512 }
513
514 HWTEST_F(DmAnonymousTest, StringToInt64_002, testing::ext::TestSize.Level0)
515 {
516 std::string str = "12345";
517 int32_t base = 10;
518 int32_t ret = StringToInt64(str, base);
519 EXPECT_EQ(ret, 12345);
520 }
521
522 HWTEST_F(DmAnonymousTest, GetCallerPkgName_001, testing::ext::TestSize.Level0)
523 {
524 std::string str = "pkgName#12345";
525 std::string ret = GetCallerPkgName(str);
526 EXPECT_FALSE(ret.empty());
527 }
528
529 HWTEST_F(DmAnonymousTest, IsMessageLengthValid_001, testing::ext::TestSize.Level0)
530 {
531 std::string inputMessage;
532 bool ret = IsMessageLengthValid(inputMessage);
533 EXPECT_FALSE(ret);
534 }
535
536 HWTEST_F(DmAnonymousTest, IsDmCommonNotifyEventValid_001, testing::ext::TestSize.Level0)
537 {
538 DmCommonNotifyEvent dmCommonNotifyEvent = DmCommonNotifyEvent::MAX;
539 bool ret = IsDmCommonNotifyEventValid(dmCommonNotifyEvent);
540 EXPECT_FALSE(ret);
541 }
542
543 HWTEST_F(DmAnonymousTest, GetAnonyInt32List_001, testing::ext::TestSize.Level0)
544 {
545 std::vector<int32_t> values = {1, 1};
546 std::string test = "[ *, * ]";
547 EXPECT_EQ(GetAnonyInt32List(values), test);
548 }
549
550 HWTEST_F(DmAnonymousTest, GetAnonyInt32List_002, testing::ext::TestSize.Level0)
551 {
552 std::vector<int32_t> values = {};
553 std::string test = "[ ]";
554 EXPECT_EQ(GetAnonyInt32List(values), test);
555 }
556
557 HWTEST_F(DmAnonymousTest, GetAnonyStringList_002, testing::ext::TestSize.Level0)
558 {
559 std::vector<std::string> valueVec = {};
560 std::string test = "[ ]";
561 EXPECT_EQ(GetAnonyStringList(valueVec), test);
562 }
563
564 HWTEST_F(DmAnonymousTest, IsNumberString_004, testing::ext::TestSize.Level0)
565 {
566 const std::string inputString = "1233214569876678012312312312455644413123123";
567 bool ret = IsNumberString(inputString);
568 EXPECT_EQ(ret, false);
569 }
570
571 HWTEST_F(DmAnonymousTest, IsNumberString_005, testing::ext::TestSize.Level0)
572 {
573 const std::string inputString = "123*+123";
574 bool ret = IsNumberString(inputString);
575 EXPECT_EQ(ret, false);
576 }
577
578 HWTEST_F(DmAnonymousTest, ConvertMapToJsonString_001, testing::ext::TestSize.Level0)
579 {
580 std::map<std::string, std::string> paramMap;
581 for (int i = 0; i < 1001; i++) {
582 paramMap[std::to_string(i)] = "value";
583 }
584 EXPECT_EQ(ConvertMapToJsonString(paramMap), "");
585 }
586
587 HWTEST_F(DmAnonymousTest, ParseMapFromJsonString_004, testing::ext::TestSize.Level0)
588 {
589 std::map<std::string, std::string> paramMap;
590 for (int i = 0; i < 1001; i++) {
591 paramMap[std::to_string(i)] = "value";
592 }
593 std::string jsonStr = "{\"key1\":\"value1\",\"key2\":\"value2\"}";
594 ParseMapFromJsonString(jsonStr, paramMap);
595 EXPECT_EQ(paramMap.size(), 1001);
596 }
597
598 HWTEST_F(DmAnonymousTest, CompareVersion_001, testing::ext::TestSize.Level0)
599 {
600 std::string remoteVersion = "1.2.3.4";
601 std::string oldVersion = "1.2.3";
602 EXPECT_EQ(CompareVersion(remoteVersion, oldVersion), true);
603 }
604
605 HWTEST_F(DmAnonymousTest, StringToInt_003, testing::ext::TestSize.Level0)
606 {
607 std::string str = "!++";
608 int32_t base = 10;
609 int32_t ret = StringToInt(str, base);
610 EXPECT_EQ(ret, 0);
611 }
612
613 HWTEST_F(DmAnonymousTest, StringToInt_004, testing::ext::TestSize.Level0)
614 {
615 std::string str = "-9223372036854775809";
616 int32_t base = 10;
617 int32_t ret = StringToInt(str, base);
618 EXPECT_EQ(ret, 0);
619 }
620
621 HWTEST_F(DmAnonymousTest, StringToInt64_003, testing::ext::TestSize.Level0)
622 {
623 std::string str = "!++";
624 int32_t base = 10;
625 int32_t ret = StringToInt64(str, base);
626 EXPECT_EQ(ret, 0);
627 }
628
629 HWTEST_F(DmAnonymousTest, StringToInt64_004, testing::ext::TestSize.Level0)
630 {
631 std::string str = "-9223372036854775809";
632 int32_t base = 10;
633 int32_t ret = StringToInt64(str, base);
634 EXPECT_EQ(ret, 0);
635 }
636
637 HWTEST_F(DmAnonymousTest, GetSubscribeId_002, testing::ext::TestSize.Level0)
638 {
639 std::string pkgName = "12345pkgName";
640 uint16_t ret = GetSubscribeId(pkgName);
641 EXPECT_EQ(ret, 0);
642 }
643
644 HWTEST_F(DmAnonymousTest, IsIdLengthValid_001, testing::ext::TestSize.Level0)
645 {
646 std::string inputID;
647 inputID.assign(300, 'A');
648 uint16_t ret = IsIdLengthValid(inputID);
649 EXPECT_EQ(ret, false);
650 inputID = "";
651 ret = IsIdLengthValid(inputID);
652 EXPECT_EQ(ret, false);
653 inputID = "123";
654 ret = IsIdLengthValid(inputID);
655 EXPECT_EQ(ret, true);
656 }
657
658 HWTEST_F(DmAnonymousTest, IsMessageLengthValid_002, testing::ext::TestSize.Level0)
659 {
660 std::string inputMessage;
661 inputMessage.assign(40 * 1024 * 1024 + 1, 'A');
662 bool ret = IsMessageLengthValid(inputMessage);
663 EXPECT_FALSE(ret);
664 }
665
666 HWTEST_F(DmAnonymousTest, IsValueExist_001, testing::ext::TestSize.Level0)
667 {
668 std::multimap<std::string, int32_t> unorderedmap = {{"1", 1}};
669 std::string udid = "1";
670 int32_t userId = 3;
671 bool ret = IsValueExist(unorderedmap, udid, userId);
672 EXPECT_FALSE(ret);
673 udid = "3";
674 ret = IsValueExist(unorderedmap, udid, 1);
675 EXPECT_FALSE(ret);
676 ret = IsValueExist(unorderedmap, udid, userId);
677 EXPECT_FALSE(ret);
678 }
679
680 HWTEST_F(DmAnonymousTest, IsDmCommonNotifyEventValid_002, testing::ext::TestSize.Level0)
681 {
682 DmCommonNotifyEvent dmCommonNotifyEvent = DmCommonNotifyEvent::MIN;
683 bool ret = IsDmCommonNotifyEventValid(dmCommonNotifyEvent);
684 EXPECT_FALSE(ret);
685 }
686
687 HWTEST_F(DmAnonymousTest, GetSubStr_001, testing::ext::TestSize.Level0)
688 {
689 std::string rawStr = "123";
690 std::string separator = "2";
691 int32_t index = 10;
692 EXPECT_EQ(GetSubStr(rawStr, separator, index), "");
693 index = -1;
694 EXPECT_EQ(GetSubStr(rawStr, separator, index), "");
695 separator = "";
696 EXPECT_EQ(GetSubStr(rawStr, separator, index), "");
697 rawStr = "";
698 EXPECT_EQ(GetSubStr(rawStr, separator, index), "");
699 }
700
701 HWTEST_F(DmAnonymousTest, GetSubscribeId_001, testing::ext::TestSize.Level0)
702 {
703 std::string pkgName = "12345#pkgName";
704 uint16_t ret = GetSubscribeId(pkgName);
705 EXPECT_GE(ret, 0);
706 }
707
708 HWTEST_F(DmAnonymousTest, GetAnonyInt32List_005, testing::ext::TestSize.Level0)
709 {
710 std::vector<int32_t> values;
711 values.push_back(101);
712 values.push_back(102);
713 std::string ret = GetAnonyInt32List(values);
714 EXPECT_FALSE(ret.empty());
715 }
716
717 HWTEST_F(DmAnonymousTest, IsIdLengthValid_002, testing::ext::TestSize.Level0)
718 {
719 std::string inputID = "";
720 bool ret = IsIdLengthValid(inputID);
721 EXPECT_FALSE(ret);
722 }
723
724 HWTEST_F(DmAnonymousTest, GetSubStr_002, testing::ext::TestSize.Level0)
725 {
726 std::string rawStr = "";
727 std::string separator = "";
728 int32_t index = 1;
729 std::string ret = GetSubStr(rawStr, separator, index);
730 EXPECT_TRUE(ret.empty());
731 }
732 } // namespace
733 } // namespace DistributedHardware
734 } // namespace OHOS
735