Question

在单元测试中我将XElement对象与我期望的对象进行比较。我使用的方法是在.ToString()对象上调用XElement并将其与硬编码的字符串值进行比较。这种方法非常不舒服，因为我总是要注意字符串中的格式。

我检查了XElement.DeepEquals（）方法，但由于任何原因它没有帮助。

有谁知道我应该使用哪种方法最好？

Answer 1

我发现this excellent article很有用。它包含一个代码示例，它实现了XNode.DeepEquals的替代，它在比较之前规范化XML树，这使得非语义内容无关紧要。

为了说明，XNode.DeepEquals的实现对于这些语义上等效的文档返回false：

XElement root1 = XElement.Parse("<Root a='1' b='2'><Child>1</Child></Root>");
XElement root2 = XElement.Parse("<Root b='2' a='1'><Child>1</Child></Root>");

但是，使用文章中的DeepEqualsWithNormalization实现，您将获得值true，因为属性的排序不重要。此实现包含在下面。

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Xml;
using System.Xml.Linq;
using System.Xml.Schema;

public static class MyExtensions
{
    public static string ToStringAlignAttributes(this XDocument document)
    {
        XmlWriterSettings settings = new XmlWriterSettings();
        settings.Indent = true;
        settings.OmitXmlDeclaration = true;
        settings.NewLineOnAttributes = true;
        StringBuilder stringBuilder = new StringBuilder();
        using (XmlWriter xmlWriter = XmlWriter.Create(stringBuilder, settings))
            document.WriteTo(xmlWriter);
        return stringBuilder.ToString();
    }
}

class Program
{
    private static class Xsi
    {
        public static XNamespace xsi = "http://www.w3.org/2001/XMLSchema-instance";

        public static XName schemaLocation = xsi + "schemaLocation";
        public static XName noNamespaceSchemaLocation = xsi + "noNamespaceSchemaLocation";
    }

    public static XDocument Normalize(XDocument source, XmlSchemaSet schema)
    {
        bool havePSVI = false;
        // validate, throw errors, add PSVI information
        if (schema != null)
        {
            source.Validate(schema, null, true);
            havePSVI = true;
        }
        return new XDocument(
            source.Declaration,
            source.Nodes().Select(n =>
            {
                // Remove comments, processing instructions, and text nodes that are
                // children of XDocument.  Only white space text nodes are allowed as
                // children of a document, so we can remove all text nodes.
                if (n is XComment || n is XProcessingInstruction || n is XText)
                    return null;
                XElement e = n as XElement;
                if (e != null)
                    return NormalizeElement(e, havePSVI);
                return n;
            }
            )
        );
    }

    public static bool DeepEqualsWithNormalization(XDocument doc1, XDocument doc2,
        XmlSchemaSet schemaSet)
    {
        XDocument d1 = Normalize(doc1, schemaSet);
        XDocument d2 = Normalize(doc2, schemaSet);
        return XNode.DeepEquals(d1, d2);
    }

    private static IEnumerable<XAttribute> NormalizeAttributes(XElement element,
        bool havePSVI)
    {
        return element.Attributes()
                .Where(a => !a.IsNamespaceDeclaration &&
                    a.Name != Xsi.schemaLocation &&
                    a.Name != Xsi.noNamespaceSchemaLocation)
                .OrderBy(a => a.Name.NamespaceName)
                .ThenBy(a => a.Name.LocalName)
                .Select(
                    a =>
                    {
                        if (havePSVI)
                        {
                            var dt = a.GetSchemaInfo().SchemaType.TypeCode;
                            switch (dt)
                            {
                                case XmlTypeCode.Boolean:
                                    return new XAttribute(a.Name, (bool)a);
                                case XmlTypeCode.DateTime:
                                    return new XAttribute(a.Name, (DateTime)a);
                                case XmlTypeCode.Decimal:
                                    return new XAttribute(a.Name, (decimal)a);
                                case XmlTypeCode.Double:
                                    return new XAttribute(a.Name, (double)a);
                                case XmlTypeCode.Float:
                                    return new XAttribute(a.Name, (float)a);
                                case XmlTypeCode.HexBinary:
                                case XmlTypeCode.Language:
                                    return new XAttribute(a.Name,
                                        ((string)a).ToLower());
                            }
                        }
                        return a;
                    }
                );
    }

    private static XNode NormalizeNode(XNode node, bool havePSVI)
    {
        // trim comments and processing instructions from normalized tree
        if (node is XComment || node is XProcessingInstruction)
            return null;
        XElement e = node as XElement;
        if (e != null)
            return NormalizeElement(e, havePSVI);
        // Only thing left is XCData and XText, so clone them
        return node;
    }

    private static XElement NormalizeElement(XElement element, bool havePSVI)
    {
        if (havePSVI)
        {
            var dt = element.GetSchemaInfo();
            switch (dt.SchemaType.TypeCode)
            {
                case XmlTypeCode.Boolean:
                    return new XElement(element.Name,
                        NormalizeAttributes(element, havePSVI),
                        (bool)element);
                case XmlTypeCode.DateTime:
                    return new XElement(element.Name,
                        NormalizeAttributes(element, havePSVI),
                        (DateTime)element);
                case XmlTypeCode.Decimal:
                    return new XElement(element.Name,
                        NormalizeAttributes(element, havePSVI),
                        (decimal)element);
                case XmlTypeCode.Double:
                    return new XElement(element.Name,
                        NormalizeAttributes(element, havePSVI),
                        (double)element);
                case XmlTypeCode.Float:
                    return new XElement(element.Name,
                        NormalizeAttributes(element, havePSVI),
                        (float)element);
                case XmlTypeCode.HexBinary:
                case XmlTypeCode.Language:
                    return new XElement(element.Name,
                        NormalizeAttributes(element, havePSVI),
                        ((string)element).ToLower());
                default:
                    return new XElement(element.Name,
                        NormalizeAttributes(element, havePSVI),
                        element.Nodes().Select(n => NormalizeNode(n, havePSVI))
                    );
            }
        }
        else
        {
            return new XElement(element.Name,
                NormalizeAttributes(element, havePSVI),
                element.Nodes().Select(n => NormalizeNode(n, havePSVI))
            );
        }
    }
}

