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 }

   1 /*
   2  * Copyright (c) 2003, 2015, 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.FilePermission;
  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.xpath.XPath;
  35 import static javax.xml.xpath.XPathConstants.BOOLEAN;
  36 import static javax.xml.xpath.XPathConstants.NODE;
  37 import static javax.xml.xpath.XPathConstants.NODESET;
  38 import static javax.xml.xpath.XPathConstants.NUMBER;
  39 import static javax.xml.xpath.XPathConstants.STRING;
  40 import javax.xml.xpath.XPathExpressionException;
  41 import javax.xml.xpath.XPathFactory;
  42 import static javax.xml.xpath.ptests.XPathTestConst.XML_DIR;
  43 import jaxp.library.JAXPFileReadOnlyBaseTest;
  44 import static org.testng.Assert.assertEquals;
  45 import org.testng.annotations.BeforeTest;
  46 import org.testng.annotations.Test;
  47 import org.w3c.dom.Attr;
  48 import org.w3c.dom.Document;
  49 import org.w3c.dom.NodeList;
  50 import org.xml.sax.InputSource;

  51 
  52 /**
  53  * Class containing the test cases for XPathExpression API.
  54  */
  55 public class XPathExpressionTest extends JAXPFileReadOnlyBaseTest {
  56     /**
  57      * Document object for testing XML file.
  58      */
  59     private Document document;
  60 
  61     /**
  62      * A XPath for evaluation environment and expressions.
  63      */
  64     private XPath xpath;
  65 
  66     /**
  67      * A QName using default name space.
  68      */
  69     private static final QName TEST_QNAME = new QName(XMLConstants.XML_NS_URI, "");
  70 
  71     /**
  72      * XML File Path.
  73      */
  74     private static final Path XML_PATH = Paths.get(XML_DIR + "widgets.xml");
  75 
  76     /**
  77      * An expression name which locate at "/widgets/widget[@name='a']/@quantity"
  78      */
  79     private static final String EXPRESSION_NAME_A = "/widgets/widget[@name='a']/@quantity";
  80 
  81     /**
  82      * An expression name which locate at "/widgets/widget[@name='b']/@quantity"
  83      */
  84     private static final String EXPRESSION_NAME_B = "/widgets/widget[@name='b']/@quantity";
  85 
  86     /**
  87      * Create Document object and XPath object for every time
  88      * @throws Exception If any errors occur.



  89      */
  90     @BeforeTest
  91     public void setup() throws Exception {
  92         setPermissions(new FilePermission(XML_PATH.toFile().toString(), "read"));
  93         document = DocumentBuilderFactory.newInstance().newDocumentBuilder().parse(XML_PATH.toFile());
  94         xpath = XPathFactory.newInstance().newXPath();
  95     }
  96 
  97     /**
  98      * Test for evaluate(java.lang.Object item,QName returnType)throws
  99      * XPathExpressionException.
 100      * 
 101      * @throws XPathExpressionException If the expression cannot be evaluated.
 102      */
 103     @Test
 104     public void testCheckXPathExpression01() throws XPathExpressionException {

 105         assertEquals(xpath.compile(EXPRESSION_NAME_A).
 106                 evaluate(document, STRING), "6");



 107     }
 108 
 109     /**
 110      * evaluate(java.lang.Object item,QName returnType) throws NPE if input
 111      * source is null.
 112      * 
 113      * @throws XPathExpressionException If the expression cannot be evaluated.
 114      */
 115     @Test(expectedExceptions = NullPointerException.class)
 116     public void testCheckXPathExpression02() throws XPathExpressionException {

 117         xpath.compile(EXPRESSION_NAME_A).evaluate(null, STRING);



 118     }
 119 
 120     /**
 121      * evaluate(java.lang.Object item,QName returnType) throws NPE if returnType
 122      * is null.
 123      * 
 124      * @throws XPathExpressionException If the expression cannot be evaluated.
 125      */
 126     @Test(expectedExceptions = NullPointerException.class)
 127     public void testCheckXPathExpression03() throws XPathExpressionException {

 128         xpath.compile(EXPRESSION_NAME_A).evaluate(document, null);



 129     }
 130 
 131     /**
 132      * Test for method evaluate(java.lang.Object item,QName returnType).If a
 133      * request is made to evaluate the expression in the absence of a context
 134      * item, simple expressions, such as "1+1", can be evaluated.
 135      * 
 136      * @throws XPathExpressionException If the expression cannot be evaluated.
 137      */
 138     @Test
 139     public void testCheckXPathExpression04() throws XPathExpressionException {

 140         assertEquals(xpath.compile("1+1").evaluate(document, STRING), "2");



 141     }
 142 
 143     /**
 144      * evaluate(java.lang.Object item,QName returnType) throws IAE If returnType
 145      * is not one of the types defined in XPathConstants.
 146      * 
 147      * @throws XPathExpressionException If the expression cannot be evaluated.
 148      */
 149     @Test(expectedExceptions = IllegalArgumentException.class)
 150     public void testCheckXPathExpression05() throws XPathExpressionException {

 151         xpath.compile(EXPRESSION_NAME_A).evaluate(document, TEST_QNAME);



 152     }
 153 
 154     /**
 155      * evaluate(java.lang.Object item,QName returnType) return correct boolean
 156      * value if returnType is Boolean.
 157      * 
 158      * @throws XPathExpressionException If the expression cannot be evaluated.
 159      */
 160     @Test
 161     public void testCheckXPathExpression06() throws XPathExpressionException {

 162         assertEquals(xpath.compile(EXPRESSION_NAME_A).
 163                 evaluate(document, BOOLEAN), true);



 164     }
 165 
 166     /**
 167      * evaluate(java.lang.Object item,QName returnType) return correct boolean
 168      * value if returnType is Boolean.
 169      * 
 170      * @throws XPathExpressionException If the expression cannot be evaluated.
 171      */
 172     @Test
 173     public void testCheckXPathExpression07() throws XPathExpressionException {

 174         assertEquals(xpath.compile(EXPRESSION_NAME_B).
 175             evaluate(document, BOOLEAN), false);



 176     }
 177 
 178     /**
 179      * evaluate(java.lang.Object item,QName returnType) return correct number
 180      * value when return type is Double.
 181      * 
 182      * @throws XPathExpressionException If the expression cannot be evaluated.
 183      */
 184     @Test
 185     public void testCheckXPathExpression08() throws XPathExpressionException {

 186         assertEquals(xpath.compile(EXPRESSION_NAME_A).
 187             evaluate(document, NUMBER), 6d);



 188     }
 189 
 190     /**
 191      * evaluate(java.lang.Object item,QName returnType) evaluate an attribute
 192      * value which returnType is Node.
 193      * 
 194      * @throws XPathExpressionException If the expression cannot be evaluated.
 195      */
 196     @Test
 197     public void testCheckXPathExpression09() throws XPathExpressionException {

 198         Attr attr = (Attr) xpath.compile(EXPRESSION_NAME_A).
 199                 evaluate(document, NODE);
 200         assertEquals(attr.getValue(), "6");



 201     }
 202 
 203     /**
 204      * evaluate(java.lang.Object item,QName returnType) evaluate an attribute
 205      * value which returnType is NodeList.
 206      * 
 207      * @throws XPathExpressionException If the expression cannot be evaluated.
 208      */
 209     @Test
 210     public void testCheckXPathExpression10() throws XPathExpressionException {

 211         NodeList nodeList = (NodeList) xpath.compile(EXPRESSION_NAME_A).
 212                 evaluate(document, NODESET);
 213         Attr attr = (Attr) nodeList.item(0);
 214         assertEquals(attr.getValue(), "6");



 215     }
 216 
 217     /**
 218      * Test for evaluate(java.lang.Object item) when returnType is left off of
 219      * the XPath.evaluate method, all expressions are evaluated to a String
 220      * value.
 221      * 
 222      * @throws XPathExpressionException If the expression cannot be evaluated.
 223      */
 224     @Test
 225     public void testCheckXPathExpression11() throws XPathExpressionException {

 226         assertEquals(xpath.compile(EXPRESSION_NAME_A).evaluate(document), "6");



 227     }
 228 
 229     /**
 230      * evaluate(java.lang.Object item) throws NPE if expression is null.
 231      * 
 232      * @throws XPathExpressionException If the expression cannot be evaluated.
 233      */
 234     @Test(expectedExceptions = NullPointerException.class)
 235     public void testCheckXPathExpression12() throws XPathExpressionException {

 236         xpath.compile(null).evaluate(document);



 237     }
 238 
 239     /**
 240      * evaluate(java.lang.Object item) when a request is made to evaluate the
 241      * expression in the absence of a context item, simple expressions, such as
 242      * "1+1", can be evaluated.
 243      * 
 244      * @throws XPathExpressionException If the expression cannot be evaluated.
 245      */
 246     @Test
 247     public void testCheckXPathExpression13() throws XPathExpressionException {

 248         assertEquals(xpath.compile("1+1").evaluate(document), "2");



 249     }
 250 
 251     /**
 252      * evaluate(java.lang.Object item) throws NPE if document is null.
 253      * 
 254      * @throws XPathExpressionException If the expression cannot be evaluated.
 255      */
 256     @Test(expectedExceptions = NullPointerException.class)
 257     public void testCheckXPathExpression14() throws XPathExpressionException {

 258         xpath.compile(EXPRESSION_NAME_A).evaluate(null);



 259     }
 260 
 261     /**
 262      * valuate(InputSource source) return a string value if return type is
 263      * String.
 264      * 
 265      * @throws Exception If any errors occur.
 266      */
 267     @Test (groups = {"readLocalFiles"})
 268     public void testCheckXPathExpression15() throws Exception {
 269         try (InputStream is = Files.newInputStream(XML_PATH)) {
 270             assertEquals(xpath.compile(EXPRESSION_NAME_A).
 271                     evaluate(new InputSource(is)), "6");


 272         }
 273     }
 274 
 275     /**
 276      * evaluate(InputSource source) throws NPE if input source is null.
 277      * 
 278      * @throws XPathExpressionException If the expression cannot be evaluated.
 279      */
 280     @Test(expectedExceptions = NullPointerException.class)
 281     public void testCheckXPathExpression16() throws XPathExpressionException {

 282         xpath.compile(EXPRESSION_NAME_A).evaluate(null);



 283     }
 284 
 285     /**
 286      * evaluate(InputSource source) throws NPE if expression is null.
 287      * 
 288      * @throws Exception If any errors occur.
 289      */
 290     @Test(groups = {"readLocalFiles"}, expectedExceptions = NullPointerException.class)
 291     public void testCheckXPathExpression17() throws Exception {
 292         try (InputStream is = Files.newInputStream(XML_PATH)) {
 293             xpath.compile(null).evaluate(new InputSource(is));


 294         }
 295     }
 296 
 297     /**
 298      * evaluate(InputSource source) throws XPathExpressionException if
 299      * returnType is String junk characters.
 300      * 
 301      * @throws Exception If any errors occur.
 302      */
 303     @Test(groups = {"readLocalFiles"}, expectedExceptions = XPathExpressionException.class)
 304     public void testCheckXPathExpression18() throws Exception {
 305         try (InputStream is = Files.newInputStream(XML_PATH)) {
 306             xpath.compile("-*&").evaluate(new InputSource(is));


 307         }
 308     }
 309 
 310     /**
 311      * evaluate(InputSource source) throws XPathExpressionException if
 312      * expression is a blank string " ".
 313      * 
 314      * @throws Exception If any errors occur.
 315      */
 316     @Test(groups = {"readLocalFiles"}, expectedExceptions = XPathExpressionException.class)
 317     public void testCheckXPathExpression19() throws Exception {
 318         try (InputStream is = Files.newInputStream(XML_PATH)) {
 319             xpath.compile(" ").evaluate(new InputSource(is));


 320         }
 321     }
 322 
 323     /**
 324      * Test for evaluate(InputSource source,QName returnType) returns a string
 325      * value if returnType is String.
 326      * 
 327      * @throws Exception If any errors occur.
 328      */
 329     @Test(groups = {"readLocalFiles"})
 330     public void testCheckXPathExpression20() throws Exception {
 331         try (InputStream is = Files.newInputStream(XML_PATH)) {
 332             assertEquals(xpath.compile(EXPRESSION_NAME_A).
 333                 evaluate(new InputSource(is), STRING), "6");


 334         }
 335     }
 336 
 337     /**
 338      * evaluate(InputSource source,QName returnType) throws NPE if source is
 339      * null.
 340      * 
 341      * @throws XPathExpressionException If the expression cannot be evaluated.
 342      */
 343     @Test(expectedExceptions = NullPointerException.class)
 344     public void testCheckXPathExpression21() throws XPathExpressionException {

 345         xpath.compile(EXPRESSION_NAME_A).evaluate(null, STRING);



 346     }
 347 
 348     /**
 349      * evaluate(InputSource source,QName returnType) throws NPE if expression is
 350      * null.
 351      * 
 352      * @throws Exception If any errors occur.
 353      */
 354     @Test(groups = {"readLocalFiles"}, expectedExceptions = NullPointerException.class)
 355     public void testCheckXPathExpression22() throws Exception {
 356         try (InputStream is = Files.newInputStream(XML_PATH)) {
 357             xpath.compile(null).evaluate(new InputSource(is), STRING);


 358         }
 359     }
 360 
 361     /**
 362      * evaluate(InputSource source,QName returnType) throws NPE if returnType is
 363      * null.
 364      * 
 365      * @throws Exception If any errors occur.
 366      */
 367     @Test(groups = {"readLocalFiles"}, expectedExceptions = NullPointerException.class)
 368     public void testCheckXPathExpression23() throws Exception {
 369         try (InputStream is = Files.newInputStream(XML_PATH)) {
 370             xpath.compile(EXPRESSION_NAME_A).evaluate(new InputSource(is), null);


 371         }
 372     }
 373 
 374     /**
 375      * evaluate(InputSource source,QName returnType) throws
 376      * XPathExpressionException if expression is junk characters.
 377      * 
 378      * @throws Exception If any errors occur.
 379      */
 380     @Test(groups = {"readLocalFiles"}, expectedExceptions = XPathExpressionException.class)
 381     public void testCheckXPathExpression24() throws Exception {
 382         try (InputStream is = Files.newInputStream(XML_PATH)) {
 383             xpath.compile("-*&").evaluate(new InputSource(is), STRING);


 384         }
 385     }
 386 
 387     /**
 388      * evaluate(InputSource source,QName returnType) throws
 389      * XPathExpressionException if expression is blank " ".
 390      * 
 391      * @throws Exception If any errors occur.
 392      */
 393     @Test(groups = {"readLocalFiles"}, expectedExceptions = XPathExpressionException.class)
 394     public void testCheckXPathExpression25() throws Exception {
 395         try (InputStream is = Files.newInputStream(XML_PATH)) {
 396             xpath.compile(" ").evaluate(new InputSource(is), STRING);


 397         }
 398     }
 399 
 400     /**
 401      * evaluate(InputSource source,QName returnType) throws
 402      * IllegalArgumentException if returnType is not one of the types defined
 403      * in XPathConstants.
 404      * 
 405      * @throws Exception If any errors occur.
 406      */
 407     @Test(groups = {"readLocalFiles"}, expectedExceptions = IllegalArgumentException.class)
 408     public void testCheckXPathExpression26() throws Exception {
 409         try (InputStream is = Files.newInputStream(XML_PATH)) {
 410             xpath.compile(EXPRESSION_NAME_A).evaluate(new InputSource(is), TEST_QNAME);


 411         }
 412     }
 413 
 414     /**
 415      * evaluate(InputSource source,QName returnType) return a correct boolean
 416      * value if returnType is Boolean.
 417      * 
 418      * @throws Exception If any errors occur.
 419      */
 420     @Test(groups = {"readLocalFiles"})
 421     public void testCheckXPathExpression27() throws Exception {
 422         try (InputStream is = Files.newInputStream(XML_PATH)) {
 423             assertEquals(xpath.compile(EXPRESSION_NAME_A).
 424                 evaluate(new InputSource(is), BOOLEAN), true);


 425         }
 426     }
 427 
 428     /**
 429      * evaluate(InputSource source,QName returnType) return a correct boolean
 430      * value if returnType is Boolean.
 431      * 
 432      * @throws Exception If any errors occur.
 433      */
 434     @Test(groups = {"readLocalFiles"})
 435     public void testCheckXPathExpression28() throws Exception {
 436         try (InputStream is = Files.newInputStream(XML_PATH)) {
 437             assertEquals(xpath.compile(EXPRESSION_NAME_B).
 438                 evaluate(new InputSource(is), BOOLEAN), false);


 439         }
 440     }
 441 
 442     /**
 443      * evaluate(InputSource source,QName returnType) return a correct number
 444      * value if returnType is Number.
 445      * 
 446      * @throws Exception If any errors occur.
 447      */
 448     @Test(groups = {"readLocalFiles"})
 449     public void testCheckXPathExpression29() throws Exception {
 450         try (InputStream is = Files.newInputStream(XML_PATH)) {
 451             assertEquals(xpath.compile(EXPRESSION_NAME_A).
 452                 evaluate(new InputSource(is), NUMBER), 6d);


 453         }
 454     }
 455 
 456     /**
 457      * Test for evaluate(InputSource source,QName returnType) returns a node if
 458      * returnType is Node.
 459      * 
 460      * @throws Exception If any errors occur.
 461      */
 462     @Test(groups = {"readLocalFiles"})
 463     public void testCheckXPathExpression30() throws Exception {
 464         try (InputStream is = Files.newInputStream(XML_PATH)) {
 465             Attr attr = (Attr) xpath.compile(EXPRESSION_NAME_A).
 466                 evaluate(new InputSource(is), NODE);
 467             assertEquals(attr.getValue(), "6");


 468         }
 469     }
 470 
 471     /**
 472      * Test for evaluate(InputSource source,QName returnType) return a node list
 473      * if returnType is NodeList.
 474      * 
 475      * @throws Exception If any errors occur.
 476      */
 477     @Test(groups = {"readLocalFiles"})
 478     public void testCheckXPathExpression31() throws Exception {
 479         try (InputStream is = Files.newInputStream(XML_PATH)) {
 480             NodeList nodeList = (NodeList) xpath.compile(EXPRESSION_NAME_A).
 481                 evaluate(new InputSource(is), NODESET);
 482             assertEquals(((Attr) nodeList.item(0)).getValue(), "6");


 483         }
 484     }
 485 }