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-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_hdiadapter_test.h"
38
39 using namespace std;
40 using namespace testing::ext;
41 using namespace HMOS::Audio;
42
43 namespace {
44 const string ADAPTER_NAME_USB = "usb";
45 const string ADAPTER_NAME_INTERNAL = "internal";
46
47
48 class AudioHdiAdapterTest : public testing::Test {
49 public:
50 static void SetUpTestCase(void);
51 static void TearDownTestCase(void);
52 void SetUp();
53 void TearDown();
54 static TestAudioManager *(*GetAudioManager)();
55 static void *handleSo;
56 #ifdef AUDIO_MPI_SO
57 static int32_t (*SdkInit)();
58 static void (*SdkExit)();
59 static void *sdkSo;
60 #endif
61 };
62
63 TestAudioManager *(*AudioHdiAdapterTest::GetAudioManager)() = nullptr;
64 void *AudioHdiAdapterTest::handleSo = nullptr;
65 #ifdef AUDIO_MPI_SO
66 int32_t (*AudioHdiAdapterTest::SdkInit)() = nullptr;
67 void (*AudioHdiAdapterTest::SdkExit)() = nullptr;
68 void *AudioHdiAdapterTest::sdkSo = nullptr;
69 #endif
70
SetUpTestCase(void)71 void AudioHdiAdapterTest::SetUpTestCase(void)
72 {
73 #ifdef AUDIO_MPI_SO
74 char sdkResolvedPath[] = HDF_LIBRARY_FULL_PATH("libhdi_audio_interface_lib_render");
75 sdkSo = dlopen(sdkResolvedPath, RTLD_LAZY);
76 if (sdkSo == nullptr) {
77 return;
78 }
79 SdkInit = (int32_t (*)())(dlsym(sdkSo, "MpiSdkInit"));
80 if (SdkInit == nullptr) {
81 return;
82 }
83 SdkExit = (void (*)())(dlsym(sdkSo, "MpiSdkExit"));
84 if (SdkExit == nullptr) {
85 return;
86 }
87 SdkInit();
88 #endif
89 char absPath[PATH_MAX] = {0};
90 if (realpath(RESOLVED_PATH.c_str(), absPath) == nullptr) {
91 return;
92 }
93 handleSo = dlopen(absPath, RTLD_LAZY);
94 if (handleSo == nullptr) {
95 return;
96 }
97 GetAudioManager = (TestAudioManager *(*)())(dlsym(handleSo, FUNCTION_NAME.c_str()));
98 if (GetAudioManager == nullptr) {
99 return;
100 }
101 }
102
TearDownTestCase(void)103 void AudioHdiAdapterTest::TearDownTestCase(void)
104 {
105 #ifdef AUDIO_MPI_SO
106 SdkExit();
107 if (sdkSo != nullptr) {
108 dlclose(sdkSo);
109 sdkSo = nullptr;
110 }
111 if (SdkInit != nullptr) {
112 SdkInit = nullptr;
113 }
114 if (SdkExit != nullptr) {
115 SdkExit = nullptr;
116 }
117 #endif
118 if (handleSo != nullptr) {
119 dlclose(handleSo);
120 handleSo = nullptr;
121 }
122 if (GetAudioManager != nullptr) {
123 GetAudioManager = nullptr;
124 }
125 }
126
SetUp(void)127 void AudioHdiAdapterTest::SetUp(void) {}
128
TearDown(void)129 void AudioHdiAdapterTest::TearDown(void) {}
130
131 /**
132 * @tc.name Test GetAllAdapters API via legal input
133 * @tc.number SUB_Audio_HDI_GetAllAdapters_0001
134 * @tc.desc test GetAllAdapters interface，Returns 0 if the list is obtained successfully
135 */
136 HWTEST_F(AudioHdiAdapterTest, SUB_Audio_HDI_GetAllAdapters_0001, Function | MediumTest | Level1)
137 {
138 int32_t ret = -1;
139 int size = 0;
140 struct AudioAdapterDescriptor *descs = nullptr;
141
142 ASSERT_NE(nullptr, GetAudioManager);
143 TestAudioManager *manager = GetAudioManager();
144 ASSERT_NE(nullptr, manager);
145 ret = manager->GetAllAdapters(manager, &descs, &size);
146 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
147 EXPECT_EQ(AUDIO_ADAPTER_MAX_NUM, size);
148 }
149
150 /**
151 * @tc.name Test GetAllAdapters API via setting the incoming parameter manager is nullptr
152 * @tc.number SUB_Audio_HDI_GetAllAdapters_0002
153 * @tc.desc test GetAllAdapters interface，Returns -1 if the incoming parameter manager is nullptr
154 */
155 HWTEST_F(AudioHdiAdapterTest, SUB_Audio_HDI_GetAllAdapters_0002, Function | MediumTest | Level1)
156 {
157 int32_t ret = -1;
158 int size = 0;
159 struct AudioAdapterDescriptor *descs = nullptr;
160 TestAudioManager *manager1 = nullptr;
161
162 ASSERT_NE(nullptr, GetAudioManager);
163 TestAudioManager *manager = GetAudioManager();
164 ASSERT_NE(nullptr, manager);
165 ret = manager->GetAllAdapters(manager1, &descs, &size);
166 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
167 }
168
169 /**
170 * @tc.name Test GetAllAdapters API via setting the incoming parameter descs is nullptr
171 * @tc.number SUB_Audio_HDI_GetAllAdapters_0003
172 * @tc.desc test GetAllAdapters interface，Returns -1 if the incoming parameter descs is nullptr
173 */
174 HWTEST_F(AudioHdiAdapterTest, SUB_Audio_HDI_GetAllAdapters_0003, Function | MediumTest | Level1)
175 {
176 int32_t ret = -1;
177 int size = 0;
178 struct AudioAdapterDescriptor **descs = nullptr;
179
180 ASSERT_NE(nullptr, GetAudioManager);
181 TestAudioManager *manager = GetAudioManager();
182 ASSERT_NE(nullptr, manager);
183 ret = manager->GetAllAdapters(manager, descs, &size);
184 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
185 }
186
187 /**
188 * @tc.name Test GetAllAdapters API via setting the incoming parameter size is nullptr
189 * @tc.number SUB_Audio_HDI_GetAllAdapters_0004
190 * @tc.desc test GetAllAdapters interface，Returns -1 if the incoming parameter size is nullptr
191 */
192 HWTEST_F(AudioHdiAdapterTest, SUB_Audio_HDI_GetAllAdapters_0004, Function | MediumTest | Level1)
193 {
194 int32_t ret = -1;
195 int *size = nullptr;
196 struct AudioAdapterDescriptor *descs = nullptr;
197
198 ASSERT_NE(nullptr, GetAudioManager);
199 TestAudioManager *manager = GetAudioManager();
200 ASSERT_NE(nullptr, manager);
201 ret = manager->GetAllAdapters(manager, &descs, size);
202 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
203 }
204
205 /**
206 * @tc.name Test LoadAdapter API via legal input
207 * @tc.number SUB_Audio_HDI_LoadAdapter_0001
208 * @tc.desc test LoadAdapter interface，Returns 0 if the driver is loaded successfully
209 */
210 HWTEST_F(AudioHdiAdapterTest, SUB_Audio_HDI_LoadAdapter_0001, Function | MediumTest | Level1)
211 {
212 int32_t ret = -1;
213 int size = 0;
214 struct AudioAdapterDescriptor *descs = nullptr;
215
216 ASSERT_NE(nullptr, GetAudioManager);
217 TestAudioManager* manager = GetAudioManager();
218 ret = GetAdapters(manager, &descs, size);
219 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
220 struct AudioAdapterDescriptor *desc = &descs[0];
221 ASSERT_TRUE(desc != nullptr);
222 struct AudioAdapter *adapter = nullptr;
223 ret = manager->LoadAdapter(manager, desc, &adapter);
224 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
225 ret = -1;
226 if (adapter != nullptr) {
227 if (adapter->InitAllPorts != nullptr && adapter->CreateRender != nullptr &&
228 adapter->DestroyRender != nullptr && adapter->CreateCapture != nullptr &&
229 adapter->DestroyCapture != nullptr && adapter->GetPortCapability != nullptr &&
230 adapter->SetPassthroughMode != nullptr && adapter->GetPassthroughMode != nullptr) {
231 ret = 0;
232 }
233 }
234 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
235 manager->UnloadAdapter(manager, adapter);
236 }
237
238 /**
239 * @tc.name Test LoadAdapter API via changing the adapterName of incoming parameter desc
240 * @tc.number SUB_Audio_HDI_LoadAdapter_0002
241 * @tc.desc test LoadAdapter interface，Returns -1 if the adapterName of incoming parameter desc is not support
242 */
243 HWTEST_F(AudioHdiAdapterTest, SUB_Audio_HDI_LoadAdapter_0002, Function | MediumTest | Level1)
244 {
245 int32_t ret = -1;
246 int size = 0;
247 struct AudioAdapterDescriptor *descs = nullptr;
248
249 ASSERT_NE(nullptr, GetAudioManager);
250 TestAudioManager* manager = GetAudioManager();
251 ret = GetAdapters(manager, &descs, size);
252 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
253 struct AudioAdapterDescriptor *desc = &descs[0];
254 desc->adapterName = "illegal";
255 ASSERT_TRUE(desc != nullptr);
256 struct AudioAdapter *adapter = nullptr;
257
258 ret = manager->LoadAdapter(manager, desc, &adapter);
259 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
260 desc->adapterName = "internal";
261 ret = manager->LoadAdapter(manager, desc, &adapter);
262 manager->UnloadAdapter(manager, adapter);
263 }
264
265 /**
266 * @tc.name Test LoadAdapter API via setting the adapterName of incoming parameter desc is illegal
267 * @tc.number SUB_Audio_HDI_LoadAdapter_0003
268 * @tc.desc test LoadAdapter interface，Returns -1 if the adapterName of incoming parameter desc is illegal
269 */
270 HWTEST_F(AudioHdiAdapterTest, SUB_Audio_HDI_LoadAdapter_0003, Function | MediumTest | Level1)
271 {
272 int32_t ret = -1;
273 struct AudioAdapter *adapter = nullptr;
274 struct AudioAdapterDescriptor desc = {
275 .adapterName = "illegal",
276 .portNum = 2,
277 .ports = nullptr,
278 };
279
280 ASSERT_NE(nullptr, GetAudioManager);
281 TestAudioManager *manager = GetAudioManager();
282 ASSERT_NE(nullptr, manager);
283 ret = manager->LoadAdapter(manager, &desc, &adapter);
284 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
285 manager->UnloadAdapter(manager, adapter);
286 }
287
288 /**
289 * @tc.name Test LoadAdapter API via setting the adapterName of incoming parameter manager is nullptr
290 * @tc.number SUB_Audio_HDI_LoadAdapter_0004
291 * @tc.desc test LoadAdapter interface，Returns -1 if the incoming parameter manager is nullptr
292 */
293 HWTEST_F(AudioHdiAdapterTest, SUB_Audio_HDI_LoadAdapter_0004, Function | MediumTest | Level1)
294 {
295 int32_t ret = -1;
296 int size = 0;
297 struct AudioAdapterDescriptor *descs = nullptr;
298 TestAudioManager *managerNull = nullptr;
299
300 ASSERT_NE(nullptr, GetAudioManager);
301 TestAudioManager* manager = GetAudioManager();
302 ret = GetAdapters(manager, &descs, size);
303 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
304 struct AudioAdapterDescriptor *desc = &descs[0];
305 ASSERT_TRUE(desc != nullptr);
306 struct AudioAdapter *adapter = nullptr;
307
308 ret = manager->LoadAdapter(managerNull, desc, &adapter);
309 ASSERT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
310 manager->UnloadAdapter(manager, adapter);
311 }
312
313 /**
314 * @tc.name Test LoadAdapter API via setting the adapterName of incoming parameter desc is nullptr
315 * @tc.number SUB_Audio_HDI_LoadAdapter_0005
316 * @tc.desc test LoadAdapter interface，Returns -1 if the incoming parameter desc is nullptr
317 */
318 HWTEST_F(AudioHdiAdapterTest, SUB_Audio_HDI_LoadAdapter_0005, Function | MediumTest | Level1)
319 {
320 int32_t ret = -1;
321 struct AudioAdapterDescriptor *desc = nullptr;
322 struct AudioAdapter *adapter = nullptr;
323
324 ASSERT_NE(nullptr, GetAudioManager);
325 TestAudioManager *manager = GetAudioManager();
326 ASSERT_NE(nullptr, manager);
327 ret = manager->LoadAdapter(manager, desc, &adapter);
328 ASSERT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
329 manager->UnloadAdapter(manager, adapter);
330 }
331
332 /**
333 * @tc.name Test LoadAdapter API via setting the adapterName of incoming parameter adapter is nullptr
334 * @tc.number SUB_Audio_HDI_LoadAdapter_0006
335 * @tc.desc test LoadAdapter interface，Returns -1 if the incoming parameter adapter is nullptr
336 */
337 HWTEST_F(AudioHdiAdapterTest, SUB_Audio_HDI_LoadAdapter_0006, Function | MediumTest | Level1)
338 {
339 int32_t ret = -1;
340 int size = 0;
341 struct AudioAdapterDescriptor *descs = nullptr;
342 struct AudioAdapter **adapter = nullptr;
343
344 ASSERT_NE(nullptr, GetAudioManager);
345 TestAudioManager* manager = GetAudioManager();
346 ret = GetAdapters(manager, &descs, size);
347 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
348 struct AudioAdapterDescriptor *desc = &descs[0];
349 ASSERT_TRUE(desc != nullptr);
350
351 ret = manager->LoadAdapter(manager, desc, adapter);
352 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
353 }
354
355 /**
356 * @tc.name Test AudioAdapterInitAllPorts API via legal input.
357 * @tc.number SUB_Audio_HDI_AdapterInitAllPorts_0001
358 * @tc.desc Test AudioAdapterInitAllPorts interface, return 0 if the ports is initialize successfully.
359 */
360 HWTEST_F(AudioHdiAdapterTest, SUB_Audio_HDI_AdapterInitAllPorts_0001, Function | MediumTest | Level1)
361 {
362 int32_t ret = -1;
363 struct AudioAdapter *adapter = nullptr;
364 struct AudioPort* renderPort = nullptr;
365 ASSERT_NE(nullptr, GetAudioManager);
366 TestAudioManager* manager = GetAudioManager();
367
368 ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME_USB, &adapter, renderPort);
369 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
370 ASSERT_NE(nullptr, adapter);
371 ret = adapter->InitAllPorts(adapter);
372 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
373 manager->UnloadAdapter(manager, adapter);
374 }
375
376 /**
377 * @tc.name Test AudioAdapterInitAllPorts API when loads two adapters.
378 * @tc.number SUB_Audio_HDI_AdapterInitAllPorts_0002
379 * @tc.desc Test AudioAdapterInitAllPorts interface, return 0 if loads two adapters successfully.
380 */
381 HWTEST_F(AudioHdiAdapterTest, SUB_Audio_HDI_AdapterInitAllPorts_0002, Function | MediumTest | Level1)
382 {
383 int32_t ret = -1;
384 int32_t ret2 = -1;
385 struct AudioPort* renderPort = nullptr;
386 struct AudioPort* renderPortUsb = nullptr;
387 struct AudioAdapter *adapter = nullptr;
388 struct AudioAdapter *adapter1 = nullptr;
389 ASSERT_NE(nullptr, GetAudioManager);
390 TestAudioManager* manager = GetAudioManager();
391
392 ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME_INTERNAL, &adapter, renderPort);
393 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
394 ASSERT_NE(nullptr, adapter);
395 ret2 = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME_USB, &adapter1, renderPortUsb);
396 if (ret2 < 0 || adapter1 == nullptr) {
397 manager->UnloadAdapter(manager, adapter);
398 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret2);
399 }
400 ret = adapter->InitAllPorts(adapter);
401 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
402
403 ret = adapter->InitAllPorts(adapter1);
404 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret2);
405
406 manager->UnloadAdapter(manager, adapter);
407 manager->UnloadAdapter(manager, adapter1);
408 }
409
410 /**
411 * @tc.name Test AudioAdapterInitAllPorts API when the parameter adapter is empty.
412 * @tc.number SUB_Audio_HDI_AdapterInitAllPorts_0003
413 * @tc.desc Test AudioAdapterInitAllPorts API, return -1 if the parameter adapter is empty.
414 */
415 HWTEST_F(AudioHdiAdapterTest, SUB_Audio_HDI_AdapterInitAllPorts_0003, Function | MediumTest | Level1)
416 {
417 int32_t ret = -1;
418 struct AudioPort* audioPort = nullptr;
419 struct AudioAdapter *adapter = nullptr;
420 struct AudioAdapter *adapterNull = nullptr;
421 ASSERT_NE(nullptr, GetAudioManager);
422 TestAudioManager* manager = GetAudioManager();
423
424 ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME_USB, &adapter, audioPort);
425 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
426 ASSERT_NE(nullptr, adapter);
427 ret = adapter->InitAllPorts(adapterNull);
428 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
429 manager->UnloadAdapter(manager, adapter);
430 }
431
432 /**
433 * @tc.name Test AudioAdapterGetPortCapability API when the PortType is PORT_OUT.
434 * @tc.number SUB_Audio_HDI_AdapterGetPortCapability_0001
435 * @tc.desc Test AudioAdapterGetPortCapability,return 0 if PortType is PORT_OUT.
436 */
437 HWTEST_F(AudioHdiAdapterTest, SUB_Audio_HDI_AdapterGetPortCapability_0001, Function | MediumTest | Level1)
438 {
439 int32_t ret = -1;
440 struct AudioPort* audioPort = nullptr;
441 struct AudioAdapter *adapter = {};
442 ASSERT_NE(nullptr, GetAudioManager);
443 TestAudioManager* manager = GetAudioManager();
444 struct AudioPortCapability capability = {};
445
446 ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME_USB, &adapter, audioPort);
447 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
448 ASSERT_NE(nullptr, adapter);
449 ret = adapter->InitAllPorts(adapter);
450 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
451 ret = adapter->GetPortCapability(adapter, audioPort, &capability);
452 if (ret < 0 || capability.formats == nullptr || capability.subPorts == nullptr) {
453 manager->UnloadAdapter(manager, adapter);
454 ASSERT_NE(AUDIO_HAL_SUCCESS, ret);
455 ASSERT_NE(nullptr, capability.formats);
456 ASSERT_NE(nullptr, capability.subPorts);
457 }
458 if (capability.subPorts->desc == nullptr) {
459 manager->UnloadAdapter(manager, adapter);
460 ASSERT_NE(nullptr, capability.subPorts->desc);
461 }
462 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
463 manager->UnloadAdapter(manager, adapter);
464 }
465
466 /**
467 * @tc.name Test AudioAdapterGetPortCapability API when the PortType is PORT_IN.
468 * @tc.number SUB_Audio_HDI_AdapterGetPortCapability_0002
469 * @tc.desc Test AudioAdapterGetPortCapability,return 0 if PortType is PORT_IN.
470 */
471 HWTEST_F(AudioHdiAdapterTest, SUB_Audio_HDI_AdapterGetPortCapability_0002, Function | MediumTest | Level1)
472 {
473 int32_t ret = -1;
474 struct AudioPort* audioPort = nullptr;
475 struct AudioAdapter *adapter = {};
476 ASSERT_NE(nullptr, GetAudioManager);
477 TestAudioManager* manager = GetAudioManager();
478 struct AudioPortCapability capability = {};
479
480 ret = GetLoadAdapter(manager, PORT_IN, ADAPTER_NAME_USB, &adapter, audioPort);
481 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
482 ASSERT_NE(nullptr, adapter);
483 ret = adapter->InitAllPorts(adapter);
484 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
485 ret = adapter->GetPortCapability(adapter, audioPort, &capability);
486 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
487
488 manager->UnloadAdapter(manager, adapter);
489 }
490
491 /**
492 * @tc.name Test AudioAdapterGetPortCapability API when the PortType is PORT_OUT_IN.
493 * @tc.number SUB_Audio_HDI_AdapterGetPortCapability_0003
494 * @tc.desc Test AudioAdapterGetPortCapability,return 0 if PortType is PORT_OUT_IN.
495 */
496 HWTEST_F(AudioHdiAdapterTest, SUB_Audio_HDI_AdapterGetPortCapability_0003, Function | MediumTest | Level1)
497 {
498 int32_t ret = -1;
499 struct AudioPort* audioPort = nullptr;
500 struct AudioAdapter *adapter = {};
501 ASSERT_NE(nullptr, GetAudioManager);
502 TestAudioManager* manager = GetAudioManager();
503 struct AudioPortCapability capability = {};
504
505 ret = GetLoadAdapter(manager, PORT_OUT_IN, ADAPTER_NAME_USB, &adapter, audioPort);
506 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
507 ASSERT_NE(nullptr, adapter);
508 ret = adapter->InitAllPorts(adapter);
509 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
510 ret = adapter->GetPortCapability(adapter, audioPort, &capability);
511 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
512 manager->UnloadAdapter(manager, adapter);
513 }
514
515 /**
516 * @tc.name Test AudioAdapterGetPortCapability API, when the parameter adapter is empty.
517 * @tc.number SUB_Audio_HDI_AdapterGetPortCapability_0004
518 * @tc.desc Test AudioAdapterGetPortCapability, return -1 if the parameter adapter is empty.
519 */
520 HWTEST_F(AudioHdiAdapterTest, SUB_Audio_HDI_AdapterGetPortCapability_0004, Function | MediumTest | Level1)
521 {
522 int32_t ret = -1;
523 struct AudioPort* audioPort = nullptr;
524 struct AudioAdapter *adapter = nullptr;
525 struct AudioAdapter *adapterNull = nullptr;
526 struct AudioPortCapability capability = {};
527 ASSERT_NE(nullptr, GetAudioManager);
528 TestAudioManager* manager = GetAudioManager();
529
530 ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME_INTERNAL, &adapter, audioPort);
531 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
532 ASSERT_NE(nullptr, adapter);
533 ret = adapter->InitAllPorts(adapter);
534 ret = adapter->GetPortCapability(adapterNull, audioPort, &capability);
535 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
536
537 manager->UnloadAdapter(manager, adapter);
538 }
539
540 /**
541 * @tc.name Test AudioAdapterGetPortCapability API when the audioPort is nullptr or not supported.
542 * @tc.number SUB_Audio_HDI_AdapterGetPortCapability_0005
543 * @tc.desc Test AudioAdapterGetPortCapability, return -1 if the audioPort is nullptr or not supported.
544 */
545 HWTEST_F(AudioHdiAdapterTest, SUB_Audio_HDI_AdapterGetPortCapability_0005, Function | MediumTest | Level1)
546 {
547 int32_t ret = -1;
548 struct AudioPort *audioPortNull = nullptr;
549 struct AudioAdapter *adapter = nullptr;
550 struct AudioPortCapability capability = {};
551 ASSERT_NE(nullptr, GetAudioManager);
552 TestAudioManager* manager = GetAudioManager();
553 struct AudioPort* audioPort = nullptr;
554 struct AudioPort audioPortError = { .dir = PORT_OUT, .portId = 9, .portName = "AIP" };
555
556 ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME_INTERNAL, &adapter, audioPort);
557 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
558 ASSERT_NE(nullptr, adapter);
559 ret = adapter->InitAllPorts(adapter);
560 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
561 ret = adapter->GetPortCapability(adapter, audioPortNull, &capability);
562 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
563
564 ret = adapter->GetPortCapability(adapter, &audioPortError, &capability);
565 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, ret);
566 manager->UnloadAdapter(manager, adapter);
567 }
568
569 /**
570 * @tc.name Test AudioAdapterGetPortCapability API when the capability is nullptr.
571 * @tc.number SUB_Audio_HDI_AdapterGetPortCapability_0006
572 * @tc.desc Test AudioAdapterGetPortCapability, return -1 if capability is nullptr.
573 */
574 HWTEST_F(AudioHdiAdapterTest, SUB_Audio_HDI_AdapterGetPortCapability_0006, Function | MediumTest | Level1)
575 {
576 int32_t ret = -1;
577 struct AudioPort* audioPort = nullptr;
578 struct AudioAdapter *adapter = nullptr;
579 struct AudioPortCapability *capabilityNull = nullptr;
580 ASSERT_NE(nullptr, GetAudioManager);
581 TestAudioManager* manager = GetAudioManager();
582
583 ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME_INTERNAL, &adapter, audioPort);
584 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
585 ASSERT_NE(nullptr, adapter);
586 ret = adapter->InitAllPorts(adapter);
587 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
588 ret = adapter->GetPortCapability(adapter, audioPort, capabilityNull);
589 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
590
591 manager->UnloadAdapter(manager, adapter);
592 }
593
594 /**
595 * @tc.name Test AdapterSetPassthroughMode API when the PortType is PORT_OUT.
596 * @tc.number SUB_Audio_HDI_AdapterSetPassthroughMode_0001
597 * @tc.desc test AdapterSetPassthroughMode interface, return 0 if PortType is PORT_OUT.
598 */
599 HWTEST_F(AudioHdiAdapterTest, SUB_Audio_HDI_AdapterSetPassthroughMode_0001, Function | MediumTest | Level1)
600 {
601 int32_t ret = -1;
602 struct AudioPort* audioPort = nullptr;
603 struct AudioAdapter *adapter = nullptr;
604 ASSERT_NE(nullptr, GetAudioManager);
605 TestAudioManager* manager = GetAudioManager();
606 enum AudioPortPassthroughMode modeLpcm = PORT_PASSTHROUGH_AUTO;
607
608 ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME_USB, &adapter, audioPort);
609 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
610 ASSERT_NE(nullptr, adapter);
611 ret = adapter->InitAllPorts(adapter);
612 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
613 ret = adapter->SetPassthroughMode(adapter, audioPort, PORT_PASSTHROUGH_LPCM);
614 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
615 ret = adapter->GetPassthroughMode(adapter, audioPort, &modeLpcm);
616 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
617 EXPECT_EQ(PORT_PASSTHROUGH_LPCM, modeLpcm);
618
619 manager->UnloadAdapter(manager, adapter);
620 }
621
622 /**
623 * @tc.name Test AdapterSetPassthroughMode API when the PortType is PORT_IN.
624 * @tc.number SUB_Audio_HDI_AdapterSetPassthroughMode_0002
625 * @tc.desc test AdapterSetPassthroughMode interface, return -1 if PortType is PORT_IN.
626 */
627 HWTEST_F(AudioHdiAdapterTest, SUB_Audio_HDI_AdapterSetPassthroughMode_0002, Function | MediumTest | Level1)
628 {
629 int32_t ret = -1;
630 struct AudioAdapter *adapter = nullptr;
631 struct AudioPort* audioPort = nullptr;
632 ASSERT_NE(nullptr, GetAudioManager);
633 TestAudioManager* manager = GetAudioManager();
634
635 ret = GetLoadAdapter(manager, PORT_IN, ADAPTER_NAME_USB, &adapter, audioPort);
636 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
637 ASSERT_NE(nullptr, adapter);
638 ret = adapter->InitAllPorts(adapter);
639 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
640 ret = adapter->SetPassthroughMode(adapter, audioPort, PORT_PASSTHROUGH_LPCM);
641 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, ret);
642
643 manager->UnloadAdapter(manager, adapter);
644 }
645
646 /**
647 * @tc.name Test AdapterSetPassthroughMode API when the parameter adapter is nullptr.
648 * @tc.number SUB_Audio_HDI_AdapterSetPassthroughMode_0003
649 * @tc.desc test AdapterSetPassthroughMode interface, return -1 the parameter adapter is empty.
650 */
651 HWTEST_F(AudioHdiAdapterTest, SUB_Audio_HDI_AdapterSetPassthroughMode_0003, Function | MediumTest | Level1)
652 {
653 int32_t ret = -1;
654 struct AudioPort* audioPort = nullptr;
655 struct AudioAdapter *adapter = nullptr;
656 struct AudioAdapter *adapterNull = nullptr;
657 ASSERT_NE(nullptr, GetAudioManager);
658 TestAudioManager* manager = GetAudioManager();
659
660 ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME_INTERNAL, &adapter, audioPort);
661 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
662 ASSERT_NE(nullptr, adapter);
663 ret = adapter->SetPassthroughMode(adapterNull, audioPort, PORT_PASSTHROUGH_LPCM);
664 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
665 manager->UnloadAdapter(manager, adapter);
666 }
667
668 /**
669 * @tc.name Test AdapterSetPassthroughMode API when the parameter audioPort is nullptr or not supported.
670 * @tc.number SUB_Audio_HDI_AdapterSetPassthroughMode_0004
671 * @tc.desc test AdapterSetPassthroughMode interface, return -1 if the audioPort is nullptr or not supported.
672 */
673 HWTEST_F(AudioHdiAdapterTest, SUB_Audio_HDI_AdapterSetPassthroughMode_0004, Function | MediumTest | Level1)
674 {
675 int32_t ret = -1;
676 struct AudioPort* audioPort = nullptr;
677 struct AudioPort *audioPortNull = nullptr;
678 enum AudioPortPassthroughMode mode = PORT_PASSTHROUGH_LPCM;
679 struct AudioAdapter *adapter = nullptr;
680 ASSERT_NE(nullptr, GetAudioManager);
681 TestAudioManager* manager = GetAudioManager();
682 struct AudioPort audioPortError = { .dir = PORT_OUT, .portId = 8, .portName = "AIP1" };
683 ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME_USB, &adapter, audioPort);
684 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
685 ASSERT_NE(nullptr, adapter);
686 ret = adapter->InitAllPorts(adapter);
687 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
688 ret = adapter->SetPassthroughMode(adapter, audioPortNull, mode);
689 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
690
691 ret = adapter->SetPassthroughMode(adapter, &audioPortError, mode);
692 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, ret);
693 manager->UnloadAdapter(manager, adapter);
694 }
695
696 /**
697 * @tc.name Test AdapterSetPassthroughMode API when the not supported mode.
698 * @tc.number SUB_Audio_HDI_AdapterSetPassthroughMode_0005
699 * @tc.desc test AdapterSetPassthroughMode interface, return -1 if the not supported mode.
700 */
701 HWTEST_F(AudioHdiAdapterTest, SUB_Audio_HDI_AdapterSetPassthroughMode_0005, Function | MediumTest | Level1)
702 {
703 int32_t ret = -1;
704 struct AudioPort* audioPort = nullptr;
705 struct AudioAdapter *adapter = nullptr;
706 ASSERT_NE(nullptr, GetAudioManager);
707 TestAudioManager* manager = GetAudioManager();
708
709 ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME_USB, &adapter, audioPort);
710 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
711 ASSERT_NE(nullptr, adapter);
712 ret = adapter->InitAllPorts(adapter);
713 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
714 ret = adapter->SetPassthroughMode(adapter, audioPort, PORT_PASSTHROUGH_RAW);
715 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, ret);
716
717 manager->UnloadAdapter(manager, adapter);
718 }
719
720 /**
721 * @tc.name Test AdapterGetPassthroughMode API via legal input
722 * @tc.number SUB_Audio_HDI_AdapterGetPassthroughMode_0001
723 * @tc.desc test AdapterGetPassthroughMode interface, return 0 if is get successfully.
724 */
725 HWTEST_F(AudioHdiAdapterTest, SUB_Audio_HDI_AdapterGetPassthroughMode_0001, Function | MediumTest | Level1)
726 {
727 int32_t ret = -1;
728 struct AudioPort* audioPort = nullptr;
729 enum AudioPortPassthroughMode mode = PORT_PASSTHROUGH_AUTO;
730 struct AudioAdapter *adapter = nullptr;
731 ASSERT_NE(nullptr, GetAudioManager);
732 TestAudioManager* manager = GetAudioManager();
733
734 ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME_USB, &adapter, audioPort);
735 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
736 ASSERT_NE(nullptr, adapter);
737 ret = adapter->InitAllPorts(adapter);
738 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
739
740 ret = adapter->SetPassthroughMode(adapter, audioPort, PORT_PASSTHROUGH_LPCM);
741 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
742
743 ret = adapter->GetPassthroughMode(adapter, audioPort, &mode);
744 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
745 EXPECT_EQ(PORT_PASSTHROUGH_LPCM, mode);
746
747 manager->UnloadAdapter(manager, adapter);
748 }
749
750 /**
751 * @tc.name Test AdapterGetPassthroughMode API when the parameter adapter is nullptr.
752 * @tc.number SUB_Audio_HDI_AdapterGetPassthroughMode_0002
753 * @tc.desc test AdapterGetPassthroughMode interface, return -1 if the parameter adapter is empty..
754 */
755 HWTEST_F(AudioHdiAdapterTest, SUB_Audio_HDI_AdapterGetPassthroughMode_0002, Function | MediumTest | Level1)
756 {
757 int32_t ret = -1;
758 struct AudioPort* audioPort = nullptr;
759 enum AudioPortPassthroughMode mode = PORT_PASSTHROUGH_LPCM;
760 struct AudioAdapter *adapter = nullptr;
761 struct AudioAdapter *adapterNull = nullptr;
762 ASSERT_NE(nullptr, GetAudioManager);
763 TestAudioManager* manager = GetAudioManager();
764
765 ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME_USB, &adapter, audioPort);
766 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
767 ASSERT_NE(nullptr, adapter);
768 ret = adapter->InitAllPorts(adapter);
769 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
770 ret = adapter->GetPassthroughMode(adapterNull, audioPort, &mode);
771 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
772
773 manager->UnloadAdapter(manager, adapter);
774 }
775
776 /**
777 * @tc.name Test AdapterGetPassthroughMode API when the parameter audioPort is nullptr or not supported.
778 * @tc.number SUB_Audio_HDI_AdapterGetPassthroughMode_0003
779 * @tc.desc test AdapterGetPassthroughMode interface, return -1 if the audioPort is nullptr or not supported.
780 */
781 HWTEST_F(AudioHdiAdapterTest, SUB_Audio_HDI_AdapterGetPassthroughMode_0003, Function | MediumTest | Level1)
782 {
783 int32_t ret = -1;
784 struct AudioPort* audioPort = nullptr;
785 struct AudioPort *audioPortNull = nullptr;
786 enum AudioPortPassthroughMode mode = PORT_PASSTHROUGH_LPCM;
787 struct AudioAdapter *adapter = nullptr;
788 ASSERT_NE(nullptr, GetAudioManager);
789 TestAudioManager* manager = GetAudioManager();
790 struct AudioPort audioPortError = { .dir = PORT_OUT, .portId = 8, .portName = "AIP" };
791 ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME_USB, &adapter, audioPort);
792 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
793 ASSERT_NE(nullptr, adapter);
794 ret = adapter->InitAllPorts(adapter);
795 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
796 ret = adapter->GetPassthroughMode(adapter, audioPortNull, &mode);
797 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
798
799 ret = adapter->GetPassthroughMode(adapter, &audioPortError, &mode);
800 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, ret);
801 manager->UnloadAdapter(manager, adapter);
802 }
803
804 /**
805 * @tc.name Test AdapterGetPassthroughMode API when the parameter mode is nullptr.
806 * @tc.number SUB_Audio_HDI_AdapterGetPassthroughMode_0004
807 * @tc.desc test AdapterGetPassthroughMode interface, return -1 if the parameter mode is empty.
808 */
809 HWTEST_F(AudioHdiAdapterTest, SUB_Audio_HDI_AdapterGetPassthroughMode_0004, Function | MediumTest | Level1)
810 {
811 int32_t ret = -1;
812 struct AudioPort* audioPort = nullptr;
813 enum AudioPortPassthroughMode *modeNull = nullptr;
814 struct AudioAdapter *adapter = nullptr;
815 ASSERT_NE(nullptr, GetAudioManager);
816 TestAudioManager* manager = GetAudioManager();
817
818 ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME_USB, &adapter, audioPort);
819 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
820 ASSERT_NE(nullptr, adapter);
821 ret = adapter->InitAllPorts(adapter);
822 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
823 ret = adapter->GetPassthroughMode(adapter, audioPort, modeNull);
824 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
825
826 manager->UnloadAdapter(manager, adapter);
827 }
828 }