All Classes and Interfaces
Class
Description
Helper class.
Ignores case for all textual content.
Callback interface used by DifferenceEngine to determine whether to halt the
node-by-node comparison of two pieces of XML
Exception thrown when an XML parser-, transformer- or XPath-factory
throws a configuration exception.
Deprecated.
Counts the number of nodes in a document to allow assertions to be made
using a NodeTest.
Compares and describes all the differences between two XML documents.
Compares and describes any difference between XML documents.
Value object that describes a difference between DOM Nodes using one of
the DifferenceConstants ID values and a NodeDetail instance.
Constants for describing differences between DOM Nodes.
Class that has responsibility for comparing Nodes and notifying a
DifferenceListener of any differences or dissimilarities that are found.
Marker exception thrown by the protected compare() method and passed
upwards through the call stack to the public compare() method.
Listener for callbacks from a
DifferenceEngine comparison
.Adapts the marked-up content in a source InputStream to specify that it
conforms to a different DTD.
Adapts the marked-up content in a source Reader to specify that it
conforms to a different DTD.
More complex interface implementation that tests two elements for tag name
and attribute name comparability.
More complex interface implementation that tests two elements for tag name
and text content comparability.
Simple interface implementation that tests two elements for name
comparability.
Interface used by the DifferenceEngine class to determine which elements can
be compared within a NodeList of child nodes.
Expects texts to be floating point numbers and treats them as
identical if they only differ by a given tolerance value (or less).
Build a DOM document from HTML content converting from 'plain' HTML into
'XHTML' along the way with the help of a TolerantSaxDocumentBuilder and
the Swing html parser classes.
Class to use when performing a Diff that only compares the
structure of 2 pieces of XML, i.e.
Simplistic dynamically growing buffer of integers used by DoctypeSupport.
XPath engine based on javax.xml.xpath.
Utility constant class for JAXP-defined constants.
Utility constant class for JAXP Properties, typically used with
.
invalid reference
XMLReader#setProperty(String, Object)
Listener for callbacks from a
DifferenceEngine comparison
that is notified on each and every
comparision that resulted in a match.Per popular request an interface implementation that uses element
names and the text node containes in the n'th child node to compare
elements.
Interface used by XpathEngine in order to map prefixes to namespace URIs.
Class for describing Nodes
Parameter class for holding information about a
Node
within
a Difference instanceAdapter class to present the content of a DOM Node (e.g.
Encapsulation of the Node-by-Node testing of a DOM Document
Uses a nodetype-specific
NodeFilter
to pass the DOM Nodes
to a NodeTester instance that performs the acual Node validation.Perform Node-by-Node validation of a DOM Document.
Thrown by a NodeTest that fails.
Since javax.xml.namespace.QName is not present prior to Java5, this
is XMLUnit's own abstraction.
Compares all Element and Text nodes in two pieces of XML.
Implementation of NamespaceContext that's backed by a map.
Simple class for accessing the Nodes matched by an Xpath expression, or
evaluating the String value of an Xpath expression.
Base class that delegates all differences to another DifferenceListener.
Uses Sax events from the
ContentHandler
and
LexicalHandler
interfaces to build a DOM document in a tolerant
fashion -- it can cope with start tags without end tags, and end tags without
start tags for example.Handy wrapper for an XSLT transformation performed using JAXP/Trax.
Validator class based of
javax.xml.validation
.Validates XML against its internal or external DOCTYPE, or a completely
different DOCTYPE.
Collection of static methods so that XML assertion facilities are available
in any class, not just test suites.
A convenient place to hang constants relating to general XML usage
JUnit TestCase subclass: extend this to add XML assertion facilities to your
test suites.
Allows access to project control parameters such as which Parser to use and
provides some convenience methods for building Documents from Strings etc.
Base class of any checked exception that can be thrown within
XMLUnit.
Base class of any RuntimeException that can be thrown within
XMLUnit.
Abstraction of an engine evaluating XPath expressions.
Exception an
XpathEngine
is allowed to throw.Tracks Nodes visited by the DifferenceEngine and
converts that information into an Xpath-String to supply
to the NodeDetail of a Difference instance
Example demonstrating how to use the XPath API of XMLUnit in
conjunction with regular expressions (as provided by the
java.util.regex package of JDK 1.4+).
A convenient place to hang constants relating to XSL transformations
CountingNodeTester
instead.