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