1 /*
2 * Copyright (c) 2022-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 <gtest/gtest.h>
17 #include "securec.h"
18
19 #include "client_trans_channel_callback.h"
20 #include "client_trans_session_callback.h"
21 #include "client_trans_tcp_direct_callback.h"
22 #include "client_trans_proxy_manager.h"
23 #include "client_trans_auth_manager.h"
24 #include "client_trans_udp_manager.h"
25 #include "softbus_def.h"
26 #include "softbus_error_code.h"
27
28 #define TEST_DATA_LENGTH 1024
29
30 using namespace std;
31 using namespace testing::ext;
32
33 namespace OHOS {
34 const char *g_sessionName = "ohos.distributedschedule.dms.test";
35 const char *g_networkid = "ABCDEF00ABCDEF00ABCDEF00ABCDEF00ABCDEF00ABCDEF00ABCDEF00ABCDEF00";
36
OnSessionOpened(const char * sessionName,const ChannelInfo * channel,SessionType flag,SocketAccessInfo * accessInfo)37 int32_t OnSessionOpened(
38 const char *sessionName, const ChannelInfo *channel, SessionType flag, SocketAccessInfo *accessInfo)
39 {
40 return SOFTBUS_OK;
41 }
OnSessionClosed(int32_t channelId,int32_t channelType,ShutdownReason reason)42 int32_t OnSessionClosed(int32_t channelId, int32_t channelType, ShutdownReason reason)
43 {
44 return SOFTBUS_OK;
45 }
46
OnSessionOpenFailed(int32_t channelId,int32_t channelType,int32_t errCode)47 int32_t OnSessionOpenFailed(int32_t channelId, int32_t channelType, int32_t errCode)
48 {
49 return SOFTBUS_OK;
50 }
51
OnDataReceived(int32_t channelId,int32_t channelType,const void * data,uint32_t len,SessionPktType type)52 static int32_t OnDataReceived(int32_t channelId, int32_t channelType,
53 const void *data, uint32_t len, SessionPktType type)
54 {
55 return SOFTBUS_OK;
56 }
57
OnStreamReceived(int32_t channelId,int32_t channelType,const StreamData * data,const StreamData * ext,const StreamFrameInfo * param)58 static int32_t OnStreamReceived(int32_t channelId, int32_t channelType, const StreamData *data,
59 const StreamData *ext, const StreamFrameInfo *param)
60 {
61 return SOFTBUS_OK;
62 }
63
OnQosEvent(int32_t channelId,int32_t channelType,int32_t eventId,int32_t tvCount,const QosTv * tvList)64 static int32_t OnQosEvent(int32_t channelId, int32_t channelType, int32_t eventId,
65 int32_t tvCount, const QosTv *tvList)
66 {
67 return SOFTBUS_OK;
68 }
69
OnChannelBind(int32_t channelId,int32_t channelType)70 static int32_t OnChannelBind(int32_t channelId, int32_t channelType)
71 {
72 (void)channelId;
73 (void)channelType;
74 return SOFTBUS_OK;
75 }
76
77 static IClientSessionCallBack g_clientSessionCb = {
78 .OnSessionOpened = OnSessionOpened,
79 .OnSessionClosed = OnSessionClosed,
80 .OnSessionOpenFailed = OnSessionOpenFailed,
81 .OnDataReceived = OnDataReceived,
82 .OnStreamReceived = OnStreamReceived,
83 .OnQosEvent = OnQosEvent,
84 .OnChannelBind = OnChannelBind,
85 };
86
87 class ClientTransChannelCallbackTest : public testing::Test {
88 public:
ClientTransChannelCallbackTest()89 ClientTransChannelCallbackTest() {}
~ClientTransChannelCallbackTest()90 ~ClientTransChannelCallbackTest() {}
91 static void SetUpTestCase(void);
92 static void TearDownTestCase(void);
SetUp()93 void SetUp() override {}
TearDown()94 void TearDown() override {}
95 };
96
SetUpTestCase(void)97 void ClientTransChannelCallbackTest::SetUpTestCase(void)
98 {
99 int32_t ret = ClientTransAuthInit(&g_clientSessionCb);
100 EXPECT_EQ(SOFTBUS_OK, ret);
101
102 ret = ClientTransProxyInit(&g_clientSessionCb);
103 EXPECT_EQ(SOFTBUS_OK, ret);
104
105 ret = ClientTransTdcSetCallBack(&g_clientSessionCb);
106 EXPECT_EQ(SOFTBUS_OK, ret);
107
108 ret = ClientTransUdpMgrInit(&g_clientSessionCb);
109 EXPECT_EQ(SOFTBUS_OK, ret);
110 }
111
TearDownTestCase(void)112 void ClientTransChannelCallbackTest::TearDownTestCase(void) {}
113
114 /**
115 * @tc.name: TransOnChannelOpenTest001
116 * @tc.desc: trans on channel open test, use the wrong or normal parameter.
117 * @tc.type: FUNC
118 * @tc.require:
119 */
120 HWTEST_F(ClientTransChannelCallbackTest, TransOnChannelOpenTest001, TestSize.Level1)
121 {
122 ChannelInfo info = {0};
123 int32_t ret = TransOnChannelOpened(nullptr, &info);
124 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
125
126 ret = TransOnChannelOpened(g_sessionName, nullptr);
127 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
128
129 info.channelType = CHANNEL_TYPE_AUTH;
130 ret = TransOnChannelOpened(g_sessionName, &info);
131 EXPECT_EQ(SOFTBUS_OK, ret);
132
133 info.channelType = CHANNEL_TYPE_PROXY;
134 ret = TransOnChannelOpened(g_sessionName, &info);
135 EXPECT_EQ(SOFTBUS_MEM_ERR, ret);
136
137 info.channelType = CHANNEL_TYPE_TCP_DIRECT;
138 ret = TransOnChannelOpened(g_sessionName, &info);
139 EXPECT_EQ(SOFTBUS_LOCK_ERR, ret);
140
141 info.channelType = CHANNEL_TYPE_UDP;
142 info.isServer = 0;
143 ret = TransOnChannelOpened(g_sessionName, &info);
144 EXPECT_EQ(SOFTBUS_MEM_ERR, ret);
145
146 info.channelType = CHANNEL_TYPE_UDP;
147 info.isServer = 1;
148 ret = TransOnChannelOpened(g_sessionName, &info);
149 EXPECT_EQ(SOFTBUS_OK, ret);
150
151 info.channelType = CHANNEL_TYPE_BUTT;
152 ret = TransOnChannelOpened(g_sessionName, &info);
153 EXPECT_EQ(SOFTBUS_TRANS_INVALID_CHANNEL_TYPE, ret);
154 }
155
156 /**
157 * @tc.name: TransOnChannelOpenFailedTest001
158 * @tc.desc: trans on channel open failed test, use the wrong or normal parameter.
159 * @tc.type: FUNC
160 * @tc.require:
161 */
162 HWTEST_F(ClientTransChannelCallbackTest, TransOnChannelOpenFailedTest001, TestSize.Level1)
163 {
164 int32_t channelId = 1;
165 int32_t ret = TransOnChannelOpenFailed(channelId, CHANNEL_TYPE_AUTH, SOFTBUS_MEM_ERR);
166 EXPECT_EQ(SOFTBUS_OK, ret);
167
168 ret = TransOnChannelOpenFailed(channelId, CHANNEL_TYPE_PROXY, SOFTBUS_MEM_ERR);
169 EXPECT_EQ(SOFTBUS_OK, ret);
170
171 ret = TransOnChannelOpenFailed(channelId, CHANNEL_TYPE_TCP_DIRECT, SOFTBUS_MEM_ERR);
172 EXPECT_EQ(SOFTBUS_OK, ret);
173
174 ret = TransOnChannelOpenFailed(channelId, CHANNEL_TYPE_UDP, SOFTBUS_MEM_ERR);
175 EXPECT_EQ(SOFTBUS_OK, ret);
176
177 ret = TransOnChannelOpenFailed(channelId, CHANNEL_TYPE_UNDEFINED, SOFTBUS_MEM_ERR);
178 EXPECT_EQ(SOFTBUS_OK, ret);
179
180 ret = TransOnChannelOpenFailed(channelId, CHANNEL_TYPE_BUTT, SOFTBUS_MEM_ERR);
181 EXPECT_EQ(SOFTBUS_TRANS_INVALID_CHANNEL_TYPE, ret);
182 }
183
184 /**
185 * @tc.name: TransOnChannelLinkDownTest001
186 * @tc.desc: trans on channel link down test, use the wrong or normal parameter.
187 * @tc.type: FUNC
188 * @tc.require:
189 */
190 HWTEST_F(ClientTransChannelCallbackTest, TransOnChannelLinkDownTest001, TestSize.Level1)
191 {
192 #define PRIVILEGE_CLOSE_CHANNEL 11
193 int32_t ret = TransOnChannelLinkDown(nullptr, 0);
194 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
195
196 ret = TransOnChannelLinkDown(g_networkid, 0);
197 EXPECT_EQ(SOFTBUS_OK, ret);
198
199 ret = TransOnChannelLinkDown(g_networkid, 0 | 1 << PRIVILEGE_CLOSE_CHANNEL);
200 EXPECT_EQ(SOFTBUS_OK, ret);
201 }
202
203 /**
204 * @tc.name: TransOnChannelClosedTest001
205 * @tc.desc: trans on channel closed test, use the wrong or normal parameter.
206 * @tc.type: FUNC
207 * @tc.require:
208 */
209 HWTEST_F(ClientTransChannelCallbackTest, TransOnChannelClosedTest001, TestSize.Level1)
210 {
211 int32_t channelId = 1;
212 int32_t messageType = MESSAGE_TYPE_NOMAL;
213 int32_t udpMessageType = MESSAGE_TYPE_CLOSE_ACK;
214 int32_t ret = TransOnChannelClosed(channelId, CHANNEL_TYPE_AUTH, messageType, SHUTDOWN_REASON_UNKNOWN);
215 EXPECT_EQ(SOFTBUS_OK, ret);
216
217 ret = TransOnChannelClosed(channelId, CHANNEL_TYPE_AUTH, udpMessageType, SHUTDOWN_REASON_UNKNOWN);
218 EXPECT_EQ(SOFTBUS_TRANS_INVALID_CHANNEL_TYPE, ret);
219
220 ret = TransOnChannelClosed(channelId, CHANNEL_TYPE_PROXY, messageType, SHUTDOWN_REASON_UNKNOWN);
221 EXPECT_EQ(SOFTBUS_OK, ret);
222
223 ret = TransOnChannelClosed(channelId, CHANNEL_TYPE_PROXY, udpMessageType, SHUTDOWN_REASON_UNKNOWN);
224 EXPECT_EQ(SOFTBUS_TRANS_INVALID_CHANNEL_TYPE, ret);
225
226 ret = TransOnChannelClosed(channelId, CHANNEL_TYPE_UDP, udpMessageType, SHUTDOWN_REASON_UNKNOWN);
227 EXPECT_EQ(SOFTBUS_TRANS_NODE_NOT_FOUND, ret);
228
229 ret = TransOnChannelClosed(channelId, CHANNEL_TYPE_UDP, messageType, SHUTDOWN_REASON_UNKNOWN);
230 EXPECT_EQ(SOFTBUS_TRANS_UDP_GET_CHANNEL_FAILED, ret);
231
232 ret = TransOnChannelClosed(channelId, CHANNEL_TYPE_TCP_DIRECT, messageType, SHUTDOWN_REASON_UNKNOWN);
233 EXPECT_EQ(SOFTBUS_OK, ret);
234
235 ret = TransOnChannelClosed(channelId, CHANNEL_TYPE_TCP_DIRECT, udpMessageType, SHUTDOWN_REASON_UNKNOWN);
236 EXPECT_EQ(SOFTBUS_TRANS_INVALID_CHANNEL_TYPE, ret);
237
238 ret = TransOnChannelClosed(channelId, CHANNEL_TYPE_BUTT, messageType, SHUTDOWN_REASON_UNKNOWN);
239 EXPECT_EQ(SOFTBUS_TRANS_INVALID_CHANNEL_TYPE, ret);
240
241 ret = TransOnChannelClosed(channelId, CHANNEL_TYPE_TCP_DIRECT, MESSAGE_TYPE_BUTT, SHUTDOWN_REASON_UNKNOWN);
242 EXPECT_EQ(SOFTBUS_TRANS_INVALID_MESSAGE_TYPE, ret);
243 }
244
245 /**
246 * @tc.name: TransOnChannelMsgReceivedTest001
247 * @tc.desc: trans on channel msg received test, use the wrong or normal parameter.
248 * @tc.type: FUNC
249 * @tc.require:
250 */
251 HWTEST_F(ClientTransChannelCallbackTest, TransOnChannelMsgReceivedTest001, TestSize.Level1)
252 {
253 int32_t channelId = 1;
254 const void *data = (const void *)"test";
255
256 int32_t ret = TransOnChannelMsgReceived(channelId, CHANNEL_TYPE_AUTH,
257 nullptr, TEST_DATA_LENGTH, TRANS_SESSION_BYTES);
258 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
259
260 ret = TransOnChannelMsgReceived(channelId, CHANNEL_TYPE_AUTH, data, TEST_DATA_LENGTH, TRANS_SESSION_BYTES);
261 EXPECT_EQ(SOFTBUS_OK, ret);
262
263 ret = TransOnChannelMsgReceived(channelId, CHANNEL_TYPE_PROXY, data, TEST_DATA_LENGTH, TRANS_SESSION_BYTES);
264 EXPECT_EQ(SOFTBUS_TRANS_PROXY_INVALID_CHANNEL_ID, ret);
265
266 ret = TransOnChannelMsgReceived(channelId, CHANNEL_TYPE_TCP_DIRECT, data, TEST_DATA_LENGTH, TRANS_SESSION_BYTES);
267 EXPECT_EQ(SOFTBUS_OK, ret);
268
269 ret = TransOnChannelMsgReceived(channelId, CHANNEL_TYPE_BUTT, data, TEST_DATA_LENGTH, TRANS_SESSION_BYTES);
270 EXPECT_EQ(SOFTBUS_TRANS_INVALID_CHANNEL_TYPE, ret);
271 }
272
273 /**
274 * @tc.name: TransOnChannelQosEventTest001
275 * @tc.desc: trans on channel qos event test, use the wrong or normal parameter.
276 * @tc.type: FUNC
277 * @tc.require:
278 */
279 HWTEST_F(ClientTransChannelCallbackTest, TransOnChannelQosEventTest001, TestSize.Level1)
280 {
281 int32_t channelId = 1;
282 int32_t eventId = 0;
283 int32_t tvCount = 1;
284 const QosTv tvList = {
285 .type = WIFI_CHANNEL_QUALITY,
286 };
287
288 int32_t ret = TransOnChannelQosEvent(channelId, CHANNEL_TYPE_UDP, eventId, tvCount, nullptr);
289 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
290
291 ret = TransOnChannelQosEvent(channelId, CHANNEL_TYPE_UDP, eventId, tvCount, &tvList);
292 EXPECT_EQ(SOFTBUS_TRANS_UDP_GET_CHANNEL_FAILED, ret);
293
294 ret = TransOnChannelQosEvent(channelId, CHANNEL_TYPE_BUTT, eventId, tvCount, &tvList);
295 EXPECT_EQ(SOFTBUS_TRANS_INVALID_CHANNEL_TYPE, ret);
296 }
297
298 /**
299 * @tc.name: TransOnChannelBindTest001
300 * @tc.desc: trans on channel bind test, use the wrong or normal parameter.
301 * @tc.type: FUNC
302 * @tc.require:
303 */
304 HWTEST_F(ClientTransChannelCallbackTest, TransOnChannelBindTest001, TestSize.Level1)
305 {
306 const int32_t channelId = 1;
307 int32_t ret = TransOnChannelBind(channelId, CHANNEL_TYPE_UDP);
308 EXPECT_EQ(SOFTBUS_OK, ret);
309
310 ret = TransOnChannelBind(channelId, CHANNEL_TYPE_TCP_DIRECT);
311 EXPECT_EQ(SOFTBUS_NOT_FIND, ret);
312
313 ret = TransOnChannelBind(channelId, CHANNEL_TYPE_PROXY);
314 EXPECT_EQ(SOFTBUS_OK, ret);
315
316 ret = TransOnChannelBind(channelId, CHANNEL_TYPE_AUTH);
317 EXPECT_EQ(SOFTBUS_OK, ret);
318
319 ret = TransOnChannelBind(channelId, CHANNEL_TYPE_UNDEFINED);
320 EXPECT_EQ(SOFTBUS_OK, ret);
321
322 ret = TransOnChannelBind(channelId, CHANNEL_TYPE_BUTT);
323 EXPECT_EQ(SOFTBUS_TRANS_INVALID_CHANNEL_TYPE, ret);
324 }
325
326 /**
327 * @tc.name: TransOnCheckCollabRelationTest001
328 * @tc.desc: trans on channel bind test, use the wrong or normal parameter.
329 * @tc.type: FUNC
330 * @tc.require:
331 */
332 HWTEST_F(ClientTransChannelCallbackTest, TransOnCheckCollabRelationTest001, TestSize.Level1)
333 {
334 CollabInfo sourceInfo;
335 (void)memset_s(&sourceInfo, sizeof(CollabInfo), 0, sizeof(CollabInfo));
336 CollabInfo sinkInfo;
337 (void)memset_s(&sinkInfo, sizeof(CollabInfo), 0, sizeof(CollabInfo));
338 const int32_t channelId = 1;
339 const int32_t channelType = 1;
340 bool isSinkSide = true;
341 int32_t ret = TransOnCheckCollabRelation(&sourceInfo, isSinkSide, &sinkInfo, channelId, channelType);
342 EXPECT_EQ(SOFTBUS_OK, ret);
343 }
344
345 /**
346 * @tc.name: TransOnCheckCollabRelationTest002
347 * @tc.desc: trans on channel bind test, use the wrong or normal parameter.
348 * @tc.type: FUNC
349 * @tc.require:
350 */
351 HWTEST_F(ClientTransChannelCallbackTest, TransOnCheckCollabRelationTest002, TestSize.Level1)
352 {
353 CollabInfo sourceInfo;
354 (void)memset_s(&sourceInfo, sizeof(CollabInfo), 0, sizeof(CollabInfo));
355 CollabInfo sinkInfo;
356 (void)memset_s(&sinkInfo, sizeof(CollabInfo), 0, sizeof(CollabInfo));
357 const int32_t channelId = 1;
358 const int32_t channelType = 1;
359 bool isSinkSide = false;
360 int32_t ret = TransOnCheckCollabRelation(&sourceInfo, isSinkSide, &sinkInfo, channelId, channelType);
361 EXPECT_EQ(SOFTBUS_NO_INIT, ret);
362 }
363 } // namespace OHOS
364