1 /*
2 * Copyright (c) 2022-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 "securec.h"
17 #include <gtest/gtest.h>
18
19 #include "softbus_def.h"
20 #include "softbus_adapter_mem.h"
21 #include "trans_server_proxy.h"
22 #include "trans_server_proxy_standard.cpp"
23 #include "client_trans_session_manager.h"
24
25 using namespace testing::ext;
26
27 namespace OHOS {
28 #define INVALID_VALUE (-1)
29 #define SESSIONKEY_LEN 32
30 #define LEN 32
31 static const int32_t UUID = 0;
32 static const int32_t PID = 0;
33 static const char *g_sessionName = "ohos.distributedschedule.dms.test";
34 static const char *g_peerSessionName = "ohos.distributedschedule.dms.test";
35 static const char *g_peerDeviceId = "1000";
36 static const char *g_peerNetworkId = "123456789";
37 static const char *g_pkgName = "com.test.trans.session";
38 static const char *g_addr = "192.168.8.1";
39 static const uint16_t PORT = 10;
40 static const char *g_networkId = "ABCDEF00ABCDEF00ABCDEF00ABCDEF00ABCDEF00ABCDEF00ABCDEF00ABCDEF00";
41 static const char *g_groupId = "TEST_GROUP_ID";
42
43 class TransIpcStandardTest : public testing::Test {
44 public:
TransIpcStandardTest()45 TransIpcStandardTest()
46 {
47 }
~TransIpcStandardTest()48 ~TransIpcStandardTest()
49 {
50 }
51 static void SetUpTestCase(void);
52 static void TearDownTestCase(void);
53 void SetUp() override
54 {
55 }
56 void TearDown() override
57 {
58 }
59 };
60
SetUpTestCase(void)61 void TransIpcStandardTest::SetUpTestCase(void)
62 {
63 }
64
TearDownTestCase(void)65 void TransIpcStandardTest::TearDownTestCase(void)
66 {
67 }
68
69 /**
70 * @tc.name: SoftbusRegisterServiceTest001
71 * @tc.desc: SoftbusRegisterService, use the wrong parameter.
72 * @tc.type: FUNC
73 * @tc.require:I5HQGA
74 */
HWTEST_F(TransIpcStandardTest, SoftbusRegisterServiceTest001, TestSize.Level0)75 HWTEST_F(TransIpcStandardTest, SoftbusRegisterServiceTest001, TestSize.Level0)
76 {
77 SubscribeInfo* subInfo = (SubscribeInfo*)SoftBusCalloc(sizeof(SubscribeInfo));
78 ASSERT_TRUE(subInfo != nullptr);
79 (void)memset_s(subInfo, sizeof(SubscribeInfo), 0, sizeof(SubscribeInfo));
80 PublishInfo* pubInfo = (PublishInfo*)SoftBusCalloc(sizeof(PublishInfo));
81 ASSERT_TRUE(pubInfo != nullptr);
82 (void)memset_s(pubInfo, sizeof(PublishInfo), 0, sizeof(PublishInfo));
83 TransServerProxy transServerProxy(nullptr);
84
85 int32_t ret = transServerProxy.SoftbusRegisterService(g_pkgName, nullptr);
86 EXPECT_EQ(ret, SOFTBUS_OK);
87 SoftBusFree(subInfo);
88 SoftBusFree(pubInfo);
89 }
90
91 /**
92 * @tc.name: SoftbusRegisterServiceTest002
93 * @tc.desc: SoftbusRegisterService, use the wrong parameter.
94 * @tc.type: FUNC
95 * @tc.require:I5HQGA
96 */
HWTEST_F(TransIpcStandardTest, SoftbusRegisterServiceTest002, TestSize.Level0)97 HWTEST_F(TransIpcStandardTest, SoftbusRegisterServiceTest002, TestSize.Level0)
98 {
99 uint32_t addrTypeLen = 1;
100 void *info = nullptr;
101 uint32_t infoTypeLen = 1;
102 int32_t infoNum = 1;
103 int32_t key = 1;
104 unsigned char *buf = nullptr;
105 uint16_t dataChangeFlag = 1;
106 int32_t accuracy = 1;
107 int32_t period = 1;
108 TransServerProxy transServerProxy(nullptr);
109
110 int32_t ret = transServerProxy.JoinLNN(g_pkgName, (void *)g_addr, addrTypeLen);
111 EXPECT_EQ(ret, SOFTBUS_OK);
112
113 ret = transServerProxy.LeaveLNN(g_pkgName, g_networkId);
114 EXPECT_EQ(ret, SOFTBUS_OK);
115
116 ret = transServerProxy.GetAllOnlineNodeInfo(g_pkgName, &info, infoTypeLen, &infoNum);
117 EXPECT_EQ(ret, SOFTBUS_OK);
118
119 ret = transServerProxy.GetLocalDeviceInfo(g_pkgName, info, infoTypeLen);
120 EXPECT_EQ(ret, SOFTBUS_OK);
121
122 ret = transServerProxy.GetNodeKeyInfo(g_pkgName, g_networkId, key, buf, infoTypeLen);
123 EXPECT_EQ(ret, SOFTBUS_OK);
124
125 ret = transServerProxy.SetNodeDataChangeFlag(g_pkgName, g_networkId, dataChangeFlag);
126 EXPECT_EQ(ret, SOFTBUS_OK);
127
128 ret = transServerProxy.StartTimeSync(g_pkgName, g_networkId, accuracy, period);
129 EXPECT_EQ(ret, SOFTBUS_OK);
130
131 ret = transServerProxy.StopTimeSync(g_pkgName, g_networkId);
132 EXPECT_EQ(ret, SOFTBUS_OK);
133 }
134
135 /**
136 * @tc.name: CreateSessionServerTest001
137 * @tc.desc: CreateSessionServer, use the wrong parameter.
138 * @tc.type: FUNC
139 * @tc.require:I5HQGA
140 */
HWTEST_F(TransIpcStandardTest, CreateSessionServerTest001, TestSize.Level0)141 HWTEST_F(TransIpcStandardTest, CreateSessionServerTest001, TestSize.Level0)
142 {
143 TransServerProxy transServerProxy(nullptr);
144 int32_t ret = transServerProxy.CreateSessionServer(nullptr, g_sessionName);
145 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
146
147 ret = transServerProxy.CreateSessionServer(g_pkgName, nullptr);
148 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
149
150 ret = transServerProxy.CreateSessionServer(g_pkgName, g_sessionName);
151 EXPECT_EQ(ret, SOFTBUS_ACCESS_TOKEN_DENIED);
152 }
153
154 /**
155 * @tc.name: RemoveSessionServerTest001
156 * @tc.desc: RemoveSessionServer, use the wrong parameter.
157 * @tc.type: FUNC
158 * @tc.require:I5HQGA
159 */
HWTEST_F(TransIpcStandardTest, RemoveSessionServerTest001, TestSize.Level0)160 HWTEST_F(TransIpcStandardTest, RemoveSessionServerTest001, TestSize.Level0)
161 {
162 TransServerProxy transServerProxy(nullptr);
163 int32_t ret = transServerProxy.RemoveSessionServer(nullptr, g_sessionName);
164 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
165
166 ret = transServerProxy.RemoveSessionServer(g_pkgName, nullptr);
167 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
168
169 ret = transServerProxy.RemoveSessionServer(g_pkgName, g_sessionName);
170 EXPECT_EQ(ret, SOFTBUS_ACCESS_TOKEN_DENIED);
171 }
172
173 /**
174 * @tc.name: OpenSessionTest001
175 * @tc.desc: OpenSession, use the wrong parameter.
176 * @tc.type: FUNC
177 * @tc.require:I5HQGA
178 */
HWTEST_F(TransIpcStandardTest, OpenSessionTest001, TestSize.Level0)179 HWTEST_F(TransIpcStandardTest, OpenSessionTest001, TestSize.Level0)
180 {
181 TransServerProxy transServerProxy(nullptr);
182 SessionParam *param = (SessionParam*)SoftBusCalloc(sizeof(SessionParam));
183 TransInfo *info = (TransInfo*)SoftBusCalloc(sizeof(TransInfo));
184 ASSERT_TRUE(param != nullptr);
185 ASSERT_TRUE(info != nullptr);
186 (void)memset_s(param, sizeof(SessionParam), 0, sizeof(SessionParam));
187 (void)memset_s(info, sizeof(TransInfo), 0, sizeof(TransInfo));
188 param->sessionName = nullptr;
189 param->peerSessionName = nullptr;
190 param->peerDeviceId = nullptr;
191 param->groupId = nullptr;
192
193 int32_t ret = transServerProxy.OpenSession(param, info);
194 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
195
196 param->sessionName = g_sessionName;
197 ret = transServerProxy.OpenSession(param, info);
198 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
199
200 param->peerSessionName = g_peerSessionName;
201 ret = transServerProxy.OpenSession(param, info);
202 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
203
204 param->peerDeviceId = g_peerDeviceId;
205 ret = transServerProxy.OpenSession(param, info);
206 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
207
208 param->groupId = g_groupId;
209 ret = transServerProxy.OpenSession(param, info);
210 EXPECT_EQ(ret, SOFTBUS_TRANS_PROXY_WRITERAWDATA_FAILED);
211
212 SessionAttribute sessionAttribute;
213 sessionAttribute.dataType = 1;
214 sessionAttribute.linkTypeNum= 1;
215 param->attr = &sessionAttribute;
216 ret = transServerProxy.OpenSession(param, info);
217 EXPECT_EQ(ret, SOFTBUS_ACCESS_TOKEN_DENIED);
218 SoftBusFree(param);
219 SoftBusFree(info);
220 }
221
222 /**
223 * @tc.name: OpenAuthSessionTest001
224 * @tc.desc: OpenAuthSession, use the wrong parameter.
225 * @tc.type: FUNC
226 * @tc.require:I5HQGA
227 */
HWTEST_F(TransIpcStandardTest, OpenAuthSessionTest001, TestSize.Level0)228 HWTEST_F(TransIpcStandardTest, OpenAuthSessionTest001, TestSize.Level0)
229 {
230 TransServerProxy transServerProxy(nullptr);
231 ConnectionAddr *addrInfo = (ConnectionAddr*)SoftBusCalloc(sizeof(ConnectionAddr));
232 ASSERT_TRUE(addrInfo != nullptr);
233 (void)memset_s(addrInfo, sizeof(ConnectionAddr), 0, sizeof(ConnectionAddr));
234 addrInfo->type = CONNECTION_ADDR_WLAN;
235 (void)memcpy_s(addrInfo->info.ip.ip, strlen(addrInfo->info.ip.ip), g_addr, strlen(g_addr));
236 addrInfo->info.ip.port = PORT;
237 int32_t ret = transServerProxy.OpenAuthSession(nullptr, addrInfo);
238 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
239
240 ret = transServerProxy.OpenAuthSession(g_sessionName, nullptr);
241 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
242
243 ret = transServerProxy.OpenAuthSession(g_sessionName, addrInfo);
244 EXPECT_EQ(ret, SOFTBUS_TRANS_PROXY_REMOTE_NULL);
245 SoftBusFree(addrInfo);
246 }
247
248 /**
249 * @tc.name: NotifyAuthSuccessTest001
250 * @tc.desc: NotifyAuthSuccess, use the wrong parameter.
251 * @tc.type: FUNC
252 * @tc.require:I5HQGA
253 */
HWTEST_F(TransIpcStandardTest, NotifyAuthSuccessTest001, TestSize.Level0)254 HWTEST_F(TransIpcStandardTest, NotifyAuthSuccessTest001, TestSize.Level0)
255 {
256 TransServerProxy transServerProxy(nullptr);
257 int32_t channelId = 0;
258 int32_t channelType = CHANNEL_TYPE_AUTH;
259 int32_t ret = transServerProxy.NotifyAuthSuccess(channelId, channelType);
260 EXPECT_EQ(ret, SOFTBUS_ACCESS_TOKEN_DENIED);
261
262 channelId = INVALID_VALUE;
263 ret = transServerProxy.NotifyAuthSuccess(channelId, channelType);
264 EXPECT_EQ(ret, SOFTBUS_ACCESS_TOKEN_DENIED);
265 }
266
267 /**
268 * @tc.name: CloseChannelTest001
269 * @tc.desc: CloseChannel, use the wrong parameter.
270 * @tc.type: FUNC
271 * @tc.require:I5HQGA
272 */
HWTEST_F(TransIpcStandardTest, CloseChannelTest001, TestSize.Level0)273 HWTEST_F(TransIpcStandardTest, CloseChannelTest001, TestSize.Level0)
274 {
275 TransServerProxy transServerProxy(nullptr);
276 int32_t channelId = -1;
277 int32_t channelType = CHANNEL_TYPE_AUTH;
278 int32_t ret = transServerProxy.CloseChannel(nullptr, channelId, channelType);
279 EXPECT_EQ(ret, SOFTBUS_ACCESS_TOKEN_DENIED);
280 }
281
282 /**
283 * @tc.name: SendMessageTest001
284 * @tc.desc: SendMessage, use the wrong parameter.
285 * @tc.type: FUNC
286 * @tc.require:I5HQGA
287 */
HWTEST_F(TransIpcStandardTest, SendMessageTest001, TestSize.Level0)288 HWTEST_F(TransIpcStandardTest, SendMessageTest001, TestSize.Level0)
289 {
290 TransServerProxy transServerProxy(nullptr);
291 int32_t channelId = 0;
292 int32_t channelType = CHANNEL_TYPE_AUTH;
293 const char *dataInfo = "datainfo";
294 uint32_t len = LEN;
295 int32_t msgType = TRANS_SESSION_BYTES;
296 int32_t ret = transServerProxy.SendMessage(channelId, channelType, (const void *)dataInfo, len, msgType);
297 EXPECT_EQ(ret, SOFTBUS_TRANS_PROXY_REMOTE_NULL);
298
299 ret = transServerProxy.SendMessage(channelId, channelType, nullptr, len, msgType);
300 EXPECT_EQ(ret, SOFTBUS_TRANS_PROXY_REMOTE_NULL);
301 }
302
303 /**
304 * @tc.name: QosReportTest001
305 * @tc.desc: SendMessage, use the wrong parameter.
306 * @tc.type: FUNC
307 * @tc.require:I5HQGA
308 */
HWTEST_F(TransIpcStandardTest, QosReportTest001, TestSize.Level0)309 HWTEST_F(TransIpcStandardTest, QosReportTest001, TestSize.Level0)
310 {
311 TransServerProxy transServerProxy(nullptr);
312 int32_t channelId = 1;
313 int32_t channelType = CHANNEL_TYPE_BUTT;
314 int32_t appType = 0;
315 int32_t quality = QOS_IMPROVE;
316 int32_t ret = transServerProxy.QosReport(channelId, channelType, appType, quality);
317 EXPECT_EQ(ret, SOFTBUS_ACCESS_TOKEN_DENIED);
318
319 channelId = INVALID_VALUE;
320 ret = transServerProxy.QosReport(channelId, channelType, appType, quality);
321 EXPECT_EQ(ret, SOFTBUS_ACCESS_TOKEN_DENIED);
322 }
323
324 /**
325 * @tc.name: StreamStatsTest001
326 * @tc.desc: StreamStats, use the wrong parameter.
327 * @tc.type: FUNC
328 * @tc.require:I5HQGA
329 */
HWTEST_F(TransIpcStandardTest, StreamStatsTest001, TestSize.Level0)330 HWTEST_F(TransIpcStandardTest, StreamStatsTest001, TestSize.Level0)
331 {
332 TransServerProxy transServerProxy(nullptr);
333 int32_t channelId = INVALID_VALUE;
334 int32_t channelType = CHANNEL_TYPE_BUTT;
335 StreamSendStats *statsData = (StreamSendStats*)SoftBusCalloc(sizeof(StreamSendStats));
336 ASSERT_TRUE(statsData != nullptr);
337 (void)memset_s(statsData, sizeof(StreamSendStats), 0, sizeof(StreamSendStats));
338
339 int32_t ret = transServerProxy.StreamStats(channelId, channelType, nullptr);
340 EXPECT_EQ(ret, SOFTBUS_TRANS_PROXY_WRITERAWDATA_FAILED);
341
342 channelId = INVALID_VALUE;
343 ret = transServerProxy.StreamStats(channelId, channelType, statsData);
344 EXPECT_EQ(ret, SOFTBUS_TRANS_PROXY_SEND_REQUEST_FAILED);
345 SoftBusFree(statsData);
346 }
347
348 /**
349 * @tc.name: RippleStatsTest0011
350 * @tc.desc: RippleStats, use the wrong parameter.
351 * @tc.type: FUNC
352 * @tc.require:I5HQGA
353 */
HWTEST_F(TransIpcStandardTest, RippleStatsTest0011, TestSize.Level0)354 HWTEST_F(TransIpcStandardTest, RippleStatsTest0011, TestSize.Level0)
355 {
356 TransServerProxy transServerProxy(nullptr);
357 int32_t channelId = INVALID_VALUE;
358 int32_t channelType = CHANNEL_TYPE_BUTT;
359 TrafficStats *statsData = (TrafficStats*)SoftBusCalloc(sizeof(TrafficStats));
360 ASSERT_TRUE(statsData != nullptr);
361 (void)memset_s(statsData, sizeof(TrafficStats), 0, sizeof(TrafficStats));
362
363 int32_t ret = transServerProxy.RippleStats(channelId, channelType, nullptr);
364 EXPECT_EQ(ret, SOFTBUS_TRANS_PROXY_WRITERAWDATA_FAILED);
365
366 channelId = INVALID_VALUE;
367 ret = transServerProxy.RippleStats(channelId, channelType, statsData);
368 EXPECT_EQ(ret, SOFTBUS_ACCESS_TOKEN_DENIED);
369 SoftBusFree(statsData);
370 }
371
372 /**
373 * @tc.name: GrantPermissionTest001
374 * @tc.desc: GrantPermission, use the wrong parameter.
375 * @tc.type: FUNC
376 * @tc.require:I5HQGA
377 */
HWTEST_F(TransIpcStandardTest, GrantPermissionTest001, TestSize.Level0)378 HWTEST_F(TransIpcStandardTest, GrantPermissionTest001, TestSize.Level0)
379 {
380 TransServerProxy transServerProxy(nullptr);
381 int32_t ret = transServerProxy.GrantPermission(UUID, PID, nullptr);
382 EXPECT_EQ(ret, SOFTBUS_TRANS_PROXY_WRITECSTRING_FAILED);
383
384 ret = transServerProxy.GrantPermission(UUID, PID, g_sessionName);
385 EXPECT_EQ(SOFTBUS_TRANS_PROXY_SEND_REQUEST_FAILED, ret);
386 }
387
388 /**
389 * @tc.name: RemovePermissionTest001
390 * @tc.desc: RemovePermission, use the wrong parameter.
391 * @tc.type: FUNC
392 * @tc.require:I5HQGA
393 */
HWTEST_F(TransIpcStandardTest, RemovePermissionTest001, TestSize.Level0)394 HWTEST_F(TransIpcStandardTest, RemovePermissionTest001, TestSize.Level0)
395 {
396 TransServerProxy transServerProxy(nullptr);
397 int32_t ret = transServerProxy.RemovePermission(g_sessionName);
398 EXPECT_EQ(ret, SOFTBUS_TRANS_PROXY_SEND_REQUEST_FAILED);
399
400 ret = transServerProxy.RemovePermission(g_sessionName);
401 EXPECT_EQ(ret, SOFTBUS_TRANS_PROXY_SEND_REQUEST_FAILED);
402 }
403
404 /**
405 * @tc.name: ServerIpcCreateSessionServerTest001
406 * @tc.desc: ServerIpcCreateSessionServer, use the wrong parameter.
407 * @tc.type: FUNC
408 * @tc.require:I5HQGA
409 */
HWTEST_F(TransIpcStandardTest, ServerIpcCreateSessionServerTest001, TestSize.Level0)410 HWTEST_F(TransIpcStandardTest, ServerIpcCreateSessionServerTest001, TestSize.Level0)
411 {
412 int32_t ret = ServerIpcCreateSessionServer(g_pkgName, g_sessionName);
413 EXPECT_EQ(ret, SOFTBUS_ACCESS_TOKEN_DENIED);
414
415 ret = TransServerProxyInit();
416 ASSERT_EQ(ret, SOFTBUS_OK);
417
418 ret = ServerIpcCreateSessionServer(nullptr, g_sessionName);
419 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
420
421 ret = ServerIpcCreateSessionServer(g_pkgName, nullptr);
422 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
423
424 ret = ServerIpcCreateSessionServer(g_pkgName, g_sessionName);
425 EXPECT_EQ(ret, SOFTBUS_ACCESS_TOKEN_DENIED);
426
427 TransClientDeinit();
428 }
429
430 /**
431 * @tc.name: ServerIpcRemoveSessionServerTest001
432 * @tc.desc: ServerIpcRemoveSessionServer, use the wrong parameter.
433 * @tc.type: FUNC
434 * @tc.require:I5HQGA
435 */
HWTEST_F(TransIpcStandardTest, ServerIpcRemoveSessionServerTest001, TestSize.Level0)436 HWTEST_F(TransIpcStandardTest, ServerIpcRemoveSessionServerTest001, TestSize.Level0)
437 {
438 int32_t ret = ServerIpcRemoveSessionServer(g_pkgName, g_sessionName);
439 EXPECT_EQ(ret, SOFTBUS_ACCESS_TOKEN_DENIED);
440
441 ret = TransServerProxyInit();
442 ASSERT_EQ(ret, SOFTBUS_OK);
443
444 ret = ServerIpcRemoveSessionServer(nullptr, g_sessionName);
445 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
446
447 ret = ServerIpcRemoveSessionServer(g_pkgName, nullptr);
448 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
449
450 ret = ServerIpcRemoveSessionServer(g_pkgName, g_sessionName);
451 EXPECT_EQ(ret, SOFTBUS_ACCESS_TOKEN_DENIED);
452
453 TransClientDeinit();
454 }
455
456 /**
457 * @tc.name: ServerIpcOpenSessionTest001
458 * @tc.desc: ServerIpcOpenSession, use the wrong parameter.
459 * @tc.type: FUNC
460 * @tc.require:I5HQGA
461 */
HWTEST_F(TransIpcStandardTest, ServerIpcOpenSessionTest001, TestSize.Level0)462 HWTEST_F(TransIpcStandardTest, ServerIpcOpenSessionTest001, TestSize.Level0)
463 {
464 TransInfo* info = (TransInfo*)SoftBusCalloc(sizeof(TransInfo));
465 ASSERT_TRUE(info != nullptr);
466 (void)memset_s(info, sizeof(TransInfo), 0, sizeof(TransInfo));
467 SessionParam* param = (SessionParam*)SoftBusCalloc(sizeof(SessionParam));
468 ASSERT_TRUE(param != nullptr);
469 (void)memset_s(param, sizeof(SessionParam), 0, sizeof(SessionParam));
470 param->sessionName = nullptr;
471 param->peerSessionName = nullptr;
472 param->peerDeviceId = nullptr;
473 param->groupId = nullptr;
474 param->attr = nullptr;
475
476 int32_t sessionId = INVALID_SESSION_ID;
477 int32_t ret = ServerIpcOpenSession(param, info);
478 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
479
480 TransClientDeinit();
481 ret = TransServerProxyInit();
482 ASSERT_EQ(ret, SOFTBUS_OK);
483
484 param->sessionName = g_sessionName;
485 ret = ServerIpcOpenSession(param, info);
486 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
487 (void)ClientDeleteSession(sessionId);
488
489 param->peerSessionName = g_peerSessionName;
490 ret = ServerIpcOpenSession(param, info);
491 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
492 (void)ClientDeleteSession(sessionId);
493
494 param->peerDeviceId = g_peerDeviceId;
495 ret = ServerIpcOpenSession(param, info);
496 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
497 (void)ClientDeleteSession(sessionId);
498
499 param->groupId = g_groupId;
500 ret = ServerIpcOpenSession(param, info);
501 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
502 (void)ClientDeleteSession(sessionId);
503
504 SessionAttribute sessionAttribute;
505 sessionAttribute.dataType = 1;
506 sessionAttribute.linkTypeNum = 1;
507 param->attr = &sessionAttribute;
508 ret = ServerIpcOpenSession(param, info);
509 EXPECT_EQ(ret, SOFTBUS_ACCESS_TOKEN_DENIED);
510 (void)ClientDeleteSession(sessionId);
511
512 TransClientDeinit();
513 SoftBusFree(param);
514 SoftBusFree(info);
515 }
516
517 /**
518 * @tc.name: ServerIpcOpenAuthSessionTest001
519 * @tc.desc: ServerIpcOpenAuthSession, use the wrong parameter.
520 * @tc.type: FUNC
521 * @tc.require:I5HQGA
522 */
HWTEST_F(TransIpcStandardTest, ServerIpcOpenAuthSessionTest001, TestSize.Level0)523 HWTEST_F(TransIpcStandardTest, ServerIpcOpenAuthSessionTest001, TestSize.Level0)
524 {
525 ConnectionAddr* addrInfo = (ConnectionAddr*)SoftBusCalloc(sizeof(ConnectionAddr));
526 ASSERT_TRUE(addrInfo != nullptr);
527 (void)memset_s(addrInfo, sizeof(ConnectionAddr), 0, sizeof(ConnectionAddr));
528 addrInfo->type = CONNECTION_ADDR_BR;
529 int32_t ret = ServerIpcOpenAuthSession(g_sessionName, addrInfo);
530 EXPECT_EQ(ret, SOFTBUS_NO_INIT);
531
532 ret = TransServerProxyInit();
533 ASSERT_EQ(ret, SOFTBUS_OK);
534
535 ret = ServerIpcOpenAuthSession(nullptr, addrInfo);
536 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
537
538 ret = ServerIpcOpenAuthSession(g_sessionName, nullptr);
539 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
540
541 ret = ServerIpcOpenAuthSession(g_sessionName, addrInfo);
542 EXPECT_EQ(ret, SOFTBUS_NO_INIT);
543
544 TransClientDeinit();
545 SoftBusFree(addrInfo);
546 }
547
548 /**
549 * @tc.name: ServerIpcNotifyAuthSuccessTest001
550 * @tc.desc: ServerIpcNotifyAuthSuccess, use the wrong parameter.
551 * @tc.type: FUNC
552 * @tc.require:I5HQGA
553 */
HWTEST_F(TransIpcStandardTest, ServerIpcNotifyAuthSuccessTest001, TestSize.Level0)554 HWTEST_F(TransIpcStandardTest, ServerIpcNotifyAuthSuccessTest001, TestSize.Level0)
555 {
556 int32_t ret = TransServerProxyInit();
557 ASSERT_EQ(ret, SOFTBUS_OK);
558
559 int32_t channelId = 0;
560 int32_t channelType = CHANNEL_TYPE_AUTH;
561 ret = ServerIpcNotifyAuthSuccess(channelId, channelType);
562 EXPECT_EQ(ret, SOFTBUS_ACCESS_TOKEN_DENIED);
563 TransClientDeinit();
564 }
565
566 /**
567 * @tc.name: ServerIpcCloseChannelTest001
568 * @tc.desc: ServerIpcCloseChannel, use the wrong parameter.
569 * @tc.type: FUNC
570 * @tc.require:I5HQGA
571 */
HWTEST_F(TransIpcStandardTest, ServerIpcCloseChannelTest001, TestSize.Level0)572 HWTEST_F(TransIpcStandardTest, ServerIpcCloseChannelTest001, TestSize.Level0)
573 {
574 int32_t channelId = 0;
575 int32_t chanType = CHANNEL_TYPE_AUTH;
576 int32_t ret = ServerIpcCloseChannel(nullptr, channelId, chanType);
577 EXPECT_EQ(ret, SOFTBUS_ACCESS_TOKEN_DENIED);
578
579 ret = TransServerProxyInit();
580 ASSERT_EQ(ret, SOFTBUS_OK);
581
582 ret = ServerIpcCloseChannel(nullptr, -1, chanType);
583 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
584
585 ret = ServerIpcCloseChannel(nullptr, channelId, chanType);
586 EXPECT_EQ(ret, SOFTBUS_ACCESS_TOKEN_DENIED);
587
588 TransClientDeinit();
589 }
590
591 /**
592 * @tc.name: ServerIpcCloseChannelWithStatisticsTest001
593 * @tc.desc: ServerIpcCloseChannelWithStatistics, use the wrong parameter.
594 * @tc.type: FUNC
595 * @tc.require:I5HQGA
596 */
HWTEST_F(TransIpcStandardTest, ServerIpcCloseChannelWithStatisticsTest001, TestSize.Level0)597 HWTEST_F(TransIpcStandardTest, ServerIpcCloseChannelWithStatisticsTest001, TestSize.Level0)
598 {
599 int32_t channelId = -1;
600 int32_t channelType = 0;
601 int32_t laneId = 0;
602 const char *dataInfo = "dataInfo";
603 uint32_t length = strlen(dataInfo);
604
605 int32_t ret = ServerIpcCloseChannelWithStatistics(channelId, channelType, laneId, (void *)dataInfo, length);
606 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
607 }
608
609 /**
610 * @tc.name: ServerIpcSendMessageTest001
611 * @tc.desc: ServerIpcSendMessage, use the wrong parameter.
612 * @tc.type: FUNC
613 * @tc.require:I5HQGA
614 */
HWTEST_F(TransIpcStandardTest, ServerIpcSendMessageTest001, TestSize.Level0)615 HWTEST_F(TransIpcStandardTest, ServerIpcSendMessageTest001, TestSize.Level0)
616 {
617 int32_t channelId = 0;
618 int32_t chanType = CHANNEL_TYPE_AUTH;
619 int32_t ret = ServerIpcSendMessage(channelId, chanType, nullptr, 0, 0);
620 EXPECT_EQ(ret, SOFTBUS_TRANS_PROXY_WRITERAWDATA_FAILED);
621
622 ret = TransServerProxyInit();
623 ASSERT_EQ(ret, SOFTBUS_OK);
624
625 ret = ServerIpcSendMessage(channelId, chanType, nullptr, 0, 0);
626 EXPECT_EQ(ret, SOFTBUS_TRANS_PROXY_WRITERAWDATA_FAILED);
627
628 TransClientDeinit();
629 }
630
631 /**
632 * @tc.name: ServerIpcQosReportTest001
633 * @tc.desc: ServerIpcQosReport, use the wrong parameter.
634 * @tc.type: FUNC
635 * @tc.require:I5HQGA
636 */
HWTEST_F(TransIpcStandardTest, ServerIpcQosReportTest001, TestSize.Level0)637 HWTEST_F(TransIpcStandardTest, ServerIpcQosReportTest001, TestSize.Level0)
638 {
639 int32_t channelId = 0;
640 int32_t chanType = CHANNEL_TYPE_AUTH;
641 int32_t appType = 0;
642 int32_t quality = QOS_IMPROVE;
643 int32_t ret = ServerIpcQosReport(channelId, chanType, appType, quality);
644 EXPECT_EQ(ret, SOFTBUS_ACCESS_TOKEN_DENIED);
645
646 ret = TransServerProxyInit();
647 ASSERT_EQ(ret, SOFTBUS_OK);
648
649 ret = ServerIpcQosReport(channelId, chanType, appType, quality);
650 EXPECT_EQ(ret, SOFTBUS_ACCESS_TOKEN_DENIED);
651
652 TransClientDeinit();
653 }
654
655 /**
656 * @tc.name: ServerIpcStreamStatsTest001
657 * @tc.desc: ServerIpcStreamStats, use the wrong parameter.
658 * @tc.type: FUNC
659 * @tc.require:I5HQGA
660 */
HWTEST_F(TransIpcStandardTest, ServerIpcStreamStatsTest001, TestSize.Level0)661 HWTEST_F(TransIpcStandardTest, ServerIpcStreamStatsTest001, TestSize.Level0)
662 {
663 int32_t channelId = 0;
664 int32_t chanType = CHANNEL_TYPE_AUTH;
665 int32_t ret = ServerIpcStreamStats(channelId, chanType, nullptr);
666 EXPECT_EQ(ret, SOFTBUS_TRANS_PROXY_WRITERAWDATA_FAILED);
667
668 ret = TransServerProxyInit();
669 ASSERT_EQ(ret, SOFTBUS_OK);
670
671 ret = ServerIpcStreamStats(channelId, chanType, nullptr);
672 EXPECT_EQ(ret, SOFTBUS_TRANS_PROXY_WRITERAWDATA_FAILED);
673
674 TransClientDeinit();
675 }
676
677 /**
678 * @tc.name: ServerIpcRippleStatsTest001
679 * @tc.desc: ServerIpcRippleStats, use the wrong parameter.
680 * @tc.type: FUNC
681 * @tc.require:I5HQGA
682 */
HWTEST_F(TransIpcStandardTest, ServerIpcRippleStatsTest001, TestSize.Level0)683 HWTEST_F(TransIpcStandardTest, ServerIpcRippleStatsTest001, TestSize.Level0)
684 {
685 int32_t channelId = 0;
686 int32_t chanType = CHANNEL_TYPE_AUTH;
687 int32_t ret = ServerIpcRippleStats(channelId, chanType, nullptr);
688 EXPECT_EQ(ret, SOFTBUS_TRANS_PROXY_WRITERAWDATA_FAILED);
689
690 ret = TransServerProxyInit();
691 ASSERT_EQ(ret, SOFTBUS_OK);
692
693 ret = ServerIpcRippleStats(channelId, chanType, nullptr);
694 EXPECT_EQ(ret, SOFTBUS_TRANS_PROXY_WRITERAWDATA_FAILED);
695
696 TransClientDeinit();
697 }
698
699 /**
700 * @tc.name: ServerIpcGrantPermissionTest001
701 * @tc.desc: ServerIpcGrantPermission, use the wrong parameter.
702 * @tc.type: FUNC
703 * @tc.require:I5HQGA
704 */
HWTEST_F(TransIpcStandardTest, ServerIpcGrantPermissionTest001, TestSize.Level0)705 HWTEST_F(TransIpcStandardTest, ServerIpcGrantPermissionTest001, TestSize.Level0)
706 {
707 int32_t uid = 1;
708 int32_t pid = 1;
709 int32_t ret = ServerIpcGrantPermission(uid, pid, nullptr);
710 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
711
712 ret = TransServerProxyInit();
713 ASSERT_EQ(ret, SOFTBUS_OK);
714
715 ret = ServerIpcGrantPermission(uid, pid, nullptr);
716 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
717
718 ret = ServerIpcGrantPermission(uid, pid, g_sessionName);
719 EXPECT_EQ(ret, SOFTBUS_TRANS_PROXY_SEND_REQUEST_FAILED);
720
721 TransClientDeinit();
722 }
723
724 /**
725 * @tc.name: ServerIpcRemovePermissionTest001
726 * @tc.desc: ServerIpcRemovePermission, use the wrong parameter.
727 * @tc.type: FUNC
728 * @tc.require:I5HQGA
729 */
HWTEST_F(TransIpcStandardTest, ServerIpcRemovePermissionTest001, TestSize.Level0)730 HWTEST_F(TransIpcStandardTest, ServerIpcRemovePermissionTest001, TestSize.Level0)
731 {
732 int32_t ret = ServerIpcRemovePermission(nullptr);
733 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
734
735 ret = TransServerProxyInit();
736 ASSERT_EQ(ret, SOFTBUS_OK);
737
738 ret = ServerIpcRemovePermission(nullptr);
739 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
740
741 ret = ServerIpcRemovePermission(g_sessionName);
742 EXPECT_EQ(ret, SOFTBUS_TRANS_PROXY_SEND_REQUEST_FAILED);
743
744 TransClientDeinit();
745 }
746
747 /**
748 * @tc.name: ServerIpcEvaluateQosTest001
749 * @tc.desc: SendMessage, use the wrong parameter.
750 * @tc.type: FUNC
751 * @tc.require:I5HQGA
752 */
HWTEST_F(TransIpcStandardTest, ServerIpcEvaluateQosTest001, TestSize.Level0)753 HWTEST_F(TransIpcStandardTest, ServerIpcEvaluateQosTest001, TestSize.Level0)
754 {
755 TransDataType type = DATA_TYPE_MESSAGE;
756 uint32_t qosCount = QOS_TYPE_BUTT;
757 QosTV *qos = reinterpret_cast<QosTV *>(SoftBusCalloc(sizeof(QosTV)));
758 ASSERT_TRUE(qos != nullptr);
759
760 int32_t ret = ServerIpcEvaluateQos(nullptr, type, qos, qosCount);
761 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
762
763 ret = ServerIpcEvaluateQos(g_peerNetworkId, DATA_TYPE_BUTT, qos, qosCount);
764 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
765
766 ret = ServerIpcEvaluateQos(g_peerNetworkId, type, qos, 100);
767 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
768
769 ret = ServerIpcEvaluateQos(g_peerNetworkId, type, qos, qosCount);
770 EXPECT_EQ(SOFTBUS_ACCESS_TOKEN_DENIED, ret);
771 SoftBusFree(qos);
772 qos = nullptr;
773 ASSERT_TRUE(qos == nullptr);
774 }
775 }
776