जावा में 2 XML दस्तावेजों की तुलना करने का सबसे अच्छा तरीका

Question

मैं एक ऐसे एप्लिकेशन के स्वचालित परीक्षण को लिखने की कोशिश कर रहा हूं जो मूल रूप से एक XML संदेश में एक कस्टम संदेश प्रारूप का अनुवाद करता है और इसे दूसरे छोर से बाहर भेजता है। मुझे इनपुट / आउटपुट संदेश जोड़े का एक अच्छा सेट मिला है, इसलिए मुझे केवल इनपुट संदेशों को भेजने और XML संदेश के दूसरे छोर से बाहर आने के लिए सुनना होगा।

जब वास्तविक आउटपुट की अपेक्षा आउटपुट की तुलना करने का समय आता है तो मैं कुछ समस्याओं में भाग रहा हूं। मेरा पहला विचार केवल अपेक्षित और वास्तविक संदेशों पर स्ट्रिंग तुलना करना था। यह बहुत अच्छी तरह से काम नहीं करेगा क्योंकि हमारे द्वारा उपयोग किए गए उदाहरण डेटा को हमेशा लगातार प्रारूपित नहीं किया जाता है और XML नाम स्थान के लिए अक्सर अलग-अलग उपनामों का उपयोग किया जाता है (और कभी-कभी नाम स्थान का उपयोग नहीं किया जाता है।)

मुझे पता है कि मैं दोनों तारों को पार्स कर सकता हूं और फिर प्रत्येक तत्व के माध्यम से चल सकता हूं और उनकी तुलना खुद से कर सकता हूं और ऐसा करना बहुत मुश्किल नहीं होगा, लेकिन मुझे लगता है कि एक बेहतर तरीका या एक पुस्तकालय है जिसका मैं लाभ उठा सकता हूं।

तो, उबला हुआ है, सवाल यह है:

दो जावा स्ट्रिंग्स को देखते हुए, जिनमें दोनों वैध XML हैं, यदि आप शब्दार्थ के समकक्ष हैं, तो आप कैसे निर्धारित करेंगे? बोनस अंक यदि आपके पास यह निर्धारित करने का एक तरीका है कि अंतर क्या हैं।

Answer 1

XMLUnit के लिए एक नौकरी की तरह लगता है

• http://www.xmlunit.org/
• https://github.com/xmlunit

उदाहरण:

public class SomeTest extends XMLTestCase {
  @Test
  public void test() {
    String xml1 = ...
    String xml2 = ...

    XMLUnit.setIgnoreWhitespace(true); // ignore whitespace differences

    // can also compare xml Documents, InputSources, Readers, Diffs
    assertXMLEqual(xml1, xml2);  // assertXMLEquals comes from XMLTestCase
  }
}

Comments

मैं अतीत में XMLUNit के साथ समस्याएं रखता था, यह XML API संस्करणों के साथ हाइपर-चिकोटी है और विश्वसनीय साबित नहीं हुआ है। जब से मैंने इसे XOM के लिए डिसाइड किया है, तब से कुछ समय हो गया है, इसलिए शायद यह तब से इंपैक्ट है।

— स्केफमैन

XMLUnit के शुरुआती लोगों के लिए, ध्यान दें कि, डिफ़ॉल्ट रूप से myDiff.similar () झूठा वापस आ जाएगा यदि नियंत्रण और परीक्षण दस्तावेज़ इंडेंटेशन / नईलाइन्स में भिन्न होते हैं। मुझे इस व्यवहार की अपेक्षा myDiff.identical (), और myDiff.similar () से नहीं थी। XMLUnit.setIgnoreWhitespace (सत्य) शामिल करें; अपनी परीक्षा कक्षा में सभी परीक्षणों के लिए व्यवहार को बदलने के लिए अपने सेटअप विधि में, या केवल उस परीक्षा के लिए व्यवहार को बदलने के लिए एक व्यक्तिगत परीक्षा पद्धति में इसका उपयोग करें।

