import org.custommonkey.xmlunit.DifferenceConstants; //导入依赖的package包/类
/**
 * 
 * @return true si les deux résultats XML sont identiques en ignorant les champs supplémentaires dans le résultat du process ("actual result")
 * qui ne sont pas présents dans le résultat attendu ("expected result").
 */
public boolean identicalExceptAdditionalFieldsInActual() {
	boolean notIdentical = false;
	
	for (Difference difference : this.getAllDifferences()) {
		if (difference.getId() == DifferenceConstants.CHILD_NODELIST_LENGTH_ID) {
			// possibilité d'accepter des champs en plus dans le "actual"
			int expectedCount = Integer.parseInt(difference.getControlNodeDetail().getValue());
			int actualCount = Integer.parseInt(difference.getTestNodeDetail().getValue());
			
			if (expectedCount > actualCount) { // on accepte les différences s'il y a plus dans le actual que dans l'expected mais pas l'inverse
				notIdentical = true;
			}
		}
	}
	
	return (this.identical() && !notIdentical);
}
 

import org.custommonkey.xmlunit.DifferenceConstants; //导入依赖的package包/类
/**
 * 
 * @return La liste des champs supplémentaires présents dans le résultat d'un process ("actual result")
 * et non présent dans le résultat attendu ("expected result") sous forme de différences ({@link org.custommonkey.xmlunit.Difference}).
 */
public List<Difference> getAdditionalFieldsInActual() {
	List<Difference> differences = new ArrayList<Difference>(this.getAllDifferences()); // deep-copy of the differences
	
    for (Iterator<Difference> it = differences.iterator(); it.hasNext(); ) {
    	Difference difference = it.next();
        if (difference.getId() == DifferenceConstants.CHILD_NODELIST_LENGTH_ID) {
			int expectedCount = Integer.parseInt(difference.getControlNodeDetail().getValue());
			int actualCount = Integer.parseInt(difference.getTestNodeDetail().getValue());
			
			if (expectedCount > actualCount) { // on accepte les différences s'il y a plus dans le actual que dans l'expected mais pas l'inverse
	            it.remove();
			}
        }
        else {
            it.remove();
        }
    }
    
	return differences;
}
 

import org.custommonkey.xmlunit.DifferenceConstants; //导入依赖的package包/类
public int differenceFound(Difference difference) {
    // ignore <recordTime> presence
    if (difference.equals(DifferenceConstants.CHILD_NODE_NOT_FOUND)
            && "recordTime".equals(difference.getTestNodeDetail().getValue())) {
        return RETURN_IGNORE_DIFFERENCE_NODES_IDENTICAL;
    }
    // ignore <recordTime> value
    if (difference.equals(DifferenceConstants.TEXT_VALUE)
            && "recordTime".equals(difference.getTestNodeDetail().getNode().getParentNode().getNodeName())) {
        return RETURN_IGNORE_DIFFERENCE_NODES_IDENTICAL;
    }
    // check if <eventTime> equal
    if (difference.equals(DifferenceConstants.TEXT_VALUE)
            && "eventTime".equals(difference.getTestNodeDetail().getNode().getParentNode().getNodeName())) {
        try {
            Calendar testCal = TimeParser.parseAsCalendar(difference.getTestNodeDetail().getValue());
            Calendar controlCal = TimeParser.parseAsCalendar(difference.getControlNodeDetail().getValue());
            return controlCal.getTimeInMillis() == testCal.getTimeInMillis() ? RETURN_IGNORE_DIFFERENCE_NODES_IDENTICAL
                    : RETURN_ACCEPT_DIFFERENCE;
        } catch (ParseException e) {
            e.printStackTrace();
        }
    }
    return ignore.contains(difference) ? RETURN_IGNORE_DIFFERENCE_NODES_IDENTICAL : RETURN_ACCEPT_DIFFERENCE;
}
 

