nunit-core team mailing list archive

[Charlie Poole <charlie@xxxxxxxxx>]

The NUnit equality model has handled null reference the same way for 13
years, so I hesitate to change it in any way that will break existing
applications.

I agree with Simone that IsNull should not pass with anything except the
null reference.

If there is a way we can make the two AreEqual tests pass without breaking
other tests, then I might consider that. However, I'm dubious of the value
of such an addition since use of AreEqual is not the way to test that the
NullObject in question works. The right way is to call the object's Equals
overload directly and find out what it returns.

Testing by using Assert.AreEqual verifies that the object's implementation
of equality matches NUnit's. I don't think that's what you want to test.

I'm inclined to reject this on the grounds of utility, but I'd like to hear
the other side first.

Charlie


On Thu, Mar 21, 2013 at 3:26 PM, Simone Busoli
<1157828@xxxxxxxxxxxxxxxxxx>wrote:

> Looks like a valid scenario in my opinion. It's not straightforward to
> get right as we're doing all sorts of equality in NUnit but I put
> together a spike which passes all tests plus the ones Meg posted here
> except the Is.Null one. I think that one should not be supported as
> Is.Null should check for reference equality, which you cannot override.
>
> I would like to hear what Charlie thinks too.
>
> lp:~simone.busoli/nunitv2/null-equality
>
> --
> You received this bug notification because you are subscribed to NUnit
> Extended Testing Platform.
> https://bugs.launchpad.net/bugs/1157828
>
> Title:
>   EqualityComparer does not respect value-equality for null
>
> To manage notifications about this bug go to:
> https://bugs.launchpad.net/nunitv2/+bug/1157828/+subscriptions
>

-- 
You received this bug notification because you are a member of NUnit
Developers, which is subscribed to NUnit V2.
https://bugs.launchpad.net/bugs/1157828

Title:
  EqualityComparer does not respect value-equality for null

Status in NUnit V2 Test Framework:
  New

Bug description:
  I am using a third-party library that includes Null Objects with value
  comparisons that return true for null.  However, the NUnit equality
  comparer uses reference equality (via the == operator with
  System.Object references) to check for null and returns false if only
  one input is the null pointer.  This means that the value-equality
  comparison for the custom type is never reached.

  The following is a quick & dirty implementation of a Null Object with
  a few tests that demonstrate the problem:

  public class MyObject
  {
      public static MyObject NullObject = new MyObject(-1);

      public int Value { get; set; }

      public MyObject(int value)
      {
          this.Value = value;
      }

      public static bool operator ==(MyObject left, MyObject right)
      {
          if (ReferenceEquals(left, NullObject) || ReferenceEquals(left, null))
              return (ReferenceEquals(right, NullObject) || ReferenceEquals(right, null));

          else if (ReferenceEquals(right, NullObject) || ReferenceEquals(right, null))
              return false;

          return Equals(left, right);
      }

      public static bool operator !=(MyObject left, MyObject right)
      {
          return !(left == right);
      }
      public override bool Equals(object obj)
      {
          if (ReferenceEquals(obj, NullObject) || ReferenceEquals(obj, null))
              return (ReferenceEquals(this, NullObject));

          else if (ReferenceEquals(this, NullObject))
              return false;

          MyObject myobj = obj as MyObject;
          if (myobj == null)
              return false;

          return this.Value == myobj.Value;
      }

      public override int GetHashCode()
      {
          return base.GetHashCode();
      }

  }

  [TestFixture]
  public class TestNullObject
  {
      // TEST PASSES
      [Test]
      public void TestIsTrue()
      {
          Assert.IsTrue(MyObject.NullObject == null);
          Assert.IsTrue(null == MyObject.NullObject);
      }

      // TESTS FAIL
      [Test]
      public void TestIsNull()
      {
          Assert.IsNull(MyObject.NullObject);
      }

      [Test]
      public void TestAreEqual1()
      {
          Assert.AreEqual(MyObject.NullObject, null);
      }

      [Test]
      public void TestAreEqual2()
      {
          Assert.AreEqual(null, MyObject.NullObject);
      }
  }

To manage notifications about this bug go to:
https://bugs.launchpad.net/nunitv2/+bug/1157828/+subscriptions