CompareAssert (XMLUnit for Java 2.9.1 API)

java.lang.Object
- org.assertj.core.api.AbstractAssert<SELF,ACTUAL>
- - org.xmlunit.assertj.CompareAssert

All Implemented Interfaces:: org.assertj.core.api.Assert<CompareAssert,Object>, org.assertj.core.api.Descriptable<CompareAssert>, org.assertj.core.api.ExtensionPoints<CompareAssert,Object>, DifferenceEngineConfigurer<CompareAssert>

public class CompareAssert
extends org.assertj.core.api.AbstractAssert<SELF,ACTUAL>
implements DifferenceEngineConfigurer<CompareAssert>

Assertion methods for XMLs comparison.

Simple Example

 import static org.xmlunit.assertj.XmlAssert.assertThat;

 final String control = "<a><b attr=\"abc\"></b></a>";
 final String test = "<a><b attr=\"xyz\"NodeAssertFactory></b></a>";

 assertThat(test).and(control).areIdentical();
 assertThat(test).and(control).areNotSimilar();

Since:: XMLUnit 2.6.1

Field Summary
- Fields inherited from class org.assertj.core.api.AbstractAssert
  actual, info, myself, objects, throwUnsupportedExceptionOnEquals

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`CompareAssert`	`areIdentical()` Check if actual and control XMLs are identical.
`CompareAssert`	`areNotIdentical()` Check if actual and control XMLs are not identical.
`CompareAssert`	`areNotSimilar()` Check if actual and control XMLs are not similar.
`CompareAssert`	`areSimilar()` Check if actual and control XMLs are similar.
`CompareAssert`	`ignoreChildNodesOrder()` Equivalent for
`CompareAssert`	`ignoreComments()` Will remove all comment-Tags "<!-- Comment -->" from test- and control-XML before comparing.
`CompareAssert`	`ignoreCommentsUsingXSLTVersion(String xsltVersion)` Will remove all comment-Tags "<!-- Comment -->" from test- and control-XML before comparing.
`CompareAssert`	`ignoreElementContentWhitespace()` Ignore element content whitespace by removing all text nodes solely consisting of whitespace.
`CompareAssert`	`ignoreWhitespace()` Ignore whitespace by removing all empty text nodes and trimming the non-empty ones.
`protected boolean`	`isElementOfCustomAssert(StackTraceElement stackTraceElement)`
`CompareAssert`	`normalizeWhitespace()` Normalize Text-Elements by removing all empty text nodes and normalizing the non-empty ones.
`CompareAssert`	`withAttributeFilter(Predicate<Attr> attributeFilter)` Registers a filter for attributes.
`CompareAssert`	`withComparisonController(ComparisonController comparisonController)` Replace the `ComparisonControllers.Default` with your own ComparisonController.
`CompareAssert`	`withComparisonFormatter(ComparisonFormatter formatter)` Sets a non-default formatter for the differences found.
`CompareAssert`	`withComparisonListeners(ComparisonListener... comparisonListeners)` Registers listeners that are notified of each comparison.
`CompareAssert`	`withDifferenceEvaluator(DifferenceEvaluator differenceEvaluator)` Provide your own custom `DifferenceEvaluator` implementation.
`CompareAssert`	`withDifferenceListeners(ComparisonListener... comparisonListeners)` Registers listeners that are notified of each comparison with outcome other than `ComparisonResult.EQUAL`.
`CompareAssert`	`withDocumentBuilderFactory(DocumentBuilderFactory f)` Sets the `DocumentBuilderFactory` to use when creating a `Document` from the `Source`s to compare.
`CompareAssert`	`withNamespaceContext(Map<String,String> prefix2Uri)` Establish a namespace context that will be used in `Comparison.Detail#getXPath`.
`CompareAssert`	`withNodeFilter(Predicate<Node> nodeFilter)` Registers a filter for nodes.
`CompareAssert`	`withNodeMatcher(NodeMatcher nodeMatcher)` Sets the strategy for selecting nodes to compare.

