Refine search
public class IgnoreNamedElementsDifferenceListener implements DifferenceListener { private Set<String> blackList = new HashSet<String>(); public IgnoreNamedElementsDifferenceListener(String ... elementNames) { for (String name : elementNames) { blackList.add(name); } } public int differenceFound(Difference difference) { if (difference.getId() == DifferenceConstants.TEXT_VALUE_ID) { if (blackList.contains(difference.getControlNodeDetail().getNode().getParentNode().getNodeName())) { return DifferenceListener.RETURN_IGNORE_DIFFERENCE_NODES_IDENTICAL; } } return DifferenceListener.RETURN_ACCEPT_DIFFERENCE; } public void skippedComparison(Node node, Node node1) { } }
public int differenceFound(Difference diff) { String nodeName = diff.getTestNodeDetail().getNode().getNodeName(); if( sequenceDoesNotMatter.contains(nodeName) && diff.getId() == DifferenceConstants.CHILD_NODELIST_SEQUENCE_ID ) { return RETURN_IGNORE_DIFFERENCE_NODES_IDENTICAL; } logger.info( "! {}", diff.getTestNodeDetail().getNode().getNodeName()); return RETURN_ACCEPT_DIFFERENCE; }
public int differenceFound(Difference diff) { String nodeName = diff.getTestNodeDetail().getNode().getNodeName(); if (nodeName.equals("conditionExpression") || nodeName.equals("language")) { logger.info(diff.toString()); return RETURN_ACCEPT_DIFFERENCE; } return RETURN_IGNORE_DIFFERENCE_NODES_IDENTICAL; }
@Override public int differenceFound(Difference d) { if (d.getId() == DifferenceConstants.CHILD_NODELIST_LENGTH_ID) { Node controlNode = d.getControlNodeDetail().getNode(); Node testNode = d.getTestNodeDetail().getNode(); if (getRelevantChildNodesCount(controlNode) == getRelevantChildNodesCount(testNode)) { return RETURN_IGNORE_DIFFERENCE_NODES_IDENTICAL; if (d.getId() == DifferenceConstants.CHILD_NODELIST_SEQUENCE_ID) { Node controlNode = d.getControlNodeDetail().getNode(); Node testNode = d.getTestNodeDetail().getNode(); if (haveSameRelevantChildNodes(controlNode, testNode)) { return RETURN_IGNORE_DIFFERENCE_NODES_IDENTICAL; if (d.getId() == DifferenceConstants.CHILD_NODE_NOT_FOUND_ID) { Node controlNode = d.getControlNodeDetail().getNode(); Node testNode = d.getTestNodeDetail().getNode(); if (((controlNode != null) && isIrrelevantChildNode(controlNode)) || ((testNode != null) && isIrrelevantChildNode(testNode))) { if (d.getId() == DifferenceConstants.ELEMENT_NUM_ATTRIBUTES_ID) { Element controlElement = (Element) d.getControlNodeDetail().getNode(); Element testElement = (Element) d.getTestNodeDetail().getNode(); if (getRelevantAttributesCount(controlElement) == getRelevantAttributesCount(testElement)) { return RETURN_IGNORE_DIFFERENCE_NODES_IDENTICAL; if (d.getId() == DifferenceConstants.ATTR_NAME_NOT_FOUND_ID) { Element controlElement = (Element) d.getControlNodeDetail().getNode(); Element testElement = (Element) d.getTestNodeDetail().getNode(); if (haveSameRelevantAttributes(controlElement, testElement)
public int differenceFound(Difference difference) { Node controlNode = difference.getControlNodeDetail().getNode(); Node testNode = difference.getTestNodeDetail().getNode(); if (controlNode.getNodeType() == Node.TEXT_NODE && testNode.getNodeType() == Node.TEXT_NODE) { String controlText = controlNode.getNodeValue().trim(); String testText = testNode.getNodeValue().trim(); if (controlText.equals("") && testText.equals("")) { return RETURN_IGNORE_DIFFERENCE_NODES_IDENTICAL; } } return RETURN_ACCEPT_DIFFERENCE; }
protected int textualDifference(Difference d) { String control = d.getControlNodeDetail().getValue(); if (control != null) { control = control.toLowerCase(Locale.US); if (d.getTestNodeDetail().getValue() != null && control.equals(d.getTestNodeDetail().getValue() .toLowerCase(Locale.US))) { return DifferenceListener.RETURN_IGNORE_DIFFERENCE_NODES_IDENTICAL; } } // some string is null, delegate return super.textualDifference(d); } }
Diff diff = new Diff(doc1, doc2); diff.overrideDifferenceListener(new DifferenceListener() { ... @Override public int differenceFound(Difference difference) { if(difference.getId() == DifferenceConstants.HAS_CHILD_NODES_ID) { Node controlNode = difference.getControlNodeDetail().getNode(); Node testNode = difference.getTestNodeDetail().getNode(); if(controlNode.getChildNodes().getLength() == 0) { Node childNode = testNode.getChildNodes().item(0); // note the trim method call if(childNode.getNodeType() == Node.TEXT_NODE && childNode.getTextContent().trim().isEmpty()) { return DifferenceListener.RETURN_IGNORE_DIFFERENCE_NODES_IDENTICAL; } } else { // we're sure the other node has children in the else part Node childNode = controlNode.getChildNodes().item(0); if(childNode.getNodeType() == Node.TEXT_NODE && childNode.getTextContent().trim().isEmpty()) { return DifferenceListener.RETURN_IGNORE_DIFFERENCE_NODES_IDENTICAL; } } } return DifferenceListener.RETURN_ACCEPT_DIFFERENCE; } });
protected boolean ignoreDifference(final Difference d) { if ("text value".equals(d.getDescription())) { final String controlValue = d.getControlNodeDetail().getValue(); final String testValue = d.getTestNodeDetail().getValue(); return (controlValue == null || controlValue.trim().isEmpty()) && (testValue == null || testValue.trim().isEmpty()); } return false; }
@Override public int differenceFound(Difference difference) { String value = difference.getControlNodeDetail().getValue(); String tvalue = null; if (difference.getControlNodeDetail().getNode() != null) { tvalue = difference.getControlNodeDetail().getNode().getTextContent(); } if ("*".equals(value) || "*".equals(tvalue)) { return RETURN_IGNORE_DIFFERENCE_NODES_IDENTICAL; } else { return RETURN_ACCEPT_DIFFERENCE; } } });
XMLUnit.setIgnoreWhitespace(true); XMLUnit.setIgnoreComments(true); XMLUnit.setIgnoreAttributeOrder(true); Diff xmlDiff = new Diff(expected, test); xmlDiff.overrideDifferenceListener(new DifferenceListener() { @Override public int differenceFound(Difference diff) { System.err.println("called: " + diff); int diffResult = RETURN_ACCEPT_DIFFERENCE; //ignore a node difference if(diff.getControlNodeDetail().getNode().getParentNode().getNodeName().contains("myNodeName")){ skippedComparison(diff.getControlNodeDetail().getNode().getParentNode(), diff.getTestNodeDetail().getNode().getParentNode()); diffResult = RETURN_IGNORE_DIFFERENCE_NODES_IDENTICAL; } return diffResult; } @Override public void skippedComparison(Node arg0, Node arg1) {} }); assertTrue(xmlDiff.similar());
public int differenceFound(Difference difference) { //ignore dissimilarities if (difference.isRecoverable()) { return RETURN_ACCEPT_DIFFERENCE; } if ("${IGNORE}".equals(difference.getControlNodeDetail().getValue())) { return RETURN_IGNORE_DIFFERENCE_NODES_SIMILAR; } else if (isDifferenceOnlyInAttributeValuePrefix(difference)) { return RETURN_IGNORE_DIFFERENCE_NODES_SIMILAR; } else { return super.differenceFound(difference); } }
@Override public int differenceFound(Difference difference) { if (excludedNodes.contains(difference.getControlNodeDetail().getNode().getLocalName())) return 1; else { return 0; } }
private boolean isIgnoredDifference(Difference difference) { int differenceId = difference.getId(); for (int i=0; i < IGNORE_VALUES.length; ++i) { if (differenceId == IGNORE_VALUES[i]) { return true; } } return false; }
/** * If a difference is found when comparing xml it will trigger a call to * differenceFound. Determine if the difference can be ignored (part of * the IGNORED_NODES) or if it's a 'true' difference. */ @Override public int differenceFound(Difference arg0) { String elemXpathVal = arg0.getControlNodeDetail() .getXpathLocation(); if (IGNORED_NODES.contains(elemXpathVal)) { return RETURN_IGNORE_DIFFERENCE_NODES_IDENTICAL; } System.out.println(" ** Difference Found:"); System.out.println("\t" + arg0.toString() + "\n"); return RETURN_ACCEPT_DIFFERENCE; }
/** * Copy constructor using prototype Difference and * encountered NodeDetails */ protected Difference(Difference prototype, NodeDetail controlNodeDetail, NodeDetail testNodeDetail) { this(prototype.getId(), prototype.getDescription(), prototype.isRecoverable()); this.controlNodeDetail = controlNodeDetail; this.testNodeDetail = testNodeDetail; }
public class IgnoreMyAttributeElements implements DifferenceListener() { @Override public int differenceFound(Difference differenceIn) { Node controlNode = differenceIn.getControlNodeDetail().getNode(); if(controlNode.getNodeType() == Node.ELEMENT_NODE) { if(controlNode.getLocalName().equals("myelement"); { return DifferenceListener.RETURN_IGNORE_DIFFERENCE_NODES_IDENTICAL; } } return DifferenceListener.RETURN_ACCEPT_DIFFERENCE; } @Override public void skippedComparison(Node nodeIn, Node nodeIn2) { //don't care about these events } }
XpathNodeTracker testLoc) throws DifferenceFoundException { NodeDetail controlDetail = new NodeDetail(String.valueOf(expected), control, controlLoc == null ? null : controlLoc.toXpathString()); NodeDetail testDetail = new NodeDetail(String.valueOf(actual), test, testLoc == null ? null : testLoc.toXpathString()); Difference differenceInstance = new Difference(difference, controlDetail, testDetail); if (unequal(expected, actual)) {
private void compareXML(String expected, String actual) throws Exception { setNormalizeWhitespace(true); setIgnoreWhitespace(true); setIgnoreComments(true); setIgnoreAttributeOrder(false); Diff diff = XMLUnit.compareXML(expected, actual); if (!(diff.similar() && diff.identical())) { System.out.println(actual); DetailedDiff detDiff = new DetailedDiff(diff); @SuppressWarnings("rawtypes") List differences = detDiff.getAllDifferences(); StringBuilder diffLines = new StringBuilder(); for (Object object : differences) { Difference difference = (Difference) object; diffLines.append(difference.toString() + '\n'); } throw new IllegalArgumentException("Actual XML differs from expected: \n" + diffLines.toString()); } } }
case RETURN_ACCEPT_DIFFERENCE: identical = false; if (difference.isRecoverable()) { haltComparison = false; } else {
ReflectionComparatorMode[] modes = {ReflectionComparatorMode.LENIENT_ORDER, ReflectionComparatorMode.IGNORE_DEFAULTS}; List<org.unitils.reflectionassert.comparator.Comparator> comparators = new ArrayList<>(); comparators.add(new Comparator() { @Override public boolean canCompare(Object left, Object right) { return left instanceof String && right instanceof String; } @Override public Difference compare(Object left, Object right, boolean onlyFirstDifference, ReflectionComparator reflectionComparator) { return ((String) left).equalsIgnoreCase((String) right) ? null : new Difference("Non equal values: ", left, right); } }); comparators.addAll( new ReflectionComparatorFactory() { public List<Comparator> getComparatorChainNonStatic(Set<ReflectionComparatorMode> modes) { return getComparatorChain(modes); } }.getComparatorChainNonStatic(asSet(modes))); ReflectionComparator comparator = new ReflectionComparator(comparators);