— स्टू

आपकी टिप्पणी के लिए @Stew धन्यवाद, बस XMLUnit से शुरू होता है और मुझे यकीन है कि इस मुद्दे का सामना करना पड़ा होगा। +1

— Jay

यदि आप इसे XMLUnit 2 के साथ जीथब पर कोशिश कर रहे हैं, तो 2 संस्करण यह एक पूर्ण पुनर्लेखन है, इसलिए यह उदाहरण SourceForge पर XMLUnit 1 के लिए है। इसके अलावा, स्रोत पृष्ठ बताता है "जावा 1.x के लिए XMLUnit अभी भी बनाए रखा जाएगा"।

— यंगवार क्रिस्टियनसेन

यह विधि XML के रूप में assertXMLEqual है । जावा ।

— user2818782

Answer 2

निम्नलिखित जाँच करेगा कि क्या दस्तावेज़ मानक JDK पुस्तकालयों के उपयोग के बराबर हैं।

DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance ();
dbf.setNamespaceAware (सही);
dbf.setCoalescing (सही);
dbf.setIgnoringElementContentWhitespace (सही);
dbf.setIgnoringComments (सही);
DocumentBuilder db = dbf.newDocumentBuilder ();

दस्तावेज़ doc1 = db.parse (नई फ़ाइल ("file1.xml"));
doc1.normalizeDocument ();

दस्तावेज़ doc2 = db.parse (नई फ़ाइल ("file2.xml"));
doc2.normalizeDocument ();

Assert.assertTrue (doc1.isEqualNode (doc2));

सामान्य करें () यह सुनिश्चित करने के लिए है कि कोई चक्र नहीं है (तकनीकी रूप से कोई भी नहीं होगा)

उपरोक्त कोड को यद्यपि तत्वों के भीतर सफेद रिक्त स्थान की आवश्यकता होगी, क्योंकि यह इसे संरक्षित और मूल्यांकन करता है। जावा के साथ आने वाला मानक XML पार्सर आपको एक कैनोनिकल संस्करण प्रदान करने के लिए एक सुविधा सेट करने या समझने की अनुमति नहीं देता है xml:spaceकि अगर कोई समस्या हो रही है, तो आपको एक प्रतिस्थापन XML पार्सर जैसे xerces या JDOM का उपयोग करने की आवश्यकता हो सकती है।

Comments

यह पूरी तरह से बिना नामस्थान या "सामान्यीकृत" नामस्थान उपसर्ग के साथ XMLs के लिए काम करता है। मुझे संदेह है कि अगर कोई XML <ns1: a xmlns: ns1 = "ns" /> और दूसरा <ns2: a xmlns: ns2 = "ns" />

— kop1

dbf.setIgnoringElementContentWhitespace (सत्य) का परिणाम नहीं होता है, मैं अपेक्षा करता हूं कि <root> नाम </ root> इस समाधान के साथ <root> नाम </ name> के बराबर नहीं है (दो स्थान के साथ गद्देदार) लेकिन XMLUnit बराबर परिणाम देता है इस मामले (JDK8) में

— मिक्लोस Krivan

मेरे लिए यह लाइन ब्रेक की अनदेखी नहीं करता है, जो एक समस्या है।

— फ्लायआउट 91

setIgnoringElementContentWhitespace(false)

— आर्किमिडीज ट्रेजानो

Answer 3

Xom की एक Canonicalizer उपयोगिता है जो आपके DOM को एक नियमित रूप में बदल देती है, जिसे आप बाद में स्ट्रिंग और तुलना कर सकते हैं। तो व्हाट्सएप अनियमितताओं या विशेषता आदेश की परवाह किए बिना, आप अपने दस्तावेजों की नियमित, अनुमानित तुलना कर सकते हैं।

यह आईडीई में विशेष रूप से अच्छी तरह से काम करता है जिसमें ग्रहण की तरह दृश्य स्ट्रिंग तुलनाकर्ता समर्पित होते हैं। आपको दस्तावेजों के बीच शब्दार्थ अंतरों का एक दृश्य प्रतिनिधित्व मिलता है।

