• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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 
16 #include "distributed_hardware_stub_test.h"
17 
18 #include <memory>
19 
20 #include "iremote_stub.h"
21 #include "dhardware_ipc_interface_code.h"
22 
23 using namespace OHOS::Security::AccessToken;
24 using namespace testing;
25 using namespace testing::ext;
26 
27 namespace OHOS {
28 namespace DistributedHardware {
SetUpTestCase(void)29 void DistributedHardwareStubTest::SetUpTestCase(void) {}
30 
TearDownTestCase(void)31 void DistributedHardwareStubTest::TearDownTestCase(void) {}
32 
SetUp()33 void DistributedHardwareStubTest::SetUp()
34 {
35     stubTest_ = std::make_shared<MockDistributedHardwareStub>();
36     auto token = AccessTokenKitInterface::GetOrCreateAccessTokenKit();
37     token_ = std::static_pointer_cast<AccessTokenKitMock>(token);
38     ASSERT_TRUE(token_ != nullptr);
39     EXPECT_CALL(*token_, VerifyAccessToken(_, _)).WillRepeatedly(Return(PERMISSION_DENIED));
40 }
41 
TearDown()42 void DistributedHardwareStubTest::TearDown()
43 {
44     stubTest_ = nullptr;
45     AccessTokenKitInterface::ReleaseAccessTokenKit();
46     token_ = nullptr;
47 }
48 
49 /**
50  * @tc.name: OnRemoteRequest_001
51  * @tc.desc: Verify the OnRemoteRequest function
52  * @tc.type: FUNC
53  * @tc.require: AR000GHSJM
54  */
55 HWTEST_F(DistributedHardwareStubTest, OnRemoteRequest_001, TestSize.Level1)
56 {
57     ASSERT_TRUE(stubTest_ != nullptr);
58     uint32_t code = 0;
59     MessageParcel data;
60     MessageParcel reply;
61     MessageOption option;
62     EXPECT_NE(DH_FWK_SUCCESS, stubTest_->OnRemoteRequest(code, data, reply, option));
63 }
64 
65 /**
66  * @tc.name: OnRemoteRequest_002
67  * @tc.desc: Verify the OnRemoteRequest function
68  * @tc.type: FUNC
69  * @tc.require: AR000GHSJM
70  */
71 HWTEST_F(DistributedHardwareStubTest, OnRemoteRequest_002, TestSize.Level1)
72 {
73     ASSERT_TRUE(stubTest_ != nullptr);
74     uint32_t code = 0;
75     MessageParcel data;
76     MessageParcel reply;
77     MessageOption option;
78     EXPECT_EQ(ERR_INVALID_DATA, stubTest_->OnRemoteRequest(code, data, reply, option));
79 }
80 
81 HWTEST_F(DistributedHardwareStubTest, OnRemoteRequest_003, TestSize.Level1)
82 {
83     ASSERT_TRUE(stubTest_ != nullptr);
84     uint32_t code = static_cast<uint32_t>(DHMsgInterfaceCode::REG_PUBLISHER_LISTNER);
85     MessageParcel data;
86     MessageParcel reply;
87     MessageOption option;
88     data.WriteInterfaceToken(stubTest_->GetDescriptor());
89     uint32_t topicInt = (uint32_t)DHTopic::TOPIC_MIN;
90     data.WriteUint32(topicInt);
91     auto ret = stubTest_->OnRemoteRequest(code, data, reply, option);
92     EXPECT_EQ(ERR_DH_FWK_ACCESS_PERMISSION_CHECK_FAIL, ret);
93 }
94 
95 HWTEST_F(DistributedHardwareStubTest, OnRemoteRequest_004, TestSize.Level1)
96 {
97     ASSERT_TRUE(stubTest_ != nullptr);
98     uint32_t code = static_cast<uint32_t>(DHMsgInterfaceCode::PUBLISH_MESSAGE);
99     MessageParcel data;
100     MessageParcel reply;
101     MessageOption option;
102     data.WriteInterfaceToken(stubTest_->GetDescriptor());
103     uint32_t topicInt = (uint32_t)DHTopic::TOPIC_MIN;
104     data.WriteUint32(topicInt);
105     auto ret = stubTest_->OnRemoteRequest(code, data, reply, option);
106     EXPECT_EQ(ERR_DH_FWK_ACCESS_PERMISSION_CHECK_FAIL, ret);
107 }
108 
109 HWTEST_F(DistributedHardwareStubTest, OnRemoteRequest_005, TestSize.Level1)
110 {
111     ASSERT_TRUE(stubTest_ != nullptr);
112     uint32_t code = static_cast<uint32_t>(DHMsgInterfaceCode::INIT_CTL_CEN);
113     MessageParcel data;
114     MessageParcel reply;
115     MessageOption option;
116     data.WriteInterfaceToken(stubTest_->GetDescriptor());
117     uint32_t transRole = static_cast<uint32_t>(TransRole::UNKNOWN);
118     data.WriteUint32(transRole);
119     auto ret = stubTest_->OnRemoteRequest(code, data, reply, option);
120     EXPECT_EQ(ERR_DH_FWK_ACCESS_PERMISSION_CHECK_FAIL, ret);
121 }
122 
123 HWTEST_F(DistributedHardwareStubTest, OnRemoteRequest_006, TestSize.Level1)
124 {
125     ASSERT_TRUE(stubTest_ != nullptr);
126     uint32_t code = static_cast<uint32_t>(DHMsgInterfaceCode::RELEASE_CTL_CEN);
127     MessageParcel data;
128     MessageParcel reply;
129     MessageOption option;
130     data.WriteInterfaceToken(stubTest_->GetDescriptor());
131     int32_t engineId = 1;
132     data.WriteInt32(engineId);
133     auto ret = stubTest_->OnRemoteRequest(code, data, reply, option);
134     EXPECT_EQ(ERR_DH_FWK_ACCESS_PERMISSION_CHECK_FAIL, ret);
135 }
136 
137 HWTEST_F(DistributedHardwareStubTest, OnRemoteRequest_007, TestSize.Level1)
138 {
139     ASSERT_TRUE(stubTest_ != nullptr);
140     uint32_t code = static_cast<uint32_t>(DHMsgInterfaceCode::CREATE_CTL_CEN_CHANNEL);
141     MessageParcel data;
142     MessageParcel reply;
143     MessageOption option;
144     data.WriteInterfaceToken(stubTest_->GetDescriptor());
145     int32_t engineId = 1;
146     std::string peerDevId = "peerDevId_test";
147     data.WriteInt32(engineId);
148     data.WriteString(peerDevId);
149     auto ret = stubTest_->OnRemoteRequest(code, data, reply, option);
150     EXPECT_EQ(ERR_DH_FWK_ACCESS_PERMISSION_CHECK_FAIL, ret);
151 }
152 
153 HWTEST_F(DistributedHardwareStubTest, OnRemoteRequest_008, TestSize.Level1)
154 {
155     ASSERT_TRUE(stubTest_ != nullptr);
156     uint32_t code = static_cast<uint32_t>(DHMsgInterfaceCode::NOTIFY_AV_EVENT);
157     MessageParcel data;
158     MessageParcel reply;
159     MessageOption option;
160     data.WriteInterfaceToken(stubTest_->GetDescriptor());
161     int32_t engineId = 1;
162     std::string peerDevId = "peerDevId_test";
163     uint32_t type = 1;
164     std::string content = "content_test";
165     data.WriteInt32(engineId);
166     data.WriteString(peerDevId);
167     data.WriteUint32(type);
168     data.WriteString(content);
169     auto ret = stubTest_->OnRemoteRequest(code, data, reply, option);
170     EXPECT_EQ(ERR_DH_FWK_ACCESS_PERMISSION_CHECK_FAIL, ret);
171 }
172 
173 HWTEST_F(DistributedHardwareStubTest, OnRemoteRequest_009, TestSize.Level1)
174 {
175     ASSERT_TRUE(stubTest_ != nullptr);
176     uint32_t code = static_cast<uint32_t>(DHMsgInterfaceCode::QUERY_LOCAL_SYS_SPEC);
177     MessageParcel data;
178     MessageParcel reply;
179     MessageOption option;
180     data.WriteInterfaceToken(stubTest_->GetDescriptor());
181     uint32_t specInt = static_cast<uint32_t>(QueryLocalSysSpecType::MIN);
182     data.WriteUint32(specInt);
183     auto ret = stubTest_->OnRemoteRequest(code, data, reply, option);
184     EXPECT_EQ(ERR_DH_FWK_ACCESS_PERMISSION_CHECK_FAIL, ret);
185 }
186 
187 HWTEST_F(DistributedHardwareStubTest, OnRemoteRequest_010, TestSize.Level1)
188 {
189     ASSERT_TRUE(stubTest_ != nullptr);
190     uint32_t code = static_cast<uint32_t>(DHMsgInterfaceCode::NOTIFY_SOURCE_DEVICE_REMOTE_DMSDP_STARTED);
191     MessageParcel data;
192     MessageParcel reply;
193     MessageOption option;
194     data.WriteInterfaceToken(stubTest_->GetDescriptor());
195     std::string deviceId = "deviceId_test";
196     data.WriteString(deviceId);
197     auto ret = stubTest_->OnRemoteRequest(code, data, reply, option);
198     EXPECT_EQ(ERR_DH_FWK_PARA_INVALID, ret);
199 }
200 
201 HWTEST_F(DistributedHardwareStubTest, OnRemoteRequest_011, TestSize.Level1)
202 {
203     ASSERT_TRUE(stubTest_ != nullptr);
204     uint32_t code = static_cast<uint32_t>(DHMsgInterfaceCode::PAUSE_DISTRIBUTED_HARDWARE);
205     MessageParcel data;
206     MessageParcel reply;
207     MessageOption option;
208     data.WriteInterfaceToken(stubTest_->GetDescriptor());
209     auto ret = stubTest_->OnRemoteRequest(code, data, reply, option);
210     EXPECT_EQ(ERR_DH_FWK_IS_SYSTEM_HAP_CHECK_FAIL, ret);
211 }
212 
213 HWTEST_F(DistributedHardwareStubTest, OnRemoteRequest_012, TestSize.Level1)
214 {
215     ASSERT_TRUE(stubTest_ != nullptr);
216     uint32_t code = static_cast<uint32_t>(DHMsgInterfaceCode::RESUME_DISTRIBUTED_HARDWARE);
217     MessageParcel data;
218     MessageParcel reply;
219     MessageOption option;
220     data.WriteInterfaceToken(stubTest_->GetDescriptor());
221     auto ret = stubTest_->OnRemoteRequest(code, data, reply, option);
222     EXPECT_EQ(ERR_DH_FWK_IS_SYSTEM_HAP_CHECK_FAIL, ret);
223 }
224 
225 HWTEST_F(DistributedHardwareStubTest, OnRemoteRequest_013, TestSize.Level1)
226 {
227     ASSERT_TRUE(stubTest_ != nullptr);
228     uint32_t code = static_cast<uint32_t>(DHMsgInterfaceCode::STOP_DISTRIBUTED_HARDWARE);
229     MessageParcel data;
230     MessageParcel reply;
231     MessageOption option;
232     data.WriteInterfaceToken(stubTest_->GetDescriptor());
233     auto ret = stubTest_->OnRemoteRequest(code, data, reply, option);
234     EXPECT_EQ(ERR_DH_FWK_IS_SYSTEM_HAP_CHECK_FAIL, ret);
235 }
236 
237 HWTEST_F(DistributedHardwareStubTest, OnRemoteRequest_014, TestSize.Level1)
238 {
239     ASSERT_TRUE(stubTest_ != nullptr);
240     uint32_t code = static_cast<uint32_t>(DHMsgInterfaceCode::UNREG_PUBLISHER_LISTENER);
241     MessageParcel data;
242     MessageParcel reply;
243     MessageOption option;
244     data.WriteInterfaceToken(stubTest_->GetDescriptor());
245     uint32_t topicInt = (uint32_t)DHTopic::TOPIC_MIN;
246     data.WriteUint32(topicInt);
247     auto ret = stubTest_->OnRemoteRequest(code, data, reply, option);
248     EXPECT_EQ(ERR_DH_FWK_ACCESS_PERMISSION_CHECK_FAIL, ret);
249 }
250 
251 HWTEST_F(DistributedHardwareStubTest, OnRemoteRequest_015, TestSize.Level1)
252 {
253     ASSERT_TRUE(stubTest_ != nullptr);
254     uint32_t code = static_cast<uint32_t>(DHMsgInterfaceCode::REGISTER_CTL_CEN_CALLBACK);
255     MessageParcel data;
256     MessageParcel reply;
257     MessageOption option;
258     data.WriteInterfaceToken(stubTest_->GetDescriptor());
259     auto ret = stubTest_->OnRemoteRequest(code, data, reply, option);
260     EXPECT_EQ(ERR_DH_FWK_ACCESS_PERMISSION_CHECK_FAIL, ret);
261 }
262 
263 HWTEST_F(DistributedHardwareStubTest, OnRemoteRequest_016, TestSize.Level1)
264 {
265     ASSERT_TRUE(stubTest_ != nullptr);
266     uint32_t code = static_cast<uint32_t>(DHMsgInterfaceCode::GET_DISTRIBUTED_HARDWARE);
267     MessageParcel data;
268     MessageParcel reply;
269     MessageOption option;
270     data.WriteInterfaceToken(stubTest_->GetDescriptor());
271     data.WriteString("netWorkId_test");
272     auto ret = stubTest_->OnRemoteRequest(code, data, reply, option);
273     EXPECT_EQ(ERR_DH_FWK_ACCESS_PERMISSION_CHECK_FAIL, ret);
274 }
275 
276 HWTEST_F(DistributedHardwareStubTest, OnRemoteRequest_017, TestSize.Level1)
277 {
278     ASSERT_TRUE(stubTest_ != nullptr);
279     uint32_t code = static_cast<uint32_t>(DHMsgInterfaceCode::REG_DH_SINK_STATUS_LISTNER);
280     MessageParcel data;
281     MessageParcel reply;
282     MessageOption option;
283     data.WriteInterfaceToken(stubTest_->GetDescriptor());
284     auto ret = stubTest_->OnRemoteRequest(code, data, reply, option);
285     EXPECT_EQ(ERR_DH_FWK_ACCESS_PERMISSION_CHECK_FAIL, ret);
286 }
287 
288 HWTEST_F(DistributedHardwareStubTest, OnRemoteRequest_018, TestSize.Level1)
289 {
290     ASSERT_TRUE(stubTest_ != nullptr);
291     uint32_t code = static_cast<uint32_t>(DHMsgInterfaceCode::UNREG_DH_SINK_STATUS_LISTNER);
292     MessageParcel data;
293     MessageParcel reply;
294     MessageOption option;
295     data.WriteInterfaceToken(stubTest_->GetDescriptor());
296     auto ret = stubTest_->OnRemoteRequest(code, data, reply, option);
297     EXPECT_EQ(ERR_DH_FWK_ACCESS_PERMISSION_CHECK_FAIL, ret);
298 }
299 
300 HWTEST_F(DistributedHardwareStubTest, OnRemoteRequest_019, TestSize.Level1)
301 {
302     ASSERT_TRUE(stubTest_ != nullptr);
303     uint32_t code = static_cast<uint32_t>(DHMsgInterfaceCode::REG_DH_SOURCE_STATUS_LISTNER);
304     MessageParcel data;
305     MessageParcel reply;
306     MessageOption option;
307     data.WriteInterfaceToken(stubTest_->GetDescriptor());
308     auto ret = stubTest_->OnRemoteRequest(code, data, reply, option);
309     EXPECT_EQ(ERR_DH_FWK_ACCESS_PERMISSION_CHECK_FAIL, ret);
310 }
311 
312 HWTEST_F(DistributedHardwareStubTest, OnRemoteRequest_020, TestSize.Level1)
313 {
314     ASSERT_TRUE(stubTest_ != nullptr);
315     uint32_t code = static_cast<uint32_t>(DHMsgInterfaceCode::UNREG_DH_SOURCE_STATUS_LISTNER);
316     MessageParcel data;
317     MessageParcel reply;
318     MessageOption option;
319     data.WriteInterfaceToken(stubTest_->GetDescriptor());
320     auto ret = stubTest_->OnRemoteRequest(code, data, reply, option);
321     EXPECT_EQ(ERR_DH_FWK_ACCESS_PERMISSION_CHECK_FAIL, ret);
322 }
323 
324 HWTEST_F(DistributedHardwareStubTest, OnRemoteRequest_021, TestSize.Level1)
325 {
326     ASSERT_TRUE(stubTest_ != nullptr);
327     uint32_t code = static_cast<uint32_t>(DHMsgInterfaceCode::ENABLE_SINK);
328     MessageParcel data;
329     MessageParcel reply;
330     MessageOption option;
331     data.WriteInterfaceToken(stubTest_->GetDescriptor());
332     data.WriteInt32(1);
333     data.WriteInt32(static_cast<int32_t>(DHType::AUDIO));
334     data.WriteString("id_test");
335     auto ret = stubTest_->OnRemoteRequest(code, data, reply, option);
336     EXPECT_EQ(ERR_DH_FWK_ACCESS_PERMISSION_CHECK_FAIL, ret);
337 }
338 
339 HWTEST_F(DistributedHardwareStubTest, OnRemoteRequest_022, TestSize.Level1)
340 {
341     ASSERT_TRUE(stubTest_ != nullptr);
342     uint32_t code = static_cast<uint32_t>(DHMsgInterfaceCode::DISABLE_SINK);
343     MessageParcel data;
344     MessageParcel reply;
345     MessageOption option;
346     data.WriteInterfaceToken(stubTest_->GetDescriptor());
347     data.WriteInt32(1);
348     data.WriteInt32(static_cast<int32_t>(DHType::AUDIO));
349     data.WriteString("id_test");
350     auto ret = stubTest_->OnRemoteRequest(code, data, reply, option);
351     EXPECT_EQ(ERR_DH_FWK_ACCESS_PERMISSION_CHECK_FAIL, ret);
352 }
353 
354 HWTEST_F(DistributedHardwareStubTest, OnRemoteRequest_023, TestSize.Level1)
355 {
356     ASSERT_TRUE(stubTest_ != nullptr);
357     uint32_t code = static_cast<uint32_t>(DHMsgInterfaceCode::ENABLE_SOURCE);
358     MessageParcel data;
359     MessageParcel reply;
360     MessageOption option;
361     data.WriteInterfaceToken(stubTest_->GetDescriptor());
362     data.WriteInt32(1);
363     data.WriteInt32(static_cast<int32_t>(DHType::AUDIO));
364     data.WriteString("id_test");
365     auto ret = stubTest_->OnRemoteRequest(code, data, reply, option);
366     EXPECT_EQ(ERR_DH_FWK_ACCESS_PERMISSION_CHECK_FAIL, ret);
367 }
368 
369 HWTEST_F(DistributedHardwareStubTest, OnRemoteRequest_024, TestSize.Level1)
370 {
371     ASSERT_TRUE(stubTest_ != nullptr);
372     uint32_t code = static_cast<uint32_t>(DHMsgInterfaceCode::DISABLE_SOURCE);
373     MessageParcel data;
374     MessageParcel reply;
375     MessageOption option;
376     data.WriteInterfaceToken(stubTest_->GetDescriptor());
377     data.WriteInt32(1);
378     data.WriteInt32(static_cast<int32_t>(DHType::AUDIO));
379     data.WriteString("id_test");
380     auto ret = stubTest_->OnRemoteRequest(code, data, reply, option);
381     EXPECT_EQ(ERR_DH_FWK_ACCESS_PERMISSION_CHECK_FAIL, ret);
382 }
383 
384 HWTEST_F(DistributedHardwareStubTest, OnRemoteRequest_025, TestSize.Level1)
385 {
386     ASSERT_TRUE(stubTest_ != nullptr);
387     uint32_t code = static_cast<uint32_t>(0xffff);
388     MessageParcel data;
389     MessageParcel reply;
390     MessageOption option;
391     data.WriteInterfaceToken(stubTest_->GetDescriptor());
392     data.WriteInt32(1);
393     data.WriteInt32(static_cast<int32_t>(DHType::AUDIO));
394     data.WriteString("id_test");
395     auto ret = stubTest_->OnRemoteRequest(code, data, reply, option);
396     EXPECT_NE(DH_FWK_SUCCESS, ret);
397 }
398 
399 HWTEST_F(DistributedHardwareStubTest, OnRemoteRequest_026, TestSize.Level1)
400 {
401     ASSERT_TRUE(stubTest_ != nullptr);
402     ASSERT_TRUE(token_ != nullptr);
403     EXPECT_CALL(*token_, VerifyAccessToken(_, _)).WillRepeatedly(Return(PERMISSION_GRANTED));
404 
405     uint32_t code = static_cast<uint32_t>(DHMsgInterfaceCode::REG_PUBLISHER_LISTNER);
406     MessageParcel data;
407     MessageParcel reply;
408     MessageOption option;
409     data.WriteInterfaceToken(stubTest_->GetDescriptor());
410     uint32_t topicInt = (uint32_t)DHTopic::TOPIC_START_DSCREEN;
411     data.WriteUint32(topicInt);
412 
413     sptr<IRemoteObject> listener(new MockIPublisherListener());
414     data.WriteRemoteObject(listener);
415     auto ret = stubTest_->OnRemoteRequest(code, data, reply, option);
416     EXPECT_EQ(DH_FWK_SUCCESS, ret);
417 }
418 
419 HWTEST_F(DistributedHardwareStubTest, OnRemoteRequest_027, TestSize.Level1)
420 {
421     ASSERT_TRUE(stubTest_ != nullptr);
422     ASSERT_TRUE(token_ != nullptr);
423     EXPECT_CALL(*token_, VerifyAccessToken(_, _)).WillRepeatedly(Return(PERMISSION_GRANTED));
424 
425     uint32_t code = static_cast<uint32_t>(DHMsgInterfaceCode::UNREG_PUBLISHER_LISTENER);
426     MessageParcel data;
427     MessageParcel reply;
428     MessageOption option;
429     data.WriteInterfaceToken(stubTest_->GetDescriptor());
430     uint32_t topicInt = (uint32_t)DHTopic::TOPIC_START_DSCREEN;
431     data.WriteUint32(topicInt);
432 
433     sptr<IRemoteObject> listener(new MockIPublisherListener());
434     data.WriteRemoteObject(listener);
435     auto ret = stubTest_->OnRemoteRequest(code, data, reply, option);
436     EXPECT_EQ(DH_FWK_SUCCESS, ret);
437 }
438 
439 HWTEST_F(DistributedHardwareStubTest, OnRemoteRequest_028, TestSize.Level1)
440 {
441     ASSERT_TRUE(stubTest_ != nullptr);
442     ASSERT_TRUE(token_ != nullptr);
443     EXPECT_CALL(*token_, VerifyAccessToken(_, _)).WillRepeatedly(Return(PERMISSION_GRANTED));
444 
445     uint32_t code = static_cast<uint32_t>(DHMsgInterfaceCode::GET_DISTRIBUTED_HARDWARE);
446     MessageParcel data;
447     MessageParcel reply;
448     MessageOption option;
449     data.WriteInterfaceToken(stubTest_->GetDescriptor());
450     data.WriteString("netWorkId_test");
451     EnableStep enableStep = EnableStep::ENABLE_SOURCE;
452     data.WriteUint32(static_cast<uint32_t>(enableStep));
453     sptr<IRemoteObject> callback(new MockGetDhDescriptorsCallbackStub());
454     data.WriteRemoteObject(callback);
455     auto ret = stubTest_->OnRemoteRequest(code, data, reply, option);
456     EXPECT_EQ(DH_FWK_SUCCESS, ret);
457 }
458 
459 HWTEST_F(DistributedHardwareStubTest, OnRemoteRequest_029, TestSize.Level1)
460 {
461     ASSERT_TRUE(stubTest_ != nullptr);
462     ASSERT_TRUE(token_ != nullptr);
463     EXPECT_CALL(*token_, VerifyAccessToken(_, _)).WillRepeatedly(Return(PERMISSION_GRANTED));
464 
465     uint32_t code = static_cast<uint32_t>(DHMsgInterfaceCode::REG_DH_SINK_STATUS_LISTNER);
466     MessageParcel data;
467     MessageParcel reply;
468     MessageOption option;
469     data.WriteInterfaceToken(stubTest_->GetDescriptor());
470     sptr<IRemoteObject> listener(new MockHDSinkStatusListenerStub());
471     data.WriteRemoteObject(listener);
472     auto ret = stubTest_->OnRemoteRequest(code, data, reply, option);
473     EXPECT_EQ(DH_FWK_SUCCESS, ret);
474 }
475 
476 HWTEST_F(DistributedHardwareStubTest, OnRemoteRequest_030, TestSize.Level1)
477 {
478     ASSERT_TRUE(stubTest_ != nullptr);
479     ASSERT_TRUE(token_ != nullptr);
480     EXPECT_CALL(*token_, VerifyAccessToken(_, _)).WillRepeatedly(Return(PERMISSION_GRANTED));
481 
482     uint32_t code = static_cast<uint32_t>(DHMsgInterfaceCode::UNREG_DH_SINK_STATUS_LISTNER);
483     MessageParcel data;
484     MessageParcel reply;
485     MessageOption option;
486     data.WriteInterfaceToken(stubTest_->GetDescriptor());
487     sptr<IRemoteObject> listener(new MockHDSinkStatusListenerStub());
488     data.WriteRemoteObject(listener);
489     auto ret = stubTest_->OnRemoteRequest(code, data, reply, option);
490     EXPECT_EQ(DH_FWK_SUCCESS, ret);
491 }
492 
493 HWTEST_F(DistributedHardwareStubTest, OnRemoteRequest_031, TestSize.Level1)
494 {
495     ASSERT_TRUE(stubTest_ != nullptr);
496     ASSERT_TRUE(token_ != nullptr);
497     EXPECT_CALL(*token_, VerifyAccessToken(_, _)).WillRepeatedly(Return(PERMISSION_GRANTED));
498 
499     uint32_t code = static_cast<uint32_t>(DHMsgInterfaceCode::REG_DH_SOURCE_STATUS_LISTNER);
500     MessageParcel data;
501     MessageParcel reply;
502     MessageOption option;
503     data.WriteInterfaceToken(stubTest_->GetDescriptor());
504     data.WriteString("networkId_test");
505     sptr<IRemoteObject> listener(new MockHDSourceStatusListenerStub());
506     data.WriteRemoteObject(listener);
507     auto ret = stubTest_->OnRemoteRequest(code, data, reply, option);
508     EXPECT_EQ(DH_FWK_SUCCESS, ret);
509 }
510 
511 HWTEST_F(DistributedHardwareStubTest, OnRemoteRequest_032, TestSize.Level1)
512 {
513     ASSERT_TRUE(stubTest_ != nullptr);
514     ASSERT_TRUE(token_ != nullptr);
515     EXPECT_CALL(*token_, VerifyAccessToken(_, _)).WillRepeatedly(Return(PERMISSION_GRANTED));
516 
517     uint32_t code = static_cast<uint32_t>(DHMsgInterfaceCode::UNREG_DH_SOURCE_STATUS_LISTNER);
518     MessageParcel data;
519     MessageParcel reply;
520     MessageOption option;
521     data.WriteInterfaceToken(stubTest_->GetDescriptor());
522     data.WriteString("networkId_test");
523     sptr<IRemoteObject> listener(new MockHDSourceStatusListenerStub());
524     data.WriteRemoteObject(listener);
525     auto ret = stubTest_->OnRemoteRequest(code, data, reply, option);
526     EXPECT_EQ(DH_FWK_SUCCESS, ret);
527 }
528 
529 HWTEST_F(DistributedHardwareStubTest, OnRemoteRequest_033, TestSize.Level1)
530 {
531     ASSERT_TRUE(stubTest_ != nullptr);
532     ASSERT_TRUE(token_ != nullptr);
533     EXPECT_CALL(*token_, VerifyAccessToken(_, _)).WillRepeatedly(Return(PERMISSION_GRANTED));
534 
535     uint32_t code = static_cast<uint32_t>(DHMsgInterfaceCode::ENABLE_SINK);
536     MessageParcel data;
537     MessageParcel reply;
538     MessageOption option;
539     size_t descriptorCount = 1;
540     data.WriteInterfaceToken(stubTest_->GetDescriptor());
541     data.WriteInt32(descriptorCount);
542     data.WriteInt32(static_cast<int32_t>(DHType::AUDIO));
543     data.WriteString("id_test");
544     auto ret = stubTest_->OnRemoteRequest(code, data, reply, option);
545     EXPECT_EQ(DH_FWK_SUCCESS, ret);
546 }
547 
548 HWTEST_F(DistributedHardwareStubTest, OnRemoteRequest_034, TestSize.Level1)
549 {
550     ASSERT_TRUE(stubTest_ != nullptr);
551     ASSERT_TRUE(token_ != nullptr);
552     EXPECT_CALL(*token_, VerifyAccessToken(_, _)).WillRepeatedly(Return(PERMISSION_GRANTED));
553 
554     uint32_t code = static_cast<uint32_t>(DHMsgInterfaceCode::DISABLE_SINK);
555     MessageParcel data;
556     MessageParcel reply;
557     MessageOption option;
558     size_t descriptorCount = 1;
559     data.WriteInterfaceToken(stubTest_->GetDescriptor());
560     data.WriteInt32(descriptorCount);
561     data.WriteInt32(static_cast<int32_t>(DHType::AUDIO));
562     data.WriteString("id_test");
563     auto ret = stubTest_->OnRemoteRequest(code, data, reply, option);
564     EXPECT_EQ(DH_FWK_SUCCESS, ret);
565 }
566 
567 HWTEST_F(DistributedHardwareStubTest, OnRemoteRequest_035, TestSize.Level1)
568 {
569     ASSERT_TRUE(stubTest_ != nullptr);
570     ASSERT_TRUE(token_ != nullptr);
571     EXPECT_CALL(*token_, VerifyAccessToken(_, _)).WillRepeatedly(Return(PERMISSION_GRANTED));
572 
573     uint32_t code = static_cast<uint32_t>(DHMsgInterfaceCode::ENABLE_SOURCE);
574     MessageParcel data;
575     MessageParcel reply;
576     MessageOption option;
577     size_t descriptorCount = 1;
578     data.WriteInterfaceToken(stubTest_->GetDescriptor());
579     data.WriteInt32(descriptorCount);
580     data.WriteInt32(static_cast<int32_t>(DHType::AUDIO));
581     data.WriteString("id_test");
582     auto ret = stubTest_->OnRemoteRequest(code, data, reply, option);
583     EXPECT_EQ(DH_FWK_SUCCESS, ret);
584 }
585 
586 HWTEST_F(DistributedHardwareStubTest, OnRemoteRequest_036, TestSize.Level1)
587 {
588     ASSERT_TRUE(stubTest_ != nullptr);
589     ASSERT_TRUE(token_ != nullptr);
590     EXPECT_CALL(*token_, VerifyAccessToken(_, _)).WillRepeatedly(Return(PERMISSION_GRANTED));
591 
592     uint32_t code = static_cast<uint32_t>(DHMsgInterfaceCode::DISABLE_SOURCE);
593     MessageParcel data;
594     MessageParcel reply;
595     MessageOption option;
596     size_t descriptorCount = 1;
597     data.WriteInterfaceToken(stubTest_->GetDescriptor());
598     data.WriteInt32(descriptorCount);
599     data.WriteInt32(static_cast<int32_t>(DHType::AUDIO));
600     data.WriteString("id_test");
601     auto ret = stubTest_->OnRemoteRequest(code, data, reply, option);
602     EXPECT_EQ(DH_FWK_SUCCESS, ret);
603 }
604 
605 /**
606  * @tc.name: RegisterPublisherListenerInner_001
607  * @tc.desc: Verify the RegisterPublisherListenerInner function
608  * @tc.type: FUNC
609  * @tc.require: AR000GHSJM
610  */
611 HWTEST_F(DistributedHardwareStubTest, RegisterPublisherListenerInner_001, TestSize.Level1)
612 {
613     ASSERT_TRUE(stubTest_ != nullptr);
614     MessageParcel data;
615     MessageParcel reply;
616     EXPECT_NE(DH_FWK_SUCCESS, stubTest_->RegisterPublisherListenerInner(data, reply));
617 }
618 
619 /**
620  * @tc.name: UnregisterPublisherListenerInner_001
621  * @tc.desc: Verify the UnregisterPublisherListenerInner function
622  * @tc.type: FUNC
623  * @tc.require: AR000GHSJM
624  */
625 HWTEST_F(DistributedHardwareStubTest, UnregisterPublisherListenerInner_001, TestSize.Level1)
626 {
627     ASSERT_TRUE(stubTest_ != nullptr);
628     MessageParcel data;
629     MessageParcel reply;
630     EXPECT_NE(DH_FWK_SUCCESS, stubTest_->UnregisterPublisherListenerInner(data, reply));
631 }
632 
633 /**
634  * @tc.name: PublishMessageInner_001
635  * @tc.desc: Verify the PublishMessageInner function
636  * @tc.type: FUNC
637  * @tc.require: AR000GHSJM
638  */
639 HWTEST_F(DistributedHardwareStubTest, PublishMessageInner_001, TestSize.Level1)
640 {
641     ASSERT_TRUE(stubTest_ != nullptr);
642     MessageParcel data;
643     MessageParcel reply;
644     EXPECT_NE(DH_FWK_SUCCESS, stubTest_->PublishMessageInner(data, reply));
645 }
646 
647 /**
648  * @tc.name: ValidTopic_001
649  * @tc.desc: Verify the ValidTopic function
650  * @tc.type: FUNC
651  * @tc.require: AR000GHSJM
652  */
653 HWTEST_F(DistributedHardwareStubTest, ValidTopic_001, TestSize.Level1)
654 {
655     ASSERT_TRUE(stubTest_ != nullptr);
656     uint32_t topic = static_cast<uint32_t>(DHTopic::TOPIC_MIN);
657     EXPECT_EQ(false, stubTest_->ValidTopic(topic));
658 
659     uint32_t topic1 = static_cast<uint32_t>(DHTopic::TOPIC_MAX);
660     EXPECT_EQ(false, stubTest_->ValidTopic(topic1));
661 
662     uint32_t topic2 = static_cast<uint32_t>(DHTopic::TOPIC_START_DSCREEN);
663     EXPECT_EQ(true, stubTest_->ValidTopic(topic2));
664 }
665 
666 /**
667  * @tc.name: ValidQueryLocalSpec_001
668  * @tc.desc: Verify the ValidQueryLocalSpec function
669  * @tc.type: FUNC
670  * @tc.require: AR000GHSJM
671  */
672 HWTEST_F(DistributedHardwareStubTest, ValidQueryLocalSpec_001, TestSize.Level1)
673 {
674     ASSERT_TRUE(stubTest_ != nullptr);
675     uint32_t spec = 1;
676     EXPECT_EQ(true, stubTest_->ValidQueryLocalSpec(spec));
677 }
678 
679 /**
680  * @tc.name: ValidQueryLocalSpec_002
681  * @tc.desc: Verify the ValidQueryLocalSpec function
682  * @tc.type: FUNC
683  * @tc.require: AR000GHSJM
684  */
685 HWTEST_F(DistributedHardwareStubTest, ValidQueryLocalSpec_002, TestSize.Level1)
686 {
687     ASSERT_TRUE(stubTest_ != nullptr);
688     uint32_t spec = 0;
689     EXPECT_EQ(false, stubTest_->ValidQueryLocalSpec(spec));
690     spec = 5;
691     EXPECT_EQ(false, stubTest_->ValidQueryLocalSpec(spec));
692 }
693 
694 /**
695  * @tc.name: LoadDistributedHDFInner_001
696  * @tc.desc: Verify the LoadDistributedHDFInner function
697  * @tc.type: FUNC
698  * @tc.require: AR000GHSJM
699  */
700 HWTEST_F(DistributedHardwareStubTest, LoadDistributedHDFInner_001, TestSize.Level1)
701 {
702     ASSERT_TRUE(stubTest_ != nullptr);
703     ASSERT_TRUE(token_ != nullptr);
704     EXPECT_CALL(*token_, VerifyAccessToken(_, _)).WillRepeatedly(Return(PERMISSION_GRANTED));
705     MessageParcel data;
706     MessageParcel reply;
707     EXPECT_EQ(DH_FWK_SUCCESS, stubTest_->LoadDistributedHDFInner(data, reply));
708 }
709 
710 /**
711  * @tc.name: LoadDistributedHDFInner_002
712  * @tc.desc: Verify the LoadDistributedHDFInner function
713  * @tc.type: FUNC
714  * @tc.require: AR000GHSJM
715  */
716 HWTEST_F(DistributedHardwareStubTest, LoadDistributedHDFInner_002, TestSize.Level1)
717 {
718     ASSERT_TRUE(stubTest_ != nullptr);
719     ASSERT_TRUE(token_ != nullptr);
720     EXPECT_CALL(*token_, VerifyAccessToken(_, _)).WillRepeatedly(Return(PERMISSION_GRANTED));
721     MessageParcel data;
722     MessageParcel reply;
723     auto listener = sptr<MockIPublisherListener>(new MockIPublisherListener());
724     data.WriteUint32(static_cast<uint32_t>(DHType::AUDIO));
725     data.WriteRemoteObject(listener->AsObject());
726     EXPECT_EQ(DH_FWK_SUCCESS, stubTest_->LoadDistributedHDFInner(data, reply));
727 }
728 
729 /**
730  * @tc.name: LoadDistributedHDFInner_003
731  * @tc.desc: Verify the LoadDistributedHDFInner function
732  * @tc.type: FUNC
733  * @tc.require: AR000GHSJM
734  */
735 HWTEST_F(DistributedHardwareStubTest, LoadDistributedHDFInner_003, TestSize.Level1)
736 {
737     ASSERT_TRUE(stubTest_ != nullptr);
738     ASSERT_TRUE(token_ != nullptr);
739     EXPECT_CALL(*token_, VerifyAccessToken(_, _)).WillRepeatedly(Return(PERMISSION_GRANTED));
740     MessageParcel data;
741     MessageParcel reply;
742     auto listener = sptr<MockIPublisherListener>(new MockIPublisherListener());
743     data.WriteUint32(static_cast<uint32_t>(DHType::CAMERA));
744     data.WriteRemoteObject(listener->AsObject());
745     EXPECT_EQ(DH_FWK_SUCCESS, stubTest_->LoadDistributedHDFInner(data, reply));
746 }
747 
748 /**
749  * @tc.name: UnLoadDistributedHDFInner_001
750  * @tc.desc: Verify the UnLoadDistributedHDFInner function
751  * @tc.type: FUNC
752  * @tc.require: AR000GHSJM
753  */
754 HWTEST_F(DistributedHardwareStubTest, UnLoadDistributedHDFInner_001, TestSize.Level1)
755 {
756     ASSERT_TRUE(stubTest_ != nullptr);
757     ASSERT_TRUE(token_ != nullptr);
758     EXPECT_CALL(*token_, VerifyAccessToken(_, _)).WillRepeatedly(Return(PERMISSION_GRANTED));
759     MessageParcel data;
760     MessageParcel reply;
761     EXPECT_EQ(DH_FWK_SUCCESS, stubTest_->UnLoadDistributedHDFInner(data, reply));
762 }
763 
764 /**
765  * @tc.name: UnLoadDistributedHDFInner_002
766  * @tc.desc: Verify the UnLoadDistributedHDFInner function
767  * @tc.type: FUNC
768  * @tc.require: AR000GHSJM
769  */
770 HWTEST_F(DistributedHardwareStubTest, UnLoadDistributedHDFInner_002, TestSize.Level1)
771 {
772     ASSERT_TRUE(stubTest_ != nullptr);
773     ASSERT_TRUE(token_ != nullptr);
774     EXPECT_CALL(*token_, VerifyAccessToken(_, _)).WillRepeatedly(Return(PERMISSION_GRANTED));
775     MessageParcel data;
776     MessageParcel reply;
777     auto listener = sptr<MockIPublisherListener>(new MockIPublisherListener());
778     data.WriteUint32(static_cast<uint32_t>(DHType::AUDIO));
779     data.WriteRemoteObject(listener->AsObject());
780     EXPECT_EQ(DH_FWK_SUCCESS, stubTest_->UnLoadDistributedHDFInner(data, reply));
781 }
782 
783 /**
784  * @tc.name: UnLoadDistributedHDFInner_003
785  * @tc.desc: Verify the UnLoadDistributedHDFInner function
786  * @tc.type: FUNC
787  * @tc.require: AR000GHSJM
788  */
789 HWTEST_F(DistributedHardwareStubTest, UnLoadDistributedHDFInner_003, TestSize.Level1)
790 {
791     ASSERT_TRUE(stubTest_ != nullptr);
792     ASSERT_TRUE(token_ != nullptr);
793     EXPECT_CALL(*token_, VerifyAccessToken(_, _)).WillRepeatedly(Return(PERMISSION_GRANTED));
794     MessageParcel data;
795     MessageParcel reply;
796     auto listener = sptr<MockIPublisherListener>(new MockIPublisherListener());
797     data.WriteUint32(static_cast<uint32_t>(DHType::CAMERA));
798     data.WriteRemoteObject(listener->AsObject());
799     EXPECT_EQ(DH_FWK_SUCCESS, stubTest_->UnLoadDistributedHDFInner(data, reply));
800 }
801 } // namespace DistributedHardware
802 } // namespace OHOS
803