Jak porównać listy w testach jednostkowych

Jak ten test może się nie powieść?

[TestMethod]
public void Get_Code()
{
    var expected = new List<int>();
    expected.AddRange(new [] { 100, 400, 200, 900, 2300, 1900 });

    var actual = new List<int>();
    actual.AddRange(new [] { 100, 400, 200, 900, 2300, 1900 });

    Assert.AreEqual(expected, actual);
    // Assert.AreSame(expected, actual)       fails
    // Assert.IsTrue(expected.Equals(actual)) fails
}

Aby twierdzić o kolekcjach, należy użyć CollectionAssert:

CollectionAssert.AreEqual(expected, actual);

List<T>nie zastępuje Equals, więc jeśli Assert.AreEqualtylko Equalswywoła, skończy się na równości referencji.

Myślę, że to pomoże

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

Jeśli chcesz sprawdzić, czy każda zawiera tę samą kolekcję wartości, powinieneś użyć:

CollectionAssert.AreEquivalent(expected, actual);

Edytować:

„Dwie kolekcje są równoważne, jeśli mają te same elementy w tej samej ilości, ale w dowolnej kolejności. Elementy są równe, jeśli ich wartości są równe, a nie jeśli odnoszą się do tego samego obiektu.” - https://msdn.microsoft.com/en-us/library/ms243779.aspx

Próbowałem innych odpowiedzi w tym wątku, ale one nie działały dla mnie i porównywałem kolekcje obiektów, które miały takie same wartości zapisane w swoich właściwościach, ale obiekty były różne.

Wywołanie metody:

CompareIEnumerable(to, emailDeserialized.ToIndividual,
            (x, y) => x.ToName == y.ToName && x.ToEmailAddress == y.ToEmailAddress);

Metoda porównań:

private static void CompareIEnumerable<T>(IEnumerable<T> one, IEnumerable<T> two, Func<T, T, bool> comparisonFunction)
    {
        var oneArray = one as T[] ?? one.ToArray();
        var twoArray = two as T[] ?? two.ToArray();

        if (oneArray.Length != twoArray.Length)
        {
            Assert.Fail("Collections are not same length");
        }

        for (int i = 0; i < oneArray.Length; i++)
        {
            var isEqual = comparisonFunction(oneArray[i], twoArray[i]);
            Assert.IsTrue(isEqual);
        }
    }

ten test porównuje wprowadzoną datę, sprawdza, czy jest to rok przestępny, jeśli tak, generuje 20 lat przestępnych od wprowadzonej daty, jeśli nie, wyświetla NASTĘPNE 20 lat przestępnych, myTest. Testowanie odnosi się do instancji myTest, która z kolei wywołuje wartości z listy o nazwie Testowanie zawierające wymagane obliczone wartości. część ćwiczenia, które musiałem wykonać.

[TestMethod]
        public void TestMethod1()
        {
            int testVal = 2012;
            TestClass myTest = new TestClass();
            var expected = new List<int>();
            expected.Add(2012);
            expected.Add(2016);
            expected.Add(2020);
            expected.Add(2024);
            expected.Add(2028);
            expected.Add(2032);
            expected.Add(2036);
            expected.Add(2040);
            expected.Add(2044);
            expected.Add(2048);
            expected.Add(2052);
            expected.Add(2056);
            expected.Add(2060);
            expected.Add(2064);
            expected.Add(2068);
            expected.Add(2072);
            expected.Add(2076);
            expected.Add(2080);
            expected.Add(2084);
            expected.Add(2088);
            var actual = myTest.Testing(2012);
            CollectionAssert.AreEqual(expected, actual);
        }

List<AdminUser> adminDetailsExpected = new List<AdminUser>()
{
new AdminUser  {firstName = "test1" , lastName = "test1" , userId = 
"001test1"  },
new AdminUser {firstName = "test2" , lastName = "test2" , userId = 
"002test2"   }
};

//Działać

List<AdminUser> adminDetailsActual = RetrieveAdmin(); // your retrieve logic goes here

//Zapewniać

Assert.AreEqual(adminDetailsExpected.Count, adminDetailsActual.Count);  //Test succeeds if the count matches else fails. This count can be used as a work around to test

Płynne twierdzenia dokonują głębokich porównań tablic actualArray.Should().BeEquivalentTo(expectedArray)