1 /*
2 * Copyright (c) 2022 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include <gtest/gtest.h>
17 #include "hdi_service_common.h"
18
19 using namespace std;
20 using namespace testing::ext;
21 using namespace OHOS::Audio;
22
23 namespace {
24 const float COUNT = 1000; // number of interface calls
25 const long LOWLATENCY = 10000; // low interface delay:10ms
26 const long NORMALLATENCY = 30000; // normal interface delay:30ms
27 const int BUFFER = 1024 * 4;
28
29 class AudioIdlHdiCapturePerformaceTest : public testing::Test {
30 public:
31 static void SetUpTestCase(void);
32 static void TearDownTestCase(void);
33 void SetUp();
34 void TearDown();
35 static TestAudioManager *manager;
36 struct IAudioAdapter *adapter = nullptr;
37 struct IAudioCapture *capture = nullptr;
38 };
39
40 TestAudioManager *AudioIdlHdiCapturePerformaceTest::manager = nullptr;
41
SetUpTestCase(void)42 void AudioIdlHdiCapturePerformaceTest::SetUpTestCase(void)
43 {
44 manager = IAudioManagerGet(IS_STUB);
45 ASSERT_NE(nullptr, manager);
46 }
47
TearDownTestCase(void)48 void AudioIdlHdiCapturePerformaceTest::TearDownTestCase(void)
49 {
50 if (manager != nullptr) {
51 (void)IAudioManagerRelease(manager, IS_STUB);
52 }
53 }
54
SetUp(void)55 void AudioIdlHdiCapturePerformaceTest::SetUp(void)
56 {
57 ASSERT_NE(nullptr, manager);
58 int32_t ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME, &adapter, &capture);
59 ASSERT_EQ(HDF_SUCCESS, ret);
60 }
61
TearDown(void)62 void AudioIdlHdiCapturePerformaceTest::TearDown(void)
63 {
64 int32_t ret = ReleaseCaptureSource(manager, adapter, capture);
65 ASSERT_EQ(HDF_SUCCESS, ret);
66 }
67 /**
68 * @tc.name AudioCaptureStartPerformance_001
69 * @tc.devDesc tests the performace of AudioCaptureStart interface by executing 1000 times,
70 * and calculates the delay time and average of Delay Time.
71 * @tc.type: PERF
72 */
73 HWTEST_F(AudioIdlHdiCapturePerformaceTest, AudioCaptureStartPerformance_001, TestSize.Level1)
74 {
75 struct PrepareAudioPara audiopara = {
76 .capture = capture, .delayTime = 0, .totalTime = 0, .averageDelayTime =0,
77 };
78 ASSERT_NE(nullptr, audiopara.capture);
79 for (int i = 0; i < COUNT; ++i) {
80 gettimeofday(&audiopara.start, NULL);
81 int32_t ret = audiopara.capture->Start(audiopara.capture);
82 gettimeofday(&audiopara.end, NULL);
83 EXPECT_EQ(HDF_SUCCESS, ret);
84 audiopara.delayTime = (audiopara.end.tv_sec * MICROSECOND + audiopara.end.tv_usec) -
85 (audiopara.start.tv_sec * MICROSECOND + audiopara.start.tv_usec);
86 audiopara.totalTime += audiopara.delayTime;
87 ret = audiopara.capture->Stop(audiopara.capture);
88 EXPECT_EQ(HDF_SUCCESS, ret);
89 }
90 audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT;
91 EXPECT_GT(LOWLATENCY, audiopara.averageDelayTime);
92 }
93 /**
94 * @tc.name AudioCapturePausePerformance_001
95 * @tc.devDesc tests the performace of AudioCapturePause interface by executing 1000 times,
96 * and calculates the delay time and average of Delay Time.
97 * @tc.type: PERF
98 */
99 HWTEST_F(AudioIdlHdiCapturePerformaceTest, AudioCapturePausePerformance_001, TestSize.Level1)
100 {
101 struct PrepareAudioPara audiopara = {
102 .capture = capture, .delayTime = 0, .totalTime = 0, .averageDelayTime =0,
103 };
104 ASSERT_NE(nullptr, audiopara.capture);
105 int32_t ret = audiopara.capture->Start(audiopara.capture);
106 EXPECT_EQ(HDF_SUCCESS, ret);
107 for (int i = 0; i < COUNT; ++i) {
108 gettimeofday(&audiopara.start, NULL);
109 ret = audiopara.capture->Pause(audiopara.capture);
110 gettimeofday(&audiopara.end, NULL);
111 EXPECT_EQ(HDF_SUCCESS, ret);
112 ret = audiopara.capture->Resume(audiopara.capture);
113 EXPECT_EQ(HDF_SUCCESS, ret);
114 audiopara.delayTime = (audiopara.end.tv_sec * MICROSECOND + audiopara.end.tv_usec) -
115 (audiopara.start.tv_sec * MICROSECOND + audiopara.start.tv_usec);
116 audiopara.totalTime += audiopara.delayTime;
117 }
118 audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT;
119 EXPECT_GT(LOWLATENCY, audiopara.averageDelayTime);
120 ret = audiopara.capture->Stop(audiopara.capture);
121 EXPECT_EQ(HDF_SUCCESS, ret);
122 }
123
124 /**
125 * @tc.name AudioCaptureResumePerformance_001
126 * @tc.devDesc tests the performace of AudioCaptureResume interface by executing 1000 times,
127 * and calculates the delay time and average of Delay Time.
128 * @tc.type: PERF
129 */
130 HWTEST_F(AudioIdlHdiCapturePerformaceTest, AudioCaptureResumePerformance_001, TestSize.Level1)
131 {
132 struct PrepareAudioPara audiopara = {
133 .capture = capture, .delayTime = 0, .totalTime = 0, .averageDelayTime =0,
134 };
135 ASSERT_NE(nullptr, audiopara.capture);
136 int32_t ret = audiopara.capture->Start(audiopara.capture);
137 EXPECT_EQ(HDF_SUCCESS, ret);
138 for (int i = 0; i < COUNT; ++i) {
139 ret = audiopara.capture->Pause(audiopara.capture);
140 EXPECT_EQ(HDF_SUCCESS, ret);
141 gettimeofday(&audiopara.start, NULL);
142 ret = audiopara.capture->Resume(audiopara.capture);
143 gettimeofday(&audiopara.end, NULL);
144 ASSERT_EQ(HDF_SUCCESS, ret);
145 audiopara.delayTime = (audiopara.end.tv_sec * MICROSECOND + audiopara.end.tv_usec) -
146 (audiopara.start.tv_sec * MICROSECOND + audiopara.start.tv_usec);
147 audiopara.totalTime += audiopara.delayTime;
148 }
149 audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT;
150 EXPECT_GT(LOWLATENCY, audiopara.averageDelayTime);
151 ret = audiopara.capture->Stop(audiopara.capture);
152 EXPECT_EQ(HDF_SUCCESS, ret);
153 }
154
155 /**
156 * @tc.name AudioCaptureStopPerformance_001
157 * @tc.devDesc tests the performace of AudioCaptureStop interface by executing 1000 times,
158 * and calculates the delay time and average of Delay Time.
159 * @tc.type: PERF
160 */
161 HWTEST_F(AudioIdlHdiCapturePerformaceTest, AudioCaptureStopPerformance_001, TestSize.Level1)
162 {
163 struct PrepareAudioPara audiopara = {
164 .capture = capture, .delayTime = 0, .totalTime = 0, .averageDelayTime =0,
165 };
166 ASSERT_NE(nullptr, audiopara.capture);
167 for (int i = 0; i < COUNT; ++i) {
168 int32_t ret = audiopara.capture->Start(audiopara.capture);
169 EXPECT_EQ(HDF_SUCCESS, ret);
170 gettimeofday(&audiopara.start, NULL);
171 ret = audiopara.capture->Stop(audiopara.capture);
172 gettimeofday(&audiopara.end, NULL);
173 EXPECT_EQ(HDF_SUCCESS, ret);
174 audiopara.delayTime = (audiopara.end.tv_sec * MICROSECOND + audiopara.end.tv_usec) -
175 (audiopara.start.tv_sec * MICROSECOND + audiopara.start.tv_usec);
176 audiopara.totalTime += audiopara.delayTime;
177 }
178 audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT;
179 EXPECT_GT(LOWLATENCY, audiopara.averageDelayTime);
180 }
181
182 /**
183 * @tc.name AudioCaptureSetSampleAttributesPerformance_001
184 * @tc.devDesc tests the performace of AudioCaptureSetSampleAttributes interface by executing 1000 times,
185 * and calculates the delay time and average of Delay Time.
186 * @tc.type: PERF
187 */
188 HWTEST_F(AudioIdlHdiCapturePerformaceTest, AudioCaptureSetSampleAttributesPerformance_001, TestSize.Level1)
189 {
190 struct PrepareAudioPara audiopara = {
191 .capture = capture, .delayTime = 0, .totalTime = 0, .averageDelayTime =0,
192 };
193 ASSERT_NE(nullptr, audiopara.capture);
194 InitAttrs(audiopara.attrs);
195 for (int i = 0; i < COUNT; ++i) {
196 gettimeofday(&audiopara.start, NULL);
197 int32_t ret = audiopara.capture->SetSampleAttributes(audiopara.capture, &audiopara.attrs);
198 gettimeofday(&audiopara.end, NULL);
199 EXPECT_EQ(HDF_SUCCESS, ret);
200 audiopara.delayTime = (audiopara.end.tv_sec * MICROSECOND + audiopara.end.tv_usec) -
201 (audiopara.start.tv_sec * MICROSECOND + audiopara.start.tv_usec);
202 audiopara.totalTime += audiopara.delayTime;
203 }
204 audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT;
205 EXPECT_GT(LOWLATENCY, audiopara.averageDelayTime);
206 }
207 /**
208 * @tc.name AudioCaptureCaptureFramePerformance_001
209 * @tc.devDesc tests the performace of AudioCaptureCaptureFrame interface by executing 1000 times,
210 * and calculates the delay time and average of Delay Time.
211 * @tc.type: PERF
212 */
213 HWTEST_F(AudioIdlHdiCapturePerformaceTest, AudioCaptureCaptureFramePerformance_001, TestSize.Level1)
214 {
215 struct PrepareAudioPara audiopara = {
216 .capture = capture, .delayTime = 0, .totalTime = 0, .averageDelayTime =0,
217 .replyBytes = BUFFER, .requestBytes = BUFFER
218 };
219 ASSERT_NE(nullptr, audiopara.capture);
220 audiopara.frame = (char *)calloc(1, BUFFER);
221 ASSERT_NE(nullptr, audiopara.frame);
222 InitAttrs(audiopara.attrs);
223 audiopara.attrs.silenceThreshold = BUFFER;
224 int32_t ret = audiopara.capture->SetSampleAttributes(audiopara.capture, &audiopara.attrs);
225 ret = audiopara.capture->Start(audiopara.capture);
226 EXPECT_EQ(HDF_SUCCESS, ret);
227 for (int i = 0; i < COUNT; ++i) {
228 gettimeofday(&audiopara.start, NULL);
229 ret = audiopara.capture->CaptureFrame(audiopara.capture, (int8_t*) audiopara.frame, &audiopara.replyBytes,
230 audiopara.requestBytes);
231 gettimeofday(&audiopara.end, NULL);
232 EXPECT_EQ(HDF_SUCCESS, ret);
233 audiopara.delayTime = (audiopara.end.tv_sec * MICROSECOND + audiopara.end.tv_usec) -
234 (audiopara.start.tv_sec * MICROSECOND + audiopara.start.tv_usec);
235 audiopara.totalTime += audiopara.delayTime;
236 }
237 ret = audiopara.capture->Stop(audiopara.capture);
238 EXPECT_EQ(HDF_SUCCESS, ret);
239 audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT;
240 EXPECT_GT(NORMALLATENCY, audiopara.averageDelayTime);
241 free(audiopara.frame);
242 audiopara.frame = nullptr;
243 }
244 /**
245 * @tc.name AudioCaptureGetSampleAttributesPerformance_001
246 * @tc.devDesc tests the performace of AudioCaptureGetSampleAttributes interface by executing 1000 times,
247 * and calculates the delay time and average of Delay Time.
248 * @tc.type: PERF
249 */
250 HWTEST_F(AudioIdlHdiCapturePerformaceTest, AudioCaptureGetSampleAttributesPerformance_001, TestSize.Level1)
251 {
252 struct PrepareAudioPara audiopara = {
253 .capture = capture, .delayTime = 0, .totalTime = 0, .averageDelayTime =0,
254 };
255 ASSERT_NE(nullptr, audiopara.capture);
256 InitAttrs(audiopara.attrs);
257 int32_t ret = audiopara.capture->SetSampleAttributes(audiopara.capture, &audiopara.attrs);
258 EXPECT_EQ(HDF_SUCCESS, ret);
259 for (int i = 0; i < COUNT; ++i) {
260 gettimeofday(&audiopara.start, NULL);
261 ret = audiopara.capture->GetSampleAttributes(audiopara.capture, &audiopara.attrsValue);
262 gettimeofday(&audiopara.end, NULL);
263 EXPECT_EQ(HDF_SUCCESS, ret);
264 audiopara.delayTime = (audiopara.end.tv_sec * MICROSECOND + audiopara.end.tv_usec) -
265 (audiopara.start.tv_sec * MICROSECOND + audiopara.start.tv_usec);
266 audiopara.totalTime += audiopara.delayTime;
267 }
268 audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT;
269 EXPECT_GT(LOWLATENCY, audiopara.averageDelayTime);
270 }
271
272 /**
273 * @tc.name AudioCaptureSetMutePerformance_001
274 * @tc.devDesc tests the performace of AudioCaptureSetMute interface by executing 1000 times,
275 * and calculates the delay time and average of Delay Time.
276 * @tc.type: PERF
277 */
278
279 HWTEST_F(AudioIdlHdiCapturePerformaceTest, AudioCaptureSetMutePerformance_001, TestSize.Level1)
280 {
281 struct PrepareAudioPara audiopara = {
282 .capture = capture, .delayTime = 0, .totalTime = 0, .averageDelayTime =0,
283 };
284 ASSERT_NE(nullptr, audiopara.capture);
285 for (int i = 0; i < COUNT; ++i) {
286 gettimeofday(&audiopara.start, NULL);
287 int32_t ret = audiopara.capture->SetMute(audiopara.capture, false);
288 gettimeofday(&audiopara.end, NULL);
289 EXPECT_EQ(HDF_SUCCESS, ret);
290 audiopara.delayTime = (audiopara.end.tv_sec * MICROSECOND + audiopara.end.tv_usec) -
291 (audiopara.start.tv_sec * MICROSECOND + audiopara.start.tv_usec);
292 audiopara.totalTime += audiopara.delayTime;
293 ret = audiopara.capture->GetMute(audiopara.capture, &audiopara.character.getmute);
294 EXPECT_EQ(HDF_SUCCESS, ret);
295 EXPECT_FALSE(audiopara.character.getmute);
296 }
297 audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT;
298 EXPECT_GT(LOWLATENCY, audiopara.averageDelayTime);
299 }
300
301 /**
302 * @tc.name AudioCaptureGetMutePerformance_001
303 * @tc.devDesc tests the performace of AudioCaptureGetMute interface by executing 1000 times,
304 * and calculates the delay time and average of Delay Time.
305 * @tc.type: PERF
306 */
307 HWTEST_F(AudioIdlHdiCapturePerformaceTest, AudioCaptureGetMutePerformance_001, TestSize.Level1)
308 {
309 struct PrepareAudioPara audiopara = {
310 .capture = capture, .delayTime = 0, .totalTime = 0, .averageDelayTime =0,
311 };
312 ASSERT_NE(nullptr, audiopara.capture);
313 int32_t ret = audiopara.capture->SetMute(audiopara.capture, false);
314 EXPECT_EQ(HDF_SUCCESS, ret);
315 for (int i = 0; i < COUNT; ++i) {
316 gettimeofday(&audiopara.start, NULL);
317 ret = audiopara.capture->GetMute(audiopara.capture, &audiopara.character.getmute);
318 gettimeofday(&audiopara.end, NULL);
319 EXPECT_EQ(HDF_SUCCESS, ret);
320 EXPECT_FALSE(audiopara.character.getmute);
321 audiopara.delayTime = (audiopara.end.tv_sec * MICROSECOND + audiopara.end.tv_usec) -
322 (audiopara.start.tv_sec * MICROSECOND + audiopara.start.tv_usec);
323 audiopara.totalTime += audiopara.delayTime;
324 }
325 audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT;
326 EXPECT_GT(LOWLATENCY, audiopara.averageDelayTime);
327 }
328
329 /**
330 * @tc.name AudioCaptureSetVolumePerformance_001
331 * @tc.devDesc tests the performace of AudioCaptureSetVolume interface by executing 1000 times,
332 * and calculates the delay time and average of Delay Time.
333 * @tc.type: PERF
334 */
335 HWTEST_F(AudioIdlHdiCapturePerformaceTest, AudioCaptureSetVolumePerformance_001, TestSize.Level1)
336 {
337 struct PrepareAudioPara audiopara = {
338 .capture = capture, .delayTime = 0, .totalTime = 0, .averageDelayTime =0, .character.setvolume = 0.7
339 };
340 ASSERT_NE(nullptr, audiopara.capture);
341 for (int i = 0; i < COUNT; ++i) {
342 gettimeofday(&audiopara.start, NULL);
343 int32_t ret = audiopara.capture->SetVolume(audiopara.capture, audiopara.character.setvolume);
344 gettimeofday(&audiopara.end, NULL);
345 EXPECT_EQ(HDF_SUCCESS, ret);
346 ret = audiopara.capture->GetVolume(audiopara.capture, &audiopara.character.getvolume);
347 EXPECT_EQ(HDF_SUCCESS, ret);
348 EXPECT_EQ(audiopara.character.setvolume, audiopara.character.getvolume);
349 audiopara.delayTime = (audiopara.end.tv_sec * MICROSECOND + audiopara.end.tv_usec) -
350 (audiopara.start.tv_sec * MICROSECOND + audiopara.start.tv_usec);
351 audiopara.totalTime += audiopara.delayTime;
352 }
353 audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT;
354 EXPECT_GT(LOWLATENCY, audiopara.averageDelayTime);
355 }
356
357 /**
358 * @tc.name AudioCaptureGetVolumePerformance_001
359 * @tc.devDesc tests the performace of AudioCaptureGetVolume interface by executing 1000 times,
360 * and calculates the delay time and average of Delay Time.
361 * @tc.type: PERF
362 */
363 HWTEST_F(AudioIdlHdiCapturePerformaceTest, AudioCaptureGetVolumePerformance_001, TestSize.Level1)
364 {
365 struct PrepareAudioPara audiopara = {
366 .capture = capture, .delayTime = 0, .totalTime = 0, .averageDelayTime =0, .character.setvolume = 0.8
367 };
368 ASSERT_NE(nullptr, audiopara.capture);
369 int32_t ret = audiopara.capture->SetVolume(audiopara.capture, audiopara.character.setvolume);
370 EXPECT_EQ(HDF_SUCCESS, ret);
371 for (int i = 0; i < COUNT; ++i) {
372 gettimeofday(&audiopara.start, NULL);
373 ret = audiopara.capture->GetVolume(audiopara.capture, &audiopara.character.getvolume);
374 gettimeofday(&audiopara.end, NULL);
375 EXPECT_EQ(HDF_SUCCESS, ret);
376 EXPECT_EQ(audiopara.character.setvolume, audiopara.character.getvolume);
377 audiopara.delayTime = (audiopara.end.tv_sec * MICROSECOND + audiopara.end.tv_usec) -
378 (audiopara.start.tv_sec * MICROSECOND + audiopara.start.tv_usec);
379 audiopara.totalTime += audiopara.delayTime;
380 }
381 audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT;
382 EXPECT_GT(LOWLATENCY, audiopara.averageDelayTime);
383 }
384
385 /**
386 * @tc.name AudioCaptureGetGainPerformance_001
387 * @tc.devDesc tests the performace of AudioCaptureGetGain interface by executing 1000 times,
388 * and calculates the delay time and average of Delay Time.
389 * @tc.type: PERF
390 */
391 HWTEST_F(AudioIdlHdiCapturePerformaceTest, AudioCaptureGetGainPerformance_001, TestSize.Level1)
392 {
393 struct PrepareAudioPara audiopara = {
394 .capture = capture, .delayTime = 0, .totalTime = 0, .averageDelayTime =0, .character.setgain = 7
395 };
396 ASSERT_NE(nullptr, audiopara.capture);
397 int32_t ret = audiopara.capture->SetGain(audiopara.capture, audiopara.character.setgain);
398 EXPECT_EQ(HDF_SUCCESS, ret);
399 for (int i = 0; i < COUNT; ++i) {
400 gettimeofday(&audiopara.start, NULL);
401 ret = audiopara.capture->GetGain(audiopara.capture, &audiopara.character.getgain);
402 gettimeofday(&audiopara.end, NULL);
403 EXPECT_EQ(HDF_SUCCESS, ret);
404 EXPECT_EQ(audiopara.character.setgain, audiopara.character.getgain);
405 audiopara.delayTime = (audiopara.end.tv_sec * MICROSECOND + audiopara.end.tv_usec) -
406 (audiopara.start.tv_sec * MICROSECOND + audiopara.start.tv_usec);
407 audiopara.totalTime += audiopara.delayTime;
408 }
409 audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT;
410 EXPECT_GT(LOWLATENCY, audiopara.averageDelayTime);
411 }
412
413 /**
414 * @tc.name AudioCaptureSetGainPerformance_001
415 * @tc.devDesc tests the performace of AudioCaptureSetGain interface by executing 1000 times,
416 * and calculates the delay time and average of Delay Time.
417 * @tc.type: PERF
418 */
419 HWTEST_F(AudioIdlHdiCapturePerformaceTest, AudioCaptureSetGainPerformance_001, TestSize.Level1)
420 {
421 struct PrepareAudioPara audiopara = {
422 .capture = capture, .delayTime = 0, .totalTime = 0, .averageDelayTime =0, .character.setgain = 8
423 };
424 ASSERT_NE(nullptr, audiopara.capture);
425 for (int i = 0; i < COUNT; ++i) {
426 gettimeofday(&audiopara.start, NULL);
427 int32_t ret = audiopara.capture->SetGain(audiopara.capture, audiopara.character.setgain);
428 gettimeofday(&audiopara.end, NULL);
429 EXPECT_EQ(HDF_SUCCESS, ret);
430 ret = audiopara.capture->GetGain(audiopara.capture, &audiopara.character.getgain);
431 EXPECT_EQ(HDF_SUCCESS, ret);
432 EXPECT_EQ(audiopara.character.setgain, audiopara.character.getgain);
433 audiopara.delayTime = (audiopara.end.tv_sec * MICROSECOND + audiopara.end.tv_usec) -
434 (audiopara.start.tv_sec * MICROSECOND + audiopara.start.tv_usec);
435 audiopara.totalTime += audiopara.delayTime;
436 }
437 audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT;
438 EXPECT_GT(LOWLATENCY, audiopara.averageDelayTime);
439 }
440
441 /**
442 * @tc.name AudioCaptureGetCurrentChannelIdPerformance_001
443 * @tc.devDesc tests the performace of AudioCaptureGetCurrentChannelId interface by executing 1000 times,
444 * and calculates the delay time and average of Delay Time.
445 * @tc.type: PERF
446 */
447 HWTEST_F(AudioIdlHdiCapturePerformaceTest, AudioCaptureGetCurrentChannelIdPerformance_001, TestSize.Level1)
448 {
449 struct PrepareAudioPara audiopara = {
450 .capture = capture, .delayTime = 0, .totalTime = 0, .averageDelayTime =0
451 };
452 ASSERT_NE(nullptr, audiopara.capture);
453 for (int i = 0; i < COUNT; ++i) {
454 gettimeofday(&audiopara.start, NULL);
455 int32_t ret = audiopara.capture->GetCurrentChannelId(audiopara.capture,
456 &audiopara.character.getcurrentchannelId);
457 gettimeofday(&audiopara.end, NULL);
458 EXPECT_EQ(HDF_SUCCESS, ret);
459 audiopara.delayTime = (audiopara.end.tv_sec * MICROSECOND + audiopara.end.tv_usec) -
460 (audiopara.start.tv_sec * MICROSECOND + audiopara.start.tv_usec);
461 audiopara.totalTime += audiopara.delayTime;
462 }
463 audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT;
464 EXPECT_GT(LOWLATENCY, audiopara.averageDelayTime);
465 }
466
467 /**
468 * @tc.name AudioCaptureGetFrameCountPerformance_001
469 * @tc.devDesc tests the performace of AudioCaptureGetFrameCount interface by executing 1000 times,
470 * and calculates the delay time and average of Delay Time.
471 * @tc.type: PERF
472 */
473 HWTEST_F(AudioIdlHdiCapturePerformaceTest, AudioCaptureGetFrameCountPerformance_001, TestSize.Level1)
474 {
475 struct PrepareAudioPara audiopara = {
476 .capture = capture, .delayTime = 0, .totalTime = 0, .averageDelayTime =0
477 };
478 ASSERT_NE(nullptr, audiopara.capture);
479 for (int i = 0; i < COUNT; ++i) {
480 gettimeofday(&audiopara.start, NULL);
481 int32_t ret = audiopara.capture->GetFrameCount(audiopara.capture, &audiopara.character.getframecount);
482 gettimeofday(&audiopara.end, NULL);
483 EXPECT_EQ(HDF_SUCCESS, ret);
484 EXPECT_EQ(INITIAL_VALUE, audiopara.character.getframecount);
485 audiopara.delayTime = (audiopara.end.tv_sec * MICROSECOND + audiopara.end.tv_usec) -
486 (audiopara.start.tv_sec * MICROSECOND + audiopara.start.tv_usec);
487 audiopara.totalTime += audiopara.delayTime;
488 }
489 audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT;
490 EXPECT_GT(LOWLATENCY, audiopara.averageDelayTime);
491 }
492
493 /**
494 * @tc.name AudioCaptureGetFrameSizePerformance_001
495 * @tc.devDesc tests the performace of AudioCaptureGetFrameSize interface by executing 1000 times,
496 * and calculates the delay time and average of Delay Time.
497 * @tc.type: PERF
498 */
499 HWTEST_F(AudioIdlHdiCapturePerformaceTest, AudioCaptureGetFrameSizePerformance_001, TestSize.Level1)
500 {
501 struct PrepareAudioPara audiopara = {
502 .capture = capture, .delayTime = 0, .totalTime = 0, .averageDelayTime =0
503 };
504 ASSERT_NE(nullptr, audiopara.capture);
505 for (int i = 0; i < COUNT; ++i) {
506 gettimeofday(&audiopara.start, NULL);
507 int32_t ret = audiopara.capture->GetFrameSize(audiopara.capture, &audiopara.character.getframesize);
508 gettimeofday(&audiopara.end, NULL);
509 EXPECT_EQ(HDF_SUCCESS, ret);
510 EXPECT_GT(audiopara.character.getframesize, INITIAL_VALUE);
511 audiopara.delayTime = (audiopara.end.tv_sec * MICROSECOND + audiopara.end.tv_usec) -
512 (audiopara.start.tv_sec * MICROSECOND + audiopara.start.tv_usec);
513 audiopara.totalTime += audiopara.delayTime;
514 }
515 audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT;
516 EXPECT_GT(LOWLATENCY, audiopara.averageDelayTime);
517 }
518
519 /**
520 * @tc.name AudioCaptureFlushPerformance_001
521 * @tc.devDesc tests the performace of AudioCaptureFlush interface by executing 1000 times,
522 * and calculates the delay time and average of Delay Time.
523 * @tc.type: PERF
524 */
525 HWTEST_F(AudioIdlHdiCapturePerformaceTest, AudioCaptureFlushPerformance_001, TestSize.Level1)
526 {
527 struct PrepareAudioPara audiopara = {
528 .capture = capture, .delayTime = 0, .totalTime = 0, .averageDelayTime =0
529 };
530 ASSERT_NE(nullptr, audiopara.capture);
531 for (int i = 0; i < COUNT; ++i) {
532 int32_t ret = audiopara.capture->Start(audiopara.capture);
533 EXPECT_EQ(HDF_SUCCESS, ret);
534 gettimeofday(&audiopara.start, NULL);
535 ret = audiopara.capture->Flush(audiopara.capture);
536 gettimeofday(&audiopara.end, NULL);
537 EXPECT_EQ(HDF_ERR_NOT_SUPPORT, ret);
538 audiopara.delayTime = (audiopara.end.tv_sec * MICROSECOND + audiopara.end.tv_usec) -
539 (audiopara.start.tv_sec * MICROSECOND + audiopara.start.tv_usec);
540 audiopara.totalTime += audiopara.delayTime;
541 ret = audiopara.capture->Stop(audiopara.capture);
542 EXPECT_EQ(HDF_SUCCESS, ret);
543 }
544 audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT;
545 EXPECT_GT(LOWLATENCY, audiopara.averageDelayTime);
546 }
547
548 /**
549 * @tc.name AudioCaptureGetGainThresholdPerformance_001
550 * @tc.devDesc tests the performace of AudioCaptureGetGainThreshold interface by executing 1000 times,
551 * and calculates the delay time and average of Delay Time.
552 * @tc.type: PERF
553 */
554 HWTEST_F(AudioIdlHdiCapturePerformaceTest, AudioCaptureGetGainThresholdPerformance_001, TestSize.Level1)
555 {
556 struct PrepareAudioPara audiopara = {
557 .capture = capture, .delayTime = 0, .totalTime = 0, .averageDelayTime =0
558 };
559 ASSERT_NE(nullptr, audiopara.capture);
560 for (int i = 0; i < COUNT; ++i) {
561 gettimeofday(&audiopara.start, NULL);
562 int32_t ret = audiopara.capture->GetGainThreshold(audiopara.capture, &audiopara.character.gainthresholdmin,
563 &audiopara.character.gainthresholdmax);
564 gettimeofday(&audiopara.end, NULL);
565 EXPECT_EQ(HDF_SUCCESS, ret);
566 EXPECT_EQ(audiopara.character.gainthresholdmin, GAIN_MIN);
567 EXPECT_EQ(audiopara.character.gainthresholdmax, GAIN_MAX);
568 audiopara.delayTime = (audiopara.end.tv_sec * MICROSECOND + audiopara.end.tv_usec) -
569 (audiopara.start.tv_sec * MICROSECOND + audiopara.start.tv_usec);
570 audiopara.totalTime += audiopara.delayTime;
571 }
572 audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT;
573 EXPECT_GT(LOWLATENCY, audiopara.averageDelayTime);
574 }
575
576 /**
577 * @tc.name AudioCaptureCheckSceneCapabilityPerformance_001
578 * @tc.devDesc tests the performace of AudioCaptureCheckSceneCapability interface by executing 1000 times,
579 * and calculates the delay time and average of Delay Time.
580 * @tc.type: PERF
581 */
582 HWTEST_F(AudioIdlHdiCapturePerformaceTest, AudioCaptureCheckSceneCapabilityPerformance_001,
583 TestSize.Level1)
584 {
585 struct PrepareAudioPara audiopara = {
586 .capture = capture, .delayTime = 0, .totalTime = 0, .averageDelayTime =0
587 };
588 ASSERT_NE(nullptr, audiopara.capture);
589 struct AudioSceneDescriptor scenes = { .scene.id = 0, .desc.pins = PIN_IN_MIC };
590 bool supported = false;
591 for (int i = 0; i < COUNT; ++i) {
592 scenes.desc.desc = strdup("mic");
593 gettimeofday(&audiopara.start, NULL);
594 int32_t ret = audiopara.capture->CheckSceneCapability(audiopara.capture, &scenes, &supported);
595 gettimeofday(&audiopara.end, NULL);
596 free(scenes.desc.desc);
597 EXPECT_EQ(HDF_SUCCESS, ret);
598 audiopara.delayTime = (audiopara.end.tv_sec * MICROSECOND + audiopara.end.tv_usec) -
599 (audiopara.start.tv_sec * MICROSECOND + audiopara.start.tv_usec);
600 audiopara.totalTime += audiopara.delayTime;
601 }
602 audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT;
603 EXPECT_GT(LOWLATENCY, audiopara.averageDelayTime);
604 }
605
606 /**
607 * @tc.name AudioCaptureSelectScenePerformance_001
608 * @tc.devDesc tests the performace of AudioCaptureSelectScene interface by executing 1000 times,
609 * and calculates the delay time and average of Delay Time.
610 * @tc.type: PERF
611 */
612 HWTEST_F(AudioIdlHdiCapturePerformaceTest, AudioCaptureSelectScenePerformance_001, TestSize.Level1)
613 {
614 struct PrepareAudioPara audiopara = {
615 .capture = capture, .delayTime = 0, .totalTime = 0, .averageDelayTime =0
616 };
617 ASSERT_NE(nullptr, audiopara.capture);
618 struct AudioSceneDescriptor scenes = { .scene.id = 0, .desc.pins = PIN_IN_MIC };
619 for (int i = 0; i < COUNT; ++i) {
620 scenes.desc.desc = strdup("mic");
621 gettimeofday(&audiopara.start, NULL);
622 int32_t ret = audiopara.capture->SelectScene(audiopara.capture, &scenes);
623 gettimeofday(&audiopara.end, NULL);
624 EXPECT_EQ(HDF_SUCCESS, ret);
625 audiopara.delayTime = (audiopara.end.tv_sec * MICROSECOND + audiopara.end.tv_usec) -
626 (audiopara.start.tv_sec * MICROSECOND + audiopara.start.tv_usec);
627 audiopara.totalTime += audiopara.delayTime;
628 free(scenes.desc.desc);
629 }
630 audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT;
631 EXPECT_GT(LOWLATENCY, audiopara.averageDelayTime);
632 }
633
634 /**
635 * @tc.name AudioGetCapturePositionPerformance_001
636 * @tc.devDesc tests the performace of AudioCaptureGetCapturePosition interface by executing 1000 times,
637 * and calculates the delay time and average of Delay Time.
638 * @tc.type: PERF
639 */
640 HWTEST_F(AudioIdlHdiCapturePerformaceTest, AudioGetCapturePositionPerformance_001, TestSize.Level1)
641 {
642 struct PrepareAudioPara audiopara = {
643 .capture = capture, .delayTime = 0, .totalTime = 0, .averageDelayTime =0
644 };
645 ASSERT_NE(nullptr, audiopara.capture);
646 int32_t ret = audiopara.capture->Start(audiopara.capture);
647 EXPECT_EQ(HDF_SUCCESS, ret);
648 for (int i = 0; i < COUNT; ++i) {
649 gettimeofday(&audiopara.start, NULL);
650 ret = audiopara.capture->GetCapturePosition(audiopara.capture, &audiopara.character.getframes, &audiopara.time);
651 gettimeofday(&audiopara.end, NULL);
652 EXPECT_EQ(HDF_SUCCESS, ret);
653 audiopara.delayTime = (audiopara.end.tv_sec * MICROSECOND + audiopara.end.tv_usec) -
654 (audiopara.start.tv_sec * MICROSECOND + audiopara.start.tv_usec);
655 audiopara.totalTime += audiopara.delayTime;
656 }
657 audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT;
658 EXPECT_GT(LOWLATENCY, audiopara.averageDelayTime);
659 }
660
661 /**
662 * @tc.name AudioCaptureSetExtraParamsPerformance_001
663 * @tc.desc tests the performace of AudioCaptureSetExtraParams interface by executing 1000 times,
664 * and calculates the delay time and average of Delay Time.
665 * @tc.type: PERF
666 */
667 HWTEST_F(AudioIdlHdiCapturePerformaceTest, AudioCaptureSetExtraParamsPerformance_001, TestSize.Level1)
668 {
669 char keyValueList[] = "attr-route=1;attr-format=32;attr-channels=2;attr-frame-count=82;attr-sampling-rate=48000";
670 struct PrepareAudioPara audiopara = {
671 .capture = capture, .delayTime = 0, .totalTime = 0, .averageDelayTime =0
672 };
673 ASSERT_NE(nullptr, audiopara.capture);
674 for (int i = 0; i < COUNT; ++i) {
675 gettimeofday(&audiopara.start, NULL);
676 int32_t ret = audiopara.capture->SetExtraParams(audiopara.capture, keyValueList);
677 gettimeofday(&audiopara.end, NULL);
678 EXPECT_EQ(HDF_SUCCESS, ret);
679 audiopara.delayTime = (audiopara.end.tv_sec * MICROSECOND + audiopara.end.tv_usec) -
680 (audiopara.start.tv_sec * MICROSECOND + audiopara.start.tv_usec);
681 audiopara.totalTime += audiopara.delayTime;
682 }
683 audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT;
684 EXPECT_GT(LOWLATENCY, audiopara.averageDelayTime);
685 }
686
687 /**
688 * @tc.name AudioCaptureGetExtraParamsPerformance_001
689 * @tc.desc tests the performace of AudioCaptureGetExtraParams interface by executing 1000 times,
690 * and calculates the delay time and average of Delay Time.
691 * @tc.type: PERF
692 */
693 HWTEST_F(AudioIdlHdiCapturePerformaceTest, AudioCaptureGetExtraParamsPerformance_001, TestSize.Level1)
694 {
695 struct PrepareAudioPara audiopara = {
696 .capture = capture, .delayTime = 0, .totalTime = 0, .averageDelayTime =0
697 };
698 ASSERT_NE(nullptr, audiopara.capture);
699 char keyValueList[] = "attr-format=24;attr-frame-count=4096;";
700 char keyValueListExp[] = "attr-route=0;attr-format=24;attr-channels=2;\
701 attr-frame-count=4096;attr-sampling-rate=48000";
702 int32_t listLenth = 256;
703 int32_t ret = audiopara.capture->SetExtraParams(audiopara.capture, keyValueList);
704 EXPECT_EQ(HDF_SUCCESS, ret);
705 for (int i = 0; i < COUNT; ++i) {
706 char keyValueListValue[256] = {};
707 gettimeofday(&audiopara.start, NULL);
708 ret = audiopara.capture->GetExtraParams(audiopara.capture, keyValueListValue, listLenth);
709 gettimeofday(&audiopara.end, NULL);
710 EXPECT_EQ(HDF_SUCCESS, ret);
711 EXPECT_STREQ(keyValueListExp, keyValueListValue);
712 audiopara.delayTime = (audiopara.end.tv_sec * MICROSECOND + audiopara.end.tv_usec) -
713 (audiopara.start.tv_sec * MICROSECOND + audiopara.start.tv_usec);
714 audiopara.totalTime += audiopara.delayTime;
715 }
716 audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT;
717 EXPECT_GT(LOWLATENCY, audiopara.averageDelayTime);
718 }
719
720 /**
721 * @tc.name AudioCaptureGetMmapPositionPerformance_001
722 * @tc.desc tests the performace of AudioCaptureGetMmapPosition interface by executing 1000 times,
723 * and calculates the delay time and average of Delay Time.
724 * @tc.type: PERF
725 */
726 HWTEST_F(AudioIdlHdiCapturePerformaceTest, AudioCaptureGetMmapPositionPerformance_001, TestSize.Level1)
727 {
728 uint64_t frames = 0;
729 int64_t timeExp = 0;
730 struct PrepareAudioPara audiopara = {
731 .capture = capture, .delayTime = 0, .totalTime = 0, .averageDelayTime =0
732 };
733 ASSERT_NE(nullptr, audiopara.capture);
734 for (int i = 0; i < COUNT; ++i) {
735 gettimeofday(&audiopara.start, NULL);
736 int32_t ret = audiopara.capture->GetMmapPosition(audiopara.capture, &frames, &(audiopara.time));
737 gettimeofday(&audiopara.end, NULL);
738 EXPECT_EQ(HDF_SUCCESS, ret);
739 EXPECT_EQ((audiopara.time.tvSec) * SECTONSEC + (audiopara.time.tvNSec), timeExp);
740 EXPECT_EQ(frames, INITIAL_VALUE);
741 audiopara.delayTime = (audiopara.end.tv_sec * MICROSECOND + audiopara.end.tv_usec) -
742 (audiopara.start.tv_sec * MICROSECOND + audiopara.start.tv_usec);
743 audiopara.totalTime += audiopara.delayTime;
744 }
745 audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT;
746 EXPECT_GT(LOWLATENCY, audiopara.averageDelayTime);
747 }
748 }