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 ASSERT_NE(nullptr, manager);
805 ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME, &adapter, audioPort);
806 ASSERT_EQ(HDF_SUCCESS, ret);
807
808 InitAttrs(attrs);
809 InitDevDesc(devDesc, audioPort.portId, PIN_OUT_SPEAKER);
810 attrs.format = AUDIO_FORMAT_TYPE_AAC_MAIN;
811 ret = adapter->CreateRender(adapter, &devDesc, &attrs, &render, &renderId_);
812 ASSERT_TRUE(ret == HDF_FAILURE || ret == HDF_SUCCESS);
813 InitAttrs(attrs);
814 attrs.type = AUDIO_IN_COMMUNICATION;
815 ret = adapter->CreateRender(adapter, &devDesc, &attrs, &render, &renderId_);
816 EXPECT_EQ(HDF_SUCCESS, ret);
817
818 manager->UnloadAdapter(manager, ADAPTER_NAME.c_str());
819 IAudioAdapterRelease(adapter, IS_STUB);
820 free(devDesc.desc);
821 }
822
823 /**
824 * @tc.name AudioCreateRenderNull_005
825 * @tc.desc test AudioCreateRender interface,Returns -3/-4 if the incoming parameter adapter is nullptr.
826 * @tc.type: FUNC
827 */
828 HWTEST_F(AudioIdlHdiAdapterTest, AudioCreateRenderNull_005, TestSize.Level1)
829 {
830 int32_t ret;
831 struct IAudioAdapter *adapter = nullptr;
832 struct IAudioRender *render = nullptr;
833 struct IAudioAdapter *adapterNull = nullptr;
834 struct AudioSampleAttributes attrs = {};
835 struct AudioDeviceDescriptor devDesc = {};
836 ASSERT_NE(nullptr, manager);
837 ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME, &adapter, audioPort);
838 ASSERT_EQ(HDF_SUCCESS, ret);
839
840 InitAttrs(attrs);
841 InitDevDesc(devDesc, audioPort.portId, PIN_OUT_SPEAKER);
842
843 ret = adapter->CreateRender(adapterNull, &devDesc, &attrs, &render, &renderId_);
844 ASSERT_TRUE(ret == HDF_ERR_INVALID_PARAM || ret == HDF_ERR_INVALID_OBJECT);
845
846 manager->UnloadAdapter(manager, ADAPTER_NAME.c_str());
847 IAudioAdapterRelease(adapter, IS_STUB);
848 free(devDesc.desc);
849 }
850
851 /**
852 * @tc.name AudioCreateRenderNull_006
853 * @tc.desc test AudioCreateRender interface,Returns -3 if the incoming parameter devDesc is nullptr.
854 * @tc.type: FUNC
855 */
856 HWTEST_F(AudioIdlHdiAdapterTest, AudioCreateRenderNull_006, TestSize.Level1)
857 {
858 int32_t ret;
859 struct IAudioRender *render = nullptr;
860 struct IAudioAdapter *adapter = nullptr;
861 struct AudioSampleAttributes attrs = {};
862 struct AudioDeviceDescriptor *devDescNull = nullptr;
863 ASSERT_NE(nullptr, manager);
864 ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME, &adapter, audioPort);
865 ASSERT_EQ(HDF_SUCCESS, ret);
866
867 InitAttrs(attrs);
868
869 ret = adapter->CreateRender(adapter, devDescNull, &attrs, &render, &renderId_);
870 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret);
871
872 manager->UnloadAdapter(manager, ADAPTER_NAME.c_str());
873 IAudioAdapterRelease(adapter, IS_STUB);
874 }
875
876 /**
877 * @tc.name AudioCreateRenderNull_007
878 * @tc.desc test AudioCreateRender interface,Returns -3 if the incoming parameter attrs is nullptr.
879 * @tc.type: FUNC
880 */
881 HWTEST_F(AudioIdlHdiAdapterTest, AudioCreateRenderNull_007, TestSize.Level1)
882 {
883 int32_t ret;
884 struct IAudioAdapter *adapter = nullptr;
885 struct IAudioRender *render = nullptr;
886 struct AudioSampleAttributes *attrsNull = nullptr;
887 struct AudioDeviceDescriptor devDesc = {};
888 ASSERT_NE(nullptr, manager);
889 ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME, &adapter, audioPort);
890 ASSERT_EQ(HDF_SUCCESS, ret);
891
892 InitDevDesc(devDesc, audioPort.portId, PIN_OUT_SPEAKER);
893
894 ret = adapter->CreateRender(adapter, &devDesc, attrsNull, &render, &renderId_);
895 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret);
896
897 manager->UnloadAdapter(manager, ADAPTER_NAME.c_str());
898 IAudioAdapterRelease(adapter, IS_STUB);
899 free(devDesc.desc);
900 }
901
902 #ifdef AUDIO_ADM_PASSTHROUGH
903 /**
904 * @tc.name AudioCreateRenderNull_008
905 * @tc.desc test AudioCreateRender interface,Returns -3/-4 if the incoming parameter render is nullptr.
906 * @tc.type: FUNC
907 */
908 HWTEST_F(AudioIdlHdiAdapterTest, AudioCreateRenderNull_008, TestSize.Level1)
909 {
910 int32_t ret;
911 struct IAudioAdapter *adapter = nullptr;
912 struct IAudioRender **renderNull = nullptr;
913 struct AudioSampleAttributes attrs = {};
914 struct AudioDeviceDescriptor devDesc = {};
915 ASSERT_NE(nullptr, manager);
916 ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME, &adapter, audioPort);
917 ASSERT_EQ(HDF_SUCCESS, ret);
918
919 InitAttrs(attrs);
920 InitDevDesc(devDesc, audioPort.portId, PIN_OUT_SPEAKER);
921
922 ret = adapter->CreateRender(adapter, &devDesc, &attrs, renderNull, &renderId_);
923 ASSERT_TRUE(ret == HDF_ERR_INVALID_PARAM || ret == HDF_ERR_INVALID_OBJECT);
924
925 manager->UnloadAdapter(manager, ADAPTER_NAME.c_str());
926 IAudioAdapterRelease(adapter, IS_STUB);
927 free(devDesc.desc);
928 }
929 #endif
930
931 /**
932 * @tc.name AudioCreateRender_009
933 * @tc.desc test AudioCreateRender interface,Returns -1 if the incoming parameter pins of devDesc is error.
934 * @tc.type: FUNC
935 */
936 HWTEST_F(AudioIdlHdiAdapterTest, AudioCreateRender_009, TestSize.Level1)
937 {
938 int32_t ret;
939 struct IAudioAdapter *adapter = nullptr;
940 struct IAudioRender *render = nullptr;
941 struct AudioSampleAttributes attrs = {};
942 struct AudioDeviceDescriptor devDesc = {};
943 ASSERT_NE(nullptr, manager);
944 ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME, &adapter, audioPort);
945 ASSERT_EQ(HDF_SUCCESS, ret);
946
947 InitAttrs(attrs);
948 InitDevDesc(devDesc, audioPort.portId, PIN_OUT_SPEAKER);
949
950 devDesc.pins = PIN_NONE;
951 ret = adapter->CreateRender(adapter, &devDesc, &attrs, &render, &renderId_);
952 EXPECT_EQ(HDF_FAILURE, ret);
953
954 manager->UnloadAdapter(manager, ADAPTER_NAME.c_str());
955 IAudioAdapterRelease(adapter, IS_STUB);
956 free(devDesc.desc);
957 }
958
959 /**
960 * @tc.name AudioCreateRender_010
961 * @tc.desc test AudioCreateRender interface,Returns -1 if the incoming desc which portId is not configed
962 * @tc.type: FUNC
963 */
964 HWTEST_F(AudioIdlHdiAdapterTest, AudioCreateRender_010, TestSize.Level1)
965 {
966 int32_t ret;
967 struct IAudioAdapter *adapter = nullptr;
968 struct IAudioRender *render = nullptr;
969 struct AudioSampleAttributes attrs = {};
970 struct AudioDeviceDescriptor devDesc = {};
971 uint32_t portId = 10; // invalid portId
972 ASSERT_NE(nullptr, manager);
973 ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME, &adapter, audioPort);
974 ASSERT_EQ(HDF_SUCCESS, ret);
975
976 InitAttrs(attrs);
977 InitDevDesc(devDesc, portId, PIN_OUT_SPEAKER);
978
979 ret = adapter->CreateRender(adapter, &devDesc, &attrs, &render, &renderId_);
980 ASSERT_TRUE(ret == HDF_FAILURE || ret == HDF_SUCCESS);
981 manager->UnloadAdapter(manager, ADAPTER_NAME.c_str());
982 IAudioAdapterRelease(adapter, IS_STUB);
983 free(devDesc.desc);
984 }
985
986 /**
987 * @tc.name AudioDestroyCapture_001
988 * @tc.desc Test AudioDestroyCapture interface,Returns 0 if the IAudioCapture object is destroyed
989 * @tc.type: FUNC
990 */
991 HWTEST_F(AudioIdlHdiAdapterTest, AudioDestroyCapture_001, TestSize.Level1)
992 {
993 int32_t ret;
994 AudioPortPin pins = PIN_IN_MIC;
995 struct IAudioAdapter *adapter = nullptr;
996 struct IAudioCapture *capture = nullptr;
997 ASSERT_NE(nullptr, manager);
998 ret = AudioCreateCapture(manager, pins, ADAPTER_NAME, &adapter, &capture, &captureId_);
999 ASSERT_EQ(HDF_SUCCESS, ret);
1000 struct AudioDeviceDescriptor devDesc;
1001 InitDevDesc(devDesc, 0, PIN_IN_MIC);
1002 ret =adapter->DestroyCapture(adapter, captureId_);
1003 EXPECT_EQ(HDF_SUCCESS, ret);
1004 free(devDesc.desc);
1005 IAudioCaptureRelease(capture, IS_STUB);
1006 manager->UnloadAdapter(manager, ADAPTER_NAME.c_str());
1007 IAudioAdapterRelease(adapter, IS_STUB);
1008 }
1009
1010 /**
1011 * @tc.name AudioDestroyCaptureNull_002
1012 * @tc.desc Test AudioDestroyCapture interface,Returns -3/-4 if the incoming parameter adapter is nullptr
1013 * @tc.type: FUNC
1014 */
1015 HWTEST_F(AudioIdlHdiAdapterTest, AudioDestroyCaptureNull_002, TestSize.Level1)
1016 {
1017 int32_t ret;
1018 struct IAudioAdapter *adapter = nullptr;
1019 struct IAudioAdapter *adapterNull = nullptr;
1020 struct IAudioCapture *capture = nullptr;
1021 ASSERT_NE(nullptr, manager);
1022 ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME, &adapter, &capture, &captureId_);
1023 ASSERT_EQ(HDF_SUCCESS, ret);
1024 struct AudioDeviceDescriptor devDesc;
1025 InitDevDesc(devDesc, 0, PIN_IN_MIC);
1026 ret = adapter->DestroyCapture(adapterNull, captureId_);
1027 ASSERT_TRUE(ret == HDF_ERR_INVALID_PARAM || ret == HDF_ERR_INVALID_OBJECT);
1028 ret = adapter->DestroyCapture(adapter, captureId_);
1029 EXPECT_EQ(HDF_SUCCESS, ret);
1030 free(devDesc.desc);
1031 IAudioCaptureRelease(capture, IS_STUB);
1032 manager->UnloadAdapter(manager, ADAPTER_NAME.c_str());
1033 IAudioAdapterRelease(adapter, IS_STUB);
1034 }
1035
1036 /**
1037 * @tc.name AudioDestroyRender_001
1038 * @tc.desc Test AudioDestroyRender interface, return 0 if render is destroyed successful.
1039 * @tc.type: FUNC
1040 */
1041 HWTEST_F(AudioIdlHdiAdapterTest, AudioDestroyRender_001, TestSize.Level1)
1042 {
1043 int32_t ret;
1044 struct IAudioAdapter *adapter = nullptr;
1045 struct IAudioRender *render = nullptr;
1046 ASSERT_NE(nullptr, manager);
1047 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME, &adapter, &render, &renderId_);
1048 ASSERT_EQ(HDF_SUCCESS, ret);
1049 struct AudioDeviceDescriptor devDesc;
1050 InitDevDesc(devDesc, 0, PIN_OUT_SPEAKER);
1051 ret = adapter->DestroyRender(adapter, renderId_);
1052 EXPECT_EQ(HDF_SUCCESS, ret);
1053 IAudioRenderRelease(render, IS_STUB);
1054 free(devDesc.desc);
1055 manager->UnloadAdapter(manager, ADAPTER_NAME.c_str());
1056 IAudioAdapterRelease(adapter, IS_STUB);
1057 }
1058 /**
1059 * @tc.name AudioDestroyRenderNull_002
1060 * @tc.desc Test AudioDestroyRender interface, return -3/-4 if the parameter render is nullptr.
1061 * @tc.type: FUNC
1062 */
1063 HWTEST_F(AudioIdlHdiAdapterTest, AudioDestroyRenderNull_002, TestSize.Level1)
1064 {
1065 int32_t ret;
1066 struct IAudioAdapter *adapter = nullptr;
1067 struct IAudioRender *render = nullptr;
1068 struct IAudioAdapter *adapterNull = nullptr;
1069 ASSERT_NE(nullptr, manager);
1070 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME, &adapter, &render, &renderId_);
1071 ASSERT_EQ(HDF_SUCCESS, ret);
1072 struct AudioDeviceDescriptor devDesc;
1073 InitDevDesc(devDesc, 0, PIN_OUT_SPEAKER);
1074 ret = adapter->DestroyRender(adapterNull, renderId_);
1075 ASSERT_TRUE(ret == HDF_ERR_INVALID_PARAM || ret == HDF_ERR_INVALID_OBJECT);
1076 ret = adapter->DestroyRender(adapter, renderId_);
1077 EXPECT_EQ(HDF_SUCCESS, ret);
1078 free(devDesc.desc);
1079 IAudioRenderRelease(render, IS_STUB);
1080 manager->UnloadAdapter(manager, ADAPTER_NAME.c_str());
1081 IAudioAdapterRelease(adapter, IS_STUB);
1082 }
1083 }
1084