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