1 /* 2 * Copyright (c) 1999, 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.transform.ptests; 25 26 import static javax.xml.transform.ptests.TransformerTestConst.XML_DIR; 27 28 import java.io.BufferedWriter; 29 import java.io.ByteArrayInputStream; 30 import java.io.ByteArrayOutputStream; 31 import java.io.IOException; 32 import java.io.InputStream; 33 import java.io.OutputStream; 34 import java.io.OutputStreamWriter; 35 import java.nio.file.Files; 36 import java.nio.file.Paths; 37 import java.util.function.Supplier; 38 39 import javax.xml.parsers.DocumentBuilder; 40 import javax.xml.parsers.DocumentBuilderFactory; 41 import javax.xml.parsers.ParserConfigurationException; 42 import javax.xml.stream.XMLEventWriter; 43 import javax.xml.stream.XMLInputFactory; 44 import javax.xml.stream.XMLOutputFactory; 45 import javax.xml.stream.XMLStreamException; 46 import javax.xml.stream.XMLStreamReader; 47 import javax.xml.stream.XMLStreamWriter; 48 import javax.xml.transform.Result; 49 import javax.xml.transform.Source; 50 import javax.xml.transform.Transformer; 51 import javax.xml.transform.TransformerConfigurationException; 52 import javax.xml.transform.TransformerFactory; 53 import javax.xml.transform.dom.DOMSource; 54 import javax.xml.transform.sax.SAXResult; 55 import javax.xml.transform.sax.SAXSource; 56 import javax.xml.transform.stax.StAXResult; 57 import javax.xml.transform.stax.StAXSource; 58 import javax.xml.transform.stream.StreamResult; 59 import javax.xml.transform.stream.StreamSource; 60 61 import jaxp.library.JAXPFileBaseTest; 62 63 import org.testng.annotations.BeforeClass; 64 import org.testng.annotations.DataProvider; 65 import org.testng.annotations.Test; 66 import org.w3c.dom.Document; 67 import org.xml.sax.Attributes; 68 import org.xml.sax.ContentHandler; 69 import org.xml.sax.InputSource; 70 import org.xml.sax.Locator; 71 import org.xml.sax.SAXException; 72 73 /* 74 * @summary Tests for variable combination of Transformer.transform(Source, Result) 75 */ 76 @Test(singleThreaded = true) 77 public class TransformTest extends JAXPFileBaseTest { 78 79 /** 80 * Initialize the share objects. 81 * 82 * @throws IOException 83 * @throws SAXException 84 * @throws ParserConfigurationException 85 */ 86 @BeforeClass 87 public void setup() throws SAXException, IOException, ParserConfigurationException { 88 ifac = XMLInputFactory.newInstance(); 89 ofac = XMLOutputFactory.newInstance(); 90 tfac = TransformerFactory.newInstance(); 91 92 DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance(); 93 dbf.setNamespaceAware(true); 94 db = dbf.newDocumentBuilder(); 95 96 xml = Files.readAllBytes(Paths.get(XML_DIR + "cities.xml")); 97 template = Files.readAllBytes(Paths.get(XML_DIR + "cities.xsl")); 98 99 xmlDoc = db.parse(xmlInputStream()); 100 } 101 102 @DataProvider(name = "input-provider") 103 public Object[][] prepareTestCombination() throws Exception { 104 105 Supplier<Source> staxStreamSource = () -> new StAXSource(getXMLStreamReader()); 106 Supplier<Source> staxEventSource = this::getStAXEventSource; 107 Supplier<Source> domSource = () -> new DOMSource(xmlDoc); 108 Supplier<Source> saxSource = () -> new SAXSource(new InputSource(xmlInputStream())); 109 Supplier<Source> streamSource = () -> new StreamSource(xmlInputStream()); 110 111 Supplier<Result> staxStreamResult = () -> new StAXResult(getXMLStreamWriter()); 112 Supplier<Result> staxEventResult = () -> new StAXResult(getXMLEventWriter()); 113 Supplier<Result> saxResult = this::getHandlerSAXResult; 114 Supplier<Result> streamResult = () -> new StreamResult(transOutputStream()); 115 116 Transformer domTemplateTransformer = createTransformer(getDomTemplate()); 117 Transformer saxTemplateTransformer = createTransformer(getSAXTemplate()); 118 Transformer streamTemplateTransformer = createTransformer(getStreamTemplate()); 119 Transformer noTemplateTransformer = createTransformer(null); 120 Transformer staxStreamTemplateTransformer = createTransformer(getStAXStreamTemplate()); 121 Transformer staxEventTemplateTransformer = createTransformer(getStAXEventTemplate()); 122 123 return new Object[][] { 124 // StAX Stream 125 { staxStreamSource, staxStreamResult, domTemplateTransformer }, 126 { staxStreamSource, staxStreamResult, saxTemplateTransformer }, 127 { staxStreamSource, staxStreamResult, streamTemplateTransformer }, 128 { staxStreamSource, staxStreamResult, noTemplateTransformer }, 129 { staxStreamSource, staxStreamResult, staxStreamTemplateTransformer }, 130 { staxStreamSource, saxResult, domTemplateTransformer }, 131 { staxStreamSource, streamResult, domTemplateTransformer }, 132 { domSource, staxStreamResult, domTemplateTransformer }, 133 { saxSource, staxStreamResult, domTemplateTransformer }, 134 { streamSource, staxStreamResult, domTemplateTransformer }, 135 { staxStreamSource, streamResult, saxTemplateTransformer }, 136 { domSource, staxStreamResult, saxTemplateTransformer }, 137 { saxSource, staxStreamResult, saxTemplateTransformer }, 138 { streamSource, staxStreamResult, saxTemplateTransformer }, 139 { staxStreamSource, streamResult, streamTemplateTransformer }, 140 { domSource, staxStreamResult, streamTemplateTransformer }, 141 { saxSource, staxStreamResult, streamTemplateTransformer }, 142 { streamSource, staxStreamResult, streamTemplateTransformer }, 143 // StAX Event 144 { staxEventSource, staxEventResult, domTemplateTransformer }, 145 { staxEventSource, staxEventResult, saxTemplateTransformer }, 146 { staxEventSource, staxEventResult, streamTemplateTransformer }, 147 { staxEventSource, staxEventResult, noTemplateTransformer }, 148 { staxEventSource, staxEventResult, staxEventTemplateTransformer }, 149 { staxEventSource, saxResult, domTemplateTransformer }, 150 { staxEventSource, streamResult, domTemplateTransformer }, 151 { domSource, staxEventResult, domTemplateTransformer }, 152 { saxSource, staxEventResult, domTemplateTransformer }, 153 { streamSource, staxEventResult, domTemplateTransformer }, 154 { staxEventSource, streamResult, saxTemplateTransformer }, 155 { domSource, staxEventResult, saxTemplateTransformer }, 156 { saxSource, staxEventResult, saxTemplateTransformer }, 157 { streamSource, staxEventResult, saxTemplateTransformer }, 158 { staxEventSource, streamResult, streamTemplateTransformer }, 159 { domSource, staxEventResult, streamTemplateTransformer }, 160 { saxSource, staxEventResult, streamTemplateTransformer }, 161 { streamSource, staxEventResult, streamTemplateTransformer } }; 162 } 163 164 /* 165 * run Transformer.transform(Source, Result) 166 */ 167 @Test(dataProvider = "input-provider") 168 public void testTransform(Supplier<Source> src, Supplier<Result> res, Transformer transformer) throws Throwable { 169 try { 170 transformer.transform(src.get(), res.get()); 171 } catch (WrapperException e) { 172 throw e.getCause(); 173 } 174 } 175 176 private InputStream xmlInputStream() { 177 return new ByteArrayInputStream(xml); 178 } 179 180 private InputStream templateInputStream() { 181 return new ByteArrayInputStream(template); 182 } 183 184 private OutputStream transOutputStream() { 185 return new ByteArrayOutputStream(xml.length); 186 } 187 188 private XMLStreamReader getXMLStreamReader() { 189 try { 190 return ifac.createXMLStreamReader(xmlInputStream()); 191 } catch (XMLStreamException e) { 192 throw new WrapperException(e); 193 } 194 } 195 196 private XMLStreamWriter getXMLStreamWriter() { 197 try { 198 return ofac.createXMLStreamWriter(transOutputStream()); 199 } catch (XMLStreamException e) { 200 throw new WrapperException(e); 201 } 202 } 203 204 private StAXSource getStAXEventSource() { 205 try { 206 return new StAXSource(ifac.createXMLEventReader(xmlInputStream())); 207 } catch (XMLStreamException e) { 208 throw new WrapperException(e); 209 } 210 } 211 212 private XMLEventWriter getXMLEventWriter() { 213 try { 214 return ofac.createXMLEventWriter(transOutputStream()); 215 } catch (XMLStreamException e) { 216 throw new WrapperException(e); 217 } 218 } 219 220 private SAXResult getHandlerSAXResult() { 221 SAXResult res = new SAXResult(); 222 MyContentHandler myContentHandler = new MyContentHandler(transOutputStream()); 223 res.setHandler(myContentHandler); 224 return res; 225 } 226 227 private Source getDomTemplate() throws SAXException, IOException { 228 return new DOMSource(db.parse(templateInputStream())); 229 } 230 231 private Source getSAXTemplate() { 232 return new SAXSource(new InputSource(templateInputStream())); 233 } 234 235 private Source getStreamTemplate() { 236 return new StreamSource(templateInputStream()); 237 } 238 239 private Source getStAXStreamTemplate() throws XMLStreamException { 240 return new StAXSource(ifac.createXMLStreamReader(templateInputStream())); 241 } 242 243 private Source getStAXEventTemplate() throws XMLStreamException { 244 return new StAXSource(ifac.createXMLEventReader(templateInputStream())); 245 } 246 247 private Transformer createTransformer(Source templateSource) throws TransformerConfigurationException { 248 Transformer transformer = (templateSource == null) ? tfac.newTransformer() : tfac.newTransformer(templateSource); 249 transformer.setOutputProperty("indent", "yes"); 250 return transformer; 251 252 } 253 254 private static class MyContentHandler implements ContentHandler { 255 private BufferedWriter bWriter; 256 257 public MyContentHandler(OutputStream os) { 258 bWriter = new BufferedWriter(new OutputStreamWriter(os)); 259 } 260 261 public void setDocumentLocator(Locator locator) { 262 } 263 264 public void startDocument() throws SAXException { 265 String str = "startDocument"; 266 try { 267 bWriter.write(str, 0, str.length()); 268 bWriter.newLine(); 269 } catch (IOException e) { 270 System.out.println("bWriter error"); 271 } 272 } 273 274 public void endDocument() throws SAXException { 275 String str = "endDocument"; 276 try { 277 bWriter.write(str, 0, str.length()); 278 bWriter.newLine(); 279 bWriter.flush(); 280 bWriter.close(); 281 } catch (IOException e) { 282 System.out.println("bWriter error"); 283 } 284 } 285 286 public void startPrefixMapping(String prefix, String uri) throws SAXException { 287 String str = "startPrefixMapping: " + prefix + ", " + uri; 288 try { 289 bWriter.write(str, 0, str.length()); 290 bWriter.newLine(); 291 } catch (IOException e) { 292 System.out.println("bWriter error"); 293 } 294 } 295 296 public void endPrefixMapping(String prefix) throws SAXException { 297 String str = "endPrefixMapping: " + prefix; 298 try { 299 bWriter.write(str, 0, str.length()); 300 bWriter.newLine(); 301 } catch (IOException e) { 302 System.out.println("bWriter error"); 303 } 304 } 305 306 public void startElement(String namespaceURI, String localName, String qName, Attributes atts) throws SAXException { 307 StringBuilder str = new StringBuilder("startElement: ").append(namespaceURI).append(", ").append(namespaceURI).append(", ").append(qName).append(" : "); 308 int n = atts.getLength(); 309 for (int i = 0; i < n; i++) { 310 str.append(", ").append(atts.getQName(i)).append(" : ").append(atts.getValue(i)); 311 } 312 313 try { 314 bWriter.write(str.toString(), 0, str.length()); 315 bWriter.newLine(); 316 } catch (IOException e) { 317 System.out.println("bWriter error"); 318 } 319 } 320 321 public void endElement(String namespaceURI, String localName, String qName) throws SAXException { 322 String str = "endElement: " + namespaceURI + ", " + namespaceURI + ", " + qName; 323 try { 324 bWriter.write(str, 0, str.length()); 325 bWriter.newLine(); 326 } catch (IOException e) { 327 System.out.println("bWriter error"); 328 } 329 330 } 331 332 public void characters(char ch[], int start, int length) throws SAXException { 333 String str = new String(ch, start, length); 334 try { 335 bWriter.write(str, 0, str.length()); 336 bWriter.newLine(); 337 } catch (IOException e) { 338 System.out.println("bWriter error"); 339 } 340 } 341 342 public void ignorableWhitespace(char ch[], int start, int length) throws SAXException { 343 String str = "ignorableWhitespace"; 344 try { 345 bWriter.write(str, 0, str.length()); 346 bWriter.newLine(); 347 } catch (IOException e) { 348 System.out.println("bWriter error"); 349 } 350 } 351 352 public void processingInstruction(String target, String data) throws SAXException { 353 String str = "processingInstruction: " + target + ", " + target; 354 try { 355 bWriter.write(str, 0, str.length()); 356 bWriter.newLine(); 357 } catch (IOException e) { 358 System.out.println("bWriter error"); 359 } 360 } 361 362 public void skippedEntity(String name) throws SAXException { 363 String str = "skippedEntity: " + name; 364 try { 365 bWriter.write(str, 0, str.length()); 366 bWriter.newLine(); 367 } catch (IOException e) { 368 System.out.println("bWriter error"); 369 } 370 } 371 } 372 373 private static class WrapperException extends RuntimeException { 374 public WrapperException(Throwable cause) { 375 super(cause); 376 } 377 } 378 379 private XMLInputFactory ifac; 380 private XMLOutputFactory ofac; 381 private TransformerFactory tfac; 382 private DocumentBuilder db; 383 private byte[] xml; 384 private byte[] template; 385 private Document xmlDoc; 386 387 }