1 /*
2 * Copyright (c) 2021-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
18 #include <securec.h>
19 #include "bus_center_server_proxy.h"
20 #include "bus_center_server_proxy_standard.h"
21 #include "softbus_access_token_test.h"
22 #include "softbus_bus_center.h"
23 #include "softbus_def.h"
24 #include "softbus_errcode.h"
25 #include "softbus_server_frame.h"
26 #include "softbus_utils.h"
27 #include "client_bus_center_manager.h"
28
29 #define CAPABILITY_1 "capdata1"
30 #define CAPABILITY_3 "capdata3"
31 #define CAPABILITY_4 "capdata4"
32
33 namespace OHOS {
34 using namespace testing::ext;
35
36 constexpr char TEST_PKG_NAME[] = "com.softbus.test";
37 constexpr char TEST_PKG_NAME_1[] = "com.softbus.test1";
38 constexpr int32_t DEFAULT_NODE_STATE_CB_NUM = 9;
39 constexpr uint8_t DEFAULT_LOCAL_DEVICE_TYPE_ID_1 = 0;
40 constexpr uint8_t DEFAULT_LOCAL_DEVICE_TYPE_ID_2 = 14;
41 constexpr uint8_t DEFAULT_LOCAL_DEVICE_TYPE_ID_3 = 17;
42 constexpr int32_t ERRO_CAPDATA_LEN = 514;
43 static int32_t g_subscribeId = 0;
44 static int32_t g_publishId = 0;
45
46 class BusCenterSdkTest : public testing::Test {
47 public:
48 static void SetUpTestCase();
49 static void TearDownTestCase();
50 void SetUp();
51 void TearDown();
52 };
53
SetUpTestCase()54 void BusCenterSdkTest::SetUpTestCase()
55 {
56 SetAceessTokenPermission("busCenterTest");
57 }
58
TearDownTestCase()59 void BusCenterSdkTest::TearDownTestCase()
60 {
61 }
62
SetUp()63 void BusCenterSdkTest::SetUp()
64 {
65 }
66
TearDown()67 void BusCenterSdkTest::TearDown()
68 {
69 }
70
GetSubscribeId(void)71 static int32_t GetSubscribeId(void)
72 {
73 g_subscribeId++;
74 return g_subscribeId;
75 }
76
GetPublishId(void)77 static int32_t GetPublishId(void)
78 {
79 g_publishId++;
80 return g_publishId;
81 }
82
83 static SubscribeInfo g_sInfo = {
84 .subscribeId = 1,
85 .mode = DISCOVER_MODE_ACTIVE,
86 .medium = COAP,
87 .freq = MID,
88 .isSameAccount = true,
89 .isWakeRemote = false,
90 .capability = "dvKit",
91 .capabilityData = (unsigned char *)CAPABILITY_3,
92 .dataLen = strlen(CAPABILITY_3)
93 };
94
95 static PublishInfo g_pInfo = {
96 .publishId = 1,
97 .mode = DISCOVER_MODE_ACTIVE,
98 .medium = COAP,
99 .freq = MID,
100 .capability = "dvKit",
101 .capabilityData = (unsigned char *)CAPABILITY_4,
102 .dataLen = strlen(CAPABILITY_4)
103 };
104
105 static PublishInfo g_pInfo1 = {
106 .publishId = 1,
107 .mode = DISCOVER_MODE_ACTIVE,
108 .medium = COAP,
109 .freq = MID,
110 .capability = "dvKit",
111 .capabilityData = nullptr,
112 .dataLen = 0
113 };
114
115 static SubscribeInfo g_sInfo1 = {
116 .subscribeId = 1,
117 .mode = DISCOVER_MODE_ACTIVE,
118 .medium = COAP,
119 .freq = MID,
120 .isSameAccount = true,
121 .isWakeRemote = false,
122 .capability = "hicall",
123 .capabilityData = nullptr,
124 .dataLen = 0,
125 };
126
OnNodeOnline(NodeBasicInfo * info)127 static void OnNodeOnline(NodeBasicInfo *info)
128 {
129 (void)info;
130 }
131
132 static INodeStateCb g_nodeStateCb = {
133 .events = EVENT_NODE_STATE_ONLINE,
134 .onNodeOnline = OnNodeOnline,
135 };
136
OnJoinLNNDone(ConnectionAddr * addr,const char * networkId,int32_t retCode)137 static void OnJoinLNNDone(ConnectionAddr *addr, const char *networkId, int32_t retCode)
138 {
139 (void)addr;
140 (void)networkId;
141 (void)retCode;
142 }
143
OnLeaveLNNDone(const char * networkId,int32_t retCode)144 static void OnLeaveLNNDone(const char *networkId, int32_t retCode)
145 {
146 (void)networkId;
147 (void)retCode;
148 }
149
OnTimeSyncResult(const TimeSyncResultInfo * info,int32_t retCode)150 static void OnTimeSyncResult(const TimeSyncResultInfo *info, int32_t retCode)
151 {
152 (void)info;
153 (void)retCode;
154 }
155
156 static ITimeSyncCb g_timeSyncCb = {
157 .onTimeSyncResult = OnTimeSyncResult,
158 };
159
TestDeviceFound(const DeviceInfo * device)160 static void TestDeviceFound(const DeviceInfo *device)
161 {
162 printf("[client]TestDeviceFound\n");
163 }
164
TestDiscoverResult(int32_t refreshId,RefreshResult reason)165 static void TestDiscoverResult(int32_t refreshId, RefreshResult reason)
166 {
167 printf("[client]TestDiscoverResult:%d\n", reason);
168 }
169
TestPublishResult(int publishId,PublishResult reason)170 static void TestPublishResult(int publishId, PublishResult reason)
171 {
172 printf("[client]TestPublishResult:%d\n", reason);
173 }
174
175 static IRefreshCallback g_refreshCb = {
176 .OnDeviceFound = TestDeviceFound,
177 .OnDiscoverResult = TestDiscoverResult
178 };
179
180 static IPublishCb g_publishCb = {
181 .OnPublishResult = TestPublishResult
182 };
183
184 /*
185 * @tc.name: BUS_CENTER_SDK_Join_Lnn_Test_001
186 * @tc.desc: bus center JoinLNN interface exception test
187 * @tc.type: FUNC
188 * @tc.require: I5I7B9
189 */
190 HWTEST_F(BusCenterSdkTest, BUS_CENTER_SDK_Join_Lnn_Test_001, TestSize.Level0)
191 {
192 ConnectionAddr addr;
193
194 EXPECT_TRUE(JoinLNN(nullptr, &addr, OnJoinLNNDone) != SOFTBUS_OK);
195 EXPECT_TRUE(JoinLNN(TEST_PKG_NAME, nullptr, OnJoinLNNDone) != SOFTBUS_OK);
196 EXPECT_TRUE(JoinLNN(TEST_PKG_NAME, &addr, nullptr) != SOFTBUS_OK);
197 }
198
199 /*
200 * @tc.name: BUS_CENTER_SDK_Leave_Lnn_Test_001
201 * @tc.desc: bus center LeaveLNN interface exception test
202 * @tc.type: FUNC
203 * @tc.require: I5I7B9
204 */
205 HWTEST_F(BusCenterSdkTest, BUS_CENTER_SDK_Leave_Lnn_Test_001, TestSize.Level0)
206 {
207 char errNetIdLenMore[] = "012345678998765432100123456789987654321001234567899876543210abcde";
208 char networkId[] = "0123456789987654321001234567899876543210012345678998765432100123";
209
210 EXPECT_TRUE(LeaveLNN(nullptr, networkId, OnLeaveLNNDone) != SOFTBUS_OK);
211 EXPECT_TRUE(LeaveLNN(TEST_PKG_NAME, nullptr, OnLeaveLNNDone) != SOFTBUS_OK);
212 EXPECT_TRUE(LeaveLNN(TEST_PKG_NAME, networkId, nullptr) != SOFTBUS_OK);
213 EXPECT_TRUE(LeaveLNN(TEST_PKG_NAME, errNetIdLenMore, OnLeaveLNNDone) != SOFTBUS_OK);
214 }
215
216 /*
217 * @tc.name: BUS_CENTER_SDK_STATE_CB_Test_001
218 * @tc.desc: bus center node state callback reg and unreg interface test
219 * @tc.type: FUNC
220 * @tc.require: I5I7B9
221 */
222 HWTEST_F(BusCenterSdkTest, BUS_CENTER_SDK_STATE_CB_Test_001, TestSize.Level0)
223 {
224 EXPECT_TRUE(RegNodeDeviceStateCb(TEST_PKG_NAME, &g_nodeStateCb) == SOFTBUS_OK);
225 EXPECT_TRUE(UnregNodeDeviceStateCb(&g_nodeStateCb) == SOFTBUS_OK);
226 }
227
228 /*
229 * @tc.name: BUS_CENTER_SDK_STATE_CB_Test_002
230 * @tc.desc: bus center node state callback reg and unreg upper limit interface test
231 * @tc.type: FUNC
232 * @tc.require: I5I7B9
233 */
234 HWTEST_F(BusCenterSdkTest, BUS_CENTER_SDK_STATE_CB_Test_002, TestSize.Level0)
235 {
236 int i;
237
238 for (i = 0; i <= DEFAULT_NODE_STATE_CB_NUM; ++i) {
239 EXPECT_TRUE(RegNodeDeviceStateCb(TEST_PKG_NAME, &g_nodeStateCb) == SOFTBUS_OK);
240 }
241 for (i = 0; i < DEFAULT_NODE_STATE_CB_NUM; ++i) {
242 EXPECT_TRUE(UnregNodeDeviceStateCb(&g_nodeStateCb) == SOFTBUS_OK);
243 }
244 }
245
246 /*
247 * @tc.name: BUS_CENTER_SDK_GET_ALL_NODE_INFO_Test_001
248 * @tc.desc: get all node info interface test
249 * @tc.type: FUNC
250 * @tc.require: I5I7B9
251 */
252 HWTEST_F(BusCenterSdkTest, BUS_CENTER_SDK_GET_ALL_NODE_INFO_Test_001, TestSize.Level0)
253 {
254 NodeBasicInfo *info = nullptr;
255 int infoNum;
256
257 EXPECT_TRUE(GetAllNodeDeviceInfo(TEST_PKG_NAME, &info, &infoNum) == SOFTBUS_OK);
258 if (infoNum == 0) {
259 EXPECT_TRUE(info == nullptr);
260 } else {
261 EXPECT_TRUE(info != nullptr);
262 }
263 if (info != nullptr) {
264 FreeNodeInfo(info);
265 }
266 }
267
268 /*
269 * @tc.name: BUS_CENTER_SDK_GET_LOCAL_NODE_INFO_Test_001
270 * @tc.desc: get local info interface test
271 * @tc.type: FUNC
272 * @tc.require: I5I7B9
273 */
274 HWTEST_F(BusCenterSdkTest, BUS_CENTER_SDK_GET_LOCAL_NODE_INFO_Test_001, TestSize.Level0)
275 {
276 NodeBasicInfo info;
277
278 EXPECT_TRUE(GetLocalNodeDeviceInfo(TEST_PKG_NAME, &info) == SOFTBUS_OK);
279 EXPECT_TRUE(strlen(info.networkId) == (NETWORK_ID_BUF_LEN - 1));
280 EXPECT_TRUE(info.deviceTypeId == DEFAULT_LOCAL_DEVICE_TYPE_ID_1 ||
281 info.deviceTypeId == DEFAULT_LOCAL_DEVICE_TYPE_ID_2 ||
282 info.deviceTypeId == DEFAULT_LOCAL_DEVICE_TYPE_ID_3);
283 }
284
285 /*
286 * @tc.name: BUS_CENTER_SDK_GET_NODE_KEY_INFO_Test_001
287 * @tc.desc: get node key info interface test
288 * @tc.type: FUNC
289 * @tc.require: I5I7B9
290 */
291 HWTEST_F(BusCenterSdkTest, BUS_CENTER_SDK_GET_NODE_KEY_INFO_Test_001, TestSize.Level0)
292 {
293 NodeBasicInfo info;
294 NodeBasicInfo *remoteNodeInfo = nullptr;
295 int infoNum = 0;
296 char uuid[UUID_BUF_LEN] = {0};
297 char udid[UDID_BUF_LEN] = {0};
298 char brMac[BT_MAC_LEN] = {0};
299 char ipAddr[IP_STR_MAX_LEN] = {0};
300 char deviceName[DEVICE_NAME_BUF_LEN] = {0};
301 int32_t netCapacity= 0;
302 int32_t netType= 0;
303
304 (void)memset_s(&info, sizeof(NodeBasicInfo), 0, sizeof(NodeBasicInfo));
305 EXPECT_TRUE(GetLocalNodeDeviceInfo(TEST_PKG_NAME, &info) == SOFTBUS_OK);
306 EXPECT_TRUE(GetNodeKeyInfo(TEST_PKG_NAME, info.networkId, NODE_KEY_UDID,
307 (uint8_t *)udid, UDID_BUF_LEN) == SOFTBUS_OK);
308 EXPECT_TRUE(GetNodeKeyInfo(TEST_PKG_NAME, info.networkId, NODE_KEY_UUID,
309 (uint8_t *)uuid, UUID_BUF_LEN) == SOFTBUS_OK);
310 EXPECT_TRUE(strlen(uuid) == (UUID_BUF_LEN - 1));
311
312 EXPECT_TRUE(GetNodeKeyInfo(TEST_PKG_NAME, info.networkId, NODE_KEY_BR_MAC,
313 (uint8_t *)brMac, BT_MAC_LEN) == SOFTBUS_OK);
314 EXPECT_TRUE(GetNodeKeyInfo(TEST_PKG_NAME, info.networkId, NODE_KEY_IP_ADDRESS,
315 (uint8_t *)ipAddr, IP_STR_MAX_LEN) == SOFTBUS_OK);
316 EXPECT_TRUE(GetNodeKeyInfo(TEST_PKG_NAME, info.networkId, NODE_KEY_DEV_NAME,
317 (uint8_t *)deviceName, DEVICE_NAME_BUF_LEN) == SOFTBUS_OK);
318 EXPECT_TRUE(GetNodeKeyInfo(TEST_PKG_NAME, info.networkId, NODE_KEY_NETWORK_CAPABILITY,
319 (uint8_t *)&netCapacity, LNN_COMMON_LEN) == SOFTBUS_OK);
320 EXPECT_TRUE(GetNodeKeyInfo(TEST_PKG_NAME, info.networkId, NODE_KEY_NETWORK_TYPE,
321 (uint8_t *)&netType, LNN_COMMON_LEN) == SOFTBUS_OK);
322
323 EXPECT_TRUE(GetAllNodeDeviceInfo(TEST_PKG_NAME, &remoteNodeInfo, &infoNum) == SOFTBUS_OK);
324 for (int i = 0; i < infoNum; i++) {
325 EXPECT_TRUE(GetNodeKeyInfo(TEST_PKG_NAME, (remoteNodeInfo + i)->networkId, NODE_KEY_BR_MAC,
326 (uint8_t *)brMac, BT_MAC_LEN) == SOFTBUS_OK);
327 EXPECT_TRUE(GetNodeKeyInfo(TEST_PKG_NAME, (remoteNodeInfo + i)->networkId, NODE_KEY_IP_ADDRESS,
328 (uint8_t *)ipAddr, IP_STR_MAX_LEN) == SOFTBUS_OK);
329 EXPECT_TRUE(GetNodeKeyInfo(TEST_PKG_NAME, (remoteNodeInfo + i)->networkId, NODE_KEY_DEV_NAME,
330 (uint8_t *)deviceName, DEVICE_NAME_BUF_LEN) == SOFTBUS_OK);
331 EXPECT_TRUE(GetNodeKeyInfo(TEST_PKG_NAME, (remoteNodeInfo + i)->networkId, NODE_KEY_NETWORK_CAPABILITY,
332 (uint8_t *)&netCapacity, LNN_COMMON_LEN) == SOFTBUS_OK);
333 EXPECT_TRUE(GetNodeKeyInfo(TEST_PKG_NAME, (remoteNodeInfo + i)->networkId, NODE_KEY_NETWORK_TYPE,
334 (uint8_t *)&netType, LNN_COMMON_LEN) == SOFTBUS_OK);
335 }
336 FreeNodeInfo(remoteNodeInfo);
337 }
338
339 /*
340 * @tc.name: BUS_CENTER_SDK_GET_NODE_KEY_INFO_Test_002
341 * @tc.desc: get node key info(screen status) interface test
342 * @tc.type: FUNC
343 * @tc.require: I5I7B9
344 */
345 HWTEST_F(BusCenterSdkTest, BUS_CENTER_SDK_GET_NODE_KEY_INFO_Test_002, TestSize.Level0)
346 {
347 NodeBasicInfo info;
348 NodeBasicInfo *remoteNodeInfo = nullptr;
349 int32_t infoNum = 0;
350 bool isScreenOn = false;
351 (void)memset_s(&info, sizeof(NodeBasicInfo), 0, sizeof(NodeBasicInfo));
352 EXPECT_TRUE(GetLocalNodeDeviceInfo(TEST_PKG_NAME, &info) == SOFTBUS_OK);
353 EXPECT_TRUE(GetAllNodeDeviceInfo(TEST_PKG_NAME, &remoteNodeInfo, &infoNum) == SOFTBUS_OK);
354 for (int32_t i = 0; i < infoNum; i++) {
355 EXPECT_TRUE(GetNodeKeyInfo(TEST_PKG_NAME, (remoteNodeInfo + i)->networkId, NODE_KEY_DEVICE_SCREEN_STATUS,
356 (uint8_t*)&isScreenOn, DATA_DEVICE_SCREEN_STATUS_LEN) == SOFTBUS_OK);
357 }
358 FreeNodeInfo(remoteNodeInfo);
359 }
360
361 /*
362 * @tc.name: BUS_CENTER_SDK_START_TIME_SYNC_Test_001
363 * @tc.desc: start time sync interface test
364 * @tc.type: FUNC
365 * @tc.require: I5I7B9
366 */
367 HWTEST_F(BusCenterSdkTest, BUS_CENTER_SDK_START_TIME_SYNC_Test_001, TestSize.Level0)
368 {
369 char networkId[] = "0123456789987654321001234567899876543210012345678998765432100123";
370
371 EXPECT_TRUE(StartTimeSync(nullptr, networkId, LOW_ACCURACY, SHORT_PERIOD, &g_timeSyncCb) != SOFTBUS_OK);
372 EXPECT_TRUE(StartTimeSync(TEST_PKG_NAME, nullptr, LOW_ACCURACY, SHORT_PERIOD, &g_timeSyncCb) != SOFTBUS_OK);
373 EXPECT_TRUE(StartTimeSync(TEST_PKG_NAME, networkId, LOW_ACCURACY, SHORT_PERIOD, &g_timeSyncCb) != SOFTBUS_OK);
374 EXPECT_TRUE(StartTimeSync(TEST_PKG_NAME, networkId, LOW_ACCURACY, SHORT_PERIOD, nullptr) != SOFTBUS_OK);
375 }
376
377 /*
378 * @tc.name: BUS_CENTER_SDK_START_TIME_SYNC_Test_002
379 * @tc.desc: start time sync interface test
380 * @tc.type: FUNC
381 * @tc.require: I5I7B9
382 */
383 HWTEST_F(BusCenterSdkTest, BUS_CENTER_SDK_START_TIME_SYNC_Test_002, TestSize.Level0)
384 {
385 char networkId[] = "0123456789987654321001234567899876543210012345678998765432100123";
386
387 EXPECT_TRUE(StopTimeSync(nullptr, networkId) != SOFTBUS_OK);
388 EXPECT_TRUE(StopTimeSync(TEST_PKG_NAME, nullptr) != SOFTBUS_OK);
389 EXPECT_TRUE(StopTimeSync(TEST_PKG_NAME, networkId) != SOFTBUS_OK);
390 }
391
392 /**
393 * @tc.name: PublishLNNTest001
394 * @tc.desc: Verify wrong parameter
395 * @tc.type: FUNC
396 * @tc.require: I5I7B9
397 */
398 HWTEST_F(BusCenterSdkTest, PublishLNNTest001, TestSize.Level0)
399 {
400 int32_t ret = PublishLNN(nullptr, &g_pInfo, &g_publishCb);
401 EXPECT_TRUE(ret != 0);
402
403 ret = PublishLNN(TEST_PKG_NAME, nullptr, &g_publishCb);
404 EXPECT_TRUE(ret != 0);
405
406 ret = PublishLNN(TEST_PKG_NAME, &g_pInfo, nullptr);
407 EXPECT_TRUE(ret != 0);
408
409 g_pInfo.medium = (ExchangeMedium)(COAP + 1);
410 ret = PublishLNN(TEST_PKG_NAME, &g_pInfo, &g_publishCb);
411 EXPECT_TRUE(ret != 0);
412 g_pInfo.medium = COAP;
413
414 g_pInfo.mode = (DiscoverMode)(DISCOVER_MODE_ACTIVE + 1);
415 ret = PublishLNN(TEST_PKG_NAME, &g_pInfo, &g_publishCb);
416 EXPECT_TRUE(ret != 0);
417 g_pInfo.mode = DISCOVER_MODE_ACTIVE;
418
419 g_pInfo.freq = (ExchangeFreq)(FREQ_BUTT);
420 ret = PublishLNN(TEST_PKG_NAME, &g_pInfo, &g_publishCb);
421 EXPECT_TRUE(ret != 0);
422 g_pInfo.freq = LOW;
423
424 g_pInfo.capabilityData = nullptr;
425 ret = PublishLNN(TEST_PKG_NAME, &g_pInfo, &g_publishCb);
426 EXPECT_TRUE(ret != 0);
427 g_pInfo.capabilityData = (unsigned char *)CAPABILITY_1;
428
429 g_pInfo.dataLen = ERRO_CAPDATA_LEN;
430 ret = PublishLNN(TEST_PKG_NAME, &g_pInfo, &g_publishCb);
431 EXPECT_TRUE(ret != 0);
432 g_pInfo.dataLen = strlen(CAPABILITY_1);
433 }
434
435 /**
436 * @tc.name: PublishLNNTest002
437 * @tc.desc: Verify normal case
438 * @tc.type: FUNC
439 * @tc.require: I5I7B9 I5PTUS
440 */
441 HWTEST_F(BusCenterSdkTest, PublishLNNTest002, TestSize.Level0)
442 {
443 int32_t ret;
444 int tmpId1 = GetPublishId();
445 int tmpId2 = GetPublishId();
446 int tmpId3 = GetPublishId();
447 NodeBasicInfo info;
448 char localIp[IP_LEN] = {0};
449 char loopBackIpAddr[] = "127.0.0.1";
450 char invalidIpAddr[] = "0.0.0.0";
451 (void)memset_s(&info, sizeof(NodeBasicInfo), 0, sizeof(NodeBasicInfo));
452 EXPECT_TRUE(GetLocalNodeDeviceInfo(TEST_PKG_NAME, &info) == SOFTBUS_OK);
453 EXPECT_TRUE(GetNodeKeyInfo(TEST_PKG_NAME, info.networkId, NODE_KEY_IP_ADDRESS,
454 (uint8_t *)localIp, IP_LEN) == SOFTBUS_OK);
455 if (strcmp(localIp, loopBackIpAddr) != 0 &&
456 strcmp(localIp, invalidIpAddr) != 0 &&
457 strcmp(localIp, "") != 0) {
458 g_pInfo.publishId = tmpId1;
459 ret = PublishLNN(TEST_PKG_NAME, &g_pInfo, &g_publishCb);
460 EXPECT_TRUE(ret == SOFTBUS_OK);
461 g_pInfo1.publishId = tmpId2;
462 ret = PublishLNN(TEST_PKG_NAME, &g_pInfo1, &g_publishCb);
463 EXPECT_TRUE(ret == SOFTBUS_OK);
464 g_pInfo1.publishId = tmpId3;
465 ret = PublishLNN(TEST_PKG_NAME_1, &g_pInfo1, &g_publishCb);
466 EXPECT_TRUE(ret == SOFTBUS_OK);
467 ret = StopPublishLNN(TEST_PKG_NAME, tmpId1);
468 EXPECT_TRUE(ret == SOFTBUS_OK);
469 ret = StopPublishLNN(TEST_PKG_NAME, tmpId2);
470 EXPECT_TRUE(ret == SOFTBUS_OK);
471 ret = StopPublishLNN(TEST_PKG_NAME_1, tmpId3);
472 EXPECT_TRUE(ret == SOFTBUS_OK);
473 }
474 }
475
476 /**
477 * @tc.name: RefreshLNNTest001
478 * @tc.desc: Verify wrong parameter
479 * @tc.type: FUNC
480 * @tc.require: I5I7B9
481 */
482 HWTEST_F(BusCenterSdkTest, RefreshLNNTest001, TestSize.Level0)
483 {
484 int ret;
485
486 ret = RefreshLNN(nullptr, &g_sInfo, &g_refreshCb);
487 EXPECT_TRUE(ret != 0);
488
489 ret = RefreshLNN(TEST_PKG_NAME, nullptr, &g_refreshCb);
490 EXPECT_TRUE(ret != 0);
491
492 ret = RefreshLNN(TEST_PKG_NAME, &g_sInfo, nullptr);
493 EXPECT_TRUE(ret != 0);
494
495 g_sInfo.medium = (ExchangeMedium)(COAP + 1);
496 ret = RefreshLNN(TEST_PKG_NAME, &g_sInfo, &g_refreshCb);
497 EXPECT_TRUE(ret != 0);
498 g_sInfo.medium = COAP;
499
500 g_sInfo.mode = (DiscoverMode)(DISCOVER_MODE_ACTIVE + 1);
501 ret = RefreshLNN(TEST_PKG_NAME, &g_sInfo, &g_refreshCb);
502 EXPECT_TRUE(ret != 0);
503 g_sInfo.mode = DISCOVER_MODE_ACTIVE;
504
505 g_sInfo.freq = (ExchangeFreq)(FREQ_BUTT);
506 ret = RefreshLNN(TEST_PKG_NAME, &g_sInfo, &g_refreshCb);
507 EXPECT_TRUE(ret != 0);
508 g_sInfo.freq = LOW;
509
510 g_sInfo.capabilityData = nullptr;
511 ret = RefreshLNN(TEST_PKG_NAME, &g_sInfo, &g_refreshCb);
512 EXPECT_TRUE(ret != 0);
513 g_sInfo.capabilityData = (unsigned char *)CAPABILITY_1;
514
515 g_sInfo.dataLen = ERRO_CAPDATA_LEN;
516 ret = RefreshLNN(TEST_PKG_NAME, &g_sInfo, &g_refreshCb);
517 EXPECT_TRUE(ret != 0);
518 g_sInfo.dataLen = strlen(CAPABILITY_1);
519 }
520
521 /**
522 * @tc.name: RefreshLNNTest002
523 * @tc.desc: Verify normal case
524 * @tc.type: FUNC
525 * @tc.require: I5I7B9 I5PTUS
526 */
527 HWTEST_F(BusCenterSdkTest, RefreshLNNTest002, TestSize.Level0)
528 {
529 int32_t ret;
530 int tmpId1 = GetSubscribeId();
531 int tmpId2 = GetSubscribeId();
532 int tmpId3 = GetSubscribeId();
533 NodeBasicInfo info;
534 char localIp[IP_LEN] = {0};
535 char loopBackIpAddr[] = "127.0.0.1";
536 char invalidIpAddr[] = "0.0.0.0";
537 (void)memset_s(&info, sizeof(NodeBasicInfo), 0, sizeof(NodeBasicInfo));
538 EXPECT_TRUE(GetLocalNodeDeviceInfo(TEST_PKG_NAME, &info) == SOFTBUS_OK);
539 EXPECT_TRUE(GetNodeKeyInfo(TEST_PKG_NAME, info.networkId, NODE_KEY_IP_ADDRESS,
540 (uint8_t *)localIp, IP_LEN) == SOFTBUS_OK);
541 if (strcmp(localIp, loopBackIpAddr) != 0 &&
542 strcmp(localIp, invalidIpAddr) != 0 &&
543 strcmp(localIp, "") != 0) {
544 g_sInfo.subscribeId = tmpId1;
545 ret = RefreshLNN(TEST_PKG_NAME, &g_sInfo, &g_refreshCb);
546 EXPECT_TRUE(ret == SOFTBUS_OK);
547 g_sInfo1.subscribeId = tmpId2;
548 ret = RefreshLNN(TEST_PKG_NAME, &g_sInfo1, &g_refreshCb);
549 EXPECT_TRUE(ret == SOFTBUS_OK);
550 g_sInfo1.subscribeId = tmpId3;
551 ret = RefreshLNN(TEST_PKG_NAME_1, &g_sInfo1, &g_refreshCb);
552 EXPECT_TRUE(ret == SOFTBUS_OK);
553 ret = StopRefreshLNN(TEST_PKG_NAME, tmpId1);
554 EXPECT_TRUE(ret == SOFTBUS_OK);
555 ret = StopRefreshLNN(TEST_PKG_NAME, tmpId2);
556 EXPECT_TRUE(ret == SOFTBUS_OK);
557 ret = StopRefreshLNN(TEST_PKG_NAME_1, tmpId3);
558 EXPECT_TRUE(ret == SOFTBUS_OK);
559 }
560 }
561
562 /**
563 * @tc.name: SET_NODE_DATA_CHANGE_FLAG_INNER_Test001
564 * @tc.desc: Set Node Data Change Flag Inner
565 * @tc.type: FUNC
566 * @tc.require:
567 */
568 HWTEST_F(BusCenterSdkTest, SET_NODE_DATA_CHANGE_FLAG_INNER_Test001, TestSize.Level0)
569 {
570 char pkgName[] = "test";
571 char *networkId = nullptr;
572 uint16_t dataChangeFlag = 0;
573 int32_t ret = SetNodeDataChangeFlagInner(pkgName, networkId, dataChangeFlag);
574 EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
575 }
576
577 /*
578 * @tc.name: SERVER_IPC_SET_NODE_DATA_CHANGE_FLAG_Test001
579 * @tc.desc: ServerIpcSetNodeDataChangeFlag Result
580 * @tc.type: FUNC
581 * @tc.require:
582 */
583 HWTEST_F(BusCenterSdkTest, SERVER_IPC_SET_NODE_DATA_CHANGE_FLAG_Test001, TestSize.Level1)
584 {
585 char pkgName[] = "test";
586 char *networkId1 = nullptr;
587 uint16_t dataChangeFlag = false;
588 BusCenterServerProxyInit();
589 int32_t ret = ServerIpcSetNodeDataChangeFlag(pkgName, networkId1, dataChangeFlag);
590 EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
591 }
592
593 /*
594 * @tc.name: SERVER_IPC_SET_NODE_DATA_CHANGE_Test001
595 * @tc.desc: Meta Node On Leave Result
596 * @tc.type: FUNC
597 * @tc.require:
598 */
599 HWTEST_F(BusCenterSdkTest, SERVER_IPC_SET_NODE_DATA_CHANGE_Test002, TestSize.Level1)
600 {
601 BusCenterServerProxyInit();
602 char pkgName[] = "pkgname";
603 char networkId[] = "12313";
604 uint16_t dataChangeFlag = 11;
605 int32_t ret = ServerIpcSetNodeDataChangeFlag(pkgName, networkId, dataChangeFlag);
606 EXPECT_TRUE(ret == SOFTBUS_ERR);
607 }
608
609 } // namespace OHOS
610