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.
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.
A source that is obtained from a different source by stripping all comments.
Assertion methods for XMLs comparison.
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.
Formatter methods for a Comparison Object.
Default implementation that uses javax.xml.bind.
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.
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.
Holds the element not satisfing a requirement and the error message.
Holds the element not satisfing a requirement and the error message.
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. where the values of text and attribute nodes should be ignored.
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.
JaxbBuilder for Jaxb-Object and creating a JAXBSource.
Implementation that uses jakarta.xml.bind.
JaxbBuilder for Jaxb-Object and creating a JAXBSource.
Input.Builder for Jaxb-Object and creating a JAXBSource.
Interface that creates a JAXB Builder.
XPath engine based on javax.xml.xpath.
Utility constant class for JAXP-defined constants.
Contains names for common properties.
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.
Assertion methods for Iterable of Node.
Assertion methods for Iterable of Node.
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.
Adapts XMLUnit 1.x ComparisonController to XMLUnit 2.x ComparisonController.
Adapts XMLUnit 1.x DifferenceListener to XMLUnit 2.x DifferenceEvaluator.
Adapts XMLUnit 1.x ComparisonQualifider to XMLUnit 2.x ElementSelector.
Adapts XMLUnit 1.x MatchTracker to XMLUnit 2.x ComparisonListener.
Class for describing Nodes
Parameter class for holding information about a Node within a Difference instance
Common NodeFilter implementations.
Adapter class to present the content of a DOM Node (e.g. a Document) as an InputStream using a DOM to Stream transformation.
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.
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.
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.
Assertion methods for XML validation.
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.
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.
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.
Configures XpathFactories.
Builder for a XPathFactoryConfigurer.
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