1 /* 2 * Copyright (c) 2014, 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 dom.ls; 25 26 import java.io.IOException; 27 import java.io.StringBufferInputStream; 28 29 import javax.xml.parsers.DocumentBuilder; 30 import javax.xml.parsers.DocumentBuilderFactory; 31 import javax.xml.parsers.ParserConfigurationException; 32 33 import org.testng.Assert; 34 import org.testng.annotations.Test; 35 import org.w3c.dom.Attr; 36 import org.w3c.dom.DOMImplementation; 37 import org.w3c.dom.Document; 38 import org.w3c.dom.Element; 39 import org.w3c.dom.NamedNodeMap; 40 import org.w3c.dom.Node; 41 import org.w3c.dom.NodeList; 42 import org.w3c.dom.ls.DOMImplementationLS; 43 import org.w3c.dom.ls.LSInput; 44 import org.w3c.dom.ls.LSParser; 45 import org.w3c.dom.ls.LSParserFilter; 46 import org.w3c.dom.traversal.NodeFilter; 47 import org.xml.sax.SAXException; 48 49 /* 50 * @summary Test Specifications and Descriptions for LSParser. 51 */ 52 public class LSParserTCKTest { 53 54 DOMImplementationLS implLS = null; 55 public String xml1 = "<?xml version=\"1.0\"?><ROOT><ELEMENT1><CHILD1/><CHILD1><COC1/></CHILD1></ELEMENT1><ELEMENT2>test1<CHILD2/></ELEMENT2></ROOT>"; 56 57 /** 58 * Equivalence class partitioning 59 * with state, input and output values orientation 60 * for public Document parse(LSInput is), 61 * <br><b>pre-conditions</b>: set filter that REJECTs any CHILD* node, 62 * <br><b>is</b>: xml1 63 * <br><b>output</b>: XML document with ELEMNENT1 and ELEMENT2 only. 64 */ 65 @Test 66 public void testfilter0001() { 67 LSParser parser = createLSParser(); 68 if (parser == null) { 69 Assert.fail("Unable to create LSParser!"); 70 } 71 // set filter 72 parser.setFilter(new LSParserFilter() { 73 public short startElement(Element elt) { 74 return FILTER_ACCEPT; 75 } 76 77 public short acceptNode(Node enode) { 78 if (enode.getNodeName().startsWith("CHILD")) { 79 return FILTER_REJECT; 80 } 81 return FILTER_ACCEPT; 82 } 83 84 public int getWhatToShow() { 85 return NodeFilter.SHOW_ALL; 86 } 87 }); 88 String expected = "<?xml version=\"1.0\"?><ROOT><ELEMENT1></ELEMENT1><ELEMENT2>test1</ELEMENT2></ROOT>"; 89 Document doc = parser.parse(getXmlSource(xml1)); 90 if (!match(expected, doc)) { 91 Assert.fail("DOM structure after parsing is not equal to a structure of XML document, that being parsed"); 92 } 93 94 System.out.println("OKAY"); 95 } 96 97 public LSParserTCKTest(String name) { 98 init(); 99 } 100 101 protected void init() { 102 Document doc = null; 103 DocumentBuilder parser = null; 104 try { 105 parser = DocumentBuilderFactory.newInstance().newDocumentBuilder(); 106 } catch (ParserConfigurationException e) { 107 e.printStackTrace(); 108 } 109 StringBufferInputStream is = new StringBufferInputStream(xml1); 110 try { 111 doc = parser.parse(is); 112 } catch (SAXException e) { 113 e.printStackTrace(); 114 } catch (IOException e) { 115 e.printStackTrace(); 116 } 117 DOMImplementation impl = doc.getImplementation(); 118 implLS = (DOMImplementationLS) impl.getFeature("LS", "3.0"); 119 } 120 121 public LSInput getXmlSource(String xmldoc) { 122 LSInput srcdoc = createLSInput(); 123 srcdoc.setStringData(xmldoc); 124 return srcdoc; 125 } 126 127 public LSInput createLSInput() { 128 return implLS.createLSInput(); 129 } 130 131 public LSParser createLSParser() { 132 return implLS.createLSParser(DOMImplementationLS.MODE_SYNCHRONOUS, "http://www.w3.org/2001/XMLSchema"); 133 } 134 135 public boolean match(String template, Node source) { 136 LSParser dp = createLSParser(); 137 if (dp == null) { 138 System.out.println("Can not create LSParser."); 139 return false; 140 } 141 LSInput src = getXmlSource(template); 142 Document doc = dp.parse(src); 143 return checkXMLs(doc, source); 144 } 145 146 // ========================== XML comparison code ============== 147 public boolean checkXMLs(Node template, Node source) { 148 if (source == null || template == null) { 149 return template == source; 150 } 151 String tname = template.getLocalName(); 152 String tvalue = template.getNodeValue(); 153 NamedNodeMap tattr = template.getAttributes(); 154 NodeList tchildren = template.getChildNodes(); 155 156 String sname = source.getLocalName(); 157 String svalue = source.getNodeValue(); 158 NamedNodeMap sattr = source.getAttributes(); 159 NodeList schildren = source.getChildNodes(); 160 if (tname != null && !tname.equals(sname)) { 161 return false; 162 } 163 if (tvalue != null && !tvalue.equals(svalue)) { 164 return false; 165 } 166 if (tattr != null && sattr != null) { 167 if (sattr.getLength() != tattr.getLength()) { 168 return false; 169 } 170 for (int i = 0; i < tattr.getLength(); i++) { 171 Attr t = (Attr) tattr.item(i); 172 Attr s = (Attr) sattr.getNamedItem(t.getName()); 173 if (!checkXMLAttrs(t, s)) { 174 // ref.println(sname+": [expected attr: " + t + 175 // "; actual attr: " +s+"]"); 176 return false; 177 } 178 } 179 } else if (tattr != null || sattr != null) { 180 return false; 181 } 182 183 for (int i = 0; i < tchildren.getLength(); i++) { 184 if (!checkXMLs(tchildren.item(i), schildren.item(i))) { 185 // ref.println(sname+": [expected node: "+tchildren.item(i) 186 // +"; actual node: "+schildren.item(i)+"]"); 187 return false; 188 } 189 } 190 return true; 191 } 192 193 public boolean checkXMLAttrs(Attr template, Attr source) { 194 if (source == null || template == null) { 195 return template == source; 196 } 197 String tname = template.getName(); 198 String tvalue = template.getValue(); 199 String sname = source.getName(); 200 String svalue = source.getValue(); 201 System.out.println("Attr:" + tname + "?" + sname); 202 if (tname != null && !tname.equals(sname)) { 203 // ref.println("Attr Name:" + tname + "!=" + sname); 204 return false; 205 } 206 if (tvalue != null && !tvalue.equals(svalue)) { 207 // ref.println("Attr value:" + tvalue + "!=" + svalue); 208 return false; 209 } 210 // ref.println("Attr:" + tname + ":" + tvalue + "=" + sname + ":" + 211 // svalue); 212 return true; 213 } 214 215 /** 216 * Equivalence class partitioning with state, input and output values 217 * orientation for public Document parse(LSInput is), <br> 218 * <b>pre-conditions</b>: set filter that SKIPs ELEMENT1 node, <br> 219 * <b>is</b>: xml1 <br> 220 * <b>output</b>: XML document with CHILD1 and ELEMENT2 only. 221 */ 222 @Test 223 public void testFilter0002() { 224 LSParser parser = createLSParser(); 225 if (parser == null) { 226 Assert.fail("Unable to create LSParser!"); 227 } 228 // set filter 229 parser.setFilter(new LSParserFilter() { 230 public short startElement(Element elt) { 231 return FILTER_ACCEPT; 232 } 233 234 public short acceptNode(Node enode) { 235 if (enode.getNodeName().startsWith("ELEMENT1")) { 236 return FILTER_SKIP; 237 } 238 return FILTER_ACCEPT; 239 } 240 241 public int getWhatToShow() { 242 return NodeFilter.SHOW_ALL; 243 } 244 }); 245 String expected = "<?xml version=\"1.0\"?><ROOT><CHILD1/><CHILD1><COC1/></CHILD1><ELEMENT2>test1<CHILD2/></ELEMENT2></ROOT>"; 246 Document doc = parser.parse(getXmlSource(xml1)); 247 if (!match(expected, doc)) { 248 Assert.fail("DOM structure after parsing is not equal to a structure of XML document, that being parsed"); 249 } 250 System.out.println("OKAY"); 251 } 252 253 /** 254 * Equivalence class partitioning with state, input and output values 255 * orientation for public Document parse(LSInput is), <br> 256 * <b>pre-conditions</b>: set filter that SKIPs ELEMENT1 node, <br> 257 * <b>is</b>: xml1 <br> 258 * <b>output</b>: XML document with ELEMENT1 only. 259 */ 260 @Test 261 public void testFilter0003() { 262 LSParser parser = createLSParser(); 263 if (parser == null) { 264 Assert.fail("Unable to create LSParser!"); 265 } 266 // set filter 267 parser.setFilter(new LSParserFilter() { 268 public short startElement(Element elt) { 269 return FILTER_ACCEPT; 270 } 271 272 public short acceptNode(Node enode) { 273 if (enode.getNodeName().startsWith("ELEMENT2")) { 274 return FILTER_INTERRUPT; 275 } 276 return FILTER_ACCEPT; 277 } 278 279 public int getWhatToShow() { 280 return NodeFilter.SHOW_ALL; 281 } 282 }); 283 String expected = "<ROOT><ELEMENT1><CHILD1/><CHILD1><COC1/></CHILD1></ELEMENT1></ROOT>"; 284 Document doc = parser.parse(getXmlSource(xml1)); 285 if (!match(expected, doc)) { 286 Assert.fail("DOM structure after parsing is not equal to a structure of XML document, that being parsed"); 287 } 288 System.out.println("OKAY"); 289 } 290 291 /** 292 * Equivalence class partitioning with state, input and output values 293 * orientation for public Document parse(LSInput is), <br> 294 * <b>pre-conditions</b>: set filter that accepts all, <br> 295 * <b>is</b>: xml1 <br> 296 * <b>output</b>: full XML document. 297 */ 298 @Test 299 public void testFilter0004() { 300 LSParser parser = createLSParser(); 301 if (parser == null) { 302 Assert.fail("Unable to create LSParser!"); 303 } 304 // set filter 305 parser.setFilter(new LSParserFilter() { 306 public short startElement(Element elt) { 307 return FILTER_ACCEPT; 308 } 309 310 public short acceptNode(Node enode) { 311 return FILTER_ACCEPT; 312 } 313 314 public int getWhatToShow() { 315 return NodeFilter.SHOW_ALL; 316 } 317 }); 318 String expected = "<ROOT><ELEMENT1><CHILD1/><CHILD1><COC1/></CHILD1></ELEMENT1><ELEMENT2>test1<CHILD2/></ELEMENT2></ROOT>"; 319 Document doc = parser.parse(getXmlSource(xml1)); 320 if (!match(expected, doc)) { 321 Assert.fail("DOM structure after parsing is not equal to a structure of XML document, that being parsed"); 322 } 323 System.out.println("OKAY"); 324 } 325 326 /** 327 * Equivalence class partitioning with state, input and output values 328 * orientation for public Document parse(LSInput is), <br> 329 * <b>pre-conditions</b>: set filter that REJECTs all, <br> 330 * <b>is</b>: xml1 <br> 331 * <b>output</b>: empty XML document. 332 */ 333 @Test 334 public void testFilter0005() { 335 LSParser parser = createLSParser(); 336 if (parser == null) { 337 Assert.fail("Unable to create LSParser!"); 338 } 339 // set filter 340 parser.setFilter(new LSParserFilter() { 341 public short startElement(Element elt) { 342 return FILTER_ACCEPT; 343 } 344 345 public short acceptNode(Node enode) { 346 return FILTER_REJECT; 347 } 348 349 public int getWhatToShow() { 350 return NodeFilter.SHOW_ALL; 351 } 352 }); 353 Document doc = parser.parse(getXmlSource(xml1)); 354 NodeList children = doc.getDocumentElement().getChildNodes(); 355 if (children.getLength() != 0) { 356 Assert.fail("Not all children skipped"); 357 } 358 System.out.println("OKAY"); 359 } 360 361 /** 362 * Equivalence class partitioning with state, input and output values 363 * orientation for public Document parse(LSInput is), <br> 364 * <b>pre-conditions</b>: set filter that SKIPs all, <br> 365 * <b>is</b>: xml1 <br> 366 * <b>output</b>: empty XML document. 367 */ 368 @Test 369 public void testFilter0006() { 370 LSParser parser = createLSParser(); 371 if (parser == null) { 372 Assert.fail("Unable to create LSParser!"); 373 } 374 // set filter 375 parser.setFilter(new LSParserFilter() { 376 public short startElement(Element elt) { 377 return FILTER_ACCEPT; 378 } 379 380 public short acceptNode(Node enode) { 381 return FILTER_SKIP; 382 } 383 384 public int getWhatToShow() { 385 return NodeFilter.SHOW_ALL; 386 } 387 }); 388 Document doc = parser.parse(getXmlSource(xml1)); 389 NodeList children = doc.getDocumentElement().getChildNodes(); 390 if (children.getLength() != 0) { 391 Assert.fail("Not all children skipped"); 392 } 393 System.out.println("OKAY"); 394 } 395 396 /** 397 * Equivalence class partitioning with state, input and output values 398 * orientation for public Document parse(LSInput is), <br> 399 * <b>pre-conditions</b>: set filter that REJECTs any CHILD* start element, <br> 400 * <b>is</b>: xml1 <br> 401 * <b>output</b>: XML document with ELEMENT1 and ELEMENT2 only. 402 */ 403 @Test 404 public void testFilter0007() { 405 LSParser parser = createLSParser(); 406 if (parser == null) { 407 Assert.fail("Unable to create LSParser!"); 408 } 409 // set filter 410 parser.setFilter(new LSParserFilter() { 411 public short startElement(Element elt) { 412 if (elt.getTagName().startsWith("CHILD")) { 413 return FILTER_REJECT; 414 } 415 return FILTER_ACCEPT; 416 } 417 418 public short acceptNode(Node enode) { 419 return FILTER_ACCEPT; 420 } 421 422 public int getWhatToShow() { 423 return NodeFilter.SHOW_ALL; 424 } 425 }); 426 String expected = "<?xml version=\"1.0\"?><ROOT><ELEMENT1></ELEMENT1><ELEMENT2>test1</ELEMENT2></ROOT>"; 427 Document doc = parser.parse(getXmlSource(xml1)); 428 if (!match(expected, doc)) { 429 Assert.fail("DOM structure after parsing is not equal to a structure of XML document, that being parsed"); 430 } 431 System.out.println("OKAY"); 432 } 433 434 /** 435 * Equivalence class partitioning with state, input and output values 436 * orientation for public Document parse(LSInput is), <br> 437 * <b>pre-conditions</b>: set filter that SKIPs ELEMENT1 start element, <br> 438 * <b>is</b>: xml1 <br> 439 * <b>output</b>: XML document with CHILD1 and ELEMENT2 only. 440 */ 441 @Test 442 public void testFilter0008() { 443 LSParser parser = createLSParser(); 444 if (parser == null) { 445 Assert.fail("Unable to create LSParser!"); 446 } 447 // set filter 448 parser.setFilter(new LSParserFilter() { 449 public short startElement(Element elt) { 450 if (elt.getTagName().equals("ELEMENT1")) { 451 return FILTER_SKIP; 452 } 453 return FILTER_ACCEPT; 454 } 455 456 public short acceptNode(Node enode) { 457 return FILTER_ACCEPT; 458 } 459 460 public int getWhatToShow() { 461 return NodeFilter.SHOW_ALL; 462 } 463 }); 464 String expected = "<?xml version=\"1.0\"?><ROOT><CHILD1/><CHILD1><COC1/></CHILD1><ELEMENT2>test1<CHILD2/></ELEMENT2></ROOT>"; 465 Document doc = parser.parse(getXmlSource(xml1)); 466 if (!match(expected, doc)) { 467 Assert.fail("DOM structure after parsing is not equal to a structure of XML document, that being parsed"); 468 } 469 System.out.println("OKAY"); 470 } 471 472 /** 473 * Equivalence class partitioning with state, input and output values 474 * orientation for public Document parse(LSInput is), <br> 475 * <b>pre-conditions</b>: set filter that SKIPs ELEMENT1 start element, <br> 476 * <b>is</b>: xml1 <br> 477 * <b>output</b>: XML document with ELEMENT1 only. 478 */ 479 @Test 480 public void testFilter0009() { 481 LSParser parser = createLSParser(); 482 if (parser == null) { 483 Assert.fail("Unable to create LSParser!"); 484 } 485 // set filter 486 parser.setFilter(new LSParserFilter() { 487 public short startElement(Element elt) { 488 if (elt.getTagName().startsWith("ELEMENT2")) { 489 return FILTER_INTERRUPT; 490 } 491 return FILTER_ACCEPT; 492 } 493 494 public short acceptNode(Node enode) { 495 return FILTER_ACCEPT; 496 } 497 498 public int getWhatToShow() { 499 return NodeFilter.SHOW_ALL; 500 } 501 }); 502 String expected = "<ROOT><ELEMENT1><CHILD1/><CHILD1><COC1/></CHILD1></ELEMENT1></ROOT>"; 503 Document doc = parser.parse(getXmlSource(xml1)); 504 if (!match(expected, doc)) { 505 Assert.fail("DOM structure after parsing is not equal to a structure of XML document, that being parsed"); 506 } 507 System.out.println("OKAY"); 508 } 509 510 /** 511 * Equivalence class partitioning with state, input and output values 512 * orientation for public Document parse(LSInput is), <br> 513 * <b>pre-conditions</b>: set filter that REJECTs all start element, <br> 514 * <b>is</b>: xml1 <br> 515 * <b>output</b>: empty XML document. 516 */ 517 @Test 518 public void testFilter0010() { 519 LSParser parser = createLSParser(); 520 if (parser == null) { 521 Assert.fail("Unable to create LSParser"); 522 } 523 // set filter 524 parser.setFilter(new LSParserFilter() { 525 public short startElement(Element elt) { 526 return FILTER_REJECT; 527 } 528 529 public short acceptNode(Node enode) { 530 return FILTER_ACCEPT; 531 } 532 533 public int getWhatToShow() { 534 return NodeFilter.SHOW_ALL; 535 } 536 }); 537 Document doc = parser.parse(getXmlSource(xml1)); 538 NodeList children = doc.getDocumentElement().getChildNodes(); 539 if (children.getLength() != 0) { 540 Assert.fail("Not all children skipped"); 541 } 542 System.out.println("OKAY"); 543 } 544 545 /** 546 * Equivalence class partitioning with state, input and output values 547 * orientation for public Document parse(LSInput is), <br> 548 * <b>pre-conditions</b>: set filter that SKIPs all, <br> 549 * <b>is</b>: xml1 <br> 550 * <b>output</b>: empty XML document. 551 */ 552 @Test 553 public void testFilter0011() { 554 LSParser parser = createLSParser(); 555 if (parser == null) { 556 Assert.fail("Unable to create LSParser"); 557 } 558 // set filter 559 parser.setFilter(new LSParserFilter() { 560 public short startElement(Element elt) { 561 return FILTER_SKIP; 562 } 563 564 public short acceptNode(Node enode) { 565 return FILTER_ACCEPT; 566 } 567 568 public int getWhatToShow() { 569 return NodeFilter.SHOW_ALL; 570 } 571 }); 572 Document doc = parser.parse(getXmlSource(xml1)); 573 NodeList children = doc.getDocumentElement().getChildNodes(); 574 if (children.getLength() != 1) { 575 Assert.fail("Not all Element nodes skipped"); 576 } 577 System.out.println("OKAY"); 578 } 579 580 }