1 /*
2 * Copyright (c) 2025 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.h"
24 #include "lnn_local_net_ledger.h"
25 #include "disc_nstackx_adapter_mock.h"
26 #include "softbus_adapter_mem.h"
27 #include "softbus_error_code.h"
28
29 using namespace testing::ext;
30
31 static bool isDeviceFound = false;
32 namespace OHOS {
33
34 class DiscNstackxAdapterTest : public testing::Test {
35 public:
DiscNstackxAdapterTest()36 DiscNstackxAdapterTest() { }
~DiscNstackxAdapterTest()37 ~DiscNstackxAdapterTest() { }
SetUpTestCase()38 static void SetUpTestCase() { }
TearDownTestCase()39 static void TearDownTestCase() { }
SetUp()40 void SetUp() override { }
TearDown()41 void TearDown() override { }
42 };
43
44 static constexpr uint32_t OSD_CAPABILITY = 128;
45
46 static NSTACKX_DeviceInfo g_testNstackxInfo = {
47 .deviceId = "{UDID:123456789012345}",
48 .deviceName = "OpenHarmonyDevice",
49 .capabilityBitmapNum = 1,
50 .capabilityBitmap = { OSD_CAPABILITY },
51 .deviceType = 0,
52 .mode = DISCOVER_MODE,
53 .update = 1,
54 .reserved = 0,
55 .networkName = "wlan0",
56 .discoveryType = NSTACKX_DISCOVERY_TYPE_ACTIVE,
57 .businessType = NSTACKX_BUSINESS_TYPE_NULL,
58 .reservedInfo = "reserved"
59 };
60
OnDeviceFoundTest(const DeviceInfo * device,const InnerDeviceInfoAddtions * additions)61 static void OnDeviceFoundTest(const DeviceInfo *device, const InnerDeviceInfoAddtions *additions)
62 {
63 (void)device;
64 (void)additions;
65 DISC_LOGI(DISC_TEST, "OnDeviceFoundTest in");
66 isDeviceFound = true;
67 }
68
69 static DiscInnerCallback g_discInnerCb = {
70 .OnDeviceFound = OnDeviceFoundTest,
71 };
72
73 /*
74 * @tc.name: DiscCoapAdapterInit001
75 * @tc.desc: Test DiscNstackxInit should return SOFTBUS_OK when repeat init
76 * @tc.type: FUNC
77 * @tc.require:
78 */
79 HWTEST_F(DiscNstackxAdapterTest, DiscCoapAdapterInit001, TestSize.Level1)
80 {
81 DiscNstackxDeinit();
82 int32_t ret = DiscNstackxInit();
83 ASSERT_EQ(ret, SOFTBUS_OK);
84
85 // repeat init
86 ret = DiscNstackxInit();
87 EXPECT_EQ(ret, SOFTBUS_OK);
88 }
89
90 /*
91 * @tc.name: DiscCoapAdapterDeInit001
92 * @tc.desc: Test DiscNstackxInit should return SOFTBUS_OK after repeat deinit
93 * @tc.type: FUNC
94 * @tc.require:
95 */
96 HWTEST_F(DiscNstackxAdapterTest, DiscCoapAdapterDeInit001, TestSize.Level1)
97 {
98 DiscNstackxDeinit();
99 DiscNstackxDeinit();
100 int32_t ret = DiscNstackxInit();
101 ASSERT_EQ(ret, SOFTBUS_OK);
102
103 // repeat init
104 ret = DiscNstackxInit();
105 EXPECT_EQ(ret, SOFTBUS_OK);
106
107 DiscNstackxDeinit();
108 }
109
110 /*
111 * @tc.name: DiscCoapAdapterRegCb001
112 * @tc.desc: Test DiscCoapRegisterCb should return SOFTBUS_INVALID_PARAM when given invalid DiscInnerCallback
113 * @tc.type: FUNC
114 * @tc.require:
115 */
116 HWTEST_F(DiscNstackxAdapterTest, DiscCoapAdapterRegCb001, TestSize.Level1)
117 {
118 int32_t ret = DiscNstackxInit();
119 ASSERT_EQ(ret, SOFTBUS_OK);
120
121 ret = DiscCoapRegisterCb(nullptr);
122 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
123
124 ret = DiscCoapRegisterCb(&g_discInnerCb);
125 EXPECT_EQ(ret, SOFTBUS_OK);
126
127 DiscNstackxDeinit();
128 }
129
130 /*
131 * @tc.name: DiscCoapAdapterRegCapa001
132 * @tc.desc: Test DiscCoapRegisterCapability should return SOFTBUS_INVALID_PARAM
133 * when given invalid capabilityBitmapNum,
134 * should return SOFTBUS_DISCOVER_COAP_REGISTER_CAP_FAIL when given exceed max capabilityBitmapNum,
135 * should return SOFTBUS_OK when given valid capabilityBitmapNum
136 * @tc.type: FUNC
137 * @tc.require:
138 */
139 HWTEST_F(DiscNstackxAdapterTest, DiscCoapAdapterRegCapa001, TestSize.Level1)
140 {
141 int32_t ret = DiscNstackxInit();
142 ASSERT_EQ(ret, SOFTBUS_OK);
143
144 uint32_t capaBitmap[] = { 128 };
145 uint32_t bitmapCount = 1;
146 uint32_t invalidCount = 3;
147 ret = DiscCoapRegisterCapability(0, capaBitmap);
148 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
149
150 ret = DiscCoapRegisterCapability(invalidCount, capaBitmap);
151 EXPECT_EQ(ret, SOFTBUS_OK);
152
153 ret = DiscCoapRegisterCapability(bitmapCount, capaBitmap);
154 EXPECT_EQ(ret, SOFTBUS_OK);
155
156 DiscNstackxDeinit();
157 }
158
159 /*
160 * @tc.name: DiscCoapAdapterSetFilter001
161 * @tc.desc: Test DiscCoapSetFilterCapability should return SOFTBUS_INVALID_PARAM
162 * when given invalid capabilityBitmapNum,
163 * should return SOFTBUS_DISCOVER_COAP_SET_FILTER_CAP_FAIL when given exceed max capabilityBitmapNum,
164 * should return SOFTBUS_OK when given valid capabilityBitmapNum
165 * @tc.type: FUNC
166 * @tc.require:
167 */
168 HWTEST_F(DiscNstackxAdapterTest, DiscCoapAdapterSetFilter001, TestSize.Level1)
169 {
170 int32_t ret = DiscNstackxInit();
171 ASSERT_EQ(ret, SOFTBUS_OK);
172
173 uint32_t capaBitmap[] = { 128 };
174 uint32_t bitmapCount = 1;
175 uint32_t invalidCount = 3;
176 ret = DiscCoapSetFilterCapability(0, capaBitmap);
177 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
178
179 ret = DiscCoapSetFilterCapability(invalidCount, capaBitmap);
180 EXPECT_EQ(ret, SOFTBUS_OK);
181
182 ret = DiscCoapSetFilterCapability(bitmapCount, capaBitmap);
183 EXPECT_EQ(ret, SOFTBUS_OK);
184
185 DiscNstackxDeinit();
186 }
187
188 /*
189 * @tc.name: DiscCoapRegisterServiceData001
190 * @tc.desc: Test DiscCoapRegisterServiceData should return SOFTBUS_OK when DiscNstackxInit has started
191 * @tc.type: FUNC
192 * @tc.require:
193 */
194 HWTEST_F(DiscNstackxAdapterTest, DiscCoapRegisterServiceData001, TestSize.Level1)
195 {
196 int32_t ret = DiscNstackxInit();
197 ASSERT_EQ(ret, SOFTBUS_OK);
198
199 PublishOption option = {
200 .freq = LOW,
201 };
202 ret = DiscCoapRegisterServiceData(&option, 0);
203 EXPECT_EQ(ret, SOFTBUS_OK);
204
205 DiscNstackxDeinit();
206 }
207
208 /*
209 * @tc.name: DiscCoapRegisterCapabilityData001
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, DiscCoapRegisterCapabilityData001, TestSize.Level1)
215 {
216 int32_t ret = DiscNstackxInit();
217 ASSERT_EQ(ret, SOFTBUS_OK);
218
219 const unsigned char capData[] = "{\"devHash\":\"1122334455667788990011223344556677889900\",\"nbVer\":9,"
220 "\"nick\":\"Mark\",\"OH\":1,\"abl\":2,\"icon\":0}";
221 uint32_t len = strlen((const char *)capData);
222
223 ret = DiscCoapRegisterCapabilityData(nullptr, len, 0);
224 EXPECT_EQ(ret, SOFTBUS_OK);
225
226 ret = DiscCoapRegisterCapabilityData(capData, 0, 0);
227 EXPECT_EQ(ret, SOFTBUS_OK);
228
229 uint32_t capability = (1 << HICALL_CAPABILITY_BITMAP);
230 ret = DiscCoapRegisterCapabilityData(capData, len, capability);
231 EXPECT_EQ(ret, SOFTBUS_OK);
232
233 capability = (1 << PROFILE_CAPABILITY_BITMAP);
234 ret = DiscCoapRegisterCapabilityData(capData, len, capability);
235 EXPECT_EQ(ret, SOFTBUS_OK);
236
237 capability = (1 << HOMEVISIONPIC_CAPABILITY_BITMAP);
238 ret = DiscCoapRegisterCapabilityData(capData, len, capability);
239 EXPECT_EQ(ret, SOFTBUS_OK);
240
241 capability = (1 << CASTPLUS_CAPABILITY_BITMAP);
242 ret = DiscCoapRegisterCapabilityData(capData, len, capability);
243 EXPECT_EQ(ret, SOFTBUS_OK);
244
245 capability = (1 << AA_CAPABILITY_BITMAP);
246 ret = DiscCoapRegisterCapabilityData(capData, len, capability);
247 EXPECT_EQ(ret, SOFTBUS_OK);
248
249 capability = (1 << DVKIT_CAPABILITY_BITMAP);
250 ret = DiscCoapRegisterCapabilityData(capData, len, capability);
251 EXPECT_EQ(ret, SOFTBUS_OK);
252
253 capability = (1 << DDMP_CAPABILITY_BITMAP);
254 ret = DiscCoapRegisterCapabilityData(capData, len, capability);
255 EXPECT_EQ(ret, SOFTBUS_OK);
256
257 capability = (1 << OSD_CAPABILITY_BITMAP);
258 ret = DiscCoapRegisterCapabilityData(capData, len, capability);
259 EXPECT_EQ(ret, SOFTBUS_OK);
260
261 capability = (1 << SHARE_CAPABILITY_BITMAP);
262 ret = DiscCoapRegisterCapabilityData(capData, len, capability);
263 EXPECT_EQ(ret, SOFTBUS_DISCOVER_COAP_PARSE_DATA_FAIL);
264 }
265
266 /*
267 * @tc.name: DiscCoapModifyNstackThread001
268 * @tc.desc: Test DiscCoapModifyNstackThread
269 * @tc.type: FUNC
270 * @tc.require:
271 */
272 HWTEST_F(DiscNstackxAdapterTest, DiscCoapModifyNstackThread001, TestSize.Level1)
273 {
274 int32_t ret = DiscNstackxInit();
275 ASSERT_EQ(ret, SOFTBUS_OK);
276
277 DiscCoapModifyNstackThread(LINK_STATUS_UP, WLAN_IF);
278
279 DiscCoapRecordLinkStatus(LINK_STATUS_UP, WLAN_IF);
280 DiscCoapModifyNstackThread(LINK_STATUS_UP, WLAN_IF);
281
282 DiscCoapRecordLinkStatus(LINK_STATUS_UP, USB_IF);
283 DiscCoapModifyNstackThread(LINK_STATUS_UP, USB_IF);
284
285 DiscCoapModifyNstackThread(LINK_STATUS_DOWN, USB_IF);
286
287 DiscCoapRecordLinkStatus(LINK_STATUS_DOWN, USB_IF);
288 DiscCoapModifyNstackThread(LINK_STATUS_DOWN, USB_IF);
289
290 DiscCoapRecordLinkStatus(LINK_STATUS_DOWN, WLAN_IF);
291 DiscCoapModifyNstackThread(LINK_STATUS_DOWN, WLAN_IF);
292
293 DiscNstackxDeinit();
294 }
295
296 /*
297 * @tc.name: DiscCoapSendRsp001
298 * @tc.desc: Test DiscCoapSendRsp should return SOFTBUS_OK when linkup
299 * @tc.type: FUNC
300 * @tc.require:
301 */
302 HWTEST_F(DiscNstackxAdapterTest, DiscCoapSendRsp001, TestSize.Level1)
303 {
304 AdapterMock adapterMock;
305 EXPECT_CALL(adapterMock, LnnGetLocalStrInfoByIfnameIdx).
306 WillRepeatedly(AdapterMock::ActionOfLnnGetLocalStrInfoByIfnameIdx);
307
308 int32_t ret = DiscNstackxInit();
309 ASSERT_EQ(ret, SOFTBUS_OK);
310
311 ret = DiscCoapSendRsp(nullptr, 0);
312 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
313
314 DeviceInfo devInfo = {};
315 ret = DiscCoapSendRsp(&devInfo, 0);
316 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
317
318 DiscCoapRecordLinkStatus(LINK_STATUS_UP, WLAN_IF);
319 strcpy_s(devInfo.addr[0].info.ip.ip, IP_STR_MAX_LEN, "test");
320 ret = DiscCoapSendRsp(&devInfo, 0);
321 EXPECT_EQ(ret, SOFTBUS_OK);
322
323 strcpy_s(devInfo.addr[0].info.ip.ip, IP_STR_MAX_LEN, "fe80::1111:2222:3333:4444");
324 ret = DiscCoapSendRsp(&devInfo, 0);
325 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
326
327 DiscCoapRecordLinkStatus(LINK_STATUS_DOWN, WLAN_IF);
328 DiscCoapRecordLinkStatus(LINK_STATUS_UP, USB_IF);
329 ret = DiscCoapSendRsp(&devInfo, 0);
330 EXPECT_EQ(ret, SOFTBUS_OK);
331
332 strcpy_s(devInfo.addr[0].info.ip.ip, IP_STR_MAX_LEN, "192.168.1.1");
333 ret = DiscCoapSendRsp(&devInfo, 0);
334 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
335
336 DiscNstackxDeinit();
337 }
338
339 /*
340 * @tc.name: DiscCoapAdapterFound001
341 * @tc.desc: Test OnDeviceFound should be called when given invalid NSTACKX_DeviceInfo and deviceCount,
342 * should be called when given valid NSTACKX_DeviceInfo and deviceCount
343 * @tc.type: FUNC
344 * @tc.require:
345 */
346 HWTEST_F(DiscNstackxAdapterTest, DiscCoapAdapterFound001, TestSize.Level1)
347 {
348 AdapterMock adapterMock;
349 EXPECT_CALL(adapterMock, NSTACKX_Init).WillRepeatedly(AdapterMock::ActionOfNstackInit);
350
351 int32_t ret = DiscNstackxInit();
352 ASSERT_EQ(ret, SOFTBUS_OK);
353 ret = DiscCoapRegisterCb(&g_discInnerCb);
354 EXPECT_EQ(ret, SOFTBUS_OK);
355
356 adapterMock.InjectDeviceFoundEvent(nullptr, 0);
357 EXPECT_TRUE(!isDeviceFound);
358
359 adapterMock.InjectDeviceFoundEvent(&g_testNstackxInfo, 0);
360 EXPECT_TRUE(!isDeviceFound);
361
362 g_testNstackxInfo.update = 0;
363 adapterMock.InjectDeviceFoundEvent(&g_testNstackxInfo, 1);
364 EXPECT_TRUE(!isDeviceFound);
365
366 g_testNstackxInfo.update = 1;
367 g_testNstackxInfo.discoveryType = NSTACKX_DISCOVERY_TYPE_PASSIVE;
368 g_testNstackxInfo.mode = DISCOVER_MODE;
369 adapterMock.InjectDeviceFoundEvent(&g_testNstackxInfo, 1);
370 EXPECT_TRUE(!isDeviceFound);
371
372 g_testNstackxInfo.mode = PUBLISH_MODE_PROACTIVE;
373 adapterMock.InjectDeviceFoundEvent(&g_testNstackxInfo, 1);
374 EXPECT_TRUE(!isDeviceFound);
375
376 g_testNstackxInfo.discoveryType = NSTACKX_DISCOVERY_TYPE_ACTIVE;
377 adapterMock.InjectDeviceFoundEvent(&g_testNstackxInfo, 1);
378 EXPECT_TRUE(!isDeviceFound);
379 }
380
381 /*
382 * @tc.name: DiscCoapAdapterFound002
383 * @tc.desc: Test DiscOnDeviceFound should reach the branch when given valid NSTACKX_DeviceInfo and DeviceCount
384 * when DiscCoapRegisterCb was given vaild callback
385 * @tc.type: FUNC
386 * @tc.require:
387 */
388 HWTEST_F(DiscNstackxAdapterTest, DiscCoapAdapterFound002, TestSize.Level1)
389 {
390 AdapterMock adapterMock;
391 EXPECT_CALL(adapterMock, NSTACKX_Init).WillRepeatedly(AdapterMock::ActionOfNstackInit);
392
393 int32_t ret = DiscNstackxInit();
394 ASSERT_EQ(ret, SOFTBUS_OK);
395
396 NSTACKX_DeviceInfo testDeviceList;
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
404 g_discInnerCb.OnDeviceFound = nullptr;
405 ret = DiscCoapRegisterCb(&g_discInnerCb);
406 EXPECT_EQ(ret, SOFTBUS_OK);
407 adapterMock.InjectDeviceFoundEvent(&testDeviceList, 1);
408 EXPECT_TRUE(!isDeviceFound);
409
410 g_discInnerCb.OnDeviceFound = OnDeviceFoundTest;
411 ret = DiscCoapRegisterCb(&g_discInnerCb);
412 EXPECT_EQ(ret, SOFTBUS_OK);
413 adapterMock.InjectDeviceFoundEvent(&testDeviceList, 1);
414 EXPECT_TRUE(!isDeviceFound);
415 }
416
417 /*
418 * @tc.name: DiscCoapAdapterFound003
419 * @tc.desc: Test DiscOnDeviceFound should reach the branch when given different network
420 * when DiscCoapRegisterCb was given vaild callback
421 * @tc.type: FUNC
422 * @tc.require:
423 */
424 HWTEST_F(DiscNstackxAdapterTest, DiscCoapAdapterFound003, TestSize.Level1)
425 {
426 AdapterMock adapterMock;
427 EXPECT_CALL(adapterMock, NSTACKX_Init).WillRepeatedly(AdapterMock::ActionOfNstackInit);
428
429 int32_t ret = DiscNstackxInit();
430 ASSERT_EQ(ret, SOFTBUS_OK);
431 ret = DiscCoapRegisterCb(&g_discInnerCb);
432 EXPECT_EQ(ret, SOFTBUS_OK);
433
434 NSTACKX_DeviceInfo testDeviceList;
435 testDeviceList.update = 1;
436 ret = strcpy_s(testDeviceList.deviceId, sizeof(testDeviceList.deviceId), "{\"UDID\":\"abcde\"}");
437 EXPECT_EQ(ret, EOK);
438 ret = strcpy_s(testDeviceList.reservedInfo, sizeof(testDeviceList.reservedInfo), "{\"version\":\"1.0.0\"}");
439 EXPECT_EQ(ret, EOK);
440
441 ret = strcpy_s(testDeviceList.networkName, sizeof(testDeviceList.networkName), "wlan0");
442 EXPECT_EQ(ret, EOK);
443 adapterMock.InjectDeviceFoundEvent(&testDeviceList, 1);
444 EXPECT_TRUE(!isDeviceFound);
445
446 ret = strcpy_s(testDeviceList.networkName, sizeof(testDeviceList.networkName), "ncm0");
447 EXPECT_EQ(ret, EOK);
448 adapterMock.InjectDeviceFoundEvent(&testDeviceList, 1);
449 EXPECT_TRUE(!isDeviceFound);
450
451 ret = strcpy_s(testDeviceList.networkName, sizeof(testDeviceList.networkName), "wwan0");
452 EXPECT_EQ(ret, EOK);
453 adapterMock.InjectDeviceFoundEvent(&testDeviceList, 1);
454 EXPECT_TRUE(!isDeviceFound);
455
456 ret = strcpy_s(testDeviceList.networkName, sizeof(testDeviceList.networkName), "eth0");
457 EXPECT_EQ(ret, EOK);
458 adapterMock.InjectDeviceFoundEvent(&testDeviceList, 1);
459 EXPECT_TRUE(!isDeviceFound);
460
461 ret = strcpy_s(testDeviceList.networkName, sizeof(testDeviceList.networkName), "net");
462 EXPECT_EQ(ret, EOK);
463 adapterMock.InjectDeviceFoundEvent(&testDeviceList, 1);
464 EXPECT_TRUE(!isDeviceFound);
465 }
466
467 /*
468 * @tc.name: DiscCoapAdapterParseResInfo001
469 * @tc.desc: Test DiscParseReservedInfo when given different NSTACKX_DeviceInfo.reservedInfo,
470 * @tc.type: FUNC
471 * @tc.require:
472 */
473 HWTEST_F(DiscNstackxAdapterTest, DiscCoapAdapterParseResInfo001, TestSize.Level1)
474 {
475 AdapterMock adapterMock;
476 EXPECT_CALL(adapterMock, NSTACKX_Init).WillRepeatedly(AdapterMock::ActionOfNstackInit);
477
478 int32_t ret = DiscNstackxInit();
479 ASSERT_EQ(ret, SOFTBUS_OK);
480 ret = DiscCoapRegisterCb(&g_discInnerCb);
481 EXPECT_EQ(ret, SOFTBUS_OK);
482
483 NSTACKX_DeviceInfo testDeviceList;
484 testDeviceList.update = 1;
485 ret = strcpy_s(testDeviceList.deviceId, sizeof(testDeviceList.deviceId), "test");
486 EXPECT_EQ(ret, EOK);
487 adapterMock.InjectDeviceFoundEvent(&testDeviceList, 1);
488 EXPECT_TRUE(!isDeviceFound);
489
490 ret = strcpy_s(testDeviceList.deviceId, sizeof(testDeviceList.deviceId), "{\"UDID\":\"abcde\"}");
491 EXPECT_EQ(ret, EOK);
492 adapterMock.InjectDeviceFoundEvent(&testDeviceList, 1);
493 EXPECT_TRUE(!isDeviceFound);
494
495 ret = strcpy_s(testDeviceList.reservedInfo, sizeof(testDeviceList.reservedInfo), "test");
496 EXPECT_EQ(ret, EOK);
497 adapterMock.InjectDeviceFoundEvent(&testDeviceList, 1);
498 EXPECT_TRUE(!isDeviceFound);
499
500 ret = strcpy_s(testDeviceList.reservedInfo, sizeof(testDeviceList.reservedInfo), "{\"version\":\"1.0.0\"}");
501 EXPECT_EQ(ret, EOK);
502 adapterMock.InjectDeviceFoundEvent(&testDeviceList, 1);
503 EXPECT_TRUE(!isDeviceFound);
504
505 ret = strcpy_s(testDeviceList.reservedInfo, sizeof(testDeviceList.reservedInfo),
506 "{\"version\":\"1.0.0\",\"bData\":{\"nickname\":\"Jane\"}}");
507 EXPECT_EQ(ret, EOK);
508 adapterMock.InjectDeviceFoundEvent(&testDeviceList, 1);
509 EXPECT_TRUE(!isDeviceFound);
510 }
511 } // namespace OHOS