Come confrontare gli elenchi nel test unitario


181

Come può fallire questo test?

[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
}

Risposte:


371

Per fare affermazioni sulle raccolte, è necessario utilizzare CollectionAssert:

CollectionAssert.AreEqual(expected, actual);

List<T>non sovrascrive Equals, quindi se Assert.AreEqualsolo chiama Equals, finirà per usare l'uguaglianza di riferimento.


6
Vorrei che questo fornisse messaggi più dettagliati quando falliva. "Diverso numero di elementi" e "L'elemento all'indice 0 non corrispondono" sono leggermente inutili. Cosa sono allora ?!
Colonnello Panic,

32
Se non si cura di ordine voce: {A, B, C} == {C, B, A}, quindi utilizzare CollectionAssert.AreEquivalentinvece msdn.microsoft.com/en-us/library/ms243779.aspx
user2023861

2
Si noti che CollectionAssert.AreEqualpuò essere notevolmente più lento diAssert.IsTrue...SequenceEqual
Mark Sowul il

1
@MarkSowul: Ma viene fornita una diagnostica degli errori molto migliore, giusto?
Jon Skeet,

2
@MarkSowul: Hmm ... sembra che valga la pena segnalarlo come un bug. Nessun motivo dovrebbe essere così male.
Jon Skeet,

34

Immagino che questo ti aiuterà

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

4
Anche questo è stato il mio fallback, ma spero che CollectionAssert possa fornire messaggi di errore più utili.
Jon Skeet,

4
Purtroppo, in realtà non è così: "CollectionAssert.AreEqual fallito. (L'elemento all'indice 0 non corrisponde.)" (Quali sono gli elementi?)
nome

17

Se si desidera verificare che ciascuno contenga la stessa raccolta di valori, è necessario utilizzare:

CollectionAssert.AreEquivalent(expected, actual);

Modificare:

"Due raccolte sono equivalenti se hanno gli stessi elementi nella stessa quantità, ma in qualsiasi ordine. Gli elementi sono uguali se i loro valori sono uguali, non se si riferiscono allo stesso oggetto." - https://msdn.microsoft.com/en-us/library/ms243779.aspx


14

Ho provato le altre risposte in questo thread, e non hanno funzionato per me e stavo confrontando raccolte di oggetti che avevano gli stessi valori memorizzati nelle loro proprietà, ma gli oggetti erano diversi.

Metodo di chiamata:

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

Metodo di confronto:

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);
        }
    }

3
Bella aggiunta, oppure puoi anche sovrascrivere il Equalsmetodo e CollectionAssertfunzionerà.
Ray Cheng,

6

questo test confronta un input di data, controlla se è un anno bisestile, in tal caso, genera 20 anni bisestili dalla data immessa, in caso contrario, genera i prossimi 20 anni bisestili, myTest.Testing si riferisce all'istanza myTest che a sua volta chiama i valori da un elenco chiamato Test contenente i valori calcolati richiesti. parte di un esercizio che dovevo fare.

[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);
        }

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

//Atto

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

//Asserire

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

0

Affermazioni fluide fanno confronti profondi di array actualArray.Should().BeEquivalentTo(expectedArray)

Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.