How does Assert.AreEqual determine equality between two generic IEnumerables?

Question

I have a unit test that will test to see if a method that returns the correct IEnumerable. The method builds the IEnumerable using yield return. The class that it is an IEnumerable of is below:

enum TokenType
{
    NUMBER,
    COMMAND,
    ARITHMETIC,
}

internal class Token
{
    public TokenType type {get; set;}
    public string text {get; set;}
    public static bool operator == (Token lh, Token rh) { return (lh.type == rh.type) && (lh.text == rh.text);}
    public static bool operator !=(Token lh, Token rh) { return !(lh == rh); }
    public override int GetHashCode()
    {
        return text.GetHashCode() % type.GetHashCode();
    }
    public override bool Equals(object obj)
    { return this == (Token)obj; }
}

This is the relevant part of the method:

 foreach (var lookup in REGEX_MAPPING)
 {
     if (lookup.re.IsMatch(s))
     {
         yield return new Token { type = lookup.type, text = s };
         break;
     }
 }

If I store the result of this method in actual and make another enumerable expected and compare them like this:

  Assert.AreEqual(expected, actual);

...the assertion fails.

I wrote an extension method for IEnumerable that is similar to Python's zip function (it combines two IEnumerables into a set of pairs), and tried this:

foreach(Token[] t in expected.zip(actual))
{
    Assert.AreEqual(t[0], t[1]);
}

...and it worked! So what is the difference between these two Assert.AreEquals?

Answer 1

Assert.AreEqual is going to compare the two objects at hand. IEnumerables are types in and of themselves, and provide a mechanism to iterate over some collection...but they are not actually that collection. Your original comparison compared two IEnumerables, which is a valid comparison...but that wasn't what you needed. You needed to compare what the two IEnumerables were intended to enumerate.

Here is how I compare two enumerables:

Assert.AreEqual(t1.Count(), t2.Count());

IEnumerator<Token> e1 = t1.GetEnumerator();
IEnumerator<Token> e2 = t2.GetEnumerator();

while (e1.MoveNext() && e2.MoveNext())
{
    Assert.AreEqual(e1.Current, e2.Current);
}

I am not sure if the above is less code than what your .Zip method or not, but its about as simple as it gets.

Answer 2

Found it:

Assert.IsTrue(expected.SequenceEqual(actual));

Answer 3

Have you considered using the CollectionAssert class instead... considering that it is intended to perform equality checks on collections?

Addendum:
If the 'collections' being compared are enumerations, then simply wrapping in a 'new List<T>(enumeration)' is the easiest way to perform the comparison. Constructing a new list causes some overhead ofcourse, but in the context of a unit test this should not matter too much I hope?