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