1 /*
2 * Copyright (c) 2021 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 /**
17 * @addtogroup Audio
18 * @{
19 *
20 * @brief Test audio route path function
21 *
22 * @since 1.0
23 * @version 1.0
24 */
25
26 #include "audio_hdi_common.h"
27 #include "audio_pathroute_test.h"
28
29 using namespace std;
30 using namespace testing::ext;
31 using namespace HMOS::Audio;
32
33 namespace {
34 const string ADAPTER_USB = "usb";
35 const string ADAPTER_INTERNAL = "internal";
36 const int REGISTER_STATUS_ON = 1;
37 const int REGISTER_STATUS_OFF = 0;
38 static struct AudioCtlElemValue g_elemValues[4] = {
39 {
40 .id.cardServiceName = "hdf_audio_codec_dev0",
41 .id.iface = AUDIODRV_CTL_ELEM_IFACE_DAC,
42 .id.itemName = "Dacl enable",
43 .value[0] = 0,
44 }, {
45 .id.cardServiceName = "hdf_audio_codec_dev0",
46 .id.iface = AUDIODRV_CTL_ELEM_IFACE_DAC,
47 .id.itemName = "Dacr enable",
48 .value[0] = 0,
49 }, {
50 .id.cardServiceName = "hdf_audio_codec_dev0",
51 .id.iface = AUDIODRV_CTL_ELEM_IFACE_PGA,
52 .id.itemName = "LPGA MIC Switch",
53 .value[0] = 0,
54 }, {
55 .id.cardServiceName = "hdf_audio_codec_dev0",
56 .id.iface = AUDIODRV_CTL_ELEM_IFACE_PGA,
57 .id.itemName = "RPGA MIC Switch",
58 .value[0] = 0,
59 }
60 };
61 class AudioPathRouteTest : public testing::Test {
62 public:
63 static void SetUpTestCase(void);
64 static void TearDownTestCase(void);
65 void SetUp();
66 void TearDown();
67 static TestAudioManager *(*GetAudioManager)();
68 static void *handleSo;
69 };
70
71 TestAudioManager *(*AudioPathRouteTest::GetAudioManager)() = nullptr;
72 void *AudioPathRouteTest::handleSo = nullptr;
73
SetUpTestCase(void)74 void AudioPathRouteTest::SetUpTestCase(void)
75 {
76 char resolvedPath[] = HDF_LIBRARY_FULL_PATH("libhdi_audio");
77 handleSo = dlopen(resolvedPath, RTLD_LAZY);
78 if (handleSo == nullptr) {
79 return;
80 }
81 GetAudioManager = (TestAudioManager* (*)())(dlsym(handleSo, "GetAudioManagerFuncs"));
82 if (GetAudioManager == nullptr) {
83 return;
84 }
85 }
86
TearDownTestCase(void)87 void AudioPathRouteTest::TearDownTestCase(void)
88 {
89 if (handleSo != nullptr) {
90 dlclose(handleSo);
91 handleSo = nullptr;
92 }
93 if (GetAudioManager != nullptr) {
94 GetAudioManager = nullptr;
95 }
96 }
97
SetUp(void)98 void AudioPathRouteTest::SetUp(void) {}
99
TearDown(void)100 void AudioPathRouteTest::TearDown(void) {}
101
102 /**
103 * @tc.name Test the audio path route selection function of palyback scene
104 * @tc.number SUB_Audio_AudioPathRoute_0001
105 * @tc.desc The audio path route can be opened successfully,When it is set to
106 palyback scene(attrs.type = AUDIO_IN_MEDIA,pins = PIN_OUT_SPEAKER)
107 * @tc.author: liweiming
108 */
109 HWTEST_F(AudioPathRouteTest, SUB_Audio_AudioPathRoute_0001, TestSize.Level1)
110 {
111 int32_t ret = -1;
112 enum AudioPortPin pins = PIN_OUT_SPEAKER;
113 struct AudioRender *render = nullptr;
114 struct AudioAdapter *adapter = nullptr;
115 ret = PowerOff(g_elemValues[0], g_elemValues[1]);
116 ASSERT_EQ(HDF_SUCCESS, ret);
117 ASSERT_NE(nullptr, GetAudioManager);
118 TestAudioManager* manager = GetAudioManager();
119 ret = AudioCreateRender(manager, pins, ADAPTER_USB, &adapter, &render);
120 ASSERT_EQ(HDF_SUCCESS, ret);
121 ret = CheckRegisterStatus(g_elemValues[0].id, g_elemValues[1].id, REGISTER_STATUS_ON, REGISTER_STATUS_ON);
122 EXPECT_EQ(HDF_SUCCESS, ret);
123 adapter->DestroyRender(adapter, render);
124 manager->UnloadAdapter(manager, adapter);
125 }
126 /**
127 * @tc.name Test the audio path route selection function via switching device SPEAKER to HEADSET
128 * @tc.number SUB_Audio_AudioPathRoute_0002
129 * @tc.desc The audio path route can be opened successfully,When switching
130 device(attrs.type = AUDIO_IN_MEDIA,pins = PIN_OUT_HEADSET)
131 * @tc.author: liweiming
132 */
133 HWTEST_F(AudioPathRouteTest, SUB_Audio_AudioPathRoute_0002, TestSize.Level1)
134 {
135 int32_t ret = -1;
136 enum AudioPortPin pins = PIN_OUT_SPEAKER;
137 struct AudioRender *render = nullptr;
138 struct AudioAdapter *adapter = nullptr;
139 g_elemValues[0].value[0] = 1;
140 g_elemValues[1].value[0] = 1;
141 ret = PowerOff(g_elemValues[0], g_elemValues[1]);
142 ASSERT_EQ(HDF_SUCCESS, ret);
143 ASSERT_NE(nullptr, GetAudioManager);
144 TestAudioManager* manager = GetAudioManager();
145 ret = AudioCreateRender(manager, pins, ADAPTER_USB, &adapter, &render);
146 ASSERT_EQ(HDF_SUCCESS, ret);
147 struct AudioSceneDescriptor scene = {
148 .scene.id = 0,
149 .desc.pins = PIN_OUT_HEADSET,
150 };
151 ret = render->scene.SelectScene(AudioHandle(render), &scene);
152 EXPECT_EQ(HDF_SUCCESS, ret);
153 ret = CheckRegisterStatus(g_elemValues[0].id, g_elemValues[1].id, REGISTER_STATUS_OFF, REGISTER_STATUS_OFF);
154 adapter->DestroyRender(adapter, render);
155 manager->UnloadAdapter(manager, adapter);
156 }
157 /**
158 * @tc.name Test the audio path route selection function of playback sence
159 when the audio path route has been opened
160 * @tc.number SUB_Audio_AudioPathRoute_0003
161 * @tc.desc The audio path route of playback scene can be opened successfully,When The current
162 audio path route has been opened
163 * @tc.author: liweiming
164 */
165 HWTEST_F(AudioPathRouteTest, SUB_Audio_AudioPathRoute_0003, TestSize.Level1)
166 {
167 int32_t ret = -1;
168 struct AudioRender *render = nullptr;
169 struct AudioAdapter *adapter = nullptr;
170 ret = PowerOff(g_elemValues[0], g_elemValues[1]);
171 ASSERT_EQ(HDF_SUCCESS, ret);
172 ASSERT_NE(nullptr, GetAudioManager);
173 TestAudioManager* manager = GetAudioManager();
174 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_USB, &adapter, &render);
175 ASSERT_EQ(HDF_SUCCESS, ret);
176 struct AudioSceneDescriptor scene = {
177 .scene.id = 0,
178 .desc.pins = PIN_OUT_SPEAKER,
179 };
180 ret = render->scene.SelectScene(AudioHandle(render), &scene);
181 EXPECT_EQ(HDF_SUCCESS, ret);
182 ret = CheckRegisterStatus(g_elemValues[0].id, g_elemValues[1].id, REGISTER_STATUS_ON, REGISTER_STATUS_ON);
183 EXPECT_EQ(HDF_SUCCESS, ret);
184 adapter->DestroyRender(adapter, render);
185 manager->UnloadAdapter(manager, adapter);
186 }
187 /**
188 * @tc.name Test the audio path route selection function of recording scene
189 * @tc.number SUB_Audio_AudioPathRoute_0004
190 * @tc.desc The audio path route can be opened successfully,When it is set to
191 recording scene(attrs.type = AUDIO_IN_MEDIA,pins = PIN_IN_MIC)
192 * @tc.author: liweiming
193 */
194 HWTEST_F(AudioPathRouteTest, SUB_Audio_AudioPathRoute_0004, TestSize.Level1)
195 {
196 int32_t ret = -1;
197 enum AudioPortPin pins = PIN_IN_MIC;
198 struct AudioAdapter *adapter = nullptr;
199 struct AudioCapture *capture = nullptr;
200 g_elemValues[3].value[0] = 1;
201 ret = PowerOff(g_elemValues[2], g_elemValues[3]);
202 ASSERT_EQ(HDF_SUCCESS, ret);
203 ASSERT_NE(nullptr, GetAudioManager);
204 TestAudioManager* manager = GetAudioManager();
205 ret = AudioCreateCapture(manager, pins, ADAPTER_INTERNAL, &adapter, &capture);
206 ASSERT_EQ(HDF_SUCCESS, ret);
207 ret = CheckRegisterStatus(g_elemValues[2].id, g_elemValues[3].id, REGISTER_STATUS_ON, REGISTER_STATUS_OFF);
208 EXPECT_EQ(HDF_SUCCESS, ret);
209 adapter->DestroyCapture(adapter, capture);
210 manager->UnloadAdapter(manager, adapter);
211 }
212 /**
213 * @tc.name Test the audio path route selection function via switching device MIC to HS_MIC
214 * @tc.number SUB_Audio_AudioPathRoute_0005
215 * @tc.desc The audio path route can be opened successfully,When it is set to
216 recording scene(attrs.type = AUDIO_IN_MEDIA,pins = PIN_IN_HS_MIC)
217 * @tc.author: liweiming
218 */
219 HWTEST_F(AudioPathRouteTest, SUB_Audio_AudioPathRoute_0005, TestSize.Level1)
220 {
221 int32_t ret = -1;
222 enum AudioPortPin pins = PIN_IN_MIC;
223 struct AudioAdapter *adapter = nullptr;
224 struct AudioCapture *capture = nullptr;
225 g_elemValues[2].value[0] = 1;
226 g_elemValues[3].value[0] = 1;
227 ret = PowerOff(g_elemValues[2], g_elemValues[3]);
228 ASSERT_EQ(HDF_SUCCESS, ret);
229 ASSERT_NE(nullptr, GetAudioManager);
230 TestAudioManager* manager = GetAudioManager();
231 ret = AudioCreateCapture(manager, pins, ADAPTER_INTERNAL, &adapter, &capture);
232 ASSERT_EQ(HDF_SUCCESS, ret);
233 struct AudioSceneDescriptor scene = {
234 .scene.id = 0,
235 .desc.pins = PIN_IN_HS_MIC,
236 };
237 ret = capture->scene.SelectScene(AudioHandle(capture), &scene);
238 EXPECT_EQ(HDF_SUCCESS, ret);
239 ret = CheckRegisterStatus(g_elemValues[2].id, g_elemValues[3].id, REGISTER_STATUS_OFF, REGISTER_STATUS_OFF);
240 adapter->DestroyCapture(adapter, capture);
241 manager->UnloadAdapter(manager, adapter);
242 }
243 /**
244 * @tc.name Test the audio path route selection function of recording sence
245 when the audio path route has been opened
246 * @tc.number SUB_Audio_AudioPathRoute_0006
247 * @tc.desc The audio path route of recording scene can be opened successfully,When The current
248 audio path route has been opened
249 * @tc.author: liweiming
250 */
251 HWTEST_F(AudioPathRouteTest, SUB_Audio_AudioPathRoute_0006, TestSize.Level1)
252 {
253 int32_t ret = -1;
254 struct AudioAdapter *adapter = nullptr;
255 struct AudioCapture *capture = nullptr;
256 g_elemValues[3].value[0] = 1;
257 ret = PowerOff(g_elemValues[2], g_elemValues[3]);
258 ASSERT_EQ(HDF_SUCCESS, ret);
259 ASSERT_NE(nullptr, GetAudioManager);
260 TestAudioManager* manager = GetAudioManager();
261 ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_INTERNAL, &adapter, &capture);
262 ASSERT_EQ(HDF_SUCCESS, ret);
263 struct AudioSceneDescriptor scene = {
264 .scene.id = 0,
265 .desc.pins = PIN_IN_MIC,
266 };
267 ret = capture->scene.SelectScene(AudioHandle(capture), &scene);
268 EXPECT_EQ(HDF_SUCCESS, ret);
269 ret = CheckRegisterStatus(g_elemValues[2].id, g_elemValues[3].id, REGISTER_STATUS_ON, REGISTER_STATUS_OFF);
270 EXPECT_EQ(HDF_SUCCESS, ret);
271 adapter->DestroyCapture(adapter, capture);
272 manager->UnloadAdapter(manager, adapter);
273 }
274 /**
275 * @tc.name Test the audio path route selection function via runing multi service scenarios
276 * @tc.number SUB_Audio_AudioPathRoute_0007
277 * @tc.desc The audio path route can be opened successfully,When runing multi service scenarios
278 * @tc.author: liweiming
279 */
280 HWTEST_F(AudioPathRouteTest, SUB_Audio_AudioPathRoute_0007, TestSize.Level1)
281 {
282 int32_t ret = -1;
283 struct AudioAdapter *captureAdapter = nullptr;
284 struct AudioAdapter *renderAdapter = nullptr;
285 struct AudioCapture *capture = nullptr;
286 struct AudioRender *render = nullptr;
287 ret = PowerOff(g_elemValues[0], g_elemValues[1]);
288 ASSERT_EQ(HDF_SUCCESS, ret);
289 ret = PowerOff(g_elemValues[2], g_elemValues[3]);
290 ASSERT_NE(nullptr, GetAudioManager);
291 TestAudioManager* manager = GetAudioManager();
292 ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_INTERNAL, &captureAdapter, &capture);
293 ASSERT_EQ(HDF_SUCCESS, ret);
294 ret = CheckRegisterStatus(g_elemValues[2].id, g_elemValues[3].id, REGISTER_STATUS_ON, REGISTER_STATUS_OFF);
295 EXPECT_EQ(HDF_SUCCESS, ret);
296 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_USB, &renderAdapter, &render);
297 if (ret < 0) {
298 captureAdapter->DestroyCapture(captureAdapter, capture);
299 manager->UnloadAdapter(manager, captureAdapter);
300 ASSERT_EQ(HDF_SUCCESS, ret);
301 }
302 ret = CheckRegisterStatus(g_elemValues[0].id, g_elemValues[1].id, REGISTER_STATUS_ON, REGISTER_STATUS_ON);
303 EXPECT_EQ(HDF_SUCCESS, ret);
304 captureAdapter->DestroyCapture(captureAdapter, capture);
305 manager->UnloadAdapter(manager, captureAdapter);
306 renderAdapter->DestroyRender(renderAdapter, render);
307 manager->UnloadAdapter(manager, renderAdapter);
308 }
309 }