Methods inherited from class org.assertj.core.api.AbstractAssert
areEqual, asInstanceOf, asList, assertionError, asString, describedAs, descriptionText, doesNotHave, doesNotHaveSameClassAs, doesNotHaveSameHashCodeAs, doesNotHaveToString, equals, extracting, extracting, failure, failureWithActualExpected, failWithActualExpectedAndMessage, failWithMessage, getWritableAssertionInfo, has, hashCode, hasSameClassAs, hasSameHashCodeAs, hasToString, inBinary, inHexadecimal, is, isEqualTo, isExactlyInstanceOf, isIn, isIn, isInstanceOf, isInstanceOfAny, isInstanceOfSatisfying, isNot, isNotEqualTo, isNotExactlyInstanceOf, isNotIn, isNotIn, isNotInstanceOf, isNotInstanceOfAny, isNotNull, isNotOfAnyClassIn, isNotSameAs, isNull, isOfAnyClassIn, isSameAs, matches, matches, newListAssertInstance, overridingErrorMessage, overridingErrorMessage, satisfies, satisfies, satisfies, satisfiesAnyOf, satisfiesAnyOf, satisfiesAnyOfForProxy, satisfiesForProxy, setCustomRepresentation, setDescriptionConsumer, setPrintAssertionsDescription, throwAssertionError, usingComparator, usingComparator, usingDefaultComparator, usingRecursiveComparison, usingRecursiveComparison, withFailMessage, withFailMessage, withRepresentation, withThreadDumpOnError

Methods inherited from class java.lang.Object
clone, finalize, getClass, notify, notifyAll, toString, wait, wait, wait

Methods inherited from interface org.assertj.core.api.Descriptable
as, as, as, describedAs

- Method Detail
  - withNodeMatcher
```
public CompareAssert withNodeMatcher(NodeMatcher nodeMatcher)
```
    Sets the strategy for selecting nodes to compare.
    Example with DefaultNodeMatcher:
```
 .withNodeMatcher(new DefaultNodeMatcher(ElementSelectors.byNameAndText))
 
```
    This overwrites any NodeMatcher set via earlier invocations of withNodeMatcher.
    Specified by:
    
    withNodeMatcher in interface DifferenceEngineConfigurer<CompareAssert>
    
    Parameters:
    
    nodeMatcher - the NodeMatcher to use
    
    Returns:
    
    this
    
    See Also:
    
    DiffBuilder.withNodeMatcher(NodeMatcher)
  - withDifferenceEvaluator
```
public CompareAssert withDifferenceEvaluator(DifferenceEvaluator differenceEvaluator)
```
    Provide your own custom DifferenceEvaluator implementation.
    This overwrites the Default DifferenceEvaluator.
    
    If you want use your custom DifferenceEvaluator in combination with the default or another DifferenceEvaluator you should use DifferenceEvaluators.chain(DifferenceEvaluator...) or DifferenceEvaluators.first(DifferenceEvaluator...) to combine them:
```
         .withDifferenceEvaluator(
             DifferenceEvaluators.chain(
                 DifferenceEvaluators.Default,
                 new MyCustomDifferenceEvaluator()))
         ....
 
```
    This overwrites any DifferenceEvaluator set via earlier invocations of withDifferenceEvaluator.
    Specified by:
    
    withDifferenceEvaluator in interface DifferenceEngineConfigurer<CompareAssert>
    
    Parameters:
    
    differenceEvaluator - the DifferenceEvaluator to use
    
    Returns:
    
    this
    
    See Also:
    
    DiffBuilder.withDifferenceEvaluator(DifferenceEvaluator)
  - withComparisonController
```
public CompareAssert withComparisonController(ComparisonController comparisonController)
```
    Replace the ComparisonControllers.Default with your own ComparisonController.
    Example use:
```
      .withComparisonController(ComparisonControllers.StopWhenDifferent)
 
```
    This overwrites any ComparisonController set via earlier invocations of withComparisonController.
    Specified by:
    
    withComparisonController in interface DifferenceEngineConfigurer<CompareAssert>
    
    Parameters:
    
    comparisonController - ComparisonController to use
    
    Returns:
    
    this
    
    See Also:
    
    DiffBuilder.withComparisonController(ComparisonController)
  - withComparisonListeners
```
public CompareAssert withComparisonListeners(ComparisonListener... comparisonListeners)
```
    Registers listeners that are notified of each comparison.
    
    Specified by:
    
    withComparisonListeners in interface DifferenceEngineConfigurer<CompareAssert>
    
    Parameters:
    
    comparisonListeners - ComparisonListeners to use
    
    Returns:
    
    this
    
    See Also:
    
    DiffBuilder.withComparisonListeners(ComparisonListener...)
  - withDifferenceListeners
