Comment affirmer que deux liste contient des éléments avec les mêmes propriétés publiques dans NUnit?

RETRAVAILLÉ RÉPONSE

Il y a un CollectionAssert.AreEqual(IEnumerable, IEnumerable, IComparer) de la surcharge d'affirmer que deux collections contiennent les mêmes objets dans le même ordre, à l'aide d'un IComparer mise en œuvre pour vérifier l'objet d'équivalence.

Dans le scénario décrit ci-dessus, l'ordre n'est pas important. Toutefois, suffisamment à gérer aussi la situation où il y a plusieurs équivalent des objets dans les deux collections, il devient nécessaire de premier ordre des objets dans chaque collecte et l'utilisation de l'une-par-une comparaison pour s'assurer que le nombre d'équivalent objets sont les mêmes dans les deux collections.

Enumerable.OrderBy fournit une surcharge qui prend un IComparer<T> argument. Pour s'assurer que les deux collections sont triés dans le même ordre, il est plus ou moins nécessaire que les types de l'identification des propriétés de mettre en œuvre IComparable. Voici un exemple de comparer la classe qui implémente à la fois la IComparer et IComparer<Foo> interfaces, et où il est supposé que Bar l'emporte lors de la commande:

public class FooComparer : IComparer, IComparer<Foo>
{
    public int Compare(object x, object y)
    {
        var lhs = x as Foo;
        var rhs = y as Foo;
        if (lhs == null || rhs == null) throw new InvalidOperationException();
        return Compare(lhs, rhs);
    }

    public int Compare(Foo x, Foo y)
    {
        int temp;
        return (temp = x.Bar.CompareTo(y.Bar)) != 0 ? temp : x.Bar2.CompareTo(y.Bar2);
    }
}

À affirmer que les objets dans les deux collections sont de même et vient en nombre égal (mais pas nécessairement dans le même ordre pour commencer), les lignes suivantes devraient faire l'affaire:

var comparer = new FooComparer();
CollectionAssert.AreEqual(
    expectedCollection.OrderBy(foo => foo, comparer), 
    foundCollection.OrderBy(foo => foo, comparer), comparer);    

À L'Aide De A.Tous les.Matches() fonctionne très bien pour la comparaison d'une trouvé de la collection à la devrait collection. Cependant, il n'est pas nécessaire de définir le prédicat utilisé par l'A.Tous les.Matches() comme une fonction distincte. Pour relativement simples comparaisons, le prédicat peut être inclus en tant que partie de l'expression lambda comme ça.

Assert.That(found, Has.All.Matches<Foo>(f => 
    expected.Any(e =>
        f.Bar1 == e.Bar1 &&
        f.Bar2 == e.Bar2 &&
        f.Bar3= = e.Bar3)));

Maintenant, alors que cette assertion s'assurer que chaque entrée dans le trouvé collection existe aussi dans le devrait collection, il ne prouve pas l'inverse, à savoir que chaque entrée dans le devrait collection est contenue dans le trouvé collection. Donc, quand il est important de savoir que trouvé et devrait contiennent sont sémantiquement équivalentes (c'est à dire, ils contiennent les mêmes sémantiquement équivalent entrées), on doit ajouter une affirmation supplémentaire.

Le plus simple choix est d'ajouter le suivant.

Assert.AreEqual(found.Count() == expected.Count());

Pour ceux qui préfèrent un plus gros marteau, de l'affirmation suivante pourrait être utilisée à la place.

Assert.That(expected, Has.All.Matches<Foo>(e => 
    found.Any(f =>
        e.Bar1 == f.Bar1 &&
        e.Bar2 == f.Bar2 &&
        e.Bar3= = f.Bar3)));

En utilisant la première assertion ci-dessus en association avec le deuxième (de préférence) ou de troisième affirmation, nous avons maintenant prouvé que les deux collections sont sémantiquement identiques.

Pour effectuer equivilance opérations sur des types complexes vous avez besoin pour mettre en œuvre IComaprable.

http://support.microsoft.com/kb/320727

Vous pouvez également utiliser récursive de réflexion, ce qui est moins souhaitable.

J'ai eu un problème similaire. Liste des contributeurs, qui contient des "commentateurs" et d'autres ppl... je veux obtenir tous les commentaires et de qui proviennent les créateurs, mais je suis ofc seulement intéressés par des créateurs uniques. Si quelqu'un a créé 50 commentaires je ne veux que son nom apparaît qu'une fois. Alors, j'ai écrit un test pour voir que les commentateurs sont int la GetContributors() résultat.

J'ai peut-être tort, mais ce que je pense de votre après (ce que j'ai est après, quand j'ai trouvé ce post), c'est affirmer qu'il y a exactement un de chaque élément dans une collection, trouve dans une autre collection.

J'ai résolu ce problème comme suit:

Assert.IsTrue(commenters.All(c => actual.Count(p => p.Id == c.Id) == 1));

Si vous aussi vous voulez la liste résultante de ne pas contenir d'autres éléments que prévu, vous pouvez simplement comparer la longueur des listes ainsi..

Assert.IsTrue(commenters.length == actual.Count());

J'espère que c'est utile, si oui, je serais très reconnaissant si vous dirais ma réponse.

Code Simple expliquant comment utiliser l'interface IComparer

using System.Collections;
using System.Collections.Generic;
using Microsoft.VisualStudio.TestTools.UnitTesting;
namespace CollectionAssert
{
[TestClass]
public class UnitTest1
{
[TestMethod]
public void TestMethod1()
{
IComparer collectionComparer = new CollectionComparer();
var expected = new List<SomeModel>{ new SomeModel { Name = "SomeOne", Age = 40}, new SomeModel{Name="SomeOther", Age = 50}};
var actual = new List<SomeModel> { new SomeModel { Name = "SomeOne", Age = 40 }, new SomeModel { Name = "SomeOther", Age = 50 } };
NUnit.Framework.CollectionAssert.AreEqual(expected, actual, collectionComparer);
}
}
public class SomeModel
{
public string Name { get; set; }
public int Age { get; set; }
}
public class CollectionComparer : IComparer, IComparer<SomeModel>
{
public int Compare(SomeModel x, SomeModel y)
{
if(x == null || y == null) return -1;
return x.Age == y.Age && x.Name == y.Name ? 0 : -1;
}
public int Compare(object x, object y)
{
var modelX = x as SomeModel;
var modelY = y as SomeModel;
return Compare(modelX, modelY);
}
}
}