1 /*
2 * Copyright (c) 2022 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include <cstring>
17 #include "securec.h"
18 #define private public
19 #include "dbinder_service.h"
20 #include "mock_dbinder_remote_listener.h"
21 #undef private
22 #include "dbinder_remote_listener.h"
23 #include "gtest/gtest.h"
24 #include "rpc_feature_set.h"
25 #include "rpc_log.h"
26 #include "log_tags.h"
27 #include "string_ex.h"
28
29 using namespace testing::ext;
30 using namespace OHOS;
31 using namespace OHOS::HiviewDFX;
32
33 namespace {
34 constexpr binder_uintptr_t TEST_BINDER_OBJECT_PTR = 1564618;
35 constexpr int TEST_STUB_INDEX = 1234;
36 constexpr int32_t TEST_SYSTEM_ABILITY_ID = 0x2;
37 constexpr int TEST_OBJECT_HANDLE = 16;
38 constexpr uint32_t TEST_SEQ_NUMBER = 123456;
39 constexpr int TEST_PID = 10;
40 constexpr int TEST_UID = 10;
41 }
42
43 class DBinderServiceUnitTest : public testing::Test {
44 public:
45 static void SetUpTestCase(void);
46 static void TearDownTestCase(void);
47 void SetUp();
48 void TearDown();
49 static constexpr HiLogLabel LABEL = { LOG_CORE, LOG_ID_TEST, "DBinderServiceUnitTest" };
50 };
51
SetUp()52 void DBinderServiceUnitTest::SetUp() {}
53
TearDown()54 void DBinderServiceUnitTest::TearDown() {}
55
SetUpTestCase()56 void DBinderServiceUnitTest::SetUpTestCase() {}
57
TearDownTestCase()58 void DBinderServiceUnitTest::TearDownTestCase() {}
59
60 class TestDeathRecipient : public IRemoteObject::DeathRecipient {
61 public:
TestDeathRecipient()62 TestDeathRecipient() {}
~TestDeathRecipient()63 virtual ~TestDeathRecipient() {}
OnRemoteDied(const wptr<IRemoteObject> & object)64 void OnRemoteDied(const wptr<IRemoteObject>& object) override {}
65 };
66
67 class TestRpcSystemAbilityCallback : public RpcSystemAbilityCallback {
68 public:
GetSystemAbilityFromRemote(int32_t systemAbilityId)69 sptr<IRemoteObject> GetSystemAbilityFromRemote(int32_t systemAbilityId) override
70 {
71 return nullptr;
72 }
73
LoadSystemAbilityFromRemote(const std::string & srcNetworkId,int32_t systemAbilityId)74 bool LoadSystemAbilityFromRemote(const std::string& srcNetworkId, int32_t systemAbilityId) override
75 {
76 return isLoad_;
77 }
IsDistributedSystemAbility(int32_t systemAbilityId)78 bool IsDistributedSystemAbility(int32_t systemAbilityId) override
79 {
80 return isSystemAbility_;
81 }
82 bool isSystemAbility_ = true;
83 bool isLoad_ = true;
84 };
85
86 /*
87 * @tc.name: ProcessOnSessionClosed001
88 * @tc.desc: Verify the ProcessOnSessionClosed function
89 * @tc.type: FUNC
90 */
91 HWTEST_F(DBinderServiceUnitTest, ProcessOnSessionClosed001, TestSize.Level1)
92 {
93 sptr<DBinderService> dBinderService = DBinderService::GetInstance();
94 EXPECT_TRUE(dBinderService != nullptr);
95 std::string networkId = "1234567890";
96 EXPECT_EQ(dBinderService->ProcessOnSessionClosed(networkId), true);
97 }
98
99 /*
100 * @tc.name: ProcessOnSessionClosed002
101 * @tc.desc: Verify the ProcessOnSessionClosed function
102 * @tc.type: FUNC
103 */
104 HWTEST_F(DBinderServiceUnitTest, ProcessOnSessionClosed002, TestSize.Level1)
105 {
106 sptr<DBinderService> dBinderService = DBinderService::GetInstance();
107 EXPECT_TRUE(dBinderService != nullptr);
108 std::string networkId = "";
109 EXPECT_EQ(dBinderService->ProcessOnSessionClosed(networkId), true);
110 }
111
112 /*
113 * @tc.name: ProcessOnSessionClosed003
114 * @tc.desc: Verify the ProcessOnSessionClosed function
115 * @tc.type: FUNC
116 */
117 HWTEST_F(DBinderServiceUnitTest, ProcessOnSessionClosed003, TestSize.Level1)
118 {
119 sptr<DBinderService> dBinderService = DBinderService::GetInstance();
120 EXPECT_NE(dBinderService, nullptr);
121
122 auto info = std::make_shared<ThreadLockInfo>();
123 info->networkId = "1";
124 dBinderService->threadLockInfo_.insert({1, info});
125
126 std::string networkId = "2";
127 bool ret = dBinderService->ProcessOnSessionClosed(networkId);
128 EXPECT_TRUE(ret);
129 }
130
131 /**
132 * @tc.name: StartDBinderService001
133 * @tc.desc: Verify the StartDBinderService function
134 * @tc.type: FUNC
135 */
136 HWTEST_F(DBinderServiceUnitTest, StartDBinderService001, TestSize.Level1)
137 {
138 sptr<DBinderService> dBinderService = DBinderService::GetInstance();
139 EXPECT_TRUE(dBinderService != nullptr);
140 std::shared_ptr<RpcSystemAbilityCallback> callbackImpl = nullptr;
141 bool res = dBinderService->StartDBinderService(callbackImpl);
142 EXPECT_EQ(res, false);
143 }
144
145 /**
146 * @tc.name: StartDBinderService002
147 * @tc.desc: Verify the StartDBinderService function
148 * @tc.type: FUNC
149 */
150 HWTEST_F(DBinderServiceUnitTest, StartDBinderService002, TestSize.Level1)
151 {
152 sptr<DBinderService> dBinderService = DBinderService::GetInstance();
153 EXPECT_TRUE(dBinderService != nullptr);
154 std::shared_ptr<RpcSystemAbilityCallback> callbackImpl = nullptr;
155 DBinderService::mainThreadCreated_ = true;
156 bool res = dBinderService->StartDBinderService(callbackImpl);
157 EXPECT_EQ(res, false);
158 }
159
160 /**
161 * @tc.name: StartDBinderService003
162 * @tc.desc: Verify the StartDBinderService function
163 * @tc.type: FUNC
164 */
165 HWTEST_F(DBinderServiceUnitTest, StartDBinderService003, TestSize.Level1)
166 {
167 sptr<DBinderService> dBinderService = DBinderService::GetInstance();
168 EXPECT_TRUE(dBinderService != nullptr);
169 std::shared_ptr<RpcSystemAbilityCallback> callbackImpl = nullptr;
170 DBinderService::mainThreadCreated_ = false;
171 dBinderService->remoteListener_ = nullptr;
172 bool res = dBinderService->StartDBinderService(callbackImpl);
173 EXPECT_EQ(res, false);
174 }
175
176 /**
177 * @tc.name: StartDBinderService004
178 * @tc.desc: Verify the StartDBinderService function
179 * @tc.type: FUNC
180 */
181 HWTEST_F(DBinderServiceUnitTest, StartDBinderService004, TestSize.Level1)
182 {
183 sptr<DBinderService> dBinderService = DBinderService::GetInstance();
184 EXPECT_TRUE(dBinderService != nullptr);
185 std::shared_ptr<RpcSystemAbilityCallback> callbackImpl = nullptr;
186 DBinderService::mainThreadCreated_ = false;
187 dBinderService->remoteListener_ = std::make_shared<DBinderRemoteListener>();
188 EXPECT_TRUE(dBinderService->remoteListener_ != nullptr);
189 bool res = dBinderService->StartDBinderService(callbackImpl);
190 EXPECT_EQ(res, true);
191 }
192
193 /**
194 * @tc.name: ReStartRemoteListener001
195 * @tc.desc: Verify the ReStartRemoteListener function
196 * @tc.type: FUNC
197 */
198 HWTEST_F(DBinderServiceUnitTest, ReStartRemoteListener001, TestSize.Level1)
199 {
200 sptr<DBinderService> dBinderService = DBinderService::GetInstance();
201 EXPECT_TRUE(dBinderService != nullptr);
202 dBinderService->remoteListener_ = nullptr;
203 bool res = dBinderService->ReStartRemoteListener();
204 EXPECT_EQ(res, false);
205 }
206
207 /**
208 * @tc.name: ReStartRemoteListener002
209 * @tc.desc: Verify the ReStartRemoteListener function
210 * @tc.type: FUNC
211 */
212 HWTEST_F(DBinderServiceUnitTest, ReStartRemoteListener002, TestSize.Level1)
213 {
214 sptr<DBinderService> dBinderService = DBinderService::GetInstance();
215 EXPECT_TRUE(dBinderService != nullptr);
216 dBinderService->remoteListener_ = std::make_shared<DBinderRemoteListener>();
217 EXPECT_TRUE(dBinderService->remoteListener_ != nullptr);
218 bool res = dBinderService->ReStartRemoteListener();
219 EXPECT_EQ(res, false);
220 }
221
222 /**
223 * @tc.name: StartRemoteListener001
224 * @tc.desc: Verify the StartRemoteListener function
225 * @tc.type: FUNC
226 */
227 HWTEST_F(DBinderServiceUnitTest, StartRemoteListener001, TestSize.Level1)
228 {
229 sptr<DBinderService> dBinderService = DBinderService::GetInstance();
230 EXPECT_TRUE(dBinderService != nullptr);
231 dBinderService->remoteListener_ = nullptr;
232 bool res = dBinderService->StartRemoteListener();
233 EXPECT_EQ(res, false);
234 }
235
236 /**
237 * @tc.name: StartRemoteListener002
238 * @tc.desc: Verify the StartRemoteListener function
239 * @tc.type: FUNC
240 */
241 HWTEST_F(DBinderServiceUnitTest, StartRemoteListener002, TestSize.Level1)
242 {
243 sptr<DBinderService> dBinderService = DBinderService::GetInstance();
244 EXPECT_TRUE(dBinderService != nullptr);
245 dBinderService->remoteListener_ = std::make_shared<DBinderRemoteListener>();
246 EXPECT_TRUE(dBinderService->remoteListener_ != nullptr);
247 bool res = dBinderService->StartRemoteListener();
248 EXPECT_EQ(res, true);
249 }
250
251 /**
252 * @tc.name: RegisterRemoteProxy001
253 * @tc.desc: Verify the RegisterRemoteProxy function
254 * @tc.type: FUNC
255 */
256 HWTEST_F(DBinderServiceUnitTest, RegisterRemoteProxy001, TestSize.Level1)
257 {
258 sptr<DBinderService> dBinderService = DBinderService::GetInstance();
259 EXPECT_TRUE(dBinderService != nullptr);
260 std::u16string serviceName = std::u16string();
261 sptr<IRemoteObject> binderObject = nullptr;
262 bool res = dBinderService->RegisterRemoteProxy(serviceName, binderObject);
263 EXPECT_EQ(res, false);
264 }
265
266 /**
267 * @tc.name: RegisterRemoteProxy002
268 * @tc.desc: Verify the RegisterRemoteProxy function
269 * @tc.type: FUNC
270 */
271 HWTEST_F(DBinderServiceUnitTest, RegisterRemoteProxy002, TestSize.Level1)
272 {
273 sptr<DBinderService> dBinderService = DBinderService::GetInstance();
274 EXPECT_TRUE(dBinderService != nullptr);
275 std::u16string serviceName = std::u16string();
276 int32_t systemAbilityId = 0;
277 EXPECT_EQ(dBinderService->RegisterRemoteProxy(serviceName, systemAbilityId), false);
278 }
279
280 /**
281 * @tc.name: QuerySessionObject001
282 * @tc.desc: Verify the QuerySessionObject function
283 * @tc.type: FUNC
284 */
285 HWTEST_F(DBinderServiceUnitTest, QuerySessionObject001, TestSize.Level1)
286 {
287 sptr<DBinderService> dBinderService = DBinderService::GetInstance();
288 EXPECT_TRUE(dBinderService != nullptr);
289 binder_uintptr_t stub = 0;
290 std::shared_ptr<struct SessionInfo> testSession = nullptr;
291 testSession = dBinderService->QuerySessionObject(stub);
292 EXPECT_EQ(testSession, nullptr);
293 }
294
295 /**
296 * @tc.name: QuerySessionObject002
297 * @tc.desc: Verify the QuerySessionObject function
298 * @tc.type: FUNC
299 */
300 HWTEST_F(DBinderServiceUnitTest, QuerySessionObject002, TestSize.Level1)
301 {
302 sptr<DBinderService> dBinderService = DBinderService::GetInstance();
303 EXPECT_TRUE(dBinderService != nullptr);
304 binder_uintptr_t stub = 0;
305 std::shared_ptr<struct SessionInfo> Session = nullptr;
306 EXPECT_EQ(dBinderService->AttachSessionObject(Session, stub), true);
307 std::shared_ptr<struct SessionInfo> testSession = dBinderService->QuerySessionObject(stub);
308 EXPECT_EQ(testSession, Session);
309 }
310
311 /**
312 * @tc.name: AttachDeathRecipient001
313 * @tc.desc: Verify the AttachDeathRecipient function
314 * @tc.type: FUNC
315 */
316 HWTEST_F(DBinderServiceUnitTest, AttachDeathRecipient001, TestSize.Level1)
317 {
318 sptr<DBinderService> dBinderService = DBinderService::GetInstance();
319 EXPECT_TRUE(dBinderService != nullptr);
320 sptr<IRemoteObject> object = nullptr;
321 sptr<IRemoteObject::DeathRecipient> deathRecipient = nullptr;
322 bool res = dBinderService->AttachDeathRecipient(object, deathRecipient);
323 EXPECT_TRUE(res);
324 }
325
326 /**
327 * @tc.name: AttachCallbackProxy001
328 * @tc.desc: Verify the AttachCallbackProxy function
329 * @tc.type: FUNC
330 */
331 HWTEST_F(DBinderServiceUnitTest, AttachCallbackProxy001, TestSize.Level1)
332 {
333 sptr<DBinderService> dBinderService = DBinderService::GetInstance();
334 EXPECT_TRUE(dBinderService != nullptr);
335 sptr<IRemoteObject> object = nullptr;
336 DBinderServiceStub *dbStub = nullptr;
337 bool res = dBinderService->AttachCallbackProxy(object, dbStub);
338 EXPECT_TRUE(res);
339 }
340
341 /**
342 * @tc.name: DetachProxyObject001
343 * @tc.desc: Verify the DetachProxyObject function
344 * @tc.type: FUNC
345 */
346 HWTEST_F(DBinderServiceUnitTest, DetachProxyObject001, TestSize.Level1)
347 {
348 sptr<DBinderService> dBinderService = DBinderService::GetInstance();
349 EXPECT_TRUE(dBinderService != nullptr);
350 binder_uintptr_t binderObject = 0;
351 bool res = dBinderService->DetachProxyObject(binderObject);
352 EXPECT_EQ(res, false);
353 }
354
355 /**
356 * @tc.name: ConvertToSecureDeviceIDTest001
357 * @tc.desc: Verify the ConvertToSecureDeviceID function
358 * @tc.type: FUNC
359 */
360 HWTEST_F(DBinderServiceUnitTest, ConvertToSecureDeviceIDTest001, TestSize.Level1)
361 {
362 sptr<DBinderService> dBinderService = DBinderService::GetInstance();
363 EXPECT_TRUE(dBinderService != nullptr);
364 std::string deviceID;
365 EXPECT_EQ(dBinderService->ConvertToSecureDeviceID(deviceID), "****");
366 }
367
368 /**
369 * @tc.name: ConvertToSecureDeviceIDTest002
370 * @tc.desc: Verify the ConvertToSecureDeviceID function
371 * @tc.type: FUNC
372 */
373 HWTEST_F(DBinderServiceUnitTest, ConvertToSecureDeviceIDTest002, TestSize.Level1)
374 {
375 sptr<DBinderService> dBinderService = DBinderService::GetInstance();
376 EXPECT_TRUE(dBinderService != nullptr);
377 std::string deviceID("123456");
378 EXPECT_EQ(dBinderService->ConvertToSecureDeviceID(deviceID),
379 deviceID.substr(0, ENCRYPT_LENGTH) + "****" + deviceID.substr(strlen(deviceID.c_str()) - ENCRYPT_LENGTH));
380 }
381
382 /**
383 * @tc.name: GetRemoteTransTypeTest003
384 * @tc.desc: Verify the GetRemoteTransType function
385 * @tc.type: FUNC
386 */
387 HWTEST_F(DBinderServiceUnitTest, GetRemoteTransTypeTest003, TestSize.Level1)
388 {
389 sptr<DBinderService> dBinderService = DBinderService::GetInstance();
390 EXPECT_TRUE(dBinderService != nullptr);
391 EXPECT_EQ(dBinderService->GetRemoteTransType(), IRemoteObject::DATABUS_TYPE);
392 }
393
394 /**
395 * @tc.name: StopRemoteListener001
396 * @tc.desc: Verify the StopRemoteListener function
397 * @tc.type: FUNC
398 */
399 HWTEST_F(DBinderServiceUnitTest, StopRemoteListener001, TestSize.Level1)
400 {
401 sptr<DBinderService> dBinderService = DBinderService::GetInstance();
402 EXPECT_TRUE(dBinderService != nullptr);
403 std::shared_ptr<DBinderRemoteListener> testListener = std::make_shared<DBinderRemoteListener>();
404 EXPECT_TRUE(testListener != nullptr);
405 EXPECT_EQ(dBinderService->StartRemoteListener(), true);
406 dBinderService->StopRemoteListener();
407 }
408
409 /**
410 * @tc.name: GetRemoteTransType001
411 * @tc.desc: Verify the GetRemoteTransType function
412 * @tc.type: FUNC
413 */
414 HWTEST_F(DBinderServiceUnitTest, GetRemoteListener001, TestSize.Level1)
415 {
416 sptr<DBinderService> dBinderService = DBinderService::GetInstance();
417 EXPECT_TRUE(dBinderService != nullptr);
418 std::shared_ptr<DBinderRemoteListener> testDbinder = nullptr;
419 testDbinder = dBinderService->GetRemoteListener();
420 EXPECT_EQ(testDbinder, nullptr);
421 }
422
423 /**
424 * @tc.name: GetRemoteListener002
425 * @tc.desc: Verify the GetRemoteListener function
426 * @tc.type: FUNC
427 */
428 HWTEST_F(DBinderServiceUnitTest, GetRemoteListener002, TestSize.Level1)
429 {
430 sptr<DBinderService> dBinderService = DBinderService::GetInstance();
431 EXPECT_TRUE(dBinderService != nullptr);
432 std::shared_ptr<DBinderRemoteListener> testListener = std::make_shared<DBinderRemoteListener>();
433 EXPECT_TRUE(testListener != nullptr);
434 EXPECT_EQ(dBinderService->StartRemoteListener(), false);
435 std::shared_ptr<DBinderRemoteListener> testDbinder = nullptr;
436 testDbinder = dBinderService->GetRemoteListener();
437 }
438
439 /**
440 * @tc.name: GetSeqNumber001
441 * @tc.desc: Verify the GetSeqNumber function
442 * @tc.type: FUNC
443 */
444 HWTEST_F(DBinderServiceUnitTest, GetSeqNumber001, TestSize.Level1)
445 {
446 sptr<DBinderService> dBinderService = DBinderService::GetInstance();
447 EXPECT_TRUE(dBinderService != nullptr);
448 dBinderService->seqNumber_ = 0;
449 uint32_t ret = dBinderService->GetSeqNumber();
450 EXPECT_EQ(ret, dBinderService->seqNumber_++);
451 }
452
453 /**
454 * @tc.name: GetSeqNumber002
455 * @tc.desc: Verify the GetSeqNumber function
456 * @tc.type: FUNC
457 */
458 HWTEST_F(DBinderServiceUnitTest, GetSeqNumber002, TestSize.Level1)
459 {
460 sptr<DBinderService> dBinderService = DBinderService::GetInstance();
461 EXPECT_TRUE(dBinderService != nullptr);
462 dBinderService->seqNumber_ = std::numeric_limits<uint32_t>::max();
463 uint32_t ret = dBinderService->GetSeqNumber();
464 EXPECT_EQ(ret, 1);
465 }
466
467 /**
468 * @tc.name: IsDeviceIdIllegal001
469 * @tc.desc: Verify the IsDeviceIdIllegal function
470 * @tc.type: FUNC
471 */
472 HWTEST_F(DBinderServiceUnitTest, IsDeviceIdIllegal001, TestSize.Level1)
473 {
474 sptr<DBinderService> dBinderService = DBinderService::GetInstance();
475 EXPECT_TRUE(dBinderService != nullptr);
476 std::string deviceID = "";
477 bool res = dBinderService->IsDeviceIdIllegal(deviceID);
478 EXPECT_EQ(res, true);
479 }
480
481 /**
482 * @tc.name: IsDeviceIdIllegal002
483 * @tc.desc: Verify the IsDeviceIdIllegal function
484 * @tc.type: FUNC
485 */
486 HWTEST_F(DBinderServiceUnitTest, IsDeviceIdIllegal002, TestSize.Level1)
487 {
488 sptr<DBinderService> dBinderService = DBinderService::GetInstance();
489 EXPECT_TRUE(dBinderService != nullptr);
490 std::string deviceID = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
491 bool res = dBinderService->IsDeviceIdIllegal(deviceID);
492 EXPECT_EQ(res, true);
493 }
494
495 /**
496 * @tc.name: IsDeviceIdIllegal003
497 * @tc.desc: Verify the IsDeviceIdIllegal function
498 * @tc.type: FUNC
499 */
500 HWTEST_F(DBinderServiceUnitTest, IsDeviceIdIllegal003, TestSize.Level1)
501 {
502 sptr<DBinderService> dBinderService = DBinderService::GetInstance();
503 EXPECT_TRUE(dBinderService != nullptr);
504 std::string deviceID = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
505 bool res = dBinderService->IsDeviceIdIllegal(deviceID);
506 EXPECT_EQ(res, false);
507 }
508
509 /**
510 * @tc.name: AddStubByTag001
511 * @tc.desc: Verify the AddStubByTag function
512 * @tc.type: FUNC
513 */
514 HWTEST_F(DBinderServiceUnitTest, AddStubByTag001, TestSize.Level1)
515 {
516 sptr<DBinderService> dBinderService = DBinderService::GetInstance();
517 EXPECT_TRUE(dBinderService != nullptr);
518
519 const std::string serviceName = "abc";
520 const std::string deviceID = "bcd";
521 binder_uintptr_t binderObject = TEST_BINDER_OBJECT_PTR;
522 sptr<DBinderServiceStub> stub = new DBinderServiceStub(serviceName, deviceID, binderObject);
523 EXPECT_TRUE(stub != nullptr);
524 binder_uintptr_t binderObjectPtr = reinterpret_cast<binder_uintptr_t>(stub.GetRefPtr());
525
526 binder_uintptr_t stubTag = dBinderService->stubTagNum_++;
527 auto result = dBinderService->mapDBinderStubRegisters_.insert({stubTag, binderObjectPtr});
528 EXPECT_TRUE(result.second);
529
530 binder_uintptr_t stubTag2 = dBinderService->AddStubByTag(binderObjectPtr);
531 EXPECT_EQ(stubTag2, stubTag);
532
533 dBinderService->stubTagNum_ = 1;
534 dBinderService->mapDBinderStubRegisters_.clear();
535 }
536
537 /**
538 * @tc.name: AddStubByTag002
539 * @tc.desc: Verify the AddStubByTag function
540 * @tc.type: FUNC
541 */
542 HWTEST_F(DBinderServiceUnitTest, AddStubByTag002, TestSize.Level1)
543 {
544 sptr<DBinderService> dBinderService = DBinderService::GetInstance();
545 EXPECT_TRUE(dBinderService != nullptr);
546
547 const std::string serviceName = "abc";
548 const std::string deviceID = "bcd";
549 binder_uintptr_t binderObject = TEST_BINDER_OBJECT_PTR;
550 sptr<DBinderServiceStub> stub = new DBinderServiceStub(serviceName, deviceID, binderObject);
551 EXPECT_TRUE(stub != nullptr);
552 binder_uintptr_t binderObjectPtr = reinterpret_cast<binder_uintptr_t>(stub.GetRefPtr());
553
554 binder_uintptr_t stubTag = dBinderService->AddStubByTag(binderObjectPtr);
555 EXPECT_GT(stubTag, 0);
556
557 dBinderService->stubTagNum_ = 1;
558 dBinderService->mapDBinderStubRegisters_.clear();
559 }
560
561 /**
562 * @tc.name: AddStubByTag003
563 * @tc.desc: Verify the AddStubByTag function
564 * @tc.type: FUNC
565 */
566 HWTEST_F(DBinderServiceUnitTest, AddStubByTag003, TestSize.Level1)
567 {
568 sptr<DBinderService> dBinderService = DBinderService::GetInstance();
569 EXPECT_TRUE(dBinderService != nullptr);
570
571 const std::string serviceName = "abc";
572 const std::string deviceID = "bcd";
573 binder_uintptr_t binderObject = TEST_BINDER_OBJECT_PTR;
574 sptr<DBinderServiceStub> stub = new DBinderServiceStub(serviceName, deviceID, binderObject);
575 EXPECT_NE(stub, nullptr);
576 binder_uintptr_t binderObjectPtr = reinterpret_cast<binder_uintptr_t>(stub.GetRefPtr());
577 binder_uintptr_t stubTag = dBinderService->AddStubByTag(binderObjectPtr);
578 EXPECT_GT(stubTag, 0);
579
580 sptr<DBinderServiceStub> stub2 = new DBinderServiceStub(serviceName, deviceID, binderObject);
581 EXPECT_NE(stub2, nullptr);
582 binder_uintptr_t binderObject2Ptr = reinterpret_cast<binder_uintptr_t>(stub2.GetRefPtr());
583 auto result = dBinderService->mapDBinderStubRegisters_.insert_or_assign(stubTag, binderObject2Ptr);
584 EXPECT_FALSE(result.second);
585
586 dBinderService->stubTagNum_--;
587 binder_uintptr_t stubTag2 = dBinderService->AddStubByTag(binderObjectPtr);
588 EXPECT_EQ(stubTag2, 0);
589
590 dBinderService->stubTagNum_ = 1;
591 dBinderService->mapDBinderStubRegisters_.clear();
592 }
593
594 /**
595 * @tc.name: QueryStubPtr001
596 * @tc.desc: Verify the QueryStubPtr function
597 * @tc.type: FUNC
598 */
599 HWTEST_F(DBinderServiceUnitTest, QueryStubPtr001, TestSize.Level1)
600 {
601 sptr<DBinderService> dBinderService = DBinderService::GetInstance();
602 EXPECT_TRUE(dBinderService != nullptr);
603
604 const std::string serviceName = "abc";
605 const std::string deviceID = "bcd";
606 binder_uintptr_t binderObject = TEST_BINDER_OBJECT_PTR;
607 sptr<DBinderServiceStub> stub = new DBinderServiceStub(serviceName, deviceID, binderObject);
608 EXPECT_NE(stub, nullptr);
609 binder_uintptr_t binderObjectPtr = reinterpret_cast<binder_uintptr_t>(stub.GetRefPtr());
610
611 binder_uintptr_t stubTag = dBinderService->AddStubByTag(binderObjectPtr);
612 EXPECT_GT(stubTag, 0);
613
614 binder_uintptr_t stubPtr = dBinderService->QueryStubPtr(stubTag);
615 EXPECT_EQ(stubPtr, binderObjectPtr);
616
617 dBinderService->stubTagNum_ = 1;
618 dBinderService->mapDBinderStubRegisters_.clear();
619 }
620
621 /**
622 * @tc.name: QueryStubPtr002
623 * @tc.desc: Verify the QueryStubPtr function
624 * @tc.type: FUNC
625 */
626 HWTEST_F(DBinderServiceUnitTest, QueryStubPtr002, TestSize.Level1)
627 {
628 sptr<DBinderService> dBinderService = DBinderService::GetInstance();
629 EXPECT_TRUE(dBinderService != nullptr);
630
631 binder_uintptr_t binderObject = 0;
632 binder_uintptr_t stubPtr = dBinderService->QueryStubPtr(binderObject);
633 EXPECT_EQ(stubPtr, 0);
634 }
635
636 /**
637 * @tc.name: CheckBinderObject001
638 * @tc.desc: Verify the CheckBinderObject function
639 * @tc.type: FUNC
640 */
641 HWTEST_F(DBinderServiceUnitTest, CheckBinderObject001, TestSize.Level1)
642 {
643 sptr<DBinderService> dBinderService = DBinderService::GetInstance();
644 EXPECT_TRUE(dBinderService != nullptr);
645 sptr<DBinderServiceStub> stub = nullptr;
646 binder_uintptr_t binderObject = TEST_BINDER_OBJECT_PTR;
647 bool res = dBinderService->CheckBinderObject(stub, binderObject);
648 EXPECT_EQ(res, false);
649 }
650
651 /**
652 * @tc.name: CheckBinderObject002
653 * @tc.desc: Verify the CheckBinderObject function
654 * @tc.type: FUNC
655 */
656 HWTEST_F(DBinderServiceUnitTest, CheckBinderObject002, TestSize.Level1)
657 {
658 sptr<DBinderService> dBinderService = DBinderService::GetInstance();
659 EXPECT_TRUE(dBinderService != nullptr);
660 const std::string serviceName = "abc";
661 const std::string deviceID = "bcd";
662 binder_uintptr_t binderObject = TEST_BINDER_OBJECT_PTR;
663 sptr<DBinderServiceStub> stub = new DBinderServiceStub(serviceName, deviceID, binderObject);
664 EXPECT_TRUE(stub != nullptr);
665 bool res = dBinderService->CheckBinderObject(stub, binderObject);
666 EXPECT_EQ(res, false);
667 }
668
669 /**
670 * @tc.name: CheckBinderObject003
671 * @tc.desc: Verify the CheckBinderObject function
672 * @tc.type: FUNC
673 */
674 HWTEST_F(DBinderServiceUnitTest, CheckBinderObject003, TestSize.Level1)
675 {
676 sptr<DBinderService> dBinderService = DBinderService::GetInstance();
677 EXPECT_TRUE(dBinderService != nullptr);
678 const std::string serviceName = "abc";
679 const std::string deviceID = "bcd";
680 binder_uintptr_t binderObject = TEST_BINDER_OBJECT_PTR;
681 sptr<DBinderServiceStub> stub = new DBinderServiceStub(serviceName, deviceID, binderObject);
682 EXPECT_TRUE(stub != nullptr);
683
684 binder_uintptr_t binderObjectPtr = reinterpret_cast<binder_uintptr_t>(stub.GetRefPtr());
685 bool ret = dBinderService->CheckBinderObject(stub, binderObjectPtr);
686 EXPECT_TRUE(ret);
687 }
688
689 /**
690 * @tc.name: HasDBinderStub001
691 * @tc.desc: Verify the HasDBinderStub function
692 * @tc.type: FUNC
693 */
694 HWTEST_F(DBinderServiceUnitTest, HasDBinderStub001, TestSize.Level1)
695 {
696 sptr<DBinderService> dBinderService = DBinderService::GetInstance();
697 EXPECT_TRUE(dBinderService != nullptr);
698 dBinderService->DBinderStubRegisted_.clear();
699
700 const std::string serviceName = "abc";
701 const std::string deviceID = "bcd";
702 binder_uintptr_t binderObject = TEST_BINDER_OBJECT_PTR;
703 sptr<DBinderServiceStub> stub = new DBinderServiceStub(serviceName, deviceID, binderObject);
704 EXPECT_TRUE(stub != nullptr);
705 dBinderService->DBinderStubRegisted_.push_back(stub);
706
707 binder_uintptr_t binderObjectPtr = reinterpret_cast<binder_uintptr_t>(stub.GetRefPtr());
708 bool ret = dBinderService->HasDBinderStub(binderObjectPtr);
709 EXPECT_TRUE(ret);
710
711 dBinderService->DBinderStubRegisted_.clear();
712 }
713
714 /**
715 * @tc.name: HasDBinderStub002
716 * @tc.desc: Verify the HasDBinderStub function
717 * @tc.type: FUNC
718 */
719 HWTEST_F(DBinderServiceUnitTest, HasDBinderStub002, TestSize.Level1)
720 {
721 sptr<DBinderService> dBinderService = DBinderService::GetInstance();
722 EXPECT_TRUE(dBinderService != nullptr);
723 dBinderService->DBinderStubRegisted_.clear();
724
725 const std::string serviceName = "abc";
726 const std::string deviceID = "bcd";
727 binder_uintptr_t binderObject = TEST_BINDER_OBJECT_PTR;
728 sptr<DBinderServiceStub> stub = new DBinderServiceStub(serviceName, deviceID, binderObject);
729 EXPECT_TRUE(stub != nullptr);
730
731 binderObject = reinterpret_cast<binder_uintptr_t>(stub.GetRefPtr());
732 stub->binderObject_ = binderObject;
733
734 dBinderService->DBinderStubRegisted_.push_back(stub);
735 bool ret = dBinderService->HasDBinderStub(binderObject);
736 EXPECT_TRUE(ret);
737
738 dBinderService->DBinderStubRegisted_.clear();
739 }
740
741 /**
742 * @tc.name: DeleteDBinderStub001
743 * @tc.desc: Verify the DeleteDBinderStub function
744 * @tc.type: FUNC
745 */
746 HWTEST_F(DBinderServiceUnitTest, DeleteDBinderStub001, TestSize.Level1)
747 {
748 sptr<DBinderService> dBinderService = DBinderService::GetInstance();
749 EXPECT_TRUE(dBinderService != nullptr);
750
751 dBinderService->DBinderStubRegisted_.clear();
752 dBinderService->mapDBinderStubRegisters_.clear();
753
754 const std::string serviceName = "abc";
755 const std::string deviceID = "bcd";
756 binder_uintptr_t binderObject = TEST_BINDER_OBJECT_PTR;
757 sptr<DBinderServiceStub> stub = new DBinderServiceStub(serviceName, deviceID, binderObject);
758 EXPECT_TRUE(stub != nullptr);
759 dBinderService->DBinderStubRegisted_.push_back(stub);
760
761 const std::string serviceName2 = "abcd";
762 const std::string deviceID2 = "bcde";
763 binder_uintptr_t binderObject2 = TEST_BINDER_OBJECT_PTR + 1;
764 sptr<DBinderServiceStub> stub2 = new DBinderServiceStub(serviceName2, deviceID2, binderObject2);
765 EXPECT_TRUE(stub2 != nullptr);
766
767 binder_uintptr_t binderPtr = reinterpret_cast<binder_uintptr_t>(stub.GetRefPtr());
768 dBinderService->mapDBinderStubRegisters_.insert({binderPtr, binderPtr});
769
770 binder_uintptr_t binderPtr2 = reinterpret_cast<binder_uintptr_t>(stub2.GetRefPtr());
771 dBinderService->mapDBinderStubRegisters_.insert({binderPtr2, binderPtr2});
772
773 const std::u16string serviceStr16 = Str8ToStr16(serviceName);
774 bool ret = dBinderService->DeleteDBinderStub(serviceStr16, deviceID);
775 ASSERT_TRUE(ret);
776 }
777
778 /**
779 * @tc.name: IsSameStubObject001
780 * @tc.desc: Verify the IsSameStubObject function
781 * @tc.type: FUNC
782 */
783 HWTEST_F(DBinderServiceUnitTest, IsSameStubObject001, TestSize.Level1)
784 {
785 sptr<DBinderService> dBinderService = DBinderService::GetInstance();
786 EXPECT_TRUE(dBinderService != nullptr);
787 sptr<DBinderServiceStub> stub = nullptr;
788 std::u16string service = std::u16string();
789 const std::string device = "";
790 bool res = dBinderService->IsSameStubObject(stub, service, device);
791 EXPECT_EQ(res, false);
792 }
793
794 /**
795 * @tc.name: MakeRemoteBinder001
796 * @tc.desc: Verify the MakeRemoteBinder function
797 * @tc.type: FUNC
798 */
799 HWTEST_F(DBinderServiceUnitTest, MakeRemoteBinder001, TestSize.Level1)
800 {
801 sptr<DBinderService> dBinderService = DBinderService::GetInstance();
802 EXPECT_TRUE(dBinderService != nullptr);
803 std::u16string serviceName = std::u16string();
804 std::string deviceID = "";
805 binder_uintptr_t binderObject = TEST_BINDER_OBJECT_PTR;
806 uint32_t pid = 0;
807 uint32_t uid = 0;
808 EXPECT_EQ(dBinderService->MakeRemoteBinder(serviceName, deviceID, binderObject, pid, uid), nullptr);
809 }
810
811 /**
812 * @tc.name: MakeRemoteBinder002
813 * @tc.desc: Verify the MakeRemoteBinder function
814 * @tc.type: FUNC
815 */
816 HWTEST_F(DBinderServiceUnitTest, MakeRemoteBinder002, TestSize.Level1)
817 {
818 sptr<DBinderService> dBinderService = DBinderService::GetInstance();
819 EXPECT_TRUE(dBinderService != nullptr);
820 std::u16string serviceName;
821 std::string deviceID("001");
822 binder_uintptr_t binderObject = TEST_BINDER_OBJECT_PTR;
823 uint32_t pid = 0;
824 uint32_t uid = 0;
825 EXPECT_EQ(dBinderService->MakeRemoteBinder(serviceName, deviceID, binderObject, pid, uid), nullptr);
826 }
827
828 /**
829 * @tc.name: MakeRemoteBinderTest003
830 * @tc.desc: Verify the MakeRemoteBinder function
831 * @tc.type: FUNC
832 */
833 HWTEST_F(DBinderServiceUnitTest, MakeRemoteBinderTest003, TestSize.Level1)
834 {
835 sptr<DBinderService> dBinderService = DBinderService::GetInstance();
836 EXPECT_TRUE(dBinderService != nullptr);
837 std::u16string serviceName;
838 std::string deviceID("001");
839 binder_uintptr_t binderObject = TEST_BINDER_OBJECT_PTR;
840 uint32_t pid = TEST_PID;
841 uint32_t uid = TEST_UID;
842 EXPECT_EQ(dBinderService->MakeRemoteBinder(serviceName, deviceID, binderObject, pid, uid), nullptr);
843 }
844
845 /**
846 * @tc.name: MakeRemoteBinderTest004
847 * @tc.desc: Verify the MakeRemoteBinder function
848 * @tc.type: FUNC
849 */
850 HWTEST_F(DBinderServiceUnitTest, MakeRemoteBinderTest004, TestSize.Level1)
851 {
852 sptr<DBinderService> dBinderService = DBinderService::GetInstance();
853 EXPECT_TRUE(dBinderService != nullptr);
854 std::u16string serviceName = u"abcd";
855 std::string deviceID("001");
856 binder_uintptr_t binderObject = TEST_BINDER_OBJECT_PTR;
857 uint32_t pid = TEST_PID;
858 uint32_t uid = TEST_UID;
859 sptr<DBinderServiceStub> ret = dBinderService->MakeRemoteBinder(serviceName, deviceID, binderObject, pid, uid);
860 EXPECT_EQ(ret, nullptr);
861 }
862
863 /**
864 * @tc.name: CheckDeviceIDsInvalid001
865 * @tc.desc: Verify the CheckDeviceIDsInvalid function
866 * @tc.type: FUNC
867 */
868 HWTEST_F(DBinderServiceUnitTest, CheckDeviceIDsInvalid001, TestSize.Level1)
869 {
870 sptr<DBinderService> dBinderService = DBinderService::GetInstance();
871 EXPECT_TRUE(dBinderService != nullptr);
872
873 std::string deviceID;
874 std::string localDevID;
875 bool ret = dBinderService->CheckDeviceIDsInvalid(deviceID, localDevID);
876 EXPECT_TRUE(ret);
877 }
878
879 /**
880 * @tc.name: CheckDeviceIDsInvalid002
881 * @tc.desc: Verify the CheckDeviceIDsInvalid function
882 * @tc.type: FUNC
883 */
884 HWTEST_F(DBinderServiceUnitTest, CheckDeviceIDsInvalid002, TestSize.Level1)
885 {
886 sptr<DBinderService> dBinderService = DBinderService::GetInstance();
887 EXPECT_TRUE(dBinderService != nullptr);
888
889 std::string deviceID(DEVICEID_LENGTH - 1, 'a');
890 std::string localDevID(DEVICEID_LENGTH - 1, 'a');
891 bool ret = dBinderService->CheckDeviceIDsInvalid(deviceID, localDevID);
892 EXPECT_FALSE(ret);
893 }
894
895 /**
896 * @tc.name: CopyDeviceIDsToMessage001
897 * @tc.desc: Verify the CopyDeviceIDsToMessage function
898 * @tc.type: FUNC
899 */
900 HWTEST_F(DBinderServiceUnitTest, CopyDeviceIDsToMessage001, TestSize.Level1)
901 {
902 sptr<DBinderService> dBinderService = DBinderService::GetInstance();
903 EXPECT_TRUE(dBinderService != nullptr);
904
905 auto message = std::make_shared<struct DHandleEntryTxRx>();
906
907 std::string localDevID(DEVICEID_LENGTH + 1, 'a');
908 std::string deviceID(DEVICEID_LENGTH + 1, 'a');
909 bool ret = dBinderService->CopyDeviceIDsToMessage(message, localDevID, deviceID);
910 EXPECT_FALSE(ret);
911 }
912
913 /**
914 * @tc.name: CopyDeviceIDsToMessage002
915 * @tc.desc: Verify the CopyDeviceIDsToMessage function
916 * @tc.type: FUNC
917 */
918 HWTEST_F(DBinderServiceUnitTest, CopyDeviceIDsToMessage002, TestSize.Level1)
919 {
920 sptr<DBinderService> dBinderService = DBinderService::GetInstance();
921 EXPECT_TRUE(dBinderService != nullptr);
922
923 auto message = std::make_shared<struct DHandleEntryTxRx>();
924
925 std::string localDevID(DEVICEID_LENGTH - 1, 'a');
926 std::string deviceID(DEVICEID_LENGTH - 1, 'a');
927 bool ret = dBinderService->CopyDeviceIDsToMessage(message, localDevID, deviceID);
928 EXPECT_TRUE(ret);
929 }
930
931 /**
932 * @tc.name: CreateMessage001
933 * @tc.desc: Verify the CreateMessage function
934 * @tc.type: FUNC
935 */
936 HWTEST_F(DBinderServiceUnitTest, CreateMessage001, TestSize.Level1)
937 {
938 sptr<DBinderService> dBinderService = DBinderService::GetInstance();
939 EXPECT_TRUE(dBinderService != nullptr);
940
941 std::string serviceName = "testServiceName";
942 std::string deviceID = "testDeviceID";
943 binder_uintptr_t binderObject = TEST_BINDER_OBJECT_PTR;
944 sptr<DBinderServiceStub> stub = new DBinderServiceStub(serviceName, deviceID, binderObject);
945 EXPECT_TRUE(stub != nullptr);
946
947 uint32_t seqNumber = 1;
948 uint32_t pid = 1;
949 uint32_t uid = 1;
950 auto message = dBinderService->CreateMessage(stub, seqNumber, pid, uid);
951 EXPECT_NE(message, nullptr);
952 }
953
954 /**
955 * @tc.name: SendEntryToRemote001
956 * @tc.desc: Verify the SendEntryToRemote function
957 * @tc.type: FUNC
958 */
959 HWTEST_F(DBinderServiceUnitTest, SendEntryToRemote001, TestSize.Level1)
960 {
961 std::string serviceName = "testServiceName";
962 std::string deviceID = "testDeviceID";
963 binder_uintptr_t binderObject = TEST_BINDER_OBJECT_PTR;
964 sptr<DBinderService> dBinderService = DBinderService::GetInstance();
965 EXPECT_TRUE(dBinderService != nullptr);
966 sptr<DBinderServiceStub> stub = new DBinderServiceStub(serviceName, deviceID, binderObject);
967 EXPECT_TRUE(stub != nullptr);
968 uint32_t seqNumber = 0;
969 uint32_t pid = 0;
970 uint32_t uid = 0;
971 bool res = dBinderService->SendEntryToRemote(stub, seqNumber, pid, uid);
972 EXPECT_EQ(res, false);
973 }
974
975 /**
976 * @tc.name: CheckSystemAbilityId001
977 * @tc.desc: Verify the CheckSystemAbilityId function
978 * @tc.type: FUNC
979 */
980 HWTEST_F(DBinderServiceUnitTest, CheckSystemAbilityId001, TestSize.Level1)
981 {
982 sptr<DBinderService> dBinderService = DBinderService::GetInstance();
983 EXPECT_TRUE(dBinderService != nullptr);
984 int32_t systemAbilityId = TEST_SYSTEM_ABILITY_ID;
985 bool res = dBinderService->CheckSystemAbilityId(systemAbilityId);
986 EXPECT_EQ(res, true);
987 }
988
989 /**
990 * @tc.name: AllocFreeSocketPort001
991 * @tc.desc: Verify the AllocFreeSocketPort function
992 * @tc.type: FUNC
993 */
994 HWTEST_F(DBinderServiceUnitTest, AllocFreeSocketPort001, TestSize.Level1)
995 {
996 sptr<DBinderService> dBinderService = DBinderService::GetInstance();
997 EXPECT_TRUE(dBinderService != nullptr);
998 uint16_t ret = dBinderService->AllocFreeSocketPort();
999 EXPECT_EQ(ret, 0);
1000 }
1001
1002 /**
1003 * @tc.name: IsSameLoadSaItem001
1004 * @tc.desc: Verify the IsSameLoadSaItem function
1005 * @tc.type: FUNC
1006 */
1007 HWTEST_F(DBinderServiceUnitTest, IsSameLoadSaItem001, TestSize.Level1)
1008 {
1009 sptr<DBinderService> dBinderService = DBinderService::GetInstance();
1010 EXPECT_TRUE(dBinderService != nullptr);
1011 std::string srcNetworkId = "aaaaaaaaaaaaaa";
1012 int32_t systemAbilityId = TEST_SYSTEM_ABILITY_ID;
1013 std::shared_ptr<DHandleEntryTxRx> loadSaItem = std::make_shared<DHandleEntryTxRx>();
1014 EXPECT_TRUE(loadSaItem != nullptr);
1015 loadSaItem->stubIndex = TEST_SYSTEM_ABILITY_ID;
1016 strcpy_s(loadSaItem->deviceIdInfo.fromDeviceId, DEVICEID_LENGTH, "aaaaaaaaaaaaaa");
1017 bool res = dBinderService->IsSameLoadSaItem(srcNetworkId, systemAbilityId, loadSaItem);
1018 EXPECT_EQ(res, true);
1019 }
1020
1021 /**
1022 * @tc.name: IsSameLoadSaItem002
1023 * @tc.desc: Verify the IsSameLoadSaItem function
1024 * @tc.type: FUNC
1025 */
1026 HWTEST_F(DBinderServiceUnitTest, IsSameLoadSaItem002, TestSize.Level1)
1027 {
1028 sptr<DBinderService> dBinderService = DBinderService::GetInstance();
1029 EXPECT_TRUE(dBinderService != nullptr);
1030 std::string srcNetworkId = "bbbbbbb";
1031 int32_t systemAbilityId = TEST_SYSTEM_ABILITY_ID;
1032 std::shared_ptr<DHandleEntryTxRx> loadSaItem = std::make_shared<DHandleEntryTxRx>();
1033 EXPECT_TRUE(loadSaItem != nullptr);
1034 loadSaItem->stubIndex = TEST_STUB_INDEX;
1035 strcpy_s(loadSaItem->deviceIdInfo.fromDeviceId, DEVICEID_LENGTH, "aaaaaaaaaaaaaa");
1036 bool res = dBinderService->IsSameLoadSaItem(srcNetworkId, systemAbilityId, loadSaItem);
1037 EXPECT_EQ(res, false);
1038 }
1039
1040 /**
1041 * @tc.name: IsSameLoadSaItem003
1042 * @tc.desc: Verify the IsSameLoadSaItem function
1043 * @tc.type: FUNC
1044 */
1045 HWTEST_F(DBinderServiceUnitTest, IsSameLoadSaItem003, TestSize.Level1)
1046 {
1047 sptr<DBinderService> dBinderService = DBinderService::GetInstance();
1048 EXPECT_TRUE(dBinderService != nullptr);
1049 std::string srcNetworkId = "aaaaaaaaaaaaaa";
1050 int32_t systemAbilityId = TEST_SYSTEM_ABILITY_ID;
1051 std::shared_ptr<DHandleEntryTxRx> loadSaItem = std::make_shared<DHandleEntryTxRx>();
1052 EXPECT_TRUE(loadSaItem != nullptr);
1053 loadSaItem->stubIndex = TEST_STUB_INDEX;
1054 strcpy_s(loadSaItem->deviceIdInfo.fromDeviceId, DEVICEID_LENGTH, "aaaaaaaaaaaaaa");
1055 bool res = dBinderService->IsSameLoadSaItem(srcNetworkId, systemAbilityId, loadSaItem);
1056 EXPECT_EQ(res, false);
1057 }
1058
1059 /**
1060 * @tc.name: OnRemoteInvokerMessage001
1061 * @tc.desc: Verify the OnRemoteInvokerMessage function
1062 * @tc.type: FUNC
1063 */
1064 HWTEST_F(DBinderServiceUnitTest, OnRemoteInvokerMessage001, TestSize.Level1)
1065 {
1066 sptr<DBinderService> dBinderService = DBinderService::GetInstance();
1067 EXPECT_TRUE(dBinderService != nullptr);
1068 std::shared_ptr<MockDBinderRemoteListener> mockListener = std::make_shared<MockDBinderRemoteListener>();
1069 dBinderService->remoteListener_ = std::static_pointer_cast<DBinderRemoteListener>(mockListener);
1070 EXPECT_TRUE(dBinderService->remoteListener_ != nullptr);
1071
1072 std::shared_ptr<struct DHandleEntryTxRx> message = std::make_shared<DHandleEntryTxRx>();
1073 EXPECT_TRUE(message != nullptr);
1074 (void)memset_s(message.get(), sizeof(DHandleEntryTxRx), 0, sizeof(DHandleEntryTxRx));
1075 message->stubIndex = DBinderService::FIRST_SYS_ABILITY_ID - 1;
1076 message->binderObject = DBinderService::FIRST_SYS_ABILITY_ID - 1;
1077 message->deviceIdInfo.fromDeviceId[0] = 't';
1078
1079 DBinderSoftbusClient::GetInstance().sendBytesFunc_ = MockDBinderRemoteListener::SendBytes;
1080 PeerSocketInfo info;
1081 info.networkId = message->deviceIdInfo.fromDeviceId;
1082 int32_t socket = 1001;
1083 DBinderRemoteListener::ServerOnBind(socket, info);
1084
1085 bool ret = dBinderService->OnRemoteInvokerMessage(message);
1086 EXPECT_FALSE(ret);
1087 EXPECT_EQ(MockDBinderRemoteListener::GetInstance().GetResult(), SAID_INVALID_ERR);
1088 dBinderService->remoteListener_ = nullptr;
1089 DBinderSoftbusClient::GetInstance().sendBytesFunc_ = nullptr;
1090 }
1091
1092 /**
1093 * @tc.name: OnRemoteInvokerMessage002
1094 * @tc.desc: Verify the OnRemoteInvokerMessage function
1095 * @tc.type: FUNC
1096 */
1097 HWTEST_F(DBinderServiceUnitTest, OnRemoteInvokerMessage002, TestSize.Level1)
1098 {
1099 sptr<DBinderService> dBinderService = DBinderService::GetInstance();
1100 EXPECT_TRUE(dBinderService != nullptr);
1101 std::shared_ptr<struct DHandleEntryTxRx> message = std::make_shared<DHandleEntryTxRx>();
1102 EXPECT_TRUE(message != nullptr);
1103 (void)memset_s(message.get(), sizeof(DHandleEntryTxRx), 0, sizeof(DHandleEntryTxRx));
1104 message->stubIndex = TEST_STUB_INDEX;
1105 dBinderService->dbinderCallback_ = std::make_shared<TestRpcSystemAbilityCallback>();
1106 EXPECT_TRUE(dBinderService->dbinderCallback_ != nullptr);
1107 bool res = dBinderService->OnRemoteInvokerMessage(message);
1108 EXPECT_EQ(res, true);
1109 }
1110
1111 /**
1112 * @tc.name: OnRemoteInvokerMessage003
1113 * @tc.desc: Verify the OnRemoteInvokerMessage function
1114 * @tc.type: FUNC
1115 */
1116 HWTEST_F(DBinderServiceUnitTest, OnRemoteInvokerMessage003, TestSize.Level1)
1117 {
1118 sptr<DBinderService> dBinderService = DBinderService::GetInstance();
1119 EXPECT_TRUE(dBinderService != nullptr);
1120 std::shared_ptr<MockDBinderRemoteListener> mockListener = std::make_shared<MockDBinderRemoteListener>();
1121 dBinderService->remoteListener_ = std::static_pointer_cast<DBinderRemoteListener>(mockListener);
1122 EXPECT_TRUE(dBinderService->remoteListener_ != nullptr);
1123
1124 std::shared_ptr<struct DHandleEntryTxRx> message = std::make_shared<DHandleEntryTxRx>();
1125 EXPECT_TRUE(message != nullptr);
1126 (void)memset_s(message.get(), sizeof(DHandleEntryTxRx), 0, sizeof(DHandleEntryTxRx));
1127 message->stubIndex = DBinderService::FIRST_SYS_ABILITY_ID;
1128 message->binderObject = DBinderService::FIRST_SYS_ABILITY_ID;
1129 message->deviceIdInfo.fromDeviceId[0] = 't';
1130
1131 std::shared_ptr<TestRpcSystemAbilityCallback> cb = std::make_shared<TestRpcSystemAbilityCallback>();
1132 cb->isSystemAbility_ = false;
1133 dBinderService->dbinderCallback_ = cb;
1134
1135 DBinderSoftbusClient::GetInstance().sendBytesFunc_ = MockDBinderRemoteListener::SendBytes;
1136 PeerSocketInfo info;
1137 info.networkId = message->deviceIdInfo.fromDeviceId;
1138 int32_t socket = 1001;
1139 DBinderRemoteListener::ServerOnBind(socket, info);
1140
1141 bool ret = dBinderService->OnRemoteInvokerMessage(message);
1142 EXPECT_FALSE(ret);
1143 EXPECT_EQ(MockDBinderRemoteListener::GetInstance().GetResult(), SA_NOT_DISTRUBUTED_ERR);
1144 dBinderService->remoteListener_ = nullptr;
1145 cb->isSystemAbility_ = true;
1146 DBinderSoftbusClient::GetInstance().sendBytesFunc_ = nullptr;
1147 }
1148
1149 /**
1150 * @tc.name: OnRemoteInvokerMessage004
1151 * @tc.desc: Verify the OnRemoteInvokerMessage function
1152 * @tc.type: FUNC
1153 */
1154 HWTEST_F(DBinderServiceUnitTest, OnRemoteInvokerMessage004, TestSize.Level1)
1155 {
1156 sptr<DBinderService> dBinderService = DBinderService::GetInstance();
1157 EXPECT_TRUE(dBinderService != nullptr);
1158 std::shared_ptr<MockDBinderRemoteListener> mockListener = std::make_shared<MockDBinderRemoteListener>();
1159 dBinderService->remoteListener_ = std::static_pointer_cast<DBinderRemoteListener>(mockListener);
1160 EXPECT_TRUE(dBinderService->remoteListener_ != nullptr);
1161
1162 std::shared_ptr<struct DHandleEntryTxRx> message = std::make_shared<DHandleEntryTxRx>();
1163 EXPECT_TRUE(message != nullptr);
1164 (void)memset_s(message.get(), sizeof(DHandleEntryTxRx), 0, sizeof(DHandleEntryTxRx));
1165 message->stubIndex = DBinderService::FIRST_SYS_ABILITY_ID;
1166 message->binderObject = DBinderService::FIRST_SYS_ABILITY_ID;
1167 message->deviceIdInfo.fromDeviceId[0] = 't';
1168
1169 std::shared_ptr<TestRpcSystemAbilityCallback> cb = std::make_shared<TestRpcSystemAbilityCallback>();
1170 cb->isLoad_ = false;
1171 dBinderService->dbinderCallback_ = cb;
1172
1173 DBinderSoftbusClient::GetInstance().sendBytesFunc_ = MockDBinderRemoteListener::SendBytes;
1174 PeerSocketInfo info;
1175 info.networkId = message->deviceIdInfo.fromDeviceId;
1176 int32_t socket = 1001;
1177 DBinderRemoteListener::ServerOnBind(socket, info);
1178
1179 bool ret = dBinderService->OnRemoteInvokerMessage(message);
1180 EXPECT_FALSE(ret);
1181 EXPECT_EQ(MockDBinderRemoteListener::GetInstance().GetResult(), SA_NOT_AVAILABLE);
1182 dBinderService->remoteListener_ = nullptr;
1183 cb->isLoad_ = true;
1184 DBinderSoftbusClient::GetInstance().sendBytesFunc_ = nullptr;
1185 }
1186
1187
1188 /**
1189 * @tc.name: GetDatabusNameByProxyTest001
1190 * @tc.desc: Verify the GetDatabusNameByProxy function
1191 * @tc.type: FUNC
1192 */
1193 HWTEST_F(DBinderServiceUnitTest, GetDatabusNameByProxyTest001, TestSize.Level1)
1194 {
1195 sptr<DBinderService> dBinderService = DBinderService::GetInstance();
1196 EXPECT_TRUE(dBinderService != nullptr);
1197 IPCObjectProxy* proxy = nullptr;
1198 std::string res = dBinderService->GetDatabusNameByProxy(proxy);
1199 EXPECT_EQ(res, "");
1200 IPCObjectProxy object(TEST_OBJECT_HANDLE);
1201 res = dBinderService->GetDatabusNameByProxy(&object);
1202 EXPECT_EQ(res, "");
1203 }
1204
1205 /**
1206 * @tc.name: InvokerRemoteDBinderTest001
1207 * @tc.desc: Verify the InvokerRemoteDBinder function
1208 * @tc.type: FUNC
1209 */
1210 HWTEST_F(DBinderServiceUnitTest, InvokerRemoteDBinderTest001, TestSize.Level1)
1211 {
1212 sptr<DBinderService> dBinderService = DBinderService::GetInstance();
1213 EXPECT_TRUE(dBinderService != nullptr);
1214 sptr<DBinderServiceStub> stub = nullptr;
1215 uint32_t seqNumber = TEST_SEQ_NUMBER;
1216 uint32_t pid = 0;
1217 uint32_t uid = 0;
1218 int32_t ret = dBinderService->InvokerRemoteDBinder(stub, seqNumber, pid, uid);
1219 EXPECT_EQ(ret, DBinderErrorCode::STUB_INVALID);
1220 std::string serviceName("testServer");
1221 std::string deviceID("123456");
1222 binder_uintptr_t binderObject = TEST_BINDER_OBJECT_PTR;
1223 stub = new DBinderServiceStub(serviceName, deviceID, binderObject);
1224 EXPECT_TRUE(stub != nullptr);
1225 ret = dBinderService->InvokerRemoteDBinder(stub, seqNumber, pid, uid);
1226 EXPECT_EQ(ret, DBinderErrorCode::SEND_MESSAGE_FAILED);
1227 }
1228
1229 /**
1230 * @tc.name: CreateDatabusNameTest001
1231 * @tc.desc: Verify the CreateDatabusName function
1232 * @tc.type: FUNC
1233 */
1234 HWTEST_F(DBinderServiceUnitTest, CreateDatabusNameTest001, TestSize.Level1)
1235 {
1236 sptr<DBinderService> dBinderService = DBinderService::GetInstance();
1237 EXPECT_TRUE(dBinderService != nullptr);
1238 int pid = 0;
1239 int uid = 0;
1240 std::string res = dBinderService->CreateDatabusName(pid, uid);
1241 EXPECT_EQ(res, "");
1242 pid = TEST_PID;
1243 uid = TEST_UID;
1244 res = dBinderService->CreateDatabusName(pid, uid);
1245 EXPECT_EQ(res, "");
1246 }
1247
1248 /**
1249 * @tc.name: FindServicesByDeviceIDTest001
1250 * @tc.desc: Verify the FindServicesByDeviceID function
1251 * @tc.type: FUNC
1252 */
1253 HWTEST_F(DBinderServiceUnitTest, FindServicesByDeviceIDTest001, TestSize.Level1)
1254 {
1255 sptr<DBinderService> dBinderService = DBinderService::GetInstance();
1256 EXPECT_TRUE(dBinderService != nullptr);
1257 std::string serviceName("testServer");
1258 std::string deviceID("123456");
1259 binder_uintptr_t binderObject = TEST_BINDER_OBJECT_PTR;
1260 sptr<DBinderServiceStub> dBinderServiceStub = new DBinderServiceStub(serviceName, deviceID, binderObject);
1261 EXPECT_TRUE(dBinderServiceStub != nullptr);
1262 dBinderService->DBinderStubRegisted_.push_back(dBinderServiceStub);
1263 std::list<std::u16string> serviceNames;
1264 serviceNames.push_back(Str8ToStr16(serviceName));
1265 EXPECT_EQ(dBinderService->FindServicesByDeviceID(deviceID), serviceNames);
1266 }
1267
1268 /**
1269 * @tc.name: NoticeDeviceDieTest001
1270 * @tc.desc: Verify the NoticeDeviceDie function
1271 * @tc.type: FUNC
1272 */
1273 HWTEST_F(DBinderServiceUnitTest, NoticeDeviceDieTest001, TestSize.Level1)
1274 {
1275 sptr<DBinderService> dBinderService = DBinderService::GetInstance();
1276 EXPECT_TRUE(dBinderService != nullptr);
1277 std::string deviceID;
1278 EXPECT_EQ(dBinderService->NoticeDeviceDie(deviceID), DBINDER_SERVICE_INVALID_DATA_ERR);
1279 }
1280
1281 /**
1282 * @tc.name: NoticeDeviceDieTest002
1283 * @tc.desc: Verify the NoticeDeviceDie function
1284 * @tc.type: FUNC
1285 */
1286 HWTEST_F(DBinderServiceUnitTest, NoticeDeviceDieTest002, TestSize.Level1)
1287 {
1288 sptr<DBinderService> dBinderService = DBinderService::GetInstance();
1289 EXPECT_TRUE(dBinderService != nullptr);
1290 std::string deviceID("123456");
1291 EXPECT_EQ(dBinderService->NoticeDeviceDie(deviceID), DBINDER_SERVICE_NOTICE_DIE_ERR);
1292 }
1293
1294 /**
1295 * @tc.name: NoticeDeviceDieTest003
1296 * @tc.desc: Verify the NoticeDeviceDie function
1297 * @tc.type: FUNC
1298 */
1299 HWTEST_F(DBinderServiceUnitTest, NoticeDeviceDieTest003, TestSize.Level1)
1300 {
1301 sptr<DBinderService> dBinderService = DBinderService::GetInstance();
1302 EXPECT_TRUE(dBinderService != nullptr);
1303 std::string deviceID("123456");
1304 dBinderService->remoteListener_ = std::make_shared<DBinderRemoteListener>();
1305 EXPECT_TRUE(dBinderService->remoteListener_ != nullptr);
1306 EXPECT_EQ(dBinderService->NoticeDeviceDie(deviceID), DBINDER_SERVICE_NOTICE_DIE_ERR);
1307 }
1308
1309 /**
1310 * @tc.name: NoticeServiceDieTest001
1311 * @tc.desc: Verify the NoticeServiceDie function
1312 * @tc.type: FUNC
1313 */
1314 HWTEST_F(DBinderServiceUnitTest, NoticeServiceDieTest001, TestSize.Level1)
1315 {
1316 sptr<DBinderService> dBinderService = DBinderService::GetInstance();
1317 EXPECT_TRUE(dBinderService != nullptr);
1318 dBinderService->StartRemoteListener();
1319 std::u16string serviceName;
1320 std::string deviceID("123456");
1321 EXPECT_EQ(dBinderService->NoticeServiceDie(serviceName, deviceID), DBINDER_SERVICE_INVALID_DATA_ERR);
1322 }
1323
1324 /**
1325 * @tc.name: NoticeServiceDieInnerTest001
1326 * @tc.desc: Verify the NoticeServiceDieInner function
1327 * @tc.type: FUNC
1328 */
1329 HWTEST_F(DBinderServiceUnitTest, NoticeServiceDieInnerTest001, TestSize.Level1)
1330 {
1331 sptr<DBinderService> dBinderService = DBinderService::GetInstance();
1332 EXPECT_TRUE(dBinderService != nullptr);
1333 dBinderService->StartRemoteListener();
1334 std::u16string serviceName;
1335 std::string deviceID("123456");
1336 EXPECT_EQ(dBinderService->NoticeServiceDieInner(serviceName, deviceID), DBINDER_SERVICE_INVALID_DATA_ERR);
1337 }
1338
1339 /**
1340 * @tc.name: NoticeServiceDieInnerTest002
1341 * @tc.desc: Verify the NoticeServiceDieInner function
1342 * @tc.type: FUNC
1343 */
1344 HWTEST_F(DBinderServiceUnitTest, NoticeServiceDieInnerTest002, TestSize.Level1)
1345 {
1346 sptr<DBinderService> dBinderService = DBinderService::GetInstance();
1347 EXPECT_TRUE(dBinderService != nullptr);
1348 dBinderService->StartRemoteListener();
1349 std::u16string serviceName(u"test");
1350 std::string deviceID("123456");
1351 EXPECT_EQ(dBinderService->NoticeServiceDieInner(serviceName, deviceID), ERR_NONE);
1352 }
1353
1354 /**
1355 * @tc.name: NoticeServiceDieInnerTest003
1356 * @tc.desc: Verify the NoticeServiceDieInner function
1357 * @tc.type: FUNC
1358 */
1359 HWTEST_F(DBinderServiceUnitTest, NoticeServiceDieInnerTest003, TestSize.Level1)
1360 {
1361 sptr<DBinderService> dBinderService = DBinderService::GetInstance();
1362 EXPECT_TRUE(dBinderService != nullptr);
1363 dBinderService->StartRemoteListener();
1364 std::u16string serviceName(u"testServer");
1365 std::string deviceID("123456");
1366 EXPECT_EQ(dBinderService->NoticeServiceDieInner(serviceName, deviceID), ERR_NONE);
1367 }
1368
1369 /**
1370 * @tc.name: ProcessCallbackProxyTest001
1371 * @tc.desc: Verify the ProcessCallbackProxy function
1372 * @tc.type: FUNC
1373 */
1374 HWTEST_F(DBinderServiceUnitTest, ProcessCallbackProxyTest001, TestSize.Level1)
1375 {
1376 sptr<DBinderService> dBinderService = DBinderService::GetInstance();
1377 EXPECT_TRUE(dBinderService != nullptr);
1378 sptr<IRemoteObject> object = new IPCObjectProxy(TEST_OBJECT_HANDLE);
1379 EXPECT_TRUE(object != nullptr);
1380 std::string serviceName("testServer");
1381 std::string deviceID("123456");
1382 binder_uintptr_t binderObject = TEST_BINDER_OBJECT_PTR;
1383 sptr<DBinderServiceStub> dBinderServiceStub = new DBinderServiceStub(serviceName, deviceID, binderObject);
1384 EXPECT_TRUE(dBinderServiceStub != nullptr);
1385 bool res = dBinderService->AttachCallbackProxy(object, dBinderServiceStub.GetRefPtr());
1386 dBinderService->ProcessCallbackProxy(dBinderServiceStub);
1387 EXPECT_TRUE(res);
1388 }
1389
1390 /**
1391 * @tc.name: NoticeCallbackProxyTest001
1392 * @tc.desc: Verify the NoticeCallbackProxy function
1393 * @tc.type: FUNC
1394 */
1395 HWTEST_F(DBinderServiceUnitTest, NoticeCallbackProxyTest001, TestSize.Level1)
1396 {
1397 sptr<DBinderService> dBinderService = DBinderService::GetInstance();
1398 EXPECT_TRUE(dBinderService != nullptr);
1399 sptr<IRemoteObject> object = new IPCObjectProxy(TEST_OBJECT_HANDLE);
1400 EXPECT_TRUE(object != nullptr);
1401 std::string serviceName("testServer");
1402 std::string deviceID("123456");
1403 binder_uintptr_t binderObject = TEST_BINDER_OBJECT_PTR;
1404 sptr<DBinderServiceStub> dBinderServiceStub = new DBinderServiceStub(serviceName, deviceID, binderObject);
1405 EXPECT_TRUE(dBinderServiceStub != nullptr);
1406 dBinderService->AttachCallbackProxy(object, dBinderServiceStub.GetRefPtr());
1407 EXPECT_EQ(dBinderService->NoticeCallbackProxy(dBinderServiceStub), false);
1408 }
1409
1410 /**
1411 * @tc.name: DetachCallbackProxyTest001
1412 * @tc.desc: Verify the DetachCallbackProxy function
1413 * @tc.type: FUNC
1414 */
1415 HWTEST_F(DBinderServiceUnitTest, DetachCallbackProxyTest001, TestSize.Level1)
1416 {
1417 sptr<DBinderService> dBinderService = DBinderService::GetInstance();
1418 EXPECT_TRUE(dBinderService != nullptr);
1419 sptr<IRemoteObject> object = new IPCObjectProxy(TEST_OBJECT_HANDLE);
1420 EXPECT_TRUE(object != nullptr);
1421 std::string serviceName("test1");
1422 std::string deviceID("12345");
1423 binder_uintptr_t binderObject = TEST_BINDER_OBJECT_PTR;
1424 sptr<DBinderServiceStub> dBinderServiceStub = new DBinderServiceStub(serviceName, deviceID, binderObject);
1425 EXPECT_TRUE(dBinderServiceStub != nullptr);
1426 dBinderService->AttachCallbackProxy(object, dBinderServiceStub.GetRefPtr());
1427 EXPECT_EQ(dBinderService->DetachCallbackProxy(object), true);
1428 }
1429
1430 /**
1431 * @tc.name: DetachCallbackProxyTest002
1432 * @tc.desc: Verify the DetachCallbackProxy function
1433 * @tc.type: FUNC
1434 */
1435 HWTEST_F(DBinderServiceUnitTest, DetachCallbackProxyTest002, TestSize.Level1)
1436 {
1437 sptr<DBinderService> dBinderService = DBinderService::GetInstance();
1438 EXPECT_TRUE(dBinderService != nullptr);
1439 sptr<IRemoteObject> object = new IPCObjectProxy(TEST_OBJECT_HANDLE);
1440 EXPECT_TRUE(object != nullptr);
1441 EXPECT_EQ(dBinderService->DetachCallbackProxy(object), false);
1442 }
1443
1444 /**
1445 * @tc.name: QueryDeathRecipientTest001
1446 * @tc.desc: Verify the QueryDeathRecipient function
1447 * @tc.type: FUNC
1448 */
1449 HWTEST_F(DBinderServiceUnitTest, QueryDeathRecipientTest001, TestSize.Level1)
1450 {
1451 sptr<DBinderService> dBinderService = DBinderService::GetInstance();
1452 EXPECT_TRUE(dBinderService != nullptr);
1453 sptr<IRemoteObject> object = new IPCObjectProxy(TEST_OBJECT_HANDLE);
1454 EXPECT_TRUE(object != nullptr);
1455 sptr<IRemoteObject::DeathRecipient> deathRecipient = new TestDeathRecipient();
1456 EXPECT_TRUE(deathRecipient != nullptr);
1457 dBinderService->AttachDeathRecipient(object, deathRecipient);
1458 EXPECT_EQ(dBinderService->QueryDeathRecipient(object), deathRecipient);
1459 }
1460
1461 /**
1462 * @tc.name: QueryDeathRecipientTest002
1463 * @tc.desc: Verify the QueryDeathRecipient function
1464 * @tc.type: FUNC
1465 */
1466 HWTEST_F(DBinderServiceUnitTest, QueryDeathRecipientTest002, TestSize.Level1)
1467 {
1468 sptr<DBinderService> dBinderService = DBinderService::GetInstance();
1469 EXPECT_TRUE(dBinderService != nullptr);
1470 EXPECT_EQ(dBinderService->QueryDeathRecipient(nullptr), nullptr);
1471 }
1472
1473 /**
1474 * @tc.name: AttachProxyObjectTest001
1475 * @tc.desc: Verify the AttachProxyObject function
1476 * @tc.type: FUNC
1477 */
1478 HWTEST_F(DBinderServiceUnitTest, AttachProxyObjectTest001, TestSize.Level1)
1479 {
1480 std::string name("Test");
1481 binder_uintptr_t binderObject = TEST_BINDER_OBJECT_PTR;
1482 binder_uintptr_t binderObject1 = TEST_BINDER_OBJECT_PTR + 1;
1483 sptr<IRemoteObject> object = new IPCObjectProxy(TEST_OBJECT_HANDLE);
1484 EXPECT_TRUE(object != nullptr);
1485 sptr<DBinderService> dBinderService = DBinderService::GetInstance();
1486 EXPECT_TRUE(dBinderService != nullptr);
1487 EXPECT_EQ(dBinderService->AttachProxyObject(object, binderObject), true);
1488 EXPECT_EQ(dBinderService->QueryProxyObject(binderObject), object);
1489 EXPECT_EQ(dBinderService->QueryProxyObject(binderObject1), nullptr);
1490 }
1491
1492 /**
1493 * @tc.name: AttachProxyObjectTest002
1494 * @tc.desc: Verify the AttachProxyObject function
1495 * @tc.type: FUNC
1496 */
1497 HWTEST_F(DBinderServiceUnitTest, AttachProxyObjectTest002, TestSize.Level1)
1498 {
1499 uint32_t seqNumber = TEST_SEQ_NUMBER;
1500 sptr<DBinderService> dBinderService = DBinderService::GetInstance();
1501 EXPECT_TRUE(dBinderService != nullptr);
1502 std::shared_ptr<OHOS::ThreadLockInfo> threadLockInfo = std::make_shared<OHOS::ThreadLockInfo>();
1503 EXPECT_TRUE(threadLockInfo != nullptr);
1504 dBinderService->AttachThreadLockInfo(seqNumber, "networkId", threadLockInfo);
1505 dBinderService->WakeupThreadByStub(seqNumber);
1506 EXPECT_TRUE(dBinderService->QueryThreadLockInfo(seqNumber) != nullptr);
1507 EXPECT_EQ(dBinderService->QueryThreadLockInfo(seqNumber), threadLockInfo);
1508 dBinderService->DetachThreadLockInfo(seqNumber);
1509 dBinderService->WakeupThreadByStub(seqNumber);
1510 EXPECT_TRUE(dBinderService->QueryThreadLockInfo(seqNumber) == nullptr);
1511 }
1512
1513 /**
1514 * @tc.name: MakeSessionByReplyMessageTest001
1515 * @tc.desc: Verify the MakeSessionByReplyMessage function
1516 * @tc.type: FUNC
1517 */
1518 HWTEST_F(DBinderServiceUnitTest, MakeSessionByReplyMessageTest001, TestSize.Level1)
1519 {
1520 sptr<DBinderService> dBinderService = DBinderService::GetInstance();
1521 EXPECT_TRUE(dBinderService != nullptr);
1522 std::shared_ptr<struct DHandleEntryTxRx> replyMessage = std::make_shared<DHandleEntryTxRx>();
1523 EXPECT_TRUE(replyMessage != nullptr);
1524 (void)memset_s(replyMessage.get(), sizeof(DHandleEntryTxRx), 0, sizeof(DHandleEntryTxRx));
1525 dBinderService->MakeSessionByReplyMessage(replyMessage);
1526 EXPECT_EQ(dBinderService->HasDBinderStub(replyMessage->binderObject), false);
1527
1528 std::string serviceName("testServer");
1529 std::string deviceID;
1530 binder_uintptr_t binderObject = TEST_BINDER_OBJECT_PTR;
1531 sptr<DBinderServiceStub> stub = new DBinderServiceStub(serviceName, deviceID, binderObject);
1532 EXPECT_TRUE(stub != nullptr);
1533 replyMessage->stub = reinterpret_cast<binder_uintptr_t>(stub.GetRefPtr());
1534 dBinderService->MakeSessionByReplyMessage(replyMessage);
1535 }
1536
1537 /**
1538 * @tc.name: RegisterRemoteProxyTest001
1539 * @tc.desc: Verify the RegisterRemoteProxy function
1540 * @tc.type: FUNC
1541 */
1542 HWTEST_F(DBinderServiceUnitTest, RegisterRemoteProxyTest001, TestSize.Level1)
1543 {
1544 sptr<DBinderService> dBinderService = DBinderService::GetInstance();
1545 EXPECT_TRUE(dBinderService != nullptr);
1546 std::u16string serviceName;
1547 int32_t systemAbilityId = 1;
1548 EXPECT_EQ(dBinderService->RegisterRemoteProxy(serviceName, systemAbilityId), false);
1549 serviceName = u"testServer";
1550 systemAbilityId = 0;
1551 EXPECT_EQ(dBinderService->RegisterRemoteProxy(serviceName, systemAbilityId), false);
1552 systemAbilityId = 1;
1553 EXPECT_EQ(dBinderService->RegisterRemoteProxy(serviceName, systemAbilityId), true);
1554 }
1555
1556 /**
1557 * @tc.name: RegisterRemoteProxyTest002
1558 * @tc.desc: Verify the RegisterRemoteProxy function
1559 * @tc.type: FUNC
1560 */
1561 HWTEST_F(DBinderServiceUnitTest, RegisterRemoteProxyTest002, TestSize.Level1)
1562 {
1563 sptr<DBinderService> dBinderService = DBinderService::GetInstance();
1564 EXPECT_TRUE(dBinderService != nullptr);
1565 std::u16string serviceName;
1566 sptr<IRemoteObject> binderObject = nullptr;
1567 EXPECT_EQ(dBinderService->RegisterRemoteProxy(serviceName, binderObject), false);
1568 serviceName = u"testServer";
1569 EXPECT_EQ(dBinderService->RegisterRemoteProxy(serviceName, binderObject), false);
1570 sptr<IRemoteObject> object = new IPCObjectProxy(TEST_OBJECT_HANDLE);
1571 EXPECT_TRUE(object != nullptr);
1572 EXPECT_EQ(dBinderService->RegisterRemoteProxy(serviceName, object), true);
1573 }
1574
1575 /**
1576 * @tc.name: GetRegisterServiceTest001
1577 * @tc.desc: Verify the GetRegisterService function
1578 * @tc.type: FUNC
1579 */
1580 HWTEST_F(DBinderServiceUnitTest, GetRegisterServiceTest001, TestSize.Level1)
1581 {
1582 sptr<DBinderService> dBinderService = DBinderService::GetInstance();
1583 EXPECT_TRUE(dBinderService != nullptr);
1584 binder_uintptr_t binderObject = 1;
1585 EXPECT_EQ(dBinderService->GetRegisterService(binderObject), std::u16string());
1586 std::u16string serviceName(u"testServer");
1587 dBinderService->RegisterRemoteProxyInner(serviceName, binderObject);
1588 EXPECT_EQ(dBinderService->GetRegisterService(binderObject), serviceName);
1589 }
1590
1591 /**
1592 * @tc.name: OnRemoteMessageTaskTest001
1593 * @tc.desc: Verify the OnRemoteMessageTask function
1594 * @tc.type: FUNC
1595 */
1596 HWTEST_F(DBinderServiceUnitTest, OnRemoteMessageTaskTest001, TestSize.Level1)
1597 {
1598 sptr<DBinderService> dBinderService = DBinderService::GetInstance();
1599 EXPECT_TRUE(dBinderService != nullptr);
1600 std::shared_ptr<struct DHandleEntryTxRx> handleEntryTxRx = nullptr;
1601 EXPECT_EQ(dBinderService->OnRemoteMessageTask(handleEntryTxRx), false);
1602 std::shared_ptr<DHandleEntryTxRx> message = std::make_shared<DHandleEntryTxRx>();
1603 EXPECT_TRUE(message != nullptr);
1604 message->head.len = 10;
1605 message->head.version = 1;
1606 message->transType = 0;
1607 message->fromPort = 1;
1608 message->toPort = 2;
1609 message->stubIndex = 1;
1610 message->seqNumber = 1;
1611 message->binderObject = TEST_BINDER_OBJECT_PTR;
1612 message->deviceIdInfo.tokenId = 1;
1613 message->deviceIdInfo.fromDeviceId[0] = 't';
1614 message->deviceIdInfo.toDeviceId[0] = 't';
1615 message->stub = 10;
1616 message->serviceNameLength = 10;
1617 message->serviceName[0] = 't';
1618 message->pid = TEST_PID;
1619 message->uid = TEST_UID;
1620 dBinderService->dbinderCallback_ = std::make_shared<TestRpcSystemAbilityCallback>();
1621 EXPECT_TRUE(dBinderService->dbinderCallback_ != nullptr);
1622 message->dBinderCode = DBinderCode::MESSAGE_AS_INVOKER;
1623 EXPECT_EQ(dBinderService->OnRemoteMessageTask(message), true);
1624 message->dBinderCode = DBinderCode::MESSAGE_AS_REPLY;
1625 EXPECT_EQ(dBinderService->OnRemoteMessageTask(message), true);
1626 message->dBinderCode = DBinderCode::MESSAGE_AS_OBITUARY;
1627 EXPECT_EQ(dBinderService->OnRemoteMessageTask(message), false);
1628 message->dBinderCode = DBinderCode::MESSAGE_AS_REMOTE_ERROR;
1629 EXPECT_EQ(dBinderService->OnRemoteMessageTask(message), true);
1630 }
1631
1632 /**
1633 * @tc.name: OnRemoteInvokerDataBusMessageTest001
1634 * @tc.desc: Verify the OnRemoteInvokerDataBusMessage function
1635 * @tc.type: FUNC
1636 */
1637 HWTEST_F(DBinderServiceUnitTest, OnRemoteInvokerDataBusMessageTest001, TestSize.Level1)
1638 {
1639 sptr<DBinderService> dBinderService = DBinderService::GetInstance();
1640 EXPECT_TRUE(dBinderService != nullptr);
1641 IPCObjectProxy* proxy = nullptr;
1642 std::string remoteDeviceId;
1643 int pid = 1;
1644 int uid = 1;
1645 uint32_t tokenId = 1;
1646 std::shared_ptr<struct DHandleEntryTxRx> replyMessage = std::make_shared<DHandleEntryTxRx>();
1647 EXPECT_TRUE(replyMessage != nullptr);
1648 (void)memset_s(replyMessage.get(), sizeof(DHandleEntryTxRx), 0, sizeof(DHandleEntryTxRx));
1649 EXPECT_EQ(dBinderService->OnRemoteInvokerDataBusMessage(
1650 proxy, replyMessage, remoteDeviceId, pid, uid, tokenId), DBinderErrorCode::DEVICEID_INVALID);
1651 }
1652
1653 /**
1654 * @tc.name: OnRemoteInvokerDataBusMessageTest002
1655 * @tc.desc: Verify the OnRemoteInvokerDataBusMessage function
1656 * @tc.type: FUNC
1657 */
1658 HWTEST_F(DBinderServiceUnitTest, OnRemoteInvokerDataBusMessageTest002, TestSize.Level1)
1659 {
1660 sptr<DBinderService> dBinderService = DBinderService::GetInstance();
1661 EXPECT_TRUE(dBinderService != nullptr);
1662 std::string remoteDeviceId("test");
1663 int pid = 1;
1664 int uid = 1;
1665 uint32_t tokenId = 1;
1666 IPCObjectProxy objectProxy(0);
1667 std::shared_ptr<struct DHandleEntryTxRx> replyMessage = std::make_shared<DHandleEntryTxRx>();
1668 EXPECT_TRUE(replyMessage != nullptr);
1669 (void)memset_s(replyMessage.get(), sizeof(DHandleEntryTxRx), 0, sizeof(DHandleEntryTxRx));
1670 EXPECT_EQ(dBinderService->OnRemoteInvokerDataBusMessage(
1671 &objectProxy, replyMessage, remoteDeviceId, pid, uid, tokenId), DBinderErrorCode::SESSION_NAME_NOT_FOUND);
1672 }
1673
1674 /*
1675 * @tc.name: ProcessOnSessionClosedTest002
1676 * @tc.desc: Verify the ProcessOnSessionClosed function
1677 * @tc.type: FUNC
1678 */
1679 HWTEST_F(DBinderServiceUnitTest, ProcessOnSessionClosedTest002, TestSize.Level1)
1680 {
1681 sptr<DBinderService> dBinderService = DBinderService::GetInstance();
1682 EXPECT_TRUE(dBinderService != nullptr);
1683 std::shared_ptr<OHOS::ThreadLockInfo> threadLockInfo = std::make_shared<OHOS::ThreadLockInfo>();
1684 EXPECT_TRUE(threadLockInfo != nullptr);
1685 uint32_t seqNumber = TEST_SEQ_NUMBER;
1686 std::string networkId = "networkId";
1687 dBinderService->AttachThreadLockInfo(seqNumber, networkId, threadLockInfo);
1688 EXPECT_EQ(dBinderService->ProcessOnSessionClosed(networkId), true);
1689 }
1690
1691 /**
1692 * @tc.name: FindDBinderStub001
1693 * @tc.desc: Verify the FindDBinderStub function
1694 * @tc.type: FUNC
1695 */
1696 HWTEST_F(DBinderServiceUnitTest, FindDBinderStub001, TestSize.Level1)
1697 {
1698 sptr<DBinderService> dBinderService = DBinderService::GetInstance();
1699 EXPECT_TRUE(dBinderService != nullptr);
1700 std::u16string service(u"test");
1701 std::string device = "aaa";
1702 binder_uintptr_t binderObject = TEST_BINDER_OBJECT_PTR;
1703 sptr<DBinderServiceStub> testDdBinderStub1 = dBinderService->FindOrNewDBinderStub(service, device, binderObject);
1704 EXPECT_TRUE(testDdBinderStub1 != nullptr);
1705 sptr<DBinderServiceStub> testDdBinderStub2 = dBinderService->FindOrNewDBinderStub(service, device, binderObject);
1706 EXPECT_TRUE(testDdBinderStub2 != nullptr);
1707 EXPECT_EQ(testDdBinderStub1.GetRefPtr(), testDdBinderStub2.GetRefPtr());
1708
1709 sptr<DBinderServiceStub> testDdBinderStub3 = dBinderService->FindDBinderStub(service, device);
1710 EXPECT_TRUE(testDdBinderStub3 != nullptr);
1711 EXPECT_EQ(testDdBinderStub1.GetRefPtr(), testDdBinderStub3.GetRefPtr());
1712
1713 std::u16string service1(u"test1");
1714 std::string device1 = "bbb";
1715 EXPECT_EQ(dBinderService->FindDBinderStub(service1, device1), nullptr);
1716
1717 EXPECT_EQ(dBinderService->DeleteDBinderStub(service1, device1), false);
1718 EXPECT_EQ(dBinderService->DeleteDBinderStub(service, device), true);
1719 }
1720
1721 /**
1722 * @tc.name: ReStartRemoteListenerTest001
1723 * @tc.desc: Verify the ReStartRemoteListener function
1724 * @tc.type: FUNC
1725 */
1726 HWTEST_F(DBinderServiceUnitTest, ReStartRemoteListenerTest001, TestSize.Level1)
1727 {
1728 sptr<DBinderService> dBinderService = DBinderService::GetInstance();
1729 EXPECT_TRUE(dBinderService != nullptr);
1730 dBinderService->remoteListener_ = nullptr;
1731 bool res = dBinderService->ReStartRemoteListener();
1732 EXPECT_EQ(res, false);
1733 }
1734
1735 /**
1736 * @tc.name: ReStartRemoteListenerTest002
1737 * @tc.desc: Verify the ReStartRemoteListener function
1738 * @tc.type: FUNC
1739 */
1740 HWTEST_F(DBinderServiceUnitTest, ReStartRemoteListenerTest002, TestSize.Level1)
1741 {
1742 sptr<DBinderService> dBinderService = DBinderService::GetInstance();
1743 EXPECT_TRUE(dBinderService != nullptr);
1744 dBinderService->remoteListener_ = std::make_shared<DBinderRemoteListener>();
1745 EXPECT_TRUE(dBinderService->remoteListener_ != nullptr);
1746 bool res = dBinderService->ReStartRemoteListener();
1747 EXPECT_EQ(res, false);
1748 }
1749
1750 /**
1751 * @tc.name: IsSameStubObjectTest002
1752 * @tc.desc: Verify the IsSameStubObject function
1753 * @tc.type: FUNC
1754 */
1755 HWTEST_F(DBinderServiceUnitTest, IsSameStubObjectTest002, TestSize.Level1)
1756 {
1757 sptr<DBinderService> dBinderService = DBinderService::GetInstance();
1758 EXPECT_TRUE(dBinderService != nullptr);
1759 std::string serviceName = "test";
1760 std::string deviceID = "001";
1761 binder_uintptr_t binderObject = 1;
1762 sptr<DBinderServiceStub> stub = new DBinderServiceStub(serviceName, deviceID, binderObject);
1763 EXPECT_TRUE(stub != nullptr);
1764 std::u16string service(u"test");
1765 bool res = dBinderService->IsSameStubObject(stub, service, deviceID);
1766 EXPECT_EQ(res, true);
1767 }
1768
1769 /**
1770 * @tc.name: SendEntryToRemoteTest002
1771 * @tc.desc: Verify the SendEntryToRemote function
1772 * @tc.type: FUNC
1773 */
1774 HWTEST_F(DBinderServiceUnitTest, SendEntryToRemoteTest002, TestSize.Level1)
1775 {
1776 std::string serviceName("testServer");
1777 std::string deviceID;
1778 binder_uintptr_t binderObject = TEST_BINDER_OBJECT_PTR;
1779 sptr<DBinderService> dBinderService = DBinderService::GetInstance();
1780 EXPECT_TRUE(dBinderService != nullptr);
1781 sptr<DBinderServiceStub> stub = new DBinderServiceStub(serviceName, deviceID, binderObject);
1782 EXPECT_TRUE(stub != nullptr);
1783 uint32_t seqNumber = 0;
1784 uint32_t pid = 0;
1785 uint32_t uid = 0;
1786 bool res = dBinderService->SendEntryToRemote(stub, seqNumber, pid, uid);
1787 EXPECT_EQ(res, false);
1788 }
1789
1790 /**
1791 * @tc.name: PopLoadSaItemTest001
1792 * @tc.desc: Verify the PopLoadSaItem function
1793 * @tc.type: FUNC
1794 */
1795 HWTEST_F(DBinderServiceUnitTest, PopLoadSaItemTest001, TestSize.Level1)
1796 {
1797 sptr<DBinderService> dBinderService = DBinderService::GetInstance();
1798 EXPECT_TRUE(dBinderService != nullptr);
1799 std::string srcNetworkId;
1800 int32_t systemAbilityId = 1;
1801 EXPECT_EQ(dBinderService->PopLoadSaItem(srcNetworkId, systemAbilityId), nullptr);
1802
1803 srcNetworkId = "t";
1804 std::shared_ptr<struct DHandleEntryTxRx> message = std::make_shared<DHandleEntryTxRx>();
1805 EXPECT_TRUE(message != nullptr);
1806 (void)memset_s(message.get(), sizeof(DHandleEntryTxRx), 0, sizeof(DHandleEntryTxRx));
1807 message->stubIndex = systemAbilityId;
1808 message->deviceIdInfo.fromDeviceId[0] = 't';
1809 dBinderService->dbinderCallback_ = std::make_shared<TestRpcSystemAbilityCallback>();
1810 EXPECT_TRUE(dBinderService->dbinderCallback_ != nullptr);
1811 dBinderService->OnRemoteInvokerMessage(message);
1812 std::shared_ptr<DHandleEntryTxRx> dHandleEntryTxRx = dBinderService->PopLoadSaItem(srcNetworkId, systemAbilityId);
1813 EXPECT_TRUE(dHandleEntryTxRx != nullptr);
1814 sptr<IRemoteObject> remoteObject = nullptr;
1815 dBinderService->LoadSystemAbilityComplete("test", 2, remoteObject);
1816
1817 /* verify running into the remoteObject is null branch */
1818 DBinderSoftbusClient::GetInstance().sendBytesFunc_ = MockDBinderRemoteListener::SendBytes;
1819 PeerSocketInfo info;
1820 info.networkId = message->deviceIdInfo.fromDeviceId;
1821 int32_t socket = 1001;
1822 DBinderRemoteListener::ServerOnBind(socket, info);
1823
1824 std::shared_ptr<MockDBinderRemoteListener> mockListener = std::make_shared<MockDBinderRemoteListener>();
1825 dBinderService->remoteListener_ = std::static_pointer_cast<DBinderRemoteListener>(mockListener);
1826 EXPECT_TRUE(dBinderService->remoteListener_ != nullptr);
1827 dBinderService->LoadSystemAbilityComplete(srcNetworkId, systemAbilityId, remoteObject);
1828 EXPECT_EQ(MockDBinderRemoteListener::GetInstance().GetResult(), SA_NOT_FOUND);
1829
1830 /* verify running into the add death recipient fail branch */
1831 dBinderService->loadSaReply_.push_back(message);
1832 sptr<MockIPCObjectProxy> remoteObject1 = sptr<MockIPCObjectProxy>::MakeSptr();
1833 EXPECT_TRUE(remoteObject1 != nullptr);
1834 EXPECT_CALL(*remoteObject1, AddDeathRecipient(testing::_)).WillRepeatedly(testing::Return(false));
1835 dBinderService->LoadSystemAbilityComplete(srcNetworkId, systemAbilityId, remoteObject1);
1836 EXPECT_EQ(MockDBinderRemoteListener::GetInstance().GetResult(), SA_NOT_FOUND);
1837 dBinderService->remoteListener_ = nullptr;
1838 DBinderSoftbusClient::GetInstance().sendBytesFunc_ = nullptr;
1839 }
1840
1841 /**
1842 * @tc.name: PopLoadSaItemTest002
1843 * @tc.desc: Verify the PopLoadSaItem function
1844 * @tc.type: FUNC
1845 */
1846 HWTEST_F(DBinderServiceUnitTest, PopLoadSaItemTest002, TestSize.Level1)
1847 {
1848 sptr<DBinderService> dBinderService = DBinderService::GetInstance();
1849 EXPECT_TRUE(dBinderService != nullptr);
1850
1851 std::string srcNetworkId = "t";
1852 int32_t systemAbilityId = 1;
1853 std::shared_ptr<struct DHandleEntryTxRx> message = std::make_shared<DHandleEntryTxRx>();
1854 EXPECT_TRUE(message != nullptr);
1855 (void)memset_s(message.get(), sizeof(DHandleEntryTxRx), 0, sizeof(DHandleEntryTxRx));
1856 message->stubIndex = systemAbilityId;
1857 message->deviceIdInfo.fromDeviceId[0] = 't';
1858 message->binderObject = 0;
1859 dBinderService->loadSaReply_.push_back(message);
1860
1861 sptr<IRemoteObject> remoteObject1 = new IPCObjectProxy(1);
1862 EXPECT_TRUE(remoteObject1 != nullptr);
1863 dBinderService->LoadSystemAbilityComplete(srcNetworkId, systemAbilityId, remoteObject1);
1864 }
1865
1866 /**
1867 * @tc.name: PopLoadSaItemTest003
1868 * @tc.desc: Verify the PopLoadSaItem function
1869 * @tc.type: FUNC
1870 */
1871 HWTEST_F(DBinderServiceUnitTest, PopLoadSaItemTest003, TestSize.Level1)
1872 {
1873 sptr<DBinderService> dBinderService = DBinderService::GetInstance();
1874 EXPECT_TRUE(dBinderService != nullptr);
1875
1876 std::string srcNetworkId = "t";
1877 int32_t systemAbilityId = 1;
1878 std::shared_ptr<struct DHandleEntryTxRx> message = std::make_shared<DHandleEntryTxRx>();
1879 EXPECT_TRUE(message != nullptr);
1880 (void)memset_s(message.get(), sizeof(DHandleEntryTxRx), 0, sizeof(DHandleEntryTxRx));
1881 message->stubIndex = systemAbilityId;
1882 message->deviceIdInfo.fromDeviceId[0] = 't';
1883 message->transType = IRemoteObject::DATABUS_TYPE + 1;
1884 dBinderService->loadSaReply_.push_back(message);
1885
1886 sptr<IRemoteObject> remoteObject1 = new IPCObjectProxy(1);
1887 EXPECT_TRUE(remoteObject1 != nullptr);
1888 binder_uintptr_t binderObjectPtr = reinterpret_cast<binder_uintptr_t>(remoteObject1.GetRefPtr());
1889 bool ret = dBinderService->AttachProxyObject(remoteObject1, binderObjectPtr);
1890 EXPECT_TRUE(ret);
1891
1892 DBinderSoftbusClient::GetInstance().sendBytesFunc_ = MockDBinderRemoteListener::SendBytes;
1893 PeerSocketInfo info;
1894 info.networkId = message->deviceIdInfo.fromDeviceId;
1895 int32_t socket = 1001;
1896 DBinderRemoteListener::ServerOnBind(socket, info);
1897
1898 message->binderObject = binderObjectPtr;
1899 /* verify running into the transType invalid branch */
1900 std::shared_ptr<MockDBinderRemoteListener> mockListener = std::make_shared<MockDBinderRemoteListener>();
1901 dBinderService->remoteListener_ = std::static_pointer_cast<DBinderRemoteListener>(mockListener);
1902 EXPECT_TRUE(dBinderService->remoteListener_ != nullptr);
1903 dBinderService->LoadSystemAbilityComplete(srcNetworkId, systemAbilityId, remoteObject1);
1904 EXPECT_EQ(MockDBinderRemoteListener::GetInstance().GetResult(), SA_INVOKE_FAILED);
1905 dBinderService->remoteListener_ = nullptr;
1906 DBinderSoftbusClient::GetInstance().sendBytesFunc_ = nullptr;
1907 }
1908
1909 /**
1910 * @tc.name: PopLoadSaItemTest004
1911 * @tc.desc: Verify the PopLoadSaItem function
1912 * @tc.type: FUNC
1913 */
1914 HWTEST_F(DBinderServiceUnitTest, PopLoadSaItemTest004, TestSize.Level1)
1915 {
1916 sptr<DBinderService> dBinderService = DBinderService::GetInstance();
1917 EXPECT_TRUE(dBinderService != nullptr);
1918
1919 std::string srcNetworkId = "t";
1920 int32_t systemAbilityId = 1;
1921 std::shared_ptr<struct DHandleEntryTxRx> message = std::make_shared<DHandleEntryTxRx>();
1922 EXPECT_TRUE(message != nullptr);
1923 (void)memset_s(message.get(), sizeof(DHandleEntryTxRx), 0, sizeof(DHandleEntryTxRx));
1924 message->stubIndex = systemAbilityId;
1925 message->deviceIdInfo.fromDeviceId[0] = 't';
1926 message->transType = IRemoteObject::DATABUS_TYPE;
1927 dBinderService->loadSaReply_.push_back(message);
1928
1929 /* verify running into the OnRemoteInvokerDataBusMessage fail branch */
1930 sptr<MockIPCObjectProxy> remoteObject1 = sptr<MockIPCObjectProxy>::MakeSptr();
1931 EXPECT_TRUE(remoteObject1 != nullptr);
1932 binder_uintptr_t binderObjectPtr = reinterpret_cast<binder_uintptr_t>(remoteObject1.GetRefPtr());
1933 bool ret = dBinderService->AttachProxyObject(remoteObject1, binderObjectPtr);
1934 EXPECT_TRUE(ret);
1935
1936 DBinderSoftbusClient::GetInstance().sendBytesFunc_ = MockDBinderRemoteListener::SendBytes;
1937 PeerSocketInfo info;
1938 info.networkId = message->deviceIdInfo.fromDeviceId;;
1939 int32_t socket = 1001;
1940 DBinderRemoteListener::ServerOnBind(socket, info);
1941
1942 message->binderObject = binderObjectPtr;
1943 std::shared_ptr<MockDBinderRemoteListener> mockListener = std::make_shared<MockDBinderRemoteListener>();
1944 dBinderService->remoteListener_ = std::static_pointer_cast<DBinderRemoteListener>(mockListener);
1945 EXPECT_TRUE(dBinderService->remoteListener_ != nullptr);
1946 EXPECT_CALL(*remoteObject1, IsObjectDead()).WillOnce(testing::Return(true)).WillRepeatedly(testing::Return(false));
1947 dBinderService->LoadSystemAbilityComplete(srcNetworkId, systemAbilityId, remoteObject1);
1948 EXPECT_EQ(MockDBinderRemoteListener::GetInstance().GetResult(), SESSION_NAME_NOT_FOUND);
1949 dBinderService->remoteListener_ = nullptr;
1950 DBinderSoftbusClient::GetInstance().sendBytesFunc_ = nullptr;
1951 ret = dBinderService->DetachProxyObject(binderObjectPtr);
1952 EXPECT_TRUE(ret);
1953 }
1954
1955 /**
1956 * @tc.name: SendReplyMessageToRemote001
1957 * @tc.desc: Verify the SendReplyMessageToRemote function
1958 * @tc.type: FUNC
1959 */
1960 HWTEST_F(DBinderServiceUnitTest, SendReplyMessageToRemote001, TestSize.Level1)
1961 {
1962 uint32_t dBinderCode = 4;
1963 uint32_t reason = 0;
1964 std::shared_ptr<DHandleEntryTxRx> replyMessage = std::make_shared<DHandleEntryTxRx>();
1965 EXPECT_TRUE(replyMessage != nullptr);
1966 sptr<DBinderService> dBinderService = DBinderService::GetInstance();
1967 EXPECT_TRUE(dBinderService != nullptr);
1968 dBinderService->remoteListener_ = std::make_shared<DBinderRemoteListener>();
1969 EXPECT_TRUE(dBinderService->remoteListener_ != nullptr);
1970 dBinderService->SendReplyMessageToRemote(dBinderCode, reason, replyMessage);
1971 dBinderCode = 1;
1972 dBinderService->SendReplyMessageToRemote(dBinderCode, reason, replyMessage);
1973 DBinderService *temp = DBinderService::GetInstance();
1974 EXPECT_TRUE(temp != nullptr);
1975 DBinderService::instance_ = temp;
1976 dBinderService = DBinderService::GetInstance();
1977 EXPECT_TRUE(dBinderService != nullptr);
1978 EXPECT_EQ(dBinderService, DBinderService::instance_);
1979 }
1980
1981 /**
1982 * @tc.name: CheckAndAmendSaId001
1983 * @tc.desc: Verify the CheckAndAmendSaId function
1984 * @tc.type: FUNC
1985 */
1986 HWTEST_F(DBinderServiceUnitTest, CheckAndAmendSaId001, TestSize.Level1)
1987 {
1988 sptr<DBinderService> dBinderService = DBinderService::GetInstance();
1989 EXPECT_NE(dBinderService, nullptr);
1990
1991 std::shared_ptr<struct DHandleEntryTxRx> message = std::make_shared<DHandleEntryTxRx>();
1992 EXPECT_TRUE(message != nullptr);
1993 (void)memset_s(message.get(), sizeof(DHandleEntryTxRx), 0, sizeof(DHandleEntryTxRx));
1994
1995 message->stubIndex = DBinderService::FIRST_SYS_ABILITY_ID - 1;
1996 message->binderObject = DBinderService::FIRST_SYS_ABILITY_ID;
1997 bool ret = dBinderService->CheckAndAmendSaId(message);
1998 EXPECT_TRUE(ret);
1999
2000 message->stubIndex = DBinderService::FIRST_SYS_ABILITY_ID - 1;
2001 message->binderObject = DBinderService::FIRST_SYS_ABILITY_ID - 1;
2002 ret = dBinderService->CheckAndAmendSaId(message);
2003 EXPECT_FALSE(ret);
2004 }
2005
2006 /**
2007 * @tc.name: AddAsynMessageTask001
2008 * @tc.desc: Verify the AddAsynMessageTask function
2009 * @tc.type: FUNC
2010 */
2011 HWTEST_F(DBinderServiceUnitTest, AddAsynMessageTask001, TestSize.Level1)
2012 {
2013 std::shared_ptr<struct DHandleEntryTxRx> message = std::make_shared<struct DHandleEntryTxRx>();
2014 EXPECT_NE(message.get(), nullptr);
2015 sptr<DBinderService> dBinderService = DBinderService::GetInstance();
2016 EXPECT_TRUE(dBinderService != nullptr);
2017 dBinderService->AddAsynMessageTask(message);
2018 }
2019
2020 /**
2021 * @tc.name: IsSameSession002
2022 * @tc.desc: Verify the IsSameSession function
2023 * @tc.type: FUNC
2024 */
2025 HWTEST_F(DBinderServiceUnitTest, IsSameSession002, TestSize.Level1)
2026 {
2027 std::shared_ptr<struct SessionInfo> oldSession= std::make_shared<struct SessionInfo>();
2028 EXPECT_NE(oldSession.get(), nullptr);
2029 std::shared_ptr<struct SessionInfo> newSession= std::make_shared<struct SessionInfo>();
2030 EXPECT_NE(newSession.get(), nullptr);
2031 oldSession->stubIndex = 1;
2032 oldSession->toPort = 2;
2033 oldSession->fromPort = 3;
2034 oldSession->type = 4;
2035 oldSession->serviceName[0] = 't';
2036 newSession->stubIndex = 2;
2037 newSession->toPort = 2;
2038 newSession->fromPort = 3;
2039 newSession->type = 4;
2040 newSession->serviceName[0] = 't';
2041 sptr<DBinderService> dBinderService = DBinderService::GetInstance();
2042 EXPECT_TRUE(dBinderService != nullptr);
2043 EXPECT_EQ(dBinderService->IsSameSession(oldSession, newSession), false);
2044 newSession->stubIndex = 1;
2045 newSession->toPort = 12;
2046 EXPECT_EQ(dBinderService->IsSameSession(oldSession, newSession), false);
2047 newSession->toPort = 2;
2048 newSession->fromPort = 13;
2049 EXPECT_EQ(dBinderService->IsSameSession(oldSession, newSession), false);
2050 newSession->fromPort = 3;
2051 newSession->type = 14;
2052 EXPECT_EQ(dBinderService->IsSameSession(oldSession, newSession), false);
2053 newSession->type = 4;
2054 EXPECT_EQ(dBinderService->IsSameSession(oldSession, newSession), true);
2055 }
2056
2057 /**
2058 * @tc.name: IsSameSession003
2059 * @tc.desc: Verify the IsSameSession function
2060 * @tc.type: FUNC
2061 */
2062 HWTEST_F(DBinderServiceUnitTest, IsSameSession003, TestSize.Level1)
2063 {
2064 std::shared_ptr<struct SessionInfo> oldSession= std::make_shared<struct SessionInfo>();
2065 EXPECT_NE(oldSession.get(), nullptr);
2066 std::shared_ptr<struct SessionInfo> newSession= std::make_shared<struct SessionInfo>();
2067 EXPECT_NE(newSession.get(), nullptr);
2068
2069 oldSession->stubIndex = 1;
2070 oldSession->toPort = 2;
2071 oldSession->fromPort = 3;
2072 oldSession->type = 4;
2073 oldSession->serviceName[0] = 't';
2074 oldSession->deviceIdInfo.fromDeviceId[0] = 'a';
2075
2076 newSession->stubIndex = oldSession->stubIndex;
2077 newSession->toPort = oldSession->toPort;
2078 newSession->fromPort = oldSession->fromPort;
2079 newSession->type = oldSession->type;
2080 newSession->serviceName[0] = 't';
2081 newSession->deviceIdInfo.fromDeviceId[0] = 'b';
2082
2083 sptr<DBinderService> dBinderService = DBinderService::GetInstance();
2084 EXPECT_TRUE(dBinderService != nullptr);
2085
2086 bool ret = dBinderService->IsSameSession(oldSession, newSession);
2087 EXPECT_FALSE(ret);
2088 }
2089
2090 /**
2091 * @tc.name: AttachSessionObject001
2092 * @tc.desc: Verify the AttachSessionObject function
2093 * @tc.type: FUNC
2094 */
2095 HWTEST_F(DBinderServiceUnitTest, AttachSessionObject001, TestSize.Level1)
2096 {
2097 std::shared_ptr<struct SessionInfo> object = nullptr;
2098 binder_uintptr_t stub = 0;
2099 sptr<DBinderService> dBinderService = DBinderService::GetInstance();
2100 EXPECT_TRUE(dBinderService != nullptr);
2101 dBinderService->sessionObject_.clear();
2102 EXPECT_EQ(dBinderService->AttachSessionObject(object, stub), true);
2103 }
2104
2105 /**
2106 * @tc.name: CheckInvokeListenThreadIllegal001
2107 * @tc.desc: Verify the CheckInvokeListenThreadIllegal function
2108 * @tc.type: FUNC
2109 */
2110 HWTEST_F(DBinderServiceUnitTest, CheckInvokeListenThreadIllegal001, TestSize.Level1)
2111 {
2112 sptr<DBinderService> dBinderService = DBinderService::GetInstance();
2113 EXPECT_NE(dBinderService, nullptr);
2114
2115 IPCObjectProxy object(TEST_OBJECT_HANDLE);
2116 MessageParcel data;
2117 MessageParcel reply;
2118 bool ret = dBinderService->CheckInvokeListenThreadIllegal(&object, data, reply);
2119 EXPECT_TRUE(ret);
2120 }
2121
2122 /**
2123 * @tc.name: CheckStubIndexAndSessionNameIllegal001
2124 * @tc.desc: Verify the CheckStubIndexAndSessionNameIllegal function
2125 * @tc.type: FUNC
2126 */
2127 HWTEST_F(DBinderServiceUnitTest, CheckStubIndexAndSessionNameIllegal001, TestSize.Level1)
2128 {
2129 sptr<DBinderService> dBinderService = DBinderService::GetInstance();
2130 EXPECT_NE(dBinderService, nullptr);
2131
2132 uint64_t stubIndex = 0;
2133 std::string serverSessionName;
2134 std::string deviceId;
2135 IPCObjectProxy proxy(TEST_OBJECT_HANDLE);
2136 bool ret = dBinderService->CheckStubIndexAndSessionNameIllegal(stubIndex, serverSessionName, deviceId, &proxy);
2137 EXPECT_TRUE(ret);
2138
2139 stubIndex = 1;
2140 serverSessionName = "abc";
2141 ret = dBinderService->CheckStubIndexAndSessionNameIllegal(stubIndex, serverSessionName, deviceId, &proxy);
2142 EXPECT_FALSE(ret);
2143 }
2144
2145 /**
2146 * @tc.name: SetReplyMessage001
2147 * @tc.desc: Verify the SetReplyMessage function
2148 * @tc.type: FUNC
2149 */
2150 HWTEST_F(DBinderServiceUnitTest, SetReplyMessage001, TestSize.Level1)
2151 {
2152 sptr<DBinderService> dBinderService = DBinderService::GetInstance();
2153 EXPECT_NE(dBinderService, nullptr);
2154
2155 auto replyMessage = std::make_shared<struct DHandleEntryTxRx>();
2156 (void)memset_s(replyMessage.get(), sizeof(DHandleEntryTxRx), 0, sizeof(DHandleEntryTxRx));
2157 replyMessage->head.version = RPC_TOKENID_SUPPORT_VERSION + 1;
2158
2159 uint64_t stubIndex = 0;
2160 std::string serverSessionName(SERVICENAME_LENGTH + 1, 'a');
2161 uint32_t selfTokenId = 0;
2162 IPCObjectProxy proxy(TEST_OBJECT_HANDLE);
2163 bool ret = dBinderService->SetReplyMessage(replyMessage, stubIndex, serverSessionName, selfTokenId, &proxy);
2164 EXPECT_FALSE(ret);
2165
2166 serverSessionName = string(SERVICENAME_LENGTH - 1, 'a');
2167 ret = dBinderService->SetReplyMessage(replyMessage, stubIndex, serverSessionName, selfTokenId, &proxy);
2168 EXPECT_TRUE(ret);
2169 }
2170
2171 /**
2172 * @tc.name: IsInvalidStub001
2173 * @tc.desc: Verify the IsInvalidStub function
2174 * @tc.type: FUNC
2175 */
2176 HWTEST_F(DBinderServiceUnitTest, IsInvalidStub001, TestSize.Level1)
2177 {
2178 sptr<DBinderService> dBinderService = DBinderService::GetInstance();
2179 EXPECT_NE(dBinderService, nullptr);
2180
2181 const std::string serviceName = "abc";
2182 const std::string deviceID = "bcd";
2183 binder_uintptr_t binderObject = TEST_BINDER_OBJECT_PTR;
2184 sptr<DBinderServiceStub> stub = new DBinderServiceStub(serviceName, deviceID, binderObject);
2185 EXPECT_NE(stub, nullptr);
2186
2187 binder_uintptr_t binderObjectPtr = reinterpret_cast<binder_uintptr_t>(stub.GetRefPtr());
2188 binder_uintptr_t stubTag = dBinderService->stubTagNum_++;
2189 auto result = dBinderService->mapDBinderStubRegisters_.insert({stubTag, binderObjectPtr});
2190 EXPECT_TRUE(result.second);
2191
2192 dBinderService->DBinderStubRegisted_.push_back(stub);
2193
2194 auto replyMessage = std::make_shared<struct DHandleEntryTxRx>();
2195 (void)memset_s(replyMessage.get(), sizeof(DHandleEntryTxRx), 0, sizeof(DHandleEntryTxRx));
2196 replyMessage->stub = stubTag;
2197
2198 bool ret = dBinderService->IsInvalidStub(replyMessage);
2199 EXPECT_FALSE(ret);
2200 }
2201
2202 /**
2203 * @tc.name: CopyDeviceIdInfo001
2204 * @tc.desc: Verify the CopyDeviceIdInfo function
2205 * @tc.type: FUNC
2206 */
2207 HWTEST_F(DBinderServiceUnitTest, CopyDeviceIdInfo001, TestSize.Level1)
2208 {
2209 sptr<DBinderService> dBinderService = DBinderService::GetInstance();
2210 EXPECT_NE(dBinderService, nullptr);
2211
2212 auto session = std::make_shared<SessionInfo>();
2213
2214 auto replyMessage = std::make_shared<struct DHandleEntryTxRx>();
2215 (void)memset_s(replyMessage.get(), sizeof(DHandleEntryTxRx), 0, sizeof(DHandleEntryTxRx));
2216
2217 dBinderService->InitializeSession(session, replyMessage);
2218 bool ret = dBinderService->CopyDeviceIdInfo(session, replyMessage);
2219 EXPECT_TRUE(ret);
2220 }
2221
2222 /**
2223 * @tc.name: MakeSessionByReplyMessage001
2224 * @tc.desc: Verify the MakeSessionByReplyMessage function
2225 * @tc.type: FUNC
2226 */
2227 HWTEST_F(DBinderServiceUnitTest, MakeSessionByReplyMessage001, TestSize.Level1)
2228 {
2229 sptr<DBinderService> dBinderService = DBinderService::GetInstance();
2230 EXPECT_NE(dBinderService, nullptr);
2231
2232 const std::string serviceName = "abc";
2233 const std::string deviceID = "bcd";
2234 binder_uintptr_t binderObject = TEST_BINDER_OBJECT_PTR;
2235 sptr<DBinderServiceStub> stub = new DBinderServiceStub(serviceName, deviceID, binderObject);
2236 EXPECT_NE(stub, nullptr);
2237 binder_uintptr_t binderObjectPtr = reinterpret_cast<binder_uintptr_t>(stub.GetRefPtr());
2238 binder_uintptr_t stubTag = dBinderService->AddStubByTag(binderObjectPtr);
2239 EXPECT_GT(stubTag, 0);
2240
2241 dBinderService->DBinderStubRegisted_.push_back(stub);
2242
2243 auto replyMessage = std::make_shared<struct DHandleEntryTxRx>();
2244 (void)memset_s(replyMessage.get(), sizeof(DHandleEntryTxRx), 0, sizeof(DHandleEntryTxRx));
2245
2246 replyMessage->dBinderCode = MESSAGE_AS_REPLY;
2247 replyMessage->stubIndex = 0;
2248 dBinderService->MakeSessionByReplyMessage(replyMessage);
2249
2250 replyMessage->stubIndex = 1;
2251 dBinderService->MakeSessionByReplyMessage(replyMessage);
2252
2253 replyMessage->stub = binderObjectPtr;
2254 dBinderService->MakeSessionByReplyMessage(replyMessage);
2255 }
2256
2257 /**
2258 * @tc.name: NoticeServiceDie001
2259 * @tc.desc: Verify the NoticeServiceDie function
2260 * @tc.type: FUNC
2261 */
2262 HWTEST_F(DBinderServiceUnitTest, NoticeServiceDie001, TestSize.Level1)
2263 {
2264 sptr<DBinderService> dBinderService = DBinderService::GetInstance();
2265 EXPECT_NE(dBinderService, nullptr);
2266
2267 std::u16string serviceName;
2268 std::string deviceID;
2269
2270 int32_t ret = dBinderService->NoticeServiceDie(serviceName, deviceID);
2271 EXPECT_EQ(ret, DBINDER_SERVICE_INVALID_DATA_ERR);
2272 }
2273