• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (c) 2024 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 <cstring>
17 #include <gtest/gtest.h>
18 #include <gmock/gmock.h>
19 #include <memory>
20 #include <unordered_map>
21 #include <libxml/parser.h>
22 #include <libxml/tree.h>
23 #include "parameters.h"
24 
25 #define private public
26 #include "nweb.h"
27 #include "nweb_adapter_helper.h"
28 #include "nweb_c_api.h"
29 #include "nweb_config_helper.h"
30 #include "nweb_helper.h"
31 #include "nweb_init_params.h"
32 
33 
34 using namespace testing;
35 using namespace testing::ext;
36 using namespace OHOS::NWeb;
37 
38 namespace OHOS {
39 namespace NWebConfig {
40 
41 const auto XML_ATTR_NAME = "name";
42 const auto XML_BUNDLE_NAME = "bundle_name";
43 const auto XML_ENABLE_WINDOW_ORIENTATION = "enable_window_orientation";
44 
45 class MockNWebConfigHelper : public NWebConfigHelper {
46 public:
47     MOCK_METHOD1(ParseConfig, void(std::shared_ptr<NWebEngineInitArgsImpl> initArgs));
48     MOCK_METHOD1(ParseNWebLTPOConfig, void(xmlNodePtr nodePtr));
49     MOCK_METHOD2(ParseDeleteConfig, void(const xmlNodePtr &rootPtr,
50         std::shared_ptr<NWebEngineInitArgsImpl> initArgs));
51     MOCK_METHOD2(ParseWebConfigXml, void(const std::string& configFilePath,
52         std::shared_ptr<NWebEngineInitArgsImpl> initArgs));
53 };
54 
55 class NWebConfigHelperTest : public ::testing::Test {
56 protected:
57     std::shared_ptr<NWebEngineInitArgsImpl> initArgs = std::make_shared<NWebEngineInitArgsImpl>();
58     xmlNodePtr rootElement;
59     xmlNodePtr childNodePtr;
60     std::unique_ptr<xmlChar[]> content;
61     NWebConfigHelper &helper = NWebConfigHelper::Instance();
SetUp()62     void SetUp() override
63     {
64         rootElement = xmlNewNode(NULL, BAD_CAST "root");
65         childNodePtr = xmlNewNode(NULL, BAD_CAST "child");
66         int contentSize = 10;
67         content = std::make_unique<xmlChar[]>(contentSize);
68     }
TearDown()69     void TearDown() override {
70         if (rootElement != nullptr) {
71             xmlFreeNode(rootElement);
72         }
73         if (childNodePtr != nullptr) {
74             xmlFreeNode(childNodePtr);
75         }
76     }
77 };
78 
79 /**
80  * @tc.name: ParseWebConfigXml_FileNotFound
81  * @tc.desc: ParseWebConfigXml.
82  * @tc.type: FUNC
83  * @tc.require:
84  */
85 HWTEST_F(NWebConfigHelperTest, ParseWebConfigXml_FileNotFound, TestSize.Level0)
86 {
87     std::string configFilePath = "nonexistent.xml";
88     EXPECT_NE(initArgs, nullptr);
89     NWebConfigHelper::Instance().ParseWebConfigXml(configFilePath, initArgs);
90 }
91 
92 /**
93  * @tc.name: ParseWebConfigXml_ValidOrientationConfig
94  * @tc.desc: ParseWebConfigXml.
95  * @tc.type: FUNC
96  * @tc.require:
97  */
98 HWTEST_F(NWebConfigHelperTest, ParseWebConfigXml_ValidOrientationConfig, TestSize.Level0)
99 {
100     std::string configFilePath = "valid_orientation.xml";
101     EXPECT_NE(initArgs, nullptr);
102     NWebConfigHelper::Instance().ParseWebConfigXml(configFilePath, initArgs);
103 }
104 
105 /**
106  * @tc.name: GetPerfConfig_ShouldReturnEmptyVector_WhenSettingNameNotExist
107  * @tc.desc: GetPerfConfig.
108  * @tc.type: FUNC
109  * @tc.require:
110  */
111 HWTEST_F(NWebConfigHelperTest, GetPerfConfig_ShouldReturnEmptyVector_WhenSettingNameNotExist, TestSize.Level0)
112 {
113     std::string settingName = "NonExistentSetting";
114     std::vector<FrameRateSetting> result = NWebConfigHelper::Instance().GetPerfConfig(settingName);
115     EXPECT_TRUE(result.empty());
116 }
117 
118 /**
119  * @tc.name: ParsePerfConfig_ShouldReturnEmptyString_WhenConfigNotFound
120  * @tc.desc: ParsePerfConfig.
121  * @tc.type: FUNC
122  * @tc.require:
123  */
124 HWTEST_F(NWebConfigHelperTest, ParsePerfConfig_ShouldReturnEmptyString_WhenConfigNotFound, TestSize.Level0)
125 {
126     std::string configNodeName = "non_existent_config";
127     std::string argsNodeName = "non_existent_args";
128     std::string result = NWebConfigHelper::Instance().ParsePerfConfig(configNodeName, argsNodeName);
129     EXPECT_EQ(result, "");
130 }
131 
132 /**
133  * @tc.name: ParsePerfConfig_ShouldReturnValue_WhenConfigFound
134  * @tc.desc: ParsePerfConfig.
135  * @tc.type: FUNC
136  * @tc.require:
137  */
138 HWTEST_F(NWebConfigHelperTest, ParsePerfConfig_ShouldReturnValue_WhenConfigFound, TestSize.Level0)
139 {
140     std::string configNodeName = "existent_config";
141     std::string argsNodeName = "existent_args";
142     std::string expectedValue = "expected_value";
143     NWebConfigHelper::Instance().perfConfig_[configNodeName + "/" + argsNodeName] = expectedValue;
144     std::string result = NWebConfigHelper::Instance().ParsePerfConfig(configNodeName, argsNodeName);
145     EXPECT_EQ(result, expectedValue);
146 }
147 
148 /**
149  * @tc.name: ParsePerfConfig_NullNode
150  * @tc.desc: ParsePerfConfig.
151  * @tc.type: FUNC
152  * @tc.require:
153  */
154 HWTEST_F(NWebConfigHelperTest, ParsePerfConfig_NullNode, TestSize.Level0)
155 {
156     xmlNodePtr node = xmlNewNode(nullptr, BAD_CAST "node");
157     NWebConfigHelper::Instance().ParsePerfConfig(node);
158     EXPECT_FALSE(NWebConfigHelper::Instance().perfConfig_.empty());
159 }
160 
161 /**
162  * @tc.name: ParsePerfConfig_CommentNode
163  * @tc.desc: ParsePerfConfig.
164  * @tc.type: FUNC
165  * @tc.require:
166  */
167 HWTEST_F(NWebConfigHelperTest, ParsePerfConfig_CommentNode, TestSize.Level0)
168 {
169     xmlNodePtr node = xmlNewNode(nullptr, BAD_CAST "comment");
170     NWebConfigHelper::Instance().ParsePerfConfig(node);
171     EXPECT_FALSE(NWebConfigHelper::Instance().perfConfig_.empty());
172     xmlFreeNode(node);
173 }
174 
175 /**
176  * @tc.name: ParseDeleteConfig_NullRootPtr
177  * @tc.desc: ParseDeleteConfig.
178  * @tc.type: FUNC
179  * @tc.require:
180  */
181 HWTEST_F(NWebConfigHelperTest, ParseDeleteConfig_NullRootPtr, TestSize.Level0)
182 {
183     xmlNodePtr rootPtr = xmlNewNode(nullptr, BAD_CAST "valid");
184     xmlNodePtr childNodePtr = xmlNewNode(nullptr, BAD_CAST "child");
185     EXPECT_NE(rootPtr, nullptr);
186     EXPECT_NE(childNodePtr, nullptr);
187     xmlAddChild(rootPtr, childNodePtr);
188     NWebConfigHelper::Instance().ParseDeleteConfig(rootPtr, initArgs);
189 }
190 
191 /**
192  * @tc.name: ParseDeleteConfig_ValidNode
193  * @tc.desc: ParseDeleteConfig.
194  * @tc.type: FUNC
195  * @tc.require:
196  */
197 HWTEST_F(NWebConfigHelperTest, ParseDeleteConfig_ValidNode, TestSize.Level0)
198 {
199     xmlNodePtr rootPtr = xmlNewNode(nullptr, BAD_CAST "valid");
200     xmlNodePtr childNodePtr = xmlNewNode(nullptr, BAD_CAST "child");
201     EXPECT_NE(rootPtr, nullptr);
202     EXPECT_NE(childNodePtr, nullptr);
203     xmlAddChild(rootPtr, childNodePtr);
204     xmlChar *content = xmlNodeGetContent(childNodePtr);
205     xmlNodeSetContent(childNodePtr, content);
206     xmlFree(content);
207     NWebConfigHelper::Instance().ParseDeleteConfig(rootPtr, initArgs);
208 }
209 
210 /**
211  * @tc.name: ParseDeleteConfig_InvalidChildNode
212  * @tc.desc: ParseDeleteConfig.
213  * @tc.type: FUNC
214  * @tc.require:
215  */
216 HWTEST_F(NWebConfigHelperTest, ParseDeleteConfig_InvalidChildNode, TestSize.Level0)
217 {
218     xmlNodePtr rootPtr = xmlNewNode(nullptr, BAD_CAST "valid");
219     xmlNodePtr childNodePtr = xmlNewNode(nullptr, BAD_CAST "invalid");
220     EXPECT_NE(rootPtr, nullptr);
221     EXPECT_NE(childNodePtr, nullptr);
222     xmlAddChild(rootPtr, childNodePtr);
223     NWebConfigHelper::Instance().ParseDeleteConfig(rootPtr, initArgs);
224 }
225 
226 /**
227  * @tc.name: ParseDeleteConfig_NullContent
228  * @tc.desc: ParseDeleteConfig.
229  * @tc.type: FUNC
230  * @tc.require:
231  */
232 HWTEST_F(NWebConfigHelperTest, ParseDeleteConfig_NullContent, TestSize.Level0)
233 {
234     xmlNodePtr rootPtr = xmlNewNode(nullptr, BAD_CAST "valid");
235     xmlNodePtr childNodePtr = xmlNewNode(nullptr, BAD_CAST "child");
236     EXPECT_NE(rootPtr, nullptr);
237     EXPECT_NE(childNodePtr, nullptr);
238     xmlAddChild(rootPtr, childNodePtr);
239     NWebConfigHelper::Instance().ParseDeleteConfig(rootPtr, initArgs);
240 }
241 
242 /**
243  * @tc.name: ParseDeleteConfig_NotFoundConfig
244  * @tc.desc: ParseDeleteConfig.
245  * @tc.type: FUNC
246  * @tc.require:
247  */
248 HWTEST_F(NWebConfigHelperTest, ParseDeleteConfig_NotFoundConfig, TestSize.Level0)
249 {
250     xmlNodePtr rootPtr = xmlNewNode(nullptr, BAD_CAST "valid");
251     xmlNodePtr childNodePtr = xmlNewNode(nullptr, BAD_CAST "child");
252     EXPECT_NE(rootPtr, nullptr);
253     EXPECT_NE(childNodePtr, nullptr);
254     xmlAddChild(rootPtr, childNodePtr);
255     xmlChar *content = xmlNodeGetContent(childNodePtr);
256     xmlNodeSetContent(childNodePtr, content);
257     xmlFree(content);
258     NWebConfigHelper::Instance().ParseDeleteConfig(rootPtr, initArgs);
259 }
260 
261 /**
262  * @tc.name: ParseDeleteConfig_EmptyParam
263  * @tc.desc: ParseDeleteConfig.
264  * @tc.type: FUNC
265  * @tc.require:
266  */
267 HWTEST_F(NWebConfigHelperTest, ParseDeleteConfig_EmptyParam, TestSize.Level0)
268 {
269     xmlNodePtr rootPtr = xmlNewNode(nullptr, BAD_CAST "valid");
270     xmlNodePtr childNodePtr = xmlNewNode(nullptr, BAD_CAST "child");
271     EXPECT_NE(rootPtr, nullptr);
272     EXPECT_NE(childNodePtr, nullptr);
273     xmlAddChild(rootPtr, childNodePtr);
274     xmlChar *content = xmlNodeGetContent(childNodePtr);
275     xmlNodeSetContent(childNodePtr, content);
276     xmlFree(content);
277     NWebConfigHelper::Instance().ParseDeleteConfig(rootPtr, initArgs);
278 }
279 
280 /**
281  * @tc.name: ParseWindowOrientationConfig_WhenNodeIsComment
282  * @tc.desc: ParseDeleteConfig.
283  * @tc.type: FUNC
284  * @tc.require:
285  */
286 HWTEST_F(NWebConfigHelperTest,
287     ParseWindowOrientationConfig_WhenNodeIsComment, TestSize.Level0) {
288     xmlNodePtr nodePtr = xmlNewNode(nullptr, BAD_CAST "testNode");
289     EXPECT_NE(nodePtr, nullptr);
290     nodePtr->type = xmlElementType::XML_COMMENT_NODE;
291     std::shared_ptr<NWebEngineInitArgsImpl> initArgs = std::make_shared<NWebEngineInitArgsImpl>();
292     NWebConfigHelper::Instance().ParseWindowOrientationConfig(nodePtr, initArgs);
293     EXPECT_EQ(initArgs->GetArgsToAdd().size(), 0);
294 }
295 
296 /**
297  * @tc.name: ParseWindowOrientationConfig_WhenBundleNameOrOrientationIsMissing
298  * @tc.desc: ParseWindowOrientationConfig.
299  * @tc.type: FUNC
300  * @tc.require:
301  */
302 HWTEST_F(NWebConfigHelperTest,
303     ParseWindowOrientationConfig_WhenBundleNameOrOrientationIsMissing, TestSize.Level0) {
304     xmlNodePtr nodePtr = xmlNewNode(nullptr, BAD_CAST "testNode");
305     EXPECT_NE(nodePtr, nullptr);
306     nodePtr->properties = nullptr;
307     std::shared_ptr<NWebEngineInitArgsImpl> initArgs = std::make_shared<NWebEngineInitArgsImpl>();
308     NWebConfigHelper::Instance().ParseWindowOrientationConfig(nodePtr, initArgs);
309     EXPECT_EQ(initArgs->GetArgsToAdd().size(), 0);
310 }
311 
312 /**
313  * @tc.name: ParseWindowOrientationConfig_WhenBundleNameMatchesAndOrientationIsTure
314  * @tc.desc: ParseWindowOrientationConfig.
315  * @tc.type: FUNC
316  * @tc.require:
317  */
318 HWTEST_F(NWebConfigHelperTest,
319     ParseWindowOrientationConfig_WhenBundleNameMatchesAndOrientationIsTure, TestSize.Level0) {
320     xmlNodePtr nodePtr = xmlNewNode(nullptr, BAD_CAST "testNode");
321     EXPECT_NE(nodePtr, nullptr);
322     xmlNewProp(nodePtr, BAD_CAST(XML_BUNDLE_NAME), BAD_CAST("testBundleName"));
323     xmlNewProp(nodePtr, BAD_CAST(XML_ENABLE_WINDOW_ORIENTATION), BAD_CAST("true"));
324     std::shared_ptr<NWebEngineInitArgsImpl> initArgs = std::make_shared<NWebEngineInitArgsImpl>();
325     NWebConfigHelper::Instance().ParseWindowOrientationConfig(nodePtr, initArgs);
326     EXPECT_EQ(initArgs->GetArgsToAdd().size(), 0);
327 }
328 
329 /**
330  * @tc.name: ParseWindowOrientationConfig_WhenBundleNameMatchesAndOrientationIsFalse
331  * @tc.desc: ParseWindowOrientationConfig.
332  * @tc.type: FUNC
333  * @tc.require:
334  */
335 HWTEST_F(NWebConfigHelperTest,
336     ParseWindowOrientationConfig_WhenBundleNameMatchesAndOrientationIsFalse, TestSize.Level0) {
337     xmlNodePtr nodePtr = xmlNewNode(nullptr, BAD_CAST "testNode");
338     EXPECT_NE(nodePtr, nullptr);
339     xmlNewProp(nodePtr, BAD_CAST(XML_BUNDLE_NAME), BAD_CAST "testBundleName");
340     xmlNewProp(nodePtr, BAD_CAST(XML_ENABLE_WINDOW_ORIENTATION), BAD_CAST("false"));
341     std::shared_ptr<NWebEngineInitArgsImpl> initArgs = std::make_shared<NWebEngineInitArgsImpl>();
342     NWebConfigHelper::Instance().ParseWindowOrientationConfig(nodePtr, initArgs);
343     EXPECT_EQ(initArgs->GetArgsToAdd().size(), 0);
344 }
345 
346 /**
347  * @tc.name: ParseWindowOrientationConfig_WhenBundleNameMatchesAndOrientationIsInvalid
348  * @tc.desc: ParseWindowOrientationConfig.
349  * @tc.type: FUNC
350  * @tc.require:
351  */
352 HWTEST_F(NWebConfigHelperTest,
353     ParseWindowOrientationConfig_WhenBundleNameMatchesAndOrientationIsInvalid, TestSize.Level0) {
354     xmlNodePtr nodePtr = xmlNewNode(nullptr, BAD_CAST "testNode");
355     EXPECT_NE(nodePtr, nullptr);
356     xmlNewProp(nodePtr, BAD_CAST(XML_BUNDLE_NAME), BAD_CAST("testBundleName"));
357     xmlNewProp(nodePtr, BAD_CAST(XML_ENABLE_WINDOW_ORIENTATION), BAD_CAST("invalidValue"));
358     std::shared_ptr<NWebEngineInitArgsImpl> initArgs = std::make_shared<NWebEngineInitArgsImpl>();
359     NWebConfigHelper::Instance().ParseWindowOrientationConfig(nodePtr, initArgs);
360     EXPECT_EQ(initArgs->GetArgsToAdd().size(), 0);
361 }
362 
363 /**
364  * @tc.name  : safeGetPropAsInt_ShouldReturnDefaultValue_WhenPropNotExist
365  * @tc.number: OHOS_NWEB_001
366  * @tc.desc  : Test safeGetPropAsInt function when the property does not exist.
367  */
368 HWTEST_F(NWebConfigHelperTest, safeGetPropAsInt_ShouldReturnDefaultValue_WhenPropNotExist,
369     testing::ext::TestSize.Level0)
370 {
371     int defaultValue = 10;
372     int result = NWebConfigHelper::Instance().safeGetPropAsInt(rootElement,
373       BAD_CAST "non_existent_prop", defaultValue);
374     EXPECT_EQ(result, defaultValue);
375 }
376 
377 /**
378  * @tc.name  : safeGetPropAsInt_ShouldReturnPropValue_WhenPropExist
379  * @tc.number: OHOS_NWEB_002
380  * @tc.desc  : Test safeGetPropAsInt function when the property exists.
381  */
382 HWTEST_F(NWebConfigHelperTest, safeGetPropAsInt_ShouldReturnPropValue_WhenPropExist, testing::ext::TestSize.Level0)
383 {
384     xmlNewProp(rootElement, BAD_CAST "test_prop", BAD_CAST "20");
385     int result = NWebConfigHelper::Instance().safeGetPropAsInt(rootElement, BAD_CAST "test_prop", 10);
386     EXPECT_EQ(result, 20);
387 }
388 
389 /**
390  * @tc.name  : safeGetPropAsInt_ShouldReturnDefaultValue_WhenPropValueNotInt
391  * @tc.number: OHOS_NWEB_003
392  * @tc.desc  : Test safeGetPropAsInt function when the property value is not an integer.
393  */
394 HWTEST_F(NWebConfigHelperTest, safeGetPropAsInt_ShouldReturnDefaultValue_WhenPropValueNotInt,
395     testing::ext::TestSize.Level0)
396 {
397     xmlNewProp(rootElement, BAD_CAST "test_prop", BAD_CAST "not_an_integer");
398     int defaultValue = 0;
399     int result = NWebConfigHelper::Instance().safeGetPropAsInt(rootElement, BAD_CAST "test_prop", defaultValue);
400     EXPECT_EQ(result, defaultValue);
401 }
402 
403 /**
404  * @tc.name  : WriteConfigValueToSysPara_ShouldSetParameter_WhenConfigNameIsFlowBufferConfigMaxFdNumber
405  * @tc.number: NWebConfigHelperTest_001
406  * @tc.desc  : Test WriteConfigValueToSysPara method when configName is "flowBufferConfig/maxFdNumber"
407  */
408 HWTEST_F(NWebConfigHelperTest,
409     WriteConfigValueToSysPara_ShouldSetParameter_WhenConfigNameIsFlowBufferConfigMaxFdNumber, TestSize.Level0)
410 {
411     std::string configName = "flowBufferConfig/maxFdNumber";
412     std::string value = "1024";
413     NWebConfigHelper::Instance().WriteConfigValueToSysPara(configName, value);
414     std::string actualValue = OHOS::system::GetParameter("web.flowbuffer.maxfd", "");
415     EXPECT_EQ(value, actualValue);
416 }
417 
418 /**
419  * @tc.name  : WriteConfigValueToSysPara_ShouldNotSetParameter_WhenConfigNameIsNotFlowBufferConfigMaxFdNumber
420  * @tc.number: NWebConfigHelperTest_002
421  * @tc.desc  : Test WriteConfigValueToSysPara method when configName is not "flowBufferConfig/maxFdNumber"
422  */
423 HWTEST_F(NWebConfigHelperTest,
424     WriteConfigValueToSysPara_ShouldNotSetParameter_WhenConfigNameIsNotFlowBufferConfigMaxFdNumber, TestSize.Level0)
425 {
426     std::string configName = "someOtherConfig";
427     std::string value = "1024";
428     NWebConfigHelper::Instance().WriteConfigValueToSysPara(configName, value);
429     std::string actualValue = OHOS::system::GetParameter("web.flowbuffer.maxfd", "");
430     EXPECT_EQ(value, actualValue);
431 }
432 
433 /**
434  * @tc.name  : ParseNWebLTPOConfig_ShouldHandleInvalidNode_WhenNodeIsNull
435  * @tc.number: NWebConfigHelperTest_001
436  * @tc.desc  : Test when node is null then ParseNWebLTPOConfig should handle it correctly
437  */
438 HWTEST_F(NWebConfigHelperTest, ParseNWebLTPOConfig_ShouldHandleInvalidNode_WhenNodeIsNull, TestSize.Level0)
439 {
440     xmlNodePtr rootPtr = xmlNewNode(nullptr, BAD_CAST "valid");
441     xmlNodePtr childNodePtr = xmlNewNode(nullptr, BAD_CAST "child");
442     EXPECT_NE(rootPtr, nullptr);
443     EXPECT_NE(childNodePtr, nullptr);
444     xmlAddChild(rootPtr, childNodePtr);
445     NWebConfigHelper::Instance().ParseNWebLTPOConfig(rootPtr);
446 }
447 
448 /**
449  * @tc.name  : ParseNWebLTPOConfig_ShouldHandleInvalidNode_WhenNodeIsComment
450  * @tc.number: NWebConfigHelperTest_002
451  * @tc.desc  : Test when node is a comment then ParseNWebLTPOConfig should handle it correctly
452  */
453 HWTEST_F(NWebConfigHelperTest, ParseNWebLTPOConfig_ShouldHandleInvalidNode_WhenNodeIsComment, TestSize.Level0)
454 {
455     xmlNodePtr nodePtr = xmlNewComment((xmlChar *)"This is a comment");
456     xmlNodePtr childNodePtr = xmlNewNode(nullptr, BAD_CAST "child");
457     EXPECT_NE(nodePtr, nullptr);
458     EXPECT_NE(childNodePtr, nullptr);
459     xmlAddChild(nodePtr, childNodePtr);
460     NWebConfigHelper::Instance().ParseNWebLTPOConfig(nodePtr);
461     xmlFreeNode(nodePtr);
462 }
463 
464 /**
465  * @tc.name  : ParseNWebLTPOConfig_ShouldHandleValidNode_WhenNameIsValid
466  * @tc.number: NWebConfigHelperTest_004
467  * @tc.desc  : Test when node and name are valid then ParseNWebLTPOConfig should handle it correctly
468  */
469 HWTEST_F(NWebConfigHelperTest, ParseNWebLTPOConfig_ShouldHandleValidNode_WhenNameIsValid, TestSize.Level0)
470 {
471     xmlNodePtr nodePtr = xmlNewNode(nullptr, BAD_CAST "testNode");
472     EXPECT_NE(nodePtr, nullptr);
473     xmlNewProp(nodePtr, BAD_CAST(XML_ATTR_NAME), BAD_CAST("validName"));
474     NWebConfigHelper::Instance().ParseNWebLTPOConfig(nodePtr);
475     xmlFreeNode(nodePtr);
476 }
477 
478 /**
479  * @tc.name  : ParseNWebLTPOConfig_ShouldHandleInvalidDynamicNode_WhenDynamicNodeIsComment
480  * @tc.number: NWebConfigHelperTest_006
481  * @tc.desc  : Test when dynamic node is a comment then ParseNWebLTPOConfig should handle it correctly
482  */
483 HWTEST_F(NWebConfigHelperTest, ParseNWebLTPOConfig_ShouldHandleInvalidDynamicNode_WhenDynamicNodeIsComment,
484     TestSize.Level0)
485 {
486     xmlNodePtr nodePtr = xmlNewNode(nullptr, BAD_CAST "testNode");
487     EXPECT_NE(nodePtr, nullptr);
488     xmlNewProp(nodePtr, BAD_CAST(XML_ATTR_NAME), BAD_CAST("validName"));
489     xmlNodePtr dynamicNodePtr = xmlNewComment((xmlChar *)"This is a comment");
490     EXPECT_NE(dynamicNodePtr, nullptr);
491     xmlAddChild(nodePtr, dynamicNodePtr);
492     NWebConfigHelper::Instance().ParseNWebLTPOConfig(nodePtr);
493     xmlFreeNode(nodePtr);
494 }
495 
496 /**
497  * @tc.name  : GetChildrenNode_ShouldReturnNode_WhenNodeExists
498  * @tc.number: NWebConfigHelperTest_001
499  * @tc.desc  : Test GetChildrenNode function when the node exists
500  */
501 HWTEST_F(NWebConfigHelperTest, GetChildrenNode_ShouldReturnNode_WhenNodeExists, TestSize.Level0)
502 {
503     xmlNodePtr rootNode = xmlNewNode(nullptr, BAD_CAST "root");
504     xmlNodePtr childNode = nullptr;
505     xmlAddChild(rootNode, childNode);
506     xmlNodePtr resultNode = NWebConfigHelper::Instance().GetChildrenNode(rootNode, "child");
507     EXPECT_EQ(resultNode, childNode);
508     xmlFreeNode(rootNode);
509     xmlFreeNode(childNode);
510 }
511 
512 /**
513  * @tc.name  : GetChildrenNode_ShouldReturnNull_WhenNodeNotExists
514  * @tc.number: NWebConfigHelperTest_002
515  * @tc.desc  : Test GetChildrenNode function when the node does not exist
516  */
517 HWTEST_F(NWebConfigHelperTest, GetChildrenNode_ShouldReturnNull_WhenNodeNotExists, TestSize.Level0)
518 {
519     xmlNodePtr rootNode = xmlNewNode(nullptr, BAD_CAST "root");
520     xmlNodePtr childNode = nullptr;
521     xmlAddChild(rootNode, childNode);
522     xmlNodePtr resultNode = NWebConfigHelper::Instance().GetChildrenNode(rootNode, "non_existent_child");
523     EXPECT_EQ(resultNode, nullptr);
524     xmlFreeNode(rootNode);
525     xmlFreeNode(childNode);
526 }
527 
528 /**
529  * @tc.name  : GetChildrenNode_ShouldReturnNull_WhenNodeNameIsEmpty
530  * @tc.number: NWebConfigHelperTest_004
531  * @tc.desc  : Test GetChildrenNode function when the node name is empty
532  */
533 HWTEST_F(NWebConfigHelperTest, GetChildrenNode_ShouldReturnNull_WhenNodeNameIsEmpty, TestSize.Level0)
534 {
535     xmlNodePtr rootNode = xmlNewNode(nullptr, BAD_CAST "root");
536     xmlNodePtr resultNode = NWebConfigHelper::Instance().GetChildrenNode(rootNode, "");
537     EXPECT_EQ(resultNode, nullptr);
538     xmlFreeNode(rootNode);
539 }
540 
541 /**
542  * @tc.name  : ReadConfig_ShouldHandleInvalidNode_WhenNodeIsNull
543  * @tc.number: NWebConfigHelperTest_001
544  * @tc.desc  : Test when node is null then ReadConfig should skip the node
545  */
546 HWTEST_F(NWebConfigHelperTest, ReadConfig_ShouldHandleInvalidNode_WhenNodeIsNull, TestSize.Level0)
547 {
548     rootElement->xmlChildrenNode = nullptr;
549     NWebConfigHelper::Instance().ReadConfig(rootElement, initArgs);
550     EXPECT_EQ(initArgs->GetArgsToAdd().size(), 0);
551 }
552 
553 /**
554  * @tc.name  : ReadConfig_ShouldHandleInvalidNode_WhenNodeIsComment
555  * @tc.number: NWebConfigHelperTest_002
556  * @tc.desc  : Test when node is a comment then ReadConfig should skip the node
557  */
558 HWTEST_F(NWebConfigHelperTest, ReadConfig_ShouldHandleInvalidNode_WhenNodeIsComment, TestSize.Level0)
559 {
560     rootElement->type = xmlElementType::XML_COMMENT_NODE;
561     NWebConfigHelper::Instance().ReadConfig(rootElement, initArgs);
562     EXPECT_EQ(initArgs->GetArgsToAdd().size(), 0);
563 }
564 
565 /**
566  * @tc.name  : ReadConfig_ShouldHandleInvalidNode_WhenChildNodeIsNull
567  * @tc.number: NWebConfigHelperTest_003
568  * @tc.desc  : Test when child node is null then ReadConfig should skip the child node
569  */
570 HWTEST_F(NWebConfigHelperTest, ReadConfig_ShouldHandleInvalidNode_WhenChildNodeIsNull, TestSize.Level0)
571 {
572     xmlNodePtr rootElement = xmlNewNode(nullptr, BAD_CAST "root");
573     xmlNodePtr childNodePtr = xmlNewNode(nullptr, BAD_CAST "child");
574     rootElement->xmlChildrenNode = childNodePtr;
575     childNodePtr->xmlChildrenNode = nullptr;
576     NWebConfigHelper::Instance().ReadConfig(rootElement, initArgs);
577     EXPECT_EQ(initArgs->GetArgsToAdd().size(), 0);
578 }
579 
580 /**
581  * @tc.name  : ReadConfig_ShouldHandleInvalidNode_WhenChildNodeIsComment
582  * @tc.number: NWebConfigHelperTest_004
583  * @tc.desc  : Test when child node is a comment then ReadConfig should skip the child node
584  */
585 HWTEST_F(NWebConfigHelperTest, ReadConfig_ShouldHandleInvalidNode_WhenChildNodeIsComment, TestSize.Level0)
586 {
587     xmlNodePtr rootElement = xmlNewNode(nullptr, BAD_CAST "root");
588     xmlNodePtr childNodePtr = xmlNewNode(nullptr, BAD_CAST "child");
589     rootElement->xmlChildrenNode = childNodePtr;
590     childNodePtr->type = xmlElementType::XML_COMMENT_NODE;
591     NWebConfigHelper::Instance().ReadConfig(rootElement, initArgs);
592     EXPECT_EQ(initArgs->GetArgsToAdd().size(), 0);
593 }
594 
595 /**
596  * @tc.name  : ReadConfig_ShouldHandleInvalidNode_WhenContentIsNull
597  * @tc.number: NWebConfigHelperTest_005
598  * @tc.desc  : Test when content is null then ReadConfig should skip the node
599  */
600 HWTEST_F(NWebConfigHelperTest, ReadConfig_ShouldHandleInvalidNode_WhenContentIsNull, TestSize.Level0)
601 {
602     xmlNodePtr rootElement = xmlNewNode(nullptr, BAD_CAST "root");
603     xmlNodePtr childNodePtr = xmlNewNode(nullptr, BAD_CAST "child");
604     rootElement->xmlChildrenNode = childNodePtr;
605     childNodePtr->xmlChildrenNode = nullptr;
606     NWebConfigHelper::Instance().ReadConfig(rootElement, initArgs);
607     EXPECT_EQ(initArgs->GetArgsToAdd().size(), 0);
608 }
609 
610 /**
611  * @tc.name  : ReadConfig_ShouldHandleValidNode_WhenContentIsValid
612  * @tc.number: NWebConfigHelperTest_006
613  * @tc.desc  : Test when content is valid then ReadConfig should add the param to initArgs
614  */
615 HWTEST_F(NWebConfigHelperTest, ReadConfig_ShouldHandleValidNode_WhenContentIsValid, TestSize.Level0)
616 {
617     xmlNodePtr rootElement = xmlNewNode(nullptr, BAD_CAST "root");
618     xmlNodePtr childNodePtr = xmlNewNode(nullptr, BAD_CAST "child");rootElement->xmlChildrenNode = childNodePtr;
619     rootElement->content = (xmlChar *)"valid_content";
620     rootElement->type = XML_TEXT_NODE;
621     childNodePtr->xmlChildrenNode = nullptr;
622     NWebConfigHelper::Instance().ReadConfig(rootElement, initArgs);
623     EXPECT_EQ(initArgs->GetArgsToAdd().size(), 0);
624 }
625 
626 /**
627  * @tc.name  : GetConfigPath_ShouldReturnSystemPath_WhenConfigPathIsInvalid
628  * @tc.number: NWebConfigHelperTest_001
629  * @tc.desc  : Test scenario for GetConfigPath when config path is invalid
630  */
631 HWTEST_F(NWebConfigHelperTest, GetConfigPath_ShouldReturnSystemPath_WhenConfigPathIsInvalid, TestSize.Level0)
632 {
633     std::string configFileName = "invalid_config_file";
634     std::string expectedPath = "/system/" + configFileName;
635     EXPECT_EQ(NWebConfigHelper::Instance().GetConfigPath(configFileName), expectedPath);
636 }
637 
638 /**
639  * @tc.name  : NWebConfigHelper_ReadConfigIfNeeded_ShouldParseConfig_WhenPerfConfigEmpty
640  * @tc.number: NWebConfigHelper_Test_001
641  * @tc.desc  : Test that ReadConfigIfNeeded parses config when perfConfig is empty
642  */
643 HWTEST_F(NWebConfigHelperTest, NWebConfigHelper_ReadConfigIfNeeded_ShouldParseConfig_WhenPerfConfigEmpty,
644     TestSize.Level0)
645 {
646     NWebConfigHelper::Instance().perfConfig_.clear();
647     EXPECT_TRUE(NWebConfigHelper::Instance().perfConfig_.empty());
648     NWebConfigHelper::Instance().ReadConfigIfNeeded();
649 }
650 
651 /**
652  * @tc.name  : NWebConfigHelper_ReadConfigIfNeeded_ShouldNotParseConfig_WhenPerfConfigNotEmpty
653  * @tc.number: NWebConfigHelper_Test_002
654  * @tc.desc  : Test that ReadConfigIfNeeded does not parse config when perfConfig is not empty
655  */
656 HWTEST_F(NWebConfigHelperTest, NWebConfigHelper_ReadConfigIfNeeded_ShouldNotParseConfig_WhenPerfConfigNotEmpty,
657     TestSize.Level0)
658 {
659     NWebConfigHelper::Instance().perfConfig_.insert(std::make_pair("some_config", ""));
660     NWebConfigHelper::Instance().ReadConfigIfNeeded();
661     MockNWebConfigHelper *mock = new MockNWebConfigHelper();
662     EXPECT_CALL(*mock, ParseConfig(initArgs)).Times(0);
663     delete mock;
664 }
665 } // NWebConfig
666 } // OHOS```