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 using namespace testing::ext;
23
24 namespace OHOS {
25 namespace DistributedHardware {
SetUpTestCase(void)26 void DistributedHardwareStubTest::SetUpTestCase(void) {}
27
TearDownTestCase(void)28 void DistributedHardwareStubTest::TearDownTestCase(void) {}
29
SetUp()30 void DistributedHardwareStubTest::SetUp()
31 {
32 stubTest_ = std::make_shared<MockDistributedHardwareStub>();
33 }
34
TearDown()35 void DistributedHardwareStubTest::TearDown()
36 {
37 stubTest_ = nullptr;
38 }
39
40 /**
41 * @tc.name: OnRemoteRequest_001
42 * @tc.desc: Verify the OnRemoteRequest function
43 * @tc.type: FUNC
44 * @tc.require: AR000GHSJM
45 */
46 HWTEST_F(DistributedHardwareStubTest, OnRemoteRequest_001, TestSize.Level0)
47 {
48 ASSERT_TRUE(stubTest_ != nullptr);
49 uint32_t code = 0;
50 MessageParcel data;
51 MessageParcel reply;
52 MessageOption option;
53 EXPECT_NE(DH_FWK_SUCCESS, stubTest_->OnRemoteRequest(code, data, reply, option));
54 }
55
56 /**
57 * @tc.name: OnRemoteRequest_002
58 * @tc.desc: Verify the OnRemoteRequest function
59 * @tc.type: FUNC
60 * @tc.require: AR000GHSJM
61 */
62 HWTEST_F(DistributedHardwareStubTest, OnRemoteRequest_002, TestSize.Level0)
63 {
64 ASSERT_TRUE(stubTest_ != nullptr);
65 uint32_t code = 0;
66 MessageParcel data;
67 MessageParcel reply;
68 MessageOption option;
69 EXPECT_EQ(ERR_INVALID_DATA, stubTest_->OnRemoteRequest(code, data, reply, option));
70 }
71
72 HWTEST_F(DistributedHardwareStubTest, OnRemoteRequest_003, TestSize.Level0)
73 {
74 ASSERT_TRUE(stubTest_ != nullptr);
75 uint32_t code = static_cast<uint32_t>(DHMsgInterfaceCode::REG_PUBLISHER_LISTNER);
76 MessageParcel data;
77 MessageParcel reply;
78 MessageOption option;
79 data.WriteInterfaceToken(stubTest_->GetDescriptor());
80 uint32_t topicInt = (uint32_t)DHTopic::TOPIC_MIN;
81 data.WriteUint32(topicInt);
82 auto ret = stubTest_->OnRemoteRequest(code, data, reply, option);
83 EXPECT_EQ(ERR_DH_FWK_ACCESS_PERMISSION_CHECK_FAIL, ret);
84 }
85
86 HWTEST_F(DistributedHardwareStubTest, OnRemoteRequest_004, TestSize.Level0)
87 {
88 ASSERT_TRUE(stubTest_ != nullptr);
89 uint32_t code = static_cast<uint32_t>(DHMsgInterfaceCode::PUBLISH_MESSAGE);
90 MessageParcel data;
91 MessageParcel reply;
92 MessageOption option;
93 data.WriteInterfaceToken(stubTest_->GetDescriptor());
94 uint32_t topicInt = (uint32_t)DHTopic::TOPIC_MIN;
95 data.WriteUint32(topicInt);
96 auto ret = stubTest_->OnRemoteRequest(code, data, reply, option);
97 EXPECT_EQ(ERR_DH_FWK_ACCESS_PERMISSION_CHECK_FAIL, ret);
98 }
99
100 HWTEST_F(DistributedHardwareStubTest, OnRemoteRequest_005, TestSize.Level0)
101 {
102 ASSERT_TRUE(stubTest_ != nullptr);
103 uint32_t code = static_cast<uint32_t>(DHMsgInterfaceCode::INIT_CTL_CEN);
104 MessageParcel data;
105 MessageParcel reply;
106 MessageOption option;
107 data.WriteInterfaceToken(stubTest_->GetDescriptor());
108 uint32_t transRole = static_cast<uint32_t>(TransRole::UNKNOWN);
109 data.WriteUint32(transRole);
110 auto ret = stubTest_->OnRemoteRequest(code, data, reply, option);
111 EXPECT_EQ(ERR_DH_FWK_ACCESS_PERMISSION_CHECK_FAIL, ret);
112 }
113
114 HWTEST_F(DistributedHardwareStubTest, OnRemoteRequest_006, TestSize.Level0)
115 {
116 ASSERT_TRUE(stubTest_ != nullptr);
117 uint32_t code = static_cast<uint32_t>(DHMsgInterfaceCode::RELEASE_CTL_CEN);
118 MessageParcel data;
119 MessageParcel reply;
120 MessageOption option;
121 data.WriteInterfaceToken(stubTest_->GetDescriptor());
122 int32_t engineId = 1;
123 data.WriteInt32(engineId);
124 auto ret = stubTest_->OnRemoteRequest(code, data, reply, option);
125 EXPECT_EQ(ERR_DH_FWK_ACCESS_PERMISSION_CHECK_FAIL, ret);
126 }
127
128 HWTEST_F(DistributedHardwareStubTest, OnRemoteRequest_007, TestSize.Level0)
129 {
130 ASSERT_TRUE(stubTest_ != nullptr);
131 uint32_t code = static_cast<uint32_t>(DHMsgInterfaceCode::CREATE_CTL_CEN_CHANNEL);
132 MessageParcel data;
133 MessageParcel reply;
134 MessageOption option;
135 data.WriteInterfaceToken(stubTest_->GetDescriptor());
136 int32_t engineId = 1;
137 std::string peerDevId = "peerDevId_test";
138 data.WriteInt32(engineId);
139 data.WriteString(peerDevId);
140 auto ret = stubTest_->OnRemoteRequest(code, data, reply, option);
141 EXPECT_EQ(ERR_DH_FWK_ACCESS_PERMISSION_CHECK_FAIL, ret);
142 }
143
144 HWTEST_F(DistributedHardwareStubTest, OnRemoteRequest_008, TestSize.Level0)
145 {
146 ASSERT_TRUE(stubTest_ != nullptr);
147 uint32_t code = static_cast<uint32_t>(DHMsgInterfaceCode::NOTIFY_AV_EVENT);
148 MessageParcel data;
149 MessageParcel reply;
150 MessageOption option;
151 data.WriteInterfaceToken(stubTest_->GetDescriptor());
152 int32_t engineId = 1;
153 std::string peerDevId = "peerDevId_test";
154 uint32_t type = 1;
155 std::string content = "content_test";
156 data.WriteInt32(engineId);
157 data.WriteString(peerDevId);
158 data.WriteUint32(type);
159 data.WriteString(content);
160 auto ret = stubTest_->OnRemoteRequest(code, data, reply, option);
161 EXPECT_EQ(ERR_DH_FWK_ACCESS_PERMISSION_CHECK_FAIL, ret);
162 }
163
164 HWTEST_F(DistributedHardwareStubTest, OnRemoteRequest_009, TestSize.Level0)
165 {
166 ASSERT_TRUE(stubTest_ != nullptr);
167 uint32_t code = static_cast<uint32_t>(DHMsgInterfaceCode::QUERY_LOCAL_SYS_SPEC);
168 MessageParcel data;
169 MessageParcel reply;
170 MessageOption option;
171 data.WriteInterfaceToken(stubTest_->GetDescriptor());
172 uint32_t specInt = static_cast<uint32_t>(QueryLocalSysSpecType::MIN);
173 data.WriteUint32(specInt);
174 auto ret = stubTest_->OnRemoteRequest(code, data, reply, option);
175 EXPECT_EQ(ERR_DH_FWK_ACCESS_PERMISSION_CHECK_FAIL, ret);
176 }
177
178 HWTEST_F(DistributedHardwareStubTest, OnRemoteRequest_010, TestSize.Level0)
179 {
180 ASSERT_TRUE(stubTest_ != nullptr);
181 uint32_t code = static_cast<uint32_t>(DHMsgInterfaceCode::NOTIFY_SOURCE_DEVICE_REMOTE_DMSDP_STARTED);
182 MessageParcel data;
183 MessageParcel reply;
184 MessageOption option;
185 data.WriteInterfaceToken(stubTest_->GetDescriptor());
186 std::string deviceId = "deviceId_test";
187 data.WriteString(deviceId);
188 auto ret = stubTest_->OnRemoteRequest(code, data, reply, option);
189 EXPECT_EQ(ERR_DH_FWK_ACCESS_PERMISSION_CHECK_FAIL, ret);
190 }
191
192 HWTEST_F(DistributedHardwareStubTest, OnRemoteRequest_011, TestSize.Level0)
193 {
194 ASSERT_TRUE(stubTest_ != nullptr);
195 uint32_t code = static_cast<uint32_t>(DHMsgInterfaceCode::PAUSE_DISTRIBUTED_HARDWARE);
196 MessageParcel data;
197 MessageParcel reply;
198 MessageOption option;
199 data.WriteInterfaceToken(stubTest_->GetDescriptor());
200 auto ret = stubTest_->OnRemoteRequest(code, data, reply, option);
201 EXPECT_EQ(ERR_DH_FWK_IS_SYSTEM_HAP_CHECK_FAIL, ret);
202 }
203
204 HWTEST_F(DistributedHardwareStubTest, OnRemoteRequest_012, TestSize.Level0)
205 {
206 ASSERT_TRUE(stubTest_ != nullptr);
207 uint32_t code = static_cast<uint32_t>(DHMsgInterfaceCode::RESUME_DISTRIBUTED_HARDWARE);
208 MessageParcel data;
209 MessageParcel reply;
210 MessageOption option;
211 data.WriteInterfaceToken(stubTest_->GetDescriptor());
212 auto ret = stubTest_->OnRemoteRequest(code, data, reply, option);
213 EXPECT_EQ(ERR_DH_FWK_IS_SYSTEM_HAP_CHECK_FAIL, ret);
214 }
215
216 HWTEST_F(DistributedHardwareStubTest, OnRemoteRequest_013, TestSize.Level0)
217 {
218 ASSERT_TRUE(stubTest_ != nullptr);
219 uint32_t code = static_cast<uint32_t>(DHMsgInterfaceCode::STOP_DISTRIBUTED_HARDWARE);
220 MessageParcel data;
221 MessageParcel reply;
222 MessageOption option;
223 data.WriteInterfaceToken(stubTest_->GetDescriptor());
224 auto ret = stubTest_->OnRemoteRequest(code, data, reply, option);
225 EXPECT_EQ(ERR_DH_FWK_IS_SYSTEM_HAP_CHECK_FAIL, ret);
226 }
227
228 HWTEST_F(DistributedHardwareStubTest, OnRemoteRequest_014, TestSize.Level0)
229 {
230 ASSERT_TRUE(stubTest_ != nullptr);
231 uint32_t code = static_cast<uint32_t>(DHMsgInterfaceCode::UNREG_PUBLISHER_LISTENER);
232 MessageParcel data;
233 MessageParcel reply;
234 MessageOption option;
235 data.WriteInterfaceToken(stubTest_->GetDescriptor());
236 uint32_t topicInt = (uint32_t)DHTopic::TOPIC_MIN;
237 data.WriteUint32(topicInt);
238 auto ret = stubTest_->OnRemoteRequest(code, data, reply, option);
239 EXPECT_EQ(ERR_DH_FWK_ACCESS_PERMISSION_CHECK_FAIL, ret);
240 }
241
242 HWTEST_F(DistributedHardwareStubTest, OnRemoteRequest_015, TestSize.Level0)
243 {
244 ASSERT_TRUE(stubTest_ != nullptr);
245 uint32_t code = static_cast<uint32_t>(DHMsgInterfaceCode::REGISTER_CTL_CEN_CALLBACK);
246 MessageParcel data;
247 MessageParcel reply;
248 MessageOption option;
249 data.WriteInterfaceToken(stubTest_->GetDescriptor());
250 auto ret = stubTest_->OnRemoteRequest(code, data, reply, option);
251 EXPECT_EQ(ERR_DH_FWK_ACCESS_PERMISSION_CHECK_FAIL, ret);
252 }
253
254 HWTEST_F(DistributedHardwareStubTest, OnRemoteRequest_016, TestSize.Level0)
255 {
256 ASSERT_TRUE(stubTest_ != nullptr);
257 uint32_t code = static_cast<uint32_t>(DHMsgInterfaceCode::GET_DISTRIBUTED_HARDWARE);
258 MessageParcel data;
259 MessageParcel reply;
260 MessageOption option;
261 data.WriteInterfaceToken(stubTest_->GetDescriptor());
262 data.WriteString("netWorkId_test");
263 auto ret = stubTest_->OnRemoteRequest(code, data, reply, option);
264 EXPECT_EQ(ERR_DH_FWK_ACCESS_PERMISSION_CHECK_FAIL, ret);
265 }
266
267 HWTEST_F(DistributedHardwareStubTest, OnRemoteRequest_017, TestSize.Level0)
268 {
269 ASSERT_TRUE(stubTest_ != nullptr);
270 uint32_t code = static_cast<uint32_t>(DHMsgInterfaceCode::REG_DH_SINK_STATUS_LISTNER);
271 MessageParcel data;
272 MessageParcel reply;
273 MessageOption option;
274 data.WriteInterfaceToken(stubTest_->GetDescriptor());
275 auto ret = stubTest_->OnRemoteRequest(code, data, reply, option);
276 EXPECT_EQ(ERR_DH_FWK_ACCESS_PERMISSION_CHECK_FAIL, ret);
277 }
278
279 HWTEST_F(DistributedHardwareStubTest, OnRemoteRequest_018, TestSize.Level0)
280 {
281 ASSERT_TRUE(stubTest_ != nullptr);
282 uint32_t code = static_cast<uint32_t>(DHMsgInterfaceCode::UNREG_DH_SINK_STATUS_LISTNER);
283 MessageParcel data;
284 MessageParcel reply;
285 MessageOption option;
286 data.WriteInterfaceToken(stubTest_->GetDescriptor());
287 auto ret = stubTest_->OnRemoteRequest(code, data, reply, option);
288 EXPECT_EQ(ERR_DH_FWK_ACCESS_PERMISSION_CHECK_FAIL, ret);
289 }
290
291 HWTEST_F(DistributedHardwareStubTest, OnRemoteRequest_019, TestSize.Level0)
292 {
293 ASSERT_TRUE(stubTest_ != nullptr);
294 uint32_t code = static_cast<uint32_t>(DHMsgInterfaceCode::REG_DH_SOURCE_STATUS_LISTNER);
295 MessageParcel data;
296 MessageParcel reply;
297 MessageOption option;
298 data.WriteInterfaceToken(stubTest_->GetDescriptor());
299 auto ret = stubTest_->OnRemoteRequest(code, data, reply, option);
300 EXPECT_EQ(ERR_DH_FWK_ACCESS_PERMISSION_CHECK_FAIL, ret);
301 }
302
303 HWTEST_F(DistributedHardwareStubTest, OnRemoteRequest_020, TestSize.Level0)
304 {
305 ASSERT_TRUE(stubTest_ != nullptr);
306 uint32_t code = static_cast<uint32_t>(DHMsgInterfaceCode::UNREG_DH_SOURCE_STATUS_LISTNER);
307 MessageParcel data;
308 MessageParcel reply;
309 MessageOption option;
310 data.WriteInterfaceToken(stubTest_->GetDescriptor());
311 auto ret = stubTest_->OnRemoteRequest(code, data, reply, option);
312 EXPECT_EQ(ERR_DH_FWK_ACCESS_PERMISSION_CHECK_FAIL, ret);
313 }
314
315 HWTEST_F(DistributedHardwareStubTest, OnRemoteRequest_021, TestSize.Level0)
316 {
317 ASSERT_TRUE(stubTest_ != nullptr);
318 uint32_t code = static_cast<uint32_t>(DHMsgInterfaceCode::ENABLE_SINK);
319 MessageParcel data;
320 MessageParcel reply;
321 MessageOption option;
322 data.WriteInterfaceToken(stubTest_->GetDescriptor());
323 data.WriteInt32(1);
324 data.WriteInt32(static_cast<int32_t>(DHType::AUDIO));
325 data.WriteString("id_test");
326 auto ret = stubTest_->OnRemoteRequest(code, data, reply, option);
327 EXPECT_EQ(ERR_DH_FWK_ACCESS_PERMISSION_CHECK_FAIL, ret);
328 }
329
330 HWTEST_F(DistributedHardwareStubTest, OnRemoteRequest_022, TestSize.Level0)
331 {
332 ASSERT_TRUE(stubTest_ != nullptr);
333 uint32_t code = static_cast<uint32_t>(DHMsgInterfaceCode::DISABLE_SINK);
334 MessageParcel data;
335 MessageParcel reply;
336 MessageOption option;
337 data.WriteInterfaceToken(stubTest_->GetDescriptor());
338 data.WriteInt32(1);
339 data.WriteInt32(static_cast<int32_t>(DHType::AUDIO));
340 data.WriteString("id_test");
341 auto ret = stubTest_->OnRemoteRequest(code, data, reply, option);
342 EXPECT_EQ(ERR_DH_FWK_ACCESS_PERMISSION_CHECK_FAIL, ret);
343 }
344
345 HWTEST_F(DistributedHardwareStubTest, OnRemoteRequest_023, TestSize.Level0)
346 {
347 ASSERT_TRUE(stubTest_ != nullptr);
348 uint32_t code = static_cast<uint32_t>(DHMsgInterfaceCode::ENABLE_SOURCE);
349 MessageParcel data;
350 MessageParcel reply;
351 MessageOption option;
352 data.WriteInterfaceToken(stubTest_->GetDescriptor());
353 data.WriteInt32(1);
354 data.WriteInt32(static_cast<int32_t>(DHType::AUDIO));
355 data.WriteString("id_test");
356 auto ret = stubTest_->OnRemoteRequest(code, data, reply, option);
357 EXPECT_EQ(ERR_DH_FWK_ACCESS_PERMISSION_CHECK_FAIL, ret);
358 }
359
360 HWTEST_F(DistributedHardwareStubTest, OnRemoteRequest_024, TestSize.Level0)
361 {
362 ASSERT_TRUE(stubTest_ != nullptr);
363 uint32_t code = static_cast<uint32_t>(DHMsgInterfaceCode::DISABLE_SOURCE);
364 MessageParcel data;
365 MessageParcel reply;
366 MessageOption option;
367 data.WriteInterfaceToken(stubTest_->GetDescriptor());
368 data.WriteInt32(1);
369 data.WriteInt32(static_cast<int32_t>(DHType::AUDIO));
370 data.WriteString("id_test");
371 auto ret = stubTest_->OnRemoteRequest(code, data, reply, option);
372 EXPECT_EQ(ERR_DH_FWK_ACCESS_PERMISSION_CHECK_FAIL, ret);
373 }
374
375 /**
376 * @tc.name: RegisterPublisherListenerInner_001
377 * @tc.desc: Verify the RegisterPublisherListenerInner function
378 * @tc.type: FUNC
379 * @tc.require: AR000GHSJM
380 */
381 HWTEST_F(DistributedHardwareStubTest, RegisterPublisherListenerInner_001, TestSize.Level0)
382 {
383 ASSERT_TRUE(stubTest_ != nullptr);
384 MessageParcel data;
385 MessageParcel reply;
386 EXPECT_NE(DH_FWK_SUCCESS, stubTest_->RegisterPublisherListenerInner(data, reply));
387 }
388
389 /**
390 * @tc.name: UnregisterPublisherListenerInner_001
391 * @tc.desc: Verify the UnregisterPublisherListenerInner function
392 * @tc.type: FUNC
393 * @tc.require: AR000GHSJM
394 */
395 HWTEST_F(DistributedHardwareStubTest, UnregisterPublisherListenerInner_001, TestSize.Level0)
396 {
397 ASSERT_TRUE(stubTest_ != nullptr);
398 MessageParcel data;
399 MessageParcel reply;
400 EXPECT_NE(DH_FWK_SUCCESS, stubTest_->UnregisterPublisherListenerInner(data, reply));
401 }
402
403 /**
404 * @tc.name: PublishMessageInner_001
405 * @tc.desc: Verify the PublishMessageInner function
406 * @tc.type: FUNC
407 * @tc.require: AR000GHSJM
408 */
409 HWTEST_F(DistributedHardwareStubTest, PublishMessageInner_001, TestSize.Level0)
410 {
411 ASSERT_TRUE(stubTest_ != nullptr);
412 MessageParcel data;
413 MessageParcel reply;
414 EXPECT_NE(DH_FWK_SUCCESS, stubTest_->PublishMessageInner(data, reply));
415 }
416
417 /**
418 * @tc.name: ValidTopic_001
419 * @tc.desc: Verify the ValidTopic function
420 * @tc.type: FUNC
421 * @tc.require: AR000GHSJM
422 */
423 HWTEST_F(DistributedHardwareStubTest, ValidTopic_001, TestSize.Level0)
424 {
425 ASSERT_TRUE(stubTest_ != nullptr);
426 uint32_t topic = static_cast<uint32_t>(DHTopic::TOPIC_MIN);
427 EXPECT_EQ(false, stubTest_->ValidTopic(topic));
428
429 uint32_t topic1 = static_cast<uint32_t>(DHTopic::TOPIC_MAX);
430 EXPECT_EQ(false, stubTest_->ValidTopic(topic1));
431
432 uint32_t topic2 = static_cast<uint32_t>(DHTopic::TOPIC_START_DSCREEN);
433 EXPECT_EQ(true, stubTest_->ValidTopic(topic2));
434 }
435
436 /**
437 * @tc.name: ValidQueryLocalSpec_001
438 * @tc.desc: Verify the ValidQueryLocalSpec function
439 * @tc.type: FUNC
440 * @tc.require: AR000GHSJM
441 */
442 HWTEST_F(DistributedHardwareStubTest, ValidQueryLocalSpec_001, TestSize.Level0)
443 {
444 ASSERT_TRUE(stubTest_ != nullptr);
445 uint32_t spec = 1;
446 EXPECT_EQ(true, stubTest_->ValidQueryLocalSpec(spec));
447 }
448
449 /**
450 * @tc.name: ValidQueryLocalSpec_002
451 * @tc.desc: Verify the ValidQueryLocalSpec function
452 * @tc.type: FUNC
453 * @tc.require: AR000GHSJM
454 */
455 HWTEST_F(DistributedHardwareStubTest, ValidQueryLocalSpec_002, TestSize.Level0)
456 {
457 ASSERT_TRUE(stubTest_ != nullptr);
458 uint32_t spec = 0;
459 EXPECT_EQ(false, stubTest_->ValidQueryLocalSpec(spec));
460 spec = 5;
461 EXPECT_EQ(false, stubTest_->ValidQueryLocalSpec(spec));
462 }
463 } // namespace DistributedHardware
464 } // namespace OHOS
465