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 #include "osal_mem.h"
19 
20 using namespace std;
21 using namespace testing::ext;
22 using namespace OHOS::Audio;
23 
24 namespace {
25 const float COUNT = 1000;             // number of interface calls
26 const int32_t LOWLATENCY = 10000;     // low interface delay:10ms
27 const int32_t NORMALLATENCY = 30000;  // normal interface delay:30ms
28 
29 class AudioIdlHdiRenderPerformaceTest : 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 IAudioRender *render = nullptr;
38     uint32_t renderId_ = 0;
39 };
40 using THREAD_FUNC = void *(*)(void *);
41 TestAudioManager *AudioIdlHdiRenderPerformaceTest::manager = nullptr;
42 
SetUpTestCase(void)43 void AudioIdlHdiRenderPerformaceTest::SetUpTestCase(void)
44 {
45     manager = IAudioManagerGet(IS_STUB);
46     ASSERT_NE(nullptr, manager);
47 }
48 
TearDownTestCase(void)49 void AudioIdlHdiRenderPerformaceTest::TearDownTestCase(void)
50 {
51     if (manager != nullptr) {
52         (void)IAudioManagerRelease(manager, IS_STUB);
53     }
54 }
55 
SetUp(void)56 void AudioIdlHdiRenderPerformaceTest::SetUp(void)
57 {
58     ASSERT_NE(nullptr, manager);
59     int32_t ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME, &adapter, &render, &renderId_);
60     ASSERT_EQ(HDF_SUCCESS, ret);
61 }
62 
TearDown(void)63 void AudioIdlHdiRenderPerformaceTest::TearDown(void)
64 {
65     int32_t ret = ReleaseRenderSource(manager, adapter, render, renderId_);
66     ASSERT_EQ(HDF_SUCCESS, ret);
67 }
68 /**
69 * @tc.name  AudioRenderGetLatencyPerformance_001
70 * @tc.desc  tests the performace of RenderGetLatency interface by executing 1000 times,
71 * and calculates the delay time and average of Delay Time.
72 * @tc.type: PERF
73 */
74 HWTEST_F(AudioIdlHdiRenderPerformaceTest, AudioRenderGetLatencyPerformance_001, TestSize.Level1)
75 {
76     int32_t ret;
77     uint32_t latencyTime = 0;
78     uint32_t expectLatency = 0;
79     struct PrepareAudioPara audiopara = {
80         .render = render, .delayTime = 0, .totalTime = 0, .averageDelayTime =0
81     };
82     ASSERT_NE(nullptr, audiopara.render);
83     ret = AudioRenderStartAndOneFrame(audiopara.render);
84     EXPECT_EQ(HDF_SUCCESS, ret);
85 
86     for (int i = 0; i < COUNT; ++i) {
87         if (audiopara.render != nullptr) {
88             gettimeofday(&audiopara.start, NULL);
89             ret = audiopara.render->GetLatency(audiopara.render, &latencyTime);
90             gettimeofday(&audiopara.end, NULL);
91             EXPECT_EQ(HDF_SUCCESS, ret);
92             EXPECT_LT(expectLatency, latencyTime);
93             audiopara.delayTime = (audiopara.end.tv_sec * MICROSECOND + audiopara.end.tv_usec) -
94                                   (audiopara.start.tv_sec * MICROSECOND + audiopara.start.tv_usec);
95             audiopara.totalTime += audiopara.delayTime;
96         }
97     }
98     audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT;
99     EXPECT_GT(LOWLATENCY, audiopara.averageDelayTime);
100     ret = audiopara.render->Stop(audiopara.render);
101     EXPECT_EQ(HDF_SUCCESS, ret);
102 }
103 /**
104 * @tc.name  AudioRenderGetRenderPositionPerformance_001
105 * @tc.desc  tests the performace of RenderGetRenderPosition interface by executing 1000 times,
106 *           and calculates the delay time and average of Delay Time.
107 * @tc.type: PERF
108 */
109 HWTEST_F(AudioIdlHdiRenderPerformaceTest, AudioRenderGetRenderPositionPerformance_001, TestSize.Level1)
110 {
111     int32_t ret;
112     uint64_t frames = 0;
113     int64_t timeExp = 0;
114     struct PrepareAudioPara audiopara = {
115         .render = render, .path = AUDIO_FILE.c_str(), .delayTime = 0, .totalTime = 0, .averageDelayTime =0,
116     };
117     ASSERT_NE(nullptr, audiopara.render);
118     ret = pthread_create(&audiopara.tids, NULL, (THREAD_FUNC)PlayAudioFile, &audiopara);
119     EXPECT_EQ(HDF_SUCCESS, ret);
120     sleep(1);
121     for (int i = 0; i < COUNT; ++i) {
122         gettimeofday(&audiopara.start, NULL);
123         ret = audiopara.render->GetRenderPosition(audiopara.render, &frames, &audiopara.time);
124         gettimeofday(&audiopara.end, NULL);
125         EXPECT_EQ(HDF_SUCCESS, ret);
126         EXPECT_GT((audiopara.time.tvSec) * SECTONSEC + (audiopara.time.tvNSec), timeExp);
127         EXPECT_GT(frames, INITIAL_VALUE);
128         audiopara.delayTime = (audiopara.end.tv_sec * MICROSECOND + audiopara.end.tv_usec) -
129                                 (audiopara.start.tv_sec * MICROSECOND + audiopara.start.tv_usec);
130         audiopara.totalTime += audiopara.delayTime;
131     }
132     audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT;
133     EXPECT_GT(LOWLATENCY, audiopara.averageDelayTime);
134     ret = ThreadRelease(audiopara);
135     EXPECT_EQ(HDF_SUCCESS, ret);
136 }
137 /**
138 * @tc.name  AudioRenderSetRenderSpeedPerformance_001
139 * @tc.desc  tests the performace of RenderSetRenderSpeed interface by executing 1000 times,
140 *           and calculates the delay time and average of Delay Time.
141 * @tc.type: PERF
142 */
143 HWTEST_F(AudioIdlHdiRenderPerformaceTest, AudioRenderSetRenderSpeedPerformance_001, TestSize.Level1)
144 {
145     struct PrepareAudioPara audiopara = {
146         .render = render, .delayTime = 0, .totalTime = 0, .averageDelayTime =0,
147     };
148     ASSERT_NE(nullptr, audiopara.render);
149     int32_t ret = AudioRenderStartAndOneFrame(audiopara.render);
150     EXPECT_EQ(HDF_SUCCESS, ret);
151 
152     for (int i = 0; i < COUNT; ++i) {
153         float speed = 0;
154         gettimeofday(&audiopara.start, NULL);
155         ret = audiopara.render->SetRenderSpeed(audiopara.render, speed);
156         gettimeofday(&audiopara.end, NULL);
157         EXPECT_EQ(HDF_ERR_NOT_SUPPORT, ret);
158         audiopara.delayTime = (audiopara.end.tv_sec * MICROSECOND + audiopara.end.tv_usec) -
159                               (audiopara.start.tv_sec * MICROSECOND + audiopara.start.tv_usec);
160         audiopara.totalTime += audiopara.delayTime;
161         ret = audiopara.render->GetRenderSpeed(audiopara.render, &speed);
162         EXPECT_EQ(HDF_ERR_NOT_SUPPORT, ret);
163     }
164     audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT;
165     EXPECT_GT(LOWLATENCY, audiopara.averageDelayTime);
166     ret = audiopara.render->Stop(audiopara.render);
167     EXPECT_EQ(HDF_SUCCESS, ret);
168 }
169 /**
170 * @tc.name  AudioRenderGetRenderSpeedPerformance_001
171 * @tc.desc  tests the performace of RenderGetRenderSpeed interface by executing 1000 times,
172 *           and calculates the delay time and average of Delay Time.
173 * @tc.type: PERF
174 */
175 HWTEST_F(AudioIdlHdiRenderPerformaceTest, AudioAudioRenderGetRenderSpeedPerformance_001, TestSize.Level1)
176 {
177     int32_t ret;
178     struct PrepareAudioPara audiopara = {
179         .render = render, .delayTime = 0, .totalTime = 0, .averageDelayTime =0,
180     };
181     ASSERT_NE(nullptr, audiopara.render);
182     ret = AudioRenderStartAndOneFrame(audiopara.render);
183     EXPECT_EQ(HDF_SUCCESS, ret);
184     for (int i = 0; i < COUNT; ++i) {
185         float speed = 0;
186         gettimeofday(&audiopara.start, NULL);
187         ret = audiopara.render->GetRenderSpeed(audiopara.render, &speed);
188         gettimeofday(&audiopara.end, NULL);
189         EXPECT_EQ(HDF_ERR_NOT_SUPPORT, ret);
190         audiopara.delayTime = (audiopara.end.tv_sec * MICROSECOND + audiopara.end.tv_usec) -
191                               (audiopara.start.tv_sec * MICROSECOND + audiopara.start.tv_usec);
192         audiopara.totalTime += audiopara.delayTime;
193     }
194     audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT;
195     EXPECT_GT(LOWLATENCY, audiopara.averageDelayTime);
196     ret = audiopara.render->Stop(audiopara.render);
197     EXPECT_EQ(HDF_SUCCESS, ret);
198 }
199 /**
200 * @tc.name  AudioRenderSetChannelModePerformance_001
201 * @tc.desc  tests the performace of RenderSetChannelMode interface by executing 1000 times,
202 *           and calculates the delay time and average of Delay Time.
203 * @tc.type: PERF
204 */
205 HWTEST_F(AudioIdlHdiRenderPerformaceTest, AudioRenderSetChannelModePerformance_001, TestSize.Level1)
206 {
207     int32_t ret;
208     AudioChannelMode mode = AUDIO_CHANNEL_NORMAL;
209     struct PrepareAudioPara audiopara = {
210         .render = render, .delayTime = 0, .totalTime = 0, .averageDelayTime =0,
211     };
212     ASSERT_NE(nullptr, audiopara.render);
213 
214     for (int i = 0; i < COUNT; ++i) {
215         gettimeofday(&audiopara.start, NULL);
216         ret = audiopara.render->SetChannelMode(audiopara.render, mode);
217         gettimeofday(&audiopara.end, NULL);
218         EXPECT_EQ(HDF_SUCCESS, ret);
219         audiopara.delayTime = (audiopara.end.tv_sec * MICROSECOND + audiopara.end.tv_usec) -
220                               (audiopara.start.tv_sec * MICROSECOND + audiopara.start.tv_usec);
221         audiopara.totalTime += audiopara.delayTime;
222         ret = audiopara.render->GetChannelMode(audiopara.render, &mode);
223         EXPECT_EQ(HDF_SUCCESS, ret);
224         EXPECT_EQ(AUDIO_CHANNEL_NORMAL, mode);
225     }
226     audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT;
227     EXPECT_GT(LOWLATENCY, audiopara.averageDelayTime);
228 }
229 /**
230 * @tc.name  AudioRenderGetChannelModePerformance_001
231 * @tc.desc  tests the performace of RenderGetChannelMode interface by executing 1000 times,
232 *           and calculates the delay time and average of Delay Time.
233 * @tc.type: PERF
234 */
235 HWTEST_F(AudioIdlHdiRenderPerformaceTest, AudioRenderGetChannelModePerformance_001, TestSize.Level1)
236 {
237     int32_t ret;
238     AudioChannelMode mode = AUDIO_CHANNEL_NORMAL;
239     struct PrepareAudioPara audiopara = {
240         .render = render, .delayTime = 0, .totalTime = 0, .averageDelayTime =0,
241     };
242     ASSERT_NE(nullptr, audiopara.render);
243     ret = audiopara.render->SetChannelMode(audiopara.render, mode);
244     EXPECT_EQ(HDF_SUCCESS, ret);
245 
246     for (int i = 0; i < COUNT; ++i) {
247         gettimeofday(&audiopara.start, NULL);
248         ret = audiopara.render->GetChannelMode(audiopara.render, &mode);
249         gettimeofday(&audiopara.end, NULL);
250         EXPECT_EQ(HDF_SUCCESS, ret);
251         EXPECT_EQ(AUDIO_CHANNEL_NORMAL, mode);
252         audiopara.delayTime = (audiopara.end.tv_sec * MICROSECOND + audiopara.end.tv_usec) -
253                               (audiopara.start.tv_sec * MICROSECOND + audiopara.start.tv_usec);
254         audiopara.totalTime += audiopara.delayTime;
255     }
256     audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT;
257     EXPECT_GT(LOWLATENCY, audiopara.averageDelayTime);
258 }
259 /**
260 * @tc.name  AudioRenderGetFrameCountPerformance_001
261 * @tc.desc  tests the performace of RenderGetFrameCount interface by executing 1000 times,
262 *           and calculates the delay time and average of Delay Time.
263 * @tc.type: PERF
264 */
265 HWTEST_F(AudioIdlHdiRenderPerformaceTest, AudioRenderGetFrameCountPerformance_001, TestSize.Level1)
266 {
267     int32_t ret;
268     uint64_t count = 0;
269     uint64_t zero = 0;
270     struct PrepareAudioPara audiopara = {
271         .render = render, .delayTime = 0, .totalTime = 0, .averageDelayTime =0,
272     };
273     ASSERT_NE(nullptr, audiopara.render);
274     ret = AudioRenderStartAndOneFrame(audiopara.render);
275     EXPECT_EQ(HDF_SUCCESS, ret);
276 
277     for (int i = 0; i < COUNT; ++i) {
278         gettimeofday(&audiopara.start, NULL);
279         ret = audiopara.render->GetFrameCount(audiopara.render, &count);
280         gettimeofday(&audiopara.end, NULL);
281         EXPECT_EQ(HDF_SUCCESS, ret);
282         EXPECT_GT(count, zero);
283         audiopara.delayTime = (audiopara.end.tv_sec * MICROSECOND + audiopara.end.tv_usec) -
284                               (audiopara.start.tv_sec * MICROSECOND + audiopara.start.tv_usec);
285         audiopara.totalTime += audiopara.delayTime;
286     }
287     audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT;
288     EXPECT_GT(LOWLATENCY, audiopara.averageDelayTime);
289     ret = audiopara.render->Stop(audiopara.render);
290     EXPECT_EQ(HDF_SUCCESS, ret);
291 }
292 /**
293 * @tc.name  AudioRenderGetCurrentChannelIdPerformance_001
294 * @tc.desc  tests the performace of RenderGetCurrentChannelId interface by executing 1000 times,
295 *           and calculates the delay time and average of Delay Time.
296 * @tc.type: PERF
297 */
298 HWTEST_F(AudioIdlHdiRenderPerformaceTest, AudioRenderGetCurrentChannelIdPerformance_001, TestSize.Level1)
299 {
300     int32_t ret;
301     uint32_t channelId = 0;
302     uint32_t channelIdValue = CHANNELCOUNT;
303     struct PrepareAudioPara audiopara = {
304         .render = render, .delayTime = 0, .totalTime = 0, .averageDelayTime =0,
305     };
306     ASSERT_NE(nullptr, audiopara.render);
307     for (int i = 0; i < COUNT; ++i) {
308         gettimeofday(&audiopara.start, NULL);
309         ret = audiopara.render->GetCurrentChannelId(audiopara.render, &channelId);
310         gettimeofday(&audiopara.end, NULL);
311         EXPECT_EQ(HDF_SUCCESS, ret);
312         EXPECT_EQ(channelIdValue, channelId);
313         audiopara.delayTime = (audiopara.end.tv_sec * MICROSECOND + audiopara.end.tv_usec) -
314                               (audiopara.start.tv_sec * MICROSECOND + audiopara.start.tv_usec);
315         audiopara.totalTime += audiopara.delayTime;
316     }
317     audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT;
318     EXPECT_GT(LOWLATENCY, audiopara.averageDelayTime);
319 }
320 /**
321 * @tc.name  AudioRenderFlushPerformance_001
322 * @tc.desc  tests the performace of RenderFlush interface by executing 1000 times,
323 *           and calculates the delay time and average of Delay Time.
324 * @tc.type: PERF
325 */
326 HWTEST_F(AudioIdlHdiRenderPerformaceTest, AudioRenderFlushPerformance_001, TestSize.Level1)
327 {
328     int32_t ret;
329     struct PrepareAudioPara audiopara = {
330         .render = render, .delayTime = 0, .totalTime = 0, .averageDelayTime =0,
331     };
332     ASSERT_NE(nullptr, audiopara.render);
333 
334     for (int i = 0; i < COUNT; ++i) {
335         ret = AudioRenderStartAndOneFrame(audiopara.render);
336         EXPECT_EQ(HDF_SUCCESS, ret);
337         gettimeofday(&audiopara.start, NULL);
338         ret = audiopara.render->Flush(audiopara.render);
339         gettimeofday(&audiopara.end, NULL);
340         EXPECT_EQ(HDF_ERR_NOT_SUPPORT, ret);
341         ret = audiopara.render->Stop(audiopara.render);
342         EXPECT_EQ(HDF_SUCCESS, ret);
343         audiopara.delayTime = (audiopara.end.tv_sec * MICROSECOND + audiopara.end.tv_usec) -
344                               (audiopara.start.tv_sec * MICROSECOND + audiopara.start.tv_usec);
345         audiopara.totalTime += audiopara.delayTime;
346     }
347     audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT;
348     EXPECT_GT(LOWLATENCY, audiopara.averageDelayTime);
349 }
350 /**
351 * @tc.name  AudioRenderGetFrameSizePerformance_001
352 * @tc.desc  tests the performace of RenderGetFrameSize interface by executing 1000 times,
353 *           and calculates the delay time and average of Delay Time.
354 * @tc.type: PERF
355 */
356 HWTEST_F(AudioIdlHdiRenderPerformaceTest, AudioRenderGetFrameSizePerformance_001, TestSize.Level1)
357 {
358     int32_t ret;
359     uint64_t size = 0;
360     uint64_t zero = 0;
361     struct PrepareAudioPara audiopara = {
362         .render = render, .delayTime = 0, .totalTime = 0, .averageDelayTime =0,
363     };
364     ASSERT_NE(nullptr, audiopara.render);
365 
366     for (int i = 0; i < COUNT; ++i) {
367         ret = AudioRenderStartAndOneFrame(audiopara.render);
368         EXPECT_EQ(HDF_SUCCESS, ret);
369         gettimeofday(&audiopara.start, NULL);
370         ret = audiopara.render->GetFrameSize(audiopara.render, &size);
371         gettimeofday(&audiopara.end, NULL);
372         EXPECT_EQ(HDF_SUCCESS, ret);
373         EXPECT_GT(size, zero);
374         audiopara.delayTime = (audiopara.end.tv_sec * MICROSECOND + audiopara.end.tv_usec) -
375                               (audiopara.start.tv_sec * MICROSECOND + audiopara.start.tv_usec);
376         audiopara.totalTime += audiopara.delayTime;
377         ret = audiopara.render->Stop(audiopara.render);
378         EXPECT_EQ(HDF_SUCCESS, ret);
379     }
380     audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT;
381     EXPECT_GT(LOWLATENCY, audiopara.averageDelayTime);
382 }
383 
384 /**
385 * @tc.name  AudioRenderCheckSceneCapabilityPerformance_001
386 * @tc.desc  tests the performace of RenderCheckSceneCapability interface by executing 1000 times,
387 *           and calculates the delay time and average of Delay Time.
388 * @tc.type: PERF
389 */
390 HWTEST_F(AudioIdlHdiRenderPerformaceTest, AudioRenderCheckSceneCapabilityPerformance_001, TestSize.Level1)
391 {
392     int32_t ret;
393     bool supported = false;
394     struct PrepareAudioPara audiopara = {
395         .render = render, .delayTime = 0, .totalTime = 0, .averageDelayTime =0,
396     };
397     ASSERT_NE(nullptr, audiopara.render);
398     struct AudioSceneDescriptor scenes = {.scene.id = 0, .desc.pins = PIN_OUT_SPEAKER, .desc.desc = strdup("mic") };
399     for (int i = 0; i < COUNT; ++i) {
400         gettimeofday(&audiopara.start, NULL);
401         ret = audiopara.render->CheckSceneCapability(audiopara.render, &scenes, &supported);
402         gettimeofday(&audiopara.end, NULL);
403         EXPECT_EQ(HDF_SUCCESS, ret);
404         EXPECT_TRUE(supported);
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 * @tc.name  AudioRenderSelectScenePerformance_001
414 * @tc.desc  tests the performace of RenderSelectScene interface by executing 1000 times,
415 *           and calculates the delay time and average of Delay Time.
416 * @tc.type: PERF
417 */
418 HWTEST_F(AudioIdlHdiRenderPerformaceTest, AudioRenderSelectScenePerformance_001, TestSize.Level1)
419 {
420     int32_t ret;
421     struct PrepareAudioPara audiopara = {
422         .render = render, .delayTime = 0, .totalTime = 0, .averageDelayTime =0,
423     };
424     ASSERT_NE(nullptr, audiopara.render);
425     struct AudioSceneDescriptor scenes = {.scene.id = 0, .desc.pins = PIN_OUT_SPEAKER, .desc.desc = strdup("mic") };
426 
427     for (int i = 0; i < COUNT; ++i) {
428         gettimeofday(&audiopara.start, NULL);
429         ret = audiopara.render->SelectScene(audiopara.render, &scenes);
430         gettimeofday(&audiopara.end, NULL);
431         EXPECT_EQ(HDF_SUCCESS, ret);
432         audiopara.delayTime = (audiopara.end.tv_sec * MICROSECOND + audiopara.end.tv_usec) -
433                               (audiopara.start.tv_sec * MICROSECOND + audiopara.start.tv_usec);
434         audiopara.totalTime += audiopara.delayTime;
435         ret = AudioRenderStartAndOneFrame(audiopara.render);
436         EXPECT_EQ(HDF_SUCCESS, ret);
437         ret = audiopara.render->Stop(audiopara.render);
438         EXPECT_EQ(HDF_SUCCESS, ret);
439     }
440     audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT;
441     EXPECT_GT(LOWLATENCY, audiopara.averageDelayTime);
442 }
443 /**
444 * @tc.name  AudiorenderSetMutePerformance_001
445 * @tc.desc  tests the performace of renderSetMute interface by executing 1000 times,
446 *           and calculates the delay time and average of Delay Time.
447 * @tc.type: PERF
448 */
449 HWTEST_F(AudioIdlHdiRenderPerformaceTest, AudiorenderSetMutePerformance_001, TestSize.Level1)
450 {
451     int32_t ret;
452     bool muteFalse = false;
453     struct PrepareAudioPara audiopara = {
454         .render = render, .delayTime = 0, .totalTime = 0, .averageDelayTime =0,
455     };
456     ASSERT_NE(nullptr, audiopara.render);
457 
458     for (int i = 0; i < COUNT; ++i) {
459         gettimeofday(&audiopara.start, NULL);
460         ret = audiopara.render->SetMute(audiopara.render, muteFalse);
461         gettimeofday(&audiopara.end, NULL);
462         EXPECT_EQ(HDF_SUCCESS, ret);
463         audiopara.delayTime = (audiopara.end.tv_sec * MICROSECOND + audiopara.end.tv_usec) -
464                               (audiopara.start.tv_sec * MICROSECOND + audiopara.start.tv_usec);
465         audiopara.totalTime += audiopara.delayTime;
466         ret = audiopara.render->GetMute(audiopara.render, &muteFalse);
467         EXPECT_EQ(HDF_SUCCESS, ret);
468         EXPECT_EQ(false, muteFalse);
469     }
470     audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT;
471     EXPECT_GT(LOWLATENCY, audiopara.averageDelayTime);
472 }
473 /**
474 * @tc.name  AudioenderGetMutePerformance_001
475 * @tc.desc  tests the performace of renderGetMute interface by executing 1000 times,
476 *           and calculates the delay time and average of Delay Time.
477 * @tc.type: PERF
478 */
479 HWTEST_F(AudioIdlHdiRenderPerformaceTest, AudiorenderGetMutePerformance_001, TestSize.Level1)
480 {
481     int32_t ret;
482     bool muteFalse = false;
483     struct PrepareAudioPara audiopara = {
484         .render = render, .delayTime = 0, .totalTime = 0, .averageDelayTime =0,
485     };
486     ASSERT_NE(nullptr, audiopara.render);
487     ret = audiopara.render->SetMute(audiopara.render, muteFalse);
488     EXPECT_EQ(HDF_SUCCESS, ret);
489 
490     for (int i = 0; i < COUNT; ++i) {
491         gettimeofday(&audiopara.start, NULL);
492         ret = audiopara.render->GetMute(audiopara.render, &muteFalse);
493         gettimeofday(&audiopara.end, NULL);
494         EXPECT_EQ(HDF_SUCCESS, ret);
495         audiopara.delayTime = (audiopara.end.tv_sec * MICROSECOND + audiopara.end.tv_usec) -
496                               (audiopara.start.tv_sec * MICROSECOND + audiopara.start.tv_usec);
497         audiopara.totalTime += audiopara.delayTime;
498     }
499     audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT;
500     EXPECT_GT(LOWLATENCY, audiopara.averageDelayTime);
501 }
502 /**
503 * @tc.name  AudiorenderSetVolumePerformance_001
504 * @tc.desc  tests the performace of renderSetVolume interface by executing 1000 times,
505 *           and calculates the delay time and average of Delay Time.
506 * @tc.type: PERF
507 */
508 HWTEST_F(AudioIdlHdiRenderPerformaceTest, AudiorenderSetVolumePerformance_001, TestSize.Level1)
509 {
510     int32_t ret;
511     float volume = 0.80;
512     float volumeExpc = 0.80;
513     struct PrepareAudioPara audiopara = {
514         .render = render, .delayTime = 0, .totalTime = 0, .averageDelayTime =0,
515     };
516     ASSERT_NE(nullptr, audiopara.render);
517 
518     for (int i = 0; i < COUNT; ++i) {
519         gettimeofday(&audiopara.start, NULL);
520         ret = audiopara.render->SetVolume(audiopara.render, volume);
521         gettimeofday(&audiopara.end, NULL);
522         EXPECT_EQ(HDF_SUCCESS, ret);
523         audiopara.delayTime = (audiopara.end.tv_sec * MICROSECOND + audiopara.end.tv_usec) -
524                               (audiopara.start.tv_sec * MICROSECOND + audiopara.start.tv_usec);
525         audiopara.totalTime += audiopara.delayTime;
526         ret = audiopara.render->GetVolume(audiopara.render, &volume);
527         EXPECT_EQ(HDF_SUCCESS, ret);
528         EXPECT_EQ(volumeExpc, volume);
529     }
530     audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT;
531     EXPECT_GT(LOWLATENCY, audiopara.averageDelayTime);
532 }
533 /**
534 * @tc.name  AudiorenderGetVolumePerformance_001
535 * @tc.desc  tests the performace of renderGetVolume interface by executing 1000 times,
536 *           and calculates the delay time and average of Delay Time.
537 * @tc.type: PERF
538 */
539 HWTEST_F(AudioIdlHdiRenderPerformaceTest, AudiorenderGetVolumePerformance_001, TestSize.Level1)
540 {
541     int32_t ret;
542     float volume = 0.30;
543     float volumeDefault = 0.30;
544     struct PrepareAudioPara audiopara = {
545         .render = render, .delayTime = 0, .totalTime = 0, .averageDelayTime =0,
546     };
547     ASSERT_NE(nullptr, audiopara.render);
548     ret = audiopara.render->SetVolume(audiopara.render, volume);
549     EXPECT_EQ(HDF_SUCCESS, ret);
550 
551     for (int i = 0; i < COUNT; ++i) {
552         gettimeofday(&audiopara.start, NULL);
553         ret = audiopara.render->GetVolume(audiopara.render, &volume);
554         gettimeofday(&audiopara.end, NULL);
555         EXPECT_EQ(HDF_SUCCESS, ret);
556         EXPECT_EQ(volumeDefault, volume);
557         audiopara.delayTime = (audiopara.end.tv_sec * MICROSECOND + audiopara.end.tv_usec) -
558                               (audiopara.start.tv_sec * MICROSECOND + audiopara.start.tv_usec);
559         audiopara.totalTime += audiopara.delayTime;
560     }
561     audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT;
562     EXPECT_GT(LOWLATENCY, audiopara.averageDelayTime);
563 }
564 /**
565 * @tc.name  AudiorenderGetGainThresholdPerformance_001
566 * @tc.desc  tests the performace of renderGetGainThreshold interface by executing 1000 times,
567 *           and calculates the delay time and average of Delay Time.
568 * @tc.type: PERF
569 */
570 HWTEST_F(AudioIdlHdiRenderPerformaceTest, AudiorenderGetGainThresholdPerformance_001, TestSize.Level1)
571 {
572     int32_t ret;
573     float min = 0;
574     float max = 0;
575     struct PrepareAudioPara audiopara = {
576         .render = render, .delayTime = 0, .totalTime = 0, .averageDelayTime =0,
577     };
578     ASSERT_NE(nullptr, audiopara.render);
579 
580     for (int i = 0; i < COUNT; ++i) {
581         gettimeofday(&audiopara.start, NULL);
582         ret = audiopara.render->GetGainThreshold(audiopara.render, &min, &max);
583         gettimeofday(&audiopara.end, NULL);
584         EXPECT_EQ(HDF_SUCCESS, ret);
585         EXPECT_EQ(min, GAIN_MIN);
586         EXPECT_EQ(max, GAIN_MAX);
587         audiopara.delayTime = (audiopara.end.tv_sec * MICROSECOND + audiopara.end.tv_usec) -
588                               (audiopara.start.tv_sec * MICROSECOND + audiopara.start.tv_usec);
589         audiopara.totalTime += audiopara.delayTime;
590     }
591     audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT;
592     EXPECT_GT(LOWLATENCY, audiopara.averageDelayTime);
593 }
594 /**
595 * @tc.name  AudiorenderSetGainPerformance_001
596 * @tc.desc  tests the performace of renderSetGain interface by executing 1000 times,
597 *           and calculates the delay time and average of Delay Time.
598 * @tc.type: PERF
599 */
600 HWTEST_F(AudioIdlHdiRenderPerformaceTest, AudiorenderSetGainPerformance_001, TestSize.Level1)
601 {
602     int32_t ret;
603     float gain = 10;
604     float gainExpc = 10;
605     struct PrepareAudioPara audiopara = {
606         .render = render, .delayTime = 0, .totalTime = 0, .averageDelayTime =0,
607     };
608     ASSERT_NE(nullptr, audiopara.render);
609 
610     for (int i = 0; i < COUNT; ++i) {
611         gettimeofday(&audiopara.start, NULL);
612         ret = audiopara.render->SetGain(audiopara.render, gain);
613         gettimeofday(&audiopara.end, NULL);
614         EXPECT_EQ(HDF_SUCCESS, ret);
615         audiopara.delayTime = (audiopara.end.tv_sec * MICROSECOND + audiopara.end.tv_usec) -
616                               (audiopara.start.tv_sec * MICROSECOND + audiopara.start.tv_usec);
617         audiopara.totalTime += audiopara.delayTime;
618         ret = audiopara.render->GetGain(audiopara.render, &gain);
619         EXPECT_EQ(HDF_SUCCESS, ret);
620         EXPECT_EQ(gainExpc, gain);
621     }
622     audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT;
623     EXPECT_GT(LOWLATENCY, audiopara.averageDelayTime);
624 }
625 /**
626 * @tc.name  AudiorenderGetGainPerformance_001
627 * @tc.desc  tests the performace of renderGetGain interface by executing 1000 times,
628 *           and calculates the delay time and average of Delay Time.
629 * @tc.type: PERF
630 */
631 HWTEST_F(AudioIdlHdiRenderPerformaceTest, AudiorenderGetGainPerformance_001, TestSize.Level1)
632 {
633     int32_t ret;
634     float min = 0;
635     float max = 0;
636     struct PrepareAudioPara audiopara = {
637         .render = render, .delayTime = 0, .totalTime = 0, .averageDelayTime =0,
638     };
639     ASSERT_NE(nullptr, audiopara.render);
640     ret = audiopara.render->GetGainThreshold(audiopara.render, &min, &max);
641     EXPECT_EQ(HDF_SUCCESS, ret);
642     float gain = min + 1;
643     float gainValue = min + 1;
644 
645     for (int i = 0; i < COUNT; ++i) {
646         ret = audiopara.render->SetGain(audiopara.render, gain);
647         EXPECT_EQ(HDF_SUCCESS, ret);
648         gettimeofday(&audiopara.start, NULL);
649         ret = audiopara.render->GetGain(audiopara.render, &gain);
650         gettimeofday(&audiopara.end, NULL);
651         EXPECT_EQ(HDF_SUCCESS, ret);
652         EXPECT_EQ(gainValue, gain);
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 * @tc.name  AudioRenderFramePerformance_001
662 * @tc.desc  tests the performace of RenderFrame interface by executing 1000 times,
663 *           and calculates the delay time and average of Delay Time.
664 * @tc.type: PERF
665 */
666 HWTEST_F(AudioIdlHdiRenderPerformaceTest, AudioRenderFramePerformance_001, TestSize.Level1)
667 {
668     int32_t ret;
669     uint64_t requestBytes = 0;
670     uint64_t replyBytes = 0;
671     struct PrepareAudioPara audiopara = {
672         .render = render, .delayTime = 0, .totalTime = 0, .averageDelayTime =0,
673     };
674     ASSERT_NE(nullptr, audiopara.render);
675     ret = audiopara.render->Start(audiopara.render);
676     EXPECT_EQ(HDF_SUCCESS, ret);
677     ret = RenderFramePrepare(AUDIO_FILE, audiopara.frame, requestBytes);
678     EXPECT_EQ(HDF_SUCCESS, ret);
679 
680     for (int i = 0; i < COUNT; ++i) {
681         gettimeofday(&audiopara.start, NULL);
682         ret = audiopara.render->RenderFrame(audiopara.render, (int8_t *)audiopara.frame, requestBytes,
683                                             &replyBytes);
684         gettimeofday(&audiopara.end, NULL);
685         EXPECT_EQ(HDF_SUCCESS, ret);
686         audiopara.delayTime = (audiopara.end.tv_sec * MICROSECOND + audiopara.end.tv_usec) -
687                               (audiopara.start.tv_sec * MICROSECOND + audiopara.start.tv_usec);
688         audiopara.totalTime += audiopara.delayTime;
689     }
690     audiopara.render->Stop(audiopara.render);
691     EXPECT_EQ(HDF_SUCCESS, ret);
692     if (audiopara.frame != nullptr) {
693         free(audiopara.frame);
694         audiopara.frame = nullptr;
695     }
696     audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT;
697     EXPECT_GT(NORMALLATENCY, audiopara.averageDelayTime);
698 }
699 /**
700 * @tc.name  AudioRenderStartPerformance_001
701 * @tc.desc  tests the performace of RenderStart interface by executing 1000 times,
702 *           and calculates the delay time and average of Delay Time.
703 * @tc.type: PERF
704 */
705 HWTEST_F(AudioIdlHdiRenderPerformaceTest, AudioRenderStartPerformance_001, TestSize.Level1)
706 {
707     int32_t ret;
708     struct PrepareAudioPara audiopara = {
709         .render = render, .delayTime = 0, .totalTime = 0, .averageDelayTime =0,
710     };
711     ASSERT_NE(nullptr, audiopara.render);
712 
713     for (int i = 0; i < COUNT; ++i) {
714         gettimeofday(&audiopara.start, NULL);
715         ret = audiopara.render->Start(audiopara.render);
716         gettimeofday(&audiopara.end, NULL);
717         EXPECT_EQ(HDF_SUCCESS, ret);
718         audiopara.delayTime = (audiopara.end.tv_sec * MICROSECOND + audiopara.end.tv_usec) -
719                               (audiopara.start.tv_sec * MICROSECOND + audiopara.start.tv_usec);
720         audiopara.totalTime += audiopara.delayTime;
721         ret = audiopara.render->Stop(audiopara.render);
722         EXPECT_EQ(HDF_SUCCESS, ret);
723     }
724     audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT;
725     EXPECT_GT(LOWLATENCY, audiopara.averageDelayTime);
726 }
727 /**
728 * @tc.name  AudioRenderStopPerformance_001
729 * @tc.desc  tests the performace of RenderStop interface by executing 1000 times,
730 *           and calculates the delay time and average of Delay Time.
731 * @tc.type: PERF
732 */
733 HWTEST_F(AudioIdlHdiRenderPerformaceTest, AudioRenderStopPerformance_001, TestSize.Level1)
734 {
735     int32_t ret;
736     struct PrepareAudioPara audiopara = {
737         .render = render, .delayTime = 0, .totalTime = 0, .averageDelayTime =0,
738     };
739     ASSERT_NE(nullptr, audiopara.render);
740 
741     for (int i = 0; i < COUNT; ++i) {
742         ret = audiopara.render->Start(audiopara.render);
743         EXPECT_EQ(HDF_SUCCESS, ret);
744         gettimeofday(&audiopara.start, NULL);
745         ret = audiopara.render->Stop(audiopara.render);
746         gettimeofday(&audiopara.end, NULL);
747         EXPECT_EQ(HDF_SUCCESS, ret);
748         audiopara.delayTime = (audiopara.end.tv_sec * MICROSECOND + audiopara.end.tv_usec) -
749                               (audiopara.start.tv_sec * MICROSECOND + audiopara.start.tv_usec);
750         audiopara.totalTime += audiopara.delayTime;
751     }
752     audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT;
753     EXPECT_GT(LOWLATENCY, audiopara.averageDelayTime);
754 }
755 /**
756 * @tc.name  AudioRenderPausePerformance_001
757 * @tc.desc  tests the performace of RenderPause interface by executing 1000 times,
758 *           and calculates the delay time and average of Delay Time.
759 * @tc.type: PERF
760 */
761 HWTEST_F(AudioIdlHdiRenderPerformaceTest, AudioRenderPausePerformance_001, TestSize.Level1)
762 {
763     int32_t ret;
764     struct PrepareAudioPara audiopara = {
765         .render = render, .delayTime = 0, .totalTime = 0, .averageDelayTime =0,
766     };
767     ASSERT_NE(nullptr, audiopara.render);
768     ret = AudioRenderStartAndOneFrame(audiopara.render);
769     EXPECT_EQ(HDF_SUCCESS, ret);
770 
771     for (int i = 0; i < COUNT; ++i) {
772         gettimeofday(&audiopara.start, NULL);
773         ret = audiopara.render->Pause(audiopara.render);
774         gettimeofday(&audiopara.end, NULL);
775         EXPECT_EQ(HDF_SUCCESS, ret);
776         ret = audiopara.render->Resume(audiopara.render);
777         EXPECT_EQ(HDF_SUCCESS, ret);
778         audiopara.delayTime = (audiopara.end.tv_sec * MICROSECOND + audiopara.end.tv_usec) -
779                               (audiopara.start.tv_sec * MICROSECOND + audiopara.start.tv_usec);
780         audiopara.totalTime += audiopara.delayTime;
781     }
782     audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT;
783     EXPECT_GT(LOWLATENCY, audiopara.averageDelayTime);
784     ret = audiopara.render->Stop(audiopara.render);
785     EXPECT_EQ(HDF_SUCCESS, ret);
786 }
787 /**
788 * @tc.name  AudioAudioRenderResumePerformance_001
789 * @tc.desc  tests the performace of AudioRenderResume interface by executing 1000 times,
790 *           and calculates the delay time and average of Delay Time.
791 * @tc.type: PERF
792 */
793 HWTEST_F(AudioIdlHdiRenderPerformaceTest, AudioAudioRenderResumePerformance_001, TestSize.Level1)
794 {
795     int32_t ret;
796     struct PrepareAudioPara audiopara = {
797         .render = render, .delayTime = 0, .totalTime = 0, .averageDelayTime =0,
798     };
799     ASSERT_NE(nullptr, audiopara.render);
800     ret = AudioRenderStartAndOneFrame(audiopara.render);
801     EXPECT_EQ(HDF_SUCCESS, ret);
802 
803     for (int i = 0; i < COUNT; ++i) {
804         ret = audiopara.render->Pause(audiopara.render);
805         EXPECT_EQ(HDF_SUCCESS, ret);
806         gettimeofday(&audiopara.start, NULL);
807         ret = audiopara.render->Resume(audiopara.render);
808         gettimeofday(&audiopara.end, NULL);
809         EXPECT_EQ(HDF_SUCCESS, ret);
810         audiopara.delayTime = (audiopara.end.tv_sec * MICROSECOND + audiopara.end.tv_usec) -
811                               (audiopara.start.tv_sec * MICROSECOND + audiopara.start.tv_usec);
812         audiopara.totalTime += audiopara.delayTime;
813     }
814     ret = audiopara.render->Stop(audiopara.render);
815     EXPECT_EQ(HDF_SUCCESS, ret);
816     audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT;
817     EXPECT_GT(LOWLATENCY, audiopara.averageDelayTime);
818 }
819 /**
820 * @tc.name  AudioRenderSetSampleAttributesPerformance_001
821 * @tc.desc  tests the performace of RenderSetSampleAttributes interface by executing 1000 times,
822 *           and calculates the delay time and average of Delay Time.
823 * @tc.type: PERF
824 */
825 HWTEST_F(AudioIdlHdiRenderPerformaceTest, AudioRenderSetSampleAttributesPerformance_001, TestSize.Level1)
826 {
827     int32_t ret;
828     uint32_t expChannelCount = 2;
829     uint32_t expSampleRate = 8000;
830     struct PrepareAudioPara audiopara = {
831         .render = render, .delayTime = 0, .totalTime = 0, .averageDelayTime =0,
832     };
833     ASSERT_NE(nullptr, audiopara.render);
834     InitAttrsUpdate(audiopara.attrs, AUDIO_FORMAT_TYPE_PCM_16_BIT, 2, 8000);
835 
836     for (int i = 0; i < COUNT; ++i) {
837         gettimeofday(&audiopara.start, NULL);
838         ret = audiopara.render->SetSampleAttributes(audiopara.render, &audiopara.attrs);
839         gettimeofday(&audiopara.end, NULL);
840         EXPECT_EQ(HDF_SUCCESS, ret);
841         ret = audiopara.render->GetSampleAttributes(audiopara.render, &audiopara.attrsValue);
842         EXPECT_EQ(HDF_SUCCESS, ret);
843         EXPECT_EQ(AUDIO_IN_MEDIA, audiopara.attrsValue.type);
844         EXPECT_EQ(AUDIO_FORMAT_TYPE_PCM_16_BIT, audiopara.attrsValue.format);
845         EXPECT_EQ(expSampleRate, audiopara.attrsValue.sampleRate);
846         EXPECT_EQ(expChannelCount, audiopara.attrsValue.channelCount);
847         audiopara.delayTime = (audiopara.end.tv_sec * MICROSECOND + audiopara.end.tv_usec) -
848                               (audiopara.start.tv_sec * MICROSECOND + audiopara.start.tv_usec);
849         audiopara.totalTime += audiopara.delayTime;
850     }
851     audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT;
852     EXPECT_GT(LOWLATENCY, audiopara.averageDelayTime);
853 }
854 /**
855 * @tc.name  AudioRenderGetSampleAttributesPerformance_001
856 * @tc.desc  tests the performace of RenderGetSampleAttributes interface by executing 1000 times,
857 *           and calculates the delay time and average of Delay Time.
858 * @tc.type: PERF
859 */
860 HWTEST_F(AudioIdlHdiRenderPerformaceTest, AudioRenderGetSampleAttributesPerformance_001, TestSize.Level1)
861 {
862     int32_t ret;
863     uint32_t expChannelCount = 2;
864     uint32_t expSampleRate = 8000;
865     struct PrepareAudioPara audiopara = {
866         .render = render, .delayTime = 0, .totalTime = 0, .averageDelayTime =0,
867     };
868     ASSERT_NE(nullptr, audiopara.render);
869     InitAttrsUpdate(audiopara.attrs, AUDIO_FORMAT_TYPE_PCM_24_BIT, 2, 8000);
870 
871     for (int i = 0; i < COUNT; ++i) {
872         ret = audiopara.render->SetSampleAttributes(audiopara.render, &audiopara.attrs);
873         EXPECT_EQ(HDF_SUCCESS, ret);
874         gettimeofday(&audiopara.start, NULL);
875         ret = audiopara.render->GetSampleAttributes(audiopara.render, &audiopara.attrsValue);
876         gettimeofday(&audiopara.end, NULL);
877         EXPECT_EQ(HDF_SUCCESS, ret);
878         EXPECT_EQ(AUDIO_IN_MEDIA, audiopara.attrsValue.type);
879         EXPECT_EQ(AUDIO_FORMAT_TYPE_PCM_24_BIT, audiopara.attrsValue.format);
880         EXPECT_EQ(expSampleRate, audiopara.attrsValue.sampleRate);
881         EXPECT_EQ(expChannelCount, audiopara.attrsValue.channelCount);
882         audiopara.delayTime = (audiopara.end.tv_sec * MICROSECOND + audiopara.end.tv_usec) -
883                               (audiopara.start.tv_sec * MICROSECOND + audiopara.start.tv_usec);
884         audiopara.totalTime += audiopara.delayTime;
885     }
886     audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT;
887     EXPECT_GT(LOWLATENCY, audiopara.averageDelayTime);
888 }
889 
890 /**
891 * @tc.name  AudioRenderSetExtraParamsPerformance_001
892 * @tc.desc  tests the performace of RenderSetExtraParams interface by executing 1000 times,
893 *           and calculates the delay time and average of Delay Time.
894 * @tc.type: PERF
895 */
896 HWTEST_F(AudioIdlHdiRenderPerformaceTest, AudioRenderSetExtraParamsPerformance_001, TestSize.Level1)
897 {
898     int32_t ret;
899     const char keyValueList[] = "attr-route=1;attr-format=32;attr-channels=2;attr-frame-count=82;\
900 attr-sampling-rate=48000";
901     const char keyValueListExp[] = "attr-route=1;attr-format=32;attr-channels=2;attr-sampling-rate=48000";
902     size_t index = 1;
903     int32_t listLenth = 256;
904     struct PrepareAudioPara audiopara = {
905         .render = render, .delayTime = 0, .totalTime = 0, .averageDelayTime =0,
906     };
907     ASSERT_NE(nullptr, audiopara.render);
908     for (int i = 0; i < COUNT; ++i) {
909         gettimeofday(&audiopara.start, NULL);
910         ret = audiopara.render->SetExtraParams(audiopara.render, keyValueList);
911         gettimeofday(&audiopara.end, NULL);
912         EXPECT_EQ(HDF_SUCCESS, ret);
913         usleep(10000);
914         char keyValueListValue[256] = {0};
915         ret = audiopara.render->GetExtraParams(audiopara.render, keyValueListValue, listLenth);
916         EXPECT_EQ(HDF_SUCCESS, ret);
917         string strGetValue = keyValueListValue;
918         size_t indexAttr = strGetValue.find("attr-frame-count");
919         size_t indexFlag = strGetValue.rfind(";");
920         if (indexAttr != string::npos && indexFlag != string::npos) {
921             strGetValue.replace(indexAttr, indexFlag - indexAttr + index, "");
922         }
923         EXPECT_STREQ(keyValueListExp, strGetValue.c_str());
924         audiopara.delayTime = (audiopara.end.tv_sec * MICROSECOND + audiopara.end.tv_usec) -
925                               (audiopara.start.tv_sec * MICROSECOND + audiopara.start.tv_usec);
926         audiopara.totalTime += audiopara.delayTime;
927     }
928     audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT;
929     EXPECT_GT(LOWLATENCY, audiopara.averageDelayTime);
930 }
931 /**
932 * @tc.name  AudioRenderGetExtraParamsPerformance_001
933 * @tc.desc  tests the performace of RenderGetExtraParams interface by executing 1000 times,
934 *           and calculates the delay time and average of Delay Time.
935 * @tc.type: PERF
936 */
937 HWTEST_F(AudioIdlHdiRenderPerformaceTest, AudioRenderGetExtraParamsPerformance_001, TestSize.Level1)
938 {
939     int32_t ret;
940     char keyValueList[] = "attr-format=24;attr-frame-count=4096;";
941     char keyValueListExp[] = "attr-route=0;attr-format=24;attr-channels=2;attr-frame-count=4096;\
942 attr-sampling-rate=48000";
943     int32_t listLenth = 256;
944     struct PrepareAudioPara audiopara = {
945         .render = render, .delayTime = 0, .totalTime = 0, .averageDelayTime =0,
946     };
947     ASSERT_NE(nullptr, audiopara.render);
948     ret = audiopara.render->SetExtraParams(audiopara.render, keyValueList);
949     EXPECT_EQ(HDF_SUCCESS, ret);
950 
951     for (int i = 0; i < COUNT; ++i) {
952         char keyValueListValue[256] = {};
953         gettimeofday(&audiopara.start, NULL);
954         ret = audiopara.render->GetExtraParams(audiopara.render, keyValueListValue, listLenth);
955         gettimeofday(&audiopara.end, NULL);
956         ASSERT_EQ(HDF_SUCCESS, ret);
957         EXPECT_STREQ(keyValueListExp, keyValueListValue);
958         audiopara.delayTime = (audiopara.end.tv_sec * MICROSECOND + audiopara.end.tv_usec) -
959                               (audiopara.start.tv_sec * MICROSECOND + audiopara.start.tv_usec);
960         audiopara.totalTime += audiopara.delayTime;
961     }
962     audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT;
963     EXPECT_GT(LOWLATENCY, audiopara.averageDelayTime);
964 }
965 }
966