All Classes

Class	Description
AbstractDifferenceEngine	Useful base-implementation of some parts of the DifferenceEngine interface.
AbstractDifferenceEngine.DeferredComparison	Encapsulates a comparison that may or may not be performed.
AbstractNodeTester	Helper class.
AbstractTransformationBuilder<B extends TransformationBuilderBase<B>>	Base class providing the common logic of the XSLT related builders.
AssertionsAdapter	Class that is proxy for AssertJ assertions used by org.xmlunit.assertj.*Assert classes.
ByNameAndTextRecSelector	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.
CaseInsensitiveDifferenceListener	Ignores case for all textual content.
ChildNodeXPathContextProvider	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.
CommentLessSource	A source that is obtained from a different source by stripping all comments.
CompareAssert	Assertion methods for XMLs comparison.
CompareAssert.ComparisonContext
CompareMatcher	This Hamcrest Matcher compares two XML sources with each others.
Comparison	Details of a single comparison XMLUnit has performed.
Comparison.Detail	The details of a target (usually some representation of an XML Node) that took part in the comparison.
ComparisonController	Callback interface used by DifferenceEngine to determine whether to halt the node-by-node comparison of two pieces of XML
ComparisonController	Decides whether the difference engine should stop the whole comparison process because of the current difference.
ComparisonControllers	Controllers used for the base cases.
ComparisonControllers.StopComparisonController
ComparisonFormatter	Formatter methods for a Comparison Object.
ComparisonListener	Is notified of comparisions and their results.
ComparisonListenerSupport	Encapsulates support for ComparisonListeners so it can be reused by different implementations of DifferenceEngine.
ComparisonResult	The possible outcomes of a comparision.
ComparisonType	The kinds of comparisons XMLUnit performs.
ConfigurationException	Exception thrown when an XML parser-, transformer- or XPath-factory throws a configuration exception.
ConfigurationException	Exception thrown when anything inside JAXP throws a *ConfigurationException.
Convert	Conversion methods.
CountingNodeTester	Counts the number of nodes in a document to allow assertions to be made using a NodeTest.
CustomAbstractAssert<SELF extends CustomAbstractAssert<SELF,ACTUAL>,ACTUAL>	Ensures XMLUnit's stack trace lines get removed from AssertionError's stack traces if those of AssertJ are removed.
DefaultComparisonFormatter	Formatter methods for a Comparison Object.
DefaultConditionalSelectorBuilder
DefaultConditionalSelectorBuilder.ConditionalSelector
DefaultNodeMatcher	Default implemetation of NodeMatcher that matches control and tests nodes for comparison with the help of DefaultNodeMatcher.NodeTypeMatcher and ElementSelectors.
DefaultNodeMatcher.DefaultNodeTypeMatcher	DefaultNodeMatcher.NodeTypeMatcher that marks pairs of nodes of the same node type as well as pairs of CDATA sections and text nodes as eligible.
DefaultNodeMatcher.Match
DefaultNodeMatcher.NodeTypeMatcher	Determines whether two Nodes are eligible for comparison based on their node type.
DetailedDiff	Compares and describes all the differences between two XML documents.
Diff	Compares and describes any difference between XML documents.
Diff	The Diff-Object is the result of two comparisons.
DiffBuilder	DiffBuilder to create a Diff instance.
DiffBuilder.CollectResultsListener
Difference	Value object that describes a difference between DOM Nodes using one of the DifferenceConstants ID values and a NodeDetail instance.
Difference	Combines a Comparison and its result.
DifferenceConstants	Constants for describing differences between DOM Nodes.
DifferenceEngine	Class that has responsibility for comparing Nodes and notifying a DifferenceListener of any differences or dissimilarities that are found.
DifferenceEngine	XMLUnit's difference engine.
DifferenceEngine.DifferenceFoundException	Marker exception thrown by the protected compare() method and passed upwards through the call stack to the public compare() method.
DifferenceEngineConfigurer<D extends DifferenceEngineConfigurer<D>>	Subset of the configuration options available for a DifferenceEngine.
DifferenceEngineContract	The pieces of DifferenceEngine's API used by Diff.
DifferenceEvaluator	May decide to up- or downgrade the severity of a difference.
DifferenceEvaluators	Evaluators used for the base cases.
DifferenceListener	Listener for callbacks from a DifferenceEngine comparison.
DoctypeInputStream	Adapts the marked-up content in a source InputStream to specify that it conforms to a different DTD.
DoctypeReader	Adapts the marked-up content in a source Reader to specify that it conforms to a different DTD.
DoctypeSupport	Contains some common code for DoctypeReader and DoctypeInputStream.
DoctypeSupport.IntBufferReadable
DoctypeSupport.Readable
DocumentBuilderFactoryConfigurer	Configures DocumentBuilderFactories.
DocumentBuilderFactoryConfigurer.Builder	Builder for a DocumentBuilderFactoryConfigurer.
DOMDifferenceEngine	Difference engine based on DOM.
DOMDifferenceEngine.Attributes
ElementContentWhitespaceStrippedSource	A source that is obtained from a different source by removing all text nodes that only contain whitespace.
ElementNameAndAttributeQualifier	More complex interface implementation that tests two elements for tag name and attribute name comparability.
ElementNameAndTextQualifier	More complex interface implementation that tests two elements for tag name and text content comparability.
ElementNameQualifier	Simple interface implementation that tests two elements for name comparability.
ElementQualifier	Interface used by the DifferenceEngine class to determine which elements can be compared within a NodeList of child nodes.
ElementSelector	Strategy used by DefaultNodeMatcher for selecting matching elements.
ElementSelectors	Common ElementSelector implementations.
ElementSelectors.CanBeComparedPredicate
ElementSelectors.ConditionalSelectorBuilder	Allows to build complex ElementSelectors by combining simpler blocks.
ElementSelectors.ConditionalSelectorBuilderThen	then-part of conditional ElementSelectors built via ElementSelectors.ConditionalSelectorBuilder.
EvaluateXPathMatcher	This Hamcrest Matcher verifies whether the evaluation of the provided XPath expression corresponds to the value matcher specified for the provided input XML object.
FloatingPointTolerantDifferenceListener	Expects texts to be floating point numbers and treats them as identical if they only differ by a given tolerance value (or less).
HasXPathMatcher	This Hamcrest Matcher verifies whether the provided XPath expression corresponds to at least one element in the provided object.
HTMLDocumentBuilder	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.
IgnorePlaceholderHandler	Handler for the "ignore" placeholder keyword.
IgnoreTextAndAttributeValuesDifferenceListener	Class to use when performing a Diff that only compares the structure of 2 pieces of XML, i.e.
Input	Fluent API to create Source instances.
Input.Builder	Interface for fluent builders of Sources.
Input.SourceHoldingBuilder
Input.StreamBuilder
Input.Transformation
Input.TransformationBuilder	Builds Sources by transforming other sources.
IntegerBuffer	Simplistic dynamically growing buffer of integers used by DoctypeSupport.
IsDateTimePlaceholderHandler	Handler for the isDateTime placeholder keyword.
IsNullPredicate	A function that tests whether an object is null.
IsNumberPlaceholderHandler	Handler for the isNumber placeholder keyword.
IterableNodeList	Provides an iterable view to a NodeList, the Iterator that can be obtained from this Iterable will be read-only.
Jaxp13XpathEngine	XPath engine based on javax.xml.xpath.
Jaxp13XpathEngine.NodeListForIterable
JAXPConstants	Utility constant class for JAXP-defined constants.
JAXPConstants.Properties
JAXPValidator	Validator using the javax.xml.validation namespace.
JAXPXPathEngine	Simplified access to JAXP's XPath API.
Languages	Constants for the languages supported by XMLUnit's schema validation.
Linqy	A couple of (functional) sequence processing constructs.
Linqy.FilteringIterator<T>
Linqy.MappingIterator<F,T>
Linqy.OnceOnlyIterator<E>
Mapper<F,T>	A function mapping from one type to another.
MatchesRegexPlaceholderHandler	Handler for the matchesRegex() placeholder keyword.
MatchTracker	Listener for callbacks from a DifferenceEngine comparison that is notified on each and every comparision that resulted in a match.
MultiLevelByNameAndTextSelector	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.
MultiLevelElementNameAndTextQualifier	Per popular request an interface implementation that uses element names and the text node containes in the n'th child node to compare elements.
MultipleNodeAssert	Assertion methods for Iterable of Node.
MultipleNodeAssert.SingleNodeAssertConsumer
NamespaceContext	Interface used by XpathEngine in order to map prefixes to namespace URIs.
NewDifferenceEngine	Class that has responsibility for comparing Nodes and notifying a DifferenceListener of any differences or dissimilarities that are found.
NewDifferenceEngine.CompareUnmatchedNodeMatcher
NewDifferenceEngine.CompareUnmatchedNodeMatcher.Entry
NewDifferenceEngine.ComparisonController2ComparisonController
NewDifferenceEngine.DifferenceListener2DifferenceEvaluator
NewDifferenceEngine.ElementQualifier2ElementSelector
NewDifferenceEngine.IgnoreDoctypeNotPresentDifferences
NewDifferenceEngine.IsBetweenDocumentNodeAndRootElement	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.
NewDifferenceEngine.MatchTracker2ComparisonListener
NodeAssertFactory
NodeDescriptor	Class for describing Nodes
NodeDetail	Parameter class for holding information about a Node within a Difference instance
NodeFilters	Common NodeFilter implementations.
NodeInputStream	Adapter class to present the content of a DOM Node (e.g.
NodeMatcher	Strategy that matches control and tests nodes for comparison.
Nodes	Utility algorithms that work on DOM nodes.
NodeTest	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.
NodeTest.NodeTypeNodeFilter	Node type specific Node Filter: accepts Nodes of those types specified in constructor, rejects all others
NodeTester	Perform Node-by-Node validation of a DOM Document.
NodeTestException	Thrown by a NodeTest that fails.
NodeUtils
NormalizedSource	Performs XML normalization on a given Source, Document or Node.
ParsingValidator	Validator implementation that uses "the old way" of validating an XML input by parsing the input.
ParsingValidator.Properties
PlaceholderDifferenceEvaluator	This class is used to add placeholder feature to XML comparison.
PlaceholderHandler	Interface implemented by classes that are responsible for a placeholder keyword.
PlaceholderSupport	Adds support for the placeholder feature to a DifferenceEngineConfigurer - like DiffBuilder or org.xmlunit.matchers.CompareMatcher.
Predicate<T>	A function that tests an object for a property.
QualifiedName	Since javax.xml.namespace.QName is not present prior to Java5, this is XMLUnit's own abstraction.
RecursiveElementNameAndTextQualifier	Compares all Element and Text nodes in two pieces of XML.
RecursiveXPathBuilder	Finds the XPathContext of a Node by recursively building up the XPathContext.
ShouldAnyNodeHaveXPath
ShouldBeConvertible
ShouldBeInvalid
ShouldBeNotSimilar
ShouldBeValid
ShouldHaveAttribute
ShouldHaveXPath
ShouldNotHaveAttribute
ShouldNotHaveThrown
SimpleNamespaceContext	Implementation of NamespaceContext that's backed by a map.
SimpleXpathEngine	Simple class for accessing the Nodes matched by an Xpath expression, or evaluating the String value of an Xpath expression.
SingleNodeAssert	Assertion methods for Node.
TextDifferenceListenerBase	Base class that delegates all differences to another DifferenceListener.
TolerantSaxDocumentBuilder	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.
Transform	Handy wrapper for an XSLT transformation performed using JAXP/Trax.
Transform	Fluent API access to Transformation.
Transform.Builder	Builder for XSLT transformations.
Transform.Trans<R>
Transform.TransformationBuilder
Transform.TransformationResult	Provides different options to obtain the result of an XSLT transformation.
Transformation	Provides a convenience layer over TraX.
TransformationBuilderBase<B extends TransformationBuilderBase<B>>	Holds the common builder methods for XSLT related builders.
TransformerFactoryConfigurer	Configures TransformerFactories.
TransformerFactoryConfigurer.Builder	Builder for a TransformerFactoryConfigurer.
TypeMatcher<T>	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.
TypeMatcher.BigDecimalTypeMatcher
TypeMatcher.BooleanTypeMatcher
TypeMatcher.DoubleTypeMatcher
TypeMatcher.IntegerTypeMatcher
ValidationAssert	Assertion methods for XML validation.
ValidationHandler	ErrorHandler collecting parser exceptions as ValidationProblems.
ValidationMatcher	Hamcrest Matcher for XML Validation against W3C XML Schema using JAXPValidator.
ValidationMatcher.HasSystemIdPredicate
ValidationProblem	A validation "problem" which may be an error or a warning.
ValidationProblem.ProblemType	The type of validation problem encountered.
ValidationResult	The result of a validation.
Validator	Validator class based of javax.xml.validation.
Validator	Validates XML against its internal or external DOCTYPE, or a completely different DOCTYPE.
Validator	Validates a piece of XML against a schema given in a supported language or the definition of such a schema itself.
ValueAssert	Assertion methods for String result of XPath evaluation.
WhitespaceNormalizedSource	A source that is obtained from a different source by removing all empty text nodes and normalizing the non-empty ones.
WhitespaceStrippedSource	A source that is obtained from a different source by removing all empty text nodes and trimming the non-empty ones.
XmlAssert	Entry point for fluent interface for writing assertions based on AssertJ library.
XMLAssert	Collection of static methods so that XML assertion facilities are available in any class, not just test suites.
XMLAssert.NodeBasedNamespaceContext
XMLConstants	A convenient place to hang constants relating to general XML usage
XMLTestCase	JUnit TestCase subclass: extend this to add XML assertion facilities to your test suites.
XMLUnit	Allows access to project control parameters such as which Parser to use and provides some convenience methods for building Documents from Strings etc.
XMLUnitException	Base class of any checked exception that can be thrown within XMLUnit.
XMLUnitException	Base class of any Exception thrown within XMLUnit.
XMLUnitNamespaceContext2Jaxp13	Adapts XMLUnit's NamespaceContext to JAXP 1.3's NamespaceContext.
XMLUnitRuntimeException	Base class of any RuntimeException that can be thrown within XMLUnit.
XPathContext	Helper class that keeps track of the XPath of matched nodes during comparison.
XPathContext.DOMNodeInfo	DOM based implementation of XPathContext.NodeInfo.
XPathContext.Level
XPathContext.NodeInfo	Representation of a node used by XPathContext.
XpathEngine	Abstraction of an engine evaluating XPath expressions.
XPathEngine	Interface for XMLUnit's XPath abstraction.
XpathException	Exception an XpathEngine is allowed to throw.
XpathNodeTracker	Tracks Nodes visited by the DifferenceEngine and converts that information into an Xpath-String to supply to the NodeDetail of a Difference instance.
XPathRegexAssert	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+).
XSLTConstants	A convenient place to hang constants relating to XSL transformations