Answer 4

XMLUnit का नवीनतम संस्करण दो एक्सएमआर के बराबर होने के काम में मदद कर सकता है। भी XMLUnit.setIgnoreWhitespace()और XMLUnit.setIgnoreAttributeOrder()मामले में मामले के लिए आवश्यक हो सकता है।

नीचे एक्सएमएल यूनिट उपयोग के एक सरल उदाहरण का कार्य कोड देखें।

import org.custommonkey.xmlunit.DetailedDiff;
import org.custommonkey.xmlunit.XMLUnit;
import org.junit.Assert;

public class TestXml {

    public static void main(String[] args) throws Exception {
        String result = "<abc             attr=\"value1\"                title=\"something\">            </abc>";
        // will be ok
        assertXMLEquals("<abc attr=\"value1\" title=\"something\"></abc>", result);
    }

    public static void assertXMLEquals(String expectedXML, String actualXML) throws Exception {
        XMLUnit.setIgnoreWhitespace(true);
        XMLUnit.setIgnoreAttributeOrder(true);

        DetailedDiff diff = new DetailedDiff(XMLUnit.compareXML(expectedXML, actualXML));

        List<?> allDifferences = diff.getAllDifferences();
        Assert.assertEquals("Differences found: "+ diff.toString(), 0, allDifferences.size());
    }

}

मावेन का उपयोग करते हुए, इसे अपने में जोड़ें pom.xml:

<dependency>
    <groupId>xmlunit</groupId>
    <artifactId>xmlunit</artifactId>
    <version>1.4</version>
</dependency>

Comments

यह उन लोगों के लिए एकदम सही है जिन्हें एक स्थिर विधि से तुलना करने की आवश्यकता है।

— एंडी बी

यह एकदम सही जवाब है। धन्यवाद .. हालांकि मुझे उन नोड्स को अनदेखा करने की आवश्यकता है जो अस्तित्व में नहीं हैं। चूँकि मैं परिणाम आउटपुट में ऐसा आउटपुट नहीं देखना चाहता: बाल नोड "नल" की अपेक्षित उपस्थिति लेकिन ...... मैं ऐसा कैसे कर सकता हूँ? सादर। @acdcjunior

— limonik

XMLUnit.setIgnoreAttributeOrder (सही); काम नहीं करता। यदि कुछ नोड्स का एक अलग क्रम है, तो तुलना विफल हो जाएगी।

— Bevor

[अद्यतन] यह समाधान काम करता है: stackoverflow.com/questions/33695041/…

— 22:06 बजे प्रकाशित किया जाएगा

आपको एहसास है कि "IgnoreAttributeOrder" का अर्थ है विशेषता क्रम को अनदेखा करना और नोड्स के आदेश की उपेक्षा करना, सही नहीं है?

— एकड्यूजनीयर

Answer 5

धन्यवाद, मैंने इसे बढ़ाया, यह कोशिश करो ...

import java.io.ByteArrayInputStream;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;

import org.w3c.dom.Document;
import org.w3c.dom.NamedNodeMap;
import org.w3c.dom.Node;

public class XmlDiff 
{
    private boolean nodeTypeDiff = true;
    private boolean nodeValueDiff = true;

    public boolean diff( String xml1, String xml2, List<String> diffs ) throws Exception
    {
        DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
        dbf.setNamespaceAware(true);
        dbf.setCoalescing(true);
        dbf.setIgnoringElementContentWhitespace(true);
        dbf.setIgnoringComments(true);
        DocumentBuilder db = dbf.newDocumentBuilder();


        Document doc1 = db.parse(new ByteArrayInputStream(xml1.getBytes()));
        Document doc2 = db.parse(new ByteArrayInputStream(xml2.getBytes()));

        doc1.normalizeDocument();
        doc2.normalizeDocument();

        return diff( doc1, doc2, diffs );

    }

