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