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 <securec.h>
17
18 #include <gtest/gtest.h>
19 #include "softbus_def.h"
20 #include "softbus_errcode.h"
21 #include "softbus_log.h"
22 #include "softbus_trans_def.h"
23 #include "softbus_app_info.h"
24 #include "softbus_server_frame.h"
25 #include "softbus_adapter_mem.h"
26 #include "client_trans_session_manager.h"
27 #include "client_trans_session_service.h"
28 #include "softbus_config_type.h"
29
30 #define TRANS_TEST_SESSION_ID 10
31 #define TRANS_TEST_PID 0
32 #define TRANS_TEST_UID 0
33 #define TRANS_TEST_CHANNEL_ID 12345
34 #define TRANS_TEST_FILE_ENCRYPT 10
35 #define TRANS_TEST_ALGORITHM 1
36 #define TRANS_TEST_CRC 1
37 #define TRANS_TEST_STATE 1
38
39 #define TRANS_TEST_INVALID_PID (-1)
40 #define TRANS_TEST_INVALID_UID (-1)
41 #define TRANS_TEST_INVALID_QUALITY (-1)
42 #define TRANS_TEST_INVALID_CHANNEL_ID (-1)
43 #define TRANS_TEST_INVALID_SESSION_ID (-1)
44
45 #define MAX_SESSION_SERVER_NUM 32
46
47 using namespace testing::ext;
48
49 namespace OHOS {
50
51 const char *g_pkgName = "dms";
52 const char *g_sessionName = "ohos.distributedschedule.dms.test";
53 const char *g_networkId = "ABCDEF00ABCDEF00ABCDEF00ABCDEF00ABCDEF00ABCDEF00ABCDEF00ABCDEF0";
54 const char *g_deviceId = "ABCDEF00ABCDEF00ABCDEF00ABCDEF00ABCDEF00ABCDEF00ABCDEF00ABCDEF0";
55 const char *g_groupid = "TEST_GROUP_ID";
56 static SessionAttribute g_sessionAttr = {
57 .dataType = TYPE_BYTES,
58 };
59 class TransClientSessionServiceTest : public testing::Test {
60 public:
TransClientSessionServiceTest()61 TransClientSessionServiceTest()
62 {}
~TransClientSessionServiceTest()63 ~TransClientSessionServiceTest()
64 {}
65 static void SetUpTestCase(void);
66 static void TearDownTestCase(void);
SetUp()67 void SetUp() override
68 {}
TearDown()69 void TearDown() override
70 {}
71 };
72
SetUpTestCase(void)73 void TransClientSessionServiceTest::SetUpTestCase(void)
74 {
75 InitSoftBusServer();
76 }
77
TearDownTestCase(void)78 void TransClientSessionServiceTest::TearDownTestCase(void)
79 {
80 }
81
OnSessionOpened(int sessionId,int result)82 static int OnSessionOpened(int sessionId, int result)
83 {
84 LOG_INFO("session opened,sesison id = %d\r\n", sessionId);
85 return SOFTBUS_OK;
86 }
87
OnSessionClosed(int sessionId)88 static void OnSessionClosed(int sessionId)
89 {
90 LOG_INFO("session closed, session id = %d\r\n", sessionId);
91 }
92
OnBytesReceived(int sessionId,const void * data,unsigned int len)93 static void OnBytesReceived(int sessionId, const void *data, unsigned int len)
94 {
95 LOG_INFO("session bytes received, session id = %d\r\n", sessionId);
96 }
97
OnMessageReceived(int sessionId,const void * data,unsigned int len)98 static void OnMessageReceived(int sessionId, const void *data, unsigned int len)
99 {
100 LOG_INFO("session msg received, session id = %d\r\n", sessionId);
101 }
102
103 static ISessionListener g_sessionlistener = {
104 .OnSessionOpened = OnSessionOpened,
105 .OnSessionClosed = OnSessionClosed,
106 .OnBytesReceived = OnBytesReceived,
107 .OnMessageReceived = OnMessageReceived,
108 };
109
GenerateSession(const SessionParam * param)110 static SessionInfo *GenerateSession(const SessionParam *param)
111 {
112 SessionInfo *session = (SessionInfo*)SoftBusMalloc(sizeof(SessionInfo));
113 EXPECT_TRUE(session != NULL);
114 memset_s(session, sizeof(SessionInfo), 0, sizeof(SessionInfo));
115
116 int ret = strcpy_s(session->info.peerSessionName, SESSION_NAME_SIZE_MAX, param->peerSessionName);
117 EXPECT_EQ(ret, EOK);
118
119 ret = strcpy_s(session->info.peerDeviceId, DEVICE_ID_SIZE_MAX, param->peerDeviceId);
120 EXPECT_EQ(ret, EOK);
121
122 ret = strcpy_s(session->info.groupId, GROUP_ID_SIZE_MAX, param->groupId);
123 EXPECT_EQ(ret, EOK);
124
125 session->sessionId = INVALID_SESSION_ID;
126 session->channelId = INVALID_CHANNEL_ID;
127 session->channelType = CHANNEL_TYPE_BUTT;
128 session->isServer = false;
129 session->isEnable = false;
130 session->routeType = ROUTE_TYPE_ALL;
131 session->info.flag = TYPE_BYTES;
132 session->isEncrypt = true;
133 session->algorithm = TRANS_TEST_ALGORITHM;
134 session->fileEncrypt = TRANS_TEST_FILE_ENCRYPT;
135 session->crc = TRANS_TEST_CRC;
136
137 return session;
138 }
GenerateCommParam(SessionParam * sessionParam)139 static void GenerateCommParam(SessionParam *sessionParam)
140 {
141 sessionParam->sessionName = g_sessionName;
142 sessionParam->peerSessionName = g_sessionName;
143 sessionParam->peerDeviceId = g_deviceId;
144 sessionParam->groupId = g_groupid;
145 sessionParam->attr = &g_sessionAttr;
146 }
147
148 /**
149 * @tc.name: TransClientSessionServiceTest01
150 * @tc.desc: Transmission sdk session service qos report and open session synchronize with invalid parameters.
151 * @tc.type: FUNC
152 * @tc.require:
153 */
154 HWTEST_F(TransClientSessionServiceTest, TransClientSessionServiceTest01, TestSize.Level1)
155 {
156 int32_t ret = QosReport(TRANS_TEST_SESSION_ID, APP_TYPE_AUTH, TRANS_TEST_INVALID_QUALITY);
157 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
158 ret = QosReport(TRANS_TEST_SESSION_ID, APP_TYPE_AUTH, QOS_IMPROVE);
159 EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_SERVER_NOINIT);
160 ret = OpenSessionSync(NULL, g_sessionName, g_networkId, g_groupid, &g_sessionAttr);
161 EXPECT_EQ(ret, INVALID_SESSION_ID);
162 ret = OpenSessionSync(g_sessionName, NULL, g_networkId, g_groupid, &g_sessionAttr);
163 EXPECT_EQ(ret, INVALID_SESSION_ID);
164 ret = OpenSessionSync(g_sessionName, g_sessionName, NULL, g_groupid, &g_sessionAttr);
165 EXPECT_EQ(ret, INVALID_SESSION_ID);
166 ret = OpenSessionSync(g_sessionName, g_sessionName, g_networkId, NULL, &g_sessionAttr);
167 EXPECT_EQ(ret, INVALID_SESSION_ID);
168 ret = OpenSessionSync(g_sessionName, g_sessionName, g_networkId, g_groupid, NULL);
169 EXPECT_EQ(ret, INVALID_SESSION_ID);
170 ret = OpenSessionSync(g_sessionName, g_sessionName, g_networkId, g_groupid, &g_sessionAttr);
171 EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_SERVER_NOINIT);
172 }
173
174 /**
175 * @tc.name: TransClientSessionServiceTest02
176 * @tc.desc: Transmission sdk session service qos report.
177 * @tc.type: FUNC
178 * @tc.require:
179 */
180 HWTEST_F(TransClientSessionServiceTest, TransClientSessionServiceTest02, TestSize.Level1)
181 {
182 int32_t ret = TransClientInit();
183 EXPECT_EQ(ret, SOFTBUS_OK);
184 ret = ClientAddSessionServer(SEC_TYPE_PLAINTEXT, g_pkgName, g_sessionName, &g_sessionlistener);
185 EXPECT_EQ(ret, SOFTBUS_OK);
186 SessionParam *sessionParam = (SessionParam*)SoftBusMalloc(sizeof(SessionParam));
187 EXPECT_TRUE(sessionParam != NULL);
188 memset_s(sessionParam, sizeof(SessionParam), 0, sizeof(SessionParam));
189 GenerateCommParam(sessionParam);
190 SessionInfo *session = GenerateSession(sessionParam);
191 session->channelId = TRANS_TEST_CHANNEL_ID;
192 session->channelType = CHANNEL_TYPE_UDP;
193 session->isServer = true;
194 ret = ClientAddNewSession(g_sessionName, session);
195 EXPECT_EQ(ret, SOFTBUS_OK);
196 int32_t sessionId = 0;
197 ret = ClientGetSessionIdByChannelId(TRANS_TEST_CHANNEL_ID, CHANNEL_TYPE_UDP, &sessionId);
198 EXPECT_EQ(ret, SOFTBUS_OK);
199 ret = QosReport(sessionId, APP_TYPE_AUTH, QOS_IMPROVE);
200 EXPECT_EQ(ret, SOFTBUS_TRANS_INVALID_SESSION_ID);
201 ret = ClientDeleteSession(sessionId);
202 EXPECT_EQ(ret, SOFTBUS_OK);
203 session = GenerateSession(sessionParam);
204 session->channelId = TRANS_TEST_CHANNEL_ID;
205 session->channelType = CHANNEL_TYPE_UDP;
206 ret = ClientAddNewSession(g_sessionName, session);
207 EXPECT_EQ(ret, SOFTBUS_OK);
208 ret = ClientGetSessionIdByChannelId(TRANS_TEST_CHANNEL_ID, CHANNEL_TYPE_UDP, &sessionId);
209 EXPECT_EQ(ret, SOFTBUS_OK);
210 ret = QosReport(sessionId, APP_TYPE_AUTH, QOS_IMPROVE);
211 EXPECT_EQ(ret, SOFTBUS_ERR);
212 ret = ClientDeleteSessionServer(SEC_TYPE_PLAINTEXT, g_sessionName);
213 EXPECT_EQ(ret, SOFTBUS_OK);
214 SoftBusFree(sessionParam);
215 }
216
217 /**
218 * @tc.name: TransClientSessionServiceTest03
219 * @tc.desc: Transmission sdk session service open session synchronize.
220 * @tc.type: FUNC
221 * @tc.require:
222 */
223 HWTEST_F(TransClientSessionServiceTest, TransClientSessionServiceTest03, TestSize.Level1)
224 {
225 int32_t sessionId = 0;
226 bool isEnabled = false;
227 SessionParam *sessionParam = (SessionParam*)SoftBusMalloc(sizeof(SessionParam));
228 EXPECT_TRUE(sessionParam != NULL);
229 memset_s(sessionParam, sizeof(SessionParam), 0, sizeof(SessionParam));
230 GenerateCommParam(sessionParam);
231 int32_t ret = ClientAddSessionServer(SEC_TYPE_PLAINTEXT, g_pkgName, g_sessionName, &g_sessionlistener);
232 EXPECT_EQ(ret, SOFTBUS_OK);
233 ret = ClientAddSession(sessionParam, &sessionId, &isEnabled);
234 EXPECT_EQ(ret, SOFTBUS_OK);
235 ret = OpenSessionSync(g_sessionName, g_sessionName, g_networkId, g_groupid, &g_sessionAttr);
236 EXPECT_EQ(ret, sessionId);
237 ret = ClientDeleteSession(sessionId);
238 EXPECT_EQ(ret, SOFTBUS_OK);
239 ret = OpenSessionSync(g_sessionName, g_sessionName, g_networkId, g_groupid, &g_sessionAttr);
240 EXPECT_TRUE(ret != SOFTBUS_OK);
241 ret = ClientDeleteSessionServer(SEC_TYPE_PLAINTEXT, g_sessionName);
242 EXPECT_EQ(ret, SOFTBUS_OK);
243 SoftBusFree(sessionParam);
244 }
245
246 }
247