NUnit的Is.EqualTo是否不能可靠地用于从泛型类派生的类?

Asked
Viewd1827

8

今天我遇到了NUnit的以下问题。

我有一个从通用类派生的类。 我开始进行一些序列化测试,并使用NUnit的Is.EqualTo()函数进行了相等性测试。

当应该通过失败的测试通过时,我开始怀疑出了点问题。当我改用obj1.Equals(obj2)时,它按预期失败。

为了进行调查,我创建了以下测试:

 namespace NUnit.Tests

{

using Framework;

    public class ThatNUnit
    {
        [Test]
        public void IsNotEqualTo_ClientsNotEqual_Passes()
        {
            var client1 = new DerrivedClient();
            var client2 = new DerrivedClient();

            client1.Name = "player1";
            client1.SomeGenericProperty = client1.Name;
            client2.Name = "player2";
            client2.SomeGenericProperty = client2.Name;

            Assert.That(client1.Equals(client2), Is.False);
            Assert.That(client1, Is.Not.EqualTo(client2));
        }

        [Test]
        public void IsNotEqualTo_ClientsAreEqual_AlsoPasses_SomethingWrongHere()
        {
            var client1 = new DerrivedClient();
            var client2 = new DerrivedClient();

            client1.Name = "player1";
            client1.SomeGenericProperty = client1.Name;
            client2.Name = client1.Name;
            client2.SomeGenericProperty = client1.Name;

            Assert.That(client1.Equals(client2), Is.True);
            Assert.That(client1, Is.Not.EqualTo(client2));
        }
    }

    public class DerrivedClient : Client<string>
    {
    }

    public class Client<T>
    {
        public string Name { get; set; }

        public T SomeGenericProperty { get; set; }

        public override bool Equals(object obj)
        {
            if (ReferenceEquals(null, obj))
            {
                return false;
            }
            if (ReferenceEquals(this, obj))
            {
                return true;
            }
            if (obj.GetType() != typeof(Client<T>))
            {
                return false;
            }
            return Equals((Client<T>)obj);
        }

        public bool Equals(Client<T> other)
        {
            if (ReferenceEquals(null, other))
            {
                return false;
            }
            if (ReferenceEquals(this, other))
            {
                return true;
            }
            return Equals(other.Name, Name) && Equals(other.SomeGenericProperty, SomeGenericProperty);
        }

        public override int GetHashCode()
        {
            unchecked
            {
                return ((Name != null ? Name.GetHashCode() : 0) * 397) ^ SomeGenericProperty.GetHashCode();
            }
        }

        public override string ToString()
        {
            return string.Format("{0}, {1}", Name, SomeGenericProperty);
        }
    }
}
 

第二个测试中的两个(实际上是相互矛盾的断言)显示了问题:

 Assert.That(client1.Equals(client2), Is.True);
Assert.That(client1, Is.Not.EqualTo(client2));
 

此测试应该以一种或另一种方式失败,但是不会!

因此,我对NUnit的源代码进行了一些研究,结果发现,在某些特殊条件下经过一些if()之后,使用了ObjectsAreEqual(object x,object y)方法(最终通过Assert.That( x,Is.EqualTo(y))进入以下代码行:

 return x.Equals(y);
 

我发现现在非常困惑,因为我现在必须认为,Is.EqualTo()只会走更长的路线,但基本上应该与x.Equals(y)一样

这里有兴趣的人的完整方法(在NUNit.Framework.Constraints命名空间内):

   public bool ObjectsEqual(object x, object y)
    {
        this.failurePoints = new ArrayList();

        if (x == null && y == null)
            return true;

        if (x == null || y == null)
            return false;

        Type xType = x.GetType();
        Type yType = y.GetType();

        if (xType.IsArray && yType.IsArray && !compareAsCollection)
            return ArraysEqual((Array)x, (Array)y);

        if (x is ICollection && y is ICollection)
            return CollectionsEqual((ICollection)x, (ICollection)y);

        if (x is IEnumerable && y is IEnumerable && !(x is string && y is string))
            return EnumerablesEqual((IEnumerable)x, (IEnumerable)y);

        if (externalComparer != null)
            return externalComparer.ObjectsEqual(x, y);

        if (x is string && y is string)
            return StringsEqual((string)x, (string)y);

        if (x is Stream && y is Stream)
            return StreamsEqual((Stream)x, (Stream)y);

        if (x is DirectoryInfo && y is DirectoryInfo)
            return DirectoriesEqual((DirectoryInfo)x, (DirectoryInfo)y);

        if (Numerics.IsNumericType(x) && Numerics.IsNumericType(y))
            return Numerics.AreEqual(x, y, ref tolerance);

        if (tolerance != null && tolerance.Value is TimeSpan)
        {
            TimeSpan amount = (TimeSpan)tolerance.Value;

            if (x is DateTime && y is DateTime)
                return ((DateTime)x - (DateTime)y).Duration() <= amount;

            if (x is TimeSpan && y is TimeSpan)
                return ((TimeSpan)x - (TimeSpan)y).Duration() <= amount;
        }

        return x.Equals(y);
    }
 

那么这是怎么回事,怎么解决?

我希望能够信任我的测试,因此也可以再次信任NUnit。

我也不想开始使用Equals()而不是Is.EqualTo()(测试失败时前者不会给我这么好的输出)。

谢谢。

更新

同时,我进一步研究了这个问题,并在这里找到了类似的问题并发布了可能的解决方法

1 个答案

5

问题是第二个测试的第二个断言调用了Equals重载,该重载接受了object而不是Client<T>,因此此比较返回false:

 // obj.GetType() returns Client.DerrivedClient

if (obj.GetType() != typeof(Client<T>))
{
    return false;
}
 

要解决此问题,您可以将比较操作更改为此:

 if (obj.GetType() != this.GetType())
 
  • 我很高兴-我认为实际情况是严重的痛苦;我唯一的建议是稍事休息(甚至是一个短暂的休息!),以便您可以用新鲜的眼睛看它。祝你好运!

    Jeff SternalOctober 26, 2009 16:14
  • 感谢杰夫,这似乎是对的。 我的简单示例已通过这种方式解决,但实际上,我仍然在努力。 将来,这将教会我不要仅仅将生成的代码的有效性视为理所当然。

    Thorsten LorenzOctober 26, 2009 15:35