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_service_test.h"
17
18 #include <chrono>
19 #include <thread>
20 #include <vector>
21
22 #include "constants.h"
23 #include "cJSON.h"
24 #include "dh_context.h"
25 #include "distributed_hardware_errno.h"
26 #include "distributed_hardware_log.h"
27 #include "distributed_hardware_service.h"
28 #include "distributed_hardware_manager.h"
29 #include "task_board.h"
30 #include "mock_publisher_listener.h"
31
32 using namespace testing::ext;
33
34 namespace OHOS {
35 namespace DistributedHardware {
36 namespace {
37 const int32_t ASID = 4801;
38 const DHTopic TOPIC = DHTopic::TOPIC_START_DSCREEN;
39 sptr<IPublisherListener> g_listener(new MockPublisherListener());
40
41 const std::u16string ARGS_H = u"-h";
42 const std::u16string ARGS_L = u"-l";
43 const std::u16string ARGS_E = u"-e";
44 const std::u16string ARGS_T = u"-t";
45 const std::u16string ARGS_C = u"-c";
46 }
SetUpTestCase(void)47 void DistributedHardwareServiceTest::SetUpTestCase(void) {}
48
TearDownTestCase(void)49 void DistributedHardwareServiceTest::TearDownTestCase(void) {}
50
SetUp()51 void DistributedHardwareServiceTest::SetUp() {}
52
TearDown()53 void DistributedHardwareServiceTest::TearDown() {}
54
55 /**
56 * @tc.name: register_publisher_listener_001
57 * @tc.desc: Verify the RegisterPublisherListener function
58 * @tc.type: FUNC
59 * @tc.require: AR000GHSJM
60 */
61 HWTEST_F(DistributedHardwareServiceTest, register_publisher_listener_001, TestSize.Level0)
62 {
63 DistributedHardwareService service(ASID, true);
64 auto ret = service.RegisterPublisherListener(TOPIC, g_listener);
65
66 EXPECT_EQ(ret, DH_FWK_SUCCESS);
67 }
68
69 /**
70 * @tc.name: register_publisher_listener_002
71 * @tc.desc: Verify the RegisterPublisherListener function
72 * @tc.type: FUNC
73 * @tc.require: AR000GHSJM
74 */
75 HWTEST_F(DistributedHardwareServiceTest, register_publisher_listener_002, TestSize.Level0)
76 {
77 DistributedHardwareService service(ASID, true);
78 sptr<IPublisherListener> listener = nullptr;
79 auto ret = service.RegisterPublisherListener(TOPIC, listener);
80 EXPECT_EQ(ret, DH_FWK_SUCCESS);
81 }
82
83 /**
84 * @tc.name: unregister_publisher_listener_001
85 * @tc.desc: Verify the UnregisterPublisherListener function
86 * @tc.type: FUNC
87 * @tc.require: AR000GHSJM
88 */
89 HWTEST_F(DistributedHardwareServiceTest, unregister_publisher_listener_001, TestSize.Level0)
90 {
91 DistributedHardwareService service(ASID, true);
92 service.RegisterPublisherListener(TOPIC, g_listener);
93 auto ret = service.UnregisterPublisherListener(TOPIC, g_listener);
94
95 EXPECT_EQ(ret, DH_FWK_SUCCESS);
96 }
97
98 /**
99 * @tc.name: publish_message_001
100 * @tc.desc: Verify the PublishMessage function
101 * @tc.type: FUNC
102 * @tc.require: AR000GHSJM
103 */
104 HWTEST_F(DistributedHardwareServiceTest, publish_message_001, TestSize.Level0)
105 {
106 DistributedHardwareService service(ASID, true);
107 std::string msg;
108 service.RegisterPublisherListener(TOPIC, g_listener);
109 auto ret = service.PublishMessage(TOPIC, msg);
110
111 EXPECT_EQ(ret, DH_FWK_SUCCESS);
112 }
113
114 /**
115 * @tc.name: publish_message_002
116 * @tc.desc: Verify the PublishMessage function
117 * @tc.type: FUNC
118 * @tc.require: AR000GHSJM
119 */
120 HWTEST_F(DistributedHardwareServiceTest, publish_message_002, TestSize.Level0)
121 {
122 DistributedHardwareService service(ASID, true);
123 std::string msg = "msg";
124 service.RegisterPublisherListener(TOPIC, g_listener);
125 auto ret = service.PublishMessage(TOPIC, msg);
126
127 EXPECT_EQ(ret, DH_FWK_SUCCESS);
128 }
129
130 /**
131 * @tc.name: onStop_test_002
132 * @tc.desc: Verify the OnStop function
133 * @tc.type: FUNC
134 * @tc.require: AR000GHSJM
135 */
136 HWTEST_F(DistributedHardwareServiceTest, onStop_test_002, TestSize.Level0)
137 {
138 DistributedHardwareService service(ASID, true);
139 service.OnStop();
140
141 EXPECT_EQ(service.state_, ServiceRunningState::STATE_NOT_START);
142 }
143
144 /**
145 * @tc.name: dump_test_001
146 * @tc.desc: Verify the Dump function
147 * @tc.type: FUNC
148 * @tc.require: AR000GHSJM
149 */
150 HWTEST_F(DistributedHardwareServiceTest, dump_test_001, TestSize.Level0)
151 {
152 DistributedHardwareService service(ASID, true);
153 int32_t fd = 1;
154
155 auto ret = service.Dump(fd, std::vector<std::u16string> { ARGS_H });
156 EXPECT_EQ(ret, DH_FWK_SUCCESS);
157 ret = service.Dump(fd, std::vector<std::u16string> { ARGS_L });
158 EXPECT_EQ(ret, DH_FWK_SUCCESS);
159 ret = service.Dump(fd, std::vector<std::u16string> { ARGS_E });
160 EXPECT_EQ(ret, DH_FWK_SUCCESS);
161 ret = service.Dump(fd, std::vector<std::u16string> { ARGS_T });
162 EXPECT_EQ(ret, DH_FWK_SUCCESS);
163 ret = service.Dump(fd, std::vector<std::u16string> { ARGS_C });
164 EXPECT_EQ(ret, DH_FWK_SUCCESS);
165 }
166
167 /**
168 * @tc.name: OnStart_001
169 * @tc.desc: Verify the OnStart function
170 * @tc.type: FUNC
171 * @tc.require: AR000GHSJM
172 */
173 HWTEST_F(DistributedHardwareServiceTest, OnStart_001, TestSize.Level0)
174 {
175 DistributedHardwareService service(ASID, true);
176 service.state_ = ServiceRunningState::STATE_RUNNING;
177 service.OnStart();
178 service.OnStop();
179 EXPECT_EQ(ServiceRunningState::STATE_NOT_START, service.state_);
180 }
181
182 /**
183 * @tc.name: QueryLocalSysSpec_001
184 * @tc.desc: Verify the QueryLocalSysSpec function
185 * @tc.type: FUNC
186 * @tc.require: AR000GHSJM
187 */
188 HWTEST_F(DistributedHardwareServiceTest, QueryLocalSysSpec_001, TestSize.Level0)
189 {
190 DistributedHardwareService service(ASID, true);
191 std::string ret = service.QueryLocalSysSpec(QueryLocalSysSpecType::HISTREAMER_AUDIO_ENCODER);
192 ret = service.QueryLocalSysSpec(QueryLocalSysSpecType::HISTREAMER_AUDIO_DECODER);
193 ret = service.QueryLocalSysSpec(QueryLocalSysSpecType::HISTREAMER_VIDEO_ENCODER);
194 ret = service.QueryLocalSysSpec(QueryLocalSysSpecType::HISTREAMER_VIDEO_DECODER);
195 ret = service.QueryLocalSysSpec(QueryLocalSysSpecType::MAX);
196 EXPECT_EQ(ret.empty(), true);
197 }
198
199 /**
200 * @tc.name: PauseDistributedHardware_001
201 * @tc.desc: Verify the PauseDistributedHardware function
202 * @tc.type: FUNC
203 * @tc.require: AR000GHSJM
204 */
205 HWTEST_F(DistributedHardwareServiceTest, PauseDistributedHardware_001, TestSize.Level0)
206 {
207 DistributedHardwareService service(ASID, true);
208 std::string networkId = "111";
209 auto ret = service.PauseDistributedHardware(DHType::UNKNOWN, networkId);
210 ret = service.PauseDistributedHardware(DHType::CAMERA, networkId);
211 ret = service.PauseDistributedHardware(DHType::MAX_DH, networkId);
212 EXPECT_EQ(ret, ERR_DH_FWK_PARA_INVALID);
213 }
214
215 /**
216 * @tc.name: ResumeDistributedHardware_001
217 * @tc.desc: Verify the ResumeDistributedHardware function
218 * @tc.type: FUNC
219 * @tc.require: AR000GHSJM
220 */
221 HWTEST_F(DistributedHardwareServiceTest, ResumeDistributedHardware_001, TestSize.Level0)
222 {
223 DistributedHardwareService service(ASID, true);
224 std::string networkId = "111";
225 auto ret = service.PauseDistributedHardware(DHType::UNKNOWN, networkId);
226 ret = service.PauseDistributedHardware(DHType::AUDIO, networkId);
227 ret = service.PauseDistributedHardware(DHType::MAX_DH, networkId);
228 EXPECT_EQ(ret, ERR_DH_FWK_PARA_INVALID);
229 }
230
231 /**
232 * @tc.name: StopDistributedHardware_001
233 * @tc.desc: Verify the StopDistributedHardware function
234 * @tc.type: FUNC
235 * @tc.require: AR000GHSJM
236 */
237 HWTEST_F(DistributedHardwareServiceTest, StopDistributedHardware_001, TestSize.Level0)
238 {
239 DistributedHardwareService service(ASID, true);
240 std::string networkId = "111";
241 auto ret = service.PauseDistributedHardware(DHType::UNKNOWN, networkId);
242 ret = service.PauseDistributedHardware(DHType::INPUT, networkId);
243 ret = service.PauseDistributedHardware(DHType::MAX_DH, networkId);
244 EXPECT_EQ(ret, ERR_DH_FWK_PARA_INVALID);
245 }
246
247 /**
248 * @tc.name: GetDistributedHardware_001
249 * @tc.desc: Verify the GetDistributedHardware function
250 * @tc.type: FUNC
251 * @tc.require: AR000GHSJM
252 */
253 HWTEST_F(DistributedHardwareServiceTest, GetDistributedHardware_001, TestSize.Level0)
254 {
255 DistributedHardwareService service(ASID, true);
256 std::vector<DHDescriptor> descriptors;
257
258 std::string networkId = "111";
259 auto ret = service.GetDistributedHardware(networkId, descriptors);
260 EXPECT_EQ(ret, DH_FWK_SUCCESS);
261
262 networkId = "local";
263 ret = service.GetDistributedHardware(networkId, descriptors);
264 EXPECT_EQ(ret, DH_FWK_SUCCESS);
265 }
266
267 /**
268 * @tc.name: RegisterDHStatusListener_001
269 * @tc.desc: Verify the RegisterDHStatusListener function
270 * @tc.type: FUNC
271 * @tc.require: AR000GHSJM
272 */
273 HWTEST_F(DistributedHardwareServiceTest, RegisterDHStatusListener_001, TestSize.Level0)
274 {
275 DistributedHardwareService service(ASID, true);
276 sptr<IHDSinkStatusListener> listener = nullptr;
277
278 auto ret = service.RegisterDHStatusListener(listener);
279 EXPECT_EQ(ret, DH_FWK_SUCCESS);
280 }
281
282 /**
283 * @tc.name: RegisterDHStatusListener_002
284 * @tc.desc: Verify the RegisterDHStatusListener function
285 * @tc.type: FUNC
286 * @tc.require: AR000GHSJM
287 */
288 HWTEST_F(DistributedHardwareServiceTest, RegisterDHStatusListener_002, TestSize.Level0)
289 {
290 DistributedHardwareService service(ASID, true);
291 sptr<IHDSourceStatusListener> listener = nullptr;
292
293 std::string networkId = "111";
294 auto ret = service.RegisterDHStatusListener(networkId, listener);
295 EXPECT_EQ(ret, DH_FWK_SUCCESS);
296 }
297
298 /**
299 * @tc.name: UnregisterDHStatusListener_001
300 * @tc.desc: Verify the UnregisterDHStatusListener function
301 * @tc.type: FUNC
302 * @tc.require: AR000GHSJM
303 */
304 HWTEST_F(DistributedHardwareServiceTest, UnregisterDHStatusListener_001, TestSize.Level0)
305 {
306 DistributedHardwareService service(ASID, true);
307 sptr<IHDSinkStatusListener> listener = nullptr;
308
309 auto ret = service.UnregisterDHStatusListener(listener);
310 EXPECT_EQ(ret, DH_FWK_SUCCESS);
311 }
312
313 /**
314 * @tc.name: UnregisterDHStatusListener_002
315 * @tc.desc: Verify the UnregisterDHStatusListener function
316 * @tc.type: FUNC
317 * @tc.require: AR000GHSJM
318 */
319 HWTEST_F(DistributedHardwareServiceTest, UnregisterDHStatusListener_002, TestSize.Level0)
320 {
321 DistributedHardwareService service(ASID, true);
322 sptr<IHDSourceStatusListener> listener = nullptr;
323
324 std::string networkId = "111";
325 auto ret = service.UnregisterDHStatusListener(networkId, listener);
326 EXPECT_EQ(ret, DH_FWK_SUCCESS);
327 }
328
329 /**
330 * @tc.name: EnableSink_001
331 * @tc.desc: Verify the EnableSink function
332 * @tc.type: FUNC
333 * @tc.require: AR000GHSJM
334 */
335 HWTEST_F(DistributedHardwareServiceTest, EnableSink_001, TestSize.Level0)
336 {
337 DistributedHardwareService service(ASID, true);
338 std::vector<DHDescriptor> descriptors{{"id_test", DHType::AUDIO}};
339
340 auto ret = service.EnableSink(descriptors);
341 EXPECT_EQ(ret, DH_FWK_SUCCESS);
342 }
343
344 /**
345 * @tc.name: DisableSink_001
346 * @tc.desc: Verify the DisableSink function
347 * @tc.type: FUNC
348 * @tc.require: AR000GHSJM
349 */
350 HWTEST_F(DistributedHardwareServiceTest, DisableSink_001, TestSize.Level0)
351 {
352 DistributedHardwareService service(ASID, true);
353 std::vector<DHDescriptor> descriptors{{"id_test", DHType::AUDIO}};
354
355 auto ret = service.DisableSink(descriptors);
356 EXPECT_EQ(ret, DH_FWK_SUCCESS);
357 }
358
359 /**
360 * @tc.name: EnableSource_001
361 * @tc.desc: Verify the EnableSource function
362 * @tc.type: FUNC
363 * @tc.require: AR000GHSJM
364 */
365 HWTEST_F(DistributedHardwareServiceTest, EnableSource_001, TestSize.Level0)
366 {
367 DistributedHardwareService service(ASID, true);
368 std::string networkId = "111";
369 std::vector<DHDescriptor> descriptors{{"id_test", DHType::AUDIO}};
370
371 auto ret = service.EnableSource(networkId, descriptors);
372 EXPECT_EQ(ret, DH_FWK_SUCCESS);
373 }
374
375 /**
376 * @tc.name: DisableSource_001
377 * @tc.desc: Verify the DisableSource function
378 * @tc.type: FUNC
379 * @tc.require: AR000GHSJM
380 */
381 HWTEST_F(DistributedHardwareServiceTest, DisableSource_001, TestSize.Level0)
382 {
383 DistributedHardwareService service(ASID, true);
384 std::string networkId = "111";
385 std::vector<DHDescriptor> descriptors{{"id_test", DHType::AUDIO}};
386
387 auto ret = service.DisableSource(networkId, descriptors);
388 EXPECT_EQ(ret, DH_FWK_SUCCESS);
389 }
390
391 HWTEST_F(DistributedHardwareServiceTest, ResumeDistributedHardware_002, TestSize.Level0)
392 {
393 DistributedHardwareService service(ASID, true);
394 std::string networkId = "111";
395 auto ret = service.ResumeDistributedHardware(DHType::UNKNOWN, networkId);
396 EXPECT_EQ(ret, ERR_DH_FWK_PARA_INVALID);
397 }
398
399 HWTEST_F(DistributedHardwareServiceTest, StopDistributedHardware_002, TestSize.Level0)
400 {
401 DistributedHardwareService service(ASID, true);
402 std::string networkId = "111";
403 auto ret = service.StopDistributedHardware(DHType::UNKNOWN, networkId);
404 EXPECT_EQ(ret, ERR_DH_FWK_PARA_INVALID);
405 }
406
407 HWTEST_F(DistributedHardwareServiceTest, DoBusinessInit_001, TestSize.Level0)
408 {
409 DistributedHardwareService service(ASID, true);
410 auto ret = service.DoBusinessInit();
411 EXPECT_EQ(true, ret);
412 }
413
414 HWTEST_F(DistributedHardwareServiceTest, QueryDhSysSpec_001, TestSize.Level0)
415 {
416 std::string targetKey = "";
417 std::string attrs = "";
418 DistributedHardwareService service(ASID, true);
419 auto ret = service.QueryDhSysSpec(targetKey, attrs);
420 EXPECT_EQ(0, ret.length());
421 }
422
423 HWTEST_F(DistributedHardwareServiceTest, QueryDhSysSpec_002, TestSize.Level0)
424 {
425 std::string targetKey = "histmAudEnc";
426 int32_t target = 100;
427 cJSON *attrJson = cJSON_CreateObject();
428 ASSERT_TRUE(attrJson != nullptr);
429 cJSON_AddNumberToObject(attrJson, targetKey.c_str(), target);
430 char* cjson = cJSON_PrintUnformatted(attrJson);
431 if (cjson == nullptr) {
432 cJSON_Delete(attrJson);
433 return;
434 }
435 std::string attrs(cjson);
436 DistributedHardwareService service(ASID, true);
437 auto ret = service.QueryDhSysSpec(targetKey, attrs);
438 EXPECT_EQ(0, ret.length());
439 cJSON_free(cjson);
440 cJSON_Delete(attrJson);
441
442 cJSON *attrJson1 = cJSON_CreateObject();
443 ASSERT_TRUE(attrJson1 != nullptr);
444 std::string targetKeyValue = "targetKeyValue";
445 cJSON_AddStringToObject(attrJson1, targetKey.c_str(), targetKeyValue.c_str());
446 char* cjson1 = cJSON_PrintUnformatted(attrJson1);
447 if (cjson1 == nullptr) {
448 cJSON_Delete(attrJson1);
449 return;
450 }
451 std::string attrs1(cjson1);
452 ret = service.QueryDhSysSpec(targetKey, attrs1);
453 EXPECT_NE(0, ret.length());
454 cJSON_free(cjson1);
455 cJSON_Delete(attrJson1);
456 }
457 } // namespace DistributedHardware
458 } // namespace OHOS
459