Should().BeEquivalentTo failing for identical objects

[RaphCayou]

Description

Using latest version 6.12.0

When trying to use BeEquivalentTo to compare 2 objects with a few properties, the assertion is failing even if the objects are identical.

Reproduction Steps

// DTO structure
public class Subscription
{
    public Guid Id { get; }
    public SubscriptionFees? Fees { get; }
    public SubscriptionCommitmentTerm? CommitmentTerm { get; }

    // ctor
}

public struct SubscriptionCommitmentTerm
{
    public CommitmentTermType Type { get; }
    public DateTime TermEndDate { get; }
    public SubscriptionRenewalConfiguration? RenewalConfiguration { get; }
    public CommittedMinimalQuantity[] CommittedMinimalQuantities { get; }

    // ctor
}

public struct SubscriptionFees
{
    public decimal RecurringFee { get; }
    public decimal SetupFee { get; }
    public Currency Currency { get; }

    // ctor
}

public struct CommittedMinimalQuantity
{
    public DateTime CommittedUntil { get; }
    public int Quantity { get; }

    // ctor
}

public struct SubscriptionRenewalConfiguration
{
    public DateTime RenewalDate { get; }
    public int? ScheduledQuantity { get; }

    // ctor
}

public enum CommitmentTermType
{
    Monthly = 0,
    Annual = 1,
    Biennial = 2,
    Triennial = 3
}

public enum Currency
{
    Undefined = 0,
    Cad = 1,
    Usd = 2,
    Eur = 3,
    Gbp = 4
}

[Test]
public void SimpleTest()
{
	var id = Guid.NewGuid();
	var now = DateTime.Now;
	var sub1 = new Subscription(
		id,
		new SubscriptionFees(
			6,
			7,
			Currency.Cad),
		new SubscriptionCommitmentTerm(
			CommitmentTermType.Monthly,
			now.AddMonths(1).AddDays(-1).ToLocalDate().ToDateTimeUnspecified(),
			null,
			new List<CommittedMinimalQuantity>
                        {
				new CommittedMinimalQuantity(
					now.AddDays(7),
					new Quantity(0)),
				new CommittedMinimalQuantity(
					now.AddDays(7).AddHours(2),
					new Quantity(2))
                        }),
		"monthly",
		now);
	var sub2 = new Subscription(
		id,
		new SubscriptionFees(
			6,
			7,
			Currency.Cad),
		new SubscriptionCommitmentTerm(
			CommitmentTermType.Monthly,
			now.AddMonths(1).AddDays(-1).ToLocalDate().ToDateTimeUnspecified(),
			null,
			new List<CommittedMinimalQuantity>
                        {
				new CommittedMinimalQuantity(
					now.AddDays(7),
					new Quantity(0)),
				new CommittedMinimalQuantity(
					now.AddDays(7).AddHours(2),
					new Quantity(2))
                        }),
		"monthly",
		now);

	sub1.Should().BeEquivalentTo(sub2);
}

Expected behavior

The BeEquivalentTo should give true because they are exactly the same. I thought it could be related to the struct but the SubscriptionFees are also a struct and they compare correctly. The error started happening when I added the CommittedMinimalQuantity DTO. If I remove that property from the DTO, the rest compares correctly, but I can't seem to pinpoint what specifically makes the comparison fail in that one.

Actual behavior

The assertion fails with this error.

Expected property response.GetResultValue().Items[0].CommitmentTerm to be 
SubscriptionCommitmentTerm
{
    {
    CommittedMinimalQuantities = CommittedMinimalQuantity
        {
            CommittedUntil = <2024-03-11 12:16:31.3016469>, 
            Quantity = 0
        }, 
        CommittedMinimalQuantity
        {
            CommittedUntil = <2024-03-11 14:16:31.3016469>, 
            Quantity = 2
            }
    }, 
    RenewalConfiguration = <null>, 
    TermEndDate = <2024-04-03>, 
    Type = CommitmentTermType.Monthly {value: 0}
}, but found 
SubscriptionCommitmentTerm
{
    {
    CommittedMinimalQuantities = CommittedMinimalQuantity
        {
            CommittedUntil = <2024-03-11 12:16:31.3016469>, 
            Quantity = 0
        }, 
        CommittedMinimalQuantity
        {
            CommittedUntil = <2024-03-11 14:16:31.3016469>, 
            Quantity = 2
            }
    }, 
    RenewalConfiguration = <null>, 
    TermEndDate = <2024-04-03>, 
    Type = CommitmentTermType.Monthly {value: 0}
}

Kdiff on the given error is identical.

Oddly, trying to using exclusion options on all properties of the DTO still makes it not equivalent.

Regression?

No response

Known Workarounds

In the meantime, making my assertion like this works for my test case. I exclude the problematic DTO, and I compare each property separately. Notice how the CommittedMinimalQuantities compares correctly, even though its introduction breaks the BeEquivalentTo.

responseSubscription.Should().BeEquivalentTo(
            expectedSubscription,
            c => c.Excluding(s => s.CommitmentTerm));
        responseCommitmentTerm.CommittedMinimalQuantities.Should().BeEquivalentTo(expectedCommitmentTerm.CommittedMinimalQuantities);
responseCommitmentTerm.RenewalConfiguration.Should().BeEquivalentTo(expectedCommitmentTerm.RenewalConfiguration);
responseCommitmentTerm.Type.Should().Be(expectedCommitmentTerm.Type);
responseCommitmentTerm.TermEndDate.Should().Be(expectedCommitmentTerm.TermEndDate);

Configuration

No response

Other information

No response

Are you willing to help with a pull-request?

No

[julienasp]

it is because struct are value types, and as such they are using the ComparingByValue strategy. (using the Equals, the inherited one in your case)

it is by design it's explained here: https://learn.microsoft.com/en-us/dotnet/fundamentals/code-analysis/quality-rules/ca1815

For non-blittable value types, the inherited implementation of Equals uses the System.Reflection library to compare the contents of all fields. Reflection is computationally expensive, and comparing every field for equality might be unnecessary. If you expect users to compare or sort instances, or use them as hash table keys, your value type should implement Equals. If your programming language supports operator overloading, you should also provide an implementation of the equality and inequality operators.

which is equivalent of calling Object.ReferenceEquals, so since your instances of the struct (without an Equals method) do not share the same reference, then it says that they are not equivalent.

by using AssertionOptions.AssertEquivalencyUsing(options => options
.ComparingByMembers());

it will force a referenceType comparison strategy.

Also related to

 I thought it could be related to the struct but the SubscriptionFees are also a struct and they compare correctly

your guts were onto something

from MSDN

 The Equals(Object) implementation provided by ValueType performs a byte-by-byte comparison for value types whose fields are all value types, but it uses reflection to perform a field-by-field comparison of value types whose fields include reference types

in your case the SubscriptionsFees is a byte-by-byte comparaison because all fields are value types, and the tricky part in your case is that SubscriptionCommitmentTerm is using a reference type, but going fast over the code we can miss it

CommittedMinimalQuantity[] <--------

an array is a reference type.

[julienasp]

@dennisdoomen is there a policy/config/setting to set ComparingByMembers for everything?

if there isnt, i might be down to do it

[dennisdoomen]

There's an AssertionOptions.AssertEquivalencyUsing that you can use to alter the behavior globally. You could use a module initializer to set that before the first test runs.