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