Comment vérifier si une liste est ordonnée ?

Question

Je suis en train de faire des tests unitaires et je veux savoir s'il y a un moyen de tester si une liste est ordonnée par une propriété des objets qu'elle contient.

Pour l'instant, je le fais de cette façon mais je n'aime pas ça, je veux une meilleure méthode. Quelqu'un peut-il m'aider ?

// (fill the list)
List<StudyFeedItem> studyFeeds = 
    Feeds.GetStudyFeeds(2120, DateTime.Today.AddDays(-200), 20);   

StudyFeedItem previous = studyFeeds.First();

foreach (StudyFeedItem item in studyFeeds)
{
    if (item != previous)
    {
        Assert.IsTrue(previous.Date > item.Date);
    }

    previous = item;
}

Answer 1

Si vous utilisez MSTest, vous pouvez jeter un coup d'oeil à CollectionAssert.AreEqual .

Enumerable.SequenceEqual peut être une autre API utile à utiliser dans une assertion.

Dans les deux cas, vous devez préparer une liste qui contient la liste attendue dans l'ordre attendu, puis comparer cette liste au résultat.

Voici un exemple :

var studyFeeds = Feeds.GetStudyFeeds(2120, DateTime.Today.AddDays(-200), 20);   
var expectedList = studyFeeds.OrderByDescending(x => x.Date);
Assert.IsTrue(expectedList.SequenceEqual(studyFeeds));

Answer 2

Une solution .NET 4.0 consisterait à utiliser la fonction Enumerable.Zip pour fermer la liste en la décalant d'une unité, ce qui permet de coupler chaque élément avec l'élément suivant de la liste. Vous pouvez ensuite vérifier que la condition est vraie pour chaque paire, par ex.

var ordered = studyFeeds.Zip(studyFeeds.Skip(1), (a, b) => new { a, b })
                        .All(p => p.a.Date < p.b.Date);

Si vous êtes sur une version antérieure du framework, vous pouvez écrire votre propre méthode Zip sans trop de problème, quelque chose comme ce qui suit (la validation des arguments et l'élimination des énumérateurs si applicable est laissée au lecteur) :

public static IEnumerable<TResult> Zip<TFirst, TSecond, TResult>(
    this IEnumerable<TFirst> first,
    IEnumerable<TSecond> second,
    Func<TFirst, TSecond, TResult> selector)
{
    var e1 = first.GetEnumerator();
    var e2 = second.GetEnumerator();
    while (e1.MoveNext() & e2.MoveNext()) // one & is important
        yield return selector(e1.Current, e2.Current);
}

Answer 3

Introduction de Nunit 2.5 CollectionOrderedContraint et une belle syntaxe pour vérifier l'ordre d'une collection :

Assert.That(collection, Is.Ordered.By("PropertyName"));

Plus besoin de commander et de comparer manuellement.

Answer 4

Si votre cadre de test unitaire dispose de méthodes d'aide pour affirmer l'égalité des collections, vous devriez pouvoir faire quelque chose comme ceci (à la manière de NUnit) :

var sorted = studyFeeds.OrderBy(s => s.Date);
CollectionAssert.AreEqual(sorted.ToList(), studyFeeds.ToList());

La méthode assert fonctionne avec n'importe quel IEnumerable mais lorsque les deux collections sont de type IList ou "array of something", le message d'erreur envoyé en cas d'échec de l'assert contiendra l'index du premier élément non placé.

Answer 5

Pourquoi pas :

var list = items.ToList();
for(int i = 1; i < list.Count; i++) {
    Assert.IsTrue(yourComparer.Compare(list[i - 1], list[i]) <= 0);
} 

où yourComparer est une instance de YourComparer qui met en œuvre IComparer<YourBusinessObject> . Cela garantit que chaque élément est inférieur à l'élément suivant dans l'énumération.