30

假设我有两个 xml 字符串

<test>
  <elem>a</elem>
  <elem>b</elem>
</test>

<test>
  <elem>b</elem>
  <elem>a</elem>
</test>

如何编写一个比较这两个字符串并忽略元素顺序的测试？

我希望测试尽可能短，没有地方进行 10 行 XML 解析等。我正在寻找一个简单的断言或类似的东西。

我有这个（不起作用）

   Diff diff = XMLUnit.compareXML(expectedString, actualString);   
   XMLAssert.assertXMLEqual("meh", diff, true);
4

9 回答 9

28

对于 xmlunit 2.0（我一直在寻找这个），现在使用DefaultNodeMatcher完成了

Diff diff = Diffbuilder.compare(Input.fromFile(control))
   .withTest(Input.fromFile(test))
   .withNodeMatcher(new DefaultNodeMatcher(ElementSelectors.byNameAndText))
   .build()

希望这有助于这有助于其他人谷歌搜索......

于 2016-02-03T11:59:07.813 回答
18

XMLUnit 会做你想做的事，但你必须指定 elementQualifier。如果没有指定 elementQualifier，它只会比较相同位置的节点。

对于您的示例，您需要一个 ElementNameAndTextQualifer，如果存在与元素名称和它的文本值匹配的节点，这会考虑一个类似的节点，例如：

Diff diff = new Diff(control, toTest);
// we don't care about ordering
diff.overrideElementQualifier(new ElementNameAndTextQualifier());
XMLAssert.assertXMLEqual(diff, true);

您可以在此处阅读有关它的更多信息：http: //xmlunit.sourceforge.net/userguide/html/ar01s03.html#ElementQualifier

于 2013-07-30T04:35:21.430 回答
17

我原来的答案已经过时了。如果我必须再次构建它，我会使用 xmlunit 2 和 xmlunit-matchers。请注意，对于 xml 单元，不同的顺序总是“相似”不等于。

@Test
public void testXmlUnit() {
    String myControlXML = "<test><elem>a</elem><elem>b</elem></test>";
    String expected = "<test><elem>b</elem><elem>a</elem></test>";
    assertThat(myControlXML, isSimilarTo(expected)
            .withNodeMatcher(new DefaultNodeMatcher(ElementSelectors.byNameAndText)));
    //In case you wan't to ignore whitespaces add ignoreWhitespace().normalizeWhitespace()
    assertThat(myControlXML, isSimilarTo(expected)
        .ignoreWhitespace()
        .normalizeWhitespace()
        .withNodeMatcher(new DefaultNodeMatcher(ElementSelectors.byNameAndText)));
}

如果有人仍然不想在这里使用纯 java 实现，那就是。此实现从 xml 中提取内容并比较列表忽略顺序。

public static Document loadXMLFromString(String xml) throws Exception {
    DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
    DocumentBuilder builder = factory.newDocumentBuilder();
    InputSource is = new InputSource(new StringReader(xml));
    return builder.parse(is);
}

@Test
public void test() throws Exception {
    Document doc = loadXMLFromString("<test>\n" +
            "  <elem>b</elem>\n" +
            "  <elem>a</elem>\n" +
            "</test>");
    XPathFactory xPathfactory = XPathFactory.newInstance();
    XPath xpath = xPathfactory.newXPath();
    XPathExpression expr = xpath.compile("//test//elem");
    NodeList all = (NodeList) expr.evaluate(doc, XPathConstants.NODESET);
    List<String> values = new ArrayList<>();
    if (all != null && all.getLength() > 0) {
        for (int i = 0; i < all.getLength(); i++) {
            values.add(all.item(i).getTextContent());
        }
    }
    Set<String> expected = new HashSet<>(Arrays.asList("a", "b"));
    assertThat("List equality without order",
            values, containsInAnyOrder(expected.toArray()));
}
于 2013-05-14T10:22:02.230 回答
1

从比较 XML 中交叉发布忽略子元素的顺序

今天晚上我也有类似的需求，但找不到符合我要求的东西。

我的解决方法是对我想要区分的两个 XML 文件进行排序，按元素名称的字母顺序排序。一旦它们的顺序一致，我就可以使用常规的视觉差异工具来区分这两个排序的文件。

如果这种方法对其他人有用，我已经在http://dalelane.co.uk/blog/?p=3225分享了我编写的用于排序的 python 脚本

于 2014-10-06T02:14:28.440 回答
1

对我来说，我还需要checkForSimilar()在DiffBuilder. 没有它，断言是错误的，说节点的顺序不一样（子列表中的位置不一样）

我的代码是：

 Diff diff = Diffbuilder.compare(Input.fromFile(control))
   .withTest(Input.fromFile(test))
   .withNodeMatcher(new DefaultNodeMatcher(ElementSelectors.byNameAndText))
   .checkForSimilar()
   .build()
于 2017-03-23T10:47:52.763 回答
1

