leptris 1.9.231.1-arm-linux → 1.9.232.0-arm-linux
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- checksums.yaml +4 -4
- data/CHANGELOG.md +19 -0
- data/Rakefile +1 -1
- data/ext/leptris/native/native.c +35 -4
- data/lib/leptris/version.rb +1 -1
- data/lib/leptris/xml/ffi.rb +4 -0
- data/lib/leptris/xml/native.so +0 -0
- data/lib/leptris/xml/node.rb +28 -0
- data/lib/libleptris.so +0 -0
- data/vendor-src/README.md +1 -1
- data/vendor-src/libleptris/CHANGELOG.md +15 -0
- data/vendor-src/libleptris/CMakeLists.txt +1 -1
- data/vendor-src/libleptris/src/include/leptris/descriptor.h +5 -1
- data/vendor-src/libleptris/src/include/leptris.h +17 -0
- data/vendor-src/libleptris/src/leptris/descriptor/plan.c +26 -6
- data/vendor-src/libleptris/src/leptris/dom/node.c +24 -7
- data/vendor-src/libleptris/src/leptris/xpath/evaluator_operators.c +22 -8
- data/vendor-src/libleptris/src/leptris/xpath/functions.c +29 -8
- data/vendor-src/libleptris/src/leptris/xpath/functions_ext31.c +30 -1
- data/vendor-src/libleptris/src/leptris/xpath/parser.c +106 -6
- data/vendor-src/libleptris/test/abi/test_descriptor.cpp +68 -0
- data/vendor-src/libleptris/test/dom/test_dom.cpp +56 -0
- data/vendor-src/libleptris/test/xquery/qt3/fn/codepoints-to-string.xml +808 -0
- data/vendor-src/libleptris/test/xquery/qt3/fn/deep-equal.xml +2709 -0
- data/vendor-src/libleptris/test/xquery/qt3/fn/distinct-values.xml +1223 -0
- data/vendor-src/libleptris/test/xquery/qt3/fn/index-of.xml +493 -0
- data/vendor-src/libleptris/test/xquery/qt3/fn/insert-before.xml +399 -0
- data/vendor-src/libleptris/test/xquery/qt3/fn/remove.xml +480 -0
- data/vendor-src/libleptris/test/xquery/qt3/fn/reverse.xml +653 -0
- data/vendor-src/libleptris/test/xquery/qt3/fn/string-to-codepoints.xml +452 -0
- data/vendor-src/libleptris/test/xquery/qt3/fn/subsequence.xml +1041 -0
- data/vendor-src/libleptris/test/xquery/test_qt3.cpp +179 -1
- data/vendor-src/libleptris/test/xquery/test_xquery.cpp +27 -0
- data/vendor-src/libleptris/vcpkg.json +1 -1
- metadata +11 -2
|
@@ -0,0 +1,2709 @@
|
|
|
1
|
+
<?xml version="1.0" encoding="us-ascii"?>
|
|
2
|
+
<test-set xmlns="http://www.w3.org/2010/09/qt-fots-catalog" name="fn-deep-equal">
|
|
3
|
+
<description>Tests for the deep-equal() function</description>
|
|
4
|
+
<link type="spec" document="http://www.w3.org/TR/xpath-functions-30/"
|
|
5
|
+
idref="func-deep-equal"/>
|
|
6
|
+
|
|
7
|
+
<environment name="bib">
|
|
8
|
+
<source role="." file="../docs/bib.xml">
|
|
9
|
+
<description>Data for the the XML Query XMP use cases</description>
|
|
10
|
+
<created by="XQuery WG" on="2005-02-11"/>
|
|
11
|
+
</source>
|
|
12
|
+
</environment>
|
|
13
|
+
|
|
14
|
+
<environment name="perverse">
|
|
15
|
+
<schema uri="http://www.w3.org/XQueryTest/perversity" file="deep-equal/perverse.xsd">
|
|
16
|
+
<description>A Schema having mixed, elementOnly, and empty elements with the same name</description>
|
|
17
|
+
<created by="Michael Kay" on="2012-05-30"/>
|
|
18
|
+
</schema>
|
|
19
|
+
</environment>
|
|
20
|
+
|
|
21
|
+
|
|
22
|
+
<test-case name="fn-deep-equalint2args-1">
|
|
23
|
+
<description> Evaluates The "deep-equal" function with the arguments set as follows: $parameter1 = xs:int(lower bound) $parameter2 = xs:int(lower bound) </description>
|
|
24
|
+
<created by="Carmelo Montanez" on="2004-12-13"/>
|
|
25
|
+
<test>fn:deep-equal((xs:int("-2147483648")),(xs:int("-2147483648")))</test>
|
|
26
|
+
<result>
|
|
27
|
+
<assert-true/>
|
|
28
|
+
</result>
|
|
29
|
+
</test-case>
|
|
30
|
+
|
|
31
|
+
<test-case name="fn-deep-equalint2args-2">
|
|
32
|
+
<description> Evaluates The "deep-equal" function with the arguments set as follows: $parameter1 = xs:int(mid range) $parameter2 = xs:int(lower bound) </description>
|
|
33
|
+
<created by="Carmelo Montanez" on="2004-12-13"/>
|
|
34
|
+
<test>fn:deep-equal((xs:int("-1873914410")),(xs:int("-2147483648")))</test>
|
|
35
|
+
<result>
|
|
36
|
+
<assert-false/>
|
|
37
|
+
</result>
|
|
38
|
+
</test-case>
|
|
39
|
+
|
|
40
|
+
<test-case name="fn-deep-equalint2args-3">
|
|
41
|
+
<description> Evaluates The "deep-equal" function with the arguments set as follows: $parameter1 = xs:int(upper bound) $parameter2 = xs:int(lower bound) </description>
|
|
42
|
+
<created by="Carmelo Montanez" on="2004-12-13"/>
|
|
43
|
+
<test>fn:deep-equal((xs:int("2147483647")),(xs:int("-2147483648")))</test>
|
|
44
|
+
<result>
|
|
45
|
+
<assert-false/>
|
|
46
|
+
</result>
|
|
47
|
+
</test-case>
|
|
48
|
+
|
|
49
|
+
<test-case name="fn-deep-equalint2args-4">
|
|
50
|
+
<description> Evaluates The "deep-equal" function with the arguments set as follows: $parameter1 = xs:int(lower bound) $parameter2 = xs:int(mid range) </description>
|
|
51
|
+
<created by="Carmelo Montanez" on="2004-12-13"/>
|
|
52
|
+
<test>fn:deep-equal((xs:int("-2147483648")),(xs:int("-1873914410")))</test>
|
|
53
|
+
<result>
|
|
54
|
+
<assert-false/>
|
|
55
|
+
</result>
|
|
56
|
+
</test-case>
|
|
57
|
+
|
|
58
|
+
<test-case name="fn-deep-equalint2args-5">
|
|
59
|
+
<description> Evaluates The "deep-equal" function with the arguments set as follows: $parameter1 = xs:int(lower bound) $parameter2 = xs:int(upper bound) </description>
|
|
60
|
+
<created by="Carmelo Montanez" on="2004-12-13"/>
|
|
61
|
+
<test>fn:deep-equal((xs:int("-2147483648")),(xs:int("2147483647")))</test>
|
|
62
|
+
<result>
|
|
63
|
+
<assert-false/>
|
|
64
|
+
</result>
|
|
65
|
+
</test-case>
|
|
66
|
+
|
|
67
|
+
<test-case name="fn-deep-equalintg2args-1">
|
|
68
|
+
<description> Evaluates The "deep-equal" function with the arguments set as follows: $parameter1 = xs:integer(lower bound) $parameter2 = xs:integer(lower bound) </description>
|
|
69
|
+
<created by="Carmelo Montanez" on="2004-12-13"/>
|
|
70
|
+
<test>fn:deep-equal((xs:integer("-999999999999999999")),(xs:integer("-999999999999999999")))</test>
|
|
71
|
+
<result>
|
|
72
|
+
<assert-true/>
|
|
73
|
+
</result>
|
|
74
|
+
</test-case>
|
|
75
|
+
|
|
76
|
+
<test-case name="fn-deep-equalintg2args-2">
|
|
77
|
+
<description> Evaluates The "deep-equal" function with the arguments set as follows: $parameter1 = xs:integer(mid range) $parameter2 = xs:integer(lower bound) </description>
|
|
78
|
+
<created by="Carmelo Montanez" on="2004-12-13"/>
|
|
79
|
+
<test>fn:deep-equal((xs:integer("830993497117024304")),(xs:integer("-999999999999999999")))</test>
|
|
80
|
+
<result>
|
|
81
|
+
<assert-false/>
|
|
82
|
+
</result>
|
|
83
|
+
</test-case>
|
|
84
|
+
|
|
85
|
+
<test-case name="fn-deep-equalintg2args-3">
|
|
86
|
+
<description> Evaluates The "deep-equal" function with the arguments set as follows: $parameter1 = xs:integer(upper bound) $parameter2 = xs:integer(lower bound) </description>
|
|
87
|
+
<created by="Carmelo Montanez" on="2004-12-13"/>
|
|
88
|
+
<test>fn:deep-equal((xs:integer("999999999999999999")),(xs:integer("-999999999999999999")))</test>
|
|
89
|
+
<result>
|
|
90
|
+
<assert-false/>
|
|
91
|
+
</result>
|
|
92
|
+
</test-case>
|
|
93
|
+
|
|
94
|
+
<test-case name="fn-deep-equalintg2args-4">
|
|
95
|
+
<description> Evaluates The "deep-equal" function with the arguments set as follows: $parameter1 = xs:integer(lower bound) $parameter2 = xs:integer(mid range) </description>
|
|
96
|
+
<created by="Carmelo Montanez" on="2004-12-13"/>
|
|
97
|
+
<test>fn:deep-equal((xs:integer("-999999999999999999")),(xs:integer("830993497117024304")))</test>
|
|
98
|
+
<result>
|
|
99
|
+
<assert-false/>
|
|
100
|
+
</result>
|
|
101
|
+
</test-case>
|
|
102
|
+
|
|
103
|
+
<test-case name="fn-deep-equalintg2args-5">
|
|
104
|
+
<description> Evaluates The "deep-equal" function with the arguments set as follows: $parameter1 = xs:integer(lower bound) $parameter2 = xs:integer(upper bound) </description>
|
|
105
|
+
<created by="Carmelo Montanez" on="2004-12-13"/>
|
|
106
|
+
<test>fn:deep-equal((xs:integer("-999999999999999999")),(xs:integer("999999999999999999")))</test>
|
|
107
|
+
<result>
|
|
108
|
+
<assert-false/>
|
|
109
|
+
</result>
|
|
110
|
+
</test-case>
|
|
111
|
+
|
|
112
|
+
<test-case name="fn-deep-equaldec2args-1">
|
|
113
|
+
<description> Evaluates The "deep-equal" function with the arguments set as follows: $parameter1 = xs:decimal(lower bound) $parameter2 = xs:decimal(lower bound) </description>
|
|
114
|
+
<created by="Carmelo Montanez" on="2004-12-13"/>
|
|
115
|
+
<test>fn:deep-equal((xs:decimal("-999999999999999999")),(xs:decimal("-999999999999999999")))</test>
|
|
116
|
+
<result>
|
|
117
|
+
<assert-true/>
|
|
118
|
+
</result>
|
|
119
|
+
</test-case>
|
|
120
|
+
|
|
121
|
+
<test-case name="fn-deep-equaldec2args-2">
|
|
122
|
+
<description> Evaluates The "deep-equal" function with the arguments set as follows: $parameter1 = xs:decimal(mid range) $parameter2 = xs:decimal(lower bound) </description>
|
|
123
|
+
<created by="Carmelo Montanez" on="2004-12-13"/>
|
|
124
|
+
<test>fn:deep-equal((xs:decimal("617375191608514839")),(xs:decimal("-999999999999999999")))</test>
|
|
125
|
+
<result>
|
|
126
|
+
<assert-false/>
|
|
127
|
+
</result>
|
|
128
|
+
</test-case>
|
|
129
|
+
|
|
130
|
+
<test-case name="fn-deep-equaldec2args-3">
|
|
131
|
+
<description> Evaluates The "deep-equal" function with the arguments set as follows: $parameter1 = xs:decimal(upper bound) $parameter2 = xs:decimal(lower bound) </description>
|
|
132
|
+
<created by="Carmelo Montanez" on="2004-12-13"/>
|
|
133
|
+
<test>fn:deep-equal((xs:decimal("999999999999999999")),(xs:decimal("-999999999999999999")))</test>
|
|
134
|
+
<result>
|
|
135
|
+
<assert-false/>
|
|
136
|
+
</result>
|
|
137
|
+
</test-case>
|
|
138
|
+
|
|
139
|
+
<test-case name="fn-deep-equaldec2args-4">
|
|
140
|
+
<description> Evaluates The "deep-equal" function with the arguments set as follows: $parameter1 = xs:decimal(lower bound) $parameter2 = xs:decimal(mid range) </description>
|
|
141
|
+
<created by="Carmelo Montanez" on="2004-12-13"/>
|
|
142
|
+
<test>fn:deep-equal((xs:decimal("-999999999999999999")),(xs:decimal("617375191608514839")))</test>
|
|
143
|
+
<result>
|
|
144
|
+
<assert-false/>
|
|
145
|
+
</result>
|
|
146
|
+
</test-case>
|
|
147
|
+
|
|
148
|
+
<test-case name="fn-deep-equaldec2args-5">
|
|
149
|
+
<description> Evaluates The "deep-equal" function with the arguments set as follows: $parameter1 = xs:decimal(lower bound) $parameter2 = xs:decimal(upper bound) </description>
|
|
150
|
+
<created by="Carmelo Montanez" on="2004-12-13"/>
|
|
151
|
+
<test>fn:deep-equal((xs:decimal("-999999999999999999")),(xs:decimal("999999999999999999")))</test>
|
|
152
|
+
<result>
|
|
153
|
+
<assert-false/>
|
|
154
|
+
</result>
|
|
155
|
+
</test-case>
|
|
156
|
+
|
|
157
|
+
<test-case name="fn-deep-equaldbl2args-1">
|
|
158
|
+
<description> Evaluates The "deep-equal" function with the arguments set as follows: $parameter1 = xs:double(lower bound) $parameter2 = xs:double(lower bound) </description>
|
|
159
|
+
<created by="Carmelo Montanez" on="2004-12-13"/>
|
|
160
|
+
<test>fn:deep-equal((xs:double("-1.7976931348623157E308")),(xs:double("-1.7976931348623157E308")))</test>
|
|
161
|
+
<result>
|
|
162
|
+
<assert-true/>
|
|
163
|
+
</result>
|
|
164
|
+
</test-case>
|
|
165
|
+
|
|
166
|
+
<test-case name="fn-deep-equaldbl2args-2">
|
|
167
|
+
<description> Evaluates The "deep-equal" function with the arguments set as follows: $parameter1 = xs:double(mid range) $parameter2 = xs:double(lower bound) </description>
|
|
168
|
+
<created by="Carmelo Montanez" on="2004-12-13"/>
|
|
169
|
+
<test>fn:deep-equal((xs:double("0")),(xs:double("-1.7976931348623157E308")))</test>
|
|
170
|
+
<result>
|
|
171
|
+
<assert-false/>
|
|
172
|
+
</result>
|
|
173
|
+
</test-case>
|
|
174
|
+
|
|
175
|
+
<test-case name="fn-deep-equaldbl2args-3">
|
|
176
|
+
<description> Evaluates The "deep-equal" function with the arguments set as follows: $parameter1 = xs:double(upper bound) $parameter2 = xs:double(lower bound) </description>
|
|
177
|
+
<created by="Carmelo Montanez" on="2004-12-13"/>
|
|
178
|
+
<test>fn:deep-equal((xs:double("1.7976931348623157E308")),(xs:double("-1.7976931348623157E308")))</test>
|
|
179
|
+
<result>
|
|
180
|
+
<assert-false/>
|
|
181
|
+
</result>
|
|
182
|
+
</test-case>
|
|
183
|
+
|
|
184
|
+
<test-case name="fn-deep-equaldbl2args-4">
|
|
185
|
+
<description> Evaluates The "deep-equal" function with the arguments set as follows: $parameter1 = xs:double(lower bound) $parameter2 = xs:double(mid range) </description>
|
|
186
|
+
<created by="Carmelo Montanez" on="2004-12-13"/>
|
|
187
|
+
<test>fn:deep-equal((xs:double("-1.7976931348623157E308")),(xs:double("0")))</test>
|
|
188
|
+
<result>
|
|
189
|
+
<assert-false/>
|
|
190
|
+
</result>
|
|
191
|
+
</test-case>
|
|
192
|
+
|
|
193
|
+
<test-case name="fn-deep-equaldbl2args-5">
|
|
194
|
+
<description> Evaluates The "deep-equal" function with the arguments set as follows: $parameter1 = xs:double(lower bound) $parameter2 = xs:double(upper bound) </description>
|
|
195
|
+
<created by="Carmelo Montanez" on="2004-12-13"/>
|
|
196
|
+
<test>fn:deep-equal((xs:double("-1.7976931348623157E308")),(xs:double("1.7976931348623157E308")))</test>
|
|
197
|
+
<result>
|
|
198
|
+
<assert-false/>
|
|
199
|
+
</result>
|
|
200
|
+
</test-case>
|
|
201
|
+
|
|
202
|
+
<test-case name="fn-deep-equalflt2args-1">
|
|
203
|
+
<description> Evaluates The "deep-equal" function with the arguments set as follows: $parameter1 = xs:float(lower bound) $parameter2 = xs:float(lower bound) </description>
|
|
204
|
+
<created by="Carmelo Montanez" on="2004-12-13"/>
|
|
205
|
+
<test>fn:deep-equal((xs:float("-3.4028235E38")),(xs:float("-3.4028235E38")))</test>
|
|
206
|
+
<result>
|
|
207
|
+
<assert-true/>
|
|
208
|
+
</result>
|
|
209
|
+
</test-case>
|
|
210
|
+
|
|
211
|
+
<test-case name="fn-deep-equalflt2args-2">
|
|
212
|
+
<description> Evaluates The "deep-equal" function with the arguments set as follows: $parameter1 = xs:float(mid range) $parameter2 = xs:float(lower bound) </description>
|
|
213
|
+
<created by="Carmelo Montanez" on="2004-12-13"/>
|
|
214
|
+
<test>fn:deep-equal((xs:float("0")),(xs:float("-3.4028235E38")))</test>
|
|
215
|
+
<result>
|
|
216
|
+
<assert-false/>
|
|
217
|
+
</result>
|
|
218
|
+
</test-case>
|
|
219
|
+
|
|
220
|
+
<test-case name="fn-deep-equalflt2args-3">
|
|
221
|
+
<description> Evaluates The "deep-equal" function with the arguments set as follows: $parameter1 = xs:float(upper bound) $parameter2 = xs:float(lower bound) </description>
|
|
222
|
+
<created by="Carmelo Montanez" on="2004-12-13"/>
|
|
223
|
+
<test>fn:deep-equal((xs:float("3.4028235E38")),(xs:float("-3.4028235E38")))</test>
|
|
224
|
+
<result>
|
|
225
|
+
<assert-false/>
|
|
226
|
+
</result>
|
|
227
|
+
</test-case>
|
|
228
|
+
|
|
229
|
+
<test-case name="fn-deep-equalflt2args-4">
|
|
230
|
+
<description> Evaluates The "deep-equal" function with the arguments set as follows: $parameter1 = xs:float(lower bound) $parameter2 = xs:float(mid range) </description>
|
|
231
|
+
<created by="Carmelo Montanez" on="2004-12-13"/>
|
|
232
|
+
<test>fn:deep-equal((xs:float("-3.4028235E38")),(xs:float("0")))</test>
|
|
233
|
+
<result>
|
|
234
|
+
<assert-false/>
|
|
235
|
+
</result>
|
|
236
|
+
</test-case>
|
|
237
|
+
|
|
238
|
+
<test-case name="fn-deep-equalflt2args-5">
|
|
239
|
+
<description> Evaluates The "deep-equal" function with the arguments set as follows: $parameter1 = xs:float(lower bound) $parameter2 = xs:float(upper bound) </description>
|
|
240
|
+
<created by="Carmelo Montanez" on="2004-12-13"/>
|
|
241
|
+
<test>fn:deep-equal((xs:float("-3.4028235E38")),(xs:float("3.4028235E38")))</test>
|
|
242
|
+
<result>
|
|
243
|
+
<assert-false/>
|
|
244
|
+
</result>
|
|
245
|
+
</test-case>
|
|
246
|
+
|
|
247
|
+
<test-case name="fn-deep-equallng2args-1">
|
|
248
|
+
<description> Evaluates The "deep-equal" function with the arguments set as follows: $parameter1 = xs:long(lower bound) $parameter2 = xs:long(lower bound) </description>
|
|
249
|
+
<created by="Carmelo Montanez" on="2004-12-13"/>
|
|
250
|
+
<test>fn:deep-equal((xs:long("-92233720368547758")),(xs:long("-92233720368547758")))</test>
|
|
251
|
+
<result>
|
|
252
|
+
<assert-true/>
|
|
253
|
+
</result>
|
|
254
|
+
</test-case>
|
|
255
|
+
|
|
256
|
+
<test-case name="fn-deep-equallng2args-2">
|
|
257
|
+
<description> Evaluates The "deep-equal" function with the arguments set as follows: $parameter1 = xs:long(mid range) $parameter2 = xs:long(lower bound) </description>
|
|
258
|
+
<created by="Carmelo Montanez" on="2004-12-13"/>
|
|
259
|
+
<test>fn:deep-equal((xs:long("-47175562203048468")),(xs:long("-92233720368547758")))</test>
|
|
260
|
+
<result>
|
|
261
|
+
<assert-false/>
|
|
262
|
+
</result>
|
|
263
|
+
</test-case>
|
|
264
|
+
|
|
265
|
+
<test-case name="fn-deep-equallng2args-3">
|
|
266
|
+
<description> Evaluates The "deep-equal" function with the arguments set as follows: $parameter1 = xs:long(upper bound) $parameter2 = xs:long(lower bound) </description>
|
|
267
|
+
<created by="Carmelo Montanez" on="2004-12-13"/>
|
|
268
|
+
<test>fn:deep-equal((xs:long("92233720368547758")),(xs:long("-92233720368547758")))</test>
|
|
269
|
+
<result>
|
|
270
|
+
<assert-false/>
|
|
271
|
+
</result>
|
|
272
|
+
</test-case>
|
|
273
|
+
|
|
274
|
+
<test-case name="fn-deep-equallng2args-4">
|
|
275
|
+
<description> Evaluates The "deep-equal" function with the arguments set as follows: $parameter1 = xs:long(lower bound) $parameter2 = xs:long(mid range) </description>
|
|
276
|
+
<created by="Carmelo Montanez" on="2004-12-13"/>
|
|
277
|
+
<test>fn:deep-equal((xs:long("-92233720368547758")),(xs:long("-47175562203048468")))</test>
|
|
278
|
+
<result>
|
|
279
|
+
<assert-false/>
|
|
280
|
+
</result>
|
|
281
|
+
</test-case>
|
|
282
|
+
|
|
283
|
+
<test-case name="fn-deep-equallng2args-5">
|
|
284
|
+
<description> Evaluates The "deep-equal" function with the arguments set as follows: $parameter1 = xs:long(lower bound) $parameter2 = xs:long(upper bound) </description>
|
|
285
|
+
<created by="Carmelo Montanez" on="2004-12-13"/>
|
|
286
|
+
<test>fn:deep-equal((xs:long("-92233720368547758")),(xs:long("92233720368547758")))</test>
|
|
287
|
+
<result>
|
|
288
|
+
<assert-false/>
|
|
289
|
+
</result>
|
|
290
|
+
</test-case>
|
|
291
|
+
|
|
292
|
+
<test-case name="fn-deep-equalusht2args-1">
|
|
293
|
+
<description> Evaluates The "deep-equal" function with the arguments set as follows: $parameter1 = xs:unsignedShort(lower bound) $parameter2 = xs:unsignedShort(lower bound) </description>
|
|
294
|
+
<created by="Carmelo Montanez" on="2004-12-13"/>
|
|
295
|
+
<test>fn:deep-equal((xs:unsignedShort("0")),(xs:unsignedShort("0")))</test>
|
|
296
|
+
<result>
|
|
297
|
+
<assert-true/>
|
|
298
|
+
</result>
|
|
299
|
+
</test-case>
|
|
300
|
+
|
|
301
|
+
<test-case name="fn-deep-equalusht2args-2">
|
|
302
|
+
<description> Evaluates The "deep-equal" function with the arguments set as follows: $parameter1 = xs:unsignedShort(mid range) $parameter2 = xs:unsignedShort(lower bound) </description>
|
|
303
|
+
<created by="Carmelo Montanez" on="2004-12-13"/>
|
|
304
|
+
<test>fn:deep-equal((xs:unsignedShort("44633")),(xs:unsignedShort("0")))</test>
|
|
305
|
+
<result>
|
|
306
|
+
<assert-false/>
|
|
307
|
+
</result>
|
|
308
|
+
</test-case>
|
|
309
|
+
|
|
310
|
+
<test-case name="fn-deep-equalusht2args-3">
|
|
311
|
+
<description> Evaluates The "deep-equal" function with the arguments set as follows: $parameter1 = xs:unsignedShort(upper bound) $parameter2 = xs:unsignedShort(lower bound) </description>
|
|
312
|
+
<created by="Carmelo Montanez" on="2004-12-13"/>
|
|
313
|
+
<test>fn:deep-equal((xs:unsignedShort("65535")),(xs:unsignedShort("0")))</test>
|
|
314
|
+
<result>
|
|
315
|
+
<assert-false/>
|
|
316
|
+
</result>
|
|
317
|
+
</test-case>
|
|
318
|
+
|
|
319
|
+
<test-case name="fn-deep-equalusht2args-4">
|
|
320
|
+
<description> Evaluates The "deep-equal" function with the arguments set as follows: $parameter1 = xs:unsignedShort(lower bound) $parameter2 = xs:unsignedShort(mid range) </description>
|
|
321
|
+
<created by="Carmelo Montanez" on="2004-12-13"/>
|
|
322
|
+
<test>fn:deep-equal((xs:unsignedShort("0")),(xs:unsignedShort("44633")))</test>
|
|
323
|
+
<result>
|
|
324
|
+
<assert-false/>
|
|
325
|
+
</result>
|
|
326
|
+
</test-case>
|
|
327
|
+
|
|
328
|
+
<test-case name="fn-deep-equalusht2args-5">
|
|
329
|
+
<description> Evaluates The "deep-equal" function with the arguments set as follows: $parameter1 = xs:unsignedShort(lower bound) $parameter2 = xs:unsignedShort(upper bound) </description>
|
|
330
|
+
<created by="Carmelo Montanez" on="2004-12-13"/>
|
|
331
|
+
<test>fn:deep-equal((xs:unsignedShort("0")),(xs:unsignedShort("65535")))</test>
|
|
332
|
+
<result>
|
|
333
|
+
<assert-false/>
|
|
334
|
+
</result>
|
|
335
|
+
</test-case>
|
|
336
|
+
|
|
337
|
+
<test-case name="fn-deep-equalnint2args-1">
|
|
338
|
+
<description> Evaluates The "deep-equal" function with the arguments set as follows: $parameter1 = xs:negativeInteger(lower bound) $parameter2 = xs:negativeInteger(lower bound) </description>
|
|
339
|
+
<created by="Carmelo Montanez" on="2004-12-13"/>
|
|
340
|
+
<test>fn:deep-equal((xs:negativeInteger("-999999999999999999")),(xs:negativeInteger("-999999999999999999")))</test>
|
|
341
|
+
<result>
|
|
342
|
+
<assert-true/>
|
|
343
|
+
</result>
|
|
344
|
+
</test-case>
|
|
345
|
+
|
|
346
|
+
<test-case name="fn-deep-equalnint2args-2">
|
|
347
|
+
<description> Evaluates The "deep-equal" function with the arguments set as follows: $parameter1 = xs:negativeInteger(mid range) $parameter2 = xs:negativeInteger(lower bound) </description>
|
|
348
|
+
<created by="Carmelo Montanez" on="2004-12-13"/>
|
|
349
|
+
<test>fn:deep-equal((xs:negativeInteger("-297014075999096793")),(xs:negativeInteger("-999999999999999999")))</test>
|
|
350
|
+
<result>
|
|
351
|
+
<assert-false/>
|
|
352
|
+
</result>
|
|
353
|
+
</test-case>
|
|
354
|
+
|
|
355
|
+
<test-case name="fn-deep-equalnint2args-3">
|
|
356
|
+
<description> Evaluates The "deep-equal" function with the arguments set as follows: $parameter1 = xs:negativeInteger(upper bound) $parameter2 = xs:negativeInteger(lower bound) </description>
|
|
357
|
+
<created by="Carmelo Montanez" on="2004-12-13"/>
|
|
358
|
+
<test>fn:deep-equal((xs:negativeInteger("-1")),(xs:negativeInteger("-999999999999999999")))</test>
|
|
359
|
+
<result>
|
|
360
|
+
<assert-false/>
|
|
361
|
+
</result>
|
|
362
|
+
</test-case>
|
|
363
|
+
|
|
364
|
+
<test-case name="fn-deep-equalnint2args-4">
|
|
365
|
+
<description> Evaluates The "deep-equal" function with the arguments set as follows: $parameter1 = xs:negativeInteger(lower bound) $parameter2 = xs:negativeInteger(mid range) </description>
|
|
366
|
+
<created by="Carmelo Montanez" on="2004-12-13"/>
|
|
367
|
+
<test>fn:deep-equal((xs:negativeInteger("-999999999999999999")),(xs:negativeInteger("-297014075999096793")))</test>
|
|
368
|
+
<result>
|
|
369
|
+
<assert-false/>
|
|
370
|
+
</result>
|
|
371
|
+
</test-case>
|
|
372
|
+
|
|
373
|
+
<test-case name="fn-deep-equalnint2args-5">
|
|
374
|
+
<description> Evaluates The "deep-equal" function with the arguments set as follows: $parameter1 = xs:negativeInteger(lower bound) $parameter2 = xs:negativeInteger(upper bound) </description>
|
|
375
|
+
<created by="Carmelo Montanez" on="2004-12-13"/>
|
|
376
|
+
<test>fn:deep-equal((xs:negativeInteger("-999999999999999999")),(xs:negativeInteger("-1")))</test>
|
|
377
|
+
<result>
|
|
378
|
+
<assert-false/>
|
|
379
|
+
</result>
|
|
380
|
+
</test-case>
|
|
381
|
+
|
|
382
|
+
<test-case name="fn-deep-equalpint2args-1">
|
|
383
|
+
<description> Evaluates The "deep-equal" function with the arguments set as follows: $parameter1 = xs:positiveInteger(lower bound) $parameter2 = xs:positiveInteger(lower bound) </description>
|
|
384
|
+
<created by="Carmelo Montanez" on="2004-12-13"/>
|
|
385
|
+
<test>fn:deep-equal((xs:positiveInteger("1")),(xs:positiveInteger("1")))</test>
|
|
386
|
+
<result>
|
|
387
|
+
<assert-true/>
|
|
388
|
+
</result>
|
|
389
|
+
</test-case>
|
|
390
|
+
|
|
391
|
+
<test-case name="fn-deep-equalpint2args-2">
|
|
392
|
+
<description> Evaluates The "deep-equal" function with the arguments set as follows: $parameter1 = xs:positiveInteger(mid range) $parameter2 = xs:positiveInteger(lower bound) </description>
|
|
393
|
+
<created by="Carmelo Montanez" on="2004-12-13"/>
|
|
394
|
+
<test>fn:deep-equal((xs:positiveInteger("52704602390610033")),(xs:positiveInteger("1")))</test>
|
|
395
|
+
<result>
|
|
396
|
+
<assert-false/>
|
|
397
|
+
</result>
|
|
398
|
+
</test-case>
|
|
399
|
+
|
|
400
|
+
<test-case name="fn-deep-equalpint2args-3">
|
|
401
|
+
<description> Evaluates The "deep-equal" function with the arguments set as follows: $parameter1 = xs:positiveInteger(upper bound) $parameter2 = xs:positiveInteger(lower bound) </description>
|
|
402
|
+
<created by="Carmelo Montanez" on="2004-12-13"/>
|
|
403
|
+
<test>fn:deep-equal((xs:positiveInteger("999999999999999999")),(xs:positiveInteger("1")))</test>
|
|
404
|
+
<result>
|
|
405
|
+
<assert-false/>
|
|
406
|
+
</result>
|
|
407
|
+
</test-case>
|
|
408
|
+
|
|
409
|
+
<test-case name="fn-deep-equalpint2args-4">
|
|
410
|
+
<description> Evaluates The "deep-equal" function with the arguments set as follows: $parameter1 = xs:positiveInteger(lower bound) $parameter2 = xs:positiveInteger(mid range) </description>
|
|
411
|
+
<created by="Carmelo Montanez" on="2004-12-13"/>
|
|
412
|
+
<test>fn:deep-equal((xs:positiveInteger("1")),(xs:positiveInteger("52704602390610033")))</test>
|
|
413
|
+
<result>
|
|
414
|
+
<assert-false/>
|
|
415
|
+
</result>
|
|
416
|
+
</test-case>
|
|
417
|
+
|
|
418
|
+
<test-case name="fn-deep-equalpint2args-5">
|
|
419
|
+
<description> Evaluates The "deep-equal" function with the arguments set as follows: $parameter1 = xs:positiveInteger(lower bound) $parameter2 = xs:positiveInteger(upper bound) </description>
|
|
420
|
+
<created by="Carmelo Montanez" on="2004-12-13"/>
|
|
421
|
+
<test>fn:deep-equal((xs:positiveInteger("1")),(xs:positiveInteger("999999999999999999")))</test>
|
|
422
|
+
<result>
|
|
423
|
+
<assert-false/>
|
|
424
|
+
</result>
|
|
425
|
+
</test-case>
|
|
426
|
+
|
|
427
|
+
<test-case name="fn-deep-equalulng2args-1">
|
|
428
|
+
<description> Evaluates The "deep-equal" function with the arguments set as follows: $parameter1 = xs:unsignedLong(lower bound) $parameter2 = xs:unsignedLong(lower bound) </description>
|
|
429
|
+
<created by="Carmelo Montanez" on="2004-12-13"/>
|
|
430
|
+
<test>fn:deep-equal((xs:unsignedLong("0")),(xs:unsignedLong("0")))</test>
|
|
431
|
+
<result>
|
|
432
|
+
<assert-true/>
|
|
433
|
+
</result>
|
|
434
|
+
</test-case>
|
|
435
|
+
|
|
436
|
+
<test-case name="fn-deep-equalulng2args-2">
|
|
437
|
+
<description> Evaluates The "deep-equal" function with the arguments set as follows: $parameter1 = xs:unsignedLong(mid range) $parameter2 = xs:unsignedLong(lower bound) </description>
|
|
438
|
+
<created by="Carmelo Montanez" on="2004-12-13"/>
|
|
439
|
+
<test>fn:deep-equal((xs:unsignedLong("130747108607674654")),(xs:unsignedLong("0")))</test>
|
|
440
|
+
<result>
|
|
441
|
+
<assert-false/>
|
|
442
|
+
</result>
|
|
443
|
+
</test-case>
|
|
444
|
+
|
|
445
|
+
<test-case name="fn-deep-equalulng2args-3">
|
|
446
|
+
<description> Evaluates The "deep-equal" function with the arguments set as follows: $parameter1 = xs:unsignedLong(upper bound) $parameter2 = xs:unsignedLong(lower bound) </description>
|
|
447
|
+
<created by="Carmelo Montanez" on="2004-12-13"/>
|
|
448
|
+
<test>fn:deep-equal((xs:unsignedLong("184467440737095516")),(xs:unsignedLong("0")))</test>
|
|
449
|
+
<result>
|
|
450
|
+
<assert-false/>
|
|
451
|
+
</result>
|
|
452
|
+
</test-case>
|
|
453
|
+
|
|
454
|
+
<test-case name="fn-deep-equalulng2args-4">
|
|
455
|
+
<description> Evaluates The "deep-equal" function with the arguments set as follows: $parameter1 = xs:unsignedLong(lower bound) $parameter2 = xs:unsignedLong(mid range) </description>
|
|
456
|
+
<created by="Carmelo Montanez" on="2004-12-13"/>
|
|
457
|
+
<test>fn:deep-equal((xs:unsignedLong("0")),(xs:unsignedLong("130747108607674654")))</test>
|
|
458
|
+
<result>
|
|
459
|
+
<assert-false/>
|
|
460
|
+
</result>
|
|
461
|
+
</test-case>
|
|
462
|
+
|
|
463
|
+
<test-case name="fn-deep-equalulng2args-5">
|
|
464
|
+
<description> Evaluates The "deep-equal" function with the arguments set as follows: $parameter1 = xs:unsignedLong(lower bound) $parameter2 = xs:unsignedLong(upper bound) </description>
|
|
465
|
+
<created by="Carmelo Montanez" on="2004-12-13"/>
|
|
466
|
+
<test>fn:deep-equal((xs:unsignedLong("0")),(xs:unsignedLong("184467440737095516")))</test>
|
|
467
|
+
<result>
|
|
468
|
+
<assert-false/>
|
|
469
|
+
</result>
|
|
470
|
+
</test-case>
|
|
471
|
+
|
|
472
|
+
<test-case name="fn-deep-equalnpi2args-1">
|
|
473
|
+
<description> Evaluates The "deep-equal" function with the arguments set as follows: $parameter1 = xs:nonPositiveInteger(lower bound) $parameter2 = xs:nonPositiveInteger(lower bound) </description>
|
|
474
|
+
<created by="Carmelo Montanez" on="2004-12-13"/>
|
|
475
|
+
<test>fn:deep-equal((xs:nonPositiveInteger("-999999999999999999")),(xs:nonPositiveInteger("-999999999999999999")))</test>
|
|
476
|
+
<result>
|
|
477
|
+
<assert-true/>
|
|
478
|
+
</result>
|
|
479
|
+
</test-case>
|
|
480
|
+
|
|
481
|
+
<test-case name="fn-deep-equalnpi2args-2">
|
|
482
|
+
<description> Evaluates The "deep-equal" function with the arguments set as follows: $parameter1 = xs:nonPositiveInteger(mid range) $parameter2 = xs:nonPositiveInteger(lower bound) </description>
|
|
483
|
+
<created by="Carmelo Montanez" on="2004-12-13"/>
|
|
484
|
+
<test>fn:deep-equal((xs:nonPositiveInteger("-475688437271870490")),(xs:nonPositiveInteger("-999999999999999999")))</test>
|
|
485
|
+
<result>
|
|
486
|
+
<assert-false/>
|
|
487
|
+
</result>
|
|
488
|
+
</test-case>
|
|
489
|
+
|
|
490
|
+
<test-case name="fn-deep-equalnpi2args-3">
|
|
491
|
+
<description> Evaluates The "deep-equal" function with the arguments set as follows: $parameter1 = xs:nonPositiveInteger(upper bound) $parameter2 = xs:nonPositiveInteger(lower bound) </description>
|
|
492
|
+
<created by="Carmelo Montanez" on="2004-12-13"/>
|
|
493
|
+
<test>fn:deep-equal((xs:nonPositiveInteger("0")),(xs:nonPositiveInteger("-999999999999999999")))</test>
|
|
494
|
+
<result>
|
|
495
|
+
<assert-false/>
|
|
496
|
+
</result>
|
|
497
|
+
</test-case>
|
|
498
|
+
|
|
499
|
+
<test-case name="fn-deep-equalnpi2args-4">
|
|
500
|
+
<description> Evaluates The "deep-equal" function with the arguments set as follows: $parameter1 = xs:nonPositiveInteger(lower bound) $parameter2 = xs:nonPositiveInteger(mid range) </description>
|
|
501
|
+
<created by="Carmelo Montanez" on="2004-12-13"/>
|
|
502
|
+
<test>fn:deep-equal((xs:nonPositiveInteger("-999999999999999999")),(xs:nonPositiveInteger("-475688437271870490")))</test>
|
|
503
|
+
<result>
|
|
504
|
+
<assert-false/>
|
|
505
|
+
</result>
|
|
506
|
+
</test-case>
|
|
507
|
+
|
|
508
|
+
<test-case name="fn-deep-equalnpi2args-5">
|
|
509
|
+
<description> Evaluates The "deep-equal" function with the arguments set as follows: $parameter1 = xs:nonPositiveInteger(lower bound) $parameter2 = xs:nonPositiveInteger(upper bound) </description>
|
|
510
|
+
<created by="Carmelo Montanez" on="2004-12-13"/>
|
|
511
|
+
<test>fn:deep-equal((xs:nonPositiveInteger("-999999999999999999")),(xs:nonPositiveInteger("0")))</test>
|
|
512
|
+
<result>
|
|
513
|
+
<assert-false/>
|
|
514
|
+
</result>
|
|
515
|
+
</test-case>
|
|
516
|
+
|
|
517
|
+
<test-case name="fn-deep-equalnni2args-1">
|
|
518
|
+
<description> Evaluates The "deep-equal" function with the arguments set as follows: $parameter1 = xs:nonNegativeInteger(lower bound) $parameter2 = xs:nonNegativeInteger(lower bound) </description>
|
|
519
|
+
<created by="Carmelo Montanez" on="2004-12-13"/>
|
|
520
|
+
<test>fn:deep-equal((xs:nonNegativeInteger("0")),(xs:nonNegativeInteger("0")))</test>
|
|
521
|
+
<result>
|
|
522
|
+
<assert-true/>
|
|
523
|
+
</result>
|
|
524
|
+
</test-case>
|
|
525
|
+
|
|
526
|
+
<test-case name="fn-deep-equalnni2args-2">
|
|
527
|
+
<description> Evaluates The "deep-equal" function with the arguments set as follows: $parameter1 = xs:nonNegativeInteger(mid range) $parameter2 = xs:nonNegativeInteger(lower bound) </description>
|
|
528
|
+
<created by="Carmelo Montanez" on="2004-12-13"/>
|
|
529
|
+
<test>fn:deep-equal((xs:nonNegativeInteger("303884545991464527")),(xs:nonNegativeInteger("0")))</test>
|
|
530
|
+
<result>
|
|
531
|
+
<assert-false/>
|
|
532
|
+
</result>
|
|
533
|
+
</test-case>
|
|
534
|
+
|
|
535
|
+
<test-case name="fn-deep-equalnni2args-3">
|
|
536
|
+
<description> Evaluates The "deep-equal" function with the arguments set as follows: $parameter1 = xs:nonNegativeInteger(upper bound) $parameter2 = xs:nonNegativeInteger(lower bound) </description>
|
|
537
|
+
<created by="Carmelo Montanez" on="2004-12-13"/>
|
|
538
|
+
<test>fn:deep-equal((xs:nonNegativeInteger("999999999999999999")),(xs:nonNegativeInteger("0")))</test>
|
|
539
|
+
<result>
|
|
540
|
+
<assert-false/>
|
|
541
|
+
</result>
|
|
542
|
+
</test-case>
|
|
543
|
+
|
|
544
|
+
<test-case name="fn-deep-equalnni2args-4">
|
|
545
|
+
<description> Evaluates The "deep-equal" function with the arguments set as follows: $parameter1 = xs:nonNegativeInteger(lower bound) $parameter2 = xs:nonNegativeInteger(mid range) </description>
|
|
546
|
+
<created by="Carmelo Montanez" on="2004-12-13"/>
|
|
547
|
+
<test>fn:deep-equal((xs:nonNegativeInteger("0")),(xs:nonNegativeInteger("303884545991464527")))</test>
|
|
548
|
+
<result>
|
|
549
|
+
<assert-false/>
|
|
550
|
+
</result>
|
|
551
|
+
</test-case>
|
|
552
|
+
|
|
553
|
+
<test-case name="fn-deep-equalnni2args-5">
|
|
554
|
+
<description> Evaluates The "deep-equal" function with the arguments set as follows: $parameter1 = xs:nonNegativeInteger(lower bound) $parameter2 = xs:nonNegativeInteger(upper bound) </description>
|
|
555
|
+
<created by="Carmelo Montanez" on="2004-12-13"/>
|
|
556
|
+
<test>fn:deep-equal((xs:nonNegativeInteger("0")),(xs:nonNegativeInteger("999999999999999999")))</test>
|
|
557
|
+
<result>
|
|
558
|
+
<assert-false/>
|
|
559
|
+
</result>
|
|
560
|
+
</test-case>
|
|
561
|
+
|
|
562
|
+
<test-case name="fn-deep-equalsht2args-1">
|
|
563
|
+
<description> Evaluates The "deep-equal" function with the arguments set as follows: $parameter1 = xs:short(lower bound) $parameter2 = xs:short(lower bound) </description>
|
|
564
|
+
<created by="Carmelo Montanez" on="2004-12-13"/>
|
|
565
|
+
<test>fn:deep-equal((xs:short("-32768")),(xs:short("-32768")))</test>
|
|
566
|
+
<result>
|
|
567
|
+
<assert-true/>
|
|
568
|
+
</result>
|
|
569
|
+
</test-case>
|
|
570
|
+
|
|
571
|
+
<test-case name="fn-deep-equalsht2args-2">
|
|
572
|
+
<description> Evaluates The "deep-equal" function with the arguments set as follows: $parameter1 = xs:short(mid range) $parameter2 = xs:short(lower bound) </description>
|
|
573
|
+
<created by="Carmelo Montanez" on="2004-12-13"/>
|
|
574
|
+
<test>fn:deep-equal((xs:short("-5324")),(xs:short("-32768")))</test>
|
|
575
|
+
<result>
|
|
576
|
+
<assert-false/>
|
|
577
|
+
</result>
|
|
578
|
+
</test-case>
|
|
579
|
+
|
|
580
|
+
<test-case name="fn-deep-equalsht2args-3">
|
|
581
|
+
<description> Evaluates The "deep-equal" function with the arguments set as follows: $parameter1 = xs:short(upper bound) $parameter2 = xs:short(lower bound) </description>
|
|
582
|
+
<created by="Carmelo Montanez" on="2004-12-13"/>
|
|
583
|
+
<test>fn:deep-equal((xs:short("32767")),(xs:short("-32768")))</test>
|
|
584
|
+
<result>
|
|
585
|
+
<assert-false/>
|
|
586
|
+
</result>
|
|
587
|
+
</test-case>
|
|
588
|
+
|
|
589
|
+
<test-case name="fn-deep-equalsht2args-4">
|
|
590
|
+
<description> Evaluates The "deep-equal" function with the arguments set as follows: $parameter1 = xs:short(lower bound) $parameter2 = xs:short(mid range) </description>
|
|
591
|
+
<created by="Carmelo Montanez" on="2004-12-13"/>
|
|
592
|
+
<test>fn:deep-equal((xs:short("-32768")),(xs:short("-5324")))</test>
|
|
593
|
+
<result>
|
|
594
|
+
<assert-false/>
|
|
595
|
+
</result>
|
|
596
|
+
</test-case>
|
|
597
|
+
|
|
598
|
+
<test-case name="fn-deep-equalsht2args-5">
|
|
599
|
+
<description> Evaluates The "deep-equal" function with the arguments set as follows: $parameter1 = xs:short(lower bound) $parameter2 = xs:short(upper bound) </description>
|
|
600
|
+
<created by="Carmelo Montanez" on="2004-12-13"/>
|
|
601
|
+
<test>fn:deep-equal((xs:short("-32768")),(xs:short("32767")))</test>
|
|
602
|
+
<result>
|
|
603
|
+
<assert-false/>
|
|
604
|
+
</result>
|
|
605
|
+
</test-case>
|
|
606
|
+
|
|
607
|
+
<test-case name="fn-deep-equal-mix-args-001">
|
|
608
|
+
<description> The order of elements in sequence is important </description>
|
|
609
|
+
<created by="Pulkita Tyagi" on="2005-05-24"/>
|
|
610
|
+
<test>fn:deep-equal( (1,2) , (2,1))</test>
|
|
611
|
+
<result>
|
|
612
|
+
<assert-false/>
|
|
613
|
+
</result>
|
|
614
|
+
</test-case>
|
|
615
|
+
|
|
616
|
+
<test-case name="fn-deep-equal-mix-args-002">
|
|
617
|
+
<description> Two sequences are fn:deep-equal if items have same value and same order </description>
|
|
618
|
+
<created by="Pulkita Tyagi" on="2005-05-24"/>
|
|
619
|
+
<test>fn:deep-equal( (1,2) , (1,2))</test>
|
|
620
|
+
<result>
|
|
621
|
+
<assert-true/>
|
|
622
|
+
</result>
|
|
623
|
+
</test-case>
|
|
624
|
+
|
|
625
|
+
<test-case name="fn-deep-equal-mix-args-003">
|
|
626
|
+
<description> comparing arguments of type string </description>
|
|
627
|
+
<created by="Pulkita Tyagi" on="2005-05-24"/>
|
|
628
|
+
<test>fn:deep-equal( xs:string("A") , "A")</test>
|
|
629
|
+
<result>
|
|
630
|
+
<assert-true/>
|
|
631
|
+
</result>
|
|
632
|
+
</test-case>
|
|
633
|
+
|
|
634
|
+
<test-case name="fn-deep-equal-mix-args-004">
|
|
635
|
+
<description> arg of type string, but case is different </description>
|
|
636
|
+
<created by="Pulkita Tyagi" on="2005-05-24"/>
|
|
637
|
+
<test>fn:deep-equal( xs:string("A") , "a")</test>
|
|
638
|
+
<result>
|
|
639
|
+
<assert-false/>
|
|
640
|
+
</result>
|
|
641
|
+
</test-case>
|
|
642
|
+
|
|
643
|
+
<test-case name="fn-deep-equal-mix-args-005">
|
|
644
|
+
<description> arg1: string, arg2: sequence with 1 element of type string </description>
|
|
645
|
+
<created by="Pulkita Tyagi" on="2005-05-24"/>
|
|
646
|
+
<test>fn:deep-equal( xs:string("A") , ("A"))</test>
|
|
647
|
+
<result>
|
|
648
|
+
<assert-true/>
|
|
649
|
+
</result>
|
|
650
|
+
</test-case>
|
|
651
|
+
|
|
652
|
+
<test-case name="fn-deep-equal-mix-args-006">
|
|
653
|
+
<description> Comparing null strings </description>
|
|
654
|
+
<created by="Pulkita Tyagi" on="2005-05-24"/>
|
|
655
|
+
<test>fn:deep-equal( xs:string("") , (""))</test>
|
|
656
|
+
<result>
|
|
657
|
+
<assert-true/>
|
|
658
|
+
</result>
|
|
659
|
+
</test-case>
|
|
660
|
+
|
|
661
|
+
<test-case name="fn-deep-equal-mix-args-007">
|
|
662
|
+
<description> Comparing null sequences </description>
|
|
663
|
+
<created by="Pulkita Tyagi" on="2005-05-24"/>
|
|
664
|
+
<test>fn:deep-equal( () , ())</test>
|
|
665
|
+
<result>
|
|
666
|
+
<assert-true/>
|
|
667
|
+
</result>
|
|
668
|
+
</test-case>
|
|
669
|
+
|
|
670
|
+
<test-case name="fn-deep-equal-mix-args-008">
|
|
671
|
+
<description> Comparing nested null & a null sequence </description>
|
|
672
|
+
<created by="Pulkita Tyagi" on="2005-05-24"/>
|
|
673
|
+
<test>fn:deep-equal( (()) , ())</test>
|
|
674
|
+
<result>
|
|
675
|
+
<assert-true/>
|
|
676
|
+
</result>
|
|
677
|
+
</test-case>
|
|
678
|
+
|
|
679
|
+
<test-case name="fn-deep-equal-mix-args-009">
|
|
680
|
+
<description> Comparing arg1: sequence with a space with agr2: empty sequence </description>
|
|
681
|
+
<created by="Pulkita Tyagi" on="2005-05-24"/>
|
|
682
|
+
<test>fn:deep-equal( ( ) , ())</test>
|
|
683
|
+
<result>
|
|
684
|
+
<assert-true/>
|
|
685
|
+
</result>
|
|
686
|
+
</test-case>
|
|
687
|
+
|
|
688
|
+
<test-case name="fn-deep-equal-mix-args-010">
|
|
689
|
+
<description> Comparing strings with different value </description>
|
|
690
|
+
<created by="Pulkita Tyagi" on="2005-05-24"/>
|
|
691
|
+
<test>fn:deep-equal(xs:string("abc"), xs:string("cba"))</test>
|
|
692
|
+
<result>
|
|
693
|
+
<assert-false/>
|
|
694
|
+
</result>
|
|
695
|
+
</test-case>
|
|
696
|
+
|
|
697
|
+
<test-case name="fn-deep-equal-mix-args-011">
|
|
698
|
+
<description> Comparing arg1: anyURI, arg2: string </description>
|
|
699
|
+
<created by="Pulkita Tyagi" on="2005-05-24"/>
|
|
700
|
+
<test>fn:deep-equal( xs:anyURI("www.example.com") , "www.example.com")</test>
|
|
701
|
+
<result>
|
|
702
|
+
<assert-true/>
|
|
703
|
+
</result>
|
|
704
|
+
</test-case>
|
|
705
|
+
|
|
706
|
+
<test-case name="fn-deep-equal-mix-args-012">
|
|
707
|
+
<description> Comparing arg1:anyURI and arg2:string </description>
|
|
708
|
+
<created by="Pulkita Tyagi" on="2005-05-24"/>
|
|
709
|
+
<test>fn:deep-equal( xs:anyURI("www.example.com") , xs:string("www.example.com"))</test>
|
|
710
|
+
<result>
|
|
711
|
+
<assert-true/>
|
|
712
|
+
</result>
|
|
713
|
+
</test-case>
|
|
714
|
+
|
|
715
|
+
<test-case name="fn-deep-equal-mix-args-013">
|
|
716
|
+
<description> Comparing arg1:integer and arg2:decimal </description>
|
|
717
|
+
<created by="Pulkita Tyagi" on="2005-05-24"/>
|
|
718
|
+
<test>fn:deep-equal( xs:integer(1) , xs:decimal(1.0))</test>
|
|
719
|
+
<result>
|
|
720
|
+
<assert-true/>
|
|
721
|
+
</result>
|
|
722
|
+
</test-case>
|
|
723
|
+
|
|
724
|
+
<test-case name="fn-deep-equal-mix-args-014">
|
|
725
|
+
<description> Comapring integer args with different values </description>
|
|
726
|
+
<created by="Pulkita Tyagi" on="2005-05-24"/>
|
|
727
|
+
<test>fn:deep-equal( xs:integer(1) , xs:integer(-1))</test>
|
|
728
|
+
<result>
|
|
729
|
+
<assert-false/>
|
|
730
|
+
</result>
|
|
731
|
+
</test-case>
|
|
732
|
+
|
|
733
|
+
<test-case name="fn-deep-equal-mix-args-015">
|
|
734
|
+
<description> Comparing arg1:integer and arg2:float </description>
|
|
735
|
+
<created by="Pulkita Tyagi" on="2005-05-24"/>
|
|
736
|
+
<test>fn:deep-equal( xs:integer(1) , xs:float(1.0))</test>
|
|
737
|
+
<result>
|
|
738
|
+
<assert-true/>
|
|
739
|
+
</result>
|
|
740
|
+
</test-case>
|
|
741
|
+
|
|
742
|
+
<test-case name="fn-deep-equal-mix-args-016">
|
|
743
|
+
<description> Comparing arg1:integer, arg2:double </description>
|
|
744
|
+
<created by="Pulkita Tyagi" on="2005-05-24"/>
|
|
745
|
+
<test>fn:deep-equal( xs:integer(1) , xs:double(1.0))</test>
|
|
746
|
+
<result>
|
|
747
|
+
<assert-true/>
|
|
748
|
+
</result>
|
|
749
|
+
</test-case>
|
|
750
|
+
|
|
751
|
+
<test-case name="fn-deep-equal-mix-args-017">
|
|
752
|
+
<description> Comparing arg1:decimal , arg2:float </description>
|
|
753
|
+
<created by="Pulkita Tyagi" on="2005-05-24"/>
|
|
754
|
+
<test>fn:deep-equal( xs:decimal(1.01) , xs:float(1.01))</test>
|
|
755
|
+
<result>
|
|
756
|
+
<assert-true/>
|
|
757
|
+
</result>
|
|
758
|
+
</test-case>
|
|
759
|
+
|
|
760
|
+
<test-case name="fn-deep-equal-mix-args-018">
|
|
761
|
+
<description> Comparing arg1:decimal, arg2:double </description>
|
|
762
|
+
<created by="Pulkita Tyagi" on="2005-05-24"/>
|
|
763
|
+
<test>fn:deep-equal( xs:decimal(1.01) , xs:double(1.01))</test>
|
|
764
|
+
<result>
|
|
765
|
+
<assert-true/>
|
|
766
|
+
</result>
|
|
767
|
+
</test-case>
|
|
768
|
+
|
|
769
|
+
<test-case name="fn-deep-equal-mix-args-019">
|
|
770
|
+
<description> Comparing arg1:float , arg2:double </description>
|
|
771
|
+
<created by="Pulkita Tyagi" on="2005-05-24"/>
|
|
772
|
+
<test>fn:deep-equal( xs:float(1.01) , xs:double(1.01))</test>
|
|
773
|
+
<result>
|
|
774
|
+
<assert-false/>
|
|
775
|
+
</result>
|
|
776
|
+
</test-case>
|
|
777
|
+
|
|
778
|
+
<test-case name="fn-deep-equal-mix-args-020">
|
|
779
|
+
<description> Comparing arg1:float, arg2:double values INF </description>
|
|
780
|
+
<created by="Pulkita Tyagi" on="2005-05-24"/>
|
|
781
|
+
<test>fn:deep-equal( xs:float("INF") , xs:double("INF"))</test>
|
|
782
|
+
<result>
|
|
783
|
+
<assert-true/>
|
|
784
|
+
</result>
|
|
785
|
+
</test-case>
|
|
786
|
+
|
|
787
|
+
<test-case name="fn-deep-equal-mix-args-021">
|
|
788
|
+
<description> Comparing arg1:float, arg2:double values -INF </description>
|
|
789
|
+
<created by="Pulkita Tyagi" on="2005-05-24"/>
|
|
790
|
+
<test>fn:deep-equal( xs:float("-INF") , xs:double("-INF"))</test>
|
|
791
|
+
<result>
|
|
792
|
+
<assert-true/>
|
|
793
|
+
</result>
|
|
794
|
+
</test-case>
|
|
795
|
+
|
|
796
|
+
<test-case name="fn-deep-equal-mix-args-022">
|
|
797
|
+
<description> Comparing arg1:float, arg2:double values NaN </description>
|
|
798
|
+
<created by="Pulkita Tyagi" on="2005-05-24"/>
|
|
799
|
+
<test>fn:deep-equal( xs:float("NaN") , xs:double("NaN"))</test>
|
|
800
|
+
<result>
|
|
801
|
+
<assert-true/>
|
|
802
|
+
</result>
|
|
803
|
+
</test-case>
|
|
804
|
+
|
|
805
|
+
<test-case name="fn-deep-equal-mix-args-023">
|
|
806
|
+
<description> Comparing two boolean args </description>
|
|
807
|
+
<created by="Pulkita Tyagi" on="2005-05-24"/>
|
|
808
|
+
<test>fn:deep-equal( xs:boolean("1") , xs:boolean("true"))</test>
|
|
809
|
+
<result>
|
|
810
|
+
<assert-true/>
|
|
811
|
+
</result>
|
|
812
|
+
</test-case>
|
|
813
|
+
|
|
814
|
+
<test-case name="fn-deep-equal-mix-args-024">
|
|
815
|
+
<description> Comparing two boolean args </description>
|
|
816
|
+
<created by="Pulkita Tyagi" on="2005-05-24"/>
|
|
817
|
+
<test>fn:deep-equal( xs:boolean("true") , xs:boolean("true"))</test>
|
|
818
|
+
<result>
|
|
819
|
+
<assert-true/>
|
|
820
|
+
</result>
|
|
821
|
+
</test-case>
|
|
822
|
+
|
|
823
|
+
<test-case name="fn-deep-equal-mix-args-025">
|
|
824
|
+
<description> Comparing arg1:boolean arg2:value returned by true fn </description>
|
|
825
|
+
<created by="Pulkita Tyagi" on="2005-05-24"/>
|
|
826
|
+
<test>fn:deep-equal( xs:boolean("true") , true())</test>
|
|
827
|
+
<result>
|
|
828
|
+
<assert-true/>
|
|
829
|
+
</result>
|
|
830
|
+
</test-case>
|
|
831
|
+
|
|
832
|
+
<test-case name="fn-deep-equal-mix-args-026">
|
|
833
|
+
<description> Comparing two boolean args </description>
|
|
834
|
+
<created by="Pulkita Tyagi" on="2005-05-24"/>
|
|
835
|
+
<test>fn:deep-equal( xs:boolean("0") , xs:boolean("false"))</test>
|
|
836
|
+
<result>
|
|
837
|
+
<assert-true/>
|
|
838
|
+
</result>
|
|
839
|
+
</test-case>
|
|
840
|
+
|
|
841
|
+
<test-case name="fn-deep-equal-mix-args-027">
|
|
842
|
+
<description> Comparing arg1:boolean arg2:value of false fn </description>
|
|
843
|
+
<created by="Pulkita Tyagi" on="2005-05-24"/>
|
|
844
|
+
<test>fn:deep-equal( xs:boolean("false") , false())</test>
|
|
845
|
+
<result>
|
|
846
|
+
<assert-true/>
|
|
847
|
+
</result>
|
|
848
|
+
</test-case>
|
|
849
|
+
|
|
850
|
+
<test-case name="fn-deep-equal-mix-args-028">
|
|
851
|
+
<description> Comparing arg1:date, arg2: string </description>
|
|
852
|
+
<created by="Pulkita Tyagi" on="2005-05-24"/>
|
|
853
|
+
<test>fn:deep-equal( xs:date("1993-03-31") , "1993-03-31")</test>
|
|
854
|
+
<result>
|
|
855
|
+
<assert-false/>
|
|
856
|
+
</result>
|
|
857
|
+
</test-case>
|
|
858
|
+
|
|
859
|
+
<test-case name="fn-deep-equal-mix-args-029">
|
|
860
|
+
<description> Comparing arg1:date, arg2: string </description>
|
|
861
|
+
<created by="Pulkita Tyagi" on="2005-05-24"/>
|
|
862
|
+
<test>fn:deep-equal( xs:date("1993-03-31") , xs:string("1993-03-31"))</test>
|
|
863
|
+
<result>
|
|
864
|
+
<assert-false/>
|
|
865
|
+
</result>
|
|
866
|
+
</test-case>
|
|
867
|
+
|
|
868
|
+
<test-case name="fn-deep-equal-mix-args-030">
|
|
869
|
+
<description> Comparing arg1:dateTime, arg2: string </description>
|
|
870
|
+
<created by="Pulkita Tyagi" on="2005-05-24"/>
|
|
871
|
+
<test>fn:deep-equal(xs:dateTime("1972-12-31T00:00:00"), "1972-12-31T00:00:00")</test>
|
|
872
|
+
<result>
|
|
873
|
+
<assert-false/>
|
|
874
|
+
</result>
|
|
875
|
+
</test-case>
|
|
876
|
+
|
|
877
|
+
<test-case name="fn-deep-equal-mix-args-031">
|
|
878
|
+
<description> Comparing arg1:time, arg2: string </description>
|
|
879
|
+
<created by="Pulkita Tyagi" on="2005-05-24"/>
|
|
880
|
+
<test>fn:deep-equal(xs:time("12:30:00"), "12:30:00")</test>
|
|
881
|
+
<result>
|
|
882
|
+
<assert-false/>
|
|
883
|
+
</result>
|
|
884
|
+
</test-case>
|
|
885
|
+
|
|
886
|
+
<test-case name="fn-deep-equal-node-args-1">
|
|
887
|
+
<description> Apply deep-equal to nodes </description>
|
|
888
|
+
<created by="Andrew Eisenberg" on="2006-09-25"/>
|
|
889
|
+
<environment ref="bib"/>
|
|
890
|
+
<dependency type="spec" value="XQ10+"/>
|
|
891
|
+
<test><![CDATA[fn:deep-equal(<a> {/bib/node()} </a>/node(), <b> {/bib/node()} </b>/node() )]]></test>
|
|
892
|
+
<result>
|
|
893
|
+
<assert-true/>
|
|
894
|
+
</result>
|
|
895
|
+
</test-case>
|
|
896
|
+
|
|
897
|
+
<test-case name="fn-deep-equal-node-args-2">
|
|
898
|
+
<description> Apply deep-equal to nodes </description>
|
|
899
|
+
<created by="Andrew Eisenberg" on="2006-09-25"/>
|
|
900
|
+
<environment ref="bib"/>
|
|
901
|
+
<dependency type="spec" value="XQ10+"/>
|
|
902
|
+
<test><![CDATA[fn:deep-equal(<a> {/bib/node(), /bib/node()} </a>/node(), <b> {/bib/node(), <difference/>, /bib/node()} </b>/node() )]]></test>
|
|
903
|
+
<result>
|
|
904
|
+
<assert-false/>
|
|
905
|
+
</result>
|
|
906
|
+
</test-case>
|
|
907
|
+
|
|
908
|
+
<test-case name="fn-deep-equal-arrays-1" covers="array-square-constructor fn-deep-equal">
|
|
909
|
+
<description> Apply deep-equal to arrays </description>
|
|
910
|
+
<created by="Michael Kay" on="2014-10-14"/>
|
|
911
|
+
<dependency type="spec" value="XP31+ XQ31+"/>
|
|
912
|
+
<test>fn:deep-equal([], [])</test>
|
|
913
|
+
<result>
|
|
914
|
+
<assert-true/>
|
|
915
|
+
</result>
|
|
916
|
+
</test-case>
|
|
917
|
+
|
|
918
|
+
<test-case name="fn-deep-equal-arrays-2" covers="array-square-constructor fn-deep-equal">
|
|
919
|
+
<description> Apply deep-equal to arrays </description>
|
|
920
|
+
<created by="Michael Kay" on="2014-10-14"/>
|
|
921
|
+
<dependency type="spec" value="XP31+ XQ31+"/>
|
|
922
|
+
<test>fn:deep-equal([1,2], [1,2])</test>
|
|
923
|
+
<result>
|
|
924
|
+
<assert-true/>
|
|
925
|
+
</result>
|
|
926
|
+
</test-case>
|
|
927
|
+
|
|
928
|
+
<test-case name="fn-deep-equal-arrays-3" covers="array-square-constructor fn-deep-equal">
|
|
929
|
+
<description> Apply deep-equal to arrays </description>
|
|
930
|
+
<created by="Michael Kay" on="2014-10-14"/>
|
|
931
|
+
<dependency type="spec" value="XP31+ XQ31+"/>
|
|
932
|
+
<test>fn:deep-equal([[]], [[]])</test>
|
|
933
|
+
<result>
|
|
934
|
+
<assert-true/>
|
|
935
|
+
</result>
|
|
936
|
+
</test-case>
|
|
937
|
+
|
|
938
|
+
<test-case name="fn-deep-equal-arrays-4" covers="array-square-constructor fn-deep-equal">
|
|
939
|
+
<description> Apply deep-equal to arrays </description>
|
|
940
|
+
<created by="Michael Kay" on="2014-10-14"/>
|
|
941
|
+
<dependency type="spec" value="XP31+ XQ31+"/>
|
|
942
|
+
<test>fn:deep-equal([], [1])</test>
|
|
943
|
+
<result>
|
|
944
|
+
<assert-false/>
|
|
945
|
+
</result>
|
|
946
|
+
</test-case>
|
|
947
|
+
|
|
948
|
+
<test-case name="fn-deep-equal-arrays-5" covers="array-square-constructor fn-deep-equal">
|
|
949
|
+
<description> Apply deep-equal to arrays </description>
|
|
950
|
+
<created by="Michael Kay" on="2014-10-14"/>
|
|
951
|
+
<dependency type="spec" value="XP31+ XQ31+"/>
|
|
952
|
+
<test>fn:deep-equal([1], 1)</test>
|
|
953
|
+
<result>
|
|
954
|
+
<assert-false/>
|
|
955
|
+
</result>
|
|
956
|
+
</test-case>
|
|
957
|
+
|
|
958
|
+
<test-case name="fn-deep-equal-arrays-6" covers="array-square-constructor fn-deep-equal">
|
|
959
|
+
<description> Apply deep-equal to arrays </description>
|
|
960
|
+
<created by="Michael Kay" on="2014-10-14"/>
|
|
961
|
+
<dependency type="spec" value="XP31+ XQ31+"/>
|
|
962
|
+
<test>fn:deep-equal([], [()])</test>
|
|
963
|
+
<result>
|
|
964
|
+
<assert-false/>
|
|
965
|
+
</result>
|
|
966
|
+
</test-case>
|
|
967
|
+
|
|
968
|
+
<test-case name="fn-deep-equal-arrays-7" covers="array-square-constructor fn-deep-equal">
|
|
969
|
+
<description> Apply deep-equal to arrays </description>
|
|
970
|
+
<created by="Michael Kay" on="2014-10-14"/>
|
|
971
|
+
<dependency type="spec" value="XP31+ XQ31+"/>
|
|
972
|
+
<test>fn:deep-equal([()], [()])</test>
|
|
973
|
+
<result>
|
|
974
|
+
<assert-true/>
|
|
975
|
+
</result>
|
|
976
|
+
</test-case>
|
|
977
|
+
|
|
978
|
+
<test-case name="fn-deep-equal-arrays-8" covers="array-square-constructor map-constructor fn-deep-equal">
|
|
979
|
+
<description> Apply deep-equal to arrays </description>
|
|
980
|
+
<created by="Michael Kay" on="2014-10-14"/>
|
|
981
|
+
<dependency type="spec" value="XP31+ XQ31+"/>
|
|
982
|
+
<test>fn:deep-equal([map{}], [map{}])</test>
|
|
983
|
+
<result>
|
|
984
|
+
<assert-true/>
|
|
985
|
+
</result>
|
|
986
|
+
</test-case>
|
|
987
|
+
|
|
988
|
+
<test-case name="fn-deep-equal-arrays-9" covers="array-square-constructor fn-deep-equal">
|
|
989
|
+
<description> Apply deep-equal to arrays </description>
|
|
990
|
+
<created by="Michael Kay" on="2014-10-14"/>
|
|
991
|
+
<dependency type="spec" value="XP31+ XQ31+"/>
|
|
992
|
+
<test>fn:deep-equal([map{1:1, 2:2}], [map{2:2, 1:1}])</test>
|
|
993
|
+
<result>
|
|
994
|
+
<assert-true/>
|
|
995
|
+
</result>
|
|
996
|
+
</test-case>
|
|
997
|
+
|
|
998
|
+
<test-case name="fn-deep-equal-arrays-10" covers="array-square-constructor fn-deep-equal">
|
|
999
|
+
<description> Apply deep-equal to arrays </description>
|
|
1000
|
+
<created by="Michael Kay" on="2014-10-14"/>
|
|
1001
|
+
<dependency type="spec" value="XQ31+"/>
|
|
1002
|
+
<test><![CDATA[
|
|
1003
|
+
fn:deep-equal([<a>1</a>], [<a>1</a>])
|
|
1004
|
+
]]></test>
|
|
1005
|
+
<result>
|
|
1006
|
+
<assert-true/>
|
|
1007
|
+
</result>
|
|
1008
|
+
</test-case>
|
|
1009
|
+
|
|
1010
|
+
<test-case name="fn-deep-equal-arrays-11" covers="array-square-constructor fn-deep-equal">
|
|
1011
|
+
<description> Apply deep-equal to arrays </description>
|
|
1012
|
+
<created by="Michael Kay" on="2014-10-14"/>
|
|
1013
|
+
<dependency type="spec" value="XP31+ XQ31+"/>
|
|
1014
|
+
<test>fn:deep-equal([['a', 'b', 'c']], [['a', 'b', 'c']])</test>
|
|
1015
|
+
<result>
|
|
1016
|
+
<assert-true/>
|
|
1017
|
+
</result>
|
|
1018
|
+
</test-case>
|
|
1019
|
+
|
|
1020
|
+
<test-case name="fn-deep-equal-arrays-12" covers="array-square-constructor fn-deep-equal">
|
|
1021
|
+
<description> Apply deep-equal to arrays </description>
|
|
1022
|
+
<created by="Michael Kay" on="2014-10-14"/>
|
|
1023
|
+
<dependency type="spec" value="XP31+ XQ31+"/>
|
|
1024
|
+
<test>fn:deep-equal([['a', 'b', 'c']], [['A', 'B', 'C']])</test>
|
|
1025
|
+
<result>
|
|
1026
|
+
<assert-false/>
|
|
1027
|
+
</result>
|
|
1028
|
+
</test-case>
|
|
1029
|
+
|
|
1030
|
+
<test-case name="fn-deep-equal-arrays-13" covers="array-square-constructor fn-deep-equal">
|
|
1031
|
+
<description> Apply deep-equal to arrays, with a collation </description>
|
|
1032
|
+
<created by="Michael Kay" on="2014-10-14"/>
|
|
1033
|
+
<modified by="Michael Kay" on="2016-06-14" change="See bug 29621"/>
|
|
1034
|
+
<dependency type="spec" value="XP31+ XQ31+"/>
|
|
1035
|
+
<dependency type="feature" value="simple-uca-fallback"/>
|
|
1036
|
+
<test>fn:deep-equal([['a', 'b', 'c']], [['A', 'B', 'C']], 'http://www.w3.org/2013/collation/UCA?strength=secondary')</test>
|
|
1037
|
+
<result>
|
|
1038
|
+
<assert-true/>
|
|
1039
|
+
</result>
|
|
1040
|
+
</test-case>
|
|
1041
|
+
|
|
1042
|
+
<test-case name="fn-deep-equal-arrays-14" covers="array-square-constructor fn-deep-equal">
|
|
1043
|
+
<description> Apply deep-equal to a sequence of arrays </description>
|
|
1044
|
+
<created by="Michael Kay" on="2018-09-03"/>
|
|
1045
|
+
<dependency type="spec" value="XP31+ XQ31+"/>
|
|
1046
|
+
<test>fn:deep-equal(([['a', 'b', 'c']], [], [1]), ([['a', 'b', 'c']], [], [1]))</test>
|
|
1047
|
+
<result>
|
|
1048
|
+
<assert-true/>
|
|
1049
|
+
</result>
|
|
1050
|
+
</test-case>
|
|
1051
|
+
|
|
1052
|
+
<test-case name="fn-deep-equal-arrays-15" covers="array-square-constructor fn-deep-equal">
|
|
1053
|
+
<description> Apply deep-equal to a sequence of arrays </description>
|
|
1054
|
+
<created by="Michael Kay" on="2018-09-03"/>
|
|
1055
|
+
<dependency type="spec" value="XP31+ XQ31+"/>
|
|
1056
|
+
<test>fn:deep-equal(([['a', 'b', 'c']], [], [1]), ([['a', 'b', 'c']], [], [1], []))</test>
|
|
1057
|
+
<result>
|
|
1058
|
+
<assert-false/>
|
|
1059
|
+
</result>
|
|
1060
|
+
</test-case>
|
|
1061
|
+
|
|
1062
|
+
<test-case name="fn-deep-equal-arrays-16" covers="array-square-constructor fn-deep-equal">
|
|
1063
|
+
<description> Apply deep-equal to a sequence of arrays </description>
|
|
1064
|
+
<created by="Michael Kay" on="2018-09-03"/>
|
|
1065
|
+
<dependency type="spec" value="XP31+ XQ31+"/>
|
|
1066
|
+
<test>fn:deep-equal(([['a', 'b', 'c']], [], [1]), ([['a', 'b', 'c']], [], [2]))</test>
|
|
1067
|
+
<result>
|
|
1068
|
+
<assert-false/>
|
|
1069
|
+
</result>
|
|
1070
|
+
</test-case>
|
|
1071
|
+
|
|
1072
|
+
<test-case name="fn-deep-equal-arrays-17" covers="array-square-constructor fn-deep-equal">
|
|
1073
|
+
<description> Apply deep-equal to a sequence of arrays </description>
|
|
1074
|
+
<created by="Michael Kay" on="2018-09-03"/>
|
|
1075
|
+
<dependency type="spec" value="XP31+ XQ31+"/>
|
|
1076
|
+
<test>fn:deep-equal(([['a', 'b', 'c']], [], [1]), ([['a', 'b', 'c', 'd']], [], [1]))</test>
|
|
1077
|
+
<result>
|
|
1078
|
+
<assert-false/>
|
|
1079
|
+
</result>
|
|
1080
|
+
</test-case>
|
|
1081
|
+
|
|
1082
|
+
<test-case name="fn-deep-equal-arrays-18" covers="array-square-constructor fn-deep-equal">
|
|
1083
|
+
<description> Apply deep-equal to a sequence of arrays, after remove operation </description>
|
|
1084
|
+
<created by="Michael Kay" on="2018-09-03"/>
|
|
1085
|
+
<dependency type="spec" value="XP31+ XQ31+"/>
|
|
1086
|
+
<test>fn:deep-equal(([['a', 'b', 'd'] => array:put(3, 'c')], [], [1]), ([['a', 'b', 'c', 'd'] => array:remove(4)], [], [1]))</test>
|
|
1087
|
+
<result>
|
|
1088
|
+
<assert-true/>
|
|
1089
|
+
</result>
|
|
1090
|
+
</test-case>
|
|
1091
|
+
|
|
1092
|
+
<test-case name="fn-deep-equal-maps-1" covers="map-constructor fn-deep-equal">
|
|
1093
|
+
<description> Map deep-equal to map </description>
|
|
1094
|
+
<created by="Michael Kay" on="2014-10-14"/>
|
|
1095
|
+
<dependency type="spec" value="XP31+ XQ31+"/>
|
|
1096
|
+
<test>fn:deep-equal(map{}, map{})</test>
|
|
1097
|
+
<result>
|
|
1098
|
+
<assert-true/>
|
|
1099
|
+
</result>
|
|
1100
|
+
</test-case>
|
|
1101
|
+
|
|
1102
|
+
<test-case name="fn-deep-equal-maps-2" covers="map-constructor fn-deep-equal">
|
|
1103
|
+
<description> Map deep-equal to map </description>
|
|
1104
|
+
<created by="Michael Kay" on="2014-10-14"/>
|
|
1105
|
+
<dependency type="spec" value="XP31+ XQ31+"/>
|
|
1106
|
+
<test>fn:deep-equal(map{1:2}, map{})</test>
|
|
1107
|
+
<result>
|
|
1108
|
+
<assert-false/>
|
|
1109
|
+
</result>
|
|
1110
|
+
</test-case>
|
|
1111
|
+
|
|
1112
|
+
<test-case name="fn-deep-equal-maps-3" covers="map-constructor fn-deep-equal">
|
|
1113
|
+
<description> Map deep-equal to map </description>
|
|
1114
|
+
<created by="Michael Kay" on="2014-10-14"/>
|
|
1115
|
+
<dependency type="spec" value="XP31+ XQ31+"/>
|
|
1116
|
+
<test>fn:deep-equal(map{}, map{1:()})</test>
|
|
1117
|
+
<result>
|
|
1118
|
+
<assert-false/>
|
|
1119
|
+
</result>
|
|
1120
|
+
</test-case>
|
|
1121
|
+
|
|
1122
|
+
<test-case name="fn-deep-equal-maps-4" covers="map-constructor fn-deep-equal">
|
|
1123
|
+
<description> Map deep-equal to map; order of entries is ignored </description>
|
|
1124
|
+
<created by="Michael Kay" on="2014-10-14"/>
|
|
1125
|
+
<dependency type="spec" value="XP31+ XQ31+"/>
|
|
1126
|
+
<test>fn:deep-equal(map{1:true(), 2:false()}, map{2:false(), 1:true()})</test>
|
|
1127
|
+
<result>
|
|
1128
|
+
<assert-true/>
|
|
1129
|
+
</result>
|
|
1130
|
+
</test-case>
|
|
1131
|
+
|
|
1132
|
+
<test-case name="fn-deep-equal-maps-5" covers="map-constructor fn-deep-equal">
|
|
1133
|
+
<description> Map deep-equal to map; keys differ in type but equal in value </description>
|
|
1134
|
+
<created by="Michael Kay" on="2014-10-14"/>
|
|
1135
|
+
<dependency type="spec" value="XP31+ XQ31+"/>
|
|
1136
|
+
<test>fn:deep-equal(map{1:true()}, map{1.0:true()})</test>
|
|
1137
|
+
<result>
|
|
1138
|
+
<assert-true/>
|
|
1139
|
+
</result>
|
|
1140
|
+
</test-case>
|
|
1141
|
+
|
|
1142
|
+
<test-case name="fn-deep-equal-maps-6" covers="map-constructor fn-deep-equal">
|
|
1143
|
+
<description> Map deep-equal to map; keys differ in type but equal in value </description>
|
|
1144
|
+
<created by="Michael Kay" on="2014-10-14"/>
|
|
1145
|
+
<dependency type="spec" value="XP31+ XQ31+"/>
|
|
1146
|
+
<test>fn:deep-equal(map{1:true()}, map{1.0e0:true()})</test>
|
|
1147
|
+
<result>
|
|
1148
|
+
<assert-true/>
|
|
1149
|
+
</result>
|
|
1150
|
+
</test-case>
|
|
1151
|
+
|
|
1152
|
+
<test-case name="fn-deep-equal-maps-7" covers="map-constructor fn-deep-equal">
|
|
1153
|
+
<description> Map deep-equal to map; NaN keys </description>
|
|
1154
|
+
<created by="Michael Kay" on="2014-10-14"/>
|
|
1155
|
+
<dependency type="spec" value="XP31+ XQ31+"/>
|
|
1156
|
+
<test>fn:deep-equal(map{xs:double('NaN'):true()}, map{xs:double('NaN'):true()})</test>
|
|
1157
|
+
<result>
|
|
1158
|
+
<assert-true/>
|
|
1159
|
+
</result>
|
|
1160
|
+
</test-case>
|
|
1161
|
+
|
|
1162
|
+
<test-case name="fn-deep-equal-maps-8" covers="map-constructor fn-deep-equal">
|
|
1163
|
+
<description> Map deep-equal to map; NaN keys </description>
|
|
1164
|
+
<created by="Michael Kay" on="2014-10-14"/>
|
|
1165
|
+
<dependency type="spec" value="XP31+ XQ31+"/>
|
|
1166
|
+
<test>fn:deep-equal(map{xs:double('NaN'):true()}, map{xs:float('NaN'):true()})</test>
|
|
1167
|
+
<result>
|
|
1168
|
+
<assert-true/>
|
|
1169
|
+
</result>
|
|
1170
|
+
</test-case>
|
|
1171
|
+
|
|
1172
|
+
<test-case name="fn-deep-equal-maps-9" covers="map-constructor array-square-constructor fn-deep-equal">
|
|
1173
|
+
<description> Map deep-equal to map; value is an array </description>
|
|
1174
|
+
<created by="Michael Kay" on="2014-10-14"/>
|
|
1175
|
+
<dependency type="spec" value="XP31+ XQ31+"/>
|
|
1176
|
+
<test>fn:deep-equal(map{12:[1,2,3]}, map{12.0:[1.0, 2.0, 3.0]})</test>
|
|
1177
|
+
<result>
|
|
1178
|
+
<assert-true/>
|
|
1179
|
+
</result>
|
|
1180
|
+
</test-case>
|
|
1181
|
+
|
|
1182
|
+
<test-case name="fn-deep-equal-maps-10" covers="map-constructor array-square-constructor fn-deep-equal">
|
|
1183
|
+
<description> Map deep-equal to map; values are unequal arrays </description>
|
|
1184
|
+
<created by="Michael Kay" on="2014-10-14"/>
|
|
1185
|
+
<dependency type="spec" value="XP31+ XQ31+"/>
|
|
1186
|
+
<test>fn:deep-equal(map{12:[1,2,3]}, map{12:[3,2,1]})</test>
|
|
1187
|
+
<result>
|
|
1188
|
+
<assert-false/>
|
|
1189
|
+
</result>
|
|
1190
|
+
</test-case>
|
|
1191
|
+
|
|
1192
|
+
<test-case name="fn-deep-equal-maps-11" covers="map-constructor array-square-constructor fn-deep-equal">
|
|
1193
|
+
<description> Map deep-equal to map; values are nodes </description>
|
|
1194
|
+
<created by="Michael Kay" on="2014-10-14"/>
|
|
1195
|
+
<dependency type="spec" value="XQ31+"/>
|
|
1196
|
+
<test><![CDATA[
|
|
1197
|
+
fn:deep-equal(map{12:<a x='2' y='3'>23</a>}, map{12:<a y='3' x='2'>23</a>})
|
|
1198
|
+
]]></test>
|
|
1199
|
+
<result>
|
|
1200
|
+
<assert-true/>
|
|
1201
|
+
</result>
|
|
1202
|
+
</test-case>
|
|
1203
|
+
|
|
1204
|
+
<test-case name="fn-deep-equal-maps-12" covers="map-constructor fn-deep-equal">
|
|
1205
|
+
<description> Map deep-equal to map; values are nodes </description>
|
|
1206
|
+
<created by="Michael Kay" on="2014-10-14"/>
|
|
1207
|
+
<dependency type="spec" value="XQ31+"/>
|
|
1208
|
+
<test><![CDATA[
|
|
1209
|
+
fn:deep-equal(map{12:<a x='2' y='3'>23</a>}, map{12:<a y='3' x='2' z='1'>23</a>})
|
|
1210
|
+
]]></test>
|
|
1211
|
+
<result>
|
|
1212
|
+
<assert-false/>
|
|
1213
|
+
</result>
|
|
1214
|
+
</test-case>
|
|
1215
|
+
|
|
1216
|
+
<test-case name="fn-deep-equal-maps-13" covers="map-constructor fn-deep-equal">
|
|
1217
|
+
<description> Map deep-equal to map; collation is not used for comparing keys </description>
|
|
1218
|
+
<created by="Michael Kay" on="2014-10-14"/>
|
|
1219
|
+
<dependency type="spec" value="XP31+ XQ31+"/>
|
|
1220
|
+
<test>
|
|
1221
|
+
fn:deep-equal(map{"a":1}, map{"A":1},
|
|
1222
|
+
'http://www.w3.org/2013/collation/UCA?strength=secondary')
|
|
1223
|
+
</test>
|
|
1224
|
+
<result>
|
|
1225
|
+
<assert-false/>
|
|
1226
|
+
</result>
|
|
1227
|
+
</test-case>
|
|
1228
|
+
|
|
1229
|
+
<test-case name="fn-deep-equal-maps-14" covers="map-constructor fn-deep-equal">
|
|
1230
|
+
<description> Map deep-equal to map; collation is used for comparing values </description>
|
|
1231
|
+
<created by="Michael Kay" on="2014-10-14"/>
|
|
1232
|
+
<dependency type="spec" value="XP31+ XQ31+"/>
|
|
1233
|
+
<test>
|
|
1234
|
+
fn:deep-equal(map{1:"a"}, map{1:"A"},
|
|
1235
|
+
'http://www.w3.org/2013/collation/UCA?strength=secondary')
|
|
1236
|
+
</test>
|
|
1237
|
+
<result>
|
|
1238
|
+
<assert-true/>
|
|
1239
|
+
</result>
|
|
1240
|
+
</test-case>
|
|
1241
|
+
|
|
1242
|
+
<test-case name="fn-deep-equal-maps-15" covers="map-constructor map-remove fn-deep-equal">
|
|
1243
|
+
<description> Map deep-equal to map; after remove operation </description>
|
|
1244
|
+
<created by="Michael Kay" on="2014-10-14"/>
|
|
1245
|
+
<environment ref="map" />
|
|
1246
|
+
<dependency type="spec" value="XP31+ XQ31+"/>
|
|
1247
|
+
<test>
|
|
1248
|
+
fn:deep-equal(map{1:"A"}, map:remove(map{1:"A", 2:"B"}, 2))
|
|
1249
|
+
</test>
|
|
1250
|
+
<result>
|
|
1251
|
+
<assert-true/>
|
|
1252
|
+
</result>
|
|
1253
|
+
</test-case>
|
|
1254
|
+
|
|
1255
|
+
<test-case name="fn-deep-equal-maps-16" covers="map-constructor fn-deep-equal">
|
|
1256
|
+
<description> Map deep-equal to map; effect of implicit timezone </description>
|
|
1257
|
+
<created by="Michael Kay" on="2014-10-14"/>
|
|
1258
|
+
<modified by="Michael Kay" on="2015-07-13" change="spec change on timezone handling in maps"/>
|
|
1259
|
+
<dependency type="spec" value="XP31+ XQ31+"/>
|
|
1260
|
+
<test>
|
|
1261
|
+
let $t := xs:dateTime('2014-10-14T11:31:12') return
|
|
1262
|
+
let $u := adjust-dateTime-to-timezone($t, implicit-timezone()) return
|
|
1263
|
+
fn:deep-equal(map{$t :()}, map{$u :()})
|
|
1264
|
+
</test>
|
|
1265
|
+
<result>
|
|
1266
|
+
<assert-false/>
|
|
1267
|
+
</result>
|
|
1268
|
+
</test-case>
|
|
1269
|
+
|
|
1270
|
+
<test-case name="fn-deep-equal-maps-17" covers="map-constructor fn-deep-equal">
|
|
1271
|
+
<description> Map deep-equal to map; effect of implicit timezone </description>
|
|
1272
|
+
<created by="Michael Kay" on="2014-10-14"/>
|
|
1273
|
+
<dependency type="spec" value="XP31+ XQ31+"/>
|
|
1274
|
+
<test>
|
|
1275
|
+
let $t := xs:dateTime('2014-10-14T11:31:12') return
|
|
1276
|
+
let $u := adjust-dateTime-to-timezone($t, implicit-timezone()+xs:dayTimeDuration('PT1H')) return
|
|
1277
|
+
fn:deep-equal(map{$t :()}, map{$u :()})
|
|
1278
|
+
</test>
|
|
1279
|
+
<result>
|
|
1280
|
+
<assert-false/>
|
|
1281
|
+
</result>
|
|
1282
|
+
</test-case>
|
|
1283
|
+
|
|
1284
|
+
<test-case name="fn-deep-equal-maps-18" covers="map-constructor fn-deep-equal">
|
|
1285
|
+
<description> Sequence of maps deep-equal to a sequence of maps</description>
|
|
1286
|
+
<created by="Michael Kay" on="2018-09-03"/>
|
|
1287
|
+
<dependency type="spec" value="XQ31+"/>
|
|
1288
|
+
<test><![CDATA[
|
|
1289
|
+
fn:deep-equal((map{1:'a', 2:'b'}, map{1:'x', 2:'y'}), (map{2:'b', 1:'a'}, map{2:'y', 1:'x'}))
|
|
1290
|
+
]]></test>
|
|
1291
|
+
<result>
|
|
1292
|
+
<assert-true/>
|
|
1293
|
+
</result>
|
|
1294
|
+
</test-case>
|
|
1295
|
+
|
|
1296
|
+
<test-case name="fn-deep-equal-maps-19" covers="map-constructor fn-deep-equal">
|
|
1297
|
+
<description> Sequence of maps deep-equal to a sequence of maps</description>
|
|
1298
|
+
<created by="Michael Kay" on="2018-09-03"/>
|
|
1299
|
+
<dependency type="spec" value="XQ31+"/>
|
|
1300
|
+
<test><![CDATA[
|
|
1301
|
+
fn:deep-equal((map{1:'a', 2:'b'}, map{1:'x', 2:'y'}), (map{2:'b', 1:'a'}, map{2:'y', 1:'z'}))
|
|
1302
|
+
]]></test>
|
|
1303
|
+
<result>
|
|
1304
|
+
<assert-false/>
|
|
1305
|
+
</result>
|
|
1306
|
+
</test-case>
|
|
1307
|
+
|
|
1308
|
+
<test-case name="fn-deep-equal-maps-20" covers="map-constructor fn-deep-equal">
|
|
1309
|
+
<description> Sequence of maps deep-equal to a sequence of maps</description>
|
|
1310
|
+
<created by="Michael Kay" on="2018-09-03"/>
|
|
1311
|
+
<dependency type="spec" value="XQ31+"/>
|
|
1312
|
+
<test><![CDATA[
|
|
1313
|
+
fn:deep-equal((map{1:'a', 2:'b'}, map{1:'x', 2:'y'}), (map{2:'b', 1:'a'}, map{2:'y', 1:'x'}, map{}))
|
|
1314
|
+
]]></test>
|
|
1315
|
+
<result>
|
|
1316
|
+
<assert-false/>
|
|
1317
|
+
</result>
|
|
1318
|
+
</test-case>
|
|
1319
|
+
|
|
1320
|
+
<test-case name="fn-deep-equal-node-args-3">
|
|
1321
|
+
<description> Apply deep-equal to nodes </description>
|
|
1322
|
+
<created by="Andrew Eisenberg" on="2006-09-25"/>
|
|
1323
|
+
<environment ref="bib"/>
|
|
1324
|
+
<dependency type="spec" value="XQ10+"/>
|
|
1325
|
+
<test><![CDATA[fn:deep-equal(<a> {/node(), /node()} </a>/node(), <b> {/node(), 'difference', /node()} </b>/node() )]]></test>
|
|
1326
|
+
<result>
|
|
1327
|
+
<assert-false/>
|
|
1328
|
+
</result>
|
|
1329
|
+
</test-case>
|
|
1330
|
+
|
|
1331
|
+
<test-case name="fn-deep-equal-node-args-4">
|
|
1332
|
+
<description> Apply deep-equal to nodes </description>
|
|
1333
|
+
<created by="Andrew Eisenberg" on="2006-09-25"/>
|
|
1334
|
+
<environment ref="bib"/>
|
|
1335
|
+
<dependency type="spec" value="XQ10+"/>
|
|
1336
|
+
<test><![CDATA[fn:deep-equal(<a> {/node(), <diff x='1'/>, /node()} </a>/node(), <b> {/node(), <diff x='2'/>, /node()} </b>/node() )]]></test>
|
|
1337
|
+
<result>
|
|
1338
|
+
<assert-false/>
|
|
1339
|
+
</result>
|
|
1340
|
+
</test-case>
|
|
1341
|
+
|
|
1342
|
+
<test-case name="fn-deep-equal-node-args-5">
|
|
1343
|
+
<description> Apply deep-equal to nodes </description>
|
|
1344
|
+
<created by="Andrew Eisenberg" on="2006-09-25"/>
|
|
1345
|
+
<environment ref="bib"/>
|
|
1346
|
+
<dependency type="spec" value="XQ10+"/>
|
|
1347
|
+
<test><![CDATA[fn:deep-equal(<a> {/node(), <diff x='1'/>, /node()} </a>/node(), <b> {/node(), <diff xx='1'/>, /node()} </b>/node() )]]></test>
|
|
1348
|
+
<result>
|
|
1349
|
+
<assert-false/>
|
|
1350
|
+
</result>
|
|
1351
|
+
</test-case>
|
|
1352
|
+
|
|
1353
|
+
<test-case name="K-SeqDeepEqualFunc-1">
|
|
1354
|
+
<description> A test whose essence is: `deep-equal()`. </description>
|
|
1355
|
+
<created by="Frans Englich" on="2007-11-26"/>
|
|
1356
|
+
<test>deep-equal()</test>
|
|
1357
|
+
<result>
|
|
1358
|
+
<error code="XPST0017"/>
|
|
1359
|
+
</result>
|
|
1360
|
+
</test-case>
|
|
1361
|
+
|
|
1362
|
+
<test-case name="K-SeqDeepEqualFunc-2">
|
|
1363
|
+
<description> A test whose essence is: `deep-equal("a string")`. </description>
|
|
1364
|
+
<created by="Frans Englich" on="2007-11-26"/>
|
|
1365
|
+
<test>deep-equal("a string")</test>
|
|
1366
|
+
<result>
|
|
1367
|
+
<error code="XPST0017"/>
|
|
1368
|
+
</result>
|
|
1369
|
+
</test-case>
|
|
1370
|
+
|
|
1371
|
+
<test-case name="K-SeqDeepEqualFunc-3">
|
|
1372
|
+
<description> A test whose essence is: `deep-equal("a string", "a string", "http://www.w3.org/2005/xpath-functions/collation/codepoint", "wrong param")`. </description>
|
|
1373
|
+
<created by="Frans Englich" on="2007-11-26"/>
|
|
1374
|
+
<test>deep-equal("a string", "a string", "http://www.w3.org/2005/xpath-functions/collation/codepoint", "wrong param")</test>
|
|
1375
|
+
<result>
|
|
1376
|
+
<error code="XPST0017"/>
|
|
1377
|
+
</result>
|
|
1378
|
+
</test-case>
|
|
1379
|
+
|
|
1380
|
+
<test-case name="K-SeqDeepEqualFunc-4">
|
|
1381
|
+
<description> A test whose essence is: `deep-equal("a string", "a string", "http://www.example.com/COLLATION/NOT/SUPPORTED")`. </description>
|
|
1382
|
+
<created by="Frans Englich" on="2007-11-26"/>
|
|
1383
|
+
<modified by="Christian Gruen" on="2020-08-11" change="Identical arguments will never yield false"/>
|
|
1384
|
+
<test>deep-equal("a string", "a string", "http://www.example.com/COLLATION/NOT/SUPPORTED")</test>
|
|
1385
|
+
<result>
|
|
1386
|
+
<any-of>
|
|
1387
|
+
<assert-string-value>true</assert-string-value>
|
|
1388
|
+
<error code="FOCH0002"/>
|
|
1389
|
+
</any-of>
|
|
1390
|
+
</result>
|
|
1391
|
+
</test-case>
|
|
1392
|
+
|
|
1393
|
+
<test-case name="K-SeqDeepEqualFunc-5">
|
|
1394
|
+
<description> A test whose essence is: `deep-equal("a string", "a string", ())`. </description>
|
|
1395
|
+
<created by="Frans Englich" on="2007-11-26"/>
|
|
1396
|
+
<modified by="Christian Gruen" on="2020-08-11" change="Identical arguments will never yield false"/>
|
|
1397
|
+
<test>deep-equal("a string", "a string", ())</test>
|
|
1398
|
+
<result>
|
|
1399
|
+
<any-of>
|
|
1400
|
+
<assert-string-value>true</assert-string-value>
|
|
1401
|
+
<error code="XPTY0004"/>
|
|
1402
|
+
</any-of>
|
|
1403
|
+
</result>
|
|
1404
|
+
</test-case>
|
|
1405
|
+
|
|
1406
|
+
<test-case name="K-SeqDeepEqualFunc-6">
|
|
1407
|
+
<description> A test whose essence is: `deep-equal("a string", "a string", "http://www.w3.org/2005/xpath-functions/collation/codepoint")`. </description>
|
|
1408
|
+
<created by="Frans Englich" on="2007-11-26"/>
|
|
1409
|
+
<test>deep-equal("a string", "a string", "http://www.w3.org/2005/xpath-functions/collation/codepoint")</test>
|
|
1410
|
+
<result>
|
|
1411
|
+
<assert-true/>
|
|
1412
|
+
</result>
|
|
1413
|
+
</test-case>
|
|
1414
|
+
|
|
1415
|
+
<test-case name="K-SeqDeepEqualFunc-7">
|
|
1416
|
+
<description> A test whose essence is: `deep-equal((), ()) eq true()`. </description>
|
|
1417
|
+
<created by="Frans Englich" on="2007-11-26"/>
|
|
1418
|
+
<test>deep-equal((), ()) eq true()</test>
|
|
1419
|
+
<result>
|
|
1420
|
+
<assert-true/>
|
|
1421
|
+
</result>
|
|
1422
|
+
</test-case>
|
|
1423
|
+
|
|
1424
|
+
<test-case name="K-SeqDeepEqualFunc-8">
|
|
1425
|
+
<description> A test whose essence is: `deep-equal(xs:float("NaN"), xs:float("NaN"))`. </description>
|
|
1426
|
+
<created by="Frans Englich" on="2007-11-26"/>
|
|
1427
|
+
<test>deep-equal(xs:float("NaN"), xs:float("NaN"))</test>
|
|
1428
|
+
<result>
|
|
1429
|
+
<assert-true/>
|
|
1430
|
+
</result>
|
|
1431
|
+
</test-case>
|
|
1432
|
+
|
|
1433
|
+
<test-case name="K-SeqDeepEqualFunc-9">
|
|
1434
|
+
<description> A test whose essence is: `deep-equal(xs:double("NaN"), xs:double("NaN"))`. </description>
|
|
1435
|
+
<created by="Frans Englich" on="2007-11-26"/>
|
|
1436
|
+
<test>deep-equal(xs:double("NaN"), xs:double("NaN"))</test>
|
|
1437
|
+
<result>
|
|
1438
|
+
<assert-true/>
|
|
1439
|
+
</result>
|
|
1440
|
+
</test-case>
|
|
1441
|
+
|
|
1442
|
+
<test-case name="K-SeqDeepEqualFunc-10">
|
|
1443
|
+
<description> A test whose essence is: `deep-equal(xs:float("NaN"), xs:double("NaN"))`. </description>
|
|
1444
|
+
<created by="Frans Englich" on="2007-11-26"/>
|
|
1445
|
+
<test>deep-equal(xs:float("NaN"), xs:double("NaN"))</test>
|
|
1446
|
+
<result>
|
|
1447
|
+
<assert-true/>
|
|
1448
|
+
</result>
|
|
1449
|
+
</test-case>
|
|
1450
|
+
|
|
1451
|
+
<test-case name="K-SeqDeepEqualFunc-11">
|
|
1452
|
+
<description> A test whose essence is: `deep-equal(xs:double("NaN"), xs:float("NaN"))`. </description>
|
|
1453
|
+
<created by="Frans Englich" on="2007-11-26"/>
|
|
1454
|
+
<test>deep-equal(xs:double("NaN"), xs:float("NaN"))</test>
|
|
1455
|
+
<result>
|
|
1456
|
+
<assert-true/>
|
|
1457
|
+
</result>
|
|
1458
|
+
</test-case>
|
|
1459
|
+
|
|
1460
|
+
<test-case name="K-SeqDeepEqualFunc-12">
|
|
1461
|
+
<description> A test whose essence is: `not(deep-equal(xs:float("NaN"), xs:float(0)))`. </description>
|
|
1462
|
+
<created by="Frans Englich" on="2007-11-26"/>
|
|
1463
|
+
<test>not(deep-equal(xs:float("NaN"), xs:float(0)))</test>
|
|
1464
|
+
<result>
|
|
1465
|
+
<assert-true/>
|
|
1466
|
+
</result>
|
|
1467
|
+
</test-case>
|
|
1468
|
+
|
|
1469
|
+
<test-case name="K-SeqDeepEqualFunc-13">
|
|
1470
|
+
<description> A test whose essence is: `not(deep-equal(xs:float(0), xs:float("NaN")))`. </description>
|
|
1471
|
+
<created by="Frans Englich" on="2007-11-26"/>
|
|
1472
|
+
<test>not(deep-equal(xs:float(0), xs:float("NaN")))</test>
|
|
1473
|
+
<result>
|
|
1474
|
+
<assert-true/>
|
|
1475
|
+
</result>
|
|
1476
|
+
</test-case>
|
|
1477
|
+
|
|
1478
|
+
<test-case name="K-SeqDeepEqualFunc-14">
|
|
1479
|
+
<description> A test whose essence is: `not(deep-equal(xs:double(0), xs:double("NaN")))`. </description>
|
|
1480
|
+
<created by="Frans Englich" on="2007-11-26"/>
|
|
1481
|
+
<test>not(deep-equal(xs:double(0), xs:double("NaN")))</test>
|
|
1482
|
+
<result>
|
|
1483
|
+
<assert-true/>
|
|
1484
|
+
</result>
|
|
1485
|
+
</test-case>
|
|
1486
|
+
|
|
1487
|
+
<test-case name="K-SeqDeepEqualFunc-15">
|
|
1488
|
+
<description> A test whose essence is: `not(deep-equal(xs:double("NaN"), xs:double(0)))`. </description>
|
|
1489
|
+
<created by="Frans Englich" on="2007-11-26"/>
|
|
1490
|
+
<test>not(deep-equal(xs:double("NaN"), xs:double(0)))</test>
|
|
1491
|
+
<result>
|
|
1492
|
+
<assert-true/>
|
|
1493
|
+
</result>
|
|
1494
|
+
</test-case>
|
|
1495
|
+
|
|
1496
|
+
<test-case name="K-SeqDeepEqualFunc-16">
|
|
1497
|
+
<description> A test whose essence is: `not(deep-equal(xs:decimal("1"), xs:anyURI("example.com")))`. </description>
|
|
1498
|
+
<created by="Frans Englich" on="2007-11-26"/>
|
|
1499
|
+
<test>not(deep-equal(xs:decimal("1"), xs:anyURI("example.com")))</test>
|
|
1500
|
+
<result>
|
|
1501
|
+
<assert-true/>
|
|
1502
|
+
</result>
|
|
1503
|
+
</test-case>
|
|
1504
|
+
|
|
1505
|
+
<test-case name="K-SeqDeepEqualFunc-17">
|
|
1506
|
+
<description> A test whose essence is: `not(deep-equal(QName("example.com", "ncname"), 3e2))`. </description>
|
|
1507
|
+
<created by="Frans Englich" on="2007-11-26"/>
|
|
1508
|
+
<test>not(deep-equal(QName("example.com", "ncname"), 3e2))</test>
|
|
1509
|
+
<result>
|
|
1510
|
+
<assert-true/>
|
|
1511
|
+
</result>
|
|
1512
|
+
</test-case>
|
|
1513
|
+
|
|
1514
|
+
<test-case name="K-SeqDeepEqualFunc-18">
|
|
1515
|
+
<description> A test whose essence is: `not(deep-equal((1, 2, xs:anyURI("example.com")), (1, 2, 3)))`. </description>
|
|
1516
|
+
<created by="Frans Englich" on="2007-11-26"/>
|
|
1517
|
+
<test>not(deep-equal((1, 2, xs:anyURI("example.com")), (1, 2, 3)))</test>
|
|
1518
|
+
<result>
|
|
1519
|
+
<assert-true/>
|
|
1520
|
+
</result>
|
|
1521
|
+
</test-case>
|
|
1522
|
+
|
|
1523
|
+
<test-case name="K-SeqDeepEqualFunc-19">
|
|
1524
|
+
<description> A test whose essence is: `not(deep-equal((1, xs:decimal("2.2"), 3), (1, 2, 3)))`. </description>
|
|
1525
|
+
<created by="Frans Englich" on="2007-11-26"/>
|
|
1526
|
+
<test>not(deep-equal((1, xs:decimal("2.2"), 3), (1, 2, 3)))</test>
|
|
1527
|
+
<result>
|
|
1528
|
+
<assert-true/>
|
|
1529
|
+
</result>
|
|
1530
|
+
</test-case>
|
|
1531
|
+
|
|
1532
|
+
<test-case name="K-SeqDeepEqualFunc-20">
|
|
1533
|
+
<description> A test whose essence is: `not(deep-equal((true(), 2, 3), (1, 2, 3)))`. </description>
|
|
1534
|
+
<created by="Frans Englich" on="2007-11-26"/>
|
|
1535
|
+
<test>not(deep-equal((true(), 2, 3), (1, 2, 3)))</test>
|
|
1536
|
+
<result>
|
|
1537
|
+
<assert-true/>
|
|
1538
|
+
</result>
|
|
1539
|
+
</test-case>
|
|
1540
|
+
|
|
1541
|
+
<test-case name="K-SeqDeepEqualFunc-21">
|
|
1542
|
+
<description> A test whose essence is: `not(deep-equal((1, 2, 3), (1, 2, QName("example.com", "ncname"))))`. </description>
|
|
1543
|
+
<created by="Frans Englich" on="2007-11-26"/>
|
|
1544
|
+
<test>not(deep-equal((1, 2, 3), (1, 2, QName("example.com", "ncname"))))</test>
|
|
1545
|
+
<result>
|
|
1546
|
+
<assert-true/>
|
|
1547
|
+
</result>
|
|
1548
|
+
</test-case>
|
|
1549
|
+
|
|
1550
|
+
<test-case name="K-SeqDeepEqualFunc-22">
|
|
1551
|
+
<description> A test whose essence is: `not(deep-equal((1, 2, 3), (1, xs:hexBinary("FF"), 3)))`. </description>
|
|
1552
|
+
<created by="Frans Englich" on="2007-11-26"/>
|
|
1553
|
+
<test>not(deep-equal((1, 2, 3), (1, xs:hexBinary("FF"), 3)))</test>
|
|
1554
|
+
<result>
|
|
1555
|
+
<assert-true/>
|
|
1556
|
+
</result>
|
|
1557
|
+
</test-case>
|
|
1558
|
+
|
|
1559
|
+
<test-case name="K-SeqDeepEqualFunc-23">
|
|
1560
|
+
<description> A test whose essence is: `not(deep-equal((1, 2, 3), (xs:base64Binary("FFFF"), 2, 3)))`. </description>
|
|
1561
|
+
<created by="Frans Englich" on="2007-11-26"/>
|
|
1562
|
+
<test>not(deep-equal((1, 2, 3), (xs:base64Binary("FFFF"), 2, 3)))</test>
|
|
1563
|
+
<result>
|
|
1564
|
+
<assert-true/>
|
|
1565
|
+
</result>
|
|
1566
|
+
</test-case>
|
|
1567
|
+
|
|
1568
|
+
<test-case name="K-SeqDeepEqualFunc-24">
|
|
1569
|
+
<description> A test whose essence is: `deep-equal((1, 2, xs:base64Binary("FFFF")), (1, 2, xs:base64Binary("FFFF")))`. </description>
|
|
1570
|
+
<created by="Frans Englich" on="2007-11-26"/>
|
|
1571
|
+
<test>deep-equal((1, 2, xs:base64Binary("FFFF")), (1, 2, xs:base64Binary("FFFF")))</test>
|
|
1572
|
+
<result>
|
|
1573
|
+
<assert-true/>
|
|
1574
|
+
</result>
|
|
1575
|
+
</test-case>
|
|
1576
|
+
|
|
1577
|
+
<test-case name="K-SeqDeepEqualFunc-25">
|
|
1578
|
+
<description> A test whose essence is: `deep-equal((1, 1, 1), (1, 1, 1))`. </description>
|
|
1579
|
+
<created by="Frans Englich" on="2007-11-26"/>
|
|
1580
|
+
<test>deep-equal((1, 1, 1), (1, 1, 1))</test>
|
|
1581
|
+
<result>
|
|
1582
|
+
<assert-true/>
|
|
1583
|
+
</result>
|
|
1584
|
+
</test-case>
|
|
1585
|
+
|
|
1586
|
+
<test-case name="K-SeqDeepEqualFunc-26">
|
|
1587
|
+
<description> A test whose essence is: `not(deep-equal((1, 1, 3), (1, 1, 1)))`. </description>
|
|
1588
|
+
<created by="Frans Englich" on="2007-11-26"/>
|
|
1589
|
+
<test>not(deep-equal((1, 1, 3), (1, 1, 1)))</test>
|
|
1590
|
+
<result>
|
|
1591
|
+
<assert-true/>
|
|
1592
|
+
</result>
|
|
1593
|
+
</test-case>
|
|
1594
|
+
|
|
1595
|
+
<test-case name="K-SeqDeepEqualFunc-27">
|
|
1596
|
+
<description> A test whose essence is: `not(deep-equal((1, 3, 1), (1, 1, 1)))`. </description>
|
|
1597
|
+
<created by="Frans Englich" on="2007-11-26"/>
|
|
1598
|
+
<test>not(deep-equal((1, 3, 1), (1, 1, 1)))</test>
|
|
1599
|
+
<result>
|
|
1600
|
+
<assert-true/>
|
|
1601
|
+
</result>
|
|
1602
|
+
</test-case>
|
|
1603
|
+
|
|
1604
|
+
<test-case name="K-SeqDeepEqualFunc-28">
|
|
1605
|
+
<description> A test whose essence is: `not(deep-equal((3, 1, 1), (1, 1, 1)))`. </description>
|
|
1606
|
+
<created by="Frans Englich" on="2007-11-26"/>
|
|
1607
|
+
<test>not(deep-equal((3, 1, 1), (1, 1, 1)))</test>
|
|
1608
|
+
<result>
|
|
1609
|
+
<assert-true/>
|
|
1610
|
+
</result>
|
|
1611
|
+
</test-case>
|
|
1612
|
+
|
|
1613
|
+
<test-case name="K-SeqDeepEqualFunc-29">
|
|
1614
|
+
<description> A test whose essence is: `not(deep-equal((1, 1, 1), (3, 1, 1)))`. </description>
|
|
1615
|
+
<created by="Frans Englich" on="2007-11-26"/>
|
|
1616
|
+
<test>not(deep-equal((1, 1, 1), (3, 1, 1)))</test>
|
|
1617
|
+
<result>
|
|
1618
|
+
<assert-true/>
|
|
1619
|
+
</result>
|
|
1620
|
+
</test-case>
|
|
1621
|
+
|
|
1622
|
+
<test-case name="K-SeqDeepEqualFunc-30">
|
|
1623
|
+
<description> A test whose essence is: `not(deep-equal((1, 1, 1), (1, 3, 1)))`. </description>
|
|
1624
|
+
<created by="Frans Englich" on="2007-11-26"/>
|
|
1625
|
+
<test>not(deep-equal((1, 1, 1), (1, 3, 1)))</test>
|
|
1626
|
+
<result>
|
|
1627
|
+
<assert-true/>
|
|
1628
|
+
</result>
|
|
1629
|
+
</test-case>
|
|
1630
|
+
|
|
1631
|
+
<test-case name="K-SeqDeepEqualFunc-31">
|
|
1632
|
+
<description> A test whose essence is: `not(deep-equal((1, 1, 1), (1, 1, 3)))`. </description>
|
|
1633
|
+
<created by="Frans Englich" on="2007-11-26"/>
|
|
1634
|
+
<test>not(deep-equal((1, 1, 1), (1, 1, 3)))</test>
|
|
1635
|
+
<result>
|
|
1636
|
+
<assert-true/>
|
|
1637
|
+
</result>
|
|
1638
|
+
</test-case>
|
|
1639
|
+
|
|
1640
|
+
<test-case name="K-SeqDeepEqualFunc-32">
|
|
1641
|
+
<description> A test whose essence is: `deep-equal(index-of(20, 20), (1))`. </description>
|
|
1642
|
+
<created by="Frans Englich" on="2007-11-26"/>
|
|
1643
|
+
<test>deep-equal(index-of(20, 20), (1))</test>
|
|
1644
|
+
<result>
|
|
1645
|
+
<assert-true/>
|
|
1646
|
+
</result>
|
|
1647
|
+
</test-case>
|
|
1648
|
+
|
|
1649
|
+
<test-case name="K-SeqDeepEqualFunc-33">
|
|
1650
|
+
<description> A test whose essence is: `deep-equal(index-of((20, 40), 20), (1))`. </description>
|
|
1651
|
+
<created by="Frans Englich" on="2007-11-26"/>
|
|
1652
|
+
<test>deep-equal(index-of((20, 40), 20), (1))</test>
|
|
1653
|
+
<result>
|
|
1654
|
+
<assert-true/>
|
|
1655
|
+
</result>
|
|
1656
|
+
</test-case>
|
|
1657
|
+
|
|
1658
|
+
<test-case name="K-SeqDeepEqualFunc-34">
|
|
1659
|
+
<description> A test whose essence is: `deep-equal(index-of((20, 20), 20), (1, 2))`. </description>
|
|
1660
|
+
<created by="Frans Englich" on="2007-11-26"/>
|
|
1661
|
+
<test>deep-equal(index-of((20, 20), 20), (1, 2))</test>
|
|
1662
|
+
<result>
|
|
1663
|
+
<assert-true/>
|
|
1664
|
+
</result>
|
|
1665
|
+
</test-case>
|
|
1666
|
+
|
|
1667
|
+
<test-case name="K-SeqDeepEqualFunc-35">
|
|
1668
|
+
<description> A test whose essence is: `deep-equal(index-of((20, 40, 20), 20), (1, 3))`. </description>
|
|
1669
|
+
<created by="Frans Englich" on="2007-11-26"/>
|
|
1670
|
+
<test>deep-equal(index-of((20, 40, 20), 20), (1, 3))</test>
|
|
1671
|
+
<result>
|
|
1672
|
+
<assert-true/>
|
|
1673
|
+
</result>
|
|
1674
|
+
</test-case>
|
|
1675
|
+
|
|
1676
|
+
<test-case name="K-SeqDeepEqualFunc-36">
|
|
1677
|
+
<description> A test whose essence is: `deep-equal((1, 1, "str"), (1, 1, "str"))`. </description>
|
|
1678
|
+
<created by="Frans Englich" on="2007-11-26"/>
|
|
1679
|
+
<test>deep-equal((1, 1, "str"), (1, 1, "str"))</test>
|
|
1680
|
+
<result>
|
|
1681
|
+
<assert-true/>
|
|
1682
|
+
</result>
|
|
1683
|
+
</test-case>
|
|
1684
|
+
|
|
1685
|
+
<test-case name="K-SeqDeepEqualFunc-37">
|
|
1686
|
+
<description> A test whose essence is: `deep-equal((1, "str", 1), (1, "str", 1))`. </description>
|
|
1687
|
+
<created by="Frans Englich" on="2007-11-26"/>
|
|
1688
|
+
<test>deep-equal((1, "str", 1), (1, "str", 1))</test>
|
|
1689
|
+
<result>
|
|
1690
|
+
<assert-true/>
|
|
1691
|
+
</result>
|
|
1692
|
+
</test-case>
|
|
1693
|
+
|
|
1694
|
+
<test-case name="K-SeqDeepEqualFunc-38">
|
|
1695
|
+
<description> A test whose essence is: `deep-equal(("str", 1, 1), ("str", 1, 1))`. </description>
|
|
1696
|
+
<created by="Frans Englich" on="2007-11-26"/>
|
|
1697
|
+
<test>deep-equal(("str", 1, 1), ("str", 1, 1))</test>
|
|
1698
|
+
<result>
|
|
1699
|
+
<assert-true/>
|
|
1700
|
+
</result>
|
|
1701
|
+
</test-case>
|
|
1702
|
+
|
|
1703
|
+
<test-case name="K-SeqDeepEqualFunc-39">
|
|
1704
|
+
<description> A test whose essence is: `deep-equal((1, 1, ()), (1, 1, ()))`. </description>
|
|
1705
|
+
<created by="Frans Englich" on="2007-11-26"/>
|
|
1706
|
+
<test>deep-equal((1, 1, ()), (1, 1, ()))</test>
|
|
1707
|
+
<result>
|
|
1708
|
+
<assert-true/>
|
|
1709
|
+
</result>
|
|
1710
|
+
</test-case>
|
|
1711
|
+
|
|
1712
|
+
<test-case name="K-SeqDeepEqualFunc-40">
|
|
1713
|
+
<description> A test whose essence is: `deep-equal((1, (), 1), (1, (), 1))`. </description>
|
|
1714
|
+
<created by="Frans Englich" on="2007-11-26"/>
|
|
1715
|
+
<test>deep-equal((1, (), 1), (1, (), 1))</test>
|
|
1716
|
+
<result>
|
|
1717
|
+
<assert-true/>
|
|
1718
|
+
</result>
|
|
1719
|
+
</test-case>
|
|
1720
|
+
|
|
1721
|
+
<test-case name="K-SeqDeepEqualFunc-41">
|
|
1722
|
+
<description> A test whose essence is: `deep-equal(((), 1, 1), ((), 1, 1))`. </description>
|
|
1723
|
+
<created by="Frans Englich" on="2007-11-26"/>
|
|
1724
|
+
<test>deep-equal(((), 1, 1), ((), 1, 1))</test>
|
|
1725
|
+
<result>
|
|
1726
|
+
<assert-true/>
|
|
1727
|
+
</result>
|
|
1728
|
+
</test-case>
|
|
1729
|
+
|
|
1730
|
+
<test-case name="K-SeqDeepEqualFunc-42">
|
|
1731
|
+
<description> A test whose essence is: `not(deep-equal((1, 1, ()), (1, 1, 1)))`. </description>
|
|
1732
|
+
<created by="Frans Englich" on="2007-11-26"/>
|
|
1733
|
+
<test>not(deep-equal((1, 1, ()), (1, 1, 1)))</test>
|
|
1734
|
+
<result>
|
|
1735
|
+
<assert-true/>
|
|
1736
|
+
</result>
|
|
1737
|
+
</test-case>
|
|
1738
|
+
|
|
1739
|
+
<test-case name="K-SeqDeepEqualFunc-43">
|
|
1740
|
+
<description> A test whose essence is: `not(deep-equal((1, (), 1), (1, 1, 1)))`. </description>
|
|
1741
|
+
<created by="Frans Englich" on="2007-11-26"/>
|
|
1742
|
+
<test>not(deep-equal((1, (), 1), (1, 1, 1)))</test>
|
|
1743
|
+
<result>
|
|
1744
|
+
<assert-true/>
|
|
1745
|
+
</result>
|
|
1746
|
+
</test-case>
|
|
1747
|
+
|
|
1748
|
+
<test-case name="K-SeqDeepEqualFunc-44">
|
|
1749
|
+
<description> A test whose essence is: `not(deep-equal(((), 1, 1), (1, 1, 1)))`. </description>
|
|
1750
|
+
<created by="Frans Englich" on="2007-11-26"/>
|
|
1751
|
+
<test>not(deep-equal(((), 1, 1), (1, 1, 1)))</test>
|
|
1752
|
+
<result>
|
|
1753
|
+
<assert-true/>
|
|
1754
|
+
</result>
|
|
1755
|
+
</test-case>
|
|
1756
|
+
|
|
1757
|
+
<test-case name="K-SeqDeepEqualFunc-45">
|
|
1758
|
+
<description> A test whose essence is: `not(deep-equal((1, 1, 1), (1, 1, ())))`. </description>
|
|
1759
|
+
<created by="Frans Englich" on="2007-11-26"/>
|
|
1760
|
+
<test>not(deep-equal((1, 1, 1), (1, 1, ())))</test>
|
|
1761
|
+
<result>
|
|
1762
|
+
<assert-true/>
|
|
1763
|
+
</result>
|
|
1764
|
+
</test-case>
|
|
1765
|
+
|
|
1766
|
+
<test-case name="K-SeqDeepEqualFunc-46">
|
|
1767
|
+
<description> A test whose essence is: `not(deep-equal((1, 1, 1), (1, (), 1)))`. </description>
|
|
1768
|
+
<created by="Frans Englich" on="2007-11-26"/>
|
|
1769
|
+
<test>not(deep-equal((1, 1, 1), (1, (), 1)))</test>
|
|
1770
|
+
<result>
|
|
1771
|
+
<assert-true/>
|
|
1772
|
+
</result>
|
|
1773
|
+
</test-case>
|
|
1774
|
+
|
|
1775
|
+
<test-case name="K-SeqDeepEqualFunc-47">
|
|
1776
|
+
<description> A test whose essence is: `not(deep-equal((1, 1, 1), ((), 1, 1)))`. </description>
|
|
1777
|
+
<created by="Frans Englich" on="2007-11-26"/>
|
|
1778
|
+
<test>not(deep-equal((1, 1, 1), ((), 1, 1)))</test>
|
|
1779
|
+
<result>
|
|
1780
|
+
<assert-true/>
|
|
1781
|
+
</result>
|
|
1782
|
+
</test-case>
|
|
1783
|
+
|
|
1784
|
+
<test-case name="K-SeqDeepEqualFunc-48">
|
|
1785
|
+
<description> A test whose essence is: `not(deep-equal((1, 1), (1, 1, 1)))`. </description>
|
|
1786
|
+
<created by="Frans Englich" on="2007-11-26"/>
|
|
1787
|
+
<test>not(deep-equal((1, 1), (1, 1, 1)))</test>
|
|
1788
|
+
<result>
|
|
1789
|
+
<assert-true/>
|
|
1790
|
+
</result>
|
|
1791
|
+
</test-case>
|
|
1792
|
+
|
|
1793
|
+
<test-case name="K-SeqDeepEqualFunc-49">
|
|
1794
|
+
<description> A test whose essence is: `not(deep-equal((1, 1, 1), (1, 1)))`. </description>
|
|
1795
|
+
<created by="Frans Englich" on="2007-11-26"/>
|
|
1796
|
+
<test>not(deep-equal((1, 1, 1), (1, 1)))</test>
|
|
1797
|
+
<result>
|
|
1798
|
+
<assert-true/>
|
|
1799
|
+
</result>
|
|
1800
|
+
</test-case>
|
|
1801
|
+
|
|
1802
|
+
<test-case name="K-SeqDeepEqualFunc-50">
|
|
1803
|
+
<description> A test whose essence is: `not(deep-equal((), (1, 1, 1)))`. </description>
|
|
1804
|
+
<created by="Frans Englich" on="2007-11-26"/>
|
|
1805
|
+
<test>not(deep-equal((), (1, 1, 1)))</test>
|
|
1806
|
+
<result>
|
|
1807
|
+
<assert-true/>
|
|
1808
|
+
</result>
|
|
1809
|
+
</test-case>
|
|
1810
|
+
|
|
1811
|
+
<test-case name="K-SeqDeepEqualFunc-51">
|
|
1812
|
+
<description> A test whose essence is: `not(deep-equal((1, 1, 1), ()))`. </description>
|
|
1813
|
+
<created by="Frans Englich" on="2007-11-26"/>
|
|
1814
|
+
<test>not(deep-equal((1, 1, 1), ()))</test>
|
|
1815
|
+
<result>
|
|
1816
|
+
<assert-true/>
|
|
1817
|
+
</result>
|
|
1818
|
+
</test-case>
|
|
1819
|
+
|
|
1820
|
+
<test-case name="K-SeqDeepEqualFunc-52">
|
|
1821
|
+
<description> A test whose essence is: `deep-equal((), reverse(0 to -5))`. </description>
|
|
1822
|
+
<created by="Frans Englich" on="2007-11-26"/>
|
|
1823
|
+
<test>deep-equal((), reverse(0 to -5))</test>
|
|
1824
|
+
<result>
|
|
1825
|
+
<assert-true/>
|
|
1826
|
+
</result>
|
|
1827
|
+
</test-case>
|
|
1828
|
+
|
|
1829
|
+
<test-case name="K-SeqDeepEqualFunc-53">
|
|
1830
|
+
<description> A test whose essence is: `deep-equal((), 0 to -5)`. </description>
|
|
1831
|
+
<created by="Frans Englich" on="2007-11-26"/>
|
|
1832
|
+
<test>deep-equal((), 0 to -5)</test>
|
|
1833
|
+
<result>
|
|
1834
|
+
<assert-true/>
|
|
1835
|
+
</result>
|
|
1836
|
+
</test-case>
|
|
1837
|
+
|
|
1838
|
+
<test-case name="K-SeqDeepEqualFunc-54">
|
|
1839
|
+
<description> A test whose essence is: `deep-equal(reverse(0 to -5), ())`. </description>
|
|
1840
|
+
<created by="Frans Englich" on="2007-11-26"/>
|
|
1841
|
+
<test>deep-equal(reverse(0 to -5), ())</test>
|
|
1842
|
+
<result>
|
|
1843
|
+
<assert-true/>
|
|
1844
|
+
</result>
|
|
1845
|
+
</test-case>
|
|
1846
|
+
|
|
1847
|
+
<test-case name="K-SeqDeepEqualFunc-55">
|
|
1848
|
+
<description> A test whose essence is: `deep-equal(0 to -5, ())`. </description>
|
|
1849
|
+
<created by="Frans Englich" on="2007-11-26"/>
|
|
1850
|
+
<test>deep-equal(0 to -5, ())</test>
|
|
1851
|
+
<result>
|
|
1852
|
+
<assert-true/>
|
|
1853
|
+
</result>
|
|
1854
|
+
</test-case>
|
|
1855
|
+
|
|
1856
|
+
<test-case name="K-SeqDeepEqualFunc-56">
|
|
1857
|
+
<description>Use case-blind collation, if supported</description>
|
|
1858
|
+
<created by="Michael Kay" on="2012-05-30"/>
|
|
1859
|
+
<modified by="O'Neil Delpratt" on="2013-08-02" change="Added feature dependency - Fix to bug issue #22423" />
|
|
1860
|
+
<environment>
|
|
1861
|
+
<collation uri="http://www.w3.org/2010/09/qt-fots-catalog/collation/caseblind"/>
|
|
1862
|
+
</environment>
|
|
1863
|
+
<dependency type="feature" value="non_unicode_codepoint_collation"/>
|
|
1864
|
+
<test>deep-equal(("a", "A"), ("A", "a"), "http://www.w3.org/2010/09/qt-fots-catalog/collation/caseblind")</test>
|
|
1865
|
+
<result>
|
|
1866
|
+
<assert-true/>
|
|
1867
|
+
</result>
|
|
1868
|
+
</test-case>
|
|
1869
|
+
|
|
1870
|
+
<test-case name="K-SeqDeepEqualFunc-57">
|
|
1871
|
+
<description>Use case-blind collation, if supported</description>
|
|
1872
|
+
<created by="Michael Kay" on="2012-05-30"/>
|
|
1873
|
+
<modified by="O'Neil Delpratt" on="2013-08-02" change="Added feature dependency - Fix to bug issue #22423" />
|
|
1874
|
+
<environment>
|
|
1875
|
+
<collation uri="http://www.w3.org/2010/09/qt-fots-catalog/collation/caseblind"/>
|
|
1876
|
+
</environment>
|
|
1877
|
+
<dependency type="feature" value="non_unicode_codepoint_collation"/>
|
|
1878
|
+
<test>deep-equal(("a", "A"), ("A", "b"), "http://www.w3.org/2010/09/qt-fots-catalog/collation/caseblind")</test>
|
|
1879
|
+
<result>
|
|
1880
|
+
<assert-false/>
|
|
1881
|
+
</result>
|
|
1882
|
+
</test-case>
|
|
1883
|
+
|
|
1884
|
+
<test-case name="K-SeqDeepEqualFunc-58">
|
|
1885
|
+
<description>Use case-blind collation, if supported, within attribute nodes</description>
|
|
1886
|
+
<created by="Michael Kay" on="2012-05-30"/>
|
|
1887
|
+
<modified by="O'Neil Delpratt" on="2013-08-02" change="Added feature dependency - Fix to bug issue #22423" />
|
|
1888
|
+
<environment>
|
|
1889
|
+
<collation uri="http://www.w3.org/2010/09/qt-fots-catalog/collation/caseblind"/>
|
|
1890
|
+
</environment>
|
|
1891
|
+
<dependency type="spec" value="XQ10+"/>
|
|
1892
|
+
<dependency type="feature" value="non_unicode_codepoint_collation"/>
|
|
1893
|
+
<test><![CDATA[
|
|
1894
|
+
deep-equal(<a><b x="abc"/></a>, <a><b x="ABC"/></a>,
|
|
1895
|
+
"http://www.w3.org/2010/09/qt-fots-catalog/collation/caseblind")
|
|
1896
|
+
]]></test>
|
|
1897
|
+
<result>
|
|
1898
|
+
<assert-true/>
|
|
1899
|
+
</result>
|
|
1900
|
+
</test-case>
|
|
1901
|
+
|
|
1902
|
+
<test-case name="K-SeqDeepEqualFunc-59">
|
|
1903
|
+
<description>Use case-blind collation, if supported, within element nodes</description>
|
|
1904
|
+
<created by="Michael Kay" on="2012-05-30"/>
|
|
1905
|
+
<modified by="O'Neil Delpratt" on="2013-08-02" change="Added feature dependency - Fix to bug issue #22423" />
|
|
1906
|
+
<environment>
|
|
1907
|
+
<collation uri="http://www.w3.org/2010/09/qt-fots-catalog/collation/caseblind"/>
|
|
1908
|
+
</environment>
|
|
1909
|
+
<dependency type="spec" value="XQ10+"/>
|
|
1910
|
+
<dependency type="feature" value="non_unicode_codepoint_collation"/>
|
|
1911
|
+
<test><![CDATA[
|
|
1912
|
+
deep-equal(<a><b>abc</b></a>, <a><b>ABC</b></a>,
|
|
1913
|
+
"http://www.w3.org/2010/09/qt-fots-catalog/collation/caseblind")
|
|
1914
|
+
]]></test>
|
|
1915
|
+
<result>
|
|
1916
|
+
<assert-true/>
|
|
1917
|
+
</result>
|
|
1918
|
+
</test-case>
|
|
1919
|
+
|
|
1920
|
+
<test-case name="K-SeqDeepEqualFunc-60">
|
|
1921
|
+
<description>Use case-blind collation, if supported, doesn't apply to names</description>
|
|
1922
|
+
<created by="Michael Kay" on="2012-05-30"/>
|
|
1923
|
+
<modified by="O'Neil Delpratt" on="2013-08-02" change="Added feature dependency - Fix to bug issue #22423" />
|
|
1924
|
+
<environment>
|
|
1925
|
+
<collation uri="http://www.w3.org/2010/09/qt-fots-catalog/collation/caseblind"/>
|
|
1926
|
+
</environment>
|
|
1927
|
+
<dependency type="spec" value="XQ10+"/>
|
|
1928
|
+
<dependency type="feature" value="non_unicode_codepoint_collation"/>
|
|
1929
|
+
<test><![CDATA[
|
|
1930
|
+
deep-equal(<a><b>abc</b></a>, <a><B>abc</B></a>,
|
|
1931
|
+
"http://www.w3.org/2010/09/qt-fots-catalog/collation/caseblind")
|
|
1932
|
+
]]></test>
|
|
1933
|
+
<result>
|
|
1934
|
+
<assert-false/>
|
|
1935
|
+
</result>
|
|
1936
|
+
</test-case>
|
|
1937
|
+
|
|
1938
|
+
<test-case name="K-SeqDeepEqualFunc-61">
|
|
1939
|
+
<description>Use case-blind collation, if supported, doesn't apply to attribute names</description>
|
|
1940
|
+
<created by="Michael Kay" on="2012-05-30"/>
|
|
1941
|
+
<modified by="O'Neil Delpratt" on="2013-08-02" change="Added feature dependency - Fix to bug issue #22423" />
|
|
1942
|
+
<environment>
|
|
1943
|
+
<collation uri="http://www.w3.org/2010/09/qt-fots-catalog/collation/caseblind"/>
|
|
1944
|
+
</environment>
|
|
1945
|
+
<dependency type="spec" value="XQ10+"/>
|
|
1946
|
+
<dependency type="feature" value="non_unicode_codepoint_collation"/>
|
|
1947
|
+
<test><![CDATA[
|
|
1948
|
+
deep-equal(<a><b x="abc"/></a>, <a><b X="abc"/></a>,
|
|
1949
|
+
"http://www.w3.org/2010/09/qt-fots-catalog/collation/caseblind")
|
|
1950
|
+
]]></test>
|
|
1951
|
+
<result>
|
|
1952
|
+
<assert-false/>
|
|
1953
|
+
</result>
|
|
1954
|
+
</test-case>
|
|
1955
|
+
|
|
1956
|
+
<test-case name="K-SeqDeepEqualFunc-62" covers-30="partial-function-application">
|
|
1957
|
+
<description>Use case-blind collation, if supported, partially applied</description>
|
|
1958
|
+
<created by="Michael Kay" on="2012-05-30"/>
|
|
1959
|
+
<modified by="O'Neil Delpratt" on="2013-08-02" change="Added feature dependency - Fix to bug issue #22423" />
|
|
1960
|
+
<modified by="Josh Spiegel" on="2014-05-29" change="added dependency"/>
|
|
1961
|
+
<environment>
|
|
1962
|
+
<collation uri="http://www.w3.org/2010/09/qt-fots-catalog/collation/caseblind"/>
|
|
1963
|
+
</environment>
|
|
1964
|
+
<dependency type="spec" value="XQ30+"/>
|
|
1965
|
+
<dependency type="feature" value="non_unicode_codepoint_collation"/>
|
|
1966
|
+
<dependency type="feature" value="higherOrderFunctions"/>
|
|
1967
|
+
<test><![CDATA[
|
|
1968
|
+
let $deep := deep-equal(?, ?, "http://www.w3.org/2010/09/qt-fots-catalog/collation/caseblind")
|
|
1969
|
+
return $deep(<a><b>abc</b></a>, <a><b>ABC</b></a>)
|
|
1970
|
+
]]></test>
|
|
1971
|
+
<result>
|
|
1972
|
+
<assert-true/>
|
|
1973
|
+
</result>
|
|
1974
|
+
</test-case>
|
|
1975
|
+
|
|
1976
|
+
<test-case name="K-SeqDeepEqualFunc-63" covers-30="named-function-ref">
|
|
1977
|
+
<description>Use case-blind collation, if supported, in dynamic call</description>
|
|
1978
|
+
<created by="Michael Kay" on="2012-05-30"/>
|
|
1979
|
+
<modified by="O'Neil Delpratt" on="2013-08-02" change="Added feature dependency - Fix to bug issue #22423" />
|
|
1980
|
+
<environment>
|
|
1981
|
+
<collation uri="http://www.w3.org/2010/09/qt-fots-catalog/collation/caseblind"/>
|
|
1982
|
+
</environment>
|
|
1983
|
+
<dependency type="spec" value="XQ30+"/>
|
|
1984
|
+
<dependency type="feature" value="higherOrderFunctions"/>
|
|
1985
|
+
<dependency type="feature" value="non_unicode_codepoint_collation"/>
|
|
1986
|
+
<test><![CDATA[
|
|
1987
|
+
let $deep := deep-equal#3
|
|
1988
|
+
return $deep(<a><b>abc</b></a>, <a><b>ABC</b></a>,
|
|
1989
|
+
"http://www.w3.org/2010/09/qt-fots-catalog/collation/caseblind")
|
|
1990
|
+
]]></test>
|
|
1991
|
+
<result>
|
|
1992
|
+
<assert-true/>
|
|
1993
|
+
</result>
|
|
1994
|
+
</test-case>
|
|
1995
|
+
|
|
1996
|
+
<test-case name="K-SeqDeepEqualFunc-64" covers="html-ascii-case-insensitive">
|
|
1997
|
+
<description>Use case-blind collation, if supported</description>
|
|
1998
|
+
<created by="Michael Kay" on="2014-12-05"/>
|
|
1999
|
+
<environment>
|
|
2000
|
+
<collation uri="http://www.w3.org/2005/xpath-functions/collation/html-ascii-case-insensitive"/>
|
|
2001
|
+
</environment>
|
|
2002
|
+
<dependency type="spec" value="XP31+ XQ31+"/>
|
|
2003
|
+
<test>deep-equal(("a", "A"), ("A", "a"), "http://www.w3.org/2005/xpath-functions/collation/html-ascii-case-insensitive")</test>
|
|
2004
|
+
<result>
|
|
2005
|
+
<assert-true/>
|
|
2006
|
+
</result>
|
|
2007
|
+
</test-case>
|
|
2008
|
+
|
|
2009
|
+
<test-case name="K-SeqDeepEqualFunc-65" covers="html-ascii-case-insensitive">
|
|
2010
|
+
<description>Use case-blind collation, if supported</description>
|
|
2011
|
+
<created by="Michael Kay" on="2014-12-05"/>
|
|
2012
|
+
<environment>
|
|
2013
|
+
<collation uri="http://www.w3.org/2005/xpath-functions/collation/html-ascii-case-insensitive"/>
|
|
2014
|
+
</environment>
|
|
2015
|
+
<dependency type="spec" value="XP31+ XQ31+"/>
|
|
2016
|
+
<test>deep-equal(("a", "A"), ("A", "b"), "http://www.w3.org/2005/xpath-functions/collation/html-ascii-case-insensitive")</test>
|
|
2017
|
+
<result>
|
|
2018
|
+
<assert-false/>
|
|
2019
|
+
</result>
|
|
2020
|
+
</test-case>
|
|
2021
|
+
|
|
2022
|
+
<test-case name="K-SeqDeepEqualFunc-66" covers="html-ascii-case-insensitive">
|
|
2023
|
+
<description>Use case-blind collation, if supported, within attribute nodes</description>
|
|
2024
|
+
<created by="Michael Kay" on="2014-12-05"/>
|
|
2025
|
+
<environment>
|
|
2026
|
+
<collation uri="http://www.w3.org/2005/xpath-functions/collation/html-ascii-case-insensitive"/>
|
|
2027
|
+
</environment>
|
|
2028
|
+
<dependency type="spec" value="XQ31+"/>
|
|
2029
|
+
<test><![CDATA[
|
|
2030
|
+
deep-equal(<a><b x="abc"/></a>, <a><b x="ABC"/></a>,
|
|
2031
|
+
"http://www.w3.org/2005/xpath-functions/collation/html-ascii-case-insensitive")
|
|
2032
|
+
]]></test>
|
|
2033
|
+
<result>
|
|
2034
|
+
<assert-true/>
|
|
2035
|
+
</result>
|
|
2036
|
+
</test-case>
|
|
2037
|
+
|
|
2038
|
+
<test-case name="K-SeqDeepEqualFunc-67" covers="html-ascii-case-insensitive">
|
|
2039
|
+
<description>Use case-blind collation, if supported, within element nodes</description>
|
|
2040
|
+
<created by="Michael Kay" on="2014-12-05"/>
|
|
2041
|
+
<environment>
|
|
2042
|
+
<collation uri="http://www.w3.org/2005/xpath-functions/collation/html-ascii-case-insensitive"/>
|
|
2043
|
+
</environment>
|
|
2044
|
+
<dependency type="spec" value="XQ31+"/>
|
|
2045
|
+
<test><![CDATA[
|
|
2046
|
+
deep-equal(<a><b>abc</b></a>, <a><b>ABC</b></a>,
|
|
2047
|
+
"http://www.w3.org/2005/xpath-functions/collation/html-ascii-case-insensitive")
|
|
2048
|
+
]]></test>
|
|
2049
|
+
<result>
|
|
2050
|
+
<assert-true/>
|
|
2051
|
+
</result>
|
|
2052
|
+
</test-case>
|
|
2053
|
+
|
|
2054
|
+
<test-case name="K-SeqDeepEqualFunc-68" covers="html-ascii-case-insensitive">
|
|
2055
|
+
<description>Use case-blind collation, if supported, doesn't apply to names</description>
|
|
2056
|
+
<created by="Michael Kay" on="2014-12-05"/>
|
|
2057
|
+
<environment>
|
|
2058
|
+
<collation uri="http://www.w3.org/2005/xpath-functions/collation/html-ascii-case-insensitive"/>
|
|
2059
|
+
</environment>
|
|
2060
|
+
<dependency type="spec" value="XQ31+"/>
|
|
2061
|
+
<test><![CDATA[
|
|
2062
|
+
deep-equal(<a><b>abc</b></a>, <a><B>abc</B></a>,
|
|
2063
|
+
"http://www.w3.org/2005/xpath-functions/collation/html-ascii-case-insensitive")
|
|
2064
|
+
]]></test>
|
|
2065
|
+
<result>
|
|
2066
|
+
<assert-false/>
|
|
2067
|
+
</result>
|
|
2068
|
+
</test-case>
|
|
2069
|
+
|
|
2070
|
+
<test-case name="K-SeqDeepEqualFunc-69" covers="html-ascii-case-insensitive">
|
|
2071
|
+
<description>Use case-blind collation, if supported, doesn't apply to attribute names</description>
|
|
2072
|
+
<created by="Michael Kay" on="2014-12-05"/>
|
|
2073
|
+
<environment>
|
|
2074
|
+
<collation uri="http://www.w3.org/2005/xpath-functions/collation/html-ascii-case-insensitive"/>
|
|
2075
|
+
</environment>
|
|
2076
|
+
<dependency type="spec" value="XQ31+"/>
|
|
2077
|
+
<test><![CDATA[
|
|
2078
|
+
deep-equal(<a><b x="abc"/></a>, <a><b X="abc"/></a>,
|
|
2079
|
+
"http://www.w3.org/2005/xpath-functions/collation/html-ascii-case-insensitive")
|
|
2080
|
+
]]></test>
|
|
2081
|
+
<result>
|
|
2082
|
+
<assert-false/>
|
|
2083
|
+
</result>
|
|
2084
|
+
</test-case>
|
|
2085
|
+
|
|
2086
|
+
<test-case name="K-SeqDeepEqualFunc-70" covers-30="partial-function-application" covers="html-ascii-case-insensitive">
|
|
2087
|
+
<description>Use case-blind collation, if supported, partially applied</description>
|
|
2088
|
+
<created by="Michael Kay" on="2014-12-05"/>
|
|
2089
|
+
<environment>
|
|
2090
|
+
<collation uri="http://www.w3.org/2005/xpath-functions/collation/html-ascii-case-insensitive"/>
|
|
2091
|
+
</environment>
|
|
2092
|
+
<dependency type="spec" value="XQ31+"/>
|
|
2093
|
+
<dependency type="feature" value="non_unicode_codepoint_collation"/>
|
|
2094
|
+
<dependency type="feature" value="higherOrderFunctions"/>
|
|
2095
|
+
<test><![CDATA[
|
|
2096
|
+
let $deep := deep-equal(?, ?, "http://www.w3.org/2005/xpath-functions/collation/html-ascii-case-insensitive")
|
|
2097
|
+
return $deep(<a><b>abc</b></a>, <a><b>ABC</b></a>)
|
|
2098
|
+
]]></test>
|
|
2099
|
+
<result>
|
|
2100
|
+
<assert-true/>
|
|
2101
|
+
</result>
|
|
2102
|
+
</test-case>
|
|
2103
|
+
|
|
2104
|
+
<test-case name="K-SeqDeepEqualFunc-71" covers-30="named-function-ref" covers="html-ascii-case-insensitive">
|
|
2105
|
+
<description>Use case-blind collation, if supported, in dynamic call</description>
|
|
2106
|
+
<created by="Michael Kay" on="2014-12-05"/>
|
|
2107
|
+
<environment>
|
|
2108
|
+
<collation uri="http://www.w3.org/2005/xpath-functions/collation/html-ascii-case-insensitive"/>
|
|
2109
|
+
</environment>
|
|
2110
|
+
<dependency type="spec" value="XQ31+"/>
|
|
2111
|
+
<dependency type="feature" value="higherOrderFunctions"/>
|
|
2112
|
+
<test><![CDATA[
|
|
2113
|
+
let $deep := deep-equal#3
|
|
2114
|
+
return $deep(<a><b>abc</b></a>, <a><b>ABC</b></a>,
|
|
2115
|
+
"http://www.w3.org/2005/xpath-functions/collation/html-ascii-case-insensitive")
|
|
2116
|
+
]]></test>
|
|
2117
|
+
<result>
|
|
2118
|
+
<assert-true/>
|
|
2119
|
+
</result>
|
|
2120
|
+
</test-case>
|
|
2121
|
+
|
|
2122
|
+
<test-case name="K2-SeqDeepEqualFunc-1">
|
|
2123
|
+
<description> Two date/time values that never will compare equal. </description>
|
|
2124
|
+
<created by="Frans Englich" on="2007-11-26"/>
|
|
2125
|
+
<test>not(deep-equal(current-time(), current-date()))</test>
|
|
2126
|
+
<result>
|
|
2127
|
+
<assert-true/>
|
|
2128
|
+
</result>
|
|
2129
|
+
</test-case>
|
|
2130
|
+
|
|
2131
|
+
<test-case name="K2-SeqDeepEqualFunc-2">
|
|
2132
|
+
<description> A date and node value that never will compare equal. </description>
|
|
2133
|
+
<created by="Frans Englich" on="2007-11-26"/>
|
|
2134
|
+
<dependency type="spec" value="XQ10+"/>
|
|
2135
|
+
<test><![CDATA[deep-equal(current-time(), <e/>)]]></test>
|
|
2136
|
+
<result>
|
|
2137
|
+
<assert-false/>
|
|
2138
|
+
</result>
|
|
2139
|
+
</test-case>
|
|
2140
|
+
|
|
2141
|
+
<test-case name="K2-SeqDeepEqualFunc-3">
|
|
2142
|
+
<description> A date and node value that never will compare equal(#2). </description>
|
|
2143
|
+
<created by="Frans Englich" on="2007-11-26"/>
|
|
2144
|
+
<dependency type="spec" value="XQ10+"/>
|
|
2145
|
+
<test><![CDATA[deep-equal(<e/>, current-time())]]></test>
|
|
2146
|
+
<result>
|
|
2147
|
+
<assert-false/>
|
|
2148
|
+
</result>
|
|
2149
|
+
</test-case>
|
|
2150
|
+
|
|
2151
|
+
<test-case name="K2-SeqDeepEqualFunc-4">
|
|
2152
|
+
<description> Time values that never will compare equal. </description>
|
|
2153
|
+
<created by="Frans Englich" on="2007-11-26"/>
|
|
2154
|
+
<test>deep-equal((current-time(), current-time(), current-time()), (current-time(), current-time()))</test>
|
|
2155
|
+
<result>
|
|
2156
|
+
<assert-false/>
|
|
2157
|
+
</result>
|
|
2158
|
+
</test-case>
|
|
2159
|
+
|
|
2160
|
+
<test-case name="K2-SeqDeepEqualFunc-5">
|
|
2161
|
+
<description> Comparing mixed content. </description>
|
|
2162
|
+
<created by="Frans Englich" on="2007-11-26"/>
|
|
2163
|
+
<dependency type="spec" value="XQ10+"/>
|
|
2164
|
+
<test><![CDATA[deep-equal((1, <e/>, 2), (1, <e/>, 2))]]></test>
|
|
2165
|
+
<result>
|
|
2166
|
+
<assert-true/>
|
|
2167
|
+
</result>
|
|
2168
|
+
</test-case>
|
|
2169
|
+
|
|
2170
|
+
<test-case name="K2-SeqDeepEqualFunc-6">
|
|
2171
|
+
<description> Comparing mixed content(#2). </description>
|
|
2172
|
+
<created by="Frans Englich" on="2007-11-26"/>
|
|
2173
|
+
<dependency type="spec" value="XQ10+"/>
|
|
2174
|
+
<test><![CDATA[deep-equal((1, <a/>, 2), (1, <b/>, 2))]]></test>
|
|
2175
|
+
<result>
|
|
2176
|
+
<assert-false/>
|
|
2177
|
+
</result>
|
|
2178
|
+
</test-case>
|
|
2179
|
+
|
|
2180
|
+
<test-case name="K2-SeqDeepEqualFunc-7">
|
|
2181
|
+
<description> Comparing mixed content(#3). </description>
|
|
2182
|
+
<created by="Frans Englich" on="2007-11-26"/>
|
|
2183
|
+
<dependency type="spec" value="XQ10+"/>
|
|
2184
|
+
<test><![CDATA[deep-equal((<a/>, <b/>, 4), (<a/>, <b/>, 2))]]></test>
|
|
2185
|
+
<result>
|
|
2186
|
+
<assert-false/>
|
|
2187
|
+
</result>
|
|
2188
|
+
</test-case>
|
|
2189
|
+
|
|
2190
|
+
<test-case name="K2-SeqDeepEqualFunc-8">
|
|
2191
|
+
<description> fn:deep-equal() takes two arguments, not zero. </description>
|
|
2192
|
+
<created by="Frans Englich" on="2007-11-26"/>
|
|
2193
|
+
<test>deep-equal()</test>
|
|
2194
|
+
<result>
|
|
2195
|
+
<error code="XPST0017"/>
|
|
2196
|
+
</result>
|
|
2197
|
+
</test-case>
|
|
2198
|
+
|
|
2199
|
+
<test-case name="K2-SeqDeepEqualFunc-9">
|
|
2200
|
+
<description> fn:deep-equal() takes two arguments, not one. </description>
|
|
2201
|
+
<created by="Frans Englich" on="2007-11-26"/>
|
|
2202
|
+
<test>deep-equal((1, 2, 3))</test>
|
|
2203
|
+
<result>
|
|
2204
|
+
<error code="XPST0017"/>
|
|
2205
|
+
</result>
|
|
2206
|
+
</test-case>
|
|
2207
|
+
|
|
2208
|
+
<test-case name="K2-SeqDeepEqualFunc-10">
|
|
2209
|
+
<description> fn:deep-equal() with two sequence of nodes. </description>
|
|
2210
|
+
<created by="Frans Englich" on="2007-11-26"/>
|
|
2211
|
+
<dependency type="spec" value="XQ10+"/>
|
|
2212
|
+
<test><![CDATA[deep-equal((<a/>, <b/>, <c/>), (<a/>, <b/>, <c/>))]]></test>
|
|
2213
|
+
<result>
|
|
2214
|
+
<assert-true/>
|
|
2215
|
+
</result>
|
|
2216
|
+
</test-case>
|
|
2217
|
+
|
|
2218
|
+
<test-case name="K2-SeqDeepEqualFunc-11">
|
|
2219
|
+
<description> fn:deep-equal() with two sequence of nodes(#2). </description>
|
|
2220
|
+
<created by="Frans Englich" on="2007-11-26"/>
|
|
2221
|
+
<dependency type="spec" value="XQ10+"/>
|
|
2222
|
+
<test><![CDATA[deep-equal((<a/>, <b/>, <c/>), (<a/>, <b/>, <a/>))]]></test>
|
|
2223
|
+
<result>
|
|
2224
|
+
<assert-false/>
|
|
2225
|
+
</result>
|
|
2226
|
+
</test-case>
|
|
2227
|
+
|
|
2228
|
+
<test-case name="K2-SeqDeepEqualFunc-12">
|
|
2229
|
+
<description> fn:deep-equal() with two sequence of nodes(#3). </description>
|
|
2230
|
+
<created by="Frans Englich" on="2007-11-26"/>
|
|
2231
|
+
<dependency type="spec" value="XQ10+"/>
|
|
2232
|
+
<test><![CDATA[deep-equal((<a/>, <b/>), (<a/>, <b/>, <c/>))]]></test>
|
|
2233
|
+
<result>
|
|
2234
|
+
<assert-false/>
|
|
2235
|
+
</result>
|
|
2236
|
+
</test-case>
|
|
2237
|
+
|
|
2238
|
+
<test-case name="K2-SeqDeepEqualFunc-13">
|
|
2239
|
+
<description> fn:deep-equal() with two sequence of nodes(#4). </description>
|
|
2240
|
+
<created by="Frans Englich" on="2007-11-26"/>
|
|
2241
|
+
<dependency type="spec" value="XQ10+"/>
|
|
2242
|
+
<test><![CDATA[deep-equal((<a/>, <b/>, <c/>), (<a/>, <b/>))]]></test>
|
|
2243
|
+
<result>
|
|
2244
|
+
<assert-false/>
|
|
2245
|
+
</result>
|
|
2246
|
+
</test-case>
|
|
2247
|
+
|
|
2248
|
+
<test-case name="K2-SeqDeepEqualFunc-14">
|
|
2249
|
+
<description> Ensure processing instructions are ignored if children of a document node. </description>
|
|
2250
|
+
<created by="Frans Englich" on="2007-11-26"/>
|
|
2251
|
+
<dependency type="spec" value="XQ10+"/>
|
|
2252
|
+
<test><![CDATA[declare variable $d1 := document { <?target data?>, text{"some text"}}; declare variable $d2 := document {text{"some text"}}; deep-equal($d1, $d2)]]></test>
|
|
2253
|
+
<result>
|
|
2254
|
+
<assert-true/>
|
|
2255
|
+
</result>
|
|
2256
|
+
</test-case>
|
|
2257
|
+
|
|
2258
|
+
<test-case name="K2-SeqDeepEqualFunc-15">
|
|
2259
|
+
<description> Ensure processing instructions are ignored if children of a document node(#2). </description>
|
|
2260
|
+
<created by="Frans Englich" on="2007-11-26"/>
|
|
2261
|
+
<dependency type="spec" value="XQ10+"/>
|
|
2262
|
+
<test><![CDATA[declare variable $d1 := document {()}; declare variable $d2 := document {<?target data?>}; deep-equal($d1, $d2)]]></test>
|
|
2263
|
+
<result>
|
|
2264
|
+
<assert-true/>
|
|
2265
|
+
</result>
|
|
2266
|
+
</test-case>
|
|
2267
|
+
|
|
2268
|
+
<test-case name="K2-SeqDeepEqualFunc-16">
|
|
2269
|
+
<description> Ensure processing instructions are ignored if children of a document node. </description>
|
|
2270
|
+
<created by="Frans Englich" on="2007-11-26"/>
|
|
2271
|
+
<dependency type="spec" value="XQ10+"/>
|
|
2272
|
+
<test><![CDATA[declare variable $d1 := document { <?target data?>, text{"some text"}}; declare variable $d2 := document {text{"some text"}}; deep-equal($d1, $d2)]]></test>
|
|
2273
|
+
<result>
|
|
2274
|
+
<assert-true/>
|
|
2275
|
+
</result>
|
|
2276
|
+
</test-case>
|
|
2277
|
+
|
|
2278
|
+
<test-case name="K2-SeqDeepEqualFunc-17">
|
|
2279
|
+
<description> Ensure processing instructions are ignored if children of a document node(#2). </description>
|
|
2280
|
+
<created by="Frans Englich" on="2007-11-26"/>
|
|
2281
|
+
<dependency type="spec" value="XQ10+"/>
|
|
2282
|
+
<test><![CDATA[declare variable $d1 := document {()}; declare variable $d2 := document {<?target data?>}; deep-equal($d1, $d2)]]></test>
|
|
2283
|
+
<result>
|
|
2284
|
+
<assert-true/>
|
|
2285
|
+
</result>
|
|
2286
|
+
</test-case>
|
|
2287
|
+
|
|
2288
|
+
<test-case name="K2-SeqDeepEqualFunc-18">
|
|
2289
|
+
<description> fn:deep-equal() with mixed content. </description>
|
|
2290
|
+
<created by="Frans Englich" on="2007-11-26"/>
|
|
2291
|
+
<dependency type="spec" value="XQ10+"/>
|
|
2292
|
+
<test><![CDATA[deep-equal(<e>1</e>, 1)]]></test>
|
|
2293
|
+
<result>
|
|
2294
|
+
<assert-false/>
|
|
2295
|
+
</result>
|
|
2296
|
+
</test-case>
|
|
2297
|
+
|
|
2298
|
+
<test-case name="K2-SeqDeepEqualFunc-19">
|
|
2299
|
+
<description> fn:deep-equal() with mixed content(#2). </description>
|
|
2300
|
+
<created by="Frans Englich" on="2007-11-26"/>
|
|
2301
|
+
<dependency type="spec" value="XQ10+"/>
|
|
2302
|
+
<test><![CDATA[deep-equal(1, <e>1</e>)]]></test>
|
|
2303
|
+
<result>
|
|
2304
|
+
<assert-false/>
|
|
2305
|
+
</result>
|
|
2306
|
+
</test-case>
|
|
2307
|
+
|
|
2308
|
+
<test-case name="K2-SeqDeepEqualFunc-20">
|
|
2309
|
+
<description> One of the operands has two text nodes, and hence it evaluate to false. </description>
|
|
2310
|
+
<created by="Frans Englich" on="2007-11-26"/>
|
|
2311
|
+
<dependency type="spec" value="XQ10+"/>
|
|
2312
|
+
<test><![CDATA[declare variable $d1 := <e a="1" b="2">te<?target data?>xt</e>; declare variable $d2 := <e b="2" a="1">text</e>; deep-equal($d1, $d2), deep-equal($d2, $d1)]]></test>
|
|
2313
|
+
<result>
|
|
2314
|
+
<assert-string-value>false false</assert-string-value>
|
|
2315
|
+
</result>
|
|
2316
|
+
</test-case>
|
|
2317
|
+
|
|
2318
|
+
<test-case name="K2-SeqDeepEqualFunc-21">
|
|
2319
|
+
<description> Processing instructions inside elements are ignored. </description>
|
|
2320
|
+
<created by="Frans Englich" on="2007-11-26"/>
|
|
2321
|
+
<dependency type="spec" value="XQ10+"/>
|
|
2322
|
+
<test><![CDATA[declare variable $d1 := <e a="1" b="2"><?target data?>text</e>; declare variable $d2 := <e b="2" a="1">text</e>; deep-equal($d1, $d2), deep-equal($d2, $d1)]]></test>
|
|
2323
|
+
<result>
|
|
2324
|
+
<assert-string-value>true true</assert-string-value>
|
|
2325
|
+
</result>
|
|
2326
|
+
</test-case>
|
|
2327
|
+
|
|
2328
|
+
<test-case name="K2-SeqDeepEqualFunc-22">
|
|
2329
|
+
<description> One of the operands has two text nodes besides the comment, and hence it evaluate to false. </description>
|
|
2330
|
+
<created by="Frans Englich" on="2007-11-26"/>
|
|
2331
|
+
<dependency type="spec" value="XQ10+"/>
|
|
2332
|
+
<test><![CDATA[declare variable $d1 := <e a="1" b="2">te<!-- content -->xt</e>; declare variable $d2 := <e b="2" a="1">text</e>; deep-equal($d1, $d2), deep-equal($d2, $d1)]]></test>
|
|
2333
|
+
<result>
|
|
2334
|
+
<assert-string-value>false false</assert-string-value>
|
|
2335
|
+
</result>
|
|
2336
|
+
</test-case>
|
|
2337
|
+
|
|
2338
|
+
<test-case name="K2-SeqDeepEqualFunc-23">
|
|
2339
|
+
<description> Comments inside elements are ignored. </description>
|
|
2340
|
+
<created by="Frans Englich" on="2007-11-26"/>
|
|
2341
|
+
<dependency type="spec" value="XQ10+"/>
|
|
2342
|
+
<test><![CDATA[declare variable $d1 := <e a="1" b="2"><!-- content -->text</e>; declare variable $d2 := <e b="2" a="1">text</e>; deep-equal($d1, $d2), deep-equal($d2, $d1)]]></test>
|
|
2343
|
+
<result>
|
|
2344
|
+
<assert-string-value>true true</assert-string-value>
|
|
2345
|
+
</result>
|
|
2346
|
+
</test-case>
|
|
2347
|
+
|
|
2348
|
+
<test-case name="K2-SeqDeepEqualFunc-24">
|
|
2349
|
+
<description> Compare attribute nodes. </description>
|
|
2350
|
+
<created by="Frans Englich" on="2007-11-26"/>
|
|
2351
|
+
<dependency type="spec" value="XQ10+"/>
|
|
2352
|
+
<test>deep-equal(attribute name {"content"}, attribute name {"content"})</test>
|
|
2353
|
+
<result>
|
|
2354
|
+
<assert-true/>
|
|
2355
|
+
</result>
|
|
2356
|
+
</test-case>
|
|
2357
|
+
|
|
2358
|
+
<test-case name="K2-SeqDeepEqualFunc-25">
|
|
2359
|
+
<description> Compare attribute nodes in a weird order. </description>
|
|
2360
|
+
<created by="Frans Englich" on="2007-11-26"/>
|
|
2361
|
+
<dependency type="spec" value="XQ10+"/>
|
|
2362
|
+
<test>deep-equal((attribute name2 {"content"}, attribute name {"content"}), (attribute name {"content"}, attribute name2 {"content"}))</test>
|
|
2363
|
+
<result>
|
|
2364
|
+
<assert-false/>
|
|
2365
|
+
</result>
|
|
2366
|
+
</test-case>
|
|
2367
|
+
|
|
2368
|
+
<test-case name="K2-SeqDeepEqualFunc-26">
|
|
2369
|
+
<description> Compare operands with attributes nodes of different size. </description>
|
|
2370
|
+
<created by="Frans Englich" on="2007-11-26"/>
|
|
2371
|
+
<dependency type="spec" value="XQ10+"/>
|
|
2372
|
+
<test>deep-equal((attribute name {"content"}, attribute name {"content"}), (attribute name {"content"}))</test>
|
|
2373
|
+
<result>
|
|
2374
|
+
<assert-false/>
|
|
2375
|
+
</result>
|
|
2376
|
+
</test-case>
|
|
2377
|
+
|
|
2378
|
+
<test-case name="K2-SeqDeepEqualFunc-27">
|
|
2379
|
+
<description> Compare operands with attributes nodes of different size(#2). </description>
|
|
2380
|
+
<created by="Frans Englich" on="2007-11-26"/>
|
|
2381
|
+
<dependency type="spec" value="XQ10+"/>
|
|
2382
|
+
<test>deep-equal((attribute name {"content"}, attribute name {"content"}), attribute name {"content"})</test>
|
|
2383
|
+
<result>
|
|
2384
|
+
<assert-false/>
|
|
2385
|
+
</result>
|
|
2386
|
+
</test-case>
|
|
2387
|
+
|
|
2388
|
+
<test-case name="K2-SeqDeepEqualFunc-28">
|
|
2389
|
+
<description> Test deep-equalness of two attribute nodes. </description>
|
|
2390
|
+
<created by="Frans Englich" on="2007-11-26"/>
|
|
2391
|
+
<dependency type="spec" value="XQ10+"/>
|
|
2392
|
+
<test>deep-equal(attribute name {}, attribute name {})</test>
|
|
2393
|
+
<result>
|
|
2394
|
+
<assert-true/>
|
|
2395
|
+
</result>
|
|
2396
|
+
</test-case>
|
|
2397
|
+
|
|
2398
|
+
<test-case name="K2-SeqDeepEqualFunc-29">
|
|
2399
|
+
<description> Test deep-equalness of two attribute nodes. </description>
|
|
2400
|
+
<created by="Frans Englich" on="2007-11-26"/>
|
|
2401
|
+
<dependency type="spec" value="XQ10+"/>
|
|
2402
|
+
<test>deep-equal(attribute name {"content"}, attribute name {"content"})</test>
|
|
2403
|
+
<result>
|
|
2404
|
+
<assert-true/>
|
|
2405
|
+
</result>
|
|
2406
|
+
</test-case>
|
|
2407
|
+
|
|
2408
|
+
<test-case name="K2-SeqDeepEqualFunc-30">
|
|
2409
|
+
<description> Test deep-equalness of two attribute nodes that has the same name, but different string values. </description>
|
|
2410
|
+
<created by="Frans Englich" on="2007-11-26"/>
|
|
2411
|
+
<dependency type="spec" value="XQ10+"/>
|
|
2412
|
+
<test>deep-equal(attribute name {"content"}, attribute name {})</test>
|
|
2413
|
+
<result>
|
|
2414
|
+
<assert-false/>
|
|
2415
|
+
</result>
|
|
2416
|
+
</test-case>
|
|
2417
|
+
|
|
2418
|
+
<test-case name="K2-SeqDeepEqualFunc-31">
|
|
2419
|
+
<description> Test deep-equalness of two attribute nodes that has same text content but different names. </description>
|
|
2420
|
+
<created by="Frans Englich" on="2007-11-26"/>
|
|
2421
|
+
<dependency type="spec" value="XQ10+"/>
|
|
2422
|
+
<test>deep-equal(attribute name {}, attribute name2 {})</test>
|
|
2423
|
+
<result>
|
|
2424
|
+
<assert-false/>
|
|
2425
|
+
</result>
|
|
2426
|
+
</test-case>
|
|
2427
|
+
|
|
2428
|
+
<test-case name="K2-SeqDeepEqualFunc-32">
|
|
2429
|
+
<description> Test deep-equalness of two attribute nodes that has identical text content but different names. </description>
|
|
2430
|
+
<created by="Frans Englich" on="2007-11-26"/>
|
|
2431
|
+
<dependency type="spec" value="XQ10+"/>
|
|
2432
|
+
<test>deep-equal(attribute name {"content "}, attribute name2 {"content "})</test>
|
|
2433
|
+
<result>
|
|
2434
|
+
<assert-false/>
|
|
2435
|
+
</result>
|
|
2436
|
+
</test-case>
|
|
2437
|
+
|
|
2438
|
+
<test-case name="K2-SeqDeepEqualFunc-33">
|
|
2439
|
+
<description> Namespace prefixes and namespace nodes are ignored</description>
|
|
2440
|
+
<created by="Michael Kay" on="2012-05-30"/>
|
|
2441
|
+
<dependency type="spec" value="XQ10+"/>
|
|
2442
|
+
<test><![CDATA[
|
|
2443
|
+
deep-equal(<e xmlns="http://www.example.com/ns"/>, <p:e xmlns:p="http://www.example.com/ns"/>)
|
|
2444
|
+
]]></test>
|
|
2445
|
+
<result>
|
|
2446
|
+
<assert-true/>
|
|
2447
|
+
</result>
|
|
2448
|
+
</test-case>
|
|
2449
|
+
|
|
2450
|
+
<test-case name="K2-SeqDeepEqualFunc-34">
|
|
2451
|
+
<description> Parent node is ignored</description>
|
|
2452
|
+
<created by="Michael Kay" on="2012-05-30"/>
|
|
2453
|
+
<dependency type="spec" value="XQ10+"/>
|
|
2454
|
+
<test><![CDATA[
|
|
2455
|
+
deep-equal(<e><a>12</a></e>/*, <f><a>12</a></f>/*)
|
|
2456
|
+
]]></test>
|
|
2457
|
+
<result>
|
|
2458
|
+
<assert-true/>
|
|
2459
|
+
</result>
|
|
2460
|
+
</test-case>
|
|
2461
|
+
|
|
2462
|
+
<test-case name="K2-SeqDeepEqualFunc-35">
|
|
2463
|
+
<description> Type annotation is ignored for atomic values</description>
|
|
2464
|
+
<created by="Michael Kay" on="2012-05-30"/>
|
|
2465
|
+
<test>
|
|
2466
|
+
deep-equal("a", xs:NCName("a"))
|
|
2467
|
+
</test>
|
|
2468
|
+
<result>
|
|
2469
|
+
<assert-true/>
|
|
2470
|
+
</result>
|
|
2471
|
+
</test-case>
|
|
2472
|
+
|
|
2473
|
+
<test-case name="K2-SeqDeepEqualFunc-36" covers-30="validate-by-type">
|
|
2474
|
+
<description> Compare typed value, not string value</description>
|
|
2475
|
+
<created by="Michael Kay" on="2012-05-30"/>
|
|
2476
|
+
<dependency type="spec" value="XQ30+"/>
|
|
2477
|
+
<dependency type="feature" value="schemaValidation"/>
|
|
2478
|
+
<test><![CDATA[
|
|
2479
|
+
deep-equal(validate type xs:integer {<e>2012</e>}, validate type xs:gYear{<e>2012</e>})
|
|
2480
|
+
]]></test>
|
|
2481
|
+
<result>
|
|
2482
|
+
<assert-false/>
|
|
2483
|
+
</result>
|
|
2484
|
+
</test-case>
|
|
2485
|
+
|
|
2486
|
+
<test-case name="K2-SeqDeepEqualFunc-37" covers-30="validate-by-type">
|
|
2487
|
+
<description> Type annotation is ignored on nodes</description>
|
|
2488
|
+
<created by="Michael Kay" on="2012-05-30"/>
|
|
2489
|
+
<dependency type="spec" value="XQ30+"/>
|
|
2490
|
+
<dependency type="feature" value="schemaValidation"/>
|
|
2491
|
+
<test><![CDATA[
|
|
2492
|
+
deep-equal(validate type xs:integer {<e>2012</e>}, validate type xs:decimal{<e>2012</e>})
|
|
2493
|
+
]]></test>
|
|
2494
|
+
<result>
|
|
2495
|
+
<assert-true/>
|
|
2496
|
+
</result>
|
|
2497
|
+
</test-case>
|
|
2498
|
+
|
|
2499
|
+
<test-case name="K2-SeqDeepEqualFunc-38">
|
|
2500
|
+
<description>Element with mixed content is not equal to similar element with element-only content</description>
|
|
2501
|
+
<created by="Michael Kay" on="2012-05-30"/>
|
|
2502
|
+
<modified by="O'Neil Delpratt" on="2012-10-09" change="Bug fix relating to 17267" />
|
|
2503
|
+
<environment ref="perverse"/>
|
|
2504
|
+
<dependency type="spec" value="XQ10+"/>
|
|
2505
|
+
<dependency type="feature" value="schemaValidation"/>
|
|
2506
|
+
<dependency type="feature" value="schemaImport"/>
|
|
2507
|
+
<test><![CDATA[
|
|
2508
|
+
import schema namespace p = "http://www.w3.org/XQueryTest/perversity";
|
|
2509
|
+
let $v := validate strict {<p:elementOnly><p:e/></p:elementOnly>}
|
|
2510
|
+
let $w := validate strict {<p:mixed><p:e/></p:mixed>}
|
|
2511
|
+
let $x := validate strict {<p:empty><p:e/></p:empty>}
|
|
2512
|
+
let $y := validate strict {<p:simple><p:e/></p:simple>}
|
|
2513
|
+
return deep-equal($v/p:e, $w/p:e) or deep-equal($w/p:e, $x/p:e)
|
|
2514
|
+
or deep-equal($v/p:e, $x/p:e) or deep-equal($x/p:e, $y/p:e)
|
|
2515
|
+
]]></test>
|
|
2516
|
+
<result>
|
|
2517
|
+
<assert-false/>
|
|
2518
|
+
</result>
|
|
2519
|
+
</test-case>
|
|
2520
|
+
|
|
2521
|
+
<test-case name="K2-SeqDeepEqualFunc-39">
|
|
2522
|
+
<description>Element with mixed content is not equal to similar element with simple content</description>
|
|
2523
|
+
<created by="Michael Kay" on="2012-05-30"/>
|
|
2524
|
+
<modified by="O'Neil Delpratt" on="2012-10-09" change="Bug fix relating to 17267" />
|
|
2525
|
+
<environment ref="perverse"/>
|
|
2526
|
+
<dependency type="spec" value="XQ10+"/>
|
|
2527
|
+
<dependency type="feature" value="schemaValidation"/>
|
|
2528
|
+
<dependency type="feature" value="schemaImport"/>
|
|
2529
|
+
<test><![CDATA[
|
|
2530
|
+
import schema namespace p = "http://www.w3.org/XQueryTest/perversity";
|
|
2531
|
+
let $w := validate strict {<p:mixed><p:e>fraternity</p:e></p:mixed>}
|
|
2532
|
+
let $y := validate strict {<p:simple><p:e>fraternity</p:e></p:simple>}
|
|
2533
|
+
return deep-equal($w/p:e, $y/p:e)
|
|
2534
|
+
]]></test>
|
|
2535
|
+
<result>
|
|
2536
|
+
<assert-false/>
|
|
2537
|
+
</result>
|
|
2538
|
+
</test-case>
|
|
2539
|
+
|
|
2540
|
+
<test-case name="K2-SeqDeepEqualFunc-40">
|
|
2541
|
+
<description> Handle dependency on implicit timezone </description>
|
|
2542
|
+
<created by="Michael Kay" on="2012-05-30"/>
|
|
2543
|
+
<test>
|
|
2544
|
+
deep-equal(xs:dateTime('2012-05-30T12:00:00'), xs:dateTime('2012-05-30T12:00:00Z') - implicit-timezone())
|
|
2545
|
+
</test>
|
|
2546
|
+
<result>
|
|
2547
|
+
<assert-true/>
|
|
2548
|
+
</result>
|
|
2549
|
+
</test-case>
|
|
2550
|
+
|
|
2551
|
+
<test-case name="K2-SeqDeepEqualFunc-41">
|
|
2552
|
+
<description>List of one integer equals union of one integer</description>
|
|
2553
|
+
<created by="Michael Kay" on="2016-11-25"/>
|
|
2554
|
+
<environment ref="perverse"/>
|
|
2555
|
+
<dependency type="spec" value="XQ10+"/>
|
|
2556
|
+
<dependency type="feature" value="schemaValidation"/>
|
|
2557
|
+
<dependency type="feature" value="schemaImport"/>
|
|
2558
|
+
<test><![CDATA[
|
|
2559
|
+
import schema namespace p = "http://www.w3.org/XQueryTest/perversity";
|
|
2560
|
+
let $w := validate strict {<p:list><p:e>12</p:e></p:list>}
|
|
2561
|
+
let $y := validate strict {<p:union><p:e>12</p:e></p:union>}
|
|
2562
|
+
return deep-equal($w/p:e, $y/p:e)
|
|
2563
|
+
]]></test>
|
|
2564
|
+
<result>
|
|
2565
|
+
<assert-true/>
|
|
2566
|
+
</result>
|
|
2567
|
+
</test-case>
|
|
2568
|
+
|
|
2569
|
+
<test-case name="K2-SeqDeepEqualFunc-42">
|
|
2570
|
+
<description>Empty List of integers not equal to empty string</description>
|
|
2571
|
+
<created by="Michael Kay" on="2016-11-25"/>
|
|
2572
|
+
<environment ref="perverse"/>
|
|
2573
|
+
<dependency type="spec" value="XQ10+"/>
|
|
2574
|
+
<dependency type="feature" value="schemaValidation"/>
|
|
2575
|
+
<dependency type="feature" value="schemaImport"/>
|
|
2576
|
+
<test><![CDATA[
|
|
2577
|
+
import schema namespace p = "http://www.w3.org/XQueryTest/perversity";
|
|
2578
|
+
let $w := validate strict {<p:list><p:e></p:e></p:list>}
|
|
2579
|
+
let $y := validate strict {<p:union><p:e></p:e></p:union>}
|
|
2580
|
+
return deep-equal($w/p:e, $y/p:e)
|
|
2581
|
+
]]></test>
|
|
2582
|
+
<result>
|
|
2583
|
+
<assert-false/>
|
|
2584
|
+
</result>
|
|
2585
|
+
</test-case>
|
|
2586
|
+
|
|
2587
|
+
<test-case name="K2-SeqDeepEqualFunc-43">
|
|
2588
|
+
<description>An error evaluating an argument (as distinct from a comparison error) is propagated (Saxon bug 3714)</description>
|
|
2589
|
+
<created by="Michael Kay" on="2018-03-09"/>
|
|
2590
|
+
<modified by="Christian Gruen" on="2020-08-11" change="Arguents have different result size, evaluation can be skipped"/>
|
|
2591
|
+
<modified by="Benito van der Zander" on="2020-09-24" change="add missing spec dependencies"/>
|
|
2592
|
+
<dependency type="spec" value="XP30+ XQ30+"/>
|
|
2593
|
+
<test>deep-equal((0 to year-from-date(current-date()))!(10 idiv .), 11 to 22)</test>
|
|
2594
|
+
<result>
|
|
2595
|
+
<any-of>
|
|
2596
|
+
<assert-string-value>false</assert-string-value>
|
|
2597
|
+
<error code="FOAR0001"/>
|
|
2598
|
+
</any-of>
|
|
2599
|
+
</result>
|
|
2600
|
+
</test-case>
|
|
2601
|
+
|
|
2602
|
+
|
|
2603
|
+
<test-case name="cbcl-deep-equal-001">
|
|
2604
|
+
<description> Test deep-equal ignores processing instructions and comments in elements. </description>
|
|
2605
|
+
<created by="Oliver Hallam" on="2008-04-15"/>
|
|
2606
|
+
<dependency type="spec" value="XQ10+"/>
|
|
2607
|
+
<test><![CDATA[let $doc1 := <doc><?processing-instruction content ?></doc> let $doc2 := <doc><!--comment--></doc> return deep-equal($doc1, $doc2)]]></test>
|
|
2608
|
+
<result>
|
|
2609
|
+
<assert-true/>
|
|
2610
|
+
</result>
|
|
2611
|
+
</test-case>
|
|
2612
|
+
|
|
2613
|
+
|
|
2614
|
+
<test-case name="cbcl-deep-equal-002">
|
|
2615
|
+
<description> Test deep-equal on processing instructions with different values. </description>
|
|
2616
|
+
<created by="Oliver Hallam" on="2008-04-15"/>
|
|
2617
|
+
<dependency type="spec" value="XQ10+"/>
|
|
2618
|
+
<test><![CDATA[let $doc1 := <?cheese brie?> let $doc2 := <?cheese stilton?> return deep-equal($doc1, $doc2)]]></test>
|
|
2619
|
+
<result>
|
|
2620
|
+
<assert-false/>
|
|
2621
|
+
</result>
|
|
2622
|
+
</test-case>
|
|
2623
|
+
|
|
2624
|
+
|
|
2625
|
+
<test-case name="cbcl-deep-equal-003">
|
|
2626
|
+
<description> Test deep-equal on processing instructions with different names. </description>
|
|
2627
|
+
<created by="Oliver Hallam" on="2008-04-15"/>
|
|
2628
|
+
<dependency type="spec" value="XQ10+"/>
|
|
2629
|
+
<test><![CDATA[let $doc1 := <?foo test?> let $doc2 := <?bar test?> return deep-equal($doc1, $doc2)]]></test>
|
|
2630
|
+
<result>
|
|
2631
|
+
<assert-false/>
|
|
2632
|
+
</result>
|
|
2633
|
+
</test-case>
|
|
2634
|
+
|
|
2635
|
+
|
|
2636
|
+
<test-case name="cbcl-deep-equal-004">
|
|
2637
|
+
<description> Test deep-equal on equal processing instructions </description>
|
|
2638
|
+
<created by="Oliver Hallam" on="2008-04-15"/>
|
|
2639
|
+
<dependency type="spec" value="XQ10+"/>
|
|
2640
|
+
<test><![CDATA[let $doc1 := <?foo bar?> let $doc2 := <?foo bar?> return deep-equal($doc1, $doc2)]]></test>
|
|
2641
|
+
<result>
|
|
2642
|
+
<assert-true/>
|
|
2643
|
+
</result>
|
|
2644
|
+
</test-case>
|
|
2645
|
+
|
|
2646
|
+
|
|
2647
|
+
<test-case name="cbcl-deep-equal-005">
|
|
2648
|
+
<description> Test deep-equal simplifying to fn:empty </description>
|
|
2649
|
+
<created by="Oliver Hallam" on="2008-04-15"/>
|
|
2650
|
+
<dependency type="spec" value="XQ10+"/>
|
|
2651
|
+
<test>declare function local:f($x as xs:integer)as xs:integer* { 1 to $x }; deep-equal((local:f(3), 2, local:f(1)), (local:f(3), 2))</test>
|
|
2652
|
+
<result>
|
|
2653
|
+
<assert-false/>
|
|
2654
|
+
</result>
|
|
2655
|
+
</test-case>
|
|
2656
|
+
|
|
2657
|
+
|
|
2658
|
+
<test-case name="cbcl-deep-equal-006">
|
|
2659
|
+
<description> Test deep-equal simplifying to fn:empty </description>
|
|
2660
|
+
<created by="Oliver Hallam" on="2008-04-15"/>
|
|
2661
|
+
<dependency type="spec" value="XQ10+"/>
|
|
2662
|
+
<test>declare function local:f($x as xs:integer) as xs:integer* { 1 to $x }; deep-equal((local:f(3), 2), (local:f(3), 2, local:f(1)))</test>
|
|
2663
|
+
<result>
|
|
2664
|
+
<assert-false/>
|
|
2665
|
+
</result>
|
|
2666
|
+
</test-case>
|
|
2667
|
+
|
|
2668
|
+
|
|
2669
|
+
<test-case name="cbcl-deep-equal-007">
|
|
2670
|
+
<description> Test deep-equal on comparison requiring dynamic context </description>
|
|
2671
|
+
<created by="Oliver Hallam" on="2008-04-15"/>
|
|
2672
|
+
<test>deep-equal(xs:gMonth("--12+03:00"), xs:gMonth("--12")) eq (implicit-timezone() eq xs:dayTimeDuration("PT3H"))</test>
|
|
2673
|
+
<result>
|
|
2674
|
+
<assert-true/>
|
|
2675
|
+
</result>
|
|
2676
|
+
</test-case>
|
|
2677
|
+
|
|
2678
|
+
|
|
2679
|
+
<test-case name="cbcl-deep-equal-008">
|
|
2680
|
+
<description> Test that deep equal compares untypedAtomic values correctly </description>
|
|
2681
|
+
<created by="Oliver Hallam" on="2008-06-17"/>
|
|
2682
|
+
<test>deep-equal((xs:untypedAtomic("a"), xs:untypedAtomic("P1Y"), 2.0), (xs:untypedAtomic("a"), xs:yearMonthDuration("P12M"), xs:untypedAtomic(" 2")))</test>
|
|
2683
|
+
<result>
|
|
2684
|
+
<assert-false/>
|
|
2685
|
+
</result>
|
|
2686
|
+
</test-case>
|
|
2687
|
+
|
|
2688
|
+
<test-case name="cbcl-deep-equal-009">
|
|
2689
|
+
<description> test fn:deep equal (was duplicate cbcl-deep-equal-001)</description>
|
|
2690
|
+
<created by="Tim Mills" on="2008-05-02"/>
|
|
2691
|
+
<dependency type="spec" value="XQ10+"/>
|
|
2692
|
+
<test><![CDATA[fn:deep-equal(<a b="b" c="c" />, <a b="b" />)]]></test>
|
|
2693
|
+
<result>
|
|
2694
|
+
<assert-false/>
|
|
2695
|
+
</result>
|
|
2696
|
+
</test-case>
|
|
2697
|
+
|
|
2698
|
+
<test-case name="cbcl-deep-equal-010">
|
|
2699
|
+
<description> Test that deep equal compares untypedAtomic values correctly </description>
|
|
2700
|
+
<created by="Tim Mills" on="2012-10-30"/>
|
|
2701
|
+
<modified by="Michael Dyck" on="2012-10-30" change="Add dependency on XQ10+ because query contains constructors"/>
|
|
2702
|
+
<dependency type="spec" value="XQ10+"/>
|
|
2703
|
+
<test><![CDATA[deep-equal((<a />, xs:untypedAtomic("a"), xs:untypedAtomic("P1Y"), 2.0), (<a />, xs:untypedAtomic("a"), xs:yearMonthDuration("P12M"), xs:untypedAtomic(" 2")))]]></test>
|
|
2704
|
+
<result>
|
|
2705
|
+
<assert-false/>
|
|
2706
|
+
</result>
|
|
2707
|
+
</test-case>
|
|
2708
|
+
|
|
2709
|
+
</test-set>
|