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