1 /*
2 * Copyright (c) 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 #include "audio_effect.h"
16 #include "audio_effect_service_test.h"
17
18 using namespace testing::ext;
19
20 namespace OHOS {
21 namespace AudioStandard {
22
SetUpTestCase(void)23 void AudioEffectServiceTest::SetUpTestCase(void) {}
TearDownTestCase(void)24 void AudioEffectServiceTest::TearDownTestCase(void) {}
SetUp(void)25 void AudioEffectServiceTest::SetUp(void) {}
TearDown(void)26 void AudioEffectServiceTest::TearDown(void) {}
27
28 /**
29 * @tc.name : Test AudioEffectService.
30 * @tc.number: AudioEffectService_001.
31 * @tc.desc : Test EffectServiceInit interfaces.
32 */
33 HWTEST(AudioEffectServiceTest, AudioEffectService_001, TestSize.Level1)
34 {
35 auto audioEffectService_ = std::make_shared<AudioEffectService>();
36 audioEffectService_->EffectServiceInit();
37 EXPECT_NE(audioEffectService_, nullptr);
38 }
39
40 /**
41 * @tc.name : Test AudioEffectService.
42 * @tc.number: audioEffectService_002.
43 * @tc.desc : Test VerifySceneMappingItem interfaces.
44 */
45 HWTEST(AudioEffectServiceTest, audioEffectService_002, TestSize.Level1)
46 {
47 auto audioEffectService_ = std::make_shared<AudioEffectService>();
48 SceneMappingItem item;
49 audioEffectService_->VerifySceneMappingItem(item);
50 EXPECT_NE(audioEffectService_, nullptr);
51
52 item.name = "STREAM_USAGE_UNKNOWN";
53 audioEffectService_->VerifySceneMappingItem(item);
54 EXPECT_NE(audioEffectService_, nullptr);
55 }
56
57 /**
58 * @tc.name : Test AudioEffectService.
59 * @tc.number: audioEffectService_003.
60 * @tc.desc : Test UpdateEffectChains interfaces.
61 */
62 HWTEST(AudioEffectServiceTest, audioEffectService_003, TestSize.Level1)
63 {
64 auto audioEffectService_ = std::make_shared<AudioEffectService>();
65 std::vector<std::string> availableLayout;
66 audioEffectService_->UpdateEffectChains(availableLayout);
67 EXPECT_NE(audioEffectService_, nullptr);
68
69 EffectChain effectChain;
70 audioEffectService_->supportedEffectConfig_.effectChains.push_back(effectChain);
71 for (auto it = audioEffectService_->supportedEffectConfig_.effectChains.begin();
72 it != audioEffectService_->supportedEffectConfig_.effectChains.end(); ++it) {
73 it->apply.push_back("test");
74 }
75 audioEffectService_->UpdateEffectChains(availableLayout);
76 EXPECT_NE(audioEffectService_, nullptr);
77 }
78
79 /**
80 * @tc.name : Test AudioEffectService.
81 * @tc.number: audioEffectService_004.
82 * @tc.desc : Test UpdateAvailableAEConfig interfaces.
83 */
84 HWTEST(AudioEffectServiceTest, audioEffectService_004, TestSize.Level1)
85 {
86 auto audioEffectService_ = std::make_shared<AudioEffectService>();
87 OriginalEffectConfig aeConfig;
88 SceneMappingItem sceneMappingItem;
89 aeConfig.postProcess.sceneMap.push_back(sceneMappingItem);
90 audioEffectService_->UpdateAvailableAEConfig(aeConfig);
91 EXPECT_NE(audioEffectService_, nullptr);
92
93 Stream newStream;
94 audioEffectService_->supportedEffectConfig_.postProcessNew.stream.push_back(newStream);
95 audioEffectService_->UpdateAvailableAEConfig(aeConfig);
96 EXPECT_NE(audioEffectService_, nullptr);
97 }
98
99 /**
100 * @tc.name : Test AudioEffectService.
101 * @tc.number: audioEffectService_005.
102 * @tc.desc : Test UpdateUnsupportedModePre interfaces.
103 */
104 HWTEST(AudioEffectServiceTest, audioEffectService_005, TestSize.Level1)
105 {
106 auto audioEffectService_ = std::make_shared<AudioEffectService>();
107 PreStreamScene preStreamScene;
108 OriginalEffectConfig aeConfig;
109 aeConfig.preProcess.defaultScenes.push_back(preStreamScene);
110 audioEffectService_->UpdateAvailableAEConfig(aeConfig);
111 EXPECT_NE(audioEffectService_, nullptr);
112 }
113
114 /**
115 * @tc.name : Test AudioEffectService.
116 * @tc.number: audioEffectService_006.
117 * @tc.desc : Test UpdateUnsupportedModePre/UpdateUnsupportedDevicePre interfaces.
118 */
119 HWTEST(AudioEffectServiceTest, audioEffectService_006, TestSize.Level1)
120 {
121 auto audioEffectService_ = std::make_shared<AudioEffectService>();
122 PreStreamScene preStreamScene;
123 preStreamScene.mode.push_back("ENHANCE");
124 preStreamScene.stream = "SCENE_VOIP_UP";
125 OriginalEffectConfig aeConfig;
126 aeConfig.preProcess.defaultScenes.push_back(preStreamScene);
127 audioEffectService_->UpdateAvailableAEConfig(aeConfig);
128 EXPECT_NE(audioEffectService_, nullptr);
129 }
130
131 /**
132 * @tc.name : Test AudioEffectService.
133 * @tc.number: audioEffectService_007.
134 * @tc.desc : Test UpdateUnsupportedModePre/UpdateUnsupportedDevicePre interfaces.
135 */
136 HWTEST(AudioEffectServiceTest, audioEffectService_007, TestSize.Level1)
137 {
138 auto audioEffectService_ = std::make_shared<AudioEffectService>();
139 PreStreamScene preStreamScene;
140 preStreamScene.mode.push_back("ENHANCE_NONE");
141 preStreamScene.stream = "SCENE_VOIP_UP";
142 OriginalEffectConfig aeConfig;
143 aeConfig.preProcess.defaultScenes.push_back(preStreamScene);
144 audioEffectService_->UpdateAvailableAEConfig(aeConfig);
145 EXPECT_NE(audioEffectService_, nullptr);
146 }
147
148 /**
149 * @tc.name : Test AudioEffectService.
150 * @tc.number: audioEffectService_008.
151 * @tc.desc : Test UpdateUnsupportedModePre/UpdateUnsupportedDevicePre interfaces.
152 */
153 HWTEST(AudioEffectServiceTest, audioEffectService_008, TestSize.Level1)
154 {
155 auto audioEffectService_ = std::make_shared<AudioEffectService>();
156 PreStreamScene preStreamScene;
157 preStreamScene.mode.push_back("ENHANCE_DEFAULT");
158 preStreamScene.stream = "SCENE_VOIP_UP";
159 OriginalEffectConfig aeConfig;
160 Device device;
161 std::vector<Device> newDevice;
162 newDevice.push_back(device);
163 preStreamScene.device.push_back(newDevice);
164 aeConfig.preProcess.defaultScenes.push_back(preStreamScene);
165 audioEffectService_->UpdateAvailableAEConfig(aeConfig);
166 EXPECT_NE(audioEffectService_, nullptr);
167 }
168
169 /**
170 * @tc.name : Test AudioEffectService.
171 * @tc.number: audioEffectService_009.
172 * @tc.desc : Test UpdateUnsupportedModePost interfaces.
173 */
174 HWTEST(AudioEffectServiceTest, audioEffectService_009, TestSize.Level1)
175 {
176 auto audioEffectService_ = std::make_shared<AudioEffectService>();
177 PostStreamScene postStreamScene;
178 OriginalEffectConfig aeConfig;
179 aeConfig.postProcess.defaultScenes.push_back(postStreamScene);
180 audioEffectService_->UpdateAvailableAEConfig(aeConfig);
181 EXPECT_NE(audioEffectService_, nullptr);
182 }
183
184 /**
185 * @tc.name : Test AudioEffectService.
186 * @tc.number: audioEffectService_010.
187 * @tc.desc : Test UpdateUnsupportedModePost/UpdateUnsupportedDevicePost interfaces.
188 */
189 HWTEST(AudioEffectServiceTest, audioEffectService_010, TestSize.Level1)
190 {
191 auto audioEffectService_ = std::make_shared<AudioEffectService>();
192 PostStreamScene postStreamScene;
193 postStreamScene.mode.push_back("EFFECT");
194 postStreamScene.stream = "SCENE_OTHERS";
195 OriginalEffectConfig aeConfig;
196 aeConfig.postProcess.defaultScenes.push_back(postStreamScene);
197 audioEffectService_->UpdateAvailableAEConfig(aeConfig);
198 EXPECT_NE(audioEffectService_, nullptr);
199 }
200
201 /**
202 * @tc.name : Test AudioEffectService.
203 * @tc.number: audioEffectService_011.
204 * @tc.desc : Test UpdateUnsupportedModePost/UpdateUnsupportedDevicePost interfaces.
205 */
206 HWTEST(AudioEffectServiceTest, audioEffectService_011, TestSize.Level1)
207 {
208 auto audioEffectService_ = std::make_shared<AudioEffectService>();
209 PostStreamScene postStreamScene;
210 postStreamScene.mode.push_back("EFFECT_NONE");
211 postStreamScene.stream = "SCENE_OTHERS";
212 OriginalEffectConfig aeConfig;
213 aeConfig.postProcess.defaultScenes.push_back(postStreamScene);
214 audioEffectService_->UpdateAvailableAEConfig(aeConfig);
215 EXPECT_NE(audioEffectService_, nullptr);
216 }
217
218 /**
219 * @tc.name : Test AudioEffectService.
220 * @tc.number: audioEffectService_012.
221 * @tc.desc : Test UpdateUnsupportedModePost/UpdateUnsupportedDevicePost interfaces.
222 */
223 HWTEST(AudioEffectServiceTest, audioEffectService_012, TestSize.Level1)
224 {
225 auto audioEffectService_ = std::make_shared<AudioEffectService>();
226 PostStreamScene postStreamScene;
227 postStreamScene.mode.push_back("EFFECT_DEFAULT");
228 postStreamScene.stream = "SCENE_OTHERS";
229 OriginalEffectConfig aeConfig;
230 Device device;
231 std::vector<Device> newDevice;
232 newDevice.push_back(device);
233 postStreamScene.device.push_back(newDevice);
234 aeConfig.postProcess.defaultScenes.push_back(postStreamScene);
235 audioEffectService_->UpdateAvailableAEConfig(aeConfig);
236 EXPECT_NE(audioEffectService_, nullptr);
237 }
238
239 /**
240 * @tc.name : Test AudioEffectService.
241 * @tc.number: audioEffectService_013.
242 * @tc.desc : Test UpdateAvailableSceneMapPost interfaces.
243 */
244 HWTEST(AudioEffectServiceTest, audioEffectService_013, TestSize.Level1)
245 {
246 auto audioEffectService_ = std::make_shared<AudioEffectService>();
247 OriginalEffectConfig aeConfig;
248 SceneMappingItem sceneMappingItem;
249 sceneMappingItem.name = "STREAM_USAGE_MEDIA";
250 sceneMappingItem.sceneType = "sceneType";
251 audioEffectService_->postSceneTypeSet_.push_back("sceneType");
252 aeConfig.postProcess.sceneMap.push_back(sceneMappingItem);
253 audioEffectService_->UpdateAvailableAEConfig(aeConfig);
254 EXPECT_NE(audioEffectService_, nullptr);
255 }
256
257 /**
258 * @tc.name : Test AudioEffectService.
259 * @tc.number: audioEffectService_014.
260 * @tc.desc : Test UpdateDuplicateBypassMode interfaces.
261 */
262 HWTEST(AudioEffectServiceTest, audioEffectService_014, TestSize.Level1)
263 {
264 auto audioEffectService_ = std::make_shared<AudioEffectService>();
265 Stream newStream1;
266 Stream newStream2;
267 ProcessNew processNew;
268 StreamEffectMode streamEffect;
269 processNew.stream.push_back(newStream1);
270 streamEffect.mode = "EFFECT_NONE";
271 newStream2.streamEffectMode.push_back(streamEffect);
272 processNew.stream.push_back(newStream2);
273 audioEffectService_->UpdateDuplicateBypassMode(processNew);
274 EXPECT_NE(audioEffectService_, nullptr);
275 }
276
277 /**
278 * @tc.name : Test AudioEffectService.
279 * @tc.number: audioEffectService_015.
280 * @tc.desc : Test UpdateDuplicateMode interfaces.
281 */
282 HWTEST(AudioEffectServiceTest, audioEffectService_015, TestSize.Level1)
283 {
284 auto audioEffectService_ = std::make_shared<AudioEffectService>();
285 Stream newStream;
286 ProcessNew processNew;
287 StreamEffectMode streamEffect;
288 newStream.streamEffectMode.push_back(streamEffect);
289 processNew.stream.push_back(newStream);
290 audioEffectService_->UpdateDuplicateMode(processNew);
291 EXPECT_NE(audioEffectService_, nullptr);
292 }
293
294 /**
295 * @tc.name : Test AudioEffectService.
296 * @tc.number: audioEffectService_016.
297 * @tc.desc : Test UpdateDuplicateDevice interfaces.
298 */
299 HWTEST(AudioEffectServiceTest, audioEffectService_016, TestSize.Level1)
300 {
301 auto audioEffectService_ = std::make_shared<AudioEffectService>();
302 Device device1;
303 Device device2;
304 Stream newStream;
305 ProcessNew processNew;
306 StreamEffectMode streamEffect;
307 device1.type = "test";
308 device2.type = "test";
309 streamEffect.devicePort.push_back(device1);
310 streamEffect.devicePort.push_back(device2);
311 newStream.streamEffectMode.push_back(streamEffect);
312 processNew.stream.push_back(newStream);
313 audioEffectService_->UpdateDuplicateDevice(processNew);
314 EXPECT_NE(audioEffectService_, nullptr);
315 }
316
317 /**
318 * @tc.name : Test AudioEffectService.
319 * @tc.number: audioEffectService_017.
320 * @tc.desc : Test UpdateDuplicateScene interfaces.
321 */
322 HWTEST(AudioEffectServiceTest, audioEffectService_017, TestSize.Level1)
323 {
324 auto audioEffectService_ = std::make_shared<AudioEffectService>();
325 Stream newStream1;
326 Stream newStream2;
327 newStream1.scene = "test";
328 newStream1.priority = NORMAL_SCENE;
329 newStream2.scene = "test";
330 newStream2.priority = NORMAL_SCENE;
331 ProcessNew processNew;
332 processNew.stream.push_back(newStream1);
333 processNew.stream.push_back(newStream2);
334 audioEffectService_->UpdateDuplicateScene(processNew);
335 EXPECT_NE(audioEffectService_, nullptr);
336 }
337
338 /**
339 * @tc.name : Test AudioEffectService.
340 * @tc.number: audioEffectService_018.
341 * @tc.desc : Test UpdateDuplicateDefaultScene interfaces.
342 */
343 HWTEST(AudioEffectServiceTest, audioEffectService_018, TestSize.Level1)
344 {
345 auto audioEffectService_ = std::make_shared<AudioEffectService>();
346 ProcessNew processNew;
347 Stream newStream0;
348 Stream newStream1;
349 Stream newStream2;
350 newStream0.priority = NORMAL_SCENE;
351 newStream1.priority = DEFAULT_SCENE;
352 newStream2.priority = DEFAULT_SCENE;
353 processNew.stream.push_back(newStream0);
354 audioEffectService_->UpdateDuplicateDefaultScene(processNew);
355 EXPECT_NE(audioEffectService_, nullptr);
356
357 processNew.stream.push_back(newStream1);
358 processNew.stream.push_back(newStream2);
359 audioEffectService_->UpdateDuplicateDefaultScene(processNew);
360 EXPECT_NE(audioEffectService_, nullptr);
361 }
362
363 /**
364 * @tc.name : Test AudioEffectService.
365 * @tc.number: audioEffectService_019.
366 * @tc.desc : Test UpdateUnavailableEffectChains/UpdateUnavailableEffectChainsRecord interfaces.
367 */
368 HWTEST(AudioEffectServiceTest, audioEffectService_019, TestSize.Level1)
369 {
370 auto audioEffectService_ = std::make_shared<AudioEffectService>();
371 Stream newStream;
372 ProcessNew processNew;
373 StreamEffectMode streamEffect;
374 newStream.streamEffectMode.push_back(streamEffect);
375 processNew.stream.push_back(newStream);
376 std::vector<std::string> availableLayout;
377 audioEffectService_->UpdateUnavailableEffectChains(availableLayout, processNew);
378 EXPECT_NE(audioEffectService_, nullptr);
379 }
380
381 /**
382 * @tc.name : Test AudioEffectService.
383 * @tc.number: audioEffectService_020.
384 * @tc.desc : Test UpdateUnavailableEffectChains/UpdateUnavailableEffectChainsRecord interfaces.
385 */
386 HWTEST(AudioEffectServiceTest, audioEffectService_020, TestSize.Level1)
387 {
388 auto audioEffectService_ = std::make_shared<AudioEffectService>();
389 Device device1;
390 Device device2;
391 device1.chain = "test";
392 device2.chain = "test";
393 Stream newStream;
394 ProcessNew processNew;
395 StreamEffectMode streamEffect;
396 streamEffect.devicePort.push_back(device1);
397 streamEffect.devicePort.push_back(device2);
398 newStream.streamEffectMode.push_back(streamEffect);
399 processNew.stream.push_back(newStream);
400 std::vector<std::string> availableLayout;
401 audioEffectService_->UpdateUnavailableEffectChains(availableLayout, processNew);
402 EXPECT_NE(audioEffectService_, nullptr);
403 }
404
405 /**
406 * @tc.name : Test AudioEffectService.
407 * @tc.number: audioEffectService_021.
408 * @tc.desc : Test UpdateUnavailableEffectChains/UpdateUnavailableEffectChainsRecord interfaces.
409 */
410 HWTEST(AudioEffectServiceTest, audioEffectService_021, TestSize.Level1)
411 {
412 auto audioEffectService_ = std::make_shared<AudioEffectService>();
413 Device device1;
414 Device device2;
415 device1.chain = "test1";
416 device2.chain = "test2";
417 Stream newStream;
418 ProcessNew processNew;
419 StreamEffectMode streamEffect;
420 streamEffect.devicePort.push_back(device1);
421 streamEffect.devicePort.push_back(device2);
422 newStream.streamEffectMode.push_back(streamEffect);
423 processNew.stream.push_back(newStream);
424 std::vector<std::string> availableLayout;
425 availableLayout.push_back("test1");
426 audioEffectService_->UpdateUnavailableEffectChains(availableLayout, processNew);
427 EXPECT_NE(audioEffectService_, nullptr);
428 }
429
430 /**
431 * @tc.name : Test AudioEffectService.
432 * @tc.number: audioEffectService_022.
433 * @tc.desc : Test UpdateSupportedEffectProperty interfaces.
434 */
435 HWTEST(AudioEffectServiceTest, audioEffectService_022, TestSize.Level1)
436 {
437 Device device;
438 Effect effect;
439 EffectChain effectChain;
440 auto audioEffectService_ = std::make_shared<AudioEffectService>();
441 std::unordered_map<std::string, std::set<std::pair<std::string, std::string>>> device2PropertySet;
442 audioEffectService_->UpdateSupportedEffectProperty(device, device2PropertySet);
443 EXPECT_NE(audioEffectService_, nullptr);
444
445 device.chain = "test";
446 effectChain.name = "test";
447 effectChain.apply.push_back("test");
448 audioEffectService_->supportedEffectConfig_.effectChains.push_back(effectChain);
449 audioEffectService_->UpdateSupportedEffectProperty(device, device2PropertySet);
450 EXPECT_NE(audioEffectService_, nullptr);
451
452 effect.name = "test";
453 device.type = "test";
454 effect.effectProperty.push_back("test1");
455 audioEffectService_->availableEffects_.push_back(effect);
456 audioEffectService_->UpdateSupportedEffectProperty(device, device2PropertySet);
457 EXPECT_NE(audioEffectService_, nullptr);
458
459 std::set<std::pair<std::string, std::string>> deviceSet = {{"test1", "value1"}, {"test2", "value2"}};
460 device2PropertySet.insert({"test", deviceSet});
461 audioEffectService_->UpdateSupportedEffectProperty(device, device2PropertySet);
462 EXPECT_NE(audioEffectService_, nullptr);
463 }
464
465 /**
466 * @tc.name : Test AudioEffectService.
467 * @tc.number: audioEffectService_023.
468 * @tc.desc : Test UpdateDuplicateProcessNew interfaces.
469 */
470 HWTEST(AudioEffectServiceTest, audioEffectService_023, TestSize.Level1)
471 {
472 auto audioEffectService_ = std::make_shared<AudioEffectService>();
473 Stream newStream;
474 ProcessNew processNew;
475 StreamEffectMode streamEffect;
476 newStream.streamEffectMode.push_back(streamEffect);
477 processNew.stream.push_back(newStream);
478 std::vector<std::string> availableLayout;
479 audioEffectService_->UpdateDuplicateProcessNew(availableLayout, processNew);
480 EXPECT_NE(audioEffectService_, nullptr);
481 }
482
483 /**
484 * @tc.name : Test AudioEffectService.
485 * @tc.number: audioEffectService_024.
486 * @tc.desc : Test BuildAvailableAEConfig interfaces.
487 */
488 HWTEST(AudioEffectServiceTest, audioEffectService_024, TestSize.Level1)
489 {
490 auto audioEffectService_ = std::make_shared<AudioEffectService>();
491 audioEffectService_->BuildAvailableAEConfig();
492 EXPECT_NE(audioEffectService_, nullptr);
493
494 EffectChain effectChain;
495 PreStreamScene preStreamScene;
496 PostStreamScene postStreamScene;
497 audioEffectService_->oriEffectConfig_.effectChains.push_back(effectChain);
498 audioEffectService_->oriEffectConfig_.preProcess.defaultScenes.push_back(preStreamScene);
499 audioEffectService_->oriEffectConfig_.preProcess.normalScenes.push_back(preStreamScene);
500 audioEffectService_->oriEffectConfig_.postProcess.defaultScenes.push_back(postStreamScene);
501 audioEffectService_->oriEffectConfig_.postProcess.normalScenes.push_back(postStreamScene);
502 audioEffectService_->BuildAvailableAEConfig();
503 EXPECT_NE(audioEffectService_, nullptr);
504 }
505
506 /**
507 * @tc.name : Test AudioEffectService.
508 * @tc.number: audioEffectService_025.
509 * @tc.desc : Test ConstructEffectChainMode interfaces.
510 */
511 HWTEST(AudioEffectServiceTest, audioEffectService_025, TestSize.Level1)
512 {
513 Device device1;
514 Device device2;
515 device2.chain = "chain";
516 device2.type = "DEVICE_TYPE_DEFAULT";
517 StreamEffectMode mode;
518 mode.mode = "mode";
519 mode.devicePort.push_back(device1);
520 mode.devicePort.push_back(device2);
521 std::string sceneType = "sceneType";
522 EffectChainManagerParam effectChainMgrParam;
523 auto audioEffectService_ = std::make_shared<AudioEffectService>();
524 audioEffectService_->ConstructEffectChainMode(mode, sceneType, effectChainMgrParam);
525 EXPECT_NE(audioEffectService_, nullptr);
526 }
527
528 /**
529 * @tc.name : Test AudioEffectService.
530 * @tc.number: audioEffectService_026.
531 * @tc.desc : Test ConstructDefaultEffectProperty interfaces.
532 */
533 HWTEST(AudioEffectServiceTest, audioEffectService_026, TestSize.Level1)
534 {
535 auto audioEffectService_ = std::make_shared<AudioEffectService>();
536 EffectChain effectChain;
537 std::string chainName = "chainName";
538 std::unordered_map<std::string, std::string> effectDefaultProperty;
539 audioEffectService_->supportedEffectConfig_.effectChains.push_back(effectChain);
540 audioEffectService_->ConstructDefaultEffectProperty(chainName, effectDefaultProperty);
541 EXPECT_NE(audioEffectService_, nullptr);
542 }
543
544 /**
545 * @tc.name : Test AudioEffectService.
546 * @tc.number: audioEffectService_027.
547 * @tc.desc : Test ConstructDefaultEffectProperty interfaces.
548 */
549 HWTEST(AudioEffectServiceTest, audioEffectService_027, TestSize.Level1)
550 {
551 auto audioEffectService_ = std::make_shared<AudioEffectService>();
552 EffectChain effectChain;
553 effectChain.name = "chainName";
554 effectChain.apply.push_back("test");
555 std::string chainName = "chainName";
556 Effect effect;
557 audioEffectService_->availableEffects_.push_back(effect);
558 std::unordered_map<std::string, std::string> effectDefaultProperty;
559 audioEffectService_->supportedEffectConfig_.effectChains.push_back(effectChain);
560 audioEffectService_->ConstructDefaultEffectProperty(chainName, effectDefaultProperty);
561 EXPECT_NE(audioEffectService_, nullptr);
562 }
563
564 /**
565 * @tc.name : Test AudioEffectService.
566 * @tc.number: audioEffectService_028.
567 * @tc.desc : Test ConstructDefaultEffectProperty interfaces.
568 */
569 HWTEST(AudioEffectServiceTest, audioEffectService_028, TestSize.Level1)
570 {
571 auto audioEffectService_ = std::make_shared<AudioEffectService>();
572 EffectChain effectChain;
573 effectChain.name = "chainName";
574 effectChain.apply.push_back("test");
575 effectChain.apply.push_back("test");
576 std::string chainName = "chainName";
577 Effect effect;
578 effect.name = "test";
579 effect.effectProperty.push_back("test");
580 audioEffectService_->availableEffects_.push_back(effect);
581 std::unordered_map<std::string, std::string> effectDefaultProperty;
582 audioEffectService_->supportedEffectConfig_.effectChains.push_back(effectChain);
583 audioEffectService_->ConstructDefaultEffectProperty(chainName, effectDefaultProperty);
584 EXPECT_NE(audioEffectService_, nullptr);
585 }
586
587 /**
588 * @tc.name : Test AudioEffectService.
589 * @tc.number: audioEffectService_029.
590 * @tc.desc : Test ConstructDefaultEffectProperty interfaces.
591 */
592 HWTEST(AudioEffectServiceTest, audioEffectService_029, TestSize.Level1)
593 {
594 auto audioEffectService_ = std::make_shared<AudioEffectService>();
595 EffectChain effectChain;
596 effectChain.name = "chainName";
597 effectChain.apply.push_back("test");
598 std::string chainName = "chainName";
599 Effect effect;
600 effect.name = "test";
601 audioEffectService_->availableEffects_.push_back(effect);
602 std::unordered_map<std::string, std::string> effectDefaultProperty;
603 audioEffectService_->supportedEffectConfig_.effectChains.push_back(effectChain);
604 audioEffectService_->ConstructDefaultEffectProperty(chainName, effectDefaultProperty);
605 EXPECT_NE(audioEffectService_, nullptr);
606 }
607
608 /**
609 * @tc.name : Test AudioEffectService.
610 * @tc.number: audioEffectService_030.
611 * @tc.desc : Test ConstructEffectChainManagerParam interfaces.
612 */
613 HWTEST(AudioEffectServiceTest, audioEffectService_030, TestSize.Level1)
614 {
615 auto audioEffectService_ = std::make_shared<AudioEffectService>();
616 Stream stream1;
617 Stream stream2;
618 stream1.scene = "test";
619 stream1.priority = PRIOR_SCENE;
620 stream2.scene = "test";
621 stream2.priority = DEFAULT_SCENE;
622 EffectChainManagerParam effectChainManagerParam;
623 audioEffectService_->supportedEffectConfig_.postProcessNew.stream.push_back(stream1);
624 audioEffectService_->supportedEffectConfig_.postProcessNew.stream.push_back(stream2);
625 audioEffectService_->ConstructEffectChainManagerParam(effectChainManagerParam);
626 EXPECT_NE(audioEffectService_, nullptr);
627 }
628
629 /**
630 * @tc.name : Test AudioEffectService.
631 * @tc.number: audioEffectService_031.
632 * @tc.desc : Test ConstructEnhanceChainManagerParam interfaces.
633 */
634 HWTEST(AudioEffectServiceTest, audioEffectService_031, TestSize.Level1)
635 {
636 auto audioEffectService_ = std::make_shared<AudioEffectService>();
637 Stream stream1;
638 Stream stream2;
639 stream1.scene = "test";
640 stream1.priority = PRIOR_SCENE;
641 stream2.scene = "test";
642 stream2.priority = DEFAULT_SCENE;
643 EffectChainManagerParam effectChainManagerParam;
644 audioEffectService_->supportedEffectConfig_.preProcessNew.stream.push_back(stream1);
645 audioEffectService_->supportedEffectConfig_.preProcessNew.stream.push_back(stream2);
646 audioEffectService_->ConstructEnhanceChainManagerParam(effectChainManagerParam);
647 EXPECT_NE(audioEffectService_, nullptr);
648 }
649
650 /**
651 * @tc.name : Test AudioEffectService.
652 * @tc.number: audioEffectService_032.
653 * @tc.desc : Test AddSupportedPropertyByDeviceInner interfaces.
654 */
655 HWTEST(AudioEffectServiceTest, audioEffectService_032, TestSize.Level1)
656 {
657 auto audioEffectService_ = std::make_shared<AudioEffectService>();
658 std::set<std::pair<std::string, std::string>> mergedSet;
659 const std::unordered_map<std::string, std::set<std::pair<std::string, std::string>>> device2PropertySet;
660 int32_t result = audioEffectService_->AddSupportedPropertyByDeviceInner(DeviceType::DEVICE_TYPE_MAX,
661 mergedSet, device2PropertySet);
662 EXPECT_EQ(result, -1);
663 }
664
665 /**
666 * @tc.name : Test AudioEffectService.
667 * @tc.number: audioEffectService_033.
668 * @tc.desc : Test AddSupportedPropertyByDeviceInner interfaces.
669 */
670 HWTEST(AudioEffectServiceTest, audioEffectService_033, TestSize.Level1)
671 {
672 auto audioEffectService_ = std::make_shared<AudioEffectService>();
673 std::set<std::pair<std::string, std::string>> mergedSet;
674 std::unordered_map<std::string, std::set<std::pair<std::string, std::string>>> device2PropertySet;
675 std::set<std::pair<std::string, std::string>> device2Property;
676 device2PropertySet.insert({"DEVICE_TYPE_DEFAULT", device2Property});
677 int32_t result = audioEffectService_->AddSupportedPropertyByDeviceInner(DeviceType::DEVICE_TYPE_INVALID,
678 mergedSet, device2PropertySet);
679 EXPECT_EQ(result, AUDIO_OK);
680 }
681
682 /**
683 * @tc.name : Test AudioEffectService.
684 * @tc.number: audioEffectService_034.
685 * @tc.desc : Test AddSupportedPropertyByDeviceInner interfaces.
686 */
687 HWTEST(AudioEffectServiceTest, audioEffectService_034, TestSize.Level1)
688 {
689 auto audioEffectService_ = std::make_shared<AudioEffectService>();
690 std::set<std::pair<std::string, std::string>> mergedSet;
691 std::unordered_map<std::string, std::set<std::pair<std::string, std::string>>> device2PropertySet;
692 std::set<std::pair<std::string, std::string>> device2Property;
693 device2PropertySet.insert({"DEVICE_TYPE_DEFAULT", device2Property});
694 int32_t result = audioEffectService_->AddSupportedPropertyByDeviceInner(DeviceType::DEVICE_TYPE_NONE,
695 mergedSet, device2PropertySet);
696 EXPECT_EQ(result, AUDIO_OK);
697 }
698 } // namespace AudioStandard
699 } // namespace OHOS
700