Comment Comparer deux objets dans l'unité de test?

Ce que vous cherchez est ce qu'en xUnit des Modèles de Test est appelé Test Spécifique À L'Égalité.

Alors que vous pouvez choisir de remplacer la méthode Equals, cela peut conduire à L'Égalité De La Pollution parce que la mise en œuvre, vous devez le test peut ne pas être le plus approprié pour le type en général.

Par exemple, Domain-Driven Design distingue entre Entités et des Objets de Valeur de, et ceux-là sont très différentes de l'égalité sémantique.

Lorsque c'est le cas, vous pouvez écrire une comparaison personnalisée pour le type en question.

Si vous êtes fatigués de faire cela, AutoFixture's à la Ressemblance de classe offre à des fins générales de Test Spécifique à l'Égalité. Avec vos Élèves de la classe, cela vous permettra d'écrire un test comme ceci:

[TestMethod]
public void VerifyThatStudentAreEqual()
{
    Student st1 = new Student();
    st1.ID = 20;
    st1.Name = "ligaoren";

    Student st2 = new Student();
    st2.ID = 20;
    st2.Name = "ligaoren";

    var expectedStudent = new Likeness<Student, Student>(st1);

    Assert.AreEqual(expectedStudent, st2);
}

Ce n'est pas vous obliger à remplacer est Égal à l'Élève.

Ressemblance effectue une sémantique de comparaison, de sorte qu'il peut aussi comparer deux types différents, aussi longtemps qu'ils sont sémantiquement similaires.

Vous devez fournir un override de de l'Objet.Égal à et de l'Objet.GetHashCode:

public override bool Equals(object obj) {
    Student other = obj as Student;
    if(other == null) {
        return false;
    }
    return (this.Name == other.Name) && (this.ID == other.ID);
}

public override int GetHashCode() {
    return 33 * Name.GetHashCode() + ID.GetHashCode();
}

Comme pour vérifier si les deux collections sont égaux, l'utilisation Énumérable.SequenceEqual:

//first and second are IEnumerable<T>
Assert.IsTrue(first.SequenceEqual(second)); 

Notez que vous devrez peut-être utiliser le surcharge qui accepte un IEqualityComparer<T>.

http://www.infoq.com/articles/Equality-Overloading-DotNET

Cet article peut être utile , je résoudre ce problème simplement en utilisant refcetion dump tout rempli;
Ensuite, nous avons juste besoin de comparer deux chaînes de caractères.

Code Ici:

 ///<summary>
    ///output all properties and values of obj
    ///</summary>
    ///<param name="obj"></param>
    ///<param name="separator">default as ";"</param>
    ///<returns>properties and values of obj,with specified separator </returns>
    ///<Author>ligaoren</Author>
    public static string Dump(object obj, string separator)
    {
        try
        {
            if (obj == null)
            {
                return string.Empty;
            }
            if (string.IsNullOrEmpty(separator))
            {
                separator = ";";
            }
            Type t = obj.GetType();
            StringBuilder info = new StringBuilder(t.Name).Append(" Values : ");
            foreach (PropertyInfo item in t.GetProperties())
            {
                object value = t.GetProperty(item.Name).GetValue(obj, null);
                info.AppendFormat("[{0}:{1}]{2}", item.Name, value, separator);
            }
            return info.ToString();
        }
        catch (Exception ex)
        {
            log.Error("Dump Exception", ex);
            return string.Empty;
        }
    }

1. Bonjour tout d'abord ajouter votre projet de test Newtonsoft.Json avec Nuget PM

   H> Install-Package Newtonsoft.Json -Version 10.0.3

2. Puis ajouter le fichier de test

   using Newtonsoft.Json;

3. Utilisation:

   Assert.AreEqual(
       JsonConvert.SerializeObject(expected),
       JsonConvert.SerializeObject(actual));

Ont un coup d'oeil sur le lien suivant. Sa solution sur le projet de code et je l'ai utilisé aussi. Il fonctionne très bien pour comparer des objets dans les deux NUnit et MSUnit

http://www.codeproject.com/Articles/22709/Testing-Equality-of-Two-Objects?msg=5189539#xx5189539xx

Peut-être vous avez besoin d'ajouter un public bool Equals(object o) à la classe.

Si vous utilisez NUnit vous pouvez utiliser cette syntaxe et de spécifier un IEqualityComparer spécifiquement pour le test:

[Test]
public void CompareObjectsTest()
{
    ClassType object1 = ...;
    ClassType object2 = ...;
    Assert.That( object1, Is.EqualTo( object2 ).Using( new MyComparer() ) );
}

private class MyComparer : IEqualityComparer<ClassType>
{
    public bool Equals( ClassType x, ClassType y )
    {
        return ....
    }

    public int GetHashCode( ClassType obj )
    {
        return obj.GetHashCode();
    }
}

Voir aussi ici: L'Égalité De Contrainte (NUnit 2.4 /2.5)