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 int32_t g_subscribeId = 0;
32 static int32_t 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 SetAccessTokenPermission("discTest");
57 }
58
TearDownTestCase(void)59 void DiscSdkTest::TearDownTestCase(void)
60 {}
61
GetSubscribeId(void)62 static int32_t GetSubscribeId(void)
63 {
64 g_subscribeId++;
65 return g_subscribeId;
66 }
67
GetPublishId(void)68 static int32_t 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(int32_t publishId,PublishResult reason)158 static void TestOnPublishResult(int32_t 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)(COAP1);
515 ret = RefreshLNN(g_pkgName, &testInfo, &g_refreshCb);
516 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
517 testInfo.medium = (ExchangeMedium)(USB);
518 testInfo.mode = DISCOVER_MODE_ACTIVE;
519 ret = RefreshLNN(g_pkgName, &testInfo, &g_refreshCb);
520 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
521 testInfo.medium = (ExchangeMedium)(AUTO - 1);
522 ret = RefreshLNN(g_pkgName, &testInfo, &g_refreshCb);
523 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
524 testInfo.medium = COAP;
525
526 testInfo.freq = (ExchangeFreq)(FREQ_BUTT);
527 ret = RefreshLNN(g_pkgName, &testInfo, &g_refreshCb);
528 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
529 testInfo.freq = (ExchangeFreq)(LOW - 1);
530 ret = RefreshLNN(g_pkgName, &testInfo, &g_refreshCb);
531 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
532 testInfo.freq = LOW;
533
534 testInfo.capabilityData = nullptr;
535 ret = RefreshLNN(g_pkgName, &testInfo, &g_refreshCb);
536 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
537 testInfo.capabilityData = (unsigned char *)"capdata1";
538
539 testInfo.dataLen = ERRO_CAPDATA_LEN;
540 ret = RefreshLNN(g_pkgName, &testInfo, &g_refreshCb);
541 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
542 }
543
544 /**
545 * @tc.name: RefreshLNNTest004
546 * @tc.desc: Verify the RefreshLNN normal case.
547 * @tc.type: FUNC
548 * @tc.require:
549 */
550 HWTEST_F(DiscSdkTest, RefreshLNNTest004, TestSize.Level1)
551 {
552 g_sInfo.subscribeId = GetSubscribeId();
553 int32_t ret = RefreshLNN(g_pkgName, &g_sInfo, &g_refreshCb);
554 EXPECT_EQ(ret, SOFTBUS_OK);
555 ret = StopRefreshLNN(g_pkgName, g_sInfo.subscribeId);
556
557 g_sInfo1.subscribeId = GetSubscribeId();
558 ret = RefreshLNN(g_pkgName, &g_sInfo1, &g_refreshCb);
559 EXPECT_EQ(ret, SOFTBUS_OK);
560 ret = StopRefreshLNN(g_pkgName, g_sInfo1.subscribeId);
561
562 g_sInfo1.subscribeId = GetSubscribeId();
563 ret = RefreshLNN(g_pkgName_1, &g_sInfo1, &g_refreshCb);
564 EXPECT_EQ(ret, SOFTBUS_OK);
565 ret = StopRefreshLNN(g_pkgName, g_sInfo1.subscribeId);
566 }
567
568 /**
569 * @tc.name: RefreshLNNTest005
570 * @tc.desc: Test different freq with passive CoAP discovery.
571 * @tc.type: FUNC
572 * @tc.require: The RefreshLNN and StopRefreshLNN operates normally.
573 */
574 HWTEST_F(DiscSdkTest, RefreshLNNTest005, TestSize.Level1)
575 {
576 g_subscribeInfo.subscribeId = GetSubscribeId();
577 g_subscribeInfo.mode = DISCOVER_MODE_PASSIVE;
578 g_subscribeInfo.medium = COAP;
579
580 int32_t ret = RefreshLNN(g_pkgName, &g_subscribeInfo, &g_refreshCb);
581 EXPECT_EQ(ret, SOFTBUS_OK);
582 ret = StopRefreshLNN(g_pkgName, g_subscribeInfo.subscribeId);
583 EXPECT_EQ(ret, SOFTBUS_OK);
584
585 g_subscribeInfo.freq = MID;
586 ret = RefreshLNN(g_pkgName, &g_subscribeInfo, &g_refreshCb);
587 EXPECT_EQ(ret, SOFTBUS_OK);
588 ret = StopRefreshLNN(g_pkgName, g_subscribeInfo.subscribeId);
589 EXPECT_EQ(ret, SOFTBUS_OK);
590
591 g_subscribeInfo.freq = HIGH;
592 ret = RefreshLNN(g_pkgName, &g_subscribeInfo, &g_refreshCb);
593 EXPECT_EQ(ret, SOFTBUS_OK);
594 ret = StopRefreshLNN(g_pkgName, g_subscribeInfo.subscribeId);
595 EXPECT_EQ(ret, SOFTBUS_OK);
596
597 g_subscribeInfo.freq = SUPER_HIGH;
598 ret = RefreshLNN(g_pkgName, &g_subscribeInfo, &g_refreshCb);
599 EXPECT_EQ(ret, SOFTBUS_OK);
600 ret = StopRefreshLNN(g_pkgName, g_subscribeInfo.subscribeId);
601 EXPECT_EQ(ret, SOFTBUS_OK);
602
603 g_subscribeInfo.freq = EXTREME_HIGH;
604 ret = RefreshLNN(g_pkgName, &g_subscribeInfo, &g_refreshCb);
605 EXPECT_EQ(ret, SOFTBUS_OK);
606 ret = StopRefreshLNN(g_pkgName, g_subscribeInfo.subscribeId);
607 EXPECT_EQ(ret, SOFTBUS_OK);
608 }
609
610 /**
611 * @tc.name: RefreshLNNTest006
612 * @tc.desc: Test different freq with passive BLE discovery.
613 * @tc.type: FUNC
614 * @tc.require: The RefreshLNN and StopRefreshLNN operates normally.
615 */
616 HWTEST_F(DiscSdkTest, RefreshLNNTest006, TestSize.Level1)
617 {
618 g_subscribeInfo.subscribeId = GetSubscribeId();
619 g_subscribeInfo.mode = DISCOVER_MODE_PASSIVE;
620 g_subscribeInfo.medium = BLE;
621
622 bool isBtOn = SoftbusTestGetBtStatus();
623 printf("bt status %s\n", isBtOn ? "on" : "off");
624
625 int32_t ret = RefreshLNN(g_pkgName, &g_subscribeInfo, &g_refreshCb);
626 EXPECT_EQ(isBtOn, (ret == SOFTBUS_OK));
627 ret = StopRefreshLNN(g_pkgName, g_subscribeInfo.subscribeId);
628 EXPECT_EQ(isBtOn, (ret == SOFTBUS_OK));
629
630 g_subscribeInfo.freq = MID;
631 ret = RefreshLNN(g_pkgName, &g_subscribeInfo, &g_refreshCb);
632 EXPECT_EQ(isBtOn, (ret == SOFTBUS_OK));
633 ret = StopRefreshLNN(g_pkgName, g_subscribeInfo.subscribeId);
634 EXPECT_EQ(isBtOn, (ret == SOFTBUS_OK));
635
636 g_subscribeInfo.freq = HIGH;
637 ret = RefreshLNN(g_pkgName, &g_subscribeInfo, &g_refreshCb);
638 EXPECT_EQ(isBtOn, (ret == SOFTBUS_OK));
639 ret = StopRefreshLNN(g_pkgName, g_subscribeInfo.subscribeId);
640 EXPECT_EQ(isBtOn, (ret == SOFTBUS_OK));
641
642 g_subscribeInfo.freq = SUPER_HIGH;
643 ret = RefreshLNN(g_pkgName, &g_subscribeInfo, &g_refreshCb);
644 EXPECT_EQ(isBtOn, (ret == SOFTBUS_OK));
645 ret = StopRefreshLNN(g_pkgName, g_subscribeInfo.subscribeId);
646 EXPECT_EQ(isBtOn, (ret == SOFTBUS_OK));
647
648 g_subscribeInfo.freq = EXTREME_HIGH;
649 ret = RefreshLNN(g_pkgName, &g_subscribeInfo, &g_refreshCb);
650 EXPECT_EQ(isBtOn, (ret == SOFTBUS_OK));
651 ret = StopRefreshLNN(g_pkgName, g_subscribeInfo.subscribeId);
652 EXPECT_EQ(isBtOn, (ret == SOFTBUS_OK));
653 }
654
655 /**
656 * @tc.name: RefreshLNNTest007
657 * @tc.desc: Test different capability with passive CoAP discovery.
658 * @tc.type: FUNC
659 * @tc.require: The RefreshLNN and StopRefreshLNN operates normally.
660 */
661 HWTEST_F(DiscSdkTest, RefreshLNNTest007, TestSize.Level1)
662 {
663 g_subscribeInfo.subscribeId = GetSubscribeId();
664 g_subscribeInfo.mode = DISCOVER_MODE_PASSIVE;
665 g_subscribeInfo.medium = COAP;
666
667 int32_t ret = RefreshLNN(g_pkgName, &g_subscribeInfo, &g_refreshCb);
668 EXPECT_EQ(ret, SOFTBUS_OK);
669 ret = StopRefreshLNN(g_pkgName, g_subscribeInfo.subscribeId);
670
671 g_subscribeInfo.capability = "hicall";
672 ret = RefreshLNN(g_pkgName, &g_subscribeInfo, &g_refreshCb);
673 EXPECT_EQ(ret, SOFTBUS_OK);
674 ret = StopRefreshLNN(g_pkgName, g_subscribeInfo.subscribeId);
675
676 g_subscribeInfo.capability = "profile";
677 ret = RefreshLNN(g_pkgName, &g_subscribeInfo, &g_refreshCb);
678 EXPECT_EQ(ret, SOFTBUS_OK);
679 ret = StopRefreshLNN(g_pkgName, g_subscribeInfo.subscribeId);
680
681 g_subscribeInfo.capability = "homevisionPic";
682 ret = RefreshLNN(g_pkgName, &g_subscribeInfo, &g_refreshCb);
683 EXPECT_EQ(ret, SOFTBUS_OK);
684 ret = StopRefreshLNN(g_pkgName, g_subscribeInfo.subscribeId);
685
686 g_subscribeInfo.capability = "castPlus";
687 ret = RefreshLNN(g_pkgName, &g_subscribeInfo, &g_refreshCb);
688 EXPECT_EQ(ret, SOFTBUS_OK);
689 ret = StopRefreshLNN(g_pkgName, g_subscribeInfo.subscribeId);
690
691 g_subscribeInfo.capability = "aaCapability";
692 ret = RefreshLNN(g_pkgName, &g_subscribeInfo, &g_refreshCb);
693 EXPECT_EQ(ret, SOFTBUS_OK);
694 ret = StopRefreshLNN(g_pkgName, g_subscribeInfo.subscribeId);
695
696 g_subscribeInfo.capability = "ddmpCapability";
697 ret = RefreshLNN(g_pkgName, &g_subscribeInfo, &g_refreshCb);
698 EXPECT_EQ(ret, SOFTBUS_OK);
699 ret = StopRefreshLNN(g_pkgName, g_subscribeInfo.subscribeId);
700
701 g_subscribeInfo.capability = "osdCapability";
702 ret = RefreshLNN(g_pkgName, &g_subscribeInfo, &g_refreshCb);
703 EXPECT_EQ(ret, SOFTBUS_OK);
704 ret = StopRefreshLNN(g_pkgName, g_subscribeInfo.subscribeId);
705 }
706
707 /**
708 * @tc.name: RefreshLNNTest008
709 * @tc.desc: Test different capability with passive BLE discovery: dvKit, castPlus, osdCapability
710 * @tc.type: FUNC
711 * @tc.require: The RefreshLNN and StopRefreshLNN operates normally.
712 */
713 HWTEST_F(DiscSdkTest, RefreshLNNTest008, TestSize.Level1)
714 {
715 g_subscribeInfo.subscribeId = GetSubscribeId();
716 g_subscribeInfo.mode = DISCOVER_MODE_PASSIVE;
717 g_subscribeInfo.medium = BLE;
718
719 bool isBtOn = SoftbusTestGetBtStatus();
720 printf("bt status %s\n", isBtOn ? "on" : "off");
721
722 g_subscribeInfo.capability = "dvKit";
723 int32_t ret = RefreshLNN(g_pkgName, &g_subscribeInfo, &g_refreshCb);
724 EXPECT_EQ(isBtOn, (ret == SOFTBUS_OK));
725 ret = StopRefreshLNN(g_pkgName, g_subscribeInfo.subscribeId);
726
727 g_subscribeInfo.capability = "castPlus";
728 ret = RefreshLNN(g_pkgName, &g_subscribeInfo, &g_refreshCb);
729 EXPECT_EQ(isBtOn, (ret == SOFTBUS_OK));
730 ret = StopRefreshLNN(g_pkgName, g_subscribeInfo.subscribeId);
731
732 g_subscribeInfo.capability = "osdCapability";
733 ret = RefreshLNN(g_pkgName, &g_subscribeInfo, &g_refreshCb);
734 EXPECT_EQ(isBtOn, (ret == SOFTBUS_OK));
735 ret = StopRefreshLNN(g_pkgName, g_subscribeInfo.subscribeId);
736 }
737
738 /**
739 * @tc.name: RefreshLNNTest009
740 * @tc.desc: Test usb capability with passive usb discovery
741 * @tc.type: FUNC
742 * @tc.require: The RefreshLNN and StopRefreshLNN operates normally.
743 */
744 HWTEST_F(DiscSdkTest, RefreshLNNTest009, TestSize.Level1)
745 {
746 g_subscribeInfo.subscribeId = GetSubscribeId();
747 g_subscribeInfo.mode = DISCOVER_MODE_PASSIVE;
748 g_subscribeInfo.medium = USB;
749 g_subscribeInfo.capability = "approach";
750
751 int32_t ret = RefreshLNN(g_pkgName, &g_subscribeInfo, &g_refreshCb);
752 EXPECT_NE(ret, SOFTBUS_INVALID_PARAM);
753
754 ret = StopRefreshLNN(g_pkgName, g_subscribeInfo.subscribeId);
755 EXPECT_NE(ret, SOFTBUS_INVALID_PARAM);
756 }
757
758 /**
759 * @tc.name: StopPublishLNNTest001
760 * @tc.desc: Verify StopPublishLNN invalid parameter.
761 * @tc.type: FUNC
762 * @tc.require:
763 */
764 HWTEST_F(DiscSdkTest, StopPublishLNNTest001, TestSize.Level1)
765 {
766 int32_t tmpId = GetPublishId();
767 g_pInfo.publishId = tmpId;
768 PublishLNN(g_pkgName, &g_pInfo, &g_publishCb);
769
770 int32_t ret = StopPublishLNN(nullptr, tmpId);
771 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
772
773 ret = StopPublishLNN(g_erroPkgName, tmpId);
774 EXPECT_NE(ret, SOFTBUS_OK);
775 }
776
777 /**
778 * @tc.name: StopPublishLNNTest002
779 * @tc.desc: Verify PublishLNN and StopPublishLNN normal case.
780 * @tc.type: FUNC
781 * @tc.require:
782 */
783 HWTEST_F(DiscSdkTest, StopPublishLNNTest002, TestSize.Level1)
784 {
785 int32_t tmpId1 = GetPublishId();
786 int32_t tmpId2 = GetPublishId();
787
788 g_pInfo.publishId = tmpId1;
789 PublishLNN(g_pkgName, &g_pInfo, &g_publishCb);
790 g_pInfo1.publishId = tmpId2;
791 PublishLNN(g_pkgName, &g_pInfo1, &g_publishCb);
792
793 int32_t ret = StopPublishLNN(g_pkgName, tmpId1);
794 EXPECT_EQ(ret, SOFTBUS_OK);
795 ret = StopPublishLNN(g_pkgName, tmpId2);
796 EXPECT_EQ(ret, SOFTBUS_OK);
797 }
798
799 /**
800 * @tc.name: StopPublishLNNTest003
801 * @tc.desc: Verify PublishLNN and StopPublishLNN same parameter again.
802 * @tc.type: FUNC
803 * @tc.require:
804 */
805 HWTEST_F(DiscSdkTest, StopPublishLNNTest003, TestSize.Level1)
806 {
807 int32_t tmpId = GetPublishId();
808 g_pInfo.publishId = tmpId;
809 PublishLNN(g_pkgName, &g_pInfo, &g_publishCb);
810
811 int32_t ret = StopPublishLNN(g_pkgName, tmpId);
812 EXPECT_EQ(ret, SOFTBUS_OK);
813 }
814
815 /**
816 * @tc.name: StopPublishLNNTest004
817 * @tc.desc: Test different freq with stop passive CoAP publish.
818 * @tc.type: FUNC
819 * @tc.require: The StopPublishLNN operates normally.
820 */
821 HWTEST_F(DiscSdkTest, StopPublishLNNTest004, TestSize.Level1)
822 {
823 g_publishInfo.publishId = GetPublishId();
824 g_publishInfo.mode = DISCOVER_MODE_PASSIVE;
825 g_publishInfo.medium = COAP;
826
827 PublishLNN(g_pkgName, &g_publishInfo, &g_publishCb);
828 int32_t ret = StopPublishLNN(g_pkgName, g_publishInfo.publishId);
829 EXPECT_EQ(ret, SOFTBUS_OK);
830
831 g_publishInfo.freq = MID;
832 PublishLNN(g_pkgName, &g_publishInfo, &g_publishCb);
833 ret = StopPublishLNN(g_pkgName, g_publishInfo.publishId);
834 EXPECT_EQ(ret, SOFTBUS_OK);
835
836 g_publishInfo.freq = HIGH;
837 PublishLNN(g_pkgName, &g_publishInfo, &g_publishCb);
838 ret = StopPublishLNN(g_pkgName, g_publishInfo.publishId);
839 EXPECT_EQ(ret, SOFTBUS_OK);
840
841 g_publishInfo.freq = SUPER_HIGH;
842 PublishLNN(g_pkgName, &g_publishInfo, &g_publishCb);
843 ret = StopPublishLNN(g_pkgName, g_publishInfo.publishId);
844 EXPECT_EQ(ret, SOFTBUS_OK);
845
846 g_publishInfo.freq = EXTREME_HIGH;
847 PublishLNN(g_pkgName, &g_publishInfo, &g_publishCb);
848 ret = StopPublishLNN(g_pkgName, g_publishInfo.publishId);
849 EXPECT_EQ(ret, SOFTBUS_OK);
850 }
851
852 /**
853 * @tc.name: StopPublishLNNTest005
854 * @tc.desc: Test different freq with stop passive BLE publish.
855 * @tc.type: FUNC
856 * @tc.require: The StopPublishLNN operates normally.
857 */
858 HWTEST_F(DiscSdkTest, StopPublishLNNTest005, TestSize.Level1)
859 {
860 g_publishInfo.publishId = GetPublishId();
861 g_publishInfo.mode = DISCOVER_MODE_PASSIVE;
862 g_publishInfo.medium = BLE;
863
864 bool isBtOn = SoftbusTestGetBtStatus();
865 printf("bt status %s\n", isBtOn ? "on" : "off");
866
867 PublishLNN(g_pkgName, &g_publishInfo, &g_publishCb);
868 int32_t ret = StopPublishLNN(g_pkgName, g_publishInfo.publishId);
869 EXPECT_EQ(isBtOn, (ret == SOFTBUS_OK));
870
871 g_publishInfo.freq = MID;
872 PublishLNN(g_pkgName, &g_publishInfo, &g_publishCb);
873 ret = StopPublishLNN(g_pkgName, g_publishInfo.publishId);
874 EXPECT_EQ(isBtOn, (ret == SOFTBUS_OK));
875
876 g_publishInfo.freq = HIGH;
877 PublishLNN(g_pkgName, &g_publishInfo, &g_publishCb);
878 ret = StopPublishLNN(g_pkgName, g_publishInfo.publishId);
879 EXPECT_EQ(isBtOn, (ret == SOFTBUS_OK));
880
881 g_publishInfo.freq = SUPER_HIGH;
882 PublishLNN(g_pkgName, &g_publishInfo, &g_publishCb);
883 ret = StopPublishLNN(g_pkgName, g_publishInfo.publishId);
884 EXPECT_EQ(isBtOn, (ret == SOFTBUS_OK));
885
886 g_publishInfo.freq = EXTREME_HIGH;
887 PublishLNN(g_pkgName, &g_publishInfo, &g_publishCb);
888 ret = StopPublishLNN(g_pkgName, g_publishInfo.publishId);
889 EXPECT_EQ(isBtOn, (ret == SOFTBUS_OK));
890 }
891
892 /**
893 * @tc.name: StopRefreshLNNTest001
894 * @tc.desc: Verify StopRefreshLNN invalid parameter.
895 * @tc.type: FUNC
896 * @tc.require:
897 */
898 HWTEST_F(DiscSdkTest, StopRefreshLNNTest001, TestSize.Level1)
899 {
900 int32_t tmpId = GetSubscribeId();
901 g_sInfo.subscribeId = tmpId;
902 RefreshLNN(g_pkgName, &g_sInfo, &g_refreshCb);
903
904 int32_t ret = StopRefreshLNN(nullptr, tmpId);
905 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
906 ret = StopRefreshLNN(g_erroPkgName, tmpId);
907 EXPECT_NE(ret, SOFTBUS_OK);
908 }
909
910 /**
911 * @tc.name: StopRefreshLNNTest002
912 * @tc.desc: test under normal conditions.
913 * @tc.type: FUNC
914 * @tc.require:
915 */
916 HWTEST_F(DiscSdkTest, StopRefreshLNNTest002, TestSize.Level1)
917 {
918 int32_t tmpId1 = GetSubscribeId();
919 int32_t tmpId2 = GetSubscribeId();
920
921 g_sInfo.subscribeId = tmpId1;
922 RefreshLNN(g_pkgName, &g_sInfo, &g_refreshCb);
923 g_sInfo1.subscribeId = tmpId2;
924 RefreshLNN(g_pkgName, &g_sInfo1, &g_refreshCb);
925
926 int32_t ret = StopRefreshLNN(g_pkgName, tmpId1);
927 EXPECT_EQ(ret, SOFTBUS_OK);
928 ret = StopRefreshLNN(g_pkgName, tmpId2);
929 EXPECT_EQ(ret, SOFTBUS_OK);
930 }
931
932 /**
933 * @tc.name: StopRefreshLNNTest003
934 * @tc.desc: Verify RefreshLNN and StopRefreshLNN same parameter again.
935 * @tc.type: FUNC
936 * @tc.require:
937 */
938 HWTEST_F(DiscSdkTest, StopRefreshLNNTest003, TestSize.Level1)
939 {
940 int32_t tmpId = GetSubscribeId();
941 g_sInfo.subscribeId = tmpId;
942 RefreshLNN(g_pkgName, &g_sInfo, &g_refreshCb);
943
944 int32_t ret = StopRefreshLNN(g_pkgName, tmpId);
945 EXPECT_EQ(ret, SOFTBUS_OK);
946 }
947
948 /**
949 * @tc.name: StopRefreshLNNTest004
950 * @tc.desc:Test different freq with stop passive CoAP discovery.
951 * @tc.type: FUNC
952 * @tc.require: The StopRefreshLNN operates normally
953 */
954 HWTEST_F(DiscSdkTest, StopRefreshLNNTest004, TestSize.Level1)
955 {
956 g_subscribeInfo.subscribeId = GetSubscribeId();
957 g_subscribeInfo.mode = DISCOVER_MODE_PASSIVE;
958 g_subscribeInfo.medium = COAP;
959 g_subscribeInfo.capability = "osdCapability";
960
961 RefreshLNN(g_pkgName, &g_subscribeInfo, &g_refreshCb);
962 int32_t ret = StopRefreshLNN(g_pkgName, g_subscribeInfo.subscribeId);
963 EXPECT_EQ(ret, SOFTBUS_OK);
964
965 g_subscribeInfo.freq = MID;
966 RefreshLNN(g_pkgName, &g_subscribeInfo, &g_refreshCb);
967 ret = StopRefreshLNN(g_pkgName, g_subscribeInfo.subscribeId);
968 EXPECT_EQ(ret, SOFTBUS_OK);
969
970 g_subscribeInfo.freq = HIGH;
971 RefreshLNN(g_pkgName, &g_subscribeInfo, &g_refreshCb);
972 ret = StopRefreshLNN(g_pkgName, g_subscribeInfo.subscribeId);
973 EXPECT_EQ(ret, SOFTBUS_OK);
974
975 g_subscribeInfo.freq = SUPER_HIGH;
976 RefreshLNN(g_pkgName, &g_subscribeInfo, &g_refreshCb);
977 ret = StopRefreshLNN(g_pkgName, g_subscribeInfo.subscribeId);
978 EXPECT_EQ(ret, SOFTBUS_OK);
979
980 g_subscribeInfo.freq = EXTREME_HIGH;
981 RefreshLNN(g_pkgName, &g_subscribeInfo, &g_refreshCb);
982 ret = StopRefreshLNN(g_pkgName, g_subscribeInfo.subscribeId);
983 EXPECT_EQ(ret, SOFTBUS_OK);
984 }
985
986 /**
987 * @tc.name: StopRefreshLNNTest005
988 * @tc.desc:Test different freq with stop passive BLE discovery.
989 * @tc.type: FUNC
990 * @tc.require: The StopRefreshLNN operates normally
991 */
992 HWTEST_F(DiscSdkTest, StopRefreshLNNTest005, TestSize.Level1)
993 {
994 g_subscribeInfo.subscribeId = GetSubscribeId();
995 g_subscribeInfo.mode = DISCOVER_MODE_PASSIVE;
996 g_subscribeInfo.medium = BLE;
997
998 bool isBtOn = SoftbusTestGetBtStatus();
999 printf("bt status %s\n", isBtOn ? "on" : "off");
1000
1001 RefreshLNN(g_pkgName, &g_subscribeInfo, &g_refreshCb);
1002 int32_t ret = StopRefreshLNN(g_pkgName, g_subscribeInfo.subscribeId);
1003 EXPECT_EQ(isBtOn, (ret == SOFTBUS_OK));
1004
1005 g_subscribeInfo.freq = MID;
1006 RefreshLNN(g_pkgName, &g_subscribeInfo, &g_refreshCb);
1007 ret = StopRefreshLNN(g_pkgName, g_subscribeInfo.subscribeId);
1008 EXPECT_EQ(isBtOn, (ret == SOFTBUS_OK));
1009
1010 g_subscribeInfo.freq = HIGH;
1011 RefreshLNN(g_pkgName, &g_subscribeInfo, &g_refreshCb);
1012 ret = StopRefreshLNN(g_pkgName, g_subscribeInfo.subscribeId);
1013 EXPECT_EQ(isBtOn, (ret == SOFTBUS_OK));
1014
1015 g_subscribeInfo.freq = SUPER_HIGH;
1016 RefreshLNN(g_pkgName, &g_subscribeInfo, &g_refreshCb);
1017 ret = StopRefreshLNN(g_pkgName, g_subscribeInfo.subscribeId);
1018 EXPECT_EQ(isBtOn, (ret == SOFTBUS_OK));
1019
1020 g_subscribeInfo.freq = EXTREME_HIGH;
1021 RefreshLNN(g_pkgName, &g_subscribeInfo, &g_refreshCb);
1022 ret = StopRefreshLNN(g_pkgName, g_subscribeInfo.subscribeId);
1023 EXPECT_EQ(isBtOn, (ret == SOFTBUS_OK));
1024 }
1025
1026 /**
1027 * @tc.name:DiscRecoveryPublishTest01
1028 * @tc.desc: Test recovery publish.
1029 * @tc.in: Test module, Test number, Test levels.
1030 * @tc.out: Zero
1031 * @tc.type: FUNC
1032 * @tc.require:The DiscRecoveryPublish operates normally
1033 */
1034 HWTEST_F(DiscSdkTest, DiscRecoveryPublishTest01, TestSize.Level1)
1035 {
1036 int32_t ret;
1037 PublishInfo testInfo = {
1038 .publishId = GetPublishId(),
1039 .mode = DISCOVER_MODE_PASSIVE,
1040 .medium = COAP,
1041 .freq = LOW,
1042 .capability = "dvKit",
1043 .capabilityData = (unsigned char *)"capdata2",
1044 .dataLen = (unsigned int) strlen("capdata2")
1045 };
1046 BusCenterClientDeinit();
1047 BusCenterClientInit();
1048 ret = DiscRecoveryPublish();
1049 EXPECT_EQ(ret, SOFTBUS_OK);
1050
1051 ret = PublishLNN(g_pkgName, &testInfo, &g_publishCb);
1052 EXPECT_EQ(ret, SOFTBUS_OK);
1053 ret = DiscRecoveryPublish();
1054 EXPECT_TRUE(ret != 0);
1055 ret = StopPublishLNN(g_pkgName, testInfo.publishId);
1056
1057 ret = PublishLNN(g_pkgName, &testInfo, &g_publishCb);
1058 EXPECT_EQ(ret, SOFTBUS_OK);
1059 ret = StopPublishLNN(g_pkgName, testInfo.publishId);
1060 ret = DiscRecoveryPublish();
1061 EXPECT_EQ(ret, SOFTBUS_OK);
1062 }
1063
1064 /**
1065 * @tc.name:DiscRecoverySubscribeTest01
1066 * @tc.desc: Test recovery subscribe.
1067 * @tc.in: Test module, Test number, Test levels.
1068 * @tc.out: Zero
1069 * @tc.type: FUNC
1070 * @tc.require:The DiscRecoverySubscribe operates normally
1071 */
1072 HWTEST_F(DiscSdkTest, DiscRecoverySubscribeTest01, TestSize.Level1)
1073 {
1074 int32_t ret;
1075 SubscribeInfo testInfo = {
1076 .subscribeId = GetSubscribeId(),
1077 .mode = DISCOVER_MODE_PASSIVE,
1078 .medium = AUTO,
1079 .freq = LOW,
1080 .isSameAccount = true,
1081 .isWakeRemote = false,
1082 .capability = "dvKit",
1083 .capabilityData = (unsigned char *)"capdata3",
1084 .dataLen = (unsigned int) strlen("capdata3")
1085 };
1086 BusCenterClientDeinit();
1087 BusCenterClientInit();
1088 ret = DiscRecoverySubscribe();
1089 EXPECT_EQ(ret, SOFTBUS_OK);
1090
1091 ret = RefreshLNN(g_pkgName, &testInfo, &g_refreshCb);
1092 EXPECT_EQ(ret, SOFTBUS_OK);
1093 ret = DiscRecoverySubscribe();
1094 EXPECT_TRUE(ret != 0);
1095 ret = StopRefreshLNN(g_pkgName, testInfo.subscribeId);
1096
1097 ret = RefreshLNN(g_pkgName, &testInfo, &g_refreshCb);
1098 EXPECT_EQ(ret, SOFTBUS_OK);
1099 ret = StopRefreshLNN(g_pkgName, testInfo.subscribeId);
1100 ret = DiscRecoverySubscribe();
1101 EXPECT_EQ(ret, SOFTBUS_OK);
1102 }
1103 } // namespace OHOS