CollectionAssert.AreEquivalent vs Assert.Equals()

Question

public void NumericListCanBeSorted()
{
  var sorted = sort.SortNumbers(nums);
  Assert.AreEqual(sorted, nums);
}

public List<int> SortNumbers(List<int> nums)
    {
        List<int> sortedList = new List<int>();

        for (int i = 0; i < nums.Count(); i++)
        {
            for (int j = i + 1; j < nums.Count; j++)
            {
                if (nums[i] > nums[j])
                {
                    //Swapping values
                    nums[i] = nums[i] + nums[j];
                    nums[j] = nums[i] - nums[j];
                    nums[i] = nums[i] - nums[j];
                }
            }
            sortedList.Add(nums[i]);
        }
        return sortedList;
    }

Result Message: Assert.AreEqual failed. 
Expected:     <System.Collections.Generic.List`1[System.Int32]>. 
      Actual :<System.Collections.Generic.List`1[System.Int32]>.

The datatypes of expected and actual are same. Still test failed. Cannot understand why? Can someone please help me know the reason.Moreover, it works for the following function.

  public List<int> SortNumbers(List<int> nums)
    {
        List<int> sortedList = new List<int>();
        for (int i = 0; i < nums.Count(); i++)
        {
            for (int j = i + 1; j < nums.Count; j++)
            {
                if (nums[i] > nums[j])
                {
                    //Swapping values
                    nums[i] = nums[i] + nums[j];
                    nums[j] = nums[i] - nums[j];
                    nums[i] = nums[i] - nums[j];
                }
            }
        }
        sortedList = nums;
        return sortedList;
    }

Answer 1

Reference type comparisons.

Try using CollectionAssert.AreEqual or CollectionAssert.AreEquivalent.

https://msdn.microsoft.com/en-us/library/microsoft.visualstudio.testtools.unittesting.collectionassert.areequivalent.aspx

Here's what happens:

You use Assert.AreEqual(List<int>, List<int>), of which, the CLR/.NET go in and say, "is the reference of List 1 the same as List 2?" The result is no, therefore the CLR/.NET send you a false reading.

CollectionAssert enumerates the arrays (which is what Lists are internally) and determines if they have the same items. CollectionAssert.AreEqual check that they have the same items in the same order. CollectionAssert.AreEquivalent check that they have the same items, in any order.

ANY array/List/Dictionary MUST use CollectionAssert for such comparisons.

For example:

List<int> l1 = new List<int>();
List<int> l2 = l1;
Assert.AreEqual(l1, l2);

This will result in true, due to l2 having been set to the same reference as l1.

However,

List<int> l1 = new List<int>();
List<int> l2 = new List<int>();
Assert.AreEqual(l1, l2);

This will result in a false due to l2 having been made a NEW reference to a NEW object. Whereas using

CollectionAssert.AreEqual(l1, l2);

Will result in a true in either situation above. This is because the CLR/.NET actually go through the list and inventory it, essentially.

Another edit, because I wanted to clarify further: you can also use CollectionAssert.AreEquivalent, which will not guarantee the items in the same order, but will simply guarantee that the arrays/Lists/Dictionaries have the same quantities of the same items. I.e.:

1,2,3,3,2,1
1,3,2,2,3,1

This will result in true with CollectionAssert.AreEquivalent, but false with CollectionAssert.AreEqual.