--- /dev/null 2014-09-08 10:45:56.830930409 -0700 +++ new/test/javax/xml/jaxp/functional/org/apache/qetest/trax/Minitest.java 2014-12-31 11:40:30.312071589 -0800 @@ -0,0 +1,174 @@ +/* + * Copyright (c) 2014, Oracle and/or its affiliates. All rights reserved. + */ +/* + * 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. + */ +package org.apache.qetest.trax; + +import java.io.FileOutputStream; +import java.io.IOException; +import java.util.Properties; +import javax.xml.transform.Templates; +import javax.xml.transform.Transformer; +import javax.xml.transform.TransformerException; +import javax.xml.transform.TransformerFactory; +import javax.xml.transform.stream.StreamResult; +import javax.xml.transform.stream.StreamSource; +import jaxp.library.JAXPFileBaseTest; +import static jaxp.library.JAXPTestUtilities.compareWithGold; +import static jaxp.library.JAXPTestUtilities.filenameToURL; +import static org.apache.qetest.trax.TraxConst.GOLDEN_DIR; +import static org.apache.qetest.trax.TraxConst.XML_DIR; +import static jaxp.library.JAXPTestUtilities.getNextFile; +import org.apache.qetest.xslwrapper.TransformWrapper; +import org.apache.qetest.xslwrapper.TransformWrapperFactory; +import static org.testng.Assert.assertTrue; +import org.testng.annotations.DataProvider; +import org.testng.annotations.Test; + +/** + * Unit test for Xalan-J 2.x. + * + * Developers should always run either the minitest or smoketest + * target before checking any code into the xml-xalan CVS + * repository. Running the minitest before checking in ensures + * that the Xalan CVS tree will always be in a compileable and + * at least basically functional state, thus ensuring a workable + * product for your fellow Xalan developers. Ensuring your code + * passes the smoketest target will also help the nightly GUMP + * runs to pass the smoketest as well and avoid 'nag' emails. + */ +public class Minitest extends JAXPFileBaseTest { + /** + * Constants matching parameter names/values. + */ + private static final String PARAM1S = "param1s"; + + private static final String PARAM1N = "param1n"; + + /** + * Basic systemId transforms and parameters plus API coverage. + * + * @throws TransformerException If an unrecoverable error occurs during the + * course of the transformation. + * @throws IOException if any I/O operation error. + */ + @Test + public void test() throws TransformerException, IOException { + String xslFile = XML_DIR + "Minitest.xsl"; + String xmlFile = XML_DIR + "Minitest.xml"; + // Use separate output files for different versions, since + // some indenting rules are implemented differently 1.x/2.x + String goldFile = GOLDEN_DIR + "Minitest-xalanj2.out"; + + String file1 = getNextFile(this.getClass()); + String file2 = getNextFile(this.getClass()); + + try (FileOutputStream fos1 = new FileOutputStream(file1); + FileOutputStream fos2 = new FileOutputStream(file2);) { + TransformerFactory factory = TransformerFactory.newInstance(); + Templates templates = factory.newTemplates(new StreamSource(filenameToURL(xslFile))); + Transformer transformer = templates.newTransformer(); + transformer.transform(new StreamSource(filenameToURL(xmlFile)), + new StreamResult(fos1)); + compareWithGold(goldFile, file1); + + // Validate transformer reuse + transformer.transform(new StreamSource(filenameToURL(xmlFile)), + new StreamResult(fos2)); + compareWithGold(goldFile, file2); + } + + String paramXslFile = XML_DIR + "MinitestParam.xsl"; + String paramXmlFile = XML_DIR + "MinitestParam.xml"; + String paramGoldFile = GOLDEN_DIR + "MinitestParam.out"; + String file3 = getNextFile(this.getClass()); + try (FileOutputStream fos = new FileOutputStream(file3)) { + // Validate selected API's - primarily Parameters + TransformerFactory factory = TransformerFactory.newInstance(); + Templates paramTemplates = factory.newTemplates(new StreamSource(filenameToURL(paramXslFile))); + Transformer paramTransformer = paramTemplates.newTransformer(); + paramTransformer.setParameter(PARAM1S, "paramVal"); + assertTrue(paramTransformer.getParameter(PARAM1S) instanceof String); + + // Verify simple re-set/get of a single parameter - new Integer + paramTransformer.setParameter(PARAM1S, 1234); // SPR SCUU4R3JGY - can't re-set + assertTrue(paramTransformer.getParameter(PARAM1S) instanceof Integer); + + // Validate a transform with two params set + paramTransformer.setParameter(PARAM1N, "new-param1n-value"); + + paramTransformer.transform(new StreamSource(filenameToURL(paramXmlFile)), + new StreamResult(fos)); + compareWithGold(paramGoldFile, file3); + // Validate params are still set after transform + assertTrue(paramTransformer.getParameter(PARAM1S) instanceof Integer); + assertTrue(paramTransformer.getParameter(PARAM1S) instanceof Integer); + } + } + + @DataProvider + public Object[][] wrapperProvider() { + return new Object[][]{ + {"Minitest.xsl", "Minitest.xml", "Minitest-xalanj2.out", "trax.dom"}, + {"Minitest.xsl", "Minitest.xml", "Minitest-xalanj2.out", "trax.sax"}, + {"Minitest.xsl", "Minitest.xml", "Minitest-xalanj2.out", "trax.stream"}, + {"Minitest.xsl", "Minitest.xml", "Minitest-xalanj2.out", "trax.file"}, + {"Minitest.xsl", "Minitest.xml", "Minitest-xalanj2.out", "trax.systemId"}, + {"Minitest.xsl", "Minitest.xml", "Minitest-xalanj2.out", "trax.localPath"}, + {"Minitest.xsl", "Minitest.xml", "Minitest-xalanj2.out", "trax.systemId3"}, + {"MinitestPerf.xsl", "MinitestPerf.xml", "MinitestPerf.out", "trax.dom"}, + {"MinitestPerf.xsl", "MinitestPerf.xml", "MinitestPerf.out", "trax.sax"}, + {"MinitestPerf.xsl", "MinitestPerf.xml", "MinitestPerf.out", "trax.stream"}, + {"MinitestPerf.xsl", "MinitestPerf.xml", "MinitestPerf.out", "trax.file"}, + {"MinitestPerf.xsl", "MinitestPerf.xml", "MinitestPerf.out", "trax.systemId"}, + {"MinitestPerf.xsl", "MinitestPerf.xml", "MinitestPerf.out", "trax.localPath"}, + {"MinitestPerf.xsl", "MinitestPerf.xml", "MinitestPerf.out", "trax.systemId3"} + }; + } + + /** + * Basic test for transformWrapper. Worker method to use a TransformWrapper + * to transform a file and checking the output. + * + * @param xslName stylesheet file. + * @param xmlName XML file for parsing. + * @param goldName golden file for checking. + * @param flavor Test favor. + * @throws Exception any exception in wrapper. + */ + @Test(dataProvider = "wrapperProvider") + public void testTransformWrapper(String xslName, String xmlName, + String goldName, String flavor) throws Exception { + String xslFile = XML_DIR + xslName; + String xmlFile = XML_DIR + xmlName; + String goldFile = GOLDEN_DIR + goldName; + String outputFile = getNextFile(this.getClass()); + + TransformWrapper transformWrapper = TransformWrapperFactory.newWrapper(flavor); + transformWrapper.newProcessor(new Properties()); + if (null == xslFile) { + // presume it's an embedded test + transformWrapper.transformEmbedded(xmlFile, outputFile); + } else { + // presume it's a normal stylesheet test + transformWrapper.transform(xmlFile, xslFile, outputFile); + } + compareWithGold(goldFile, outputFile); + + } +}