cd160610-9b67-4752-a2c4-e3a0d82d991e

Committed 21 Apr 2025 11:55AM UTC coverage: 91.756% (-0.02%) from 91.78%

Build # cd160610-9b67-4752-a2c4-e3a0d82d991e

Build Type

push

circleci

Committed by

web-flow

Commit Message

Merge pull request #289 from xmlunit/circleci-project-setup

CircleCI project setup

Run Details

3996 of 4698 branches covered (85.06%)

11754 of 12810 relevant lines covered (91.76%)

2.35 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

92.0

/xmlunit-legacy/src/main/java/org/custommonkey/xmlunit/NewDifferenceEngine.java

/*
******************************************************************
Copyright (c) 2001-2010,2013,2015-2016,2018,2022 Jeff Martin, Tim Bacon
All rights reserved.

Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions
are met:

    * Redistributions of source code must retain the above copyright
      notice, this list of conditions and the following disclaimer.
    * Redistributions in binary form must reproduce the above
      copyright notice, this list of conditions and the following
      disclaimer in the documentation and/or other materials provided
      with the distribution.
    * Neither the name of the XMLUnit nor the names
      of its contributors may be used to endorse or promote products
      derived from this software without specific prior written
      permission.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
POSSIBILITY OF SUCH DAMAGE.

******************************************************************
*/

package org.custommonkey.xmlunit;

import java.util.Collections;
import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import javax.xml.transform.Source;

import org.xmlunit.builder.Input;
import org.xmlunit.diff.ByNameAndTextRecSelector;
import org.xmlunit.diff.Comparison;
import org.xmlunit.diff.ComparisonListener;
import org.xmlunit.diff.ComparisonResult;
import org.xmlunit.diff.ComparisonType;
import org.xmlunit.diff.DOMDifferenceEngine;
import org.xmlunit.diff.DefaultNodeMatcher;
import org.xmlunit.diff.DifferenceEvaluator;
import org.xmlunit.diff.DifferenceEvaluators;
import org.xmlunit.diff.ElementSelector;
import org.xmlunit.diff.ElementSelectors;
import org.xmlunit.diff.NodeFilters;
import org.xmlunit.diff.NodeMatcher;
import org.xmlunit.input.CommentLessSource;
import org.xmlunit.input.WhitespaceNormalizedSource;
import org.xmlunit.input.WhitespaceStrippedSource;
import org.xmlunit.util.IterableNodeList;
import org.xmlunit.util.Linqy;
import org.xmlunit.util.Predicate;
import org.custommonkey.xmlunit.examples.RecursiveElementNameAndTextQualifier;

import org.w3c.dom.CDATASection;
import org.w3c.dom.Comment;
import org.w3c.dom.Document;
import org.w3c.dom.DocumentType;
import org.w3c.dom.Element;
import org.w3c.dom.Node;

/**
 * Class that has responsibility for comparing Nodes and notifying a
 * DifferenceListener of any differences or dissimilarities that are found.
 * Knows how to compare namespaces and nested child nodes, but currently
 * only compares nodes of type ELEMENT_NODE, CDATA_SECTION_NODE,
 * COMMENT_NODE, DOCUMENT_TYPE_NODE, PROCESSING_INSTRUCTION_NODE and TEXT_NODE.
 * Nodes of other types (eg ENTITY_NODE) will be skipped.
 * @see DifferenceListener#differenceFound(Difference)
 */
