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_proxy_manager.h"
20 #include "session.h"
21 #include "softbus_def.h"
22 #include "softbus_errcode.h"
23 #include "softbus_access_token_test.h"
24 #include "client_trans_proxy_file_manager.h"
25
26 #define TEST_CHANNEL_ID (-10)
27 #define TEST_ERR_CODE (-1)
28 #define TEST_DATA "testdata"
29 #define TEST_DATA_LENGTH 9
30 #define TEST_FILE_CNT 4
31
32 using namespace std;
33 using namespace testing::ext;
34
35 namespace OHOS {
36 const char *g_proxyPkgName = "dms";
37 const char *g_proxySessionName = "ohos.distributedschedule.dms.test";
38 const char *g_testProxyFileName[] = {
39 "/data/test.txt",
40 "/data/ss.txt",
41 "/data/test.tar",
42 "/data/test.mp3",
43 };
44 const char *g_proxyFileSet[] = {
45 "/data/data/test.txt",
46 "/path/max/length/512/"
47 "11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111"
48 "11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111"
49 "11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111"
50 "11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111"
51 "111111111111111111111111111111111111111111111111111",
52 "ss",
53 "/data/ss",
54 };
55
56 class ClientTransProxyManagerTest : public testing::Test {
57 public:
ClientTransProxyManagerTest()58 ClientTransProxyManagerTest() {}
~ClientTransProxyManagerTest()59 ~ClientTransProxyManagerTest() {}
60 static void SetUpTestCase(void);
61 static void TearDownTestCase(void);
SetUp()62 void SetUp() override {}
TearDown()63 void TearDown() override {}
64 };
65
SetUpTestCase(void)66 void ClientTransProxyManagerTest::SetUpTestCase(void)
67 {
68 SetAceessTokenPermission("dsoftbusTransTest");
69 }
TearDownTestCase(void)70 void ClientTransProxyManagerTest::TearDownTestCase(void) {}
71
TransOnSessionOpened(const char * sessionName,const ChannelInfo * channel,SessionType flag)72 int32_t TransOnSessionOpened(const char *sessionName, const ChannelInfo *channel, SessionType flag)
73 {
74 return SOFTBUS_OK;
75 }
76
TransOnSessionClosed(int32_t channelId,int32_t channelType)77 int32_t TransOnSessionClosed(int32_t channelId, int32_t channelType)
78 {
79 return SOFTBUS_OK;
80 }
81
TransOnSessionOpenFailed(int32_t channelId,int32_t channelType,int32_t errCode)82 int32_t TransOnSessionOpenFailed(int32_t channelId, int32_t channelType, int32_t errCode)
83 {
84 return SOFTBUS_OK;
85 }
86
TransOnBytesReceived(int32_t channelId,int32_t channelType,const void * data,uint32_t len,SessionPktType type)87 int32_t TransOnBytesReceived(int32_t channelId, int32_t channelType,
88 const void *data, uint32_t len, SessionPktType type)
89 {
90 return SOFTBUS_OK;
91 }
92
TransOnOnStreamRecevied(int32_t channelId,int32_t channelType,const StreamData * data,const StreamData * ext,const StreamFrameInfo * param)93 int32_t TransOnOnStreamRecevied(int32_t channelId, int32_t channelType,
94 const StreamData *data, const StreamData *ext, const StreamFrameInfo *param)
95 {
96 return SOFTBUS_OK;
97 }
98
TransOnGetSessionId(int32_t channelId,int32_t channelType,int32_t * sessionId)99 int32_t TransOnGetSessionId(int32_t channelId, int32_t channelType, int32_t *sessionId)
100 {
101 return SOFTBUS_OK;
102 }
TransOnQosEvent(int32_t channelId,int32_t channelType,int32_t eventId,int32_t tvCount,const QosTv * tvList)103 int32_t TransOnQosEvent(int32_t channelId, int32_t channelType, int32_t eventId,
104 int32_t tvCount, const QosTv *tvList)
105 {
106 return SOFTBUS_OK;
107 }
108
OnSessionOpened(int sessionId,int result)109 static int OnSessionOpened(int sessionId, int result)
110 {
111 return SOFTBUS_OK;
112 }
113
OnSessionClosed(int sessionId)114 static void OnSessionClosed(int sessionId)
115 {
116 }
117
OnBytesReceived(int sessionId,const void * data,unsigned int len)118 static void OnBytesReceived(int sessionId, const void *data, unsigned int len)
119 {
120 }
121
OnMessageReceived(int sessionId,const void * data,unsigned int len)122 static void OnMessageReceived(int sessionId, const void *data, unsigned int len)
123 {
124 }
125
126 static ISessionListener g_sessionlistener = {
127 .OnSessionOpened = OnSessionOpened,
128 .OnSessionClosed = OnSessionClosed,
129 .OnBytesReceived = OnBytesReceived,
130 .OnMessageReceived = OnMessageReceived,
131 };
132
133 /**
134 * @tc.name: ClinetTransProxyInitTest
135 * @tc.desc: client trans proxy init test, use the wrong or normal parameter.
136 * @tc.type: FUNC
137 * @tc.require:
138 */
139 HWTEST_F(ClientTransProxyManagerTest, ClinetTransProxyInitTest, TestSize.Level0)
140 {
141 IClientSessionCallBack cb;
142 cb.OnSessionOpened = TransOnSessionOpened;
143 cb.OnSessionClosed = TransOnSessionClosed;
144 cb.OnSessionOpenFailed = TransOnSessionOpenFailed;
145 cb.OnDataReceived = TransOnBytesReceived;
146 cb.OnStreamReceived = TransOnOnStreamRecevied;
147 cb.OnGetSessionId = TransOnGetSessionId;
148 cb.OnQosEvent = TransOnQosEvent;
149
150 int ret = ClinetTransProxyInit(nullptr);
151 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
152
153 ret = ClinetTransProxyInit(&cb);
154 EXPECT_EQ(SOFTBUS_OK, ret);
155 }
156
157 /**
158 * @tc.name: ClientTransProxyOnChannelOpenedTest
159 * @tc.desc: client trans proxy on channel opened test, use the wrong or normal parameter.
160 * @tc.type: FUNC
161 * @tc.require:
162 */
163 HWTEST_F(ClientTransProxyManagerTest, ClientTransProxyOnChannelOpenedTest, TestSize.Level0)
164 {
165 int ret = ClientTransProxyOnChannelOpened(g_proxySessionName, nullptr);
166 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
167
168 ChannelInfo channelInfo = {0};
169 ret = ClientTransProxyOnChannelOpened(g_proxySessionName, &channelInfo);
170 EXPECT_NE(SOFTBUS_ERR, ret);
171
172 ret = CreateSessionServer(g_proxyPkgName, g_proxySessionName, &g_sessionlistener);
173 EXPECT_EQ(SOFTBUS_OK, ret);
174
175 ret = ClientTransProxyOnChannelOpened(g_proxySessionName, &channelInfo);
176 EXPECT_EQ(SOFTBUS_OK, ret);
177
178 ret = RemoveSessionServer(g_proxyPkgName, g_proxySessionName);
179 EXPECT_EQ(SOFTBUS_OK, ret);
180 }
181
182 /**
183 * @tc.name: ClientTransProxyOnChannelClosedTest
184 * @tc.desc: client trans proxy on channel closed test, use the normal parameter.
185 * @tc.type: FUNC
186 * @tc.require:
187 */
188 HWTEST_F(ClientTransProxyManagerTest, ClientTransProxyOnChannelClosedTest, TestSize.Level0)
189 {
190 int32_t channelId = 1;
191 int ret = ClientTransProxyOnChannelClosed(channelId);
192 EXPECT_EQ(SOFTBUS_OK, ret);
193
194 ret = CreateSessionServer(g_proxyPkgName, g_proxySessionName, &g_sessionlistener);
195 EXPECT_EQ(SOFTBUS_OK, ret);
196
197 ret = ClientTransProxyOnChannelClosed(channelId);
198 EXPECT_EQ(SOFTBUS_OK, ret);
199
200 ret = RemoveSessionServer(g_proxyPkgName, g_proxySessionName);
201 EXPECT_EQ(SOFTBUS_OK, ret);
202 }
203
204 /**
205 * @tc.name: ClientTransProxyOnChannelOpenFailedTest
206 * @tc.desc: client trans proxy on channel open failed test, use the normal parameter.
207 * @tc.type: FUNC
208 * @tc.require:
209 */
210 HWTEST_F(ClientTransProxyManagerTest, ClientTransProxyOnChannelOpenFailedTest, TestSize.Level0)
211 {
212 int32_t channelId = 1;
213 int ret = ClientTransProxyOnChannelOpenFailed(channelId, TEST_ERR_CODE);
214 EXPECT_EQ(SOFTBUS_OK, ret);
215
216 ret = CreateSessionServer(g_proxyPkgName, g_proxySessionName, &g_sessionlistener);
217 EXPECT_EQ(SOFTBUS_OK, ret);
218
219 ret = ClientTransProxyOnChannelOpenFailed(channelId, TEST_ERR_CODE);
220 EXPECT_EQ(SOFTBUS_OK, ret);
221
222 ret = RemoveSessionServer(g_proxyPkgName, g_proxySessionName);
223 EXPECT_EQ(SOFTBUS_OK, ret);
224 }
225
226 /**
227 * @tc.name: ClientTransProxyOnDataReceivedTest
228 * @tc.desc: client trans proxy on data received test, use the wrong or normal parameter.
229 * @tc.type: FUNC
230 * @tc.require:
231 */
232 HWTEST_F(ClientTransProxyManagerTest, ClientTransProxyOnDataReceivedTest, TestSize.Level0)
233 {
234 int32_t channelId = 1;
235 int ret = ClientTransProxyOnDataReceived(channelId, nullptr, TEST_DATA_LENGTH, TRANS_SESSION_BYTES);
236 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
237
238 ret = ClientTransProxyOnDataReceived(channelId, TEST_DATA, TEST_DATA_LENGTH, TRANS_SESSION_BYTES);
239 EXPECT_EQ(SOFTBUS_OK, ret);
240
241 ret = CreateSessionServer(g_proxyPkgName, g_proxySessionName, &g_sessionlistener);
242 EXPECT_EQ(SOFTBUS_OK, ret);
243
244 ret = ClientTransProxyOnDataReceived(channelId, TEST_DATA, TEST_DATA_LENGTH, TRANS_SESSION_BYTES);
245 EXPECT_EQ(SOFTBUS_OK, ret);
246
247 ret = RemoveSessionServer(g_proxyPkgName, g_proxySessionName);
248 EXPECT_EQ(SOFTBUS_OK, ret);
249 }
250
251 /**
252 * @tc.name: ClientTransProxyCloseChannelTest
253 * @tc.desc: client trans proxy close channel test, use the normal parameter.
254 * @tc.type: FUNC
255 * @tc.require:
256 */
257 HWTEST_F(ClientTransProxyManagerTest, ClientTransProxyCloseChannelTest, TestSize.Level0)
258 {
259 int32_t channelId = 1;
260 ClientTransProxyCloseChannel(TEST_CHANNEL_ID);
261
262 int ret = CreateSessionServer(g_proxyPkgName, g_proxySessionName, &g_sessionlistener);
263 EXPECT_EQ(SOFTBUS_OK, ret);
264
265 ClientTransProxyCloseChannel(channelId);
266
267 ret = RemoveSessionServer(g_proxyPkgName, g_proxySessionName);
268 EXPECT_EQ(SOFTBUS_OK, ret);
269 }
270
271 /**
272 * @tc.name: TransProxyChannelSendFileTest
273 * @tc.desc: trans proxy channel send file test, use the wrong parameter.
274 * @tc.type: FUNC
275 * @tc.require:
276 */
277 HWTEST_F(ClientTransProxyManagerTest, TransProxyChannelSendFileTest, TestSize.Level0)
278 {
279 int32_t channelId = 1;
280 int ret = TransProxyChannelSendFile(channelId, nullptr, g_proxyFileSet, TEST_FILE_CNT);
281 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
282
283 ret = TransProxyChannelSendFile(channelId, g_testProxyFileName, g_proxyFileSet, MAX_SEND_FILE_NUM + TEST_FILE_CNT);
284 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
285
286 ret = TransProxyChannelSendFile(channelId, g_testProxyFileName, nullptr, TEST_FILE_CNT);
287 EXPECT_EQ(SOFTBUS_ERR, ret);
288
289 ret = TransProxyChannelSendFile(channelId, g_testProxyFileName, g_proxyFileSet, TEST_FILE_CNT);
290 EXPECT_EQ(SOFTBUS_ERR, ret);
291 }
292 } // namespace OHOS