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 "auth_interface.h"
20 #include "disc_log.h"
21 #include "ipc_skeleton.h"
22 #include "iservice_registry.h"
23 #include "message_option.h"
24 #include "message_parcel.h"
25 #include "softbus_access_token_test.h"
26 #include "softbus_adapter_mem.h"
27 #include "softbus_common.h"
28 #include "softbus_error_code.h"
29 #include "softbus_feature_config.h"
30 #include "softbus_server.h"
31 #include "softbus_server_frame.h"
32 #include "softbus_server_ipc_interface_code.h"
33 #include "softbus_server_stub.cpp"
34 #include "softbus_server_stub.h"
35 #include "softbus_server_stub_test_mock.h"
36 #include "system_ability_definition.h"
37 #include "trans_session_manager.h"
38 #include "trans_session_service.h"
39 #include "trans_type.h"
40 #include <gtest/gtest.h>
41
42 using namespace testing;
43 using namespace testing::ext;
44
45 namespace OHOS {
46
47 #define TEST_SESSION_NAME_SIZE_MAX 256
48 #define TEST_DEVICE_ID_SIZE_MAX 50
49 #define TEST_GROUP_ID_SIZE_MAX 50
50 #define TEST_PKG_NAME_SIZE_MAX 65
51
52 char g_mySessionName[TEST_SESSION_NAME_SIZE_MAX] = "com.test.trans.session";
53 char g_peerSessionName[TEST_SESSION_NAME_SIZE_MAX] = "com.test.trans.session.sendfile";
54 char g_peerDeviceId[TEST_DEVICE_ID_SIZE_MAX] = "com.test.trans.session.sendfile";
55 char g_groupId[TEST_GROUP_ID_SIZE_MAX] = "com.test.trans.session.sendfile";
56 char g_myPkgName[TEST_PKG_NAME_SIZE_MAX] = "test";
57
58 class SoftbusServerStubTest : public testing::Test {
59 public:
SoftbusServerStubTest()60 SoftbusServerStubTest()
61 {}
~SoftbusServerStubTest()62 ~SoftbusServerStubTest()
63 {}
64 static void SetUpTestCase(void);
65 static void TearDownTestCase(void);
SetUp()66 void SetUp() override
67 {}
TearDown()68 void TearDown() override
69 {}
70 };
71
SetUpTestCase(void)72 void SoftbusServerStubTest::SetUpTestCase(void)
73 {
74 SoftbusConfigInit();
75 ConnServerInit();
76 AuthInit();
77 BusCenterServerInit();
78 TransServerInit();
79 }
80
TearDownTestCase(void)81 void SoftbusServerStubTest::TearDownTestCase(void)
82 {
83 ConnServerDeinit();
84 AuthDeinit();
85 BusCenterServerDeinit();
86 TransServerDeinit();
87 }
88
GenerateSessionParam()89 SessionParam *GenerateSessionParam()
90 {
91 SetAceessTokenPermission("SoftBusServerStubTest");
92 SessionParam *sessionParam = (SessionParam *)SoftBusCalloc(sizeof(SessionParam));
93 EXPECT_NE(nullptr, sessionParam);
94 SessionAttribute attr;
95 attr.dataType = 1;
96 attr.linkTypeNum = 0;
97 sessionParam->sessionName = g_mySessionName;
98 sessionParam->peerSessionName = g_peerSessionName;
99 sessionParam->peerDeviceId = g_peerDeviceId;
100 sessionParam->groupId = g_groupId;
101 sessionParam->attr = &attr;
102 return sessionParam;
103 }
104
DeGenerateSessionParam(SessionParam * sessionParam)105 void DeGenerateSessionParam(SessionParam *sessionParam)
106 {
107 if (sessionParam != nullptr) {
108 SoftBusFree(sessionParam);
109 }
110 }
111
GenerateSessionServer()112 static SessionServer *GenerateSessionServer()
113 {
114 SessionServer *sessionServer = (SessionServer*)SoftBusCalloc(sizeof(SessionServer));
115 EXPECT_NE(nullptr, sessionServer);
116 int32_t ret = strcpy_s(sessionServer->sessionName, sizeof(sessionServer->sessionName), g_mySessionName);
117 if (ret != EOK) {
118 SoftBusFree(sessionServer);
119 return nullptr;
120 }
121 ret = strcpy_s(sessionServer->pkgName, sizeof(sessionServer->pkgName), g_myPkgName);
122 if (ret != EOK) {
123 SoftBusFree(sessionServer);
124 return nullptr;
125 }
126 return sessionServer;
127 }
128
DeGenerateSessionServer(SessionServer * sessionServer)129 void DeGenerateSessionServer(SessionServer *sessionServer)
130 {
131 if (sessionServer != nullptr) {
132 SoftBusFree(sessionServer);
133 }
134 }
135
GenerateRemoteObject(void)136 static sptr<IRemoteObject> GenerateRemoteObject(void)
137 {
138 auto samgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
139 if (samgr != nullptr) {
140 return samgr->GetSystemAbility(SOFTBUS_SERVER_SA_ID);
141 }
142 return nullptr;
143 }
144
145 /**
146 * @tc.name: SoftbusServerStubTest001
147 * @tc.desc: Verify the CheckOpenSessionPermission function.
148 * @tc.type: FUNC
149 * @tc.require:
150 */
151 HWTEST_F(SoftbusServerStubTest, SoftbusServerStubTest001, TestSize.Level1)
152 {
153 int32_t ret = TransSessionMgrInit();
154 EXPECT_EQ(SOFTBUS_OK, ret);
155 SessionServer *sessionServer = GenerateSessionServer();
156 EXPECT_NE(nullptr, sessionServer);
157 ret = TransSessionServerAddItem(sessionServer);
158 EXPECT_EQ(SOFTBUS_OK, ret);
159
160 SessionParam *sessionParam001 = GenerateSessionParam();
161 ASSERT_NE(nullptr, sessionParam001);
162 sptr<OHOS::SoftBusServerStub> softBusServer = new OHOS::SoftBusServer(SOFTBUS_SERVER_SA_ID, true);
163 ASSERT_NE(nullptr, softBusServer);
164 NiceMock<SoftbusServerStubTestInterfaceMock> softbusServerStubMock;
165 EXPECT_CALL(softbusServerStubMock, CheckTransPermission).WillRepeatedly(Return(SOFTBUS_OK));
166 EXPECT_CALL(softbusServerStubMock, CheckTransSecLevel).WillRepeatedly(Return(SOFTBUS_OK));
167 EXPECT_CALL(softbusServerStubMock, CheckUidAndPid).WillRepeatedly(Return(true));
168 ret = softBusServer->CheckOpenSessionPermission(sessionParam001);
169 EXPECT_EQ(SOFTBUS_OK, ret);
170 DeGenerateSessionParam(sessionParam001);
171
172 SessionParam *sessionParam002 = nullptr;
173 ret = softBusServer->CheckOpenSessionPermission(sessionParam002);
174 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
175 DeGenerateSessionParam(sessionParam002);
176
177 SessionParam *sessionParam003 = GenerateSessionParam();
178 ASSERT_NE(nullptr, sessionParam003);
179 sessionParam003->peerSessionName = nullptr;
180 EXPECT_CALL(softbusServerStubMock, CheckTransSecLevel).WillRepeatedly(Return(SOFTBUS_PERMISSION_DENIED));
181 ret = softBusServer->CheckOpenSessionPermission(sessionParam003);
182 EXPECT_EQ(SOFTBUS_PERMISSION_DENIED, ret);
183 DeGenerateSessionParam(sessionParam003);
184
185 DeGenerateSessionServer(sessionServer);
186 TransSessionMgrDeinit();
187 }
188
189 /**
190 * @tc.name: SoftbusServerStubTest002
191 * @tc.desc: Verify the CheckChannelPermission function.
192 * @tc.type: FUNC
193 * @tc.require:
194 */
195 HWTEST_F(SoftbusServerStubTest, SoftbusServerStubTest002, TestSize.Level1)
196 {
197 sptr<OHOS::SoftBusServerStub> softBusServer = new OHOS::SoftBusServer(SOFTBUS_SERVER_SA_ID, true);
198 ASSERT_NE(nullptr, softBusServer);
199 NiceMock<SoftbusServerStubTestInterfaceMock> softbusServerStubMock;
200 int32_t channelId = 0;
201 int32_t channelType = 0;
202
203 EXPECT_CALL(softbusServerStubMock, TransGetNameByChanId).WillRepeatedly(Return(SOFTBUS_INVALID_PARAM));
204 int32_t ret = softBusServer->CheckChannelPermission(channelId, channelType);
205 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
206
207 EXPECT_CALL(softbusServerStubMock, TransGetNameByChanId).WillRepeatedly(Return(SOFTBUS_OK));
208 EXPECT_CALL(softbusServerStubMock, CheckTransPermission).WillRepeatedly(Return(SOFTBUS_OK));
209 ret = softBusServer->CheckChannelPermission(channelId, channelType);
210 EXPECT_EQ(SOFTBUS_OK, ret);
211
212 EXPECT_CALL(softbusServerStubMock, CheckTransPermission).WillRepeatedly(Return(SOFTBUS_PERMISSION_DENIED));
213 ret = softBusServer->CheckChannelPermission(channelId, channelType);
214 EXPECT_EQ(SOFTBUS_PERMISSION_DENIED, ret);
215 }
216
217 /**
218 * @tc.name: SoftbusServerStubTest007
219 * @tc.desc: Verify the SoftbusRegisterServiceInner function.
220 * @tc.type: FUNC
221 * @tc.require:
222 */
223 HWTEST_F(SoftbusServerStubTest, SoftbusServerStubTest007, TestSize.Level1)
224 {
225 sptr<OHOS::SoftBusServerStub> softBusServer = new OHOS::SoftBusServer(SOFTBUS_SERVER_SA_ID, true);
226 ASSERT_NE(nullptr, softBusServer);
227 char test[10] = "test";
228 MessageParcel datas;
229 MessageParcel reply;
230 sptr<IRemoteObject> obj = GenerateRemoteObject();
231 EXPECT_NE(nullptr, obj);
232
233 int32_t ret = softBusServer->SoftbusRegisterServiceInner(datas, reply);
234 EXPECT_EQ(SOFTBUS_TRANS_PROXY_REMOTE_NULL, ret);
235
236 datas.WriteRemoteObject(obj);
237 ret = softBusServer->SoftbusRegisterServiceInner(datas, reply);
238 EXPECT_EQ(SOFTBUS_TRANS_PROXY_READCSTRING_FAILED, ret);
239
240 datas.WriteRemoteObject(obj);
241 datas.WriteCString(test);
242 ret = softBusServer->SoftbusRegisterServiceInner(datas, reply);
243 EXPECT_EQ(SOFTBUS_OK, ret);
244 }
245
246 /**
247 * @tc.name: SoftbusServerStubTest008
248 * @tc.desc: Verify the OnRemoteRequest function.
249 * @tc.type: FUNC
250 * @tc.require:
251 */
252 HWTEST_F(SoftbusServerStubTest, SoftbusServerStubTest008, TestSize.Level1)
253 {
254 sptr<OHOS::SoftBusServerStub> softBusServer = new OHOS::SoftBusServer(SOFTBUS_SERVER_SA_ID, true);
255 ASSERT_NE(nullptr, softBusServer);
256 uint32_t code = SERVER_OPEN_SESSION;
257 MessageParcel datas;
258 MessageParcel reply;
259 MessageOption option;
260
261 int32_t ret = softBusServer->OnRemoteRequest(code, datas, reply, option);
262 EXPECT_EQ(SOFTBUS_IPC_ERR, ret);
263
264 datas.WriteInterfaceToken(std::u16string(u"test"));
265 ret = softBusServer->OnRemoteRequest(code, datas, reply, option);
266 EXPECT_EQ(SOFTBUS_IPC_ERR, ret);
267
268 InitSoftBusServer();
269 datas.WriteInterfaceToken(std::u16string(u"test"));
270 ret = softBusServer->OnRemoteRequest(code, datas, reply, option);
271 EXPECT_EQ(SOFTBUS_IPC_ERR, ret);
272 }
273
274 /**
275 * @tc.name: SoftbusServerStubTest009
276 * @tc.desc: Verify the Create and Remove SessionServerInner function.
277 * @tc.type: FUNC
278 * @tc.require:
279 */
280 HWTEST_F(SoftbusServerStubTest, SoftbusServerStubTest009, TestSize.Level1)
281 {
282 sptr<OHOS::SoftBusServerStub> softBusServer = new OHOS::SoftBusServer(SOFTBUS_SERVER_SA_ID, true);
283 ASSERT_NE(nullptr, softBusServer);
284 NiceMock<SoftbusServerStubTestInterfaceMock> softbusServerStubMock;
285 char test[10] = "test";
286 MessageParcel datas;
287 MessageParcel reply;
288
289 int32_t ret = softBusServer->CreateSessionServerInner(datas, reply);
290 EXPECT_EQ(SOFTBUS_TRANS_PROXY_READCSTRING_FAILED, ret);
291
292 datas.WriteCString(test);
293 datas.WriteCString(test);
294 ret = softBusServer->CreateSessionServerInner(datas, reply);
295 EXPECT_EQ(SOFTBUS_OK, ret);
296
297 ret = softBusServer->RemoveSessionServerInner(datas, reply);
298 EXPECT_EQ(SOFTBUS_TRANS_PROXY_READCSTRING_FAILED, ret);
299
300 datas.WriteCString(test);
301 ret = softBusServer->RemoveSessionServerInner(datas, reply);
302 EXPECT_EQ(SOFTBUS_OK, ret);
303
304 EXPECT_CALL(softbusServerStubMock, CheckTransPermission).WillRepeatedly(Return(SOFTBUS_PERMISSION_DENIED));
305 datas.WriteCString(test);
306 datas.WriteCString(test);
307 ret = softBusServer->RemoveSessionServerInner(datas, reply);
308 EXPECT_EQ(SOFTBUS_OK, ret);
309
310 EXPECT_CALL(softbusServerStubMock, CheckTransPermission).WillRepeatedly(Return(SOFTBUS_OK));
311 datas.WriteCString(test);
312 datas.WriteCString(test);
313 ret = softBusServer->RemoveSessionServerInner(datas, reply);
314 EXPECT_EQ(SOFTBUS_TRANS_CHECK_PID_ERROR, ret);
315 }
316
317 /**
318 * @tc.name: SoftbusServerStubTest010
319 * @tc.desc: Verify the ReadQosInfo function.
320 * @tc.type: FUNC
321 * @tc.require:
322 */
323 HWTEST_F(SoftbusServerStubTest, SoftbusServerStubTest010, TestSize.Level1)
324 {
325 unsigned int qosCount = 0;
326 bool boolNum = false;
327 QosTV qosInfo[7];
328 MessageParcel datas;
329 SessionParam param;
330
331 bool ret = ReadQosInfo(datas, param);
332 EXPECT_EQ(false, ret);
333
334 datas.WriteBool(boolNum);
335 ret = ReadQosInfo(datas, param);
336 EXPECT_EQ(true, ret);
337
338 boolNum = true;
339 datas.WriteBool(boolNum);
340 ret = ReadQosInfo(datas, param);
341 EXPECT_EQ(false, ret);
342
343 datas.WriteBool(boolNum);
344 datas.WriteUint32(qosCount);
345 ret = ReadQosInfo(datas, param);
346 EXPECT_EQ(true, ret);
347
348 qosCount = 10;
349 datas.WriteBool(boolNum);
350 datas.WriteUint32(qosCount);
351 ret = ReadQosInfo(datas, param);
352 EXPECT_EQ(false, ret);
353
354 qosCount = 7;
355 datas.WriteBool(boolNum);
356 datas.WriteUint32(qosCount);
357 ret = ReadQosInfo(datas, param);
358 EXPECT_EQ(false, ret);
359
360 datas.WriteBool(boolNum);
361 datas.WriteUint32(qosCount);
362 datas.WriteBuffer(qosInfo, sizeof(QosTV) * 7);
363 ret = ReadQosInfo(datas, param);
364 EXPECT_EQ(true, ret);
365 }
366
367 /**
368 * @tc.name: SoftbusServerStubTest011
369 * @tc.desc: Verify the OpenSessionInner function.
370 * @tc.type: FUNC
371 * @tc.require:
372 */
373 HWTEST_F(SoftbusServerStubTest, SoftbusServerStubTest011, TestSize.Level1)
374 {
375 sptr<OHOS::SoftBusServerStub> softBusServer = new OHOS::SoftBusServer(SOFTBUS_SERVER_SA_ID, true);
376 ASSERT_NE(nullptr, softBusServer);
377 char test[10] = "test";
378 bool boolNum = false;
379 MessageParcel datas;
380 MessageParcel reply;
381
382 int32_t ret = softBusServer->OpenSessionInner(datas, reply);
383 EXPECT_EQ(SOFTBUS_IPC_ERR, ret);
384
385 datas.WriteCString(test);
386 datas.WriteCString(test);
387 datas.WriteCString(test);
388 datas.WriteCString(test);
389 datas.WriteBool(boolNum);
390 datas.WriteInt32(0);
391 datas.WriteInt32(0);
392 datas.WriteInt32(0);
393 datas.WriteInt32(0);
394 datas.WriteUint16(0);
395 datas.WriteBool(boolNum);
396 ret = softBusServer->OpenSessionInner(datas, reply);
397 EXPECT_EQ(SOFTBUS_IPC_ERR, ret);
398 }
399
400 /**
401 * @tc.name: SoftbusServerStubTest012
402 * @tc.desc: Verify the OpenAuthSessionInner function.
403 * @tc.type: FUNC
404 * @tc.require:
405 */
406 HWTEST_F(SoftbusServerStubTest, SoftbusServerStubTest012, TestSize.Level1)
407 {
408 sptr<OHOS::SoftBusServerStub> softBusServer = new OHOS::SoftBusServer(SOFTBUS_SERVER_SA_ID, true);
409 ASSERT_NE(nullptr, softBusServer);
410 ConnectionAddr addrInfo;
411 memset_s(&addrInfo, sizeof(ConnectionAddr), 0, sizeof(ConnectionAddr));
412 char test[10] = "test";
413 MessageParcel datas;
414 MessageParcel reply;
415
416 int32_t ret = softBusServer->OpenAuthSessionInner(datas, reply);
417 EXPECT_EQ(SOFTBUS_TRANS_PROXY_READCSTRING_FAILED, ret);
418
419 datas.WriteCString(test);
420 datas.WriteRawData(&addrInfo, sizeof(ConnectionAddr));
421 ret = softBusServer->OpenAuthSessionInner(datas, reply);
422 EXPECT_EQ(SOFTBUS_OK, ret);
423 }
424
425 /**
426 * @tc.name: SoftbusServerStubTest013
427 * @tc.desc: Verify the NotifyAuthSuccessInner function.
428 * @tc.type: FUNC
429 * @tc.require:
430 */
431 HWTEST_F(SoftbusServerStubTest, SoftbusServerStubTest013, TestSize.Level1)
432 {
433 sptr<OHOS::SoftBusServerStub> softBusServer = new OHOS::SoftBusServer(SOFTBUS_SERVER_SA_ID, true);
434 ASSERT_NE(nullptr, softBusServer);
435 int32_t channelId = 0;
436 int32_t channelType = 0;
437 MessageParcel datas;
438 MessageParcel reply;
439
440 NiceMock<SoftbusServerStubTestInterfaceMock> softbusServerStubMock;
441 EXPECT_CALL(softbusServerStubMock, TransGetAndComparePid).WillRepeatedly(Return(SOFTBUS_OK));
442 int32_t ret = softBusServer->NotifyAuthSuccessInner(datas, reply);
443 EXPECT_EQ(SOFTBUS_TRANS_PROXY_READINT_FAILED, ret);
444
445 datas.WriteInt32(channelId);
446 ret = softBusServer->NotifyAuthSuccessInner(datas, reply);
447 EXPECT_EQ(SOFTBUS_TRANS_PROXY_READINT_FAILED, ret);
448
449 datas.WriteInt32(channelId);
450 datas.WriteInt32(channelType);
451 ret = softBusServer->NotifyAuthSuccessInner(datas, reply);
452 EXPECT_EQ(SOFTBUS_OK, ret);
453 }
454
455 /**
456 * @tc.name: SoftbusServerStubTest014
457 * @tc.desc: Verify the ReleaseResourcesInner function.
458 * @tc.type: FUNC
459 * @tc.require:
460 */
461 HWTEST_F(SoftbusServerStubTest, SoftbusServerStubTest014, TestSize.Level1)
462 {
463 sptr<OHOS::SoftBusServerStub> softBusServer = new OHOS::SoftBusServer(SOFTBUS_SERVER_SA_ID, true);
464 ASSERT_NE(nullptr, softBusServer);
465 NiceMock<SoftbusServerStubTestInterfaceMock> softbusServerStubMock;
466 int32_t channelId = 0;
467 MessageParcel datas;
468 MessageParcel reply;
469
470 int32_t ret = softBusServer->ReleaseResourcesInner(datas, reply);
471 EXPECT_EQ(SOFTBUS_IPC_ERR, ret);
472
473 datas.WriteInt32(channelId);
474 EXPECT_CALL(softbusServerStubMock, TransGetAndComparePid).WillRepeatedly(Return(SOFTBUS_NO_INIT));
475 ret = softBusServer->ReleaseResourcesInner(datas, reply);
476 EXPECT_EQ(SOFTBUS_NO_INIT, ret);
477
478 datas.WriteInt32(channelId);
479 EXPECT_CALL(softbusServerStubMock, TransGetAndComparePid).WillRepeatedly(Return(SOFTBUS_OK));
480 EXPECT_CALL(softbusServerStubMock, TransReleaseUdpResources).WillRepeatedly(Return(SOFTBUS_OK));
481 ret = softBusServer->ReleaseResourcesInner(datas, reply);
482 EXPECT_EQ(SOFTBUS_OK, ret);
483 }
484
485 /**
486 * @tc.name: SoftbusServerStubTest015
487 * @tc.desc: Verify the CloseChannelInner function.
488 * @tc.type: FUNC
489 * @tc.require:
490 */
491 HWTEST_F(SoftbusServerStubTest, SoftbusServerStubTest015, TestSize.Level1)
492 {
493 sptr<OHOS::SoftBusServerStub> softBusServer = new OHOS::SoftBusServer(SOFTBUS_SERVER_SA_ID, true);
494 ASSERT_NE(nullptr, softBusServer);
495 NiceMock<SoftbusServerStubTestInterfaceMock> softbusServerStubMock;
496 char test[10] = "test";
497 int32_t channelId = 0;
498 int32_t channelType = CHANNEL_TYPE_UNDEFINED;
499 MessageParcel datas;
500 MessageParcel reply;
501
502 int32_t ret = softBusServer->CloseChannelInner(datas, reply);
503 EXPECT_EQ(SOFTBUS_TRANS_PROXY_READINT_FAILED, ret);
504 datas.WriteInt32(channelId);
505 ret = softBusServer->CloseChannelInner(datas, reply);
506 EXPECT_EQ(SOFTBUS_TRANS_PROXY_READINT_FAILED, ret);
507
508 datas.WriteInt32(channelId);
509 datas.WriteInt32(channelType);
510 ret = softBusServer->CloseChannelInner(datas, reply);
511 EXPECT_EQ(SOFTBUS_IPC_ERR, ret);
512 datas.WriteInt32(channelId);
513 datas.WriteInt32(channelType);
514 datas.WriteCString(test);
515 EXPECT_CALL(softbusServerStubMock, TransGetAndComparePidBySession).WillRepeatedly(Return(SOFTBUS_NO_INIT));
516 ret = softBusServer->CloseChannelInner(datas, reply);
517 EXPECT_EQ(SOFTBUS_NO_INIT, ret);
518
519 datas.WriteInt32(channelId);
520 datas.WriteInt32(channelType);
521 datas.WriteCString(test);
522 EXPECT_CALL(softbusServerStubMock, TransGetAndComparePidBySession).WillRepeatedly(Return(SOFTBUS_OK));
523 ret = softBusServer->CloseChannelInner(datas, reply);
524 EXPECT_EQ(SOFTBUS_OK, ret);
525 channelType = 0;
526 datas.WriteInt32(channelId);
527 datas.WriteInt32(channelType);
528 datas.WriteCString(test);
529 EXPECT_CALL(softbusServerStubMock, TransGetAndComparePid).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, TransGetAndComparePid).WillRepeatedly(Return(SOFTBUS_OK));
537 ret = softBusServer->CloseChannelInner(datas, reply);
538 EXPECT_EQ(SOFTBUS_OK, ret);
539 }
540
541 /**
542 * @tc.name: SoftbusServerStubTest016
543 * @tc.desc: Verify the CloseChannelWithStatisticsInner function.
544 * @tc.type: FUNC
545 * @tc.require:
546 */
547 HWTEST_F(SoftbusServerStubTest, SoftbusServerStubTest016, TestSize.Level1)
548 {
549 sptr<OHOS::SoftBusServerStub> softBusServer = new OHOS::SoftBusServer(SOFTBUS_SERVER_SA_ID, true);
550 ASSERT_NE(nullptr, softBusServer);
551 char test[10] = "test";
552 int32_t channelId = 1;
553 uint64_t laneId = 1;
554 uint32_t len = 10;
555 int32_t channelType = 0;
556 MessageParcel datas;
557 MessageParcel reply;
558
559 int32_t ret = softBusServer->CloseChannelWithStatisticsInner(datas, reply);
560 EXPECT_EQ(SOFTBUS_TRANS_PROXY_READINT_FAILED, ret);
561
562 datas.WriteInt32(channelId);
563 ret = softBusServer->CloseChannelWithStatisticsInner(datas, reply);
564 EXPECT_EQ(SOFTBUS_TRANS_PROXY_READINT_FAILED, ret);
565
566 datas.WriteInt32(channelId);
567 datas.WriteInt32(channelType);
568 ret = softBusServer->CloseChannelWithStatisticsInner(datas, reply);
569 EXPECT_EQ(SOFTBUS_TRANS_PROXY_READUINT_FAILED, ret);
570
571 datas.WriteInt32(channelId);
572 datas.WriteInt32(channelType);
573 datas.WriteUint64(laneId);
574 ret = softBusServer->CloseChannelWithStatisticsInner(datas, reply);
575 EXPECT_EQ(SOFTBUS_TRANS_PROXY_READUINT_FAILED, ret);
576
577 datas.WriteInt32(channelId);
578 datas.WriteInt32(channelType);
579 datas.WriteUint64(laneId);
580 datas.WriteUint32(len);
581 ret = softBusServer->CloseChannelWithStatisticsInner(datas, reply);
582 EXPECT_EQ(SOFTBUS_IPC_ERR, ret);
583
584 datas.WriteInt32(channelId);
585 datas.WriteInt32(channelType);
586 datas.WriteUint64(laneId);
587 datas.WriteUint32(len);
588 datas.WriteRawData(test, len);
589 ret = softBusServer->CloseChannelWithStatisticsInner(datas, reply);
590 EXPECT_EQ(SOFTBUS_OK, ret);
591 }
592
593 /**
594 * @tc.name: SoftbusServerStubTest017
595 * @tc.desc: Verify the SendMessageInner function part01.
596 * @tc.type: FUNC
597 * @tc.require:
598 */
599 HWTEST_F(SoftbusServerStubTest, SoftbusServerStubTest017, TestSize.Level1)
600 {
601 sptr<OHOS::SoftBusServerStub> softBusServer = new OHOS::SoftBusServer(SOFTBUS_SERVER_SA_ID, true);
602 ASSERT_NE(nullptr, softBusServer);
603 char test[10] = "test";
604 int32_t channelId = 0;
605 int32_t channelType = 0;
606 uint32_t len = 10;
607 MessageParcel datas;
608 MessageParcel reply;
609
610 int32_t ret = softBusServer->SendMessageInner(datas, reply);
611 EXPECT_EQ(SOFTBUS_TRANS_PROXY_READINT_FAILED, ret);
612
613 datas.WriteInt32(channelId);
614 ret = softBusServer->SendMessageInner(datas, reply);
615 EXPECT_EQ(SOFTBUS_TRANS_PROXY_READINT_FAILED, ret);
616
617 datas.WriteInt32(channelId);
618 datas.WriteInt32(channelType);
619 ret = softBusServer->SendMessageInner(datas, reply);
620 EXPECT_EQ(SOFTBUS_TRANS_PROXY_READUINT_FAILED, ret);
621
622 datas.WriteInt32(channelId);
623 datas.WriteInt32(channelType);
624 datas.WriteUint32(len);
625 ret = softBusServer->SendMessageInner(datas, reply);
626 EXPECT_EQ(SOFTBUS_IPC_ERR, ret);
627
628 datas.WriteInt32(channelId);
629 datas.WriteInt32(channelType);
630 datas.WriteUint32(len);
631 datas.WriteRawData(test, len);
632 ret = softBusServer->SendMessageInner(datas, reply);
633 EXPECT_EQ(SOFTBUS_TRANS_PROXY_READINT_FAILED, ret);
634 }
635
636 /**
637 * @tc.name: SoftbusServerStubTest018
638 * @tc.desc: Verify the SendMessageInner function part02.
639 * @tc.type: FUNC
640 * @tc.require:
641 */
642 HWTEST_F(SoftbusServerStubTest, SoftbusServerStubTest018, TestSize.Level1)
643 {
644 sptr<OHOS::SoftBusServerStub> softBusServer = new OHOS::SoftBusServer(SOFTBUS_SERVER_SA_ID, true);
645 ASSERT_NE(nullptr, softBusServer);
646 NiceMock<SoftbusServerStubTestInterfaceMock> softbusServerStubMock;
647 char test[10] = "test";
648 int32_t channelId = 0;
649 int32_t channelType = 0;
650 uint32_t len = 10;
651 int32_t msgType = 0;
652 MessageParcel datas;
653 MessageParcel reply;
654
655 datas.WriteInt32(channelId);
656 datas.WriteInt32(channelType);
657 datas.WriteUint32(len);
658 datas.WriteRawData(test, len);
659 datas.WriteInt32(msgType);
660 EXPECT_CALL(softbusServerStubMock, TransGetAppInfoByChanId).WillRepeatedly(Return(SOFTBUS_NOT_FIND));
661 int32_t ret = softBusServer->SendMessageInner(datas, reply);
662 EXPECT_EQ(SOFTBUS_OK, ret);
663 }
664
665 /**
666 * @tc.name: SoftbusServerStubTest019
667 * @tc.desc: Verify the EvaluateQosInner function.
668 * @tc.type: FUNC
669 * @tc.require:
670 */
671 HWTEST_F(SoftbusServerStubTest, SoftbusServerStubTest019, TestSize.Level1)
672 {
673 sptr<OHOS::SoftBusServerStub> softBusServer = new OHOS::SoftBusServer(SOFTBUS_SERVER_SA_ID, true);
674 ASSERT_NE(nullptr, softBusServer);
675 char test[10] = "test";
676 QosTV qosInfo[7];
677 int32_t dataTypeNumber = 0;
678 uint32_t qosCount = 10;
679 MessageParcel datas;
680 MessageParcel reply;
681
682 int32_t ret = softBusServer->EvaluateQosInner(datas, reply);
683 EXPECT_EQ(SOFTBUS_IPC_ERR, ret);
684
685 datas.WriteCString(test);
686 ret = softBusServer->EvaluateQosInner(datas, reply);
687 EXPECT_EQ(SOFTBUS_IPC_ERR, ret);
688
689 datas.WriteCString(test);
690 datas.WriteInt32(dataTypeNumber);
691 ret = softBusServer->EvaluateQosInner(datas, reply);
692 EXPECT_EQ(SOFTBUS_IPC_ERR, ret);
693
694 dataTypeNumber = 5;
695 datas.WriteCString(test);
696 datas.WriteInt32(dataTypeNumber);
697 ret = softBusServer->EvaluateQosInner(datas, reply);
698 EXPECT_EQ(SOFTBUS_IPC_ERR, ret);
699
700 datas.WriteCString(test);
701 datas.WriteInt32(dataTypeNumber);
702 datas.WriteInt32(qosCount);
703 ret = softBusServer->EvaluateQosInner(datas, reply);
704 EXPECT_EQ(SOFTBUS_IPC_ERR, ret);
705
706 qosCount = 7;
707 datas.WriteCString(test);
708 datas.WriteInt32(dataTypeNumber);
709 datas.WriteInt32(qosCount);
710 ret = softBusServer->EvaluateQosInner(datas, reply);
711 EXPECT_EQ(SOFTBUS_IPC_ERR, ret);
712
713 datas.WriteCString(test);
714 datas.WriteInt32(dataTypeNumber);
715 datas.WriteInt32(qosCount);
716 datas.WriteBuffer(qosInfo, sizeof(QosTV) * qosCount);
717 ret = softBusServer->EvaluateQosInner(datas, reply);
718 EXPECT_EQ(SOFTBUS_OK, ret);
719 }
720
721 /**
722 * @tc.name: SoftbusServerStubTest020
723 * @tc.desc: Verify the Join and Leave LNNInner function.
724 * @tc.type: FUNC
725 * @tc.require:
726 */
727 HWTEST_F(SoftbusServerStubTest, SoftbusServerStubTest020, TestSize.Level1)
728 {
729 sptr<OHOS::SoftBusServerStub> softBusServer = new OHOS::SoftBusServer(SOFTBUS_SERVER_SA_ID, true);
730 ASSERT_NE(nullptr, softBusServer);
731 ConnectionAddr addr;
732 char test[10] = "test";
733 uint32_t addrTypeLen = sizeof(ConnectionAddr);
734 MessageParcel datas;
735 MessageParcel reply;
736
737 int32_t ret = softBusServer->JoinLNNInner(datas, reply);
738 EXPECT_EQ(SOFTBUS_IPC_ERR, ret);
739
740 datas.WriteCString(test);
741 ret = softBusServer->JoinLNNInner(datas, reply);
742 EXPECT_EQ(SOFTBUS_IPC_ERR, ret);
743
744 datas.WriteCString(test);
745 datas.WriteUint32(addrTypeLen);
746 ret = softBusServer->JoinLNNInner(datas, reply);
747 EXPECT_EQ(SOFTBUS_IPC_ERR, ret);
748
749 datas.WriteCString(test);
750 datas.WriteUint32(addrTypeLen);
751 datas.WriteRawData(&addr, addrTypeLen);
752 ret = softBusServer->JoinLNNInner(datas, reply);
753 EXPECT_EQ(SOFTBUS_OK, ret);
754
755 ret = softBusServer->LeaveLNNInner(datas, reply);
756 EXPECT_EQ(SOFTBUS_IPC_ERR, ret);
757
758 datas.WriteCString(test);
759 ret = softBusServer->LeaveLNNInner(datas, reply);
760 EXPECT_EQ(SOFTBUS_IPC_ERR, ret);
761
762 datas.WriteCString(test);
763 datas.WriteCString(test);
764 ret = softBusServer->LeaveLNNInner(datas, reply);
765 EXPECT_EQ(SOFTBUS_OK, ret);
766 }
767
768 /**
769 * @tc.name: SoftbusServerStubTest021
770 * @tc.desc: Verify the GetAllOnlineNodeInfoInner function.
771 * @tc.type: FUNC
772 * @tc.require:
773 */
774 HWTEST_F(SoftbusServerStubTest, SoftbusServerStubTest021, TestSize.Level1)
775 {
776 sptr<OHOS::SoftBusServerStub> softBusServer = new OHOS::SoftBusServer(SOFTBUS_SERVER_SA_ID, true);
777 ASSERT_NE(nullptr, softBusServer);
778 NiceMock<SoftbusServerStubTestInterfaceMock> softbusServerStubMock;
779 char test[10] = "test";
780 uint32_t infoTypeLen = 0;
781 MessageParcel datas;
782 MessageParcel reply;
783
784 int32_t ret = softBusServer->GetAllOnlineNodeInfoInner(datas, reply);
785 EXPECT_EQ(SOFTBUS_IPC_ERR, ret);
786
787 datas.WriteCString(test);
788 ret = softBusServer->GetAllOnlineNodeInfoInner(datas, reply);
789 EXPECT_EQ(SOFTBUS_IPC_ERR, ret);
790
791 datas.WriteCString(test);
792 datas.WriteUint32(infoTypeLen);
793 EXPECT_CALL(softbusServerStubMock, LnnIpcGetAllOnlineNodeInfo).WillRepeatedly(
794 Return(SOFTBUS_NETWORK_GET_ALL_NODE_INFO_ERR)
795 );
796 ret = softBusServer->GetAllOnlineNodeInfoInner(datas, reply);
797 EXPECT_EQ(SOFTBUS_NETWORK_GET_ALL_NODE_INFO_ERR, ret);
798
799 datas.WriteCString(test);
800 datas.WriteUint32(infoTypeLen);
801 EXPECT_CALL(softbusServerStubMock, LnnIpcGetAllOnlineNodeInfo).WillRepeatedly(Return(SOFTBUS_OK));
802 ret = softBusServer->GetAllOnlineNodeInfoInner(datas, reply);
803 EXPECT_NE(SOFTBUS_IPC_ERR, ret);
804 }
805
806 /**
807 * @tc.name: SoftbusServerStubTest022
808 * @tc.desc: Verify the GetLocalDeviceInfoInner function.
809 * @tc.type: FUNC
810 * @tc.require:
811 */
812 HWTEST_F(SoftbusServerStubTest, SoftbusServerStubTest022, TestSize.Level1)
813 {
814 sptr<OHOS::SoftBusServerStub> softBusServer = new OHOS::SoftBusServer(SOFTBUS_SERVER_SA_ID, true);
815 ASSERT_NE(nullptr, softBusServer);
816 NiceMock<SoftbusServerStubTestInterfaceMock> softbusServerStubMock;
817 char test[10] = "test";
818 uint32_t infoTypeLen = 0;
819 MessageParcel datas;
820 MessageParcel reply;
821
822 int32_t ret = softBusServer->GetLocalDeviceInfoInner(datas, reply);
823 EXPECT_EQ(SOFTBUS_IPC_ERR, ret);
824
825 datas.WriteCString(test);
826 ret = softBusServer->GetLocalDeviceInfoInner(datas, reply);
827 EXPECT_EQ(SOFTBUS_IPC_ERR, ret);
828
829 datas.WriteCString(test);
830 datas.WriteUint32(infoTypeLen);
831 ret = softBusServer->GetLocalDeviceInfoInner(datas, reply);
832 EXPECT_EQ(SOFTBUS_IPC_ERR, ret);
833
834 infoTypeLen = sizeof(NodeBasicInfo);
835 datas.WriteCString(test);
836 datas.WriteUint32(infoTypeLen);
837 EXPECT_CALL(softbusServerStubMock, LnnIpcGetLocalDeviceInfo).WillRepeatedly(
838 Return(SOFTBUS_NETWORK_GET_LOCAL_NODE_INFO_ERR)
839 );
840 ret = softBusServer->GetLocalDeviceInfoInner(datas, reply);
841 EXPECT_EQ(SOFTBUS_NETWORK_GET_LOCAL_NODE_INFO_ERR, ret);
842
843 datas.WriteCString(test);
844 datas.WriteUint32(infoTypeLen);
845 EXPECT_CALL(softbusServerStubMock, LnnIpcGetLocalDeviceInfo).WillRepeatedly(Return(SOFTBUS_OK));
846 ret = softBusServer->GetLocalDeviceInfoInner(datas, reply);
847 EXPECT_NE(SOFTBUS_IPC_ERR, ret);
848 }
849
850 /**
851 * @tc.name: SoftbusServerStubTest023
852 * @tc.desc: Verify the GetNodeKeyInfoInner function part01.
853 * @tc.type: FUNC
854 * @tc.require:
855 */
856 HWTEST_F(SoftbusServerStubTest, SoftbusServerStubTest023, TestSize.Level1)
857 {
858 sptr<OHOS::SoftBusServerStub> softBusServer = new OHOS::SoftBusServer(SOFTBUS_SERVER_SA_ID, true);
859 ASSERT_NE(nullptr, softBusServer);
860 NiceMock<SoftbusServerStubTestInterfaceMock> softbusServerStubMock;
861 EXPECT_CALL(softbusServerStubMock, LnnIpcGetNodeKeyInfo).WillRepeatedly(Return(SOFTBUS_OK));
862 char test[10] = "test";
863 int32_t key = 13;
864 uint32_t len = 20;
865 MessageParcel datas;
866 MessageParcel reply;
867
868 int32_t ret = softBusServer->GetNodeKeyInfoInner(datas, reply);
869 EXPECT_EQ(SOFTBUS_IPC_ERR, ret);
870
871 datas.WriteCString(test);
872 ret = softBusServer->GetNodeKeyInfoInner(datas, reply);
873 EXPECT_EQ(SOFTBUS_IPC_ERR, ret);
874
875 datas.WriteCString(test);
876 datas.WriteCString(test);
877 ret = softBusServer->GetNodeKeyInfoInner(datas, reply);
878 EXPECT_EQ(SOFTBUS_IPC_ERR, ret);
879
880 datas.WriteCString(test);
881 datas.WriteCString(test);
882 datas.WriteInt32(key);
883 datas.WriteUint32(len);
884 ret = softBusServer->GetNodeKeyInfoInner(datas, reply);
885 EXPECT_NE(SOFTBUS_IPC_ERR, ret);
886 }
887
888 /**
889 * @tc.name: SoftbusServerStubTest024
890 * @tc.desc: Verify the GetNodeKeyInfoInner function part02.
891 * @tc.type: FUNC
892 * @tc.require:
893 */
894 HWTEST_F(SoftbusServerStubTest, SoftbusServerStubTest024, TestSize.Level1)
895 {
896 sptr<OHOS::SoftBusServerStub> softBusServer = new OHOS::SoftBusServer(SOFTBUS_SERVER_SA_ID, true);
897 ASSERT_NE(nullptr, softBusServer);
898 NiceMock<SoftbusServerStubTestInterfaceMock> softbusServerStubMock;
899 char test[10] = "test";
900 int32_t key = 0;
901 uint32_t len = 0;
902 MessageParcel datas;
903 MessageParcel reply;
904
905 datas.WriteCString(test);
906 datas.WriteCString(test);
907 datas.WriteInt32(key);
908 int32_t ret = softBusServer->GetNodeKeyInfoInner(datas, reply);
909 EXPECT_EQ(SOFTBUS_IPC_ERR, ret);
910
911 datas.WriteCString(test);
912 datas.WriteCString(test);
913 datas.WriteInt32(key);
914 datas.WriteUint32(len);
915 ret = softBusServer->GetNodeKeyInfoInner(datas, reply);
916 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
917
918 len = 65;
919 datas.WriteCString(test);
920 datas.WriteCString(test);
921 datas.WriteInt32(key);
922 datas.WriteUint32(len);
923 EXPECT_CALL(softbusServerStubMock, LnnIpcGetNodeKeyInfo).WillRepeatedly(Return(SOFTBUS_NETWORK_NODE_KEY_INFO_ERR));
924 ret = softBusServer->GetNodeKeyInfoInner(datas, reply);
925 EXPECT_EQ(SOFTBUS_NETWORK_NODE_KEY_INFO_ERR, ret);
926
927 datas.WriteCString(test);
928 datas.WriteCString(test);
929 datas.WriteInt32(key);
930 datas.WriteUint32(len);
931 EXPECT_CALL(softbusServerStubMock, LnnIpcGetNodeKeyInfo).WillRepeatedly(Return(SOFTBUS_OK));
932 ret = softBusServer->GetNodeKeyInfoInner(datas, reply);
933 EXPECT_NE(SOFTBUS_IPC_ERR, ret);
934 }
935
936 /**
937 * @tc.name: SoftbusServerStubTest025
938 * @tc.desc: Verify the SetNodeDataChangeFlagInner function.
939 * @tc.type: FUNC
940 * @tc.require:
941 */
942 HWTEST_F(SoftbusServerStubTest, SoftbusServerStubTest025, TestSize.Level1)
943 {
944 sptr<OHOS::SoftBusServerStub> softBusServer = new OHOS::SoftBusServer(SOFTBUS_SERVER_SA_ID, true);
945 ASSERT_NE(nullptr, softBusServer);
946 char test[10] = "test";
947 uint16_t changeFlag = 0;
948 MessageParcel datas;
949 MessageParcel reply;
950
951 int32_t ret = softBusServer->SetNodeDataChangeFlagInner(datas, reply);
952 EXPECT_EQ(SOFTBUS_IPC_ERR, ret);
953
954 datas.WriteCString(test);
955 ret = softBusServer->SetNodeDataChangeFlagInner(datas, reply);
956 EXPECT_EQ(SOFTBUS_IPC_ERR, ret);
957
958 datas.WriteCString(test);
959 datas.WriteCString(test);
960 ret = softBusServer->SetNodeDataChangeFlagInner(datas, reply);
961 EXPECT_EQ(SOFTBUS_IPC_ERR, ret);
962
963 datas.WriteCString(test);
964 datas.WriteCString(test);
965 datas.WriteUint16(changeFlag);
966 ret = softBusServer->SetNodeDataChangeFlagInner(datas, reply);
967 EXPECT_EQ(SOFTBUS_OK, ret);
968 }
969
970 /**
971 * @tc.name: SoftbusServerStubTest026
972 * @tc.desc: Verify the RegDataLevelChangeCbInner function.
973 * @tc.type: FUNC
974 * @tc.require:
975 */
976 HWTEST_F(SoftbusServerStubTest, SoftbusServerStubTest026, TestSize.Level1)
977 {
978 sptr<OHOS::SoftBusServerStub> softBusServer = new OHOS::SoftBusServer(SOFTBUS_SERVER_SA_ID, true);
979 ASSERT_NE(nullptr, softBusServer);
980 char test[10] = "test";
981 MessageParcel datas;
982 MessageParcel reply;
983
984 int32_t ret = softBusServer->RegDataLevelChangeCbInner(datas, reply);
985 EXPECT_EQ(SOFTBUS_IPC_ERR, ret);
986
987 datas.WriteCString(test);
988 ret = softBusServer->RegDataLevelChangeCbInner(datas, reply);
989 EXPECT_EQ(SOFTBUS_IPC_ERR, ret);
990 }
991
992 /**
993 * @tc.name: SoftbusServerStubTest027
994 * @tc.desc: Verify the UnregDataLevelChangeCbInner function.
995 * @tc.type: FUNC
996 * @tc.require:
997 */
998 HWTEST_F(SoftbusServerStubTest, SoftbusServerStubTest027, TestSize.Level1)
999 {
1000 sptr<OHOS::SoftBusServerStub> softBusServer = new OHOS::SoftBusServer(SOFTBUS_SERVER_SA_ID, true);
1001 ASSERT_NE(nullptr, softBusServer);
1002 char test[10] = "test";
1003 MessageParcel datas;
1004 MessageParcel reply;
1005
1006 int32_t ret = softBusServer->UnregDataLevelChangeCbInner(datas, reply);
1007 EXPECT_EQ(SOFTBUS_IPC_ERR, ret);
1008
1009 datas.WriteCString(test);
1010 ret = softBusServer->UnregDataLevelChangeCbInner(datas, reply);
1011 EXPECT_EQ(SOFTBUS_IPC_ERR, ret);
1012 }
1013
1014 /**
1015 * @tc.name: SoftbusServerStubTest028
1016 * @tc.desc: Verify the SetDataLevelInner function.
1017 * @tc.type: FUNC
1018 * @tc.require:
1019 */
1020 HWTEST_F(SoftbusServerStubTest, SoftbusServerStubTest028, TestSize.Level1)
1021 {
1022 sptr<OHOS::SoftBusServerStub> softBusServer = new OHOS::SoftBusServer(SOFTBUS_SERVER_SA_ID, true);
1023 ASSERT_NE(nullptr, softBusServer);
1024 DataLevel dataLevel;
1025 MessageParcel datas;
1026 MessageParcel reply;
1027
1028 int32_t ret = softBusServer->SetDataLevelInner(datas, reply);
1029 EXPECT_EQ(SOFTBUS_IPC_ERR, ret);
1030
1031 datas.WriteRawData(&dataLevel, sizeof(dataLevel));
1032 ret = softBusServer->SetDataLevelInner(datas, reply);
1033 EXPECT_EQ(SOFTBUS_OK, ret);
1034 }
1035
1036 /**
1037 * @tc.name: SoftbusServerStubTest029
1038 * @tc.desc: Verify the Start and Stop TimeSyncInner function.
1039 * @tc.type: FUNC
1040 * @tc.require:
1041 */
1042 HWTEST_F(SoftbusServerStubTest, SoftbusServerStubTest029, TestSize.Level1)
1043 {
1044 sptr<OHOS::SoftBusServerStub> softBusServer = new OHOS::SoftBusServer(SOFTBUS_SERVER_SA_ID, true);
1045 ASSERT_NE(nullptr, softBusServer);
1046 char test[10] = "test";
1047 int32_t accuracy = 0;
1048 int32_t period = 0;
1049 MessageParcel datas;
1050 MessageParcel reply;
1051
1052 int32_t ret = softBusServer->StartTimeSyncInner(datas, reply);
1053 EXPECT_EQ(SOFTBUS_IPC_ERR, ret);
1054
1055 datas.WriteCString(test);
1056 datas.WriteCString(test);
1057 ret = softBusServer->StartTimeSyncInner(datas, reply);
1058 EXPECT_EQ(SOFTBUS_IPC_ERR, ret);
1059
1060 datas.WriteCString(test);
1061 datas.WriteCString(test);
1062 datas.WriteInt32(accuracy);
1063 ret = softBusServer->StartTimeSyncInner(datas, reply);
1064 EXPECT_EQ(SOFTBUS_IPC_ERR, ret);
1065
1066 datas.WriteCString(test);
1067 datas.WriteCString(test);
1068 datas.WriteInt32(accuracy);
1069 datas.WriteInt32(period);
1070 ret = softBusServer->StartTimeSyncInner(datas, reply);
1071 EXPECT_EQ(SOFTBUS_OK, ret);
1072
1073 datas.WriteCString(test);
1074 ret = softBusServer->StopTimeSyncInner(datas, reply);
1075 EXPECT_EQ(SOFTBUS_IPC_ERR, ret);
1076
1077 datas.WriteCString(test);
1078 datas.WriteCString(test);
1079 ret = softBusServer->StopTimeSyncInner(datas, reply);
1080 EXPECT_EQ(SOFTBUS_OK, ret);
1081 }
1082
1083 /**
1084 * @tc.name: SoftbusServerStubTest030
1085 * @tc.desc: Verify the QosReportInner function.
1086 * @tc.type: FUNC
1087 * @tc.require:
1088 */
1089 HWTEST_F(SoftbusServerStubTest, SoftbusServerStubTest030, TestSize.Level1)
1090 {
1091 sptr<OHOS::SoftBusServerStub> softBusServer = new OHOS::SoftBusServer(SOFTBUS_SERVER_SA_ID, true);
1092 ASSERT_NE(nullptr, softBusServer);
1093 int32_t channelId = 0;
1094 int32_t channelType = 0;
1095 int32_t appType = 0;
1096 int32_t quality = 0;
1097 MessageParcel datas;
1098 MessageParcel reply;
1099
1100 NiceMock<SoftbusServerStubTestInterfaceMock> softbusServerStubMock;
1101 EXPECT_CALL(softbusServerStubMock, CheckUidAndPid).WillRepeatedly(Return(true));
1102 int32_t ret = softBusServer->QosReportInner(datas, reply);
1103 EXPECT_EQ(SOFTBUS_TRANS_PROXY_READINT_FAILED, ret);
1104
1105 datas.WriteInt32(channelId);
1106 ret = softBusServer->QosReportInner(datas, reply);
1107 EXPECT_EQ(SOFTBUS_TRANS_PROXY_READINT_FAILED, ret);
1108
1109 datas.WriteInt32(channelId);
1110 datas.WriteInt32(channelType);
1111 ret = softBusServer->QosReportInner(datas, reply);
1112 EXPECT_EQ(SOFTBUS_TRANS_PROXY_READINT_FAILED, ret);
1113
1114 datas.WriteInt32(channelId);
1115 datas.WriteInt32(channelType);
1116 datas.WriteInt32(appType);
1117 ret = softBusServer->QosReportInner(datas, reply);
1118 EXPECT_EQ(SOFTBUS_TRANS_PROXY_READINT_FAILED, ret);
1119
1120 datas.WriteInt32(channelId);
1121 datas.WriteInt32(channelType);
1122 datas.WriteInt32(appType);
1123 datas.WriteInt32(quality);
1124 ret = softBusServer->QosReportInner(datas, reply);
1125 EXPECT_EQ(SOFTBUS_OK, ret);
1126 }
1127
1128 /**
1129 * @tc.name: SoftbusServerStubTest031
1130 * @tc.desc: Verify the StreamStatsInner function.
1131 * @tc.type: FUNC
1132 * @tc.require:
1133 */
1134 HWTEST_F(SoftbusServerStubTest, SoftbusServerStubTest031, TestSize.Level1)
1135 {
1136 sptr<OHOS::SoftBusServerStub> softBusServer = new OHOS::SoftBusServer(SOFTBUS_SERVER_SA_ID, true);
1137 ASSERT_NE(nullptr, softBusServer);
1138 int32_t channelId = 0;
1139 int32_t channelType = 0;
1140 StreamSendStats stats;
1141 MessageParcel datas;
1142 MessageParcel reply;
1143
1144 NiceMock<SoftbusServerStubTestInterfaceMock> softbusServerStubMock;
1145 EXPECT_CALL(softbusServerStubMock, CheckUidAndPid).WillRepeatedly(Return(true));
1146 int32_t ret = softBusServer->StreamStatsInner(datas, reply);
1147 EXPECT_EQ(SOFTBUS_TRANS_PROXY_READINT_FAILED, ret);
1148
1149 datas.WriteInt32(channelId);
1150 ret = softBusServer->StreamStatsInner(datas, reply);
1151 EXPECT_EQ(SOFTBUS_TRANS_PROXY_READINT_FAILED, ret);
1152
1153 datas.WriteInt32(channelId);
1154 datas.WriteInt32(channelType);
1155 ret = softBusServer->StreamStatsInner(datas, reply);
1156 EXPECT_EQ(SOFTBUS_TRANS_PROXY_READRAWDATA_FAILED, ret);
1157
1158 datas.WriteInt32(channelId);
1159 datas.WriteInt32(channelType);
1160 datas.WriteRawData(&stats, sizeof(StreamSendStats));
1161 ret = softBusServer->StreamStatsInner(datas, reply);
1162 EXPECT_EQ(SOFTBUS_OK, ret);
1163 }
1164
1165 /**
1166 * @tc.name: SoftbusServerStubTest032
1167 * @tc.desc: Verify the RippleStatsInner function.
1168 * @tc.type: FUNC
1169 * @tc.require:
1170 */
1171 HWTEST_F(SoftbusServerStubTest, SoftbusServerStubTest032, TestSize.Level1)
1172 {
1173 sptr<OHOS::SoftBusServerStub> softBusServer = new OHOS::SoftBusServer(SOFTBUS_SERVER_SA_ID, true);
1174 ASSERT_NE(nullptr, softBusServer);
1175 int32_t channelId = 0;
1176 int32_t channelType = 0;
1177 TrafficStats stats;
1178 MessageParcel datas;
1179 MessageParcel reply;
1180
1181 NiceMock<SoftbusServerStubTestInterfaceMock> softbusServerStubMock;
1182 EXPECT_CALL(softbusServerStubMock, CheckUidAndPid).WillRepeatedly(Return(true));
1183 int32_t ret = softBusServer->RippleStatsInner(datas, reply);
1184 EXPECT_EQ(SOFTBUS_TRANS_PROXY_READINT_FAILED, ret);
1185
1186 datas.WriteInt32(channelId);
1187 ret = softBusServer->RippleStatsInner(datas, reply);
1188 EXPECT_EQ(SOFTBUS_TRANS_PROXY_READINT_FAILED, ret);
1189
1190 datas.WriteInt32(channelId);
1191 datas.WriteInt32(channelType);
1192 ret = softBusServer->RippleStatsInner(datas, reply);
1193 EXPECT_EQ(SOFTBUS_TRANS_PROXY_READRAWDATA_FAILED, ret);
1194
1195 datas.WriteInt32(channelId);
1196 datas.WriteInt32(channelType);
1197 datas.WriteRawData(&stats, sizeof(TrafficStats));
1198 ret = softBusServer->RippleStatsInner(datas, reply);
1199 EXPECT_EQ(SOFTBUS_OK, ret);
1200 }
1201
1202 /**
1203 * @tc.name: SoftbusServerStubTest033
1204 * @tc.desc: Verify the Grant and Remove Permission Inner function.
1205 * @tc.type: FUNC
1206 * @tc.require:
1207 */
1208 HWTEST_F(SoftbusServerStubTest, SoftbusServerStubTest033, TestSize.Level1)
1209 {
1210 sptr<OHOS::SoftBusServerStub> softBusServer = new OHOS::SoftBusServer(SOFTBUS_SERVER_SA_ID, true);
1211 ASSERT_NE(nullptr, softBusServer);
1212 NiceMock<SoftbusServerStubTestInterfaceMock> softbusServerStubMock;
1213 char test[10] = "test";
1214 int32_t uid = 0;
1215 int32_t pid = 0;
1216 MessageParcel datas;
1217 MessageParcel reply;
1218
1219 EXPECT_CALL(softbusServerStubMock, CheckDynamicPermission).WillRepeatedly(Return(SOFTBUS_PERMISSION_DENIED));
1220 int32_t ret = softBusServer->GrantPermissionInner(datas, reply);
1221 EXPECT_EQ(SOFTBUS_OK, ret);
1222
1223 EXPECT_CALL(softbusServerStubMock, CheckDynamicPermission).WillRepeatedly(Return(SOFTBUS_OK));
1224 datas.WriteInt32(uid);
1225 datas.WriteInt32(pid);
1226 ret = softBusServer->GrantPermissionInner(datas, reply);
1227 EXPECT_EQ(SOFTBUS_OK, ret);
1228
1229 datas.WriteInt32(uid);
1230 datas.WriteInt32(pid);
1231 datas.WriteCString(test);
1232 ret = softBusServer->GrantPermissionInner(datas, reply);
1233 EXPECT_EQ(SOFTBUS_OK, ret);
1234
1235 EXPECT_CALL(softbusServerStubMock, CheckDynamicPermission).WillRepeatedly(Return(SOFTBUS_PERMISSION_DENIED));
1236 ret = softBusServer->RemovePermissionInner(datas, reply);
1237 EXPECT_EQ(SOFTBUS_OK, ret);
1238
1239 EXPECT_CALL(softbusServerStubMock, CheckDynamicPermission).WillRepeatedly(Return(SOFTBUS_OK));
1240 ret = softBusServer->RemovePermissionInner(datas, reply);
1241 EXPECT_EQ(SOFTBUS_OK, ret);
1242
1243 datas.WriteCString(test);
1244 ret = softBusServer->RemovePermissionInner(datas, reply);
1245 EXPECT_EQ(SOFTBUS_OK, ret);
1246 }
1247
1248 /**
1249 * @tc.name: SoftbusServerStubTest034
1250 * @tc.desc: Verify the Publish and Stop Publish LNNInner function part01.
1251 * @tc.type: FUNC
1252 * @tc.require:
1253 */
1254 HWTEST_F(SoftbusServerStubTest, SoftbusServerStubTest034, TestSize.Level1)
1255 {
1256 sptr<OHOS::SoftBusServerStub> softBusServer = new OHOS::SoftBusServer(SOFTBUS_SERVER_SA_ID, true);
1257 ASSERT_NE(nullptr, softBusServer);
1258 char test[10] = "test";
1259 int32_t publishId = 0;
1260 int32_t mode = 0;
1261 int32_t medium = -1;
1262 MessageParcel datas;
1263 MessageParcel reply;
1264
1265 int32_t ret = softBusServer->PublishLNNInner(datas, reply);
1266 EXPECT_EQ(SOFTBUS_IPC_ERR, ret);
1267
1268 datas.WriteCString(test);
1269 ret = softBusServer->PublishLNNInner(datas, reply);
1270 EXPECT_EQ(SOFTBUS_IPC_ERR, ret);
1271
1272 datas.WriteCString(test);
1273 datas.WriteInt32(publishId);
1274 ret = softBusServer->PublishLNNInner(datas, reply);
1275 EXPECT_EQ(SOFTBUS_IPC_ERR, ret);
1276
1277 datas.WriteCString(test);
1278 datas.WriteInt32(publishId);
1279 datas.WriteInt32(mode);
1280 ret = softBusServer->PublishLNNInner(datas, reply);
1281 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
1282
1283 mode = 85;
1284 datas.WriteCString(test);
1285 datas.WriteInt32(publishId);
1286 datas.WriteInt32(mode);
1287 ret = softBusServer->PublishLNNInner(datas, reply);
1288 EXPECT_EQ(SOFTBUS_IPC_ERR, ret);
1289
1290 datas.WriteCString(test);
1291 datas.WriteInt32(publishId);
1292 datas.WriteInt32(mode);
1293 datas.WriteInt32(medium);
1294 ret = softBusServer->PublishLNNInner(datas, reply);
1295 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
1296 }
1297
1298 /**
1299 * @tc.name: SoftbusServerStubTest035
1300 * @tc.desc: Verify the Publish and Stop Publish LNNInner function part02.
1301 * @tc.type: FUNC
1302 * @tc.require:
1303 */
1304 HWTEST_F(SoftbusServerStubTest, SoftbusServerStubTest035, TestSize.Level1)
1305 {
1306 sptr<OHOS::SoftBusServerStub> softBusServer = new OHOS::SoftBusServer(SOFTBUS_SERVER_SA_ID, true);
1307 ASSERT_NE(nullptr, softBusServer);
1308 char test[10] = "test";
1309 int32_t publishId = 0;
1310 int32_t mode = 85;
1311 int32_t medium = 0;
1312 int32_t freq = -1;
1313 MessageParcel datas;
1314 MessageParcel reply;
1315
1316 datas.WriteCString(test);
1317 datas.WriteInt32(publishId);
1318 datas.WriteInt32(mode);
1319 datas.WriteInt32(medium);
1320 int32_t ret = softBusServer->PublishLNNInner(datas, reply);
1321 EXPECT_EQ(SOFTBUS_IPC_ERR, ret);
1322
1323 datas.WriteCString(test);
1324 datas.WriteInt32(publishId);
1325 datas.WriteInt32(mode);
1326 datas.WriteInt32(medium);
1327 datas.WriteInt32(freq);
1328 ret = softBusServer->PublishLNNInner(datas, reply);
1329 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
1330
1331 freq = 0;
1332 datas.WriteCString(test);
1333 datas.WriteInt32(publishId);
1334 datas.WriteInt32(mode);
1335 datas.WriteInt32(medium);
1336 datas.WriteInt32(freq);
1337 ret = softBusServer->PublishLNNInner(datas, reply);
1338 EXPECT_EQ(SOFTBUS_IPC_ERR, ret);
1339
1340 datas.WriteCString(test);
1341 datas.WriteInt32(publishId);
1342 datas.WriteInt32(mode);
1343 datas.WriteInt32(medium);
1344 datas.WriteInt32(freq);
1345 datas.WriteCString(test);
1346 ret = softBusServer->PublishLNNInner(datas, reply);
1347 EXPECT_EQ(SOFTBUS_IPC_ERR, ret);
1348 }
1349
1350 /**
1351 * @tc.name: SoftbusServerStubTest036
1352 * @tc.desc: Verify the Publish and Stop Publish LNNInner function part03.
1353 * @tc.type: FUNC
1354 * @tc.require:
1355 */
1356 HWTEST_F(SoftbusServerStubTest, SoftbusServerStubTest036, TestSize.Level1)
1357 {
1358 sptr<OHOS::SoftBusServerStub> softBusServer = new OHOS::SoftBusServer(SOFTBUS_SERVER_SA_ID, true);
1359 ASSERT_NE(nullptr, softBusServer);
1360 char test[10] = "test";
1361 int32_t publishId = 0;
1362 int32_t mode = 85;
1363 int32_t medium = 0;
1364 int32_t freq = 0;
1365 uint32_t dataLen = 0;
1366 bool ranging = true;
1367 MessageParcel datas;
1368 MessageParcel reply;
1369
1370 datas.WriteCString(test);
1371 datas.WriteInt32(publishId);
1372 datas.WriteInt32(mode);
1373 datas.WriteInt32(medium);
1374 datas.WriteInt32(freq);
1375 datas.WriteCString(test);
1376 datas.WriteUint32(dataLen);
1377 int32_t ret = softBusServer->PublishLNNInner(datas, reply);
1378 EXPECT_EQ(SOFTBUS_IPC_ERR, ret);
1379
1380 datas.WriteCString(test);
1381 datas.WriteInt32(publishId);
1382 datas.WriteInt32(mode);
1383 datas.WriteInt32(medium);
1384 datas.WriteInt32(freq);
1385 datas.WriteCString(test);
1386 datas.WriteUint32(dataLen);
1387 datas.WriteBool(ranging);
1388 ret = softBusServer->PublishLNNInner(datas, reply);
1389 EXPECT_EQ(SOFTBUS_OK, ret);
1390
1391 ret = softBusServer->StopPublishLNNInner(datas, reply);
1392 EXPECT_EQ(SOFTBUS_IPC_ERR, ret);
1393
1394 datas.WriteCString(test);
1395 ret = softBusServer->StopPublishLNNInner(datas, reply);
1396 EXPECT_EQ(SOFTBUS_IPC_ERR, ret);
1397
1398 datas.WriteCString(test);
1399 datas.WriteInt32(publishId);
1400 ret = softBusServer->StopPublishLNNInner(datas, reply);
1401 EXPECT_EQ(SOFTBUS_OK, ret);
1402 }
1403
1404 /**
1405 * @tc.name: SoftbusServerStubTest037
1406 * @tc.desc: Verify the Refresh and Stop Refresh LNNInner function part01.
1407 * @tc.type: FUNC
1408 * @tc.require:
1409 */
1410 HWTEST_F(SoftbusServerStubTest, SoftbusServerStubTest037, 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 subscribeId = 0;
1416 int32_t mode = 0;
1417 int32_t medium = -1;
1418 MessageParcel datas;
1419 MessageParcel reply;
1420
1421 int32_t ret = softBusServer->RefreshLNNInner(datas, reply);
1422 EXPECT_EQ(SOFTBUS_IPC_ERR, ret);
1423
1424 datas.WriteCString(test);
1425 ret = softBusServer->RefreshLNNInner(datas, reply);
1426 EXPECT_EQ(SOFTBUS_IPC_ERR, ret);
1427
1428 datas.WriteCString(test);
1429 datas.WriteInt32(subscribeId);
1430 ret = softBusServer->RefreshLNNInner(datas, reply);
1431 EXPECT_EQ(SOFTBUS_IPC_ERR, ret);
1432
1433 datas.WriteCString(test);
1434 datas.WriteInt32(subscribeId);
1435 datas.WriteInt32(mode);
1436 ret = softBusServer->RefreshLNNInner(datas, reply);
1437 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
1438
1439 mode = 85;
1440 datas.WriteCString(test);
1441 datas.WriteInt32(subscribeId);
1442 datas.WriteInt32(mode);
1443 ret = softBusServer->RefreshLNNInner(datas, reply);
1444 EXPECT_EQ(SOFTBUS_IPC_ERR, ret);
1445
1446 datas.WriteCString(test);
1447 datas.WriteInt32(subscribeId);
1448 datas.WriteInt32(mode);
1449 datas.WriteInt32(medium);
1450 ret = softBusServer->RefreshLNNInner(datas, reply);
1451 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
1452
1453 datas.WriteCString(test);
1454 ret = softBusServer->StopRefreshLNNInner(datas, reply);
1455 EXPECT_EQ(SOFTBUS_IPC_ERR, ret);
1456 }
1457
1458 /**
1459 * @tc.name: SoftbusServerStubTest038
1460 * @tc.desc: Verify the Refresh and Stop Refresh LNNInner function part02.
1461 * @tc.type: FUNC
1462 * @tc.require:
1463 */
1464 HWTEST_F(SoftbusServerStubTest, SoftbusServerStubTest038, 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 = 85;
1471 int32_t medium = 0;
1472 int32_t freq = -1;
1473 bool flag = true;
1474 MessageParcel datas;
1475 MessageParcel reply;
1476
1477 datas.WriteCString(test);
1478 datas.WriteInt32(subscribeId);
1479 datas.WriteInt32(mode);
1480 datas.WriteInt32(medium);
1481 int32_t ret = softBusServer->RefreshLNNInner(datas, reply);
1482 EXPECT_EQ(SOFTBUS_IPC_ERR, ret);
1483
1484 datas.WriteCString(test);
1485 datas.WriteInt32(subscribeId);
1486 datas.WriteInt32(mode);
1487 datas.WriteInt32(medium);
1488 datas.WriteInt32(freq);
1489 ret = softBusServer->RefreshLNNInner(datas, reply);
1490 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
1491
1492 freq = 0;
1493 datas.WriteCString(test);
1494 datas.WriteInt32(subscribeId);
1495 datas.WriteInt32(mode);
1496 datas.WriteInt32(medium);
1497 datas.WriteInt32(freq);
1498 ret = softBusServer->RefreshLNNInner(datas, reply);
1499 EXPECT_EQ(SOFTBUS_IPC_ERR, ret);
1500
1501 datas.WriteCString(test);
1502 datas.WriteInt32(subscribeId);
1503 datas.WriteInt32(mode);
1504 datas.WriteInt32(medium);
1505 datas.WriteInt32(freq);
1506 datas.WriteBool(flag);
1507 ret = softBusServer->RefreshLNNInner(datas, reply);
1508 EXPECT_EQ(SOFTBUS_IPC_ERR, ret);
1509
1510 ret = softBusServer->StopRefreshLNNInner(datas, reply);
1511 EXPECT_EQ(SOFTBUS_IPC_ERR, ret);
1512 }
1513
1514 /**
1515 * @tc.name: SoftbusServerStubTest039
1516 * @tc.desc: Verify the Refresh and Stop Refresh LNNInner function part03.
1517 * @tc.type: FUNC
1518 * @tc.require:
1519 */
1520 HWTEST_F(SoftbusServerStubTest, SoftbusServerStubTest039, TestSize.Level1)
1521 {
1522 sptr<OHOS::SoftBusServerStub> softBusServer = new OHOS::SoftBusServer(SOFTBUS_SERVER_SA_ID, true);
1523 ASSERT_NE(nullptr, softBusServer);
1524 char test[10] = "test";
1525 int32_t subscribeId = 0;
1526 int32_t mode = 85;
1527 int32_t medium = 0;
1528 int32_t freq = 0;
1529 bool flag = true;
1530 uint32_t dataLen = 0;
1531 int32_t refreshId = 0;
1532 MessageParcel datas;
1533 MessageParcel reply;
1534 datas.WriteCString(test);
1535 datas.WriteInt32(subscribeId);
1536 datas.WriteInt32(mode);
1537 datas.WriteInt32(medium);
1538 datas.WriteInt32(freq);
1539 datas.WriteBool(flag);
1540 datas.WriteBool(flag);
1541 int32_t ret = softBusServer->RefreshLNNInner(datas, reply);
1542 EXPECT_EQ(SOFTBUS_IPC_ERR, ret);
1543 datas.WriteCString(test);
1544 datas.WriteInt32(subscribeId);
1545 datas.WriteInt32(mode);
1546 datas.WriteInt32(medium);
1547 datas.WriteInt32(freq);
1548 datas.WriteBool(flag);
1549 datas.WriteBool(flag);
1550 datas.WriteCString(test);
1551 ret = softBusServer->RefreshLNNInner(datas, reply);
1552 EXPECT_EQ(SOFTBUS_IPC_ERR, ret);
1553 datas.WriteCString(test);
1554 datas.WriteInt32(subscribeId);
1555 datas.WriteInt32(mode);
1556 datas.WriteInt32(medium);
1557 datas.WriteInt32(freq);
1558 datas.WriteBool(flag);
1559 datas.WriteBool(flag);
1560 datas.WriteCString(test);
1561 datas.WriteUint32(dataLen);
1562 ret = softBusServer->RefreshLNNInner(datas, reply);
1563 EXPECT_EQ(SOFTBUS_OK, ret);
1564 datas.WriteCString(test);
1565 datas.WriteInt32(refreshId);
1566 ret = softBusServer->StopRefreshLNNInner(datas, reply);
1567 EXPECT_EQ(SOFTBUS_OK, ret);
1568 }
1569
1570 /**
1571 * @tc.name: SoftbusServerStubTest040
1572 * @tc.desc: Verify the Active and DeActive MetaNode Inner function.
1573 * @tc.type: FUNC
1574 * @tc.require:
1575 */
1576 HWTEST_F(SoftbusServerStubTest, SoftbusServerStubTest040, TestSize.Level1)
1577 {
1578 sptr<OHOS::SoftBusServerStub> softBusServer = new OHOS::SoftBusServer(SOFTBUS_SERVER_SA_ID, true);
1579 ASSERT_NE(nullptr, softBusServer);
1580 NiceMock<SoftbusServerStubTestInterfaceMock> softbusServerStubMock;
1581 char test[10] = "test";
1582 MetaNodeConfigInfo info;
1583 MessageParcel datas;
1584 MessageParcel reply;
1585
1586 int32_t ret = softBusServer->ActiveMetaNodeInner(datas, reply);
1587 EXPECT_EQ(SOFTBUS_IPC_ERR, ret);
1588
1589 datas.WriteRawData(&info, sizeof(MetaNodeConfigInfo));
1590 EXPECT_CALL(softbusServerStubMock, LnnIpcActiveMetaNode).WillRepeatedly(
1591 Return(SOFTBUS_NETWORK_ACTIVE_META_NODE_ERR)
1592 );
1593 ret = softBusServer->ActiveMetaNodeInner(datas, reply);
1594 EXPECT_EQ(SOFTBUS_NETWORK_ACTIVE_META_NODE_ERR, ret);
1595
1596 datas.WriteRawData(&info, sizeof(MetaNodeConfigInfo));
1597 EXPECT_CALL(softbusServerStubMock, LnnIpcActiveMetaNode).WillRepeatedly(Return(SOFTBUS_OK));
1598 ret = softBusServer->ActiveMetaNodeInner(datas, reply);
1599 EXPECT_NE(SOFTBUS_IPC_ERR, ret);
1600
1601 ret = softBusServer->DeactiveMetaNodeInner(datas, reply);
1602 EXPECT_EQ(SOFTBUS_IPC_ERR, ret);
1603
1604 datas.WriteCString(test);
1605 EXPECT_CALL(softbusServerStubMock, LnnIpcDeactiveMetaNode).WillRepeatedly(
1606 Return(SOFTBUS_NETWORK_DEACTIVE_META_NODE_ERR)
1607 );
1608 ret = softBusServer->DeactiveMetaNodeInner(datas, reply);
1609 EXPECT_EQ(SOFTBUS_NETWORK_DEACTIVE_META_NODE_ERR, ret);
1610
1611 datas.WriteCString(test);
1612 EXPECT_CALL(softbusServerStubMock, LnnIpcDeactiveMetaNode).WillRepeatedly(Return(SOFTBUS_OK));
1613 ret = softBusServer->DeactiveMetaNodeInner(datas, reply);
1614 EXPECT_NE(SOFTBUS_IPC_ERR, ret);
1615 }
1616
1617 /**
1618 * @tc.name: SoftbusServerStubTest041
1619 * @tc.desc: Verify the GetAllMetaNodeInfoInner function.
1620 * @tc.type: FUNC
1621 * @tc.require:
1622 */
1623 HWTEST_F(SoftbusServerStubTest, SoftbusServerStubTest041, TestSize.Level1)
1624 {
1625 sptr<OHOS::SoftBusServerStub> softBusServer = new OHOS::SoftBusServer(SOFTBUS_SERVER_SA_ID, true);
1626 ASSERT_NE(nullptr, softBusServer);
1627 NiceMock<SoftbusServerStubTestInterfaceMock> softbusServerStubMock;
1628 int32_t infoNum = 4;
1629 MessageParcel datas;
1630 MessageParcel reply;
1631
1632 int32_t ret = softBusServer->GetAllMetaNodeInfoInner(datas, reply);
1633 EXPECT_EQ(SOFTBUS_IPC_ERR, ret);
1634
1635 datas.WriteInt32(infoNum);
1636 ret = softBusServer->GetAllMetaNodeInfoInner(datas, reply);
1637 EXPECT_EQ(SOFTBUS_IPC_ERR, ret);
1638
1639 infoNum = 2;
1640 datas.WriteInt32(infoNum);
1641 EXPECT_CALL(softbusServerStubMock, LnnIpcGetAllMetaNodeInfo).WillRepeatedly(
1642 Return(SOFTBUS_NETWORK_GET_META_NODE_INFO_ERR)
1643 );
1644 ret = softBusServer->GetAllMetaNodeInfoInner(datas, reply);
1645 EXPECT_EQ(SOFTBUS_NETWORK_GET_META_NODE_INFO_ERR, ret);
1646
1647 datas.WriteInt32(infoNum);
1648 EXPECT_CALL(softbusServerStubMock, LnnIpcGetAllMetaNodeInfo).WillRepeatedly(Return(SOFTBUS_OK));
1649 ret = softBusServer->GetAllMetaNodeInfoInner(datas, reply);
1650 EXPECT_NE(SOFTBUS_IPC_ERR, ret);
1651 }
1652
1653 /**
1654 * @tc.name: SoftbusServerStubTest042
1655 * @tc.desc: Verify the ShiftLNNGearInner function.
1656 * @tc.type: FUNC
1657 * @tc.require:
1658 */
1659 HWTEST_F(SoftbusServerStubTest, SoftbusServerStubTest042, TestSize.Level1)
1660 {
1661 sptr<OHOS::SoftBusServerStub> softBusServer = new OHOS::SoftBusServer(SOFTBUS_SERVER_SA_ID, true);
1662 ASSERT_NE(nullptr, softBusServer);
1663 GearMode gearMode;
1664 char test[10] = "test";
1665 bool flag = true;
1666 MessageParcel datas;
1667 MessageParcel reply;
1668
1669 int32_t ret = softBusServer->ShiftLNNGearInner(datas, reply);
1670 EXPECT_EQ(SOFTBUS_TRANS_PROXY_WRITECSTRING_FAILED, ret);
1671
1672 datas.WriteCString(test);
1673 ret = softBusServer->ShiftLNNGearInner(datas, reply);
1674 EXPECT_EQ(SOFTBUS_TRANS_PROXY_READCSTRING_FAILED, ret);
1675
1676 datas.WriteCString(test);
1677 datas.WriteCString(test);
1678 ret = softBusServer->ShiftLNNGearInner(datas, reply);
1679 EXPECT_EQ(SOFTBUS_TRANS_PROXY_READCSTRING_FAILED, ret);
1680
1681 datas.WriteCString(test);
1682 datas.WriteCString(test);
1683 datas.WriteBool(flag);
1684 ret = softBusServer->ShiftLNNGearInner(datas, reply);
1685 EXPECT_EQ(SOFTBUS_TRANS_PROXY_READRAWDATA_FAILED, ret);
1686
1687 datas.WriteCString(test);
1688 datas.WriteCString(test);
1689 datas.WriteBool(flag);
1690 datas.WriteRawData(&gearMode, sizeof(GearMode));
1691 ret = softBusServer->ShiftLNNGearInner(datas, reply);
1692 EXPECT_EQ(SOFTBUS_OK, ret);
1693 }
1694
1695 /**
1696 * @tc.name: SoftbusServerStubTest043
1697 * @tc.desc: Verify the GetSoftbusSpecObjectInner function.
1698 * @tc.type: FUNC
1699 * @tc.require:
1700 */
1701 HWTEST_F(SoftbusServerStubTest, SoftbusServerStubTest043, TestSize.Level1)
1702 {
1703 sptr<OHOS::SoftBusServerStub> softBusServer = new OHOS::SoftBusServer(SOFTBUS_SERVER_SA_ID, true);
1704 ASSERT_NE(nullptr, softBusServer);
1705 MessageParcel datas;
1706 MessageParcel reply;
1707
1708 int32_t ret = softBusServer->GetSoftbusSpecObjectInner(datas, reply);
1709 EXPECT_EQ(SOFTBUS_OK, ret);
1710 }
1711
1712 /**
1713 * @tc.name: SoftbusServerStubTest044
1714 * @tc.desc: Verify the GetBusCenterExObjInner function.
1715 * @tc.type: FUNC
1716 * @tc.require:
1717 */
1718 HWTEST_F(SoftbusServerStubTest, SoftbusServerStubTest044, TestSize.Level1)
1719 {
1720 sptr<OHOS::SoftBusServerStub> softBusServer = new OHOS::SoftBusServer(SOFTBUS_SERVER_SA_ID, true);
1721 ASSERT_NE(nullptr, softBusServer);
1722 MessageParcel datas;
1723 MessageParcel reply;
1724
1725 int32_t ret = softBusServer->GetBusCenterExObjInner(datas, reply);
1726 EXPECT_EQ(SOFTBUS_OK, ret);
1727 }
1728 }