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