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