ResolveTypeNameDifference does not handle generic types well

[mikkelbu]

Given two different classes that gives the same result via ToString(), e.g.

class Dummy
{
    internal readonly int value;

    public Dummy(int value)
    {
        this.value = value;
    }

    public override string ToString()
    {
        return "Dummy " + value;
    }
}

class Dummy1
{
    internal readonly int value;

    public Dummy1(int value)
    {
        this.value = value;
    }

    public override string ToString()
    {
        return "Dummy " + value;
    }
}

Then the following tests fails correctly with a message from ResolveTypeNameDifference that describes the type difference.

[Test]
public void SomeTest()
{
    var d1 = new Dummy(12);
    var d2 = new Dummy1(12);
    var tuple1 = new KeyValuePair<Dummy>("", d1);
    var tuple2 = new KeyValuePair<Dummy1>("", d2);

    Assert.That(tuple1, Is.EqualTo(tuple2));
}

The error message, however, does not handle the generic class very well

  Expected: (Dummy 12) (ValueTupleEqualityTests+Dummy1])
  But was:  (Dummy 12) (ValueTupleEqualityTests+Dummy])

I would have expected something like

  Expected: (Dummy 12) (KeyValuePair`2[String,ValueTupleEqualityTests+Dummy1])
  But was:  (Dummy 12) (KeyValuePair`2[String,ValueTupleEqualityTests+Dummy])

At the moment the code just splits on "." and there is no special handling of generic types.

[OmicronPersei]

(Somewhat off topic...): What KeyValuePair type are you using that accepts only one templated parameter?

Also, I was able to confirm the same using the below example test (based on your Dummy and Dummy1 types you specified):

[Test]
public void SomeTest()
{
	var d1 = new Dummy(12);
	var d2 = new Dummy1(12);
	var tuple1 = new Tuple<Dummy>(d1);
	var tuple2 = new Tuple<Dummy1>(d2);

	Assert.That(tuple1, Is.EqualTo(tuple2));
}

with a failure message of:

Message: Expected: <(Dummy 12)> (TextMessageWriterTests+Dummy1])
But was: <(Dummy 12)> (TextMessageWriterTests+Dummy])

[OmicronPersei]

Also I'm willing to take up this one, unless you wanted to @mikkelbu ?

[mikkelbu]

You are most welcome to take this one 😄 .

Wrt

(Somewhat off topic...): What KeyValuePair type are you using that accepts only one templated parameter?
then I think that I just made a copy-paste error. The first type parameter should be a string.

[OmicronPersei]

So @mikkelbu is right, we do indeed do our Type name differentiation by looking solely at when the namespace and/or type differs by iterating backwards using "." as a delimeter until a type name does not match.

Thinking about what this means for generics, I think the logic for determining the type/namespace difference demands its own class. Take, for example, the two differing types, with only templated param:

NUnit.Framework.Constraints.EqualConstraintTests+DummyTemplatedClass`1[NUnit.Framework.Constraints.EqualConstraintTests+Dummy]
NUnit.Framework.Constraints.EqualConstraintTests+DummyTemplatedClass`1[NUnit.Framework.Constraints.EqualConstraintTests+Dummy1]

The type/namespace of both the objects and their templated types can differ.

To implement the feature, I think what we'll need to do is perform the original algorithm, but for all types, including the generics.

[CharliePoole]

@OmicronPersei Could you point to the code where we do this? It's hard to search when using some platforms to read issues.

[OmicronPersei]

Should be right here.

[OmicronPersei]

I think either way, since there's already a lot going on in that method, this is probably a good time to extract a class from it, so that we can unit test the algorithm easier without relying on a fully constructed TextMessageWriter.

[CharliePoole]

I wasn't aware of that change. [Frustrating how big this project has become.]

I agree that you need to look at the implementation and maybe create a class. I think you may also want to look at how and where that method is getting called as well.