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