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