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
21namespace OHOS::xml {
22class XmlTest {
23public:
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
75XmlSerializer 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
85void XmlTest::SetDeclaration(napi_env env)
86{
87    XmlSerializer xmlSerializer = construct(env);
88    xmlSerializer.isHasDecl = true;
89    xmlSerializer.SetDeclaration();
90}
91
92void 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
103void 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
114void XmlTest::WriteEscaped(napi_env env)
115{
116    XmlSerializer xmlSerializer = construct(env);
117    xmlSerializer.WriteEscaped("'\"&><q");
118}
119
120void XmlTest::XmlSerializerError(napi_env env)
121{
122    XmlSerializer xmlSerializer = construct(env);
123    xmlSerializer.XmlSerializerError();
124}
125
126void 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
133size_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
142std::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
150TagEnum 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
158TagEnum 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
166TagEnum 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
177std::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
184int 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
192int 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
200std::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
207bool 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
220void 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
231std::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
242bool 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
255bool 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
263TagEnum 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
271void XmlTest::TestParseEntityDecl(napi_env env)
272{
273    OHOS::xml::XmlPullParser xml(env, "%1234", "utf8");
274    xml.ParseEntityDecl();
275}
276
277std::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
287std::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
298bool 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
310std::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
322size_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
333std::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
343std::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
359std::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
380std::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
400bool 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
412bool 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
421bool 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
429std::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
439int XmlTest::SplicNspFunction(napi_env env, std::string pushStr)
440{
441    XmlSerializer xmlSerializer = construct(env);
442    xmlSerializer.type = pushStr;
443    return xmlSerializer.curNspNum;
444}
445
446std::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
457std::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
465bool 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
478bool 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
491bool 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
498std::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
507TagEnum 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
517int 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_Hs
527