| /* |
| * 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$ |
| */ |
| |
| /* |
| * |
| * SystemIdImpInclTest.java |
| * |
| */ |
| package org.apache.qetest.trax; |
| |
| import java.io.File; |
| import java.io.FileInputStream; |
| import java.io.FileOutputStream; |
| import java.io.IOException; |
| import java.io.InputStream; |
| import java.io.InputStreamReader; |
| import java.net.URL; |
| import java.net.URLConnection; |
| import java.util.Properties; |
| |
| import javax.xml.parsers.DocumentBuilder; |
| import javax.xml.parsers.DocumentBuilderFactory; |
| import javax.xml.parsers.SAXParser; |
| import javax.xml.parsers.SAXParserFactory; |
| import javax.xml.transform.Result; |
| import javax.xml.transform.Source; |
| import javax.xml.transform.Templates; |
| import javax.xml.transform.Transformer; |
| import javax.xml.transform.TransformerFactory; |
| import javax.xml.transform.dom.DOMSource; |
| import javax.xml.transform.sax.SAXSource; |
| import javax.xml.transform.sax.SAXTransformerFactory; |
| 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.xsl.XSLTestfileInfo; |
| import org.w3c.dom.Node; |
| import org.xml.sax.InputSource; |
| import org.xml.sax.XMLReader; |
| |
| //------------------------------------------------------------------------- |
| |
| /** |
| * Test behavior of imports/includes with various setSystemId sources. |
| * <b>Note:</b> This test is directory-dependent, so if there are |
| * any fails, check the code to see what the test file is expecting |
| * the path/directory/etc. to be. |
| * //@todo More variations on kinds of systemIds: file: id's that |
| * are absolute, etc.; any/all other forms of id's like http: |
| * (which will require network resources available). |
| * |
| * @author shane_curcuru@lotus.com |
| * @version $Id$ |
| */ |
| public class SystemIdImpInclTest extends FileBasedTest |
| { |
| |
| /** |
| * Provides nextName(), currentName() functionality for tests |
| * that may produce any number of output files. |
| */ |
| protected OutputNameManager outNames; |
| |
| /** |
| * Name of a valid, known-good xsl/xml file pair we can use. |
| */ |
| protected XSLTestfileInfo testFileInfo = new XSLTestfileInfo(); |
| |
| /** |
| * Just basename of a valid, known-good file, both .xsl/.xml . |
| */ |
| protected String knownGoodBaseName = null; |
| |
| /** Gold filename for level0, i.e. one directory above the testfile. */ |
| protected String goldFileLevel0 = "SystemIdImpInclLevel0.out"; |
| |
| /** Gold filename for level1, i.e. the directory of the testfile. */ |
| protected String goldFileLevel1 = "SystemIdImpInclLevel1.out"; |
| |
| /** Gold filename for level2, i.e. a directory below the testfile. */ |
| protected String goldFileLevel2 = "SystemIdImpInclLevel2.out"; |
| |
| /** Gold filename for http, i.e. a from a webserver. */ |
| protected String goldFileHttp = "SystemIdImpInclHttp.out"; |
| |
| /** Subdirectory under test\tests\api for our xsl/xml files. */ |
| public static final String TRAX_SUBDIR = "trax"; |
| |
| /** Convenience variable for user.dir - cached during test. */ |
| protected String savedUserDir = null; |
| |
| /** Just initialize test name, comment, numTestCases. */ |
| public SystemIdImpInclTest() |
| { |
| numTestCases = 3; // Set numTestCases to 3 to skip the 4th one that does http: |
| testName = "SystemIdImpInclTest"; |
| testComment = "Test behavior of imports/includes with various setSystemId sources"; |
| } |
| |
| |
| /** |
| * Initialize this test - Set names of xml/xsl test files, |
| * cache user.dir property. |
| * |
| * @param p Properties to initialize from (unused) |
| * @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_SUBDIR); |
| 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_SUBDIR |
| + File.separator + testName, ".out"); |
| |
| String testBasePath = inputDir |
| + File.separator |
| + TRAX_SUBDIR |
| + File.separator; |
| String goldBasePath = goldDir |
| + File.separator |
| + TRAX_SUBDIR |
| + File.separator; |
| |
| // Just bare pathnames, not URI's |
| knownGoodBaseName = "SystemIdImpIncl"; |
| testFileInfo.inputName = testBasePath + knownGoodBaseName + ".xsl"; |
| testFileInfo.xmlName = testBasePath + knownGoodBaseName + ".xml"; |
| testFileInfo.goldName = goldBasePath + knownGoodBaseName + ".out"; |
| goldFileLevel0 = goldBasePath + goldFileLevel0; // just prepend path |
| goldFileLevel1 = goldBasePath + goldFileLevel1; // just prepend path |
| goldFileLevel2 = goldBasePath + goldFileLevel2; // just prepend path |
| goldFileHttp = goldBasePath + goldFileHttp; // just prepend path |
| |
| // Cache user.dir property |
| savedUserDir = System.getProperty("user.dir"); |
| reporter.logHashtable(Logger.STATUSMSG, System.getProperties(), "System.getProperties()"); |
| reporter.logHashtable(Logger.STATUSMSG, testProps, "testProps"); |
| |
| return true; |
| } |
| |
| |
| /** |
| * Cleanup this test - uncache user.dir property. |
| * |
| * @param p Properties to initialize from (if needed) |
| * @return false if we should abort the test; true otherwise |
| */ |
| public boolean doTestFileClose(Properties p) |
| { |
| // Uncache user.dir property |
| System.getProperties().put("user.dir", savedUserDir); |
| return true; |
| } |
| |
| |
| /** |
| * Simple StreamSources with different setSystemIds. |
| * |
| * @return false if we should abort the test; true otherwise |
| */ |
| public boolean testCase1() |
| { |
| reporter.testCaseInit("Simple StreamSources with different setSystemIds"); |
| |
| TransformerFactory factory = null; |
| try |
| { |
| factory = TransformerFactory.newInstance(); |
| } |
| catch (Throwable t) |
| { |
| reporter.checkFail("Problem creating factory; can't continue testcase"); |
| reporter.logThrowable(reporter.ERRORMSG, t, |
| "Problem creating factory; can't continue testcase"); |
| return true; |
| } |
| try |
| { |
| // Verify we can do basic transforms with readers/streams, |
| // with the 'normal' systemId |
| reporter.logInfoMsg("StreamSource.setSystemId(level1)"); |
| InputStream xslStream1 = new FileInputStream(testFileInfo.inputName); |
| Source xslSource1 = new StreamSource(xslStream1); |
| xslSource1.setSystemId(QetestUtils.filenameToURL(testFileInfo.inputName)); |
| |
| InputStream xmlStream1 = new FileInputStream(testFileInfo.xmlName); |
| Source xmlSource1 = new StreamSource(xmlStream1); |
| xmlSource1.setSystemId(QetestUtils.filenameToURL(testFileInfo.xmlName)); |
| |
| reporter.logTraceMsg("Create FileOutputStream to " + outNames.nextName()); |
| FileOutputStream fos1 = new FileOutputStream(outNames.currentName()); |
| Result result1 = new StreamResult(fos1); |
| |
| Templates templates1 = factory.newTemplates(xslSource1); |
| Transformer transformer1 = templates1.newTransformer(); |
| reporter.logInfoMsg("About to transform, systemId(level1)"); |
| transformer1.transform(xmlSource1, result1); |
| fos1.close(); // must close ostreams we own |
| if (Logger.PASS_RESULT |
| != fileChecker.check(reporter, |
| new File(outNames.currentName()), |
| new File(goldFileLevel1), |
| "transform after setSystemId(level1) into " + outNames.currentName()) |
| ) |
| reporter.logInfoMsg("transform after setSystemId(level1)... failure reason:" + fileChecker.getExtendedInfo()); |
| } |
| catch (Throwable t) |
| { |
| reporter.checkFail("Problem with setSystemId(level1)"); |
| reporter.logThrowable(reporter.ERRORMSG, t, "Problem with after setSystemId(level1)"); |
| } |
| |
| try |
| { |
| // Verify we can do basic transforms with readers/streams, |
| // systemId set up one level |
| reporter.logInfoMsg("StreamSource.setSystemId(level0)"); |
| InputStream xslStream1 = new FileInputStream(testFileInfo.inputName); |
| Source xslSource1 = new StreamSource(xslStream1); |
| xslSource1.setSystemId(QetestUtils.filenameToURL(inputDir + File.separator + knownGoodBaseName + ".xsl")); |
| |
| InputStream xmlStream1 = new FileInputStream(testFileInfo.xmlName); |
| Source xmlSource1 = new StreamSource(xmlStream1); |
| xmlSource1.setSystemId(QetestUtils.filenameToURL(inputDir + File.separator + knownGoodBaseName + ".xml")); |
| |
| reporter.logTraceMsg("Create FileOutputStream to " + outNames.nextName()); |
| FileOutputStream fos1 = new FileOutputStream(outNames.currentName()); |
| Result result1 = new StreamResult(fos1); |
| |
| Templates templates1 = factory.newTemplates(xslSource1); |
| Transformer transformer1 = templates1.newTransformer(); |
| reporter.logInfoMsg("About to transform, systemId(level0)"); |
| transformer1.transform(xmlSource1, result1); |
| fos1.close(); // must close ostreams we own |
| if (Logger.PASS_RESULT |
| != fileChecker.check(reporter, |
| new File(outNames.currentName()), |
| new File(goldFileLevel0), |
| "transform after setSystemId(level0) into " + outNames.currentName()) |
| ) |
| reporter.logInfoMsg("transform after setSystemId(level0)... failure reason:" + fileChecker.getExtendedInfo()); |
| } |
| catch (Throwable t) |
| { |
| reporter.checkFail("Problem with setSystemId(level0)"); |
| reporter.logThrowable(reporter.ERRORMSG, t, "Problem with setSystemId(level0)"); |
| } |
| |
| try |
| { |
| // Verify we can do basic transforms with readers/streams, |
| // with the systemId down one level |
| reporter.logInfoMsg("StreamSource.setSystemId(level2)"); |
| InputStream xslStream1 = new FileInputStream(testFileInfo.inputName); |
| Source xslSource1 = new StreamSource(xslStream1); |
| xslSource1.setSystemId(QetestUtils.filenameToURL(inputDir + "/trax/systemid/" + knownGoodBaseName + ".xsl")); |
| |
| InputStream xmlStream1 = new FileInputStream(testFileInfo.xmlName); |
| Source xmlSource1 = new StreamSource(xmlStream1); |
| xmlSource1.setSystemId(QetestUtils.filenameToURL(inputDir + "/trax/systemid/" + knownGoodBaseName + ".xml")); |
| |
| reporter.logTraceMsg("Create FileOutputStream to " + outNames.nextName()); |
| FileOutputStream fos1 = new FileOutputStream(outNames.currentName()); |
| Result result1 = new StreamResult(fos1); |
| |
| Templates templates1 = factory.newTemplates(xslSource1); |
| Transformer transformer1 = templates1.newTransformer(); |
| reporter.logInfoMsg("About to transform, systemId(level2)"); |
| transformer1.transform(xmlSource1, result1); |
| fos1.close(); // must close ostreams we own |
| if (Logger.PASS_RESULT |
| != fileChecker.check(reporter, |
| new File(outNames.currentName()), |
| new File(goldFileLevel2), |
| "transform after setSystemId(level2) into " + outNames.currentName()) |
| ) |
| reporter.logInfoMsg("transform after setSystemId(level2)... failure reason:" + fileChecker.getExtendedInfo()); |
| } |
| catch (Throwable t) |
| { |
| reporter.checkFail("Problem with setSystemId(level2)"); |
| reporter.logThrowable(reporter.ERRORMSG, t, "Problem with setSystemId(level2)"); |
| } |
| |
| try |
| { |
| // Verify we can do basic transforms with readers/streams, |
| // with the systemId down one level |
| reporter.logInfoMsg("StreamSource.setSystemId(xslonly level2)"); |
| InputStream xslStream1 = new FileInputStream(testFileInfo.inputName); |
| Source xslSource1 = new StreamSource(xslStream1); |
| xslSource1.setSystemId(QetestUtils.filenameToURL(inputDir + "/trax/systemid/" + knownGoodBaseName + ".xsl")); |
| |
| InputStream xmlStream1 = new FileInputStream(testFileInfo.xmlName); |
| Source xmlSource1 = new StreamSource(xmlStream1); |
| // Explicitly don't set the xmlId - shouldn't be needed |
| |
| reporter.logTraceMsg("Create FileOutputStream to " + outNames.nextName()); |
| FileOutputStream fos1 = new FileOutputStream(outNames.currentName()); |
| Result result1 = new StreamResult(fos1); |
| |
| Templates templates1 = factory.newTemplates(xslSource1); |
| Transformer transformer1 = templates1.newTransformer(); |
| reporter.logInfoMsg("About to transform, systemId(xslonly level2)"); |
| transformer1.transform(xmlSource1, result1); |
| fos1.close(); // must close ostreams we own |
| if (Logger.PASS_RESULT |
| != fileChecker.check(reporter, |
| new File(outNames.currentName()), |
| new File(goldFileLevel2), |
| "transform after setSystemId(xslonly level2) into " + outNames.currentName()) |
| ) |
| reporter.logInfoMsg("transform after setSystemId(xslonly level2)... failure reason:" + fileChecker.getExtendedInfo()); |
| } |
| catch (Throwable t) |
| { |
| reporter.checkFail("Problem with setSystemId(xslonly level2)"); |
| reporter.logThrowable(reporter.ERRORMSG, t, "Problem with setSystemId(xslonly level2)"); |
| } |
| reporter.testCaseClose(); |
| return true; |
| } |
| |
| /** |
| * Verify simple SAXSources with systemIds. |
| * |
| * @return false if we should abort the test; true otherwise |
| */ |
| public boolean testCase2() |
| { |
| reporter.testCaseInit("Verify simple SAXSources with systemIds"); |
| |
| TransformerFactory factory = null; |
| SAXTransformerFactory saxFactory = null; |
| InputSource xslInpSrc = null; |
| Source xslSource = null; |
| Source xmlSource = null; |
| try |
| { |
| factory = TransformerFactory.newInstance(); |
| saxFactory = (SAXTransformerFactory)factory; |
| } |
| catch (Throwable t) |
| { |
| reporter.checkFail("Problem creating factory; can't continue testcase"); |
| reporter.logThrowable(reporter.ERRORMSG, t, |
| "Problem creating factory; can't continue testcase"); |
| return true; |
| } |
| try |
| { |
| // Verify basic transforms with with various systemId |
| // and a SAXSource(InputSource(String)) |
| // level0: one level up |
| /******************************** |
| // SAXSource(impSrc(str)) level0, level2 |
| // Note: these cases may not be valid to test, since the setSystemId |
| // call will effectively overwrite the underlying InputSource's |
| // real systemId, and thus the stylesheet can't be built |
| // Answer: write a custom test case that parses the stylesheet |
| // and builds it, but doesn't get imports/includes until later |
| // when we have setSystemId |
| xslInpSrc = new InputSource(new InputStreamReader(new FileInputStream(testFileInfo.inputName), "UTF-8")); //@DEM |
| // xslInpSrc = new InputSource(new FileReader(testFileInfo.inputName)); @DEM |
| xslSource = new SAXSource(xslInpSrc); |
| |
| xmlSource = new StreamSource(new FileInputStream(testFileInfo.xmlName)); |
| xmlSource.setSystemId(QetestUtils.filenameToURL(testFileInfo.xmlName)); |
| |
| checkSourceWithSystemId(xslSource, QetestUtils.filenameToURL(inputDir + File.separator + knownGoodBaseName + ".xsl"), |
| xmlSource, goldFileLevel0, |
| "SAXSource(inpSrc(str)).systemId(level0: one up)"); |
| ********************************/ |
| // level1: same systemId as actual file |
| // @DEM changes are to allow test to run on various |
| // platforms regardeless of encodings; force it to |
| // be UTF-8 since that's what's checked in |
| xslInpSrc = new InputSource(new InputStreamReader(new FileInputStream(testFileInfo.inputName), "UTF-8")); //@DEM |
| // xslInpSrc = new InputSource(new FileReader(testFileInfo.inputName)); @DEM |
| xslSource = new SAXSource(xslInpSrc); |
| |
| xmlSource = new StreamSource(new FileInputStream(testFileInfo.xmlName)); |
| xmlSource.setSystemId(QetestUtils.filenameToURL(testFileInfo.xmlName)); |
| |
| checkSourceWithSystemId(xslSource, QetestUtils.filenameToURL(testFileInfo.inputName), |
| xmlSource, goldFileLevel1, |
| "SAXSource(inpSrc(str)).systemId(level1: same level)"); |
| |
| // level2: one level down |
| /******************************** |
| // SAXSource(impSrc(str)) level0, level2 |
| // Note: these cases may not be valid to test, since the setSystemId |
| // call will effectively overwrite the underlying InputSource's |
| // real systemId, and thus the stylesheet can't be built |
| // Answer: write a custom test case that parses the stylesheet |
| // and builds it, but doesn't get imports/includes until later |
| // when we have setSystemId |
| xslInpSrc = new InputSource(new InputStreamReader(new FileInputStream(testFileInfo.inputName), "UTF-8")); //@DEM |
| // xslInpSrc = new InputSource(new FileReader(testFileInfo.inputName)); @DEM |
| xslSource = new SAXSource(xslInpSrc); |
| |
| xmlSource = new StreamSource(new FileInputStream(testFileInfo.xmlName)); |
| xmlSource.setSystemId(QetestUtils.filenameToURL(testFileInfo.xmlName)); |
| |
| checkSourceWithSystemId(xslSource, QetestUtils.filenameToURL(inputDir + "/trax/systemid/" + knownGoodBaseName + ".xsl"), |
| xmlSource, goldFileLevel2, |
| "SAXSource(inpSrc(str)).systemId(level2: one down)"); |
| ********************************/ |
| reporter.logTraceMsg("@todo: add test for SAXSource with reset systemId (see code comments)"); |
| } |
| catch (Throwable t) |
| { |
| reporter.checkFail("Problem with SAXSources(1)"); |
| reporter.logThrowable(reporter.ERRORMSG, t, "Problem with SAXSources(1)"); |
| } |
| try |
| { |
| // Verify basic transforms with with various systemId |
| // and a SAXSource(InputSource(InputStream)) |
| // level0: one level up |
| xslInpSrc = new InputSource(new FileInputStream(testFileInfo.inputName)); |
| xslSource = new SAXSource(xslInpSrc); |
| |
| xmlSource = new StreamSource(new FileInputStream(testFileInfo.xmlName)); |
| xmlSource.setSystemId(QetestUtils.filenameToURL(testFileInfo.xmlName)); |
| |
| checkSourceWithSystemId(xslSource, QetestUtils.filenameToURL(inputDir + File.separator + knownGoodBaseName + ".xsl"), |
| xmlSource, goldFileLevel0, |
| "SAXSource(inpSrc(byteS)).systemId(level0: one up)"); |
| |
| // level1: same systemId as actual file |
| xslInpSrc = new InputSource(new FileInputStream(testFileInfo.inputName)); |
| xslSource = new SAXSource(xslInpSrc); |
| |
| xmlSource = new StreamSource(new FileInputStream(testFileInfo.xmlName)); |
| xmlSource.setSystemId(QetestUtils.filenameToURL(testFileInfo.xmlName)); |
| |
| checkSourceWithSystemId(xslSource, QetestUtils.filenameToURL(testFileInfo.inputName), |
| xmlSource, goldFileLevel1, |
| "SAXSource(inpSrc(byteS)).systemId(level1: same level)"); |
| |
| // level2: one level down |
| xslInpSrc = new InputSource(new FileInputStream(testFileInfo.inputName)); |
| xslSource = new SAXSource(xslInpSrc); |
| |
| xmlSource = new StreamSource(new FileInputStream(testFileInfo.xmlName)); |
| xmlSource.setSystemId(QetestUtils.filenameToURL(testFileInfo.xmlName)); |
| |
| checkSourceWithSystemId(xslSource, QetestUtils.filenameToURL(inputDir + "/trax/systemid/" + knownGoodBaseName + ".xsl"), |
| xmlSource, goldFileLevel2, |
| "SAXSource(inpSrc(byteS)).systemId(level2: one down)"); |
| |
| // Verify basic transforms with with various systemId |
| // and a SAXSource(InputSource(Reader)) |
| // level0: one level up |
| xslInpSrc = new InputSource(new InputStreamReader(new FileInputStream(testFileInfo.inputName), "UTF-8")); //@DEM |
| // xslInpSrc = new InputSource(new FileReader(testFileInfo.inputName)); @DEM |
| xslSource = new SAXSource(xslInpSrc); |
| |
| xmlSource = new StreamSource(new FileInputStream(testFileInfo.xmlName)); |
| xmlSource.setSystemId(QetestUtils.filenameToURL(testFileInfo.xmlName)); |
| |
| checkSourceWithSystemId(xslSource, QetestUtils.filenameToURL(inputDir + File.separator + knownGoodBaseName + ".xsl"), |
| xmlSource, goldFileLevel0, |
| "SAXSource(inpSrc(charS)).systemId(level0: one up)"); |
| |
| // level1: same systemId as actual file |
| xslInpSrc = new InputSource(new InputStreamReader(new FileInputStream(testFileInfo.inputName), "UTF-8")); //@DEM |
| // xslInpSrc = new InputSource(new FileReader(testFileInfo.inputName)); @DEM |
| xslSource = new SAXSource(xslInpSrc); |
| |
| xmlSource = new StreamSource(new FileInputStream(testFileInfo.xmlName)); |
| xmlSource.setSystemId(QetestUtils.filenameToURL(testFileInfo.xmlName)); |
| |
| checkSourceWithSystemId(xslSource, QetestUtils.filenameToURL(testFileInfo.inputName), |
| xmlSource, goldFileLevel1, |
| "SAXSource(inpSrc(charS)).systemId(level1: same level)"); |
| |
| // level2: one level down |
| xslInpSrc = new InputSource(new InputStreamReader(new FileInputStream(testFileInfo.inputName), "UTF-8")); //@DEM |
| // xslInpSrc = new InputSource(new FileReader(testFileInfo.inputName)); @DEM |
| xslSource = new SAXSource(xslInpSrc); |
| |
| xmlSource = new StreamSource(new FileInputStream(testFileInfo.xmlName)); |
| xmlSource.setSystemId(QetestUtils.filenameToURL(testFileInfo.xmlName)); |
| |
| checkSourceWithSystemId(xslSource, QetestUtils.filenameToURL(inputDir + "/trax/systemid/" + knownGoodBaseName + ".xsl"), |
| xmlSource, goldFileLevel2, |
| "SAXSource(inpSrc(charS)).systemId(level2: one down)"); |
| |
| // Verify basic transforms with with various systemId |
| // and a SAXSource(XMLReader, InputSource(various)) |
| // Be sure to use the JAXP methods only! |
| SAXParserFactory spfactory = SAXParserFactory.newInstance(); |
| spfactory.setNamespaceAware(true); |
| SAXParser saxParser = spfactory.newSAXParser(); |
| XMLReader reader = saxParser.getXMLReader(); |
| // level0: one level up, with a character stream |
| xslInpSrc = new InputSource(new InputStreamReader(new FileInputStream(testFileInfo.inputName), "UTF-8")); //@DEM |
| // xslInpSrc = new InputSource(new FileReader(testFileInfo.inputName)); @DEM |
| xslSource = new SAXSource(reader, xslInpSrc); |
| |
| xmlSource = new StreamSource(new FileInputStream(testFileInfo.xmlName)); |
| xmlSource.setSystemId(QetestUtils.filenameToURL(testFileInfo.xmlName)); |
| |
| checkSourceWithSystemId(xslSource, QetestUtils.filenameToURL(inputDir + File.separator + knownGoodBaseName + ".xsl"), |
| xmlSource, goldFileLevel0, |
| "SAXSource(reader, inpSrc(charS)).systemId(level0: one up)"); |
| |
| // level1: same systemId as actual file, with a systemId |
| saxParser = spfactory.newSAXParser(); |
| reader = saxParser.getXMLReader(); |
| xslInpSrc = new InputSource(testFileInfo.inputName); |
| xslSource = new SAXSource(reader, xslInpSrc); |
| |
| xmlSource = new StreamSource(new FileInputStream(testFileInfo.xmlName)); |
| xmlSource.setSystemId(QetestUtils.filenameToURL(testFileInfo.xmlName)); |
| |
| checkSourceWithSystemId(xslSource, QetestUtils.filenameToURL(testFileInfo.inputName), |
| xmlSource, goldFileLevel1, |
| "SAXSource(reader, inpSrc(str)).systemId(level1: same level)"); |
| |
| // level2: one level down, with a byte stream |
| saxParser = spfactory.newSAXParser(); |
| reader = saxParser.getXMLReader(); |
| xslInpSrc = new InputSource(new FileInputStream(testFileInfo.inputName)); |
| xslSource = new SAXSource(reader, xslInpSrc); |
| |
| xmlSource = new StreamSource(new FileInputStream(testFileInfo.xmlName)); |
| xmlSource.setSystemId(QetestUtils.filenameToURL(testFileInfo.xmlName)); |
| |
| checkSourceWithSystemId(xslSource, QetestUtils.filenameToURL(inputDir + "/trax/systemid/" + knownGoodBaseName + ".xsl"), |
| xmlSource, goldFileLevel2, |
| "SAXSource(reader, inpSrc(byteS)).systemId(level2: one down)"); |
| } |
| catch (Throwable t) |
| { |
| reporter.checkFail("Problem with SAXSources(2)"); |
| reporter.logThrowable(reporter.ERRORMSG, t, "Problem with SAXSources(2)"); |
| } |
| |
| reporter.testCaseClose(); |
| return true; |
| } |
| |
| /** |
| * Verify simple DOMSources with systemIds. |
| * |
| * @return false if we should abort the test; true otherwise |
| */ |
| public boolean testCase3() |
| { |
| reporter.testCaseInit("Verify simple DOMSources with systemIds"); |
| TransformerFactory factory = null; |
| DocumentBuilderFactory dfactory = null; |
| DocumentBuilder docBuilder = null; |
| Node xslNode = null; |
| Source xslSource = null; |
| Source xmlSource = null; |
| |
| try |
| { |
| factory = TransformerFactory.newInstance(); |
| dfactory = DocumentBuilderFactory.newInstance(); |
| dfactory.setNamespaceAware(true); |
| } |
| catch (Throwable t) |
| { |
| reporter.checkFail("Problem creating factory; can't continue testcase"); |
| reporter.logThrowable(reporter.ERRORMSG, t, |
| "Problem creating factory; can't continue testcase"); |
| return true; |
| } |
| try |
| { |
| docBuilder = dfactory.newDocumentBuilder(); |
| |
| // Verify basic transforms with with various systemId |
| // and a DOMSource(InputSource(String)) |
| // level0: one level up |
| reporter.logTraceMsg("about to parse(InputSource(" + QetestUtils.filenameToURL(testFileInfo.inputName) + "))"); |
| xslNode = docBuilder.parse(new InputSource(QetestUtils.filenameToURL(testFileInfo.inputName))); |
| xslSource = new DOMSource(xslNode); |
| |
| xmlSource = new StreamSource(new FileInputStream(testFileInfo.xmlName)); |
| xmlSource.setSystemId(QetestUtils.filenameToURL(testFileInfo.xmlName)); |
| |
| checkSourceWithSystemId(xslSource, QetestUtils.filenameToURL(inputDir + File.separator + knownGoodBaseName + ".xsl"), |
| xmlSource, goldFileLevel0, |
| "DOMSource(inpSrc(str)).systemId(level0: one up)"); |
| |
| // level1: same systemId as actual file |
| reporter.logTraceMsg("about to parse(InputSource(" + QetestUtils.filenameToURL(testFileInfo.inputName) + "))"); |
| xslNode = docBuilder.parse(new InputSource(QetestUtils.filenameToURL(testFileInfo.inputName))); |
| xslSource = new DOMSource(xslNode); |
| |
| xmlSource = new StreamSource(new FileInputStream(testFileInfo.xmlName)); |
| xmlSource.setSystemId(QetestUtils.filenameToURL(testFileInfo.xmlName)); |
| |
| checkSourceWithSystemId(xslSource, QetestUtils.filenameToURL(testFileInfo.inputName), |
| xmlSource, goldFileLevel1, |
| "DOMSource(inpSrc(str)).systemId(level1: same level)"); |
| |
| // level2: one level down |
| reporter.logTraceMsg("about to parse(InputSource(" + QetestUtils.filenameToURL(testFileInfo.inputName) + "))"); |
| xslNode = docBuilder.parse(new InputSource(QetestUtils.filenameToURL(testFileInfo.inputName))); |
| xslSource = new DOMSource(xslNode); |
| |
| xmlSource = new StreamSource(new FileInputStream(testFileInfo.xmlName)); |
| xmlSource.setSystemId(QetestUtils.filenameToURL(testFileInfo.xmlName)); |
| |
| checkSourceWithSystemId(xslSource, QetestUtils.filenameToURL(inputDir + "/trax/systemid/" + knownGoodBaseName + ".xsl"), |
| xmlSource, goldFileLevel2, |
| "DOMSource(inpSrc(str)).systemId(level2: one down)"); |
| |
| // Sample extra test: DOMSource that had systemId set |
| // differently in the constructor - tests that you can |
| // later call setSystemId and have it work |
| // level0: one level up |
| reporter.logTraceMsg("about to parse(InputSource(" + QetestUtils.filenameToURL(testFileInfo.inputName) + "))"); |
| xslNode = docBuilder.parse(new InputSource(QetestUtils.filenameToURL(testFileInfo.inputName))); |
| // Set the original systemId to itself, or level1 |
| xslSource = new DOMSource(xslNode, QetestUtils.filenameToURL(testFileInfo.inputName)); |
| |
| xmlSource = new StreamSource(new FileInputStream(testFileInfo.xmlName)); |
| xmlSource.setSystemId(QetestUtils.filenameToURL(testFileInfo.xmlName)); |
| |
| // Test it with a level0, or one level up systemId |
| checkSourceWithSystemId(xslSource, QetestUtils.filenameToURL(inputDir + File.separator + knownGoodBaseName + ".xsl"), |
| xmlSource, goldFileLevel0, |
| "DOMSource(inpSrc(str),sysId-level1).systemId(level0: one up)"); |
| } |
| catch (Throwable t) |
| { |
| reporter.checkFail("Problem with DOMSources(1)"); |
| reporter.logThrowable(reporter.ERRORMSG, t, "Problem with DOMSources(1)"); |
| } |
| |
| |
| |
| reporter.testCaseClose(); |
| return true; |
| } |
| |
| |
| /** |
| * Verify various simple Sources with http: systemIds. |
| * Test may be commented out until we have a better way to |
| * maintain and check for existence and correct content of |
| * stylesheets on the http server. |
| * |
| * @return false if we should abort the test; true otherwise |
| */ |
| public boolean testCase4() |
| { |
| reporter.testCaseInit("Verify various simple Sources with http: systemIds"); |
| |
| // This is the name of a directory on the apache server |
| // that has impincl\SystemIdInclude.xsl and |
| // impincl\SystemIdImport.xsl files on it - obviously, |
| // your JVM must have access to this server to successfully |
| // run this portion of the test! |
| String httpSystemIdBase = "http://xml.apache.org/xalan-j/test"; |
| |
| // Verify http connectivity |
| // If your JVM environment can't connect to the http: |
| // server, then we can't complete the test |
| // This could happen due to various network problems, |
| // not being connected, firewalls, etc. |
| try |
| { |
| reporter.logInfoMsg("verifing http connectivity before continuing testCase"); |
| // Note hard-coded path to one of the two files we'll be relying on |
| URL testURL = new URL(httpSystemIdBase + "/impincl/SystemIdInclude.xsl"); |
| URLConnection urlConnection = testURL.openConnection(); |
| // Ensure we don't get a cached copy |
| urlConnection.setUseCaches(false); |
| // Ensure we don't get asked interactive questions |
| urlConnection.setAllowUserInteraction(false); |
| // Actually connect to the document; will throw |
| // IOException if anything goes wrong |
| urlConnection.connect(); |
| // Convenience: log out when the doc was last modified |
| reporter.logInfoMsg(testURL.toString() + " last modified: " |
| + urlConnection.getLastModified()); |
| int contentLen = urlConnection.getContentLength(); |
| reporter.logStatusMsg("URL.getContentLength() was: " + contentLen); |
| if (contentLen < 1) |
| { |
| // if no content, throw 'fake' exception to |
| // short-circut test case |
| throw new IOException("URL.getContentLength() was: " + contentLen); |
| } |
| // Also verify that the file there contains (some of) the data we expect! |
| reporter.logTraceMsg("calling urlConnection.getContent()..."); |
| Object content = urlConnection.getContent(); |
| if (null == content) |
| { |
| // if no content, throw 'fake' exception to |
| // short-circut test case |
| throw new IOException("URL.getContent() was null!"); |
| } |
| reporter.logTraceMsg("getContent().toString() is now: " + content.toString()); |
| |
| //@todo we should also verify some key strings in the |
| // expected .xsl file here, if possible |
| } |
| catch (IOException ioe) |
| { |
| reporter.logThrowable(Logger.ERRORMSG, ioe, "Can't connect threw"); |
| reporter.logErrorMsg("Can't connect to: " + httpSystemIdBase |
| + "/impincl/SystemIdInclude.xsl, skipping testcase"); |
| reporter.checkPass("FAKE PASS RECORD; testCase was skipped"); |
| // Skip the rest of the testcase |
| reporter.testCaseClose(); |
| return true; |
| } |
| |
| |
| TransformerFactory factory = null; |
| Source xslSource = null; |
| Source xmlSource = null; |
| |
| try |
| { |
| factory = TransformerFactory.newInstance(); |
| } |
| catch (Throwable t) |
| { |
| reporter.checkFail("Problem creating factory; can't continue testcase"); |
| reporter.logThrowable(reporter.ERRORMSG, t, |
| "Problem creating factory; can't continue testcase"); |
| return true; |
| } |
| try |
| { |
| // Verify StreamSource from local disk with a |
| // http: systemId for imports/includes |
| xslSource = new StreamSource(new FileInputStream(testFileInfo.inputName)); |
| |
| xmlSource = new StreamSource(new FileInputStream(testFileInfo.xmlName)); |
| xmlSource.setSystemId(QetestUtils.filenameToURL(testFileInfo.xmlName)); |
| |
| // Note that the systemId set (the second argument below) |
| // must be the path to the proper 'directory' level |
| // on the webserver: setting it to just ".../test" |
| // will fail, since it be considered a file of that |
| // name, not the directory |
| checkSourceWithSystemId(xslSource, httpSystemIdBase + "/", |
| xmlSource, goldFileHttp, |
| "StreamSource().systemId(http:)"); |
| |
| xslSource = new StreamSource(new FileInputStream(testFileInfo.inputName)); |
| |
| xmlSource = new StreamSource(new FileInputStream(testFileInfo.xmlName)); |
| xmlSource.setSystemId(QetestUtils.filenameToURL(testFileInfo.xmlName)); |
| |
| checkSourceWithSystemId(xslSource, httpSystemIdBase + "/" + knownGoodBaseName + ".xsl", |
| xmlSource, goldFileHttp, |
| "StreamSource().systemId(http:)"); |
| } |
| catch (Throwable t) |
| { |
| reporter.checkFail("Problem with http systemIds(1)"); |
| reporter.logThrowable(reporter.ERRORMSG, t, "Problem with http systemIds(1)"); |
| } |
| |
| reporter.testCaseClose(); |
| return true; |
| } |
| |
| |
| /** |
| * Worker method to test setting SystemId and doing transform. |
| * Simply does:<pre> |
| * xslSrc.setSystemId(systemId); |
| * templates = factory.newTemplates(xslSrc); |
| * transformer = templates.newTransformer(); |
| * transformer.transform(xmlSrc, StreamResult(...)); |
| * fileChecker.check(... goldFileName, desc) |
| * </pre> |
| * Also catches any exceptions and logs them as fails. |
| * |
| * @param xslSrc Source to use for stylesheet |
| * @param systemId systemId to set on the stylesheet |
| * @param xmlSrc Source to use for XML input data |
| * @param goldFileName name of expected file to compare with |
| * @param desc description of this test |
| */ |
| public void checkSourceWithSystemId(Source xslSrc, String systemId, |
| Source xmlSrc, String goldFileName, |
| String desc) |
| { |
| reporter.logTraceMsg(desc + " (" + systemId + ")"); |
| try |
| { |
| TransformerFactory factory = TransformerFactory.newInstance(); |
| xslSrc.setSystemId(systemId); |
| |
| // Use the next available output name for result |
| FileOutputStream fos = new FileOutputStream(outNames.nextName()); |
| Result outputResult = new StreamResult(fos); |
| |
| Templates templates = factory.newTemplates(xslSrc); |
| Transformer transformer = templates.newTransformer(); |
| transformer.transform(xmlSrc, outputResult); |
| fos.close(); // must close ostreams we own |
| if (Logger.PASS_RESULT |
| != fileChecker.check(reporter, |
| new File(outNames.currentName()), |
| new File(goldFileName), |
| desc + " (" + systemId + ") into: " + outNames.currentName()) |
| ) |
| reporter.logInfoMsg(desc + "... failure reason:" + fileChecker.getExtendedInfo()); |
| } |
| catch (Throwable t) |
| { |
| reporter.checkFail(desc + " threw: " + t.toString()); |
| reporter.logThrowable(reporter.ERRORMSG, t, desc + " threw"); |
| } |
| } |
| |
| |
| /** |
| * 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 SystemIdImpInclTest:\n" |
| + "(Note: assumes inputDir=.\\tests\\api)\n" |
| + "(Note: test is directory-dependent!)\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) |
| { |
| SystemIdImpInclTest app = new SystemIdImpInclTest(); |
| app.doMain(args); |
| } |
| } |
