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 <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_type.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 g_minLightId = HDF_LIGHT_ID_BATTERY;
31    constexpr int32_t g_maxLightId = HDF_LIGHT_ID_ATTENTION;
32    constexpr int32_t MAX_VALUE = 255;
33    constexpr int32_t MIN_VALUE = 0;
34    constexpr int32_t ON_TIME = 500;
35    constexpr int32_t OFF_TIME = 500;
36    std::vector<HdfLightInfo> g_info;
37    sptr<ILightInterface> g_lightInterface = nullptr;
38
39class HdfLightHdiServiceTest : public testing::Test {
40public:
41    static void SetUpTestCase();
42    static void TearDownTestCase();
43    void SetUp();
44    void TearDown();
45};
46
47void HdfLightHdiServiceTest::SetUpTestCase()
48{
49    g_lightInterface = ILightInterface::Get();
50}
51
52void HdfLightHdiServiceTest::TearDownTestCase()
53{
54}
55
56void HdfLightHdiServiceTest::SetUp()
57{
58}
59
60void HdfLightHdiServiceTest::TearDown()
61{
62}
63
64void InitConfig(HdfLightEffect &effect)
65{
66    effect.lightColor.colorValue.rgbColor.r = MIN_VALUE;
67    effect.lightColor.colorValue.rgbColor.g = MIN_VALUE;
68    effect.lightColor.colorValue.rgbColor.b = MIN_VALUE;
69    effect.flashEffect.flashMode = HDF_LIGHT_FLASH_NONE;
70}
71
72/**
73  * @tc.name: CheckLightInstanceIsEmpty
74  * @tc.desc: Creat a light instance. The instance is not empty.
75  * @tc.type: FUNC
76  */
77HWTEST_F(HdfLightHdiServiceTest, SUB_Driver_Sensor_HdiLight_0100, Function | MediumTest | Level1)
78{
79    ASSERT_NE(nullptr, g_lightInterface);
80}
81
82/**
83  * @tc.name: GetLightInfo001
84  * @tc.desc: Get light info.
85  * @tc.type: FUNC
86  */
87HWTEST_F(HdfLightHdiServiceTest, SUB_Driver_Sensor_HdiLight_0200, Function | MediumTest | Level1)
88{
89    ASSERT_NE(nullptr, g_lightInterface);
90
91    std::vector<HdfLightInfo> info;
92    int32_t ret = g_lightInterface->GetLightInfo(info);
93    EXPECT_EQ(0, ret);
94    printf("get light list num[%zu]\n\r", info.size());
95
96    for (auto iter : info)
97    {
98        EXPECT_GE(iter.lightId, g_minLightId);
99        EXPECT_LE(iter.lightId, g_maxLightId);
100    }
101}
102
103/**
104  * @tc.name: TurnOnLight001
105  * @tc.desc: TurnOnLight.
106  * @tc.type: FUNC
107  */
108HWTEST_F(HdfLightHdiServiceTest, SUB_Driver_Sensor_HdiLight_0300, Function | MediumTest | Level1)
109{
110    ASSERT_NE(nullptr, g_lightInterface);
111
112    std::vector<HdfLightInfo> info;
113    int32_t ret = g_lightInterface->GetLightInfo(info);
114    EXPECT_EQ(HDF_SUCCESS, ret);
115    printf("get light list num[%zu]\n\r", info.size());
116
117    for (auto iter : info)
118    {
119        EXPECT_GE(iter.lightId, g_minLightId);
120        EXPECT_LE(iter.lightId, g_maxLightId);
121
122        HdfLightEffect effect;
123        effect.lightColor.colorValue.rgbColor.r = 255;
124        effect.lightColor.colorValue.rgbColor.g = 0;
125        effect.lightColor.colorValue.rgbColor.b = 0;
126        effect.flashEffect.flashMode = LIGHT_FLASH_NONE;
127        int32_t ret = g_lightInterface->TurnOnLight(iter.lightId, effect);
128        EXPECT_EQ(HDF_SUCCESS, ret);
129        OsalSleep(g_sleepTime);
130        ret = g_lightInterface->TurnOffLight(iter.lightId);
131        EXPECT_EQ(HDF_SUCCESS, ret);
132    }
133}
134
135/**
136  * @tc.name: TurnOnLight002
137  * @tc.desc: TurnOnLight.
138  * @tc.type: FUNC
139  */
140HWTEST_F(HdfLightHdiServiceTest, SUB_Driver_Sensor_HdiLight_0400, Function | MediumTest | Level1)
141{
142    ASSERT_NE(nullptr, g_lightInterface);
143
144    std::vector<HdfLightInfo> info;
145    int32_t ret = g_lightInterface->GetLightInfo(info);
146    EXPECT_EQ(0, ret);
147    printf("get light list num[%zu]\n\r", info.size());
148
149    for (auto iter : info)
150    {
151        EXPECT_GE(iter.lightId, g_minLightId);
152        EXPECT_LE(iter.lightId, g_maxLightId);
153
154        HdfLightEffect effect;
155        effect.lightColor.colorValue.rgbColor.r = 255;
156        effect.lightColor.colorValue.rgbColor.g = 0;
157        effect.lightColor.colorValue.rgbColor.b = 0;
158        effect.flashEffect.flashMode = LIGHT_FLASH_BUTT;
159        int32_t ret = g_lightInterface->TurnOnLight(iter.lightId, effect);
160        EXPECT_EQ(LIGHT_NOT_FLASH, ret);
161    }
162}
163
164/**
165  * @tc.name: TurnOnLight003
166  * @tc.desc: TurnOnLight.
167  * @tc.type: FUNC
168  */
169HWTEST_F(HdfLightHdiServiceTest, SUB_Driver_Sensor_HdiLight_0500, Function | MediumTest | Level1)
170{
171    ASSERT_NE(nullptr, g_lightInterface);
172
173    std::vector<HdfLightInfo> info;
174    int32_t ret = g_lightInterface->GetLightInfo(info);
175    EXPECT_EQ(0, ret);
176    printf("get light list num[%zu]\n\r", info.size());
177
178    for (auto iter : info)
179    {
180        EXPECT_GE(iter.lightId, g_minLightId);
181        EXPECT_LE(iter.lightId, g_maxLightId);
182
183        HdfLightEffect effect;
184        effect.lightColor.colorValue.rgbColor.r = 255;
185        effect.lightColor.colorValue.rgbColor.g = 0;
186        effect.lightColor.colorValue.rgbColor.b = 0;
187        effect.flashEffect.flashMode = LIGHT_FLASH_BLINK;
188        effect.flashEffect.onTime = ON_TIME;
189        effect.flashEffect.offTime = OFF_TIME;
190        int32_t ret = g_lightInterface->TurnOnLight(iter.lightId, effect);
191        EXPECT_EQ(HDF_SUCCESS, ret);
192        OsalSleep(g_sleepTime);
193        ret = g_lightInterface->TurnOffLight(iter.lightId);
194        EXPECT_EQ(HDF_SUCCESS, ret);
195    }
196}
197
198/**
199  * @tc.name: TurnOnLight005
200  * @tc.desc: TurnOnLight.
201  * @tc.type: FUNC
202  */
203HWTEST_F(HdfLightHdiServiceTest, SUB_Driver_Sensor_HdiLight_0600, Function | MediumTest | Level1)
204{
205    ASSERT_NE(nullptr, g_lightInterface);
206
207    std::vector<HdfLightInfo> info;
208    int32_t ret = g_lightInterface->GetLightInfo(info);
209    EXPECT_EQ(HDF_SUCCESS, ret);
210    printf("get light list num[%zu]\n\r", info.size());
211
212    for (auto iter : info)
213    {
214        EXPECT_GE(iter.lightId, g_minLightId);
215        EXPECT_LE(iter.lightId, g_maxLightId);
216
217        HdfLightEffect effect;
218        effect.lightColor.colorValue.rgbColor.r = 255;
219        effect.lightColor.colorValue.rgbColor.g = 0;
220        effect.lightColor.colorValue.rgbColor.b = 0;
221        effect.flashEffect.flashMode = LIGHT_FLASH_GRADIENT;
222        int32_t ret = g_lightInterface->TurnOnLight(iter.lightId, effect);
223        EXPECT_EQ(HDF_ERR_NOT_SUPPORT, ret);
224        OsalSleep(g_sleepTime);
225        ret = g_lightInterface->TurnOffLight(iter.lightId);
226        EXPECT_EQ(HDF_SUCCESS, ret);
227    }
228}
229
230/**
231  * @tc.name: DisableLight001
232  * @tc.desc: DisableLight.
233  * @tc.type: FUNC
234  */
235HWTEST_F(HdfLightHdiServiceTest, SUB_Driver_Sensor_HdiLight_0700, Function | MediumTest | Level1)
236{
237    ASSERT_NE(nullptr, g_lightInterface);
238
239    HdfLightEffect effect;
240    int32_t ret  = g_lightInterface->TurnOnLight(HDF_LIGHT_ID_BUTT, effect);
241    EXPECT_EQ(LIGHT_NOT_SUPPORT, ret);
242    ret  = g_lightInterface->TurnOffLight(HDF_LIGHT_ID_BUTT);
243    EXPECT_EQ(LIGHT_NOT_SUPPORT, ret);
244}
245
246/**
247  * @tc.name: DisableLight002
248  * @tc.desc: DisableLight.
249  * @tc.type: FUNC
250  */
251HWTEST_F(HdfLightHdiServiceTest, SUB_Driver_Sensor_HdiLight_0800, Function | MediumTest | Level1)
252{
253    ASSERT_NE(nullptr, g_lightInterface);
254
255    HdfLightEffect effect;
256    int32_t ret  = g_lightInterface->TurnOnLight(HDF_LIGHT_ID_NOTIFICATIONS, effect);
257    EXPECT_EQ(LIGHT_NOT_SUPPORT, ret);
258    ret  = g_lightInterface->TurnOffLight(HDF_LIGHT_ID_NOTIFICATIONS);
259    EXPECT_EQ(LIGHT_NOT_SUPPORT, ret);
260}
261
262/**
263  * @tc.name: TurnOnMultiLights001
264  * @tc.desc: DTurnOnMultiLights.
265  * @tc.type: FUNC
266  */
267HWTEST_F(HdfLightHdiServiceTest, SUB_Driver_Sensor_HdiLight_0900, Function | MediumTest | Level1)
268{
269    ASSERT_NE(nullptr, g_lightInterface);
270
271    std::vector<HdfLightInfo> info;
272    int32_t ret = g_lightInterface-> GetLightInfo(info);
273    EXPECT_EQ(0, ret);
274    for (auto iter : info)
275    {
276        EXPECT_GE(iter.lightId, g_minLightId);
277        EXPECT_LE(iter.lightId, g_maxLightId);
278        std::vector<HdfLightColor> lightColor;
279        struct HdfLightColor light;
280        light.colorValue.rgbColor.b = 0;
281        lightColor.push_back(light);
282        ret = g_lightInterface->TurnOnMultiLights(iter.lightId, lightColor);
283        EXPECT_EQ(HDF_SUCCESS, ret);
284    }
285}
286
287/**
288  * @tc.name: TurnOnLightRed001
289  * @tc.desc: Turn on the battery light is steady on red.
290  * @tc.type: FUNC
291  */
292HWTEST_F(HdfLightHdiServiceTest, SUB_Driver_Sensor_HdiLight_1000, Function | MediumTest | Level1)
293{
294    ASSERT_NE(nullptr, g_lightInterface);
295
296    HdfLightEffect effect;
297    InitConfig(effect);
298    effect.lightColor.colorValue.rgbColor.r = MAX_VALUE;
299
300    int32_t ret = g_lightInterface->TurnOnLight(LIGHT_ID_BATTERY, effect);
301    EXPECT_EQ(HDF_SUCCESS, ret);
302
303    OsalSleep(g_sleepTime);
304
305    ret = g_lightInterface->TurnOffLight(LIGHT_ID_BATTERY);
306    EXPECT_EQ(HDF_SUCCESS, ret);
307}
308
309/**
310  * @tc.name: TurnOnLightGreen001
311  * @tc.desc: Turn on the battery light is steady on green.
312  * @tc.type: FUNC
313  */
314HWTEST_F(HdfLightHdiServiceTest, SUB_Driver_Sensor_HdiLight_1100, Function | MediumTest | Level1)
315{
316    ASSERT_NE(nullptr, g_lightInterface);
317
318    HdfLightEffect effect;
319    InitConfig(effect);
320    effect.lightColor.colorValue.rgbColor.g = MAX_VALUE;
321
322    int32_t ret = g_lightInterface->TurnOnLight(LIGHT_ID_BATTERY, effect);
323    EXPECT_EQ(HDF_SUCCESS, ret);
324
325    OsalSleep(g_sleepTime);
326
327    ret = g_lightInterface->TurnOffLight(LIGHT_ID_BATTERY);
328    EXPECT_EQ(HDF_SUCCESS, ret);
329}
330
331/**
332  * @tc.name: TurnOnLightBlue001
333  * @tc.desc: Turn on the battery light is steady on blue.
334  * @tc.type: FUNC
335  */
336HWTEST_F(HdfLightHdiServiceTest, SUB_Driver_Sensor_HdiLight_1200, Function | MediumTest | Level1)
337{
338    ASSERT_NE(nullptr, g_lightInterface);
339
340    HdfLightEffect effect;
341    InitConfig(effect);
342    effect.lightColor.colorValue.rgbColor.b = MAX_VALUE;
343
344    int32_t ret = g_lightInterface->TurnOnLight(LIGHT_ID_BATTERY, effect);
345    EXPECT_EQ(HDF_SUCCESS, ret);
346
347    OsalSleep(g_sleepTime);
348
349    ret = g_lightInterface->TurnOffLight(LIGHT_ID_BATTERY);
350    EXPECT_EQ(HDF_SUCCESS, ret);
351}
352
353/**
354  * @tc.name: TurnOnLightRed002
355  * @tc.desc: Turn on the battery light blinking red.
356  * @tc.type: FUNC
357  */
358HWTEST_F(HdfLightHdiServiceTest, SUB_Driver_Sensor_HdiLight_1300, Function | MediumTest | Level1)
359{
360    ASSERT_NE(nullptr, g_lightInterface);
361
362    HdfLightEffect effect;
363    InitConfig(effect);
364    effect.lightColor.colorValue.rgbColor.r = MAX_VALUE;
365    effect.flashEffect.flashMode = HDF_LIGHT_FLASH_BLINK;
366    effect.flashEffect.onTime = ON_TIME;
367    effect.flashEffect.offTime = OFF_TIME;
368
369    int32_t ret = g_lightInterface->TurnOnLight(LIGHT_ID_BATTERY, effect);
370    EXPECT_EQ(HDF_SUCCESS, ret);
371
372    OsalSleep(g_sleepTime);
373
374    ret = g_lightInterface->TurnOffLight(LIGHT_ID_BATTERY);
375    EXPECT_EQ(HDF_SUCCESS, ret);
376}
377
378/**
379  * @tc.name: TurnOnLightGreen002
380  * @tc.desc: Turn on the battery light blinking green.
381  * @tc.type: FUNC
382  */
383HWTEST_F(HdfLightHdiServiceTest, SUB_Driver_Sensor_HdiLight_1400, Function | MediumTest | Level1)
384{
385    ASSERT_NE(nullptr, g_lightInterface);
386
387    HdfLightEffect effect;
388    InitConfig(effect);
389    effect.lightColor.colorValue.rgbColor.g = MAX_VALUE;
390    effect.flashEffect.flashMode = HDF_LIGHT_FLASH_BLINK;
391    effect.flashEffect.onTime = ON_TIME;
392    effect.flashEffect.offTime = OFF_TIME;
393
394    int32_t ret = g_lightInterface->TurnOnLight(LIGHT_ID_BATTERY, effect);
395    EXPECT_EQ(HDF_SUCCESS, ret);
396
397    OsalSleep(g_sleepTime);
398
399    ret = g_lightInterface->TurnOffLight(LIGHT_ID_BATTERY);
400    EXPECT_EQ(HDF_SUCCESS, ret);
401}
402
403/**
404  * @tc.name: TurnOnLightBlue002
405  * @tc.desc: Turn on the battery light blinking blue.
406  * @tc.type: FUNC
407  */
408HWTEST_F(HdfLightHdiServiceTest, SUB_Driver_Sensor_HdiLight_1500, Function | MediumTest | Level1)
409{
410    ASSERT_NE(nullptr, g_lightInterface);
411
412    HdfLightEffect effect;
413    InitConfig(effect);
414    effect.lightColor.colorValue.rgbColor.b = MAX_VALUE;
415    effect.flashEffect.flashMode = HDF_LIGHT_FLASH_BLINK;
416    effect.flashEffect.onTime = ON_TIME;
417    effect.flashEffect.offTime = OFF_TIME;
418    int32_t ret = g_lightInterface->TurnOnLight(LIGHT_ID_BATTERY, effect);
419    EXPECT_EQ(HDF_SUCCESS, ret);
420
421    OsalSleep(g_sleepTime);
422
423    ret = g_lightInterface->TurnOffLight(LIGHT_ID_BATTERY);
424    EXPECT_EQ(HDF_SUCCESS, ret);
425}
426
427/**
428  * @tc.name: TurnOnLightUnsupport001
429  * @tc.desc: Unsupported flashmode(HDF_LIGHT_FLASH_GRADIENT).
430  * @tc.type: FUNC
431  */
432HWTEST_F(HdfLightHdiServiceTest, SUB_Driver_Sensor_HdiLight_1600, Function | MediumTest | Level1)
433{
434    ASSERT_NE(nullptr, g_lightInterface);
435
436    HdfLightEffect effect;
437    InitConfig(effect);
438    effect.lightColor.colorValue.rgbColor.r = MAX_VALUE;
439    effect.lightColor.colorValue.rgbColor.g = MAX_VALUE;
440    effect.lightColor.colorValue.rgbColor.b = MAX_VALUE;
441    effect.flashEffect.flashMode = HDF_LIGHT_FLASH_GRADIENT;
442    effect.flashEffect.onTime = ON_TIME;
443    effect.flashEffect.offTime = OFF_TIME;
444
445    int32_t ret = g_lightInterface->TurnOnLight(LIGHT_ID_BATTERY, effect);
446    EXPECT_EQ(LIGHT_NOT_FLASH, ret);
447
448    ret = g_lightInterface->TurnOffLight(LIGHT_ID_BATTERY);
449    EXPECT_EQ(HDF_SUCCESS, ret);
450}
451
452/**
453  * @tc.name: TurnOnLightUnsupport002
454  * @tc.desc: Unsupported lightID(LIGHT_ID_NOTIFICATIONS).
455  * @tc.type: FUNC
456  */
457HWTEST_F(HdfLightHdiServiceTest, SUB_Driver_Sensor_HdiLight_1700, Function | MediumTest | Level1)
458{
459    ASSERT_NE(nullptr, g_lightInterface);
460
461    HdfLightEffect effect;
462    InitConfig(effect);
463    effect.lightColor.colorValue.rgbColor.r = MAX_VALUE;
464    effect.lightColor.colorValue.rgbColor.g = MAX_VALUE;
465    effect.lightColor.colorValue.rgbColor.b = MAX_VALUE;
466
467    int32_t ret = g_lightInterface->TurnOnLight(LIGHT_ID_NOTIFICATIONS, effect);
468    EXPECT_EQ(LIGHT_NOT_SUPPORT, ret);
469}
470
471/**
472  * @tc.name: TurnOnLightUnsupport003
473  * @tc.desc: Unsupported lightID(LIGHT_ID_ATTENTION).
474  * @tc.type: FUNC
475  */
476HWTEST_F(HdfLightHdiServiceTest, SUB_Driver_Sensor_HdiLight_1800, Function | MediumTest | Level1)
477{
478    ASSERT_NE(nullptr, g_lightInterface);
479
480    HdfLightEffect effect;
481    InitConfig(effect);
482    effect.lightColor.colorValue.rgbColor.r = MAX_VALUE;
483    effect.lightColor.colorValue.rgbColor.g = MAX_VALUE;
484    effect.lightColor.colorValue.rgbColor.b = MAX_VALUE;
485
486    int32_t ret = g_lightInterface->TurnOnLight(LIGHT_ID_ATTENTION, effect);
487    EXPECT_EQ(LIGHT_NOT_SUPPORT, ret);
488}
489
490/**
491  * @tc.name: TurnOnLightAbnormal001
492  * @tc.desc: Abnormal onTime in gradient mode.
493  * @tc.type: FUNC
494  */
495HWTEST_F(HdfLightHdiServiceTest, SUB_Driver_Sensor_HdiLight_1900, Function | MediumTest | Level1)
496{
497    ASSERT_NE(nullptr, g_lightInterface);
498
499    HdfLightEffect effect;
500    InitConfig(effect);
501    effect.lightColor.colorValue.rgbColor.r = MAX_VALUE;
502    effect.lightColor.colorValue.rgbColor.g = MAX_VALUE;
503    effect.lightColor.colorValue.rgbColor.b = MAX_VALUE;
504    effect.flashEffect.flashMode = HDF_LIGHT_FLASH_GRADIENT;
505    effect.flashEffect.onTime = 0;
506    effect.flashEffect.offTime = OFF_TIME;
507
508    int32_t ret = g_lightInterface->TurnOnLight(LIGHT_ID_BATTERY, effect);
509    EXPECT_EQ(LIGHT_NOT_FLASH, ret);
510
511    ret = g_lightInterface->TurnOffLight(LIGHT_ID_BATTERY);
512    EXPECT_EQ(HDF_SUCCESS, ret);
513}
514
515/**
516  * @tc.name: TurnOnLightAbnormal002
517  * @tc.desc: Abnormal offTime in gradient mode.
518  * @tc.type: FUNC
519  */
520HWTEST_F(HdfLightHdiServiceTest, SUB_Driver_Sensor_HdiLight_2000, Function | MediumTest | Level1)
521{
522    ASSERT_NE(nullptr, g_lightInterface);
523
524    HdfLightEffect effect;
525    InitConfig(effect);
526    effect.lightColor.colorValue.rgbColor.r = MAX_VALUE;
527    effect.lightColor.colorValue.rgbColor.g = MAX_VALUE;
528    effect.lightColor.colorValue.rgbColor.b = MAX_VALUE;
529    effect.flashEffect.flashMode = HDF_LIGHT_FLASH_GRADIENT;
530    effect.flashEffect.onTime = ON_TIME;
531    effect.flashEffect.offTime = 0;
532
533    int32_t ret = g_lightInterface->TurnOnLight(LIGHT_ID_BATTERY, effect);
534    EXPECT_EQ(LIGHT_NOT_FLASH, ret);
535
536    ret = g_lightInterface->TurnOffLight(LIGHT_ID_BATTERY);
537    EXPECT_EQ(HDF_SUCCESS, ret);
538}
539
540/**
541  * @tc.name: TurnOnLightAbnormal003
542  * @tc.desc: Abnormal onTime in blinking mode.
543  * @tc.type: FUNC
544  */
545HWTEST_F(HdfLightHdiServiceTest, SUB_Driver_Sensor_HdiLight_2100, Function | MediumTest | Level1)
546{
547    ASSERT_NE(nullptr, g_lightInterface);
548
549    HdfLightEffect effect;
550    InitConfig(effect);
551    effect.lightColor.colorValue.rgbColor.r = MAX_VALUE;
552    effect.lightColor.colorValue.rgbColor.g = MAX_VALUE;
553    effect.lightColor.colorValue.rgbColor.b = MAX_VALUE;
554    effect.flashEffect.flashMode = HDF_LIGHT_FLASH_BLINK;
555    effect.flashEffect.onTime = 0;
556    effect.flashEffect.offTime = OFF_TIME;
557
558    int32_t ret = g_lightInterface->TurnOnLight(LIGHT_ID_BATTERY, effect);
559    EXPECT_EQ(LIGHT_NOT_FLASH, ret);
560
561    ret = g_lightInterface->TurnOffLight(LIGHT_ID_BATTERY);
562    EXPECT_EQ(HDF_SUCCESS, ret);
563}
564
565/**
566  * @tc.name: TurnOnLightAbnormal004
567  * @tc.desc: Abnormal offTime in blinking mode.
568  * @tc.type: FUNC
569  */
570HWTEST_F(HdfLightHdiServiceTest, SUB_Driver_Sensor_HdiLight_2200, Function | MediumTest | Level1)
571{
572    ASSERT_NE(nullptr, g_lightInterface);
573
574    HdfLightEffect effect;
575    InitConfig(effect);
576    effect.lightColor.colorValue.rgbColor.r = MAX_VALUE;
577    effect.lightColor.colorValue.rgbColor.g = MAX_VALUE;
578    effect.lightColor.colorValue.rgbColor.b = MAX_VALUE;
579    effect.flashEffect.flashMode = HDF_LIGHT_FLASH_BLINK;
580    effect.flashEffect.onTime = ON_TIME;
581    effect.flashEffect.offTime = 0;
582
583    int32_t ret = g_lightInterface->TurnOnLight(LIGHT_ID_BATTERY, effect);
584    EXPECT_EQ(LIGHT_NOT_FLASH, ret);
585
586    ret = g_lightInterface->TurnOffLight(LIGHT_ID_BATTERY);
587    EXPECT_EQ(HDF_SUCCESS, ret);
588}
589
590/**
591  * @tc.name: TurnOnMultiLights001
592  * @tc.desc: TurnOnMultiLights.
593  * @tc.type: FUNC
594  */
595HWTEST_F(HdfLightHdiServiceTest, SUB_Driver_Sensor_HdiLight_2300, Function | MediumTest | Level1)
596{
597    ASSERT_NE(nullptr, g_lightInterface);
598
599    std::vector<HdfLightColor> lightColor;
600    struct HdfLightColor light;
601    light.colorValue.rgbColor.r = MAX_VALUE;
602    light.colorValue.rgbColor.g = MIN_VALUE;
603    light.colorValue.rgbColor.b = MIN_VALUE;
604    lightColor.push_back(light);
605
606    int32_t ret = g_lightInterface->TurnOnMultiLights(LIGHT_ID_BATTERY, lightColor);
607    EXPECT_EQ(HDF_SUCCESS, ret);
608
609    OsalSleep(g_sleepTime);
610
611    ret = g_lightInterface->TurnOffLight(LIGHT_ID_BATTERY);
612    EXPECT_EQ(HDF_SUCCESS, ret);
613}
614}