1 /*
2 * Copyright (c) 2022 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-related APIs, including custom data types and functions for loading drivers,
21 * accessing a driver adapter.
22 *
23 * @since 1.0
24 * @version 1.0
25 */
26
27 /**
28 * @file audio_hdi_common.h
29 *
30 * @brief Declares APIs for operations related to the audio adapter.
31 *
32 * @since 1.0
33 * @version 1.0
34 */
35
36 #include "audio_hdi_common.h"
37 #include "audio_usb_adapter_test.h"
38
39 using namespace std;
40 using namespace testing::ext;
41 using namespace OHOS::Audio;
42
43 namespace {
44 const string ADAPTER_NAME_USB = "usb";
45
46 class AudioUsbAdapterTest : public testing::Test {
47 public:
48 static void SetUpTestCase(void);
49 static void TearDownTestCase(void);
50 void SetUp();
51 void TearDown();
52 static TestAudioManager *manager;
53 };
54
55 TestAudioManager *AudioUsbAdapterTest::manager = nullptr;
56
SetUpTestCase(void)57 void AudioUsbAdapterTest::SetUpTestCase(void)
58 {
59 manager = GetAudioManagerFuncs();
60 ASSERT_NE(nullptr, manager);
61 }
62
TearDownTestCase(void)63 void AudioUsbAdapterTest::TearDownTestCase(void) {}
64
SetUp(void)65 void AudioUsbAdapterTest::SetUp(void) {}
66
TearDown(void)67 void AudioUsbAdapterTest::TearDown(void) {}
68
69 /**
70 * @tc.name AudioAdapterInitAllPorts_001
71 * @tc.desc Test AudioAdapterInitAllPorts interface, return 0 if the ports is initialize successfully.
72 * @tc.type: FUNC
73 */
74 HWTEST_F(AudioUsbAdapterTest, AudioAdapterInitAllPorts_001, TestSize.Level1)
75 {
76 int32_t ret = -1;
77 struct AudioAdapter *adapter = nullptr;
78 struct AudioPort* renderPort = nullptr;
79 ASSERT_NE(nullptr, manager);
80
81 ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME_USB, &adapter, renderPort);
82 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
83 ASSERT_NE(nullptr, adapter);
84 ret = adapter->InitAllPorts(adapter);
85 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
86 manager->UnloadAdapter(manager, adapter);
87 }
88 /**
89 * @tc.name AudioAdapterGetPortCapability_001
90 * @tc.desc Test AudioAdapterGetPortCapability,return 0 if PortType is PORT_OUT.
91 * @tc.type: FUNC
92 */
93 HWTEST_F(AudioUsbAdapterTest, AudioAdapterGetPortCapability_001, TestSize.Level1)
94 {
95 int32_t ret = -1;
96 struct AudioPort* audioPort = nullptr;
97 struct AudioAdapter *adapter = {};
98 ASSERT_NE(nullptr, manager);
99 struct AudioPortCapability capability = {};
100
101 ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME_USB, &adapter, audioPort);
102 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
103 ASSERT_NE(nullptr, adapter);
104 ret = adapter->InitAllPorts(adapter);
105 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
106 ret = adapter->GetPortCapability(adapter, audioPort, &capability);
107
108 if (ret < 0 || capability.formats == nullptr || capability.subPorts == nullptr) {
109 manager->UnloadAdapter(manager, adapter);
110 ASSERT_NE(AUDIO_HAL_SUCCESS, ret);
111 ASSERT_NE(nullptr, capability.formats);
112 ASSERT_NE(nullptr, capability.subPorts);
113 }
114
115 if (capability.subPorts->desc == nullptr) {
116 manager->UnloadAdapter(manager, adapter);
117 ASSERT_NE(nullptr, capability.subPorts->desc);
118 }
119
120 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
121 manager->UnloadAdapter(manager, adapter);
122 }
123 /**
124 * @tc.name AudioAdapterGetPortCapability_002
125 * @tc.desc Test AudioAdapterGetPortCapability,return 0 if PortType is PORT_IN.
126 * @tc.type: FUNC
127 */
128 HWTEST_F(AudioUsbAdapterTest, AudioAdapterGetPortCapability_002, TestSize.Level1)
129 {
130 int32_t ret = -1;
131 struct AudioPort* audioPort = nullptr;
132 struct AudioAdapter *adapter = {};
133 ASSERT_NE(nullptr, manager);
134 struct AudioPortCapability capability = {};
135
136 ret = GetLoadAdapter(manager, PORT_IN, ADAPTER_NAME_USB, &adapter, audioPort);
137 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
138 ASSERT_NE(nullptr, adapter);
139 ret = adapter->InitAllPorts(adapter);
140 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
141 ret = adapter->GetPortCapability(adapter, audioPort, &capability);
142 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
143
144 manager->UnloadAdapter(manager, adapter);
145 }
146 /**
147 * @tc.name AudioAdapterGetPortCapability_003
148 * @tc.desc Test AudioAdapterGetPortCapability,return 0 if PortType is PORT_OUT_IN.
149 * @tc.type: FUNC
150 */
151 HWTEST_F(AudioUsbAdapterTest, AudioAdapterGetPortCapability_003, TestSize.Level1)
152 {
153 int32_t ret = -1;
154 struct AudioPort* audioPort = nullptr;
155 struct AudioAdapter *adapter = {};
156 ASSERT_NE(nullptr, manager);
157 struct AudioPortCapability capability = {};
158
159 ret = GetLoadAdapter(manager, PORT_OUT_IN, ADAPTER_NAME_USB, &adapter, audioPort);
160 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
161 ASSERT_NE(nullptr, adapter);
162 ret = adapter->InitAllPorts(adapter);
163 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
164 ret = adapter->GetPortCapability(adapter, audioPort, &capability);
165 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
166 manager->UnloadAdapter(manager, adapter);
167 }
168
169 /**
170 * @tc.name AudioAdapterSetPassthroughMode_001
171 * @tc.desc test AdapterSetPassthroughMode interface, return 0 if PortType is PORT_OUT.
172 * @tc.type: FUNC
173 */
174 HWTEST_F(AudioUsbAdapterTest, AudioAdapterSetPassthroughMode_001, TestSize.Level1)
175 {
176 int32_t ret = -1;
177 struct AudioPort* audioPort = nullptr;
178 struct AudioAdapter *adapter = nullptr;
179 ASSERT_NE(nullptr, manager);
180 AudioPortPassthroughMode modeLpcm = PORT_PASSTHROUGH_AUTO;
181
182 ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME_USB, &adapter, audioPort);
183 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
184 ASSERT_NE(nullptr, adapter);
185 ret = adapter->InitAllPorts(adapter);
186 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
187 ret = adapter->SetPassthroughMode(adapter, audioPort, PORT_PASSTHROUGH_LPCM);
188 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
189 ret = adapter->GetPassthroughMode(adapter, audioPort, &modeLpcm);
190 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
191 EXPECT_EQ(PORT_PASSTHROUGH_LPCM, modeLpcm);
192
193 manager->UnloadAdapter(manager, adapter);
194 }
195
196 /**
197 * @tc.name AudioAdapterSetPassthroughMode_002
198 * @tc.desc test AdapterSetPassthroughMode interface, return -1 if PortType is PORT_IN.
199 * @tc.type: FUNC
200 */
201 HWTEST_F(AudioUsbAdapterTest, AudioAdapterSetPassthroughMode_002, TestSize.Level1)
202 {
203 int32_t ret = -1;
204 struct AudioAdapter *adapter = nullptr;
205 struct AudioPort* audioPort = nullptr;
206 ASSERT_NE(nullptr, manager);
207
208 ret = GetLoadAdapter(manager, PORT_IN, ADAPTER_NAME_USB, &adapter, audioPort);
209 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
210 ASSERT_NE(nullptr, adapter);
211 ret = adapter->InitAllPorts(adapter);
212 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
213 ret = adapter->SetPassthroughMode(adapter, audioPort, PORT_PASSTHROUGH_LPCM);
214 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, ret);
215
216 manager->UnloadAdapter(manager, adapter);
217 }
218
219 /**
220 * @tc.name AudioAdapterGetPassthroughMode_001
221 * @tc.desc test AdapterGetPassthroughMode interface, return 0 if is get successfully.
222 * @tc.type: FUNC
223 */
224 HWTEST_F(AudioUsbAdapterTest, AudioAdapterGetPassthroughMode_001, TestSize.Level1)
225 {
226 int32_t ret = -1;
227 struct AudioPort* audioPort = nullptr;
228 AudioPortPassthroughMode mode = PORT_PASSTHROUGH_AUTO;
229 struct AudioAdapter *adapter = nullptr;
230 ASSERT_NE(nullptr, manager);
231
232 ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME_USB, &adapter, audioPort);
233 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
234 ASSERT_NE(nullptr, adapter);
235 ret = adapter->InitAllPorts(adapter);
236 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
237
238 ret = adapter->SetPassthroughMode(adapter, audioPort, PORT_PASSTHROUGH_LPCM);
239 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
240
241 ret = adapter->GetPassthroughMode(adapter, audioPort, &mode);
242 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
243 EXPECT_EQ(PORT_PASSTHROUGH_LPCM, mode);
244
245 manager->UnloadAdapter(manager, adapter);
246 }
247
248 /**
249 * @tc.name AudioCreateCapture_001
250 * @tc.desc Test AudioCreateCapture interface,Returns 0 if the AudioCapture object is created successfully
251 * @tc.type: FUNC
252 */
253 HWTEST_F(AudioUsbAdapterTest, AudioCreateCapture_001, TestSize.Level1)
254 {
255 int32_t ret = -1;
256 struct AudioAdapter *adapter = nullptr;
257 struct AudioCapture *capture = nullptr;
258
259 ASSERT_NE(nullptr, manager);
260 ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_USB, &adapter, &capture);
261 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
262 adapter->DestroyCapture(adapter, capture);
263 manager->UnloadAdapter(manager, adapter);
264 }
265 /**
266 * @tc.name AudioCreateCapture_002
267 * @tc.desc test AudioCreateCapture interface:
268 (1)service mode:Returns 0,if the AudioCapture object can be created successfully which was created
269 (2)passthrough mode: Returns -1,if the AudioCapture object can't be created which was created
270 * @tc.type: FUNC
271 */
272 HWTEST_F(AudioUsbAdapterTest, AudioCreateCapture_002, TestSize.Level1)
273 {
274 int32_t ret = -1;
275 struct AudioAdapter *adapter = nullptr;
276 struct AudioCapture *firstCapture = nullptr;
277 struct AudioCapture *secondCapture = nullptr;
278 struct AudioPort* audioPort = nullptr;
279 struct AudioSampleAttributes attrs = {};
280 struct AudioDeviceDescriptor DevDesc = {};
281
282 ASSERT_NE(nullptr, manager);
283 ret = GetLoadAdapter(manager, PORT_OUT_IN, ADAPTER_NAME_USB, &adapter, audioPort);
284 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
285 InitAttrs(attrs);
286 InitDevDesc(DevDesc, audioPort->portId, PIN_IN_MIC);
287 ret = adapter->CreateCapture(adapter, &DevDesc, &attrs, &firstCapture);
288 if (ret < 0) {
289 manager->UnloadAdapter(manager, adapter);
290 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
291 }
292 ret = adapter->CreateCapture(adapter, &DevDesc, &attrs, &secondCapture);
293 #if defined (AUDIO_ADM_SERVICE)
294 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
295 adapter->DestroyCapture(adapter, secondCapture);
296 #endif
297 #if defined (AUDIO_ADM_SO) || defined (__LITEOS__)
298 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, ret);
299 adapter->DestroyCapture(adapter, firstCapture);
300 #endif
301 manager->UnloadAdapter(manager, adapter);
302 }
303
304 /**
305 * @tc.name AudioDestroyCapture_001
306 * @tc.desc Test AudioDestroyCapture interface,Returns 0 if the AudioCapture object is destroyed
307 * @tc.type: FUNC
308 */
309 HWTEST_F(AudioUsbAdapterTest, AudioDestroyCapture_001, TestSize.Level1)
310 {
311 int32_t ret = -1;
312 struct AudioAdapter *adapter = nullptr;
313 struct AudioCapture *capture = nullptr;
314
315 ASSERT_NE(nullptr, manager);
316 ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_USB, &adapter, &capture);
317 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
318 ret = adapter->DestroyCapture(adapter, capture);
319 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
320 manager->UnloadAdapter(manager, adapter);
321 }
322 /**
323 * @tc.name AudioCreateRender_001
324 * @tc.desc test AudioCreateRender interface,return 0 if render is created successful.
325 * @tc.type: FUNC
326 */
327 HWTEST_F(AudioUsbAdapterTest, AudioCreateRender_001, TestSize.Level1)
328 {
329 int32_t ret = -1;
330 struct AudioAdapter *adapter = nullptr;
331 struct AudioRender *render = nullptr;
332 ASSERT_NE(nullptr, manager);
333 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render);
334 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
335
336 adapter->DestroyRender(adapter, render);
337 manager->UnloadAdapter(manager, adapter);
338 }
339 /**
340 * @tc.name AudioDestroyRender_001
341 * @tc.desc Test AudioDestroyRender interface, return 0 if render is destroyed successful.
342 * @tc.type: FUNC
343 */
344 HWTEST_F(AudioUsbAdapterTest, AudioDestroyRender_001, TestSize.Level1)
345 {
346 int32_t ret = -1;
347 struct AudioAdapter *adapter = nullptr;
348 struct AudioRender *render = nullptr;
349 ASSERT_NE(nullptr, manager);
350 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render);
351 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
352
353 ret = adapter->DestroyRender(adapter, render);
354 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
355 manager->UnloadAdapter(manager, adapter);
356 }
357 }
358