import org.custommonkey.xmlunit.DifferenceConstants; //导入依赖的package包/类
@Override
public int differenceFound(Difference diff) {

    if (diff.getId() == DifferenceConstants.TEXT_VALUE.getId()) {
        String control = diff.getControlNodeDetail().getValue();
        if (control != null) {
            control = control.trim();
            if (diff.getTestNodeDetail().getValue() != null
                && control.equals(diff.getTestNodeDetail().getValue().trim())) {
                return
                    DifferenceListener.RETURN_IGNORE_DIFFERENCE_NODES_SIMILAR;
            }
        }
    }
    return RETURN_ACCEPT_DIFFERENCE;
}
 

import org.custommonkey.xmlunit.DifferenceConstants; //导入依赖的package包/类
/**
 * Ignores all differences caused by an ignored attribute (see {@link DiffConfiguration#getIgnoredAttributes()}
 * @param difference
 * @return
 */
protected boolean isCausedByIgnoredAttribute(Difference difference) {
	if (difference.getId() == DifferenceConstants.ATTR_NAME_NOT_FOUND_ID){
		//ignore attributes belonging to a certain namespace
		String attrName = difference.getControlNodeDetail().getValue();
		Node node;
		if (attrName == null || attrName.equals(ATTR_NULL)){
			attrName = difference.getTestNodeDetail().getValue();
			node = helper.getDocumentNode(difference, XmlDiffDocumentType.TEST, false);
		}else{
			node = helper.getDocumentNode(difference, XmlDiffDocumentType.CONTROL, false);
		}
		String namespace = helper.getNamespaceOfAttribute(attrName, node.getAttributes());
		if (namespace != null && ignoredNamespacesInAttributes.contains(namespace)){
			//add attribute name to ignored attributes so that a difference in attribute numbers can be caught later on
               getAttributeSetForNode(node, ignoredAttributesMap)
                       .add(attrName);
			return true;
		}
			
	}
	return isCausedByAttribute(difference, false);
}
 

import org.custommonkey.xmlunit.DifferenceConstants; //导入依赖的package包/类
/**
 * Ignores all differences when the test model has added optional attributes
 * missing from the reference.
 * 
 * @param difference
 * @return
 */
protected boolean isCausedByAddingDefaultAttribute(Difference difference) {
    if (difference.getId() == DifferenceConstants.ATTR_NAME_NOT_FOUND_ID) {
        // ignore attributes belonging to a certain namespace
        String attrName = difference.getControlNodeDetail().getValue();
        String testAttrName = difference.getTestNodeDetail().getValue();
        Node node;
        if (attrName == null || attrName.equals(ATTR_NULL)) {
            node = helper.getDocumentNode(difference,
                    XmlDiffDocumentType.TEST, false);
        } else {
            node = helper.getDocumentNode(difference,
                    XmlDiffDocumentType.CONTROL, false);
        }
        Set<String> defaultedAttributesForNode = getAttributeSetForNode(
                node, defaultAttributesMap);
        for (String string : defaultedAttributesForNode) {
            if (testAttrName.equals(string)) {
                return true;
            }
        }
    }
    return false;
}
 

import org.custommonkey.xmlunit.DifferenceConstants; //导入依赖的package包/类
public static void assertXMLIgnorePrefix(String aMessage, Document aExpected, Document aActual) throws Exception {
    XMLUnit.setIgnoreComments(true);
    XMLUnit.setIgnoreWhitespace(true);
    XMLUnit.setIgnoreAttributeOrder(true);

    Diff diff = new Diff(aExpected, aActual);
    diff.overrideDifferenceListener(new DifferenceListener() {

        public void skippedComparison(Node aArg0, Node aArg1) {
        }

        public int differenceFound(Difference aDifference) {
            if (aDifference.getId() == DifferenceConstants.NAMESPACE_PREFIX_ID) {
                return DifferenceListener.RETURN_IGNORE_DIFFERENCE_NODES_IDENTICAL;
            }
            return DifferenceListener.RETURN_ACCEPT_DIFFERENCE;
        }
    });
    try {
        XMLAssert.assertXMLEqual(diff, true);
    } catch (Throwable t) {
        dump(aActual);
        StringWriter sw = new StringWriter();
        t.printStackTrace(new PrintWriter(sw));
        fail(sw.toString());
    }
}
 

