1 /*
2 * Copyright (c) 2022-2025 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.Level1)
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.Level1)
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.Level1)
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.Level1)
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.Level1)
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.Level1)
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.Level1)
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.Level1)
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.Level1)
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.Level1)
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.Level1)
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.Level1)
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.Level1)
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.Level1)
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.Level1)
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.Level1)
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.Level1)
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: IsUint64_001
301 * @tc.desc: Return true
302 * @tc.type: FUNC
303 * @tc.require: AR000GHSJK
304 */
305 HWTEST_F(DmAnonymousTest, IsUint64_001, testing::ext::TestSize.Level1)
306 {
307 std::string str = R"(
308 {
309 "REQUESTID" : 789
310 }
311 )";
312 JsonObject jsonObj(str);
313 bool ret = IsUint64(jsonObj, TAG_REQUEST_ID);
314 EXPECT_EQ(ret, true);
315 }
316
317 /**
318 * @tc.name: IsUint64_002
319 * @tc.desc: Return false
320 * @tc.type: FUNC
321 * @tc.require: AR000GHSJK
322 */
323 HWTEST_F(DmAnonymousTest, IsUint64_002, testing::ext::TestSize.Level1)
324 {
325 std::string str = R"(
326 {
327 "REQUESTID" : "requestidTest"
328 }
329 )";
330 JsonObject jsonObj(str);
331 bool ret = IsUint64(jsonObj, TAG_REQUEST_ID);
332 EXPECT_EQ(ret, false);
333 }
334
335 /**
336 * @tc.name: IsArray_001
337 * @tc.desc: Return true
338 * @tc.type: FUNC
339 * @tc.require: AR000GHSJK
340 */
341 HWTEST_F(DmAnonymousTest, IsArray_001, testing::ext::TestSize.Level1)
342 {
343 std::string str = R"(
344 {
345 "authType" : 1,
346 "userId" : "123",
347 "credentialData" :
348 [
349 {
350 "credentialType" : 1,
351 "credentialId" : "104",
352 "authCode" : "1234567812345678123456781234567812345678123456781234567812345678",
353 "serverPk" : "",
354 "pkInfoSignature" : "",
355 "pkInfo" : "",
356 "peerDeviceId" : ""
357 }
358 ]
359 }
360 )";
361 JsonObject jsonObj(str);
362 bool ret = IsArray(jsonObj, FIELD_CREDENTIAL_DATA);
363 EXPECT_EQ(ret, true);
364 }
365
366 /**
367 * @tc.name: IsArray_002
368 * @tc.desc: Return false
369 * @tc.type: FUNC
370 * @tc.require: AR000GHSJK
371 */
372 HWTEST_F(DmAnonymousTest, IsArray_002, testing::ext::TestSize.Level1)
373 {
374 std::string str = R"(
375 {
376 "authType" : 1,
377 "userId" : "123",
378 "credentialData" : "credentialDataTest"
379 }
380 )";
381 JsonObject jsonObj(str);
382 bool ret = IsArray(jsonObj, FIELD_CREDENTIAL_DATA);
383 EXPECT_EQ(ret, false);
384 }
385
386 /**
387 * @tc.name: IsBool_001
388 * @tc.desc: Return true
389 * @tc.type: FUNC
390 * @tc.require: AR000GHSJK
391 */
392 HWTEST_F(DmAnonymousTest, IsBool_001, testing::ext::TestSize.Level1)
393 {
394 std::string str = R"(
395 {
396 "CRYPTOSUPPORT" : false,
397 "userId" : "123",
398 "credentialData" : "credentialDataTest"
399 }
400 )";
401 JsonObject jsonObj(str);
402 bool ret = IsBool(jsonObj, TAG_CRYPTO_SUPPORT);
403 EXPECT_EQ(ret, true);
404 }
405
406 /**
407 * @tc.name: IsBool_002
408 * @tc.desc: Return false
409 * @tc.type: FUNC
410 * @tc.require: AR000GHSJK
411 */
412 HWTEST_F(DmAnonymousTest, IsBool_002, testing::ext::TestSize.Level1)
413 {
414 std::string str = R"(
415 {
416 "CRYPTOSUPPORT" : "cryptosupportTest",
417 "userId" : "123",
418 "credentialData" : "credentialDataTest"
419 }
420 )";
421 JsonObject jsonObj(str);
422 bool ret = IsBool(jsonObj, TAG_CRYPTO_SUPPORT);
423 EXPECT_EQ(ret, false);
424 }
425
426 /**
427 * @tc.name: ConvertCharArray2String_001
428 * @tc.desc: Return false
429 * @tc.type: FUNC
430 * @tc.require: AR000GHSJK
431 */
432 HWTEST_F(DmAnonymousTest, ConvertCharArray2String_001, testing::ext::TestSize.Level1)
433 {
434 constexpr uint32_t MAX_MESSAGE_LEN = 40 * 1024 * 1024;
435 char *srcData = nullptr;
436 uint32_t srcLen = 0;
437 std::string ret = ConvertCharArray2String(srcData, srcLen);
438 EXPECT_EQ(ret, "");
439 ret = ConvertCharArray2String(srcData, MAX_MESSAGE_LEN + 1);
440 EXPECT_EQ(ret, "");
441 char srcData2[20] = {"1234"};
442 ret = ConvertCharArray2String(srcData2, MAX_MESSAGE_LEN + 1);
443 EXPECT_EQ(ret, "");
444 uint32_t srcLen2 = 20;
445 ret = ConvertCharArray2String(srcData2, srcLen);
446 EXPECT_EQ(ret, "");
447 ret = ConvertCharArray2String(srcData, srcLen2);
448 EXPECT_EQ(ret, "");
449 ret = ConvertCharArray2String(srcData2, srcLen2);
450 EXPECT_EQ(ret, "1234");
451 }
452
453 HWTEST_F(DmAnonymousTest, StringToInt_001, testing::ext::TestSize.Level1)
454 {
455 std::string str = "12344";
456 int32_t base = 10;
457 int32_t ret = StringToInt(str, base);
458 EXPECT_EQ(ret, 12344);
459 }
460
461 HWTEST_F(DmAnonymousTest, StringToInt_002, testing::ext::TestSize.Level1)
462 {
463 std::string str;
464 int32_t base = 10;
465 int32_t ret = StringToInt(str, base);
466 EXPECT_EQ(ret, 0);
467 }
468
469 HWTEST_F(DmAnonymousTest, StringToInt64_001, testing::ext::TestSize.Level1)
470 {
471 std::string str;
472 int32_t base = 10;
473 int64_t ret = StringToInt64(str, base);
474 EXPECT_EQ(ret, 0);
475 }
476
477
478 HWTEST_F(DmAnonymousTest, ParseMapFromJsonString_001, testing::ext::TestSize.Level1)
479 {
480 std::string jsonStr = R"(
481 {
482 "authType" : 1,
483 "userId" : "123",
484 "credentialData" :
485 [
486 {
487 "CRYPTOSUPPORT" : "cryptosupportTest",
488 "credentialType" : 1,
489 "credentialId" : "104",
490 "authCode" : "1234567812345678123456781234567812345678123456781234567812345678",
491 "serverPk" : "hello",
492 "pkInfoSignature" : "world",
493 "pkInfo" : "pkginfo",
494 "peerDeviceId" : "3515656546"
495 }
496 ]
497 }
498 )";
499 std::map<std::string, std::string> paramMap;
500 JsonObject jsonObj(jsonStr);
501 ParseMapFromJsonString(jsonStr, paramMap);
502 EXPECT_GE(paramMap.size(), 0);
503 }
504
505 HWTEST_F(DmAnonymousTest, ParseMapFromJsonString_002, testing::ext::TestSize.Level1)
506 {
507 std::string jsonStr = R"(
508 {
509 "authType" : 1,
510 "userId" : "123",
511 "credentialData" :
512 [
513 {
514 "CRYPTOSUPPORT" : "cryptosupportTest",
515 "credentialType" : 1,
516 "credentialId" : "104",
517 "authCode" : "1234567812345678123456781234567812345678123456781234567812345678",
518 "serverPk" : "hello",
519 "pkInfoSignature" : "world",
520 "pkInfo" : "pkginfo",
521 "peerDeviceId" : "3515656546"
522 }
523 ]
524 )";
525 std::map<std::string, std::string> paramMap;
526 JsonObject jsonObj(jsonStr);
527 ParseMapFromJsonString(jsonStr, paramMap);
528 EXPECT_EQ(paramMap.size(), 0);
529 }
530
531 HWTEST_F(DmAnonymousTest, ParseMapFromJsonString_003, testing::ext::TestSize.Level1)
532 {
533 std::string jsonStr = "";
534 std::map<std::string, std::string> paramMap;
535 JsonObject jsonObj(jsonStr);
536 ParseMapFromJsonString(jsonStr, paramMap);
537 EXPECT_EQ(paramMap.size(), 0);
538 }
539
540 HWTEST_F(DmAnonymousTest, GetAnonyStringList_001, testing::ext::TestSize.Level1)
541 {
542 std::string value = "valueTest";
543 std::vector<std::string> valueVec;
544 valueVec.push_back(value);
545 std::string str = GetAnonyStringList(valueVec);
546 auto ret = str.size();
547 EXPECT_GE(ret, 0);
548 }
549
550 HWTEST_F(DmAnonymousTest, StringToInt64_002, testing::ext::TestSize.Level1)
551 {
552 std::string str = "12345";
553 int32_t base = 10;
554 int32_t ret = StringToInt64(str, base);
555 EXPECT_EQ(ret, 12345);
556 }
557
558 HWTEST_F(DmAnonymousTest, GetCallerPkgName_001, testing::ext::TestSize.Level1)
559 {
560 std::string str = "pkgName#12345";
561 std::string ret = GetCallerPkgName(str);
562 EXPECT_FALSE(ret.empty());
563 }
564
565 HWTEST_F(DmAnonymousTest, IsMessageLengthValid_001, testing::ext::TestSize.Level1)
566 {
567 std::string inputMessage;
568 bool ret = IsMessageLengthValid(inputMessage);
569 EXPECT_FALSE(ret);
570 }
571
572 HWTEST_F(DmAnonymousTest, IsDmCommonNotifyEventValid_001, testing::ext::TestSize.Level1)
573 {
574 DmCommonNotifyEvent dmCommonNotifyEvent = DmCommonNotifyEvent::MAX;
575 bool ret = IsDmCommonNotifyEventValid(dmCommonNotifyEvent);
576 EXPECT_FALSE(ret);
577 }
578
579 HWTEST_F(DmAnonymousTest, GetAnonyInt32List_001, testing::ext::TestSize.Level1)
580 {
581 std::vector<int32_t> values = {1, 1};
582 std::string test = "[ *, * ]";
583 EXPECT_EQ(GetAnonyInt32List(values), test);
584 }
585
586 HWTEST_F(DmAnonymousTest, GetAnonyInt32List_002, testing::ext::TestSize.Level1)
587 {
588 std::vector<int32_t> values = {};
589 std::string test = "[ ]";
590 EXPECT_EQ(GetAnonyInt32List(values), test);
591 }
592
593 HWTEST_F(DmAnonymousTest, GetAnonyStringList_002, testing::ext::TestSize.Level1)
594 {
595 std::vector<std::string> valueVec = {};
596 std::string test = "[ ]";
597 EXPECT_EQ(GetAnonyStringList(valueVec), test);
598 }
599
600 HWTEST_F(DmAnonymousTest, IsNumberString_004, testing::ext::TestSize.Level1)
601 {
602 const std::string inputString = "1233214569876678012312312312455644413123123";
603 bool ret = IsNumberString(inputString);
604 EXPECT_EQ(ret, false);
605 }
606
607 HWTEST_F(DmAnonymousTest, IsNumberString_005, testing::ext::TestSize.Level1)
608 {
609 const std::string inputString = "123*+123";
610 bool ret = IsNumberString(inputString);
611 EXPECT_EQ(ret, false);
612 }
613
614 HWTEST_F(DmAnonymousTest, ConvertMapToJsonString_001, testing::ext::TestSize.Level1)
615 {
616 std::map<std::string, std::string> paramMap;
617 for (int i = 0; i < 1001; i++) {
618 paramMap[std::to_string(i)] = "value";
619 }
620 EXPECT_EQ(ConvertMapToJsonString(paramMap), "");
621 }
622
623 HWTEST_F(DmAnonymousTest, ParseMapFromJsonString_004, testing::ext::TestSize.Level1)
624 {
625 std::map<std::string, std::string> paramMap;
626 for (int i = 0; i < 1001; i++) {
627 paramMap[std::to_string(i)] = "value";
628 }
629 std::string jsonStr = "{\"key1\":\"value1\",\"key2\":\"value2\"}";
630 ParseMapFromJsonString(jsonStr, paramMap);
631 EXPECT_EQ(paramMap.size(), 1001);
632 }
633
634 HWTEST_F(DmAnonymousTest, CompareVersion_001, testing::ext::TestSize.Level1)
635 {
636 std::string remoteVersion = "1.2.3.4";
637 std::string oldVersion = "1.2.3";
638 EXPECT_EQ(CompareVersion(remoteVersion, oldVersion), true);
639 }
640
641 HWTEST_F(DmAnonymousTest, StringToInt_003, testing::ext::TestSize.Level1)
642 {
643 std::string str = "!++";
644 int32_t base = 10;
645 int32_t ret = StringToInt(str, base);
646 EXPECT_EQ(ret, 0);
647 }
648
649 HWTEST_F(DmAnonymousTest, StringToInt_004, testing::ext::TestSize.Level1)
650 {
651 std::string str = "-9223372036854775809";
652 int32_t base = 10;
653 int32_t ret = StringToInt(str, base);
654 EXPECT_EQ(ret, 0);
655 }
656
657 HWTEST_F(DmAnonymousTest, StringToInt64_003, testing::ext::TestSize.Level1)
658 {
659 std::string str = "!++";
660 int32_t base = 10;
661 int32_t ret = StringToInt64(str, base);
662 EXPECT_EQ(ret, 0);
663 }
664
665 HWTEST_F(DmAnonymousTest, StringToInt64_004, testing::ext::TestSize.Level1)
666 {
667 std::string str = "-9223372036854775809";
668 int32_t base = 10;
669 int32_t ret = StringToInt64(str, base);
670 EXPECT_EQ(ret, 0);
671 }
672
673 HWTEST_F(DmAnonymousTest, GetSubscribeId_002, testing::ext::TestSize.Level1)
674 {
675 std::string pkgName = "12345pkgName";
676 uint16_t ret = GetSubscribeId(pkgName);
677 EXPECT_EQ(ret, 0);
678 }
679
680 HWTEST_F(DmAnonymousTest, IsIdLengthValid_001, testing::ext::TestSize.Level1)
681 {
682 std::string inputID;
683 inputID.assign(300, 'A');
684 uint16_t ret = IsIdLengthValid(inputID);
685 EXPECT_EQ(ret, false);
686 inputID = "";
687 ret = IsIdLengthValid(inputID);
688 EXPECT_EQ(ret, false);
689 inputID = "123";
690 ret = IsIdLengthValid(inputID);
691 EXPECT_EQ(ret, true);
692 }
693
694 HWTEST_F(DmAnonymousTest, IsMessageLengthValid_002, testing::ext::TestSize.Level1)
695 {
696 std::string inputMessage;
697 inputMessage.assign(40 * 1024 * 1024 + 1, 'A');
698 bool ret = IsMessageLengthValid(inputMessage);
699 EXPECT_FALSE(ret);
700 }
701
702 HWTEST_F(DmAnonymousTest, IsValueExist_001, testing::ext::TestSize.Level1)
703 {
704 std::multimap<std::string, int32_t> unorderedmap = {{"1", 1}};
705 std::string udid = "1";
706 int32_t userId = 3;
707 bool ret = IsValueExist(unorderedmap, udid, userId);
708 EXPECT_FALSE(ret);
709 udid = "3";
710 ret = IsValueExist(unorderedmap, udid, 1);
711 EXPECT_FALSE(ret);
712 ret = IsValueExist(unorderedmap, udid, userId);
713 EXPECT_FALSE(ret);
714 }
715
716 HWTEST_F(DmAnonymousTest, IsDmCommonNotifyEventValid_002, testing::ext::TestSize.Level1)
717 {
718 DmCommonNotifyEvent dmCommonNotifyEvent = DmCommonNotifyEvent::MIN;
719 bool ret = IsDmCommonNotifyEventValid(dmCommonNotifyEvent);
720 EXPECT_FALSE(ret);
721 }
722
723 HWTEST_F(DmAnonymousTest, GetSubStr_001, testing::ext::TestSize.Level1)
724 {
725 std::string rawStr = "123";
726 std::string separator = "2";
727 int32_t index = 10;
728 EXPECT_EQ(GetSubStr(rawStr, separator, index), "");
729 index = -1;
730 EXPECT_EQ(GetSubStr(rawStr, separator, index), "");
731 separator = "";
732 EXPECT_EQ(GetSubStr(rawStr, separator, index), "");
733 rawStr = "";
734 EXPECT_EQ(GetSubStr(rawStr, separator, index), "");
735 }
736
737 HWTEST_F(DmAnonymousTest, GetSubscribeId_001, testing::ext::TestSize.Level1)
738 {
739 std::string pkgName = "12345#pkgName";
740 uint16_t ret = GetSubscribeId(pkgName);
741 EXPECT_GE(ret, 0);
742 }
743
744 HWTEST_F(DmAnonymousTest, GetAnonyInt32List_005, testing::ext::TestSize.Level1)
745 {
746 std::vector<int32_t> values;
747 values.push_back(101);
748 values.push_back(102);
749 std::string ret = GetAnonyInt32List(values);
750 EXPECT_FALSE(ret.empty());
751 }
752
753 HWTEST_F(DmAnonymousTest, IsIdLengthValid_002, testing::ext::TestSize.Level1)
754 {
755 std::string inputID = "";
756 bool ret = IsIdLengthValid(inputID);
757 EXPECT_FALSE(ret);
758 }
759
760 HWTEST_F(DmAnonymousTest, GetSubStr_002, testing::ext::TestSize.Level1)
761 {
762 std::string rawStr = "";
763 std::string separator = "";
764 int32_t index = 1;
765 std::string ret = GetSubStr(rawStr, separator, index);
766 EXPECT_TRUE(ret.empty());
767 }
768 } // namespace
769 } // namespace DistributedHardware
770 } // namespace OHOS
771