1 /*
2 * Copyright (c) 2021 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 <cstring>
17 #include <gtest/gtest.h>
18 #include <securec.h>
19 #include "p2plink_manager.h"
20 #include "softbus_log.h"
21 #include "p2plink_interface.h"
22 #include "p2plink_message.c"
23 #include "p2plink_channel_freq.h"
24 #include "softbus_errcode.h"
25 #include "p2plink_json_payload.h"
26 #include "softbus_json_utils.h"
27 #include "softbus_adapter_mem.h"
28 #include "p2plink_common.h"
29 #include "p2plink_state_machine.h"
30 #include "p2plink_adapter.h"
31 #include "softbus_server_frame.h"
32 #include "p2plink_broadcast_receiver.h"
33 #include "p2plink_control_message.h"
34 #include "message_handler.h"
35
36 static const int32_t TEST_FREQUENCY_INVALID = -1;
37 static const int32_t MAX_STRING_NUM = 5;
38 static const int32_t TEST_DATA_NUM = 1;
39 static const int32_t TEST_CHAN_LIST = 10;
40 static const int32_t ERR_CHAN_LIST = 22;
41 using namespace testing::ext;
42 namespace OHOS {
43 class ConnectionP2PFuncTest : public testing::Test {
44 public:
SetUpTestCase()45 static void SetUpTestCase() {}
TearDownTestCase()46 static void TearDownTestCase() {}
SetUp()47 void SetUp() override {}
TearDown()48 void TearDown() override {}
49 };
50
SetUp()51 void SetUp()
52 {
53 InitSoftBusServer();
54 }
55
TestP2pLinkNegoSuccess(int32_t requestId,const P2pLinkNegoConnResult * result)56 static void TestP2pLinkNegoSuccess(int32_t requestId, const P2pLinkNegoConnResult *result)
57 {
58 return;
59 }
60
TestP2pLinkNegoFail(int32_t requestId,int32_t reason)61 static void TestP2pLinkNegoFail(int32_t requestId, int32_t reason)
62 {
63 return;
64 }
65
TestP2pLinkNegoConnected(const P2pLinkNegoConnResult * result)66 static void TestP2pLinkNegoConnected(const P2pLinkNegoConnResult *result)
67 {
68 return;
69 }
70
71 static P2pLinkNegoCb g_testP2pLinkNegoCb = {
72 .onConnected = TestP2pLinkNegoSuccess,
73 .onConnectFailed = TestP2pLinkNegoFail,
74 .onPeerConnected = TestP2pLinkNegoConnected,
75 };
76
77 /*
78 * @tc.name: testP2pLinkLoopDisconnectDev001
79 * @tc.desc: arg is NULL
80 * @tc.type: FUNC
81 * @tc.require:
82 */
83 HWTEST_F(ConnectionP2PFuncTest, testP2pLinkLoopDisconnectDev001, TestSize.Level1)
84 {
85 P2pLinkLoopDisconnectDev(P2PLOOP_P2PAUTHCHAN_OK, nullptr);
86 EXPECT_EQ(true, true);
87 }
88
89 /*
90 * @tc.name: testP2pLinkLoopDisconnectDev002
91 * @tc.desc: test ConnTypeIsSupport
92 * @tc.type: FUNC
93 * @tc.require:
94 */
95 HWTEST_F(ConnectionP2PFuncTest, testP2pLinkLoopDisconnectDev002, TestSize.Level1)
96 {
97 auto *info = static_cast<P2pLinkDisconnectInfo *>(SoftBusMalloc(sizeof(P2pLinkDisconnectInfo)));
98 ASSERT_TRUE(info != nullptr);
99 info->pid = 11;
100 info->authId = 11;
101 (void)strcpy_s(info->peerMac, sizeof(info->peerMac), "abc");
102
103 P2pLinkLoopDisconnectDev(P2PLOOP_P2PAUTHCHAN_OK, info);
104 EXPECT_EQ(true, true);
105 }
106
107 /*
108 * @tc.name: testP2pLinkNeoDataProcess001
109 * @tc.desc: param is NULL
110 * @tc.type: FUNC
111 * @tc.require:
112 */
113 HWTEST_F(ConnectionP2PFuncTest, testP2pLinkNeoDataProcess001, TestSize.Level1)
114 {
115 P2pLinkNeoDataProcess(P2PLOOP_P2PAUTHCHAN_OK, nullptr);
116 EXPECT_EQ(true, true);
117 }
118
119 /*
120 * @tc.name: testP2pLinkNegoDataRecv001
121 * @tc.desc: param is NULL
122 * @tc.type: FUNC
123 * @tc.require:
124 */
125 HWTEST_F(ConnectionP2PFuncTest, testP2pLinkNegoDataRecv001, TestSize.Level1)
126 {
127 int64_t authId = 11;
128 AuthTransData *data = nullptr;
129 P2pLinkNegoDataRecv(authId, data);
130 EXPECT_EQ(true, true);
131 }
132
133 /*
134 * @tc.name: testP2pLinkSendMessage001
135 * @tc.desc: param is NULL
136 * @tc.type: FUNC
137 * @tc.require:
138 */
139 HWTEST_F(ConnectionP2PFuncTest, testP2pLinkSendMessage001, TestSize.Level1)
140 {
141 char data[] = "data";
142 int ret = P2pLinkSendMessage(11, data, strlen(data));
143 EXPECT_EQ(ret, SOFTBUS_ERR);
144 }
145
146 /*
147 * @tc.name: P2plinkChannelListToStringTest001
148 * @tc.desc: Use different parameters to convert the channel list to a string.
149 * @tc.type: FUNC
150 * @tc.require:
151 */
152 HWTEST_F(ConnectionP2PFuncTest, P2plinkChannelListToStringTest001, TestSize.Level1)
153 {
154 P2pLink5GList *testChannelList = (P2pLink5GList *)SoftBusCalloc(sizeof(P2pLink5GList) +
155 sizeof(int32_t) * TEST_DATA_NUM);
156 ASSERT_TRUE(testChannelList != nullptr);
157
158 testChannelList->num = TEST_DATA_NUM;
159 testChannelList->chans[0] = TEST_CHAN_LIST;
160 char testChannelString[] = "aaabbb";
161 int32_t len = sizeof(testChannelList->chans);
162 int32_t ret = P2plinkChannelListToString(nullptr, testChannelString, len);
163 EXPECT_EQ(ret, SOFTBUS_OK);
164
165 ret = P2plinkChannelListToString(testChannelList, nullptr, len);
166 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
167
168 ret = P2plinkChannelListToString(testChannelList, testChannelString, 0);
169 EXPECT_EQ(ret, SOFTBUS_MEM_ERR);
170
171 ret = P2plinkChannelListToString(testChannelList, testChannelString, len - 1);
172 EXPECT_EQ(ret, SOFTBUS_MEM_ERR);
173
174 ret = P2plinkChannelListToString(testChannelList, testChannelString, len);
175 EXPECT_EQ(ret, SOFTBUS_MEM_ERR);
176
177 testChannelList->num = 0;
178 ret = P2plinkChannelListToString(testChannelList, testChannelString, len);
179 EXPECT_EQ(ret, SOFTBUS_OK);
180 testChannelList->num = TEST_DATA_NUM;
181 }
182
183 /*
184 * @tc.name: P2pLinkUpateAndGetStationFreqTest001
185 * @tc.desc: some diff param in P2pLinkUpateAndGetStationFreq update and get freq.
186 * @tc.type: FUNC
187 * @tc.require:
188 */
189 HWTEST_F(ConnectionP2PFuncTest, P2pLinkUpateAndGetStationFreqTest001, TestSize.Level1)
190 {
191 P2pLink5GList *testChannelList = (P2pLink5GList *)SoftBusCalloc(sizeof(P2pLink5GList) +
192 sizeof(int32_t) * TEST_DATA_NUM);
193 ASSERT_TRUE(testChannelList != nullptr);
194
195 testChannelList->num = TEST_DATA_NUM;
196 testChannelList->chans[0] = ERR_CHAN_LIST;
197
198 int32_t ret = P2pLinkUpateAndGetStationFreq(nullptr);
199 EXPECT_EQ(ret, TEST_FREQUENCY_INVALID);
200
201 testChannelList->num = 0;
202 ret = P2pLinkUpateAndGetStationFreq(testChannelList);
203 EXPECT_EQ(ret, TEST_FREQUENCY_INVALID);
204 testChannelList->num = 1;
205
206 ret = P2pLinkUpateAndGetStationFreq(testChannelList);
207 EXPECT_EQ(ret, TEST_FREQUENCY_INVALID);
208 }
209
210 /*
211 * @tc.name: P2pLinkParseItemDataByDelimitTest001
212 * @tc.desc: some diff param in P2pLinkParseItemDataByDelimit to list.
213 * @tc.type: FUNC
214 * @tc.require:
215 */
216 HWTEST_F(ConnectionP2PFuncTest, P2pLinkParseItemDataByDelimitTest001, TestSize.Level1)
217 {
218 char *testList[MAX_STRING_NUM] = {nullptr};
219 int32_t testOutNum = 0;
220 char testString[] = "aaa\nbbb\nccc\nddd\neee";
221
222 P2pLinkParseItemDataByDelimit(testString, "\n", testList, MAX_STRING_NUM, &testOutNum);
223 EXPECT_GE(testOutNum, MAX_STRING_NUM);
224 int32_t ret = strcmp(testList[0], "aaa");
225 EXPECT_EQ(EOK, ret);
226
227 testOutNum = 0;
228 P2pLinkParseItemDataByDelimit(nullptr, "\n", testList, MAX_STRING_NUM, &testOutNum);
229 EXPECT_EQ(testOutNum, 0);
230
231 P2pLinkParseItemDataByDelimit(testString, nullptr, testList, MAX_STRING_NUM, &testOutNum);
232 EXPECT_EQ(testOutNum, 0);
233
234 P2pLinkParseItemDataByDelimit(testString, "\n", nullptr, MAX_STRING_NUM, &testOutNum);
235 EXPECT_EQ(testOutNum, 0);
236
237 P2pLinkParseItemDataByDelimit(testString, "\n", testList, 0, &testOutNum);
238 EXPECT_EQ(testOutNum, 0);
239
240 P2pLinkParseItemDataByDelimit(testString, "\n", testList, MAX_STRING_NUM, nullptr);
241 EXPECT_EQ(testOutNum, 0);
242 }
243
244 /*
245 * @tc.name: P2pLinkUnpackRequestMsgTest001
246 * @tc.desc: use different parameters to parse the request msg packet.
247 * @tc.type: FUNC
248 * @tc.require:
249 */
250 HWTEST_F(ConnectionP2PFuncTest, P2pLinkUnpackRequestMsgTest001, TestSize.Level1)
251 {
252 cJSON *testData = cJSON_CreateObject();
253 ASSERT_TRUE(testData != nullptr);
254 P2pContentType testType = CONTENT_TYPE_GO_INFO;
255 P2pRequestMsg testRequest;
256 (void)memset_s(&testRequest, sizeof(P2pRequestMsg), 0, sizeof(P2pRequestMsg));
257 P2pRequestMsg testRequestMsg = {
258 .cmdType = 0,
259 .version = 1,
260 .role = ROLE_GC,
261 .isbridgeSupport = false,
262 .contentType = CONTENT_TYPE_GC_INFO,
263 .myMac = "11:22:33:44:55:66",
264 .wifiCfg = "testWifiCfgInfo",
265 };
266
267 int32_t ret = P2pLinkUnpackRequestMsg(nullptr, testType, &testRequest);
268 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
269
270 ret = P2pLinkUnpackRequestMsg(testData, testType, nullptr);
271 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
272
273 ret = P2pLinkUnpackRequestMsg(testData, testType, &testRequest);
274 EXPECT_EQ(ret, SOFTBUS_PARSE_JSON_ERR);
275
276 testType = CONTENT_TYPE_GC_INFO;
277 ret = P2pLinkUnpackRequestMsg(testData, testType, &testRequest);
278 EXPECT_EQ(ret, SOFTBUS_PARSE_JSON_ERR);
279
280 testType = CONTENT_TYPE_RESULT;
281 ret = P2pLinkUnpackRequestMsg(testData, testType, &testRequest);
282 EXPECT_EQ(ret, SOFTBUS_PARSE_JSON_ERR);
283
284 ret = P2pLinkPackRequestMsg(&testRequestMsg, CONTENT_TYPE_RESULT, testData);
285 EXPECT_EQ(ret, SOFTBUS_OK);
286
287 ret = P2pLinkUnpackRequestMsg(testData, testType, &testRequest);
288 EXPECT_EQ(ret, SOFTBUS_OK);
289
290 cJSON_Delete(testData);
291 }
292
293 /*
294 * @tc.name: P2plinkUnpackRepsonseMsgTest001
295 * @tc.desc: use different parameters to parse the repsonse msg packet.
296 * @tc.type: FUNC
297 * @tc.require:
298 */
299 HWTEST_F(ConnectionP2PFuncTest, P2plinkUnpackRepsonseMsgTest001, TestSize.Level1)
300 {
301 cJSON *testData = cJSON_CreateObject();
302 ASSERT_TRUE(testData != nullptr);
303 P2pContentType testType = CONTENT_TYPE_GO_INFO;
304 P2pRespMsg testResponse;
305 (void)memset_s(&testResponse, sizeof(P2pRespMsg), 0, sizeof(P2pRespMsg));
306 P2pRespMsg testResponseMsg = {
307 .cmdType = 0,
308 .version = 1,
309 .result = ROLE_GC,
310 .contentType = CONTENT_TYPE_GC_INFO,
311 .myMac = "11:22:33:44:55:66",
312 .myIp = "192.168.1.1",
313 .wifiCfg = "testWifiCfgInfo",
314 };
315
316 int32_t ret = P2plinkUnpackRepsonseMsg(nullptr, testType, &testResponse);
317 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
318
319 ret = P2plinkUnpackRepsonseMsg(testData, testType, nullptr);
320 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
321
322 ret = P2plinkUnpackRepsonseMsg(testData, testType, &testResponse);
323 EXPECT_EQ(ret, SOFTBUS_PARSE_JSON_ERR);
324
325 testType = CONTENT_TYPE_GC_INFO;
326 ret = P2plinkUnpackRepsonseMsg(testData, testType, &testResponse);
327 EXPECT_EQ(ret, SOFTBUS_PARSE_JSON_ERR);
328
329 testType = CONTENT_TYPE_RESULT;
330 ret = P2plinkUnpackRepsonseMsg(testData, testType, &testResponse);
331 EXPECT_EQ(ret, SOFTBUS_PARSE_JSON_ERR);
332
333 ret = P2plinkPackRepsonseMsg(&testResponseMsg, CONTENT_TYPE_RESULT, testData);
334 EXPECT_EQ(ret, SOFTBUS_OK);
335
336 ret = P2plinkUnpackRepsonseMsg(testData, testType, &testResponse);
337 EXPECT_EQ(ret, SOFTBUS_OK);
338
339 cJSON_Delete(testData);
340 }
341
342 /*
343 * @tc.name: P2pLinkNegoInitTest001
344 * @tc.desc: some diff param in P2pLinkNegoInit.
345 * @tc.type: FUNC
346 * @tc.require:
347 */
348 HWTEST_F(ConnectionP2PFuncTest, P2pLinkNegoInitTest001, TestSize.Level1)
349 {
350 int32_t ret = P2pLinkNegoInit(nullptr);
351 EXPECT_EQ(ret, SOFTBUS_ERR);
352
353 ret = P2pLinkNegoInit(&g_testP2pLinkNegoCb);
354 EXPECT_EQ(ret, SOFTBUS_OK);
355 }
356
357 /*
358 * @tc.name: P2pLinkNegoStartTest001
359 * @tc.desc: Start a negotiation with right parameters.
360 * @tc.type: FUNC
361 * @tc.require:
362 */
363 HWTEST_F(ConnectionP2PFuncTest, P2pLinkNegoStartTest001, TestSize.Level1)
364 {
365 P2pLinkNegoConnInfo testConnInfo = {
366 .authId = 1,
367 .requestId = 1,
368 .expectRole = ROLE_AUTO,
369 .peerMac = "11:22:33:44:55:66",
370 };
371
372 int32_t ret = P2pLinkManagerInit();
373 ASSERT_EQ(ret, SOFTBUS_OK);
374
375 P2pLinkNegoStart(&testConnInfo);
376 P2pLinkNegoStop();
377 }
378
379 /*
380 * @tc.name: GetP2pLinkNegoStatusTest001
381 * @tc.desc: Gets the current negotiation status.
382 * @tc.type: FUNC
383 * @tc.require:
384 */
385 HWTEST_F(ConnectionP2PFuncTest, GetP2pLinkNegoStatusTest001, TestSize.Level1)
386 {
387 int32_t ret = P2pLinkNegoInit(&g_testP2pLinkNegoCb);
388 ASSERT_EQ(ret, SOFTBUS_OK);
389
390 ret = GetP2pLinkNegoStatus();
391 EXPECT_EQ(ret, P2PLINK_NEG_IDLE);
392 }
393
394 /*
395 * @tc.name: P2pLinkNegoMsgProcTest001
396 * @tc.desc: Send different types of messages for negotiation.
397 * @tc.type: FUNC
398 * @tc.require:
399 */
400 HWTEST_F(ConnectionP2PFuncTest, P2pLinkNegoMsgProcTest001, TestSize.Level1)
401 {
402 cJSON *testData = cJSON_CreateObject();
403 ASSERT_TRUE(testData != nullptr);
404 P2pLinkCmdType testCmdType = CMD_CONNECT_RESPONSE;
405 int64_t authId = 1;
406 P2pLinkNegoMsgProc(authId, testCmdType, nullptr);
407
408 P2pLinkNegoMsgProc(authId, testCmdType, testData);
409
410 testCmdType = CMD_CONNECT_REQUEST;
411 P2pLinkNegoMsgProc(authId, testCmdType, testData);
412
413 cJSON_Delete(testData);
414 }
415
416 /*
417 * @tc.name: P2pLinkNegoOnGroupChangedTest001
418 * @tc.desc: Different group data is modified to negotiate the group.
419 * @tc.type: FUNC
420 * @tc.require:
421 */
422 HWTEST_F(ConnectionP2PFuncTest, P2pLinkNegoOnGroupChangedTest001, TestSize.Level1)
423 {
424 P2pLinkGroup group;
425
426 int32_t ret = P2pLinkNegoInit(&g_testP2pLinkNegoCb);
427 EXPECT_EQ(ret, SOFTBUS_OK);
428
429 P2pLinkNegoOnGroupChanged(nullptr);
430 P2pLinkNegoOnGroupChanged(&group);
431 }
432
433 /*
434 * @tc.name: P2pLinkNegoOnConnectStateTest001
435 * @tc.desc: Change the link to negotiate the recv connection state change.
436 * @tc.type: FUNC
437 * @tc.require:
438 */
439 HWTEST_F(ConnectionP2PFuncTest, P2pLinkNegoOnConnectStateTest001, TestSize.Level1)
440 {
441 P2pLinkConnState testState = P2PLINK_CONNECTING;
442
443 int32_t ret = P2pLinkNegoInit(&g_testP2pLinkNegoCb);
444 EXPECT_EQ(ret, SOFTBUS_OK);
445
446 P2pLinkNegoOnConnectState(testState);
447 }
448
449 /*
450 * @tc.name: P2pLinkNegoGetFinalRoleTest001
451 * @tc.desc: Different roles at both ends get the final role.
452 * @tc.type: FUNC
453 * @tc.require:
454 */
455 HWTEST_F(ConnectionP2PFuncTest, P2pLinkNegoGetFinalRoleTest001, TestSize.Level1)
456 {
457 P2pLinkRole testMyRole = ROLE_GO;
458 P2pLinkRole testPeerRole = ROLE_GO;
459 bool isSupportBridge = false;
460 const char *testMyGoMac = "11:22:33:44:55:66";
461 const char *testPeerGoMac = "11:22:33:44:55:66";
462
463 int32_t ret = P2pLinkNegoInit(&g_testP2pLinkNegoCb);
464 ASSERT_EQ(ret, SOFTBUS_OK);
465
466 P2pLinkSetRole(testMyRole);
467 P2pLinkSetGoMac(testMyGoMac);
468 ret = P2pLinkNegoGetFinalRole(testPeerRole, testPeerRole, testPeerGoMac, isSupportBridge);
469 EXPECT_EQ(ret, ERROR_BOTH_GO);
470
471 testMyRole = ROLE_GC;
472 P2pLinkSetRole(testMyRole);
473 P2pLinkSetGoMac(testMyGoMac);
474 ret = P2pLinkNegoGetFinalRole(testPeerRole, testPeerRole, testPeerGoMac, isSupportBridge);
475 EXPECT_EQ(ret, ROLE_GC);
476
477
478 testMyRole = ROLE_NONE;
479 P2pLinkSetRole(testMyRole);
480 P2pLinkSetGoMac(testMyGoMac);
481 ret = P2pLinkNegoGetFinalRole(testPeerRole, testPeerRole, testPeerGoMac, isSupportBridge);
482 EXPECT_EQ(ret, ROLE_GC);
483 }
484
485 /*
486 * @tc.name: P2pLinkFsmInitTest001
487 * @tc.desc: some diff param in P2pLinkFsmInit.
488 * @tc.type: FUNC
489 * @tc.require:
490 */
491 HWTEST_F(ConnectionP2PFuncTest, P2pLinkFsmInitTest001, TestSize.Level1)
492 {
493 FsmStateMachine *testFsm = (FsmStateMachine *)SoftBusCalloc(sizeof(FsmStateMachine));
494 ASSERT_TRUE(testFsm != nullptr);
495 int32_t ret = P2pLinkFsmInit(nullptr);
496 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
497
498 ret = P2pLinkFsmInit(testFsm);
499 EXPECT_EQ(ret, SOFTBUS_OK);
500 SoftBusFree(testFsm);
501 }
502
503 /*
504 * @tc.name: P2pLinkFsmDeinitTest001
505 * @tc.desc: some diff param in P2pLinkFsmDeinit.
506 * @tc.type: FUNC
507 * @tc.require:
508 */
509 HWTEST_F(ConnectionP2PFuncTest, P2pLinkFsmDeinitTest001, TestSize.Level1)
510 {
511 FsmStateMachine *testFsm = (FsmStateMachine *)SoftBusCalloc(sizeof(FsmStateMachine));
512 ASSERT_TRUE(testFsm != nullptr);
513 P2pLinkFsmDeinit(nullptr);
514
515 int32_t ret = P2pLinkFsmInit(testFsm);
516 ASSERT_EQ(ret, SOFTBUS_OK);
517 P2pLinkFsmDeinit(testFsm);
518 P2pLinkFsmDeinit(testFsm);
519
520 SoftBusFree(testFsm);
521 }
522
523 /*
524 * @tc.name: P2pLinkFsmStartTest001
525 * @tc.desc: some diff param in P2pLinkFsmStart.
526 * @tc.type: FUNC
527 * @tc.require:
528 */
529 HWTEST_F(ConnectionP2PFuncTest, P2pLinkFsmStartTest001, TestSize.Level1)
530 {
531 FsmStateMachine *testFsm = (FsmStateMachine *)SoftBusCalloc(sizeof(FsmStateMachine));
532 ASSERT_TRUE(testFsm != nullptr);
533 FsmState *testInitialState = (FsmState *)SoftBusCalloc(sizeof(FsmState));
534 ASSERT_TRUE(testInitialState != nullptr);
535
536 int32_t ret = P2pLinkFsmInit(testFsm);
537 ASSERT_EQ(ret, SOFTBUS_OK);
538
539 P2pLinkFsmStart(testFsm, testInitialState);
540 testFsm->currentState =nullptr;
541 P2pLinkFsmStart(testFsm, testInitialState);
542
543 P2pLinkFsmAddState(testFsm, testInitialState);
544 P2pLinkFsmStart(testFsm, testInitialState);
545
546 P2pLinkFsmStop(testFsm);
547 EXPECT_TRUE(testFsm->currentState == nullptr);
548 P2pLinkFsmStop(testFsm);
549
550 SoftBusFree(testFsm);
551 SoftBusFree(testInitialState);
552 }
553
554 /*
555 * @tc.name: P2pLinkFsmTransactStateTest001
556 * @tc.desc: some diff param in P2pLinkFsmTransactState.
557 * @tc.type: FUNC
558 * @tc.require:
559 */
560 HWTEST_F(ConnectionP2PFuncTest, P2pLinkFsmTransactStateTest001, TestSize.Level1)
561 {
562 FsmStateMachine *testFsm = (FsmStateMachine *)SoftBusCalloc(sizeof(FsmStateMachine));
563 ASSERT_TRUE(testFsm != nullptr);
564 FsmState *testState = (FsmState *)SoftBusCalloc(sizeof(FsmState));
565 ASSERT_TRUE(testState != nullptr);
566
567 int32_t ret = P2pLinkNegoInit(&g_testP2pLinkNegoCb);
568 ASSERT_EQ(ret, SOFTBUS_OK);
569 P2pLinkNegoStop();
570
571 P2pLinkFsmTransactState(nullptr, testState);
572 P2pLinkFsmTransactState(testFsm, nullptr);
573
574 testFsm->currentState = nullptr;
575 P2pLinkFsmTransactState(testFsm, testState);
576
577 SoftBusFree(testFsm);
578 SoftBusFree(testState);
579 }
580
581 /*
582 * @tc.name: P2pLinkFsmMsgProcTest001
583 * @tc.desc: some diff param in P2pLinkFsmMsgProc.
584 * @tc.type: FUNC
585 * @tc.require:
586 */
587 HWTEST_F(ConnectionP2PFuncTest, P2pLinkFsmMsgProcTest001, TestSize.Level1)
588 {
589 FsmStateMachine *testFsm = (FsmStateMachine *)SoftBusCalloc(sizeof(FsmStateMachine));
590 ASSERT_TRUE(testFsm != nullptr);
591
592 P2pLoopMsg testMsgType = WAIT_CONN_TIME_OUT;
593 int32_t ret = P2pLinkManagerInit();
594 ASSERT_EQ(ret, SOFTBUS_OK);
595 testFsm->currentState = nullptr;
596 P2pLinkFsmMsgProc(testFsm, testMsgType, nullptr);
597
598 SoftBusFree(testFsm);
599 }
600 } // namespace OHOS