1 /*
2 * Copyright (c) 2022 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "test_xml.h"
17 #include "test.h"
18
19 #include "napi/native_api.h"
20 #include "napi/native_node_api.h"
21
22 #include "js_xml.h"
23 #include "native_module_xml.h"
24 #include "securec.h"
25 #include "tools/log.h"
26
27 using namespace OHOS::xml;
28
29 #define ASSERT_CHECK_CALL(call) \
30 { \
31 ASSERT_EQ(call, napi_ok); \
32 }
33
34 #define ASSERT_CHECK_VALUE_TYPE(env, value, type) \
35 { \
36 napi_valuetype valueType = napi_undefined; \
37 ASSERT_TRUE(value != nullptr); \
38 ASSERT_CHECK_CALL(napi_typeof(env, value, &valueType)); \
39 ASSERT_EQ(valueType, type); \
40 }
41
42 static std::string g_testStr = "";
Method(napi_env env,napi_callback_info info)43 napi_value Method(napi_env env, napi_callback_info info)
44 {
45 napi_value thisVar = nullptr;
46 size_t argc = 0;
47 napi_value args[6] = { 0 }; // 6:six args
48 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, nullptr, &thisVar, nullptr));
49 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, &thisVar, nullptr));
50
51 napi_value name = args[0];
52 napi_value value = args[1];
53
54 std::string buffer1 = "";
55 size_t bufferSize1 = 0;
56 napi_get_value_string_utf8(env, name, nullptr, 0, &bufferSize1);
57 buffer1.reserve(bufferSize1 + 1);
58 buffer1.resize(bufferSize1);
59 napi_get_value_string_utf8(env, name, buffer1.data(), bufferSize1 + 1, &bufferSize1);
60
61 std::string buffer2 = "";
62 size_t bufferSize2 = 0;
63 napi_get_value_string_utf8(env, value, nullptr, 0, &bufferSize2);
64 buffer2.reserve(bufferSize2 + 1);
65 buffer2.resize(bufferSize2);
66 napi_get_value_string_utf8(env, value, buffer2.data(), bufferSize2 + 1, &bufferSize2);
67 g_testStr += buffer1 + buffer2;
68 napi_value result = nullptr;
69 napi_get_boolean(env, true, &result);
70 return result;
71 }
72
TokenValueCallbackFunction(napi_env env,napi_callback_info info)73 napi_value TokenValueCallbackFunction(napi_env env, napi_callback_info info)
74 {
75 napi_value thisVar = nullptr;
76 size_t argc = 0;
77 napi_value args[6] = { 0 }; // 6:six args
78 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, nullptr, &thisVar, nullptr));
79 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, &thisVar, nullptr));
80 napi_value value = args[1];
81 napi_value value3 = nullptr;
82 napi_get_named_property(env, value, "getDepth", &value3);
83 napi_get_named_property(env, value, "getColumnNumber", &value3);
84 napi_get_named_property(env, value, "getLineNumber", &value3);
85 napi_get_named_property(env, value, "getAttributeCount", &value3);
86 napi_get_named_property(env, value, "getName", &value3);
87 napi_get_named_property(env, value, "getNamespace", &value3);
88 napi_get_named_property(env, value, "getPrefix", &value3);
89 napi_get_named_property(env, value, "getText", &value3);
90 napi_get_named_property(env, value, "isEmptyElementTag", &value3);
91 napi_get_named_property(env, value, "isWhitespace", &value3);
92 napi_valuetype result2 = napi_null;
93 napi_typeof(env, value3, &result2);
94 napi_value returnVal = nullptr;
95 napi_call_function(env, thisVar, value3, 0, nullptr, &returnVal);
96
97 napi_value result = nullptr;
98 napi_get_boolean(env, true, &result);
99 return result;
100 }
101
TokenValueCallbackFunc(napi_env env,napi_callback_info info)102 napi_value TokenValueCallbackFunc(napi_env env, napi_callback_info info)
103 {
104 napi_value thisVar = nullptr;
105 size_t argc = 0;
106 napi_value args[6] = { 0 }; // 6:six args
107 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, nullptr, &thisVar, nullptr));
108 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, &thisVar, nullptr));
109 napi_value value = args[1];
110 napi_value value3 = nullptr;
111 napi_get_named_property(env, value, "getDepth", &value3);
112 napi_value returnVal = nullptr;
113 napi_call_function(env, thisVar, value3, 0, nullptr, &returnVal);
114 napi_get_named_property(env, value, "getColumnNumber", &value3);
115 napi_call_function(env, thisVar, value3, 0, nullptr, &returnVal);
116 napi_get_named_property(env, value, "getLineNumber", &value3);
117 napi_call_function(env, thisVar, value3, 0, nullptr, &returnVal);
118 napi_get_named_property(env, value, "getAttributeCount", &value3);
119 napi_call_function(env, thisVar, value3, 0, nullptr, &returnVal);
120 napi_get_named_property(env, value, "getName", &value3);
121 napi_call_function(env, thisVar, value3, 0, nullptr, &returnVal);
122 napi_get_named_property(env, value, "getNamespace", &value3);
123 napi_call_function(env, thisVar, value3, 0, nullptr, &returnVal);
124 napi_get_named_property(env, value, "getPrefix", &value3);
125 napi_call_function(env, thisVar, value3, 0, nullptr, &returnVal);
126 napi_get_named_property(env, value, "getText", &value3);
127 napi_call_function(env, thisVar, value3, 0, nullptr, &returnVal);
128 napi_get_named_property(env, value, "isEmptyElementTag", &value3);
129 napi_call_function(env, thisVar, value3, 0, nullptr, &returnVal);
130 napi_get_named_property(env, value, "isWhitespace", &value3);
131 napi_call_function(env, thisVar, value3, 0, nullptr, &returnVal);
132
133 napi_value result = nullptr;
134 napi_get_boolean(env, true, &result);
135 return result;
136 }
137
138 /* @tc.name: StartElementTest001
139 * @tc.desc: Test whether write a elemnet start tag with the given name successfully.
140 * @tc.type: FUNC
141 */
142 HWTEST_F(NativeEngineTest, StartElementTest001, testing::ext::TestSize.Level0)
143 {
144 napi_env env = (napi_env)engine_;
145 napi_value arrayBuffer = nullptr;
146 void* pBuffer = nullptr;
147 size_t size = 1024;
148 napi_create_arraybuffer(env, size, &pBuffer, &arrayBuffer);
149 OHOS::xml::XmlSerializer xmlSerializer(reinterpret_cast<char*>(pBuffer), size, "utf-8");
150 xmlSerializer.StartElement("note1");
151 xmlSerializer.EndElement();
152 ASSERT_STREQ(reinterpret_cast<char*>(pBuffer), "<note1/>");
153 }
154
155 /* @tc.name: StartElementTest002
156 * @tc.desc: Test whether write a elemnet start tag with the given name successfully.
157 * @tc.type: FUNC
158 */
159 HWTEST_F(NativeEngineTest, StartElementTest002, testing::ext::TestSize.Level0)
160 {
161 napi_env env = (napi_env)engine_;
162 napi_value arrayBuffer = nullptr;
163 void* pBuffer = nullptr;
164 size_t size = 1024;
165 napi_create_arraybuffer(env, size, &pBuffer, &arrayBuffer);
166 OHOS::xml::XmlSerializer xmlSerializer(reinterpret_cast<char*>(pBuffer), size, "utf-8");
167 xmlSerializer.StartElement("note1");
168 xmlSerializer.EndElement();
169 xmlSerializer.StartElement("note2");
170 xmlSerializer.EndElement();
171 ASSERT_STREQ(reinterpret_cast<char*>(pBuffer), "<note1/>\r\n<note2/>");
172 }
173
174 /* @tc.name: StartElementTest003
175 * @tc.desc: Test whether write a elemnet start tag with the given name successfully.
176 * @tc.type: FUNC
177 */
178 HWTEST_F(NativeEngineTest, StartElementTest003, testing::ext::TestSize.Level0)
179 {
180 napi_env env = (napi_env)engine_;
181 napi_value arrayBuffer = nullptr;
182 void* pBuffer = nullptr;
183 size_t size = 1024;
184 napi_create_arraybuffer(env, size, &pBuffer, &arrayBuffer);
185 OHOS::xml::XmlSerializer xmlSerializer(reinterpret_cast<char*>(pBuffer), size, "utf-8");
186 xmlSerializer.StartElement("note1");
187 xmlSerializer.StartElement("note2");
188 xmlSerializer.EndElement();
189 xmlSerializer.EndElement();
190 ASSERT_STREQ(reinterpret_cast<char*>(pBuffer), "<note1>\r\n <note2/>\r\n</note1>");
191 }
192
193 /* @tc.name: StartElementTest004
194 * @tc.desc: Test whether write a elemnet start tag with the given name successfully.
195 * @tc.type: FUNC
196 */
197 HWTEST_F(NativeEngineTest, StartElementTest004, testing::ext::TestSize.Level0)
198 {
199 napi_env env = (napi_env)engine_;
200 napi_value arrayBuffer = nullptr;
201 void* pBuffer = nullptr;
202 size_t size = 1024;
203 napi_create_arraybuffer(env, size, &pBuffer, &arrayBuffer);
204 OHOS::xml::XmlSerializer xmlSerializer(reinterpret_cast<char*>(pBuffer), size, "utf-8");
205 xmlSerializer.StartElement("note1");
206 xmlSerializer.StartElement("note2");
207 xmlSerializer.StartElement("note3");
208 xmlSerializer.EndElement();
209 xmlSerializer.EndElement();
210 xmlSerializer.EndElement();
211 ASSERT_STREQ(reinterpret_cast<char*>(pBuffer), "<note1>\r\n <note2>\r\n <note3/>\r\n </note2>\r\n</note1>");
212 }
213
214 /* @tc.name: StartElementTest005
215 * @tc.desc: Test whether write a elemnet start tag with the given name successfully.
216 * @tc.type: FUNC
217 */
218 HWTEST_F(NativeEngineTest, StartElementTest005, testing::ext::TestSize.Level0)
219 {
220 napi_env env = (napi_env)engine_;
221 napi_value arrayBuffer = nullptr;
222 void* pBuffer = nullptr;
223 size_t size = 1024;
224 napi_create_arraybuffer(env, size, &pBuffer, &arrayBuffer);
225 OHOS::xml::XmlSerializer xmlSerializer(reinterpret_cast<char*>(pBuffer), size, "utf-8");
226 xmlSerializer.StartElement("note1");
227 xmlSerializer.StartElement("note2");
228 xmlSerializer.EndElement();
229 xmlSerializer.StartElement("note3");
230 xmlSerializer.EndElement();
231 xmlSerializer.EndElement();
232 ASSERT_STREQ(reinterpret_cast<char*>(pBuffer), "<note1>\r\n <note2/>\r\n <note3/>\r\n</note1>");
233 }
234
235 /* @tc.name: SetAttributesTest001
236 * @tc.desc: Test whether write an attribute successfully.
237 * @tc.type: FUNC
238 */
239 HWTEST_F(NativeEngineTest, SetAttributesTest001, testing::ext::TestSize.Level0)
240 {
241 napi_env env = (napi_env)engine_;
242 napi_value arrayBuffer = nullptr;
243 void* pBuffer = nullptr;
244 size_t size = 1024;
245 napi_create_arraybuffer(env, size, &pBuffer, &arrayBuffer);
246 OHOS::xml::XmlSerializer xmlSerializer(reinterpret_cast<char*>(pBuffer), size, "utf-8");
247 xmlSerializer.StartElement("note");
248 xmlSerializer.SetAttributes("importance1", "high1");
249 xmlSerializer.EndElement();
250 ASSERT_STREQ(reinterpret_cast<char*>(pBuffer), "<note importance1=\"high1\"/>");
251 }
252
253 /* @tc.name: SetAttributesTest002
254 * @tc.desc: Test whether write an attribute successfully.
255 * @tc.type: FUNC
256 */
257 HWTEST_F(NativeEngineTest, SetAttributesTest002, testing::ext::TestSize.Level0)
258 {
259 napi_env env = (napi_env)engine_;
260 napi_value arrayBuffer = nullptr;
261 void* pBuffer = nullptr;
262 size_t size = 1024;
263 napi_create_arraybuffer(env, size, &pBuffer, &arrayBuffer);
264 OHOS::xml::XmlSerializer xmlSerializer(reinterpret_cast<char*>(pBuffer), size, "utf-8");
265 xmlSerializer.StartElement("note");
266 xmlSerializer.SetAttributes("importance1", "high1");
267 xmlSerializer.SetAttributes("importance2", "high2");
268 xmlSerializer.EndElement();
269 ASSERT_STREQ(reinterpret_cast<char*>(pBuffer), "<note importance1=\"high1\" importance2=\"high2\"/>");
270 }
271
272 /* @tc.name: SetAttributesTest003
273 * @tc.desc: Test whether write an attribute successfully.
274 * @tc.type: FUNC
275 */
276 HWTEST_F(NativeEngineTest, SetAttributesTest003, testing::ext::TestSize.Level0)
277 {
278 napi_env env = (napi_env)engine_;
279 napi_value arrayBuffer = nullptr;
280 void* pBuffer = nullptr;
281 size_t size = 1024;
282 napi_create_arraybuffer(env, size, &pBuffer, &arrayBuffer);
283 OHOS::xml::XmlSerializer xmlSerializer(reinterpret_cast<char*>(pBuffer), size, "utf-8");
284 xmlSerializer.StartElement("note");
285 xmlSerializer.SetAttributes("importance1", "high1");
286 xmlSerializer.SetAttributes("importance2", "high2");
287 xmlSerializer.SetAttributes("importance3", "high3");
288 xmlSerializer.EndElement();
289 ASSERT_STREQ(reinterpret_cast<char*>(pBuffer),
290 "<note importance1=\"high1\" importance2=\"high2\" importance3=\"high3\"/>");
291 }
292
293 /* @tc.name: SetAttributesTest004
294 * @tc.desc: Test whether write an attribute successfully.
295 * @tc.type: FUNC
296 */
297 HWTEST_F(NativeEngineTest, SetAttributesTest004, testing::ext::TestSize.Level0)
298 {
299 napi_env env = (napi_env)engine_;
300 napi_value arrayBuffer = nullptr;
301 void* pBuffer = nullptr;
302 size_t size = 1024;
303 napi_create_arraybuffer(env, size, &pBuffer, &arrayBuffer);
304 OHOS::xml::XmlSerializer xmlSerializer(reinterpret_cast<char*>(pBuffer), size, "utf-8");
305 xmlSerializer.StartElement("note");
306 xmlSerializer.SetAttributes("importance1", "high1");
307 xmlSerializer.SetAttributes("importance2", "high2");
308 xmlSerializer.SetAttributes("importance3", "high3");
309 xmlSerializer.SetAttributes("importance4", "high4");
310 xmlSerializer.EndElement();
311 ASSERT_STREQ(reinterpret_cast<char*>(pBuffer),
312 "<note importance1=\"high1\" importance2=\"high2\" importance3=\"high3\" importance4=\"high4\"/>");
313 }
314
315 /* @tc.name: SetAttributesTest005
316 * @tc.desc: Test whether write an attribute successfully.
317 * @tc.type: FUNC
318 */
319 HWTEST_F(NativeEngineTest, SetAttributesTest005, testing::ext::TestSize.Level0)
320 {
321 napi_env env = (napi_env)engine_;
322 napi_value arrayBuffer = nullptr;
323 void* pBuffer = nullptr;
324 size_t size = 1024;
325 napi_create_arraybuffer(env, size, &pBuffer, &arrayBuffer);
326 OHOS::xml::XmlSerializer xmlSerializer(reinterpret_cast<char*>(pBuffer), size, "utf-8");
327 xmlSerializer.StartElement("note");
328 xmlSerializer.SetAttributes("importance1", "high1");
329 xmlSerializer.SetAttributes("importance2", "high2");
330 xmlSerializer.SetAttributes("importance3", "high3");
331 xmlSerializer.SetAttributes("importance4", "high4");
332 xmlSerializer.SetAttributes("importance5", "high5");
333 xmlSerializer.EndElement();
334 std::string strPrior = "<note importance1=\"high1\" importance2=\"high2\" ";
335 std::string strBack = "importance3=\"high3\" importance4=\"high4\" importance5=\"high5\"/>";
336 std::string strEnd = strPrior + strBack;
337 ASSERT_STREQ(reinterpret_cast<char*>(pBuffer), strEnd.c_str());
338 }
339
340 /* @tc.name: AddEmptyElementTest001
341 * @tc.desc: Test whether add an empty element successfully.
342 * @tc.type: FUNC
343 */
344 HWTEST_F(NativeEngineTest, AddEmptyElementTest001, testing::ext::TestSize.Level0)
345 {
346 napi_env env = (napi_env)engine_;
347 napi_value arrayBuffer = nullptr;
348 void* pBuffer = nullptr;
349 size_t size = 1024;
350 napi_create_arraybuffer(env, size, &pBuffer, &arrayBuffer);
351 OHOS::xml::XmlSerializer xmlSerializer(reinterpret_cast<char*>(pBuffer), size, "utf-8");
352 xmlSerializer.StartElement("note");
353 xmlSerializer.AddEmptyElement("a");
354 xmlSerializer.EndElement();
355 ASSERT_STREQ(reinterpret_cast<char*>(pBuffer), "<note>\r\n <a/>\r\n</note>");
356 }
357
358 /* @tc.name: AddEmptyElementTest002
359 * @tc.desc: Test whether add an empty element successfully.
360 * @tc.type: FUNC
361 */
362 HWTEST_F(NativeEngineTest, AddEmptyElementTest002, testing::ext::TestSize.Level0)
363 {
364 napi_env env = (napi_env)engine_;
365 napi_value arrayBuffer = nullptr;
366 void* pBuffer = nullptr;
367 size_t size = 1024;
368 napi_create_arraybuffer(env, size, &pBuffer, &arrayBuffer);
369 OHOS::xml::XmlSerializer xmlSerializer(reinterpret_cast<char*>(pBuffer), size, "utf-8");
370 xmlSerializer.StartElement("note");
371 xmlSerializer.EndElement();
372 xmlSerializer.AddEmptyElement("b");
373 ASSERT_STREQ(reinterpret_cast<char*>(pBuffer), "<note/>\r\n<b/>");
374 }
375
376 /* @tc.name: AddEmptyElementTest003
377 * @tc.desc: Test whether add an empty element successfully.
378 * @tc.type: FUNC
379 */
380 HWTEST_F(NativeEngineTest, AddEmptyElementTest003, testing::ext::TestSize.Level0)
381 {
382 napi_env env = (napi_env)engine_;
383 napi_value arrayBuffer = nullptr;
384 void* pBuffer = nullptr;
385 size_t size = 1024;
386 napi_create_arraybuffer(env, size, &pBuffer, &arrayBuffer);
387 OHOS::xml::XmlSerializer xmlSerializer(reinterpret_cast<char*>(pBuffer), size, "utf-8");
388 xmlSerializer.AddEmptyElement("c");
389 xmlSerializer.StartElement("note");
390 xmlSerializer.EndElement();
391 ASSERT_STREQ(reinterpret_cast<char*>(pBuffer), "<c/>\r\n<note/>");
392 }
393
394 /* @tc.name: AddEmptyElementTest004
395 * @tc.desc: Test whether add an empty element successfully.
396 * @tc.type: FUNC
397 */
398 HWTEST_F(NativeEngineTest, AddEmptyElementTest004, testing::ext::TestSize.Level0)
399 {
400 napi_env env = (napi_env)engine_;
401 napi_value arrayBuffer = nullptr;
402 void* pBuffer = nullptr;
403 size_t size = 1024;
404 napi_create_arraybuffer(env, size, &pBuffer, &arrayBuffer);
405 OHOS::xml::XmlSerializer xmlSerializer(reinterpret_cast<char*>(pBuffer), size, "utf-8");
406 xmlSerializer.AddEmptyElement("d");
407 ASSERT_STREQ(reinterpret_cast<char*>(pBuffer), "<d/>");
408 }
409
410 /* @tc.name: AddEmptyElementTest005
411 * @tc.desc: Test whether add an empty element successfully.
412 * @tc.type: FUNC
413 */
414 HWTEST_F(NativeEngineTest, AddEmptyElementTest005, testing::ext::TestSize.Level0)
415 {
416 napi_env env = (napi_env)engine_;
417 napi_value arrayBuffer = nullptr;
418 void* pBuffer = nullptr;
419 size_t size = 1024;
420 napi_create_arraybuffer(env, size, &pBuffer, &arrayBuffer);
421 OHOS::xml::XmlSerializer xmlSerializer(reinterpret_cast<char*>(pBuffer), size, "utf-8");
422 xmlSerializer.StartElement("note");
423 xmlSerializer.AddEmptyElement("c");
424 xmlSerializer.AddEmptyElement("d");
425 xmlSerializer.EndElement();
426 ASSERT_STREQ(reinterpret_cast<char*>(pBuffer), "<note>\r\n <c/>\r\n <d/>\r\n</note>");
427 }
428
429 /* @tc.name: SetDeclarationTest001
430 * @tc.desc: Test whether write xml declaration with encoding successfully.
431 * @tc.type: FUNC
432 */
433 HWTEST_F(NativeEngineTest, SetDeclarationTest001, testing::ext::TestSize.Level0)
434 {
435 napi_env env = (napi_env)engine_;
436 napi_value arrayBuffer = nullptr;
437 void* pBuffer = nullptr;
438 size_t size = 1024;
439 napi_create_arraybuffer(env, size, &pBuffer, &arrayBuffer);
440 OHOS::xml::XmlSerializer xmlSerializer(reinterpret_cast<char*>(pBuffer), size, "utf-8");
441 xmlSerializer.SetDeclaration();
442 ASSERT_STREQ(reinterpret_cast<char*>(pBuffer), "<?xml version=\"1.0\" encoding=\"utf-8\"?>");
443 }
444
445 /* @tc.name: SetDeclarationTest002
446 * @tc.desc: Test whether write xml declaration with encoding successfully.
447 * @tc.type: FUNC
448 */
449 HWTEST_F(NativeEngineTest, SetDeclarationTest002, testing::ext::TestSize.Level0)
450 {
451 napi_env env = (napi_env)engine_;
452 napi_value arrayBuffer = nullptr;
453 void* pBuffer = nullptr;
454 size_t size = 1024;
455 napi_create_arraybuffer(env, size, &pBuffer, &arrayBuffer);
456 OHOS::xml::XmlSerializer xmlSerializer(reinterpret_cast<char*>(pBuffer), size, "utf-8");
457 xmlSerializer.SetDeclaration();
458 ASSERT_STREQ(reinterpret_cast<char*>(pBuffer), "<?xml version=\"1.0\" encoding=\"utf-8\"?>");
459 }
460
461 /* @tc.name: SetDeclarationTest003
462 * @tc.desc: Test whether write xml declaration with encoding successfully.
463 * @tc.type: FUNC
464 */
465 HWTEST_F(NativeEngineTest, SetDeclarationTest003, testing::ext::TestSize.Level0)
466 {
467 napi_env env = (napi_env)engine_;
468 napi_value arrayBuffer = nullptr;
469 void* pBuffer = nullptr;
470 size_t size = 1024;
471 napi_create_arraybuffer(env, size, &pBuffer, &arrayBuffer);
472 OHOS::xml::XmlSerializer xmlSerializer(reinterpret_cast<char*>(pBuffer), size, "utf-8");
473 xmlSerializer.SetDeclaration();
474 ASSERT_STREQ(reinterpret_cast<char*>(pBuffer), "<?xml version=\"1.0\" encoding=\"utf-8\"?>");
475 }
476
477 /* @tc.name: SetDeclarationTest004
478 * @tc.desc: Test whether write xml declaration with encoding successfully.
479 * @tc.type: FUNC
480 */
481 HWTEST_F(NativeEngineTest, SetDeclarationTest004, testing::ext::TestSize.Level0)
482 {
483 napi_env env = (napi_env)engine_;
484 napi_value arrayBuffer = nullptr;
485 void* pBuffer = nullptr;
486 size_t size = 1024;
487 napi_create_arraybuffer(env, size, &pBuffer, &arrayBuffer);
488 OHOS::xml::XmlSerializer xmlSerializer(reinterpret_cast<char*>(pBuffer), size, "utf-8");
489 xmlSerializer.SetDeclaration();
490 ASSERT_STREQ(reinterpret_cast<char*>(pBuffer), "<?xml version=\"1.0\" encoding=\"utf-8\"?>");
491 }
492
493 /* @tc.name: SetDeclarationTest005
494 * @tc.desc: Test whether write xml declaration with encoding successfully.
495 * @tc.type: FUNC
496 */
497 HWTEST_F(NativeEngineTest, SetDeclarationTest005, testing::ext::TestSize.Level0)
498 {
499 napi_env env = (napi_env)engine_;
500 napi_value arrayBuffer = nullptr;
501 void* pBuffer = nullptr;
502 size_t size = 1024;
503 napi_create_arraybuffer(env, size, &pBuffer, &arrayBuffer);
504 OHOS::xml::XmlSerializer xmlSerializer(reinterpret_cast<char*>(pBuffer), size, "utf-8");
505 xmlSerializer.SetDeclaration();
506 ASSERT_STREQ(reinterpret_cast<char*>(pBuffer), "<?xml version=\"1.0\" encoding=\"utf-8\"?>");
507 }
508
509 /* @tc.name: EndElementTest001
510 * @tc.desc: Test whether write end tag of the element successfully.
511 * @tc.type: FUNC
512 */
513 HWTEST_F(NativeEngineTest, EndElementTest001, testing::ext::TestSize.Level0)
514 {
515 napi_env env = (napi_env)engine_;
516 napi_value arrayBuffer = nullptr;
517 void* pBuffer = nullptr;
518 size_t size = 1024;
519 napi_create_arraybuffer(env, size, &pBuffer, &arrayBuffer);
520 OHOS::xml::XmlSerializer xmlSerializer(reinterpret_cast<char*>(pBuffer), size, "utf-8");
521 xmlSerializer.StartElement("note");
522 xmlSerializer.EndElement();
523 ASSERT_STREQ(reinterpret_cast<char*>(pBuffer), "<note/>");
524 }
525
526 /* @tc.name: EndElementTest002
527 * @tc.desc: Test whether write end tag of the element successfully.
528 * @tc.type: FUNC
529 */
530 HWTEST_F(NativeEngineTest, EndElementTest002, testing::ext::TestSize.Level0)
531 {
532 napi_env env = (napi_env)engine_;
533 napi_value arrayBuffer = nullptr;
534 void* pBuffer = nullptr;
535 size_t size = 1024;
536 napi_create_arraybuffer(env, size, &pBuffer, &arrayBuffer);
537 OHOS::xml::XmlSerializer xmlSerializer(reinterpret_cast<char*>(pBuffer), size, "utf-8");
538 xmlSerializer.StartElement("note");
539 xmlSerializer.SetAttributes("importance", "high");
540 xmlSerializer.EndElement();
541 ASSERT_STREQ(reinterpret_cast<char*>(pBuffer), "<note importance=\"high\"/>");
542 }
543
544 /* @tc.name: EndElementTest003
545 * @tc.desc: Test whether write end tag of the element successfully.
546 * @tc.type: FUNC
547 */
548 HWTEST_F(NativeEngineTest, EndElementTest003, testing::ext::TestSize.Level0)
549 {
550 napi_env env = (napi_env)engine_;
551 napi_value arrayBuffer = nullptr;
552 void* pBuffer = nullptr;
553 size_t size = 1024;
554 napi_create_arraybuffer(env, size, &pBuffer, &arrayBuffer);
555 OHOS::xml::XmlSerializer xmlSerializer(reinterpret_cast<char*>(pBuffer), size, "utf-8");
556 xmlSerializer.StartElement("note");
557 xmlSerializer.SetAttributes("impo", "hi");
558 xmlSerializer.EndElement();
559 ASSERT_STREQ(reinterpret_cast<char*>(pBuffer), "<note impo=\"hi\"/>");
560 }
561
562 /* @tc.name: EndElementTest004
563 * @tc.desc: Test whether write end tag of the element successfully.
564 * @tc.type: FUNC
565 */
566 HWTEST_F(NativeEngineTest, EndElementTest004, testing::ext::TestSize.Level0)
567 {
568 napi_env env = (napi_env)engine_;
569 napi_value arrayBuffer = nullptr;
570 void* pBuffer = nullptr;
571 size_t size = 1024;
572 napi_create_arraybuffer(env, size, &pBuffer, &arrayBuffer);
573 OHOS::xml::XmlSerializer xmlSerializer(reinterpret_cast<char*>(pBuffer), size, "utf-8");
574 xmlSerializer.StartElement("note1");
575 xmlSerializer.StartElement("note2");
576 xmlSerializer.EndElement();
577 xmlSerializer.EndElement();
578 ASSERT_STREQ(reinterpret_cast<char*>(pBuffer), "<note1>\r\n <note2/>\r\n</note1>");
579 }
580
581 /* @tc.name: EndElementTest005
582 * @tc.desc: Test whether write end tag of the element successfully.
583 * @tc.type: FUNC
584 */
585 HWTEST_F(NativeEngineTest, EndElementTest005, testing::ext::TestSize.Level0)
586 {
587 napi_env env = (napi_env)engine_;
588 napi_value arrayBuffer = nullptr;
589 void* pBuffer = nullptr;
590 size_t size = 1024;
591 napi_create_arraybuffer(env, size, &pBuffer, &arrayBuffer);
592 OHOS::xml::XmlSerializer xmlSerializer(reinterpret_cast<char*>(pBuffer), size, "utf-8");
593 xmlSerializer.StartElement("note2");
594 xmlSerializer.SetAttributes("importance", "high");
595 xmlSerializer.EndElement();
596 ASSERT_STREQ(reinterpret_cast<char*>(pBuffer), "<note2 importance=\"high\"/>");
597 }
598
599 /* @tc.name: SetNamespaceTest001
600 * @tc.desc: Test whether write the namespace of the current element tag successfully.
601 * @tc.type: FUNC
602 */
603 HWTEST_F(NativeEngineTest, SetNamespaceTest001, testing::ext::TestSize.Level0)
604 {
605 napi_env env = (napi_env)engine_;
606 napi_value arrayBuffer = nullptr;
607 void* pBuffer = nullptr;
608 size_t size = 1024;
609 napi_create_arraybuffer(env, size, &pBuffer, &arrayBuffer);
610 OHOS::xml::XmlSerializer xmlSerializer(reinterpret_cast<char*>(pBuffer), size, "utf-8");
611 xmlSerializer.SetDeclaration();
612 xmlSerializer.SetNamespace("h", "http://www.w3.org/TR/html4/");
613 xmlSerializer.StartElement("note");
614 xmlSerializer.EndElement();
615 ASSERT_STREQ(reinterpret_cast<char*>(pBuffer),
616 "<?xml version=\"1.0\" encoding=\"utf-8\"?>\r\n<h:note xmlns:h=\"http://www.w3.org/TR/html4/\"/>");
617 }
618
619 /* @tc.name: SetNamespaceTest002
620 * @tc.desc: Test whether write the namespace of the current element tag successfully.
621 * @tc.type: FUNC
622 */
623 HWTEST_F(NativeEngineTest, SetNamespaceTest002, testing::ext::TestSize.Level0)
624 {
625 napi_env env = (napi_env)engine_;
626 napi_value arrayBuffer = nullptr;
627 void* pBuffer = nullptr;
628 size_t size = 1024;
629 napi_create_arraybuffer(env, size, &pBuffer, &arrayBuffer);
630 OHOS::xml::XmlSerializer xmlSerializer(reinterpret_cast<char*>(pBuffer), size, "utf-8");
631 xmlSerializer.SetDeclaration();
632 xmlSerializer.SetNamespace("b", "http://www.w3.org/TR/html4/");
633 xmlSerializer.StartElement("note");
634 xmlSerializer.EndElement();
635 ASSERT_STREQ(reinterpret_cast<char*>(pBuffer),
636 "<?xml version=\"1.0\" encoding=\"utf-8\"?>\r\n<b:note xmlns:b=\"http://www.w3.org/TR/html4/\"/>");
637 }
638
639 /* @tc.name: SetNamespaceTest003
640 * @tc.desc: Test whether write the namespace of the current element tag successfully.
641 * @tc.type: FUNC
642 */
643 HWTEST_F(NativeEngineTest, SetNamespaceTest003, testing::ext::TestSize.Level0)
644 {
645 napi_env env = (napi_env)engine_;
646 napi_value arrayBuffer = nullptr;
647 void* pBuffer = nullptr;
648 size_t size = 1024;
649 napi_create_arraybuffer(env, size, &pBuffer, &arrayBuffer);
650 OHOS::xml::XmlSerializer xmlSerializer(reinterpret_cast<char*>(pBuffer), size, "utf-8");
651 xmlSerializer.SetDeclaration();
652 xmlSerializer.SetNamespace("h", "http://www.111/");
653 xmlSerializer.StartElement("note");
654 xmlSerializer.EndElement();
655 ASSERT_STREQ(reinterpret_cast<char*>(pBuffer),
656 "<?xml version=\"1.0\" encoding=\"utf-8\"?>\r\n<h:note xmlns:h=\"http://www.111/\"/>");
657 }
658
659 /* @tc.name: SetNamespaceTest004
660 * @tc.desc: Test whether write the namespace of the current element tag successfully.
661 * @tc.type: FUNC
662 */
663 HWTEST_F(NativeEngineTest, SetNamespaceTest004, testing::ext::TestSize.Level0)
664 {
665 napi_env env = (napi_env)engine_;
666 napi_value arrayBuffer = nullptr;
667 void* pBuffer = nullptr;
668 size_t size = 1024;
669 napi_create_arraybuffer(env, size, &pBuffer, &arrayBuffer);
670 OHOS::xml::XmlSerializer xmlSerializer(reinterpret_cast<char*>(pBuffer), size, "utf-8");
671 xmlSerializer.SetDeclaration();
672 xmlSerializer.SetNamespace("h", "http://www.w3.org/TR/html4/");
673 xmlSerializer.StartElement("note1");
674 xmlSerializer.StartElement("note2");
675 xmlSerializer.EndElement();
676 xmlSerializer.EndElement();
677 std::string strPrior = "<?xml version=\"1.0\" encoding=\"utf-8\"?>\r\n";
678 std::string strBack = "<h:note1 xmlns:h=\"http://www.w3.org/TR/html4/\">\r\n <h:note2/>\r\n</h:note1>";
679 std::string strEnd = strPrior + strBack;
680 ASSERT_STREQ(reinterpret_cast<char*>(pBuffer), strEnd.c_str());
681 }
682
683 /* @tc.name: SetNamespaceTest005
684 * @tc.desc: Test whether write the namespace of the current element tag successfully.
685 * @tc.type: FUNC
686 */
687 HWTEST_F(NativeEngineTest, SetNamespaceTest005, testing::ext::TestSize.Level0)
688 {
689 napi_env env = (napi_env)engine_;
690 napi_value arrayBuffer = nullptr;
691 void* pBuffer = nullptr;
692 size_t size = 1024;
693 napi_create_arraybuffer(env, size, &pBuffer, &arrayBuffer);
694 OHOS::xml::XmlSerializer xmlSerializer(reinterpret_cast<char*>(pBuffer), size, "utf-8");
695 xmlSerializer.SetDeclaration();
696 xmlSerializer.SetNamespace("h", "http://www.w3.org/TR/html4/");
697 xmlSerializer.StartElement("note1");
698 xmlSerializer.StartElement("note2");
699 xmlSerializer.EndElement();
700 xmlSerializer.EndElement();
701 std::string strPrior = "<?xml version=\"1.0\" encoding=\"utf-8\"?>\r\n";
702 std::string strBack = "<h:note1 xmlns:h=\"http://www.w3.org/TR/html4/\">\r\n <h:note2/>\r\n</h:note1>";
703 std::string strEnd = strPrior + strBack;
704 ASSERT_STREQ(reinterpret_cast<char*>(pBuffer), strEnd.c_str());
705 }
706
707 /* @tc.name: SetCommentTest001
708 * @tc.desc: Test write the comment successfully.
709 * @tc.type: FUNC
710 */
711 HWTEST_F(NativeEngineTest, SetCommentTest001, testing::ext::TestSize.Level0)
712 {
713 napi_env env = (napi_env)engine_;
714 napi_value arrayBuffer = nullptr;
715 void* pBuffer = nullptr;
716 size_t size = 1024;
717 napi_create_arraybuffer(env, size, &pBuffer, &arrayBuffer);
718 OHOS::xml::XmlSerializer xmlSerializer(reinterpret_cast<char*>(pBuffer), size, "utf-8");
719 xmlSerializer.StartElement("note");
720 xmlSerializer.SetComment("Hi!");
721 xmlSerializer.EndElement();
722 ASSERT_STREQ(reinterpret_cast<char*>(pBuffer), "<note>\r\n <!--Hi!-->\r\n</note>");
723 }
724
725 /* @tc.name: SetCommentTest002
726 * @tc.desc: Test write the comment successfully.
727 * @tc.type: FUNC
728 */
729 HWTEST_F(NativeEngineTest, SetCommentTest002, testing::ext::TestSize.Level0)
730 {
731 napi_env env = (napi_env)engine_;
732 napi_value arrayBuffer = nullptr;
733 void* pBuffer = nullptr;
734 size_t size = 1024;
735 napi_create_arraybuffer(env, size, &pBuffer, &arrayBuffer);
736 OHOS::xml::XmlSerializer xmlSerializer(reinterpret_cast<char*>(pBuffer), size, "utf-8");
737 xmlSerializer.StartElement("note");
738 xmlSerializer.SetComment("Hello, World!");
739 xmlSerializer.EndElement();
740 ASSERT_STREQ(reinterpret_cast<char*>(pBuffer), "<note>\r\n <!--Hello, World!-->\r\n</note>");
741 }
742
743 /* @tc.name: SetCommentTest003
744 * @tc.desc: Test write the comment successfully.
745 * @tc.type: FUNC
746 */
747 HWTEST_F(NativeEngineTest, SetCommentTest003, testing::ext::TestSize.Level0)
748 {
749 napi_env env = (napi_env)engine_;
750 napi_value arrayBuffer = nullptr;
751 void* pBuffer = nullptr;
752 size_t size = 1024;
753 napi_create_arraybuffer(env, size, &pBuffer, &arrayBuffer);
754 OHOS::xml::XmlSerializer xmlSerializer(reinterpret_cast<char*>(pBuffer), size, "utf-8");
755 xmlSerializer.SetComment("Hello, World!");
756 ASSERT_STREQ(reinterpret_cast<char*>(pBuffer), "<!--Hello, World!-->");
757 }
758
759 /* @tc.name: SetCommentTest004
760 * @tc.desc: Test write the comment successfully.
761 * @tc.type: FUNC
762 */
763 HWTEST_F(NativeEngineTest, SetCommentTest004, testing::ext::TestSize.Level0)
764 {
765 napi_env env = (napi_env)engine_;
766 napi_value arrayBuffer = nullptr;
767 void* pBuffer = nullptr;
768 size_t size = 1024;
769 napi_create_arraybuffer(env, size, &pBuffer, &arrayBuffer);
770 OHOS::xml::XmlSerializer xmlSerializer(reinterpret_cast<char*>(pBuffer), size, "utf-8");
771 xmlSerializer.SetComment("Hello, World!");
772 ASSERT_STREQ(reinterpret_cast<char*>(pBuffer), "<!--Hello, World!-->");
773 }
774
775 /* @tc.name: SetCommentTest005
776 * @tc.desc: Test write the comment successfully.
777 * @tc.type: FUNC
778 */
779 HWTEST_F(NativeEngineTest, SetCommentTest005, testing::ext::TestSize.Level0)
780 {
781 napi_env env = (napi_env)engine_;
782 napi_value arrayBuffer = nullptr;
783 void* pBuffer = nullptr;
784 size_t size = 1024;
785 napi_create_arraybuffer(env, size, &pBuffer, &arrayBuffer);
786 OHOS::xml::XmlSerializer xmlSerializer(reinterpret_cast<char*>(pBuffer), size, "utf-8");
787 xmlSerializer.SetComment("Hello, World!");
788 xmlSerializer.StartElement("note");
789 xmlSerializer.EndElement();
790 ASSERT_STREQ(reinterpret_cast<char*>(pBuffer), "<!--Hello, World!-->\r\n<note/>");
791 }
792
793 /* @tc.name: Test001
794 * @tc.desc: Test .
795 * @tc.type: FUNC
796 */
797 HWTEST_F(NativeEngineTest, SetCDATATest001, testing::ext::TestSize.Level0)
798 {
799 napi_env env = (napi_env)engine_;
800 napi_value arrayBuffer = nullptr;
801 void* pBuffer = nullptr;
802 size_t size = 1024;
803 napi_create_arraybuffer(env, size, &pBuffer, &arrayBuffer);
804 OHOS::xml::XmlSerializer xmlSerializer(reinterpret_cast<char*>(pBuffer), size, "utf-8");
805 xmlSerializer.SetCData("root SYSTEM");
806 ASSERT_STREQ(reinterpret_cast<char*>(pBuffer), "<![CDATA[root SYSTEM]]>");
807 }
808
809 /* @tc.name: SetCDATATest002
810 * @tc.desc: Test whether Writes the CDATA successfully.
811 * @tc.type: FUNC
812 */
813 HWTEST_F(NativeEngineTest, SetCDATATest002, testing::ext::TestSize.Level0)
814 {
815 napi_env env = (napi_env)engine_;
816 napi_value arrayBuffer = nullptr;
817 void* pBuffer = nullptr;
818 size_t size = 1024;
819 napi_create_arraybuffer(env, size, &pBuffer, &arrayBuffer);
820 OHOS::xml::XmlSerializer xmlSerializer(reinterpret_cast<char*>(pBuffer), size, "utf-8");
821 xmlSerializer.SetCData("root SYSTEM \"http://www.test.org/test.dtd\"");
822 ASSERT_STREQ(reinterpret_cast<char*>(pBuffer), "<![CDATA[root SYSTEM \"http://www.test.org/test.dtd\"]]>");
823 }
824
825 /* @tc.name: SetCDATATest003
826 * @tc.desc: Test whether Writes the CDATA successfully.
827 * @tc.type: FUNC
828 */
829 HWTEST_F(NativeEngineTest, SetCDATATest003, testing::ext::TestSize.Level0)
830 {
831 napi_env env = (napi_env)engine_;
832 napi_value arrayBuffer = nullptr;
833 void* pBuffer = nullptr;
834 size_t size = 1024;
835 napi_create_arraybuffer(env, size, &pBuffer, &arrayBuffer);
836 OHOS::xml::XmlSerializer xmlSerializer(reinterpret_cast<char*>(pBuffer), size, "utf-8");
837 xmlSerializer.StartElement("note");
838 xmlSerializer.EndElement();
839 xmlSerializer.SetCData("root SYSTEM \"http://www.test.org/test.dtd\"");
840 ASSERT_STREQ(reinterpret_cast<char*>(pBuffer),
841 "<note/>\r\n<![CDATA[root SYSTEM \"http://www.test.org/test.dtd\"]]>");
842 }
843
844 /* @tc.name: SetCDATATest004
845 * @tc.desc: Test whether Writes the CDATA successfully.
846 * @tc.type: FUNC
847 */
848 HWTEST_F(NativeEngineTest, SetCDATATest004, testing::ext::TestSize.Level0)
849 {
850 napi_env env = (napi_env)engine_;
851 napi_value arrayBuffer = nullptr;
852 void* pBuffer = nullptr;
853 size_t size = 1024;
854 napi_create_arraybuffer(env, size, &pBuffer, &arrayBuffer);
855 OHOS::xml::XmlSerializer xmlSerializer(reinterpret_cast<char*>(pBuffer), size, "utf-8");
856 xmlSerializer.SetCData("root SYSTEM \"http://www.test.org/test.dtd\"");
857 xmlSerializer.StartElement("note");
858 xmlSerializer.EndElement();
859 ASSERT_STREQ(reinterpret_cast<char*>(pBuffer),
860 "<![CDATA[root SYSTEM \"http://www.test.org/test.dtd\"]]>\r\n<note/>");
861 }
862
863 /* @tc.name: SetCDATATest005
864 * @tc.desc: Test whether Writes the CDATA successfully.
865 * @tc.type: FUNC
866 */
867 HWTEST_F(NativeEngineTest, SetCDATATest005, testing::ext::TestSize.Level0)
868 {
869 napi_env env = (napi_env)engine_;
870 napi_value arrayBuffer = nullptr;
871 void* pBuffer = nullptr;
872 size_t size = 1024;
873 napi_create_arraybuffer(env, size, &pBuffer, &arrayBuffer);
874 OHOS::xml::XmlSerializer xmlSerializer(reinterpret_cast<char*>(pBuffer), size, "utf-8");
875 xmlSerializer.StartElement("note");
876 xmlSerializer.SetCData("root SYSTEM \"http://www.test.org/test.dtd\"");
877 xmlSerializer.EndElement();
878 ASSERT_STREQ(reinterpret_cast<char*>(pBuffer),
879 "<note>\r\n <![CDATA[root SYSTEM \"http://www.test.org/test.dtd\"]]>\r\n</note>");
880 }
881
882 /* @tc.name: SetTextTest001
883 * @tc.desc: Test whether Writes the text successfully.
884 * @tc.type: FUNC
885 */
886 HWTEST_F(NativeEngineTest, SetTextTest001, testing::ext::TestSize.Level0)
887 {
888 napi_env env = (napi_env)engine_;
889 napi_value arrayBuffer = nullptr;
890 void* pBuffer = nullptr;
891 size_t size = 1024;
892 napi_create_arraybuffer(env, size, &pBuffer, &arrayBuffer);
893 OHOS::xml::XmlSerializer xmlSerializer(reinterpret_cast<char*>(pBuffer), size, "utf-8");
894 xmlSerializer.StartElement("note");
895 xmlSerializer.SetAttributes("importance", "high");
896 xmlSerializer.SetText("Happy1");
897 xmlSerializer.EndElement();
898 ASSERT_STREQ(reinterpret_cast<char*>(pBuffer), "<note importance=\"high\">Happy1</note>");
899 }
900
901 /* @tc.name: SetTextTest002
902 * @tc.desc: Test whether Writes the text successfully.
903 * @tc.type: FUNC
904 */
905 HWTEST_F(NativeEngineTest, SetTextTest002, testing::ext::TestSize.Level0)
906 {
907 napi_env env = (napi_env)engine_;
908 napi_value arrayBuffer = nullptr;
909 void* pBuffer = nullptr;
910 size_t size = 1024;
911 napi_create_arraybuffer(env, size, &pBuffer, &arrayBuffer);
912 OHOS::xml::XmlSerializer xmlSerializer(reinterpret_cast<char*>(pBuffer), size, "utf-8");
913 xmlSerializer.StartElement("note");
914 xmlSerializer.SetAttributes("importance", "high");
915 xmlSerializer.SetText("Happy2");
916 xmlSerializer.EndElement();
917 ASSERT_STREQ(reinterpret_cast<char*>(pBuffer), "<note importance=\"high\">Happy2</note>");
918 }
919
920 /* @tc.name: SetTextTest003
921 * @tc.desc: Test whether Writes the text successfully.
922 * @tc.type: FUNC
923 */
924 HWTEST_F(NativeEngineTest, SetTextTest003, testing::ext::TestSize.Level0)
925 {
926 napi_env env = (napi_env)engine_;
927 napi_value arrayBuffer = nullptr;
928 void* pBuffer = nullptr;
929 size_t size = 1024;
930 napi_create_arraybuffer(env, size, &pBuffer, &arrayBuffer);
931 OHOS::xml::XmlSerializer xmlSerializer(reinterpret_cast<char*>(pBuffer), size, "utf-8");
932 xmlSerializer.StartElement("note");
933 xmlSerializer.SetAttributes("importance", "high");
934 xmlSerializer.SetText("Happy3");
935 xmlSerializer.EndElement();
936 ASSERT_STREQ(reinterpret_cast<char*>(pBuffer), "<note importance=\"high\">Happy3</note>");
937 }
938
939 /* @tc.name: SetTextTest004
940 * @tc.desc: Test whether Writes the text successfully.
941 * @tc.type: FUNC
942 */
943 HWTEST_F(NativeEngineTest, SetTextTest004, testing::ext::TestSize.Level0)
944 {
945 napi_env env = (napi_env)engine_;
946 napi_value arrayBuffer = nullptr;
947 void* pBuffer = nullptr;
948 size_t size = 1024;
949 napi_create_arraybuffer(env, size, &pBuffer, &arrayBuffer);
950 OHOS::xml::XmlSerializer xmlSerializer(reinterpret_cast<char*>(pBuffer), size, "utf-8");
951 xmlSerializer.StartElement("note");
952 xmlSerializer.SetAttributes("importance", "high");
953 xmlSerializer.SetText("Happy4");
954 xmlSerializer.EndElement();
955 ASSERT_STREQ(reinterpret_cast<char*>(pBuffer), "<note importance=\"high\">Happy4</note>");
956 }
957
958 /* @tc.name: SetTextTest005
959 * @tc.desc: Test whether Writes the text successfully.
960 * @tc.type: FUNC
961 */
962 HWTEST_F(NativeEngineTest, SetTextTest005, testing::ext::TestSize.Level0)
963 {
964 napi_env env = (napi_env)engine_;
965 napi_value arrayBuffer = nullptr;
966 void* pBuffer = nullptr;
967 size_t size = 1024;
968 napi_create_arraybuffer(env, size, &pBuffer, &arrayBuffer);
969 OHOS::xml::XmlSerializer xmlSerializer(reinterpret_cast<char*>(pBuffer), size, "utf-8");
970 xmlSerializer.StartElement("note");
971 xmlSerializer.SetAttributes("importance", "high");
972 xmlSerializer.SetText("Happy5");
973 xmlSerializer.EndElement();
974 ASSERT_STREQ(reinterpret_cast<char*>(pBuffer), "<note importance=\"high\">Happy5</note>");
975 }
976 /* @tc.name: SetDocTypeTest001
977 * @tc.desc: Test whether rites the DOCTYPE successfully.
978 * @tc.type: FUNC
979 */
980 HWTEST_F(NativeEngineTest, SetDocTypeTest001, testing::ext::TestSize.Level0)
981 {
982 napi_env env = (napi_env)engine_;
983 napi_value arrayBuffer = nullptr;
984 void* pBuffer = nullptr;
985 size_t size = 1024;
986 napi_create_arraybuffer(env, size, &pBuffer, &arrayBuffer);
987 OHOS::xml::XmlSerializer xmlSerializer(reinterpret_cast<char*>(pBuffer), size, "utf-8");
988 xmlSerializer.SetDocType("root SYSTEM");
989 ASSERT_STREQ(reinterpret_cast<char*>(pBuffer), "<!DOCTYPE root SYSTEM>");
990 }
991 /* @tc.name: SetDocTypeTest002
992 * @tc.desc: Test whether rites the DOCTYPE successfully.
993 * @tc.type: FUNC
994 */
995 HWTEST_F(NativeEngineTest, SetDocTypeTest002, testing::ext::TestSize.Level0)
996 {
997 napi_env env = (napi_env)engine_;
998 napi_value arrayBuffer = nullptr;
999 void* pBuffer = nullptr;
1000 size_t size = 1024;
1001 napi_create_arraybuffer(env, size, &pBuffer, &arrayBuffer);
1002 OHOS::xml::XmlSerializer xmlSerializer(reinterpret_cast<char*>(pBuffer), size, "utf-8");
1003 xmlSerializer.SetDocType("root SYSTEM \"http://www.test.org/test.dtd\"");
1004 ASSERT_STREQ(reinterpret_cast<char*>(pBuffer), "<!DOCTYPE root SYSTEM \"http://www.test.org/test.dtd\">");
1005 }
1006
1007 /* @tc.name: SetDocTypeTest003
1008 * @tc.desc: Test whether rites the DOCTYPE successfully.
1009 * @tc.type: FUNC
1010 */
1011 HWTEST_F(NativeEngineTest, SetDocTypeTest003, testing::ext::TestSize.Level0)
1012 {
1013 napi_env env = (napi_env)engine_;
1014 napi_value arrayBuffer = nullptr;
1015 void* pBuffer = nullptr;
1016 size_t size = 1024;
1017 napi_create_arraybuffer(env, size, &pBuffer, &arrayBuffer);
1018 OHOS::xml::XmlSerializer xmlSerializer(reinterpret_cast<char*>(pBuffer), size, "utf-8");
1019 xmlSerializer.StartElement("note");
1020 xmlSerializer.EndElement();
1021 xmlSerializer.SetDocType("root SYSTEM \"http://www.test.org/test.dtd\"");
1022 ASSERT_STREQ(reinterpret_cast<char*>(pBuffer),
1023 "<note/>\r\n<!DOCTYPE root SYSTEM \"http://www.test.org/test.dtd\">");
1024 }
1025
1026 /* @tc.name: SetDocTypeTest004
1027 * @tc.desc: Test whether rites the DOCTYPE successfully.
1028 * @tc.type: FUNC
1029 */
1030 HWTEST_F(NativeEngineTest, SetDocTypeTest004, 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 \"http://www.test.org/test.dtd\"");
1039 xmlSerializer.StartElement("note");
1040 xmlSerializer.EndElement();
1041 ASSERT_STREQ(reinterpret_cast<char*>(pBuffer),
1042 "<!DOCTYPE root SYSTEM \"http://www.test.org/test.dtd\">\r\n<note/>");
1043 }
1044
1045 /* @tc.name: SetDocTypeTest005
1046 * @tc.desc: Test whether rites the DOCTYPE successfully.
1047 * @tc.type: FUNC
1048 */
1049 HWTEST_F(NativeEngineTest, SetDocTypeTest005, testing::ext::TestSize.Level0)
1050 {
1051 napi_env env = (napi_env)engine_;
1052 napi_value arrayBuffer = nullptr;
1053 void* pBuffer = nullptr;
1054 size_t size = 1024;
1055 napi_create_arraybuffer(env, size, &pBuffer, &arrayBuffer);
1056 OHOS::xml::XmlSerializer xmlSerializer(reinterpret_cast<char*>(pBuffer), size, "utf-8");
1057 xmlSerializer.StartElement("note");
1058 xmlSerializer.SetDocType("root SYSTEM \"http://www.test.org/test.dtd\"");
1059 xmlSerializer.EndElement();
1060 ASSERT_STREQ(reinterpret_cast<char*>(pBuffer),
1061 "<note>\r\n <!DOCTYPE root SYSTEM \"http://www.test.org/test.dtd\">\r\n</note>");
1062 }
1063
1064 /* @tc.name: XmlParseTest001
1065 * @tc.desc: To XML text to JavaScript object.
1066 * @tc.type: FUNC
1067 */
1068 HWTEST_F(NativeEngineTest, XmlParseTest001, testing::ext::TestSize.Level0)
1069 {
1070 napi_env env = (napi_env)engine_;
1071 std::string str1 = "<?xml version=\"1.0\" encoding=\"utf-8\"?><!DOCTYPE note [\n<!ENTITY foo \"baa\">]>";
1072 std::string str2 = "<note importance=\"high\" logged=\"true\">";
1073 std::string str3 = "<![CDATA[\r\nfuncrion matchwo(a,6)\r\n{\r\nreturn 1;\r\n}\r\n]]>";
1074 std::string str4 = "<!--Hello, World!--> <company>John & Hans</company> <title>Happy</title>";
1075 std::string str5 = "<title>Happy</title> <todo>Work</todo> <todo>Play</todo> <?go there?>";
1076 std::string str6 = "<a><b/></a> <h:table xmlns:h=\"http://www.w3.org/TR/html4/\"> <h:tr>";
1077 std::string str7 = "<h:td>Apples</h:td> <h:td>Bananas</h:td> </h:tr>";
1078 std::string str8 = "</h:table></note>";
1079 std::string strXml = str1 + str2 + str3 + str4 + str5 + str6 + str7 + str8;
1080 g_testStr = "";
1081 OHOS::xml::XmlPullParser xmlPullParser(strXml, "utf-8");
1082 napi_value options = nullptr;
1083 napi_create_object(env, &options);
1084 const char* key1 = "supportDoctype";
1085 const char* key2 = "ignoreNameSpace";
1086 const char* key3 = "tagValueCallbackFunction";
1087 napi_value object = nullptr;
1088 napi_create_object(env, &object);
1089 napi_value value1 = nullptr;
1090 napi_value value2 = nullptr;
1091 napi_get_boolean(env, true, &value1);
1092 napi_get_boolean(env, false, &value2);
1093 napi_value value3 = nullptr;
1094 std::string cbName = "Method";
1095 napi_create_function(env, cbName.c_str(), cbName.size(), Method, nullptr, &value3);
1096 napi_set_named_property(env, object, key1, value1);
1097 napi_set_named_property(env, object, key2, value2);
1098 napi_set_named_property(env, object, key3, value3);
1099 xmlPullParser.DealOptionInfo(env, object);
1100 xmlPullParser.Parse(env, options);
1101 std::string res1 = " note [\n<!ENTITY foo \"baa\">]note\r\nfuncrion matchwo(a,6)\r\n{\r\nreturn 1;\r\n}\r\n";
1102 std::string res2 = "Hello, World! companyJohn & Hanscompany titleHappytitletitleHappytitle";
1103 std::string res3 = " todoWorktodo todoPlaytodo go thereabba table trtdApplestd tdBananastd trtablenote";
1104 std::string result = res1 + res2 + res3;
1105 ASSERT_STREQ(g_testStr.c_str(), result.c_str());
1106 }
1107
1108 /* @tc.name: XmlParseTest002
1109 * @tc.desc: To XML text to JavaScript object.
1110 * @tc.type: FUNC
1111 */
1112 HWTEST_F(NativeEngineTest, XmlParseTest002, testing::ext::TestSize.Level0)
1113 {
1114 napi_env env = (napi_env)engine_;
1115 std::string str1 = "<?xml version=\"1.0\" encoding=\"utf-8\"?><!DOCTYPE note [\n<!ENTITY foo \"baa\">]>";
1116 std::string str2 = "<note importance=\"high\" logged=\"true\">";
1117 std::string str3 = " <![CDATA[\r\nfuncrion matchwo(a,6)\r\n{\r\nreturn 1;\r\n}\r\n]]>";
1118 std::string str4 = " <!--Hello, World!--> <company>John & Hans</company> <title>Happy</title>";
1119 std::string str5 = " <title>Happy</title> <todo>Work</todo> <todo>Play</todo> <?go there?>";
1120 std::string str6 = " <a><b/></a> <h:table xmlns:h=\"http://www.w3.org/TR/html4/\"> <h:tr>";
1121 std::string str7 = " <h:td>Apples</h:td> <h:td>Bananas</h:td> </h:tr>";
1122 std::string str8 = " </h:table></note>";
1123 std::string strXml = str1 + str2 + str3 + str4 + str5 + str6 + str7 + str8;
1124 g_testStr = "";
1125 OHOS::xml::XmlPullParser xmlPullParser(strXml, "utf-8");
1126 napi_value options = nullptr;
1127 napi_create_object(env, &options);
1128 const char* key1 = "supportDoctype";
1129 const char* key2 = "ignoreNameSpace";
1130 const char* key3 = "attributeValueCallbackFunction";
1131 napi_value object = nullptr;
1132 napi_create_object(env, &object);
1133 napi_value value1 = nullptr;
1134 napi_value value2 = nullptr;
1135 napi_get_boolean(env, false, &value1);
1136 napi_get_boolean(env, true, &value2);
1137 napi_value value3 = nullptr;
1138 std::string cbName = "Method";
1139 napi_create_function(env, cbName.c_str(), cbName.size(), Method, nullptr, &value3);
1140 napi_set_named_property(env, object, key1, value1);
1141 napi_set_named_property(env, object, key2, value2);
1142 napi_set_named_property(env, object, key3, value3);
1143 xmlPullParser.DealOptionInfo(env, object);
1144 xmlPullParser.Parse(env, options);
1145 ASSERT_STREQ(g_testStr.c_str(), "importancehighloggedtruexmlns:hhttp://www.w3.org/TR/html4/");
1146 }
1147
1148 /* @tc.name: XmlParseTest003
1149 * @tc.desc: To XML text to JavaScript object.
1150 * @tc.type: FUNC
1151 */
1152 HWTEST_F(NativeEngineTest, XmlParseTest003, testing::ext::TestSize.Level0)
1153 {
1154 napi_env env = (napi_env)engine_;
1155 std::string str1 = "<?xml version=\"1.0\" encoding=\"utf-8\"?><!DOCTYPE note [\n<!ENTITY foo \"baa\">]>";
1156 std::string str2 = "<note importance=\"high\" logged=\"true\">";
1157 std::string str3 = "<![CDATA[\r\nfuncrion matchwo(a,6)\r\n{\r\nreturn 1;\r\n}\r\n]]>";
1158 std::string str4 = "<!--Hello, World!--> <company>John & Hans</company> <title>Happy</title>";
1159 std::string str5 = "<title>Happy</title> <todo>Work</todo> <todo>Play</todo> <?go there?>";
1160 std::string str6 = "<a><b/></a> <h:table xmlns:h=\"http://www.w3.org/TR/html4/\"> <h:tr>";
1161 std::string str7 = "<h:td>Apples</h:td> <h:td>Bananas</h:td> </h:tr>";
1162 std::string str8 = "</h:table></note>";
1163 std::string strXml = str1 + str2 + str3 + str4 + str5 + str6 + str7 + str8;
1164 g_testStr = "";
1165 OHOS::xml::XmlPullParser xmlPullParser(strXml, "utf-8");
1166 napi_value options = nullptr;
1167 napi_create_object(env, &options);
1168 const char* key1 = "supportDoctype";
1169 const char* key2 = "ignoreNameSpace";
1170 const char* key3 = "tagValueCallbackFunction";
1171 napi_value object = nullptr;
1172 napi_create_object(env, &object);
1173 napi_value value1 = nullptr;
1174 napi_value value2 = nullptr;
1175 napi_get_boolean(env, false, &value1);
1176 napi_get_boolean(env, true, &value2);
1177 napi_value value3 = nullptr;
1178 std::string cbName = "Method";
1179 napi_create_function(env, cbName.c_str(), cbName.size(), Method, nullptr, &value3);
1180 napi_set_named_property(env, object, key1, value1);
1181 napi_set_named_property(env, object, key2, value2);
1182 napi_set_named_property(env, object, key3, value3);
1183 xmlPullParser.DealOptionInfo(env, object);
1184 xmlPullParser.Parse(env, options);
1185 std::string res1 = "note\r\nfuncrion matchwo(a,6)\r\n{\r\nreturn 1;\r\n}\r\nHello, World! companyJohn &";
1186 std::string res2 = " Hanscompany titleHappytitletitleHappytitle todoWorktodo todoPlaytodo go thereabba h:table";
1187 std::string res3 = " h:trh:tdApplesh:td h:tdBananash:td h:trh:tablenote";
1188 std::string result = res1 + res2 + res3;
1189 ASSERT_STREQ(g_testStr.c_str(), result.c_str());
1190 }
1191
1192 /* @tc.name: XmlParseTest004
1193 * @tc.desc: To XML text to JavaScript object.
1194 * @tc.type: FUNC
1195 */
1196 HWTEST_F(NativeEngineTest, XmlParseTest004, testing::ext::TestSize.Level0)
1197 {
1198 napi_env env = (napi_env)engine_;
1199 std::string str1 = "<?xml version=\"1.0\" encoding=\"utf-8\"?><!DOCTYPE note [\n<!ENTITY foo \"baa\">]>";
1200 std::string str2 = "<note importance=\"high\" logged=\"true\">";
1201 std::string str3 = " <![CDATA[\r\nfuncrion matchwo(a,6)\r\n{\r\nreturn 1;\r\n}\r\n]]>";
1202 std::string str4 = " <!--Hello, World!--> <company>John & Hans</company> <title>Happy</title>";
1203 std::string str5 = " <title>Happy</title> <todo>Work</todo> <todo>Play</todo> <?go there?>";
1204 std::string str6 = " <a><b/></a> <h:table xmlns:h=\"http://www.w3.org/TR/html4/\"> <h:tr>";
1205 std::string str7 = " <h:td>Apples</h:td> <h:td>Bananas</h:td> </h:tr>";
1206 std::string str8 = " </h:table></note>";
1207 std::string strXml = str1 + str2 + str3 + str4 + str5 + str6 + str7 + str8;
1208 g_testStr = "";
1209 OHOS::xml::XmlPullParser xmlPullParser(strXml, "utf-8");
1210 napi_value options = nullptr;
1211 napi_create_object(env, &options);
1212 const char* key1 = "supportDoctype";
1213 const char* key2 = "ignoreNameSpace";
1214 const char* key3 = "attributeValueCallbackFunction";
1215 napi_value object = nullptr;
1216 napi_create_object(env, &object);
1217 napi_value value1 = nullptr;
1218 napi_value value2 = nullptr;
1219 napi_get_boolean(env, true, &value1);
1220 napi_get_boolean(env, true, &value2);
1221 napi_value value3 = nullptr;
1222 std::string cbName = "Method";
1223 napi_create_function(env, cbName.c_str(), cbName.size(), Method, nullptr, &value3);
1224 napi_set_named_property(env, object, key1, value1);
1225 napi_set_named_property(env, object, key2, value2);
1226 napi_set_named_property(env, object, key3, value3);
1227 xmlPullParser.DealOptionInfo(env, object);
1228 xmlPullParser.Parse(env, options);
1229 ASSERT_STREQ(g_testStr.c_str(), "importancehighloggedtruexmlns:hhttp://www.w3.org/TR/html4/");
1230 }
1231
1232 /* @tc.name: XmlParseTest005
1233 * @tc.desc: To XML text to JavaScript object.
1234 * @tc.type: FUNC
1235 */
1236 HWTEST_F(NativeEngineTest, XmlParseTest005, testing::ext::TestSize.Level0)
1237 {
1238 napi_env env = (napi_env)engine_;
1239 std::string str1 = "<?xml version=\"1.0\" encoding=\"utf-8\"?><!DOCTYPE note [\n<!ENTITY foo \"baa\">]>";
1240 std::string str2 = "<note importance=\"high\" logged=\"true\">";
1241 std::string str3 = "<![CDATA[\r\nfuncrion matchwo(a,6)\r\n{\r\nreturn 1;\r\n}\r\n]]>";
1242 std::string str4 = "<!--Hello, World!--> <company>John & Hans</company> <title>Happy</title>";
1243 std::string str5 = "<title>Happy</title> <todo>Work</todo> <todo>Play</todo> <?go there?>";
1244 std::string str6 = "<a><b/></a> <h:table xmlns:h=\"http://www.w3.org/TR/html4/\"> <h:tr>";
1245 std::string str7 = "<h:td>Apples</h:td> <h:td>Bananas</h:td> </h:tr>";
1246 std::string str8 = "</h:table></note>";
1247 std::string strXml = str1 + str2 + str3 + str4 + str5 + str6 + str7 + str8;
1248 g_testStr = "";
1249 OHOS::xml::XmlPullParser xmlPullParser(strXml, "utf-8");
1250 napi_value options = nullptr;
1251 napi_create_object(env, &options);
1252 const char* key1 = "supportDoctype";
1253 const char* key2 = "ignoreNameSpace";
1254 const char* key3 = "tagValueCallbackFunction";
1255 napi_value object = nullptr;
1256 napi_create_object(env, &object);
1257 napi_value value1 = nullptr;
1258 napi_value value2 = nullptr;
1259 napi_get_boolean(env, true, &value1);
1260 napi_get_boolean(env, true, &value2);
1261 napi_value value3 = nullptr;
1262 std::string cbName = "Method";
1263 napi_create_function(env, cbName.c_str(), cbName.size(), Method, nullptr, &value3);
1264 napi_set_named_property(env, object, key1, value1);
1265 napi_set_named_property(env, object, key2, value2);
1266 napi_set_named_property(env, object, key3, value3);
1267 xmlPullParser.DealOptionInfo(env, object);
1268 xmlPullParser.Parse(env, options);
1269 std::string res1 = " note [\n<!ENTITY foo \"baa\">]note\r\nfuncrion matchwo(a,6)\r\n{\r\nreturn 1;\r\n}\r\n";
1270 std::string res2 = "Hello, World! companyJohn & Hanscompany titleHappytitletitleHappytitle todoWorktodo";
1271 std::string res3 = " todoPlaytodo go thereabba h:table h:trh:tdApplesh:td h:tdBananash:td h:trh:tablenote";
1272 std::string result = res1 + res2 + res3;
1273 ASSERT_STREQ(g_testStr.c_str(), result.c_str());
1274 }
1275
1276 /* @tc.name: XmlParseTest006
1277 * @tc.desc: To XML text to JavaScript object.
1278 * @tc.type: FUNC
1279 */
1280 HWTEST_F(NativeEngineTest, XmlParseTest006, testing::ext::TestSize.Level0)
1281 {
1282 napi_env env = (napi_env)engine_;
1283 std::string str1 = "<?xml version=\"1.0\" encoding=\"utf-8\"?><!DOCTYPE note [\n<!ENTITY foo \"baa\">]>";
1284 std::string str2 = "<note importance=\"high\" logged=\"true\">";
1285 std::string str3 = "<![CDATA[\r\nfuncrion matchwo(a,6)\r\n{\r\nreturn 1;\r\n}\r\n]]>";
1286 std::string str4 = "<!--Hello, World!--> <company>John & Hans</company> <title>Happy</title>";
1287 std::string str5 = "<title>Happy</title> <todo>Work</todo> <todo>Play</todo> <?go there?>";
1288 std::string str6 = "<a><b/></a> <h:table xmlns:h=\"http://www.w3.org/TR/html4/\"> <h:tr>";
1289 std::string str7 = "<h:td>Apples</h:td> <h:td>Bananas</h:td> </h:tr>";
1290 std::string str8 = "</h:table></note>";
1291 std::string strXml = str1 + str2 + str3 + str4 + str5 + str6 + str7 + str8;
1292 OHOS::xml::XmlPullParser xmlPullParser(strXml, "utf-8");
1293 napi_value options = nullptr;
1294 napi_create_object(env, &options);
1295 const char* key1 = "supportDoctype";
1296 const char* key2 = "ignoreNameSpace";
1297 const char* key3 = "tokenValueCallbackFunction";
1298 napi_value object = nullptr;
1299 napi_create_object(env, &object);
1300 napi_value value1 = nullptr;
1301 napi_value value2 = nullptr;
1302 napi_get_boolean(env, true, &value1);
1303 napi_get_boolean(env, true, &value2);
1304 napi_value value3 = nullptr;
1305 std::string cbName = "TokenValueCallbackFunction";
1306 napi_create_function(env, cbName.c_str(), cbName.size(), TokenValueCallbackFunction, nullptr, &value3);
1307 napi_set_named_property(env, object, key1, value1);
1308 napi_set_named_property(env, object, key2, value2);
1309 napi_set_named_property(env, object, key3, value3);
1310 xmlPullParser.DealOptionInfo(env, object);
1311 xmlPullParser.Parse(env, options);
1312 std::string res1 = " note [\n<!ENTITY foo \"baa\">]note\r\nfuncrion matchwo(a,6)\r\n{\r\nreturn 1;\r\n}\r\n";
1313 std::string res2 = "Hello, World! companyJohn & Hanscompany titleHappytitletitleHappytitle todoWorktodo";
1314 std::string res3 = " todoPlaytodo go thereabba h:table h:trh:tdApplesh:td h:tdBananash:td h:trh:tablenote";
1315 std::string result = res1 + res2 + res3;
1316 ASSERT_STREQ(g_testStr.c_str(), result.c_str());
1317 }
1318
1319 /* @tc.name: XmlParseTest007
1320 * @tc.desc: To XML text to JavaScript object.
1321 * @tc.type: FUNC
1322 */
1323 HWTEST_F(NativeEngineTest, XmlParseTest007, testing::ext::TestSize.Level0)
1324 {
1325 napi_env env = (napi_env)engine_;
1326 std::string str1 = "<?xml version=\"1.0\" encoding=\"utf-8\"?>";
1327 std::string str2 = "<note importance=\"high\" logged=\"true\">";
1328 std::string str3 = " <![CDATA[\r\nfuncrion matchwo(a,6)\r\n{\r\nreturn 1;\r\n}\r\n]]>";
1329 std::string str4 = " <!--Hello, World!--> <company>John & Hans</company> <title>Happy</title>";
1330 std::string str5 = " <title>Happy</title> <todo>Work</todo> <todo>Play</todo> <?go there?>";
1331 std::string str6 = " <a><b/></a> <h:table xmlns:h=\"http://www.w3.org/TR/html4/\"> <h:tr>";
1332 std::string str7 = " <h:td>Apples</h:td> <h:td>Bananas</h:td> </h:tr>";
1333 std::string str8 = " </h:table></note>";
1334 std::string strXml = str1 + str2 + str3 + str4 + str5 + str6 + str7 + str8;
1335 g_testStr = "";
1336 OHOS::xml::XmlPullParser xmlPullParser(strXml, "utf-8");
1337 napi_value options = nullptr;
1338 napi_create_object(env, &options);
1339 const char* key1 = "supportDoctype";
1340 const char* key2 = "ignoreNameSpace";
1341 const char* key3 = "attributeValueCallbackFunction";
1342 napi_value object = nullptr;
1343 napi_create_object(env, &object);
1344 napi_value value1 = nullptr;
1345 napi_value value2 = nullptr;
1346 napi_get_boolean(env, true, &value1);
1347 napi_get_boolean(env, true, &value2);
1348 napi_value value3 = nullptr;
1349 std::string cbName = "Method";
1350 napi_create_function(env, cbName.c_str(), cbName.size(), Method, nullptr, &value3);
1351 napi_set_named_property(env, object, key1, value1);
1352 napi_set_named_property(env, object, key2, value2);
1353 napi_set_named_property(env, object, key3, value3);
1354 xmlPullParser.DealOptionInfo(env, object);
1355 xmlPullParser.Parse(env, options);
1356 ASSERT_STREQ(g_testStr.c_str(), "importancehighloggedtruexmlns:hhttp://www.w3.org/TR/html4/");
1357 }
1358
1359 /* @tc.name: XmlParseTest008
1360 * @tc.desc: To XML text to JavaScript object.
1361 * @tc.type: FUNC
1362 */
1363 HWTEST_F(NativeEngineTest, XmlParseTest008, testing::ext::TestSize.Level0)
1364 {
1365 napi_env env = (napi_env)engine_;
1366 std::string str1 = "<?xml version=\"1.0\" encoding=\"utf-8\"?>";
1367 std::string str2 = "<note importance=\"high\" logged=\"true\">";
1368 std::string str3 = "<![CDATA[\r\nfuncrion matchwo(a,6)\r\n{\r\nreturn 1;\r\n}\r\n]]>";
1369 std::string str4 = "<!--Hello, World!--> <company>John & Hans</company> <title>Happy</title>";
1370 std::string str5 = "<title>Happy</title> <todo>Work</todo> <todo>Play</todo> <?go there?>";
1371 std::string str6 = "<a><b/></a> <h:table xmlns:h=\"http://www.w3.org/TR/html4/\"> <h:tr>";
1372 std::string str7 = "<h:td>Apples</h:td> <h:td>Bananas</h:td> </h:tr>";
1373 std::string str8 = "</h:table></note>";
1374 std::string strXml = str1 + str2 + str3 + str4 + str5 + str6 + str7 + str8;
1375 g_testStr = "";
1376 OHOS::xml::XmlPullParser xmlPullParser(strXml, "utf-8");
1377 napi_value options = nullptr;
1378 napi_create_object(env, &options);
1379 const char* key1 = "supportDoctype";
1380 const char* key2 = "ignoreNameSpace";
1381 const char* key3 = "tagValueCallbackFunction";
1382 napi_value object = nullptr;
1383 napi_create_object(env, &object);
1384 napi_value value1 = nullptr;
1385 napi_value value2 = nullptr;
1386 napi_get_boolean(env, true, &value1);
1387 napi_get_boolean(env, true, &value2);
1388 napi_value value3 = nullptr;
1389 std::string cbName = "Method";
1390 napi_create_function(env, cbName.c_str(), cbName.size(), Method, nullptr, &value3);
1391 napi_set_named_property(env, object, key1, value1);
1392 napi_set_named_property(env, object, key2, value2);
1393 napi_set_named_property(env, object, key3, value3);
1394 xmlPullParser.DealOptionInfo(env, object);
1395 xmlPullParser.Parse(env, options);
1396 std::string res1 = "note\r\nfuncrion matchwo(a,6)\r\n{\r\nreturn 1;\r\n}\r\nHello, World! companyJohn &";
1397 std::string res2 = " Hanscompany titleHappytitletitleHappytitle todoWorktodo todoPlaytodo go thereabba h:table ";
1398 std::string res3 = "h:trh:tdApplesh:td h:tdBananash:td h:trh:tablenote";
1399 std::string result = res1 + res2 + res3;
1400 ASSERT_STREQ(g_testStr.c_str(), result.c_str());
1401 }
1402
1403 /* @tc.name: XmlParseTest009
1404 * @tc.desc: To XML text to JavaScript object.
1405 * @tc.type: FUNC
1406 */
1407 HWTEST_F(NativeEngineTest, XmlParseTest009, testing::ext::TestSize.Level0)
1408 {
1409 napi_env env = (napi_env)engine_;
1410 std::string str1 = "<?xml version=\"1.0\" encoding=\"utf-8\"?>";
1411 std::string str2 = "<note importance=\"high\" logged=\"true\">";
1412 std::string str3 = "<![CDATA[\r\nfuncrion matchwo(a,6)\r\n{\r\nreturn 1;\r\n}\r\n]]>";
1413 std::string str4 = "<!--Hello, World!--> <company>John & Hans</company> <title>Happy</title>";
1414 std::string str5 = "<title>Happy</title> <todo>Work</todo> <todo>Play</todo> <?go there?>";
1415 std::string str6 = "<a><b/></a> <h:table xmlns:h=\"http://www.w3.org/TR/html4/\"> <h:tr>";
1416 std::string str7 = "<h:td>Apples</h:td> <h:td>Bananas</h:td> </h:tr>";
1417 std::string str8 = "</h:table></note>";
1418 std::string strXml = str1 + str2 + str3 + str4 + str5 + str6 + str7 + str8;
1419 OHOS::xml::XmlPullParser xmlPullParser(strXml, "utf-8");
1420 napi_value options = nullptr;
1421 napi_create_object(env, &options);
1422 const char* key1 = "supportDoctype";
1423 const char* key2 = "ignoreNameSpace";
1424 const char* key3 = "tokenValueCallbackFunction";
1425 napi_value object = nullptr;
1426 napi_create_object(env, &object);
1427 napi_value value1 = nullptr;
1428 napi_value value2 = nullptr;
1429 napi_get_boolean(env, true, &value1);
1430 napi_get_boolean(env, true, &value2);
1431 napi_value value3 = nullptr;
1432 std::string cbName = "TokenValueCallbackFunc";
1433 napi_create_function(env, cbName.c_str(), cbName.size(), TokenValueCallbackFunc, nullptr, &value3);
1434 napi_set_named_property(env, object, key1, value1);
1435 napi_set_named_property(env, object, key2, value2);
1436 napi_set_named_property(env, object, key3, value3);
1437 xmlPullParser.DealOptionInfo(env, object);
1438 xmlPullParser.Parse(env, options);
1439 std::string res1 = "note\r\nfuncrion matchwo(a,6)\r\n{\r\nreturn 1;\r\n}\r\nHello, World! companyJohn &";
1440 std::string res2 = " Hanscompany titleHappytitletitleHappytitle todoWorktodo todoPlaytodo go thereabba h:table";
1441 std::string res3 = " h:trh:tdApplesh:td h:tdBananash:td h:trh:tablenote";
1442 std::string result = res1 + res2 + res3;
1443 ASSERT_STREQ(g_testStr.c_str(), result.c_str());
1444 }
1445
1446 /* @tc.name: XmlParseTest0010
1447 * @tc.desc: To XML text to JavaScript object.
1448 * @tc.type: FUNC
1449 */
1450 HWTEST_F(NativeEngineTest, XmlParseTest0010, testing::ext::TestSize.Level0)
1451 {
1452 napi_env env = (napi_env)engine_;
1453 std::string str1 = "<?xml version=\"1.0\" encoding=\"utf-8\"?><!DOCTYPE note [\n<!ENTITY foo \"baa\">]>";
1454 std::string str2 = "<note importance=\"high\" logged=\"true\">";
1455 std::string str3 = "<![CDATA[\r\nfuncrion matchwo(a,6)\r\n{\r\nreturn 1;\r\n}\r\n]]>";
1456 std::string str4 = "<!--Hello, World!--> <company>John & Hans</company> <title>Happy</title>";
1457 std::string str5 = "<title>Happy</title> <todo>Work</todo> <todo>Play</todo> <?go there?>";
1458 std::string str6 = "<a><b/></a> <h:table xml:h=\"http://www.w3.org/TR/html4/\"> <h:tr>";
1459 std::string str7 = "<h:td>Apples</h:td> <h:td>Bananas</h:td> </h:tr>";
1460 std::string str8 = "</h:table></note>";
1461 std::string strXml = str1 + str2 + str3 + str4 + str5 + str6 + str7 + str8;
1462 g_testStr = "";
1463 OHOS::xml::XmlPullParser xmlPullParser(strXml, "utf-8");
1464 napi_value options = nullptr;
1465 napi_create_object(env, &options);
1466 const char* key1 = "supportDoctype";
1467 const char* key2 = "ignoreNameSpace";
1468 const char* key3 = "tagValueCallbackFunction";
1469 napi_value object = nullptr;
1470 napi_create_object(env, &object);
1471 napi_value value1 = nullptr;
1472 napi_value value2 = nullptr;
1473 napi_get_boolean(env, true, &value1);
1474 napi_get_boolean(env, false, &value2);
1475 napi_value value3 = nullptr;
1476 std::string cbName = "Method";
1477 napi_create_function(env, cbName.c_str(), cbName.size(), Method, nullptr, &value3);
1478 napi_set_named_property(env, object, key1, value1);
1479 napi_set_named_property(env, object, key2, value2);
1480 napi_set_named_property(env, object, key3, value3);
1481 xmlPullParser.DealOptionInfo(env, object);
1482 xmlPullParser.Parse(env, options);
1483 std::string res1 = " note [\n<!ENTITY foo \"baa\">]note\r\nfuncrion matchwo(a,6)\r\n{\r\nreturn 1;\r\n}\r\n";
1484 std::string res2 = "Hello, World! companyJohn & Hanscompany titleHappytitletitleHappytitle todoWorktodo";
1485 std::string res3 = " todoPlaytodo go thereabba table trtdApplestd tdBananastd trtablenote";
1486 std::string result = res1 + res2 + res3;
1487 ASSERT_STREQ(g_testStr.c_str(), result.c_str());
1488 }
1489
1490 /* @tc.name: XmlParseTest0011
1491 * @tc.desc: To XML text to JavaScript object.
1492 * @tc.type: FUNC
1493 */
1494 HWTEST_F(NativeEngineTest, XmlParseTest0011, testing::ext::TestSize.Level0)
1495 {
1496 napi_env env = (napi_env)engine_;
1497 std::string str1 = "<?xml version=\"1.0\" encoding=\"utf-8\"?><!DOCTYPE note";
1498 std::string str2 = " [\n<!ATTLIST operand type src \"dest\">]><note importance=\"high\" logged=\"true\">";
1499 std::string str3 = " <![CDATA[\r\nfuncrion matchwo(a,6)\r\n{\r\nreturn 1;\r\n}\r\n]]>";
1500 std::string str4 = " <!--Hello, World!--> <company>John & Hans</company> <title>Happy</title>";
1501 std::string str5 = " <title>Happy</title> <todo>Work</todo> <todo>Play</todo> <?go there?>";
1502 std::string str6 = " <a><b/></a> <h:table xmlns:h=\"http://www.w3.org/TR/html4/\"> <h:tr>";
1503 std::string str7 = " <h:td>Apples</h:td> <h:td>Bananas</h:td> </h:tr>";
1504 std::string str8 = " </h:table></note>";
1505 std::string strXml = str1 + str2 + str3 + str4 + str5 + str6 + str7 + str8;
1506 g_testStr = "";
1507 OHOS::xml::XmlPullParser xmlPullParser(strXml, "utf-8");
1508 napi_value options = nullptr;
1509 napi_create_object(env, &options);
1510 const char* key1 = "supportDoctype";
1511 const char* key2 = "ignoreNameSpace";
1512 const char* key3 = "tokenValueCallbackFunction";
1513 napi_value object = nullptr;
1514 napi_create_object(env, &object);
1515 napi_value value1 = nullptr;
1516 napi_value value2 = nullptr;
1517 napi_get_boolean(env, true, &value1);
1518 napi_get_boolean(env, true, &value2);
1519 napi_value value3 = nullptr;
1520 std::string cbName = "TokenValueCallbackFunction";
1521 napi_create_function(env, cbName.c_str(), cbName.size(), TokenValueCallbackFunction, nullptr, &value3);
1522 napi_set_named_property(env, object, key1, value1);
1523 napi_set_named_property(env, object, key2, value2);
1524 napi_set_named_property(env, object, key3, value3);
1525 xmlPullParser.DealOptionInfo(env, object);
1526 xmlPullParser.Parse(env, options);
1527 ASSERT_STREQ(g_testStr.c_str(), "");
1528 }
1529
1530 /* @tc.name: XmlParseTest0012
1531 * @tc.desc: To XML text to JavaScript object.
1532 * @tc.type: FUNC
1533 */
1534 HWTEST_F(NativeEngineTest, XmlParseTest0012, testing::ext::TestSize.Level0)
1535 {
1536 napi_env env = (napi_env)engine_;
1537 std::string str1 = "<?xml version=\"1.0\" encoding=\"utf-8\"?><!DOCTYPE note [\n<!ELEMENT>]>";
1538 std::string str2 = "<note importance=\"high\" logged=\"true\">";
1539 std::string str3 = " <![CDATA[\r\nfuncrion matchwo(a,6)\r\n{\r\nreturn 1;\r\n}\r\n]]>";
1540 std::string str4 = " <!--Hello, World!--> <company>John & Hans</company> <title>Happy</title>";
1541 std::string str5 = " <title>Happy</title> <todo>Work</todo> <todo>Play</todo> <?go there?>";
1542 std::string str6 = " <a><b/></a> <h:table xmlns:h=\"http://www.w3.org/TR/html4/\"> <h:tr>";
1543 std::string str7 = " <h:td>Apples</h:td> <h:td>Bananas</h:td> </h:tr>";
1544 std::string str8 = " </h:table></note>";
1545 std::string strXml = str1 + str2 + str3 + str4 + str5 + str6 + str7 + str8;
1546 OHOS::xml::XmlPullParser xmlPullParser(strXml, "utf-8");
1547 napi_value options = nullptr;
1548 napi_create_object(env, &options);
1549 const char* key1 = "supportDoctype";
1550 const char* key2 = "ignoreNameSpace";
1551 const char* key3 = "tokenValueCallbackFunction";
1552 napi_value object = nullptr;
1553 napi_create_object(env, &object);
1554 napi_value value1 = nullptr;
1555 napi_value value2 = nullptr;
1556 napi_get_boolean(env, true, &value1);
1557 napi_get_boolean(env, true, &value2);
1558 napi_value value3 = nullptr;
1559 std::string cbName = "TokenValueCallbackFunction";
1560 napi_create_function(env, cbName.c_str(), cbName.size(), TokenValueCallbackFunction, nullptr, &value3);
1561 napi_set_named_property(env, object, key1, value1);
1562 napi_set_named_property(env, object, key2, value2);
1563 napi_set_named_property(env, object, key3, value3);
1564 xmlPullParser.DealOptionInfo(env, object);
1565 xmlPullParser.Parse(env, options);
1566 ASSERT_STREQ(g_testStr.c_str(), "");
1567 }
1568
1569 /* @tc.name: Xmlfunctest001
1570 * @tc.desc: To XML text to JavaScript object.
1571 * @tc.type: FUNC
1572 */
1573 HWTEST_F(NativeEngineTest, Xmlfunctest001, testing::ext::TestSize.Level0)
1574 {
1575 std::string strXml = "<?xml version=\"1.0\" encoding=\"utf-8\"?> <title>Happy</title> <todo>Work</todo>";
1576 OHOS::xml::XmlPullParser xmlPullParser(strXml, "utf-8");
1577 ASSERT_EQ(xmlPullParser.GetColumnNumber(), 1);
1578 ASSERT_EQ(xmlPullParser.GetDepth(), 0);
1579 ASSERT_EQ(xmlPullParser.GetLineNumber(), 1);
1580 ASSERT_STREQ(xmlPullParser.GetName().c_str(), "");
1581 ASSERT_STREQ(xmlPullParser.GetPrefix().c_str(), "");
1582 ASSERT_STREQ(xmlPullParser.GetText().c_str(), "");
1583 ASSERT_FALSE(xmlPullParser.IsEmptyElementTag());
1584 ASSERT_EQ(xmlPullParser.GetAttributeCount(), 0);
1585 ASSERT_FALSE(xmlPullParser.IsWhitespace());
1586 ASSERT_STREQ(xmlPullParser.GetNamespace().c_str(), "");
1587 }
1588
1589 /* @tc.name: XmlSerializertest001
1590 * @tc.desc: To XML text to JavaScript object.
1591 * @tc.type: FUNC
1592 */
1593 HWTEST_F(NativeEngineTest, XmlSerializertest001, testing::ext::TestSize.Level0)
1594 {
1595 napi_env env = (napi_env)engine_;
1596 napi_value exports = nullptr;
1597 napi_create_object(env, &exports);
1598 OHOS::xml::XmlSerializerInit(env, exports);
1599 napi_value xmlSerializerClass = nullptr;
1600 napi_get_named_property(env, exports, "XmlSerializer", &xmlSerializerClass);
1601
1602 napi_value args[2]; // 2: number of arguments
1603 size_t length = 2048; // allocate an ArrayBuffer with a size of 2048 bytes
1604 void* pBuffer = nullptr;
1605 napi_create_arraybuffer(env, length, &pBuffer, &args[0]);
1606 std::string encoding = "utf-8";
1607 napi_create_string_utf8(env, encoding.c_str(), encoding.size(), &args[1]);
1608 napi_value instance = nullptr;
1609 napi_new_instance(env, xmlSerializerClass, 2, args, &instance); // 2: number of arguments
1610
1611 std::string name = "importance";
1612 napi_create_string_utf8(env, name.c_str(), name.size(), &args[0]);
1613 std::string value = "high";
1614 napi_create_string_utf8(env, value.c_str(), value.size(), &args[1]);
1615 napi_value testFunc = nullptr;
1616 napi_get_named_property(env, instance, "setAttributes", &testFunc);
1617 napi_value funcResultValue = nullptr;
1618 napi_call_function(env, instance, testFunc, 2, args, &funcResultValue); // 2: number of arguments
1619 ASSERT_NE(funcResultValue, nullptr);
1620
1621 napi_get_named_property(env, instance, "setDeclaration", &testFunc);
1622 napi_call_function(env, instance, testFunc, 0, nullptr, &funcResultValue);
1623 ASSERT_NE(funcResultValue, nullptr);
1624
1625 name = "note";
1626 napi_value val = nullptr;
1627 napi_create_string_utf8(env, name.c_str(), name.size(), &val);
1628 napi_get_named_property(env, instance, "startElement", &testFunc);
1629 napi_call_function(env, instance, testFunc, 1, &val, &funcResultValue);
1630 ASSERT_NE(funcResultValue, nullptr);
1631
1632 napi_get_named_property(env, instance, "endElement", &testFunc);
1633 napi_call_function(env, instance, testFunc, 0, nullptr, &funcResultValue);
1634 ASSERT_NE(funcResultValue, nullptr);
1635
1636 name = "h";
1637 napi_create_string_utf8(env, name.c_str(), name.size(), &args[0]);
1638 value = "http://www.w3.org/TR/html4/";
1639 napi_create_string_utf8(env, value.c_str(), value.size(), &args[1]);
1640 napi_get_named_property(env, instance, "setNamespace", &testFunc);
1641 napi_call_function(env, instance, testFunc, 2, args, &funcResultValue); // 2: number of arguments
1642 ASSERT_NE(funcResultValue, nullptr);
1643
1644 name = "Hello, World!";
1645 napi_create_string_utf8(env, name.c_str(), name.size(), &val);
1646 napi_get_named_property(env, instance, "setComment", &testFunc);
1647 napi_call_function(env, instance, testFunc, 1, &val, &funcResultValue);
1648 ASSERT_NE(funcResultValue, nullptr);
1649
1650 name = "root SYSTEM";
1651 napi_create_string_utf8(env, name.c_str(), name.size(), &val);
1652 napi_get_named_property(env, instance, "setCDATA", &testFunc);
1653 napi_call_function(env, instance, testFunc, 1, &val, &funcResultValue);
1654 ASSERT_NE(funcResultValue, nullptr);
1655
1656 name = "Happy";
1657 napi_create_string_utf8(env, name.c_str(), name.size(), &val);
1658 napi_get_named_property(env, instance, "setText", &testFunc);
1659 napi_call_function(env, instance, testFunc, 1, &val, &funcResultValue);
1660 ASSERT_NE(funcResultValue, nullptr);
1661
1662 name = "root SYSTEM \"http://www.test.org/test.dtd\"";
1663 napi_create_string_utf8(env, name.c_str(), name.size(), &val);
1664 napi_get_named_property(env, instance, "setDocType", &testFunc);
1665 napi_call_function(env, instance, testFunc, 1, &val, &funcResultValue);
1666 ASSERT_NE(funcResultValue, nullptr);
1667
1668 napi_get_named_property(env, instance, "XmlSerializerError", &testFunc);
1669 napi_call_function(env, instance, testFunc, 0, nullptr, &funcResultValue);
1670 ASSERT_NE(funcResultValue, nullptr);
1671 }
1672
1673 /* @tc.name: XmlPullParsertest001
1674 * @tc.desc: To XML text to JavaScript object.
1675 * @tc.type: FUNC
1676 */
1677 HWTEST_F(NativeEngineTest, XmlPullParsertest001, testing::ext::TestSize.Level0)
1678 {
1679 napi_env env = (napi_env)engine_;
1680 napi_value exports = nullptr;
1681 napi_create_object(env, &exports);
1682 OHOS::xml::XmlPullParserInit(env, exports);
1683 napi_value xmlPullParserClass = nullptr;
1684 napi_get_named_property(env, exports, "XmlPullParser", &xmlPullParserClass);
1685
1686 std::string firStr = "<?xml version=\"1.0\" encoding=\"utf-8\"?><note importance=\"high\" logged=\"true\">";
1687 std::string secStr = " <title>Happy</title><todo>Work</todo><todo>Play</todo></note>";
1688 std::string strXml = firStr + secStr;
1689 napi_value args[2]; // 2: number of arguments
1690 void* pBuffer = nullptr;
1691 size_t strLen = strXml.size();
1692 napi_create_arraybuffer(env, strLen, &pBuffer, &args[0]);
1693 memcpy_s(pBuffer, strLen, strXml.c_str(), strLen);
1694 std::string encoding = "utf-8";
1695 napi_create_string_utf8(env, encoding.c_str(), encoding.size(), &args[1]);
1696 napi_value instance = nullptr;
1697 napi_new_instance(env, xmlPullParserClass, 2, args, &instance); // 2: number of arguments
1698
1699 napi_value obj = nullptr;
1700 napi_create_object(env, &obj);
1701 napi_value val;
1702 napi_get_boolean(env, true, &val);
1703 napi_set_named_property(env, obj, "supportDoctype", val);
1704 napi_set_named_property(env, obj, "ignoreNameSpace", val);
1705 std::string cbName = "Method";
1706 napi_create_function(env, cbName.c_str(), cbName.size(), Method, nullptr, &val);
1707 napi_set_named_property(env, obj, "tokenValueCallbackFunction", val);
1708 napi_value funcResultValue = nullptr;
1709 napi_value testFunc = nullptr;
1710 napi_get_named_property(env, instance, "parse", &testFunc);
1711 napi_call_function(env, instance, testFunc, 1, &obj, &funcResultValue);
1712 ASSERT_NE(funcResultValue, nullptr);
1713
1714 napi_get_named_property(env, instance, "XmlPullParserError", &testFunc);
1715 napi_call_function(env, instance, testFunc, 0, nullptr, &funcResultValue);
1716 ASSERT_NE(funcResultValue, nullptr);
1717 }
1718
1719 /* @tc.name: SetDeclaration
1720 * @tc.desc: Test SetDeclaration Func
1721 * @tc.type: FUNC
1722 */
1723 HWTEST_F(NativeEngineTest, Xmltest001, testing::ext::TestSize.Level0)
1724 {
1725 napi_env env = (napi_env)engine_;
1726
1727 XmlTest::SetDeclaration(env);
1728 XmlTest::SetNamespace(env);
1729 XmlTest::StartElement(env);
1730 XmlTest::WriteEscaped(env);
1731 XmlTest::XmlSerializerError(env);
1732
1733 std::string strXml = "<?xml version=\"1.0\" encoding=\"utf-8\"?> <title>Happy</title> <todo>Work</todo>";
1734 OHOS::xml::XmlPullParser xmlPullParser(strXml, "utf-8");
1735 XmlTest::PushSrcLinkList();
1736 std::string strTemp = "xml version";
1737 xmlPullParser.Replace(strTemp, "xml", "convert");
1738 ASSERT_STREQ(strTemp.c_str(), "convert version");
1739 }
1740
1741 /* @tc.name: GetNSCount
1742 * @tc.desc: Test GetNSCount Func
1743 * @tc.type: FUNC
1744 */
1745 HWTEST_F(NativeEngineTest, GetNSCount001, testing::ext::TestSize.Level0)
1746 {
1747 size_t res = XmlTest::GetNSCount(1);
1748 ASSERT_EQ(res, 0);
1749
1750 std::string str = XmlTest::XmlPullParserError();
1751 ASSERT_STREQ(str.c_str(), "IndexOutOfBoundsException");
1752 }
1753
1754 /* @tc.name: DealExclamationGroup
1755 * @tc.desc: Test DealExclamationGroup Func
1756 * @tc.type: FUNC
1757 */
1758 HWTEST_F(NativeEngineTest, DealExclamationGroup001, testing::ext::TestSize.Level0)
1759 {
1760 TagEnum tEnum = XmlTest::DealExclamationGroup("stER");
1761 ASSERT_EQ(tEnum, TagEnum::ERROR1);
1762
1763 tEnum = XmlTest::DealExclamationGroup("stNR");
1764 ASSERT_EQ(tEnum, TagEnum::NOTATIONDECL);
1765
1766 tEnum = XmlTest::DealExclamationGroup("staR");
1767 ASSERT_EQ(tEnum, TagEnum::ERROR1);
1768 }
1769
1770 /* @tc.name: DealLtGroup
1771 * @tc.desc: Test DealLtGroup Func
1772 * @tc.type: FUNC
1773 */
1774 HWTEST_F(NativeEngineTest, DealLtGroup001, testing::ext::TestSize.Level0)
1775 {
1776 TagEnum tEnum = XmlTest::DealLtGroup();
1777 ASSERT_EQ(tEnum, TagEnum::END_TAG);
1778
1779 tEnum = XmlTest::ParseTagType();
1780 ASSERT_EQ(tEnum, TagEnum::TEXT);
1781 }
1782
1783 /* @tc.name: MakeStrUpper
1784 * @tc.desc: Test MakeStrUpper Func
1785 * @tc.type: FUNC
1786 */
1787 HWTEST_F(NativeEngineTest, MakeStrUpper001, testing::ext::TestSize.Level0)
1788 {
1789 std::string strXml = "to";
1790 OHOS::xml::XmlPullParser xmlPullParser(strXml, "utf-8");
1791 std::string src = "C";
1792 xmlPullParser.MakeStrUpper(src);
1793 ASSERT_STREQ(src.c_str(), "c");
1794
1795 std::string str = "todo";
1796 src = XmlTest::SkipText(strXml, str);
1797 ASSERT_STREQ(src.c_str(), "expected: 'todo' but was EOF");
1798
1799 strXml = "<todo>Work</todo>";
1800 src = XmlTest::SkipText(strXml, str);
1801 ASSERT_STREQ(src.c_str(), "expected: \"todo\" but was \"<tod...\"");
1802 }
1803
1804 /* @tc.name: GetColumnNumber
1805 * @tc.desc: Test GetColumnNumber Func
1806 * @tc.type: FUNC
1807 */
1808 HWTEST_F(NativeEngineTest, GetColumnNumber, testing::ext::TestSize.Level0)
1809 {
1810 napi_env env = (napi_env)engine_;
1811 OHOS::xml::XmlTest testXml;
1812 int res = testXml.TestGetColumnNumber(env);
1813 ASSERT_EQ(res, 2); // 2: ColumnNumber
1814 }
1815
1816 /* @tc.name: GetLineNumber
1817 * @tc.desc: Test GetLineNumber Func
1818 * @tc.type: FUNC
1819 */
1820 HWTEST_F(NativeEngineTest, GetLineNumber, testing::ext::TestSize.Level0)
1821 {
1822 napi_env env = (napi_env)engine_;
1823 OHOS::xml::XmlTest testXml;
1824 int res = testXml.TestGetLineNumber(env);
1825
1826 OHOS::xml::XmlPullParser xml("1\n1", "utf8");
1827 xml.ParseInneNotaDecl();
1828 ASSERT_EQ(res, 2); // 2: LineNumber
1829 }
1830
1831 /* @tc.name: GetText
1832 * @tc.desc: Test GetText Func
1833 * @tc.type: FUNC
1834 */
1835 HWTEST_F(NativeEngineTest, GetText, testing::ext::TestSize.Level0)
1836 {
1837 napi_env env = (napi_env)engine_;
1838 OHOS::xml::XmlTest testXml;
1839 std::string res = testXml.TestGetText(env);
1840 ASSERT_STREQ(res.c_str(), "");
1841 }
1842
1843 /* @tc.name: ParseStartTagFuncDeal
1844 * @tc.desc: Test ParseStartTagFuncDeal Func
1845 * @tc.type: FUNC
1846 */
1847 HWTEST_F(NativeEngineTest, ParseStartTagFuncDeal, testing::ext::TestSize.Level0)
1848 {
1849 OHOS::xml::XmlPullParser xml("", "utf8");
1850 bool res = xml.ParseStartTagFuncDeal(true);
1851 ASSERT_FALSE(res);
1852 }
1853
1854 /* @tc.name: ParseNsp
1855 * @tc.desc: Test ParseNsp Func
1856 * @tc.type: FUNC
1857 */
1858 HWTEST_F(NativeEngineTest, ParseNsp, testing::ext::TestSize.Level0)
1859 {
1860 napi_env env = (napi_env)engine_;
1861 OHOS::xml::XmlTest testXml;
1862 bool res = testXml.TestParseNsp(env);
1863 ASSERT_FALSE(res);
1864 }
1865
1866 /* @tc.name: ParseDeclaration
1867 * @tc.desc: Test ParseDeclaration Func
1868 * @tc.type: FUNC
1869 */
1870 HWTEST_F(NativeEngineTest, ParseDeclaration, testing::ext::TestSize.Level0)
1871 {
1872 napi_env env = (napi_env)engine_;
1873 OHOS::xml::XmlTest testXml;
1874 testXml.TestParseDeclaration(env);
1875 bool res = false;
1876 ASSERT_FALSE(res);
1877 }
1878
1879 /* @tc.name: ParseDelimiterInfo
1880 * @tc.desc: Test ParseDelimiterInfo Func
1881 * @tc.type: FUNC
1882 */
1883 HWTEST_F(NativeEngineTest, ParseDelimiterInfo, testing::ext::TestSize.Level0)
1884 {
1885 napi_env env = (napi_env)engine_;
1886 OHOS::xml::XmlTest testXml;
1887 std::string res = testXml.TestParseDelimiterInfo(env);
1888 ASSERT_STREQ(res.c_str(), "");
1889 }
1890
1891 /* @tc.name: ParseEndTag
1892 * @tc.desc: Test ParseEndTag Func
1893 * @tc.type: FUNC
1894 */
1895 HWTEST_F(NativeEngineTest, ParseEndTag, testing::ext::TestSize.Level0)
1896 {
1897 napi_env env = (napi_env)engine_;
1898 OHOS::xml::XmlTest testXml;
1899 bool res = testXml.TestParseEndTag(env);
1900 ASSERT_FALSE(res);
1901 }
1902
1903 /* @tc.name: ParserDoctInnerInfo
1904 * @tc.desc: Test ParserDoctInnerInfo Func
1905 * @tc.type: FUNC
1906 */
1907 HWTEST_F(NativeEngineTest, ParserDoctInnerInfo, testing::ext::TestSize.Level0)
1908 {
1909 OHOS::xml::XmlPullParser xml("S11", "utf8");
1910 bool res = xml.ParserDoctInnerInfo(false, true);
1911
1912 OHOS::xml::XmlPullParser xml1("P11", "utf8");
1913 res = xml1.ParserDoctInnerInfo(true, true);
1914 OHOS::xml::XmlPullParser xml2("P11", "utf8");
1915 res = xml2.ParserDoctInnerInfo(true, false);
1916 ASSERT_TRUE(res);
1917 }
1918
1919 /* @tc.name: ParseDelimiter
1920 * @tc.desc: Test ParseDelimiter Func
1921 * @tc.type: FUNC
1922 */
1923 HWTEST_F(NativeEngineTest, ParseDelimiter, testing::ext::TestSize.Level0)
1924 {
1925 OHOS::xml::XmlPullParser xml("\"\'1", "utf8");
1926 std::string res = xml.ParseDelimiter(false);
1927 ASSERT_STREQ(res.c_str(), "");
1928 }
1929
1930 /* @tc.name: ParseSpecText
1931 * @tc.desc: Test ParseSpecText Func
1932 * @tc.type: FUNC
1933 */
1934 HWTEST_F(NativeEngineTest, ParseSpecText, testing::ext::TestSize.Level0)
1935 {
1936 OHOS::xml::XmlPullParser xml("()*", "utf8");
1937 xml.ParseSpecText();
1938 OHOS::xml::XmlPullParser xml1("E", "utf8");
1939 xml1.ParseSpecText();
1940 OHOS::xml::XmlPullParser xml2("A", "utf8");
1941 xml2.ParseSpecText();
1942 bool res = false;
1943 ASSERT_FALSE(res);
1944 }
1945
1946 /* @tc.name: ParseComment
1947 * @tc.desc: Test ParseComment Func
1948 * @tc.type: FUNC
1949 */
1950 HWTEST_F(NativeEngineTest, ParseComment, testing::ext::TestSize.Level0)
1951 {
1952 napi_env env = (napi_env)engine_;
1953 OHOS::xml::XmlTest testXml;
1954 bool res = testXml.TestParseComment(env);
1955 ASSERT_FALSE(res);
1956 }
1957
1958 /* @tc.name: ParseOneTagFunc
1959 * @tc.desc: Test ParseOneTagFunc Func
1960 * @tc.type: FUNC
1961 */
1962 HWTEST_F(NativeEngineTest, ParseOneTagFunc, testing::ext::TestSize.Level0)
1963 {
1964 OHOS::xml::XmlTest testXml;
1965 OHOS::xml::TagEnum res = testXml.TestParseOneTagFunc();
1966 ASSERT_EQ(res, OHOS::xml::TagEnum::ERROR1);
1967 }
1968
1969 /* @tc.name: ParseEntityDecl
1970 * @tc.desc: Test ParseEntityDecl Func
1971 * @tc.type: FUNC
1972 */
1973 HWTEST_F(NativeEngineTest, TestParseEntityDecl, testing::ext::TestSize.Level0)
1974 {
1975 OHOS::xml::XmlTest testXml;
1976 testXml.TestParseEntityDecl();
1977 bool res = false;
1978 ASSERT_FALSE(res);
1979 }
1980
1981 /* @tc.name: ParseNameInner
1982 * @tc.desc: Test ParseNameInner Func
1983 * @tc.type: FUNC
1984 */
1985 HWTEST_F(NativeEngineTest, ParseNameInner, testing::ext::TestSize.Level0)
1986 {
1987 std::string res = XmlTest::ParseNameInner(1);
1988 ASSERT_STREQ(res.c_str(), "version");
1989 }
1990
1991 /* @tc.name: ParseName
1992 * @tc.desc: Test ParseName Func
1993 * @tc.type: FUNC
1994 */
1995 HWTEST_F(NativeEngineTest, ParseName, testing::ext::TestSize.Level0)
1996 {
1997 std::string res = XmlTest::ParseName();
1998 ASSERT_STREQ(res.c_str(), "");
1999 }
2000
2001 /* @tc.name: ParseEntityFunc
2002 * @tc.desc: Test ParseEntityFunc Func
2003 * @tc.type: FUNC
2004 */
2005 HWTEST_F(NativeEngineTest, ParseEntityFunc, testing::ext::TestSize.Level0)
2006 {
2007 OHOS::xml::XmlPullParser xmlPullParser("xml", "utf8");
2008 std::string out = "W#x2";
2009 XmlTest::ParseEntityFunc(out, "", true, TextEnum::ENTITY_DECL);
2010
2011 out = "W#1";
2012 XmlTest::ParseEntityFunc(out, "", true, TextEnum::ENTITY_DECL);
2013
2014 out = "Work1";
2015 XmlTest::ParseEntityFunc(out, "", true, TextEnum::ENTITY_DECL);
2016
2017 out = "Work";
2018 XmlTest::ParseEntityFunc(out, "", true, TextEnum::TEXT);
2019 XmlTest::ParseEntityFunc(out, "", false, TextEnum::TEXT);
2020
2021 out = "W";
2022 XmlTest::ParseEntityFunc(out, "", true, TextEnum::TEXT);
2023 XmlTest::ParseEntityFunc(out, "info", true, TextEnum::TEXT);
2024 }
2025
2026 /* @tc.name: ParseEntity
2027 * @tc.desc: Test ParseEntity Func
2028 * @tc.type: FUNC
2029 */
2030 HWTEST_F(NativeEngineTest, ParseEntity, testing::ext::TestSize.Level0)
2031 {
2032 std::string res = XmlTest::ParseEntity();
2033 ASSERT_STREQ(res.c_str(), "Should not be reached");
2034 }
2035
2036 /* @tc.name: ParseTagValueInner
2037 * @tc.desc: Test ParseTagValueInner Func
2038 * @tc.type: FUNC
2039 */
2040 HWTEST_F(NativeEngineTest, ParseTagValueInner, testing::ext::TestSize.Level0)
2041 {
2042 size_t start = 0;
2043 std::string result = "xml";
2044 size_t position = 1;
2045 std::string xmlStr = "todo";
2046 size_t res = XmlTest::ParseTagValueInner(start, result, position, xmlStr);
2047 ASSERT_EQ(res, 2);
2048
2049 start = 1;
2050 xmlStr = "t";
2051 res = XmlTest::ParseTagValueInner(start, result, position, xmlStr);
2052 ASSERT_EQ(res, 0);
2053 }
2054
2055 /* @tc.name: ParseTagValue
2056 * @tc.desc: Test ParseTagValue Func
2057 * @tc.type: FUNC
2058 */
2059 HWTEST_F(NativeEngineTest, ParseTagValue, testing::ext::TestSize.Level0)
2060 {
2061 size_t max = 1;
2062 std::string strXml = "W";
2063 std::string res = XmlTest::ParseTagValue('c', false, TextEnum::TEXT, max);
2064 ASSERT_STREQ(res.c_str(), "xml");
2065
2066 res = XmlTest::ParseTagValue('e', true, TextEnum::ATTRI, max);
2067 ASSERT_STREQ(res.c_str(), "");
2068 }
2069
2070 /* @tc.name: GetNamespace
2071 * @tc.desc: Test GetNamespace Func
2072 * @tc.type: FUNC
2073 */
2074 HWTEST_F(NativeEngineTest, GetNamespace, testing::ext::TestSize.Level0)
2075 {
2076 std::string prefix = "";
2077 size_t depth = 2;
2078 std::string res = XmlTest::GetNamespace(prefix, depth);
2079 ASSERT_STREQ(res.c_str(), "W");
2080
2081 prefix = "fix";
2082 depth = 1;
2083 std::string res1 = XmlTest::GetNamespace(prefix, depth);
2084 ASSERT_STREQ(res1.c_str(), "");
2085 }
2086
2087 /* @tc.name: ParseNspFunc
2088 * @tc.desc: Test ParseNspFunc Func
2089 * @tc.type: FUNC
2090 */
2091 HWTEST_F(NativeEngineTest, ParseNspFunc, testing::ext::TestSize.Level0)
2092 {
2093 std::string res = XmlTest::ParseNspFunc();
2094 ASSERT_STREQ(res.c_str(), "illegal empty namespace");
2095 }
2096
2097 /* @tc.name: ParseNspFunction
2098 * @tc.desc: Test ParseNspFunction Func
2099 * @tc.type: FUNC
2100 */
2101 HWTEST_F(NativeEngineTest, ParseNspFunction, testing::ext::TestSize.Level0)
2102 {
2103 std::string pushStr = "yu:er";
2104 std::string res = XmlTest::ParseNspFunction(pushStr);
2105 ASSERT_STREQ(res.c_str(), "Undefined Prefix: yu in ");
2106
2107 pushStr = ":yuer";
2108 res = XmlTest::ParseNspFunction(pushStr);
2109 ASSERT_STREQ(res.c_str(), "illegal attribute name: ");
2110 }
2111
2112 /* @tc.name: ParseNsp002
2113 * @tc.desc: Test ParseNsp Func
2114 * @tc.type: FUNC
2115 */
2116 HWTEST_F(NativeEngineTest, ParseNsp002, testing::ext::TestSize.Level0)
2117 {
2118 bool res = XmlTest::ParseNsp();
2119 ASSERT_FALSE(res);
2120 }
2121
2122 /* @tc.name: ParseStartTagFuncDeal002
2123 * @tc.desc: Test ParseStartTagFuncDeal Func
2124 * @tc.type: FUNC
2125 */
2126 HWTEST_F(NativeEngineTest, ParseStartTagFuncDeal002, testing::ext::TestSize.Level0)
2127 {
2128 bool res = XmlTest::ParseStartTagFuncDeal("w=", false);
2129 ASSERT_FALSE(res);
2130
2131 res = XmlTest::ParseStartTagFuncDeal("=q", true);
2132 ASSERT_TRUE(res);
2133
2134 res = XmlTest::ParseStartTagFuncDeal("==", false);
2135 ASSERT_TRUE(res);
2136 }
2137
2138 /* @tc.name: ParseStartTagFunc
2139 * @tc.desc: Test ParseStartTagFunc Func
2140 * @tc.type: FUNC
2141 */
2142 HWTEST_F(NativeEngineTest, ParseStartTagFunc, testing::ext::TestSize.Level0)
2143 {
2144 OHOS::xml::XmlPullParser xmlPullParser("", "utf-8");
2145 bool res = xmlPullParser.ParseStartTagFunc(false, false);
2146 ASSERT_FALSE(res);
2147 }
2148
2149 /* @tc.name: ParseDeclaration002
2150 * @tc.desc: Test ParseDeclaration Func
2151 * @tc.type: FUNC
2152 */
2153 HWTEST_F(NativeEngineTest, ParseDeclaration002, testing::ext::TestSize.Level0)
2154 {
2155 std::string xml = "<?xml version=\"1.0\" encoding=\"utf-8\" standalone=\"no\"?><todo>Work</todo>";
2156 bool res = XmlTest::ParseDeclaration(xml);
2157 ASSERT_TRUE(res);
2158
2159 xml = "<?xml version=\"1.0\" encoding=\"utf-8\" standalone=\"yes\"?><todo>Work</todo>";
2160 res = XmlTest::ParseDeclaration(xml);
2161 ASSERT_TRUE(res);
2162
2163 xml = "<?xml version=\"1.0\" encoding=\"utf-8\" standalone=\"else\"?><todo>Work</todo>";
2164 res = XmlTest::ParseDeclaration(xml);
2165 ASSERT_TRUE(res);
2166
2167 xml = "<?xml version=\"1.0\" encoding=\"utf-8\" standa=\"no\"?><todo>Work</todo>";
2168 res = XmlTest::ParseDeclaration(xml);
2169 ASSERT_TRUE(res);
2170 }