1 /*
2 * Copyright (c) 2025 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 <gmock/gmock.h>
17 #include <gtest/gtest.h>
18 #include <securec.h>
19
20 #include "auth_interface.h"
21 #include "bus_center_manager.h"
22 #include "client_trans_session_manager.h"
23 #include "client_trans_socket_manager.h"
24 #include "client_trans_session_service.h"
25 #include "client_trans_session_callback.c"
26 #include "softbus_def.h"
27 #include "softbus_app_info.h"
28 #include "softbus_trans_def.h"
29 #include "softbus_error_code.h"
30 #include "softbus_adapter_mem.h"
31 #include "softbus_config_type.h"
32 #include "softbus_server_frame.h"
33 #include "softbus_feature_config.h"
34 #include "softbus_conn_interface.h"
35 #include "trans_log.h"
36 #include "trans_session_mgr_mock.h"
37
38 using namespace std;
39 using namespace testing;
40 using namespace testing::ext;
41 using testing::NiceMock;
42
43 namespace OHOS {
44
45 class TransClientSessionCallbackExTest : public testing::Test {
46 public:
TransClientSessionCallbackExTest()47 TransClientSessionCallbackExTest()
48 {}
~TransClientSessionCallbackExTest()49 ~TransClientSessionCallbackExTest()
50 {}
51 static void SetUpTestCase(void);
52 static void TearDownTestCase(void);
SetUp()53 void SetUp() override
54 {}
TearDown()55 void TearDown() override
56 {}
57 };
58
SetUpTestCase(void)59 void TransClientSessionCallbackExTest::SetUpTestCase(void) {}
60
TearDownTestCase(void)61 void TransClientSessionCallbackExTest::TearDownTestCase(void) {}
62
63 typedef enum {
64 EXCUTE_IN_FIRST_TIME = 1,
65 EXCUTE_IN_SECOND_TIME,
66 EXCUTE_IN_THIRD_TIME,
67 EXCUTE_IN_FOURTH_TIME,
68 EXCUTE_IN_FIFTH_TIME,
69 EXCUTE_IN_SIXTH_TIME,
70 } ExcuteTimes;
71
72 /**
73 * @tc.name: FillSessionInfoTest01
74 * @tc.desc: FillSessionInfo param is invalid.
75 * @tc.type: FUNC
76 * @tc.require:
77 */
78 HWTEST_F(TransClientSessionCallbackExTest, FillSessionInfoTest01, TestSize.Level1)
79 {
80 SessionInfo session;
81 ChannelInfo channel = {
82 .peerSessionName = reinterpret_cast<char *>(SoftBusCalloc(SESSION_NAME_SIZE_MAX)),
83 .peerDeviceId = reinterpret_cast<char *>(SoftBusCalloc(DEVICE_ID_SIZE_MAX)),
84 .groupId = reinterpret_cast<char *>(SoftBusCalloc(GROUP_ID_SIZE_MAX)),
85 .tokenType = ACCESS_TOKEN_TYPE_NATIVE,
86 };
87 strcpy_s(channel.peerSessionName, SESSION_NAME_SIZE_MAX, "peerSessionName");
88 strcpy_s(channel.peerDeviceId, DEVICE_ID_SIZE_MAX, "peerDeviceId");
89 strcpy_s(channel.groupId, GROUP_ID_SIZE_MAX, "groupId");
90
91 int32_t ret = FillSessionInfo(&session, &channel, 0);
92 EXPECT_EQ(ret, SOFTBUS_OK);
93
94 channel.tokenType = ACCESS_TOKEN_TYPE_HAP;
95 channel.peerBusinessAccountId = reinterpret_cast<char *>(SoftBusCalloc(ACCOUNT_UID_LEN_MAX));
96 ret = FillSessionInfo(&session, &channel, 0);
97 EXPECT_EQ(ret, SOFTBUS_OK);
98
99 channel.peerExtraAccessInfo = reinterpret_cast<char *>(SoftBusCalloc(EXTRA_ACCESS_INFO_LEN_MAX));
100 ret = FillSessionInfo(&session, &channel, 0);
101 EXPECT_EQ(ret, SOFTBUS_OK);
102
103 channel.tokenType = ACCESS_TOKEN_TYPE_NATIVE;
104 ret = FillSessionInfo(&session, &channel, 0);
105 EXPECT_EQ(ret, SOFTBUS_OK);
106
107 SoftBusFree(channel.peerSessionName);
108 SoftBusFree(channel.peerDeviceId);
109 SoftBusFree(channel.groupId);
110 SoftBusFree(channel.peerBusinessAccountId);
111 SoftBusFree(channel.peerExtraAccessInfo);
112 }
113
MyOnError(int32_t socket,int32_t errCode)114 void MyOnError(int32_t socket, int32_t errCode)
115 {
116 (void)socket;
117 (void)errCode;
118 return;
119 }
120
121 /**
122 * @tc.name: TransOnBindFailedTest001
123 * @tc.desc: TransOnBindFailed param is invalid.
124 * @tc.type: FUNC
125 * @tc.require:
126 */
127 HWTEST_F(TransClientSessionCallbackExTest, TransOnBindFailedTest001, TestSize.Level1)
128 {
129 ISocketListener listener = {
130 .OnError = MyOnError,
131 };
132 NiceMock<TransSessionMgrMock> transSessionMgrMock;
133 EXPECT_CALL(transSessionMgrMock, ClientGetSessionIsAsyncBySessionId).WillOnce(Return(SOFTBUS_INVALID_PARAM))
134 .WillOnce(TransSessionMgrMock::ActionOfClientGetSessionIsAsyncBySessionId).WillRepeatedly(Return(SOFTBUS_OK));
135
136 int32_t ret = TransOnBindFailed(0, &listener, 0);
137 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
138
139 ret = TransOnBindFailed(0, &listener, 0);
140 EXPECT_EQ(ret, SOFTBUS_OK);
141
142 ret = TransOnBindFailed(0, nullptr, 0);
143 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
144
145 listener.OnError = nullptr;
146 ret = TransOnBindFailed(0, &listener, 0);
147 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
148 listener.OnError = MyOnError;
149
150 EXPECT_CALL(transSessionMgrMock, GetSocketLifecycleAndSessionNameBySessionId)
151 .WillOnce(Return(SOFTBUS_INVALID_PARAM))
152 .WillOnce(Return(SOFTBUS_OK))
153 .WillRepeatedly(TransSessionMgrMock::ActionOfGetSocketLifecycleAndSessionNameBySessionId);
154
155 ret = TransOnBindFailed(0, &listener, 0);
156 EXPECT_EQ(ret, SOFTBUS_OK);
157
158 ret = TransOnBindFailed(0, &listener, 0);
159 EXPECT_EQ(ret, SOFTBUS_OK);
160
161 ret = TransOnBindFailed(0, &listener, 0);
162 EXPECT_EQ(ret, SOFTBUS_STRCPY_ERR);
163 }
164
165 /**
166 * @tc.name: HandleAsyncBindSuccessTest001
167 * @tc.desc: HandleAsyncBindSuccess param is invalid.
168 * @tc.type: FUNC
169 * @tc.require:
170 */
171 HWTEST_F(TransClientSessionCallbackExTest, HandleAsyncBindSuccessTest001, TestSize.Level1)
172 {
173 SocketLifecycleData lifecycle = {
174 .sessionState = SESSION_STATE_OPENING,
175 };
176 NiceMock<TransSessionMgrMock> transSessionMgrMock;
177 EXPECT_CALL(transSessionMgrMock, ClientHandleBindWaitTimer).WillRepeatedly(Return(SOFTBUS_OK));
178
179 lifecycle.sessionState = SESSION_STATE_CANCELLING;
180 int32_t ret = HandleAsyncBindSuccess(0, nullptr, &lifecycle);
181 EXPECT_EQ(ret, SOFTBUS_OK);
182 lifecycle.sessionState = SESSION_STATE_OPENING;
183
184 EXPECT_CALL(transSessionMgrMock, SetSessionStateBySessionId).WillOnce(Return(SOFTBUS_TRANS_INVALID_SESSION_ID))
185 .WillRepeatedly(Return(SOFTBUS_OK));
186
187 ret = HandleAsyncBindSuccess(0, nullptr, &lifecycle);
188 EXPECT_EQ(ret, SOFTBUS_TRANS_INVALID_SESSION_ID);
189
190 ret = HandleAsyncBindSuccess(0, nullptr, &lifecycle);
191 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
192 }
193
MyOnNegotiateSucc(int32_t socket,PeerSocketInfo info)194 bool MyOnNegotiateSucc(int32_t socket, PeerSocketInfo info)
195 {
196 (void)socket;
197 (void)info;
198 return true;
199 }
200
MyOnNegotiateFailed(int32_t socket,PeerSocketInfo info)201 bool MyOnNegotiateFailed(int32_t socket, PeerSocketInfo info)
202 {
203 (void)socket;
204 (void)info;
205 return false;
206 }
207
208 /**
209 * @tc.name: TransOnNegotiateTest001
210 * @tc.desc: TransOnNegotiate param is invalid.
211 * @tc.type: FUNC
212 * @tc.require:
213 */
214 HWTEST_F(TransClientSessionCallbackExTest, TransOnNegotiateTest001, TestSize.Level1)
215 {
216 ISocketListener socketCallback = {
217 .OnNegotiate = MyOnNegotiateFailed,
218 };
219 NiceMock<TransSessionMgrMock> transSessionMgrMock;
220 EXPECT_CALL(transSessionMgrMock, ClientGetPeerSocketInfoById).WillOnce(Return(SOFTBUS_INVALID_PARAM))
221 .WillRepeatedly(Return(SOFTBUS_OK));
222
223 int32_t ret = TransOnNegotiate(0, &socketCallback);
224 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
225
226 ret = TransOnNegotiate(0, &socketCallback);
227 EXPECT_EQ(ret, SOFTBUS_TRANS_NEGOTIATE_REJECTED);
228
229 socketCallback.OnNegotiate = MyOnNegotiateSucc;
230 ret = TransOnNegotiate(0, &socketCallback);
231 EXPECT_EQ(ret, SOFTBUS_OK);
232 }
233
MyOnNegotiate2Succ(int32_t socket,PeerSocketInfo info,SocketAccessInfo * peerInfo,SocketAccessInfo * localInfo)234 bool MyOnNegotiate2Succ(int32_t socket, PeerSocketInfo info, SocketAccessInfo *peerInfo, SocketAccessInfo *localInfo)
235 {
236 (void)socket;
237 (void)info;
238 (void)peerInfo;
239 (void)localInfo;
240 return true;
241 }
242
MyOnNegotiate2Failed(int32_t socket,PeerSocketInfo info,SocketAccessInfo * peerInfo,SocketAccessInfo * localInfo)243 bool MyOnNegotiate2Failed(int32_t socket, PeerSocketInfo info, SocketAccessInfo *peerInfo, SocketAccessInfo *localInfo)
244 {
245 (void)socket;
246 (void)info;
247 (void)peerInfo;
248 (void)localInfo;
249 return false;
250 }
251
252 /**
253 * @tc.name: TransOnNegotiateTest002
254 * @tc.desc: TransOnNegotiate2 param is invalid.
255 * @tc.type: FUNC
256 * @tc.require:
257 */
258 HWTEST_F(TransClientSessionCallbackExTest, TransOnNegotiateTest002, TestSize.Level1)
259 {
260 ISocketListener socketCallback = {
261 .OnNegotiate2 = nullptr,
262 };
263 ChannelInfo channel = {
264 .peerUserId = -1,
265 };
266
267 int32_t ret = TransOnNegotiate2(0, nullptr, &channel, nullptr);
268 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
269
270 ret = TransOnNegotiate2(0, &socketCallback, &channel, nullptr);
271 EXPECT_EQ(ret, SOFTBUS_OK);
272
273 ret = TransOnNegotiate2(0, &socketCallback, &channel, nullptr);
274 EXPECT_EQ(ret, SOFTBUS_OK);
275
276 NiceMock<TransSessionMgrMock> transSessionMgrMock;
277 EXPECT_CALL(transSessionMgrMock, ClientGetPeerSocketInfoById).WillOnce(Return(SOFTBUS_INVALID_PARAM))
278 .WillRepeatedly(Return(SOFTBUS_OK));
279 socketCallback.OnNegotiate2 = MyOnNegotiate2Failed;
280 channel.peerUserId = 0;
281 ret = TransOnNegotiate2(0, &socketCallback, &channel, nullptr);
282 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
283
284 ret = TransOnNegotiate2(0, &socketCallback, &channel, nullptr);
285 EXPECT_EQ(ret, SOFTBUS_TRANS_NEGOTIATE_REJECTED);
286
287 socketCallback.OnNegotiate2 = MyOnNegotiate2Succ;
288 ret = TransOnNegotiate2(0, &socketCallback, &channel, nullptr);
289 EXPECT_EQ(ret, SOFTBUS_OK);
290 }
291
292 /**
293 * @tc.name: HandleServerOnNegotiateTest001
294 * @tc.desc: HandleServerOnNegotiate param is invalid.
295 * @tc.type: FUNC
296 * @tc.require:
297 */
298 HWTEST_F(TransClientSessionCallbackExTest, HandleServerOnNegotiateTest001, TestSize.Level1)
299 {
300 NiceMock<TransSessionMgrMock> transSessionMgrMock;
301 EXPECT_CALL(transSessionMgrMock, ClientDeleteSocketSession).WillRepeatedly(Return(SOFTBUS_OK));
302 ISocketListener socketCallback = {
303 .OnNegotiate = nullptr,
304 .OnNegotiate2 = nullptr,
305 };
306 ChannelInfo channel = {
307 .peerUserId = -1,
308 .channelType = CHANNEL_TYPE_AUTH,
309 };
310
311 int32_t ret = HandleServerOnNegotiate(0, ACCESS_TOKEN_TYPE_HAP, nullptr, &channel, nullptr);
312 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
313
314 ret = HandleServerOnNegotiate(0, ACCESS_TOKEN_TYPE_HAP, &socketCallback, &channel, nullptr);
315 EXPECT_EQ(ret, SOFTBUS_OK);
316
317 ret = HandleServerOnNegotiate(0, ACCESS_TOKEN_TYPE_NATIVE, &socketCallback, &channel, nullptr);
318 EXPECT_EQ(ret, SOFTBUS_OK);
319
320 channel.channelId = CHANNEL_TYPE_TCP_DIRECT;
321 ret = HandleServerOnNegotiate(0, ACCESS_TOKEN_TYPE_HAP, &socketCallback, &channel, nullptr);
322 EXPECT_EQ(ret, SOFTBUS_OK);
323
324 ret = HandleServerOnNegotiate(0, ACCESS_TOKEN_TYPE_NATIVE, &socketCallback, &channel, nullptr);
325 EXPECT_EQ(ret, SOFTBUS_OK);
326
327 socketCallback.OnNegotiate2 = MyOnNegotiate2Failed;
328 ret = HandleServerOnNegotiate(0, ACCESS_TOKEN_TYPE_NATIVE, &socketCallback, &channel, nullptr);
329 EXPECT_EQ(ret, SOFTBUS_OK);
330 }
331
ActionOfGetIsAsyncAndTokenTypeBySessionId(int32_t sessionId,bool * isAsync,int32_t * tokenType)332 int32_t ActionOfGetIsAsyncAndTokenTypeBySessionId(int32_t sessionId, bool *isAsync, int32_t *tokenType)
333 {
334 (void)sessionId;
335 (void)tokenType;
336 *isAsync = false;
337 return SOFTBUS_OK;
338 }
339
340 /**
341 * @tc.name: HandleOnBindSuccessTest001
342 * @tc.desc: HandleOnBindSuccess param is invalid.
343 * @tc.type: FUNC
344 * @tc.require:
345 */
346 HWTEST_F(TransClientSessionCallbackExTest, HandleOnBindSuccessTest001, TestSize.Level1)
347 {
348 NiceMock<TransSessionMgrMock> transSessionMgrMock;
349 EXPECT_CALL(transSessionMgrMock, ClientDeleteSocketSession).WillRepeatedly(Return(SOFTBUS_OK));
350 EXPECT_CALL(transSessionMgrMock, GetIsAsyncAndTokenTypeBySessionId).WillRepeatedly(
__anon30547ecf0202(int32_t sessionId, bool *isAsync, int32_t *tokenType) 351 [](int32_t sessionId, bool *isAsync, int32_t *tokenType) -> int32_t {
352 static int32_t times = 0;
353 times++;
354 if (times < EXCUTE_IN_THIRD_TIME) {
355 return SOFTBUS_OK;
356 }
357 return ActionOfGetIsAsyncAndTokenTypeBySessionId(sessionId, isAsync, tokenType);
358 });
359 SessionListenerAdapter sessionCallback;
360 sessionCallback.socketServer.OnNegotiate = nullptr;
361 sessionCallback.socketClient.OnQos = nullptr;
362 ChannelInfo channel = {
363 .isServer = true,
364 };
365 SocketAccessInfo sinkAccessInfo;
366
367 EXPECT_CALL(transSessionMgrMock, GetSocketLifecycleAndSessionNameBySessionId)
368 .WillOnce(Return(SOFTBUS_INVALID_PARAM)).WillRepeatedly(Return(SOFTBUS_OK));
369 int32_t ret = HandleOnBindSuccess(0, sessionCallback, &channel, &sinkAccessInfo);
370 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
371
372 ret = HandleOnBindSuccess(0, sessionCallback, &channel, &sinkAccessInfo);
373 EXPECT_EQ(ret, SOFTBUS_OK);
374
375 channel.isServer = false;
376 EXPECT_CALL(transSessionMgrMock, ClientHandleBindWaitTimer).WillRepeatedly(Return(SOFTBUS_OK));
377 ret = HandleOnBindSuccess(0, sessionCallback, &channel, &sinkAccessInfo);
378 EXPECT_EQ(ret, SOFTBUS_OK);
379
380 ret = HandleOnBindSuccess(0, sessionCallback, &channel, &sinkAccessInfo);
381 EXPECT_EQ(ret, SOFTBUS_OK);
382 }
383
MyOnSessionOpened(int sessionId,int result)384 int MyOnSessionOpened(int sessionId, int result)
385 {
386 (void)sessionId;
387 (void)result;
388 return SOFTBUS_OK;
389 }
390
391 /**
392 * @tc.name: TransOnSessionOpenFailedTest001
393 * @tc.desc: TransOnSessionOpenFailed param is invalid.
394 * @tc.type: FUNC
395 * @tc.require:
396 */
397 HWTEST_F(TransClientSessionCallbackExTest, TransOnSessionOpenFailedTest001, TestSize.Level1)
398 {
399 NiceMock<TransSessionMgrMock> transSessionMgrMock;
400 EXPECT_CALL(transSessionMgrMock, ClientGetSessionIdByChannelId).WillRepeatedly(Return(SOFTBUS_OK));
401 EXPECT_CALL(transSessionMgrMock, ClientDeleteSession).WillRepeatedly(Return(SOFTBUS_OK));
402 EXPECT_CALL(transSessionMgrMock, ClientSetEnableStatusBySocket).WillRepeatedly(Return(SOFTBUS_OK));
403 EXPECT_CALL(transSessionMgrMock, ClientDeleteSocketSession).WillRepeatedly(Return(SOFTBUS_OK));
404 EXPECT_CALL(transSessionMgrMock, ClientHandleBindWaitTimer).WillRepeatedly(Return(SOFTBUS_OK));
405 EXPECT_CALL(transSessionMgrMock, ClientSignalSyncBind).WillRepeatedly(Return(SOFTBUS_OK));
406
407 EXPECT_CALL(transSessionMgrMock, ClientGetSessionIsAsyncBySessionId).WillOnce(Return(SOFTBUS_INVALID_PARAM))
408 .WillOnce(TransSessionMgrMock::ActionOfClientGetSessionIsAsyncBySessionId).WillRepeatedly(Return(SOFTBUS_OK));
409 EXPECT_CALL(transSessionMgrMock, ClientGetSessionCallbackAdapterById).WillRepeatedly(
__anon30547ecf0302(int32_t sessionId, SessionListenerAdapter *callbackAdapter, bool *isServer) 410 [](int32_t sessionId, SessionListenerAdapter *callbackAdapter, bool *isServer) -> int32_t {
411 (void)sessionId;
412 static int32_t times = 0;
413 times++;
414 callbackAdapter->isSocketListener = false;
415 *isServer = false;
416 if (times == EXCUTE_IN_FIRST_TIME) {
417 callbackAdapter->session.OnSessionOpened = nullptr;
418 return SOFTBUS_OK;
419 }
420 if (times == EXCUTE_IN_SECOND_TIME) {
421 callbackAdapter->session.OnSessionOpened = MyOnSessionOpened;
422 return SOFTBUS_OK;
423 }
424 callbackAdapter->isSocketListener = true;
425
426 if (times < EXCUTE_IN_SIXTH_TIME) {
427 return SOFTBUS_OK;
428 }
429 *isServer = true;
430 return SOFTBUS_OK;
431 });
432 int32_t ret = TransOnSessionOpenFailed(0, 0, SOFTBUS_OK);
433 EXPECT_EQ(ret, SOFTBUS_OK);
434
435 ret = TransOnSessionOpenFailed(0, 0, SOFTBUS_OK);
436 EXPECT_EQ(ret, SOFTBUS_OK);
437
438 ret = TransOnSessionOpenFailed(0, 0, SOFTBUS_OK);
439 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
440
441 ret = TransOnSessionOpenFailed(0, 0, SOFTBUS_OK);
442 EXPECT_EQ(ret, SOFTBUS_OK);
443
444 ret = TransOnSessionOpenFailed(0, 0, SOFTBUS_OK);
445 EXPECT_EQ(ret, SOFTBUS_OK);
446
447 ret = TransOnSessionOpenFailed(0, 0, SOFTBUS_OK);
448 EXPECT_EQ(ret, SOFTBUS_OK);
449 }
450
MyOnSessionClosed(int sessionId)451 void MyOnSessionClosed(int sessionId)
452 {
453 (void)sessionId;
454 return;
455 }
456
MyOnShutdown(int32_t socket,ShutdownReason reason)457 void MyOnShutdown(int32_t socket, ShutdownReason reason)
458 {
459 (void)socket;
460 (void)reason;
461 return;
462 }
463
ActionOfClientGetChannelBySessionId(int32_t sessionId,int32_t * channelId,int32_t * type,SessionEnableStatus * enableStatus)464 int32_t ActionOfClientGetChannelBySessionId(
465 int32_t sessionId, int32_t *channelId, int32_t *type, SessionEnableStatus *enableStatus)
466 {
467 (void)sessionId;
468 (void)channelId;
469 (void)type;
470 static int32_t times = 0;
471 times++;
472 if (times < EXCUTE_IN_SECOND_TIME) {
473 *enableStatus = ENABLE_STATUS_FAILED;
474 return SOFTBUS_OK;
475 }
476 *enableStatus = ENABLE_STATUS_SUCCESS;
477 return SOFTBUS_OK;
478 }
479
480 /**
481 * @tc.name: TransOnSessionClosedTest001
482 * @tc.desc: TransOnSessionClosed param is invalid.
483 * @tc.type: FUNC
484 * @tc.require:
485 */
486 HWTEST_F(TransClientSessionCallbackExTest, TransOnSessionClosedTest001, TestSize.Level1)
487 {
488 NiceMock<TransSessionMgrMock> transSessionMgrMock;
489 EXPECT_CALL(transSessionMgrMock, ClientGetSessionIdByChannelId).WillRepeatedly(Return(SOFTBUS_OK));
490 EXPECT_CALL(transSessionMgrMock, ClientDeleteSocketSession).WillRepeatedly(Return(SOFTBUS_OK));
491 EXPECT_CALL(transSessionMgrMock, ClientDeleteSession).WillRepeatedly(Return(SOFTBUS_INVALID_PARAM));
492
493 EXPECT_CALL(transSessionMgrMock, ClientGetChannelBySessionId)
494 .WillRepeatedly(ActionOfClientGetChannelBySessionId);
495 bool isD2d = false;
496 EXPECT_CALL(transSessionMgrMock, ClientGetSessionIsD2DByChannelId).WillRepeatedly(
497 DoAll(SetArgPointee<2>(isD2d), Return(SOFTBUS_OK)));
498 EXPECT_CALL(transSessionMgrMock, ClientGetSessionCallbackAdapterById).WillRepeatedly(
__anon30547ecf0402(int32_t sessionId, SessionListenerAdapter *callbackAdapter, bool *isServer) 499 [](int32_t sessionId, SessionListenerAdapter *callbackAdapter, bool *isServer) -> int32_t {
500 (void)sessionId;
501 static int32_t times = 0;
502 times++;
503 *isServer = true;
504 callbackAdapter->socketServer.OnShutdown = nullptr;
505 callbackAdapter->session.OnSessionClosed = nullptr;
506 if (times == EXCUTE_IN_FIRST_TIME) {
507 callbackAdapter->isSocketListener = true;
508 return SOFTBUS_OK;
509 }
510 if (times == EXCUTE_IN_SECOND_TIME) {
511 callbackAdapter->isSocketListener = false;
512 callbackAdapter->session.OnSessionClosed = MyOnSessionClosed;
513 return SOFTBUS_OK;
514 }
515 if (times == EXCUTE_IN_THIRD_TIME) {
516 callbackAdapter->isSocketListener = true;
517 return SOFTBUS_OK;
518 }
519 callbackAdapter->isSocketListener = true;
520 callbackAdapter->socketServer.OnShutdown = MyOnShutdown;
521 return SOFTBUS_OK;
522 });
523
524 int32_t ret = TransOnSessionClosed(0, CHANNEL_TYPE_UDP, SHUTDOWN_REASON_LOCAL);
525 EXPECT_EQ(ret, SOFTBUS_NO_INIT);
526
527 ret = TransOnSessionClosed(0, CHANNEL_TYPE_UDP, SHUTDOWN_REASON_LOCAL);
528 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
529
530 ret = TransOnSessionClosed(0, CHANNEL_TYPE_UDP, SHUTDOWN_REASON_LOCAL);
531 EXPECT_EQ(ret, SOFTBUS_OK);
532
533 ret = TransOnSessionClosed(0, CHANNEL_TYPE_UDP, SHUTDOWN_REASON_LOCAL);
534 EXPECT_EQ(ret, SOFTBUS_OK);
535 isD2d = true;
536 EXPECT_CALL(transSessionMgrMock, ClientGetSessionIsD2DByChannelId).WillRepeatedly(
537 DoAll(SetArgPointee<2>(isD2d), Return(SOFTBUS_OK)));
538 ret = TransOnSessionClosed(0, CHANNEL_TYPE_UDP, SHUTDOWN_REASON_LOCAL);
539 EXPECT_EQ(ret, SOFTBUS_OK);
540 }
541
MyOnBytes(int32_t socket,const void * data,uint32_t dataLen)542 void MyOnBytes(int32_t socket, const void *data, uint32_t dataLen)
543 {
544 (void)socket;
545 (void)data;
546 (void)dataLen;
547 return;
548 }
549
MyOnMessage(int32_t socket,const void * data,uint32_t dataLen)550 void MyOnMessage(int32_t socket, const void *data, uint32_t dataLen)
551 {
552 (void)socket;
553 (void)data;
554 (void)dataLen;
555 return;
556 }
557
558 /**
559 * @tc.name: TransOnDataReceivedTest001
560 * @tc.desc: TransOnDataReceived param is invalid.
561 * @tc.type: FUNC
562 * @tc.require:
563 */
564 HWTEST_F(TransClientSessionCallbackExTest, TransOnDataReceivedTest001, TestSize.Level1)
565 {
566 NiceMock<TransSessionMgrMock> transSessionMgrMock;
567 EXPECT_CALL(transSessionMgrMock, ClientGetSessionIdByChannelId).WillRepeatedly(Return(SOFTBUS_OK));
568 EXPECT_CALL(transSessionMgrMock, ClientResetIdleTimeoutById).WillRepeatedly(Return(SOFTBUS_OK));
569
570 EXPECT_CALL(transSessionMgrMock, ClientGetSessionCallbackAdapterById).WillRepeatedly(
__anon30547ecf0502(int32_t sessionId, SessionListenerAdapter *callbackAdapter, bool *isServer) 571 [](int32_t sessionId, SessionListenerAdapter *callbackAdapter, bool *isServer) -> int32_t {
572 (void)sessionId;
573 static int32_t times = 0;
574 times++;
575 *isServer = true;
576 callbackAdapter->isSocketListener = true;
577 callbackAdapter->socketServer.OnBytes = nullptr;
578 callbackAdapter->socketServer.OnMessage = nullptr;
579 callbackAdapter->session.OnBytesReceived = nullptr;
580 callbackAdapter->session.OnMessageReceived = nullptr;
581 if (times < EXCUTE_IN_THIRD_TIME) {
582 callbackAdapter->isSocketListener = false;
583 return SOFTBUS_OK;
584 }
585 if (times < EXCUTE_IN_FIFTH_TIME) {
586 return SOFTBUS_OK;
587 }
588 callbackAdapter->socketServer.OnBytes = MyOnBytes;
589 callbackAdapter->socketServer.OnMessage = MyOnMessage;
590 return SOFTBUS_OK;
591 });
592
593 int32_t ret = TransOnDataReceived(0, CHANNEL_TYPE_UDP, nullptr, 0, TRANS_SESSION_BYTES);
594 EXPECT_EQ(ret, SOFTBUS_OK);
595
596 ret = TransOnDataReceived(0, CHANNEL_TYPE_UDP, nullptr, 0, TRANS_SESSION_MESSAGE);
597 EXPECT_EQ(ret, SOFTBUS_OK);
598
599 ret = TransOnDataReceived(0, CHANNEL_TYPE_UDP, nullptr, 0, TRANS_SESSION_BYTES);
600 EXPECT_EQ(ret, SOFTBUS_OK);
601
602 ret = TransOnDataReceived(0, CHANNEL_TYPE_UDP, nullptr, 0, TRANS_SESSION_MESSAGE);
603 EXPECT_EQ(ret, SOFTBUS_OK);
604
605 ret = TransOnDataReceived(0, CHANNEL_TYPE_UDP, nullptr, 0, TRANS_SESSION_BYTES);
606 EXPECT_EQ(ret, SOFTBUS_OK);
607
608 ret = TransOnDataReceived(0, CHANNEL_TYPE_UDP, nullptr, 0, TRANS_SESSION_MESSAGE);
609 EXPECT_EQ(ret, SOFTBUS_OK);
610 }
611
MyOnStream(int32_t socket,const StreamData * data,const StreamData * ext,const StreamFrameInfo * param)612 void MyOnStream(int32_t socket, const StreamData *data, const StreamData *ext, const StreamFrameInfo *param)
613 {
614 (void)socket;
615 (void)data;
616 (void)ext;
617 (void)param;
618 return;
619 }
620
621 /**
622 * @tc.name: TransOnOnStreamReceviedTest001
623 * @tc.desc: TransOnOnStreamRecevied param is invalid.
624 * @tc.type: FUNC
625 * @tc.require:
626 */
627 HWTEST_F(TransClientSessionCallbackExTest, TransOnOnStreamReceviedTest001, TestSize.Level1)
628 {
629 NiceMock<TransSessionMgrMock> transSessionMgrMock;
630 EXPECT_CALL(transSessionMgrMock, ClientGetSessionIdByChannelId).WillRepeatedly(Return(SOFTBUS_OK));
631 EXPECT_CALL(transSessionMgrMock, ClientResetIdleTimeoutById).WillRepeatedly(Return(SOFTBUS_OK));
632
633 EXPECT_CALL(transSessionMgrMock, ClientGetSessionCallbackAdapterById).WillRepeatedly(
__anon30547ecf0602(int32_t sessionId, SessionListenerAdapter *callbackAdapter, bool *isServer) 634 [](int32_t sessionId, SessionListenerAdapter *callbackAdapter, bool *isServer) -> int32_t {
635 (void)sessionId;
636 (void)isServer;
637 static int32_t times = 0;
638 times++;
639 callbackAdapter->isSocketListener = true;
640 callbackAdapter->socketServer.OnStream = nullptr;
641 if (times == EXCUTE_IN_FIRST_TIME) {
642 return SOFTBUS_OK;
643 }
644 callbackAdapter->socketServer.OnStream = MyOnStream;
645 return SOFTBUS_OK;
646 });
647
648 int32_t ret = TransOnOnStreamRecevied(0, CHANNEL_TYPE_UDP, nullptr, nullptr, nullptr);
649 EXPECT_EQ(ret, SOFTBUS_OK);
650
651 ret = TransOnOnStreamRecevied(0, CHANNEL_TYPE_UDP, nullptr, nullptr, nullptr);
652 EXPECT_EQ(ret, SOFTBUS_OK);
653 }
654
MyOnBind(int32_t socket,PeerSocketInfo info)655 void MyOnBind(int32_t socket, PeerSocketInfo info)
656 {
657 (void)socket;
658 (void)info;
659 return;
660 }
661
662 /**
663 * @tc.name: ClientTransOnChannelBindTest001
664 * @tc.desc: ClientTransOnChannelBind param is invalid.
665 * @tc.type: FUNC
666 * @tc.require:
667 */
668 HWTEST_F(TransClientSessionCallbackExTest, ClientTransOnChannelBindTest001, TestSize.Level1)
669 {
670 NiceMock<TransSessionMgrMock> transSessionMgrMock;
671 EXPECT_CALL(transSessionMgrMock, ClientGetSessionIdByChannelId).WillRepeatedly(Return(SOFTBUS_OK));
672 EXPECT_CALL(transSessionMgrMock, ClientGetPeerSocketInfoById).WillRepeatedly(Return(SOFTBUS_OK));
673
674 EXPECT_CALL(transSessionMgrMock, ClientGetSessionCallbackAdapterById).WillRepeatedly(
__anon30547ecf0702(int32_t sessionId, SessionListenerAdapter *callbackAdapter, bool *isServer) 675 [](int32_t sessionId, SessionListenerAdapter *callbackAdapter, bool *isServer) -> int32_t {
676 (void)sessionId;
677 static int32_t times = 0;
678 times++;
679 *isServer = true;
680 callbackAdapter->isSocketListener = true;
681 callbackAdapter->socketServer.OnBind = MyOnBind;
682 if (times == EXCUTE_IN_FIRST_TIME) {
683 callbackAdapter->isSocketListener = false;
684 return SOFTBUS_OK;
685 }
686 if (times == EXCUTE_IN_SECOND_TIME) {
687 *isServer = false;
688 return SOFTBUS_OK;
689 }
690 if (times == EXCUTE_IN_THIRD_TIME) {
691 callbackAdapter->socketServer.OnBind = nullptr;
692 return SOFTBUS_OK;
693 }
694 return SOFTBUS_OK;
695 });
696
697 int32_t ret = ClientTransOnChannelBind(0, CHANNEL_TYPE_UDP);
698 EXPECT_EQ(ret, SOFTBUS_NOT_NEED_UPDATE);
699
700 ret = ClientTransOnChannelBind(0, CHANNEL_TYPE_UDP);
701 EXPECT_EQ(ret, SOFTBUS_NOT_NEED_UPDATE);
702
703 ret = ClientTransOnChannelBind(0, CHANNEL_TYPE_UDP);
704 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
705
706 ret = ClientTransOnChannelBind(0, CHANNEL_TYPE_UDP);
707 EXPECT_EQ(ret, SOFTBUS_OK);
708 }
709
MyOnQos(int32_t socket,QoSEvent eventId,const QosTV * qos,uint32_t qosCount)710 void MyOnQos(int32_t socket, QoSEvent eventId, const QosTV *qos, uint32_t qosCount)
711 {
712 (void)socket;
713 (void)eventId;
714 (void)qos;
715 (void)qosCount;
716 return;
717 }
718
ActionOfClientCacheQosEvent(int32_t socket,QoSEvent event,const QosTV * qos,uint32_t count)719 int32_t ActionOfClientCacheQosEvent(int32_t socket, QoSEvent event, const QosTV *qos, uint32_t count)
720 {
721 (void)socket;
722 (void)event;
723 (void)qos;
724 (void)count;
725 static int32_t times = 0;
726 times++;
727 if (times == EXCUTE_IN_FIRST_TIME) {
728 return SOFTBUS_OK;
729 }
730 if (times == EXCUTE_IN_SECOND_TIME) {
731 return SOFTBUS_TRANS_NO_NEED_CACHE_QOS_EVENT;
732 }
733 if (times == EXCUTE_IN_THIRD_TIME) {
734 return SOFTBUS_INVALID_PARAM;
735 }
736 return SOFTBUS_OK;
737 }
738
739 /**
740 * @tc.name: ClientTransOnQosTest001
741 * @tc.desc: ClientTransOnQos param is invalid.
742 * @tc.type: FUNC
743 * @tc.require:
744 */
745 HWTEST_F(TransClientSessionCallbackExTest, ClientTransOnQosTest001, TestSize.Level1)
746 {
747 NiceMock<TransSessionMgrMock> transSessionMgrMock;
748 EXPECT_CALL(transSessionMgrMock, ClientGetSessionIdByChannelId).WillRepeatedly(Return(SOFTBUS_OK));
749
750 EXPECT_CALL(transSessionMgrMock, ClientGetSessionCallbackAdapterById).WillRepeatedly(
__anon30547ecf0802(int32_t sessionId, SessionListenerAdapter *callbackAdapter, bool *isServer) 751 [](int32_t sessionId, SessionListenerAdapter *callbackAdapter, bool *isServer) -> int32_t {
752 (void)sessionId;
753 static int32_t times = 0;
754 times++;
755 *isServer = false;
756 callbackAdapter->isSocketListener = true;
757 callbackAdapter->socketClient.OnQos = MyOnQos;
758 if (times == EXCUTE_IN_FIRST_TIME) {
759 *isServer = true;
760 return SOFTBUS_OK;
761 }
762 if (times == EXCUTE_IN_SECOND_TIME) {
763 callbackAdapter->isSocketListener = false;
764 return SOFTBUS_OK;
765 }
766 if (times == EXCUTE_IN_THIRD_TIME) {
767 callbackAdapter->socketClient.OnQos = nullptr;
768 return SOFTBUS_OK;
769 }
770 return SOFTBUS_OK;
771 });
772 EXPECT_CALL(transSessionMgrMock, ClientCacheQosEvent).WillRepeatedly(ActionOfClientCacheQosEvent);
773
774 QosTV qos;
775 int32_t ret = ClientTransOnQos(0, CHANNEL_TYPE_UDP, QOS_SATISFIED, &qos, 0);
776 EXPECT_EQ(ret, SOFTBUS_OK);
777
778 ret = ClientTransOnQos(0, CHANNEL_TYPE_UDP, QOS_SATISFIED, &qos, 0);
779 EXPECT_EQ(ret, SOFTBUS_OK);
780
781 ret = ClientTransOnQos(0, CHANNEL_TYPE_UDP, QOS_SATISFIED, &qos, 0);
782 EXPECT_EQ(ret, SOFTBUS_OK);
783
784 ret = ClientTransOnQos(0, CHANNEL_TYPE_UDP, QOS_SATISFIED, &qos, 0);
785 EXPECT_EQ(ret, SOFTBUS_OK);
786
787 ret = ClientTransOnQos(0, CHANNEL_TYPE_UDP, QOS_SATISFIED, &qos, 0);
788 EXPECT_EQ(ret, SOFTBUS_OK);
789
790 ret = ClientTransOnQos(0, CHANNEL_TYPE_UDP, QOS_SATISFIED, &qos, 0);
791 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
792 }
793 }