    /**
     * Diff 2 nodes and put the diffs in the list 
     */
    public boolean diff( Node node1, Node node2, List<String> diffs ) throws Exception
    {
        if( diffNodeExists( node1, node2, diffs ) )
        {
            return true;
        }

        if( nodeTypeDiff )
        {
            diffNodeType(node1, node2, diffs );
        }

        if( nodeValueDiff )
        {
            diffNodeValue(node1, node2, diffs );
        }


        System.out.println(node1.getNodeName() + "/" + node2.getNodeName());

        diffAttributes( node1, node2, diffs );
        diffNodes( node1, node2, diffs );

        return diffs.size() > 0;
    }

    /**
     * Diff the nodes
     */
    public boolean diffNodes( Node node1, Node node2, List<String> diffs ) throws Exception
    {
        //Sort by Name
        Map<String,Node> children1 = new LinkedHashMap<String,Node>();      
        for( Node child1 = node1.getFirstChild(); child1 != null; child1 = child1.getNextSibling() )
        {
            children1.put( child1.getNodeName(), child1 );
        }

        //Sort by Name
        Map<String,Node> children2 = new LinkedHashMap<String,Node>();      
        for( Node child2 = node2.getFirstChild(); child2!= null; child2 = child2.getNextSibling() )
        {
            children2.put( child2.getNodeName(), child2 );
        }

        //Diff all the children1
        for( Node child1 : children1.values() )
        {
            Node child2 = children2.remove( child1.getNodeName() );
            diff( child1, child2, diffs );
        }

        //Diff all the children2 left over
        for( Node child2 : children2.values() )
        {
            Node child1 = children1.get( child2.getNodeName() );
            diff( child1, child2, diffs );
        }

        return diffs.size() > 0;
    }


    /**
     * Diff the nodes
     */
    public boolean diffAttributes( Node node1, Node node2, List<String> diffs ) throws Exception
    {        
        //Sort by Name
        NamedNodeMap nodeMap1 = node1.getAttributes();
        Map<String,Node> attributes1 = new LinkedHashMap<String,Node>();        
        for( int index = 0; nodeMap1 != null && index < nodeMap1.getLength(); index++ )
        {
            attributes1.put( nodeMap1.item(index).getNodeName(), nodeMap1.item(index) );
        }

        //Sort by Name
        NamedNodeMap nodeMap2 = node2.getAttributes();
        Map<String,Node> attributes2 = new LinkedHashMap<String,Node>();        
        for( int index = 0; nodeMap2 != null && index < nodeMap2.getLength(); index++ )
        {
            attributes2.put( nodeMap2.item(index).getNodeName(), nodeMap2.item(index) );

        }

        //Diff all the attributes1
        for( Node attribute1 : attributes1.values() )
        {
            Node attribute2 = attributes2.remove( attribute1.getNodeName() );
            diff( attribute1, attribute2, diffs );
        }

        //Diff all the attributes2 left over
        for( Node attribute2 : attributes2.values() )
        {
            Node attribute1 = attributes1.get( attribute2.getNodeName() );
            diff( attribute1, attribute2, diffs );
        }

        return diffs.size() > 0;
    }
    /**
     * Check that the nodes exist
     */
    public boolean diffNodeExists( Node node1, Node node2, List<String> diffs ) throws Exception
    {
        if( node1 == null && node2 == null )
        {
            diffs.add( getPath(node2) + ":node " + node1 + "!=" + node2 + "\n" );
            return true;
        }

        if( node1 == null && node2 != null )
        {
            diffs.add( getPath(node2) + ":node " + node1 + "!=" + node2.getNodeName() );
            return true;
        }

        if( node1 != null && node2 == null )
        {
            diffs.add( getPath(node1) + ":node " + node1.getNodeName() + "!=" + node2 );
            return true;
        }

        return false;
    }

