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