From 45aef3f3828a751c1a29b449ca2e03232e4a2441 Mon Sep 17 00:00:00 2001 From: gaorui Date: Tue, 10 Jun 2025 17:46:06 +0800 Subject: [PATCH] fix: cJSON code optimize and add tests Signed-off-by: gaorui Change-Id: Ib4f3ade6d78b247bb9678675ec807117c616cc9f --- .../include/brightness_config_parser.h | 2 + .../include/calculation_config_parser.h | 2 + .../include/config_parser_base.h | 3 +- .../include/lux_filter_config_parser.h | 2 + .../include/lux_threshold_config_parser.h | 1 + .../src/brightness_config_parser.cpp | 18 +- .../src/calculation_config_parser.cpp | 22 +- brightness_manager/src/config_parser_base.cpp | 27 +- .../src/lux_filter_config_parser.cpp | 30 +- .../src/lux_threshold_config_parser.cpp | 28 +- brightness_manager/test/unittest/BUILD.gn | 6 + .../src/brightness_config_parse_test.cpp | 290 ++++++++++++++++++ .../service/native/src/screen_controller.cpp | 4 +- .../native/include/display_cjson_utils.h | 58 ++++ 14 files changed, 447 insertions(+), 46 deletions(-) create mode 100644 state_manager/utils/native/include/display_cjson_utils.h diff --git a/brightness_manager/include/brightness_config_parser.h b/brightness_manager/include/brightness_config_parser.h index f721e74..7d3c3b4 100644 --- a/brightness_manager/include/brightness_config_parser.h +++ b/brightness_manager/include/brightness_config_parser.h @@ -17,6 +17,7 @@ #define BRIGHTNESS_CONFIG_PARSER_H #include +#include namespace OHOS { namespace DisplayPowerMgr { @@ -50,6 +51,7 @@ public: BrightnessConfigParser& operator=(BrightnessConfigParser&&) = delete; static bool ParseConfig(BrightnessConfig::Data& data); + static bool ParseConfigJsonRoot(const std::string& fileContent, BrightnessConfig::Data& data); static void PrintConfig(const BrightnessConfig::Data& data); }; } // namespace DisplayPowerMgr diff --git a/brightness_manager/include/calculation_config_parser.h b/brightness_manager/include/calculation_config_parser.h index d4d9b06..2a4654b 100644 --- a/brightness_manager/include/calculation_config_parser.h +++ b/brightness_manager/include/calculation_config_parser.h @@ -17,6 +17,7 @@ #define CALCULATION_CONFIG_PARSER_H #include +#include namespace OHOS { namespace DisplayPowerMgr { @@ -50,6 +51,7 @@ public: CalculationConfigParser& operator=(CalculationConfigParser&&) = delete; static bool ParseConfig(int displayId, CalculationConfig::Data& data); + static bool ParseConfigJsonRoot(int displayId, const std::string& fileContent, CalculationConfig::Data& data); static void PrintConfig(int displayId, const CalculationConfig::Data& data); }; } // namespace DisplayPowerMgr diff --git a/brightness_manager/include/config_parser_base.h b/brightness_manager/include/config_parser_base.h index 7900089..ade2cf9 100644 --- a/brightness_manager/include/config_parser_base.h +++ b/brightness_manager/include/config_parser_base.h @@ -24,6 +24,7 @@ #include "brightness_config_parser.h" #include "calculation_config_parser.h" +#include "display_cjson_utils.h" namespace OHOS { namespace DisplayPowerMgr { @@ -38,7 +39,7 @@ public: void Initialize(); const std::string LoadConfigPath(int displayId, const std::string& configName) const; - const cJSON* LoadConfigRoot(int displayId, const std::string& configName) const; + const std::string LoadConfigRoot(int displayId, const std::string& configName) const; void ParsePointXy(const cJSON* root, const std::string& name, std::vector& data) const; const std::string PointXyToString(const std::string& name, const std::vector& data) const; void ParseScreenData(const cJSON* root, const std::string& name, std::unordered_map& data, diff --git a/brightness_manager/include/lux_filter_config_parser.h b/brightness_manager/include/lux_filter_config_parser.h index 3a2556b..9ccf929 100644 --- a/brightness_manager/include/lux_filter_config_parser.h +++ b/brightness_manager/include/lux_filter_config_parser.h @@ -44,6 +44,8 @@ public: cJSON* item, std::unordered_map& data); static bool ParseConfig( int displayId, std::unordered_map& data); + static bool ParseConfigJsonRoot( + const std::string& fileContent, std::unordered_map& data); static void PrintConfig( int displayId, const std::unordered_map& data); }; diff --git a/brightness_manager/include/lux_threshold_config_parser.h b/brightness_manager/include/lux_threshold_config_parser.h index 9da7146..f1f016a 100644 --- a/brightness_manager/include/lux_threshold_config_parser.h +++ b/brightness_manager/include/lux_threshold_config_parser.h @@ -50,6 +50,7 @@ public: static void LuxThresholdParseConfigParams(cJSON* item, LuxThresholdConfig::Data& data); static bool ParseConfig(int displayId, LuxThresholdConfig::Data& data); + static bool ParseConfigJsonRoot(const std::string& fileContent, LuxThresholdConfig::Data& data); static void PrintConfig(int displayId, const LuxThresholdConfig::Data& data); }; } // namespace DisplayPowerMgr diff --git a/brightness_manager/src/brightness_config_parser.cpp b/brightness_manager/src/brightness_config_parser.cpp index c5dcb29..d5058c7 100644 --- a/brightness_manager/src/brightness_config_parser.cpp +++ b/brightness_manager/src/brightness_config_parser.cpp @@ -32,13 +32,24 @@ using namespace OHOS::DisplayPowerMgr; bool BrightnessConfigParser::ParseConfig(BrightnessConfig::Data& data) { DISPLAY_HILOGI(FEAT_BRIGHTNESS, "parse BrightnessConfigParser start!"); - const cJSON* root = ConfigParserBase::Get().LoadConfigRoot(0, CONFIG_NAME); - if (!root) { + const std::string fileContent = ConfigParserBase::Get().LoadConfigRoot(0, CONFIG_NAME); + if (!ParseConfigJsonRoot(fileContent, data)) { DISPLAY_HILOGI(FEAT_BRIGHTNESS, "parse BrightnessConfigParser error!"); return false; } + DISPLAY_HILOGI(FEAT_BRIGHTNESS, "parse BrightnessConfigParser over!"); + return true; +} + +bool BrightnessConfigParser::ParseConfigJsonRoot(const std::string& fileContent, BrightnessConfig::Data& data) +{ + const cJSON* root = cJSON_Parse(fileContent.c_str()); + if (!root) { + DISPLAY_HILOGE(FEAT_BRIGHTNESS, "Parse file %{public}s failure.", fileContent.c_str()); + return false; + } if (!cJSON_IsObject(root)) { - DISPLAY_HILOGI(FEAT_BRIGHTNESS, "root is not an object!"); + DISPLAY_HILOGE(FEAT_BRIGHTNESS, "root is not an object!"); cJSON_Delete(const_cast(root)); return false; } @@ -47,7 +58,6 @@ bool BrightnessConfigParser::ParseConfig(BrightnessConfig::Data& data) ConfigParserBase::Get().ParseScreenData(root, "foldStatus", data.foldStatusModeMap, "foldStatus"); cJSON_Delete(const_cast(root)); - DISPLAY_HILOGI(FEAT_BRIGHTNESS, "parse BrightnessConfigParser over!"); return true; } diff --git a/brightness_manager/src/calculation_config_parser.cpp b/brightness_manager/src/calculation_config_parser.cpp index f422146..b68ca3b 100644 --- a/brightness_manager/src/calculation_config_parser.cpp +++ b/brightness_manager/src/calculation_config_parser.cpp @@ -32,19 +32,32 @@ using namespace OHOS::DisplayPowerMgr; bool CalculationConfigParser::ParseConfig(int displayId, CalculationConfig::Data& data) { DISPLAY_HILOGI(FEAT_BRIGHTNESS, "[%{public}d] parse CalculationConfig start!", displayId); - const cJSON* root = ConfigParserBase::Get().LoadConfigRoot(displayId, CONFIG_NAME); - if (!root) { + const std::string fileContent = ConfigParserBase::Get().LoadConfigRoot(displayId, CONFIG_NAME); + if (!ParseConfigJsonRoot(displayId, fileContent, data)) { DISPLAY_HILOGI(FEAT_BRIGHTNESS, "[%{public}d] parse CalculationConfig error!", displayId); return false; } + + DISPLAY_HILOGI(FEAT_BRIGHTNESS, "[%{public}d] parse CalculationConfig over!", displayId); + return true; +} + +bool CalculationConfigParser::ParseConfigJsonRoot( + int displayId, const std::string& fileContent, CalculationConfig::Data& data) +{ + const cJSON* root = cJSON_Parse(fileContent.c_str()); + if (!root) { + DISPLAY_HILOGE(FEAT_BRIGHTNESS, "Parse file %{public}s failure.", fileContent.c_str()); + return false; + } if (!cJSON_IsObject(root)) { - DISPLAY_HILOGI(FEAT_BRIGHTNESS, "root is not an object!"); + DISPLAY_HILOGE(FEAT_BRIGHTNESS, "root is not an object!"); cJSON_Delete(const_cast(root)); return false; } const cJSON* defaultBrightnessNode = cJSON_GetObjectItemCaseSensitive(root, "defaultBrightness"); - if (defaultBrightnessNode && cJSON_IsNumber(defaultBrightnessNode)) { + if (DisplayJsonUtils::IsValidJsonNumber(defaultBrightnessNode)) { data.defaultBrightness = static_cast(defaultBrightnessNode->valuedouble); } else { DISPLAY_HILOGW(FEAT_BRIGHTNESS, "[%{public}d] parse defaultBrightness error!", displayId); @@ -53,7 +66,6 @@ bool CalculationConfigParser::ParseConfig(int displayId, CalculationConfig::Data ConfigParserBase::Get().ParsePointXy(root, "defaultPoints", data.defaultPoints); cJSON_Delete(const_cast(root)); - DISPLAY_HILOGI(FEAT_BRIGHTNESS, "[%{public}d] parse CalculationConfig over!", displayId); return true; } diff --git a/brightness_manager/src/config_parser_base.cpp b/brightness_manager/src/config_parser_base.cpp index decc9ed..54f5752 100644 --- a/brightness_manager/src/config_parser_base.cpp +++ b/brightness_manager/src/config_parser_base.cpp @@ -126,24 +126,19 @@ const std::string ConfigParserBase::LoadConfigPath(int displayId, const std::str return configPath; } -const cJSON* ConfigParserBase::LoadConfigRoot(int displayId, const std::string& configName) const +const std::string ConfigParserBase::LoadConfigRoot(int displayId, const std::string& configName) const { DISPLAY_HILOGI(FEAT_BRIGHTNESS, "[%{public}d] LoadConfigRoot [%{public}s]!", displayId, configName.c_str()); const std::string configPath = LoadConfigPath(displayId, configName); std::ifstream fileStream(configPath, std::ios::in | std::ios::binary); if (!fileStream) { DISPLAY_HILOGE(FEAT_BRIGHTNESS, "Open file %{public}s failure.", configName.c_str()); - return nullptr; + return std::string(""); } std::string fileContent((std::istreambuf_iterator(fileStream)), std::istreambuf_iterator()); fileStream.close(); - cJSON* root = cJSON_Parse(fileContent.c_str()); - if (!root) { - DISPLAY_HILOGE(FEAT_BRIGHTNESS, "Parse file %{public}s failure.", configName.c_str()); - return nullptr; - } - return root; + return fileContent; } void ConfigParserBase::ParsePointXy( @@ -151,14 +146,14 @@ void ConfigParserBase::ParsePointXy( { data.clear(); const cJSON* array = cJSON_GetObjectItemCaseSensitive(root, name.c_str()); - if (!array || !cJSON_IsArray(array)) { + if (!DisplayJsonUtils::IsValidJsonArray(array)) { DISPLAY_HILOGW(FEAT_BRIGHTNESS, "root <%{public}s> is not found or is not an array!", name.c_str()); return; } cJSON* item = nullptr; cJSON_ArrayForEach(item, array) { - if (!cJSON_IsArray(item)) { + if (!DisplayJsonUtils::IsValidJsonArray(item)) { DISPLAY_HILOGW(FEAT_BRIGHTNESS, "array <%{public}s> element is not an array!", name.c_str()); return; } @@ -171,14 +166,14 @@ void ConfigParserBase::ParsePointXy( } const cJSON* xNode = cJSON_GetArrayItem(item, POINT_X_INDEX); - if (xNode && cJSON_IsNumber(xNode)) { + if (DisplayJsonUtils::IsValidJsonNumber(xNode)) { pointXy.x = static_cast(xNode->valuedouble); } else { DISPLAY_HILOGW(FEAT_BRIGHTNESS, "parse [%{public}s] error!", name.c_str()); } const cJSON* yNode = cJSON_GetArrayItem(item, POINT_Y_INDEX); - if (yNode && cJSON_IsNumber(yNode)) { + if (DisplayJsonUtils::IsValidJsonNumber(yNode)) { pointXy.y = static_cast(yNode->valuedouble); } else { DISPLAY_HILOGW(FEAT_BRIGHTNESS, "parse [%{public}s] error!", name.c_str()); @@ -205,7 +200,7 @@ void ConfigParserBase::ParseScreenData(const cJSON* root, const std::string& nam { data.clear(); const cJSON* array = cJSON_GetObjectItemCaseSensitive(root, name.c_str()); - if (!array || !cJSON_IsArray(array)) { + if (!DisplayJsonUtils::IsValidJsonArray(array)) { DISPLAY_HILOGW(FEAT_BRIGHTNESS, "root <%{public}s> is not found or is not an array!", name.c_str()); return; } @@ -218,17 +213,17 @@ void ConfigParserBase::ParseScreenData(const cJSON* root, const std::string& nam ScreenData screenData{}; int displayMode = 0; const cJSON* displayModeNode = cJSON_GetObjectItemCaseSensitive(item, paramName.c_str()); - if (displayModeNode && cJSON_IsNumber(displayModeNode)) { + if (DisplayJsonUtils::IsValidJsonNumber(displayModeNode)) { displayMode = displayModeNode->valueint; } const cJSON* displayIdNode = cJSON_GetObjectItemCaseSensitive(item, "displayId"); - if (displayIdNode && cJSON_IsNumber(displayIdNode)) { + if (DisplayJsonUtils::IsValidJsonNumber(displayIdNode)) { screenData.displayId = displayIdNode->valueint; } const cJSON* sensorIdNode = cJSON_GetObjectItemCaseSensitive(item, "sensorId"); - if (sensorIdNode && cJSON_IsNumber(sensorIdNode)) { + if (DisplayJsonUtils::IsValidJsonNumber(sensorIdNode)) { screenData.sensorId = sensorIdNode->valueint; } diff --git a/brightness_manager/src/lux_filter_config_parser.cpp b/brightness_manager/src/lux_filter_config_parser.cpp index 522e3aa..9c32379 100644 --- a/brightness_manager/src/lux_filter_config_parser.cpp +++ b/brightness_manager/src/lux_filter_config_parser.cpp @@ -39,31 +39,30 @@ void LuxFilterConfigParser::LuxFilterParseConfigParams( LuxFilterConfig::Data config{}; std::string name; const cJSON* filterNameNode = cJSON_GetObjectItemCaseSensitive(item, "filterName"); - if (filterNameNode && cJSON_IsString(filterNameNode) && filterNameNode->valuestring && - strlen(filterNameNode->valuestring) > 0) { + if (DisplayJsonUtils::IsValidJsonStringAndNoEmpty(filterNameNode)) { name = filterNameNode->valuestring; } else { DISPLAY_HILOGW(FEAT_BRIGHTNESS, "<%{public}s> filterName is not found!", CONFIG_NAME.c_str()); return; } const cJSON* filterNoFilterNumNode = cJSON_GetObjectItemCaseSensitive(item, "filterNoFilterNum"); - if (filterNoFilterNumNode && cJSON_IsNumber(filterNoFilterNumNode)) { + if (DisplayJsonUtils::IsValidJsonNumber(filterNoFilterNumNode)) { config.filterNoFilterNum = filterNoFilterNumNode->valueint; } const cJSON* filterNumNode = cJSON_GetObjectItemCaseSensitive(item, "filterNum"); - if (filterNumNode && cJSON_IsNumber(filterNumNode)) { + if (DisplayJsonUtils::IsValidJsonNumber(filterNumNode)) { config.filterNum = filterNumNode->valueint; } const cJSON* filterMaxFuncLuxNumNode = cJSON_GetObjectItemCaseSensitive(item, "filterMaxFuncLuxNum"); - if (filterMaxFuncLuxNumNode && cJSON_IsNumber(filterMaxFuncLuxNumNode)) { + if (DisplayJsonUtils::IsValidJsonNumber(filterMaxFuncLuxNumNode)) { config.filterMaxFuncLuxNum = filterMaxFuncLuxNumNode->valueint; } const cJSON* filterAlphaNode = cJSON_GetObjectItemCaseSensitive(item, "filterAlpha"); - if (filterAlphaNode && cJSON_IsNumber(filterAlphaNode)) { + if (DisplayJsonUtils::IsValidJsonNumber(filterAlphaNode)) { config.filterAlpha = static_cast(filterAlphaNode->valuedouble); } const cJSON* filterLuxThNode = cJSON_GetObjectItemCaseSensitive(item, "filterLuxTh"); - if (filterLuxThNode && cJSON_IsNumber(filterLuxThNode)) { + if (DisplayJsonUtils::IsValidJsonNumber(filterLuxThNode)) { config.filterLuxTh = filterLuxThNode->valueint; } data.insert(std::make_pair(name, config)); @@ -74,9 +73,23 @@ bool LuxFilterConfigParser::ParseConfig( int displayId, std::unordered_map& data) { DISPLAY_HILOGI(FEAT_BRIGHTNESS, "[%{public}d] parse LuxFilterConfig start!", displayId); - const cJSON* root = ConfigParserBase::Get().LoadConfigRoot(displayId, CONFIG_NAME); + const std::string fileContent = ConfigParserBase::Get().LoadConfigRoot(displayId, CONFIG_NAME); + if (!ParseConfigJsonRoot(fileContent, data)) { + DISPLAY_HILOGI(FEAT_BRIGHTNESS, "[%{public}d] parse LuxFilterConfig error!", displayId); + return false; + } + + DISPLAY_HILOGI(FEAT_BRIGHTNESS, "[%{public}d] parse LuxFilterConfig over!", displayId); + return true; +} + +bool LuxFilterConfigParser::ParseConfigJsonRoot( + const std::string& fileContent, std::unordered_map& data) +{ + const cJSON* root = cJSON_Parse(fileContent.c_str()); if (!root) { SetDefault(data); + DISPLAY_HILOGE(FEAT_BRIGHTNESS, "Parse file %{public}s failure.", fileContent.c_str()); return false; } if (!cJSON_IsArray(root)) { @@ -93,7 +106,6 @@ bool LuxFilterConfigParser::ParseConfig( LuxFilterParseConfigParams(item, data); } cJSON_Delete(const_cast(root)); - DISPLAY_HILOGI(FEAT_BRIGHTNESS, "[%{public}d] parse LuxFilterConfig over!", displayId); return true; } diff --git a/brightness_manager/src/lux_threshold_config_parser.cpp b/brightness_manager/src/lux_threshold_config_parser.cpp index 3eb3264..6b457d7 100644 --- a/brightness_manager/src/lux_threshold_config_parser.cpp +++ b/brightness_manager/src/lux_threshold_config_parser.cpp @@ -72,8 +72,7 @@ void LuxThresholdConfigParser::LuxThresholdParseConfigParams(cJSON* item, LuxThr std::string name; const cJSON* modeNameNode = cJSON_GetObjectItemCaseSensitive(item, "modeName"); - if (modeNameNode && cJSON_IsString(modeNameNode) && modeNameNode->valuestring && - strlen(modeNameNode->valuestring) > 0) { + if (DisplayJsonUtils::IsValidJsonStringAndNoEmpty(modeNameNode)) { name = modeNameNode->valuestring; } else { DISPLAY_HILOGW(FEAT_BRIGHTNESS, "<%{public}s> modeName is not found!", CONFIG_NAME.c_str()); @@ -81,12 +80,12 @@ void LuxThresholdConfigParser::LuxThresholdParseConfigParams(cJSON* item, LuxThr } const cJSON* brightenDebounceTimeNode = cJSON_GetObjectItemCaseSensitive(item, "brightenDebounceTime"); - if (brightenDebounceTimeNode && cJSON_IsNumber(brightenDebounceTimeNode)) { + if (DisplayJsonUtils::IsValidJsonNumber(brightenDebounceTimeNode)) { config.brightenDebounceTime = brightenDebounceTimeNode->valueint; } const cJSON* darkenDebounceTimeNode = cJSON_GetObjectItemCaseSensitive(item, "darkenDebounceTime"); - if (darkenDebounceTimeNode && cJSON_IsNumber(darkenDebounceTimeNode)) { + if (DisplayJsonUtils::IsValidJsonNumber(darkenDebounceTimeNode)) { config.darkenDebounceTime = darkenDebounceTimeNode->valueint; } @@ -100,9 +99,22 @@ void LuxThresholdConfigParser::LuxThresholdParseConfigParams(cJSON* item, LuxThr bool LuxThresholdConfigParser::ParseConfig(int displayId, LuxThresholdConfig::Data& data) { DISPLAY_HILOGI(FEAT_BRIGHTNESS, "[%{public}d] parse LuxThresholdConfigParser start!", displayId); - const cJSON* root = ConfigParserBase::Get().LoadConfigRoot(displayId, CONFIG_NAME); + const std::string fileContent = ConfigParserBase::Get().LoadConfigRoot(displayId, CONFIG_NAME); + if (!ParseConfigJsonRoot(fileContent, data)) { + DISPLAY_HILOGI(FEAT_BRIGHTNESS, "[%{public}d] parse LuxThresholdConfigParser error!", displayId); + return false; + } + + DISPLAY_HILOGI(FEAT_BRIGHTNESS, "[%{public}d] parse LuxThresholdConfigParser over!", displayId); + return true; +} + +bool LuxThresholdConfigParser::ParseConfigJsonRoot(const std::string& fileContent, LuxThresholdConfig::Data& data) +{ + const cJSON* root = cJSON_Parse(fileContent.c_str()); if (!root) { SetDefault(data); + DISPLAY_HILOGE(FEAT_BRIGHTNESS, "Parse file %{public}s failure.", fileContent.c_str()); return false; } if (!cJSON_IsObject(root)) { @@ -111,7 +123,7 @@ bool LuxThresholdConfigParser::ParseConfig(int displayId, LuxThresholdConfig::Da return false; } const cJSON* isLevelEnableNode = cJSON_GetObjectItemCaseSensitive(root, "isLevelEnable"); - if (isLevelEnableNode && cJSON_IsBool(isLevelEnableNode)) { + if (DisplayJsonUtils::IsValidJsonBool(isLevelEnableNode)) { data.isLevelEnable = cJSON_IsTrue(isLevelEnableNode); } @@ -121,7 +133,7 @@ bool LuxThresholdConfigParser::ParseConfig(int displayId, LuxThresholdConfig::Da root, "darkenPointsForLevel", data.darkenPointsForLevel); const cJSON* thresholdModeArray = cJSON_GetObjectItemCaseSensitive(root, "thresholdMode"); - if (!thresholdModeArray || !cJSON_IsArray(thresholdModeArray)) { + if (!DisplayJsonUtils::IsValidJsonArray(thresholdModeArray)) { DISPLAY_HILOGW(FEAT_BRIGHTNESS, "root <%{public}s> is not Array!", CONFIG_NAME.c_str()); cJSON_Delete(const_cast(root)); return false; @@ -134,9 +146,7 @@ bool LuxThresholdConfigParser::ParseConfig(int displayId, LuxThresholdConfig::Da } LuxThresholdParseConfigParams(item, data); } - cJSON_Delete(const_cast(root)); - DISPLAY_HILOGI(FEAT_BRIGHTNESS, "[%{public}d] parse LuxThresholdConfigParser over!", displayId); return true; } diff --git a/brightness_manager/test/unittest/BUILD.gn b/brightness_manager/test/unittest/BUILD.gn index 057c7fe..52cbe9d 100644 --- a/brightness_manager/test/unittest/BUILD.gn +++ b/brightness_manager/test/unittest/BUILD.gn @@ -84,6 +84,12 @@ ohos_unittest("brightness_service_test") { } ohos_unittest("brightness_config_parse_test") { + sanitize = { + cfi = true + cfi_cross_dso = true + debug = false + } + branch_protector_ret = "pac_ret" sources = [ "./src/brightness_config_parse_test.cpp" ] cflags = [ "-Dprivate=public", diff --git a/brightness_manager/test/unittest/src/brightness_config_parse_test.cpp b/brightness_manager/test/unittest/src/brightness_config_parse_test.cpp index 8f33283..b08f937 100644 --- a/brightness_manager/test/unittest/src/brightness_config_parse_test.cpp +++ b/brightness_manager/test/unittest/src/brightness_config_parse_test.cpp @@ -59,6 +59,7 @@ constexpr float DEFAULT_VALUE_FLOAT = -1.0f; HWTEST_F(BrightnessConfigParseTest, BrightnessConfigParseTest001, TestSize.Level0) { DISPLAY_HILOGI(LABEL_TEST, "BrightnessConfigParseTest001 function start!"); + EXPECT_TRUE(root_); cJSON* array = cJSON_CreateArray(); cJSON* item1 = cJSON_CreateFloatArray((const float[]){POINT_1_X, POINT_1_Y}, NUMBER_TWO); cJSON* item2 = cJSON_CreateFloatArray((const float[]){POINT_2_X, POINT_2_Y}, NUMBER_TWO); @@ -81,6 +82,7 @@ HWTEST_F(BrightnessConfigParseTest, BrightnessConfigParseTest001, TestSize.Level HWTEST_F(BrightnessConfigParseTest, BrightnessConfigParseTest002, TestSize.Level0) { DISPLAY_HILOGI(LABEL_TEST, "BrightnessConfigParseTest002 function start!"); + EXPECT_TRUE(root_); cJSON* array = cJSON_CreateArray(); cJSON* item = cJSON_CreateFloatArray((const float[]){POINT_1_X}, NUMBER_ONE); cJSON_AddItemToArray(array, item); @@ -96,6 +98,7 @@ HWTEST_F(BrightnessConfigParseTest, BrightnessConfigParseTest002, TestSize.Level HWTEST_F(BrightnessConfigParseTest, BrightnessConfigParseTest003, TestSize.Level0) { DISPLAY_HILOGI(LABEL_TEST, "BrightnessConfigParseTest003 function start!"); + EXPECT_TRUE(root_); std::vector data; ConfigParserBase parser; parser.ParsePointXy(root_, "points", data); @@ -106,6 +109,7 @@ HWTEST_F(BrightnessConfigParseTest, BrightnessConfigParseTest003, TestSize.Level HWTEST_F(BrightnessConfigParseTest, BrightnessConfigParseTest004, TestSize.Level0) { DISPLAY_HILOGI(LABEL_TEST, "BrightnessConfigParseTest004 function start!"); + EXPECT_TRUE(root_); cJSON* array = cJSON_CreateArray(); cJSON_AddItemToObject(root_, "points", array); std::vector data; @@ -118,6 +122,7 @@ HWTEST_F(BrightnessConfigParseTest, BrightnessConfigParseTest004, TestSize.Level HWTEST_F(BrightnessConfigParseTest, BrightnessConfigParseTest005, TestSize.Level0) { DISPLAY_HILOGI(LABEL_TEST, "BrightnessConfigParseTest005 function start!"); + EXPECT_TRUE(root_); cJSON_AddItemToObject(root_, "points", cJSON_CreateString("not an array")); std::vector data; ConfigParserBase parser; @@ -129,6 +134,7 @@ HWTEST_F(BrightnessConfigParseTest, BrightnessConfigParseTest005, TestSize.Level HWTEST_F(BrightnessConfigParseTest, BrightnessConfigParseTest006, TestSize.Level0) { DISPLAY_HILOGI(LABEL_TEST, "BrightnessConfigParseTest006 function start!"); + EXPECT_TRUE(root_); cJSON* array = cJSON_CreateArray(); cJSON_AddItemToArray(array, cJSON_CreateString("not array")); cJSON_AddItemToObject(root_, "points", array); @@ -143,6 +149,7 @@ HWTEST_F(BrightnessConfigParseTest, BrightnessConfigParseTest006, TestSize.Level HWTEST_F(BrightnessConfigParseTest, BrightnessConfigParseTest007, TestSize.Level0) { DISPLAY_HILOGI(LABEL_TEST, "BrightnessConfigParseTest007 function start!"); + EXPECT_TRUE(root_); cJSON* array = cJSON_CreateArray(); cJSON* item1 = cJSON_CreateObject(); @@ -174,6 +181,7 @@ HWTEST_F(BrightnessConfigParseTest, BrightnessConfigParseTest007, TestSize.Level HWTEST_F(BrightnessConfigParseTest, BrightnessConfigParseTest008, TestSize.Level0) { DISPLAY_HILOGI(LABEL_TEST, "BrightnessConfigParseTest008 function start!"); + EXPECT_TRUE(root_); std::unordered_map data; ConfigParserBase parser; parser.ParseScreenData(root_, "displayModeData", data, "displayMode"); @@ -184,6 +192,7 @@ HWTEST_F(BrightnessConfigParseTest, BrightnessConfigParseTest008, TestSize.Level HWTEST_F(BrightnessConfigParseTest, BrightnessConfigParseTest009, TestSize.Level0) { DISPLAY_HILOGI(LABEL_TEST, "BrightnessConfigParseTest009 function start!"); + EXPECT_TRUE(root_); cJSON_AddItemToObject(root_, "displayModeData", cJSON_CreateString("not an array")); std::unordered_map data; ConfigParserBase parser; @@ -195,6 +204,7 @@ HWTEST_F(BrightnessConfigParseTest, BrightnessConfigParseTest009, TestSize.Level HWTEST_F(BrightnessConfigParseTest, BrightnessConfigParseTest010, TestSize.Level0) { DISPLAY_HILOGI(LABEL_TEST, "BrightnessConfigParseTest010 function start!"); + EXPECT_TRUE(root_); cJSON* array = cJSON_CreateArray(); cJSON_AddItemToArray(array, cJSON_CreateNumber(DISPLAY_ID_ONE)); cJSON_AddItemToObject(root_, "displayModeData", array); @@ -209,6 +219,7 @@ HWTEST_F(BrightnessConfigParseTest, BrightnessConfigParseTest010, TestSize.Level HWTEST_F(BrightnessConfigParseTest, BrightnessConfigParseTest011, TestSize.Level0) { DISPLAY_HILOGI(LABEL_TEST, "BrightnessConfigParseTest011 function start!"); + EXPECT_TRUE(root_); cJSON* array = cJSON_CreateArray(); cJSON* item = cJSON_CreateObject(); @@ -228,6 +239,7 @@ HWTEST_F(BrightnessConfigParseTest, BrightnessConfigParseTest011, TestSize.Level HWTEST_F(BrightnessConfigParseTest, BrightnessConfigParseTest012, TestSize.Level0) { DISPLAY_HILOGI(LABEL_TEST, "BrightnessConfigParseTest012 function start!"); + EXPECT_TRUE(root_); cJSON* array = cJSON_CreateArray(); cJSON* item = cJSON_CreateObject(); @@ -248,6 +260,7 @@ HWTEST_F(BrightnessConfigParseTest, BrightnessConfigParseTest012, TestSize.Level HWTEST_F(BrightnessConfigParseTest, BrightnessConfigParseTest013, TestSize.Level0) { DISPLAY_HILOGI(LABEL_TEST, "BrightnessConfigParseTest013 function start!"); + EXPECT_TRUE(root_); cJSON* array = cJSON_CreateArray(); cJSON_AddItemToObject(root_, "displayModeData", array); @@ -261,6 +274,7 @@ HWTEST_F(BrightnessConfigParseTest, BrightnessConfigParseTest013, TestSize.Level HWTEST_F(BrightnessConfigParseTest, BrightnessConfigParseTest014, TestSize.Level0) { DISPLAY_HILOGI(LABEL_TEST, "BrightnessConfigParseTest014 function start!"); + EXPECT_TRUE(root_); cJSON_AddItemToObject(root_, "filterName", cJSON_CreateString("default")); cJSON_AddItemToObject(root_, "filterNoFilterNum", cJSON_CreateNumber(NUMBER_ONE)); cJSON_AddItemToObject(root_, "filterNum", cJSON_CreateNumber(NUMBER_TWO)); @@ -285,6 +299,7 @@ HWTEST_F(BrightnessConfigParseTest, BrightnessConfigParseTest014, TestSize.Level HWTEST_F(BrightnessConfigParseTest, BrightnessConfigParseTest015, TestSize.Level0) { DISPLAY_HILOGI(LABEL_TEST, "BrightnessConfigParseTest015 function start!"); + EXPECT_TRUE(root_); cJSON_AddItemToObject(root_, "filterNum", cJSON_CreateNumber(NUMBER_ONE)); LuxFilterConfigParser parser; std::unordered_map data; @@ -296,6 +311,7 @@ HWTEST_F(BrightnessConfigParseTest, BrightnessConfigParseTest015, TestSize.Level HWTEST_F(BrightnessConfigParseTest, BrightnessConfigParseTest016, TestSize.Level0) { DISPLAY_HILOGI(LABEL_TEST, "BrightnessConfigParseTest016 function start!"); + EXPECT_TRUE(root_); cJSON_AddItemToObject(root_, "filterName", cJSON_CreateNumber(NUMBER_ONE)); LuxFilterConfigParser parser; std::unordered_map data; @@ -307,6 +323,7 @@ HWTEST_F(BrightnessConfigParseTest, BrightnessConfigParseTest016, TestSize.Level HWTEST_F(BrightnessConfigParseTest, BrightnessConfigParseTest017, TestSize.Level0) { DISPLAY_HILOGI(LABEL_TEST, "BrightnessConfigParseTest017 function start!"); + EXPECT_TRUE(root_); cJSON_AddItemToObject(root_, "filterName", cJSON_CreateString("")); LuxFilterConfigParser parser; std::unordered_map data; @@ -318,6 +335,7 @@ HWTEST_F(BrightnessConfigParseTest, BrightnessConfigParseTest017, TestSize.Level HWTEST_F(BrightnessConfigParseTest, BrightnessConfigParseTest018, TestSize.Level0) { DISPLAY_HILOGI(LABEL_TEST, "BrightnessConfigParseTest018 function start!"); + EXPECT_TRUE(root_); cJSON_AddItemToObject(root_, "filterName", cJSON_CreateString("default")); LuxFilterConfigParser parser; @@ -332,4 +350,276 @@ HWTEST_F(BrightnessConfigParseTest, BrightnessConfigParseTest018, TestSize.Level EXPECT_EQ(data["default"].filterLuxTh, DEFAULT_VALUE_NUMBER); DISPLAY_HILOGI(LABEL_TEST, "BrightnessConfigParseTest018 function end!"); } + +HWTEST_F(BrightnessConfigParseTest, BrightnessConfigParseTest019, TestSize.Level0) +{ + DISPLAY_HILOGI(LABEL_TEST, "BrightnessConfigParseTest019 function start!"); + EXPECT_TRUE(root_); + BrightnessConfig::Data data; + BrightnessConfigParser::ParseConfig(data); + EXPECT_FALSE(data.displayModeMap.empty()); + DISPLAY_HILOGI(LABEL_TEST, "BrightnessConfigParseTest019 function end!"); +} + +HWTEST_F(BrightnessConfigParseTest, BrightnessConfigParseTest020, TestSize.Level0) +{ + DISPLAY_HILOGI(LABEL_TEST, "BrightnessConfigParseTest020 function start!"); + EXPECT_TRUE(root_); + CalculationConfig::Data data; + CalculationConfigParser::ParseConfig(0, data); + EXPECT_FALSE(data.defaultPoints.empty()); + DISPLAY_HILOGI(LABEL_TEST, "BrightnessConfigParseTest020 function end!"); +} + +HWTEST_F(BrightnessConfigParseTest, BrightnessConfigParseTest022, TestSize.Level0) +{ + DISPLAY_HILOGI(LABEL_TEST, "BrightnessConfigParseTest022 function start!"); + EXPECT_TRUE(root_); + cJSON* array = cJSON_CreateArray(); + cJSON* item1 = cJSON_CreateArray(); + if (item1 != NULL) { + cJSON_AddItemToArray(item1, cJSON_CreateString("POINT_1_X")); + cJSON_AddItemToArray(item1, cJSON_CreateString("POINT_1_Y")); + } + cJSON_AddItemToArray(array, item1); + cJSON_AddItemToObject(root_, "points", array); + + std::vector data; + ConfigParserBase parser; + parser.LoadConfigRoot(0, "brightness_config"); + parser.ParsePointXy(root_, "points", data); + ASSERT_EQ(data.size(), NUMBER_ONE); + EXPECT_EQ(data[0].x, DEFAULT_VALUE_FLOAT); + EXPECT_EQ(data[0].y, DEFAULT_VALUE_FLOAT); + DISPLAY_HILOGI(LABEL_TEST, "BrightnessConfigParseTest022 function end!"); +} + +HWTEST_F(BrightnessConfigParseTest, BrightnessConfigParseTest023, TestSize.Level0) +{ + DISPLAY_HILOGI(LABEL_TEST, "BrightnessConfigParseTest023 function start!"); + EXPECT_TRUE(root_); + cJSON_AddItemToObject(root_, "modeName", cJSON_CreateNumber(NUMBER_ONE)); + + LuxThresholdConfigParser parser; + LuxThresholdConfig::Data data; + parser.LuxThresholdParseConfigParams(root_, data); + EXPECT_TRUE(data.modeArray.empty()); + DISPLAY_HILOGI(LABEL_TEST, "BrightnessConfigParseTest023 function end!"); +} + +HWTEST_F(BrightnessConfigParseTest, BrightnessConfigParseTest024, TestSize.Level0) +{ + DISPLAY_HILOGI(LABEL_TEST, "BrightnessConfigParseTest024 function start!"); + EXPECT_TRUE(root_); + cJSON_AddItemToObject(root_, "modeName", cJSON_CreateString("indoor")); + cJSON_AddItemToObject(root_, "brightenDebounceTime", cJSON_CreateNumber(NUMBER_ONE)); + cJSON_AddItemToObject(root_, "darkenDebounceTime", cJSON_CreateNumber(NUMBER_TWO)); + + LuxThresholdConfigParser parser; + LuxThresholdConfig::Data data; + parser.LuxThresholdParseConfigParams(root_, data); + ASSERT_EQ(data.modeArray.size(), NUMBER_ONE); + auto& mode = data.modeArray["indoor"]; + EXPECT_EQ(mode.brightenDebounceTime, NUMBER_ONE); + EXPECT_EQ(mode.darkenDebounceTime, NUMBER_TWO); + DISPLAY_HILOGI(LABEL_TEST, "BrightnessConfigParseTest024 function end!"); +} + +HWTEST_F(BrightnessConfigParseTest, BrightnessConfigParseTest025, TestSize.Level0) +{ + DISPLAY_HILOGI(LABEL_TEST, "BrightnessConfigParseTest025 function start!"); + EXPECT_TRUE(root_); + cJSON_AddItemToObject(root_, "brightenDebounceTime", cJSON_CreateNumber(NUMBER_ONE)); + + LuxThresholdConfigParser parser; + LuxThresholdConfig::Data data; + parser.LuxThresholdParseConfigParams(root_, data); + EXPECT_TRUE(data.modeArray.empty()); + DISPLAY_HILOGI(LABEL_TEST, "BrightnessConfigParseTest025 function end!"); +} + +HWTEST_F(BrightnessConfigParseTest, BrightnessConfigParseTest027, TestSize.Level0) +{ + DISPLAY_HILOGI(LABEL_TEST, "BrightnessConfigParseTest027 function start!"); + EXPECT_TRUE(root_); + BrightnessConfig::Data data; + bool ret = BrightnessConfigParser::ParseConfigJsonRoot("", data); + EXPECT_FALSE(ret); + DISPLAY_HILOGI(LABEL_TEST, "BrightnessConfigParseTest027 function end!"); +} + +HWTEST_F(BrightnessConfigParseTest, BrightnessConfigParseTest028, TestSize.Level0) +{ + DISPLAY_HILOGI(LABEL_TEST, "BrightnessConfigParseTest028 function start!"); + EXPECT_TRUE(root_); + BrightnessConfig::Data data; + bool ret = BrightnessConfigParser::ParseConfigJsonRoot("[]", data); + EXPECT_FALSE(ret); + DISPLAY_HILOGI(LABEL_TEST, "BrightnessConfigParseTest028 function end!"); +} + +HWTEST_F(BrightnessConfigParseTest, BrightnessConfigParseTest029, TestSize.Level0) +{ + DISPLAY_HILOGI(LABEL_TEST, "BrightnessConfigParseTest029 function start!"); + EXPECT_TRUE(root_); + BrightnessConfig::Data data; + const std::string json = R"({"lid": {"action": 1, "delayMs": 2}})"; + bool ret = BrightnessConfigParser::ParseConfigJsonRoot(json, data); + EXPECT_TRUE(ret); + DISPLAY_HILOGI(LABEL_TEST, "BrightnessConfigParseTest029 function end!"); +} + +HWTEST_F(BrightnessConfigParseTest, BrightnessConfigParseTest030, TestSize.Level0) +{ + DISPLAY_HILOGI(LABEL_TEST, "BrightnessConfigParseTest030 function start!"); + EXPECT_TRUE(root_); + CalculationConfig::Data data; + bool ret = CalculationConfigParser::ParseConfigJsonRoot(0, "", data); + EXPECT_FALSE(ret); + DISPLAY_HILOGI(LABEL_TEST, "BrightnessConfigParseTest030 function end!"); +} + +HWTEST_F(BrightnessConfigParseTest, BrightnessConfigParseTest031, TestSize.Level0) +{ + DISPLAY_HILOGI(LABEL_TEST, "BrightnessConfigParseTest031 function start!"); + EXPECT_TRUE(root_); + CalculationConfig::Data data; + bool ret = CalculationConfigParser::ParseConfigJsonRoot(0, "[]", data); + EXPECT_FALSE(ret); + DISPLAY_HILOGI(LABEL_TEST, "BrightnessConfigParseTest031 function end!"); +} + +HWTEST_F(BrightnessConfigParseTest, BrightnessConfigParseTest032, TestSize.Level0) +{ + DISPLAY_HILOGI(LABEL_TEST, "BrightnessConfigParseTest032 function start!"); + EXPECT_TRUE(root_); + CalculationConfig::Data data; + const std::string json = R"({"defaultBrightness": 2})"; + bool ret = CalculationConfigParser::ParseConfigJsonRoot(0, json, data); + EXPECT_TRUE(ret); + DISPLAY_HILOGI(LABEL_TEST, "BrightnessConfigParseTest032 function end!"); +} + +HWTEST_F(BrightnessConfigParseTest, BrightnessConfigParseTest033, TestSize.Level0) +{ + DISPLAY_HILOGI(LABEL_TEST, "BrightnessConfigParseTest033 function start!"); + EXPECT_TRUE(root_); + std::unordered_map data; + LuxFilterConfigParser::ParseConfig(0, data); + bool ret = LuxFilterConfigParser::ParseConfigJsonRoot("", data); + EXPECT_FALSE(ret); + DISPLAY_HILOGI(LABEL_TEST, "BrightnessConfigParseTest033 function end!"); +} + +HWTEST_F(BrightnessConfigParseTest, BrightnessConfigParseTest034, TestSize.Level0) +{ + DISPLAY_HILOGI(LABEL_TEST, "BrightnessConfigParseTest034 function start!"); + EXPECT_TRUE(root_); + std::unordered_map data; + const std::string json = R"({"test": 2})"; + bool ret = LuxFilterConfigParser::ParseConfigJsonRoot(json, data); + EXPECT_FALSE(ret); + DISPLAY_HILOGI(LABEL_TEST, "BrightnessConfigParseTest034 function end!"); +} + +HWTEST_F(BrightnessConfigParseTest, BrightnessConfigParseTest035, TestSize.Level0) +{ + DISPLAY_HILOGI(LABEL_TEST, "BrightnessConfigParseTest035 function start!"); + EXPECT_TRUE(root_); + std::unordered_map data; + const std::string json = R"([{"name":"A", "value":123}, []])"; + bool ret = LuxFilterConfigParser::ParseConfigJsonRoot(json, data); + EXPECT_TRUE(ret); + DISPLAY_HILOGI(LABEL_TEST, "BrightnessConfigParseTest035 function end!"); +} + +HWTEST_F(BrightnessConfigParseTest, BrightnessConfigParseTest036, TestSize.Level0) +{ + DISPLAY_HILOGI(LABEL_TEST, "BrightnessConfigParseTest036 function start!"); + EXPECT_TRUE(root_); + std::unordered_map data; + std::string json = R"([{"name":"A", "value":123}, {"name":"B", "value":456}])"; + bool ret = LuxFilterConfigParser::ParseConfigJsonRoot(json, data); + EXPECT_TRUE(ret); + DISPLAY_HILOGI(LABEL_TEST, "BrightnessConfigParseTest036 function end!"); +} + +HWTEST_F(BrightnessConfigParseTest, BrightnessConfigParseTest038, TestSize.Level0) +{ + DISPLAY_HILOGI(LABEL_TEST, "BrightnessConfigParseTest038 function start!"); + EXPECT_TRUE(root_); + LuxThresholdConfig::Data data; + LuxThresholdConfigParser::ParseConfig(0, data); + bool ret = LuxThresholdConfigParser::ParseConfigJsonRoot("", data); + EXPECT_FALSE(ret); + DISPLAY_HILOGI(LABEL_TEST, "BrightnessConfigParseTest038 function end!"); +} + +HWTEST_F(BrightnessConfigParseTest, BrightnessConfigParseTest039, TestSize.Level0) +{ + DISPLAY_HILOGI(LABEL_TEST, "BrightnessConfigParseTest039 function start!"); + EXPECT_TRUE(root_); + LuxThresholdConfig::Data data; + bool ret = LuxThresholdConfigParser::ParseConfigJsonRoot("[]", data); + EXPECT_FALSE(ret); + DISPLAY_HILOGI(LABEL_TEST, "BrightnessConfigParseTest039 function end!"); +} + +HWTEST_F(BrightnessConfigParseTest, BrightnessConfigParseTest040, TestSize.Level0) +{ + DISPLAY_HILOGI(LABEL_TEST, "BrightnessConfigParseTest040 function start!"); + EXPECT_TRUE(root_); + LuxThresholdConfig::Data data; + const std::string json = R"({"isLevelEnable": "11", "thresholdMode": "12"})"; + bool ret = LuxThresholdConfigParser::ParseConfigJsonRoot(json, data); + EXPECT_FALSE(ret); + DISPLAY_HILOGI(LABEL_TEST, "BrightnessConfigParseTest040 function end!"); +} + +HWTEST_F(BrightnessConfigParseTest, BrightnessConfigParseTest041, TestSize.Level0) +{ + DISPLAY_HILOGI(LABEL_TEST, "BrightnessConfigParseTest041 function start!"); + EXPECT_TRUE(root_); + LuxThresholdConfig::Data data; + std::string json = R"({"isLevelEnable": true, "thresholdMode": [{"name":"A", "value":123}, + {"name":"B", "value":456}]})"; + bool ret = LuxThresholdConfigParser::ParseConfigJsonRoot(json, data); + EXPECT_TRUE(ret); + DISPLAY_HILOGI(LABEL_TEST, "BrightnessConfigParseTest041 function end!"); +} + +HWTEST_F(BrightnessConfigParseTest, BrightnessConfigParseTest042, TestSize.Level0) +{ + DISPLAY_HILOGI(LABEL_TEST, "BrightnessConfigParseTest042 function start!"); + EXPECT_TRUE(root_); + LuxThresholdConfig::Data data; + std::string json = R"({"isLevelEnable": true, "thresholdMode": [{"name":"A", "value":123}, []]})"; + bool ret = LuxThresholdConfigParser::ParseConfigJsonRoot(json, data); + EXPECT_TRUE(ret); + DISPLAY_HILOGI(LABEL_TEST, "BrightnessConfigParseTest042 function end!"); +} + +HWTEST_F(BrightnessConfigParseTest, BrightnessConfigParseTest043, TestSize.Level0) +{ + DISPLAY_HILOGI(LABEL_TEST, "BrightnessConfigParseTest043 function start!"); + EXPECT_TRUE(root_); + cJSON_AddItemToObject(root_, "modeName", cJSON_CreateString("indoor")); + + LuxThresholdConfigParser parser; + LuxThresholdConfig::Data data; + parser.LuxThresholdParseConfigParams(root_, data); + ASSERT_EQ(data.modeArray.size(), NUMBER_ONE); + DISPLAY_HILOGI(LABEL_TEST, "BrightnessConfigParseTest043 function end!"); +} + +HWTEST_F(BrightnessConfigParseTest, BrightnessConfigParseTest044, TestSize.Level0) +{ + DISPLAY_HILOGI(LABEL_TEST, "BrightnessConfigParseTest044 function start!"); + EXPECT_TRUE(root_); + CalculationConfig::Data data; + const std::string json = R"({"test": 2})"; + bool ret = CalculationConfigParser::ParseConfigJsonRoot(0, json, data); + EXPECT_TRUE(ret); + DISPLAY_HILOGI(LABEL_TEST, "BrightnessConfigParseTest044 function end!"); +} } // namespace diff --git a/state_manager/service/native/src/screen_controller.cpp b/state_manager/service/native/src/screen_controller.cpp index 6b62c1c..a048fcd 100644 --- a/state_manager/service/native/src/screen_controller.cpp +++ b/state_manager/service/native/src/screen_controller.cpp @@ -83,14 +83,14 @@ DisplayState ScreenController::GetState() DisplayState ScreenController::SetDelayOffState() { - DISPLAY_HILOGI(COMP_SVC, "Set the dispaly state is DELAY OFF when overriding display off delay"); + DISPLAY_HILOGI(COMP_SVC, "Set the display state is DELAY OFF when overriding display off delay"); state_ = DisplayState::DISPLAY_DELAY_OFF; return state_; } DisplayState ScreenController::SetOnState() { - DISPLAY_HILOGI(COMP_SVC, "Set the dispaly state is ON after overriding display on delay"); + DISPLAY_HILOGI(COMP_SVC, "Set the display state is ON after overriding display on delay"); state_ = DisplayState::DISPLAY_ON; return state_; } diff --git a/state_manager/utils/native/include/display_cjson_utils.h b/state_manager/utils/native/include/display_cjson_utils.h new file mode 100644 index 0000000..4cd2350 --- /dev/null +++ b/state_manager/utils/native/include/display_cjson_utils.h @@ -0,0 +1,58 @@ +/* + * Copyright (c) 2025 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef DISPLAY_CJSON_UTILS_H +#define DISPLAY_CJSON_UTILS_H + +#include +#include + +namespace OHOS { +namespace DisplayPowerMgr { +namespace DisplayJsonUtils { +inline bool IsValidJsonObject(const cJSON* jsonValue) +{ + return jsonValue && cJSON_IsObject(jsonValue); +} + +inline bool IsValidJsonString(const cJSON* jsonValue) +{ + return jsonValue && cJSON_IsString(jsonValue) && jsonValue->valuestring != nullptr; +} + +inline bool IsValidJsonStringAndNoEmpty(const cJSON* jsonValue) +{ + return jsonValue && cJSON_IsString(jsonValue) && jsonValue->valuestring != nullptr && + strlen(jsonValue->valuestring) > 0; +} + +inline bool IsValidJsonNumber(const cJSON* jsonValue) +{ + return jsonValue && cJSON_IsNumber(jsonValue); +} + +inline bool IsValidJsonArray(const cJSON* jsonValue) +{ + return jsonValue && cJSON_IsArray(jsonValue); +} + +inline bool IsValidJsonBool(const cJSON* jsonValue) +{ + return jsonValue && cJSON_IsBool(jsonValue); +} +} // namespace DisplayJsonUtils +} // namespace DisplayPowerMgr +} // namespace OHOS +#endif // DISPLAY_CJSON_UTILS_H -- Gitee