< prev index next >

test/javax/xml/jaxp/functional/javax/xml/xpath/ptests/XPathTest.java

Print this page


   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 java.util.Iterator;

  32 import javax.xml.XMLConstants;
  33 import javax.xml.namespace.NamespaceContext;
  34 import javax.xml.namespace.QName;
  35 import javax.xml.parsers.DocumentBuilderFactory;
  36 import javax.xml.xpath.XPath;
  37 import static javax.xml.xpath.XPathConstants.BOOLEAN;
  38 import static javax.xml.xpath.XPathConstants.NODE;
  39 import static javax.xml.xpath.XPathConstants.NODESET;
  40 import static javax.xml.xpath.XPathConstants.NUMBER;
  41 import static javax.xml.xpath.XPathConstants.STRING;
  42 import javax.xml.xpath.XPathExpressionException;
  43 import javax.xml.xpath.XPathFactory;
  44 import static javax.xml.xpath.ptests.XPathTestConst.XML_DIR;
  45 import jaxp.library.JAXPFileReadOnlyBaseTest;
  46 import static org.testng.AssertJUnit.assertEquals;
  47 import static org.testng.AssertJUnit.assertNotNull;
  48 import static org.testng.AssertJUnit.assertNull;
  49 import org.testng.annotations.BeforeTest;

  50 import org.testng.annotations.Test;
  51 import org.w3c.dom.Attr;
  52 import org.w3c.dom.Document;
  53 import org.w3c.dom.NodeList;
  54 import org.xml.sax.InputSource;
  55 
  56 /**
  57  * Class containing the test cases for XPath API.
  58  */
  59 public class XPathTest extends JAXPFileReadOnlyBaseTest {

  60     /**
  61      * Document object for testing XML file.
  62      */
  63     private Document document;
  64 
  65     /**
  66      * A XPath for evaluation environment and expressions.
  67      */
  68     private XPath xpath;
  69 
  70     /**
  71      * A QName using default name space.
  72      */
  73     private static final QName TEST_QNAME = new QName(XMLConstants.XML_NS_URI, "");
  74 
  75     /**
  76      * XML File Path.
  77      */
  78     private static final Path XML_PATH = Paths.get(XML_DIR + "widgets.xml");
  79 
  80     /**
  81      * An expression name which locate at "/widgets/widget[@name='a']/@quantity"
  82      */
  83     private static final String EXPRESSION_NAME_A = "/widgets/widget[@name='a']/@quantity";
  84 
  85     /**
  86      * An expression name which locate at "/widgets/widget[@name='b']/@quantity"
  87      */
  88     private static final String EXPRESSION_NAME_B = "/widgets/widget[@name='b']/@quantity";
  89 
  90     /**
  91      * Create Document object and XPath object for every time
  92      * @throws Exception If any errors occur.
  93      */
  94     @BeforeTest
  95     public void setup() throws Exception {
  96         setPermissions(new FilePermission(XML_DIR + "-", "read"));
  97         document = DocumentBuilderFactory.newInstance().newDocumentBuilder().parse(XML_PATH.toFile());
  98         xpath = XPathFactory.newInstance().newXPath();
  99     }
 100 
 101     /**
 102      * Test for XPath.evaluate(java.lang.String expression, java.lang.Object
 103      * item, QName returnType) which return type is String.
 104      *
 105      * @throws XPathExpressionException If the expression cannot be evaluated.
 106      */
 107     @Test
 108     public void testCheckXPath01() throws XPathExpressionException {
 109         assertEquals(xpath.evaluate(EXPRESSION_NAME_A, document, STRING), "6");
 110     }
 111 
 112 
 113     /**
 114      * Test for XPath.compile(java.lang.String expression) and then
 115      * evaluate(java.lang.Object item, QName returnType).
 116      *


 330         assertEquals(xpath.evaluate("1+1", document), "2");
 331     }
 332 
 333     /**
 334      * XPath.evaluate(java.lang.String expression, java.lang.Object item) throws
 335      * NPE if InputSource is null.
 336      *
 337      * @throws XPathExpressionException If the expression cannot be evaluated.
 338      */
 339     @Test(expectedExceptions = NullPointerException.class)
 340     public void testCheckXPath21() throws XPathExpressionException {
 341         xpath.evaluate(EXPRESSION_NAME_A, null);
 342     }
 343 
 344     /**
 345      * XPath.evaluate(java.lang.String expression, InputSource source) return
 346      * correct value by looking for Node.
 347      *
 348      * @throws Exception If any errors occur.
 349      */
 350     @Test (groups = {"readLocalFiles"})
 351     public void testCheckXPath22() throws Exception {
 352         try (InputStream is = Files.newInputStream(XML_PATH)) {
 353             assertEquals(xpath.evaluate(EXPRESSION_NAME_A, new InputSource(is)), "6");
 354         }
 355     }
 356 
 357     /**
 358      * XPath.evaluate(java.lang.String expression, InputSource source) throws
 359      * NPE if InputSource is null.
 360      *
 361      * @throws XPathExpressionException If the expression cannot be evaluated.
 362      */
 363     @Test(expectedExceptions = NullPointerException.class)
 364     public void testCheckXPath23() throws XPathExpressionException {
 365         xpath.evaluate(EXPRESSION_NAME_A, null);
 366     }
 367 
 368     /**
 369      * XPath.evaluate(java.lang.String expression, InputSource source) throws
 370      * NPE if String expression is null.
 371      *
 372      * @throws Exception If any errors occur.
 373      */
 374     @Test(groups = {"readLocalFiles"}, expectedExceptions = NullPointerException.class)
 375     public void testCheckXPath24() throws Exception {
 376         try (InputStream is = Files.newInputStream(XML_PATH)) {
 377             xpath.evaluate(null, new InputSource(is));
 378         }
 379     }
 380 
 381     /**
 382      * Test for XPath.evaluate(java.lang.String expression, InputSource source).
 383      * If expression is junk characters, expression cannot be evaluated, should
 384      * throw XPathExpressionException.
 385      *
 386      * @throws Exception If any errors occur.
 387      */
 388     @Test(groups = {"readLocalFiles"}, expectedExceptions = XPathExpressionException.class)
 389     public void testCheckXPath25() throws Exception {
 390         try (InputStream is = Files.newInputStream(XML_PATH)) {
 391             xpath.evaluate("-*&", new InputSource(is));
 392         }
 393     }
 394 
 395     /**
 396      * XPath.evaluate(java.lang.String expression, InputSource source) throws
 397      * XPathExpressionException if expression is blank " ".
 398      *
 399      * @throws Exception If any errors occur.
 400      */
 401     @Test(groups = {"readLocalFiles"}, expectedExceptions = XPathExpressionException.class)
 402     public void testCheckXPath26() throws Exception {
 403         try (InputStream is = Files.newInputStream(XML_PATH)) {
 404             xpath.evaluate(" ", new InputSource(is));
 405         }
 406     }
 407 
 408     /**
 409      * XPath.evaluate(java.lang.String expression, InputSource source, QName
 410      * returnType) returns correct string value which return type is String.
 411      *
 412      * @throws Exception If any errors occur.
 413      */
 414     @Test(groups = {"readLocalFiles"})
 415     public void testCheckXPath27() throws Exception {
 416         try (InputStream is = Files.newInputStream(XML_PATH)) {
 417             assertEquals(xpath.evaluate(EXPRESSION_NAME_A, new InputSource(is), STRING), "6");
 418         }
 419     }
 420 
 421     /**
 422      * XPath.evaluate(java.lang.String expression, InputSource source, QName
 423      * returnType) throws NPE if source is null.
 424      *
 425      * @throws XPathExpressionException If the expression cannot be evaluated.
 426      */
 427     @Test(expectedExceptions = NullPointerException.class)
 428     public void testCheckXPath28() throws XPathExpressionException {
 429         xpath.evaluate(EXPRESSION_NAME_A, null, STRING);
 430     }
 431 
 432     /**
 433      * XPath.evaluate(java.lang.String expression, InputSource source, QName
 434      * returnType) throws NPE if expression is null.
 435      *
 436      * @throws Exception If any errors occur.
 437      */
 438     @Test(groups = {"readLocalFiles"}, expectedExceptions = NullPointerException.class)
 439     public void testCheckXPath29() throws Exception {
 440         try (InputStream is = Files.newInputStream(XML_PATH)) {
 441             xpath.evaluate(null, new InputSource(is), STRING);
 442         }
 443     }
 444 
 445     /**
 446      * XPath.evaluate(java.lang.String expression, InputSource source,
 447      * QName returnType) throws NPE if returnType is null.
 448      *
 449      * @throws Exception If any errors occur.
 450      */
 451     @Test(groups = {"readLocalFiles"}, expectedExceptions = NullPointerException.class)
 452     public void testCheckXPath30() throws Exception {
 453         try (InputStream is = Files.newInputStream(XML_PATH)) {
 454             xpath.evaluate(EXPRESSION_NAME_A, new InputSource(is), null);
 455         }
 456     }
 457 
 458     /**
 459      * XPath.evaluate(java.lang.String expression, InputSource source, QName
 460      * returnType) throws XPathExpressionException if expression is junk characters.
 461      *
 462      * @throws Exception If any errors occur.
 463      */
 464     @Test(groups = {"readLocalFiles"}, expectedExceptions = XPathExpressionException.class)
 465     public void testCheckXPath31() throws Exception {
 466         try (InputStream is = Files.newInputStream(XML_PATH)) {
 467             xpath.evaluate("-*&", new InputSource(is), STRING);
 468         }
 469     }
 470 
 471     /**
 472      * XPath.evaluate(java.lang.String expression, InputSource source, QName
 473      * returnType) throws XPathExpressionException if expression is blank " ".
 474      *
 475      * @throws Exception If any errors occur.
 476      */
 477     @Test(groups = {"readLocalFiles"}, expectedExceptions = XPathExpressionException.class)
 478     public void testCheckXPath32() throws Exception {
 479         try (InputStream is = Files.newInputStream(XML_PATH)) {
 480             xpath.evaluate(" ", new InputSource(is), STRING);
 481         }
 482     }
 483 
 484     /**
 485      * XPath.evaluate(java.lang.String expression, InputSource source,
 486      * QName returnType) throws IllegalArgumentException if returnType is not
 487      * one of the types defined in XPathConstants.
 488      *
 489      * @throws Exception If any errors occur.
 490      */
 491     @Test(groups = {"readLocalFiles"}, expectedExceptions = IllegalArgumentException.class)
 492     public void testCheckXPath33() throws Exception {
 493         try (InputStream is = Files.newInputStream(XML_PATH)) {
 494             xpath.evaluate(EXPRESSION_NAME_A, new InputSource(is), TEST_QNAME);
 495         }
 496     }
 497 
 498     /**
 499      * XPath.evaluate(java.lang.String expression, InputSource source,
 500      * QName returnType) return correct boolean value if return type is Boolean.
 501      *
 502      * @throws Exception If any errors occur.
 503      */
 504     @Test(groups = {"readLocalFiles"})
 505     public void testCheckXPath34() throws Exception {
 506         try (InputStream is = Files.newInputStream(XML_PATH)) {
 507             assertEquals(xpath.evaluate(EXPRESSION_NAME_A, new InputSource(is),
 508                 BOOLEAN), true);
 509         }
 510     }
 511 
 512     /**
 513      * XPath.evaluate(java.lang.String expression, InputSource source,
 514      * QName returnType) return correct boolean value if return type is Boolean.
 515      *
 516      * @throws Exception If any errors occur.
 517      */
 518     @Test(groups = {"readLocalFiles"})
 519     public void testCheckXPath35() throws Exception {
 520         try (InputStream is = Files.newInputStream(XML_PATH)) {
 521             assertEquals(xpath.evaluate(EXPRESSION_NAME_B, new InputSource(is),
 522                 BOOLEAN), false);
 523         }
 524     }
 525 
 526     /**
 527      * XPath.evaluate(java.lang.String expression, InputSource source,
 528      * QName returnType) return correct number value if return type is Number.
 529      *
 530      * @throws Exception If any errors occur.
 531      */
 532     @Test(groups = {"readLocalFiles"})
 533     public void testCheckXPath36() throws Exception {
 534         try (InputStream is = Files.newInputStream(XML_PATH)) {
 535             assertEquals(xpath.evaluate(EXPRESSION_NAME_A, new InputSource(is),
 536                 NUMBER), 6d);
 537         }
 538     }
 539 
 540     /**
 541      * XPath.evaluate(java.lang.String expression, InputSource source,
 542      * QName returnType) return correct string value if return type is Node.
 543      *
 544      * @throws Exception If any errors occur.
 545      */
 546     @Test(groups = {"readLocalFiles"})
 547     public void testCheckXPath37() throws Exception {
 548         try (InputStream is = Files.newInputStream(XML_PATH)) {
 549             assertEquals(((Attr)xpath.evaluate(EXPRESSION_NAME_A,
 550                 new InputSource(is), NODE)).getValue(), "6");
 551         }
 552     }
 553 
 554     /**
 555      * Test for XPath.evaluate(java.lang.String expression, InputSource source,
 556      * QName returnType) which return type is NodeList.
 557      *
 558      * @throws Exception If any errors occur.
 559      */
 560     @Test(groups = {"readLocalFiles"})
 561     public void testCheckXPath38() throws Exception {
 562         try (InputStream is = Files.newInputStream(XML_PATH)) {
 563             NodeList nodeList = (NodeList)xpath.evaluate(EXPRESSION_NAME_A,
 564                 new InputSource(is), NODESET);
 565             assertEquals(((Attr) nodeList.item(0)).getValue(), "6");
 566         }
 567     }
 568 
 569     /**
 570      * Test for XPath.evaluate(java.lang.String expression, InputSource iSource,
 571      * QName returnType). If return type is Boolean, should return false as
 572      * expression is not successful in evaluating to any result.
 573      *
 574      * @throws Exception If any errors occur.
 575      */
 576     @Test(groups = {"readLocalFiles"})
 577     public void testCheckXPath52() throws Exception {
 578         try (InputStream is = Files.newInputStream(XML_PATH)) {
 579             assertEquals(xpath.evaluate(EXPRESSION_NAME_B, new InputSource(is),
 580                 BOOLEAN), false);
 581         }
 582     }
 583 
 584     /**
 585      * XPath.evaluate(java.lang.String expression, InputSource iSource, QName
 586      * returnType) returns correct number value which return type is Number.
 587      *
 588      * @throws Exception If any errors occur.
 589      */
 590     @Test(groups = {"readLocalFiles"})
 591     public void testCheckXPath53() throws Exception {
 592         try (InputStream is = Files.newInputStream(XML_PATH)) {
 593             assertEquals(xpath.evaluate(EXPRESSION_NAME_A, new InputSource(is),
 594                 NUMBER), 6d);
 595         }
 596     }
 597 
 598     /**
 599      * XPath.evaluate(java.lang.String expression, InputSource iSource, QName
 600      * returnType) returns a node value if returnType is Node.
 601      *
 602      * @throws Exception If any errors occur.
 603      */
 604     @Test(groups = {"readLocalFiles"})
 605     public void testCheckXPath54() throws Exception {
 606         try (InputStream is = Files.newInputStream(XML_PATH)) {
 607             assertEquals(((Attr)xpath.evaluate(EXPRESSION_NAME_A,
 608                 new InputSource(is), NODE)).getValue(), "6");
 609         }
 610     }
 611 
 612     /**
 613      * XPath.evaluate(java.lang.String expression, InputSource iSource, QName
 614      * returnType) returns a node list if returnType is NodeList.
 615      *
 616      * @throws Exception If any errors occur.
 617      */
 618     @Test(groups = {"readLocalFiles"})
 619     public void testCheckXPath55() throws Exception {
 620         try (InputStream is = Files.newInputStream(XML_PATH)) {
 621             NodeList nodeList = (NodeList)xpath.evaluate(EXPRESSION_NAME_A,
 622                 new InputSource(is), NODESET);
 623             assertEquals(((Attr) nodeList.item(0)).getValue(), "6");
 624         }
 625     }
 626 
 627     /**
 628      * Test for XPath.getNamespaceContext() returns the current namespace
 629      * context, null is returned if no namespace context is in effect.
 630      */
 631     @Test
 632     public void testCheckXPath56() {
 633         // CR 6376058 says that an impl will be provided, but by
 634         // default we still return null here
 635         assertNull(xpath.getNamespaceContext());
 636     }
 637 
 638     /**


   1 /*
   2  * Copyright (c) 2003, 2016, 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 static javax.xml.xpath.XPathConstants.BOOLEAN;
  27 import static javax.xml.xpath.XPathConstants.NODE;
  28 import static javax.xml.xpath.XPathConstants.NODESET;
  29 import static javax.xml.xpath.XPathConstants.NUMBER;
  30 import static javax.xml.xpath.XPathConstants.STRING;
  31 import static javax.xml.xpath.ptests.XPathTestConst.XML_DIR;
  32 import static org.testng.AssertJUnit.assertEquals;
  33 import static org.testng.AssertJUnit.assertNotNull;
  34 import static org.testng.AssertJUnit.assertNull;
  35 
  36 import java.io.InputStream;
  37 import java.nio.file.Files;
  38 import java.nio.file.Path;
  39 import java.nio.file.Paths;
  40 import java.util.Iterator;
  41 
  42 import javax.xml.XMLConstants;
  43 import javax.xml.namespace.NamespaceContext;
  44 import javax.xml.namespace.QName;
  45 import javax.xml.parsers.DocumentBuilderFactory;
  46 import javax.xml.xpath.XPath;





  47 import javax.xml.xpath.XPathExpressionException;
  48 import javax.xml.xpath.XPathFactory;
  49 




  50 import org.testng.annotations.BeforeTest;
  51 import org.testng.annotations.Listeners;
  52 import org.testng.annotations.Test;
  53 import org.w3c.dom.Attr;
  54 import org.w3c.dom.Document;
  55 import org.w3c.dom.NodeList;
  56 import org.xml.sax.InputSource;
  57 
  58 /**
  59  * Class containing the test cases for XPath API.
  60  */
  61 @Listeners({jaxp.library.FilePolicy.class})
  62 public class XPathTest {
  63     /**
  64      * Document object for testing XML file.
  65      */
  66     private Document document;
  67 
  68     /**
  69      * A XPath for evaluation environment and expressions.
  70      */
  71     private XPath xpath;
  72 
  73     /**
  74      * A QName using default name space.
  75      */
  76     private static final QName TEST_QNAME = new QName(XMLConstants.XML_NS_URI, "");
  77 
  78     /**
  79      * XML File Path.
  80      */
  81     private static final Path XML_PATH = Paths.get(XML_DIR + "widgets.xml");
  82 
  83     /**
  84      * An expression name which locate at "/widgets/widget[@name='a']/@quantity"
  85      */
  86     private static final String EXPRESSION_NAME_A = "/widgets/widget[@name='a']/@quantity";
  87 
  88     /**
  89      * An expression name which locate at "/widgets/widget[@name='b']/@quantity"
  90      */
  91     private static final String EXPRESSION_NAME_B = "/widgets/widget[@name='b']/@quantity";
  92 
  93     /**
  94      * Create Document object and XPath object for every time
  95      * @throws Exception If any errors occur.
  96      */
  97     @BeforeTest
  98     public void setup() throws Exception {

  99         document = DocumentBuilderFactory.newInstance().newDocumentBuilder().parse(XML_PATH.toFile());
 100         xpath = XPathFactory.newInstance().newXPath();
 101     }
 102 
 103     /**
 104      * Test for XPath.evaluate(java.lang.String expression, java.lang.Object
 105      * item, QName returnType) which return type is String.
 106      *
 107      * @throws XPathExpressionException If the expression cannot be evaluated.
 108      */
 109     @Test
 110     public void testCheckXPath01() throws XPathExpressionException {
 111         assertEquals(xpath.evaluate(EXPRESSION_NAME_A, document, STRING), "6");
 112     }
 113 
 114 
 115     /**
 116      * Test for XPath.compile(java.lang.String expression) and then
 117      * evaluate(java.lang.Object item, QName returnType).
 118      *


 332         assertEquals(xpath.evaluate("1+1", document), "2");
 333     }
 334 
 335     /**
 336      * XPath.evaluate(java.lang.String expression, java.lang.Object item) throws
 337      * NPE if InputSource is null.
 338      *
 339      * @throws XPathExpressionException If the expression cannot be evaluated.
 340      */
 341     @Test(expectedExceptions = NullPointerException.class)
 342     public void testCheckXPath21() throws XPathExpressionException {
 343         xpath.evaluate(EXPRESSION_NAME_A, null);
 344     }
 345 
 346     /**
 347      * XPath.evaluate(java.lang.String expression, InputSource source) return
 348      * correct value by looking for Node.
 349      *
 350      * @throws Exception If any errors occur.
 351      */
 352     @Test 
 353     public void testCheckXPath22() throws Exception {
 354         try (InputStream is = Files.newInputStream(XML_PATH)) {
 355             assertEquals(xpath.evaluate(EXPRESSION_NAME_A, new InputSource(is)), "6");
 356         }
 357     }
 358 
 359     /**
 360      * XPath.evaluate(java.lang.String expression, InputSource source) throws
 361      * NPE if InputSource is null.
 362      *
 363      * @throws XPathExpressionException If the expression cannot be evaluated.
 364      */
 365     @Test(expectedExceptions = NullPointerException.class)
 366     public void testCheckXPath23() throws XPathExpressionException {
 367         xpath.evaluate(EXPRESSION_NAME_A, null);
 368     }
 369 
 370     /**
 371      * XPath.evaluate(java.lang.String expression, InputSource source) throws
 372      * NPE if String expression is null.
 373      *
 374      * @throws Exception If any errors occur.
 375      */
 376     @Test(expectedExceptions = NullPointerException.class)
 377     public void testCheckXPath24() throws Exception {
 378         try (InputStream is = Files.newInputStream(XML_PATH)) {
 379             xpath.evaluate(null, new InputSource(is));
 380         }
 381     }
 382 
 383     /**
 384      * Test for XPath.evaluate(java.lang.String expression, InputSource source).
 385      * If expression is junk characters, expression cannot be evaluated, should
 386      * throw XPathExpressionException.
 387      *
 388      * @throws Exception If any errors occur.
 389      */
 390     @Test(expectedExceptions = XPathExpressionException.class)
 391     public void testCheckXPath25() throws Exception {
 392         try (InputStream is = Files.newInputStream(XML_PATH)) {
 393             xpath.evaluate("-*&", new InputSource(is));
 394         }
 395     }
 396 
 397     /**
 398      * XPath.evaluate(java.lang.String expression, InputSource source) throws
 399      * XPathExpressionException if expression is blank " ".
 400      *
 401      * @throws Exception If any errors occur.
 402      */
 403     @Test(expectedExceptions = XPathExpressionException.class)
 404     public void testCheckXPath26() throws Exception {
 405         try (InputStream is = Files.newInputStream(XML_PATH)) {
 406             xpath.evaluate(" ", new InputSource(is));
 407         }
 408     }
 409 
 410     /**
 411      * XPath.evaluate(java.lang.String expression, InputSource source, QName
 412      * returnType) returns correct string value which return type is String.
 413      *
 414      * @throws Exception If any errors occur.
 415      */
 416     @Test
 417     public void testCheckXPath27() throws Exception {
 418         try (InputStream is = Files.newInputStream(XML_PATH)) {
 419             assertEquals(xpath.evaluate(EXPRESSION_NAME_A, new InputSource(is), STRING), "6");
 420         }
 421     }
 422 
 423     /**
 424      * XPath.evaluate(java.lang.String expression, InputSource source, QName
 425      * returnType) throws NPE if source is null.
 426      *
 427      * @throws XPathExpressionException If the expression cannot be evaluated.
 428      */
 429     @Test(expectedExceptions = NullPointerException.class)
 430     public void testCheckXPath28() throws XPathExpressionException {
 431         xpath.evaluate(EXPRESSION_NAME_A, null, STRING);
 432     }
 433 
 434     /**
 435      * XPath.evaluate(java.lang.String expression, InputSource source, QName
 436      * returnType) throws NPE if expression is null.
 437      *
 438      * @throws Exception If any errors occur.
 439      */
 440     @Test(expectedExceptions = NullPointerException.class)
 441     public void testCheckXPath29() throws Exception {
 442         try (InputStream is = Files.newInputStream(XML_PATH)) {
 443             xpath.evaluate(null, new InputSource(is), STRING);
 444         }
 445     }
 446 
 447     /**
 448      * XPath.evaluate(java.lang.String expression, InputSource source,
 449      * QName returnType) throws NPE if returnType is null.
 450      *
 451      * @throws Exception If any errors occur.
 452      */
 453     @Test(expectedExceptions = NullPointerException.class)
 454     public void testCheckXPath30() throws Exception {
 455         try (InputStream is = Files.newInputStream(XML_PATH)) {
 456             xpath.evaluate(EXPRESSION_NAME_A, new InputSource(is), null);
 457         }
 458     }
 459 
 460     /**
 461      * XPath.evaluate(java.lang.String expression, InputSource source, QName
 462      * returnType) throws XPathExpressionException if expression is junk characters.
 463      *
 464      * @throws Exception If any errors occur.
 465      */
 466     @Test(expectedExceptions = XPathExpressionException.class)
 467     public void testCheckXPath31() throws Exception {
 468         try (InputStream is = Files.newInputStream(XML_PATH)) {
 469             xpath.evaluate("-*&", new InputSource(is), STRING);
 470         }
 471     }
 472 
 473     /**
 474      * XPath.evaluate(java.lang.String expression, InputSource source, QName
 475      * returnType) throws XPathExpressionException if expression is blank " ".
 476      *
 477      * @throws Exception If any errors occur.
 478      */
 479     @Test(expectedExceptions = XPathExpressionException.class)
 480     public void testCheckXPath32() throws Exception {
 481         try (InputStream is = Files.newInputStream(XML_PATH)) {
 482             xpath.evaluate(" ", new InputSource(is), STRING);
 483         }
 484     }
 485 
 486     /**
 487      * XPath.evaluate(java.lang.String expression, InputSource source,
 488      * QName returnType) throws IllegalArgumentException if returnType is not
 489      * one of the types defined in XPathConstants.
 490      *
 491      * @throws Exception If any errors occur.
 492      */
 493     @Test(expectedExceptions = IllegalArgumentException.class)
 494     public void testCheckXPath33() throws Exception {
 495         try (InputStream is = Files.newInputStream(XML_PATH)) {
 496             xpath.evaluate(EXPRESSION_NAME_A, new InputSource(is), TEST_QNAME);
 497         }
 498     }
 499 
 500     /**
 501      * XPath.evaluate(java.lang.String expression, InputSource source,
 502      * QName returnType) return correct boolean value if return type is Boolean.
 503      *
 504      * @throws Exception If any errors occur.
 505      */
 506     @Test
 507     public void testCheckXPath34() throws Exception {
 508         try (InputStream is = Files.newInputStream(XML_PATH)) {
 509             assertEquals(xpath.evaluate(EXPRESSION_NAME_A, new InputSource(is),
 510                 BOOLEAN), true);
 511         }
 512     }
 513 
 514     /**
 515      * XPath.evaluate(java.lang.String expression, InputSource source,
 516      * QName returnType) return correct boolean value if return type is Boolean.
 517      *
 518      * @throws Exception If any errors occur.
 519      */
 520     @Test
 521     public void testCheckXPath35() throws Exception {
 522         try (InputStream is = Files.newInputStream(XML_PATH)) {
 523             assertEquals(xpath.evaluate(EXPRESSION_NAME_B, new InputSource(is),
 524                 BOOLEAN), false);
 525         }
 526     }
 527 
 528     /**
 529      * XPath.evaluate(java.lang.String expression, InputSource source,
 530      * QName returnType) return correct number value if return type is Number.
 531      *
 532      * @throws Exception If any errors occur.
 533      */
 534     @Test
 535     public void testCheckXPath36() throws Exception {
 536         try (InputStream is = Files.newInputStream(XML_PATH)) {
 537             assertEquals(xpath.evaluate(EXPRESSION_NAME_A, new InputSource(is),
 538                 NUMBER), 6d);
 539         }
 540     }
 541 
 542     /**
 543      * XPath.evaluate(java.lang.String expression, InputSource source,
 544      * QName returnType) return correct string value if return type is Node.
 545      *
 546      * @throws Exception If any errors occur.
 547      */
 548     @Test
 549     public void testCheckXPath37() throws Exception {
 550         try (InputStream is = Files.newInputStream(XML_PATH)) {
 551             assertEquals(((Attr)xpath.evaluate(EXPRESSION_NAME_A,
 552                 new InputSource(is), NODE)).getValue(), "6");
 553         }
 554     }
 555 
 556     /**
 557      * Test for XPath.evaluate(java.lang.String expression, InputSource source,
 558      * QName returnType) which return type is NodeList.
 559      *
 560      * @throws Exception If any errors occur.
 561      */
 562     @Test
 563     public void testCheckXPath38() throws Exception {
 564         try (InputStream is = Files.newInputStream(XML_PATH)) {
 565             NodeList nodeList = (NodeList)xpath.evaluate(EXPRESSION_NAME_A,
 566                 new InputSource(is), NODESET);
 567             assertEquals(((Attr) nodeList.item(0)).getValue(), "6");
 568         }
 569     }
 570 
 571     /**
 572      * Test for XPath.evaluate(java.lang.String expression, InputSource iSource,
 573      * QName returnType). If return type is Boolean, should return false as
 574      * expression is not successful in evaluating to any result.
 575      *
 576      * @throws Exception If any errors occur.
 577      */
 578     @Test
 579     public void testCheckXPath52() throws Exception {
 580         try (InputStream is = Files.newInputStream(XML_PATH)) {
 581             assertEquals(xpath.evaluate(EXPRESSION_NAME_B, new InputSource(is),
 582                 BOOLEAN), false);
 583         }
 584     }
 585 
 586     /**
 587      * XPath.evaluate(java.lang.String expression, InputSource iSource, QName
 588      * returnType) returns correct number value which return type is Number.
 589      *
 590      * @throws Exception If any errors occur.
 591      */
 592     @Test
 593     public void testCheckXPath53() throws Exception {
 594         try (InputStream is = Files.newInputStream(XML_PATH)) {
 595             assertEquals(xpath.evaluate(EXPRESSION_NAME_A, new InputSource(is),
 596                 NUMBER), 6d);
 597         }
 598     }
 599 
 600     /**
 601      * XPath.evaluate(java.lang.String expression, InputSource iSource, QName
 602      * returnType) returns a node value if returnType is Node.
 603      *
 604      * @throws Exception If any errors occur.
 605      */
 606     @Test
 607     public void testCheckXPath54() throws Exception {
 608         try (InputStream is = Files.newInputStream(XML_PATH)) {
 609             assertEquals(((Attr)xpath.evaluate(EXPRESSION_NAME_A,
 610                 new InputSource(is), NODE)).getValue(), "6");
 611         }
 612     }
 613 
 614     /**
 615      * XPath.evaluate(java.lang.String expression, InputSource iSource, QName
 616      * returnType) returns a node list if returnType is NodeList.
 617      *
 618      * @throws Exception If any errors occur.
 619      */
 620     @Test
 621     public void testCheckXPath55() throws Exception {
 622         try (InputStream is = Files.newInputStream(XML_PATH)) {
 623             NodeList nodeList = (NodeList)xpath.evaluate(EXPRESSION_NAME_A,
 624                 new InputSource(is), NODESET);
 625             assertEquals(((Attr) nodeList.item(0)).getValue(), "6");
 626         }
 627     }
 628 
 629     /**
 630      * Test for XPath.getNamespaceContext() returns the current namespace
 631      * context, null is returned if no namespace context is in effect.
 632      */
 633     @Test
 634     public void testCheckXPath56() {
 635         // CR 6376058 says that an impl will be provided, but by
 636         // default we still return null here
 637         assertNull(xpath.getNamespaceContext());
 638     }
 639 
 640     /**


< prev index next >