All Classes and Interfaces
Class
Description
Useful base-implementation of some parts of the DifferenceEngine
interface.
Encapsulates a comparison that may or may not be performed.
Helper class.
Base class providing the common logic of the XSLT related builders.
Class that is proxy for AssertJ assertions used by org.xmlunit.assertj.*Assert classes.
ElementSelector that allows two elements to be compared if
their name (including namespace URI, if any) and textual content is
the same and the same is true for all child elements recursively.Ignores case for all textual content.
Maps
Node to XPathContext by assuming all nodes
passed in are child nodes of the same parent node who's
XPathContext is provided as argument to the constructor.A source that is obtained from a different source by stripping all
comments.
Assertion methods for XMLs comparison.
This Hamcrest
Matcher compares two XML sources with each others.Details of a single comparison XMLUnit has performed.
The details of a target (usually some representation of an XML
Node) that took part in the comparison.
Callback interface used by DifferenceEngine to determine whether to halt the
node-by-node comparison of two pieces of XML
Decides whether the difference engine should stop the whole
comparison process because of the current difference.
Controllers used for the base cases.
Formatter methods for a
Comparison Object.Is notified of comparisions and their results.
Encapsulates support for
ComparisonListeners so it can be
reused by different implementations of DifferenceEngine.The possible outcomes of a comparision.
The kinds of comparisons XMLUnit performs.
Exception thrown when an XML parser-, transformer- or XPath-factory
throws a configuration exception.
Exception thrown when anything inside JAXP throws a
*ConfigurationException.
Conversion methods.
Counts the number of nodes in a document to allow assertions to be made
using a NodeTest.
Ensures XMLUnit's stack trace lines get removed from AssertionError's stack traces if those of AssertJ are removed.
Formatter methods for a
Comparison Object.Default implemetation of
NodeMatcher that matches control
and tests nodes for comparison with the help of DefaultNodeMatcher.NodeTypeMatcher and ElementSelectors.DefaultNodeMatcher.NodeTypeMatcher that marks pairs of nodes of the same
node type as well as pairs of CDATA sections and text nodes as
eligible.Determines whether two Nodes are eligible for comparison based
on their node type.
Compares and describes all the differences between two XML documents.
Compares and describes any difference between XML documents.
The Diff-Object is the result of two comparisons.
DiffBuilder to create a
Diff instance.Value object that describes a difference between DOM Nodes using one of
the DifferenceConstants ID values and a NodeDetail instance.
Combines a
Comparison and its result.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.
XMLUnit's difference engine.
Marker exception thrown by the protected compare() method and passed
upwards through the call stack to the public compare() method.
Subset of the configuration options available for a
DifferenceEngine.The pieces of DifferenceEngine's API used by Diff.
May decide to up- or downgrade the severity of a difference.
Evaluators used for the base cases.
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.
Contains some common code for DoctypeReader and DoctypeInputStream.
Configures DocumentBuilderFactories.
Builder for a DocumentBuilderFactoryConfigurer.
Difference engine based on DOM.
A source that is obtained from a different source by removing all
text nodes that only contain whitespace.
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.
Strategy used by
DefaultNodeMatcher for selecting matching
elements.Common ElementSelector implementations.
Allows to build complex
ElementSelectors by combining simpler blocks.Copied subset of
ElementsShouldSatisfy as AssertJ has moved the nested
UnsatisfiedRequirement class to a top level class, breaking backwards compatibility.This Hamcrest
Matcher verifies whether the evaluation of the provided XPath expression
corresponds to the value matcher specified for the provided input XML object.Expects texts to be floating point numbers and treats them as
identical if they only differ by a given tolerance value (or less).
This Hamcrest
Matcher verifies whether the provided XPath expression corresponds to at least
one element in the provided object.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.
Handler for the "ignore" placeholder keyword.
Class to use when performing a Diff that only compares the
structure of 2 pieces of XML, i.e.
Fluent API to create Source instances.
Interface for fluent builders of
Sources.Builds
Sources by transforming other sources.Simplistic dynamically growing buffer of integers used by DoctypeSupport.
Handler for the
isDateTime placeholder keyword.A function that tests whether an object is null.
Handler for the
isNumber placeholder keyword.Provides an iterable view to a NodeList, the Iterator that can be
obtained from this Iterable will be read-only.
XPath engine based on javax.xml.xpath.
Utility constant class for JAXP-defined constants.
Validator using the javax.xml.validation namespace.
Simplified access to JAXP's XPath API.
Constants for the languages supported by XMLUnit's schema
validation.
A couple of (functional) sequence processing constructs.
A function mapping from one type to another.
Handler for the
matchesRegex() placeholder keyword.Listener for callbacks from a
DifferenceEngine comparison that is notified on each and every
comparision that resulted in a match.ElementSelector that allows two elements to be compared if
their name (including namespace URI, if any) and textual content is
the same at a certain level of nesting.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 that has responsibility for comparing Nodes and notifying a
DifferenceListener of any differences or dissimilarities that are found.
Tests whether the DifferenceEngine is currently processing
comparisons of "things" between the document node and the
document's root element (comments or PIs, mostly) since these
must be ignored for backwards compatibility reasons.
Class for describing Nodes
Parameter class for holding information about a
Node within
a Difference instanceCommon NodeFilter implementations.
Adapter class to present the content of a DOM Node (e.g.
Strategy that matches control and tests nodes for comparison.
Utility algorithms that work on DOM nodes.
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.Node type specific Node Filter: accepts Nodes of those types specified
in constructor, rejects all others
Perform Node-by-Node validation of a DOM Document.
Thrown by a NodeTest that fails.
Performs XML normalization on a given Source, Document or Node.
Validator implementation that uses "the old way" of validating an
XML input by parsing the input.
This class is used to add placeholder feature to XML comparison.
Interface implemented by classes that are responsible for a
placeholder keyword.
Adds support for the placeholder feature to a
DifferenceEngineConfigurer - like DiffBuilder or
org.xmlunit.matchers.CompareMatcher.A function that tests an object for a property.
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.
Finds the XPathContext of a Node by recursively building up the XPathContext.
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.
Assertion methods for
Node.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.
Fluent API access to
Transformation.Builder for XSLT transformations.
Provides different options to obtain the result of an XSLT transformation.
Provides a convenience layer over TraX.
Holds the common builder methods for XSLT related builders.
Configures TransformerFactories.
Builder for a TransformerFactoryConfigurer.
This Hamcrest
Matcher is base Matcher to verify
whether examined string value is convertible to the specified type
and whether converted value corresponds to the given value valueMatcher.Assertion methods for XML validation.
ErrorHandler collecting parser exceptions as ValidationProblems.Hamcrest Matcher for XML Validation against W3C XML Schema using
JAXPValidator.A validation "problem" which may be an error or a warning.
The type of validation problem encountered.
The result of a validation.
Validator class based of
javax.xml.validation.Validates XML against its internal or external DOCTYPE, or a completely
different DOCTYPE.
Validates a piece of XML against a schema given in a supported
language or the definition of such a schema itself.
Assertion methods for
String result of XPath evaluation.A source that is obtained from a different source by removing all
empty text nodes and normalizing the non-empty ones.
A source that is obtained from a different source by removing all
empty text nodes and trimming the non-empty ones.
Entry point for fluent interface for writing assertions based on AssertJ library.
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 Exception thrown within XMLUnit.
Base class of any RuntimeException that can be thrown within
XMLUnit.
Helper class that keeps track of the XPath of matched nodes during
comparison.
DOM based implementation of
XPathContext.NodeInfo.Representation of a node used by
XPathContext.Abstraction of an engine evaluating XPath expressions.
Interface for XMLUnit's XPath abstraction.
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