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 <cmath>
17#include <cstdio>
18#include <gtest/gtest.h>
19#include <securec.h>
20#include "hdf_base.h"
21#include "osal_time.h"
22#include "v1_0/ilight_interface.h"
23#include "light_if.h"
24
25using namespace OHOS::HDI::Light::V1_0;
26using namespace testing::ext;
27
28namespace {
29    constexpr uint32_t g_sleepTime = 3;
30    constexpr int32_t MAX_VALUE = 255;
31    constexpr int32_t MIN_VALUE = 0;
32    constexpr int32_t ON_TIME = 500;
33    constexpr int32_t OFF_TIME = 500;
34    std::vector<HdfLightInfo> g_info;
35    sptr<ILightInterface> g_lightInterface = nullptr;
36}
37
38class HdfLightHdiTest : public testing::Test {
39public:
40    static void SetUpTestCase();
41    static void TearDownTestCase();
42    void SetUp();
43    void TearDown();
44};
45
46void HdfLightHdiTest::SetUpTestCase()
47{
48    g_lightInterface = ILightInterface::Get();
49}
50
51void HdfLightHdiTest::TearDownTestCase()
52{
53}
54
55void HdfLightHdiTest::SetUp()
56{
57}
58
59void HdfLightHdiTest::TearDown()
60{
61}
62
63static void InitConfig(HdfLightEffect &effect)
64{
65    effect.lightColor.colorValue.rgbColor.r = MIN_VALUE;
66    effect.lightColor.colorValue.rgbColor.g = MIN_VALUE;
67    effect.lightColor.colorValue.rgbColor.b = MIN_VALUE;
68    effect.flashEffect.flashMode = HDF_LIGHT_FLASH_NONE;
69}
70
71/**
72  * @tc.name: TurnOnLightRed001
73  * @tc.desc: Turn on the battery light is steady on red.
74  * @tc.type: FUNC
75  * @tc.require: #I4NN4Z
76  */
77HWTEST_F(HdfLightHdiTest, TurnOnLightRed_001, TestSize.Level1)
78{
79    ASSERT_NE(nullptr, g_lightInterface);
80
81    HdfLightEffect effect;
82    InitConfig(effect);
83    effect.lightColor.colorValue.rgbColor.r = MAX_VALUE;
84
85    int32_t ret = g_lightInterface->TurnOnLight(LIGHT_ID_BATTERY, effect);
86    EXPECT_EQ(HDF_SUCCESS, ret);
87
88    OsalSleep(g_sleepTime);
89
90    ret = g_lightInterface->TurnOffLight(LIGHT_ID_BATTERY);
91    EXPECT_EQ(HDF_SUCCESS, ret);
92}
93
94/**
95  * @tc.name: TurnOnLightGreen001
96  * @tc.desc: Turn on the battery light is steady on green.
97  * @tc.type: FUNC
98  * @tc.require: #I4NN4Z
99  */
100HWTEST_F(HdfLightHdiTest, TurnOnLightGreen_001, TestSize.Level1)
101{
102    ASSERT_NE(nullptr, g_lightInterface);
103
104    HdfLightEffect effect;
105    InitConfig(effect);
106    effect.lightColor.colorValue.rgbColor.g = MAX_VALUE;
107
108    int32_t ret = g_lightInterface->TurnOnLight(LIGHT_ID_BATTERY, effect);
109    EXPECT_EQ(HDF_SUCCESS, ret);
110
111    OsalSleep(g_sleepTime);
112
113    ret = g_lightInterface->TurnOffLight(LIGHT_ID_BATTERY);
114    EXPECT_EQ(HDF_SUCCESS, ret);
115}
116
117/**
118  * @tc.name: TurnOnLightBlue001
119  * @tc.desc: Turn on the battery light is steady on blue.
120  * @tc.type: FUNC
121  * @tc.require: #I4NN4Z
122  */
123HWTEST_F(HdfLightHdiTest, TurnOnLightBlue_001, TestSize.Level1)
124{
125    ASSERT_NE(nullptr, g_lightInterface);
126
127    HdfLightEffect effect;
128    InitConfig(effect);
129    effect.lightColor.colorValue.rgbColor.b = MAX_VALUE;
130
131    int32_t ret = g_lightInterface->TurnOnLight(LIGHT_ID_BATTERY, effect);
132    EXPECT_EQ(HDF_SUCCESS, ret);
133
134    OsalSleep(g_sleepTime);
135
136    ret = g_lightInterface->TurnOffLight(LIGHT_ID_BATTERY);
137    EXPECT_EQ(HDF_SUCCESS, ret);
138}
139
140/**
141  * @tc.name: TurnOnLightRed002
142  * @tc.desc: Turn on the battery light blinking red.
143  * @tc.type: FUNC
144  * @tc.require: #I4NN4Z
145  */
146HWTEST_F(HdfLightHdiTest, TurnOnLightRed_002, TestSize.Level1)
147{
148    ASSERT_NE(nullptr, g_lightInterface);
149
150    HdfLightEffect effect;
151    InitConfig(effect);
152    effect.lightColor.colorValue.rgbColor.r = MAX_VALUE;
153    effect.flashEffect.flashMode = HDF_LIGHT_FLASH_BLINK;
154    effect.flashEffect.onTime = ON_TIME;
155    effect.flashEffect.offTime = OFF_TIME;
156
157    int32_t ret = g_lightInterface->TurnOnLight(LIGHT_ID_BATTERY, effect);
158    EXPECT_EQ(HDF_SUCCESS, ret);
159
160    OsalSleep(g_sleepTime);
161
162    ret = g_lightInterface->TurnOffLight(LIGHT_ID_BATTERY);
163    EXPECT_EQ(HDF_SUCCESS, ret);
164}
165
166/**
167  * @tc.name: TurnOnLightGreen002
168  * @tc.desc: Turn on the battery light blinking green.
169  * @tc.type: FUNC
170  * @tc.require: #I4NN4Z
171  */
172HWTEST_F(HdfLightHdiTest, TurnOnLightGreen_002, TestSize.Level1)
173{
174    ASSERT_NE(nullptr, g_lightInterface);
175
176    HdfLightEffect effect;
177    InitConfig(effect);
178    effect.lightColor.colorValue.rgbColor.g = MAX_VALUE;
179    effect.flashEffect.flashMode = HDF_LIGHT_FLASH_BLINK;
180    effect.flashEffect.onTime = ON_TIME;
181    effect.flashEffect.offTime = OFF_TIME;
182
183    int32_t ret = g_lightInterface->TurnOnLight(LIGHT_ID_BATTERY, effect);
184    EXPECT_EQ(HDF_SUCCESS, ret);
185
186    OsalSleep(g_sleepTime);
187
188    ret = g_lightInterface->TurnOffLight(LIGHT_ID_BATTERY);
189    EXPECT_EQ(HDF_SUCCESS, ret);
190}
191
192/**
193  * @tc.name: TurnOnLightBlue002
194  * @tc.desc: Turn on the battery light blinking blue.
195  * @tc.type: FUNC
196  * @tc.require: #I4NN4Z
197  */
198HWTEST_F(HdfLightHdiTest, TurnOnLightBlue_002, TestSize.Level1)
199{
200    ASSERT_NE(nullptr, g_lightInterface);
201
202    HdfLightEffect effect;
203    InitConfig(effect);
204    effect.lightColor.colorValue.rgbColor.b = MAX_VALUE;
205    effect.flashEffect.flashMode = HDF_LIGHT_FLASH_BLINK;
206    effect.flashEffect.onTime = ON_TIME;
207    effect.flashEffect.offTime = OFF_TIME;
208    int32_t ret = g_lightInterface->TurnOnLight(LIGHT_ID_BATTERY, effect);
209    EXPECT_EQ(HDF_SUCCESS, ret);
210
211    OsalSleep(g_sleepTime);
212
213    ret = g_lightInterface->TurnOffLight(LIGHT_ID_BATTERY);
214    EXPECT_EQ(HDF_SUCCESS, ret);
215}
216
217/**
218  * @tc.name: TurnOnLightUnsupport001
219  * @tc.desc: Unsupported flashmode(HDF_LIGHT_FLASH_GRADIENT).
220  * @tc.type: FUNC
221  * @tc.require: #I4NN4Z
222  */
223HWTEST_F(HdfLightHdiTest, TurnOnLightUnsupport_001, TestSize.Level1)
224{
225    ASSERT_NE(nullptr, g_lightInterface);
226
227    HdfLightEffect effect;
228    InitConfig(effect);
229    effect.lightColor.colorValue.rgbColor.r = MAX_VALUE;
230    effect.lightColor.colorValue.rgbColor.g = MAX_VALUE;
231    effect.lightColor.colorValue.rgbColor.b = MAX_VALUE;
232    effect.flashEffect.flashMode = HDF_LIGHT_FLASH_GRADIENT;
233    effect.flashEffect.onTime = ON_TIME;
234    effect.flashEffect.offTime = OFF_TIME;
235
236    int32_t ret = g_lightInterface->TurnOnLight(LIGHT_ID_BATTERY, effect);
237    EXPECT_EQ(LIGHT_NOT_FLASH, ret);
238
239    ret = g_lightInterface->TurnOffLight(LIGHT_ID_BATTERY);
240    EXPECT_EQ(HDF_SUCCESS, ret);
241}
242
243/**
244  * @tc.name: TurnOnLightUnsupport002
245  * @tc.desc: Unsupported lightID(LIGHT_ID_NOTIFICATIONS).
246  * @tc.type: FUNC
247  * @tc.require: #I4NN4Z
248  */
249HWTEST_F(HdfLightHdiTest, TurnOnLightUnsupport_002, TestSize.Level1)
250{
251    ASSERT_NE(nullptr, g_lightInterface);
252
253    HdfLightEffect effect;
254    InitConfig(effect);
255    effect.lightColor.colorValue.rgbColor.r = MAX_VALUE;
256    effect.lightColor.colorValue.rgbColor.g = MAX_VALUE;
257    effect.lightColor.colorValue.rgbColor.b = MAX_VALUE;
258
259    int32_t ret = g_lightInterface->TurnOnLight(LIGHT_ID_NOTIFICATIONS, effect);
260    EXPECT_EQ(LIGHT_NOT_SUPPORT, ret);
261}
262
263/**
264  * @tc.name: TurnOnLightUnsupport003
265  * @tc.desc: Unsupported lightID(LIGHT_ID_ATTENTION).
266  * @tc.type: FUNC
267  * @tc.require: #I4NN4Z
268  */
269HWTEST_F(HdfLightHdiTest, TurnOnLightUnsupport_003, TestSize.Level1)
270{
271    ASSERT_NE(nullptr, g_lightInterface);
272
273    HdfLightEffect effect;
274    InitConfig(effect);
275    effect.lightColor.colorValue.rgbColor.r = MAX_VALUE;
276    effect.lightColor.colorValue.rgbColor.g = MAX_VALUE;
277    effect.lightColor.colorValue.rgbColor.b = MAX_VALUE;
278
279    int32_t ret = g_lightInterface->TurnOnLight(LIGHT_ID_ATTENTION, effect);
280    EXPECT_EQ(LIGHT_NOT_SUPPORT, ret);
281}
282
283/**
284  * @tc.name: TurnOnLightAbnormal001
285  * @tc.desc: Abnormal onTime in gradient mode.
286  * @tc.type: FUNC
287  * @tc.require: #I4NN4Z
288  */
289HWTEST_F(HdfLightHdiTest, TurnOnLightAbnormal_001, TestSize.Level1)
290{
291    ASSERT_NE(nullptr, g_lightInterface);
292
293    HdfLightEffect effect;
294    InitConfig(effect);
295    effect.lightColor.colorValue.rgbColor.r = MAX_VALUE;
296    effect.lightColor.colorValue.rgbColor.g = MAX_VALUE;
297    effect.lightColor.colorValue.rgbColor.b = MAX_VALUE;
298    effect.flashEffect.flashMode = HDF_LIGHT_FLASH_GRADIENT;
299    effect.flashEffect.onTime = 0;
300    effect.flashEffect.offTime = OFF_TIME;
301
302    int32_t ret = g_lightInterface->TurnOnLight(LIGHT_ID_BATTERY, effect);
303    EXPECT_EQ(LIGHT_NOT_FLASH, ret);
304
305    ret = g_lightInterface->TurnOffLight(LIGHT_ID_BATTERY);
306    EXPECT_EQ(HDF_SUCCESS, ret);
307}
308
309/**
310  * @tc.name: TurnOnLightAbnormal002
311  * @tc.desc: Abnormal offTime in gradient mode.
312  * @tc.type: FUNC
313  * @tc.require: #I4NN4Z
314  */
315HWTEST_F(HdfLightHdiTest, TurnOnLightAbnormal_002, TestSize.Level1)
316{
317    ASSERT_NE(nullptr, g_lightInterface);
318
319    HdfLightEffect effect;
320    InitConfig(effect);
321    effect.lightColor.colorValue.rgbColor.r = MAX_VALUE;
322    effect.lightColor.colorValue.rgbColor.g = MAX_VALUE;
323    effect.lightColor.colorValue.rgbColor.b = MAX_VALUE;
324    effect.flashEffect.flashMode = HDF_LIGHT_FLASH_GRADIENT;
325    effect.flashEffect.onTime = ON_TIME;
326    effect.flashEffect.offTime = 0;
327
328    int32_t ret = g_lightInterface->TurnOnLight(LIGHT_ID_BATTERY, effect);
329    EXPECT_EQ(LIGHT_NOT_FLASH, ret);
330
331    ret = g_lightInterface->TurnOffLight(LIGHT_ID_BATTERY);
332    EXPECT_EQ(HDF_SUCCESS, ret);
333}
334
335/**
336  * @tc.name: TurnOnLightAbnormal003
337  * @tc.desc: Abnormal onTime in blinking mode.
338  * @tc.type: FUNC
339  * @tc.require: #I4NN4Z
340  */
341HWTEST_F(HdfLightHdiTest, TurnOnLightAbnormal_003, TestSize.Level1)
342{
343    ASSERT_NE(nullptr, g_lightInterface);
344
345    HdfLightEffect effect;
346    InitConfig(effect);
347    effect.lightColor.colorValue.rgbColor.r = MAX_VALUE;
348    effect.lightColor.colorValue.rgbColor.g = MAX_VALUE;
349    effect.lightColor.colorValue.rgbColor.b = MAX_VALUE;
350    effect.flashEffect.flashMode = HDF_LIGHT_FLASH_BLINK;
351    effect.flashEffect.onTime = 0;
352    effect.flashEffect.offTime = OFF_TIME;
353
354    int32_t ret = g_lightInterface->TurnOnLight(LIGHT_ID_BATTERY, effect);
355    EXPECT_EQ(LIGHT_NOT_FLASH, ret);
356
357    ret = g_lightInterface->TurnOffLight(LIGHT_ID_BATTERY);
358    EXPECT_EQ(HDF_SUCCESS, ret);
359}
360
361/**
362  * @tc.name: TurnOnLightAbnormal004
363  * @tc.desc: Abnormal offTime in blinking mode.
364  * @tc.type: FUNC
365  * @tc.require: #I4NN4Z
366  */
367HWTEST_F(HdfLightHdiTest, TurnOnLightAbnormal_004, TestSize.Level1)
368{
369    ASSERT_NE(nullptr, g_lightInterface);
370
371    HdfLightEffect effect;
372    InitConfig(effect);
373    effect.lightColor.colorValue.rgbColor.r = MAX_VALUE;
374    effect.lightColor.colorValue.rgbColor.g = MAX_VALUE;
375    effect.lightColor.colorValue.rgbColor.b = MAX_VALUE;
376    effect.flashEffect.flashMode = HDF_LIGHT_FLASH_BLINK;
377    effect.flashEffect.onTime = ON_TIME;
378    effect.flashEffect.offTime = 0;
379
380    int32_t ret = g_lightInterface->TurnOnLight(LIGHT_ID_BATTERY, effect);
381    EXPECT_EQ(LIGHT_NOT_FLASH, ret);
382
383    ret = g_lightInterface->TurnOffLight(LIGHT_ID_BATTERY);
384    EXPECT_EQ(HDF_SUCCESS, ret);
385}
386
387/**
388  * @tc.name: TurnOnMultiLights001
389  * @tc.desc: TurnOnMultiLights.
390  * @tc.type: FUNC
391  * @tc.require: #I4NN4Z
392  */
393HWTEST_F(HdfLightHdiTest, TurnOnMultiLights_001, TestSize.Level1)
394{
395    ASSERT_NE(nullptr, g_lightInterface);
396
397    std::vector<HdfLightColor> lightColor;
398    struct HdfLightColor light;
399    light.colorValue.rgbColor.r = MAX_VALUE;
400    light.colorValue.rgbColor.g = MIN_VALUE;
401    light.colorValue.rgbColor.b = MIN_VALUE;
402    lightColor.push_back(light);
403
404    int32_t ret = g_lightInterface->TurnOnMultiLights(LIGHT_ID_BATTERY, lightColor);
405    EXPECT_EQ(HDF_SUCCESS, ret);
406
407    OsalSleep(g_sleepTime);
408
409    ret = g_lightInterface->TurnOffLight(LIGHT_ID_BATTERY);
410    EXPECT_EQ(HDF_SUCCESS, ret);
411}
412
413/**
414  * @tc.name: NewLightInterfaceInstance
415  * @tc.desc: create lightInterfaceInstance
416  * @tc.type: FUNC
417  * @tc.require: #I4NN4Z
418  */
419HWTEST_F(HdfLightHdiTest, NewLightInterfaceInstance, TestSize.Level1)
420{
421    const struct LightInterface *lightInterface = NewLightInterfaceInstance();
422    ASSERT_NE(nullptr, lightInterface);
423    int32_t ret = FreeLightInterfaceInstance();
424    EXPECT_EQ(HDF_SUCCESS, ret);
425}