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