1 /*
2  * Copyright (c) 2021-2024 Huawei Device Co., Ltd.
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at
6  *
7  *     http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15 
16 #include <cstdio>
17 #include <ctime>
18 #include <gtest/gtest.h>
19 #include <sys/time.h>
20 #include <unistd.h>
21 
22 #include "client_bus_center_manager.h"
23 #include "disc_sdk_test_bt_status.h"
24 #include "softbus_access_token_test.h"
25 #include "softbus_bus_center.h"
26 #include "softbus_error_code.h"
27 
28 using namespace testing::ext;
29 
30 namespace OHOS {
31 static int g_subscribeId = 0;
32 static int g_publishId = 0;
33 static const char *g_pkgName = "Softbus_Kits";
34 static const char *g_pkgName_1 = "Softbus_Kits_1";
35 static const char *g_erroPkgName = "Softbus_Erro_Kits";
36 static const char *g_erroPkgName1 = "ErroErroErroErroErroErroErroErroErroErroErroErroErroErroErroErroEErroE";
37 
38 const int32_t ERRO_CAPDATA_LEN = 514;
39 
40 class DiscSdkTest : public testing::Test {
41 public:
DiscSdkTest()42     DiscSdkTest()
43     {}
~DiscSdkTest()44     ~DiscSdkTest()
45     {}
46     static void SetUpTestCase(void);
47     static void TearDownTestCase(void);
SetUp()48     void SetUp() override
49     {}
TearDown()50     void TearDown() override
51     {}
52 };
53 
SetUpTestCase(void)54 void DiscSdkTest::SetUpTestCase(void)
55 {
56     SetAceessTokenPermission("discTest");
57 }
58 
TearDownTestCase(void)59 void DiscSdkTest::TearDownTestCase(void)
60 {}
61 
GetSubscribeId(void)62 static int GetSubscribeId(void)
63 {
64     g_subscribeId++;
65     return g_subscribeId;
66 }
67 
GetPublishId(void)68 static int GetPublishId(void)
69 {
70     g_publishId++;
71     return g_publishId;
72 }
73 
74 static SubscribeInfo g_sInfo = {
75     .subscribeId = 1,
76     .mode = DISCOVER_MODE_PASSIVE,
77     .medium = COAP,
78     .freq = MID,
79     .isSameAccount = true,
80     .isWakeRemote = false,
81     .capability = "dvKit",
82     .capabilityData = (unsigned char *)"capdata3",
83     .dataLen = (unsigned int) strlen("capdata3")
84 };
85 
86 static PublishInfo g_pInfo = {
87     .publishId = 1,
88     .mode = DISCOVER_MODE_PASSIVE,
89     .medium = COAP,
90     .freq = MID,
91     .capability = "dvKit",
92     .capabilityData = (unsigned char *)"capdata4",
93     .dataLen = (unsigned int) strlen("capdata4")
94 };
95 
96 static PublishInfo g_pInfo1 = {
97     .publishId = 1,
98     .mode = DISCOVER_MODE_PASSIVE,
99     .medium = COAP,
100     .freq = MID,
101     .capability = "dvKit",
102     .capabilityData = nullptr,
103     .dataLen = 0
104 };
105 
106 static SubscribeInfo g_sInfo1 = {
107     .subscribeId = 1,
108     .mode = DISCOVER_MODE_PASSIVE,
109     .medium = COAP,
110     .freq = MID,
111     .isSameAccount = true,
112     .isWakeRemote = false,
113     .capability = "hicall",
114     .capabilityData = nullptr,
115     .dataLen = 0
116 };
117 
118 static PublishInfo g_publishInfo = {
119     .publishId = 1,
120     .mode = DISCOVER_MODE_PASSIVE,
121     .medium = COAP,
122     .freq = MID,
123     .capability = "dvKit",
124     .capabilityData = nullptr,
125     .dataLen = 0
126 };
127 
128 static SubscribeInfo g_subscribeInfo = {
129     .subscribeId = 1,
130     .mode = DISCOVER_MODE_PASSIVE,
131     .medium = COAP,
132     .freq = MID,
133     .isSameAccount = true,
134     .isWakeRemote = false,
135     .capability = "dvKit",
136     .capabilityData = nullptr,
137     .dataLen = 0
138 };
139 
TestDeviceFound(const DeviceInfo * device)140 static void TestDeviceFound(const DeviceInfo *device)
141 {
142     (void)device;
143     printf("[client]TestDeviceFound\n");
144 }
145 
TestOnDiscoverResult(int32_t refreshId,RefreshResult reason)146 static void TestOnDiscoverResult(int32_t refreshId, RefreshResult reason)
147 {
148     (void)refreshId;
149     (void)reason;
150     printf("[client]TestDiscoverResult\n");
151 }
152 
153 static const IRefreshCallback g_refreshCb = {
154     .OnDeviceFound = TestDeviceFound,
155     .OnDiscoverResult = TestOnDiscoverResult
156 };
157 
TestOnPublishResult(int publishId,PublishResult reason)158 static void TestOnPublishResult(int publishId, PublishResult reason)
159 {
160     (void)publishId;
161     (void)reason;
162     printf("[client]TestPublishResult\n");
163 }
164 
165 static const IPublishCb g_publishCb = {
166     .OnPublishResult = TestOnPublishResult,
167 };
168 
169 /**
170  * @tc.name: PublishLNNTest001
171  * @tc.desc: Test for invalid parameters
172  * @tc.type: FUNC
173  * @tc.require:
174  */
175 HWTEST_F(DiscSdkTest, PublishLNNTest001, TestSize.Level1)
176 {
177     int32_t ret = PublishLNN(nullptr, &g_pInfo, &g_publishCb);
178     EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
179 
180     ret = PublishLNN(g_pkgName, nullptr, &g_publishCb);
181     EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
182 
183     ret = PublishLNN(g_pkgName, &g_pInfo, nullptr);
184     EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
185 }
186 
187 /**
188  * @tc.name: PublishLNNTest002
189  * @tc.desc: Test for invalid packageName.
190  * @tc.type: FUNC
191  * @tc.require:The PublishLNN operates normally.
192  */
193 HWTEST_F(DiscSdkTest, PublishLNNTest002, TestSize.Level1)
194 {
195     g_pInfo.publishId = GetPublishId();
196     int32_t ret = PublishLNN(g_erroPkgName1, &g_pInfo, &g_publishCb);
197     EXPECT_NE(ret, SOFTBUS_OK);
198 }
199 
200 /**
201  * @tc.name: PublishLNNTest003
202  * @tc.desc: Test for invalid PublishInfo
203  * @tc.type: FUNC
204  * @tc.require:
205  */
206 HWTEST_F(DiscSdkTest, PublishLNNTest003, TestSize.Level1)
207 {
208     PublishInfo testInfo = {
209         .publishId = GetPublishId(),
210         .mode = DISCOVER_MODE_ACTIVE,
211         .medium = COAP,
212         .freq = MID,
213         .capability = "dvKit",
214         .capabilityData = (unsigned char *)"capdata2",
215         .dataLen = (unsigned int) strlen("capdata2"),
216         .ranging = false
217     };
218 
219     testInfo.mode = (DiscoverMode)(DISCOVER_MODE_ACTIVE + 1);
220     int32_t ret = PublishLNN(g_pkgName, &testInfo, &g_publishCb);
221     EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
222     testInfo.mode = (DiscoverMode)(DISCOVER_MODE_PASSIVE - 1);
223     ret = PublishLNN(g_pkgName, &testInfo, &g_publishCb);
224     EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
225     testInfo.mode = DISCOVER_MODE_PASSIVE;
226 
227     testInfo.medium = (ExchangeMedium)(COAP + 1);
228     ret = PublishLNN(g_pkgName, &testInfo, &g_publishCb);
229     EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
230     testInfo.medium = (ExchangeMedium)(AUTO - 1);
231     ret = PublishLNN(g_pkgName, &testInfo, &g_publishCb);
232     EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
233     testInfo.medium = COAP;
234 
235     testInfo.freq = (ExchangeFreq)(FREQ_BUTT);
236     ret = PublishLNN(g_pkgName, &testInfo, &g_publishCb);
237     EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
238     testInfo.freq = (ExchangeFreq)(LOW - 1);
239     ret = PublishLNN(g_pkgName, &testInfo, &g_publishCb);
240     EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
241     testInfo.freq = LOW;
242 
243     testInfo.capabilityData = nullptr;
244     ret = PublishLNN(g_pkgName, &testInfo, &g_publishCb);
245     EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
246     testInfo.capabilityData = (unsigned char *)"capdata1";
247 
248     testInfo.dataLen = ERRO_CAPDATA_LEN;
249     ret = PublishLNN(g_pkgName, &testInfo, &g_publishCb);
250     EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
251 }
252 
253 /**
254  * @tc.name: PublishLNNTest004
255  * @tc.desc: Test GetPublishId and PublishLNN to see if they are running properly.
256  * @tc.type: FUNC
257  * @tc.require:
258  */
259 HWTEST_F(DiscSdkTest, PublishLNNTest004, TestSize.Level1)
260 {
261     g_pInfo.publishId = GetPublishId();
262     int32_t ret = PublishLNN(g_pkgName, &g_pInfo, &g_publishCb);
263     EXPECT_EQ(ret, SOFTBUS_OK);
264     ret = StopPublishLNN(g_pkgName, g_pInfo.publishId);
265 
266     g_pInfo1.publishId = GetPublishId();
267     ret = PublishLNN(g_pkgName, &g_pInfo1, &g_publishCb);
268     EXPECT_EQ(ret, SOFTBUS_OK);
269     ret = StopPublishLNN(g_pkgName, g_pInfo1.publishId);
270 
271     g_pInfo1.publishId = GetPublishId();
272     ret = PublishLNN(g_pkgName_1, &g_pInfo1, &g_publishCb);
273     EXPECT_EQ(ret, SOFTBUS_OK);
274     ret = StopPublishLNN(g_pkgName_1, g_pInfo1.publishId);
275 }
276 
277 /**
278  * @tc.name: PublishLNNTest005
279  * @tc.desc: Test different freq with passive CoAP publish.
280  * @tc.type: FUNC
281  * @tc.require: The PublishLNN and StopPublishLNN operates normally.
282  */
283 HWTEST_F(DiscSdkTest, PublishLNNTest005, TestSize.Level1)
284 {
285     g_publishInfo.publishId = GetPublishId();
286     g_publishInfo.mode = DISCOVER_MODE_PASSIVE;
287     g_publishInfo.medium = COAP;
288 
289     int32_t ret = PublishLNN(g_pkgName, &g_publishInfo, &g_publishCb);
290     EXPECT_EQ(ret, SOFTBUS_OK);
291     ret = StopPublishLNN(g_pkgName, g_publishInfo.publishId);
292     EXPECT_EQ(ret, SOFTBUS_OK);
293 
294     g_publishInfo.freq = MID;
295     ret = PublishLNN(g_pkgName, &g_publishInfo, &g_publishCb);
296     EXPECT_EQ(ret, SOFTBUS_OK);
297     ret = StopPublishLNN(g_pkgName, g_publishInfo.publishId);
298     EXPECT_EQ(ret, SOFTBUS_OK);
299 
300     g_publishInfo.freq = HIGH;
301     ret = PublishLNN(g_pkgName, &g_publishInfo, &g_publishCb);
302     EXPECT_EQ(ret, SOFTBUS_OK);
303     ret = StopPublishLNN(g_pkgName, g_publishInfo.publishId);
304     EXPECT_EQ(ret, SOFTBUS_OK);
305 
306     g_publishInfo.freq = SUPER_HIGH;
307     ret = PublishLNN(g_pkgName, &g_publishInfo, &g_publishCb);
308     EXPECT_EQ(ret, SOFTBUS_OK);
309     ret = StopPublishLNN(g_pkgName, g_publishInfo.publishId);
310     EXPECT_EQ(ret, SOFTBUS_OK);
311 
312     g_publishInfo.freq = EXTREME_HIGH;
313     ret = PublishLNN(g_pkgName, &g_publishInfo, &g_publishCb);
314     EXPECT_EQ(ret, SOFTBUS_OK);
315     ret = StopPublishLNN(g_pkgName, g_publishInfo.publishId);
316     EXPECT_EQ(ret, SOFTBUS_OK);
317 }
318 
319 /**
320  * @tc.name: PublishLNNTest006
321  * @tc.desc: Test different freq with passive BLE publish.
322  * @tc.type: FUNC
323  * @tc.require: The PublishLNN and StopPublishLNN operates normally.
324  */
325 HWTEST_F(DiscSdkTest, PublishLNNTest006, TestSize.Level1)
326 {
327     g_publishInfo.publishId = GetPublishId();
328     g_publishInfo.mode = DISCOVER_MODE_PASSIVE;
329     g_publishInfo.medium = BLE;
330 
331     bool isBtOn = SoftbusTestGetBtStatus();
332     printf("bt status %s\n", isBtOn ? "on" : "off");
333 
334     int32_t ret = PublishLNN(g_pkgName, &g_publishInfo, &g_publishCb);
335     EXPECT_EQ(isBtOn, (ret == SOFTBUS_OK));
336     ret = StopPublishLNN(g_pkgName, g_publishInfo.publishId);
337     EXPECT_EQ(isBtOn, (ret == SOFTBUS_OK));
338 
339     g_publishInfo.freq = MID;
340     ret = PublishLNN(g_pkgName, &g_publishInfo, &g_publishCb);
341     EXPECT_EQ(isBtOn, (ret == SOFTBUS_OK));
342     ret = StopPublishLNN(g_pkgName, g_publishInfo.publishId);
343     EXPECT_EQ(isBtOn, (ret == SOFTBUS_OK));
344 
345     g_publishInfo.freq = HIGH;
346     ret = PublishLNN(g_pkgName, &g_publishInfo, &g_publishCb);
347     EXPECT_EQ(isBtOn, (ret == SOFTBUS_OK));
348     ret = StopPublishLNN(g_pkgName, g_publishInfo.publishId);
349     EXPECT_EQ(isBtOn, (ret == SOFTBUS_OK));
350 
351     g_publishInfo.freq = SUPER_HIGH;
352     ret = PublishLNN(g_pkgName, &g_publishInfo, &g_publishCb);
353     EXPECT_EQ(isBtOn, (ret == SOFTBUS_OK));
354     ret = StopPublishLNN(g_pkgName, g_publishInfo.publishId);
355     EXPECT_EQ(isBtOn, (ret == SOFTBUS_OK));
356 
357     g_publishInfo.freq = EXTREME_HIGH;
358     ret = PublishLNN(g_pkgName, &g_publishInfo, &g_publishCb);
359     EXPECT_EQ(isBtOn, (ret == SOFTBUS_OK));
360     ret = StopPublishLNN(g_pkgName, g_publishInfo.publishId);
361     EXPECT_EQ(isBtOn, (ret == SOFTBUS_OK));
362 }
363 
364 /**
365  * @tc.name: PublishLNNTest007
366  * @tc.desc: Test different capability with passive CoAP publish.
367  * @tc.type: FUNC
368  * @tc.require: The PublishLNN and StopPublishLNN operates normally.
369  */
370 HWTEST_F(DiscSdkTest, PublishLNNTest007, TestSize.Level1)
371 {
372     g_publishInfo.publishId = GetPublishId();
373     g_publishInfo.mode = DISCOVER_MODE_PASSIVE;
374     g_publishInfo.medium = COAP;
375 
376     int32_t ret = PublishLNN(g_pkgName, &g_publishInfo, &g_publishCb);
377     EXPECT_EQ(ret, SOFTBUS_OK);
378     ret = StopPublishLNN(g_pkgName, g_publishInfo.publishId);
379 
380     g_publishInfo.capability = "hicall";
381     ret = PublishLNN(g_pkgName, &g_publishInfo, &g_publishCb);
382     EXPECT_EQ(ret, SOFTBUS_OK);
383     ret = StopPublishLNN(g_pkgName, g_publishInfo.publishId);
384 
385     g_publishInfo.capability = "profile";
386     ret = PublishLNN(g_pkgName, &g_publishInfo, &g_publishCb);
387     EXPECT_EQ(ret, SOFTBUS_OK);
388     ret = StopPublishLNN(g_pkgName, g_publishInfo.publishId);
389 
390     g_publishInfo.capability = "homevisionPic";
391     ret = PublishLNN(g_pkgName, &g_publishInfo, &g_publishCb);
392     EXPECT_EQ(ret, SOFTBUS_OK);
393     ret = StopPublishLNN(g_pkgName, g_publishInfo.publishId);
394 
395     g_publishInfo.capability = "castPlus";
396     g_publishInfo.capabilityData = (unsigned char *)"{\"castPlus\":\"capdata2\"}";
397     g_publishInfo.dataLen = (unsigned int) strlen("{\"castPlus\":\"capdata2\"}");
398     ret = PublishLNN(g_pkgName, &g_publishInfo, &g_publishCb);
399     EXPECT_EQ(ret, SOFTBUS_OK);
400     g_publishInfo.capabilityData = (unsigned char *)"capdata2";
401     g_publishInfo.dataLen = (unsigned int) strlen("capdata2");
402     ret = StopPublishLNN(g_pkgName, g_publishInfo.publishId);
403 
404     g_publishInfo.capability = "aaCapability";
405     ret = PublishLNN(g_pkgName, &g_publishInfo, &g_publishCb);
406     EXPECT_EQ(ret, SOFTBUS_OK);
407     ret = StopPublishLNN(g_pkgName, g_publishInfo.publishId);
408 
409     g_publishInfo.capability = "ddmpCapability";
410     ret = PublishLNN(g_pkgName, &g_publishInfo, &g_publishCb);
411     EXPECT_EQ(ret, SOFTBUS_OK);
412     ret = StopPublishLNN(g_pkgName, g_publishInfo.publishId);
413 
414     g_publishInfo.capability = "osdCapability";
415     ret = PublishLNN(g_pkgName, &g_publishInfo, &g_publishCb);
416     EXPECT_EQ(ret, SOFTBUS_OK);
417     ret = StopPublishLNN(g_pkgName, g_publishInfo.publishId);
418 }
419 
420 /**
421  * @tc.name: PublishLNNTest008
422  * @tc.desc: Test different capability with passive BLE publish: dvKit, castPlus, osdCapability
423  * @tc.type: FUNC
424  * @tc.require: The PublishLNN and StopPublishLNN operates normally.
425  */
426 HWTEST_F(DiscSdkTest, PublishLNNTest008, TestSize.Level1)
427 {
428     g_publishInfo.publishId = GetPublishId();
429     g_publishInfo.mode = DISCOVER_MODE_PASSIVE;
430     g_publishInfo.medium = BLE;
431 
432     bool isBtOn = SoftbusTestGetBtStatus();
433     printf("bt status %s\n", isBtOn ? "on" : "off");
434 
435     g_publishInfo.capability = "dvKit";
436     int32_t ret = PublishLNN(g_pkgName, &g_publishInfo, &g_publishCb);
437     EXPECT_EQ(isBtOn, (ret == SOFTBUS_OK));
438     ret = StopPublishLNN(g_pkgName, g_publishInfo.publishId);
439 
440     g_publishInfo.capability = "castPlus";
441     g_publishInfo.capabilityData = (unsigned char *)"{\"castPlus\":\"capdata2\"}";
442     g_publishInfo.dataLen = (unsigned int) strlen("{\"castPlus\":\"capdata2\"}");
443     ret = PublishLNN(g_pkgName, &g_publishInfo, &g_publishCb);
444     EXPECT_EQ(isBtOn, (ret == SOFTBUS_OK));
445     g_publishInfo.capabilityData = (unsigned char *)"capdata2";
446     g_publishInfo.dataLen = (unsigned int) strlen("capdata2");
447     ret = StopPublishLNN(g_pkgName, g_publishInfo.publishId);
448 
449     g_publishInfo.capability = "osdCapability";
450     ret = PublishLNN(g_pkgName, &g_publishInfo, &g_publishCb);
451     EXPECT_EQ(isBtOn, (ret == SOFTBUS_OK));
452     ret = StopPublishLNN(g_pkgName, g_publishInfo.publishId);
453 }
454 
455 /**
456  * @tc.name: RefreshLNNTest001
457  * @tc.desc: Test for invalid parameters
458  * @tc.type: FUNC
459  * @tc.require:
460  */
461 HWTEST_F(DiscSdkTest, RefreshLNNTest001, TestSize.Level1)
462 {
463     int32_t ret = RefreshLNN(nullptr, &g_sInfo, &g_refreshCb);
464     EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
465 
466     ret = RefreshLNN(g_pkgName, nullptr, &g_refreshCb);
467     EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
468 
469     ret = RefreshLNN(g_pkgName, &g_sInfo, nullptr);
470     EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
471 }
472 
473 /**
474  * @tc.name: RefreshLNNTest002
475  * @tc.desc: Test for invalid packageName.
476  * @tc.type: FUNC
477  * @tc.require:The PublishLNN operates normally.
478  */
479 HWTEST_F(DiscSdkTest, RefreshLNNTest002, TestSize.Level1)
480 {
481     g_sInfo.subscribeId = GetSubscribeId();
482     int32_t ret = RefreshLNN(g_erroPkgName1, &g_sInfo, &g_refreshCb);
483     EXPECT_NE(ret, SOFTBUS_OK);
484 }
485 
486 /**
487  * @tc.name: RefreshLNNTest003
488  * @tc.desc: Test for invalid SubscribeInfo.
489  * @tc.type: FUNC
490  * @tc.require:
491  */
492 HWTEST_F(DiscSdkTest, RefreshLNNTest003, TestSize.Level1)
493 {
494     SubscribeInfo testInfo = {
495         .subscribeId = GetSubscribeId(),
496         .mode = DISCOVER_MODE_ACTIVE,
497         .medium = COAP,
498         .freq = MID,
499         .isSameAccount = true,
500         .isWakeRemote = false,
501         .capability = "dvKit",
502         .capabilityData = (unsigned char *)"capdata3",
503         .dataLen = (unsigned int) strlen("capdata3")
504     };
505 
506     testInfo.mode = (DiscoverMode)(DISCOVER_MODE_ACTIVE + 1);
507     int32_t ret = RefreshLNN(g_pkgName, &testInfo, &g_refreshCb);
508     EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
509     testInfo.mode = (DiscoverMode)(DISCOVER_MODE_PASSIVE - 1);
510     ret = RefreshLNN(g_pkgName, &testInfo, &g_refreshCb);
511     EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
512     testInfo.mode = DISCOVER_MODE_PASSIVE;
513 
514     testInfo.medium = (ExchangeMedium)(COAP + 1);
515     ret = RefreshLNN(g_pkgName, &testInfo, &g_refreshCb);
516     EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
517     testInfo.medium = (ExchangeMedium)(AUTO - 1);
518     ret = RefreshLNN(g_pkgName, &testInfo, &g_refreshCb);
519     EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
520     testInfo.medium = COAP;
521 
522     testInfo.freq = (ExchangeFreq)(FREQ_BUTT);
523     ret = RefreshLNN(g_pkgName, &testInfo, &g_refreshCb);
524     EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
525     testInfo.freq = (ExchangeFreq)(LOW - 1);
526     ret = RefreshLNN(g_pkgName, &testInfo, &g_refreshCb);
527     EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
528     testInfo.freq = LOW;
529 
530     testInfo.capabilityData = nullptr;
531     ret = RefreshLNN(g_pkgName, &testInfo, &g_refreshCb);
532     EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
533     testInfo.capabilityData = (unsigned char *)"capdata1";
534 
535     testInfo.dataLen = ERRO_CAPDATA_LEN;
536     ret = RefreshLNN(g_pkgName, &testInfo, &g_refreshCb);
537     EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
538 }
539 
540 /**
541  * @tc.name: RefreshLNNTest004
542  * @tc.desc: Verify the RefreshLNN normal case.
543  * @tc.type: FUNC
544  * @tc.require:
545  */
546 HWTEST_F(DiscSdkTest, RefreshLNNTest004, TestSize.Level1)
547 {
548     g_sInfo.subscribeId = GetSubscribeId();
549     int32_t ret = RefreshLNN(g_pkgName, &g_sInfo, &g_refreshCb);
550     EXPECT_EQ(ret, SOFTBUS_OK);
551     ret = StopRefreshLNN(g_pkgName, g_sInfo.subscribeId);
552 
553     g_sInfo1.subscribeId = GetSubscribeId();
554     ret = RefreshLNN(g_pkgName, &g_sInfo1, &g_refreshCb);
555     EXPECT_EQ(ret, SOFTBUS_OK);
556     ret = StopRefreshLNN(g_pkgName, g_sInfo1.subscribeId);
557 
558     g_sInfo1.subscribeId = GetSubscribeId();
559     ret = RefreshLNN(g_pkgName_1, &g_sInfo1, &g_refreshCb);
560     EXPECT_EQ(ret, SOFTBUS_OK);
561     ret = StopRefreshLNN(g_pkgName, g_sInfo1.subscribeId);
562 }
563 
564 /**
565  * @tc.name: RefreshLNNTest005
566  * @tc.desc: Test different freq with passive CoAP discovery.
567  * @tc.type: FUNC
568  * @tc.require: The RefreshLNN and StopRefreshLNN operates normally.
569  */
570 HWTEST_F(DiscSdkTest, RefreshLNNTest005, TestSize.Level1)
571 {
572     g_subscribeInfo.subscribeId = GetSubscribeId();
573     g_subscribeInfo.mode = DISCOVER_MODE_PASSIVE;
574     g_subscribeInfo.medium = COAP;
575 
576     int32_t ret = RefreshLNN(g_pkgName, &g_subscribeInfo, &g_refreshCb);
577     EXPECT_EQ(ret, SOFTBUS_OK);
578     ret = StopRefreshLNN(g_pkgName, g_subscribeInfo.subscribeId);
579     EXPECT_EQ(ret, SOFTBUS_OK);
580 
581     g_subscribeInfo.freq = MID;
582     ret = RefreshLNN(g_pkgName, &g_subscribeInfo, &g_refreshCb);
583     EXPECT_EQ(ret, SOFTBUS_OK);
584     ret = StopRefreshLNN(g_pkgName, g_subscribeInfo.subscribeId);
585     EXPECT_EQ(ret, SOFTBUS_OK);
586 
587     g_subscribeInfo.freq = HIGH;
588     ret = RefreshLNN(g_pkgName, &g_subscribeInfo, &g_refreshCb);
589     EXPECT_EQ(ret, SOFTBUS_OK);
590     ret = StopRefreshLNN(g_pkgName, g_subscribeInfo.subscribeId);
591     EXPECT_EQ(ret, SOFTBUS_OK);
592 
593     g_subscribeInfo.freq = SUPER_HIGH;
594     ret = RefreshLNN(g_pkgName, &g_subscribeInfo, &g_refreshCb);
595     EXPECT_EQ(ret, SOFTBUS_OK);
596     ret = StopRefreshLNN(g_pkgName, g_subscribeInfo.subscribeId);
597     EXPECT_EQ(ret, SOFTBUS_OK);
598 
599     g_subscribeInfo.freq = EXTREME_HIGH;
600     ret = RefreshLNN(g_pkgName, &g_subscribeInfo, &g_refreshCb);
601     EXPECT_EQ(ret, SOFTBUS_OK);
602     ret = StopRefreshLNN(g_pkgName, g_subscribeInfo.subscribeId);
603     EXPECT_EQ(ret, SOFTBUS_OK);
604 }
605 
606 /**
607  * @tc.name: RefreshLNNTest006
608  * @tc.desc: Test different freq with passive BLE discovery.
609  * @tc.type: FUNC
610  * @tc.require: The RefreshLNN and StopRefreshLNN operates normally.
611  */
612 HWTEST_F(DiscSdkTest, RefreshLNNTest006, TestSize.Level1)
613 {
614     g_subscribeInfo.subscribeId = GetSubscribeId();
615     g_subscribeInfo.mode = DISCOVER_MODE_PASSIVE;
616     g_subscribeInfo.medium = BLE;
617 
618     bool isBtOn = SoftbusTestGetBtStatus();
619     printf("bt status %s\n", isBtOn ? "on" : "off");
620 
621     int32_t ret = RefreshLNN(g_pkgName, &g_subscribeInfo, &g_refreshCb);
622     EXPECT_EQ(isBtOn, (ret == SOFTBUS_OK));
623     ret = StopRefreshLNN(g_pkgName, g_subscribeInfo.subscribeId);
624     EXPECT_EQ(isBtOn, (ret == SOFTBUS_OK));
625 
626     g_subscribeInfo.freq = MID;
627     ret = RefreshLNN(g_pkgName, &g_subscribeInfo, &g_refreshCb);
628     EXPECT_EQ(isBtOn, (ret == SOFTBUS_OK));
629     ret = StopRefreshLNN(g_pkgName, g_subscribeInfo.subscribeId);
630     EXPECT_EQ(isBtOn, (ret == SOFTBUS_OK));
631 
632     g_subscribeInfo.freq = HIGH;
633     ret = RefreshLNN(g_pkgName, &g_subscribeInfo, &g_refreshCb);
634     EXPECT_EQ(isBtOn, (ret == SOFTBUS_OK));
635     ret = StopRefreshLNN(g_pkgName, g_subscribeInfo.subscribeId);
636     EXPECT_EQ(isBtOn, (ret == SOFTBUS_OK));
637 
638     g_subscribeInfo.freq = SUPER_HIGH;
639     ret = RefreshLNN(g_pkgName, &g_subscribeInfo, &g_refreshCb);
640     EXPECT_EQ(isBtOn, (ret == SOFTBUS_OK));
641     ret = StopRefreshLNN(g_pkgName, g_subscribeInfo.subscribeId);
642     EXPECT_EQ(isBtOn, (ret == SOFTBUS_OK));
643 
644     g_subscribeInfo.freq = EXTREME_HIGH;
645     ret = RefreshLNN(g_pkgName, &g_subscribeInfo, &g_refreshCb);
646     EXPECT_EQ(isBtOn, (ret == SOFTBUS_OK));
647     ret = StopRefreshLNN(g_pkgName, g_subscribeInfo.subscribeId);
648     EXPECT_EQ(isBtOn, (ret == SOFTBUS_OK));
649 }
650 
651 /**
652  * @tc.name: RefreshLNNTest007
653  * @tc.desc: Test different capability with passive CoAP discovery.
654  * @tc.type: FUNC
655  * @tc.require: The RefreshLNN and StopRefreshLNN operates normally.
656  */
657 HWTEST_F(DiscSdkTest, RefreshLNNTest007, TestSize.Level1)
658 {
659     g_subscribeInfo.subscribeId = GetSubscribeId();
660     g_subscribeInfo.mode = DISCOVER_MODE_PASSIVE;
661     g_subscribeInfo.medium = COAP;
662 
663     int32_t ret = RefreshLNN(g_pkgName, &g_subscribeInfo, &g_refreshCb);
664     EXPECT_EQ(ret, SOFTBUS_OK);
665     ret = StopRefreshLNN(g_pkgName, g_subscribeInfo.subscribeId);
666 
667     g_subscribeInfo.capability = "hicall";
668     ret = RefreshLNN(g_pkgName, &g_subscribeInfo, &g_refreshCb);
669     EXPECT_EQ(ret, SOFTBUS_OK);
670     ret = StopRefreshLNN(g_pkgName, g_subscribeInfo.subscribeId);
671 
672     g_subscribeInfo.capability = "profile";
673     ret = RefreshLNN(g_pkgName, &g_subscribeInfo, &g_refreshCb);
674     EXPECT_EQ(ret, SOFTBUS_OK);
675     ret = StopRefreshLNN(g_pkgName, g_subscribeInfo.subscribeId);
676 
677     g_subscribeInfo.capability = "homevisionPic";
678     ret = RefreshLNN(g_pkgName, &g_subscribeInfo, &g_refreshCb);
679     EXPECT_EQ(ret, SOFTBUS_OK);
680     ret = StopRefreshLNN(g_pkgName, g_subscribeInfo.subscribeId);
681 
682     g_subscribeInfo.capability = "castPlus";
683     ret = RefreshLNN(g_pkgName, &g_subscribeInfo, &g_refreshCb);
684     EXPECT_EQ(ret, SOFTBUS_OK);
685     ret = StopRefreshLNN(g_pkgName, g_subscribeInfo.subscribeId);
686 
687     g_subscribeInfo.capability = "aaCapability";
688     ret = RefreshLNN(g_pkgName, &g_subscribeInfo, &g_refreshCb);
689     EXPECT_EQ(ret, SOFTBUS_OK);
690     ret = StopRefreshLNN(g_pkgName, g_subscribeInfo.subscribeId);
691 
692     g_subscribeInfo.capability = "ddmpCapability";
693     ret = RefreshLNN(g_pkgName, &g_subscribeInfo, &g_refreshCb);
694     EXPECT_EQ(ret, SOFTBUS_OK);
695     ret = StopRefreshLNN(g_pkgName, g_subscribeInfo.subscribeId);
696 
697     g_subscribeInfo.capability = "osdCapability";
698     ret = RefreshLNN(g_pkgName, &g_subscribeInfo, &g_refreshCb);
699     EXPECT_EQ(ret, SOFTBUS_OK);
700     ret = StopRefreshLNN(g_pkgName, g_subscribeInfo.subscribeId);
701 }
702 
703 /**
704  * @tc.name: RefreshLNNTest008
705  * @tc.desc: Test different capability with passive BLE discovery: dvKit, castPlus, osdCapability
706  * @tc.type: FUNC
707  * @tc.require: The RefreshLNN and StopRefreshLNN operates normally.
708  */
709 HWTEST_F(DiscSdkTest, RefreshLNNTest008, TestSize.Level1)
710 {
711     g_subscribeInfo.subscribeId = GetSubscribeId();
712     g_subscribeInfo.mode = DISCOVER_MODE_PASSIVE;
713     g_subscribeInfo.medium = BLE;
714 
715     bool isBtOn = SoftbusTestGetBtStatus();
716     printf("bt status %s\n", isBtOn ? "on" : "off");
717 
718     g_subscribeInfo.capability = "dvKit";
719     int32_t ret = RefreshLNN(g_pkgName, &g_subscribeInfo, &g_refreshCb);
720     EXPECT_EQ(isBtOn, (ret == SOFTBUS_OK));
721     ret = StopRefreshLNN(g_pkgName, g_subscribeInfo.subscribeId);
722 
723     g_subscribeInfo.capability = "castPlus";
724     ret = RefreshLNN(g_pkgName, &g_subscribeInfo, &g_refreshCb);
725     EXPECT_EQ(isBtOn, (ret == SOFTBUS_OK));
726     ret = StopRefreshLNN(g_pkgName, g_subscribeInfo.subscribeId);
727 
728     g_subscribeInfo.capability = "osdCapability";
729     ret = RefreshLNN(g_pkgName, &g_subscribeInfo, &g_refreshCb);
730     EXPECT_EQ(isBtOn, (ret == SOFTBUS_OK));
731     ret = StopRefreshLNN(g_pkgName, g_subscribeInfo.subscribeId);
732 }
733 
734 /**
735  * @tc.name: StopPublishLNNTest001
736  * @tc.desc: Verify StopPublishLNN invalid parameter.
737  * @tc.type: FUNC
738  * @tc.require:
739  */
740 HWTEST_F(DiscSdkTest, StopPublishLNNTest001, TestSize.Level1)
741 {
742     int32_t tmpId = GetPublishId();
743     g_pInfo.publishId = tmpId;
744     PublishLNN(g_pkgName, &g_pInfo, &g_publishCb);
745 
746     int32_t ret = StopPublishLNN(nullptr, tmpId);
747     EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
748 
749     ret = StopPublishLNN(g_erroPkgName, tmpId);
750     EXPECT_NE(ret, SOFTBUS_OK);
751 }
752 
753 /**
754  * @tc.name: StopPublishLNNTest002
755  * @tc.desc: Verify PublishLNN and StopPublishLNN normal case.
756  * @tc.type: FUNC
757  * @tc.require:
758  */
759 HWTEST_F(DiscSdkTest, StopPublishLNNTest002, TestSize.Level1)
760 {
761     int32_t tmpId1 = GetPublishId();
762     int32_t tmpId2 = GetPublishId();
763 
764     g_pInfo.publishId = tmpId1;
765     PublishLNN(g_pkgName, &g_pInfo, &g_publishCb);
766     g_pInfo1.publishId = tmpId2;
767     PublishLNN(g_pkgName, &g_pInfo1, &g_publishCb);
768 
769     int32_t ret = StopPublishLNN(g_pkgName, tmpId1);
770     EXPECT_EQ(ret, SOFTBUS_OK);
771     ret = StopPublishLNN(g_pkgName, tmpId2);
772     EXPECT_EQ(ret, SOFTBUS_OK);
773 }
774 
775 /**
776  * @tc.name: StopPublishLNNTest003
777  * @tc.desc: Verify PublishLNN and StopPublishLNN same parameter again.
778  * @tc.type: FUNC
779  * @tc.require:
780  */
781 HWTEST_F(DiscSdkTest, StopPublishLNNTest003, TestSize.Level1)
782 {
783     int32_t tmpId = GetPublishId();
784     g_pInfo.publishId = tmpId;
785     PublishLNN(g_pkgName, &g_pInfo, &g_publishCb);
786 
787     int32_t ret = StopPublishLNN(g_pkgName, tmpId);
788     EXPECT_EQ(ret, SOFTBUS_OK);
789 }
790 
791 /**
792  * @tc.name: StopPublishLNNTest004
793  * @tc.desc: Test different freq with stop passive CoAP publish.
794  * @tc.type: FUNC
795  * @tc.require: The StopPublishLNN operates normally.
796  */
797 HWTEST_F(DiscSdkTest, StopPublishLNNTest004, TestSize.Level1)
798 {
799     g_publishInfo.publishId = GetPublishId();
800     g_publishInfo.mode = DISCOVER_MODE_PASSIVE;
801     g_publishInfo.medium = COAP;
802 
803     PublishLNN(g_pkgName, &g_publishInfo, &g_publishCb);
804     int32_t ret = StopPublishLNN(g_pkgName, g_publishInfo.publishId);
805     EXPECT_EQ(ret, SOFTBUS_OK);
806 
807     g_publishInfo.freq = MID;
808     PublishLNN(g_pkgName, &g_publishInfo, &g_publishCb);
809     ret = StopPublishLNN(g_pkgName, g_publishInfo.publishId);
810     EXPECT_EQ(ret, SOFTBUS_OK);
811 
812     g_publishInfo.freq = HIGH;
813     PublishLNN(g_pkgName, &g_publishInfo, &g_publishCb);
814     ret = StopPublishLNN(g_pkgName, g_publishInfo.publishId);
815     EXPECT_EQ(ret, SOFTBUS_OK);
816 
817     g_publishInfo.freq = SUPER_HIGH;
818     PublishLNN(g_pkgName, &g_publishInfo, &g_publishCb);
819     ret = StopPublishLNN(g_pkgName, g_publishInfo.publishId);
820     EXPECT_EQ(ret, SOFTBUS_OK);
821 
822     g_publishInfo.freq = EXTREME_HIGH;
823     PublishLNN(g_pkgName, &g_publishInfo, &g_publishCb);
824     ret = StopPublishLNN(g_pkgName, g_publishInfo.publishId);
825     EXPECT_EQ(ret, SOFTBUS_OK);
826 }
827 
828 /**
829  * @tc.name: StopPublishLNNTest005
830  * @tc.desc: Test different freq with stop passive BLE publish.
831  * @tc.type: FUNC
832  * @tc.require: The StopPublishLNN operates normally.
833  */
834 HWTEST_F(DiscSdkTest, StopPublishLNNTest005, TestSize.Level1)
835 {
836     g_publishInfo.publishId = GetPublishId();
837     g_publishInfo.mode = DISCOVER_MODE_PASSIVE;
838     g_publishInfo.medium = BLE;
839 
840     bool isBtOn = SoftbusTestGetBtStatus();
841     printf("bt status %s\n", isBtOn ? "on" : "off");
842 
843     PublishLNN(g_pkgName, &g_publishInfo, &g_publishCb);
844     int32_t ret = StopPublishLNN(g_pkgName, g_publishInfo.publishId);
845     EXPECT_EQ(isBtOn, (ret == SOFTBUS_OK));
846 
847     g_publishInfo.freq = MID;
848     PublishLNN(g_pkgName, &g_publishInfo, &g_publishCb);
849     ret = StopPublishLNN(g_pkgName, g_publishInfo.publishId);
850     EXPECT_EQ(isBtOn, (ret == SOFTBUS_OK));
851 
852     g_publishInfo.freq = HIGH;
853     PublishLNN(g_pkgName, &g_publishInfo, &g_publishCb);
854     ret = StopPublishLNN(g_pkgName, g_publishInfo.publishId);
855     EXPECT_EQ(isBtOn, (ret == SOFTBUS_OK));
856 
857     g_publishInfo.freq = SUPER_HIGH;
858     PublishLNN(g_pkgName, &g_publishInfo, &g_publishCb);
859     ret = StopPublishLNN(g_pkgName, g_publishInfo.publishId);
860     EXPECT_EQ(isBtOn, (ret == SOFTBUS_OK));
861 
862     g_publishInfo.freq = EXTREME_HIGH;
863     PublishLNN(g_pkgName, &g_publishInfo, &g_publishCb);
864     ret = StopPublishLNN(g_pkgName, g_publishInfo.publishId);
865     EXPECT_EQ(isBtOn, (ret == SOFTBUS_OK));
866 }
867 
868 /**
869  * @tc.name: StopRefreshLNNTest001
870  * @tc.desc: Verify StopRefreshLNN invalid parameter.
871  * @tc.type: FUNC
872  * @tc.require:
873  */
874 HWTEST_F(DiscSdkTest, StopRefreshLNNTest001, TestSize.Level1)
875 {
876     int32_t tmpId = GetSubscribeId();
877     g_sInfo.subscribeId = tmpId;
878     RefreshLNN(g_pkgName, &g_sInfo, &g_refreshCb);
879 
880     int32_t ret = StopRefreshLNN(nullptr, tmpId);
881     EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
882     ret = StopRefreshLNN(g_erroPkgName, tmpId);
883     EXPECT_NE(ret, SOFTBUS_OK);
884 }
885 
886 /**
887  * @tc.name: StopRefreshLNNTest002
888  * @tc.desc: test under normal conditions.
889  * @tc.type: FUNC
890  * @tc.require:
891  */
892 HWTEST_F(DiscSdkTest, StopRefreshLNNTest002, TestSize.Level1)
893 {
894     int32_t tmpId1 = GetSubscribeId();
895     int32_t tmpId2 = GetSubscribeId();
896 
897     g_sInfo.subscribeId = tmpId1;
898     RefreshLNN(g_pkgName, &g_sInfo, &g_refreshCb);
899     g_sInfo1.subscribeId = tmpId2;
900     RefreshLNN(g_pkgName, &g_sInfo1, &g_refreshCb);
901 
902     int32_t ret = StopRefreshLNN(g_pkgName, tmpId1);
903     EXPECT_EQ(ret, SOFTBUS_OK);
904     ret = StopRefreshLNN(g_pkgName, tmpId2);
905     EXPECT_EQ(ret, SOFTBUS_OK);
906 }
907 
908 /**
909  * @tc.name: StopRefreshLNNTest003
910  * @tc.desc: Verify RefreshLNN and StopRefreshLNN same parameter again.
911  * @tc.type: FUNC
912  * @tc.require:
913  */
914 HWTEST_F(DiscSdkTest, StopRefreshLNNTest003, TestSize.Level1)
915 {
916     int32_t tmpId = GetSubscribeId();
917     g_sInfo.subscribeId = tmpId;
918     RefreshLNN(g_pkgName, &g_sInfo, &g_refreshCb);
919 
920     int32_t ret = StopRefreshLNN(g_pkgName, tmpId);
921     EXPECT_EQ(ret, SOFTBUS_OK);
922 }
923 
924 /**
925  * @tc.name: StopRefreshLNNTest004
926  * @tc.desc:Test different freq with stop passive CoAP discovery.
927  * @tc.type: FUNC
928  * @tc.require: The StopRefreshLNN operates normally
929  */
930 HWTEST_F(DiscSdkTest, StopRefreshLNNTest004, TestSize.Level1)
931 {
932     g_subscribeInfo.subscribeId = GetSubscribeId();
933     g_subscribeInfo.mode = DISCOVER_MODE_PASSIVE;
934     g_subscribeInfo.medium = COAP;
935 
936     RefreshLNN(g_pkgName, &g_subscribeInfo, &g_refreshCb);
937     int32_t ret = StopRefreshLNN(g_pkgName, g_subscribeInfo.subscribeId);
938     EXPECT_EQ(ret, SOFTBUS_OK);
939 
940     g_subscribeInfo.freq = MID;
941     RefreshLNN(g_pkgName, &g_subscribeInfo, &g_refreshCb);
942     ret = StopRefreshLNN(g_pkgName, g_subscribeInfo.subscribeId);
943     EXPECT_EQ(ret, SOFTBUS_OK);
944 
945     g_subscribeInfo.freq = HIGH;
946     RefreshLNN(g_pkgName, &g_subscribeInfo, &g_refreshCb);
947     ret = StopRefreshLNN(g_pkgName, g_subscribeInfo.subscribeId);
948     EXPECT_EQ(ret, SOFTBUS_OK);
949 
950     g_subscribeInfo.freq = SUPER_HIGH;
951     RefreshLNN(g_pkgName, &g_subscribeInfo, &g_refreshCb);
952     ret = StopRefreshLNN(g_pkgName, g_subscribeInfo.subscribeId);
953     EXPECT_EQ(ret, SOFTBUS_OK);
954 
955     g_subscribeInfo.freq = EXTREME_HIGH;
956     RefreshLNN(g_pkgName, &g_subscribeInfo, &g_refreshCb);
957     ret = StopRefreshLNN(g_pkgName, g_subscribeInfo.subscribeId);
958     EXPECT_EQ(ret, SOFTBUS_OK);
959 }
960 
961 /**
962  * @tc.name: StopRefreshLNNTest005
963  * @tc.desc:Test different freq with stop passive BLE discovery.
964  * @tc.type: FUNC
965  * @tc.require: The StopRefreshLNN operates normally
966  */
967 HWTEST_F(DiscSdkTest, StopRefreshLNNTest005, TestSize.Level1)
968 {
969     g_subscribeInfo.subscribeId = GetSubscribeId();
970     g_subscribeInfo.mode = DISCOVER_MODE_PASSIVE;
971     g_subscribeInfo.medium = BLE;
972 
973     bool isBtOn = SoftbusTestGetBtStatus();
974     printf("bt status %s\n", isBtOn ? "on" : "off");
975 
976     RefreshLNN(g_pkgName, &g_subscribeInfo, &g_refreshCb);
977     int32_t ret = StopRefreshLNN(g_pkgName, g_subscribeInfo.subscribeId);
978     EXPECT_EQ(isBtOn, (ret == SOFTBUS_OK));
979 
980     g_subscribeInfo.freq = MID;
981     RefreshLNN(g_pkgName, &g_subscribeInfo, &g_refreshCb);
982     ret = StopRefreshLNN(g_pkgName, g_subscribeInfo.subscribeId);
983     EXPECT_EQ(isBtOn, (ret == SOFTBUS_OK));
984 
985     g_subscribeInfo.freq = HIGH;
986     RefreshLNN(g_pkgName, &g_subscribeInfo, &g_refreshCb);
987     ret = StopRefreshLNN(g_pkgName, g_subscribeInfo.subscribeId);
988     EXPECT_EQ(isBtOn, (ret == SOFTBUS_OK));
989 
990     g_subscribeInfo.freq = SUPER_HIGH;
991     RefreshLNN(g_pkgName, &g_subscribeInfo, &g_refreshCb);
992     ret = StopRefreshLNN(g_pkgName, g_subscribeInfo.subscribeId);
993     EXPECT_EQ(isBtOn, (ret == SOFTBUS_OK));
994 
995     g_subscribeInfo.freq = EXTREME_HIGH;
996     RefreshLNN(g_pkgName, &g_subscribeInfo, &g_refreshCb);
997     ret = StopRefreshLNN(g_pkgName, g_subscribeInfo.subscribeId);
998     EXPECT_EQ(isBtOn, (ret == SOFTBUS_OK));
999 }
1000 
1001 /**
1002  * @tc.name:DiscRecoveryPublishTest01
1003  * @tc.desc: Test recovery publish.
1004  * @tc.in: Test module, Test number, Test levels.
1005  * @tc.out: Zero
1006  * @tc.type: FUNC
1007  * @tc.require:The DiscRecoveryPublish operates normally
1008  */
1009 HWTEST_F(DiscSdkTest, DiscRecoveryPublishTest01, TestSize.Level1)
1010 {
1011     int ret;
1012     PublishInfo testInfo = {
1013         .publishId = GetPublishId(),
1014         .mode = DISCOVER_MODE_PASSIVE,
1015         .medium = COAP,
1016         .freq = LOW,
1017         .capability = "dvKit",
1018         .capabilityData = (unsigned char *)"capdata2",
1019         .dataLen = (unsigned int) strlen("capdata2")
1020     };
1021     BusCenterClientDeinit();
1022     BusCenterClientInit();
1023     ret = DiscRecoveryPublish();
1024     EXPECT_EQ(ret, SOFTBUS_OK);
1025 
1026     ret = PublishLNN(g_pkgName, &testInfo, &g_publishCb);
1027     EXPECT_EQ(ret, SOFTBUS_OK);
1028     ret = DiscRecoveryPublish();
1029     EXPECT_TRUE(ret != 0);
1030     ret = StopPublishLNN(g_pkgName, testInfo.publishId);
1031 
1032     ret = PublishLNN(g_pkgName, &testInfo, &g_publishCb);
1033     EXPECT_EQ(ret, SOFTBUS_OK);
1034     ret = StopPublishLNN(g_pkgName, testInfo.publishId);
1035     ret = DiscRecoveryPublish();
1036     EXPECT_EQ(ret, SOFTBUS_OK);
1037 }
1038 
1039 /**
1040  * @tc.name:DiscRecoverySubscribeTest01
1041  * @tc.desc: Test recovery subscribe.
1042  * @tc.in: Test module, Test number, Test levels.
1043  * @tc.out: Zero
1044  * @tc.type: FUNC
1045  * @tc.require:The DiscRecoverySubscribe operates normally
1046  */
1047 HWTEST_F(DiscSdkTest, DiscRecoverySubscribeTest01, TestSize.Level1)
1048 {
1049     int ret;
1050     SubscribeInfo testInfo = {
1051         .subscribeId = GetSubscribeId(),
1052         .mode = DISCOVER_MODE_PASSIVE,
1053         .medium = AUTO,
1054         .freq = LOW,
1055         .isSameAccount = true,
1056         .isWakeRemote = false,
1057         .capability = "dvKit",
1058         .capabilityData = (unsigned char *)"capdata3",
1059         .dataLen = (unsigned int) strlen("capdata3")
1060     };
1061     BusCenterClientDeinit();
1062     BusCenterClientInit();
1063     ret = DiscRecoverySubscribe();
1064     EXPECT_EQ(ret, SOFTBUS_OK);
1065 
1066     ret = RefreshLNN(g_pkgName, &testInfo, &g_refreshCb);
1067     EXPECT_EQ(ret, SOFTBUS_OK);
1068     ret = DiscRecoverySubscribe();
1069     EXPECT_TRUE(ret != 0);
1070     ret = StopRefreshLNN(g_pkgName, testInfo.subscribeId);
1071 
1072     ret = RefreshLNN(g_pkgName, &testInfo, &g_refreshCb);
1073     EXPECT_EQ(ret, SOFTBUS_OK);
1074     ret = StopRefreshLNN(g_pkgName, testInfo.subscribeId);
1075     ret = DiscRecoverySubscribe();
1076     EXPECT_EQ(ret, SOFTBUS_OK);
1077 }
1078 } // namespace OHOS
1079