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