public class NewDifferenceEngine
    implements DifferenceConstants, DifferenceEngineContract {

    private static final Integer ZERO = Integer.valueOf(0);
    private static final Map<Class<? extends ElementQualifier>, ElementSelector>
        KNOWN_SELECTORS;
    static {
        Map<Class<? extends ElementQualifier>, ElementSelector> m =
            new HashMap<Class<? extends ElementQualifier>, ElementSelector>();
        m.put(ElementNameAndTextQualifier.class,
              ElementSelectors.byNameAndText);
        m.put(ElementNameQualifier.class, ElementSelectors.byName);
        m.put(RecursiveElementNameAndTextQualifier.class,
              new ByNameAndTextRecSelector());
        KNOWN_SELECTORS = Collections.unmodifiableMap(m);
    }

    private final ComparisonController controller;
    private MatchTracker matchTracker;

    /**
     * Simple constructor that uses no MatchTracker at all.
     * @param controller the instance used to determine whether a Difference
     * detected by this class should halt further comparison or not
     * @see ComparisonController#haltComparison(Difference)
     */
    public NewDifferenceEngine(ComparisonController controller) {
        this(controller, null);
    }

    /**
     * Simple constructor
     * @param controller the instance used to determine whether a Difference
     * detected by this class should halt further comparison or not
     * @param matchTracker the instance that is notified on each
     * successful match.  May be null.
     * @see ComparisonController#haltComparison(Difference)
     * @see MatchTracker#matchFound(Difference)
     */
    public NewDifferenceEngine(ComparisonController controller,
                               MatchTracker matchTracker) {
        this.controller = controller;
        this.matchTracker = matchTracker;
    }

    /**
     * @param matchTracker the instance that is notified on each
     * successful match.  May be null.
     */
    @Override
    public void setMatchTracker(MatchTracker matchTracker) {
        this.matchTracker = matchTracker;
    }

    /**
     * Entry point for Node comparison testing.
     * @param control Control XML to compare
     * @param test Test XML to compare
     * @param listener Notified of any {@link Difference differences} detected
     * during node comparison testing
     * @param elementQualifier Used to determine which elements qualify for
     * comparison e.g. when a node has repeated child elements that may occur
     * in any sequence and that sequence is not considered important.
     */
    @Override
    public void compare(Node control, Node test, DifferenceListener listener,
                        ElementQualifier elementQualifier) {
        DOMDifferenceEngine engine = new DOMDifferenceEngine();
        engine.setNodeFilter(NodeFilters.AcceptAll);

        final IsBetweenDocumentNodeAndRootElement checkPrelude =
            new IsBetweenDocumentNodeAndRootElement();
        engine.addComparisonListener(checkPrelude);

        if (matchTracker != null) {
            engine
                .addMatchListener(new MatchTracker2ComparisonListener(matchTracker));
        }

        org.xmlunit.diff.ComparisonController mappedController =
            new ComparisonController2ComparisonController(controller);
        engine.setComparisonController(mappedController);
        if (listener != null) {
            final DifferenceEvaluator evaluator =
                DifferenceEvaluators.chain(DifferenceEvaluators.Default,
                                           DifferenceEvaluators.ignorePrologDifferencesExceptDoctype(),
                                           new IgnoreDoctypeNotPresentDifferences(),
                                           new DifferenceListener2DifferenceEvaluator(listener));
            engine.setDifferenceEvaluator(evaluator);
        }

        NodeMatcher m = new DefaultNodeMatcher();
        if (elementQualifier != null) {
            Class<?> c = elementQualifier.getClass();
            if (KNOWN_SELECTORS.containsKey(c)) {
                m = new DefaultNodeMatcher(KNOWN_SELECTORS.get(c));
            } else {
                m = new DefaultNodeMatcher(new ElementQualifier2ElementSelector(elementQualifier));
            }
        }
        if (!XMLUnit.getCompareUnmatched()) {
            engine.setNodeMatcher(m);
        } else {
            engine.setNodeMatcher(new CompareUnmatchedNodeMatcher(m));
        }

        Input.Builder ctrlBuilder = Input.fromNode(control);
        Input.Builder tstBuilder = Input.fromNode(test);

        Source ctrlSource = ctrlBuilder.build();
        Source tstSource = tstBuilder.build();
        if (XMLUnit.getIgnoreComments()) {
            ctrlSource = new CommentLessSource(ctrlSource);
            tstSource = new CommentLessSource(tstSource);
        }
        if (XMLUnit.getNormalizeWhitespace()) {
            ctrlSource = new WhitespaceNormalizedSource(ctrlSource);
            tstSource = new WhitespaceNormalizedSource(tstSource);
        } else if (XMLUnit.getIgnoreWhitespace()) {
            ctrlSource = new WhitespaceStrippedSource(ctrlSource);
            tstSource = new WhitespaceStrippedSource(tstSource);
        }

        engine.compare(ctrlSource, tstSource);
    }

    private static Iterable<Difference> toDifference(org.xmlunit.diff.Difference d) {
        return toDifference(d.getComparison());
    }

    /**
     * Maps a Comparison to Differences.
     * @param comp comparison to map
     * @return Differences
     */
    public static Iterable<Difference> toDifference(Comparison comp) {
        List<Difference> diffs = new LinkedList<Difference>();
        Difference proto = null;
        switch (comp.getType()) {
        case ATTR_VALUE_EXPLICITLY_SPECIFIED:
            proto = ATTR_VALUE_EXPLICITLY_SPECIFIED;
            break;
        case HAS_DOCTYPE_DECLARATION:
            proto = HAS_DOCTYPE_DECLARATION;
            break;
        case DOCTYPE_NAME:
            proto = DOCTYPE_NAME;
            break;
        case DOCTYPE_PUBLIC_ID:
            proto = DOCTYPE_PUBLIC_ID;
            break;
        case DOCTYPE_SYSTEM_ID:
            proto = DOCTYPE_SYSTEM_ID;
            break;
        case SCHEMA_LOCATION:
            proto = SCHEMA_LOCATION;
            break;
        case NO_NAMESPACE_SCHEMA_LOCATION:
            proto = NO_NAMESPACE_SCHEMA_LOCATION;
            break;
        case NODE_TYPE:
            proto = NODE_TYPE;
            break;
        case NAMESPACE_PREFIX:
            proto = NAMESPACE_PREFIX;
            break;
        case NAMESPACE_URI:
            proto = NAMESPACE_URI;
            break;
        case TEXT_VALUE:
            if (comp.getControlDetails().getTarget() instanceof CDATASection) {
                proto = CDATA_VALUE;
            } else if (comp.getControlDetails().getTarget()
                       instanceof Comment) {
                proto = COMMENT_VALUE;
            } else {
                proto = TEXT_VALUE;
            }
            break;
        case PROCESSING_INSTRUCTION_TARGET:
            proto = PROCESSING_INSTRUCTION_TARGET;
            break;
        case PROCESSING_INSTRUCTION_DATA:
            proto = PROCESSING_INSTRUCTION_DATA;
            break;
        case ELEMENT_TAG_NAME:
            proto = ELEMENT_TAG_NAME;
            break;
        case ELEMENT_NUM_ATTRIBUTES:
            proto = ELEMENT_NUM_ATTRIBUTES;
            break;
        case ATTR_VALUE:
            proto = ATTR_VALUE;
            break;
        case CHILD_NODELIST_LENGTH:
            Comparison.Detail cd = comp.getControlDetails();
            Comparison.Detail td = comp.getTestDetails();
            if (ZERO.equals(cd.getValue())
                || ZERO.equals(td.getValue())) {
                diffs.add(new Difference(HAS_CHILD_NODES,
                                         new NodeDetail(String
                                                        .valueOf(!ZERO
                                                                 .equals(cd
                                                                         .getValue())),
                                                        cd.getTarget(),
                                                        cd.getXPath()),
                                         new NodeDetail(String
                                                        .valueOf(!ZERO
                                                                 .equals(td
                                                                         .getValue())),
                                                        td.getTarget(),
                                                        td.getXPath())));
            }
            proto = CHILD_NODELIST_LENGTH;
            break;
        case CHILD_NODELIST_SEQUENCE:
            proto = CHILD_NODELIST_SEQUENCE;
            break;
        case CHILD_LOOKUP:
            proto = CHILD_NODE_NOT_FOUND;
            break;
        case ATTR_NAME_LOOKUP:
            proto = ATTR_NAME_NOT_FOUND;
            break;
        default:
            /* comparison doesn't match one of legacy's built-in differences */
            break;
        }
        if (proto != null) {
            diffs.add(new Difference(proto, toNodeDetail(comp.getControlDetails()),
                                     toNodeDetail(comp.getTestDetails())));
        }
        return diffs;
    }

    /**
     * Maps node details.
     * @param detail XMLUnit 2.x detail
     * @return XMLUnit 1.x detail
     */
    public static NodeDetail toNodeDetail(Comparison.Detail detail) {
        String value = String.valueOf(detail.getValue());
        if (detail.getValue() instanceof Node) {
            value = ((Node) detail.getValue()).getNodeName();
        }
        return new NodeDetail(value, detail.getTarget(),
                              detail.getXPath());
    }

    /**
     * Adapts XMLUnit 1.x MatchTracker to XMLUnit 2.x ComparisonListener.
     */
    public static class MatchTracker2ComparisonListener
        implements ComparisonListener {
        private final MatchTracker mt;

        /**
         * @param m MatchTracker to adapt
         */
        public MatchTracker2ComparisonListener(MatchTracker m) {
            mt = m;
        }

        @Override
        public void comparisonPerformed(Comparison comparison,
                                        ComparisonResult outcome) {
            for (Difference diff : toDifference(comparison)) {
                mt.matchFound(diff);
            }
        }
    }

    /**
     * Adapts XMLUnit 1.x ComparisonController to XMLUnit 2.x ComparisonController.
     */
    public static class ComparisonController2ComparisonController
        implements org.xmlunit.diff.ComparisonController {
        private final ComparisonController cc;
        /**
         * @param c ComparisonController to adapt.
         */
        public ComparisonController2ComparisonController(ComparisonController c) {
            cc = c;
        }

        @Override
        public boolean stopDiffing(org.xmlunit.diff.Difference difference) {
            for (Difference diff : toDifference(difference)) {
                if (cc.haltComparison(diff)) {
                    return true;
                }
            }
            return false;
        }
    }

    /**
     * Adapts XMLUnit 1.x ComparisonQualifider to XMLUnit 2.x ElementSelector.
     */
    public static class ElementQualifier2ElementSelector
        implements ElementSelector {
        private final ElementQualifier eq;

        /**
         * @param eq ElementQualifier to adapt
         */
        public ElementQualifier2ElementSelector(ElementQualifier eq) {
            this.eq = eq;
        }

        @Override
        public boolean canBeCompared(Element controlElement,
                                     Element testElement) {
            return eq.qualifyForComparison(controlElement, testElement);
        }

    }

    private static final class IgnoreDoctypeNotPresentDifferences implements DifferenceEvaluator {
        public ComparisonResult evaluate(Comparison comparison,
                                         ComparisonResult outcome) {
            if (outcome == ComparisonResult.EQUAL) {
                return outcome;
            }
            if (comparison.getType() == ComparisonType.CHILD_LOOKUP
                && (isDoctype(comparison.getControlDetails())
                    || isDoctype(comparison.getTestDetails()))) {
                return ComparisonResult.EQUAL;
            }
            if (comparison.getType() == ComparisonType.CHILD_NODELIST_LENGTH
                && isDocumentWithDocTypeDifference(comparison)
                && Math.abs((Integer) comparison.getControlDetails().getValue()
                            - (Integer) comparison.getTestDetails().getValue())
                   == 1) {
                return ComparisonResult.EQUAL;
            }
            if (comparison.getType() == ComparisonType.CHILD_NODELIST_SEQUENCE
                && isDocumentWithDocTypeDifference(comparison)) {
                return ComparisonResult.EQUAL;
            }
            return outcome;
        }

        private boolean isDoctype(Comparison.Detail detail) {
            return detail != null && detail.getTarget() instanceof DocumentType;
        }

        private boolean isDocumentWithDocTypeDifference(Comparison comparison) {
            if (!(comparison.getControlDetails().getTarget() instanceof Document)) {
                return false;
            }
            return hasDoctypeChild(comparison.getControlDetails().getTarget())
                || hasDoctypeChild(comparison.getTestDetails().getTarget());
        }

        private boolean hasDoctypeChild(Node n) {
            return Linqy.any(new IterableNodeList(n.getChildNodes()),
                             new Predicate<Node>() {
                                 public boolean test(Node n) {
                                     return n instanceof DocumentType;
                                 }
                             });
        }
    }

    /**
     * Adapts XMLUnit 1.x DifferenceListener to XMLUnit 2.x DifferenceEvaluator.
     */
    public static class DifferenceListener2DifferenceEvaluator
        implements DifferenceEvaluator {
        private final DifferenceListener dl;

        /**
         * @param dl DifferenceListener to adapt
         */
        public DifferenceListener2DifferenceEvaluator(DifferenceListener dl) {
            this.dl = dl;
        }

        @Override
        public ComparisonResult evaluate(Comparison comparison,
                                         ComparisonResult outcome) {
            if (outcome == ComparisonResult.EQUAL) {
                return outcome;
            }
            ComparisonResult max = outcome;
            for (Difference diff : toDifference(comparison)) {
                ComparisonResult curr = null;
                switch (dl.differenceFound(diff)) {
                case DifferenceListener
                    .RETURN_IGNORE_DIFFERENCE_NODES_IDENTICAL:
                    curr = ComparisonResult.EQUAL;
                    break;
                case DifferenceListener
                    .RETURN_IGNORE_DIFFERENCE_NODES_SIMILAR:
                    curr = ComparisonResult.SIMILAR;
                    break;
                case DifferenceListener
                    .RETURN_UPGRADE_DIFFERENCE_NODES_DIFFERENT:
                    curr = ComparisonResult.DIFFERENT;
                    break;
                default:
                    // unknown result, ignore it
                    break;
                }
                if (curr != null && curr.compareTo(max) > 0) {
                    max = curr;
                }
            }
            return max;
        }
    }

    /**
     * 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.
     *
     * <p>Relies on the following assumptions:
     * <ul>

     *   <li>the last comparison DOMDifferenceEngine performs on the
     *     document node is an XML_ENCODING comparison.</li>
     *   <li>the first comparison DOMDifferenceEngine performs on matching
     *     root elements is a NODE_TYPE comparison.  The control Node
     *     is an Element Node.</li>
     *   <li>the first comparison DOMDifferenceEngine performs if the
     *     root elements don't match is a CHILD_LOOKUP comparison.
     *     The control Node is an Element Node.</li>
     * </ul>
     * </p>
     */
    private static class IsBetweenDocumentNodeAndRootElement
        implements ComparisonListener {

        private boolean haveSeenXmlEncoding = false;
        private boolean haveSeenElementNodeComparison = false;

        public void comparisonPerformed(Comparison comparison,
                                        ComparisonResult outcome) {
            if (comparison.getType() == ComparisonType.XML_ENCODING) {
                haveSeenXmlEncoding = true;
            } else if (comparison.getControlDetails().getTarget()
                          instanceof Element
                       &&
                       (comparison.getType() == ComparisonType.NODE_TYPE
                        || comparison.getType() == ComparisonType.CHILD_LOOKUP)
                       ) {
                haveSeenElementNodeComparison = true;
            }
        }

        private boolean shouldSkip() {
            return haveSeenXmlEncoding && !haveSeenElementNodeComparison;
        }
    }

    private static class CompareUnmatchedNodeMatcher
        implements NodeMatcher {
        private final NodeMatcher nestedMatcher;
        private CompareUnmatchedNodeMatcher(NodeMatcher nested) {
            nestedMatcher = nested;
        }

        public Iterable<Map.Entry<Node, Node>>
            match(Iterable<Node> controlNodes,
                  Iterable<Node> testNodes) {
            final Map<Node, Node> map = new HashMap<Node, Node>();
            for (Map.Entry<Node, Node> e
                     : nestedMatcher.match(controlNodes, testNodes)) {
                map.put(e.getKey(), e.getValue());
            }

            final LinkedList<Map.Entry<Node, Node>> result =
                new LinkedList<Map.Entry<Node, Node>>();

            for (Node n : controlNodes) {
                if (map.containsKey(n)) {
                    result.add(new Entry(n, map.get(n)));
                } else {
                    Iterable<Node> unmatchedTestElements =
                        Linqy.filter(testNodes, new Predicate<Node>() {
                                @Override
                                public boolean test(Node t) {
                                    return !map.containsValue(t);
                                }
                            });
                    Iterator<Node> it = unmatchedTestElements.iterator();
                    if (it.hasNext()) {
                        Node t = it.next();
                        map.put(n, t);
                        result.add(new Entry(n, t));
                    }
                }
            }
            return result;
        }

        private static class Entry implements Map.Entry<Node, Node> {
            private final Node key;
            private final Node value;
            private Entry(Node k, Node v) {
                key = k;
                value = v;
            }
            public Node getKey() { return key; }
            public Node getValue() { return value; }
            public Node setValue(Node v) {
                throw new UnsupportedOperationException();
            }
        }
    }

}

