1 /*
2 * Copyright (c) 2022-2024 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #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 if (stubTest_ == nullptr) {
49 return;
50 }
51 uint32_t code = 0;
52 MessageParcel data;
53 MessageParcel reply;
54 MessageOption option;
55 EXPECT_NE(DH_FWK_SUCCESS, stubTest_->OnRemoteRequest(code, data, reply, option));
56 }
57
58 /**
59 * @tc.name: OnRemoteRequest_002
60 * @tc.desc: Verify the OnRemoteRequest function
61 * @tc.type: FUNC
62 * @tc.require: AR000GHSJM
63 */
64 HWTEST_F(DistributedHardwareStubTest, OnRemoteRequest_002, TestSize.Level0)
65 {
66 if (stubTest_ == nullptr) {
67 return;
68 }
69 uint32_t code = 0;
70 MessageParcel data;
71 MessageParcel reply;
72 MessageOption option;
73 EXPECT_EQ(ERR_INVALID_DATA, stubTest_->OnRemoteRequest(code, data, reply, option));
74 }
75
76 HWTEST_F(DistributedHardwareStubTest, OnRemoteRequest_003, TestSize.Level0)
77 {
78 if (stubTest_ == nullptr) {
79 return;
80 }
81 uint32_t code = static_cast<uint32_t>(DHMsgInterfaceCode::REG_PUBLISHER_LISTNER);
82 MessageParcel data;
83 MessageParcel reply;
84 MessageOption option;
85 data.WriteInterfaceToken(stubTest_->GetDescriptor());
86 uint32_t topicInt = (uint32_t)DHTopic::TOPIC_MIN;
87 data.WriteUint32(topicInt);
88 auto ret = stubTest_->OnRemoteRequest(code, data, reply, option);
89 EXPECT_EQ(ERR_DH_FWK_ACCESS_PERMISSION_CHECK_FAIL, ret);
90 }
91
92 HWTEST_F(DistributedHardwareStubTest, OnRemoteRequest_004, TestSize.Level0)
93 {
94 if (stubTest_ == nullptr) {
95 return;
96 }
97 uint32_t code = static_cast<uint32_t>(DHMsgInterfaceCode::PUBLISH_MESSAGE);
98 MessageParcel data;
99 MessageParcel reply;
100 MessageOption option;
101 data.WriteInterfaceToken(stubTest_->GetDescriptor());
102 uint32_t topicInt = (uint32_t)DHTopic::TOPIC_MIN;
103 data.WriteUint32(topicInt);
104 auto ret = stubTest_->OnRemoteRequest(code, data, reply, option);
105 EXPECT_EQ(ERR_DH_FWK_ACCESS_PERMISSION_CHECK_FAIL, ret);
106 }
107
108 HWTEST_F(DistributedHardwareStubTest, OnRemoteRequest_005, TestSize.Level0)
109 {
110 if (stubTest_ == nullptr) {
111 return;
112 }
113 uint32_t code = static_cast<uint32_t>(DHMsgInterfaceCode::INIT_CTL_CEN);
114 MessageParcel data;
115 MessageParcel reply;
116 MessageOption option;
117 data.WriteInterfaceToken(stubTest_->GetDescriptor());
118 uint32_t transRole = static_cast<uint32_t>(TransRole::UNKNOWN);
119 data.WriteUint32(transRole);
120 auto ret = stubTest_->OnRemoteRequest(code, data, reply, option);
121 EXPECT_EQ(ERR_DH_FWK_ACCESS_PERMISSION_CHECK_FAIL, ret);
122 }
123
124 HWTEST_F(DistributedHardwareStubTest, OnRemoteRequest_006, TestSize.Level0)
125 {
126 if (stubTest_ == nullptr) {
127 return;
128 }
129 uint32_t code = static_cast<uint32_t>(DHMsgInterfaceCode::RELEASE_CTL_CEN);
130 MessageParcel data;
131 MessageParcel reply;
132 MessageOption option;
133 data.WriteInterfaceToken(stubTest_->GetDescriptor());
134 int32_t engineId = 1;
135 data.WriteInt32(engineId);
136 auto ret = stubTest_->OnRemoteRequest(code, data, reply, option);
137 EXPECT_EQ(ERR_DH_FWK_ACCESS_PERMISSION_CHECK_FAIL, ret);
138 }
139
140 HWTEST_F(DistributedHardwareStubTest, OnRemoteRequest_007, TestSize.Level0)
141 {
142 if (stubTest_ == nullptr) {
143 return;
144 }
145 uint32_t code = static_cast<uint32_t>(DHMsgInterfaceCode::CREATE_CTL_CEN_CHANNEL);
146 MessageParcel data;
147 MessageParcel reply;
148 MessageOption option;
149 data.WriteInterfaceToken(stubTest_->GetDescriptor());
150 int32_t engineId = 1;
151 std::string peerDevId = "peerDevId_test";
152 data.WriteInt32(engineId);
153 data.WriteString(peerDevId);
154 auto ret = stubTest_->OnRemoteRequest(code, data, reply, option);
155 EXPECT_EQ(ERR_DH_FWK_ACCESS_PERMISSION_CHECK_FAIL, ret);
156 }
157
158 HWTEST_F(DistributedHardwareStubTest, OnRemoteRequest_008, TestSize.Level0)
159 {
160 if (stubTest_ == nullptr) {
161 return;
162 }
163 uint32_t code = static_cast<uint32_t>(DHMsgInterfaceCode::NOTIFY_AV_EVENT);
164 MessageParcel data;
165 MessageParcel reply;
166 MessageOption option;
167 data.WriteInterfaceToken(stubTest_->GetDescriptor());
168 int32_t engineId = 1;
169 std::string peerDevId = "peerDevId_test";
170 uint32_t type = 1;
171 std::string content = "content_test";
172 data.WriteInt32(engineId);
173 data.WriteString(peerDevId);
174 data.WriteUint32(type);
175 data.WriteString(content);
176 auto ret = stubTest_->OnRemoteRequest(code, data, reply, option);
177 EXPECT_EQ(ERR_DH_FWK_ACCESS_PERMISSION_CHECK_FAIL, ret);
178 }
179
180 HWTEST_F(DistributedHardwareStubTest, OnRemoteRequest_009, TestSize.Level0)
181 {
182 if (stubTest_ == nullptr) {
183 return;
184 }
185 uint32_t code = static_cast<uint32_t>(DHMsgInterfaceCode::QUERY_LOCAL_SYS_SPEC);
186 MessageParcel data;
187 MessageParcel reply;
188 MessageOption option;
189 data.WriteInterfaceToken(stubTest_->GetDescriptor());
190 uint32_t specInt = static_cast<uint32_t>(QueryLocalSysSpecType::MIN);
191 data.WriteUint32(specInt);
192 auto ret = stubTest_->OnRemoteRequest(code, data, reply, option);
193 EXPECT_EQ(ERR_DH_FWK_ACCESS_PERMISSION_CHECK_FAIL, ret);
194 }
195
196 HWTEST_F(DistributedHardwareStubTest, OnRemoteRequest_010, TestSize.Level0)
197 {
198 if (stubTest_ == nullptr) {
199 return;
200 }
201 uint32_t code = static_cast<uint32_t>(DHMsgInterfaceCode::NOTIFY_SOURCE_DEVICE_REMOTE_DMSDP_STARTED);
202 MessageParcel data;
203 MessageParcel reply;
204 MessageOption option;
205 data.WriteInterfaceToken(stubTest_->GetDescriptor());
206 std::string deviceId = "deviceId_test";
207 data.WriteString(deviceId);
208 auto ret = stubTest_->OnRemoteRequest(code, data, reply, option);
209 EXPECT_EQ(ERR_DH_FWK_ACCESS_PERMISSION_CHECK_FAIL, ret);
210 }
211
212 HWTEST_F(DistributedHardwareStubTest, OnRemoteRequest_011, TestSize.Level0)
213 {
214 if (stubTest_ == nullptr) {
215 return;
216 }
217 uint32_t code = static_cast<uint32_t>(DHMsgInterfaceCode::PAUSE_DISTRIBUTED_HARDWARE);
218 MessageParcel data;
219 MessageParcel reply;
220 MessageOption option;
221 data.WriteInterfaceToken(stubTest_->GetDescriptor());
222 auto ret = stubTest_->OnRemoteRequest(code, data, reply, option);
223 EXPECT_EQ(ERR_DH_FWK_IS_SYSTEM_HAP_CHECK_FAIL, ret);
224 }
225
226 HWTEST_F(DistributedHardwareStubTest, OnRemoteRequest_012, TestSize.Level0)
227 {
228 if (stubTest_ == nullptr) {
229 return;
230 }
231 uint32_t code = static_cast<uint32_t>(DHMsgInterfaceCode::RESUME_DISTRIBUTED_HARDWARE);
232 MessageParcel data;
233 MessageParcel reply;
234 MessageOption option;
235 data.WriteInterfaceToken(stubTest_->GetDescriptor());
236 auto ret = stubTest_->OnRemoteRequest(code, data, reply, option);
237 EXPECT_EQ(ERR_DH_FWK_IS_SYSTEM_HAP_CHECK_FAIL, ret);
238 }
239
240 HWTEST_F(DistributedHardwareStubTest, OnRemoteRequest_013, TestSize.Level0)
241 {
242 if (stubTest_ == nullptr) {
243 return;
244 }
245 uint32_t code = static_cast<uint32_t>(DHMsgInterfaceCode::STOP_DISTRIBUTED_HARDWARE);
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_IS_SYSTEM_HAP_CHECK_FAIL, ret);
252 }
253
254 HWTEST_F(DistributedHardwareStubTest, OnRemoteRequest_014, TestSize.Level0)
255 {
256 if (stubTest_ == nullptr) {
257 return;
258 }
259 uint32_t code = static_cast<uint32_t>(DHMsgInterfaceCode::UNREG_PUBLISHER_LISTENER);
260 MessageParcel data;
261 MessageParcel reply;
262 MessageOption option;
263 data.WriteInterfaceToken(stubTest_->GetDescriptor());
264 uint32_t topicInt = (uint32_t)DHTopic::TOPIC_MIN;
265 data.WriteUint32(topicInt);
266 auto ret = stubTest_->OnRemoteRequest(code, data, reply, option);
267 EXPECT_EQ(ERR_DH_FWK_ACCESS_PERMISSION_CHECK_FAIL, ret);
268 }
269
270 /**
271 * @tc.name: RegisterPublisherListenerInner_001
272 * @tc.desc: Verify the RegisterPublisherListenerInner function
273 * @tc.type: FUNC
274 * @tc.require: AR000GHSJM
275 */
276 HWTEST_F(DistributedHardwareStubTest, RegisterPublisherListenerInner_001, TestSize.Level0)
277 {
278 if (stubTest_ == nullptr) {
279 return;
280 }
281 MessageParcel data;
282 MessageParcel reply;
283 EXPECT_NE(DH_FWK_SUCCESS, stubTest_->RegisterPublisherListenerInner(data, reply));
284 }
285
286 /**
287 * @tc.name: UnregisterPublisherListenerInner_001
288 * @tc.desc: Verify the UnregisterPublisherListenerInner function
289 * @tc.type: FUNC
290 * @tc.require: AR000GHSJM
291 */
292 HWTEST_F(DistributedHardwareStubTest, UnregisterPublisherListenerInner_001, TestSize.Level0)
293 {
294 if (stubTest_ == nullptr) {
295 return;
296 }
297 MessageParcel data;
298 MessageParcel reply;
299 EXPECT_NE(DH_FWK_SUCCESS, stubTest_->UnregisterPublisherListenerInner(data, reply));
300 }
301
302 /**
303 * @tc.name: PublishMessageInner_001
304 * @tc.desc: Verify the PublishMessageInner function
305 * @tc.type: FUNC
306 * @tc.require: AR000GHSJM
307 */
308 HWTEST_F(DistributedHardwareStubTest, PublishMessageInner_001, TestSize.Level0)
309 {
310 if (stubTest_ == nullptr) {
311 return;
312 }
313 MessageParcel data;
314 MessageParcel reply;
315 EXPECT_NE(DH_FWK_SUCCESS, stubTest_->PublishMessageInner(data, reply));
316 }
317
318 /**
319 * @tc.name: ValidTopic_001
320 * @tc.desc: Verify the ValidTopic function
321 * @tc.type: FUNC
322 * @tc.require: AR000GHSJM
323 */
324 HWTEST_F(DistributedHardwareStubTest, ValidTopic_001, TestSize.Level0)
325 {
326 if (stubTest_ == nullptr) {
327 return;
328 }
329 uint32_t topic = static_cast<uint32_t>(DHTopic::TOPIC_MIN);
330 EXPECT_EQ(false, stubTest_->ValidTopic(topic));
331
332 uint32_t topic1 = static_cast<uint32_t>(DHTopic::TOPIC_MAX);
333 EXPECT_EQ(false, stubTest_->ValidTopic(topic1));
334
335 uint32_t topic2 = static_cast<uint32_t>(DHTopic::TOPIC_START_DSCREEN);
336 EXPECT_EQ(true, stubTest_->ValidTopic(topic2));
337 }
338
339 /**
340 * @tc.name: ValidQueryLocalSpec_001
341 * @tc.desc: Verify the ValidQueryLocalSpec function
342 * @tc.type: FUNC
343 * @tc.require: AR000GHSJM
344 */
345 HWTEST_F(DistributedHardwareStubTest, ValidQueryLocalSpec_001, TestSize.Level0)
346 {
347 if (stubTest_ == nullptr) {
348 return;
349 }
350 uint32_t spec = 1;
351 EXPECT_EQ(true, stubTest_->ValidQueryLocalSpec(spec));
352 }
353
354 /**
355 * @tc.name: ValidQueryLocalSpec_002
356 * @tc.desc: Verify the ValidQueryLocalSpec function
357 * @tc.type: FUNC
358 * @tc.require: AR000GHSJM
359 */
360 HWTEST_F(DistributedHardwareStubTest, ValidQueryLocalSpec_002, TestSize.Level0)
361 {
362 if (stubTest_ == nullptr) {
363 return;
364 }
365 uint32_t spec = 0;
366 EXPECT_EQ(false, stubTest_->ValidQueryLocalSpec(spec));
367 spec = 5;
368 EXPECT_EQ(false, stubTest_->ValidQueryLocalSpec(spec));
369 }
370
371
372 } // namespace DistributedHardware
373 } // namespace OHOS
374