• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (c) 2025 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 #include <cJSON.h>
16 #include <gtest/gtest.h>
17 #include "brightness_config_parser.h"
18 #include "calculation_config_parser.h"
19 #include "config_parser_base.h"
20 #include "display_log.h"
21 #include "lux_filter_config_parser.h"
22 #include "lux_threshold_config_parser.h"
23 
24 using namespace testing;
25 using namespace testing::ext;
26 using namespace OHOS;
27 using namespace OHOS::DisplayPowerMgr;
28 using namespace std;
29 
30 class BrightnessConfigParseTest : public Test {
31 public:
SetUp()32     void SetUp() override
33     {
34         root_ = cJSON_CreateObject();
35     }
36 
TearDown()37     void TearDown() override
38     {
39         cJSON_Delete(root_);
40     }
41 
42     cJSON* root_;
43 };
44 
45 namespace {
46 constexpr float POINT_1_X = 1.5f;
47 constexpr float POINT_1_Y = 2.3f;
48 constexpr float POINT_2_X = 4.0f;
49 constexpr float POINT_2_Y = 5.0f;
50 constexpr size_t NUMBER_ONE = 1;
51 constexpr size_t NUMBER_TWO = 2;
52 constexpr size_t DISPLAY_ID_ONE = 100;
53 constexpr size_t DISPLAY_ID_TWO = 101;
54 constexpr size_t SENSOR_ID_ONE = 200;
55 constexpr size_t SENSOR_ID_TWO = 201;
56 constexpr size_t DEFAULT_VALUE_NUMBER = -1;
57 constexpr float DEFAULT_VALUE_FLOAT = -1.0f;
58 
59 HWTEST_F(BrightnessConfigParseTest, BrightnessConfigParseTest001, TestSize.Level0)
60 {
61     DISPLAY_HILOGI(LABEL_TEST, "BrightnessConfigParseTest001 function start!");
62     EXPECT_TRUE(root_);
63     cJSON* array = cJSON_CreateArray();
64     cJSON* item1 = cJSON_CreateFloatArray((const float[]){POINT_1_X, POINT_1_Y}, NUMBER_TWO);
65     cJSON* item2 = cJSON_CreateFloatArray((const float[]){POINT_2_X, POINT_2_Y}, NUMBER_TWO);
66     cJSON_AddItemToArray(array, item1);
67     cJSON_AddItemToArray(array, item2);
68     cJSON_AddItemToObject(root_, "points", array);
69 
70     std::vector<PointXy> data;
71     ConfigParserBase parser;
72     parser.ParsePointXy(root_, "points", data);
73 
74     ASSERT_EQ(data.size(), NUMBER_TWO);
75     EXPECT_EQ(data[0].x, POINT_1_X);
76     EXPECT_EQ(data[0].y, POINT_1_Y);
77     EXPECT_EQ(data[1].x, POINT_2_X);
78     EXPECT_EQ(data[1].y, POINT_2_Y);
79     DISPLAY_HILOGI(LABEL_TEST, "BrightnessConfigParseTest001 function end!");
80 }
81 
82 HWTEST_F(BrightnessConfigParseTest, BrightnessConfigParseTest002, TestSize.Level0)
83 {
84     DISPLAY_HILOGI(LABEL_TEST, "BrightnessConfigParseTest002 function start!");
85     EXPECT_TRUE(root_);
86     cJSON* array = cJSON_CreateArray();
87     cJSON* item = cJSON_CreateFloatArray((const float[]){POINT_1_X}, NUMBER_ONE);
88     cJSON_AddItemToArray(array, item);
89     cJSON_AddItemToObject(root_, "points", array);
90 
91     std::vector<PointXy> data;
92     ConfigParserBase parser;
93     parser.ParsePointXy(root_, "points", data);
94     EXPECT_TRUE(data.empty());
95     DISPLAY_HILOGI(LABEL_TEST, "BrightnessConfigParseTest002 function end!");
96 }
97 
98 HWTEST_F(BrightnessConfigParseTest, BrightnessConfigParseTest003, TestSize.Level0)
99 {
100     DISPLAY_HILOGI(LABEL_TEST, "BrightnessConfigParseTest003 function start!");
101     EXPECT_TRUE(root_);
102     std::vector<PointXy> data;
103     ConfigParserBase parser;
104     parser.ParsePointXy(root_, "points", data);
105     EXPECT_TRUE(data.empty());
106     DISPLAY_HILOGI(LABEL_TEST, "BrightnessConfigParseTest003 function end!");
107 }
108 
109 HWTEST_F(BrightnessConfigParseTest, BrightnessConfigParseTest004, TestSize.Level0)
110 {
111     DISPLAY_HILOGI(LABEL_TEST, "BrightnessConfigParseTest004 function start!");
112     EXPECT_TRUE(root_);
113     cJSON* array = cJSON_CreateArray();
114     cJSON_AddItemToObject(root_, "points", array);
115     std::vector<PointXy> data;
116     ConfigParserBase parser;
117     parser.ParsePointXy(root_, "points", data);
118     EXPECT_TRUE(data.empty());
119     DISPLAY_HILOGI(LABEL_TEST, "BrightnessConfigParseTest004 function end!");
120 }
121 
122 HWTEST_F(BrightnessConfigParseTest, BrightnessConfigParseTest005, TestSize.Level0)
123 {
124     DISPLAY_HILOGI(LABEL_TEST, "BrightnessConfigParseTest005 function start!");
125     EXPECT_TRUE(root_);
126     cJSON_AddItemToObject(root_, "points", cJSON_CreateString("not an array"));
127     std::vector<PointXy> data;
128     ConfigParserBase parser;
129     parser.ParsePointXy(root_, "points", data);
130     EXPECT_TRUE(data.empty());
131     DISPLAY_HILOGI(LABEL_TEST, "BrightnessConfigParseTest005 function end!");
132 }
133 
134 HWTEST_F(BrightnessConfigParseTest, BrightnessConfigParseTest006, TestSize.Level0)
135 {
136     DISPLAY_HILOGI(LABEL_TEST, "BrightnessConfigParseTest006 function start!");
137     EXPECT_TRUE(root_);
138     cJSON* array = cJSON_CreateArray();
139     cJSON_AddItemToArray(array, cJSON_CreateString("not array"));
140     cJSON_AddItemToObject(root_, "points", array);
141 
142     std::vector<PointXy> data;
143     ConfigParserBase parser;
144     parser.ParsePointXy(root_, "points", data);
145     EXPECT_TRUE(data.empty());
146     DISPLAY_HILOGI(LABEL_TEST, "BrightnessConfigParseTest006 function end!");
147 }
148 
149 HWTEST_F(BrightnessConfigParseTest, BrightnessConfigParseTest007, TestSize.Level0)
150 {
151     DISPLAY_HILOGI(LABEL_TEST, "BrightnessConfigParseTest007 function start!");
152     EXPECT_TRUE(root_);
153     cJSON* array = cJSON_CreateArray();
154 
155     cJSON* item1 = cJSON_CreateObject();
156     cJSON_AddItemToObject(item1, "displayMode", cJSON_CreateNumber(0));
157     cJSON_AddItemToObject(item1, "displayId", cJSON_CreateNumber(DISPLAY_ID_ONE));
158     cJSON_AddItemToObject(item1, "sensorId", cJSON_CreateNumber(SENSOR_ID_ONE));
159     cJSON_AddItemToArray(array, item1);
160 
161     cJSON* item2 = cJSON_CreateObject();
162     cJSON_AddItemToObject(item2, "displayMode", cJSON_CreateNumber(NUMBER_ONE));
163     cJSON_AddItemToObject(item2, "displayId", cJSON_CreateNumber(DISPLAY_ID_TWO));
164     cJSON_AddItemToObject(item2, "sensorId", cJSON_CreateNumber(SENSOR_ID_TWO));
165     cJSON_AddItemToArray(array, item2);
166 
167     cJSON_AddItemToObject(root_, "displayModeData", array);
168 
169     std::unordered_map<int, ScreenData> data;
170     ConfigParserBase parser;
171     parser.ParseScreenData(root_, "displayModeData", data, "displayMode");
172 
173     ASSERT_EQ(data.size(), NUMBER_TWO);
174     EXPECT_EQ(data[0].displayId, DISPLAY_ID_ONE);
175     EXPECT_EQ(data[0].sensorId, SENSOR_ID_ONE);
176     EXPECT_EQ(data[1].displayId, DISPLAY_ID_TWO);
177     EXPECT_EQ(data[1].sensorId, SENSOR_ID_TWO);
178     DISPLAY_HILOGI(LABEL_TEST, "BrightnessConfigParseTest007 function end!");
179 }
180 
181 HWTEST_F(BrightnessConfigParseTest, BrightnessConfigParseTest008, TestSize.Level0)
182 {
183     DISPLAY_HILOGI(LABEL_TEST, "BrightnessConfigParseTest008 function start!");
184     EXPECT_TRUE(root_);
185     std::unordered_map<int, ScreenData> data;
186     ConfigParserBase parser;
187     parser.ParseScreenData(root_, "displayModeData", data, "displayMode");
188     EXPECT_TRUE(data.empty());
189     DISPLAY_HILOGI(LABEL_TEST, "BrightnessConfigParseTest008 function end!");
190 }
191 
192 HWTEST_F(BrightnessConfigParseTest, BrightnessConfigParseTest009, TestSize.Level0)
193 {
194     DISPLAY_HILOGI(LABEL_TEST, "BrightnessConfigParseTest009 function start!");
195     EXPECT_TRUE(root_);
196     cJSON_AddItemToObject(root_, "displayModeData", cJSON_CreateString("not an array"));
197     std::unordered_map<int, ScreenData> data;
198     ConfigParserBase parser;
199     parser.ParseScreenData(root_, "displayModeData", data, "displayMode");
200     EXPECT_TRUE(data.empty());
201     DISPLAY_HILOGI(LABEL_TEST, "BrightnessConfigParseTest009 function end!");
202 }
203 
204 HWTEST_F(BrightnessConfigParseTest, BrightnessConfigParseTest010, TestSize.Level0)
205 {
206     DISPLAY_HILOGI(LABEL_TEST, "BrightnessConfigParseTest010 function start!");
207     EXPECT_TRUE(root_);
208     cJSON* array = cJSON_CreateArray();
209     cJSON_AddItemToArray(array, cJSON_CreateNumber(DISPLAY_ID_ONE));
210     cJSON_AddItemToObject(root_, "displayModeData", array);
211 
212     std::unordered_map<int, ScreenData> data;
213     ConfigParserBase parser;
214     parser.ParseScreenData(root_, "displayModeData", data, "displayMode");
215     EXPECT_TRUE(data.empty());
216     DISPLAY_HILOGI(LABEL_TEST, "BrightnessConfigParseTest010 function end!");
217 }
218 
219 HWTEST_F(BrightnessConfigParseTest, BrightnessConfigParseTest011, TestSize.Level0)
220 {
221     DISPLAY_HILOGI(LABEL_TEST, "BrightnessConfigParseTest011 function start!");
222     EXPECT_TRUE(root_);
223     cJSON* array = cJSON_CreateArray();
224 
225     cJSON* item = cJSON_CreateObject();
226     cJSON_AddItemToObject(item, "displayId", cJSON_CreateNumber(DISPLAY_ID_ONE));
227     cJSON_AddItemToArray(array, item);
228     cJSON_AddItemToObject(root_, "displayModeData", array);
229 
230     std::unordered_map<int, ScreenData> data;
231     ConfigParserBase parser;
232     parser.ParseScreenData(root_, "displayModeData", data, "displayMode");
233     ASSERT_EQ(data.size(), NUMBER_ONE);
234     EXPECT_EQ(data[0].displayId, DISPLAY_ID_ONE);
235     EXPECT_EQ(data[0].sensorId, 0);
236     DISPLAY_HILOGI(LABEL_TEST, "BrightnessConfigParseTest011 function end!");
237 }
238 
239 HWTEST_F(BrightnessConfigParseTest, BrightnessConfigParseTest012, TestSize.Level0)
240 {
241     DISPLAY_HILOGI(LABEL_TEST, "BrightnessConfigParseTest012 function start!");
242     EXPECT_TRUE(root_);
243     cJSON* array = cJSON_CreateArray();
244 
245     cJSON* item = cJSON_CreateObject();
246     cJSON_AddItemToObject(item, "displayMode", cJSON_CreateNumber(0));
247     cJSON_AddItemToArray(array, item);
248     cJSON_AddItemToObject(root_, "displayModeData", array);
249 
250     std::unordered_map<int, ScreenData> data;
251     ConfigParserBase parser;
252     parser.ParseScreenData(root_, "displayModeData", data, "displayMode");
253 
254     ASSERT_EQ(data.size(), NUMBER_ONE);
255     EXPECT_EQ(data[0].displayId, 0);
256     EXPECT_EQ(data[0].sensorId, 0);
257     DISPLAY_HILOGI(LABEL_TEST, "BrightnessConfigParseTest012 function end!");
258 }
259 
260 HWTEST_F(BrightnessConfigParseTest, BrightnessConfigParseTest013, TestSize.Level0)
261 {
262     DISPLAY_HILOGI(LABEL_TEST, "BrightnessConfigParseTest013 function start!");
263     EXPECT_TRUE(root_);
264     cJSON* array = cJSON_CreateArray();
265     cJSON_AddItemToObject(root_, "displayModeData", array);
266 
267     std::unordered_map<int, ScreenData> data;
268     ConfigParserBase parser;
269     parser.ParseScreenData(root_, "displayModeData", data, "displayMode");
270     EXPECT_TRUE(data.empty());
271     DISPLAY_HILOGI(LABEL_TEST, "BrightnessConfigParseTest013 function end!");
272 }
273 
274 HWTEST_F(BrightnessConfigParseTest, BrightnessConfigParseTest014, TestSize.Level0)
275 {
276     DISPLAY_HILOGI(LABEL_TEST, "BrightnessConfigParseTest014 function start!");
277     EXPECT_TRUE(root_);
278     cJSON_AddItemToObject(root_, "filterName", cJSON_CreateString("default"));
279     cJSON_AddItemToObject(root_, "filterNoFilterNum", cJSON_CreateNumber(NUMBER_ONE));
280     cJSON_AddItemToObject(root_, "filterNum", cJSON_CreateNumber(NUMBER_TWO));
281     cJSON_AddItemToObject(root_, "filterMaxFuncLuxNum", cJSON_CreateNumber(DISPLAY_ID_ONE));
282     cJSON_AddItemToObject(root_, "filterAlpha", cJSON_CreateNumber(POINT_1_X));
283     cJSON_AddItemToObject(root_, "filterLuxTh", cJSON_CreateNumber(DISPLAY_ID_TWO));
284 
285     LuxFilterConfigParser parser;
286     std::unordered_map<std::string, LuxFilterConfig::Data> data;
287     parser.LuxFilterParseConfigParams(root_, data);
288 
289     ASSERT_EQ(data.size(), 1);
290     EXPECT_EQ(data["default"].filterNoFilterNum, NUMBER_ONE);
291     EXPECT_EQ(data["default"].filterNum, NUMBER_TWO);
292     EXPECT_EQ(data["default"].filterMaxFuncLuxNum, DISPLAY_ID_ONE);
293     EXPECT_FLOAT_EQ(data["default"].filterAlpha, POINT_1_X);
294     EXPECT_EQ(data["default"].filterLuxTh, DISPLAY_ID_TWO);
295 
296     DISPLAY_HILOGI(LABEL_TEST, "BrightnessConfigParseTest014 function end!");
297 }
298 
299 HWTEST_F(BrightnessConfigParseTest, BrightnessConfigParseTest015, TestSize.Level0)
300 {
301     DISPLAY_HILOGI(LABEL_TEST, "BrightnessConfigParseTest015 function start!");
302     EXPECT_TRUE(root_);
303     cJSON_AddItemToObject(root_, "filterNum", cJSON_CreateNumber(NUMBER_ONE));
304     LuxFilterConfigParser parser;
305     std::unordered_map<std::string, LuxFilterConfig::Data> data;
306     parser.LuxFilterParseConfigParams(root_, data);
307     EXPECT_TRUE(data.empty());
308     DISPLAY_HILOGI(LABEL_TEST, "BrightnessConfigParseTest015 function end!");
309 }
310 
311 HWTEST_F(BrightnessConfigParseTest, BrightnessConfigParseTest016, TestSize.Level0)
312 {
313     DISPLAY_HILOGI(LABEL_TEST, "BrightnessConfigParseTest016 function start!");
314     EXPECT_TRUE(root_);
315     cJSON_AddItemToObject(root_, "filterName", cJSON_CreateNumber(NUMBER_ONE));
316     LuxFilterConfigParser parser;
317     std::unordered_map<std::string, LuxFilterConfig::Data> data;
318     parser.LuxFilterParseConfigParams(root_, data);
319     EXPECT_TRUE(data.empty());
320     DISPLAY_HILOGI(LABEL_TEST, "BrightnessConfigParseTest016 function end!");
321 }
322 
323 HWTEST_F(BrightnessConfigParseTest, BrightnessConfigParseTest017, TestSize.Level0)
324 {
325     DISPLAY_HILOGI(LABEL_TEST, "BrightnessConfigParseTest017 function start!");
326     EXPECT_TRUE(root_);
327     cJSON_AddItemToObject(root_, "filterName", cJSON_CreateString(""));
328     LuxFilterConfigParser parser;
329     std::unordered_map<std::string, LuxFilterConfig::Data> data;
330     parser.LuxFilterParseConfigParams(root_, data);
331     EXPECT_TRUE(data.empty());
332     DISPLAY_HILOGI(LABEL_TEST, "BrightnessConfigParseTest017 function end!");
333 }
334 
335 HWTEST_F(BrightnessConfigParseTest, BrightnessConfigParseTest018, TestSize.Level0)
336 {
337     DISPLAY_HILOGI(LABEL_TEST, "BrightnessConfigParseTest018 function start!");
338     EXPECT_TRUE(root_);
339     cJSON_AddItemToObject(root_, "filterName", cJSON_CreateString("default"));
340 
341     LuxFilterConfigParser parser;
342     std::unordered_map<std::string, LuxFilterConfig::Data> data;
343     parser.LuxFilterParseConfigParams(root_, data);
344 
345     ASSERT_EQ(data.size(), 1);
346     EXPECT_EQ(data["default"].filterNoFilterNum, DEFAULT_VALUE_NUMBER);
347     EXPECT_EQ(data["default"].filterNum, DEFAULT_VALUE_NUMBER);
348     EXPECT_EQ(data["default"].filterMaxFuncLuxNum, DEFAULT_VALUE_NUMBER);
349     EXPECT_FLOAT_EQ(data["default"].filterAlpha, DEFAULT_VALUE_FLOAT);
350     EXPECT_EQ(data["default"].filterLuxTh, DEFAULT_VALUE_NUMBER);
351     DISPLAY_HILOGI(LABEL_TEST, "BrightnessConfigParseTest018 function end!");
352 }
353 
354 HWTEST_F(BrightnessConfigParseTest, BrightnessConfigParseTest019, TestSize.Level0)
355 {
356     DISPLAY_HILOGI(LABEL_TEST, "BrightnessConfigParseTest019 function start!");
357     EXPECT_TRUE(root_);
358     BrightnessConfig::Data data;
359     BrightnessConfigParser::ParseConfig(data);
360     EXPECT_FALSE(data.displayModeMap.empty());
361     DISPLAY_HILOGI(LABEL_TEST, "BrightnessConfigParseTest019 function end!");
362 }
363 
364 HWTEST_F(BrightnessConfigParseTest, BrightnessConfigParseTest020, TestSize.Level0)
365 {
366     DISPLAY_HILOGI(LABEL_TEST, "BrightnessConfigParseTest020 function start!");
367     EXPECT_TRUE(root_);
368     CalculationConfig::Data data;
369     CalculationConfigParser::ParseConfig(0, data);
370     EXPECT_FALSE(data.defaultPoints.empty());
371     DISPLAY_HILOGI(LABEL_TEST, "BrightnessConfigParseTest020 function end!");
372 }
373 
374 HWTEST_F(BrightnessConfigParseTest, BrightnessConfigParseTest022, TestSize.Level0)
375 {
376     DISPLAY_HILOGI(LABEL_TEST, "BrightnessConfigParseTest022 function start!");
377     EXPECT_TRUE(root_);
378     cJSON* array = cJSON_CreateArray();
379     cJSON* item1 = cJSON_CreateArray();
380     if (item1 != NULL) {
381         cJSON_AddItemToArray(item1, cJSON_CreateString("POINT_1_X"));
382         cJSON_AddItemToArray(item1, cJSON_CreateString("POINT_1_Y"));
383     }
384     cJSON_AddItemToArray(array, item1);
385     cJSON_AddItemToObject(root_, "points", array);
386 
387     std::vector<PointXy> data;
388     ConfigParserBase parser;
389     parser.LoadConfigRoot(0, "brightness_config");
390     parser.ParsePointXy(root_, "points", data);
391     ASSERT_EQ(data.size(), NUMBER_ONE);
392     EXPECT_EQ(data[0].x, DEFAULT_VALUE_FLOAT);
393     EXPECT_EQ(data[0].y, DEFAULT_VALUE_FLOAT);
394     DISPLAY_HILOGI(LABEL_TEST, "BrightnessConfigParseTest022 function end!");
395 }
396 
397 HWTEST_F(BrightnessConfigParseTest, BrightnessConfigParseTest023, TestSize.Level0)
398 {
399     DISPLAY_HILOGI(LABEL_TEST, "BrightnessConfigParseTest023 function start!");
400     EXPECT_TRUE(root_);
401     cJSON_AddItemToObject(root_, "modeName", cJSON_CreateNumber(NUMBER_ONE));
402 
403     LuxThresholdConfigParser parser;
404     LuxThresholdConfig::Data data;
405     parser.LuxThresholdParseConfigParams(root_, data);
406     EXPECT_TRUE(data.modeArray.empty());
407     DISPLAY_HILOGI(LABEL_TEST, "BrightnessConfigParseTest023 function end!");
408 }
409 
410 HWTEST_F(BrightnessConfigParseTest, BrightnessConfigParseTest024, TestSize.Level0)
411 {
412     DISPLAY_HILOGI(LABEL_TEST, "BrightnessConfigParseTest024 function start!");
413     EXPECT_TRUE(root_);
414     cJSON_AddItemToObject(root_, "modeName", cJSON_CreateString("indoor"));
415     cJSON_AddItemToObject(root_, "brightenDebounceTime", cJSON_CreateNumber(NUMBER_ONE));
416     cJSON_AddItemToObject(root_, "darkenDebounceTime", cJSON_CreateNumber(NUMBER_TWO));
417 
418     LuxThresholdConfigParser parser;
419     LuxThresholdConfig::Data data;
420     parser.LuxThresholdParseConfigParams(root_, data);
421     ASSERT_EQ(data.modeArray.size(), NUMBER_ONE);
422     auto& mode = data.modeArray["indoor"];
423     EXPECT_EQ(mode.brightenDebounceTime, NUMBER_ONE);
424     EXPECT_EQ(mode.darkenDebounceTime, NUMBER_TWO);
425     DISPLAY_HILOGI(LABEL_TEST, "BrightnessConfigParseTest024 function end!");
426 }
427 
428 HWTEST_F(BrightnessConfigParseTest, BrightnessConfigParseTest025, TestSize.Level0)
429 {
430     DISPLAY_HILOGI(LABEL_TEST, "BrightnessConfigParseTest025 function start!");
431     EXPECT_TRUE(root_);
432     cJSON_AddItemToObject(root_, "brightenDebounceTime", cJSON_CreateNumber(NUMBER_ONE));
433 
434     LuxThresholdConfigParser parser;
435     LuxThresholdConfig::Data data;
436     parser.LuxThresholdParseConfigParams(root_, data);
437     EXPECT_TRUE(data.modeArray.empty());
438     DISPLAY_HILOGI(LABEL_TEST, "BrightnessConfigParseTest025 function end!");
439 }
440 
441 HWTEST_F(BrightnessConfigParseTest, BrightnessConfigParseTest027, TestSize.Level0)
442 {
443     DISPLAY_HILOGI(LABEL_TEST, "BrightnessConfigParseTest027 function start!");
444     EXPECT_TRUE(root_);
445     BrightnessConfig::Data data;
446     bool ret = BrightnessConfigParser::ParseConfigJsonRoot("", data);
447     EXPECT_FALSE(ret);
448     DISPLAY_HILOGI(LABEL_TEST, "BrightnessConfigParseTest027 function end!");
449 }
450 
451 HWTEST_F(BrightnessConfigParseTest, BrightnessConfigParseTest028, TestSize.Level0)
452 {
453     DISPLAY_HILOGI(LABEL_TEST, "BrightnessConfigParseTest028 function start!");
454     EXPECT_TRUE(root_);
455     BrightnessConfig::Data data;
456     bool ret = BrightnessConfigParser::ParseConfigJsonRoot("[]", data);
457     EXPECT_FALSE(ret);
458     DISPLAY_HILOGI(LABEL_TEST, "BrightnessConfigParseTest028 function end!");
459 }
460 
461 HWTEST_F(BrightnessConfigParseTest, BrightnessConfigParseTest029, TestSize.Level0)
462 {
463     DISPLAY_HILOGI(LABEL_TEST, "BrightnessConfigParseTest029 function start!");
464     EXPECT_TRUE(root_);
465     BrightnessConfig::Data data;
466     const std::string json = R"({"lid": {"action": 1, "delayMs": 2}})";
467     bool ret = BrightnessConfigParser::ParseConfigJsonRoot(json, data);
468     EXPECT_TRUE(ret);
469     DISPLAY_HILOGI(LABEL_TEST, "BrightnessConfigParseTest029 function end!");
470 }
471 
472 HWTEST_F(BrightnessConfigParseTest, BrightnessConfigParseTest030, TestSize.Level0)
473 {
474     DISPLAY_HILOGI(LABEL_TEST, "BrightnessConfigParseTest030 function start!");
475     EXPECT_TRUE(root_);
476     CalculationConfig::Data data;
477     bool ret = CalculationConfigParser::ParseConfigJsonRoot(0, "", data);
478     EXPECT_FALSE(ret);
479     DISPLAY_HILOGI(LABEL_TEST, "BrightnessConfigParseTest030 function end!");
480 }
481 
482 HWTEST_F(BrightnessConfigParseTest, BrightnessConfigParseTest031, TestSize.Level0)
483 {
484     DISPLAY_HILOGI(LABEL_TEST, "BrightnessConfigParseTest031 function start!");
485     EXPECT_TRUE(root_);
486     CalculationConfig::Data data;
487     bool ret = CalculationConfigParser::ParseConfigJsonRoot(0, "[]", data);
488     EXPECT_FALSE(ret);
489     DISPLAY_HILOGI(LABEL_TEST, "BrightnessConfigParseTest031 function end!");
490 }
491 
492 HWTEST_F(BrightnessConfigParseTest, BrightnessConfigParseTest032, TestSize.Level0)
493 {
494     DISPLAY_HILOGI(LABEL_TEST, "BrightnessConfigParseTest032 function start!");
495     EXPECT_TRUE(root_);
496     CalculationConfig::Data data;
497     const std::string json = R"({"defaultBrightness": 2})";
498     bool ret = CalculationConfigParser::ParseConfigJsonRoot(0, json, data);
499     EXPECT_TRUE(ret);
500     DISPLAY_HILOGI(LABEL_TEST, "BrightnessConfigParseTest032 function end!");
501 }
502 
503 HWTEST_F(BrightnessConfigParseTest, BrightnessConfigParseTest033, TestSize.Level0)
504 {
505     DISPLAY_HILOGI(LABEL_TEST, "BrightnessConfigParseTest033 function start!");
506     EXPECT_TRUE(root_);
507     std::unordered_map<std::string, LuxFilterConfig::Data> data;
508     LuxFilterConfigParser::ParseConfig(0, data);
509     bool ret = LuxFilterConfigParser::ParseConfigJsonRoot("", data);
510     EXPECT_FALSE(ret);
511     DISPLAY_HILOGI(LABEL_TEST, "BrightnessConfigParseTest033 function end!");
512 }
513 
514 HWTEST_F(BrightnessConfigParseTest, BrightnessConfigParseTest034, TestSize.Level0)
515 {
516     DISPLAY_HILOGI(LABEL_TEST, "BrightnessConfigParseTest034 function start!");
517     EXPECT_TRUE(root_);
518     std::unordered_map<std::string, LuxFilterConfig::Data> data;
519     const std::string json = R"({"test": 2})";
520     bool ret = LuxFilterConfigParser::ParseConfigJsonRoot(json, data);
521     EXPECT_FALSE(ret);
522     DISPLAY_HILOGI(LABEL_TEST, "BrightnessConfigParseTest034 function end!");
523 }
524 
525 HWTEST_F(BrightnessConfigParseTest, BrightnessConfigParseTest035, TestSize.Level0)
526 {
527     DISPLAY_HILOGI(LABEL_TEST, "BrightnessConfigParseTest035 function start!");
528     EXPECT_TRUE(root_);
529     std::unordered_map<std::string, LuxFilterConfig::Data> data;
530     const std::string json = R"([{"name":"A", "value":123}, []])";
531     bool ret = LuxFilterConfigParser::ParseConfigJsonRoot(json, data);
532     EXPECT_TRUE(ret);
533     DISPLAY_HILOGI(LABEL_TEST, "BrightnessConfigParseTest035 function end!");
534 }
535 
536 HWTEST_F(BrightnessConfigParseTest, BrightnessConfigParseTest036, TestSize.Level0)
537 {
538     DISPLAY_HILOGI(LABEL_TEST, "BrightnessConfigParseTest036 function start!");
539     EXPECT_TRUE(root_);
540     std::unordered_map<std::string, LuxFilterConfig::Data> data;
541     std::string json = R"([{"name":"A", "value":123}, {"name":"B", "value":456}])";
542     bool ret = LuxFilterConfigParser::ParseConfigJsonRoot(json, data);
543     EXPECT_TRUE(ret);
544     DISPLAY_HILOGI(LABEL_TEST, "BrightnessConfigParseTest036 function end!");
545 }
546 
547 HWTEST_F(BrightnessConfigParseTest, BrightnessConfigParseTest038, TestSize.Level0)
548 {
549     DISPLAY_HILOGI(LABEL_TEST, "BrightnessConfigParseTest038 function start!");
550     EXPECT_TRUE(root_);
551     LuxThresholdConfig::Data data;
552     LuxThresholdConfigParser::ParseConfig(0, data);
553     bool ret = LuxThresholdConfigParser::ParseConfigJsonRoot("", data);
554     EXPECT_FALSE(ret);
555     DISPLAY_HILOGI(LABEL_TEST, "BrightnessConfigParseTest038 function end!");
556 }
557 
558 HWTEST_F(BrightnessConfigParseTest, BrightnessConfigParseTest039, TestSize.Level0)
559 {
560     DISPLAY_HILOGI(LABEL_TEST, "BrightnessConfigParseTest039 function start!");
561     EXPECT_TRUE(root_);
562     LuxThresholdConfig::Data data;
563     bool ret = LuxThresholdConfigParser::ParseConfigJsonRoot("[]", data);
564     EXPECT_FALSE(ret);
565     DISPLAY_HILOGI(LABEL_TEST, "BrightnessConfigParseTest039 function end!");
566 }
567 
568 HWTEST_F(BrightnessConfigParseTest, BrightnessConfigParseTest040, TestSize.Level0)
569 {
570     DISPLAY_HILOGI(LABEL_TEST, "BrightnessConfigParseTest040 function start!");
571     EXPECT_TRUE(root_);
572     LuxThresholdConfig::Data data;
573     const std::string json = R"({"isLevelEnable": "11", "thresholdMode": "12"})";
574     bool ret = LuxThresholdConfigParser::ParseConfigJsonRoot(json, data);
575     EXPECT_FALSE(ret);
576     DISPLAY_HILOGI(LABEL_TEST, "BrightnessConfigParseTest040 function end!");
577 }
578 
579 HWTEST_F(BrightnessConfigParseTest, BrightnessConfigParseTest041, TestSize.Level0)
580 {
581     DISPLAY_HILOGI(LABEL_TEST, "BrightnessConfigParseTest041 function start!");
582     EXPECT_TRUE(root_);
583     LuxThresholdConfig::Data data;
584     std::string json = R"({"isLevelEnable": true, "thresholdMode": [{"name":"A", "value":123},
585         {"name":"B", "value":456}]})";
586     bool ret = LuxThresholdConfigParser::ParseConfigJsonRoot(json, data);
587     EXPECT_TRUE(ret);
588     DISPLAY_HILOGI(LABEL_TEST, "BrightnessConfigParseTest041 function end!");
589 }
590 
591 HWTEST_F(BrightnessConfigParseTest, BrightnessConfigParseTest042, TestSize.Level0)
592 {
593     DISPLAY_HILOGI(LABEL_TEST, "BrightnessConfigParseTest042 function start!");
594     EXPECT_TRUE(root_);
595     LuxThresholdConfig::Data data;
596     std::string json = R"({"isLevelEnable": true, "thresholdMode": [{"name":"A", "value":123}, []]})";
597     bool ret = LuxThresholdConfigParser::ParseConfigJsonRoot(json, data);
598     EXPECT_TRUE(ret);
599     DISPLAY_HILOGI(LABEL_TEST, "BrightnessConfigParseTest042 function end!");
600 }
601 
602 HWTEST_F(BrightnessConfigParseTest, BrightnessConfigParseTest043, TestSize.Level0)
603 {
604     DISPLAY_HILOGI(LABEL_TEST, "BrightnessConfigParseTest043 function start!");
605     EXPECT_TRUE(root_);
606     cJSON_AddItemToObject(root_, "modeName", cJSON_CreateString("indoor"));
607 
608     LuxThresholdConfigParser parser;
609     LuxThresholdConfig::Data data;
610     parser.LuxThresholdParseConfigParams(root_, data);
611     ASSERT_EQ(data.modeArray.size(), NUMBER_ONE);
612     DISPLAY_HILOGI(LABEL_TEST, "BrightnessConfigParseTest043 function end!");
613 }
614 
615 HWTEST_F(BrightnessConfigParseTest, BrightnessConfigParseTest044, TestSize.Level0)
616 {
617     DISPLAY_HILOGI(LABEL_TEST, "BrightnessConfigParseTest044 function start!");
618     EXPECT_TRUE(root_);
619     CalculationConfig::Data data;
620     const std::string json = R"({"test": 2})";
621     bool ret = CalculationConfigParser::ParseConfigJsonRoot(0, json, data);
622     EXPECT_TRUE(ret);
623     DISPLAY_HILOGI(LABEL_TEST, "BrightnessConfigParseTest044 function end!");
624 }
625 } // namespace
626