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 #include <securec.h>
18
19 #include "bus_center_server_proxy.h"
20 #include "bus_center_server_proxy_standard.h"
21 #include "client_bus_center_manager.h"
22 #include "softbus_access_token_test.h"
23 #include "softbus_bus_center.h"
24 #include "softbus_def.h"
25 #include "softbus_error_code.h"
26 #include "softbus_server_frame.h"
27 #include "softbus_utils.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 char TEST_MSDP_NAME[] = "ohos.msdp.spatialawareness";
39 constexpr int32_t DEFAULT_NODE_STATE_CB_NUM = 9;
40 constexpr uint8_t DEFAULT_LOCAL_DEVICE_TYPE_ID_1 = 0;
41 constexpr uint8_t DEFAULT_LOCAL_DEVICE_TYPE_ID_2 = 14;
42 constexpr uint8_t DEFAULT_LOCAL_DEVICE_TYPE_ID_3 = 17;
43 constexpr int32_t ERRO_CAPDATA_LEN = 514;
44 static int32_t g_subscribeId = 0;
45 static int32_t g_publishId = 0;
46
47 class BusCenterSdkTest : public testing::Test {
48 public:
49 static void SetUpTestCase();
50 static void TearDownTestCase();
51 void SetUp();
52 void TearDown();
53 };
54
SetUpTestCase()55 void BusCenterSdkTest::SetUpTestCase()
56 {
57 SetAccessTokenPermission("busCenterTest");
58 }
59
TearDownTestCase()60 void BusCenterSdkTest::TearDownTestCase() { }
61
SetUp()62 void BusCenterSdkTest::SetUp() { }
63
TearDown()64 void BusCenterSdkTest::TearDown() { }
65
GetSubscribeId(void)66 static int32_t GetSubscribeId(void)
67 {
68 g_subscribeId++;
69 return g_subscribeId;
70 }
71
GetPublishId(void)72 static int32_t GetPublishId(void)
73 {
74 g_publishId++;
75 return g_publishId;
76 }
77
78 static SubscribeInfo g_sInfo = { .subscribeId = 1,
79 .mode = DISCOVER_MODE_ACTIVE,
80 .medium = COAP,
81 .freq = MID,
82 .isSameAccount = true,
83 .isWakeRemote = false,
84 .capability = "dvKit",
85 .capabilityData = (unsigned char *)CAPABILITY_3,
86 .dataLen = strlen(CAPABILITY_3) };
87
88 static PublishInfo g_pInfo = { .publishId = 1,
89 .mode = DISCOVER_MODE_ACTIVE,
90 .medium = COAP,
91 .freq = MID,
92 .capability = "dvKit",
93 .capabilityData = (unsigned char *)CAPABILITY_4,
94 .dataLen = strlen(CAPABILITY_4) };
95
96 static PublishInfo g_pInfo1 = { .publishId = 1,
97 .mode = DISCOVER_MODE_ACTIVE,
98 .medium = COAP,
99 .freq = MID,
100 .capability = "dvKit",
101 .capabilityData = nullptr,
102 .dataLen = 0 };
103
104 static SubscribeInfo g_sInfo1 = {
105 .subscribeId = 1,
106 .mode = DISCOVER_MODE_ACTIVE,
107 .medium = COAP,
108 .freq = MID,
109 .isSameAccount = true,
110 .isWakeRemote = false,
111 .capability = "hicall",
112 .capabilityData = nullptr,
113 .dataLen = 0,
114 };
115
OnNodeOnline(NodeBasicInfo * info)116 static void OnNodeOnline(NodeBasicInfo *info)
117 {
118 (void)info;
119 }
120
121 static INodeStateCb g_nodeStateCb = {
122 .events = EVENT_NODE_STATE_ONLINE,
123 .onNodeOnline = OnNodeOnline,
124 };
125
OnJoinLNNDone(ConnectionAddr * addr,const char * networkId,int32_t retCode)126 static void OnJoinLNNDone(ConnectionAddr *addr, const char *networkId, int32_t retCode)
127 {
128 (void)addr;
129 (void)networkId;
130 (void)retCode;
131 }
132
OnLeaveLNNDone(const char * networkId,int32_t retCode)133 static void OnLeaveLNNDone(const char *networkId, int32_t retCode)
134 {
135 (void)networkId;
136 (void)retCode;
137 }
138
OnTimeSyncResult(const TimeSyncResultInfo * info,int32_t retCode)139 static void OnTimeSyncResult(const TimeSyncResultInfo *info, int32_t retCode)
140 {
141 (void)info;
142 (void)retCode;
143 }
144
145 static ITimeSyncCb g_timeSyncCb = {
146 .onTimeSyncResult = OnTimeSyncResult,
147 };
148
TestDeviceFound(const DeviceInfo * device)149 static void TestDeviceFound(const DeviceInfo *device)
150 {
151 printf("[client]TestDeviceFound\n");
152 }
153
TestDiscoverResult(int32_t refreshId,RefreshResult reason)154 static void TestDiscoverResult(int32_t refreshId, RefreshResult reason)
155 {
156 printf("[client]TestDiscoverResult:%d\n", reason);
157 }
158
TestPublishResult(int32_t publishId,PublishResult reason)159 static void TestPublishResult(int32_t publishId, PublishResult reason)
160 {
161 printf("[client]TestPublishResult:%d\n", reason);
162 }
163
164 static IRefreshCallback g_refreshCb = { .OnDeviceFound = TestDeviceFound, .OnDiscoverResult = TestDiscoverResult };
165
166 static IPublishCb g_publishCb = { .OnPublishResult = TestPublishResult };
167
OnDataLevelChanged(const char * networkId,const DataLevel dataLevel)168 static void OnDataLevelChanged(const char *networkId, const DataLevel dataLevel)
169 {
170 (void)networkId;
171 (void)dataLevel;
172 }
173
OnBleRangeDone(const BleRangeInfo * info)174 static void OnBleRangeDone(const BleRangeInfo *info)
175 {
176 (void)info;
177 }
178
179 static IDataLevelCb g_dataLevelCb = { .onDataLevelChanged = OnDataLevelChanged };
180 static IBleRangeCb g_bleRangeCb = { .onBleRangeInfoReceived = OnBleRangeDone };
181 static IBleRangeCb g_bleRangeCb1 = { .onBleRangeInfoReceived = nullptr };
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, false) != SOFTBUS_OK);
194 EXPECT_TRUE(JoinLNN(TEST_PKG_NAME, nullptr, OnJoinLNNDone, false) != SOFTBUS_OK);
195 EXPECT_TRUE(JoinLNN(TEST_PKG_NAME, &addr, nullptr, false) != 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 int32_t 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_STATE_CB_Test_003
247 * @tc.desc: bus center node state callback reg param check
248 * @tc.type: FUNC
249 * @tc.require: I5I7B9
250 */
251 HWTEST_F(BusCenterSdkTest, BUS_CENTER_SDK_STATE_CB_Test_003, TestSize.Level0)
252 {
253 EXPECT_EQ(RegNodeDeviceStateCb(nullptr, &g_nodeStateCb), SOFTBUS_INVALID_PARAM);
254 EXPECT_EQ(RegNodeDeviceStateCb(TEST_PKG_NAME, nullptr), SOFTBUS_INVALID_PARAM);
255 EXPECT_EQ(UnregNodeDeviceStateCb(nullptr), SOFTBUS_INVALID_PARAM);
256
257 INodeStateCb nodeStateCb = {};
258 nodeStateCb.events = 0;
259 EXPECT_EQ(RegNodeDeviceStateCb(TEST_PKG_NAME, nullptr), SOFTBUS_INVALID_PARAM);
260 nodeStateCb.events = EVENT_NODE_STATE_ONLINE;
261 EXPECT_EQ(RegNodeDeviceStateCb(TEST_PKG_NAME, nullptr), SOFTBUS_INVALID_PARAM);
262 nodeStateCb.events = EVENT_NODE_STATE_ONLINE;
263 nodeStateCb.onNodeOnline = OnNodeOnline;
264 EXPECT_EQ(RegNodeDeviceStateCb(TEST_PKG_NAME, &nodeStateCb), SOFTBUS_OK);
265
266 nodeStateCb.events = EVENT_NODE_STATE_OFFLINE;
267 EXPECT_EQ(RegNodeDeviceStateCb(TEST_PKG_NAME, nullptr), SOFTBUS_INVALID_PARAM);
268 nodeStateCb.events = EVENT_NODE_STATE_INFO_CHANGED;
269 EXPECT_EQ(RegNodeDeviceStateCb(TEST_PKG_NAME, nullptr), SOFTBUS_INVALID_PARAM);
270 nodeStateCb.events = EVENT_NODE_STATUS_CHANGED;
271 EXPECT_EQ(RegNodeDeviceStateCb(TEST_PKG_NAME, nullptr), SOFTBUS_INVALID_PARAM);
272 nodeStateCb.events = EVENT_NODE_HICHAIN_PROOF_EXCEPTION;
273 EXPECT_EQ(RegNodeDeviceStateCb(TEST_PKG_NAME, nullptr), SOFTBUS_INVALID_PARAM);
274 nodeStateCb.events = EVENT_NODE_STATE_ONLINE & EVENT_NODE_HICHAIN_PROOF_EXCEPTION;
275 EXPECT_EQ(RegNodeDeviceStateCb(TEST_PKG_NAME, nullptr), SOFTBUS_INVALID_PARAM);
276 }
277
278 /*
279 * @tc.name: BUS_CENTER_SDK_GET_ALL_NODE_INFO_Test_001
280 * @tc.desc: get all node info interface test
281 * @tc.type: FUNC
282 * @tc.require: I5I7B9
283 */
284 HWTEST_F(BusCenterSdkTest, BUS_CENTER_SDK_GET_ALL_NODE_INFO_Test_001, TestSize.Level0)
285 {
286 NodeBasicInfo *info = nullptr;
287 int32_t infoNum;
288
289 EXPECT_EQ(GetAllNodeDeviceInfo(nullptr, &info, &infoNum), SOFTBUS_INVALID_PARAM);
290 EXPECT_EQ(GetAllNodeDeviceInfo(TEST_PKG_NAME, nullptr, &infoNum), SOFTBUS_INVALID_PARAM);
291 EXPECT_EQ(GetAllNodeDeviceInfo(TEST_PKG_NAME, &info, nullptr), SOFTBUS_INVALID_PARAM);
292 EXPECT_EQ(GetAllNodeDeviceInfo(TEST_PKG_NAME, &info, &infoNum), SOFTBUS_OK);
293 if (infoNum == 0) {
294 EXPECT_TRUE(info == nullptr);
295 } else {
296 EXPECT_TRUE(info != nullptr);
297 }
298 if (info != nullptr) {
299 FreeNodeInfo(info);
300 }
301 }
302
303 /*
304 * @tc.name: BUS_CENTER_SDK_GET_LOCAL_NODE_INFO_Test_001
305 * @tc.desc: get local info interface test
306 * @tc.type: FUNC
307 * @tc.require: I5I7B9
308 */
309 HWTEST_F(BusCenterSdkTest, BUS_CENTER_SDK_GET_LOCAL_NODE_INFO_Test_001, TestSize.Level0)
310 {
311 NodeBasicInfo info;
312
313 EXPECT_EQ(GetLocalNodeDeviceInfo(nullptr, &info), SOFTBUS_INVALID_PARAM);
314 EXPECT_EQ(GetLocalNodeDeviceInfo(TEST_PKG_NAME, nullptr), SOFTBUS_INVALID_PARAM);
315 EXPECT_EQ(GetLocalNodeDeviceInfo(TEST_PKG_NAME, &info), SOFTBUS_OK);
316 EXPECT_EQ(strlen(info.networkId), (NETWORK_ID_BUF_LEN - 1));
317 EXPECT_TRUE(info.deviceTypeId == DEFAULT_LOCAL_DEVICE_TYPE_ID_1 ||
318 info.deviceTypeId == DEFAULT_LOCAL_DEVICE_TYPE_ID_2 || info.deviceTypeId == DEFAULT_LOCAL_DEVICE_TYPE_ID_3);
319 }
320
321 /*
322 * @tc.name: BUS_CENTER_SDK_GET_NODE_KEY_INFO_Test_001
323 * @tc.desc: get node key info interface test
324 * @tc.type: FUNC
325 * @tc.require: I5I7B9
326 */
327 HWTEST_F(BusCenterSdkTest, BUS_CENTER_SDK_GET_NODE_KEY_INFO_Test_001, TestSize.Level0)
328 {
329 NodeBasicInfo info;
330 NodeBasicInfo *remoteNodeInfo = nullptr;
331 int32_t infoNum = 0;
332 char uuid[UUID_BUF_LEN] = { 0 };
333 char udid[UDID_BUF_LEN] = { 0 };
334 char brMac[BT_MAC_LEN] = { 0 };
335 char ipAddr[IP_STR_MAX_LEN] = { 0 };
336 char deviceName[DEVICE_NAME_BUF_LEN] = { 0 };
337 int32_t netCapacity = 0;
338 int32_t netType = 0;
339
340 (void)memset_s(&info, sizeof(NodeBasicInfo), 0, sizeof(NodeBasicInfo));
341 EXPECT_TRUE(GetLocalNodeDeviceInfo(TEST_PKG_NAME, &info) == SOFTBUS_OK);
342 EXPECT_TRUE(
343 GetNodeKeyInfo(nullptr, info.networkId, NODE_KEY_UDID, (uint8_t *)udid, UDID_BUF_LEN) == SOFTBUS_INVALID_PARAM);
344 EXPECT_TRUE(
345 GetNodeKeyInfo(TEST_PKG_NAME, info.networkId, NODE_KEY_UDID, (uint8_t *)udid, 0) == SOFTBUS_INVALID_PARAM);
346 EXPECT_TRUE(
347 GetNodeKeyInfo(TEST_PKG_NAME, info.networkId, NODE_KEY_UDID, (uint8_t *)udid, UDID_BUF_LEN) == SOFTBUS_OK);
348 EXPECT_TRUE(
349 GetNodeKeyInfo(TEST_PKG_NAME, info.networkId, NODE_KEY_UUID, (uint8_t *)uuid, UUID_BUF_LEN) == SOFTBUS_OK);
350 EXPECT_TRUE(strlen(uuid) == (UUID_BUF_LEN - 1));
351
352 EXPECT_TRUE(
353 GetNodeKeyInfo(TEST_PKG_NAME, info.networkId, NODE_KEY_BR_MAC, (uint8_t *)brMac, BT_MAC_LEN) == SOFTBUS_OK);
354 EXPECT_TRUE(GetNodeKeyInfo(TEST_PKG_NAME, info.networkId, NODE_KEY_IP_ADDRESS, (uint8_t *)ipAddr, IP_STR_MAX_LEN) ==
355 SOFTBUS_OK);
356 EXPECT_TRUE(GetNodeKeyInfo(TEST_PKG_NAME, info.networkId, NODE_KEY_DEV_NAME, (uint8_t *)deviceName,
357 DEVICE_NAME_BUF_LEN) == SOFTBUS_OK);
358 EXPECT_TRUE(GetNodeKeyInfo(TEST_PKG_NAME, info.networkId, NODE_KEY_NETWORK_CAPABILITY, (uint8_t *)&netCapacity,
359 LNN_COMMON_LEN) == SOFTBUS_OK);
360 EXPECT_TRUE(GetNodeKeyInfo(TEST_PKG_NAME, info.networkId, NODE_KEY_NETWORK_TYPE, (uint8_t *)&netType,
361 LNN_COMMON_LEN) == SOFTBUS_OK);
362
363 EXPECT_TRUE(GetAllNodeDeviceInfo(TEST_PKG_NAME, &remoteNodeInfo, &infoNum) == SOFTBUS_OK);
364 for (int32_t i = 0; i < infoNum; i++) {
365 EXPECT_TRUE(GetNodeKeyInfo(TEST_PKG_NAME, (remoteNodeInfo + i)->networkId, NODE_KEY_BR_MAC, (uint8_t *)brMac,
366 BT_MAC_LEN) == SOFTBUS_OK);
367 EXPECT_TRUE(GetNodeKeyInfo(TEST_PKG_NAME, (remoteNodeInfo + i)->networkId, NODE_KEY_IP_ADDRESS,
368 (uint8_t *)ipAddr, IP_STR_MAX_LEN) == SOFTBUS_OK);
369 EXPECT_TRUE(GetNodeKeyInfo(TEST_PKG_NAME, (remoteNodeInfo + i)->networkId, NODE_KEY_DEV_NAME,
370 (uint8_t *)deviceName, DEVICE_NAME_BUF_LEN) == SOFTBUS_OK);
371 EXPECT_TRUE(GetNodeKeyInfo(TEST_PKG_NAME, (remoteNodeInfo + i)->networkId, NODE_KEY_NETWORK_CAPABILITY,
372 (uint8_t *)&netCapacity, LNN_COMMON_LEN) == SOFTBUS_OK);
373 EXPECT_TRUE(GetNodeKeyInfo(TEST_PKG_NAME, (remoteNodeInfo + i)->networkId, NODE_KEY_NETWORK_TYPE,
374 (uint8_t *)&netType, LNN_COMMON_LEN) == SOFTBUS_OK);
375 }
376 FreeNodeInfo(remoteNodeInfo);
377 }
378
379 /*
380 * @tc.name: BUS_CENTER_SDK_GET_NODE_KEY_INFO_Test_002
381 * @tc.desc: get node key info(screen status) interface test
382 * @tc.type: FUNC
383 * @tc.require: I5I7B9
384 */
385 HWTEST_F(BusCenterSdkTest, BUS_CENTER_SDK_GET_NODE_KEY_INFO_Test_002, TestSize.Level0)
386 {
387 NodeBasicInfo info;
388 NodeBasicInfo *remoteNodeInfo = nullptr;
389 int32_t infoNum = 0;
390 bool isScreenOn = false;
391 (void)memset_s(&info, sizeof(NodeBasicInfo), 0, sizeof(NodeBasicInfo));
392 EXPECT_TRUE(GetLocalNodeDeviceInfo(TEST_PKG_NAME, &info) == SOFTBUS_OK);
393 EXPECT_TRUE(GetAllNodeDeviceInfo(TEST_PKG_NAME, &remoteNodeInfo, &infoNum) == SOFTBUS_OK);
394 for (int32_t i = 0; i < infoNum; i++) {
395 EXPECT_TRUE(GetNodeKeyInfo(TEST_PKG_NAME, (remoteNodeInfo + i)->networkId, NODE_KEY_DEVICE_SCREEN_STATUS,
396 (uint8_t *)&isScreenOn, DATA_DEVICE_SCREEN_STATUS_LEN) == SOFTBUS_OK);
397 }
398 FreeNodeInfo(remoteNodeInfo);
399 }
400
401 /*
402 * @tc.name: BUS_CENTER_SDK_START_TIME_SYNC_Test_001
403 * @tc.desc: start time sync interface test
404 * @tc.type: FUNC
405 * @tc.require: I5I7B9
406 */
407 HWTEST_F(BusCenterSdkTest, BUS_CENTER_SDK_START_TIME_SYNC_Test_001, TestSize.Level0)
408 {
409 char networkId[] = "0123456789987654321001234567899876543210012345678998765432100123";
410
411 EXPECT_TRUE(StartTimeSync(nullptr, networkId, LOW_ACCURACY, SHORT_PERIOD, &g_timeSyncCb) != SOFTBUS_OK);
412 EXPECT_TRUE(StartTimeSync(TEST_PKG_NAME, nullptr, LOW_ACCURACY, SHORT_PERIOD, &g_timeSyncCb) != SOFTBUS_OK);
413 EXPECT_TRUE(StartTimeSync(TEST_PKG_NAME, networkId, LOW_ACCURACY, SHORT_PERIOD, &g_timeSyncCb) != SOFTBUS_OK);
414 EXPECT_TRUE(StartTimeSync(TEST_PKG_NAME, networkId, LOW_ACCURACY, SHORT_PERIOD, nullptr) != SOFTBUS_OK);
415 }
416
417 /*
418 * @tc.name: BUS_CENTER_SDK_START_TIME_SYNC_Test_002
419 * @tc.desc: start time sync interface test
420 * @tc.type: FUNC
421 * @tc.require: I5I7B9
422 */
423 HWTEST_F(BusCenterSdkTest, BUS_CENTER_SDK_START_TIME_SYNC_Test_002, TestSize.Level0)
424 {
425 char networkId[] = "0123456789987654321001234567899876543210012345678998765432100123";
426
427 EXPECT_TRUE(StopTimeSync(nullptr, networkId) != SOFTBUS_OK);
428 EXPECT_TRUE(StopTimeSync(TEST_PKG_NAME, nullptr) != SOFTBUS_OK);
429 EXPECT_TRUE(StopTimeSync(TEST_PKG_NAME, networkId) != SOFTBUS_OK);
430 }
431
432 /**
433 * @tc.name: PublishLNNTest001
434 * @tc.desc: Verify wrong parameter
435 * @tc.type: FUNC
436 * @tc.require: I5I7B9
437 */
438 HWTEST_F(BusCenterSdkTest, PublishLNNTest001, TestSize.Level0)
439 {
440 int32_t ret = PublishLNN(nullptr, &g_pInfo, &g_publishCb);
441 EXPECT_TRUE(ret != 0);
442
443 ret = PublishLNN(TEST_PKG_NAME, nullptr, &g_publishCb);
444 EXPECT_TRUE(ret != 0);
445
446 ret = PublishLNN(TEST_PKG_NAME, &g_pInfo, nullptr);
447 EXPECT_TRUE(ret != 0);
448
449 ret = PublishLNN("MODULE_LNN", &g_pInfo, &g_publishCb);
450 EXPECT_TRUE(ret != 0);
451
452 g_pInfo.medium = (ExchangeMedium)(COAP + 1);
453 ret = PublishLNN(TEST_PKG_NAME, &g_pInfo, &g_publishCb);
454 EXPECT_TRUE(ret != 0);
455 g_pInfo.medium = COAP;
456
457 g_pInfo.mode = (DiscoverMode)(DISCOVER_MODE_ACTIVE + 1);
458 ret = PublishLNN(TEST_PKG_NAME, &g_pInfo, &g_publishCb);
459 EXPECT_TRUE(ret != 0);
460 g_pInfo.mode = DISCOVER_MODE_ACTIVE;
461
462 g_pInfo.freq = (ExchangeFreq)(FREQ_BUTT);
463 ret = PublishLNN(TEST_PKG_NAME, &g_pInfo, &g_publishCb);
464 EXPECT_TRUE(ret != 0);
465 g_pInfo.freq = LOW;
466
467 g_pInfo.capabilityData = nullptr;
468 ret = PublishLNN(TEST_PKG_NAME, &g_pInfo, &g_publishCb);
469 EXPECT_TRUE(ret != 0);
470 g_pInfo.capabilityData = (unsigned char *)CAPABILITY_1;
471
472 g_pInfo.dataLen = ERRO_CAPDATA_LEN;
473 ret = PublishLNN(TEST_PKG_NAME, &g_pInfo, &g_publishCb);
474 EXPECT_TRUE(ret != 0);
475 g_pInfo.dataLen = strlen(CAPABILITY_1);
476 }
477
478 /**
479 * @tc.name: PublishLNNTest002
480 * @tc.desc: Verify normal case
481 * @tc.type: FUNC
482 * @tc.require: I5I7B9 I5PTUS
483 */
484 HWTEST_F(BusCenterSdkTest, PublishLNNTest002, TestSize.Level0)
485 {
486 int32_t ret;
487 int32_t tmpId1 = GetPublishId();
488 int32_t tmpId2 = GetPublishId();
489 int32_t tmpId3 = GetPublishId();
490 NodeBasicInfo info;
491 char localIp[IP_LEN] = { 0 };
492 char loopBackIpAddr[] = "127.0.0.1";
493 char invalidIpAddr[] = "0.0.0.0";
494 (void)memset_s(&info, sizeof(NodeBasicInfo), 0, sizeof(NodeBasicInfo));
495 EXPECT_TRUE(GetLocalNodeDeviceInfo(TEST_PKG_NAME, &info) == SOFTBUS_OK);
496 EXPECT_TRUE(
497 GetNodeKeyInfo(TEST_PKG_NAME, info.networkId, NODE_KEY_IP_ADDRESS, (uint8_t *)localIp, IP_LEN) == SOFTBUS_OK);
498 if (strcmp(localIp, loopBackIpAddr) != 0 && strcmp(localIp, invalidIpAddr) != 0 && strcmp(localIp, "") != 0) {
499 g_pInfo.publishId = tmpId1;
500 ret = PublishLNN(TEST_PKG_NAME, &g_pInfo, &g_publishCb);
501 EXPECT_TRUE(ret == SOFTBUS_OK);
502 g_pInfo1.publishId = tmpId2;
503 ret = PublishLNN(TEST_PKG_NAME, &g_pInfo1, &g_publishCb);
504 EXPECT_TRUE(ret == SOFTBUS_OK);
505 g_pInfo1.publishId = tmpId3;
506 ret = PublishLNN(TEST_PKG_NAME_1, &g_pInfo1, &g_publishCb);
507 EXPECT_TRUE(ret == SOFTBUS_OK);
508 ret = StopPublishLNN(TEST_PKG_NAME, tmpId1);
509 EXPECT_TRUE(ret == SOFTBUS_OK);
510 ret = StopPublishLNN(TEST_PKG_NAME, tmpId2);
511 EXPECT_TRUE(ret == SOFTBUS_OK);
512 ret = StopPublishLNN(TEST_PKG_NAME_1, tmpId3);
513 EXPECT_TRUE(ret == SOFTBUS_OK);
514 }
515 }
516
517 /**
518 * @tc.name: RefreshLNNTest001
519 * @tc.desc: Verify wrong parameter
520 * @tc.type: FUNC
521 * @tc.require: I5I7B9
522 */
523 HWTEST_F(BusCenterSdkTest, RefreshLNNTest001, TestSize.Level0)
524 {
525 int32_t ret;
526
527 ret = RefreshLNN(nullptr, &g_sInfo, &g_refreshCb);
528 EXPECT_TRUE(ret != 0);
529
530 ret = RefreshLNN(TEST_PKG_NAME, nullptr, &g_refreshCb);
531 EXPECT_TRUE(ret != 0);
532
533 ret = RefreshLNN(TEST_PKG_NAME, &g_sInfo, nullptr);
534 EXPECT_TRUE(ret != 0);
535
536 ret = RefreshLNN("MODULE_LNN", &g_sInfo, &g_refreshCb);
537 EXPECT_TRUE(ret != 0);
538
539 g_sInfo.medium = (ExchangeMedium)(COAP + 1);
540 ret = RefreshLNN(TEST_PKG_NAME, &g_sInfo, &g_refreshCb);
541 EXPECT_TRUE(ret != 0);
542 g_sInfo.medium = COAP;
543
544 g_sInfo.mode = (DiscoverMode)(DISCOVER_MODE_ACTIVE + 1);
545 ret = RefreshLNN(TEST_PKG_NAME, &g_sInfo, &g_refreshCb);
546 EXPECT_TRUE(ret != 0);
547 g_sInfo.mode = DISCOVER_MODE_ACTIVE;
548
549 g_sInfo.freq = (ExchangeFreq)(FREQ_BUTT);
550 ret = RefreshLNN(TEST_PKG_NAME, &g_sInfo, &g_refreshCb);
551 EXPECT_TRUE(ret != 0);
552 g_sInfo.freq = LOW;
553
554 g_sInfo.capabilityData = nullptr;
555 ret = RefreshLNN(TEST_PKG_NAME, &g_sInfo, &g_refreshCb);
556 EXPECT_TRUE(ret != 0);
557 g_sInfo.capabilityData = (unsigned char *)CAPABILITY_1;
558
559 g_sInfo.dataLen = ERRO_CAPDATA_LEN;
560 ret = RefreshLNN(TEST_PKG_NAME, &g_sInfo, &g_refreshCb);
561 EXPECT_TRUE(ret != 0);
562 g_sInfo.dataLen = strlen(CAPABILITY_1);
563 }
564
565 /**
566 * @tc.name: RefreshLNNTest002
567 * @tc.desc: Verify normal case
568 * @tc.type: FUNC
569 * @tc.require: I5I7B9 I5PTUS
570 */
571 HWTEST_F(BusCenterSdkTest, RefreshLNNTest002, TestSize.Level0)
572 {
573 int32_t ret;
574 int32_t tmpId1 = GetSubscribeId();
575 int32_t tmpId2 = GetSubscribeId();
576 int32_t tmpId3 = GetSubscribeId();
577 NodeBasicInfo info;
578 char localIp[IP_LEN] = { 0 };
579 char loopBackIpAddr[] = "127.0.0.1";
580 char invalidIpAddr[] = "0.0.0.0";
581 (void)memset_s(&info, sizeof(NodeBasicInfo), 0, sizeof(NodeBasicInfo));
582 EXPECT_TRUE(GetLocalNodeDeviceInfo(TEST_PKG_NAME, &info) == SOFTBUS_OK);
583 EXPECT_TRUE(
584 GetNodeKeyInfo(TEST_PKG_NAME, info.networkId, NODE_KEY_IP_ADDRESS, (uint8_t *)localIp, IP_LEN) == SOFTBUS_OK);
585 if (strcmp(localIp, loopBackIpAddr) != 0 && strcmp(localIp, invalidIpAddr) != 0 && strcmp(localIp, "") != 0) {
586 g_sInfo.subscribeId = tmpId1;
587 ret = RefreshLNN(TEST_PKG_NAME, &g_sInfo, &g_refreshCb);
588 EXPECT_TRUE(ret == SOFTBUS_OK);
589 g_sInfo1.subscribeId = tmpId2;
590 ret = RefreshLNN(TEST_PKG_NAME, &g_sInfo1, &g_refreshCb);
591 EXPECT_TRUE(ret == SOFTBUS_OK);
592 g_sInfo1.subscribeId = tmpId3;
593 ret = RefreshLNN(TEST_PKG_NAME_1, &g_sInfo1, &g_refreshCb);
594 EXPECT_TRUE(ret == SOFTBUS_OK);
595 ret = StopRefreshLNN(TEST_PKG_NAME, tmpId1);
596 EXPECT_TRUE(ret == SOFTBUS_OK);
597 ret = StopRefreshLNN(TEST_PKG_NAME, tmpId2);
598 EXPECT_TRUE(ret == SOFTBUS_OK);
599 ret = StopRefreshLNN(TEST_PKG_NAME_1, tmpId3);
600 EXPECT_TRUE(ret == SOFTBUS_OK);
601 }
602 }
603
604 /**
605 * @tc.name: SET_NODE_DATA_CHANGE_FLAG_INNER_Test001
606 * @tc.desc: Set Node Data Change Flag Inner
607 * @tc.type: FUNC
608 * @tc.require:
609 */
610 HWTEST_F(BusCenterSdkTest, SET_NODE_DATA_CHANGE_FLAG_INNER_Test001, TestSize.Level0)
611 {
612 char pkgName[] = "test";
613 char *networkId = nullptr;
614 uint16_t dataChangeFlag = 0;
615 int32_t ret = SetNodeDataChangeFlagInner(pkgName, networkId, dataChangeFlag);
616 EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
617 }
618
619 /*
620 * @tc.name: SERVER_IPC_SET_NODE_DATA_CHANGE_FLAG_Test001
621 * @tc.desc: ServerIpcSetNodeDataChangeFlag Result
622 * @tc.type: FUNC
623 * @tc.require:
624 */
625 HWTEST_F(BusCenterSdkTest, SERVER_IPC_SET_NODE_DATA_CHANGE_FLAG_Test001, TestSize.Level1)
626 {
627 char pkgName[] = "test";
628 char *networkId1 = nullptr;
629 uint16_t dataChangeFlag = false;
630 BusCenterServerProxyInit();
631 int32_t ret = ServerIpcSetNodeDataChangeFlag(pkgName, networkId1, dataChangeFlag);
632 EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
633 }
634
635 /*
636 * @tc.name: SERVER_IPC_SET_NODE_DATA_CHANGE_Test001
637 * @tc.desc: Meta Node On Leave Result
638 * @tc.type: FUNC
639 * @tc.require:
640 */
641 HWTEST_F(BusCenterSdkTest, SERVER_IPC_SET_NODE_DATA_CHANGE_Test002, TestSize.Level1)
642 {
643 BusCenterServerProxyInit();
644 char pkgName[] = "pkgname";
645 char networkId[] = "12313";
646 uint16_t dataChangeFlag = 11;
647 int32_t ret = ServerIpcSetNodeDataChangeFlag(pkgName, networkId, dataChangeFlag);
648 EXPECT_NE(ret, SOFTBUS_OK);
649 }
650
651 /*
652 * @tc.name: BUS_CENTER_SDK_PARAM_CHECK_Test001
653 * @tc.desc: test sdk parm check
654 * @tc.type: FUNC
655 * @tc.require:
656 */
657 HWTEST_F(BusCenterSdkTest, BUS_CENTER_SDK_PARAM_CHECK_Test001, TestSize.Level1)
658 {
659 EXPECT_EQ(RegDataLevelChangeCb(nullptr, &g_dataLevelCb), SOFTBUS_INVALID_PARAM);
660 EXPECT_EQ(RegDataLevelChangeCb(TEST_PKG_NAME, nullptr), SOFTBUS_INVALID_PARAM);
661 EXPECT_EQ(RegDataLevelChangeCb(TEST_PKG_NAME, &g_dataLevelCb), SOFTBUS_INVALID_PARAM);
662 EXPECT_EQ(UnregDataLevelChangeCb(nullptr), SOFTBUS_INVALID_PARAM);
663 EXPECT_EQ(UnregDataLevelChangeCb(TEST_PKG_NAME), SOFTBUS_INVALID_PARAM);
664 EXPECT_EQ(SetDataLevel(nullptr), SOFTBUS_INVALID_PARAM);
665 EXPECT_EQ(SetDataLevel(nullptr), SOFTBUS_INVALID_PARAM);
666 EXPECT_EQ(StopPublishLNN(nullptr, 0), SOFTBUS_INVALID_PARAM);
667 char msg[] = "abc";
668 EXPECT_EQ(SyncTrustedRelationShip(nullptr, msg, strlen(msg)), SOFTBUS_INVALID_PARAM);
669 EXPECT_EQ(SyncTrustedRelationShip(TEST_PKG_NAME, nullptr, strlen(msg)), SOFTBUS_INVALID_PARAM);
670 EXPECT_EQ(SyncTrustedRelationShip(TEST_PKG_NAME, msg, strlen(msg)), SOFTBUS_IPC_ERR);
671 }
672
673 /*
674 * @tc.name: BUS_CENTER_SDK_TRIGGER_RANGE_Test001
675 * @tc.desc: test sdk parm check
676 * @tc.type: FUNC
677 * @tc.require:
678 */
679 HWTEST_F(BusCenterSdkTest, BUS_CENTER_SDK_TRIGGER_RANGE_Test001, TestSize.Level1)
680 {
681 EXPECT_EQ(RegBleRangeCb(nullptr, &g_bleRangeCb), SOFTBUS_INVALID_PARAM);
682 EXPECT_EQ(RegBleRangeCb(nullptr, nullptr), SOFTBUS_INVALID_PARAM);
683 EXPECT_EQ(RegBleRangeCb(nullptr, &g_bleRangeCb1), SOFTBUS_INVALID_PARAM);
684 EXPECT_EQ(RegBleRangeCb(TEST_PKG_NAME, &g_bleRangeCb), SOFTBUS_INVALID_PARAM);
685 EXPECT_EQ(RegBleRangeCb(TEST_MSDP_NAME, &g_bleRangeCb), SOFTBUS_FUNC_NOT_SUPPORT);
686 EXPECT_EQ(UnregBleRangeCb(nullptr), SOFTBUS_INVALID_PARAM);
687 EXPECT_EQ(UnregBleRangeCb(TEST_PKG_NAME), SOFTBUS_INVALID_PARAM);
688 EXPECT_EQ(UnregBleRangeCb(TEST_MSDP_NAME), SOFTBUS_FUNC_NOT_SUPPORT);
689
690 const char *callerId = "123";
691 HbMode mode = { .connFlag = true, .duration = 5, .replyFlag = false };
692 EXPECT_EQ(TriggerHbForMeasureDistance(nullptr, nullptr, nullptr), SOFTBUS_INVALID_PARAM);
693 EXPECT_EQ(TriggerHbForMeasureDistance(TEST_PKG_NAME, nullptr, nullptr), SOFTBUS_INVALID_PARAM);
694 EXPECT_EQ(TriggerHbForMeasureDistance(TEST_PKG_NAME, callerId, nullptr), SOFTBUS_INVALID_PARAM);
695 EXPECT_EQ(TriggerHbForMeasureDistance(nullptr, callerId, &mode), SOFTBUS_INVALID_PARAM);
696 EXPECT_EQ(TriggerHbForMeasureDistance(TEST_PKG_NAME, callerId, &mode), SOFTBUS_OK);
697 }
698 } // namespace OHOS
699