diff options
Diffstat (limited to 'xml')
| -rw-r--r-- | xml/src/test/java/org/apache/harmony/xml/XsltXPathConformanceTestSuite.java | 484 |
1 files changed, 484 insertions, 0 deletions
diff --git a/xml/src/test/java/org/apache/harmony/xml/XsltXPathConformanceTestSuite.java b/xml/src/test/java/org/apache/harmony/xml/XsltXPathConformanceTestSuite.java new file mode 100644 index 0000000..7773814 --- /dev/null +++ b/xml/src/test/java/org/apache/harmony/xml/XsltXPathConformanceTestSuite.java @@ -0,0 +1,484 @@ +/* + * Copyright (C) 2010 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.harmony.xml; + +import junit.framework.Assert; +import junit.framework.AssertionFailedError; +import junit.framework.Test; +import junit.framework.TestCase; +import junit.framework.TestSuite; +import junit.textui.TestRunner; +import org.w3c.dom.Attr; +import org.w3c.dom.Comment; +import org.w3c.dom.Document; +import org.w3c.dom.Element; +import org.w3c.dom.NamedNodeMap; +import org.w3c.dom.Node; +import org.w3c.dom.NodeList; +import org.w3c.dom.ProcessingInstruction; +import org.w3c.dom.Text; +import org.xml.sax.SAXException; +import org.xmlpull.v1.XmlPullParserException; +import org.xmlpull.v1.XmlPullParserFactory; +import org.xmlpull.v1.XmlSerializer; + +import javax.xml.parsers.DocumentBuilder; +import javax.xml.parsers.DocumentBuilderFactory; +import javax.xml.parsers.ParserConfigurationException; +import javax.xml.transform.Result; +import javax.xml.transform.Source; +import javax.xml.transform.Transformer; +import javax.xml.transform.TransformerConfigurationException; +import javax.xml.transform.TransformerFactory; +import javax.xml.transform.dom.DOMResult; +import javax.xml.transform.stream.StreamSource; +import java.io.File; +import java.io.FileInputStream; +import java.io.FileNotFoundException; +import java.io.IOException; +import java.io.StringWriter; +import java.util.ArrayList; +import java.util.Collections; +import java.util.Comparator; +import java.util.List; + +/** + * The <a href="http://www.oasis-open.org/committees/tc_home.php?wg_abbrev=xslt">OASIS + * XSLT conformance test suite</a>, adapted for use by JUnit. To run these tests + * on a device: + * <ul> + * <li>Obtain the <a href="http://www.oasis-open.org/committees/download.php/12171/XSLT-testsuite-04.ZIP">test + * suite zip file from the OASIS project site.</li> + * <li>Unzip. + * <li>Copy the files to a device: <code>adb shell mkdir /data/oasis ; + * adb push ./XSLT-Conformance-TC /data/oasis</code>. + * <li>Invoke this class' main method, passing the on-device path to the test + * suite's <code>catalog.xml</code> file as an argument. + * </ul> + */ +public class XsltXPathConformanceTestSuite { + + private static final String defaultCatalogFile + = "/home/dalvik-prebuild/OASIS/XSLT-Conformance-TC/TESTS/catalog.xml"; + + /** Orders element attributes by optional URI and name. */ + private static final Comparator<Attr> orderByName = new Comparator<Attr>() { + public int compare(Attr a, Attr b) { + int result = compareNullsFirst(a.getBaseURI(), b.getBaseURI()); + return result == 0 ? result + : compareNullsFirst(a.getName(), b.getName()); + } + + <T extends Comparable<T>> int compareNullsFirst(T a, T b) { + return (a == b) ? 0 + : (a == null) ? -1 + : (b == null) ? 1 + : a.compareTo(b); + } + }; + + private final DocumentBuilder documentBuilder; + private final TransformerFactory transformerFactory; + private final XmlPullParserFactory xmlPullParserFactory; + + public XsltXPathConformanceTestSuite() + throws ParserConfigurationException, XmlPullParserException { + DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance(); + factory.setNamespaceAware(true); + factory.setCoalescing(true); + documentBuilder = factory.newDocumentBuilder(); + + transformerFactory = TransformerFactory.newInstance(); + xmlPullParserFactory = XmlPullParserFactory.newInstance(); + } + + public static void main(String[] args) throws Exception { + if (args.length != 1) { + System.out.println("Usage: XsltXPathConformanceTestSuite <catalog-xml>"); + System.out.println(); + System.out.println(" catalog-xml: an XML file describing an OASIS test suite"); + System.out.println(" such as: " + defaultCatalogFile); + return; + } + + File catalogXml = new File(args[0]); + TestRunner.run(suite(catalogXml)); + } + + public static Test suite() throws Exception { + return suite(new File(defaultCatalogFile)); + } + + /** + * Returns a JUnit test suite for the tests described by the given document. + */ + public static Test suite(File catalogXml) throws Exception { + XsltXPathConformanceTestSuite suite = new XsltXPathConformanceTestSuite(); + + /* + * Extract the tests from an XML document with the following structure: + * + * <test-suite> + * <test-catalog submitter="Lotus"> + * <creator>Lotus/IBM</creator> + * <major-path>Xalan_Conformance_Tests</major-path> + * <date>2001-11-16</date> + * <test-case ...> ... </test-case> + * <test-case ...> ... </test-case> + * <test-case ...> ... </test-case> + * </test-catalog> + * </test-suite> + */ + + Document document = DocumentBuilderFactory.newInstance() + .newDocumentBuilder().parse(catalogXml); + Element testSuiteElement = document.getDocumentElement(); + TestSuite result = new TestSuite(); + for (Element testCatalog : elementsOf(testSuiteElement.getElementsByTagName("test-catalog"))) { + Element majorPathElement = (Element) testCatalog.getElementsByTagName("major-path").item(0); + String majorPath = majorPathElement.getTextContent(); + File base = new File(catalogXml.getParentFile(), majorPath); + + for (Element testCaseElement : elementsOf(testCatalog.getElementsByTagName("test-case"))) { + result.addTest(suite.create(base, testCaseElement)); + } + } + + return result; + } + + /** + * Returns a JUnit test for the test described by the given element. + */ + private Test create(File base, Element testCaseElement) { + + /* + * Extract the XSLT test from a DOM entity with the following structure: + * + * <test-case category="XSLT-Result-Tree" id="attribset_attribset01"> + * <file-path>attribset</file-path> + * <creator>Paul Dick</creator> + * <date>2001-11-08</date> + * <purpose>Set attribute of a LRE from single attribute set.</purpose> + * <spec-citation place="7.1.4" type="section" version="1.0" spec="xslt"/> + * <scenario operation="standard"> + * <input-file role="principal-data">attribset01.xml</input-file> + * <input-file role="principal-stylesheet">attribset01.xsl</input-file> + * <output-file role="principal" compare="XML">attribset01.out</output-file> + * </scenario> + * </test-case> + */ + + Element filePathElement = (Element) testCaseElement.getElementsByTagName("file-path").item(0); + Element purposeElement = (Element) testCaseElement.getElementsByTagName("purpose").item(0); + Element specCitationElement = (Element) testCaseElement.getElementsByTagName("spec-citation").item(0); + Element scenarioElement = (Element) testCaseElement.getElementsByTagName("scenario").item(0); + + String category = testCaseElement.getAttribute("category"); + String id = testCaseElement.getAttribute("id"); + String name = category + "." + id; + String purpose = purposeElement != null ? purposeElement.getTextContent() : ""; + String spec = "place=" + specCitationElement.getAttribute("place") + + " type" + specCitationElement.getAttribute("type") + + " version=" + specCitationElement.getAttribute("version") + + " spec=" + specCitationElement.getAttribute("spec"); + String operation = scenarioElement.getAttribute("operation"); + + Element principalDataElement = null; + Element principalStylesheetElement = null; + Element principalElement = null; + + for (Element element : elementsOf(scenarioElement.getChildNodes())) { + String role = element.getAttribute("role"); + if (role.equals("principal-data")) { + principalDataElement = element; + } else if (role.equals("principal-stylesheet")) { + principalStylesheetElement = element; + } else if (role.equals("principal")) { + principalElement = element; + } else if (!role.equals("supplemental-stylesheet") + && !role.equals("supplemental-data")) { + return new MisspecifiedTest("Unexpected element at " + name); + } + } + + String testDirectory = filePathElement.getTextContent(); + File inBase = new File(base, testDirectory); + File outBase = new File(new File(base, "REF_OUT"), testDirectory); + + if (principalDataElement == null || principalStylesheetElement == null) { + return new MisspecifiedTest("Expected <scenario> to have " + + "principal=data and principal-stylesheet elements at " + name); + } + + try { + File principalData = findFile(inBase, principalDataElement.getTextContent()); + File principalStylesheet = findFile(inBase, principalStylesheetElement.getTextContent()); + + final File principal; + final String compareAs; + if (!operation.equals("execution-error")) { + if (principalElement == null) { + return new MisspecifiedTest("Expected <scenario> to have principal element at " + name); + } + + principal = findFile(outBase, principalElement.getTextContent()); + compareAs = principalElement.getAttribute("compare"); + } else { + principal = null; + compareAs = null; + } + + return new XsltTest(category, id, purpose, spec, principalData, + principalStylesheet, principal, operation, compareAs); + } catch (FileNotFoundException e) { + return new MisspecifiedTest(e.getMessage() + " at " + name); + } + } + + /** + * Finds the named file in the named directory. This tries extra hard to + * avoid case-insensitive-naming problems, where the requested file is + * available in a different casing. + */ + private File findFile(File directory, String name) throws FileNotFoundException { + File file = new File(directory, name); + if (file.exists()) { + return file; + } + + for (String child : directory.list()) { + if (child.equalsIgnoreCase(name)) { + return new File(directory, child); + } + } + + throw new FileNotFoundException("Missing file: " + file); + } + + /** + * Placeholder for a test that couldn't be configured to run properly. + */ + public class MisspecifiedTest extends TestCase { + private final String message; + + MisspecifiedTest(String message) { + super("test"); + this.message = message; + } + + public void test() { + fail(message); + } + } + + /** + * Processes an input XML file with an input XSLT stylesheet and compares + * the result to an expected output file. + */ + public class XsltTest extends TestCase { + // TODO: include these in toString + private final String category; + private final String id; + private final String purpose; + private final String spec; + + private final File principalData; + private final File principalStylesheet; + private final File principal; + + /** either "standard" or "execution-error" */ + private final String operation; + + /** the syntax to compare the output file using, such as "XML" or "HTML" */ + private final String compareAs; + + XsltTest(String category, String id, String purpose, String spec, + File principalData, File principalStylesheet, File principal, + String operation, String compareAs) { + super("test"); + this.category = category; + this.id = id; + this.purpose = purpose; + this.spec = spec; + this.principalData = principalData; + this.principalStylesheet = principalStylesheet; + this.principal = principal; + this.operation = operation; + this.compareAs = compareAs; + } + + public void test() throws Exception { + if (purpose != null) { + System.out.println("Purpose: " + purpose); + } + if (spec != null) { + System.out.println("Spec: " + spec); + } + + Source xslt = new StreamSource(principalStylesheet); + Source in = new StreamSource(principalData); + + Transformer transformer; + try { + transformer = transformerFactory.newTransformer(xslt); + assertEquals("Expected transformer creation to fail", + "standard", operation); + } catch (TransformerConfigurationException e) { + if (operation.equals("execution-error")) { + return; // expected, such as in XSLT-Result-Tree.Attributes__78369 + } + AssertionFailedError failure = new AssertionFailedError(); + failure.initCause(e); + throw failure; + } + + Result result; + if (compareAs.equals("XML")) { + result = new DOMResult(); + } else { + // TODO: implement support for comparing HTML etc. + throw new UnsupportedOperationException("Cannot compare as " + compareAs); + } + + transformer.transform(in, result); + + if (compareAs.equals("XML")) { + DOMResult domResult = (DOMResult) result; + assertNodesAreEquivalent(principal, domResult.getNode()); + } + } + + @Override public String getName() { + return category + "." + id; + } + } + + /** + * Ensures both XML documents represent the same semantic data. Non-semantic + * data such as namespace prefixes, comments, and whitespace is ignored. + */ + private void assertNodesAreEquivalent(File expected, Node actual) + throws ParserConfigurationException, IOException, SAXException, + XmlPullParserException { + + Document expectedDocument = documentBuilder.parse(new FileInputStream(expected)); + String expectedString = nodeToNormalizedString(expectedDocument); + String actualString = nodeToNormalizedString(actual); + + Assert.assertEquals("Expected XML to match file " + expected, + expectedString, actualString); + } + + private String nodeToNormalizedString(Node node) + throws XmlPullParserException, IOException { + StringWriter writer = new StringWriter(); + XmlSerializer xmlSerializer = xmlPullParserFactory.newSerializer(); + xmlSerializer.setFeature("http://xmlpull.org/v1/doc/features.html#indent-output", true); + xmlSerializer.setOutput(writer); + emitNode(xmlSerializer, node); + xmlSerializer.flush(); + return writer.toString(); + } + + private void emitNode(XmlSerializer serializer, Node node) throws IOException { + if (node instanceof Element) { + Element element = (Element) node; + serializer.startTag(element.getBaseURI(), element.getLocalName()); + emitAttributes(serializer, element); + emitChildren(serializer, element); + serializer.endTag(element.getBaseURI(), element.getLocalName()); + + } else if (node instanceof Text) { + // TODO: is it okay to trim whitespace in general? This may cause + // false positives for elements like HTML's <pre> tag + String trimmed = node.getTextContent().trim(); + if (trimmed.length() > 0) { + serializer.text(trimmed); + } + + } else if (node instanceof Document) { + Document document = (Document) node; + serializer.startDocument("UTF-8", true); + emitNode(serializer, document.getDocumentElement()); + serializer.endDocument(); + + } else if (node instanceof ProcessingInstruction) { + ProcessingInstruction processingInstruction = (ProcessingInstruction) node; + String data = processingInstruction.getData(); + String target = processingInstruction.getTarget(); + serializer.processingInstruction(target + " " + data); + + } else if (node instanceof Comment) { + // ignore! + + } else { + Object nodeClass = node != null ? node.getClass() : null; + throw new UnsupportedOperationException( + "Cannot serialize nodes of type " + nodeClass); + } + } + + private void emitAttributes(XmlSerializer serializer, Node node) + throws IOException { + NamedNodeMap map = node.getAttributes(); + if (map == null) { + return; + } + + List<Attr> attributes = new ArrayList<Attr>(); + for (int i = 0; i < map.getLength(); i++) { + attributes.add((Attr) map.item(i)); + } + Collections.sort(attributes, orderByName); + + for (Attr attr : attributes) { + if ("xmlns".equals(attr.getPrefix()) || "xmlns".equals(attr.getLocalName())) { + /* + * Omit namespace declarations because they aren't considered + * data. Ie. <foo:a xmlns:bar="http://google.com"> is semantically + * equal to <bar:a xmlns:bar="http://google.com"> since the + * prefix doesn't matter, only the URI it points to. + * + * When we omit the prefix, our XML serializer will still + * generate one for us, using a predictable pattern. + */ + } else { + serializer.attribute(attr.getBaseURI(), attr.getLocalName(), attr.getValue()); + } + } + } + + private void emitChildren(XmlSerializer serializer, Node node) + throws IOException { + NodeList childNodes = node.getChildNodes(); + for (int i = 0; i < childNodes.getLength(); i++) { + emitNode(serializer, childNodes.item(i)); + } + } + + private static List<Element> elementsOf(NodeList nodeList) { + List<Element> result = new ArrayList<Element>(); + for (int i = 0; i < nodeList.getLength(); i++) { + Node node = nodeList.item(i); + if (node instanceof Element) { + result.add((Element) node); + } + } + return result; + } +} |