xmlUnit1.5 Comparison
郗鹏
xmlunit 用来对比不同的xml content是否相同。你可以ignore withspace和order.
下面是一个例子：
XMLUnit.setIgnoreWhitespace(true);
XMLUnit.setIgnoreAttributeOrder(true);
DifferenceListener myDifferenceListener = new IgnoreTextAndAttributeValuesDifferenceListener();
Diff myDiff = new Diff(myControlXML, myTestXML);
myDiff.overrideDifferenceListener(myDifferenceListener);
下面是一个例子：
import java.io.IOException;
import java.io.Reader;
import java.io.StringReader;
import org.custommonkey.xmlunit.AbstractNodeTester;
import org.custommonkey.xmlunit.Diff;
import org.custommonkey.xmlunit.NodeTest;
import org.custommonkey.xmlunit.NodeTester;
import org.custommonkey.xmlunit.Validator;
import org.custommonkey.xmlunit.XMLAssert;
import org.custommonkey.xmlunit.XMLUnit;
import org.custommonkey.xmlunit.XpathEngine;
import org.custommonkey.xmlunit.exceptions.ConfigurationException;
import org.custommonkey.xmlunit.exceptions.XpathException;
import org.w3c.dom.Document;
import org.w3c.dom.Node;
import org.xml.sax.InputSource;
import org.xml.sax.SAXException;
public class XMLTestCase {
/**
* Compare XML documents provided by two InputSource classes
* @param control Control document
* @param test Document to test
* @return Diff object describing differences in documents
* @throws SAXException
* @throws IOException
*/
public Diff compareXML(InputSource control, InputSource test)
throws SAXException, IOException {
return XMLUnit.compareXML(control, test);
}
/**
* Compare XML documents provided by two Reader classes
* @param control Control document
* @param test Document to test
* @return Diff object describing differences in documents
* @throws SAXException
* @throws IOException
*/
public Diff compareXML(Reader control, Reader test)
throws SAXException, IOException {
return XMLUnit.compareXML(control, test);
}
/**
* Compare XML documents provided by two Reader classes
* @param control Control document
* @param test Document to test
* @return Diff object describing differences in documents
* @throws SAXException
* @throws IOException
*/
public Diff compareXML(String control, Reader test)
throws SAXException, IOException {
return XMLUnit.compareXML(new StringReader(control), test);
}
/**
* Compare XML documents provided by two Reader classes
* @param control Control document
* @param test Document to test
* @return Diff object describing differences in documents
* @throws SAXException
* @throws IOException
*/
public Diff compareXML(Reader control, String test)
throws SAXException, IOException {
return XMLUnit.compareXML(control, new StringReader(test));
}
/**
* Compare two XML documents provided as strings
* @param control Control document
* @param test Document to test
* @return Diff object describing differences in documents
* @throws SAXException
* @throws IOException
*/
public Diff compareXML(String control, String test)
throws SAXException, IOException {
return XMLUnit.compareXML(control, test);
}
/**
* Compare two XML documents provided as strings
* @param control Control document
* @param test Document to test
* @return Diff object describing differences in documents
*/
public Diff compareXML(Document control, Document test) {
return XMLUnit.compareXML(control, test);
}
/**
* Assert that the result of an XML comparison is or is not similar.
* @param diff the result of an XML comparison
* @param assertion true if asserting that result is similar
*/
public void assertXMLEqual(Diff diff, boolean assertion) {
XMLAssert.assertXMLEqual(diff, assertion);
}
/**
* Assert that the result of an XML comparison is or is not similar.
* @param msg additional message to display if assertion fails
* @param diff the result of an XML comparison
* @param assertion true if asserting that result is similar
*/
public void assertXMLEqual(String msg, Diff diff, boolean assertion) {
XMLAssert.assertXMLEqual(msg, diff, assertion);
}
/**
* Assert that the result of an XML comparison is or is not identical
* @param diff the result of an XML comparison
* @param assertion true if asserting that result is identical
*/
public void assertXMLIdentical(Diff diff, boolean assertion) {
XMLAssert.assertXMLIdentical(diff.toString(), diff, assertion);
}
/**
* Assert that the result of an XML comparison is or is not identical
* @param msg Message to display if assertion fails
* @param diff the result of an XML comparison
* @param assertion true if asserting that result is identical
*/
public void assertXMLIdentical(String msg, Diff diff, boolean assertion) {
XMLAssert.assertXMLIdentical(msg, diff, assertion);
}
/**
* Assert that two XML documents are similar
* @param control XML to be compared against
* @param test XML to be tested
* @throws SAXException
* @throws IOException
*/
public void assertXMLEqual(InputSource control, InputSource test)
throws SAXException, IOException {
XMLAssert.assertXMLEqual(control, test);
}
/**
* Assert that two XML documents are similar
* @param control XML to be compared against
* @param test XML to be tested
* @throws SAXException
* @throws IOException
*/
public void assertXMLEqual(String control, String test)
throws SAXException, IOException {
XMLAssert.assertXMLEqual(control, test);
}
/**
* Assert that two XML documents are similar
* @param control XML to be compared against
* @param test XML to be tested
*/
public void assertXMLEqual(Document control, Document test) {
XMLAssert.assertXMLEqual(control, test);
}
/**
* Assert that two XML documents are similar
* @param control XML to be compared against
* @param test XML to be tested
* @throws SAXException
* @throws IOException
*/
public void assertXMLEqual(Reader control, Reader test)
throws SAXException, IOException {
XMLAssert.assertXMLEqual(control, test);
}
/**
* Assert that two XML documents are similar
* @param err Message to be displayed on assertion failure
* @param control XML to be compared against
* @param test XML to be tested
* @throws SAXException
* @throws IOException
*/
public void assertXMLEqual(String err, String control, String test)
throws SAXException, IOException {
XMLAssert.assertXMLEqual(err, control, test);
}
/**
* Assert that two XML documents are similar
* @param err Message to be displayed on assertion failure
* @param control XML to be compared against
* @param test XML to be tested
* @throws SAXException
* @throws IOException
*/
public void assertXMLEqual(String err, InputSource control,
InputSource test)
throws SAXException, IOException {
XMLAssert.assertXMLEqual(err, control, test);
}
/**
* Assert that two XML documents are similar
* @param err Message to be displayed on assertion failure
* @param control XML to be compared against
* @param test XML to be tested
*/
public void assertXMLEqual(String err, Document control, Document test) {
XMLAssert.assertXMLEqual(err, control, test);
}
/**
* Assert that two XML documents are similar
* @param err Message to be displayed on assertion failure
* @param control XML to be compared against
* @param test XML to be tested
* @throws SAXException
* @throws IOException
*/
public void assertXMLEqual(String err, Reader control, Reader test)
throws SAXException, IOException {
XMLAssert.assertXMLEqual(err, control, test);
}
/**
* Assert that two XML documents are NOT similar
* @param control XML to be compared against
* @param test XML to be tested
* @throws SAXException
* @throws IOException
*/
public void assertXMLNotEqual(InputSource control, InputSource test)
throws SAXException, IOException {
XMLAssert.assertXMLNotEqual(control, test);
}
/**
* Assert that two XML documents are NOT similar
* @param control XML to be compared against
* @param test XML to be tested
* @throws SAXException
* @throws IOException
*/
public void assertXMLNotEqual(String control, String test)
throws SAXException, IOException {
XMLAssert.assertXMLNotEqual(control, test);
}
/**
* Assert that two XML documents are NOT similar
* @param control XML to be compared against
* @param test XML to be tested
*/
public void assertXMLNotEqual(Document control, Document test) {
XMLAssert.assertXMLNotEqual(control, test);
}
/**
* Assert that two XML documents are NOT similar
* @param control XML to be compared against
* @param test XML to be tested
* @throws SAXException
* @throws IOException
*/
public void assertXMLNotEqual(Reader control, Reader test)
throws SAXException, IOException {
XMLAssert.assertXMLNotEqual(control, test);
}
/**
* Assert that two XML documents are NOT similar
* @param err Message to be displayed on assertion failure
* @param control XML to be compared against
* @param test XML to be tested
* @throws SAXException
* @throws IOException
*/
public void assertXMLNotEqual(String err, InputSource control,
InputSource test)
throws SAXException, IOException {
XMLAssert.assertXMLNotEqual(err, control, test);
}
/**
* Assert that two XML documents are NOT similar
* @param err Message to be displayed on assertion failure
* @param control XML to be compared against
* @param test XML to be tested
* @throws SAXException
* @throws IOException
*/
public void assertXMLNotEqual(String err, String control, String test)
throws SAXException, IOException {
XMLAssert.assertXMLNotEqual(err, control, test);
}
/**
* Assert that two XML documents are NOT similar
* @param err Message to be displayed on assertion failure
* @param control XML to be compared against
* @param test XML to be tested
*/
public void assertXMLNotEqual(String err, Document control, Document test) {
XMLAssert.assertXMLNotEqual(err, control, test);
}
/**
* Assert that two XML documents are NOT similar
* @param err Message to be displayed on assertion failure
* @param control XML to be compared against
* @param test XML to be tested
* @throws SAXException
* @throws IOException
*/
public void assertXMLNotEqual(String err, Reader control, Reader test)
throws SAXException, IOException {
XMLAssert.assertXMLNotEqual(err, control, test);
}
/**
* Assert that the node lists of two Xpaths in the same document are equal
* @param xpathOne
* @param xpathTwo
* @param document
* @see XpathEngine
*/
public void assertXpathsEqual(String controlXpath, String testXpath,
InputSource document)
throws SAXException, IOException, XpathException {
XMLAssert.assertXpathsEqual(controlXpath, testXpath, document);
}
/**
* Assert that the node lists of two Xpaths in the same document are equal
* @param xpathOne
* @param xpathTwo
* @param document
* @see XpathEngine
*/
public void assertXpathsEqual(String controlXpath, String testXpath,
Document document)
throws XpathException {
XMLAssert.assertXpathsEqual(controlXpath, testXpath, document);
}
/**
* Assert that the node lists of two Xpaths in the same XML string are
* equal
* @param xpathOne
* @param xpathTwo
* @param inXMLString
* @throws SAXException
* @throws IOException
*/
public void assertXpathsEqual(String controlXpath, String testXpath,
String inXMLString)
throws SAXException, IOException, XpathException {
XMLAssert.assertXpathsEqual(controlXpath, testXpath, inXMLString);
}
/**
* Assert that the node lists of two Xpaths in two XML pieces are equal
* @param xpathOne
* @param control
* @param xpathTwo
* @param test
* @throws SAXException
* @throws IOException
*/
public void assertXpathsEqual(String controlXpath, InputSource control,
String testXpath, InputSource test)
throws SAXException, IOException, XpathException {
XMLAssert.assertXpathsEqual(controlXpath, control,
testXpath, test);
}
/**
* Assert that the node lists of two Xpaths in two XML strings are equal
* @param xpathOne
* @param inControlXMLString
* @param xpathTwo
* @param inTestXMLString
* @throws SAXException
* @throws IOException
*/
public void assertXpathsEqual(String controlXpath,
String inControlXMLString, String testXpath,
String inTestXMLString)
throws SAXException, IOException,
XpathException {
XMLAssert.assertXpathsEqual(controlXpath, inControlXMLString,
testXpath, inTestXMLString);
}
/**
* Assert that the node lists of two Xpaths in two documents are equal
* @param xpathOne
* @param xpathTwo
* @param document
* @see XpathEngine
*/
public void assertXpathsEqual(String controlXpath,
Document controlDocument,
String testXpath, Document testDocument)
throws XpathException {
XMLAssert.assertXpathsEqual(controlXpath, controlDocument, testXpath,
testDocument);
}
/**
* Assert that the node lists of two Xpaths in the same document are NOT equal
* @param xpathOne
* @param xpathTwo
* @param document
* @see XpathEngine
*/
public void assertXpathsNotEqual(String controlXpath, String testXpath,
Document document)
throws XpathException {
XMLAssert.assertXpathsNotEqual(controlXpath, testXpath, document);
}
/**
* Assert that the node lists of two Xpaths in the same XML are NOT
* equal
* @param xpathOne
* @param xpathTwo
* @param control
* @throws SAXException
* @throws IOException
*/
public void assertXpathsNotEqual(String controlXpath, String testXpath,
InputSource control)
throws SAXException, IOException, XpathException {
XMLAssert.assertXpathsNotEqual(controlXpath, testXpath, control);
}
/**
* Assert that the node lists of two Xpaths in the same XML string are NOT
* equal
* @param xpathOne
* @param xpathTwo
* @param inXMLString
* @throws SAXException
* @throws IOException
*/
public void assertXpathsNotEqual(String controlXpath, String testXpath,
String inXMLString)
throws SAXException,
IOException, XpathException {
XMLAssert.assertXpathsNotEqual(controlXpath, testXpath, inXMLString);
}
/**
* Assert that the node lists of two Xpaths in two pieces of XML
* are NOT equal
* @param xpathOne
* @param control
* @param xpathTwo
* @param test
* @throws SAXException
* @throws IOException
*/
public void assertXpathsNotEqual(String controlXpath, InputSource control,
String testXpath, InputSource test)
throws SAXException, IOException, XpathException {
XMLAssert.assertXpathsNotEqual(controlXpath, control, testXpath, test);
}
/**
* Assert that the node lists of two Xpaths in two XML strings are NOT equal
* @param xpathOne
* @param inControlXMLString
* @param xpathTwo
* @param inTestXMLString
* @throws SAXException
* @throws IOException
*/
public void assertXpathsNotEqual(String controlXpath,
String inControlXMLString,
String testXpath, String inTestXMLString)
throws SAXException, IOException,
XpathException {
XMLAssert.assertXpathsNotEqual(controlXpath, inControlXMLString,
testXpath, inTestXMLString);
}
/**
* Assert that the node lists of two Xpaths in two documents are NOT equal
* @param xpathOne
* @param xpathTwo
* @param document
* @see XpathEngine
*/
public void assertXpathsNotEqual(String controlXpath,
Document controlDocument,
String testXpath, Document testDocument)
throws XpathException {
XMLAssert.assertXpathsNotEqual(controlXpath, controlDocument,
testXpath, testDocument);
}
/**
* Assert that the evaluation of two Xpaths in the same document are equal
* @param xpathOne
* @param xpathTwo
* @param document
* @see XpathEngine
*/
public void assertXpathValuesEqual(String controlXpath, String testXpath,
Document document)
throws XpathException {
XMLAssert.assertXpathValuesEqual(controlXpath, testXpath, document);
}
/**
* Assert that the evaluation of two Xpaths in the same XML are
* equal
* @param xpathOne
* @param xpathTwo
* @param control
* @throws SAXException
* @throws IOException
*/
public void assertXpathValuesEqual(String controlXpath, String testXpath,
InputSource control)
throws SAXException, IOException, XpathException {
XMLAssert.assertXpathValuesEqual(controlXpath, testXpath, control);
}
/**
* Assert that the evaluation of two Xpaths in the same XML string are
* equal
* @param xpathOne
* @param xpathTwo
* @param inXMLString
* @throws SAXException
* @throws IOException
*/
public void assertXpathValuesEqual(String controlXpath, String testXpath,
String inXMLString)
throws SAXException, IOException,
XpathException {
XMLAssert.assertXpathValuesEqual(controlXpath, testXpath, inXMLString);
}
/**
* Assert that the evaluation of two Xpaths in two XML strings are equal
* @param xpathOne
* @param control
* @param xpathTwo
* @param test
* @throws SAXException
* @throws IOException
*/
public void assertXpathValuesEqual(String controlXpath,
InputSource control,
String testXpath,
InputSource test)
throws SAXException, IOException, XpathException {
XMLAssert.assertXpathValuesEqual(controlXpath, control,
testXpath, test);
}
/**
* Assert that the evaluation of two Xpaths in two XML strings are equal
* @param xpathOne
* @param inControlXMLString
* @param xpathTwo
* @param inTestXMLString
* @throws SAXException
* @throws IOException
*/
public void assertXpathValuesEqual(String controlXpath,
String inControlXMLString,
String testXpath,
String inTestXMLString)
throws SAXException, IOException,
XpathException {
XMLAssert.assertXpathValuesEqual(controlXpath, inControlXMLString,
testXpath, inTestXMLString);
}
/**
* Assert that the evaluation of two Xpaths in two documents are equal
* @param xpathOne
* @param xpathTwo
* @param document
* @see XpathEngine
*/
public void assertXpathValuesEqual(String controlXpath,
Document controlDocument,
String testXpath, Document testDocument)
throws XpathException {
XMLAssert.assertXpathValuesEqual(controlXpath, controlDocument,
testXpath, testDocument);
}
/**
* Assert that the evaluation of two Xpaths in the same XML string are
* NOT equal
* @param xpathOne
* @param xpathTwo
* @param control
* @throws SAXException
* @throws IOException
*/
public void assertXpathValuesNotEqual(String controlXpath,
String testXpath,
InputSource control)
throws SAXException, IOException, XpathException {
XMLAssert.assertXpathValuesNotEqual(controlXpath, testXpath,
control);
}
/**
* Assert that the evaluation of two Xpaths in the same XML string are
* NOT equal
* @param xpathOne
* @param xpathTwo
* @param inXMLString
* @throws SAXException
* @throws IOException
*/
public void assertXpathValuesNotEqual(String controlXpath, String testXpath,
String inXMLString)
throws SAXException, IOException,
XpathException {
XMLAssert.assertXpathValuesNotEqual(controlXpath, testXpath,
inXMLString);
}
/**
* Assert that the evaluation of two Xpaths in the same document are
* NOT equal
* @param xpathOne
* @param xpathTwo
* @param document
*/
public void assertXpathValuesNotEqual(String controlXpath, String testXpath,
Document document)
throws XpathException {
XMLAssert.assertXpathValuesNotEqual(controlXpath, testXpath, document);
}
/**
* Assert that the evaluation of two Xpaths in two XML strings are
* NOT equal
* @param xpathOne
* @param control
* @param xpathTwo
* @param test
* @throws SAXException
* @throws IOException
*/
public void assertXpathValuesNotEqual(String controlXpath,
InputSource control,
String testXpath,
InputSource test)
throws SAXException, IOException, XpathException {
XMLAssert.assertXpathValuesNotEqual(controlXpath, control,
testXpath, test);
}
/**
* Assert that the evaluation of two Xpaths in two XML strings are
* NOT equal
* @param xpathOne
* @param inControlXMLString
* @param xpathTwo
* @param inTestXMLString
* @throws SAXException
* @throws IOException
*/
public void assertXpathValuesNotEqual(String controlXpath,
String inControlXMLString,
String testXpath,
String inTestXMLString)
throws SAXException, IOException,
XpathException {
XMLAssert.assertXpathValuesNotEqual(controlXpath, inControlXMLString,
testXpath, inTestXMLString);
}
/**
* Assert that the evaluation of two Xpaths in two documents are
* NOT equal
* @param xpathOne
* @param xpathTwo
* @param document
*/
public void assertXpathValuesNotEqual(String controlXpath,
Document controlDocument,
String testXpath,
Document testDocument)
throws XpathException {
XMLAssert.assertXpathValuesNotEqual(controlXpath, controlDocument,
testXpath, testDocument);
}
/**
* Assert the value of an Xpath expression in an XML String
* @param expectedValue
* @param xpathExpression
* @param control
* @throws SAXException
* @throws IOException
* @see XpathEngine which provides the underlying evaluation mechanism
*/
public void assertXpathEvaluatesTo(String expectedValue,
String xpathExpression,
InputSource control)
throws SAXException, IOException, XpathException {
XMLAssert.assertXpathEvaluatesTo(expectedValue, xpathExpression,
control);
}
/**
* Assert the value of an Xpath expression in an XML String
* @param expectedValue
* @param xpathExpression
* @param inXMLString
* @throws SAXException
* @throws IOException
* @see XpathEngine which provides the underlying evaluation mechanism
*/
public void assertXpathEvaluatesTo(String expectedValue,
String xpathExpression,
String inXMLString)
throws SAXException, IOException,
XpathException {
XMLAssert.assertXpathEvaluatesTo(expectedValue, xpathExpression,
inXMLString);
}
/**
* Assert the value of an Xpath expression in an DOM Document
* @param expectedValue
* @param xpathExpression
* @param inDocument
* @param ctx
* @see XpathEngine which provides the underlying evaluation mechanism
*/
public void assertXpathEvaluatesTo(String expectedValue,
String xpathExpression,
Document inDocument)
throws XpathException {
XMLAssert.assertXpathEvaluatesTo(expectedValue, xpathExpression,
inDocument);
}
/**
* Assert that a specific XPath exists in some given XML
* @param inXpathExpression
* @param xml
* @see XpathEngine which provides the underlying evaluation mechanism
*/
public void assertXpathExists(String xPathExpression,
InputSource xml)
throws IOException, SAXException, XpathException {
XMLAssert.assertXpathExists(xPathExpression, xml);
}
/**
* Assert that a specific XPath exists in some given XML
* @param inXpathExpression
* @param inXMLString
* @see XpathEngine which provides the underlying evaluation mechanism
*/
public void assertXpathExists(String xPathExpression,
String inXMLString)
throws IOException, SAXException, XpathException {
XMLAssert.assertXpathExists(xPathExpression, inXMLString);
}
/**
* Assert that a specific XPath exists in some given XML
* @param inXpathExpression
* @param inDocument
* @param ctx
* @see XpathEngine which provides the underlying evaluation mechanism
*/
public void assertXpathExists(String xPathExpression, Document inDocument)
throws XpathException {
XMLAssert.assertXpathExists(xPathExpression, inDocument);
}
/**
* Assert that a specific XPath does NOT exist in some given XML
* @param inXpathExpression
* @param xml
* @see XpathEngine which provides the underlying evaluation mechanism
*/
public void assertXpathNotExists(String xPathExpression,
InputSource xml)
throws IOException, SAXException, XpathException {
XMLAssert.assertXpathNotExists(xPathExpression, xml);
}
/**
* Assert that a specific XPath does NOT exist in some given XML
* @param inXpathExpression
* @param inXMLString
* @see XpathEngine which provides the underlying evaluation mechanism
*/
public void assertXpathNotExists(String xPathExpression,
String inXMLString)
throws IOException, SAXException, XpathException {
XMLAssert.assertXpathNotExists(xPathExpression, inXMLString);
}
/**
* Assert that a specific XPath does NOT exist in some given XML
* @param inXpathExpression
* @param inDocument
* @see XpathEngine which provides the underlying evaluation mechanism
*/
public void assertXpathNotExists(String xPathExpression,
Document inDocument)
throws XpathException {
XMLAssert.assertXpathNotExists(xPathExpression, inDocument);
}
/**
* Assert that a piece of XML contains valid XML: the input must
* contain a DOCTYPE declaration to be validated
* @param xml
* @throws SAXException
* @throws ConfigurationException if validation could not be turned on
* @see Validator
*/
public void assertXMLValid(InputSource xml)
throws SAXException, ConfigurationException {
XMLAssert.assertXMLValid(xml);
}
/**
* Assert that a String containing XML contains valid XML: the String must
* contain a DOCTYPE declaration to be validated
* @param xmlString
* @throws SAXException
* @throws ConfigurationException if validation could not be turned on
* @see Validator
*/
public void assertXMLValid(String xmlString)
throws SAXException, ConfigurationException {
XMLAssert.assertXMLValid(xmlString);
}
/**
* Assert that a piece of XML contains valid XML: the document must
* contain a DOCTYPE to be validated, but the validation will use the
* systemId to obtain the DTD
* @param xml
* @param systemId
* @throws SAXException
* @throws ConfigurationException if validation could not be turned on
* @see Validator
*/
public void assertXMLValid(InputSource xml, String systemId)
throws SAXException, ConfigurationException {
XMLAssert.assertXMLValid(xml, systemId);
}
/**
* Assert that a String containing XML contains valid XML: the String must
* contain a DOCTYPE to be validated, but the validation will use the
* systemId to obtain the DTD
* @param xmlString
* @param systemId
* @throws SAXException
* @throws ConfigurationException if validation could not be turned on
* @see Validator
*/
public void assertXMLValid(String xmlString, String systemId)
throws SAXException, ConfigurationException {
XMLAssert.assertXMLValid(xmlString, systemId);
}
/**
* Assert that a piece of XML contains valid XML: the document
* will be given a DOCTYPE to be validated with the name and
* systemId specified regardless of whether it already contains a
* doctype declaration.
* @param xml
* @param systemId
* @param doctype
* @throws SAXException
* @throws ConfigurationException if validation could not be turned on
* @see Validator
*/
public void assertXMLValid(InputSource xml, String systemId,
String doctype)
throws SAXException, ConfigurationException {
XMLAssert.assertXMLValid(xml, systemId, doctype);
}
/**
* Assert that a String containing XML contains valid XML: the String will
* be given a DOCTYPE to be validated with the name and systemId specified
* regardless of whether it already contains a doctype declaration.
* @param xmlString
* @param systemId
* @param doctype
* @throws SAXException
* @throws ConfigurationException if validation could not be turned on
* @see Validator
*/
public void assertXMLValid(String xmlString, String systemId, String doctype)
throws SAXException, ConfigurationException {
XMLAssert.assertXMLValid(xmlString, systemId, doctype);
}
/**
* Assert that a Validator instance returns <code>isValid() == true</code>
* @param validator
*/
public void assertXMLValid(Validator validator) {
XMLAssert.assertXMLValid(validator);
}
/**
* Execute a <code>NodeTest<code> for a single node type
* and assert that it passes
* @param xml XML to be tested
* @param tester The test strategy
* @param nodeType The node type to be tested: constants defined
* in {@link Node org.w3c.dom.Node} e.g. <code>Node.ELEMENT_NODE</code>
* @throws SAXException
* @throws IOException
* @see AbstractNodeTester
* @see CountingNodeTester
*/
public void assertNodeTestPasses(InputSource xml, NodeTester tester,
short nodeType)
throws SAXException, IOException {
XMLAssert.assertNodeTestPasses(xml, tester, nodeType);
}
/**
* Execute a <code>NodeTest<code> for a single node type
* and assert that it passes
* @param xmlString XML to be tested
* @param tester The test strategy
* @param nodeType The node type to be tested: constants defined
* in {@link Node org.w3c.dom.Node} e.g. <code>Node.ELEMENT_NODE</code>
* @throws SAXException
* @throws IOException
* @see AbstractNodeTester
* @see CountingNodeTester
*/
public void assertNodeTestPasses(String xmlString, NodeTester tester,
short nodeType)
throws SAXException, IOException {
XMLAssert.assertNodeTestPasses(xmlString, tester, nodeType);
}
/**
* Execute a <code>NodeTest<code> for multiple node types and make an
* assertion about it whether it is expected to pass
* @param test a NodeTest instance containing the XML source to be tested
* @param tester The test strategy
* @param nodeTypes The node types to be tested: constants defined
* in {@link Node org.w3c.dom.Node} e.g. <code>Node.ELEMENT_NODE</code>
* @param assertion true if the test is expected to pass, false otherwise
* @see AbstractNodeTester
* @see CountingNodeTester
*/
public void assertNodeTestPasses(NodeTest test, NodeTester tester,
short[] nodeTypes, boolean assertion) {
XMLAssert.assertNodeTestPasses(test, tester, nodeTypes, assertion);
}
}
import java.io.File;
import java.io.FileReader;
import java.util.List;
import javax.xml.transform.stream.StreamSource;
import org.custommonkey.xmlunit.DetailedDiff;
import org.custommonkey.xmlunit.Diff;
import org.custommonkey.xmlunit.DifferenceListener;
import org.custommonkey.xmlunit.ElementNameAndTextQualifier;
import org.custommonkey.xmlunit.HTMLDocumentBuilder;
import org.custommonkey.xmlunit.IgnoreTextAndAttributeValuesDifferenceListener;
import org.custommonkey.xmlunit.TolerantSaxDocumentBuilder;
import org.custommonkey.xmlunit.Transform;
import org.custommonkey.xmlunit.Validator;
import org.custommonkey.xmlunit.XMLUnit;
import org.custommonkey.xmlunit.XpathEngine;
import org.custommonkey.xmlunit.examples.CountingNodeTester;
import org.junit.Assert;
import org.junit.Test;
import org.w3c.dom.Document;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
public class ComparisonTest extends XMLTestCase {
public static void main(String[] args) {
}
@Test
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);
assertXMLNotEqual("test xml not similar to control xml", myControlXML,
myTestXML);
}
@Test
public void testIdentical() 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);
Assert.assertTrue("pieces of XML are similar " + myDiff,
myDiff.similar());
Assert.assertFalse("but are they identical? " + myDiff,
myDiff.identical());
}
@Test
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(compareXML(myControlXML,
myTestXML));
List allDifferences = myDiff.getAllDifferences();
Assert.assertNotEquals(myDiff.toString(), 0, allDifferences.size());
}
@Test
public void testCompareToSkeletonXML() throws Exception {
String myControlXML = "<location><street-address>22 any street</street-address><postcode>XY00 99Z</postcode></location>";
String myTestXML = "<location><street-address>20 east cheap</street-address><postcode>EC3M 1EB</postcode></location>";
DifferenceListener myDifferenceListener = new IgnoreTextAndAttributeValuesDifferenceListener();
Diff myDiff = new Diff(myControlXML, myTestXML);
myDiff.overrideDifferenceListener(myDifferenceListener);
Assert.assertTrue("test XML matches control skeleton XML " + myDiff,
myDiff.similar());
}
@Test
public void testRepeatedChildElements() throws Exception {
String myControlXML = "<suite><test status=\"pass\">FirstTestCase</test><test status=\"pass\">SecondTestCase</test></suite>";
String myTestXML = "<suite><test status=\"pass\">SecondTestCase</test><test status=\"pass\">FirstTestCase</test></suite>";
assertXMLNotEqual(
"Repeated child elements in different sequence order are not equal by default",
myControlXML, myTestXML);
Diff myDiff = new Diff(myControlXML, myTestXML);
myDiff.overrideElementQualifier(new ElementNameAndTextQualifier());
assertXMLEqual(
"But they are equal when an ElementQualifier controls which test element is compared with each control element",
myDiff, true);
}
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);
Assert.assertTrue("XSL transformation worked as expected " + myDiff,
myDiff.similar());
}
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());
Assert.assertTrue("XSL transformation worked as expected " + myDiff,
myDiff.similar());
}
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);
Assert.assertTrue("test document validates against unreferenced DTD",
myValidator.isValid());
}
@Test
public void testXPaths() throws Exception {
String mySolarSystemXML = "<solar-system><planet name='Earth' position='3' supportsLife='yes'/>"
+ "<planet name='Venus' position='4'/></solar-system>";
XpathEngine simpleXpathEngine = XMLUnit.newXpathEngine();
NodeList list = simpleXpathEngine.getMatchingNodes("//planet",
XMLUnit.buildControlDocument(mySolarSystemXML));
Assert.assertTrue(list.getLength() == 2);
assertXpathExists("//planet[@name='Earth']", mySolarSystemXML);
assertXpathNotExists("//star[@name='alpha centauri']", mySolarSystemXML);
assertXpathsEqual("//planet[@name='Earth']", "//planet[@position='3']",
mySolarSystemXML);
assertXpathsNotEqual("//planet[@name='Venus']",
"//planet[@supportsLife='yes']", mySolarSystemXML);
}
public void testXPathValues() throws Exception {
String myJavaFlavours = "<java-flavours><jvm current='some platforms'>1.1.x</jvm>"
+ "<jvm current='no'>1.2.x</jvm><jvm current='yes'>1.3.x</jvm>"
+ "<jvm current='yes' latest='yes'>1.4.x</jvm></java-flavours>";
assertXpathEvaluatesTo("1.4.x", "//jvm[@latest='yes']", myJavaFlavours);
assertXpathEvaluatesTo("2", "count(//jvm[@current='yes'])",
myJavaFlavours);
assertXpathValuesEqual("//jvm[4]/@latest", "//jvm[4]/@current",
myJavaFlavours);
assertXpathValuesNotEqual("//jvm[2]/@current", "//jvm[3]/@current",
myJavaFlavours);
}
public void testXpathsInHTML() throws Exception {
String someBadlyFormedHTML = "<html><title>Ugh</title><body><h1>Heading<ul><li id='1'>Item One<li id='2'>Item Two";
TolerantSaxDocumentBuilder tolerantSaxDocumentBuilder = new TolerantSaxDocumentBuilder(
XMLUnit.getTestParser());
HTMLDocumentBuilder htmlDocumentBuilder = new HTMLDocumentBuilder(
tolerantSaxDocumentBuilder);
Document wellFormedDocument = htmlDocumentBuilder
.parse(someBadlyFormedHTML);
assertXpathEvaluatesTo("Item One", "/html/body//li[@id='1']",
wellFormedDocument);
}
public void testCountingNodeTester() throws Exception {
String testXML = "<fibonacci><val>1</val><val>2</val><val>3</val>"
+ "<val>5</val><val>9</val></fibonacci>";
CountingNodeTester countingNodeTester = new CountingNodeTester(4);
assertNodeTestPasses(testXML, countingNodeTester, Node.TEXT_NODE);
}
}
类似资料：