• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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 "client_trans_session_manager.c"
21 #include "softbus_adapter_mem.h"
22 #include "softbus_error_code.h"
23 #include "trans_common_mock.h"
24 #include "trans_log.h"
25 #include "trans_socket_mgr_mock.h"
26 
27 using namespace std;
28 using namespace testing;
29 using namespace testing::ext;
30 using testing::NiceMock;
31 
32 namespace OHOS {
33 
34 class TransClientSessionManagerExTest : public testing::Test {
35 public:
TransClientSessionManagerExTest()36     TransClientSessionManagerExTest()
37     {}
~TransClientSessionManagerExTest()38     ~TransClientSessionManagerExTest()
39     {}
SetUpTestCase(void)40     static void SetUpTestCase(void)
41     {}
TearDownTestCase(void)42     static void TearDownTestCase(void)
43     {}
SetUp()44     void SetUp() override
45     {}
TearDown()46     void TearDown() override
47     {}
48 };
49 
50 typedef enum {
51     EXCUTE_IN_FIRST_TIME = 1,
52     EXCUTE_IN_SECOND_TIME,
53     EXCUTE_IN_THIRD_TIME,
54     EXCUTE_IN_FOURTH_TIME,
55     EXCUTE_IN_FIFTH_TIME,
56     EXCUTE_IN_SIXTH_TIME,
57 } ExcuteTimes;
58 
59 SoftBusList g_clientSessionServerList;
60 ClientSessionServer g_server;
61 SessionInfo g_sessionNode;
62 
63 /**
64  * @tc.name: TransClientSessionManagerExTest01
65  * @tc.desc: TransClientInit with invalid parameters.
66  * @tc.type: FUNC
67  * @tc.require:
68  */
69 HWTEST_F(TransClientSessionManagerExTest, TransClientSessionManagerExTest01, TestSize.Level1)
70 {
71     NiceMock<TransCommInterfaceMock> transCommInterfaceMock;
72     EXPECT_CALL(transCommInterfaceMock, RegNodeDeviceStateCbInner).WillRepeatedly(Return(SOFTBUS_OK));
73     EXPECT_CALL(transCommInterfaceMock, CreateSoftBusList).WillOnce(Return(nullptr))
74         .WillRepeatedly(Return(&g_clientSessionServerList));
75     int32_t ret = TransClientInit();
76     EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_SERVER_NOINIT);
77 
78     NiceMock<TransSocketMgrMock> transSocketMgrMock;
79     EXPECT_CALL(transSocketMgrMock, TransDataSeqInfoListInit).WillOnce(Return(SOFTBUS_TRANS_DATA_SEQ_INFO_NO_INIT))
80         .WillRepeatedly(Return(SOFTBUS_OK));
81     ret = TransClientInit();
82     EXPECT_EQ(ret, SOFTBUS_TRANS_DATA_SEQ_INFO_NO_INIT);
83 
84     EXPECT_CALL(transCommInterfaceMock, TransServerProxyInit).WillOnce(Return(SOFTBUS_TRANS_SERVER_INIT_FAILED))
85         .WillRepeatedly(Return(SOFTBUS_OK));
86     ret = TransClientInit();
87     EXPECT_EQ(ret, SOFTBUS_TRANS_SERVER_INIT_FAILED);
88 
89     EXPECT_CALL(transCommInterfaceMock, ClientTransChannelInit).WillOnce(Return(SOFTBUS_TRANS_SERVER_INIT_FAILED))
90         .WillRepeatedly(Return(SOFTBUS_OK));
91     ret = TransClientInit();
92     EXPECT_EQ(ret, SOFTBUS_TRANS_SERVER_INIT_FAILED);
93 
94     EXPECT_CALL(transCommInterfaceMock, RegisterTimeoutCallback).WillRepeatedly(
__anon2d20be9d0202(int32_t timerFunId, TimerFunCallback callback) 95         [](int32_t timerFunId, TimerFunCallback callback) -> int32_t {
96         (void)timerFunId;
97         (void)callback;
98         static int32_t times = 0;
99         times++;
100         if (times == EXCUTE_IN_FIRST_TIME) {
101             return SOFTBUS_TRANS_SERVER_INIT_FAILED;
102         }
103         if (times == EXCUTE_IN_SECOND_TIME) {
104             return SOFTBUS_OK;
105         }
106         if (times == EXCUTE_IN_THIRD_TIME) {
107             return SOFTBUS_TRANS_DATA_SEQ_INFO_INIT_FAIL;
108         }
109         return SOFTBUS_OK;
110     });
111     ret = TransClientInit();
112     EXPECT_EQ(ret, SOFTBUS_TRANS_SERVER_INIT_FAILED);
113 
114     ret = TransClientInit();
115     EXPECT_EQ(ret, SOFTBUS_TRANS_DATA_SEQ_INFO_INIT_FAIL);
116 
117     ret = TransClientInit();
118     EXPECT_EQ(ret, SOFTBUS_OK);
119 }
120 
121 /**
122  * @tc.name: TransClientSessionManagerExTest02
123  * @tc.desc: ClientGetSessionNameBySessionId with invalid parameters.
124  * @tc.type: FUNC
125  * @tc.require:
126  */
127 HWTEST_F(TransClientSessionManagerExTest, TransClientSessionManagerExTest02, TestSize.Level1)
128 {
129     char *sessionName = reinterpret_cast<char *>(SoftBusCalloc(SESSION_NAME_SIZE_MAX));
130 
131     int32_t ret = ClientGetSessionNameBySessionId(0, nullptr);
132     EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
133 
134     ret = ClientGetSessionNameBySessionId(-1, sessionName);
135     EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
136 
137     ret = ClientGetSessionNameBySessionId(1, sessionName);
138     EXPECT_EQ(ret, SOFTBUS_LOCK_ERR);
139 
140     SoftBusMutexAttr mutexAttr;
141     mutexAttr.type = SOFTBUS_MUTEX_RECURSIVE;
142     EXPECT_EQ(SoftBusMutexInit(&g_clientSessionServerList.lock, &mutexAttr), SOFTBUS_OK);
143     ListInit(&g_clientSessionServerList.list);
144     ListInit(&g_server.node);
145     ListInit(&g_server.sessionList);
146     ListInit(&g_sessionNode.node);
147 
148     ListAdd(&g_clientSessionServerList.list, &g_server.node);
149     ret = ClientGetSessionNameBySessionId(0, sessionName);
150     EXPECT_EQ(ret, SOFTBUS_NOT_FIND);
151 
152     ListAdd(&g_server.sessionList, &g_sessionNode.node);
153     g_sessionNode.sessionId = 0;
154     ret = ClientGetSessionNameBySessionId(1, sessionName);
155     EXPECT_EQ(ret, SOFTBUS_NOT_FIND);
156     g_sessionNode.sessionId = 1;
157 
158     (void)strcpy_s(g_server.sessionName, SESSION_NAME_SIZE_MAX, "sessionName");
159     ret = ClientGetSessionNameBySessionId(1, sessionName);
160     EXPECT_EQ(ret, SOFTBUS_OK);
161 
162     SoftBusFree(sessionName);
163 }
164 
165 /**
166  * @tc.name: TransClientSessionManagerExTest03
167  * @tc.desc: TransSetNeedAckBySocket with invalid parameters.
168  * @tc.type: FUNC
169  * @tc.require:
170  */
171 HWTEST_F(TransClientSessionManagerExTest, TransClientSessionManagerExTest03, TestSize.Level1)
172 {
173     int32_t ret = TransSetNeedAckBySocket(0, true);
174     EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
175 
176     ret = TransSetNeedAckBySocket(2, true);
177     EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_INFO_NOT_FOUND);
178 
179     g_sessionNode.isSupportTlv = false;
180     ret = TransSetNeedAckBySocket(1, true);
181     EXPECT_EQ(ret, SOFTBUS_TRANS_NOT_SUPPORT_TLV_HEAD);
182     g_sessionNode.isSupportTlv = true;
183 
184     ret = TransSetNeedAckBySocket(1, true);
185     EXPECT_EQ(ret, SOFTBUS_OK);
186 }
187 
188 /**
189  * @tc.name: TransClientSessionManagerExTest04
190  * @tc.desc: TransGetSupportTlvBySocket with invalid parameters.
191  * @tc.type: FUNC
192  * @tc.require:
193  */
194 HWTEST_F(TransClientSessionManagerExTest, TransClientSessionManagerExTest04, TestSize.Level1)
195 {
196     int32_t optValueSize = 0;
197     bool supportTlv = false;
198     int32_t ret = TransGetSupportTlvBySocket(0, &supportTlv, &optValueSize);
199     EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
200 
201     ret = TransGetSupportTlvBySocket(1, nullptr, &optValueSize);
202     EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
203 
204     ret = TransGetSupportTlvBySocket(1, &supportTlv, nullptr);
205     EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
206 
207     ret = TransGetSupportTlvBySocket(0, nullptr, &optValueSize);
208     EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
209 
210     ret = TransGetSupportTlvBySocket(0, &supportTlv, nullptr);
211     EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
212 
213     ret = TransGetSupportTlvBySocket(1, nullptr, nullptr);
214     EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
215 
216     ret = TransGetSupportTlvBySocket(0, nullptr, nullptr);
217     EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
218 
219     ret = TransGetSupportTlvBySocket(1, &supportTlv, &optValueSize);
220     EXPECT_EQ(ret, SOFTBUS_OK);
221     EXPECT_EQ(supportTlv, true);
222     EXPECT_EQ(optValueSize, sizeof(bool));
223 }
224 
225 /**
226  * @tc.name: TransClientSessionManagerExTest05
227  * @tc.desc: ClientGetCachedQosEventBySocket with invalid parameters.
228  * @tc.type: FUNC
229  * @tc.require:
230  */
231 HWTEST_F(TransClientSessionManagerExTest, TransClientSessionManagerExTest05, TestSize.Level1)
232 {
233     CachedQosEvent cachedQosEvent;
234     int32_t ret = ClientGetCachedQosEventBySocket(0, &cachedQosEvent);
235     EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
236 
237     ret = ClientGetCachedQosEventBySocket(1, nullptr);
238     EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
239 
240     ret = ClientGetCachedQosEventBySocket(0, nullptr);
241     EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
242 
243     ret = ClientGetCachedQosEventBySocket(2, &cachedQosEvent);
244     EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_INFO_NOT_FOUND);
245 
246     ret = ClientGetCachedQosEventBySocket(1, &cachedQosEvent);
247     EXPECT_EQ(ret, SOFTBUS_OK);
248 }
249 
250 /**
251  * @tc.name: TransClientSessionManagerExTest06
252  * @tc.desc: ClientCacheQosEvent with invalid parameters.
253  * @tc.type: FUNC
254  * @tc.require:
255  */
256 HWTEST_F(TransClientSessionManagerExTest, TransClientSessionManagerExTest06, TestSize.Level1)
257 {
258     QosTV qos;
259     (void)memset_s(&qos, sizeof(QosTV), 0, sizeof(QosTV));
260     int32_t ret = ClientCacheQosEvent(0, QOS_SATISFIED, &qos, 1);
261     EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
262 
263     ret = ClientCacheQosEvent(1, QOS_SATISFIED, nullptr, 1);
264     EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
265 
266     ret = ClientCacheQosEvent(1, QOS_SATISFIED, &qos, 0);
267     EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
268 
269     ret = ClientCacheQosEvent(0, QOS_SATISFIED, nullptr, 1);
270     EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
271 
272     ret = ClientCacheQosEvent(0, QOS_SATISFIED, &qos, 0);
273     EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
274 
275     ret = ClientCacheQosEvent(1, QOS_SATISFIED, nullptr, 0);
276     EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
277 
278     ret = ClientCacheQosEvent(0, QOS_SATISFIED, nullptr, 0);
279     EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
280 
281     ret = ClientCacheQosEvent(2, QOS_SATISFIED, &qos, 1);
282     EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_INFO_NOT_FOUND);
283 
284     g_sessionNode.lifecycle.sessionState = SESSION_STATE_CALLBACK_FINISHED;
285     ret = ClientCacheQosEvent(1, QOS_SATISFIED, &qos, 1);
286     EXPECT_EQ(ret, SOFTBUS_TRANS_NO_NEED_CACHE_QOS_EVENT);
287     g_sessionNode.lifecycle.sessionState = SESSION_STATE_OPENING;
288 
289     ret = ClientCacheQosEvent(1, QOS_SATISFIED, &qos, 1);
290     EXPECT_EQ(ret, SOFTBUS_OK);
291 }
292 
293 /**
294  * @tc.name: TransClientSessionManagerExTest07
295  * @tc.desc: ClientCancelAuthSessionTimer with invalid parameters.
296  * @tc.type: FUNC
297  * @tc.require:
298  */
299 HWTEST_F(TransClientSessionManagerExTest, TransClientSessionManagerExTest07, TestSize.Level1)
300 {
301     int32_t ret = ClientCancelAuthSessionTimer(0);
302     EXPECT_EQ(ret, SOFTBUS_TRANS_INVALID_SESSION_ID);
303 
304     ret = ClientCancelAuthSessionTimer(1);
305     EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_INFO_NOT_FOUND);
306 
307     (void)strcpy_s(g_server.sessionName, SESSION_NAME_SIZE_MAX, "IShareAuthSession");
308     ret = ClientCancelAuthSessionTimer(2);
309     EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_INFO_NOT_FOUND);
310 
311     g_sessionNode.actionId = 0;
312     g_sessionNode.channelType = CHANNEL_TYPE_UNDEFINED;
313     ret = ClientCancelAuthSessionTimer(1);
314     EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_INFO_NOT_FOUND);
315 
316     g_sessionNode.channelType = CHANNEL_TYPE_PROXY;
317     ret = ClientCancelAuthSessionTimer(1);
318     EXPECT_EQ(ret, SOFTBUS_OK);
319 
320     g_sessionNode.channelType = CHANNEL_TYPE_AUTH;
321     ret = ClientCancelAuthSessionTimer(1);
322     EXPECT_EQ(ret, SOFTBUS_OK);
323 }
324 
325 /**
326  * @tc.name: TransClientSessionManagerExTest08
327  * @tc.desc: ClientUpdateAuthSessionTimer with invalid parameters.
328  * @tc.type: FUNC
329  * @tc.require:
330  */
331 HWTEST_F(TransClientSessionManagerExTest, TransClientSessionManagerExTest08, TestSize.Level1)
332 {
333     g_sessionNode.actionId = 0;
334     int32_t ret = ClientUpdateAuthSessionTimer(&g_sessionNode, 0);
335     EXPECT_EQ(ret, SOFTBUS_OK);
336     g_sessionNode.actionId = 1;
337 
338     g_sessionNode.lifecycle.maxWaitTime = 0;
339     ret = ClientUpdateAuthSessionTimer(&g_sessionNode, 0);
340     EXPECT_EQ(ret, SOFTBUS_NOT_NEED_UPDATE);
341 
342     g_sessionNode.lifecycle.maxWaitTime = 1;
343     ret = ClientUpdateAuthSessionTimer(&g_sessionNode, 0);
344     EXPECT_EQ(ret, SOFTBUS_OK);
345 }
346 
347 /**
348  * @tc.name: TransClientSessionManagerExTest09
349  * @tc.desc: ClientSignalSyncBind with invalid parameters.
350  * @tc.type: FUNC
351  * @tc.require:
352  */
353 HWTEST_F(TransClientSessionManagerExTest, TransClientSessionManagerExTest09, TestSize.Level1)
354 {
355     int32_t ret = ClientSignalSyncBind(0, 0);
356     EXPECT_EQ(ret, SOFTBUS_TRANS_INVALID_SESSION_ID);
357 
358     ret = ClientSignalSyncBind(2, 0);
359     EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_INFO_NOT_FOUND);
360 
361     g_sessionNode.isAsync = true;
362     ret = ClientSignalSyncBind(1, 0);
363     EXPECT_EQ(ret, SOFTBUS_OK);
364     g_sessionNode.isAsync = false;
365 
366     NiceMock<TransCommInterfaceMock> transCommInterfaceMock;
367     EXPECT_CALL(transCommInterfaceMock, SoftBusCondSignal).WillOnce(Return(SOFTBUS_INVALID_PARAM))
368         .WillRepeatedly(Return(SOFTBUS_OK));
369 
370     ret = ClientSignalSyncBind(1, 0);
371     EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
372 
373     ret = ClientSignalSyncBind(1, 0);
374     EXPECT_EQ(ret, SOFTBUS_OK);
375 }
376 
377 /**
378  * @tc.name: TransClientSessionManagerExTest10
379  * @tc.desc: ClientWaitSyncBind with invalid parameters.
380  * @tc.type: FUNC
381  * @tc.require:
382  */
383 HWTEST_F(TransClientSessionManagerExTest, TransClientSessionManagerExTest10, TestSize.Level1)
384 {
385     int32_t ret = ClientWaitSyncBind(0);
386     EXPECT_EQ(ret, SOFTBUS_TRANS_INVALID_SESSION_ID);
387 
388     ret = ClientWaitSyncBind(2);
389     EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_INFO_NOT_FOUND);
390 
391     g_sessionNode.lifecycle.sessionState = SESSION_STATE_CANCELLING;
392     g_sessionNode.lifecycle.bindErrCode = SOFTBUS_INVALID_PARAM;
393     ret = ClientWaitSyncBind(1);
394     EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
395     g_sessionNode.lifecycle.sessionState = SESSION_STATE_OPENING;
396     g_sessionNode.lifecycle.bindErrCode = SOFTBUS_OK;
397 
398     NiceMock<TransCommInterfaceMock> transCommInterfaceMock;
399     EXPECT_CALL(transCommInterfaceMock, SoftBusGetTime).WillOnce(Return(SOFTBUS_INVALID_PARAM))
400         .WillRepeatedly(Return(SOFTBUS_OK));
401     EXPECT_CALL(transCommInterfaceMock, SoftBusCondWait).WillOnce(Return(SOFTBUS_INVALID_PARAM))
402         .WillRepeatedly(Return(SOFTBUS_OK));
403     g_sessionNode.lifecycle.maxWaitTime = 1;
404     ret = ClientWaitSyncBind(1);
405     EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
406 
407     g_sessionNode.enableStatus = ENABLE_STATUS_SUCCESS;
408     ret = ClientWaitSyncBind(1);
409     EXPECT_EQ(ret, SOFTBUS_OK);
410 }
411 }