1 /*
2 * Copyright (c) 2022 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include <gtest/gtest.h>
17 #include "osal_mem.h"
18 #include "hdi_service_common.h"
19
20 using namespace std;
21 using namespace testing::ext;
22 using namespace OHOS::Audio;
23
24 namespace {
25 class AudioIdlHdiAdapterTest : public testing::Test {
26 public:
27 static void SetUpTestCase(void);
28 static void TearDownTestCase(void);
29 void SetUp();
30 void TearDown();
31 struct AudioPort audioPort = {};
32 static TestAudioManager *manager;
33 };
34
35 TestAudioManager *AudioIdlHdiAdapterTest::manager = nullptr;
36
SetUpTestCase(void)37 void AudioIdlHdiAdapterTest::SetUpTestCase(void)
38 {
39 manager = IAudioManagerGet(IS_STUB);
40 ASSERT_NE(nullptr, manager);
41 }
42
TearDownTestCase(void)43 void AudioIdlHdiAdapterTest::TearDownTestCase(void)
44 {
45 if (manager != nullptr) {
46 (void)IAudioManagerRelease(manager, IS_STUB);
47 }
48 }
49
SetUp(void)50 void AudioIdlHdiAdapterTest::SetUp(void) {}
TearDown(void)51 void AudioIdlHdiAdapterTest::TearDown(void)
52 {
53 if (audioPort.portName != nullptr) {
54 free(audioPort.portName);
55 }
56 (void) memset_s(&audioPort, sizeof(struct AudioPort), 0, sizeof(struct AudioPort));
57 }
58
59 /**
60 * @tc.name AudioAdapterInitAllPorts_001
61 * @tc.desc Test AudioAdapterInitAllPorts interface, return 0 if the ports is initialize successfully.
62 * @tc.type: FUNC
63 */
64 HWTEST_F(AudioIdlHdiAdapterTest, AudioAdapterInitAllPorts_001, TestSize.Level1)
65 {
66 int32_t ret;
67 struct IAudioAdapter *adapter = nullptr;
68 ASSERT_NE(nullptr, manager);
69
70 ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME, &adapter, audioPort);
71 ASSERT_EQ(HDF_SUCCESS, ret);
72 ASSERT_NE(nullptr, adapter);
73 ret = adapter->InitAllPorts(adapter);
74 EXPECT_EQ(HDF_SUCCESS, ret);
75 ret = manager->UnloadAdapter(manager, ADAPTER_NAME.c_str());
76 EXPECT_EQ(HDF_SUCCESS, ret);
77 IAudioAdapterRelease(adapter, IS_STUB);
78 }
79
80 /**
81 * @tc.name AudioAdapterInitAllPorts_002
82 * @tc.desc Test AudioAdapterInitAllPorts interface, return 0 if loads two adapters successfully.
83 * @tc.type: FUNC
84 */
85 HWTEST_F(AudioIdlHdiAdapterTest, AudioAdapterInitAllPorts_002, TestSize.Level1)
86 {
87 struct AudioPort secondAudioPort = {};
88 struct IAudioAdapter *firstAdapter = nullptr;
89 struct IAudioAdapter *secondAdapter = nullptr;
90 ASSERT_NE(nullptr, manager);
91
92 int32_t ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME, &firstAdapter, audioPort);
93 ASSERT_EQ(HDF_SUCCESS, ret);
94 ASSERT_NE(nullptr, firstAdapter);
95 ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME_OUT, &secondAdapter, secondAudioPort);
96 if (ret < 0 || secondAdapter == nullptr) {
97 if (secondAudioPort.portName != nullptr) {
98 free(secondAudioPort.portName);
99 }
100 manager->UnloadAdapter(manager, ADAPTER_NAME.c_str());
101 IAudioAdapterRelease(firstAdapter, IS_STUB);;
102 ASSERT_EQ(HDF_SUCCESS, ret);
103 }
104 ret = firstAdapter->InitAllPorts(firstAdapter);
105 EXPECT_EQ(HDF_SUCCESS, ret);
106
107 ret = secondAdapter->InitAllPorts(secondAdapter);
108 EXPECT_EQ(HDF_SUCCESS, ret);
109
110 ret = manager->UnloadAdapter(manager, ADAPTER_NAME.c_str());
111 EXPECT_EQ(HDF_SUCCESS, ret);
112 ret = manager->UnloadAdapter(manager, ADAPTER_NAME_OUT.c_str());
113 EXPECT_EQ(HDF_SUCCESS, ret);
114
115 IAudioAdapterRelease(firstAdapter, IS_STUB);;
116 IAudioAdapterRelease(secondAdapter, IS_STUB);;
117 free(secondAudioPort.portName);
118 }
119
120 /**
121 * @tc.name AudioAdapterInitAllPortsNull_003
122 * @tc.desc Test AudioAdapterInitAllPorts API, return -3/-4 if the parameter adapter is nullptr.
123 * @tc.type: FUNC
124 */
125 HWTEST_F(AudioIdlHdiAdapterTest, AudioAdapterInitAllPortsNull_003, TestSize.Level1)
126 {
127 int32_t ret;
128 struct IAudioAdapter *adapter = nullptr;
129 struct IAudioAdapter *adapterNull = nullptr;
130 ASSERT_NE(nullptr, manager);
131
132 ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME, &adapter, audioPort);
133 ASSERT_EQ(HDF_SUCCESS, ret);
134 ASSERT_NE(nullptr, adapter);
135 ret = adapter->InitAllPorts(adapterNull);
136 EXPECT_EQ(ret == HDF_ERR_INVALID_PARAM || ret == HDF_ERR_INVALID_OBJECT, true);
137 ret = manager->UnloadAdapter(manager, ADAPTER_NAME.c_str());
138 EXPECT_EQ(HDF_SUCCESS, ret);
139 IAudioAdapterRelease(adapter, IS_STUB);;
140 }
141
142 /**
143 * @tc.name AudioAdapterGetPortCapability_001
144 * @tc.desc Test AudioAdapterGetPortCapability,return 0 if PortType is PORT_OUT.
145 * @tc.type: FUNC
146 */
147 HWTEST_F(AudioIdlHdiAdapterTest, AudioAdapterGetPortCapability_001, TestSize.Level1)
148 {
149 int32_t ret;
150 struct IAudioAdapter *adapter = {};
151 struct AudioPortCapability *capability = nullptr;
152 capability = (struct AudioPortCapability*)OsalMemCalloc(sizeof(struct AudioPortCapability));
153 ASSERT_NE(nullptr, capability);
154 ASSERT_NE(nullptr, manager);
155
156 ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME, &adapter, audioPort);
157 ASSERT_EQ(HDF_SUCCESS, ret);
158 ASSERT_NE(nullptr, adapter);
159 ret = adapter->InitAllPorts(adapter);
160 EXPECT_EQ(HDF_SUCCESS, ret);
161 ret = adapter->GetPortCapability(adapter, &audioPort, capability);
162 EXPECT_EQ(HDF_SUCCESS, ret);
163 EXPECT_NE(nullptr, capability->formats);
164 EXPECT_NE(nullptr, capability->subPorts);
165 if (capability->subPorts != nullptr) {
166 EXPECT_NE(nullptr, capability->subPorts->desc);
167 }
168 TestAudioPortCapabilityFree(capability, true);
169 ret = manager->UnloadAdapter(manager, ADAPTER_NAME.c_str());
170 EXPECT_EQ(HDF_SUCCESS, ret);
171 IAudioAdapterRelease(adapter, IS_STUB);;
172 }
173
174 /**
175 * @tc.name AudioAdapterGetPortCapability_002
176 * @tc.desc Test AudioAdapterGetPortCapability,return 0 if PortType is PORT_IN.
177 * @tc.type: FUNC
178 */
179 HWTEST_F(AudioIdlHdiAdapterTest, AudioAdapterGetPortCapability_002, TestSize.Level1)
180 {
181 int32_t ret;
182 struct IAudioAdapter *adapter = {};
183 struct AudioPortCapability *capability = nullptr;
184 capability = (struct AudioPortCapability*)OsalMemCalloc(sizeof(struct AudioPortCapability));
185 ASSERT_NE(nullptr, capability);
186 ASSERT_NE(nullptr, manager);
187
188 ret = GetLoadAdapter(manager, PORT_IN, ADAPTER_NAME, &adapter, audioPort);
189 ASSERT_EQ(HDF_SUCCESS, ret);
190 ASSERT_NE(nullptr, adapter);
191 ret = adapter->InitAllPorts(adapter);
192 EXPECT_EQ(HDF_SUCCESS, ret);
193 ret = adapter->GetPortCapability(adapter, &audioPort, capability);
194 EXPECT_EQ(HDF_SUCCESS, ret);
195
196 TestAudioPortCapabilityFree(capability, true);
197 ret = manager->UnloadAdapter(manager, ADAPTER_NAME.c_str());
198 EXPECT_EQ(HDF_SUCCESS, ret);
199 IAudioAdapterRelease(adapter, IS_STUB);;
200 }
201
202 /**
203 * @tc.name AudioAdapterGetPortCapabilityNull_003
204 * @tc.desc Test AudioAdapterGetPortCapability, return -3/-4 if the parameter adapter is nullptr.
205 * @tc.type: FUNC
206 */
207 HWTEST_F(AudioIdlHdiAdapterTest, AudioAdapterGetPortCapabilityNull_003, TestSize.Level1)
208 {
209 int32_t ret;
210 struct IAudioAdapter *adapter = nullptr;
211 struct IAudioAdapter *adapterNull = nullptr;
212 struct AudioPortCapability *capability = nullptr;
213 capability = (struct AudioPortCapability*)OsalMemCalloc(sizeof(struct AudioPortCapability));
214 ASSERT_NE(nullptr, capability);
215 ASSERT_NE(nullptr, manager);
216
217 ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME, &adapter, audioPort);
218 ASSERT_EQ(HDF_SUCCESS, ret);
219 ASSERT_NE(nullptr, adapter);
220 ret = adapter->InitAllPorts(adapter);
221 EXPECT_EQ(HDF_SUCCESS, ret);
222 ret = adapter->GetPortCapability(adapterNull, &audioPort, capability);
223 EXPECT_EQ(ret == HDF_ERR_INVALID_PARAM || ret == HDF_ERR_INVALID_OBJECT, true);
224
225 OsalMemFree(capability);
226 ret = manager->UnloadAdapter(manager, ADAPTER_NAME.c_str());
227 EXPECT_EQ(HDF_SUCCESS, ret);
228 IAudioAdapterRelease(adapter, IS_STUB);;
229 }
230
231 /**
232 * @tc.name AudioAdapterGetPortCapabilityNull_004
233 * @tc.desc Test AudioAdapterGetPortCapability, return -3 if the audioPort is nullptr,
234 return -1 if the audioPort is not supported.
235 * @tc.type: FUNC
236 */
237 HWTEST_F(AudioIdlHdiAdapterTest, AudioAdapterGetPortCapabilityNull_004, TestSize.Level1)
238 {
239 int32_t ret;
240 struct AudioPort *audioPortNull = nullptr;
241 struct IAudioAdapter *adapter = nullptr;
242 struct AudioPortCapability *capability = nullptr;
243 capability = (struct AudioPortCapability*)OsalMemCalloc(sizeof(struct AudioPortCapability));
244 ASSERT_NE(nullptr, capability);
245 struct AudioPort audioPortError = {.dir = PORT_OUT, .portId = 9, .portName = strdup("AIP")};
246 ASSERT_NE(nullptr, manager);
247
248 ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME, &adapter, audioPort);
249 ASSERT_EQ(HDF_SUCCESS, ret);
250 ASSERT_NE(nullptr, adapter);
251 ret = adapter->InitAllPorts(adapter);
252 EXPECT_EQ(HDF_SUCCESS, ret);
253 ret = adapter->GetPortCapability(adapter, audioPortNull, capability);
254 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret);
255
256 ret = adapter->GetPortCapability(adapter, &audioPortError, capability);
257 EXPECT_EQ(HDF_FAILURE, ret);
258 free(audioPortError.portName);
259 OsalMemFree(capability);
260 ret = manager->UnloadAdapter(manager, ADAPTER_NAME.c_str());
261 EXPECT_EQ(HDF_SUCCESS, ret);
262 IAudioAdapterRelease(adapter, IS_STUB);;
263 }
264 #ifdef AUDIO_ADM_PASSTHROUGH
265 /**
266 * @tc.name AudioAdapterGetPortCapabilityNull_005
267 * @tc.desc Test AudioAdapterGetPortCapability, return -3 if capability is nullptr.
268 * @tc.type: FUNC
269 */
270 HWTEST_F(AudioIdlHdiAdapterTest, AudioAdapterGetPortCapabilityNull_005, TestSize.Level1)
271 {
272 int32_t ret;
273 struct IAudioAdapter *adapter = nullptr;
274 struct AudioPortCapability *capabilityNull = nullptr;
275 ASSERT_NE(nullptr, manager);
276
277 ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME, &adapter, audioPort);
278 ASSERT_EQ(HDF_SUCCESS, ret);
279 ASSERT_NE(nullptr, adapter);
280 ret = adapter->InitAllPorts(adapter);
281 EXPECT_EQ(HDF_SUCCESS, ret);
282 ret = adapter->GetPortCapability(adapter, &audioPort, capabilityNull);
283 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret);
284
285 ret = manager->UnloadAdapter(manager, ADAPTER_NAME.c_str());
286 EXPECT_EQ(HDF_SUCCESS, ret);
287 IAudioAdapterRelease(adapter, IS_STUB);;
288 }
289 #endif
290 /**
291 * @tc.name AudioAdapterSetPassthroughMode_001
292 * @tc.desc test AdapterSetPassthroughMode interface, return 0 if PortType is PORT_OUT.
293 * @tc.type: FUNC
294 */
295 HWTEST_F(AudioIdlHdiAdapterTest, AudioAdapterSetPassthroughMode_001, TestSize.Level1)
296 {
297 int32_t ret;
298 struct IAudioAdapter *adapter = nullptr;
299 AudioPortPassthroughMode modeLpcm = PORT_PASSTHROUGH_AUTO;
300 ASSERT_NE(nullptr, manager);
301
302 ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME, &adapter, audioPort);
303 ASSERT_EQ(HDF_SUCCESS, ret);
304 ASSERT_NE(nullptr, adapter);
305 ret = adapter->InitAllPorts(adapter);
306 EXPECT_EQ(HDF_SUCCESS, ret);
307 ret = adapter->SetPassthroughMode(adapter, &audioPort, PORT_PASSTHROUGH_LPCM);
308 EXPECT_EQ(HDF_SUCCESS, ret);
309 ret = adapter->GetPassthroughMode(adapter, &audioPort, &modeLpcm);
310 EXPECT_EQ(HDF_SUCCESS, ret);
311 EXPECT_EQ(PORT_PASSTHROUGH_LPCM, modeLpcm);
312
313 ret = manager->UnloadAdapter(manager, ADAPTER_NAME.c_str());
314 EXPECT_EQ(HDF_SUCCESS, ret);
315 IAudioAdapterRelease(adapter, IS_STUB);;
316 }
317
318 /**
319 * @tc.name AudioAdapterSetPassthroughMode_002
320 * @tc.desc test AdapterSetPassthroughMode interface, return -1 if PortType is PORT_IN.
321 * @tc.type: FUNC
322 */
323 HWTEST_F(AudioIdlHdiAdapterTest, AudioAdapterSetPassthroughMode_002, TestSize.Level1)
324 {
325 int32_t ret;
326 struct IAudioAdapter *adapter = nullptr;
327 ASSERT_NE(nullptr, manager);
328
329 ret = GetLoadAdapter(manager, PORT_IN, ADAPTER_NAME, &adapter, audioPort);
330 ASSERT_EQ(HDF_SUCCESS, ret);
331 ASSERT_NE(nullptr, adapter);
332 ret = adapter->InitAllPorts(adapter);
333 EXPECT_EQ(HDF_SUCCESS, ret);
334 ret = adapter->SetPassthroughMode(adapter, &audioPort, PORT_PASSTHROUGH_LPCM);
335 EXPECT_EQ(HDF_FAILURE, ret);
336
337 ret = manager->UnloadAdapter(manager, ADAPTER_NAME.c_str());
338 EXPECT_EQ(HDF_SUCCESS, ret);
339 IAudioAdapterRelease(adapter, IS_STUB);;
340 }
341
342 /**
343 * @tc.name AudioAdapterSetPassthroughModeNull_003
344 * @tc.desc test AdapterSetPassthroughMode interface, return -3/-4 the parameter adapter is nullptr.
345 * @tc.type: FUNC
346 */
347 HWTEST_F(AudioIdlHdiAdapterTest, AudioAdapterSetPassthroughModeNull_003, TestSize.Level1)
348 {
349 int32_t ret;
350 struct IAudioAdapter *adapter = nullptr;
351 struct IAudioAdapter *adapterNull = nullptr;
352 ASSERT_NE(nullptr, manager);
353
354 ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME, &adapter, audioPort);
355 ASSERT_EQ(HDF_SUCCESS, ret);
356 ASSERT_NE(nullptr, adapter);
357 ret = adapter->InitAllPorts(adapter);
358 EXPECT_EQ(HDF_SUCCESS, ret);
359 ret = adapter->SetPassthroughMode(adapterNull, &audioPort, PORT_PASSTHROUGH_LPCM);
360 EXPECT_EQ(ret == HDF_ERR_INVALID_PARAM || ret == HDF_ERR_INVALID_OBJECT, true);
361 ret = manager->UnloadAdapter(manager, ADAPTER_NAME.c_str());
362 EXPECT_EQ(HDF_SUCCESS, ret);
363 IAudioAdapterRelease(adapter, IS_STUB);;
364 }
365
366 /**
367 * @tc.name AudioAdapterSetPassthroughModeNull_004
368 * @tc.desc test AdapterSetPassthroughMode interface, return -3 if the audioPort is nullptr,
369 return -1 if the audioPort is not supported.
370 * @tc.type: FUNC
371 */
372 HWTEST_F(AudioIdlHdiAdapterTest, AudioAdapterSetPassthroughModeNull_004, TestSize.Level1)
373 {
374 int32_t ret;
375 struct AudioPort *audioPortNull = nullptr;
376 AudioPortPassthroughMode mode = PORT_PASSTHROUGH_LPCM;
377 struct IAudioAdapter *adapter = nullptr;
378 struct AudioPort audioPortError = { .dir = PORT_OUT, .portId = 8, .portName = strdup("AIP1")};
379 ASSERT_NE(nullptr, manager);
380
381 ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME, &adapter, audioPort);
382 ASSERT_EQ(HDF_SUCCESS, ret);
383 ASSERT_NE(nullptr, adapter);
384 ret = adapter->InitAllPorts(adapter);
385 EXPECT_EQ(HDF_SUCCESS, ret);
386 ret = adapter->SetPassthroughMode(adapter, audioPortNull, mode);
387 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret);
388
389 ret = adapter->SetPassthroughMode(adapter, &audioPortError, mode);
390 EXPECT_EQ(HDF_FAILURE, ret);
391 ret = manager->UnloadAdapter(manager, ADAPTER_NAME.c_str());
392 EXPECT_EQ(HDF_SUCCESS, ret);
393 free(audioPortError.portName);
394 IAudioAdapterRelease(adapter, IS_STUB);;
395 }
396
397 /**
398 * @tc.name AudioAdapterSetPassthroughMode_005
399 * @tc.desc test AdapterSetPassthroughMode interface, return -1 if the not supported mode.
400 * @tc.type: FUNC
401 */
402 HWTEST_F(AudioIdlHdiAdapterTest, AudioAdapterSetPassthroughMode_005, TestSize.Level1)
403 {
404 int32_t ret;
405 struct IAudioAdapter *adapter = nullptr;
406 ASSERT_NE(nullptr, manager);
407
408 ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME, &adapter, audioPort);
409 ASSERT_EQ(HDF_SUCCESS, ret);
410 ASSERT_NE(nullptr, adapter);
411 ret = adapter->InitAllPorts(adapter);
412 EXPECT_EQ(HDF_SUCCESS, ret);
413 ret = adapter->SetPassthroughMode(adapter, &audioPort, PORT_PASSTHROUGH_RAW);
414 EXPECT_EQ(HDF_FAILURE, ret);
415
416 ret = manager->UnloadAdapter(manager, ADAPTER_NAME.c_str());
417 EXPECT_EQ(HDF_SUCCESS, ret);
418 IAudioAdapterRelease(adapter, IS_STUB);
419 }
420
421 /**
422 * @tc.name AudioAdapterGetPassthroughMode_001
423 * @tc.desc test AdapterGetPassthroughMode interface, return 0 if is get successfully.
424 * @tc.type: FUNC
425 */
426 HWTEST_F(AudioIdlHdiAdapterTest, AudioAdapterGetPassthroughMode_001, TestSize.Level1)
427 {
428 int32_t ret;
429 AudioPortPassthroughMode mode = PORT_PASSTHROUGH_AUTO;
430 struct IAudioAdapter *adapter = nullptr;
431 ASSERT_NE(nullptr, manager);
432
433 ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME, &adapter, audioPort);
434 ASSERT_EQ(HDF_SUCCESS, ret);
435 ASSERT_NE(nullptr, adapter);
436 ret = adapter->InitAllPorts(adapter);
437 EXPECT_EQ(HDF_SUCCESS, ret);
438
439 ret = adapter->SetPassthroughMode(adapter, &audioPort, PORT_PASSTHROUGH_LPCM);
440 EXPECT_EQ(HDF_SUCCESS, ret);
441
442 ret = adapter->GetPassthroughMode(adapter, &audioPort, &mode);
443 EXPECT_EQ(HDF_SUCCESS, ret);
444 EXPECT_EQ(PORT_PASSTHROUGH_LPCM, mode);
445
446 ret = manager->UnloadAdapter(manager, ADAPTER_NAME.c_str());
447 EXPECT_EQ(HDF_SUCCESS, ret);
448 IAudioAdapterRelease(adapter, IS_STUB);
449 }
450
451 /**
452 * @tc.name AudioAdapterGetPassthroughModeNull_002
453 * @tc.desc test AdapterGetPassthroughMode interface, return -3/-4 if the parameter adapter is nullptr..
454 * @tc.type: FUNC
455 */
456 HWTEST_F(AudioIdlHdiAdapterTest, AudioAdapterGetPassthroughModeNull_002, TestSize.Level1)
457 {
458 int32_t ret;
459 AudioPortPassthroughMode mode = PORT_PASSTHROUGH_LPCM;
460 struct IAudioAdapter *adapter = nullptr;
461 struct IAudioAdapter *adapterNull = nullptr;
462 ASSERT_NE(nullptr, manager);
463
464 ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME, &adapter, audioPort);
465 ASSERT_EQ(HDF_SUCCESS, ret);
466 ASSERT_NE(nullptr, adapter);
467 ret = adapter->InitAllPorts(adapter);
468 EXPECT_EQ(HDF_SUCCESS, ret);
469 ret = adapter->GetPassthroughMode(adapterNull, &audioPort, &mode);
470 EXPECT_EQ(ret == HDF_ERR_INVALID_PARAM || ret == HDF_ERR_INVALID_OBJECT, true);
471
472 ret = manager->UnloadAdapter(manager, ADAPTER_NAME.c_str());
473 EXPECT_EQ(HDF_SUCCESS, ret);
474 IAudioAdapterRelease(adapter, IS_STUB);
475 }
476
477 /**
478 * @tc.name AudioAdapterGetPassthroughModeNull_003
479 * @tc.desc test AdapterGetPassthroughMode interface, return -3 if the audioPort is nullptr,
480 return -1 if the audioPort is not supported.
481 * @tc.type: FUNC
482 */
483 HWTEST_F(AudioIdlHdiAdapterTest, AudioAdapterGetPassthroughModeNull_003, TestSize.Level1)
484 {
485 int32_t ret;
486 struct AudioPort *audioPortNull = nullptr;
487 AudioPortPassthroughMode mode = PORT_PASSTHROUGH_LPCM;
488 struct IAudioAdapter *adapter = nullptr;
489 struct AudioPort audioPortError = { .dir = PORT_OUT, .portId = 8, .portName = strdup("AIP")};
490 ASSERT_NE(nullptr, manager);
491
492 ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME, &adapter, audioPort);
493 ASSERT_EQ(HDF_SUCCESS, ret);
494 ASSERT_NE(nullptr, adapter);
495 ret = adapter->InitAllPorts(adapter);
496 EXPECT_EQ(HDF_SUCCESS, ret);
497 ret = adapter->GetPassthroughMode(adapter, audioPortNull, &mode);
498 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret);
499
500 ret = adapter->GetPassthroughMode(adapter, &audioPortError, &mode);
501 EXPECT_EQ(HDF_FAILURE, ret);
502 ret = manager->UnloadAdapter(manager, ADAPTER_NAME.c_str());
503 EXPECT_EQ(HDF_SUCCESS, ret);
504 free(audioPortError.portName);
505 IAudioAdapterRelease(adapter, IS_STUB);
506 }
507
508 /**
509 * @tc.name AudioAdapterGetPassthroughModeNull_004
510 * @tc.desc test AdapterGetPassthroughMode interface, return -3 if the parameter mode is nullptr.
511 * @tc.type: FUNC
512 */
513 HWTEST_F(AudioIdlHdiAdapterTest, AudioAdapterGetPassthroughModeNull_004, TestSize.Level1)
514 {
515 int32_t ret;
516 AudioPortPassthroughMode *modeNull = nullptr;
517 struct IAudioAdapter *adapter = nullptr;
518 ASSERT_NE(nullptr, manager);
519
520 ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME, &adapter, audioPort);
521 ASSERT_EQ(HDF_SUCCESS, ret);
522 ASSERT_NE(nullptr, adapter);
523 ret = adapter->InitAllPorts(adapter);
524 EXPECT_EQ(HDF_SUCCESS, ret);
525 ret = adapter->GetPassthroughMode(adapter, &audioPort, modeNull);
526 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret);
527
528 ret = manager->UnloadAdapter(manager, ADAPTER_NAME.c_str());
529 EXPECT_EQ(HDF_SUCCESS, ret);
530 IAudioAdapterRelease(adapter, IS_STUB);
531 }
532 /**
533 * @tc.name AudioCreateCapture_001
534 * @tc.desc Test AudioCreateCapture interface,Returns 0 if the IAudioCapture object is created successfully
535 * @tc.type: FUNC
536 */
537 HWTEST_F(AudioIdlHdiAdapterTest, AudioCreateCapture_001, TestSize.Level1)
538 {
539 int32_t ret;
540 struct IAudioAdapter *adapter = nullptr;
541 struct IAudioCapture *capture = nullptr;
542 ASSERT_NE(nullptr, manager);
543 ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME, &adapter, &capture);
544 ASSERT_EQ(HDF_SUCCESS, ret);
545 struct AudioDeviceDescriptor devDesc;
546 InitDevDesc(devDesc, 0, PIN_IN_MIC);
547 adapter->DestroyCapture(adapter, &devDesc);
548 IAudioCaptureRelease(capture, IS_STUB);
549 free(devDesc.desc);
550 manager->UnloadAdapter(manager, ADAPTER_NAME.c_str());
551 IAudioAdapterRelease(adapter, IS_STUB);
552 }
553
554 /**
555 * @tc.name AudioCreateCapture_002
556 * @tc.desc test AudioCreateCapture interface:
557 (1)service mode:Returns 0,if the IAudioCapture object can be created successfully which was created
558 (2)passthrough mode: Returns -1,if the IAudioCapture object can't be created which was created
559 * @tc.type: FUNC
560 */
561 HWTEST_F(AudioIdlHdiAdapterTest, AudioCreateCapture_002, TestSize.Level1)
562 {
563 int32_t ret;
564 struct IAudioAdapter *adapter = nullptr;
565 struct IAudioCapture *firstCapture = nullptr;
566 struct IAudioCapture *secondCapture = nullptr;
567 struct AudioSampleAttributes attrs = {};
568 struct AudioDeviceDescriptor devDesc = {};
569 ASSERT_NE(nullptr, manager);
570
571 ret = GetLoadAdapter(manager, PORT_IN, ADAPTER_NAME, &adapter, audioPort);
572 ASSERT_EQ(HDF_SUCCESS, ret);
573 InitAttrs(attrs);
574 InitDevDesc(devDesc, audioPort.portId, PIN_IN_MIC);
575 ret = adapter->CreateCapture(adapter, &devDesc, &attrs, &firstCapture);
576 EXPECT_EQ(HDF_SUCCESS, ret);
577 ret = adapter->CreateCapture(adapter, &devDesc, &attrs, &secondCapture);
578 EXPECT_EQ(HDF_FAILURE, ret);
579 adapter->DestroyCapture(adapter, &devDesc);
580 IAudioCaptureRelease(firstCapture, IS_STUB);
581 manager->UnloadAdapter(manager, ADAPTER_NAME.c_str());
582 IAudioAdapterRelease(adapter, IS_STUB);
583 free(devDesc.desc);
584 }
585
586 /**
587 * @tc.name AudioCreateCapture_003
588 * @tc.desc test AudioCreateCapture interface,Returns 0 if the IAudioCapture object can be created successfully
589 when IAudioRender was created
590 * @tc.type: FUNC
591 */
592 HWTEST_F(AudioIdlHdiAdapterTest, AudioCreateCapture_003, TestSize.Level1)
593 {
594 int32_t ret;
595 struct IAudioAdapter *adapter = nullptr;
596 struct IAudioRender *render = nullptr;
597 struct IAudioCapture *capture = nullptr;
598 struct AudioSampleAttributes attrs = {};
599 struct AudioDeviceDescriptor renderDevDesc = {};
600 struct AudioDeviceDescriptor captureDevDesc = {};
601 ASSERT_NE(nullptr, manager);
602
603 ret = GetLoadAdapter(manager, PORT_IN, ADAPTER_NAME, &adapter, audioPort);
604 ASSERT_EQ(HDF_SUCCESS, ret);
605 InitAttrs(attrs);
606 InitDevDesc(renderDevDesc, audioPort.portId, PIN_OUT_SPEAKER);
607 InitDevDesc(captureDevDesc, audioPort.portId, PIN_IN_MIC);
608 ret = adapter->CreateRender(adapter, &renderDevDesc, &attrs, &render);
609 EXPECT_EQ(HDF_SUCCESS, ret);
610
611 ret = adapter->CreateCapture(adapter, &captureDevDesc, &attrs, &capture);
612 EXPECT_EQ(HDF_SUCCESS, ret);
613 adapter->DestroyCapture(adapter, &captureDevDesc);
614 IAudioCaptureRelease(capture, IS_STUB);
615 adapter->DestroyRender(adapter, &renderDevDesc);
616 IAudioRenderRelease(render, IS_STUB);
617 manager->UnloadAdapter(manager, ADAPTER_NAME.c_str());
618 IAudioAdapterRelease(adapter, IS_STUB);
619 free(renderDevDesc.desc);
620 free(captureDevDesc.desc);
621 }
622
623 /**
624 * @tc.name AudioCreateCaptureNull_005
625 * @tc.desc Test AudioCreateCapture interface,Returns -3/-4 if the incoming parameter adapter is nullptr
626 * @tc.type: FUNC
627 */
628 HWTEST_F(AudioIdlHdiAdapterTest, AudioCreateCaptureNull_005, TestSize.Level1)
629 {
630 int32_t ret;
631 struct AudioDeviceDescriptor devDesc = {};
632 struct AudioSampleAttributes attrs = {};
633 struct IAudioAdapter *adapter = nullptr;
634 struct IAudioAdapter *adapterNull = nullptr;
635 struct IAudioCapture *capture = nullptr;
636 ASSERT_NE(nullptr, manager);
637 ret = GetLoadAdapter(manager, PORT_IN, ADAPTER_NAME, &adapter, audioPort);
638 ASSERT_EQ(HDF_SUCCESS, ret);
639 InitAttrs(attrs);
640 ret = InitDevDesc(devDesc, audioPort.portId, PIN_IN_MIC);
641 EXPECT_EQ(HDF_SUCCESS, ret);
642 ret = adapter->CreateCapture(adapterNull, &devDesc, &attrs, &capture);
643 EXPECT_EQ(ret == HDF_ERR_INVALID_PARAM || ret == HDF_ERR_INVALID_OBJECT, true);
644 manager->UnloadAdapter(manager, ADAPTER_NAME.c_str());
645 IAudioAdapterRelease(adapter, IS_STUB);
646 free(devDesc.desc);
647 }
648
649 /**
650 * @tc.name AudioCreateCaptureNull_006
651 * @tc.desc Test AudioCreateCapture interface,Returns -3 if the incoming parameter desc is nullptr
652 * @tc.type: FUNC
653 */
654 HWTEST_F(AudioIdlHdiAdapterTest, AudioCreateCaptureNull_006, TestSize.Level1)
655 {
656 int32_t ret;
657 struct AudioSampleAttributes attrs = {};
658 struct AudioDeviceDescriptor *devDesc = nullptr;
659 struct IAudioAdapter *adapter = nullptr;
660 struct IAudioCapture *capture = nullptr;
661 ASSERT_NE(nullptr, manager);
662 ret = GetLoadAdapter(manager, PORT_IN, ADAPTER_NAME, &adapter, audioPort);
663 ASSERT_EQ(HDF_SUCCESS, ret);
664 InitAttrs(attrs);
665 ret = adapter->CreateCapture(adapter, devDesc, &attrs, &capture);
666 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret);
667 manager->UnloadAdapter(manager, ADAPTER_NAME.c_str());
668 IAudioAdapterRelease(adapter, IS_STUB);
669 }
670
671 /**
672 * @tc.name AudioCreateCaptureNull_007
673 * @tc.desc Test AudioCreateCapture interface,Returns -3 if the incoming parameter attrs is nullptr
674 * @tc.type: FUNC
675 */
676 HWTEST_F(AudioIdlHdiAdapterTest, AudioCreateCaptureNull_007, TestSize.Level1)
677 {
678 int32_t ret;
679 struct AudioDeviceDescriptor devDesc = {};
680 struct AudioSampleAttributes *attrs = nullptr;
681 struct IAudioAdapter *adapter = nullptr;
682 struct IAudioCapture *capture = nullptr;
683 ASSERT_NE(nullptr, manager);
684 ret = GetLoadAdapter(manager, PORT_IN, ADAPTER_NAME, &adapter, audioPort);
685 ASSERT_EQ(HDF_SUCCESS, ret);
686 ret = InitDevDesc(devDesc, audioPort.portId, PIN_IN_MIC);
687 EXPECT_EQ(HDF_SUCCESS, ret);
688 ret = adapter->CreateCapture(adapter, &devDesc, attrs, &capture);
689 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret);
690 manager->UnloadAdapter(manager, ADAPTER_NAME.c_str());
691 IAudioAdapterRelease(adapter, IS_STUB);
692 free(devDesc.desc);
693 }
694
695 #ifdef AUDIO_ADM_PASSTHROUGH
696 /**
697 * @tc.name AudioCreateCaptureNull_008
698 * @tc.desc Test AudioCreateCapture interface,Returns -3/-4 if the incoming parameter capture is nullptr
699 * @tc.type: FUNC
700 */
701 HWTEST_F(AudioIdlHdiAdapterTest, AudioCreateCaptureNull_008, TestSize.Level1)
702 {
703 int32_t ret;
704 struct AudioDeviceDescriptor devDesc = {};
705 struct AudioSampleAttributes attrs = {};
706 struct IAudioAdapter *adapter = nullptr;
707 struct IAudioCapture **capture = nullptr;
708 ASSERT_NE(nullptr, manager);
709 ret = GetLoadAdapter(manager, PORT_IN, ADAPTER_NAME, &adapter, audioPort);
710 ASSERT_EQ(HDF_SUCCESS, ret);
711 InitAttrs(attrs);
712 ret = InitDevDesc(devDesc, audioPort.portId, PIN_IN_MIC);
713 EXPECT_EQ(HDF_SUCCESS, ret);
714 ret = adapter->CreateCapture(adapter, &devDesc, &attrs, capture);
715 EXPECT_EQ(ret == HDF_ERR_INVALID_PARAM || ret == HDF_ERR_INVALID_OBJECT, true);
716 manager->UnloadAdapter(manager, ADAPTER_NAME.c_str());
717 IAudioAdapterRelease(adapter, IS_STUB);
718 free(devDesc.desc);
719 }
720 #endif
721 /**
722 * @tc.name AudioCreateCapture_009
723 * @tc.desc Test AudioCreateCapture interface,Returns -1 if the incoming parameter adapter which port type is PORT_OUT
724 * @tc.type: FUNC
725 */
726 HWTEST_F(AudioIdlHdiAdapterTest, AudioCreateCapture_009, TestSize.Level1)
727 {
728 int32_t ret;
729 struct AudioDeviceDescriptor devDesc = {};
730 struct AudioSampleAttributes attrs = {};
731 struct IAudioAdapter *adapter = nullptr;
732 struct IAudioCapture *capture = nullptr;
733 ASSERT_NE(nullptr, manager);
734 ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME_OUT, &adapter, audioPort);
735 ASSERT_EQ(HDF_SUCCESS, ret);
736 InitAttrs(attrs);
737 ret = InitDevDesc(devDesc, audioPort.portId, PIN_OUT_SPEAKER);
738 EXPECT_EQ(HDF_SUCCESS, ret);
739 ret = adapter->CreateCapture(adapter, &devDesc, &attrs, &capture);
740 EXPECT_EQ(HDF_FAILURE, ret);
741 manager->UnloadAdapter(manager, ADAPTER_NAME_OUT.c_str());
742 IAudioAdapterRelease(adapter, IS_STUB);
743 free(devDesc.desc);
744 }
745
746 /**
747 * @tc.name AudioCreateCapture_010
748 * @tc.desc Test AudioCreateCapture interface,Returns -1 if the incoming parameter desc which portID is not configed
749 * @tc.type: FUNC
750 */
751 HWTEST_F(AudioIdlHdiAdapterTest, AudioCreateCapture_010, TestSize.Level1)
752 {
753 int32_t ret;
754 struct AudioDeviceDescriptor devDesc = {};
755 struct AudioSampleAttributes attrs = {};
756 uint32_t portId = 12; // invalid portid
757 struct IAudioAdapter *adapter = nullptr;
758 struct IAudioCapture *capture = nullptr;
759 ASSERT_NE(nullptr, manager);
760 ret = GetLoadAdapter(manager, PORT_IN, ADAPTER_NAME, &adapter, audioPort);
761 ASSERT_EQ(HDF_SUCCESS, ret);
762 InitAttrs(attrs);
763 ret = InitDevDesc(devDesc, portId, PIN_IN_MIC);
764 EXPECT_EQ(HDF_SUCCESS, ret);
765 ret = adapter->CreateCapture(adapter, &devDesc, &attrs, &capture);
766 EXPECT_EQ(HDF_FAILURE, ret);
767 manager->UnloadAdapter(manager, ADAPTER_NAME.c_str());
768 IAudioAdapterRelease(adapter, IS_STUB);
769 free(devDesc.desc);
770 }
771 /**
772 * @tc.name AudioCreateRender_001
773 * @tc.desc test AudioCreateRender interface,return 0 if render is created successful.
774 * @tc.type: FUNC
775 */
776 HWTEST_F(AudioIdlHdiAdapterTest, AudioCreateRender_001, TestSize.Level1)
777 {
778 int32_t ret;
779 struct IAudioAdapter *adapter = nullptr;
780 struct IAudioRender *render = nullptr;
781 struct AudioSampleAttributes attrs = {};
782 struct AudioDeviceDescriptor renderDevDesc = {};
783 ASSERT_NE(nullptr, manager);
784 ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME, &adapter, audioPort);
785 ASSERT_EQ(HDF_SUCCESS, ret);
786 InitAttrs(attrs);
787 InitDevDesc(renderDevDesc, audioPort.portId, PIN_OUT_SPEAKER);
788 ret = adapter->CreateRender(adapter, &renderDevDesc, &attrs, &render);
789 EXPECT_EQ(HDF_SUCCESS, ret);
790 adapter->DestroyRender(adapter, &renderDevDesc);
791 IAudioRenderRelease(render, IS_STUB);
792 manager->UnloadAdapter(manager, ADAPTER_NAME.c_str());
793 IAudioAdapterRelease(adapter, IS_STUB);
794 free(renderDevDesc.desc);
795 }
796
797 /**
798 * @tc.name AudioCreateRender_003
799 * @tc.desc test AudioCreateRender interface,return -1 if the incoming parameter pins is PIN_IN_MIC.
800 * @tc.type: FUNC
801 */
802 HWTEST_F(AudioIdlHdiAdapterTest, AudioCreateRender_003, TestSize.Level1)
803 {
804 int32_t ret;
805 struct IAudioAdapter *adapter = nullptr;
806 struct IAudioRender *render = nullptr;
807 struct AudioSampleAttributes attrs = {};
808 struct AudioDeviceDescriptor devDesc = {};
809 ASSERT_NE(nullptr, manager);
810 ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME, &adapter, audioPort);
811 ASSERT_EQ(HDF_SUCCESS, ret);
812
813 InitAttrs(attrs);
814 InitDevDesc(devDesc, audioPort.portId, PIN_IN_MIC);
815
816 ret = adapter->CreateRender(adapter, &devDesc, &attrs, &render);
817 EXPECT_EQ(HDF_FAILURE, ret);
818
819 manager->UnloadAdapter(manager, ADAPTER_NAME.c_str());
820 IAudioAdapterRelease(adapter, IS_STUB);
821 free(devDesc.desc);
822 }
823
824 /**
825 * @tc.name AudioCreateRender_004
826 * @tc.desc test AudioCreateRender interface,return -1 if the incoming parameter attr is error.
827 * @tc.type: FUNC
828 */
829 HWTEST_F(AudioIdlHdiAdapterTest, AudioCreateRender_004, TestSize.Level1)
830 {
831 int32_t ret;
832 struct IAudioAdapter *adapter = nullptr;
833 struct IAudioRender *render = nullptr;
834 struct AudioSampleAttributes attrs = {};
835 struct AudioDeviceDescriptor devDesc = {};
836 uint32_t channelCountErr = 5; // invalid channelCount
837 ASSERT_NE(nullptr, manager);
838 ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME, &adapter, audioPort);
839 ASSERT_EQ(HDF_SUCCESS, ret);
840
841 InitAttrs(attrs);
842 InitDevDesc(devDesc, audioPort.portId, PIN_OUT_SPEAKER);
843 attrs.format = AUDIO_FORMAT_AAC_MAIN;
844 ret = adapter->CreateRender(adapter, &devDesc, &attrs, &render);
845 EXPECT_EQ(HDF_FAILURE, ret);
846 attrs.channelCount = channelCountErr;
847 ret = adapter->CreateRender(adapter, &devDesc, &attrs, &render);
848 EXPECT_EQ(HDF_FAILURE, ret);
849 attrs.type = AUDIO_IN_COMMUNICATION;
850 ret = adapter->CreateRender(adapter, &devDesc, &attrs, &render);
851 EXPECT_EQ(HDF_FAILURE, ret);
852
853 manager->UnloadAdapter(manager, ADAPTER_NAME.c_str());
854 IAudioAdapterRelease(adapter, IS_STUB);
855 free(devDesc.desc);
856 }
857
858 /**
859 * @tc.name AudioCreateRenderNull_005
860 * @tc.desc test AudioCreateRender interface,Returns -3/-4 if the incoming parameter adapter is nullptr.
861 * @tc.type: FUNC
862 */
863 HWTEST_F(AudioIdlHdiAdapterTest, AudioCreateRenderNull_005, TestSize.Level1)
864 {
865 int32_t ret;
866 struct IAudioAdapter *adapter = nullptr;
867 struct IAudioRender *render = nullptr;
868 struct IAudioAdapter *adapterNull = nullptr;
869 struct AudioSampleAttributes attrs = {};
870 struct AudioDeviceDescriptor devDesc = {};
871 ASSERT_NE(nullptr, manager);
872 ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME, &adapter, audioPort);
873 ASSERT_EQ(HDF_SUCCESS, ret);
874
875 InitAttrs(attrs);
876 InitDevDesc(devDesc, audioPort.portId, PIN_OUT_SPEAKER);
877
878 ret = adapter->CreateRender(adapterNull, &devDesc, &attrs, &render);
879 EXPECT_EQ(ret == HDF_ERR_INVALID_PARAM || ret == HDF_ERR_INVALID_OBJECT, true);
880
881 manager->UnloadAdapter(manager, ADAPTER_NAME.c_str());
882 IAudioAdapterRelease(adapter, IS_STUB);
883 free(devDesc.desc);
884 }
885
886 /**
887 * @tc.name AudioCreateRenderNull_006
888 * @tc.desc test AudioCreateRender interface,Returns -3 if the incoming parameter devDesc is nullptr.
889 * @tc.type: FUNC
890 */
891 HWTEST_F(AudioIdlHdiAdapterTest, AudioCreateRenderNull_006, TestSize.Level1)
892 {
893 int32_t ret;
894 struct IAudioRender *render = nullptr;
895 struct IAudioAdapter *adapter = nullptr;
896 struct AudioSampleAttributes attrs = {};
897 struct AudioDeviceDescriptor *devDescNull = nullptr;
898 ASSERT_NE(nullptr, manager);
899 ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME, &adapter, audioPort);
900 ASSERT_EQ(HDF_SUCCESS, ret);
901
902 InitAttrs(attrs);
903
904 ret = adapter->CreateRender(adapter, devDescNull, &attrs, &render);
905 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret);
906
907 manager->UnloadAdapter(manager, ADAPTER_NAME.c_str());
908 IAudioAdapterRelease(adapter, IS_STUB);
909 }
910
911 /**
912 * @tc.name AudioCreateRenderNull_007
913 * @tc.desc test AudioCreateRender interface,Returns -3 if the incoming parameter attrs is nullptr.
914 * @tc.type: FUNC
915 */
916 HWTEST_F(AudioIdlHdiAdapterTest, AudioCreateRenderNull_007, TestSize.Level1)
917 {
918 int32_t ret;
919 struct IAudioAdapter *adapter = nullptr;
920 struct IAudioRender *render = nullptr;
921 struct AudioSampleAttributes *attrsNull = nullptr;
922 struct AudioDeviceDescriptor devDesc = {};
923 ASSERT_NE(nullptr, manager);
924 ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME, &adapter, audioPort);
925 ASSERT_EQ(HDF_SUCCESS, ret);
926
927 InitDevDesc(devDesc, audioPort.portId, PIN_OUT_SPEAKER);
928
929 ret = adapter->CreateRender(adapter, &devDesc, attrsNull, &render);
930 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret);
931
932 manager->UnloadAdapter(manager, ADAPTER_NAME.c_str());
933 IAudioAdapterRelease(adapter, IS_STUB);
934 free(devDesc.desc);
935 }
936
937 #ifdef AUDIO_ADM_PASSTHROUGH
938 /**
939 * @tc.name AudioCreateRenderNull_008
940 * @tc.desc test AudioCreateRender interface,Returns -3/-4 if the incoming parameter render is nullptr.
941 * @tc.type: FUNC
942 */
943 HWTEST_F(AudioIdlHdiAdapterTest, AudioCreateRenderNull_008, TestSize.Level1)
944 {
945 int32_t ret;
946 struct IAudioAdapter *adapter = nullptr;
947 struct IAudioRender **renderNull = nullptr;
948 struct AudioSampleAttributes attrs = {};
949 struct AudioDeviceDescriptor devDesc = {};
950 ASSERT_NE(nullptr, manager);
951 ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME, &adapter, audioPort);
952 ASSERT_EQ(HDF_SUCCESS, ret);
953
954 InitAttrs(attrs);
955 InitDevDesc(devDesc, audioPort.portId, PIN_OUT_SPEAKER);
956
957 ret = adapter->CreateRender(adapter, &devDesc, &attrs, renderNull);
958 EXPECT_EQ(ret == HDF_ERR_INVALID_PARAM || ret == HDF_ERR_INVALID_OBJECT, true);
959
960 manager->UnloadAdapter(manager, ADAPTER_NAME.c_str());
961 IAudioAdapterRelease(adapter, IS_STUB);
962 free(devDesc.desc);
963 }
964 #endif
965
966 /**
967 * @tc.name AudioCreateRender_009
968 * @tc.desc test AudioCreateRender interface,Returns -1 if the incoming parameter pins of devDesc is error.
969 * @tc.type: FUNC
970 */
971 HWTEST_F(AudioIdlHdiAdapterTest, AudioCreateRender_009, TestSize.Level1)
972 {
973 int32_t ret;
974 struct IAudioAdapter *adapter = nullptr;
975 struct IAudioRender *render = nullptr;
976 struct AudioSampleAttributes attrs = {};
977 struct AudioDeviceDescriptor devDesc = {};
978 ASSERT_NE(nullptr, manager);
979 ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME, &adapter, audioPort);
980 ASSERT_EQ(HDF_SUCCESS, ret);
981
982 InitAttrs(attrs);
983 InitDevDesc(devDesc, audioPort.portId, PIN_OUT_SPEAKER);
984
985 devDesc.pins = PIN_NONE;
986 ret = adapter->CreateRender(adapter, &devDesc, &attrs, &render);
987 EXPECT_EQ(HDF_FAILURE, ret);
988
989 manager->UnloadAdapter(manager, ADAPTER_NAME.c_str());
990 IAudioAdapterRelease(adapter, IS_STUB);
991 free(devDesc.desc);
992 }
993
994 /**
995 * @tc.name AudioCreateRender_010
996 * @tc.desc test AudioCreateRender interface,Returns -1 if the incoming desc which portId is not configed
997 * @tc.type: FUNC
998 */
999 HWTEST_F(AudioIdlHdiAdapterTest, AudioCreateRender_010, TestSize.Level1)
1000 {
1001 int32_t ret;
1002 struct IAudioAdapter *adapter = nullptr;
1003 struct IAudioRender *render = nullptr;
1004 struct AudioSampleAttributes attrs = {};
1005 struct AudioDeviceDescriptor devDesc = {};
1006 uint32_t portId = 10; // invalid portId
1007 ASSERT_NE(nullptr, manager);
1008 ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME, &adapter, audioPort);
1009 ASSERT_EQ(HDF_SUCCESS, ret);
1010
1011 InitAttrs(attrs);
1012 InitDevDesc(devDesc, portId, PIN_OUT_SPEAKER);
1013
1014 ret = adapter->CreateRender(adapter, &devDesc, &attrs, &render);
1015 EXPECT_EQ(HDF_FAILURE, ret);
1016 manager->UnloadAdapter(manager, ADAPTER_NAME.c_str());
1017 IAudioAdapterRelease(adapter, IS_STUB);
1018 free(devDesc.desc);
1019 }
1020
1021 /**
1022 * @tc.name AudioDestroyCapture_001
1023 * @tc.desc Test AudioDestroyCapture interface,Returns 0 if the IAudioCapture object is destroyed
1024 * @tc.type: FUNC
1025 */
1026 HWTEST_F(AudioIdlHdiAdapterTest, AudioDestroyCapture_001, TestSize.Level1)
1027 {
1028 int32_t ret;
1029 AudioPortPin pins = PIN_IN_MIC;
1030 struct IAudioAdapter *adapter = nullptr;
1031 struct IAudioCapture *capture = nullptr;
1032 ASSERT_NE(nullptr, manager);
1033 ret = AudioCreateCapture(manager, pins, ADAPTER_NAME, &adapter, &capture);
1034 ASSERT_EQ(HDF_SUCCESS, ret);
1035 struct AudioDeviceDescriptor devDesc;
1036 InitDevDesc(devDesc, 0, PIN_IN_MIC);
1037 ret =adapter->DestroyCapture(adapter, &devDesc);
1038 EXPECT_EQ(HDF_SUCCESS, ret);
1039 free(devDesc.desc);
1040 IAudioCaptureRelease(capture, IS_STUB);
1041 manager->UnloadAdapter(manager, ADAPTER_NAME.c_str());
1042 IAudioAdapterRelease(adapter, IS_STUB);
1043 }
1044
1045 /**
1046 * @tc.name AudioDestroyCaptureNull_002
1047 * @tc.desc Test AudioDestroyCapture interface,Returns -3/-4 if the incoming parameter adapter is nullptr
1048 * @tc.type: FUNC
1049 */
1050 HWTEST_F(AudioIdlHdiAdapterTest, AudioDestroyCaptureNull_002, TestSize.Level1)
1051 {
1052 int32_t ret;
1053 struct IAudioAdapter *adapter = nullptr;
1054 struct IAudioAdapter *adapterNull = nullptr;
1055 struct IAudioCapture *capture = nullptr;
1056 ASSERT_NE(nullptr, manager);
1057 ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME, &adapter, &capture);
1058 ASSERT_EQ(HDF_SUCCESS, ret);
1059 struct AudioDeviceDescriptor devDesc;
1060 InitDevDesc(devDesc, 0, PIN_IN_MIC);
1061 ret = adapter->DestroyCapture(adapterNull, &devDesc);
1062 EXPECT_EQ(ret == HDF_ERR_INVALID_PARAM || ret == HDF_ERR_INVALID_OBJECT, true);
1063 ret = adapter->DestroyCapture(adapter, &devDesc);
1064 EXPECT_EQ(HDF_SUCCESS, ret);
1065 free(devDesc.desc);
1066 IAudioCaptureRelease(capture, IS_STUB);
1067 manager->UnloadAdapter(manager, ADAPTER_NAME.c_str());
1068 IAudioAdapterRelease(adapter, IS_STUB);
1069 }
1070
1071 /**
1072 * @tc.name AudioDestroyRender_001
1073 * @tc.desc Test AudioDestroyRender interface, return 0 if render is destroyed successful.
1074 * @tc.type: FUNC
1075 */
1076 HWTEST_F(AudioIdlHdiAdapterTest, AudioDestroyRender_001, TestSize.Level1)
1077 {
1078 int32_t ret;
1079 struct IAudioAdapter *adapter = nullptr;
1080 struct IAudioRender *render = nullptr;
1081 ASSERT_NE(nullptr, manager);
1082 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME, &adapter, &render);
1083 ASSERT_EQ(HDF_SUCCESS, ret);
1084 struct AudioDeviceDescriptor devDesc;
1085 InitDevDesc(devDesc, 0, PIN_OUT_SPEAKER);
1086 ret = adapter->DestroyRender(adapter, &devDesc);
1087 EXPECT_EQ(HDF_SUCCESS, ret);
1088 IAudioRenderRelease(render, IS_STUB);
1089 free(devDesc.desc);
1090 manager->UnloadAdapter(manager, ADAPTER_NAME.c_str());
1091 IAudioAdapterRelease(adapter, IS_STUB);
1092 }
1093 /**
1094 * @tc.name AudioDestroyRenderNull_002
1095 * @tc.desc Test AudioDestroyRender interface, return -3/-4 if the parameter render is nullptr.
1096 * @tc.type: FUNC
1097 */
1098 HWTEST_F(AudioIdlHdiAdapterTest, AudioDestroyRenderNull_002, TestSize.Level1)
1099 {
1100 int32_t ret;
1101 struct IAudioAdapter *adapter = nullptr;
1102 struct IAudioRender *render = nullptr;
1103 struct IAudioAdapter *adapterNull = nullptr;
1104 ASSERT_NE(nullptr, manager);
1105 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME, &adapter, &render);
1106 ASSERT_EQ(HDF_SUCCESS, ret);
1107 struct AudioDeviceDescriptor devDesc;
1108 InitDevDesc(devDesc, 0, PIN_OUT_SPEAKER);
1109 ret = adapter->DestroyRender(adapterNull, &devDesc);
1110 EXPECT_EQ(ret == HDF_ERR_INVALID_PARAM || ret == HDF_ERR_INVALID_OBJECT, true);
1111 ret = adapter->DestroyRender(adapter, &devDesc);
1112 EXPECT_EQ(HDF_SUCCESS, ret);
1113 free(devDesc.desc);
1114 IAudioRenderRelease(render, IS_STUB);
1115 manager->UnloadAdapter(manager, ADAPTER_NAME.c_str());
1116 IAudioAdapterRelease(adapter, IS_STUB);
1117 }
1118 }