SAXTFactoryTest.java revision 687:e7736286abe1 
1/*
2 * Copyright (c) 2003, 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
24package javax.xml.transform.ptests;
25
26import java.io.File;
27import java.io.FileInputStream;
28import java.io.FileOutputStream;
29import javax.xml.parsers.DocumentBuilder;
30import javax.xml.parsers.DocumentBuilderFactory;
31import javax.xml.transform.Result;
32import javax.xml.transform.TransformerConfigurationException;
33import javax.xml.transform.TransformerFactory;
34import javax.xml.transform.dom.DOMSource;
35import static javax.xml.transform.ptests.TransformerTestConst.GOLDEN_DIR;
36import static javax.xml.transform.ptests.TransformerTestConst.XML_DIR;
37import javax.xml.transform.sax.SAXSource;
38import javax.xml.transform.sax.SAXTransformerFactory;
39import javax.xml.transform.sax.TemplatesHandler;
40import javax.xml.transform.sax.TransformerHandler;
41import javax.xml.transform.stream.StreamResult;
42import javax.xml.transform.stream.StreamSource;
43import jaxp.library.JAXPFileBaseTest;
44import static jaxp.library.JAXPTestUtilities.USER_DIR;
45import static jaxp.library.JAXPTestUtilities.compareWithGold;
46import static org.testng.Assert.assertTrue;
47import org.testng.annotations.Test;
48import org.w3c.dom.Document;
49import org.w3c.dom.Node;
50import org.xml.sax.InputSource;
51import org.xml.sax.XMLFilter;
52import org.xml.sax.XMLReader;
53import org.xml.sax.helpers.XMLReaderFactory;
54
55/**
56 * Test newTransformerhandler() method which takes StreamSource as argument can
57 * be set to XMLReader.
58 */
59public class SAXTFactoryTest extends JAXPFileBaseTest {
60    /**
61     * Test style-sheet file.
62     */
63    private static final String XSLT_FILE = XML_DIR + "cities.xsl";
64
65    /**
66     * Test style-sheet file.
67     */
68    private static final String XSLT_INCL_FILE = XML_DIR + "citiesinclude.xsl";
69
70    /**
71     * Test XML file.
72     */
73    private static final String XML_FILE = XML_DIR + "cities.xml";
74
75    /**
76     * SAXTFactory.newTransformerhandler() method which takes SAXSource as
77     * argument can be set to XMLReader. SAXSource has input XML file as its
78     * input source. XMLReader has a transformer handler which write out the
79     * result to output file. Test verifies output file is same as golden file.
80     *
81     * @throws Exception If any errors occur.
82     */
83    @Test
84    public void testcase01() throws Exception {
85        String outputFile = USER_DIR + "saxtf001.out";
86        String goldFile = GOLDEN_DIR + "saxtf001GF.out";
87
88        try (FileOutputStream fos = new FileOutputStream(outputFile)) {
89            XMLReader reader = XMLReaderFactory.createXMLReader();
90            SAXTransformerFactory saxTFactory
91                    = (SAXTransformerFactory) TransformerFactory.newInstance();
92            TransformerHandler handler = saxTFactory.newTransformerHandler(new StreamSource(XSLT_FILE));
93            Result result = new StreamResult(fos);
94            handler.setResult(result);
95            reader.setContentHandler(handler);
96            reader.parse(XML_FILE);
97        }
98        assertTrue(compareWithGold(goldFile, outputFile));
99    }
100
101    /**
102     * SAXTFactory.newTransformerhandler() method which takes SAXSource as
103     * argument can be set to XMLReader. SAXSource has input XML file as its
104     * input source. XMLReader has a content handler which write out the result
105     * to output file. Test verifies output file is same as golden file.
106     *
107     * @throws Exception If any errors occur.
108     */
109    @Test
110    public void testcase02() throws Exception {
111        String outputFile = USER_DIR + "saxtf002.out";
112        String goldFile = GOLDEN_DIR + "saxtf002GF.out";
113
114        try (FileOutputStream fos = new FileOutputStream(outputFile);
115                FileInputStream fis = new FileInputStream(XSLT_FILE)) {
116            XMLReader reader = XMLReaderFactory.createXMLReader();
117            SAXTransformerFactory saxTFactory
118                    = (SAXTransformerFactory) TransformerFactory.newInstance();
119            SAXSource ss = new SAXSource();
120            ss.setInputSource(new InputSource(fis));
121
122            TransformerHandler handler = saxTFactory.newTransformerHandler(ss);
123            Result result = new StreamResult(fos);
124            handler.setResult(result);
125            reader.setContentHandler(handler);
126            reader.parse(XML_FILE);
127        }
128        assertTrue(compareWithGold(goldFile, outputFile));
129    }
130
131    /**
132     * Unit test for newTransformerhandler(Source). DcoumentBuilderFactory is
133     * namespace awareness, DocumentBuilder parse xslt file as DOMSource.
134     *
135     * @throws Exception If any errors occur.
136     */
137    @Test
138    public void testcase03() throws Exception {
139        String outputFile = USER_DIR + "saxtf003.out";
140        String goldFile = GOLDEN_DIR + "saxtf003GF.out";
141
142        try (FileOutputStream fos = new FileOutputStream(outputFile)) {
143            DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
144            dbf.setNamespaceAware(true);
145            DocumentBuilder docBuilder = dbf.newDocumentBuilder();
146            Document document = docBuilder.parse(new File(XSLT_FILE));
147            Node node = (Node)document;
148            DOMSource domSource= new DOMSource(node);
149
150            XMLReader reader = XMLReaderFactory.createXMLReader();
151            SAXTransformerFactory saxTFactory
152                    = (SAXTransformerFactory)TransformerFactory.newInstance();
153            TransformerHandler handler =
154                        saxTFactory.newTransformerHandler(domSource);
155            Result result = new StreamResult(fos);
156            handler.setResult(result);
157            reader.setContentHandler(handler);
158            reader.parse(XML_FILE);
159        }
160        assertTrue(compareWithGold(goldFile, outputFile));
161    }
162
163    /**
164     * Negative test for newTransformerHandler when relative URI is in XML file.
165     *
166     * @throws Exception If any errors occur.
167     */
168    @Test(expectedExceptions = TransformerConfigurationException.class)
169    public void transformerHandlerTest04() throws Exception {
170        DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
171        dbf.setNamespaceAware(true);
172        DocumentBuilder docBuilder = dbf.newDocumentBuilder();
173        Document document = docBuilder.parse(new File(XSLT_INCL_FILE));
174        DOMSource domSource= new DOMSource(document);
175        SAXTransformerFactory saxTFactory
176                = (SAXTransformerFactory)TransformerFactory.newInstance();
177        saxTFactory.newTransformerHandler(domSource);
178    }
179
180    /**
181     * Unit test for XMLReader parsing when relative URI is used in xsl file and
182     * SystemId was set.
183     *
184     * @throws Exception If any errors occur.
185     */
186    @Test
187    public void testcase05() throws Exception {
188        String outputFile = USER_DIR + "saxtf005.out";
189        String goldFile = GOLDEN_DIR + "saxtf005GF.out";
190
191        try (FileOutputStream fos = new FileOutputStream(outputFile)) {
192            XMLReader reader = XMLReaderFactory.createXMLReader();
193            SAXTransformerFactory saxTFactory
194                    = (SAXTransformerFactory)TransformerFactory.newInstance();
195            DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
196            dbf.setNamespaceAware(true);
197            DocumentBuilder docBuilder = dbf.newDocumentBuilder();
198            Document document = docBuilder.parse(new File(XSLT_INCL_FILE));
199            Node node = (Node)document;
200            DOMSource domSource= new DOMSource(node);
201
202            domSource.setSystemId("file:///" + XML_DIR);
203
204            TransformerHandler handler =
205                        saxTFactory.newTransformerHandler(domSource);
206            Result result = new StreamResult(fos);
207
208            handler.setResult(result);
209            reader.setContentHandler(handler);
210            reader.parse(XML_FILE);
211        }
212        assertTrue(compareWithGold(goldFile, outputFile));
213    }
214
215    /**
216     * Unit test newTransformerHandler with a DOMSource.
217     *
218     * @throws Exception If any errors occur.
219     */
220    @Test
221    public void testcase06() throws Exception {
222        String outputFile = USER_DIR + "saxtf006.out";
223        String goldFile = GOLDEN_DIR + "saxtf006GF.out";
224
225        try (FileOutputStream fos = new FileOutputStream(outputFile)) {
226            XMLReader reader = XMLReaderFactory.createXMLReader();
227            SAXTransformerFactory saxTFactory
228                    = (SAXTransformerFactory)TransformerFactory.newInstance();
229
230            DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
231            dbf.setNamespaceAware(true);
232            DocumentBuilder docBuilder = dbf.newDocumentBuilder();
233            Node node = (Node)docBuilder.parse(new File(XSLT_INCL_FILE));
234
235            DOMSource domSource = new DOMSource(node, "file:///" + XML_DIR);
236            TransformerHandler handler =
237                        saxTFactory.newTransformerHandler(domSource);
238
239            Result result = new StreamResult(fos);
240            handler.setResult(result);
241            reader.setContentHandler(handler);
242            reader.parse(XML_FILE);
243        }
244        assertTrue(compareWithGold(goldFile, outputFile));
245    }
246
247    /**
248     * Test newTransformerHandler with a Template Handler.
249     *
250     * @throws Exception If any errors occur.
251     */
252    public void testcase08() throws Exception {
253        String outputFile = USER_DIR + "saxtf008.out";
254        String goldFile = GOLDEN_DIR + "saxtf008GF.out";
255
256        try (FileOutputStream fos = new FileOutputStream(outputFile)) {
257            XMLReader reader = XMLReaderFactory.createXMLReader();
258            SAXTransformerFactory saxTFactory
259                    = (SAXTransformerFactory)TransformerFactory.newInstance();
260
261            TemplatesHandler thandler = saxTFactory.newTemplatesHandler();
262            reader.setContentHandler(thandler);
263            reader.parse(XSLT_FILE);
264            TransformerHandler tfhandler
265                    = saxTFactory.newTransformerHandler(thandler.getTemplates());
266
267            Result result = new StreamResult(fos);
268            tfhandler.setResult(result);
269
270            reader.setContentHandler(tfhandler);
271            reader.parse(XML_FILE);
272        }
273        assertTrue(compareWithGold(goldFile, outputFile));
274    }
275
276    /**
277     * Test newTransformerHandler with a Template Handler along with a relative
278     * URI in the style-sheet file.
279     *
280     * @throws Exception If any errors occur.
281     */
282    @Test
283    public void testcase09() throws Exception {
284        String outputFile = USER_DIR + "saxtf009.out";
285        String goldFile = GOLDEN_DIR + "saxtf009GF.out";
286
287        try (FileOutputStream fos = new FileOutputStream(outputFile)) {
288            XMLReader reader = XMLReaderFactory.createXMLReader();
289            SAXTransformerFactory saxTFactory
290                    = (SAXTransformerFactory)TransformerFactory.newInstance();
291
292            TemplatesHandler thandler = saxTFactory.newTemplatesHandler();
293            thandler.setSystemId("file:///" + XML_DIR);
294            reader.setContentHandler(thandler);
295            reader.parse(XSLT_INCL_FILE);
296            TransformerHandler tfhandler=
297                saxTFactory.newTransformerHandler(thandler.getTemplates());
298            Result result = new StreamResult(fos);
299            tfhandler.setResult(result);
300            reader.setContentHandler(tfhandler);
301            reader.parse(XML_FILE);
302        }
303        assertTrue(compareWithGold(goldFile, outputFile));
304    }
305
306    /**
307     * Unit test for contentHandler setter/getter along reader as handler's
308     * parent.
309     *
310     * @throws Exception If any errors occur.
311     */
312    @Test
313    public void testcase10() throws Exception {
314        String outputFile = USER_DIR + "saxtf010.out";
315        String goldFile = GOLDEN_DIR + "saxtf010GF.out";
316        // The transformer will use a SAX parser as it's reader.
317        XMLReader reader = XMLReaderFactory.createXMLReader();
318        SAXTransformerFactory saxTFactory
319                = (SAXTransformerFactory)TransformerFactory.newInstance();
320        XMLFilter filter =
321            saxTFactory.newXMLFilter(new StreamSource(XSLT_FILE));
322        filter.setParent(reader);
323        filter.setContentHandler(new MyContentHandler(outputFile));
324
325        // Now, when you call transformer.parse, it will set itself as
326        // the content handler for the parser object (it's "parent"), and
327        // will then call the parse method on the parser.
328        filter.parse(new InputSource(XML_FILE));
329        assertTrue(compareWithGold(goldFile, outputFile));
330    }
331
332    /**
333     * Unit test for contentHandler setter/getter with parent.
334     *
335     * @throws Exception If any errors occur.
336     */
337    @Test
338    public void testcase11() throws Exception {
339        String outputFile = USER_DIR + "saxtf011.out";
340        String goldFile = GOLDEN_DIR + "saxtf011GF.out";
341        // The transformer will use a SAX parser as it's reader.
342        XMLReader reader = XMLReaderFactory.createXMLReader();
343        DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
344        dbf.setNamespaceAware(true);
345        DocumentBuilder docBuilder = dbf.newDocumentBuilder();
346        Document document = docBuilder.parse(new File(XSLT_FILE));
347        Node node = (Node)document;
348        DOMSource domSource= new DOMSource(node);
349
350        SAXTransformerFactory saxTFactory
351                = (SAXTransformerFactory)TransformerFactory.newInstance();
352        XMLFilter filter = saxTFactory.newXMLFilter(domSource);
353
354        filter.setParent(reader);
355        filter.setContentHandler(new MyContentHandler(outputFile));
356
357        // Now, when you call transformer.parse, it will set itself as
358        // the content handler for the parser object (it's "parent"), and
359        // will then call the parse method on the parser.
360        filter.parse(new InputSource(XML_FILE));
361        assertTrue(compareWithGold(goldFile, outputFile));
362    }
363
364    /**
365     * Unit test for contentHandler setter/getter.
366     *
367     * @throws Exception If any errors occur.
368     */
369    @Test
370    public void testcase12() throws Exception {
371        String outputFile = USER_DIR + "saxtf012.out";
372        String goldFile = GOLDEN_DIR + "saxtf012GF.out";
373        // The transformer will use a SAX parser as it's reader.
374        XMLReader reader = XMLReaderFactory.createXMLReader();
375
376        InputSource is = new InputSource(new FileInputStream(XSLT_FILE));
377        SAXSource saxSource = new SAXSource();
378        saxSource.setInputSource(is);
379
380        SAXTransformerFactory saxTFactory = (SAXTransformerFactory)TransformerFactory.newInstance();
381        XMLFilter filter = saxTFactory.newXMLFilter(saxSource);
382
383        filter.setParent(reader);
384        filter.setContentHandler(new MyContentHandler(outputFile));
385
386        // Now, when you call transformer.parse, it will set itself as
387        // the content handler for the parser object (it's "parent"), and
388        // will then call the parse method on the parser.
389        filter.parse(new InputSource(XML_FILE));
390        assertTrue(compareWithGold(goldFile, outputFile));
391    }
392
393    /**
394     * Unit test for TemplatesHandler setter/getter.
395     *
396     * @throws Exception If any errors occur.
397     */
398    @Test
399    public void testcase13() throws Exception {
400        String outputFile = USER_DIR + "saxtf013.out";
401        String goldFile = GOLDEN_DIR + "saxtf013GF.out";
402        try(FileInputStream fis = new FileInputStream(XML_FILE)) {
403            // The transformer will use a SAX parser as it's reader.
404            XMLReader reader = XMLReaderFactory.createXMLReader();
405
406            SAXTransformerFactory saxTFactory
407                    = (SAXTransformerFactory) TransformerFactory.newInstance();
408            TemplatesHandler thandler = saxTFactory.newTemplatesHandler();
409            // I have put this as it was complaining about systemid
410            thandler.setSystemId("file:///" + USER_DIR);
411
412            reader.setContentHandler(thandler);
413            reader.parse(XSLT_FILE);
414            XMLFilter filter
415                    = saxTFactory.newXMLFilter(thandler.getTemplates());
416            filter.setParent(reader);
417
418            filter.setContentHandler(new MyContentHandler(outputFile));
419            filter.parse(new InputSource(fis));
420        }
421        assertTrue(compareWithGold(goldFile, outputFile));
422    }
423}
424