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