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 
25 using namespace OHOS::HDI::Light::V1_0;
26 using namespace testing::ext;
27 
28 namespace {
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 
39 class HdfLightHdiServiceTest : public testing::Test {
40 public:
41     static void SetUpTestCase();
42     static void TearDownTestCase();
43     void SetUp();
44     void TearDown();
45 };
46 
SetUpTestCase()47 void HdfLightHdiServiceTest::SetUpTestCase()
48 {
49     g_lightInterface = ILightInterface::Get();
50 }
51 
TearDownTestCase()52 void HdfLightHdiServiceTest::TearDownTestCase()
53 {
54 }
55 
SetUp()56 void HdfLightHdiServiceTest::SetUp()
57 {
58 }
59 
TearDown()60 void HdfLightHdiServiceTest::TearDown()
61 {
62 }
63 
InitConfig(HdfLightEffect &effect)64 void 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   */
HWTEST_F(HdfLightHdiServiceTest, SUB_Driver_Sensor_HdiLight_0100, Function | MediumTest | Level1)77 HWTEST_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   */
HWTEST_F(HdfLightHdiServiceTest, SUB_Driver_Sensor_HdiLight_0200, Function | MediumTest | Level1)87 HWTEST_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   */
HWTEST_F(HdfLightHdiServiceTest, SUB_Driver_Sensor_HdiLight_0300, Function | MediumTest | Level1)108 HWTEST_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   */
HWTEST_F(HdfLightHdiServiceTest, SUB_Driver_Sensor_HdiLight_0400, Function | MediumTest | Level1)140 HWTEST_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   */
HWTEST_F(HdfLightHdiServiceTest, SUB_Driver_Sensor_HdiLight_0500, Function | MediumTest | Level1)169 HWTEST_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   */
HWTEST_F(HdfLightHdiServiceTest, SUB_Driver_Sensor_HdiLight_0600, Function | MediumTest | Level1)203 HWTEST_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   */
HWTEST_F(HdfLightHdiServiceTest, SUB_Driver_Sensor_HdiLight_0700, Function | MediumTest | Level1)235 HWTEST_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   */
HWTEST_F(HdfLightHdiServiceTest, SUB_Driver_Sensor_HdiLight_0800, Function | MediumTest | Level1)251 HWTEST_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   */
HWTEST_F(HdfLightHdiServiceTest, SUB_Driver_Sensor_HdiLight_0900, Function | MediumTest | Level1)267 HWTEST_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   */
HWTEST_F(HdfLightHdiServiceTest, SUB_Driver_Sensor_HdiLight_1000, Function | MediumTest | Level1)292 HWTEST_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   */
HWTEST_F(HdfLightHdiServiceTest, SUB_Driver_Sensor_HdiLight_1100, Function | MediumTest | Level1)314 HWTEST_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   */
HWTEST_F(HdfLightHdiServiceTest, SUB_Driver_Sensor_HdiLight_1200, Function | MediumTest | Level1)336 HWTEST_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   */
HWTEST_F(HdfLightHdiServiceTest, SUB_Driver_Sensor_HdiLight_1300, Function | MediumTest | Level1)358 HWTEST_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   */
HWTEST_F(HdfLightHdiServiceTest, SUB_Driver_Sensor_HdiLight_1400, Function | MediumTest | Level1)383 HWTEST_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   */
HWTEST_F(HdfLightHdiServiceTest, SUB_Driver_Sensor_HdiLight_1500, Function | MediumTest | Level1)408 HWTEST_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   */
HWTEST_F(HdfLightHdiServiceTest, SUB_Driver_Sensor_HdiLight_1600, Function | MediumTest | Level1)432 HWTEST_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   */
HWTEST_F(HdfLightHdiServiceTest, SUB_Driver_Sensor_HdiLight_1700, Function | MediumTest | Level1)457 HWTEST_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   */
HWTEST_F(HdfLightHdiServiceTest, SUB_Driver_Sensor_HdiLight_1800, Function | MediumTest | Level1)476 HWTEST_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   */
HWTEST_F(HdfLightHdiServiceTest, SUB_Driver_Sensor_HdiLight_1900, Function | MediumTest | Level1)495 HWTEST_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   */
HWTEST_F(HdfLightHdiServiceTest, SUB_Driver_Sensor_HdiLight_2000, Function | MediumTest | Level1)520 HWTEST_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   */
HWTEST_F(HdfLightHdiServiceTest, SUB_Driver_Sensor_HdiLight_2100, Function | MediumTest | Level1)545 HWTEST_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   */
HWTEST_F(HdfLightHdiServiceTest, SUB_Driver_Sensor_HdiLight_2200, Function | MediumTest | Level1)570 HWTEST_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   */
HWTEST_F(HdfLightHdiServiceTest, SUB_Driver_Sensor_HdiLight_2300, Function | MediumTest | Level1)595 HWTEST_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 }