import org.custommonkey.xmlunit.DifferenceConstants; //导入依赖的package包/类
@Override
public int differenceFound(Difference aDifference) {
    if (aDifference.getId() == DifferenceConstants.TEXT_VALUE_ID) {
        if (blackList.contains(aDifference.getControlNodeDetail().getNode()
                .getNodeName())) {
            return DifferenceListener.RETURN_IGNORE_DIFFERENCE_NODES_IDENTICAL;
        }
    }

    return DifferenceListener.RETURN_ACCEPT_DIFFERENCE;
}
 

import org.custommonkey.xmlunit.DifferenceConstants; //导入依赖的package包/类
MyDifferenceLister() {
    ignore = new LinkedList<Difference>();
    ignore.add(DifferenceConstants.HAS_DOCTYPE_DECLARATION);
    ignore.add(DifferenceConstants.NAMESPACE_PREFIX);
    ignore.add(DifferenceConstants.CHILD_NODELIST_SEQUENCE);
    ignore.add(DifferenceConstants.CHILD_NODELIST_LENGTH);
    ignore.add(DifferenceConstants.ATTR_SEQUENCE);
    ignore.add(DifferenceConstants.COMMENT_VALUE);
}
 

import org.custommonkey.xmlunit.DifferenceConstants; //导入依赖的package包/类
/**
 * {@inheritDoc}
 */
@Override
public int differenceFound(Difference diff) {
    if (diff.getId() == DifferenceConstants.SCHEMA_LOCATION_ID) {
        String control = reduceWhitespace(diff.getControlNodeDetail());
        String test = reduceWhitespace(diff.getTestNodeDetail());
        if ((control == null && test == null) || (control != null && control.equals(test))) {
            return RETURN_IGNORE_DIFFERENCE_NODES_IDENTICAL;
        }
    }
    return RETURN_ACCEPT_DIFFERENCE;
}
 

import org.custommonkey.xmlunit.DifferenceConstants; //导入依赖的package包/类
@Override
protected boolean equalsInternal(ObjectLocator leftLocator,
		ObjectLocator rightLocator, Node lhs, Node rhs) {
	final Diff diff = new Diff(new DOMSource(lhs), new DOMSource(rhs)) {
		@Override
		public int differenceFound(Difference difference) {
			if (difference.getId() == DifferenceConstants.NAMESPACE_PREFIX_ID) {
				return DifferenceListener.RETURN_IGNORE_DIFFERENCE_NODES_IDENTICAL;
			} else {
				return super.differenceFound(difference);
			}
		}
	};
	return diff.identical();
}
 

import org.custommonkey.xmlunit.DifferenceConstants; //导入依赖的package包/类
/**
 * Delegates to the nested DifferenceListener unless the
 * Difference is of type {@link DifferenceConstants#ATTR_VALUE_ID
 * ATTR_VALUE_ID}, {@link DifferenceConstants#CDATA_VALUE_ID
 * CDATA_VALUE_ID}, {@link DifferenceConstants#COMMENT_VALUE_ID
 * COMMENT_VALUE_ID} or {@link DifferenceConstants#TEXT_VALUE_ID
 * TEXT_VALUE_ID} - for those special differences {@link
 * #attributeDifference attributeDifference}, {@link
 * #cdataDifference cdataDifference}, {@link #commentDifference
 * commentDifference} or {@link #textDifference textDifference}
 * are invoked respectively.
 */
public int differenceFound(Difference difference) {
    switch (difference.getId()) {
    case DifferenceConstants.ATTR_VALUE_ID:
        return attributeDifference(difference);
    case DifferenceConstants.CDATA_VALUE_ID:
        return cdataDifference(difference);
    case DifferenceConstants.COMMENT_VALUE_ID:
        return commentDifference(difference);
    case DifferenceConstants.TEXT_VALUE_ID:
        return textDifference(difference);
    }
    return delegateTo.differenceFound(difference);
}
 

