1 /*
2 * Copyright (c) 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 "audio_ec_manager_unit_test.h"
17 #include "audio_device_info.h"
18 #include "audio_ec_manager.cpp"
19
20 using namespace testing::ext;
21
22 namespace OHOS {
23 namespace AudioStandard {
SetUpTestCase(void)24 void AudioEcManagerUnitTest::SetUpTestCase(void) {}
TearDownTestCase(void)25 void AudioEcManagerUnitTest::TearDownTestCase(void) {}
SetUp(void)26 void AudioEcManagerUnitTest::SetUp(void) {}
TearDown(void)27 void AudioEcManagerUnitTest::TearDown(void) {}
28
29 /**
30 * @tc.name : Test AudioEcManager.
31 * @tc.number: AudioEcManager_001
32 * @tc.desc : Test GetEcSamplingRate interface.
33 */
34 HWTEST_F(AudioEcManagerUnitTest, AudioEcManager_001, TestSize.Level1)
35 {
36 std::string halName = DP_CLASS;
37 std::shared_ptr<PipeStreamPropInfo> outModuleInfo = std::make_shared<PipeStreamPropInfo>();
38 AudioEcManager& ecManager(AudioEcManager::GetInstance());
39 std::string sRet;
40
41 outModuleInfo->sampleRate_ = 41000;
42 sRet = ecManager.GetEcSamplingRate(halName, outModuleInfo);
43 EXPECT_EQ(sRet, "41000");
44
45 ecManager.dpSinkModuleInfo_.rate = "48000";
46 sRet = ecManager.GetEcSamplingRate(halName, outModuleInfo);
47 EXPECT_EQ(sRet, "48000");
48
49 halName = USB_CLASS;
50 sRet = ecManager.GetEcSamplingRate(halName, outModuleInfo);
51 EXPECT_EQ(sRet, "41000");
52
53 ecManager.usbSinkModuleInfo_.rate = "48000";
54 sRet = ecManager.GetEcSamplingRate(halName, outModuleInfo);
55 EXPECT_EQ(sRet, "48000");
56
57 halName = "TEST";
58 ecManager.primaryMicModuleInfo_.rate = "40000";
59 sRet = ecManager.GetEcSamplingRate(halName, outModuleInfo);
60 EXPECT_EQ(sRet, "40000");
61 }
62
63 /**
64 * @tc.name : Test AudioEcManager.
65 * @tc.number: AudioEcManager_002
66 * @tc.desc : Test GetEcChannels interface.
67 */
68 HWTEST_F(AudioEcManagerUnitTest, AudioEcManager_002, TestSize.Level1)
69 {
70 std::string halName = DP_CLASS;
71 std::shared_ptr<PipeStreamPropInfo> outModuleInfo = std::make_shared<PipeStreamPropInfo>();
72 AudioEcManager& ecManager(AudioEcManager::GetInstance());
73 std::string sRet;
74
75 outModuleInfo->channelLayout_ = CH_LAYOUT_STEREO;
76 ecManager.dpSinkModuleInfo_.channels = "";
77 sRet = ecManager.GetEcChannels(halName, outModuleInfo);
78 EXPECT_EQ(sRet, "0");
79
80 ecManager.dpSinkModuleInfo_.channels = "3";
81 sRet = ecManager.GetEcChannels(halName, outModuleInfo);
82 EXPECT_EQ(sRet, "3");
83
84 halName = USB_CLASS;
85 ecManager.usbSinkModuleInfo_.channels = "";
86 sRet = ecManager.GetEcChannels(halName, outModuleInfo);
87 EXPECT_EQ(sRet, "0");
88
89 ecManager.usbSinkModuleInfo_.channels = "5";
90 sRet = ecManager.GetEcChannels(halName, outModuleInfo);
91 EXPECT_EQ(sRet, "5");
92
93 halName = "TEST";
94 sRet = ecManager.GetEcChannels(halName, outModuleInfo);
95 EXPECT_EQ(sRet, "2");
96 }
97
98 /**
99 * @tc.name : Test AudioEcManager.
100 * @tc.number: AudioEcManager_003
101 * @tc.desc : Test GetEcFormat interface.
102 */
103 HWTEST_F(AudioEcManagerUnitTest, AudioEcManager_003, TestSize.Level1)
104 {
105 std::string halName = DP_CLASS;
106 std::shared_ptr<PipeStreamPropInfo> outModuleInfo = std::make_shared<PipeStreamPropInfo>();
107 AudioEcManager& ecManager(AudioEcManager::GetInstance());
108 std::string sRet;
109
110 outModuleInfo->format_ = SAMPLE_S32LE;
111 ecManager.dpSinkModuleInfo_.format = "";
112 sRet = ecManager.GetEcFormat(halName, outModuleInfo);
113 EXPECT_EQ(sRet, "s32le");
114
115 ecManager.dpSinkModuleInfo_.format = "4";
116 sRet = ecManager.GetEcFormat(halName, outModuleInfo);
117 EXPECT_EQ(sRet, "4");
118
119 halName = USB_CLASS;
120 ecManager.usbSinkModuleInfo_.format = "";
121 sRet = ecManager.GetEcFormat(halName, outModuleInfo);
122 EXPECT_EQ(sRet, "s32le");
123
124 ecManager.usbSinkModuleInfo_.format = "5";
125 sRet = ecManager.GetEcFormat(halName, outModuleInfo);
126 EXPECT_EQ(sRet, "5");
127
128 halName = "TEST";
129 ecManager.primaryMicModuleInfo_.format = "2";
130 sRet = ecManager.GetEcFormat(halName, outModuleInfo);
131 EXPECT_EQ(sRet, "2");
132 }
133
134 /**
135 * @tc.name : Test AudioEcManager.
136 * @tc.number: AudioEcManager_004
137 * @tc.desc : Test GetPipeNameByDeviceForEc interface.
138 */
139 HWTEST_F(AudioEcManagerUnitTest, AudioEcManager_004, TestSize.Level1)
140 {
141 std::string role;
142 DeviceType deviceType = DEVICE_TYPE_SPEAKER;
143 AudioEcManager& ecManager(AudioEcManager::GetInstance());
144 std::string sRet;
145
146 sRet = ecManager.GetPipeNameByDeviceForEc(role, deviceType);
147 EXPECT_EQ(sRet, PIPE_PRIMARY_OUTPUT);
148
149 deviceType = DEVICE_TYPE_WIRED_HEADSET;
150 sRet = ecManager.GetPipeNameByDeviceForEc(role, deviceType);
151 EXPECT_EQ(sRet, PIPE_PRIMARY_OUTPUT);
152
153 deviceType = DEVICE_TYPE_USB_HEADSET;
154 sRet = ecManager.GetPipeNameByDeviceForEc(role, deviceType);
155 EXPECT_EQ(sRet, PIPE_PRIMARY_OUTPUT);
156
157 deviceType = DEVICE_TYPE_BLUETOOTH_SCO;
158 sRet = ecManager.GetPipeNameByDeviceForEc(role, deviceType);
159 EXPECT_EQ(sRet, PIPE_PRIMARY_OUTPUT);
160
161 role = ROLE_SOURCE;
162 deviceType = DEVICE_TYPE_WIRED_HEADSET;
163 sRet = ecManager.GetPipeNameByDeviceForEc(role, deviceType);
164 EXPECT_EQ(sRet, PIPE_PRIMARY_INPUT);
165
166 deviceType = DEVICE_TYPE_USB_HEADSET;
167 sRet = ecManager.GetPipeNameByDeviceForEc(role, deviceType);
168 EXPECT_EQ(sRet, PIPE_PRIMARY_INPUT);
169
170 deviceType = DEVICE_TYPE_BLUETOOTH_SCO;
171 sRet = ecManager.GetPipeNameByDeviceForEc(role, deviceType);
172 EXPECT_EQ(sRet, PIPE_PRIMARY_INPUT);
173
174 deviceType = DEVICE_TYPE_MIC;
175 sRet = ecManager.GetPipeNameByDeviceForEc(role, deviceType);
176 EXPECT_EQ(sRet, PIPE_PRIMARY_INPUT);
177
178 deviceType = DEVICE_TYPE_USB_ARM_HEADSET;
179 sRet = ecManager.GetPipeNameByDeviceForEc(role, deviceType);
180 EXPECT_EQ(sRet, PIPE_USB_ARM_INPUT);
181
182 role = "TEST";
183 sRet = ecManager.GetPipeNameByDeviceForEc(role, deviceType);
184 EXPECT_EQ(sRet, PIPE_USB_ARM_OUTPUT);
185
186 deviceType = DEVICE_TYPE_DP;
187 sRet = ecManager.GetPipeNameByDeviceForEc(role, deviceType);
188 EXPECT_EQ(sRet, PIPE_DP_OUTPUT);
189
190 deviceType = DEVICE_TYPE_NONE;
191 sRet = ecManager.GetPipeNameByDeviceForEc(role, deviceType);
192 EXPECT_EQ(sRet, PIPE_PRIMARY_OUTPUT);
193 }
194
195 /**
196 * @tc.name : Test AudioEcManager.
197 * @tc.number: AudioEcManager_005
198 * @tc.desc : Test GetPipeInfoByDeviceTypeForEc interface.
199 */
200 HWTEST_F(AudioEcManagerUnitTest, AudioEcManager_005, TestSize.Level1)
201 {
202 std::string role = ROLE_SOURCE;
203 DeviceType deviceType = DEVICE_TYPE_SPEAKER;
204 std::shared_ptr<AdapterPipeInfo> pipeInfo;
205 AudioEcManager& ecManager(AudioEcManager::GetInstance());
206 int32_t ret;
207
208 ret = ecManager.GetPipeInfoByDeviceTypeForEc(role, deviceType, pipeInfo);
209 EXPECT_NE(ret, SUCCESS);
210 }
211
212 /**
213 * @tc.name : Test AudioEcManager.
214 * @tc.number: AudioEcManager_006
215 * @tc.desc : Test GetEcType interface.
216 */
217 HWTEST_F(AudioEcManagerUnitTest, AudioEcManager_006, TestSize.Level1)
218 {
219 DeviceType inputDevice;
220 DeviceType outputDevice;
221 AudioEcManager& ecManager(AudioEcManager::GetInstance());
222 EcType ecRet;
223
224 inputDevice = DEVICE_TYPE_MIC;
225 outputDevice = DEVICE_TYPE_SPEAKER;
226 ecRet = ecManager.GetEcType(inputDevice, outputDevice);
227 EXPECT_EQ(ecRet, EC_TYPE_SAME_ADAPTER);
228
229 outputDevice = DEVICE_TYPE_MIC;
230 ecRet = ecManager.GetEcType(inputDevice, outputDevice);
231 EXPECT_EQ(ecRet, EC_TYPE_NONE);
232 }
233
234 /**
235 * @tc.name : Test AudioEcManager.
236 * @tc.number: AudioEcManager_007
237 * @tc.desc : Test UpdateAudioEcInfo interface.
238 */
239 HWTEST_F(AudioEcManagerUnitTest, AudioEcManager_007, TestSize.Level1)
240 {
241 AudioDeviceDescriptor inputDevice;
242 AudioDeviceDescriptor outputDevice;
243 AudioEcManager& ecManager(AudioEcManager::GetInstance());
244
245 inputDevice.deviceType_ = DEVICE_TYPE_MIC;
246 inputDevice.macAddress_ = "00:11:22:33:44:55";
247 inputDevice.networkId_ = "1234567890";
248 inputDevice.deviceRole_ = DEVICE_ROLE_NONE;
249 outputDevice.deviceType_ = DEVICE_TYPE_MIC;
250 outputDevice.macAddress_ = "00:11:22:33:44:55";
251 outputDevice.networkId_ = "1234567890";
252 outputDevice.deviceRole_ = DEVICE_ROLE_NONE;
253
254 ecManager.audioEcInfo_.inputDevice.deviceType_ = DEVICE_TYPE_MIC;
255 ecManager.audioEcInfo_.inputDevice.macAddress_ = "00:11:22:33:44:55";
256 ecManager.audioEcInfo_.inputDevice.networkId_ = "1234567890";
257 ecManager.audioEcInfo_.inputDevice.deviceRole_ = DEVICE_ROLE_NONE;
258 ecManager.audioEcInfo_.outputDevice.deviceType_ = DEVICE_TYPE_MIC;
259 ecManager.audioEcInfo_.outputDevice.macAddress_ = "00:11:22:33:44:55";
260 ecManager.audioEcInfo_.outputDevice.networkId_ = "1234567890";
261 ecManager.audioEcInfo_.outputDevice.deviceRole_ = DEVICE_ROLE_NONE;
262
263 ecManager.isEcFeatureEnable_ = false;
264 ecManager.UpdateAudioEcInfo(inputDevice, outputDevice);
265 EXPECT_EQ(ecManager.isEcFeatureEnable_, false);
266
267 ecManager.isEcFeatureEnable_ = true;
268 ecManager.UpdateAudioEcInfo(inputDevice, outputDevice);
269 EXPECT_EQ(ecManager.audioEcInfo_.inputDevice.IsSameDeviceDesc(inputDevice), true);
270
271 inputDevice.networkId_ = "12345678";
272 outputDevice.networkId_ = "12345678";
273 ecManager.UpdateAudioEcInfo(inputDevice, outputDevice);
274 EXPECT_EQ(ecManager.isEcFeatureEnable_, true);
275 }
276
277 /**
278 * @tc.name : Test AudioEcManager.
279 * @tc.number: AudioEcManager_008
280 * @tc.desc : Test UpdateModuleInfoForEc interface.
281 */
282 HWTEST_F(AudioEcManagerUnitTest, AudioEcManager_008, TestSize.Level1)
283 {
284 AudioModuleInfo moduleInfo;
285 AudioEcManager& ecManager(AudioEcManager::GetInstance());
286
287 ecManager.audioEcInfo_.channels = "5";
288 ecManager.UpdateModuleInfoForEc(moduleInfo);
289 EXPECT_EQ(moduleInfo.ecChannels, "5");
290 }
291
292 /**
293 * @tc.name : Test AudioEcManager.
294 * @tc.number: AudioEcManager_009
295 * @tc.desc : Test ShouldOpenMicRef interface.
296 */
297 HWTEST_F(AudioEcManagerUnitTest, AudioEcManager_009, TestSize.Level1)
298 {
299 SourceType source = SOURCE_TYPE_VOICE_COMMUNICATION;
300 AudioEcManager& ecManager(AudioEcManager::GetInstance());
301 std::string sRet;
302
303 ecManager.isMicRefFeatureEnable_ = false;
304 sRet = ecManager.ShouldOpenMicRef(source);
305 EXPECT_EQ(sRet, "0");
306
307 ecManager.isMicRefFeatureEnable_ = true;
308 sRet = ecManager.ShouldOpenMicRef(source);
309 EXPECT_EQ(sRet, "0");
310 }
311
312 /**
313 * @tc.name : Test AudioEcManager.
314 * @tc.number: AudioEcManager_010
315 * @tc.desc : Test UpdateModuleInfoForMicRef interface.
316 */
317 HWTEST_F(AudioEcManagerUnitTest, AudioEcManager_010, TestSize.Level1)
318 {
319 AudioModuleInfo moduleInfo;
320 SourceType source = SOURCE_TYPE_VOICE_COMMUNICATION;
321 AudioEcManager& ecManager(AudioEcManager::GetInstance());
322
323 ecManager.isMicRefFeatureEnable_ = false;
324 ecManager.UpdateModuleInfoForMicRef(moduleInfo, source);
325 EXPECT_EQ(moduleInfo.micRefChannels, "4");
326 }
327
328 /**
329 * @tc.name : Test AudioEcManager.
330 * @tc.number: AudioEcManager_011
331 * @tc.desc : Test GetAudioEcInfo & ResetAudioEcInfo interface.
332 */
333 HWTEST_F(AudioEcManagerUnitTest, AudioEcManager_011, TestSize.Level1)
334 {
335 AudioEcInfo ecInfo;
336 AudioEcManager& ecManager(AudioEcManager::GetInstance());
337
338 ecManager.audioEcInfo_.channels = "3";
339 ecInfo = ecManager.GetAudioEcInfo();
340 EXPECT_EQ(ecInfo.channels, "3");
341
342 ecManager.ResetAudioEcInfo();
343 ecInfo = ecManager.GetAudioEcInfo();
344 EXPECT_EQ(ecInfo.inputDevice.deviceType_, DEVICE_TYPE_NONE);
345 EXPECT_EQ(ecInfo.outputDevice.deviceType_, DEVICE_TYPE_NONE);
346 }
347
348 /**
349 * @tc.name : Test AudioEcManager.
350 * @tc.number: AudioEcManager_012
351 * @tc.desc : Test UpdateArmModuleInfo interface.
352 */
353 HWTEST_F(AudioEcManagerUnitTest, AudioEcManager_012, TestSize.Level1)
354 {
355 std::string address = "00:11:22:33:44";
356 DeviceRole role = INPUT_DEVICE;
357 AudioModuleInfo moduleInfo;
358 auto ecManager = std::make_shared<AudioEcManager>();
359 ASSERT_TRUE(ecManager != nullptr);
360
361 ecManager->UpdateArmModuleInfo(address, role, moduleInfo);
362 }
363
364 /**
365 * @tc.name : Test AudioEcManager.
366 * @tc.number: AudioEcManager_013
367 * @tc.desc : Test ReloadSourceForSession interface.
368 */
369 HWTEST_F(AudioEcManagerUnitTest, AudioEcManager_013, TestSize.Level1)
370 {
371 SessionInfo sessionInfo;
372 auto ecManager = std::make_shared<AudioEcManager>();
373 ASSERT_TRUE(ecManager != nullptr);
374
375 sessionInfo.sourceType = SOURCE_TYPE_INVALID;
376 ecManager->ReloadSourceForSession(sessionInfo);
377 }
378
379 /**
380 * @tc.name : Test AudioEcManager.
381 * @tc.number: AudioEcManager_014
382 * @tc.desc : Test GetMicRefFeatureEnable interface.
383 */
384 HWTEST_F(AudioEcManagerUnitTest, AudioEcManager_014, TestSize.Level1)
385 {
386 bool bRet;
387 AudioEcManager& ecManager(AudioEcManager::GetInstance());
388
389 ecManager.isMicRefFeatureEnable_ = true;
390 bRet = ecManager.GetMicRefFeatureEnable();
391 EXPECT_EQ(bRet, true);
392 }
393
394 /**
395 * @tc.name : Test AudioEcManager.
396 * @tc.number: AudioEcManager_015
397 * @tc.desc : Test UpdateStreamEcAndMicRefInfo interface.
398 */
399 HWTEST_F(AudioEcManagerUnitTest, AudioEcManager_015, TestSize.Level1)
400 {
401 AudioModuleInfo moduleInfo;
402 SourceType sourceType = SOURCE_TYPE_INVALID;
403 auto ecManager = std::make_shared<AudioEcManager>();
404 ASSERT_TRUE(ecManager != nullptr);
405
406 ecManager->UpdateStreamEcAndMicRefInfo(moduleInfo, sourceType);
407 }
408
409 /**
410 * @tc.name : Test AudioEcManager.
411 * @tc.number: AudioEcManager_016
412 * @tc.desc : Test GetHalNameForDevice interface.
413 */
414 HWTEST_F(AudioEcManagerUnitTest, AudioEcManager_016, TestSize.Level1)
415 {
416 std::string role;
417 DeviceType deviceType;
418 AudioEcManager& ecManager(AudioEcManager::GetInstance());
419 std::string sRet;
420
421 role = ROLE_SOURCE;
422 deviceType = DEVICE_TYPE_MIC;
423 sRet = ecManager.GetHalNameForDevice(role, deviceType);
424 EXPECT_EQ(sRet, "");
425
426 role = ROLE_SINK;
427 sRet = ecManager.GetHalNameForDevice(role, deviceType);
428 EXPECT_EQ(sRet, "");
429 }
430
431 /**
432 * @tc.name : Test AudioEcManager.
433 * @tc.number: AudioEcManager_017
434 * @tc.desc : Test Init & GetEcFeatureEnable & GetMicRefFeatureEnable interface.
435 */
436 HWTEST_F(AudioEcManagerUnitTest, AudioEcManager_017, TestSize.Level1)
437 {
438 AudioEcManager& ecManager(AudioEcManager::GetInstance());
439
440 ecManager.Init(0, 1);
441 EXPECT_EQ(ecManager.GetEcFeatureEnable(), false);
442 EXPECT_EQ(ecManager.GetMicRefFeatureEnable(), true);
443
444 ecManager.Init(1, 0);
445 EXPECT_EQ(ecManager.GetEcFeatureEnable(), true);
446 EXPECT_EQ(ecManager.GetMicRefFeatureEnable(), false);
447
448 ecManager.Init(1, 1);
449 EXPECT_EQ(ecManager.GetEcFeatureEnable(), true);
450 EXPECT_EQ(ecManager.GetMicRefFeatureEnable(), true);
451
452 ecManager.Init(0, 0);
453 EXPECT_EQ(ecManager.GetEcFeatureEnable(), false);
454 EXPECT_EQ(ecManager.GetMicRefFeatureEnable(), false);
455 }
456
457 /**
458 * @tc.name : Test AudioEcManager.
459 * @tc.number: AudioEcManager_018
460 * @tc.desc : Test CloseNormalSource & GetSourceOpened interface.
461 */
462 HWTEST_F(AudioEcManagerUnitTest, AudioEcManager_018, TestSize.Level1)
463 {
464 AudioEcManager& ecManager(AudioEcManager::GetInstance());
465
466 EXPECT_EQ(ecManager.GetSourceOpened(), SOURCE_TYPE_INVALID);
467
468 ecManager.Init(1, 0);
469 bool isEcFeatureEnable = ecManager.isEcFeatureEnable_;
470 ecManager.isEcFeatureEnable_ = true;
471 ecManager.CloseNormalSource();
472 ecManager.isEcFeatureEnable_ = isEcFeatureEnable;
473 EXPECT_EQ(ecManager.GetSourceOpened(), SOURCE_TYPE_INVALID);
474 ecManager.Init(0, 0);
475 }
476
477 /**
478 * @tc.name : Test AudioEcManager.
479 * @tc.number: AudioEcManager_019
480 * @tc.desc : Test PrepareAndOpenNormalSource interface.
481 */
482 HWTEST_F(AudioEcManagerUnitTest, AudioEcManager_019, TestSize.Level1)
483 {
484 EXPECT_EQ(ParseAudioFormat("AUDIO_FORMAT_PCM_16_BIT"), "s16le");
485 EXPECT_EQ(ParseAudioFormat("AUDIO_FORMAT_PCM_24_BIT"), "s24le");
486 EXPECT_EQ(ParseAudioFormat("AUDIO_FORMAT_PCM_32_BIT"), "s32le");
487 EXPECT_EQ(ParseAudioFormat(""), "s16le");
488 }
489
490 /**
491 * @tc.name : Test AudioEcManager.
492 * @tc.number: AudioEcManager_020
493 * @tc.desc : Test GetUsbModuleInfo interface.
494 */
495 HWTEST_F(AudioEcManagerUnitTest, AudioEcManager_020, TestSize.Level1)
496 {
497 AudioModuleInfo moduleInfo;
498
499 moduleInfo.role = "sink";
500 string deviceInfo = "sink_rate:1;sink_format:AUDIO_FORMAT_PCM_16_BIT";
501 GetUsbModuleInfo(deviceInfo, moduleInfo);
502 EXPECT_EQ(moduleInfo.rate, "1");
503
504 moduleInfo.channels = "2";
505 GetUsbModuleInfo(deviceInfo, moduleInfo);
506 }
507
508 /**
509 * @tc.name : Test AudioEcManager.
510 * @tc.number: AudioEcManager_021
511 * @tc.desc : Test GetTargetSourceTypeAndMatchingFlag interface.
512 */
513 HWTEST_F(AudioEcManagerUnitTest, AudioEcManager_021, TestSize.Level1)
514 {
515 AudioEcManager& ecManager(AudioEcManager::GetInstance());
516
517 SourceType targetSource;
518 bool useMatchingPropInfo;
519
520 ecManager.GetTargetSourceTypeAndMatchingFlag(SOURCE_TYPE_VOICE_RECOGNITION, targetSource, useMatchingPropInfo);
521 EXPECT_EQ(targetSource, SOURCE_TYPE_VOICE_RECOGNITION);
522
523 ecManager.GetTargetSourceTypeAndMatchingFlag(SOURCE_TYPE_VOICE_COMMUNICATION, targetSource, useMatchingPropInfo);
524 EXPECT_EQ(targetSource, SOURCE_TYPE_VOICE_COMMUNICATION);
525
526 ecManager.GetTargetSourceTypeAndMatchingFlag(SOURCE_TYPE_VOICE_CALL, targetSource, useMatchingPropInfo);
527 EXPECT_EQ(targetSource, SOURCE_TYPE_VOICE_CALL);
528
529 ecManager.GetTargetSourceTypeAndMatchingFlag(SOURCE_TYPE_UNPROCESSED, targetSource, useMatchingPropInfo);
530 EXPECT_EQ(targetSource, SOURCE_TYPE_UNPROCESSED);
531
532 ecManager.GetTargetSourceTypeAndMatchingFlag(SOURCE_TYPE_MIC, targetSource, useMatchingPropInfo);
533 EXPECT_EQ(targetSource, SOURCE_TYPE_MIC);
534 }
535
536 /**
537 * @tc.name : Test AudioEcManager.
538 * @tc.number: AudioEcManager_022
539 * @tc.desc : Test ActivateArmDevice interface.
540 */
541 HWTEST_F(AudioEcManagerUnitTest, AudioEcManager_022, TestSize.Level1)
542 {
543 AudioEcManager& ecManager(AudioEcManager::GetInstance());
544
545 const std::string badAddress{"bad address"};
546 const std::string goodAddress{"address=card=2;device=0 role=0"};
547 ecManager.isEcFeatureEnable_ = true;
548
549 ecManager.ActivateArmDevice(badAddress, DeviceRole::INPUT_DEVICE);
550 EXPECT_NE(ecManager.activeArmInputAddr_, badAddress);
551
552 ecManager.ActivateArmDevice(badAddress, DeviceRole::OUTPUT_DEVICE);
553 EXPECT_NE(ecManager.activeArmOutputAddr_, badAddress);
554
555 std::list<AudioModuleInfo> moduleInfoList{};
556 ecManager.audioConfigManager_.GetModuleListByType(ClassType::TYPE_USB, moduleInfoList);
557 if (moduleInfoList.empty()) {
558 AudioModuleInfo testModuleInfo1{.role = "sink", .name="m1"};
559 AudioModuleInfo testModuleInfo2{.role = "source", .name="m2"};
560 std::list<AudioModuleInfo> testModules{testModuleInfo1, testModuleInfo2};
561 ecManager.audioConfigManager_.deviceClassInfo_.insert(
562 std::make_pair(ClassType::TYPE_USB, testModules));
563
564 ecManager.ActivateArmDevice(goodAddress, DeviceRole::OUTPUT_DEVICE);
565 ecManager.ActivateArmDevice(goodAddress, DeviceRole::INPUT_DEVICE);
566 ecManager.activeArmOutputAddr_ = {};
567 ecManager.activeArmInputAddr_ = {};
568
569 ecManager.PresetArmIdleInput(goodAddress);
570 ecManager.isEcFeatureEnable_ = false;
571 ecManager.ActivateArmDevice(goodAddress, DeviceRole::INPUT_DEVICE);
572 }
573 }
574
575 /**
576 * @tc.name : Test AudioEcManager.
577 * @tc.number: AudioEcManager_023
578 * @tc.desc : Test GetUsbModuleInfo interface.
579 */
580 HWTEST_F(AudioEcManagerUnitTest, AudioEcManager_023, TestSize.Level4)
581 {
582 AudioModuleInfo moduleInfo;
583 moduleInfo.role = "source";
584 string deviceInfo = "source_rate:1;source_format:AUDIO_FORMAT_PCM_16_BIT";
585 GetUsbModuleInfo(deviceInfo, moduleInfo);
586 EXPECT_EQ(moduleInfo.rate, "1");
587 }
588
589 /**
590 * @tc.name : Test AudioEcManager.
591 * @tc.number: AudioEcManager_024
592 * @tc.desc : Test UpdateStreamEcInfo interface.
593 */
594 HWTEST_F(AudioEcManagerUnitTest, AudioEcManager_024, TestSize.Level4)
595 {
596 AudioEcManager& ecManager(AudioEcManager::GetInstance());
597 AudioModuleInfo moduleInfo;
598 SourceType sourceType = SOURCE_TYPE_VOICE_COMMUNICATION;
599 EXPECT_NO_THROW(ecManager.UpdateStreamEcInfo(moduleInfo, sourceType));
600 }
601
602 /**
603 * @tc.name : Test AudioEcManager.
604 * @tc.number: AudioEcManager_025
605 * @tc.desc : Test PresetArmIdleInput interface.
606 */
607 HWTEST_F(AudioEcManagerUnitTest, AudioEcManager_025, TestSize.Level4)
608 {
609 AudioEcManager& ecManager(AudioEcManager::GetInstance());
610 ecManager.isEcFeatureEnable_ = false;
611 ecManager.usbSourceModuleInfo_.role = "";
612 const std::string goodAddress{"address=card=2;device=0 role=0"};
613 ecManager.PresetArmIdleInput(goodAddress);
614 EXPECT_TRUE(ecManager.usbSourceModuleInfo_.role.empty());
615 }
616
617 /**
618 * @tc.name : Test AudioEcManager.
619 * @tc.number: AudioEcManager_026
620 * @tc.desc : Test CloseUsbArmDevice interface.
621 */
622 HWTEST_F(AudioEcManagerUnitTest, AudioEcManager_026, TestSize.Level4)
623 {
624 AudioEcManager& ecManager(AudioEcManager::GetInstance());
625 AudioDeviceDescriptor device(DEVICE_TYPE_EARPIECE, INPUT_DEVICE);
626 device.macAddress_ = "00:11:22:33:44:55";
627 ecManager.activeArmInputAddr_ = device.macAddress_;
628 EXPECT_NO_THROW(ecManager.CloseUsbArmDevice(device));
629
630 device.deviceRole_ = OUTPUT_DEVICE;
631 ecManager.activeArmOutputAddr_ = device.macAddress_;
632 EXPECT_NO_THROW(ecManager.CloseUsbArmDevice(device));
633 }
634
635 /**
636 * @tc.name : Test AudioEcManager.
637 * @tc.number: AudioEcManager_027
638 * @tc.desc : Test GetTargetSourceTypeAndMatchingFlag interface.
639 */
640 HWTEST_F(AudioEcManagerUnitTest, AudioEcManager_027, TestSize.Level4)
641 {
642 AudioEcManager& ecManager(AudioEcManager::GetInstance());
643 SourceType source = SOURCE_TYPE_LIVE;
644 SourceType targetSource = SOURCE_TYPE_INVALID;
645 bool useMatchingPropInfo = false;
646 ecManager.GetTargetSourceTypeAndMatchingFlag(source, targetSource, useMatchingPropInfo);
647 EXPECT_EQ(targetSource, SOURCE_TYPE_LIVE);
648 }
649 } // namespace AudioStandard
650 } // namespace OHOS