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_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_errcode.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)41 int32_t OnSessionClosed(int32_t channelId, int32_t channelType)
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
69 static IClientSessionCallBack g_clientSessionCb = {
70 .OnSessionOpened = OnSessionOpened,
71 .OnSessionClosed = OnSessionClosed,
72 .OnSessionOpenFailed = OnSessionOpenFailed,
73 .OnDataReceived = OnDataReceived,
74 .OnStreamReceived = OnStreamReceived,
75 .OnQosEvent = OnQosEvent,
76 };
77
78 class ClientTransChannelCallbackTest : public testing::Test {
79 public:
ClientTransChannelCallbackTest()80 ClientTransChannelCallbackTest() {}
~ClientTransChannelCallbackTest()81 ~ClientTransChannelCallbackTest() {}
82 static void SetUpTestCase(void);
83 static void TearDownTestCase(void);
SetUp()84 void SetUp() override {}
TearDown()85 void TearDown() override {}
86 };
87
SetUpTestCase(void)88 void ClientTransChannelCallbackTest::SetUpTestCase(void)
89 {
90 int ret = ClientTransAuthInit(&g_clientSessionCb);
91 EXPECT_EQ(SOFTBUS_OK, ret);
92
93 ret = ClinetTransProxyInit(&g_clientSessionCb);
94 EXPECT_EQ(SOFTBUS_OK, ret);
95
96 ret = ClientTransTdcSetCallBack(&g_clientSessionCb);
97 EXPECT_EQ(SOFTBUS_OK, ret);
98
99 ret = ClientTransUdpMgrInit(&g_clientSessionCb);
100 EXPECT_EQ(SOFTBUS_OK, ret);
101 }
102
TearDownTestCase(void)103 void ClientTransChannelCallbackTest::TearDownTestCase(void) {}
104
105 /**
106 * @tc.name: TransOnChannelOpenTest001
107 * @tc.desc: trans on channel open test, use the wrong or normal parameter.
108 * @tc.type: FUNC
109 * @tc.require:
110 */
111 HWTEST_F(ClientTransChannelCallbackTest, TransOnChannelOpenTest001, TestSize.Level0)
112 {
113 ChannelInfo info = {0};
114 int ret = TransOnChannelOpened(nullptr, &info);
115 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
116
117 info.channelType = CHANNEL_TYPE_AUTH;
118 ret = TransOnChannelOpened(g_sessionName, &info);
119 EXPECT_EQ(SOFTBUS_OK, ret);
120
121 info.channelType = CHANNEL_TYPE_PROXY;
122 ret = TransOnChannelOpened(g_sessionName, &info);
123 EXPECT_EQ(SOFTBUS_OK, ret);
124
125 info.channelType = CHANNEL_TYPE_TCP_DIRECT;
126 ret = TransOnChannelOpened(g_sessionName, &info);
127 EXPECT_EQ(SOFTBUS_ERR, ret);
128
129 info.channelType = CHANNEL_TYPE_UDP;
130 info.isServer = 0;
131 ret = TransOnChannelOpened(g_sessionName, &info);
132 EXPECT_EQ(SOFTBUS_MEM_ERR, ret);
133
134 info.channelType = CHANNEL_TYPE_UDP;
135 info.isServer = 1;
136 ret = TransOnChannelOpened(g_sessionName, &info);
137 EXPECT_EQ(SOFTBUS_OK, ret);
138
139 info.channelType = CHANNEL_TYPE_BUTT;
140 ret = TransOnChannelOpened(g_sessionName, &info);
141 EXPECT_EQ(SOFTBUS_TRANS_INVALID_CHANNEL_TYPE, ret);
142 }
143
144 /**
145 * @tc.name: TransOnChannelOpenFailedTest001
146 * @tc.desc: trans on channel open failed test, use the wrong or normal parameter.
147 * @tc.type: FUNC
148 * @tc.require:
149 */
150 HWTEST_F(ClientTransChannelCallbackTest, TransOnChannelOpenFailedTest001, TestSize.Level0)
151 {
152 int channelId = 1;
153 int ret = TransOnChannelOpenFailed(channelId, CHANNEL_TYPE_AUTH, SOFTBUS_ERR);
154 EXPECT_EQ(SOFTBUS_OK, ret);
155
156 ret = TransOnChannelOpenFailed(channelId, CHANNEL_TYPE_PROXY, SOFTBUS_ERR);
157 EXPECT_EQ(SOFTBUS_OK, ret);
158
159 ret = TransOnChannelOpenFailed(channelId, CHANNEL_TYPE_TCP_DIRECT, SOFTBUS_ERR);
160 EXPECT_EQ(SOFTBUS_OK, ret);
161
162 ret = TransOnChannelOpenFailed(channelId, CHANNEL_TYPE_UDP, SOFTBUS_ERR);
163 EXPECT_EQ(SOFTBUS_OK, ret);
164
165 ret = TransOnChannelOpenFailed(channelId, CHANNEL_TYPE_BUTT, SOFTBUS_ERR);
166 EXPECT_EQ(SOFTBUS_TRANS_INVALID_CHANNEL_TYPE, ret);
167 }
168
169 /**
170 * @tc.name: TransOnChannelLinkDownTest001
171 * @tc.desc: trans on channel link down test, use the wrong or normal parameter.
172 * @tc.type: FUNC
173 * @tc.require:
174 */
175 HWTEST_F(ClientTransChannelCallbackTest, TransOnChannelLinkDownTest001, TestSize.Level0)
176 {
177 int ret = TransOnChannelLinkDown(nullptr, 0);
178 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
179
180 ret = TransOnChannelLinkDown(g_networkid, 0);
181 EXPECT_EQ(SOFTBUS_OK, ret);
182 }
183
184 /**
185 * @tc.name: TransOnChannelClosedTest001
186 * @tc.desc: trans on channel closed test, use the wrong or normal parameter.
187 * @tc.type: FUNC
188 * @tc.require:
189 */
190 HWTEST_F(ClientTransChannelCallbackTest, TransOnChannelClosedTest001, TestSize.Level0)
191 {
192 int channelId = 1;
193 int ret = TransOnChannelClosed(channelId, CHANNEL_TYPE_AUTH);
194 EXPECT_EQ(SOFTBUS_OK, ret);
195
196 ret = TransOnChannelClosed(channelId, CHANNEL_TYPE_PROXY);
197 EXPECT_EQ(SOFTBUS_OK, ret);
198
199 ret = TransOnChannelClosed(channelId, CHANNEL_TYPE_UDP);
200 EXPECT_EQ(SOFTBUS_ERR, ret);
201
202 ret = TransOnChannelClosed(channelId, CHANNEL_TYPE_TCP_DIRECT);
203 EXPECT_EQ(SOFTBUS_TRANS_INVALID_CHANNEL_TYPE, ret);
204 }
205
206 /**
207 * @tc.name: TransOnChannelMsgReceivedTest001
208 * @tc.desc: trans on channel msg received test, use the wrong or normal parameter.
209 * @tc.type: FUNC
210 * @tc.require:
211 */
212 HWTEST_F(ClientTransChannelCallbackTest, TransOnChannelMsgReceivedTest001, TestSize.Level0)
213 {
214 int channelId = 1;
215 const void *data = (const void *)"test";
216 int ret = TransOnChannelMsgReceived(channelId, CHANNEL_TYPE_AUTH, data, TEST_DATA_LENGTH, TRANS_SESSION_BYTES);
217 EXPECT_EQ(SOFTBUS_OK, ret);
218
219 ret = TransOnChannelMsgReceived(channelId, CHANNEL_TYPE_PROXY, data, TEST_DATA_LENGTH, TRANS_SESSION_BYTES);
220 EXPECT_EQ(SOFTBUS_OK, ret);
221
222 ret = TransOnChannelMsgReceived(channelId, CHANNEL_TYPE_BUTT, data, TEST_DATA_LENGTH, TRANS_SESSION_BYTES);
223 EXPECT_EQ(SOFTBUS_TRANS_INVALID_CHANNEL_TYPE, ret);
224 }
225
226 /**
227 * @tc.name: TransOnChannelQosEventTest001
228 * @tc.desc: trans on channel qos event test, use the wrong or normal parameter.
229 * @tc.type: FUNC
230 * @tc.require:
231 */
232 HWTEST_F(ClientTransChannelCallbackTest, TransOnChannelQosEventTest001, TestSize.Level0)
233 {
234 int channelId = 1;
235 int32_t eventId = 0;
236 int32_t tvCount = 1;
237 const QosTv tvList = {
238 .type = WIFI_CHANNEL_QUALITY,
239 };
240 int ret = TransOnChannelQosEvent(channelId, CHANNEL_TYPE_UDP, eventId, tvCount, &tvList);
241 EXPECT_EQ(SOFTBUS_ERR, ret);
242
243 ret = TransOnChannelQosEvent(channelId, CHANNEL_TYPE_BUTT, eventId, tvCount, &tvList);
244 EXPECT_EQ(SOFTBUS_TRANS_INVALID_CHANNEL_TYPE, ret);
245 }
246 } // namespace OHOS