我不知道他们为解决方案采用了哪些版本，但没有任何效果（或者至少很简单）所以这是我为有同样痛苦的人提供的解决方案。

PS 我讨厌人们错过静态方法的导入或 FQN 类名

    @Test
void given2XMLS_are_different_elements_sequence_with_whitespaces(){
    String testXml = "<struct><int>3</int>  <boolean>false</boolean> </struct>";
    String expected = "<struct><boolean>false</boolean><int>3</int></struct>";

    XmlAssert.assertThat(testXml).and(expected)
            .ignoreWhitespace()
            .normalizeWhitespace()
            .withNodeMatcher(new DefaultNodeMatcher(ElementSelectors.byNameAndText))
            .areSimilar();
}
于 2020-09-08T04:11:30.657 回答
1

就像如何比较基于属性相等性的更复杂的 xml 元素匹配的示例name。例如：

<request>
     <param name="foo" style="" type="xs:int"/>
     <param name="Cookie" path="cookie" style="header" type="xs:string" />
</request>

对比

<request>
     <param name="Cookie" path="cookie" style="header" type="xs:string" />
     <param name="foo" style="query" type="xs:int"/>
</request>

使用以下自定义元素限定符：

final Diff diff = XMLUnit.compareXML(controlXml, testXml);
diff.overrideElementQualifier(new ElementNameAndTextQualifier() {

    @Override
    public boolean qualifyForComparison(final Element control, final Element test) {
        // this condition is copied from super.super class
        if (!(control != null && test != null
                      && equalsNamespace(control, test)
                      && getNonNamespacedNodeName(control).equals(getNonNamespacedNodeName(test)))) {
            return false;
        }

        // matching based on 'name' attribute
        if (control.hasAttribute("name") && test.hasAttribute("name")) {
            if (control.getAttribute("name").equals(test.getAttribute("name"))) {
                return true;
            }
        }
        return false;
    }
});
XMLAssert.assertXMLEqual(diff, true);
于 2015-08-21T09:23:46.937 回答
0

选项 1
如果 XML 代码很简单，试试这个：

 String testString = ...
 assertTrue(testString.matches("(?m)^<test>(\\s*<elem>(a|b)</elem>\\s*){2}</test>$"));


选项 2
如果 XML 更复杂，请使用 XML 解析器加载它，并将找到的实际节点与您的参考节点进行比较。

于 2013-05-14T10:12:42.050 回答
0

我最终重写了 xml 并将其比较。让我知道它是否对您遇到类似问题的任何人有所帮助。

import org.apache.commons.lang3.StringUtils;
import org.jdom2.Attribute;
import org.jdom2.Document;
import org.jdom2.Element;
import org.jdom2.input.SAXBuilder;
import org.jdom2.output.Format;
import org.jdom2.output.XMLOutputter;

import java.io.ByteArrayInputStream;
import java.nio.charset.StandardCharsets;
import java.util.List;
import java.util.stream.Collectors;

public class XmlRewriter {
    private static String rewriteXml(String xml) throws Exception {
        SAXBuilder builder = new SAXBuilder();
        Document document = builder.build(new ByteArrayInputStream(xml.getBytes(StandardCharsets.UTF_8)));
        Element root = document.getRootElement();

        XMLOutputter xmlOutputter = new XMLOutputter(Format.getPrettyFormat());

        root.sortChildren((o1, o2) -> {
            if(!StringUtils.equals(o1.getName(), o2.getName())){
                return o1.getName().compareTo(o2.getName());
            }
            // get attributes
            int attrCompare = transformToStr(o1.getAttributes()).compareTo(transformToStr(o2.getAttributes()));
            if(attrCompare!=0){
                return attrCompare;
            }
            if(o1.getValue()!=null && o2.getValue()!=null){
                return o1.getValue().compareTo(o2.getValue());
            }
            return 0;
        });
        return xmlOutputter.outputString(root);
    }

    private static String transformToStr(List<Attribute> attributes){
        return attributes.stream().map(e-> e.getName()+":"+e.getValue()).sorted().collect(Collectors.joining(","));
    }

    public static boolean areXmlSimilar(String xml1, String xml2) throws Exception {
        Diff diff = DiffBuilder.compare(rewriteXml(xml1)).withTest(rewriteXml(xml2))
                .normalizeWhitespace()
                .ignoreWhitespace()
                .ignoreComments()
                .checkForSimilar()
                .withNodeMatcher(new DefaultNodeMatcher(ElementSelectors.byNameAndText))
                .build();

        return !diff.hasDifferences();
    }

// move below into another test class.. 
    @Test
    public void compareXml() throws Exception {
        String xml1 = "<<your first XML str here>>";
        String xml2 = "<<another XML str here>>";
        assertTrue(XmlUtil.areXmlSimilar(xml1, xml2));
    }
}
于 2021-08-16T06:11:36.667 回答