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 HIGHLATENCY = 60000; // high interface delay:60ms
28
29 class AudioIdlHdiAdapterPerformaceTest : public testing::Test {
30 public:
31 static void SetUpTestCase(void);
32 static void TearDownTestCase(void);
33 void SetUp();
34 void TearDown();
35 static struct IAudioAdapter *adapter;
36 static struct AudioPort audioPort;
37 static TestAudioManager *manager;
38 };
39 using THREAD_FUNC = void *(*)(void *);
40 TestAudioManager *AudioIdlHdiAdapterPerformaceTest::manager = nullptr;
41 struct IAudioAdapter *AudioIdlHdiAdapterPerformaceTest::adapter = nullptr;
42 struct AudioPort AudioIdlHdiAdapterPerformaceTest::audioPort = {};
43
SetUpTestCase(void)44 void AudioIdlHdiAdapterPerformaceTest::SetUpTestCase(void)
45 {
46 manager = IAudioManagerGet(IS_STUB);
47 ASSERT_NE(nullptr, manager);
48 int32_t ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME, &adapter, audioPort);
49 ASSERT_EQ(HDF_SUCCESS, ret);
50 }
51
TearDownTestCase(void)52 void AudioIdlHdiAdapterPerformaceTest::TearDownTestCase(void)
53 {
54 if (manager != nullptr && manager->UnloadAdapter != nullptr && adapter != nullptr) {
55 int32_t ret = manager->UnloadAdapter(manager, ADAPTER_NAME.c_str());
56 EXPECT_EQ(HDF_SUCCESS, ret);
57 IAudioAdapterRelease(adapter, IS_STUB);
58 free(audioPort.portName);
59 (void)IAudioManagerRelease(manager, IS_STUB);
60 }
61 }
62
SetUp(void)63 void AudioIdlHdiAdapterPerformaceTest::SetUp(void) {}
64
TearDown(void)65 void AudioIdlHdiAdapterPerformaceTest::TearDown(void) {}
66 /**
67 * @tc.name AudioManagerInitAllPortsPerformance_001
68 * @tc.desc tests the performace of InitAllPorts interface by executing 1000 times,
69 * and calculates the delay time and average of Delay Time.
70 * @tc.type: PERF
71 */
72 HWTEST_F(AudioIdlHdiAdapterPerformaceTest, AudioManagerInitAllPortsPerformance_001, TestSize.Level1)
73 {
74 int32_t ret;
75 struct PrepareAudioPara audiopara = {
76 .adapter = adapter, .delayTime = 0, .totalTime = 0, .averageDelayTime =0,
77 };
78 ASSERT_NE(nullptr, audiopara.adapter);
79
80 for (int i = 0; i < COUNT; ++i) {
81 EXPECT_NE(nullptr, audiopara.adapter);
82 gettimeofday(&audiopara.start, NULL);
83 ret = audiopara.adapter->InitAllPorts(audiopara.adapter);
84 gettimeofday(&audiopara.end, NULL);
85 EXPECT_EQ(HDF_SUCCESS, ret);
86 audiopara.delayTime = (audiopara.end.tv_sec * MICROSECOND + audiopara.end.tv_usec) -
87 (audiopara.start.tv_sec * MICROSECOND + audiopara.start.tv_usec);
88 audiopara.totalTime += audiopara.delayTime;
89 }
90 audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT;
91 EXPECT_GT(LOWLATENCY, audiopara.averageDelayTime);
92 }
93 /**
94 * @tc.name AudioGetPortCapabilityPerformance_001
95 * @tc.desc tests the performace of GetPortCapability interface by executing 1000 times,
96 * and calculates the delay time and average of Delay Time.
97 * @tc.type: PERF
98 */
99 HWTEST_F(AudioIdlHdiAdapterPerformaceTest, AudioGetPortCapabilityPerformance_001, TestSize.Level1)
100 {
101 int32_t ret;
102 struct PrepareAudioPara audiopara = {
103 .adapter = adapter, .delayTime = 0, .totalTime = 0, .averageDelayTime =0,
104 };
105 ASSERT_NE(nullptr, audiopara.adapter);
106 ret = audiopara.adapter->InitAllPorts(audiopara.adapter);
107 EXPECT_EQ(HDF_SUCCESS, ret);
108 for (int i = 0; i < COUNT; ++i) {
109 struct AudioPortCapability *capability = nullptr;
110 capability = (struct AudioPortCapability*)OsalMemCalloc(sizeof(struct AudioPortCapability));
111 ASSERT_NE(nullptr, capability);
112 gettimeofday(&audiopara.start, NULL);
113 ret = audiopara.adapter->GetPortCapability(audiopara.adapter, &audioPort, capability);
114 gettimeofday(&audiopara.end, NULL);
115 EXPECT_EQ(HDF_SUCCESS, ret);
116 EXPECT_NE(nullptr, capability->formats);
117 EXPECT_NE(nullptr, capability->subPorts);
118 if (capability->subPorts != nullptr) {
119 EXPECT_NE(nullptr, capability->subPorts->desc);
120 }
121 TestAudioPortCapabilityFree(capability, true);
122 audiopara.delayTime = (audiopara.end.tv_sec * MICROSECOND + audiopara.end.tv_usec) -
123 (audiopara.start.tv_sec * MICROSECOND + audiopara.start.tv_usec);
124 audiopara.totalTime += audiopara.delayTime;
125 }
126 audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT;
127 EXPECT_GT(LOWLATENCY, audiopara.averageDelayTime);
128 }
129 /**
130 * @tc.name AudioSetPassthroughModePerformance_001
131 * @tc.desc tests the performace of SetPassthroughMode interface by executing 1000 times,
132 * and calculates the delay time and average of Delay Time.
133 * @tc.type: PERF
134 */
135 HWTEST_F(AudioIdlHdiAdapterPerformaceTest, AudioSetPassthroughModePerformance_001, TestSize.Level1)
136 {
137 int32_t ret;
138 struct PrepareAudioPara audiopara = {
139 .adapter = adapter, .mode = PORT_PASSTHROUGH_LPCM, .delayTime = 0, .totalTime = 0, .averageDelayTime =0,
140 };
141 ASSERT_NE(nullptr, audiopara.adapter);
142 ret = audiopara.adapter->InitAllPorts(audiopara.adapter);
143 EXPECT_EQ(HDF_SUCCESS, ret);
144 for (int i = 0; i < COUNT; ++i) {
145 AudioPortPassthroughMode mode = PORT_PASSTHROUGH_AUTO;
146 gettimeofday(&audiopara.start, NULL);
147 ret = audiopara.adapter->SetPassthroughMode(audiopara.adapter, &audioPort, audiopara.mode);
148 gettimeofday(&audiopara.end, NULL);
149 EXPECT_EQ(HDF_SUCCESS, ret);
150 audiopara.delayTime = (audiopara.end.tv_sec * MICROSECOND + audiopara.end.tv_usec) -
151 (audiopara.start.tv_sec * MICROSECOND + audiopara.start.tv_usec);
152 audiopara.totalTime += audiopara.delayTime;
153 ret = audiopara.adapter->GetPassthroughMode(audiopara.adapter, &audioPort, &mode);
154 EXPECT_EQ(HDF_SUCCESS, ret);
155 EXPECT_EQ(PORT_PASSTHROUGH_LPCM, mode);
156 }
157 audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT;
158 EXPECT_GT(LOWLATENCY, audiopara.averageDelayTime);
159 }
160 /**
161 * @tc.name AudioGetPassthroughModePerformance_001
162 * @tc.desc tests the performace of GetPassthroughMode interface by executing 1000 times,
163 * and calculates the delay time and average of Delay Time.
164 * @tc.type: PERF
165 */
166 HWTEST_F(AudioIdlHdiAdapterPerformaceTest, AudioGetPassthroughModePerformance_001, TestSize.Level1)
167 {
168 int32_t ret;
169 struct PrepareAudioPara audiopara = {
170 .adapter = adapter, .mode = PORT_PASSTHROUGH_LPCM, .delayTime = 0, .totalTime = 0, .averageDelayTime =0,
171 };
172 ASSERT_NE(nullptr, audiopara.adapter);
173 ret = audiopara.adapter->InitAllPorts(audiopara.adapter);
174 EXPECT_EQ(HDF_SUCCESS, ret);
175 ret = audiopara.adapter->SetPassthroughMode(audiopara.adapter, &audioPort, audiopara.mode);
176 EXPECT_EQ(HDF_SUCCESS, ret);
177
178 for (int i = 0; i < COUNT; ++i) {
179 AudioPortPassthroughMode mode = PORT_PASSTHROUGH_AUTO;
180 gettimeofday(&audiopara.start, NULL);
181 ret = audiopara.adapter->GetPassthroughMode(audiopara.adapter, &audioPort, &mode);
182 gettimeofday(&audiopara.end, NULL);
183 EXPECT_EQ(HDF_SUCCESS, ret);
184 EXPECT_EQ(PORT_PASSTHROUGH_LPCM, mode);
185 audiopara.delayTime = (audiopara.end.tv_sec * MICROSECOND + audiopara.end.tv_usec) -
186 (audiopara.start.tv_sec * MICROSECOND + audiopara.start.tv_usec);
187 audiopara.totalTime += audiopara.delayTime;
188 }
189 audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT;
190 EXPECT_GT(LOWLATENCY, audiopara.averageDelayTime);
191 }
192 /**
193 * @tc.name AudioCreateRenderPerformance_001
194 * @tc.desc tests the performace of CreateRender interface by executing 1000 times,
195 * and calculates the delay time and average of Delay Time.
196 * @tc.type: PERF
197 */
198 HWTEST_F(AudioIdlHdiAdapterPerformaceTest, AudioCreateRenderPerformance_001, TestSize.Level1)
199 {
200 int32_t ret;
201 struct PrepareAudioPara audiopara = {
202 .adapter = adapter, .delayTime = 0, .totalTime = 0, .averageDelayTime =0, .pins = PIN_OUT_SPEAKER
203 };
204 ASSERT_NE(nullptr, audiopara.adapter);
205 InitAttrs(audiopara.attrs);
206 InitDevDesc(audiopara.devDesc, audioPort.portId, audiopara.pins);
207
208 for (int i = 0; i < COUNT; ++i) {
209 gettimeofday(&audiopara.start, NULL);
210 ret = audiopara.adapter->CreateRender(audiopara.adapter, &audiopara.devDesc, &audiopara.attrs,
211 &audiopara.render);
212 gettimeofday(&audiopara.end, NULL);
213 EXPECT_EQ(HDF_SUCCESS, ret);
214 audiopara.delayTime = (audiopara.end.tv_sec * MICROSECOND + audiopara.end.tv_usec) -
215 (audiopara.start.tv_sec * MICROSECOND + audiopara.start.tv_usec);
216 audiopara.totalTime += audiopara.delayTime;
217 ret = audiopara.adapter->DestroyRender(audiopara.adapter, &audiopara.devDesc);
218 IAudioRenderRelease(audiopara.render, IS_STUB);
219 audiopara.render = nullptr;
220 EXPECT_EQ(HDF_SUCCESS, ret);
221 }
222 free(audiopara.devDesc.desc);
223 audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT;
224 EXPECT_GT(HIGHLATENCY, audiopara.averageDelayTime);
225 }
226 /**
227 * @tc.name AudioDestroyRenderPerformance_001
228 * @tc.desc tests the performace of DestroyRender interface by executing 1000 times,
229 * and calculates the delay time and average of Delay Time.
230 * @tc.type: PERF
231 */
232 HWTEST_F(AudioIdlHdiAdapterPerformaceTest, AudioDestroyRenderPerformance_001, TestSize.Level1)
233 {
234 int32_t ret;
235 struct PrepareAudioPara audiopara = {
236 .adapter = adapter, .delayTime = 0, .totalTime = 0, .averageDelayTime =0, .pins = PIN_OUT_SPEAKER
237 };
238 ASSERT_NE(nullptr, audiopara.adapter);
239 InitAttrs(audiopara.attrs);
240 InitDevDesc(audiopara.devDesc, audioPort.portId, audiopara.pins);
241
242 for (int i = 0; i < COUNT; ++i) {
243 ret = audiopara.adapter->CreateRender(audiopara.adapter, &audiopara.devDesc, &audiopara.attrs,
244 &audiopara.render);
245 EXPECT_EQ(HDF_SUCCESS, ret);
246 gettimeofday(&audiopara.start, NULL);
247 audiopara.adapter->DestroyRender(audiopara.adapter, &audiopara.devDesc);
248 gettimeofday(&audiopara.end, NULL);
249 audiopara.delayTime = (audiopara.end.tv_sec * MICROSECOND + audiopara.end.tv_usec) -
250 (audiopara.start.tv_sec * MICROSECOND + audiopara.start.tv_usec);
251 audiopara.totalTime += audiopara.delayTime;
252 }
253 free(audiopara.devDesc.desc);
254 audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT;
255 EXPECT_GT(LOWLATENCY, audiopara.averageDelayTime);
256 }
257 /**
258 * @tc.name AudioCreateCapturePerformance_001
259 * @tc.desc tests the performace of AudioCreateCapture interface by executing 1000 times,
260 * and calculates the delay time and average of Delay Time.
261 * @tc.type: PERF
262 */
263 HWTEST_F(AudioIdlHdiAdapterPerformaceTest, AudioCreateCapturePerformance_001, TestSize.Level1)
264 {
265 int32_t ret;
266 struct PrepareAudioPara audiopara = {
267 .adapter = adapter, .delayTime = 0, .averageDelayTime =0, .totalTime = 0, .pins = PIN_IN_MIC
268 };
269 ASSERT_NE(nullptr, audiopara.adapter);
270 InitAttrs(audiopara.attrs);
271 InitDevDesc(audiopara.devDesc, audioPort.portId, audiopara.pins);
272 for (int i = 0; i < COUNT; ++i) {
273 gettimeofday(&audiopara.start, NULL);
274 ret = audiopara.adapter->CreateCapture(audiopara.adapter, &audiopara.devDesc, &audiopara.attrs,
275 &audiopara.capture);
276 gettimeofday(&audiopara.end, NULL);
277 audiopara.delayTime = (audiopara.end.tv_sec * MICROSECOND + audiopara.end.tv_usec) -
278 (audiopara.start.tv_sec * MICROSECOND + audiopara.start.tv_usec);
279 audiopara.totalTime += audiopara.delayTime;
280 ret = audiopara.adapter->DestroyCapture(audiopara.adapter, &audiopara.devDesc);
281 IAudioCaptureRelease(audiopara.capture, IS_STUB);
282 audiopara.capture = nullptr;
283 EXPECT_EQ(HDF_SUCCESS, ret);
284 }
285 free(audiopara.devDesc.desc);
286 audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT;
287 EXPECT_GT(HIGHLATENCY, audiopara.averageDelayTime);
288 }
289 /**
290 * @tc.name AudioDestroyCapturePerformance_001
291 * @tc.desc tests the performace of AudioDestroyCapture interface by executing 1000 times,
292 * and calculates the delay time and average of Delay Time.
293 * @tc.type: PERF
294 */
295 HWTEST_F(AudioIdlHdiAdapterPerformaceTest, AudioDestroyCapturePerformance_001, TestSize.Level1)
296 {
297 int32_t ret;
298 struct PrepareAudioPara audiopara = {
299 .adapter = adapter, .delayTime = 0, .totalTime = 0, .averageDelayTime =0, .pins = PIN_IN_MIC
300 };
301 ASSERT_NE(nullptr, audiopara.adapter);
302 InitAttrs(audiopara.attrs);
303 InitDevDesc(audiopara.devDesc, audioPort.portId, audiopara.pins);
304 for (int i = 0; i < COUNT; ++i) {
305 ret = audiopara.adapter->CreateCapture(audiopara.adapter, &audiopara.devDesc, &audiopara.attrs,
306 &audiopara.capture);
307 ASSERT_EQ(HDF_SUCCESS, ret);
308 gettimeofday(&audiopara.start, NULL);
309 ret = audiopara.adapter->DestroyCapture(audiopara.adapter, &audiopara.devDesc);
310 IAudioCaptureRelease(audiopara.capture, IS_STUB);
311 gettimeofday(&audiopara.end, NULL);
312 EXPECT_EQ(HDF_SUCCESS, ret);
313 audiopara.capture = nullptr;
314 audiopara.delayTime = (audiopara.end.tv_sec * MICROSECOND + audiopara.end.tv_usec) -
315 (audiopara.start.tv_sec * MICROSECOND + audiopara.start.tv_usec);
316 audiopara.totalTime += audiopara.delayTime;
317 }
318 free(audiopara.devDesc.desc);
319 audiopara.averageDelayTime = (float)audiopara.totalTime / COUNT;
320 EXPECT_GT(LOWLATENCY, audiopara.averageDelayTime);
321 }
322 }
323