1 /*
2 * Copyright (c) 2022-2023 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 <benchmark/benchmark.h>
17 #include <cmath>
18 #include <cstdio>
19 #include <gtest/gtest.h>
20 #include <securec.h>
21 #include <string>
22 #include <unistd.h>
23 #include <vector>
24 #include "hdf_base.h"
25 #include "osal_time.h"
26 #include "sensor_callback_impl.h"
27 #include "sensor_type.h"
28 #include "sensor_uhdf_log.h"
29 #include "v3_0/isensor_interface.h"
30
31 using namespace OHOS::HDI::Sensor::V3_0;
32 using namespace OHOS::HDI::Sensor;
33 using namespace testing::ext;
34 using namespace std;
35
36 namespace {
37 sptr<ISensorInterface> g_sensorInterface = nullptr;
38 sptr<V3_0::ISensorCallback> g_traditionalCallback = new SensorCallbackImpl();
39 sptr<V3_0::ISensorCallback> g_medicalCallback = new SensorCallbackImpl();
40 std::vector<HdfSensorInformation> g_info;
41
42 constexpr int32_t ITERATION_FREQUENCY = 100;
43 constexpr int32_t REPETITION_FREQUENCY = 3;
44 constexpr int32_t SENSOR_INTERVAL1 = 20;
45 constexpr int32_t SENSOR_INTERVAL2 = 2;
46 constexpr int32_t SENSOR_POLL_TIME = 3;
47 constexpr int32_t SENSOR_WAIT_TIME = 10;
48 constexpr uint32_t OPTION = 0;
49 constexpr uint32_t SENSOR_DATA_FLAG = 1;
50 constexpr int32_t RATE_LEVEL = 50;
51
52 class SensorBenchmarkTest : public benchmark::Fixture {
53 public:
54 void SetUp(const ::benchmark::State &state);
55 void TearDown(const ::benchmark::State &state);
56 };
57
SetUp(const::benchmark::State & state)58 void SensorBenchmarkTest::SetUp(const ::benchmark::State &state)
59 {
60 g_sensorInterface = ISensorInterface::Get();
61 }
62
TearDown(const::benchmark::State & state)63 void SensorBenchmarkTest::TearDown(const ::benchmark::State &state)
64 {
65 }
66
67 /**
68 * @tc.name: DriverSystem_SensorBenchmark_GetAllSensorInfo
69 * @tc.desc: Benchmarktest for interface GetAllSensorInfo
70 * Obtains information about all sensors in the system
71 * @tc.type: FUNC
72 */
BENCHMARK_F(SensorBenchmarkTest,GetAllSensorInfo)73 BENCHMARK_F(SensorBenchmarkTest, GetAllSensorInfo)(benchmark::State &state)
74 {
75 ASSERT_NE(nullptr, g_sensorInterface);
76
77 int32_t ret;
78
79 for (auto _ : state) {
80 ret = g_sensorInterface->GetAllSensorInfo(g_info);
81 EXPECT_EQ(SENSOR_SUCCESS, ret);
82 }
83 }
84
85 BENCHMARK_REGISTER_F(SensorBenchmarkTest, GetAllSensorInfo)->
86 Iterations(ITERATION_FREQUENCY)->Repetitions(REPETITION_FREQUENCY)->ReportAggregatesOnly();
87
88 /**
89 * @tc.name: DriverSystem_SensorBenchmark_register
90 * @tc.desc: Benchmarktest for interface register
91 * Returns 0 if the callback is successfully registered; returns a negative value otherwise
92 * @tc.type: FUNC
93 */
BENCHMARK_F(SensorBenchmarkTest,register)94 BENCHMARK_F(SensorBenchmarkTest, register)(benchmark::State &state)
95 {
96 ASSERT_NE(nullptr, g_sensorInterface);
97
98 int32_t ret;
99
100 for (auto _ : state) {
101 ret = g_sensorInterface->Register(TRADITIONAL_SENSOR_TYPE, g_traditionalCallback);
102 EXPECT_EQ(SENSOR_SUCCESS, ret);
103 }
104 ret = g_sensorInterface->Unregister(TRADITIONAL_SENSOR_TYPE, g_traditionalCallback);
105 EXPECT_EQ(SENSOR_SUCCESS, ret);
106 }
107
108 BENCHMARK_REGISTER_F(SensorBenchmarkTest, register)->
109 Iterations(ITERATION_FREQUENCY)->Repetitions(REPETITION_FREQUENCY)->ReportAggregatesOnly();
110
111 /**
112 * @tc.name: DriverSystem_SensorBenchmark_Unregister
113 * @tc.desc: Benchmarktest for interface Unregister
114 * Returns 0 if the callback is successfully registered; returns a negative value otherwise
115 * @tc.type: FUNC
116 */
BENCHMARK_F(SensorBenchmarkTest,Unregister)117 BENCHMARK_F(SensorBenchmarkTest, Unregister)(benchmark::State &state)
118 {
119 ASSERT_NE(nullptr, g_sensorInterface);
120
121 int32_t ret;
122
123 for (auto _ : state) {
124 ret = g_sensorInterface->Register(TRADITIONAL_SENSOR_TYPE, g_traditionalCallback);
125 OsalMSleep(SENSOR_POLL_TIME);
126 EXPECT_EQ(SENSOR_SUCCESS, ret);
127 ret = g_sensorInterface->Unregister(TRADITIONAL_SENSOR_TYPE, g_traditionalCallback);
128 OsalMSleep(SENSOR_POLL_TIME);
129 EXPECT_EQ(SENSOR_SUCCESS, ret);
130 }
131 }
132
133 BENCHMARK_REGISTER_F(SensorBenchmarkTest, Unregister)->
134 Iterations(ITERATION_FREQUENCY)->Repetitions(REPETITION_FREQUENCY)->ReportAggregatesOnly();
135
136 /**
137 * @tc.name: DriverSystem_SensorBenchmark_Enable
138 * @tc.desc: Benchmarktest for interface Enable
139 * Enables the sensor unavailable in the sensor list based on the specified sensor ID
140 * @tc.type: FUNC
141 */
BENCHMARK_F(SensorBenchmarkTest,Enable)142 BENCHMARK_F(SensorBenchmarkTest, Enable)(benchmark::State &state)
143 {
144 ASSERT_NE(nullptr, g_sensorInterface);
145
146 int32_t ret;
147
148 ret = g_sensorInterface->Register(TRADITIONAL_SENSOR_TYPE, g_traditionalCallback);
149 EXPECT_EQ(SENSOR_SUCCESS, ret);
150
151 EXPECT_GT(g_info.size(), 0);
152
153 for (auto iter : g_info) {
154 HDF_LOGI("deviceSensorInfo deviceId%{public}d sensorType%{public}d sensorId%{public}d location%{public}d, "
155 "info name[%{public}s], power[%{public}f]\n\r", iter.deviceSensorInfo.deviceId,
156 iter.deviceSensorInfo.sensorType, iter.deviceSensorInfo.sensorId, iter.deviceSensorInfo.location,
157 iter.sensorName.c_str(), iter.power);
158 ret = g_sensorInterface->SetBatch({iter.deviceSensorInfo.deviceId, iter.deviceSensorInfo.sensorType,
159 iter.deviceSensorInfo.sensorId, iter.deviceSensorInfo.location},
160 SENSOR_INTERVAL1, SENSOR_POLL_TIME);
161 EXPECT_EQ(SENSOR_SUCCESS, ret);
162 for (auto _ : state) {
163 ret = g_sensorInterface->Enable({iter.deviceSensorInfo.deviceId, iter.deviceSensorInfo.sensorType,
164 iter.deviceSensorInfo.sensorId, iter.deviceSensorInfo.location});
165 EXPECT_EQ(SENSOR_SUCCESS, ret);
166 }
167 OsalMSleep(SENSOR_POLL_TIME);
168 ret = g_sensorInterface->Disable({iter.deviceSensorInfo.deviceId, iter.deviceSensorInfo.sensorType,
169 iter.deviceSensorInfo.sensorId, iter.deviceSensorInfo.location});
170 EXPECT_EQ(SENSOR_SUCCESS, ret);
171 }
172 ret = g_sensorInterface->Unregister(TRADITIONAL_SENSOR_TYPE, g_traditionalCallback);
173 EXPECT_EQ(SensorCallbackImpl::sensorDataFlag, SENSOR_DATA_FLAG);
174 SensorCallbackImpl::sensorDataFlag = SENSOR_DATA_FLAG;
175 }
176
177 BENCHMARK_REGISTER_F(SensorBenchmarkTest, Enable)->
178 Iterations(ITERATION_FREQUENCY)->Repetitions(REPETITION_FREQUENCY)->ReportAggregatesOnly();
179
180 /**
181 * @tc.name: DriverSystem_SensorBenchmark_Disable
182 * @tc.desc: Benchmarktest for interface Disable
183 * Enables the sensor unavailable in the sensor list based on the specified sensor ID
184 * @tc.type: FUNC
185 */
BENCHMARK_F(SensorBenchmarkTest,Disable)186 BENCHMARK_F(SensorBenchmarkTest, Disable)(benchmark::State &state)
187 {
188 ASSERT_NE(nullptr, g_sensorInterface);
189
190 int32_t ret;
191
192 ret = g_sensorInterface->Register(TRADITIONAL_SENSOR_TYPE, g_traditionalCallback);
193 EXPECT_EQ(SENSOR_SUCCESS, ret);
194 EXPECT_GT(g_info.size(), 0);
195
196 for (auto iter : g_info) {
197 HDF_LOGI("deviceSensorInfo deviceId%{public}d sensorType%{public}d sensorId%{public}d location%{public}d, "
198 "info name[%{public}s], power[%{public}f]\n\r", iter.deviceSensorInfo.deviceId,
199 iter.deviceSensorInfo.sensorType, iter.deviceSensorInfo.sensorId, iter.deviceSensorInfo.location,
200 iter.sensorName.c_str(), iter.power);
201 ret = g_sensorInterface->SetBatch({iter.deviceSensorInfo.deviceId, iter.deviceSensorInfo.sensorType,
202 iter.deviceSensorInfo.sensorId, iter.deviceSensorInfo.location},
203 SENSOR_INTERVAL1, SENSOR_POLL_TIME);
204 EXPECT_EQ(SENSOR_SUCCESS, ret);
205 ret = g_sensorInterface->Enable({iter.deviceSensorInfo.deviceId, iter.deviceSensorInfo.sensorType,
206 iter.deviceSensorInfo.sensorId, iter.deviceSensorInfo.location});
207 EXPECT_EQ(SENSOR_SUCCESS, ret);
208 OsalMSleep(SENSOR_POLL_TIME);
209 for (auto _ : state) {
210 ret = g_sensorInterface->Disable({iter.deviceSensorInfo.deviceId, iter.deviceSensorInfo.sensorType,
211 iter.deviceSensorInfo.sensorId, iter.deviceSensorInfo.location});
212 EXPECT_EQ(SENSOR_SUCCESS, ret);
213 }
214 }
215 ret = g_sensorInterface->Unregister(TRADITIONAL_SENSOR_TYPE, g_traditionalCallback);
216 EXPECT_EQ(SensorCallbackImpl::sensorDataFlag, SENSOR_DATA_FLAG);
217 SensorCallbackImpl::sensorDataFlag = SENSOR_DATA_FLAG;
218 }
219
220 BENCHMARK_REGISTER_F(SensorBenchmarkTest, Disable)->
221 Iterations(ITERATION_FREQUENCY)->Repetitions(REPETITION_FREQUENCY)->ReportAggregatesOnly();
222
223 /**
224 * @tc.name: DriverSystem_SensorBenchmark_SetBatch
225 * @tc.desc: Benchmarktest for interface SetBatch
226 * Sets the sampling time and data report interval for sensors in batches
227 * @tc.type: FUNC
228 */
BENCHMARK_F(SensorBenchmarkTest,SetBatch)229 BENCHMARK_F(SensorBenchmarkTest, SetBatch)(benchmark::State &state)
230 {
231 ASSERT_NE(nullptr, g_sensorInterface);
232
233 int32_t ret;
234
235 ret = g_sensorInterface->Register(TRADITIONAL_SENSOR_TYPE, g_traditionalCallback);
236 EXPECT_EQ(SENSOR_SUCCESS, ret);
237
238 EXPECT_GT(g_info.size(), 0);
239 for (auto iter : g_info) {
240 HDF_LOGI("deviceSensorInfo deviceId%{public}d sensorType%{public}d sensorId%{public}d location%{public}d, "
241 "info name[%{public}s], power[%{public}f]\n\r", iter.deviceSensorInfo.deviceId,
242 iter.deviceSensorInfo.sensorType, iter.deviceSensorInfo.sensorId, iter.deviceSensorInfo.location,
243 iter.sensorName.c_str(), iter.power);
244 for (auto _ : state) {
245 ret = g_sensorInterface->SetBatch({iter.deviceSensorInfo.deviceId, iter.deviceSensorInfo.sensorType,
246 iter.deviceSensorInfo.sensorId, iter.deviceSensorInfo.location},
247 SENSOR_INTERVAL2, SENSOR_POLL_TIME);
248 EXPECT_EQ(SENSOR_SUCCESS, ret);
249 }
250 ret = g_sensorInterface->Enable({iter.deviceSensorInfo.deviceId, iter.deviceSensorInfo.sensorType,
251 iter.deviceSensorInfo.sensorId, iter.deviceSensorInfo.location});
252 EXPECT_EQ(SENSOR_SUCCESS, ret);
253 OsalMSleep(SENSOR_WAIT_TIME);
254 ret = g_sensorInterface->Disable({iter.deviceSensorInfo.deviceId, iter.deviceSensorInfo.sensorType,
255 iter.deviceSensorInfo.sensorId, iter.deviceSensorInfo.location});
256 EXPECT_EQ(SENSOR_SUCCESS, ret);
257 }
258 ret = g_sensorInterface->Unregister(TRADITIONAL_SENSOR_TYPE, g_traditionalCallback);
259 EXPECT_EQ(SENSOR_SUCCESS, ret);
260 EXPECT_EQ(SensorCallbackImpl::sensorDataFlag, SENSOR_DATA_FLAG);
261 SensorCallbackImpl::sensorDataFlag = SENSOR_DATA_FLAG;
262 }
263
264 BENCHMARK_REGISTER_F(SensorBenchmarkTest, SetBatch)->
265 Iterations(ITERATION_FREQUENCY)->Repetitions(REPETITION_FREQUENCY)->ReportAggregatesOnly();
266
267 /**
268 * @tc.name: DriverSystem_SensorBenchmark_SetMode
269 * @tc.desc: Benchmarktest for interface SetMode
270 * Sets the data reporting mode for the specified sensor
271 * @tc.type: FUNC
272 */
BENCHMARK_F(SensorBenchmarkTest,SetMode)273 BENCHMARK_F(SensorBenchmarkTest, SetMode)(benchmark::State &state)
274 {
275 ASSERT_NE(nullptr, g_sensorInterface);
276 EXPECT_GT(g_info.size(), 0);
277
278 int32_t ret;
279 EXPECT_GT(g_info.size(), 0);
280 for (auto iter : g_info) {
281 HDF_LOGI("deviceSensorInfo deviceId%{public}d sensorType%{public}d sensorId%{public}d location%{public}d, "
282 "info name[%{public}s], power[%{public}f]\n\r", iter.deviceSensorInfo.deviceId,
283 iter.deviceSensorInfo.sensorType, iter.deviceSensorInfo.sensorId, iter.deviceSensorInfo.location,
284 iter.sensorName.c_str(), iter.power);
285 ret = g_sensorInterface->SetBatch({iter.deviceSensorInfo.deviceId, iter.deviceSensorInfo.sensorType,
286 iter.deviceSensorInfo.sensorId, iter.deviceSensorInfo.location},
287 SENSOR_INTERVAL1, SENSOR_POLL_TIME);
288 EXPECT_EQ(SENSOR_SUCCESS, ret);
289 for (auto _ : state) {
290 if (SENSOR_TYPE_HALL == 0) {
291 ret = g_sensorInterface->SetMode({iter.deviceSensorInfo.deviceId, iter.deviceSensorInfo.sensorType,
292 iter.deviceSensorInfo.sensorId, iter.deviceSensorInfo.location},
293 SENSOR_MODE_ON_CHANGE);
294 } else {
295 ret = g_sensorInterface->SetMode({iter.deviceSensorInfo.deviceId, iter.deviceSensorInfo.sensorType,
296 iter.deviceSensorInfo.sensorId, iter.deviceSensorInfo.location},
297 SENSOR_MODE_REALTIME);
298 }
299 EXPECT_EQ(SENSOR_SUCCESS, ret);
300 }
301 ret = g_sensorInterface->Enable({iter.deviceSensorInfo.deviceId, iter.deviceSensorInfo.sensorType,
302 iter.deviceSensorInfo.sensorId, iter.deviceSensorInfo.location});
303 EXPECT_EQ(SENSOR_SUCCESS, ret);
304 OsalMSleep(SENSOR_WAIT_TIME);
305 ret = g_sensorInterface->Disable({iter.deviceSensorInfo.deviceId, iter.deviceSensorInfo.sensorType,
306 iter.deviceSensorInfo.sensorId, iter.deviceSensorInfo.location});
307 EXPECT_EQ(SENSOR_SUCCESS, ret);
308 }
309 }
310
311 BENCHMARK_REGISTER_F(SensorBenchmarkTest, SetMode)->
312 Iterations(ITERATION_FREQUENCY)->Repetitions(REPETITION_FREQUENCY)->ReportAggregatesOnly();
313
314 /**
315 * @tc.name: DriverSystem_SensorBenchmark_SetOption
316 * @tc.desc: Benchmarktest for interface SetOption
317 * Sets options for the specified sensor, including its measurement range and accuracy
318 * @tc.type: FUNC
319 */
BENCHMARK_F(SensorBenchmarkTest,SetOption)320 BENCHMARK_F(SensorBenchmarkTest, SetOption)(benchmark::State &state)
321 {
322 ASSERT_NE(nullptr, g_sensorInterface);
323 EXPECT_GT(g_info.size(), 0);
324
325 int32_t ret;
326 EXPECT_GT(g_info.size(), 0);
327 for (auto iter : g_info) {
328 HDF_LOGI("deviceSensorInfo deviceId%{public}d sensorType%{public}d sensorId%{public}d location%{public}d, "
329 "info name[%{public}s], power[%{public}f]\n\r", iter.deviceSensorInfo.deviceId,
330 iter.deviceSensorInfo.sensorType, iter.deviceSensorInfo.sensorId, iter.deviceSensorInfo.location,
331 iter.sensorName.c_str(), iter.power);
332 for (auto _ : state) {
333 ret = g_sensorInterface->SetOption({iter.deviceSensorInfo.deviceId, iter.deviceSensorInfo.sensorType,
334 iter.deviceSensorInfo.sensorId, iter.deviceSensorInfo.location},
335 OPTION);
336 EXPECT_EQ(SENSOR_SUCCESS, ret);
337 }
338 }
339 }
340
341 BENCHMARK_REGISTER_F(SensorBenchmarkTest, SetOption)->
342 Iterations(ITERATION_FREQUENCY)->Repetitions(REPETITION_FREQUENCY)->ReportAggregatesOnly();
343
344 /**
345 * @tc.name: DriverSystem_SensorBenchmark_SetSdcSensor
346 * @tc.desc: Benchmarktest for interface SetSdcSensor
347 * Sets options for the specified sensor, including its measurement range and accuracy
348 * @tc.type: FUNC
349 */
BENCHMARK_F(SensorBenchmarkTest,SetSdcSensor)350 BENCHMARK_F(SensorBenchmarkTest, SetSdcSensor)(benchmark::State &state)
351 {
352 ASSERT_NE(nullptr, g_sensorInterface);
353 EXPECT_GT(g_info.size(), 0);
354
355 int32_t ret;
356 EXPECT_GT(g_info.size(), 0);
357 for (auto iter : g_info) {
358 HDF_LOGI("deviceSensorInfo deviceId%{public}d sensorType%{public}d sensorId%{public}d location%{public}d, "
359 "info name[%{public}s], power[%{public}f]\n\r", iter.deviceSensorInfo.deviceId,
360 iter.deviceSensorInfo.sensorType, iter.deviceSensorInfo.sensorId, iter.deviceSensorInfo.location,
361 iter.sensorName.c_str(), iter.power);
362 for (auto _ : state) {
363 ret = g_sensorInterface->SetSdcSensor({0, iter.deviceSensorInfo.sensorType, 0, 0}, true, RATE_LEVEL);
364 EXPECT_EQ(SENSOR_SUCCESS, ret);
365 OsalMSleep(SENSOR_WAIT_TIME);
366 ret = g_sensorInterface->SetSdcSensor({0, iter.deviceSensorInfo.sensorType, 0, 0}, false, RATE_LEVEL);
367 EXPECT_EQ(SENSOR_SUCCESS, ret);
368 }
369 }
370 }
371
372 BENCHMARK_REGISTER_F(SensorBenchmarkTest, SetSdcSensor)->
373 Iterations(ITERATION_FREQUENCY)->Repetitions(REPETITION_FREQUENCY)->ReportAggregatesOnly();
374
375 /**
376 * @tc.name: DriverSystem_SensorBenchmark_GetSdcSensorInfo
377 * @tc.desc: Benchmarktest for interface GetSdcSensorInfo
378 * Sets options for the specified sensor, including its measurement range and accuracy
379 * @tc.type: FUNC
380 */
BENCHMARK_F(SensorBenchmarkTest,GetSdcSensorInfo)381 BENCHMARK_F(SensorBenchmarkTest, GetSdcSensorInfo)(benchmark::State &state)
382 {
383 ASSERT_NE(nullptr, g_sensorInterface);
384 EXPECT_GT(g_info.size(), 0);
385
386 int32_t ret;
387 EXPECT_GT(g_info.size(), 0);
388 for (auto iter : g_info) {
389 HDF_LOGI("deviceSensorInfo deviceId%{public}d sensorType%{public}d sensorId%{public}d location%{public}d, "
390 "info name[%{public}s], power[%{public}f]\n\r", iter.deviceSensorInfo.deviceId,
391 iter.deviceSensorInfo.sensorType, iter.deviceSensorInfo.sensorId, iter.deviceSensorInfo.location,
392 iter.sensorName.c_str(), iter.power);
393 for (auto _ : state) {
394 std::vector<OHOS::HDI::Sensor::V3_0::SdcSensorInfo> sdcSensorInfo;
395 ret = g_sensorInterface->GetSdcSensorInfo(sdcSensorInfo);
396 EXPECT_EQ(SENSOR_SUCCESS, ret);
397 }
398 }
399 }
400
401 BENCHMARK_REGISTER_F(SensorBenchmarkTest, GetSdcSensorInfo)->
402 Iterations(ITERATION_FREQUENCY)->Repetitions(REPETITION_FREQUENCY)->ReportAggregatesOnly();
403
404 /**
405 * @tc.name: DriverSystem_SensorBenchmark_RegisterAsync
406 * @tc.desc: Benchmarktest for interface RegisterAsync
407 * Sets options for the specified sensor, including its measurement range and accuracy
408 * @tc.type: FUNC
409 */
BENCHMARK_F(SensorBenchmarkTest,RegisterAsync)410 BENCHMARK_F(SensorBenchmarkTest, RegisterAsync)(benchmark::State &state)
411 {
412 ASSERT_NE(nullptr, g_sensorInterface);
413 EXPECT_GT(g_info.size(), 0);
414
415 int32_t ret;
416 EXPECT_GT(g_info.size(), 0);
417 for (auto iter : g_info) {
418 HDF_LOGI("deviceSensorInfo deviceId%{public}d sensorType%{public}d sensorId%{public}d location%{public}d, "
419 "info name[%{public}s], power[%{public}f]\n\r", iter.deviceSensorInfo.deviceId,
420 iter.deviceSensorInfo.sensorType, iter.deviceSensorInfo.sensorId, iter.deviceSensorInfo.location,
421 iter.sensorName.c_str(), iter.power);
422 for (auto _ : state) {
423 ret = g_sensorInterface->RegisterAsync(TRADITIONAL_SENSOR_TYPE, g_traditionalCallback);
424 EXPECT_EQ(SENSOR_SUCCESS, ret);
425 ret = g_sensorInterface->UnregisterAsync(TRADITIONAL_SENSOR_TYPE, g_traditionalCallback);
426 EXPECT_EQ(SENSOR_SUCCESS, ret);
427 }
428 }
429 }
430
431 BENCHMARK_REGISTER_F(SensorBenchmarkTest, GetSdcSensorInfo)->
432 Iterations(ITERATION_FREQUENCY)->Repetitions(REPETITION_FREQUENCY)->ReportAggregatesOnly();
433
434 /**
435 * @tc.name: DriverSystem_SensorBenchmark_GetDeviceSensorInfo
436 * @tc.desc: Benchmarktest for interface GetDeviceSensorInfo
437 * Obtains information about all sensors in the system
438 * @tc.type: FUNC
439 */
BENCHMARK_F(SensorBenchmarkTest,GetDeviceSensorInfo)440 BENCHMARK_F(SensorBenchmarkTest, GetDeviceSensorInfo)(benchmark::State &state)
441 {
442 ASSERT_NE(nullptr, g_sensorInterface);
443
444 int32_t ret;
445
446 for (auto iter : g_info) {
447 for (auto _ : state) {
448 ret = g_sensorInterface->GetDeviceSensorInfo(iter.deviceSensorInfo.deviceId, g_info);
449 EXPECT_EQ(SENSOR_SUCCESS, ret);
450 }
451 }
452 }
453
454 BENCHMARK_REGISTER_F(SensorBenchmarkTest, GetDeviceSensorInfo)->
455 Iterations(ITERATION_FREQUENCY)->Repetitions(REPETITION_FREQUENCY)->ReportAggregatesOnly();
456 }
457 BENCHMARK_MAIN();
458