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