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