```
public CompareAssert withDifferenceListeners(ComparisonListener... comparisonListeners)
```
    Registers listeners that are notified of each comparison with outcome other than ComparisonResult.EQUAL.
    This overwrites any ComparisonListeners set via earlier invocations of withDifferenceListeners.
    
    Specified by:
    
    withDifferenceListeners in interface DifferenceEngineConfigurer<CompareAssert>
    
    Parameters:
    
    comparisonListeners - ComparisonListeners to use
    
    Returns:
    
    this
    
    See Also:
    
    DiffBuilder.withDifferenceListeners(ComparisonListener...)
  - withNamespaceContext
```
public CompareAssert withNamespaceContext(Map<String,String> prefix2Uri)
```
    Establish a namespace context that will be used in Comparison.Detail#getXPath.
    Without a namespace context (or with an empty context) the XPath expressions will only use local names for elements and attributes.
    
    This overwrites any Map set via earlier invocations of withNamespaceContext.
    
    Specified by:
    
    withNamespaceContext in interface DifferenceEngineConfigurer<CompareAssert>
    
    Parameters:
    
    prefix2Uri - mapping between prefix and namespace URI
    
    Returns:
    
    this
    
    See Also:
    
    DiffBuilder.withNamespaceContext(Map)
  - withAttributeFilter
```
public CompareAssert withAttributeFilter(Predicate<Attr> attributeFilter)
```
    Registers a filter for attributes.
    Only attributes for which the predicate returns true are part of the comparison. By default all attributes are considered.
    
    The "special" namespace, namespace-location and schema-instance-type attributes can not be ignored this way. If you want to suppress comparison of them you'll need to implement DifferenceEvaluator.
    
    This overwrites any Predicate set via earlier invocations of withAttributeFilter.
    
    Specified by:
    
    withAttributeFilter in interface DifferenceEngineConfigurer<CompareAssert>
    
    Parameters:
    
    attributeFilter - attribute filter to use
    
    Returns:
    
    this
    
    See Also:
    
    DiffBuilder.withAttributeFilter(Predicate)
  - withNodeFilter
```
public CompareAssert withNodeFilter(Predicate<Node> nodeFilter)
```
    Registers a filter for nodes.
    Only nodes for which the predicate returns true are part of the comparison. By default nodes that are not document types are considered.
    
    This overwrites any Predicate set via earlier invocations of withNodeFilter.
    
    Specified by:
    
    withNodeFilter in interface DifferenceEngineConfigurer<CompareAssert>
    
    Parameters:
    
    nodeFilter - node filter to use
    
    Returns:
    
    this
    
    See Also:
    
    DiffBuilder.withNodeFilter(Predicate)
  - withComparisonFormatter
```
public CompareAssert withComparisonFormatter(ComparisonFormatter formatter)
```
    Sets a non-default formatter for the differences found.
    This overwrites any ComparisonFormatter set via earlier invocations of withComparisonFormatter.
    
    Specified by:
    
    withComparisonFormatter in interface DifferenceEngineConfigurer<CompareAssert>
    
    Parameters:
    
    formatter - formatter to use
    
    Returns:
    
    this
    
    See Also:
    
    DiffBuilder.withComparisonFormatter(ComparisonFormatter)
  - withDocumentBuilderFactory
```
public CompareAssert withDocumentBuilderFactory(DocumentBuilderFactory f)
```
    Sets the DocumentBuilderFactory to use when creating a Document from the Sources to compare.
    
    Parameters:
    
    f - the DocumentBuilderFactory to use
    
    Returns:
    
    this
    
    See Also:
    
    DiffBuilder.withDocumentBuilderFactory(DocumentBuilderFactory)
  - ignoreWhitespace
```
public CompareAssert ignoreWhitespace()
```
    Ignore whitespace by removing all empty text nodes and trimming the non-empty ones.
    
    Returns:
    
    this
    
    See Also:
    
    DiffBuilder.ignoreWhitespace()
  - normalizeWhitespace
```
public CompareAssert normalizeWhitespace()
```
    Normalize Text-Elements by removing all empty text nodes and normalizing the non-empty ones.
    
    Returns:
    
    this
    
    See Also:
    
    DiffBuilder.normalizeWhitespace()
  - ignoreElementContentWhitespace
