1 /*
2 * Copyright (c) 2014, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation.
8 *
9 * This code is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
12 * version 2 for more details (a copy is included in the LICENSE file that
13 * accompanied this code).
14 *
15 * You should have received a copy of the GNU General Public License version
16 * 2 along with this work; if not, write to the Free Software Foundation,
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 */
23
24 package javax.xml.xpath.ptests;
25
26 import java.io.IOException;
27 import java.io.InputStream;
28 import java.nio.file.Files;
29 import java.nio.file.Path;
30 import java.nio.file.Paths;
31 import javax.xml.XMLConstants;
32 import javax.xml.namespace.QName;
33 import javax.xml.parsers.DocumentBuilderFactory;
34 import javax.xml.parsers.ParserConfigurationException;
35 import javax.xml.xpath.XPath;
36 import static javax.xml.xpath.XPathConstants.BOOLEAN;
37 import static javax.xml.xpath.XPathConstants.NODE;
38 import static javax.xml.xpath.XPathConstants.NODESET;
39 import static javax.xml.xpath.XPathConstants.NUMBER;
40 import static javax.xml.xpath.XPathConstants.STRING;
41 import javax.xml.xpath.XPathExpressionException;
42 import javax.xml.xpath.XPathFactory;
43 import static javax.xml.xpath.ptests.XPathTestConst.XML_DIR;
44 import static jaxp.library.JAXPTestUtilities.failUnexpected;
45 import static org.testng.Assert.assertEquals;
46 import org.testng.annotations.BeforeTest;
47 import org.testng.annotations.Test;
48 import org.w3c.dom.Attr;
49 import org.w3c.dom.Document;
50 import org.w3c.dom.NodeList;
51 import org.xml.sax.InputSource;
52 import org.xml.sax.SAXException;
53
54 /**
55 * Class containing the test cases for XPathExpression API.
56 */
57 public class XPathExpressionTest {
58 /**
59 * Document object for testing XML file.
60 */
61 private Document document;
62
63 /**
64 * A XPath for evaluation environment and expressions.
65 */
66 private XPath xpath;
67
68 /**
69 * A QName using default name space.
70 */
71 private static final QName TEST_QNAME = new QName(XMLConstants.XML_NS_URI, "");
72
73 /**
74 * XML File Path.
75 */
76 private static final Path XML_PATH = Paths.get(XML_DIR + "widgets.xml");
77
78 /**
79 * An expression name which locate at "/widgets/widget[@name='a']/@quantity"
80 */
81 private static final String EXPRESSION_NAME_A = "/widgets/widget[@name='a']/@quantity";
82
83 /**
84 * An expression name which locate at "/widgets/widget[@name='b']/@quantity"
85 */
86 private static final String EXPRESSION_NAME_B = "/widgets/widget[@name='b']/@quantity";
87
88 /**
89 * Create Document object and XPath object for every time
90 * @throws ParserConfigurationException If the factory class cannot be
91 * loaded, instantiated
92 * @throws SAXException If any parse errors occur.
93 * @throws IOException If operation on xml file failed.
94 */
95 @BeforeTest
96 public void setup() throws ParserConfigurationException, SAXException, IOException {
97 document = DocumentBuilderFactory.newInstance().newDocumentBuilder().parse(XML_PATH.toFile());
98 xpath = XPathFactory.newInstance().newXPath();
99 }
100
101 /**
102 * Test for evaluate(java.lang.Object item,QName returnType)throws
103 * XPathExpressionException.
104 */
105 @Test
106 public void testCheckXPathExpression01() {
107 try {
108 assertEquals(xpath.compile(EXPRESSION_NAME_A).
109 evaluate(document, STRING), "6");
110 } catch (XPathExpressionException ex) {
111 failUnexpected(ex);
112 }
113 }
114
115 /**
116 * evaluate(java.lang.Object item,QName returnType) throws NPE if input
117 * source is null.
118 */
119 @Test(expectedExceptions = NullPointerException.class)
120 public void testCheckXPathExpression02() {
121 try {
122 xpath.compile(EXPRESSION_NAME_A).evaluate(null, STRING);
123 } catch (XPathExpressionException ex) {
124 failUnexpected(ex);
125 }
126 }
127
128 /**
129 * evaluate(java.lang.Object item,QName returnType) throws NPE if returnType
130 * is null.
131 */
132 @Test(expectedExceptions = NullPointerException.class)
133 public void testCheckXPathExpression03() {
134 try {
135 xpath.compile(EXPRESSION_NAME_A).evaluate(document, null);
136 } catch (XPathExpressionException ex) {
137 failUnexpected(ex);
138 }
139 }
140
141 /**
142 * Test for method evaluate(java.lang.Object item,QName returnType).If a
143 * request is made to evaluate the expression in the absence of a context
144 * item, simple expressions, such as "1+1", can be evaluated.
145 */
146 @Test
147 public void testCheckXPathExpression04() {
148 try {
149 assertEquals(xpath.compile("1+1").evaluate(document, STRING), "2");
150 } catch (XPathExpressionException ex) {
151 failUnexpected(ex);
152 }
153 }
154
155 /**
156 * evaluate(java.lang.Object item,QName returnType) throws IAE If returnType
157 * is not one of the types defined in XPathConstants.
158 */
159 @Test(expectedExceptions = IllegalArgumentException.class)
160 public void testCheckXPathExpression05() {
161 try {
162 xpath.compile(EXPRESSION_NAME_A).evaluate(document, TEST_QNAME);
163 } catch (XPathExpressionException ex) {
164 failUnexpected(ex);
165 }
166 }
167
168 /**
169 * evaluate(java.lang.Object item,QName returnType) return correct boolean
170 * value if returnType is Boolean.
171 */
172 @Test
173 public void testCheckXPathExpression06() {
174 try {
175 assertEquals(xpath.compile(EXPRESSION_NAME_A).
176 evaluate(document, BOOLEAN), true);
177 } catch (XPathExpressionException ex) {
178 failUnexpected(ex);
179 }
180 }
181
182 /**
183 * evaluate(java.lang.Object item,QName returnType) return correct boolean
184 * value if returnType is Boolean.
185 */
186 @Test
187 public void testCheckXPathExpression07() {
188 try {
189 assertEquals(xpath.compile(EXPRESSION_NAME_B).
190 evaluate(document, BOOLEAN), false);
191 } catch (XPathExpressionException ex) {
192 failUnexpected(ex);
193 }
194 }
195
196 /**
197 * evaluate(java.lang.Object item,QName returnType) return correct number
198 * value when return type is Double.
199 */
200 @Test
201 public void testCheckXPathExpression08() {
202 try {
203 assertEquals(xpath.compile(EXPRESSION_NAME_A).
204 evaluate(document, NUMBER), 6d);
205 } catch (XPathExpressionException ex) {
206 failUnexpected(ex);
207 }
208 }
209
210 /**
211 * evaluate(java.lang.Object item,QName returnType) evaluate an attribute
212 * value which returnType is Node.
213 */
214 @Test
215 public void testCheckXPathExpression09() {
216 try {
217 Attr attr = (Attr) xpath.compile(EXPRESSION_NAME_A).
218 evaluate(document, NODE);
219 assertEquals(attr.getValue(), "6");
220 } catch (XPathExpressionException ex) {
221 failUnexpected(ex);
222 }
223 }
224
225 /**
226 * evaluate(java.lang.Object item,QName returnType) evaluate an attribute
227 * value which returnType is NodeList.
228 */
229 @Test
230 public void testCheckXPathExpression10() {
231 try {
232 NodeList nodeList = (NodeList) xpath.compile(EXPRESSION_NAME_A).
233 evaluate(document, NODESET);
234 Attr attr = (Attr) nodeList.item(0);
235 assertEquals(attr.getValue(), "6");
236 } catch (XPathExpressionException ex) {
237 failUnexpected(ex);
238 }
239 }
240
241 /**
242 * Test for evaluate(java.lang.Object item) when returnType is left off of
243 * the XPath.evaluate method, all expressions are evaluated to a String
244 * value.
245 */
246 @Test
247 public void testCheckXPathExpression11() {
248 try {
249 assertEquals(xpath.compile(EXPRESSION_NAME_A).evaluate(document), "6");
250 } catch (XPathExpressionException ex) {
251 failUnexpected(ex);
252 }
253 }
254
255 /**
256 * evaluate(java.lang.Object item) throws NPE if expression is null.
257 */
258 @Test(expectedExceptions = NullPointerException.class)
259 public void testCheckXPathExpression12() {
260 try {
261 xpath.compile(null).evaluate(document);
262 } catch (XPathExpressionException ex) {
263 failUnexpected(ex);
264 }
265 }
266
267 /**
268 * evaluate(java.lang.Object item) when a request is made to evaluate the
269 * expression in the absence of a context item, simple expressions, such as
270 * "1+1", can be evaluated.
271 */
272 @Test
273 public void testCheckXPathExpression13() {
274 try {
275 assertEquals(xpath.compile("1+1").evaluate(document), "2");
276 } catch (XPathExpressionException ex) {
277 failUnexpected(ex);
278 }
279 }
280
281 /**
282 * evaluate(java.lang.Object item) throws NPE if document is null.
283 */
284 @Test(expectedExceptions = NullPointerException.class)
285 public void testCheckXPathExpression14() {
286 try {
287 xpath.compile(EXPRESSION_NAME_A).evaluate(null);
288 } catch (XPathExpressionException ex) {
289 failUnexpected(ex);
290 }
291 }
292
293 /**
294 * valuate(InputSource source) return a string value if return type is
295 * String.
296 */
297 @Test
298 public void testCheckXPathExpression15() {
299 try (InputStream is = Files.newInputStream(XML_PATH)) {
300 assertEquals(xpath.compile(EXPRESSION_NAME_A).
301 evaluate(new InputSource(is)), "6");
302 } catch (XPathExpressionException | IOException ex) {
303 failUnexpected(ex);
304 }
305 }
306
307 /**
308 * evaluate(InputSource source) throws NPE if input source is null.
309 */
310 @Test(expectedExceptions = NullPointerException.class)
311 public void testCheckXPathExpression16() {
312 try {
313 xpath.compile(EXPRESSION_NAME_A).evaluate(null);
314 } catch (XPathExpressionException ex) {
315 failUnexpected(ex);
316 }
317 }
318
319 /**
320 * evaluate(InputSource source) throws NPE if expression is null
321 */
322 @Test(expectedExceptions = NullPointerException.class)
323 public void testCheckXPathExpression17() {
324 try (InputStream is = Files.newInputStream(XML_PATH)) {
325 xpath.compile(null).evaluate(new InputSource(is));
326 } catch (XPathExpressionException | IOException ex) {
327 failUnexpected(ex);
328 }
329 }
330
331 /**
332 * evaluate(InputSource source) throws XPathExpressionException if
333 * returnType is String junk characters.
334 *
335 * @throws XPathExpressionException
336 */
337 @Test(expectedExceptions = XPathExpressionException.class)
338 public void testCheckXPathExpression18() throws XPathExpressionException {
339 try (InputStream is = Files.newInputStream(XML_PATH)) {
340 xpath.compile("-*&").evaluate(new InputSource(is));
341 } catch (IOException ex) {
342 failUnexpected(ex);
343 }
344 }
345
346 /**
347 * evaluate(InputSource source) throws XPathExpressionException if
348 * expression is a blank string " ".
349 *
350 * @throws XPathExpressionException
351 */
352 @Test(expectedExceptions = XPathExpressionException.class)
353 public void testCheckXPathExpression19() throws XPathExpressionException {
354 try (InputStream is = Files.newInputStream(XML_PATH)) {
355 xpath.compile(" ").evaluate(new InputSource(is));
356 } catch (IOException ex) {
357 failUnexpected(ex);
358 }
359 }
360
361 /**
362 * Test for evaluate(InputSource source,QName returnType) returns a string
363 * value if returnType is String.
364 */
365 @Test
366 public void testCheckXPathExpression20() {
367 try (InputStream is = Files.newInputStream(XML_PATH)) {
368 assertEquals(xpath.compile(EXPRESSION_NAME_A).
369 evaluate(new InputSource(is), STRING), "6");
370 } catch (XPathExpressionException | IOException ex) {
371 failUnexpected(ex);
372 }
373 }
374
375 /**
376 * evaluate(InputSource source,QName returnType) throws NPE if source is
377 * null.
378 */
379 @Test(expectedExceptions = NullPointerException.class)
380 public void testCheckXPathExpression21() {
381 try {
382 xpath.compile(EXPRESSION_NAME_A).evaluate(null, STRING);
383 } catch (XPathExpressionException ex) {
384 failUnexpected(ex);
385 }
386 }
387
388 /**
389 * evaluate(InputSource source,QName returnType) throws NPE if expression is
390 * null.
391 */
392 @Test(expectedExceptions = NullPointerException.class)
393 public void testCheckXPathExpression22() {
394 try (InputStream is = Files.newInputStream(XML_PATH)) {
395 xpath.compile(null).evaluate(new InputSource(is), STRING);
396 } catch (XPathExpressionException | IOException ex) {
397 failUnexpected(ex);
398 }
399 }
400
401 /**
402 * evaluate(InputSource source,QName returnType) throws NPE if returnType is
403 * null.
404 */
405 @Test(expectedExceptions = NullPointerException.class)
406 public void testCheckXPathExpression23() {
407 try (InputStream is = Files.newInputStream(XML_PATH)) {
408 xpath.compile(EXPRESSION_NAME_A).evaluate(new InputSource(is), null);
409 } catch (XPathExpressionException | IOException ex) {
410 failUnexpected(ex);
411 }
412 }
413
414 /**
415 * evaluate(InputSource source,QName returnType) throws
416 * XPathExpressionException if expression is junk characters.
417 *
418 * @throws XPathExpressionException
419 */
420 @Test(expectedExceptions = XPathExpressionException.class)
421 public void testCheckXPathExpression24() throws XPathExpressionException {
422 try (InputStream is = Files.newInputStream(XML_PATH)) {
423 xpath.compile("-*&").evaluate(new InputSource(is), STRING);
424 } catch (IOException ex) {
425 failUnexpected(ex);
426 }
427 }
428
429 /**
430 * evaluate(InputSource source,QName returnType) throws
431 * XPathExpressionException if expression is blank " ".
432 *
433 * @throws XPathExpressionException
434 */
435 @Test(expectedExceptions = XPathExpressionException.class)
436 public void testCheckXPathExpression25() throws XPathExpressionException {
437 try (InputStream is = Files.newInputStream(XML_PATH)) {
438 xpath.compile(" ").evaluate(new InputSource(is), STRING);
439 } catch (IOException ex) {
440 failUnexpected(ex);
441 }
442 }
443
444 /**
445 * evaluate(InputSource source,QName returnType) throws
446 * IllegalArgumentException if returnType is not one of the types defined
447 * in XPathConstants.
448 */
449 @Test(expectedExceptions = IllegalArgumentException.class)
450 public void testCheckXPathExpression26() {
451 try (InputStream is = Files.newInputStream(XML_PATH)) {
452 xpath.compile(EXPRESSION_NAME_A).evaluate(new InputSource(is), TEST_QNAME);
453 } catch (XPathExpressionException | IOException ex) {
454 failUnexpected(ex);
455 }
456 }
457
458 /**
459 * evaluate(InputSource source,QName returnType) return a correct boolean
460 * value if returnType is Boolean.
461 */
462 @Test
463 public void testCheckXPathExpression27() {
464 try (InputStream is = Files.newInputStream(XML_PATH)) {
465 assertEquals(xpath.compile(EXPRESSION_NAME_A).
466 evaluate(new InputSource(is), BOOLEAN), true);
467 } catch (XPathExpressionException | IOException ex) {
468 failUnexpected(ex);
469 }
470 }
471
472 /**
473 * evaluate(InputSource source,QName returnType) return a correct boolean
474 * value if returnType is Boolean.
475 */
476 @Test
477 public void testCheckXPathExpression28() {
478 try (InputStream is = Files.newInputStream(XML_PATH)) {
479 assertEquals(xpath.compile(EXPRESSION_NAME_B).
480 evaluate(new InputSource(is), BOOLEAN), false);
481 } catch (XPathExpressionException | IOException ex) {
482 failUnexpected(ex);
483 }
484 }
485
486 /**
487 * evaluate(InputSource source,QName returnType) return a correct number
488 * value if returnType is Number.
489 */
490 @Test
491 public void testCheckXPathExpression29() {
492 try (InputStream is = Files.newInputStream(XML_PATH)) {
493 assertEquals(xpath.compile(EXPRESSION_NAME_A).
494 evaluate(new InputSource(is), NUMBER), 6d);
495 } catch (XPathExpressionException | IOException ex) {
496 failUnexpected(ex);
497 }
498 }
499
500 /**
501 * Test for evaluate(InputSource source,QName returnType) returns a node if
502 * returnType is Node.
503 */
504 @Test
505 public void testCheckXPathExpression30() {
506 try (InputStream is = Files.newInputStream(XML_PATH)) {
507 Attr attr = (Attr) xpath.compile(EXPRESSION_NAME_A).
508 evaluate(new InputSource(is), NODE);
509 assertEquals(attr.getValue(), "6");
510 } catch (XPathExpressionException | IOException ex) {
511 failUnexpected(ex);
512 }
513 }
514
515 /**
516 * Test for evaluate(InputSource source,QName returnType) return a node list
517 * if returnType is NodeList.
518 */
519 @Test
520 public void testCheckXPathExpression31() {
521 try (InputStream is = Files.newInputStream(XML_PATH)) {
522 NodeList nodeList = (NodeList) xpath.compile(EXPRESSION_NAME_A).
523 evaluate(new InputSource(is), NODESET);
524 assertEquals(((Attr) nodeList.item(0)).getValue(), "6");
525 } catch (XPathExpressionException | IOException ex) {
526 failUnexpected(ex);
527 }
528 }
529 }