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
28using namespace testing::ext;
29
30namespace OHOS {
31static int32_t g_subscribeId = 0;
32static int32_t g_publishId = 0;
33static const char *g_pkgName = "Softbus_Kits";
34static const char *g_pkgName_1 = "Softbus_Kits_1";
35static const char *g_erroPkgName = "Softbus_Erro_Kits";
36static const char *g_erroPkgName1 = "ErroErroErroErroErroErroErroErroErroErroErroErroErroErroErroErroEErroE";
37
38const int32_t ERRO_CAPDATA_LEN = 514;
39
40class DiscSdkTest : public testing::Test {
41public:
42    DiscSdkTest()
43    {}
44    ~DiscSdkTest()
45    {}
46    static void SetUpTestCase(void);
47    static void TearDownTestCase(void);
48    void SetUp() override
49    {}
50    void TearDown() override
51    {}
52};
53
54void DiscSdkTest::SetUpTestCase(void)
55{
56    SetAceessTokenPermission("discTest");
57}
58
59void DiscSdkTest::TearDownTestCase(void)
60{}
61
62static int32_t GetSubscribeId(void)
63{
64    g_subscribeId++;
65    return g_subscribeId;
66}
67
68static int32_t GetPublishId(void)
69{
70    g_publishId++;
71    return g_publishId;
72}
73
74static 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
86static 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
96static 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
106static 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
118static 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
128static 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
140static void TestDeviceFound(const DeviceInfo *device)
141{
142    (void)device;
143    printf("[client]TestDeviceFound\n");
144}
145
146static void TestOnDiscoverResult(int32_t refreshId, RefreshResult reason)
147{
148    (void)refreshId;
149    (void)reason;
150    printf("[client]TestDiscoverResult\n");
151}
152
153static const IRefreshCallback g_refreshCb = {
154    .OnDeviceFound = TestDeviceFound,
155    .OnDiscoverResult = TestOnDiscoverResult
156};
157
158static void TestOnPublishResult(int32_t publishId, PublishResult reason)
159{
160    (void)publishId;
161    (void)reason;
162    printf("[client]TestPublishResult\n");
163}
164
165static 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 */
175HWTEST_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 */
193HWTEST_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 */
206HWTEST_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 */
259HWTEST_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 */
283HWTEST_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 */
325HWTEST_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 */
370HWTEST_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 */
426HWTEST_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 */
461HWTEST_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 */
479HWTEST_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 */
492HWTEST_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 */
546HWTEST_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 */
570HWTEST_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 */
612HWTEST_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 */
657HWTEST_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 */
709HWTEST_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 */
740HWTEST_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 */
759HWTEST_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 */
781HWTEST_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 */
797HWTEST_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 */
834HWTEST_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 */
874HWTEST_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 */
892HWTEST_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 */
914HWTEST_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 */
930HWTEST_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 */
967HWTEST_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 */
1009HWTEST_F(DiscSdkTest, DiscRecoveryPublishTest01, TestSize.Level1)
1010{
1011    int32_t 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 */
1047HWTEST_F(DiscSdkTest, DiscRecoverySubscribeTest01, TestSize.Level1)
1048{
1049    int32_t 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