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 "bus_center_info_key.h"
21 #include "disc_log.h"
22 #include "disc_manager.h"
23 #include "disc_nstackx_adapter.c"
24 #include "disc_nstackx_adapter.h"
25 #include "lnn_local_net_ledger.h"
26 #include "nstackx.h"
27 #include "nstackx_error.h"
28 #include "softbus_adapter_mem.h"
29 #include "softbus_error_code.h"
30
31 using namespace testing::ext;
32
33 #define NSTACKX_EFAILED (-1)
34 namespace OHOS {
35
36 static bool isDeviceFound = false;
37 class DiscNstackxAdapterTest : public testing::Test {
38 public:
DiscNstackxAdapterTest()39 DiscNstackxAdapterTest() { }
~DiscNstackxAdapterTest()40 ~DiscNstackxAdapterTest() { }
SetUpTestCase()41 static void SetUpTestCase() { }
TearDownTestCase()42 static void TearDownTestCase() { }
SetUp()43 void SetUp() override { }
TearDown()44 void TearDown() override { }
45 };
46
47 static InnerDeviceInfoAddtions g_testAddtions = { .medium = AUTO };
48
OnDeviceFoundTest(const DeviceInfo * device,const InnerDeviceInfoAddtions * additions)49 static void OnDeviceFoundTest(const DeviceInfo *device, const InnerDeviceInfoAddtions *additions)
50 {
51 (void)device;
52 (void)additions;
53 DISC_LOGI(DISC_TEST, "OnDeviceFoundTest in");
54 isDeviceFound = true;
55 g_testAddtions.medium = additions->medium;
56 }
57
58 static DiscInnerCallback g_discInnerCb = { .OnDeviceFound = OnDeviceFoundTest };
59
60 static constexpr uint32_t OSD_CAPABILITY = 128;
61
62 static NSTACKX_DeviceInfo g_testNstackxInfo = { .deviceId = "{UDID:123456789012345}",
63 .deviceName = "OpenHarmonyDevice",
64 .capabilityBitmapNum = 1,
65 .capabilityBitmap = { OSD_CAPABILITY },
66 .deviceType = 0,
67 .mode = DISCOVER_MODE,
68 .update = 1,
69 .reserved = 0,
70 .networkName = "wlan0",
71 .discoveryType = NSTACKX_DISCOVERY_TYPE_ACTIVE,
72 .businessType = NSTACKX_BUSINESS_TYPE_NULL,
73 .reservedInfo = "reserved" };
74
75 /*
76 * @tc.name: TestDiscCoapAdapterInit001
77 * @tc.desc: Test DiscNstackxInit should return SOFTBUS_OK when repeat init
78 * @tc.type: FUNC
79 * @tc.require:
80 */
81 HWTEST_F(DiscNstackxAdapterTest, TestDiscCoapAdapterInit001, TestSize.Level1)
82 {
83 DiscNstackxDeinit();
84 int32_t ret = DiscNstackxInit();
85 ASSERT_EQ(ret, SOFTBUS_OK);
86
87 // repeat init
88 ret = DiscNstackxInit();
89 EXPECT_EQ(ret, SOFTBUS_OK);
90 }
91
92 /*
93 * @tc.name: TestDiscCoapAdapterDeInit001
94 * @tc.desc: Test DiscNstackxInit should return SOFTBUS_OK after repeat deinit
95 * @tc.type: FUNC
96 * @tc.require:
97 */
98 HWTEST_F(DiscNstackxAdapterTest, TestDiscCoapAdapterDeInit001, TestSize.Level1)
99 {
100 DiscNstackxDeinit();
101 DiscNstackxDeinit();
102 int32_t ret = DiscNstackxInit();
103 ASSERT_EQ(ret, SOFTBUS_OK);
104
105 // repeat init
106 ret = DiscNstackxInit();
107 EXPECT_EQ(ret, SOFTBUS_OK);
108
109 DiscNstackxDeinit();
110 }
111
112 /*
113 * @tc.name: TestDiscCoapModifyNstackThread001
114 * @tc.desc: Test start discovery.
115 * @tc.type: FUNC
116 * @tc.require:
117 */
118 HWTEST_F(DiscNstackxAdapterTest, TestDiscCoapModifyNstackThread001, TestSize.Level1)
119 {
120 DiscCoapModifyNstackThread(LINK_STATUS_DOWN);
121 int32_t ret = DiscNstackxInit();
122 ASSERT_EQ(ret, SOFTBUS_OK);
123
124 DiscCoapOption testCoapOption = {
125 .freq = LOW,
126 .mode = ACTIVE_PUBLISH
127 };
128 ret = DiscCoapStartDiscovery(&testCoapOption);
129 EXPECT_EQ(ret, SOFTBUS_NETWORK_NOT_FOUND);
130 ret = DiscCoapStopDiscovery();
131 EXPECT_EQ(ret, SOFTBUS_DISCOVER_COAP_STOP_DISCOVER_FAIL);
132
133 DiscCoapModifyNstackThread(LINK_STATUS_UP);
134 ret = DiscCoapStopDiscovery();
135 EXPECT_EQ(ret, SOFTBUS_OK);
136
137 DiscNstackxDeinit();
138 }
139
140 /*
141 * @tc.name: TestDiscCoapModifyNstackThread002
142 * @tc.desc: Test send coap rsp.
143 * @tc.type: FUNC
144 * @tc.require:
145 */
146 HWTEST_F(DiscNstackxAdapterTest, TestDiscCoapModifyNstackThread002, TestSize.Level1)
147 {
148 DiscCoapModifyNstackThread(LINK_STATUS_DOWN);
149 int32_t ret = DiscNstackxInit();
150 ASSERT_EQ(ret, SOFTBUS_OK);
151
152 DeviceInfo testDiscDevInfo {
153 .devId = "test",
154 };
155 uint8_t bType = 0;
156 ret = LnnInitLocalLedger();
157 EXPECT_EQ(ret, SOFTBUS_OK);
158 ret = DiscCoapSendRsp(&testDiscDevInfo, bType);
159 EXPECT_EQ(ret, NSTACKX_EFAILED);
160
161 DiscCoapModifyNstackThread(LINK_STATUS_UP);
162 ret = DiscCoapSendRsp(&testDiscDevInfo, bType);
163 EXPECT_EQ(ret, SOFTBUS_OK);
164
165 DiscNstackxDeinit();
166 LnnDeinitLocalLedger();
167 }
168
169 /*
170 * @tc.name: TestDiscCoapAdapterRegCb001
171 * @tc.desc: Test DiscCoapRegisterCb should return SOFTBUS_INVALID_PARAM when given invalid DiscInnerCallback
172 * @tc.type: FUNC
173 * @tc.require:
174 */
175 HWTEST_F(DiscNstackxAdapterTest, TestDiscCoapAdapterRegCb001, TestSize.Level1)
176 {
177 int32_t ret = DiscNstackxInit();
178 ASSERT_EQ(ret, SOFTBUS_OK);
179
180 ret = DiscCoapRegisterCb(nullptr);
181 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
182
183 ret = DiscCoapRegisterCb(&g_discInnerCb);
184 EXPECT_EQ(ret, SOFTBUS_OK);
185 }
186
187 /*
188 * @tc.name: TestDiscCoapAdapterRegCapa001
189 * @tc.desc: Test DiscCoapRegisterCapability should return SOFTBUS_INVALID_PARAM
190 * when given invalid capabilityBitmapNum,
191 * should return SOFTBUS_DISCOVER_COAP_REGISTER_CAP_FAIL when given exceed max capabilityBitmapNum,
192 * should return SOFTBUS_OK when given valid capabilityBitmapNum
193 * @tc.type: FUNC
194 * @tc.require:
195 */
196 HWTEST_F(DiscNstackxAdapterTest, TestDiscCoapAdapterRegCapa001, TestSize.Level1)
197 {
198 int32_t ret = DiscNstackxInit();
199 ASSERT_EQ(ret, SOFTBUS_OK);
200
201 uint32_t capaBitmap[] = { 128 };
202 uint32_t bitmapCount = 1;
203 uint32_t invalidCount = 3;
204 ret = DiscCoapRegisterCapability(0, capaBitmap);
205 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
206
207 ret = DiscCoapRegisterCapability(invalidCount, capaBitmap);
208 EXPECT_EQ(ret, SOFTBUS_DISCOVER_COAP_REGISTER_CAP_FAIL);
209
210 ret = DiscCoapRegisterCapability(bitmapCount, capaBitmap);
211 EXPECT_EQ(ret, SOFTBUS_OK);
212 }
213
214 /*
215 * @tc.name: TestDiscCoapAdapterSetFilter001
216 * @tc.desc: Test DiscCoapSetFilterCapability should return SOFTBUS_INVALID_PARAM
217 * when given invalid capabilityBitmapNum,
218 * should return SOFTBUS_DISCOVER_COAP_SET_FILTER_CAP_FAIL when given exceed max capabilityBitmapNum,
219 * should return SOFTBUS_OK when given valid capabilityBitmapNum
220 * @tc.type: FUNC
221 * @tc.require:
222 */
223 HWTEST_F(DiscNstackxAdapterTest, TestDiscCoapAdapterSetFilter001, TestSize.Level1)
224 {
225 int32_t ret = DiscNstackxInit();
226 ASSERT_EQ(ret, SOFTBUS_OK);
227
228 uint32_t capaBitmap[] = { 128 };
229 uint32_t bitmapCount = 1;
230 uint32_t invalidCount = 3;
231 ret = DiscCoapSetFilterCapability(0, capaBitmap);
232 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
233
234 ret = DiscCoapSetFilterCapability(invalidCount, capaBitmap);
235 EXPECT_EQ(ret, SOFTBUS_DISCOVER_COAP_SET_FILTER_CAP_FAIL);
236
237 ret = DiscCoapSetFilterCapability(bitmapCount, capaBitmap);
238 EXPECT_EQ(ret, SOFTBUS_OK);
239 }
240
241 /*
242 * @tc.name: TestDiscCoapAdapterRegData001
243 * @tc.desc: Test DiscCoapRegisterServiceData should return SOFTBUS_OK when DiscNstackxInit has started
244 * @tc.type: FUNC
245 * @tc.require:
246 */
247 HWTEST_F(DiscNstackxAdapterTest, TestDiscCoapAdapterRegData001, TestSize.Level1)
248 {
249 int32_t ret = DiscNstackxInit();
250 ASSERT_EQ(ret, SOFTBUS_OK);
251
252 PublishOption option = {
253 .freq = LOW,
254 };
255 ret = DiscCoapRegisterServiceData(&option, 0);
256 EXPECT_EQ(ret, SOFTBUS_OK);
257 }
258
259 #ifdef DSOFTBUS_FEATURE_DISC_SHARE_COAP
260 /*
261 * @tc.name: TestDiscCoapAdapterRegCapaData001
262 * @tc.desc: Test DiscCoapRegisterCapabilityData should return SOFTBUS_OK when DiscNstackxInit has started
263 * @tc.type: FUNC
264 * @tc.require:
265 */
266 HWTEST_F(DiscNstackxAdapterTest, TestDiscCoapAdapterRegCapaData001, TestSize.Level1)
267 {
268 int32_t ret = DiscNstackxInit();
269 ASSERT_EQ(ret, SOFTBUS_OK);
270
271 const unsigned char capabilityData[] = "test";
272 uint32_t dataLen = 4;
273 uint32_t capability = 1;
274
275 ret = DiscCoapRegisterCapabilityData(nullptr, dataLen, capability);
276 EXPECT_EQ(ret, SOFTBUS_OK);
277 ret = DiscCoapRegisterCapabilityData(capabilityData, 0, capability);
278 EXPECT_EQ(ret, SOFTBUS_OK);
279
280 ret = DiscCoapRegisterCapabilityData(capabilityData, dataLen, capability);
281 EXPECT_EQ(ret, SOFTBUS_OK);
282 }
283 #endif /* DSOFTBUS_FEATURE_DISC_SHARE_COAP */
284
285 /*
286 * @tc.name: TestDiscCoapAdapterStartDisc001
287 * @tc.desc: Test DiscCoapStartDiscovery should return SOFTBUS_INVALID_PARAM when given invalid DiscCoapOption
288 * should return SOFTBUS_OK when given valid DiscCoapOption
289 * @tc.type: FUNC
290 * @tc.require:
291 */
292 HWTEST_F(DiscNstackxAdapterTest, TestDiscCoapAdapterStartDisc001, TestSize.Level1)
293 {
294 int32_t ret = DiscNstackxInit();
295 ASSERT_EQ(ret, SOFTBUS_OK);
296 DiscCoapModifyNstackThread(LINK_STATUS_UP);
297
298 DiscCoapOption testCoapOption = {
299 .freq = LOW,
300 .mode = INVALID_MODE
301 };
302 ret = DiscCoapStartDiscovery(nullptr);
303 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
304
305 ret = DiscCoapStartDiscovery(&testCoapOption);
306 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
307
308 testCoapOption.mode = (DiscCoapMode)(ACTIVE_DISCOVERY + 1);
309 ret = DiscCoapStartDiscovery(&testCoapOption);
310 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
311
312 testCoapOption.mode = ACTIVE_PUBLISH;
313 ret = DiscCoapStartDiscovery(&testCoapOption);
314 EXPECT_EQ(ret, SOFTBUS_NETWORK_NOT_FOUND);
315 ret = DiscCoapStopDiscovery();
316 EXPECT_EQ(ret, SOFTBUS_OK);
317
318 testCoapOption.mode = ACTIVE_DISCOVERY;
319 ret = DiscCoapStartDiscovery(&testCoapOption);
320 EXPECT_EQ(ret, SOFTBUS_NETWORK_NOT_FOUND);
321 ret = DiscCoapStopDiscovery();
322 EXPECT_EQ(ret, SOFTBUS_OK);
323
324 DiscNstackxDeinit();
325 ret = DiscCoapStopDiscovery();
326 EXPECT_EQ(ret, SOFTBUS_DISCOVER_COAP_STOP_DISCOVER_FAIL);
327 }
328
329 /*
330 * @tc.name: TestDiscCoapAdapterStartDisc002
331 * @tc.desc: Test DiscCoapStartDiscovery should return SOFTBUS_OK when given valid DiscCoapOption.freq,
332 * should return not SOFTBUS_OK when given invalid DiscCoapOption.freq
333 * @tc.type: FUNC
334 * @tc.require:
335 */
336 HWTEST_F(DiscNstackxAdapterTest, TestDiscCoapAdapterStartDisc002, TestSize.Level1)
337 {
338 int32_t ret = DiscNstackxInit();
339 ASSERT_EQ(ret, SOFTBUS_OK);
340 DiscCoapModifyNstackThread(LINK_STATUS_UP);
341
342 DiscCoapOption testOption = { 0 };
343 testOption.freq = LOW;
344 testOption.mode = ACTIVE_PUBLISH;
345
346 ret = DiscCoapStartDiscovery(&testOption);
347 EXPECT_EQ(ret, SOFTBUS_NETWORK_NOT_FOUND);
348 ret = DiscCoapStopDiscovery();
349 EXPECT_EQ(ret, SOFTBUS_OK);
350
351 testOption.freq = MID;
352 ret = DiscCoapStartDiscovery(&testOption);
353 EXPECT_EQ(ret, SOFTBUS_NETWORK_NOT_FOUND);
354 ret = DiscCoapStopDiscovery();
355 EXPECT_EQ(ret, SOFTBUS_OK);
356
357 testOption.freq = HIGH;
358 ret = DiscCoapStartDiscovery(&testOption);
359 EXPECT_EQ(ret, SOFTBUS_NETWORK_NOT_FOUND);
360 ret = DiscCoapStopDiscovery();
361 EXPECT_EQ(ret, SOFTBUS_OK);
362
363 testOption.freq = SUPER_HIGH;
364 ret = DiscCoapStartDiscovery(&testOption);
365 EXPECT_EQ(ret, SOFTBUS_NETWORK_NOT_FOUND);
366 ret = DiscCoapStopDiscovery();
367 EXPECT_EQ(ret, SOFTBUS_OK);
368
369 testOption.freq = EXTREME_HIGH;
370 ret = DiscCoapStartDiscovery(&testOption);
371 EXPECT_EQ(ret, SOFTBUS_NETWORK_NOT_FOUND);
372 ret = DiscCoapStopDiscovery();
373 EXPECT_EQ(ret, SOFTBUS_OK);
374
375 testOption.freq = LOW - 1;
376 ret = DiscCoapStartDiscovery(&testOption);
377 EXPECT_NE(ret, SOFTBUS_OK);
378 testOption.freq = FREQ_BUTT;
379 ret = DiscCoapStartDiscovery(&testOption);
380 EXPECT_NE(ret, SOFTBUS_OK);
381
382 DiscNstackxDeinit();
383 ret = DiscCoapStopDiscovery();
384 EXPECT_EQ(ret, SOFTBUS_DISCOVER_COAP_STOP_DISCOVER_FAIL);
385 }
386
387 /*
388 * @tc.name: TestDiscCoapAdapterUpdate001
389 * @tc.desc: Test DiscCoapUpdateLocalIp should return SOFTBUS_OK when given LINK_STATUS_UP LinkStatus,
390 * should return SOFTBUS_OK when given LINK_STATUS_DOWN LinkStatus,
391 * should return SOFTBUS_OK when given invalid LinkStatus
392 * @tc.type: FUNC
393 * @tc.require:
394 */
395 HWTEST_F(DiscNstackxAdapterTest, TestDiscCoapAdapterUpdate001, TestSize.Level1)
396 {
397 int32_t ret = DiscNstackxInit();
398 ASSERT_EQ(ret, SOFTBUS_OK);
399
400 DiscCoapOption testCoapOption = {
401 .freq = LOW,
402 .mode = ACTIVE_DISCOVERY
403 };
404 DiscCoapUpdateLocalIp(LINK_STATUS_UP);
405 DiscCoapUpdateDevName();
406 ret = DiscCoapStartDiscovery(&testCoapOption);
407 EXPECT_EQ(ret, SOFTBUS_NETWORK_NOT_FOUND);
408
409 DiscCoapUpdateLocalIp(LINK_STATUS_DOWN);
410 ret = DiscCoapStartDiscovery(&testCoapOption);
411 EXPECT_EQ(ret, SOFTBUS_NETWORK_NOT_FOUND);
412
413 DiscCoapUpdateLocalIp((LinkStatus)(-1));
414 ret = DiscCoapStartDiscovery(&testCoapOption);
415 EXPECT_EQ(ret, SOFTBUS_NETWORK_NOT_FOUND);
416 }
417
418 /*
419 * @tc.name: TestDiscCoapAdapterFound001
420 * @tc.desc: Test OnDeviceFound should be called when given invalid NSTACKX_DeviceInfo and deviceCount,
421 * should be called when given valid NSTACKX_DeviceInfo and deviceCount
422 * @tc.type: FUNC
423 * @tc.require:
424 */
425 HWTEST_F(DiscNstackxAdapterTest, TestDiscCoapAdapterFound001, TestSize.Level1)
426 {
427 int32_t ret = DiscNstackxInit();
428 ASSERT_EQ(ret, SOFTBUS_OK);
429 ret = DiscCoapRegisterCb(&g_discInnerCb);
430 EXPECT_EQ(ret, SOFTBUS_OK);
431
432 OnDeviceFound(&g_testNstackxInfo, 0);
433 ASSERT_TRUE(!isDeviceFound);
434
435 OnDeviceFound(nullptr, 1);
436 ASSERT_TRUE(!isDeviceFound);
437
438 g_testNstackxInfo.update = 0;
439 OnDeviceFound(&g_testNstackxInfo, 1);
440 ASSERT_TRUE(!isDeviceFound);
441 g_testNstackxInfo.update = 1;
442
443 g_testNstackxInfo.discoveryType = NSTACKX_DISCOVERY_TYPE_PASSIVE;
444 g_testNstackxInfo.mode = DISCOVER_MODE;
445 OnDeviceFound(&g_testNstackxInfo, 1);
446 ASSERT_TRUE(!isDeviceFound);
447
448 g_testNstackxInfo.mode = PUBLISH_MODE_PROACTIVE;
449 OnDeviceFound(&g_testNstackxInfo, 1);
450 ASSERT_TRUE(!isDeviceFound);
451
452 g_testNstackxInfo.discoveryType = NSTACKX_DISCOVERY_TYPE_ACTIVE;
453 OnDeviceFound(&g_testNstackxInfo, 1);
454 ASSERT_TRUE(!isDeviceFound);
455 }
456
457 /*
458 * @tc.name: TestDiscCoapAdapterFound002
459 * @tc.desc: Test DiscOnDeviceFound should reach the branch when given valid NSTACKX_DeviceInfo and DeviceCount
460 * when DiscCoapRegisterCb was given vaild and nullptr
461 * @tc.type: FUNC
462 * @tc.require:
463 */
464 HWTEST_F(DiscNstackxAdapterTest, TestDiscCoapAdapterFound002, TestSize.Level1)
465 {
466 int32_t ret = DiscNstackxInit();
467 ASSERT_EQ(ret, SOFTBUS_OK);
468
469 NSTACKX_DeviceInfo testDeviceList;
470 uint32_t testDeviceCount = 1;
471 testDeviceList.update = 1;
472 testDeviceList.mode = PUBLISH_MODE_PROACTIVE;
473 ret = strcpy_s(testDeviceList.deviceId, sizeof(testDeviceList.deviceId), "{\"UDID\":\"abcde\"}");
474 EXPECT_EQ(ret, EOK);
475 ret = strcpy_s(testDeviceList.reservedInfo, sizeof(testDeviceList.reservedInfo), "{\"version\":\"1.0.0\"}");
476 EXPECT_EQ(ret, EOK);
477 g_discInnerCb.OnDeviceFound = OnDeviceFoundTest;
478 ret = DiscCoapRegisterCb(&g_discInnerCb);
479 EXPECT_EQ(ret, SOFTBUS_OK);
480
481 g_discInnerCb.OnDeviceFound = nullptr;
482 ret = DiscCoapRegisterCb(&g_discInnerCb);
483 EXPECT_EQ(ret, SOFTBUS_OK);
484 g_testAddtions.medium = AUTO;
485 OnDeviceFound(&testDeviceList, testDeviceCount);
486 EXPECT_EQ(g_testAddtions.medium, AUTO);
487
488 ret = DiscCoapRegisterCb(nullptr);
489 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
490 g_testAddtions.medium = AUTO;
491 OnDeviceFound(&testDeviceList, testDeviceCount);
492 EXPECT_EQ(g_testAddtions.medium, AUTO);
493 }
494
495 /*
496 * @tc.name: TestDiscCoapAdapterParseResInfo001
497 * @tc.desc: Test DiscParseReservedInfo should return SOFTBUS_OK when given Json NSTACKX_DeviceInfo.reservedInfo,
498 * should return SOFTBUS_PARSE_JSON_ERR when given non-Json format NSTACKX_DeviceInfo.reservedInfo
499 * @tc.type: FUNC
500 * @tc.require:
501 */
502 HWTEST_F(DiscNstackxAdapterTest, TestDiscCoapAdapterParseResInfo001, TestSize.Level1)
503 {
504 int32_t ret = DiscNstackxInit();
505 ASSERT_EQ(ret, SOFTBUS_OK);
506
507 NSTACKX_DeviceInfo testNstackxDevice;
508 DeviceInfo testDevice;
509 char nickname[DISC_MAX_NICKNAME_LEN] = { 0 };
510 ret = strcpy_s(testNstackxDevice.reservedInfo, sizeof(testNstackxDevice.reservedInfo), "{\"version\":\"1.0.0\"}");
511 EXPECT_EQ(ret, EOK);
512 ret = ParseReservedInfo(&testNstackxDevice, &testDevice, nickname);
513 EXPECT_EQ(ret, SOFTBUS_OK);
514
515 ret = strcpy_s(testNstackxDevice.reservedInfo, sizeof(testNstackxDevice.reservedInfo), "test");
516 EXPECT_EQ(ret, EOK);
517 ret = ParseReservedInfo(&testNstackxDevice, &testDevice, nickname);
518 EXPECT_EQ(ret, SOFTBUS_PARSE_JSON_ERR);
519 }
520
521 /*
522 * @tc.name: TestDiscCoapAdapterParseResInfo002
523 * @tc.desc: Test DiscParseReservedInfo should return SOFTBUS_OK when given nullptr DeviceInfo
524 * @tc.type: FUNC
525 * @tc.require:
526 */
527 HWTEST_F(DiscNstackxAdapterTest, TestDiscCoapAdapterParseResInfo002, TestSize.Level1)
528 {
529 int32_t ret = DiscNstackxInit();
530 ASSERT_EQ(ret, SOFTBUS_OK);
531
532 NSTACKX_DeviceInfo testNstackxDevice;
533 DeviceInfo testDevice;
534 char nickname[DISC_MAX_NICKNAME_LEN] = { 0 };
535 ret = strcpy_s(testNstackxDevice.reservedInfo, sizeof(testNstackxDevice.reservedInfo),
536 "{\"version\":\"1.0.0\",\"bData\":{\"nickname\":\"Jane\"}}");
537 EXPECT_EQ(ret, EOK);
538 ret = ParseReservedInfo(&testNstackxDevice, &testDevice, nickname);
539 EXPECT_EQ(ret, SOFTBUS_OK);
540
541 ret = ParseReservedInfo(&testNstackxDevice, &testDevice, nullptr);
542 EXPECT_EQ(ret, SOFTBUS_OK);
543 }
544
545 /*
546 * @tc.name: TestDiscCoapAdapterParseResInfo003
547 * @tc.desc: Test DiscParseReservedInfo should return SOFTBUS_OK when given nickname or not
548 * @tc.type: FUNC
549 * @tc.require:
550 */
551 HWTEST_F(DiscNstackxAdapterTest, TestDiscCoapAdapterParseResInfo003, TestSize.Level1)
552 {
553 int32_t ret = DiscNstackxInit();
554 ASSERT_EQ(ret, SOFTBUS_OK);
555
556 NSTACKX_DeviceInfo testNstackxDevice;
557 DeviceInfo testDevice;
558 char nickname[DISC_MAX_NICKNAME_LEN] = { 0 };
559 ret = strcpy_s(testNstackxDevice.reservedInfo, sizeof(testNstackxDevice.reservedInfo), "{\"version\":\"1.0.0\"}");
560 EXPECT_EQ(ret, EOK);
561 ret = ParseReservedInfo(&testNstackxDevice, nullptr, nickname);
562 EXPECT_EQ(ret, SOFTBUS_OK);
563
564 ret = ParseReservedInfo(&testNstackxDevice, &testDevice, nickname);
565 EXPECT_EQ(ret, SOFTBUS_OK);
566 }
567
568 /*
569 * @tc.name: TestDiscCoapAdapterParseDevInfo001
570 * @tc.desc: Test DiscParseDiscDevInfo DeviceInfo.addr[0].type should be
571 * CONNECTION_ADDR_WLAN and CONNECTION_ADDR_ETH when given PUBLISH_MODE_PROACTIVE NSTACKX_DeviceInfo.mode,
572 * and when NSTACKX_DeviceInfo.networkName are "wlan" and "eth"
573 * @tc.type: FUNC
574 * @tc.require:
575 */
576 HWTEST_F(DiscNstackxAdapterTest, TestDiscCoapAdapterParseDevInfo001, TestSize.Level1)
577 {
578 int32_t ret = DiscNstackxInit();
579 LnnInitLocalLedger();
580 ASSERT_EQ(ret, SOFTBUS_OK);
581
582 NSTACKX_DeviceInfo testNstackxDevice;
583 DeviceInfo testDiscDevInfo;
584 testNstackxDevice.mode = PUBLISH_MODE_PROACTIVE;
585 ret = strcpy_s(testNstackxDevice.networkName, sizeof(testNstackxDevice.networkName), "wlan");
586 EXPECT_EQ(ret, EOK);
587 ParseDiscDevInfo(&testNstackxDevice, &testDiscDevInfo);
588 EXPECT_EQ(testDiscDevInfo.addr[0].type, CONNECTION_ADDR_WLAN);
589
590 ret = strcpy_s(testNstackxDevice.networkName, sizeof(testNstackxDevice.networkName), "eth");
591 EXPECT_EQ(ret, EOK);
592 ParseDiscDevInfo(&testNstackxDevice, &testDiscDevInfo);
593 EXPECT_EQ(testDiscDevInfo.addr[0].type, CONNECTION_ADDR_ETH);
594 LnnDeinitLocalLedger();
595 }
596
597 /*
598 * @tc.name: TestDiscCoapAdapterParseDevInfo002
599 * @tc.desc: Test DiscParseDiscDevInfo should return SOFTBUS_PARSE_JSON_ERR
600 * when given non-Json NSTACKX_DeviceInfo.reservedInfo
601 * @tc.type: FUNC
602 * @tc.require:
603 */
604 HWTEST_F(DiscNstackxAdapterTest, TestDiscCoapAdapterParseDevInfo002, TestSize.Level1)
605 {
606 int32_t ret = DiscNstackxInit();
607 LnnInitLocalLedger();
608 ASSERT_EQ(ret, SOFTBUS_OK);
609
610 NSTACKX_DeviceInfo testNstackxDevInfo {
611 .deviceId = "{\"UDID\":\"abcde\"}",
612 .reservedInfo = "{\"version\":\"1.0.0\"}",
613 .mode = PUBLISH_MODE_PROACTIVE,
614 };
615 DeviceInfo testDiscDevInfo {
616 .devId = "test",
617 };
618 ret = ParseDiscDevInfo(&testNstackxDevInfo, &testDiscDevInfo);
619 EXPECT_EQ(ret, SOFTBUS_OK);
620
621 ret = strcpy_s(testNstackxDevInfo.reservedInfo, sizeof(testNstackxDevInfo.reservedInfo), "test");
622 EXPECT_EQ(ret, EOK);
623 ret = ParseDiscDevInfo(&testNstackxDevInfo, &testDiscDevInfo);
624 EXPECT_EQ(ret, SOFTBUS_PARSE_JSON_ERR);
625 LnnDeinitLocalLedger();
626 }
627
628 /*
629 * @tc.name: TestDiscCoapAdapterParseDevInfo003
630 * @tc.desc: Test DiscParseDiscDevInfo should return SOFTBUS_OK
631 * when given NSTACKX_DISCOVERY_TYPE_ACTIVE NSTACKX_DeviceInfo.discoveryType,
632 * should return SOFTBUS_OK when given PUBLISH_MODE_PROACTIVE NSTACKX_DeviceInfo.mode
633 * @tc.type: FUNC
634 * @tc.require:
635 */
636 HWTEST_F(DiscNstackxAdapterTest, TestDiscCoapAdapterParseDevInfo003, TestSize.Level1)
637 {
638 int32_t ret = DiscNstackxInit();
639 LnnInitLocalLedger();
640 ASSERT_EQ(ret, SOFTBUS_OK);
641
642 NSTACKX_DeviceInfo testNstackxDevInfo {
643 .deviceId = "{\"UDID\":\"abcde\"}",
644 .reservedInfo = "{\"version\":\"1.0.0\"}",
645 .mode = DEFAULT_MODE,
646 .discoveryType = NSTACKX_DISCOVERY_TYPE_ACTIVE,
647 };
648 DeviceInfo testDiscDevInfo;
649 ret = ParseDiscDevInfo(&testNstackxDevInfo, &testDiscDevInfo);
650 EXPECT_EQ(ret, SOFTBUS_OK);
651
652 testNstackxDevInfo.mode = PUBLISH_MODE_PROACTIVE;
653 ret = ParseDiscDevInfo(&testNstackxDevInfo, &testDiscDevInfo);
654 EXPECT_EQ(ret, SOFTBUS_OK);
655 LnnDeinitLocalLedger();
656 }
657
658 /*
659 * @tc.name: TestDiscCoapAdapterRegisterCb001
660 * @tc.desc: Test DiscCoapRegisterCb should return SOFTBUS_OK when given valid,
661 * should return SOFTBUS_INVALID_PARAM when given nullptr DiscInnerCallback
662 * @tc.type: FUNC
663 * @tc.require:
664 */
665 HWTEST_F(DiscNstackxAdapterTest, TestDiscCoapAdapterRegisterCb001, TestSize.Level1)
666 {
667 int32_t ret = DiscNstackxInit();
668 ASSERT_EQ(ret, SOFTBUS_OK);
669
670 ret = DiscCoapRegisterCb(&g_discInnerCb);
671 EXPECT_EQ(ret, SOFTBUS_OK);
672
673 ret = DiscCoapRegisterCb(nullptr);
674 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
675 }
676
677 /*
678 * @tc.name: TestDiscCoapSendRsp001
679 * @tc.desc: Test DiscCoapSendRsp should return SOFTBUS_OK when given valid,
680 * should return SOFTBUS_INVALID_PARAM when given nullptr DeviceInfo
681 * should return SOFTBUS_LOCK_ERR when localledger not init
682 * @tc.type: FUNC
683 * @tc.require:
684 */
685 HWTEST_F(DiscNstackxAdapterTest, TestDiscCoapSendRsp001, TestSize.Level1)
686 {
687 int32_t ret = DiscNstackxInit();
688 ASSERT_EQ(ret, SOFTBUS_OK);
689 DiscCoapModifyNstackThread(LINK_STATUS_UP);
690
691 DeviceInfo testDiscDevInfo {
692 .devId = "test",
693 };
694 uint8_t bType = 0;
695
696 ret = DiscCoapSendRsp(nullptr, bType);
697 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
698
699 ret = DiscCoapSendRsp(&testDiscDevInfo, bType);
700 EXPECT_EQ(ret, SOFTBUS_LOCK_ERR);
701
702 ret = LnnInitLocalLedger();
703 EXPECT_EQ(ret, SOFTBUS_OK);
704 ret = DiscCoapSendRsp(&testDiscDevInfo, bType);
705 EXPECT_EQ(ret, SOFTBUS_OK);
706 LnnDeinitLocalLedger();
707 }
708 } // namespace OHOS
709