1 /*
2 * Copyright (c) 2022-2025 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 #include "ipc_types.h"
16 #include "iremote_object.h"
17 #include "log_tags.h"
18 #include "message_parcel.h"
19 #include "rpc_log.h"
20 #include "gtest/gtest.h"
21 #include "securec.h"
22 #include <iostream>
23
24 #define private public
25 #define protected public
26 #include "dbinder_service.h"
27 #include "dbinder_service_stub.h"
28 #include "sys_binder.h"
29 #undef protected
30 #undef private
31
32 using namespace testing::ext;
33 using namespace OHOS;
34 using namespace OHOS::HiviewDFX;
35
36 namespace {
37 constexpr binder_uintptr_t BINDER_OBJECT = 11;
38 constexpr uint32_t PROCESS_PROTO_CODE = 11;
39 constexpr uint32_t SESSION_TYPE_UNKNOWN = 99;
40 constexpr int32_t UNKNOWN_TRANSACTION_CODE = 999;
41 constexpr uint32_t TEST_PID = 111;
42 constexpr uint32_t TEST_UID = 222;
43 constexpr uint32_t TEST_SEQ_NUM = 333;
44 }
45
46 typedef unsigned long long binder_uintptr_t;
47 class DBinderServiceStubUnitTest : public testing::Test {
48 public:
49 static void SetUpTestCase(void);
50 static void TearDownTestCase(void);
51 void SetUp();
52 void TearDown();
53 };
54
SetUp()55 void DBinderServiceStubUnitTest::SetUp()
56 {}
57
TearDown()58 void DBinderServiceStubUnitTest::TearDown()
59 {}
60
SetUpTestCase()61 void DBinderServiceStubUnitTest::SetUpTestCase()
62 {}
63
TearDownTestCase()64 void DBinderServiceStubUnitTest::TearDownTestCase()
65 {}
66
67 /**
68 * @tc.name: DBinderServiceStub001
69 * @tc.desc: Verify the DBinderServiceStub function
70 * @tc.type: FUNC
71 */
72 HWTEST_F(DBinderServiceStubUnitTest, DBinderServiceStub001, TestSize.Level1)
73 {
74 const std::u16string service = u"serviceTest";
75 const std::string device = "deviceTest";
76 binder_uintptr_t object = BINDER_OBJECT;
77 DBinderServiceStub dBinderServiceStub(service, device, object);
78 int32_t num = dBinderServiceStub.GetObjectRefCount();
79 EXPECT_NE(num, 0);
80 }
81
82 /**
83 * @tc.name: DBinderServiceStub002
84 * @tc.desc: Verify the DBinderServiceStub function
85 * @tc.type: FUNC
86 */
87 HWTEST_F(DBinderServiceStubUnitTest, DBinderServiceStub002, TestSize.Level1)
88 {
89 const std::u16string service = u"";
90 const std::string device = "deviceTest";
91 binder_uintptr_t object = BINDER_OBJECT;
92 DBinderServiceStub dBinderServiceStub(service, device, object);
93 int32_t num = dBinderServiceStub.GetObjectRefCount();
94 EXPECT_NE(num, 0);
95 }
96
97 /**
98 * @tc.name: DBinderServiceStub003
99 * @tc.desc: Verify the DBinderServiceStub function
100 * @tc.type: FUNC
101 */
102 HWTEST_F(DBinderServiceStubUnitTest, DBinderServiceStub003, TestSize.Level1)
103 {
104 const std::u16string service = u"serviceTest";
105 const std::string device = "";
106 binder_uintptr_t object = BINDER_OBJECT;
107 DBinderServiceStub dBinderServiceStub(service, device, object);
108 int32_t num = dBinderServiceStub.GetObjectRefCount();
109 EXPECT_NE(num, 0);
110 }
111
112 /**
113 * @tc.name: DBinderServiceStub004
114 * @tc.desc: Verify the DBinderServiceStub function
115 * @tc.type: FUNC
116 */
117 HWTEST_F(DBinderServiceStubUnitTest, DBinderServiceStub004, TestSize.Level1)
118 {
119 const std::u16string service = u"serviceTest";
120 const std::string device = "deviceTest";
121 binder_uintptr_t object = UINT_MAX;
122 DBinderServiceStub dBinderServiceStub(service, device, object);
123 int32_t num = dBinderServiceStub.GetObjectRefCount();
124 EXPECT_NE(num, 0);
125 }
126
127
128 /**
129 * @tc.name: GetServiceName001
130 * @tc.desc: Verify the GetServiceName function
131 * @tc.type: FUNC
132 */
133 HWTEST_F(DBinderServiceStubUnitTest, GetServiceName001, TestSize.Level1)
134 {
135 const std::u16string service = u"serviceTest";
136 const std::string device = "deviceTest";
137 binder_uintptr_t object = BINDER_OBJECT;
138 DBinderServiceStub dBinderServiceStub(service, device, object);
139 std::u16string ret = dBinderServiceStub.GetServiceName();
140 EXPECT_EQ(ret, u"serviceTest");
141 }
142
143 /**
144 * @tc.name: GetServiceName002
145 * @tc.desc: Verify the GetServiceName function
146 * @tc.type: FUNC
147 */
148 HWTEST_F(DBinderServiceStubUnitTest, GetServiceName002, TestSize.Level1)
149 {
150 const std::u16string service;
151 const std::string device = "deviceTest";
152 binder_uintptr_t object = BINDER_OBJECT;
153 DBinderServiceStub dBinderServiceStub(service, device, object);
154 std::u16string ret = dBinderServiceStub.GetServiceName();
155 EXPECT_EQ(ret, u"");
156 }
157
158 /**
159 * @tc.name: GetDeviceID001
160 * @tc.desc: Verify the GetDeviceID function
161 * @tc.type: FUNC
162 */
163 HWTEST_F(DBinderServiceStubUnitTest, GetDeviceID001, TestSize.Level1)
164 {
165 const std::u16string service = u"serviceTest";
166 const std::string device = "deviceTest";
167 binder_uintptr_t object = BINDER_OBJECT;
168 DBinderServiceStub dBinderServiceStub(service, device, object);
169 std::string ret = dBinderServiceStub.GetDeviceID();
170 EXPECT_EQ(ret, "deviceTest");
171 }
172
173 /**
174 * @tc.name: GetDeviceID002
175 * @tc.desc: Verify the GetDeviceID function
176 * @tc.type: FUNC
177 */
178 HWTEST_F(DBinderServiceStubUnitTest, GetDeviceID002, TestSize.Level1)
179 {
180 const std::u16string service = u"serviceTest";
181 const std::string device;
182 binder_uintptr_t object = BINDER_OBJECT;
183 DBinderServiceStub dBinderServiceStub(service, device, object);
184 std::string ret = dBinderServiceStub.GetDeviceID();
185 EXPECT_EQ(ret, "");
186 }
187
188 /**
189 * @tc.name: GetBinderObject001
190 * @tc.desc: Verify the GetBinderObject function
191 * @tc.type: FUNC
192 */
193 HWTEST_F(DBinderServiceStubUnitTest, GetBinderObject001, TestSize.Level1)
194 {
195 const std::u16string service = u"serviceTest";
196 const std::string device = "deviceTest";
197 binder_uintptr_t object = BINDER_OBJECT;
198 DBinderServiceStub dBinderServiceStub(service, device, object);
199 binder_uintptr_t ret = dBinderServiceStub.GetBinderObject();
200 EXPECT_EQ(ret, BINDER_OBJECT);
201 }
202
203 /**
204 * @tc.name: GetBinderObject002
205 * @tc.desc: Verify the GetBinderObject function
206 * @tc.type: FUNC
207 */
208 HWTEST_F(DBinderServiceStubUnitTest, GetBinderObject002, TestSize.Level1)
209 {
210 const std::u16string service = u"serviceTest";
211 const std::string device = "deviceTest";
212 binder_uintptr_t object = UINT_MAX;
213 DBinderServiceStub dBinderServiceStub(service, device, object);
214 binder_uintptr_t ret = dBinderServiceStub.GetBinderObject();
215 EXPECT_EQ(ret, UINT_MAX);
216 }
217
218 /**
219 * @tc.name: ProcessProto001
220 * @tc.desc: Verify the ProcessProto function
221 * @tc.type: FUNC
222 */
223 HWTEST_F(DBinderServiceStubUnitTest, ProcessProto001, TestSize.Level1)
224 {
225 const std::u16string service = u"serviceTest";
226 const std::string device = "deviceTest";
227 binder_uintptr_t object = BINDER_OBJECT;
228 DBinderServiceStub dBinderServiceStub(service, device, object);
229 uint32_t code = PROCESS_PROTO_CODE;
230 MessageParcel data;
231 MessageParcel reply;
232 MessageOption option;
233 int32_t ret = dBinderServiceStub.ProcessProto(code, data, reply, option);
234 EXPECT_EQ(ret, DBINDER_SERVICE_PROCESS_PROTO_ERR);
235 }
236
237 /**
238 * @tc.name: ProcessProto002
239 * @tc.desc: Verify the ProcessProto function
240 * @tc.type: FUNC
241 */
242 HWTEST_F(DBinderServiceStubUnitTest, ProcessProto002, TestSize.Level1)
243 {
244 const std::u16string service = u"serviceTest";
245 const std::string device = "deviceTest";
246 binder_uintptr_t object = BINDER_OBJECT;
247 DBinderServiceStub dBinderServiceStub(service, device, object);
248 binder_uintptr_t key = reinterpret_cast<binder_uintptr_t>(&dBinderServiceStub);
249 sptr<DBinderService> dBinderService = DBinderService::GetInstance();
250 EXPECT_TRUE(dBinderService != nullptr);
251 std::shared_ptr<struct SessionInfo> sessionInfo = std::make_shared<struct SessionInfo>();
252 EXPECT_TRUE(sessionInfo != nullptr);
253 dBinderService->sessionObject_[key] = sessionInfo;
254 uint32_t code = PROCESS_PROTO_CODE;
255 MessageParcel data;
256 MessageParcel reply;
257 MessageOption option;
258 int32_t ret = dBinderServiceStub.ProcessProto(code, data, reply, option);
259 EXPECT_EQ(ret, DBINDER_SERVICE_PROCESS_PROTO_ERR);
260 }
261
262 /**
263 * @tc.name: ProcessProto003
264 * @tc.desc: Verify the ProcessProto function
265 * @tc.type: FUNC
266 */
267 HWTEST_F(DBinderServiceStubUnitTest, ProcessProto003, TestSize.Level1)
268 {
269 const std::u16string service = u"serviceTest";
270 const std::string device = "deviceTest";
271 binder_uintptr_t object = BINDER_OBJECT;
272 DBinderServiceStub dBinderServiceStub(service, device, object);
273 uint32_t code = PROCESS_PROTO_CODE;
274 MessageParcel data;
275 MessageParcel reply;
276 MessageOption option;
277 int32_t ret = dBinderServiceStub.ProcessProto(code, data, reply, option);
278 EXPECT_EQ(ret, DBINDER_SERVICE_PROCESS_PROTO_ERR);
279 }
280
281 /**
282 * @tc.name: ProcessProto004
283 * @tc.desc: Verify the ProcessProto function with unknown session type
284 * @tc.type: FUNC
285 */
286 HWTEST_F(DBinderServiceStubUnitTest, ProcessProto004, TestSize.Level1)
287 {
288 const std::u16string service = u"serviceTest";
289 const std::string device = "deviceTest";
290 binder_uintptr_t object = BINDER_OBJECT;
291 DBinderServiceStub dBinderServiceStub(service, device, object);
292
293 uint32_t code = PROCESS_PROTO_CODE;
294 MessageParcel data;
295 MessageParcel reply;
296 MessageOption option;
297
298 sptr<DBinderService> dBinderService = DBinderService::GetInstance();
299 EXPECT_TRUE(dBinderService != nullptr);
300 binder_uintptr_t key = reinterpret_cast<binder_uintptr_t>(&dBinderServiceStub);
301 std::shared_ptr<struct SessionInfo> sessionInfo = std::make_shared<struct SessionInfo>();
302 EXPECT_TRUE(sessionInfo != nullptr);
303 sessionInfo->type = SESSION_TYPE_UNKNOWN;
304 dBinderService->sessionObject_[key] = sessionInfo;
305
306 int32_t ret = dBinderServiceStub.ProcessProto(code, data, reply, option);
307 EXPECT_EQ(ret, DBINDER_SERVICE_PROCESS_PROTO_ERR);
308 }
309
310 /**
311 * @tc.name: ProcessProto005
312 * @tc.desc: Verify the ProcessProto function
313 * @tc.type: FUNC
314 */
315 HWTEST_F(DBinderServiceStubUnitTest, ProcessProto005, TestSize.Level1)
316 {
317 const std::u16string service = u"serviceTest";
318 const std::string device = "deviceTest";
319 binder_uintptr_t object = BINDER_OBJECT;
320 DBinderServiceStub dBinderServiceStub(service, device, object);
321 uint32_t code = UINT_MAX;
322 MessageParcel data;
323 MessageParcel reply;
324 MessageOption option;
325 int32_t ret = dBinderServiceStub.ProcessProto(code, data, reply, option);
326 EXPECT_EQ(ret, DBINDER_SERVICE_PROCESS_PROTO_ERR);
327 }
328
329 /**
330 * @tc.name: OnRemoteRequest001
331 * @tc.desc: Verify the OnRemoteRequest function
332 * @tc.type: FUNC
333 */
334 HWTEST_F(DBinderServiceStubUnitTest, OnRemoteRequest001, TestSize.Level1)
335 {
336 const std::u16string service = u"serviceTest";
337 const std::string device = "deviceTest";
338 binder_uintptr_t object = BINDER_OBJECT;
339 DBinderServiceStub dBinderServiceStub(service, device, object);
340
341 uint32_t code = GET_PROTO_INFO;
342 MessageParcel data;
343 MessageParcel reply;
344 MessageOption option;
345 int32_t ret = dBinderServiceStub.OnRemoteRequest(code, data, reply, option);
346 EXPECT_EQ(ret, DBINDER_SERVICE_PROCESS_PROTO_ERR);
347 }
348
349 /**
350 * @tc.name: OnRemoteRequest002
351 * @tc.desc: Verify the OnRemoteRequest function
352 * @tc.type: FUNC
353 */
354 HWTEST_F(DBinderServiceStubUnitTest, OnRemoteRequest002, TestSize.Level1)
355 {
356 const std::u16string service = u"serviceTest";
357 const std::string device = "deviceTest";
358 binder_uintptr_t object = BINDER_OBJECT;
359 DBinderServiceStub dBinderServiceStub(service, device, object);
360
361 uint32_t code = DBINDER_OBITUARY_TRANSACTION;
362 MessageParcel data;
363 MessageParcel reply;
364 MessageOption option;
365 int32_t ret = dBinderServiceStub.OnRemoteRequest(code, data, reply, option);
366 EXPECT_EQ(ret, DBINDER_SERVICE_INVALID_DATA_ERR);
367 }
368
369 /**
370 * @tc.name: OnRemoteRequest003
371 * @tc.desc: Verify the OnRemoteRequest function
372 * @tc.type: FUNC
373 */
374 HWTEST_F(DBinderServiceStubUnitTest, OnRemoteRequest003, TestSize.Level1)
375 {
376 const std::u16string service = u"serviceTest";
377 const std::string device = "deviceTest";
378 binder_uintptr_t object = BINDER_OBJECT;
379 DBinderServiceStub dBinderServiceStub(service, device, object);
380
381 uint32_t code = PROCESS_PROTO_CODE;
382 MessageParcel data;
383 MessageParcel reply;
384 MessageOption option;
385 int32_t ret = dBinderServiceStub.OnRemoteRequest(code, data, reply, option);
386 EXPECT_EQ(ret, DBINDER_SERVICE_UNKNOW_TRANS_ERR);
387 }
388
389 /**
390 * @tc.name: ProcessDeathRecipient001
391 * @tc.desc: Verify the ProcessDeathRecipient function
392 * @tc.type: FUNC
393 */
394 HWTEST_F(DBinderServiceStubUnitTest, ProcessDeathRecipient001, TestSize.Level1)
395 {
396 const std::u16string service = u"serviceTest";
397 const std::string device = "deviceTest";
398 binder_uintptr_t object = BINDER_OBJECT;
399 DBinderServiceStub dBinderServiceStub(service, device, object);
400
401 MessageParcel data;
402 data.WriteInt32(IRemoteObject::DeathRecipient::ADD_DEATH_RECIPIENT);
403 int32_t ret = dBinderServiceStub.ProcessDeathRecipient(data);
404 EXPECT_EQ(ret, DBINDER_SERVICE_INVALID_DATA_ERR);
405 }
406
407 /**
408 * @tc.name: ProcessDeathRecipient002
409 * @tc.desc: Verify the ProcessDeathRecipient function
410 * @tc.type: FUNC
411 */
412 HWTEST_F(DBinderServiceStubUnitTest, ProcessDeathRecipient002, TestSize.Level1)
413 {
414 const std::u16string service = u"serviceTest";
415 const std::string device = "deviceTest";
416 binder_uintptr_t object = BINDER_OBJECT;
417 DBinderServiceStub dBinderServiceStub(service, device, object);
418
419 MessageParcel data;
420 data.WriteInt32(IRemoteObject::DeathRecipient::REMOVE_DEATH_RECIPIENT);
421 int32_t ret = dBinderServiceStub.ProcessDeathRecipient(data);
422 EXPECT_EQ(ret, DBINDER_SERVICE_REMOVE_DEATH_ERR);
423 }
424
425 /**
426 * @tc.name: ProcessDeathRecipient003
427 * @tc.desc: Verify the ProcessDeathRecipient function with unknown type
428 * @tc.type: FUNC
429 */
430 HWTEST_F(DBinderServiceStubUnitTest, ProcessDeathRecipient003, TestSize.Level1)
431 {
432 const std::u16string service = u"serviceTest";
433 const std::string device = "deviceTest";
434 binder_uintptr_t object = BINDER_OBJECT;
435 DBinderServiceStub dBinderServiceStub(service, device, object);
436
437 MessageParcel data;
438 data.WriteInt32(UNKNOWN_TRANSACTION_CODE);
439
440 int32_t ret = dBinderServiceStub.ProcessDeathRecipient(data);
441 EXPECT_EQ(ret, DBINDER_SERVICE_UNKNOW_TRANS_ERR);
442 }
443
444 /**
445 * @tc.name: ProcessDeathRecipient004
446 * @tc.desc: Verify the ProcessDeathRecipient function with unknown type
447 * @tc.type: FUNC
448 */
449 HWTEST_F(DBinderServiceStubUnitTest, ProcessDeathRecipient004, TestSize.Level1)
450 {
451 const std::u16string service = u"serviceTest";
452 const std::string device = "deviceTest";
453 binder_uintptr_t object = BINDER_OBJECT;
454 DBinderServiceStub dBinderServiceStub(service, device, object);
455
456 MessageParcel data;
457 data.WriteString("");
458
459 int32_t ret = dBinderServiceStub.ProcessDeathRecipient(data);
460 EXPECT_EQ(ret, DBINDER_SERVICE_INVALID_DATA_ERR);
461 }
462
463 /**
464 * @tc.name: AddDbinderDeathRecipient001
465 * @tc.desc: Verify the AddDbinderDeathRecipient function
466 * @tc.type: FUNC
467 */
468 HWTEST_F(DBinderServiceStubUnitTest, AddDbinderDeathRecipient001, TestSize.Level1)
469 {
470 const std::u16string service = u"serviceTest";
471 const std::string device = "deviceTest";
472 binder_uintptr_t object = BINDER_OBJECT;
473 DBinderServiceStub dBinderServiceStub(service, device, object);
474 MessageParcel data;
475 int32_t ret = dBinderServiceStub.AddDbinderDeathRecipient(data);
476 EXPECT_EQ(ret, DBINDER_SERVICE_INVALID_DATA_ERR);
477 }
478
479 /**
480 * @tc.name: AddDbinderDeathRecipient002
481 * @tc.desc: Verify the AddDbinderDeathRecipient function
482 * @tc.type: FUNC
483 */
484 HWTEST_F(DBinderServiceStubUnitTest, AddDbinderDeathRecipient002, TestSize.Level1)
485 {
486 const std::u16string service = u"serviceTest";
487 const std::string device = "deviceTest";
488 binder_uintptr_t object = BINDER_OBJECT;
489 DBinderServiceStub dBinderServiceStub(service, device, object);
490
491 sptr<IPCObjectStub> callbackStub = new (std::nothrow) IPCObjectStub(u"testStub");
492 EXPECT_TRUE(callbackStub != nullptr);
493 MessageParcel data;
494 data.WriteRemoteObject(callbackStub);
495 data.WriteString("");
496 int32_t ret = dBinderServiceStub.AddDbinderDeathRecipient(data);
497 EXPECT_EQ(ret, DBINDER_SERVICE_ADD_DEATH_ERR);
498 }
499
500 /**
501 * @tc.name: AddDbinderDeathRecipient003
502 * @tc.desc: Verify the AddDbinderDeathRecipient function
503 * @tc.type: FUNC
504 */
505 HWTEST_F(DBinderServiceStubUnitTest, AddDbinderDeathRecipient003, TestSize.Level1)
506 {
507 const std::u16string service = u"serviceTest";
508 const std::string device = "deviceTest";
509 binder_uintptr_t object = BINDER_OBJECT;
510 DBinderServiceStub dBinderServiceStub(service, device, object);
511
512 sptr<IPCObjectStub> callbackStub = new (std::nothrow) IPCObjectStub(u"testStub");
513 EXPECT_TRUE(callbackStub != nullptr);
514 MessageParcel data;
515 data.WriteRemoteObject(callbackStub);
516 data.WriteString("test");
517 int32_t ret = dBinderServiceStub.AddDbinderDeathRecipient(data);
518 EXPECT_EQ(ret, DBINDER_SERVICE_ADD_DEATH_ERR);
519 }
520
521 /**
522 * @tc.name: AddDbinderDeathRecipient004
523 * @tc.desc: Verify the AddDbinderDeathRecipient function
524 * @tc.type: FUNC
525 */
526 HWTEST_F(DBinderServiceStubUnitTest, AddDbinderDeathRecipient004, TestSize.Level1)
527 {
528 const std::u16string service = u"serviceTest";
529 const std::string device = "deviceTest";
530 binder_uintptr_t object = BINDER_OBJECT;
531 DBinderServiceStub dBinderServiceStub(service, device, object);
532
533 sptr<IPCObjectProxy> callbackProxy = new (std::nothrow) IPCObjectProxy(0);
534 EXPECT_TRUE(callbackProxy != nullptr);
535 MessageParcel data;
536 data.WriteRemoteObject(callbackProxy);
537 data.WriteString("test");
538 int32_t ret = dBinderServiceStub.AddDbinderDeathRecipient(data);
539 EXPECT_EQ(ret, ERR_NONE);
540 }
541
542 /**
543 * @tc.name: AddDbinderDeathRecipient005
544 * @tc.desc: Verify the AddDbinderDeathRecipient function
545 * @tc.type: FUNC
546 */
547 HWTEST_F(DBinderServiceStubUnitTest, AddDbinderDeathRecipient005, TestSize.Level1)
548 {
549 const std::u16string service = u"serviceTest";
550 const std::string device = "deviceTest";
551 binder_uintptr_t object = BINDER_OBJECT;
552 DBinderServiceStub dBinderServiceStub(service, device, object);
553
554 sptr<IPCObjectProxy> callbackProxy = new (std::nothrow) IPCObjectProxy(0);
555 EXPECT_TRUE(callbackProxy != nullptr);
556 MessageParcel data;
557 data.WriteRemoteObject(callbackProxy);
558 data.WriteString("");
559 int32_t ret = dBinderServiceStub.AddDbinderDeathRecipient(data);
560 EXPECT_EQ(ret, DBINDER_SERVICE_ADD_DEATH_ERR);
561 }
562
563 /**
564 * @tc.name: RemoveDbinderDeathRecipient001
565 * @tc.desc: Verify the RemoveDbinderDeathRecipient function
566 * @tc.type: FUNC
567 */
568 HWTEST_F(DBinderServiceStubUnitTest, RemoveDbinderDeathRecipient001, TestSize.Level1)
569 {
570 const std::u16string service = u"serviceTest";
571 const std::string device = "deviceTest";
572 binder_uintptr_t object = BINDER_OBJECT;
573 DBinderServiceStub dBinderServiceStub(service, device, object);
574
575 MessageParcel data;
576 int32_t ret = dBinderServiceStub.RemoveDbinderDeathRecipient(data);
577 EXPECT_EQ(ret, DBINDER_SERVICE_REMOVE_DEATH_ERR);
578 }
579
580 /**
581 * @tc.name: RemoveDbinderDeathRecipient002
582 * @tc.desc: Verify the RemoveDbinderDeathRecipient function
583 * @tc.type: FUNC
584 */
585 HWTEST_F(DBinderServiceStubUnitTest, RemoveDbinderDeathRecipient002, TestSize.Level1)
586 {
587 const std::u16string service = u"serviceTest";
588 const std::string device = "deviceTest";
589 binder_uintptr_t object = BINDER_OBJECT;
590 DBinderServiceStub dBinderServiceStub(service, device, object);
591
592 sptr<IPCObjectProxy> callbackProxy = new (std::nothrow) IPCObjectProxy(0);
593 EXPECT_TRUE(callbackProxy != nullptr);
594 MessageParcel data;
595 data.WriteRemoteObject(callbackProxy);
596 data.WriteString("test");
597 int32_t ret = dBinderServiceStub.RemoveDbinderDeathRecipient(data);
598 EXPECT_EQ(ret, ERR_NONE);
599 }
600
601 /**
602 * @tc.name: RemoveDbinderDeathRecipient003
603 * @tc.desc: Verify the RemoveDbinderDeathRecipient function
604 * @tc.type: FUNC
605 */
606 HWTEST_F(DBinderServiceStubUnitTest, RemoveDbinderDeathRecipient003, TestSize.Level1)
607 {
608 const std::u16string service = u"serviceTest";
609 const std::string device = "deviceTest";
610 binder_uintptr_t object = BINDER_OBJECT;
611 DBinderServiceStub dBinderServiceStub(service, device, object);
612
613 sptr<IPCObjectProxy> callbackProxy = new (std::nothrow) IPCObjectProxy(0);
614 EXPECT_TRUE(callbackProxy != nullptr);
615 MessageParcel data;
616 data.WriteRemoteObject(callbackProxy);
617 data.WriteString("");
618 int32_t ret = dBinderServiceStub.RemoveDbinderDeathRecipient(data);
619 EXPECT_EQ(ret, DBINDER_SERVICE_REMOVE_DEATH_ERR);
620 }
621
622 /**
623 * @tc.name: RemoveDbinderDeathRecipient004
624 * @tc.desc: Verify the RemoveDbinderDeathRecipient function
625 * @tc.type: FUNC
626 */
627 HWTEST_F(DBinderServiceStubUnitTest, RemoveDbinderDeathRecipient004, TestSize.Level1)
628 {
629 const std::u16string service = u"serviceTest";
630 const std::string device = "deviceTest";
631 binder_uintptr_t object = BINDER_OBJECT;
632 DBinderServiceStub dBinderServiceStub(service, device, object);
633
634 sptr<IPCObjectStub> callbackStub = new (std::nothrow) IPCObjectStub(u"testStub");
635 EXPECT_TRUE(callbackStub != nullptr);
636 MessageParcel data;
637 data.WriteRemoteObject(callbackStub);
638 data.WriteString("test");
639 int32_t ret = dBinderServiceStub.RemoveDbinderDeathRecipient(data);
640 EXPECT_EQ(ret, DBINDER_SERVICE_REMOVE_DEATH_ERR);
641 }
642
643 /**
644 * @tc.name: RemoveDbinderDeathRecipient005
645 * @tc.desc: Verify the RemoveDbinderDeathRecipient function
646 * @tc.type: FUNC
647 */
648 HWTEST_F(DBinderServiceStubUnitTest, RemoveDbinderDeathRecipient005, TestSize.Level1)
649 {
650 const std::u16string service = u"serviceTest";
651 const std::string device = "deviceTest";
652 binder_uintptr_t object = BINDER_OBJECT;
653 DBinderServiceStub dBinderServiceStub(service, device, object);
654
655 sptr<IPCObjectStub> callbackStub = new (std::nothrow) IPCObjectStub(u"testStub");
656 EXPECT_TRUE(callbackStub != nullptr);
657 MessageParcel data;
658 data.WriteRemoteObject(callbackStub);
659 data.WriteString("");
660 int32_t ret = dBinderServiceStub.RemoveDbinderDeathRecipient(data);
661 EXPECT_EQ(ret, DBINDER_SERVICE_REMOVE_DEATH_ERR);
662 }
663
664 /**
665 * @tc.name: GetAndSaveDBinderData001
666 * @tc.desc: Verify the GetAndSaveDBinderData function
667 * @tc.type: FUNC
668 */
669 HWTEST_F(DBinderServiceStubUnitTest, GetAndSaveDBinderData001, TestSize.Level1)
670 {
671 const std::u16string service = u"serviceTest";
672 const std::string device = "deviceTest";
673 binder_uintptr_t object = BINDER_OBJECT;
674 DBinderServiceStub dBinderServiceStub(service, device, object);
675
676 pid_t pid = -1;
677 uid_t uid = -1;
678
679 int ret = dBinderServiceStub.GetAndSaveDBinderData(pid, uid);
680 EXPECT_EQ(ret, DBINDER_SERVICE_FILL_DATA_ERR);
681 }
682
683 /**
684 * @tc.name: GetAndSaveDBinderData002
685 * @tc.desc: Verify the GetAndSaveDBinderData function
686 * @tc.type: FUNC
687 */
688 HWTEST_F(DBinderServiceStubUnitTest, GetAndSaveDBinderData002, TestSize.Level1)
689 {
690 const std::u16string service = u"serviceTest";
691 const std::string device = "deviceTest";
692 binder_uintptr_t object = BINDER_OBJECT;
693 DBinderServiceStub dBinderServiceStub(service, device, object);
694
695 pid_t pid = 1234;
696 uid_t uid = 1001;
697 int ret = dBinderServiceStub.GetAndSaveDBinderData(pid, uid);
698 EXPECT_EQ(ret, DBINDER_SERVICE_FILL_DATA_ERR);
699 }
700
701 /**
702 * @tc.name: Marshalling001
703 * @tc.desc: Verify the Marshalling function
704 * @tc.type: FUNC
705 */
706 HWTEST_F(DBinderServiceStubUnitTest, Marshalling001, TestSize.Level1)
707 {
708 sptr<IRemoteObject> nullObject = nullptr;
709 const std::u16string service = u"serviceTest";
710 const std::string device = "deviceTest";
711 binder_uintptr_t object = BINDER_OBJECT;
712 DBinderServiceStub dBinderServiceStub(service, device, object);
713
714 Parcel parcel;
715 bool result = dBinderServiceStub.Marshalling(parcel, nullObject);
716 EXPECT_FALSE(result);
717 }
718
719 /**
720 * @tc.name: Marshalling002
721 * @tc.desc: Verify the Marshalling function
722 * @tc.type: FUNC
723 */
724 HWTEST_F(DBinderServiceStubUnitTest, Marshalling002, TestSize.Level1)
725 {
726 const std::u16string service = u"serviceTest";
727 const std::string device = "deviceTest";
728 binder_uintptr_t object = BINDER_OBJECT;
729 DBinderServiceStub dBinderServiceStub(service, device, object);
730
731 const std::u16string service2 = u"serviceTest2";
732 const std::string device2 = "deviceTest2";
733 sptr<IRemoteObject> stubObject = new DBinderServiceStub(service2, device2, object);
734 EXPECT_TRUE(stubObject != nullptr);
735 Parcel parcel;
736 bool result = dBinderServiceStub.Marshalling(parcel, stubObject);
737 EXPECT_TRUE(result);
738 }
739
740 /**
741 * @tc.name: Marshalling003
742 * @tc.desc: Verify the Marshalling function
743 * @tc.type: FUNC
744 */
745 HWTEST_F(DBinderServiceStubUnitTest, Marshalling003, TestSize.Level1)
746 {
747 const std::u16string service1 = u"serviceTest1";
748 const std::string device1 = "deviceTest1";
749 binder_uintptr_t object = BINDER_OBJECT;
750 DBinderServiceStub dBinderServiceStub1(service1, device1, object);
751
752 const std::u16string service2 = u"serviceTest2";
753 const std::string device2 = "deviceTest2";
754 DBinderServiceStub* dBinderServiceStub2 = new DBinderServiceStub(service2, device2, object);
755 dBinderServiceStub2->dbinderData_ = nullptr;
756 sptr<IRemoteObject> stubObject = dBinderServiceStub2;
757
758 Parcel parcel;
759 bool result = dBinderServiceStub1.Marshalling(parcel, stubObject);
760 EXPECT_FALSE(result);
761 }
762
763 /**
764 * @tc.name: SaveDBinderData001
765 * @tc.desc: Verify the SaveDBinderData function
766 * @tc.type: FUNC
767 */
768 HWTEST_F(DBinderServiceStubUnitTest, SaveDBinderData001, TestSize.Level1)
769 {
770 DBinderService::GetInstance()->instance_ = nullptr;
771 const std::u16string service1 = u"serviceTest1";
772 const std::string device1 = "deviceTest1";
773 binder_uintptr_t object = BINDER_OBJECT;
774 DBinderServiceStub dbinderServiceStub(service1, device1, object);
775 std::string localBusName = "localBusName";
776 int ret = dbinderServiceStub.SaveDBinderData(localBusName);
777 ASSERT_EQ(ret, DBINDER_SERVICE_FILL_DATA_ERR);
778 }
779
780 /**
781 * @tc.name: SaveDBinderData002
782 * @tc.desc: Verify the SaveDBinderData function
783 * @tc.type: FUNC
784 */
785 HWTEST_F(DBinderServiceStubUnitTest, SaveDBinderData002, TestSize.Level1)
786 {
787 const std::u16string service1 = u"serviceTest1";
788 const std::string device1 = "deviceTest1";
789 binder_uintptr_t object = BINDER_OBJECT;
790 DBinderServiceStub dbinderServiceStub(service1, device1, object);
791 std::string localBusName = "localBusName";
792 dbinderServiceStub.dbinderData_ = std::make_unique<uint8_t[]>(sizeof(DBinderNegotiationData));
793 ASSERT_NE(dbinderServiceStub.dbinderData_, nullptr);
794 int ret = dbinderServiceStub.SaveDBinderData(localBusName);
795 ASSERT_EQ(ret, DBINDER_SERVICE_FILL_DATA_ERR);
796 }
797
798 /**
799 * @tc.name: SaveDBinderData003
800 * @tc.desc: Verify the SaveDBinderData function
801 * @tc.type: FUNC
802 */
803 HWTEST_F(DBinderServiceStubUnitTest, SaveDBinderData003, TestSize.Level1)
804 {
805 const std::u16string service1 = u"serviceTest1";
806 const std::string device1 = "deviceTest1";
807 binder_uintptr_t object = BINDER_OBJECT;
808 DBinderServiceStub dbinderServiceStub(service1, device1, object);
809 binder_uintptr_t objectAddress = reinterpret_cast<binder_uintptr_t>(&dbinderServiceStub);
810 std::string localBusName = "localBusName";
811 sptr<DBinderService> dBinderService = DBinderService::GetInstance();
812 std::shared_ptr<SessionInfo> sessionInfo = std::make_shared<SessionInfo>();
813 EXPECT_TRUE(sessionInfo != nullptr);
814 sessionInfo->type = SESSION_TYPE_UNKNOWN;
815 bool isInitialized = dBinderService->AttachSessionObject(sessionInfo, objectAddress);
816 ASSERT_TRUE(isInitialized);
817 dbinderServiceStub.dbinderData_ = nullptr;
818 int ret = dbinderServiceStub.SaveDBinderData(localBusName);
819 ASSERT_EQ(ret, DBINDER_SERVICE_MALLOC_ERR);
820 bool result = dBinderService->DetachSessionObject(objectAddress);
821 ASSERT_TRUE(result);
822 }
823
824 /**
825 * @tc.name: SaveDBinderData004
826 * @tc.desc: Verify the SaveDBinderData function
827 * @tc.type: FUNC
828 */
829 HWTEST_F(DBinderServiceStubUnitTest, SaveDBinderData004, TestSize.Level1)
830 {
831 const std::u16string service1 = u"serviceTest1";
832 const std::string device1 = "deviceTest1";
833 binder_uintptr_t object = BINDER_OBJECT;
834 DBinderServiceStub dbinderServiceStub(service1, device1, object);
835 std::string localBusName = "localBusName";
836 dbinderServiceStub.dbinderData_ = std::make_unique<uint8_t[]>(sizeof(DBinderNegotiationData));
837 ASSERT_NE(dbinderServiceStub.dbinderData_, nullptr);
838 DBinderNegotiationData data;
839 data.stubIndex = 1;
840 data.peerTokenId = 1;
841 data.peerServiceName = "target_name";
842 data.peerDeviceId = "target_device";
843 data.localDeviceId = "local_device";
844 data.localServiceName = "local_name";
845 memcpy_s(dbinderServiceStub.dbinderData_.get(), sizeof(DBinderNegotiationData),
846 &data, sizeof(DBinderNegotiationData));
847 int ret = dbinderServiceStub.SaveDBinderData(localBusName);
848 ASSERT_EQ(ret, DBINDER_SERVICE_FILL_DATA_ERR);
849 }
850
851 /**
852 * @tc.name: SaveDBinderData005
853 * @tc.desc: Verify the SaveDBinderData function
854 * @tc.type: FUNC
855 */
856 HWTEST_F(DBinderServiceStubUnitTest, SaveDBinderData005, TestSize.Level1)
857 {
858 const std::u16string service1 = u"serviceTest1";
859 const std::string device1 = "deviceTest1";
860 binder_uintptr_t object = BINDER_OBJECT;
861 DBinderServiceStub dbinderServiceStub(service1, device1, object);
862 binder_uintptr_t objectAddress = reinterpret_cast<binder_uintptr_t>(&dbinderServiceStub);
863 std::string localBusName = "localBusName";
864 dbinderServiceStub.dbinderData_ = std::make_unique<uint8_t[]>(sizeof(dbinder_negotiation_data));
865 ASSERT_NE(dbinderServiceStub.dbinderData_, nullptr);
866 dbinder_negotiation_data *dbinderData = reinterpret_cast<dbinder_negotiation_data *>(
867 dbinderServiceStub.dbinderData_.get());
868 dbinderData->stub_index = 1;
869 dbinderData->tokenid = 1;
870 auto ret = strcpy_s(dbinderData->target_name, SESSION_NAME_LENGTH, "target_name");
871 ret += strcpy_s(dbinderData->target_device, OHOS::DEVICEID_LENGTH, "target_device");
872 ret += strcpy_s(dbinderData->local_device, OHOS::DEVICEID_LENGTH, "local_device");
873 ret += strcpy_s(dbinderData->local_name, SESSION_NAME_LENGTH, "local_name");
874 ASSERT_EQ(ret, EOK);
875 sptr<DBinderService> dBinderService = DBinderService::GetInstance();
876 std::shared_ptr<SessionInfo> sessionInfo = std::make_shared<SessionInfo>();
877 EXPECT_TRUE(sessionInfo != nullptr);
878 sessionInfo->type = SESSION_TYPE_UNKNOWN;
879 bool isInitialized = dBinderService->AttachSessionObject(sessionInfo, objectAddress);
880 ASSERT_TRUE(isInitialized);
881 ret = dbinderServiceStub.SaveDBinderData(localBusName);
882 ASSERT_EQ(ret, ERR_NONE);
883 bool result = dBinderService->DetachSessionObject(objectAddress);
884 ASSERT_TRUE(result);
885 }
886
887 /**
888 * @tc.name: GetPeerPid001
889 * @tc.desc: Verify the GetPeerPid function
890 * @tc.type: FUNC
891 */
892 HWTEST_F(DBinderServiceStubUnitTest, GetPeerPid001, TestSize.Level1)
893 {
894 const std::u16string service = u"serviceTest";
895 const std::string deviceId = "deviceTest";
896 binder_uintptr_t object = BINDER_OBJECT;
897 DBinderServiceStub dbinderServiceStub(service, deviceId, object);
898 EXPECT_EQ(dbinderServiceStub.GetPeerPid(), 0);
899
900 DBinderServiceStub dbinderServiceStub2(service, deviceId, object, TEST_PID, TEST_UID);
901 EXPECT_EQ(dbinderServiceStub2.GetPeerPid(), TEST_PID);
902 }
903
904 /**
905 * @tc.name: GetPeerUid001
906 * @tc.desc: Verify the GetPeerUid function
907 * @tc.type: FUNC
908 */
909 HWTEST_F(DBinderServiceStubUnitTest, GetPeerUid001, TestSize.Level1)
910 {
911 const std::u16string service = u"serviceTest";
912 const std::string deviceId = "deviceTest";
913 binder_uintptr_t object = BINDER_OBJECT;
914 DBinderServiceStub dbinderServiceStub(service, deviceId, object);
915 EXPECT_EQ(dbinderServiceStub.GetPeerUid(), 0);
916
917 DBinderServiceStub dbinderServiceStub2(service, deviceId, object, TEST_PID, TEST_UID);
918 EXPECT_EQ(dbinderServiceStub2.GetPeerUid(), TEST_UID);
919 }
920
921 /**
922 * @tc.name: SetSeqNumber001
923 * @tc.desc: Verify the SetSeqNumber function
924 * @tc.type: FUNC
925 */
926 HWTEST_F(DBinderServiceStubUnitTest, SetSeqNumber001, TestSize.Level1)
927 {
928 const std::u16string service = u"serviceTest";
929 const std::string deviceId = "deviceTest";
930 binder_uintptr_t object = BINDER_OBJECT;
931 DBinderServiceStub dbinderServiceStub(service, deviceId, object);
932 dbinderServiceStub.SetSeqNumber(TEST_SEQ_NUM);
933 EXPECT_EQ(dbinderServiceStub.GetSeqNumber(), TEST_SEQ_NUM);
934 }
935
936 /**
937 * @tc.name: SetNegoStatusAndTime001
938 * @tc.desc: Verify the SetNegoStatusAndTime function
939 * @tc.type: FUNC
940 */
941 HWTEST_F(DBinderServiceStubUnitTest, SetNegoStatusAndTime001, TestSize.Level1)
942 {
943 const std::u16string service = u"serviceTest";
944 const std::string deviceId = "deviceTest";
945 binder_uintptr_t object = BINDER_OBJECT;
946 DBinderServiceStub dbinderServiceStub(service, deviceId, object);
947 dbinderServiceStub.SetNegoStatusAndTime(NegotiationStatus::NEGO_DOING, 1);
948
949 NegotiationStatus status = NegotiationStatus::NEGO_INIT;
950 uint64_t time = 0;
951 dbinderServiceStub.GetNegoStatusAndTime(status, time);
952 EXPECT_EQ(status, NegotiationStatus::NEGO_DOING);
953 EXPECT_EQ(time, 1);
954 }