1 /*
2 * Copyright (c) 2021 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 "audio_lib_common.h"
17 #include "audio_smartpa_test.h"
18
19 using namespace std;
20 using namespace testing::ext;
21 using namespace OHOS::Audio;
22
23 namespace {
24 const string BIND_CONTROL = "control";
25 const string BIND_RENDER = "render";
26 const string BIND_NAME_ERROR = "rendeo";
27
28 class AudioSmartPaTest : public testing::Test {
29 public:
30 static void SetUpTestCase(void);
31 static void TearDownTestCase(void);
32 void SetUp();
33 void TearDown();
34 static struct DevHandle *(*BindServiceRender)(const char *);
35 static int32_t (*InterfaceLibOutputRender)(struct DevHandle *, int32_t, struct AudioHwRenderParam *);
36 static int32_t (*InterfaceLibCtlRender)(struct DevHandle *, int32_t, struct AudioHwRenderParam *);
37 static void (*CloseServiceRender)(struct DevHandle *);
38 static void *ptrHandle;
39 static TestAudioManager *manager;
40 int32_t BindServiceAndHwRender(struct AudioHwRender *&hwRender, const std::string BindName,
41 const std::string adapterNameCase, struct DevHandle *&handle) const;
42 };
43
44 TestAudioManager *AudioSmartPaTest::manager = nullptr;
45 struct DevHandle *(*AudioSmartPaTest::BindServiceRender)(const char *) = nullptr;
46 int32_t (*AudioSmartPaTest::InterfaceLibOutputRender)(struct DevHandle *, int, struct AudioHwRenderParam *) = nullptr;
47 int32_t (*AudioSmartPaTest::InterfaceLibCtlRender)(struct DevHandle *, int, struct AudioHwRenderParam *) = nullptr;
48 void (*AudioSmartPaTest::CloseServiceRender)(struct DevHandle *) = nullptr;
49 void *AudioSmartPaTest::ptrHandle = nullptr;
50 using THREAD_FUNC = void *(*)(void *);
51
SetUpTestCase(void)52 void AudioSmartPaTest::SetUpTestCase(void)
53 {
54 manager = GetAudioManagerFuncs();
55 ASSERT_NE(nullptr, manager);
56 string resolvedPathOne = HDF_LIBRARY_FULL_PATH("libhdi_audio_interface_lib_render");
57 ptrHandle = dlopen(resolvedPathOne.c_str(), RTLD_LAZY);
58 ASSERT_NE(nullptr, ptrHandle);
59 BindServiceRender = (struct DevHandle* (*)(const char *))dlsym(ptrHandle, "AudioBindServiceRender");
60 InterfaceLibOutputRender = (int32_t (*)(struct DevHandle *, int,
61 struct AudioHwRenderParam *))dlsym(ptrHandle, "AudioInterfaceLibOutputRender");
62 InterfaceLibCtlRender = (int32_t (*)(struct DevHandle *, int,
63 struct AudioHwRenderParam *))dlsym(ptrHandle, "AudioInterfaceLibCtlRender");
64 CloseServiceRender = reinterpret_cast<void (*)(struct DevHandle *)>(dlsym(ptrHandle, "AudioCloseServiceRender"));
65 if (BindServiceRender == nullptr || CloseServiceRender == nullptr ||
66 InterfaceLibCtlRender == nullptr || InterfaceLibOutputRender == nullptr) {
67 return;
68 }
69 }
70
TearDownTestCase(void)71 void AudioSmartPaTest::TearDownTestCase(void)
72 {
73 if (ptrHandle != nullptr) {
74 (void)dlclose(ptrHandle);
75 }
76 if (BindServiceRender != nullptr) {
77 BindServiceRender = nullptr;
78 }
79 if (CloseServiceRender != nullptr) {
80 CloseServiceRender = nullptr;
81 }
82 if (InterfaceLibOutputRender != nullptr) {
83 InterfaceLibOutputRender = nullptr;
84 }
85 if (InterfaceLibCtlRender != nullptr) {
86 InterfaceLibCtlRender = nullptr;
87 }
88 }
89
SetUp(void)90 void AudioSmartPaTest::SetUp(void) {}
91
TearDown(void)92 void AudioSmartPaTest::TearDown(void) {}
93
BindServiceAndHwRender(struct AudioHwRender * & hwRender,const std::string BindName,const std::string adapterNameCase,struct DevHandle * & handle) const94 int32_t AudioSmartPaTest::BindServiceAndHwRender(struct AudioHwRender *&hwRender,
95 const std::string BindName, const std::string adapterNameCase, struct DevHandle *&handle) const
96 {
97 handle = BindServiceRender(BindName.c_str());
98 if (handle == nullptr) {
99 return HDF_FAILURE;
100 }
101 hwRender = static_cast<struct AudioHwRender *>(calloc(1, sizeof(*hwRender)));
102 if (hwRender == nullptr) {
103 CloseServiceRender(handle);
104 return HDF_FAILURE;
105 }
106 if (InitHwRender(hwRender, adapterNameCase)) {
107 CloseServiceRender(handle);
108 free(hwRender);
109 hwRender = nullptr;
110 return HDF_FAILURE;
111 }
112 return HDF_SUCCESS;
113 }
114 /**
115 * @tc.name AudioFunctionSmartpaTest_001
116 * @tc.desc test Render interface by playing an audio file based smartPA successfully.
117 * @tc.type: FUNC
118 */
119 HWTEST_F(AudioSmartPaTest, AudioFunctionSmartpaTest_001, TestSize.Level1)
120 {
121 int32_t ret = -1;
122 ASSERT_NE(nullptr, manager);
123 struct PrepareAudioPara audiopara = {
124 .manager = manager, .portType = PORT_OUT, .adapterName = ADAPTER_NAME_OUT.c_str(), .pins = PIN_OUT_SPEAKER,
125 .path = AUDIO_FILE.c_str()
126 };
127 uint32_t latencyTime = 0;
128 uint32_t expectedValue = 0;
129
130 ret = pthread_create(&audiopara.tids, NULL, (THREAD_FUNC)PlayAudioFile, &audiopara);
131 ASSERT_EQ(HDF_SUCCESS, ret);
132 sleep(1);
133 if (audiopara.render != nullptr) {
134 ret = audiopara.render->GetLatency(audiopara.render, &latencyTime);
135 EXPECT_EQ(HDF_SUCCESS, ret);
136 EXPECT_LT(expectedValue, latencyTime);
137 FrameStatus(0);
138 usleep(1000);
139 ret = audiopara.render->control.Pause((AudioHandle)(audiopara.render));
140 EXPECT_EQ(HDF_SUCCESS, ret);
141 ret = audiopara.render->control.Flush((AudioHandle)audiopara.render);
142 EXPECT_EQ(HDF_ERR_NOT_SUPPORT, ret);
143 sleep(1);
144 ret = audiopara.render->control.Resume((AudioHandle)(audiopara.render));
145 EXPECT_EQ(HDF_SUCCESS, ret);
146 FrameStatus(1);
147 }
148 ret = ThreadRelease(audiopara);
149 EXPECT_EQ(HDF_SUCCESS, ret);
150 }
151 /**
152 * @tc.name AudioFunctionSmartpaTest_002
153 * @tc.desc test Render function,set volume when playing audio file based smartPA.
154 * @tc.type: FUNC
155 */
156 HWTEST_F(AudioSmartPaTest, AudioFunctionSmartpaTest_002, TestSize.Level1)
157 {
158 int32_t ret = -1;
159 float volumeMax = 1.0;
160 ASSERT_NE(nullptr, manager);
161 struct PrepareAudioPara audiopara = {
162 .manager = manager, .portType = PORT_OUT, .adapterName = ADAPTER_NAME_OUT.c_str(), .pins = PIN_OUT_SPEAKER,
163 .path = AUDIO_FILE.c_str()
164 };
165 float volumeValue[10] = {0};
166 float volumeArr[10] = {0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0};
167
168 ret = pthread_create(&audiopara.tids, NULL, (THREAD_FUNC)PlayAudioFile, &audiopara);
169 ASSERT_EQ(HDF_SUCCESS, ret);
170 sleep(1);
171 if (audiopara.render != nullptr) {
172 ret = audiopara.render->volume.SetVolume(audiopara.render, volumeMax);
173 for (int i = 0; i < 10; i++) {
174 ret = audiopara.render->volume.SetVolume(audiopara.render, volumeArr[i]);
175 EXPECT_EQ(HDF_SUCCESS, ret);
176 ret = audiopara.render->volume.GetVolume(audiopara.render, &volumeValue[i]);
177 EXPECT_EQ(HDF_SUCCESS, ret);
178 EXPECT_EQ(volumeArr[i], volumeValue[i]);
179 usleep(30000);
180 }
181 }
182 ret = ThreadRelease(audiopara);
183 EXPECT_EQ(HDF_SUCCESS, ret);
184 }
185 /**
186 * @tc.name AudioFunctionSmartpaTest_003
187 * @tc.desc test render function by SetMute and GetMute when playing audio file based smartPA.
188 * @tc.type: FUNC
189 */
190 HWTEST_F(AudioSmartPaTest, AudioFunctionSmartpaTest_003, TestSize.Level1)
191 {
192 int32_t ret = -1;
193 ASSERT_NE(nullptr, manager);
194 struct PrepareAudioPara audiopara = {
195 .manager = manager, .portType = PORT_OUT, .adapterName = ADAPTER_NAME_OUT.c_str(), .pins = PIN_OUT_SPEAKER,
196 .path = AUDIO_FILE.c_str()
197 };
198
199 ret = pthread_create(&audiopara.tids, NULL, (THREAD_FUNC)PlayAudioFile, &audiopara);
200 ASSERT_EQ(HDF_SUCCESS, ret);
201 sleep(1);
202 bool muteTrue = true;
203 bool muteFalse = false;
204 if (audiopara.render != nullptr) {
205 ret = audiopara.render->volume.SetMute(audiopara.render, muteTrue);
206 EXPECT_EQ(HDF_SUCCESS, ret);
207 ret = audiopara.render->volume.GetMute(audiopara.render, &muteTrue);
208 EXPECT_EQ(HDF_SUCCESS, ret);
209 EXPECT_EQ(true, muteTrue);
210 sleep(1);
211 ret = audiopara.render->volume.SetMute(audiopara.render, muteFalse);
212 EXPECT_EQ(HDF_SUCCESS, ret);
213 ret = audiopara.render->volume.GetMute(audiopara.render, &muteFalse);
214 EXPECT_EQ(HDF_SUCCESS, ret);
215 EXPECT_EQ(false, muteFalse);
216 }
217 ret = ThreadRelease(audiopara);
218 EXPECT_EQ(HDF_SUCCESS, ret);
219 }
220 /**
221 * @tc.name AudioFunctionSmartpaTest_004
222 * @tc.desc test render function by Get render position when playing audio file based smartPA.
223 * @tc.type: FUNC
224 */
225 HWTEST_F(AudioSmartPaTest, AudioFunctionSmartpaTest_004, TestSize.Level1)
226 {
227 int32_t ret = -1;
228 ASSERT_NE(nullptr, manager);
229 struct PrepareAudioPara audiopara = {
230 .manager = manager, .portType = PORT_OUT, .adapterName = ADAPTER_NAME_OUT.c_str(), .pins = PIN_OUT_SPEAKER,
231 .path = AUDIO_FILE.c_str()
232 };
233 uint64_t frames = 0;
234 int64_t timeExp = 0;
235 struct AudioTimeStamp time = {.tvSec = 0};
236
237 ret = pthread_create(&audiopara.tids, NULL, (THREAD_FUNC)PlayAudioFile, &audiopara);
238 ASSERT_EQ(HDF_SUCCESS, ret);
239 sleep(2);
240 if (audiopara.render != nullptr) {
241 ret = audiopara.render->GetRenderPosition(audiopara.render, &frames, &time);
242 EXPECT_EQ(HDF_SUCCESS, ret);
243 EXPECT_GT(time.tvSec, timeExp);
244 EXPECT_GT(frames, INITIAL_VALUE);
245 }
246 ret = ThreadRelease(audiopara);
247 EXPECT_EQ(HDF_SUCCESS, ret);
248 }
249 /**
250 * @tc.name AudioFunctionSmartpaTest_005
251 * @tc.desc test render function by Get frame count and size when playing audio file based smartPA.
252 * @tc.type: FUNC
253 */
254 HWTEST_F(AudioSmartPaTest, AudioFunctionSmartpaTest_005, TestSize.Level1)
255 {
256 int32_t ret = -1;
257 ASSERT_NE(nullptr, manager);
258 struct PrepareAudioPara audiopara = {
259 .manager = manager, .portType = PORT_OUT, .adapterName = ADAPTER_NAME_OUT.c_str(), .pins = PIN_OUT_SPEAKER,
260 .path = AUDIO_FILE.c_str()
261 };
262 uint64_t size = 0;
263 uint64_t count = 0;
264 uint64_t zero = 0;
265 uint64_t sizeExpect = 0;
266
267 ret = pthread_create(&audiopara.tids, NULL, (THREAD_FUNC)PlayAudioFile, &audiopara);
268 ASSERT_EQ(HDF_SUCCESS, ret);
269 sleep(1);
270 if (audiopara.render != nullptr) {
271 ret = audiopara.render->attr.GetFrameSize(audiopara.render, &size);
272 EXPECT_EQ(HDF_SUCCESS, ret);
273 sizeExpect = PcmFramesToBytes(audiopara.attrs);
274 EXPECT_EQ(size, sizeExpect);
275
276 ret = audiopara.render->attr.GetFrameCount(audiopara.render, &count);
277 EXPECT_EQ(HDF_SUCCESS, ret);
278 EXPECT_GT(count, zero);
279 }
280 ret = ThreadRelease(audiopara);
281 EXPECT_EQ(HDF_SUCCESS, ret);
282 }
283 /**
284 * @tc.name AudioFunctionSmartpaTest_006
285 * @tc.desc test render function by SetSampleAttributes when playing audio file based smartPA.
286 * @tc.type: FUNC
287 */
288 HWTEST_F(AudioSmartPaTest, AudioFunctionSmartpaTest_006, TestSize.Level1)
289 {
290 ASSERT_NE(nullptr, manager);
291 struct PrepareAudioPara audiopara = {
292 .manager = manager, .portType = PORT_OUT, .adapterName = ADAPTER_NAME_OUT.c_str(), .pins = PIN_OUT_SPEAKER,
293 .path = AUDIO_FILE.c_str()
294 };
295 int32_t ret = -1;
296 uint32_t samplerateValue = 48000;
297 uint32_t channelcountValue = 1;
298 struct AudioSampleAttributes attrsValue = {};
299
300 ret = pthread_create(&audiopara.tids, NULL, (THREAD_FUNC)PlayAudioFile, &audiopara);
301 ASSERT_EQ(HDF_SUCCESS, ret);
302
303 sleep(1);
304 if (audiopara.render != nullptr) {
305 audiopara.attrs.type = AUDIO_IN_MEDIA;
306 audiopara.attrs.format = AUDIO_FORMAT_PCM_16_BIT;
307 audiopara.attrs.period = DEEP_BUFFER_RENDER_PERIOD_SIZE;
308 audiopara.attrs.sampleRate = 48000;
309 audiopara.attrs.channelCount = 1;
310 audiopara.attrs.stopThreshold = INT_32_MAX;
311
312 ret = audiopara.render->attr.SetSampleAttributes(audiopara.render, &(audiopara.attrs));
313 EXPECT_EQ(HDF_SUCCESS, ret);
314 ret = audiopara.render->attr.GetSampleAttributes(audiopara.render, &attrsValue);
315 EXPECT_EQ(HDF_SUCCESS, ret);
316
317 EXPECT_EQ(AUDIO_IN_MEDIA, attrsValue.type);
318 EXPECT_EQ(AUDIO_FORMAT_PCM_16_BIT, attrsValue.format);
319 EXPECT_EQ(samplerateValue, attrsValue.sampleRate);
320 EXPECT_EQ(channelcountValue, attrsValue.channelCount);
321 EXPECT_EQ(INT_32_MAX, attrsValue.stopThreshold);
322 }
323 ret = ThreadRelease(audiopara);
324 EXPECT_EQ(HDF_SUCCESS, ret);
325 }
326 /**
327 * this value.
328 * @tc.name AudioFunctionSmartpaTest_009
329 * @tc.desc test InterfaceLibCtlRender ,cmdId is AUDIODRV_CTL_IOCTL_ELEM_WRITE and AUDIODRV_CTL_IOCTL_ELEM_READ.
330 * @tc.type: FUNC
331 */
332 HWTEST_F(AudioSmartPaTest, AudioFunctionSmartpaTest_009, TestSize.Level1)
333 {
334 int32_t ret = -1;
335 float volumevalue = 0;
336 float thresholdValueMaxOut = 0;
337 float thresholdValueMinOut = 0;
338 float volumeBoundaryValueOut = 127.9;
339 struct DevHandle *handle = nullptr;
340 struct AudioHwRender *hwRender = nullptr;
341 ret = BindServiceAndHwRender(hwRender, BIND_CONTROL.c_str(), ADAPTER_NAME_OUT, handle);
342 ASSERT_EQ(HDF_SUCCESS, ret);
343 ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_VOL_THRESHOLD_READ, &hwRender->renderParam);
344 EXPECT_EQ(HDF_SUCCESS, ret);
345 thresholdValueMaxOut = hwRender->renderParam.renderMode.ctlParam.volThreshold.volMax;
346 thresholdValueMinOut = hwRender->renderParam.renderMode.ctlParam.volThreshold.volMin;
347
348 hwRender->renderParam.renderMode.ctlParam.volume = thresholdValueMinOut + 1;
349 ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_ELEM_WRITE, &hwRender->renderParam);
350 EXPECT_EQ(HDF_SUCCESS, ret);
351 ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_ELEM_READ, &hwRender->renderParam);
352 EXPECT_EQ(HDF_SUCCESS, ret);
353 volumevalue = hwRender->renderParam.renderMode.ctlParam.volume;
354 EXPECT_EQ(41, volumevalue);
355
356 hwRender->renderParam.renderMode.ctlParam.volume = thresholdValueMaxOut - 1;
357 ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_ELEM_WRITE, &hwRender->renderParam);
358 EXPECT_EQ(HDF_SUCCESS, ret);
359 ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_ELEM_READ, &hwRender->renderParam);
360 EXPECT_EQ(HDF_SUCCESS, ret);
361 volumevalue = hwRender->renderParam.renderMode.ctlParam.volume;
362 EXPECT_EQ(126, volumevalue);
363
364 hwRender->renderParam.renderMode.ctlParam.volume = volumeBoundaryValueOut;
365 ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_ELEM_WRITE, &hwRender->renderParam);
366 EXPECT_EQ(HDF_SUCCESS, ret);
367 ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_ELEM_READ, &hwRender->renderParam);
368 EXPECT_EQ(HDF_SUCCESS, ret);
369 volumevalue = hwRender->renderParam.renderMode.ctlParam.volume;
370 EXPECT_EQ(127, volumevalue);
371
372 CloseServiceRender(handle);
373 free(hwRender);
374 }
375 /**
376 * this value.
377 * @tc.name AudioFunctionSmartpaTest_010
378 * @tc.desc test InterfaceLibCtlRender ,cmdId is AUDIODRV_CTL_IOCTL_ELEM_WRITE and AUDIODRV_CTL_IOCTL_ELEM_READ.
379 * @tc.type: FUNC
380 */
381 HWTEST_F(AudioSmartPaTest, AudioFunctionSmartpaTest_010, TestSize.Level1)
382 {
383 int32_t ret = -1;
384 float thresholdValueMin = 0;
385 float thresholdValueMax = 0;
386 float volumevalue = 0;
387 struct DevHandle *handle = nullptr;
388 struct AudioHwRender *hwRender = nullptr;
389 ret = BindServiceAndHwRender(hwRender, BIND_CONTROL.c_str(), ADAPTER_NAME_OUT, handle);
390 ASSERT_EQ(HDF_SUCCESS, ret);
391 ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_VOL_THRESHOLD_READ, &hwRender->renderParam);
392 EXPECT_EQ(HDF_SUCCESS, ret);
393 thresholdValueMax = hwRender->renderParam.renderMode.ctlParam.volThreshold.volMax;
394 thresholdValueMin = hwRender->renderParam.renderMode.ctlParam.volThreshold.volMin;
395 hwRender->renderParam.renderMode.ctlParam.volume = thresholdValueMin;
396 ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_ELEM_WRITE, &hwRender->renderParam);
397 EXPECT_EQ(HDF_SUCCESS, ret);
398 ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_ELEM_READ, &hwRender->renderParam);
399 EXPECT_EQ(HDF_SUCCESS, ret);
400 volumevalue = hwRender->renderParam.renderMode.ctlParam.volume;
401 EXPECT_EQ(40, volumevalue);
402
403 hwRender->renderParam.renderMode.ctlParam.volume = thresholdValueMax;
404 ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_ELEM_WRITE, &hwRender->renderParam);
405 EXPECT_EQ(HDF_SUCCESS, ret);
406 ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_ELEM_READ, &hwRender->renderParam);
407 EXPECT_EQ(HDF_SUCCESS, ret);
408 volumevalue = hwRender->renderParam.renderMode.ctlParam.volume;
409 EXPECT_EQ(127, volumevalue);
410
411 CloseServiceRender(handle);
412 free(hwRender);
413 }
414 /**
415 * @tc.name AudioFunctionSmartpaTest_011
416 * @tc.desc test InterfaceLibCtlRender ,cmdId is AUDIODRV_CTL_IOCTL_ELEM_WRITE and AUDIODRV_CTL_IOCTL_ELEM_READ.
417 * @tc.type: FUNC
418 */
419 HWTEST_F(AudioSmartPaTest, AudioFunctionSmartpaTest_011, TestSize.Level1)
420 {
421 int32_t ret = -1;
422 float volumeThresholdValueMax = 0;
423 float volumeThresholdValueMin = 0;
424 struct DevHandle *handle = nullptr;
425 struct AudioHwRender *hwRender = nullptr;
426 ret = BindServiceAndHwRender(hwRender, BIND_CONTROL.c_str(), ADAPTER_NAME_OUT, handle);
427 ASSERT_EQ(HDF_SUCCESS, ret);
428
429 ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_VOL_THRESHOLD_READ, &hwRender->renderParam);
430 EXPECT_EQ(HDF_SUCCESS, ret);
431 volumeThresholdValueMax = hwRender->renderParam.renderMode.ctlParam.volThreshold.volMax;
432 volumeThresholdValueMin = hwRender->renderParam.renderMode.ctlParam.volThreshold.volMin;
433
434 hwRender->renderParam.renderMode.ctlParam.volume = volumeThresholdValueMax + 1;
435 ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_ELEM_WRITE, &hwRender->renderParam);
436 EXPECT_EQ(HDF_FAILURE, ret);
437
438 hwRender->renderParam.renderMode.ctlParam.volume = volumeThresholdValueMin - 1;
439 ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_ELEM_WRITE, &hwRender->renderParam);
440 EXPECT_EQ(HDF_FAILURE, ret);
441
442 CloseServiceRender(handle);
443 free(hwRender);
444 }
445 /**
446 * @tc.name AudioFunctionSmartpaTest_012
447 * @tc.desc Test AudioAdapterInitAllPorts interface, return 0 if the ports are initialized successfully.
448 * @tc.type: FUNC
449 */
450 HWTEST_F(AudioSmartPaTest, AudioFunctionSmartpaTest_012, TestSize.Level1)
451 {
452 int32_t ret = -1;
453 ASSERT_NE(nullptr, manager);
454 struct PrepareAudioPara audiopara = {
455 .manager = manager, .portType = PORT_OUT, .adapterName = ADAPTER_NAME_OUT.c_str()
456 };
457 ret = OHOS::Audio::GetLoadAdapter(audiopara.manager, audiopara.portType, audiopara.adapterName,
458 &audiopara.adapter, audiopara.audioPort);
459 ASSERT_EQ(HDF_SUCCESS, ret);
460 ret = audiopara.adapter->InitAllPorts(audiopara.adapter);
461 EXPECT_EQ(HDF_SUCCESS, ret);
462 audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter);
463 }
464 }
465