1 /*
2 * Copyright (c) 2022 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_manager.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 class ClientTransChannelManagerTest : public testing::Test {
35 public:
ClientTransChannelManagerTest()36 ClientTransChannelManagerTest() {}
~ClientTransChannelManagerTest()37 ~ClientTransChannelManagerTest() {}
38 static void SetUpTestCase(void);
39 static void TearDownTestCase(void);
SetUp()40 void SetUp() override {}
TearDown()41 void TearDown() override {}
42 };
43
OnSessionOpened(const char * sessionName,const ChannelInfo * channel,SessionType flag,SocketAccessInfo * accessInfo)44 int32_t OnSessionOpened(
45 const char *sessionName, const ChannelInfo *channel, SessionType flag, SocketAccessInfo *accessInfo)
46 {
47 return SOFTBUS_OK;
48 }
OnSessionClosed(int32_t channelId,int32_t channelType,ShutdownReason reason)49 int32_t OnSessionClosed(int32_t channelId, int32_t channelType, ShutdownReason reason)
50 {
51 return SOFTBUS_OK;
52 }
53
OnSessionOpenFailed(int32_t channelId,int32_t channelType,int32_t errCode)54 int32_t OnSessionOpenFailed(int32_t channelId, int32_t channelType, int32_t errCode)
55 {
56 return SOFTBUS_OK;
57 }
58
OnDataReceived(int32_t channelId,int32_t channelType,const void * data,uint32_t len,SessionPktType type)59 static int32_t OnDataReceived(int32_t channelId, int32_t channelType,
60 const void *data, uint32_t len, SessionPktType type)
61 {
62 return SOFTBUS_OK;
63 }
64
OnStreamReceived(int32_t channelId,int32_t channelType,const StreamData * data,const StreamData * ext,const StreamFrameInfo * param)65 static int32_t OnStreamReceived(int32_t channelId, int32_t channelType, const StreamData *data,
66 const StreamData *ext, const StreamFrameInfo *param)
67 {
68 return SOFTBUS_OK;
69 }
70
OnQosEvent(int32_t channelId,int32_t channelType,int32_t eventId,int32_t tvCount,const QosTv * tvList)71 static int32_t OnQosEvent(int32_t channelId, int32_t channelType, int32_t eventId,
72 int32_t tvCount, const QosTv *tvList)
73 {
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 };
85
SetUpTestCase(void)86 void ClientTransChannelManagerTest::SetUpTestCase(void)
87 {
88 int32_t ret = ClientTransAuthInit(&g_clientSessionCb);
89 EXPECT_EQ(SOFTBUS_OK, ret);
90
91 ret = ClientTransProxyInit(&g_clientSessionCb);
92 EXPECT_EQ(SOFTBUS_OK, ret);
93
94 ret = ClientTransTdcSetCallBack(&g_clientSessionCb);
95 EXPECT_EQ(SOFTBUS_OK, ret);
96
97 ret = ClientTransUdpMgrInit(&g_clientSessionCb);
98 EXPECT_EQ(SOFTBUS_OK, ret);
99 }
TearDownTestCase(void)100 void ClientTransChannelManagerTest::TearDownTestCase(void) {}
101
102 /**
103 * @tc.name: ClientTransCloseChannelTest001
104 * @tc.desc: client trans channel manager test, use the wrong or normal parameter.
105 * @tc.type: FUNC
106 * @tc.require:
107 */
108 HWTEST_F(ClientTransChannelManagerTest, ClientTransCloseChannelTest001, TestSize.Level1)
109 {
110 int32_t channelId = 1;
111 int32_t ret = ClientTransCloseChannel(channelId, CHANNEL_TYPE_PROXY, 1);
112 EXPECT_EQ(SOFTBUS_OK, ret);
113
114 ret = ClientTransCloseChannel(channelId, CHANNEL_TYPE_TCP_DIRECT, 1);
115 EXPECT_EQ(SOFTBUS_OK, ret);
116
117 ret = ClientTransCloseChannel(channelId, CHANNEL_TYPE_AUTH, 1);
118 EXPECT_EQ(SOFTBUS_OK, ret);
119
120 ret = ClientTransCloseChannel(channelId, CHANNEL_TYPE_BUTT, 1);
121 EXPECT_EQ(SOFTBUS_TRANS_INVALID_CHANNEL_TYPE, ret);
122 }
123
124
125 /**
126 * @tc.name: ClientTransChannelSendBytesTest001
127 * @tc.desc: client trans channel send byte test, use the wrong or normal parameter.
128 * @tc.type: FUNC
129 * @tc.require:
130 */
131 HWTEST_F(ClientTransChannelManagerTest, ClientTransChannelSendBytesTest001, TestSize.Level1)
132 {
133 int32_t channelId = 1;
134 const char *data = "test";
135
136 int32_t ret = ClientTransChannelSendBytes(channelId, CHANNEL_TYPE_AUTH, nullptr, TEST_DATA_LENGTH);
137 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
138
139 ret = ClientTransChannelSendBytes(channelId, CHANNEL_TYPE_AUTH, data, 0);
140 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
141
142 ret = ClientTransChannelSendBytes(channelId, CHANNEL_TYPE_AUTH, data, TEST_DATA_LENGTH);
143 EXPECT_EQ(SOFTBUS_TRANS_SESSION_SERVER_NOINIT, ret);
144
145 ret = ClientTransChannelSendBytes(channelId, CHANNEL_TYPE_PROXY, data, TEST_DATA_LENGTH);
146 EXPECT_EQ(SOFTBUS_TRANS_SESSION_SERVER_NOINIT, ret);
147
148 ret = ClientTransChannelSendBytes(channelId, CHANNEL_TYPE_TCP_DIRECT, data, TEST_DATA_LENGTH);
149 EXPECT_EQ(SOFTBUS_TRANS_SESSION_SERVER_NOINIT, ret);
150
151 ret = ClientTransChannelSendBytes(channelId, CHANNEL_TYPE_BUTT, data, TEST_DATA_LENGTH);
152 EXPECT_EQ(SOFTBUS_TRANS_SESSION_SERVER_NOINIT, ret);
153 }
154
155 /**
156 * @tc.name: ClientTransChannelSendMessageTest001
157 * @tc.desc: client trans channel send message test, use the wrong or normal parameter.
158 * @tc.type: FUNC
159 * @tc.require:
160 */
161 HWTEST_F(ClientTransChannelManagerTest, ClientTransChannelSendMessageTest001, TestSize.Level1)
162 {
163 int32_t channelId = 1;
164 const char *data = "test";
165
166 int32_t ret = ClientTransChannelSendMessage(channelId, CHANNEL_TYPE_AUTH, nullptr, TEST_DATA_LENGTH);
167 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
168
169 ret = ClientTransChannelSendMessage(channelId, CHANNEL_TYPE_AUTH, nullptr, 0);
170 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
171
172 ret = ClientTransChannelSendMessage(channelId, CHANNEL_TYPE_AUTH, data, TEST_DATA_LENGTH);
173 EXPECT_EQ(SOFTBUS_PERMISSION_DENIED, ret);
174
175 ret = ClientTransChannelSendMessage(channelId, CHANNEL_TYPE_PROXY, data, TEST_DATA_LENGTH);
176 EXPECT_EQ(SOFTBUS_TRANS_PROXY_CHANNEL_NOT_FOUND, ret);
177
178 ret = ClientTransChannelSendMessage(channelId, CHANNEL_TYPE_TCP_DIRECT, data, TEST_DATA_LENGTH);
179 EXPECT_EQ(SOFTBUS_TRANS_TDC_CHANNEL_NOT_FOUND, ret);
180
181 ret = ClientTransChannelSendMessage(channelId, CHANNEL_TYPE_BUTT, data, TEST_DATA_LENGTH);
182 EXPECT_EQ(SOFTBUS_TRANS_CHANNEL_TYPE_INVALID, ret);
183 }
184
185 /**
186 * @tc.name: ClientTransChannelSendStreamTest001
187 * @tc.desc: client trans channel send stream test, use the wrong or normal parameter.
188 * @tc.type: FUNC
189 * @tc.require:
190 */
191 HWTEST_F(ClientTransChannelManagerTest, ClientTransChannelSendStreamTest001, TestSize.Level1)
192 {
193 int32_t channelId = 1;
194 const StreamData data = {0};
195 const StreamData ext = {0};
196 const StreamFrameInfo param = {0};
197
198 int32_t ret = ClientTransChannelSendStream(channelId, CHANNEL_TYPE_UDP, nullptr, &ext, ¶m);
199 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
200
201 ret = ClientTransChannelSendStream(channelId, CHANNEL_TYPE_UDP, &data, nullptr, ¶m);
202 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
203
204 ret = ClientTransChannelSendStream(channelId, CHANNEL_TYPE_UDP, &data, &ext, nullptr);
205 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
206
207 ret = ClientTransChannelSendStream(channelId, CHANNEL_TYPE_UDP, &data, &ext, ¶m);
208 EXPECT_EQ(SOFTBUS_TRANS_UDP_GET_CHANNEL_FAILED, ret);
209
210 ret = ClientTransChannelSendStream(channelId, CHANNEL_TYPE_BUTT, &data, &ext, ¶m);
211 EXPECT_EQ(SOFTBUS_TRANS_CHANNEL_TYPE_INVALID, ret);
212 }
213
214 /**
215 * @tc.name: ClientTransChannelSendFileTest001
216 * @tc.desc: client trans channel send file test, use the wrong or normal parameter.
217 * @tc.type: FUNC
218 * @tc.require:
219 */
220 HWTEST_F(ClientTransChannelManagerTest, ClientTransChannelSendFileTest001, TestSize.Level1)
221 {
222 int32_t channelId = 1;
223 int32_t fileCnt = 1;
224 const char *sFileList[] = { "/data/test.txt" };
225 const char *dFileList[] = { "/data/test.txt" };
226 int32_t ret = ClientTransChannelSendFile(channelId, CHANNEL_TYPE_UDP, sFileList, dFileList, fileCnt);
227 EXPECT_EQ(SOFTBUS_TRANS_UDP_GET_CHANNEL_FAILED, ret);
228
229 ret = ClientTransChannelSendFile(channelId, CHANNEL_TYPE_PROXY, sFileList, dFileList, fileCnt);
230 EXPECT_EQ(SOFTBUS_TRANS_SESSION_SERVER_NOINIT, ret);
231
232 ret = ClientTransChannelSendFile(channelId, CHANNEL_TYPE_BUTT, sFileList, dFileList, fileCnt);
233 EXPECT_EQ(SOFTBUS_TRANS_CHANNEL_TYPE_INVALID, ret);
234 }
235
236 /**
237 * @tc.name: ClientTransChannelAsyncSendMessageTest001
238 * @tc.desc: client trans channel send async message test, use the wrong or normal parameter.
239 * @tc.type: FUNC
240 * @tc.require:
241 */
242 HWTEST_F(ClientTransChannelManagerTest, ClientTransChannelAsyncSendMessageTest001, TestSize.Level1)
243 {
244 int32_t channelId = 1;
245 const char *data = "test";
246 uint16_t dataSeq = 1;
247
248 int32_t ret = ClientTransChannelAsyncSendMessage(channelId, CHANNEL_TYPE_AUTH, nullptr, TEST_DATA_LENGTH, dataSeq);
249 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
250
251 ret = ClientTransChannelAsyncSendMessage(channelId, CHANNEL_TYPE_AUTH, data, 0, dataSeq);
252 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
253
254 ret = ClientTransChannelAsyncSendMessage(channelId, CHANNEL_TYPE_AUTH, data, TEST_DATA_LENGTH, 0);
255 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
256
257 ret = ClientTransChannelAsyncSendMessage(channelId, CHANNEL_TYPE_PROXY, data, TEST_DATA_LENGTH, dataSeq);
258 EXPECT_EQ(SOFTBUS_TRANS_PROXY_CHANNEL_NOT_FOUND, ret);
259
260 ret = ClientTransChannelAsyncSendMessage(channelId, CHANNEL_TYPE_TCP_DIRECT, data, TEST_DATA_LENGTH, dataSeq);
261 EXPECT_EQ(SOFTBUS_TRANS_INVALID_CHANNEL_TYPE, ret);
262 }
263 } // namespace OHOS