```
public CompareAssert ignoreElementContentWhitespace()
```
    Ignore element content whitespace by removing all text nodes solely consisting of whitespace.
    
    Returns:
    
    this
    
    See Also:
    
    DiffBuilder.ignoreElementContentWhitespace()
  - ignoreComments
```
public CompareAssert ignoreComments()
```
    Will remove all comment-Tags "" from test- and control-XML before comparing.
    
    Returns:
    
    this
    
    See Also:
    
    DiffBuilder.ignoreComments()
  - ignoreCommentsUsingXSLTVersion
```
public CompareAssert ignoreCommentsUsingXSLTVersion(String xsltVersion)
```
    Will remove all comment-Tags "" from test- and control-XML before comparing.
    
    Parameters:
    
    xsltVersion - use this version for the stylesheet
    
    Returns:
    
    this
    
    See Also:
    
    DiffBuilder.ignoreCommentsUsingXSLTVersion(String)
  - ignoreChildNodesOrder
```
public CompareAssert ignoreChildNodesOrder()
```
    Equivalent for
```
     .withNodeMatcher(new DefaultNodeMatcher(ElementSelectors.byNameAndText))
     .withDifferenceEvaluator(
          chain(
              Default,
              DifferenceEvaluators.downgradeDifferencesToEqual(ComparisonType.CHILD_NODELIST_SEQUENCE)));
 
```
    Returns:
    
    this
    
    See Also:
    
    DiffBuilder.withNodeMatcher(NodeMatcher)
  - areIdentical
```
public CompareAssert areIdentical()
```
    Check if actual and control XMLs are identical. If custom comparison controller wasn't defined then ComparisonControllers.StopWhenSimilar is used.
    
    Returns:
    
    this
    
    Throws:
    
    AssertionError - if the test value is invalid
    
    AssertionError - if the control value is invalid
    
    See Also:
    
    DiffBuilder.checkForIdentical()
  - areNotIdentical
```
public CompareAssert areNotIdentical()
```
    Check if actual and control XMLs are not identical. If custom comparison controller wasn't defined then ComparisonControllers.StopWhenSimilar is used.
    
    Returns:
    
    this
    
    Throws:
    
    AssertionError - if the test value is invalid
    
    AssertionError - if the control value is invalid
    
    See Also:
    
    DiffBuilder.checkForSimilar()
  - areSimilar
```
public CompareAssert areSimilar()
```
    Check if actual and control XMLs are similar. If custom comparison controller wasn't defined then ComparisonControllers.StopWhenDifferent is used.
    
    Returns:
    
    this
    
    Throws:
    
    AssertionError - if the test value is invalid
    
    AssertionError - if the control value is invalid
    
    See Also:
    
    DiffBuilder.checkForSimilar()
  - areNotSimilar
```
public CompareAssert areNotSimilar()
```
    Check if actual and control XMLs are not similar. If custom comparison controller wasn't defined then ComparisonControllers.StopWhenDifferent is used.
    
    Returns:
    
    this
    
    Throws:
    
    AssertionError - if the test value is invalid
    
    AssertionError - if the control value is invalid
    
    See Also:
    
    DiffBuilder.checkForSimilar()
  - isElementOfCustomAssert
```
protected boolean isElementOfCustomAssert(StackTraceElement stackTraceElement)
```
    Overrides:
    
    isElementOfCustomAssert in class org.assertj.core.api.AbstractAssert<SELF extends org.xmlunit.assertj.CustomAbstractAssert<SELF,ACTUAL>,ACTUAL>

Class CompareAssert

Field Summary

Fields inherited from class org.assertj.core.api.AbstractAssert

Method Summary

Methods inherited from class org.assertj.core.api.AbstractAssert

Methods inherited from class java.lang.Object

Methods inherited from interface org.assertj.core.api.Descriptable

Method Detail

withNodeMatcher

withDifferenceEvaluator

withComparisonController

withComparisonListeners

withDifferenceListeners

withNamespaceContext

withAttributeFilter

withNodeFilter

withComparisonFormatter

withDocumentBuilderFactory

ignoreWhitespace

normalizeWhitespace

ignoreElementContentWhitespace

ignoreComments

ignoreCommentsUsingXSLTVersion

ignoreChildNodesOrder

areIdentical

areNotIdentical

areSimilar

areNotSimilar

isElementOfCustomAssert