Est-il un moyen facile de xunit.net pour comparer deux collections sans concernant les éléments de " l'ordre?

Dans un de mes tests, je veux m'assurer qu'une collection de certains articles. Donc, je veux comparer cette collection avec les éléments de la collection pas sur l'ordre des éléments. Actuellement, mon code de test ressemble un peu à ceci:

[Fact]
public void SomeTest()
{
    //Do something in Arrange and Act phase to obtain a collection
    List<int> actual = ...

    //Now the important stuff in the Assert phase
    var expected = new List<int> { 42, 87, 30 };
    Assert.Equal(expected.Count, actual.Count);
    foreach (var item in actual)
        Assert.True(expected.Contains(item));
}

Est-il un moyen plus facile à atteindre dans xunit.net? Je ne peux pas utiliser Assert.Equal que cette méthode vérifie si l'ordre des éléments est la même dans les deux collections. J'ai eu un coup d'oeil à Assert.Collection mais cela ne veut pas supprimer le Assert.Equal(expected.Count, actual.Count) instruction dans le code ci-dessus.

Merci pour vos réponses à l'avance.

OriginalL'auteur feO2x | 2015-01-29

automated-tests c#xunit.net

20

Brad Wilson, de xunit.net m'a dit dans ce Github Problème que l'on devrait utiliser LINQ OrderBy de l'opérateur et par la suite Assert.Equal pour vérifier que les deux collections contiennent de l'égalité des articles sans quant à leur ordre. Bien sûr, vous devriez avoir une propriété sur l'élément correspondant de la classe que vous pouvez utiliser pour la commande en premier lieu (que je n'ai pas vraiment dans mon cas).

Personnellement, j'ai résolu ce problème en utilisant FluentAssertions, une bibliothèque qui fournit un grand nombre de méthodes d'assertion qui peut être appliquée dans un fluide de style. Bien sûr, il y a aussi beaucoup de méthodes que vous pouvez utiliser pour valider les collections.

Dans le contexte de ma question, je voudrais utiliser quelque chose comme le code suivant:
```
[Fact]
public void Foo()
{
    var first = new[] { 1, 2, 3 };
    var second = new[] { 3, 2, 1 };

    first.Should().BeEquivalentTo(second);
}
```
Ce test passe parce que les BeEquivalentTo appel ignore l'ordre des éléments.

Shouldly est également une bonne alternative si vous ne voulez pas aller avec FluentAssertions.

OriginalL'auteur feO2x
11

Pas un Xunit, mais une Linq réponse :
```
bool areSame = !expected.Except(actual).Any() && expected.Count == actual.Count;
```
Donc dans XUnit :
```
Assert.True(!expected.Except(actual).Any() && expected.Count == actual.Count));
```
@Robi-y dit, dans Microsoft.VisualStudio.QualityTools.UnitTestFramework il est CollectionAssert.AreEquivalent

Vous devez également vérifier les tailles de droite?
Je pense que vous avez raison @thomas d'aquin: Raph réponse échouera si la liste 1 est {1, 3, 5} et la liste 2 est {1, 3, 3, 3, 5}. Maintenant que j'y pense, en vérifiant les dimensions peuvent ne pas être suffisant, car que serait un échec si la liste 1 est {1, 1, 3, 5, 5} et la liste 2 est {1, 3, 3, 5, 5}. Pourtant, +1 à Raph pour un très élégant point de départ.
À l'exception des rendements les différences entre les deux listes. Si il y a un élément de plus dans une liste, ce point sera donné. Donc pas besoin de vérifier la taille.
Hmmm. Oui, si il y a un chevauchement des valeurs, il échoue. En outre, ce test ne n' de vérifier les valeurs de l'ordre. Vous devez ajouter vérifier sur le Comte. Donc je corrige ma réponse
Vous pouvez également utiliser le CollectionAssert.AreEquivalent à partir de mstest...

OriginalL'auteur rducom
6

Peut-être une autre façon est:
```
Assert.True(expected.SequenceEqual(actual));
```
Ce ne vérifie l'ordre aussi. C'est ce qui se passe en interne:
```
using (IEnumerator<TSource> e1 = first.GetEnumerator())
using (IEnumerator<TSource> e2 = second.GetEnumerator())
{
    while (e1.MoveNext())
    {
        if (!(e2.MoveNext() && comparer.Equals(e1.Current, e2.Current))) return false;
    }
    if (e2.MoveNext()) return false;
}
return true;
```
Donc, si vous ne se soucient pas de l'ordre, il suffit de commander les deux listes avant:
```
Assert.True(expected.OrderBy(i => i).SequenceEqual(actual.OrderBy(i => i)));
```
Merci Raph - je devrais peut-être ont précisé dans ma réponse que la liste ne contient pas nécessairement les valeurs int. En fait les valeurs que j'utilise ne peut pas être commandé (c'est à dire les classes correspondantes ne pas mettre en œuvre IComparable<T>). Ainsi SequenceEqual n'est pas une option, car elle vérifie l'ordre des éléments.
Si vous avez une propriété d'identité sur vous de la classe, peut-être que vous pouvez l'utiliser à l'ordre par cette propriété. Dans le pire des cas, vous pouvez mettre en œuvre une coutume IEqualityComparer<T> pour votre classe.

OriginalL'auteur rducom
1

Vous pouvez utiliser CollectionAssert.AreEquivalent de Microsoft
```
CollectionAssert.AreEquivalent(expected, actual);
```
OriginalL'auteur mantale

Vous devez vous connecter pour publier un commentaire.