diff options
Diffstat (limited to 'test/java/src/org/apache/qetest/trax/TransformerAPITest.java')
| -rw-r--r-- | test/java/src/org/apache/qetest/trax/TransformerAPITest.java | 1315 |
1 files changed, 1315 insertions, 0 deletions
diff --git a/test/java/src/org/apache/qetest/trax/TransformerAPITest.java b/test/java/src/org/apache/qetest/trax/TransformerAPITest.java new file mode 100644 index 0000000..fa0cf36 --- /dev/null +++ b/test/java/src/org/apache/qetest/trax/TransformerAPITest.java @@ -0,0 +1,1315 @@ +/* + * 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; + +//------------------------------------------------------------------------- + +/** + * 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); + } +} |