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 InitDevDesc(devDesc, audioPort.portId, PIN_IN_MIC);
535 ret = adapter->CreateCapture(adapter, &devDesc, &attrs, &firstCapture, &captureId_);
536 EXPECT_EQ(HDF_SUCCESS, ret);
537 adapter->DestroyCapture(adapter, captureId_);
538 IAudioCaptureRelease(firstCapture, IS_STUB);
539 manager->UnloadAdapter(manager, ADAPTER_NAME.c_str());
540 IAudioAdapterRelease(adapter, IS_STUB);
541 free(devDesc.desc);
542 }
543
544 /**
545 * @tc.name AudioCreateCapture_003
546 * @tc.desc test AudioCreateCapture interface,Returns 0 if the IAudioCapture object can be created successfully
547 when IAudioRender was created
548 * @tc.type: FUNC
549 */
550 HWTEST_F(AudioIdlHdiAdapterTest, AudioCreateCapture_003, TestSize.Level1)
551 {
552 int32_t ret;
553 struct IAudioAdapter *adapter = nullptr;
554 struct IAudioRender *render = nullptr;
555 struct IAudioCapture *capture = nullptr;
556 struct AudioSampleAttributes attrs = {};
557 struct AudioDeviceDescriptor renderDevDesc = {};
558 struct AudioDeviceDescriptor captureDevDesc = {};
559 ASSERT_NE(nullptr, manager);
560
561 ret = GetLoadAdapter(manager, PORT_IN, ADAPTER_NAME, &adapter, audioPort);
562 ASSERT_EQ(HDF_SUCCESS, ret);
563 InitAttrs(attrs);
564 InitDevDesc(renderDevDesc, audioPort.portId, PIN_OUT_SPEAKER);
565 InitDevDesc(captureDevDesc, audioPort.portId, PIN_IN_MIC);
566 ret = adapter->CreateRender(adapter, &renderDevDesc, &attrs, &render, &renderId_);
567 EXPECT_EQ(HDF_SUCCESS, ret);
568
569 ret = adapter->CreateCapture(adapter, &captureDevDesc, &attrs, &capture, &captureId_);
570 EXPECT_EQ(HDF_SUCCESS, ret);
571 adapter->DestroyCapture(adapter, captureId_);
572 IAudioCaptureRelease(capture, IS_STUB);
573 adapter->DestroyRender(adapter, renderId_);
574 IAudioRenderRelease(render, IS_STUB);
575 manager->UnloadAdapter(manager, ADAPTER_NAME.c_str());
576 IAudioAdapterRelease(adapter, IS_STUB);
577 free(renderDevDesc.desc);
578 free(captureDevDesc.desc);
579 }
580
581 /**
582 * @tc.name AudioCreateCaptureNull_005
583 * @tc.desc Test AudioCreateCapture interface,Returns -3/-4 if the incoming parameter adapter is nullptr
584 * @tc.type: FUNC
585 */
586 HWTEST_F(AudioIdlHdiAdapterTest, AudioCreateCaptureNull_005, TestSize.Level1)
587 {
588 int32_t ret;
589 struct AudioDeviceDescriptor devDesc = {};
590 struct AudioSampleAttributes attrs = {};
591 struct IAudioAdapter *adapter = nullptr;
592 struct IAudioAdapter *adapterNull = nullptr;
593 struct IAudioCapture *capture = nullptr;
594 ASSERT_NE(nullptr, manager);
595 ret = GetLoadAdapter(manager, PORT_IN, ADAPTER_NAME, &adapter, audioPort);
596 ASSERT_EQ(HDF_SUCCESS, ret);
597 InitAttrs(attrs);
598 ret = InitDevDesc(devDesc, audioPort.portId, PIN_IN_MIC);
599 EXPECT_EQ(HDF_SUCCESS, ret);
600 ret = adapter->CreateCapture(adapterNull, &devDesc, &attrs, &capture, &captureId_);
601 ASSERT_TRUE(ret == HDF_ERR_INVALID_PARAM || ret == HDF_ERR_INVALID_OBJECT);
602 manager->UnloadAdapter(manager, ADAPTER_NAME.c_str());
603 IAudioAdapterRelease(adapter, IS_STUB);
604 free(devDesc.desc);
605 }
606
607 /**
608 * @tc.name AudioCreateCaptureNull_006
609 * @tc.desc Test AudioCreateCapture interface,Returns -3 if the incoming parameter desc is nullptr
610 * @tc.type: FUNC
611 */
612 HWTEST_F(AudioIdlHdiAdapterTest, AudioCreateCaptureNull_006, TestSize.Level1)
613 {
614 int32_t ret;
615 struct AudioSampleAttributes attrs = {};
616 struct AudioDeviceDescriptor *devDesc = nullptr;
617 struct IAudioAdapter *adapter = nullptr;
618 struct IAudioCapture *capture = nullptr;
619 ASSERT_NE(nullptr, manager);
620 ret = GetLoadAdapter(manager, PORT_IN, ADAPTER_NAME, &adapter, audioPort);
621 ASSERT_EQ(HDF_SUCCESS, ret);
622 InitAttrs(attrs);
623 ret = adapter->CreateCapture(adapter, devDesc, &attrs, &capture, &captureId_);
624 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret);
625 manager->UnloadAdapter(manager, ADAPTER_NAME.c_str());
626 IAudioAdapterRelease(adapter, IS_STUB);
627 }
628
629 /**
630 * @tc.name AudioCreateCaptureNull_007
631 * @tc.desc Test AudioCreateCapture interface,Returns -3 if the incoming parameter attrs is nullptr
632 * @tc.type: FUNC
633 */
634 HWTEST_F(AudioIdlHdiAdapterTest, AudioCreateCaptureNull_007, TestSize.Level1)
635 {
636 int32_t ret;
637 struct AudioDeviceDescriptor devDesc = {};
638 struct AudioSampleAttributes *attrs = nullptr;
639 struct IAudioAdapter *adapter = nullptr;
640 struct IAudioCapture *capture = nullptr;
641 ASSERT_NE(nullptr, manager);
642 ret = GetLoadAdapter(manager, PORT_IN, ADAPTER_NAME, &adapter, audioPort);
643 ASSERT_EQ(HDF_SUCCESS, ret);
644 ret = InitDevDesc(devDesc, audioPort.portId, PIN_IN_MIC);
645 EXPECT_EQ(HDF_SUCCESS, ret);
646 ret = adapter->CreateCapture(adapter, &devDesc, attrs, &capture, &captureId_);
647 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret);
648 manager->UnloadAdapter(manager, ADAPTER_NAME.c_str());
649 IAudioAdapterRelease(adapter, IS_STUB);
650 free(devDesc.desc);
651 }
652
653 #ifdef AUDIO_ADM_PASSTHROUGH
654 /**
655 * @tc.name AudioCreateCaptureNull_008
656 * @tc.desc Test AudioCreateCapture interface,Returns -3/-4 if the incoming parameter capture is nullptr
657 * @tc.type: FUNC
658 */
659 HWTEST_F(AudioIdlHdiAdapterTest, AudioCreateCaptureNull_008, TestSize.Level1)
660 {
661 int32_t ret;
662 struct AudioDeviceDescriptor devDesc = {};
663 struct AudioSampleAttributes attrs = {};
664 struct IAudioAdapter *adapter = nullptr;
665 struct IAudioCapture **capture = nullptr;
666 ASSERT_NE(nullptr, manager);
667 ret = GetLoadAdapter(manager, PORT_IN, ADAPTER_NAME, &adapter, audioPort);
668 ASSERT_EQ(HDF_SUCCESS, ret);
669 InitAttrs(attrs);
670 ret = InitDevDesc(devDesc, audioPort.portId, PIN_IN_MIC);
671 EXPECT_EQ(HDF_SUCCESS, ret);
672 ret = adapter->CreateCapture(adapter, &devDesc, &attrs, capture);
673 ASSERT_TRUE(ret == HDF_ERR_INVALID_PARAM || ret == HDF_ERR_INVALID_OBJECT);
674 manager->UnloadAdapter(manager, ADAPTER_NAME.c_str());
675 IAudioAdapterRelease(adapter, IS_STUB);
676 free(devDesc.desc);
677 }
678 #endif
679 /**
680 * @tc.name AudioCreateCapture_009
681 * @tc.desc Test AudioCreateCapture interface,Returns -1 if the incoming parameter adapter which devDesc'pin is
682 * PIN_OUT_SPEAKER
683 * @tc.type: FUNC
684 */
685 HWTEST_F(AudioIdlHdiAdapterTest, AudioCreateCapture_009, TestSize.Level1)
686 {
687 int32_t ret;
688 struct AudioDeviceDescriptor devDesc = {};
689 struct AudioSampleAttributes attrs = {};
690 struct IAudioAdapter *adapter = nullptr;
691 struct IAudioCapture *capture = nullptr;
692 ASSERT_NE(nullptr, manager);
693 ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME, &adapter, audioPort);
694 ASSERT_EQ(HDF_SUCCESS, ret);
695 InitAttrs(attrs);
696 ret = InitDevDesc(devDesc, audioPort.portId, PIN_OUT_SPEAKER);
697 EXPECT_EQ(HDF_SUCCESS, ret);
698 ret = adapter->CreateCapture(adapter, &devDesc, &attrs, &capture, &captureId_);
699 EXPECT_EQ(HDF_FAILURE, ret);
700 manager->UnloadAdapter(manager, ADAPTER_NAME.c_str());
701 IAudioAdapterRelease(adapter, IS_STUB);
702 free(devDesc.desc);
703 }
704
705 /**
706 * @tc.name AudioCreateCapture_010
707 * @tc.desc Test AudioCreateCapture interface,Returns -1 if the incoming parameter desc which portID is not configed
708 * @tc.type: FUNC
709 */
710 HWTEST_F(AudioIdlHdiAdapterTest, AudioCreateCapture_010, TestSize.Level1)
711 {
712 int32_t ret;
713 struct AudioDeviceDescriptor devDesc = {};
714 struct AudioSampleAttributes attrs = {};
715 uint32_t portId = 12; // invalid portid
716 struct IAudioAdapter *adapter = nullptr;
717 struct IAudioCapture *capture = nullptr;
718 ASSERT_NE(nullptr, manager);
719 ret = GetLoadAdapter(manager, PORT_IN, ADAPTER_NAME, &adapter, audioPort);
720 ASSERT_EQ(HDF_SUCCESS, ret);
721 InitAttrs(attrs);
722 ret = InitDevDesc(devDesc, portId, PIN_IN_MIC);
723 EXPECT_EQ(HDF_SUCCESS, ret);
724 ret = adapter->CreateCapture(adapter, &devDesc, &attrs, &capture, &captureId_);
725 ASSERT_TRUE(ret == HDF_FAILURE || ret == HDF_SUCCESS);
726 manager->UnloadAdapter(manager, ADAPTER_NAME.c_str());
727 IAudioAdapterRelease(adapter, IS_STUB);
728 free(devDesc.desc);
729 }
730 /**
731 * @tc.name AudioCreateRender_001
732 * @tc.desc test AudioCreateRender interface,return 0 if render is created successful.
733 * @tc.type: FUNC
734 */
735 HWTEST_F(AudioIdlHdiAdapterTest, AudioCreateRender_001, TestSize.Level1)
736 {
737 int32_t ret;
738 struct IAudioAdapter *adapter = nullptr;
739 struct IAudioRender *render = nullptr;
740 struct AudioSampleAttributes attrs = {};
741 struct AudioDeviceDescriptor renderDevDesc = {};
742 ASSERT_NE(nullptr, manager);
743 ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME, &adapter, audioPort);
744 ASSERT_EQ(HDF_SUCCESS, ret);
745 InitAttrs(attrs);
746 InitDevDesc(renderDevDesc, audioPort.portId, PIN_OUT_SPEAKER);
747 ret = adapter->CreateRender(adapter, &renderDevDesc, &attrs, &render, &renderId_);
748 EXPECT_EQ(HDF_SUCCESS, ret);
749 adapter->DestroyRender(adapter, renderId_);
750 IAudioRenderRelease(render, IS_STUB);
751 manager->UnloadAdapter(manager, ADAPTER_NAME.c_str());
752 IAudioAdapterRelease(adapter, IS_STUB);
753 free(renderDevDesc.desc);
754 }
755
756 /**
757 * @tc.name AudioCreateRender_003
758 * @tc.desc test AudioCreateRender interface,return -1 if the incoming parameter pins is PIN_IN_MIC.
759 * @tc.type: FUNC
760 */
761 HWTEST_F(AudioIdlHdiAdapterTest, AudioCreateRender_003, TestSize.Level1)
762 {
763 int32_t ret;
764 struct IAudioAdapter *adapter = nullptr;
765 struct IAudioRender *render = nullptr;
766 struct AudioSampleAttributes attrs = {};
767 struct AudioDeviceDescriptor devDesc = {};
768 ASSERT_NE(nullptr, manager);
769 ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME, &adapter, audioPort);
770 ASSERT_EQ(HDF_SUCCESS, ret);
771
772 InitAttrs(attrs);
773 InitDevDesc(devDesc, audioPort.portId, PIN_IN_MIC);
774
775 ret = adapter->CreateRender(adapter, &devDesc, &attrs, &render, &renderId_);
776 EXPECT_EQ(HDF_FAILURE, ret);
777
778 manager->UnloadAdapter(manager, ADAPTER_NAME.c_str());
779 IAudioAdapterRelease(adapter, IS_STUB);
780 free(devDesc.desc);
781 }
782
783 /**
784 * @tc.name AudioCreateRender_004
785 * @tc.desc test AudioCreateRender interface,return -1 if the incoming parameter attr is error.
786 * @tc.type: FUNC
787 */
788 HWTEST_F(AudioIdlHdiAdapterTest, AudioCreateRender_004, TestSize.Level1)
789 {
790 int32_t ret;
791 struct IAudioAdapter *adapter = nullptr;
792 struct IAudioRender *render = nullptr;
793 struct AudioSampleAttributes attrs = {};
794 struct AudioDeviceDescriptor devDesc = {};
795 uint32_t channelCountErr = 5; // invalid channelCount
796 ASSERT_NE(nullptr, manager);
797 ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME, &adapter, audioPort);
798 ASSERT_EQ(HDF_SUCCESS, ret);
799
800 InitAttrs(attrs);
801 InitDevDesc(devDesc, audioPort.portId, PIN_OUT_SPEAKER);
802 attrs.format = AUDIO_FORMAT_TYPE_AAC_MAIN;
803 ret = adapter->CreateRender(adapter, &devDesc, &attrs, &render, &renderId_);
804 ASSERT_TRUE(ret == HDF_FAILURE || ret == HDF_SUCCESS);
805 attrs.channelCount = channelCountErr;
806 ret = adapter->CreateRender(adapter, &devDesc, &attrs, &render, &renderId_);
807 EXPECT_EQ(HDF_FAILURE, ret);
808 attrs.type = AUDIO_IN_COMMUNICATION;
809 ret = adapter->CreateRender(adapter, &devDesc, &attrs, &render, &renderId_);
810 EXPECT_EQ(HDF_FAILURE, ret);
811
812 manager->UnloadAdapter(manager, ADAPTER_NAME.c_str());
813 IAudioAdapterRelease(adapter, IS_STUB);
814 free(devDesc.desc);
815 }
816
817 /**
818 * @tc.name AudioCreateRenderNull_005
819 * @tc.desc test AudioCreateRender interface,Returns -3/-4 if the incoming parameter adapter is nullptr.
820 * @tc.type: FUNC
821 */
822 HWTEST_F(AudioIdlHdiAdapterTest, AudioCreateRenderNull_005, TestSize.Level1)
823 {
824 int32_t ret;
825 struct IAudioAdapter *adapter = nullptr;
826 struct IAudioRender *render = nullptr;
827 struct IAudioAdapter *adapterNull = nullptr;
828 struct AudioSampleAttributes attrs = {};
829 struct AudioDeviceDescriptor devDesc = {};
830 ASSERT_NE(nullptr, manager);
831 ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME, &adapter, audioPort);
832 ASSERT_EQ(HDF_SUCCESS, ret);
833
834 InitAttrs(attrs);
835 InitDevDesc(devDesc, audioPort.portId, PIN_OUT_SPEAKER);
836
837 ret = adapter->CreateRender(adapterNull, &devDesc, &attrs, &render, &renderId_);
838 ASSERT_TRUE(ret == HDF_ERR_INVALID_PARAM || ret == HDF_ERR_INVALID_OBJECT);
839
840 manager->UnloadAdapter(manager, ADAPTER_NAME.c_str());
841 IAudioAdapterRelease(adapter, IS_STUB);
842 free(devDesc.desc);
843 }
844
845 /**
846 * @tc.name AudioCreateRenderNull_006
847 * @tc.desc test AudioCreateRender interface,Returns -3 if the incoming parameter devDesc is nullptr.
848 * @tc.type: FUNC
849 */
850 HWTEST_F(AudioIdlHdiAdapterTest, AudioCreateRenderNull_006, TestSize.Level1)
851 {
852 int32_t ret;
853 struct IAudioRender *render = nullptr;
854 struct IAudioAdapter *adapter = nullptr;
855 struct AudioSampleAttributes attrs = {};
856 struct AudioDeviceDescriptor *devDescNull = nullptr;
857 ASSERT_NE(nullptr, manager);
858 ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME, &adapter, audioPort);
859 ASSERT_EQ(HDF_SUCCESS, ret);
860
861 InitAttrs(attrs);
862
863 ret = adapter->CreateRender(adapter, devDescNull, &attrs, &render, &renderId_);
864 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret);
865
866 manager->UnloadAdapter(manager, ADAPTER_NAME.c_str());
867 IAudioAdapterRelease(adapter, IS_STUB);
868 }
869
870 /**
871 * @tc.name AudioCreateRenderNull_007
872 * @tc.desc test AudioCreateRender interface,Returns -3 if the incoming parameter attrs is nullptr.
873 * @tc.type: FUNC
874 */
875 HWTEST_F(AudioIdlHdiAdapterTest, AudioCreateRenderNull_007, TestSize.Level1)
876 {
877 int32_t ret;
878 struct IAudioAdapter *adapter = nullptr;
879 struct IAudioRender *render = nullptr;
880 struct AudioSampleAttributes *attrsNull = nullptr;
881 struct AudioDeviceDescriptor devDesc = {};
882 ASSERT_NE(nullptr, manager);
883 ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME, &adapter, audioPort);
884 ASSERT_EQ(HDF_SUCCESS, ret);
885
886 InitDevDesc(devDesc, audioPort.portId, PIN_OUT_SPEAKER);
887
888 ret = adapter->CreateRender(adapter, &devDesc, attrsNull, &render, &renderId_);
889 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret);
890
891 manager->UnloadAdapter(manager, ADAPTER_NAME.c_str());
892 IAudioAdapterRelease(adapter, IS_STUB);
893 free(devDesc.desc);
894 }
895
896 #ifdef AUDIO_ADM_PASSTHROUGH
897 /**
898 * @tc.name AudioCreateRenderNull_008
899 * @tc.desc test AudioCreateRender interface,Returns -3/-4 if the incoming parameter render is nullptr.
900 * @tc.type: FUNC
901 */
902 HWTEST_F(AudioIdlHdiAdapterTest, AudioCreateRenderNull_008, TestSize.Level1)
903 {
904 int32_t ret;
905 struct IAudioAdapter *adapter = nullptr;
906 struct IAudioRender **renderNull = nullptr;
907 struct AudioSampleAttributes attrs = {};
908 struct AudioDeviceDescriptor devDesc = {};
909 ASSERT_NE(nullptr, manager);
910 ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME, &adapter, audioPort);
911 ASSERT_EQ(HDF_SUCCESS, ret);
912
913 InitAttrs(attrs);
914 InitDevDesc(devDesc, audioPort.portId, PIN_OUT_SPEAKER);
915
916 ret = adapter->CreateRender(adapter, &devDesc, &attrs, renderNull, &renderId_);
917 ASSERT_TRUE(ret == HDF_ERR_INVALID_PARAM || ret == HDF_ERR_INVALID_OBJECT);
918
919 manager->UnloadAdapter(manager, ADAPTER_NAME.c_str());
920 IAudioAdapterRelease(adapter, IS_STUB);
921 free(devDesc.desc);
922 }
923 #endif
924
925 /**
926 * @tc.name AudioCreateRender_009
927 * @tc.desc test AudioCreateRender interface,Returns -1 if the incoming parameter pins of devDesc is error.
928 * @tc.type: FUNC
929 */
930 HWTEST_F(AudioIdlHdiAdapterTest, AudioCreateRender_009, TestSize.Level1)
931 {
932 int32_t ret;
933 struct IAudioAdapter *adapter = nullptr;
934 struct IAudioRender *render = nullptr;
935 struct AudioSampleAttributes attrs = {};
936 struct AudioDeviceDescriptor devDesc = {};
937 ASSERT_NE(nullptr, manager);
938 ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME, &adapter, audioPort);
939 ASSERT_EQ(HDF_SUCCESS, ret);
940
941 InitAttrs(attrs);
942 InitDevDesc(devDesc, audioPort.portId, PIN_OUT_SPEAKER);
943
944 devDesc.pins = PIN_NONE;
945 ret = adapter->CreateRender(adapter, &devDesc, &attrs, &render, &renderId_);
946 EXPECT_EQ(HDF_FAILURE, ret);
947
948 manager->UnloadAdapter(manager, ADAPTER_NAME.c_str());
949 IAudioAdapterRelease(adapter, IS_STUB);
950 free(devDesc.desc);
951 }
952
953 /**
954 * @tc.name AudioCreateRender_010
955 * @tc.desc test AudioCreateRender interface,Returns -1 if the incoming desc which portId is not configed
956 * @tc.type: FUNC
957 */
958 HWTEST_F(AudioIdlHdiAdapterTest, AudioCreateRender_010, TestSize.Level1)
959 {
960 int32_t ret;
961 struct IAudioAdapter *adapter = nullptr;
962 struct IAudioRender *render = nullptr;
963 struct AudioSampleAttributes attrs = {};
964 struct AudioDeviceDescriptor devDesc = {};
965 uint32_t portId = 10; // invalid portId
966 ASSERT_NE(nullptr, manager);
967 ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME, &adapter, audioPort);
968 ASSERT_EQ(HDF_SUCCESS, ret);
969
970 InitAttrs(attrs);
971 InitDevDesc(devDesc, portId, PIN_OUT_SPEAKER);
972
973 ret = adapter->CreateRender(adapter, &devDesc, &attrs, &render, &renderId_);
974 ASSERT_TRUE(ret == HDF_FAILURE || ret == HDF_SUCCESS);
975 manager->UnloadAdapter(manager, ADAPTER_NAME.c_str());
976 IAudioAdapterRelease(adapter, IS_STUB);
977 free(devDesc.desc);
978 }
979
980 /**
981 * @tc.name AudioDestroyCapture_001
982 * @tc.desc Test AudioDestroyCapture interface,Returns 0 if the IAudioCapture object is destroyed
983 * @tc.type: FUNC
984 */
985 HWTEST_F(AudioIdlHdiAdapterTest, AudioDestroyCapture_001, TestSize.Level1)
986 {
987 int32_t ret;
988 AudioPortPin pins = PIN_IN_MIC;
989 struct IAudioAdapter *adapter = nullptr;
990 struct IAudioCapture *capture = nullptr;
991 ASSERT_NE(nullptr, manager);
992 ret = AudioCreateCapture(manager, pins, ADAPTER_NAME, &adapter, &capture, &captureId_);
993 ASSERT_EQ(HDF_SUCCESS, ret);
994 struct AudioDeviceDescriptor devDesc;
995 InitDevDesc(devDesc, 0, PIN_IN_MIC);
996 ret =adapter->DestroyCapture(adapter, captureId_);
997 EXPECT_EQ(HDF_SUCCESS, ret);
998 free(devDesc.desc);
999 IAudioCaptureRelease(capture, IS_STUB);
1000 manager->UnloadAdapter(manager, ADAPTER_NAME.c_str());
1001 IAudioAdapterRelease(adapter, IS_STUB);
1002 }
1003
1004 /**
1005 * @tc.name AudioDestroyCaptureNull_002
1006 * @tc.desc Test AudioDestroyCapture interface,Returns -3/-4 if the incoming parameter adapter is nullptr
1007 * @tc.type: FUNC
1008 */
1009 HWTEST_F(AudioIdlHdiAdapterTest, AudioDestroyCaptureNull_002, TestSize.Level1)
1010 {
1011 int32_t ret;
1012 struct IAudioAdapter *adapter = nullptr;
1013 struct IAudioAdapter *adapterNull = nullptr;
1014 struct IAudioCapture *capture = nullptr;
1015 ASSERT_NE(nullptr, manager);
1016 ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME, &adapter, &capture, &captureId_);
1017 ASSERT_EQ(HDF_SUCCESS, ret);
1018 struct AudioDeviceDescriptor devDesc;
1019 InitDevDesc(devDesc, 0, PIN_IN_MIC);
1020 ret = adapter->DestroyCapture(adapterNull, captureId_);
1021 ASSERT_TRUE(ret == HDF_ERR_INVALID_PARAM || ret == HDF_ERR_INVALID_OBJECT);
1022 ret = adapter->DestroyCapture(adapter, captureId_);
1023 EXPECT_EQ(HDF_SUCCESS, ret);
1024 free(devDesc.desc);
1025 IAudioCaptureRelease(capture, IS_STUB);
1026 manager->UnloadAdapter(manager, ADAPTER_NAME.c_str());
1027 IAudioAdapterRelease(adapter, IS_STUB);
1028 }
1029
1030 /**
1031 * @tc.name AudioDestroyRender_001
1032 * @tc.desc Test AudioDestroyRender interface, return 0 if render is destroyed successful.
1033 * @tc.type: FUNC
1034 */
1035 HWTEST_F(AudioIdlHdiAdapterTest, AudioDestroyRender_001, TestSize.Level1)
1036 {
1037 int32_t ret;
1038 struct IAudioAdapter *adapter = nullptr;
1039 struct IAudioRender *render = nullptr;
1040 ASSERT_NE(nullptr, manager);
1041 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME, &adapter, &render, &renderId_);
1042 ASSERT_EQ(HDF_SUCCESS, ret);
1043 struct AudioDeviceDescriptor devDesc;
1044 InitDevDesc(devDesc, 0, PIN_OUT_SPEAKER);
1045 ret = adapter->DestroyRender(adapter, renderId_);
1046 EXPECT_EQ(HDF_SUCCESS, ret);
1047 IAudioRenderRelease(render, IS_STUB);
1048 free(devDesc.desc);
1049 manager->UnloadAdapter(manager, ADAPTER_NAME.c_str());
1050 IAudioAdapterRelease(adapter, IS_STUB);
1051 }
1052 /**
1053 * @tc.name AudioDestroyRenderNull_002
1054 * @tc.desc Test AudioDestroyRender interface, return -3/-4 if the parameter render is nullptr.
1055 * @tc.type: FUNC
1056 */
1057 HWTEST_F(AudioIdlHdiAdapterTest, AudioDestroyRenderNull_002, TestSize.Level1)
1058 {
1059 int32_t ret;
1060 struct IAudioAdapter *adapter = nullptr;
1061 struct IAudioRender *render = nullptr;
1062 struct IAudioAdapter *adapterNull = nullptr;
1063 ASSERT_NE(nullptr, manager);
1064 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME, &adapter, &render, &renderId_);
1065 ASSERT_EQ(HDF_SUCCESS, ret);
1066 struct AudioDeviceDescriptor devDesc;
1067 InitDevDesc(devDesc, 0, PIN_OUT_SPEAKER);
1068 ret = adapter->DestroyRender(adapterNull, renderId_);
1069 ASSERT_TRUE(ret == HDF_ERR_INVALID_PARAM || ret == HDF_ERR_INVALID_OBJECT);
1070 ret = adapter->DestroyRender(adapter, renderId_);
1071 EXPECT_EQ(HDF_SUCCESS, ret);
1072 free(devDesc.desc);
1073 IAudioRenderRelease(render, IS_STUB);
1074 manager->UnloadAdapter(manager, ADAPTER_NAME.c_str());
1075 IAudioAdapterRelease(adapter, IS_STUB);
1076 }
1077 }
1078