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