Java DifferenceConstants.ATTR_NAME_NOT_FOUND_ID属性代码示例

/**
 * 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);
}
 

/**
 * 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;
}
 

/**
 * 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;
}
 

@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;
  }
}
 

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;
	}