1	/*
2	******************************************************************
3	Copyright (c) 2001-2010,2013,2015-2016,2018,2022 Jeff Martin, Tim Bacon
4	All rights reserved.
5
6	Redistribution and use in source and binary forms, with or without
7	modification, are permitted provided that the following conditions
8	are met:
9
10	* Redistributions of source code must retain the above copyright
11	notice, this list of conditions and the following disclaimer.
12	* Redistributions in binary form must reproduce the above
13	copyright notice, this list of conditions and the following
14	disclaimer in the documentation and/or other materials provided
15	with the distribution.
16	* Neither the name of the XMLUnit nor the names
17	of its contributors may be used to endorse or promote products
18	derived from this software without specific prior written
19	permission.
20
21	THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
22	"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
23	LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
24	FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
25	COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
26	INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
27	BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
28	LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
29	CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
30	LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
31	ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
32	POSSIBILITY OF SUCH DAMAGE.
33
34	******************************************************************
35	*/
36
37	package org.custommonkey.xmlunit;
38
39	import java.util.Collections;
40	import java.util.HashMap;
41	import java.util.Iterator;
42	import java.util.LinkedList;
43	import java.util.List;
44	import java.util.Map;
45	import javax.xml.transform.Source;
46
47	import org.xmlunit.builder.Input;
48	import org.xmlunit.diff.ByNameAndTextRecSelector;
49	import org.xmlunit.diff.Comparison;
50	import org.xmlunit.diff.ComparisonListener;
51	import org.xmlunit.diff.ComparisonResult;
52	import org.xmlunit.diff.ComparisonType;
53	import org.xmlunit.diff.DOMDifferenceEngine;
54	import org.xmlunit.diff.DefaultNodeMatcher;
55	import org.xmlunit.diff.DifferenceEvaluator;
56	import org.xmlunit.diff.DifferenceEvaluators;
57	import org.xmlunit.diff.ElementSelector;
58	import org.xmlunit.diff.ElementSelectors;
59	import org.xmlunit.diff.NodeFilters;
60	import org.xmlunit.diff.NodeMatcher;
61	import org.xmlunit.input.CommentLessSource;
62	import org.xmlunit.input.WhitespaceNormalizedSource;
63	import org.xmlunit.input.WhitespaceStrippedSource;
64	import org.xmlunit.util.IterableNodeList;
65	import org.xmlunit.util.Linqy;
66	import org.xmlunit.util.Predicate;
67	import org.custommonkey.xmlunit.examples.RecursiveElementNameAndTextQualifier;
68
69	import org.w3c.dom.CDATASection;
70	import org.w3c.dom.Comment;
71	import org.w3c.dom.Document;
72	import org.w3c.dom.DocumentType;
73	import org.w3c.dom.Element;
74	import org.w3c.dom.Node;
75
76	/**
77	* Class that has responsibility for comparing Nodes and notifying a
78	* DifferenceListener of any differences or dissimilarities that are found.
79	* Knows how to compare namespaces and nested child nodes, but currently
80	* only compares nodes of type ELEMENT_NODE, CDATA_SECTION_NODE,
81	* COMMENT_NODE, DOCUMENT_TYPE_NODE, PROCESSING_INSTRUCTION_NODE and TEXT_NODE.
82	* Nodes of other types (eg ENTITY_NODE) will be skipped.
83	* @see DifferenceListener#differenceFound(Difference)
84	*/
85	public class NewDifferenceEngine
86	implements DifferenceConstants, DifferenceEngineContract {
87
88	private static final Integer ZERO = Integer.valueOf(0);	1✔
89	private static final Map<Class<? extends ElementQualifier>, ElementSelector>
90	KNOWN_SELECTORS;
91	static {
92	Map<Class<? extends ElementQualifier>, ElementSelector> m =	1✔
93	new HashMap<Class<? extends ElementQualifier>, ElementSelector>();
94	m.put(ElementNameAndTextQualifier.class,	1✔
95	ElementSelectors.byNameAndText);
96	m.put(ElementNameQualifier.class, ElementSelectors.byName);	1✔
97	m.put(RecursiveElementNameAndTextQualifier.class,	1✔
98	new ByNameAndTextRecSelector());
99	KNOWN_SELECTORS = Collections.unmodifiableMap(m);	1✔
100	}	1✔
101
102	private final ComparisonController controller;
103	private MatchTracker matchTracker;
104
105	/**
106	* Simple constructor that uses no MatchTracker at all.
107	* @param controller the instance used to determine whether a Difference
108	* detected by this class should halt further comparison or not
109	* @see ComparisonController#haltComparison(Difference)
110	*/
111	public NewDifferenceEngine(ComparisonController controller) {
112	this(controller, null);	1✔
113	}	1✔
114
115	/**
116	* Simple constructor
117	* @param controller the instance used to determine whether a Difference
118	* detected by this class should halt further comparison or not
119	* @param matchTracker the instance that is notified on each
120	* successful match. May be null.
121	* @see ComparisonController#haltComparison(Difference)
122	* @see MatchTracker#matchFound(Difference)
123	*/
124	public NewDifferenceEngine(ComparisonController controller,
125	MatchTracker matchTracker) {	1✔
126	this.controller = controller;	1✔
127	this.matchTracker = matchTracker;	1✔
128	}	1✔
129
130	/**
131	* @param matchTracker the instance that is notified on each
132	* successful match. May be null.
133	*/
134	@Override
135	public void setMatchTracker(MatchTracker matchTracker) {
136	this.matchTracker = matchTracker;	1✔
137	}	1✔
138
139	/**
140	* Entry point for Node comparison testing.
141	* @param control Control XML to compare
142	* @param test Test XML to compare
143	* @param listener Notified of any {@link Difference differences} detected
144	* during node comparison testing
145	* @param elementQualifier Used to determine which elements qualify for
146	* comparison e.g. when a node has repeated child elements that may occur
147	* in any sequence and that sequence is not considered important.
148	*/
149	@Override
150	public void compare(Node control, Node test, DifferenceListener listener,
151	ElementQualifier elementQualifier) {
152	DOMDifferenceEngine engine = new DOMDifferenceEngine();	1✔
153	engine.setNodeFilter(NodeFilters.AcceptAll);	1✔
154
155	final IsBetweenDocumentNodeAndRootElement checkPrelude =	1✔
156	new IsBetweenDocumentNodeAndRootElement();
157	engine.addComparisonListener(checkPrelude);	1✔
158
159	if (matchTracker != null) {	1✔
160	engine	1✔
161	.addMatchListener(new MatchTracker2ComparisonListener(matchTracker));	1✔
162	}
163
164	org.xmlunit.diff.ComparisonController mappedController =	1✔
165	new ComparisonController2ComparisonController(controller);
166	engine.setComparisonController(mappedController);	1✔
167	if (listener != null) {	1!
168	final DifferenceEvaluator evaluator =	1✔
169	DifferenceEvaluators.chain(DifferenceEvaluators.Default,	1✔
170	DifferenceEvaluators.ignorePrologDifferencesExceptDoctype(),	1✔
171	new IgnoreDoctypeNotPresentDifferences(),
172	new DifferenceListener2DifferenceEvaluator(listener));
173	engine.setDifferenceEvaluator(evaluator);	1✔
174	}
175
176	NodeMatcher m = new DefaultNodeMatcher();	1✔
177	if (elementQualifier != null) {	1✔
178	Class<?> c = elementQualifier.getClass();	1✔
179	if (KNOWN_SELECTORS.containsKey(c)) {	1✔
180	m = new DefaultNodeMatcher(KNOWN_SELECTORS.get(c));	1✔
181	} else {
182	m = new DefaultNodeMatcher(new ElementQualifier2ElementSelector(elementQualifier));	1✔
183	}
184	}
185	if (!XMLUnit.getCompareUnmatched()) {	1✔
186	engine.setNodeMatcher(m);	1✔
187	} else {
188	engine.setNodeMatcher(new CompareUnmatchedNodeMatcher(m));	1✔
189	}
190
191	Input.Builder ctrlBuilder = Input.fromNode(control);	1✔
192	Input.Builder tstBuilder = Input.fromNode(test);	1✔
193
194	Source ctrlSource = ctrlBuilder.build();	1✔
195	Source tstSource = tstBuilder.build();	1✔
196	if (XMLUnit.getIgnoreComments()) {	1✔
197	ctrlSource = new CommentLessSource(ctrlSource);	1✔
198	tstSource = new CommentLessSource(tstSource);	1✔
199	}
200	if (XMLUnit.getNormalizeWhitespace()) {	1✔
201	ctrlSource = new WhitespaceNormalizedSource(ctrlSource);	1✔
202	tstSource = new WhitespaceNormalizedSource(tstSource);	1✔
203	} else if (XMLUnit.getIgnoreWhitespace()) {	1✔
204	ctrlSource = new WhitespaceStrippedSource(ctrlSource);	1✔
205	tstSource = new WhitespaceStrippedSource(tstSource);	1✔
206	}
207
208	engine.compare(ctrlSource, tstSource);	1✔
209	}	1✔
210
211	private static Iterable<Difference> toDifference(org.xmlunit.diff.Difference d) {
212	return toDifference(d.getComparison());	1✔
213	}
214
215	/**
216	* Maps a Comparison to Differences.
217	* @param comp comparison to map
218	* @return Differences
219	*/
220	public static Iterable<Difference> toDifference(Comparison comp) {
221	List<Difference> diffs = new LinkedList<Difference>();	1✔
222	Difference proto = null;	1✔
223	switch (comp.getType()) {	1!
224	case ATTR_VALUE_EXPLICITLY_SPECIFIED:
225	proto = ATTR_VALUE_EXPLICITLY_SPECIFIED;	×
226	break;	×
227	case HAS_DOCTYPE_DECLARATION:
228	proto = HAS_DOCTYPE_DECLARATION;	1✔
229	break;	1✔
230	case DOCTYPE_NAME:
231	proto = DOCTYPE_NAME;	×
232	break;	×
233	case DOCTYPE_PUBLIC_ID:
234	proto = DOCTYPE_PUBLIC_ID;	1✔
235	break;	1✔
236	case DOCTYPE_SYSTEM_ID:
237	proto = DOCTYPE_SYSTEM_ID;	1✔
238	break;	1✔
239	case SCHEMA_LOCATION:
240	proto = SCHEMA_LOCATION;	1✔
241	break;	1✔
242	case NO_NAMESPACE_SCHEMA_LOCATION:
243	proto = NO_NAMESPACE_SCHEMA_LOCATION;	1✔
244	break;	1✔
245	case NODE_TYPE:
246	proto = NODE_TYPE;	1✔
247	break;	1✔
248	case NAMESPACE_PREFIX:
249	proto = NAMESPACE_PREFIX;	1✔
250	break;	1✔
251	case NAMESPACE_URI:
252	proto = NAMESPACE_URI;	1✔
253	break;	1✔
254	case TEXT_VALUE:
255	if (comp.getControlDetails().getTarget() instanceof CDATASection) {	1✔
256	proto = CDATA_VALUE;	1✔
257	} else if (comp.getControlDetails().getTarget()	1✔
258	instanceof Comment) {
259	proto = COMMENT_VALUE;	1✔
260	} else {
261	proto = TEXT_VALUE;	1✔
262	}
263	break;	1✔
264	case PROCESSING_INSTRUCTION_TARGET:
265	proto = PROCESSING_INSTRUCTION_TARGET;	1✔
266	break;	1✔
267	case PROCESSING_INSTRUCTION_DATA:
268	proto = PROCESSING_INSTRUCTION_DATA;	×
269	break;	×
270	case ELEMENT_TAG_NAME:
271	proto = ELEMENT_TAG_NAME;	1✔
272	break;	1✔
273	case ELEMENT_NUM_ATTRIBUTES:
274	proto = ELEMENT_NUM_ATTRIBUTES;	1✔
275	break;	1✔
276	case ATTR_VALUE:
277	proto = ATTR_VALUE;	1✔
278	break;	1✔
279	case CHILD_NODELIST_LENGTH:
280	Comparison.Detail cd = comp.getControlDetails();	1✔
281	Comparison.Detail td = comp.getTestDetails();	1✔
282	if (ZERO.equals(cd.getValue())	1✔
283	\|\| ZERO.equals(td.getValue())) {	1✔
284	diffs.add(new Difference(HAS_CHILD_NODES,	1✔
285	new NodeDetail(String
286	.valueOf(!ZERO	1✔
287	.equals(cd	1✔
288	.getValue())),	1✔
289	cd.getTarget(),	1✔
290	cd.getXPath()),	1✔
291	new NodeDetail(String
292	.valueOf(!ZERO	1✔
293	.equals(td	1✔
294	.getValue())),	1✔
295	td.getTarget(),	1✔
296	td.getXPath())));	1✔
297	}
298	proto = CHILD_NODELIST_LENGTH;	1✔
299	break;	1✔
300	case CHILD_NODELIST_SEQUENCE:
301	proto = CHILD_NODELIST_SEQUENCE;	1✔
302	break;	1✔
303	case CHILD_LOOKUP:
304	proto = CHILD_NODE_NOT_FOUND;	1✔
305	break;	1✔
306	case ATTR_NAME_LOOKUP:
307	proto = ATTR_NAME_NOT_FOUND;	1✔
308	break;	1✔
309	default:
310	/* comparison doesn't match one of legacy's built-in differences */
311	break;
312	}
313	if (proto != null) {	1✔
314	diffs.add(new Difference(proto, toNodeDetail(comp.getControlDetails()),	1✔
315	toNodeDetail(comp.getTestDetails())));	1✔
316	}
317	return diffs;	1✔
318	}
319
320	/**
321	* Maps node details.
322	* @param detail XMLUnit 2.x detail
323	* @return XMLUnit 1.x detail
324	*/
325	public static NodeDetail toNodeDetail(Comparison.Detail detail) {
326	String value = String.valueOf(detail.getValue());	1✔
327	if (detail.getValue() instanceof Node) {	1!
328	value = ((Node) detail.getValue()).getNodeName();	×
329	}
330	return new NodeDetail(value, detail.getTarget(),	1✔
331	detail.getXPath());	1✔
332	}
333
334	/**
335	* Adapts XMLUnit 1.x MatchTracker to XMLUnit 2.x ComparisonListener.
336	*/
337	public static class MatchTracker2ComparisonListener
338	implements ComparisonListener {
339	private final MatchTracker mt;
340
341	/**
342	* @param m MatchTracker to adapt
343	*/
344	public MatchTracker2ComparisonListener(MatchTracker m) {	1✔
345	mt = m;	1✔
346	}	1✔
347
348	@Override
349	public void comparisonPerformed(Comparison comparison,
350	ComparisonResult outcome) {
351	for (Difference diff : toDifference(comparison)) {	1✔
352	mt.matchFound(diff);	1✔
353	}	1✔
354	}	1✔
355	}
356
357	/**
358	* Adapts XMLUnit 1.x ComparisonController to XMLUnit 2.x ComparisonController.
359	*/
360	public static class ComparisonController2ComparisonController
361	implements org.xmlunit.diff.ComparisonController {
362	private final ComparisonController cc;
363	/**
364	* @param c ComparisonController to adapt.
365	*/
366	public ComparisonController2ComparisonController(ComparisonController c) {	1✔
367	cc = c;	1✔
368	}	1✔
369
370	@Override
371	public boolean stopDiffing(org.xmlunit.diff.Difference difference) {
372	for (Difference diff : toDifference(difference)) {	1✔
373	if (cc.haltComparison(diff)) {	1✔
374	return true;	1✔
375	}
376	}	1✔
377	return false;	1✔
378	}
379	}
380
381	/**
382	* Adapts XMLUnit 1.x ComparisonQualifider to XMLUnit 2.x ElementSelector.
383	*/
384	public static class ElementQualifier2ElementSelector
385	implements ElementSelector {
386	private final ElementQualifier eq;
387
388	/**
389	* @param eq ElementQualifier to adapt
390	*/
391	public ElementQualifier2ElementSelector(ElementQualifier eq) {	1✔
392	this.eq = eq;	1✔
393	}	1✔
394
395	@Override
396	public boolean canBeCompared(Element controlElement,
397	Element testElement) {
398	return eq.qualifyForComparison(controlElement, testElement);	1✔
399	}
400
401	}
402
403	private static final class IgnoreDoctypeNotPresentDifferences implements DifferenceEvaluator {
404	public ComparisonResult evaluate(Comparison comparison,
405	ComparisonResult outcome) {
406	if (outcome == ComparisonResult.EQUAL) {	1✔
407	return outcome;	1✔
408	}
409	if (comparison.getType() == ComparisonType.CHILD_LOOKUP	1✔
410	&& (isDoctype(comparison.getControlDetails())	1✔
411	\|\| isDoctype(comparison.getTestDetails()))) {	1!
412	return ComparisonResult.EQUAL;	1✔
413	}
414	if (comparison.getType() == ComparisonType.CHILD_NODELIST_LENGTH	1✔
415	&& isDocumentWithDocTypeDifference(comparison)	1!
416	&& Math.abs((Integer) comparison.getControlDetails().getValue()	×
417	- (Integer) comparison.getTestDetails().getValue())	×
418	== 1) {
419	return ComparisonResult.EQUAL;	×
420	}
421	if (comparison.getType() == ComparisonType.CHILD_NODELIST_SEQUENCE	1✔
422	&& isDocumentWithDocTypeDifference(comparison)) {	1!
423	return ComparisonResult.EQUAL;	×
424	}
425	return outcome;	1✔
426	}
427
428	private boolean isDoctype(Comparison.Detail detail) {
429	return detail != null && detail.getTarget() instanceof DocumentType;	1!
430	}
431
432	private boolean isDocumentWithDocTypeDifference(Comparison comparison) {
433	if (!(comparison.getControlDetails().getTarget() instanceof Document)) {	1!
434	return false;	1✔
435	}
436	return hasDoctypeChild(comparison.getControlDetails().getTarget())	×
437	\|\| hasDoctypeChild(comparison.getTestDetails().getTarget());	×
438	}
439
440	private boolean hasDoctypeChild(Node n) {
441	return Linqy.any(new IterableNodeList(n.getChildNodes()),	×
442	new Predicate<Node>() {	×
443	public boolean test(Node n) {
444	return n instanceof DocumentType;	×
445	}
446	});
447	}
448	}
449
450	/**
451	* Adapts XMLUnit 1.x DifferenceListener to XMLUnit 2.x DifferenceEvaluator.
452	*/
453	public static class DifferenceListener2DifferenceEvaluator
454	implements DifferenceEvaluator {
455	private final DifferenceListener dl;
456
457	/**
458	* @param dl DifferenceListener to adapt
459	*/
460	public DifferenceListener2DifferenceEvaluator(DifferenceListener dl) {	1✔
461	this.dl = dl;	1✔
462	}	1✔
463
464	@Override
465	public ComparisonResult evaluate(Comparison comparison,
466	ComparisonResult outcome) {
467	if (outcome == ComparisonResult.EQUAL) {	1✔
468	return outcome;	1✔
469	}
470	ComparisonResult max = outcome;	1✔
471	for (Difference diff : toDifference(comparison)) {	1✔
472	ComparisonResult curr = null;	1✔
473	switch (dl.differenceFound(diff)) {	1✔
474	case DifferenceListener
475	.RETURN_IGNORE_DIFFERENCE_NODES_IDENTICAL:
476	curr = ComparisonResult.EQUAL;	1✔
477	break;	1✔
478	case DifferenceListener
479	.RETURN_IGNORE_DIFFERENCE_NODES_SIMILAR:
480	curr = ComparisonResult.SIMILAR;	1✔
481	break;	1✔
482	case DifferenceListener
483	.RETURN_UPGRADE_DIFFERENCE_NODES_DIFFERENT:
484	curr = ComparisonResult.DIFFERENT;	1✔
485	break;	1✔
486	default:
487	// unknown result, ignore it
488	break;
489	}
490	if (curr != null && curr.compareTo(max) > 0) {	1✔
491	max = curr;	1✔
492	}
493	}	1✔
494	return max;	1✔
495	}
496	}
497
498	/**
499	* Tests whether the DifferenceEngine is currently processing
500	* comparisons of "things" between the document node and the
501	* document's root element (comments or PIs, mostly) since these
502	* must be ignored for backwards compatibility reasons.
503	*
504	* <p>Relies on the following assumptions:
505	* <ul>
506
507	* <li>the last comparison DOMDifferenceEngine performs on the
508	* document node is an XML_ENCODING comparison.</li>
509	* <li>the first comparison DOMDifferenceEngine performs on matching
510	* root elements is a NODE_TYPE comparison. The control Node
511	* is an Element Node.</li>
512	* <li>the first comparison DOMDifferenceEngine performs if the
513	* root elements don't match is a CHILD_LOOKUP comparison.
514	* The control Node is an Element Node.</li>
515	* </ul>
516	* </p>
517	*/
518	private static class IsBetweenDocumentNodeAndRootElement	1✔
519	implements ComparisonListener {
520
521	private boolean haveSeenXmlEncoding = false;	1✔
522	private boolean haveSeenElementNodeComparison = false;	1✔
523
524	public void comparisonPerformed(Comparison comparison,
525	ComparisonResult outcome) {
526	if (comparison.getType() == ComparisonType.XML_ENCODING) {	1✔
527	haveSeenXmlEncoding = true;	1✔
528	} else if (comparison.getControlDetails().getTarget()	1✔
529	instanceof Element
530	&&
531	(comparison.getType() == ComparisonType.NODE_TYPE	1✔
532	\|\| comparison.getType() == ComparisonType.CHILD_LOOKUP)	1✔
533	) {
534	haveSeenElementNodeComparison = true;	1✔
535	}
536	}	1✔
537
538	private boolean shouldSkip() {
539	return haveSeenXmlEncoding && !haveSeenElementNodeComparison;	×
540	}
541	}
542
543	private static class CompareUnmatchedNodeMatcher
544	implements NodeMatcher {
545	private final NodeMatcher nestedMatcher;
546	private CompareUnmatchedNodeMatcher(NodeMatcher nested) {	1✔
547	nestedMatcher = nested;	1✔
548	}	1✔
549
550	public Iterable<Map.Entry<Node, Node>>
551	match(Iterable<Node> controlNodes,
552	Iterable<Node> testNodes) {
553	final Map<Node, Node> map = new HashMap<Node, Node>();	1✔
554	for (Map.Entry<Node, Node> e
555	: nestedMatcher.match(controlNodes, testNodes)) {	1✔
556	map.put(e.getKey(), e.getValue());	1✔
557	}	1✔
558
559	final LinkedList<Map.Entry<Node, Node>> result =	1✔
560	new LinkedList<Map.Entry<Node, Node>>();
561
562	for (Node n : controlNodes) {	1✔
563	if (map.containsKey(n)) {	1✔
564	result.add(new Entry(n, map.get(n)));	1✔
565	} else {
566	Iterable<Node> unmatchedTestElements =	1✔
567	Linqy.filter(testNodes, new Predicate<Node>() {	1✔
568	@Override
569	public boolean test(Node t) {
570	return !map.containsValue(t);	1✔
571	}
572	});
573	Iterator<Node> it = unmatchedTestElements.iterator();	1✔
574	if (it.hasNext()) {	1✔
575	Node t = it.next();	1✔
576	map.put(n, t);	1✔
577	result.add(new Entry(n, t));	1✔
578	}
579	}
580	}	1✔
581	return result;	1✔
582	}
583
584	private static class Entry implements Map.Entry<Node, Node> {
585	private final Node key;
586	private final Node value;
587	private Entry(Node k, Node v) {	1✔
588	key = k;	1✔
589	value = v;	1✔
590	}	1✔
591	public Node getKey() { return key; }	1✔
592	public Node getValue() { return value; }	1✔
593	public Node setValue(Node v) {
594	throw new UnsupportedOperationException();	×
595	}
596	}
597	}
598
599	}

xmlunit / xmlunit / cd160610-9b67-4752-a2c4-e3a0d82d991e

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous