1 /*
2 * Copyright (c) 2022 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 <cstddef>
17 #include <cstdlib>
18 #include <cstring>
19 #include <gtest/gtest.h>
20 #include <securec.h>
21
22 #include "client_bus_center_manager.h"
23 #include "client_bus_center_manager_mock.h"
24 #include "common_list.h"
25 #include "softbus_adapter_mem.h"
26 #include "softbus_common.h"
27 #include "softbus_config_type.h"
28 #include "softbus_error_code.h"
29
30 #include "client_bus_center_manager.c"
31
32 namespace OHOS {
33 using namespace testing::ext;
34 using namespace testing;
35 constexpr char NODE1_BR_MAC[] = "12345TTU";
36 constexpr char NODE1_BLE_MAC[] = "23456TTU";
37 constexpr char NODE1_IP[] = "10.146.181.134";
38 constexpr uint16_t NODE1_PORT = 10;
39 constexpr char NODE1_NETWORK_ID[] = "235689BNHFCF";
40 constexpr int32_t NODE1_SESSION_ID = 100;
41 constexpr int32_t NODE1_CHANNEL_ID = 100;
42 constexpr int32_t NODE1_SESSION_TYPE = 100;
43 constexpr int32_t LNN_PUBLISH_ID = 0;
44 constexpr int32_t LNN_SUBSCRIBE_ID = 0;
45 constexpr char CAPABILITY[] = "ddmpCapabilityTest";
46 constexpr unsigned char CAPABILITY_DATA[] = "ddmpCapabilityTest";
47 constexpr uint32_t EVENT = 15;
48 constexpr int32_t INVALID_TYPE = -1;
49 constexpr int32_t TYPE = 1;
50 constexpr int32_t LNN_REFRESH_ID = 0;
51 constexpr int32_t RESULT_REASON = -1;
52 constexpr char PKGNAME[] = "softbustest";
53 class ClientBusCentManagerTest : public testing::Test {
54 public:
55 static void SetUpTestCase();
56 static void TearDownTestCase();
57 void SetUp();
58 void TearDown();
59 };
60
SetUpTestCase()61 void ClientBusCentManagerTest::SetUpTestCase() { }
62
TearDownTestCase()63 void ClientBusCentManagerTest::TearDownTestCase() { }
64
SetUp()65 void ClientBusCentManagerTest::SetUp() { }
66
TearDown()67 void ClientBusCentManagerTest::TearDown() { }
68
69 /*
70 * @tc.name: BUS_CENTER_CLIENT_INIT_Test_001
71 * @tc.desc: bus center client init test
72 * @tc.type: FUNC
73 * @tc.require:
74 */
75 HWTEST_F(ClientBusCentManagerTest, BUS_CENTER_CLIENT_INIT_Test_001, TestSize.Level1)
76 {
77 ClientBusCenterManagerInterfaceMock busCentManagerMock;
78 EXPECT_CALL(busCentManagerMock, SoftbusGetConfig(_, _, _)).WillRepeatedly(Return(SOFTBUS_INVALID_PARAM));
79 EXPECT_CALL(busCentManagerMock, BusCenterServerProxyInit())
80 .WillOnce(Return(SOFTBUS_SERVER_NOT_INIT))
81 .WillRepeatedly(Return(SOFTBUS_OK));
82 EXPECT_CALL(busCentManagerMock, BusCenterServerProxyDeInit()).WillRepeatedly(Return());
83 EXPECT_NE(BusCenterClientInit(), SOFTBUS_OK);
84 EXPECT_TRUE(BusCenterClientInit() == SOFTBUS_OK);
85 BusCenterClientDeinit();
86 }
87
88 /*
89 * @tc.name: JOIN_LNN_INNER_Test_001
90 * @tc.desc: join lnn inner test
91 * @tc.type: FUNC
92 * @tc.require:
93 */
94 HWTEST_F(ClientBusCentManagerTest, JOIN_LNN_INNER_Test_001, TestSize.Level1)
95 {
96 OnJoinLNNResult cb = nullptr;
97 ConnectionAddr target1;
98 (void)memset_s(&target1, sizeof(ConnectionAddr), 0, sizeof(ConnectionAddr));
99 target1.type = CONNECTION_ADDR_BR;
100 (void)strcpy_s(target1.info.br.brMac, BT_MAC_LEN, NODE1_BR_MAC);
101 (void)strcpy_s(target1.info.ble.bleMac, BT_MAC_LEN, NODE1_BLE_MAC);
102 (void)strcpy_s(target1.info.ip.ip, IP_STR_MAX_LEN, NODE1_IP);
103 target1.info.ip.port = NODE1_PORT;
104 target1.info.session.sessionId = NODE1_SESSION_ID;
105 target1.info.session.channelId = NODE1_CHANNEL_ID;
106 target1.info.session.type = NODE1_SESSION_TYPE;
107 ClientBusCenterManagerInterfaceMock busCentManagerMock;
108 EXPECT_CALL(busCentManagerMock, SoftbusGetConfig(_, _, _)).WillRepeatedly(Return(SOFTBUS_OK));
109 EXPECT_CALL(busCentManagerMock, BusCenterServerProxyInit()).WillRepeatedly(Return(SOFTBUS_OK));
110 EXPECT_CALL(busCentManagerMock, BusCenterServerProxyDeInit()).WillRepeatedly(Return());
111 EXPECT_TRUE(BusCenterClientInit() == SOFTBUS_OK);
112 EXPECT_CALL(busCentManagerMock, ServerIpcJoinLNN(_, _, _, _))
113 .WillOnce(Return(SOFTBUS_SERVER_NOT_INIT))
114 .WillRepeatedly(Return(SOFTBUS_OK));
115 EXPECT_NE(JoinLNNInner(nullptr, &target1, cb, false), SOFTBUS_OK);
116 EXPECT_TRUE(JoinLNNInner(nullptr, &target1, cb, false) == SOFTBUS_OK);
117 EXPECT_TRUE(JoinLNNInner(nullptr, &target1, nullptr, false) == SOFTBUS_ALREADY_EXISTED);
118 target1.type = CONNECTION_ADDR_BLE;
119 EXPECT_TRUE(JoinLNNInner(nullptr, &target1, nullptr, false) == SOFTBUS_OK);
120 target1.type = CONNECTION_ADDR_WLAN;
121 EXPECT_TRUE(JoinLNNInner(nullptr, &target1, nullptr, false) == SOFTBUS_OK);
122 target1.type = CONNECTION_ADDR_ETH;
123 EXPECT_TRUE(JoinLNNInner(nullptr, &target1, nullptr, false) == SOFTBUS_OK);
124 target1.type = CONNECTION_ADDR_SESSION;
125 EXPECT_TRUE(JoinLNNInner(nullptr, &target1, nullptr, false) == SOFTBUS_OK);
126 target1.type = CONNECTION_ADDR_MAX;
127 EXPECT_TRUE(JoinLNNInner(nullptr, &target1, nullptr, false) == SOFTBUS_OK);
128 BusCenterClientDeinit();
129 }
130
131 /*
132 * @tc.name: LEAVE_LNN_INNER_Test_001
133 * @tc.desc: leave lnn inner test
134 * @tc.type: FUNC
135 * @tc.require:
136 */
137 HWTEST_F(ClientBusCentManagerTest, LEAVE_LNN_INNER_Test_001, TestSize.Level1)
138 {
139 OnLeaveLNNResult cb = nullptr;
140 ClientBusCenterManagerInterfaceMock busCentManagerMock;
141 EXPECT_CALL(busCentManagerMock, SoftbusGetConfig(_, _, _)).WillRepeatedly(Return(SOFTBUS_OK));
142 EXPECT_CALL(busCentManagerMock, BusCenterServerProxyInit()).WillRepeatedly(Return(SOFTBUS_OK));
143 EXPECT_CALL(busCentManagerMock, BusCenterServerProxyDeInit()).WillRepeatedly(Return());
144 EXPECT_TRUE(BusCenterClientInit() == SOFTBUS_OK);
145 EXPECT_CALL(busCentManagerMock, ServerIpcLeaveLNN(_, _))
146 .WillOnce(Return(SOFTBUS_SERVER_NOT_INIT))
147 .WillRepeatedly(Return(SOFTBUS_OK));
148 EXPECT_NE(LeaveLNNInner(nullptr, NODE1_NETWORK_ID, cb), SOFTBUS_OK);
149 EXPECT_TRUE(LeaveLNNInner(nullptr, NODE1_NETWORK_ID, cb) == SOFTBUS_OK);
150 EXPECT_NE(LeaveLNNInner(nullptr, NODE1_NETWORK_ID, nullptr), SOFTBUS_OK);
151 BusCenterClientDeinit();
152 }
153
154 /*
155 * @tc.name: REG_NODE_DEVICE_STATE_CB_INNER_Test_001
156 * @tc.desc: reg node device state cb inner test
157 * @tc.type: FUNC
158 * @tc.require:
159 */
160 HWTEST_F(ClientBusCentManagerTest, REG_NODE_DEVICE_STATE_CB_INNER_Test_001, TestSize.Level1)
161 {
162 INodeStateCb callback;
163 ClientBusCenterManagerInterfaceMock busCentManagerMock;
164 EXPECT_CALL(busCentManagerMock, SoftbusGetConfig(_, _, _)).WillRepeatedly(Return(SOFTBUS_OK));
165 EXPECT_CALL(busCentManagerMock, BusCenterServerProxyInit()).WillRepeatedly(Return(SOFTBUS_OK));
166 EXPECT_CALL(busCentManagerMock, BusCenterServerProxyDeInit()).WillRepeatedly(Return());
167 EXPECT_TRUE(BusCenterClientInit() == SOFTBUS_OK);
168 EXPECT_TRUE(RegNodeDeviceStateCbInner(nullptr, &callback) == SOFTBUS_INVALID_PARAM);
169 EXPECT_TRUE(RegNodeDeviceStateCbInner(PKGNAME, &callback) == SOFTBUS_OK);
170 BusCenterClientDeinit();
171 }
172
173 /*
174 * @tc.name: UNREG_NODE_DEVICE_STATE_CB_INNER_Test_001
175 * @tc.desc: unreg node device state cb inner test
176 * @tc.type: FUNC
177 * @tc.require:
178 */
179 HWTEST_F(ClientBusCentManagerTest, UNREG_NODE_DEVICE_STATE_CB_INNER_Test_001, TestSize.Level1)
180 {
181 INodeStateCb callback;
182 ClientBusCenterManagerInterfaceMock busCentManagerMock;
183 EXPECT_CALL(busCentManagerMock, SoftbusGetConfig(_, _, _)).WillRepeatedly(Return(SOFTBUS_OK));
184 EXPECT_CALL(busCentManagerMock, BusCenterServerProxyInit()).WillRepeatedly(Return(SOFTBUS_OK));
185 EXPECT_CALL(busCentManagerMock, BusCenterServerProxyDeInit()).WillRepeatedly(Return());
186 EXPECT_TRUE(BusCenterClientInit() == SOFTBUS_OK);
187 EXPECT_TRUE(UnregNodeDeviceStateCbInner(&callback) == SOFTBUS_OK);
188 BusCenterClientDeinit();
189 }
190
191 /*
192 * @tc.name: GET_ALL_NODE_DEVICE_INFO_INNER_Test_001
193 * @tc.desc: get all node device info inner test
194 * @tc.type: FUNC
195 * @tc.require:
196 */
197 HWTEST_F(ClientBusCentManagerTest, GET_ALL_NODE_DEVICE_INFO_INNER_Test_001, TestSize.Level1)
198 {
199 ClientBusCenterManagerInterfaceMock busCentManagerMock;
200 EXPECT_CALL(busCentManagerMock, ServerIpcGetAllOnlineNodeInfo(_, _, _, _))
201 .WillOnce(Return(SOFTBUS_SERVER_NOT_INIT))
202 .WillRepeatedly(Return(SOFTBUS_OK));
203 EXPECT_NE(GetAllNodeDeviceInfoInner(nullptr, nullptr, nullptr), SOFTBUS_OK);
204 EXPECT_TRUE(GetAllNodeDeviceInfoInner(nullptr, nullptr, nullptr) == SOFTBUS_OK);
205 }
206
207 /*
208 * @tc.name: GET_LOCAL_NODE_DEVICE_INFO_INNER_Test_001
209 * @tc.desc: get local node device info inner test
210 * @tc.type: FUNC
211 * @tc.require:
212 */
213 HWTEST_F(ClientBusCentManagerTest, GET_LOCAL_NODE_DEVICE_INFO_INNER_Test_001, TestSize.Level1)
214 {
215 ClientBusCenterManagerInterfaceMock busCentManagerMock;
216 EXPECT_CALL(busCentManagerMock, ServerIpcGetLocalDeviceInfo(_, _, _))
217 .WillOnce(Return(SOFTBUS_SERVER_NOT_INIT))
218 .WillRepeatedly(Return(SOFTBUS_OK));
219 EXPECT_NE(GetLocalNodeDeviceInfoInner(nullptr, nullptr), SOFTBUS_OK);
220 EXPECT_TRUE(GetLocalNodeDeviceInfoInner(nullptr, nullptr) == SOFTBUS_OK);
221 }
222
223 /*
224 * @tc.name: GET_NODE_KEY_INFO_INNER_Test_001
225 * @tc.desc: get node key info inner test
226 * @tc.type: FUNC
227 * @tc.require:
228 */
229 HWTEST_F(ClientBusCentManagerTest, GET_NODE_KEY_INFO_INNER_Test_001, TestSize.Level1)
230 {
231 int32_t infoLen = 0;
232 ClientBusCenterManagerInterfaceMock busCentManagerMock;
233 EXPECT_CALL(busCentManagerMock, ServerIpcGetNodeKeyInfo(_, _, _, _, _))
234 .WillOnce(Return(SOFTBUS_SERVER_NOT_INIT))
235 .WillRepeatedly(Return(SOFTBUS_OK));
236 EXPECT_NE(GetNodeKeyInfoInner(nullptr, nullptr, NODE_KEY_UDID, nullptr, infoLen), SOFTBUS_OK);
237 EXPECT_TRUE(GetNodeKeyInfoInner(nullptr, nullptr, NODE_KEY_UDID, nullptr, infoLen) == SOFTBUS_OK);
238 }
239
240 /*
241 * @tc.name: SET_NODE_DATA_CHANGE_FLAG_INNER_Test_001
242 * @tc.desc: set node data change flag inner test
243 * @tc.type: FUNC
244 * @tc.require:
245 */
246 HWTEST_F(ClientBusCentManagerTest, SET_NODE_DATA_CHANGE_FLAG_INNER_Test_001, TestSize.Level1)
247 {
248 uint16_t dataChangeFlag = 0;
249 ClientBusCenterManagerInterfaceMock busCentManagerMock;
250 EXPECT_CALL(busCentManagerMock, ServerIpcSetNodeDataChangeFlag(_, _, _))
251 .WillOnce(Return(SOFTBUS_SERVER_NOT_INIT))
252 .WillRepeatedly(Return(SOFTBUS_OK));
253 EXPECT_NE(SetNodeDataChangeFlagInner(nullptr, nullptr, dataChangeFlag), SOFTBUS_OK);
254 EXPECT_TRUE(SetNodeDataChangeFlagInner(nullptr, nullptr, dataChangeFlag) == SOFTBUS_OK);
255 }
256
257 /*
258 * @tc.name: START_TIME_SYNC_INNER_Test_001
259 * @tc.desc: start time sync inner test
260 * @tc.type: FUNC
261 * @tc.require:
262 */
263 HWTEST_F(ClientBusCentManagerTest, START_TIME_SYNC_INNER_Test_001, TestSize.Level1)
264 {
265 ITimeSyncCb cb;
266 ClientBusCenterManagerInterfaceMock busCentManagerMock;
267 EXPECT_CALL(busCentManagerMock, SoftbusGetConfig(_, _, _)).WillRepeatedly(Return(SOFTBUS_OK));
268 EXPECT_CALL(busCentManagerMock, BusCenterServerProxyInit()).WillRepeatedly(Return(SOFTBUS_OK));
269 EXPECT_CALL(busCentManagerMock, BusCenterServerProxyDeInit()).WillRepeatedly(Return());
270 EXPECT_TRUE(BusCenterClientInit() == SOFTBUS_OK);
271 EXPECT_CALL(busCentManagerMock, ServerIpcStartTimeSync(_, _, _, _))
272 .WillOnce(Return(SOFTBUS_SERVER_NOT_INIT))
273 .WillRepeatedly(Return(SOFTBUS_OK));
274 EXPECT_NE(StartTimeSyncInner(nullptr, nullptr, LOW_ACCURACY, SHORT_PERIOD, &cb), SOFTBUS_OK);
275 EXPECT_TRUE(StartTimeSyncInner(nullptr, NODE1_NETWORK_ID, LOW_ACCURACY, SHORT_PERIOD, &cb) == SOFTBUS_OK);
276 EXPECT_NE(StartTimeSyncInner(nullptr, NODE1_NETWORK_ID, LOW_ACCURACY, SHORT_PERIOD, &cb), SOFTBUS_OK);
277 BusCenterClientDeinit();
278 }
279
280 /*
281 * @tc.name: STOP_TIME_SYNC_INNER_Test_001
282 * @tc.desc: stop time sync inner test
283 * @tc.type: FUNC
284 * @tc.require:
285 */
286 HWTEST_F(ClientBusCentManagerTest, STOP_TIME_SYNC_INNER_Test_001, TestSize.Level1)
287 {
288 ClientBusCenterManagerInterfaceMock busCentManagerMock;
289 EXPECT_CALL(busCentManagerMock, SoftbusGetConfig(_, _, _)).WillRepeatedly(Return(SOFTBUS_OK));
290 EXPECT_CALL(busCentManagerMock, BusCenterServerProxyInit()).WillRepeatedly(Return(SOFTBUS_OK));
291 EXPECT_CALL(busCentManagerMock, BusCenterServerProxyDeInit()).WillRepeatedly(Return());
292 EXPECT_TRUE(BusCenterClientInit() == SOFTBUS_OK);
293 EXPECT_CALL(busCentManagerMock, ServerIpcStopTimeSync(_, _)).WillRepeatedly(Return(SOFTBUS_SERVER_NOT_INIT));
294 EXPECT_NE(StopTimeSyncInner(nullptr, NODE1_NETWORK_ID), SOFTBUS_OK);
295 BusCenterClientDeinit();
296 }
297
298 /*
299 * @tc.name: STOP_TIME_SYNC_INNER_Test_002
300 * @tc.desc: stop time sync inner test
301 * @tc.type: FUNC
302 * @tc.require:
303 */
304 HWTEST_F(ClientBusCentManagerTest, STOP_TIME_SYNC_INNER_Test_002, TestSize.Level1)
305 {
306 ITimeSyncCb cb;
307 ClientBusCenterManagerInterfaceMock busCentManagerMock;
308 EXPECT_CALL(busCentManagerMock, SoftbusGetConfig(_, _, _)).WillRepeatedly(Return(SOFTBUS_OK));
309 EXPECT_CALL(busCentManagerMock, BusCenterServerProxyInit()).WillRepeatedly(Return(SOFTBUS_OK));
310 EXPECT_CALL(busCentManagerMock, BusCenterServerProxyDeInit()).WillRepeatedly(Return());
311 EXPECT_TRUE(BusCenterClientInit() == SOFTBUS_OK);
312 EXPECT_CALL(busCentManagerMock, ServerIpcStartTimeSync(_, _, _, _)).WillRepeatedly(Return(SOFTBUS_OK));
313 EXPECT_TRUE(StartTimeSyncInner(nullptr, NODE1_NETWORK_ID, LOW_ACCURACY, SHORT_PERIOD, &cb) == SOFTBUS_OK);
314 EXPECT_CALL(busCentManagerMock, ServerIpcStopTimeSync(_, _))
315 .WillOnce(Return(SOFTBUS_SERVER_NOT_INIT))
316 .WillRepeatedly(Return(SOFTBUS_OK));
317 EXPECT_TRUE(StopTimeSyncInner(nullptr, NODE1_NETWORK_ID) == SOFTBUS_OK);
318 EXPECT_NE(StopTimeSyncInner(nullptr, NODE1_NETWORK_ID), SOFTBUS_OK);
319 BusCenterClientDeinit();
320 }
321
OnPublishResultCb(int32_t publishId,PublishResult reason)322 static void OnPublishResultCb(int32_t publishId, PublishResult reason)
323 {
324 (void)publishId;
325 (void)reason;
326 printf("on call publish result cb\n");
327 }
328
329 /*
330 * @tc.name: PUBLISH_LNN_INNER_Test_001
331 * @tc.desc: publish lnn inner test
332 * @tc.type: FUNC
333 * @tc.require:
334 */
335 HWTEST_F(ClientBusCentManagerTest, PUBLISH_LNN_INNER_Test_001, TestSize.Level1)
336 {
337 IPublishCb cb;
338 cb.OnPublishResult = OnPublishResultCb;
339 PublishInfo info;
340 (void)memset_s(&info, sizeof(PublishInfo), 0, sizeof(PublishInfo));
341 info.publishId = LNN_PUBLISH_ID;
342 info.mode = DISCOVER_MODE_PASSIVE;
343 info.medium = COAP;
344 info.freq = HIGH;
345 info.capability = CAPABILITY;
346 info.capabilityData = const_cast<unsigned char *>(CAPABILITY_DATA);
347 info.dataLen = strlen(reinterpret_cast<const char *>(const_cast<unsigned char *>(CAPABILITY_DATA)));
348 info.ranging = false;
349 LnnOnPublishLNNResult(LNN_PUBLISH_ID, RESULT_REASON);
350 ClientBusCenterManagerInterfaceMock busCentManagerMock;
351 EXPECT_CALL(busCentManagerMock, ServerIpcPublishLNN(_, _))
352 .WillOnce(Return(SOFTBUS_SERVER_NOT_INIT))
353 .WillRepeatedly(Return(SOFTBUS_OK));
354 EXPECT_NE(PublishLNNInner(nullptr, &info, &cb), SOFTBUS_OK);
355 EXPECT_TRUE(PublishLNNInner(nullptr, &info, &cb) == SOFTBUS_OK);
356 LnnOnPublishLNNResult(LNN_PUBLISH_ID, RESULT_REASON);
357 }
358
359 /*
360 * @tc.name: STOP_PUBLISH_LNN_INNER_Test_001
361 * @tc.desc: stop publish lnn inner test
362 * @tc.type: FUNC
363 * @tc.require:
364 */
365 HWTEST_F(ClientBusCentManagerTest, STOP_PUBLISH_LNN_INNER_Test_001, TestSize.Level1)
366 {
367 ClientBusCenterManagerInterfaceMock busCentManagerMock;
368 EXPECT_CALL(busCentManagerMock, ServerIpcStopPublishLNN(_, _))
369 .WillOnce(Return(SOFTBUS_SERVER_NOT_INIT))
370 .WillRepeatedly(Return(SOFTBUS_OK));
371 EXPECT_NE(StopPublishLNNInner(nullptr, LNN_PUBLISH_ID), SOFTBUS_OK);
372 EXPECT_TRUE(StopPublishLNNInner(nullptr, LNN_PUBLISH_ID) == SOFTBUS_OK);
373 }
374
OnDeviceFoundCb(const DeviceInfo * device)375 static void OnDeviceFoundCb(const DeviceInfo *device)
376 {
377 (void)device;
378 printf("on call device found cb\n");
379 }
380
OnDiscoverResultCb(int32_t refreshId,RefreshResult reason)381 static void OnDiscoverResultCb(int32_t refreshId, RefreshResult reason)
382 {
383 (void)refreshId;
384 (void)reason;
385 printf("on call discover result cb\n");
386 }
387
388 /*
389 * @tc.name: REFRESH_LNN_INNER_Test_001
390 * @tc.desc: refresh lnn inner test
391 * @tc.type: FUNC
392 * @tc.require:
393 */
394 HWTEST_F(ClientBusCentManagerTest, REFRESH_LNN_INNER_Test_001, TestSize.Level1)
395 {
396 SubscribeInfo info;
397 IRefreshCallback cb;
398 cb.OnDeviceFound = OnDeviceFoundCb;
399 cb.OnDiscoverResult = OnDiscoverResultCb;
400 (void)memset_s(&info, sizeof(SubscribeInfo), 0, sizeof(SubscribeInfo));
401 info.subscribeId = LNN_SUBSCRIBE_ID;
402 info.mode = DISCOVER_MODE_PASSIVE;
403 info.medium = COAP;
404 info.freq = HIGH;
405 info.isSameAccount = false;
406 info.isWakeRemote = false;
407 info.capability = CAPABILITY;
408 info.capabilityData = const_cast<unsigned char *>(CAPABILITY_DATA);
409 info.dataLen = strlen(reinterpret_cast<const char *>(const_cast<unsigned char *>(CAPABILITY_DATA)));
410 LnnOnRefreshLNNResult(LNN_REFRESH_ID, RESULT_REASON);
411 LnnOnRefreshDeviceFound(nullptr);
412 ClientBusCenterManagerInterfaceMock busCentManagerMock;
413 EXPECT_CALL(busCentManagerMock, ServerIpcRefreshLNN(_, _))
414 .WillOnce(Return(SOFTBUS_SERVER_NOT_INIT))
415 .WillRepeatedly(Return(SOFTBUS_OK));
416 EXPECT_NE(RefreshLNNInner(nullptr, &info, &cb), SOFTBUS_OK);
417 EXPECT_TRUE(RefreshLNNInner(nullptr, &info, &cb) == SOFTBUS_OK);
418 LnnOnRefreshLNNResult(LNN_REFRESH_ID, RESULT_REASON);
419 LnnOnRefreshDeviceFound(nullptr);
420 }
421
422 /*
423 * @tc.name: STOP_REFRESH_LNN_INNER_Test_001
424 * @tc.desc: stop refresh lnn inner test
425 * @tc.type: FUNC
426 * @tc.require:
427 */
428 HWTEST_F(ClientBusCentManagerTest, STOP_REFRESH_LNN_INNER_Test_001, TestSize.Level1)
429 {
430 ClientBusCenterManagerInterfaceMock busCentManagerMock;
431 EXPECT_CALL(busCentManagerMock, ServerIpcStopRefreshLNN(_, _))
432 .WillOnce(Return(SOFTBUS_SERVER_NOT_INIT))
433 .WillRepeatedly(Return(SOFTBUS_OK));
434 EXPECT_NE(StopRefreshLNNInner(nullptr, LNN_SUBSCRIBE_ID), SOFTBUS_OK);
435 EXPECT_TRUE(StopRefreshLNNInner(nullptr, LNN_SUBSCRIBE_ID) == SOFTBUS_OK);
436 }
437
OnJoinLNNResultCb(ConnectionAddr * addr,const char * networkId,int32_t retCode)438 static void OnJoinLNNResultCb(ConnectionAddr *addr, const char *networkId, int32_t retCode)
439 {
440 (void)addr;
441 (void)networkId;
442 (void)retCode;
443 printf("on call join LNN result cb\n");
444 }
445
446 /*
447 * @tc.name: LNN_ONJOIN_RESULT_Test_001
448 * @tc.desc: lnn on join result test
449 * @tc.type: FUNC
450 * @tc.require:
451 */
452 HWTEST_F(ClientBusCentManagerTest, LNN_ONJOIN_RESULT_Test_001, TestSize.Level1)
453 {
454 int32_t retCode = 0;
455 ConnectionAddr addr;
456 (void)memset_s(&addr, sizeof(ConnectionAddr), 0, sizeof(ConnectionAddr));
457 addr.type = CONNECTION_ADDR_BR;
458 (void)strcpy_s(addr.info.br.brMac, BT_MAC_LEN, NODE1_BR_MAC);
459 EXPECT_TRUE(LnnOnJoinResult(nullptr, nullptr, retCode) == SOFTBUS_INVALID_PARAM);
460 ClientBusCenterManagerInterfaceMock busCentManagerMock;
461 EXPECT_CALL(busCentManagerMock, SoftbusGetConfig(_, _, _)).WillRepeatedly(Return(SOFTBUS_OK));
462 EXPECT_CALL(busCentManagerMock, BusCenterServerProxyInit()).WillRepeatedly(Return(SOFTBUS_OK));
463 EXPECT_CALL(busCentManagerMock, BusCenterServerProxyDeInit()).WillRepeatedly(Return());
464 EXPECT_TRUE(BusCenterClientInit() == SOFTBUS_OK);
465 EXPECT_TRUE(LnnOnJoinResult(reinterpret_cast<void *>(&addr), NODE1_NETWORK_ID, retCode) == SOFTBUS_OK);
466 EXPECT_CALL(busCentManagerMock, ServerIpcJoinLNN(_, _, _, _)).WillRepeatedly(Return(SOFTBUS_OK));
467 EXPECT_TRUE(JoinLNNInner(nullptr, &addr, OnJoinLNNResultCb, false) == SOFTBUS_OK);
468 EXPECT_TRUE(LnnOnJoinResult(reinterpret_cast<void *>(&addr), NODE1_NETWORK_ID, retCode) == SOFTBUS_OK);
469 EXPECT_TRUE(JoinLNNInner(nullptr, &addr, nullptr, false) == SOFTBUS_OK);
470 EXPECT_TRUE(LnnOnJoinResult(reinterpret_cast<void *>(&addr), NODE1_NETWORK_ID, retCode) == SOFTBUS_OK);
471 BusCenterClientDeinit();
472 }
473
OnLeaveResultCb(const char * networkId,int32_t retCode)474 static void OnLeaveResultCb(const char *networkId, int32_t retCode)
475 {
476 (void)networkId;
477 (void)retCode;
478 printf("on call leave result cb\n");
479 }
480
481 /*
482 * @tc.name: LNN_ON_LEAVE_RESULT_Test_001
483 * @tc.desc: lnn on leave result test
484 * @tc.type: FUNC
485 * @tc.require:
486 */
487 HWTEST_F(ClientBusCentManagerTest, LNN_ON_LEAVE_RESULT_Test_001, TestSize.Level1)
488 {
489 int32_t retCode = 0;
490 ClientBusCenterManagerInterfaceMock busCentManagerMock;
491 EXPECT_CALL(busCentManagerMock, SoftbusGetConfig(_, _, _)).WillRepeatedly(Return(SOFTBUS_OK));
492 EXPECT_TRUE(LnnOnLeaveResult(nullptr, retCode) == SOFTBUS_INVALID_PARAM);
493 EXPECT_CALL(busCentManagerMock, BusCenterServerProxyInit()).WillRepeatedly(Return(SOFTBUS_OK));
494 EXPECT_CALL(busCentManagerMock, BusCenterServerProxyDeInit()).WillRepeatedly(Return());
495 EXPECT_TRUE(BusCenterClientInit() == SOFTBUS_OK);
496 EXPECT_TRUE(LnnOnLeaveResult(NODE1_NETWORK_ID, retCode) == SOFTBUS_OK);
497 EXPECT_CALL(busCentManagerMock, ServerIpcLeaveLNN(_, _)).WillRepeatedly(Return(SOFTBUS_OK));
498 EXPECT_TRUE(LeaveLNNInner(nullptr, NODE1_NETWORK_ID, OnLeaveResultCb) == SOFTBUS_OK);
499 EXPECT_TRUE(LnnOnLeaveResult(NODE1_NETWORK_ID, retCode) == SOFTBUS_OK);
500 EXPECT_TRUE(LeaveLNNInner(nullptr, NODE1_NETWORK_ID, nullptr) == SOFTBUS_OK);
501 EXPECT_TRUE(LnnOnLeaveResult(NODE1_NETWORK_ID, retCode) == SOFTBUS_OK);
502 BusCenterClientDeinit();
503 }
504
OnNodeOnlineCb(NodeBasicInfo * info)505 static void OnNodeOnlineCb(NodeBasicInfo *info)
506 {
507 (void)info;
508 printf("on call node online cb\n");
509 }
510
OnNodeOfflineCb(NodeBasicInfo * info)511 static void OnNodeOfflineCb(NodeBasicInfo *info)
512 {
513 (void)info;
514 printf("on call node offline cb\n");
515 }
516
OnNodeBasicInfoChangedCb(NodeBasicInfoType type,NodeBasicInfo * info)517 static void OnNodeBasicInfoChangedCb(NodeBasicInfoType type, NodeBasicInfo *info)
518 {
519 (void)type;
520 (void)info;
521 printf("on call node basic info changed cb\n");
522 }
523
OnNodeStatusChangedCb(NodeStatusType type,NodeStatus * status)524 static void OnNodeStatusChangedCb(NodeStatusType type, NodeStatus *status)
525 {
526 (void)type;
527 (void)status;
528 printf("on call node status changed cb\n");
529 }
530
531 /*
532 * @tc.name: LNN_ON_NODE_ONLINE_STATE_CHANGED_Test_001
533 * @tc.desc: lnn on node online state changed test
534 * @tc.type: FUNC
535 * @tc.require:
536 */
537 HWTEST_F(ClientBusCentManagerTest, LNN_ON_NODE_ONLINE_STATE_CHANGED_Test_001, TestSize.Level1)
538 {
539 INodeStateCb callBcak;
540 (void)memset_s(&callBcak, sizeof(INodeStateCb), 0, sizeof(INodeStateCb));
541 callBcak.events = EVENT;
542 callBcak.onNodeOnline = OnNodeOnlineCb;
543 callBcak.onNodeOffline = OnNodeOfflineCb;
544 callBcak.onNodeBasicInfoChanged = OnNodeBasicInfoChangedCb;
545 callBcak.onNodeStatusChanged = OnNodeStatusChangedCb;
546 NodeBasicInfo info;
547 ClientBusCenterManagerInterfaceMock busCentManagerMock;
548 EXPECT_CALL(busCentManagerMock, SoftbusGetConfig(_, _, _)).WillRepeatedly(Return(SOFTBUS_OK));
549 EXPECT_TRUE(LnnOnNodeOnlineStateChanged("", false, nullptr) == SOFTBUS_INVALID_PARAM);
550 EXPECT_CALL(busCentManagerMock, BusCenterServerProxyInit()).WillRepeatedly(Return(SOFTBUS_OK));
551 EXPECT_CALL(busCentManagerMock, BusCenterServerProxyDeInit()).WillRepeatedly(Return());
552 EXPECT_TRUE(BusCenterClientInit() == SOFTBUS_OK);
553 EXPECT_TRUE(RegNodeDeviceStateCbInner(nullptr, &callBcak) == SOFTBUS_INVALID_PARAM);
554 EXPECT_TRUE(RegNodeDeviceStateCbInner(PKGNAME, &callBcak) == SOFTBUS_OK);
555 EXPECT_TRUE(LnnOnNodeOnlineStateChanged("", true, reinterpret_cast<void *>(&info)) == SOFTBUS_OK);
556 EXPECT_TRUE(LnnOnNodeOnlineStateChanged("", false, reinterpret_cast<void *>(&info)) == SOFTBUS_OK);
557 BusCenterClientDeinit();
558 }
559
560 /*
561 * @tc.name: LNN_ON_NODE_BASICINFO_CHANGED_Test_001
562 * @tc.desc: lnn on node basic info changed test
563 * @tc.type: FUNC
564 * @tc.require:
565 */
566 HWTEST_F(ClientBusCentManagerTest, LNN_ON_NODE_BASICINFO_CHANGED_Test_001, TestSize.Level1)
567 {
568 INodeStateCb callBcak;
569 (void)memset_s(&callBcak, sizeof(INodeStateCb), 0, sizeof(INodeStateCb));
570 callBcak.events = EVENT;
571 callBcak.onNodeOnline = OnNodeOnlineCb;
572 callBcak.onNodeOffline = OnNodeOfflineCb;
573 callBcak.onNodeBasicInfoChanged = OnNodeBasicInfoChangedCb;
574 callBcak.onNodeStatusChanged = OnNodeStatusChangedCb;
575 NodeBasicInfo info;
576 ClientBusCenterManagerInterfaceMock busCentManagerMock;
577 EXPECT_CALL(busCentManagerMock, SoftbusGetConfig(_, _, _)).WillRepeatedly(Return(SOFTBUS_OK));
578 EXPECT_TRUE(LnnOnNodeBasicInfoChanged("", nullptr, INVALID_TYPE) == SOFTBUS_INVALID_PARAM);
579 EXPECT_TRUE(LnnOnNodeBasicInfoChanged("", reinterpret_cast<void *>(&info), INVALID_TYPE) == SOFTBUS_INVALID_PARAM);
580 EXPECT_CALL(busCentManagerMock, BusCenterServerProxyInit()).WillRepeatedly(Return(SOFTBUS_OK));
581 EXPECT_CALL(busCentManagerMock, BusCenterServerProxyDeInit()).WillRepeatedly(Return());
582 EXPECT_TRUE(BusCenterClientInit() == SOFTBUS_OK);
583 EXPECT_TRUE(RegNodeDeviceStateCbInner(nullptr, &callBcak) == SOFTBUS_INVALID_PARAM);
584 EXPECT_TRUE(RegNodeDeviceStateCbInner(PKGNAME, &callBcak) == SOFTBUS_OK);
585 EXPECT_TRUE(LnnOnNodeBasicInfoChanged("", reinterpret_cast<void *>(&info), INVALID_TYPE) == SOFTBUS_INVALID_PARAM);
586 EXPECT_TRUE(LnnOnNodeBasicInfoChanged("", reinterpret_cast<void *>(&info), TYPE) == SOFTBUS_OK);
587 BusCenterClientDeinit();
588 }
589
590 /*
591 * @tc.name: LNN_ON_NODE_STATUS_CHANGED_Test_001
592 * @tc.desc: lnn on node status changed test
593 * @tc.type: FUNC
594 * @tc.require:
595 */
596 HWTEST_F(ClientBusCentManagerTest, LNN_ON_NODE_STATUS_CHANGED_Test_001, TestSize.Level1)
597 {
598 INodeStateCb callBcak;
599 (void)memset_s(&callBcak, sizeof(INodeStateCb), 0, sizeof(INodeStateCb));
600 callBcak.events = EVENT_NODE_STATUS_CHANGED;
601 callBcak.onNodeStatusChanged = OnNodeStatusChangedCb;
602 NodeStatus info;
603 ClientBusCenterManagerInterfaceMock busCentManagerMock;
604 EXPECT_CALL(busCentManagerMock, SoftbusGetConfig(_, _, _)).WillRepeatedly(Return(SOFTBUS_OK));
605 EXPECT_TRUE(
606 LnnOnNodeStatusChanged(nullptr, reinterpret_cast<void *>(&info), TYPE_SCREEN_STATUS) == SOFTBUS_INVALID_PARAM);
607 EXPECT_TRUE(LnnOnNodeStatusChanged("", nullptr, TYPE_STATUS_MAX + 1) == SOFTBUS_INVALID_PARAM);
608 EXPECT_CALL(busCentManagerMock, BusCenterServerProxyInit()).WillRepeatedly(Return(SOFTBUS_OK));
609 EXPECT_CALL(busCentManagerMock, BusCenterServerProxyDeInit()).WillRepeatedly(Return());
610 EXPECT_TRUE(BusCenterClientInit() == SOFTBUS_OK);
611 EXPECT_TRUE(RegNodeDeviceStateCbInner(nullptr, &callBcak) == SOFTBUS_INVALID_PARAM);
612 EXPECT_TRUE(RegNodeDeviceStateCbInner(PKGNAME, &callBcak) == SOFTBUS_OK);
613 EXPECT_TRUE(
614 LnnOnNodeStatusChanged("", reinterpret_cast<void *>(&info), TYPE_STATUS_MAX + 1) == SOFTBUS_INVALID_PARAM);
615 EXPECT_TRUE(LnnOnNodeStatusChanged("", reinterpret_cast<void *>(&info), TYPE_SCREEN_STATUS) == SOFTBUS_OK);
616 BusCenterClientDeinit();
617 }
618
OnTimeSyncResultCb(const TimeSyncResultInfo * info,int32_t retCode)619 static void OnTimeSyncResultCb(const TimeSyncResultInfo *info, int32_t retCode)
620 {
621 (void)info;
622 (void)retCode;
623 printf("on call time sync result cb\n");
624 }
625
626 /*
627 * @tc.name: LNN_ON_TIME_SYNC_RESULT_Test_001
628 * @tc.desc: lnn on time sync result test
629 * @tc.type: FUNC
630 * @tc.require:
631 */
632 HWTEST_F(ClientBusCentManagerTest, LNN_ON_TIME_SYNC_RESULT_Test_001, TestSize.Level1)
633 {
634 int32_t retCode = 0;
635 ITimeSyncCb cb;
636 cb.onTimeSyncResult = OnTimeSyncResultCb;
637 TimeSyncResultInfo info;
638 (void)memset_s(&info, sizeof(TimeSyncResultInfo), 0, sizeof(TimeSyncResultInfo));
639 (void)strcpy_s(info.target.targetNetworkId, NETWORK_ID_BUF_LEN, NODE1_NETWORK_ID);
640 ClientBusCenterManagerInterfaceMock busCentManagerMock;
641 EXPECT_CALL(busCentManagerMock, SoftbusGetConfig(_, _, _)).WillRepeatedly(Return(SOFTBUS_OK));
642 EXPECT_TRUE(LnnOnTimeSyncResult(nullptr, retCode) == SOFTBUS_INVALID_PARAM);
643 EXPECT_CALL(busCentManagerMock, BusCenterServerProxyInit()).WillRepeatedly(Return(SOFTBUS_OK));
644 EXPECT_CALL(busCentManagerMock, BusCenterServerProxyDeInit()).WillRepeatedly(Return());
645 EXPECT_TRUE(BusCenterClientInit() == SOFTBUS_OK);
646 EXPECT_CALL(busCentManagerMock, ServerIpcStartTimeSync(_, _, _, _)).WillRepeatedly(Return(SOFTBUS_OK));
647 EXPECT_TRUE(StartTimeSyncInner(nullptr, NODE1_NETWORK_ID, LOW_ACCURACY, SHORT_PERIOD, &cb) == SOFTBUS_OK);
648 EXPECT_TRUE(LnnOnTimeSyncResult(reinterpret_cast<const void *>(&info), retCode) == SOFTBUS_OK);
649 BusCenterClientDeinit();
650 }
651
652 /*
653 * @tc.name: REG_DATA_LEVEL_CHANGE_CB_INNER_Test_001
654 * @tc.desc: reg data level change cb inner test
655 * @tc.type: FUNC
656 * @tc.require:
657 */
658 HWTEST_F(ClientBusCentManagerTest, REG_DATA_LEVEL_CHANGE_CB_INNER_Test_001, TestSize.Level1)
659 {
660 IDataLevelCb cb;
661 (void)memset_s(&cb, sizeof(IDataLevelCb), 0, sizeof(IDataLevelCb));
662 EXPECT_EQ(RegDataLevelChangeCbInner(nullptr, &cb), SOFTBUS_STRCPY_ERR);
663
664 ClientBusCenterManagerInterfaceMock busCentManagerMock;
665 EXPECT_CALL(busCentManagerMock, ServerIpcRegDataLevelChangeCb(_)).WillOnce(Return(SOFTBUS_SERVER_NOT_INIT));
666 EXPECT_EQ(RegDataLevelChangeCbInner("pkgName", &cb), SOFTBUS_SERVER_NOT_INIT);
667
668 EXPECT_CALL(busCentManagerMock, ServerIpcRegDataLevelChangeCb(_)).WillOnce(Return(SOFTBUS_OK));
669 EXPECT_EQ(RegDataLevelChangeCbInner("pkgName", &cb), SOFTBUS_OK);
670 }
671
672 /*
673 * @tc.name: REG_BLE_RANGE_INNER_Test_001
674 * @tc.desc: reg ble range cb inner test
675 * @tc.type: FUNC
676 * @tc.require:
677 */
678 HWTEST_F(ClientBusCentManagerTest, REG_BLE_RANGE_INNER_Test_001, TestSize.Level1)
679 {
680 IRangeCallback cb;
681 (void)memset_s(&cb, sizeof(IRangeCallback), 0, sizeof(IRangeCallback));
682
683 ClientBusCenterManagerInterfaceMock busCentManagerMock;
684 EXPECT_CALL(busCentManagerMock, ServerIpcRegRangeCbForMsdp(_)).WillOnce(Return(SOFTBUS_SERVER_NOT_INIT));
685 EXPECT_EQ(RegRangeCbForMsdpInner("pkgName", &cb), SOFTBUS_SERVER_NOT_INIT);
686
687 EXPECT_CALL(busCentManagerMock, ServerIpcRegRangeCbForMsdp(_)).WillOnce(Return(SOFTBUS_OK));
688 EXPECT_EQ(RegRangeCbForMsdpInner("pkgName", &cb), SOFTBUS_OK);
689 }
690
691 /*
692 * @tc.name: UNREG_BLE_RANGE_INNER_Test_001
693 * @tc.desc: unReg ble range cb inner test
694 * @tc.type: FUNC
695 * @tc.require:
696 */
697 HWTEST_F(ClientBusCentManagerTest, UNREG_BLE_RANGE_INNER_Test_001, TestSize.Level1)
698 {
699 ClientBusCenterManagerInterfaceMock busCentManagerMock;
700 EXPECT_CALL(busCentManagerMock, ServerIpcUnregRangeCbForMsdp(_)).WillOnce(Return(SOFTBUS_SERVER_NOT_INIT));
701 EXPECT_EQ(UnregRangeCbForMsdpInner("pkgName"), SOFTBUS_SERVER_NOT_INIT);
702
703 EXPECT_CALL(busCentManagerMock, ServerIpcUnregRangeCbForMsdp(_)).WillOnce(Return(SOFTBUS_OK));
704 EXPECT_EQ(UnregRangeCbForMsdpInner("pkgName"), SOFTBUS_OK);
705 }
706
707 /*
708 * @tc.name: TRIGGER_HB_FOR_RANGE_INNER_Test_001
709 * @tc.desc: reg ble range cb inner test
710 * @tc.type: FUNC
711 * @tc.require:
712 */
713 HWTEST_F(ClientBusCentManagerTest, TRIGGER_HB_FOR_RANGE_INNER_Test_001, TestSize.Level1)
714 {
715 RangeConfig config;
716
717 ClientBusCenterManagerInterfaceMock busCentManagerMock;
718 EXPECT_CALL(busCentManagerMock, ServerIpcTriggerRangeForMsdp(_, _))
719 .WillOnce(Return(SOFTBUS_SERVER_NOT_INIT));
720 EXPECT_EQ(TriggerRangeForMsdpInner("pkgName", &config), SOFTBUS_SERVER_NOT_INIT);
721
722 EXPECT_CALL(busCentManagerMock, ServerIpcTriggerRangeForMsdp(_, _)).WillOnce(Return(SOFTBUS_OK));
723 EXPECT_EQ(TriggerRangeForMsdpInner("pkgName", &config), SOFTBUS_OK);
724 }
725
726 /*
727 * @tc.name: RESTART_REG_DATA_LEVEL_CHANGE_Test_001
728 * @tc.desc: restart reg data level change test
729 * @tc.type: FUNC
730 * @tc.require:
731 */
732 HWTEST_F(ClientBusCentManagerTest, RESTART_REG_DATA_LEVEL_CHANGE_Test_001, TestSize.Level1)
733 {
734 g_regDataLevelChangePkgName[0] = '\0';
735 EXPECT_NO_FATAL_FAILURE(RestartRegDataLevelChange());
736
737 g_regDataLevelChangePkgName[0] = '1';
738 g_regDataLevelChangePkgName[1] = '\0';
739 ClientBusCenterManagerInterfaceMock busCentManagerMock;
740 EXPECT_CALL(busCentManagerMock, ServerIpcRegDataLevelChangeCb(_)).WillOnce(Return(SOFTBUS_SERVER_NOT_INIT));
741 EXPECT_NO_FATAL_FAILURE(RestartRegDataLevelChange());
742
743 EXPECT_CALL(busCentManagerMock, ServerIpcRegDataLevelChangeCb(_)).WillOnce(Return(SOFTBUS_OK));
744 EXPECT_NO_FATAL_FAILURE(RestartRegDataLevelChange());
745 }
746
747 /*
748 * @tc.name: UNREG_DATA_LEVEL_CHANGE_CB_INNER_Test_001
749 * @tc.desc: unreg data level change cb inner test
750 * @tc.type: FUNC
751 * @tc.require:
752 */
753 HWTEST_F(ClientBusCentManagerTest, UNREG_DATA_LEVEL_CHANGE_CB_INNER_Test_001, TestSize.Level1)
754 {
755 ClientBusCenterManagerInterfaceMock busCentManagerMock;
756 EXPECT_CALL(busCentManagerMock, ServerIpcUnregDataLevelChangeCb(_)).WillOnce(Return(SOFTBUS_SERVER_NOT_INIT));
757 EXPECT_EQ(UnregDataLevelChangeCbInner(nullptr), SOFTBUS_SERVER_NOT_INIT);
758
759 EXPECT_CALL(busCentManagerMock, ServerIpcUnregDataLevelChangeCb(_)).WillOnce(Return(SOFTBUS_OK));
760 auto ret = UnregDataLevelChangeCbInner(nullptr);
761 EXPECT_EQ(ret, SOFTBUS_OK);
762 }
763
764 /*
765 * @tc.name: SET_DATA_LEVEL_INNER_Test_001
766 * @tc.desc: set data level inner test
767 * @tc.type: FUNC
768 * @tc.require:
769 */
770 HWTEST_F(ClientBusCentManagerTest, SET_DATA_LEVEL_INNER_Test_001, TestSize.Level1)
771 {
772 ClientBusCenterManagerInterfaceMock busCentManagerMock;
773 EXPECT_CALL(busCentManagerMock, ServerIpcSetDataLevel(_)).WillOnce(Return(SOFTBUS_SERVER_NOT_INIT));
774 EXPECT_EQ(SetDataLevelInner(nullptr), SOFTBUS_SERVER_NOT_INIT);
775
776 EXPECT_CALL(busCentManagerMock, ServerIpcSetDataLevel(_)).WillOnce(Return(SOFTBUS_OK));
777 auto ret = SetDataLevelInner(nullptr);
778 EXPECT_EQ(ret, SOFTBUS_OK);
779 }
780
781 /*
782 * @tc.name: LNN_ON_LOCAL_NETWORK_ID_CHANGED_Test_001
783 * @tc.desc: lnn on local network id changed test
784 * @tc.type: FUNC
785 * @tc.require:
786 */
787 HWTEST_F(ClientBusCentManagerTest, LNN_ON_LOCAL_NETWORK_ID_CHANGED_Test_001, TestSize.Level1)
788 {
789 SoftBusMutexInit(&g_busCenterClient.lock, nullptr);
790 EXPECT_EQ(LnnOnLocalNetworkIdChanged(nullptr), SOFTBUS_INVALID_PARAM);
791
792 g_busCenterClient.isInit = false;
793 EXPECT_EQ(LnnOnLocalNetworkIdChanged("pkgName"), SOFTBUS_NO_INIT);
794
795 g_busCenterClient.isInit = true;
796 ClientBusCenterManagerInterfaceMock busCentManagerMock;
797 EXPECT_CALL(busCentManagerMock, SoftBusMutexLockInner(_)).WillOnce(Return(SOFTBUS_LOCK_ERR));
798 EXPECT_EQ(LnnOnLocalNetworkIdChanged("pkgName"), SOFTBUS_LOCK_ERR);
799
800 EXPECT_CALL(busCentManagerMock, SoftBusMutexLockInner(_)).WillOnce(Return(SOFTBUS_OK));
801 EXPECT_CALL(busCentManagerMock, SoftBusMutexUnlockInner(_)).WillOnce(Return(SOFTBUS_LOCK_ERR));
802 auto ret = LnnOnLocalNetworkIdChanged("pkgName");
803 EXPECT_EQ(ret, SOFTBUS_OK);
804
805 EXPECT_CALL(busCentManagerMock, SoftBusMutexLockInner(_)).WillOnce(Return(SOFTBUS_OK));
806 EXPECT_CALL(busCentManagerMock, SoftBusMutexUnlockInner(_)).WillOnce(Return(SOFTBUS_OK));
807 ret = LnnOnLocalNetworkIdChanged("pkgName");
808 EXPECT_EQ(ret, SOFTBUS_OK);
809 }
810
811 /*
812 * @tc.name: LNN_ON_NODE_DEVICE_TRUSTED_CHANGE_Test_001
813 * @tc.desc: lnn on node device trusted change test
814 * @tc.type: FUNC
815 * @tc.require:
816 */
817 HWTEST_F(ClientBusCentManagerTest, LNN_ON_NODE_DEVICE_TRUSTED_CHANGE_Test_001, TestSize.Level1)
818 {
819 SoftBusMutexInit(&g_busCenterClient.lock, nullptr);
820 EXPECT_EQ(LnnOnNodeDeviceTrustedChange(nullptr, 0, nullptr, 0), SOFTBUS_INVALID_PARAM);
821
822 g_busCenterClient.isInit = false;
823 EXPECT_EQ(LnnOnNodeDeviceTrustedChange("pkgName", 0, nullptr, 0), SOFTBUS_NO_INIT);
824
825 g_busCenterClient.isInit = true;
826 ClientBusCenterManagerInterfaceMock busCentManagerMock;
827 EXPECT_CALL(busCentManagerMock, SoftBusMutexLockInner(_)).WillOnce(Return(SOFTBUS_LOCK_ERR));
828 EXPECT_EQ(LnnOnNodeDeviceTrustedChange("pkgName", 0, nullptr, 0), SOFTBUS_LOCK_ERR);
829
830 EXPECT_CALL(busCentManagerMock, SoftBusMutexLockInner(_)).WillOnce(Return(SOFTBUS_OK));
831 EXPECT_CALL(busCentManagerMock, SoftBusMutexUnlockInner(_)).WillOnce(Return(SOFTBUS_LOCK_ERR));
832 EXPECT_EQ(LnnOnNodeDeviceTrustedChange("pkgName", 0, nullptr, 0), SOFTBUS_OK);
833
834 EXPECT_CALL(busCentManagerMock, SoftBusMutexLockInner(_)).WillOnce(Return(SOFTBUS_OK));
835 EXPECT_CALL(busCentManagerMock, SoftBusMutexUnlockInner(_)).WillOnce(Return(SOFTBUS_LOCK_ERR));
836 EXPECT_EQ(LnnOnNodeDeviceTrustedChange("pkgName", 0, nullptr, 0), SOFTBUS_OK);
837 }
838
839 /*
840 * @tc.name: LNN_ON_HICHAIN_PROOF_EXCEPTION_Test_001
841 * @tc.desc: lnn on hichain proof exception test
842 * @tc.type: FUNC
843 * @tc.require:
844 */
845 HWTEST_F(ClientBusCentManagerTest, LNN_ON_HICHAIN_PROOF_EXCEPTION_Test_001, TestSize.Level1)
846 {
847 SoftBusMutexInit(&g_busCenterClient.lock, nullptr);
848 EXPECT_EQ(LnnOnHichainProofException(nullptr, nullptr, 0, 0, 0), SOFTBUS_INVALID_PARAM);
849
850 g_busCenterClient.isInit = false;
851 EXPECT_EQ(LnnOnHichainProofException("pkgName", nullptr, 0, 0, 0), SOFTBUS_NO_INIT);
852
853 g_busCenterClient.isInit = true;
854 ClientBusCenterManagerInterfaceMock busCentManagerMock;
855 EXPECT_CALL(busCentManagerMock, SoftBusMutexLockInner(_)).WillOnce(Return(SOFTBUS_LOCK_ERR));
856 EXPECT_EQ(LnnOnHichainProofException("pkgName", nullptr, 0, 0, 0), SOFTBUS_LOCK_ERR);
857
858 EXPECT_CALL(busCentManagerMock, SoftBusMutexLockInner(_)).WillOnce(Return(SOFTBUS_OK));
859 EXPECT_CALL(busCentManagerMock, SoftBusMutexUnlockInner(_)).WillOnce(Return(SOFTBUS_LOCK_ERR));
860 EXPECT_EQ(LnnOnHichainProofException("pkgName", nullptr, 0, 0, 0), SOFTBUS_OK);
861
862 EXPECT_CALL(busCentManagerMock, SoftBusMutexLockInner(_)).WillOnce(Return(SOFTBUS_OK));
863 EXPECT_CALL(busCentManagerMock, SoftBusMutexUnlockInner(_)).WillOnce(Return(SOFTBUS_LOCK_ERR));
864 EXPECT_EQ(LnnOnHichainProofException("pkgName", nullptr, 0, 0, 0), SOFTBUS_OK);
865 }
866
867 /*
868 * @tc.name: LNN_ON_TIME_SYNC_RESULT_Test_002
869 * @tc.desc: lnn on time sync result test
870 * @tc.type: FUNC
871 * @tc.require:
872 */
873 HWTEST_F(ClientBusCentManagerTest, LNN_ON_TIME_SYNC_RESULT_Test_002, TestSize.Level1)
874 {
875 SoftBusMutexInit(&g_busCenterClient.lock, nullptr);
876 EXPECT_EQ(LnnOnTimeSyncResult(nullptr, 0), SOFTBUS_INVALID_PARAM);
877
878 g_busCenterClient.isInit = false;
879 EXPECT_EQ(LnnOnTimeSyncResult("info", 0), SOFTBUS_NETWORK_CLIENT_NOT_INIT);
880
881 g_busCenterClient.isInit = true;
882 ClientBusCenterManagerInterfaceMock busCentManagerMock;
883 EXPECT_CALL(busCentManagerMock, SoftBusMutexLockInner(_)).WillOnce(Return(SOFTBUS_LOCK_ERR));
884 EXPECT_EQ(LnnOnTimeSyncResult("info", 0), SOFTBUS_LOCK_ERR);
885
886 EXPECT_CALL(busCentManagerMock, SoftBusMutexLockInner(_)).WillOnce(Return(SOFTBUS_OK));
887 EXPECT_CALL(busCentManagerMock, SoftBusMutexUnlockInner(_)).WillOnce(Return(SOFTBUS_LOCK_ERR));
888 EXPECT_EQ(LnnOnTimeSyncResult("info", 0), SOFTBUS_OK);
889
890 EXPECT_CALL(busCentManagerMock, SoftBusMutexLockInner(_)).WillOnce(Return(SOFTBUS_OK));
891 EXPECT_CALL(busCentManagerMock, SoftBusMutexUnlockInner(_)).WillOnce(Return(SOFTBUS_LOCK_ERR));
892 EXPECT_EQ(LnnOnTimeSyncResult("info", 0), SOFTBUS_OK);
893 }
894
895 /*
896 * @tc.name: LNN_ON_DATA_LEVEL_CHANGED_Test_001
897 * @tc.desc: lnn on data level changed test
898 * @tc.type: FUNC
899 * @tc.require:
900 */
901 HWTEST_F(ClientBusCentManagerTest, LNN_ON_DATA_LEVEL_CHANGED_Test_001, TestSize.Level1)
902 {
903 auto ptr = g_busCenterClient.dataLevelCb.onDataLevelChanged;
904 g_busCenterClient.dataLevelCb.onDataLevelChanged = nullptr;
905 EXPECT_NO_FATAL_FAILURE(LnnOnDataLevelChanged(nullptr, nullptr));
906
907 g_busCenterClient.dataLevelCb.onDataLevelChanged = ptr;
908 EXPECT_NO_FATAL_FAILURE(LnnOnDataLevelChanged(nullptr, nullptr));
909 }
910
911 /*
912 * @tc.name: DISC_RECOVERY_PUBLISH_Test_001
913 * @tc.desc: disc recovery publish test
914 * @tc.type: FUNC
915 * @tc.require:
916 */
917 HWTEST_F(ClientBusCentManagerTest, DISC_RECOVERY_PUBLISH_Test_001, TestSize.Level1)
918 {
919 g_isInited = false;
920 EXPECT_EQ(DiscRecoveryPublish(), SOFTBUS_OK);
921
922 g_isInited = true;
923 auto ret = DiscRecoveryPublish();
924 EXPECT_EQ(ret, SOFTBUS_LOCK_ERR);
925 }
926
927 /*
928 * @tc.name: DISC_RECOVERY_SUBSCRIBE_Test_001
929 * @tc.desc: disc recovery subscribe test
930 * @tc.type: FUNC
931 * @tc.require:
932 */
933 HWTEST_F(ClientBusCentManagerTest, DISC_RECOVERY_SUBSCRIBE_Test_001, TestSize.Level1)
934 {
935 g_isInited = false;
936 EXPECT_EQ(DiscRecoverySubscribe(), SOFTBUS_OK);
937
938 g_isInited = true;
939 auto ret = DiscRecoverySubscribe();
940 EXPECT_EQ(ret, SOFTBUS_LOCK_ERR);
941 }
942
943 /*
944 * @tc.name: IS_SAME_CONNECTION_ADDR_Test_001
945 * @tc.desc: is same connection addr test
946 * @tc.type: FUNC
947 * @tc.require:
948 */
949 HWTEST_F(ClientBusCentManagerTest, IS_SAME_CONNECTION_ADDR_Test_001, TestSize.Level1)
950 {
951 ConnectionAddr addr1;
952 (void)memset_s(&addr1, sizeof(ConnectionAddr), 0, sizeof(ConnectionAddr));
953 ConnectionAddr addr2;
954 (void)memset_s(&addr2, sizeof(ConnectionAddr), 0, sizeof(ConnectionAddr));
955 addr1.type = CONNECTION_ADDR_WLAN;
956 addr2.type = CONNECTION_ADDR_BR;
957 EXPECT_EQ(IsSameConnectionAddr(&addr1, &addr2), false);
958
959 addr1.type = CONNECTION_ADDR_BR;
960 addr2.type = CONNECTION_ADDR_BR;
961 memset_s(addr1.info.br.brMac, BT_MAC_LEN, 0, BT_MAC_LEN);
962 memset_s(addr2.info.br.brMac, BT_MAC_LEN, 0, BT_MAC_LEN);
963 EXPECT_EQ(IsSameConnectionAddr(&addr1, &addr2), true);
964
965 addr1.type = CONNECTION_ADDR_BLE;
966 addr2.type = CONNECTION_ADDR_BLE;
967 memset_s(addr2.info.ble.udidHash, UDID_HASH_LEN, 0, UDID_HASH_LEN);
968 memset_s(addr1.info.ble.bleMac, BT_MAC_LEN, 0, BT_MAC_LEN);
969 memset_s(addr2.info.ble.bleMac, BT_MAC_LEN, 0, BT_MAC_LEN);
970 EXPECT_EQ(IsSameConnectionAddr(&addr1, &addr2), true);
971
972 memset_s(addr1.info.ble.udidHash, UDID_HASH_LEN, 0, UDID_HASH_LEN);
973 memset_s(addr2.info.ble.udidHash, UDID_HASH_LEN, 1, UDID_HASH_LEN);
974 EXPECT_EQ(IsSameConnectionAddr(&addr1, &addr2), true);
975
976 memset_s(addr1.info.ble.udidHash, UDID_HASH_LEN, 1, UDID_HASH_LEN);
977 EXPECT_EQ(IsSameConnectionAddr(&addr1, &addr2), true);
978
979 addr1.type = CONNECTION_ADDR_WLAN;
980 addr2.type = CONNECTION_ADDR_WLAN;
981 memset_s(addr1.info.ip.ip, IP_STR_MAX_LEN, 0, IP_STR_MAX_LEN);
982 memset_s(addr2.info.ip.ip, IP_STR_MAX_LEN, 0, IP_STR_MAX_LEN);
983 addr1.info.ip.port = 0;
984 addr2.info.ip.port = 0;
985 EXPECT_EQ(IsSameConnectionAddr(&addr1, &addr2), true);
986
987 addr2.info.ip.port = 1;
988 EXPECT_EQ(IsSameConnectionAddr(&addr1, &addr2), false);
989 }
990
991 /*
992 * @tc.name: IS_SAME_CONNECTION_ADDR_Test_002
993 * @tc.desc: is same connection addr test
994 * @tc.type: FUNC
995 * @tc.require:
996 */
997 HWTEST_F(ClientBusCentManagerTest, IS_SAME_CONNECTION_ADDR_Test_002, TestSize.Level1)
998 {
999 ConnectionAddr addr1;
1000 (void)memset_s(&addr1, sizeof(ConnectionAddr), 0, sizeof(ConnectionAddr));
1001 ConnectionAddr addr2;
1002 (void)memset_s(&addr2, sizeof(ConnectionAddr), 0, sizeof(ConnectionAddr));
1003 addr1.type = CONNECTION_ADDR_WLAN;
1004 addr2.type = CONNECTION_ADDR_WLAN;
1005 memset_s(addr1.info.ip.ip, IP_STR_MAX_LEN, 0, IP_STR_MAX_LEN);
1006 memset_s(addr1.info.ip.ip, IP_STR_MAX_LEN, 1, IP_STR_MAX_LEN);
1007 addr1.info.ip.port = 0;
1008 addr2.info.ip.port = 0;
1009 EXPECT_EQ(IsSameConnectionAddr(&addr1, &addr2), false);
1010
1011 addr1.type = CONNECTION_ADDR_ETH;
1012 addr2.type = CONNECTION_ADDR_ETH;
1013 memset_s(addr1.info.ip.ip, IP_STR_MAX_LEN, 0, IP_STR_MAX_LEN);
1014 memset_s(addr2.info.ip.ip, IP_STR_MAX_LEN, 0, IP_STR_MAX_LEN);
1015 addr1.info.ip.port = 0;
1016 addr2.info.ip.port = 0;
1017 EXPECT_EQ(IsSameConnectionAddr(&addr1, &addr2), true);
1018
1019 addr2.info.ip.port = 1;
1020 EXPECT_EQ(IsSameConnectionAddr(&addr1, &addr2), false);
1021
1022 memset_s(addr1.info.ip.ip, IP_STR_MAX_LEN, 1, IP_STR_MAX_LEN);
1023 addr1.info.ip.port = 0;
1024 addr2.info.ip.port = 0;
1025 EXPECT_EQ(IsSameConnectionAddr(&addr1, &addr2), false);
1026
1027 addr1.type = CONNECTION_ADDR_SESSION;
1028 addr2.type = CONNECTION_ADDR_SESSION;
1029 addr1.info.session.sessionId = 0;
1030 addr2.info.session.sessionId = 0;
1031 addr1.info.session.channelId = 0;
1032 addr2.info.session.channelId = 0;
1033 addr1.info.session.type = 0;
1034 addr2.info.session.type = 0;
1035 EXPECT_EQ(IsSameConnectionAddr(&addr1, &addr2), true);
1036
1037 addr2.info.session.type = 1;
1038 EXPECT_EQ(IsSameConnectionAddr(&addr1, &addr2), false);
1039
1040 addr2.info.session.channelId = 1;
1041 EXPECT_EQ(IsSameConnectionAddr(&addr1, &addr2), false);
1042
1043 addr2.info.session.sessionId = 1;
1044 EXPECT_EQ(IsSameConnectionAddr(&addr1, &addr2), false);
1045
1046 addr1.type = CONNECTION_ADDR_MAX;
1047 addr2.type = CONNECTION_ADDR_MAX;
1048 EXPECT_EQ(IsSameConnectionAddr(&addr1, &addr2), false);
1049 }
1050
1051 /*
1052 * @tc.name: ADD_LEAVE_LNNCB_ITEM_Test_001
1053 * @tc.desc: add leave lnncb item test
1054 * @tc.type: FUNC
1055 * @tc.require:
1056 */
1057 HWTEST_F(ClientBusCentManagerTest, ADD_LEAVE_LNNCB_ITEM_Test_001, TestSize.Level1)
1058 {
__anonb813c05c0102(const char *, int32_t) 1059 OnLeaveLNNResult cb = [](const char *, int32_t) -> void {};
1060 ListInit(&g_busCenterClient.leaveLNNCbList);
1061 EXPECT_EQ(AddLeaveLNNCbItem("1.2.3.4", cb), SOFTBUS_OK);
1062 }
1063
1064 /*
1065 * @tc.name: ADD_TIME_SYNC_CB_ITEM_Test_001
1066 * @tc.desc: add time sync cb item test
1067 * @tc.type: FUNC
1068 * @tc.require:
1069 */
1070 HWTEST_F(ClientBusCentManagerTest, ADD_TIME_SYNC_CB_ITEM_Test_001, TestSize.Level1)
1071 {
1072 ITimeSyncCb cb;
1073 (void)memset_s(&cb, sizeof(ITimeSyncCb), 0, sizeof(ITimeSyncCb));
__anonb813c05c0202(const TimeSyncResultInfo *, int32_t) 1074 cb.onTimeSyncResult = [](const TimeSyncResultInfo *, int32_t) ->void {};
1075 ListInit(&g_busCenterClient.timeSyncCbList);
1076 EXPECT_EQ(AddTimeSyncCbItem("1.2.3.4", &cb), SOFTBUS_OK);
1077 }
1078
1079 /*
1080 * @tc.name: FREE_DISC_PUBLISH_MSG_Test_001
1081 * @tc.desc: free disc publish msg test
1082 * @tc.type: FUNC
1083 * @tc.require:
1084 */
1085 HWTEST_F(ClientBusCentManagerTest, FREE_DISC_PUBLISH_MSG_Test_001, TestSize.Level1)
1086 {
1087 DiscPublishMsg *msg = nullptr;
1088 EXPECT_NO_FATAL_FAILURE(FreeDiscPublishMsg(&msg));
1089
1090 msg = (DiscPublishMsg *)SoftBusCalloc(sizeof(DiscPublishMsg));
1091 if (msg == nullptr) {
1092 COMM_LOGE(COMM_TEST, "msg calloc fail");
1093 return;
1094 }
1095 msg->info = nullptr;
1096 EXPECT_NO_FATAL_FAILURE(FreeDiscPublishMsg(&msg));
1097
1098 msg = (DiscPublishMsg *)SoftBusCalloc(sizeof(DiscPublishMsg));
1099 if (msg == nullptr) {
1100 COMM_LOGE(COMM_TEST, "msg calloc fail");
1101 return;
1102 }
1103 msg->info = (PublishInfo *)SoftBusCalloc(sizeof(PublishInfo));
1104 if (msg->info == nullptr) {
1105 COMM_LOGE(COMM_TEST, "msgInfo calloc fail");
1106 SoftBusFree(msg);
1107 return;
1108 }
1109 msg->info->capability = nullptr;
1110 msg->info->capabilityData = nullptr;
1111 EXPECT_NO_FATAL_FAILURE(FreeDiscPublishMsg(&msg));
1112 }
1113
1114 /*
1115 * @tc.name: FREE_DISC_SUBSCRIBE_MSG_Test_001
1116 * @tc.desc: free disc subscribe msg test
1117 * @tc.type: FUNC
1118 * @tc.require:
1119 */
1120 HWTEST_F(ClientBusCentManagerTest, FREE_DISC_SUBSCRIBE_MSG_Test_001, TestSize.Level1)
1121 {
1122 DiscSubscribeMsg *msg = nullptr;
1123 EXPECT_NO_FATAL_FAILURE(FreeDiscSubscribeMsg(&msg));
1124
1125 msg = (DiscSubscribeMsg *)SoftBusCalloc(sizeof(DiscSubscribeMsg));
1126 if (msg == nullptr) {
1127 COMM_LOGE(COMM_TEST, "msg calloc fail");
1128 return;
1129 }
1130 msg->info = nullptr;
1131 EXPECT_NO_FATAL_FAILURE(FreeDiscSubscribeMsg(&msg));
1132
1133 msg = (DiscSubscribeMsg *)SoftBusCalloc(sizeof(DiscSubscribeMsg));
1134 if (msg == nullptr) {
1135 COMM_LOGE(COMM_TEST, "msg calloc fail");
1136 return;
1137 }
1138 msg->info = (SubscribeInfo *)SoftBusCalloc(sizeof(SubscribeInfo));
1139 if (msg->info == nullptr) {
1140 COMM_LOGE(COMM_TEST, "msgInfo calloc fail");
1141 SoftBusFree(msg);
1142 return;
1143 }
1144 msg->info->capability = nullptr;
1145 msg->info->capabilityData = nullptr;
1146 EXPECT_NO_FATAL_FAILURE(FreeDiscSubscribeMsg(&msg));
1147 }
1148 } // namespace OHOS