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