1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
|
/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/*
* This file is part of the LibreOffice project.
*
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/.
*/
#ifndef INCLUDED_TEST_XMLTESTTOOLS_HXX
#define INCLUDED_TEST_XMLTESTTOOLS_HXX
#include <sal/config.h>
#include <test/testdllapi.hxx>
#include <libxml/xmlwriter.h>
#include <libxml/tree.h>
#include <libxml/xpath.h>
#include <libxml/xpathInternals.h>
#include <libxml/parserInternals.h>
#include <rtl/string.hxx>
#include <rtl/ustring.hxx>
#include <unotools/tempfile.hxx>
#include <vcl/mtfxmldump.hxx>
#include <test/xmldocptr.hxx>
#include <cppunit/TestAssert.h>
#include <string_view>
#include <vector>
class OOO_DLLPUBLIC_TEST XmlTestTools
{
public:
/// Return xmlDocPtr representation of the XML stream read from pStream.
static xmlDocUniquePtr parseXmlStream(SvStream* pStream);
static xmlDocUniquePtr dumpAndParse(MetafileXmlDump& rDumper, const GDIMetaFile& rGDIMetaFile);
protected:
XmlTestTools();
virtual ~XmlTestTools();
static xmlDocUniquePtr parseXml(utl::TempFileNamed const & aTempFile);
virtual void registerNamespaces(xmlXPathContextPtr& pXmlXpathCtx);
// Caller must call xmlXPathFreeObject:
xmlXPathObjectPtr getXPathNode(const xmlDocUniquePtr& pXmlDoc, const char* pXPath);
/**
* Same as the assertXPath(), but don't assert: return the string instead.
*/
OUString getXPath(const xmlDocUniquePtr& pXmlDoc, const char* pXPath, const char* pAttribute);
OUString getXPath(const xmlDocUniquePtr& pXmlDoc, const OString& sXPath, const char* pAttribute)
{
return getXPath(pXmlDoc, sXPath.getStr(), pAttribute);
}
/**
* Same as the assertXPathContent(), but don't assert: return the string instead.
*/
OUString getXPathContent(const xmlDocUniquePtr& pXmlDoc, const char* pXPath);
OUString getXPathContent(const xmlDocUniquePtr& pXmlDoc, const OString& sXPath)
{
return getXPathContent(pXmlDoc, sXPath.getStr());
}
/**
* Get the position of the child named rName of the parent node specified by pXPath.
* Useful for checking relative order of elements.
*/
int getXPathPosition(const xmlDocUniquePtr& pXmlDoc, const char* pXPath, const char* pChildName);
/**
* Get the number of the nodes returned by the pXPath.
*/
int countXPathNodes(const xmlDocUniquePtr& pXmlDoc, const char* pXPath);
int countXPathNodes(const xmlDocUniquePtr& pXmlDoc, const OString& sXPath)
{
return countXPathNodes(pXmlDoc, sXPath.getStr());
}
/**
* Assert that pXPath exists, returns exactly one node, and the pXPath's attribute's value
* equals to the rExpected value.
*/
void assertXPath(const xmlDocUniquePtr& pXmlDoc, const char* pXPath, const char* pAttribute,
std::u16string_view rExpectedValue);
void assertXPath(const xmlDocUniquePtr& pXmlDoc, const OString& sXPath, const char* pAttribute,
std::u16string_view rExpectedValue)
{
assertXPath(pXmlDoc, sXPath.getStr(), pAttribute, rExpectedValue);
}
void assertXPathAttrs(const xmlDocUniquePtr& pXmlDoc, const char* pXPath,
const std::vector<std::pair<const char*, std::u16string_view>>& aPairVector);
void assertXPathAttrs(const xmlDocUniquePtr& pXmlDoc, const OString& sXPath,
const std::vector<std::pair<const char*, std::u16string_view>>& aPairVector)
{
assertXPathAttrs(pXmlDoc, sXPath.getStr(), aPairVector);
}
/**
* Given a double for the rExpected value, assert that pXPath exists, returns exactly one node,
* and the pXPath's attribute's value matches the rExpected value within tolerance provided
* by delta. This is used to account for HiDPI scaling.
*/
void assertXPathDoubleValue(const xmlDocUniquePtr& pXmlDoc, const char* pXPath, const char* pAttribute,
double expectedValue, double delta);
/**
* Assert that pXPath exists, and returns exactly nNumberOfNodes nodes (1 by default).
* Also useful for checking that we do _not_ export some node (nNumberOfNodes == 0).
*/
void assertXPath(const xmlDocUniquePtr& pXmlDoc, const char* pXPath, int nNumberOfNodes = 1);
void assertXPath(const xmlDocUniquePtr& pXmlDoc, const OString& sXPath, int nNumberOfNodes = 1)
{
assertXPath(pXmlDoc, sXPath.getStr(), nNumberOfNodes);
}
/**
* Assert that pXPath exists, and its content equals rContent.
*/
void assertXPathContent(const xmlDocUniquePtr& pXmlDoc, const char* pXPath, std::u16string_view rContent);
void assertXPathContent(const xmlDocUniquePtr& pXmlDoc, const OString& sXPath,
std::u16string_view rContent)
{
assertXPathContent(pXmlDoc, sXPath.getStr(), rContent);
}
/**
* Assert that pXPath exists and it has an rNSPrefix=rNSHref namespace definition.
*/
void assertXPathNSDef(const xmlDocUniquePtr& pXmlDoc, const char* pXPath, std::string_view rNSPrefix,
std::string_view rNSHref);
/**
* Assert that pXPath exists, and has exactly nNumberOfChildNodes child nodes.
* Useful for checking that we do have a no child nodes to a specific node (nNumberOfChildNodes == 0).
*/
void assertXPathChildren(const xmlDocUniquePtr& pXmlDoc, const char* pXPath, int nNumberOfChildNodes);
void assertXPathChildren(const xmlDocUniquePtr& pXmlDoc, const OString& sXPath,
int nNumberOfChildNodes)
{
assertXPathChildren(pXmlDoc, sXPath.getStr(), nNumberOfChildNodes);
}
/**
* Assert that pXPath exists, has exactly 1 result set nodes and does *not* have an attribute named pAttribute.
*/
void assertXPathNoAttribute(const xmlDocUniquePtr& pXmlDoc, const char* pXPath, const char* pAttribute);
void assertXPathNoAttribute(const xmlDocUniquePtr& pXmlDoc, const OString& sXPath,
const char* pAttribute)
{
assertXPathNoAttribute(pXmlDoc, sXPath.getStr(), pAttribute);
}
/**
* Same as the assertXPathNoAttribute(), but don't assert: return the bool instead.
*/
bool hasXPathAttribute(const xmlDocUniquePtr& pXmlDoc, const char* pXPath, const char* pAttribute);
// Assert that the node name of the single node returned by an XPath is as specified,
// e.g. to check order of elements, where getXPathPosition is unapplicable
void assertXPathNodeName(const xmlDocUniquePtr& pXmlDoc, const char* pXPath, std::string_view rExpectedName);
static void registerODFNamespaces(xmlXPathContextPtr& pXmlXpathCtx);
static void registerOOXMLNamespaces(xmlXPathContextPtr& pXmlXpathCtx);
};
#endif
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
