1 /*
2 * Copyright (c) 2022-2024 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include <gtest/gtest.h>
17 #include <securec.h>
18
19 #include "lnn_auth_mock.h"
20 #include "lnn_connection_fsm.c"
21 #include "lnn_connection_fsm.h"
22 #include "lnn_connection_fsm_process.c"
23 #include "lnn_connection_fsm_process.h"
24 #include "lnn_devicename_info.h"
25 #include "lnn_net_builder.h"
26 #include "lnn_net_ledger_mock.h"
27 #include "lnn_service_mock.h"
28 #include "message_handler.h"
29 #include "softbus_adapter_mem.h"
30 #include "softbus_common.h"
31 #include "softbus_error_code.h"
32
33 constexpr char DEVICE_IP1[MAX_ADDR_LEN] = "127.0.0.1";
34 constexpr char DEVICE_IP2[MAX_ADDR_LEN] = "127.0.0.2";
35 constexpr uint16_t PORT1 = 1000;
36 constexpr uint16_t PORT2 = 1001;
37 constexpr int64_t AUTH_ID = 10;
38 constexpr char NODE_UDID[UUID_BUF_LEN] = "123456ABCDEF";
39 constexpr char NETWORKID1[NETWORK_ID_BUF_LEN] = "123456ABD";
40 constexpr uint32_t REQUEST_ID = 1;
41 constexpr uint32_t CONN_FLAG = 0;
42
43 namespace OHOS {
44 using namespace testing;
45 using namespace testing::ext;
46
47 class LNNConnectionFsmMockTest : public testing::Test {
48 public:
49 static void SetUpTestCase();
50 static void TearDownTestCase();
51 void SetUp();
52 void TearDown();
53 };
54
SetUpTestCase()55 void LNNConnectionFsmMockTest::SetUpTestCase()
56 {
57 LooperInit();
58 }
59
TearDownTestCase()60 void LNNConnectionFsmMockTest::TearDownTestCase()
61 {
62 LooperDeinit();
63 }
64
SetUp()65 void LNNConnectionFsmMockTest::SetUp() { }
66
TearDown()67 void LNNConnectionFsmMockTest::TearDown() { }
68
LnnConnectionFsmStopCallback(struct tagLnnConnectionFsm * connFsm)69 static void LnnConnectionFsmStopCallback(struct tagLnnConnectionFsm *connFsm)
70 {
71 (void)connFsm;
72 return;
73 }
74
75 /*
76 * @tc.name: LNN_IS_NODE_INFO_CHANGED_TEST_001
77 * @tc.desc: is node info changed test
78 * @tc.type: FUNC
79 * @tc.require:
80 */
81 HWTEST_F(LNNConnectionFsmMockTest, LNN_IS_NODE_INFO_CHANGED_TEST_001, TestSize.Level1)
82 {
83 LnnConnectionFsm *connFsm = nullptr;
84 ConnectionAddr target = {
85 .type = CONNECTION_ADDR_WLAN,
86 .info.ip.port = PORT1,
87 };
88 (void)strcpy_s(target.info.ip.ip, IP_STR_MAX_LEN, DEVICE_IP1);
89 connFsm = LnnCreateConnectionFsm(&target, "pkgName", true);
90 EXPECT_TRUE(connFsm != nullptr);
91 int32_t ret = LnnStartConnectionFsm(connFsm);
92 EXPECT_TRUE(ret == SOFTBUS_OK);
93 NodeInfo oldNodeInfo;
94 NodeInfo newNodeInfo;
95 ConnectionAddrType type;
96 (void)strcpy_s(oldNodeInfo.networkId, NETWORK_ID_BUF_LEN, NETWORKID1);
97 (void)strcpy_s(newNodeInfo.networkId, NETWORK_ID_BUF_LEN, NETWORKID1);
98 (void)strcpy_s(oldNodeInfo.connectInfo.ifInfo[WLAN_IF].deviceIp, MAX_ADDR_LEN, DEVICE_IP1);
99 (void)strcpy_s(newNodeInfo.connectInfo.ifInfo[WLAN_IF].deviceIp, MAX_ADDR_LEN, DEVICE_IP1);
100 oldNodeInfo.connectInfo.ifInfo[WLAN_IF].authPort = PORT1;
101 newNodeInfo.connectInfo.ifInfo[WLAN_IF].authPort = PORT1;
102 oldNodeInfo.connectInfo.ifInfo[WLAN_IF].proxyPort = PORT1;
103 newNodeInfo.connectInfo.ifInfo[WLAN_IF].proxyPort = PORT1;
104 oldNodeInfo.connectInfo.ifInfo[WLAN_IF].sessionPort = PORT1;
105 newNodeInfo.connectInfo.ifInfo[WLAN_IF].sessionPort = PORT1;
106
107 NiceMock<LnnNetLedgertInterfaceMock> netLedgerMock;
108 EXPECT_CALL(netLedgerMock, LnnHasDiscoveryType).WillOnce(Return(false)).WillRepeatedly(Return(true));
109 bool ret1 = IsNodeInfoChanged(connFsm, &oldNodeInfo, &newNodeInfo, &type);
110 EXPECT_TRUE(ret1 == false);
111 ret1 = IsNodeInfoChanged(connFsm, &oldNodeInfo, &newNodeInfo, &type);
112 EXPECT_TRUE(ret1 == false);
113 ret1 = IsNodeInfoChanged(connFsm, &oldNodeInfo, &newNodeInfo, &type);
114 EXPECT_TRUE(ret1 == false);
115 ret1 = IsNodeInfoChanged(connFsm, &oldNodeInfo, &newNodeInfo, &type);
116 EXPECT_TRUE(ret1 == false);
117 ret1 = IsNodeInfoChanged(connFsm, &oldNodeInfo, &newNodeInfo, &type);
118 EXPECT_TRUE(ret1 == false);
119 newNodeInfo.connectInfo.ifInfo[WLAN_IF].sessionPort = PORT2;
120 ret1 = IsNodeInfoChanged(connFsm, &oldNodeInfo, &newNodeInfo, &type);
121 EXPECT_TRUE(ret1 == true);
122 newNodeInfo.connectInfo.ifInfo[WLAN_IF].proxyPort = PORT2;
123 ret1 = IsNodeInfoChanged(connFsm, &oldNodeInfo, &newNodeInfo, &type);
124 EXPECT_TRUE(ret1 == true);
125 newNodeInfo.connectInfo.ifInfo[WLAN_IF].authPort = PORT2;
126 ret1 = IsNodeInfoChanged(connFsm, &oldNodeInfo, &newNodeInfo, &type);
127 EXPECT_TRUE(ret1 == true);
128 (void)strcpy_s(newNodeInfo.connectInfo.ifInfo[WLAN_IF].deviceIp, MAX_ADDR_LEN, DEVICE_IP2);
129 ret1 = IsNodeInfoChanged(connFsm, &oldNodeInfo, &newNodeInfo, &type);
130 EXPECT_TRUE(ret1 == true);
131 LnnDestroyConnectionFsm(connFsm);
132 }
133
134 /*
135 * @tc.name: AUTH_STATE_PROCESS_TEST_001
136 * @tc.desc: auth state process test
137 * @tc.type: FUNC
138 * @tc.require:
139 */
140 HWTEST_F(LNNConnectionFsmMockTest, AUTH_STATE_PROCESS_TEST_001, TestSize.Level1)
141 {
142 NiceMock<LnnServicetInterfaceMock> serviceMock;
143 LnnConnectionFsm *connFsm = nullptr;
144 connFsm = reinterpret_cast<LnnConnectionFsm *>(SoftBusMalloc(sizeof(LnnConnectionFsm)));
145 EXPECT_TRUE(connFsm != nullptr);
146 void *para = nullptr;
147 para = reinterpret_cast<void *>(SoftBusMalloc(sizeof(int32_t)));
148 EXPECT_TRUE(para != nullptr);
149 void *para1 = nullptr;
150 para1 = reinterpret_cast<void *>(SoftBusMalloc(sizeof(int32_t)));
151 EXPECT_TRUE(para1 != nullptr);
152 connFsm->connInfo.authHandle.authId = AUTH_ID;
153 connFsm->isSession = false;
154 EXPECT_CALL(serviceMock, LnnNotifyJoinResult).WillRepeatedly(Return());
155 bool ret = AuthStateProcess(nullptr, FSM_MSG_TYPE_JOIN_LNN, para);
156 EXPECT_TRUE(ret == false);
157 ret = AuthStateProcess(&connFsm->fsm, FSM_MSG_TYPE_JOIN_LNN, para);
158 EXPECT_TRUE(ret == true);
159 ret = AuthStateProcess(&connFsm->fsm, FSM_MSG_TYPE_AUTH_DONE, nullptr);
160 EXPECT_TRUE(ret == true);
161 connFsm->isDead = true;
162 ret = AuthStateProcess(&connFsm->fsm, FSM_MSG_TYPE_JOIN_LNN, nullptr);
163 EXPECT_TRUE(ret == true);
164 ret = AuthStateProcess(&connFsm->fsm, FSM_MSG_TYPE_AUTH_DONE, para1);
165 EXPECT_TRUE(ret == true);
166 ret = AuthStateProcess(&connFsm->fsm, FSM_MSG_TYPE_DISCONNECT, nullptr);
167 EXPECT_TRUE(ret == true);
168 ret = AuthStateProcess(&connFsm->fsm, FSM_MSG_TYPE_JOIN_LNN_TIMEOUT, nullptr);
169 EXPECT_TRUE(ret == true);
170 SoftBusFree(connFsm);
171 }
172
173 /*
174 * @tc.name: AUTH_STATE_PROCESS_TEST_002
175 * @tc.desc: auth state process on join lnn test
176 * @tc.type: FUNC
177 * @tc.require:
178 */
179 HWTEST_F(LNNConnectionFsmMockTest, AUTH_STATE_PROCESS_TEST_002, TestSize.Level1)
180 {
181 LnnConnectionFsm *connFsm = nullptr;
182 ConnectionAddr target = {
183 .type = CONNECTION_ADDR_BLE,
184 };
185 connFsm = LnnCreateConnectionFsm(&target, "pkgName", true);
186 EXPECT_TRUE(connFsm != nullptr);
187 int32_t ret = LnnStartConnectionFsm(connFsm);
188 EXPECT_TRUE(ret == SOFTBUS_OK);
189 connFsm->isDead = false;
190 connFsm->isNeedConnect = false;
191 int32_t *retCode = nullptr;
192 retCode = reinterpret_cast<int32_t *>(SoftBusMalloc(sizeof(int32_t)));
193 EXPECT_TRUE(retCode != nullptr);
194 *retCode = SOFTBUS_OK;
195
196 NiceMock<LnnNetLedgertInterfaceMock> netLedgerMock;
197 NiceMock<LnnServicetInterfaceMock> serviceMock;
198 NiceMock<LnnAuthtInterfaceMock> authtMock;
199 EXPECT_CALL(serviceMock, AuthGenRequestId).WillRepeatedly(Return(REQUEST_ID));
200 EXPECT_CALL(authtMock, AuthStartVerify).WillRepeatedly(Return(SOFTBUS_INVALID_PARAM));
201
202 bool ret1 = AuthStateProcess(&connFsm->fsm, FSM_MSG_TYPE_JOIN_LNN, reinterpret_cast<void *>(retCode));
203 EXPECT_TRUE(ret1 == true);
204 LnnDestroyConnectionFsm(connFsm);
205 }
206
207 /*
208 * @tc.name: AUTH_STATE_PROCESS_TEST_003
209 * @tc.desc: auth state process on auth done test
210 * @tc.type: FUNC
211 * @tc.require:
212 */
213 HWTEST_F(LNNConnectionFsmMockTest, AUTH_STATE_PROCESS_TEST_003, TestSize.Level1)
214 {
215 NiceMock<LnnNetLedgertInterfaceMock> netLedgerMock;
216 NiceMock<LnnServicetInterfaceMock> serviceMock;
217 NiceMock<LnnAuthtInterfaceMock> authtMock;
218 EXPECT_CALL(authtMock, AuthGetVersion).WillOnce(Return(SOFTBUS_INVALID_PARAM)).WillRepeatedly(Return(SOFTBUS_OK));
219 EXPECT_CALL(serviceMock, AuthGetDeviceUuid)
220 .WillOnce(Return(SOFTBUS_INVALID_PARAM))
221 .WillRepeatedly(Return(SOFTBUS_OK));
222
223 int32_t *retCode = nullptr;
224 retCode = reinterpret_cast<int32_t *>(SoftBusMalloc(sizeof(int32_t)));
225 EXPECT_TRUE(retCode != nullptr);
226 *retCode = SOFTBUS_OK;
227 int32_t *retCode1 = nullptr;
228 retCode1 = reinterpret_cast<int32_t *>(SoftBusMalloc(sizeof(int32_t)));
229 EXPECT_TRUE(retCode1 != nullptr);
230 *retCode1 = SOFTBUS_OK;
231 int32_t *retCode2 = nullptr;
232 retCode2 = reinterpret_cast<int32_t *>(SoftBusMalloc(sizeof(int32_t)));
233 EXPECT_TRUE(retCode2 != nullptr);
234 *retCode2 = SOFTBUS_OK;
235 int32_t *retCode3 = nullptr;
236 retCode3 = reinterpret_cast<int32_t *>(SoftBusMalloc(sizeof(int32_t)));
237 EXPECT_TRUE(retCode3 != nullptr);
238 *retCode3 = SOFTBUS_OK;
239 LnnConnectionFsm *connFsm = nullptr;
240 ConnectionAddr target = {
241 .type = CONNECTION_ADDR_WLAN,
242 .info.ip.port = PORT1,
243 };
244 (void)strcpy_s(target.info.ip.ip, IP_STR_MAX_LEN, DEVICE_IP1);
245 connFsm = LnnCreateConnectionFsm(&target, "pkgName", true);
246 EXPECT_TRUE(connFsm != nullptr);
247 int32_t ret = LnnStartConnectionFsm(connFsm);
248 EXPECT_TRUE(ret == SOFTBUS_OK);
249 connFsm->connInfo.nodeInfo = reinterpret_cast<NodeInfo *>(SoftBusMalloc(sizeof(NodeInfo)));
250 EXPECT_TRUE(connFsm->connInfo.nodeInfo != nullptr);
251 connFsm->isDead = false;
252 connFsm->fsm.flag = 0;
253 connFsm->fsm.looper = nullptr;
254
255 bool ret1 = AuthStateProcess(&connFsm->fsm, FSM_MSG_TYPE_AUTH_DONE, reinterpret_cast<void *>(retCode));
256 EXPECT_TRUE(ret1 == true);
257 ret1 = AuthStateProcess(&connFsm->fsm, FSM_MSG_TYPE_AUTH_DONE, reinterpret_cast<void *>(retCode1));
258 EXPECT_TRUE(ret1 == true);
259 ret1 = AuthStateProcess(&connFsm->fsm, FSM_MSG_TYPE_AUTH_DONE, reinterpret_cast<void *>(retCode2));
260 EXPECT_TRUE(ret1 == true);
261 (void)strcpy_s(connFsm->connInfo.nodeInfo->uuid, UUID_BUF_LEN, NODE_UDID);
262 ret1 = AuthStateProcess(&connFsm->fsm, FSM_MSG_TYPE_AUTH_DONE, reinterpret_cast<void *>(retCode3));
263 EXPECT_TRUE(ret1 == true);
264 LnnDestroyConnectionFsm(connFsm);
265 }
266
267 /*
268 * @tc.name: ONLINE_STATE_ENTER_TEST_001
269 * @tc.desc: online state enter test
270 * @tc.type: FUNC
271 * @tc.require:
272 */
273 HWTEST_F(LNNConnectionFsmMockTest, ONLINE_STATE_ENTER_TEST_001, TestSize.Level1)
274 {
275 LnnConnectionFsm *connFsm = nullptr;
276 ConnectionAddr target = {
277 .type = CONNECTION_ADDR_BLE,
278 };
279 connFsm = LnnCreateConnectionFsm(&target, "pkgName", true);
280 EXPECT_TRUE(connFsm != nullptr);
281 int32_t ret = LnnStartConnectionFsm(connFsm);
282 EXPECT_TRUE(ret == SOFTBUS_OK);
283 connFsm->connInfo.nodeInfo = reinterpret_cast<NodeInfo *>(SoftBusMalloc(sizeof(NodeInfo)));
284 EXPECT_TRUE(connFsm->connInfo.nodeInfo != nullptr);
285 NiceMock<LnnNetLedgertInterfaceMock> netLedgerMock;
286 NiceMock<LnnServicetInterfaceMock> serviceMock;
287 EXPECT_CALL(netLedgerMock, LnnAddOnlineNode).WillOnce(Return(REPORT_CHANGE)).WillRepeatedly(Return(REPORT_ONLINE));
288
289 OnlineStateEnter(nullptr);
290 OnlineStateEnter(&connFsm->fsm);
291 connFsm->connInfo.nodeInfo = reinterpret_cast<NodeInfo *>(SoftBusMalloc(sizeof(NodeInfo)));
292 EXPECT_TRUE(connFsm->connInfo.nodeInfo != nullptr);
293 OnlineStateEnter(&connFsm->fsm);
294 LnnDestroyConnectionFsm(connFsm);
295 }
296
297 /*
298 * @tc.name: CLEAN_INVALID_CONNSTATE_PROCESS_TEST_001
299 * @tc.desc: clean invalid connstate process test
300 * @tc.type: FUNC
301 * @tc.require:
302 */
303 HWTEST_F(LNNConnectionFsmMockTest, CLEAN_INVALID_CONNSTATE_PROCESS_TEST_001, TestSize.Level1)
304 {
305 LnnConnectionFsm *connFsm = nullptr;
306 ConnectionAddr target = {
307 .type = CONNECTION_ADDR_BLE,
308 };
309 int32_t *retCode = nullptr;
310 retCode = reinterpret_cast<int32_t *>(SoftBusMalloc(sizeof(int32_t)));
311 *retCode = SOFTBUS_OK;
312 connFsm = LnnCreateConnectionFsm(&target, "pkgName", true);
313 EXPECT_TRUE(connFsm != nullptr);
314 int32_t ret = LnnStartConnectionFsm(connFsm);
315 EXPECT_TRUE(ret == SOFTBUS_OK);
316 connFsm->connInfo.nodeInfo = reinterpret_cast<NodeInfo *>(SoftBusMalloc(sizeof(NodeInfo)));
317 EXPECT_TRUE(connFsm->connInfo.nodeInfo != nullptr);
318 connFsm->fsm.flag = CONN_FLAG;
319 NiceMock<LnnNetLedgertInterfaceMock> netLedgerMock;
320 NiceMock<LnnServicetInterfaceMock> serviceMock;
321 EXPECT_CALL(netLedgerMock, LnnGetRemoteNodeInfoById)
322 .WillOnce(Return(SOFTBUS_INVALID_PARAM))
323 .WillRepeatedly(Return(SOFTBUS_OK));
324 EXPECT_CALL(netLedgerMock, LnnIsNodeOnline).WillRepeatedly(Return(SOFTBUS_INVALID_PARAM));
325 bool ret1 =
326 CleanInvalidConnStateProcess(&connFsm->fsm, FSM_MSG_TYPE_LEAVE_INVALID_CONN, reinterpret_cast<void *>(retCode));
327 EXPECT_TRUE(ret1 == true);
328 ret1 =
329 CleanInvalidConnStateProcess(&connFsm->fsm, FSM_MSG_TYPE_LEAVE_INVALID_CONN, reinterpret_cast<void *>(retCode));
330 EXPECT_TRUE(ret1 == true);
331 ret1 =
332 CleanInvalidConnStateProcess(&connFsm->fsm, FSM_MSG_TYPE_LEAVE_INVALID_CONN, reinterpret_cast<void *>(retCode));
333 EXPECT_TRUE(ret1 == true);
334 ret1 = CleanInvalidConnStateProcess(&connFsm->fsm, FSM_MSG_TYPE_NOT_TRUSTED, reinterpret_cast<void *>(retCode));
335 EXPECT_TRUE(ret1 == true);
336 ret1 = CleanInvalidConnStateProcess(&connFsm->fsm, FSM_MSG_TYPE_DISCONNECT, reinterpret_cast<void *>(retCode));
337 EXPECT_TRUE(ret1 == true);
338 ret1 = CleanInvalidConnStateProcess(&connFsm->fsm, FSM_MSG_TYPE_INITIATE_ONLINE, reinterpret_cast<void *>(retCode));
339 EXPECT_TRUE(ret1 == true);
340 ret1 =
341 CleanInvalidConnStateProcess(&connFsm->fsm, FSM_MSG_TYPE_JOIN_LNN_TIMEOUT, reinterpret_cast<void *>(retCode));
342 EXPECT_TRUE(ret1 == true);
343 ret1 = CleanInvalidConnStateProcess(&connFsm->fsm, FSM_MSG_TYPE_JOIN_LNN, reinterpret_cast<void *>(retCode));
344 EXPECT_TRUE(ret1 == false);
345 LnnDestroyConnectionFsm(connFsm);
346 }
347
348 /*
349 * @tc.name: ONLINE_STATE_PROCESS_TEST_001
350 * @tc.desc: online state process test
351 * @tc.type: FUNC
352 * @tc.require:
353 */
354 HWTEST_F(LNNConnectionFsmMockTest, ONLINE_STATE_PROCESS_TEST_001, TestSize.Level1)
355 {
356 NiceMock<LnnNetLedgertInterfaceMock> netLedgerMock;
357 NiceMock<LnnServicetInterfaceMock> serviceMock;
358 LnnConnectionFsm *connFsm = nullptr;
359 ConnectionAddr target = {
360 .type = CONNECTION_ADDR_BLE,
361 };
362 int32_t *retCode = reinterpret_cast<int32_t *>(SoftBusMalloc(sizeof(int32_t)));
363 *retCode = SOFTBUS_OK;
364 connFsm = LnnCreateConnectionFsm(&target, "pkgName", true);
365 EXPECT_TRUE(connFsm != nullptr);
366 int32_t ret = LnnStartConnectionFsm(connFsm);
367 EXPECT_TRUE(ret == SOFTBUS_OK);
368
369 bool ret1 = OnlineStateProcess(&connFsm->fsm, FSM_MSG_TYPE_JOIN_LNN, reinterpret_cast<void *>(retCode));
370 EXPECT_TRUE(ret1 == true);
371 ret1 = OnlineStateProcess(&connFsm->fsm, FSM_MSG_TYPE_LEAVE_LNN, reinterpret_cast<void *>(retCode));
372 EXPECT_TRUE(ret1 == true);
373 LnnDestroyConnectionFsm(connFsm);
374 }
375
376 /*
377 * @tc.name: LEAVING_STATE_ENTER_TEST_001
378 * @tc.desc: leaving state enter test
379 * @tc.type: FUNC
380 * @tc.require:
381 */
382 HWTEST_F(LNNConnectionFsmMockTest, LEAVING_STATE_ENTER_TEST_001, TestSize.Level1)
383 {
384 LnnConnectionFsm *connFsm = nullptr;
385 ConnectionAddr target = {
386 .type = CONNECTION_ADDR_BLE,
387 };
388 connFsm = LnnCreateConnectionFsm(&target, "pkgName", true);
389 EXPECT_TRUE(connFsm != nullptr);
390 int32_t ret = LnnStartConnectionFsm(connFsm);
391 EXPECT_TRUE(ret == SOFTBUS_OK);
392
393 NiceMock<LnnNetLedgertInterfaceMock> netLedgerMock;
394 NiceMock<LnnServicetInterfaceMock> serviceMock;
395 LeavingStateEnter(nullptr);
396 LeavingStateEnter(&connFsm->fsm);
397 LnnDestroyConnectionFsm(connFsm);
398 }
399
400 /*
401 * @tc.name: LEAVING_STATE_PROCESS_TEST_001
402 * @tc.desc: leaving state process test
403 * @tc.type: FUNC
404 * @tc.require:
405 */
406 HWTEST_F(LNNConnectionFsmMockTest, LEAVING_STATE_PROCESS_TEST_001, TestSize.Level1)
407 {
408 LnnConnectionFsm *connFsm = nullptr;
409 ConnectionAddr target = {
410 .type = CONNECTION_ADDR_BLE,
411 };
412 int32_t *retCode = reinterpret_cast<int32_t *>(SoftBusMalloc(sizeof(int32_t)));
413 *retCode = SOFTBUS_OK;
414 connFsm = LnnCreateConnectionFsm(&target, "pkgName", true);
415 EXPECT_TRUE(connFsm != nullptr);
416 int32_t ret = LnnStartConnectionFsm(connFsm);
417 EXPECT_TRUE(ret == SOFTBUS_OK);
418
419 NiceMock<LnnNetLedgertInterfaceMock> netLedgerMock;
420 bool ret1 = LeavingStateProcess(&connFsm->fsm, FSM_MSG_TYPE_JOIN_LNN, reinterpret_cast<void *>(retCode));
421 EXPECT_TRUE(ret1 == true);
422 ret1 = LeavingStateProcess(&connFsm->fsm, FSM_MSG_TYPE_JOIN_LNN, reinterpret_cast<void *>(retCode));
423 EXPECT_TRUE(ret1 == true);
424 ret1 = LeavingStateProcess(&connFsm->fsm, FSM_MSG_TYPE_AUTH_DONE, reinterpret_cast<void *>(retCode));
425 EXPECT_TRUE(ret1 == false);
426 LnnDestroyConnectionFsm(connFsm);
427 }
428
429 /*
430 * @tc.name: LNN_STOP_CONNECTION_FSM_TEST_001
431 * @tc.desc: lnn stop connection fsm test
432 * @tc.type: FUNC
433 * @tc.require:
434 */
435 HWTEST_F(LNNConnectionFsmMockTest, LNN_STOP_CONNECTION_FSM_TEST_001, TestSize.Level1)
436 {
437 NiceMock<LnnNetLedgertInterfaceMock> netLedgerMock;
438 LnnConnectionFsm *connFsm = nullptr;
439 ConnectionAddr target = {
440 .type = CONNECTION_ADDR_BLE,
441 };
442 int32_t ret = LnnStopConnectionFsm(connFsm, LnnConnectionFsmStopCallback);
443 EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
444 connFsm = LnnCreateConnectionFsm(&target, "pkgName", true);
445 EXPECT_TRUE(connFsm != nullptr);
446 ret = LnnStartConnectionFsm(connFsm);
447 EXPECT_TRUE(ret == SOFTBUS_OK);
448 ret = LnnStopConnectionFsm(connFsm, nullptr);
449 EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
450 ret = LnnStopConnectionFsm(connFsm, LnnConnectionFsmStopCallback);
451 EXPECT_TRUE(ret == SOFTBUS_OK);
452 LnnDestroyConnectionFsm(connFsm);
453 }
454 } // namespace OHOS
455