Answer 2

我开始和@llasarov一样，但也不喜欢使用字符串。我在这里发现了XElement.DeepEquals（），所以找到问题帮助 me 。

我可以看到，如果你的测试返回一个庞大的XML结构可能会很困难，但在我看来，这不应该做 - 测试应该检查尽可能小的结构。

假设您有一个方法，您希望返回一个看起来像<Test Sample="Value" />的元素。您可以使用XElement和XAttribute构造函数轻松构建期望值，如下所示：

[TestMethod()]
public void MyXmlMethodTest()
{
    // Use XElement API to build expected element.
    XElement expected = new XElement("Test", new XAttribute("Sample", "Value"));

    // Call the method being tested.
    XElement actual = MyXmlMethod();

    // Assert using XNode.DeepEquals
    Assert.IsTrue(XNode.DeepEquals(expected, actual));
}

即使有少数元素和属性，这也是可管理且一致的。

Answer 3

我有一个问题，比较XElements的相等性，其中一个元素有子节点，其中自闭标签但另一个有开放和关闭标签，例如[blah /] vs [blah] [/ blah]

深度等于函数当然是报告它们不同所以我需要一个normalize函数。我最终使用了本博客中发布的内容的变体（“marianor”）：

http://weblogs.asp.net/marianor/archive/2009/01/02/easy-way-to-compare-two-xmls-for-equality.aspx

一个小的改变是我在规范化后使用了深度等于函数（而不是字符串比较），并且我添加了逻辑来处理包含空文本的元素与空元素相同（以解决上述问题）。结果如下。

private bool CompareXml(string xml)
{
    var a = Normalize(currentElement);
    var b = Normalize(newElement);

    return XElement.DeepEquals(a, b);
}

private static XElement Normalize(XElement element)
{
    if (element.HasElements)
    {
        return new XElement(element.Name, element.Attributes().Where(a => a.Name.Namespace == XNamespace.Xmlns)
                                                                .OrderBy(a => a.Name.ToString()),element.Elements().OrderBy(a => a.Name.ToString())
                                                                .Select(e => Normalize(e)));
    }

    if (element.IsEmpty || string.IsNullOrEmpty(element.Value))
    {
        return new XElement(element.Name, element.Attributes()
            .OrderBy(a => a.Name.ToString()));
    }

    return new XElement(element.Name, element.Attributes()
        .OrderBy(a => a.Name.ToString()), element.Value);
}

Answer 4

在xunit中，您可以将Assert.Equals与XNode.EqualityComparer一起使用，如下所示：

var expected = new XElement("Sample", new XAttribute("name", "test"));
var result = systemUnderTest.DoSomething();

Assert.Equal(expected, result, XNode.EqualityComparer);

此方法的优点是，如果测试失败，它将打印错误消息中的xml元素，以便您查看它们之间的区别。

Answer 5

取决于您正在测试的内容。您需要验证XML是否相同或等效。

我怀疑后者在这种情况下你应该使用xlinq查询xelement并断言它具有所需的元素和属性。

在一天结束时，它会降低所需要的效果。例如

<element att='xxxx'>
  <sub />
</element>

和

<element att='zzz' />

如果您不关心<sub /> or att

，

可能相同

Answer 6

可能有所帮助的下一步：摆脱任何排序的规范化。有时元素顺序根本不重要（想想集合而不是列表或数组）。

这个基于前一个（RobJohnson），但也根据他们的＆＃34;内容＆＃34;命令元素，它使用属性的数量，属性值和Xml元素值本身。

static XElement NormalizeWithoutAnyOrder( XElement element )
{
    if( element.HasElements )
    {
        return new XElement(
            element.Name,
            element.Attributes().OrderBy( a => a.Name.ToString() ),
            element.Elements()
                .OrderBy( a => a.Name.ToString() )
                .Select( e => NormalizeWithoutAnyOrder( e ) )
                .OrderBy( e => e.Attributes().Count() )
                .OrderBy( e => e.Attributes()
                                .Select( a => a.Value )
                                .Concatenate("\u0001") )
                .ThenBy( e => e.Value ) );
    }
    if( element.IsEmpty || string.IsNullOrEmpty( element.Value ) )
    {
        return new XElement( element.Name,
                             element.Attributes()
                                    .OrderBy( a => a.Name.ToString() ) );
    }
    return new XElement( element.Name, 
                         element.Attributes()
                                .OrderBy( a => a.Name.ToString() ), 
                         element.Value );
}

IEnumerable.Concatenate扩展方法与string.Join方法相同。

Answer 7

对于单元测试，我发现最简单的方法是让XElement解析你期望的字符串。

string expected = "<some XML>";
XElement result = systemUnderTest.DoSomething();

Assert.Equal(XElement.Parse(expected).ToString(), result.ToString());

比较XElement对象的最佳方法

7 个答案: