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