Sequence order result filtering

Help
Sul123
2013-01-30
2013-03-03
  • Sul123

    Sul123 - 2013-01-30

    Similar questions have been asked on this forum, but didn't the precise answer to what I am looking for.

    I have a question regarding “Similar” and “Identical”. In the following example given on XMLUnit help page:

    <author>Dan Brown</author>
    <category></category>
    

    And

    <category></category>
    <author>Dan Brown</author>
    

    The output comes out to be:

    Similar? true
    Identical? false
    ***********************
    Expected sequence of child nodes ’5′ but was ’7′ – comparing at /books/book/author to at /books/book/author
    ***********************
    ***********************
    Expected sequence of child nodes ’7′ but was ’5′ – comparing at /books/book/category to at /books/book/category
    ***********************

    My question how can we “NOT” include in the output such non-identical information? My problem is that I have a long xml documents to compare. There are cases, where the differences are related to orderring and in addition to others.

    But when I get the total output, it gets kind of difficult to find the actual differences (non-orderring) related.

    I have to manually skip the non-important information (orderring differences) from the actual differences for example if anything is missing in the reference documents or have different content etc.

    Have said that, I read somewhere that such "orderring" problems can be solved with my own "custom DifferenceListener".

    So I did the following, (the whole class):

    import java.io.FileNotFoundException;
    import java.io.FileReader;
    import java.io.IOException;
    import java.io.StringWriter;
    import java.net.URL;
    import java.util.List;
    import org.w3c.dom.Node;
    import javax.xml.transform.OutputKeys;
    import javax.xml.transform.Transformer;
    import javax.xml.transform.TransformerException;
    import javax.xml.transform.TransformerFactory;
    import javax.xml.transform.dom.DOMSource;
    import javax.xml.transform.stream.StreamResult;
    import org.custommonkey.xmlunit.DetailedDiff;
    import org.custommonkey.xmlunit.Diff;
    import org.custommonkey.xmlunit.Difference;
    import org.custommonkey.xmlunit.DifferenceConstants;
    import org.custommonkey.xmlunit.DifferenceListener;
    import org.custommonkey.xmlunit.ElementNameAndAttributeQualifier;
    import org.custommonkey.xmlunit.ElementNameAndTextQualifier;
    import org.custommonkey.xmlunit.ElementNameQualifier;
    import org.custommonkey.xmlunit.MatchTracker;
    import org.custommonkey.xmlunit.NodeDetail;
    import org.custommonkey.xmlunit.XMLUnit;
    import org.custommonkey.xmlunit.examples.MultiLevelElementNameAndTextQualifier;
    import org.custommonkey.xmlunit.examples.RecursiveElementNameAndTextQualifier;
    import org.xml.sax.SAXException;
    public class XMLComparator {
        public static void main(String[] args) {
            URL url1 = XMLComparator.class.getResource("reference.xml");
            URL url2 = XMLComparator.class.getResource("comparison.xml");
            FileReader fr1 = null;
            FileReader fr2 = null;
            try {
                fr1 = new FileReader(url1.getPath());
                fr2 = new FileReader(url2.getPath());
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            }
            XMLUnit.setIgnoreComments(Boolean.TRUE);
            XMLUnit.setIgnoreWhitespace(Boolean.TRUE);
            XMLUnit.setNormalizeWhitespace(Boolean.TRUE);
            XMLUnit.setIgnoreDiffBetweenTextAndCDATA(Boolean.TRUE);
            XMLUnit.setIgnoreAttributeOrder(Boolean.TRUE);
    
            XMLUnit.setCompareUnmatched(Boolean.FALSE);
    
            try {
                Diff diff = new Diff(fr1, fr2);
    
                diff.overrideDifferenceListener(new DifferenceListener() {
    
                    @Override
                    public void skippedComparison(Node arg0, Node arg1) {
                        // TODO Auto-generated method stub
                    }
    
                    @Override
                     public int differenceFound(Difference diff) { 
                         if (diff.getId() == DifferenceConstants.CHILD_NODELIST_SEQUENCE_ID) 
                     {
                         return RETURN_IGNORE_DIFFERENCE_NODES_IDENTICAL;  
                         }
                            
                         return RETURN_ACCEPT_DIFFERENCE;
                     }
    
                });
    
                System.out.println(" Similar ? " + diff.similar());
                System.out.println(" Identical ? " + diff.identical());
    
                DetailedDiff detDiff = new DetailedDiff(diff);
                detDiff.overrideMatchTracker(new MatchTrackerImpl());
                detDiff.overrideElementQualifier(new ElementNameAndTextQualifier());
    
                List differences = detDiff.getAllDifferences();
    
                for (Object object : differences) {
                    Difference difference = (Difference) object;
                    System.out.println("***********************");
                    System.out.println(difference);
                    System.out.println("***********************");
                }
            } catch (SAXException e) {
                e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
    class MatchTrackerImpl implements MatchTracker {
        public void matchFound(Difference difference) {
            if (difference != null) {
                NodeDetail controlNode = difference.getControlNodeDetail();
                NodeDetail testNode = difference.getTestNodeDetail();
                String controlNodeValue = printNode(controlNode.getNode());
                String testNodeValue = printNode(testNode.getNode());
                if (controlNodeValue != null) {
                    // System.out.println("####################");
                    // System.out.println("Control Node: " + controlNodeValue);
                }
                if (testNodeValue != null) {
                    // System.out.println("Test Node: " + testNodeValue);
                    // System.out.println("####################");
                }
            }
        }
        private static String printNode(Node node) {
            if (node != null && node.getNodeType() == Node.ELEMENT_NODE) {
                StringWriter sw = new StringWriter();
                try {
                    Transformer t = TransformerFactory.newInstance()
                            .newTransformer();
                    t.setOutputProperty(OutputKeys.OMIT_XML_DECLARATION, "yes");
                    t.transform(new DOMSource(node), new StreamResult(sw));
                } catch (TransformerException te) {
                    System.out.println("nodeToString Transformer Exception");
                }
                return sw.toString();
            }
            return null;
        }
    }
    

    reference.xml

    <?xml version="1.0" encoding="UTF-8"?>
    <UsernameToken>
        <OtherSrvcName>EXCURSION_AND_TICKETS</OtherSrvcName>
        <OtherSrvcName>TRAVELGUIDE</OtherSrvcName>
    </UsernameToken>
    

    comparison.xml

    <?xml version="1.0" encoding="UTF-8"?>
    <UsernameToken>
        <OtherSrvcName>TRAVELGUIDE</OtherSrvcName>
        <OtherSrvcName>EXCURSION_AND_TICKETS</OtherSrvcName>
    </UsernameToken>
    

    The output:

    Similar ? false
    Identical ? false

    This to some degree resolved my original problem, but my question is why Similar is false? Shouldn't it be 'true' ?

    Secondly, on my slightly changing the XMLs, the entire output then yielded the same original response, which i am not interested in.

    reference.xml

    <?xml version="1.0" encoding="UTF-8"?>
    <UsernameToken>
        <OtherSrvcPref>
            <OtherSrvcName>EXCURSION_AND_TICKETS</OtherSrvcName>
        </OtherSrvcPref>
        <OtherSrvcPref>
            <OtherSrvcName>TRAVELGUIDE</OtherSrvcName>
        </OtherSrvcPref>
    </UsernameToken>
    

    comparision.xml

    <?xml version="1.0" encoding="UTF-8"?>
    <UsernameToken>
        <OtherSrvcPref>
            <OtherSrvcName>TRAVELGUIDE</OtherSrvcName>
        </OtherSrvcPref>
        <OtherSrvcPref>
            <OtherSrvcName>EXCURSION_AND_TICKETS</OtherSrvcName>
        </OtherSrvcPref>
    </UsernameToken>
    

    Output:

    Similar ? false
    Identical ? false
    ***********************
    Expected presence of child node 'OtherSrvcName' but was 'null' - comparing <OtherSrvcName…> at /UsernameToken/OtherSrvcPref/OtherSrvcName to  at null
    ***********************
    ***********************
    Expected presence of child node 'null' but was 'OtherSrvcName' - comparing  at null to <OtherSrvcName…> at /UsernameToken/OtherSrvcPref/OtherSrvcName
    ***********************
    ***********************
    Expected presence of child node 'OtherSrvcName' but was 'null' - comparing <OtherSrvcName…> at /UsernameToken/OtherSrvcPref/OtherSrvcName to  at null
    ***********************
    ***********************
    Expected presence of child node 'null' but was 'OtherSrvcName' - comparing  at null to <OtherSrvcName…> at /UsernameToken/OtherSrvcPref/OtherSrvcName
    ***********************

    Now why am i getting the 'Expected presence…' messages in the output? Shouldn't it just produce the same output as in the previous case, i.e.

    Similar ? false
    Identical ? false

    I don't understand this difference in the behaviour of the output? Could someone please help me out here..

    Thanks.

     
  • Stefan Bodewig

    Stefan Bodewig - 2013-02-01

    As to why you get a similar ? false in you first example, I'll need to investigate it.  At first glance this looks like a bug.

    In the second case XMLUnit doesn't have an ordering problem per se, it is a matching problem.  By default it matches on the element name only so it will compare your OtherSrvcPref elements in the order they appear inside the document - and then complain about the different nested text in their child nodes.  For this you will have to override the ElementQualifier and RecursiveElementNameAndTextQualifier should work for this specific case.

     

Log in to post a comment.

Get latest updates about Open Source Projects, Conferences and News.

Sign up for the SourceForge newsletter:

JavaScript is required for this form.





No, thanks