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 16 #include "gtest/gtest.h" 17 #define private public 18 #define protected public 19 #include "adapter/ohos/capability/feature_config/config_xml_parser_base.h" 20 #include "adapter/ohos/capability/feature_config/feature_param_manager.h" 21 #undef private 22 #undef protected 23 using namespace testing; 24 using namespace testing::ext; 25 26 namespace OHOS::Ace { 27 class ArkUIFeatureParamManagerTest : public testing::Test { 28 public: SetUpTestCase()29 static void SetUpTestCase() {}; TearDownTestCase()30 static void TearDownTestCase() {}; SetUp()31 void SetUp() {}; TearDown()32 void TearDown() {}; 33 34 const std::string PERF_CONFIG = "PerformanceOptConfig"; 35 const std::string BUNDLE_NAME = "bundleName"; 36 const std::string FEATURE = "feature"; 37 const std::string NAME = "name"; 38 const std::string ID = "id"; 39 const std::string TEST1_HAP = "test1.hap"; 40 const std::string TEST2_HAP = "test2.hap"; 41 const std::string UI_NODE_GC_NAME = "UINodeGcParamParser"; 42 const std::string SYNC_LOAD_NAME = "SyncLoadParser"; 43 const std::string SYNC_LOAD_VALUE = "value"; 44 const std::string SYNC_LOAD_VALUE_TIME = "50"; 45 const std::string TEST_UNDEFINE = "Undefine"; 46 }; 47 48 /** 49 * @tc.name: InitTest001 50 * @tc.desc: ArkUIFeatureParamManagerTest::Init 51 * @tc.type: FUNC 52 */ 53 HWTEST_F(ArkUIFeatureParamManagerTest, InitTest, TestSize.Level1) 54 { 55 FeatureParamManager::GetInstance().Init(TEST1_HAP); 56 auto& featureParser = FeatureParamManager::GetInstance().featureParser_; 57 EXPECT_NE(featureParser, nullptr); 58 59 FeatureParamManager::GetInstance().Init(TEST1_HAP); 60 EXPECT_NE(featureParser, nullptr); 61 } 62 63 /** 64 * @tc.name: ParseInternalWithBundleNameTest 65 * @tc.desc: FeatureParamManager test 66 * @tc.type: FUNC 67 */ 68 HWTEST_F(ArkUIFeatureParamManagerTest, ParseInternalWithBundleNameTest, TestSize.Level1) 69 { 70 FeatureParamManager::GetInstance().Init(TEST1_HAP); 71 auto& featureParser = FeatureParamManager::GetInstance().featureParser_; 72 73 xmlNode featureNode1 = { 74 .type = xmlElementType::XML_ELEMENT_NODE, 75 .name = reinterpret_cast<const xmlChar*>(FEATURE.c_str()), 76 }; 77 xmlSetProp(&featureNode1, (const xmlChar*)(ID.c_str()), (const xmlChar*)(UI_NODE_GC_NAME.c_str())); 78 79 xmlNode featureNode2 = { 80 .type = xmlElementType::XML_ELEMENT_NODE, 81 .name = reinterpret_cast<const xmlChar*>(FEATURE.c_str()), 82 }; 83 xmlSetProp(&featureNode2, (const xmlChar*)(ID.c_str()), (const xmlChar*)(SYNC_LOAD_NAME.c_str())); 84 85 xmlNode featureNode3 = { 86 .type = xmlElementType::XML_ELEMENT_NODE, 87 .name = reinterpret_cast<const xmlChar*>(TEST_UNDEFINE.c_str()), 88 }; 89 xmlSetProp(&featureNode3, (const xmlChar*)(ID.c_str()), (const xmlChar*)(TEST_UNDEFINE.c_str())); 90 91 xmlNode bundleNameNode { 92 .type = xmlElementType::XML_ELEMENT_NODE, 93 .name = reinterpret_cast<const xmlChar*>(BUNDLE_NAME.c_str()), 94 }; 95 96 xmlSetProp(&bundleNameNode, (const xmlChar*)(NAME.c_str()), (const xmlChar*)(TEST1_HAP.c_str())); 97 xmlNode configNode = { 98 .name = reinterpret_cast<const xmlChar*>(PERF_CONFIG.c_str()), 99 }; 100 101 xmlNode rootNode; 102 auto ret = featureParser->ParseInternalWithBundleName(rootNode, TEST1_HAP); 103 EXPECT_EQ(ret, ParseErrCode::PARSE_GET_CHILD_FAIL); 104 105 rootNode.children = &configNode; 106 ret = featureParser->ParseInternalWithBundleName(rootNode, TEST1_HAP); 107 EXPECT_EQ(ret, ParseErrCode::PARSE_GET_CHILD_FAIL); 108 109 configNode.children = &bundleNameNode; 110 ret = featureParser->ParseInternalWithBundleName(rootNode, TEST1_HAP); 111 EXPECT_EQ(ret, ParseErrCode::PARSE_EXEC_SUCCESS); 112 113 bundleNameNode.children = &featureNode1; 114 ret = featureParser->ParseInternalWithBundleName(rootNode, TEST1_HAP); 115 EXPECT_EQ(ret, ParseErrCode::PARSE_EXEC_SUCCESS); 116 117 featureNode1.next = &featureNode2; 118 ret = featureParser->ParseInternalWithBundleName(rootNode, TEST1_HAP); 119 EXPECT_EQ(ret, ParseErrCode::PARSE_EXEC_SUCCESS); 120 121 xmlSetProp(&featureNode2, (const xmlChar*)(SYNC_LOAD_VALUE.c_str()), 122 (const xmlChar*)(SYNC_LOAD_VALUE_TIME.c_str())); 123 ret = featureParser->ParseInternalWithBundleName(rootNode, TEST1_HAP); 124 EXPECT_EQ(ret, ParseErrCode::PARSE_EXEC_SUCCESS); 125 126 featureNode2.next = &featureNode3; 127 ret = featureParser->ParseInternalWithBundleName(rootNode, TEST1_HAP); 128 EXPECT_EQ(ret, ParseErrCode::PARSE_EXEC_SUCCESS); 129 130 bundleNameNode.name = reinterpret_cast<const xmlChar*>(TEST_UNDEFINE.c_str()); 131 ret = featureParser->ParseInternalWithBundleName(rootNode, TEST1_HAP); 132 EXPECT_EQ(ret, ParseErrCode::PARSE_EXEC_SUCCESS); 133 134 featureParser->Destroy(); 135 } 136 137 /** 138 * @tc.name: ParsePerformanceConfigXMLWithBundleNameTest 139 * @tc.desc: ParsePerformanceConfigXMLWithBundleName test 140 * @tc.type: FUNC 141 */ 142 HWTEST_F(ArkUIFeatureParamManagerTest, ParsePerformanceConfigXMLWithBundleNameTest, TestSize.Level1) 143 { 144 auto featureParser = std::make_unique<ConfigXMLParserBase>(); 145 auto ret = featureParser->ParsePerformanceConfigXMLWithBundleName(TEST1_HAP); 146 EXPECT_EQ(ret, ParseErrCode::PARSE_SYS_FILE_LOAD_FAIL); 147 auto doc = std::make_shared<xmlDoc>(); 148 featureParser->xmlSysDocument_ = doc.get(); 149 150 ret = featureParser->ParsePerformanceConfigXMLWithBundleName(TEST1_HAP); 151 EXPECT_EQ(ret, ParseErrCode::PARSE_GET_ROOT_FAIL); 152 153 xmlNode children; 154 children.type = xmlElementType::XML_ELEMENT_NODE; 155 doc->children = &children; 156 ret = featureParser->ParsePerformanceConfigXMLWithBundleName(TEST1_HAP); 157 EXPECT_EQ(ret, ParseErrCode::PARSE_GET_CHILD_FAIL); 158 featureParser->xmlSysDocument_ = nullptr; 159 featureParser = nullptr; 160 } 161 162 /** 163 * @tc.name: ParseXmlNodeNameWithIndexTest 164 * @tc.desc: ParseXmlNodeNameWithIndex test 165 * @tc.type: FUNC 166 */ 167 HWTEST_F(ArkUIFeatureParamManagerTest, ParseXmlNodeNameWithIndexTest, TestSize.Level1) 168 { 169 auto featureParser = std::make_unique<ConfigXMLParserBase>(); 170 xmlNode node; 171 auto ret = featureParser->ParseXmlNodeNameWithIndex(node, 4); 172 EXPECT_EQ(ret, ParseErrCode::PARSE_SIZE_ERROR); 173 featureParser = nullptr; 174 } 175 }