1 /*
2 * Copyright (c) 2022-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 <gtest/gtest.h>
17 #include <securec.h>
18 #include <unistd.h>
19
20 #include "disc_coap.h"
21 #include "disc_manager.h"
22 #include "disc_nstackx_adapter.h"
23 #include "softbus_adapter_mem.h"
24 #include "softbus_error_code.h"
25
26 using namespace testing::ext;
27 namespace OHOS {
28
29 static constexpr uint32_t DDMP_CAPABILITY = 64;
30 static constexpr uint32_t OSD_CAPABILITY = 128;
31
32 static DiscoveryFuncInterface *g_discCoapFuncInterface = nullptr;
33
34 class DiscCoapTest : public testing::Test {
35 public:
DiscCoapTest()36 DiscCoapTest()
37 {}
~DiscCoapTest()38 ~DiscCoapTest()
39 {}
40 static void SetUpTestCase(void);
41 static void TearDownTestCase(void);
SetUp()42 void SetUp() override {}
TearDown()43 void TearDown() override {}
44 };
45
SetUpTestCase(void)46 void DiscCoapTest::SetUpTestCase(void)
47 {}
48
TearDownTestCase(void)49 void DiscCoapTest::TearDownTestCase(void)
50 {}
51
52 static DiscInnerCallback g_discInnerCb = {
53 .OnDeviceFound = nullptr
54 };
55
56 static PublishOption g_testPubOption = {
57 .freq = LOW,
58 .capabilityBitmap = {DDMP_CAPABILITY},
59 .capabilityData = nullptr,
60 .dataLen = 0,
61 .ranging = false
62 };
63
64 static SubscribeOption g_testSubOption = {
65 .freq = LOW,
66 .isSameAccount = false,
67 .isWakeRemote = false,
68 .capabilityBitmap = {OSD_CAPABILITY},
69 .capabilityData = nullptr,
70 .dataLen = 0
71 };
72
73 /*
74 * @tc.name: TestCoapPublish001
75 * @tc.desc: Test DiscCoapPublish and DiscCoapUnpublish should return SOFTBUS_INVALID_PARAM when given nullptr,
76 * should return SOFTBUS_OK when given valid PublishOption
77 * @tc.type: FUNC
78 * @tc.require:
79 */
80 HWTEST_F(DiscCoapTest, TestCoapPublish001, TestSize.Level1)
81 {
82 g_discCoapFuncInterface = DiscCoapInit(&g_discInnerCb);
83 ASSERT_NE(g_discCoapFuncInterface, nullptr);
84 int32_t ret = g_discCoapFuncInterface->Publish(nullptr);
85 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
86 ret = g_discCoapFuncInterface->Unpublish(nullptr);
87 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
88
89 ret = g_discCoapFuncInterface->Publish(&g_testPubOption);
90 EXPECT_EQ(ret, SOFTBUS_DISCOVER_COAP_START_PUBLISH_FAIL);
91 ret = g_discCoapFuncInterface->Unpublish(&g_testPubOption);
92 EXPECT_EQ(ret, SOFTBUS_OK);
93
94 g_testPubOption.ranging = true;
95 ret = g_discCoapFuncInterface->Publish(&g_testPubOption);
96 g_testPubOption.ranging = false;
97 EXPECT_EQ(ret, SOFTBUS_DISCOVER_COAP_START_PUBLISH_FAIL);
98 ret = g_discCoapFuncInterface->Unpublish(&g_testPubOption);
99 EXPECT_EQ(ret, SOFTBUS_OK);
100
101 DiscCoapDeinit();
102 g_discCoapFuncInterface = nullptr;
103 }
104
105 /*
106 * @tc.name: TestCoapPublish002
107 * @tc.desc: Test DiscCoapPublish and DiscCoapUnpublish should return
108 * SOFTBUS_INVALID_PARAM when given nullptr g_publishMgr
109 * @tc.type: FUNC
110 * @tc.require:
111 */
112 HWTEST_F(DiscCoapTest, TestCoapPublish002, TestSize.Level1)
113 {
114 g_discCoapFuncInterface = DiscCoapInit(&g_discInnerCb);
115 ASSERT_NE(g_discCoapFuncInterface, nullptr);
116 DiscoveryFuncInterface *tmp = DiscCoapInit(nullptr);
117 EXPECT_EQ(tmp, nullptr);
118 int32_t ret = g_discCoapFuncInterface->Publish(&g_testPubOption);
119 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
120 ret = g_discCoapFuncInterface->Unpublish(&g_testPubOption);
121 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
122
123 DiscCoapDeinit();
124 g_discCoapFuncInterface = nullptr;
125 }
126
127 /*
128 * @tc.name: TestCoapPublish003
129 * @tc.desc: Test DiscCoapPublish and DiscCoapUnpublish should return
130 * not SOFTBUS_OK when given invalid PublishOption.freq
131 * @tc.type: FUNC
132 * @tc.require:
133 */
134 HWTEST_F(DiscCoapTest, TestCoapPublish003, TestSize.Level1)
135 {
136 g_discCoapFuncInterface = DiscCoapInit(&g_discInnerCb);
137 ASSERT_NE(g_discCoapFuncInterface, nullptr);
138
139 g_testPubOption.freq = LOW - 1;
140 int32_t ret = g_discCoapFuncInterface->Publish(&g_testPubOption);
141 EXPECT_NE(ret, SOFTBUS_OK);
142 ret = g_discCoapFuncInterface->Unpublish(&g_testPubOption);
143 EXPECT_NE(ret, SOFTBUS_OK);
144 g_testPubOption.freq = FREQ_BUTT + 1;
145 ret = g_discCoapFuncInterface->Publish(&g_testPubOption);
146 EXPECT_NE(ret, SOFTBUS_OK);
147 ret = g_discCoapFuncInterface->Unpublish(&g_testPubOption);
148 EXPECT_NE(ret, SOFTBUS_OK);
149
150 g_testPubOption.freq = LOW;
151 ret = g_discCoapFuncInterface->Publish(&g_testPubOption);
152 EXPECT_EQ(ret, SOFTBUS_DISCOVER_COAP_START_PUBLISH_FAIL);
153 ret = g_discCoapFuncInterface->Unpublish(&g_testPubOption);
154 EXPECT_EQ(ret, SOFTBUS_OK);
155
156 DiscCoapDeinit();
157 g_discCoapFuncInterface = nullptr;
158 }
159
160 /*
161 * @tc.name: TestCoapPublish004
162 * @tc.desc: Test DiscCoapPublish and DiscCoapUnpublish should return
163 * SOFTBUS_DISCOVER_COAP_START_PUBLISH_FAIL when given NSTACKX_INIT_STATE_START g_nstackInitState,
164 * should not return SOFTBUS_OK when given capabilityBitmap {0} and NSTACKX_INIT_STATE_START g_nstackInitState
165 * @tc.type: FUNC
166 * @tc.require:
167 */
168 HWTEST_F(DiscCoapTest, TestCoapPublish004, TestSize.Level1)
169 {
170 g_discCoapFuncInterface = DiscCoapInit(&g_discInnerCb);
171 ASSERT_NE(g_discCoapFuncInterface, nullptr);
172 int32_t ret = DiscNstackxInit();
173 EXPECT_EQ(ret, SOFTBUS_OK);
174
175 ret = g_discCoapFuncInterface->Publish(&g_testPubOption);
176 EXPECT_EQ(ret, SOFTBUS_DISCOVER_COAP_START_PUBLISH_FAIL);
177 ret = g_discCoapFuncInterface->Unpublish(&g_testPubOption);
178 EXPECT_EQ(ret, SOFTBUS_OK);
179
180 DiscNstackxDeinit();
181 ret = g_discCoapFuncInterface->Publish(&g_testPubOption);
182 EXPECT_EQ(ret, SOFTBUS_DISCOVER_COAP_START_PUBLISH_FAIL);
183 ret = g_discCoapFuncInterface->Unpublish(&g_testPubOption);
184 EXPECT_EQ(ret, SOFTBUS_DISCOVER_COAP_REGISTER_CAP_FAIL);
185
186 g_testPubOption.capabilityBitmap[0] = 0;
187 ret = g_discCoapFuncInterface->Publish(&g_testPubOption);
188 EXPECT_EQ(ret, SOFTBUS_DISCOVER_COAP_START_PUBLISH_FAIL);
189 ret = g_discCoapFuncInterface->Unpublish(&g_testPubOption);
190 EXPECT_EQ(ret, SOFTBUS_DISCOVER_COAP_REGISTER_CAP_FAIL);
191
192 DiscCoapDeinit();
193 g_discCoapFuncInterface = nullptr;
194 g_testPubOption.capabilityBitmap[0] = DDMP_CAPABILITY;
195 }
196
197 /*
198 * @tc.name: TestCoapStartScan001
199 * @tc.desc: test DiscCoapStartScan and DiscCoapStopScan should return SOFTBUS_INVALID_PARAM when given nullptr,
200 * should return SOFTBUS_OK when given valid PublishOption
201 * @tc.type: FUNC
202 * @tc.require:
203 */
204 HWTEST_F(DiscCoapTest, TestCoapStartScan001, TestSize.Level1)
205 {
206 g_discCoapFuncInterface = DiscCoapInit(&g_discInnerCb);
207 ASSERT_NE(g_discCoapFuncInterface, nullptr);
208 int32_t ret = g_discCoapFuncInterface->StartScan(nullptr);
209 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
210 ret = g_discCoapFuncInterface->StopScan(nullptr);
211 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
212
213 ret = g_discCoapFuncInterface->StartScan(&g_testPubOption);
214 EXPECT_EQ(ret, SOFTBUS_OK);
215 ret = g_discCoapFuncInterface->StopScan(&g_testPubOption);
216 EXPECT_EQ(ret, SOFTBUS_OK);
217
218 g_testPubOption.ranging = true;
219 ret = g_discCoapFuncInterface->StartScan(&g_testPubOption);
220 g_testPubOption.ranging = false;
221 EXPECT_EQ(ret, SOFTBUS_OK);
222 ret = g_discCoapFuncInterface->StopScan(&g_testPubOption);
223 EXPECT_EQ(ret, SOFTBUS_OK);
224
225 DiscCoapDeinit();
226 g_discCoapFuncInterface = nullptr;
227 }
228
229 /*
230 * @tc.name: TestCoapStartScan002
231 * @tc.desc: Test DiscCoapStartScan and DiscCoapStopScan should return
232 * SOFTBUS_INVALID_PARAM when given nullptr g_publishMgr
233 * @tc.type: FUNC
234 * @tc.require:
235 */
236 HWTEST_F(DiscCoapTest, TestCoapStartScan002, TestSize.Level1)
237 {
238 g_discCoapFuncInterface = DiscCoapInit(&g_discInnerCb);
239 ASSERT_NE(g_discCoapFuncInterface, nullptr);
240 DiscoveryFuncInterface *tmp = DiscCoapInit(nullptr);
241 EXPECT_EQ(tmp, nullptr);
242 int32_t ret = g_discCoapFuncInterface->StartScan(&g_testPubOption);
243 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
244 ret = g_discCoapFuncInterface->StopScan(&g_testPubOption);
245 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
246
247 DiscCoapDeinit();
248 g_discCoapFuncInterface = nullptr;
249 }
250
251 /*
252 * @tc.name: TestCoapStartScan003
253 * @tc.desc: Test DiscCoapStartScan and DiscCoapStopScan when should return
254 * SOFTBUS_DISCOVER_COAP_START_PUBLISH_FAIL when given NSTACKX_INIT_STATE_START g_nstackInitState,
255 * should not return SOFTBUS_OK when given capabilityBitmap {0} and NSTACKX_INIT_STATE_START g_nstackInitState
256 * @tc.type: FUNC
257 * @tc.require:
258 */
259 HWTEST_F(DiscCoapTest, TestCoapStartScan003, TestSize.Level1)
260 {
261 g_discCoapFuncInterface = DiscCoapInit(&g_discInnerCb);
262 ASSERT_NE(g_discCoapFuncInterface, nullptr);
263 int32_t ret = DiscNstackxInit();
264 EXPECT_EQ(ret, SOFTBUS_OK);
265
266 ret = g_discCoapFuncInterface->StartScan(&g_testPubOption);
267 EXPECT_EQ(ret, SOFTBUS_OK);
268 ret = g_discCoapFuncInterface->StopScan(&g_testPubOption);
269 EXPECT_EQ(ret, SOFTBUS_OK);
270
271 DiscNstackxDeinit();
272 ret = g_discCoapFuncInterface->StartScan(&g_testPubOption);
273 EXPECT_EQ(ret, SOFTBUS_DISCOVER_COAP_START_PUBLISH_FAIL);
274 ret = g_discCoapFuncInterface->StopScan(&g_testPubOption);
275 EXPECT_EQ(ret, SOFTBUS_DISCOVER_COAP_REGISTER_CAP_FAIL);
276
277 g_testPubOption.capabilityBitmap[0] = 0;
278 ret = g_discCoapFuncInterface->StartScan(&g_testPubOption);
279 EXPECT_EQ(ret, SOFTBUS_DISCOVER_COAP_START_PUBLISH_FAIL);
280 ret = g_discCoapFuncInterface->StopScan(&g_testPubOption);
281 EXPECT_EQ(ret, SOFTBUS_DISCOVER_COAP_REGISTER_CAP_FAIL);
282
283 DiscCoapDeinit();
284 g_discCoapFuncInterface = nullptr;
285 g_testPubOption.capabilityBitmap[0] = DDMP_CAPABILITY;
286 }
287
288 /*
289 * @tc.name: TestCoapStartAdvertise001
290 * @tc.desc: Test DiscCoapStartAdvertise and DiscCoapStopAdvertise
291 * should return SOFTBUS_INVALID_PARAM when given nullptr,
292 * should return SOFTBUS_OK when given valid SubscribeOption
293 * @tc.type: FUNC
294 * @tc.require:
295 */
296 HWTEST_F(DiscCoapTest, TestCoapStartAdvertise001, TestSize.Level1)
297 {
298 g_discCoapFuncInterface = DiscCoapInit(&g_discInnerCb);
299 ASSERT_NE(g_discCoapFuncInterface, nullptr);
300 int32_t ret = g_discCoapFuncInterface->StartAdvertise(nullptr);
301 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
302 ret = g_discCoapFuncInterface->StopAdvertise(nullptr);
303 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
304
305 ret = g_discCoapFuncInterface->StartAdvertise(&g_testSubOption);
306 EXPECT_EQ(ret, SOFTBUS_DISCOVER_COAP_START_DISCOVER_FAIL);
307 ret = g_discCoapFuncInterface->StopAdvertise(&g_testSubOption);
308 EXPECT_EQ(ret, SOFTBUS_OK);
309
310 DiscCoapDeinit();
311 g_discCoapFuncInterface = nullptr;
312 }
313
314 /*
315 * @tc.name: TestCoapStartAdvertise002
316 * @tc.desc: Test DiscCoapStartAdvertise and DiscCoapStopAdvertise should return
317 * SOFTBUS_INVALID_PARAM when given nullptr g_publishMgr
318 * @tc.type: FUNC
319 * @tc.require:
320 */
321 HWTEST_F(DiscCoapTest, TestCoapStartAdvertise002, TestSize.Level1)
322 {
323 g_discCoapFuncInterface = DiscCoapInit(&g_discInnerCb);
324 ASSERT_NE(g_discCoapFuncInterface, nullptr);
325 DiscoveryFuncInterface *tmp = DiscCoapInit(nullptr);
326 EXPECT_EQ(tmp, nullptr);
327 int32_t ret = g_discCoapFuncInterface->StartAdvertise(&g_testSubOption);
328 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
329 ret = g_discCoapFuncInterface->StopAdvertise(&g_testSubOption);
330 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
331
332 DiscCoapDeinit();
333 g_discCoapFuncInterface = nullptr;
334 }
335
336 /*
337 * @tc.name: TestCoapStartAdvertise003
338 * @tc.desc: Test DiscCoapStartAdvertise and DiscCoapStopAdvertise should return
339 * not SOFTBUS_OK when given invalid SubscribeOption.freq,
340 * should return not SOFTBUS_OK when given invalid SubscribeOption.freq
341 * @tc.type: FUNC
342 * @tc.require:
343 */
344 HWTEST_F(DiscCoapTest, TestCoapStartAdvertise003, TestSize.Level1)
345 {
346 g_discCoapFuncInterface = DiscCoapInit(&g_discInnerCb);
347 ASSERT_NE(g_discCoapFuncInterface, nullptr);
348
349 g_testSubOption.freq = LOW - 1;
350 int32_t ret = g_discCoapFuncInterface->StartAdvertise(&g_testSubOption);
351 EXPECT_NE(ret, SOFTBUS_OK);
352 ret = g_discCoapFuncInterface->StopAdvertise(&g_testSubOption);
353 EXPECT_NE(ret, SOFTBUS_OK);
354 g_testSubOption.freq = FREQ_BUTT + 1;
355 ret = g_discCoapFuncInterface->StartAdvertise(&g_testSubOption);
356 EXPECT_NE(ret, SOFTBUS_OK);
357 ret = g_discCoapFuncInterface->StopAdvertise(&g_testSubOption);
358 EXPECT_NE(ret, SOFTBUS_OK);
359
360 g_testSubOption.freq = LOW;
361 ret = g_discCoapFuncInterface->StartAdvertise(&g_testSubOption);
362 EXPECT_EQ(ret, SOFTBUS_DISCOVER_COAP_START_DISCOVER_FAIL);
363 ret = g_discCoapFuncInterface->StopAdvertise(&g_testSubOption);
364 EXPECT_EQ(ret, SOFTBUS_OK);
365
366 DiscCoapDeinit();
367 g_discCoapFuncInterface = nullptr;
368 }
369
370 /*
371 * @tc.name: TestCoapStartAdvertise004
372 * @tc.desc: Test DiscCoapStartAdvertise and DiscCoapStopAdvertise should return
373 * SOFTBUS_DISCOVER_COAP_SET_FILTER_CAP_FAIL when given NSTACKX_INIT_STATE_START g_nstackInitState,
374 * should return SOFTBUS_DISCOVER_COAP_STOP_DISCOVER_FAIL when given capabilityBitmap {0} and
375 * NSTACKX_INIT_STATE_START g_nstackInitState
376 * @tc.type: FUNC
377 * @tc.require:
378 */
379 HWTEST_F(DiscCoapTest, TestCoapStartAdvertise004, TestSize.Level1)
380 {
381 g_discCoapFuncInterface = DiscCoapInit(&g_discInnerCb);
382 ASSERT_NE(g_discCoapFuncInterface, nullptr);
383 int32_t ret = DiscNstackxInit();
384 EXPECT_EQ(ret, SOFTBUS_OK);
385
386 ret = g_discCoapFuncInterface->StartAdvertise(&g_testSubOption);
387 EXPECT_EQ(ret, SOFTBUS_DISCOVER_COAP_START_DISCOVER_FAIL);
388 ret = g_discCoapFuncInterface->StopAdvertise(&g_testSubOption);
389 EXPECT_EQ(ret, SOFTBUS_OK);
390
391 DiscNstackxDeinit();
392 ret = g_discCoapFuncInterface->StartAdvertise(&g_testSubOption);
393 EXPECT_EQ(ret, SOFTBUS_DISCOVER_COAP_SET_FILTER_CAP_FAIL);
394 ret = g_discCoapFuncInterface->StopAdvertise(&g_testSubOption);
395 EXPECT_EQ(ret, SOFTBUS_DISCOVER_COAP_SET_FILTER_CAP_FAIL);
396
397 g_testSubOption.capabilityBitmap[0] = 0;
398 ret = g_discCoapFuncInterface->StartAdvertise(&g_testSubOption);
399 EXPECT_EQ(ret, SOFTBUS_DISCOVER_COAP_STOP_DISCOVER_FAIL);
400 ret = g_discCoapFuncInterface->StopAdvertise(&g_testSubOption);
401 EXPECT_EQ(ret, SOFTBUS_DISCOVER_COAP_STOP_DISCOVER_FAIL);
402
403 DiscCoapDeinit();
404 g_discCoapFuncInterface = nullptr;
405 g_testSubOption.capabilityBitmap[0] = OSD_CAPABILITY;
406 }
407
408 /*
409 * @tc.name: TestCoapSubscribe001
410 * @tc.desc: test DiscCoapSubscribe and DiscCoapUnsubscribe should return SOFTBUS_INVALID_PARAM when given nullptr,
411 * should return SOFTBUS_OK when given valid SubscribeOption
412 * @tc.type: FUNC
413 * @tc.require:
414 */
415 HWTEST_F(DiscCoapTest, TestCoapSubscribe001, TestSize.Level1)
416 {
417 g_discCoapFuncInterface = DiscCoapInit(&g_discInnerCb);
418 ASSERT_NE(g_discCoapFuncInterface, nullptr);
419 int32_t ret = g_discCoapFuncInterface->Subscribe(nullptr);
420 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
421 ret = g_discCoapFuncInterface->Unsubscribe(nullptr);
422 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
423
424 ret = g_discCoapFuncInterface->Subscribe(&g_testSubOption);
425 EXPECT_EQ(ret, SOFTBUS_OK);
426 ret = g_discCoapFuncInterface->Unsubscribe(&g_testSubOption);
427 EXPECT_EQ(ret, SOFTBUS_OK);
428
429 DiscCoapDeinit();
430 g_discCoapFuncInterface = nullptr;
431 }
432
433 /*
434 * @tc.name: TestCoapSubscribe002
435 * @tc.desc: Test DiscCoapSubscribe and DiscCoapUnsubscribe should return
436 * SOFTBUS_INVALID_PARAM when given nullptr g_publishMgr
437 * @tc.type: FUNC
438 * @tc.require:
439 */
440 HWTEST_F(DiscCoapTest, TestCoapSubscribe002, TestSize.Level1)
441 {
442 g_discCoapFuncInterface = DiscCoapInit(&g_discInnerCb);
443 ASSERT_NE(g_discCoapFuncInterface, nullptr);
444 DiscoveryFuncInterface *tmp = DiscCoapInit(nullptr);
445 EXPECT_EQ(tmp, nullptr);
446 int32_t ret = g_discCoapFuncInterface->Subscribe(&g_testSubOption);
447 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
448 ret = g_discCoapFuncInterface->Unsubscribe(&g_testSubOption);
449 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
450
451 DiscCoapDeinit();
452 g_discCoapFuncInterface = nullptr;
453 }
454
455 /*
456 * @tc.name: TestCoapSubscribe003
457 * @tc.desc: Test DiscCoapSubscribe and DiscCoapUnsubscribe should return
458 * SOFTBUS_DISCOVER_COAP_SET_FILTER_CAP_FAIL when given NSTACKX_INIT_STATE_START g_nstackInitState,
459 * should return SOFTBUS_OK when given capabilityBitmap {0} and NSTACKX_INIT_STATE_START g_nstackInitState
460 * @tc.type: FUNC
461 * @tc.require:
462 */
463 HWTEST_F(DiscCoapTest, TestCoapSubscribe003, TestSize.Level1)
464 {
465 g_discCoapFuncInterface = DiscCoapInit(&g_discInnerCb);
466 ASSERT_NE(g_discCoapFuncInterface, nullptr);
467 int32_t ret = DiscNstackxInit();
468 EXPECT_EQ(ret, SOFTBUS_OK);
469
470 ret = g_discCoapFuncInterface->Subscribe(&g_testSubOption);
471 EXPECT_EQ(ret, SOFTBUS_OK);
472 ret = g_discCoapFuncInterface->Unsubscribe(&g_testSubOption);
473 EXPECT_EQ(ret, SOFTBUS_OK);
474
475 DiscNstackxDeinit();
476 ret = g_discCoapFuncInterface->Subscribe(&g_testSubOption);
477 EXPECT_EQ(ret, SOFTBUS_DISCOVER_COAP_SET_FILTER_CAP_FAIL);
478 ret = g_discCoapFuncInterface->Unsubscribe(&g_testSubOption);
479 EXPECT_EQ(ret, SOFTBUS_DISCOVER_COAP_SET_FILTER_CAP_FAIL);
480
481 g_testSubOption.capabilityBitmap[0] = 0;
482 ret = g_discCoapFuncInterface->Subscribe(&g_testSubOption);
483 EXPECT_EQ(ret, SOFTBUS_OK);
484 ret = g_discCoapFuncInterface->Unsubscribe(&g_testSubOption);
485 EXPECT_EQ(ret, SOFTBUS_OK);
486
487 DiscCoapDeinit();
488 g_discCoapFuncInterface = nullptr;
489 g_testSubOption.capabilityBitmap[0] = OSD_CAPABILITY;
490 }
491
492 /*
493 * @tc.name: TestCoapLinkStatusChanged001
494 * @tc.desc: Test DiscCoapLinkStatusChanged should return SOFTBUS_OK when given LINK_STATUS_UP,
495 * should return SOFTBUS_OK when given LINK_STATUS_DOWN LinkStatus
496 * @tc.type: FUNC
497 * @tc.require:
498 */
499 HWTEST_F(DiscCoapTest, testCoapLinkStatusChanged001, TestSize.Level1)
500 {
501 g_discCoapFuncInterface = DiscCoapInit(&g_discInnerCb);
502 ASSERT_NE(g_discCoapFuncInterface, nullptr);
503 int32_t ret = g_discCoapFuncInterface->StartAdvertise(&g_testSubOption);
504 EXPECT_EQ(ret, SOFTBUS_DISCOVER_COAP_START_DISCOVER_FAIL);
505 ret = g_discCoapFuncInterface->StopAdvertise(&g_testSubOption);
506 EXPECT_EQ(ret, SOFTBUS_OK);
507
508 g_discCoapFuncInterface->LinkStatusChanged(LINK_STATUS_UP);
509 ret = g_discCoapFuncInterface->StartAdvertise(&g_testSubOption);
510 EXPECT_EQ(ret, SOFTBUS_DISCOVER_COAP_START_DISCOVER_FAIL);
511 ret = g_discCoapFuncInterface->StopAdvertise(&g_testSubOption);
512 EXPECT_EQ(ret, SOFTBUS_OK);
513
514 g_discCoapFuncInterface->LinkStatusChanged(LINK_STATUS_DOWN);
515 ret = g_discCoapFuncInterface->StartAdvertise(&g_testSubOption);
516 EXPECT_EQ(ret, SOFTBUS_DISCOVER_COAP_START_DISCOVER_FAIL);
517 ret = g_discCoapFuncInterface->StopAdvertise(&g_testSubOption);
518 EXPECT_EQ(ret, SOFTBUS_OK);
519
520 DiscCoapDeinit();
521 g_discCoapFuncInterface = nullptr;
522 }
523
524 /*
525 * @tc.name: TestCoapUpdateLocalDevInfo001
526 * @tc.desc: Test DiscCoapUpdateLocalDevInfo should return SOFTBUS_OK when given TYPE_LOCAL_DEVICE_NAME,
527 * should return SOFTBUS_OK when given TYPE_ACCOUNT InfoTypeChanged
528 * @tc.type: FUNC
529 * @tc.require:
530 */
531 HWTEST_F(DiscCoapTest, testCoapUpdateLocalDevInfo001, TestSize.Level1)
532 {
533 g_discCoapFuncInterface = DiscCoapInit(&g_discInnerCb);
534 ASSERT_NE(g_discCoapFuncInterface, nullptr);
535 int32_t ret = g_discCoapFuncInterface->StartAdvertise(&g_testSubOption);
536 EXPECT_EQ(ret, SOFTBUS_DISCOVER_COAP_START_DISCOVER_FAIL);
537 ret = g_discCoapFuncInterface->StopAdvertise(&g_testSubOption);
538 EXPECT_EQ(ret, SOFTBUS_OK);
539
540 g_discCoapFuncInterface->UpdateLocalDeviceInfo(TYPE_LOCAL_DEVICE_NAME);
541 ret = g_discCoapFuncInterface->StartAdvertise(&g_testSubOption);
542 EXPECT_EQ(ret, SOFTBUS_DISCOVER_COAP_START_DISCOVER_FAIL);
543 ret = g_discCoapFuncInterface->StopAdvertise(&g_testSubOption);
544 EXPECT_EQ(ret, SOFTBUS_OK);
545
546 g_discCoapFuncInterface->UpdateLocalDeviceInfo(TYPE_ACCOUNT);
547 ret = g_discCoapFuncInterface->StartAdvertise(&g_testSubOption);
548 EXPECT_EQ(ret, SOFTBUS_DISCOVER_COAP_START_DISCOVER_FAIL);
549 ret = g_discCoapFuncInterface->StopAdvertise(&g_testSubOption);
550 EXPECT_EQ(ret, SOFTBUS_OK);
551
552 DiscCoapDeinit();
553 g_discCoapFuncInterface = nullptr;
554 }
555 } // namespace OHOS