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 "component_loader.h"
25 #include "component_manager.h"
26 #include "dh_context.h"
27 #include "distributed_hardware_errno.h"
28 #include "distributed_hardware_log.h"
29 #include "distributed_hardware_service.h"
30 #include "distributed_hardware_manager.h"
31 #include "task_board.h"
32 #include "mock_publisher_listener.h"
33
34 using namespace testing::ext;
35
36 namespace OHOS {
37 namespace DistributedHardware {
38 namespace {
39 const int32_t ASID = 4801;
40 const DHTopic TOPIC = DHTopic::TOPIC_START_DSCREEN;
41 sptr<IPublisherListener> g_listener(new MockPublisherListener());
42
43 const std::u16string ARGS_H = u"-h";
44 const std::u16string ARGS_L = u"-l";
45 const std::u16string ARGS_E = u"-e";
46 const std::u16string ARGS_T = u"-t";
47 const std::u16string ARGS_C = u"-c";
48
49 constexpr int32_t TEST_COMP_SINK_SA_ID = 4804;
50 constexpr int32_t TEST_SINK_SA_ID = 12345;
51 constexpr int32_t TEST_SOURCE_SA_ID = 12345;
52 }
SetUpTestCase(void)53 void DistributedHardwareServiceTest::SetUpTestCase(void) {}
54
TearDownTestCase(void)55 void DistributedHardwareServiceTest::TearDownTestCase(void) {}
56
SetUp()57 void DistributedHardwareServiceTest::SetUp() {}
58
TearDown()59 void DistributedHardwareServiceTest::TearDown() {}
60
SetUpComponentLoaderConfig()61 void SetUpComponentLoaderConfig()
62 {
63 if (ComponentLoader::GetInstance().compHandlerMap_.find(DHType::AUDIO)
64 == ComponentLoader::GetInstance().compHandlerMap_.end()) {
65 CompHandler handler;
66 handler.compConfig.name = "distributed_audio";
67 handler.compConfig.type = DHType::AUDIO;
68 handler.compConfig.compHandlerLoc = "libdistributed_audio_handler.z.so";
69 handler.compConfig.compHandlerVersion = "1.0";
70 handler.compConfig.compSourceLoc = "libdistributed_audio_source_sdk.z.so";
71 handler.compConfig.compSourceVersion = "1.0";
72 handler.compConfig.compSinkLoc = "libdistributed_audio_sink_sdk.z.so";
73 handler.compConfig.compSinkVersion = "2.0";
74 handler.compConfig.compSinkSaId = TEST_COMP_SINK_SA_ID;
75 handler.compConfig.haveFeature = false;
76 handler.hardwareHandler = nullptr;
77 handler.sourceHandler = nullptr;
78 handler.sinkHandler = nullptr;
79 handler.type = DHType::AUDIO;
80 handler.sinkSaId = TEST_SINK_SA_ID;
81 handler.sourceSaId = TEST_SOURCE_SA_ID;
82 ComponentLoader::GetInstance().compHandlerMap_[DHType::AUDIO] = handler;
83 }
84 }
85
SetDownComponentLoaderConfig()86 void SetDownComponentLoaderConfig()
87 {
88 auto itHandler = ComponentLoader::GetInstance().compHandlerMap_.find(DHType::AUDIO);
89 if (itHandler != ComponentLoader::GetInstance().compHandlerMap_.end()) {
90 CompHandler &handler = itHandler->second;
91 if (handler.sinkSaId == TEST_SINK_SA_ID && handler.sourceSaId == TEST_SOURCE_SA_ID) {
92 ComponentLoader::GetInstance().compHandlerMap_.erase(itHandler);
93 }
94 }
95 }
96
OnSuccess(const std::string & networkId,const std::vector<DHDescriptor> & descriptors,EnableStep enableStep)97 void DistributedHardwareServiceTest::TestGetDistributedHardwareCallback::OnSuccess(
98 const std::string &networkId, const std::vector<DHDescriptor> &descriptors, EnableStep enableStep)
99 {
100 (void)networkId;
101 (void)descriptors;
102 (void)enableStep;
103 }
104
OnError(const std::string & networkId,int32_t error)105 void DistributedHardwareServiceTest::TestGetDistributedHardwareCallback::OnError(const std::string &networkId,
106 int32_t error)
107 {
108 (void)networkId;
109 (void)error;
110 }
111
112 /**
113 * @tc.name: register_publisher_listener_001
114 * @tc.desc: Verify the RegisterPublisherListener function
115 * @tc.type: FUNC
116 * @tc.require: AR000GHSJM
117 */
118 HWTEST_F(DistributedHardwareServiceTest, register_publisher_listener_001, TestSize.Level1)
119 {
120 DistributedHardwareService service(ASID, true);
121 auto ret = service.RegisterPublisherListener(TOPIC, g_listener);
122
123 EXPECT_EQ(ret, DH_FWK_SUCCESS);
124 }
125
126 /**
127 * @tc.name: register_publisher_listener_002
128 * @tc.desc: Verify the RegisterPublisherListener function
129 * @tc.type: FUNC
130 * @tc.require: AR000GHSJM
131 */
132 HWTEST_F(DistributedHardwareServiceTest, register_publisher_listener_002, TestSize.Level1)
133 {
134 DistributedHardwareService service(ASID, true);
135 sptr<IPublisherListener> listener = nullptr;
136 auto ret = service.RegisterPublisherListener(TOPIC, listener);
137 EXPECT_EQ(ret, DH_FWK_SUCCESS);
138 }
139
140 /**
141 * @tc.name: unregister_publisher_listener_001
142 * @tc.desc: Verify the UnregisterPublisherListener function
143 * @tc.type: FUNC
144 * @tc.require: AR000GHSJM
145 */
146 HWTEST_F(DistributedHardwareServiceTest, unregister_publisher_listener_001, TestSize.Level1)
147 {
148 DistributedHardwareService service(ASID, true);
149 service.RegisterPublisherListener(TOPIC, g_listener);
150 auto ret = service.UnregisterPublisherListener(TOPIC, g_listener);
151
152 EXPECT_EQ(ret, DH_FWK_SUCCESS);
153 }
154
155 /**
156 * @tc.name: publish_message_001
157 * @tc.desc: Verify the PublishMessage function
158 * @tc.type: FUNC
159 * @tc.require: AR000GHSJM
160 */
161 HWTEST_F(DistributedHardwareServiceTest, publish_message_001, TestSize.Level1)
162 {
163 DistributedHardwareService service(ASID, true);
164 std::string msg;
165 service.RegisterPublisherListener(TOPIC, g_listener);
166 auto ret = service.PublishMessage(TOPIC, msg);
167
168 EXPECT_EQ(ret, DH_FWK_SUCCESS);
169 }
170
171 /**
172 * @tc.name: publish_message_002
173 * @tc.desc: Verify the PublishMessage function
174 * @tc.type: FUNC
175 * @tc.require: AR000GHSJM
176 */
177 HWTEST_F(DistributedHardwareServiceTest, publish_message_002, TestSize.Level1)
178 {
179 DistributedHardwareService service(ASID, true);
180 std::string msg = "msg";
181 service.RegisterPublisherListener(TOPIC, g_listener);
182 auto ret = service.PublishMessage(TOPIC, msg);
183
184 EXPECT_EQ(ret, DH_FWK_SUCCESS);
185 }
186
187 /**
188 * @tc.name: onStop_test_002
189 * @tc.desc: Verify the OnStop function
190 * @tc.type: FUNC
191 * @tc.require: AR000GHSJM
192 */
193 HWTEST_F(DistributedHardwareServiceTest, onStop_test_002, TestSize.Level1)
194 {
195 DistributedHardwareService service(ASID, true);
196 service.OnStop();
197
198 EXPECT_EQ(service.state_, ServiceRunningState::STATE_NOT_START);
199 }
200
201 /**
202 * @tc.name: dump_test_001
203 * @tc.desc: Verify the Dump function
204 * @tc.type: FUNC
205 * @tc.require: AR000GHSJM
206 */
207 HWTEST_F(DistributedHardwareServiceTest, dump_test_001, TestSize.Level1)
208 {
209 DistributedHardwareService service(ASID, true);
210 int32_t fd = 1;
211
212 auto ret = service.Dump(fd, std::vector<std::u16string> { ARGS_H });
213 EXPECT_EQ(ret, DH_FWK_SUCCESS);
214 ret = service.Dump(fd, std::vector<std::u16string> { ARGS_L });
215 EXPECT_EQ(ret, DH_FWK_SUCCESS);
216 ret = service.Dump(fd, std::vector<std::u16string> { ARGS_E });
217 EXPECT_EQ(ret, DH_FWK_SUCCESS);
218 ret = service.Dump(fd, std::vector<std::u16string> { ARGS_T });
219 EXPECT_EQ(ret, DH_FWK_SUCCESS);
220 ret = service.Dump(fd, std::vector<std::u16string> { ARGS_C });
221 EXPECT_EQ(ret, DH_FWK_SUCCESS);
222 }
223
224 /**
225 * @tc.name: OnStart_001
226 * @tc.desc: Verify the OnStart function
227 * @tc.type: FUNC
228 * @tc.require: AR000GHSJM
229 */
230 HWTEST_F(DistributedHardwareServiceTest, OnStart_001, TestSize.Level1)
231 {
232 DistributedHardwareService service(ASID, true);
233 service.state_ = ServiceRunningState::STATE_RUNNING;
234 service.OnStart();
235 service.OnStop();
236 EXPECT_EQ(ServiceRunningState::STATE_NOT_START, service.state_);
237 }
238
239 /**
240 * @tc.name: QueryLocalSysSpec_001
241 * @tc.desc: Verify the QueryLocalSysSpec function
242 * @tc.type: FUNC
243 * @tc.require: AR000GHSJM
244 */
245 HWTEST_F(DistributedHardwareServiceTest, QueryLocalSysSpec_001, TestSize.Level1)
246 {
247 DistributedHardwareService service(ASID, true);
248 std::string ret = service.QueryLocalSysSpec(QueryLocalSysSpecType::HISTREAMER_AUDIO_ENCODER);
249 ret = service.QueryLocalSysSpec(QueryLocalSysSpecType::HISTREAMER_AUDIO_DECODER);
250 ret = service.QueryLocalSysSpec(QueryLocalSysSpecType::HISTREAMER_VIDEO_ENCODER);
251 ret = service.QueryLocalSysSpec(QueryLocalSysSpecType::HISTREAMER_VIDEO_DECODER);
252 ret = service.QueryLocalSysSpec(QueryLocalSysSpecType::MAX);
253 EXPECT_EQ(ret.empty(), true);
254 }
255
256 /**
257 * @tc.name: PauseDistributedHardware_001
258 * @tc.desc: Verify the PauseDistributedHardware function
259 * @tc.type: FUNC
260 * @tc.require: AR000GHSJM
261 */
262 HWTEST_F(DistributedHardwareServiceTest, PauseDistributedHardware_001, TestSize.Level1)
263 {
264 DistributedHardwareService service(ASID, true);
265 std::string networkId = "111";
266 auto ret = service.PauseDistributedHardware(DHType::UNKNOWN, networkId);
267 ret = service.PauseDistributedHardware(DHType::CAMERA, networkId);
268 ret = service.PauseDistributedHardware(DHType::MAX_DH, networkId);
269 EXPECT_EQ(ret, ERR_DH_FWK_PARA_INVALID);
270 }
271
272 /**
273 * @tc.name: ResumeDistributedHardware_001
274 * @tc.desc: Verify the ResumeDistributedHardware function
275 * @tc.type: FUNC
276 * @tc.require: AR000GHSJM
277 */
278 HWTEST_F(DistributedHardwareServiceTest, ResumeDistributedHardware_001, TestSize.Level1)
279 {
280 DistributedHardwareService service(ASID, true);
281 std::string networkId = "111";
282 auto ret = service.PauseDistributedHardware(DHType::UNKNOWN, networkId);
283 ret = service.PauseDistributedHardware(DHType::AUDIO, networkId);
284 ret = service.PauseDistributedHardware(DHType::MAX_DH, networkId);
285 EXPECT_EQ(ret, ERR_DH_FWK_PARA_INVALID);
286 }
287
288 /**
289 * @tc.name: StopDistributedHardware_001
290 * @tc.desc: Verify the StopDistributedHardware function
291 * @tc.type: FUNC
292 * @tc.require: AR000GHSJM
293 */
294 HWTEST_F(DistributedHardwareServiceTest, StopDistributedHardware_001, TestSize.Level1)
295 {
296 DistributedHardwareService service(ASID, true);
297 std::string networkId = "111";
298 auto ret = service.PauseDistributedHardware(DHType::UNKNOWN, networkId);
299 ret = service.PauseDistributedHardware(DHType::INPUT, networkId);
300 ret = service.PauseDistributedHardware(DHType::MAX_DH, networkId);
301 EXPECT_EQ(ret, ERR_DH_FWK_PARA_INVALID);
302 }
303
304 /**
305 * @tc.name: GetDistributedHardware_001
306 * @tc.desc: Verify the GetDistributedHardware function
307 * @tc.type: FUNC
308 * @tc.require: AR000GHSJM
309 */
310 HWTEST_F(DistributedHardwareServiceTest, GetDistributedHardware_001, TestSize.Level1)
311 {
312 DistributedHardwareService service(ASID, true);
313 std::string networkId = "";
314 EnableStep enableStep = EnableStep::ENABLE_SOURCE;
315 auto ret = service.GetDistributedHardware(networkId, enableStep, nullptr);
316 EXPECT_EQ(ret, ERR_DH_FWK_PARA_INVALID);
317
318 networkId = "111";
319 ret = service.GetDistributedHardware(networkId, enableStep, nullptr);
320 EXPECT_EQ(ret, ERR_DH_FWK_PARA_INVALID);
321
322 sptr<IGetDhDescriptorsCallback> callback(new TestGetDistributedHardwareCallback());
323 ret = service.GetDistributedHardware(networkId, enableStep, callback);
324 EXPECT_EQ(ret, DH_FWK_SUCCESS);
325
326 networkId = "local";
327 ret = service.GetDistributedHardware(networkId, enableStep, callback);
328 EXPECT_EQ(ret, DH_FWK_SUCCESS);
329 }
330
331 /**
332 * @tc.name: RegisterDHStatusListener_001
333 * @tc.desc: Verify the RegisterDHStatusListener function
334 * @tc.type: FUNC
335 * @tc.require: AR000GHSJM
336 */
337 HWTEST_F(DistributedHardwareServiceTest, RegisterDHStatusListener_001, TestSize.Level1)
338 {
339 DistributedHardwareService service(ASID, true);
340 sptr<IHDSinkStatusListener> listener = nullptr;
341
342 SetUpComponentLoaderConfig();
343 auto ret = service.RegisterDHStatusListener(listener);
344 EXPECT_EQ(ret, DH_FWK_SUCCESS);
345 ret = service.RegisterDHStatusListener(listener);
346 SetDownComponentLoaderConfig();
347 EXPECT_EQ(ret, ERR_DH_FWK_COMPONENT_REPEAT_CALL);
348 }
349
350 /**
351 * @tc.name: RegisterDHStatusListener_002
352 * @tc.desc: Verify the RegisterDHStatusListener function
353 * @tc.type: FUNC
354 * @tc.require: AR000GHSJM
355 */
356 HWTEST_F(DistributedHardwareServiceTest, RegisterDHStatusListener_002, TestSize.Level1)
357 {
358 DistributedHardwareService service(ASID, true);
359 sptr<IHDSourceStatusListener> listener = nullptr;
360
361 SetUpComponentLoaderConfig();
362 std::string networkId = "111";
363 auto ret = service.RegisterDHStatusListener(networkId, listener);
364 EXPECT_EQ(ret, DH_FWK_SUCCESS);
365 ret = service.RegisterDHStatusListener(networkId, listener);
366 EXPECT_EQ(ret, ERR_DH_FWK_COMPONENT_REPEAT_CALL);
367 SetDownComponentLoaderConfig();
368
369 networkId = "";
370 ret = service.RegisterDHStatusListener(networkId, listener);
371 EXPECT_EQ(ret, ERR_DH_FWK_PARA_INVALID);
372 }
373
374 /**
375 * @tc.name: UnregisterDHStatusListener_001
376 * @tc.desc: Verify the UnregisterDHStatusListener function
377 * @tc.type: FUNC
378 * @tc.require: AR000GHSJM
379 */
380 HWTEST_F(DistributedHardwareServiceTest, UnregisterDHStatusListener_001, TestSize.Level1)
381 {
382 DistributedHardwareService service(ASID, true);
383 sptr<IHDSinkStatusListener> listener = nullptr;
384
385 SetUpComponentLoaderConfig();
386 auto ret = service.UnregisterDHStatusListener(listener);
387 EXPECT_EQ(ret, DH_FWK_SUCCESS);
388 ret = service.UnregisterDHStatusListener(listener);
389 SetDownComponentLoaderConfig();
390 EXPECT_EQ(ret, ERR_DH_FWK_COMPONENT_REPEAT_CALL);
391 }
392
393 /**
394 * @tc.name: UnregisterDHStatusListener_002
395 * @tc.desc: Verify the UnregisterDHStatusListener function
396 * @tc.type: FUNC
397 * @tc.require: AR000GHSJM
398 */
399 HWTEST_F(DistributedHardwareServiceTest, UnregisterDHStatusListener_002, TestSize.Level1)
400 {
401 DistributedHardwareService service(ASID, true);
402 sptr<IHDSourceStatusListener> listener = nullptr;
403
404 SetUpComponentLoaderConfig();
405 std::string networkId = "111";
406 auto ret = service.UnregisterDHStatusListener(networkId, listener);
407 EXPECT_EQ(ret, DH_FWK_SUCCESS);
408 ret = service.UnregisterDHStatusListener(networkId, listener);
409 EXPECT_EQ(ret, ERR_DH_FWK_COMPONENT_REPEAT_CALL);
410 SetDownComponentLoaderConfig();
411
412 networkId = "";
413 ret = service.UnregisterDHStatusListener(networkId, listener);
414 EXPECT_EQ(ret, ERR_DH_FWK_PARA_INVALID);
415 }
416
417 /**
418 * @tc.name: EnableSink_001
419 * @tc.desc: Verify the EnableSink function
420 * @tc.type: FUNC
421 * @tc.require: AR000GHSJM
422 */
423 HWTEST_F(DistributedHardwareServiceTest, EnableSink_001, TestSize.Level1)
424 {
425 DistributedHardwareService service(ASID, true);
426 std::vector<DHDescriptor> descriptors{{"id_test", DHType::AUDIO}};
427
428 auto ret = service.EnableSink(descriptors);
429 EXPECT_EQ(ret, DH_FWK_SUCCESS);
430 }
431
432 /**
433 * @tc.name: DisableSink_001
434 * @tc.desc: Verify the DisableSink function
435 * @tc.type: FUNC
436 * @tc.require: AR000GHSJM
437 */
438 HWTEST_F(DistributedHardwareServiceTest, DisableSink_001, TestSize.Level1)
439 {
440 DistributedHardwareService service(ASID, true);
441 std::vector<DHDescriptor> descriptors{{"id_test", DHType::AUDIO}};
442
443 auto ret = service.DisableSink(descriptors);
444 EXPECT_EQ(ret, DH_FWK_SUCCESS);
445 }
446
447 /**
448 * @tc.name: EnableSource_001
449 * @tc.desc: Verify the EnableSource function
450 * @tc.type: FUNC
451 * @tc.require: AR000GHSJM
452 */
453 HWTEST_F(DistributedHardwareServiceTest, EnableSource_001, TestSize.Level1)
454 {
455 DistributedHardwareService service(ASID, true);
456 std::string networkId = "111";
457 std::vector<DHDescriptor> descriptors{{"id_test", DHType::AUDIO}};
458
459 auto ret = service.EnableSource(networkId, descriptors);
460 EXPECT_EQ(ret, DH_FWK_SUCCESS);
461
462 networkId = "";
463 ret = service.EnableSource(networkId, descriptors);
464 EXPECT_EQ(ret, ERR_DH_FWK_PARA_INVALID);
465 }
466
467 /**
468 * @tc.name: DisableSource_001
469 * @tc.desc: Verify the DisableSource function
470 * @tc.type: FUNC
471 * @tc.require: AR000GHSJM
472 */
473 HWTEST_F(DistributedHardwareServiceTest, DisableSource_001, TestSize.Level1)
474 {
475 DistributedHardwareService service(ASID, true);
476 std::string networkId = "111";
477 std::vector<DHDescriptor> descriptors{{"id_test", DHType::AUDIO}};
478
479 auto ret = service.DisableSource(networkId, descriptors);
480 EXPECT_EQ(ret, DH_FWK_SUCCESS);
481
482 networkId = "";
483 ret = service.DisableSource(networkId, descriptors);
484 EXPECT_EQ(ret, ERR_DH_FWK_PARA_INVALID);
485 }
486
487 HWTEST_F(DistributedHardwareServiceTest, PauseDistributedHardware_003, TestSize.Level1)
488 {
489 DistributedHardwareService service(ASID, true);
490 std::string networkId = "111";
491 DHType dhType = DHType::AUDIO;
492 IDistributedHardwareSink *sinkPtr = nullptr;
493 ComponentManager::GetInstance().compSink_.insert(std::make_pair(dhType, sinkPtr));
494 auto ret = service.PauseDistributedHardware(dhType, networkId);
495 EXPECT_EQ(ret, ERR_DH_FWK_PARA_INVALID);
496 ComponentManager::GetInstance().compSink_.clear();
497 }
498
499 HWTEST_F(DistributedHardwareServiceTest, PauseDistributedHardware_004, TestSize.Level1)
500 {
501 SetUpComponentLoaderConfig();
502 DistributedHardwareService service(ASID, true);
503 std::string networkId = "111";
504 DHType dhType = DHType::AUDIO;
505 ComponentManager::GetInstance().InitCompSink(dhType);
506 auto ret = service.PauseDistributedHardware(dhType, networkId);
507 EXPECT_NE(ret, DH_FWK_SUCCESS);
508 SetDownComponentLoaderConfig();
509 ComponentManager::GetInstance().compSink_.clear();
510 }
511
512 HWTEST_F(DistributedHardwareServiceTest, ResumeDistributedHardware_002, TestSize.Level1)
513 {
514 DistributedHardwareService service(ASID, true);
515 std::string networkId = "111";
516 auto ret = service.ResumeDistributedHardware(DHType::UNKNOWN, networkId);
517 EXPECT_EQ(ret, ERR_DH_FWK_PARA_INVALID);
518 }
519
520 HWTEST_F(DistributedHardwareServiceTest, ResumeDistributedHardware_003, TestSize.Level1)
521 {
522 DistributedHardwareService service(ASID, true);
523 std::string networkId = "111";
524 DHType dhType = DHType::AUDIO;
525 IDistributedHardwareSink *sinkPtr = nullptr;
526 ComponentManager::GetInstance().compSink_.insert(std::make_pair(dhType, sinkPtr));
527 auto ret = service.ResumeDistributedHardware(dhType, networkId);
528 EXPECT_EQ(ret, ERR_DH_FWK_PARA_INVALID);
529 ComponentManager::GetInstance().compSink_.clear();
530 }
531
532 HWTEST_F(DistributedHardwareServiceTest, ResumeDistributedHardware_004, TestSize.Level1)
533 {
534 SetUpComponentLoaderConfig();
535 DistributedHardwareService service(ASID, true);
536 std::string networkId = "111";
537 DHType dhType = DHType::AUDIO;
538 ComponentManager::GetInstance().InitCompSink(dhType);
539 auto ret = service.ResumeDistributedHardware(dhType, networkId);
540 EXPECT_NE(ret, DH_FWK_SUCCESS);
541 SetDownComponentLoaderConfig();
542 ComponentManager::GetInstance().compSink_.clear();
543 }
544
545 HWTEST_F(DistributedHardwareServiceTest, StopDistributedHardware_002, TestSize.Level1)
546 {
547 DistributedHardwareService service(ASID, true);
548 std::string networkId = "111";
549 auto ret = service.StopDistributedHardware(DHType::UNKNOWN, networkId);
550 EXPECT_EQ(ret, ERR_DH_FWK_PARA_INVALID);
551 }
552
553 HWTEST_F(DistributedHardwareServiceTest, StopDistributedHardware_003, TestSize.Level1)
554 {
555 DistributedHardwareService service(ASID, true);
556 std::string networkId = "111";
557 DHType dhType = DHType::AUDIO;
558 IDistributedHardwareSink *sinkPtr = nullptr;
559 ComponentManager::GetInstance().compSink_.insert(std::make_pair(dhType, sinkPtr));
560 auto ret = service.StopDistributedHardware(dhType, networkId);
561 EXPECT_EQ(ret, ERR_DH_FWK_PARA_INVALID);
562 ComponentManager::GetInstance().compSink_.clear();
563 }
564
565 HWTEST_F(DistributedHardwareServiceTest, StopDistributedHardware_004, TestSize.Level1)
566 {
567 SetUpComponentLoaderConfig();
568 DistributedHardwareService service(ASID, true);
569 std::string networkId = "111";
570 DHType dhType = DHType::AUDIO;
571 ComponentManager::GetInstance().InitCompSink(dhType);
572 auto ret = service.StopDistributedHardware(dhType, networkId);
573 EXPECT_NE(ret, DH_FWK_SUCCESS);
574 SetDownComponentLoaderConfig();
575 ComponentManager::GetInstance().compSink_.clear();
576 }
577
578 HWTEST_F(DistributedHardwareServiceTest, DoBusinessInit_001, TestSize.Level1)
579 {
580 DistributedHardwareService service(ASID, true);
581 auto ret = service.DoBusinessInit();
582 EXPECT_EQ(true, ret);
583 }
584
585 HWTEST_F(DistributedHardwareServiceTest, QueryDhSysSpec_001, TestSize.Level1)
586 {
587 std::string targetKey = "";
588 std::string attrs = "";
589 DistributedHardwareService service(ASID, true);
590 auto ret = service.QueryDhSysSpec(targetKey, attrs);
591 EXPECT_EQ(0, ret.length());
592 }
593
594 HWTEST_F(DistributedHardwareServiceTest, QueryDhSysSpec_002, TestSize.Level1)
595 {
596 std::string targetKey = "histmAudEnc";
597 int32_t target = 100;
598 cJSON *attrJson = cJSON_CreateObject();
599 ASSERT_TRUE(attrJson != nullptr);
600 cJSON_AddNumberToObject(attrJson, targetKey.c_str(), target);
601 char* cjson = cJSON_PrintUnformatted(attrJson);
602 if (cjson == nullptr) {
603 cJSON_Delete(attrJson);
604 return;
605 }
606 std::string attrs(cjson);
607 DistributedHardwareService service(ASID, true);
608 auto ret = service.QueryDhSysSpec(targetKey, attrs);
609 EXPECT_EQ(0, ret.length());
610 cJSON_free(cjson);
611 cJSON_Delete(attrJson);
612
613 cJSON *attrJson1 = cJSON_CreateObject();
614 ASSERT_TRUE(attrJson1 != nullptr);
615 std::string targetKeyValue = "targetKeyValue";
616 cJSON_AddStringToObject(attrJson1, targetKey.c_str(), targetKeyValue.c_str());
617 char* cjson1 = cJSON_PrintUnformatted(attrJson1);
618 if (cjson1 == nullptr) {
619 cJSON_Delete(attrJson1);
620 return;
621 }
622 std::string attrs1(cjson1);
623 ret = service.QueryDhSysSpec(targetKey, attrs1);
624 EXPECT_NE(0, ret.length());
625 cJSON_free(cjson1);
626 cJSON_Delete(attrJson1);
627 }
628
629 HWTEST_F(DistributedHardwareServiceTest, LoadDistributedHDF_001, TestSize.Level1)
630 {
631 DistributedHardwareService service(ASID, true);
632 service.LoadDistributedHDF(DHType::AUDIO);
633 service.LoadDistributedHDF(DHType::CAMERA);
634 EXPECT_EQ(ERR_DH_FWK_NO_HDF_SUPPORT, service.LoadDistributedHDF(DHType::UNKNOWN));
635 service.UnLoadDistributedHDF(DHType::AUDIO);
636 service.UnLoadDistributedHDF(DHType::CAMERA);
637 EXPECT_EQ(ERR_DH_FWK_NO_HDF_SUPPORT, service.UnLoadDistributedHDF(DHType::UNKNOWN));
638 }
639 } // namespace DistributedHardware
640 } // namespace OHOS
641