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