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
28using namespace OHOS::HDI::Light::V1_0;
29using namespace testing::ext;
30using namespace std;
31
32namespace {
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
45class LightBenchmarkTest : public benchmark::Fixture {
46public:
47    void SetUp(const ::benchmark::State &state);
48    void TearDown(const ::benchmark::State &state);
49};
50
51void LightBenchmarkTest::SetUp(const ::benchmark::State &state)
52{
53    g_lightInterface = ILightInterface::Get();
54}
55
56void 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  */
65BENCHMARK_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
83BENCHMARK_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  */
91BENCHMARK_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
121BENCHMARK_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  */
129BENCHMARK_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
160BENCHMARK_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  */
168BENCHMARK_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
192BENCHMARK_REGISTER_F(LightBenchmarkTest, TurnOnMultiLights)->
193    Iterations(ITERATION_FREQUENCY)->Repetitions(REPETITION_FREQUENCY)->ReportAggregatesOnly();
194}
195
196BENCHMARK_MAIN();
197