1 /*
2 * Copyright (c) 2023 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 #ifndef TEST_XML_H
17 #define TEST_XML_H
18
19 #include "js_api_module/xml/js_xml.h"
20
21 namespace OHOS::xml {
22 class XmlTest {
23 public:
24 XmlTest() = default;
25 ~XmlTest() = default;
26 static XmlSerializer construct(napi_env env);
27 static void SetDeclaration(napi_env env);
28 static void SetNamespace(napi_env env);
29 static void StartElement(napi_env env);
30 static void WriteEscaped(napi_env env);
31 static void XmlSerializerError(napi_env env);
32 static void PushSrcLinkList(napi_env env);
33 static size_t GetNSCount(napi_env env, size_t iTemp);
34 static std::string XmlPullParserError(napi_env env);
35 static TagEnum DealExclamationGroup(napi_env env, std::string xml);
36 static TagEnum DealLtGroup(napi_env env);
37 static TagEnum ParseTagType(napi_env env, std::string str, int apiVersion);
38 static std::string SkipText(napi_env env, std::string strXml, std::string str);
39 static std::string ParseNameInner(napi_env env, size_t start);
40 static std::string ParseName(napi_env env);
41 static bool ParseEntityFunc(napi_env env, std::string out, std::string sysInfo, bool flag, TextEnum textEnum);
42 static std::string ParseEntity(napi_env env, bool relaxed);
43 static size_t ParseTagValueInner(napi_env env, size_t &start,
44 std::string &result, size_t position, std::string xmlStr);
45 static std::string ParseTagValue(napi_env env, char delimiter, bool resolveEntities, TextEnum textEnum, size_t max);
46 static std::string GetNamespace(napi_env env, const std::string prefix, size_t depth);
47 static std::string ParseNspFunc(napi_env env);
48 static std::string ParseNspFunction(napi_env env, std::string pushStr);
49 static bool ParseNsp(napi_env env);
50 static bool ParseStartTagFuncDeal(napi_env env, std::string xml, bool relax);
51 static bool ParseDeclaration(napi_env env, std::string str);
52 static bool ReadInternalSubset();
53 static bool ParseStartTag(napi_env env, std::string str);
54 static bool ParseEndTagFunction(napi_env env, std::string str);
55 static bool ParseTagValueFunc(napi_env env, std::string str, char &c, size_t &start, std::string &result);
56 static std::string DealNapiStrValueFunction(napi_env env, std::string pushStr);
57 static int SplicNspFunction(napi_env env, std::string pushStr);
58 static std::string SetNamespaceFunction(napi_env env, std::string prefix, const std::string &nsTemp);
59 static std::string XmlSerializerErrorFunction(napi_env env);
60 static std::string DealLengthFuc(napi_env env, std::string str, size_t minimum, std::string pushStr);
61 int SkipCharFunction(napi_env env, std::string str, char expected);
62 int TestGetColumnNumber(napi_env env);
63 int TestGetLineNumber(napi_env env);
64 std::string TestGetText(napi_env env);
65 bool TestParseNsp(napi_env env);
66 void TestParseDeclaration(napi_env env);
67 std::string TestParseDelimiterInfo(napi_env env);
68 bool TestParseEndTag(napi_env env);
69 bool TestParseComment(napi_env env);
70 TagEnum TestParseOneTagFunc(napi_env env);
71 static TagEnum ParseStartTagFuncTest(napi_env env, std::string str, bool xmldecl, bool throwOnResolveFailure);
72 void TestParseEntityDecl(napi_env env);
73 };
74
construct(napi_env env)75 XmlSerializer XmlTest::construct(napi_env env)
76 {
77 napi_value arrayBuffer = nullptr;
78 void* pBuffer = nullptr;
79 size_t size = 1024; // 1024: buffer size
80 napi_create_arraybuffer(env, size, &pBuffer, &arrayBuffer);
81 OHOS::xml::XmlSerializer xmlSerializer(reinterpret_cast<char*>(pBuffer), size, "utf-8");
82 return xmlSerializer;
83 }
84
SetDeclaration(napi_env env)85 void XmlTest::SetDeclaration(napi_env env)
86 {
87 XmlSerializer xmlSerializer = construct(env);
88 xmlSerializer.isHasDecl = true;
89 xmlSerializer.SetDeclaration();
90 }
91
SetNamespace(napi_env env)92 void XmlTest::SetNamespace(napi_env env)
93 {
94 XmlSerializer xmlSerializer = construct(env);
95 xmlSerializer.type = "isStart";
96 xmlSerializer.iLength_ = 0;
97 xmlSerializer.depth_ = 1;
98 xmlSerializer.elementStack.push_back("");
99 xmlSerializer.elementStack.push_back("");
100 xmlSerializer.SetNamespace("xml", "convert");
101 }
102
StartElement(napi_env env)103 void XmlTest::StartElement(napi_env env)
104 {
105 XmlSerializer xmlSerializer = construct(env);
106 xmlSerializer.depth_ = 1;
107 xmlSerializer.elementStack[0] = "x";
108 xmlSerializer.elementStack.push_back("");
109 xmlSerializer.elementStack.push_back("");
110 xmlSerializer.elementStack.push_back("");
111 xmlSerializer.StartElement("val");
112 }
113
WriteEscaped(napi_env env)114 void XmlTest::WriteEscaped(napi_env env)
115 {
116 XmlSerializer xmlSerializer = construct(env);
117 xmlSerializer.WriteEscaped("'\"&><q");
118 }
119
XmlSerializerError(napi_env env)120 void XmlTest::XmlSerializerError(napi_env env)
121 {
122 XmlSerializer xmlSerializer = construct(env);
123 xmlSerializer.XmlSerializerError();
124 }
125
PushSrcLinkList(napi_env env)126 void XmlTest::PushSrcLinkList(napi_env env)
127 {
128 std::string strXml = "<?xml version=\"1.0\" encoding=\"utf-8\"?> <title>Happy</title> <todo>Work</todo>";
129 OHOS::xml::XmlPullParser xmlPullParser(env, strXml, "utf-8");
130 xmlPullParser.PushSrcLinkList("str");
131 }
132
GetNSCount(napi_env env,size_t iTemp)133 size_t XmlTest::GetNSCount(napi_env env, size_t iTemp)
134 {
135 std::string strXml = "<?xml version=\"1.0\" encoding=\"utf-8\"?><todo>Work</todo>";
136 OHOS::xml::XmlPullParser xmlPullParser(env, strXml, "utf-8");
137 xmlPullParser.nspCounts_.push_back(0);
138 xmlPullParser.nspCounts_.push_back(1);
139 return xmlPullParser.GetNSCount(iTemp);
140 }
141
XmlPullParserError(napi_env env)142 std::string XmlTest::XmlPullParserError(napi_env env)
143 {
144 std::string strXml = "<?xml version=\"1.0\" encoding=\"utf-8\"?><todo>Work</todo>";
145 OHOS::xml::XmlPullParser xmlPullParser(env, "strXml", "utf-8");
146 xmlPullParser.xmlPullParserError_ = "IndexOutOfBoundsException";
147 return xmlPullParser.XmlPullParserError();
148 }
149
DealExclamationGroup(napi_env env,std::string xml)150 TagEnum XmlTest::DealExclamationGroup(napi_env env, std::string xml)
151 {
152 std::string strXml = "<?xml version=\"1.0\" encoding=\"utf-8\"?><todo>Work</todo>";
153 OHOS::xml::XmlPullParser xmlPullParser(env, "strXml", "utf-8");
154 xmlPullParser.strXml_ = xml;
155 return xmlPullParser.DealExclamationGroup();
156 }
157
DealLtGroup(napi_env env)158 TagEnum XmlTest::DealLtGroup(napi_env env)
159 {
160 std::string strXml = "<?xml version=\"1.0\" encoding=\"utf-8\"?><todo>Work</todo>";
161 OHOS::xml::XmlPullParser xmlPullParser(env, strXml, "utf-8");
162 xmlPullParser.strXml_ = "?/";
163 return xmlPullParser.DealLtGroup();
164 }
165
ParseTagType(napi_env env,std::string str,int apiVersion)166 TagEnum XmlTest::ParseTagType(napi_env env, std::string str, int apiVersion)
167 {
168 std::string strXml = "<?xml version=\"1.0\" encoding=\"utf-8\"?><todo>Work</todo>";
169 OHOS::xml::XmlPullParser xmlPullParser(env, strXml, "utf-8");
170 xmlPullParser.bStartDoc_ = false;
171 xmlPullParser.max_ = 0;
172 xmlPullParser.strXml_ = str;
173 xmlPullParser.apiVersion_ = apiVersion;
174 return xmlPullParser.ParseTagType(false);
175 }
176
SkipText(napi_env env,std::string strXml,std::string str)177 std::string XmlTest::SkipText(napi_env env, std::string strXml, std::string str)
178 {
179 OHOS::xml::XmlPullParser xmlPullParser(env, strXml, "utf-8");
180 xmlPullParser.SkipText(str);
181 return xmlPullParser.XmlPullParserError();
182 }
183
TestGetColumnNumber(napi_env env)184 int XmlTest::TestGetColumnNumber(napi_env env)
185 {
186 OHOS::xml::XmlPullParser xml(env, "1\n1", "utf8");
187 xml.position_ = 3; // 3: index is three
188 int res = xml.GetColumnNumber();
189 return res;
190 }
191
TestGetLineNumber(napi_env env)192 int XmlTest::TestGetLineNumber(napi_env env)
193 {
194 OHOS::xml::XmlPullParser xml(env, "\n", "utf8");
195 xml.position_ = 1;
196 int res = xml.GetLineNumber();
197 return res;
198 }
199
TestGetText(napi_env env)200 std::string XmlTest::TestGetText(napi_env env)
201 {
202 OHOS::xml::XmlPullParser xml(env, "1\n1", "utf8");
203 xml.type = TagEnum::WHITESPACE;
204 return xml.GetText();
205 }
206
TestParseNsp(napi_env env)207 bool XmlTest::TestParseNsp(napi_env env)
208 {
209 OHOS::xml::XmlPullParser xml(env, "", "utf8");
210 xml.attriCount_ = 1;
211 xml.attributes.push_back("");
212 xml.attributes.push_back("");
213 xml.attributes.push_back("xmlns");
214 xml.attributes.push_back("");
215 xml.nspCounts_.push_back(0);
216 xml.name_ = ":";
217 return xml.ParseNsp();
218 }
219
TestParseDeclaration(napi_env env)220 void XmlTest::TestParseDeclaration(napi_env env)
221 {
222 OHOS::xml::XmlPullParser xml(env, "", "utf8");
223 xml.bufferStartLine_ = 1;
224 xml.attributes.push_back("");
225 xml.attributes.push_back("");
226 xml.attributes.push_back("");
227 xml.attributes.push_back("1.0");
228 xml.ParseDeclaration();
229 }
230
TestParseDelimiterInfo(napi_env env)231 std::string XmlTest::TestParseDelimiterInfo(napi_env env)
232 {
233 OHOS::xml::XmlPullParser xml(env, "12", "utf8");
234 xml.text_ = "123";
235 std::string res = xml.ParseDelimiterInfo("456", true);
236 xml.strXml_ = "456";
237 xml.position_ = 0;
238 res = xml.ParseDelimiterInfo("456", false);
239 return res;
240 }
241
TestParseEndTag(napi_env env)242 bool XmlTest::TestParseEndTag(napi_env env)
243 {
244 OHOS::xml::XmlPullParser xml(env, "123456789", "utf8");
245 xml.relaxed = false;
246 xml.depth = 1;
247 xml.elementStack_.resize(20); // 20 :vector size
248 xml.elementStack_[3] = "!"; // 3: index of three
249 xml.ParseEndTag();
250 xml.depth = 0;
251 xml.ParseEndTag();
252 return false;
253 }
254
TestParseComment(napi_env env)255 bool XmlTest::TestParseComment(napi_env env)
256 {
257 OHOS::xml::XmlPullParser xml(env, "1", "utf8");
258 xml.relaxed = true;
259 xml.ParseComment(true);
260 return false;
261 }
262
TestParseOneTagFunc(napi_env env)263 TagEnum XmlTest::TestParseOneTagFunc(napi_env env)
264 {
265 OHOS::xml::XmlPullParser xml(env, "1", "utf8");
266 xml.type = TagEnum::ERROR;
267 TagEnum res = xml.ParseOneTagFunc();
268 return res;
269 }
270
TestParseEntityDecl(napi_env env)271 void XmlTest::TestParseEntityDecl(napi_env env)
272 {
273 OHOS::xml::XmlPullParser xml(env, "%1234", "utf8");
274 xml.ParseEntityDecl();
275 }
276
ParseNameInner(napi_env env,size_t start)277 std::string XmlTest::ParseNameInner(napi_env env, size_t start)
278 {
279 std::string strXml = "<todo>Work</todo>";
280 OHOS::xml::XmlPullParser xmlPullParser(env, strXml, "utf-8");
281 xmlPullParser.position_ = 1;
282 xmlPullParser.max_ = 1;
283 xmlPullParser.strXml_ = "version";
284 return xmlPullParser.ParseNameInner(start);
285 }
286
ParseName(napi_env env)287 std::string XmlTest::ParseName(napi_env env)
288 {
289 std::string strXml = "><todo>Work</todo>";
290 OHOS::xml::XmlPullParser xmlPullParser(env, strXml, "utf-8");
291 xmlPullParser.strXml_ = "encoding";
292 size_t len = xmlPullParser.strXml_.length();
293 xmlPullParser.position_ = len;
294 xmlPullParser.max_ = len;
295 return xmlPullParser.ParseName();
296 }
297
ParseEntityFunc(napi_env env,std::string out,std::string sysInfo,bool flag,TextEnum textEnum)298 bool XmlTest::ParseEntityFunc(napi_env env, std::string out, std::string sysInfo, bool flag, TextEnum textEnum)
299 {
300 std::string strXml = "<todo>Work</todo>";
301 OHOS::xml::XmlPullParser xmlPullParser(env, strXml, "utf-8");
302 std::string key = "Work";
303 xmlPullParser.documentEntities[key] = "value";
304 xmlPullParser.bDocDecl = flag;
305 xmlPullParser.sysInfo_ = sysInfo;
306 xmlPullParser.ParseEntityFunc(0, out, true, textEnum);
307 return xmlPullParser.bUnresolved_;
308 }
309
ParseEntity(napi_env env,bool relaxed)310 std::string XmlTest::ParseEntity(napi_env env, bool relaxed)
311 {
312 std::string strXml = "Wor";
313 std::string out = "W#13434";
314 OHOS::xml::XmlPullParser xmlPullParser(env, strXml, "utf-8");
315 xmlPullParser.position_ = 0;
316 xmlPullParser.max_ = 1;
317 xmlPullParser.relaxed = relaxed;
318 xmlPullParser.ParseEntity(out, true, true, TextEnum::ENTITY_DECL);
319 return xmlPullParser.XmlPullParserError();
320 }
321
ParseTagValueInner(napi_env env,size_t & start,std::string & result,size_t position,std::string xmlStr)322 size_t XmlTest::ParseTagValueInner(napi_env env, size_t &start,
323 std::string &result, size_t position, std::string xmlStr)
324 {
325 std::string strXml = "<todo>Work</todo>";
326 OHOS::xml::XmlPullParser xmlPullParser(env, strXml, "utf-8");
327 xmlPullParser.position_ = position;
328 xmlPullParser.max_ = 1;
329 xmlPullParser.strXml_ = xmlStr;
330 return xmlPullParser.ParseTagValueInner(start, result, 'o', TextEnum::ENTITY_DECL, false);
331 }
332
ParseTagValue(napi_env env,char delimiter,bool resolveEntities,TextEnum textEnum,size_t max)333 std::string XmlTest::ParseTagValue(napi_env env, char delimiter, bool resolveEntities, TextEnum textEnum, size_t max)
334 {
335 std::string xml = "W";
336 OHOS::xml::XmlPullParser xmlPullParser(env, xml, "utf-8");
337 xmlPullParser.text_ = "xml";
338 xmlPullParser.position_ = 1;
339 xmlPullParser.max_ = max;
340 return xmlPullParser.ParseTagValue(delimiter, resolveEntities, false, textEnum);
341 }
342
GetNamespace(napi_env env,const std::string prefix,size_t depth)343 std::string XmlTest::GetNamespace(napi_env env, const std::string prefix, size_t depth)
344 {
345 std::string xml = "Work";
346 const std::string preStr = prefix;
347 OHOS::xml::XmlPullParser xmlPullParser(env, xml, "utf-8");
348 xmlPullParser.depth = depth;
349 xmlPullParser.nspCounts_.push_back(0);
350 xmlPullParser.nspCounts_.push_back(1);
351 xmlPullParser.nspCounts_.push_back(2); // values greater than pos_
352 xmlPullParser.nspStack_.push_back("Q");
353 xmlPullParser.nspStack_.push_back("E");
354 xmlPullParser.nspStack_.push_back("");
355 xmlPullParser.nspStack_.push_back("W");
356 return xmlPullParser.GetNamespace(preStr);
357 }
358
ParseNspFunc(napi_env env)359 std::string XmlTest::ParseNspFunc(napi_env env)
360 {
361 std::string xml = "Work";
362 size_t count = 0;
363 std::string attrName = "sub";
364 bool any = true;
365 OHOS::xml::XmlPullParser xmlPullParser(env, xml, "utf-8");
366 xmlPullParser.attributes.push_back("q");
367 xmlPullParser.attributes.push_back("e");
368 xmlPullParser.attributes.push_back("r");
369 xmlPullParser.attributes.push_back("");
370 xmlPullParser.nspCounts_.push_back(0);
371 xmlPullParser.nspStack_.push_back("t");
372 xmlPullParser.nspStack_.push_back("c");
373 xmlPullParser.nspStack_.push_back("y");
374 xmlPullParser.nspStack_.push_back("p");
375 xmlPullParser.bKeepNsAttri = true;
376 xmlPullParser.ParseNspFunc(count, attrName, any);
377 return xmlPullParser.XmlPullParserError();
378 }
379
ParseNspFunction(napi_env env,std::string pushStr)380 std::string XmlTest::ParseNspFunction(napi_env env, std::string pushStr)
381 {
382 std::string xml = "Work";
383 OHOS::xml::XmlPullParser xmlPullParser(env, xml, "utf-8");
384 xmlPullParser.attriCount_ = 1;
385 xmlPullParser.depth = 1;
386 xmlPullParser.nspCounts_.push_back(0);
387 xmlPullParser.nspCounts_.push_back(1);
388 xmlPullParser.nspCounts_.push_back(2); // values greater than pos_
389 xmlPullParser.nspStack_.push_back("Q");
390 xmlPullParser.nspStack_.push_back("E");
391 xmlPullParser.nspStack_.push_back("");
392 xmlPullParser.nspStack_.push_back("W");
393 xmlPullParser.attributes.push_back("r");
394 xmlPullParser.attributes.push_back("t");
395 xmlPullParser.attributes.push_back(pushStr);
396 xmlPullParser.ParseNspFunction();
397 return xmlPullParser.XmlPullParserError();
398 }
399
ParseNsp(napi_env env)400 bool XmlTest::ParseNsp(napi_env env)
401 {
402 std::string xml = "Work";
403 OHOS::xml::XmlPullParser xmlPullParser(env, xml, "utf-8");
404 xmlPullParser.attributes.push_back("");
405 xmlPullParser.attributes.push_back("");
406 xmlPullParser.attributes.push_back("xmlns");
407 xmlPullParser.nspCounts_.push_back(0);
408 xmlPullParser.name_ = ":xml";
409 return xmlPullParser.ParseNsp();
410 }
411
ParseStartTagFuncDeal(napi_env env,std::string xml,bool relax)412 bool XmlTest::ParseStartTagFuncDeal(napi_env env, std::string xml, bool relax)
413 {
414 OHOS::xml::XmlPullParser xmlPullParser(env, xml, "utf-8");
415 xmlPullParser.position_ = 0;
416 xmlPullParser.max_ = 1;
417 xmlPullParser.relaxed = relax;
418 return xmlPullParser.ParseStartTagFuncDeal(true);
419 }
420
ParseDeclaration(napi_env env,std::string str)421 bool XmlTest::ParseDeclaration(napi_env env, std::string str)
422 {
423 OHOS::xml::XmlPullParser xmlPullParser(env, str, "utf-8");
424 xmlPullParser.attriCount_ = 3; // values greater than pos_
425 xmlPullParser.ParseDeclaration();
426 return true;
427 }
428
DealNapiStrValueFunction(napi_env env,std::string pushStr)429 std::string XmlTest::DealNapiStrValueFunction(napi_env env, std::string pushStr)
430 {
431 napi_value arg = nullptr;
432 std::string output = "";
433 napi_create_string_utf8(env, pushStr.c_str(), pushStr.size(), &arg);
434 XmlSerializer xmlSerializer = construct(env);
435 xmlSerializer.DealNapiStrValue(env, arg, output);
436 return output;
437 }
438
SplicNspFunction(napi_env env,std::string pushStr)439 int XmlTest::SplicNspFunction(napi_env env, std::string pushStr)
440 {
441 XmlSerializer xmlSerializer = construct(env);
442 xmlSerializer.type = pushStr;
443 return xmlSerializer.curNspNum;
444 }
445
SetNamespaceFunction(napi_env env,std::string prefix,const std::string & nsTemp)446 std::string XmlTest::SetNamespaceFunction(napi_env env, std::string prefix, const std::string &nsTemp)
447 {
448 XmlSerializer xmlSerializer = construct(env);
449 xmlSerializer.type = "isStart";
450 xmlSerializer.SetDeclaration();
451 xmlSerializer.SetNamespace(prefix, nsTemp);
452 xmlSerializer.StartElement("note");
453 xmlSerializer.EndElement();
454 return xmlSerializer.out_;
455 }
456
XmlSerializerErrorFunction(napi_env env)457 std::string XmlTest::XmlSerializerErrorFunction(napi_env env)
458 {
459 XmlSerializer xmlSerializer = construct(env);
460 xmlSerializer.isHasDecl = true;
461 xmlSerializer.SetDeclaration();
462 return xmlSerializer.xmlSerializerError_;
463 }
464
ParseStartTag(napi_env env,std::string str)465 bool XmlTest::ParseStartTag(napi_env env, std::string str)
466 {
467 OHOS::xml::XmlPullParser xmlPullParser(env, str, "utf-8");
468 xmlPullParser.attriCount_ = 3; // values greater than pos_
469 xmlPullParser.defaultAttributes["lt;"]["<"] = "lt;";
470 xmlPullParser.defaultAttributes["lt;"]["<"] = "<";
471 xmlPullParser.defaultAttributes["gt;"]["<"] = "gt;";
472 xmlPullParser.defaultAttributes["gt;"]["<"] = ">";
473 xmlPullParser.ParseStartTag(false, false);
474 xmlPullParser.ParseDeclaration();
475 return true;
476 }
477
ParseEndTagFunction(napi_env env,std::string str)478 bool XmlTest::ParseEndTagFunction(napi_env env, std::string str)
479 {
480 OHOS::xml::XmlPullParser xml(env, str, "utf8");
481 xml.relaxed = false;
482 xml.depth = 1;
483 xml.elementStack_.resize(20); // 20 :vector size
484 xml.elementStack_[3] = "!"; // 3: index of three
485 xml.ParseEndTag();
486 xml.depth = 0;
487 xml.ParseEndTag();
488 return true;
489 }
490
ParseTagValueFunc(napi_env env,std::string str,char & c,size_t & start,std::string & result)491 bool XmlTest::ParseTagValueFunc(napi_env env, std::string str, char &c, size_t &start, std::string &result)
492 {
493 OHOS::xml::XmlPullParser xml(env, str, "utf8");
494 xml.max_ = 100; // 100: max_ size
495 return xml.ParseTagValueFunc(c, true, TextEnum::ATTRI, start, result);
496 }
497
DealLengthFuc(napi_env env,std::string str,size_t minimum,std::string pushStr)498 std::string XmlTest::DealLengthFuc(napi_env env, std::string str, size_t minimum, std::string pushStr)
499 {
500 OHOS::xml::XmlPullParser xmlPullParser(env, str, "utf-8");
501 xmlPullParser.keyInfo_ = pushStr;
502 xmlPullParser.position_ = 10; // 10: position_ size
503 xmlPullParser.DealLength(minimum);
504 return xmlPullParser.keyInfo_;
505 }
506
ParseStartTagFuncTest(napi_env env,std::string str,bool xmldecl,bool throwOnResolveFailure)507 TagEnum XmlTest::ParseStartTagFuncTest(napi_env env, std::string str, bool xmldecl, bool throwOnResolveFailure)
508 {
509 OHOS::xml::XmlPullParser xmlPullParser(env, str, "utf-8");
510 size_t minimum = 10; // 10: minimum size
511 xmlPullParser.position_ = 100; // 100: position_ size
512 xmlPullParser.DealLength(minimum);
513 TagEnum res = xmlPullParser.ParseStartTagFunc(xmldecl, throwOnResolveFailure);
514 return res;
515 }
516
SkipCharFunction(napi_env env,std::string str,char expected)517 int XmlTest::SkipCharFunction(napi_env env, std::string str, char expected)
518 {
519 OHOS::xml::XmlPullParser xmlPullParser(env, str, "utf-8");
520 xmlPullParser.DealLength(666); // 666: minimum size
521 xmlPullParser.position_ = 666; // 666: position_ size
522 xmlPullParser.SkipChar(expected);
523 return xmlPullParser.PriorDealChar();
524 }
525 }
526 #endif // TEST_XML_H
527