Файл: XMLUnit-Java.pdf

Example 1.1 Configuring JAXP via System Properties

System.setProperty("javax.xml.parsers.DocumentBuilderFactory",

"org.apache.xerces.jaxp.DocumentBuilderFactoryImpl");

System.setProperty("javax.xml.parsers.SAXParserFactory",

"org.apache.xerces.jaxp.SAXParserFactoryImpl");

System.setProperty("javax.xml.transform.TransformerFactory",

"org.apache.xalan.processor.TransformerFactoryImpl");

You may want to read Section 2.4.1 for more details - in particular if you are using Java 1.4 or later.

Alternatively there are static methods on the XMLUnit class that can be called directly. The advantage of this approach is that you can specify a different parser class for control and test XML and change the current parser class at any time in your tests, should you need to make assertions about the compatibility of different parsers.

Example 1.2 Configuring JAXP via XMLUnit class

XMLUnit.setControlParser("org.apache.xerces.jaxp.DocumentBuilderFactoryImpl");

XMLUnit.setTestParser("org.apache.xerces.jaxp.DocumentBuilderFactoryImpl");

XMLUnit.setSAXParserFactory("org.apache.xerces.jaxp.SAXParserFactoryImpl");

XMLUnit.setTransformerFactory("org.apache.xalan.processor.TransformerFactoryImpl");

1.5Writing XML comparison tests

Let’s say we have two pieces of XML that we wish to compare and assert that they are equal. We could write a simple test class like this:

Example 1.3 A simple comparison test

public class MyXMLTestCase extends XMLTestCase { public MyXMLTestCase(String name) {

super(name);

}

public void testForEquality() throws Exception {

String myControlXML = "<msg><uuid>0x00435A8C</uuid></msg>"; String myTestXML = "<msg><localId>2376</localId></msg>"; assertXMLEqual("Comparing test xml to control xml",

myControlXML, myTestXML);

}

}

The assertXMLEqual test will pass if the control and test XML are either similar or identical. Obviously in this case the pieces of XML are different and the test will fail. The failure message indicates both what the difference is and the XPath locations of the nodes that were being compared:

When comparing pieces of XML, the XMLTestCase actually creates an instance of the Diff class. The Diff class stores the result of an XML comparison and makes it available through the methods similar() and identical(). The asser tXMLEqual() method tests the value of Diff.similar() and the assertXMLIdentical() method tests the value of

Diff.identical().

It is easy to create a Diff instance directly without using the XMLTestCase class as below:

Example 1.4 Creating a Diff instance

public void testXMLIdentical()throws Exception { String myControlXML =

"<struct><int>3</int><boolean>false</boolean></struct>"; String myTestXML =

"<struct><boolean>false</boolean><int>3</int></struct>"; Diff myDiff = new Diff(myControlXML, myTestXML); assertTrue("XML similar " + myDiff.toString(),

myDiff.similar());

assertTrue("XML identical " + myDiff.toString(), myDiff.identical());

}

This test fails as two pieces of XML are similar but not identical if their nodes occur in a different sequence. The failure message reported by JUnit from the call to myDiff.toString() looks like this:

For efficiency reasons a Diff stops the comparison process as soon as the first difference is found. To get all the differences between two pieces of XML an instance of the DetailedDiff class, a subclass of Diff, is required. Note that a Detailed Diff is constructed using an existing Diff instance.

Consider this test that uses a DetailedDiff:

Example 1.5 Using DetailedDiff

public void testAllDifferences() throws Exception {

String myControlXML = "<news><item id=\"1\">War</item>"

+"<item id=\"2\">Plague</item>"

+"<item id=\"3\">Famine</item></news>";

String myTestXML = "<news><item id=\"1\">Peace</item>"

+"<item id=\"2\">Health</item>"

+"<item id=\"3\">Plenty</item></news>";

DetailedDiff myDiff = new DetailedDiff(new Diff(myControlXML, myTestXML)); List allDifferences = myDiff.getAllDifferences(); assertEquals(myDiff.toString(), 2, allDifferences.size());

}

This test fails with the message below as each of the 3 news items differs between the control and test XML:

The List returned from the getAllDifferences() method contains Difference instances. These instances describe both the type4 of difference found between a control node and test node and the NodeDetail of those nodes (including the XPath location of each node). Difference instances are passed at runtime in notification events to a registered DifferenceList ener, an interface whose default implementation is provided by the Diff class.

However it is possible to override this default behaviour by implementing the interface in your own class. The IgnoreTextAnd AttributeValuesDifferenceListener class is an example of how to implement a custom DifferenceListener.

4 A full set of prototype Difference instances - one for each type of difference - is defined using final static fields in the DifferenceConstants class.

Example 1.8 Testing the Result of a Transformation

public void testXSLTransformation() throws Exception { String myInputXML = "...";

File myStylesheetFile = new File("...");

Transform myTransform = new Transform(myInputXML, myStylesheetFile); String myExpectedOutputXML = "...";

Diff myDiff = new Diff(myExpectedOutputXML, myTransform); assertTrue("XSL transformation worked as expected", myDiff.similar());

}

The getResultString() and getResultDocument() methods of the Transform class can be used to access the result of the XSLT transformation programmatically if required, for example as below:

Example 1.9 Using Transform programmatically

public void testAnotherXSLTransformation() throws Exception { File myInputXMLFile = new File("...");

File myStylesheetFile = new File("..."); Transform myTransform = new Transform(

new StreamSource(myInputXMLFile), new StreamSource(myStylesheetFile));

Document myExpectedOutputXML = XMLUnit.buildDocument(XMLUnit.getControlParser(),

new FileReader("...")); Diff myDiff = new Diff(myExpectedOutputXML, myTransform.getResultDocument());

assertTrue("XSL transformation worked as expected", myDiff.similar());

}

1.7Validation Tests

XML parsers that validate a piece of XML against a DTD are common, however they rely on a DTD reference being present in the XML, and they can only validate against a single DTD. When writing a system that exchanges XML messages with third parties there are times when you would like to validate the XML against a DTD that is not available to the recipient of the message and so cannot be referenced in the message itself. XMLUnit provides a Validator class for this purpose.

Example 1.10 Validating Against a DTD

public void testValidation() throws Exception { XMLUnit.getTestDocumentBuilderFactory().setValidating(true);

// As the document is parsed it is validated against its referenced DTD Document myTestDocument = XMLUnit.buildTestDocument("...");

String mySystemId = "...";

String myDTDUrl = new File("...").toURL().toExternalForm(); Validator myValidator = new Validator(myTestDocument, mySystemId,

myDTDUrl); assertTrue("test document validates against unreferenced DTD",

myValidator.isValid());

}

Starting with XMLUnit 1.1, the Validator class can also validate against one or more XML Schema definitions. See Section 4.1.2 for details.

XMLUnit 1.2 introduces a new Validator class that relies on JAXP 1.3’s javax.xml.validation package. This Validator can validate against W3C XML Schema, but may support different Schema languages like RELAX NG if your JAXP implementation supports it. See Section 4.4 for details.