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 }