public void EqualsReturnsCorrectResultForFields()
{
// Fixture setup
var expected = true;
var comparerStubs = new[]
{
new DelegatingMemberComparer
{
OnIsSatisfiedByField = p => true,
OnEquals = (x, y) => false
},
new DelegatingMemberComparer
{
OnIsSatisfiedByField = p => true,
OnEquals = (x, y) => expected
},
new DelegatingMemberComparer
{
OnIsSatisfiedByField = p => true,
OnEquals = (x, y) => false
}
};
var sut = new SemanticComparer <FieldHolder <string> >(comparerStubs);
var value = new FieldHolder <string>();
var other = new FieldHolder <string>();
// Exercise system
var result = BothEquals(sut, value, other);
// Verify outcome
Assert.Equal(expected, result.All(b => b));
// Teardown
}
public void SutIsEqualityComparer(Type expectedType)
{
// Fixture setup
// Exercise system
var sut = new SemanticComparer <int, string>();
// Verify outcome
Assert.IsAssignableFrom(expectedType, sut);
// Teardown
}
public void EqualsReturnsCorrectResult(string x, string y, bool expected)
{
// Fixture setup
var sut = new SemanticComparer <string>();
// Exercise system
var result = BothEquals(sut, x, y);
// Verify outcome
Assert.Equal(expected, result.All(b => b));
// Teardown
}
private static void CompareSemantically <TSource, TDestination>(TSource likenObject, TDestination comparee, bool expectedResult)
{
// Fixture setup
var sut = new SemanticComparer <TSource, TDestination>();
// Exercise system
bool result = sut.Equals(likenObject, comparee);
// Verify outcome
Assert.Equal(expectedResult, result);
// Teardown
}
public void SutDoesNotEqualAnonymousObject()
{
// Fixture setup
var sut = new SemanticComparer <ConcreteType, ConcreteType>();
object anonymousObject = new object();
// Exercise system
var result = sut.Equals(new ConcreteType(), anonymousObject);
// Verify outcome
Assert.False(result);
// Teardown
}
public void EqualsIsSummetricWithSemanticallyUnequalObjects()
{
// Fixture setup
var source = new ConcreteType("Lorem", "ipsum", "dolor", "sit");
var dest = new DoublePropertyHolder <object, object>();
dest.Property1 = source.Property1;
dest.Property2 = "abc";
var sut = new SemanticComparer <ConcreteType, DoublePropertyHolder <object, object> >();
// Exercise system and verify outcome
Assert.False(sut.Equals(source, dest) && sut.Equals(dest, source));
// Teardown
}
public void SutEqualsIdenticalStrongType()
{
// Fixture setup
var ticks = 8293247;
var value = TimeSpan.FromTicks(ticks);
var sut = new SemanticComparer <TimeSpan, TimeSpan>();
var other = TimeSpan.FromTicks(ticks);
// Exercise system
var result = sut.Equals(value, other);
// Verify outcome
Assert.True(result);
// Teardown
}
public void ComparersIsCorrectWhenInitializedWithDefaultConstructor()
{
// Fixture setup
var expected = new[]
{
new MemberComparer(new SemanticComparer <TimeSpan, TimeSpan>())
};
var sut = new SemanticComparer <TimeSpan>();
// Exercise system
var result = sut.Comparers.Cast <MemberComparer>();
// Verify outcome
Assert.True(expected.SequenceEqual(result, new MemberComparerComparer()));
// Teardown
}
public void SutWithSemanticEqualityWillReturnTrue()
{
// Fixture setup
var value = new ConcreteType("Lorem", "ipsum", "dolor", "sit");
var sut = new SemanticComparer <ConcreteType, DoublePropertyHolder <object, object> >();
var other = new DoublePropertyHolder <object, object>();
other.Property1 = value.Property1;
other.Property2 = value.Property2;
// Exercise system
var result = sut.Equals(value, other);
// Verify outcome
Assert.True(result);
// Teardown
}
public void ComparersIsCorrectWhenInitializedWithEnumerable()
{
// Fixture setup
var expected = new[]
{
new DelegatingMemberComparer(),
new DelegatingMemberComparer(),
new DelegatingMemberComparer()
}.ToList();
var sut = new SemanticComparer <string>(expected);
// Exercise system
var result = sut.Comparers;
// Verify outcome
Assert.True(expected.SequenceEqual(result));
// Teardown
}
public void EqualsWhenOverriddenSourcePropertyEqualsReturnsFalseWillReturnFalse()
{
// Fixture setup
var equalityResponse = false;
var value = new PropertyHolder <EqualityResponder>();
value.Property = new EqualityResponder(equalityResponse);
var sut = new SemanticComparer <PropertyHolder <EqualityResponder>, PropertyHolder <object> >();
var other = new PropertyHolder <object>();
other.Property = new object();
// Exercise system
var result = sut.Equals(value, other);
// Verify outcome
Assert.Equal(equalityResponse, result);
// Teardown
}
public void SutEqualsIdenticalStrongTypeSequence()
{
// Fixture setup
var sut = new SemanticComparer <TimeSpan, TimeSpan>();
var ticks = 8293247;
var value = TimeSpan.FromTicks(ticks);
var values = new object[] { value, value, value };
var other = TimeSpan.FromTicks(ticks);
var others = new object[] { other, other, other };
// Exercise system
var result = values.SequenceEqual(others, sut);
// Verify outcome
Assert.True(result);
// Teardown
}
public void SutDoesNotEqualAnonymousObjectSequence()
{
// Fixture setup
var sut = new SemanticComparer <ConcreteType, ConcreteType>();
object anonymousObject = new object();
object[] anonymousObjects = new object[] { anonymousObject, anonymousObject, anonymousObject };
ConcreteType concreteType = new ConcreteType();
ConcreteType[] concreteTypes = new ConcreteType[] { concreteType, concreteType, concreteType };
// Exercise system
var result = concreteTypes.SequenceEqual(anonymousObjects, sut);
// Verify outcome
Assert.False(result);
// Teardown
}
public void SutOfAbstractTypeDoesNotEqualConcreteInstanceWhenPropertyDiffers()
{
// Fixture setup
var value = new ConcreteType("Lorem", "ipsum", "dolor", "sit");
value.Property4 = "Ploeh";
var sut = new SemanticComparer <ConcreteType, AbstractType>();
var other = new ConcreteType();
other.Property1 = value.Property1;
other.Property2 = value.Property2;
other.Property3 = value.Property3;
other.Property4 = "Fnaah";
// Exercise system
var result = sut.Equals(value, other);
// Verify outcome
Assert.False(result);
// Teardown
}
public void EqualsReturnsCorrectResultForComplexClass(
ComplexClass value,
ComplexClass other,
bool expected)
{
// Fixture setup
var comparerStubs = new[]
{
new DelegatingMemberComparer
{
OnIsSatisfiedByProperty = x => true,
OnEquals = (x, y) => x.Equals(y)
},
new DelegatingMemberComparer
{
OnIsSatisfiedByProperty = x =>
x.PropertyType == typeof(Entity),
OnEquals = (x, y) =>
((Entity)x).Name.Equals(
((Entity)y).Name)
},
new DelegatingMemberComparer
{
OnIsSatisfiedByProperty = x =>
x.PropertyType == typeof(OperatingSystem),
OnEquals = (x, y) =>
((OperatingSystem)x).Version.Equals(
((OperatingSystem)y).Version)
}
};
var sut = new SemanticComparer <ComplexClass>(comparerStubs);
// Exercise system
var result = BothEquals(sut, value, other);
// Verify outcome
Assert.Equal(expected, result.All(b => b));
// Teardown
}
public void EqualsForwardsCorrectCallToComparers()
{
// Fixture setup
var value = new TypeWithDifferentParameterTypesAndProperties(
1, "abc", 3, Guid.NewGuid());
var other = new TypeWithDifferentParameterTypesAndProperties(
1, "ABC", 3, Guid.NewGuid());
var comparerStubs = new[]
{
new DelegatingMemberComparer
{
OnIsSatisfiedByProperty = x => true,
OnEquals = (x, y) => x.Equals(y)
},
new DelegatingMemberComparer
{
OnIsSatisfiedByProperty = x =>
x.PropertyType == typeof(Guid),
OnEquals = (x, y) => true
},
new DelegatingMemberComparer
{
OnIsSatisfiedByProperty = x =>
x.PropertyType == typeof(string),
OnEquals = (x, y) =>
StringComparer.OrdinalIgnoreCase.Equals(x as string, y as string)
}
};
var sut = new SemanticComparer <TypeWithDifferentParameterTypesAndProperties>(comparerStubs);
// Exercise system
var result = BothEquals(sut, value, other);
// Verify outcome
Assert.True(result.All(b => b));
// Teardown
}
public void SutOfAbstractTypeEqualsConcreteInstancesThatDifferOnlyOnMemberNotDefinedByAbstraction()
{
// Fixture setup
var value = new ConcreteType("Lorem", "ipsum", "dolor", "sit");
value.Property5 = "Ploeh";
var sut = new SemanticComparer <ConcreteType, AbstractType>();
var other = new ConcreteType();
other.Property1 = value.Property1;
other.Property2 = value.Property2;
other.Property3 = value.Property3;
other.Property4 = value.Property4;
other.Property5 = "Fnaah";
// Exercise system
var result = sut.Equals(value, other);
// Verify outcome
Assert.True(result);
// Teardown
}
private static IEnumerable <bool> BothEquals <T>(SemanticComparer <T> sut, T x, T y)
{
yield return(sut.Equals(x, y));
yield return(((IEqualityComparer)sut).Equals(x, y));
}
