1/*
2 * Copyright (c) 2022 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 *     http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16#include "test_xml.h"
17#include "test.h"
18
19#include "napi/native_api.h"
20#include "napi/native_node_api.h"
21
22#include "js_xml.h"
23#include "native_module_xml.h"
24#include "securec.h"
25#include "tools/log.h"
26
27using namespace OHOS::xml;
28
29#define ASSERT_CHECK_CALL(call)   \
30    {                             \
31        ASSERT_EQ(call, napi_ok); \
32    }
33
34#define ASSERT_CHECK_VALUE_TYPE(env, value, type)               \
35    {                                                           \
36        napi_valuetype valueType = napi_undefined;              \
37        ASSERT_TRUE(value != nullptr);                          \
38        ASSERT_CHECK_CALL(napi_typeof(env, value, &valueType)); \
39        ASSERT_EQ(valueType, type);                             \
40    }
41
42static std::string g_testStr = "";
43napi_value Method(napi_env env, napi_callback_info info)
44{
45    napi_value thisVar = nullptr;
46    size_t argc = 0;
47    napi_value args[6] = { 0 }; // 6:six args
48    NAPI_CALL(env, napi_get_cb_info(env, info, &argc, nullptr, &thisVar, nullptr));
49    NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, &thisVar, nullptr));
50
51    napi_value name = args[0];
52    napi_value value = args[1];
53
54    std::string buffer1 = "";
55    size_t bufferSize1 = 0;
56    napi_get_value_string_utf8(env, name, nullptr, 0, &bufferSize1);
57    buffer1.reserve(bufferSize1 + 1);
58    buffer1.resize(bufferSize1);
59    napi_get_value_string_utf8(env, name, buffer1.data(), bufferSize1 + 1, &bufferSize1);
60
61    std::string buffer2 = "";
62    size_t bufferSize2 = 0;
63    napi_get_value_string_utf8(env, value, nullptr, 0, &bufferSize2);
64    buffer2.reserve(bufferSize2 + 1);
65    buffer2.resize(bufferSize2);
66    napi_get_value_string_utf8(env, value, buffer2.data(), bufferSize2 + 1, &bufferSize2);
67    g_testStr += buffer1 + buffer2;
68    napi_value result = nullptr;
69    napi_get_boolean(env, true, &result);
70    return result;
71}
72
73napi_value TokenValueCallbackFunction(napi_env env, napi_callback_info info)
74{
75    napi_value thisVar = nullptr;
76    size_t argc = 0;
77    napi_value args[6] = { 0 }; // 6:six args
78    NAPI_CALL(env, napi_get_cb_info(env, info, &argc, nullptr, &thisVar, nullptr));
79    NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, &thisVar, nullptr));
80    napi_value value = args[1];
81    napi_value value3 = nullptr;
82    napi_get_named_property(env, value, "getDepth", &value3);
83    napi_get_named_property(env, value, "getColumnNumber", &value3);
84    napi_get_named_property(env, value, "getLineNumber", &value3);
85    napi_get_named_property(env, value, "getAttributeCount", &value3);
86    napi_get_named_property(env, value, "getName", &value3);
87    napi_get_named_property(env, value, "getNamespace", &value3);
88    napi_get_named_property(env, value, "getPrefix", &value3);
89    napi_get_named_property(env, value, "getText", &value3);
90    napi_get_named_property(env, value, "isEmptyElementTag", &value3);
91    napi_get_named_property(env, value, "isWhitespace", &value3);
92    napi_valuetype result2 = napi_null;
93    napi_typeof(env, value3, &result2);
94    napi_value returnVal = nullptr;
95    napi_call_function(env, thisVar, value3, 0, nullptr, &returnVal);
96
97    napi_value result = nullptr;
98    napi_get_boolean(env, true, &result);
99    return result;
100}
101
102napi_value TokenValueCallbackFunc(napi_env env, napi_callback_info info)
103{
104    napi_value thisVar = nullptr;
105    size_t argc = 0;
106    napi_value args[6] = { 0 }; // 6:six args
107    NAPI_CALL(env, napi_get_cb_info(env, info, &argc, nullptr, &thisVar, nullptr));
108    NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, &thisVar, nullptr));
109    napi_value value = args[1];
110    napi_value value3 = nullptr;
111    napi_get_named_property(env, value, "getDepth", &value3);
112    napi_value returnVal = nullptr;
113    napi_call_function(env, thisVar, value3, 0, nullptr, &returnVal);
114    napi_get_named_property(env, value, "getColumnNumber", &value3);
115    napi_call_function(env, thisVar, value3, 0, nullptr, &returnVal);
116    napi_get_named_property(env, value, "getLineNumber", &value3);
117    napi_call_function(env, thisVar, value3, 0, nullptr, &returnVal);
118    napi_get_named_property(env, value, "getAttributeCount", &value3);
119    napi_call_function(env, thisVar, value3, 0, nullptr, &returnVal);
120    napi_get_named_property(env, value, "getName", &value3);
121    napi_call_function(env, thisVar, value3, 0, nullptr, &returnVal);
122    napi_get_named_property(env, value, "getNamespace", &value3);
123    napi_call_function(env, thisVar, value3, 0, nullptr, &returnVal);
124    napi_get_named_property(env, value, "getPrefix", &value3);
125    napi_call_function(env, thisVar, value3, 0, nullptr, &returnVal);
126    napi_get_named_property(env, value, "getText", &value3);
127    napi_call_function(env, thisVar, value3, 0, nullptr, &returnVal);
128    napi_get_named_property(env, value, "isEmptyElementTag", &value3);
129    napi_call_function(env, thisVar, value3, 0, nullptr, &returnVal);
130    napi_get_named_property(env, value, "isWhitespace", &value3);
131    napi_call_function(env, thisVar, value3, 0, nullptr, &returnVal);
132
133    napi_value result = nullptr;
134    napi_get_boolean(env, true, &result);
135    return result;
136}
137
138/* @tc.name: StartElementTest001
139 * @tc.desc: Test whether write a elemnet start tag with the given name successfully.
140 * @tc.type: FUNC
141 */
142HWTEST_F(NativeEngineTest, StartElementTest001, testing::ext::TestSize.Level0)
143{
144    napi_env env = (napi_env)engine_;
145    napi_value arrayBuffer = nullptr;
146    void* pBuffer = nullptr;
147    size_t size = 1024;
148    napi_create_arraybuffer(env, size, &pBuffer, &arrayBuffer);
149    OHOS::xml::XmlSerializer xmlSerializer(reinterpret_cast<char*>(pBuffer), size, "utf-8");
150    xmlSerializer.StartElement("note1");
151    xmlSerializer.EndElement();
152    ASSERT_STREQ(reinterpret_cast<char*>(pBuffer), "<note1/>");
153}
154
155/* @tc.name: StartElementTest002
156 * @tc.desc: Test whether write a elemnet start tag with the given name successfully.
157 * @tc.type: FUNC
158 */
159HWTEST_F(NativeEngineTest, StartElementTest002, testing::ext::TestSize.Level0)
160{
161    napi_env env = (napi_env)engine_;
162    napi_value arrayBuffer = nullptr;
163    void* pBuffer = nullptr;
164    size_t size = 1024;
165    napi_create_arraybuffer(env, size, &pBuffer, &arrayBuffer);
166    OHOS::xml::XmlSerializer xmlSerializer(reinterpret_cast<char*>(pBuffer), size, "utf-8");
167    xmlSerializer.StartElement("note1");
168    xmlSerializer.EndElement();
169    xmlSerializer.StartElement("note2");
170    xmlSerializer.EndElement();
171    ASSERT_STREQ(reinterpret_cast<char*>(pBuffer), "<note1/>\r\n<note2/>");
172}
173
174/* @tc.name: StartElementTest003
175 * @tc.desc: Test whether write a elemnet start tag with the given name successfully.
176 * @tc.type: FUNC
177 */
178HWTEST_F(NativeEngineTest, StartElementTest003, testing::ext::TestSize.Level0)
179{
180    napi_env env = (napi_env)engine_;
181    napi_value arrayBuffer = nullptr;
182    void* pBuffer = nullptr;
183    size_t size = 1024;
184    napi_create_arraybuffer(env, size, &pBuffer, &arrayBuffer);
185    OHOS::xml::XmlSerializer xmlSerializer(reinterpret_cast<char*>(pBuffer), size, "utf-8");
186    xmlSerializer.StartElement("note1");
187    xmlSerializer.StartElement("note2");
188    xmlSerializer.EndElement();
189    xmlSerializer.EndElement();
190    ASSERT_STREQ(reinterpret_cast<char*>(pBuffer), "<note1>\r\n  <note2/>\r\n</note1>");
191}
192
193/* @tc.name: StartElementTest004
194 * @tc.desc: Test whether write a elemnet start tag with the given name successfully.
195 * @tc.type: FUNC
196 */
197HWTEST_F(NativeEngineTest, StartElementTest004, testing::ext::TestSize.Level0)
198{
199    napi_env env = (napi_env)engine_;
200    napi_value arrayBuffer = nullptr;
201    void* pBuffer = nullptr;
202    size_t size = 1024;
203    napi_create_arraybuffer(env, size, &pBuffer, &arrayBuffer);
204    OHOS::xml::XmlSerializer xmlSerializer(reinterpret_cast<char*>(pBuffer), size, "utf-8");
205    xmlSerializer.StartElement("note1");
206    xmlSerializer.StartElement("note2");
207    xmlSerializer.StartElement("note3");
208    xmlSerializer.EndElement();
209    xmlSerializer.EndElement();
210    xmlSerializer.EndElement();
211    ASSERT_STREQ(reinterpret_cast<char*>(pBuffer), "<note1>\r\n  <note2>\r\n    <note3/>\r\n  </note2>\r\n</note1>");
212}
213
214/* @tc.name: StartElementTest005
215 * @tc.desc: Test whether write a elemnet start tag with the given name successfully.
216 * @tc.type: FUNC
217 */
218HWTEST_F(NativeEngineTest, StartElementTest005, testing::ext::TestSize.Level0)
219{
220    napi_env env = (napi_env)engine_;
221    napi_value arrayBuffer = nullptr;
222    void* pBuffer = nullptr;
223    size_t size = 1024;
224    napi_create_arraybuffer(env, size, &pBuffer, &arrayBuffer);
225    OHOS::xml::XmlSerializer xmlSerializer(reinterpret_cast<char*>(pBuffer), size, "utf-8");
226    xmlSerializer.StartElement("note1");
227    xmlSerializer.StartElement("note2");
228    xmlSerializer.EndElement();
229    xmlSerializer.StartElement("note3");
230    xmlSerializer.EndElement();
231    xmlSerializer.EndElement();
232    ASSERT_STREQ(reinterpret_cast<char*>(pBuffer), "<note1>\r\n  <note2/>\r\n  <note3/>\r\n</note1>");
233}
234
235/* @tc.name: SetAttributesTest001
236 * @tc.desc: Test whether write an attribute successfully.
237 * @tc.type: FUNC
238 */
239HWTEST_F(NativeEngineTest, SetAttributesTest001, testing::ext::TestSize.Level0)
240{
241    napi_env env = (napi_env)engine_;
242    napi_value arrayBuffer = nullptr;
243    void* pBuffer = nullptr;
244    size_t size = 1024;
245    napi_create_arraybuffer(env, size, &pBuffer, &arrayBuffer);
246    OHOS::xml::XmlSerializer xmlSerializer(reinterpret_cast<char*>(pBuffer), size, "utf-8");
247    xmlSerializer.StartElement("note");
248    xmlSerializer.SetAttributes("importance1", "high1");
249    xmlSerializer.EndElement();
250    ASSERT_STREQ(reinterpret_cast<char*>(pBuffer), "<note importance1=\"high1\"/>");
251}
252
253/* @tc.name: SetAttributesTest002
254 * @tc.desc: Test whether write an attribute successfully.
255 * @tc.type: FUNC
256 */
257HWTEST_F(NativeEngineTest, SetAttributesTest002, testing::ext::TestSize.Level0)
258{
259    napi_env env = (napi_env)engine_;
260    napi_value arrayBuffer = nullptr;
261    void* pBuffer = nullptr;
262    size_t size = 1024;
263    napi_create_arraybuffer(env, size, &pBuffer, &arrayBuffer);
264    OHOS::xml::XmlSerializer xmlSerializer(reinterpret_cast<char*>(pBuffer), size, "utf-8");
265    xmlSerializer.StartElement("note");
266    xmlSerializer.SetAttributes("importance1", "high1");
267    xmlSerializer.SetAttributes("importance2", "high2");
268    xmlSerializer.EndElement();
269    ASSERT_STREQ(reinterpret_cast<char*>(pBuffer), "<note importance1=\"high1\" importance2=\"high2\"/>");
270}
271
272/* @tc.name: SetAttributesTest003
273 * @tc.desc: Test whether write an attribute successfully.
274 * @tc.type: FUNC
275 */
276HWTEST_F(NativeEngineTest, SetAttributesTest003, testing::ext::TestSize.Level0)
277{
278    napi_env env = (napi_env)engine_;
279    napi_value arrayBuffer = nullptr;
280    void* pBuffer = nullptr;
281    size_t size = 1024;
282    napi_create_arraybuffer(env, size, &pBuffer, &arrayBuffer);
283    OHOS::xml::XmlSerializer xmlSerializer(reinterpret_cast<char*>(pBuffer), size, "utf-8");
284    xmlSerializer.StartElement("note");
285    xmlSerializer.SetAttributes("importance1", "high1");
286    xmlSerializer.SetAttributes("importance2", "high2");
287    xmlSerializer.SetAttributes("importance3", "high3");
288    xmlSerializer.EndElement();
289    ASSERT_STREQ(reinterpret_cast<char*>(pBuffer),
290                 "<note importance1=\"high1\" importance2=\"high2\" importance3=\"high3\"/>");
291}
292
293/* @tc.name: SetAttributesTest004
294 * @tc.desc: Test whether write an attribute successfully.
295 * @tc.type: FUNC
296 */
297HWTEST_F(NativeEngineTest, SetAttributesTest004, testing::ext::TestSize.Level0)
298{
299    napi_env env = (napi_env)engine_;
300    napi_value arrayBuffer = nullptr;
301    void* pBuffer = nullptr;
302    size_t size = 1024;
303    napi_create_arraybuffer(env, size, &pBuffer, &arrayBuffer);
304    OHOS::xml::XmlSerializer xmlSerializer(reinterpret_cast<char*>(pBuffer), size, "utf-8");
305    xmlSerializer.StartElement("note");
306    xmlSerializer.SetAttributes("importance1", "high1");
307    xmlSerializer.SetAttributes("importance2", "high2");
308    xmlSerializer.SetAttributes("importance3", "high3");
309    xmlSerializer.SetAttributes("importance4", "high4");
310    xmlSerializer.EndElement();
311    ASSERT_STREQ(reinterpret_cast<char*>(pBuffer),
312                 "<note importance1=\"high1\" importance2=\"high2\" importance3=\"high3\" importance4=\"high4\"/>");
313}
314
315/* @tc.name: SetAttributesTest005
316 * @tc.desc: Test whether write an attribute successfully.
317 * @tc.type: FUNC
318 */
319HWTEST_F(NativeEngineTest, SetAttributesTest005, testing::ext::TestSize.Level0)
320{
321    napi_env env = (napi_env)engine_;
322    napi_value arrayBuffer = nullptr;
323    void* pBuffer = nullptr;
324    size_t size = 1024;
325    napi_create_arraybuffer(env, size, &pBuffer, &arrayBuffer);
326    OHOS::xml::XmlSerializer xmlSerializer(reinterpret_cast<char*>(pBuffer), size, "utf-8");
327    xmlSerializer.StartElement("note");
328    xmlSerializer.SetAttributes("importance1", "high1");
329    xmlSerializer.SetAttributes("importance2", "high2");
330    xmlSerializer.SetAttributes("importance3", "high3");
331    xmlSerializer.SetAttributes("importance4", "high4");
332    xmlSerializer.SetAttributes("importance5", "high5");
333    xmlSerializer.EndElement();
334    std::string strPrior = "<note importance1=\"high1\" importance2=\"high2\" ";
335    std::string strBack = "importance3=\"high3\" importance4=\"high4\" importance5=\"high5\"/>";
336    std::string strEnd = strPrior + strBack;
337    ASSERT_STREQ(reinterpret_cast<char*>(pBuffer), strEnd.c_str());
338}
339
340/* @tc.name: AddEmptyElementTest001
341 * @tc.desc: Test whether add an empty element successfully.
342 * @tc.type: FUNC
343 */
344HWTEST_F(NativeEngineTest, AddEmptyElementTest001, testing::ext::TestSize.Level0)
345{
346    napi_env env = (napi_env)engine_;
347    napi_value arrayBuffer = nullptr;
348    void* pBuffer = nullptr;
349    size_t size = 1024;
350    napi_create_arraybuffer(env, size, &pBuffer, &arrayBuffer);
351    OHOS::xml::XmlSerializer xmlSerializer(reinterpret_cast<char*>(pBuffer), size, "utf-8");
352    xmlSerializer.StartElement("note");
353    xmlSerializer.AddEmptyElement("a");
354    xmlSerializer.EndElement();
355    ASSERT_STREQ(reinterpret_cast<char*>(pBuffer), "<note>\r\n  <a/>\r\n</note>");
356}
357
358/* @tc.name: AddEmptyElementTest002
359 * @tc.desc: Test whether add an empty element successfully.
360 * @tc.type: FUNC
361 */
362HWTEST_F(NativeEngineTest, AddEmptyElementTest002, testing::ext::TestSize.Level0)
363{
364    napi_env env = (napi_env)engine_;
365    napi_value arrayBuffer = nullptr;
366    void* pBuffer = nullptr;
367    size_t size = 1024;
368    napi_create_arraybuffer(env, size, &pBuffer, &arrayBuffer);
369    OHOS::xml::XmlSerializer xmlSerializer(reinterpret_cast<char*>(pBuffer), size, "utf-8");
370    xmlSerializer.StartElement("note");
371    xmlSerializer.EndElement();
372    xmlSerializer.AddEmptyElement("b");
373    ASSERT_STREQ(reinterpret_cast<char*>(pBuffer), "<note/>\r\n<b/>");
374}
375
376/* @tc.name: AddEmptyElementTest003
377 * @tc.desc: Test whether add an empty element successfully.
378 * @tc.type: FUNC
379 */
380HWTEST_F(NativeEngineTest, AddEmptyElementTest003, testing::ext::TestSize.Level0)
381{
382    napi_env env = (napi_env)engine_;
383    napi_value arrayBuffer = nullptr;
384    void* pBuffer = nullptr;
385    size_t size = 1024;
386    napi_create_arraybuffer(env, size, &pBuffer, &arrayBuffer);
387    OHOS::xml::XmlSerializer xmlSerializer(reinterpret_cast<char*>(pBuffer), size, "utf-8");
388    xmlSerializer.AddEmptyElement("c");
389    xmlSerializer.StartElement("note");
390    xmlSerializer.EndElement();
391    ASSERT_STREQ(reinterpret_cast<char*>(pBuffer), "<c/>\r\n<note/>");
392}
393
394/* @tc.name: AddEmptyElementTest004
395 * @tc.desc: Test whether add an empty element successfully.
396 * @tc.type: FUNC
397 */
398HWTEST_F(NativeEngineTest, AddEmptyElementTest004, testing::ext::TestSize.Level0)
399{
400    napi_env env = (napi_env)engine_;
401    napi_value arrayBuffer = nullptr;
402    void* pBuffer = nullptr;
403    size_t size = 1024;
404    napi_create_arraybuffer(env, size, &pBuffer, &arrayBuffer);
405    OHOS::xml::XmlSerializer xmlSerializer(reinterpret_cast<char*>(pBuffer), size, "utf-8");
406    xmlSerializer.AddEmptyElement("d");
407    ASSERT_STREQ(reinterpret_cast<char*>(pBuffer), "<d/>");
408}
409
410/* @tc.name: AddEmptyElementTest005
411 * @tc.desc: Test whether add an empty element successfully.
412 * @tc.type: FUNC
413 */
414HWTEST_F(NativeEngineTest, AddEmptyElementTest005, testing::ext::TestSize.Level0)
415{
416    napi_env env = (napi_env)engine_;
417    napi_value arrayBuffer = nullptr;
418    void* pBuffer = nullptr;
419    size_t size = 1024;
420    napi_create_arraybuffer(env, size, &pBuffer, &arrayBuffer);
421    OHOS::xml::XmlSerializer xmlSerializer(reinterpret_cast<char*>(pBuffer), size, "utf-8");
422    xmlSerializer.StartElement("note");
423    xmlSerializer.AddEmptyElement("c");
424    xmlSerializer.AddEmptyElement("d");
425    xmlSerializer.EndElement();
426    ASSERT_STREQ(reinterpret_cast<char*>(pBuffer), "<note>\r\n  <c/>\r\n  <d/>\r\n</note>");
427}
428
429/* @tc.name: SetDeclarationTest001
430 * @tc.desc: Test whether write xml declaration with encoding successfully.
431 * @tc.type: FUNC
432 */
433HWTEST_F(NativeEngineTest, SetDeclarationTest001, testing::ext::TestSize.Level0)
434{
435    napi_env env = (napi_env)engine_;
436    napi_value arrayBuffer = nullptr;
437    void* pBuffer = nullptr;
438    size_t size = 1024;
439    napi_create_arraybuffer(env, size, &pBuffer, &arrayBuffer);
440    OHOS::xml::XmlSerializer xmlSerializer(reinterpret_cast<char*>(pBuffer), size, "utf-8");
441    xmlSerializer.SetDeclaration();
442    ASSERT_STREQ(reinterpret_cast<char*>(pBuffer), "<?xml version=\"1.0\" encoding=\"utf-8\"?>");
443}
444
445/* @tc.name: SetDeclarationTest002
446 * @tc.desc: Test whether write xml declaration with encoding successfully.
447 * @tc.type: FUNC
448 */
449HWTEST_F(NativeEngineTest, SetDeclarationTest002, testing::ext::TestSize.Level0)
450{
451    napi_env env = (napi_env)engine_;
452    napi_value arrayBuffer = nullptr;
453    void* pBuffer = nullptr;
454    size_t size = 1024;
455    napi_create_arraybuffer(env, size, &pBuffer, &arrayBuffer);
456    OHOS::xml::XmlSerializer xmlSerializer(reinterpret_cast<char*>(pBuffer), size, "utf-8");
457    xmlSerializer.SetDeclaration();
458    ASSERT_STREQ(reinterpret_cast<char*>(pBuffer), "<?xml version=\"1.0\" encoding=\"utf-8\"?>");
459}
460
461/* @tc.name: SetDeclarationTest003
462 * @tc.desc: Test whether write xml declaration with encoding successfully.
463 * @tc.type: FUNC
464 */
465HWTEST_F(NativeEngineTest, SetDeclarationTest003, testing::ext::TestSize.Level0)
466{
467    napi_env env = (napi_env)engine_;
468    napi_value arrayBuffer = nullptr;
469    void* pBuffer = nullptr;
470    size_t size = 1024;
471    napi_create_arraybuffer(env, size, &pBuffer, &arrayBuffer);
472    OHOS::xml::XmlSerializer xmlSerializer(reinterpret_cast<char*>(pBuffer), size, "utf-8");
473    xmlSerializer.SetDeclaration();
474    ASSERT_STREQ(reinterpret_cast<char*>(pBuffer), "<?xml version=\"1.0\" encoding=\"utf-8\"?>");
475}
476
477/* @tc.name: SetDeclarationTest004
478 * @tc.desc: Test whether write xml declaration with encoding successfully.
479 * @tc.type: FUNC
480 */
481HWTEST_F(NativeEngineTest, SetDeclarationTest004, testing::ext::TestSize.Level0)
482{
483    napi_env env = (napi_env)engine_;
484    napi_value arrayBuffer = nullptr;
485    void* pBuffer = nullptr;
486    size_t size = 1024;
487    napi_create_arraybuffer(env, size, &pBuffer, &arrayBuffer);
488    OHOS::xml::XmlSerializer xmlSerializer(reinterpret_cast<char*>(pBuffer), size, "utf-8");
489    xmlSerializer.SetDeclaration();
490    ASSERT_STREQ(reinterpret_cast<char*>(pBuffer), "<?xml version=\"1.0\" encoding=\"utf-8\"?>");
491}
492
493/* @tc.name: SetDeclarationTest005
494 * @tc.desc: Test whether write xml declaration with encoding successfully.
495 * @tc.type: FUNC
496 */
497HWTEST_F(NativeEngineTest, SetDeclarationTest005, testing::ext::TestSize.Level0)
498{
499    napi_env env = (napi_env)engine_;
500    napi_value arrayBuffer = nullptr;
501    void* pBuffer = nullptr;
502    size_t size = 1024;
503    napi_create_arraybuffer(env, size, &pBuffer, &arrayBuffer);
504    OHOS::xml::XmlSerializer xmlSerializer(reinterpret_cast<char*>(pBuffer), size, "utf-8");
505    xmlSerializer.SetDeclaration();
506    ASSERT_STREQ(reinterpret_cast<char*>(pBuffer), "<?xml version=\"1.0\" encoding=\"utf-8\"?>");
507}
508
509/* @tc.name: EndElementTest001
510 * @tc.desc: Test whether write end tag of the element successfully.
511 * @tc.type: FUNC
512 */
513HWTEST_F(NativeEngineTest, EndElementTest001, testing::ext::TestSize.Level0)
514{
515    napi_env env = (napi_env)engine_;
516    napi_value arrayBuffer = nullptr;
517    void* pBuffer = nullptr;
518    size_t size = 1024;
519    napi_create_arraybuffer(env, size, &pBuffer, &arrayBuffer);
520    OHOS::xml::XmlSerializer xmlSerializer(reinterpret_cast<char*>(pBuffer), size, "utf-8");
521    xmlSerializer.StartElement("note");
522    xmlSerializer.EndElement();
523    ASSERT_STREQ(reinterpret_cast<char*>(pBuffer), "<note/>");
524}
525
526/* @tc.name: EndElementTest002
527 * @tc.desc: Test whether write end tag of the element successfully.
528 * @tc.type: FUNC
529 */
530HWTEST_F(NativeEngineTest, EndElementTest002, testing::ext::TestSize.Level0)
531{
532    napi_env env = (napi_env)engine_;
533    napi_value arrayBuffer = nullptr;
534    void* pBuffer = nullptr;
535    size_t size = 1024;
536    napi_create_arraybuffer(env, size, &pBuffer, &arrayBuffer);
537    OHOS::xml::XmlSerializer xmlSerializer(reinterpret_cast<char*>(pBuffer), size, "utf-8");
538    xmlSerializer.StartElement("note");
539    xmlSerializer.SetAttributes("importance", "high");
540    xmlSerializer.EndElement();
541    ASSERT_STREQ(reinterpret_cast<char*>(pBuffer), "<note importance=\"high\"/>");
542}
543
544/* @tc.name: EndElementTest003
545 * @tc.desc: Test whether write end tag of the element successfully.
546 * @tc.type: FUNC
547 */
548HWTEST_F(NativeEngineTest, EndElementTest003, testing::ext::TestSize.Level0)
549{
550    napi_env env = (napi_env)engine_;
551    napi_value arrayBuffer = nullptr;
552    void* pBuffer = nullptr;
553    size_t size = 1024;
554    napi_create_arraybuffer(env, size, &pBuffer, &arrayBuffer);
555    OHOS::xml::XmlSerializer xmlSerializer(reinterpret_cast<char*>(pBuffer), size, "utf-8");
556    xmlSerializer.StartElement("note");
557    xmlSerializer.SetAttributes("impo", "hi");
558    xmlSerializer.EndElement();
559    ASSERT_STREQ(reinterpret_cast<char*>(pBuffer), "<note impo=\"hi\"/>");
560}
561
562/* @tc.name: EndElementTest004
563 * @tc.desc: Test whether write end tag of the element successfully.
564 * @tc.type: FUNC
565 */
566HWTEST_F(NativeEngineTest, EndElementTest004, testing::ext::TestSize.Level0)
567{
568    napi_env env = (napi_env)engine_;
569    napi_value arrayBuffer = nullptr;
570    void* pBuffer = nullptr;
571    size_t size = 1024;
572    napi_create_arraybuffer(env, size, &pBuffer, &arrayBuffer);
573    OHOS::xml::XmlSerializer xmlSerializer(reinterpret_cast<char*>(pBuffer), size, "utf-8");
574    xmlSerializer.StartElement("note1");
575    xmlSerializer.StartElement("note2");
576    xmlSerializer.EndElement();
577    xmlSerializer.EndElement();
578    ASSERT_STREQ(reinterpret_cast<char*>(pBuffer), "<note1>\r\n  <note2/>\r\n</note1>");
579}
580
581/* @tc.name: EndElementTest005
582 * @tc.desc: Test whether write end tag of the element successfully.
583 * @tc.type: FUNC
584 */
585HWTEST_F(NativeEngineTest, EndElementTest005, testing::ext::TestSize.Level0)
586{
587    napi_env env = (napi_env)engine_;
588    napi_value arrayBuffer = nullptr;
589    void* pBuffer = nullptr;
590    size_t size = 1024;
591    napi_create_arraybuffer(env, size, &pBuffer, &arrayBuffer);
592    OHOS::xml::XmlSerializer xmlSerializer(reinterpret_cast<char*>(pBuffer), size, "utf-8");
593    xmlSerializer.StartElement("note2");
594    xmlSerializer.SetAttributes("importance", "high");
595    xmlSerializer.EndElement();
596    ASSERT_STREQ(reinterpret_cast<char*>(pBuffer), "<note2 importance=\"high\"/>");
597}
598
599/* @tc.name: SetNamespaceTest001
600 * @tc.desc: Test whether write the namespace of the current element tag successfully.
601 * @tc.type: FUNC
602 */
603HWTEST_F(NativeEngineTest, SetNamespaceTest001, testing::ext::TestSize.Level0)
604{
605    napi_env env = (napi_env)engine_;
606    napi_value arrayBuffer = nullptr;
607    void* pBuffer = nullptr;
608    size_t size = 1024;
609    napi_create_arraybuffer(env, size, &pBuffer, &arrayBuffer);
610    OHOS::xml::XmlSerializer xmlSerializer(reinterpret_cast<char*>(pBuffer), size, "utf-8");
611    xmlSerializer.SetDeclaration();
612    xmlSerializer.SetNamespace("h", "http://www.w3.org/TR/html4/");
613    xmlSerializer.StartElement("note");
614    xmlSerializer.EndElement();
615    ASSERT_STREQ(reinterpret_cast<char*>(pBuffer),
616                 "<?xml version=\"1.0\" encoding=\"utf-8\"?>\r\n<h:note xmlns:h=\"http://www.w3.org/TR/html4/\"/>");
617}
618
619/* @tc.name: SetNamespaceTest002
620 * @tc.desc: Test whether write the namespace of the current element tag successfully.
621 * @tc.type: FUNC
622 */
623HWTEST_F(NativeEngineTest, SetNamespaceTest002, testing::ext::TestSize.Level0)
624{
625    napi_env env = (napi_env)engine_;
626    napi_value arrayBuffer = nullptr;
627    void* pBuffer = nullptr;
628    size_t size = 1024;
629    napi_create_arraybuffer(env, size, &pBuffer, &arrayBuffer);
630    OHOS::xml::XmlSerializer xmlSerializer(reinterpret_cast<char*>(pBuffer), size, "utf-8");
631    xmlSerializer.SetDeclaration();
632    xmlSerializer.SetNamespace("b", "http://www.w3.org/TR/html4/");
633    xmlSerializer.StartElement("note");
634    xmlSerializer.EndElement();
635    ASSERT_STREQ(reinterpret_cast<char*>(pBuffer),
636                 "<?xml version=\"1.0\" encoding=\"utf-8\"?>\r\n<b:note xmlns:b=\"http://www.w3.org/TR/html4/\"/>");
637}
638
639/* @tc.name: SetNamespaceTest003
640 * @tc.desc: Test whether write the namespace of the current element tag successfully.
641 * @tc.type: FUNC
642 */
643HWTEST_F(NativeEngineTest, SetNamespaceTest003, testing::ext::TestSize.Level0)
644{
645    napi_env env = (napi_env)engine_;
646    napi_value arrayBuffer = nullptr;
647    void* pBuffer = nullptr;
648    size_t size = 1024;
649    napi_create_arraybuffer(env, size, &pBuffer, &arrayBuffer);
650    OHOS::xml::XmlSerializer xmlSerializer(reinterpret_cast<char*>(pBuffer), size, "utf-8");
651    xmlSerializer.SetDeclaration();
652    xmlSerializer.SetNamespace("h", "http://www.111/");
653    xmlSerializer.StartElement("note");
654    xmlSerializer.EndElement();
655    ASSERT_STREQ(reinterpret_cast<char*>(pBuffer),
656                 "<?xml version=\"1.0\" encoding=\"utf-8\"?>\r\n<h:note xmlns:h=\"http://www.111/\"/>");
657}
658
659/* @tc.name: SetNamespaceTest004
660 * @tc.desc: Test whether write the namespace of the current element tag successfully.
661 * @tc.type: FUNC
662 */
663HWTEST_F(NativeEngineTest, SetNamespaceTest004, testing::ext::TestSize.Level0)
664{
665    napi_env env = (napi_env)engine_;
666    napi_value arrayBuffer = nullptr;
667    void* pBuffer = nullptr;
668    size_t size = 1024;
669    napi_create_arraybuffer(env, size, &pBuffer, &arrayBuffer);
670    OHOS::xml::XmlSerializer xmlSerializer(reinterpret_cast<char*>(pBuffer), size, "utf-8");
671    xmlSerializer.SetDeclaration();
672    xmlSerializer.SetNamespace("h", "http://www.w3.org/TR/html4/");
673    xmlSerializer.StartElement("note1");
674    xmlSerializer.StartElement("note2");
675    xmlSerializer.EndElement();
676    xmlSerializer.EndElement();
677    std::string strPrior = "<?xml version=\"1.0\" encoding=\"utf-8\"?>\r\n";
678    std::string strBack = "<h:note1 xmlns:h=\"http://www.w3.org/TR/html4/\">\r\n  <h:note2/>\r\n</h:note1>";
679    std::string strEnd = strPrior + strBack;
680    ASSERT_STREQ(reinterpret_cast<char*>(pBuffer), strEnd.c_str());
681}
682
683/* @tc.name: SetNamespaceTest005
684 * @tc.desc: Test whether write the namespace of the current element tag successfully.
685 * @tc.type: FUNC
686 */
687HWTEST_F(NativeEngineTest, SetNamespaceTest005, testing::ext::TestSize.Level0)
688{
689    napi_env env = (napi_env)engine_;
690    napi_value arrayBuffer = nullptr;
691    void* pBuffer = nullptr;
692    size_t size = 1024;
693    napi_create_arraybuffer(env, size, &pBuffer, &arrayBuffer);
694    OHOS::xml::XmlSerializer xmlSerializer(reinterpret_cast<char*>(pBuffer), size, "utf-8");
695    xmlSerializer.SetDeclaration();
696    xmlSerializer.SetNamespace("h", "http://www.w3.org/TR/html4/");
697    xmlSerializer.StartElement("note1");
698    xmlSerializer.StartElement("note2");
699    xmlSerializer.EndElement();
700    xmlSerializer.EndElement();
701    std::string strPrior = "<?xml version=\"1.0\" encoding=\"utf-8\"?>\r\n";
702    std::string strBack = "<h:note1 xmlns:h=\"http://www.w3.org/TR/html4/\">\r\n  <h:note2/>\r\n</h:note1>";
703    std::string strEnd = strPrior + strBack;
704    ASSERT_STREQ(reinterpret_cast<char*>(pBuffer), strEnd.c_str());
705}
706
707/* @tc.name: SetCommentTest001
708 * @tc.desc: Test write the comment successfully.
709 * @tc.type: FUNC
710 */
711HWTEST_F(NativeEngineTest, SetCommentTest001, testing::ext::TestSize.Level0)
712{
713    napi_env env = (napi_env)engine_;
714    napi_value arrayBuffer = nullptr;
715    void* pBuffer = nullptr;
716    size_t size = 1024;
717    napi_create_arraybuffer(env, size, &pBuffer, &arrayBuffer);
718    OHOS::xml::XmlSerializer xmlSerializer(reinterpret_cast<char*>(pBuffer), size, "utf-8");
719    xmlSerializer.StartElement("note");
720    xmlSerializer.SetComment("Hi!");
721    xmlSerializer.EndElement();
722    ASSERT_STREQ(reinterpret_cast<char*>(pBuffer), "<note>\r\n  <!--Hi!-->\r\n</note>");
723}
724
725/* @tc.name: SetCommentTest002
726 * @tc.desc: Test write the comment successfully.
727 * @tc.type: FUNC
728 */
729HWTEST_F(NativeEngineTest, SetCommentTest002, testing::ext::TestSize.Level0)
730{
731    napi_env env = (napi_env)engine_;
732    napi_value arrayBuffer = nullptr;
733    void* pBuffer = nullptr;
734    size_t size = 1024;
735    napi_create_arraybuffer(env, size, &pBuffer, &arrayBuffer);
736    OHOS::xml::XmlSerializer xmlSerializer(reinterpret_cast<char*>(pBuffer), size, "utf-8");
737    xmlSerializer.StartElement("note");
738    xmlSerializer.SetComment("Hello, World!");
739    xmlSerializer.EndElement();
740    ASSERT_STREQ(reinterpret_cast<char*>(pBuffer), "<note>\r\n  <!--Hello, World!-->\r\n</note>");
741}
742
743/* @tc.name: SetCommentTest003
744 * @tc.desc: Test write the comment successfully.
745 * @tc.type: FUNC
746 */
747HWTEST_F(NativeEngineTest, SetCommentTest003, testing::ext::TestSize.Level0)
748{
749    napi_env env = (napi_env)engine_;
750    napi_value arrayBuffer = nullptr;
751    void* pBuffer = nullptr;
752    size_t size = 1024;
753    napi_create_arraybuffer(env, size, &pBuffer, &arrayBuffer);
754    OHOS::xml::XmlSerializer xmlSerializer(reinterpret_cast<char*>(pBuffer), size, "utf-8");
755    xmlSerializer.SetComment("Hello, World!");
756    ASSERT_STREQ(reinterpret_cast<char*>(pBuffer), "<!--Hello, World!-->");
757}
758
759/* @tc.name: SetCommentTest004
760 * @tc.desc: Test write the comment successfully.
761 * @tc.type: FUNC
762 */
763HWTEST_F(NativeEngineTest, SetCommentTest004, testing::ext::TestSize.Level0)
764{
765    napi_env env = (napi_env)engine_;
766    napi_value arrayBuffer = nullptr;
767    void* pBuffer = nullptr;
768    size_t size = 1024;
769    napi_create_arraybuffer(env, size, &pBuffer, &arrayBuffer);
770    OHOS::xml::XmlSerializer xmlSerializer(reinterpret_cast<char*>(pBuffer), size, "utf-8");
771    xmlSerializer.SetComment("Hello, World!");
772    ASSERT_STREQ(reinterpret_cast<char*>(pBuffer), "<!--Hello, World!-->");
773}
774
775/* @tc.name: SetCommentTest005
776 * @tc.desc: Test write the comment successfully.
777 * @tc.type: FUNC
778 */
779HWTEST_F(NativeEngineTest, SetCommentTest005, testing::ext::TestSize.Level0)
780{
781    napi_env env = (napi_env)engine_;
782    napi_value arrayBuffer = nullptr;
783    void* pBuffer = nullptr;
784    size_t size = 1024;
785    napi_create_arraybuffer(env, size, &pBuffer, &arrayBuffer);
786    OHOS::xml::XmlSerializer xmlSerializer(reinterpret_cast<char*>(pBuffer), size, "utf-8");
787    xmlSerializer.SetComment("Hello, World!");
788    xmlSerializer.StartElement("note");
789    xmlSerializer.EndElement();
790    ASSERT_STREQ(reinterpret_cast<char*>(pBuffer), "<!--Hello, World!-->\r\n<note/>");
791}
792
793/* @tc.name: Test001
794 * @tc.desc: Test .
795 * @tc.type: FUNC
796 */
797HWTEST_F(NativeEngineTest, SetCDATATest001, testing::ext::TestSize.Level0)
798{
799    napi_env env = (napi_env)engine_;
800    napi_value arrayBuffer = nullptr;
801    void* pBuffer = nullptr;
802    size_t size = 1024;
803    napi_create_arraybuffer(env, size, &pBuffer, &arrayBuffer);
804    OHOS::xml::XmlSerializer xmlSerializer(reinterpret_cast<char*>(pBuffer), size, "utf-8");
805    xmlSerializer.SetCData("root SYSTEM");
806    ASSERT_STREQ(reinterpret_cast<char*>(pBuffer), "<![CDATA[root SYSTEM]]>");
807}
808
809/* @tc.name: SetCDATATest002
810 * @tc.desc: Test whether Writes the CDATA successfully.
811 * @tc.type: FUNC
812 */
813HWTEST_F(NativeEngineTest, SetCDATATest002, testing::ext::TestSize.Level0)
814{
815    napi_env env = (napi_env)engine_;
816    napi_value arrayBuffer = nullptr;
817    void* pBuffer = nullptr;
818    size_t size = 1024;
819    napi_create_arraybuffer(env, size, &pBuffer, &arrayBuffer);
820    OHOS::xml::XmlSerializer xmlSerializer(reinterpret_cast<char*>(pBuffer), size, "utf-8");
821    xmlSerializer.SetCData("root SYSTEM \"http://www.test.org/test.dtd\"");
822    ASSERT_STREQ(reinterpret_cast<char*>(pBuffer), "<![CDATA[root SYSTEM \"http://www.test.org/test.dtd\"]]>");
823}
824
825/* @tc.name: SetCDATATest003
826 * @tc.desc: Test whether Writes the CDATA successfully.
827 * @tc.type: FUNC
828 */
829HWTEST_F(NativeEngineTest, SetCDATATest003, testing::ext::TestSize.Level0)
830{
831    napi_env env = (napi_env)engine_;
832    napi_value arrayBuffer = nullptr;
833    void* pBuffer = nullptr;
834    size_t size = 1024;
835    napi_create_arraybuffer(env, size, &pBuffer, &arrayBuffer);
836    OHOS::xml::XmlSerializer xmlSerializer(reinterpret_cast<char*>(pBuffer), size, "utf-8");
837    xmlSerializer.StartElement("note");
838    xmlSerializer.EndElement();
839    xmlSerializer.SetCData("root SYSTEM \"http://www.test.org/test.dtd\"");
840    ASSERT_STREQ(reinterpret_cast<char*>(pBuffer),
841                 "<note/>\r\n<![CDATA[root SYSTEM \"http://www.test.org/test.dtd\"]]>");
842}
843
844/* @tc.name: SetCDATATest004
845 * @tc.desc: Test whether Writes the CDATA successfully.
846 * @tc.type: FUNC
847 */
848HWTEST_F(NativeEngineTest, SetCDATATest004, testing::ext::TestSize.Level0)
849{
850    napi_env env = (napi_env)engine_;
851    napi_value arrayBuffer = nullptr;
852    void* pBuffer = nullptr;
853    size_t size = 1024;
854    napi_create_arraybuffer(env, size, &pBuffer, &arrayBuffer);
855    OHOS::xml::XmlSerializer xmlSerializer(reinterpret_cast<char*>(pBuffer), size, "utf-8");
856    xmlSerializer.SetCData("root SYSTEM \"http://www.test.org/test.dtd\"");
857    xmlSerializer.StartElement("note");
858    xmlSerializer.EndElement();
859    ASSERT_STREQ(reinterpret_cast<char*>(pBuffer),
860                 "<![CDATA[root SYSTEM \"http://www.test.org/test.dtd\"]]>\r\n<note/>");
861}
862
863/* @tc.name: SetCDATATest005
864 * @tc.desc: Test whether Writes the CDATA successfully.
865 * @tc.type: FUNC
866 */
867HWTEST_F(NativeEngineTest, SetCDATATest005, testing::ext::TestSize.Level0)
868{
869    napi_env env = (napi_env)engine_;
870    napi_value arrayBuffer = nullptr;
871    void* pBuffer = nullptr;
872    size_t size = 1024;
873    napi_create_arraybuffer(env, size, &pBuffer, &arrayBuffer);
874    OHOS::xml::XmlSerializer xmlSerializer(reinterpret_cast<char*>(pBuffer), size, "utf-8");
875    xmlSerializer.StartElement("note");
876    xmlSerializer.SetCData("root SYSTEM \"http://www.test.org/test.dtd\"");
877    xmlSerializer.EndElement();
878    ASSERT_STREQ(reinterpret_cast<char*>(pBuffer),
879                 "<note>\r\n  <![CDATA[root SYSTEM \"http://www.test.org/test.dtd\"]]>\r\n</note>");
880}
881
882/* @tc.name: SetCDATATest006
883 * @tc.desc: Test whether Writes the CDATA successfully.
884 * @tc.type: FUNC
885 */
886HWTEST_F(NativeEngineTest, SetCDATATest006, testing::ext::TestSize.Level0)
887{
888    napi_env env = (napi_env)engine_;
889    napi_value arrayBuffer = nullptr;
890    void* pBuffer = nullptr;
891    size_t size = 1024;
892    napi_create_arraybuffer(env, size, &pBuffer, &arrayBuffer);
893    OHOS::xml::XmlSerializer xmlSerializer(reinterpret_cast<char*>(pBuffer), size, "utf-8");
894    xmlSerializer.SetCData("]]>");
895    ASSERT_STREQ(reinterpret_cast<char*>(pBuffer), "<![CDATA[]]]]><![CDATA[>]]>");
896}
897
898/* @tc.name: SetCDATATest007
899 * @tc.desc: Test whether Writes the CDATA successfully.
900 * @tc.type: FUNC
901 */
902HWTEST_F(NativeEngineTest, SetCDATATest007, testing::ext::TestSize.Level0)
903{
904    napi_env env = (napi_env)engine_;
905    napi_value arrayBuffer = nullptr;
906    void* pBuffer = nullptr;
907    size_t size = 1024;
908    napi_create_arraybuffer(env, size, &pBuffer, &arrayBuffer);
909    OHOS::xml::XmlSerializer xmlSerializer(reinterpret_cast<char*>(pBuffer), size, "utf-8");
910    xmlSerializer.SetCData("<![CDATA[]]>");
911    ASSERT_STREQ(reinterpret_cast<char*>(pBuffer), "<![CDATA[<![CDATA[]]]]><![CDATA[>]]>");
912}
913
914/* @tc.name: SetCDATATest008
915 * @tc.desc: Test whether Writes the CDATA successfully.
916 * @tc.type: FUNC
917 */
918HWTEST_F(NativeEngineTest, SetCDATATest008, testing::ext::TestSize.Level0)
919{
920    napi_env env = (napi_env)engine_;
921    napi_value arrayBuffer = nullptr;
922    void* pBuffer = nullptr;
923    size_t size = 1024;
924    napi_create_arraybuffer(env, size, &pBuffer, &arrayBuffer);
925    OHOS::xml::XmlSerializer xmlSerializer(reinterpret_cast<char*>(pBuffer), size, "utf-8");
926    xmlSerializer.SetCData("]]>]]>");
927    ASSERT_STREQ(reinterpret_cast<char*>(pBuffer), "<![CDATA[]]]]><![CDATA[>]]]]><![CDATA[>]]>");
928}
929
930/* @tc.name: SetTextTest001
931 * @tc.desc: Test whether Writes the text successfully.
932 * @tc.type: FUNC
933 */
934HWTEST_F(NativeEngineTest, SetTextTest001, testing::ext::TestSize.Level0)
935{
936    napi_env env = (napi_env)engine_;
937    napi_value arrayBuffer = nullptr;
938    void* pBuffer = nullptr;
939    size_t size = 1024;
940    napi_create_arraybuffer(env, size, &pBuffer, &arrayBuffer);
941    OHOS::xml::XmlSerializer xmlSerializer(reinterpret_cast<char*>(pBuffer), size, "utf-8");
942    xmlSerializer.StartElement("note");
943    xmlSerializer.SetAttributes("importance", "high");
944    xmlSerializer.SetText("Happy1");
945    xmlSerializer.EndElement();
946    ASSERT_STREQ(reinterpret_cast<char*>(pBuffer), "<note importance=\"high\">Happy1</note>");
947}
948
949/* @tc.name: SetTextTest002
950 * @tc.desc: Test whether Writes the text successfully.
951 * @tc.type: FUNC
952 */
953HWTEST_F(NativeEngineTest, SetTextTest002, testing::ext::TestSize.Level0)
954{
955    napi_env env = (napi_env)engine_;
956    napi_value arrayBuffer = nullptr;
957    void* pBuffer = nullptr;
958    size_t size = 1024;
959    napi_create_arraybuffer(env, size, &pBuffer, &arrayBuffer);
960    OHOS::xml::XmlSerializer xmlSerializer(reinterpret_cast<char*>(pBuffer), size, "utf-8");
961    xmlSerializer.StartElement("note");
962    xmlSerializer.SetAttributes("importance", "high");
963    xmlSerializer.SetText("Happy2");
964    xmlSerializer.EndElement();
965    ASSERT_STREQ(reinterpret_cast<char*>(pBuffer), "<note importance=\"high\">Happy2</note>");
966}
967
968/* @tc.name: SetTextTest003
969 * @tc.desc: Test whether Writes the text successfully.
970 * @tc.type: FUNC
971 */
972HWTEST_F(NativeEngineTest, SetTextTest003, testing::ext::TestSize.Level0)
973{
974    napi_env env = (napi_env)engine_;
975    napi_value arrayBuffer = nullptr;
976    void* pBuffer = nullptr;
977    size_t size = 1024;
978    napi_create_arraybuffer(env, size, &pBuffer, &arrayBuffer);
979    OHOS::xml::XmlSerializer xmlSerializer(reinterpret_cast<char*>(pBuffer), size, "utf-8");
980    xmlSerializer.StartElement("note");
981    xmlSerializer.SetAttributes("importance", "high");
982    xmlSerializer.SetText("Happy3");
983    xmlSerializer.EndElement();
984    ASSERT_STREQ(reinterpret_cast<char*>(pBuffer), "<note importance=\"high\">Happy3</note>");
985}
986
987/* @tc.name: SetTextTest004
988 * @tc.desc: Test whether Writes the text successfully.
989 * @tc.type: FUNC
990 */
991HWTEST_F(NativeEngineTest, SetTextTest004, testing::ext::TestSize.Level0)
992{
993    napi_env env = (napi_env)engine_;
994    napi_value arrayBuffer = nullptr;
995    void* pBuffer = nullptr;
996    size_t size = 1024;
997    napi_create_arraybuffer(env, size, &pBuffer, &arrayBuffer);
998    OHOS::xml::XmlSerializer xmlSerializer(reinterpret_cast<char*>(pBuffer), size, "utf-8");
999    xmlSerializer.StartElement("note");
1000    xmlSerializer.SetAttributes("importance", "high");
1001    xmlSerializer.SetText("Happy4");
1002    xmlSerializer.EndElement();
1003    ASSERT_STREQ(reinterpret_cast<char*>(pBuffer), "<note importance=\"high\">Happy4</note>");
1004}
1005
1006/* @tc.name: SetTextTest005
1007 * @tc.desc: Test whether Writes the text successfully.
1008 * @tc.type: FUNC
1009 */
1010HWTEST_F(NativeEngineTest, SetTextTest005, testing::ext::TestSize.Level0)
1011{
1012    napi_env env = (napi_env)engine_;
1013    napi_value arrayBuffer = nullptr;
1014    void* pBuffer = nullptr;
1015    size_t size = 1024;
1016    napi_create_arraybuffer(env, size, &pBuffer, &arrayBuffer);
1017    OHOS::xml::XmlSerializer xmlSerializer(reinterpret_cast<char*>(pBuffer), size, "utf-8");
1018    xmlSerializer.StartElement("note");
1019    xmlSerializer.SetAttributes("importance", "high");
1020    xmlSerializer.SetText("Happy5");
1021    xmlSerializer.EndElement();
1022    ASSERT_STREQ(reinterpret_cast<char*>(pBuffer), "<note importance=\"high\">Happy5</note>");
1023}
1024/* @tc.name: SetDocTypeTest001
1025 * @tc.desc: Test whether rites the DOCTYPE successfully.
1026 * @tc.type: FUNC
1027 */
1028HWTEST_F(NativeEngineTest, SetDocTypeTest001, testing::ext::TestSize.Level0)
1029{
1030    napi_env env = (napi_env)engine_;
1031    napi_value arrayBuffer = nullptr;
1032    void* pBuffer = nullptr;
1033    size_t size = 1024;
1034    napi_create_arraybuffer(env, size, &pBuffer, &arrayBuffer);
1035    OHOS::xml::XmlSerializer xmlSerializer(reinterpret_cast<char*>(pBuffer), size, "utf-8");
1036    xmlSerializer.SetDocType("root SYSTEM");
1037    ASSERT_STREQ(reinterpret_cast<char*>(pBuffer), "<!DOCTYPE root SYSTEM>");
1038}
1039/* @tc.name: SetDocTypeTest002
1040 * @tc.desc: Test whether rites the DOCTYPE successfully.
1041 * @tc.type: FUNC
1042 */
1043HWTEST_F(NativeEngineTest, SetDocTypeTest002, testing::ext::TestSize.Level0)
1044{
1045    napi_env env = (napi_env)engine_;
1046    napi_value arrayBuffer = nullptr;
1047    void* pBuffer = nullptr;
1048    size_t size = 1024;
1049    napi_create_arraybuffer(env, size, &pBuffer, &arrayBuffer);
1050    OHOS::xml::XmlSerializer xmlSerializer(reinterpret_cast<char*>(pBuffer), size, "utf-8");
1051    xmlSerializer.SetDocType("root SYSTEM \"http://www.test.org/test.dtd\"");
1052    ASSERT_STREQ(reinterpret_cast<char*>(pBuffer), "<!DOCTYPE root SYSTEM \"http://www.test.org/test.dtd\">");
1053}
1054
1055/* @tc.name: SetDocTypeTest003
1056 * @tc.desc: Test whether rites the DOCTYPE successfully.
1057 * @tc.type: FUNC
1058 */
1059HWTEST_F(NativeEngineTest, SetDocTypeTest003, testing::ext::TestSize.Level0)
1060{
1061    napi_env env = (napi_env)engine_;
1062    napi_value arrayBuffer = nullptr;
1063    void* pBuffer = nullptr;
1064    size_t size = 1024;
1065    napi_create_arraybuffer(env, size, &pBuffer, &arrayBuffer);
1066    OHOS::xml::XmlSerializer xmlSerializer(reinterpret_cast<char*>(pBuffer), size, "utf-8");
1067    xmlSerializer.StartElement("note");
1068    xmlSerializer.EndElement();
1069    xmlSerializer.SetDocType("root SYSTEM \"http://www.test.org/test.dtd\"");
1070    ASSERT_STREQ(reinterpret_cast<char*>(pBuffer),
1071                 "<note/>\r\n<!DOCTYPE root SYSTEM \"http://www.test.org/test.dtd\">");
1072}
1073
1074/* @tc.name: SetDocTypeTest004
1075 * @tc.desc: Test whether rites the DOCTYPE successfully.
1076 * @tc.type: FUNC
1077 */
1078HWTEST_F(NativeEngineTest, SetDocTypeTest004, testing::ext::TestSize.Level0)
1079{
1080    napi_env env = (napi_env)engine_;
1081    napi_value arrayBuffer = nullptr;
1082    void* pBuffer = nullptr;
1083    size_t size = 1024;
1084    napi_create_arraybuffer(env, size, &pBuffer, &arrayBuffer);
1085    OHOS::xml::XmlSerializer xmlSerializer(reinterpret_cast<char*>(pBuffer), size, "utf-8");
1086    xmlSerializer.SetDocType("root SYSTEM \"http://www.test.org/test.dtd\"");
1087    xmlSerializer.StartElement("note");
1088    xmlSerializer.EndElement();
1089    ASSERT_STREQ(reinterpret_cast<char*>(pBuffer),
1090                 "<!DOCTYPE root SYSTEM \"http://www.test.org/test.dtd\">\r\n<note/>");
1091}
1092
1093/* @tc.name: SetDocTypeTest005
1094 * @tc.desc: Test whether rites the DOCTYPE successfully.
1095 * @tc.type: FUNC
1096 */
1097HWTEST_F(NativeEngineTest, SetDocTypeTest005, testing::ext::TestSize.Level0)
1098{
1099    napi_env env = (napi_env)engine_;
1100    napi_value arrayBuffer = nullptr;
1101    void* pBuffer = nullptr;
1102    size_t size = 1024;
1103    napi_create_arraybuffer(env, size, &pBuffer, &arrayBuffer);
1104    OHOS::xml::XmlSerializer xmlSerializer(reinterpret_cast<char*>(pBuffer), size, "utf-8");
1105    xmlSerializer.StartElement("note");
1106    xmlSerializer.SetDocType("root SYSTEM \"http://www.test.org/test.dtd\"");
1107    xmlSerializer.EndElement();
1108    ASSERT_STREQ(reinterpret_cast<char*>(pBuffer),
1109                 "<note>\r\n  <!DOCTYPE root SYSTEM \"http://www.test.org/test.dtd\">\r\n</note>");
1110}
1111
1112/* @tc.name: XmlParseTest001
1113 * @tc.desc: To XML text to JavaScript object.
1114 * @tc.type: FUNC
1115 */
1116HWTEST_F(NativeEngineTest, XmlParseTest001, testing::ext::TestSize.Level0)
1117{
1118    napi_env env = (napi_env)engine_;
1119    std::string str1 = "<?xml version=\"1.0\" encoding=\"utf-8\"?><!DOCTYPE note [\n<!ENTITY foo \"baa\">]>";
1120    std::string str2 = "<note importance=\"high\" logged=\"true\">";
1121    std::string str3 = "<![CDATA[\r\nfuncrion matchwo(a,6)\r\n{\r\nreturn 1;\r\n}\r\n]]>";
1122    std::string str4 = "<!--Hello, World!--> <company>John &amp; Hans</company> <title>Happy</title>";
1123    std::string str5 = "<title>Happy</title> <todo>Work</todo> <todo>Play</todo> <?go there?>";
1124    std::string str6 = "<a><b/></a> <h:table xmlns:h=\"http://www.w3.org/TR/html4/\"> <h:tr>";
1125    std::string str7 = "<h:td>Apples</h:td> <h:td>Bananas</h:td> </h:tr>";
1126    std::string str8 = "</h:table></note>";
1127    std::string strXml = str1 + str2 + str3 + str4 + str5 + str6 + str7 + str8;
1128    g_testStr = "";
1129    OHOS::xml::XmlPullParser xmlPullParser(env, strXml, "utf-8");
1130    napi_value options = nullptr;
1131    napi_create_object(env, &options);
1132    const char* key1 = "supportDoctype";
1133    const char* key2 = "ignoreNameSpace";
1134    const char* key3 = "tagValueCallbackFunction";
1135    napi_value object = nullptr;
1136    napi_create_object(env, &object);
1137    napi_value value1 = nullptr;
1138    napi_value value2 = nullptr;
1139    napi_get_boolean(env, true, &value1);
1140    napi_get_boolean(env, false, &value2);
1141    napi_value value3 = nullptr;
1142    std::string cbName = "Method";
1143    napi_create_function(env, cbName.c_str(), cbName.size(), Method, nullptr, &value3);
1144    napi_set_named_property(env, object, key1, value1);
1145    napi_set_named_property(env, object, key2, value2);
1146    napi_set_named_property(env, object, key3, value3);
1147    xmlPullParser.DealOptionInfo(env, object);
1148    xmlPullParser.Parse(env, options);
1149    std::string res1 = " note [\n<!ENTITY foo \"baa\">]note\r\nfuncrion matchwo(a,6)\r\n{\r\nreturn 1;\r\n}\r\n";
1150    std::string res2 = "Hello, World! companyJohn & Hanscompany titleHappytitletitleHappytitle";
1151    std::string res3 = " todoWorktodo todoPlaytodo go thereabba table trtdApplestd tdBananastd trtablenote";
1152    std::string result = res1 + res2 + res3;
1153    ASSERT_STREQ(g_testStr.c_str(), result.c_str());
1154}
1155
1156/* @tc.name: XmlParseTest002
1157 * @tc.desc: To XML text to JavaScript object.
1158 * @tc.type: FUNC
1159 */
1160HWTEST_F(NativeEngineTest, XmlParseTest002, testing::ext::TestSize.Level0)
1161{
1162    napi_env env = (napi_env)engine_;
1163    std::string str1 = "<?xml version=\"1.0\" encoding=\"utf-8\"?><!DOCTYPE note [\n<!ENTITY foo \"baa\">]>";
1164    std::string str2 = "<note importance=\"high\" logged=\"true\">";
1165    std::string str3 = "    <![CDATA[\r\nfuncrion matchwo(a,6)\r\n{\r\nreturn 1;\r\n}\r\n]]>";
1166    std::string str4 = "    <!--Hello, World!-->    <company>John &amp; Hans</company>    <title>Happy</title>";
1167    std::string str5 = "    <title>Happy</title>    <todo>Work</todo>    <todo>Play</todo>    <?go there?>";
1168    std::string str6 = "    <a><b/></a>    <h:table xmlns:h=\"http://www.w3.org/TR/html4/\">        <h:tr>";
1169    std::string str7 = "            <h:td>Apples</h:td>            <h:td>Bananas</h:td>        </h:tr>";
1170    std::string str8 = "    </h:table></note>";
1171    std::string strXml = str1 + str2 + str3 + str4 + str5 + str6 + str7 + str8;
1172    g_testStr = "";
1173    OHOS::xml::XmlPullParser xmlPullParser(env, strXml, "utf-8");
1174    napi_value options = nullptr;
1175    napi_create_object(env, &options);
1176    const char* key1 = "supportDoctype";
1177    const char* key2 = "ignoreNameSpace";
1178    const char* key3 = "attributeValueCallbackFunction";
1179    napi_value object = nullptr;
1180    napi_create_object(env, &object);
1181    napi_value value1 = nullptr;
1182    napi_value value2 = nullptr;
1183    napi_get_boolean(env, false, &value1);
1184    napi_get_boolean(env, true, &value2);
1185    napi_value value3 = nullptr;
1186    std::string cbName = "Method";
1187    napi_create_function(env, cbName.c_str(), cbName.size(), Method, nullptr, &value3);
1188    napi_set_named_property(env, object, key1, value1);
1189    napi_set_named_property(env, object, key2, value2);
1190    napi_set_named_property(env, object, key3, value3);
1191    xmlPullParser.DealOptionInfo(env, object);
1192    xmlPullParser.Parse(env, options);
1193    ASSERT_STREQ(g_testStr.c_str(), "importancehighloggedtruexmlns:hhttp://www.w3.org/TR/html4/");
1194}
1195
1196/* @tc.name: XmlParseTest003
1197 * @tc.desc: To XML text to JavaScript object.
1198 * @tc.type: FUNC
1199 */
1200HWTEST_F(NativeEngineTest, XmlParseTest003, testing::ext::TestSize.Level0)
1201{
1202    napi_env env = (napi_env)engine_;
1203    std::string str1 = "<?xml version=\"1.0\" encoding=\"utf-8\"?><!DOCTYPE note [\n<!ENTITY foo \"baa\">]>";
1204    std::string str2 = "<note importance=\"high\" logged=\"true\">";
1205    std::string str3 = "<![CDATA[\r\nfuncrion matchwo(a,6)\r\n{\r\nreturn 1;\r\n}\r\n]]>";
1206    std::string str4 = "<!--Hello, World!--> <company>John &amp; Hans</company> <title>Happy</title>";
1207    std::string str5 = "<title>Happy</title> <todo>Work</todo> <todo>Play</todo> <?go there?>";
1208    std::string str6 = "<a><b/></a> <h:table xmlns:h=\"http://www.w3.org/TR/html4/\"> <h:tr>";
1209    std::string str7 = "<h:td>Apples</h:td> <h:td>Bananas</h:td> </h:tr>";
1210    std::string str8 = "</h:table></note>";
1211    std::string strXml = str1 + str2 + str3 + str4 + str5 + str6 + str7 + str8;
1212    g_testStr = "";
1213    OHOS::xml::XmlPullParser xmlPullParser(env, strXml, "utf-8");
1214    napi_value options = nullptr;
1215    napi_create_object(env, &options);
1216    const char* key1 = "supportDoctype";
1217    const char* key2 = "ignoreNameSpace";
1218    const char* key3 = "tagValueCallbackFunction";
1219    napi_value object = nullptr;
1220    napi_create_object(env, &object);
1221    napi_value value1 = nullptr;
1222    napi_value value2 = nullptr;
1223    napi_get_boolean(env, false, &value1);
1224    napi_get_boolean(env, true, &value2);
1225    napi_value value3 = nullptr;
1226    std::string cbName = "Method";
1227    napi_create_function(env, cbName.c_str(), cbName.size(), Method, nullptr, &value3);
1228    napi_set_named_property(env, object, key1, value1);
1229    napi_set_named_property(env, object, key2, value2);
1230    napi_set_named_property(env, object, key3, value3);
1231    xmlPullParser.DealOptionInfo(env, object);
1232    xmlPullParser.Parse(env, options);
1233    std::string res1 = "note\r\nfuncrion matchwo(a,6)\r\n{\r\nreturn 1;\r\n}\r\nHello, World! companyJohn &";
1234    std::string res2 = " Hanscompany titleHappytitletitleHappytitle todoWorktodo todoPlaytodo go thereabba h:table";
1235    std::string res3 = " h:trh:tdApplesh:td h:tdBananash:td h:trh:tablenote";
1236    std::string result = res1 + res2 + res3;
1237    ASSERT_STREQ(g_testStr.c_str(), result.c_str());
1238}
1239
1240/* @tc.name: XmlParseTest004
1241 * @tc.desc: To XML text to JavaScript object.
1242 * @tc.type: FUNC
1243 */
1244HWTEST_F(NativeEngineTest, XmlParseTest004, testing::ext::TestSize.Level0)
1245{
1246    napi_env env = (napi_env)engine_;
1247    std::string str1 = "<?xml version=\"1.0\" encoding=\"utf-8\"?><!DOCTYPE note [\n<!ENTITY foo \"baa\">]>";
1248    std::string str2 = "<note importance=\"high\" logged=\"true\">";
1249    std::string str3 = "    <![CDATA[\r\nfuncrion matchwo(a,6)\r\n{\r\nreturn 1;\r\n}\r\n]]>";
1250    std::string str4 = "    <!--Hello, World!-->    <company>John &amp; Hans</company>    <title>Happy</title>";
1251    std::string str5 = "    <title>Happy</title>    <todo>Work</todo>    <todo>Play</todo>    <?go there?>";
1252    std::string str6 = "    <a><b/></a>    <h:table xmlns:h=\"http://www.w3.org/TR/html4/\">        <h:tr>";
1253    std::string str7 = "            <h:td>Apples</h:td>            <h:td>Bananas</h:td>        </h:tr>";
1254    std::string str8 = "    </h:table></note>";
1255    std::string strXml = str1 + str2 + str3 + str4 + str5 + str6 + str7 + str8;
1256    g_testStr = "";
1257    OHOS::xml::XmlPullParser xmlPullParser(env, strXml, "utf-8");
1258    napi_value options = nullptr;
1259    napi_create_object(env, &options);
1260    const char* key1 = "supportDoctype";
1261    const char* key2 = "ignoreNameSpace";
1262    const char* key3 = "attributeValueCallbackFunction";
1263    napi_value object = nullptr;
1264    napi_create_object(env, &object);
1265    napi_value value1 = nullptr;
1266    napi_value value2 = nullptr;
1267    napi_get_boolean(env, true, &value1);
1268    napi_get_boolean(env, true, &value2);
1269    napi_value value3 = nullptr;
1270    std::string cbName = "Method";
1271    napi_create_function(env, cbName.c_str(), cbName.size(), Method, nullptr, &value3);
1272    napi_set_named_property(env, object, key1, value1);
1273    napi_set_named_property(env, object, key2, value2);
1274    napi_set_named_property(env, object, key3, value3);
1275    xmlPullParser.DealOptionInfo(env, object);
1276    xmlPullParser.Parse(env, options);
1277    ASSERT_STREQ(g_testStr.c_str(), "importancehighloggedtruexmlns:hhttp://www.w3.org/TR/html4/");
1278}
1279
1280/* @tc.name: XmlParseTest005
1281 * @tc.desc: To XML text to JavaScript object.
1282 * @tc.type: FUNC
1283 */
1284HWTEST_F(NativeEngineTest, XmlParseTest005, testing::ext::TestSize.Level0)
1285{
1286    napi_env env = (napi_env)engine_;
1287    std::string str1 = "<?xml version=\"1.0\" encoding=\"utf-8\"?><!DOCTYPE note [\n<!ENTITY foo \"baa\">]>";
1288    std::string str2 = "<note importance=\"high\" logged=\"true\">";
1289    std::string str3 = "<![CDATA[\r\nfuncrion matchwo(a,6)\r\n{\r\nreturn 1;\r\n}\r\n]]>";
1290    std::string str4 = "<!--Hello, World!--> <company>John &amp; Hans</company> <title>Happy</title>";
1291    std::string str5 = "<title>Happy</title> <todo>Work</todo> <todo>Play</todo> <?go there?>";
1292    std::string str6 = "<a><b/></a> <h:table xmlns:h=\"http://www.w3.org/TR/html4/\"> <h:tr>";
1293    std::string str7 = "<h:td>Apples</h:td> <h:td>Bananas</h:td> </h:tr>";
1294    std::string str8 = "</h:table></note>";
1295    std::string strXml = str1 + str2 + str3 + str4 + str5 + str6 + str7 + str8;
1296    g_testStr = "";
1297    OHOS::xml::XmlPullParser xmlPullParser(env, strXml, "utf-8");
1298    napi_value options = nullptr;
1299    napi_create_object(env, &options);
1300    const char* key1 = "supportDoctype";
1301    const char* key2 = "ignoreNameSpace";
1302    const char* key3 = "tagValueCallbackFunction";
1303    napi_value object = nullptr;
1304    napi_create_object(env, &object);
1305    napi_value value1 = nullptr;
1306    napi_value value2 = nullptr;
1307    napi_get_boolean(env, true, &value1);
1308    napi_get_boolean(env, true, &value2);
1309    napi_value value3 = nullptr;
1310    std::string cbName = "Method";
1311    napi_create_function(env, cbName.c_str(), cbName.size(), Method, nullptr, &value3);
1312    napi_set_named_property(env, object, key1, value1);
1313    napi_set_named_property(env, object, key2, value2);
1314    napi_set_named_property(env, object, key3, value3);
1315    xmlPullParser.DealOptionInfo(env, object);
1316    xmlPullParser.Parse(env, options);
1317    std::string res1 = " note [\n<!ENTITY foo \"baa\">]note\r\nfuncrion matchwo(a,6)\r\n{\r\nreturn 1;\r\n}\r\n";
1318    std::string res2 = "Hello, World! companyJohn & Hanscompany titleHappytitletitleHappytitle todoWorktodo";
1319    std::string res3 = " todoPlaytodo go thereabba h:table h:trh:tdApplesh:td h:tdBananash:td h:trh:tablenote";
1320    std::string result = res1 + res2 + res3;
1321    ASSERT_STREQ(g_testStr.c_str(), result.c_str());
1322}
1323
1324/* @tc.name: XmlParseTest006
1325 * @tc.desc: To XML text to JavaScript object.
1326 * @tc.type: FUNC
1327 */
1328HWTEST_F(NativeEngineTest, XmlParseTest006, testing::ext::TestSize.Level0)
1329{
1330    napi_env env = (napi_env)engine_;
1331    std::string str1 = "<?xml version=\"1.0\" encoding=\"utf-8\"?><!DOCTYPE note [\n<!ENTITY foo \"baa\">]>";
1332    std::string str2 = "<note importance=\"high\" logged=\"true\">";
1333    std::string str3 = "<![CDATA[\r\nfuncrion matchwo(a,6)\r\n{\r\nreturn 1;\r\n}\r\n]]>";
1334    std::string str4 = "<!--Hello, World!--> <company>John &amp; Hans</company> <title>Happy</title>";
1335    std::string str5 = "<title>Happy</title> <todo>Work</todo> <todo>Play</todo> <?go there?>";
1336    std::string str6 = "<a><b/></a> <h:table xmlns:h=\"http://www.w3.org/TR/html4/\"> <h:tr>";
1337    std::string str7 = "<h:td>Apples</h:td> <h:td>Bananas</h:td> </h:tr>";
1338    std::string str8 = "</h:table></note>";
1339    std::string strXml = str1 + str2 + str3 + str4 + str5 + str6 + str7 + str8;
1340    OHOS::xml::XmlPullParser xmlPullParser(env, strXml, "utf-8");
1341    napi_value options = nullptr;
1342    napi_create_object(env, &options);
1343    const char* key1 = "supportDoctype";
1344    const char* key2 = "ignoreNameSpace";
1345    const char* key3 = "tokenValueCallbackFunction";
1346    napi_value object = nullptr;
1347    napi_create_object(env, &object);
1348    napi_value value1 = nullptr;
1349    napi_value value2 = nullptr;
1350    napi_get_boolean(env, true, &value1);
1351    napi_get_boolean(env, true, &value2);
1352    napi_value value3 = nullptr;
1353    std::string cbName = "TokenValueCallbackFunction";
1354    napi_create_function(env, cbName.c_str(), cbName.size(), TokenValueCallbackFunction, nullptr, &value3);
1355    napi_set_named_property(env, object, key1, value1);
1356    napi_set_named_property(env, object, key2, value2);
1357    napi_set_named_property(env, object, key3, value3);
1358    xmlPullParser.DealOptionInfo(env, object);
1359    xmlPullParser.Parse(env, options);
1360    std::string res1 = " note [\n<!ENTITY foo \"baa\">]note\r\nfuncrion matchwo(a,6)\r\n{\r\nreturn 1;\r\n}\r\n";
1361    std::string res2 = "Hello, World! companyJohn & Hanscompany titleHappytitletitleHappytitle todoWorktodo";
1362    std::string res3 = " todoPlaytodo go thereabba h:table h:trh:tdApplesh:td h:tdBananash:td h:trh:tablenote";
1363    std::string result = res1 + res2 + res3;
1364    ASSERT_STREQ(g_testStr.c_str(), result.c_str());
1365}
1366
1367/* @tc.name: XmlParseTest007
1368 * @tc.desc: To XML text to JavaScript object.
1369 * @tc.type: FUNC
1370 */
1371HWTEST_F(NativeEngineTest, XmlParseTest007, testing::ext::TestSize.Level0)
1372{
1373    napi_env env = (napi_env)engine_;
1374    std::string str1 = "<?xml version=\"1.0\" encoding=\"utf-8\"?>";
1375    std::string str2 = "<note importance=\"high\" logged=\"true\">";
1376    std::string str3 = "    <![CDATA[\r\nfuncrion matchwo(a,6)\r\n{\r\nreturn 1;\r\n}\r\n]]>";
1377    std::string str4 = "    <!--Hello, World!-->    <company>John &amp; Hans</company>    <title>Happy</title>";
1378    std::string str5 = "    <title>Happy</title>    <todo>Work</todo>    <todo>Play</todo>    <?go there?>";
1379    std::string str6 = "    <a><b/></a>    <h:table xmlns:h=\"http://www.w3.org/TR/html4/\">        <h:tr>";
1380    std::string str7 = "            <h:td>Apples</h:td>            <h:td>Bananas</h:td>        </h:tr>";
1381    std::string str8 = "    </h:table></note>";
1382    std::string strXml = str1 + str2 + str3 + str4 + str5 + str6 + str7 + str8;
1383    g_testStr = "";
1384    OHOS::xml::XmlPullParser xmlPullParser(env, strXml, "utf-8");
1385    napi_value options = nullptr;
1386    napi_create_object(env, &options);
1387    const char* key1 = "supportDoctype";
1388    const char* key2 = "ignoreNameSpace";
1389    const char* key3 = "attributeValueCallbackFunction";
1390    napi_value object = nullptr;
1391    napi_create_object(env, &object);
1392    napi_value value1 = nullptr;
1393    napi_value value2 = nullptr;
1394    napi_get_boolean(env, true, &value1);
1395    napi_get_boolean(env, true, &value2);
1396    napi_value value3 = nullptr;
1397    std::string cbName = "Method";
1398    napi_create_function(env, cbName.c_str(), cbName.size(), Method, nullptr, &value3);
1399    napi_set_named_property(env, object, key1, value1);
1400    napi_set_named_property(env, object, key2, value2);
1401    napi_set_named_property(env, object, key3, value3);
1402    xmlPullParser.DealOptionInfo(env, object);
1403    xmlPullParser.Parse(env, options);
1404    ASSERT_STREQ(g_testStr.c_str(), "importancehighloggedtruexmlns:hhttp://www.w3.org/TR/html4/");
1405}
1406
1407/* @tc.name: XmlParseTest008
1408 * @tc.desc: To XML text to JavaScript object.
1409 * @tc.type: FUNC
1410 */
1411HWTEST_F(NativeEngineTest, XmlParseTest008, testing::ext::TestSize.Level0)
1412{
1413    napi_env env = (napi_env)engine_;
1414    std::string str1 = "<?xml version=\"1.0\" encoding=\"utf-8\"?>";
1415    std::string str2 = "<note importance=\"high\" logged=\"true\">";
1416    std::string str3 = "<![CDATA[\r\nfuncrion matchwo(a,6)\r\n{\r\nreturn 1;\r\n}\r\n]]>";
1417    std::string str4 = "<!--Hello, World!--> <company>John &amp; Hans</company> <title>Happy</title>";
1418    std::string str5 = "<title>Happy</title> <todo>Work</todo> <todo>Play</todo> <?go there?>";
1419    std::string str6 = "<a><b/></a> <h:table xmlns:h=\"http://www.w3.org/TR/html4/\"> <h:tr>";
1420    std::string str7 = "<h:td>Apples</h:td> <h:td>Bananas</h:td> </h:tr>";
1421    std::string str8 = "</h:table></note>";
1422    std::string strXml = str1 + str2 + str3 + str4 + str5 + str6 + str7 + str8;
1423    g_testStr = "";
1424    OHOS::xml::XmlPullParser xmlPullParser(env, strXml, "utf-8");
1425    napi_value options = nullptr;
1426    napi_create_object(env, &options);
1427    const char* key1 = "supportDoctype";
1428    const char* key2 = "ignoreNameSpace";
1429    const char* key3 = "tagValueCallbackFunction";
1430    napi_value object = nullptr;
1431    napi_create_object(env, &object);
1432    napi_value value1 = nullptr;
1433    napi_value value2 = nullptr;
1434    napi_get_boolean(env, true, &value1);
1435    napi_get_boolean(env, true, &value2);
1436    napi_value value3 = nullptr;
1437    std::string cbName = "Method";
1438    napi_create_function(env, cbName.c_str(), cbName.size(), Method, nullptr, &value3);
1439    napi_set_named_property(env, object, key1, value1);
1440    napi_set_named_property(env, object, key2, value2);
1441    napi_set_named_property(env, object, key3, value3);
1442    xmlPullParser.DealOptionInfo(env, object);
1443    xmlPullParser.Parse(env, options);
1444    std::string res1 = "note\r\nfuncrion matchwo(a,6)\r\n{\r\nreturn 1;\r\n}\r\nHello, World! companyJohn &";
1445    std::string res2 = " Hanscompany titleHappytitletitleHappytitle todoWorktodo todoPlaytodo go thereabba h:table ";
1446    std::string res3 = "h:trh:tdApplesh:td h:tdBananash:td h:trh:tablenote";
1447    std::string result = res1 + res2 + res3;
1448    ASSERT_STREQ(g_testStr.c_str(), result.c_str());
1449}
1450
1451/* @tc.name: XmlParseTest009
1452 * @tc.desc: To XML text to JavaScript object.
1453 * @tc.type: FUNC
1454 */
1455HWTEST_F(NativeEngineTest, XmlParseTest009, testing::ext::TestSize.Level0)
1456{
1457    napi_env env = (napi_env)engine_;
1458    std::string str1 = "<?xml version=\"1.0\" encoding=\"utf-8\"?>";
1459    std::string str2 = "<note importance=\"high\" logged=\"true\">";
1460    std::string str3 = "<![CDATA[\r\nfuncrion matchwo(a,6)\r\n{\r\nreturn 1;\r\n}\r\n]]>";
1461    std::string str4 = "<!--Hello, World!--> <company>John &amp; Hans</company> <title>Happy</title>";
1462    std::string str5 = "<title>Happy</title> <todo>Work</todo> <todo>Play</todo> <?go there?>";
1463    std::string str6 = "<a><b/></a> <h:table xmlns:h=\"http://www.w3.org/TR/html4/\"> <h:tr>";
1464    std::string str7 = "<h:td>Apples</h:td> <h:td>Bananas</h:td> </h:tr>";
1465    std::string str8 = "</h:table></note>";
1466    std::string strXml = str1 + str2 + str3 + str4 + str5 + str6 + str7 + str8;
1467    OHOS::xml::XmlPullParser xmlPullParser(env, strXml, "utf-8");
1468    napi_value options = nullptr;
1469    napi_create_object(env, &options);
1470    const char* key1 = "supportDoctype";
1471    const char* key2 = "ignoreNameSpace";
1472    const char* key3 = "tokenValueCallbackFunction";
1473    napi_value object = nullptr;
1474    napi_create_object(env, &object);
1475    napi_value value1 = nullptr;
1476    napi_value value2 = nullptr;
1477    napi_get_boolean(env, true, &value1);
1478    napi_get_boolean(env, true, &value2);
1479    napi_value value3 = nullptr;
1480    std::string cbName = "TokenValueCallbackFunc";
1481    napi_create_function(env, cbName.c_str(), cbName.size(), TokenValueCallbackFunc, nullptr, &value3);
1482    napi_set_named_property(env, object, key1, value1);
1483    napi_set_named_property(env, object, key2, value2);
1484    napi_set_named_property(env, object, key3, value3);
1485    xmlPullParser.DealOptionInfo(env, object);
1486    xmlPullParser.Parse(env, options);
1487    std::string res1 = "note\r\nfuncrion matchwo(a,6)\r\n{\r\nreturn 1;\r\n}\r\nHello, World! companyJohn &";
1488    std::string res2 = " Hanscompany titleHappytitletitleHappytitle todoWorktodo todoPlaytodo go thereabba h:table";
1489    std::string res3 = " h:trh:tdApplesh:td h:tdBananash:td h:trh:tablenote";
1490    std::string result = res1 + res2 + res3;
1491    ASSERT_STREQ(g_testStr.c_str(), result.c_str());
1492}
1493
1494/* @tc.name: XmlParseTest0010
1495 * @tc.desc: To XML text to JavaScript object.
1496 * @tc.type: FUNC
1497 */
1498HWTEST_F(NativeEngineTest, XmlParseTest0010, testing::ext::TestSize.Level0)
1499{
1500    napi_env env = (napi_env)engine_;
1501    std::string str1 = "<?xml version=\"1.0\" encoding=\"utf-8\"?><!DOCTYPE note [\n<!ENTITY foo \"baa\">]>";
1502    std::string str2 = "<note importance=\"high\" logged=\"true\">";
1503    std::string str3 = "<![CDATA[\r\nfuncrion matchwo(a,6)\r\n{\r\nreturn 1;\r\n}\r\n]]>";
1504    std::string str4 = "<!--Hello, World!--> <company>John &amp; Hans</company> <title>Happy</title>";
1505    std::string str5 = "<title>Happy</title> <todo>Work</todo> <todo>Play</todo> <?go there?>";
1506    std::string str6 = "<a><b/></a> <h:table xml:h=\"http://www.w3.org/TR/html4/\"> <h:tr>";
1507    std::string str7 = "<h:td>Apples</h:td> <h:td>Bananas</h:td> </h:tr>";
1508    std::string str8 = "</h:table></note>";
1509    std::string strXml = str1 + str2 + str3 + str4 + str5 + str6 + str7 + str8;
1510    g_testStr = "";
1511    OHOS::xml::XmlPullParser xmlPullParser(env, strXml, "utf-8");
1512    napi_value options = nullptr;
1513    napi_create_object(env, &options);
1514    const char* key1 = "supportDoctype";
1515    const char* key2 = "ignoreNameSpace";
1516    const char* key3 = "tagValueCallbackFunction";
1517    napi_value object = nullptr;
1518    napi_create_object(env, &object);
1519    napi_value value1 = nullptr;
1520    napi_value value2 = nullptr;
1521    napi_get_boolean(env, true, &value1);
1522    napi_get_boolean(env, false, &value2);
1523    napi_value value3 = nullptr;
1524    std::string cbName = "Method";
1525    napi_create_function(env, cbName.c_str(), cbName.size(), Method, nullptr, &value3);
1526    napi_set_named_property(env, object, key1, value1);
1527    napi_set_named_property(env, object, key2, value2);
1528    napi_set_named_property(env, object, key3, value3);
1529    xmlPullParser.DealOptionInfo(env, object);
1530    xmlPullParser.Parse(env, options);
1531    std::string res1 = " note [\n<!ENTITY foo \"baa\">]note\r\nfuncrion matchwo(a,6)\r\n{\r\nreturn 1;\r\n}\r\n";
1532    std::string res2 = "Hello, World! companyJohn & Hanscompany titleHappytitletitleHappytitle todoWorktodo";
1533    std::string res3 = " todoPlaytodo go thereabba table trtdApplestd tdBananastd trtablenote";
1534    std::string result = res1 + res2 + res3;
1535    ASSERT_STREQ(g_testStr.c_str(), result.c_str());
1536}
1537
1538/* @tc.name: XmlParseTest0011
1539 * @tc.desc: To XML text to JavaScript object.
1540 * @tc.type: FUNC
1541 */
1542HWTEST_F(NativeEngineTest, XmlParseTest0011, testing::ext::TestSize.Level0)
1543{
1544    napi_env env = (napi_env)engine_;
1545    std::string str1 = "<?xml version=\"1.0\" encoding=\"utf-8\"?><!DOCTYPE note";
1546    std::string str2 = " [\n<!ATTLIST operand type src \"dest\">]><note importance=\"high\" logged=\"true\">";
1547    std::string str3 = "    <![CDATA[\r\nfuncrion matchwo(a,6)\r\n{\r\nreturn 1;\r\n}\r\n]]>";
1548    std::string str4 = "    <!--Hello, World!-->    <company>John &amp; Hans</company>    <title>Happy</title>";
1549    std::string str5 = "    <title>Happy</title>    <todo>Work</todo>    <todo>Play</todo>    <?go there?>";
1550    std::string str6 = "    <a><b/></a>    <h:table xmlns:h=\"http://www.w3.org/TR/html4/\">        <h:tr>";
1551    std::string str7 = "            <h:td>Apples</h:td>            <h:td>Bananas</h:td>        </h:tr>";
1552    std::string str8 = "    </h:table></note>";
1553    std::string strXml = str1 + str2 + str3 + str4 + str5 + str6 + str7 + str8;
1554    g_testStr = "";
1555    OHOS::xml::XmlPullParser xmlPullParser(env, strXml, "utf-8");
1556    napi_value options = nullptr;
1557    napi_create_object(env, &options);
1558    const char* key1 = "supportDoctype";
1559    const char* key2 = "ignoreNameSpace";
1560    const char* key3 = "tokenValueCallbackFunction";
1561    napi_value object = nullptr;
1562    napi_create_object(env, &object);
1563    napi_value value1 = nullptr;
1564    napi_value value2 = nullptr;
1565    napi_get_boolean(env, true, &value1);
1566    napi_get_boolean(env, true, &value2);
1567    napi_value value3 = nullptr;
1568    std::string cbName = "TokenValueCallbackFunction";
1569    napi_create_function(env, cbName.c_str(), cbName.size(), TokenValueCallbackFunction, nullptr, &value3);
1570    napi_set_named_property(env, object, key1, value1);
1571    napi_set_named_property(env, object, key2, value2);
1572    napi_set_named_property(env, object, key3, value3);
1573    xmlPullParser.DealOptionInfo(env, object);
1574    xmlPullParser.Parse(env, options);
1575    ASSERT_STREQ(g_testStr.c_str(), "");
1576}
1577
1578/* @tc.name: XmlParseTest0012
1579 * @tc.desc: To XML text to JavaScript object.
1580 * @tc.type: FUNC
1581 */
1582HWTEST_F(NativeEngineTest, XmlParseTest0012, testing::ext::TestSize.Level0)
1583{
1584    napi_env env = (napi_env)engine_;
1585    std::string str1 = "<?xml version=\"1.0\" encoding=\"utf-8\"?><!DOCTYPE note [\n<!ELEMENT>]>";
1586    std::string str2 = "<note importance=\"high\" logged=\"true\">";
1587    std::string str3 = "    <![CDATA[\r\nfuncrion matchwo(a,6)\r\n{\r\nreturn 1;\r\n}\r\n]]>";
1588    std::string str4 = "    <!--Hello, World!-->    <company>John &amp; Hans</company>    <title>Happy</title>";
1589    std::string str5 = "    <title>Happy</title>    <todo>Work</todo>    <todo>Play</todo>    <?go there?>";
1590    std::string str6 = "    <a><b/></a>    <h:table xmlns:h=\"http://www.w3.org/TR/html4/\">        <h:tr>";
1591    std::string str7 = "            <h:td>Apples</h:td>            <h:td>Bananas</h:td>        </h:tr>";
1592    std::string str8 = "    </h:table></note>";
1593    std::string strXml = str1 + str2 + str3 + str4 + str5 + str6 + str7 + str8;
1594    OHOS::xml::XmlPullParser xmlPullParser(env, strXml, "utf-8");
1595    napi_value options = nullptr;
1596    napi_create_object(env, &options);
1597    const char* key1 = "supportDoctype";
1598    const char* key2 = "ignoreNameSpace";
1599    const char* key3 = "tokenValueCallbackFunction";
1600    napi_value object = nullptr;
1601    napi_create_object(env, &object);
1602    napi_value value1 = nullptr;
1603    napi_value value2 = nullptr;
1604    napi_get_boolean(env, true, &value1);
1605    napi_get_boolean(env, true, &value2);
1606    napi_value value3 = nullptr;
1607    std::string cbName = "TokenValueCallbackFunction";
1608    napi_create_function(env, cbName.c_str(), cbName.size(), TokenValueCallbackFunction, nullptr, &value3);
1609    napi_set_named_property(env, object, key1, value1);
1610    napi_set_named_property(env, object, key2, value2);
1611    napi_set_named_property(env, object, key3, value3);
1612    xmlPullParser.DealOptionInfo(env, object);
1613    xmlPullParser.Parse(env, options);
1614    ASSERT_STREQ(g_testStr.c_str(), "");
1615}
1616
1617/* @tc.name: Xmlfunctest001
1618 * @tc.desc: To XML text to JavaScript object.
1619 * @tc.type: FUNC
1620 */
1621HWTEST_F(NativeEngineTest, Xmlfunctest001, testing::ext::TestSize.Level0)
1622{
1623    napi_env env = (napi_env)engine_;
1624    std::string strXml = "<?xml version=\"1.0\" encoding=\"utf-8\"?>    <title>Happy</title>    <todo>Work</todo>";
1625    OHOS::xml::XmlPullParser xmlPullParser(env, strXml, "utf-8");
1626    ASSERT_EQ(xmlPullParser.GetColumnNumber(), 1);
1627    ASSERT_EQ(xmlPullParser.GetDepth(), 0);
1628    ASSERT_EQ(xmlPullParser.GetLineNumber(), 1);
1629    ASSERT_STREQ(xmlPullParser.GetName().c_str(), "");
1630    ASSERT_STREQ(xmlPullParser.GetPrefix().c_str(), "");
1631    ASSERT_STREQ(xmlPullParser.GetText().c_str(), "");
1632    ASSERT_FALSE(xmlPullParser.IsEmptyElementTag());
1633    ASSERT_EQ(xmlPullParser.GetAttributeCount(), 0);
1634    ASSERT_FALSE(xmlPullParser.IsWhitespace());
1635    ASSERT_STREQ(xmlPullParser.GetNamespace().c_str(), "");
1636}
1637
1638/* @tc.name: XmlSerializertest001
1639 * @tc.desc: To XML text to JavaScript object.
1640 * @tc.type: FUNC
1641 */
1642HWTEST_F(NativeEngineTest, XmlSerializertest001, testing::ext::TestSize.Level0)
1643{
1644    napi_env env = (napi_env)engine_;
1645    napi_value exports = nullptr;
1646    napi_create_object(env, &exports);
1647    OHOS::xml::XmlSerializerInit(env, exports);
1648    napi_value xmlSerializerClass = nullptr;
1649    napi_get_named_property(env, exports, "XmlSerializer", &xmlSerializerClass);
1650
1651    napi_value args[2]; // 2: number of arguments
1652    size_t length = 2048; // allocate an ArrayBuffer with a size of 2048 bytes
1653    void* pBuffer = nullptr;
1654    napi_create_arraybuffer(env, length, &pBuffer, &args[0]);
1655    std::string encoding = "utf-8";
1656    napi_create_string_utf8(env, encoding.c_str(), encoding.size(), &args[1]);
1657    napi_value instance = nullptr;
1658    napi_new_instance(env, xmlSerializerClass, 2, args, &instance); // 2: number of arguments
1659
1660    std::string name = "importance";
1661    napi_create_string_utf8(env, name.c_str(), name.size(), &args[0]);
1662    std::string value = "high";
1663    napi_create_string_utf8(env, value.c_str(), value.size(), &args[1]);
1664    napi_value testFunc = nullptr;
1665    napi_get_named_property(env, instance, "setAttributes", &testFunc);
1666    napi_value funcResultValue = nullptr;
1667    napi_call_function(env, instance, testFunc, 2, args, &funcResultValue); // 2: number of arguments
1668    ASSERT_NE(funcResultValue, nullptr);
1669
1670    napi_get_named_property(env, instance, "setDeclaration", &testFunc);
1671    napi_call_function(env, instance, testFunc, 0, nullptr, &funcResultValue);
1672    ASSERT_NE(funcResultValue, nullptr);
1673
1674    name = "note";
1675    napi_value val = nullptr;
1676    napi_create_string_utf8(env, name.c_str(), name.size(), &val);
1677    napi_get_named_property(env, instance, "startElement", &testFunc);
1678    napi_call_function(env, instance, testFunc, 1, &val, &funcResultValue);
1679    ASSERT_NE(funcResultValue, nullptr);
1680
1681    napi_get_named_property(env, instance, "endElement", &testFunc);
1682    napi_call_function(env, instance, testFunc, 0, nullptr, &funcResultValue);
1683    ASSERT_NE(funcResultValue, nullptr);
1684
1685    name = "h";
1686    napi_create_string_utf8(env, name.c_str(), name.size(), &args[0]);
1687    value = "http://www.w3.org/TR/html4/";
1688    napi_create_string_utf8(env, value.c_str(), value.size(), &args[1]);
1689    napi_get_named_property(env, instance, "setNamespace", &testFunc);
1690    napi_call_function(env, instance, testFunc, 2, args, &funcResultValue); // 2: number of arguments
1691    ASSERT_NE(funcResultValue, nullptr);
1692}
1693
1694/* @tc.name: XmlSerializertest002
1695 * @tc.desc: To XML text to JavaScript object.
1696 * @tc.type: FUNC
1697 */
1698HWTEST_F(NativeEngineTest, XmlSerializertest002, testing::ext::TestSize.Level0)
1699{
1700    napi_env env = (napi_env)engine_;
1701    napi_value exports = nullptr;
1702    napi_create_object(env, &exports);
1703    OHOS::xml::XmlSerializerInit(env, exports);
1704    napi_value xmlSerializerClass = nullptr;
1705    napi_get_named_property(env, exports, "XmlSerializer", &xmlSerializerClass);
1706
1707    napi_value args[2]; // 2: number of arguments
1708    size_t length = 2048; // allocate an ArrayBuffer with a size of 2048 bytes
1709    void* pBuffer = nullptr;
1710    napi_create_arraybuffer(env, length, &pBuffer, &args[0]);
1711    std::string encoding = "utf-8";
1712    napi_create_string_utf8(env, encoding.c_str(), encoding.size(), &args[1]);
1713    napi_value instance = nullptr;
1714    napi_value val = nullptr;
1715    napi_new_instance(env, xmlSerializerClass, 2, args, &instance); // 2: number of arguments
1716    napi_value testFunc = nullptr;
1717    napi_value funcResultValue = nullptr;
1718    std::string name = "Hello, World!";
1719    napi_create_string_utf8(env, name.c_str(), name.size(), &val);
1720    napi_get_named_property(env, instance, "setComment", &testFunc);
1721    napi_call_function(env, instance, testFunc, 1, &val, &funcResultValue);
1722    ASSERT_NE(funcResultValue, nullptr);
1723
1724    name = "root SYSTEM";
1725    napi_create_string_utf8(env, name.c_str(), name.size(), &val);
1726    napi_get_named_property(env, instance, "setCDATA", &testFunc);
1727    napi_call_function(env, instance, testFunc, 1, &val, &funcResultValue);
1728    ASSERT_NE(funcResultValue, nullptr);
1729
1730    name = "Happy";
1731    napi_create_string_utf8(env, name.c_str(), name.size(), &val);
1732    napi_get_named_property(env, instance, "setText", &testFunc);
1733    napi_call_function(env, instance, testFunc, 1, &val, &funcResultValue);
1734    ASSERT_NE(funcResultValue, nullptr);
1735
1736    name = "root SYSTEM \"http://www.test.org/test.dtd\"";
1737    napi_create_string_utf8(env, name.c_str(), name.size(), &val);
1738    napi_get_named_property(env, instance, "setDocType", &testFunc);
1739    napi_call_function(env, instance, testFunc, 1, &val, &funcResultValue);
1740    ASSERT_NE(funcResultValue, nullptr);
1741
1742    napi_get_named_property(env, instance, "XmlSerializerError", &testFunc);
1743    napi_call_function(env, instance, testFunc, 0, nullptr, &funcResultValue);
1744    ASSERT_NE(funcResultValue, nullptr);
1745}
1746
1747/* @tc.name: XmlPullParsertest001
1748 * @tc.desc: To XML text to JavaScript object.
1749 * @tc.type: FUNC
1750 */
1751HWTEST_F(NativeEngineTest, XmlPullParsertest001, testing::ext::TestSize.Level0)
1752{
1753    napi_env env = (napi_env)engine_;
1754    napi_value exports = nullptr;
1755    napi_create_object(env, &exports);
1756    OHOS::xml::XmlPullParserInit(env, exports);
1757    napi_value xmlPullParserClass = nullptr;
1758    napi_get_named_property(env, exports, "XmlPullParser", &xmlPullParserClass);
1759
1760    std::string firStr = "<?xml version=\"1.0\" encoding=\"utf-8\"?><note importance=\"high\" logged=\"true\">";
1761    std::string secStr = " <title>Happy</title><todo>Work</todo><todo>Play</todo></note>";
1762    std::string strXml = firStr + secStr;
1763    napi_value args[2]; // 2: number of arguments
1764    void* pBuffer = nullptr;
1765    size_t strLen = strXml.size();
1766    napi_create_arraybuffer(env, strLen, &pBuffer, &args[0]);
1767    memcpy_s(pBuffer, strLen, strXml.c_str(), strLen);
1768    std::string encoding = "utf-8";
1769    napi_create_string_utf8(env, encoding.c_str(), encoding.size(), &args[1]);
1770    napi_value instance = nullptr;
1771    napi_new_instance(env, xmlPullParserClass, 2, args, &instance); // 2: number of arguments
1772
1773    napi_value obj = nullptr;
1774    napi_create_object(env, &obj);
1775    napi_value val;
1776    napi_get_boolean(env, true, &val);
1777    napi_set_named_property(env, obj, "supportDoctype", val);
1778    napi_set_named_property(env, obj, "ignoreNameSpace", val);
1779    std::string cbName = "Method";
1780    napi_create_function(env, cbName.c_str(), cbName.size(), Method, nullptr, &val);
1781    napi_set_named_property(env, obj, "tokenValueCallbackFunction", val);
1782    napi_value funcResultValue = nullptr;
1783    napi_value testFunc = nullptr;
1784    napi_get_named_property(env, instance, "parse", &testFunc);
1785    napi_call_function(env, instance, testFunc, 1, &obj, &funcResultValue);
1786    ASSERT_NE(funcResultValue, nullptr);
1787
1788    napi_get_named_property(env, instance, "XmlPullParserError", &testFunc);
1789    napi_call_function(env, instance, testFunc, 0, nullptr, &funcResultValue);
1790    ASSERT_NE(funcResultValue, nullptr);
1791}
1792
1793/* @tc.name: SetDeclaration
1794 * @tc.desc: Test SetDeclaration Func
1795 * @tc.type: FUNC
1796 */
1797HWTEST_F(NativeEngineTest, Xmltest001, testing::ext::TestSize.Level0)
1798{
1799    napi_env env = (napi_env)engine_;
1800
1801    XmlTest::SetDeclaration(env);
1802    XmlTest::SetNamespace(env);
1803    XmlTest::StartElement(env);
1804    XmlTest::WriteEscaped(env);
1805    XmlTest::XmlSerializerError(env);
1806
1807    std::string strXml = "<?xml version=\"1.0\" encoding=\"utf-8\"?>    <title>Happy</title>    <todo>Work</todo>";
1808    OHOS::xml::XmlPullParser xmlPullParser(env, strXml, "utf-8");
1809    XmlTest::PushSrcLinkList(env);
1810    std::string strTemp = "xml version";
1811    xmlPullParser.Replace(strTemp, "xml", "convert");
1812    ASSERT_STREQ(strTemp.c_str(), "convert version");
1813}
1814
1815/* @tc.name: GetNSCount
1816 * @tc.desc: Test GetNSCount Func
1817 * @tc.type: FUNC
1818 */
1819HWTEST_F(NativeEngineTest, GetNSCount001, testing::ext::TestSize.Level0)
1820{
1821    napi_env env = (napi_env)engine_;
1822    size_t res = XmlTest::GetNSCount(env, 1);
1823    ASSERT_EQ(res, 0);
1824
1825    std::string str = XmlTest::XmlPullParserError(env);
1826    ASSERT_STREQ(str.c_str(), "IndexOutOfBoundsException");
1827}
1828
1829/* @tc.name: DealExclamationGroup
1830 * @tc.desc: Test DealExclamationGroup Func
1831 * @tc.type: FUNC
1832 */
1833HWTEST_F(NativeEngineTest, DealExclamationGroup001, testing::ext::TestSize.Level0)
1834{
1835    napi_env env = (napi_env)engine_;
1836    TagEnum tEnum = XmlTest::DealExclamationGroup(env, "stER");
1837    ASSERT_EQ(tEnum, TagEnum::ERROR);
1838
1839    tEnum = XmlTest::DealExclamationGroup(env, "stNR");
1840    ASSERT_EQ(tEnum, TagEnum::NOTATIONDECL);
1841
1842    tEnum = XmlTest::DealExclamationGroup(env, "staR");
1843    ASSERT_EQ(tEnum, TagEnum::ERROR);
1844}
1845
1846/* @tc.name: DealLtGroup001
1847 * @tc.desc: Test DealLtGroup Func
1848 * @tc.type: FUNC
1849 */
1850HWTEST_F(NativeEngineTest, DealLtGroup001, testing::ext::TestSize.Level0)
1851{
1852    napi_env env = (napi_env)engine_;
1853    TagEnum tEnum = XmlTest::DealLtGroup(env);
1854    ASSERT_EQ(tEnum, TagEnum::END_TAG);
1855    std::string str1 = "%";
1856    int apiVersion = 13; // 13: apiVersion
1857    tEnum = XmlTest::ParseTagType(env, str1, apiVersion);
1858    ASSERT_EQ(tEnum, TagEnum::TEXT);
1859}
1860
1861/* @tc.name: DealLtGroup002
1862 * @tc.desc: Test DealLtGroup Func
1863 * @tc.type: FUNC
1864 */
1865HWTEST_F(NativeEngineTest, DealLtGroup002, testing::ext::TestSize.Level0)
1866{
1867    napi_env env = (napi_env)engine_;
1868    TagEnum tEnum = XmlTest::DealLtGroup(env);
1869    ASSERT_EQ(tEnum, TagEnum::END_TAG);
1870    std::string str1 = "&";
1871    int apiVersion = 13; // 13: apiVersion
1872    tEnum = XmlTest::ParseTagType(env, str1, apiVersion);
1873    ASSERT_EQ(tEnum, TagEnum::ENTITY_REFERENCE);
1874}
1875
1876/* @tc.name: DealLtGroup003
1877 * @tc.desc: Test DealLtGroup Func
1878 * @tc.type: FUNC
1879 */
1880HWTEST_F(NativeEngineTest, DealLtGroup003, testing::ext::TestSize.Level0)
1881{
1882    napi_env env = (napi_env)engine_;
1883    TagEnum tEnum = XmlTest::DealLtGroup(env);
1884    ASSERT_EQ(tEnum, TagEnum::END_TAG);
1885    std::string str1 = "&";
1886    int apiVersion = 11; // 11: apiVersion
1887    tEnum = XmlTest::ParseTagType(env, str1, apiVersion);
1888    ASSERT_EQ(tEnum, TagEnum::TEXT);
1889}
1890
1891/* @tc.name: MakeStrUpper
1892 * @tc.desc: Test MakeStrUpper Func
1893 * @tc.type: FUNC
1894 */
1895HWTEST_F(NativeEngineTest, MakeStrUpper001, testing::ext::TestSize.Level0)
1896{
1897    napi_env env = (napi_env)engine_;
1898    std::string strXml = "to";
1899    OHOS::xml::XmlPullParser xmlPullParser(env, strXml, "utf-8");
1900    std::string src = "C";
1901    xmlPullParser.MakeStrUpper(src);
1902    ASSERT_STREQ(src.c_str(), "c");
1903
1904    std::string str = "todo";
1905    src = XmlTest::SkipText(env, strXml, str);
1906    ASSERT_STREQ(src.c_str(), "expected: 'todo' but was EOF");
1907
1908    strXml = "<todo>Work</todo>";
1909    src = XmlTest::SkipText(env, strXml, str);
1910    ASSERT_STREQ(src.c_str(), "expected: \"todo\" but was \"<tod...\"");
1911}
1912
1913/* @tc.name: GetColumnNumber
1914 * @tc.desc: Test GetColumnNumber Func
1915 * @tc.type: FUNC
1916 */
1917HWTEST_F(NativeEngineTest, GetColumnNumber, testing::ext::TestSize.Level0)
1918{
1919    napi_env env = (napi_env)engine_;
1920    OHOS::xml::XmlTest testXml;
1921    int res = testXml.TestGetColumnNumber(env);
1922    ASSERT_EQ(res, 2); // 2: ColumnNumber
1923}
1924
1925/* @tc.name: GetLineNumber
1926 * @tc.desc: Test GetLineNumber Func
1927 * @tc.type: FUNC
1928 */
1929HWTEST_F(NativeEngineTest, GetLineNumber, testing::ext::TestSize.Level0)
1930{
1931    napi_env env = (napi_env)engine_;
1932    OHOS::xml::XmlTest testXml;
1933    int res = testXml.TestGetLineNumber(env);
1934
1935    OHOS::xml::XmlPullParser xml(env, "1\n1", "utf8");
1936    xml.ParseInneNotaDecl();
1937    ASSERT_EQ(res, 2); // 2: LineNumber
1938}
1939
1940/* @tc.name: GetText
1941 * @tc.desc: Test GetText Func
1942 * @tc.type: FUNC
1943 */
1944HWTEST_F(NativeEngineTest, GetText, testing::ext::TestSize.Level0)
1945{
1946    napi_env env = (napi_env)engine_;
1947    OHOS::xml::XmlTest testXml;
1948    std::string res = testXml.TestGetText(env);
1949    ASSERT_STREQ(res.c_str(), "");
1950}
1951
1952/* @tc.name: ParseStartTagFuncDeal
1953 * @tc.desc: Test ParseStartTagFuncDeal Func
1954 * @tc.type: FUNC
1955 */
1956HWTEST_F(NativeEngineTest, ParseStartTagFuncDeal, testing::ext::TestSize.Level0)
1957{
1958    napi_env env = (napi_env)engine_;
1959    OHOS::xml::XmlPullParser xml(env, "", "utf8");
1960    bool res = xml.ParseStartTagFuncDeal(true);
1961    ASSERT_FALSE(res);
1962}
1963
1964/* @tc.name: ParseNsp
1965 * @tc.desc: Test ParseNsp Func
1966 * @tc.type: FUNC
1967 */
1968HWTEST_F(NativeEngineTest, ParseNsp, testing::ext::TestSize.Level0)
1969{
1970    napi_env env = (napi_env)engine_;
1971    OHOS::xml::XmlTest testXml;
1972    bool res = testXml.TestParseNsp(env);
1973    ASSERT_FALSE(res);
1974}
1975
1976/* @tc.name: ParseDeclaration
1977 * @tc.desc: Test ParseDeclaration Func
1978 * @tc.type: FUNC
1979 */
1980HWTEST_F(NativeEngineTest, ParseDeclaration, testing::ext::TestSize.Level0)
1981{
1982    napi_env env = (napi_env)engine_;
1983    OHOS::xml::XmlTest testXml;
1984    testXml.TestParseDeclaration(env);
1985    bool res = false;
1986    ASSERT_FALSE(res);
1987}
1988
1989/* @tc.name: ParseDelimiterInfo
1990 * @tc.desc: Test ParseDelimiterInfo Func
1991 * @tc.type: FUNC
1992 */
1993HWTEST_F(NativeEngineTest, ParseDelimiterInfo, testing::ext::TestSize.Level0)
1994{
1995    napi_env env = (napi_env)engine_;
1996    OHOS::xml::XmlTest testXml;
1997    std::string res = testXml.TestParseDelimiterInfo(env);
1998    ASSERT_STREQ(res.c_str(), "");
1999}
2000
2001/* @tc.name: ParseEndTag
2002 * @tc.desc: Test ParseEndTag Func
2003 * @tc.type: FUNC
2004 */
2005HWTEST_F(NativeEngineTest, ParseEndTag, testing::ext::TestSize.Level0)
2006{
2007    napi_env env = (napi_env)engine_;
2008    OHOS::xml::XmlTest testXml;
2009    bool res = testXml.TestParseEndTag(env);
2010    ASSERT_FALSE(res);
2011}
2012
2013/* @tc.name: ParserDoctInnerInfo
2014 * @tc.desc: Test ParserDoctInnerInfo Func
2015 * @tc.type: FUNC
2016 */
2017HWTEST_F(NativeEngineTest, ParserDoctInnerInfo, testing::ext::TestSize.Level0)
2018{
2019    napi_env env = (napi_env)engine_;
2020    OHOS::xml::XmlPullParser xml(env, "S11", "utf8");
2021    bool res = xml.ParserDoctInnerInfo(false, true);
2022
2023    OHOS::xml::XmlPullParser xml1(env, "P11", "utf8");
2024    res = xml1.ParserDoctInnerInfo(true, true);
2025    OHOS::xml::XmlPullParser xml2(env, "P11", "utf8");
2026    res = xml2.ParserDoctInnerInfo(true, false);
2027    ASSERT_TRUE(res);
2028}
2029
2030/* @tc.name: ParseDelimiter
2031 * @tc.desc: Test ParseDelimiter Func
2032 * @tc.type: FUNC
2033 */
2034HWTEST_F(NativeEngineTest, ParseDelimiter, testing::ext::TestSize.Level0)
2035{
2036    napi_env env = (napi_env)engine_;
2037    OHOS::xml::XmlPullParser xml(env, "\"\'1", "utf8");
2038    std::string res = xml.ParseDelimiter(false);
2039    ASSERT_STREQ(res.c_str(), "");
2040}
2041
2042/* @tc.name: ParseSpecText
2043 * @tc.desc: Test ParseSpecText Func
2044 * @tc.type: FUNC
2045 */
2046HWTEST_F(NativeEngineTest, ParseSpecText, testing::ext::TestSize.Level0)
2047{
2048    napi_env env = (napi_env)engine_;
2049    OHOS::xml::XmlPullParser xml(env, "()*", "utf8");
2050    xml.ParseSpecText();
2051    OHOS::xml::XmlPullParser xml1(env, "E", "utf8");
2052    xml1.ParseSpecText();
2053    OHOS::xml::XmlPullParser xml2(env, "A", "utf8");
2054    xml2.ParseSpecText();
2055    bool res = false;
2056    ASSERT_FALSE(res);
2057}
2058
2059/* @tc.name: ParseComment
2060 * @tc.desc: Test ParseComment Func
2061 * @tc.type: FUNC
2062 */
2063HWTEST_F(NativeEngineTest, ParseComment, testing::ext::TestSize.Level0)
2064{
2065    napi_env env = (napi_env)engine_;
2066    OHOS::xml::XmlTest testXml;
2067    bool res = testXml.TestParseComment(env);
2068    ASSERT_FALSE(res);
2069}
2070
2071/* @tc.name: ParseOneTagFunc
2072 * @tc.desc: Test ParseOneTagFunc Func
2073 * @tc.type: FUNC
2074 */
2075HWTEST_F(NativeEngineTest, ParseOneTagFunc, testing::ext::TestSize.Level0)
2076{
2077    napi_env env = (napi_env)engine_;
2078    OHOS::xml::XmlTest testXml;
2079    OHOS::xml::TagEnum res = testXml.TestParseOneTagFunc(env);
2080    ASSERT_EQ(res, OHOS::xml::TagEnum::ERROR);
2081}
2082
2083/* @tc.name: ParseEntityDecl
2084 * @tc.desc: Test ParseEntityDecl Func
2085 * @tc.type: FUNC
2086 */
2087HWTEST_F(NativeEngineTest, TestParseEntityDecl, testing::ext::TestSize.Level0)
2088{
2089    napi_env env = (napi_env)engine_;
2090    OHOS::xml::XmlTest testXml;
2091    testXml.TestParseEntityDecl(env);
2092    bool res = false;
2093    ASSERT_FALSE(res);
2094}
2095
2096/* @tc.name: ParseNameInner
2097 * @tc.desc: Test ParseNameInner Func
2098 * @tc.type: FUNC
2099 */
2100HWTEST_F(NativeEngineTest, ParseNameInner, testing::ext::TestSize.Level0)
2101{
2102    napi_env env = (napi_env)engine_;
2103    std::string res = XmlTest::ParseNameInner(env, 1);
2104    ASSERT_STREQ(res.c_str(), "version");
2105}
2106
2107/* @tc.name: ParseName
2108 * @tc.desc: Test ParseName Func
2109 * @tc.type: FUNC
2110 */
2111HWTEST_F(NativeEngineTest, ParseName, testing::ext::TestSize.Level0)
2112{
2113    napi_env env = (napi_env)engine_;
2114    std::string res = XmlTest::ParseName(env);
2115    ASSERT_STREQ(res.c_str(), "");
2116}
2117
2118/* @tc.name: ParseEntityFunc
2119 * @tc.desc: Test ParseEntityFunc Func
2120 * @tc.type: FUNC
2121 */
2122HWTEST_F(NativeEngineTest, ParseEntityFunc, testing::ext::TestSize.Level0)
2123{
2124    napi_env env = (napi_env)engine_;
2125    OHOS::xml::XmlPullParser xmlPullParser(env, "xml", "utf8");
2126    std::string out = "W#x2";
2127    bool res = XmlTest::ParseEntityFunc(env, out, "", true, TextEnum::ENTITY_DECL);
2128    ASSERT_FALSE(res);
2129
2130    out = "W#1";
2131    res = XmlTest::ParseEntityFunc(env, out, "", true, TextEnum::ENTITY_DECL);
2132    ASSERT_FALSE(res);
2133
2134    out = "Work1";
2135    res = XmlTest::ParseEntityFunc(env, out, "", true, TextEnum::ENTITY_DECL);
2136    ASSERT_FALSE(res);
2137
2138    out = "Work";
2139    res = XmlTest::ParseEntityFunc(env, out, "", true, TextEnum::TEXT);
2140    ASSERT_FALSE(res);
2141    res = XmlTest::ParseEntityFunc(env, out, "", false, TextEnum::TEXT);
2142    ASSERT_FALSE(res);
2143
2144    out = "W";
2145    res = XmlTest::ParseEntityFunc(env, out, "", true, TextEnum::TEXT);
2146    ASSERT_TRUE(res);
2147    res = XmlTest::ParseEntityFunc(env, out, "info", true, TextEnum::TEXT);
2148    ASSERT_FALSE(res);
2149}
2150
2151/* @tc.name: ParseEntity001
2152 * @tc.desc: Test ParseEntity Func
2153 * @tc.type: FUNC
2154 */
2155HWTEST_F(NativeEngineTest, ParseEntity001, testing::ext::TestSize.Level0)
2156{
2157    napi_env env = (napi_env)engine_;
2158    bool relaxed = true;
2159    std::string res = XmlTest::ParseEntity(env, relaxed);
2160    ASSERT_STREQ(res.c_str(), "Should not be reached");
2161}
2162
2163/* @tc.name: ParseEntity002
2164 * @tc.desc: Test ParseEntity Func
2165 * @tc.type: FUNC
2166 */
2167HWTEST_F(NativeEngineTest, ParseEntity002, testing::ext::TestSize.Level0)
2168{
2169    napi_env env = (napi_env)engine_;
2170    bool relaxed = false;
2171    std::string res = XmlTest::ParseEntity(env, relaxed);
2172    ASSERT_STREQ(res.c_str(), "unterminated entity ref");
2173}
2174
2175/* @tc.name: ParseTagValueInner
2176 * @tc.desc: Test ParseTagValueInner Func
2177 * @tc.type: FUNC
2178 */
2179HWTEST_F(NativeEngineTest, ParseTagValueInner, testing::ext::TestSize.Level0)
2180{
2181    napi_env env = (napi_env)engine_;
2182    size_t start = 0;
2183    std::string result = "xml";
2184    size_t position = 1;
2185    std::string xmlStr = "todo";
2186    size_t res = XmlTest::ParseTagValueInner(env, start, result, position, xmlStr);
2187    ASSERT_EQ(res, 2);
2188
2189    start = 1;
2190    xmlStr = "t";
2191    res = XmlTest::ParseTagValueInner(env, start, result, position, xmlStr);
2192    ASSERT_EQ(res, 0);
2193}
2194
2195/* @tc.name: ParseTagValue
2196 * @tc.desc: Test ParseTagValue Func
2197 * @tc.type: FUNC
2198 */
2199HWTEST_F(NativeEngineTest, ParseTagValue, testing::ext::TestSize.Level0)
2200{
2201    napi_env env = (napi_env)engine_;
2202    size_t max = 1;
2203    std::string strXml = "W";
2204    std::string res = XmlTest::ParseTagValue(env, 'c', false, TextEnum::TEXT, max);
2205    ASSERT_STREQ(res.c_str(), "xml");
2206
2207    res = XmlTest::ParseTagValue(env, 'e', true, TextEnum::ATTRI, max);
2208    ASSERT_STREQ(res.c_str(), "");
2209}
2210
2211/* @tc.name: GetNamespace
2212 * @tc.desc: Test GetNamespace Func
2213 * @tc.type: FUNC
2214 */
2215HWTEST_F(NativeEngineTest, GetNamespace, testing::ext::TestSize.Level0)
2216{
2217    napi_env env = (napi_env)engine_;
2218    std::string prefix = "";
2219    size_t depth = 2;
2220    std::string res = XmlTest::GetNamespace(env, prefix, depth);
2221    ASSERT_STREQ(res.c_str(), "W");
2222
2223    prefix = "fix";
2224    depth = 1;
2225    std::string res1 = XmlTest::GetNamespace(env, prefix, depth);
2226    ASSERT_STREQ(res1.c_str(), "");
2227}
2228
2229/* @tc.name: ParseNspFunc
2230 * @tc.desc: Test ParseNspFunc Func
2231 * @tc.type: FUNC
2232 */
2233HWTEST_F(NativeEngineTest, ParseNspFunc, testing::ext::TestSize.Level0)
2234{
2235    napi_env env = (napi_env)engine_;
2236    std::string res = XmlTest::ParseNspFunc(env);
2237    ASSERT_STREQ(res.c_str(), "illegal empty namespace");
2238}
2239
2240/* @tc.name: ParseNspFunction
2241 * @tc.desc: Test ParseNspFunction Func
2242 * @tc.type: FUNC
2243 */
2244HWTEST_F(NativeEngineTest, ParseNspFunction, testing::ext::TestSize.Level0)
2245{
2246    napi_env env = (napi_env)engine_;
2247    std::string pushStr = "yu:er";
2248    std::string res = XmlTest::ParseNspFunction(env, pushStr);
2249    ASSERT_STREQ(res.c_str(), "Undefined Prefix: yu in ");
2250
2251    pushStr = ":yuer";
2252    res = XmlTest::ParseNspFunction(env, pushStr);
2253    ASSERT_STREQ(res.c_str(), "illegal attribute name: ");
2254}
2255
2256/* @tc.name: ParseNsp002
2257 * @tc.desc: Test ParseNsp Func
2258 * @tc.type: FUNC
2259 */
2260HWTEST_F(NativeEngineTest, ParseNsp002, testing::ext::TestSize.Level0)
2261{
2262    napi_env env = (napi_env)engine_;
2263    bool res = XmlTest::ParseNsp(env);
2264    ASSERT_FALSE(res);
2265}
2266
2267/* @tc.name: ParseStartTagFuncDeal002
2268 * @tc.desc: Test ParseStartTagFuncDeal Func
2269 * @tc.type: FUNC
2270 */
2271HWTEST_F(NativeEngineTest, ParseStartTagFuncDeal002, testing::ext::TestSize.Level0)
2272{
2273    napi_env env = (napi_env)engine_;
2274    bool res = XmlTest::ParseStartTagFuncDeal(env, "w=", false);
2275    ASSERT_FALSE(res);
2276
2277    res = XmlTest::ParseStartTagFuncDeal(env, "=q", true);
2278    ASSERT_TRUE(res);
2279
2280    res = XmlTest::ParseStartTagFuncDeal(env, "==", false);
2281    ASSERT_FALSE(res);
2282}
2283
2284/* @tc.name: ParseStartTagFunc
2285 * @tc.desc: Test ParseStartTagFunc Func
2286 * @tc.type: FUNC
2287 */
2288HWTEST_F(NativeEngineTest, ParseStartTagFunc001, testing::ext::TestSize.Level0)
2289{
2290    napi_env env = (napi_env)engine_;
2291    OHOS::xml::XmlPullParser xmlPullParser(env, "", "utf-8");
2292    TagEnum res = xmlPullParser.ParseStartTagFunc(false, false);
2293    ASSERT_EQ(res, OHOS::xml::TagEnum::ERROR);
2294}
2295
2296/* @tc.name: ParseStartTagFunc
2297 * @tc.desc: Test ParseStartTagFunc Func
2298 * @tc.type: FUNC
2299 */
2300HWTEST_F(NativeEngineTest, ParseStartTagFunc002, testing::ext::TestSize.Level0)
2301{
2302    napi_env env = (napi_env)engine_;
2303    std::string str1 = "<?xml version=\"1.0\" encoding=\"utf-8\"?>";
2304    std::string str2 = "<note importance=\"high\" logged=\"true\">";
2305    std::string str3 = "    <title>Hello\rWorld\n</title>";
2306    std::string str4 = "    <todo>Work\r\n</todo>";
2307    std::string str5 = "    <mess><![CDATA[This is a \r\n CDATA section]]></mess>";
2308    std::string str6 = "</note>";
2309    std::string strXml = str1 + str2 + str3 + str4 + str5 + str6;
2310    TagEnum res = XmlTest::ParseStartTagFuncTest(env, strXml, false, true);
2311    ASSERT_EQ(res, OHOS::xml::TagEnum::ERROR);
2312}
2313
2314/* @tc.name: ParseDeclaration002
2315 * @tc.desc: Test ParseDeclaration Func
2316 * @tc.type: FUNC
2317 */
2318HWTEST_F(NativeEngineTest, ParseDeclaration002, testing::ext::TestSize.Level0)
2319{
2320    napi_env env = (napi_env)engine_;
2321    std::string xml = "<?xml version=\"1.0\" encoding=\"utf-8\" standalone=\"no\"?><todo>Work</todo>";
2322    bool res = XmlTest::ParseDeclaration(env, xml);
2323    ASSERT_TRUE(res);
2324
2325    xml = "<?xml version=\"1.0\" encoding=\"utf-8\" standalone=\"yes\"?><todo>Work</todo>";
2326    res = XmlTest::ParseDeclaration(env, xml);
2327    ASSERT_TRUE(res);
2328
2329    xml = "<?xml version=\"1.0\" encoding=\"utf-8\" standalone=\"else\"?><todo>Work</todo>";
2330    res = XmlTest::ParseDeclaration(env, xml);
2331    ASSERT_TRUE(res);
2332
2333    xml = "<?xml version=\"1.0\" encoding=\"utf-8\" standa=\"no\"?><todo>Work</todo>";
2334    res = XmlTest::ParseDeclaration(env, xml);
2335    ASSERT_TRUE(res);
2336}
2337
2338/* @tc.name: DealNapiStrValue001
2339 * @tc.desc: Test DealNapiStrValue Func
2340 * @tc.type: FUNC
2341 */
2342HWTEST_F(NativeEngineTest, DealNapiStrValue001, testing::ext::TestSize.Level0)
2343{
2344    napi_env env = (napi_env)engine_;
2345    std::string str = "<?xml version=\"1.0\" encoding=\"utf-8\" standa=\"no\"?><todo>Work</todo>";
2346    std::string output = XmlTest::DealNapiStrValueFunction(env, str);
2347    ASSERT_STREQ(output.c_str(), str.c_str());
2348}
2349
2350/* @tc.name: DealNapiStrValue002
2351 * @tc.desc: Test DealNapiStrValue Func
2352 * @tc.type: FUNC
2353 */
2354HWTEST_F(NativeEngineTest, DealNapiStrValue002, testing::ext::TestSize.Level0)
2355{
2356    napi_env env = (napi_env)engine_;
2357    std::string strPrior = "<?xml version=\"1.0\" encoding=\"utf-8\"?>\r\n";
2358    std::string output = XmlTest::DealNapiStrValueFunction(env, strPrior);
2359    ASSERT_STREQ(output.c_str(), strPrior.c_str());
2360}
2361
2362/* @tc.name: DealNapiStrValue003
2363 * @tc.desc: Test DealNapiStrValue Func
2364 * @tc.type: FUNC
2365 */
2366HWTEST_F(NativeEngineTest, DealNapiStrValue003, testing::ext::TestSize.Level0)
2367{
2368    napi_env env = (napi_env)engine_;
2369    std::string str1 = "<?xml version=\"1.0\" encoding=\"utf-8\" standalone=\"no\"?><todo>Work</todo>";
2370    std::string output = XmlTest::DealNapiStrValueFunction(env, str1);
2371    ASSERT_STREQ(output.c_str(), str1.c_str());
2372}
2373
2374/* @tc.name: SplicNsp001
2375 * @tc.desc: Test SplicNsp Func
2376 * @tc.type: FUNC
2377 */
2378HWTEST_F(NativeEngineTest, SplicNspFunction001, testing::ext::TestSize.Level0)
2379{
2380    napi_env env = (napi_env)engine_;
2381    std::string str1 = "isStart";
2382    int output = XmlTest::SplicNspFunction(env, str1);
2383    ASSERT_EQ(output, 0);
2384}
2385
2386/* @tc.name: SetNamespaceFunction001
2387 * @tc.desc: Test SetNamespace Func
2388 * @tc.type: FUNC
2389 */
2390HWTEST_F(NativeEngineTest, SetNamespaceFunction001, testing::ext::TestSize.Level0)
2391{
2392    napi_env env = (napi_env)engine_;
2393    napi_value arrayBuffer = nullptr;
2394    void* pBuffer = nullptr;
2395    size_t size = 1024;
2396    napi_create_arraybuffer(env, size, &pBuffer, &arrayBuffer);
2397    OHOS::xml::XmlSerializer xmlSerializer(reinterpret_cast<char*>(pBuffer), size, "utf-8");
2398    std::string str1 = "h";
2399    std::string str2 = "http://www.w3.org/TR/html4/";
2400    xmlSerializer.SetDeclaration();
2401    xmlSerializer.SetNamespace(str1, str2);
2402    xmlSerializer.StartElement("note");
2403    xmlSerializer.EndElement();
2404    std::string result = "<?xml version=\"1.0\" encoding=\"utf-8\"?>\r\n<h:"
2405                         "note xmlns:h=\"http://www.w3.org/TR/html4/\"/>";
2406    ASSERT_STREQ(reinterpret_cast<char*>(pBuffer), result.c_str());
2407}
2408
2409/* @tc.name: SetNamespaceFunction002
2410 * @tc.desc: Test SetNamespace Func
2411 * @tc.type: FUNC
2412 */
2413HWTEST_F(NativeEngineTest, SetNamespaceFunction002, testing::ext::TestSize.Level0)
2414{
2415    napi_env env = (napi_env)engine_;
2416    napi_value arrayBuffer = nullptr;
2417    void* pBuffer = nullptr;
2418    size_t size = 1024;
2419    napi_create_arraybuffer(env, size, &pBuffer, &arrayBuffer);
2420    OHOS::xml::XmlSerializer xmlSerializer(reinterpret_cast<char*>(pBuffer), size, "utf-8");
2421    std::string str1 = "b";
2422    std::string str2 = "http://www.w3.org/TR/html4/";
2423    xmlSerializer.SetDeclaration();
2424    xmlSerializer.SetNamespace(str1, str2);
2425    xmlSerializer.StartElement("note");
2426    xmlSerializer.EndElement();
2427    std::string result = "<?xml version=\"1.0\" encoding=\"utf-8\"?>\r\n<b:"
2428                         "note xmlns:b=\"http://www.w3.org/TR/html4/\"/>";
2429    ASSERT_STREQ(reinterpret_cast<char*>(pBuffer), result.c_str());
2430}
2431
2432/* @tc.name: SetNamespaceFunction003
2433 * @tc.desc: Test SetNamespace Func
2434 * @tc.type: FUNC
2435 */
2436HWTEST_F(NativeEngineTest, SetNamespaceFunction003, testing::ext::TestSize.Level0)
2437{
2438    napi_env env = (napi_env)engine_;
2439    napi_value arrayBuffer = nullptr;
2440    void* pBuffer = nullptr;
2441    size_t size = 2048;
2442    napi_create_arraybuffer(env, size, &pBuffer, &arrayBuffer);
2443    OHOS::xml::XmlSerializer xmlSerializer(reinterpret_cast<char*>(pBuffer), size, "utf-8");
2444    std::string str1 = "h";
2445    std::string str2 = "http://www.111/";
2446    xmlSerializer.SetDeclaration();
2447    xmlSerializer.SetNamespace(str1, str2);
2448    xmlSerializer.StartElement("note1");
2449    xmlSerializer.StartElement("note2");
2450    xmlSerializer.EndElement();
2451    xmlSerializer.EndElement();
2452    std::string result = "<?xml version=\"1.0\" encoding=\"utf-8\"?>\r\n<h:"
2453                         "note1 xmlns:h=\"http://www.111/\">\r\n  <h:note2/>\r\n</h:note1>";
2454    ASSERT_STREQ(reinterpret_cast<char*>(pBuffer), result.c_str());
2455}
2456
2457/* @tc.name: SetNamespaceFunction004
2458 * @tc.desc: Test SetNamespace Func
2459 * @tc.type: FUNC
2460 */
2461HWTEST_F(NativeEngineTest, SetNamespaceFunction004, testing::ext::TestSize.Level0)
2462{
2463    napi_env env = (napi_env)engine_;
2464    std::string str1 = "h";
2465    std::string str2 = "http://www.111/";
2466    std::string result = " xmlns:h=\"http://www.111/\"/>";
2467    std::string outPut = XmlTest::SetNamespaceFunction(env, str1, str2);
2468    ASSERT_STREQ(outPut.c_str(), result.c_str());
2469}
2470
2471/* @tc.name: StartElementFunction001
2472 * @tc.desc: Test StartElement Func
2473 * @tc.type: FUNC
2474 */
2475HWTEST_F(NativeEngineTest, StartElementFunction001, testing::ext::TestSize.Level0)
2476{
2477    napi_env env = (napi_env)engine_;
2478    napi_value arrayBuffer = nullptr;
2479    void* pBuffer = nullptr;
2480    size_t size = 2048;
2481    napi_create_arraybuffer(env, size, &pBuffer, &arrayBuffer);
2482    OHOS::xml::XmlSerializer xmlSerializer(reinterpret_cast<char*>(pBuffer), size, "utf-8");
2483    xmlSerializer.StartElement("note");
2484    xmlSerializer.SetComment("Hi!");
2485    xmlSerializer.EndElement();
2486    std::string result = "<note>\r\n  <!--Hi!-->\r\n</note>";
2487    ASSERT_STREQ(reinterpret_cast<char*>(pBuffer), result.c_str());
2488}
2489
2490/* @tc.name: EndElementFunction001
2491 * @tc.desc: Test EndElement Func
2492 * @tc.type: FUNC
2493 */
2494HWTEST_F(NativeEngineTest, EndElementFunction001, testing::ext::TestSize.Level0)
2495{
2496    napi_env env = (napi_env)engine_;
2497    napi_value arrayBuffer = nullptr;
2498    void* pBuffer = nullptr;
2499    size_t size = 2048;
2500    napi_create_arraybuffer(env, size, &pBuffer, &arrayBuffer);
2501    OHOS::xml::XmlSerializer xmlSerializer(reinterpret_cast<char*>(pBuffer), size, "utf-8");
2502    xmlSerializer.StartElement("note");
2503    xmlSerializer.SetCData("root SYSTEM \"http://www.test.org/test.dtd\"");
2504    xmlSerializer.EndElement();
2505    std::string result = "<note>\r\n  <![CDATA[root SYSTEM \"http://www.test.org/test.dtd\"]]>\r\n</note>";
2506    ASSERT_STREQ(reinterpret_cast<char*>(pBuffer), result.c_str());
2507}
2508
2509/* @tc.name: EndElementFunction002
2510 * @tc.desc: Test EndElement Func
2511 * @tc.type: FUNC
2512 */
2513HWTEST_F(NativeEngineTest, EndElementFunction002, testing::ext::TestSize.Level0)
2514{
2515    napi_env env = (napi_env)engine_;
2516    napi_value arrayBuffer = nullptr;
2517    void* pBuffer = nullptr;
2518    size_t size = 2048;
2519    napi_create_arraybuffer(env, size, &pBuffer, &arrayBuffer);
2520    OHOS::xml::XmlSerializer xmlSerializer(reinterpret_cast<char*>(pBuffer), size, "utf-8");
2521    xmlSerializer.SetDeclaration();
2522    xmlSerializer.SetNamespace("h", "http://www.w3.org/TR/html4/");
2523    xmlSerializer.StartElement("note1");
2524    xmlSerializer.StartElement("note2");
2525    xmlSerializer.EndElement();
2526    xmlSerializer.EndElement();
2527    std::string result = "<?xml version=\"1.0\" encoding=\"utf-8\"?>\r\n<h:note1 xmlns:"
2528                         "h=\"http://www.w3.org/TR/html4/\">\r\n  <h:note2/>\r\n</h:note1>";
2529    ASSERT_STREQ(reinterpret_cast<char*>(pBuffer), result.c_str());
2530}
2531
2532/* @tc.name: AddEmptyElementFunction001
2533 * @tc.desc: Test AddEmptyElement Func
2534 * @tc.type: FUNC
2535 */
2536HWTEST_F(NativeEngineTest, AddEmptyElementFunction001, testing::ext::TestSize.Level0)
2537{
2538    napi_env env = (napi_env)engine_;
2539    napi_value arrayBuffer = nullptr;
2540    void* pBuffer = nullptr;
2541    size_t size = 2048;
2542    napi_create_arraybuffer(env, size, &pBuffer, &arrayBuffer);
2543    OHOS::xml::XmlSerializer xmlSerializer(reinterpret_cast<char*>(pBuffer), size, "utf-8");
2544    xmlSerializer.StartElement("note");
2545    xmlSerializer.AddEmptyElement("a");
2546    xmlSerializer.EndElement();
2547    std::string result = "<note>\r\n  <a/>\r\n</note>";
2548    ASSERT_STREQ(reinterpret_cast<char*>(pBuffer), result.c_str());
2549}
2550
2551/* @tc.name: AddEmptyElementFunction002
2552 * @tc.desc: Test AddEmptyElement Func
2553 * @tc.type: FUNC
2554 */
2555HWTEST_F(NativeEngineTest, AddEmptyElementFunction002, testing::ext::TestSize.Level0)
2556{
2557    napi_env env = (napi_env)engine_;
2558    napi_value arrayBuffer = nullptr;
2559    void* pBuffer = nullptr;
2560    size_t size = 2048;
2561    napi_create_arraybuffer(env, size, &pBuffer, &arrayBuffer);
2562    OHOS::xml::XmlSerializer xmlSerializer(reinterpret_cast<char*>(pBuffer), size, "utf-8");
2563    xmlSerializer.StartElement("note");
2564    xmlSerializer.EndElement();
2565    xmlSerializer.AddEmptyElement("b");
2566    std::string result = "<note/>\r\n<b/>";
2567    ASSERT_STREQ(reinterpret_cast<char*>(pBuffer), result.c_str());
2568}
2569
2570/* @tc.name: SetTextFunction001
2571 * @tc.desc: Test SetText Func
2572 * @tc.type: FUNC
2573 */
2574HWTEST_F(NativeEngineTest, SetTextFunction001, testing::ext::TestSize.Level0)
2575{
2576    napi_env env = (napi_env)engine_;
2577    napi_value arrayBuffer = nullptr;
2578    void* pBuffer = nullptr;
2579    size_t size = 2048;
2580    napi_create_arraybuffer(env, size, &pBuffer, &arrayBuffer);
2581    OHOS::xml::XmlSerializer xmlSerializer(reinterpret_cast<char*>(pBuffer), size, "utf-8");
2582    xmlSerializer.StartElement("note");
2583    xmlSerializer.SetAttributes("importance", "high");
2584    xmlSerializer.SetText("Hello\"World");
2585    xmlSerializer.EndElement();
2586    std::string result = "<note importance=\"high\">Hello&quot;World</note>";
2587    ASSERT_STREQ(reinterpret_cast<char*>(pBuffer), result.c_str());
2588}
2589
2590/* @tc.name: SetTextFunction002
2591 * @tc.desc: Test SetText Func
2592 * @tc.type: FUNC
2593 */
2594HWTEST_F(NativeEngineTest, SetTextFunction002, testing::ext::TestSize.Level0)
2595{
2596    napi_env env = (napi_env)engine_;
2597    napi_value arrayBuffer = nullptr;
2598    void* pBuffer = nullptr;
2599    size_t size = 2048;
2600    napi_create_arraybuffer(env, size, &pBuffer, &arrayBuffer);
2601    OHOS::xml::XmlSerializer xmlSerializer(reinterpret_cast<char*>(pBuffer), size, "utf-8");
2602    xmlSerializer.StartElement("note");
2603    xmlSerializer.SetAttributes("importance", "high");
2604    xmlSerializer.SetText("Happy5");
2605    xmlSerializer.EndElement();
2606    std::string result = "<note importance=\"high\">Happy5</note>";
2607    ASSERT_STREQ(reinterpret_cast<char*>(pBuffer), result.c_str());
2608}
2609
2610/* @tc.name: SetCommentFunction001
2611 * @tc.desc: Test SetComment Func
2612 * @tc.type: FUNC
2613 */
2614HWTEST_F(NativeEngineTest, SetCommentFunction001, testing::ext::TestSize.Level0)
2615{
2616    napi_env env = (napi_env)engine_;
2617    napi_value arrayBuffer = nullptr;
2618    void* pBuffer = nullptr;
2619    size_t size = 2048;
2620    napi_create_arraybuffer(env, size, &pBuffer, &arrayBuffer);
2621    OHOS::xml::XmlSerializer xmlSerializer(reinterpret_cast<char*>(pBuffer), size, "utf-8");
2622    xmlSerializer.StartElement("note");
2623    xmlSerializer.SetComment("Hi!");
2624    xmlSerializer.EndElement();
2625    std::string result = "<note>\r\n  <!--Hi!-->\r\n</note>";
2626    ASSERT_STREQ(reinterpret_cast<char*>(pBuffer), result.c_str());
2627}
2628
2629/* @tc.name: SetCommentFunction002
2630 * @tc.desc: Test SetComment Func
2631 * @tc.type: FUNC
2632 */
2633HWTEST_F(NativeEngineTest, SetCommentFunction002, testing::ext::TestSize.Level0)
2634{
2635    napi_env env = (napi_env)engine_;
2636    napi_value arrayBuffer = nullptr;
2637    void* pBuffer = nullptr;
2638    size_t size = 2048;
2639    napi_create_arraybuffer(env, size, &pBuffer, &arrayBuffer);
2640    OHOS::xml::XmlSerializer xmlSerializer(reinterpret_cast<char*>(pBuffer), size, "utf-8");
2641    xmlSerializer.StartElement("note");
2642    xmlSerializer.SetComment("Hi!");
2643    xmlSerializer.EndElement();
2644    std::string result = "<note>\r\n  <!--Hi!-->\r\n</note>";
2645    ASSERT_STREQ(reinterpret_cast<char*>(pBuffer), result.c_str());
2646}
2647
2648/* @tc.name: SetCDataFunction001
2649 * @tc.desc: Test SetCData Func
2650 * @tc.type: FUNC
2651 */
2652HWTEST_F(NativeEngineTest, SetCDataFunction001, testing::ext::TestSize.Level0)
2653{
2654    napi_env env = (napi_env)engine_;
2655    napi_value arrayBuffer = nullptr;
2656    void* pBuffer = nullptr;
2657    size_t size = 2048;
2658    napi_create_arraybuffer(env, size, &pBuffer, &arrayBuffer);
2659    OHOS::xml::XmlSerializer xmlSerializer(reinterpret_cast<char*>(pBuffer), size, "utf-8");
2660    xmlSerializer.SetCData("root ]]> SYSTEM");
2661    std::string result = "<![CDATA[root ]]]]><![CDATA[> SYSTEM]]>";
2662    ASSERT_STREQ(reinterpret_cast<char*>(pBuffer), result.c_str());
2663}
2664
2665/* @tc.name: SetCDataFunction002
2666 * @tc.desc: Test SetCData Func
2667 * @tc.type: FUNC
2668 */
2669HWTEST_F(NativeEngineTest, SetCDataFunction002, testing::ext::TestSize.Level0)
2670{
2671    napi_env env = (napi_env)engine_;
2672    napi_value arrayBuffer = nullptr;
2673    void* pBuffer = nullptr;
2674    size_t size = 2048;
2675    napi_create_arraybuffer(env, size, &pBuffer, &arrayBuffer);
2676    OHOS::xml::XmlSerializer xmlSerializer(reinterpret_cast<char*>(pBuffer), size, "utf-8");
2677    xmlSerializer.StartElement("note");
2678    xmlSerializer.EndElement();
2679    xmlSerializer.SetCData("root SYSTEM \"http://www.test.org/test.dtd\"");
2680    std::string result = "<note/>\r\n<![CDATA[root SYSTEM \"http://www.test.org/test.dtd\"]]>";
2681    ASSERT_STREQ(reinterpret_cast<char*>(pBuffer), result.c_str());
2682}
2683
2684/* @tc.name: SetCDataFunction003
2685 * @tc.desc: Test SetCData Func
2686 * @tc.type: FUNC
2687 */
2688HWTEST_F(NativeEngineTest, SetCDataFunction003, testing::ext::TestSize.Level0)
2689{
2690    napi_env env = (napi_env)engine_;
2691    napi_value arrayBuffer = nullptr;
2692    void* pBuffer = nullptr;
2693    size_t size = 2048;
2694    napi_create_arraybuffer(env, size, &pBuffer, &arrayBuffer);
2695    OHOS::xml::XmlSerializer xmlSerializer(reinterpret_cast<char*>(pBuffer), size, "utf-8");
2696    xmlSerializer.StartElement("note");
2697    xmlSerializer.SetCData("root SYSTEM \"http://www.test.org/test.dtd\"");
2698    xmlSerializer.EndElement();
2699    std::string result = "<note>\r\n  <![CDATA[root SYSTEM \"http://www.test.org/test.dtd\"]]>\r\n</note>";
2700    ASSERT_STREQ(reinterpret_cast<char*>(pBuffer), result.c_str());
2701}
2702
2703/* @tc.name: WriteEscapedFunction001
2704 * @tc.desc: Test WriteEscaped Func
2705 * @tc.type: FUNC
2706 */
2707HWTEST_F(NativeEngineTest, WriteEscapedFunction001, testing::ext::TestSize.Level0)
2708{
2709    napi_env env = (napi_env)engine_;
2710    napi_value arrayBuffer = nullptr;
2711    void* pBuffer = nullptr;
2712    size_t size = 2048;
2713    napi_create_arraybuffer(env, size, &pBuffer, &arrayBuffer);
2714    OHOS::xml::XmlSerializer xmlSerializer(reinterpret_cast<char*>(pBuffer), size, "utf-8");
2715    xmlSerializer.StartElement("note");
2716    xmlSerializer.SetAttributes("importance", "high");
2717    xmlSerializer.SetText("Hello>World");
2718    xmlSerializer.EndElement();
2719    std::string result = "<note importance=\"high\">Hello&gt;World</note>";
2720    ASSERT_STREQ(reinterpret_cast<char*>(pBuffer), result.c_str());
2721}
2722
2723/* @tc.name: WriteEscapedFunction002
2724 * @tc.desc: Test WriteEscaped Func
2725 * @tc.type: FUNC
2726 */
2727HWTEST_F(NativeEngineTest, WriteEscapedFunction002, testing::ext::TestSize.Level0)
2728{
2729    napi_env env = (napi_env)engine_;
2730    napi_value arrayBuffer = nullptr;
2731    void* pBuffer = nullptr;
2732    size_t size = 2048;
2733    napi_create_arraybuffer(env, size, &pBuffer, &arrayBuffer);
2734    OHOS::xml::XmlSerializer xmlSerializer(reinterpret_cast<char*>(pBuffer), size, "utf-8");
2735    xmlSerializer.StartElement("note");
2736    xmlSerializer.SetAttributes("importance", "high");
2737    xmlSerializer.SetText("Hello<World");
2738    xmlSerializer.EndElement();
2739    std::string result = "<note importance=\"high\">Hello&lt;World</note>";
2740    ASSERT_STREQ(reinterpret_cast<char*>(pBuffer), result.c_str());
2741}
2742
2743/* @tc.name: WriteEscapedFunction003
2744 * @tc.desc: Test WriteEscaped Func
2745 * @tc.type: FUNC
2746 */
2747HWTEST_F(NativeEngineTest, WriteEscapedFunction003, testing::ext::TestSize.Level0)
2748{
2749    napi_env env = (napi_env)engine_;
2750    napi_value arrayBuffer = nullptr;
2751    void* pBuffer = nullptr;
2752    size_t size = 2048;
2753    napi_create_arraybuffer(env, size, &pBuffer, &arrayBuffer);
2754    OHOS::xml::XmlSerializer xmlSerializer(reinterpret_cast<char*>(pBuffer), size, "utf-8");
2755    xmlSerializer.StartElement("note");
2756    xmlSerializer.SetAttributes("importance", "high");
2757    xmlSerializer.SetText("Hello&World");
2758    xmlSerializer.EndElement();
2759    std::string result = "<note importance=\"high\">Hello&amp;World</note>";
2760    ASSERT_STREQ(reinterpret_cast<char*>(pBuffer), result.c_str());
2761}
2762
2763/* @tc.name: WriteEscapedFunction004
2764 * @tc.desc: Test WriteEscaped Func
2765 * @tc.type: FUNC
2766 */
2767HWTEST_F(NativeEngineTest, WriteEscapedFunction004, testing::ext::TestSize.Level0)
2768{
2769    napi_env env = (napi_env)engine_;
2770    napi_value arrayBuffer = nullptr;
2771    void* pBuffer = nullptr;
2772    size_t size = 2048;
2773    napi_create_arraybuffer(env, size, &pBuffer, &arrayBuffer);
2774    OHOS::xml::XmlSerializer xmlSerializer(reinterpret_cast<char*>(pBuffer), size, "utf-8");
2775    xmlSerializer.StartElement("note");
2776    xmlSerializer.SetAttributes("importance", "high");
2777    xmlSerializer.SetText("Hello'World");
2778    xmlSerializer.EndElement();
2779    std::string result = "<note importance=\"high\">Hello&apos;World</note>";
2780    ASSERT_STREQ(reinterpret_cast<char*>(pBuffer), result.c_str());
2781}
2782
2783/* @tc.name: XmlSerializerErrorFunction001
2784 * @tc.desc: Test XmlSerializerErro Func
2785 * @tc.type: FUNC
2786 */
2787HWTEST_F(NativeEngineTest, XmlSerializerErrorFunction001, testing::ext::TestSize.Level0)
2788{
2789    napi_env env = (napi_env)engine_;
2790    std::string outPut = XmlTest::XmlSerializerErrorFunction(env);
2791    std::string result = "illegal position for declaration";
2792    ASSERT_STREQ(outPut.c_str(), result.c_str());
2793}
2794
2795/* @tc.name: XmlParseTagValueFuncFunction001
2796 * @tc.desc: Test ParseTagValueFunc Func
2797 * @tc.type: FUNC
2798 */
2799HWTEST_F(NativeEngineTest, XmlParseTagValueFuncFunction001, testing::ext::TestSize.Level0)
2800{
2801    napi_env env = (napi_env)engine_;
2802    std::string str1 = "<?xml version=\"1.0\" encoding=\"utf-8\"?>";
2803    std::string str3 = "    <title>Hello\rWorld\n</title>";
2804    std::string str4 = "    <todo>Work\r\n</todo>";
2805    std::string strXml = str1 + str3 + str4;
2806    g_testStr = "";
2807    OHOS::xml::XmlPullParser xmlPullParser(env, strXml, "utf-8");
2808    napi_value options = nullptr;
2809    napi_create_object(env, &options);
2810    const char* key1 = "supportDoctype";
2811    const char* key2 = "ignoreNameSpace";
2812    const char* key3 = "tokenValueCallbackFunction";
2813    napi_value object = nullptr;
2814    napi_create_object(env, &object);
2815    napi_value value1 = nullptr;
2816    napi_value value2 = nullptr;
2817    napi_get_boolean(env, true, &value1);
2818    napi_get_boolean(env, true, &value2);
2819    napi_value value3 = nullptr;
2820    std::string cbName = "Method";
2821    napi_create_function(env, cbName.c_str(), cbName.size(), Method, nullptr, &value3);
2822    napi_set_named_property(env, object, key1, value1);
2823    napi_set_named_property(env, object, key2, value2);
2824    napi_set_named_property(env, object, key3, value3);
2825    xmlPullParser.DealOptionInfo(env, object);
2826    xmlPullParser.Parse(env, options);
2827    std::string result = "";
2828    ASSERT_STREQ(g_testStr.c_str(), result.c_str());
2829}
2830
2831/* @tc.name: XmlParseTagValueFuncFunction002
2832 * @tc.desc: Test ParseTagValueFunc Func
2833 * @tc.type: FUNC
2834 */
2835HWTEST_F(NativeEngineTest, XmlParseTagValueFuncFunction002, testing::ext::TestSize.Level0)
2836{
2837    napi_env env = (napi_env)engine_;
2838    std::string str1 = "<?xml version=\"1.0\" encoding=\"utf-8\"?>";
2839    char cRecv = static_cast<char>(10);
2840    size_t intPut = 49;
2841    std::string str2 = "Hello";
2842    bool res = XmlTest::ParseTagValueFunc(env, str1, cRecv, intPut, str2);
2843    ASSERT_TRUE(res);
2844}
2845
2846/* @tc.name: XmlParseTagValueFuncFunction003
2847 * @tc.desc: Test ParseTagValueFunc Func
2848 * @tc.type: FUNC
2849 */
2850HWTEST_F(NativeEngineTest, XmlParseTagValueFuncFunction003, testing::ext::TestSize.Level0)
2851{
2852    napi_env env = (napi_env)engine_;
2853    std::string str1 = "<?xml version=\"1.0\" encoding=\"utf-8\"?>";
2854    char cRecv = static_cast<char>(60);
2855    size_t intPut = 49;
2856    std::string str2 = "World";
2857    bool res = XmlTest::ParseTagValueFunc(env, str1, cRecv, intPut, str2);
2858    ASSERT_TRUE(res);
2859}
2860
2861/* @tc.name: XmlParseTagValueFuncFunction004
2862 * @tc.desc: Test ParseTagValueFunc Func
2863 * @tc.type: FUNC
2864 */
2865HWTEST_F(NativeEngineTest, XmlParseTagValueFuncFunction004, testing::ext::TestSize.Level0)
2866{
2867    napi_env env = (napi_env)engine_;
2868    std::string str1 = "<]>ml version=\"1.0\" encoding=\"utf-8\" standalone=\"no\"?><todo>Work</todo>";
2869    std::string str2 = "<note importance=\"high\" logged=\"true\">";
2870    std::string str3 = "    <title>Hello\rWorld\n</title>";
2871    std::string str4 = "    <todo>Work\r\n</todo>";
2872    std::string strXml = str1 + str2 + str3 + str4;
2873    char cRecv = static_cast<char>(93);
2874    size_t intPut = 60;
2875    std::string str = "work";
2876    bool res = XmlTest::ParseTagValueFunc(env, strXml, cRecv, intPut, str);
2877    ASSERT_TRUE(res);
2878}
2879
2880/* @tc.name: XmlParseTagValueFuncFunction005
2881 * @tc.desc: Test ParseTagValueFunc Func
2882 * @tc.type: FUNC
2883 */
2884HWTEST_F(NativeEngineTest, XmlParseTagValueFuncFunction005, testing::ext::TestSize.Level0)
2885{
2886    napi_env env = (napi_env)engine_;
2887    std::string str1 = "<?xml version=\"1.0\" encoding=\"utf-8\" standalone=\"no\"?><todo>Work</todo>";
2888    char cRecv = static_cast<char>(37);
2889    size_t intPut = 60;
2890    std::string str2 = "work";
2891    bool res = XmlTest::ParseTagValueFunc(env, str1, cRecv, intPut, str2);
2892    ASSERT_TRUE(res);
2893}
2894
2895/* @tc.name: XmlParseTagValueFuncFunction006
2896 * @tc.desc: Test ParseTagValueFunc Func
2897 * @tc.type: FUNC
2898 */
2899HWTEST_F(NativeEngineTest, XmlParseTagValueFuncFunction006, testing::ext::TestSize.Level0)
2900{
2901    napi_env env = (napi_env)engine_;
2902    std::string str1 = "<?xml version=\"1.0\" encoding=\"utf-8\"?><!DOCTYPE note [\n<!ENTITY foo \"baa\">]>";
2903    char cRecv = static_cast<char>(100);
2904    size_t intPut = 70;
2905    std::string str2 = "work";
2906    bool res = XmlTest::ParseTagValueFunc(env, str1, cRecv, intPut, str2);
2907    ASSERT_TRUE(res);
2908}
2909
2910/* @tc.name: XmlParseTagValueFuncFunction007
2911 * @tc.desc: Test ParseTagValueFunc Func
2912 * @tc.type: FUNC
2913 */
2914HWTEST_F(NativeEngineTest, XmlParseTagValueFuncFunction007, testing::ext::TestSize.Level0)
2915{
2916    napi_env env = (napi_env)engine_;
2917    std::string str1 = "<?xml version=\"1.0\" encoding=\"utf-8\"?>";
2918    std::string str2 = "<note importance=\"high\" logged=\"true\">";
2919    std::string str3 = "    <title>Hello\rWorld\n</title>";
2920    std::string str4 = "    <todo>Work\r\n</todo>";
2921    std::string str5 = "    <mess><![CDATA[This is a \r\n CDATA section]]></mess>";
2922    std::string str6 = "</note>";
2923    std::string strXml = str1 + str2 + str3 + str4 + str5 + str6;
2924    g_testStr = "";
2925    OHOS::xml::XmlPullParser xmlPullParser(env, strXml, "utf-8");
2926    napi_value options = nullptr;
2927    napi_create_object(env, &options);
2928    const char* key1 = "supportDoctype";
2929    const char* key2 = "ignoreNameSpace";
2930    const char* key3 = "tokenValueCallbackFunction";
2931    napi_value object = nullptr;
2932    napi_create_object(env, &object);
2933    napi_value value1 = nullptr;
2934    napi_value value2 = nullptr;
2935    napi_get_boolean(env, true, &value1);
2936    napi_get_boolean(env, true, &value2);
2937    napi_value value3 = nullptr;
2938    std::string cbName = "Method";
2939    napi_create_function(env, cbName.c_str(), cbName.size(), Method, nullptr, &value3);
2940    napi_set_named_property(env, object, key1, value1);
2941    napi_set_named_property(env, object, key2, value2);
2942    napi_set_named_property(env, object, key3, value3);
2943    xmlPullParser.DealOptionInfo(env, object);
2944    xmlPullParser.Parse(env, options);
2945    std::string result = "";
2946    ASSERT_STREQ(g_testStr.c_str(), result.c_str());
2947}
2948
2949/* @tc.name: ParseStartTagFunction001
2950 * @tc.desc: Test ParseStartTag Func
2951 * @tc.type: FUNC
2952 */
2953HWTEST_F(NativeEngineTest, ParseStartTagFunction001, testing::ext::TestSize.Level0)
2954{
2955    napi_env env = (napi_env)engine_;
2956    std::string xml = "<?xml version=\"1.0\" encoding=\"utf-8\" standalone=\"no\"?><todo>Work</todo>";
2957    bool res = XmlTest::ParseStartTag(env, xml);
2958    ASSERT_TRUE(res);
2959}
2960
2961/* @tc.name: ParseEndTagFunction001
2962 * @tc.desc: Test ParseStartTag Func
2963 * @tc.type: FUNC
2964 */
2965HWTEST_F(NativeEngineTest, ParseEndTagFunction001, testing::ext::TestSize.Level0)
2966{
2967    napi_env env = (napi_env)engine_;
2968    std::string xml = "<?xml version=\"1.0\" encoding=\"utf-8\"?>";
2969    bool res = XmlTest::ParseEndTagFunction(env, xml);
2970    ASSERT_TRUE(res);
2971}
2972
2973/* @tc.name: ParseInnerAttriDeclFunction001
2974 * @tc.desc: Test ParseInnerAttriDecl Func
2975 * @tc.type: FUNC
2976 */
2977HWTEST_F(NativeEngineTest, ParseInnerAttriDeclFunction001, testing::ext::TestSize.Level0)
2978{
2979    napi_env env = (napi_env)engine_;
2980    std::string str1 = "<?xml version=\"1.0\" encoding=\"utf-8\"?><!DOCTYPE note";
2981    std::string str2 = " [\n<!ATTLIST operand type src # \"dest\">]><note importance=\"high\" logged=\"true\">";
2982    std::string strXml = str1 + str2;
2983    g_testStr = "";
2984    OHOS::xml::XmlPullParser xmlPullParser(env, strXml, "utf-8");
2985    napi_value options = nullptr;
2986    napi_create_object(env, &options);
2987    const char* key1 = "supportDoctype";
2988    const char* key2 = "ignoreNameSpace";
2989    const char* key3 = "tokenValueCallbackFunction";
2990    napi_value object = nullptr;
2991    napi_create_object(env, &object);
2992    napi_value value1 = nullptr;
2993    napi_value value2 = nullptr;
2994    napi_get_boolean(env, true, &value1);
2995    napi_get_boolean(env, true, &value2);
2996    napi_value value3 = nullptr;
2997    std::string cbName = "Method";
2998    napi_create_function(env, cbName.c_str(), cbName.size(), Method, nullptr, &value3);
2999    napi_set_named_property(env, object, key1, value1);
3000    napi_set_named_property(env, object, key2, value2);
3001    napi_set_named_property(env, object, key3, value3);
3002    xmlPullParser.DealOptionInfo(env, object);
3003    xmlPullParser.Parse(env, options);
3004    ASSERT_STREQ(g_testStr.c_str(), "");
3005}
3006
3007/* @tc.name: ParseInnerAttriDeclFunction002
3008 * @tc.desc: Test ParseInnerAttriDecl Func
3009 * @tc.type: FUNC
3010 */
3011HWTEST_F(NativeEngineTest, ParseInnerAttriDeclFunction002, testing::ext::TestSize.Level0)
3012{
3013    napi_env env = (napi_env)engine_;
3014    std::string str1 = "<?xml version=\"1.0\" encoding=\"utf-8\"?><!DOCTYPE note";
3015    std::string str2 = " [\n<!ATTLIST operand type src #R \"dest\">]><note importance=\"high\" logged=\"true\">";
3016    std::string strXml = str1 + str2;
3017    g_testStr = "";
3018    OHOS::xml::XmlPullParser xmlPullParser(env, strXml, "utf-8");
3019    napi_value options = nullptr;
3020    napi_create_object(env, &options);
3021    const char* key1 = "supportDoctype";
3022    const char* key2 = "ignoreNameSpace";
3023    const char* key3 = "tokenValueCallbackFunction";
3024    napi_value object = nullptr;
3025    napi_create_object(env, &object);
3026    napi_value value1 = nullptr;
3027    napi_value value2 = nullptr;
3028    napi_get_boolean(env, true, &value1);
3029    napi_get_boolean(env, true, &value2);
3030    napi_value value3 = nullptr;
3031    std::string cbName = "Method";
3032    napi_create_function(env, cbName.c_str(), cbName.size(), Method, nullptr, &value3);
3033    napi_set_named_property(env, object, key1, value1);
3034    napi_set_named_property(env, object, key2, value2);
3035    napi_set_named_property(env, object, key3, value3);
3036    xmlPullParser.DealOptionInfo(env, object);
3037    xmlPullParser.Parse(env, options);
3038    ASSERT_STREQ(g_testStr.c_str(), "");
3039}
3040
3041/* @tc.name: ParseInnerAttriDeclFunction003
3042 * @tc.desc: Test ParseInnerAttriDecl Func
3043 * @tc.type: FUNC
3044 */
3045HWTEST_F(NativeEngineTest, ParseInnerAttriDeclFunction003, testing::ext::TestSize.Level0)
3046{
3047    napi_env env = (napi_env)engine_;
3048    std::string str1 = "<?xml version=\"1.0\" encoding=\"utf-8\"?><!DOCTYPE note";
3049    std::string str2 = " [\n<!ATTLIST operand type src #F>>>>\"dest\">]><note importance=\"high\" logged=\"true\">";
3050    std::string strXml = str1 + str2;
3051    g_testStr = "";
3052    OHOS::xml::XmlPullParser xmlPullParser(env, strXml, "utf-8");
3053    napi_value options = nullptr;
3054    napi_create_object(env, &options);
3055    const char* key1 = "supportDoctype";
3056    const char* key2 = "ignoreNameSpace";
3057    const char* key3 = "tokenValueCallbackFunction";
3058    napi_value object = nullptr;
3059    napi_create_object(env, &object);
3060    napi_value value1 = nullptr;
3061    napi_value value2 = nullptr;
3062    napi_get_boolean(env, true, &value1);
3063    napi_get_boolean(env, true, &value2);
3064    napi_value value3 = nullptr;
3065    std::string cbName = "Method";
3066    napi_create_function(env, cbName.c_str(), cbName.size(), Method, nullptr, &value3);
3067    napi_set_named_property(env, object, key1, value1);
3068    napi_set_named_property(env, object, key2, value2);
3069    napi_set_named_property(env, object, key3, value3);
3070    xmlPullParser.DealOptionInfo(env, object);
3071    xmlPullParser.Parse(env, options);
3072    ASSERT_STREQ(g_testStr.c_str(), "");
3073}
3074
3075/* @tc.name: ParseInnerAttriDeclFunction004
3076 * @tc.desc: Test ParseInnerAttriDecl Func
3077 * @tc.type: FUNC
3078 */
3079HWTEST_F(NativeEngineTest, ParseInnerAttriDeclFunction004, testing::ext::TestSize.Level0)
3080{
3081    napi_env env = (napi_env)engine_;
3082    std::string str1 = "<?xml version=\"1.0\" encoding=\"utf-8\"?><!DOCTYPE note";
3083    std::string str2 = " [\n<!ATTLIST operand type src #III>>>>\"dest\">]><note importance=\"high\" logged=\"true\">";
3084    std::string strXml = str1 + str2;
3085    g_testStr = "";
3086    OHOS::xml::XmlPullParser xmlPullParser(env, strXml, "utf-8");
3087    napi_value options = nullptr;
3088    napi_create_object(env, &options);
3089    const char* key1 = "supportDoctype";
3090    const char* key2 = "ignoreNameSpace";
3091    const char* key3 = "tokenValueCallbackFunction";
3092    napi_value object = nullptr;
3093    napi_create_object(env, &object);
3094    napi_value value1 = nullptr;
3095    napi_value value2 = nullptr;
3096    napi_get_boolean(env, true, &value1);
3097    napi_get_boolean(env, true, &value2);
3098    napi_value value3 = nullptr;
3099    std::string cbName = "Method";
3100    napi_create_function(env, cbName.c_str(), cbName.size(), Method, nullptr, &value3);
3101    napi_set_named_property(env, object, key1, value1);
3102    napi_set_named_property(env, object, key2, value2);
3103    napi_set_named_property(env, object, key3, value3);
3104    xmlPullParser.DealOptionInfo(env, object);
3105    xmlPullParser.Parse(env, options);
3106    ASSERT_STREQ(g_testStr.c_str(), "");
3107}
3108
3109/* @tc.name: ParseInnerAttriDeclFuncFunction001
3110 * @tc.desc: Test ParseInnerAttriDeclFunc Func
3111 * @tc.type: FUNC
3112 */
3113HWTEST_F(NativeEngineTest, ParseInnerAttriDeclFuncFunction001, testing::ext::TestSize.Level0)
3114{
3115    napi_env env = (napi_env)engine_;
3116    std::string str1 = "<?xml version=\"1.0\" encoding=\"utf-8\"?><!DOCTYPE note";
3117    std::string str2 = " [\n<!ATTLIST operand type src #III>>>>()\"dest\">]>";
3118    std::string str3 = "<note importance=\"high\" logged=\"true\">";
3119    std::string strXml = str1 + str2 + str3;
3120    g_testStr = "";
3121    OHOS::xml::XmlPullParser xmlPullParser(env, strXml, "utf-8");
3122    napi_value options = nullptr;
3123    napi_create_object(env, &options);
3124    const char* key1 = "supportDoctype";
3125    const char* key2 = "ignoreNameSpace";
3126    const char* key3 = "tokenValueCallbackFunction";
3127    napi_value object = nullptr;
3128    napi_create_object(env, &object);
3129    napi_value value1 = nullptr;
3130    napi_value value2 = nullptr;
3131    napi_get_boolean(env, true, &value1);
3132    napi_get_boolean(env, true, &value2);
3133    napi_value value3 = nullptr;
3134    std::string cbName = "Method";
3135    napi_create_function(env, cbName.c_str(), cbName.size(), Method, nullptr, &value3);
3136    napi_set_named_property(env, object, key1, value1);
3137    napi_set_named_property(env, object, key2, value2);
3138    napi_set_named_property(env, object, key3, value3);
3139    xmlPullParser.DealOptionInfo(env, object);
3140    xmlPullParser.Parse(env, options);
3141    ASSERT_STREQ(g_testStr.c_str(), "");
3142}
3143
3144/* @tc.name: ParseInnerAttriDeclFuncFunction002
3145 * @tc.desc: Test ParseInnerAttriDeclFunc Func
3146 * @tc.type: FUNC
3147 */
3148HWTEST_F(NativeEngineTest, ParseInnerAttriDeclFuncFunction002, testing::ext::TestSize.Level0)
3149{
3150    napi_env env = (napi_env)engine_;
3151    std::string str1 = "<?xml version=\"1.0\" encoding=\"utf-8\"?><!DOCTYPE note";
3152    std::string str2 = " [\n<!ATTLIST operand type src #III>>>>(|)\"dest\">]>";
3153    std::string str3 = "<note importance=\"high\" logged=\"true\">";
3154    std::string strXml = str1 + str2 + str3;
3155    g_testStr = "";
3156    OHOS::xml::XmlPullParser xmlPullParser(env, strXml, "utf-8");
3157    napi_value options = nullptr;
3158    napi_create_object(env, &options);
3159    const char* key1 = "supportDoctype";
3160    const char* key2 = "ignoreNameSpace";
3161    const char* key3 = "tokenValueCallbackFunction";
3162    napi_value object = nullptr;
3163    napi_create_object(env, &object);
3164    napi_value value1 = nullptr;
3165    napi_value value2 = nullptr;
3166    napi_get_boolean(env, true, &value1);
3167    napi_get_boolean(env, true, &value2);
3168    napi_value value3 = nullptr;
3169    std::string cbName = "Method";
3170    napi_create_function(env, cbName.c_str(), cbName.size(), Method, nullptr, &value3);
3171    napi_set_named_property(env, object, key1, value1);
3172    napi_set_named_property(env, object, key2, value2);
3173    napi_set_named_property(env, object, key3, value3);
3174    xmlPullParser.DealOptionInfo(env, object);
3175    xmlPullParser.Parse(env, options);
3176    ASSERT_STREQ(g_testStr.c_str(), "");
3177}
3178
3179/* @tc.name: DealLengthFunction001
3180 * @tc.desc: Test DealLength Func
3181 * @tc.type: FUNC
3182 */
3183HWTEST_F(NativeEngineTest, DealLengthFunction001, testing::ext::TestSize.Level0)
3184{
3185    napi_env env = (napi_env)engine_;
3186    std::string xml = "<?xml version=\"1.0\" encoding=\"utf-8\" standalone=\"no\"?><todo>Work</todo>";
3187    size_t minimum = 10;
3188    std::string pushStr = "<note importance=\"high\" logged=\"true\">";
3189    std::string result = XmlTest::DealLengthFuc(env, xml, minimum, pushStr);
3190    std::string outPut = "<note importance=\"high\" logged=\"true\"><?xml vers";
3191    ASSERT_STREQ(result.c_str(), outPut.c_str());
3192}
3193
3194/* @tc.name: SkipCharFunction001
3195 * @tc.desc: Test SkipCharFunction Func
3196 * @tc.type: FUNC
3197 */
3198HWTEST_F(NativeEngineTest, SkipCharFunction001, testing::ext::TestSize.Level0)
3199{
3200    napi_env env = (napi_env)engine_;
3201    std::string xml = "<?xml version=\"1.0\" encoding=\"utf-8\" standalone=\"no\"?><todo>Work</todo>";
3202    char expected = static_cast<char>(10);
3203    OHOS::xml::XmlTest testXml;
3204    int output = testXml.SkipCharFunction(env, xml, expected);
3205    ASSERT_EQ(output, 63);
3206}