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 /**
17 * @addtogroup Audio
18 * @{
19 *
20 * @brief Test audio recording interface delayTime.
21 *
22 * @since 1.0
23 * @version 1.0
24 */
25
26 /**
27 * @file audio_hdi_common.h
28 *
29 * @brief Declares APIs for operations related to the audio delayTime.
30 *
31 * @since 1.0
32 * @version 1.0
33 */
34
35 #include "audio_hdi_common.h"
36 #include "audio_hdicapture_performace_test.h"
37
38 using namespace std;
39 using namespace testing::ext;
40 using namespace HMOS::Audio;
41
42 namespace {
43 const string ADAPTER_NAME_USB = "usb";
44 const float COUNT = 1000;
45 const long LOWLATENCY = 10000;
46 const long NORMALLATENCY = 30000;
47 const long HIGHLATENCY = 60000;
48 const int BUFFER = 1024 * 4;
49
50 class AudioHdiCapturePerformaceTest : public testing::Test {
51 public:
52 static void SetUpTestCase(void);
53 static void TearDownTestCase(void);
54 void SetUp();
55 void TearDown();
56 static TestAudioManager *(*GetAudioManager)();
57 static void *handleSo;
58 #ifdef AUDIO_MPI_SO
59 static int32_t (*SdkInit)();
60 static void (*SdkExit)();
61 static void *sdkSo;
62 #endif
63 };
64
65 TestAudioManager *(*AudioHdiCapturePerformaceTest::GetAudioManager)() = nullptr;
66 void *AudioHdiCapturePerformaceTest::handleSo = nullptr;
67 #ifdef AUDIO_MPI_SO
68 int32_t (*AudioHdiCapturePerformaceTest::SdkInit)() = nullptr;
69 void (*AudioHdiCapturePerformaceTest::SdkExit)() = nullptr;
70 void *AudioHdiCapturePerformaceTest::sdkSo = nullptr;
71 #endif
72
SetUpTestCase(void)73 void AudioHdiCapturePerformaceTest::SetUpTestCase(void)
74 {
75 #ifdef AUDIO_MPI_SO
76 char sdkResolvedPath[] = HDF_LIBRARY_FULL_PATH("libhdi_audio_interface_lib_render");
77 sdkSo = dlopen(sdkResolvedPath, RTLD_LAZY);
78 if (sdkSo == nullptr) {
79 return;
80 }
81 SdkInit = (int32_t (*)())(dlsym(sdkSo, "MpiSdkInit"));
82 if (SdkInit == nullptr) {
83 return;
84 }
85 SdkExit = (void (*)())(dlsym(sdkSo, "MpiSdkExit"));
86 if (SdkExit == nullptr) {
87 return;
88 }
89 SdkInit();
90 #endif
91 char absPath[PATH_MAX] = {0};
92 if (realpath(RESOLVED_PATH.c_str(), absPath) == nullptr) {
93 return;
94 }
95 handleSo = dlopen(absPath, RTLD_LAZY);
96 if (handleSo == nullptr) {
97 return;
98 }
99 GetAudioManager = (TestAudioManager *(*)())(dlsym(handleSo, FUNCTION_NAME.c_str()));
100 if (GetAudioManager == nullptr) {
101 return;
102 }
103 }
104
TearDownTestCase(void)105 void AudioHdiCapturePerformaceTest::TearDownTestCase(void)
106 {
107 #ifdef AUDIO_MPI_SO
108 if (SdkExit != nullptr) {
109 SdkExit();
110 }
111 if (sdkSo != nullptr) {
112 dlclose(sdkSo);
113 sdkSo = nullptr;
114 }
115 if (SdkInit != nullptr) {
116 SdkInit = nullptr;
117 }
118 if (SdkExit != nullptr) {
119 SdkExit = nullptr;
120 }
121 #endif
122 if (handleSo != nullptr) {
123 dlclose(handleSo);
124 handleSo = nullptr;
125 }
126 if (GetAudioManager != nullptr) {
127 GetAudioManager = nullptr;
128 }
129 }
130
SetUp(void)131 void AudioHdiCapturePerformaceTest::SetUp(void) {}
132
TearDown(void)133 void AudioHdiCapturePerformaceTest::TearDown(void) {}
134
135 /**
136 * @tc.name the performace of AudioCreateCapture
137 * @tc.number SUB_Audio_HDI_AudioCreateCapture_Performance_0001
138 * @tc.devDesc tests the performace of AudioCreateCapture interface by executing 1000 times,
139 * and calculates the delay time and average of Delay Time.
140 * @tc.author: liutian
141 */
142 HWTEST_F(AudioHdiCapturePerformaceTest, SUB_Audio_HDI_AudioCreateCapture_Performance_0001, TestSize.Level1)
143 {
144 int32_t ret = -1;
145 struct PrepareAudioPara audiopara = {
146 .portType = PORT_IN, .adapterName = ADAPTER_NAME_USB.c_str(), .pins = PIN_IN_MIC, .totalTime = 0
147 };
148 ASSERT_NE(nullptr, GetAudioManager);
149 audiopara.manager = GetAudioManager();
150 ASSERT_NE(nullptr, audiopara.manager);
151 ret = GetLoadAdapter(audiopara.manager, audiopara.portType, audiopara.adapterName,
152 &audiopara.adapter, audiopara.audioPort);
153 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
154 InitAttrs(audiopara.attrs);
155 InitDevDesc(audiopara.devDesc, audiopara.audioPort->portId, audiopara.pins);
156 for (int i = 0; i < COUNT; ++i) {
157 gettimeofday(&audiopara.start, NULL);
158 ret = audiopara.adapter->CreateCapture(audiopara.adapter, &audiopara.devDesc, &audiopara.attrs,
159 &audiopara.capture);
160 gettimeofday(&audiopara.end, NULL);
161 if (ret < 0 || audiopara.capture == nullptr) {
162 audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter);
163 audiopara.adapter = nullptr;
164 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
165 }
166 audiopara.delayTime = (audiopara.end.tv_sec * MICROSECOND + audiopara.end.tv_usec) -
167 (audiopara.start.tv_sec * MICROSECOND + audiopara.start.tv_usec);
168 audiopara.totalTime += audiopara.delayTime;
169 ret = audiopara.adapter->DestroyCapture(audiopara.adapter, audiopara.capture);
170 audiopara.capture = nullptr;
171 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
172 }
173 audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT;
174 EXPECT_GT(HIGHLATENCY, audiopara.averageDelayTime);
175 audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter);
176 audiopara.adapter = nullptr;
177 }
178
179 /**
180 * @tc.name the performace of AudioDestroyCapture
181 * @tc.number SUB_Audio_HDI_AudioDestroyCapture_Performance_0001
182 * @tc.devDesc tests the performace of AudioDestroyCapture interface by executing 1000 times,
183 * and calculates the delay time and average of Delay Time.
184 * @tc.author: liutian
185 */
186 HWTEST_F(AudioHdiCapturePerformaceTest, SUB_Audio_HDI_AudioDestroyCapture_Performance_0001, TestSize.Level1)
187 {
188 int32_t ret = -1;
189 struct PrepareAudioPara audiopara = {
190 .portType = PORT_IN, .adapterName = ADAPTER_NAME_USB.c_str(), .pins = PIN_IN_MIC, .totalTime = 0
191 };
192 ASSERT_NE(nullptr, GetAudioManager);
193 audiopara.manager = GetAudioManager();
194 ASSERT_NE(nullptr, audiopara.manager);
195 for (int i = 0; i < COUNT; ++i) {
196 ret = AudioCreateCapture(audiopara.manager, audiopara.pins, audiopara.adapterName, &audiopara.adapter,
197 &audiopara.capture);
198 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
199 gettimeofday(&audiopara.start, NULL);
200 ret = audiopara.adapter->DestroyCapture(audiopara.adapter, audiopara.capture);
201 gettimeofday(&audiopara.end, NULL);
202 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
203 audiopara.capture = nullptr;
204 audiopara.delayTime = (audiopara.end.tv_sec * MICROSECOND + audiopara.end.tv_usec) -
205 (audiopara.start.tv_sec * MICROSECOND + audiopara.start.tv_usec);
206 audiopara.totalTime += audiopara.delayTime;
207 audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter);
208 audiopara.adapter = nullptr;
209 }
210 audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT;
211 EXPECT_GT(LOWLATENCY, audiopara.averageDelayTime);
212 }
213
214 /**
215 * @tc.name the performace of AudioCaptureStart
216 * @tc.number SUB_Audio_HDI_AudioCaptureStart_Performance_0001
217 * @tc.devDesc tests the performace of AudioCaptureStart interface by executing 1000 times,
218 * and calculates the delay time and average of Delay Time.
219 * @tc.author: liutian
220 */
221 HWTEST_F(AudioHdiCapturePerformaceTest, SUB_Audio_HDI_AudioCaptureStart_Performance_0001, TestSize.Level1)
222 {
223 int32_t ret = -1;
224 struct PrepareAudioPara audiopara = {
225 .portType = PORT_IN, .adapterName = ADAPTER_NAME_USB.c_str(), .pins = PIN_IN_MIC, .totalTime = 0
226 };
227 ASSERT_NE(nullptr, GetAudioManager);
228 audiopara.manager = GetAudioManager();
229 ASSERT_NE(nullptr, audiopara.manager);
230 for (int i = 0; i < COUNT; ++i) {
231 ret = AudioCreateCapture(audiopara.manager, audiopara.pins, audiopara.adapterName, &audiopara.adapter,
232 &audiopara.capture);
233 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
234 gettimeofday(&audiopara.start, NULL);
235 ret = audiopara.capture->control.Start((AudioHandle)audiopara.capture);
236 gettimeofday(&audiopara.end, NULL);
237 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
238 audiopara.delayTime = (audiopara.end.tv_sec * MICROSECOND + audiopara.end.tv_usec) -
239 (audiopara.start.tv_sec * MICROSECOND + audiopara.start.tv_usec);
240 audiopara.totalTime += audiopara.delayTime;
241 ret = StopAudio(audiopara);
242 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
243 }
244 audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT;
245 EXPECT_GT(LOWLATENCY, audiopara.averageDelayTime);
246 }
247 /**
248 * @tc.name the performace of AudioCapturePause
249 * @tc.number SUB_Audio_HDI_AudioCapturePause_Performance_0001
250 * @tc.devDesc tests the performace of AudioCapturePause interface by executing 1000 times,
251 * and calculates the delay time and average of Delay Time.
252 * @tc.author: liutian
253 */
254 HWTEST_F(AudioHdiCapturePerformaceTest, SUB_Audio_HDI_AudioCapturePause_Performance_0001, TestSize.Level1)
255 {
256 int32_t ret = -1;
257 struct PrepareAudioPara audiopara = {
258 .portType = PORT_IN, .adapterName = ADAPTER_NAME_USB.c_str(), .pins = PIN_IN_MIC, .totalTime = 0
259 };
260 ASSERT_NE(nullptr, GetAudioManager);
261 audiopara.manager = GetAudioManager();
262 ASSERT_NE(nullptr, audiopara.manager);
263 ret = AudioCreateCapture(audiopara.manager, audiopara.pins, audiopara.adapterName, &audiopara.adapter,
264 &audiopara.capture);
265 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
266 ret = audiopara.capture->control.Start((AudioHandle)audiopara.capture);
267 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
268 for (int i = 0; i < COUNT; ++i) {
269 gettimeofday(&audiopara.start, NULL);
270 ret = audiopara.capture->control.Pause((AudioHandle)audiopara.capture);
271 gettimeofday(&audiopara.end, NULL);
272 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
273 ret = audiopara.capture->control.Resume((AudioHandle)audiopara.capture);
274 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
275 audiopara.delayTime = (audiopara.end.tv_sec * MICROSECOND + audiopara.end.tv_usec) -
276 (audiopara.start.tv_sec * MICROSECOND + audiopara.start.tv_usec);
277 audiopara.totalTime += audiopara.delayTime;
278 }
279 audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT;
280 EXPECT_GT(LOWLATENCY, audiopara.averageDelayTime);
281 ret = StopAudio(audiopara);
282 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
283 }
284
285 /**
286 * @tc.name the performace of AudioCaptureResume
287 * @tc.number SUB_Audio_HDI_AudioCaptureResume_Performance_0001
288 * @tc.devDesc tests the performace of AudioCaptureResume interface by executing 1000 times,
289 * and calculates the delay time and average of Delay Time.
290 * @tc.author: liutian
291 */
292 HWTEST_F(AudioHdiCapturePerformaceTest, SUB_Audio_HDI_AudioCaptureResume_Performance_0001, TestSize.Level1)
293 {
294 int32_t ret = -1;
295 struct PrepareAudioPara audiopara = {
296 .portType = PORT_IN, .adapterName = ADAPTER_NAME_USB.c_str(), .pins = PIN_IN_MIC, .totalTime = 0
297 };
298 ASSERT_NE(nullptr, GetAudioManager);
299 audiopara.manager = GetAudioManager();
300 ASSERT_NE(nullptr, audiopara.manager);
301 ret = AudioCreateCapture(audiopara.manager, audiopara.pins, audiopara.adapterName, &audiopara.adapter,
302 &audiopara.capture);
303 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
304 ret = audiopara.capture->control.Start((AudioHandle)audiopara.capture);
305 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
306 for (int i = 0; i < COUNT; ++i) {
307 ret = audiopara.capture->control.Pause((AudioHandle)audiopara.capture);
308 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
309 gettimeofday(&audiopara.start, NULL);
310 ret = audiopara.capture->control.Resume((AudioHandle)audiopara.capture);
311 gettimeofday(&audiopara.end, NULL);
312 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
313 audiopara.delayTime = (audiopara.end.tv_sec * MICROSECOND + audiopara.end.tv_usec) -
314 (audiopara.start.tv_sec * MICROSECOND + audiopara.start.tv_usec);
315 audiopara.totalTime += audiopara.delayTime;
316 }
317 audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT;
318 EXPECT_GT(LOWLATENCY, audiopara.averageDelayTime);
319 ret = StopAudio(audiopara);
320 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
321 }
322 /**
323 * @tc.name the performace of AudioCaptureStop
324 * @tc.number SUB_Audio_HDI_AudioCaptureStop_Performance_0001
325 * @tc.devDesc tests the performace of AudioCaptureStop interface by executing 1000 times,
326 * and calculates the delay time and average of Delay Time.
327 * @tc.author: liutian
328 */
329 HWTEST_F(AudioHdiCapturePerformaceTest, SUB_Audio_HDI_AudioCaptureStop_Performance_0001, TestSize.Level1)
330 {
331 int32_t ret = -1;
332 struct PrepareAudioPara audiopara = {
333 .portType = PORT_IN, .adapterName = ADAPTER_NAME_USB.c_str(), .pins = PIN_IN_MIC, .totalTime = 0
334 };
335 ASSERT_NE(nullptr, GetAudioManager);
336 audiopara.manager = GetAudioManager();
337 ASSERT_NE(nullptr, audiopara.manager);
338 for (int i = 0; i < COUNT; ++i) {
339 ret = AudioCreateCapture(audiopara.manager, audiopara.pins, audiopara.adapterName, &audiopara.adapter,
340 &audiopara.capture);
341 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
342 ret = audiopara.capture->control.Start((AudioHandle)audiopara.capture);
343 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
344 gettimeofday(&audiopara.start, NULL);
345 ret = audiopara.capture->control.Stop((AudioHandle)audiopara.capture);
346 gettimeofday(&audiopara.end, NULL);
347 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
348 audiopara.delayTime = (audiopara.end.tv_sec * MICROSECOND + audiopara.end.tv_usec) -
349 (audiopara.start.tv_sec * MICROSECOND + audiopara.start.tv_usec);
350 audiopara.totalTime += audiopara.delayTime;
351 ret = audiopara.adapter->DestroyCapture(audiopara.adapter, audiopara.capture);
352 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
353 audiopara.capture = nullptr;
354 audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter);
355 audiopara.adapter = nullptr;
356 }
357 audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT;
358 EXPECT_GT(LOWLATENCY, audiopara.averageDelayTime);
359 }
360
361 /**
362 * @tc.name the performace of AudioCaptureSetSampleAttributes
363 * @tc.number SUB_Audio_HDI_AudioCaptureSetSampleAttributes_Performance_0001
364 * @tc.devDesc tests the performace of AudioCaptureSetSampleAttributes interface by executing 1000 times,
365 * and calculates the delay time and average of Delay Time.
366 * @tc.author: liutian
367 */
368 HWTEST_F(AudioHdiCapturePerformaceTest, SUB_Audio_HDI_AudioCaptureSetSampleAttributes_Performance_0001, TestSize.Level1)
369 {
370 int32_t ret = -1;
371 struct PrepareAudioPara audiopara = {
372 .portType = PORT_IN, .adapterName = ADAPTER_NAME_USB.c_str(), .pins = PIN_IN_MIC, .totalTime = 0
373 };
374 ASSERT_NE(nullptr, GetAudioManager);
375 audiopara.manager = GetAudioManager();
376 ASSERT_NE(nullptr, audiopara.manager);
377 ret = AudioCreateCapture(audiopara.manager, audiopara.pins, audiopara.adapterName, &audiopara.adapter,
378 &audiopara.capture);
379 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
380 InitAttrs(audiopara.attrs);
381 for (int i = 0; i < COUNT; ++i) {
382 gettimeofday(&audiopara.start, NULL);
383 ret = audiopara.capture->attr.SetSampleAttributes(audiopara.capture, &audiopara.attrs);
384 gettimeofday(&audiopara.end, NULL);
385 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
386 audiopara.delayTime = (audiopara.end.tv_sec * MICROSECOND + audiopara.end.tv_usec) -
387 (audiopara.start.tv_sec * MICROSECOND + audiopara.start.tv_usec);
388 audiopara.totalTime += audiopara.delayTime;
389 }
390 audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT;
391 EXPECT_GT(LOWLATENCY, audiopara.averageDelayTime);
392 ret = audiopara.adapter->DestroyCapture(audiopara.adapter, audiopara.capture);
393 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
394 audiopara.capture = nullptr;
395 audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter);
396 audiopara.adapter = nullptr;
397 }
398 /**
399 * @tc.name the performace of AudioCaptureCaptureFrame
400 * @tc.number SUB_Audio_HDI_AudioCaptureCaptureFrame_Performance_0001
401 * @tc.devDesc tests the performace of AudioCaptureCaptureFrame interface by executing 1000 times,
402 * and calculates the delay time and average of Delay Time.
403 * @tc.author: liutian
404 */
405 HWTEST_F(AudioHdiCapturePerformaceTest, SUB_Audio_HDI_AudioCaptureCaptureFrame_Performance_0001, TestSize.Level1)
406 {
407 int32_t ret = -1;
408 struct PrepareAudioPara audiopara = {
409 .portType = PORT_IN, .adapterName = ADAPTER_NAME_USB.c_str(), .pins = PIN_IN_MIC, .totalTime = 0,
410 .requestBytes = BUFFER_LENTH
411 };
412 ASSERT_NE(nullptr, GetAudioManager);
413 audiopara.manager = GetAudioManager();
414 ASSERT_NE(nullptr, audiopara.manager);
415 audiopara.frame = (char *)calloc(1, BUFFER_LENTH);
416 ASSERT_NE(nullptr, audiopara.frame);
417 for (int i = 0; i < COUNT; ++i) {
418 ret = GetLoadAdapter(audiopara.manager, audiopara.portType, audiopara.adapterName, &(audiopara.adapter),
419 audiopara.audioPort);
420 if (ret < 0 || audiopara.adapter == nullptr) {
421 free(audiopara.frame);
422 audiopara.frame = nullptr;
423 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
424 }
425 InitAttrs(audiopara.attrs);
426 audiopara.attrs.silenceThreshold = BUFFER;
427 InitDevDesc(audiopara.devDesc, audiopara.audioPort->portId, audiopara.pins);
428 ret = audiopara.adapter->CreateCapture(audiopara.adapter, &audiopara.devDesc, &audiopara.attrs,
429 &audiopara.capture);
430 if (ret < 0) {
431 audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter);
432 free(audiopara.frame);
433 audiopara.frame = nullptr;
434 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
435 }
436 ret = audiopara.capture->control.Start((AudioHandle)audiopara.capture);
437 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
438 gettimeofday(&audiopara.start, NULL);
439 ret = audiopara.capture->CaptureFrame(audiopara.capture, audiopara.frame, audiopara.requestBytes,
440 &audiopara.replyBytes);
441 gettimeofday(&audiopara.end, NULL);
442 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
443 audiopara.delayTime = (audiopara.end.tv_sec * MICROSECOND + audiopara.end.tv_usec) -
444 (audiopara.start.tv_sec * MICROSECOND + audiopara.start.tv_usec);
445 audiopara.totalTime += audiopara.delayTime;
446 ret = StopAudio(audiopara);
447 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
448 }
449 audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT;
450 EXPECT_GT(NORMALLATENCY, audiopara.averageDelayTime);
451 free(audiopara.frame);
452 audiopara.frame = nullptr;
453 }
454 /**
455 * @tc.name the performace of AudioCaptureGetSampleAttributes
456 * @tc.number SUB_Audio_HDI_AudioCaptureGetSampleAttributes_Performance_0001
457 * @tc.devDesc tests the performace of AudioCaptureGetSampleAttributes interface by executing 1000 times,
458 * and calculates the delay time and average of Delay Time.
459 * @tc.author: liutian
460 */
461 HWTEST_F(AudioHdiCapturePerformaceTest, SUB_Audio_HDI_AudioCaptureGetSampleAttributes_Performance_0001, TestSize.Level1)
462 {
463 int32_t ret = -1;
464 struct PrepareAudioPara audiopara = {
465 .portType = PORT_IN, .adapterName = ADAPTER_NAME_USB.c_str(), .pins = PIN_IN_MIC, .totalTime = 0
466 };
467 ASSERT_NE(nullptr, GetAudioManager);
468 audiopara.manager = GetAudioManager();
469 ASSERT_NE(nullptr, audiopara.manager);
470 ret = AudioCreateCapture(audiopara.manager, audiopara.pins, audiopara.adapterName, &audiopara.adapter,
471 &audiopara.capture);
472 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
473 InitAttrs(audiopara.attrs);
474 ret = audiopara.capture->attr.SetSampleAttributes(audiopara.capture, &audiopara.attrs);
475 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
476 for (int i = 0; i < COUNT; ++i) {
477 gettimeofday(&audiopara.start, NULL);
478 ret = audiopara.capture->attr.GetSampleAttributes(audiopara.capture, &audiopara.attrsValue);
479 gettimeofday(&audiopara.end, NULL);
480 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
481 audiopara.delayTime = (audiopara.end.tv_sec * MICROSECOND + audiopara.end.tv_usec) -
482 (audiopara.start.tv_sec * MICROSECOND + audiopara.start.tv_usec);
483 audiopara.totalTime += audiopara.delayTime;
484 }
485 audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT;
486 EXPECT_GT(LOWLATENCY, audiopara.averageDelayTime);
487 ret = audiopara.adapter->DestroyCapture(audiopara.adapter, audiopara.capture);
488 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
489 audiopara.capture = nullptr;
490 audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter);
491 audiopara.adapter = nullptr;
492 }
493
494 /**
495 * @tc.name the performace of AudioCaptureSetMute
496 * @tc.number SUB_Audio_HDI_AudioCaptureSetMute_Performance_0001
497 * @tc.devDesc tests the performace of AudioCaptureSetMute interface by executing 1000 times,
498 * and calculates the delay time and average of Delay Time.
499 * @tc.author: liutian
500 */
501 HWTEST_F(AudioHdiCapturePerformaceTest, SUB_Audio_HDI_AudioCaptureSetMute_Performance_0001, TestSize.Level1)
502 {
503 int32_t ret = -1;
504 struct PrepareAudioPara audiopara = {
505 .portType = PORT_IN, .adapterName = ADAPTER_NAME_USB.c_str(), .pins = PIN_IN_MIC, .totalTime = 0
506 };
507 ASSERT_NE(nullptr, GetAudioManager);
508 audiopara.manager = GetAudioManager();
509 ASSERT_NE(nullptr, audiopara.manager);
510 ret = AudioCreateCapture(audiopara.manager, audiopara.pins, audiopara.adapterName, &audiopara.adapter,
511 &audiopara.capture);
512 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
513 for (int i = 0; i < COUNT; ++i) {
514 gettimeofday(&audiopara.start, NULL);
515 ret = audiopara.capture->volume.SetMute(audiopara.capture, false);
516 gettimeofday(&audiopara.end, NULL);
517 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
518 audiopara.delayTime = (audiopara.end.tv_sec * MICROSECOND + audiopara.end.tv_usec) -
519 (audiopara.start.tv_sec * MICROSECOND + audiopara.start.tv_usec);
520 audiopara.totalTime += audiopara.delayTime;
521 ret = audiopara.capture->volume.GetMute(audiopara.capture, &audiopara.character.getmute);
522 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
523 EXPECT_FALSE(audiopara.character.getmute);
524 }
525 audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT;
526 EXPECT_GT(LOWLATENCY, audiopara.averageDelayTime);
527 ret = audiopara.adapter->DestroyCapture(audiopara.adapter, audiopara.capture);
528 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
529 audiopara.capture = nullptr;
530 audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter);
531 audiopara.adapter = nullptr;
532 }
533
534 /**
535 * @tc.name the performace of AudioCaptureGetMute
536 * @tc.number SUB_Audio_HDI_AudioCaptureGetMute_Performance_0001
537 * @tc.devDesc tests the performace of AudioCaptureGetMute interface by executing 1000 times,
538 * and calculates the delay time and average of Delay Time.
539 * @tc.author: liutian
540 */
541 HWTEST_F(AudioHdiCapturePerformaceTest, SUB_Audio_HDI_AudioCaptureGetMute_Performance_0001, TestSize.Level1)
542 {
543 int32_t ret = -1;
544 struct PrepareAudioPara audiopara = {
545 .portType = PORT_IN, .adapterName = ADAPTER_NAME_USB.c_str(), .pins = PIN_IN_MIC, .totalTime = 0
546 };
547 ASSERT_NE(nullptr, GetAudioManager);
548 audiopara.manager = GetAudioManager();
549 ASSERT_NE(nullptr, audiopara.manager);
550 ret = AudioCreateCapture(audiopara.manager, audiopara.pins, audiopara.adapterName, &audiopara.adapter,
551 &audiopara.capture);
552 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
553 ret = audiopara.capture->volume.SetMute(audiopara.capture, false);
554 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
555 for (int i = 0; i < COUNT; ++i) {
556 gettimeofday(&audiopara.start, NULL);
557 ret = audiopara.capture->volume.GetMute(audiopara.capture, &audiopara.character.getmute);
558 gettimeofday(&audiopara.end, NULL);
559 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
560 EXPECT_FALSE(audiopara.character.getmute);
561 audiopara.delayTime = (audiopara.end.tv_sec * MICROSECOND + audiopara.end.tv_usec) -
562 (audiopara.start.tv_sec * MICROSECOND + audiopara.start.tv_usec);
563 audiopara.totalTime += audiopara.delayTime;
564 }
565 audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT;
566 EXPECT_GT(LOWLATENCY, audiopara.averageDelayTime);
567 ret = audiopara.adapter->DestroyCapture(audiopara.adapter, audiopara.capture);
568 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
569 audiopara.capture = nullptr;
570 audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter);
571 audiopara.adapter = nullptr;
572 }
573
574 /**
575 * @tc.name the performace of AudioCaptureSetVolume
576 * @tc.number SUB_Audio_HDI_AudioCaptureSetVolume_Performance_0001
577 * @tc.devDesc tests the performace of AudioCaptureSetVolume interface by executing 1000 times,
578 * and calculates the delay time and average of Delay Time.
579 * @tc.author: liutian
580 */
581 HWTEST_F(AudioHdiCapturePerformaceTest, SUB_Audio_HDI_AudioCaptureSetVolume_Performance_0001, TestSize.Level1)
582 {
583 int32_t ret = -1;
584 struct PrepareAudioPara audiopara = {
585 .portType = PORT_IN, .adapterName = ADAPTER_NAME_USB.c_str(), .pins = PIN_IN_MIC, .totalTime = 0,
586 .character.setvolume = 0.7
587 };
588 ASSERT_NE(nullptr, GetAudioManager);
589 audiopara.manager = GetAudioManager();
590 ASSERT_NE(nullptr, audiopara.manager);
591 ret = AudioCreateCapture(audiopara.manager, audiopara.pins, audiopara.adapterName, &audiopara.adapter,
592 &audiopara.capture);
593 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
594 for (int i = 0; i < COUNT; ++i) {
595 gettimeofday(&audiopara.start, NULL);
596 ret = audiopara.capture->volume.SetVolume(audiopara.capture, audiopara.character.setvolume);
597 gettimeofday(&audiopara.end, NULL);
598 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
599 ret = audiopara.capture->volume.GetVolume(audiopara.capture, &audiopara.character.getvolume);
600 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
601 EXPECT_EQ(audiopara.character.setvolume, audiopara.character.getvolume);
602 audiopara.delayTime = (audiopara.end.tv_sec * MICROSECOND + audiopara.end.tv_usec) -
603 (audiopara.start.tv_sec * MICROSECOND + audiopara.start.tv_usec);
604 audiopara.totalTime += audiopara.delayTime;
605 }
606 audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT;
607 EXPECT_GT(LOWLATENCY, audiopara.averageDelayTime);
608 ret = audiopara.adapter->DestroyCapture(audiopara.adapter, audiopara.capture);
609 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
610 audiopara.capture = nullptr;
611 audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter);
612 audiopara.adapter = nullptr;
613 }
614
615 /**
616 * @tc.name the performace of AudioCaptureGetVolume
617 * @tc.number SUB_Audio_HDI_AudioCaptureGetVolume_Performance_0001
618 * @tc.devDesc tests the performace of AudioCaptureGetVolume interface by executing 1000 times,
619 * and calculates the delay time and average of Delay Time.
620 * @tc.author: liutian
621 */
622 HWTEST_F(AudioHdiCapturePerformaceTest, SUB_Audio_HDI_AudioCaptureGetVolume_Performance_0001, TestSize.Level1)
623 {
624 int32_t ret = -1;
625 struct PrepareAudioPara audiopara = {
626 .portType = PORT_IN, .adapterName = ADAPTER_NAME_USB.c_str(), .pins = PIN_IN_MIC, .totalTime = 0,
627 .character.setvolume = 0.8
628 };
629 ASSERT_NE(nullptr, GetAudioManager);
630 audiopara.manager = GetAudioManager();
631 ASSERT_NE(nullptr, audiopara.manager);
632 ret = AudioCreateCapture(audiopara.manager, audiopara.pins, audiopara.adapterName, &audiopara.adapter,
633 &audiopara.capture);
634 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
635 ret = audiopara.capture->volume.SetVolume(audiopara.capture, audiopara.character.setvolume);
636 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
637 for (int i = 0; i < COUNT; ++i) {
638 gettimeofday(&audiopara.start, NULL);
639 ret = audiopara.capture->volume.GetVolume(audiopara.capture, &audiopara.character.getvolume);
640 gettimeofday(&audiopara.end, NULL);
641 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
642 EXPECT_EQ(audiopara.character.setvolume, audiopara.character.getvolume);
643 audiopara.delayTime = (audiopara.end.tv_sec * MICROSECOND + audiopara.end.tv_usec) -
644 (audiopara.start.tv_sec * MICROSECOND + audiopara.start.tv_usec);
645 audiopara.totalTime += audiopara.delayTime;
646 }
647 audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT;
648 EXPECT_GT(LOWLATENCY, audiopara.averageDelayTime);
649 ret = audiopara.adapter->DestroyCapture(audiopara.adapter, audiopara.capture);
650 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
651 audiopara.capture = nullptr;
652 audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter);
653 audiopara.adapter = nullptr;
654 }
655
656 /**
657 * @tc.name the performace of AudioCaptureGetGain
658 * @tc.number SUB_Audio_HDI_AudioCaptureGetGain_Performance_0001
659 * @tc.devDesc tests the performace of AudioCaptureGetGain interface by executing 1000 times,
660 * and calculates the delay time and average of Delay Time.
661 * @tc.author: liutian
662 */
663 HWTEST_F(AudioHdiCapturePerformaceTest, SUB_Audio_HDI_AudioCaptureGetGain_Performance_0001, TestSize.Level1)
664 {
665 int32_t ret = -1;
666 struct PrepareAudioPara audiopara = {
667 .portType = PORT_IN, .adapterName = ADAPTER_NAME_USB.c_str(), .pins = PIN_IN_MIC, .totalTime = 0,
668 .character.setgain = 7
669 };
670 ASSERT_NE(nullptr, GetAudioManager);
671 audiopara.manager = GetAudioManager();
672 ASSERT_NE(nullptr, audiopara.manager);
673 ret = AudioCreateCapture(audiopara.manager, audiopara.pins, audiopara.adapterName, &audiopara.adapter,
674 &audiopara.capture);
675 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
676 ret = audiopara.capture->volume.SetGain(audiopara.capture, audiopara.character.setgain);
677 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
678 for (int i = 0; i < COUNT; ++i) {
679 gettimeofday(&audiopara.start, NULL);
680 ret = audiopara.capture->volume.GetGain(audiopara.capture, &audiopara.character.getgain);
681 gettimeofday(&audiopara.end, NULL);
682 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
683 EXPECT_EQ(audiopara.character.setgain, audiopara.character.getgain);
684 audiopara.delayTime = (audiopara.end.tv_sec * MICROSECOND + audiopara.end.tv_usec) -
685 (audiopara.start.tv_sec * MICROSECOND + audiopara.start.tv_usec);
686 audiopara.totalTime += audiopara.delayTime;
687 }
688 audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT;
689 EXPECT_GT(LOWLATENCY, audiopara.averageDelayTime);
690 ret = audiopara.adapter->DestroyCapture(audiopara.adapter, audiopara.capture);
691 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
692 audiopara.capture = nullptr;
693 audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter);
694 audiopara.adapter = nullptr;
695 }
696
697 /**
698 * @tc.name the performace of AudioCaptureSetGain
699 * @tc.number SUB_Audio_HDI_AudioCaptureSetGain_Performance_0001
700 * @tc.devDesc tests the performace of AudioCaptureSetGain interface by executing 1000 times,
701 * and calculates the delay time and average of Delay Time.
702 * @tc.author: liutian
703 */
704 HWTEST_F(AudioHdiCapturePerformaceTest, SUB_Audio_HDI_AudioCaptureSetGain_Performance_0001, TestSize.Level1)
705 {
706 int32_t ret = -1;
707 struct PrepareAudioPara audiopara = {
708 .portType = PORT_IN, .adapterName = ADAPTER_NAME_USB.c_str(), .pins = PIN_IN_MIC, .totalTime = 0,
709 .character.setgain = 8
710 };
711 ASSERT_NE(nullptr, GetAudioManager);
712 audiopara.manager = GetAudioManager();
713 ASSERT_NE(nullptr, audiopara.manager);
714 ret = AudioCreateCapture(audiopara.manager, audiopara.pins, audiopara.adapterName, &audiopara.adapter,
715 &audiopara.capture);
716 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
717 for (int i = 0; i < COUNT; ++i) {
718 gettimeofday(&audiopara.start, NULL);
719 ret = audiopara.capture->volume.SetGain(audiopara.capture, audiopara.character.setgain);
720 gettimeofday(&audiopara.end, NULL);
721 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
722 ret = audiopara.capture->volume.GetGain(audiopara.capture, &audiopara.character.getgain);
723 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
724 EXPECT_EQ(audiopara.character.setgain, audiopara.character.getgain);
725 audiopara.delayTime = (audiopara.end.tv_sec * MICROSECOND + audiopara.end.tv_usec) -
726 (audiopara.start.tv_sec * MICROSECOND + audiopara.start.tv_usec);
727 audiopara.totalTime += audiopara.delayTime;
728 }
729 audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT;
730 EXPECT_GT(LOWLATENCY, audiopara.averageDelayTime);
731 ret = audiopara.adapter->DestroyCapture(audiopara.adapter, audiopara.capture);
732 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
733 audiopara.capture = nullptr;
734 audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter);
735 audiopara.adapter = nullptr;
736 }
737
738 /**
739 * @tc.name the performace of AudioCaptureGetCurrentChannelId
740 * @tc.number SUB_Audio_HDI_AudioCaptureGetCurrentChannelId_Performance_0001
741 * @tc.devDesc tests the performace of AudioCaptureGetCurrentChannelId interface by executing 1000 times,
742 * and calculates the delay time and average of Delay Time.
743 * @tc.author: liutian
744 */
745 HWTEST_F(AudioHdiCapturePerformaceTest, SUB_Audio_HDI_AudioCaptureGetCurrentChannelId_Performance_0001, TestSize.Level1)
746 {
747 int32_t ret = -1;
748 struct PrepareAudioPara audiopara = {
749 .portType = PORT_IN, .adapterName = ADAPTER_NAME_USB.c_str(), .pins = PIN_IN_MIC, .totalTime = 0
750 };
751 ASSERT_NE(nullptr, GetAudioManager);
752 audiopara.manager = GetAudioManager();
753 ASSERT_NE(nullptr, audiopara.manager);
754 ret = AudioCreateCapture(audiopara.manager, audiopara.pins, audiopara.adapterName, &audiopara.adapter,
755 &audiopara.capture);
756 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
757 for (int i = 0; i < COUNT; ++i) {
758 gettimeofday(&audiopara.start, NULL);
759 ret = audiopara.capture->attr.GetCurrentChannelId(audiopara.capture, &audiopara.character.getcurrentchannelId);
760 gettimeofday(&audiopara.end, NULL);
761 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
762 audiopara.delayTime = (audiopara.end.tv_sec * MICROSECOND + audiopara.end.tv_usec) -
763 (audiopara.start.tv_sec * MICROSECOND + audiopara.start.tv_usec);
764 audiopara.totalTime += audiopara.delayTime;
765 }
766 audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT;
767 EXPECT_GT(LOWLATENCY, audiopara.averageDelayTime);
768 ret = audiopara.adapter->DestroyCapture(audiopara.adapter, audiopara.capture);
769 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
770 audiopara.capture = nullptr;
771 audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter);
772 audiopara.adapter = nullptr;
773 }
774
775 /**
776 * @tc.name the performace of AudioCaptureGetFrameCount
777 * @tc.number SUB_Audio_HDI_AudioCaptureGetFrameCount_Performance_0001
778 * @tc.devDesc tests the performace of AudioCaptureGetFrameCount interface by executing 1000 times,
779 * and calculates the delay time and average of Delay Time.
780 * @tc.author: liutian
781 */
782 HWTEST_F(AudioHdiCapturePerformaceTest, SUB_Audio_HDI_AudioCaptureGetFrameCount_Performance_0001, TestSize.Level1)
783 {
784 int32_t ret = -1;
785 struct PrepareAudioPara audiopara = {
786 .portType = PORT_IN, .adapterName = ADAPTER_NAME_USB.c_str(), .pins = PIN_IN_MIC, .totalTime = 0
787 };
788 ASSERT_NE(nullptr, GetAudioManager);
789 audiopara.manager = GetAudioManager();
790 ASSERT_NE(nullptr, audiopara.manager);
791 ret = AudioCreateCapture(audiopara.manager, audiopara.pins, audiopara.adapterName, &audiopara.adapter,
792 &audiopara.capture);
793 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
794 for (int i = 0; i < COUNT; ++i) {
795 gettimeofday(&audiopara.start, NULL);
796 ret = audiopara.capture->attr.GetFrameCount(audiopara.capture, &audiopara.character.getframecount);
797 gettimeofday(&audiopara.end, NULL);
798 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
799 EXPECT_EQ(INITIAL_VALUE, audiopara.character.getframecount);
800 audiopara.delayTime = (audiopara.end.tv_sec * MICROSECOND + audiopara.end.tv_usec) -
801 (audiopara.start.tv_sec * MICROSECOND + audiopara.start.tv_usec);
802 audiopara.totalTime += audiopara.delayTime;
803 }
804 audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT;
805 EXPECT_GT(LOWLATENCY, audiopara.averageDelayTime);
806 ret = audiopara.adapter->DestroyCapture(audiopara.adapter, audiopara.capture);
807 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
808 audiopara.capture = nullptr;
809 audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter);
810 audiopara.adapter = nullptr;
811 }
812
813 /**
814 * @tc.name the performace of AudioCaptureGetFrameSize
815 * @tc.number SUB_Audio_HDI_AudioCaptureGetFrameSize_Performance_0001
816 * @tc.devDesc tests the performace of AudioCaptureGetFrameSize interface by executing 1000 times,
817 * and calculates the delay time and average of Delay Time.
818 * @tc.author: liutian
819 */
820 HWTEST_F(AudioHdiCapturePerformaceTest, SUB_Audio_HDI_AudioCaptureGetFrameSize_Performance_0001, TestSize.Level1)
821 {
822 int32_t ret = -1;
823 struct PrepareAudioPara audiopara = {
824 .portType = PORT_IN, .adapterName = ADAPTER_NAME_USB.c_str(), .pins = PIN_IN_MIC, .totalTime = 0
825 };
826 ASSERT_NE(nullptr, GetAudioManager);
827 audiopara.manager = GetAudioManager();
828 ASSERT_NE(nullptr, audiopara.manager);
829 ret = AudioCreateCapture(audiopara.manager, audiopara.pins, audiopara.adapterName, &audiopara.adapter,
830 &audiopara.capture);
831 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
832 for (int i = 0; i < COUNT; ++i) {
833 gettimeofday(&audiopara.start, NULL);
834 ret = audiopara.capture->attr.GetFrameSize(audiopara.capture, &audiopara.character.getframesize);
835 gettimeofday(&audiopara.end, NULL);
836 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
837 EXPECT_GT(audiopara.character.getframesize, INITIAL_VALUE);
838 audiopara.delayTime = (audiopara.end.tv_sec * MICROSECOND + audiopara.end.tv_usec) -
839 (audiopara.start.tv_sec * MICROSECOND + audiopara.start.tv_usec);
840 audiopara.totalTime += audiopara.delayTime;
841 }
842 audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT;
843 EXPECT_GT(LOWLATENCY, audiopara.averageDelayTime);
844 ret = audiopara.adapter->DestroyCapture(audiopara.adapter, audiopara.capture);
845 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
846 audiopara.capture = nullptr;
847 audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter);
848 audiopara.adapter = nullptr;
849 }
850
851 /**
852 * @tc.name the performace of AudioCaptureFlush
853 * @tc.number SUB_Audio_HDI_AudioCaptureFlush_Performance_0001
854 * @tc.devDesc tests the performace of AudioCaptureFlush interface by executing 1000 times,
855 * and calculates the delay time and average of Delay Time.
856 * @tc.author: liutian
857 */
858 HWTEST_F(AudioHdiCapturePerformaceTest, SUB_Audio_HDI_AudioCaptureFlush_Performance_0001, TestSize.Level1)
859 {
860 int32_t ret = -1;
861 struct PrepareAudioPara audiopara = {
862 .portType = PORT_IN, .adapterName = ADAPTER_NAME_USB.c_str(), .pins = PIN_IN_MIC, .totalTime = 0
863 };
864 ASSERT_NE(nullptr, GetAudioManager);
865 audiopara.manager = GetAudioManager();
866 ASSERT_NE(nullptr, audiopara.manager);
867 for (int i = 0; i < COUNT; ++i) {
868 ret = AudioCreateCapture(audiopara.manager, audiopara.pins, audiopara.adapterName, &audiopara.adapter,
869 &audiopara.capture);
870 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
871 ret = audiopara.capture->control.Start((AudioHandle)audiopara.capture);
872 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
873 gettimeofday(&audiopara.start, NULL);
874 ret = audiopara.capture->control.Flush((AudioHandle)audiopara.capture);
875 gettimeofday(&audiopara.end, NULL);
876 EXPECT_EQ(HDF_ERR_NOT_SUPPORT, ret);
877 audiopara.delayTime = (audiopara.end.tv_sec * MICROSECOND + audiopara.end.tv_usec) -
878 (audiopara.start.tv_sec * MICROSECOND + audiopara.start.tv_usec);
879 audiopara.totalTime += audiopara.delayTime;
880 ret = StopAudio(audiopara);
881 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
882 }
883 audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT;
884 EXPECT_GT(LOWLATENCY, audiopara.averageDelayTime);
885 }
886
887 /**
888 * @tc.name the performace of AudioCaptureGetGainThreshold
889 * @tc.number SUB_Audio_HDI_AudioCaptureGetGainThreshold_Performance_0001
890 * @tc.devDesc tests the performace of AudioCaptureGetGainThreshold interface by executing 1000 times,
891 * and calculates the delay time and average of Delay Time.
892 * @tc.author: liutian
893 */
894 HWTEST_F(AudioHdiCapturePerformaceTest, SUB_Audio_HDI_AudioCaptureGetGainThreshold_Performance_0001, TestSize.Level1)
895 {
896 int32_t ret = -1;
897 struct PrepareAudioPara audiopara = {
898 .portType = PORT_IN, .adapterName = ADAPTER_NAME_USB.c_str(), .pins = PIN_IN_MIC, .totalTime = 0
899 };
900 ASSERT_NE(nullptr, GetAudioManager);
901 audiopara.manager = GetAudioManager();
902 ASSERT_NE(nullptr, audiopara.manager);
903 ret = AudioCreateCapture(audiopara.manager, audiopara.pins, audiopara.adapterName, &audiopara.adapter,
904 &audiopara.capture);
905 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
906 for (int i = 0; i < COUNT; ++i) {
907 gettimeofday(&audiopara.start, NULL);
908 ret = audiopara.capture->volume.GetGainThreshold(audiopara.capture, &audiopara.character.gainthresholdmin,
909 &audiopara.character.gainthresholdmax);
910 gettimeofday(&audiopara.end, NULL);
911 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
912 EXPECT_EQ(audiopara.character.gainthresholdmin, GAIN_MIN);
913 EXPECT_EQ(audiopara.character.gainthresholdmax, GAIN_MAX);
914 audiopara.delayTime = (audiopara.end.tv_sec * MICROSECOND + audiopara.end.tv_usec) -
915 (audiopara.start.tv_sec * MICROSECOND + audiopara.start.tv_usec);
916 audiopara.totalTime += audiopara.delayTime;
917 }
918 audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT;
919 EXPECT_GT(LOWLATENCY, audiopara.averageDelayTime);
920 ret = audiopara.adapter->DestroyCapture(audiopara.adapter, audiopara.capture);
921 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
922 audiopara.capture = nullptr;
923 audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter);
924 audiopara.adapter = nullptr;
925 }
926
927 /**
928 * @tc.name the performace of AudioCaptureCheckSceneCapability
929 * @tc.number SUB_Audio_HDI_AudioCaptureCheckSceneCapability_Performance_0001
930 * @tc.devDesc tests the performace of AudioCaptureCheckSceneCapability interface by executing 1000 times,
931 * and calculates the delay time and average of Delay Time.
932 * @tc.author: liutian
933 */
934 HWTEST_F(AudioHdiCapturePerformaceTest, SUB_Audio_HDI_AudioCaptureCheckSceneCapability_Performance_0001,
935 TestSize.Level1)
936 {
937 int32_t ret = -1;
938 struct PrepareAudioPara audiopara = {
939 .portType = PORT_IN, .adapterName = ADAPTER_NAME_USB.c_str(), .pins = PIN_IN_MIC, .totalTime = 0
940 };
941 struct AudioSceneDescriptor scenes = { .scene.id = 0, .desc.pins = PIN_IN_MIC };
942 bool supported = false;
943 ASSERT_NE(nullptr, GetAudioManager);
944 audiopara.manager = GetAudioManager();
945 ASSERT_NE(nullptr, audiopara.manager);
946 ret = AudioCreateCapture(audiopara.manager, audiopara.pins, audiopara.adapterName, &audiopara.adapter,
947 &audiopara.capture);
948 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
949 for (int i = 0; i < COUNT; ++i) {
950 gettimeofday(&audiopara.start, NULL);
951 ret = audiopara.capture->scene.CheckSceneCapability(audiopara.capture, &scenes, &supported);
952 gettimeofday(&audiopara.end, NULL);
953 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
954 audiopara.delayTime = (audiopara.end.tv_sec * MICROSECOND + audiopara.end.tv_usec) -
955 (audiopara.start.tv_sec * MICROSECOND + audiopara.start.tv_usec);
956 audiopara.totalTime += audiopara.delayTime;
957 }
958 audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT;
959 EXPECT_GT(LOWLATENCY, audiopara.averageDelayTime);
960 ret = audiopara.adapter->DestroyCapture(audiopara.adapter, audiopara.capture);
961 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
962 audiopara.capture = nullptr;
963 audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter);
964 audiopara.adapter = nullptr;
965 }
966
967 /**
968 * @tc.name the performace of AudioCaptureSelectScene
969 * @tc.number SUB_Audio_HDI_AudioCaptureSelectScene_Performance_0001
970 * @tc.devDesc tests the performace of AudioCaptureSelectScene interface by executing 1000 times,
971 * and calculates the delay time and average of Delay Time.
972 * @tc.author: liutian
973 */
974 HWTEST_F(AudioHdiCapturePerformaceTest, SUB_Audio_HDI_AudioCaptureSelectScene_Performance_0001, TestSize.Level1)
975 {
976 int32_t ret = -1;
977 struct PrepareAudioPara audiopara = {
978 .portType = PORT_IN, .adapterName = ADAPTER_NAME_USB.c_str(), .pins = PIN_IN_MIC, .totalTime = 0
979 };
980 struct AudioSceneDescriptor scenes = { .scene.id = 0, .desc.pins = PIN_IN_MIC };
981 ASSERT_NE(nullptr, GetAudioManager);
982 audiopara.manager = GetAudioManager();
983 ASSERT_NE(nullptr, audiopara.manager);
984 ret = AudioCreateCapture(audiopara.manager, audiopara.pins, audiopara.adapterName, &audiopara.adapter,
985 &audiopara.capture);
986 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
987 for (int i = 0; i < COUNT; ++i) {
988 gettimeofday(&audiopara.start, NULL);
989 ret = audiopara.capture->scene.SelectScene(audiopara.capture, &scenes);
990 gettimeofday(&audiopara.end, NULL);
991 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
992 audiopara.delayTime = (audiopara.end.tv_sec * MICROSECOND + audiopara.end.tv_usec) -
993 (audiopara.start.tv_sec * MICROSECOND + audiopara.start.tv_usec);
994 audiopara.totalTime += audiopara.delayTime;
995 }
996 audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT;
997 EXPECT_GT(LOWLATENCY, audiopara.averageDelayTime);
998 ret = audiopara.adapter->DestroyCapture(audiopara.adapter, audiopara.capture);
999 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1000 audiopara.capture = nullptr;
1001 audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter);
1002 audiopara.adapter = nullptr;
1003 }
1004
1005 /**
1006 * @tc.name the performace of AudioGetCapturePosition
1007 * @tc.number SUB_Audio_HDI_AudioGetCapturePosition_Performance_0001
1008 * @tc.devDesc tests the performace of AudioCaptureGetCapturePosition interface by executing 1000 times,
1009 * and calculates the delay time and average of Delay Time.
1010 * @tc.author: liutian
1011 */
1012 HWTEST_F(AudioHdiCapturePerformaceTest, SUB_Audio_HDI_AudioGetCapturePosition_Performance_0001, TestSize.Level1)
1013 {
1014 int32_t ret = -1;
1015 struct PrepareAudioPara audiopara = {
1016 .portType = PORT_IN, .adapterName = ADAPTER_NAME_USB.c_str(), .pins = PIN_IN_MIC, .totalTime = 0
1017 };
1018 ASSERT_NE(nullptr, GetAudioManager);
1019 audiopara.manager = GetAudioManager();
1020 ASSERT_NE(nullptr, audiopara.manager);
1021 ret = AudioCreateCapture(audiopara.manager, audiopara.pins, audiopara.adapterName, &audiopara.adapter,
1022 &audiopara.capture);
1023 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
1024 ret = audiopara.capture->control.Start((AudioHandle)audiopara.capture);
1025 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1026 for (int i = 0; i < COUNT; ++i) {
1027 gettimeofday(&audiopara.start, NULL);
1028 ret = audiopara.capture->GetCapturePosition(audiopara.capture, &audiopara.character.getframes, &audiopara.time);
1029 gettimeofday(&audiopara.end, NULL);
1030 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1031 audiopara.delayTime = (audiopara.end.tv_sec * MICROSECOND + audiopara.end.tv_usec) -
1032 (audiopara.start.tv_sec * MICROSECOND + audiopara.start.tv_usec);
1033 audiopara.totalTime += audiopara.delayTime;
1034 }
1035 audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT;
1036 EXPECT_GT(LOWLATENCY, audiopara.averageDelayTime);
1037 ret = StopAudio(audiopara);
1038 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1039 }
1040
1041 /**
1042 * @tc.name the performace of AudioCaptureSetExtraParams
1043 * @tc.number SUB_Audio_HDI_AudioCaptureSetExtraParams_Performance_0001
1044 * @tc.desc tests the performace of AudioCaptureSetExtraParams interface by executing 1000 times,
1045 * and calculates the delay time and average of Delay Time.
1046 * @tc.author: liutian
1047 */
1048 HWTEST_F(AudioHdiCapturePerformaceTest, SUB_Audio_HDI_AudioCaptureSetExtraParams_Performance_0001, TestSize.Level1)
1049 {
1050 int32_t ret = -1;
1051 char keyValueList[] = "attr-route=1;attr-format=32;attr-channels=2;attr-frame-count=82;attr-sampling-rate=48000";
1052 struct PrepareAudioPara audiopara = {
1053 .portType = PORT_IN, .adapterName = ADAPTER_NAME_USB.c_str(), .pins = PIN_IN_MIC, .totalTime = 0
1054 };
1055 ASSERT_NE(nullptr, GetAudioManager);
1056 audiopara.manager = GetAudioManager();
1057 ASSERT_NE(nullptr, audiopara.manager);
1058 ret = AudioCreateStartCapture(audiopara.manager, &audiopara.capture, &audiopara.adapter, ADAPTER_NAME_USB);
1059 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
1060
1061 for (int i = 0; i < COUNT; ++i) {
1062 gettimeofday(&audiopara.start, NULL);
1063 ret = audiopara.capture->attr.SetExtraParams((AudioHandle)audiopara.capture, keyValueList);
1064 gettimeofday(&audiopara.end, NULL);
1065 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1066 audiopara.delayTime = (audiopara.end.tv_sec * MICROSECOND + audiopara.end.tv_usec) -
1067 (audiopara.start.tv_sec * MICROSECOND + audiopara.start.tv_usec);
1068 audiopara.totalTime += audiopara.delayTime;
1069 }
1070 ret = StopAudio(audiopara);
1071 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1072 audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT;
1073 EXPECT_GT(LOWLATENCY, audiopara.averageDelayTime);
1074 }
1075
1076 /**
1077 * @tc.name the performace of AudioCaptureGetExtraParams
1078 * @tc.number SUB_Audio_HDI_AudioCaptureGetExtraParams_Performance_0001
1079 * @tc.desc tests the performace of AudioCaptureGetExtraParams interface by executing 1000 times,
1080 * and calculates the delay time and average of Delay Time.
1081 * @tc.author: liutian
1082 */
1083 HWTEST_F(AudioHdiCapturePerformaceTest, SUB_Audio_HDI_AudioCaptureGetExtraParams_Performance_0001, TestSize.Level1)
1084 {
1085 int32_t ret = -1;
1086 struct PrepareAudioPara audiopara = {
1087 .portType = PORT_IN, .adapterName = ADAPTER_NAME_USB.c_str(), .pins = PIN_IN_MIC, .totalTime = 0
1088 };
1089 char keyValueList[] = "attr-format=24;attr-frame-count=4096;";
1090 char keyValueListExp[] = "attr-route=0;attr-format=24;attr-channels=2;attr-frame-count=4096;\
1091 attr-sampling-rate=48000";
1092 int32_t listLenth = 256;
1093 ASSERT_NE(nullptr, GetAudioManager);
1094 audiopara.manager = GetAudioManager();
1095 ASSERT_NE(nullptr, audiopara.manager);
1096
1097 ret = AudioCreateStartCapture(audiopara.manager, &audiopara.capture, &audiopara.adapter, ADAPTER_NAME_USB);
1098 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
1099 ret = audiopara.capture->attr.SetExtraParams((AudioHandle)audiopara.capture, keyValueList);
1100 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1101
1102 for (int i = 0; i < COUNT; ++i) {
1103 char keyValueListValue[256] = {};
1104 gettimeofday(&audiopara.start, NULL);
1105 ret = audiopara.capture->attr.GetExtraParams((AudioHandle)audiopara.capture, keyValueListValue, listLenth);
1106 gettimeofday(&audiopara.end, NULL);
1107 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1108 EXPECT_STREQ(keyValueListExp, keyValueListValue);
1109 audiopara.delayTime = (audiopara.end.tv_sec * MICROSECOND + audiopara.end.tv_usec) -
1110 (audiopara.start.tv_sec * MICROSECOND + audiopara.start.tv_usec);
1111 audiopara.totalTime += audiopara.delayTime;
1112 }
1113 ret = StopAudio(audiopara);
1114 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1115 audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT;
1116 EXPECT_GT(LOWLATENCY, audiopara.averageDelayTime);
1117 }
1118
1119 /**
1120 * @tc.name the performace of AudioCaptureGetMmapPosition
1121 * @tc.number SUB_Audio_HDI_AudioCaptureGetMmapPosition_Performance_0001
1122 * @tc.desc tests the performace of AudioCaptureGetMmapPosition interface by executing 1000 times,
1123 * and calculates the delay time and average of Delay Time.
1124 * @tc.author: liutian
1125 */
1126 HWTEST_F(AudioHdiCapturePerformaceTest, SUB_Audio_HDI_AudioCaptureGetMmapPosition_Performance_0001, TestSize.Level1)
1127 {
1128 int32_t ret = -1;
1129 uint64_t frames = 0;
1130 int64_t timeExp = 0;
1131 struct PrepareAudioPara audiopara = {
1132 .portType = PORT_IN, .adapterName = ADAPTER_NAME_USB.c_str(), .pins = PIN_IN_MIC, .totalTime = 0
1133 };
1134 ASSERT_NE(nullptr, GetAudioManager);
1135 audiopara.manager = GetAudioManager();
1136 ASSERT_NE(nullptr, audiopara.manager);
1137 ret = AudioCreateCapture(audiopara.manager, audiopara.pins, audiopara.adapterName, &audiopara.adapter,
1138 &audiopara.capture);
1139 if (ret < 0 || audiopara.capture == nullptr) {
1140 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
1141 ASSERT_EQ(nullptr, audiopara.capture);
1142 }
1143
1144 for (int i = 0; i < COUNT; ++i) {
1145 gettimeofday(&audiopara.start, NULL);
1146 ret = audiopara.capture->attr.GetMmapPosition(audiopara.capture, &frames, &(audiopara.time));
1147 gettimeofday(&audiopara.end, NULL);
1148 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1149 EXPECT_EQ((audiopara.time.tvSec) * SECTONSEC + (audiopara.time.tvNSec), timeExp);
1150 EXPECT_EQ(frames, INITIAL_VALUE);
1151 audiopara.delayTime = (audiopara.end.tv_sec * MICROSECOND + audiopara.end.tv_usec) -
1152 (audiopara.start.tv_sec * MICROSECOND + audiopara.start.tv_usec);
1153 audiopara.totalTime += audiopara.delayTime;
1154 }
1155 audiopara.adapter->DestroyCapture(audiopara.adapter, audiopara.capture);
1156 audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter);
1157 audiopara.capture = nullptr;
1158 audiopara.adapter = nullptr;
1159 audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT;
1160 EXPECT_GT(LOWLATENCY, audiopara.averageDelayTime);
1161 }
1162 }
1163