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 StreamPropInfo outModuleInfo;
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 StreamPropInfo outModuleInfo;
72 AudioEcManager& ecManager(AudioEcManager::GetInstance());
73 std::string sRet;
74
75 outModuleInfo.channelLayout_ = 3;
76 sRet = ecManager.GetEcChannels(halName, outModuleInfo);
77 EXPECT_EQ(sRet, "3");
78
79 ecManager.dpSinkModuleInfo_.channels = "4";
80 sRet = ecManager.GetEcChannels(halName, outModuleInfo);
81 EXPECT_EQ(sRet, "4");
82
83 halName = USB_CLASS;
84 sRet = ecManager.GetEcChannels(halName, outModuleInfo);
85 EXPECT_EQ(sRet, "3");
86
87 ecManager.usbSinkModuleInfo_.channels = "5";
88 sRet = ecManager.GetEcChannels(halName, outModuleInfo);
89 EXPECT_EQ(sRet, "5");
90
91 halName = "TEST";
92 sRet = ecManager.GetEcChannels(halName, outModuleInfo);
93 EXPECT_EQ(sRet, "2");
94 }
95
96 /**
97 * @tc.name : Test AudioEcManager.
98 * @tc.number: AudioEcManager_003
99 * @tc.desc : Test GetEcFormat interface.
100 */
101 HWTEST_F(AudioEcManagerUnitTest, AudioEcManager_003, TestSize.Level1)
102 {
103 std::string halName = DP_CLASS;
104 StreamPropInfo outModuleInfo;
105 AudioEcManager& ecManager(AudioEcManager::GetInstance());
106 std::string sRet;
107
108 outModuleInfo.format_ = "3";
109 sRet = ecManager.GetEcFormat(halName, outModuleInfo);
110 EXPECT_EQ(sRet, "3");
111
112 ecManager.dpSinkModuleInfo_.format = "4";
113 sRet = ecManager.GetEcFormat(halName, outModuleInfo);
114 EXPECT_EQ(sRet, "4");
115
116 halName = USB_CLASS;
117 sRet = ecManager.GetEcFormat(halName, outModuleInfo);
118 EXPECT_EQ(sRet, "3");
119
120 ecManager.usbSinkModuleInfo_.format = "5";
121 sRet = ecManager.GetEcFormat(halName, outModuleInfo);
122 EXPECT_EQ(sRet, "5");
123
124 halName = "TEST";
125 ecManager.primaryMicModuleInfo_.format = "2";
126 sRet = ecManager.GetEcFormat(halName, outModuleInfo);
127 EXPECT_EQ(sRet, "2");
128 }
129
130 /**
131 * @tc.name : Test AudioEcManager.
132 * @tc.number: AudioEcManager_004
133 * @tc.desc : Test GetPipeNameByDeviceForEc interface.
134 */
135 HWTEST_F(AudioEcManagerUnitTest, AudioEcManager_004, TestSize.Level1)
136 {
137 std::string role;
138 DeviceType deviceType = DEVICE_TYPE_SPEAKER;
139 AudioEcManager& ecManager(AudioEcManager::GetInstance());
140 std::string sRet;
141
142 sRet = ecManager.GetPipeNameByDeviceForEc(role, deviceType);
143 EXPECT_EQ(sRet, PIPE_PRIMARY_OUTPUT);
144
145 deviceType = DEVICE_TYPE_WIRED_HEADSET;
146 sRet = ecManager.GetPipeNameByDeviceForEc(role, deviceType);
147 EXPECT_EQ(sRet, PIPE_PRIMARY_OUTPUT);
148
149 deviceType = DEVICE_TYPE_USB_HEADSET;
150 sRet = ecManager.GetPipeNameByDeviceForEc(role, deviceType);
151 EXPECT_EQ(sRet, PIPE_PRIMARY_OUTPUT);
152
153 deviceType = DEVICE_TYPE_BLUETOOTH_SCO;
154 sRet = ecManager.GetPipeNameByDeviceForEc(role, deviceType);
155 EXPECT_EQ(sRet, PIPE_PRIMARY_OUTPUT);
156
157 role = ROLE_SOURCE;
158 deviceType = DEVICE_TYPE_WIRED_HEADSET;
159 sRet = ecManager.GetPipeNameByDeviceForEc(role, deviceType);
160 EXPECT_EQ(sRet, PIPE_PRIMARY_INPUT);
161
162 deviceType = DEVICE_TYPE_USB_HEADSET;
163 sRet = ecManager.GetPipeNameByDeviceForEc(role, deviceType);
164 EXPECT_EQ(sRet, PIPE_PRIMARY_INPUT);
165
166 deviceType = DEVICE_TYPE_BLUETOOTH_SCO;
167 sRet = ecManager.GetPipeNameByDeviceForEc(role, deviceType);
168 EXPECT_EQ(sRet, PIPE_PRIMARY_INPUT);
169
170 deviceType = DEVICE_TYPE_MIC;
171 sRet = ecManager.GetPipeNameByDeviceForEc(role, deviceType);
172 EXPECT_EQ(sRet, PIPE_PRIMARY_INPUT);
173
174 deviceType = DEVICE_TYPE_USB_ARM_HEADSET;
175 sRet = ecManager.GetPipeNameByDeviceForEc(role, deviceType);
176 EXPECT_EQ(sRet, PIPE_USB_ARM_INPUT);
177
178 role = "TEST";
179 sRet = ecManager.GetPipeNameByDeviceForEc(role, deviceType);
180 EXPECT_EQ(sRet, PIPE_USB_ARM_OUTPUT);
181
182 deviceType = DEVICE_TYPE_DP;
183 sRet = ecManager.GetPipeNameByDeviceForEc(role, deviceType);
184 EXPECT_EQ(sRet, PIPE_DP_OUTPUT);
185
186 deviceType = DEVICE_TYPE_NONE;
187 sRet = ecManager.GetPipeNameByDeviceForEc(role, deviceType);
188 EXPECT_EQ(sRet, PIPE_PRIMARY_OUTPUT);
189 }
190
191 /**
192 * @tc.name : Test AudioEcManager.
193 * @tc.number: AudioEcManager_005
194 * @tc.desc : Test GetPipeInfoByDeviceTypeForEc interface.
195 */
196 HWTEST_F(AudioEcManagerUnitTest, AudioEcManager_005, TestSize.Level1)
197 {
198 std::string role = ROLE_SOURCE;
199 DeviceType deviceType = DEVICE_TYPE_SPEAKER;
200 PipeInfo pipeInfo;
201 AudioEcManager& ecManager(AudioEcManager::GetInstance());
202 int32_t ret;
203
204 ret = ecManager.GetPipeInfoByDeviceTypeForEc(role, deviceType, pipeInfo);
205 EXPECT_NE(ret, SUCCESS);
206 }
207
208 /**
209 * @tc.name : Test AudioEcManager.
210 * @tc.number: AudioEcManager_006
211 * @tc.desc : Test GetEcType interface.
212 */
213 HWTEST_F(AudioEcManagerUnitTest, AudioEcManager_006, TestSize.Level1)
214 {
215 DeviceType inputDevice;
216 DeviceType outputDevice;
217 AudioEcManager& ecManager(AudioEcManager::GetInstance());
218 EcType ecRet;
219
220 inputDevice = DEVICE_TYPE_MIC;
221 outputDevice = DEVICE_TYPE_SPEAKER;
222 ecRet = ecManager.GetEcType(inputDevice, outputDevice);
223 EXPECT_EQ(ecRet, EC_TYPE_SAME_ADAPTER);
224
225 outputDevice = DEVICE_TYPE_MIC;
226 ecRet = ecManager.GetEcType(inputDevice, outputDevice);
227 EXPECT_EQ(ecRet, EC_TYPE_NONE);
228 }
229
230 /**
231 * @tc.name : Test AudioEcManager.
232 * @tc.number: AudioEcManager_007
233 * @tc.desc : Test UpdateAudioEcInfo interface.
234 */
235 HWTEST_F(AudioEcManagerUnitTest, AudioEcManager_007, TestSize.Level1)
236 {
237 AudioDeviceDescriptor inputDevice;
238 AudioDeviceDescriptor outputDevice;
239 AudioEcManager& ecManager(AudioEcManager::GetInstance());
240
241 inputDevice.deviceType_ = DEVICE_TYPE_MIC;
242 inputDevice.macAddress_ = "00:11:22:33:44:55";
243 inputDevice.networkId_ = "1234567890";
244 inputDevice.deviceRole_ = DEVICE_ROLE_NONE;
245 outputDevice.deviceType_ = DEVICE_TYPE_MIC;
246 outputDevice.macAddress_ = "00:11:22:33:44:55";
247 outputDevice.networkId_ = "1234567890";
248 outputDevice.deviceRole_ = DEVICE_ROLE_NONE;
249
250 ecManager.audioEcInfo_.inputDevice.deviceType_ = DEVICE_TYPE_MIC;
251 ecManager.audioEcInfo_.inputDevice.macAddress_ = "00:11:22:33:44:55";
252 ecManager.audioEcInfo_.inputDevice.networkId_ = "1234567890";
253 ecManager.audioEcInfo_.inputDevice.deviceRole_ = DEVICE_ROLE_NONE;
254 ecManager.audioEcInfo_.outputDevice.deviceType_ = DEVICE_TYPE_MIC;
255 ecManager.audioEcInfo_.outputDevice.macAddress_ = "00:11:22:33:44:55";
256 ecManager.audioEcInfo_.outputDevice.networkId_ = "1234567890";
257 ecManager.audioEcInfo_.outputDevice.deviceRole_ = DEVICE_ROLE_NONE;
258
259 ecManager.isEcFeatureEnable_ = false;
260 ecManager.UpdateAudioEcInfo(inputDevice, outputDevice);
261 EXPECT_EQ(ecManager.isEcFeatureEnable_, false);
262
263 ecManager.isEcFeatureEnable_ = true;
264 ecManager.UpdateAudioEcInfo(inputDevice, outputDevice);
265 EXPECT_EQ(ecManager.audioEcInfo_.inputDevice.IsSameDeviceDesc(inputDevice), true);
266
267 inputDevice.networkId_ = "12345678";
268 outputDevice.networkId_ = "12345678";
269 ecManager.UpdateAudioEcInfo(inputDevice, outputDevice);
270 EXPECT_EQ(ecManager.isEcFeatureEnable_, true);
271 }
272
273 /**
274 * @tc.name : Test AudioEcManager.
275 * @tc.number: AudioEcManager_008
276 * @tc.desc : Test UpdateModuleInfoForEc interface.
277 */
278 HWTEST_F(AudioEcManagerUnitTest, AudioEcManager_008, TestSize.Level1)
279 {
280 AudioModuleInfo moduleInfo;
281 AudioEcManager& ecManager(AudioEcManager::GetInstance());
282
283 ecManager.audioEcInfo_.channels = "5";
284 ecManager.UpdateModuleInfoForEc(moduleInfo);
285 EXPECT_EQ(moduleInfo.ecChannels, "5");
286 }
287
288 /**
289 * @tc.name : Test AudioEcManager.
290 * @tc.number: AudioEcManager_009
291 * @tc.desc : Test ShouldOpenMicRef interface.
292 */
293 HWTEST_F(AudioEcManagerUnitTest, AudioEcManager_009, TestSize.Level1)
294 {
295 SourceType source = SOURCE_TYPE_VOICE_COMMUNICATION;
296 AudioEcManager& ecManager(AudioEcManager::GetInstance());
297 std::string sRet;
298
299 ecManager.isMicRefFeatureEnable_ = false;
300 sRet = ecManager.ShouldOpenMicRef(source);
301 EXPECT_EQ(sRet, "0");
302
303 ecManager.isMicRefFeatureEnable_ = true;
304 sRet = ecManager.ShouldOpenMicRef(source);
305 EXPECT_EQ(sRet, "0");
306 }
307
308 /**
309 * @tc.name : Test AudioEcManager.
310 * @tc.number: AudioEcManager_010
311 * @tc.desc : Test UpdateModuleInfoForMicRef interface.
312 */
313 HWTEST_F(AudioEcManagerUnitTest, AudioEcManager_010, TestSize.Level1)
314 {
315 AudioModuleInfo moduleInfo;
316 SourceType source = SOURCE_TYPE_VOICE_COMMUNICATION;
317 AudioEcManager& ecManager(AudioEcManager::GetInstance());
318
319 ecManager.isMicRefFeatureEnable_ = false;
320 ecManager.UpdateModuleInfoForMicRef(moduleInfo, source);
321 EXPECT_EQ(moduleInfo.micRefChannels, "4");
322 }
323
324 /**
325 * @tc.name : Test AudioEcManager.
326 * @tc.number: AudioEcManager_011
327 * @tc.desc : Test GetAudioEcInfo interface.
328 */
329 HWTEST_F(AudioEcManagerUnitTest, AudioEcManager_011, TestSize.Level1)
330 {
331 AudioEcInfo ecInfo;
332 AudioEcManager& ecManager(AudioEcManager::GetInstance());
333
334 ecManager.audioEcInfo_.channels = "3";
335 ecInfo = ecManager.GetAudioEcInfo();
336 EXPECT_EQ(ecInfo.channels, "3");
337 }
338
339 /**
340 * @tc.name : Test AudioEcManager.
341 * @tc.number: AudioEcManager_012
342 * @tc.desc : Test UpdateArmModuleInfo interface.
343 */
344 HWTEST_F(AudioEcManagerUnitTest, AudioEcManager_012, TestSize.Level1)
345 {
346 std::string address = "00:11:22:33:44";
347 DeviceRole role = INPUT_DEVICE;
348 AudioModuleInfo moduleInfo;
349 AudioEcManager& ecManager(AudioEcManager::GetInstance());
350
351 ecManager.UpdateArmModuleInfo(address, role, moduleInfo);
352 }
353
354 /**
355 * @tc.name : Test AudioEcManager.
356 * @tc.number: AudioEcManager_013
357 * @tc.desc : Test ReloadSourceForSession interface.
358 */
359 HWTEST_F(AudioEcManagerUnitTest, AudioEcManager_013, TestSize.Level1)
360 {
361 SessionInfo sessionInfo;
362 AudioEcManager& ecManager(AudioEcManager::GetInstance());
363
364 sessionInfo.sourceType = SOURCE_TYPE_INVALID;
365 ecManager.ReloadSourceForSession(sessionInfo);
366 }
367
368 /**
369 * @tc.name : Test AudioEcManager.
370 * @tc.number: AudioEcManager_014
371 * @tc.desc : Test GetMicRefFeatureEnable interface.
372 */
373 HWTEST_F(AudioEcManagerUnitTest, AudioEcManager_014, TestSize.Level1)
374 {
375 bool bRet;
376 AudioEcManager& ecManager(AudioEcManager::GetInstance());
377
378 ecManager.isMicRefFeatureEnable_ = true;
379 bRet = ecManager.GetMicRefFeatureEnable();
380 EXPECT_EQ(bRet, true);
381 }
382
383 /**
384 * @tc.name : Test AudioEcManager.
385 * @tc.number: AudioEcManager_015
386 * @tc.desc : Test UpdateStreamEcAndMicRefInfo interface.
387 */
388 HWTEST_F(AudioEcManagerUnitTest, AudioEcManager_015, TestSize.Level1)
389 {
390 AudioModuleInfo moduleInfo;
391 SourceType sourceType = SOURCE_TYPE_INVALID;
392 AudioEcManager& ecManager(AudioEcManager::GetInstance());
393
394 ecManager.UpdateStreamEcAndMicRefInfo(moduleInfo, sourceType);
395 }
396
397 /**
398 * @tc.name : Test AudioEcManager.
399 * @tc.number: AudioEcManager_016
400 * @tc.desc : Test GetHalNameForDevice interface.
401 */
402 HWTEST_F(AudioEcManagerUnitTest, AudioEcManager_016, TestSize.Level1)
403 {
404 std::string role;
405 DeviceType deviceType;
406 AudioEcManager& ecManager(AudioEcManager::GetInstance());
407 std::string sRet;
408
409 role = ROLE_SOURCE;
410 deviceType = DEVICE_TYPE_MIC;
411 sRet = ecManager.GetHalNameForDevice(role, deviceType);
412 EXPECT_EQ(sRet, "");
413
414 role = ROLE_SINK;
415 sRet = ecManager.GetHalNameForDevice(role, deviceType);
416 EXPECT_EQ(sRet, "");
417 }
418 } // namespace AudioStandard
419 } // namespace OHOS