1 /*
2  * Copyright (c) 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 #include <gtest/gtest.h>
16 #include "securec.h"
17 
18 #include "softbus_errcode.h"
19 #include "trans_auth_message.h"
20 #include "trans_tcp_direct_callback.h"
21 #include "trans_tcp_direct_p2p.h"
22 #include "trans_tcp_direct_p2p.c"
23 #include "trans_tcp_direct_p2p_test_mock.h"
24 #include "trans_tcp_direct_sessionconn.h"
25 
26 using namespace testing;
27 using namespace testing::ext;
28 
29 #define TEST_CHANNEL_ID 1
30 #define TEST_MODULE 20
31 #define TEST_PORT 43526
32 #define TEST_SEQ 123
33 #define TEST_LEN 20
34 #define TEST_FD 5
35 #define TEST_AUTHID 947251635
36 #define TEST_PID 2048
37 #define TEST_UID 4096
38 #define TEST_AUTO_CLOSE_TIME 5
39 #define INVALID_VALUE (-1)
40 #define TEST_REQ_ID 1234
41 #define INVALID_AUTH_LINK_TYPE 10
42 #define PKG_NAME_SIZE_MAX_LEN 65
43 #define P2P_PORT "P2P_PORT"
44 #define P2P_IP "P2P_IP"
45 #define ERR_CODE "ERR_CODE"
46 static const char *IP = "192.168.8.1";
47 static const char *MY_IP = "192.168.8.13";
48 static const char *DATA = "test_send_data";
49 static const char *SESSION_NAME = "com.test.trans.auth.demo";
50 static const char *PKGE_NAME = "dms";
51 static const char *TEST_SESSION_KEY = "Test_OpenHarmony";
52 static const char *TEST_GROUP_ID = "Test_Group_Id";
53 static const char *TEST_UDID = "ABCDEF00ABCDEF00ABCDEF00ABCDEF00ABCDEF00ABCDEF00ABCDEF00ABCDEF00";
54 
55 namespace OHOS {
56 
57 class TransTcpDirectP2pMockTest : public testing::Test {
58 public:
TransTcpDirectP2pMockTest()59     TransTcpDirectP2pMockTest()
60     {}
~TransTcpDirectP2pMockTest()61     ~TransTcpDirectP2pMockTest()
62     {}
63     static void SetUpTestCase(void);
64     static void TearDownTestCase(void);
SetUp()65     void SetUp() override
66     {}
TearDown()67     void TearDown() override
68     {}
69 };
70 
SetUpTestCase(void)71 void TransTcpDirectP2pMockTest::SetUpTestCase(void)
72 {
73     // will free in TearDownTestCase
74     SoftBusList *list = (SoftBusList *)SoftBusCalloc(sizeof(SoftBusList));
75     ASSERT_TRUE(list != nullptr);
76     SoftBusMutexInit(&list->lock, nullptr);
77     ListInit(&list->list);
78     NiceMock<TransTcpDirectP2pInterfaceMock> TcpP2pDirectMock;
79     EXPECT_CALL(TcpP2pDirectMock, CreateSoftBusList).WillOnce(Return(nullptr));
80     int32_t ret = CreatHmlListenerList();
81     EXPECT_EQ(SOFTBUS_MALLOC_ERR, ret);
82     EXPECT_CALL(TcpP2pDirectMock, CreateSoftBusList).WillOnce(Return(list));
83     EXPECT_CALL(TcpP2pDirectMock, RegAuthTransListener).WillOnce(Return(SOFTBUS_OK));
84     EXPECT_CALL(TcpP2pDirectMock, TransProxyPipelineRegisterListener).WillOnce(Return(SOFTBUS_OK));
85     ret = P2pDirectChannelInit();
86     EXPECT_EQ(SOFTBUS_OK, ret);
87     // will free in TearDownTestCase
88     SoftBusList *SessionList = (SoftBusList *)SoftBusCalloc(sizeof(SoftBusList));
89     ASSERT_TRUE(SessionList != nullptr);
90     SoftBusMutexInit(&SessionList->lock, nullptr);
91     ListInit(&SessionList->list);
92     EXPECT_CALL(TcpP2pDirectMock, CreateSoftBusList).WillOnce(Return(SessionList));
93     ret = TransSrvDataListInit();
94     EXPECT_EQ(SOFTBUS_OK, ret);
95 }
96 
TearDownTestCase(void)97 void TransTcpDirectP2pMockTest::TearDownTestCase(void)
98 {
99     TransSrvDataListDeinit();
100     SoftBusList *list = GetSessionConnList();
101     DestroySoftBusList(list);
102     list = nullptr;
103 }
104 
TestSetSessionConn()105 SessionConn *TestSetSessionConn()
106 {
107     SessionConn *testConn = (SessionConn*)SoftBusCalloc(sizeof(SessionConn));
108     if (testConn == nullptr) {
109         return nullptr;
110     }
111     testConn->serverSide = true;
112     testConn->appInfo.fd = TEST_FD;
113     testConn->appInfo.myHandleId = TEST_AUTHID;
114     testConn->appInfo.peerHandleId = TEST_AUTHID;
115     testConn->appInfo.peerData.uid = TEST_UID;
116     testConn->appInfo.peerData.pid = TEST_PID;
117     testConn->appInfo.businessType = BUSINESS_TYPE_MESSAGE;
118     testConn->appInfo.autoCloseTime = TEST_AUTO_CLOSE_TIME;
119     testConn->appInfo.peerData.port = TEST_PORT;
120     testConn->appInfo.myData.dataConfig = 1;
121     testConn->appInfo.fastTransDataSize = TEST_LEN;
122     testConn->channelId = TEST_CHANNEL_ID;
123     testConn->status = TCP_DIRECT_CHANNEL_STATUS_VERIFY_P2P;
124     testConn->timeout = 0;
125     testConn->req = TEST_SEQ;
126     testConn->authHandle.authId = 1;
127     testConn->appInfo.callingTokenId = 1;
128     testConn->requestId = TEST_REQ_ID;
129     testConn->listenMod = DIRECT_CHANNEL_SERVER_WIFI;
130     testConn->appInfo.myData.pid = 1;
131     testConn->appInfo.peerData.dataConfig = 0;
132     testConn->appInfo.linkType = 1;
133     testConn->appInfo.routeType = WIFI_P2P;
134     testConn->appInfo.peerData.channelId = TEST_CHANNEL_ID;
135     testConn->authHandle.type = AUTH_LINK_TYPE_WIFI;
136     (void)memcpy_s(testConn->appInfo.myData.sessionName, SESSION_NAME_SIZE_MAX,
137         SESSION_NAME, (strlen(SESSION_NAME) + 1));
138     (void)memcpy_s(testConn->appInfo.myData.pkgName, PKG_NAME_SIZE_MAX_LEN, PKGE_NAME, (strlen(PKGE_NAME) + 1));
139     (void)memcpy_s(testConn->appInfo.peerData.sessionName,
140         SESSION_NAME_SIZE_MAX, SESSION_NAME, (strlen(SESSION_NAME) + 1));
141     (void)memcpy_s(testConn->appInfo.sessionKey, SESSION_KEY_LENGTH, TEST_SESSION_KEY, (strlen(TEST_SESSION_KEY) + 1));
142     (void)memcpy_s(testConn->appInfo.groupId, GROUP_ID_SIZE_MAX, TEST_GROUP_ID, (strlen(TEST_GROUP_ID) + 1));
143     (void)memcpy_s(testConn->appInfo.peerData.addr, IP_LEN, IP, (strlen(IP) + 1));
144     return testConn;
145 }
146 
TestTransCreateJson(void)147 static cJSON *TestTransCreateJson(void)
148 {
149     cJSON *json = cJSON_CreateObject();
150     if (json == nullptr) {
151         std::cout << "create json fail" << std::endl;
152         return nullptr;
153     }
154     if (!AddNumberToJsonObject(json, P2P_PORT, TEST_PORT)) {
155         std::cout << "add P2p port failed" << std::endl;
156         cJSON_Delete(json);
157         return nullptr;
158     }
159     if (!AddStringToJsonObject(json, P2P_IP, IP)) {
160         std::cout << "add P2p port failed" << std::endl;
161         cJSON_Delete(json);
162         return nullptr;
163     }
164     return json;
165 }
166 
167 /**
168  * @tc.name: StartNewP2pListenerTest001
169  * @tc.desc: Should return SOFTBUS_OK when given valid param.
170  * @tc.type: FUNC
171  * @tc.require:
172  */
173 HWTEST_F(TransTcpDirectP2pMockTest, StartNewP2pListenerTest001, TestSize.Level1)
174 {
175     int32_t port = TEST_PORT;
176     NiceMock<TransTcpDirectP2pInterfaceMock> TcpP2pDirectMock;
177     EXPECT_CALL(TcpP2pDirectMock, TransTdcStartSessionListener).WillOnce(Return(port));
178     int32_t ret = StartNewP2pListener(IP, &port);
179     EXPECT_EQ(SOFTBUS_OK, ret);
180     EXPECT_CALL(TcpP2pDirectMock, StopBaseListener).WillOnce(Return(SOFTBUS_INVALID_PARAM));
181     StopP2pSessionListener();
182     EXPECT_CALL(TcpP2pDirectMock, TransTdcStartSessionListener).WillOnce(Return(port));
183     ret = StartNewP2pListener(IP, &port);
184     EXPECT_EQ(SOFTBUS_OK, ret);
185     EXPECT_CALL(TcpP2pDirectMock, StopBaseListener).WillOnce(Return(SOFTBUS_OK));
186     StopP2pSessionListener();
187 }
188 
189 /**
190  * @tc.name: StartNewHmlListenerTest001
191  * @tc.desc: Should return SOFTBUS_OK when given valid param..
192  * @tc.type: FUNC
193  * @tc.require:
194  */
195 HWTEST_F(TransTcpDirectP2pMockTest, StartNewHmlListenerTest001, TestSize.Level1)
196 {
197     ListenerModule moudleType;
198     int32_t port = TEST_PORT;
199     NiceMock<TransTcpDirectP2pInterfaceMock> TcpP2pDirectMock;
200     EXPECT_CALL(TcpP2pDirectMock, TransTdcStartSessionListener).WillOnce(Return(port));
201     int32_t ret = StartNewHmlListener(IP, &port, &moudleType);
202     EXPECT_EQ(SOFTBUS_OK, ret);
203 }
204 
205 /**
206  * @tc.name: StartHmlListenerTest001
207  * @tc.desc: Should return SOFTBUS_OK when given valid param.
208  * @tc.type: FUNC
209  * @tc.require:
210  */
211 HWTEST_F(TransTcpDirectP2pMockTest, StartHmlListenerTest001, TestSize.Level1)
212 {
213     ListenerModule moudleType = DIRECT_CHANNEL_SERVER_HML_START;
214     int32_t port = TEST_PORT;
215     NiceMock<TransTcpDirectP2pInterfaceMock> TcpP2pDirectMock;
216     EXPECT_CALL(TcpP2pDirectMock, TransTdcStartSessionListener).WillOnce(Return(port));
217     int32_t ret = StartHmlListener(IP, &port, TEST_UDID);
218     EXPECT_EQ(SOFTBUS_OK, ret);
219     ret = StartHmlListener(IP, &port, TEST_UDID);
220     EXPECT_EQ(SOFTBUS_OK, ret);
221     EXPECT_CALL(TcpP2pDirectMock, StopBaseListener).WillOnce(Return(SOFTBUS_INVALID_PARAM));
222     StopHmlListener(moudleType);
223     EXPECT_CALL(TcpP2pDirectMock, StopBaseListener).WillOnce(Return(SOFTBUS_OK));
224     StopHmlListener(moudleType);
225 }
226 
227 /**
228  * @tc.name: GetModuleByHmlIpTest001
229  * @tc.desc: Should return SOFTBUS_OK when given valid param.
230  * @tc.type: FUNC
231  * @tc.require:
232  */
233 HWTEST_F(TransTcpDirectP2pMockTest, GetModuleByHmlIpTest001, TestSize.Level1)
234 {
235     ListenerModule moudleType = DIRECT_CHANNEL_SERVER_HML_START;
236     int32_t port = TEST_PORT;
237     NiceMock<TransTcpDirectP2pInterfaceMock> TcpP2pDirectMock;
238     EXPECT_CALL(TcpP2pDirectMock, TransTdcStartSessionListener).WillOnce(Return(port));
239     int32_t ret = StartHmlListener(IP, &port, TEST_UDID);
240     EXPECT_EQ(SOFTBUS_OK, ret);
241     moudleType = GetModuleByHmlIp(IP);
242     EXPECT_EQ(DIRECT_CHANNEL_SERVER_HML_START, moudleType);
243     EXPECT_CALL(TcpP2pDirectMock, StopBaseListener).WillOnce(Return(SOFTBUS_OK));
244     StopHmlListener(moudleType);
245     ClearHmlListenerByUuid(nullptr);
246     ClearHmlListenerByUuid(TEST_UDID);
247 }
248 
249 /**
250  * @tc.name: SendAuthDataTest001
251  * @tc.desc: Should return SOFTBUS_OK when SendAuthData return SOFTBUS_OK.
252  * @tc.desc: Should return SOFTBUS_INVALID_PARAM when AuthPostTransData return SOFTBUS_INVALID_PARAM.
253  * @tc.type: FUNC
254  * @tc.require:
255  */
256 HWTEST_F(TransTcpDirectP2pMockTest, SendAuthDataTest001, TestSize.Level1)
257 {
258     AuthHandle authHandle = { .authId = 1, .type = AUTH_LINK_TYPE_WIFI };
259     int32_t module = TEST_MODULE;
260     int32_t flag = 1;
261     int64_t seq = TEST_SEQ;
262     NiceMock<TransTcpDirectP2pInterfaceMock> TcpP2pDirectMock;
263     EXPECT_CALL(TcpP2pDirectMock, AuthPostTransData).WillOnce(Return(SOFTBUS_INVALID_PARAM));
264     int32_t ret = SendAuthData(authHandle, module, flag, seq, DATA);
265     EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
266     EXPECT_CALL(TcpP2pDirectMock, AuthPostTransData).WillOnce(Return(SOFTBUS_OK));
267     ret = SendAuthData(authHandle, module, flag, seq, DATA);
268     EXPECT_EQ(SOFTBUS_OK, ret);
269 }
270 
271 /**
272  * @tc.name: VerifyP2pTest001
273  * @tc.desc: Should return SOFTBUS_PARSE_JSON_ERR when VerifyP2pPack return nullptr.
274  * @tc.desc: Should return SOFTBUS_INVALID_PARAM when AuthPostTransData return SOFTBUS_INVALID_PARAM.
275  * @tc.type: FUNC
276  * @tc.require:
277  */
278 HWTEST_F(TransTcpDirectP2pMockTest, VerifyP2pTest001, TestSize.Level1)
279 {
280     AuthHandle authHandle = { .authId = 1, .type = AUTH_LINK_TYPE_WIFI };
281     int64_t seq = TEST_SEQ;
282     int32_t port = TEST_PORT;
283     // will free in VerifyP2p
284     char *data = static_cast<char *>(SoftBusCalloc(TEST_LEN));
285     ASSERT_TRUE(data != nullptr);
286     (void)memcpy_s(data, TEST_LEN, DATA, TEST_LEN);
287     NiceMock<TransTcpDirectP2pInterfaceMock> TcpP2pDirectMock;
288     EXPECT_CALL(TcpP2pDirectMock, VerifyP2pPack).WillOnce(Return(nullptr));
289     int32_t ret = VerifyP2p(authHandle, IP, IP, port, seq);
290     EXPECT_EQ(SOFTBUS_PARSE_JSON_ERR, ret);
291     EXPECT_CALL(TcpP2pDirectMock, VerifyP2pPack).WillOnce(Return(data));
292     EXPECT_CALL(TcpP2pDirectMock, AuthPostTransData).WillOnce(Return(SOFTBUS_INVALID_PARAM));
293     ret = VerifyP2p(authHandle, IP, IP, port, seq);
294     EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
295     // will free in VerifyP2p
296     char *testData = static_cast<char *>(SoftBusCalloc(TEST_LEN));
297     ASSERT_TRUE(testData != nullptr);
298     (void)memcpy_s(testData, TEST_LEN, DATA, TEST_LEN);
299     EXPECT_CALL(TcpP2pDirectMock, VerifyP2pPack).WillOnce(Return(testData));
300     EXPECT_CALL(TcpP2pDirectMock, AuthPostTransData).WillOnce(Return(SOFTBUS_OK));
301     ret = VerifyP2p(authHandle, IP, IP, port, seq);
302     EXPECT_EQ(SOFTBUS_OK, ret);
303 }
304 
305 /**
306  * @tc.name: OnAuthConnOpenedTest001
307  * @tc.desc: Test OnAuthConnOpened.
308  * @tc.type: FUNC
309  * @tc.require:
310  */
311 HWTEST_F(TransTcpDirectP2pMockTest, OnAuthConnOpenedTest001, TestSize.Level1)
312 {
313     uint32_t requestId = TEST_REQ_ID;
314     AuthHandle authHandle = { .authId = 1, .type = 0 };
315     int32_t reason = SOFTBUS_TRANS_OPEN_AUTH_CONN_FAILED;
316     OnAuthConnOpened(requestId, authHandle);
317     authHandle.type = INVALID_AUTH_LINK_TYPE;
318     OnAuthConnOpened(requestId, authHandle);
319     authHandle.type = AUTH_LINK_TYPE_WIFI;
320     OnAuthConnOpened(requestId, authHandle);
321     OnAuthConnOpenFailed(requestId, reason);
322     // will free in OnAuthConnOpened--VerifyP2p
323     char *data = static_cast<char *>(SoftBusCalloc(TEST_LEN));
324     ASSERT_TRUE(data != nullptr);
325     (void)memcpy_s(data, TEST_LEN, DATA, TEST_LEN);
326 
327     // will free in TearDownTestCase--GetSessionConnList--DestroySoftBusList
328     SoftBusList *SessionList = (SoftBusList *)SoftBusCalloc(sizeof(SoftBusList));
329     ASSERT_TRUE(SessionList != nullptr);
330     SoftBusMutexInit(&SessionList->lock, nullptr);
331     ListInit(&SessionList->list);
332     NiceMock<TransTcpDirectP2pInterfaceMock> TcpP2pDirectMock;
333     EXPECT_CALL(TcpP2pDirectMock, CreateSoftBusList).WillOnce(Return(SessionList));
334     int32_t ret = CreatSessionConnList();
335     EXPECT_EQ(SOFTBUS_OK, ret);
336     OnAuthConnOpened(requestId, authHandle);
337     OnAuthConnOpenFailed(requestId, reason);
338     // will free in OnAuthConnOpened--OnChannelOpenFail--TransDelSessionConnById
339     SessionConn *conn = TestSetSessionConn();
340     ASSERT_TRUE(conn != nullptr);
341     ret = TransTdcAddSessionConn(conn);
342     EXPECT_EQ(SOFTBUS_OK, ret);
343 
344     EXPECT_CALL(TcpP2pDirectMock, NotifyChannelOpenFailed).WillRepeatedly(Return(SOFTBUS_OK));
345     OnAuthConnOpenFailed(requestId, reason);
346 
347     // will free in OnAuthConnOpened--OnChannelOpenFail--TransDelSessionConnById
348     SessionConn *testConn = TestSetSessionConn();
349     ASSERT_TRUE(testConn != nullptr);
350     ret = TransTdcAddSessionConn(testConn);
351     EXPECT_EQ(SOFTBUS_OK, ret);
352     EXPECT_CALL(TcpP2pDirectMock, VerifyP2pPack).WillOnce(Return(data));
353     EXPECT_CALL(TcpP2pDirectMock, AuthPostTransData).WillOnce(Return(SOFTBUS_OK));
354     EXPECT_CALL(TcpP2pDirectMock, NotifyChannelOpenFailed).WillRepeatedly(Return(SOFTBUS_OK));
355     OnAuthConnOpened(requestId, authHandle);
356 
357 
358     EXPECT_CALL(TcpP2pDirectMock, VerifyP2pPack).WillOnce(Return(nullptr));
359     OnAuthConnOpened(requestId, authHandle);
360 }
361 
362 /**
363  * @tc.name: OpenAuthConnTest001
364  * @tc.desc: Should return SOFTBUS_TRANS_OPEN_AUTH_CONN_FAILED when AuthOpenConn return error.
365  * @tc.desc: Should return SOFTBUS_OK when AuthOpenConn return SOFTBUS_OK.
366  * @tc.type: FUNC
367  * @tc.require:
368  */
369 HWTEST_F(TransTcpDirectP2pMockTest, OpenAuthConnTest001, TestSize.Level1)
370 {
371     uint32_t reqId = TEST_REQ_ID;
372     bool isMeta = false;
373     ConnectType type = CONNECT_HML;
374     NiceMock<TransTcpDirectP2pInterfaceMock> TcpP2pDirectMock;
375     EXPECT_CALL(TcpP2pDirectMock, AuthGetHmlConnInfo).WillOnce(Return(SOFTBUS_OK));
376     EXPECT_CALL(TcpP2pDirectMock, AuthOpenConn).WillOnce(Return(SOFTBUS_OK));
377     int32_t ret = OpenAuthConn(IP, reqId, isMeta, type);
378     EXPECT_EQ(SOFTBUS_OK, ret);
379     EXPECT_CALL(TcpP2pDirectMock, AuthGetHmlConnInfo).WillOnce(Return(SOFTBUS_INVALID_PARAM));
380     EXPECT_CALL(TcpP2pDirectMock, AuthGetPreferConnInfo).WillOnce(Return(SOFTBUS_OK));
381     EXPECT_CALL(TcpP2pDirectMock, AuthOpenConn).WillOnce(Return(SOFTBUS_OK));
382     ret = OpenAuthConn(IP, reqId, isMeta, type);
383     EXPECT_EQ(SOFTBUS_OK, ret);
384     type = CONNECT_P2P;
385     EXPECT_CALL(TcpP2pDirectMock, AuthGetP2pConnInfo).WillOnce(Return(SOFTBUS_OK));
386     EXPECT_CALL(TcpP2pDirectMock, AuthOpenConn).WillOnce(Return(SOFTBUS_INVALID_PARAM));
387     ret = OpenAuthConn(IP, reqId, isMeta, type);
388     EXPECT_EQ(SOFTBUS_TRANS_OPEN_AUTH_CONN_FAILED, ret);
389 }
390 
391 /**
392  * @tc.name: PackAndSendVerifyP2pRspTest001
393  * @tc.desc: Should return SOFTBUS_PARSE_JSON_ERR when VerifyP2pPack return nullptr.
394  * @tc.type: FUNC
395  * @tc.require:
396  */
397 HWTEST_F(TransTcpDirectP2pMockTest, PackAndSendVerifyP2pRspTest001, TestSize.Level1)
398 {
399     AuthHandle authHandle = { .authId = 1, .type = 0 };
400     int64_t seq = TEST_SEQ;
401     int32_t port = TEST_PORT;
402     bool isAuthLink = false;
403     // will free in PackAndSendVerifyP2pRsp
404     char *data = static_cast<char *>(SoftBusCalloc(TEST_LEN));
405     ASSERT_TRUE(data != nullptr);
406     (void)memcpy_s(data, TEST_LEN, DATA, TEST_LEN);
407 
408     NiceMock<TransTcpDirectP2pInterfaceMock> TcpP2pDirectMock;
409     EXPECT_CALL(TcpP2pDirectMock, VerifyP2pPack).WillOnce(Return(nullptr));
410     EXPECT_CALL(TcpP2pDirectMock, VerifyP2pPackError).WillOnce(Return(data));
411     EXPECT_CALL(TcpP2pDirectMock, TransProxyPipelineSendMessage).WillOnce(Return(SOFTBUS_NOT_FIND));
412     int32_t ret = PackAndSendVerifyP2pRsp(IP, port, seq, isAuthLink, authHandle);
413     EXPECT_EQ(SOFTBUS_PARSE_JSON_ERR, ret);
414 
415     isAuthLink = true;
416     char *testData = static_cast<char *>(SoftBusCalloc(TEST_LEN));
417     ASSERT_TRUE(testData != nullptr);
418     (void)memcpy_s(testData, TEST_LEN, DATA, TEST_LEN);
419     EXPECT_CALL(TcpP2pDirectMock, VerifyP2pPack).WillOnce(Return(nullptr));
420     EXPECT_CALL(TcpP2pDirectMock, VerifyP2pPackError).WillOnce(Return(testData));
421     EXPECT_CALL(TcpP2pDirectMock, AuthPostTransData).WillOnce(Return(SOFTBUS_OK));
422     ret = PackAndSendVerifyP2pRsp(IP, port, seq, isAuthLink, authHandle);
423     EXPECT_EQ(SOFTBUS_PARSE_JSON_ERR, ret);
424 }
425 
426 /**
427  * @tc.name: PackAndSendVerifyP2pRspTest002
428  * @tc.desc: Should return SOFTBUS_OK when AuthPostTransData return SOFTBUS_OK.
429  * @tc.desc: Should return SOFTBUS_NOT_FIND when TransProxyPipelineSendMessage return SOFTBUS_NOT_FIND.
430  * @tc.type: FUNC
431  * @tc.require:
432  */
433 HWTEST_F(TransTcpDirectP2pMockTest, PackAndSendVerifyP2pRspTest002, TestSize.Level1)
434 {
435     AuthHandle authHandle = { .authId = 1, .type = 0 };
436     int64_t seq = TEST_SEQ;
437     int32_t port = TEST_PORT;
438     bool isAuthLink = false;
439     // will free in PackAndSendVerifyP2pRsp
440     char *data = static_cast<char *>(SoftBusCalloc(TEST_LEN));
441     ASSERT_TRUE(data != nullptr);
442     (void)memcpy_s(data, TEST_LEN, DATA, TEST_LEN);
443     char *newData = static_cast<char *>(SoftBusCalloc(TEST_LEN));
444     ASSERT_TRUE(newData != nullptr);
445     (void)memcpy_s(data, TEST_LEN, DATA, TEST_LEN);
446 
447     NiceMock<TransTcpDirectP2pInterfaceMock> TcpP2pDirectMock;
448     EXPECT_CALL(TcpP2pDirectMock, VerifyP2pPack).WillOnce(Return(data));
449     EXPECT_CALL(TcpP2pDirectMock, TransProxyPipelineSendMessage).WillOnce(Return(SOFTBUS_NOT_FIND));
450     int32_t ret = PackAndSendVerifyP2pRsp(IP, port, seq, isAuthLink, authHandle);
451     EXPECT_EQ(SOFTBUS_NOT_FIND, ret);
452 
453     isAuthLink = true;
454     EXPECT_CALL(TcpP2pDirectMock, VerifyP2pPack).WillOnce(Return(newData));
455     EXPECT_CALL(TcpP2pDirectMock, AuthPostTransData).WillOnce(Return(SOFTBUS_OK));
456     ret = PackAndSendVerifyP2pRsp(IP, port, seq, isAuthLink, authHandle);
457     EXPECT_EQ(SOFTBUS_OK, ret);
458 }
459 
460 /**
461  * @tc.name: OnVerifyP2pRequestTest001
462  * @tc.desc: Should return SOFTBUS_TRANS_GET_P2P_INFO_FAILED when TransProxyPipelineSendMessage return error.
463  * @tc.type: FUNC
464  * @tc.require:
465  */
466 HWTEST_F(TransTcpDirectP2pMockTest, OnVerifyP2pRequestTest001, TestSize.Level1)
467 {
468     AuthHandle authHandle = { .authId = 1, .type = 0 };
469     int64_t seq = TEST_SEQ;
470     bool isAuthLink = false;
471     cJSON *json = TestTransCreateJson();
472     ASSERT_TRUE(json != nullptr);
473     // will free in VerifyP2pPackError
474     char *data = static_cast<char *>(SoftBusCalloc(TEST_LEN));
475     ASSERT_TRUE(data != nullptr);
476     (void)memcpy_s(data, TEST_LEN, DATA, TEST_LEN);
477 
478     NiceMock<TransTcpDirectP2pInterfaceMock> TcpP2pDirectMock;
479     EXPECT_CALL(TcpP2pDirectMock, VerifyP2pPackError).WillOnce(Return(data));
480     EXPECT_CALL(TcpP2pDirectMock, TransProxyPipelineSendMessage).WillOnce(Return(SOFTBUS_NOT_FIND));
481     int32_t ret = OnVerifyP2pRequest(authHandle, seq, json, isAuthLink);
482     EXPECT_EQ(SOFTBUS_TRANS_GET_P2P_INFO_FAILED, ret);
483 
484     cJSON_Delete(json);
485 }
486 
487 /**
488  * @tc.name: ConnectTcpDirectPeerTest001
489  * @tc.desc: Should return SOFTBUS_OK when ConnOpenClientSocket return SOFTBUS_OK.
490  * @tc.desc: Should return error when ConnOpenClientSocket return SOFTBUS_OK.
491  * @tc.type: FUNC
492  * @tc.require:
493  */
494 HWTEST_F(TransTcpDirectP2pMockTest, ConnectTcpDirectPeerTest001, TestSize.Level1)
495 {
496     NiceMock<TransTcpDirectP2pInterfaceMock> TcpP2pDirectMock;
497     EXPECT_CALL(TcpP2pDirectMock, IsHmlIpAddr).WillOnce(Return(false));
498     EXPECT_CALL(TcpP2pDirectMock, ConnOpenClientSocket).WillOnce(Return(SOFTBUS_NO_INIT));
499     int32_t ret = ConnectTcpDirectPeer(IP, TEST_PORT, MY_IP);
500     EXPECT_EQ(SOFTBUS_NO_INIT, ret);
501     EXPECT_CALL(TcpP2pDirectMock, IsHmlIpAddr).WillOnce(Return(true));
502     EXPECT_CALL(TcpP2pDirectMock, ConnOpenClientSocket).WillOnce(Return(SOFTBUS_OK));
503     ret = ConnectTcpDirectPeer(IP, TEST_PORT, MY_IP);
504     EXPECT_EQ(SOFTBUS_OK, ret);
505 }
506 
507 /**
508  * @tc.name: AddHmlTriggerTest001
509  * @tc.desc: Should return SOFTBUS_OK when ConnOpenClientSocket return SOFTBUS_OK.
510  * @tc.desc: Should return error when ConnOpenClientSocket return SOFTBUS_OK.
511  * @tc.type: FUNC
512  * @tc.require:
513  */
514 HWTEST_F(TransTcpDirectP2pMockTest, AddHmlTriggerTest001, TestSize.Level1)
515 {
516     int32_t port = TEST_PORT;
517     int32_t fd = TEST_FD;
518     int64_t seq = TEST_SEQ;
519     int32_t ret = AddHmlTrigger(fd, IP, seq);
520     EXPECT_EQ(SOFTBUS_TRANS_ADD_HML_TRIGGER_FAILED, ret);
521     NiceMock<TransTcpDirectP2pInterfaceMock> TcpP2pDirectMock;
522     EXPECT_CALL(TcpP2pDirectMock, TransTdcStartSessionListener).WillOnce(Return(port));
523     ret = StartHmlListener(IP, &port, TEST_UDID);
524     EXPECT_EQ(SOFTBUS_OK, ret);
525     EXPECT_CALL(TcpP2pDirectMock, AddTrigger).WillOnce(Return(SOFTBUS_NO_INIT));
526     ret = AddHmlTrigger(fd, IP, seq);
527     EXPECT_EQ(SOFTBUS_NO_INIT, ret);
528 
529     EXPECT_CALL(TcpP2pDirectMock, AddTrigger).WillOnce(Return(SOFTBUS_OK));
530     ret = AddHmlTrigger(fd, IP, seq);
531     EXPECT_EQ(SOFTBUS_NOT_FIND, ret);
532 
533     SessionConn *conn = TestSetSessionConn();
534     ASSERT_TRUE(conn != nullptr);
535     ret = TransTdcAddSessionConn(conn);
536     EXPECT_EQ(SOFTBUS_OK, ret);
537 
538     EXPECT_CALL(TcpP2pDirectMock, AddTrigger).WillOnce(Return(SOFTBUS_OK));
539     ret = AddHmlTrigger(fd, IP, seq);
540     EXPECT_EQ(SOFTBUS_OK, ret);
541     TransDelSessionConnById(conn->channelId);
542 }
543 
544 /**
545  * @tc.name: AddP2pOrHmlTriggerTest001
546  * @tc.desc: Should return SOFTBUS_OK when AddTrigger return SOFTBUS_OK.
547  * @tc.type: FUNC
548  * @tc.require:
549  */
550 HWTEST_F(TransTcpDirectP2pMockTest, AddP2pOrHmlTriggerTest001, TestSize.Level1)
551 {
552     int32_t fd = TEST_FD;
553     int64_t seq = TEST_SEQ;
554     NiceMock<TransTcpDirectP2pInterfaceMock> TcpP2pDirectMock;
555     EXPECT_CALL(TcpP2pDirectMock, IsHmlIpAddr).WillOnce(Return(false));
556     EXPECT_CALL(TcpP2pDirectMock, AddTrigger).WillOnce(Return(SOFTBUS_OK));
557     int32_t ret = AddP2pOrHmlTrigger(fd, IP, seq);
558     EXPECT_EQ(SOFTBUS_OK, ret);
559 }
560 
561 /**
562  * @tc.name: OnVerifyP2pReplyTest001
563  * @tc.desc: Should return SOFTBUS_OK when AddTrigger return SOFTBUS_OK.
564  * @tc.type: FUNC
565  * @tc.require:
566  */
567 HWTEST_F(TransTcpDirectP2pMockTest, OnVerifyP2pReplyTest001, TestSize.Level1)
568 {
569     int64_t authId = 1;
570     int64_t seq = TEST_SEQ;
571     cJSON *json = TestTransCreateJson();
572     ASSERT_TRUE(json != nullptr);
573     // will free in OnVerifyP2pReply---OnChannelOpenFail---TransDelSessionConnById
574     SessionConn *testConn = TestSetSessionConn();
575     ASSERT_TRUE(testConn != nullptr);
576     int32_t ret = TransTdcAddSessionConn(testConn);
577     EXPECT_EQ(SOFTBUS_OK, ret);
578     NiceMock<TransTcpDirectP2pInterfaceMock> TcpP2pDirectMock;
579     EXPECT_CALL(TcpP2pDirectMock, IsHmlIpAddr).WillRepeatedly(Return(true));
580     EXPECT_CALL(TcpP2pDirectMock, ConnOpenClientSocket).WillOnce(Return(SOFTBUS_NO_INIT));
581     EXPECT_CALL(TcpP2pDirectMock, NotifyChannelOpenFailed).WillRepeatedly(Return(SOFTBUS_NO_INIT));
582     ret = OnVerifyP2pReply(authId, seq, json);
583     EXPECT_EQ(SOFTBUS_TRANS_VERIFY_P2P_FAILED, ret);
584 
585     // will free in OnVerifyP2pReply---OnChannelOpenFail---TransDelSessionConnById
586     SessionConn *newConn = TestSetSessionConn();
587     ASSERT_TRUE(newConn != nullptr);
588     ret = TransTdcAddSessionConn(newConn);
589     EXPECT_EQ(SOFTBUS_OK, ret);
590     EXPECT_CALL(TcpP2pDirectMock, ConnOpenClientSocket).WillRepeatedly(Return(1));
591     EXPECT_CALL(TcpP2pDirectMock, TransSrvAddDataBufNode).WillOnce(Return(SOFTBUS_NO_INIT));
592     ret = OnVerifyP2pReply(authId, seq, json);
593     EXPECT_EQ(SOFTBUS_TRANS_VERIFY_P2P_FAILED, ret);
594 
595     // will free in OnVerifyP2pReply---OnChannelOpenFail---TransDelSessionConnById
596     SessionConn *conn = TestSetSessionConn();
597     ASSERT_TRUE(conn != nullptr);
598     ret = TransTdcAddSessionConn(conn);
599     EXPECT_EQ(SOFTBUS_OK, ret);
600     cJSON *testJson = cJSON_CreateObject();
601     ret = OnVerifyP2pReply(authId, seq, testJson);
602     EXPECT_EQ(SOFTBUS_TRANS_VERIFY_P2P_FAILED, ret);
603 
604     cJSON_Delete(json);
605     cJSON_Delete(testJson);
606 }
607 
608 /**
609  * @tc.name: OnVerifyP2pReplyTest002
610  * @tc.desc: Should return SOFTBUS_OK when AddTrigger return SOFTBUS_OK.
611  * @tc.type: FUNC
612  * @tc.require:
613  */
614 HWTEST_F(TransTcpDirectP2pMockTest, OnVerifyP2pReplyTest002, TestSize.Level1)
615 {
616     int64_t authId = 1;
617     int64_t seq = TEST_SEQ;
618     cJSON *json = TestTransCreateJson();
619     ASSERT_TRUE(json != nullptr);
620     // will free in OnVerifyP2pReply---OnChannelOpenFail---TransDelSessionConnById
621     SessionConn *NewConn = TestSetSessionConn();
622     ASSERT_TRUE(NewConn != nullptr);
623     int32_t ret = TransTdcAddSessionConn(NewConn);
624     EXPECT_EQ(SOFTBUS_OK, ret);
625     NiceMock<TransTcpDirectP2pInterfaceMock> TcpP2pDirectMock;
626     EXPECT_CALL(TcpP2pDirectMock, IsHmlIpAddr).WillRepeatedly(Return(false));
627     EXPECT_CALL(TcpP2pDirectMock, ConnOpenClientSocket).WillRepeatedly(Return(1));
628     EXPECT_CALL(TcpP2pDirectMock, TransSrvAddDataBufNode).WillRepeatedly(Return(SOFTBUS_OK));
629     EXPECT_CALL(TcpP2pDirectMock, IsHmlIpAddr).WillRepeatedly(Return(false));
630     EXPECT_CALL(TcpP2pDirectMock, AddTrigger).WillOnce(Return(SOFTBUS_NO_INIT));
631     EXPECT_CALL(TcpP2pDirectMock, NotifyChannelOpenFailed).WillRepeatedly(Return(SOFTBUS_NO_INIT));
632     ret = OnVerifyP2pReply(authId, seq, json);
633     EXPECT_EQ(SOFTBUS_TRANS_VERIFY_P2P_FAILED, ret);
634 
635     SessionConn *conn = TestSetSessionConn();
636     ASSERT_TRUE(conn != nullptr);
637     ret = TransTdcAddSessionConn(conn);
638     EXPECT_EQ(SOFTBUS_OK, ret);
639     EXPECT_CALL(TcpP2pDirectMock, AddTrigger).WillOnce(Return(SOFTBUS_OK));
640     ret = OnVerifyP2pReply(authId, seq, json);
641     EXPECT_EQ(SOFTBUS_OK, ret);
642     TransDelSessionConnById(conn->channelId);
643     cJSON_Delete(json);
644 }
645 
646 /**
647  * @tc.name: OnAuthDataRecvTest001
648  * @tc.desc: Test OnAuthDataRecv.
649  * @tc.type: FUNC
650  * @tc.require:
651  */
652 HWTEST_F(TransTcpDirectP2pMockTest, OnAuthDataRecvTest001, TestSize.Level1)
653 {
654     // will free in OnAuthDataRecv
655     cJSON *json = TestTransCreateJson();
656     ASSERT_TRUE(json != nullptr);
657     const char *str = "data";
658     AuthTransData *data = (AuthTransData*)SoftBusCalloc(sizeof(AuthTransData));
659     ASSERT_TRUE(data != nullptr);
660     data->module = MODULE_P2P_LINK;
661     data->flag = FLAG_REPLY;
662     data->seq = 1;
663     data->data = nullptr;
664     data->len = 0;
665     AuthHandle authHandle = { .authId = 1, .type = 0 };
666     OnAuthDataRecv(authHandle, nullptr);
667     OnAuthDataRecv(authHandle, data);
668     data->data = (const uint8_t *)str;
669     OnAuthDataRecv(authHandle, data);
670     data->len = TEST_LEN;
671     OnAuthDataRecv(authHandle, data);
672     authHandle.type = INVALID_AUTH_LINK_TYPE;
673     OnAuthDataRecv(authHandle, data);
674     authHandle.type = AUTH_LINK_TYPE_WIFI;
675     OnAuthDataRecv(authHandle, data);
676     data->module = MODULE_P2P_LISTEN;
677     NiceMock<TransTcpDirectP2pInterfaceMock> TcpP2pDirectMock;
678     EXPECT_CALL(TcpP2pDirectMock, cJSON_ParseWithLength).WillRepeatedly(Return(nullptr));
679     OnAuthDataRecv(authHandle, data);
680     EXPECT_CALL(TcpP2pDirectMock, cJSON_ParseWithLength).WillRepeatedly(Return(json));
681     OnAuthDataRecv(authHandle, data);
682 }
683 
684 /**
685  * @tc.name: OnAuthChannelCloseTest001
686  * @tc.desc: Should return SOFTBUS_OK when AddTrigger return SOFTBUS_OK.
687  * @tc.type: FUNC
688  * @tc.require:
689  */
690 HWTEST_F(TransTcpDirectP2pMockTest, OnAuthChannelCloseTest001, TestSize.Level1)
691 {
692     AuthHandle authHandle = { .authId = 1, .type = AUTH_LINK_TYPE_WIFI };
693     SessionConn *conn = TestSetSessionConn();
694     ASSERT_TRUE(conn != nullptr);
695     int32_t ret = TransTdcAddSessionConn(conn);
696     EXPECT_EQ(SOFTBUS_OK, ret);
697     NiceMock<TransTcpDirectP2pInterfaceMock> TcpP2pDirectMock;
698     EXPECT_CALL(TcpP2pDirectMock, NotifyChannelOpenFailed).WillRepeatedly(Return(SOFTBUS_NO_INIT));
699     OnAuthChannelClose(authHandle);
700     OnAuthChannelClose(authHandle);
701     TransDelSessionConnById(conn->channelId);
702 }
703 
704 /**
705  * @tc.name: OpenNewAuthConnTest001
706  * @tc.desc: Should return SOFTBUS_TRANS_OPEN_AUTH_CONN_FAILED when AuthOpenConn return error.
707  * @tc.desc: Should return SOFTBUS_OK when AuthOpenConn return SOFTBUS_OK.
708  * @tc.type: FUNC
709  * @tc.require:
710  */
711 HWTEST_F(TransTcpDirectP2pMockTest, OpenNewAuthConnTest001, TestSize.Level1)
712 {
713     int32_t newChannelId = TEST_CHANNEL_ID;
714     ConnectType type = CONNECT_HML;
715     SessionConn *conn = TestSetSessionConn();
716     ASSERT_TRUE(conn != nullptr);
717     AppInfo *appInfo = (AppInfo *)SoftBusCalloc(sizeof(AppInfo));
718     ASSERT_TRUE(appInfo != nullptr);
719     (void)memcpy_s(appInfo, sizeof(AppInfo), &conn->appInfo, sizeof(AppInfo));
720     NiceMock<TransTcpDirectP2pInterfaceMock> TcpP2pDirectMock;
721     EXPECT_CALL(TcpP2pDirectMock, AuthGetHmlConnInfo).WillOnce(Return(SOFTBUS_OK));
722     EXPECT_CALL(TcpP2pDirectMock, AuthOpenConn).WillOnce(Return(SOFTBUS_OK));
723     int32_t ret = OpenNewAuthConn(appInfo, conn, newChannelId, type);
724     EXPECT_EQ(SOFTBUS_OK, ret);
725     type = CONNECT_P2P;
726     EXPECT_CALL(TcpP2pDirectMock, AuthGetP2pConnInfo).WillOnce(Return(SOFTBUS_OK));
727     EXPECT_CALL(TcpP2pDirectMock, AuthOpenConn).WillOnce(Return(SOFTBUS_INVALID_PARAM));
728     ret = OpenNewAuthConn(appInfo, conn, newChannelId, type);
729     EXPECT_EQ(SOFTBUS_TRANS_OPEN_AUTH_CONN_FAILED, ret);
730     TransDelSessionConnById(conn->channelId);
731     SoftBusFree(appInfo);
732 }
733 
734 /**
735  * @tc.name: OnP2pVerifyMsgReceivedTest001
736  * @tc.desc: Test OnP2pVerifyMsgReceived
737  * @tc.type: FUNC
738  * @tc.require:
739  */
740 HWTEST_F(TransTcpDirectP2pMockTest, OnP2pVerifyMsgReceivedTest001, TestSize.Level1)
741 {
742     cJSON *json = cJSON_CreateObject();
743     ASSERT_TRUE(json != nullptr);
744     cJSON *testJson = cJSON_CreateObject();
745     ASSERT_TRUE(testJson != nullptr);
746     cJSON *newJson = cJSON_CreateObject();
747     ASSERT_TRUE(newJson != nullptr);
748     int64_t msgType = P2P_VERIFY_REQUEST;
749     char *data = reinterpret_cast<char *>(&msgType);
750     int32_t channelId = TEST_CHANNEL_ID;
751     uint32_t len = 1;
752     OnP2pVerifyMsgReceived(channelId, nullptr, len);
753     OnP2pVerifyMsgReceived(channelId, data, len);
754     len = TEST_LEN;
755     NiceMock<TransTcpDirectP2pInterfaceMock> TcpP2pDirectMock;
756     EXPECT_CALL(TcpP2pDirectMock, cJSON_ParseWithLength).WillRepeatedly(Return(nullptr));
757     OnP2pVerifyMsgReceived(channelId, data, len);
758     EXPECT_CALL(TcpP2pDirectMock, cJSON_ParseWithLength).WillRepeatedly(Return(json));
759     OnP2pVerifyMsgReceived(channelId, data, len);
760     msgType = P2P_VERIFY_REPLY;
761     data = reinterpret_cast<char *>(&msgType);
762     EXPECT_CALL(TcpP2pDirectMock, cJSON_ParseWithLength).WillRepeatedly(Return(testJson));
763     OnP2pVerifyMsgReceived(channelId, data, len);
764     msgType = INVALID_AUTH_LINK_TYPE;
765     data = reinterpret_cast<char *>(&msgType);
766     EXPECT_CALL(TcpP2pDirectMock, cJSON_ParseWithLength).WillRepeatedly(Return(newJson));
767     OnP2pVerifyMsgReceived(channelId, data, len);
768 }
769 
770 /**
771  * @tc.name: StartVerifyP2pInfoTest001
772  * @tc.desc: Test OnP2pVerifyMsgReceived when TransProxyPipelineGetChannelIdByNetworkId return INVALID_CHANNEL_ID
773  * @tc.type: FUNC
774  * @tc.require:
775  */
776 HWTEST_F(TransTcpDirectP2pMockTest, StartVerifyP2pInfoTest001, TestSize.Level1)
777 {
778     SessionConn *conn = TestSetSessionConn();
779     ASSERT_TRUE(conn != nullptr);
780     ConnectType type = CONNECT_HML;
781     AppInfo *appInfo = (AppInfo *)SoftBusCalloc(sizeof(AppInfo));
782     ASSERT_TRUE(appInfo != nullptr);
783     (void)memcpy_s(appInfo, sizeof(AppInfo), &conn->appInfo, sizeof(AppInfo));
784     uint32_t reqId = TEST_REQ_ID;
785     NiceMock<TransTcpDirectP2pInterfaceMock> TcpP2pDirectMock;
786     EXPECT_CALL(TcpP2pDirectMock, TransProxyPipelineGetChannelIdByNetworkId).
787         WillRepeatedly(Return(INVALID_CHANNEL_ID));
788     EXPECT_CALL(TcpP2pDirectMock, AuthGenRequestId).WillRepeatedly(Return(reqId));
789     EXPECT_CALL(TcpP2pDirectMock, AuthGetHmlConnInfo).WillRepeatedly(Return(SOFTBUS_OK));
790     EXPECT_CALL(TcpP2pDirectMock, AuthOpenConn).WillRepeatedly(Return(SOFTBUS_OK));
791     int32_t ret = StartVerifyP2pInfo(appInfo, conn, type);
792     EXPECT_EQ(SOFTBUS_OK, ret);
793     type = CONNECT_P2P_REUSE;
794     EXPECT_CALL(TcpP2pDirectMock, IsHmlIpAddr).WillRepeatedly(Return(true));
795     ret = StartVerifyP2pInfo(appInfo, conn, type);
796     EXPECT_EQ(SOFTBUS_OK, ret);
797     SoftBusFree(conn);
798     SoftBusFree(appInfo);
799 }
800 
801 /**
802  * @tc.name: StartVerifyP2pInfoTest002
803  * @tc.desc: Test OnP2pVerifyMsgReceived when TransProxyPipelineGetChannelIdByNetworkId return VALID_CHANNEL_ID
804  * @tc.type: FUNC
805  * @tc.require:
806  */
807 HWTEST_F(TransTcpDirectP2pMockTest, StartVerifyP2pInfoTest002, TestSize.Level1)
808 {
809     SessionConn *conn = TestSetSessionConn();
810     ASSERT_TRUE(conn != nullptr);
811     ConnectType type = CONNECT_HML;
812     AppInfo *appInfo = (AppInfo *)SoftBusCalloc(sizeof(AppInfo));
813     ASSERT_TRUE(appInfo != nullptr);
814     (void)memcpy_s(appInfo, sizeof(AppInfo), &conn->appInfo, sizeof(AppInfo));
815     NiceMock<TransTcpDirectP2pInterfaceMock> TcpP2pDirectMock;
816     EXPECT_CALL(TcpP2pDirectMock, TransProxyPipelineGetChannelIdByNetworkId).
817         WillRepeatedly(Return(TEST_CHANNEL_ID));
818     EXPECT_CALL(TcpP2pDirectMock, TransProxyReuseByChannelId).WillOnce(Return(SOFTBUS_NO_INIT));
819     int32_t ret = StartVerifyP2pInfo(appInfo, conn, type);
820     EXPECT_EQ(SOFTBUS_NO_INIT, ret);
821     EXPECT_CALL(TcpP2pDirectMock, TransProxyReuseByChannelId).WillRepeatedly(Return(SOFTBUS_OK));
822     EXPECT_CALL(TcpP2pDirectMock, TransProxyPipelineCloseChannelDelay).WillRepeatedly(Return(SOFTBUS_OK));
823     ret = StartVerifyP2pInfo(appInfo, conn, type);
824     EXPECT_EQ(SOFTBUS_TRANS_TCP_GET_AUTHID_FAILED, ret);
825     SoftBusFree(conn);
826     SoftBusFree(appInfo);
827 }
828 
829 /**
830  * @tc.name: CopyAppInfoFastTransDataTest001
831  * @tc.desc: Test OnP2pVerifyMsgReceived when TransProxyPipelineGetChannelIdByNetworkId return VALID_CHANNEL_ID
832  * @tc.type: FUNC
833  * @tc.require:
834  */
835 HWTEST_F(TransTcpDirectP2pMockTest, CopyAppInfoFastTransDataTest001, TestSize.Level1)
836 {
837     SessionConn *conn = TestSetSessionConn();
838     ASSERT_TRUE(conn != nullptr);
839     AppInfo *appInfo = (AppInfo *)SoftBusCalloc(sizeof(AppInfo));
840     ASSERT_TRUE(appInfo != nullptr);
841     (void)memcpy_s(appInfo, sizeof(AppInfo), &conn->appInfo, sizeof(AppInfo));
842     uint8_t *fastTransData = (uint8_t *)SoftBusCalloc(appInfo->fastTransDataSize);
843     ASSERT_TRUE(fastTransData != nullptr);
844     appInfo->fastTransData = nullptr;
845     FreeFastTransData(appInfo);
846     int32_t ret = CopyAppInfoFastTransData(conn, appInfo);
847     EXPECT_EQ(SOFTBUS_OK, ret);
848     appInfo->fastTransData = fastTransData;
849     ret = CopyAppInfoFastTransData(conn, appInfo);
850     EXPECT_EQ(SOFTBUS_OK, ret);
851     appInfo->fastTransDataSize = 0;
852     ret = CopyAppInfoFastTransData(conn, appInfo);
853     EXPECT_EQ(SOFTBUS_OK, ret);
854     FreeFastTransData(appInfo);
855     FreeFastTransData(nullptr);
856 
857     SoftBusFree(conn);
858     SoftBusFree(appInfo);
859 }
860 
861 /**
862  * @tc.name: BuildSessionConnTest001
863  * @tc.desc: Test OnP2pVerifyMsgReceived when TransProxyPipelineGetChannelIdByNetworkId return VALID_CHANNEL_ID
864  * @tc.type: FUNC
865  * @tc.require:
866  */
867 HWTEST_F(TransTcpDirectP2pMockTest, BuildSessionConnTest001, TestSize.Level1)
868 {
869     SessionConn *conn = TestSetSessionConn();
870     ASSERT_TRUE(conn != nullptr);
871     AppInfo *appInfo = (AppInfo *)SoftBusCalloc(sizeof(AppInfo));
872     ASSERT_TRUE(appInfo != nullptr);
873     (void)memcpy_s(appInfo, sizeof(AppInfo), &conn->appInfo, sizeof(AppInfo));
874     NiceMock<TransTcpDirectP2pInterfaceMock> TcpP2pDirectMock;
875     EXPECT_CALL(TcpP2pDirectMock, CreateNewSessinConn).WillOnce(Return(nullptr));
876     int32_t ret = BuildSessionConn(appInfo, &conn);
877     EXPECT_EQ(SOFTBUS_MEM_ERR, ret);
878     appInfo->fastTransData = nullptr;
879     EXPECT_CALL(TcpP2pDirectMock, CreateNewSessinConn).WillRepeatedly(Return(conn));
880     ret = BuildSessionConn(appInfo, &conn);
881     EXPECT_EQ(SOFTBUS_MEM_ERR, ret);
882 
883     SoftBusFree(appInfo);
884 }
885 
886 /**
887  * @tc.name: StartTransP2pDirectListenerTest001
888  * @tc.desc: Test OnP2pVerifyMsgReceived when TransProxyPipelineGetChannelIdByNetworkId return VALID_CHANNEL_ID
889  * @tc.type: FUNC
890  * @tc.require:
891  */
892 HWTEST_F(TransTcpDirectP2pMockTest, StartTransP2pDirectListenerTest001, TestSize.Level1)
893 {
894     SessionConn *conn = TestSetSessionConn();
895     ASSERT_TRUE(conn != nullptr);
896     ConnectType type = CONNECT_HML;
897     int32_t port = TEST_PORT;
898     AppInfo *appInfo = (AppInfo *)SoftBusCalloc(sizeof(AppInfo));
899     ASSERT_TRUE(appInfo != nullptr);
900     (void)memcpy_s(appInfo, sizeof(AppInfo), &conn->appInfo, sizeof(AppInfo));
901     NiceMock<TransTcpDirectP2pInterfaceMock> TcpP2pDirectMock;
902     EXPECT_CALL(TcpP2pDirectMock, TransTdcStartSessionListener).WillOnce(Return(port));
903     int32_t ret = StartTransP2pDirectListener(type, conn, appInfo);
904     EXPECT_EQ(SOFTBUS_OK, ret);
905     type = CONNECT_P2P;
906     EXPECT_CALL(TcpP2pDirectMock, IsHmlIpAddr).WillRepeatedly(Return(false));
907     EXPECT_CALL(TcpP2pDirectMock, TransTdcStartSessionListener).WillRepeatedly(Return(port));
908     ret = StartTransP2pDirectListener(type, conn, appInfo);
909     EXPECT_EQ(SOFTBUS_OK, ret);
910     EXPECT_CALL(TcpP2pDirectMock, IsHmlIpAddr).WillRepeatedly(Return(true));
911     ret = StartTransP2pDirectListener(type, conn, appInfo);
912     EXPECT_EQ(SOFTBUS_OK, ret);
913 
914     SoftBusFree(conn);
915     SoftBusFree(appInfo);
916 }
917 
918 /**
919  * @tc.name: OpenP2pDirectChannelTest001
920  * @tc.desc: Test OnP2pVerifyMsgReceived when TransProxyPipelineGetChannelIdByNetworkId return VALID_CHANNEL_ID
921  * @tc.type: FUNC
922  * @tc.require:
923  */
924 HWTEST_F(TransTcpDirectP2pMockTest, OpenP2pDirectChannelTest001, TestSize.Level1)
925 {
926     SessionConn *conn = TestSetSessionConn();
927     ASSERT_TRUE(conn != nullptr);
928     ConnectOption *connInfo = (ConnectOption *)SoftBusCalloc(sizeof(ConnectOption));
929     ASSERT_TRUE(connInfo != nullptr);
930     connInfo->type = CONNECT_TCP;
931     AppInfo *appInfo = (AppInfo *)SoftBusCalloc(sizeof(AppInfo));
932     ASSERT_TRUE(appInfo != nullptr);
933     (void)memcpy_s(appInfo, sizeof(AppInfo), &conn->appInfo, sizeof(AppInfo));
934     uint8_t *fastTransData = (uint8_t *)SoftBusCalloc(appInfo->fastTransDataSize);
935     ASSERT_TRUE(fastTransData != nullptr);
936     appInfo->fastTransData = fastTransData;
937     int32_t channelId = TEST_CHANNEL_ID;
938     int32_t ret = OpenP2pDirectChannel(appInfo, connInfo, &channelId);
939     EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
940     ret = OpenP2pDirectChannel(nullptr, connInfo, &channelId);
941     EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
942     ret = OpenP2pDirectChannel(appInfo, nullptr, &channelId);
943     EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
944     ret = OpenP2pDirectChannel(appInfo, connInfo, nullptr);
945     EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
946     connInfo->type = CONNECT_P2P_REUSE;
947     NiceMock<TransTcpDirectP2pInterfaceMock> TcpP2pDirectMock;
948     EXPECT_CALL(TcpP2pDirectMock, CreateNewSessinConn).WillRepeatedly(Return(nullptr));
949     ret = OpenP2pDirectChannel(appInfo, connInfo, &channelId);
950     EXPECT_EQ(SOFTBUS_MEM_ERR, ret);
951     connInfo->type = CONNECT_HML;
952     ret = OpenP2pDirectChannel(appInfo, connInfo, &channelId);
953     EXPECT_EQ(SOFTBUS_MEM_ERR, ret);
954     connInfo->type = CONNECT_P2P;
955     ret = OpenP2pDirectChannel(appInfo, connInfo, &channelId);
956     EXPECT_EQ(SOFTBUS_MEM_ERR, ret);
957 
958     EXPECT_CALL(TcpP2pDirectMock, CreateNewSessinConn).WillRepeatedly(Return(conn));
959     EXPECT_CALL(TcpP2pDirectMock, IsHmlIpAddr).WillRepeatedly(Return(true));
960     ret = OpenP2pDirectChannel(appInfo, connInfo, &channelId);
961     EXPECT_EQ(SOFTBUS_TRANS_TCP_GET_AUTHID_FAILED, ret);
962 
963     FreeFastTransData(appInfo);
964     SoftBusFree(appInfo);
965 }
966 }
967