public void Equality_on_array_of_nullables_works()
{
var x = new EnumSmall?[] { EnumSmall.First, null };
var y = new EnumSmall?[] { EnumSmall.First, EnumSmall.One };
var referenceComparer = new CollectionEqualityComparer <EnumSmall?>(new NullableEqualityComparer <EnumSmall>());
var expectedHashX = referenceComparer.GetHashCode(x);
var expectedHashY = referenceComparer.GetHashCode(y);
var expectedEquals = referenceComparer.Equals(x, y);
var comparer = ComparerBuilder.Default.GetEqualityComparer <EnumSmall?[]>();
var hashX = comparer.GetHashCode(x);
var hashY = comparer.GetHashCode(y);
var equals = comparer.Equals(x, y);
using (new AssertionScope()) {
comparer.Equals(x, x).Should().BeTrue();
referenceComparer.Equals(y, y).Should().BeTrue();
comparer.Equals(null, null).Should().BeTrue();
equals.Should().Be(expectedEquals);
hashX.Should().Be(expectedHashX);
hashY.Should().Be(expectedHashY);
}
}
public void Equals_SameObjects_TrueIsReturned()
{
var event1 = new TestEventOne {
Message = "one"
};
var event2 = new TestEventOne {
Message = "two"
};
var event3 = new TestEventOne {
Message = "three"
};
var collection1 = new[]
{
event1,
event2,
event3
};
var collection2 = new[]
{
event1,
event2,
event3
};
var result =
new CollectionEqualityComparer <TestEventOne, string>(obj => obj.Message).Equals(
collection1,
collection2);
result.Should().BeTrue();
}
public void Enumerable_structs_with_nullables_are_comparable()
{
var referenceComparer = new CollectionEqualityComparer <ComparableStruct <int?>?>(new NullableEqualityComparer <ComparableStruct <int?> >(new ComparableStructEqualityComparer <int?>()));
var comparer = ComparerBuilder.Default.GetEqualityComparer <EnumerableStruct <ComparableStruct <int?>?> >();
Helper.Parallel(() => {
var x = _fixture.Create <EnumerableStruct <ComparableStruct <int?>?> >();
var y = _fixture.Create <EnumerableStruct <ComparableStruct <int?>?> >();
var expectedHashX = referenceComparer.GetHashCode(x);
var expectedHashY = referenceComparer.GetHashCode(y);
var expectedEquals = referenceComparer.Equals(x, y);
var equals = comparer.Equals(x, y);
var hashX = comparer.GetHashCode(x);
var hashY = comparer.GetHashCode(y);
using (new AssertionScope()) {
comparer.Equals(x, x).Should().BeTrue();
equals.Should().Be(expectedEquals);
hashX.Should().Be(expectedHashX);
hashY.Should().Be(expectedHashY);
}
});
}
public void Equals_SamePrimitivesCollection_TrueIsReturned()
{
var collection = new[] { 1, 2, 3, 4, 5 };
var result = new CollectionEqualityComparer <int>().Equals(collection, collection);
result.Should().BeTrue();
}
public void Equals_DifferentPrimitives_FalseIsReturned()
{
var collection1 = new[] { 1, 2, 3, 4, 5 };
var collection2 = new[] { 1, 2, 4, 5, 6 };
var result = new CollectionEqualityComparer <int>().Equals(collection1, collection2);
result.Should().BeFalse();
}
public void Equals_SamePrimitivesDifferentOrder_TrueIsReturned()
{
var collection1 = new[] { 1, 2, 3, 4, 5 };
var collection2 = new[] { 1, 5, 3, 4, 2 };
var result = new CollectionEqualityComparer <int>().Equals(collection1, collection2);
result.Should().BeTrue();
}
public void Equals_NullCollectionVsEmptyCollection_TrueIsReturned()
{
var collection1 = Array.Empty <int>();
var collection2 = (int[]?)null;
var result1 = new CollectionEqualityComparer <int>().Equals(collection1, collection2);
var result2 = new CollectionEqualityComparer <int>().Equals(collection2, collection1);
result1.Should().BeTrue();
result2.Should().BeTrue();
}
public void Equals_SameObjectsCollection_TrueIsReturned()
{
var collection = new IEvent[]
{
new TestEventOne {
Message = "one"
},
new TestEventOne {
Message = "two"
},
new TestEventTwo()
};
var result = new CollectionEqualityComparer <IEvent>().Equals(collection, collection);
result.Should().BeTrue();
}
public bool Equals(TestBodyValuesV1Request request, TestBodyValuesV1Response response)
{
Argument.NotNull(request, nameof(request));
Argument.NotNull(response, nameof(response));
var collectionEqualityComparer = new CollectionEqualityComparer();
var dictionaryEqualityComparer = new DictionaryEqualityComparer();
bool equals = true;
if ((request.Boolean == response.Boolean &&
request.Byte == response.Byte &&
request.Char == response.Char &&
request.DateTimeOffset == response.DateTimeOffset &&
request.Decimal == response.Decimal &&
request.Double == response.Double &&
request.Enum == response.Enum &&
request.Int16 == response.Int16 &&
request.Int32 == response.Int32 &&
request.Int64 == response.Int64 &&
request.SignedByte == response.SignedByte &&
request.Single == response.Single &&
request.String == response.String &&
request.TimeSpan == response.TimeSpan &&
request.UnsignedInt16 == response.UnsignedInt16 &&
request.UnsignedInt32 == response.UnsignedInt32 &&
request.UnsignedInt64 == response.UnsignedInt64 &&
request.Uri == response.Uri &&
request.Uuid == response.Uuid) == false)
{
equals = false;
}
else if ((collectionEqualityComparer.CollectionEquals(request.Array, response.Array) &&
collectionEqualityComparer.CollectionEquals(request.Bytes, response.Bytes) &&
dictionaryEqualityComparer.DictionaryEquals(request.Dictionary, response.Dictionary)) == false)
{
equals = false;
}
return(equals);
}
public void Should_use_delayed_comparison()
{
var x = _fixture.CreateMany <SampleEqualityStruct <EnumSmall?>?>().ToArray();
var y = _fixture.CreateMany <SampleEqualityStruct <EnumSmall?>?>().ToArray();
var referenceComparer = new CollectionEqualityComparer <SampleEqualityStruct <EnumSmall?>?>(
new NullableEqualityComparer <SampleEqualityStruct <EnumSmall?> >());
var comparer = new ComparerBuilder().GetEqualityComparer <object>();
var expectedHashX = referenceComparer.GetHashCode(x);
var expectedHashY = referenceComparer.GetHashCode(y);
var actualHashX = comparer.GetHashCode(x);
var actualHashY = comparer.GetHashCode(y);
var expected = referenceComparer.Equals(x, y);
var actual = comparer.Equals(x, y);
using (new AssertionScope()) {
actualHashX.Should().Be(expectedHashX);
actualHashY.Should().Be(expectedHashY);
actual.Should().Be(expected);
}
}
