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 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.parsers.ParserConfigurationException;
  37 import javax.xml.xpath.XPath;
  38 import static javax.xml.xpath.XPathConstants.BOOLEAN;
  39 import static javax.xml.xpath.XPathConstants.NODE;
  40 import static javax.xml.xpath.XPathConstants.NODESET;
  41 import static javax.xml.xpath.XPathConstants.NUMBER;
  42 import static javax.xml.xpath.XPathConstants.STRING;
  43 import javax.xml.xpath.XPathExpressionException;
  44 import javax.xml.xpath.XPathFactory;
  45 import static javax.xml.xpath.ptests.XPathTestConst.XML_DIR;
  46 import static jaxp.library.JAXPTestUtilities.failUnexpected;
  47 import static org.testng.AssertJUnit.assertEquals;
  48 import static org.testng.AssertJUnit.assertNotNull;
  49 import static org.testng.AssertJUnit.assertNull;


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

 101         document = DocumentBuilderFactory.newInstance().newDocumentBuilder().parse(XML_PATH.toFile());
 102         xpath = XPathFactory.newInstance().newXPath();
 103     }
 104 
 105     /**
 106      * Test for XPath.evaluate(java.lang.String expression, java.lang.Object
 107      * item, QName returnType) which return type is String.


 108      */
 109     @Test
 110     public void testCheckXPath01() {
 111         try {
 112             assertEquals(xpath.evaluate(EXPRESSION_NAME_A, document, STRING), "6");
 113         } catch (XPathExpressionException ex) {
 114             failUnexpected(ex);
 115         }
 116     }
 117 
 118 
 119     /**
 120      * Test for XPath.compile(java.lang.String expression) and then
 121      * evaluate(java.lang.Object item, QName returnType).


 122      */
 123     @Test
 124     public void testCheckXPath02() {
 125         try {
 126             assertEquals(xpath.compile(EXPRESSION_NAME_A).evaluate(document, STRING), "6");
 127         } catch (XPathExpressionException ex) {
 128             failUnexpected(ex);
 129         }
 130     }
 131 
 132     /**
 133      * Test for XPath.evaluate(java.lang.String expression, java.lang.Object
 134      * item) when the third argument is left off of the XPath.evaluate method,
 135      * all expressions are evaluated to a String value.


 136      */
 137     @Test
 138     public void testCheckXPath03() {
 139         try {
 140             assertEquals(xpath.evaluate(EXPRESSION_NAME_A, document), "6");
 141         } catch (XPathExpressionException ex) {
 142             failUnexpected(ex);
 143         }
 144     }
 145 
 146     /**
 147      * Test for XPath.compile(java.lang.String expression). If expression is
 148      * null, should throw NPE.


 149      */
 150     @Test(expectedExceptions = NullPointerException.class)
 151     public void testCheckXPath04() {
 152         try {
 153             xpath.compile(null);
 154         } catch (XPathExpressionException ex) {
 155             failUnexpected(ex);
 156         }
 157     }
 158 
 159     /**
 160      * Test for XPath.compile(java.lang.String expression). If expression cannot
 161      * be compiled junk characters, should throw XPathExpressionException.
 162      *
 163      * @throws XPathExpressionException
 164      */
 165     @Test(expectedExceptions = XPathExpressionException.class)
 166     public void testCheckXPath05() throws XPathExpressionException {
 167         xpath.compile("-*&");
 168     }
 169 
 170     /**
 171      * Test for XPath.compile(java.lang.String expression). If expression is
 172      * blank, should throw XPathExpressionException
 173      *
 174      * @throws XPathExpressionException
 175      */
 176     @Test(expectedExceptions = XPathExpressionException.class)
 177     public void testCheckXPath06() throws XPathExpressionException {
 178         xpath.compile(" ");
 179     }
 180 
 181     /**
 182      * Test for XPath.compile(java.lang.String expression). The expression
 183      * cannot be evaluated as this does not exist.


 184      */
 185     @Test
 186     public void testCheckXPath07() {
 187         try {
 188             assertEquals(xpath.compile(EXPRESSION_NAME_B).evaluate(document, STRING), "");
 189         } catch (XPathExpressionException ex) {
 190             failUnexpected(ex);
 191         }
 192 
 193     }
 194 
 195 
 196     /**
 197      * Test for XPath.evaluate(java.lang.String expression, java.lang.Object
 198      * item, QName returnType). If String expression is null, should throw NPE


 199      */
 200     @Test(expectedExceptions = NullPointerException.class)
 201     public void testCheckXPath08() {
 202         try {
 203             xpath.evaluate(null, document, STRING);
 204         } catch (XPathExpressionException ex) {
 205             failUnexpected(ex);
 206         }
 207     }
 208 
 209     /**
 210      * Test for XPath.evaluate(java.lang.String expression, java.lang.Object
 211      * item, QName returnType). If item is null, should throw NPE.


 212      */
 213     @Test(expectedExceptions = NullPointerException.class)
 214     public void testCheckXPath09() {
 215         try {
 216             xpath.evaluate(EXPRESSION_NAME_A, null, STRING);
 217         } catch (XPathExpressionException ex) {
 218             failUnexpected(ex);
 219         }
 220     }
 221 
 222     /**
 223      * Test for XPath.evaluate(java.lang.String expression, java.lang.Object
 224      * item, QName returnType). If returnType is null, should throw NPE.


 225      */
 226     @Test(expectedExceptions = NullPointerException.class)
 227     public void testCheckXPath10() {
 228         try {
 229             xpath.evaluate(EXPRESSION_NAME_A, document, null);
 230         } catch (XPathExpressionException ex) {
 231             failUnexpected(ex);
 232         }
 233     }
 234 
 235     /**
 236      * Test for XPath.evaluate(java.lang.String expression, java.lang.Object
 237      * item, QName returnType). If a request is made to evaluate the expression
 238      * in the absence of a context item, simple expressions, such as "1+1", can
 239      * be evaluated.


 240      */
 241     @Test
 242     public void testCheckXPath11() {
 243         try {
 244             assertEquals(xpath.evaluate("1+1", document, STRING), "2");
 245         } catch (XPathExpressionException ex) {
 246             failUnexpected(ex);
 247         }
 248     }
 249 
 250     /**
 251      * XPath.evaluate(java.lang.String expression, java.lang.Object item, QName
 252      * returnType) throws XPathExpressionException if expression is a empty
 253      * string "".
 254      * .
 255      *
 256      * @throws XPathExpressionException
 257      */
 258     @Test(expectedExceptions = XPathExpressionException.class)
 259     public void testCheckXPath12() throws XPathExpressionException {
 260         xpath.evaluate("", document, STRING);
 261     }
 262 
 263     /**
 264      * XPath.evaluate(java.lang.String expression, java.lang.Object item, QName
 265      * returnType) throws IllegalArgumentException if returnType is not one of
 266      * the types defined in XPathConstants.


 267      */
 268     @Test(expectedExceptions = IllegalArgumentException.class)
 269     public void testCheckXPath13() {
 270         try {
 271             xpath.evaluate(EXPRESSION_NAME_A, document, TEST_QNAME);
 272         } catch (XPathExpressionException ex) {
 273             failUnexpected(ex);
 274         }
 275     }
 276 
 277     /**
 278      * XPath.evaluate(java.lang.String expression, java.lang.Object item, QName
 279      * returnType) returns correct boolean value if returnType is Boolean.


 280      */
 281     @Test
 282     public void testCheckXPath14() {
 283         try {
 284             assertEquals(xpath.evaluate(EXPRESSION_NAME_A, document, BOOLEAN), true);
 285         } catch (XPathExpressionException ex) {
 286             failUnexpected(ex);
 287         }
 288     }
 289 
 290     /**
 291      * XPath.evaluate(java.lang.String expression, java.lang.Object item, QName
 292      * returnType) returns false as  expression is not successful in evaluating
 293      * to any result if returnType is Boolean.


 294      */
 295     @Test
 296     public void testCheckXPath15() {
 297         try {
 298             assertEquals(xpath.evaluate(EXPRESSION_NAME_B, document, BOOLEAN), false);
 299         } catch (XPathExpressionException ex) {
 300             failUnexpected(ex);
 301         }
 302     }
 303 
 304     /**
 305      * XPath.evaluate(java.lang.String expression, java.lang.Object item, QName
 306      * returnType) returns correct number value if return type is Number.


 307      */
 308     @Test
 309     public void testCheckXPath16() {
 310         try {
 311             assertEquals(xpath.evaluate(EXPRESSION_NAME_A, document, NUMBER), 6d);
 312         } catch (XPathExpressionException ex) {
 313             failUnexpected(ex);
 314         }
 315     }
 316 
 317 
 318     /**
 319      * XPath.evaluate(java.lang.String expression, java.lang.Object item, QName
 320      * returnType) returns correct string value if return type is Node.


 321      */
 322     @Test
 323     public void testCheckXPath17() {
 324         try {
 325             assertEquals(((Attr)xpath.evaluate(EXPRESSION_NAME_A, document, NODE)).getValue(), "6");
 326         } catch (XPathExpressionException ex) {
 327             failUnexpected(ex);
 328         }
 329     }
 330 
 331     /**
 332      * Test for XPath.evaluate(java.lang.String expression, java.lang.Object
 333      * item, QName returnType). If return type is NodeList,the evaluated value
 334      * equals to "6" as expected.


 335      */
 336     @Test
 337     public void testCheckXPath18() {
 338         try {
 339             NodeList nodeList = (NodeList)xpath.evaluate(EXPRESSION_NAME_A, document, NODESET);
 340             assertEquals(((Attr) nodeList.item(0)).getValue(), "6");
 341         } catch (XPathExpressionException ex) {
 342             failUnexpected(ex);
 343         }
 344     }
 345 
 346     /**
 347      * Test for XPath.evaluate(java.lang.String expression, java.lang.Object
 348      * item). If expression is null, should throw NPE.


 349      */
 350     @Test(expectedExceptions = NullPointerException.class)
 351     public void testCheckXPath19() {
 352         try {
 353             xpath.evaluate(null, document);
 354         } catch (XPathExpressionException ex) {
 355             failUnexpected(ex);
 356         }
 357     }
 358 
 359     /**
 360      * Test for XPath.evaluate(java.lang.String expression, java.lang.Object
 361      * item). If a request is made to evaluate the expression in the absence of
 362      * a context item, simple expressions, such as "1+1", can be evaluated.


 363      */
 364     @Test
 365     public void testCheckXPath20() {
 366         try {
 367             assertEquals(xpath.evaluate("1+1", document), "2");
 368         } catch (XPathExpressionException ex) {
 369             failUnexpected(ex);
 370         }
 371     }
 372 
 373     /**
 374      * XPath.evaluate(java.lang.String expression, java.lang.Object item) throws
 375      * NPE if InputSource is null.


 376      */
 377     @Test(expectedExceptions = NullPointerException.class)
 378     public void testCheckXPath21() {
 379         try {
 380             xpath.evaluate(EXPRESSION_NAME_A, null);
 381         } catch (XPathExpressionException ex) {
 382             failUnexpected(ex);
 383         }















 384     }
 385 
 386     /**
 387      * XPath.evaluate(java.lang.String expression, InputSource source) return
 388      * correct value by looking for Node.





 389      */
 390     @Test
 391     public void testCheckXPath22() {
 392         try (InputStream is = Files.newInputStream(XML_PATH)) {
 393             assertEquals(xpath.evaluate(EXPRESSION_NAME_A, new InputSource(is)), "6");
 394         } catch (XPathExpressionException | IOException ex) {
 395             failUnexpected(ex);
 396         }
 397     }
 398 
 399     /**
 400      * XPath.evaluate(java.lang.String expression, InputSource source) throws
 401      * NPE if InputSource is null.


 402      */
 403     @Test(expectedExceptions = NullPointerException.class)
 404     public void testCheckXPath23() {
 405         try {
 406             xpath.evaluate(EXPRESSION_NAME_A, null);
 407         } catch (XPathExpressionException ex) {
 408             failUnexpected(ex);
 409         }
 410     }
 411 
 412     /**
 413      * XPath.evaluate(java.lang.String expression, InputSource source) throws
 414      * NPE if String expression is null.





 415      */
 416     @Test(expectedExceptions = NullPointerException.class)
 417     public void testCheckXPath24() {
 418         try (InputStream is = Files.newInputStream(XML_PATH)) {
 419             xpath.evaluate(null, new InputSource(is));
 420         } catch (XPathExpressionException | IOException ex) {
 421             failUnexpected(ex);
 422         }
 423     }
 424 
 425     /**
 426      * Test for XPath.evaluate(java.lang.String expression, InputSource source).
 427      * If expression is junk characters, expression cannot be evaluated, should
 428      * throw XPathExpressionException.
 429      *
 430      * @throws XPathExpressionException



 431      */
 432     @Test(expectedExceptions = XPathExpressionException.class)
 433     public void testCheckXPath25() throws XPathExpressionException {
 434         try (InputStream is = Files.newInputStream(XML_PATH)) {
 435             xpath.evaluate("-*&", new InputSource(is));
 436         } catch (IOException ex) {
 437             failUnexpected(ex);
 438         }
 439     }
 440 
 441     /**
 442      * XPath.evaluate(java.lang.String expression, InputSource source) throws
 443      * XPathExpressionException if expression is blank " ".
 444      *
 445      * @throws XPathExpressionException



 446      */
 447     @Test(expectedExceptions = XPathExpressionException.class)
 448     public void testCheckXPath26() throws XPathExpressionException {
 449         try (InputStream is = Files.newInputStream(XML_PATH)) {
 450             xpath.evaluate(" ", new InputSource(is));
 451         } catch (IOException ex) {
 452             failUnexpected(ex);
 453         }
 454     }
 455 
 456     /**
 457      * XPath.evaluate(java.lang.String expression, InputSource source, QName
 458      * returnType) returns correct string value which return type is String.





 459      */
 460     @Test
 461     public void testCheckXPath27() {
 462         try (InputStream is = Files.newInputStream(XML_PATH)) {
 463             assertEquals(xpath.evaluate(EXPRESSION_NAME_A, new InputSource(is), STRING), "6");
 464         } catch (XPathExpressionException | IOException ex) {
 465             failUnexpected(ex);
 466         }
 467     }
 468 
 469     /**
 470      * XPath.evaluate(java.lang.String expression, InputSource source, QName
 471      * returnType) throws NPE if source is null.


 472      */
 473     @Test(expectedExceptions = NullPointerException.class)
 474     public void testCheckXPath28() {
 475         try {
 476             xpath.evaluate(EXPRESSION_NAME_A, null, STRING);
 477         } catch (XPathExpressionException ex) {
 478             failUnexpected(ex);
 479         }
 480     }
 481 
 482     /**
 483      * XPath.evaluate(java.lang.String expression, InputSource source, QName
 484      * returnType) throws NPE if expression is null.





 485      */
 486     @Test(expectedExceptions = NullPointerException.class)
 487     public void testCheckXPath29() {
 488         try (InputStream is = Files.newInputStream(XML_PATH)) {
 489             xpath.evaluate(null, new InputSource(is), STRING);
 490         } catch (XPathExpressionException | IOException ex) {
 491             failUnexpected(ex);
 492         }
 493     }
 494 
 495     /**
 496      * XPath.evaluate(java.lang.String expression, InputSource source,
 497      * QName returnType) throws NPE if returnType is null .





 498      */
 499     @Test(expectedExceptions = NullPointerException.class)
 500     public void testCheckXPath30() {
 501         try (InputStream is = Files.newInputStream(XML_PATH)) {
 502             xpath.evaluate(EXPRESSION_NAME_A, new InputSource(is), null);
 503         } catch (XPathExpressionException | IOException ex) {
 504             failUnexpected(ex);
 505         }
 506     }
 507 
 508     /**
 509      * XPath.evaluate(java.lang.String expression, InputSource source, QName
 510      * returnType) throws XPathExpressionException if expression is junk characters.
 511      *
 512      * @throws XPathExpressionException



 513      */
 514     @Test(expectedExceptions = XPathExpressionException.class)
 515     public void testCheckXPath31() throws XPathExpressionException {
 516         try (InputStream is = Files.newInputStream(XML_PATH)) {
 517             xpath.evaluate("-*&", new InputSource(is), STRING);
 518         } catch (IOException ex) {
 519             failUnexpected(ex);
 520         }
 521     }
 522 
 523     /**
 524      * XPath.evaluate(java.lang.String expression, InputSource source, QName
 525      * returnType) throws XPathExpressionException if expression is blank " ".
 526      *
 527      * @throws XPathExpressionException



 528      */
 529     @Test(expectedExceptions = XPathExpressionException.class)
 530     public void testCheckXPath32() throws XPathExpressionException {
 531         try (InputStream is = Files.newInputStream(XML_PATH)) {
 532             xpath.evaluate(" ", new InputSource(is), STRING);
 533         } catch (IOException ex) {
 534             failUnexpected(ex);
 535         }
 536     }
 537 
 538     /**
 539      * XPath.evaluate(java.lang.String expression, InputSource source,
 540      * QName returnType) throws IllegalArgumentException if returnType is not
 541      * one of the types defined in XPathConstants.





 542      */
 543     @Test(expectedExceptions = IllegalArgumentException.class)
 544     public void testCheckXPath33() {
 545         try (InputStream is = Files.newInputStream(XML_PATH)) {
 546             xpath.evaluate(EXPRESSION_NAME_A, new InputSource(is), TEST_QNAME);
 547         } catch (XPathExpressionException | IOException ex) {
 548             failUnexpected(ex);
 549         }
 550     }
 551 
 552     /**
 553      * XPath.evaluate(java.lang.String expression, InputSource source,
 554      * QName returnType) return correct boolean value if return type is Boolean.





 555      */
 556     @Test
 557     public void testCheckXPath34() {
 558         try (InputStream is = Files.newInputStream(XML_PATH)) {
 559             assertEquals(xpath.evaluate(EXPRESSION_NAME_A, new InputSource(is),
 560                 BOOLEAN), true);
 561         } catch (XPathExpressionException | IOException ex) {
 562             failUnexpected(ex);
 563         }
 564     }
 565 
 566     /**
 567      * XPath.evaluate(java.lang.String expression, InputSource source,
 568      * QName returnType) return correct boolean value if return type is Boolean.





 569      */
 570     @Test
 571     public void testCheckXPath35() {
 572         try (InputStream is = Files.newInputStream(XML_PATH)) {
 573             assertEquals(xpath.evaluate(EXPRESSION_NAME_B, new InputSource(is),
 574                 BOOLEAN), false);
 575         } catch (XPathExpressionException | IOException ex) {
 576             failUnexpected(ex);
 577         }
 578     }
 579 
 580     /**
 581      * XPath.evaluate(java.lang.String expression, InputSource source,
 582      * QName returnType) return correct number value if return type is Number.





 583      */
 584     @Test
 585     public void testCheckXPath36() {
 586         try (InputStream is = Files.newInputStream(XML_PATH)) {
 587             assertEquals(xpath.evaluate(EXPRESSION_NAME_A, new InputSource(is),
 588                 NUMBER), 6d);
 589         } catch (XPathExpressionException | IOException ex) {
 590             failUnexpected(ex);
 591         }
 592     }
 593 
 594     /**
 595      * XPath.evaluate(java.lang.String expression, InputSource source,
 596      * QName returnType) return correct string value if return type is Node.





 597      */
 598     @Test
 599     public void testCheckXPath37() {
 600         try (InputStream is = Files.newInputStream(XML_PATH)) {
 601             assertEquals(((Attr)xpath.evaluate(EXPRESSION_NAME_A,
 602                 new InputSource(is), NODE)).getValue(), "6");
 603         } catch (XPathExpressionException | IOException ex) {
 604             failUnexpected(ex);
 605         }
 606     }
 607 
 608     /**
 609      * Test for XPath.evaluate(java.lang.String expression, InputSource source,
 610      * QName returnType) which return type is NodeList.





 611      */
 612     @Test
 613     public void testCheckXPath38() {
 614         try (InputStream is = Files.newInputStream(XML_PATH)) {
 615             NodeList nodeList = (NodeList)xpath.evaluate(EXPRESSION_NAME_A,
 616                 new InputSource(is), NODESET);
 617             assertEquals(((Attr) nodeList.item(0)).getValue(), "6");
 618         } catch (XPathExpressionException | IOException ex) {
 619             failUnexpected(ex);
 620         }
 621     }
 622 
 623     /**
 624      * Test for XPath.evaluate(java.lang.String expression, InputSource iSource,
 625      * QName returnType). If return type is Boolean, should return false as
 626      * expression is not successful in evaluating to any result.





 627      */
 628     @Test
 629     public void testCheckXPath52() {
 630         try (InputStream is = Files.newInputStream(XML_PATH)) {
 631             assertEquals(xpath.evaluate(EXPRESSION_NAME_B, new InputSource(is),
 632                 BOOLEAN), false);
 633         } catch (XPathExpressionException | IOException ex) {
 634             failUnexpected(ex);
 635         }
 636     }
 637 
 638     /**
 639      * XPath.evaluate(java.lang.String expression, InputSource iSource, QName
 640      * returnType) returns correct number value which return type is Number.





 641      */
 642     @Test
 643     public void testCheckXPath53() {
 644         try (InputStream is = Files.newInputStream(XML_PATH)) {
 645             assertEquals(xpath.evaluate(EXPRESSION_NAME_A, new InputSource(is),
 646                 NUMBER), 6d);
 647         } catch (XPathExpressionException | IOException ex) {
 648             failUnexpected(ex);
 649         }
 650     }
 651 
 652     /**
 653      * XPath.evaluate(java.lang.String expression, InputSource iSource, QName
 654      * returnType) returns a node value if returnType is Node.





 655      */
 656     @Test
 657     public void testCheckXPath54() {
 658         try (InputStream is = Files.newInputStream(XML_PATH)) {
 659             assertEquals(((Attr)xpath.evaluate(EXPRESSION_NAME_A,
 660                 new InputSource(is), NODE)).getValue(), "6");
 661         } catch (XPathExpressionException | IOException ex) {
 662             failUnexpected(ex);
 663         }
 664     }
 665 
 666     /**
 667      * XPath.evaluate(java.lang.String expression, InputSource iSource, QName
 668      * returnType) returns a node list if returnType is NodeList.





 669      */
 670     @Test
 671     public void testCheckXPath55() {
 672         try (InputStream is = Files.newInputStream(XML_PATH)) {
 673             NodeList nodeList = (NodeList)xpath.evaluate(EXPRESSION_NAME_A,
 674                 new InputSource(is), NODESET);
 675             assertEquals(((Attr) nodeList.item(0)).getValue(), "6");
 676         } catch (XPathExpressionException | IOException ex) {
 677             failUnexpected(ex);
 678         }
 679     }
 680 
 681     /**
 682      * Test for XPath.getNamespaceContext() returns the current namespace
 683      * context, null is returned if no namespace context is in effect.
 684      */
 685     @Test
 686     public void testCheckXPath56() {
 687         // CR 6376058 says that an impl will be provided, but by
 688         // default we still return null here
 689         assertNull(xpath.getNamespaceContext());
 690     }
 691 
 692     /**
 693      * Test for XPath.setNamespaceContext(NamespaceContext nsContext) Establish
 694      * a namespace context. Set a valid nsContext and retrieve it using
 695      * getNamespaceContext(), should return the same.
 696      */
 697     @Test
 698     public void testCheckXPath57() {
 699         MyNamespaceContext myNamespaceContext = new MyNamespaceContext();
 700         xpath.setNamespaceContext(myNamespaceContext);
 701         assertEquals(xpath.getNamespaceContext(), myNamespaceContext);
 702     }
 703 
 704     /**
 705      * Test for XPath.setNamespaceContext(NamespaceContext nsContext) Establish
 706      * a namespace context. NullPointerException is thrown if nsContext is null.
 707      */
 708     @Test(expectedExceptions = NullPointerException.class)
 709     public void testCheckXPath58() {
 710         xpath.setNamespaceContext(null);
 711     }
 712 
 713     /**
 714      * Test for XPath.getXPathFunctionResolver() Return the current function
 715      * resolver. Null is returned if no function resolver is in effect.
 716      */
 717     @Test
 718     public void testCheckXPath59() {
 719         assertNull(xpath.getXPathFunctionResolver());
 720     }
 721 
 722     /**
 723      * Test for XPath.setXPathFunctionResolver(XPathFunctionResolver resolver).
 724      * Set a valid resolver and retrieve it using getXPathFunctionResolver(),
 725      * should return the same.
 726      */
 727     @Test
 728     public void testCheckXPath60() {
 729         xpath.setXPathFunctionResolver((functionName, arity) -> null);
 730         assertNotNull(xpath.getXPathFunctionResolver());
 731     }
 732 
 733     /**
 734      * Test for XPath.setXPathFunctionResolver(XPathFunctionResolver resolver).
 735      * set resolver as null, should throw NPE.
 736      */
 737     @Test(expectedExceptions = NullPointerException.class)
 738     public void testCheckXPath61() {
 739         xpath.setXPathFunctionResolver(null);
 740     }
 741 
 742     /**
 743      * Test for XPath.getXPathVariableResolver() Return the current variable
 744      * resolver. null is returned if no variable resolver is in effect.
 745      */
 746     @Test
 747     public void testCheckXPath62() {
 748         assertNull(xpath.getXPathVariableResolver());
 749     }
 750 
 751     /**
 752      * Test for XPath.setXPathVariableResolver(XPathVariableResolver resolver).
 753      * Set a valid resolver and retrieve it using getXPathVariableResolver(),
 754      * should return the same.
 755      */
 756     @Test
 757     public void testCheckXPath63() {
 758         xpath.setXPathVariableResolver(qname -> null);
 759         assertNotNull(xpath.getXPathVariableResolver());
 760     }
 761 
 762     /**
 763      * Test for XPath.setXPathVariableResolver(XPathVariableResolver resolver).
 764      * Set resolver as null, should throw NPE.
 765      */
 766     @Test(expectedExceptions = NullPointerException.class)
 767     public void testCheckXPath64() {
 768         xpath.setXPathVariableResolver(null);
 769     }
 770 
 771     /**
 772      * Customized NamespaceContext used for test
 773      */
 774     private class MyNamespaceContext implements NamespaceContext {
 775         /**
 776          * et Namespace URI bound to a prefix in the current scope.
 777          * @param prefix prefix to look up
 778          * @return a Namespace URI identical to prefix
 779          */
 780         @Override
 781         public String getNamespaceURI(String prefix) {
 782             return prefix;
 783         }
 784 
 785         /**
 786          * Get prefix bound to Namespace URI in the current scope.
 787          * @param namespaceURI URI of Namespace to lookup
 788          * @return prefix identical to URI of Namespace
 789          */
 790         @Override
 791         public String getPrefix(String namespaceURI) {
 792             return namespaceURI;
 793         }
 794 
 795         /**
 796          * Get all prefixes bound to a Namespace URI in the current scope.
 797          * @param namespaceURI URI of Namespace to lookup
 798          * @return null
 799          */
 800         @Override
 801         public Iterator getPrefixes(String namespaceURI) {
 802             return null;
 803         }
 804     }
 805 }
--- EOF ---