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