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 <gtest/gtest.h>
17 #include <securec.h>
18 #include <cstddef>
19 #include <cstdlib>
20 #include <cstring>
21 
22 #include "client_bus_center_manager_mock.h"
23 #include "client_bus_center_manager.h"
24 #include "softbus_adapter_mem.h"
25 #include "softbus_common.h"
26 #include "softbus_config_type.h"
27 #include "softbus_error_code.h"
28 
29 namespace OHOS {
30 using namespace testing::ext;
31 using namespace testing;
32 constexpr char NODE1_BR_MAC[] = "12345TTU";
33 constexpr char NODE1_BLE_MAC[] = "23456TTU";
34 constexpr char NODE1_IP[] = "10.146.181.134";
35 constexpr uint16_t NODE1_PORT = 10;
36 constexpr char NODE1_NETWORK_ID[] = "235689BNHFCF";
37 constexpr int32_t NODE1_SESSION_ID = 100;
38 constexpr int32_t NODE1_CHANNEL_ID = 100;
39 constexpr int32_t NODE1_SESSION_TYPE = 100;
40 constexpr int LNN_PUBLISH_ID = 0;
41 constexpr int LNN_SUBSCRIBE_ID = 0;
42 constexpr char CAPABILITY[] = "ddmpCapabilityTest";
43 constexpr unsigned char CAPABILITY_DATA[] = "ddmpCapabilityTest";
44 constexpr uint32_t EVENT = 15;
45 constexpr int32_t INVALID_TYPE = -1;
46 constexpr int32_t TYPE = 1;
47 constexpr int32_t LNN_REFRESH_ID = 0;
48 constexpr int32_t RESULT_REASON = -1;
49 constexpr char PKGNAME[] = "softbustest";
50 class ClientBusCentManagerTest : public testing::Test {
51 public:
52     static void SetUpTestCase();
53     static void TearDownTestCase();
54     void SetUp();
55     void TearDown();
56 };
57 
SetUpTestCase()58 void ClientBusCentManagerTest::SetUpTestCase() {}
59 
TearDownTestCase()60 void ClientBusCentManagerTest::TearDownTestCase() {}
61 
SetUp()62 void ClientBusCentManagerTest::SetUp() {}
63 
TearDown()64 void ClientBusCentManagerTest::TearDown() {}
65 
66 /*
67 * @tc.name: BUS_CENTER_CLIENT_INIT_Test_001
68 * @tc.desc: bus center client init test
69 * @tc.type: FUNC
70 * @tc.require:
71 */
72 HWTEST_F(ClientBusCentManagerTest, BUS_CENTER_CLIENT_INIT_Test_001, TestSize.Level1)
73 {
74     ClientBusCenterManagerInterfaceMock busCentManagerMock;
75     EXPECT_CALL(busCentManagerMock, SoftbusGetConfig(_, _, _)).WillRepeatedly(Return(SOFTBUS_ERR));
76     EXPECT_CALL(busCentManagerMock, BusCenterServerProxyInit())
77         .WillOnce(Return(SOFTBUS_ERR)).WillRepeatedly(Return(SOFTBUS_OK));
78     EXPECT_CALL(busCentManagerMock, BusCenterServerProxyDeInit()).WillRepeatedly(Return());
79     EXPECT_TRUE(BusCenterClientInit() == SOFTBUS_ERR);
80     EXPECT_TRUE(BusCenterClientInit() == SOFTBUS_OK);
81     BusCenterClientDeinit();
82 }
83 
84 /*
85 * @tc.name: JOIN_LNN_INNER_Test_001
86 * @tc.desc: join lnn inner test
87 * @tc.type: FUNC
88 * @tc.require:
89 */
90 HWTEST_F(ClientBusCentManagerTest, JOIN_LNN_INNER_Test_001, TestSize.Level1)
91 {
92     OnJoinLNNResult cb = nullptr;
93     ConnectionAddr target1;
94     (void)memset_s(&target1, sizeof(ConnectionAddr), 0, sizeof(ConnectionAddr));
95     target1.type = CONNECTION_ADDR_BR;
96     (void)strcpy_s(target1.info.br.brMac, BT_MAC_LEN, NODE1_BR_MAC);
97     (void)strcpy_s(target1.info.ble.bleMac, BT_MAC_LEN, NODE1_BLE_MAC);
98     (void)strcpy_s(target1.info.ip.ip, IP_STR_MAX_LEN, NODE1_IP);
99     target1.info.ip.port = NODE1_PORT;
100     target1.info.session.sessionId = NODE1_SESSION_ID;
101     target1.info.session.channelId = NODE1_CHANNEL_ID;
102     target1.info.session.type = NODE1_SESSION_TYPE;
103     ClientBusCenterManagerInterfaceMock busCentManagerMock;
104     EXPECT_CALL(busCentManagerMock, SoftbusGetConfig(_, _, _)).WillRepeatedly(Return(SOFTBUS_OK));
105     EXPECT_CALL(busCentManagerMock, BusCenterServerProxyInit()).WillRepeatedly(Return(SOFTBUS_OK));
106     EXPECT_CALL(busCentManagerMock, BusCenterServerProxyDeInit()).WillRepeatedly(Return());
107     EXPECT_TRUE(BusCenterClientInit() == SOFTBUS_OK);
108     EXPECT_CALL(busCentManagerMock, ServerIpcJoinLNN(_, _, _))
109         .WillOnce(Return(SOFTBUS_ERR))
110         .WillRepeatedly(Return(SOFTBUS_OK));
111     EXPECT_TRUE(JoinLNNInner(nullptr, &target1, cb) == SOFTBUS_ERR);
112     EXPECT_TRUE(JoinLNNInner(nullptr, &target1, cb) == SOFTBUS_OK);
113     EXPECT_TRUE(JoinLNNInner(nullptr, &target1, nullptr) == SOFTBUS_ALREADY_EXISTED);
114     target1.type = CONNECTION_ADDR_BLE;
115     EXPECT_TRUE(JoinLNNInner(nullptr, &target1, nullptr) == SOFTBUS_OK);
116     target1.type = CONNECTION_ADDR_WLAN;
117     EXPECT_TRUE(JoinLNNInner(nullptr, &target1, nullptr) == SOFTBUS_OK);
118     target1.type = CONNECTION_ADDR_ETH;
119     EXPECT_TRUE(JoinLNNInner(nullptr, &target1, nullptr) == SOFTBUS_OK);
120     target1.type = CONNECTION_ADDR_SESSION;
121     EXPECT_TRUE(JoinLNNInner(nullptr, &target1, nullptr) == SOFTBUS_OK);
122     target1.type = CONNECTION_ADDR_MAX;
123     EXPECT_TRUE(JoinLNNInner(nullptr, &target1, nullptr) == SOFTBUS_OK);
124     BusCenterClientDeinit();
125 }
126 
127 /*
128 * @tc.name: LEAVE_LNN_INNER_Test_001
129 * @tc.desc: leave lnn inner test
130 * @tc.type: FUNC
131 * @tc.require:
132 */
133 HWTEST_F(ClientBusCentManagerTest, LEAVE_LNN_INNER_Test_001, TestSize.Level1)
134 {
135     OnLeaveLNNResult cb = nullptr;
136     ClientBusCenterManagerInterfaceMock busCentManagerMock;
137     EXPECT_CALL(busCentManagerMock, SoftbusGetConfig(_, _, _)).WillRepeatedly(Return(SOFTBUS_OK));
138     EXPECT_CALL(busCentManagerMock, BusCenterServerProxyInit()).WillRepeatedly(Return(SOFTBUS_OK));
139     EXPECT_CALL(busCentManagerMock, BusCenterServerProxyDeInit()).WillRepeatedly(Return());
140     EXPECT_TRUE(BusCenterClientInit() == SOFTBUS_OK);
141     EXPECT_CALL(busCentManagerMock, ServerIpcLeaveLNN(_, _))
142         .WillOnce(Return(SOFTBUS_ERR))
143         .WillRepeatedly(Return(SOFTBUS_OK));
144     EXPECT_TRUE(LeaveLNNInner(nullptr, NODE1_NETWORK_ID, cb) == SOFTBUS_ERR);
145     EXPECT_TRUE(LeaveLNNInner(nullptr, NODE1_NETWORK_ID, cb) == SOFTBUS_OK);
146     EXPECT_TRUE(LeaveLNNInner(nullptr, NODE1_NETWORK_ID, nullptr) == SOFTBUS_ERR);
147     BusCenterClientDeinit();
148 }
149 
150 /*
151 * @tc.name: REG_NODE_DEVICE_STATE_CB_INNER_Test_001
152 * @tc.desc: reg node device state cb inner test
153 * @tc.type: FUNC
154 * @tc.require:
155 */
156 HWTEST_F(ClientBusCentManagerTest, REG_NODE_DEVICE_STATE_CB_INNER_Test_001, TestSize.Level1)
157 {
158     INodeStateCb callback;
159     ClientBusCenterManagerInterfaceMock busCentManagerMock;
160     EXPECT_CALL(busCentManagerMock, SoftbusGetConfig(_, _, _)).WillRepeatedly(Return(SOFTBUS_OK));
161     EXPECT_CALL(busCentManagerMock, BusCenterServerProxyInit()).WillRepeatedly(Return(SOFTBUS_OK));
162     EXPECT_CALL(busCentManagerMock, BusCenterServerProxyDeInit()).WillRepeatedly(Return());
163     EXPECT_TRUE(BusCenterClientInit() == SOFTBUS_OK);
164     EXPECT_TRUE(RegNodeDeviceStateCbInner(nullptr, &callback) == SOFTBUS_INVALID_PARAM);
165     EXPECT_TRUE(RegNodeDeviceStateCbInner(PKGNAME, &callback) == SOFTBUS_OK);
166     BusCenterClientDeinit();
167 }
168 
169 /*
170 * @tc.name: UNREG_NODE_DEVICE_STATE_CB_INNER_Test_001
171 * @tc.desc: unreg node device state cb inner test
172 * @tc.type: FUNC
173 * @tc.require:
174 */
175 HWTEST_F(ClientBusCentManagerTest, UNREG_NODE_DEVICE_STATE_CB_INNER_Test_001, TestSize.Level1)
176 {
177     INodeStateCb callback;
178     ClientBusCenterManagerInterfaceMock busCentManagerMock;
179     EXPECT_CALL(busCentManagerMock, SoftbusGetConfig(_, _, _)).WillRepeatedly(Return(SOFTBUS_OK));
180     EXPECT_CALL(busCentManagerMock, BusCenterServerProxyInit()).WillRepeatedly(Return(SOFTBUS_OK));
181     EXPECT_CALL(busCentManagerMock, BusCenterServerProxyDeInit()).WillRepeatedly(Return());
182     EXPECT_TRUE(BusCenterClientInit() == SOFTBUS_OK);
183     EXPECT_TRUE(UnregNodeDeviceStateCbInner(&callback) == SOFTBUS_OK);
184     BusCenterClientDeinit();
185 }
186 
187 /*
188 * @tc.name: GET_ALL_NODE_DEVICE_INFO_INNER_Test_001
189 * @tc.desc: get all node device info inner test
190 * @tc.type: FUNC
191 * @tc.require:
192 */
193 HWTEST_F(ClientBusCentManagerTest, GET_ALL_NODE_DEVICE_INFO_INNER_Test_001, TestSize.Level1)
194 {
195     ClientBusCenterManagerInterfaceMock busCentManagerMock;
196     EXPECT_CALL(busCentManagerMock, ServerIpcGetAllOnlineNodeInfo(_, _, _, _))
197         .WillOnce(Return(SOFTBUS_ERR))
198         .WillRepeatedly(Return(SOFTBUS_OK));
199     EXPECT_TRUE(GetAllNodeDeviceInfoInner(nullptr, nullptr, nullptr) == SOFTBUS_ERR);
200     EXPECT_TRUE(GetAllNodeDeviceInfoInner(nullptr, nullptr, nullptr) == SOFTBUS_OK);
201 }
202 
203 /*
204 * @tc.name: GET_LOCAL_NODE_DEVICE_INFO_INNER_Test_001
205 * @tc.desc: get local node device info inner test
206 * @tc.type: FUNC
207 * @tc.require:
208 */
209 HWTEST_F(ClientBusCentManagerTest, GET_LOCAL_NODE_DEVICE_INFO_INNER_Test_001, TestSize.Level1)
210 {
211     ClientBusCenterManagerInterfaceMock busCentManagerMock;
212     EXPECT_CALL(busCentManagerMock, ServerIpcGetLocalDeviceInfo(_, _, _))
213         .WillOnce(Return(SOFTBUS_ERR))
214         .WillRepeatedly(Return(SOFTBUS_OK));
215     EXPECT_TRUE(GetLocalNodeDeviceInfoInner(nullptr, nullptr) == SOFTBUS_ERR);
216     EXPECT_TRUE(GetLocalNodeDeviceInfoInner(nullptr, nullptr) == SOFTBUS_OK);
217 }
218 
219 /*
220 * @tc.name: GET_NODE_KEY_INFO_INNER_Test_001
221 * @tc.desc: get node key info inner test
222 * @tc.type: FUNC
223 * @tc.require:
224 */
225 HWTEST_F(ClientBusCentManagerTest, GET_NODE_KEY_INFO_INNER_Test_001, TestSize.Level1)
226 {
227     int32_t infoLen = 0;
228     ClientBusCenterManagerInterfaceMock busCentManagerMock;
229     EXPECT_CALL(busCentManagerMock, ServerIpcGetNodeKeyInfo(_, _, _, _, _))
230         .WillOnce(Return(SOFTBUS_ERR))
231         .WillRepeatedly(Return(SOFTBUS_OK));
232     EXPECT_TRUE(GetNodeKeyInfoInner(nullptr, nullptr, NODE_KEY_UDID, nullptr, infoLen) == SOFTBUS_ERR);
233     EXPECT_TRUE(GetNodeKeyInfoInner(nullptr, nullptr, NODE_KEY_UDID, nullptr, infoLen) == SOFTBUS_OK);
234 }
235 
236 /*
237 * @tc.name: SET_NODE_DATA_CHANGE_FLAG_INNER_Test_001
238 * @tc.desc: set node data change flag inner test
239 * @tc.type: FUNC
240 * @tc.require:
241 */
242 HWTEST_F(ClientBusCentManagerTest, SET_NODE_DATA_CHANGE_FLAG_INNER_Test_001, TestSize.Level1)
243 {
244     uint16_t dataChangeFlag = 0;
245     ClientBusCenterManagerInterfaceMock busCentManagerMock;
246     EXPECT_CALL(busCentManagerMock, ServerIpcSetNodeDataChangeFlag(_, _, _))
247         .WillOnce(Return(SOFTBUS_ERR))
248         .WillRepeatedly(Return(SOFTBUS_OK));
249     EXPECT_TRUE(SetNodeDataChangeFlagInner(nullptr, nullptr, dataChangeFlag) == SOFTBUS_ERR);
250     EXPECT_TRUE(SetNodeDataChangeFlagInner(nullptr, nullptr, dataChangeFlag) == SOFTBUS_OK);
251 }
252 
253 /*
254 * @tc.name: START_TIME_SYNC_INNER_Test_001
255 * @tc.desc: start time sync inner test
256 * @tc.type: FUNC
257 * @tc.require:
258 */
259 HWTEST_F(ClientBusCentManagerTest, START_TIME_SYNC_INNER_Test_001, TestSize.Level1)
260 {
261     ITimeSyncCb cb;
262     ClientBusCenterManagerInterfaceMock busCentManagerMock;
263     EXPECT_CALL(busCentManagerMock, SoftbusGetConfig(_, _, _)).WillRepeatedly(Return(SOFTBUS_OK));
264     EXPECT_CALL(busCentManagerMock, BusCenterServerProxyInit()).WillRepeatedly(Return(SOFTBUS_OK));
265     EXPECT_CALL(busCentManagerMock, BusCenterServerProxyDeInit()).WillRepeatedly(Return());
266     EXPECT_TRUE(BusCenterClientInit() == SOFTBUS_OK);
267     EXPECT_CALL(busCentManagerMock, ServerIpcStartTimeSync(_, _, _, _))
268         .WillOnce(Return(SOFTBUS_ERR))
269         .WillRepeatedly(Return(SOFTBUS_OK));
270     EXPECT_TRUE(StartTimeSyncInner(nullptr, nullptr, LOW_ACCURACY, SHORT_PERIOD, &cb) == SOFTBUS_ERR);
271     EXPECT_TRUE(StartTimeSyncInner(nullptr, NODE1_NETWORK_ID, LOW_ACCURACY, SHORT_PERIOD, &cb) == SOFTBUS_OK);
272     EXPECT_TRUE(StartTimeSyncInner(nullptr, NODE1_NETWORK_ID, LOW_ACCURACY, SHORT_PERIOD, &cb) == SOFTBUS_ERR);
273     BusCenterClientDeinit();
274 }
275 
276 /*
277 * @tc.name: STOP_TIME_SYNC_INNER_Test_001
278 * @tc.desc: stop time sync inner test
279 * @tc.type: FUNC
280 * @tc.require:
281 */
282 HWTEST_F(ClientBusCentManagerTest, STOP_TIME_SYNC_INNER_Test_001, TestSize.Level1)
283 {
284     ClientBusCenterManagerInterfaceMock busCentManagerMock;
285     EXPECT_CALL(busCentManagerMock, SoftbusGetConfig(_, _, _)).WillRepeatedly(Return(SOFTBUS_OK));
286     EXPECT_CALL(busCentManagerMock, BusCenterServerProxyInit()).WillRepeatedly(Return(SOFTBUS_OK));
287     EXPECT_CALL(busCentManagerMock, BusCenterServerProxyDeInit()).WillRepeatedly(Return());
288     EXPECT_TRUE(BusCenterClientInit() == SOFTBUS_OK);
289     EXPECT_CALL(busCentManagerMock, ServerIpcStopTimeSync(_, _)).WillRepeatedly(Return(SOFTBUS_ERR));
290     EXPECT_TRUE(StopTimeSyncInner(nullptr, NODE1_NETWORK_ID) == SOFTBUS_ERR);
291     BusCenterClientDeinit();
292 }
293 
294 /*
295 * @tc.name: STOP_TIME_SYNC_INNER_Test_002
296 * @tc.desc: stop time sync inner test
297 * @tc.type: FUNC
298 * @tc.require:
299 */
300 HWTEST_F(ClientBusCentManagerTest, STOP_TIME_SYNC_INNER_Test_002, TestSize.Level1)
301 {
302     ITimeSyncCb cb;
303     ClientBusCenterManagerInterfaceMock busCentManagerMock;
304     EXPECT_CALL(busCentManagerMock, SoftbusGetConfig(_, _, _)).WillRepeatedly(Return(SOFTBUS_OK));
305     EXPECT_CALL(busCentManagerMock, BusCenterServerProxyInit()).WillRepeatedly(Return(SOFTBUS_OK));
306     EXPECT_CALL(busCentManagerMock, BusCenterServerProxyDeInit()).WillRepeatedly(Return());
307     EXPECT_TRUE(BusCenterClientInit() == SOFTBUS_OK);
308     EXPECT_CALL(busCentManagerMock, ServerIpcStartTimeSync(_, _, _, _)).WillRepeatedly(Return(SOFTBUS_OK));
309     EXPECT_TRUE(StartTimeSyncInner(nullptr, NODE1_NETWORK_ID, LOW_ACCURACY, SHORT_PERIOD, &cb) == SOFTBUS_OK);
310     EXPECT_CALL(busCentManagerMock, ServerIpcStopTimeSync(_, _))
311         .WillOnce(Return(SOFTBUS_ERR))
312         .WillRepeatedly(Return(SOFTBUS_OK));
313     EXPECT_TRUE(StopTimeSyncInner(nullptr, NODE1_NETWORK_ID) == SOFTBUS_OK);
314     EXPECT_TRUE(StopTimeSyncInner(nullptr, NODE1_NETWORK_ID) == SOFTBUS_ERR);
315     BusCenterClientDeinit();
316 }
317 
OnPublishResultCb(int publishId,PublishResult reason)318 static void OnPublishResultCb(int publishId, PublishResult reason)
319 {
320     (void)publishId;
321     (void)reason;
322     printf("on call publish result cb\n");
323 }
324 
325 /*
326 * @tc.name: PUBLISH_LNN_INNER_Test_001
327 * @tc.desc: publish lnn inner test
328 * @tc.type: FUNC
329 * @tc.require:
330 */
331 HWTEST_F(ClientBusCentManagerTest, PUBLISH_LNN_INNER_Test_001, TestSize.Level1)
332 {
333     IPublishCb cb;
334     cb.OnPublishResult = OnPublishResultCb;
335     PublishInfo info;
336     (void)memset_s(&info, sizeof(PublishInfo), 0, sizeof(PublishInfo));
337     info.publishId = LNN_PUBLISH_ID;
338     info.mode = DISCOVER_MODE_PASSIVE;
339     info.medium = COAP;
340     info.freq = HIGH;
341     info.capability = CAPABILITY;
342     info.capabilityData = const_cast<unsigned char*>(CAPABILITY_DATA);
343     info.dataLen = strlen(reinterpret_cast<const char *>(const_cast<unsigned char*>(CAPABILITY_DATA)));
344     info.ranging = false;
345     LnnOnPublishLNNResult(LNN_PUBLISH_ID, RESULT_REASON);
346     ClientBusCenterManagerInterfaceMock busCentManagerMock;
347     EXPECT_CALL(busCentManagerMock, ServerIpcPublishLNN(_, _))
348         .WillOnce(Return(SOFTBUS_ERR))
349         .WillRepeatedly(Return(SOFTBUS_OK));
350     EXPECT_TRUE(PublishLNNInner(nullptr, &info, &cb) == SOFTBUS_ERR);
351     EXPECT_TRUE(PublishLNNInner(nullptr, &info, &cb) == SOFTBUS_OK);
352     LnnOnPublishLNNResult(LNN_PUBLISH_ID, RESULT_REASON);
353 }
354 
355 /*
356 * @tc.name: STOP_PUBLISH_LNN_INNER_Test_001
357 * @tc.desc: stop publish lnn inner test
358 * @tc.type: FUNC
359 * @tc.require:
360 */
361 HWTEST_F(ClientBusCentManagerTest, STOP_PUBLISH_LNN_INNER_Test_001, TestSize.Level1)
362 {
363     ClientBusCenterManagerInterfaceMock busCentManagerMock;
364     EXPECT_CALL(busCentManagerMock, ServerIpcStopPublishLNN(_, _))
365         .WillOnce(Return(SOFTBUS_ERR))
366         .WillRepeatedly(Return(SOFTBUS_OK));
367     EXPECT_TRUE(StopPublishLNNInner(nullptr, LNN_PUBLISH_ID) == SOFTBUS_ERR);
368     EXPECT_TRUE(StopPublishLNNInner(nullptr, LNN_PUBLISH_ID) == SOFTBUS_OK);
369 }
370 
OnDeviceFoundCb(const DeviceInfo * device)371 static void OnDeviceFoundCb(const DeviceInfo *device)
372 {
373     (void)device;
374     printf("on call device found cb\n");
375 }
376 
OnDiscoverResultCb(int32_t refreshId,RefreshResult reason)377 static void OnDiscoverResultCb(int32_t refreshId, RefreshResult reason)
378 {
379     (void)refreshId;
380     (void)reason;
381     printf("on call discover result cb\n");
382 }
383 
384 /*
385 * @tc.name: REFRESH_LNN_INNER_Test_001
386 * @tc.desc: refresh lnn inner test
387 * @tc.type: FUNC
388 * @tc.require:
389 */
390 HWTEST_F(ClientBusCentManagerTest, REFRESH_LNN_INNER_Test_001, TestSize.Level1)
391 {
392     SubscribeInfo info;
393     IRefreshCallback cb;
394     cb.OnDeviceFound = OnDeviceFoundCb;
395     cb.OnDiscoverResult = OnDiscoverResultCb;
396     (void)memset_s(&info, sizeof(SubscribeInfo), 0, sizeof(SubscribeInfo));
397     info.subscribeId = LNN_SUBSCRIBE_ID;
398     info.mode = DISCOVER_MODE_PASSIVE;
399     info.medium = COAP;
400     info.freq = HIGH;
401     info.isSameAccount = false;
402     info.isWakeRemote = false;
403     info.capability = CAPABILITY;
404     info.capabilityData = const_cast<unsigned char*>(CAPABILITY_DATA);
405     info.dataLen = strlen(reinterpret_cast<const char *>(const_cast<unsigned char*>(CAPABILITY_DATA)));
406     LnnOnRefreshLNNResult(LNN_REFRESH_ID, RESULT_REASON);
407     LnnOnRefreshDeviceFound(nullptr);
408     ClientBusCenterManagerInterfaceMock busCentManagerMock;
409     EXPECT_CALL(busCentManagerMock, ServerIpcRefreshLNN(_, _))
410         .WillOnce(Return(SOFTBUS_ERR))
411         .WillRepeatedly(Return(SOFTBUS_OK));
412     EXPECT_TRUE(RefreshLNNInner(nullptr, &info, &cb) == SOFTBUS_ERR);
413     EXPECT_TRUE(RefreshLNNInner(nullptr, &info, &cb) == SOFTBUS_OK);
414     LnnOnRefreshLNNResult(LNN_REFRESH_ID, RESULT_REASON);
415     LnnOnRefreshDeviceFound(nullptr);
416 }
417 
418 /*
419 * @tc.name: STOP_REFRESH_LNN_INNER_Test_001
420 * @tc.desc: stop refresh lnn inner test
421 * @tc.type: FUNC
422 * @tc.require:
423 */
424 HWTEST_F(ClientBusCentManagerTest, STOP_REFRESH_LNN_INNER_Test_001, TestSize.Level1)
425 {
426     ClientBusCenterManagerInterfaceMock busCentManagerMock;
427     EXPECT_CALL(busCentManagerMock, ServerIpcStopRefreshLNN(_, _))
428         .WillOnce(Return(SOFTBUS_ERR))
429         .WillRepeatedly(Return(SOFTBUS_OK));
430     EXPECT_TRUE(StopRefreshLNNInner(nullptr, LNN_SUBSCRIBE_ID) == SOFTBUS_ERR);
431     EXPECT_TRUE(StopRefreshLNNInner(nullptr, LNN_SUBSCRIBE_ID) == SOFTBUS_OK);
432 }
433 
OnJoinLNNResultCb(ConnectionAddr * addr,const char * networkId,int32_t retCode)434 static void OnJoinLNNResultCb(ConnectionAddr *addr, const char *networkId, int32_t retCode)
435 {
436     (void)addr;
437     (void)networkId;
438     (void)retCode;
439     printf("on call join LNN result cb\n");
440 }
441 
442 /*
443 * @tc.name: LNN_ONJOIN_RESULT_Test_001
444 * @tc.desc: lnn on join result test
445 * @tc.type: FUNC
446 * @tc.require:
447 */
448 HWTEST_F(ClientBusCentManagerTest, LNN_ONJOIN_RESULT_Test_001, TestSize.Level1)
449 {
450     int32_t retCode = 0;
451     ConnectionAddr addr;
452     (void)memset_s(&addr, sizeof(ConnectionAddr), 0, sizeof(ConnectionAddr));
453     addr.type = CONNECTION_ADDR_BR;
454     (void)strcpy_s(addr.info.br.brMac, BT_MAC_LEN, NODE1_BR_MAC);
455     EXPECT_TRUE(LnnOnJoinResult(nullptr, nullptr, retCode) == SOFTBUS_INVALID_PARAM);
456     ClientBusCenterManagerInterfaceMock busCentManagerMock;
457     EXPECT_CALL(busCentManagerMock, SoftbusGetConfig(_, _, _)).WillRepeatedly(Return(SOFTBUS_OK));
458     EXPECT_CALL(busCentManagerMock, BusCenterServerProxyInit()).WillRepeatedly(Return(SOFTBUS_OK));
459     EXPECT_CALL(busCentManagerMock, BusCenterServerProxyDeInit()).WillRepeatedly(Return());
460     EXPECT_TRUE(BusCenterClientInit() == SOFTBUS_OK);
461     EXPECT_TRUE(LnnOnJoinResult(reinterpret_cast<void *>(&addr), NODE1_NETWORK_ID, retCode) == SOFTBUS_OK);
462     EXPECT_CALL(busCentManagerMock, ServerIpcJoinLNN(_, _, _)).WillRepeatedly(Return(SOFTBUS_OK));
463     EXPECT_TRUE(JoinLNNInner(nullptr, &addr, OnJoinLNNResultCb) == SOFTBUS_OK);
464     EXPECT_TRUE(LnnOnJoinResult(reinterpret_cast<void *>(&addr), NODE1_NETWORK_ID, retCode) == SOFTBUS_OK);
465     EXPECT_TRUE(JoinLNNInner(nullptr, &addr, nullptr) == SOFTBUS_OK);
466     EXPECT_TRUE(LnnOnJoinResult(reinterpret_cast<void *>(&addr), NODE1_NETWORK_ID, retCode) == SOFTBUS_OK);
467     BusCenterClientDeinit();
468 }
469 
OnLeaveResultCb(const char * networkId,int32_t retCode)470 static void OnLeaveResultCb(const char *networkId, int32_t retCode)
471 {
472     (void)networkId;
473     (void)retCode;
474     printf("on call leave result cb\n");
475 }
476 
477 /*
478 * @tc.name: LNN_ON_LEAVE_RESULT_Test_001
479 * @tc.desc: lnn on leave result test
480 * @tc.type: FUNC
481 * @tc.require:
482 */
483 HWTEST_F(ClientBusCentManagerTest, LNN_ON_LEAVE_RESULT_Test_001, TestSize.Level1)
484 {
485     int32_t retCode = 0;
486     ClientBusCenterManagerInterfaceMock busCentManagerMock;
487     EXPECT_CALL(busCentManagerMock, SoftbusGetConfig(_, _, _)).WillRepeatedly(Return(SOFTBUS_OK));
488     EXPECT_TRUE(LnnOnLeaveResult(nullptr, retCode) == SOFTBUS_INVALID_PARAM);
489     EXPECT_CALL(busCentManagerMock, BusCenterServerProxyInit()).WillRepeatedly(Return(SOFTBUS_OK));
490     EXPECT_CALL(busCentManagerMock, BusCenterServerProxyDeInit()).WillRepeatedly(Return());
491     EXPECT_TRUE(BusCenterClientInit() == SOFTBUS_OK);
492     EXPECT_TRUE(LnnOnLeaveResult(NODE1_NETWORK_ID, retCode) == SOFTBUS_OK);
493     EXPECT_CALL(busCentManagerMock, ServerIpcLeaveLNN(_, _)).WillRepeatedly(Return(SOFTBUS_OK));
494     EXPECT_TRUE(LeaveLNNInner(nullptr, NODE1_NETWORK_ID, OnLeaveResultCb) == SOFTBUS_OK);
495     EXPECT_TRUE(LnnOnLeaveResult(NODE1_NETWORK_ID, retCode) == SOFTBUS_OK);
496     EXPECT_TRUE(LeaveLNNInner(nullptr, NODE1_NETWORK_ID, nullptr) == SOFTBUS_OK);
497     EXPECT_TRUE(LnnOnLeaveResult(NODE1_NETWORK_ID, retCode) == SOFTBUS_OK);
498     BusCenterClientDeinit();
499 }
500 
OnNodeOnlineCb(NodeBasicInfo * info)501 static void OnNodeOnlineCb(NodeBasicInfo *info)
502 {
503     (void)info;
504     printf("on call node online cb\n");
505 }
506 
OnNodeOfflineCb(NodeBasicInfo * info)507 static void OnNodeOfflineCb(NodeBasicInfo *info)
508 {
509     (void)info;
510     printf("on call node offline cb\n");
511 }
512 
OnNodeBasicInfoChangedCb(NodeBasicInfoType type,NodeBasicInfo * info)513 static void OnNodeBasicInfoChangedCb(NodeBasicInfoType type, NodeBasicInfo *info)
514 {
515     (void)type;
516     (void)info;
517     printf("on call node basic info changed cb\n");
518 }
519 
OnNodeStatusChangedCb(NodeStatusType type,NodeStatus * status)520 static void OnNodeStatusChangedCb(NodeStatusType type, NodeStatus *status)
521 {
522     (void)type;
523     (void)status;
524     printf("on call node status changed cb\n");
525 }
526 
527 /*
528 * @tc.name: LNN_ON_NODE_ONLINE_STATE_CHANGED_Test_001
529 * @tc.desc: lnn on node online state changed test
530 * @tc.type: FUNC
531 * @tc.require:
532 */
533 HWTEST_F(ClientBusCentManagerTest, LNN_ON_NODE_ONLINE_STATE_CHANGED_Test_001, TestSize.Level1)
534 {
535     INodeStateCb callBcak;
536     (void)memset_s(&callBcak, sizeof(INodeStateCb), 0, sizeof(INodeStateCb));
537     callBcak.events = EVENT;
538     callBcak.onNodeOnline = OnNodeOnlineCb;
539     callBcak.onNodeOffline = OnNodeOfflineCb;
540     callBcak.onNodeBasicInfoChanged = OnNodeBasicInfoChangedCb;
541     callBcak.onNodeStatusChanged = OnNodeStatusChangedCb;
542     NodeBasicInfo info;
543     ClientBusCenterManagerInterfaceMock busCentManagerMock;
544     EXPECT_CALL(busCentManagerMock, SoftbusGetConfig(_, _, _)).WillRepeatedly(Return(SOFTBUS_OK));
545     EXPECT_TRUE(LnnOnNodeOnlineStateChanged("", false, nullptr) == SOFTBUS_INVALID_PARAM);
546     EXPECT_CALL(busCentManagerMock, BusCenterServerProxyInit()).WillRepeatedly(Return(SOFTBUS_OK));
547     EXPECT_CALL(busCentManagerMock, BusCenterServerProxyDeInit()).WillRepeatedly(Return());
548     EXPECT_TRUE(BusCenterClientInit() == SOFTBUS_OK);
549     EXPECT_TRUE(RegNodeDeviceStateCbInner(nullptr, &callBcak) == SOFTBUS_INVALID_PARAM);
550     EXPECT_TRUE(RegNodeDeviceStateCbInner(PKGNAME, &callBcak) == SOFTBUS_OK);
551     EXPECT_TRUE(LnnOnNodeOnlineStateChanged("", true, reinterpret_cast<void *>(&info)) == SOFTBUS_OK);
552     EXPECT_TRUE(LnnOnNodeOnlineStateChanged("", false, reinterpret_cast<void *>(&info)) == SOFTBUS_OK);
553     BusCenterClientDeinit();
554 }
555 
556 /*
557 * @tc.name: LNN_ON_NODE_BASICINFO_CHANGED_Test_001
558 * @tc.desc: lnn on node basic info changed test
559 * @tc.type: FUNC
560 * @tc.require:
561 */
562 HWTEST_F(ClientBusCentManagerTest, LNN_ON_NODE_BASICINFO_CHANGED_Test_001, TestSize.Level1)
563 {
564     INodeStateCb callBcak;
565     (void)memset_s(&callBcak, sizeof(INodeStateCb), 0, sizeof(INodeStateCb));
566     callBcak.events = EVENT;
567     callBcak.onNodeOnline = OnNodeOnlineCb;
568     callBcak.onNodeOffline = OnNodeOfflineCb;
569     callBcak.onNodeBasicInfoChanged = OnNodeBasicInfoChangedCb;
570     callBcak.onNodeStatusChanged = OnNodeStatusChangedCb;
571     NodeBasicInfo info;
572     ClientBusCenterManagerInterfaceMock busCentManagerMock;
573     EXPECT_CALL(busCentManagerMock, SoftbusGetConfig(_, _, _)).WillRepeatedly(Return(SOFTBUS_OK));
574     EXPECT_TRUE(LnnOnNodeBasicInfoChanged("", nullptr, INVALID_TYPE) == SOFTBUS_INVALID_PARAM);
575     EXPECT_TRUE(LnnOnNodeBasicInfoChanged("", reinterpret_cast<void *>(&info), INVALID_TYPE) == SOFTBUS_INVALID_PARAM);
576     EXPECT_CALL(busCentManagerMock, BusCenterServerProxyInit()).WillRepeatedly(Return(SOFTBUS_OK));
577     EXPECT_CALL(busCentManagerMock, BusCenterServerProxyDeInit()).WillRepeatedly(Return());
578     EXPECT_TRUE(BusCenterClientInit() == SOFTBUS_OK);
579     EXPECT_TRUE(RegNodeDeviceStateCbInner(nullptr, &callBcak) == SOFTBUS_INVALID_PARAM);
580     EXPECT_TRUE(RegNodeDeviceStateCbInner(PKGNAME, &callBcak) == SOFTBUS_OK);
581     EXPECT_TRUE(LnnOnNodeBasicInfoChanged("", reinterpret_cast<void *>(&info), INVALID_TYPE) == SOFTBUS_INVALID_PARAM);
582     EXPECT_TRUE(LnnOnNodeBasicInfoChanged("", reinterpret_cast<void *>(&info), TYPE) == SOFTBUS_OK);
583     BusCenterClientDeinit();
584 }
585 
586 /*
587 * @tc.name: LNN_ON_NODE_STATUS_CHANGED_Test_001
588 * @tc.desc: lnn on node status changed test
589 * @tc.type: FUNC
590 * @tc.require:
591 */
592 HWTEST_F(ClientBusCentManagerTest, LNN_ON_NODE_STATUS_CHANGED_Test_001, TestSize.Level1)
593 {
594     INodeStateCb callBcak;
595     (void)memset_s(&callBcak, sizeof(INodeStateCb), 0, sizeof(INodeStateCb));
596     callBcak.events = EVENT_NODE_STATUS_CHANGED;
597     callBcak.onNodeStatusChanged = OnNodeStatusChangedCb;
598     NodeStatus info;
599     ClientBusCenterManagerInterfaceMock busCentManagerMock;
600     EXPECT_CALL(busCentManagerMock, SoftbusGetConfig(_, _, _)).WillRepeatedly(Return(SOFTBUS_OK));
601     EXPECT_TRUE(LnnOnNodeStatusChanged(nullptr, reinterpret_cast<void *>(&info), TYPE_SCREEN_STATUS) ==
602         SOFTBUS_INVALID_PARAM);
603     EXPECT_TRUE(LnnOnNodeStatusChanged("", nullptr, TYPE_STATUS_MAX + 1) == SOFTBUS_INVALID_PARAM);
604     EXPECT_CALL(busCentManagerMock, BusCenterServerProxyInit()).WillRepeatedly(Return(SOFTBUS_OK));
605     EXPECT_CALL(busCentManagerMock, BusCenterServerProxyDeInit()).WillRepeatedly(Return());
606     EXPECT_TRUE(BusCenterClientInit() == SOFTBUS_OK);
607     EXPECT_TRUE(RegNodeDeviceStateCbInner(nullptr, &callBcak) == SOFTBUS_INVALID_PARAM);
608     EXPECT_TRUE(RegNodeDeviceStateCbInner(PKGNAME, &callBcak) == SOFTBUS_OK);
609     EXPECT_TRUE(LnnOnNodeStatusChanged("", reinterpret_cast<void *>(&info), TYPE_STATUS_MAX + 1) ==
610         SOFTBUS_INVALID_PARAM);
611     EXPECT_TRUE(LnnOnNodeStatusChanged("", reinterpret_cast<void *>(&info), TYPE_SCREEN_STATUS) == SOFTBUS_OK);
612     BusCenterClientDeinit();
613 }
614 
OnTimeSyncResultCb(const TimeSyncResultInfo * info,int32_t retCode)615 static void OnTimeSyncResultCb(const TimeSyncResultInfo *info, int32_t retCode)
616 {
617     (void)info;
618     (void)retCode;
619     printf("on call time sync result cb\n");
620 }
621 
622 /*
623 * @tc.name: LNN_ON_TIME_SYNC_RESULT_Test_001
624 * @tc.desc: lnn on time sync result test
625 * @tc.type: FUNC
626 * @tc.require:
627 */
628 HWTEST_F(ClientBusCentManagerTest, LNN_ON_TIME_SYNC_RESULT_Test_001, TestSize.Level1)
629 {
630     int32_t retCode = 0;
631     ITimeSyncCb cb;
632     cb.onTimeSyncResult = OnTimeSyncResultCb;
633     TimeSyncResultInfo info;
634     (void)memset_s(&info, sizeof(TimeSyncResultInfo), 0, sizeof(TimeSyncResultInfo));
635     (void)strcpy_s(info.target.targetNetworkId, NETWORK_ID_BUF_LEN, NODE1_NETWORK_ID);
636     ClientBusCenterManagerInterfaceMock busCentManagerMock;
637     EXPECT_CALL(busCentManagerMock, SoftbusGetConfig(_, _, _)).WillRepeatedly(Return(SOFTBUS_OK));
638     EXPECT_TRUE(LnnOnTimeSyncResult(nullptr, retCode) == SOFTBUS_INVALID_PARAM);
639     EXPECT_CALL(busCentManagerMock, BusCenterServerProxyInit()).WillRepeatedly(Return(SOFTBUS_OK));
640     EXPECT_CALL(busCentManagerMock, BusCenterServerProxyDeInit()).WillRepeatedly(Return());
641     EXPECT_TRUE(BusCenterClientInit() == SOFTBUS_OK);
642     EXPECT_CALL(busCentManagerMock, ServerIpcStartTimeSync(_, _, _, _)).WillRepeatedly(Return(SOFTBUS_OK));
643     EXPECT_TRUE(StartTimeSyncInner(nullptr, NODE1_NETWORK_ID, LOW_ACCURACY, SHORT_PERIOD, &cb) == SOFTBUS_OK);
644     EXPECT_TRUE(LnnOnTimeSyncResult(reinterpret_cast<const void *>(&info), retCode) == SOFTBUS_OK);
645     BusCenterClientDeinit();
646 }
647 } // namespace OHOS
648