public void TwoClassInstances_AreNotEquals()
{
var rec = new ReferenceEqualityComparer();
var instance = new Entity();
rec.Equals(instance, new Entity()).Should().Be.False();
rec.Equals(instance, instance).Should().Be.True();
rec.GetHashCode().Should().Not.Be.EqualTo(17);
rec.GetHashCode().Should().Not.Be.EqualTo((new Entity()).GetHashCode());
}
public void TwoClassInstances_AreNotEquals()
{
var rec = new ReferenceEqualityComparer();
var instance = new Entity();
rec.Equals(instance, new Entity()).Should().Be.False();
rec.Equals(instance, instance).Should().Be.True();
rec.GetHashCode().Should().Not.Be.EqualTo(17);
rec.GetHashCode().Should().Not.Be.EqualTo((new Entity()).GetHashCode());
}
public void NullSafe()
{
var req = new ReferenceEqualityComparer<string>();
Assert.AreEqual(0, req.GetHashCode(null));
Assert.True(req.Equals(null, null));
Assert.False(req.Equals(null, "abc"));
var reqo = new ReferenceEqualityComparer();
Assert.AreEqual(0, reqo.GetHashCode(null));
Assert.True(reqo.Equals(null, null));
Assert.False(reqo.Equals(null, "abc"));
}
public void generic_iEqualityComparer_equals_with_null_and_null()
{
var instance = new ReferenceEqualityComparer<GenericParameterHelper>();
bool actual = instance.Equals( null, null );
actual.Should().Be.True();
}
public void generic_iEqualityComparer_equals_with_null_and_null()
{
var instance = new ReferenceEqualityComparer <GenericParameterHelper>();
bool actual = instance.Equals(null, null);
actual.Should().Be.True();
}
public void TestCase02_CompareValueTypes()
{
ReferenceEqualityComparer <DateTime> comparer = new ReferenceEqualityComparer <DateTime>();
/* Situation 1: Comparing two variables that point to different instances with different contents */
DateTime dummyA = new DateTime(2000, 5, 10);
DateTime dummyB = new DateTime(2000, 6, 9);
bool result = comparer.Equals(dummyA, dummyB);
Assert.IsFalse(result);
/* Situation 2: Comparing two variables that point to different instances with the same content */
dummyA = new DateTime(2000, 5, 10);
dummyB = new DateTime(2000, 5, 10);
result = comparer.Equals(dummyA, dummyB);
Assert.IsFalse(result);
}
public void ReferenceEqualityComparerClassEqualsMethodReturnsTrueWhenTheSameTimeOfDayObjectIsPassedToBothParameters()
{
TimeOfDay testParam = _rnd.NextTimeOfDay();
ReferenceEqualityComparer testObject = ReferenceEqualityComparer.Default;
bool testOutput = testObject.Equals(testParam, testParam);
Assert.IsTrue(testOutput);
}
public void iEqualityComparer_equals_with_null_and_instance()
{
IEqualityComparer instance = new ReferenceEqualityComparer <GenericParameterHelper>();
var y = new GenericParameterHelper();
bool actual = instance.Equals(null, y);
actual.Should().Be.False();
}
public static void Equals___Should_return_false___When_one_object_is_null_and_the_other_is_not_null()
{
// Arrange
var item1a = new Version();
Version item1b = null;
Version item2a = null;
var item2b = new Version();
var systemUnderTest = new ReferenceEqualityComparer <Version>();
// Act
var actual1 = systemUnderTest.Equals(item1a, item1b);
var actual2 = systemUnderTest.Equals(item2a, item2b);
// Assert
actual1.Should().BeFalse();
actual2.Should().BeFalse();
}
public void Equals_SameInstance_ReturnTrue()
{
// Setup
var comparer = new ReferenceEqualityComparer <object>();
var obj = new object();
// Call & Assert
Assert.IsTrue(comparer.Equals(obj, obj));
Assert.AreEqual(comparer.GetHashCode(obj), comparer.GetHashCode(obj));
}
public void generic_iEqualityComparer_equals_with_equal_instances()
{
var instance = new ReferenceEqualityComparer<GenericParameterHelper>();
var x = new GenericParameterHelper();
var y = x;
bool actual = instance.Equals( x, y );
actual.Should().Be.True();
}
public void AnObjectIsEqualToItself()
{
var referenceComparer = new ReferenceEqualityComparer();
var obj1 = new object();
var obj2 = obj1;
var consideredEqual = referenceComparer.Equals(obj1, obj2);
Assert.IsTrue(consideredEqual);
}
public void iEqualityComparer_equals_with_equal_instances()
{
IEqualityComparer instance = new ReferenceEqualityComparer <GenericParameterHelper>();
var x = new GenericParameterHelper();
var y = x;
bool actual = instance.Equals(x, y);
actual.Should().Be.True();
}
public static void Equals___Should_return_true___When_both_objects_are_the_same_reference()
{
// Arrange
var item = Some.Dummies <byte>().ToArray();
var systemUnderTest = new ReferenceEqualityComparer <byte[]>();
// Act
var actual = systemUnderTest.Equals(item, item);
// Assert
actual.Should().BeTrue();
}
public void ReferenceEqualityComparerClassEqualsMethodReturnsFalseWhenTwoDifferentButEqualTimeOfDayObjectsArePassedAsParameters()
{
TimeOfDay testParam0 = _rnd.NextTimeOfDay();
TimeOfDay testParam1 = new TimeOfDay(testParam0.AbsoluteSeconds);
ReferenceEqualityComparer testObject = ReferenceEqualityComparer.Default;
bool testOutput = testObject.Equals(testParam0, testParam1);
Assert.IsFalse(testOutput);
// Just to double-check that the parameters do compare equal!
Assert.AreEqual(testParam0, testParam1);
}
public void Equals_UsesReferenceEquals()
{
MyClass o1 = new MyClass {
SomeInt = 10
};
MyClass o2 = new MyClass {
SomeInt = 10
};
Assert.Equal(o1, o2);
ReferenceEqualityComparer comparer1 = ReferenceEqualityComparer.Instance;
IEqualityComparer comparer2 = ReferenceEqualityComparer.Instance;
IEqualityComparer <object> comparer3 = ReferenceEqualityComparer.Instance;
IEqualityComparer <MyClass> comparer4 = ReferenceEqualityComparer.Instance; // test contravariance
#pragma warning disable CS8625 // Cannot convert null literal to non-nullable reference type.
#pragma warning disable CS8604 // Possible null reference argument.
Assert.True(comparer1.Equals(null, null));
Assert.False(comparer1.Equals(null, o2));
Assert.False(comparer1.Equals(o1, o2));
Assert.False(comparer1.Equals(o1, null));
#pragma warning restore CS8604 // Possible null reference argument.
#pragma warning restore CS8625 // Cannot convert null literal to non-nullable reference type.
Assert.True(comparer2.Equals(null, null));
Assert.False(comparer2.Equals(null, o2));
Assert.False(comparer2.Equals(o1, o2));
Assert.False(comparer2.Equals(o1, null));
Assert.True(comparer3.Equals(null, null));
Assert.False(comparer3.Equals(null, o2));
Assert.False(comparer3.Equals(o1, o2));
Assert.False(comparer3.Equals(o1, null));
Assert.True(comparer4.Equals(null, null));
Assert.False(comparer4.Equals(null, o2));
Assert.False(comparer4.Equals(o1, o2));
Assert.False(comparer4.Equals(o1, null));
}
public static void Equals___Should_return_true___When_both_objects_are_null()
{
// Arrange
object item1 = null;
object item2 = null;
var systemUnderTest = new ReferenceEqualityComparer <object>();
// Act
var actual = systemUnderTest.Equals(item1, item2);
// Assert
actual.Should().BeTrue();
}
public static void Equals___Should_return_false___When_objects_are_not_the_same_reference_and_equal()
{
// Arrange
var item1 = new Version(1, 2, 3, 4);
var item2 = new Version(1, 2, 3, 4);
var systemUnderTest = new ReferenceEqualityComparer <object>();
// Act
var actual = systemUnderTest.Equals(item1, item2);
// Assert
actual.Should().BeFalse();
}
public void IgnoresEquivalence()
{
string x = new string(new []{ 'a', 'b', 'c', 'd' });
string y = new string(new []{ 'a', 'b', 'c', 'd' });
if(!Equals(x, y))
Assert.Inconclusive("Compiler has optimised x and y to one object. Change test!");
var req = new ReferenceEqualityComparer<string>();
Assert.False(req.Equals(x, y));
Assert.True(req.Equals(x, x));
var reqo = new ReferenceEqualityComparer();
Assert.False(reqo.Equals(x, y));
Assert.True(reqo.Equals(x, x));
if(req.GetHashCode(x) == req.GetHashCode(y))
Assert.Inconclusive
("Same hashcode could happen rarely, but if more than once in a blue moon, this is a bug");
if(reqo.GetHashCode(x) == req.GetHashCode(y))
Assert.Inconclusive
("Same hashcode could happen rarely, but if more than once in a blue moon, this is a bug");
if(req.GetHashCode(x) == x.GetHashCode())
Assert.Inconclusive
("Same hashcode could happen rarely, but if more than once in a blue moon, this is a bug");
Assert.AreEqual(reqo.GetHashCode(x), req.GetHashCode(x));
}
public void Equals_OtherEqualsInstance_ReturnFalse()
{
// Setup
var comparer = new ReferenceEqualityComparer <object>();
var objectFirst = new TestObject();
var objectSecond = new TestObject();
// Call
bool equals = comparer.Equals(objectFirst, objectSecond);
// Assert
Assert.IsFalse(equals);
Assert.IsTrue(objectFirst.Equals(objectSecond));
Assert.AreNotEqual(comparer.GetHashCode(objectFirst), comparer.GetHashCode(objectSecond));
}
public void Equals_UsesReferenceEquals()
{
MyClass o1 = new MyClass {
SomeInt = 10
};
MyClass o2 = new MyClass {
SomeInt = 10
};
Assert.Equal(o1, o2);
ReferenceEqualityComparer comparer1 = ReferenceEqualityComparer.Instance;
IEqualityComparer comparer2 = ReferenceEqualityComparer.Instance;
IEqualityComparer <object> comparer3 = ReferenceEqualityComparer.Instance;
IEqualityComparer <MyClass> comparer4 = ReferenceEqualityComparer.Instance; // test contravariance
Assert.True(comparer1.Equals(null, null));
Assert.False(comparer1.Equals(null, o2));
Assert.False(comparer1.Equals(o1, o2));
Assert.False(comparer1.Equals(o1, null));
Assert.True(comparer2.Equals(null, null));
Assert.False(comparer2.Equals(null, o2));
Assert.False(comparer2.Equals(o1, o2));
Assert.False(comparer2.Equals(o1, null));
Assert.True(comparer3.Equals(null, null));
Assert.False(comparer3.Equals(null, o2));
Assert.False(comparer3.Equals(o1, o2));
Assert.False(comparer3.Equals(o1, null));
Assert.True(comparer4.Equals(null, null));
Assert.False(comparer4.Equals(null, o2));
Assert.False(comparer4.Equals(o1, o2));
Assert.False(comparer4.Equals(o1, null));
}
public void TestCase03_CompareNullableValueTypes()
{
ReferenceEqualityComparer <DateTime?> comparer = new ReferenceEqualityComparer <DateTime?>();
/* Situation 1: Comparing two variables that point to the same instance (note: a nullable value-type is still a value-type) */
DateTime?dummyA = new DateTime?(new DateTime(2000, 5, 10));
DateTime?dummyB = dummyA;
bool result = comparer.Equals(dummyA, dummyB);
Assert.IsFalse(result);
/* Situation 2: Comparing two variables that point to different instances with different contents */
dummyA = new DateTime?(new DateTime(2000, 5, 10));
dummyB = new DateTime?(new DateTime(2000, 6, 9));
result = comparer.Equals(dummyA, dummyB);
Assert.IsFalse(result);
/* Situation 3: Comparing two variables that point to different instances with the same content */
dummyA = new DateTime?(new DateTime(2000, 5, 10));
dummyB = new DateTime?(new DateTime(2000, 5, 10));
result = comparer.Equals(dummyA, dummyB);
Assert.IsFalse(result);
/* Situation 4: Comparing an instance with its 'clone' */
DateTime testValue = new DateTime(2000, 5, 10);
dummyA = new DateTime?(testValue);
dummyB = new DateTime?(testValue);
result = comparer.Equals(dummyA, dummyB);
Assert.IsFalse(result);
/* Situation 5: Comparing an instance with a null-value */
dummyA = new DateTime?(new DateTime(2000, 5, 10));
dummyB = null;
result = comparer.Equals(dummyA, dummyB);
Assert.IsFalse(result);
/* Situation 6: Comparing a null-value with an instance */
dummyA = null;
dummyB = new DateTime?(new DateTime(2000, 5, 10));
result = comparer.Equals(dummyA, dummyB);
Assert.IsFalse(result);
/* Situation 6: Comparing two null-values */
dummyA = null;
dummyB = null;
result = comparer.Equals(dummyA, dummyB);
Assert.IsTrue(result);
}
public void DifferentObjectsEqualAsIEquatableAreNotConsideredEqual()
{
var referenceComparer = new ReferenceEqualityComparer();
var mock1 = new Mock <IEquatable <object> >();
mock1.Setup(obj => obj.Equals(It.IsAny <object>())).Returns(true);
var mock2 = new Mock <IEquatable <object> >();
mock2.Setup(obj => obj.Equals(It.IsAny <object>())).Returns(true);
var obj1 = mock1.Object;
var obj2 = mock2.Object;
var consideredEqual = referenceComparer.Equals(obj1, obj2);
Assert.IsFalse(consideredEqual);
}
public void It_should_be_false_when_x_and_y_are_unique_instances()
{
var actual = target.Equals(new object(), new object());
actual.Should().BeFalse();
}
public void iEqualityComparer_equals_with_null_and_instance()
{
IEqualityComparer instance = new ReferenceEqualityComparer<GenericParameterHelper>();
var y = new GenericParameterHelper();
bool actual = instance.Equals( null, y );
actual.Should().Be.False();
}
public void TestCase01_CompareReferenceTypes()
{
ReferenceEqualityComparer <TestDummy> comparer = new ReferenceEqualityComparer <TestDummy>();
/* Situation 1: Comparing two variables that point to the same instance */
TestDummy dummyA = new TestDummy {
TextValue = "Hello World", NumericValue = 5
};
TestDummy dummyB = dummyA;
bool result = comparer.Equals(dummyA, dummyB);
Assert.IsTrue(result);
/* Situation 2: Comparing two variables that point to different instances with different contents */
dummyA = new TestDummy {
TextValue = "Hello World", NumericValue = 5
};
dummyB = new TestDummy {
TextValue = "hello world", NumericValue = 6
};
result = comparer.Equals(dummyA, dummyB);
Assert.IsFalse(result);
/* Situation 3: Comparing two variables that point to different instances with the same content */
dummyA = new TestDummy {
TextValue = "hello world", NumericValue = 5
};
dummyB = new TestDummy {
TextValue = "hello world", NumericValue = 5
};
result = comparer.Equals(dummyA, dummyB);
Assert.IsFalse(result);
/* Situation 4: Comparing an instance with its clone */
dummyA = new TestDummy {
TextValue = "Hello World", NumericValue = 5
};
dummyB = dummyA.Clone <TestDummy>();
result = comparer.Equals(dummyA, dummyB);
Assert.IsFalse(result);
/* Situation 5: Comparing an instance with a null-value */
dummyA = new TestDummy {
TextValue = "Hello World", NumericValue = 5
};
dummyB = null;
result = comparer.Equals(dummyA, dummyB);
Assert.IsFalse(result);
/* Situation 6: Comparing a null-value with an instance */
dummyA = null;
dummyB = new TestDummy {
TextValue = "Hello World", NumericValue = 5
};
result = comparer.Equals(dummyA, dummyB);
Assert.IsFalse(result);
/* Situation 6: Comparing two null-values */
dummyA = null;
dummyB = null;
result = comparer.Equals(dummyA, dummyB);
Assert.IsTrue(result);
}
public void Equal_True()
{
Assert.That(_comparer.Equals(_obj1, _obj1), Is.True);
}
