| /* |
| * 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$ |
| */ |
| |
| package org.apache.qetest.trax; |
| |
| import java.io.File; |
| import java.io.FileOutputStream; |
| import java.util.Enumeration; |
| import java.util.Hashtable; |
| import java.util.Properties; |
| |
| import javax.xml.transform.ErrorListener; |
| import javax.xml.transform.OutputKeys; |
| import javax.xml.transform.Result; |
| import javax.xml.transform.Source; |
| 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 org.apache.qetest.Datalet; |
| import org.apache.qetest.FileBasedTest; |
| import org.apache.qetest.Logger; |
| import org.apache.qetest.OutputNameManager; |
| import org.apache.qetest.QetestUtils; |
| import org.apache.qetest.TestletImpl; |
| import org.apache.qetest.xsl.XSLTestfileInfo; |
| import org.apache.xml.utils.DefaultErrorHandler; |
| import org.junit.Test; |
| |
| //------------------------------------------------------------------------- |
| |
| /** |
| * Basic API coverage test for the Transformer class of TRAX. |
| * This test focuses on coverage testing for the API's, and |
| * very brief functional testing. Also see tests in the |
| * trax\sax, trax\dom, and trax\stream directories for specific |
| * coverage of Transformer API's in those usage cases. |
| * @author shane_curcuru@lotus.com |
| */ |
| public class TransformerAPITest extends FileBasedTest |
| { |
| |
| /** Cheap-o filename for various output files. */ |
| protected OutputNameManager outNames; |
| |
| /** Cheap-o filename set for general API tests. */ |
| protected XSLTestfileInfo simpleTest = new XSLTestfileInfo(); |
| |
| /** TransformerAPIParam.xsl used for set/getParameter related tests */ |
| protected XSLTestfileInfo paramTest = new XSLTestfileInfo(); |
| |
| /** Parameter names from TransformerAPIParam.xsl */ |
| public static final String PARAM1S = "param1s"; |
| public static final String PARAM2S = "param2s"; |
| public static final String PARAM3S = "param3s"; |
| public static final String PARAM1N = "param1n"; |
| public static final String PARAM2N = "param2n"; |
| public static final String PARAM3N = "param3n"; |
| |
| /** TransformerAPIOutputFormat.xsl used for set/getOutputFormat related tests */ |
| protected XSLTestfileInfo outputFormatTest = new XSLTestfileInfo(); |
| |
| /** Just goldName for outputFormatTest with UTF-8 */ |
| protected String outputFormatTestUTF8 = null; |
| |
| /** TransformerAPIHTMLFormat.xsl.xsl used for set/getOutputFormat related tests */ |
| protected XSLTestfileInfo htmlFormatTest = new XSLTestfileInfo(); |
| |
| /** Known outputFormat values from TransformerAPIOutputFormat.xsl */ |
| public static final String METHOD_VALUE = "xml"; |
| public static final String VERSION_VALUE ="123.45"; |
| public static final String ENCODING_VALUE ="UTF-16"; |
| public static final String STANDALONE_VALUE = "yes"; |
| public static final String DOCTYPE_PUBLIC_VALUE = "this-is-doctype-public"; |
| public static final String DOCTYPE_SYSTEM_VALUE = "this-is-doctype-system"; |
| public static final String CDATA_SECTION_ELEMENTS_VALUE = "cdataHere"; |
| public static final String INDENT_VALUE = "yes"; |
| public static final String MEDIA_TYPE_VALUE = "text/test/xml"; |
| public static final String OMIT_XML_DECLARATION_VALUE = "yes"; |
| |
| /** Cheap-o filename set(s) for multiple transform tests. */ |
| protected XSLTestfileInfo multiTest = new XSLTestfileInfo(); |
| protected XSLTestfileInfo multi2Test = new XSLTestfileInfo(); |
| |
| /** Subdir name under test\tests\api for files. */ |
| public static final String TRAX_SUBDIR = "trax"; |
| |
| /** Default ctor initializes test name, comment, numTestCases. */ |
| public TransformerAPITest() |
| { |
| |
| numTestCases = 6; // REPLACE_num |
| testName = "TransformerAPITest"; |
| testComment = "Basic API coverage test for the Transformer class"; |
| } |
| |
| /** |
| * Initialize this test - Set names of xml/xsl test files, cache system property. |
| * |
| * @param p Properties to initialize with (may be unused) |
| * @return false if test should be aborted, 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); |
| |
| outNames = new OutputNameManager(outputDir + File.separator + TRAX_SUBDIR |
| + File.separator + testName, ".out"); |
| |
| // We assume inputDir=...tests\api, and use the trax subdir |
| // also assume inputDir, etc. exist already |
| String testBasePath = inputDir + File.separator + TRAX_SUBDIR |
| + File.separator; |
| String goldBasePath = goldDir + File.separator + TRAX_SUBDIR |
| + File.separator; |
| |
| simpleTest.xmlName = QetestUtils.filenameToURL(testBasePath + "identity.xml"); |
| simpleTest.inputName = QetestUtils.filenameToURL(testBasePath + "identity.xsl"); |
| simpleTest.goldName = goldBasePath + "identity.out"; |
| |
| paramTest.xmlName = QetestUtils.filenameToURL(testBasePath + "TransformerAPIParam.xml"); |
| paramTest.inputName = QetestUtils.filenameToURL(testBasePath + "TransformerAPIParam.xsl"); |
| paramTest.goldName = goldBasePath + "TransformerAPIParam.out"; |
| |
| outputFormatTest.xmlName = QetestUtils.filenameToURL(testBasePath + "TransformerAPIOutputFormat.xml"); |
| outputFormatTest.inputName = QetestUtils.filenameToURL(testBasePath + "TransformerAPIOutputFormat.xsl"); |
| outputFormatTest.goldName = goldBasePath + "TransformerAPIOutputFormatUTF16.out"; |
| outputFormatTestUTF8 = goldBasePath + "TransformerAPIOutputFormatUTF8.out"; |
| |
| htmlFormatTest.xmlName = QetestUtils.filenameToURL(testBasePath + "TransformerAPIHTMLFormat.xml"); |
| htmlFormatTest.inputName = QetestUtils.filenameToURL(testBasePath + "TransformerAPIHTMLFormat.xsl"); |
| htmlFormatTest.goldName = goldBasePath + "TransformerAPIHTMLFormat.out"; |
| |
| multiTest.xmlName = QetestUtils.filenameToURL(testBasePath + "TransformerAPIVar.xml"); |
| multiTest.inputName = QetestUtils.filenameToURL(testBasePath + "TransformerAPIVar.xsl"); |
| multiTest.goldName = goldBasePath + "TransformerAPIVar.out"; |
| |
| multi2Test.xmlName = QetestUtils.filenameToURL(testBasePath + "TransformerAPIVar2.xml"); |
| multi2Test.goldName = goldBasePath + "TransformerAPIVar2.out"; |
| try |
| { |
| TransformerFactory tf = TransformerFactory.newInstance(); |
| if (!(tf.getFeature(StreamSource.FEATURE) |
| && tf.getFeature(StreamResult.FEATURE))) |
| { // The rest of this test relies on Streams only |
| reporter.logErrorMsg("Streams not supported! Some tests may be invalid!"); |
| } |
| } |
| catch (Exception e) |
| { |
| reporter.checkFail( |
| "Problem creating factory; Some tests may be invalid!"); |
| reporter.logThrowable(reporter.ERRORMSG, e, |
| "Problem creating factory; Some tests may be invalid!"); |
| } |
| |
| return true; |
| } |
| |
| |
| /** |
| * TRAX Transformer: cover basic get/setParameter(s) APIs. |
| * See {@link ParameterTest ParameterTest} for more |
| * functional test coverage on setting different kinds |
| * and types of parameters, etc. |
| * |
| * @return false if we should abort the test |
| */ |
| public boolean testCase1() |
| { |
| |
| reporter.testCaseInit( |
| "TRAX Transformer: cover basic get/setParameter(s) APIs"); |
| |
| TransformerFactory factory = null; |
| Templates templates = null; |
| Transformer transformer = null; |
| Transformer identityTransformer = null; |
| try |
| { |
| factory = TransformerFactory.newInstance(); |
| factory.setErrorListener(new DefaultErrorHandler()); |
| identityTransformer = factory.newTransformer(); |
| identityTransformer.setErrorListener(new DefaultErrorHandler()); |
| templates = factory.newTemplates(new StreamSource(paramTest.inputName)); |
| } |
| catch (Exception e) |
| { |
| reporter.checkFail("Problem creating Templates; cannot continue testcase"); |
| reporter.logThrowable(reporter.ERRORMSG, e, |
| "Problem creating Templates; cannot continue testcase"); |
| return true; |
| } |
| // Note: large number of try...catch blocks so that early |
| // exceptions won't blow out the whole testCase |
| try |
| { |
| // See what the default 'identity' transform has by default |
| Object tmp = identityTransformer.getParameter("This-param-does-not-exist"); |
| reporter.checkObject(tmp, null, "This-param-does-not-exist is null by default identityTransformer"); |
| // Can you set properties on this transformer? |
| identityTransformer.setParameter("foo", "bar"); |
| tmp = identityTransformer.getParameter("foo"); |
| if (tmp == null) |
| { |
| reporter.checkFail("identityTransformer set/getParameter is:" + tmp); |
| } |
| else |
| { |
| reporter.checkString((String)tmp, "bar", "identityTransformer set/getParameter value: " + tmp); |
| reporter.check((tmp instanceof String), true, "identityTransformer set/getParameter datatype"); |
| } |
| } |
| catch (Exception e) |
| { |
| reporter.logThrowable(reporter.ERRORMSG, e, "Problem(1) with identity parameters"); |
| reporter.checkFail("Problem(1) with identity parameters"); |
| } |
| |
| try |
| { |
| transformer = templates.newTransformer(); // may throw TransformerConfigurationException |
| transformer.setErrorListener(new DefaultErrorHandler()); |
| // Default Transformer should not have any parameters.. |
| Object tmp = transformer.getParameter("This-param-does-not-exist"); |
| reporter.checkObject(tmp, null, "This-param-does-not-exist is null by default"); |
| // .. including params in the stylesheet |
| tmp = transformer.getParameter(PARAM1S); |
| if (tmp == null) |
| { // @todo should use checkObject instead of this if... construct |
| reporter.checkPass(PARAM1S + " is null by default"); |
| } |
| else |
| { |
| reporter.checkFail(PARAM1S + " is " + tmp + " by default"); |
| } |
| |
| // Verify simple set/get of a single parameter - String |
| transformer.setParameter(PARAM1S, "new value1s"); |
| reporter.logTraceMsg("Just reset " + PARAM1S + " to new value1s"); |
| tmp = transformer.getParameter(PARAM1S); // SPR SCUU4QWTVZ - returns an XString - fixed |
| if (tmp == null) |
| { |
| reporter.checkFail(PARAM1S + " is still set to null!"); |
| } |
| else |
| { // Validate SPR SCUU4QWTVZ - should return the same type you set |
| if (tmp instanceof String) |
| { |
| reporter.checkString((String)tmp, "new value1s", PARAM1S + " is now set to ?" + tmp + "?"); |
| } |
| else |
| { |
| reporter.checkFail(PARAM1S + " is now ?" + tmp + "?, isa " + tmp.getClass().getName()); |
| } |
| } |
| } |
| catch (Exception e) |
| { |
| reporter.logThrowable(reporter.ERRORMSG, e, "Problem(2) set/getParameter testing"); |
| reporter.checkFail("Problem(2) set/getParameter testing"); |
| } |
| |
| try |
| { |
| transformer = templates.newTransformer(); |
| transformer.setErrorListener(new DefaultErrorHandler()); |
| // Verify simple set/get of a single parameter - Integer |
| transformer.setParameter(PARAM3S, new Integer(1234)); |
| reporter.logTraceMsg("Just set " + PARAM3S + " to Integer(1234)"); |
| Object tmp = transformer.getParameter(PARAM3S); // SPR SCUU4QWTVZ - returns an XObject - fixed |
| if (tmp == null) |
| { |
| reporter.checkFail(PARAM3S + " is still set to null!"); |
| } |
| else |
| { // Validate SPR SCUU4QWTVZ - should return the same type you set |
| if (tmp instanceof Integer) |
| { |
| reporter.checkObject(tmp, new Integer(1234), PARAM3S + " is now set to ?" + tmp + "?"); |
| } |
| else |
| { |
| reporter.checkFail(PARAM3S + " is now ?" + tmp + "?, isa " + tmp.getClass().getName()); |
| } |
| } |
| |
| // Verify simple re-set/get of a single parameter - new Integer |
| transformer.setParameter(PARAM3S, new Integer(99)); // SPR SCUU4R3JGY - can't re-set |
| reporter.logTraceMsg("Just reset " + PARAM3S + " to new Integer(99)"); |
| tmp = null; |
| tmp = transformer.getParameter(PARAM3S); |
| if (tmp == null) |
| { |
| reporter.checkFail(PARAM3S + " is still set to null!"); |
| } |
| else |
| { // Validate SPR SCUU4QWTVZ - should return the same type you set |
| if (tmp instanceof Integer) |
| { |
| reporter.checkObject(tmp, new Integer(99), PARAM3S + " is now set to ?" + tmp + "?"); |
| } |
| else |
| { |
| reporter.checkFail(PARAM3S + " is now ?" + tmp + "?, isa " + tmp.getClass().getName()); |
| } |
| } |
| |
| // Verify simple re-set/get of a single parameter - now a new String |
| transformer.setParameter(PARAM3S, "new value3s"); |
| reporter.logTraceMsg("Just reset " + PARAM3S + " to new value3s"); |
| tmp = null; |
| tmp = transformer.getParameter(PARAM3S); |
| if (tmp == null) |
| { |
| reporter.checkFail(PARAM3S + " is still set to null!"); |
| } |
| else |
| { // Validate SPR SCUU4QWTVZ - should return the same type you set |
| if (tmp instanceof String) |
| { |
| reporter.checkString((String)tmp, "new value3s", PARAM3S + " is now set to ?" + tmp + "?"); |
| } |
| else |
| { |
| reporter.checkFail(PARAM3S + " is now ?" + tmp + "?, isa " + tmp.getClass().getName()); |
| } |
| } |
| } |
| catch (Exception e) |
| { |
| reporter.logThrowable(reporter.ERRORMSG, e, "Problem(3) set/getParameters testing"); |
| reporter.checkFail("Problem(3) set/getParameters testing"); |
| } |
| |
| try |
| { |
| transformer = templates.newTransformer(); |
| transformer.setErrorListener(new DefaultErrorHandler()); |
| transformer.setParameter(PARAM1S, "'test-param-1s'"); // note single quotes |
| transformer.setParameter(PARAM1N, new Integer(1234)); |
| // Verify basic params actually affect transformation |
| // Use the transformer we set the params onto above! |
| FileOutputStream fos = new FileOutputStream(outNames.nextName()); |
| if (doTransform(transformer, |
| new StreamSource(paramTest.xmlName), |
| new StreamResult(fos))) |
| { |
| fos.close(); // must close ostreams we own |
| // @todo should update goldFile! |
| if (Logger.PASS_RESULT |
| != fileChecker.check(reporter, |
| new File(outNames.currentName()), |
| new File(paramTest.goldName), |
| "transform with param1s,param1n into: " + outNames.currentName()) |
| ) |
| reporter.logInfoMsg("transform with param1s,param1n failure reason:" + fileChecker.getExtendedInfo()); |
| } |
| String gotStr = (String)transformer.getParameter(PARAM1S); |
| reporter.check(gotStr, "'test-param-1s'", |
| PARAM1S + " is still set after transform to ?" + gotStr + "?"); |
| Integer gotInt = (Integer)transformer.getParameter(PARAM1N); |
| reporter.checkInt(gotInt.intValue(), 1234, |
| PARAM1N + " is still set after transform to ?" + gotInt + "?"); |
| } |
| catch (Exception e) |
| { |
| reporter.logThrowable(reporter.ERRORMSG, e, "Problem(4) with parameter transform"); |
| reporter.checkFail("Problem(4) with parameter transform"); |
| } |
| |
| reporter.testCaseClose(); |
| return true; |
| } |
| |
| |
| /** |
| * API coverage test of Transformer.set/getOutputProperty() |
| * See {@link OutputPropertiesTest} for more coverage on setting |
| * different kinds of outputs, etc. |
| * |
| * @return false if we should abort the test |
| */ |
| public boolean testCase2() |
| { |
| //@todo I can't decide how to split tests up between |
| // testCase2/testCase3 - they really should be reorganized |
| reporter.testCaseInit("API coverage test of Transformer.set/getOutputProperty()"); |
| TransformerFactory factory = null; |
| Templates outputTemplates = null; |
| Transformer outputTransformer = null; |
| Templates htmlTemplates = null; |
| Transformer htmlTransformer = null; |
| Templates identityTemplates = null; |
| Transformer identityTransformer = null; // an .xsl file defining an identity transform |
| Transformer defaultTransformer = null; // the default 'identity' transform |
| try |
| { |
| factory = TransformerFactory.newInstance(); |
| factory.setErrorListener(new DefaultErrorHandler()); |
| outputTemplates = factory.newTemplates(new StreamSource(outputFormatTest.inputName)); |
| outputTransformer = outputTemplates.newTransformer(); |
| outputTransformer.setErrorListener(new DefaultErrorHandler()); |
| |
| htmlTemplates = factory.newTemplates(new StreamSource(htmlFormatTest.inputName)); |
| htmlTransformer = htmlTemplates.newTransformer(); |
| htmlTransformer.setErrorListener(new DefaultErrorHandler()); |
| |
| identityTemplates = factory.newTemplates(new StreamSource(simpleTest.inputName)); |
| identityTransformer = identityTemplates.newTransformer(); |
| identityTransformer.setErrorListener(new DefaultErrorHandler()); |
| |
| defaultTransformer = factory.newTransformer(); |
| defaultTransformer.setErrorListener(new DefaultErrorHandler()); |
| } |
| catch (Throwable t) |
| { |
| reporter.checkFail("Problem creating Templates; cannot continue"); |
| reporter.logThrowable(reporter.ERRORMSG, t, |
| "Problem creating Templates; cannot continue"); |
| return true; |
| } |
| |
| try |
| { |
| // See what the default 'identity' transform has by default |
| Properties defaultProps = defaultTransformer.getOutputProperties(); // SPR SCUU4RXQYH throws npe |
| reporter.logHashtable(reporter.STATUSMSG, defaultProps, |
| "default defaultTransformer.getOutputProperties()"); |
| |
| // Check that the local stylesheet.getProperty has default set, cf. getOutputProperties javadoc |
| reporter.check(("xml".equals(defaultProps.getProperty(OutputKeys.METHOD))), true, "defaultTransformer.op.getProperty(" |
| + OutputKeys.METHOD + ") is default value, act: " + defaultProps.getProperty(OutputKeys.METHOD)); |
| // Check that the local stylesheet.get has nothing set, cf. getOutputProperties javadoc |
| reporter.check((null == defaultProps.get(OutputKeys.METHOD)), true, "defaultTransformer.op.get(" |
| + OutputKeys.METHOD + ") is null value, act: " + defaultProps.get(OutputKeys.METHOD)); |
| |
| // Can you set properties on this transformer? |
| defaultTransformer.setOutputProperty(OutputKeys.METHOD, "text"); |
| reporter.logTraceMsg("Just defaultTransformer setOutputProperty(method,text)"); |
| String tmp = defaultTransformer.getOutputProperty(OutputKeys.METHOD); // SPR SCUU4R3JPH - throws npe |
| reporter.check(tmp, "text", "defaultTransformer set/getOutputProperty, is ?" + tmp + "?"); |
| } |
| catch (Exception e) |
| { |
| reporter.logThrowable(reporter.ERRORMSG, e, "Problem(1) with default output property"); |
| reporter.checkFail("Problem(1) with default output property", "SCUU4RXQYH"); |
| } |
| |
| try |
| { |
| // See what the our .xsl file 'identity' transform has |
| Properties identityProps = identityTransformer.getOutputProperties(); |
| reporter.logHashtable(reporter.STATUSMSG, identityProps, |
| "default identityTransformer.getOutputProperties()"); |
| |
| // Check that the local stylesheet.getProperty has default set, cf. getOutputProperties javadoc |
| reporter.check(("xml".equals(identityProps.getProperty(OutputKeys.METHOD))), true, "identityTransformer.op.getProperty(" |
| + OutputKeys.METHOD + ") is default value, act: " + identityProps.getProperty(OutputKeys.METHOD)); |
| // Check that the local stylesheet.get has nothing set, cf. getOutputProperties javadoc |
| reporter.check((null == identityProps.get(OutputKeys.METHOD)), true, "identityTransformer.op.get(" |
| + OutputKeys.METHOD + ") is null value, act: " + identityProps.get(OutputKeys.METHOD)); |
| |
| // Check that the local stylesheet.getProperty has default set, cf. getOutputProperties javadoc |
| reporter.check(("no".equals(identityProps.getProperty(OutputKeys.INDENT))), true, "identityTransformer.op.getProperty(" |
| + OutputKeys.INDENT + ") is default value, act: " + identityProps.getProperty(OutputKeys.INDENT)); |
| // Check that the local stylesheet.get has nothing set, cf. getOutputProperties javadoc |
| reporter.check((null == (identityProps.get(OutputKeys.INDENT))), true, "identityTransformer.op.get(" |
| + OutputKeys.INDENT + ") is default value, act: " + identityProps.get(OutputKeys.INDENT)); |
| |
| // Can you set properties on this transformer? |
| defaultTransformer.setOutputProperty(OutputKeys.METHOD, "text"); |
| reporter.logTraceMsg("Just identityTransformer setOutputProperty(method,text)"); |
| String tmp = defaultTransformer.getOutputProperty(OutputKeys.METHOD); // SPR SCUU4R3JPH - throws npe |
| reporter.check(tmp, "text", "identityTransformer set/getOutputProperty, is ?" + tmp + "?"); |
| } |
| catch (Exception e) |
| { |
| reporter.logThrowable(reporter.ERRORMSG, e, "Problem(2) with identity output property"); |
| reporter.checkFail("Problem(2) with identity output property"); |
| } |
| |
| try |
| { |
| // See what the our html-format output has |
| Properties htmlProps = htmlTransformer.getOutputProperties(); |
| reporter.logHashtable(reporter.STATUSMSG, htmlProps, |
| "default htmlTransformer.getOutputProperties()"); |
| |
| // Check that the local stylesheet.getProperty has stylesheet val set, cf. getOutputProperties javadoc |
| reporter.check(("html".equals(htmlProps.getProperty(OutputKeys.METHOD))), true, "htmlTransformer.op.getProperty(" |
| + OutputKeys.METHOD + ") is stylesheet value, act: " + htmlProps.getProperty(OutputKeys.METHOD)); |
| // Check that the local stylesheet.get has stylesheet val set, cf. getOutputProperties javadoc |
| reporter.check(("html".equals(htmlProps.get(OutputKeys.METHOD))), true, "htmlTransformer.op.get(" |
| + OutputKeys.METHOD + ") is stylesheet value, act: " + htmlProps.get(OutputKeys.METHOD)); |
| |
| // Check that the local stylesheet.getProperty has default set, cf. getOutputProperties javadoc |
| reporter.check(("yes".equals(htmlProps.getProperty(OutputKeys.INDENT))), true, "htmlTransformer.op.getProperty(" |
| + OutputKeys.INDENT + ") is default value, act: " + htmlProps.getProperty(OutputKeys.INDENT)); |
| // Check that the local stylesheet.get has nothing set, cf. getOutputProperties javadoc |
| reporter.check((null == (htmlProps.get(OutputKeys.INDENT))), true, "htmlTransformer.op.get(" |
| + OutputKeys.INDENT + ") is default value, act: " + htmlProps.get(OutputKeys.INDENT)); |
| |
| // Can you set properties on this transformer? |
| defaultTransformer.setOutputProperty(OutputKeys.METHOD, "text"); |
| reporter.logTraceMsg("Just htmlTransformer setOutputProperty(method,text)"); |
| String tmp = defaultTransformer.getOutputProperty(OutputKeys.METHOD); // SPR SCUU4R3JPH - throws npe |
| reporter.check(tmp, "text", "htmlTransformer set/getOutputProperty, is ?" + tmp + "?"); |
| } |
| catch (Exception e) |
| { |
| reporter.logThrowable(reporter.ERRORMSG, e, "Problem(3) with html output property"); |
| reporter.checkFail("Problem(3) with html output property"); |
| } |
| |
| try |
| { |
| // See what our outputTemplates parent has |
| Properties tmpltProps = outputTemplates.getOutputProperties(); |
| reporter.logHashtable(reporter.STATUSMSG, tmpltProps, |
| "default outputTemplates.getOutputProperties()"); |
| |
| // See what we have by default, from our testfile |
| outputTransformer = outputTemplates.newTransformer(); |
| outputTransformer.setErrorListener(new DefaultErrorHandler()); |
| try |
| { |
| // Inner try-catch |
| Properties outProps = outputTransformer.getOutputProperties(); // SPR SCUU4RXQYH throws npe |
| reporter.logHashtable(reporter.STATUSMSG, outProps, |
| "default outputTransformer.getOutputProperties()"); |
| |
| // Validate the two have the same properties (which they |
| // should, since we just got the templates now) |
| for (Enumeration names = tmpltProps.propertyNames(); |
| names.hasMoreElements(); /* no increment portion */ ) |
| { |
| String key = (String)names.nextElement(); |
| String value = tmpltProps.getProperty(key); |
| reporter.check(value, outProps.getProperty(key), |
| "Template, transformer identical outProp: " + key); |
| } |
| |
| // Validate known output properties from our testfile |
| String knownOutputProps[][] = |
| { |
| { OutputKeys.METHOD, METHOD_VALUE }, |
| { OutputKeys.VERSION, VERSION_VALUE }, |
| { OutputKeys.ENCODING, ENCODING_VALUE }, |
| { OutputKeys.STANDALONE, STANDALONE_VALUE }, |
| { OutputKeys.DOCTYPE_PUBLIC, DOCTYPE_PUBLIC_VALUE }, // SPR SCUU4R3JRR - not returned |
| { OutputKeys.DOCTYPE_SYSTEM, DOCTYPE_SYSTEM_VALUE }, // SPR SCUU4R3JRR - not returned |
| { OutputKeys.CDATA_SECTION_ELEMENTS, CDATA_SECTION_ELEMENTS_VALUE }, // SPR SCUU4R3JRR - not returned |
| { OutputKeys.INDENT, INDENT_VALUE }, |
| { OutputKeys.MEDIA_TYPE, MEDIA_TYPE_VALUE }, |
| { OutputKeys.OMIT_XML_DECLARATION, OMIT_XML_DECLARATION_VALUE } |
| }; |
| |
| for (int i = 0; i < knownOutputProps.length; i++) |
| { |
| String item = outProps.getProperty(knownOutputProps[i][0]); |
| reporter.check(item, knownOutputProps[i][1], |
| "Known prop(1) " + knownOutputProps[i][0] |
| + " is: ?" + item + "?"); |
| } |
| reporter.logStatusMsg("@todo validate getting individual properties"); |
| } |
| catch (Exception e) |
| { |
| reporter.logThrowable(reporter.ERRORMSG, e, "Problem(a1) with set/get output properties"); |
| reporter.checkFail("Problem(a1) with set/get output properties", "SCUU4RXQYH"); |
| } |
| |
| /* |
| NOTE (SB): |
| Shane omits the xml-decl in the stylesheet, which I don't think |
| will create a valid XML with UTF-16 encoding (I could be wrong). |
| Also, Xerces 1.2.3 is pretty broken for UTF-16 right now. |
| So just comment this out for the moment. |
| |
| // Try doing a transform (will be UTF-16), to get some output |
| if (doTransform(outputTransformer, |
| new StreamSource(outputFormatTest.xmlName), |
| new StreamResult(new FileOutputStream(outNames.nextName())))) |
| { |
| // @todo should update goldFile! |
| fileChecker.check(reporter, |
| new File(outNames.currentName()), |
| new File(outputFormatTest.goldName), |
| "transform(UTF-16,1) outputParams into: " + outNames.currentName()); |
| } |
| */ |
| |
| // Change a single property (makes for simpler encoding output!) |
| outputTransformer.setOutputProperty(OutputKeys.ENCODING, "UTF-8"); |
| String encoding = outputTransformer.getOutputProperty(OutputKeys.ENCODING); |
| reporter.check(encoding, "UTF-8", "outputTransformer set/getOutputProperty value to ?" + encoding + "?"); |
| // Try doing another transform (will be UTF-8), to get some output |
| // Verify that other output properties stay the same |
| FileOutputStream fos = new FileOutputStream(outNames.nextName()); |
| if (doTransform(outputTransformer, |
| new StreamSource(outputFormatTest.xmlName), |
| new StreamResult(fos))) |
| { |
| fos.close(); // must close ostreams we own |
| // @todo should update goldFile! |
| if (Logger.PASS_RESULT |
| != fileChecker.check(reporter, |
| new File(outNames.currentName()), |
| new File(outputFormatTestUTF8), |
| "transform(UTF-8) outputParams into: " + outNames.currentName()) |
| ) |
| reporter.logInfoMsg("transform(UTF-8) outputParams failure reason:" + fileChecker.getExtendedInfo()); |
| } |
| // Try getting the whole block and logging it out, just to see what's there |
| Properties moreOutProps = outputTransformer.getOutputProperties(); |
| reporter.logHashtable(reporter.STATUSMSG, moreOutProps, |
| "After several transforms getOutputProperties()"); |
| |
| try |
| { // Inner try-catch |
| // Simple set/getOutputProperty |
| outputTransformer = outputTemplates.newTransformer(); |
| outputTransformer.setErrorListener(new DefaultErrorHandler()); |
| String tmp = outputTransformer.getOutputProperty(OutputKeys.OMIT_XML_DECLARATION); // SPR SCUU4RXR6E |
| // SPR SCUU4R3JZ7 - throws npe |
| reporter.logTraceMsg(OutputKeys.OMIT_XML_DECLARATION + " is currently: " + tmp); |
| outputTransformer.setOutputProperty(OutputKeys.OMIT_XML_DECLARATION, "no"); |
| tmp = outputTransformer.getOutputProperty(OutputKeys.OMIT_XML_DECLARATION); |
| reporter.check(tmp, "no", "outputTransformer set/getOutputProperty value to ?" + tmp + "?"); |
| } |
| catch (Exception e) |
| { |
| reporter.logThrowable(reporter.ERRORMSG, e, "Problem(a2) with set/get output properties"); |
| reporter.checkFail("Problem(a2) with set/get output properties", "SCUU4RXR6E"); |
| } |
| try |
| { // Inner try-catch |
| // Try getting the whole properties block, so we can see what it thinks it has |
| outputTransformer = outputTemplates.newTransformer(); |
| outputTransformer.setErrorListener(new DefaultErrorHandler()); |
| Properties newOutProps = outputTransformer.getOutputProperties(); |
| reporter.logHashtable(reporter.STATUSMSG, newOutProps, |
| "Another getOutputProperties()"); |
| |
| // Simple set/getOutputProperty |
| String tmp = outputTransformer.getOutputProperty(OutputKeys.ENCODING); |
| reporter.logTraceMsg(OutputKeys.ENCODING + " is currently: " + tmp); |
| outputTransformer.setOutputProperty(OutputKeys.ENCODING, "UTF-8"); |
| tmp = outputTransformer.getOutputProperty(OutputKeys.ENCODING); |
| reporter.check(tmp, "UTF-8", "outputTransformer set/getOutputProperty value to ?" + tmp + "?"); |
| } |
| catch (Exception e) |
| { |
| reporter.logThrowable(reporter.ERRORMSG, e, |
| "Problem(a3) with set/get output property"); |
| } |
| |
| // OutputKeys.METHOD = xml|html|text|qname-but-not-ncname |
| // OutputKeys.VERSION = number |
| // OutputKeys.ENCODING = string |
| // OutputKeys.OMIT_XML_DECLARATION = yes|no |
| // OutputKeys.STANDALONE = yes|no |
| // OutputKeys.DOCTYPE_PUBLIC = string |
| // OutputKeys.DOCTYPE_SYSTEM = string |
| // OutputKeys.CDATA_SECTION_ELEMENTS = qnames |
| // OutputKeys.INDENT = qnames |
| // OutputKeys.MEDIA_TYPE = qnames |
| // OutputKeys.CDATA_SECTION_ELEMENTS = qnames |
| |
| reporter.logTraceMsg("//@todo Cover setOutputProperties(Properties oformat)"); |
| } |
| catch (Exception e) |
| { |
| reporter.logThrowable(reporter.ERRORMSG, e, |
| "Problem(4) with set/get output properties"); |
| reporter.checkFail("Problem(4) with set/get output properties"); |
| } |
| |
| reporter.logTraceMsg("//@todo: Negative testing: various illegal arguments, etc. - in separate testcase"); |
| |
| reporter.testCaseClose(); |
| return true; |
| } |
| |
| /** |
| * API coverage test of Transformer.set/getOutputProperties() |
| * See {@link OutputPropertiesTest} for more coverage on setting |
| * different kinds of outputs, etc. |
| * |
| * @return false if we should abort the test |
| */ |
| public boolean testCase3() |
| { |
| reporter.testCaseInit("API coverage test of Transformer.set/getOutputProperties()"); |
| TransformerFactory factory = null; |
| Templates outputTemplates = null; |
| Transformer outputTransformer = null; |
| Transformer identityTransformer = null; |
| try |
| { |
| factory = TransformerFactory.newInstance(); |
| factory.setErrorListener(new DefaultErrorHandler()); |
| identityTransformer = factory.newTransformer(); |
| identityTransformer.setErrorListener(new DefaultErrorHandler()); |
| outputTemplates = factory.newTemplates(new StreamSource(outputFormatTest.inputName)); |
| } |
| catch (Throwable t) |
| { |
| reporter.checkFail("Problem creating Templates; cannot continue"); |
| reporter.logThrowable(reporter.ERRORMSG, t, |
| "Problem creating Templates; cannot continue"); |
| return true; |
| } |
| try |
| { |
| // See what the default 'identity' transform has by default |
| Properties identityProps = identityTransformer.getOutputProperties(); // SPR SCUU4RXQYH throws npe |
| reporter.check((null != identityProps), true, "identityTransformer.getOutputProperties() is non-null"); |
| reporter.logHashtable(reporter.STATUSMSG, identityProps, |
| "default identityTransformer.getOutputProperties()"); |
| } |
| catch (Exception e) |
| { |
| reporter.logThrowable(reporter.ERRORMSG, e, |
| "Problem with identity OutputProperties"); |
| reporter.checkFail("Problem with identity OutputProperties", "SCUU4RXQYH"); |
| } |
| |
| reporter.logTraceMsg("//@todo: coverage of non-identity transformers and set/get of props"); |
| reporter.testCaseClose(); |
| return true; |
| } // end testCase3 |
| |
| |
| /** |
| * Negative tests of Transformer.set/getOutputProperty/ies() |
| * |
| * @return false if we should abort the test |
| */ |
| public boolean testCase4() |
| { |
| reporter.testCaseInit("Negative tests of Transformer.set/getOutputProperty/ies()"); |
| TransformerFactory factory = null; |
| Templates outputTemplates = null; |
| Transformer outputTransformer = null; |
| Transformer identityTransformer = null; |
| try |
| { |
| factory = TransformerFactory.newInstance(); |
| factory.setErrorListener(new DefaultErrorHandler()); |
| identityTransformer = factory.newTransformer(); |
| identityTransformer.setErrorListener(new DefaultErrorHandler()); |
| outputTemplates = factory.newTemplates(new StreamSource(outputFormatTest.inputName)); |
| } |
| catch (Throwable t) |
| { |
| reporter.checkFail("Problem creating Templates; cannot continue"); |
| reporter.logThrowable(reporter.ERRORMSG, t, |
| "Problem creating Templates; cannot continue"); |
| return true; |
| } |
| |
| GetOutputPropertyTestlet testlet = new GetOutputPropertyTestlet(); |
| reporter.logTraceMsg("Using GetOutputPropertyTestlet for negative tests"); |
| testlet.setLogger(reporter); |
| |
| // Negative tests of getOutputProperty() |
| GetOutputPropertyDatalet datalet = new GetOutputPropertyDatalet(); |
| reporter.logTraceMsg("Using GetOutputPropertyDatalet for negative tests"); |
| |
| try |
| { |
| datalet.transformer = identityTransformer; |
| datalet.propName = "bogus-name"; |
| datalet.expectedValue = null; |
| datalet.expectedException = "java.lang.IllegalArgumentException"; |
| datalet.setDescription("bogus-name identityTransformer throws IllegalArgumentException"); |
| testlet.execute(datalet); |
| |
| datalet.transformer = identityTransformer; |
| datalet.propName = "bogus-{name}"; |
| datalet.expectedValue = null; |
| datalet.expectedException = "java.lang.IllegalArgumentException"; |
| datalet.setDescription("bogus-{name} throws IllegalArgumentException"); |
| testlet.execute(datalet); |
| |
| datalet.transformer = identityTransformer; |
| datalet.propName = "{bogus-name"; |
| datalet.expectedValue = null; |
| datalet.expectedException = "java.lang.IllegalArgumentException"; |
| datalet.setDescription("{bogus-name throws IllegalArgumentException (bracket not closed)"); |
| testlet.execute(datalet); |
| |
| datalet.transformer = identityTransformer; |
| datalet.propName = "{some-namespace}bogus-name"; |
| datalet.expectedValue = datalet.NULL_VALUE_EXPECTED; |
| datalet.expectedException = null; |
| datalet.setDescription("{some-namespace}bogus-name returns null"); |
| testlet.execute(datalet); |
| |
| datalet.transformer = identityTransformer; |
| datalet.propName = "{just-some-namespace}"; |
| datalet.expectedValue = datalet.NULL_VALUE_EXPECTED; |
| datalet.expectedException = null; |
| datalet.setDescription("{just-some-namespace}bogus-name returns null"); |
| testlet.execute(datalet); |
| |
| datalet.transformer = identityTransformer; |
| datalet.propName = "{}no-namespace-at-all"; |
| datalet.expectedValue = datalet.NULL_VALUE_EXPECTED; |
| datalet.expectedException = null; |
| datalet.setDescription("{}no-namespace-at-all returns null (is this correct?)"); |
| testlet.execute(datalet); |
| |
| datalet.transformer = identityTransformer; |
| datalet.propName = OutputKeys.METHOD; |
| datalet.expectedValue = "xml"; |
| datalet.expectedException = null; |
| datalet.setDescription(OutputKeys.METHOD + " returns xml on identity transformer (is this really correct?)"); |
| testlet.execute(datalet); |
| |
| } |
| catch (Throwable t) |
| { |
| reporter.logThrowable(reporter.STATUSMSG, t, "Problem(1) with negative identityTransformer getOutputProperty"); |
| reporter.checkErr("Problem(1) with negative identityTransformer getOutputProperty: " + t.toString()); |
| } |
| try |
| { |
| datalet.transformer = outputTemplates.newTransformer(); |
| datalet.propName = "bogus-name"; |
| datalet.expectedValue = null; |
| datalet.expectedException = "java.lang.IllegalArgumentException"; |
| datalet.setDescription("bogus-name regular transformer throws IllegalArgumentException"); |
| testlet.execute(datalet); |
| |
| datalet.transformer = outputTemplates.newTransformer(); |
| datalet.propName = "bogus-{name}"; |
| datalet.expectedValue = null; |
| datalet.expectedException = "java.lang.IllegalArgumentException"; |
| datalet.setDescription("bogus-{name} throws IllegalArgumentException"); |
| testlet.execute(datalet); |
| |
| datalet.transformer = outputTemplates.newTransformer(); |
| datalet.propName = "{bogus-name"; |
| datalet.expectedValue = null; |
| datalet.expectedException = "java.lang.IllegalArgumentException"; |
| datalet.setDescription("{bogus-name throws IllegalArgumentException (bracket not closed)"); |
| /* testlet.execute(datalet); comment out 10-May-01 -sc Bugzilla 890 */ |
| /* This is a fairly unimportant bug that may well be |
| fixed in the javadoc, so I'm commenting this case |
| out so we can run this test in the smoketest and |
| get more regular coverage of it! */ |
| |
| datalet.transformer = outputTemplates.newTransformer(); |
| datalet.propName = "{some-namespace}bogus-name"; |
| datalet.expectedValue = datalet.NULL_VALUE_EXPECTED; |
| datalet.expectedException = null; |
| datalet.setDescription("{some-namespace}bogus-name returns null"); |
| testlet.execute(datalet); |
| |
| datalet.transformer = outputTemplates.newTransformer(); |
| datalet.propName = "{just-some-namespace}"; |
| datalet.expectedValue = datalet.NULL_VALUE_EXPECTED; |
| datalet.expectedException = null; |
| datalet.setDescription("{just-some-namespace}bogus-name returns null"); |
| testlet.execute(datalet); |
| |
| datalet.transformer = outputTemplates.newTransformer(); |
| datalet.propName = "{}no-namespace-at-all"; |
| datalet.expectedValue = datalet.NULL_VALUE_EXPECTED; |
| datalet.expectedException = null; |
| datalet.setDescription("{}no-namespace-at-all returns null (is this correct?)"); |
| testlet.execute(datalet); |
| |
| datalet.transformer = outputTemplates.newTransformer(); |
| datalet.propName = OutputKeys.METHOD; |
| datalet.expectedValue = METHOD_VALUE; |
| datalet.expectedException = null; |
| datalet.setDescription(OutputKeys.METHOD + " returns " + METHOD_VALUE + " on transformer"); |
| testlet.execute(datalet); |
| |
| } |
| catch (Throwable t) |
| { |
| reporter.logThrowable(reporter.STATUSMSG, t, "Problem(2) with negative transformer getOutputProperty"); |
| reporter.checkErr("Problem(2) with negative transformer getOutputProperty: " + t.toString()); |
| } |
| |
| reporter.testCaseClose(); |
| return true; |
| } // end testCase4 |
| |
| |
| /** |
| * TRAX Transformer: cover transform() API and multiple |
| * Transformations from single transformer. |
| * |
| * Note: obviously as the most important API, transform() is |
| * also covered in many other API tests as well as in various |
| * Stylesheet*Testlet tests. |
| * |
| * @return false if we should abort the test |
| */ |
| public boolean testCase5() |
| { |
| reporter.testCaseInit( |
| "TRAX Transformer: cover multiple calls to transform()"); |
| TransformerFactory factory = null; |
| Templates templates = null; |
| try |
| { |
| factory = TransformerFactory.newInstance(); |
| factory.setErrorListener(new DefaultErrorHandler()); |
| } |
| catch (Throwable t) |
| { |
| reporter.logThrowable(reporter.STATUSMSG, t, "Can't continue testcase, factory.newInstance threw:"); |
| reporter.checkErr("Can't continue testcase, factory.newInstance threw: " + t.toString()); |
| return true; |
| } |
| |
| try |
| { |
| Transformer transformer = factory.newTransformer(new StreamSource(simpleTest.inputName)); |
| transformer.setErrorListener(new DefaultErrorHandler()); |
| // Re-use the transformer multiple times on identity |
| transformer.transform(new StreamSource(simpleTest.xmlName), |
| new StreamResult(outNames.nextName())); |
| fileChecker.check(reporter, |
| new File(outNames.currentName()), |
| new File(simpleTest.goldName), |
| "transform(#1) identity into: " + outNames.currentName()); |
| |
| transformer.transform(new StreamSource(simpleTest.xmlName), |
| new StreamResult(outNames.nextName())); |
| fileChecker.check(reporter, |
| new File(outNames.currentName()), |
| new File(simpleTest.goldName), |
| "transform(#2) identity into: " + outNames.currentName()); |
| |
| transformer.transform(new StreamSource(simpleTest.xmlName), |
| new StreamResult(outNames.nextName())); |
| fileChecker.check(reporter, |
| new File(outNames.currentName()), |
| new File(simpleTest.goldName), |
| "transform(#3) identity into: " + outNames.currentName()); |
| |
| transformer = factory.newTransformer(new StreamSource(multiTest.inputName)); |
| transformer.setErrorListener(new DefaultErrorHandler()); |
| // Re-use the transformer multiple times on file with variable |
| transformer.transform(new StreamSource(multiTest.xmlName), |
| new StreamResult(outNames.nextName())); |
| fileChecker.check(reporter, |
| new File(outNames.currentName()), |
| new File(multiTest.goldName), |
| "transform(#1-a) var test into: " + outNames.currentName()); |
| |
| transformer.transform(new StreamSource(multiTest.xmlName), |
| new StreamResult(outNames.nextName())); |
| fileChecker.check(reporter, |
| new File(outNames.currentName()), |
| new File(multiTest.goldName), |
| "transform(#2-a) var test into: " + outNames.currentName()); |
| |
| // Reset the transformer to its original state |
| transformer.reset(); |
| |
| transformer.transform(new StreamSource(multiTest.xmlName), |
| new StreamResult(outNames.nextName())); |
| fileChecker.check(reporter, |
| new File(outNames.currentName()), |
| new File(multiTest.goldName), |
| "transform(#3-a) var test into: " + outNames.currentName()); |
| |
| // Now re-use with different xml doc |
| transformer.transform(new StreamSource(multi2Test.xmlName), |
| new StreamResult(outNames.nextName())); |
| fileChecker.check(reporter, |
| new File(outNames.currentName()), |
| new File(multi2Test.goldName), |
| "transform(#4-b) var test into: " + outNames.currentName()); |
| |
| // Reset the transformer to its original state |
| transformer.reset(); |
| |
| // Now re-use with original xml doc |
| transformer.transform(new StreamSource(multiTest.xmlName), |
| new StreamResult(outNames.nextName())); |
| fileChecker.check(reporter, |
| new File(outNames.currentName()), |
| new File(multiTest.goldName), |
| "transform(#5-a) var test into: " + outNames.currentName()); |
| } |
| catch (Throwable t) |
| { |
| reporter.logThrowable(reporter.WARNINGMSG, t, "Multiple transform() calls threw"); |
| reporter.checkErr("Multiple transform() calls threw: " + t.toString()); |
| } |
| reporter.testCaseClose(); |
| return true; |
| } |
| |
| /** |
| * TRAX Transformer: cover set/getURIResolver() API; |
| * plus set/getErrorListener() API. |
| * |
| * Note: These are simply coverage tests for these api's, |
| * for feature testing see links below |
| * |
| * @see ErrorListenerTest |
| * @see ErrorListenerAPITest |
| * @see URIResolverTest |
| * @return false if we should abort the test |
| */ |
| public boolean testCase6() |
| { |
| reporter.testCaseInit( |
| "TRAX Transformer: cover transform() and set/getURIResolver API and functionality"); |
| TransformerFactory factory = null; |
| Templates templates = null; |
| try |
| { |
| factory = TransformerFactory.newInstance(); |
| // Grab a stylesheet to use for this testcase |
| factory.setErrorListener(new DefaultErrorHandler()); |
| templates = factory.newTemplates(new StreamSource(simpleTest.inputName)); |
| } |
| catch (Throwable t) |
| { |
| reporter.checkErr("Can't continue testcase, factory.newInstance threw: " + t.toString()); |
| reporter.logThrowable(reporter.STATUSMSG, t, "Can't continue testcase, factory.newInstance threw:"); |
| return true; |
| } |
| |
| try |
| { |
| Transformer transformer = templates.newTransformer(); |
| ErrorListener errListener = transformer.getErrorListener(); // SPR SCUU4R3K6G - is null |
| if (errListener == null) |
| { |
| reporter.checkFail("getErrorListener() non-null by default"); |
| } |
| else |
| { |
| reporter.checkPass("getErrorListener() non-null by default, is: " + errListener); |
| } |
| |
| LoggingErrorListener loggingErrListener = new LoggingErrorListener(reporter); |
| transformer.setErrorListener(loggingErrListener); |
| reporter.checkObject(transformer.getErrorListener(), loggingErrListener, "set/getErrorListener API coverage(1)"); |
| try |
| { |
| transformer.setErrorListener(null); |
| reporter.checkFail("setErrorListener(null) worked, should have thrown exception"); |
| } |
| catch (IllegalArgumentException iae) |
| { |
| reporter.checkPass("setErrorListener(null) properly threw: " + iae.toString()); |
| } |
| // Verify the previous ErrorListener is still set |
| reporter.checkObject(transformer.getErrorListener(), loggingErrListener, "set/getErrorListener API coverage(2)"); |
| } |
| catch (Throwable t) |
| { |
| reporter.checkErr("Coverage of get/setErrorListener threw: " + t.toString()); |
| reporter.logThrowable(reporter.STATUSMSG, t, "Coverage of get/setErrorListener threw:"); |
| } |
| reporter.logStatusMsg("@todo feature testing for ErrorListener; see ErrorListenerTest, ErrorListenerAPITest"); |
| |
| try |
| { |
| Transformer transformer = templates.newTransformer(); |
| transformer.setErrorListener(new DefaultErrorHandler()); |
| // URIResolver should be null by default; try to set/get one |
| reporter.checkObject(transformer.getURIResolver(), null, "getURIResolver is null by default"); |
| LoggingURIResolver myURIResolver = new LoggingURIResolver(reporter); |
| transformer.setURIResolver(myURIResolver); |
| reporter.checkObject(transformer.getURIResolver(), myURIResolver, "set/getURIResolver API coverage"); |
| reporter.logTraceMsg("myURIres.getQuickCounters = " + myURIResolver.getQuickCounters()); |
| |
| // Assumes we support Streams |
| FileOutputStream fos = new FileOutputStream(outNames.nextName()); |
| if (doTransform(transformer, |
| new StreamSource(simpleTest.xmlName), |
| new StreamResult(fos))) |
| { |
| fos.close(); // must close ostreams we own |
| fileChecker.check(reporter, |
| new File(outNames.currentName()), |
| new File(simpleTest.goldName), |
| "transform(Stream, Stream) into: " + outNames.currentName()); |
| } |
| reporter.logTraceMsg("myURIres.getQuickCounters = " + myURIResolver.getQuickCounters()); |
| |
| reporter.logStatusMsg("@todo feature testing for URIResolver; see URIResolverTest"); |
| } |
| catch (Throwable t) |
| { |
| reporter.logThrowable(reporter.ERRORMSG, t, "TestCase threw:"); |
| reporter.checkFail("TestCase threw: " + t.toString()); |
| } |
| reporter.testCaseClose(); |
| return true; |
| } |
| |
| |
| /** |
| * Worker method performs transforms (and catches exceptions, etc.) |
| * Side effect: checkFail() if exception thrown |
| * |
| * @param Transformer to use |
| * @param Source to pull in XML from |
| * @param Result to put output in; may be modified |
| * @return false if exception thrown, true otherwise |
| */ |
| public boolean doTransform(Transformer t, Source s, Result r) |
| { |
| try |
| { |
| t.transform(s, r); |
| return true; |
| } |
| catch (TransformerException e) |
| { |
| reporter.checkFail("doTransform threw: " + e.toString()); |
| reporter.logThrowable(reporter.ERRORMSG, e, "doTransform threw:"); |
| return false; |
| } |
| } |
| |
| /** |
| * Datalet for output property testing. |
| * Fields: transformer, propName, (expectedValue|expectedException) |
| */ |
| public class GetOutputPropertyDatalet implements Datalet |
| { |
| public GetOutputPropertyDatalet() {} // no-op |
| public GetOutputPropertyDatalet(String[] args) |
| { |
| load(args); |
| } |
| public final String IDENTITY = "identity"; |
| public final String NULL_VALUE_EXPECTED = "NULL_VALUE_EXPECTED"; |
| protected String description = "no data"; |
| public String getDescription() { return description; } |
| public void setDescription(String d) { description = d; } |
| public Transformer transformer = null; |
| public String propName = null; |
| public String expectedValue = null; |
| public String expectedException = null; |
| public void load(String[] args) |
| { |
| try |
| { |
| if (IDENTITY.equals(args[0])) |
| transformer = (TransformerFactory.newInstance()).newTransformer(); |
| else |
| transformer = (TransformerFactory.newInstance()).newTransformer(new StreamSource(args[0])); |
| propName = args[1]; |
| String tmp = args[2]; |
| // Semi-hack: if it looks like the FQCN of a |
| // Throwable derivative, then use one |
| // of those; otherwise, assume it's the expected |
| // value to get back from getOutputProperty |
| if ((tmp.indexOf("Exception") >= 0) || (tmp.indexOf("Error") >= 0)) |
| expectedException = tmp; |
| else |
| expectedValue = tmp; |
| } |
| catch (Throwable t) |
| { /* no-op, let it fail elsewhere */ |
| } |
| } |
| public void load(Hashtable h) |
| { |
| transformer = (Transformer)h.get("transformer"); |
| propName = (String)h.get("propName"); |
| expectedValue = (String)h.get("expectedValue "); |
| expectedException = (String)h.get("expectedException"); |
| } |
| |
| } // end class GetOutputPropertyDatalet |
| |
| /** |
| * Calls getOutputProperty() on the Transformer supplied, and |
| * then either validates the returned String, or the classname |
| * of any exception thrown. |
| * |
| * This is almost more complex to implement as a Testlet than |
| * is really worth it, but I wanted to experiment with using one. |
| */ |
| public class GetOutputPropertyTestlet extends TestletImpl |
| { |
| { thisClassName = "org.apache.qetest.xsl.GetOutputPropertyTestlet"; } |
| public String getDescription() { return "gets OutputProperty and validates"; } |
| public Datalet getDefaultDatalet() |
| { |
| return new GetOutputPropertyDatalet(new String[] { "identity", "method", "xml" }); |
| } |
| public void execute(Datalet d) |
| { |
| GetOutputPropertyDatalet datalet = null; |
| try |
| { |
| datalet = (GetOutputPropertyDatalet)d; |
| } |
| catch (ClassCastException e) |
| { |
| logger.checkErr("Datalet provided is not a GetOutputPropertyDatalet; cannot continue"); |
| return; |
| } |
| try |
| { |
| // Perform the test |
| String val = datalet.transformer.getOutputProperty(datalet.propName); |
| // Validate non-throwing of expected exceptions |
| if (null != datalet.expectedException) |
| { |
| logger.checkFail(datalet.getDescription() + ", did not throw:" + datalet.expectedException |
| + ", act:" + val); |
| return; |
| } |
| |
| // Validate any return data |
| if (null != val) |
| { |
| // Check for positive values that exist |
| if ((null != datalet.expectedValue) |
| && datalet.expectedValue.equals(val)) |
| logger.checkPass(datalet.getDescription()); |
| else |
| logger.checkFail(datalet.getDescription() + " act:" + val |
| + ", exp:" + datalet.expectedValue); |
| } |
| else if (datalet.NULL_VALUE_EXPECTED == datalet.expectedValue) |
| { |
| // If expectedValue is the special 'null' string, |
| // and we're not expecting an exception, then |
| // we pass here |
| logger.checkPass(datalet.getDescription()); |
| } |
| else |
| { |
| // Otherwise, we fail |
| logger.checkFail(datalet.getDescription() + " act:" + val |
| + ", exp:" + datalet.expectedValue); |
| } |
| } |
| catch (Throwable t) |
| { |
| // Validate any Exceptions thrown |
| if (null != datalet.expectedException) |
| { |
| if (datalet.expectedException.equals(t.getClass().getName())) |
| logger.checkPass(datalet.getDescription()); |
| else |
| logger.checkFail(datalet.getDescription() + ", threw:" + t.toString() |
| + ", exp:" + datalet.expectedException); |
| } |
| else |
| logger.checkFail(datalet.getDescription() + ", threw: " + t.toString()); |
| } |
| } |
| } // end class GetOutputPropertyTestlet |
| |
| /** |
| * Convenience method to print out usage information - update if needed. |
| * @return usage string |
| */ |
| public String usage() |
| { |
| return ("Common [optional] options supported by TransformerAPITest:\n" |
| + "(Note: assumes inputDir=.\\tests\\api)\n" |
| + "-processorClassname classname.of.processor (to override setPlatformDefaultProcessor to Xalan 2.x)\n" |
| + super.usage()); |
| } |
| |
| /** |
| * 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) |
| { |
| TransformerAPITest app = new TransformerAPITest(); |
| app.doMain(args); |
| } |
| |
| // Android-added: Run main method as a JUnit test case. |
| @Test |
| public void main() { |
| main(new String[0]); |
| } |
| } |
