Method Detail

• compare

  public static DiffBuilder compare(Object control)

  Create a DiffBuilder from all kind of types supported by Input.from(Object).

  Parameters:

  control - the expected reference document.

  See Also:

  DiffBuilder

• withTest

  public DiffBuilder withTest(Object test)

  Set the Test-Source from all kind of types supported by Input.from(Object).

  Parameters:

  test - the test document which must be compared with the control document.

• ignoreWhitespace

  public DiffBuilder ignoreWhitespace()

  Ignore whitespace by removing all empty text nodes and trimming the non-empty ones.

• normalizeWhitespace

  public DiffBuilder normalizeWhitespace()

  Normalize Text-Elements by removing all empty text nodes and normalizing the non-empty ones.

  "normalized" in this context means all whitespace characters are replaced by space characters and consecutive whitespace characters are collapsed.

• ignoreComments

  public DiffBuilder ignoreComments()

  Will remove all comment-Tags "<!-- Comment -->" from test- and control-XML before comparing.

  Comments are ignored by applying an XSLT transformation on the source which may reduce the effect of withDocumentBuilderFactory(javax.xml.parsers.DocumentBuilderFactory). If you need more control over the transformation build the Source using a transformation yourself, using CommentLessSource.STYLE.

• withNodeMatcher

  public DiffBuilder withNodeMatcher(NodeMatcher nodeMatcher)

  Sets the strategy for selecting nodes to compare.

  Example with DefaultNodeMatcher:

   .withNodeMatcher(new DefaultNodeMatcher(ElementSelectors.byNameAndText))
   

  See Also:

  DifferenceEngine.setNodeMatcher(NodeMatcher)

• withDifferenceEvaluator

  public DiffBuilder 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:

   Diff myDiff = DiffBuilder.compare(control).withTest(test)
           .withDifferenceEvaluator(
               DifferenceEvaluators.chain(
                   DifferenceEvaluators.Default,
                   new MyCustomDifferenceEvaluator()))
           ....
           .build();
   

• withComparisonController

  public DiffBuilder withComparisonController(ComparisonController comparisonController)

  Replace the ComparisonControllers.Default with your own ComparisonController.

  Example use:

   Diff myDiff = DiffBuilder.compare(control).withTest(test)
        .withComparisonController(ComparisonControllers.StopWhenDifferent)
        .build();
   

• withComparisonListeners

  public DiffBuilder withComparisonListeners(ComparisonListener... comparisonListeners)

  Registers a listener that is notified of each comparison.

  See Also:

  DifferenceEngine.addComparisonListener(ComparisonListener)

• withDifferenceListeners

  public DiffBuilder withDifferenceListeners(ComparisonListener... comparisonListeners)

  Registers a listener that is notified of each comparison with outcome other than ComparisonResult.EQUAL.

  See Also:

  DifferenceEngine.addDifferenceListener(ComparisonListener)

• checkForSimilar

  public DiffBuilder checkForSimilar()

  check test source with the control source for similarity.

  Example for Similar: The XML node "<a>Text</a>" and "<a><![CDATA[Text]]></a>" are similar and the Test will not fail.

  The rating, if a node is similar, will be done by the DifferenceEvaluators.Default. See withDifferenceEvaluator(DifferenceEvaluator)

  Default is checkForIdentical().

• checkForIdentical

  public DiffBuilder checkForIdentical()

  check test source with the control source for identically.

  This is the Default.

• withNamespaceContext

  public DiffBuilder 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.

  Parameters:

  prefix2Uri - mapping between prefix and namespace URI

• withAttributeFilter

  public DiffBuilder 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.

• withNodeFilter

  public DiffBuilder 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.

• withComparisonFormatter

  public DiffBuilder withComparisonFormatter(ComparisonFormatter formatter)

  Sets a non-default formatter for the differences found.

• withDocumentBuilderFactory

  public DiffBuilder withDocumentBuilderFactory(DocumentBuilderFactory f)

  Sets the DocumentBuilderFactory to use when creating a Document from the Sources to compare.

  This is only used if the Sources used for control and test not already are DOMSources.

  Since:

  XMLUnit 2.2.0

• build

  public Diff build()

  Compare the Test-XML withTest(Object) with the Control-XML compare(Object) and return the collected differences in a Diff object.