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
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
|
/****************************************************************************
**
** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
** All rights reserved.
** Contact: Nokia Corporation (qt-info@nokia.com)
**
** This file is part of the test suite of the Qt Toolkit.
**
** $QT_BEGIN_LICENSE:LGPL$
** No Commercial Usage
** This file contains pre-release code and may not be distributed.
** You may use this file in accordance with the terms and conditions
** contained in the Technology Preview License Agreement accompanying
** this package.
**
** GNU Lesser General Public License Usage
** Alternatively, this file may be used under the terms of the GNU Lesser
** General Public License version 2.1 as published by the Free Software
** Foundation and appearing in the file LICENSE.LGPL included in the
** packaging of this file. Please review the following information to
** ensure the GNU Lesser General Public License version 2.1 requirements
** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
**
** In addition, as a special exception, Nokia gives you certain additional
** rights. These rights are described in the Nokia Qt LGPL Exception
** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
**
** If you have questions regarding the use of this file, please contact
** Nokia at qt-info@nokia.com.
**
**
**
**
**
**
**
**
** $QT_END_LICENSE$
**
****************************************************************************/
#ifndef PatternistSDK_TestBaseLine_H
#define PatternistSDK_TestBaseLine_H
#include <QString>
#include "Global.h"
#include "TestResult.h"
QT_BEGIN_HEADER
QT_BEGIN_NAMESPACE
class QDomNamedNodeMap;
class QDomNode;
class QDomNodeList;
template<typename T> class QList;
namespace QPatternistSDK
{
/**
* @short Represents an expected test result for a test case.
*
* TestBaseLine represents a valid outcome for a test case,
* the "base line". A XQTS test case can have many different valid
* base lines, and one TestBaseLine instance represents on of them.
*
* Of highest interest, TestBaseLine have the function scan() and
* scanErrors(), which allows serialized output to be
* compared to the base line.
*
* @ingroup PatternistSDK
* @author Frans Englich <frans.englich@nokia.com>
*/
class Q_PATTERNISTSDK_EXPORT TestBaseLine
{
public:
typedef QList<TestBaseLine *> List;
/**
* Identifies what kind of comparator to use. The documentation
* for each enumerator is copied from
* <a href="http://www.w3.org/XML/Query/test-suite/Guidelines
* for Running the XML Query Test Suite.html">Guidelines
* for Running the XML Query Test Suite</a>
*/
enum Type
{
/**
* The test harness must canonicalize both, the actual result
* and the expected result according to the "Canonical XML" recommendation [2],
* which refers to a number of open-source implementations. Byte-comparison can
* then be applied to the resulting XML documents. If the test harness does
* this process in a different manner, it must be documented.
*/
XML,
/**
* For XML fragments, the same root node must be created for both,
* implementation result and test suite result. The resulting XML
* can be compared using XML comparison.
*/
Fragment,
/**
* Text (that has been produced by XML serialization) is compared
* using byte-comparison.
*/
Text,
/**
* No comparison needs to be applied; the result is always @c true if
* the implementation successfully executes the test case.
*/
Ignore,
/**
* A human is required to make the call about correctness of the result
* according to the description in the test case.
*/
Inspect,
/**
* The expected result of the test case is an error, identified as an
* eight-character error code (e.g., XPST0003). The result of a test is
* @c true, if the implementation raises an error. However, raising an error
* because an implementation does not support the feature is not
* considered a correct result.
*/
ExpectedError,
/**
* A special comparison for the schema validation tests. The details
* can only be 'true' or 'false' depending on whether it is a valid
* schema or not.
*/
SchemaIsValid
};
/**
* Takes a string identifying a comparator either in the XSL-T or the
* XQuery test suite, and returns an enum value for it.
*
* If the value is unknown, the code asserts.
*/
static Type identifierFromString(const QString &string);
/**
* @returns a display name for @p id. For example, if Inspect was passed, "Inspect"
* would be returned.
*/
static QString displayName(const Type id);
/**
* Compares @p items(typically the result of an evaluation) against
* the base lines @p lines.
*
* @returns the status of the first base line which passes,
* otherwise TestResult::Fail.
*/
static TestResult::Status scan(const QString &serialized,
const TestBaseLine::List &lines);
static TestResult::Status scanErrors(const ErrorHandler::Message::List &errors,
const TestBaseLine::List &lines);
/**
* Constructs a TestBaseLine of type @p type.
*/
TestBaseLine(const Type type);
/**
* What @p details contains depends on the type(). If the type() is ExpectedError,
* @p details contains the relevant error code. If the type() is one which compares
* result against a base line, it is a filename locating the baseline.
*/
void setDetails(const QString &details);
Type type() const;
QString details() const;
void toXML(XMLWriter &receiver) const;
protected:
TestResult::Status verify(const QString &serializedInput) const;
private:
static bool isDeepEqual(const QDomNode &n1, const QDomNode &n2);
/**
* @returns @c true if the nodes in @p cl1 are equal to @p cl2, by calling isDeepEqual()
* for each pair.
*/
static bool isChildrenDeepEqual(const QDomNodeList &cl1, const QDomNodeList &cl2);
/**
* Considers @p cl1 and @p cl2 to be lists containing attributes. The list are equal
* if they contain attributes by same value and name, but regardless of order.
*/
static bool isAttributesEqual(const QDomNamedNodeMap &cl1, const QDomNamedNodeMap &cl2);
const Type m_type;
QString m_details;
};
}
QT_END_NAMESPACE
QT_END_HEADER
#endif
// vim: et:ts=4:sw=4:sts=4
|
