1 /*
2 * Copyright (c) 2022-2023 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_event.h"
20 #include "bus_center_manager.h"
21 #include "lnn_local_net_ledger.h"
22 #include "lnn_net_builder.h"
23 #include "message_handler.h"
24 #include "softbus_common.h"
25 #include "softbus_errcode.h"
26 #include "lnn_net_builder_process.h"
27
28 constexpr char NETWORKID[] = "ABCDEFG";
29 constexpr char OLD_NETWORKID[] = "ABCDEFG";
30 constexpr char MASTER_UDID[] = "0123456";
31 constexpr uint16_t CONN_FSM_ID = 1;
32 constexpr int32_t MASTER_WEIGHT = 1;
33 constexpr uint32_t TYPE_LEN = 1;
34 constexpr uint32_t TYPE_LENTH = 5;
35 constexpr char IP[IP_STR_MAX_LEN] = "127.0.0.1";
36 constexpr uint16_t PORT = 1000;
37 constexpr char PEERUID[MAX_ACCOUNT_HASH_LEN] = "021315ASD";
38 constexpr uint8_t MSG[] = "123456BNHFCF";
39 constexpr int64_t AUTH_ID = 10;
40 constexpr uint32_t REQUEST_ID = 10;
41
42 #define SOFTBUS_SUB_SYSTEM 203
43 #define SOFTBUS_AUTH_MODULE 3
44 #define HICHAIN_ERROR_KEY_NOEXIST (-((SOFTBUS_SUB_SYSTEM << 21) | (SOFTBUS_AUTH_MODULE << 16) | 0x0101))
45
46 namespace OHOS {
47 using namespace testing::ext;
48
49 class LNNNetBuilderTest : public testing::Test {
50 public:
51 static void SetUpTestCase();
52 static void TearDownTestCase();
53 void SetUp();
54 void TearDown();
55 };
56
SetUpTestCase()57 void LNNNetBuilderTest::SetUpTestCase()
58 {
59 LooperInit();
60 }
61
TearDownTestCase()62 void LNNNetBuilderTest::TearDownTestCase()
63 {
64 LooperDeinit();
65 }
66
SetUp()67 void LNNNetBuilderTest::SetUp()
68 {
69 LnnInitBusCenterEvent();
70 }
71
TearDown()72 void LNNNetBuilderTest::TearDown()
73 {
74 LnnDeinitNetBuilder();
75 LnnDeinitBusCenterEvent();
76 }
77
78 /*
79 * @tc.name: LNN_NOTIFY_DISCOVERY_DEVICE_TEST_001
80 * @tc.desc: test LnnNotifyDiscoveryDevice
81 * @tc.type: FUNC
82 * @tc.require: I5PRUD
83 */
84 HWTEST_F(LNNNetBuilderTest, LNN_NOTIFY_DISCOVERY_DEVICE_TEST_001, TestSize.Level0)
85 {
86 ConnectionAddr target = {
87 .type = CONNECTION_ADDR_WLAN,
88 .info.ip.port = PORT
89 };
90 LnnDfxDeviceInfoReport infoReport;
91 (void)memset_s(&infoReport, sizeof(LnnDfxDeviceInfoReport), 0, sizeof(LnnDfxDeviceInfoReport));
92 memcpy_s(target.peerUid, MAX_ACCOUNT_HASH_LEN, PEERUID, strlen(PEERUID));
93 memcpy_s(target.info.ip.ip, IP_STR_MAX_LEN, IP, strlen(IP));
94 int32_t ret = LnnNotifyDiscoveryDevice(&target, &infoReport, false);
95 EXPECT_TRUE(ret != SOFTBUS_OK);
96 ret = LnnInitNetBuilder();
97 EXPECT_TRUE(ret == SOFTBUS_OK);
98 ret = LnnNotifyDiscoveryDevice(nullptr, &infoReport, false);
99 EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
100 }
101
102 /*
103 * @tc.name: LNN_REQUEST_LEAVE_BY_ADDRTYPE_TEST_001
104 * @tc.desc: test LnnRequestLeaveByAddrType
105 * @tc.type: FUNC
106 * @tc.require: I5PRUD
107 */
108 HWTEST_F(LNNNetBuilderTest, LNN_REQUEST_LEAVE_BY_ADDRTYPE_TEST_001, TestSize.Level0)
109 {
110 const bool type[CONNECTION_ADDR_MAX] = {true, true, true, true, true};
111 int32_t ret = LnnRequestLeaveByAddrType(type, CONNECTION_ADDR_MAX);
112 EXPECT_TRUE(ret != SOFTBUS_OK);
113 ret = LnnInitNetBuilder();
114 EXPECT_TRUE(ret == SOFTBUS_OK);
115 ret = LnnRequestLeaveByAddrType(nullptr, TYPE_LENTH);
116 EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
117 ret = LnnRequestLeaveByAddrType(type, TYPE_LEN);
118 EXPECT_TRUE(ret != SOFTBUS_OK);
119 ret = LnnRequestLeaveByAddrType(type, TYPE_LENTH);
120 EXPECT_TRUE(ret == SOFTBUS_OK);
121 }
122
123 /*
124 * @tc.name: LNN_REQUEST_LEAVE_SPECIFIC_TEST_001
125 * @tc.desc: test LnnRequestLeaveSpecific
126 * @tc.type: FUNC
127 * @tc.require: I5PRUD
128 */
129 HWTEST_F(LNNNetBuilderTest, LNN_REQUEST_LEAVE_SPECIFIC_TEST_001, TestSize.Level0)
130 {
131 char *networkId = nullptr;
132 int32_t ret = LnnRequestLeaveSpecific(networkId, CONNECTION_ADDR_WLAN);
133 EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
134 ret = LnnRequestLeaveSpecific(NETWORKID, CONNECTION_ADDR_WLAN);
135 EXPECT_TRUE(ret == SOFTBUS_NO_INIT);
136 ret = LnnInitNetBuilder();
137 EXPECT_TRUE(ret == SOFTBUS_OK);
138 ret = LnnRequestLeaveSpecific(NETWORKID, CONNECTION_ADDR_WLAN);
139 EXPECT_TRUE(ret == SOFTBUS_OK);
140 }
141
142 /*
143 * @tc.name: LNN_REQUEST_LEAVE_INVALID_CONN_TEST_001
144 * @tc.desc: test LnnRequestLeaveInvalidConn
145 * @tc.type: FUNC
146 * @tc.require: I5PRUD
147 */
148 HWTEST_F(LNNNetBuilderTest, LNN_REQUEST_LEAVE_INVALID_CONN_TEST_001, TestSize.Level0)
149 {
150 int32_t ret = LnnRequestLeaveInvalidConn(OLD_NETWORKID, CONNECTION_ADDR_WLAN, NETWORKID);
151 EXPECT_TRUE(ret != SOFTBUS_OK);
152 ret = LnnInitNetBuilder();
153 EXPECT_TRUE(ret == SOFTBUS_OK);
154 ret = LnnRequestLeaveInvalidConn(OLD_NETWORKID, CONNECTION_ADDR_WLAN, NETWORKID);
155 EXPECT_TRUE(ret == SOFTBUS_OK);
156 }
157
158 /*
159 * @tc.name: LNN_REQUEST_CLEAN_CONN_FSM_TEST_001
160 * @tc.desc: test LnnRequestCleanConnFsm
161 * @tc.type: FUNC
162 * @tc.require: I5PRUD
163 */
164 HWTEST_F(LNNNetBuilderTest, LNN_REQUEST_CLEAN_CONN_FSM_TEST_001, TestSize.Level0)
165 {
166 int32_t ret = LnnRequestCleanConnFsm(CONN_FSM_ID);
167 EXPECT_TRUE(ret != SOFTBUS_OK);
168 ret = LnnInitNetBuilder();
169 EXPECT_TRUE(ret == SOFTBUS_OK);
170 ret = LnnRequestCleanConnFsm(CONN_FSM_ID);
171 EXPECT_TRUE(ret == SOFTBUS_OK);
172 }
173
174 /*
175 * @tc.name: LNN_NOTIFY_NODE_STATE_CHANGED_TEST_001
176 * @tc.desc: test LnnNotifyNodeStateChanged
177 * @tc.type: FUNC
178 * @tc.require: I5PRUD
179 */
180 HWTEST_F(LNNNetBuilderTest, LNN_NOTIFY_NODE_STATE_CHANGED_TEST_001, TestSize.Level0)
181 {
182 ConnectionAddr target = {
183 .type = CONNECTION_ADDR_WLAN,
184 .info.ip.port = PORT
185 };
186 memcpy_s(target.peerUid, MAX_ACCOUNT_HASH_LEN, PEERUID, strlen(PEERUID));
187 memcpy_s(target.info.ip.ip, IP_STR_MAX_LEN, IP, strlen(IP));
188 int32_t ret = LnnNotifyNodeStateChanged(&target);
189 EXPECT_TRUE(ret != SOFTBUS_OK);
190 ret = LnnInitNetBuilder();
191 EXPECT_TRUE(ret == SOFTBUS_OK);
192 ret = LnnNotifyNodeStateChanged(&target);
193 EXPECT_TRUE(ret == SOFTBUS_OK);
194 }
195
196 /*
197 * @tc.name: LNN_NOTIFY_MASTER_ELECT_TEST_001
198 * @tc.desc: test LnnNotifyMasterElect
199 * @tc.type: FUNC
200 * @tc.require: I5PRUD
201 */
202 HWTEST_F(LNNNetBuilderTest, LNN_NOTIFY_MASTER_ELECT_TEST_001, TestSize.Level0)
203 {
204 int32_t ret = LnnNotifyMasterElect(NETWORKID, MASTER_UDID, MASTER_WEIGHT);
205 EXPECT_TRUE(ret != SOFTBUS_OK);
206 ret = LnnInitNetBuilder();
207 EXPECT_TRUE(ret == SOFTBUS_OK);
208 char *networkId = nullptr;
209 ret = LnnNotifyMasterElect(networkId, MASTER_UDID, MASTER_WEIGHT);
210 EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
211 ret = LnnNotifyMasterElect(NETWORKID, MASTER_UDID, MASTER_WEIGHT);
212 EXPECT_TRUE(ret == SOFTBUS_OK);
213 }
214
215 /*
216 * @tc.name: LNN_UPDATE_NODE_ADDR_TEST_001
217 * @tc.desc: test LnnUpdateNodeAddr
218 * @tc.type: FUNC
219 * @tc.require: I5PRUD
220 */
221 HWTEST_F(LNNNetBuilderTest, LNN_UPDATE_NODE_ADDR_TEST_001, TestSize.Level0)
222 {
223 char *addr = nullptr;
224 int32_t ret = LnnUpdateNodeAddr(addr);
225 EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
226 ret = LnnInitNetBuilder();
227 EXPECT_TRUE(ret == SOFTBUS_OK);
228 ret = LnnUpdateNodeAddr(MASTER_UDID);
229 EXPECT_TRUE(ret == SOFTBUS_LOCK_ERR);
230 ret = LnnInitLocalLedger();
231 EXPECT_TRUE(ret == SOFTBUS_OK);
232 ret = LnnUpdateNodeAddr(MASTER_UDID);
233 EXPECT_TRUE(ret == SOFTBUS_OK);
234 }
235
236 /*
237 * @tc.name: LNN_SYNC_OFFLINE_COMPLETE_TEST_001
238 * @tc.desc: test LnnSyncOfflineComplete
239 * @tc.type: FUNC
240 * @tc.require:
241 */
242 HWTEST_F(LNNNetBuilderTest, LNN_SYNC_OFFLINE_COMPLETE_TEST_001, TestSize.Level0)
243 {
244 uint32_t len = TYPE_LEN;
245 LnnSyncOfflineComplete(LNN_INFO_TYPE_CAPABILITY, NETWORKID, MSG, len);
246 int32_t ret = LnnInitNetBuilder();
247 EXPECT_TRUE(ret == SOFTBUS_OK);
248 LnnSyncOfflineComplete(LNN_INFO_TYPE_CAPABILITY, nullptr, MSG, len);
249 LnnSyncOfflineComplete(LNN_INFO_TYPE_CAPABILITY, NETWORKID, MSG, len);
250 }
251
252 /*
253 * @tc.name: LNN_SERVER_LEAVE_TEST_001
254 * @tc.desc: test LnnServerLeave
255 * @tc.type: FUNC
256 * @tc.require:
257 */
258 HWTEST_F(LNNNetBuilderTest, LNN_SERVER_LEAVE_TEST_001, TestSize.Level0)
259 {
260 int32_t ret = LnnServerLeave(NETWORKID, "pkaName");
261 EXPECT_TRUE(ret == SOFTBUS_NO_INIT);
262 ret = LnnInitNetBuilder();
263 EXPECT_TRUE(ret == SOFTBUS_OK);
264 ret = LnnServerLeave(NETWORKID, "pkaName");
265 EXPECT_TRUE(ret == SOFTBUS_OK);
266 ret = LnnServerLeave(nullptr, "pkaName");
267 EXPECT_TRUE(ret == SOFTBUS_MALLOC_ERR);
268 }
269
270 /*
271 * @tc.name: LNN_SERVER_JOIN_TEST_001
272 * @tc.desc: test LnnServerJoin
273 * @tc.type: FUNC
274 * @tc.require:
275 */
276 HWTEST_F(LNNNetBuilderTest, LNN_SERVER_JOIN_TEST_001, TestSize.Level0)
277 {
278 ConnectionAddr addr = {
279 .type = CONNECTION_ADDR_WLAN,
280 .info.ip.port = PORT
281 };
282 (void)strcpy_s(addr.info.ip.ip, IP_STR_MAX_LEN, IP);
283 int32_t ret = LnnServerJoin(&addr, "pkgName");
284 EXPECT_TRUE(ret == SOFTBUS_NO_INIT);
285 ret = LnnInitNetBuilder();
286 EXPECT_TRUE(ret == SOFTBUS_OK);
287 ret = LnnServerJoin(&addr, "pkgName");
288 EXPECT_TRUE(ret == SOFTBUS_OK);
289 ret = LnnServerJoin(nullptr, "pkgName");
290 EXPECT_TRUE(ret == SOFTBUS_MALLOC_ERR);
291 ret = LnnServerJoin(&addr, nullptr);
292 EXPECT_TRUE(ret == SOFTBUS_MALLOC_ERR);
293 }
294
295 /*
296 * @tc.name: FIND_REQUEST_ID_BY_ADDR_TEST_001
297 * @tc.desc: test FindRequestIdByAddr
298 * @tc.type: FUNC
299 * @tc.require:
300 */
301 HWTEST_F(LNNNetBuilderTest, FIND_REQUEST_ID_BY_ADDR_TEST_001, TestSize.Level0)
302 {
303 ConnectionAddr addr = {
304 .type = CONNECTION_ADDR_WLAN,
305 .info.ip.port = PORT
306 };
307 (void)strcpy_s(addr.info.ip.ip, IP_STR_MAX_LEN, IP);
308 uint32_t requestId;
309 uint32_t ret = LnnInitNetBuilder();
310 EXPECT_TRUE(ret == SOFTBUS_OK);
311 ret = FindRequestIdByAddr(nullptr, &requestId);
312 EXPECT_TRUE(ret != SOFTBUS_OK);
313 }
314
315 /*
316 * @tc.name: FIND_NODE_INFO_BY_RQUESTID_TEST_001
317 * @tc.desc: test FindNodeInfoByRquestId
318 * @tc.type: FUNC
319 * @tc.require:
320 */
321 HWTEST_F(LNNNetBuilderTest, FIND_NODE_INFO_BY_RQUESTID_TEST_001, TestSize.Level0)
322 {
323 ConnectionAddr addr = {
324 .type = CONNECTION_ADDR_WLAN,
325 .info.ip.port = PORT
326 };
327 (void)strcpy_s(addr.info.ip.ip, IP_STR_MAX_LEN, IP);
328 int32_t ret = LnnInitNetBuilder();
329 EXPECT_TRUE(ret == SOFTBUS_OK);
330 NodeInfo *info = FindNodeInfoByRquestId(REQUEST_ID);
331 EXPECT_TRUE(info == nullptr);
332 }
333
334 /*
335 * @tc.name: LNN_GET_VERIFY_CALLBACK_TEST_001
336 * @tc.desc: test three verify callback
337 * @tc.type: FUNC
338 * @tc.require:
339 */
340 HWTEST_F(LNNNetBuilderTest, LNN_GET_VERIFY_CALLBACK_TEST_001, TestSize.Level0)
341 {
342 ConnectionAddr addr = {
343 .type = CONNECTION_ADDR_WLAN,
344 .info.ip.port = PORT
345 };
346 (void)strcpy_s(addr.info.ip.ip, IP_STR_MAX_LEN, IP);
347 NodeInfo *info = nullptr;
348 NodeInfo info1;
349 int32_t ret = LnnInitNetBuilder();
350 EXPECT_TRUE(ret == SOFTBUS_OK);
351 AuthVerifyCallback *authVerifyCallback = LnnGetVerifyCallback();
352 AuthHandle authHandle = { .authId = AUTH_ID, .type = AUTH_LINK_TYPE_WIFI };
353 authVerifyCallback->onVerifyPassed(REQUEST_ID, authHandle, info);
354 authVerifyCallback->onVerifyPassed(REQUEST_ID, authHandle, &info1);
355 authVerifyCallback = LnnGetReAuthVerifyCallback();
356 authVerifyCallback->onVerifyPassed(REQUEST_ID, authHandle, info);
357 authVerifyCallback->onVerifyPassed(REQUEST_ID, authHandle, &info1);
358 authVerifyCallback->onVerifyFailed(REQUEST_ID, SOFTBUS_OK);
359 authVerifyCallback->onVerifyFailed(REQUEST_ID, HICHAIN_ERROR_KEY_NOEXIST);
360 }
361
362 /*
363 * @tc.name: LNN_NOTIFY_AUTH_HANDLE_LEAVELNN_TEST_001
364 * @tc.desc: lnn notify auth handle leave lnn test
365 * @tc.type: FUNC
366 * @tc.require:
367 */
368 HWTEST_F(LNNNetBuilderTest, LNN_NOTIFY_AUTH_HANDLE_LEAVELNN_TEST_001, TestSize.Level0)
369 {
370 AuthHandle authHandle = { .authId = AUTH_ID, .type = AUTH_LINK_TYPE_WIFI };
371 int32_t ret = LnnNotifyAuthHandleLeaveLNN(authHandle);
372 EXPECT_TRUE(ret != SOFTBUS_OK);
373 ret = LnnInitNetBuilder();
374 EXPECT_TRUE(ret == SOFTBUS_OK);
375 ret = LnnNotifyAuthHandleLeaveLNN(authHandle);
376 EXPECT_TRUE(ret == SOFTBUS_OK);
377 }
378 } // namespace OHOS
379