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