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
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 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
38 class HdfLightHdiTest : public testing::Test {
39 public:
40 static void SetUpTestCase();
41 static void TearDownTestCase();
42 void SetUp();
43 void TearDown();
44 };
45
SetUpTestCase()46 void HdfLightHdiTest::SetUpTestCase()
47 {
48 g_lightInterface = ILightInterface::Get();
49 }
50
TearDownTestCase()51 void HdfLightHdiTest::TearDownTestCase()
52 {
53 }
54
SetUp()55 void HdfLightHdiTest::SetUp()
56 {
57 }
58
TearDown()59 void HdfLightHdiTest::TearDown()
60 {
61 }
62
InitConfig(HdfLightEffect & effect)63 static 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 */
77 HWTEST_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 */
100 HWTEST_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 */
123 HWTEST_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 */
146 HWTEST_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 */
172 HWTEST_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 */
198 HWTEST_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 */
223 HWTEST_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 */
249 HWTEST_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 */
269 HWTEST_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 */
289 HWTEST_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 */
315 HWTEST_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 */
341 HWTEST_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 */
367 HWTEST_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 */
393 HWTEST_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 */
419 HWTEST_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 }