import org.custommonkey.xmlunit.DifferenceConstants; //导入依赖的package包/类
@Override
public int differenceFound(final Difference difference)
{
	if (difference.getId() == DifferenceConstants.TEXT_VALUE_ID
			&& ignoredElements.contains(difference
					.getControlNodeDetail()
					.getNode()
					.getParentNode()
					.getNodeName()))
	{
		return RETURN_IGNORE_DIFFERENCE_NODES_SIMILAR;
	}

	return RETURN_ACCEPT_DIFFERENCE;
}
 

import org.custommonkey.xmlunit.DifferenceConstants; //导入依赖的package包/类
/**
 * Ignores all attribute value differences for attributes marked as being language (locale) specific
 * @param difference
 * @return
 */
protected boolean isCausedByLanguageSettings(Difference difference) {
	if (difference.getId() == DifferenceConstants.ATTR_VALUE_ID && 
			languageSpecificAttributes.contains(difference.getControlNodeDetail().getNode().getLocalName())){
		return true;
	}
	return false;
}
 

import org.custommonkey.xmlunit.DifferenceConstants; //导入依赖的package包/类
/**
 * Checks whether a difference in attribute values is caused by variations in the capitalization of textual representation of the same value
 * Example:
 * 	"true" vs. "TRUE vs. "True"
 * 
 * @param difference
 * @return
 */
protected boolean isCausedByCapitalizationOfAttributeValue(Difference difference) {
	if (difference.getId() == DifferenceConstants.ATTR_VALUE_ID) {
		String testValue = difference.getTestNodeDetail().getValue();
		String controlValue = difference.getControlNodeDetail().getValue();
		
		//check case-insensitive attributes
		String testName = difference.getTestNodeDetail().getNode().getLocalName();
		if (caseInsensitiveAttributes.contains(testName) && testValue.equalsIgnoreCase(controlValue)){
			return true;
		}
	}
	return false;
}
 

import org.custommonkey.xmlunit.DifferenceConstants; //导入依赖的package包/类
/**
 * Server renderer removes all attributes with no values, client renderer doesn't always do this -> 
 * ignore missing attributes if they don't have a value.
 * Also ignores missing transform attributes, when editor generates a "transform='translate(0)'"
 * @param difference
 * @return
 */
protected boolean isCausedByIgnorableAttributeValue(Difference difference) {
	if (difference.getId() == DifferenceConstants.ATTR_NAME_NOT_FOUND_ID) {
		//name is the same for both
		NodeDetail detail = difference.getControlNodeDetail();
		XmlDiffDocumentType type;
		if (detail.getValue() == null || detail.getValue().equals(ATTR_NULL)) {
			type = XmlDiffDocumentType.TEST;
			detail = difference.getTestNodeDetail();
		} else {
			type = XmlDiffDocumentType.CONTROL;
			detail = difference.getControlNodeDetail();
		}
		
		String attrName = detail.getValue();
		if (attrName != null) {
			attrName = helper.addNamespacePrefixToAttribute(attrName, detail.getNode());
			Node attrNode = detail.getNode().getAttributes().getNamedItem(attrName);
			String attrValue = (attrNode == null)? null : attrNode.getNodeValue();
			if (canAttributeBeIgnored(attrName, attrValue)) {
				Node node = helper.getDocumentNode(difference, type, false);
                   getAttributeSetForNode(node, ignoredAttributesMap).add(
                           attrName);
				return true;
			}
		}
	}
	return false;
}
 

import org.custommonkey.xmlunit.DifferenceConstants; //导入依赖的package包/类
/**
 * Editor generates different ids for some attributes.
 * If this difference is caused by such an attribute, the method checks whether the fixed part 
 * corresponds to the common id structure ({@link #REGEXP_ID}) and compares the variable part for equality 
 */
protected boolean isCausedByIgnorableDifferingId(Difference difference) {
	if (difference.getId() == DifferenceConstants.ATTR_VALUE_ID &&
			idsAndIdRefs.contains(difference.getControlNodeDetail().getNode().getLocalName())) {
		
		String controlId = difference.getControlNodeDetail().getValue();
		String testId = difference.getTestNodeDetail().getValue();
		return canDifferingIdBeIgnored(difference, controlId, testId);
	}
	return false;
}
 

