集合上的递归断言

Question

我想要一个这样的测试：

[Test]
    public void TestCollectionAssert ()
    {
        var a1 = new [] { new [] { "a" } };
        var a2 = new [] { new [] { "a" } };

        Assert.AreNotEqual (a1, a2);
        //CollectionAssert.AreEqual (a1, a2);
        CollectionAssert.AreEquivalent (a1, a2);
    }

通过。 我的真实案例更复杂，但以通用方式解决这个问题就可以了。 有什么想法吗？

Answer 1

有一个有用的 LINQ 运算符，名为 SequenceEqual() 比较两个序列是否相等。 SequenceEqual() 遍历任意两个 IEnumerable 序列并验证它们是否具有相同数量的元素和同一索引处的元素相等（使用默认的相等比较器）。但是，由于您有嵌套集合，因此您需要扩展相等的概念以也适用于它们。幸运的是，有一个重载允许您提供自己的 IEqualityComparer 对象。

由于经常需要定义一个类来提供相等语义很尴尬，因此我编写了一个通用扩展，允许您改用委托。让我们看一下代码：

public static class ComparerExt
{
    private class GenericComparer<T> : IEqualityComparer<T>
    {
        private readonly Func<T, T, bool> m_EqualityFunc;

        public GenericComparer( Func<T,T,bool> compareFunc )
        {
            m_EqualityFunc = compareFunc;
        }

        public bool Equals(T x, T y)
        {
            return m_EqualityFunc(x, y);
        }
    }

    // converts a delegate into an IComparer
    public static IEqualityComparer<T> AreEqual<T>( Func<T,T,bool> compareFunc )
    {
        compareFunc.ThrowIfNull("compareFunc");

        return new GenericComparer<T>(compareFunc);
    }
}

现在，我们可以很容易地比较两个序列：

Assert.IsTrue( 
   // check that outer sequences are equivalent...
   a1.SequenceEqual( a2,
                     // define equality as inner sequences being equal... 
                     ComparerExt.AreEqual( (a,b) => a.SequenceEqual(b) ) );

Answer 2

您可以编写如下所示的扩展方法。

public class AssertExtension
{
    public bool AreSimilar<T>(this CollectionAssert, IList<T> list1, IList<T> list2)
    {
        // ...
    }
}

问题当然是如何比较这两个列表。我建议逐步检查一个列表中的元素，并尝试将它们从另一个列表中删除。如果在执行此操作时出现问题或最后留下一些对象，则它们不相似。

Answer 3

这是一个老问题，但有人刚刚在 nunit 讨论列表上发布了一个链接，所以我会回答。

NUnit 旨在报告两个列表相等。这就是它的工作原理。 Assert.NotEqual 实际上应该失败。

Answer 4

我实现了以下方法，以递归方式比较元素。
到目前为止，它适用于我的所有测试用例，我可能会错过一个边缘情况。

    /// <summary>
    ///     Compares two enumerables recursively.
    /// </summary>
    /// <param name="left">IEnumerable</param>
    /// <param name="right">IEnumerable</param>
    /// <returns>bool</returns>
    public static bool SequenceEqual(this IEnumerable left, IEnumerable right)
    {
        if (ReferenceEquals(left, right))
        {
            return true;
        }

        if (ReferenceEquals(null, left))
        {
            return false;
        }


        if (left.GetType() != right.GetType())
        {
            return false;
        }

        var leftEnumerator = left.GetEnumerator();
        var rightEnumerator = right.GetEnumerator();

        while (leftEnumerator.MoveNext())
        {
            if (!rightEnumerator.MoveNext())
            {
                return false;
            }

            if (typeof(IEnumerable).IsAssignableFrom(leftEnumerator.Current.GetType()))
            {
                if (!typeof(IEnumerable).IsAssignableFrom(rightEnumerator.Current.GetType()))
                {
                    return false;
                }

                if (!SequenceEqual((IEnumerable)leftEnumerator.Current, (IEnumerable)rightEnumerator.Current))
                {
                    return false;
                }
            }
            else
            {
                if (!Equals(leftEnumerator.Current, rightEnumerator.Current))
                {
                    return false;
                }
            }
        }

        if (rightEnumerator.MoveNext())
        {
            return false;
        }

        return true;
    }