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 "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.deviceIp, MAX_ADDR_LEN, DEVICE_IP1);
99 (void)strcpy_s(newNodeInfo.connectInfo.deviceIp, MAX_ADDR_LEN, DEVICE_IP1);
100 oldNodeInfo.connectInfo.authPort = PORT1;
101 newNodeInfo.connectInfo.authPort = PORT1;
102 oldNodeInfo.connectInfo.proxyPort = PORT1;
103 newNodeInfo.connectInfo.proxyPort = PORT1;
104 oldNodeInfo.connectInfo.sessionPort = PORT1;
105 newNodeInfo.connectInfo.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.sessionPort = PORT2;
120 ret1 = IsNodeInfoChanged(connFsm, &oldNodeInfo, &newNodeInfo, &type);
121 EXPECT_TRUE(ret1 == true);
122 newNodeInfo.connectInfo.proxyPort = PORT2;
123 ret1 = IsNodeInfoChanged(connFsm, &oldNodeInfo, &newNodeInfo, &type);
124 EXPECT_TRUE(ret1 == true);
125 newNodeInfo.connectInfo.authPort = PORT2;
126 ret1 = IsNodeInfoChanged(connFsm, &oldNodeInfo, &newNodeInfo, &type);
127 EXPECT_TRUE(ret1 == true);
128 (void)strcpy_s(newNodeInfo.connectInfo.deviceIp, MAX_ADDR_LEN, DEVICE_IP2);
129 ret1 = IsNodeInfoChanged(connFsm, &oldNodeInfo, &newNodeInfo, &type);
130 EXPECT_TRUE(ret1 == true);
131
132 LnnDestroyConnectionFsm(connFsm);
133 }
134
135 /*
136 * @tc.name: AUTH_STATE_PROCESS_TEST_001
137 * @tc.desc: auth state process test
138 * @tc.type: FUNC
139 * @tc.require:
140 */
141 HWTEST_F(LNNConnectionFsmMockTest, AUTH_STATE_PROCESS_TEST_001, TestSize.Level1)
142 {
143 NiceMock<LnnServicetInterfaceMock> serviceMock;
144 LnnConnectionFsm *connFsm = nullptr;
145 connFsm = reinterpret_cast<LnnConnectionFsm *>(SoftBusMalloc(sizeof(LnnConnectionFsm)));
146 EXPECT_TRUE(connFsm != nullptr);
147 void *para = nullptr;
148 para = reinterpret_cast<void *>(SoftBusMalloc(sizeof(int32_t)));
149 EXPECT_TRUE(para != nullptr);
150 void *para1 = nullptr;
151 para1 = reinterpret_cast<void *>(SoftBusMalloc(sizeof(int32_t)));
152 EXPECT_TRUE(para1 != nullptr);
153 connFsm->connInfo.authHandle.authId = AUTH_ID;
154 connFsm->isSession = false;
155 EXPECT_CALL(serviceMock, LnnNotifyJoinResult).WillRepeatedly(Return());
156 bool ret = AuthStateProcess(nullptr, FSM_MSG_TYPE_JOIN_LNN, para);
157 EXPECT_TRUE(ret == false);
158 ret = AuthStateProcess(&connFsm->fsm, FSM_MSG_TYPE_JOIN_LNN, para);
159 EXPECT_TRUE(ret == true);
160 ret = AuthStateProcess(&connFsm->fsm, FSM_MSG_TYPE_AUTH_DONE, nullptr);
161 EXPECT_TRUE(ret == true);
162 connFsm->isDead = true;
163 ret = AuthStateProcess(&connFsm->fsm, FSM_MSG_TYPE_JOIN_LNN, nullptr);
164 EXPECT_TRUE(ret == true);
165 ret = AuthStateProcess(&connFsm->fsm, FSM_MSG_TYPE_AUTH_DONE, para1);
166 EXPECT_TRUE(ret == true);
167 ret = AuthStateProcess(&connFsm->fsm, FSM_MSG_TYPE_DISCONNECT, nullptr);
168 EXPECT_TRUE(ret == true);
169 ret = AuthStateProcess(&connFsm->fsm, FSM_MSG_TYPE_JOIN_LNN_TIMEOUT, nullptr);
170 EXPECT_TRUE(ret == true);
171 SoftBusFree(connFsm);
172 }
173
174 /*
175 * @tc.name: AUTH_STATE_PROCESS_TEST_002
176 * @tc.desc: auth state process on join lnn test
177 * @tc.type: FUNC
178 * @tc.require:
179 */
180 HWTEST_F(LNNConnectionFsmMockTest, AUTH_STATE_PROCESS_TEST_002, TestSize.Level1)
181 {
182 LnnConnectionFsm *connFsm = nullptr;
183 ConnectionAddr target = {
184 .type = CONNECTION_ADDR_BLE,
185 };
186 connFsm = LnnCreateConnectionFsm(&target, "pkgName", true);
187 EXPECT_TRUE(connFsm != nullptr);
188 int32_t ret = LnnStartConnectionFsm(connFsm);
189 EXPECT_TRUE(ret == SOFTBUS_OK);
190 connFsm->isDead = false;
191 connFsm->isNeedConnect = false;
192 int32_t *retCode = nullptr;
193 retCode = reinterpret_cast<int32_t *>(SoftBusMalloc(sizeof(int32_t)));
194 EXPECT_TRUE(retCode != nullptr);
195 *retCode = SOFTBUS_OK;
196
197 NiceMock<LnnNetLedgertInterfaceMock> netLedgerMock;
198 NiceMock<LnnServicetInterfaceMock> serviceMock;
199 NiceMock<LnnAuthtInterfaceMock> authtMock;
200 EXPECT_CALL(serviceMock, AuthGenRequestId).WillRepeatedly(Return(REQUEST_ID));
201 EXPECT_CALL(authtMock, AuthStartVerify).WillRepeatedly(Return(SOFTBUS_INVALID_PARAM));
202
203 bool ret1 = AuthStateProcess(&connFsm->fsm, FSM_MSG_TYPE_JOIN_LNN, reinterpret_cast<void *>(retCode));
204 EXPECT_TRUE(ret1 == true);
205
206 LnnDestroyConnectionFsm(connFsm);
207 }
208
209 /*
210 * @tc.name: AUTH_STATE_PROCESS_TEST_003
211 * @tc.desc: auth state process on auth done test
212 * @tc.type: FUNC
213 * @tc.require:
214 */
215 HWTEST_F(LNNConnectionFsmMockTest, AUTH_STATE_PROCESS_TEST_003, TestSize.Level1)
216 {
217 NiceMock<LnnNetLedgertInterfaceMock> netLedgerMock;
218 NiceMock<LnnServicetInterfaceMock> serviceMock;
219 NiceMock<LnnAuthtInterfaceMock> authtMock;
220 EXPECT_CALL(authtMock, AuthGetVersion).WillOnce(Return(SOFTBUS_INVALID_PARAM)).WillRepeatedly(Return(SOFTBUS_OK));
221 EXPECT_CALL(serviceMock, AuthGetDeviceUuid)
222 .WillOnce(Return(SOFTBUS_INVALID_PARAM))
223 .WillRepeatedly(Return(SOFTBUS_OK));
224
225 int32_t *retCode = nullptr;
226 retCode = reinterpret_cast<int32_t *>(SoftBusMalloc(sizeof(int32_t)));
227 EXPECT_TRUE(retCode != nullptr);
228 *retCode = SOFTBUS_OK;
229 int32_t *retCode1 = nullptr;
230 retCode1 = reinterpret_cast<int32_t *>(SoftBusMalloc(sizeof(int32_t)));
231 EXPECT_TRUE(retCode1 != nullptr);
232 *retCode1 = SOFTBUS_OK;
233 int32_t *retCode2 = nullptr;
234 retCode2 = reinterpret_cast<int32_t *>(SoftBusMalloc(sizeof(int32_t)));
235 EXPECT_TRUE(retCode2 != nullptr);
236 *retCode2 = SOFTBUS_OK;
237 int32_t *retCode3 = nullptr;
238 retCode3 = reinterpret_cast<int32_t *>(SoftBusMalloc(sizeof(int32_t)));
239 EXPECT_TRUE(retCode3 != nullptr);
240 *retCode3 = SOFTBUS_OK;
241 LnnConnectionFsm *connFsm = nullptr;
242 ConnectionAddr target = {
243 .type = CONNECTION_ADDR_WLAN,
244 .info.ip.port = PORT1,
245 };
246 (void)strcpy_s(target.info.ip.ip, IP_STR_MAX_LEN, DEVICE_IP1);
247 connFsm = LnnCreateConnectionFsm(&target, "pkgName", true);
248 EXPECT_TRUE(connFsm != nullptr);
249 int32_t ret = LnnStartConnectionFsm(connFsm);
250 EXPECT_TRUE(ret == SOFTBUS_OK);
251 connFsm->connInfo.nodeInfo = reinterpret_cast<NodeInfo *>(SoftBusMalloc(sizeof(NodeInfo)));
252 EXPECT_TRUE(connFsm->connInfo.nodeInfo != nullptr);
253 connFsm->isDead = false;
254 connFsm->fsm.flag = 0;
255 connFsm->fsm.looper = nullptr;
256
257 bool ret1 = AuthStateProcess(&connFsm->fsm, FSM_MSG_TYPE_AUTH_DONE, reinterpret_cast<void *>(retCode));
258 EXPECT_TRUE(ret1 == true);
259 ret1 = AuthStateProcess(&connFsm->fsm, FSM_MSG_TYPE_AUTH_DONE, reinterpret_cast<void *>(retCode1));
260 EXPECT_TRUE(ret1 == true);
261 ret1 = AuthStateProcess(&connFsm->fsm, FSM_MSG_TYPE_AUTH_DONE, reinterpret_cast<void *>(retCode2));
262 EXPECT_TRUE(ret1 == true);
263 (void)strcpy_s(connFsm->connInfo.nodeInfo->uuid, UUID_BUF_LEN, NODE_UDID);
264 ret1 = AuthStateProcess(&connFsm->fsm, FSM_MSG_TYPE_AUTH_DONE, reinterpret_cast<void *>(retCode3));
265 EXPECT_TRUE(ret1 == true);
266
267 LnnDestroyConnectionFsm(connFsm);
268 }
269
270 /*
271 * @tc.name: ONLINE_STATE_ENTER_TEST_001
272 * @tc.desc: online state enter test
273 * @tc.type: FUNC
274 * @tc.require:
275 */
276 HWTEST_F(LNNConnectionFsmMockTest, ONLINE_STATE_ENTER_TEST_001, TestSize.Level1)
277 {
278 LnnConnectionFsm *connFsm = nullptr;
279 ConnectionAddr target = {
280 .type = CONNECTION_ADDR_BLE,
281 };
282 connFsm = LnnCreateConnectionFsm(&target, "pkgName", true);
283 EXPECT_TRUE(connFsm != nullptr);
284 int32_t ret = LnnStartConnectionFsm(connFsm);
285 EXPECT_TRUE(ret == SOFTBUS_OK);
286 connFsm->connInfo.nodeInfo = reinterpret_cast<NodeInfo *>(SoftBusMalloc(sizeof(NodeInfo)));
287 EXPECT_TRUE(connFsm->connInfo.nodeInfo != nullptr);
288 NiceMock<LnnNetLedgertInterfaceMock> netLedgerMock;
289 NiceMock<LnnServicetInterfaceMock> serviceMock;
290 EXPECT_CALL(netLedgerMock, LnnAddOnlineNode).WillOnce(Return(REPORT_CHANGE)).WillRepeatedly(Return(REPORT_ONLINE));
291
292 OnlineStateEnter(nullptr);
293 OnlineStateEnter(&connFsm->fsm);
294 connFsm->connInfo.nodeInfo = reinterpret_cast<NodeInfo *>(SoftBusMalloc(sizeof(NodeInfo)));
295 EXPECT_TRUE(connFsm->connInfo.nodeInfo != nullptr);
296 OnlineStateEnter(&connFsm->fsm);
297
298 LnnDestroyConnectionFsm(connFsm);
299 }
300
301 /*
302 * @tc.name: CLEAN_INVALID_CONNSTATE_PROCESS_TEST_001
303 * @tc.desc: clean invalid connstate process test
304 * @tc.type: FUNC
305 * @tc.require:
306 */
307 HWTEST_F(LNNConnectionFsmMockTest, CLEAN_INVALID_CONNSTATE_PROCESS_TEST_001, TestSize.Level1)
308 {
309 LnnConnectionFsm *connFsm = nullptr;
310 ConnectionAddr target = {
311 .type = CONNECTION_ADDR_BLE,
312 };
313 int32_t *retCode = nullptr;
314 retCode = reinterpret_cast<int32_t *>(SoftBusMalloc(sizeof(int32_t)));
315 *retCode = SOFTBUS_OK;
316 connFsm = LnnCreateConnectionFsm(&target, "pkgName", true);
317 EXPECT_TRUE(connFsm != nullptr);
318 int32_t ret = LnnStartConnectionFsm(connFsm);
319 EXPECT_TRUE(ret == SOFTBUS_OK);
320 connFsm->connInfo.nodeInfo = reinterpret_cast<NodeInfo *>(SoftBusMalloc(sizeof(NodeInfo)));
321 EXPECT_TRUE(connFsm->connInfo.nodeInfo != nullptr);
322 connFsm->fsm.flag = CONN_FLAG;
323 NiceMock<LnnNetLedgertInterfaceMock> netLedgerMock;
324 NiceMock<LnnServicetInterfaceMock> serviceMock;
325 EXPECT_CALL(netLedgerMock, LnnGetRemoteNodeInfoById)
326 .WillOnce(Return(SOFTBUS_INVALID_PARAM))
327 .WillRepeatedly(Return(SOFTBUS_OK));
328 EXPECT_CALL(netLedgerMock, LnnIsNodeOnline).WillRepeatedly(Return(SOFTBUS_INVALID_PARAM));
329 bool ret1 =
330 CleanInvalidConnStateProcess(&connFsm->fsm, FSM_MSG_TYPE_LEAVE_INVALID_CONN, reinterpret_cast<void *>(retCode));
331 EXPECT_TRUE(ret1 == true);
332 ret1 =
333 CleanInvalidConnStateProcess(&connFsm->fsm, FSM_MSG_TYPE_LEAVE_INVALID_CONN, reinterpret_cast<void *>(retCode));
334 EXPECT_TRUE(ret1 == true);
335 ret1 =
336 CleanInvalidConnStateProcess(&connFsm->fsm, FSM_MSG_TYPE_LEAVE_INVALID_CONN, reinterpret_cast<void *>(retCode));
337 EXPECT_TRUE(ret1 == true);
338 ret1 = CleanInvalidConnStateProcess(&connFsm->fsm, FSM_MSG_TYPE_NOT_TRUSTED, reinterpret_cast<void *>(retCode));
339 EXPECT_TRUE(ret1 == true);
340 ret1 = CleanInvalidConnStateProcess(&connFsm->fsm, FSM_MSG_TYPE_DISCONNECT, reinterpret_cast<void *>(retCode));
341 EXPECT_TRUE(ret1 == true);
342 ret1 = CleanInvalidConnStateProcess(&connFsm->fsm, FSM_MSG_TYPE_INITIATE_ONLINE, reinterpret_cast<void *>(retCode));
343 EXPECT_TRUE(ret1 == true);
344 ret1 =
345 CleanInvalidConnStateProcess(&connFsm->fsm, FSM_MSG_TYPE_JOIN_LNN_TIMEOUT, reinterpret_cast<void *>(retCode));
346 EXPECT_TRUE(ret1 == true);
347 ret1 = CleanInvalidConnStateProcess(&connFsm->fsm, FSM_MSG_TYPE_JOIN_LNN, reinterpret_cast<void *>(retCode));
348 EXPECT_TRUE(ret1 == false);
349
350 LnnDestroyConnectionFsm(connFsm);
351 }
352
353 /*
354 * @tc.name: ONLINE_STATE_PROCESS_TEST_001
355 * @tc.desc: online state process test
356 * @tc.type: FUNC
357 * @tc.require:
358 */
359 HWTEST_F(LNNConnectionFsmMockTest, ONLINE_STATE_PROCESS_TEST_001, TestSize.Level1)
360 {
361 NiceMock<LnnNetLedgertInterfaceMock> netLedgerMock;
362 NiceMock<LnnServicetInterfaceMock> serviceMock;
363 LnnConnectionFsm *connFsm = nullptr;
364 ConnectionAddr target = {
365 .type = CONNECTION_ADDR_BLE,
366 };
367 int32_t *retCode = reinterpret_cast<int32_t *>(SoftBusMalloc(sizeof(int32_t)));
368 *retCode = SOFTBUS_OK;
369 connFsm = LnnCreateConnectionFsm(&target, "pkgName", true);
370 EXPECT_TRUE(connFsm != nullptr);
371 int32_t ret = LnnStartConnectionFsm(connFsm);
372 EXPECT_TRUE(ret == SOFTBUS_OK);
373
374 bool ret1 = OnlineStateProcess(&connFsm->fsm, FSM_MSG_TYPE_JOIN_LNN, reinterpret_cast<void *>(retCode));
375 EXPECT_TRUE(ret1 == true);
376 ret1 = OnlineStateProcess(&connFsm->fsm, FSM_MSG_TYPE_LEAVE_LNN, reinterpret_cast<void *>(retCode));
377 EXPECT_TRUE(ret1 == true);
378
379 LnnDestroyConnectionFsm(connFsm);
380 }
381
382 /*
383 * @tc.name: LEAVING_STATE_ENTER_TEST_001
384 * @tc.desc: leaving state enter test
385 * @tc.type: FUNC
386 * @tc.require:
387 */
388 HWTEST_F(LNNConnectionFsmMockTest, LEAVING_STATE_ENTER_TEST_001, TestSize.Level1)
389 {
390 LnnConnectionFsm *connFsm = nullptr;
391 ConnectionAddr target = {
392 .type = CONNECTION_ADDR_BLE,
393 };
394 connFsm = LnnCreateConnectionFsm(&target, "pkgName", true);
395 EXPECT_TRUE(connFsm != nullptr);
396 int32_t ret = LnnStartConnectionFsm(connFsm);
397 EXPECT_TRUE(ret == SOFTBUS_OK);
398
399 NiceMock<LnnNetLedgertInterfaceMock> netLedgerMock;
400 NiceMock<LnnServicetInterfaceMock> serviceMock;
401 LeavingStateEnter(nullptr);
402 LeavingStateEnter(&connFsm->fsm);
403
404 LnnDestroyConnectionFsm(connFsm);
405 }
406
407 /*
408 * @tc.name: LEAVING_STATE_PROCESS_TEST_001
409 * @tc.desc: leaving state process test
410 * @tc.type: FUNC
411 * @tc.require:
412 */
413 HWTEST_F(LNNConnectionFsmMockTest, LEAVING_STATE_PROCESS_TEST_001, TestSize.Level1)
414 {
415 LnnConnectionFsm *connFsm = nullptr;
416 ConnectionAddr target = {
417 .type = CONNECTION_ADDR_BLE,
418 };
419 int32_t *retCode = reinterpret_cast<int32_t *>(SoftBusMalloc(sizeof(int32_t)));
420 *retCode = SOFTBUS_OK;
421 connFsm = LnnCreateConnectionFsm(&target, "pkgName", true);
422 EXPECT_TRUE(connFsm != nullptr);
423 int32_t ret = LnnStartConnectionFsm(connFsm);
424 EXPECT_TRUE(ret == SOFTBUS_OK);
425
426 NiceMock<LnnNetLedgertInterfaceMock> netLedgerMock;
427 bool ret1 = LeavingStateProcess(&connFsm->fsm, FSM_MSG_TYPE_JOIN_LNN, reinterpret_cast<void *>(retCode));
428 EXPECT_TRUE(ret1 == true);
429 ret1 = LeavingStateProcess(&connFsm->fsm, FSM_MSG_TYPE_JOIN_LNN, reinterpret_cast<void *>(retCode));
430 EXPECT_TRUE(ret1 == true);
431 ret1 = LeavingStateProcess(&connFsm->fsm, FSM_MSG_TYPE_AUTH_DONE, reinterpret_cast<void *>(retCode));
432 EXPECT_TRUE(ret1 == false);
433
434 LnnDestroyConnectionFsm(connFsm);
435 }
436
437 /*
438 * @tc.name: LNN_STOP_CONNECTION_FSM_TEST_001
439 * @tc.desc: lnn stop connection fsm test
440 * @tc.type: FUNC
441 * @tc.require:
442 */
443 HWTEST_F(LNNConnectionFsmMockTest, LNN_STOP_CONNECTION_FSM_TEST_001, TestSize.Level1)
444 {
445 NiceMock<LnnNetLedgertInterfaceMock> netLedgerMock;
446 LnnConnectionFsm *connFsm = nullptr;
447 ConnectionAddr target = {
448 .type = CONNECTION_ADDR_BLE,
449 };
450 int32_t ret = LnnStopConnectionFsm(connFsm, LnnConnectionFsmStopCallback);
451 EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
452 connFsm = LnnCreateConnectionFsm(&target, "pkgName", true);
453 EXPECT_TRUE(connFsm != nullptr);
454 ret = LnnStartConnectionFsm(connFsm);
455 EXPECT_TRUE(ret == SOFTBUS_OK);
456 ret = LnnStopConnectionFsm(connFsm, nullptr);
457 EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
458 ret = LnnStopConnectionFsm(connFsm, LnnConnectionFsmStopCallback);
459 EXPECT_TRUE(ret == SOFTBUS_OK);
460
461 LnnDestroyConnectionFsm(connFsm);
462 }
463 } // namespace OHOS
464