import org.custommonkey.xmlunit.DifferenceConstants; //导入依赖的package包/类
/**
 * Sometimes differences are generated, where the namespaces are the same, but the prefixes are different.
 * Ignores such differences
 * 
 * @param difference
 * @return
 */
protected boolean isCausedByNamespaceProblems(Difference difference) {
	if (difference.getId() == DifferenceConstants.NAMESPACE_PREFIX_ID) {
		if (difference.getControlNodeDetail().getNode().getNamespaceURI().equals(
				difference.getTestNodeDetail().getNode().getNamespaceURI())) {
			return true;
		}
	}
	return false;
}
 

import org.custommonkey.xmlunit.DifferenceConstants; //导入依赖的package包/类
@Override
public int differenceFound(Difference difference) {
  switch (difference.getId()) {
    case DifferenceConstants.NAMESPACE_URI_ID:
      return namespaceDifferenceFound(difference);
    case DifferenceConstants.ELEMENT_NUM_ATTRIBUTES_ID:
    case DifferenceConstants.ATTR_NAME_NOT_FOUND_ID:
      return attributeDifferenceFound(difference);
    default:
      return DifferenceListener.RETURN_ACCEPT_DIFFERENCE;
  }
}
 

import org.custommonkey.xmlunit.DifferenceConstants; //导入依赖的package包/类
protected boolean isCausedByAttribute(Difference difference, boolean isOptional) {
		if (difference.getId() != DifferenceConstants.ATTR_NAME_NOT_FOUND_ID
				&& difference.getId() != DifferenceConstants.ELEMENT_NUM_ATTRIBUTES_ID
				&& difference.getId() != DifferenceConstants.HAS_CHILD_NODES_ID
				&& difference.getId() != DifferenceConstants.ATTR_VALUE_ID) {
			return false;
		}

		// get the nodes that are different
		// don't use 'difference.getControlNodeDetail().getNode()' because it
		// returns a node that is not even equal to ones returned by the xPath
		// parser
		Set<String> attributeSet;
		Node node;
		for (XmlDiffDocumentType type : XmlDiffDocumentType.values()) {// test whether one of
															// the document
															// nodes contains an
															// ignored attribute
			// optional attributes must have same value, if they are set
			if (!isOptional && difference.getId() == DifferenceConstants.ATTR_VALUE_ID) {
				// xpath originally points to the actual attribute node ->
				// remove attribute reference from xpath
				node = helper.getDocumentNode(difference, type, true);
				if (node != null){
//					String attributeName = difference.getControlNodeDetail().getNode().getNodeName();
					String attributeName = XPathUtil.getAttributeNameFromXPath(difference.getControlNodeDetail().getXpathLocation());
                    if (getAttributeSetForNode(node, ignoredAttributesMap)
                            .contains(attributeName)) {
						return true;
					}
				}
			}
			node = helper.getDocumentNode(difference, type, false);
			if (node == null) {
				continue;
			}

			if (isOptional) {
                attributeSet = getAttributeSetForNode(node,
                        optionalAttributesMap);
			} else {
                attributeSet = getAttributeSetForNode(node,
                        ignoredAttributesMap);
			}

			switch (difference.getId()) {
			case DifferenceConstants.ATTR_NAME_NOT_FOUND_ID:
				String attrName = difference.getControlNodeDetail().getValue();
				if (attrName == null || attrName.equals(ATTR_NULL)){
					attrName = difference.getTestNodeDetail().getValue();
					attrName = helper.addNamespacePrefixToAttribute(attrName, difference.getTestNodeDetail().getNode());
				}else{
					attrName = helper.addNamespacePrefixToAttribute(attrName, difference.getControlNodeDetail().getNode());
				}
				if (attributeSet.contains(attrName)) {
					return true;
				}
				break;
			case DifferenceConstants.ELEMENT_NUM_ATTRIBUTES_ID:
			case DifferenceConstants.HAS_CHILD_NODES_ID:
				if (attributeSet.size() > 0) {
					return true;
				}
				if (containsAttributesOfIgnoredNamespaces(node)) {
					return true;
				}
				if (containsIgnorableAttributeValues(node)) {
					return true;
				}
				break;
			}
		}
		return false;
	}