    /**
     * Diff the Node Type
     */
    public boolean diffNodeType( Node node1, Node node2, List<String> diffs ) throws Exception
    {       
        if( node1.getNodeType() != node2.getNodeType() ) 
        {
            diffs.add( getPath(node1) + ":type " + node1.getNodeType() + "!=" + node2.getNodeType() );
            return true;
        }

        return false;
    }

    /**
     * Diff the Node Value
     */
    public boolean diffNodeValue( Node node1, Node node2, List<String> diffs ) throws Exception
    {       
        if( node1.getNodeValue() == null && node2.getNodeValue() == null )
        {
            return false;
        }

        if( node1.getNodeValue() == null && node2.getNodeValue() != null )
        {
            diffs.add( getPath(node1) + ":type " + node1 + "!=" + node2.getNodeValue() );
            return true;
        }

        if( node1.getNodeValue() != null && node2.getNodeValue() == null )
        {
            diffs.add( getPath(node1) + ":type " + node1.getNodeValue() + "!=" + node2 );
            return true;
        }

        if( !node1.getNodeValue().equals( node2.getNodeValue() ) )
        {
            diffs.add( getPath(node1) + ":type " + node1.getNodeValue() + "!=" + node2.getNodeValue() );
            return true;
        }

        return false;
    }


    /**
     * Get the node path
     */
    public String getPath( Node node )
    {
        StringBuilder path = new StringBuilder();

        do
        {           
            path.insert(0, node.getNodeName() );
            path.insert( 0, "/" );
        }
        while( ( node = node.getParentNode() ) != null );

        return path.toString();
    }
}

Comments

काफी देर हो गई, लेकिन बस यह नोट करना चाहता था कि कोड के इस टुकड़े में एक बग है: diffNodes () में, नोड 2 को संदर्भित नहीं किया गया है - दूसरा लूप नोड 1 को गलत तरीके से पुन: उपयोग करता है (मैंने इसे ठीक करने के लिए कोड को संपादित किया है)। इसके अलावा, इसमें 1 सीमा होती है: जिस तरह से बच्चे के नक्शों की कुंजी होती है, उसके कारण यह अंतर उस मामले का समर्थन नहीं करता है जहां तत्व नाम अद्वितीय नहीं होते हैं, अर्थात दोहराए जाने वाले बाल तत्वों वाले तत्व।

— aberrant80

Answer 6

टॉम के जवाब पर बिल्डिंग , यहाँ XMLUnit v2 का उपयोग करके एक उदाहरण दिया गया है।

यह इन मावेन निर्भरता का उपयोग करता है

    <dependency>
        <groupId>org.xmlunit</groupId>
        <artifactId>xmlunit-core</artifactId>
        <version>2.0.0</version>
        <scope>test</scope>
    </dependency>
    <dependency>
        <groupId>org.xmlunit</groupId>
        <artifactId>xmlunit-matchers</artifactId>
        <version>2.0.0</version>
        <scope>test</scope>
    </dependency>

..और यहाँ परीक्षण कोड है

import static org.junit.Assert.assertThat;
import static org.xmlunit.matchers.CompareMatcher.isIdenticalTo;
import org.xmlunit.builder.Input;
import org.xmlunit.input.WhitespaceStrippedSource;

public class SomeTest extends XMLTestCase {
    @Test
    public void test() {
        String result = "<root></root>";
        String expected = "<root>  </root>";

        // ignore whitespace differences
        // https://github.com/xmlunit/user-guide/wiki/Providing-Input-to-XMLUnit#whitespacestrippedsource
        assertThat(result, isIdenticalTo(new WhitespaceStrippedSource(Input.from(expected).build())));

        assertThat(result, isIdenticalTo(Input.from(expected).build())); // will fail due to whitespace differences
    }
}

प्रलेखन है कि यह रूपरेखा है https://github.com/xmlunit/xmlunit#comparing-two-dictionments

Answer 7

Skaffman एक अच्छा जवाब दे रहा है।

