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