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 #define private public
17 #define ENHANCED_FLAG
18
19 #include <gtest/gtest.h>
20
21 #include "auth_interface.h"
22 #include "disc_log.h"
23 #include "ipc_skeleton.h"
24 #include "iservice_registry.h"
25 #include "message_option.h"
26 #include "message_parcel.h"
27 #include "session_ipc_adapter.h"
28 #include "softbus_access_token_test.h"
29 #include "softbus_adapter_mem.h"
30 #include "softbus_common.h"
31 #include "softbus_error_code.h"
32 #include "softbus_feature_config.h"
33 #include "softbus_server.h"
34 #include "softbus_server_frame.h"
35 #include "softbus_server_ipc_interface_code.h"
36 #include "softbus_server_stub.cpp"
37 #include "softbus_server_stub.h"
38 #include "softbus_server_stub_test_mock.h"
39 #include "system_ability_definition.h"
40 #include "trans_session_manager.h"
41 #include "trans_session_service.h"
42 #include "trans_type.h"
43
44 using namespace testing;
45 using namespace testing::ext;
46
47 namespace OHOS {
48
49 #define TEST_SESSION_NAME_SIZE_MAX 256
50 #define TEST_DEVICE_ID_SIZE_MAX 50
51 #define TEST_GROUP_ID_SIZE_MAX 50
52 #define TEST_PKG_NAME_SIZE_MAX 65
53 #define TEST_MAX_LEN 1025
54
55 char g_mySessionName[TEST_SESSION_NAME_SIZE_MAX] = "com.test.trans.session";
56 char g_peerSessionName[TEST_SESSION_NAME_SIZE_MAX] = "com.test.trans.session.sendfile";
57 char g_peerDeviceId[TEST_DEVICE_ID_SIZE_MAX] = "com.test.trans.session.sendfile";
58 char g_groupId[TEST_GROUP_ID_SIZE_MAX] = "com.test.trans.session.sendfile";
59 char g_myPkgName[TEST_PKG_NAME_SIZE_MAX] = "test";
60
61 class SoftbusServerStubTest : public testing::Test {
62 public:
SoftbusServerStubTest()63 SoftbusServerStubTest()
64 {}
~SoftbusServerStubTest()65 ~SoftbusServerStubTest()
66 {}
67 static void SetUpTestCase(void);
68 static void TearDownTestCase(void);
SetUp()69 void SetUp() override
70 {}
TearDown()71 void TearDown() override
72 {}
73 };
74
SetUpTestCase(void)75 void SoftbusServerStubTest::SetUpTestCase(void)
76 {
77 SoftbusConfigInit();
78 ConnServerInit();
79 AuthInit();
80 BusCenterServerInit();
81 TransServerInit();
82 }
83
TearDownTestCase(void)84 void SoftbusServerStubTest::TearDownTestCase(void)
85 {
86 NiceMock<SoftbusServerStubTestInterfaceMock> softbusServerStubMock;
87 EXPECT_CALL(softbusServerStubMock, UnregChangeListener).WillRepeatedly(Return(SOFTBUS_OK));
88 ConnServerDeinit();
89 AuthDeinit();
90 BusCenterServerDeinit();
91 TransServerDeinit();
92 }
93
GenerateSessionParam()94 SessionParam *GenerateSessionParam()
95 {
96 SetAccessTokenPermission("SoftBusServerStubTest");
97 SessionParam *sessionParam = (SessionParam *)SoftBusCalloc(sizeof(SessionParam));
98 EXPECT_NE(nullptr, sessionParam);
99 SessionAttribute attr;
100 attr.dataType = 1;
101 attr.linkTypeNum = 0;
102 sessionParam->sessionName = g_mySessionName;
103 sessionParam->peerSessionName = g_peerSessionName;
104 sessionParam->peerDeviceId = g_peerDeviceId;
105 sessionParam->groupId = g_groupId;
106 sessionParam->attr = &attr;
107 return sessionParam;
108 }
109
DeGenerateSessionParam(SessionParam * sessionParam)110 void DeGenerateSessionParam(SessionParam *sessionParam)
111 {
112 if (sessionParam != nullptr) {
113 SoftBusFree(sessionParam);
114 }
115 }
116
GenerateSessionServer()117 static SessionServer *GenerateSessionServer()
118 {
119 SessionServer *sessionServer = (SessionServer*)SoftBusCalloc(sizeof(SessionServer));
120 EXPECT_NE(nullptr, sessionServer);
121 int32_t ret = strcpy_s(sessionServer->sessionName, sizeof(sessionServer->sessionName), g_mySessionName);
122 if (ret != EOK) {
123 SoftBusFree(sessionServer);
124 return nullptr;
125 }
126 ret = strcpy_s(sessionServer->pkgName, sizeof(sessionServer->pkgName), g_myPkgName);
127 if (ret != EOK) {
128 SoftBusFree(sessionServer);
129 return nullptr;
130 }
131 return sessionServer;
132 }
133
DeGenerateSessionServer(SessionServer * sessionServer)134 void DeGenerateSessionServer(SessionServer *sessionServer)
135 {
136 if (sessionServer != nullptr) {
137 SoftBusFree(sessionServer);
138 }
139 }
140
GenerateRemoteObject(void)141 static sptr<IRemoteObject> GenerateRemoteObject(void)
142 {
143 auto samgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
144 if (samgr != nullptr) {
145 return samgr->GetSystemAbility(SOFTBUS_SERVER_SA_ID);
146 }
147 return nullptr;
148 }
149
150 /**
151 * @tc.name: SoftbusServerStubTest001
152 * @tc.desc: Verify the CheckOpenSessionPermission function.
153 * @tc.type: FUNC
154 * @tc.require:
155 */
156 HWTEST_F(SoftbusServerStubTest, SoftbusServerStubTest001, TestSize.Level1)
157 {
158 int32_t ret = TransSessionMgrInit();
159 EXPECT_EQ(SOFTBUS_OK, ret);
160 SessionServer *sessionServer = GenerateSessionServer();
161 EXPECT_NE(nullptr, sessionServer);
162 ret = TransSessionServerAddItem(sessionServer);
163 EXPECT_EQ(SOFTBUS_OK, ret);
164
165 SessionParam *sessionParam001 = GenerateSessionParam();
166 ASSERT_NE(nullptr, sessionParam001);
167 sptr<OHOS::SoftBusServerStub> softBusServer = new OHOS::SoftBusServer(SOFTBUS_SERVER_SA_ID, true);
168 ASSERT_NE(nullptr, softBusServer);
169 NiceMock<SoftbusServerStubTestInterfaceMock> softbusServerStubMock;
170 EXPECT_CALL(softbusServerStubMock, CheckTransPermission).WillRepeatedly(Return(SOFTBUS_OK));
171 EXPECT_CALL(softbusServerStubMock, CheckTransSecLevel).WillRepeatedly(Return(SOFTBUS_OK));
172 EXPECT_CALL(softbusServerStubMock, CheckUidAndPid).WillRepeatedly(Return(true));
173 ret = softBusServer->CheckOpenSessionPermission(sessionParam001);
174 EXPECT_EQ(SOFTBUS_OK, ret);
175 DeGenerateSessionParam(sessionParam001);
176
177 SessionParam *sessionParam002 = nullptr;
178 ret = softBusServer->CheckOpenSessionPermission(sessionParam002);
179 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
180 DeGenerateSessionParam(sessionParam002);
181
182 SessionParam *sessionParam003 = GenerateSessionParam();
183 ASSERT_NE(nullptr, sessionParam003);
184 sessionParam003->peerSessionName = nullptr;
185 EXPECT_CALL(softbusServerStubMock, CheckTransSecLevel).WillRepeatedly(Return(SOFTBUS_PERMISSION_DENIED));
186 ret = softBusServer->CheckOpenSessionPermission(sessionParam003);
187 EXPECT_EQ(SOFTBUS_PERMISSION_DENIED, ret);
188 DeGenerateSessionParam(sessionParam003);
189
190 DeGenerateSessionServer(sessionServer);
191 TransSessionMgrDeinit();
192 }
193
194 /**
195 * @tc.name: SoftbusServerStubTest002
196 * @tc.desc: Verify the CheckChannelPermission function.
197 * @tc.type: FUNC
198 * @tc.require:
199 */
200 HWTEST_F(SoftbusServerStubTest, SoftbusServerStubTest002, TestSize.Level1)
201 {
202 sptr<OHOS::SoftBusServerStub> softBusServer = new OHOS::SoftBusServer(SOFTBUS_SERVER_SA_ID, true);
203 ASSERT_NE(nullptr, softBusServer);
204 NiceMock<SoftbusServerStubTestInterfaceMock> softbusServerStubMock;
205 int32_t channelId = 0;
206 int32_t channelType = 0;
207
208 EXPECT_CALL(softbusServerStubMock, TransGetNameByChanId).WillRepeatedly(Return(SOFTBUS_INVALID_PARAM));
209 int32_t ret = softBusServer->CheckChannelPermission(channelId, channelType);
210 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
211
212 EXPECT_CALL(softbusServerStubMock, TransGetNameByChanId).WillRepeatedly(Return(SOFTBUS_OK));
213 EXPECT_CALL(softbusServerStubMock, CheckTransPermission).WillRepeatedly(Return(SOFTBUS_OK));
214 ret = softBusServer->CheckChannelPermission(channelId, channelType);
215 EXPECT_EQ(SOFTBUS_OK, ret);
216
217 EXPECT_CALL(softbusServerStubMock, CheckTransPermission).WillRepeatedly(Return(SOFTBUS_PERMISSION_DENIED));
218 ret = softBusServer->CheckChannelPermission(channelId, channelType);
219 EXPECT_EQ(SOFTBUS_PERMISSION_DENIED, ret);
220 }
221
222 /**
223 * @tc.name: SoftbusServerStubTest007
224 * @tc.desc: Verify the SoftbusRegisterServiceInner function.
225 * @tc.type: FUNC
226 * @tc.require:
227 */
228 HWTEST_F(SoftbusServerStubTest, SoftbusServerStubTest007, TestSize.Level1)
229 {
230 sptr<OHOS::SoftBusServerStub> softBusServer = new OHOS::SoftBusServer(SOFTBUS_SERVER_SA_ID, true);
231 ASSERT_NE(nullptr, softBusServer);
232 char test[10] = "test";
233 MessageParcel datas;
234 MessageParcel reply;
235 sptr<IRemoteObject> obj = GenerateRemoteObject();
236 EXPECT_NE(nullptr, obj);
237
238 int32_t ret = softBusServer->SoftbusRegisterServiceInner(datas, reply);
239 EXPECT_EQ(SOFTBUS_TRANS_PROXY_REMOTE_NULL, ret);
240
241 datas.WriteRemoteObject(obj);
242 ret = softBusServer->SoftbusRegisterServiceInner(datas, reply);
243 EXPECT_EQ(SOFTBUS_TRANS_PROXY_READCSTRING_FAILED, ret);
244
245 datas.WriteRemoteObject(obj);
246 datas.WriteCString(test);
247 ret = softBusServer->SoftbusRegisterServiceInner(datas, reply);
248 EXPECT_EQ(SOFTBUS_OK, ret);
249 }
250
251 /**
252 * @tc.name: SoftbusServerStubTest008
253 * @tc.desc: Verify the OnRemoteRequest function.
254 * @tc.type: FUNC
255 * @tc.require:
256 */
257 HWTEST_F(SoftbusServerStubTest, SoftbusServerStubTest008, TestSize.Level1)
258 {
259 NiceMock<SoftbusServerStubTestInterfaceMock> softbusServerStubMock;
260 EXPECT_CALL(softbusServerStubMock, UnregChangeListener).WillRepeatedly(Return(SOFTBUS_OK));
261 sptr<OHOS::SoftBusServerStub> softBusServer = new OHOS::SoftBusServer(SOFTBUS_SERVER_SA_ID, true);
262 ASSERT_NE(nullptr, softBusServer);
263 uint32_t code = SERVER_OPEN_SESSION;
264 MessageParcel datas;
265 MessageParcel reply;
266 MessageOption option;
267
268 int32_t ret = softBusServer->OnRemoteRequest(code, datas, reply, option);
269 EXPECT_EQ(SOFTBUS_IPC_ERR, ret);
270
271 datas.WriteInterfaceToken(std::u16string(u"test"));
272 ret = softBusServer->OnRemoteRequest(code, datas, reply, option);
273 EXPECT_EQ(SOFTBUS_IPC_ERR, ret);
274
275 InitSoftBusServer();
276 datas.WriteInterfaceToken(std::u16string(u"test"));
277 ret = softBusServer->OnRemoteRequest(code, datas, reply, option);
278 EXPECT_EQ(SOFTBUS_IPC_ERR, ret);
279 }
280
281 /**
282 * @tc.name: SoftbusServerStubTest009
283 * @tc.desc: Verify the Create and Remove SessionServerInner function.
284 * @tc.type: FUNC
285 * @tc.require:
286 */
287 HWTEST_F(SoftbusServerStubTest, SoftbusServerStubTest009, TestSize.Level1)
288 {
289 sptr<OHOS::SoftBusServerStub> softBusServer = new OHOS::SoftBusServer(SOFTBUS_SERVER_SA_ID, true);
290 ASSERT_NE(nullptr, softBusServer);
291 NiceMock<SoftbusServerStubTestInterfaceMock> softbusServerStubMock;
292 char test[10] = "test";
293 uint64_t timestamp = 1;
294 MessageParcel datas;
295 MessageParcel reply;
296
297 int32_t ret = softBusServer->CreateSessionServerInner(datas, reply);
298 EXPECT_EQ(SOFTBUS_TRANS_PROXY_READCSTRING_FAILED, ret);
299
300 datas.WriteCString(test);
301 datas.WriteCString(test);
302 datas.WriteUint64(timestamp);
303 ret = softBusServer->CreateSessionServerInner(datas, reply);
304 EXPECT_EQ(SOFTBUS_OK, ret);
305
306 datas.WriteCString(test);
307 datas.WriteCString(test);
308 ret = softBusServer->CreateSessionServerInner(datas, reply);
309 EXPECT_EQ(SOFTBUS_OK, ret);
310
311 ret = softBusServer->RemoveSessionServerInner(datas, reply);
312 EXPECT_EQ(SOFTBUS_TRANS_PROXY_READCSTRING_FAILED, ret);
313
314 datas.WriteCString(test);
315 ret = softBusServer->RemoveSessionServerInner(datas, reply);
316 EXPECT_EQ(SOFTBUS_OK, ret);
317
318 EXPECT_CALL(softbusServerStubMock, CheckTransPermission).WillRepeatedly(Return(SOFTBUS_PERMISSION_DENIED));
319 datas.WriteCString(test);
320 datas.WriteCString(test);
321 ret = softBusServer->RemoveSessionServerInner(datas, reply);
322 EXPECT_EQ(SOFTBUS_OK, ret);
323
324 EXPECT_CALL(softbusServerStubMock, CheckTransPermission).WillRepeatedly(Return(SOFTBUS_OK));
325 datas.WriteCString(test);
326 datas.WriteCString(test);
327 ret = softBusServer->RemoveSessionServerInner(datas, reply);
328 EXPECT_EQ(SOFTBUS_TRANS_CHECK_PID_ERROR, ret);
329 }
330
331 /**
332 * @tc.name: SoftbusServerStubTest010
333 * @tc.desc: Verify the ReadQosInfo function.
334 * @tc.type: FUNC
335 * @tc.require:
336 */
337 HWTEST_F(SoftbusServerStubTest, SoftbusServerStubTest010, TestSize.Level1)
338 {
339 unsigned int qosCount = 0;
340 bool boolNum = false;
341 QosTV qosInfo[7];
342 MessageParcel datas;
343 SessionParam param;
344
345 bool ret = ReadQosInfo(datas, param);
346 EXPECT_EQ(false, ret);
347
348 datas.WriteBool(boolNum);
349 ret = ReadQosInfo(datas, param);
350 EXPECT_EQ(true, ret);
351
352 boolNum = true;
353 datas.WriteBool(boolNum);
354 ret = ReadQosInfo(datas, param);
355 EXPECT_EQ(false, ret);
356
357 datas.WriteBool(boolNum);
358 datas.WriteUint32(qosCount);
359 ret = ReadQosInfo(datas, param);
360 EXPECT_EQ(true, ret);
361
362 qosCount = 10;
363 datas.WriteBool(boolNum);
364 datas.WriteUint32(qosCount);
365 ret = ReadQosInfo(datas, param);
366 EXPECT_EQ(false, ret);
367
368 qosCount = 7;
369 datas.WriteBool(boolNum);
370 datas.WriteUint32(qosCount);
371 ret = ReadQosInfo(datas, param);
372 EXPECT_EQ(false, ret);
373
374 datas.WriteBool(boolNum);
375 datas.WriteUint32(qosCount);
376 datas.WriteBuffer(qosInfo, sizeof(QosTV) * 7);
377 ret = ReadQosInfo(datas, param);
378 EXPECT_EQ(true, ret);
379 }
380
381 /**
382 * @tc.name: SoftbusServerStubTest011
383 * @tc.desc: Verify the OpenSessionInner function.
384 * @tc.type: FUNC
385 * @tc.require:
386 */
387 HWTEST_F(SoftbusServerStubTest, SoftbusServerStubTest011, TestSize.Level1)
388 {
389 sptr<OHOS::SoftBusServerStub> softBusServer = new OHOS::SoftBusServer(SOFTBUS_SERVER_SA_ID, true);
390 ASSERT_NE(nullptr, softBusServer);
391 char test[10] = "test";
392 bool boolNum = false;
393 MessageParcel datas;
394 MessageParcel reply;
395
396 int32_t ret = softBusServer->OpenSessionInner(datas, reply);
397 EXPECT_EQ(SOFTBUS_IPC_ERR, ret);
398
399 datas.WriteCString(test);
400 datas.WriteCString(test);
401 datas.WriteCString(test);
402 datas.WriteCString(test);
403 datas.WriteBool(boolNum);
404 datas.WriteInt32(0);
405 datas.WriteInt32(0);
406 datas.WriteInt32(0);
407 datas.WriteInt32(0);
408 datas.WriteUint16(0);
409 datas.WriteBool(boolNum);
410 ret = softBusServer->OpenSessionInner(datas, reply);
411 EXPECT_EQ(SOFTBUS_IPC_ERR, ret);
412 }
413
414 /**
415 * @tc.name: SoftbusServerStubTest012
416 * @tc.desc: Verify the OpenAuthSessionInner function.
417 * @tc.type: FUNC
418 * @tc.require:
419 */
420 HWTEST_F(SoftbusServerStubTest, SoftbusServerStubTest012, TestSize.Level1)
421 {
422 sptr<OHOS::SoftBusServerStub> softBusServer = new OHOS::SoftBusServer(SOFTBUS_SERVER_SA_ID, true);
423 ASSERT_NE(nullptr, softBusServer);
424 ConnectionAddr addrInfo;
425 memset_s(&addrInfo, sizeof(ConnectionAddr), 0, sizeof(ConnectionAddr));
426 char test[10] = "test";
427 MessageParcel datas;
428 MessageParcel reply;
429
430 int32_t ret = softBusServer->OpenAuthSessionInner(datas, reply);
431 EXPECT_EQ(SOFTBUS_TRANS_PROXY_READCSTRING_FAILED, ret);
432
433 datas.WriteCString(test);
434 datas.WriteRawData(&addrInfo, sizeof(ConnectionAddr));
435 ret = softBusServer->OpenAuthSessionInner(datas, reply);
436 EXPECT_EQ(SOFTBUS_OK, ret);
437 }
438
439 /**
440 * @tc.name: SoftbusServerStubTest013
441 * @tc.desc: Verify the NotifyAuthSuccessInner function.
442 * @tc.type: FUNC
443 * @tc.require:
444 */
445 HWTEST_F(SoftbusServerStubTest, SoftbusServerStubTest013, TestSize.Level1)
446 {
447 sptr<OHOS::SoftBusServerStub> softBusServer = new OHOS::SoftBusServer(SOFTBUS_SERVER_SA_ID, true);
448 ASSERT_NE(nullptr, softBusServer);
449 int32_t channelId = 0;
450 int32_t channelType = 0;
451 MessageParcel datas;
452 MessageParcel reply;
453
454 NiceMock<SoftbusServerStubTestInterfaceMock> softbusServerStubMock;
455 EXPECT_CALL(softbusServerStubMock, TransGetAndComparePid).WillRepeatedly(Return(SOFTBUS_OK));
456 int32_t ret = softBusServer->NotifyAuthSuccessInner(datas, reply);
457 EXPECT_EQ(SOFTBUS_TRANS_PROXY_READINT_FAILED, ret);
458
459 datas.WriteInt32(channelId);
460 ret = softBusServer->NotifyAuthSuccessInner(datas, reply);
461 EXPECT_EQ(SOFTBUS_TRANS_PROXY_READINT_FAILED, ret);
462
463 datas.WriteInt32(channelId);
464 datas.WriteInt32(channelType);
465 ret = softBusServer->NotifyAuthSuccessInner(datas, reply);
466 EXPECT_EQ(SOFTBUS_OK, ret);
467 }
468
469 /**
470 * @tc.name: SoftbusServerStubTest014
471 * @tc.desc: Verify the ReleaseResourcesInner function.
472 * @tc.type: FUNC
473 * @tc.require:
474 */
475 HWTEST_F(SoftbusServerStubTest, SoftbusServerStubTest014, TestSize.Level1)
476 {
477 sptr<OHOS::SoftBusServerStub> softBusServer = new OHOS::SoftBusServer(SOFTBUS_SERVER_SA_ID, true);
478 ASSERT_NE(nullptr, softBusServer);
479 NiceMock<SoftbusServerStubTestInterfaceMock> softbusServerStubMock;
480 int32_t channelId = 0;
481 MessageParcel datas;
482 MessageParcel reply;
483
484 int32_t ret = softBusServer->ReleaseResourcesInner(datas, reply);
485 EXPECT_EQ(SOFTBUS_IPC_ERR, ret);
486
487 datas.WriteInt32(channelId);
488 EXPECT_CALL(softbusServerStubMock, TransGetAndComparePid).WillRepeatedly(Return(SOFTBUS_NO_INIT));
489 ret = softBusServer->ReleaseResourcesInner(datas, reply);
490 EXPECT_EQ(SOFTBUS_NO_INIT, ret);
491
492 datas.WriteInt32(channelId);
493 EXPECT_CALL(softbusServerStubMock, TransGetAndComparePid).WillRepeatedly(Return(SOFTBUS_OK));
494 EXPECT_CALL(softbusServerStubMock, TransReleaseUdpResources).WillRepeatedly(Return(SOFTBUS_OK));
495 ret = softBusServer->ReleaseResourcesInner(datas, reply);
496 EXPECT_EQ(SOFTBUS_OK, ret);
497 }
498
499 /**
500 * @tc.name: SoftbusServerStubTest015
501 * @tc.desc: Verify the CloseChannelInner function.
502 * @tc.type: FUNC
503 * @tc.require:
504 */
505 HWTEST_F(SoftbusServerStubTest, SoftbusServerStubTest015, TestSize.Level1)
506 {
507 sptr<OHOS::SoftBusServerStub> softBusServer = new OHOS::SoftBusServer(SOFTBUS_SERVER_SA_ID, true);
508 ASSERT_NE(nullptr, softBusServer);
509 NiceMock<SoftbusServerStubTestInterfaceMock> softbusServerStubMock;
510 char test[10] = "test";
511 int32_t channelId = 0;
512 int32_t channelType = CHANNEL_TYPE_UNDEFINED;
513 MessageParcel datas;
514 MessageParcel reply;
515
516 int32_t ret = softBusServer->CloseChannelInner(datas, reply);
517 EXPECT_EQ(SOFTBUS_TRANS_PROXY_READINT_FAILED, ret);
518 datas.WriteInt32(channelId);
519 ret = softBusServer->CloseChannelInner(datas, reply);
520 EXPECT_EQ(SOFTBUS_TRANS_PROXY_READINT_FAILED, ret);
521
522 datas.WriteInt32(channelId);
523 datas.WriteInt32(channelType);
524 ret = softBusServer->CloseChannelInner(datas, reply);
525 EXPECT_EQ(SOFTBUS_IPC_ERR, ret);
526 datas.WriteInt32(channelId);
527 datas.WriteInt32(channelType);
528 datas.WriteCString(test);
529 EXPECT_CALL(softbusServerStubMock, TransGetAndComparePidBySession).WillRepeatedly(Return(SOFTBUS_NO_INIT));
530 ret = softBusServer->CloseChannelInner(datas, reply);
531 EXPECT_EQ(SOFTBUS_NO_INIT, ret);
532
533 datas.WriteInt32(channelId);
534 datas.WriteInt32(channelType);
535 datas.WriteCString(test);
536 EXPECT_CALL(softbusServerStubMock, TransGetAndComparePidBySession).WillRepeatedly(Return(SOFTBUS_OK));
537 ret = softBusServer->CloseChannelInner(datas, reply);
538 EXPECT_EQ(SOFTBUS_OK, ret);
539 channelType = 0;
540 datas.WriteInt32(channelId);
541 datas.WriteInt32(channelType);
542 datas.WriteCString(test);
543 EXPECT_CALL(softbusServerStubMock, TransGetAndComparePid).WillRepeatedly(Return(SOFTBUS_NO_INIT));
544 ret = softBusServer->CloseChannelInner(datas, reply);
545 EXPECT_EQ(SOFTBUS_NO_INIT, ret);
546
547 datas.WriteInt32(channelId);
548 datas.WriteInt32(channelType);
549 datas.WriteCString(test);
550 EXPECT_CALL(softbusServerStubMock, TransGetAndComparePid).WillRepeatedly(Return(SOFTBUS_OK));
551 ret = softBusServer->CloseChannelInner(datas, reply);
552 EXPECT_EQ(SOFTBUS_OK, ret);
553 }
554
555 /**
556 * @tc.name: SoftbusServerStubTest016
557 * @tc.desc: Verify the CloseChannelWithStatisticsInner function.
558 * @tc.type: FUNC
559 * @tc.require:
560 */
561 HWTEST_F(SoftbusServerStubTest, SoftbusServerStubTest016, TestSize.Level1)
562 {
563 sptr<OHOS::SoftBusServerStub> softBusServer = new OHOS::SoftBusServer(SOFTBUS_SERVER_SA_ID, true);
564 ASSERT_NE(nullptr, softBusServer);
565 char test[10] = "test";
566 int32_t channelId = 1;
567 uint64_t laneId = 1;
568 uint32_t len = 10;
569 int32_t channelType = 0;
570 MessageParcel datas;
571 MessageParcel reply;
572
573 int32_t ret = softBusServer->CloseChannelWithStatisticsInner(datas, reply);
574 EXPECT_EQ(SOFTBUS_TRANS_PROXY_READINT_FAILED, ret);
575
576 datas.WriteInt32(channelId);
577 ret = softBusServer->CloseChannelWithStatisticsInner(datas, reply);
578 EXPECT_EQ(SOFTBUS_TRANS_PROXY_READINT_FAILED, ret);
579
580 datas.WriteInt32(channelId);
581 datas.WriteInt32(channelType);
582 ret = softBusServer->CloseChannelWithStatisticsInner(datas, reply);
583 EXPECT_EQ(SOFTBUS_TRANS_PROXY_READUINT_FAILED, ret);
584
585 datas.WriteInt32(channelId);
586 datas.WriteInt32(channelType);
587 datas.WriteUint64(laneId);
588 ret = softBusServer->CloseChannelWithStatisticsInner(datas, reply);
589 EXPECT_EQ(SOFTBUS_TRANS_PROXY_READUINT_FAILED, ret);
590
591 datas.WriteInt32(channelId);
592 datas.WriteInt32(channelType);
593 datas.WriteUint64(laneId);
594 datas.WriteUint32(len);
595 ret = softBusServer->CloseChannelWithStatisticsInner(datas, reply);
596 EXPECT_EQ(SOFTBUS_IPC_ERR, ret);
597
598 datas.WriteInt32(channelId);
599 datas.WriteInt32(channelType);
600 datas.WriteUint64(laneId);
601 datas.WriteUint32(len);
602 datas.WriteRawData(test, len);
603 ret = softBusServer->CloseChannelWithStatisticsInner(datas, reply);
604 EXPECT_EQ(SOFTBUS_OK, ret);
605 }
606
607 /**
608 * @tc.name: SoftbusServerStubTest017
609 * @tc.desc: Verify the SendMessageInner function part01.
610 * @tc.type: FUNC
611 * @tc.require:
612 */
613 HWTEST_F(SoftbusServerStubTest, SoftbusServerStubTest017, TestSize.Level1)
614 {
615 sptr<OHOS::SoftBusServerStub> softBusServer = new OHOS::SoftBusServer(SOFTBUS_SERVER_SA_ID, true);
616 ASSERT_NE(nullptr, softBusServer);
617 char test[10] = "test";
618 int32_t channelId = 0;
619 int32_t channelType = 0;
620 uint32_t len = 10;
621 MessageParcel datas;
622 MessageParcel reply;
623
624 int32_t ret = softBusServer->SendMessageInner(datas, reply);
625 EXPECT_EQ(SOFTBUS_TRANS_PROXY_READINT_FAILED, ret);
626
627 datas.WriteInt32(channelId);
628 ret = softBusServer->SendMessageInner(datas, reply);
629 EXPECT_EQ(SOFTBUS_TRANS_PROXY_READINT_FAILED, ret);
630
631 datas.WriteInt32(channelId);
632 datas.WriteInt32(channelType);
633 ret = softBusServer->SendMessageInner(datas, reply);
634 EXPECT_EQ(SOFTBUS_TRANS_PROXY_READUINT_FAILED, ret);
635
636 datas.WriteInt32(channelId);
637 datas.WriteInt32(channelType);
638 datas.WriteUint32(len);
639 ret = softBusServer->SendMessageInner(datas, reply);
640 EXPECT_EQ(SOFTBUS_IPC_ERR, ret);
641
642 datas.WriteInt32(channelId);
643 datas.WriteInt32(channelType);
644 datas.WriteUint32(len);
645 datas.WriteRawData(test, len);
646 ret = softBusServer->SendMessageInner(datas, reply);
647 EXPECT_EQ(SOFTBUS_TRANS_PROXY_READINT_FAILED, ret);
648 }
649
650 /**
651 * @tc.name: SoftbusServerStubTest018
652 * @tc.desc: Verify the SendMessageInner function part02.
653 * @tc.type: FUNC
654 * @tc.require:
655 */
656 HWTEST_F(SoftbusServerStubTest, SoftbusServerStubTest018, TestSize.Level1)
657 {
658 sptr<OHOS::SoftBusServerStub> softBusServer = new OHOS::SoftBusServer(SOFTBUS_SERVER_SA_ID, true);
659 ASSERT_NE(nullptr, softBusServer);
660 NiceMock<SoftbusServerStubTestInterfaceMock> softbusServerStubMock;
661 char test[10] = "test";
662 int32_t channelId = 0;
663 int32_t channelType = 0;
664 uint32_t len = 10;
665 int32_t msgType = 0;
666 MessageParcel datas;
667 MessageParcel reply;
668
669 datas.WriteInt32(channelId);
670 datas.WriteInt32(channelType);
671 datas.WriteUint32(len);
672 datas.WriteRawData(test, len);
673 datas.WriteInt32(msgType);
674 EXPECT_CALL(softbusServerStubMock, TransGetAppInfoByChanId).WillRepeatedly(Return(SOFTBUS_NOT_FIND));
675 int32_t ret = softBusServer->SendMessageInner(datas, reply);
676 EXPECT_EQ(SOFTBUS_OK, ret);
677 }
678
679 /**
680 * @tc.name: SoftbusServerStubTest019
681 * @tc.desc: Verify the EvaluateQosInner function.
682 * @tc.type: FUNC
683 * @tc.require:
684 */
685 HWTEST_F(SoftbusServerStubTest, SoftbusServerStubTest019, TestSize.Level1)
686 {
687 sptr<OHOS::SoftBusServerStub> softBusServer = new OHOS::SoftBusServer(SOFTBUS_SERVER_SA_ID, true);
688 ASSERT_NE(nullptr, softBusServer);
689 char test[10] = "test";
690 QosTV qosInfo[7];
691 int32_t dataTypeNumber = 0;
692 uint32_t qosCount = 10;
693 MessageParcel datas;
694 MessageParcel reply;
695
696 int32_t ret = softBusServer->EvaluateQosInner(datas, reply);
697 EXPECT_EQ(SOFTBUS_IPC_ERR, ret);
698
699 datas.WriteCString(test);
700 ret = softBusServer->EvaluateQosInner(datas, reply);
701 EXPECT_EQ(SOFTBUS_IPC_ERR, ret);
702
703 datas.WriteCString(test);
704 datas.WriteInt32(dataTypeNumber);
705 ret = softBusServer->EvaluateQosInner(datas, reply);
706 EXPECT_EQ(SOFTBUS_IPC_ERR, ret);
707
708 dataTypeNumber = 5;
709 datas.WriteCString(test);
710 datas.WriteInt32(dataTypeNumber);
711 ret = softBusServer->EvaluateQosInner(datas, reply);
712 EXPECT_EQ(SOFTBUS_IPC_ERR, ret);
713
714 datas.WriteCString(test);
715 datas.WriteInt32(dataTypeNumber);
716 datas.WriteInt32(qosCount);
717 ret = softBusServer->EvaluateQosInner(datas, reply);
718 EXPECT_EQ(SOFTBUS_IPC_ERR, ret);
719
720 qosCount = 7;
721 datas.WriteCString(test);
722 datas.WriteInt32(dataTypeNumber);
723 datas.WriteInt32(qosCount);
724 ret = softBusServer->EvaluateQosInner(datas, reply);
725 EXPECT_EQ(SOFTBUS_IPC_ERR, ret);
726
727 datas.WriteCString(test);
728 datas.WriteInt32(dataTypeNumber);
729 datas.WriteInt32(qosCount);
730 datas.WriteBuffer(qosInfo, sizeof(QosTV) * qosCount);
731 ret = softBusServer->EvaluateQosInner(datas, reply);
732 EXPECT_EQ(SOFTBUS_OK, ret);
733 }
734
735 /**
736 * @tc.name: SoftbusServerStubTest020
737 * @tc.desc: Verify the Join and Leave LNNInner function.
738 * @tc.type: FUNC
739 * @tc.require:
740 */
741 HWTEST_F(SoftbusServerStubTest, SoftbusServerStubTest020, TestSize.Level1)
742 {
743 SetAccessTokenPermission("device_manager");
744 NiceMock<SoftbusServerStubTestInterfaceMock> softbusServerStubMock;
745 sptr<OHOS::SoftBusServerStub> softBusServer = new OHOS::SoftBusServer(SOFTBUS_SERVER_SA_ID, true);
746 ASSERT_NE(nullptr, softBusServer);
747 ConnectionAddr addr;
748 char test[10] = "test";
749 uint32_t addrTypeLen = sizeof(ConnectionAddr);
750 MessageParcel datas;
751 MessageParcel reply;
752
753 EXPECT_CALL(softbusServerStubMock, CheckLnnPermission).WillRepeatedly(Return(SOFTBUS_PERMISSION_DENIED));
754 int32_t ret = softBusServer->JoinLNNInner(datas, reply);
755 EXPECT_EQ(SOFTBUS_PERMISSION_DENIED, ret);
756 EXPECT_CALL(softbusServerStubMock, CheckLnnPermission).WillRepeatedly(Return(SOFTBUS_OK));
757 ret = softBusServer->JoinLNNInner(datas, reply);
758 EXPECT_EQ(SOFTBUS_IPC_ERR, ret);
759
760 datas.WriteCString(test);
761 ret = softBusServer->JoinLNNInner(datas, reply);
762 EXPECT_EQ(SOFTBUS_IPC_ERR, ret);
763
764 datas.WriteCString(test);
765 datas.WriteUint32(addrTypeLen);
766 ret = softBusServer->JoinLNNInner(datas, reply);
767 EXPECT_EQ(SOFTBUS_IPC_ERR, ret);
768
769 datas.WriteCString(test);
770 datas.WriteUint32(addrTypeLen);
771 datas.WriteRawData(&addr, addrTypeLen);
772 ret = softBusServer->JoinLNNInner(datas, reply);
773 EXPECT_EQ(SOFTBUS_IPC_ERR, ret);
774
775 ret = softBusServer->LeaveLNNInner(datas, reply);
776 EXPECT_EQ(SOFTBUS_IPC_ERR, ret);
777
778 datas.WriteCString(test);
779 ret = softBusServer->LeaveLNNInner(datas, reply);
780 EXPECT_EQ(SOFTBUS_IPC_ERR, ret);
781
782 datas.WriteCString(test);
783 datas.WriteCString(test);
784 ret = softBusServer->LeaveLNNInner(datas, reply);
785 EXPECT_EQ(SOFTBUS_OK, ret);
786 EXPECT_CALL(softbusServerStubMock, CheckLnnPermission).WillRepeatedly(Return(SOFTBUS_PERMISSION_DENIED));
787 ret = softBusServer->LeaveLNNInner(datas, reply);
788 EXPECT_EQ(SOFTBUS_PERMISSION_DENIED, ret);
789 }
790
791 /**
792 * @tc.name: SoftbusServerStubTest021
793 * @tc.desc: Verify the GetAllOnlineNodeInfoInner function.
794 * @tc.type: FUNC
795 * @tc.require:
796 */
797 HWTEST_F(SoftbusServerStubTest, SoftbusServerStubTest021, TestSize.Level1)
798 {
799 sptr<OHOS::SoftBusServerStub> softBusServer = new OHOS::SoftBusServer(SOFTBUS_SERVER_SA_ID, true);
800 ASSERT_NE(nullptr, softBusServer);
801 NiceMock<SoftbusServerStubTestInterfaceMock> softbusServerStubMock;
802 char test[10] = "test";
803 uint32_t infoTypeLen = 0;
804 MessageParcel datas;
805 MessageParcel reply;
806
807 int32_t ret = softBusServer->GetAllOnlineNodeInfoInner(datas, reply);
808 EXPECT_NE(SOFTBUS_NO_INIT, ret);
809
810 datas.WriteCString(test);
811 ret = softBusServer->GetAllOnlineNodeInfoInner(datas, reply);
812 EXPECT_NE(SOFTBUS_NO_INIT, ret);
813
814 datas.WriteCString(test);
815 datas.WriteUint32(infoTypeLen);
816 EXPECT_CALL(softbusServerStubMock, LnnIpcGetAllOnlineNodeInfo).WillRepeatedly(
817 Return(SOFTBUS_NETWORK_GET_ALL_NODE_INFO_ERR)
818 );
819 EXPECT_CALL(softbusServerStubMock, SoftBusCheckIsNormalApp).WillRepeatedly(
820 Return(false)
821 );
822 ret = softBusServer->GetAllOnlineNodeInfoInner(datas, reply);
823 EXPECT_NE(SOFTBUS_NO_INIT, ret);
824
825 datas.WriteCString(test);
826 datas.WriteUint32(infoTypeLen);
827 EXPECT_CALL(softbusServerStubMock, LnnIpcGetAllOnlineNodeInfo).WillRepeatedly(Return(SOFTBUS_OK));
828 ret = softBusServer->GetAllOnlineNodeInfoInner(datas, reply);
829 EXPECT_NE(SOFTBUS_NO_INIT, ret);
830 }
831
832 /**
833 * @tc.name: SoftbusServerStubTest022
834 * @tc.desc: Verify the GetLocalDeviceInfoInner function.
835 * @tc.type: FUNC
836 * @tc.require:
837 */
838 HWTEST_F(SoftbusServerStubTest, SoftbusServerStubTest022, TestSize.Level1)
839 {
840 sptr<OHOS::SoftBusServerStub> softBusServer = new OHOS::SoftBusServer(SOFTBUS_SERVER_SA_ID, true);
841 ASSERT_NE(nullptr, softBusServer);
842 NiceMock<SoftbusServerStubTestInterfaceMock> softbusServerStubMock;
843 char test[10] = "test";
844 uint32_t infoTypeLen = 0;
845 MessageParcel datas;
846 MessageParcel reply;
847
848 int32_t ret = softBusServer->GetLocalDeviceInfoInner(datas, reply);
849 EXPECT_EQ(SOFTBUS_IPC_ERR, ret);
850
851 datas.WriteCString(test);
852 ret = softBusServer->GetLocalDeviceInfoInner(datas, reply);
853 EXPECT_EQ(SOFTBUS_IPC_ERR, ret);
854
855 datas.WriteCString(test);
856 datas.WriteUint32(infoTypeLen);
857 ret = softBusServer->GetLocalDeviceInfoInner(datas, reply);
858 EXPECT_EQ(SOFTBUS_IPC_ERR, ret);
859
860 infoTypeLen = sizeof(NodeBasicInfo);
861 datas.WriteCString(test);
862 datas.WriteUint32(infoTypeLen);
863 EXPECT_CALL(softbusServerStubMock, LnnIpcGetLocalDeviceInfo).WillRepeatedly(
864 Return(SOFTBUS_NETWORK_GET_LOCAL_NODE_INFO_ERR)
865 );
866 ret = softBusServer->GetLocalDeviceInfoInner(datas, reply);
867 EXPECT_EQ(SOFTBUS_OK, ret);
868
869 datas.WriteCString(test);
870 datas.WriteUint32(infoTypeLen);
871 EXPECT_CALL(softbusServerStubMock, LnnIpcGetLocalDeviceInfo).WillRepeatedly(Return(SOFTBUS_OK));
872 ret = softBusServer->GetLocalDeviceInfoInner(datas, reply);
873 EXPECT_NE(SOFTBUS_IPC_ERR, ret);
874 }
875
876 /**
877 * @tc.name: SoftbusServerStubTest023
878 * @tc.desc: Verify the GetNodeKeyInfoInner function part01.
879 * @tc.type: FUNC
880 * @tc.require:
881 */
882 HWTEST_F(SoftbusServerStubTest, SoftbusServerStubTest023, TestSize.Level1)
883 {
884 sptr<OHOS::SoftBusServerStub> softBusServer = new OHOS::SoftBusServer(SOFTBUS_SERVER_SA_ID, true);
885 ASSERT_NE(nullptr, softBusServer);
886 NiceMock<SoftbusServerStubTestInterfaceMock> softbusServerStubMock;
887 EXPECT_CALL(softbusServerStubMock, LnnIpcGetNodeKeyInfo).WillRepeatedly(Return(SOFTBUS_OK));
888 char test[10] = "test";
889 int32_t key = 13;
890 uint32_t len = 20;
891 MessageParcel datas;
892 MessageParcel reply;
893 int32_t ret = softBusServer->GetNodeKeyInfoInner(datas, reply);
894 ret = softBusServer->GetNodeKeyInfoInner(datas, reply);
895 EXPECT_EQ(SOFTBUS_IPC_ERR, ret);
896
897 datas.WriteCString(test);
898 ret = softBusServer->GetNodeKeyInfoInner(datas, reply);
899 EXPECT_EQ(SOFTBUS_IPC_ERR, ret);
900
901 datas.WriteCString(test);
902 datas.WriteCString(test);
903 ret = softBusServer->GetNodeKeyInfoInner(datas, reply);
904 EXPECT_EQ(SOFTBUS_IPC_ERR, ret);
905
906 datas.WriteCString(test);
907 datas.WriteCString(test);
908 datas.WriteInt32(key);
909 datas.WriteUint32(len);
910 ret = softBusServer->GetNodeKeyInfoInner(datas, reply);
911 EXPECT_NE(SOFTBUS_IPC_ERR, ret);
912 }
913
914 /**
915 * @tc.name: SoftbusServerStubTest024
916 * @tc.desc: Verify the GetNodeKeyInfoInner function part02.
917 * @tc.type: FUNC
918 * @tc.require:
919 */
920 HWTEST_F(SoftbusServerStubTest, SoftbusServerStubTest024, TestSize.Level1)
921 {
922 sptr<OHOS::SoftBusServerStub> softBusServer = new OHOS::SoftBusServer(SOFTBUS_SERVER_SA_ID, true);
923 ASSERT_NE(nullptr, softBusServer);
924 NiceMock<SoftbusServerStubTestInterfaceMock> softbusServerStubMock;
925 char test[10] = "test";
926 int32_t key = 0;
927 uint32_t len = 0;
928 MessageParcel datas;
929 MessageParcel reply;
930
931 datas.WriteCString(test);
932 datas.WriteCString(test);
933 datas.WriteInt32(key);
934 int32_t ret = softBusServer->GetNodeKeyInfoInner(datas, reply);
935 EXPECT_EQ(SOFTBUS_IPC_ERR, ret);
936
937 datas.WriteCString(test);
938 datas.WriteCString(test);
939 datas.WriteInt32(key);
940 datas.WriteUint32(len);
941 ret = softBusServer->GetNodeKeyInfoInner(datas, reply);
942 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
943
944 len = 65;
945 datas.WriteCString(test);
946 datas.WriteCString(test);
947 datas.WriteInt32(key);
948 datas.WriteUint32(len);
949 EXPECT_CALL(softbusServerStubMock, LnnIpcGetNodeKeyInfo).WillRepeatedly(Return(SOFTBUS_NETWORK_NODE_KEY_INFO_ERR));
950 ret = softBusServer->GetNodeKeyInfoInner(datas, reply);
951 EXPECT_EQ(SOFTBUS_OK, ret);
952
953 datas.WriteCString(test);
954 datas.WriteCString(test);
955 datas.WriteInt32(key);
956 datas.WriteUint32(len);
957 EXPECT_CALL(softbusServerStubMock, LnnIpcGetNodeKeyInfo).WillRepeatedly(Return(SOFTBUS_OK));
958 ret = softBusServer->GetNodeKeyInfoInner(datas, reply);
959 EXPECT_NE(SOFTBUS_IPC_ERR, ret);
960 }
961
962 /**
963 * @tc.name: SoftbusServerStubTest025
964 * @tc.desc: Verify the SetNodeDataChangeFlagInner function.
965 * @tc.type: FUNC
966 * @tc.require:
967 */
968 HWTEST_F(SoftbusServerStubTest, SoftbusServerStubTest025, TestSize.Level1)
969 {
970 SetAccessTokenPermission("device_manager");
971 NiceMock<SoftbusServerStubTestInterfaceMock> softbusServerStubMock;
972 sptr<OHOS::SoftBusServerStub> softBusServer = new OHOS::SoftBusServer(SOFTBUS_SERVER_SA_ID, true);
973 ASSERT_NE(nullptr, softBusServer);
974 char test[10] = "test";
975 uint16_t changeFlag = 0;
976 MessageParcel datas;
977 MessageParcel reply;
978 EXPECT_CALL(softbusServerStubMock, CheckLnnPermission).WillRepeatedly(Return(SOFTBUS_PERMISSION_DENIED));
979 int32_t ret = softBusServer->SetNodeDataChangeFlagInner(datas, reply);
980 EXPECT_EQ(SOFTBUS_PERMISSION_DENIED, ret);
981 EXPECT_CALL(softbusServerStubMock, CheckLnnPermission).WillRepeatedly(Return(SOFTBUS_OK));
982 ret = softBusServer->SetNodeDataChangeFlagInner(datas, reply);
983 EXPECT_EQ(SOFTBUS_IPC_ERR, ret);
984
985 datas.WriteCString(test);
986 ret = softBusServer->SetNodeDataChangeFlagInner(datas, reply);
987 EXPECT_EQ(SOFTBUS_IPC_ERR, ret);
988
989 datas.WriteCString(test);
990 datas.WriteCString(test);
991 ret = softBusServer->SetNodeDataChangeFlagInner(datas, reply);
992 EXPECT_EQ(SOFTBUS_IPC_ERR, ret);
993
994 datas.WriteCString(test);
995 datas.WriteCString(test);
996 datas.WriteUint16(changeFlag);
997 ret = softBusServer->SetNodeDataChangeFlagInner(datas, reply);
998 EXPECT_EQ(SOFTBUS_OK, ret);
999 }
1000
1001 /**
1002 * @tc.name: SoftbusServerStubTest026
1003 * @tc.desc: Verify the RegDataLevelChangeCbInner function.
1004 * @tc.type: FUNC
1005 * @tc.require:
1006 */
1007 HWTEST_F(SoftbusServerStubTest, SoftbusServerStubTest026, TestSize.Level1)
1008 {
1009 SetAccessTokenPermission("distributeddata");
1010 NiceMock<SoftbusServerStubTestInterfaceMock> softbusServerStubMock;
1011 sptr<OHOS::SoftBusServerStub> softBusServer = new OHOS::SoftBusServer(SOFTBUS_SERVER_SA_ID, true);
1012 ASSERT_NE(nullptr, softBusServer);
1013 char test[10] = "test";
1014 MessageParcel datas;
1015 MessageParcel reply;
1016 EXPECT_CALL(softbusServerStubMock, CheckLnnPermission).WillRepeatedly(Return(SOFTBUS_PERMISSION_DENIED));
1017 int32_t ret = softBusServer->RegDataLevelChangeCbInner(datas, reply);
1018 EXPECT_EQ(SOFTBUS_PERMISSION_DENIED, ret);
1019 EXPECT_CALL(softbusServerStubMock, CheckLnnPermission).WillRepeatedly(Return(SOFTBUS_OK));
1020 ret = softBusServer->RegDataLevelChangeCbInner(datas, reply);
1021 EXPECT_EQ(SOFTBUS_IPC_ERR, ret);
1022
1023 datas.WriteCString(test);
1024 ret = softBusServer->RegDataLevelChangeCbInner(datas, reply);
1025 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
1026 }
1027
1028 /**
1029 * @tc.name: SoftbusServerStubTest027
1030 * @tc.desc: Verify the UnregDataLevelChangeCbInner function.
1031 * @tc.type: FUNC
1032 * @tc.require:
1033 */
1034 HWTEST_F(SoftbusServerStubTest, SoftbusServerStubTest027, TestSize.Level1)
1035 {
1036 SetAccessTokenPermission("distributeddata");
1037 NiceMock<SoftbusServerStubTestInterfaceMock> softbusServerStubMock;
1038 sptr<OHOS::SoftBusServerStub> softBusServer = new OHOS::SoftBusServer(SOFTBUS_SERVER_SA_ID, true);
1039 ASSERT_NE(nullptr, softBusServer);
1040 char test[10] = "test";
1041 MessageParcel datas;
1042 MessageParcel reply;
1043 EXPECT_CALL(softbusServerStubMock, CheckLnnPermission).WillRepeatedly(Return(SOFTBUS_PERMISSION_DENIED));
1044 int32_t ret = softBusServer->UnregDataLevelChangeCbInner(datas, reply);
1045 EXPECT_EQ(SOFTBUS_PERMISSION_DENIED, ret);
1046 EXPECT_CALL(softbusServerStubMock, CheckLnnPermission).WillRepeatedly(Return(SOFTBUS_OK));
1047 ret = softBusServer->UnregDataLevelChangeCbInner(datas, reply);
1048 EXPECT_EQ(SOFTBUS_IPC_ERR, ret);
1049
1050 datas.WriteCString(test);
1051 ret = softBusServer->UnregDataLevelChangeCbInner(datas, reply);
1052 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
1053 }
1054
1055 /**
1056 * @tc.name: SoftbusServerStubTest028
1057 * @tc.desc: Verify the SetDataLevelInner function.
1058 * @tc.type: FUNC
1059 * @tc.require:
1060 */
1061 HWTEST_F(SoftbusServerStubTest, SoftbusServerStubTest028, TestSize.Level1)
1062 {
1063 SetAccessTokenPermission("distributeddata");
1064 NiceMock<SoftbusServerStubTestInterfaceMock> softbusServerStubMock;
1065 sptr<OHOS::SoftBusServerStub> softBusServer = new OHOS::SoftBusServer(SOFTBUS_SERVER_SA_ID, true);
1066 ASSERT_NE(nullptr, softBusServer);
1067 DataLevel dataLevel;
1068 MessageParcel datas;
1069 MessageParcel reply;
1070 EXPECT_CALL(softbusServerStubMock, CheckLnnPermission).WillRepeatedly(Return(SOFTBUS_PERMISSION_DENIED));
1071 int32_t ret = softBusServer->SetDataLevelInner(datas, reply);
1072 EXPECT_EQ(SOFTBUS_PERMISSION_DENIED, ret);
1073 EXPECT_CALL(softbusServerStubMock, CheckLnnPermission).WillRepeatedly(Return(SOFTBUS_OK));
1074 ret = softBusServer->SetDataLevelInner(datas, reply);
1075 EXPECT_EQ(SOFTBUS_IPC_ERR, ret);
1076
1077 datas.WriteRawData(&dataLevel, sizeof(dataLevel));
1078 ret = softBusServer->SetDataLevelInner(datas, reply);
1079 EXPECT_EQ(SOFTBUS_OK, ret);
1080 }
1081
1082 /**
1083 * @tc.name: SoftbusServerStubTest029
1084 * @tc.desc: Verify the Start and Stop TimeSyncInner function.
1085 * @tc.type: FUNC
1086 * @tc.require:
1087 */
1088 HWTEST_F(SoftbusServerStubTest, SoftbusServerStubTest029, TestSize.Level1)
1089 {
1090 sptr<OHOS::SoftBusServerStub> softBusServer = new OHOS::SoftBusServer(SOFTBUS_SERVER_SA_ID, true);
1091 ASSERT_NE(nullptr, softBusServer);
1092 char test[10] = "test";
1093 int32_t accuracy = 0;
1094 int32_t period = 0;
1095 MessageParcel datas;
1096 MessageParcel datas2;
1097 MessageParcel reply;
1098
1099 int32_t ret = softBusServer->StartTimeSyncInner(datas, reply);
1100 EXPECT_EQ(SOFTBUS_IPC_ERR, ret);
1101
1102 datas.WriteCString(test);
1103 datas.WriteCString(test);
1104 ret = softBusServer->StartTimeSyncInner(datas, reply);
1105 EXPECT_EQ(SOFTBUS_IPC_ERR, ret);
1106
1107 datas.WriteCString(test);
1108 datas.WriteCString(test);
1109 datas.WriteInt32(accuracy);
1110 ret = softBusServer->StartTimeSyncInner(datas, reply);
1111 EXPECT_EQ(SOFTBUS_IPC_ERR, ret);
1112
1113 datas.WriteCString(test);
1114 datas.WriteCString(test);
1115 datas.WriteInt32(accuracy);
1116 datas.WriteInt32(period);
1117 ret = softBusServer->StartTimeSyncInner(datas, reply);
1118 EXPECT_EQ(SOFTBUS_OK, ret);
1119
1120 datas.WriteCString(test);
1121 ret = softBusServer->StopTimeSyncInner(datas, reply);
1122 EXPECT_EQ(SOFTBUS_IPC_ERR, ret);
1123
1124 datas.WriteCString(test);
1125 datas.WriteCString(test);
1126 ret = softBusServer->StopTimeSyncInner(datas, reply);
1127 EXPECT_EQ(SOFTBUS_OK, ret);
1128
1129 ret = softBusServer->StopTimeSyncInner(datas2, reply);
1130 EXPECT_EQ(SOFTBUS_IPC_ERR, ret);
1131
1132 datas.WriteCString(test);
1133 ret = softBusServer->StartTimeSyncInner(datas, reply);
1134 EXPECT_EQ(SOFTBUS_IPC_ERR, ret);
1135 }
1136
1137 /**
1138 * @tc.name: SoftbusServerStubTest030
1139 * @tc.desc: Verify the QosReportInner function.
1140 * @tc.type: FUNC
1141 * @tc.require:
1142 */
1143 HWTEST_F(SoftbusServerStubTest, SoftbusServerStubTest030, TestSize.Level1)
1144 {
1145 sptr<OHOS::SoftBusServerStub> softBusServer = new OHOS::SoftBusServer(SOFTBUS_SERVER_SA_ID, true);
1146 ASSERT_NE(nullptr, softBusServer);
1147 int32_t channelId = 0;
1148 int32_t channelType = 0;
1149 int32_t appType = 0;
1150 int32_t quality = 0;
1151 MessageParcel datas;
1152 MessageParcel reply;
1153
1154 NiceMock<SoftbusServerStubTestInterfaceMock> softbusServerStubMock;
1155 EXPECT_CALL(softbusServerStubMock, CheckUidAndPid).WillRepeatedly(Return(true));
1156 int32_t ret = softBusServer->QosReportInner(datas, reply);
1157 EXPECT_EQ(SOFTBUS_TRANS_PROXY_READINT_FAILED, ret);
1158
1159 datas.WriteInt32(channelId);
1160 ret = softBusServer->QosReportInner(datas, reply);
1161 EXPECT_EQ(SOFTBUS_TRANS_PROXY_READINT_FAILED, ret);
1162
1163 datas.WriteInt32(channelId);
1164 datas.WriteInt32(channelType);
1165 ret = softBusServer->QosReportInner(datas, reply);
1166 EXPECT_EQ(SOFTBUS_TRANS_PROXY_READINT_FAILED, ret);
1167
1168 datas.WriteInt32(channelId);
1169 datas.WriteInt32(channelType);
1170 datas.WriteInt32(appType);
1171 ret = softBusServer->QosReportInner(datas, reply);
1172 EXPECT_EQ(SOFTBUS_TRANS_PROXY_READINT_FAILED, ret);
1173
1174 datas.WriteInt32(channelId);
1175 datas.WriteInt32(channelType);
1176 datas.WriteInt32(appType);
1177 datas.WriteInt32(quality);
1178 ret = softBusServer->QosReportInner(datas, reply);
1179 EXPECT_EQ(SOFTBUS_OK, ret);
1180 }
1181
1182 /**
1183 * @tc.name: SoftbusServerStubTest031
1184 * @tc.desc: Verify the StreamStatsInner function.
1185 * @tc.type: FUNC
1186 * @tc.require:
1187 */
1188 HWTEST_F(SoftbusServerStubTest, SoftbusServerStubTest031, TestSize.Level1)
1189 {
1190 sptr<OHOS::SoftBusServerStub> softBusServer = new OHOS::SoftBusServer(SOFTBUS_SERVER_SA_ID, true);
1191 ASSERT_NE(nullptr, softBusServer);
1192 int32_t channelId = 0;
1193 int32_t channelType = 0;
1194 StreamSendStats stats;
1195 MessageParcel datas;
1196 MessageParcel reply;
1197
1198 NiceMock<SoftbusServerStubTestInterfaceMock> softbusServerStubMock;
1199 EXPECT_CALL(softbusServerStubMock, CheckUidAndPid).WillRepeatedly(Return(true));
1200 int32_t ret = softBusServer->StreamStatsInner(datas, reply);
1201 EXPECT_EQ(SOFTBUS_TRANS_PROXY_READINT_FAILED, ret);
1202
1203 datas.WriteInt32(channelId);
1204 ret = softBusServer->StreamStatsInner(datas, reply);
1205 EXPECT_EQ(SOFTBUS_TRANS_PROXY_READINT_FAILED, ret);
1206
1207 datas.WriteInt32(channelId);
1208 datas.WriteInt32(channelType);
1209 ret = softBusServer->StreamStatsInner(datas, reply);
1210 EXPECT_EQ(SOFTBUS_TRANS_PROXY_READRAWDATA_FAILED, ret);
1211
1212 datas.WriteInt32(channelId);
1213 datas.WriteInt32(channelType);
1214 datas.WriteRawData(&stats, sizeof(StreamSendStats));
1215 ret = softBusServer->StreamStatsInner(datas, reply);
1216 EXPECT_EQ(SOFTBUS_OK, ret);
1217 }
1218
1219 /**
1220 * @tc.name: SoftbusServerStubTest032
1221 * @tc.desc: Verify the RippleStatsInner function.
1222 * @tc.type: FUNC
1223 * @tc.require:
1224 */
1225 HWTEST_F(SoftbusServerStubTest, SoftbusServerStubTest032, TestSize.Level1)
1226 {
1227 sptr<OHOS::SoftBusServerStub> softBusServer = new OHOS::SoftBusServer(SOFTBUS_SERVER_SA_ID, true);
1228 ASSERT_NE(nullptr, softBusServer);
1229 int32_t channelId = 0;
1230 int32_t channelType = 0;
1231 TrafficStats stats;
1232 MessageParcel datas;
1233 MessageParcel reply;
1234
1235 NiceMock<SoftbusServerStubTestInterfaceMock> softbusServerStubMock;
1236 EXPECT_CALL(softbusServerStubMock, CheckUidAndPid).WillRepeatedly(Return(true));
1237 int32_t ret = softBusServer->RippleStatsInner(datas, reply);
1238 EXPECT_EQ(SOFTBUS_TRANS_PROXY_READINT_FAILED, ret);
1239
1240 datas.WriteInt32(channelId);
1241 ret = softBusServer->RippleStatsInner(datas, reply);
1242 EXPECT_EQ(SOFTBUS_TRANS_PROXY_READINT_FAILED, ret);
1243
1244 datas.WriteInt32(channelId);
1245 datas.WriteInt32(channelType);
1246 ret = softBusServer->RippleStatsInner(datas, reply);
1247 EXPECT_EQ(SOFTBUS_TRANS_PROXY_READRAWDATA_FAILED, ret);
1248
1249 datas.WriteInt32(channelId);
1250 datas.WriteInt32(channelType);
1251 datas.WriteRawData(&stats, sizeof(TrafficStats));
1252 ret = softBusServer->RippleStatsInner(datas, reply);
1253 EXPECT_EQ(SOFTBUS_OK, ret);
1254 }
1255
1256 /**
1257 * @tc.name: SoftbusServerStubTest033
1258 * @tc.desc: Verify the Grant and Remove Permission Inner function.
1259 * @tc.type: FUNC
1260 * @tc.require:
1261 */
1262 HWTEST_F(SoftbusServerStubTest, SoftbusServerStubTest033, TestSize.Level1)
1263 {
1264 sptr<OHOS::SoftBusServerStub> softBusServer = new OHOS::SoftBusServer(SOFTBUS_SERVER_SA_ID, true);
1265 ASSERT_NE(nullptr, softBusServer);
1266 NiceMock<SoftbusServerStubTestInterfaceMock> softbusServerStubMock;
1267 char test[10] = "test";
1268 int32_t uid = 0;
1269 int32_t pid = 0;
1270 MessageParcel datas;
1271 MessageParcel reply;
1272
1273 EXPECT_CALL(softbusServerStubMock, SoftBusCheckDynamicPermission).WillRepeatedly(Return(SOFTBUS_PERMISSION_DENIED));
1274 int32_t ret = softBusServer->GrantPermissionInner(datas, reply);
1275 EXPECT_EQ(SOFTBUS_OK, ret);
1276
1277 EXPECT_CALL(softbusServerStubMock, SoftBusCheckDynamicPermission).WillRepeatedly(Return(SOFTBUS_OK));
1278 datas.WriteInt32(uid);
1279 datas.WriteInt32(pid);
1280 ret = softBusServer->GrantPermissionInner(datas, reply);
1281 EXPECT_EQ(SOFTBUS_OK, ret);
1282
1283 datas.WriteInt32(uid);
1284 datas.WriteInt32(pid);
1285 datas.WriteCString(test);
1286 ret = softBusServer->GrantPermissionInner(datas, reply);
1287 EXPECT_EQ(SOFTBUS_OK, ret);
1288
1289 EXPECT_CALL(softbusServerStubMock, SoftBusCheckDynamicPermission).WillRepeatedly(Return(SOFTBUS_PERMISSION_DENIED));
1290 ret = softBusServer->RemovePermissionInner(datas, reply);
1291 EXPECT_EQ(SOFTBUS_OK, ret);
1292
1293 EXPECT_CALL(softbusServerStubMock, SoftBusCheckDynamicPermission).WillRepeatedly(Return(SOFTBUS_OK));
1294 ret = softBusServer->RemovePermissionInner(datas, reply);
1295 EXPECT_EQ(SOFTBUS_OK, ret);
1296
1297 datas.WriteCString(test);
1298 ret = softBusServer->RemovePermissionInner(datas, reply);
1299 EXPECT_EQ(SOFTBUS_OK, ret);
1300 }
1301
1302 /**
1303 * @tc.name: SoftbusServerStubTest034
1304 * @tc.desc: Verify the Publish and Stop Publish LNNInner function part01.
1305 * @tc.type: FUNC
1306 * @tc.require:
1307 */
1308 HWTEST_F(SoftbusServerStubTest, SoftbusServerStubTest034, TestSize.Level1)
1309 {
1310 sptr<OHOS::SoftBusServerStub> softBusServer = new OHOS::SoftBusServer(SOFTBUS_SERVER_SA_ID, true);
1311 ASSERT_NE(nullptr, softBusServer);
1312 char test[10] = "test";
1313 int32_t publishId = 0;
1314 int32_t mode = 0;
1315 int32_t medium = -1;
1316 MessageParcel datas;
1317 MessageParcel reply;
1318
1319 int32_t ret = softBusServer->PublishLNNInner(datas, reply);
1320 EXPECT_EQ(SOFTBUS_IPC_ERR, ret);
1321
1322 datas.WriteCString(test);
1323 ret = softBusServer->PublishLNNInner(datas, reply);
1324 EXPECT_EQ(SOFTBUS_IPC_ERR, ret);
1325
1326 datas.WriteCString(test);
1327 datas.WriteInt32(publishId);
1328 ret = softBusServer->PublishLNNInner(datas, reply);
1329 EXPECT_EQ(SOFTBUS_IPC_ERR, ret);
1330
1331 datas.WriteCString(test);
1332 datas.WriteInt32(publishId);
1333 datas.WriteInt32(mode);
1334 ret = softBusServer->PublishLNNInner(datas, reply);
1335 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
1336
1337 mode = 85;
1338 datas.WriteCString(test);
1339 datas.WriteInt32(publishId);
1340 datas.WriteInt32(mode);
1341 ret = softBusServer->PublishLNNInner(datas, reply);
1342 EXPECT_EQ(SOFTBUS_IPC_ERR, ret);
1343
1344 datas.WriteCString(test);
1345 datas.WriteInt32(publishId);
1346 datas.WriteInt32(mode);
1347 datas.WriteInt32(medium);
1348 ret = softBusServer->PublishLNNInner(datas, reply);
1349 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
1350 }
1351
1352 /**
1353 * @tc.name: SoftbusServerStubTest035
1354 * @tc.desc: Verify the Publish and Stop Publish LNNInner function part02.
1355 * @tc.type: FUNC
1356 * @tc.require:
1357 */
1358 HWTEST_F(SoftbusServerStubTest, SoftbusServerStubTest035, TestSize.Level1)
1359 {
1360 sptr<OHOS::SoftBusServerStub> softBusServer = new OHOS::SoftBusServer(SOFTBUS_SERVER_SA_ID, true);
1361 ASSERT_NE(nullptr, softBusServer);
1362 char test[10] = "test";
1363 int32_t publishId = 0;
1364 int32_t mode = 85;
1365 int32_t medium = 0;
1366 int32_t freq = -1;
1367 MessageParcel datas;
1368 MessageParcel reply;
1369
1370 datas.WriteCString(test);
1371 datas.WriteInt32(publishId);
1372 datas.WriteInt32(mode);
1373 datas.WriteInt32(medium);
1374 int32_t ret = softBusServer->PublishLNNInner(datas, reply);
1375 EXPECT_EQ(SOFTBUS_IPC_ERR, ret);
1376
1377 datas.WriteCString(test);
1378 datas.WriteInt32(publishId);
1379 datas.WriteInt32(mode);
1380 datas.WriteInt32(medium);
1381 datas.WriteInt32(freq);
1382 ret = softBusServer->PublishLNNInner(datas, reply);
1383 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
1384
1385 freq = 0;
1386 datas.WriteCString(test);
1387 datas.WriteInt32(publishId);
1388 datas.WriteInt32(mode);
1389 datas.WriteInt32(medium);
1390 datas.WriteInt32(freq);
1391 ret = softBusServer->PublishLNNInner(datas, reply);
1392 EXPECT_EQ(SOFTBUS_IPC_ERR, ret);
1393
1394 datas.WriteCString(test);
1395 datas.WriteInt32(publishId);
1396 datas.WriteInt32(mode);
1397 datas.WriteInt32(medium);
1398 datas.WriteInt32(freq);
1399 datas.WriteCString(test);
1400 ret = softBusServer->PublishLNNInner(datas, reply);
1401 EXPECT_EQ(SOFTBUS_IPC_ERR, ret);
1402 }
1403
1404 /**
1405 * @tc.name: SoftbusServerStubTest036
1406 * @tc.desc: Verify the Publish and Stop Publish LNNInner function part03.
1407 * @tc.type: FUNC
1408 * @tc.require:
1409 */
1410 HWTEST_F(SoftbusServerStubTest, SoftbusServerStubTest036, TestSize.Level1)
1411 {
1412 sptr<OHOS::SoftBusServerStub> softBusServer = new OHOS::SoftBusServer(SOFTBUS_SERVER_SA_ID, true);
1413 ASSERT_NE(nullptr, softBusServer);
1414 char test[10] = "test";
1415 int32_t publishId = 0;
1416 int32_t mode = 85;
1417 int32_t medium = 0;
1418 int32_t freq = 0;
1419 uint32_t dataLen = 0;
1420 bool ranging = true;
1421 MessageParcel datas;
1422 MessageParcel reply;
1423
1424 datas.WriteCString(test);
1425 datas.WriteInt32(publishId);
1426 datas.WriteInt32(mode);
1427 datas.WriteInt32(medium);
1428 datas.WriteInt32(freq);
1429 datas.WriteCString(test);
1430 datas.WriteUint32(dataLen);
1431 int32_t ret = softBusServer->PublishLNNInner(datas, reply);
1432 EXPECT_EQ(SOFTBUS_IPC_ERR, ret);
1433
1434 datas.WriteCString(test);
1435 datas.WriteInt32(publishId);
1436 datas.WriteInt32(mode);
1437 datas.WriteInt32(medium);
1438 datas.WriteInt32(freq);
1439 datas.WriteCString(test);
1440 datas.WriteUint32(dataLen);
1441 datas.WriteBool(ranging);
1442 ret = softBusServer->PublishLNNInner(datas, reply);
1443 EXPECT_EQ(SOFTBUS_OK, ret);
1444
1445 ret = softBusServer->StopPublishLNNInner(datas, reply);
1446 EXPECT_EQ(SOFTBUS_IPC_ERR, ret);
1447
1448 datas.WriteCString(test);
1449 ret = softBusServer->StopPublishLNNInner(datas, reply);
1450 EXPECT_EQ(SOFTBUS_IPC_ERR, ret);
1451
1452 datas.WriteCString(test);
1453 datas.WriteInt32(publishId);
1454 ret = softBusServer->StopPublishLNNInner(datas, reply);
1455 EXPECT_EQ(SOFTBUS_OK, ret);
1456 }
1457
1458 /**
1459 * @tc.name: SoftbusServerStubTest037
1460 * @tc.desc: Verify the Refresh and Stop Refresh LNNInner function part01.
1461 * @tc.type: FUNC
1462 * @tc.require:
1463 */
1464 HWTEST_F(SoftbusServerStubTest, SoftbusServerStubTest037, TestSize.Level1)
1465 {
1466 sptr<OHOS::SoftBusServerStub> softBusServer = new OHOS::SoftBusServer(SOFTBUS_SERVER_SA_ID, true);
1467 ASSERT_NE(nullptr, softBusServer);
1468 char test[10] = "test";
1469 int32_t subscribeId = 0;
1470 int32_t mode = 0;
1471 int32_t medium = -1;
1472 MessageParcel datas;
1473 MessageParcel reply;
1474
1475 int32_t ret = softBusServer->RefreshLNNInner(datas, reply);
1476 EXPECT_EQ(SOFTBUS_IPC_ERR, ret);
1477
1478 datas.WriteCString(test);
1479 ret = softBusServer->RefreshLNNInner(datas, reply);
1480 EXPECT_EQ(SOFTBUS_IPC_ERR, ret);
1481
1482 datas.WriteCString(test);
1483 datas.WriteInt32(subscribeId);
1484 ret = softBusServer->RefreshLNNInner(datas, reply);
1485 EXPECT_EQ(SOFTBUS_IPC_ERR, ret);
1486
1487 datas.WriteCString(test);
1488 datas.WriteInt32(subscribeId);
1489 datas.WriteInt32(mode);
1490 ret = softBusServer->RefreshLNNInner(datas, reply);
1491 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
1492
1493 mode = 85;
1494 datas.WriteCString(test);
1495 datas.WriteInt32(subscribeId);
1496 datas.WriteInt32(mode);
1497 ret = softBusServer->RefreshLNNInner(datas, reply);
1498 EXPECT_EQ(SOFTBUS_IPC_ERR, ret);
1499
1500 datas.WriteCString(test);
1501 datas.WriteInt32(subscribeId);
1502 datas.WriteInt32(mode);
1503 datas.WriteInt32(medium);
1504 ret = softBusServer->RefreshLNNInner(datas, reply);
1505 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
1506
1507 datas.WriteCString(test);
1508 ret = softBusServer->StopRefreshLNNInner(datas, reply);
1509 EXPECT_EQ(SOFTBUS_IPC_ERR, ret);
1510 }
1511
1512 /**
1513 * @tc.name: SoftbusServerStubTest038
1514 * @tc.desc: Verify the Refresh and Stop Refresh LNNInner function part02.
1515 * @tc.type: FUNC
1516 * @tc.require:
1517 */
1518 HWTEST_F(SoftbusServerStubTest, SoftbusServerStubTest038, TestSize.Level1)
1519 {
1520 sptr<OHOS::SoftBusServerStub> softBusServer = new OHOS::SoftBusServer(SOFTBUS_SERVER_SA_ID, true);
1521 ASSERT_NE(nullptr, softBusServer);
1522 char test[10] = "test";
1523 int32_t subscribeId = 0;
1524 int32_t mode = 85;
1525 int32_t medium = 0;
1526 int32_t freq = -1;
1527 bool flag = true;
1528 MessageParcel datas;
1529 MessageParcel reply;
1530
1531 datas.WriteCString(test);
1532 datas.WriteInt32(subscribeId);
1533 datas.WriteInt32(mode);
1534 datas.WriteInt32(medium);
1535 int32_t ret = softBusServer->RefreshLNNInner(datas, reply);
1536 EXPECT_EQ(SOFTBUS_IPC_ERR, ret);
1537
1538 datas.WriteCString(test);
1539 datas.WriteInt32(subscribeId);
1540 datas.WriteInt32(mode);
1541 datas.WriteInt32(medium);
1542 datas.WriteInt32(freq);
1543 ret = softBusServer->RefreshLNNInner(datas, reply);
1544 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
1545
1546 freq = 0;
1547 datas.WriteCString(test);
1548 datas.WriteInt32(subscribeId);
1549 datas.WriteInt32(mode);
1550 datas.WriteInt32(medium);
1551 datas.WriteInt32(freq);
1552 ret = softBusServer->RefreshLNNInner(datas, reply);
1553 EXPECT_EQ(SOFTBUS_IPC_ERR, ret);
1554
1555 datas.WriteCString(test);
1556 datas.WriteInt32(subscribeId);
1557 datas.WriteInt32(mode);
1558 datas.WriteInt32(medium);
1559 datas.WriteInt32(freq);
1560 datas.WriteBool(flag);
1561 ret = softBusServer->RefreshLNNInner(datas, reply);
1562 EXPECT_EQ(SOFTBUS_IPC_ERR, ret);
1563
1564 ret = softBusServer->StopRefreshLNNInner(datas, reply);
1565 EXPECT_EQ(SOFTBUS_IPC_ERR, ret);
1566 }
1567
1568 /**
1569 * @tc.name: SoftbusServerStubTest039
1570 * @tc.desc: Verify the Refresh and Stop Refresh LNNInner function part03.
1571 * @tc.type: FUNC
1572 * @tc.require:
1573 */
1574 HWTEST_F(SoftbusServerStubTest, SoftbusServerStubTest039, TestSize.Level1)
1575 {
1576 sptr<OHOS::SoftBusServerStub> softBusServer = new OHOS::SoftBusServer(SOFTBUS_SERVER_SA_ID, true);
1577 ASSERT_NE(nullptr, softBusServer);
1578 char test[10] = "test";
1579 int32_t subscribeId = 0;
1580 int32_t mode = 85;
1581 int32_t medium = 0;
1582 int32_t freq = 0;
1583 bool flag = true;
1584 uint32_t dataLen = 0;
1585 int32_t refreshId = 0;
1586 MessageParcel datas;
1587 MessageParcel reply;
1588 datas.WriteCString(test);
1589 datas.WriteInt32(subscribeId);
1590 datas.WriteInt32(mode);
1591 datas.WriteInt32(medium);
1592 datas.WriteInt32(freq);
1593 datas.WriteBool(flag);
1594 datas.WriteBool(flag);
1595 int32_t ret = softBusServer->RefreshLNNInner(datas, reply);
1596 EXPECT_EQ(SOFTBUS_IPC_ERR, ret);
1597 datas.WriteCString(test);
1598 datas.WriteInt32(subscribeId);
1599 datas.WriteInt32(mode);
1600 datas.WriteInt32(medium);
1601 datas.WriteInt32(freq);
1602 datas.WriteBool(flag);
1603 datas.WriteBool(flag);
1604 datas.WriteCString(test);
1605 ret = softBusServer->RefreshLNNInner(datas, reply);
1606 EXPECT_EQ(SOFTBUS_IPC_ERR, ret);
1607 datas.WriteCString(test);
1608 datas.WriteInt32(subscribeId);
1609 datas.WriteInt32(mode);
1610 datas.WriteInt32(medium);
1611 datas.WriteInt32(freq);
1612 datas.WriteBool(flag);
1613 datas.WriteBool(flag);
1614 datas.WriteCString(test);
1615 datas.WriteUint32(dataLen);
1616 ret = softBusServer->RefreshLNNInner(datas, reply);
1617 EXPECT_EQ(SOFTBUS_OK, ret);
1618 datas.WriteCString(test);
1619 datas.WriteInt32(refreshId);
1620 ret = softBusServer->StopRefreshLNNInner(datas, reply);
1621 EXPECT_EQ(SOFTBUS_OK, ret);
1622 }
1623
1624 /**
1625 * @tc.name: SoftbusServerStubTest040
1626 * @tc.desc: Verify the Active and DeActive MetaNode Inner function.
1627 * @tc.type: FUNC
1628 * @tc.require:
1629 */
1630 HWTEST_F(SoftbusServerStubTest, SoftbusServerStubTest040, TestSize.Level1)
1631 {
1632 SetAccessTokenPermission("device_manager");
1633 sptr<OHOS::SoftBusServerStub> softBusServer = new OHOS::SoftBusServer(SOFTBUS_SERVER_SA_ID, true);
1634 ASSERT_NE(nullptr, softBusServer);
1635 NiceMock<SoftbusServerStubTestInterfaceMock> softbusServerStubMock;
1636 char test[10] = "test";
1637 MetaNodeConfigInfo info;
1638 MessageParcel datas;
1639 MessageParcel reply;
1640 EXPECT_CALL(softbusServerStubMock, CheckLnnPermission).WillRepeatedly(Return(SOFTBUS_PERMISSION_DENIED));
1641 int32_t ret = softBusServer->ActiveMetaNodeInner(datas, reply);
1642 EXPECT_EQ(SOFTBUS_PERMISSION_DENIED, ret);
1643 EXPECT_CALL(softbusServerStubMock, CheckLnnPermission).WillRepeatedly(Return(SOFTBUS_OK));
1644 ret = softBusServer->ActiveMetaNodeInner(datas, reply);
1645 EXPECT_EQ(SOFTBUS_IPC_ERR, ret);
1646
1647 datas.WriteRawData(&info, sizeof(MetaNodeConfigInfo));
1648 EXPECT_CALL(softbusServerStubMock, LnnIpcActiveMetaNode).WillRepeatedly(
1649 Return(SOFTBUS_NETWORK_ACTIVE_META_NODE_ERR)
1650 );
1651 ret = softBusServer->ActiveMetaNodeInner(datas, reply);
1652 EXPECT_EQ(SOFTBUS_OK, ret);
1653
1654 datas.WriteRawData(&info, sizeof(MetaNodeConfigInfo));
1655 EXPECT_CALL(softbusServerStubMock, LnnIpcActiveMetaNode).WillRepeatedly(Return(SOFTBUS_OK));
1656 ret = softBusServer->ActiveMetaNodeInner(datas, reply);
1657 EXPECT_NE(SOFTBUS_IPC_ERR, ret);
1658
1659 ret = softBusServer->DeactiveMetaNodeInner(datas, reply);
1660 EXPECT_EQ(SOFTBUS_IPC_ERR, ret);
1661
1662 datas.WriteCString(test);
1663 EXPECT_CALL(softbusServerStubMock, LnnIpcDeactiveMetaNode).WillRepeatedly(
1664 Return(SOFTBUS_NETWORK_DEACTIVE_META_NODE_ERR)
1665 );
1666 ret = softBusServer->DeactiveMetaNodeInner(datas, reply);
1667 EXPECT_EQ(SOFTBUS_NETWORK_DEACTIVE_META_NODE_ERR, ret);
1668
1669 datas.WriteCString(test);
1670 EXPECT_CALL(softbusServerStubMock, LnnIpcDeactiveMetaNode).WillRepeatedly(Return(SOFTBUS_OK));
1671 ret = softBusServer->DeactiveMetaNodeInner(datas, reply);
1672 EXPECT_NE(SOFTBUS_IPC_ERR, ret);
1673 EXPECT_CALL(softbusServerStubMock, CheckLnnPermission).WillRepeatedly(Return(SOFTBUS_PERMISSION_DENIED));
1674 ret = softBusServer->DeactiveMetaNodeInner(datas, reply);
1675 EXPECT_EQ(SOFTBUS_PERMISSION_DENIED, ret);
1676 }
1677
1678 /**
1679 * @tc.name: SoftbusServerStubTest041
1680 * @tc.desc: Verify the GetAllMetaNodeInfoInner function.
1681 * @tc.type: FUNC
1682 * @tc.require:
1683 */
1684 HWTEST_F(SoftbusServerStubTest, SoftbusServerStubTest041, TestSize.Level1)
1685 {
1686 SetAccessTokenPermission("device_manager");
1687 sptr<OHOS::SoftBusServerStub> softBusServer = new OHOS::SoftBusServer(SOFTBUS_SERVER_SA_ID, true);
1688 ASSERT_NE(nullptr, softBusServer);
1689 NiceMock<SoftbusServerStubTestInterfaceMock> softbusServerStubMock;
1690 int32_t infoNum = 4;
1691 MessageParcel datas;
1692 MessageParcel reply;
1693
1694 EXPECT_CALL(softbusServerStubMock, CheckLnnPermission).WillRepeatedly(Return(SOFTBUS_PERMISSION_DENIED));
1695 int32_t ret = softBusServer->GetAllMetaNodeInfoInner(datas, reply);
1696 EXPECT_EQ(SOFTBUS_PERMISSION_DENIED, ret);
1697 EXPECT_CALL(softbusServerStubMock, CheckLnnPermission).WillRepeatedly(Return(SOFTBUS_OK));
1698 ret = softBusServer->GetAllMetaNodeInfoInner(datas, reply);
1699 EXPECT_EQ(SOFTBUS_IPC_ERR, ret);
1700
1701 datas.WriteInt32(infoNum);
1702 ret = softBusServer->GetAllMetaNodeInfoInner(datas, reply);
1703 EXPECT_EQ(SOFTBUS_IPC_ERR, ret);
1704
1705 infoNum = 2;
1706 datas.WriteInt32(infoNum);
1707 EXPECT_CALL(softbusServerStubMock, LnnIpcGetAllMetaNodeInfo).WillRepeatedly(
1708 Return(SOFTBUS_NETWORK_GET_META_NODE_INFO_ERR)
1709 );
1710 ret = softBusServer->GetAllMetaNodeInfoInner(datas, reply);
1711 EXPECT_EQ(SOFTBUS_NETWORK_GET_META_NODE_INFO_ERR, ret);
1712
1713 datas.WriteInt32(infoNum);
1714 EXPECT_CALL(softbusServerStubMock, LnnIpcGetAllMetaNodeInfo).WillRepeatedly(Return(SOFTBUS_OK));
1715 ret = softBusServer->GetAllMetaNodeInfoInner(datas, reply);
1716 EXPECT_NE(SOFTBUS_IPC_ERR, ret);
1717 }
1718
1719 /**
1720 * @tc.name: SoftbusServerStubTest042
1721 * @tc.desc: Verify the ShiftLNNGearInner function.
1722 * @tc.type: FUNC
1723 * @tc.require:
1724 */
1725 HWTEST_F(SoftbusServerStubTest, SoftbusServerStubTest042, TestSize.Level1)
1726 {
1727 SetAccessTokenPermission("SoftBusServerStubTest");
1728 NiceMock<SoftbusServerStubTestInterfaceMock> softbusServerStubMock;
1729 sptr<OHOS::SoftBusServerStub> softBusServer = new OHOS::SoftBusServer(SOFTBUS_SERVER_SA_ID, true);
1730 ASSERT_NE(nullptr, softBusServer);
1731 GearMode gearMode;
1732 char test[10] = "test";
1733 bool flag = true;
1734 MessageParcel datas;
1735 MessageParcel reply;
1736 EXPECT_CALL(softbusServerStubMock, CheckLnnPermission).WillRepeatedly(Return(SOFTBUS_PERMISSION_DENIED));
1737 int32_t ret = softBusServer->ShiftLNNGearInner(datas, reply);
1738 EXPECT_NE(SOFTBUS_NO_INIT, ret);
1739 EXPECT_CALL(softbusServerStubMock, CheckLnnPermission).WillRepeatedly(Return(SOFTBUS_OK));
1740 ret = softBusServer->ShiftLNNGearInner(datas, reply);
1741 EXPECT_NE(SOFTBUS_NO_INIT, ret);
1742
1743 datas.WriteCString(test);
1744 ret = softBusServer->ShiftLNNGearInner(datas, reply);
1745 EXPECT_NE(SOFTBUS_NO_INIT, ret);
1746
1747 datas.WriteCString(test);
1748 datas.WriteCString(test);
1749 ret = softBusServer->ShiftLNNGearInner(datas, reply);
1750 EXPECT_NE(SOFTBUS_NO_INIT, ret);
1751
1752 datas.WriteCString(test);
1753 datas.WriteCString(test);
1754 datas.WriteBool(flag);
1755 ret = softBusServer->ShiftLNNGearInner(datas, reply);
1756 EXPECT_NE(SOFTBUS_NO_INIT, ret);
1757
1758 datas.WriteCString(test);
1759 datas.WriteCString(test);
1760 datas.WriteBool(flag);
1761 datas.WriteRawData(&gearMode, sizeof(GearMode));
1762 ret = softBusServer->ShiftLNNGearInner(datas, reply);
1763 EXPECT_NE(SOFTBUS_NO_INIT, ret);
1764 }
1765
1766 /**
1767 * @tc.name: SoftbusServerStubTest043
1768 * @tc.desc: Verify the GetSoftbusSpecObjectInner function.
1769 * @tc.type: FUNC
1770 * @tc.require:
1771 */
1772 HWTEST_F(SoftbusServerStubTest, SoftbusServerStubTest043, TestSize.Level1)
1773 {
1774 sptr<OHOS::SoftBusServerStub> softBusServer = new OHOS::SoftBusServer(SOFTBUS_SERVER_SA_ID, true);
1775 ASSERT_NE(nullptr, softBusServer);
1776 MessageParcel datas;
1777 MessageParcel reply;
1778
1779 int32_t ret = softBusServer->GetSoftbusSpecObjectInner(datas, reply);
1780 EXPECT_EQ(SOFTBUS_OK, ret);
1781 }
1782
1783 /**
1784 * @tc.name: SoftbusServerStubTest044
1785 * @tc.desc: Verify the GetBusCenterExObjInner function.
1786 * @tc.type: FUNC
1787 * @tc.require:
1788 */
1789 HWTEST_F(SoftbusServerStubTest, SoftbusServerStubTest044, TestSize.Level1)
1790 {
1791 sptr<OHOS::SoftBusServerStub> softBusServer = new OHOS::SoftBusServer(SOFTBUS_SERVER_SA_ID, true);
1792 ASSERT_NE(nullptr, softBusServer);
1793 MessageParcel datas;
1794 MessageParcel reply;
1795
1796 int32_t ret = softBusServer->GetBusCenterExObjInner(datas, reply);
1797 EXPECT_EQ(SOFTBUS_OK, ret);
1798 }
1799
1800 /**
1801 * @tc.name: SoftbusServerStubTest045
1802 * @tc.desc: Verify the PrivilegeCloseChannelInner function.
1803 * @tc.type: FUNC
1804 * @tc.require:
1805 */
1806 HWTEST_F(SoftbusServerStubTest, SoftbusServerStubTest045, TestSize.Level1)
1807 {
1808 sptr<OHOS::SoftBusServerStub> softBusServer = new OHOS::SoftBusServer(SOFTBUS_SERVER_SA_ID, true);
1809 ASSERT_NE(nullptr, softBusServer);
1810 NiceMock<SoftbusServerStubTestInterfaceMock> softbusServerStubMock;
1811 char networkId[NETWORK_ID_BUF_LEN] = { 0 };
1812 uint64_t tokenId = 0;
1813 int32_t pid = 0;
1814 MessageParcel datas;
1815 MessageParcel reply;
1816
1817 EXPECT_CALL(softbusServerStubMock, SoftBusCheckDmsServerPermission)
1818 .WillRepeatedly(Return(SOFTBUS_PERMISSION_DENIED));
1819 int32_t ret = softBusServer->PrivilegeCloseChannelInner(datas, reply);
1820 EXPECT_EQ(SOFTBUS_PERMISSION_DENIED, ret);
1821
1822 datas.WriteUint64(tokenId);
1823 datas.WriteInt32(pid);
1824 datas.WriteCString(networkId);
1825 ret = softBusServer->PrivilegeCloseChannelInner(datas, reply);
1826 EXPECT_EQ(SOFTBUS_PERMISSION_DENIED, ret);
1827 }
1828
1829 /**
1830 * @tc.name: SoftbusServerStubTest046
1831 * @tc.desc: Verify the RegRangeCbForMsdpInner function.
1832 * @tc.type: FUNC
1833 * @tc.require:
1834 */
1835 HWTEST_F(SoftbusServerStubTest, SoftbusServerStubTest046, TestSize.Level1)
1836 {
1837 SetAccessTokenPermission("msdp_sa");
1838 NiceMock<SoftbusServerStubTestInterfaceMock> softbusServerStubMock;
1839 sptr<OHOS::SoftBusServerStub> softBusServer = new OHOS::SoftBusServer(SOFTBUS_SERVER_SA_ID, true);
1840 ASSERT_NE(nullptr, softBusServer);
1841 char test1[10] = "test";
1842 char test2[30] = "ohos.msdp.spatialawareness";
1843 MessageParcel datas;
1844 MessageParcel reply;
1845 EXPECT_CALL(softbusServerStubMock, CheckLnnPermission).WillRepeatedly(Return(SOFTBUS_PERMISSION_DENIED));
1846 int32_t ret = softBusServer->RegRangeCbForMsdpInner(datas, reply);
1847 EXPECT_EQ(SOFTBUS_PERMISSION_DENIED, ret);
1848 EXPECT_CALL(softbusServerStubMock, CheckLnnPermission).WillRepeatedly(Return(SOFTBUS_OK));
1849 ret = softBusServer->RegRangeCbForMsdpInner(datas, reply);
1850 EXPECT_EQ(SOFTBUS_IPC_ERR, ret);
1851
1852 datas.WriteCString(test1);
1853 ret = softBusServer->RegRangeCbForMsdpInner(datas, reply);
1854 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
1855
1856 datas.WriteCString(test2);
1857 ret = softBusServer->RegRangeCbForMsdpInner(datas, reply);
1858 EXPECT_EQ(SOFTBUS_OK, ret);
1859 }
1860
1861 /**
1862 * @tc.name: SoftbusServerStubTest047
1863 * @tc.desc: Verify the UnregRangeCbForMsdpInner function.
1864 * @tc.type: FUNC
1865 * @tc.require:
1866 */
1867 HWTEST_F(SoftbusServerStubTest, SoftbusServerStubTest047, TestSize.Level1)
1868 {
1869 SetAccessTokenPermission("msdp_sa");
1870 NiceMock<SoftbusServerStubTestInterfaceMock> softbusServerStubMock;
1871 sptr<OHOS::SoftBusServerStub> softBusServer = new OHOS::SoftBusServer(SOFTBUS_SERVER_SA_ID, true);
1872 ASSERT_NE(nullptr, softBusServer);
1873 char test1[10] = "test";
1874 char test2[30] = "ohos.msdp.spatialawareness";
1875 MessageParcel datas;
1876 MessageParcel reply;
1877 EXPECT_CALL(softbusServerStubMock, CheckLnnPermission).WillRepeatedly(Return(SOFTBUS_PERMISSION_DENIED));
1878 int32_t ret = softBusServer->UnregRangeCbForMsdpInner(datas, reply);
1879 EXPECT_EQ(SOFTBUS_PERMISSION_DENIED, ret);
1880 EXPECT_CALL(softbusServerStubMock, CheckLnnPermission).WillRepeatedly(Return(SOFTBUS_OK));
1881 ret = softBusServer->UnregRangeCbForMsdpInner(datas, reply);
1882 EXPECT_EQ(SOFTBUS_IPC_ERR, ret);
1883
1884 datas.WriteCString(test1);
1885 ret = softBusServer->UnregRangeCbForMsdpInner(datas, reply);
1886 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
1887
1888 datas.WriteCString(test2);
1889 ret = softBusServer->UnregRangeCbForMsdpInner(datas, reply);
1890 EXPECT_EQ(SOFTBUS_OK, ret);
1891 }
1892
1893 /**
1894 * @tc.name: SoftbusServerStubTest048
1895 * @tc.desc: Verify the TriggerRangeForMsdpInner function.
1896 * @tc.type: FUNC
1897 * @tc.require:
1898 */
1899 HWTEST_F(SoftbusServerStubTest, SoftbusServerStubTest048, TestSize.Level1)
1900 {
1901 SetAccessTokenPermission("msdp_sa");
1902 NiceMock<SoftbusServerStubTestInterfaceMock> softbusServerStubMock;
1903 sptr<OHOS::SoftBusServerStub> softBusServer = new OHOS::SoftBusServer(SOFTBUS_SERVER_SA_ID, true);
1904 ASSERT_NE(nullptr, softBusServer);
1905 char test[10] = "test";
1906 RangeConfig config;
1907 MessageParcel datas;
1908 MessageParcel reply;
1909 EXPECT_CALL(softbusServerStubMock, CheckLnnPermission).WillRepeatedly(Return(SOFTBUS_PERMISSION_DENIED));
1910 int32_t ret = softBusServer->TriggerRangeForMsdpInner(datas, reply);
1911 EXPECT_EQ(SOFTBUS_PERMISSION_DENIED, ret);
1912 EXPECT_CALL(softbusServerStubMock, CheckLnnPermission).WillRepeatedly(Return(SOFTBUS_OK));
1913 ret = softBusServer->TriggerRangeForMsdpInner(datas, reply);
1914 EXPECT_EQ(SOFTBUS_TRANS_PROXY_WRITECSTRING_FAILED, ret);
1915
1916 datas.WriteCString(test);
1917 datas.WriteRawData(&config, sizeof(RangeConfig));
1918 ret = softBusServer->TriggerRangeForMsdpInner(datas, reply);
1919 EXPECT_EQ(SOFTBUS_OK, ret);
1920 }
1921
1922 /**
1923 * @tc.name: SoftbusServerStubTest049
1924 * @tc.desc: Verify the CheckPkgName function.
1925 * @tc.type: FUNC
1926 * @tc.require:
1927 */
1928 HWTEST_F(SoftbusServerStubTest, SoftbusServerStubTest049, TestSize.Level1)
1929 {
1930 int32_t ret = CheckPkgName("mds");
1931 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
1932
1933 ret = CheckPkgName("ohos.distributedschedule.dms");
1934 EXPECT_EQ(SOFTBUS_OK, ret);
1935 }
1936
1937 /**
1938 * @tc.name: SoftbusServerStubTest050
1939 * @tc.desc: Verify the CreateServerInner function.
1940 * @tc.type: FUNC
1941 * @tc.require:
1942 */
1943 HWTEST_F(SoftbusServerStubTest, SoftbusServerStubTest050, TestSize.Level1)
1944 {
1945 sptr<OHOS::SoftBusServerStub> softBusServer = new OHOS::SoftBusServer(SOFTBUS_SERVER_SA_ID, true);
1946 ASSERT_NE(nullptr, softBusServer);
1947
1948 MessageParcel data;
1949 MessageParcel reply;
1950
1951 int32_t ret = softBusServer->CreateServerInner(data, reply);
1952 EXPECT_EQ(SOFTBUS_IPC_ERR, ret);
1953
1954 const char *pkgName = "1234567890123456789012345678901234567890123456789012345678901234567890123456789";
1955 data.WriteCString(pkgName);
1956 ret = softBusServer->CreateServerInner(data, reply);
1957 EXPECT_EQ(SOFTBUS_IPC_ERR, ret);
1958
1959 pkgName = "ohos.distributedschedule.dms";
1960 data.WriteCString(pkgName);
1961 ret = softBusServer->CreateServerInner(data, reply);
1962 EXPECT_EQ(SOFTBUS_IPC_ERR, ret);
1963
1964 pkgName = "ohos.distributedschedule.dms";
1965 data.WriteCString(pkgName);
1966 const char *name =
1967 "12345678901234567890123456789012345678901234567890123456789012345678901234567891234567890123456789012"
1968 "34567890123456789012345678901234567890123456789012345678912345678901234567890123456789012345678901234"
1969 "56789012345678901234567890123456789123456789012345678901234567890123456789012345678901234567890123456"
1970 "78901234567891234567890123456789012345678901234567890123456789012345678901234567890123456789";
1971 data.WriteCString(name);
1972 ret = softBusServer->CreateServerInner(data, reply);
1973 EXPECT_EQ(SOFTBUS_IPC_ERR, ret);
1974
1975 name = "test";
1976 data.WriteCString(pkgName);
1977 data.WriteCString(name);
1978 ret = softBusServer->CreateServerInner(data, reply);
1979 EXPECT_EQ(SOFTBUS_OK, ret);
1980 }
1981
1982 /**
1983 * @tc.name: SoftbusServerStubTest051
1984 * @tc.desc: Verify the RemoveServerInner function.
1985 * @tc.type: FUNC
1986 * @tc.require:
1987 */
1988 HWTEST_F(SoftbusServerStubTest, SoftbusServerStubTest051, TestSize.Level1)
1989 {
1990 sptr<OHOS::SoftBusServerStub> softBusServer = new OHOS::SoftBusServer(SOFTBUS_SERVER_SA_ID, true);
1991 ASSERT_NE(nullptr, softBusServer);
1992
1993 MessageParcel data;
1994 MessageParcel reply;
1995
1996 int32_t ret = softBusServer->RemoveServerInner(data, reply);
1997 EXPECT_EQ(SOFTBUS_IPC_ERR, ret);
1998
1999 const char *pkgName = "1234567890123456789012345678901234567890123456789012345678901234567890123456789";
2000 data.WriteCString(pkgName);
2001 ret = softBusServer->RemoveServerInner(data, reply);
2002 EXPECT_EQ(SOFTBUS_IPC_ERR, ret);
2003
2004 pkgName = "ohos.distributedschedule.dms";
2005 data.WriteCString(pkgName);
2006 ret = softBusServer->RemoveServerInner(data, reply);
2007 EXPECT_EQ(SOFTBUS_IPC_ERR, ret);
2008
2009 pkgName = "ohos.distributedschedule.dms";
2010 data.WriteCString(pkgName);
2011 const char *name =
2012 "12345678901234567890123456789012345678901234567890123456789012345678901234567891234567890123456789012"
2013 "34567890123456789012345678901234567890123456789012345678912345678901234567890123456789012345678901234"
2014 "56789012345678901234567890123456789123456789012345678901234567890123456789012345678901234567890123456"
2015 "78901234567891234567890123456789012345678901234567890123456789012345678901234567890123456789";
2016 data.WriteCString(name);
2017 ret = softBusServer->RemoveServerInner(data, reply);
2018 EXPECT_EQ(SOFTBUS_IPC_ERR, ret);
2019
2020 name = "test";
2021 data.WriteCString(pkgName);
2022 data.WriteCString(name);
2023 ret = softBusServer->RemoveServerInner(data, reply);
2024 EXPECT_EQ(SOFTBUS_OK, ret);
2025 }
2026
2027 /**
2028 * @tc.name: SoftbusServerStubTest052
2029 * @tc.desc: Verify the ConnectInner function.
2030 * @tc.type: FUNC
2031 * @tc.require:
2032 */
2033 HWTEST_F(SoftbusServerStubTest, SoftbusServerStubTest052, TestSize.Level1)
2034 {
2035 sptr<OHOS::SoftBusServerStub> softBusServer = new OHOS::SoftBusServer(SOFTBUS_SERVER_SA_ID, true);
2036 ASSERT_NE(nullptr, softBusServer);
2037
2038 MessageParcel data;
2039 MessageParcel reply;
2040
2041 int32_t ret = softBusServer->ConnectInner(data, reply);
2042 EXPECT_EQ(SOFTBUS_IPC_ERR, ret);
2043
2044 const char *pkgName = "1234567890123456789012345678901234567890123456789012345678901234567890123456789";
2045 data.WriteCString(pkgName);
2046 ret = softBusServer->ConnectInner(data, reply);
2047 EXPECT_EQ(SOFTBUS_IPC_ERR, ret);
2048
2049 pkgName = "ohos.distributedschedule.dms";
2050 data.WriteCString(pkgName);
2051 ret = softBusServer->ConnectInner(data, reply);
2052 EXPECT_EQ(SOFTBUS_IPC_ERR, ret);
2053
2054 pkgName = "ohos.distributedschedule.dms";
2055 data.WriteCString(pkgName);
2056 const char *name =
2057 "12345678901234567890123456789012345678901234567890123456789012345678901234567891234567890123456789012"
2058 "34567890123456789012345678901234567890123456789012345678912345678901234567890123456789012345678901234"
2059 "56789012345678901234567890123456789123456789012345678901234567890123456789012345678901234567890123456"
2060 "78901234567891234567890123456789012345678901234567890123456789012345678901234567890123456789";
2061 data.WriteCString(name);
2062 ret = softBusServer->ConnectInner(data, reply);
2063 EXPECT_EQ(SOFTBUS_IPC_ERR, ret);
2064
2065 name = "test";
2066 data.WriteCString(pkgName);
2067 data.WriteCString(name);
2068 ret = softBusServer->ConnectInner(data, reply);
2069 EXPECT_EQ(SOFTBUS_IPC_ERR, ret);
2070 }
2071
2072 /**
2073 * @tc.name: SoftbusServerStubTest053
2074 * @tc.desc: Verify the DisconnectInner function.
2075 * @tc.type: FUNC
2076 * @tc.require:
2077 */
2078 HWTEST_F(SoftbusServerStubTest, SoftbusServerStubTest053, TestSize.Level1)
2079 {
2080 sptr<OHOS::SoftBusServerStub> softBusServer = new OHOS::SoftBusServer(SOFTBUS_SERVER_SA_ID, true);
2081 ASSERT_NE(nullptr, softBusServer);
2082
2083 MessageParcel data;
2084 MessageParcel reply;
2085
2086 int32_t ret = softBusServer->DisconnectInner(data, reply);
2087 EXPECT_EQ(SOFTBUS_IPC_ERR, ret);
2088 }
2089
2090 /**
2091 * @tc.name: SoftbusServerStubTest054
2092 * @tc.desc: Verify the SendInner function.
2093 * @tc.type: FUNC
2094 * @tc.require:
2095 */
2096 HWTEST_F(SoftbusServerStubTest, SoftbusServerStubTest054, TestSize.Level1)
2097 {
2098 sptr<OHOS::SoftBusServerStub> softBusServer = new OHOS::SoftBusServer(SOFTBUS_SERVER_SA_ID, true);
2099 ASSERT_NE(nullptr, softBusServer);
2100
2101 MessageParcel data;
2102 MessageParcel reply;
2103
2104 int32_t ret = softBusServer->SendInner(data, reply);
2105 EXPECT_EQ(SOFTBUS_IPC_ERR, ret);
2106
2107 int32_t handle = 0;
2108 data.WriteInt32(handle);
2109 ret = softBusServer->SendInner(data, reply);
2110 EXPECT_EQ(SOFTBUS_IPC_ERR, ret);
2111
2112 uint32_t len = TEST_MAX_LEN;
2113 data.WriteInt32(handle);
2114 data.WriteUint32(len);
2115 ret = softBusServer->SendInner(data, reply);
2116 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
2117 }
2118
2119 /**
2120 * @tc.name: SoftbusServerStubTest055
2121 * @tc.desc: Verify the GetPeerDeviceIdInner function.
2122 * @tc.type: FUNC
2123 * @tc.require:
2124 */
2125 HWTEST_F(SoftbusServerStubTest, SoftbusServerStubTest055, TestSize.Level1)
2126 {
2127 sptr<OHOS::SoftBusServerStub> softBusServer = new OHOS::SoftBusServer(SOFTBUS_SERVER_SA_ID, true);
2128 ASSERT_NE(nullptr, softBusServer);
2129
2130 MessageParcel data;
2131 MessageParcel reply;
2132
2133 int32_t ret = softBusServer->GetPeerDeviceIdInner(data, reply);
2134 EXPECT_EQ(SOFTBUS_IPC_ERR, ret);
2135
2136 int32_t handle = 0;
2137 data.WriteInt32(handle);
2138 ret = softBusServer->GetPeerDeviceIdInner(data, reply);
2139 EXPECT_EQ(SOFTBUS_IPC_ERR, ret);
2140
2141 uint32_t len = TEST_DEVICE_ID_SIZE_MAX;
2142 data.WriteInt32(handle);
2143 data.WriteUint32(len);
2144 ret = softBusServer->GetPeerDeviceIdInner(data, reply);
2145 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
2146 }
2147
2148 /**
2149 * @tc.name: SoftbusServerStubTest056
2150 * @tc.desc: Verify the Create and Remove SessionServerInner function.
2151 * @tc.type: FUNC
2152 * @tc.require:
2153 */
2154 HWTEST_F(SoftbusServerStubTest, SoftbusServerStubTest056, TestSize.Level1)
2155 {
2156 sptr<OHOS::SoftBusServerStub> softBusServer = new OHOS::SoftBusServer(SOFTBUS_SERVER_SA_ID, true);
2157 ASSERT_NE(nullptr, softBusServer);
2158 NiceMock<SoftbusServerStubTestInterfaceMock> softbusServerStubMock;
2159 char test[10] = "test";
2160 MessageParcel datas;
2161 MessageParcel reply;
2162 datas.WriteCString(test);
2163 datas.WriteCString(test);
2164 int32_t ret = softBusServer->CreateSessionServerInner(datas, reply);
2165 EXPECT_EQ(SOFTBUS_OK, ret);
2166
2167 datas.WriteCString(test);
2168 datas.WriteCString(test);
2169 EXPECT_CALL(softbusServerStubMock, SoftBusCheckIsSystemApp).WillRepeatedly(Return(true));
2170 ret = softBusServer->CreateSessionServerInner(datas, reply);
2171 EXPECT_EQ(SOFTBUS_OK, ret);
2172
2173 datas.WriteCString(test);
2174 ret = softBusServer->RemoveSessionServerInner(datas, reply);
2175 EXPECT_EQ(SOFTBUS_OK, ret);
2176 }
2177
2178 /**
2179 * @tc.name: SoftbusServerStubTest057
2180 * @tc.desc: GetBundleName error test
2181 * @tc.type: FUNC
2182 * @tc.require:
2183 */
2184 HWTEST_F(SoftbusServerStubTest, SoftbusServerStubTest057, TestSize.Level1)
2185 {
2186 std::string bundleName = "test";
2187 int32_t ret = GetBundleName(0, bundleName);
2188 EXPECT_EQ(ret, SOFTBUS_TRANS_GET_BUNDLENAME_FAILED);
2189
2190 ret = GetAppId(bundleName, bundleName);
2191 EXPECT_NE(ret, SOFTBUS_OK);
2192 }
2193
2194 /**
2195 * @tc.name: SoftbusServerStubTest058
2196 * @tc.desc: CheckNormalAppSessionName error test
2197 * @tc.type: FUNC
2198 * @tc.require:
2199 */
2200 HWTEST_F(SoftbusServerStubTest, SoftbusServerStubTest058, TestSize.Level1)
2201 {
2202 NiceMock<SoftbusServerStubTestInterfaceMock> softbusServerStubMock;
2203 EXPECT_CALL(softbusServerStubMock, SoftBusCheckIsNormalApp)
2204 .WillRepeatedly(Return(true));
2205
2206 std::string bundleName = "test";
2207 MessageParcel data;
2208 ReadSessionAttrs(data, nullptr);
2209 int32_t ret = CheckNormalAppSessionName(nullptr, 0, bundleName, 0);
2210 EXPECT_EQ(ret, SOFTBUS_TRANS_GET_BUNDLENAME_FAILED);
2211 }
2212
2213 /**
2214 * @tc.name: SoftbusServerStubTest059
2215 * @tc.desc: StopRangeForMsdpInner api test
2216 * @tc.type: FUNC
2217 * @tc.require:
2218 */
2219 HWTEST_F(SoftbusServerStubTest, SoftbusServerStubTest059, TestSize.Level1)
2220 {
2221 SetAccessTokenPermission("distributeddata");
2222 NiceMock<SoftbusServerStubTestInterfaceMock> softbusServerStubMock;
2223 sptr<OHOS::SoftBusServerStub> softBusServer = new OHOS::SoftBusServer(SOFTBUS_SERVER_SA_ID, true);
2224 ASSERT_NE(softBusServer, nullptr);
2225
2226 MessageParcel data;
2227 MessageParcel reply;
2228 char test[10] = "test";
2229 ConnectionAddr addrInfo;
2230 (void)memset_s(&addrInfo, sizeof(ConnectionAddr), 0, sizeof(ConnectionAddr));
2231 EXPECT_CALL(softbusServerStubMock, CheckLnnPermission).WillRepeatedly(Return(SOFTBUS_PERMISSION_DENIED));
2232 int32_t ret = softBusServer->StopRangeForMsdpInner(data, reply);
2233 EXPECT_EQ(SOFTBUS_PERMISSION_DENIED, ret);
2234 EXPECT_CALL(softbusServerStubMock, CheckLnnPermission).WillRepeatedly(Return(SOFTBUS_OK));
2235 ret = softBusServer->StopRangeForMsdpInner(data, reply);
2236 EXPECT_EQ(ret, SOFTBUS_TRANS_PROXY_WRITECSTRING_FAILED);
2237
2238 data.WriteCString(test);
2239 ret = softBusServer->StopRangeForMsdpInner(data, reply);
2240 EXPECT_EQ(ret, SOFTBUS_TRANS_PROXY_READCSTRING_FAILED);
2241
2242 data.WriteCString(test);
2243 data.WriteRawData(&addrInfo, sizeof(ConnectionAddr));
2244 ret = softBusServer->StopRangeForMsdpInner(data, reply);
2245 EXPECT_EQ(ret, SOFTBUS_TRANS_PROXY_READCSTRING_FAILED);
2246 }
2247
2248 /**
2249 * @tc.name: SoftbusServerStubTest060
2250 * @tc.desc: CheckOpenSessionPermission error test
2251 * @tc.type: FUNC
2252 * @tc.require:
2253 */
2254 HWTEST_F(SoftbusServerStubTest, SoftbusServerStubTest060, TestSize.Level1)
2255 {
2256 sptr<OHOS::SoftBusServerStub> softBusServer = new OHOS::SoftBusServer(SOFTBUS_SERVER_SA_ID, true);
2257 ASSERT_NE(softBusServer, nullptr);
2258
2259 NiceMock<SoftbusServerStubTestInterfaceMock> softbusServerStubMock;
2260 EXPECT_CALL(softbusServerStubMock, UnregChangeListener).WillRepeatedly(Return(SOFTBUS_OK));
2261 EXPECT_CALL(softbusServerStubMock, CheckTransPermission)
2262 .WillOnce(Return(SOFTBUS_INVALID_PARAM))
2263 .WillRepeatedly(Return(SOFTBUS_OK));
2264 EXPECT_CALL(softbusServerStubMock, CheckUidAndPid).WillRepeatedly(Return(false));
2265
2266 int32_t ret = TransSessionMgrInit();
2267 EXPECT_EQ(SOFTBUS_OK, ret);
2268 SessionServer *sessionServer = GenerateSessionServer();
2269 EXPECT_NE(nullptr, sessionServer);
2270 ret = TransSessionServerAddItem(sessionServer);
2271 EXPECT_EQ(SOFTBUS_OK, ret);
2272 SessionParam *sessionParam001 = GenerateSessionParam();
2273 ASSERT_NE(sessionParam001, nullptr);
2274
2275 ret = softBusServer->CheckOpenSessionPermission(sessionParam001);
2276 EXPECT_EQ(ret, SOFTBUS_PERMISSION_DENIED);
2277
2278
2279 SoftbusReportPermissionFaultEvt(SERVER_OPEN_SESSION);
2280 ret = softBusServer->CheckOpenSessionPermission(sessionParam001);
2281 EXPECT_EQ(ret, SOFTBUS_TRANS_CHECK_PID_ERROR);
2282 }
2283
2284 /**
2285 * @tc.name: SoftbusServerStubTest061
2286 * @tc.desc: Verify the SyncTrustedRelationShipInner and SetDisplayNameInner function.
2287 * @tc.type: FUNC
2288 * @tc.require:
2289 */
2290 HWTEST_F(SoftbusServerStubTest, SoftbusServerStubTest061, TestSize.Level1)
2291 {
2292 SetAccessTokenPermission("device_manager");
2293 sptr<OHOS::SoftBusServerStub> softBusServer = new OHOS::SoftBusServer(SOFTBUS_SERVER_SA_ID, true);
2294 ASSERT_NE(nullptr, softBusServer);
2295 NiceMock<SoftbusServerStubTestInterfaceMock> softbusServerStubMock;
2296 MessageParcel datas;
2297 MessageParcel reply;
2298 EXPECT_CALL(softbusServerStubMock, UnregChangeListener).WillRepeatedly(Return(SOFTBUS_OK));
2299 EXPECT_CALL(softbusServerStubMock, CheckLnnPermission).WillRepeatedly(Return(SOFTBUS_PERMISSION_DENIED));
2300 int32_t ret = softBusServer->SyncTrustedRelationShipInner(datas, reply);
2301 EXPECT_EQ(SOFTBUS_PERMISSION_DENIED, ret);
2302 EXPECT_CALL(softbusServerStubMock, CheckLnnPermission).WillRepeatedly(Return(SOFTBUS_OK));
2303 ret = softBusServer->SyncTrustedRelationShipInner(datas, reply);
2304 EXPECT_EQ(SOFTBUS_TRANS_PROXY_READCSTRING_FAILED, ret);
2305 ret = softBusServer->SetDisplayNameInner(datas, reply);
2306 EXPECT_EQ(SOFTBUS_TRANS_PROXY_READCSTRING_FAILED, ret);
2307 EXPECT_CALL(softbusServerStubMock, CheckLnnPermission).WillRepeatedly(Return(SOFTBUS_PERMISSION_DENIED));
2308 ret = softBusServer->SetDisplayNameInner(datas, reply);
2309 EXPECT_EQ(SOFTBUS_PERMISSION_DENIED, ret);
2310 }
2311 }