एक अन्य तरीका शायद XML को xmlstarlet ( http://xmlstar.sourceforge.net/ ) जैसी कम्मांड लाइन यूटिलिटी का उपयोग करके प्रारूपित करना है और फिर दोनों स्ट्रिंग्स को प्रारूपित करना और फिर परिणामी आउटपुट फ़ाइलों को अलग करने के लिए किसी भी अलग उपयोगिता (लाइब्रेरी) का उपयोग करना है। मुझे नहीं पता कि क्या यह एक अच्छा समाधान है जब मुद्दे नेमस्पेस के साथ हैं।

Answer 8

XML सामग्री की तुलना करने के लिए AssertJ 1.4+ के विशिष्ट दावे हैं:

String expectedXml = "<foo />";
String actualXml = "<bar />";
assertThat(actualXml).isXmlEqualTo(expectedXml);

यहाँ प्रलेखन है

Answer 9

मैं Altova DiffDog का उपयोग कर रहा हूं, जिसमें XML फ़ाइलों की तुलना संरचनात्मक रूप से करने के लिए विकल्प हैं (स्ट्रिंग डेटा की अनदेखी)।

इसका मतलब है कि (यदि 'टेक्स्ट को अनदेखा करें' विकल्प की जाँच करें):

<foo a="xxx" b="xxx">xxx</foo>

तथा

<foo b="yyy" a="yyy">yyy</foo> 

इस अर्थ में समान हैं कि उनमें संरचनात्मक समानता है। यह आसान है यदि आपके पास उदाहरण फ़ाइलें हैं जो डेटा में भिन्न हैं, लेकिन संरचना नहीं!

Comments

केवल माइनस यह है कि यह 30 दिन के परीक्षण के साथ मुफ्त (99 € एक प्रो लाइसेंस के लिए) नहीं है।

— पीमिन कोंस्टेंटिन केफालकोस

मुझे केवल उपयोगिता ( altova.com/diffdog/diff-merge-tool.html ) मिली है ; एक पुस्तकालय है अच्छा लगा।

— dma_k

Answer 10

यह पूर्ण स्ट्रिंग XMLs (उन्हें रास्ते में पुन: स्वरूपित करने) की तुलना करेगा। यह आपके IDE (IntelliJ, Eclipse) के साथ काम करना आसान बनाता है, क्योंकि आप बस क्लिक करते हैं और नेत्रहीन XML फ़ाइलों में अंतर देखते हैं।

import org.apache.xml.security.c14n.CanonicalizationException;
import org.apache.xml.security.c14n.Canonicalizer;
import org.apache.xml.security.c14n.InvalidCanonicalizerException;
import org.w3c.dom.Element;
import org.w3c.dom.bootstrap.DOMImplementationRegistry;
import org.w3c.dom.ls.DOMImplementationLS;
import org.w3c.dom.ls.LSSerializer;
import org.xml.sax.InputSource;
import org.xml.sax.SAXException;

import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.transform.TransformerException;
import java.io.IOException;
import java.io.StringReader;

import static org.apache.xml.security.Init.init;
import static org.junit.Assert.assertEquals;

public class XmlUtils {
    static {
        init();
    }

    public static String toCanonicalXml(String xml) throws InvalidCanonicalizerException, ParserConfigurationException, SAXException, CanonicalizationException, IOException {
        Canonicalizer canon = Canonicalizer.getInstance(Canonicalizer.ALGO_ID_C14N_OMIT_COMMENTS);
        byte canonXmlBytes[] = canon.canonicalize(xml.getBytes());
        return new String(canonXmlBytes);
    }

    public static String prettyFormat(String input) throws TransformerException, ParserConfigurationException, IOException, SAXException, InstantiationException, IllegalAccessException, ClassNotFoundException {
        InputSource src = new InputSource(new StringReader(input));
        Element document = DocumentBuilderFactory.newInstance().newDocumentBuilder().parse(src).getDocumentElement();
        Boolean keepDeclaration = input.startsWith("<?xml");
        DOMImplementationRegistry registry = DOMImplementationRegistry.newInstance();
        DOMImplementationLS impl = (DOMImplementationLS) registry.getDOMImplementation("LS");
        LSSerializer writer = impl.createLSSerializer();
        writer.getDomConfig().setParameter("format-pretty-print", Boolean.TRUE);
        writer.getDomConfig().setParameter("xml-declaration", keepDeclaration);
        return writer.writeToString(document);
    }

    public static void assertXMLEqual(String expected, String actual) throws ParserConfigurationException, IOException, SAXException, CanonicalizationException, InvalidCanonicalizerException, TransformerException, IllegalAccessException, ClassNotFoundException, InstantiationException {
        String canonicalExpected = prettyFormat(toCanonicalXml(expected));
        String canonicalActual = prettyFormat(toCanonicalXml(actual));
        assertEquals(canonicalExpected, canonicalActual);
    }
}

मैं इसे XmlUnit को पसंद करता हूं क्योंकि क्लाइंट कोड (परीक्षण कोड) क्लीनर है।

Comments

यह मेरे द्वारा किए गए दो परीक्षणों में ठीक काम करता है, एक ही XML के साथ और विभिन्न XML के साथ। IntelliJ के साथ तुलना में अंतर एक्सएमएल स्पॉट करने के लिए आसान है।

— यंगर क्रिस्टियनसेन

वैसे, मावेन का उपयोग करने पर आपको इस निर्भरता की आवश्यकता होगी: <निर्भरता> <निर्भरता> <groupId> org.apache.santuario </ groupId> <विरूपण साक्ष्य> xmlsec </ विरूपण साक्ष्य> <संस्करण> 2.0.6 </ संस्करण> </ निर्भरता>

— यंगर क्रिस्टियनसेन

Answer 11

नीचे कोड मेरे लिए काम करता है

String xml1 = ...
String xml2 = ...
XMLUnit.setIgnoreWhitespace(true);
XMLUnit.setIgnoreAttributeOrder(true);
XMLAssert.assertXMLEqual(actualxml, xmlInDb);

Comments

कोई प्रसंग? पुस्तकालय संदर्भ?

— बेन

Answer 12

जावा एप्लिकेशन के साथ JExamXML का उपयोग करना

    import com.a7soft.examxml.ExamXML;
    import com.a7soft.examxml.Options;

       .................

       // Reads two XML files into two strings
       String s1 = readFile("orders1.xml");
       String s2 = readFile("orders.xml");

       // Loads options saved in a property file
       Options.loadOptions("options");

       // Compares two Strings representing XML entities
       System.out.println( ExamXML.compareXMLString( s1, s2 ) );

Answer 13

मुझे मुख्य प्रश्न में अनुरोध के अनुसार समान कार्यक्षमता की आवश्यकता थी। जैसा कि मुझे किसी भी 3 पार्टी पुस्तकालयों का उपयोग करने की अनुमति नहीं थी, मैंने @Archimedes Trajano समाधान पर अपना स्वयं का समाधान बनाया है।

निम्नलिखित मेरा समाधान है।

import java.io.ByteArrayInputStream;
import java.nio.charset.Charset;
import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;

import org.junit.Assert;
import org.w3c.dom.Document;

/**
 * Asserts for asserting XML strings.
 */
public final class AssertXml {

    private AssertXml() {
    }

    private static Pattern NAMESPACE_PATTERN = Pattern.compile("xmlns:(ns\\d+)=\"(.*?)\"");

    /**
     * Asserts that two XML are of identical content (namespace aliases are ignored).
     * 
     * @param expectedXml expected XML
     * @param actualXml actual XML
     * @throws Exception thrown if XML parsing fails
     */
    public static void assertEqualXmls(String expectedXml, String actualXml) throws Exception {
        // Find all namespace mappings
        Map<String, String> fullnamespace2newAlias = new HashMap<String, String>();
        generateNewAliasesForNamespacesFromXml(expectedXml, fullnamespace2newAlias);
        generateNewAliasesForNamespacesFromXml(actualXml, fullnamespace2newAlias);

        for (Entry<String, String> entry : fullnamespace2newAlias.entrySet()) {
            String newAlias = entry.getValue();
            String namespace = entry.getKey();
            Pattern nsReplacePattern = Pattern.compile("xmlns:(ns\\d+)=\"" + namespace + "\"");
            expectedXml = transletaNamespaceAliasesToNewAlias(expectedXml, newAlias, nsReplacePattern);
            actualXml = transletaNamespaceAliasesToNewAlias(actualXml, newAlias, nsReplacePattern);
        }

        // nomralize namespaces accoring to given mapping

        DocumentBuilder db = initDocumentParserFactory();

        Document expectedDocuemnt = db.parse(new ByteArrayInputStream(expectedXml.getBytes(Charset.forName("UTF-8"))));
        expectedDocuemnt.normalizeDocument();

        Document actualDocument = db.parse(new ByteArrayInputStream(actualXml.getBytes(Charset.forName("UTF-8"))));
        actualDocument.normalizeDocument();

        if (!expectedDocuemnt.isEqualNode(actualDocument)) {
            Assert.assertEquals(expectedXml, actualXml); //just to better visualize the diffeences i.e. in eclipse
        }
    }


    private static DocumentBuilder initDocumentParserFactory() throws ParserConfigurationException {
        DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
        dbf.setNamespaceAware(false);
        dbf.setCoalescing(true);
        dbf.setIgnoringElementContentWhitespace(true);
        dbf.setIgnoringComments(true);
        DocumentBuilder db = dbf.newDocumentBuilder();
        return db;
    }

    private static String transletaNamespaceAliasesToNewAlias(String xml, String newAlias, Pattern namespacePattern) {
        Matcher nsMatcherExp = namespacePattern.matcher(xml);
        if (nsMatcherExp.find()) {
            xml = xml.replaceAll(nsMatcherExp.group(1) + "[:]", newAlias + ":");
            xml = xml.replaceAll(nsMatcherExp.group(1) + "=", newAlias + "=");
        }
        return xml;
    }

    private static void generateNewAliasesForNamespacesFromXml(String xml, Map<String, String> fullnamespace2newAlias) {
        Matcher nsMatcher = NAMESPACE_PATTERN.matcher(xml);
        while (nsMatcher.find()) {
            if (!fullnamespace2newAlias.containsKey(nsMatcher.group(2))) {
                fullnamespace2newAlias.put(nsMatcher.group(2), "nsTr" + (fullnamespace2newAlias.size() + 1));
            }
        }
    }

}

यह दो एक्सएमएल स्ट्रिंग्स की तुलना करता है और किसी भी बेमेल नेमस्पेस मैपिंग की देखभाल करता है ताकि दोनों नेटिंग में अद्वितीय मूल्यों का अनुवाद किया जा सके।

नेमस्पेस के अनुवाद के मामले में ठीक हो सकता है। लेकिन मेरी आवश्यकताओं के लिए सिर्फ काम करता है।

Answer 14

चूँकि आप "शब्दशः समतुल्य" कहते हैं, मेरा मानना ​​है कि आप इसका मतलब यह है कि आप वास्तव में सत्यापित करना चाहते हैं कि xml आउटपुट्स (स्ट्रिंग) के बराबर हैं, और आप कुछ ऐसा चाहते हैं

<foo> कुछ सामान यहां </ foo> </ code>

तथा

<foo> कुछ सामान यहां </ foo> </ code>

समकक्ष के रूप में पढ़ें। अंततः यह मायने रखता है कि आप उस वस्तु पर "शब्दार्थ समतुल्य" को कैसे परिभाषित कर रहे हैं जो आप संदेश से पुनर्गठन कर रहे हैं। संदेशों से उस ऑब्जेक्ट का निर्माण करें और जो आप देख रहे हैं उसे परिभाषित करने के लिए एक कस्टम बराबर () का उपयोग करें।

Comments

जवाब नहीं बल्कि एक सवाल।

— कार्तोच