Assertion failures with PropertiesComparer are hard to debug when combined with other modifiers

[Dreamescaper]

        await Assert.ThatAsync(() => getExpectedResult()), Is.EqualTo(new ExpectedType
        {
            My = 3.548m,
            Type = 0.312m,
            With = new()
            {
                Lots = true,
                Of = "23456",
                Properties = new(2024, 05, 24)
            }
        }).UsingPropertiesComparer().After(10000, 1000));

Assertion above fails with a not really useful message:

      Assert.That(() => getExpectedResult(), Is.EqualTo(new ExpectedType
        {
            My = 3.548m,
            Type = 0.312m,
            With = new()
            {
                Lots = true,
                Of = "23456",
                Properties = new(2024, 05, 24)
            }
        }).UsingPropertiesComparer().After(10000, 1000))
  Expected: <My.Name.Space.ExpectedType> after 10000 milliseconds delay
  But was:  <My.Name.Space.ExpectedType>

I would be really great to improve it and print the failed property name (like is happens when using PropertiesComparer without After).

[manfred-brands]

The interaction between ConstraintResult and MessageWriter is a bit weird and it depends on the implementation of both what is actually happening. EqualConstraintResult overwrites WriteMessageTo

I added an override of WriteMessageTo in the DelegatingConstraintResult to call _innerResult.WriteMessageTo(writer);
This results in:

  Values differ at property ExpectedType.My
  Values differ at property ExpectedType.My
...
  Values differ at property ExpectedType.My
  Values differ at property ExpectedType.My
  Expected: 3.548m
  But was:  9.876m

Not sure if you want to see that the property My was different for all 10 comparison attempts.
I added a ResetBaseConstraint which Clears the FailurePoints in the EqualConstraint.
Instead of the DelayedConstraint knowing about the EqualConstraint it might be better to add a virtual method to Constraint with only an implementation in EqualConstraint.

We now lost the information about this actually being a DelayedConstraint, the part that says: after 10000ms.
Putting the Description back in results in <My.Name.Space.ExpectedType> after 10000 milliseconds delay being put back in.

Changing the Description to use BaseConstraint.DisplayName instead drops the type name.

The sum of these now shows:

      Equal after 1000 milliseconds delay
      Values differ at property ExpectedType.My
      Expected: 3.548m
      But was:  9.876m

Better expected and actual values for any constraint with a value that doesn't override ToString itself would be useful.
The problem is to distinguish between value properties and properties that call into other methods.
I added a TryFormatProperties to MsgUtils.
It works for my implementation of ExpectedType

ExpectedType { My = 3.548m, Type = 0.312m, With = <{ Lots = True, Of = 23456, Properties = 24/05/2024 00:00:00 }> }

But as we had complaints when we introduced PropertiesComparer to be always selected if there is no user implementation of Equals, I'm reluctant to add this formatter unconditionally as some classes might have properties that are access databases.

[Dreamescaper]

Does it makes sense to only print properties when PropertiesComparer used?

[stevenaw]

Does it makes sense to only print properties when PropertiesComparer used?

This makes sense to me.

[stevenaw]

@manfred-brands Do you have any concerns about if the formatter were applied only if property comparer were used?

[manfred-brands]

Sorry for the delay, but work was hectic just after the holidays and I had to investigate #4919 as my new tests failed.

I updated EqualConstraintResult to call a new MsgUtils.FormatValueProperties method to format expected and actual values when the UsePropertiesComparer modifiers is used.

I updated the DelayedContraintResult to override WriteMessageTo and call to actual failing result's WriteMessageTo.

It now shows:

After 200 milliseconds delay
Expected: ExpectedType { My = 9.876m, Type = 0.432m, With = <{ Lots = True, Of = 23456, Properties = 24/05/2024 00:00:00 }> }
But was:  ExpectedType { My = 3.548m, Type = 0.432m, With = <{ Lots = False, Of = 13456, Properties = 26/12/2024 00:00:00 }> }
Values differ at property ExpectedType.My:
Expected: 9.876m
But was:  3.548m