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