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 }