1 /*
2 * Copyright (c) 2021-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 "component_loader_test.h"
17
18 #include "config_policy_utils.h"
19 #include "component_loader.h"
20 #include "distributed_hardware_log.h"
21 #include "hitrace_meter.h"
22 #include "hidump_helper.h"
23 #include "kvstore_observer.h"
24 #include "cJSON.h"
25 #include "versionmanager/version_manager.h"
26
27 using namespace testing::ext;
28
29 namespace OHOS {
30 namespace DistributedHardware {
SetUpTestCase(void)31 void ComponentLoaderTest::SetUpTestCase(void) {}
32
TearDownTestCase(void)33 void ComponentLoaderTest::TearDownTestCase(void) {}
34
SetUp()35 void ComponentLoaderTest::SetUp()
36 {
37 }
38
TearDown()39 void ComponentLoaderTest::TearDown()
40 {
41 }
42
43 HWTEST_F(ComponentLoaderTest, CheckComponentEnable_001, TestSize.Level1)
44 {
45 CompConfig config = {
46 .name = "name",
47 .type = DHType::UNKNOWN,
48 .compSourceSaId = 4801,
49 .compSinkSaId = 4802
50 };
51 auto ret = ComponentLoader::GetInstance().CheckComponentEnable(config);
52 EXPECT_EQ(true, ret);
53
54 CompConfig config1 = {
55 .name = "name",
56 .type = DHType::INPUT,
57 .compSourceSaId = 4801,
58 .compSinkSaId = 4802
59 };
60 ret = ComponentLoader::GetInstance().CheckComponentEnable(config1);
61 EXPECT_EQ(false, ret);
62 }
63
64 /**
65 * @tc.name: GetLocalDHVersion_001
66 * @tc.desc: Verify the GetLocalDHVersion function.
67 * @tc.type: FUNC
68 * @tc.require: AR000GHSK3
69 */
70 HWTEST_F(ComponentLoaderTest, GetLocalDHVersion_001, TestSize.Level1)
71 {
72 DHVersion dhVersion;
73 ComponentLoader::GetInstance().isLocalVersionInit_.store(false);
74 ComponentLoader::GetInstance().StoreLocalDHVersionInDB();
75 auto ret = ComponentLoader::GetInstance().GetLocalDHVersion(dhVersion);
76 EXPECT_EQ(ERR_DH_FWK_LOADER_GET_LOCAL_VERSION_FAIL, ret);
77
78 ComponentLoader::GetInstance().isLocalVersionInit_.store(true);
79 ret = ComponentLoader::GetInstance().GetLocalDHVersion(dhVersion);
80 EXPECT_EQ(DH_FWK_SUCCESS, ret);
81 }
82
83 /**
84 * @tc.name: GetHardwareHandler_001
85 * @tc.desc: Verify the GetHardwareHandler function.
86 * @tc.type: FUNC
87 * @tc.require: AR000GHSK3
88 */
89 HWTEST_F(ComponentLoaderTest, GetHardwareHandler_001, TestSize.Level1)
90 {
91 IHardwareHandler *hardwareHandlerPtr = nullptr;
92 auto ret = ComponentLoader::GetInstance().GetHardwareHandler(DHType::UNKNOWN, hardwareHandlerPtr);
93 EXPECT_EQ(ERR_DH_FWK_LOADER_HANDLER_IS_NULL, ret);
94
95 CompHandler comHandler;
96 comHandler.hardwareHandler = nullptr;
97 ComponentLoader::GetInstance().compHandlerMap_[DHType::AUDIO] = comHandler;
98 ret = ComponentLoader::GetInstance().GetHardwareHandler(DHType::AUDIO, hardwareHandlerPtr);
99 EXPECT_EQ(ERR_DH_FWK_LOADER_HANDLER_IS_NULL, ret);
100 ComponentLoader::GetInstance().compHandlerMap_.clear();
101 }
102
103 #ifdef DHARDWARE_CLOSE_UT
104 /**
105 * @tc.name: GetHardwareHandler_002
106 * @tc.desc: Verify the GetHardwareHandler function.
107 * @tc.type: FUNC
108 * @tc.require: AR000GHSK3
109 */
110 HWTEST_F(ComponentLoaderTest, GetHardwareHandler_002, TestSize.Level1)
111 {
112 ComponentLoader::GetInstance().Init();
113 IHardwareHandler *hardwareHandlerPtr = nullptr;
114 auto ret = ComponentLoader::GetInstance().GetHardwareHandler(DHType::AUDIO, hardwareHandlerPtr);
115 EXPECT_EQ(DH_FWK_SUCCESS, ret);
116 ComponentLoader::GetInstance().UnInit();
117 }
118 #endif
119
120 /**
121 * @tc.name: GetSource_001
122 * @tc.desc: Verify the GetSource function.
123 * @tc.type: FUNC
124 * @tc.require: AR000GHSK3
125 */
126 HWTEST_F(ComponentLoaderTest, GetSource_001, TestSize.Level1)
127 {
128 IDistributedHardwareSource *sourcePtr = nullptr;
129 auto ret = ComponentLoader::GetInstance().GetSource(DHType::UNKNOWN, sourcePtr);
130 EXPECT_EQ(ERR_DH_FWK_LOADER_HANDLER_IS_NULL, ret);
131
132 CompHandler comHandler;
133 comHandler.sourceHandler = nullptr;
134 ComponentLoader::GetInstance().compHandlerMap_[DHType::AUDIO] = comHandler;
135 ret = ComponentLoader::GetInstance().GetSource(DHType::AUDIO, sourcePtr);
136 EXPECT_EQ(ERR_DH_FWK_LOADER_HANDLER_IS_NULL, ret);
137 }
138
139 #ifdef DHARDWARE_CLOSE_UT
140 /**
141 * @tc.name: GetSource_002
142 * @tc.desc: Verify the GetSource function.
143 * @tc.type: FUNC
144 * @tc.require: AR000GHSK3
145 */
146 HWTEST_F(ComponentLoaderTest, GetSource_002, TestSize.Level1)
147 {
148 ComponentLoader::GetInstance().Init();
149 IDistributedHardwareSource *sourcePtr = nullptr;
150 auto ret = ComponentLoader::GetInstance().GetSource(DHType::AUDIO, sourcePtr);
151 EXPECT_EQ(DH_FWK_SUCCESS, ret);
152 ComponentLoader::GetInstance().UnInit();
153 }
154 #endif
155
156 /**
157 * @tc.name: GetSink_001
158 * @tc.desc: Verify the GetSink function.
159 * @tc.type: FUNC
160 * @tc.require: AR000GHSK3
161 */
162 HWTEST_F(ComponentLoaderTest, GetSink_001, TestSize.Level1)
163 {
164 IDistributedHardwareSink *sinkPtr = nullptr;
165 auto ret = ComponentLoader::GetInstance().GetSink(DHType::UNKNOWN, sinkPtr);
166 EXPECT_EQ(ERR_DH_FWK_LOADER_HANDLER_IS_NULL, ret);
167
168 CompHandler comHandler;
169 comHandler.sinkHandler = nullptr;
170 ComponentLoader::GetInstance().compHandlerMap_[DHType::AUDIO] = comHandler;
171 ret = ComponentLoader::GetInstance().GetSink(DHType::AUDIO, sinkPtr);
172 EXPECT_EQ(ERR_DH_FWK_LOADER_HANDLER_IS_NULL, ret);
173 ComponentLoader::GetInstance().compHandlerMap_.clear();
174 }
175
176 #ifdef DHARDWARE_CLOSE_UT
177 /**
178 * @tc.name: GetSink_002
179 * @tc.desc: Verify the GetSink function.
180 * @tc.type: FUNC
181 * @tc.require: AR000GHSK3
182 */
183 HWTEST_F(ComponentLoaderTest, GetSink_002, TestSize.Level1)
184 {
185 ComponentLoader::GetInstance().Init();
186 IDistributedHardwareSink *sinkPtr = nullptr;
187 auto ret = ComponentLoader::GetInstance().GetSink(DHType::AUDIO, sinkPtr);
188 EXPECT_EQ(DH_FWK_SUCCESS, ret);
189 ComponentLoader::GetInstance().UnInit();
190 }
191 #endif
192
193 /**
194 * @tc.name: Readfile_001
195 * @tc.desc: Verify the Readfile function.
196 * @tc.type: FUNC
197 * @tc.require: AR000GHSK3
198 */
199 HWTEST_F(ComponentLoaderTest, Readfile_001, TestSize.Level1)
200 {
201 std::string filePath = "";
202 auto ret = ComponentLoader::GetInstance().Readfile(filePath);
203 EXPECT_EQ("", ret);
204 }
205
206 /**
207 * @tc.name: ReleaseHardwareHandler_001
208 * @tc.desc: Verify the ReleaseHardwareHandler function.
209 * @tc.type: FUNC
210 * @tc.require: AR000GHSK3
211 */
212 HWTEST_F(ComponentLoaderTest, ReleaseHardwareHandler_001, TestSize.Level1)
213 {
214 auto ret = ComponentLoader::GetInstance().ReleaseHardwareHandler(DHType::AUDIO);
215 EXPECT_EQ(ERR_DH_FWK_TYPE_NOT_EXIST, ret);
216
217 CompHandler comHandler;
218 comHandler.hardwareHandler = nullptr;
219 ComponentLoader::GetInstance().compHandlerMap_[DHType::AUDIO] = comHandler;
220 ret = ComponentLoader::GetInstance().ReleaseHardwareHandler(DHType::AUDIO);
221 EXPECT_EQ(ERR_DH_FWK_LOADER_HANDLER_UNLOAD, ret);
222 ComponentLoader::GetInstance().compHandlerMap_.clear();
223 }
224
225 /**
226 * @tc.name: ReleaseSource_001
227 * @tc.desc: Verify the ReleaseSource function.
228 * @tc.type: FUNC
229 * @tc.require: AR000GHSK3
230 */
231 HWTEST_F(ComponentLoaderTest, ReleaseSource_001, TestSize.Level1)
232 {
233 auto ret = ComponentLoader::GetInstance().ReleaseSource(DHType::AUDIO);
234 EXPECT_EQ(ERR_DH_FWK_TYPE_NOT_EXIST, ret);
235
236 CompHandler comHandler;
237 comHandler.sourceHandler = nullptr;
238 ComponentLoader::GetInstance().compHandlerMap_[DHType::AUDIO] = comHandler;
239 ret = ComponentLoader::GetInstance().ReleaseSource(DHType::AUDIO);
240 EXPECT_EQ(ERR_DH_FWK_LOADER_SOURCE_UNLOAD, ret);
241 ComponentLoader::GetInstance().compHandlerMap_.clear();
242 }
243
244 /**
245 * @tc.name: ReleaseSink_001
246 * @tc.desc: Verify the ReleaseSink function.
247 * @tc.type: FUNC
248 * @tc.require: AR000GHSK3
249 */
250 HWTEST_F(ComponentLoaderTest, ReleaseSink_001, TestSize.Level1)
251 {
252 auto ret = ComponentLoader::GetInstance().ReleaseSink(DHType::AUDIO);
253 EXPECT_EQ(ERR_DH_FWK_TYPE_NOT_EXIST, ret);
254
255 CompHandler comHandler;
256 comHandler.sinkHandler = nullptr;
257 ComponentLoader::GetInstance().compHandlerMap_[DHType::AUDIO] = comHandler;
258 ret = ComponentLoader::GetInstance().ReleaseSink(DHType::AUDIO);
259 EXPECT_EQ(ERR_DH_FWK_LOADER_SINK_UNLOAD, ret);
260 ComponentLoader::GetInstance().compHandlerMap_.clear();
261 }
262
263 /**
264 * @tc.name: GetHandler_001
265 * @tc.desc: Verify the GetHandler function.
266 * @tc.type: FUNC
267 * @tc.require: AR000GHSK3
268 */
269 HWTEST_F(ComponentLoaderTest, GetHandler_001, TestSize.Level1)
270 {
271 std::string soNameEmpty = "";
272 auto handler = ComponentLoader::GetInstance().GetHandler(soNameEmpty);
273 EXPECT_EQ(nullptr, handler);
274 }
275
276 /**
277 * @tc.name: component_loader_test_017
278 * @tc.desc: Verify the GetCompPathAndVersion function.
279 * @tc.type: FUNC
280 * @tc.require: AR000GHSK3
281 */
282 HWTEST_F(ComponentLoaderTest, component_loader_test_017, TestSize.Level1)
283 {
284 std::string jsonStr = "";
285 std::map<DHType, CompConfig> dhtypeMap;
286 int32_t ret = ComponentLoader::GetInstance().GetCompPathAndVersion(jsonStr, dhtypeMap);
287 EXPECT_EQ(ERR_DH_FWK_PARA_INVALID, ret);
288 }
289
290 /**
291 * @tc.name: component_loader_test_018
292 * @tc.desc: Verify the GetCompPathAndVersion function.
293 * @tc.type: FUNC
294 * @tc.require: AR000GHSK3
295 */
296 HWTEST_F(ComponentLoaderTest, component_loader_test_018, TestSize.Level1)
297 {
298 const char *NAME = "NAME";
299 const char *TYPE = "TYPE";
300 const char *PATH = "PATH";
301 cJSON* json0bject = cJSON_CreateObject();
302 ASSERT_TRUE(json0bject != nullptr);
303 cJSON* compVers = cJSON_CreateObject();
304 if (compVers == nullptr) {
305 cJSON_Delete(json0bject);
306 return;
307 }
308 cJSON_AddStringToObject(compVers, NAME, "name");
309 cJSON_AddNumberToObject(compVers, TYPE, 1111);
310 cJSON_AddItemToObject(json0bject, PATH, compVers);
311 char* cjson = cJSON_PrintUnformatted(json0bject);
312 if (cjson == nullptr) {
313 cJSON_Delete(json0bject);
314 return;
315 }
316 std::string jsonStr(cjson);
317 std::map<DHType, CompConfig> dhtypeMap;
318 int32_t ret = ComponentLoader::GetInstance().GetCompPathAndVersion(jsonStr, dhtypeMap);
319 cJSON_free(cjson);
320 cJSON_Delete(json0bject);
321 EXPECT_EQ(ERR_DH_FWK_PARA_INVALID, ret);
322 }
323
324 /**
325 * @tc.name: IsDHTypeExist_001
326 * @tc.desc: Verify the IsDHTypeExist function.
327 * @tc.type: FUNC
328 * @tc.require: AR000GHSK3
329 */
330 HWTEST_F(ComponentLoaderTest, IsDHTypeExist_001, TestSize.Level1)
331 {
332 CompHandler comHandler;
333 ComponentLoader::GetInstance().compHandlerMap_[DHType::AUDIO] = comHandler;
334 bool ret = ComponentLoader::GetInstance().IsDHTypeExist(DHType::AUDIO);
335 EXPECT_EQ(true, ret);
336 ComponentLoader::GetInstance().compHandlerMap_.clear();
337 }
338
339 /**
340 * @tc.name: GetSourceSaId_001
341 * @tc.desc: Verify the GetSourceSaId function.
342 * @tc.type: FUNC
343 * @tc.require: AR000GHSK3
344 */
345 HWTEST_F(ComponentLoaderTest, GetSourceSaId_001, TestSize.Level1)
346 {
347 CompHandler comHandler;
348 ComponentLoader::GetInstance().compHandlerMap_[DHType::AUDIO] = comHandler;
349 int32_t ret = ComponentLoader::GetInstance().GetSourceSaId(DHType::UNKNOWN);
350 EXPECT_EQ(DEFAULT_SA_ID, ret);
351
352 comHandler.sourceSaId = 1;
353 ComponentLoader::GetInstance().compHandlerMap_[DHType::AUDIO] = comHandler;
354 ret = ComponentLoader::GetInstance().GetSourceSaId(DHType::AUDIO);
355 EXPECT_EQ(1, ret);
356 }
357
358 /**
359 * @tc.name: component_loader_test_022
360 * @tc.desc: Verify the ParseConfig function.
361 * @tc.type: FUNC
362 * @tc.require: AR000GHSK3
363 */
364 HWTEST_F(ComponentLoaderTest, component_loader_test_022, TestSize.Level1)
365 {
366 int32_t ret = ComponentLoader::GetInstance().ParseConfig();
367 EXPECT_EQ(DH_FWK_SUCCESS, ret);
368 }
369
370 /**
371 * @tc.name: component_loader_test_023
372 * @tc.desc: Verify the ReleaseHandler function.
373 * @tc.type: FUNC
374 * @tc.require: AR000GHSK3
375 */
376 HWTEST_F(ComponentLoaderTest, component_loader_test_023, TestSize.Level1)
377 {
378 void *handler = nullptr;
379 int32_t ret = ComponentLoader::GetInstance().ReleaseHandler(handler);
380 EXPECT_EQ(ERR_DH_FWK_LOADER_HANDLER_IS_NULL, ret);
381 }
382
383 /**
384 * @tc.name: component_loader_test_024
385 * @tc.desc: Verify the ReleaseHardwareHandler function.
386 * @tc.type: FUNC
387 * @tc.require: AR000GHSK3
388 */
389 HWTEST_F(ComponentLoaderTest, component_loader_test_024, TestSize.Level1)
390 {
391 DHType dhType = DHType::GPS;
392 int32_t ret = ComponentLoader::GetInstance().ReleaseHardwareHandler(dhType);
393 EXPECT_EQ(ERR_DH_FWK_TYPE_NOT_EXIST, ret);
394 }
395
396 /**
397 * @tc.name: component_loader_test_025
398 * @tc.desc: Verify the ReleaseSource function.
399 * @tc.type: FUNC
400 * @tc.require: AR000GHSK3
401 */
402 HWTEST_F(ComponentLoaderTest, component_loader_test_025, TestSize.Level1)
403 {
404 DHType dhType = DHType::GPS;
405 int32_t ret = ComponentLoader::GetInstance().ReleaseSource(dhType);
406 EXPECT_EQ(ERR_DH_FWK_TYPE_NOT_EXIST, ret);
407 }
408
409 /**
410 * @tc.name: component_loader_test_026
411 * @tc.desc: Verify the ReleaseSink function.
412 * @tc.type: FUNC
413 * @tc.require: AR000GHSK3
414 */
415 HWTEST_F(ComponentLoaderTest, component_loader_test_026, TestSize.Level1)
416 {
417 DHType dhType = DHType::GPS;
418 int32_t ret = ComponentLoader::GetInstance().ReleaseSink(dhType);
419 EXPECT_EQ(ERR_DH_FWK_TYPE_NOT_EXIST, ret);
420 }
421
422 /**
423 * @tc.name: component_loader_test_027
424 * @tc.desc: Verify the ReleaseSink function.
425 * @tc.type: FUNC
426 * @tc.require: AR000GHSK3
427 */
428 HWTEST_F(ComponentLoaderTest, component_loader_test_027, TestSize.Level1)
429 {
430 DHType dhType = DHType::GPS;
431 bool ret = ComponentLoader::GetInstance().IsDHTypeExist(dhType);
432 EXPECT_EQ(false, ret);
433 }
434
435 /**
436 * @tc.name: component_loader_test_028
437 * @tc.desc: Verify the GetDHTypeBySrcSaId function.
438 * @tc.type: FUNC
439 * @tc.require: AR000GHSK3
440 */
441 HWTEST_F(ComponentLoaderTest, component_loader_test_028, TestSize.Level1)
442 {
443 int32_t saId = 4801;
444 DHType dhType = ComponentLoader::GetInstance().GetDHTypeBySrcSaId(saId);
445 EXPECT_EQ(dhType, DHType::UNKNOWN);
446 }
447
448 HWTEST_F(ComponentLoaderTest, ParseResourceDesc_001, TestSize.Level1)
449 {
450 CompConfig config;
451 cJSON *component = cJSON_CreateObject();
452 ASSERT_TRUE(component != nullptr);
453 cJSON_AddNumberToObject(component, COMP_NAME, 1);
454 cJSON_AddNumberToObject(component, COMP_TYPE, 1);
455 cJSON_AddNumberToObject(component, COMP_HANDLER_LOC, 1);
456 cJSON_AddNumberToObject(component, COMP_HANDLER_VERSION, 1.0);
457 cJSON_AddNumberToObject(component, COMP_SOURCE_LOC, 1);
458 cJSON_AddNumberToObject(component, COMP_SOURCE_VERSION, 1.0);
459 cJSON_AddStringToObject(component, COMP_SOURCE_SA_ID, "4801");
460 cJSON_AddNumberToObject(component, COMP_SINK_LOC, 1);
461 cJSON_AddNumberToObject(component, COMP_SINK_VERSION, 1.0);
462 cJSON_AddStringToObject(component, COMP_SINK_SA_ID, "4802");
463 cJSON_AddStringToObject(component, COMP_RESOURCE_DESC, "comp_resource_desc");
464 ComponentLoader::GetInstance().ParseCompConfigFromJson(component, config);
465 cJSON_Delete(component);
466 }
467
468 HWTEST_F(ComponentLoaderTest, ParseResourceDesc_002, TestSize.Level1)
469 {
470 CompConfig config1;
471 cJSON *component1 = cJSON_CreateObject();
472 ASSERT_TRUE(component1 != nullptr);
473 cJSON_AddStringToObject(component1, COMP_NAME, "comp_name_test");
474 cJSON_AddStringToObject(component1, COMP_TYPE, "comp_type_test");
475 cJSON_AddStringToObject(component1, COMP_HANDLER_LOC, "comp_handler_loc_test");
476 cJSON_AddStringToObject(component1, COMP_HANDLER_VERSION, "comp_handler_version_test");
477 cJSON_AddStringToObject(component1, COMP_SOURCE_LOC, "comp_source_loc_test");
478 cJSON_AddStringToObject(component1, COMP_SOURCE_VERSION, "comp_source_verison_test");
479 cJSON_AddNumberToObject(component1, COMP_SOURCE_SA_ID, 4801);
480 cJSON_AddStringToObject(component1, COMP_SINK_LOC, "comp_sink_loc_test");
481 cJSON_AddStringToObject(component1, COMP_SINK_VERSION, "com_sink_version_test");
482 cJSON_AddNumberToObject(component1, COMP_SINK_SA_ID, 4802);
483 cJSON_AddStringToObject(component1, COMP_RESOURCE_DESC, "comp_resource_desc");
484 ASSERT_NO_FATAL_FAILURE(ComponentLoader::GetInstance().ParseCompConfigFromJson(component1, config1));
485 cJSON_Delete(component1);
486 }
487
488 HWTEST_F(ComponentLoaderTest, ParseResourceDescFromJson_003, TestSize.Level1)
489 {
490 CompConfig config;
491 cJSON *resourceDescs = cJSON_CreateArray();
492 ASSERT_TRUE(resourceDescs != nullptr);
493 cJSON *sensitive = cJSON_CreateObject();
494 if (sensitive == nullptr) {
495 cJSON_Delete(resourceDescs);
496 return;
497 }
498 cJSON_AddBoolToObject(sensitive, COMP_SENSITIVE, true);
499 cJSON_AddItemToArray(resourceDescs, sensitive);
500 cJSON *subtype = cJSON_CreateObject();
501 if (subtype == nullptr) {
502 cJSON_Delete(resourceDescs);
503 return;
504 }
505 cJSON_AddBoolToObject(subtype, COMP_SUBTYPE, true);
506 cJSON_AddItemToArray(resourceDescs, subtype);
507 ComponentLoader::GetInstance().ParseResourceDescFromJson(resourceDescs, config);
508 cJSON_Delete(resourceDescs);
509 EXPECT_TRUE(config.compResourceDesc.empty());
510 }
511
512 HWTEST_F(ComponentLoaderTest, GetHardwareHandler_003, TestSize.Level1)
513 {
514 ComponentLoader::GetInstance().compHandlerMap_.clear();
515 DHType dhType = DHType::AUDIO;
516 IHardwareHandler *hardwareHandlerPtr = nullptr;
517 auto ret = ComponentLoader::GetInstance().GetHardwareHandler(dhType, hardwareHandlerPtr);
518 EXPECT_EQ(ret, ERR_DH_FWK_LOADER_HANDLER_IS_NULL);
519 }
520
521 HWTEST_F(ComponentLoaderTest, GetSource_003, TestSize.Level1)
522 {
523 ComponentLoader::GetInstance().compHandlerMap_.clear();
524 DHType dhType = DHType::AUDIO;
525 IDistributedHardwareSource *dhSourcePtr = nullptr;
526 auto ret = ComponentLoader::GetInstance().GetSource(dhType, dhSourcePtr);
527 EXPECT_EQ(ret, ERR_DH_FWK_LOADER_HANDLER_IS_NULL);
528 }
529
530 HWTEST_F(ComponentLoaderTest, GetSink_003, TestSize.Level1)
531 {
532 ComponentLoader::GetInstance().compHandlerMap_.clear();
533 DHType dhType = DHType::AUDIO;
534 IDistributedHardwareSink *dhSinkPtr = nullptr;
535 auto ret = ComponentLoader::GetInstance().GetSink(dhType, dhSinkPtr);
536 EXPECT_EQ(ret, ERR_DH_FWK_LOADER_HANDLER_IS_NULL);
537 }
538
539 HWTEST_F(ComponentLoaderTest, ReleaseHardwareHandler_002, TestSize.Level1)
540 {
541 ComponentLoader::GetInstance().compHandlerMap_.clear();
542 DHType dhType = DHType::AUDIO;
543 auto ret = ComponentLoader::GetInstance().ReleaseHardwareHandler(dhType);
544 EXPECT_EQ(ret, ERR_DH_FWK_TYPE_NOT_EXIST);
545
546 ret = ComponentLoader::GetInstance().ReleaseSource(dhType);
547 EXPECT_EQ(ret, ERR_DH_FWK_TYPE_NOT_EXIST);
548
549 ret = ComponentLoader::GetInstance().ReleaseSource(dhType);
550 EXPECT_EQ(ret, ERR_DH_FWK_TYPE_NOT_EXIST);
551
552 ret = ComponentLoader::GetInstance().GetSourceSaId(dhType);
553 EXPECT_EQ(ret, DEFAULT_SA_ID);
554 }
555
556 HWTEST_F(ComponentLoaderTest, GetDHTypeBySrcSaId_001, TestSize.Level1)
557 {
558 ComponentLoader::GetInstance().compHandlerMap_.clear();
559 int32_t saId = 4801;
560 auto ret = ComponentLoader::GetInstance().GetDHTypeBySrcSaId(saId);
561 EXPECT_EQ(ret, DHType::UNKNOWN);
562 }
563
564 HWTEST_F(ComponentLoaderTest, GetSource_004, TestSize.Level1)
565 {
566 auto ret = ComponentLoader::GetInstance().GetSource(DHType::AUDIO);
567 EXPECT_EQ(ret, ERR_DH_FWK_LOADER_HANDLER_IS_NULL);
568 }
569
570 HWTEST_F(ComponentLoaderTest, GetSink_004, TestSize.Level1)
571 {
572 auto ret = ComponentLoader::GetInstance().GetSink(DHType::AUDIO);
573 EXPECT_EQ(ret, ERR_DH_FWK_LOADER_HANDLER_IS_NULL);
574 }
575
576 HWTEST_F(ComponentLoaderTest, GetHardwareHandler_004, TestSize.Level1)
577 {
578 auto ret = ComponentLoader::GetInstance().GetHardwareHandler(DHType::AUDIO);
579 EXPECT_EQ(ret, ERR_DH_FWK_LOADER_HANDLER_IS_NULL);
580 }
581
582 HWTEST_F(ComponentLoaderTest, IsDHTypeSupport_001, TestSize.Level1)
583 {
584 auto ret = ComponentLoader::GetInstance().IsDHTypeSupport(DHType::AUDIO);
585 EXPECT_EQ(ret, false);
586 }
587
588 HWTEST_F(ComponentLoaderTest, ParseSourceFeatureFiltersFromJson_001, TestSize.Level1)
589 {
590 CompConfig config;
591 cJSON *srcFilters = cJSON_CreateArray();
592 ASSERT_TRUE(srcFilters != nullptr);
593 ComponentLoader::GetInstance().ParseSourceFeatureFiltersFromJson(srcFilters, config);
594 EXPECT_TRUE(config.sourceFeatureFilters.empty());
595 cJSON_Delete(srcFilters);
596
597 cJSON *srcFilters1 = cJSON_CreateArray();
598 ASSERT_TRUE(srcFilters1 != nullptr);
599 cJSON_AddItemToArray(srcFilters1, cJSON_CreateString("dcamera_1"));
600 cJSON_AddItemToArray(srcFilters1, cJSON_CreateNumber(1));
601 ComponentLoader::GetInstance().ParseSourceFeatureFiltersFromJson(srcFilters1, config);
602 EXPECT_FALSE(config.sourceFeatureFilters.empty());
603 cJSON_Delete(srcFilters1);
604 }
605
606 HWTEST_F(ComponentLoaderTest, ParseSinkSupportedFeaturesFromJson_001, TestSize.Level1)
607 {
608 CompConfig config;
609 cJSON *sinkFilters = cJSON_CreateArray();
610 ASSERT_TRUE(sinkFilters != nullptr);
611 ComponentLoader::GetInstance().ParseSinkSupportedFeaturesFromJson(sinkFilters, config);
612 EXPECT_TRUE(config.sinkSupportedFeatures.empty());
613 cJSON_Delete(sinkFilters);
614
615 cJSON *sinkFilters1 = cJSON_CreateArray();
616 ASSERT_TRUE(sinkFilters1 != nullptr);
617 cJSON_AddItemToArray(sinkFilters1, cJSON_CreateString("dcamera_1"));
618 cJSON_AddItemToArray(sinkFilters1, cJSON_CreateNumber(1));
619 ComponentLoader::GetInstance().ParseSinkSupportedFeaturesFromJson(sinkFilters1, config);
620 EXPECT_FALSE(config.sinkSupportedFeatures.empty());
621 cJSON_Delete(sinkFilters1);
622 }
623 } // namespace DistributedHardware
624 } // namespace OHOS
625