Пример #1
0
        public void Equality_on_member_array_of_nullables_works()
        {
            var x = _fixture.Create <ComparableObject <EnumSmall?[]> >();

            x.Field    = x.Field?.RandomNulls().ToArray();
            x.Property = x.Property?.RandomNulls().ToArray();
            var y = _fixture.Create <ComparableObject <EnumSmall?[]> >();

            y.Field    = y.Field?.RandomNulls().ToArray();
            y.Property = y.Property?.RandomNulls().ToArray();

            var referenceComparer = new ComparableObjectEqualityComparer <EnumSmall?[]>(new CollectionEqualityComparer <EnumSmall?>());
            var expectedHashX     = referenceComparer.GetHashCode(x);
            var expectedHashY     = referenceComparer.GetHashCode(y);
            var expectedEquals    = referenceComparer.Equals(x, y);

            var comparer = ComparerBuilder.Default.GetEqualityComparer <ComparableObject <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();
                comparer.Equals(null, null).Should().BeTrue();
                equals.Should().Be(expectedEquals);
                hashX.Should().Be(expectedHashX, x.ToJson());
                hashY.Should().Be(expectedHashY, y.ToJson());
            }
        }
Пример #2
0
        public void After_clean_custom_comparer_for_value_type_dynamic_comparer_should_be_created()
        {
            var x = _fixture.Create <ComparableObject <ComparableStruct <string> > >();
            var y = _fixture.Create <ComparableObject <ComparableStruct <string> > >();

            var reference          = new ComparableObjectEqualityComparer <ComparableStruct <string> >(new ComparableStructEqualityComparer <string>());
            var expectedEquals     = reference.Equals(x, y);
            var expectedHash       = reference.GetHashCode(x);
            var expectedCustomHash = HashCodeCombiner.Combine(0, 0);

            var builder         = new ComparerBuilder(c => c.SetCustomEqualityComparer <SampleStructCustomEqualityComparer>());
            var comparerCustom  = builder.GetEqualityComparer <ComparableObject <ComparableStruct <string> > >();
            var comparerDefault =
                builder.Configure(c => c.SetCustomEqualityComparer <ComparableStruct <string> >(null))
                .GetEqualityComparer <ComparableObject <ComparableStruct <string> > >();

            using (new AssertionScope()) {
                comparerCustom.Equals(x, y).Should().BeTrue();
                comparerCustom.GetHashCode(x).Should().Be(expectedCustomHash);
                comparerDefault.Equals(x, y).Should().Be(expectedEquals);
                comparerDefault.GetHashCode(x).Should().Be(expectedHash);
            }
        }