| /* |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| /* |
| * $Id$ |
| */ |
| |
| /* |
| * |
| * SmoketestOuttakes.java |
| * |
| */ |
| package org.apache.qetest.xalanj2; |
| |
| // Support for test reporting and harness classes |
| import java.io.File; |
| import java.io.FileOutputStream; |
| import java.io.IOException; |
| import java.util.Properties; |
| |
| import javax.xml.parsers.DocumentBuilder; |
| import javax.xml.parsers.DocumentBuilderFactory; |
| import javax.xml.parsers.ParserConfigurationException; |
| import javax.xml.parsers.SAXParser; |
| import javax.xml.parsers.SAXParserFactory; |
| import javax.xml.transform.OutputKeys; |
| import javax.xml.transform.Result; |
| import javax.xml.transform.Templates; |
| import javax.xml.transform.Transformer; |
| import javax.xml.transform.TransformerConfigurationException; |
| import javax.xml.transform.TransformerException; |
| import javax.xml.transform.TransformerFactory; |
| import javax.xml.transform.dom.DOMResult; |
| import javax.xml.transform.dom.DOMSource; |
| import javax.xml.transform.sax.SAXResult; |
| import javax.xml.transform.sax.SAXSource; |
| import javax.xml.transform.sax.SAXTransformerFactory; |
| import javax.xml.transform.sax.TransformerHandler; |
| import javax.xml.transform.stream.StreamResult; |
| import javax.xml.transform.stream.StreamSource; |
| |
| import org.apache.qetest.FileBasedTest; |
| import org.apache.qetest.Logger; |
| import org.apache.qetest.OutputNameManager; |
| import org.apache.qetest.QetestUtils; |
| import org.apache.qetest.trax.LoggingErrorListener; |
| import org.apache.qetest.trax.LoggingURIResolver; |
| import org.apache.qetest.xsl.LoggingSAXErrorHandler; |
| import org.apache.qetest.xsl.XSLTestfileInfo; |
| import org.apache.xml.serializer.OutputPropertiesFactory; |
| import org.apache.xml.serializer.Serializer; |
| import org.apache.xml.serializer.SerializerFactory; |
| import org.w3c.dom.Document; |
| import org.w3c.dom.DocumentFragment; |
| import org.w3c.dom.Element; |
| import org.w3c.dom.Node; |
| import org.xml.sax.InputSource; |
| import org.xml.sax.SAXException; |
| import org.xml.sax.XMLReader; |
| |
| //------------------------------------------------------------------------- |
| |
| /** |
| * Individual test points taken out of other automation files. |
| * |
| * Although as a quality engineer I'm not sure I really like this |
| * idea, I'm temporarily moving test points with known and reported |
| * fail conditions out of a number of other automated tests into |
| * here. In a distributed open source project like this, this |
| * should make it easier for developers to run a reliable smoketest |
| * before making any checkins (since the list of smoketest files |
| * will generally be kept to tests that we expect should pass; thus |
| * any fails when you run the smoketest when you run it are likely |
| * due to recent changes you have made). |
| * |
| * @author shane_curcuru@lotus.com |
| * @version $Id$ |
| */ |
| public class SmoketestOuttakes extends FileBasedTest |
| { |
| |
| /** Provides nextName(), currentName() functionality. */ |
| protected OutputNameManager outNames; |
| |
| |
| /** Just initialize test name, comment, numTestCases. */ |
| public SmoketestOuttakes() |
| { |
| numTestCases = 6; // REPLACE_num |
| testName = "SmoketestOuttakes"; |
| testComment = "Individual test points taken out of other automation files"; |
| } |
| |
| |
| /** |
| * Initialize this test - Set names of xml/xsl test files. |
| * |
| * @param p Properties to initialize from (if needed) |
| * @return false if we should abort the test; true otherwise |
| */ |
| public boolean doTestFileInit(Properties p) |
| { |
| // Used for all tests; just dump files in trax subdir |
| File outSubDir = new File(outputDir + File.separator + "trax"); |
| if (!outSubDir.mkdirs()) |
| reporter.logWarningMsg("Could not create output dir: " + outSubDir); |
| // Initialize an output name manager to that dir with .out extension |
| outNames = new OutputNameManager(outputDir + File.separator + "trax" + File.separator |
| + testName, ".out"); |
| |
| return true; |
| } |
| |
| |
| /** |
| * Recreate ExamplesTest.exampleContentHandlerToContentHandler. |
| * |
| * @return false if we should abort the test; true otherwise |
| */ |
| public boolean testCase1() |
| { |
| reporter.testCaseInit("Recreate ExamplesTest.exampleContentHandlerToContentHandler"); |
| |
| try |
| { |
| String xslID = inputDir |
| + File.separator |
| + "trax" |
| + File.separator |
| + "xsl" |
| + File.separator |
| + "foo.xsl"; |
| String sourceID = inputDir |
| + File.separator |
| + "trax" |
| + File.separator |
| + "xml" |
| + File.separator |
| + "foo.xml"; |
| String goldName = goldDir |
| + File.separator |
| + "trax" |
| + File.separator |
| + "ExamplesTest_7.out"; |
| |
| reporter.logTraceMsg("NOTE! This file is very sensitive to pathing issues!"); |
| |
| TransformerFactory tfactory = TransformerFactory.newInstance(); |
| |
| // Does this factory support SAX features? |
| if (!tfactory.getFeature(SAXSource.FEATURE)) |
| { |
| reporter.logErrorMsg("exampleContentHandlerToContentHandler:Processor does not support SAX"); |
| return true; |
| } |
| // If so, we can safely cast. |
| SAXTransformerFactory stfactory = ((SAXTransformerFactory) tfactory); |
| |
| // A TransformerHandler is a ContentHandler that will listen for |
| // SAX events, and transform them to the result. |
| reporter.logTraceMsg("newTransformerHandler(new StreamSource(" + QetestUtils.filenameToURL(xslID)); |
| TransformerHandler handler |
| = stfactory.newTransformerHandler(new StreamSource(QetestUtils.filenameToURL(xslID))); |
| |
| // Set the result handling to be a serialization to the file output stream. |
| Serializer serializer = SerializerFactory.getSerializer |
| (OutputPropertiesFactory.getDefaultMethodProperties("xml")); |
| FileOutputStream fos = new FileOutputStream(outNames.nextName()); |
| serializer.setOutputStream(fos); |
| reporter.logStatusMsg("Test-output-to: new FileOutputStream(" + outNames.currentName()); |
| |
| Result result = new SAXResult(serializer.asContentHandler()); |
| |
| handler.setResult(result); |
| |
| // Create a reader, and set it's content handler to be the TransformerHandler. |
| XMLReader reader=null; |
| |
| // Use JAXP1.1 ( if possible ) |
| try { |
| javax.xml.parsers.SAXParserFactory factory= |
| javax.xml.parsers.SAXParserFactory.newInstance(); |
| factory.setNamespaceAware( true ); |
| javax.xml.parsers.SAXParser jaxpParser= |
| factory.newSAXParser(); |
| reader=jaxpParser.getXMLReader(); |
| |
| } catch( javax.xml.parsers.ParserConfigurationException ex ) { |
| throw new org.xml.sax.SAXException( ex ); |
| } catch( javax.xml.parsers.FactoryConfigurationError ex1 ) { |
| throw new org.xml.sax.SAXException( ex1.toString() ); |
| } catch( NoSuchMethodError ex2 ) { |
| } |
| if( reader==null ) reader = getJAXPXMLReader(); |
| reader.setContentHandler(handler); |
| |
| // It's a good idea for the parser to send lexical events. |
| // The TransformerHandler is also a LexicalHandler. |
| reader.setProperty("http://xml.org/sax/properties/lexical-handler", handler); |
| |
| // Parse the source XML, and send the parse events to the TransformerHandler. |
| reporter.logTraceMsg("reader.parse(" + QetestUtils.filenameToURL(sourceID)); |
| reader.parse(QetestUtils.filenameToURL(sourceID)); |
| fos.close(); |
| |
| reporter.logTraceMsg("Note: See SPR SCUU4RZT78 for discussion as to why this output is different than XMLReader/XMLFilter"); |
| fileChecker.check(reporter, new File(outNames.currentName()), |
| new File(goldName), |
| "exampleContentHandlerToContentHandler fileChecker of:" + outNames.currentName()); |
| |
| |
| } |
| catch (Throwable t) |
| { |
| reporter.checkFail("Problem with testCase1:"); |
| reporter.logThrowable(reporter.ERRORMSG, t, "Problem with testCase1"); |
| } |
| reporter.testCaseClose(); |
| return true; |
| } |
| |
| |
| |
| /** |
| * Recreate ExamplesTest.exampleContentHandlerToContentHandler. |
| * |
| * @return false if we should abort the test; true otherwise |
| */ |
| public boolean testCase2() |
| { |
| reporter.testCaseInit("Recreate ExamplesTest.exampleContentHandlerToContentHandler"); |
| |
| String xslID = inputDir |
| + File.separator |
| + "trax" |
| + File.separator |
| + "xsl" |
| + File.separator |
| + "foo.xsl"; |
| String sourceID = inputDir |
| + File.separator |
| + "trax" |
| + File.separator |
| + "xml" |
| + File.separator |
| + "foo.xml"; |
| String goldName = goldDir |
| + File.separator |
| + "trax" |
| + File.separator |
| + "ExamplesTest_18.out"; |
| |
| try |
| { |
| |
| TransformerFactory tfactory = TransformerFactory.newInstance(); |
| |
| // Make sure the transformer factory we obtained supports both |
| // DOM and SAX. |
| if (!(tfactory.getFeature(SAXSource.FEATURE) |
| && tfactory.getFeature(DOMSource.FEATURE))) |
| { |
| reporter.logErrorMsg("exampleContentHandler2DOM:Processor does not support SAX/DOM"); |
| return true; |
| } |
| // We can now safely cast to a SAXTransformerFactory. |
| SAXTransformerFactory sfactory = (SAXTransformerFactory) tfactory; |
| |
| // Create an Document node as the root for the output. |
| DocumentBuilderFactory dfactory |
| = DocumentBuilderFactory.newInstance(); |
| DocumentBuilder docBuilder = dfactory.newDocumentBuilder(); |
| org.w3c.dom.Document outNode = docBuilder.newDocument(); |
| |
| // Create a ContentHandler that can liston to SAX events |
| // and transform the output to DOM nodes. |
| reporter.logTraceMsg("newTransformerHandler(new StreamSource(" + QetestUtils.filenameToURL(xslID)); |
| TransformerHandler handler |
| = sfactory.newTransformerHandler(new StreamSource(QetestUtils.filenameToURL(xslID))); |
| handler.setResult(new DOMResult(outNode)); |
| |
| // Create a reader and set it's ContentHandler to be the |
| // transformer. |
| XMLReader reader=null; |
| |
| // Use JAXP1.1 ( if possible ) |
| try { |
| javax.xml.parsers.SAXParserFactory factory= |
| javax.xml.parsers.SAXParserFactory.newInstance(); |
| factory.setNamespaceAware( true ); |
| javax.xml.parsers.SAXParser jaxpParser= |
| factory.newSAXParser(); |
| reader=jaxpParser.getXMLReader(); |
| |
| } catch( javax.xml.parsers.ParserConfigurationException ex ) { |
| throw new org.xml.sax.SAXException( ex ); |
| } catch( javax.xml.parsers.FactoryConfigurationError ex1 ) { |
| throw new org.xml.sax.SAXException( ex1.toString() ); |
| } catch( NoSuchMethodError ex2 ) { |
| } |
| if( reader==null ) reader= getJAXPXMLReader(); |
| reader.setContentHandler(handler); |
| reader.setProperty("http://xml.org/sax/properties/lexical-handler", |
| handler); |
| |
| // Send the SAX events from the parser to the transformer, |
| // and thus to the DOM tree. |
| reporter.logTraceMsg("reader.parse(" + QetestUtils.filenameToURL(sourceID)); |
| reader.parse(QetestUtils.filenameToURL(sourceID)); |
| |
| // Serialize the node for diagnosis. |
| // This serializes to outNames.nextName() |
| exampleSerializeNode(outNode); |
| |
| fileChecker.check(reporter, new File(outNames.currentName()), |
| new File(goldName), |
| "exampleContentHandler2DOM fileChecker of:" + outNames.currentName()); |
| |
| } |
| catch (Throwable t) |
| { |
| reporter.checkFail("Problem with testCase2:"); |
| reporter.logThrowable(reporter.ERRORMSG, t, "Problem with testCase2"); |
| } |
| reporter.testCaseClose(); |
| return true; |
| } |
| |
| |
| /** |
| * Serialize a node to System.out; |
| * used in ExamplesTest; testCase1, testCase2 above |
| */ |
| public void exampleSerializeNode(Node node) |
| throws TransformerException, TransformerConfigurationException, |
| SAXException, IOException, ParserConfigurationException |
| { |
| TransformerFactory tfactory = TransformerFactory.newInstance(); |
| |
| // This creates a transformer that does a simple identity transform, |
| // and thus can be used for all intents and purposes as a serializer. |
| Transformer serializer = tfactory.newTransformer(); |
| |
| serializer.setOutputProperty(OutputKeys.INDENT, "yes"); |
| serializer.setOutputProperty(OutputKeys.OMIT_XML_DECLARATION, "yes"); |
| serializer.transform(new DOMSource(node), |
| new StreamResult(outNames.nextName())); |
| reporter.logStatusMsg("Test-output-to: new StreamResult(" + outNames.currentName()); |
| // TEST UPDATE - Caller must validate outNames.currentName() |
| } |
| |
| |
| /** |
| * From ErrorListenerTest.java testCase2 |
| * Build a bad stylesheet/do a transform with SAX. |
| * Verify that the ErrorListener is called properly. |
| * Primarily using SAXSources. |
| * @return false if we should abort the test; true otherwise |
| */ |
| public boolean testCase3() |
| { |
| reporter.testCaseInit("Build a bad stylesheet/do a transform with SAX"); |
| XSLTestfileInfo testFileInfo = new XSLTestfileInfo(); |
| testFileInfo.inputName = inputDir |
| + File.separator |
| + "err" |
| + File.separator + "ErrorListenerTest.xsl"; |
| testFileInfo.xmlName = inputDir |
| + File.separator |
| + "err" |
| + File.separator + "ErrorListenerTest.xml"; |
| testFileInfo.goldName = goldDir |
| + File.separator |
| + "err" |
| + File.separator + "ErrorListenerTest.out"; |
| int templatesExpectedType = LoggingErrorListener.TYPE_FATALERROR; |
| String templatesExpectedValue = "decimal-format names must be unique. Name \"myminus\" has been duplicated"; |
| int transformExpectedType = LoggingErrorListener.TYPE_WARNING; |
| String transformExpectedValue = "ExpectedMessage from:list1"; |
| |
| |
| LoggingErrorListener loggingErrorListener = new LoggingErrorListener(reporter); |
| loggingErrorListener.setThrowWhen(LoggingErrorListener.THROW_NEVER); |
| reporter.logTraceMsg("loggingErrorListener originally setup:" + loggingErrorListener.getQuickCounters()); |
| |
| TransformerFactory factory = null; |
| SAXTransformerFactory saxFactory = null; |
| XMLReader reader = null; |
| Templates templates = null; |
| Transformer transformer = null; |
| TransformerHandler handler = null; |
| try |
| { |
| factory = TransformerFactory.newInstance(); |
| saxFactory = (SAXTransformerFactory)factory; // assumes SAXSource.feature! |
| |
| // Set the errorListener and validate it |
| saxFactory.setErrorListener(loggingErrorListener); |
| reporter.check((saxFactory.getErrorListener() == loggingErrorListener), |
| true, "set/getErrorListener on saxFactory"); |
| |
| // Use the JAXP way to get an XMLReader |
| reader = SAXParserFactory.newInstance().newSAXParser().getXMLReader(); |
| InputSource is = new InputSource(QetestUtils.filenameToURL(testFileInfo.inputName)); |
| |
| // Attempt to build templates from known-bad stylesheet |
| // Validate known errors in stylesheet building |
| loggingErrorListener.setExpected(templatesExpectedType, |
| templatesExpectedValue); |
| reporter.logTraceMsg("About to factory.newTransformerHandler(SAX:" + QetestUtils.filenameToURL(testFileInfo.inputName) + ")"); |
| handler = saxFactory.newTransformerHandler(new SAXSource(is)); |
| reporter.logTraceMsg("loggingErrorListener after newTransformerHandler:" + loggingErrorListener.getQuickCounters()); |
| // Clear out any setExpected or counters |
| loggingErrorListener.reset(); |
| reporter.checkPass("set ErrorListener prevented any exceptions in newTransformerHandler()"); |
| |
| // This stylesheet will still work, even though errors |
| // were detected during it's building. Note that |
| // future versions of Xalan or other processors may |
| // not be able to continue here... |
| |
| // Create a result and setup SAX parsing 'tree' |
| Result result = new StreamResult(outNames.nextName()); |
| handler.setResult(result); |
| reader.setContentHandler(handler); |
| |
| LoggingSAXErrorHandler loggingSAXErrorHandler = new LoggingSAXErrorHandler(reporter); |
| loggingSAXErrorHandler.setThrowWhen(LoggingSAXErrorHandler.THROW_NEVER); |
| reporter.logTraceMsg("LoggingSAXErrorHandler originally setup:" + loggingSAXErrorHandler.getQuickCounters()); |
| reader.setErrorHandler(loggingSAXErrorHandler); |
| |
| // Validate the first xsl:message call in the stylesheet |
| loggingErrorListener.setExpected(transformExpectedType, |
| transformExpectedValue); |
| reporter.logInfoMsg("about to parse/transform(" + QetestUtils.filenameToURL(testFileInfo.xmlName) + ")"); |
| reader.parse(QetestUtils.filenameToURL(testFileInfo.xmlName)); |
| reporter.logTraceMsg("LoggingSAXErrorHandler after parse:" + loggingSAXErrorHandler.getQuickCounters()); |
| // Clear out any setExpected or counters |
| loggingErrorListener.reset(); |
| loggingSAXErrorHandler.reset(); |
| |
| // Validate the actual output file as well: in this case, |
| // the stylesheet should still work |
| fileChecker.check(reporter, |
| new File(outNames.currentName()), |
| new File(testFileInfo.goldName), |
| "Bugzilla#4044 SAX transform of error xsl into: " + outNames.currentName()); |
| } |
| catch (Throwable t) |
| { |
| reporter.checkFail("errorListener-SAX unexpectedly threw: " + t.toString()); |
| reporter.logThrowable(Logger.ERRORMSG, t, "errorListener-SAX unexpectedly threw"); |
| } |
| |
| reporter.testCaseClose(); |
| return true; |
| } |
| |
| |
| /** |
| * From ErrorListenerTest.java testCase3 |
| * Build a bad stylesheet/do a transform with DOMs. |
| * Verify that the ErrorListener is called properly. |
| * Primarily using DOMSources. |
| * @return false if we should abort the test; true otherwise |
| */ |
| public boolean testCase4() |
| { |
| reporter.testCaseInit("Build a bad stylesheet/do a transform with DOMs"); |
| XSLTestfileInfo testFileInfo = new XSLTestfileInfo(); |
| testFileInfo.inputName = inputDir |
| + File.separator |
| + "err" |
| + File.separator + "ErrorListenerTest.xsl"; |
| testFileInfo.xmlName = inputDir |
| + File.separator |
| + "err" |
| + File.separator + "ErrorListenerTest.xml"; |
| testFileInfo.goldName = goldDir |
| + File.separator |
| + "err" |
| + File.separator + "ErrorListenerTest.out"; |
| int templatesExpectedType = LoggingErrorListener.TYPE_FATALERROR; |
| String templatesExpectedValue = "decimal-format names must be unique. Name \"myminus\" has been duplicated"; |
| int transformExpectedType = LoggingErrorListener.TYPE_WARNING; |
| String transformExpectedValue = "ExpectedMessage from:list1"; |
| |
| LoggingErrorListener loggingErrorListener = new LoggingErrorListener(reporter); |
| loggingErrorListener.setThrowWhen(LoggingErrorListener.THROW_NEVER); |
| reporter.logTraceMsg("loggingErrorListener originally setup:" + loggingErrorListener.getQuickCounters()); |
| |
| TransformerFactory factory = null; |
| Templates templates = null; |
| Transformer transformer = null; |
| DocumentBuilderFactory dfactory = null; |
| DocumentBuilder docBuilder = null; |
| Node xmlNode = null; |
| Node xslNode = null; |
| try |
| { |
| // Startup a DOM factory, create some nodes/DOMs |
| dfactory = DocumentBuilderFactory.newInstance(); |
| dfactory.setNamespaceAware(true); |
| docBuilder = dfactory.newDocumentBuilder(); |
| reporter.logInfoMsg("parsing xml, xsl files to DOMs"); |
| xslNode = docBuilder.parse(new InputSource(QetestUtils.filenameToURL(testFileInfo.inputName))); |
| xmlNode = docBuilder.parse(new InputSource(QetestUtils.filenameToURL(testFileInfo.xmlName))); |
| |
| // Create a transformer factory with an error listener |
| factory = TransformerFactory.newInstance(); |
| factory.setErrorListener(loggingErrorListener); |
| |
| // Attempt to build templates from known-bad stylesheet |
| // Validate known errors in stylesheet building |
| loggingErrorListener.setExpected(templatesExpectedType, |
| templatesExpectedValue); |
| reporter.logTraceMsg("About to factory.newTemplates(DOM:" + QetestUtils.filenameToURL(testFileInfo.inputName) + ")"); |
| templates = factory.newTemplates(new DOMSource(xslNode)); |
| reporter.logTraceMsg("loggingErrorListener after newTemplates:" + loggingErrorListener.getQuickCounters()); |
| // Clear out any setExpected or counters |
| loggingErrorListener.reset(); |
| reporter.checkPass("set ErrorListener prevented any exceptions in newTemplates()"); |
| |
| // This stylesheet will still work, even though errors |
| // were detected during it's building. Note that |
| // future versions of Xalan or other processors may |
| // not be able to continue here... |
| reporter.logErrorMsg("Bugzilla#1062 throws NPE below at templates.newTransformer()"); |
| transformer = templates.newTransformer(); |
| |
| reporter.logTraceMsg("default transformer's getErrorListener is: " + transformer.getErrorListener()); |
| // Set the errorListener and validate it |
| transformer.setErrorListener(loggingErrorListener); |
| reporter.check((transformer.getErrorListener() == loggingErrorListener), |
| true, "set/getErrorListener on transformer"); |
| |
| // Validate the first xsl:message call in the stylesheet |
| loggingErrorListener.setExpected(transformExpectedType, |
| transformExpectedValue); |
| reporter.logInfoMsg("about to transform(DOM, StreamResult)"); |
| transformer.transform(new DOMSource(xmlNode), |
| new StreamResult(outNames.nextName())); |
| reporter.logTraceMsg("after transform(...)"); |
| // Clear out any setExpected or counters |
| loggingErrorListener.reset(); |
| |
| // Validate the actual output file as well: in this case, |
| // the stylesheet should still work |
| fileChecker.check(reporter, |
| new File(outNames.currentName()), |
| new File(testFileInfo.goldName), |
| "DOM transform of error xsl into: " + outNames.currentName()); |
| |
| } |
| catch (Throwable t) |
| { |
| reporter.checkFail("errorListener-DOM unexpectedly threw: " + t.toString()); |
| reporter.logThrowable(Logger.ERRORMSG, t, "errorListener-DOM unexpectedly threw"); |
| } |
| |
| reporter.testCaseClose(); |
| return true; |
| } |
| |
| |
| /** |
| * From URIResolverTest.java testCase1 |
| * Build a stylesheet/do a transform with lots of URIs to resolve. |
| * Verify that the URIResolver is called properly. |
| * @return false if we should abort the test; true otherwise |
| */ |
| public boolean testCase5() |
| { |
| reporter.testCaseInit("Build a stylesheet/do a transform with lots of URIs to resolve"); |
| |
| XSLTestfileInfo testFileInfo = new XSLTestfileInfo(); |
| testFileInfo.inputName = inputDir + File.separator + "trax" + File.separator + "URIResolverTest.xsl"; |
| testFileInfo.xmlName = inputDir + File.separator + "trax" + File.separator + "URIResolverTest.xml"; |
| testFileInfo.goldName = goldDir + File.separator + "trax" + File.separator + "URIResolverTest.out"; |
| |
| TransformerFactory factory = null; |
| Templates templates = null; |
| Transformer transformer = null; |
| try |
| { |
| factory = TransformerFactory.newInstance(); |
| // Set the URIResolver and validate it |
| reporter.logInfoMsg("About to factory.newTemplates(" + QetestUtils.filenameToURL(testFileInfo.inputName) + ")"); |
| templates = factory.newTemplates(new StreamSource(QetestUtils.filenameToURL(testFileInfo.inputName))); |
| transformer = templates.newTransformer(); |
| |
| // Set the URIResolver and validate it |
| LoggingURIResolver loggingURIResolver = new LoggingURIResolver((Logger)reporter); |
| reporter.logTraceMsg("loggingURIResolver originally setup:" + loggingURIResolver.getQuickCounters()); |
| transformer.setURIResolver(loggingURIResolver); |
| reporter.check((transformer.getURIResolver() == loggingURIResolver), |
| true, "set/getURIResolver on transformer"); |
| |
| // Validate various URI's to be resolved during transform |
| // time with the loggingURIResolver |
| reporter.logWarningMsg("Bugzilla#2425 every document() call is resolved twice twice - two fails caused below"); |
| String[] expectedXmlUris = |
| { |
| "{" + QetestUtils.filenameToURL(testFileInfo.inputName) + "}" + "../impincl/SystemIdImport.xsl", |
| "{" + QetestUtils.filenameToURL(testFileInfo.inputName) + "}" + "impincl/SystemIdImport.xsl", |
| "{" + QetestUtils.filenameToURL(testFileInfo.inputName) + "}" + "systemid/impincl/SystemIdImport.xsl", |
| }; |
| loggingURIResolver.setExpected(expectedXmlUris); |
| reporter.logTraceMsg("about to transform(...)"); |
| transformer.transform(new StreamSource(QetestUtils.filenameToURL(testFileInfo.xmlName)), |
| new StreamResult(outNames.nextName())); |
| reporter.logTraceMsg("after transform(...)"); |
| } |
| catch (Throwable t) |
| { |
| reporter.checkFail("URIResolver test unexpectedly threw: " + t.toString()); |
| reporter.logThrowable(Logger.ERRORMSG, t, "URIResolver test unexpectedly threw"); |
| } |
| |
| reporter.testCaseClose(); |
| return true; |
| } |
| |
| |
| public static final String xslNamespace = "http://www.w3.org/1999/XSL/Transform"; |
| public static final String nsNamespace = "http://www.w3.org/XML/1998/namespace"; |
| /** |
| * From ProgrammaticDOMTest.java testCase2 Bugzilla#5133 |
| * Build a stylesheet DOM programmatically and use it. |
| * |
| * @return false if we should abort the test; true otherwise |
| */ |
| public boolean testCase6() |
| { |
| reporter.testCaseInit("Build a stylesheet DOM programmatically and use it"); |
| |
| XSLTestfileInfo testFileInfo = new XSLTestfileInfo(); |
| testFileInfo.inputName = inputDir + File.separator + "trax" + File.separator + "identity.xsl"; |
| testFileInfo.xmlName = inputDir + File.separator + "trax" + File.separator + "identity.xml"; |
| testFileInfo.goldName = goldDir + File.separator + "trax" + File.separator + "identity.out"; |
| try |
| { |
| // Startup a factory and docbuilder, create some nodes/DOMs |
| DocumentBuilderFactory dfactory = DocumentBuilderFactory.newInstance(); |
| dfactory.setNamespaceAware(true); |
| DocumentBuilder docBuilder = dfactory.newDocumentBuilder(); |
| |
| reporter.logTraceMsg("parsing xml file"); |
| Document xmlDoc = docBuilder.parse(new InputSource(testFileInfo.xmlName)); |
| TransformerFactory factory = TransformerFactory.newInstance(); |
| Transformer transformer = null; |
| |
| // Programmatically build the XSL file into a Document and transform |
| Document xslBuiltDoc = docBuilder.newDocument(); |
| appendIdentityDOMXSL(xslBuiltDoc, xslBuiltDoc, true); |
| // For debugging, write the generated stylesheet out |
| // Note this will not textually exactly match the identity.xsl file |
| reporter.logInfoMsg("Writing out xslBuiltDoc to "+ outNames.nextName()); |
| transformer = factory.newTransformer(); |
| transformer.transform(new DOMSource(xslBuiltDoc), new StreamResult(outNames.currentName())); |
| |
| reporter.logInfoMsg("About to newTransformer(xslBuiltDoc)"); |
| transformer = factory.newTransformer(new DOMSource(xslBuiltDoc)); |
| reporter.logInfoMsg("About to transform(xmlDoc, StreamResult(" + outNames.nextName() + "))"); |
| transformer.transform(new DOMSource(xmlDoc), new StreamResult(outNames.currentName())); |
| fileChecker.check(reporter, |
| new File(outNames.currentName()), |
| new File(testFileInfo.goldName), |
| "transform(xslBuiltDoc,...) into " + outNames.currentName()); |
| |
| |
| // Programmatically build the XSL file into a DocFrag and transform |
| xslBuiltDoc = docBuilder.newDocument(); |
| DocumentFragment xslBuiltDocFrag = xslBuiltDoc.createDocumentFragment(); |
| appendIdentityDOMXSL(xslBuiltDocFrag, xslBuiltDoc, true); |
| // For debugging, write the generated stylesheet out |
| reporter.logInfoMsg("Writing out xslBuiltDocFrag to "+ outNames.nextName()); |
| transformer = factory.newTransformer(); |
| transformer.transform(new DOMSource(xslBuiltDocFrag), new StreamResult(outNames.currentName())); |
| |
| reporter.logCriticalMsg("//@todo Verify that this is even a valid operation!"); |
| reporter.logInfoMsg("About to newTransformer(xslBuiltDocFrag)"); |
| reporter.logCriticalMsg("Bugzilla#5133: will throw NPE"); |
| transformer = factory.newTransformer(new DOMSource(xslBuiltDocFrag)); |
| reporter.logInfoMsg("About to transform(xmlDoc, StreamResult(" + outNames.nextName() + "))"); |
| transformer.transform(new DOMSource(xmlDoc), new StreamResult(outNames.currentName())); |
| fileChecker.check(reporter, |
| new File(outNames.currentName()), |
| new File(testFileInfo.goldName), |
| "transform(xslBuiltDocFrag,...) into " + outNames.currentName()); |
| } |
| catch (Throwable t) |
| { |
| reporter.checkFail("Problem with various XSL1 elems/documents"); |
| reporter.logThrowable(reporter.ERRORMSG, t, "Problem with various XSL1 elems/documents"); |
| } |
| try |
| { |
| // Startup a factory and docbuilder, create some nodes/DOMs |
| DocumentBuilderFactory dfactory = DocumentBuilderFactory.newInstance(); |
| dfactory.setNamespaceAware(true); |
| DocumentBuilder docBuilder = dfactory.newDocumentBuilder(); |
| |
| reporter.logTraceMsg("parsing xml file"); |
| Document xmlDoc = docBuilder.parse(new InputSource(testFileInfo.xmlName)); |
| TransformerFactory factory = TransformerFactory.newInstance(); |
| Transformer transformer = null; |
| |
| // Programmatically build the XSL file into an Element and transform |
| Document xslBuiltDoc = docBuilder.newDocument(); |
| // Note: Here, we implicitly already have the outer list |
| // element, so ensure the worker method doesn't add again |
| reporter.logCriticalMsg("Bugzilla#5133: will throw DOM003 exception"); |
| Element xslBuiltElem = xslBuiltDoc.createElementNS(xslNamespace, "xsl:stylesheet"); |
| xslBuiltElem.setAttributeNS(null, "version", "1.0"); |
| appendIdentityDOMXSL(xslBuiltElem, xslBuiltDoc, false); |
| // For debugging, write the generated stylesheet out |
| reporter.logInfoMsg("Writing out xslBuiltElem to "+ outNames.nextName()); |
| transformer = factory.newTransformer(); |
| transformer.transform(new DOMSource(xslBuiltElem), new StreamResult(outNames.currentName())); |
| |
| reporter.logCriticalMsg("//@todo Verify that this is even a valid operation!"); |
| reporter.logInfoMsg("About to newTransformer(xslBuiltElem)"); |
| transformer = factory.newTransformer(new DOMSource(xslBuiltElem)); |
| reporter.logInfoMsg("About to transform(xmlDoc, StreamResult(" + outNames.nextName() + "))"); |
| transformer.transform(new DOMSource(xmlDoc), new StreamResult(outNames.currentName())); |
| fileChecker.check(reporter, |
| new File(outNames.currentName()), |
| new File(testFileInfo.goldName), |
| "transform(xslBuiltElem,...) into " + outNames.currentName()); |
| } |
| catch (Throwable t) |
| { |
| reporter.checkFail("Problem with various XSL2 elems/documents"); |
| reporter.logThrowable(reporter.ERRORMSG, t, "Problem with various XSL2 elems/documents"); |
| } |
| |
| reporter.testCaseClose(); |
| return true; |
| } |
| |
| /** |
| * Adds identity.xsl elems to Node passed in. |
| * Subject to change; hackish for now |
| * @author curcuru |
| * @param n Node to append DOM elems to |
| * @param factory Document providing createElement, etc. services |
| * @param useOuterElem if we should append the top-level <stylesheet> elem |
| */ |
| public void appendIdentityDOMXSL(Node n, Document factory, boolean useOuterElem) |
| { |
| try |
| { |
| /// <xsl:template match="@*|node()"> |
| Element template = factory.createElementNS(xslNamespace, "xsl:template"); |
| template.setAttributeNS(null, "match", "@*|node()"); |
| |
| /// <xsl:copy> |
| Element copyElem = factory.createElementNS(xslNamespace, "xsl:copy"); |
| |
| /// <xsl:apply-templates select="@*|node()"/> |
| Element applyTemplatesElem = factory.createElementNS(xslNamespace, "xsl:apply-templates"); |
| applyTemplatesElem.setAttributeNS(null, "select", "@*|node()"); |
| |
| // Stick it all together with faked-up newlines for readability |
| copyElem.appendChild(factory.createTextNode("\n ")); |
| copyElem.appendChild(applyTemplatesElem); |
| copyElem.appendChild(factory.createTextNode("\n ")); |
| |
| template.appendChild(factory.createTextNode("\n ")); |
| template.appendChild(copyElem); |
| template.appendChild(factory.createTextNode("\n")); |
| |
| |
| if (useOuterElem) |
| { |
| // If asked to, create and append top-level <stylesheet> elem |
| /// <xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform" version="1.0"> |
| Element stylesheetElem = factory.createElementNS(xslNamespace, "xsl:stylesheet"); |
| stylesheetElem.setAttributeNS(null, "version", "1.0"); |
| |
| // Following is not officially needed by the DOM, but may help |
| // less-sophisticated DOM readers downstream |
| // Removed due to DOM003 Namespace error |
| // stylesheetElem.setAttributeNS(nsNamespace, "xmlns:xsl", xslNamespace); |
| stylesheetElem.appendChild(template); |
| n.appendChild(stylesheetElem); |
| } |
| else |
| { |
| // Otherwise, just use their Node |
| n.appendChild(template); |
| } |
| |
| } |
| catch (Exception e) |
| { |
| reporter.logErrorMsg("appendIdentityDOMXSL threw: " + e.toString()); |
| reporter.logThrowable(Logger.ERRORMSG, e, "appendIdentityDOMXSL threw"); |
| } |
| } |
| |
| /** |
| * Worker method to get an XMLReader. |
| * |
| * Not the most efficient of methods, but makes the code simpler. |
| * |
| * @return a new XMLReader for use, with setNamespaceAware(true) |
| */ |
| protected XMLReader getJAXPXMLReader() |
| throws Exception |
| { |
| // Be sure to use the JAXP methods only! |
| SAXParserFactory factory = SAXParserFactory.newInstance(); |
| factory.setNamespaceAware(true); |
| SAXParser saxParser = factory.newSAXParser(); |
| return saxParser.getXMLReader(); |
| } |
| |
| |
| /** |
| * Convenience method to print out usage information - update if needed. |
| * @return String denoting usage of this test class |
| */ |
| public String usage() |
| { |
| return ("Common [optional] options supported by SmoketestOuttakes:\n" |
| + "(Note: assumes inputDir=.\\tests\\api)\n" |
| + super.usage()); // Grab our parent classes usage as well |
| } |
| |
| |
| /** |
| * Main method to run test from the command line - can be left alone. |
| * @param args command line argument array |
| */ |
| public static void main(String[] args) |
| { |
| SmoketestOuttakes app = new SmoketestOuttakes(); |
| app.doMain(args); |
| } |
| } |
