1 /*
2 * Copyright (c) 2024 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 <string>
17 #include <gtest/gtest.h>
18 #include <securec.h>
19
20 #include "client_trans_socket_option.h"
21 #include "inner_socket.h"
22 #include "socket.h"
23 #include "softbus_error_code.h"
24
25 #define SOCKET_NAME_MAX_LEN 255
26 #define SOCKET_NAME_INVALID_LEN (SOCKET_NAME_MAX_LEN + 1)
27 #define SOCKET_PKG_NAME_MAX_LEN 64
28 #define SOCKET_PKG_NAME_INVALID_LEN (SOCKET_PKG_NAME_MAX_LEN + 1)
29 #define SOCKET_NETWORKID_MAX_LEN 64
30 #define SOCKET_NETWORKID_INVALID_LEN (SOCKET_NETWORKID_MAX_LEN + 1)
31 #define DATA_LENS 32
32 #define INVALID_VALUE (-1)
33
34 using namespace testing::ext;
35 namespace OHOS {
36 static std::string g_pkgName = "dms";
37 static std::string g_socketName = "ohos.distributedschedule.dms.test.client";
38 static std::string g_socketPeerName = "ohos.distributedschedule.dms.test.server";
39 static std::string g_networkId = "ABCDEF00ABCDEF00ABCDEF00ABCDEF00ABCDEF00ABCDEF00ABCDEF00ABCDEF0";
40
41 class TransClientSocketServiceTest : public testing::Test {
42 public:
TransClientSocketServiceTest()43 TransClientSocketServiceTest() { }
~TransClientSocketServiceTest()44 ~TransClientSocketServiceTest() { }
SetUpTestCase(void)45 static void SetUpTestCase(void) {}
TearDownTestCase(void)46 static void TearDownTestCase(void) {}
SetUp()47 void SetUp() override { }
TearDown()48 void TearDown() override { }
49 };
50
51 /**
52 * @tc.name: SocketName001
53 * @tc.desc: call Socket function with different socket name.
54 * @tc.type: FUNC
55 * @tc.require:
56 */
57 HWTEST_F(TransClientSocketServiceTest, SocketName001, TestSize.Level1)
58 {
59 SocketInfo info;
60 info.peerName = const_cast<char *>(g_socketPeerName.c_str());
61 info.peerNetworkId = const_cast<char *>(g_networkId.c_str());
62 info.pkgName = const_cast<char *>(g_pkgName.c_str());
63 info.dataType = DATA_TYPE_MESSAGE;
64
65 int32_t socketId = -1;
66
67 // socket name is null pointer
68 info.name = nullptr;
69 socketId = Socket(info);
70 ASSERT_EQ(socketId, SOFTBUS_INVALID_PARAM);
71
72 // the length of socket name is zero
73 char socketName[SOCKET_NAME_INVALID_LEN + 1];
74 memset_s(socketName, SOCKET_NAME_INVALID_LEN + 1, 0, SOCKET_NAME_INVALID_LEN + 1);
75 info.name = socketName;
76 socketId = Socket(info);
77 ASSERT_EQ(socketId, SOFTBUS_INVALID_PARAM);
78
79 // the length of socket name greater than 255
80 memset_s(socketName, SOCKET_NAME_INVALID_LEN + 1, 'a', SOCKET_NAME_INVALID_LEN);
81 info.name = socketName;
82 socketId = Socket(info);
83 ASSERT_EQ(socketId, SOFTBUS_INVALID_PARAM);
84 }
85
86 /**
87 * @tc.name: SocketPeerName001
88 * @tc.desc: call Socket function with different socket peerName.
89 * @tc.type: FUNC
90 * @tc.require:
91 */
92 HWTEST_F(TransClientSocketServiceTest, SocketPeerName001, TestSize.Level1)
93 {
94 SocketInfo info;
95 info.name = const_cast<char *>(g_socketName.c_str());
96 info.peerNetworkId = const_cast<char *>(g_networkId.c_str());
97 info.pkgName = const_cast<char *>(g_pkgName.c_str());
98 info.dataType = DATA_TYPE_MESSAGE;
99 int32_t socketId = -1;
100
101 // the length of socket peerName is zero
102 char socketName[SOCKET_NAME_INVALID_LEN + 1];
103 memset_s(socketName, SOCKET_NAME_INVALID_LEN + 1, 0, SOCKET_NAME_INVALID_LEN + 1);
104 info.peerName = socketName;
105 socketId = Socket(info);
106 ASSERT_EQ(socketId, SOFTBUS_INVALID_PARAM);
107
108 // the length of socket name greater than 255
109 memset_s(socketName, SOCKET_NAME_INVALID_LEN + 1, 'a', SOCKET_NAME_INVALID_LEN);
110 info.peerName = socketName;
111 socketId = Socket(info);
112 ASSERT_EQ(socketId, SOFTBUS_INVALID_PARAM);
113 }
114
115 /**
116 * @tc.name: SocketPeerNetworkId001
117 * @tc.desc: call Socket function with different socket peerNetworkId.
118 * @tc.type: FUNC
119 * @tc.require:
120 */
121 HWTEST_F(TransClientSocketServiceTest, SocketPeerNetworkId001, TestSize.Level1)
122 {
123 SocketInfo info;
124 info.name = const_cast<char *>(g_socketName.c_str());
125 info.peerName = const_cast<char *>(g_socketPeerName.c_str());
126 info.pkgName = const_cast<char *>(g_pkgName.c_str());
127 info.dataType = DATA_TYPE_MESSAGE;
128 int32_t socketId = -1;
129
130 // the length of socket peerNetworkId is zero
131 char networkId[SOCKET_NETWORKID_INVALID_LEN + 1];
132 memset_s(networkId, SOCKET_NETWORKID_INVALID_LEN + 1, 0, SOCKET_NETWORKID_INVALID_LEN + 1);
133 info.peerNetworkId = networkId;
134 socketId = Socket(info);
135 ASSERT_EQ(socketId, SOFTBUS_INVALID_PARAM);
136
137 // the length of socket peerNetworkId greater than 65
138 memset_s(networkId, SOCKET_NETWORKID_INVALID_LEN + 1, 'a', SOCKET_NETWORKID_INVALID_LEN);
139 info.peerNetworkId = networkId;
140 socketId = Socket(info);
141 ASSERT_EQ(socketId, SOFTBUS_INVALID_PARAM);
142 }
143
144 /**
145 * @tc.name: SocketPkgName001
146 * @tc.desc: call Socket function with different socket pkgName.
147 * @tc.type: FUNC
148 * @tc.require:
149 */
150 HWTEST_F(TransClientSocketServiceTest, SocketPkgName001, TestSize.Level1)
151 {
152 SocketInfo info;
153 info.name = const_cast<char *>(g_socketName.c_str());
154 info.peerName = const_cast<char *>(g_socketPeerName.c_str());
155 info.peerNetworkId = const_cast<char *>(g_networkId.c_str());
156 info.dataType = DATA_TYPE_MESSAGE;
157
158 int32_t socketId = -1;
159
160 // socket name is null pointer
161 info.pkgName = nullptr;
162 socketId = Socket(info);
163 ASSERT_EQ(socketId, SOFTBUS_INVALID_PARAM);
164
165 // the length of socket name is zero
166 char pkgName[SOCKET_PKG_NAME_INVALID_LEN + 1];
167 memset_s(pkgName, SOCKET_PKG_NAME_INVALID_LEN + 1, 0, SOCKET_PKG_NAME_INVALID_LEN + 1);
168 info.pkgName = pkgName;
169 socketId = Socket(info);
170 ASSERT_EQ(socketId, SOFTBUS_INVALID_PARAM);
171
172 // the length of socket name greater than 255
173 memset_s(pkgName, SOCKET_PKG_NAME_INVALID_LEN + 1, 'a', SOCKET_PKG_NAME_INVALID_LEN);
174 info.name = pkgName;
175 socketId = Socket(info);
176 ASSERT_EQ(socketId, SOFTBUS_INVALID_PARAM);
177 }
178
179 /**
180 * @tc.name: SocketPkgName001
181 * @tc.desc: call Socket function with different data type.
182 * @tc.type: FUNC
183 * @tc.require:
184 */
185 HWTEST_F(TransClientSocketServiceTest, DataType001, TestSize.Level1)
186 {
187 SocketInfo info;
188 info.name = const_cast<char *>(g_socketName.c_str());
189 info.peerName = nullptr;
190 info.peerNetworkId = nullptr;
191 info.pkgName = const_cast<char *>(g_pkgName.c_str());
192
193 for (int32_t type = DATA_TYPE_MESSAGE; type < DATA_TYPE_BUTT; type++) {
194 info.dataType = static_cast<TransDataType>(type);
195 int32_t socketId = Socket(info);
196 EXPECT_EQ(socketId, SOFTBUS_TRANS_SESSION_ADDPKG_FAILED);
197 }
198 }
199
200 /**
201 * @tc.name: DfsBind001
202 * @tc.desc: call DfsBind function with invalid socket or listener.
203 * @tc.type: FUNC
204 * @tc.require:
205 */
206 HWTEST_F(TransClientSocketServiceTest, DfsBind001, TestSize.Level1)
207 {
208 ISocketListener listener;
209 int32_t ret = DfsBind(-1, &listener);
210 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
211
212 ret = DfsBind(1, nullptr);
213 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
214
215 ret = DfsBind(1, &listener);
216 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
217 }
218
OnShutdown(int32_t socket,ShutdownReason reason)219 static void OnShutdown(int32_t socket, ShutdownReason reason)
220 {
221 return;
222 }
223
224 /**
225 * @tc.name: DfsBind002
226 * @tc.desc: call DfsBind function with offline socket.
227 * @tc.type: FUNC
228 * @tc.require:
229 */
230 HWTEST_F(TransClientSocketServiceTest, DfsBind002, TestSize.Level1)
231 {
232 ISocketListener listener = { .OnShutdown = OnShutdown };
233 int32_t ret = DfsBind(1, &listener);
234 EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_INFO_NOT_FOUND);
235 }
236
237 /**
238 * @tc.name: SetSocketOpt001
239 * @tc.desc: call SetSocketOpt function with with invalid parameter.
240 * @tc.type: FUNC
241 * @tc.require:
242 */
243 HWTEST_F(TransClientSocketServiceTest, SetSocketOpt001, TestSize.Level1)
244 {
245 OptLevel levelInvalid = OPT_LEVEL_BUTT;
246 OptLevel levelValid = OPT_LEVEL_SOFTBUS;
247 OptType optTypeInvalid = (OptType)-1;
248 OptType optTypeValid = OPT_TYPE_MAX_BUFFER;
249 int32_t socket = 1;
250 int32_t optValueValid = 1234;
251 void *temp = &optValueValid;
252 int32_t optValueSizeInvalid = -1;
253 int32_t optValueSizeValid = sizeof(int32_t);
254 int32_t ret = SetSocketOpt(socket, levelInvalid, optTypeInvalid, nullptr, optValueSizeInvalid);
255 ASSERT_EQ(ret, SOFTBUS_INVALID_PARAM);
256 ret = SetSocketOpt(socket, levelValid, optTypeInvalid, nullptr, optValueSizeInvalid);
257 ASSERT_EQ(ret, SOFTBUS_INVALID_PARAM);
258 ret = SetSocketOpt(socket, levelValid, optTypeValid, nullptr, optValueSizeInvalid);
259 ASSERT_EQ(ret, SOFTBUS_INVALID_PARAM);
260 ret = SetSocketOpt(socket, levelValid, optTypeValid, temp, optValueSizeInvalid);
261 ASSERT_EQ(ret, SOFTBUS_INVALID_PARAM);
262 ret = SetSocketOpt(socket, levelValid, optTypeValid, temp, optValueSizeValid);
263 ASSERT_NE(ret, SOFTBUS_INVALID_PARAM);
264 }
265
266 /**
267 * @tc.name: GetSocketOpt001
268 * @tc.desc: call GetSocketOpt function with with invalid parameter.
269 * @tc.type: FUNC
270 * @tc.require:
271 */
272 HWTEST_F(TransClientSocketServiceTest, GetSocketOpt001, TestSize.Level1)
273 {
274 OptLevel levelInvalid = OPT_LEVEL_BUTT;
275 OptLevel levelValid = OPT_LEVEL_SOFTBUS;
276 OptType optTypeInvalid = (OptType)-1;
277 OptType optTypeValid = OPT_TYPE_MAX_BUFFER;
278 int32_t socket = 1;
279 int32_t optValueValid = 0;
280 void *temp = &optValueValid;
281 int32_t valueSize = 0;
282 int32_t *optValueSizeValid = &valueSize;
283 int32_t ret = GetSocketOpt(socket, levelInvalid, optTypeInvalid, nullptr, nullptr);
284 ASSERT_EQ(ret, SOFTBUS_INVALID_PARAM);
285 ret = GetSocketOpt(socket, levelValid, optTypeInvalid, nullptr, nullptr);
286 ASSERT_EQ(ret, SOFTBUS_INVALID_PARAM);
287 ret = GetSocketOpt(socket, levelValid, optTypeValid, nullptr, nullptr);
288 ASSERT_EQ(ret, SOFTBUS_INVALID_PARAM);
289 ret = GetSocketOpt(socket, levelValid, optTypeValid, temp, nullptr);
290 ASSERT_EQ(ret, SOFTBUS_INVALID_PARAM);
291 ret = GetSocketOpt(socket, levelValid, optTypeValid, temp, optValueSizeValid);
292 ASSERT_NE(ret, SOFTBUS_INVALID_PARAM);
293 }
294
295 /**
296 * @tc.name: GetSocketOpt002
297 * @tc.desc: call GetSocketOpt function with with valid parameter.
298 * @tc.type: FUNC
299 * @tc.require:
300 */
301 HWTEST_F(TransClientSocketServiceTest, GetSocketOpt002, TestSize.Level1)
302 {
303 OptLevel level = OPT_LEVEL_SOFTBUS;
304 OptType optType = OPT_TYPE_MAX_BUFFER;
305 int socketId = 1;
306 uint32_t optValueValid = 0;
307 void *temp = &optValueValid;
308 int32_t valueSize = sizeof(uint32_t);
309 int32_t *optValueSizeValid = &valueSize;
310 int32_t ret = SetSocketOpt(socketId, level, optType, temp, valueSize);
311 ASSERT_EQ(ret, SOFTBUS_NOT_IMPLEMENT);
312 ret = GetSocketOpt(socketId, level, optType, temp, optValueSizeValid);
313 ASSERT_EQ(ret, SOFTBUS_NOT_IMPLEMENT);
314 }
315
316 /**
317 * @tc.name: RegisterRelationChecker001
318 * @tc.desc: call RegisterRelationChecker function with with invalid parameter.
319 * @tc.type: FUNC
320 * @tc.require:
321 */
322 HWTEST_F(TransClientSocketServiceTest, RegisterRelationChecker001, TestSize.Level1)
323 {
324 int32_t ret = RegisterRelationChecker(nullptr);
325 ASSERT_EQ(ret, SOFTBUS_INVALID_PARAM);
326 }
327
328 /**
329 * @tc.name: SetCommonSocketOpt001
330 * @tc.desc: call SetCommonSocketOpt function with with invalid parameter.
331 * @tc.type: FUNC
332 * @tc.require:
333 */
334 HWTEST_F(TransClientSocketServiceTest, SetCommonSocketOpt001, TestSize.Level1)
335 {
336 int32_t socket = 1;
337 OptLevel level = OPT_LEVEL_KERNEL;
338 OptType optType = OPT_TYPE_FIRST_PACKAGE;
339 int32_t optValueSize = DATA_LENS;
340 void *optValue = &optValueSize;
341 int32_t ret = SetCommonSocketOpt(socket, level, optType, nullptr, 0);
342 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
343
344 ret = SetCommonSocketOpt(socket, level, optType, optValue, 0);
345 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
346
347 ret = SetCommonSocketOpt(socket, level, optType, optValue, optValueSize);
348 EXPECT_EQ(ret, SOFTBUS_NOT_IMPLEMENT);
349
350 optType = OPT_TYPE_MAX_IDLE_TIMEOUT;
351 ret = SetCommonSocketOpt(socket, level, optType, optValue, optValueSize);
352 EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_INFO_NOT_FOUND);
353
354 socket = INVALID_VALUE;
355 ret = SetCommonSocketOpt(socket, level, optType, optValue, optValueSize);
356 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
357
358 optType = OPT_TYPE_NEED_ACK;
359 ret = SetCommonSocketOpt(socket, level, optType, optValue, optValueSize);
360 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
361
362 socket = 1;
363 ret = SetCommonSocketOpt(socket, level, optType, optValue, optValueSize);
364 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
365 }
366
367 /**
368 * @tc.name: GetCommonSocketOpt001
369 * @tc.desc: call GetCommonSocketOpt function with with invalid parameter.
370 * @tc.type: FUNC
371 * @tc.require:
372 */
373 HWTEST_F(TransClientSocketServiceTest, GetCommonSocketOpt001, TestSize.Level1)
374 {
375 int32_t socket = 1;
376 OptLevel level = OPT_LEVEL_KERNEL;
377 OptType optType = OPT_TYPE_FIRST_PACKAGE;
378 int32_t optValueSize = DATA_LENS;
379 void *optValue = &optValueSize;
380 int32_t ret = GetCommonSocketOpt(socket, level, optType, nullptr, nullptr);
381 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
382
383 ret = GetCommonSocketOpt(socket, level, optType, nullptr, &optValueSize);
384 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
385
386 ret = SetCommonSocketOpt(socket, level, optType, optValue, optValueSize);
387 EXPECT_EQ(ret, SOFTBUS_NOT_IMPLEMENT);
388
389 optType = OPT_TYPE_SUPPORT_ACK;
390 ret = GetCommonSocketOpt(socket, level, optType, optValue, &optValueSize);
391 EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_INFO_NOT_FOUND);
392
393 socket = INVALID_VALUE;
394 ret = GetCommonSocketOpt(socket, level, optType, optValue, &optValueSize);
395 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
396
397 optType = OPT_TYPE_MAX_IDLE_TIMEOUT;
398 ret = GetCommonSocketOpt(socket, level, optType, optValue, &optValueSize);
399 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
400
401 socket = 1;
402 ret = GetCommonSocketOpt(socket, level, optType, optValue, &optValueSize);
403 EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_INFO_NOT_FOUND);
404 }
405
406 /**
407 * @tc.name: BindAsync001
408 * @tc.desc: call BindAsync function with with valid parameter.
409 * @tc.type: FUNC
410 * @tc.require:
411 */
412 HWTEST_F(TransClientSocketServiceTest, BindAsync001, TestSize.Level1)
413 {
414 SocketInfo info = {
415 .name = const_cast<char *>(g_socketName.c_str()),
416 .pkgName = const_cast<char *>(g_pkgName.c_str()),
417 .peerName = const_cast<char *>(g_socketPeerName.c_str()),
418 .peerNetworkId = nullptr,
419 .dataType = DATA_TYPE_MESSAGE,
420 };
421
422 int32_t socket = Socket(info);
423 EXPECT_EQ(socket, SOFTBUS_TRANS_SESSION_ADDPKG_FAILED);
424
425 QosTV qosInfo[] = {
426 {.qos = QOS_TYPE_MIN_BW, .value = 80 },
427 { .qos = QOS_TYPE_MAX_LATENCY, .value = 4000},
428 { .qos = QOS_TYPE_MIN_LATENCY, .value = 2000},
429 };
430 int32_t ret = BindAsync(socket, qosInfo, sizeof(qosInfo) / sizeof(qosInfo[0]), nullptr);
431 ASSERT_EQ(ret, SOFTBUS_INVALID_PARAM);
432 }
433
434 /**
435 * @tc.name: EvaluateQos001
436 * @tc.desc: call EvaluateQos function with with valid parameter.
437 * @tc.type: FUNC
438 * @tc.require:
439 */
440 HWTEST_F(TransClientSocketServiceTest, EvaluateQos001, TestSize.Level1)
441 {
442 TransDataType dataType = DATA_TYPE_BYTES;
443 QosTV qos;
444 uint32_t qosCount = 1;
445 int32_t ret = EvaluateQos(const_cast<char *>(g_networkId.c_str()), dataType, &qos, qosCount);
446 EXPECT_EQ(ret, SOFTBUS_ACCESS_TOKEN_DENIED);
447
448 ret = EvaluateQos(nullptr, dataType, nullptr, qosCount);
449 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
450 }
451
452 /**
453 * @tc.name: GetMtuSize001
454 * @tc.desc: call GetMtuSize function with with valid parameter.
455 * @tc.type: FUNC
456 * @tc.require:
457 */
458 HWTEST_F(TransClientSocketServiceTest, GetMtuSize001, TestSize.Level1)
459 {
460 int32_t socket = INVALID_VALUE;
461 uint32_t mtuSize = 0;
462 int32_t ret = GetMtuSize(socket, &mtuSize);
463 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
464 }
465
466 /**
467 * @tc.name: PrivilegeShutdown001
468 * @tc.desc: call PrivilegeShutdown function with with valid parameter.
469 * @tc.type: FUNC
470 * @tc.require:
471 */
472 HWTEST_F(TransClientSocketServiceTest, PrivilegeShutdown001, TestSize.Level1)
473 {
474 uint64_t tokenId = 0;
475 int32_t pid = 0;
476
477 int32_t ret = PrivilegeShutdown(tokenId, pid, nullptr);
478 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
479
480 ret = PrivilegeShutdown(tokenId, pid, const_cast<char *>(g_networkId.c_str()));
481 EXPECT_EQ(ret, SOFTBUS_ACCESS_TOKEN_DENIED);
482 }
483
484 /**
485 * @tc.name: SetAccessInfo001
486 * @tc.desc: call SetAccessInfo function with with valid parameter.
487 * @tc.type: FUNC
488 * @tc.require:
489 */
490 HWTEST_F(TransClientSocketServiceTest, SetAccessInfo001, TestSize.Level1)
491 {
492 int32_t socket = 1;
493 SocketAccessInfo accessInfo = {
494 .userId = 1,
495 .businessAccountId = (char *)"accountId",
496 };
497
498 int32_t ret = SetAccessInfo(socket, accessInfo);
499 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
500 }
501 } // namespace OHOS
502