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 <benchmark/benchmark.h>
17 #include <cmath>
18 #include <cstdio>
19 #include <gtest/gtest.h>
20 #include <securec.h>
21 #include <string>
22 #include <vector>
23 #include "hdf_base.h"
24 #include "light_type.h"
25 #include "osal_time.h"
26 #include "v1_0/ilight_interface.h"
27
28 using namespace OHOS::HDI::Light::V1_0;
29 using namespace testing::ext;
30 using namespace std;
31
32 namespace {
33 constexpr int32_t ITERATION_FREQUENCY = 100;
34 constexpr int32_t REPETITION_FREQUENCY = 3;
35 constexpr int32_t COLORVALUE_RED = 255;
36 constexpr int32_t COLORVALUE_GREEN = 0;
37 constexpr int32_t COLORVALUE_BLUE = 0;
38 constexpr uint32_t SLEEP_TIME = 3;
39 constexpr int32_t MIN_LIGHT_ID = HDF_LIGHT_ID_BATTERY;
40 constexpr int32_t MAX_LIGHT_ID = HDF_LIGHT_ID_ATTENTION;
41 constexpr int32_t ON_TIME = 500;
42 constexpr int32_t OFF_TIME = 500;
43 sptr<ILightInterface> g_lightInterface = nullptr;
44
45 class LightBenchmarkTest : public benchmark::Fixture {
46 public:
47 void SetUp(const ::benchmark::State &state);
48 void TearDown(const ::benchmark::State &state);
49 };
50
SetUp(const::benchmark::State & state)51 void LightBenchmarkTest::SetUp(const ::benchmark::State &state)
52 {
53 g_lightInterface = ILightInterface::Get();
54 }
55
TearDown(const::benchmark::State & state)56 void LightBenchmarkTest::TearDown(const ::benchmark::State &state)
57 {
58 }
59
60 /**
61 * @tc.name: SUB_DriverSystem_LightBenchmark_GetLightInfo
62 * @tc.desc: Benchmarktest for interface GetLightInfo
63 * @tc.type: FUNC
64 */
BENCHMARK_F(LightBenchmarkTest,GetLightInfo)65 BENCHMARK_F(LightBenchmarkTest, GetLightInfo)(benchmark::State &st)
66 {
67 ASSERT_NE(nullptr, g_lightInterface);
68
69 std::vector<HdfLightInfo> info;
70 int32_t ret;
71
72 for (auto _ : st) {
73 ret = g_lightInterface->GetLightInfo(info);
74 EXPECT_EQ(HDF_SUCCESS, ret);
75 }
76
77 for (auto iter : info) {
78 EXPECT_GE(iter.lightId, MIN_LIGHT_ID);
79 EXPECT_LE(iter.lightId, MAX_LIGHT_ID);
80 }
81 }
82
83 BENCHMARK_REGISTER_F(LightBenchmarkTest, GetLightInfo)->
84 Iterations(ITERATION_FREQUENCY)->Repetitions(REPETITION_FREQUENCY)->ReportAggregatesOnly();
85
86 /**
87 * @tc.name: SUB_DriverSystem_LightBenchmark_TurnOnLight
88 * @tc.desc: Benchmarktest for interface TurnOnLight
89 * @tc.type: FUNC
90 */
BENCHMARK_F(LightBenchmarkTest,TurnOnLight)91 BENCHMARK_F(LightBenchmarkTest, TurnOnLight)(benchmark::State &st)
92 {
93 ASSERT_NE(nullptr, g_lightInterface);
94
95 std::vector<HdfLightInfo> info;
96 int32_t ret;
97
98 ret = g_lightInterface->GetLightInfo(info);
99 EXPECT_EQ(HDF_SUCCESS, ret);
100
101 for (auto iter : info) {
102 EXPECT_GE(iter.lightId, MIN_LIGHT_ID);
103 EXPECT_LE(iter.lightId, MAX_LIGHT_ID);
104
105 HdfLightEffect effect;
106 effect.lightColor.colorValue.rgbColor.r = COLORVALUE_RED;
107 effect.lightColor.colorValue.rgbColor.g = COLORVALUE_GREEN;
108 effect.lightColor.colorValue.rgbColor.b = COLORVALUE_BLUE;
109 effect.flashEffect.flashMode = LIGHT_FLASH_NONE;
110
111 for (auto _ : st) {
112 ret = g_lightInterface->TurnOnLight(iter.lightId, effect);
113 EXPECT_EQ(HDF_SUCCESS, ret);
114 }
115 OsalMSleep(SLEEP_TIME);
116 ret = g_lightInterface->TurnOffLight(iter.lightId);
117 EXPECT_EQ(HDF_SUCCESS, ret);
118 }
119 }
120
121 BENCHMARK_REGISTER_F(LightBenchmarkTest, TurnOnLight)->
122 Iterations(ITERATION_FREQUENCY)->Repetitions(REPETITION_FREQUENCY)->ReportAggregatesOnly();
123
124 /**
125 * @tc.name: SUB_DriverSystem_LightBenchmark_TurnOffLight
126 * @tc.desc: Benchmarktest for interface TurnOffLight
127 * @tc.type: FUNC
128 */
BENCHMARK_F(LightBenchmarkTest,TurnOffLight)129 BENCHMARK_F(LightBenchmarkTest, TurnOffLight)(benchmark::State &st)
130 {
131 ASSERT_NE(nullptr, g_lightInterface);
132
133 std::vector<HdfLightInfo> info;
134 int32_t ret;
135
136 ret = g_lightInterface->GetLightInfo(info);
137 EXPECT_EQ(HDF_SUCCESS, ret);
138
139 for (auto iter : info) {
140 EXPECT_GE(iter.lightId, MIN_LIGHT_ID);
141 EXPECT_LE(iter.lightId, MAX_LIGHT_ID);
142
143 HdfLightEffect effect;
144 effect.lightColor.colorValue.rgbColor.r = COLORVALUE_RED;
145 effect.lightColor.colorValue.rgbColor.g = COLORVALUE_GREEN;
146 effect.lightColor.colorValue.rgbColor.b = COLORVALUE_BLUE;
147 effect.flashEffect.flashMode = LIGHT_FLASH_BLINK;
148 effect.flashEffect.onTime = ON_TIME;
149 effect.flashEffect.offTime = OFF_TIME;
150 ret = g_lightInterface->TurnOnLight(iter.lightId, effect);
151 EXPECT_EQ(HDF_SUCCESS, ret);
152 OsalMSleep(SLEEP_TIME);
153 for (auto _ : st) {
154 ret = g_lightInterface->TurnOffLight(iter.lightId);
155 EXPECT_EQ(HDF_SUCCESS, ret);
156 }
157 }
158 }
159
160 BENCHMARK_REGISTER_F(LightBenchmarkTest, TurnOffLight)->
161 Iterations(ITERATION_FREQUENCY)->Repetitions(REPETITION_FREQUENCY)->ReportAggregatesOnly();
162
163 /**
164 * @tc.name: SUB_DriverSystem_LightBenchmark_TurnOnMultiLights
165 * @tc.desc: Benchmarktest for interface TurnOnMultiLights
166 * @tc.type: FUNC
167 */
BENCHMARK_F(LightBenchmarkTest,TurnOnMultiLights)168 BENCHMARK_F(LightBenchmarkTest, TurnOnMultiLights)(benchmark::State &st)
169 {
170 ASSERT_NE(nullptr, g_lightInterface);
171
172 std::vector<HdfLightInfo> info;
173 int32_t ret;
174
175 ret = g_lightInterface->GetLightInfo(info);
176 EXPECT_EQ(0, ret);
177
178 for (auto iter : info) {
179 EXPECT_GE(iter.lightId, MIN_LIGHT_ID);
180 EXPECT_LE(iter.lightId, MAX_LIGHT_ID);
181 std::vector<HdfLightColor> lightColor;
182 struct HdfLightColor light;
183 light.colorValue.rgbColor.b = COLORVALUE_BLUE;
184 lightColor.push_back(light);
185 for (auto _ : st) {
186 ret = g_lightInterface->TurnOnMultiLights(iter.lightId, lightColor);
187 EXPECT_EQ(HDF_SUCCESS, ret);
188 }
189 }
190 }
191
192 BENCHMARK_REGISTER_F(LightBenchmarkTest, TurnOnMultiLights)->
193 Iterations(ITERATION_FREQUENCY)->Repetitions(REPETITION_FREQUENCY)->ReportAggregatesOnly();
194 }
195
196 BENCHMARK_MAIN();
197