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 <cstdio>
17 #include <ctime>
18 #include <gtest/gtest.h>
19 #include <sys/time.h>
20 #include <unistd.h>
21 #include <securec.h>
22 #include <cstdint>
23
24 #include "disc_manager.h"
25 #include "softbus_log.h"
26 #include "nstackx.h"
27 #include "disc_coap.h"
28 #include "softbus_errcode.h"
29
30 #define TEST_ERRO_MOUDULE1 ((MODULE_LNN) - 1)
31 #define TEST_ERRO_MOUDULE2 ((MODULE_LNN) - 2)
32 #define TEST_ERRO_MOUDULE ((MODULE_LNN) + 3)
33 #define ERRO_CAPDATA_LEN (MAX_CAPABILITYDATA_LEN + 1)
34 #define TEST_ASSERT_TRUE(ret) \
35 if (ret) { \
36 LOG_INFO("[succ]\n"); \
37 g_succTestCount++; \
38 } else { \
39 LOG_INFO("[error]\n"); \
40 g_failTestCount++; \
41 }
42
43
44 using namespace testing::ext;
45
46 namespace OHOS {
47 static int32_t g_succTestCount = 0;
48 static int32_t g_failTestCount = 0;
49 static int32_t g_devieceFoundCount = 0;
50 static const char *g_corrPkgName = "CorrCorrCorrCorrCorrCorrCorrCorrCorrCorrCorrCorrCorrCorrCorrCorr";
51 static const char *g_erroPkgName = "ErroErroErroErroErroErroErroErroErroErroErroErroErroErroErroErroE";
52 static DiscoveryFuncInterface *g_coapDiscFunc = NULL;
53 static PublishOption g_publishOption = {.freq = 0, .capabilityBitmap = {1}, .capabilityData = NULL, .dataLen = 0};
54 static SubscribeOption g_subscribeOption = {.freq = 1,
55 .isSameAccount = true,
56 .isWakeRemote = false,
57 .capabilityBitmap = {2},
58 .capabilityData = NULL,
59 .dataLen = 0
60 };
61
62 const int32_t TEST_PUBLISHINNER_ID = 1;
63 const int32_t TEST_PUBLISH_ID = 2;
64 const int32_t TEST_SUBSCRIBEINNER_ID = 3;
65 const int32_t TEST_SUBSCRIBE_ID = 4;
66 const int32_t TEST_PUBLISHINNER_ID1 = 5;
67 const int32_t TEST_PUBLISH_ID1 = 6;
68 const int32_t TEST_SUBSCRIBEINNER_ID1 = 7;
69 const int32_t TEST_SUBSCRIBE_ID1 = 8;
70 const int32_t TEST_BITMAP_CAP = 127;
71
72 class Disc_ManagerTest : public testing::Test {
73 public:
Disc_ManagerTest()74 Disc_ManagerTest()
75 {}
~Disc_ManagerTest()76 ~Disc_ManagerTest()
77 {}
78 static void SetUpTestCase(void);
79 static void TearDownTestCase(void);
SetUp()80 void SetUp() override
81 {}
TearDown()82 void TearDown() override
83 {}
84 };
85
SetUpTestCase(void)86 void Disc_ManagerTest::SetUpTestCase(void)
87 {}
88
TearDownTestCase(void)89 void Disc_ManagerTest::TearDownTestCase(void)
90 {}
91
TestDeviceFound(const char * packageName,const DeviceInfo * device,const InnerDeviceInfoAddtions * addtions)92 static int32_t TestDeviceFound(const char *packageName, const DeviceInfo *device,
93 const InnerDeviceInfoAddtions *addtions)
94 {
95 (void)addtions;
96 g_devieceFoundCount++;
97 LOG_INFO("[device found]success!\n");
98 return 0;
99 }
100
TestInnerDeviceFound(const DeviceInfo * device,const InnerDeviceInfoAddtions * addtions)101 static void TestInnerDeviceFound(const DeviceInfo *device, const InnerDeviceInfoAddtions *addtions)
102 {
103 (void)device;
104 (void)addtions;
105 g_devieceFoundCount++;
106 LOG_INFO("[inner device found]success!\n");
107 }
108
109 static DiscInnerCallback g_innerCallback = {
110 .OnDeviceFound = TestInnerDeviceFound
111 };
112
DiscCoapStartDiscovery(uint32_t filterCapBitmap,uint32_t discMode)113 static int32_t DiscCoapStartDiscovery(uint32_t filterCapBitmap, uint32_t discMode)
114 {
115 if (g_coapDiscFunc == NULL) {
116 printf("g_coapDiscFunc is NULL.\n");
117 return SOFTBUS_ERR;
118 }
119
120 g_subscribeOption.capabilityBitmap[0] = filterCapBitmap;
121 switch (discMode) {
122 case 0:
123 if (g_coapDiscFunc->Subscribe(&g_subscribeOption) != 0) {
124 printf("passivce start discvoery failed.\n");
125 return SOFTBUS_ERR;
126 }
127 break;
128 case 1:
129 if (g_coapDiscFunc->StartAdvertise(&g_subscribeOption) != 0) {
130 printf("active start discvoery failed.\n");
131 return SOFTBUS_ERR;
132 }
133 break;
134 default:
135 printf("unsupport mode.\n");
136 return SOFTBUS_ERR;
137 }
138 return SOFTBUS_OK;
139 }
140
DiscCoapStopDiscovery(uint32_t filterCapBitmap,uint32_t discMode)141 static int32_t DiscCoapStopDiscovery(uint32_t filterCapBitmap, uint32_t discMode)
142 {
143 if (g_coapDiscFunc == NULL) {
144 return SOFTBUS_ERR;
145 }
146
147 g_subscribeOption.capabilityBitmap[0] = filterCapBitmap;
148 switch (discMode) {
149 case 0:
150 if (g_coapDiscFunc->Unsubscribe(&g_subscribeOption) != 0) {
151 return SOFTBUS_ERR;
152 }
153 break;
154 case 1:
155 if (g_coapDiscFunc->StopAdvertise(&g_subscribeOption) != 0) {
156 return SOFTBUS_ERR;
157 }
158 break;
159 default:
160 return SOFTBUS_ERR;
161 }
162 return SOFTBUS_OK;
163 }
164
DiscCoapUnpulbishService(uint32_t pubCapBitmap,uint32_t publishMode)165 static int32_t DiscCoapUnpulbishService(uint32_t pubCapBitmap, uint32_t publishMode)
166 {
167 if (g_coapDiscFunc == NULL) {
168 printf("g_coapDiscFunc is NULL.\n");
169 return SOFTBUS_ERR;
170 }
171
172 g_publishOption.capabilityBitmap[0] = pubCapBitmap;
173 switch (publishMode) {
174 case 0:
175 if (g_coapDiscFunc->StopScan(&g_publishOption) != 0) {
176 printf("passive unpublish failed.\n");
177 return SOFTBUS_ERR;
178 }
179 break;
180 case 1:
181 if (g_coapDiscFunc->Unpublish(&g_publishOption) != 0) {
182 printf("active unpublish failed.\n");
183 return SOFTBUS_ERR;
184 }
185 break;
186 default:
187 printf("unsupport mode.\n");
188 return SOFTBUS_ERR;
189 }
190 return SOFTBUS_OK;
191 }
192
193 static DiscInnerCallback g_discInnerCb = {
194 .OnDeviceFound = NULL
195 };
196
197 static IServerDiscInnerCallback g_subscribeCb = {
198 .OnServerDeviceFound = TestDeviceFound
199 };
200
201 static PublishInfo g_pInnerInfo = {
202 .publishId = TEST_PUBLISHINNER_ID,
203 .mode = DISCOVER_MODE_PASSIVE,
204 .medium = COAP,
205 .freq = LOW,
206 .capability = "hicall",
207 .capabilityData = (unsigned char *)"capdata1",
208 .dataLen = sizeof("capdata1")
209 };
210
211 static PublishInfo g_pInfo = {
212 .publishId = TEST_PUBLISH_ID,
213 .mode = DISCOVER_MODE_ACTIVE,
214 .medium = COAP,
215 .freq = MID,
216 .capability = "dvKit",
217 .capabilityData = (unsigned char *)"capdata2",
218 .dataLen = sizeof("capdata2")
219 };
220
221 static SubscribeInfo g_sInnerInfo = {
222 .subscribeId = TEST_SUBSCRIBEINNER_ID,
223 .mode = DISCOVER_MODE_ACTIVE,
224 .medium = COAP,
225 .freq = MID,
226 .isSameAccount = true,
227 .isWakeRemote = false,
228 .capability = "dvKit",
229 .capabilityData = (unsigned char *)"capdata3",
230 .dataLen = sizeof("capdata3")
231 };
232
233 static SubscribeInfo g_sInfo = {
234 .subscribeId = TEST_SUBSCRIBE_ID,
235 .mode = DISCOVER_MODE_ACTIVE,
236 .medium = COAP,
237 .freq = MID,
238 .isSameAccount = true,
239 .isWakeRemote = false,
240 .capability = "hicall",
241 .capabilityData = (unsigned char *)"capdata4",
242 .dataLen = sizeof("capdata4")
243 };
244
245 static PublishInfo g_pInnerInfo1 = {
246 .publishId = TEST_PUBLISHINNER_ID1,
247 .mode = DISCOVER_MODE_ACTIVE,
248 .medium = COAP,
249 .freq = LOW,
250 .capability = "hicall",
251 .capabilityData = NULL,
252 .dataLen = 0
253 };
254
255 static PublishInfo g_pInfo1 = {
256 .publishId = TEST_PUBLISH_ID1,
257 .mode = DISCOVER_MODE_ACTIVE,
258 .medium = COAP,
259 .freq = MID,
260 .capability = "dvKit",
261 .capabilityData = NULL,
262 .dataLen = 0
263 };
264
265 static SubscribeInfo g_sInnerInfo1 = {
266 .subscribeId = TEST_SUBSCRIBEINNER_ID1,
267 .mode = DISCOVER_MODE_PASSIVE,
268 .medium = COAP,
269 .freq = MID,
270 .isSameAccount = true,
271 .isWakeRemote = false,
272 .capability = "dvKit",
273 .capabilityData = NULL,
274 .dataLen = 0
275 };
276
277 static SubscribeInfo g_sInfo1 = {
278 .subscribeId = TEST_SUBSCRIBE_ID1,
279 .mode = DISCOVER_MODE_ACTIVE,
280 .medium = COAP,
281 .freq = MID,
282 .isSameAccount = true,
283 .isWakeRemote = false,
284 .capability = "hicall",
285 .capabilityData = NULL,
286 .dataLen = 0
287 };
288
289 /**
290 * @tc.name: DiscPublishTest001
291 * @tc.desc: Test inner module active publish，but softbus discover manager is not init.
292 * @tc.in: Test Module, Test Number, Test Levels.
293 * @tc.out: Nonzero
294 * @tc.type: FUNC
295 * @tc.require: The DiscPublish operates normally.
296 */
297 HWTEST_F(Disc_ManagerTest, DiscPublishTest001, TestSize.Level1)
298 {
299 int ret;
300 ret = DiscPublish(MODULE_CONN, &g_pInnerInfo);
301 TEST_ASSERT_TRUE(ret != 0);
302 }
303
304 /**
305 * @tc.name: DiscPublishTest002
306 * @tc.desc: Test inner module active publish, use wrong Medium and Freq Under the COAP of MODULE_LNN.
307 * @tc.in: Test Module, Test Number, Test Levels.
308 * @tc.out: Nonzero
309 * @tc.type: FUNC
310 * @tc.require: The DiscPublish operates normally.
311 */
312 HWTEST_F(Disc_ManagerTest, DiscPublishTest002, TestSize.Level1)
313 {
314 int ret;
315 PublishInfo testInfo = {
316 .publishId = TEST_PUBLISHINNER_ID,
317 .mode = DISCOVER_MODE_ACTIVE,
318 .medium = COAP,
319 .freq = LOW,
320 .capability = "hicall",
321 .capabilityData = (unsigned char *)"capdata1",
322 .dataLen = sizeof("capdata1")
323 };
324
325 DiscMgrInit();
326
327 ret = DiscPublish((DiscModule)TEST_ERRO_MOUDULE, &testInfo);
328 TEST_ASSERT_TRUE(ret != 0);
329
330 testInfo.medium = (ExchangeMedium)(COAP + 1);
331 ret = DiscPublish(MODULE_LNN, &testInfo);
332 TEST_ASSERT_TRUE(ret != 0);
333 testInfo.medium = COAP;
334
335 testInfo.freq = (ExchangeFreq)(SUPER_HIGH + 1);
336 ret = DiscPublish(MODULE_LNN, &testInfo);
337 TEST_ASSERT_TRUE(ret != 0);
338 testInfo.freq = LOW;
339
340 testInfo.capability = "hicall";
341 testInfo.capabilityData = NULL;
342 ret = DiscPublish(MODULE_LNN, &testInfo);
343 TEST_ASSERT_TRUE(ret != 0);
344 testInfo.capabilityData = (unsigned char *)"capdata1";
345
346 testInfo.dataLen = ERRO_CAPDATA_LEN;
347 ret = DiscPublish(MODULE_LNN, &testInfo);
348 TEST_ASSERT_TRUE(ret != 0);
349 testInfo.dataLen = sizeof("capdata1");
350
351 DiscMgrDeinit();
352 }
353
354 /**
355 * @tc.name: DiscPublishTest003
356 * @tc.desc: Inner LNN module active publish，use the normal parameter.
357 * @tc.in: test module, test number, Test Levels.
358 * @tc.out: Zero
359 * @tc.type: FUNC
360 * @tc.require: The DiscPublish operates normally.
361 */
362 HWTEST_F(Disc_ManagerTest, DiscPublishTest003, TestSize.Level1)
363 {
364 int ret;
365 DiscMgrInit();
366
367 ret = DiscPublish(MODULE_LNN, &g_pInnerInfo);
368 TEST_ASSERT_TRUE(ret != 0);
369
370 ret = DiscPublish(MODULE_LNN, &g_pInnerInfo1);
371 TEST_ASSERT_TRUE(ret == 0);
372
373 DiscMgrDeinit();
374 }
375
376 /**
377 * @tc.name: DiscPublishTest004
378 * @tc.desc: Inner module active publish，use the wrong parameter.
379 * @tc.in: test module, test number, Test Levels.
380 * @tc.out: Nonzero
381 * @tc.type: FUNC
382 * @tc.require: The DiscPublish operates normally.
383 */
384 HWTEST_F(Disc_ManagerTest, DiscPublishTest004, TestSize.Level1)
385 {
386 int ret;
387 DiscMgrInit();
388
389 ret = DiscPublish(MODULE_LNN, &g_pInnerInfo1);
390 TEST_ASSERT_TRUE(ret == 0);
391
392 ret = DiscPublish(MODULE_LNN, &g_pInnerInfo1);
393 TEST_ASSERT_TRUE(ret != 0);
394
395 DiscMgrDeinit();
396 }
397
398 /**
399 * @tc.name: DiscPublishTest005
400 * @tc.desc: Test inner module active publish，but softbus discover manager is not init.
401 * @tc.in: Test Module, Test Number, Test Levels.
402 * @tc.out: Nonzero
403 * @tc.type: FUNC
404 * @tc.require: The DiscPublish operates normally.
405 */
406 HWTEST_F(Disc_ManagerTest, DiscPublishTest005, TestSize.Level1)
407 {
408 int ret;
409 PublishInfo testInfo = {
410 .publishId = TEST_PUBLISHINNER_ID,
411 .mode = DISCOVER_MODE_ACTIVE,
412 .medium = COAP,
413 .freq = LOW,
414 .capability = "hicall",
415 .capabilityData = (unsigned char*)"capdata1",
416 .dataLen = sizeof("capdata1")
417 };
418
419 ret = DiscPublish(MODULE_LNN, &testInfo);
420 TEST_ASSERT_TRUE(ret != 0);
421 }
422
423 /**
424 * @tc.name: DiscPublishTest006
425 * @tc.desc: Test inner module active publish, use Diff Freq Under the AUTO of MODULE_LNN.
426 * @tc.in: Test Module, Test Number, Test Levels.
427 * @tc.out: Zero
428 * @tc.type: FUNC
429 * @tc.require: The DiscPublish operates normally.
430 */
431 HWTEST_F(Disc_ManagerTest, DiscPublishTest006, TestSize.Level1)
432 {
433 int ret;
434 PublishInfo testInfo = {
435 .publishId = TEST_PUBLISHINNER_ID,
436 .mode = DISCOVER_MODE_ACTIVE,
437 .medium = AUTO,
438 .freq = LOW,
439 .capability = "hicall",
440 .capabilityData = (unsigned char *)"capdata1",
441 .dataLen = sizeof("capdata1")
442 };
443
444 DiscMgrInit();
445
446 ret = DiscPublish(MODULE_LNN, &testInfo);
447 TEST_ASSERT_TRUE(ret == 0);
448 DiscUnpublish(MODULE_LNN, testInfo.publishId);
449
450 testInfo.freq = MID;
451 ret = DiscPublish(MODULE_LNN, &testInfo);
452 TEST_ASSERT_TRUE(ret == 0);
453 DiscUnpublish(MODULE_LNN, testInfo.publishId);
454
455 testInfo.freq = HIGH;
456 ret = DiscPublish(MODULE_LNN, &testInfo);
457 TEST_ASSERT_TRUE(ret == 0);
458 DiscUnpublish(MODULE_LNN, testInfo.publishId);
459
460 testInfo.freq = SUPER_HIGH;
461 ret = DiscPublish(MODULE_LNN, &testInfo);
462 TEST_ASSERT_TRUE(ret == 0);
463 DiscUnpublish(MODULE_LNN, testInfo.publishId);
464
465 DiscMgrDeinit();
466 }
467
468 /**
469 * @tc.name: DiscPublishTest007
470 * @tc.desc: Test inner module active publish, use Diff Freq Under the AUTO of MODULE_CONN.
471 * @tc.in: Test Module, Test Number, Test Levels.
472 * @tc.out: Zero
473 * @tc.type: FUNC
474 * @tc.require: The DiscPublish operates normally.
475 */
476 HWTEST_F(Disc_ManagerTest, DiscPublishTest007, TestSize.Level1)
477 {
478 int ret;
479 PublishInfo testInfo = {
480 .publishId = TEST_PUBLISHINNER_ID,
481 .mode = DISCOVER_MODE_ACTIVE,
482 .medium = AUTO,
483 .freq = LOW,
484 .capability = "hicall",
485 .capabilityData = (unsigned char *)"capdata1",
486 .dataLen = sizeof("capdata1")
487 };
488
489 DiscMgrInit();
490
491 ret = DiscPublish(MODULE_CONN, &testInfo);
492 TEST_ASSERT_TRUE(ret == 0);
493 DiscUnpublish(MODULE_CONN, testInfo.publishId);
494
495 testInfo.freq = MID;
496 ret = DiscPublish(MODULE_CONN, &testInfo);
497 TEST_ASSERT_TRUE(ret == 0);
498 DiscUnpublish(MODULE_CONN, testInfo.publishId);
499
500 testInfo.freq = HIGH;
501 ret = DiscPublish(MODULE_CONN, &testInfo);
502 TEST_ASSERT_TRUE(ret == 0);
503 DiscUnpublish(MODULE_CONN, testInfo.publishId);
504
505 testInfo.freq = SUPER_HIGH;
506 ret = DiscPublish(MODULE_CONN, &testInfo);
507 TEST_ASSERT_TRUE(ret == 0);
508 DiscUnpublish(MODULE_CONN, testInfo.publishId);
509
510 DiscMgrDeinit();
511 }
512
513 /**
514 * @tc.name: DiscPublishTest008
515 * @tc.desc: Test inner module active publish, use Diff Freq Under the BLE of MODULE_LNN.
516 * @tc.in: Test Module, Test Number, Test Levels.
517 * @tc.out: Zero
518 * @tc.type: FUNC
519 * @tc.require: The DiscPublish operates normally.
520 */
521 HWTEST_F(Disc_ManagerTest, DiscPublishTest008, TestSize.Level1)
522 {
523 int ret;
524 PublishInfo testInfo = {
525 .publishId = TEST_PUBLISHINNER_ID,
526 .mode = DISCOVER_MODE_ACTIVE,
527 .medium = BLE,
528 .freq = LOW,
529 .capability = "hicall",
530 .capabilityData = (unsigned char *)"capdata1",
531 .dataLen = sizeof("capdata1")
532 };
533
534 DiscMgrInit();
535
536 ret = DiscPublish(MODULE_LNN, &testInfo);
537 TEST_ASSERT_TRUE(ret == 0);
538 DiscUnpublish(MODULE_LNN, testInfo.publishId);
539
540 testInfo.freq = MID;
541 ret = DiscPublish(MODULE_LNN, &testInfo);
542 TEST_ASSERT_TRUE(ret == 0);
543 DiscUnpublish(MODULE_LNN, testInfo.publishId);
544
545 testInfo.freq = HIGH;
546 ret = DiscPublish(MODULE_LNN, &testInfo);
547 TEST_ASSERT_TRUE(ret == 0);
548 DiscUnpublish(MODULE_LNN, testInfo.publishId);
549
550 testInfo.freq = SUPER_HIGH;
551 ret = DiscPublish(MODULE_LNN, &testInfo);
552 TEST_ASSERT_TRUE(ret == 0);
553 DiscUnpublish(MODULE_LNN, testInfo.publishId);
554
555 DiscMgrDeinit();
556 }
557
558 /**
559 * @tc.name: DiscPublishTest009
560 * @tc.desc: Test inner module active publish, use Diff Freq Under the BLE of MODULE_CONN.
561 * @tc.in: Test Module, Test Number, Test Levels.
562 * @tc.out: Zero
563 * @tc.type: FUNC
564 * @tc.require: The DiscPublish operates normally.
565 */
566 HWTEST_F(Disc_ManagerTest, DiscPublishTest009, TestSize.Level1)
567 {
568 int ret;
569 PublishInfo testInfo = {
570 .publishId = TEST_PUBLISHINNER_ID,
571 .mode = DISCOVER_MODE_ACTIVE,
572 .medium = BLE,
573 .freq = LOW,
574 .capability = "hicall",
575 .capabilityData = (unsigned char *)"capdata1",
576 .dataLen = sizeof("capdata1")
577 };
578
579 DiscMgrInit();
580
581 ret = DiscPublish(MODULE_CONN, &testInfo);
582 TEST_ASSERT_TRUE(ret == 0);
583 DiscUnpublish(MODULE_CONN, testInfo.publishId);
584
585 testInfo.freq = MID;
586 ret = DiscPublish(MODULE_CONN, &testInfo);
587 TEST_ASSERT_TRUE(ret == 0);
588 DiscUnpublish(MODULE_CONN, testInfo.publishId);
589
590 testInfo.freq = HIGH;
591 ret = DiscPublish(MODULE_CONN, &testInfo);
592 TEST_ASSERT_TRUE(ret == 0);
593 DiscUnpublish(MODULE_CONN, testInfo.publishId);
594
595 testInfo.freq = SUPER_HIGH;
596 ret = DiscPublish(MODULE_CONN, &testInfo);
597 TEST_ASSERT_TRUE(ret == 0);
598 DiscUnpublish(MODULE_CONN, testInfo.publishId);
599
600 DiscMgrDeinit();
601 }
602
603 /**
604 * @tc.name: DiscPublishTest010
605 * @tc.desc: Test inner module active publish, use Diff Freq Under the COAP of MODULE_LNN.
606 * @tc.in: Test Module, Test Number, Test Levels.
607 * @tc.out: Zero
608 * @tc.type: FUNC
609 * @tc.require: The DiscPublish operates normally.
610 */
611 HWTEST_F(Disc_ManagerTest, DiscPublishTest010, TestSize.Level1)
612 {
613 int ret;
614 PublishInfo testInfo = {
615 .publishId = TEST_PUBLISHINNER_ID,
616 .mode = DISCOVER_MODE_ACTIVE,
617 .medium = COAP,
618 .freq = LOW,
619 .capability = "hicall",
620 .capabilityData = (unsigned char *)"capdata1",
621 .dataLen = sizeof("capdata1")
622 };
623
624 DiscMgrInit();
625
626 ret = DiscPublish(MODULE_LNN, &testInfo);
627 TEST_ASSERT_TRUE(ret == 0);
628 DiscUnpublish(MODULE_LNN, testInfo.publishId);
629
630 testInfo.freq = MID;
631 ret = DiscPublish(MODULE_LNN, &testInfo);
632 TEST_ASSERT_TRUE(ret == 0);
633 DiscUnpublish(MODULE_LNN, testInfo.publishId);
634
635 testInfo.freq = HIGH;
636 ret = DiscPublish(MODULE_LNN, &testInfo);
637 TEST_ASSERT_TRUE(ret == 0);
638 DiscUnpublish(MODULE_LNN, testInfo.publishId);
639
640 testInfo.freq = SUPER_HIGH;
641 ret = DiscPublish(MODULE_LNN, &testInfo);
642 TEST_ASSERT_TRUE(ret == 0);
643 DiscUnpublish(MODULE_LNN, testInfo.publishId);
644
645 DiscMgrDeinit();
646 }
647
648 /**
649 * @tc.name: DiscPublishTest011
650 * @tc.desc: Test inner module active publish, use Diff Freq Under the COAP of MODULE_CONN.
651 * @tc.in: Test Module, Test Number, Test Levels.
652 * @tc.out: Zero
653 * @tc.type: FUNC
654 * @tc.require: The DiscPublish operates normally.
655 */
656 HWTEST_F(Disc_ManagerTest, DiscPublishTest011, TestSize.Level1)
657 {
658 int ret;
659 PublishInfo testInfo = {
660 .publishId = TEST_PUBLISHINNER_ID,
661 .mode = DISCOVER_MODE_ACTIVE,
662 .medium = COAP,
663 .freq = LOW,
664 .capability = "hicall",
665 .capabilityData = (unsigned char *)"capdata1",
666 .dataLen = sizeof("capdata1")
667 };
668
669 DiscMgrInit();
670
671 ret = DiscPublish(MODULE_CONN, &testInfo);
672 TEST_ASSERT_TRUE(ret == 0);
673 DiscUnpublish(MODULE_CONN, testInfo.publishId);
674
675 testInfo.freq = MID;
676 ret = DiscPublish(MODULE_CONN, &testInfo);
677 TEST_ASSERT_TRUE(ret == 0);
678 DiscUnpublish(MODULE_CONN, testInfo.publishId);
679
680 testInfo.freq = HIGH;
681 ret = DiscPublish(MODULE_CONN, &testInfo);
682 TEST_ASSERT_TRUE(ret == 0);
683 DiscUnpublish(MODULE_CONN, testInfo.publishId);
684
685 testInfo.freq = SUPER_HIGH;
686 ret = DiscPublish(MODULE_CONN, &testInfo);
687 TEST_ASSERT_TRUE(ret == 0);
688 DiscUnpublish(MODULE_CONN, testInfo.publishId);
689
690 DiscMgrDeinit();
691 }
692
693 /**
694 * @tc.name: DiscPublishTest012
695 * @tc.desc: Test inner module active publish, use wrong Medium and Freq Under the COAP of MODULE_LNN.
696 * @tc.in: Test Module, Test Number, Test Levels.
697 * @tc.out: NonZero
698 * @tc.type: FUNC
699 * @tc.require: The DiscPublish operates normally.
700 */
701 HWTEST_F(Disc_ManagerTest, DiscPublishTest012, TestSize.Level1)
702 {
703 int ret;
704 PublishInfo testInfo = {
705 .publishId = TEST_PUBLISHINNER_ID,
706 .mode = DISCOVER_MODE_ACTIVE,
707 .medium = COAP,
708 .freq = LOW,
709 .capability = "hicall",
710 .capabilityData = (unsigned char*)"capdata1",
711 .dataLen = sizeof("capdata1")
712 };
713
714 DiscMgrInit();
715
716 ret = DiscPublish((DiscModule)TEST_ERRO_MOUDULE2, &testInfo);
717 TEST_ASSERT_TRUE(ret != 0);
718
719 testInfo.medium = (ExchangeMedium)(AUTO - 1);
720 ret = DiscPublish(MODULE_LNN, &testInfo);
721 TEST_ASSERT_TRUE(ret != 0);
722 testInfo.medium = COAP;
723
724 testInfo.freq = (ExchangeFreq)(LOW - 1);
725 ret = DiscPublish(MODULE_LNN, &testInfo);
726 TEST_ASSERT_TRUE(ret != 0);
727 testInfo.freq = LOW;
728
729 ret = DiscPublish(MODULE_LNN, NULL);
730 TEST_ASSERT_TRUE(ret != 0);
731
732 DiscMgrDeinit();
733 }
734
735 /**
736 * @tc.name: DiscPublishTest013
737 * @tc.desc: Test inner module active publish, use wrong Medium and Freq Under the BLE of MODULE_LNN.
738 * @tc.in: Test Module, Test Number, Test Levels.
739 * @tc.out: NonZero
740 * @tc.type: FUNC
741 * @tc.require: The DiscPublish operates normally.
742 */
743 HWTEST_F(Disc_ManagerTest, DiscPublishTest013, TestSize.Level1)
744 {
745 int ret;
746 PublishInfo testInfo = {
747 .publishId = TEST_PUBLISHINNER_ID,
748 .mode = DISCOVER_MODE_ACTIVE,
749 .medium = BLE,
750 .freq = LOW,
751 .capability = "hicall",
752 .capabilityData = (unsigned char*)"capdata1",
753 .dataLen = sizeof("capdata1")
754 };
755
756 DiscMgrInit();
757
758 ret = DiscPublish((DiscModule)TEST_ERRO_MOUDULE2, &testInfo);
759 TEST_ASSERT_TRUE(ret != 0);
760
761 testInfo.medium = (ExchangeMedium)(AUTO - 1);
762 ret = DiscPublish(MODULE_LNN, &testInfo);
763 TEST_ASSERT_TRUE(ret != 0);
764 testInfo.medium = COAP;
765
766 testInfo.freq = (ExchangeFreq)(LOW - 1);
767 ret = DiscPublish(MODULE_LNN, &testInfo);
768 TEST_ASSERT_TRUE(ret != 0);
769 testInfo.freq = LOW;
770
771 ret = DiscPublish(MODULE_LNN, NULL);
772 TEST_ASSERT_TRUE(ret != 0);
773
774 DiscMgrDeinit();
775 }
776
777 /**
778 * @tc.name: DiscPublishTest014
779 * @tc.desc: Test inner module active publish, use wrong Medium and Freq Under the AUTO of MODULE_LNN.
780 * @tc.in: Test Module, Test Number, Test Levels.
781 * @tc.out: NonZero
782 * @tc.type: FUNC
783 * @tc.require: The DiscPublish operates normally.
784 */
785 HWTEST_F(Disc_ManagerTest, DiscPublishTest014, TestSize.Level1)
786 {
787 int ret;
788 PublishInfo testInfo = {
789 .publishId = TEST_PUBLISHINNER_ID,
790 .mode = DISCOVER_MODE_ACTIVE,
791 .medium = AUTO,
792 .freq = LOW,
793 .capability = "hicall",
794 .capabilityData = (unsigned char*)"capdata1",
795 .dataLen = sizeof("capdata1")
796 };
797
798 DiscMgrInit();
799
800 ret = DiscPublish((DiscModule)TEST_ERRO_MOUDULE2, &testInfo);
801 TEST_ASSERT_TRUE(ret != 0);
802
803 testInfo.medium = (ExchangeMedium)(AUTO - 1);
804 ret = DiscPublish(MODULE_LNN, &testInfo);
805 TEST_ASSERT_TRUE(ret != 0);
806 testInfo.medium = COAP;
807
808 testInfo.freq = (ExchangeFreq)(LOW - 1);
809 ret = DiscPublish(MODULE_LNN, &testInfo);
810 TEST_ASSERT_TRUE(ret != 0);
811 testInfo.freq = LOW;
812
813 ret = DiscPublish(MODULE_LNN, NULL);
814 TEST_ASSERT_TRUE(ret != 0);
815
816 DiscMgrDeinit();
817 }
818
819 /**
820 * @tc.name: DiscPublishTest015
821 * @tc.desc: Inner CONN module active publish，use the normal parameter and different frequencies under COAP.
822 * @tc.in: test module, test number, Test Levels.
823 * @tc.out: Zero
824 * @tc.type: FUNC
825 * @tc.require: The DiscPublish operates normally.
826 */
827 HWTEST_F(Disc_ManagerTest, DiscPublishTest015, TestSize.Level1)
828 {
829 int ret;
830 PublishInfo testInfo = {.publishId = TEST_PUBLISHINNER_ID,
831 .mode = DISCOVER_MODE_ACTIVE,
832 .medium = COAP,
833 .freq = LOW,
834 .capability = "hicall",
835 .capabilityData = (unsigned char *)"capdata1",
836 .dataLen = sizeof("capdata1")};
837
838 DiscMgrInit();
839
840 ret = DiscPublish(MODULE_CONN, &testInfo);
841 TEST_ASSERT_TRUE(ret == 0);
842 DiscUnpublish(MODULE_CONN, testInfo.publishId);
843
844 testInfo.freq = MID;
845 ret = DiscPublish(MODULE_CONN, &testInfo);
846 TEST_ASSERT_TRUE(ret == 0);
847 DiscUnpublish(MODULE_CONN, testInfo.publishId);
848
849 testInfo.freq = HIGH;
850 ret = DiscPublish(MODULE_CONN, &testInfo);
851 TEST_ASSERT_TRUE(ret == 0);
852 DiscUnpublish(MODULE_CONN, testInfo.publishId);
853
854 testInfo.freq = SUPER_HIGH;
855 ret = DiscPublish(MODULE_CONN, &testInfo);
856 TEST_ASSERT_TRUE(ret == 0);
857 DiscUnpublish(MODULE_CONN, testInfo.publishId);
858
859 DiscMgrDeinit();
860 }
861
862 /**
863 * @tc.name: DiscStartScanTest001
864 * @tc.desc: Inner CONN module passive publish，the module is not initialized.
865 * @tc.in: test module, test number, Test Levels.
866 * @tc.out: Nonzero
867 * @tc.type: FUNC
868 * @tc.require: The DiscStartScan operates normally.
869 */
870 HWTEST_F(Disc_ManagerTest, DiscStartScanTest001, TestSize.Level1)
871 {
872 int ret;
873 ret = DiscStartScan(MODULE_CONN, &g_pInnerInfo);
874 TEST_ASSERT_TRUE(ret != 0);
875 }
876
877 /**
878 * @tc.name: DiscStartScanTest002
879 * @tc.desc: Inner LNN module passive publish，use the wrong parameter.
880 * @tc.in: test module, test number, Test Levels.
881 * @tc.out: Nonzero
882 * @tc.type: FUNC
883 * @tc.require: The DiscStartScan operates normally.
884 */
885 HWTEST_F(Disc_ManagerTest, DiscStartScanTest002, TestSize.Level1)
886 {
887 int ret;
888 PublishInfo testInfo = {.publishId = TEST_PUBLISHINNER_ID,
889 .mode = DISCOVER_MODE_PASSIVE,
890 .medium = COAP,
891 .freq = LOW,
892 .capability = "hicall",
893 .capabilityData = (unsigned char *)"capdata1",
894 .dataLen = sizeof("capdata1")};
895
896 DiscMgrInit();
897
898 ret = DiscStartScan((DiscModule)TEST_ERRO_MOUDULE, &testInfo);
899 TEST_ASSERT_TRUE(ret != 0);
900
901 testInfo.medium = (ExchangeMedium)(COAP + 1);
902 ret = DiscStartScan(MODULE_LNN, &testInfo);
903 TEST_ASSERT_TRUE(ret != 0);
904 testInfo.medium = COAP;
905
906 testInfo.freq = (ExchangeFreq)(SUPER_HIGH + 1);
907 ret = DiscStartScan(MODULE_LNN, &testInfo);
908 TEST_ASSERT_TRUE(ret != 0);
909 testInfo.freq = LOW;
910
911 testInfo.capability = "hicall";
912 testInfo.capabilityData = NULL;
913 ret = DiscStartScan(MODULE_LNN, &testInfo);
914 TEST_ASSERT_TRUE(ret != 0);
915 testInfo.capabilityData = (unsigned char *)"capdata1";
916
917 testInfo.dataLen = ERRO_CAPDATA_LEN;
918 ret = DiscStartScan(MODULE_LNN, &testInfo);
919 TEST_ASSERT_TRUE(ret != 0);
920 testInfo.dataLen = sizeof("capdata1");
921
922 DiscMgrDeinit();
923 }
924
925 /**
926 * @tc.name: DiscStartScanTest003
927 * @tc.desc: Inner LNN module passive publish，use the normal parameter.
928 * @tc.in: test module, test number, Test Levels.
929 * @tc.out: Zero
930 * @tc.type: FUNC
931 * @tc.require: The DiscStartScan operates normally.
932 */
933 HWTEST_F(Disc_ManagerTest, DiscStartScanTest003, TestSize.Level1)
934 {
935 int ret;
936 DiscMgrInit();
937
938 ret = DiscStartScan(MODULE_LNN, &g_pInnerInfo);
939 TEST_ASSERT_TRUE(ret == 0);
940
941 DiscMgrDeinit();
942 }
943
944 /**
945 * @tc.name: DiscStartScanTest004
946 * @tc.desc: Inner LNN module passive publish，use the wrong parameter.
947 * @tc.in: test module, test number, Test Levels.
948 * @tc.out: Nonzero
949 * @tc.type: FUNC
950 * @tc.require: The DiscStartScan operates normally.
951 */
952 HWTEST_F(Disc_ManagerTest, DiscStartScanTest004, TestSize.Level1)
953 {
954 int ret;
955 DiscMgrInit();
956
957 ret = DiscStartScan(MODULE_LNN, &g_pInnerInfo1);
958 TEST_ASSERT_TRUE(ret != 0);
959
960 DiscMgrDeinit();
961 }
962
963 /**
964 * @tc.name: DiscStartScanTest005
965 * @tc.desc: Test passive discover, but softbus discover manager is not initialized.
966 * @tc.in: Test module, Test number, Test levels.
967 * @tc.out: Nonzero
968 * @tc.type: FUNC
969 * @tc.require:The DiscStartScan operates normally.
970 */
971 HWTEST_F(Disc_ManagerTest, DiscStartScanTest005, TestSize.Level1)
972 {
973 int ret;
974 PublishInfo testInfo = {
975 .publishId = TEST_PUBLISHINNER_ID,
976 .mode = DISCOVER_MODE_PASSIVE,
977 .medium = COAP,
978 .freq = LOW,
979 .capability = "hicall",
980 .capabilityData = (unsigned char *)"capdata1",
981 .dataLen = sizeof("capdata1")
982 };
983
984 ret = DiscStartScan(MODULE_LNN, &testInfo);
985 TEST_ASSERT_TRUE(ret != 0);
986 }
987
988 /**
989 * @tc.name: DiscStartScanTest006
990 * @tc.desc: Test passive discover,use wrong Medium and Freq Under the COAP of MODULE_LNN.
991 * @tc.in: Test module, Test number, Test levels.
992 * @tc.out: NonZero
993 * @tc.type: FUNC
994 * @tc.require:The DiscStartScan operates normally.
995 */
996 HWTEST_F(Disc_ManagerTest, DiscStartScanTest006, TestSize.Level1)
997 {
998 int ret;
999 PublishInfo testInfo = {
1000 .publishId = TEST_PUBLISHINNER_ID,
1001 .mode = DISCOVER_MODE_PASSIVE,
1002 .medium = COAP,
1003 .freq = LOW,
1004 .capability = "hicall",
1005 .capabilityData = (unsigned char*)"capdata1",
1006 .dataLen = sizeof("capdata1")
1007 };
1008
1009 DiscMgrInit();
1010
1011 ret = DiscStartScan((DiscModule)TEST_ERRO_MOUDULE2, &testInfo);
1012 TEST_ASSERT_TRUE(ret != 0);
1013
1014 testInfo.medium = (ExchangeMedium)(AUTO - 1);
1015 ret = DiscStartScan(MODULE_LNN, &testInfo);
1016 TEST_ASSERT_TRUE(ret != 0);
1017 testInfo.medium = COAP;
1018
1019 testInfo.freq = (ExchangeFreq)(LOW - 1);
1020 ret = DiscStartScan(MODULE_LNN, &testInfo);
1021 TEST_ASSERT_TRUE(ret != 0);
1022 testInfo.freq = LOW;
1023
1024 ret = DiscStartScan(MODULE_LNN, NULL);
1025 TEST_ASSERT_TRUE(ret != 0);
1026
1027 DiscMgrDeinit();
1028 }
1029
1030 /**
1031 * @tc.name: DiscStartScanTest007
1032 * @tc.desc: Test passive discover,use wrong Medium and Freq Under the AUTO of MODULE_LNN.
1033 * @tc.in: Test module, Test number, Test levels.
1034 * @tc.out: NonZero
1035 * @tc.type: FUNC
1036 * @tc.require:The DiscStartScan operates normally.
1037 */
1038 HWTEST_F(Disc_ManagerTest, DiscStartScanTest007, TestSize.Level1)
1039 {
1040 int ret;
1041 PublishInfo testInfo = {
1042 .publishId = TEST_PUBLISHINNER_ID,
1043 .mode = DISCOVER_MODE_PASSIVE,
1044 .medium = AUTO,
1045 .freq = LOW,
1046 .capability = "hicall",
1047 .capabilityData = (unsigned char *)"capdata1",
1048 .dataLen = sizeof("capdata1")
1049 };
1050
1051 DiscMgrInit();
1052
1053 ret = DiscStartScan((DiscModule)TEST_ERRO_MOUDULE1, &testInfo);
1054 TEST_ASSERT_TRUE(ret != 0);
1055
1056 testInfo.medium = (ExchangeMedium)(AUTO - 1);
1057 ret = DiscStartScan(MODULE_LNN, &testInfo);
1058 TEST_ASSERT_TRUE(ret != 0);
1059 testInfo.medium = COAP;
1060
1061 testInfo.freq = (ExchangeFreq)(LOW - 1);
1062 ret = DiscStartScan(MODULE_LNN, &testInfo);
1063 TEST_ASSERT_TRUE(ret != 0);
1064 testInfo.freq = LOW;
1065
1066 ret = DiscStartScan(MODULE_LNN, NULL);
1067 TEST_ASSERT_TRUE(ret != 0);
1068
1069 DiscMgrDeinit();
1070 }
1071
1072 /**
1073 * @tc.name: DiscStartScanTest008
1074 * @tc.desc: Test passive discover,use wrong Medium and Freq Under the BLE of MODULE_LNN.
1075 * @tc.in: Test module, Test number, Test levels.
1076 * @tc.out: Zero
1077 * @tc.type: FUNC
1078 * @tc.require:The DiscStartScan operates normally.
1079 */
1080 HWTEST_F(Disc_ManagerTest, DiscStartScanTest008, TestSize.Level1)
1081 {
1082 int ret;
1083 PublishInfo testInfo = {
1084 .publishId = TEST_PUBLISHINNER_ID,
1085 .mode = DISCOVER_MODE_PASSIVE,
1086 .medium = BLE,
1087 .freq = LOW,
1088 .capability = "hicall",
1089 .capabilityData = (unsigned char*)"capdata1",
1090 .dataLen = sizeof("capdata1")
1091 };
1092
1093 DiscMgrInit();
1094
1095 ret = DiscStartScan((DiscModule)TEST_ERRO_MOUDULE2, &testInfo);
1096 TEST_ASSERT_TRUE(ret != 0);
1097
1098 testInfo.medium = (ExchangeMedium)(AUTO - 1);
1099 ret = DiscStartScan(MODULE_LNN, &testInfo);
1100 TEST_ASSERT_TRUE(ret != 0);
1101 testInfo.medium = COAP;
1102
1103 testInfo.freq = (ExchangeFreq)(LOW - 1);
1104 ret = DiscStartScan(MODULE_LNN, &testInfo);
1105 TEST_ASSERT_TRUE(ret != 0);
1106 testInfo.freq = LOW;
1107
1108 ret = DiscStartScan(MODULE_LNN, NULL);
1109 TEST_ASSERT_TRUE(ret != 0);
1110
1111 DiscMgrDeinit();
1112 }
1113
1114 /**
1115 * @tc.name: DiscStartAdvertiseTest001
1116 * @tc.desc: Inner CONN module active discover，the module is not initialized.
1117 * @tc.in: test module, test number, Test Levels.
1118 * @tc.out: Nonzero
1119 * @tc.type: FUNC
1120 * @tc.require: The DiscStartAdvertise operates normally.
1121 */
1122 HWTEST_F(Disc_ManagerTest, DiscStartAdvertiseTest001, TestSize.Level1)
1123 {
1124 int ret;
1125 ret = DiscStartAdvertise(MODULE_CONN, &g_sInnerInfo);
1126 TEST_ASSERT_TRUE(ret != 0);
1127 }
1128
1129 /**
1130 * @tc.name: DiscStartAdvertiseTest002
1131 * @tc.desc: Inner LNN module active discover，use the wrong parameter.
1132 * @tc.in: test module, test number, Test Levels.
1133 * @tc.out: Nonzero
1134 * @tc.type: FUNC
1135 * @tc.require: The DiscStartAdvertise operates normally.
1136 */
1137 HWTEST_F(Disc_ManagerTest, DiscStartAdvertiseTest002, TestSize.Level1)
1138 {
1139 int ret;
1140 SubscribeInfo testInfo = {.subscribeId = TEST_SUBSCRIBEINNER_ID,
1141 .mode = DISCOVER_MODE_ACTIVE,
1142 .medium = COAP,
1143 .freq = MID,
1144 .isSameAccount = true,
1145 .isWakeRemote = false,
1146 .capability = "dvKit",
1147 .capabilityData = (unsigned char *)"capdata3",
1148 .dataLen = sizeof("capdata3")};
1149
1150 DiscMgrInit();
1151
1152 ret = DiscStartAdvertise((DiscModule)TEST_ERRO_MOUDULE, &testInfo);
1153 TEST_ASSERT_TRUE(ret != 0);
1154
1155 testInfo.medium = (ExchangeMedium)(COAP + 1);
1156 ret = DiscStartAdvertise(MODULE_LNN, &testInfo);
1157 TEST_ASSERT_TRUE(ret != 0);
1158 testInfo.medium = COAP;
1159
1160 testInfo.freq = (ExchangeFreq)(SUPER_HIGH + 1);
1161 ret = DiscStartAdvertise(MODULE_LNN, &testInfo);
1162 TEST_ASSERT_TRUE(ret != 0);
1163 testInfo.freq = LOW;
1164
1165 testInfo.capability = "hicall";
1166 testInfo.capabilityData = NULL;
1167 ret = DiscStartAdvertise(MODULE_LNN, &testInfo);
1168 TEST_ASSERT_TRUE(ret != 0);
1169 testInfo.capabilityData = (unsigned char *)"capdata1";
1170
1171 testInfo.dataLen = ERRO_CAPDATA_LEN;
1172 ret = DiscStartAdvertise(MODULE_LNN, &testInfo);
1173 TEST_ASSERT_TRUE(ret != 0);
1174 testInfo.dataLen = sizeof("capdata1");
1175
1176 DiscMgrDeinit();
1177 }
1178
1179 /**
1180 * @tc.name: DiscStartAdvertiseTest003
1181 * @tc.desc: Inner CONN module active discover，use the normal parameter.
1182 * @tc.in: test module, test number, Test Levels.
1183 * @tc.out: Zero
1184 * @tc.type: FUNC
1185 * @tc.require: The DiscStartAdvertise operates normally.
1186 */
1187 HWTEST_F(Disc_ManagerTest, DiscStartAdvertiseTest003, TestSize.Level1)
1188 {
1189 int ret;
1190 DiscMgrInit();
1191
1192 ret = DiscStartAdvertise(MODULE_CONN, &g_sInnerInfo);
1193 TEST_ASSERT_TRUE(ret == 0);
1194
1195 DiscMgrDeinit();
1196 }
1197
1198 /**
1199 * @tc.name: DiscStartAdvertiseTest004
1200 * @tc.desc: Inner CONN module active discover，use the wrong parameter.
1201 * @tc.in: test module, test number, Test Levels.
1202 * @tc.out: Nonzero
1203 * @tc.type: FUNC
1204 * @tc.require: The DiscStartAdvertise operates normally.
1205 */
1206 HWTEST_F(Disc_ManagerTest, DiscStartAdvertiseTest004, TestSize.Level1)
1207 {
1208 int ret;
1209 DiscMgrInit();
1210
1211 ret = DiscStartAdvertise(MODULE_CONN, &g_sInnerInfo1);
1212 TEST_ASSERT_TRUE(ret != 0);
1213
1214 DiscMgrDeinit();
1215 }
1216
1217 /**
1218 * @tc.name: DiscStartAdvertiseTest005
1219 * @tc.desc: Test inner start discover, use wrong Medium and Freq Under the COAP of MODULE_LNN.
1220 * @tc.in: Test Module, Test Number, Test Levels.
1221 * @tc.out: NonZero
1222 * @tc.type: FUNC
1223 * @tc.require: The DiscStartAdvertise operates normally.
1224 */
1225 HWTEST_F(Disc_ManagerTest, DiscStartAdvertiseTest005, TestSize.Level1)
1226 {
1227 int ret;
1228 SubscribeInfo testInfo = {.subscribeId = TEST_SUBSCRIBEINNER_ID,
1229 .mode = DISCOVER_MODE_ACTIVE,
1230 .medium = COAP,
1231 .freq = MID,
1232 .isSameAccount = true,
1233 .isWakeRemote = false,
1234 .capability = "dvKit",
1235 .capabilityData = (unsigned char *)"capdata3",
1236 .dataLen = sizeof("capdata3")};
1237
1238 DiscMgrInit();
1239
1240 ret = DiscStartAdvertise((DiscModule)TEST_ERRO_MOUDULE1, &testInfo);
1241 TEST_ASSERT_TRUE(ret != 0);
1242
1243 testInfo.medium = (ExchangeMedium)(AUTO - 1);
1244 ret = DiscStartAdvertise(MODULE_LNN, &testInfo);
1245 TEST_ASSERT_TRUE(ret != 0);
1246 testInfo.medium = COAP;
1247
1248 testInfo.freq = (ExchangeFreq)(LOW - 1);
1249 ret = DiscStartAdvertise(MODULE_LNN, &testInfo);
1250 TEST_ASSERT_TRUE(ret != 0);
1251 testInfo.freq = LOW;
1252
1253 ret = DiscStartAdvertise(MODULE_LNN, NULL);
1254 TEST_ASSERT_TRUE(ret != 0);
1255
1256 DiscMgrDeinit();
1257 }
1258
1259 /**
1260 * @tc.name: DiscStartAdvertiseTest006
1261 * @tc.desc: Test inner start discover, use wrong Medium and Freq Under the BLE of MODULE_LNN.
1262 * @tc.in: Test Module, Test Number, Test Levels.
1263 * @tc.out: NonZero
1264 * @tc.type: FUNC
1265 * @tc.require: The DiscStartAdvertise operates normally.
1266 */
1267 HWTEST_F(Disc_ManagerTest, DiscStartAdvertiseTest006, TestSize.Level1)
1268 {
1269 int ret;
1270 SubscribeInfo testInfo = {.subscribeId = TEST_SUBSCRIBEINNER_ID,
1271 .mode = DISCOVER_MODE_ACTIVE,
1272 .medium = BLE,
1273 .freq = MID,
1274 .isSameAccount = true,
1275 .isWakeRemote = false,
1276 .capability = "dvKit",
1277 .capabilityData = (unsigned char *)"capdata3",
1278 .dataLen = sizeof("capdata3")};
1279
1280 DiscMgrInit();
1281
1282 ret = DiscStartAdvertise((DiscModule)TEST_ERRO_MOUDULE1, &testInfo);
1283 TEST_ASSERT_TRUE(ret != 0);
1284
1285 testInfo.medium = (ExchangeMedium)(AUTO - 1);
1286 ret = DiscStartAdvertise(MODULE_LNN, &testInfo);
1287 TEST_ASSERT_TRUE(ret != 0);
1288 testInfo.medium = COAP;
1289
1290 testInfo.freq = (ExchangeFreq)(LOW - 1);
1291 ret = DiscStartAdvertise(MODULE_LNN, &testInfo);
1292 TEST_ASSERT_TRUE(ret != 0);
1293 testInfo.freq = LOW;
1294
1295 ret = DiscStartAdvertise(MODULE_LNN, NULL);
1296 TEST_ASSERT_TRUE(ret != 0);
1297
1298 DiscMgrDeinit();
1299 }
1300
1301 /**
1302 * @tc.name: DiscStartAdvertiseTest007
1303 * @tc.desc: Test inner start discover, use wrong Medium and Freq Under the AUTO of MODULE_LNN.
1304 * @tc.in: Test Module, Test Number, Test Levels.
1305 * @tc.out: NonZero
1306 * @tc.type: FUNC
1307 * @tc.require: The DiscStartAdvertise operates normally.
1308 */
1309 HWTEST_F(Disc_ManagerTest, DiscStartAdvertiseTest007, TestSize.Level1)
1310 {
1311 int ret;
1312 SubscribeInfo testInfo = {.subscribeId = TEST_SUBSCRIBEINNER_ID,
1313 .mode = DISCOVER_MODE_ACTIVE,
1314 .medium = AUTO,
1315 .freq = MID,
1316 .isSameAccount = true,
1317 .isWakeRemote = false,
1318 .capability = "dvKit",
1319 .capabilityData = (unsigned char *)"capdata3",
1320 .dataLen = sizeof("capdata3")};
1321
1322 DiscMgrInit();
1323
1324 ret = DiscStartAdvertise((DiscModule)TEST_ERRO_MOUDULE1, &testInfo);
1325 TEST_ASSERT_TRUE(ret != 0);
1326
1327 testInfo.medium = (ExchangeMedium)(AUTO - 1);
1328 ret = DiscStartAdvertise(MODULE_LNN, &testInfo);
1329 TEST_ASSERT_TRUE(ret != 0);
1330 testInfo.medium = COAP;
1331
1332 testInfo.freq = (ExchangeFreq)(LOW - 1);
1333 ret = DiscStartAdvertise(MODULE_LNN, &testInfo);
1334 TEST_ASSERT_TRUE(ret != 0);
1335 testInfo.freq = LOW;
1336
1337 ret = DiscStartAdvertise(MODULE_LNN, NULL);
1338 TEST_ASSERT_TRUE(ret != 0);
1339
1340 DiscMgrDeinit();
1341 }
1342
1343 /**
1344 * @tc.name: DiscStartAdvertiseTest008
1345 * @tc.desc: Test inner module active discover，but softbus discover manager is not init.
1346 * @tc.in: Test Module, Test Number, Test Levels.
1347 * @tc.out: Zero
1348 * @tc.type: FUNC
1349 * @tc.require: The DiscStartAdvertise operates normally.
1350 */
1351 HWTEST_F(Disc_ManagerTest, DiscStartAdvertiseTest008, TestSize.Level1)
1352 {
1353 int ret;
1354 SubscribeInfo testInfo = {.subscribeId = TEST_SUBSCRIBEINNER_ID,
1355 .mode = DISCOVER_MODE_ACTIVE,
1356 .medium = COAP,
1357 .freq = MID,
1358 .isSameAccount = true,
1359 .isWakeRemote = false,
1360 .capability = "dvKit",
1361 .capabilityData = (unsigned char *)"capdata3",
1362 .dataLen = sizeof("capdata3")};
1363
1364 ret = DiscStartAdvertise(MODULE_CONN, &testInfo);
1365 TEST_ASSERT_TRUE(ret == 0);
1366 }
1367
1368 /**
1369 * @tc.name: DiscStartAdvertiseTest009
1370 * @tc.desc: Test inner module active discover，use Diff Freq Under the AUTO of MODULE_LNN.
1371 * @tc.in: Test Module, Test Number, Test Levels.
1372 * @tc.out: Zero
1373 * @tc.type: FUNC
1374 * @tc.require: The DiscStartAdvertise operates normally.
1375 */
1376 HWTEST_F(Disc_ManagerTest, DiscStartAdvertiseTest009, TestSize.Level1)
1377 {
1378 int ret;
1379 SubscribeInfo testInfo = {.subscribeId = TEST_SUBSCRIBEINNER_ID,
1380 .mode = DISCOVER_MODE_ACTIVE,
1381 .medium = AUTO,
1382 .freq = LOW,
1383 .isSameAccount = true,
1384 .isWakeRemote = false,
1385 .capability = "dvKit",
1386 .capabilityData = (unsigned char *)"capdata3",
1387 .dataLen = sizeof("capdata3")};
1388
1389 DiscMgrInit();
1390
1391 ret = DiscStartAdvertise(MODULE_LNN, &testInfo);
1392 TEST_ASSERT_TRUE(ret == 0);
1393 DiscStopAdvertise(MODULE_LNN, testInfo.subscribeId);
1394
1395 testInfo.freq = MID;
1396 ret = DiscStartAdvertise(MODULE_LNN, &testInfo);
1397 TEST_ASSERT_TRUE(ret == 0);
1398 DiscStopAdvertise(MODULE_LNN, testInfo.subscribeId);
1399
1400 testInfo.freq = HIGH;
1401 ret = DiscStartAdvertise(MODULE_LNN, &testInfo);
1402 TEST_ASSERT_TRUE(ret == 0);
1403 DiscStopAdvertise(MODULE_LNN, testInfo.subscribeId);
1404
1405 testInfo.freq = SUPER_HIGH;
1406 ret = DiscStartAdvertise(MODULE_LNN, &testInfo);
1407 TEST_ASSERT_TRUE(ret == 0);
1408 DiscStopAdvertise(MODULE_LNN, testInfo.subscribeId);
1409
1410 DiscMgrDeinit();
1411 }
1412
1413 /**
1414 * @tc.name: DiscStartAdvertiseTest010
1415 * @tc.desc: Test inner module active discover，use Diff Freq Under the AUTO of MODULE_CONN.
1416 * @tc.in: Test Module, Test Number, Test Levels.
1417 * @tc.out: Zero
1418 * @tc.type: FUNC
1419 * @tc.require: The DiscStartAdvertise operates normally.
1420 */
1421 HWTEST_F(Disc_ManagerTest, DiscStartAdvertiseTest010, TestSize.Level1)
1422 {
1423 int ret;
1424 SubscribeInfo testInfo = {.subscribeId = TEST_SUBSCRIBEINNER_ID,
1425 .mode = DISCOVER_MODE_ACTIVE,
1426 .medium = AUTO,
1427 .freq = LOW,
1428 .isSameAccount = true,
1429 .isWakeRemote = false,
1430 .capability = "dvKit",
1431 .capabilityData = (unsigned char *)"capdata3",
1432 .dataLen = sizeof("capdata3")};
1433
1434 DiscMgrInit();
1435
1436 ret = DiscStartAdvertise(MODULE_CONN, &testInfo);
1437 TEST_ASSERT_TRUE(ret == 0);
1438 DiscStopAdvertise(MODULE_CONN, testInfo.subscribeId);
1439
1440 testInfo.freq = MID;
1441 ret = DiscStartAdvertise(MODULE_CONN, &testInfo);
1442 TEST_ASSERT_TRUE(ret == 0);
1443 DiscStopAdvertise(MODULE_CONN, testInfo.subscribeId);
1444
1445 testInfo.freq = HIGH;
1446 ret = DiscStartAdvertise(MODULE_CONN, &testInfo);
1447 TEST_ASSERT_TRUE(ret == 0);
1448 DiscStopAdvertise(MODULE_CONN, testInfo.subscribeId);
1449
1450 testInfo.freq = SUPER_HIGH;
1451 ret = DiscStartAdvertise(MODULE_CONN, &testInfo);
1452 TEST_ASSERT_TRUE(ret == 0);
1453 DiscStopAdvertise(MODULE_CONN, testInfo.subscribeId);
1454
1455 DiscMgrDeinit();
1456 }
1457
1458 /**
1459 * @tc.name: DiscStartAdvertiseTest011
1460 * @tc.desc: Test inner module active discover，use Diff Freq Under the BLE of MODULE_LNN.
1461 * @tc.in: Test Module, Test Number, Test Levels.
1462 * @tc.out: Zero
1463 * @tc.type: FUNC
1464 * @tc.require: The DiscStartAdvertise operates normally.
1465 */
1466 HWTEST_F(Disc_ManagerTest, DiscStartAdvertiseTest011, TestSize.Level1)
1467 {
1468 int ret;
1469 SubscribeInfo testInfo = {.subscribeId = TEST_SUBSCRIBEINNER_ID,
1470 .mode = DISCOVER_MODE_ACTIVE,
1471 .medium = BLE,
1472 .freq = LOW,
1473 .isSameAccount = true,
1474 .isWakeRemote = false,
1475 .capability = "dvKit",
1476 .capabilityData = (unsigned char *)"capdata3",
1477 .dataLen = sizeof("capdata3")};
1478
1479 DiscMgrInit();
1480
1481 ret = DiscStartAdvertise(MODULE_LNN, &testInfo);
1482 TEST_ASSERT_TRUE(ret == 0);
1483 DiscStopAdvertise(MODULE_LNN, testInfo.subscribeId);
1484
1485 testInfo.freq = MID;
1486 ret = DiscStartAdvertise(MODULE_LNN, &testInfo);
1487 TEST_ASSERT_TRUE(ret == 0);
1488 DiscStopAdvertise(MODULE_LNN, testInfo.subscribeId);
1489
1490 testInfo.freq = HIGH;
1491 ret = DiscStartAdvertise(MODULE_LNN, &testInfo);
1492 TEST_ASSERT_TRUE(ret == 0);
1493 DiscStopAdvertise(MODULE_LNN, testInfo.subscribeId);
1494
1495 testInfo.freq = SUPER_HIGH;
1496 ret = DiscStartAdvertise(MODULE_LNN, &testInfo);
1497 TEST_ASSERT_TRUE(ret == 0);
1498 DiscStopAdvertise(MODULE_LNN, testInfo.subscribeId);
1499
1500 DiscMgrDeinit();
1501 }
1502
1503 /**
1504 * @tc.name: DiscStartAdvertiseTest012
1505 * @tc.desc: Test inner module active discover，use Diff Freq Under the BLE of MODULE_CONN.
1506 * @tc.in: Test Module, Test Number, Test Levels.
1507 * @tc.out: Zero
1508 * @tc.type: FUNC
1509 * @tc.require: The DiscStartAdvertise operates normally.
1510 */
1511 HWTEST_F(Disc_ManagerTest, DiscStartAdvertiseTest012, TestSize.Level1)
1512 {
1513 int ret;
1514 SubscribeInfo testInfo = {.subscribeId = TEST_SUBSCRIBEINNER_ID,
1515 .mode = DISCOVER_MODE_ACTIVE,
1516 .medium = BLE,
1517 .freq = LOW,
1518 .isSameAccount = true,
1519 .isWakeRemote = false,
1520 .capability = "dvKit",
1521 .capabilityData = (unsigned char *)"capdata3",
1522 .dataLen = sizeof("capdata3")};
1523
1524 DiscMgrInit();
1525
1526 ret = DiscStartAdvertise(MODULE_CONN, &testInfo);
1527 TEST_ASSERT_TRUE(ret == 0);
1528 DiscStopAdvertise(MODULE_CONN, testInfo.subscribeId);
1529
1530 testInfo.freq = MID;
1531 ret = DiscStartAdvertise(MODULE_CONN, &testInfo);
1532 TEST_ASSERT_TRUE(ret == 0);
1533 DiscStopAdvertise(MODULE_CONN, testInfo.subscribeId);
1534
1535 testInfo.freq = HIGH;
1536 ret = DiscStartAdvertise(MODULE_CONN, &testInfo);
1537 TEST_ASSERT_TRUE(ret == 0);
1538 DiscStopAdvertise(MODULE_CONN, testInfo.subscribeId);
1539
1540 testInfo.freq = SUPER_HIGH;
1541 ret = DiscStartAdvertise(MODULE_CONN, &testInfo);
1542 TEST_ASSERT_TRUE(ret == 0);
1543 DiscStopAdvertise(MODULE_CONN, testInfo.subscribeId);
1544
1545 DiscMgrDeinit();
1546 }
1547
1548 /**
1549 * @tc.name: DiscStartAdvertiseTest013
1550 * @tc.desc: Test inner module active discover，use Diff Freq Under the COAP of MODULE_LNN.
1551 * @tc.in: Test Module, Test Number, Test Levels.
1552 * @tc.out: Zero
1553 * @tc.type: FUNC
1554 * @tc.require: The DiscStartAdvertise operates normally.
1555 */
1556 HWTEST_F(Disc_ManagerTest, DiscStartAdvertiseTest013, TestSize.Level1)
1557 {
1558 int ret;
1559 SubscribeInfo testInfo = {.subscribeId = TEST_SUBSCRIBEINNER_ID,
1560 .mode = DISCOVER_MODE_ACTIVE,
1561 .medium = COAP,
1562 .freq = LOW,
1563 .isSameAccount = true,
1564 .isWakeRemote = false,
1565 .capability = "dvKit",
1566 .capabilityData = (unsigned char *)"capdata3",
1567 .dataLen = sizeof("capdata3")};
1568
1569 DiscMgrInit();
1570
1571 ret = DiscStartAdvertise(MODULE_LNN, &testInfo);
1572 TEST_ASSERT_TRUE(ret == 0);
1573 DiscStopAdvertise(MODULE_LNN, testInfo.subscribeId);
1574
1575 testInfo.freq = MID;
1576 ret = DiscStartAdvertise(MODULE_LNN, &testInfo);
1577 TEST_ASSERT_TRUE(ret == 0);
1578 DiscStopAdvertise(MODULE_LNN, testInfo.subscribeId);
1579
1580 testInfo.freq = HIGH;
1581 ret = DiscStartAdvertise(MODULE_LNN, &testInfo);
1582 TEST_ASSERT_TRUE(ret == 0);
1583 DiscStopAdvertise(MODULE_LNN, testInfo.subscribeId);
1584
1585 testInfo.freq = SUPER_HIGH;
1586 ret = DiscStartAdvertise(MODULE_LNN, &testInfo);
1587 TEST_ASSERT_TRUE(ret == 0);
1588 DiscStopAdvertise(MODULE_LNN, testInfo.subscribeId);
1589
1590 DiscMgrDeinit();
1591 }
1592
1593 /**
1594 * @tc.name: DiscStartAdvertiseTest014
1595 * @tc.desc: Test inner module active discover，use use Diff Freq Under the COAP of MODULE_CONN.
1596 * @tc.in: Test Module, Test Number, Test Levels.
1597 * @tc.out: Zero
1598 * @tc.type: FUNC
1599 * @tc.require: The DiscStartAdvertise operates normally.
1600 */
1601 HWTEST_F(Disc_ManagerTest, DiscStartAdvertiseTest014, TestSize.Level1)
1602 {
1603 int ret;
1604 SubscribeInfo testInfo = {.subscribeId = TEST_SUBSCRIBEINNER_ID,
1605 .mode = DISCOVER_MODE_ACTIVE,
1606 .medium = COAP,
1607 .freq = LOW,
1608 .isSameAccount = true,
1609 .isWakeRemote = false,
1610 .capability = "dvKit",
1611 .capabilityData = (unsigned char *)"capdata3",
1612 .dataLen = sizeof("capdata3")};
1613
1614 DiscMgrInit();
1615
1616 ret = DiscStartAdvertise(MODULE_CONN, &testInfo);
1617 TEST_ASSERT_TRUE(ret == 0);
1618 DiscStopAdvertise(MODULE_CONN, testInfo.subscribeId);
1619
1620 testInfo.freq = MID;
1621 ret = DiscStartAdvertise(MODULE_CONN, &testInfo);
1622 TEST_ASSERT_TRUE(ret == 0);
1623 DiscStopAdvertise(MODULE_CONN, testInfo.subscribeId);
1624
1625 testInfo.freq = HIGH;
1626 ret = DiscStartAdvertise(MODULE_CONN, &testInfo);
1627 TEST_ASSERT_TRUE(ret == 0);
1628 DiscStopAdvertise(MODULE_CONN, testInfo.subscribeId);
1629
1630 testInfo.freq = SUPER_HIGH;
1631 ret = DiscStartAdvertise(MODULE_CONN, &testInfo);
1632 TEST_ASSERT_TRUE(ret == 0);
1633 DiscStopAdvertise(MODULE_CONN, testInfo.subscribeId);
1634
1635 DiscMgrDeinit();
1636 }
1637
1638 /**
1639 * @tc.name: DiscStartAdvertiseTest015
1640 * @tc.desc: Inner CONN module active discover，use the normal parameter and different frequencies under COAP.
1641 * @tc.in: test module, test number, test levels.
1642 * @tc.out: Zero.
1643 * @tc.type: FUNC
1644 * @tc.require: The DiscStartAdvertise operates normally.
1645 */
1646 HWTEST_F(Disc_ManagerTest, DiscStartAdvertiseTest015, TestSize.Level1)
1647 {
1648 int ret;
1649 SubscribeInfo testInfo = {.subscribeId = TEST_SUBSCRIBEINNER_ID,
1650 .mode = DISCOVER_MODE_ACTIVE,
1651 .medium = COAP,
1652 .freq = LOW,
1653 .isSameAccount = true,
1654 .isWakeRemote = false,
1655 .capability = "dvKit",
1656 .capabilityData = (unsigned char *)"capdata3",
1657 .dataLen = sizeof("capdata3")};
1658
1659 DiscMgrInit();
1660
1661 ret = DiscStartAdvertise(MODULE_CONN, &testInfo);
1662 TEST_ASSERT_TRUE(ret == 0);
1663 DiscStopAdvertise(MODULE_CONN, testInfo.subscribeId);
1664
1665 testInfo.freq = MID;
1666 ret = DiscStartAdvertise(MODULE_CONN, &testInfo);
1667 TEST_ASSERT_TRUE(ret == 0);
1668 DiscStopAdvertise(MODULE_CONN, testInfo.subscribeId);
1669
1670 testInfo.freq = HIGH;
1671 ret = DiscStartAdvertise(MODULE_CONN, &testInfo);
1672 TEST_ASSERT_TRUE(ret == 0);
1673 DiscStopAdvertise(MODULE_CONN, testInfo.subscribeId);
1674
1675 testInfo.freq = SUPER_HIGH;
1676 ret = DiscStartAdvertise(MODULE_CONN, &testInfo);
1677 TEST_ASSERT_TRUE(ret == 0);
1678 DiscStopAdvertise(MODULE_CONN, testInfo.subscribeId);
1679
1680 DiscMgrDeinit();
1681 }
1682
1683 /**
1684 * @tc.name: DiscSubscribeTest001
1685 * @tc.desc: Inner CONN module passive discover，the module is not initialized.
1686 * @tc.in: test module, test number, Test Levels.
1687 * @tc.out: Nonzero
1688 * @tc.type: FUNC
1689 * @tc.require: The DiscSubscribe operates normally.
1690 */
1691 HWTEST_F(Disc_ManagerTest, DiscSubscribeTest001, TestSize.Level1)
1692 {
1693 int ret;
1694 ret = DiscSubscribe(MODULE_CONN, &g_sInnerInfo);
1695 TEST_ASSERT_TRUE(ret != 0);
1696 }
1697
1698 /**
1699 * @tc.name: DiscSubscribeTest002
1700 * @tc.desc: Inner LNN module passive discover，use the wrong parameter.
1701 * @tc.in: test module, test number, Test Levels.
1702 * @tc.out: Nonzero
1703 * @tc.type: FUNC
1704 * @tc.require: The DiscSubscribe operates normally.
1705 */
1706 HWTEST_F(Disc_ManagerTest, DiscSubscribeTest002, TestSize.Level1)
1707 {
1708 int ret;
1709 SubscribeInfo testInfo = {.subscribeId = TEST_SUBSCRIBEINNER_ID,
1710 .mode = DISCOVER_MODE_PASSIVE,
1711 .medium = COAP,
1712 .freq = MID,
1713 .isSameAccount = true,
1714 .isWakeRemote = false,
1715 .capability = "dvKit",
1716 .capabilityData = (unsigned char *)"capdata3",
1717 .dataLen = sizeof("capdata3")};
1718
1719 DiscMgrInit();
1720
1721 ret = DiscSubscribe((DiscModule)TEST_ERRO_MOUDULE, &testInfo);
1722 TEST_ASSERT_TRUE(ret != 0);
1723
1724 testInfo.medium = (ExchangeMedium)(COAP + 1);
1725 ret = DiscSubscribe(MODULE_LNN, &testInfo);
1726 TEST_ASSERT_TRUE(ret != 0);
1727 testInfo.medium = COAP;
1728
1729 testInfo.freq = (ExchangeFreq)(SUPER_HIGH + 1);
1730 ret = DiscSubscribe(MODULE_LNN, &testInfo);
1731 TEST_ASSERT_TRUE(ret != 0);
1732 testInfo.freq = LOW;
1733
1734 testInfo.capability = "hicall";
1735 testInfo.capabilityData = NULL;
1736 ret = DiscSubscribe(MODULE_LNN, &testInfo);
1737 TEST_ASSERT_TRUE(ret != 0);
1738 testInfo.capabilityData = (unsigned char *)"capdata1";
1739
1740 testInfo.dataLen = ERRO_CAPDATA_LEN;
1741 ret = DiscSubscribe(MODULE_LNN, &testInfo);
1742 TEST_ASSERT_TRUE(ret != 0);
1743 testInfo.dataLen = sizeof("capdata1");
1744
1745 DiscMgrDeinit();
1746 }
1747
1748 /**
1749 * @tc.name: DiscSubscribeTest003
1750 * @tc.desc: Inner CONN module passive discover，use the wrong parameter.
1751 * @tc.in: test module, test number, Test Levels.
1752 * @tc.out: Nonzero
1753 * @tc.type: FUNC
1754 * @tc.require: The DiscSubscribe operates normally.
1755 */
1756 HWTEST_F(Disc_ManagerTest, DiscSubscribeTest003, TestSize.Level1)
1757 {
1758 int ret;
1759 DiscMgrInit();
1760
1761 ret = DiscSubscribe(MODULE_CONN, &g_sInnerInfo);
1762 TEST_ASSERT_TRUE(ret != 0);
1763
1764 DiscMgrDeinit();
1765 }
1766
1767 /**
1768 * @tc.name: DiscSubscribeTest004
1769 * @tc.desc: Inner CONN module passive discover，use the normal parameter.
1770 * @tc.in: test module, test number, Test Levels.
1771 * @tc.out: Zero
1772 * @tc.type: FUNC
1773 * @tc.require: The DiscSubscribe operates normally.
1774 */
1775 HWTEST_F(Disc_ManagerTest, DiscSubscribeTest004, TestSize.Level1)
1776 {
1777 int ret;
1778 DiscMgrInit();
1779
1780 ret = DiscSubscribe(MODULE_CONN, &g_sInnerInfo1);
1781 TEST_ASSERT_TRUE(ret == 0);
1782
1783 DiscMgrDeinit();
1784 }
1785
1786 /**
1787 * @tc.name: DiscSubscribeTest005
1788 * @tc.desc: Inner CONN module passive discover，use the same parameter again, Perform two subscriptions.
1789 * @tc.in: test module, test number, Test Levels.
1790 * @tc.out: Nonzero
1791 * @tc.type: FUNC
1792 * @tc.require:The DiscSubscribe operates normally.
1793 */
1794 HWTEST_F(Disc_ManagerTest, DiscSubscribeTest005, TestSize.Level1)
1795 {
1796 int ret;
1797 DiscMgrInit();
1798
1799 ret = DiscSubscribe(MODULE_CONN, &g_sInnerInfo1);
1800 ret = DiscSubscribe(MODULE_CONN, &g_sInnerInfo1);
1801 TEST_ASSERT_TRUE(ret != 0);
1802
1803 DiscMgrDeinit();
1804 }
1805
1806 /**
1807 * @tc.name: DiscSubscribeTest006
1808 * @tc.desc: Inner LNN module passive discover, use wrong parameter.
1809 * @tc.in: test module, test number, Test Levels.
1810 * @tc.out: Nonzero
1811 * @tc.type: FUNC
1812 * @tc.require: The DiscSubscribe operates normally.
1813 */
1814 HWTEST_F(Disc_ManagerTest, DiscSubscribeTest006, TestSize.Level1)
1815 {
1816 int ret;
1817 SubscribeInfo testInfo = {
1818 .subscribeId = TEST_SUBSCRIBEINNER_ID,
1819 .mode = DISCOVER_MODE_PASSIVE,
1820 .medium = BLE,
1821 .freq = MID,
1822 .isSameAccount = true,
1823 .isWakeRemote = false,
1824 .capability = "dvKit",
1825 .capabilityData = (unsigned char*)"capdata3",
1826 .dataLen = sizeof("capdata3")
1827 };
1828
1829 DiscMgrInit();
1830
1831 ret = DiscSubscribe((DiscModule)TEST_ERRO_MOUDULE1, &testInfo);
1832 TEST_ASSERT_TRUE(ret != 0);
1833
1834 testInfo.medium = (ExchangeMedium)(AUTO - 1);
1835 ret = DiscSubscribe(MODULE_LNN, &testInfo);
1836 TEST_ASSERT_TRUE(ret != 0);
1837 testInfo.medium = COAP;
1838
1839 testInfo.freq = (ExchangeFreq)(LOW - 1);
1840 ret = DiscSubscribe(MODULE_LNN, &testInfo);
1841 TEST_ASSERT_TRUE(ret != 0);
1842 testInfo.freq = LOW;
1843
1844 ret = DiscSubscribe(MODULE_LNN, NULL);
1845 TEST_ASSERT_TRUE(ret != 0);
1846
1847 DiscMgrDeinit();
1848 }
1849
1850 /**
1851 * @tc.name: DiscSubscribeTest007
1852 * @tc.desc: Inner LNN module passive discover，use the wrong parameter.
1853 * @tc.in: test module, test number, Test Levels.
1854 * @tc.out: Nonzero
1855 * @tc.type: FUNC
1856 * @tc.require: The DiscSubscribe operates normally.
1857 */
1858 HWTEST_F(Disc_ManagerTest, DiscSubscribeTest007, TestSize.Level1)
1859 {
1860 int ret;
1861 SubscribeInfo testInfo = {
1862 .subscribeId = TEST_SUBSCRIBEINNER_ID,
1863 .mode = DISCOVER_MODE_PASSIVE,
1864 .medium = AUTO,
1865 .freq = MID,
1866 .isSameAccount = true,
1867 .isWakeRemote = false,
1868 .capability = "dvKit",
1869 .capabilityData = (unsigned char*)"capdata3",
1870 .dataLen = sizeof("capdata3")
1871 };
1872
1873 DiscMgrInit();
1874
1875 ret = DiscSubscribe((DiscModule)TEST_ERRO_MOUDULE1, &testInfo);
1876 TEST_ASSERT_TRUE(ret != 0);
1877
1878 testInfo.medium = (ExchangeMedium)(AUTO - 1);
1879 ret = DiscSubscribe(MODULE_LNN, &testInfo);
1880 TEST_ASSERT_TRUE(ret != 0);
1881 testInfo.medium = COAP;
1882
1883 testInfo.freq = (ExchangeFreq)(LOW - 1);
1884 ret = DiscSubscribe(MODULE_LNN, &testInfo);
1885 TEST_ASSERT_TRUE(ret != 0);
1886 testInfo.freq = LOW;
1887
1888 ret = DiscSubscribe(MODULE_LNN, NULL);
1889 TEST_ASSERT_TRUE(ret != 0);
1890
1891 DiscMgrDeinit();
1892 }
1893
1894 /**
1895 * @tc.name: DiscSubscribeTest008
1896 * @tc.desc: Softbus discovery manager is not init.
1897 * @tc.in: test module, test number, Test Levels.
1898 * @tc.out: Nonzero
1899 * @tc.type: FUNC
1900 * @tc.require: The DiscSubscribe operates normally.
1901 */
1902 HWTEST_F(Disc_ManagerTest, DiscSubscribeTest008, TestSize.Level1)
1903 {
1904 int ret;
1905 SubscribeInfo testInfo = {
1906 .subscribeId = TEST_SUBSCRIBEINNER_ID,
1907 .mode = DISCOVER_MODE_PASSIVE,
1908 .medium = COAP,
1909 .freq = MID,
1910 .isSameAccount = true,
1911 .isWakeRemote = false,
1912 .capability = "dvKit",
1913 .capabilityData = (unsigned char*)"capdata3",
1914 .dataLen = sizeof("capdata3")
1915 };
1916
1917 ret = DiscSubscribe(MODULE_CONN, &testInfo);
1918 TEST_ASSERT_TRUE(ret != 0);
1919 }
1920
1921 /**
1922 * @tc.name: DiscUnpublishTest001
1923 * @tc.desc: Inner CONN module stop publish，the module is not initialized.
1924 * @tc.in: test module, test number, Test Levels.
1925 * @tc.out: Nonzero
1926 * @tc.type: FUNC
1927 * @tc.require: The DiscUnpublish operates normally.
1928 */
1929 HWTEST_F(Disc_ManagerTest, DiscUnpublishTest001, TestSize.Level1)
1930 {
1931 int ret;
1932 ret = DiscUnpublish(MODULE_CONN, TEST_PUBLISHINNER_ID);
1933 TEST_ASSERT_TRUE(ret != 0);
1934 }
1935
1936 /**
1937 * @tc.name: DiscUnpublishTest002
1938 * @tc.desc: Inner LNN module stop publish，use the wrong parameter.
1939 * @tc.in: test module, test number, Test Levels.
1940 * @tc.out: Nonzero
1941 * @tc.type: FUNC
1942 * @tc.require: The DiscUnpublish operates normally.
1943 */
1944 HWTEST_F(Disc_ManagerTest, DiscUnpublishTest002, TestSize.Level1)
1945 {
1946 int ret;
1947 DiscMgrInit();
1948 DiscPublish(MODULE_LNN, &g_pInnerInfo1);
1949
1950 ret = DiscUnpublish((DiscModule)TEST_ERRO_MOUDULE, TEST_PUBLISHINNER_ID);
1951 TEST_ASSERT_TRUE(ret != 0);
1952
1953 DiscMgrDeinit();
1954 }
1955
1956 /**
1957 * @tc.name: DiscUnpublishTest003
1958 * @tc.desc: Inner LNN module stop publish，use the normal parameter.
1959 * @tc.in: test module, test number, Test Levels.
1960 * @tc.out: Zero
1961 * @tc.type: FUNC
1962 * @tc.require: The DiscUnpublish operates normally
1963 */
1964 HWTEST_F(Disc_ManagerTest, DiscUnpublishTest003, TestSize.Level1)
1965 {
1966 int ret;
1967 DiscMgrInit();
1968 DiscPublish(MODULE_LNN, &g_pInnerInfo1);
1969
1970 ret = DiscUnpublish(MODULE_LNN, TEST_PUBLISHINNER_ID1);
1971 TEST_ASSERT_TRUE(ret == 0);
1972
1973 DiscMgrDeinit();
1974 }
1975
1976 /**
1977 * @tc.name: DiscUnpublishTest004
1978 * @tc.desc: Inner LNN module stop publish，release the same parameter again, perform two subscriptions.
1979 * @tc.in: test module, test number, Test Levels.
1980 * @tc.out: Nonzero
1981 * @tc.type: FUNC
1982 * @tc.require: The DiscUnpublish operates normally.
1983 */
1984 HWTEST_F(Disc_ManagerTest, DiscUnpublishTest004, TestSize.Level1)
1985 {
1986 int ret;
1987 DiscMgrInit();
1988 DiscPublish(MODULE_LNN, &g_pInnerInfo1);
1989
1990 ret = DiscUnpublish(MODULE_LNN, TEST_PUBLISHINNER_ID1);
1991
1992 ret = DiscUnpublish(MODULE_LNN, TEST_PUBLISHINNER_ID1);
1993 TEST_ASSERT_TRUE(ret != 0);
1994
1995 DiscMgrDeinit();
1996 }
1997
1998 /**
1999 * @tc.name: DiscUnpublishTest005
2000 * @tc.desc: Inner LNN module stop publish，use the wrong parameter.
2001 * @tc.in: test module, test number, Test Levels.
2002 * @tc.out: Nonzero
2003 * @tc.type: FUNC
2004 * @tc.require: The DiscUppublish operates normally.
2005 */
2006 HWTEST_F(Disc_ManagerTest, DiscUnpublishTest005, TestSize.Level1)
2007 {
2008 int ret;
2009 DiscMgrInit();
2010 DiscPublish(MODULE_LNN, &g_pInnerInfo1);
2011
2012 ret = DiscUnpublish((DiscModule)TEST_ERRO_MOUDULE1, TEST_PUBLISHINNER_ID);
2013 TEST_ASSERT_TRUE(ret != 0);
2014
2015 DiscMgrDeinit();
2016 }
2017
2018 /**
2019 * @tc.name: DiscUnpublishTest006
2020 * @tc.desc: Inner CONN module stop publish，the module initialized, Directly to unpubish.
2021 * @tc.in: test module, test number, Test Levels.
2022 * @tc.out: Nonzero
2023 * @tc.type: FUNC
2024 * @tc.require: The DiscUnpublish operates normally.
2025 */
2026 HWTEST_F(Disc_ManagerTest, DiscUnpublishTest006, TestSize.Level1)
2027 {
2028 int ret;
2029 DiscMgrInit();
2030 ret = DiscUnpublish(MODULE_CONN, TEST_PUBLISHINNER_ID);
2031 TEST_ASSERT_TRUE(ret != 0);
2032 DiscMgrDeinit();
2033 }
2034
2035 /**
2036 * @tc.name: DiscUnpublishTest007
2037 * @tc.desc: Inner LNN module active publish, use the normal parameter and different frequencies under AUTO.
2038 * @tc.in: test module, test number, Test Levels.
2039 * @tc.out: Zero
2040 * @tc.type: FUNC
2041 * @tc.require: The DiscUnpublish operates normally.
2042 */
2043 HWTEST_F(Disc_ManagerTest, DiscUnpublishTest007, TestSize.Level1)
2044 {
2045 int ret;
2046 PublishInfo testInfo = {
2047 .publishId = TEST_PUBLISHINNER_ID,
2048 .mode = DISCOVER_MODE_ACTIVE,
2049 .medium = AUTO,
2050 .freq = LOW,
2051 .capability = "hicall",
2052 .capabilityData = (unsigned char *)"capdata1",
2053 .dataLen = sizeof("capdata1")
2054 };
2055
2056 DiscMgrInit();
2057
2058 DiscPublish(MODULE_LNN, &testInfo);
2059 ret = DiscUnpublish(MODULE_LNN, testInfo.publishId);
2060 TEST_ASSERT_TRUE(ret == 0);
2061
2062 testInfo.freq = MID;
2063 DiscPublish(MODULE_LNN, &testInfo);
2064 ret = DiscUnpublish(MODULE_LNN, testInfo.publishId);
2065 TEST_ASSERT_TRUE(ret == 0);
2066
2067 testInfo.freq = HIGH;
2068 DiscPublish(MODULE_LNN, &testInfo);
2069 ret = DiscUnpublish(MODULE_LNN, testInfo.publishId);
2070 TEST_ASSERT_TRUE(ret == 0);
2071
2072 testInfo.freq = SUPER_HIGH;
2073 DiscPublish(MODULE_LNN, &testInfo);
2074 ret = DiscUnpublish(MODULE_LNN, testInfo.publishId);
2075 TEST_ASSERT_TRUE(ret == 0);
2076
2077 DiscMgrDeinit();
2078 }
2079
2080 /**
2081 * @tc.name: DiscUnpublishTest008
2082 * @tc.desc: Inner CONN module active publish，use the normal parameter and different frequencies under AUTO.
2083 * @tc.in: test module, test number, Test Levels.
2084 * @tc.out: Zero
2085 * @tc.type: FUNC
2086 * @tc.require: The DiscUnpublish operates normally.
2087 */
2088 HWTEST_F(Disc_ManagerTest, DiscUnpublishTest008, TestSize.Level1)
2089 {
2090 int ret;
2091 PublishInfo testInfo = {
2092 .publishId = TEST_PUBLISHINNER_ID,
2093 .mode = DISCOVER_MODE_ACTIVE,
2094 .medium = AUTO,
2095 .freq = LOW,
2096 .capability = "hicall",
2097 .capabilityData = (unsigned char *)"capdata1",
2098 .dataLen = sizeof("capdata1")
2099 };
2100
2101 DiscMgrInit();
2102
2103 DiscPublish(MODULE_CONN, &testInfo);
2104 ret = DiscUnpublish(MODULE_CONN, testInfo.publishId);
2105 TEST_ASSERT_TRUE(ret == 0);
2106
2107 testInfo.freq = MID;
2108 DiscPublish(MODULE_CONN, &testInfo);
2109 ret = DiscUnpublish(MODULE_CONN, testInfo.publishId);
2110 TEST_ASSERT_TRUE(ret == 0);
2111
2112 testInfo.freq = HIGH;
2113 DiscPublish(MODULE_CONN, &testInfo);
2114 ret = DiscUnpublish(MODULE_CONN, testInfo.publishId);
2115 TEST_ASSERT_TRUE(ret == 0);
2116
2117 testInfo.freq = SUPER_HIGH;
2118 DiscPublish(MODULE_CONN, &testInfo);
2119 ret = DiscUnpublish(MODULE_CONN, testInfo.publishId);
2120 TEST_ASSERT_TRUE(ret == 0);
2121
2122 DiscMgrDeinit();
2123 }
2124
2125 /**
2126 * @tc.name: DiscUnpublishTest009
2127 * @tc.desc: Inner LNN module active publish，use the normal parameter and different frequencies under BLE.
2128 * @tc.in: test module, test number, Test Levels.
2129 * @tc.out: Zero
2130 * @tc.type: FUNC
2131 * @tc.require: The DiscUnpublish operates normally.
2132 */
2133 HWTEST_F(Disc_ManagerTest, DiscUnpublishTest009, TestSize.Level1)
2134 {
2135 int ret;
2136 PublishInfo testInfo = {
2137 .publishId = TEST_PUBLISHINNER_ID,
2138 .mode = DISCOVER_MODE_ACTIVE,
2139 .medium = BLE,
2140 .freq = LOW,
2141 .capability = "hicall",
2142 .capabilityData = (unsigned char *)"capdata1",
2143 .dataLen = sizeof("capdata1")
2144 };
2145
2146 DiscMgrInit();
2147
2148 DiscPublish(MODULE_LNN, &testInfo);
2149 ret = DiscUnpublish(MODULE_LNN, testInfo.publishId);
2150 TEST_ASSERT_TRUE(ret == 0);
2151
2152 testInfo.freq = MID;
2153 DiscPublish(MODULE_LNN, &testInfo);
2154 ret = DiscUnpublish(MODULE_LNN, testInfo.publishId);
2155 TEST_ASSERT_TRUE(ret == 0);
2156
2157 testInfo.freq = HIGH;
2158 DiscPublish(MODULE_LNN, &testInfo);
2159 ret = DiscUnpublish(MODULE_LNN, testInfo.publishId);
2160 TEST_ASSERT_TRUE(ret == 0);
2161
2162 testInfo.freq = SUPER_HIGH;
2163 DiscPublish(MODULE_LNN, &testInfo);
2164 ret = DiscUnpublish(MODULE_LNN, testInfo.publishId);
2165 TEST_ASSERT_TRUE(ret == 0);
2166
2167 DiscMgrDeinit();
2168 }
2169
2170 /**
2171 * @tc.name: DiscUnpublishTest010
2172 * @tc.desc: inner CONN module active publish，use the normal parameter and different frequencies under BLE.
2173 * @tc.in: test module, test number, Test Levels.
2174 * @tc.out: Zero
2175 * @tc.type: FUNC
2176 * @tc.require: The DiscUnpublish operates normally.
2177 */
2178 HWTEST_F(Disc_ManagerTest, DiscUnpublishTest010, TestSize.Level1)
2179 {
2180 int ret;
2181 PublishInfo testInfo = {
2182 .publishId = TEST_PUBLISHINNER_ID,
2183 .mode = DISCOVER_MODE_ACTIVE,
2184 .medium = BLE,
2185 .freq = LOW,
2186 .capability = "hicall",
2187 .capabilityData = (unsigned char *)"capdata1",
2188 .dataLen = sizeof("capdata1")
2189 };
2190
2191 DiscMgrInit();
2192
2193 DiscPublish(MODULE_CONN, &testInfo);
2194 ret = DiscUnpublish(MODULE_CONN, testInfo.publishId);
2195 TEST_ASSERT_TRUE(ret == 0);
2196
2197 testInfo.freq = MID;
2198 DiscPublish(MODULE_CONN, &testInfo);
2199 ret = DiscUnpublish(MODULE_CONN, testInfo.publishId);
2200 TEST_ASSERT_TRUE(ret == 0);
2201
2202 testInfo.freq = HIGH;
2203 DiscPublish(MODULE_CONN, &testInfo);
2204 ret = DiscUnpublish(MODULE_CONN, testInfo.publishId);
2205 TEST_ASSERT_TRUE(ret == 0);
2206
2207 testInfo.freq = SUPER_HIGH;
2208 DiscPublish(MODULE_CONN, &testInfo);
2209 ret = DiscUnpublish(MODULE_CONN, testInfo.publishId);
2210 TEST_ASSERT_TRUE(ret == 0);
2211
2212 DiscMgrDeinit();
2213 }
2214
2215 /**
2216 * @tc.name: DiscUnpublishTest011
2217 * @tc.desc: inner LNN module active publish，use the normal parameter and different frequencies under COAP.
2218 * @tc.in: test module, test number, Test Levels.
2219 * @tc.out: Zero
2220 * @tc.type: FUNC
2221 * @tc.require: The DiscUnpublish operates normally.
2222 */
2223 HWTEST_F(Disc_ManagerTest, DiscUnpublishTest011, TestSize.Level1)
2224 {
2225 int ret;
2226 PublishInfo testInfo = {
2227 .publishId = TEST_PUBLISHINNER_ID,
2228 .mode = DISCOVER_MODE_ACTIVE,
2229 .medium = COAP,
2230 .freq = LOW,
2231 .capability = "hicall",
2232 .capabilityData = (unsigned char *)"capdata1",
2233 .dataLen = sizeof("capdata1")
2234 };
2235
2236 DiscMgrInit();
2237
2238 DiscPublish(MODULE_LNN, &testInfo);
2239 ret = DiscUnpublish(MODULE_LNN, testInfo.publishId);
2240 TEST_ASSERT_TRUE(ret == 0);
2241
2242 testInfo.freq = MID;
2243 DiscPublish(MODULE_LNN, &testInfo);
2244 ret = DiscUnpublish(MODULE_LNN, testInfo.publishId);
2245 TEST_ASSERT_TRUE(ret == 0);
2246
2247 testInfo.freq = HIGH;
2248 DiscPublish(MODULE_LNN, &testInfo);
2249 ret = DiscUnpublish(MODULE_LNN, testInfo.publishId);
2250 TEST_ASSERT_TRUE(ret == 0);
2251
2252 testInfo.freq = SUPER_HIGH;
2253 DiscPublish(MODULE_LNN, &testInfo);
2254 ret = DiscUnpublish(MODULE_LNN, testInfo.publishId);
2255 TEST_ASSERT_TRUE(ret == 0);
2256
2257 DiscMgrDeinit();
2258 }
2259
2260 /**
2261 * @tc.name: DiscUnpublishTest012
2262 * @tc.desc: inner CONN module active publish，use the normal parameter and different frequencies under COAP.
2263 * @tc.in: test module, test number, Test Levels.
2264 * @tc.out: Zero
2265 * @tc.type: FUNC
2266 * @tc.require: The DiscUnpublish operates normally.
2267 */
2268 HWTEST_F(Disc_ManagerTest, DiscUnpublishTest012, TestSize.Level1)
2269 {
2270 int ret;
2271 PublishInfo testInfo = {
2272 .publishId = TEST_PUBLISHINNER_ID,
2273 .mode = DISCOVER_MODE_ACTIVE,
2274 .medium = COAP,
2275 .freq = LOW,
2276 .capability = "hicall",
2277 .capabilityData = (unsigned char *)"capdata1",
2278 .dataLen = sizeof("capdata1")
2279 };
2280
2281 DiscMgrInit();
2282
2283 DiscPublish(MODULE_CONN, &testInfo);
2284 ret = DiscUnpublish(MODULE_CONN, testInfo.publishId);
2285 TEST_ASSERT_TRUE(ret == 0);
2286
2287 testInfo.freq = MID;
2288 DiscPublish(MODULE_CONN, &testInfo);
2289 ret = DiscUnpublish(MODULE_CONN, testInfo.publishId);
2290 TEST_ASSERT_TRUE(ret == 0);
2291
2292 testInfo.freq = HIGH;
2293 DiscPublish(MODULE_CONN, &testInfo);
2294 ret = DiscUnpublish(MODULE_CONN, testInfo.publishId);
2295 TEST_ASSERT_TRUE(ret == 0);
2296
2297 testInfo.freq = SUPER_HIGH;
2298 DiscPublish(MODULE_CONN, &testInfo);
2299 ret = DiscUnpublish(MODULE_CONN, testInfo.publishId);
2300 TEST_ASSERT_TRUE(ret == 0);
2301
2302 DiscMgrDeinit();
2303 }
2304
2305 /**
2306 * @tc.name: DiscStopAdvertiseTest001
2307 * @tc.desc: Inner CONN module stop discover，the module is not initialized.
2308 * @tc.in: test module, test number, Test Levels.
2309 * @tc.out: Nonzero
2310 * @tc.type: FUNC
2311 * @tc.require: The DiscStopAdvertise operates normally.
2312 */
2313 HWTEST_F(Disc_ManagerTest, DiscStopAdvertiseTest001, TestSize.Level1)
2314 {
2315 int ret;
2316 ret = DiscStopAdvertise(MODULE_CONN, TEST_SUBSCRIBEINNER_ID);
2317 TEST_ASSERT_TRUE(ret != 0);
2318 }
2319
2320 /**
2321 * @tc.name: DiscStopAdvertiseTest002
2322 * @tc.desc: Inner module stop discover，use the wrong parameter.
2323 * @tc.in: test module, test number, Test Levels.
2324 * @tc.out: Nonzero
2325 * @tc.type: FUNC
2326 * @tc.require: The DiscStopAdvertise operates normally.
2327 */
2328 HWTEST_F(Disc_ManagerTest, DiscStopAdvertiseTest002, TestSize.Level1)
2329 {
2330 int ret;
2331 DiscMgrInit();
2332 DiscStartAdvertise(MODULE_LNN, &g_sInnerInfo);
2333
2334 ret = DiscStopAdvertise((DiscModule)TEST_ERRO_MOUDULE, TEST_SUBSCRIBEINNER_ID);
2335 TEST_ASSERT_TRUE(ret != 0);
2336
2337 DiscMgrDeinit();
2338 }
2339
2340 /**
2341 * @tc.name: DiscStopAdvertiseTest003
2342 * @tc.desc: Inner LNN module stop discover，use the normal parameter.
2343 * @tc.in: test module, test number, Test Levels.
2344 * @tc.out: Zero
2345 * @tc.type: FUNC
2346 * @tc.require: The DiscStopAdvertise operates normally.
2347 */
2348 HWTEST_F(Disc_ManagerTest, DiscStopAdvertiseTest003, TestSize.Level1)
2349 {
2350 int ret;
2351 DiscMgrInit();
2352 DiscStartAdvertise(MODULE_LNN, &g_sInnerInfo);
2353
2354 ret = DiscStopAdvertise(MODULE_LNN, TEST_SUBSCRIBEINNER_ID);
2355 TEST_ASSERT_TRUE(ret == 0);
2356
2357 DiscMgrDeinit();
2358 }
2359
2360 /**
2361 * @tc.name: DiscStopAdvertiseTest004
2362 * @tc.desc: Inner LNN module stop discover，use the same parameter again, perform two subscriptions.
2363 * @tc.in: test module, test number, Test Levels.
2364 * @tc.out: Nonzero
2365 * @tc.type: FUNC
2366 * @tc.require: The DiscStopAdvertise operates normally.
2367 */
2368 HWTEST_F(Disc_ManagerTest, DiscStopAdvertiseTest004, TestSize.Level1)
2369 {
2370 int ret;
2371 DiscMgrInit();
2372 DiscStartAdvertise(MODULE_LNN, &g_sInnerInfo);
2373
2374 ret = DiscStopAdvertise(MODULE_LNN, TEST_SUBSCRIBEINNER_ID);
2375 ret = DiscStopAdvertise(MODULE_LNN, TEST_SUBSCRIBEINNER_ID);
2376 TEST_ASSERT_TRUE(ret != 0);
2377
2378 DiscMgrDeinit();
2379 }
2380
2381 /**
2382 * @tc.name: DiscStopAdvertiseTest005
2383 * @tc.desc: Test inner module stop discover，use the wrong parameter.
2384 * @tc.in: Test module, Test number, Test levels.
2385 * @tc.out: Nonzero
2386 * @tc.type: FUNC
2387 * @tc.require:The DiscStopAdvertise operates normally.
2388 */
2389 HWTEST_F(Disc_ManagerTest, DiscStopAdvertiseTest005, TestSize.Level1)
2390 {
2391 int ret;
2392 DiscMgrInit();
2393 DiscStartAdvertise(MODULE_LNN, &g_sInnerInfo);
2394
2395 ret = DiscStopAdvertise((DiscModule)TEST_ERRO_MOUDULE1, TEST_SUBSCRIBEINNER_ID);
2396 TEST_ASSERT_TRUE(ret != 0);
2397
2398 DiscMgrDeinit();
2399 }
2400
2401 /**
2402 * @tc.name: DiscStopAdvertiseTest006
2403 * @tc.desc: Test inner module stop discover，bur module is not start discover.
2404 * @tc.in: Test module, Test number, Test levels.
2405 * @tc.out: Nonzero
2406 * @tc.type: FUNC
2407 * @tc.require:The DiscStopAdvertise operates normally.
2408 */
2409 HWTEST_F(Disc_ManagerTest, DiscStopAdvertiseTest006, TestSize.Level1)
2410 {
2411 int ret;
2412 DiscMgrInit();
2413 ret = DiscStopAdvertise(MODULE_CONN, TEST_SUBSCRIBEINNER_ID);
2414 TEST_ASSERT_TRUE(ret != 0);
2415 DiscMgrDeinit();
2416 }
2417
2418 /**
2419 * @tc.name: DiscStopAdvertiseTest007
2420 * @tc.desc: Test inner module active discover，use Diff Freq Under the AUTO of MODULE_LNN.
2421 * @tc.in: Test module, Test number, Test levels.
2422 * @tc.out: Zero
2423 * @tc.type: FUNC
2424 * @tc.require:The DiscStopAdvertise operates normally.
2425 */
2426 HWTEST_F(Disc_ManagerTest, DiscStopAdvertiseTest007, TestSize.Level1)
2427 {
2428 int ret;
2429 SubscribeInfo testInfo = {
2430 .subscribeId = TEST_SUBSCRIBEINNER_ID,
2431 .mode = DISCOVER_MODE_ACTIVE,
2432 .medium = AUTO,
2433 .freq = LOW,
2434 .isSameAccount = true,
2435 .isWakeRemote = false,
2436 .capability = "dvKit",
2437 .capabilityData = (unsigned char *)"capdata3",
2438 .dataLen = sizeof("capdata3")
2439 };
2440
2441 DiscMgrInit();
2442
2443 DiscStartAdvertise(MODULE_LNN, &testInfo);
2444 ret = DiscStopAdvertise(MODULE_LNN, testInfo.subscribeId);
2445 TEST_ASSERT_TRUE(ret == 0);
2446
2447 testInfo.freq = MID;
2448 DiscStartAdvertise(MODULE_LNN, &testInfo);
2449 ret = DiscStopAdvertise(MODULE_LNN, testInfo.subscribeId);
2450 TEST_ASSERT_TRUE(ret == 0);
2451
2452 testInfo.freq = HIGH;
2453 DiscStartAdvertise(MODULE_LNN, &testInfo);
2454 ret = DiscStopAdvertise(MODULE_LNN, testInfo.subscribeId);
2455 TEST_ASSERT_TRUE(ret == 0);
2456
2457 testInfo.freq = SUPER_HIGH;
2458 DiscStartAdvertise(MODULE_LNN, &testInfo);
2459 ret = DiscStopAdvertise(MODULE_LNN, testInfo.subscribeId);
2460 TEST_ASSERT_TRUE(ret == 0);
2461
2462 DiscMgrDeinit();
2463 }
2464
2465 /**
2466 * @tc.name: DiscStopAdvertiseTest008
2467 * @tc.desc: Test inner module active discover，use Diff Freq Under the AUTO of MODULE_CONN.
2468 * @tc.in: Test module, Test number, Test levels.
2469 * @tc.out: Zero
2470 * @tc.type: FUNC
2471 * @tc.require:The DiscStopAdvertise operates normally.
2472 */
2473 HWTEST_F(Disc_ManagerTest, DiscStopAdvertiseTest008, TestSize.Level1)
2474 {
2475 int ret;
2476 SubscribeInfo testInfo = {
2477 .subscribeId = TEST_SUBSCRIBEINNER_ID,
2478 .mode = DISCOVER_MODE_ACTIVE,
2479 .medium = AUTO,
2480 .freq = LOW,
2481 .isSameAccount = true,
2482 .isWakeRemote = false,
2483 .capability = "dvKit",
2484 .capabilityData = (unsigned char *)"capdata3",
2485 .dataLen = sizeof("capdata3")
2486 };
2487
2488 DiscMgrInit();
2489
2490 DiscStartAdvertise(MODULE_CONN, &testInfo);
2491 ret = DiscStopAdvertise(MODULE_CONN, testInfo.subscribeId);
2492 TEST_ASSERT_TRUE(ret == 0);
2493
2494 testInfo.freq = MID;
2495 DiscStartAdvertise(MODULE_CONN, &testInfo);
2496 ret = DiscStopAdvertise(MODULE_CONN, testInfo.subscribeId);
2497 TEST_ASSERT_TRUE(ret == 0);
2498
2499 testInfo.freq = HIGH;
2500 DiscStartAdvertise(MODULE_CONN, &testInfo);
2501 ret = DiscStopAdvertise(MODULE_CONN, testInfo.subscribeId);
2502 TEST_ASSERT_TRUE(ret == 0);
2503
2504 testInfo.freq = SUPER_HIGH;
2505 DiscStartAdvertise(MODULE_CONN, &testInfo);
2506 ret = DiscStopAdvertise(MODULE_CONN, testInfo.subscribeId);
2507 TEST_ASSERT_TRUE(ret == 0);
2508
2509 DiscMgrDeinit();
2510 }
2511
2512 /**
2513 * @tc.name: DiscStopAdvertiseTest009
2514 * @tc.desc: Test inner module active discover，use Diff Freq Under the BLE of MODULE_LNN.
2515 * @tc.in: Test module, Test number, Test levels.
2516 * @tc.out: Zero
2517 * @tc.type: FUNC
2518 * @tc.require:The DiscStopAdvertise operates normally.
2519 */
2520 HWTEST_F(Disc_ManagerTest, DiscStopAdvertiseTest009, TestSize.Level1)
2521 {
2522 int ret;
2523 SubscribeInfo testInfo = {
2524 .subscribeId = TEST_SUBSCRIBEINNER_ID,
2525 .mode = DISCOVER_MODE_ACTIVE,
2526 .medium = BLE,
2527 .freq = LOW,
2528 .isSameAccount = true,
2529 .isWakeRemote = false,
2530 .capability = "dvKit",
2531 .capabilityData = (unsigned char *)"capdata3",
2532 .dataLen = sizeof("capdata3")
2533 };
2534
2535 DiscMgrInit();
2536
2537 DiscStartAdvertise(MODULE_LNN, &testInfo);
2538 ret = DiscStopAdvertise(MODULE_LNN, testInfo.subscribeId);
2539 TEST_ASSERT_TRUE(ret == 0);
2540
2541 testInfo.freq = MID;
2542 DiscStartAdvertise(MODULE_LNN, &testInfo);
2543 ret = DiscStopAdvertise(MODULE_LNN, testInfo.subscribeId);
2544 TEST_ASSERT_TRUE(ret == 0);
2545
2546 testInfo.freq = HIGH;
2547 DiscStartAdvertise(MODULE_LNN, &testInfo);
2548 ret = DiscStopAdvertise(MODULE_LNN, testInfo.subscribeId);
2549 TEST_ASSERT_TRUE(ret == 0);
2550
2551 testInfo.freq = SUPER_HIGH;
2552 DiscStartAdvertise(MODULE_LNN, &testInfo);
2553 ret = DiscStopAdvertise(MODULE_LNN, testInfo.subscribeId);
2554 TEST_ASSERT_TRUE(ret == 0);
2555
2556 DiscMgrDeinit();
2557 }
2558
2559 /**
2560 * @tc.name: DiscStopAdvertiseTest010
2561 * @tc.desc: Test inner module active discover，use Diff Freq Under the BLE of MODULE_CONN.
2562 * @tc.in: Test module, Test number, Test levels.
2563 * @tc.out: Zero
2564 * @tc.type: FUNC
2565 * @tc.require:The DiscStopAdvertise operates normally.
2566 */
2567 HWTEST_F(Disc_ManagerTest, DiscStopAdvertiseTest010, TestSize.Level1)
2568 {
2569 int ret;
2570 SubscribeInfo testInfo = {
2571 .subscribeId = TEST_SUBSCRIBEINNER_ID,
2572 .mode = DISCOVER_MODE_ACTIVE,
2573 .medium = BLE,
2574 .freq = LOW,
2575 .isSameAccount = true,
2576 .isWakeRemote = false,
2577 .capability = "dvKit",
2578 .capabilityData = (unsigned char *)"capdata3",
2579 .dataLen = sizeof("capdata3")
2580 };
2581
2582 DiscMgrInit();
2583
2584 DiscStartAdvertise(MODULE_CONN, &testInfo);
2585 ret = DiscStopAdvertise(MODULE_CONN, testInfo.subscribeId);
2586 TEST_ASSERT_TRUE(ret == 0);
2587
2588 testInfo.freq = MID;
2589 DiscStartAdvertise(MODULE_CONN, &testInfo);
2590 ret = DiscStopAdvertise(MODULE_CONN, testInfo.subscribeId);
2591 TEST_ASSERT_TRUE(ret == 0);
2592
2593 testInfo.freq = HIGH;
2594 DiscStartAdvertise(MODULE_CONN, &testInfo);
2595 ret = DiscStopAdvertise(MODULE_CONN, testInfo.subscribeId);
2596 TEST_ASSERT_TRUE(ret == 0);
2597
2598 testInfo.freq = SUPER_HIGH;
2599 DiscStartAdvertise(MODULE_CONN, &testInfo);
2600 ret = DiscStopAdvertise(MODULE_CONN, testInfo.subscribeId);
2601 TEST_ASSERT_TRUE(ret == 0);
2602
2603 DiscMgrDeinit();
2604 }
2605
2606 /**
2607 * @tc.name: DiscStopAdvertiseTest011
2608 * @tc.desc: Test inner module active discover，use Diff Freq Under the COAP of MODULE_LNN.
2609 * @tc.in: Test module, Test number, Test levels.
2610 * @tc.out: Zero
2611 * @tc.type: FUNC
2612 * @tc.require:The DiscStopAdvertise operates normally.
2613 */
2614 HWTEST_F(Disc_ManagerTest, DiscStopAdvertiseTest011, TestSize.Level1)
2615 {
2616 int ret;
2617 SubscribeInfo testInfo = {
2618 .subscribeId = TEST_SUBSCRIBEINNER_ID,
2619 .mode = DISCOVER_MODE_ACTIVE,
2620 .medium = COAP,
2621 .freq = LOW,
2622 .isSameAccount = true,
2623 .isWakeRemote = false,
2624 .capability = "dvKit",
2625 .capabilityData = (unsigned char *)"capdata3",
2626 .dataLen = sizeof("capdata3")
2627 };
2628
2629 DiscMgrInit();
2630
2631 DiscStartAdvertise(MODULE_LNN, &testInfo);
2632 ret = DiscStopAdvertise(MODULE_LNN, testInfo.subscribeId);
2633 TEST_ASSERT_TRUE(ret == 0);
2634
2635 testInfo.freq = MID;
2636 DiscStartAdvertise(MODULE_LNN, &testInfo);
2637 ret = DiscStopAdvertise(MODULE_LNN, testInfo.subscribeId);
2638 TEST_ASSERT_TRUE(ret == 0);
2639
2640 testInfo.freq = HIGH;
2641 DiscStartAdvertise(MODULE_LNN, &testInfo);
2642 ret = DiscStopAdvertise(MODULE_LNN, testInfo.subscribeId);
2643 TEST_ASSERT_TRUE(ret == 0);
2644
2645 testInfo.freq = SUPER_HIGH;
2646 DiscStartAdvertise(MODULE_LNN, &testInfo);
2647 ret = DiscStopAdvertise(MODULE_LNN, testInfo.subscribeId);
2648 TEST_ASSERT_TRUE(ret == 0);
2649
2650 DiscMgrDeinit();
2651 }
2652
2653 /**
2654 * @tc.name: DiscStopAdvertiseTest012
2655 * @tc.desc: Test inner module active discover，use Diff Freq Under the COAP of MODULE_CONN.
2656 * @tc.in: Test module, Test number, Test levels.
2657 * @tc.out: Zero
2658 * @tc.type: FUNC
2659 * @tc.require:The DiscStopAdvertise operates normally.
2660 */
2661 HWTEST_F(Disc_ManagerTest, DiscStopAdvertiseTest012, TestSize.Level1)
2662 {
2663 int ret;
2664 SubscribeInfo testInfo = {
2665 .subscribeId = TEST_SUBSCRIBEINNER_ID,
2666 .mode = DISCOVER_MODE_ACTIVE,
2667 .medium = COAP,
2668 .freq = LOW,
2669 .isSameAccount = true,
2670 .isWakeRemote = false,
2671 .capability = "dvKit",
2672 .capabilityData = (unsigned char *)"capdata3",
2673 .dataLen = sizeof("capdata3")
2674 };
2675
2676 DiscMgrInit();
2677
2678 DiscStartAdvertise(MODULE_CONN, &testInfo);
2679 ret = DiscStopAdvertise(MODULE_CONN, testInfo.subscribeId);
2680 TEST_ASSERT_TRUE(ret == 0);
2681
2682 testInfo.freq = MID;
2683 DiscStartAdvertise(MODULE_CONN, &testInfo);
2684 ret = DiscStopAdvertise(MODULE_CONN, testInfo.subscribeId);
2685 TEST_ASSERT_TRUE(ret == 0);
2686
2687 testInfo.freq = HIGH;
2688 DiscStartAdvertise(MODULE_CONN, &testInfo);
2689 ret = DiscStopAdvertise(MODULE_CONN, testInfo.subscribeId);
2690 TEST_ASSERT_TRUE(ret == 0);
2691
2692 testInfo.freq = SUPER_HIGH;
2693 DiscStartAdvertise(MODULE_CONN, &testInfo);
2694 ret = DiscStopAdvertise(MODULE_CONN, testInfo.subscribeId);
2695 TEST_ASSERT_TRUE(ret == 0);
2696
2697 DiscMgrDeinit();
2698 }
2699
2700 /**
2701 * @tc.name: PublishServiceTest001
2702 * @tc.desc: Extern module publish，the module is not initialized.
2703 * @tc.in: test module, test number, Test Levels.
2704 * @tc.out: Nonzero
2705 * @tc.type: FUNC
2706 * @tc.require: The DiscPublishService operates normally.
2707 */
2708 HWTEST_F(Disc_ManagerTest, PublishServiceTest001, TestSize.Level1)
2709 {
2710 int ret;
2711 ret = DiscPublishService("pkgname1", &g_pInfo);
2712 TEST_ASSERT_TRUE(ret != 0);
2713 }
2714
2715 /**
2716 * @tc.name: PublishServiceTest002
2717 * @tc.desc: Extern module active publish，use the wrong parameter.
2718 * @tc.in: test module, test number, Test Levels.
2719 * @tc.out: Nonzero
2720 * @tc.type: FUNC
2721 * @tc.require: The DiscPublishService operates normally.
2722 */
2723 HWTEST_F(Disc_ManagerTest, PublishServiceTest002, TestSize.Level1)
2724 {
2725 int ret;
2726 PublishInfo testInfo = {.publishId = TEST_PUBLISH_ID,
2727 .mode = DISCOVER_MODE_ACTIVE,
2728 .medium = COAP,
2729 .freq = MID,
2730 .capability = "dvKit",
2731 .capabilityData = (unsigned char *)"capdata2",
2732 .dataLen = sizeof("capdata2")};
2733
2734 DiscMgrInit();
2735
2736 ret = DiscPublishService(NULL, &testInfo);
2737 TEST_ASSERT_TRUE(ret != 0);
2738
2739 ret = DiscPublishService(g_erroPkgName, &testInfo);
2740 TEST_ASSERT_TRUE(ret != 0);
2741
2742 ret = DiscPublishService("pkgname1", NULL);
2743 TEST_ASSERT_TRUE(ret != 0);
2744
2745 ret = DiscPublishService("pkgname1", &testInfo);
2746 TEST_ASSERT_TRUE(ret != 0);
2747
2748 testInfo.medium = (ExchangeMedium)(COAP + 1);
2749 ret = DiscPublishService("pkgname1", &testInfo);
2750 TEST_ASSERT_TRUE(ret != 0);
2751 testInfo.medium = COAP;
2752
2753 testInfo.mode = (DiscoverMode)(DISCOVER_MODE_ACTIVE + 1);
2754 ret = DiscPublishService("pkgname1", &testInfo);
2755 TEST_ASSERT_TRUE(ret != 0);
2756 testInfo.mode = DISCOVER_MODE_ACTIVE;
2757
2758 testInfo.freq = (ExchangeFreq)(SUPER_HIGH + 1);
2759 ret = DiscPublishService("pkgname1", &testInfo);
2760 TEST_ASSERT_TRUE(ret != 0);
2761 testInfo.freq = LOW;
2762
2763 testInfo.capability = "dvKit";
2764 testInfo.capabilityData = NULL;
2765 ret = DiscPublishService("pkgname1", &testInfo);
2766 TEST_ASSERT_TRUE(ret != 0);
2767 testInfo.capabilityData = (unsigned char *)"capdata1";
2768
2769 testInfo.dataLen = ERRO_CAPDATA_LEN;
2770 ret = DiscPublishService("pkgname1", &testInfo);
2771 TEST_ASSERT_TRUE(ret != 0);
2772 testInfo.dataLen = sizeof("capdata1");
2773
2774 DiscMgrDeinit();
2775 }
2776
2777 /**
2778 * @tc.name: PublishServiceTest003
2779 * @tc.desc: Extern module publish，use the normal parameter.
2780 * @tc.in: test module, test number, Test Levels.
2781 * @tc.out: Zero
2782 * @tc.type: FUNC
2783 * @tc.require: The DiscPublishService operates normally
2784 */
2785 HWTEST_F(Disc_ManagerTest, PublishServiceTest003, TestSize.Level1)
2786 {
2787 int ret;
2788 DiscMgrInit();
2789
2790 ret = DiscPublishService("pkgname1", &g_pInfo);
2791 TEST_ASSERT_TRUE(ret == 0);
2792
2793 ret = DiscPublishService("pkgname1", &g_pInfo1);
2794 TEST_ASSERT_TRUE(ret == 0);
2795
2796 ret = DiscPublishService(g_corrPkgName, &g_pInfo);
2797 TEST_ASSERT_TRUE(ret == 0);
2798
2799 DiscMgrDeinit();
2800 }
2801
2802 /**
2803 * @tc.name: PublishServiceTest004
2804 * @tc.desc: Extern module publish，use the same parameter again, perform two subscriptions.
2805 * @tc.in: test module, test number, Test Levels.
2806 * @tc.out: Zero
2807 * @tc.type: FUNC
2808 * @tc.require: The DiscPublishService operates normally.
2809 */
2810 HWTEST_F(Disc_ManagerTest, PublishServiceTest004, TestSize.Level1)
2811 {
2812 int ret;
2813 DiscMgrInit();
2814
2815 ret = DiscPublishService("pkgname1", &g_pInfo);
2816 ret = DiscPublishService("pkgname1", &g_pInfo);
2817 TEST_ASSERT_TRUE(ret != 0);
2818
2819 DiscMgrDeinit();
2820 }
2821
2822 /**
2823 * @tc.name: PublishServiceTest005
2824 * @tc.desc: Test extern module active publish，use the wrong Medium and Freq Under the COAP.
2825 * @tc.in: Test module, Test number, Test Levels.
2826 * @tc.out: Nonzero
2827 * @tc.type: FUNC
2828 * @tc.require: The DiscPublishService operates normally.
2829 */
2830 HWTEST_F(Disc_ManagerTest, PublishServiceTest005, TestSize.Level1)
2831 {
2832 int ret;
2833 PublishInfo testInfo = {
2834 .publishId = TEST_PUBLISH_ID,
2835 .mode = DISCOVER_MODE_ACTIVE,
2836 .medium = COAP,
2837 .freq = MID,
2838 .capability = "dvKit",
2839 .capabilityData = (unsigned char *)"capdata2",
2840 .dataLen = sizeof("capdata2")
2841 };
2842
2843 DiscMgrInit();
2844
2845 testInfo.medium = (ExchangeMedium)(AUTO - 1);
2846 ret = DiscPublishService("pkgname1", &testInfo);
2847 TEST_ASSERT_TRUE(ret != 0);
2848 testInfo.medium = COAP;
2849
2850 testInfo.freq = (ExchangeFreq)(LOW - 1);
2851 ret = DiscPublishService("pkgname1", &testInfo);
2852 TEST_ASSERT_TRUE(ret != 0);
2853 testInfo.freq = LOW;
2854
2855 DiscMgrDeinit();
2856 }
2857
2858 /**
2859 * @tc.name: PublishServiceTest006
2860 * @tc.desc: Test extern module active publish，use wrong Medium and Freq Under the BLE.
2861 * @tc.in: Test module, Test number, Test Levels.
2862 * @tc.out: Nonzero
2863 * @tc.type: FUNC
2864 * @tc.require: The DiscPublishService operates normally.
2865 */
2866 HWTEST_F(Disc_ManagerTest, PublishServiceTest006, TestSize.Level1)
2867 {
2868 int ret;
2869 PublishInfo testInfo = {
2870 .publishId = TEST_PUBLISH_ID,
2871 .mode = DISCOVER_MODE_ACTIVE,
2872 .medium = BLE,
2873 .freq = MID,
2874 .capability = "dvKit",
2875 .capabilityData = (unsigned char *)"capdata2",
2876 .dataLen = sizeof("capdata2")
2877 };
2878
2879 DiscMgrInit();
2880
2881 testInfo.medium = (ExchangeMedium)(AUTO - 1);
2882 ret = DiscPublishService("pkgname1", &testInfo);
2883 TEST_ASSERT_TRUE(ret != 0);
2884 testInfo.medium = COAP;
2885
2886 testInfo.freq = (ExchangeFreq)(LOW - 1);
2887 ret = DiscPublishService("pkgname1", &testInfo);
2888 TEST_ASSERT_TRUE(ret != 0);
2889 testInfo.freq = LOW;
2890
2891 DiscMgrDeinit();
2892 }
2893
2894 /**
2895 * @tc.name: PublishServiceTest007
2896 * @tc.desc: Test extern module active publish，use wrong Medium and Freq Under the AUTO.
2897 * @tc.in: Test module, Test number, Test Levels.
2898 * @tc.out: Nonzero
2899 * @tc.type: FUNC
2900 * @tc.require: The DiscPublishService operates normally.
2901 */
2902 HWTEST_F(Disc_ManagerTest, PublishServiceTest007, TestSize.Level1)
2903 {
2904 int ret;
2905 PublishInfo testInfo = {
2906 .publishId = TEST_PUBLISH_ID,
2907 .mode = DISCOVER_MODE_ACTIVE,
2908 .medium = AUTO,
2909 .freq = MID,
2910 .capability = "dvKit",
2911 .capabilityData = (unsigned char *)"capdata2",
2912 .dataLen = sizeof("capdata2")
2913 };
2914
2915 DiscMgrInit();
2916
2917 testInfo.medium = (ExchangeMedium)(AUTO - 1);
2918 ret = DiscPublishService("pkgname1", &testInfo);
2919 TEST_ASSERT_TRUE(ret != 0);
2920 testInfo.medium = COAP;
2921
2922 testInfo.freq = (ExchangeFreq)(LOW - 1);
2923 ret = DiscPublishService("pkgname1", &testInfo);
2924 TEST_ASSERT_TRUE(ret != 0);
2925 testInfo.freq = LOW;
2926
2927 DiscMgrDeinit();
2928 }
2929
2930 /**
2931 * @tc.name: PublishServiceTest008
2932 * @tc.desc: Test extern module active publish，use Diff Freq Under the AUTO.
2933 * @tc.in: Test module, Test number, Test Levels.
2934 * @tc.out: Zero
2935 * @tc.type: FUNC
2936 * @tc.require: The DiscPublishService operates normally.
2937 */
2938 HWTEST_F(Disc_ManagerTest, PublishServiceTest008, TestSize.Level1)
2939 {
2940 int ret;
2941 PublishInfo testInfo = {
2942 .publishId = TEST_PUBLISH_ID,
2943 .mode = DISCOVER_MODE_ACTIVE,
2944 .medium = AUTO,
2945 .freq = LOW,
2946 .capability = "dvKit",
2947 .capabilityData = (unsigned char *)"capdata2",
2948 .dataLen = sizeof("capdata2")
2949 };
2950
2951 DiscMgrInit();
2952
2953 ret = DiscPublishService("pkgname1", &testInfo);
2954 TEST_ASSERT_TRUE(ret == 0);
2955 DiscUnPublishService("pkgname1", testInfo.publishId);
2956
2957 testInfo.freq = MID;
2958 ret = DiscPublishService("pkgname1", &testInfo);
2959 TEST_ASSERT_TRUE(ret == 0);
2960 DiscUnPublishService("pkgname1", testInfo.publishId);
2961
2962 testInfo.freq = HIGH;
2963 ret = DiscPublishService("pkgname1", &testInfo);
2964 TEST_ASSERT_TRUE(ret == 0);
2965 DiscUnPublishService("pkgname1", testInfo.publishId);
2966
2967 testInfo.freq = SUPER_HIGH;
2968 ret = DiscPublishService("pkgname1", &testInfo);
2969 TEST_ASSERT_TRUE(ret == 0);
2970 DiscUnPublishService("pkgname1", testInfo.publishId);
2971
2972 DiscMgrDeinit();
2973 }
2974
2975 /**
2976 * @tc.name: PublishServiceTest009
2977 * @tc.desc: Test extern module passive publish，use Diff Freq Under the AUTO.
2978 * @tc.in: Test module, Test number, Test Levels.
2979 * @tc.out: Zero
2980 * @tc.type: FUNC
2981 * @tc.require: The DiscPublishService operates normally.
2982 */
2983 HWTEST_F(Disc_ManagerTest, PublishServiceTest009, TestSize.Level1)
2984 {
2985 int ret;
2986 PublishInfo testInfo = {
2987 .publishId = TEST_PUBLISH_ID,
2988 .mode = DISCOVER_MODE_PASSIVE,
2989 .medium = AUTO,
2990 .freq = LOW,
2991 .capability = "dvKit",
2992 .capabilityData = (unsigned char *)"capdata2",
2993 .dataLen = sizeof("capdata2")
2994 };
2995
2996 DiscMgrInit();
2997
2998 ret = DiscPublishService("pkgname1", &testInfo);
2999 TEST_ASSERT_TRUE(ret == 0);
3000 DiscUnPublishService("pkgname1", testInfo.publishId);
3001
3002 testInfo.freq = MID;
3003 ret = DiscPublishService("pkgname1", &testInfo);
3004 TEST_ASSERT_TRUE(ret == 0);
3005 DiscUnPublishService("pkgname1", testInfo.publishId);
3006
3007 testInfo.freq = HIGH;
3008 ret = DiscPublishService("pkgname1", &testInfo);
3009 TEST_ASSERT_TRUE(ret == 0);
3010 DiscUnPublishService("pkgname1", testInfo.publishId);
3011
3012 testInfo.freq = SUPER_HIGH;
3013 ret = DiscPublishService("pkgname1", &testInfo);
3014 TEST_ASSERT_TRUE(ret == 0);
3015 DiscUnPublishService("pkgname1", testInfo.publishId);
3016
3017 DiscMgrDeinit();
3018 }
3019
3020 /**
3021 * @tc.name: PublishServiceTest010
3022 * @tc.desc: Test extern module active publish，use Diff Freq Under the BLE.
3023 * @tc.in: Test module, Test number, Test Levels.
3024 * @tc.out: Zero
3025 * @tc.type: FUNC
3026 * @tc.require: The DiscPublishService operates normally.
3027 */
3028 HWTEST_F(Disc_ManagerTest, PublishServiceTest010, TestSize.Level1)
3029 {
3030 int ret;
3031 PublishInfo testInfo = {
3032 .publishId = TEST_PUBLISH_ID,
3033 .mode = DISCOVER_MODE_ACTIVE,
3034 .medium = BLE,
3035 .freq = LOW,
3036 .capability = "dvKit",
3037 .capabilityData = (unsigned char *)"capdata2",
3038 .dataLen = sizeof("capdata2")
3039 };
3040
3041 DiscMgrInit();
3042
3043 ret = DiscPublishService("pkgname1", &testInfo);
3044 TEST_ASSERT_TRUE(ret == 0);
3045 DiscUnPublishService("pkgname1", testInfo.publishId);
3046
3047 testInfo.freq = MID;
3048 ret = DiscPublishService("pkgname1", &testInfo);
3049 TEST_ASSERT_TRUE(ret == 0);
3050 DiscUnPublishService("pkgname1", testInfo.publishId);
3051
3052 testInfo.freq = HIGH;
3053 ret = DiscPublishService("pkgname1", &testInfo);
3054 TEST_ASSERT_TRUE(ret == 0);
3055 DiscUnPublishService("pkgname1", testInfo.publishId);
3056
3057 testInfo.freq = SUPER_HIGH;
3058 ret = DiscPublishService("pkgname1", &testInfo);
3059 TEST_ASSERT_TRUE(ret == 0);
3060 DiscUnPublishService("pkgname1", testInfo.publishId);
3061
3062 DiscMgrDeinit();
3063 }
3064
3065 /**
3066 * @tc.name: PublishServiceTest011
3067 * @tc.desc: Test extern module passive publish，use Diff Freq Under the BLE.
3068 * @tc.in: Test module, Test number, Test Levels.
3069 * @tc.out: Zero
3070 * @tc.type: FUNC
3071 * @tc.require: The DiscPublishService operates normally.
3072 */
3073 HWTEST_F(Disc_ManagerTest, PublishServiceTest011, TestSize.Level1)
3074 {
3075 int ret;
3076 PublishInfo testInfo = {
3077 .publishId = TEST_PUBLISH_ID,
3078 .mode = DISCOVER_MODE_PASSIVE,
3079 .medium = BLE,
3080 .freq = LOW,
3081 .capability = "dvKit",
3082 .capabilityData = (unsigned char *)"capdata2",
3083 .dataLen = sizeof("capdata2")
3084 };
3085
3086 DiscMgrInit();
3087
3088 ret = DiscPublishService("pkgname1", &testInfo);
3089 TEST_ASSERT_TRUE(ret == 0);
3090 DiscUnPublishService("pkgname1", testInfo.publishId);
3091
3092 testInfo.freq = MID;
3093 ret = DiscPublishService("pkgname1", &testInfo);
3094 TEST_ASSERT_TRUE(ret == 0);
3095 DiscUnPublishService("pkgname1", testInfo.publishId);
3096
3097 testInfo.freq = HIGH;
3098 ret = DiscPublishService("pkgname1", &testInfo);
3099 TEST_ASSERT_TRUE(ret == 0);
3100 DiscUnPublishService("pkgname1", testInfo.publishId);
3101
3102 testInfo.freq = SUPER_HIGH;
3103 ret = DiscPublishService("pkgname1", &testInfo);
3104 TEST_ASSERT_TRUE(ret == 0);
3105 DiscUnPublishService("pkgname1", testInfo.publishId);
3106
3107 DiscMgrDeinit();
3108 }
3109
3110 /**
3111 * @tc.name: PublishServiceTest012
3112 * @tc.desc: Test extern module active publish，use Diff Freq Under the COAP.
3113 * @tc.in: Test module, Test number, Test Levels.
3114 * @tc.out: Zero
3115 * @tc.type: FUNC
3116 * @tc.require: The DiscPublishService operates normally.
3117 */
3118 HWTEST_F(Disc_ManagerTest, PublishServiceTest012, TestSize.Level1)
3119 {
3120 int ret;
3121 PublishInfo testInfo = {
3122 .publishId = TEST_PUBLISH_ID,
3123 .mode = DISCOVER_MODE_ACTIVE,
3124 .medium = COAP,
3125 .freq = LOW,
3126 .capability = "dvKit",
3127 .capabilityData = (unsigned char *)"capdata2",
3128 .dataLen = sizeof("capdata2")
3129 };
3130
3131 DiscMgrInit();
3132
3133 ret = DiscPublishService("pkgname1", &testInfo);
3134 TEST_ASSERT_TRUE(ret == 0);
3135 DiscUnPublishService("pkgname1", testInfo.publishId);
3136
3137 testInfo.freq = MID;
3138 ret = DiscPublishService("pkgname1", &testInfo);
3139 TEST_ASSERT_TRUE(ret == 0);
3140 DiscUnPublishService("pkgname1", testInfo.publishId);
3141
3142 testInfo.freq = HIGH;
3143 ret = DiscPublishService("pkgname1", &testInfo);
3144 TEST_ASSERT_TRUE(ret == 0);
3145 DiscUnPublishService("pkgname1", testInfo.publishId);
3146
3147 testInfo.freq = SUPER_HIGH;
3148 ret = DiscPublishService("pkgname1", &testInfo);
3149 TEST_ASSERT_TRUE(ret == 0);
3150 DiscUnPublishService("pkgname1", testInfo.publishId);
3151
3152 DiscMgrDeinit();
3153 }
3154
3155 /**
3156 * @tc.name: PublishServiceTest013
3157 * @tc.desc: Test extern module passive publish，use Diff Freq Under the COAP.
3158 * @tc.in: Test module, Test number, Test Levels.
3159 * @tc.out: Zero
3160 * @tc.type: FUNC
3161 * @tc.require: The DiscPublishService operates normally.
3162 */
3163 HWTEST_F(Disc_ManagerTest, PublishServiceTest013, TestSize.Level1)
3164 {
3165 int ret;
3166 PublishInfo testInfo = {
3167 .publishId = TEST_PUBLISH_ID,
3168 .mode = DISCOVER_MODE_PASSIVE,
3169 .medium = COAP,
3170 .freq = LOW,
3171 .capability = "dvKit",
3172 .capabilityData = (unsigned char *)"capdata2",
3173 .dataLen = sizeof("capdata2")
3174 };
3175
3176 DiscMgrInit();
3177
3178 ret = DiscPublishService("pkgname1", &testInfo);
3179 TEST_ASSERT_TRUE(ret == 0);
3180 DiscUnPublishService("pkgname1", testInfo.publishId);
3181
3182 testInfo.freq = MID;
3183 ret = DiscPublishService("pkgname1", &testInfo);
3184 TEST_ASSERT_TRUE(ret == 0);
3185 DiscUnPublishService("pkgname1", testInfo.publishId);
3186
3187 testInfo.freq = HIGH;
3188 ret = DiscPublishService("pkgname1", &testInfo);
3189 TEST_ASSERT_TRUE(ret == 0);
3190 DiscUnPublishService("pkgname1", testInfo.publishId);
3191
3192 testInfo.freq = SUPER_HIGH;
3193 ret = DiscPublishService("pkgname1", &testInfo);
3194 TEST_ASSERT_TRUE(ret == 0);
3195 DiscUnPublishService("pkgname1", testInfo.publishId);
3196
3197 DiscMgrDeinit();
3198 }
3199
3200 /**
3201 * @tc.name: StartDiscoveryTest001
3202 * @tc.desc: Extern module discover，the module is not initialized.
3203 * @tc.in: test module, test number, Test Levels.
3204 * @tc.out: Nonzero
3205 * @tc.type: FUNC
3206 * @tc.require: The DiscStartDiscovery operates normally.
3207 */
3208 HWTEST_F(Disc_ManagerTest, StartDiscoveryTest001, TestSize.Level1)
3209 {
3210 int ret;
3211 ret = DiscStartDiscovery("pkgname1", &g_sInfo, &g_subscribeCb);
3212 TEST_ASSERT_TRUE(ret != 0);
3213 }
3214
3215 /**
3216 * @tc.name: StartDiscoveryTest002
3217 * @tc.desc: Extern module active discover，use the wrong parameter.
3218 * @tc.in: test module, test number, Test Levels.
3219 * @tc.out: Zero
3220 * @tc.type: FUNC
3221 * @tc.require: The DiscStartDiscovery operates normally
3222 */
3223 HWTEST_F(Disc_ManagerTest, StartDiscoveryTest002, TestSize.Level1)
3224 {
3225 int ret;
3226 SubscribeInfo testInfo = {.subscribeId = TEST_SUBSCRIBEINNER_ID,
3227 .mode = DISCOVER_MODE_ACTIVE,
3228 .medium = COAP,
3229 .freq = MID,
3230 .isSameAccount = true,
3231 .isWakeRemote = false,
3232 .capability = "dvKit",
3233 .capabilityData = (unsigned char *)"capdata3",
3234 .dataLen = sizeof("capdata3")};
3235
3236 DiscMgrInit();
3237
3238 ret = DiscStartDiscovery(NULL, &testInfo, &g_subscribeCb);
3239 TEST_ASSERT_TRUE(ret != 0);
3240
3241 ret = DiscStartDiscovery(g_erroPkgName, &testInfo, &g_subscribeCb);
3242 TEST_ASSERT_TRUE(ret != 0);
3243
3244 ret = DiscStartDiscovery("pkgname1", NULL, &g_subscribeCb);
3245 TEST_ASSERT_TRUE(ret != 0);
3246
3247 ret = DiscStartDiscovery("pkgname1", &testInfo, NULL);
3248 TEST_ASSERT_TRUE(ret != 0);
3249
3250 testInfo.medium = (ExchangeMedium)(COAP + 1);
3251 ret = DiscStartDiscovery("pkgname1", &testInfo, &g_subscribeCb);
3252 TEST_ASSERT_TRUE(ret != 0);
3253 testInfo.medium = COAP;
3254
3255 testInfo.mode = (DiscoverMode)(DISCOVER_MODE_ACTIVE + 1);
3256 ret = DiscStartDiscovery("pkgname1", &testInfo, &g_subscribeCb);
3257 TEST_ASSERT_TRUE(ret != 0);
3258 testInfo.mode = DISCOVER_MODE_ACTIVE;
3259
3260 testInfo.freq = (ExchangeFreq)(SUPER_HIGH + 1);
3261 ret = DiscStartDiscovery("pkgname1", &testInfo, &g_subscribeCb);
3262 TEST_ASSERT_TRUE(ret != 0);
3263 testInfo.freq = LOW;
3264
3265 testInfo.capability = "dvKit";
3266 testInfo.capabilityData = NULL;
3267 ret = DiscStartDiscovery("pkgname1", &testInfo, &g_subscribeCb);
3268 TEST_ASSERT_TRUE(ret != 0);
3269 testInfo.capabilityData = (unsigned char *)"capdata1";
3270
3271 testInfo.dataLen = ERRO_CAPDATA_LEN;
3272 ret = DiscStartDiscovery("pkgname1", &testInfo, &g_subscribeCb);
3273 TEST_ASSERT_TRUE(ret != 0);
3274 testInfo.dataLen = sizeof("capdata1");
3275
3276 DiscMgrDeinit();
3277 }
3278
3279 /**
3280 * @tc.name: StartDiscoveryTest003
3281 * @tc.desc: Extern module discover，use the normal parameter.
3282 * @tc.in: test module, test number, Test Levels.
3283 * @tc.out: Zero
3284 * @tc.type: FUNC
3285 * @tc.require: The DiscStartDiscovery operates normally.
3286 */
3287 HWTEST_F(Disc_ManagerTest, StartDiscoveryTest003, TestSize.Level1)
3288 {
3289 int ret;
3290 DiscMgrInit();
3291
3292 ret = DiscStartDiscovery("pkgname1", &g_sInfo, &g_subscribeCb);
3293 TEST_ASSERT_TRUE(ret == 0);
3294
3295 ret = DiscStartDiscovery("pkgname1", &g_sInfo1, &g_subscribeCb);
3296 TEST_ASSERT_TRUE(ret == 0);
3297
3298 ret = DiscStartDiscovery(g_corrPkgName, &g_sInfo, &g_subscribeCb);
3299 TEST_ASSERT_TRUE(ret == 0);
3300
3301 DiscMgrDeinit();
3302 }
3303
3304 /**
3305 * @tc.name: StartDiscoveryTest004
3306 * @tc.desc: Extern module discover，use the same parameter again, perform two subscriptions.
3307 * @tc.in: test module, test number, Test Levels.
3308 * @tc.out: Nonzero
3309 * @tc.type: FUNC
3310 * @tc.require: The DiscStartDiscovery operates normally.
3311 */
3312 HWTEST_F(Disc_ManagerTest, StartDiscoveryTest004, TestSize.Level1)
3313 {
3314 int ret;
3315 DiscMgrInit();
3316
3317 ret = DiscStartDiscovery("pkgname1", &g_sInfo, &g_subscribeCb);
3318 ret = DiscStartDiscovery("pkgname1", &g_sInfo, &g_subscribeCb);
3319 TEST_ASSERT_TRUE(ret != 0);
3320
3321 DiscMgrDeinit();
3322 }
3323
3324 /**
3325 * @tc.name: StartDiscoveryTest005
3326 * @tc.desc: Test extern module active discover，use wrong Medium and Freq Under the COAP.
3327 * @tc.in: Test module, Test number, Test Levels.
3328 * @tc.out: NonZero
3329 * @tc.type: FUNC
3330 * @tc.require: The DiscStartDiscovery operates normally.
3331 */
3332 HWTEST_F(Disc_ManagerTest, StartDiscoveryTest005, TestSize.Level1)
3333 {
3334 int ret;
3335 SubscribeInfo testInfo = {
3336 .subscribeId = TEST_SUBSCRIBEINNER_ID,
3337 .mode = DISCOVER_MODE_ACTIVE,
3338 .medium = COAP,
3339 .freq = MID,
3340 .isSameAccount = true,
3341 .isWakeRemote = false,
3342 .capability = "dvKit",
3343 .capabilityData = (unsigned char*)"capdata3",
3344 .dataLen = sizeof("capdata3")
3345 };
3346
3347 DiscMgrInit();
3348
3349 testInfo.medium = (ExchangeMedium)(AUTO - 1);
3350 ret = DiscStartDiscovery("pkgname1", &testInfo, &g_subscribeCb);
3351 TEST_ASSERT_TRUE(ret != 0);
3352 testInfo.medium = COAP;
3353
3354 testInfo.freq = (ExchangeFreq)(LOW - 1);
3355 ret = DiscStartDiscovery("pkgname1", &testInfo, &g_subscribeCb);
3356 TEST_ASSERT_TRUE(ret != 0);
3357 testInfo.freq = LOW;
3358
3359 DiscMgrDeinit();
3360 }
3361
3362 /**
3363 * @tc.name: StartDiscoveryTest006
3364 * @tc.desc: Test extern module active discover，use wrong Medium and Freq Under the BLE.
3365 * @tc.in: Test module, Test number, Test Levels.
3366 * @tc.out: NonZero
3367 * @tc.type: FUNC
3368 * @tc.require: The DiscStartDiscovery operates normally.
3369 */
3370 HWTEST_F(Disc_ManagerTest, StartDiscoveryTest006, TestSize.Level1)
3371 {
3372 int ret;
3373 SubscribeInfo testInfo = {
3374 .subscribeId = TEST_SUBSCRIBEINNER_ID,
3375 .mode = DISCOVER_MODE_ACTIVE,
3376 .medium = BLE,
3377 .freq = MID,
3378 .isSameAccount = true,
3379 .isWakeRemote = false,
3380 .capability = "dvKit",
3381 .capabilityData = (unsigned char*)"capdata3",
3382 .dataLen = sizeof("capdata3")
3383 };
3384
3385 DiscMgrInit();
3386
3387 testInfo.medium = (ExchangeMedium)(AUTO - 1);
3388 ret = DiscStartDiscovery("pkgname1", &testInfo, &g_subscribeCb);
3389 TEST_ASSERT_TRUE(ret != 0);
3390 testInfo.medium = COAP;
3391
3392 testInfo.freq = (ExchangeFreq)(LOW - 1);
3393 ret = DiscStartDiscovery("pkgname1", &testInfo, &g_subscribeCb);
3394 TEST_ASSERT_TRUE(ret != 0);
3395 testInfo.freq = LOW;
3396
3397 DiscMgrDeinit();
3398 }
3399
3400 /**
3401 * @tc.name: StartDiscoveryTest007
3402 * @tc.desc: Test extern module active discover，use wrong Medium and Freq Under the AUTO.
3403 * @tc.in: Test module, Test number, Test Levels.
3404 * @tc.out: NonZero
3405 * @tc.type: FUNC
3406 * @tc.require: The DiscStartDiscovery operates normally.
3407 */
3408 HWTEST_F(Disc_ManagerTest, StartDiscoveryTest007, TestSize.Level1)
3409 {
3410 int ret;
3411 SubscribeInfo testInfo = {
3412 .subscribeId = TEST_SUBSCRIBEINNER_ID,
3413 .mode = DISCOVER_MODE_ACTIVE,
3414 .medium = AUTO,
3415 .freq = MID,
3416 .isSameAccount = true,
3417 .isWakeRemote = false,
3418 .capability = "dvKit",
3419 .capabilityData = (unsigned char*)"capdata3",
3420 .dataLen = sizeof("capdata3")
3421 };
3422
3423 DiscMgrInit();
3424
3425 testInfo.medium = (ExchangeMedium)(AUTO - 1);
3426 ret = DiscStartDiscovery("pkgname1", &testInfo, &g_subscribeCb);
3427 TEST_ASSERT_TRUE(ret != 0);
3428 testInfo.medium = COAP;
3429
3430 testInfo.freq = (ExchangeFreq)(LOW - 1);
3431 ret = DiscStartDiscovery("pkgname1", &testInfo, &g_subscribeCb);
3432 TEST_ASSERT_TRUE(ret != 0);
3433 testInfo.freq = LOW;
3434
3435 DiscMgrDeinit();
3436 }
3437
3438 /**
3439 * @tc.name: StartDiscoveryTest008
3440 * @tc.desc: Test extern module active discover，use Diff Freq Under the AUTO.
3441 * @tc.in: Test module, Test number, Test Levels.
3442 * @tc.out: Zero
3443 * @tc.type: FUNC
3444 * @tc.require: The DiscStartDiscovery operates normally.
3445 */
3446 HWTEST_F(Disc_ManagerTest, StartDiscoveryTest008, TestSize.Level1)
3447 {
3448 int ret;
3449 SubscribeInfo testInfo = {
3450 .subscribeId = TEST_SUBSCRIBE_ID,
3451 .mode = DISCOVER_MODE_ACTIVE,
3452 .medium = AUTO,
3453 .freq = LOW,
3454 .isSameAccount = true,
3455 .isWakeRemote = false,
3456 .capability = "dvKit",
3457 .capabilityData = (unsigned char *)"capdata3",
3458 .dataLen = sizeof("capdata3")
3459 };
3460
3461 DiscMgrInit();
3462
3463 ret = DiscStartDiscovery("pkgname1", &testInfo, &g_subscribeCb);
3464 TEST_ASSERT_TRUE(ret == 0);
3465 DiscStopDiscovery("pkgname1", testInfo.subscribeId);
3466
3467 testInfo.freq = MID;
3468 ret = DiscStartDiscovery("pkgname1", &testInfo, &g_subscribeCb);
3469 TEST_ASSERT_TRUE(ret == 0);
3470 DiscStopDiscovery("pkgname1", testInfo.subscribeId);
3471
3472 testInfo.freq = HIGH;
3473 ret = DiscStartDiscovery("pkgname1", &testInfo, &g_subscribeCb);
3474 TEST_ASSERT_TRUE(ret == 0);
3475 DiscStopDiscovery("pkgname1", testInfo.subscribeId);
3476
3477 testInfo.freq = SUPER_HIGH;
3478 ret = DiscStartDiscovery("pkgname1", &testInfo, &g_subscribeCb);
3479 TEST_ASSERT_TRUE(ret == 0);
3480 DiscStopDiscovery("pkgname1", testInfo.subscribeId);
3481
3482 DiscMgrDeinit();
3483 }
3484
3485 /**
3486 * @tc.name: StartDiscoveryTest009
3487 * @tc.desc: Test extern module passive discover，use Diff Freq Under the AUTO.
3488 * @tc.in: Test module, Test number, Test Levels.
3489 * @tc.out: Zero
3490 * @tc.type: FUNC
3491 * @tc.require: The DiscStartDiscovery operates normally.
3492 */
3493 HWTEST_F(Disc_ManagerTest, StartDiscoveryTest009, TestSize.Level1)
3494 {
3495 int ret;
3496 SubscribeInfo testInfo = {
3497 .subscribeId = TEST_SUBSCRIBE_ID,
3498 .mode = DISCOVER_MODE_PASSIVE,
3499 .medium = AUTO,
3500 .freq = LOW,
3501 .isSameAccount = true,
3502 .isWakeRemote = false,
3503 .capability = "dvKit",
3504 .capabilityData = (unsigned char *)"capdata3",
3505 .dataLen = sizeof("capdata3")
3506 };
3507
3508 DiscMgrInit();
3509
3510 ret = DiscStartDiscovery("pkgname1", &testInfo, &g_subscribeCb);
3511 TEST_ASSERT_TRUE(ret == 0);
3512 DiscStopDiscovery("pkgname1", testInfo.subscribeId);
3513
3514 testInfo.freq = MID;
3515 ret = DiscStartDiscovery("pkgname1", &testInfo, &g_subscribeCb);
3516 TEST_ASSERT_TRUE(ret == 0);
3517 DiscStopDiscovery("pkgname1", testInfo.subscribeId);
3518
3519 testInfo.freq = HIGH;
3520 ret = DiscStartDiscovery("pkgname1", &testInfo, &g_subscribeCb);
3521 TEST_ASSERT_TRUE(ret == 0);
3522 DiscStopDiscovery("pkgname1", testInfo.subscribeId);
3523
3524 testInfo.freq = SUPER_HIGH;
3525 ret = DiscStartDiscovery("pkgname1", &testInfo, &g_subscribeCb);
3526 TEST_ASSERT_TRUE(ret == 0);
3527 DiscStopDiscovery("pkgname1", testInfo.subscribeId);
3528
3529 DiscMgrDeinit();
3530 }
3531
3532 /**
3533 * @tc.name: StartDiscoveryTest010
3534 * @tc.desc: Test extern module active discover，use Diff Freq Under the BLE.
3535 * @tc.in: Test module, Test number, Test Levels.
3536 * @tc.out: Zero
3537 * @tc.type: FUNC
3538 * @tc.require: The DiscStartDiscovery operates normally.
3539 */
3540 HWTEST_F(Disc_ManagerTest, StartDiscoveryTest010, TestSize.Level1)
3541 {
3542 int ret;
3543 SubscribeInfo testInfo = {
3544 .subscribeId = TEST_SUBSCRIBE_ID,
3545 .mode = DISCOVER_MODE_ACTIVE,
3546 .medium = BLE,
3547 .freq = LOW,
3548 .isSameAccount = true,
3549 .isWakeRemote = false,
3550 .capability = "dvKit",
3551 .capabilityData = (unsigned char *)"capdata3",
3552 .dataLen = sizeof("capdata3")
3553 };
3554
3555 DiscMgrInit();
3556
3557 ret = DiscStartDiscovery("pkgname1", &testInfo, &g_subscribeCb);
3558 TEST_ASSERT_TRUE(ret == 0);
3559 DiscStopDiscovery("pkgname1", testInfo.subscribeId);
3560
3561 testInfo.freq = MID;
3562 ret = DiscStartDiscovery("pkgname1", &testInfo, &g_subscribeCb);
3563 TEST_ASSERT_TRUE(ret == 0);
3564 DiscStopDiscovery("pkgname1", testInfo.subscribeId);
3565
3566 testInfo.freq = HIGH;
3567 ret = DiscStartDiscovery("pkgname1", &testInfo, &g_subscribeCb);
3568 TEST_ASSERT_TRUE(ret == 0);
3569 DiscStopDiscovery("pkgname1", testInfo.subscribeId);
3570
3571 testInfo.freq = SUPER_HIGH;
3572 ret = DiscStartDiscovery("pkgname1", &testInfo, &g_subscribeCb);
3573 TEST_ASSERT_TRUE(ret == 0);
3574 DiscStopDiscovery("pkgname1", testInfo.subscribeId);
3575
3576 DiscMgrDeinit();
3577 }
3578
3579 /**
3580 * @tc.name: StartDiscoveryTest011
3581 * @tc.desc: extern module discover, use the normal parameter and different frequencies under passive COAP.
3582 * @tc.in: test module, test number, Test Levels.
3583 * @tc.out: Zero
3584 * @tc.type: FUNC
3585 * @tc.require: The DiscStartDiscovery operates normally.
3586 */
3587 HWTEST_F(Disc_ManagerTest, StartDiscoveryTest011, TestSize.Level1)
3588 {
3589 int ret;
3590 SubscribeInfo testInfo = {.subscribeId = TEST_SUBSCRIBE_ID,
3591 .mode = DISCOVER_MODE_PASSIVE,
3592 .medium = COAP,
3593 .freq = LOW,
3594 .isSameAccount = true,
3595 .isWakeRemote = false,
3596 .capability = "dvKit",
3597 .capabilityData = (unsigned char *)"capdata3",
3598 .dataLen = sizeof("capdata3")};
3599
3600 DiscMgrInit();
3601
3602 ret = DiscStartDiscovery("pkgname1", &testInfo, &g_subscribeCb);
3603 TEST_ASSERT_TRUE(ret == 0);
3604 DiscStopDiscovery("pkgname1", testInfo.subscribeId);
3605
3606 testInfo.freq = MID;
3607 ret = DiscStartDiscovery("pkgname1", &testInfo, &g_subscribeCb);
3608 TEST_ASSERT_TRUE(ret == 0);
3609 DiscStopDiscovery("pkgname1", testInfo.subscribeId);
3610
3611 testInfo.freq = HIGH;
3612 ret = DiscStartDiscovery("pkgname1", &testInfo, &g_subscribeCb);
3613 TEST_ASSERT_TRUE(ret == 0);
3614 DiscStopDiscovery("pkgname1", testInfo.subscribeId);
3615
3616 testInfo.freq = SUPER_HIGH;
3617 ret = DiscStartDiscovery("pkgname1", &testInfo, &g_subscribeCb);
3618 TEST_ASSERT_TRUE(ret == 0);
3619 DiscStopDiscovery("pkgname1", testInfo.subscribeId);
3620
3621 DiscMgrDeinit();
3622 }
3623
3624
3625 /**
3626 * @tc.name: StartDiscoveryTest012
3627 * @tc.desc: Extern module discover, use the normal parameter and different frequencies under passive BLE.
3628 * @tc.in: test module, test number, Test Levels.
3629 * @tc.out: Zero
3630 * @tc.type: FUNC
3631 * @tc.require: The DiscStartDiscovery operates normally.
3632 */
3633 HWTEST_F(Disc_ManagerTest, StartDiscoveryTest012, TestSize.Level1)
3634 {
3635 int ret;
3636 SubscribeInfo testInfo = {.subscribeId = TEST_SUBSCRIBE_ID,
3637 .mode = DISCOVER_MODE_PASSIVE,
3638 .medium = BLE,
3639 .freq = LOW,
3640 .isSameAccount = true,
3641 .isWakeRemote = false,
3642 .capability = "dvKit",
3643 .capabilityData = (unsigned char *)"capdata3",
3644 .dataLen = sizeof("capdata3")};
3645
3646 DiscMgrInit();
3647
3648 ret = DiscStartDiscovery("pkgname1", &testInfo, &g_subscribeCb);
3649 TEST_ASSERT_TRUE(ret == 0);
3650 DiscStopDiscovery("pkgname1", testInfo.subscribeId);
3651
3652 testInfo.freq = MID;
3653 ret = DiscStartDiscovery("pkgname1", &testInfo, &g_subscribeCb);
3654 TEST_ASSERT_TRUE(ret == 0);
3655 DiscStopDiscovery("pkgname1", testInfo.subscribeId);
3656
3657 testInfo.freq = HIGH;
3658 ret = DiscStartDiscovery("pkgname1", &testInfo, &g_subscribeCb);
3659 TEST_ASSERT_TRUE(ret == 0);
3660 DiscStopDiscovery("pkgname1", testInfo.subscribeId);
3661
3662 testInfo.freq = SUPER_HIGH;
3663 ret = DiscStartDiscovery("pkgname1", &testInfo, &g_subscribeCb);
3664 TEST_ASSERT_TRUE(ret == 0);
3665 DiscStopDiscovery("pkgname1", testInfo.subscribeId);
3666
3667 DiscMgrDeinit();
3668 }
3669
3670 /**
3671 * @tc.name: StartDiscoveryTest013
3672 * @tc.desc: Extern module discover, use the normal parameter and different frequencies under active COAP.
3673 * @tc.in: test module, test number, Test Levels.
3674 * @tc.out: Zero
3675 * @tc.type: FUNC
3676 * @tc.require: The DiscStartDiscovery operates normally.
3677 */
3678 HWTEST_F(Disc_ManagerTest, StartDiscoveryTest013, TestSize.Level1)
3679 {
3680 int ret;
3681 SubscribeInfo testInfo = {.subscribeId = TEST_SUBSCRIBE_ID,
3682 .mode = DISCOVER_MODE_ACTIVE,
3683 .medium = COAP,
3684 .freq = LOW,
3685 .isSameAccount = true,
3686 .isWakeRemote = false,
3687 .capability = "dvKit",
3688 .capabilityData = (unsigned char *)"capdata3",
3689 .dataLen = sizeof("capdata3")};
3690
3691 DiscMgrInit();
3692
3693 ret = DiscStartDiscovery("pkgname1", &testInfo, &g_subscribeCb);
3694 TEST_ASSERT_TRUE(ret == 0);
3695 DiscStopDiscovery("pkgname1", testInfo.subscribeId);
3696
3697 testInfo.freq = MID;
3698 ret = DiscStartDiscovery("pkgname1", &testInfo, &g_subscribeCb);
3699 TEST_ASSERT_TRUE(ret == 0);
3700 DiscStopDiscovery("pkgname1", testInfo.subscribeId);
3701
3702 testInfo.freq = HIGH;
3703 ret = DiscStartDiscovery("pkgname1", &testInfo, &g_subscribeCb);
3704 TEST_ASSERT_TRUE(ret == 0);
3705 DiscStopDiscovery("pkgname1", testInfo.subscribeId);
3706
3707 testInfo.freq = SUPER_HIGH;
3708 ret = DiscStartDiscovery("pkgname1", &testInfo, &g_subscribeCb);
3709 TEST_ASSERT_TRUE(ret == 0);
3710 DiscStopDiscovery("pkgname1", testInfo.subscribeId);
3711
3712 DiscMgrDeinit();
3713 }
3714
3715 /**
3716 * @tc.name: UnPublishServiceTest001
3717 * @tc.desc: Extern module stop publish，the module is not initialized.
3718 * @tc.in: test module, test number, Test Levels.
3719 * @tc.out: Nonzero
3720 * @tc.type: FUNC
3721 * @tc.require: The DiscUnPublishService operates normally.
3722 */
3723 HWTEST_F(Disc_ManagerTest, UnPublishServiceTest001, TestSize.Level1)
3724 {
3725 int ret;
3726 ret = DiscUnPublishService("pkgname1", TEST_PUBLISH_ID);
3727 TEST_ASSERT_TRUE(ret != 0);
3728 }
3729
3730 /**
3731 * @tc.name: UnPublishServiceTest002
3732 * @tc.desc: Extern module stop publish，use the wrong parameter.
3733 * @tc.in: test module, test number, Test Levels.
3734 * @tc.out: Nonzero
3735 * @tc.type: FUNC
3736 * @tc.require: The DiscUnPublishService operates normally.
3737 */
3738 HWTEST_F(Disc_ManagerTest, UnPublishServiceTest002, TestSize.Level1)
3739 {
3740 int ret;
3741 DiscMgrInit();
3742 DiscPublishService("pkgname1", &g_pInfo);
3743
3744 ret = DiscUnPublishService(NULL, TEST_PUBLISH_ID);
3745 TEST_ASSERT_TRUE(ret != 0);
3746
3747 ret = DiscUnPublishService(g_erroPkgName, TEST_PUBLISH_ID);
3748 TEST_ASSERT_TRUE(ret != 0);
3749
3750 ret = DiscUnPublishService("pkgname2", TEST_PUBLISH_ID);
3751 TEST_ASSERT_TRUE(ret != 0);
3752
3753 DiscMgrDeinit();
3754 }
3755
3756 /**
3757 * @tc.name: UnPublishServiceTest003
3758 * @tc.desc: Extern module stop publish，use the normal parameter.
3759 * @tc.in: test module, test number, Test Levels.
3760 * @tc.out: Zero
3761 * @tc.type: FUNC
3762 * @tc.require: The DiscUnPublishService operates normally.
3763 */
3764 HWTEST_F(Disc_ManagerTest, UnPublishServiceTest003, TestSize.Level1)
3765 {
3766 int ret;
3767 DiscMgrInit();
3768 DiscPublishService("pkgname1", &g_pInfo);
3769 DiscPublishService("pkgname1", &g_pInfo1);
3770 DiscPublishService(g_corrPkgName, &g_pInfo);
3771
3772 ret = DiscUnPublishService("pkgname1", TEST_PUBLISH_ID);
3773 TEST_ASSERT_TRUE(ret == 0);
3774
3775 ret = DiscUnPublishService("pkgname1", TEST_PUBLISH_ID1);
3776 TEST_ASSERT_TRUE(ret == 0);
3777
3778 ret = DiscUnPublishService(g_corrPkgName, TEST_PUBLISH_ID);
3779 TEST_ASSERT_TRUE(ret == 0);
3780
3781 DiscMgrDeinit();
3782 }
3783
3784 /**
3785 * @tc.name: UnPublishServiceTest004
3786 * @tc.desc: Extern module stop publish，release the same parameter again, perform two subscriptions.
3787 * @tc.in: test module, test number, Test Levels.
3788 * @tc.out: Nonzero
3789 * @tc.type: FUNC
3790 * @tc.require: The DiscUnPublishService operates normally.
3791 */
3792 HWTEST_F(Disc_ManagerTest, UnPublishServiceTest004, TestSize.Level1)
3793 {
3794 int ret;
3795 DiscMgrInit();
3796 DiscPublishService("pkgname1", &g_pInfo);
3797
3798 ret = DiscUnPublishService("pkgname1", TEST_PUBLISH_ID);
3799 ret = DiscUnPublishService("pkgname1", TEST_PUBLISH_ID);
3800 TEST_ASSERT_TRUE(ret != 0);
3801
3802 DiscMgrDeinit();
3803 }
3804
3805 /**
3806 * @tc.name: UnPublishServiceTest005
3807 * @tc.desc: Extern module stop publish, use the normal parameter and different frequencies under active COAP.
3808 * @tc.in: test module, test number, Test Levels.
3809 * @tc.out: Zero
3810 * @tc.type: FUNC
3811 * @tc.require: The DiscUnPublishService operates normally.
3812 */
3813 HWTEST_F(Disc_ManagerTest, UnPublishServiceTest005, TestSize.Level1)
3814 {
3815 int ret;
3816 PublishInfo testInfo = {.publishId = TEST_PUBLISH_ID,
3817 .mode = DISCOVER_MODE_ACTIVE,
3818 .medium = COAP,
3819 .freq = LOW,
3820 .capability = "dvKit",
3821 .capabilityData = (unsigned char *)"capdata2",
3822 .dataLen = sizeof("capdata2")};
3823
3824 DiscMgrInit();
3825
3826 DiscPublishService("pkgname1", &testInfo);
3827 ret = DiscUnPublishService("pkgname1", testInfo.publishId);
3828 TEST_ASSERT_TRUE(ret == 0);
3829
3830 testInfo.freq = MID;
3831 DiscPublishService("pkgname1", &testInfo);
3832 ret = DiscUnPublishService("pkgname1", testInfo.publishId);
3833 TEST_ASSERT_TRUE(ret == 0);
3834
3835 testInfo.freq = HIGH;
3836 DiscPublishService("pkgname1", &testInfo);
3837 ret = DiscUnPublishService("pkgname1", testInfo.publishId);
3838 TEST_ASSERT_TRUE(ret == 0);
3839
3840 testInfo.freq = SUPER_HIGH;
3841 DiscPublishService("pkgname1", &testInfo);
3842 ret = DiscUnPublishService("pkgname1", testInfo.publishId);
3843 TEST_ASSERT_TRUE(ret == 0);
3844
3845 DiscMgrDeinit();
3846 }
3847
3848 /**
3849 * @tc.name: UnPublishServiceTest006
3850 * @tc.desc: Extern module stop publish, use the normal parameter and different frequencies under passive COAP.
3851 * @tc.in: test module, test number, Test Levels.
3852 * @tc.out: Zero
3853 * @tc.type: FUNC
3854 * @tc.require: The DiscUnPublishService operates normally.
3855 */
3856 HWTEST_F(Disc_ManagerTest, UnPublishServiceTest006, TestSize.Level1)
3857 {
3858 int ret;
3859 PublishInfo testInfo = {.publishId = TEST_PUBLISH_ID,
3860 .mode = DISCOVER_MODE_PASSIVE,
3861 .medium = COAP,
3862 .freq = LOW,
3863 .capability = "dvKit",
3864 .capabilityData = (unsigned char *)"capdata2",
3865 .dataLen = sizeof("capdata2")};
3866
3867 DiscMgrInit();
3868
3869 DiscPublishService("pkgname1", &testInfo);
3870 ret = DiscUnPublishService("pkgname1", testInfo.publishId);
3871 TEST_ASSERT_TRUE(ret == 0);
3872
3873 testInfo.freq = MID;
3874 DiscPublishService("pkgname1", &testInfo);
3875 ret = DiscUnPublishService("pkgname1", testInfo.publishId);
3876 TEST_ASSERT_TRUE(ret == 0);
3877
3878 testInfo.freq = HIGH;
3879 DiscPublishService("pkgname1", &testInfo);
3880 ret = DiscUnPublishService("pkgname1", testInfo.publishId);
3881 TEST_ASSERT_TRUE(ret == 0);
3882
3883 testInfo.freq = SUPER_HIGH;
3884 DiscPublishService("pkgname1", &testInfo);
3885 ret = DiscUnPublishService("pkgname1", testInfo.publishId);
3886 TEST_ASSERT_TRUE(ret == 0);
3887
3888 DiscMgrDeinit();
3889 }
3890
3891 /**
3892 * @tc.name: UnPublishServiceTest007
3893 * @tc.desc: Extern module stop publish, use the normal parameter and different frequencies under active BLE.
3894 * @tc.in: test module, test number, Test Levels.
3895 * @tc.out: Zero
3896 * @tc.type: FUNC
3897 * @tc.require: The DiscUnPublishService operates normally.
3898 */
3899 HWTEST_F(Disc_ManagerTest, UnPublishServiceTest007, TestSize.Level1)
3900 {
3901 int ret;
3902 PublishInfo testInfo = {.publishId = TEST_PUBLISH_ID,
3903 .mode = DISCOVER_MODE_ACTIVE,
3904 .medium = BLE,
3905 .freq = LOW,
3906 .capability = "dvKit",
3907 .capabilityData = (unsigned char *)"capdata2",
3908 .dataLen = sizeof("capdata2")};
3909
3910 DiscMgrInit();
3911
3912 DiscPublishService("pkgname1", &testInfo);
3913 ret = DiscUnPublishService("pkgname1", testInfo.publishId);
3914 TEST_ASSERT_TRUE(ret == 0);
3915
3916 testInfo.freq = MID;
3917 DiscPublishService("pkgname1", &testInfo);
3918 ret = DiscUnPublishService("pkgname1", testInfo.publishId);
3919 TEST_ASSERT_TRUE(ret == 0);
3920
3921 testInfo.freq = HIGH;
3922 DiscPublishService("pkgname1", &testInfo);
3923 ret = DiscUnPublishService("pkgname1", testInfo.publishId);
3924 TEST_ASSERT_TRUE(ret == 0);
3925
3926 testInfo.freq = SUPER_HIGH;
3927 DiscPublishService("pkgname1", &testInfo);
3928 ret = DiscUnPublishService("pkgname1", testInfo.publishId);
3929 TEST_ASSERT_TRUE(ret == 0);
3930
3931 DiscMgrDeinit();
3932 }
3933
3934 /**
3935 * @tc.name: UnPublishServiceTest008
3936 * @tc.desc: Extern module stop publish, use the normal parameter and different frequencies under passive BLE.
3937 * @tc.in: test module, test number, Test Levels.
3938 * @tc.out: Zero
3939 * @tc.type: FUNC
3940 * @tc.require: The DiscUnPublishService operates normally.
3941 */
3942 HWTEST_F(Disc_ManagerTest, UnPublishServiceTest008, TestSize.Level1)
3943 {
3944 int ret;
3945 PublishInfo testInfo = {.publishId = TEST_PUBLISH_ID,
3946 .mode = DISCOVER_MODE_PASSIVE,
3947 .medium = BLE,
3948 .freq = LOW,
3949 .capability = "dvKit",
3950 .capabilityData = (unsigned char *)"capdata2",
3951 .dataLen = sizeof("capdata2")};
3952
3953 DiscMgrInit();
3954
3955 DiscPublishService("pkgname1", &testInfo);
3956 ret = DiscUnPublishService("pkgname1", testInfo.publishId);
3957 TEST_ASSERT_TRUE(ret == 0);
3958
3959 testInfo.freq = MID;
3960 DiscPublishService("pkgname1", &testInfo);
3961 ret = DiscUnPublishService("pkgname1", testInfo.publishId);
3962 TEST_ASSERT_TRUE(ret == 0);
3963
3964 testInfo.freq = HIGH;
3965 DiscPublishService("pkgname1", &testInfo);
3966 ret = DiscUnPublishService("pkgname1", testInfo.publishId);
3967 TEST_ASSERT_TRUE(ret == 0);
3968
3969 testInfo.freq = SUPER_HIGH;
3970 DiscPublishService("pkgname1", &testInfo);
3971 ret = DiscUnPublishService("pkgname1", testInfo.publishId);
3972 TEST_ASSERT_TRUE(ret == 0);
3973
3974 DiscMgrDeinit();
3975 }
3976
3977 /**
3978 * @tc.name: UnPublishServiceTest009
3979 * @tc.desc: Extern module stop publish, use the normal parameter and different frequencies under active AUTO.
3980 * @tc.in: test module, test number, Test Levels.
3981 * @tc.out: Zero
3982 * @tc.type: FUNC
3983 * @tc.require: The DiscUnPublishService operates normally.
3984 */
3985 HWTEST_F(Disc_ManagerTest, UnPublishServiceTest009, TestSize.Level1)
3986 {
3987 int ret;
3988 PublishInfo testInfo = {.publishId = TEST_PUBLISH_ID,
3989 .mode = DISCOVER_MODE_ACTIVE,
3990 .medium = AUTO,
3991 .freq = LOW,
3992 .capability = "dvKit",
3993 .capabilityData = (unsigned char *)"capdata2",
3994 .dataLen = sizeof("capdata2")};
3995
3996 DiscMgrInit();
3997
3998 DiscPublishService("pkgname1", &testInfo);
3999 ret = DiscUnPublishService("pkgname1", testInfo.publishId);
4000 TEST_ASSERT_TRUE(ret == 0);
4001
4002 testInfo.freq = MID;
4003 DiscPublishService("pkgname1", &testInfo);
4004 ret = DiscUnPublishService("pkgname1", testInfo.publishId);
4005 TEST_ASSERT_TRUE(ret == 0);
4006
4007 testInfo.freq = HIGH;
4008 DiscPublishService("pkgname1", &testInfo);
4009 ret = DiscUnPublishService("pkgname1", testInfo.publishId);
4010 TEST_ASSERT_TRUE(ret == 0);
4011
4012 testInfo.freq = SUPER_HIGH;
4013 DiscPublishService("pkgname1", &testInfo);
4014 ret = DiscUnPublishService("pkgname1", testInfo.publishId);
4015 TEST_ASSERT_TRUE(ret == 0);
4016
4017 DiscMgrDeinit();
4018 }
4019
4020 /**
4021 * @tc.name: UnPublishServiceTest010
4022 * @tc.desc: Extern module stop publish, use the normal parameter and different frequencies under passive AUTO.
4023 * @tc.in: test module, test number, Test Levels.
4024 * @tc.out: Zero
4025 * @tc.type: FUNC
4026 * @tc.require: The DiscUnPublishService operates normally.
4027 */
4028 HWTEST_F(Disc_ManagerTest, UnPublishServiceTest010, TestSize.Level1)
4029 {
4030 int ret;
4031 PublishInfo testInfo = {.publishId = TEST_PUBLISH_ID,
4032 .mode = DISCOVER_MODE_PASSIVE,
4033 .medium = AUTO,
4034 .freq = LOW,
4035 .capability = "dvKit",
4036 .capabilityData = (unsigned char *)"capdata2",
4037 .dataLen = sizeof("capdata2")};
4038
4039 DiscMgrInit();
4040
4041 DiscPublishService("pkgname1", &testInfo);
4042 ret = DiscUnPublishService("pkgname1", testInfo.publishId);
4043 TEST_ASSERT_TRUE(ret == 0);
4044
4045 testInfo.freq = MID;
4046 DiscPublishService("pkgname1", &testInfo);
4047 ret = DiscUnPublishService("pkgname1", testInfo.publishId);
4048 TEST_ASSERT_TRUE(ret == 0);
4049
4050 testInfo.freq = HIGH;
4051 DiscPublishService("pkgname1", &testInfo);
4052 ret = DiscUnPublishService("pkgname1", testInfo.publishId);
4053 TEST_ASSERT_TRUE(ret == 0);
4054
4055 testInfo.freq = SUPER_HIGH;
4056 DiscPublishService("pkgname1", &testInfo);
4057 ret = DiscUnPublishService("pkgname1", testInfo.publishId);
4058 TEST_ASSERT_TRUE(ret == 0);
4059
4060 DiscMgrDeinit();
4061 }
4062
4063 /**
4064 * @tc.name: StopDiscoveryTest001
4065 * @tc.desc: Extern module stop discover，the module is not initialized.
4066 * @tc.in: test module, test number, Test Levels.
4067 * @tc.out: Nonzero
4068 * @tc.type: FUNC
4069 * @tc.require: The DiscStopDiscovery operates normally
4070 */
4071 HWTEST_F(Disc_ManagerTest, StopDiscoveryTest001, TestSize.Level1)
4072 {
4073 int ret;
4074 ret = DiscStopDiscovery("pkgname1", TEST_SUBSCRIBE_ID);
4075 TEST_ASSERT_TRUE(ret != 0);
4076 }
4077
4078 /**
4079 * @tc.name: StopDiscoveryTest002
4080 * @tc.desc: Extern module stop discover，use the wrong parameter.
4081 * @tc.in: test module, test number, Test Levels.
4082 * @tc.out: Nonzero
4083 * @tc.type: FUNC
4084 * @tc.require: The DiscStopDiscovery operates normally
4085 */
4086 HWTEST_F(Disc_ManagerTest, StopDiscoveryTest002, TestSize.Level1)
4087 {
4088 int ret;
4089 DiscMgrInit();
4090 DiscStartDiscovery("pkgname1", &g_sInfo, &g_subscribeCb);
4091
4092 ret = DiscStopDiscovery(NULL, TEST_SUBSCRIBE_ID);
4093 TEST_ASSERT_TRUE(ret != 0);
4094
4095 ret = DiscStopDiscovery(g_erroPkgName, TEST_SUBSCRIBE_ID);
4096 TEST_ASSERT_TRUE(ret != 0);
4097
4098 ret = DiscStopDiscovery("pkgname2", TEST_SUBSCRIBE_ID);
4099 TEST_ASSERT_TRUE(ret != 0);
4100
4101 DiscMgrDeinit();
4102 }
4103
4104 /**
4105 * @tc.name: StopDiscoveryTest003
4106 * @tc.desc: Extern module stop discover，use the normal parameter.
4107 * @tc.in: test module, test number, Test Levels.
4108 * @tc.out: Zero
4109 * @tc.type: FUNC
4110 * @tc.require: The DiscStopDiscovery operates normally
4111 */
4112 HWTEST_F(Disc_ManagerTest, StopDiscoveryTest003, TestSize.Level1)
4113 {
4114 int ret;
4115 DiscMgrInit();
4116 DiscStartDiscovery("pkgname1", &g_sInfo, &g_subscribeCb);
4117 DiscStartDiscovery("pkgname1", &g_sInfo1, &g_subscribeCb);
4118 DiscStartDiscovery(g_corrPkgName, &g_sInfo, &g_subscribeCb);
4119
4120 ret = DiscStopDiscovery("pkgname1", TEST_SUBSCRIBE_ID);
4121 TEST_ASSERT_TRUE(ret == 0);
4122
4123 ret = DiscStopDiscovery("pkgname1", TEST_SUBSCRIBE_ID1);
4124 TEST_ASSERT_TRUE(ret == 0);
4125
4126 ret = DiscStopDiscovery(g_corrPkgName, TEST_SUBSCRIBE_ID);
4127 TEST_ASSERT_TRUE(ret == 0);
4128
4129 DiscMgrDeinit();
4130 }
4131
4132 /**
4133 * @tc.name: StopDiscoveryTest004
4134 * @tc.desc: Extern module stop discover，release the same parameter again, perform two subscriptions.
4135 * @tc.in: Test module, test number, Test Levels.
4136 * @tc.out: Nonzero
4137 * @tc.type: FUNC
4138 * @tc.require: The DiscStopDiscovery operates normally
4139 */
4140 HWTEST_F(Disc_ManagerTest, StopDiscoveryTest004, TestSize.Level1)
4141 {
4142 int ret;
4143 DiscMgrInit();
4144 DiscStartDiscovery("pkgname1", &g_sInfo, &g_subscribeCb);
4145
4146 ret = DiscStopDiscovery("pkgname1", TEST_SUBSCRIBE_ID);
4147 ret = DiscStopDiscovery("pkgname1", TEST_SUBSCRIBE_ID);
4148 TEST_ASSERT_TRUE(ret != 0);
4149
4150 DiscMgrDeinit();
4151 }
4152
4153 /**
4154 * @tc.name: StopDiscoveryTest005
4155 * @tc.desc: Test extern module stop active discover, use Diff Freq Under the COAP.
4156 * @tc.in: Test module, Test number, Test levels.
4157 * @tc.out: Zero
4158 * @tc.type: FUNC
4159 * @tc.require: The DiscStopDiscovery operates normally.
4160 */
4161 HWTEST_F(Disc_ManagerTest, StopDiscoveryTest005, TestSize.Level1)
4162 {
4163 int ret;
4164 SubscribeInfo testInfo = {
4165 .subscribeId = TEST_SUBSCRIBE_ID,
4166 .mode = DISCOVER_MODE_ACTIVE,
4167 .medium = COAP,
4168 .freq = LOW,
4169 .isSameAccount = true,
4170 .isWakeRemote = false,
4171 .capability = "dvKit",
4172 .capabilityData = (unsigned char *)"capdata3",
4173 .dataLen = sizeof("capdata3")
4174 };
4175
4176 DiscMgrInit();
4177
4178 DiscStartDiscovery("pkgname1", &testInfo, &g_subscribeCb);
4179 ret = DiscStopDiscovery("pkgname1", testInfo.subscribeId);
4180 TEST_ASSERT_TRUE(ret == 0);
4181
4182 testInfo.freq = MID;
4183 DiscStartDiscovery("pkgname1", &testInfo, &g_subscribeCb);
4184 ret = DiscStopDiscovery("pkgname1", testInfo.subscribeId);
4185 TEST_ASSERT_TRUE(ret == 0);
4186
4187 testInfo.freq = HIGH;
4188 DiscStartDiscovery("pkgname1", &testInfo, &g_subscribeCb);
4189 ret = DiscStopDiscovery("pkgname1", testInfo.subscribeId);
4190 TEST_ASSERT_TRUE(ret == 0);
4191
4192 testInfo.freq = SUPER_HIGH;
4193 DiscStartDiscovery("pkgname1", &testInfo, &g_subscribeCb);
4194 ret = DiscStopDiscovery("pkgname1", testInfo.subscribeId);
4195 TEST_ASSERT_TRUE(ret == 0);
4196
4197 DiscMgrDeinit();
4198 }
4199
4200 /**
4201 * @tc.name: StopDiscoveryTest006
4202 * @tc.desc: Test extern module stop passive discover, use Diff Freq Under the COAP.
4203 * @tc.in: Test module, Test number, Test levels.
4204 * @tc.out: Zero
4205 * @tc.type: FUNC
4206 * @tc.require: The DiscStopDiscovery operates normally.
4207 */
4208 HWTEST_F(Disc_ManagerTest, StopDiscoveryTest006, TestSize.Level1)
4209 {
4210 int ret;
4211 SubscribeInfo testInfo = {
4212 .subscribeId = TEST_SUBSCRIBE_ID,
4213 .mode = DISCOVER_MODE_PASSIVE,
4214 .medium = COAP,
4215 .freq = LOW,
4216 .isSameAccount = true,
4217 .isWakeRemote = false,
4218 .capability = "dvKit",
4219 .capabilityData = (unsigned char *)"capdata3",
4220 .dataLen = sizeof("capdata3")
4221 };
4222
4223 DiscMgrInit();
4224
4225 DiscStartDiscovery("pkgname1", &testInfo, &g_subscribeCb);
4226 ret = DiscStopDiscovery("pkgname1", testInfo.subscribeId);
4227 TEST_ASSERT_TRUE(ret == 0);
4228
4229 testInfo.freq = MID;
4230 DiscStartDiscovery("pkgname1", &testInfo, &g_subscribeCb);
4231 ret = DiscStopDiscovery("pkgname1", testInfo.subscribeId);
4232 TEST_ASSERT_TRUE(ret == 0);
4233
4234 testInfo.freq = HIGH;
4235 DiscStartDiscovery("pkgname1", &testInfo, &g_subscribeCb);
4236 ret = DiscStopDiscovery("pkgname1", testInfo.subscribeId);
4237 TEST_ASSERT_TRUE(ret == 0);
4238
4239 testInfo.freq = SUPER_HIGH;
4240 DiscStartDiscovery("pkgname1", &testInfo, &g_subscribeCb);
4241 ret = DiscStopDiscovery("pkgname1", testInfo.subscribeId);
4242 TEST_ASSERT_TRUE(ret == 0);
4243
4244 DiscMgrDeinit();
4245 }
4246
4247 /**
4248 * @tc.name: StopDiscoveryTest007
4249 * @tc.desc: Test extern module stop active discover, use Diff Freq Under the BLE.
4250 * @tc.in: Test module, Test number, Test levels.
4251 * @tc.out: Zero
4252 * @tc.type: FUNC
4253 * @tc.require: The DiscStopDiscovery operates normally.
4254 */
4255 HWTEST_F(Disc_ManagerTest, StopDiscoveryTest007, TestSize.Level1)
4256 {
4257 int ret;
4258 SubscribeInfo testInfo = {
4259 .subscribeId = TEST_SUBSCRIBE_ID,
4260 .mode = DISCOVER_MODE_ACTIVE,
4261 .medium = BLE,
4262 .freq = LOW,
4263 .isSameAccount = true,
4264 .isWakeRemote = false,
4265 .capability = "dvKit",
4266 .capabilityData = (unsigned char *)"capdata3",
4267 .dataLen = sizeof("capdata3")
4268 };
4269
4270 DiscMgrInit();
4271
4272 DiscStartDiscovery("pkgname1", &testInfo, &g_subscribeCb);
4273 ret = DiscStopDiscovery("pkgname1", testInfo.subscribeId);
4274 TEST_ASSERT_TRUE(ret == 0);
4275
4276 testInfo.freq = MID;
4277 DiscStartDiscovery("pkgname1", &testInfo, &g_subscribeCb);
4278 ret = DiscStopDiscovery("pkgname1", testInfo.subscribeId);
4279 TEST_ASSERT_TRUE(ret == 0);
4280
4281 testInfo.freq = HIGH;
4282 DiscStartDiscovery("pkgname1", &testInfo, &g_subscribeCb);
4283 ret = DiscStopDiscovery("pkgname1", testInfo.subscribeId);
4284 TEST_ASSERT_TRUE(ret == 0);
4285
4286 testInfo.freq = SUPER_HIGH;
4287 DiscStartDiscovery("pkgname1", &testInfo, &g_subscribeCb);
4288 ret = DiscStopDiscovery("pkgname1", testInfo.subscribeId);
4289 TEST_ASSERT_TRUE(ret == 0);
4290
4291 DiscMgrDeinit();
4292 }
4293
4294 /**
4295 * @tc.name: StopDiscoveryTest008
4296 * @tc.desc: Test extern module stop passive discover, use Diff Freq Under the BLE.
4297 * @tc.in: Test module, Test number, Test levels.
4298 * @tc.out: Zero
4299 * @tc.type: FUNC
4300 * @tc.require: The DiscStopDiscovery operates normally.
4301 */
4302 HWTEST_F(Disc_ManagerTest, StopDiscoveryTest008, TestSize.Level1)
4303 {
4304 int ret;
4305 SubscribeInfo testInfo = {
4306 .subscribeId = TEST_SUBSCRIBE_ID,
4307 .mode = DISCOVER_MODE_PASSIVE,
4308 .medium = BLE,
4309 .freq = LOW,
4310 .isSameAccount = true,
4311 .isWakeRemote = false,
4312 .capability = "dvKit",
4313 .capabilityData = (unsigned char *)"capdata3",
4314 .dataLen = sizeof("capdata3")
4315 };
4316
4317 DiscMgrInit();
4318
4319 DiscStartDiscovery("pkgname1", &testInfo, &g_subscribeCb);
4320 ret = DiscStopDiscovery("pkgname1", testInfo.subscribeId);
4321 TEST_ASSERT_TRUE(ret == 0);
4322
4323 testInfo.freq = MID;
4324 DiscStartDiscovery("pkgname1", &testInfo, &g_subscribeCb);
4325 ret = DiscStopDiscovery("pkgname1", testInfo.subscribeId);
4326 TEST_ASSERT_TRUE(ret == 0);
4327
4328 testInfo.freq = HIGH;
4329 DiscStartDiscovery("pkgname1", &testInfo, &g_subscribeCb);
4330 ret = DiscStopDiscovery("pkgname1", testInfo.subscribeId);
4331 TEST_ASSERT_TRUE(ret == 0);
4332
4333 testInfo.freq = SUPER_HIGH;
4334 DiscStartDiscovery("pkgname1", &testInfo, &g_subscribeCb);
4335 ret = DiscStopDiscovery("pkgname1", testInfo.subscribeId);
4336 TEST_ASSERT_TRUE(ret == 0);
4337
4338 DiscMgrDeinit();
4339 }
4340
4341 /**
4342 * @tc.name: StopDiscoveryTest009
4343 * @tc.desc: Test extern module stop active discover，use Diff Freq Under the AUTO.
4344 * @tc.in: Test module, Test number, Test levels.
4345 * @tc.out: Zero
4346 * @tc.type: FUNC
4347 * @tc.require: The DiscStopDiscovery operates normally.
4348 */
4349 HWTEST_F(Disc_ManagerTest, StopDiscoveryTest009, TestSize.Level1)
4350 {
4351 int ret;
4352 SubscribeInfo testInfo = {
4353 .subscribeId = TEST_SUBSCRIBE_ID,
4354 .mode = DISCOVER_MODE_ACTIVE,
4355 .medium = AUTO,
4356 .freq = LOW,
4357 .isSameAccount = true,
4358 .isWakeRemote = false,
4359 .capability = "dvKit",
4360 .capabilityData = (unsigned char *)"capdata3",
4361 .dataLen = sizeof("capdata3")
4362 };
4363
4364 DiscMgrInit();
4365
4366 DiscStartDiscovery("pkgname1", &testInfo, &g_subscribeCb);
4367 ret = DiscStopDiscovery("pkgname1", testInfo.subscribeId);
4368 TEST_ASSERT_TRUE(ret == 0);
4369
4370 testInfo.freq = MID;
4371 DiscStartDiscovery("pkgname1", &testInfo, &g_subscribeCb);
4372 ret = DiscStopDiscovery("pkgname1", testInfo.subscribeId);
4373 TEST_ASSERT_TRUE(ret == 0);
4374
4375 testInfo.freq = HIGH;
4376 DiscStartDiscovery("pkgname1", &testInfo, &g_subscribeCb);
4377 ret = DiscStopDiscovery("pkgname1", testInfo.subscribeId);
4378 TEST_ASSERT_TRUE(ret == 0);
4379
4380 testInfo.freq = SUPER_HIGH;
4381 DiscStartDiscovery("pkgname1", &testInfo, &g_subscribeCb);
4382 ret = DiscStopDiscovery("pkgname1", testInfo.subscribeId);
4383 TEST_ASSERT_TRUE(ret == 0);
4384
4385 DiscMgrDeinit();
4386 }
4387
4388 /**
4389 * @tc.name: StopDiscoveryTest010
4390 * @tc.desc: Test extern module stop passive discover, use Diff Freq Under the AUTO.
4391 * @tc.in: Test module, Test number, Test levels.
4392 * @tc.out: Zero
4393 * @tc.type: FUNC
4394 * @tc.require: The DiscStopDiscovery operates normally.
4395 */
4396 HWTEST_F(Disc_ManagerTest, StopDiscoveryTest010, TestSize.Level1)
4397 {
4398 int ret;
4399 SubscribeInfo testInfo = {
4400 .subscribeId = TEST_SUBSCRIBE_ID,
4401 .mode = DISCOVER_MODE_PASSIVE,
4402 .medium = AUTO,
4403 .freq = LOW,
4404 .isSameAccount = true,
4405 .isWakeRemote = false,
4406 .capability = "dvKit",
4407 .capabilityData = (unsigned char *)"capdata3",
4408 .dataLen = sizeof("capdata3")
4409 };
4410
4411 DiscMgrInit();
4412
4413 DiscStartDiscovery("pkgname1", &testInfo, &g_subscribeCb);
4414 ret = DiscStopDiscovery("pkgname1", testInfo.subscribeId);
4415 TEST_ASSERT_TRUE(ret == 0);
4416
4417 testInfo.freq = MID;
4418 DiscStartDiscovery("pkgname1", &testInfo, &g_subscribeCb);
4419 ret = DiscStopDiscovery("pkgname1", testInfo.subscribeId);
4420 TEST_ASSERT_TRUE(ret == 0);
4421
4422 testInfo.freq = HIGH;
4423 DiscStartDiscovery("pkgname1", &testInfo, &g_subscribeCb);
4424 ret = DiscStopDiscovery("pkgname1", testInfo.subscribeId);
4425 TEST_ASSERT_TRUE(ret == 0);
4426
4427 testInfo.freq = SUPER_HIGH;
4428 DiscStartDiscovery("pkgname1", &testInfo, &g_subscribeCb);
4429 ret = DiscStopDiscovery("pkgname1", testInfo.subscribeId);
4430 TEST_ASSERT_TRUE(ret == 0);
4431
4432 DiscMgrDeinit();
4433 }
4434
4435 /**
4436 * @tc.name: DiscSetDiscoverCallbackTest001
4437 * @tc.desc: Callback set process.
4438 * @tc.in: test module, test number, Test Levels.
4439 * @tc.out: Zero
4440 * @tc.type: FUNC
4441 * @tc.require: DiscSetDiscoverCallback and DiscStartAdvertise and DiscStopAdvertise operates normally.
4442 */
4443 HWTEST_F(Disc_ManagerTest, DiscSetDiscoverCallbackTest001, TestSize.Level1)
4444 {
4445 int ret;
4446 DiscMgrInit();
4447
4448 ret = DiscSetDiscoverCallback(MODULE_CONN, &g_innerCallback);
4449 TEST_ASSERT_TRUE(ret == 0);
4450
4451 ret = DiscStartAdvertise(MODULE_CONN, &g_sInnerInfo);
4452 TEST_ASSERT_TRUE(ret == 0);
4453
4454 ret = DiscStopAdvertise(MODULE_CONN, TEST_SUBSCRIBEINNER_ID);
4455 TEST_ASSERT_TRUE(ret == 0);
4456
4457 DiscMgrDeinit();
4458 }
4459
4460 /**
4461 * @tc.name: DiscSetDiscoverCallbackTest002
4462 * @tc.desc: Callback set process.
4463 * @tc.in: test module, test number, Test Levels.
4464 * @tc.out: Zero
4465 * @tc.type: FUNC
4466 * @tc.require: DiscStartAdvertise and DiscSetDiscoverCallback and DiscStopAdvertise operates normally.
4467 */
4468 HWTEST_F(Disc_ManagerTest, DiscSetDiscoverCallbackTest002, TestSize.Level1)
4469 {
4470 int ret;
4471 DiscMgrInit();
4472
4473 ret = DiscStartAdvertise(MODULE_CONN, &g_sInnerInfo);
4474 TEST_ASSERT_TRUE(ret == 0);
4475
4476 ret = DiscSetDiscoverCallback(MODULE_CONN, &g_innerCallback);
4477 TEST_ASSERT_TRUE(ret == 0);
4478
4479 ret = DiscStopAdvertise(MODULE_CONN, TEST_SUBSCRIBEINNER_ID);
4480 TEST_ASSERT_TRUE(ret == 0);
4481
4482 DiscMgrDeinit();
4483 }
4484
4485 /**
4486 * @tc.name: DiscSetDiscoverCallbackTest003
4487 * @tc.desc: Extern onDeviceFound test.
4488 * @tc.in: test module, test number, Test Levels.
4489 * @tc.out: NA
4490 * @tc.type: FUNC
4491 * @tc.require: The DiscStartDiscovery operates normally.
4492 */
4493 HWTEST_F(Disc_ManagerTest, DiscSetDiscoverCallbackTest003, TestSize.Level1)
4494 {
4495 int ret;
4496 DeviceInfo devInfo;
4497 DiscMgrInit();
4498 ret = DiscStartDiscovery("pkgname1", &g_sInfo, &g_subscribeCb);
4499 TEST_ASSERT_TRUE(ret == 0);
4500
4501 devInfo.capabilityBitmap[0] = TEST_BITMAP_CAP;
4502 TestInnerDeviceFound(&devInfo, NULL);
4503 DiscMgrDeinit();
4504 }
4505
4506 /**
4507 * @tc.name: DiscSetDiscoverCallbackTest004
4508 * @tc.desc: Inner onDeviceFound test.
4509 * @tc.in: test module, test number, Test Levels.
4510 * @tc.out: Zero
4511 * @tc.type: FUNC
4512 * @tc.require: DiscStartAdvertise and DiscSetDiscoverCallback and DiscStopAdvertise operates normally
4513 */
4514 HWTEST_F(Disc_ManagerTest, DiscSetDiscoverCallbackTest004, TestSize.Level1)
4515 {
4516 int ret;
4517 DeviceInfo devInfo;
4518 DiscMgrInit();
4519
4520 ret = DiscStartAdvertise(MODULE_CONN, &g_sInnerInfo);
4521 TEST_ASSERT_TRUE(ret == 0);
4522
4523 ret = DiscSetDiscoverCallback(MODULE_CONN, &g_innerCallback);
4524 TEST_ASSERT_TRUE(ret == 0);
4525
4526 devInfo.capabilityBitmap[0] = TEST_BITMAP_CAP;
4527 TestInnerDeviceFound(&devInfo, NULL);
4528
4529 ret = DiscStopAdvertise(MODULE_CONN, TEST_SUBSCRIBEINNER_ID);
4530 TEST_ASSERT_TRUE(ret == 0);
4531
4532 DiscMgrDeinit();
4533 }
4534
4535 /**
4536 * @tc.name: DiscSetDiscoverCallbackTest005
4537 * @tc.desc: Inner onDeviceFound test with no callback.
4538 * @tc.in: test module, test number, Test Levels.
4539 * @tc.out: Zero
4540 * @tc.type: FUNC
4541 * @tc.require: DiscStartAdvertise and DiscStopAdvertise operates normally
4542 */
4543 HWTEST_F(Disc_ManagerTest, DiscSetDiscoverCallbackTest005, TestSize.Level1)
4544 {
4545 int ret;
4546 DeviceInfo devInfo;
4547 DiscMgrInit();
4548
4549 ret = DiscStartAdvertise(MODULE_CONN, &g_sInnerInfo);
4550 TEST_ASSERT_TRUE(ret == 0);
4551
4552 devInfo.capabilityBitmap[0] = TEST_BITMAP_CAP;
4553 TestInnerDeviceFound(&devInfo, NULL);
4554
4555 ret = DiscStopAdvertise(MODULE_CONN, TEST_SUBSCRIBEINNER_ID);
4556 TEST_ASSERT_TRUE(ret == 0);
4557
4558 DiscMgrDeinit();
4559 }
4560
4561 /**
4562 * @tc.name: DiscSetDiscoverCallbackTest006
4563 * @tc.desc: Callback use the wrong parameter.
4564 * @tc.in: test module, test number, Test Levels.
4565 * @tc.out: Nonzero
4566 * @tc.type: FUNC
4567 * @tc.require: DiscStartAdvertise and DiscSetDiscoverCallback and DiscStopAdvertise operates normally.
4568 */
4569 HWTEST_F(Disc_ManagerTest, DiscSetDiscoverCallbackTest006, TestSize.Level1)
4570 {
4571 int ret;
4572 DiscMgrInit();
4573
4574 ret = DiscStartAdvertise(MODULE_CONN, &g_sInnerInfo);
4575 TEST_ASSERT_TRUE(ret == 0);
4576
4577 ret = DiscSetDiscoverCallback(MODULE_CONN, NULL);
4578 TEST_ASSERT_TRUE(ret != 0);
4579
4580 ret = DiscStopAdvertise(MODULE_CONN, TEST_SUBSCRIBEINNER_ID);
4581 TEST_ASSERT_TRUE(ret == 0);
4582
4583 DiscMgrDeinit();
4584 }
4585
4586 /**
4587 * @tc.name: NSTACKX_SendMsgDirectTest001
4588 * @tc.desc: Test NSTACKX_SendMsgDirect input valid param.
4589 * @tc.in: test module, test number, Test Levels.
4590 * @tc.out: Zero
4591 * @tc.type: FUNC
4592 * @tc.require: The NSTACKX_SendMsgDirect operates normally.
4593 */
4594 HWTEST_F(Disc_ManagerTest, NSTACKX_SendMsgDirectTest001, TestSize.Level1)
4595 {
4596 const char *muduleName = (const char *)malloc(sizeof(char));
4597 ASSERT_TRUE(muduleName != nullptr);
4598 const char *uuid = (const char *)malloc(sizeof(char));
4599 ASSERT_TRUE(uuid != nullptr);
4600 const uint8_t *data = (const uint8_t *)malloc(sizeof(uint8_t));
4601 ASSERT_TRUE(data != nullptr);
4602 uint32_t len = 1;
4603 const char *ipaddr = (const char *)malloc(sizeof(char));
4604 ASSERT_TRUE(ipaddr != nullptr);
4605 uint8_t type = 2;
4606 NSTACKX_Parameter g_parameter;
4607 int32_t ret;
4608
4609 NSTACKX_Init(&g_parameter);
4610 ret = NSTACKX_SendMsgDirect(muduleName, uuid, data, len, ipaddr, type);
4611 NSTACKX_Deinit();
4612 TEST_ASSERT_TRUE(ret == 0);
4613 }
4614
4615 /**
4616 * @tc.name: NSTACKX_SendMsgDirectTest002
4617 * @tc.desc: Test NSTACKX_SendMsgDirect input invalid param.
4618 * @tc.in: test module, test number, Test Levels.
4619 * @tc.out: Nonzero
4620 * @tc.type: FUNC
4621 * @tc.require: The NSTACKX_SendMsgDirect operates normally.
4622 */
4623 HWTEST_F(Disc_ManagerTest, NSTACKX_SendMsgDirectTest002, TestSize.Level1)
4624 {
4625 const char *muduleName = (const char *)malloc(sizeof(char));
4626 ASSERT_TRUE(muduleName != nullptr);
4627 const char *uuid = (const char *)malloc(sizeof(char));
4628 ASSERT_TRUE(uuid != nullptr);
4629 const uint8_t *data = (const uint8_t *)malloc(sizeof(uint8_t));
4630 ASSERT_TRUE(data != nullptr);
4631 uint32_t len = 1;
4632 const char *ipaddr = nullptr;
4633 uint8_t type = 2;
4634 NSTACKX_Parameter g_parameter;
4635 int32_t ret;
4636
4637 NSTACKX_Init(&g_parameter);
4638 ret = NSTACKX_SendMsgDirect(muduleName, uuid, data, len, ipaddr, type);
4639 TEST_ASSERT_TRUE(ret == -1);
4640 }
4641
4642 /**
4643 * @tc.name: NSTACKX_SendMsgDirectTest003
4644 * @tc.desc: Test NSTACKX_SendMsgDirect not init.
4645 * @tc.in: test module, test number, Test Levels.
4646 * @tc.out: Nonzero
4647 * @tc.type: FUNC
4648 * @tc.require: The NSTACKX_SendMsgDirect operates normally.
4649 */
4650 HWTEST_F(Disc_ManagerTest, NSTACKX_SendMsgDirectTest003, TestSize.Level1)
4651 {
4652 const char *muduleName = (const char *)malloc(sizeof(char));
4653 ASSERT_TRUE(muduleName != nullptr);
4654 const char *uuid = (const char *)malloc(sizeof(char));
4655 ASSERT_TRUE(uuid != nullptr);
4656 const uint8_t *data = (const uint8_t *)malloc(sizeof(uint8_t));
4657 ASSERT_TRUE(data != nullptr);
4658 uint32_t len = 1;
4659 const char *ipaddr = (const char *)malloc(sizeof(char));
4660 ASSERT_TRUE(ipaddr != nullptr);
4661 uint8_t type = 2;
4662 int32_t ret;
4663
4664 ret = NSTACKX_SendMsgDirect(muduleName, uuid, data, len, ipaddr, type);
4665 TEST_ASSERT_TRUE(ret == -1);
4666 }
4667
4668 /**
4669 * @tc.name: NSTACKX_SendMsgTest001
4670 * @tc.desc: Test NSTACKX_SendMsg input valid param.
4671 * @tc.in: test module, test number, Test Levels.
4672 * @tc.out: Zero
4673 * @tc.type: FUNC
4674 * @tc.require: The NSTACKX_SendMsg operates normally.
4675 */
4676 HWTEST_F(Disc_ManagerTest, NSTACKX_SendMsgTest001, TestSize.Level1)
4677 {
4678 const char *muduleName = (const char *)malloc(sizeof(char));
4679 ASSERT_TRUE(muduleName != nullptr);
4680 const char *uuid = (const char *)malloc(sizeof(char));
4681 ASSERT_TRUE(muduleName != nullptr);
4682 const uint8_t *data = (const uint8_t *)malloc(sizeof(uint8_t));
4683 ASSERT_TRUE(data != nullptr);
4684 uint32_t len = 1;
4685 NSTACKX_Parameter g_parameter;
4686 int32_t ret;
4687
4688 NSTACKX_Init(&g_parameter);
4689 ret = NSTACKX_SendMsg(muduleName, uuid, data, len);
4690 NSTACKX_Deinit();
4691 TEST_ASSERT_TRUE(ret == 0);
4692 }
4693
4694 /**
4695 * @tc.name: NSTACKX_SendMsgTest002
4696 * @tc.desc: Test NSTACKX_SendMsg input invalid param.
4697 * @tc.in: test module, test number, Test Levels.
4698 * @tc.out: Nonzero
4699 * @tc.type: FUNC
4700 * @tc.require: The NSTACKX_SendMsg operates normally.
4701 */
4702 HWTEST_F(Disc_ManagerTest, NSTACKX_SendMsgTest002, TestSize.Level1)
4703 {
4704 NSTACKX_Parameter g_parameter;
4705 int32_t ret;
4706
4707 NSTACKX_Init(&g_parameter);
4708 ret = NSTACKX_SendMsg(nullptr, nullptr, nullptr, 0);
4709 NSTACKX_Deinit();
4710 TEST_ASSERT_TRUE(ret == -2);
4711 }
4712
4713 /**
4714 * @tc.name: NSTACKX_SendMsgTest003
4715 * @tc.desc: Test NSTACKX_SendMsg not init.
4716 * @tc.in: test module, test number, Test Levels.
4717 * @tc.out: Nonzero
4718 * @tc.type: FUNC
4719 * @tc.require: The NSTACKX_SendMsg operates normally.
4720 */
4721 HWTEST_F(Disc_ManagerTest, NSTACKX_SendMsgTest003, TestSize.Level1)
4722 {
4723 const char *muduleName = (const char *)malloc(sizeof(char));
4724 ASSERT_TRUE(muduleName != nullptr);
4725 const char *uuid = (const char *)malloc(sizeof(char));
4726 ASSERT_TRUE(uuid != nullptr);
4727 const uint8_t *data = (const uint8_t *)malloc(sizeof(uint8_t));
4728 ASSERT_TRUE(data != nullptr);
4729 uint32_t len = 1;
4730 int32_t ret;
4731
4732 ret = NSTACKX_SendMsg(muduleName, uuid, data, len);
4733 TEST_ASSERT_TRUE(ret == -1);
4734 }
4735
4736 /**
4737 * @tc.name: DiscCoapStopDiscoveryTest001
4738 * @tc.desc: Active stop discovery，use the normal parameter.
4739 * @tc.in: test module, test number, Test Levels.
4740 * @tc.out: Zero
4741 * @tc.type: FUNC
4742 * @tc.require: The DiscCoapStopDiscovery operates normally.
4743 */
4744 HWTEST_F(Disc_ManagerTest, DiscCoapStopDiscoveryTest001, TestSize.Level1)
4745 {
4746 int ret;
4747 const uint32_t cap_bitmap_1 = 1;
4748 const uint32_t disc_mode_active = 1;
4749 g_coapDiscFunc = DiscCoapInit(&g_discInnerCb);
4750 DiscCoapStartDiscovery(cap_bitmap_1, disc_mode_active);
4751
4752 ret = DiscCoapStopDiscovery(cap_bitmap_1, disc_mode_active);
4753 TEST_ASSERT_TRUE(ret == 0);
4754 }
4755
4756 /**
4757 * @tc.name: DiscCoapStopDiscoveryTest002
4758 * @tc.desc: Passive stop discovery，the module is not initialized.
4759 * @tc.in: test module, test number, Test Levels.
4760 * @tc.out: Nonzero
4761 * @tc.type: FUNC
4762 * @tc.require: The DiscCoapStopDiscovery operates normally.
4763 */
4764 HWTEST_F(Disc_ManagerTest, DiscCoapStopDiscoveryTest002, TestSize.Level1)
4765 {
4766 int ret;
4767 const uint32_t cap_bitmap_1 = 1;
4768 const uint32_t disc_mode_passive = 1;
4769
4770 DiscCoapStartDiscovery(cap_bitmap_1, disc_mode_passive);
4771 ret = DiscCoapStopDiscovery(cap_bitmap_1, disc_mode_passive);
4772 TEST_ASSERT_TRUE(ret != 0);
4773 }
4774
4775 /**
4776 * @tc.name: DiscCoapStopDiscoveryTest003
4777 * @tc.desc: Active stop discovery，the module is not initialized.
4778 * @tc.in: test module, test number, Test Levels.
4779 * @tc.out: Nonzero
4780 * @tc.type: FUNC
4781 * @tc.require: The DiscCoapStopDiscovery operates normally.
4782 */
4783 HWTEST_F(Disc_ManagerTest, DiscCoapStopDiscoveryTest003, TestSize.Level1)
4784 {
4785 int ret;
4786 const uint32_t cap_bitmap_1 = 1;
4787 const uint32_t disc_mode_active = 1;
4788
4789 ret = DiscCoapStopDiscovery(cap_bitmap_1, disc_mode_active);
4790 TEST_ASSERT_TRUE(ret != 0);
4791 }
4792
4793 /**
4794 * @tc.name: RegisterDeviceInfoTest001
4795 * @tc.desc: Registering device Information，use the normal parameter.
4796 * @tc.in: test module, test number, Test Levels.
4797 * @tc.out: Zero
4798 * @tc.type: FUNC
4799 * @tc.require: The NSTACKX_RegisterDevice operates normally.
4800 */
4801 HWTEST_F(Disc_ManagerTest, RegisterDeviceInfoTest001, TestSize.Level1)
4802 {
4803 int ret;
4804 const char *device_name = "TEST";
4805 const char *device_id = "abcdefgfhijklmnopqrstuvwxyz";
4806 const char *device_bt_mac = "11:22:33:44:55:66";
4807 const char *device_wifi_mac = "11:22:33:44:77:88";
4808 const char *device_ip = "192.168.0.1";
4809 const char *net_work_name = "wlan0";
4810 const uint32_t device_type = 0;
4811 const char *version = "3.1.0";
4812 NSTACKX_LocalDeviceInfo *localDevInfo = (NSTACKX_LocalDeviceInfo *)malloc(sizeof(NSTACKX_LocalDeviceInfo));
4813 ASSERT_TRUE(localDevInfo != nullptr);
4814 (void)memset_s(localDevInfo, 0, sizeof(NSTACKX_LocalDeviceInfo), 0);
4815 strcpy_s(localDevInfo->name, sizeof(localDevInfo->name), device_name);
4816 strcpy_s(localDevInfo->deviceId, sizeof(localDevInfo->deviceId), device_id);
4817 strcpy_s(localDevInfo->btMacAddr, sizeof(localDevInfo->btMacAddr), device_bt_mac);
4818 strcpy_s(localDevInfo->wifiMacAddr, sizeof(localDevInfo->wifiMacAddr), device_wifi_mac);
4819 strcpy_s(localDevInfo->networkIpAddr, sizeof(localDevInfo->networkIpAddr), device_ip);
4820 strcpy_s(localDevInfo->networkName, sizeof(localDevInfo->networkName), net_work_name);
4821 strcpy_s(localDevInfo->version, sizeof(localDevInfo->version), version);
4822 localDevInfo->deviceType = device_type;
4823
4824 ret = NSTACKX_RegisterDevice(localDevInfo);
4825 free(localDevInfo);
4826 TEST_ASSERT_TRUE(ret == 0);
4827 }
4828
4829 /**
4830 * @tc.name: RegisterDeviceInfoTest002
4831 * @tc.desc: Registering device Information，the parameter is not assigned.
4832 * @tc.in: test module, test number, Test Levels.
4833 * @tc.out: Nonzero
4834 * @tc.type: FUNC
4835 * @tc.require: The NSTACKX_RegisterDevice operates normally.
4836 */
4837 HWTEST_F(Disc_ManagerTest, RegisterDeviceInfoTest002, TestSize.Level1)
4838 {
4839 int ret;
4840 NSTACKX_LocalDeviceInfo *localDevInfo = (NSTACKX_LocalDeviceInfo *)malloc(sizeof(NSTACKX_LocalDeviceInfo));
4841 ASSERT_TRUE(localDevInfo != nullptr);
4842 (void)memset_s(localDevInfo, 0, sizeof(NSTACKX_LocalDeviceInfo), 0);
4843 ret = NSTACKX_RegisterDevice(localDevInfo);
4844 free(localDevInfo);
4845 TEST_ASSERT_TRUE(ret != 0);
4846 }
4847
4848 /**
4849 * @tc.name: RegisterDeviceInfoTest003
4850 * @tc.desc: Registering device Information，use the wrong parameter.
4851 * @tc.in: test module, test number, Test Levels.
4852 * @tc.out: Nonzero
4853 * @tc.type: FUNC
4854 * @tc.require: The NSTACKX_RegisterDevice operates normally.
4855 */
4856 HWTEST_F(Disc_ManagerTest, RegisterDeviceInfoTest003, TestSize.Level1)
4857 {
4858 int ret;
4859 const char *device_name = "TEST";
4860 const char *device_id = "abcdefgfhijklmnopqrstuvwxyz";
4861 const char *device_bt_mac = "11:22:33:44:55:66";
4862 const char *device_wifi_mac = "11:22:33:44:77:88";
4863 const char *err_device_ip = "192.168";
4864 const char *net_work_name = "wlan0";
4865 const uint32_t device_type = 0;
4866 const char *version = "3.1.0";
4867 NSTACKX_LocalDeviceInfo *localDevInfo = (NSTACKX_LocalDeviceInfo *)malloc(sizeof(NSTACKX_LocalDeviceInfo));
4868 ASSERT_TRUE(localDevInfo != nullptr);
4869 (void)memset_s(localDevInfo, 0, sizeof(NSTACKX_LocalDeviceInfo), 0);
4870 strcpy_s(localDevInfo->name, sizeof(localDevInfo->name), device_name);
4871 strcpy_s(localDevInfo->deviceId, sizeof(localDevInfo->deviceId), device_id);
4872 strcpy_s(localDevInfo->btMacAddr, sizeof(localDevInfo->btMacAddr), device_bt_mac);
4873 strcpy_s(localDevInfo->wifiMacAddr, sizeof(localDevInfo->wifiMacAddr), device_wifi_mac);
4874 strcpy_s(localDevInfo->networkIpAddr, sizeof(localDevInfo->networkIpAddr), err_device_ip);
4875 strcpy_s(localDevInfo->networkName, sizeof(localDevInfo->networkName), net_work_name);
4876 strcpy_s(localDevInfo->version, sizeof(localDevInfo->version), version);
4877 localDevInfo->deviceType = device_type;
4878
4879 ret = NSTACKX_RegisterDevice(localDevInfo);
4880 free(localDevInfo);
4881 TEST_ASSERT_TRUE(ret != 0);
4882 }
4883
4884 /**
4885 * @tc.name: DiscCoapPulbishServiceTest001
4886 * @tc.desc: Inner module publishing, use wrong parameters.
4887 * @tc.in: test module, test number, Test Levels.
4888 * @tc.out: Nonzero
4889 * @tc.type: FUNC
4890 * @tc.require: The DiscCoapUnpulbishService operates normally.
4891 */
4892 HWTEST_F(Disc_ManagerTest, DiscCoapPulbishServiceTest001, TestSize.Level1)
4893 {
4894 int ret;
4895 const uint32_t pub_cap_bitmap_2 = 6;
4896 const uint32_t publish_mode_2 = 5;
4897 g_coapDiscFunc = DiscCoapInit(&g_discInnerCb);
4898
4899 ret = DiscCoapUnpulbishService(pub_cap_bitmap_2, publish_mode_2);
4900 TEST_ASSERT_TRUE(ret != 0);
4901 DiscCoapDeinit();
4902 }
4903
4904 /**
4905 * @tc.name: DiscCoapPulbishServiceTest002
4906 * @tc.desc: Inner module publishing, use normal parameters.
4907 * @tc.in: test module, test number, Test Levels.
4908 * @tc.out: Zero
4909 * @tc.type: FUNC
4910 * @tc.require: The DiscCoapUnpulbishService operates normally.
4911 */
4912 HWTEST_F(Disc_ManagerTest, DiscCoapPulbishServiceTest002, TestSize.Level1)
4913 {
4914 int ret;
4915 const uint32_t pub_cap_bitmap_1 = 1;
4916 const uint32_t pub_lish_mode_1 = 0;
4917 g_coapDiscFunc = DiscCoapInit(&g_discInnerCb);
4918
4919 ret = DiscCoapUnpulbishService(pub_cap_bitmap_1, pub_lish_mode_1);
4920 TEST_ASSERT_TRUE(ret == 0);
4921 DiscCoapDeinit();
4922 }
4923
4924 /**
4925 * @tc.name: DiscCoapStartDiscoveryTest001
4926 * @tc.desc: Inner module Discovery, use wrong parameters.
4927 * @tc.in: test module, test number, Test Levels.
4928 * @tc.out: Nonzero
4929 * @tc.type: FUNC
4930 * @tc.require: The DiscCoapStartDiscovery operates normally.
4931 */
4932 HWTEST_F(Disc_ManagerTest, DiscCoapStartDiscoveryTest001, TestSize.Level1)
4933 {
4934 int ret;
4935 const uint32_t filter_cap_bitmap_2 = 4;
4936 const uint32_t disc_mode_2 = 8;
4937 g_coapDiscFunc = DiscCoapInit(&g_discInnerCb);
4938
4939 ret = DiscCoapStartDiscovery(filter_cap_bitmap_2, disc_mode_2);
4940 TEST_ASSERT_TRUE(ret != 0);
4941 DiscCoapDeinit();
4942 }
4943
4944 /**
4945 * @tc.name: DiscCoapStartDiscoveryTest002
4946 * @tc.desc: Test coap discovery, use normal parameters.
4947 * @tc.in: test module, test number, Test Levels.
4948 * @tc.out: Zero
4949 * @tc.type: FUNC
4950 * @tc.require: The DiscCoapStartDiscovery operates normally.
4951 */
4952 HWTEST_F(Disc_ManagerTest, DiscCoapStartDiscoveryTest002, TestSize.Level1)
4953 {
4954 int ret;
4955 const uint32_t filter_cap_bitmap_1 = 1;
4956 const uint32_t disc_mode_1 = 1;
4957 g_coapDiscFunc = DiscCoapInit(&g_discInnerCb);
4958
4959 ret = DiscCoapStartDiscovery(filter_cap_bitmap_1, disc_mode_1);
4960 TEST_ASSERT_TRUE(ret == 0);
4961 DiscCoapDeinit();
4962 }
4963
4964 /**
4965 * @tc.name: DiscCoapUnpulbishServiceTest001
4966 * @tc.desc: Inner modules stop publishing, using wrong parameters.
4967 * @tc.in: test module, test number, Test Levels.
4968 * @tc.out: Nonzero
4969 * @tc.type: FUNC
4970 * @tc.require: The DiscCoapUnpulbishService operates normally.
4971 */
4972 HWTEST_F(Disc_ManagerTest, DiscCoapUnpulbishServiceTest001, TestSize.Level1)
4973 {
4974 int ret;
4975 const uint32_t pub_cap_bitmap_2 = 6;
4976 const uint32_t publish_mode_2 = 5;
4977 g_coapDiscFunc = DiscCoapInit(&g_discInnerCb);
4978
4979 ret = DiscCoapUnpulbishService(pub_cap_bitmap_2, publish_mode_2);
4980 TEST_ASSERT_TRUE(ret != 0);
4981 DiscCoapDeinit();
4982 }
4983
4984 /**
4985 * @tc.name: DiscCoapUnpulbishServiceTest002
4986 * @tc.desc: Test stop publishing, using the normal parameters.
4987 * @tc.in: test module, test number, Test Levels.
4988 * @tc.out: Zero
4989 * @tc.type: FUNC
4990 * @tc.require: The DiscCoapUnpulbishService operates normally.
4991 */
4992 HWTEST_F(Disc_ManagerTest, DiscCoapUnpulbishServiceTest002, TestSize.Level1)
4993 {
4994 int ret;
4995 const uint32_t pub_cap_bitmap_1 = 1;
4996 const uint32_t pub_lish_mode_1 = 0;
4997 g_coapDiscFunc = DiscCoapInit(&g_discInnerCb);
4998
4999 ret = DiscCoapUnpulbishService(pub_cap_bitmap_1, pub_lish_mode_1);
5000 TEST_ASSERT_TRUE(ret == 0);
5001 DiscCoapDeinit();
5002 }
5003
5004 /**
5005 * @tc.name: NSTACKX_Test001
5006 * @tc.desc: Test NSTACKX_GetDeviceList with invalid param.
5007 * @tc.in: test module, test number, Test Levels.
5008 * @tc.out: Nonzero
5009 * @tc.type: FUNC
5010 * @tc.require: The NSTACKX_GetDeviceList operates normally.
5011 */
5012 HWTEST_F(Disc_ManagerTest, NSTACKX_Test001, TestSize.Level1)
5013 {
5014 NSTACKX_DeviceInfo deviceList;
5015 uint32_t deviceCountPtr = 0;
5016 int32_t ret;
5017 NSTACKX_Parameter g_parameter;
5018
5019 (void)memset_s(&deviceList, 0, sizeof(NSTACKX_LocalDeviceInfo), 0);
5020 NSTACKX_Init(&g_parameter);
5021 ret = NSTACKX_GetDeviceList(&deviceList, &deviceCountPtr);
5022 TEST_ASSERT_TRUE(ret == -2);
5023
5024 deviceCountPtr = NSTACKX_MAX_DEVICE_NUM;
5025 (void)memset_s(&deviceList, 0, sizeof(NSTACKX_LocalDeviceInfo), 0);
5026 ret = NSTACKX_GetDeviceList(&deviceList, &deviceCountPtr);
5027 TEST_ASSERT_TRUE(ret == -2);
5028 NSTACKX_Deinit();
5029 }
5030
5031 /**
5032 * @tc.name: NSTACKX_Test002
5033 * @tc.desc: Test NSTACKX_GetDeviceList with return value In NSTACKX different states.
5034 * @tc.in: test module, test number, Test Levels.
5035 * @tc.out: Nonzero
5036 * @tc.type: FUNC
5037 * @tc.require: The NSTACKX_GetDeviceList operates normally.
5038 */
5039 HWTEST_F(Disc_ManagerTest, NSTACKX_Test002, TestSize.Level1)
5040 {
5041 NSTACKX_DeviceInfo deviceList;
5042 uint32_t deviceCountPtr = NSTACKX_MAX_DEVICE_NUM;
5043 int32_t ret;
5044 NSTACKX_Parameter g_parameter;
5045
5046 (void)memset_s(&deviceList, 0, sizeof(NSTACKX_LocalDeviceInfo), 0);
5047 ret = NSTACKX_GetDeviceList(&deviceList, &deviceCountPtr);
5048 TEST_ASSERT_TRUE(ret == -1);
5049
5050 NSTACKX_Init(&g_parameter);
5051 ret = NSTACKX_GetDeviceList(&deviceList, &deviceCountPtr);
5052 TEST_ASSERT_TRUE(ret == 0);
5053
5054 NSTACKX_Deinit();
5055 ret = NSTACKX_GetDeviceList(&deviceList, &deviceCountPtr);
5056 TEST_ASSERT_TRUE(ret == -1);
5057 }
5058
5059 /*
5060 * @tc.name: testNSTACKX_RegisterDeviceAn001
5061 * @tc.desc: Test testNSTACKX_RegisterDeviceAn with invalid param.
5062 * @tc.in: test module, test number, Test Levels.
5063 * @tc.out: Nonzero
5064 * @tc.type: FUNC
5065 * @tc.require: The NSTACKX_RegisterDeviceAn operates normally.
5066 */
5067 HWTEST_F(Disc_ManagerTest, testNSTACKX_RegisterDeviceAn001, TestSize.Level1)
5068 {
5069 int32_t ret;
5070 NSTACKX_Parameter g_parameter;
5071
5072 NSTACKX_Init(&g_parameter);
5073 ret = NSTACKX_RegisterDeviceAn(nullptr, 0);
5074 TEST_ASSERT_TRUE(ret == -2);
5075 NSTACKX_Deinit();
5076 };
5077
5078 /*
5079 * @tc.name: testNSTACKX_RegisterDeviceAn002
5080 * @tc.desc: Test testNSTACKX_RegisterDeviceAn not initialized.
5081 * @tc.in: test module, test number, Test Levels.
5082 * @tc.out: Nonzero
5083 * @tc.type: FUNC
5084 * @tc.require: The NSTACKX_RegisterDeviceAn operates normally.
5085 */
5086 HWTEST_F(Disc_ManagerTest, testNSTACKX_RegisterDeviceAn002, TestSize.Level1)
5087 {
5088 int32_t ret;
5089
5090 ret = NSTACKX_RegisterDeviceAn(nullptr, 0);
5091 TEST_ASSERT_TRUE(ret == -1);
5092 };
5093
5094 /*
5095 * @tc.name: testNSTACKX_RegisterDeviceAn003
5096 * @tc.desc: Test testNSTACKX_RegisterDeviceAn yes or no.
5097 * @tc.in: test module, test number, Test Levels.
5098 * @tc.out: Zero
5099 * @tc.type: FUNC
5100 * @tc.require: The NSTACKX_RegisterDeviceAn operates normally.
5101 */
5102 HWTEST_F(Disc_ManagerTest, testNSTACKX_RegisterDeviceAn003, TestSize.Level1)
5103 {
5104 int32_t ret;
5105 NSTACKX_Parameter g_parameter;
5106 NSTACKX_LocalDeviceInfo testInfo = {"testdata"};
5107
5108 NSTACKX_Init(&g_parameter);
5109 ret = NSTACKX_RegisterDeviceAn(&testInfo, 0);
5110 TEST_ASSERT_TRUE(ret == 0);
5111 NSTACKX_Deinit();
5112 };
5113
5114 /*
5115 * @tc.name: testNSTACKX_RegisterCapability004
5116 * @tc.desc: Test NSTACKX_RegisterCapability with invalid param.
5117 * @tc.in: test module, test number, Test Levels.
5118 * @tc.out: Nonzero
5119 * @tc.type: FUNC
5120 * @tc.require: The NSTACKX_RegisterDeviceAn operates normally.
5121 */
5122 HWTEST_F(Disc_ManagerTest, NSTACKX_RegisterCapability004, TestSize.Level1)
5123 {
5124 int32_t ret;
5125 uint32_t mapNum = 3;
5126 NSTACKX_Parameter g_parameter;
5127
5128 NSTACKX_Init(&g_parameter);
5129 ret = NSTACKX_RegisterCapability(mapNum, 0);
5130 TEST_ASSERT_TRUE(ret == -2);
5131 ret = NSTACKX_RegisterCapability(0, 0);
5132 TEST_ASSERT_TRUE(ret == -2);
5133 NSTACKX_Deinit();
5134 };
5135
5136 /*
5137 * @tc.name: testNSTACKX_RegisterCapability005
5138 * @tc.desc: Test NSTACKX_RegisterCapability Uninitialized.
5139 * @tc.in: test module, test number, Test Levels.
5140 * @tc.out: Nonzero
5141 * @tc.type: FUNC
5142 * @tc.require: The NSTACKX_RegisterDeviceAn operates normally.
5143 */
5144 HWTEST_F(Disc_ManagerTest, NSTACKX_RegisterCapability005, TestSize.Level1)
5145 {
5146 int32_t ret;
5147
5148 ret = NSTACKX_RegisterCapability(0, 0);
5149 TEST_ASSERT_TRUE(ret == -1);
5150 };
5151
5152 /*
5153 * @tc.name: testBaseListener006
5154 * @tc.desc: Test NSTACKX_RegisterCapability yes or no.
5155 * @tc.in: test module, test number, Test Levels.
5156 * @tc.out: Nonzero
5157 * @tc.type: FUNC
5158 * @tc.require: The NSTACKX_RegisterDeviceAn operates normally.
5159 */
5160 HWTEST_F(Disc_ManagerTest, NSTACKX_RegisterCapability006, TestSize.Level1)
5161 {
5162 int32_t ret;
5163 uint32_t mapNum = 3;
5164 NSTACKX_Parameter g_parameter;
5165
5166 NSTACKX_Init(&g_parameter);
5167 ret = NSTACKX_RegisterCapability(mapNum, 0);
5168 TEST_ASSERT_TRUE(ret != 0);
5169 NSTACKX_Deinit();
5170 };
5171 }