Comment affirmer l'égalité sur deux classes sans méthode d'égalité?

Disons que j'ai une classe sans méthode equals (), dont je n'ai pas la source. Je veux affirmer l'égalité sur deux instances de cette classe.

Je peux faire plusieurs assertions:

assertEquals(obj1.getFieldA(), obj2.getFieldA());
assertEquals(obj1.getFieldB(), obj2.getFieldB());
assertEquals(obj1.getFieldC(), obj2.getFieldC());
...

Je n'aime pas cette solution parce que je n'obtiens pas une image complète de l'égalité si une affirmation précoce échoue.

Je peux comparer manuellement et suivre le résultat:

String errorStr = "";
if(!obj1.getFieldA().equals(obj2.getFieldA())) {
    errorStr += "expected: " + obj1.getFieldA() + ", actual: " + obj2.getFieldA() + "\n";
}
if(!obj1.getFieldB().equals(obj2.getFieldB())) {
    errorStr += "expected: " + obj1.getFieldB() + ", actual: " + obj2.getFieldB() + "\n";
}
...
assertEquals("", errorStr);

Cela me donne une image complète de l'égalité, mais c'est maladroit (et je n'ai même pas pris en compte d'éventuels problèmes de nullité). Une troisième option consiste à utiliser Comparator, mais compareTo () ne me dira pas quels champs ont échoué à l'égalité.

Existe-t-il une meilleure pratique pour obtenir ce que je veux de l'objet, sans sous-classer ni surcharger les égaux (ugh)?

Mockito propose une réflexion-matcher:

Pour la dernière version de Mockito, utilisez:

Assert.assertTrue(new ReflectionEquals(expected, excludeFields).matches(actual));

Pour les anciennes versions, utilisez:

Assert.assertThat(actual, new ReflectionEquals(expected, excludeFields));

Il y a beaucoup de bonnes réponses ici, mais j'aimerais aussi ajouter ma version. Ceci est basé sur Assertj.

import static org.assertj.core.api.Assertions.assertThat;

public class TestClass {

    public void test() {
        // do the actual test
        assertThat(actualObject)
            .isEqualToComparingFieldByFieldRecursively(expectedObject);
    }
}

MISE À JOUR: Dans assertj v3.13.2, cette méthode est obsolète comme indiqué par Woodz dans le commentaire. La recommandation actuelle est

public class TestClass {

    public void test() {
        // do the actual test
        assertThat(actualObject)
            .usingRecursiveComparison()
            .isEqualTo(expectedObject);
    }

}

J'implémente généralement ce cas d'utilisation en utilisant org.apache.commons.lang3.builder.EqualsBuilder

Assert.assertTrue(EqualsBuilder.reflectionEquals(expected,actual));

Je sais que c'est un peu vieux, mais j'espère que ça aide.

Je rencontre le même problème que vous, donc, après enquête, j'ai trouvé peu de questions similaires à celle-ci, et, après avoir trouvé la solution, je réponds à la même chose dans celles-ci, car je pensais que cela pourrait aider les autres.

La réponse la plus votée (et non celle choisie par l'auteur) de cette question similaire , est la solution la plus appropriée pour vous.

Fondamentalement, cela consiste à utiliser la bibliothèque appelée Unitils .

Voici l'utilisation:

User user1 = new User(1, "John", "Doe");
User user2 = new User(1, "John", "Doe");
assertReflectionEquals(user1, user2);

Ce qui passera même si la classe Userne s'implémente pas equals(). Vous pouvez voir plus d'exemples et une affirmation vraiment cool appelée assertLenientEqualsdans leur tutoriel .

Vous pouvez utiliser Apache commons lang ReflectionToStringBuilder

Vous pouvez soit spécifier les attributs que vous souhaitez tester un par un, ou mieux, exclure ceux que vous ne voulez pas:

String s = new ReflectionToStringBuilder(o, ToStringStyle.SHORT_PREFIX_STYLE)
                .setExcludeFieldNames(new String[] { "foo", "bar" }).toString()

Vous comparez ensuite les deux chaînes comme d'habitude. Pour ce qui est de la lenteur de la réflexion, je suppose que ce n'est que pour les tests, donc cela ne devrait pas être si important.

Si vous utilisez hamcrest pour vos assertions (assertThat) et que vous ne voulez pas extraire de bibliothèques de test supplémentaires, vous pouvez utiliser SamePropertyValuesAs.samePropertyValuesAspour assertir des éléments qui n'ont pas de méthode equals remplacée.

L'avantage est que vous n'avez pas à insérer encore un autre framework de test et cela donnera une erreur utile lorsque l'assertion échoue ( expected: field=<value> but was field=<something else>) au lieu d' expected: true but was falseutiliser quelque chose comme EqualsBuilder.reflectionEquals().

L'inconvénient est qu'il s'agit d'une comparaison superficielle et qu'il n'y a pas d'option pour exclure des champs (comme c'est le cas dans EqualsBuilder), vous devrez donc contourner les objets imbriqués (par exemple, supprimez-les et comparez-les indépendamment).

Meilleur cas:

import static org.hamcrest.beans.SamePropertyValuesAs.samePropertyValuesAs;
...
assertThat(actual, is(samePropertyValuesAs(expected)));

Affaire laide:

import static org.hamcrest.beans.SamePropertyValuesAs.samePropertyValuesAs;
...
SomeClass expected = buildExpected(); 
SomeClass actual = sut.doSomething();

assertThat(actual.getSubObject(), is(samePropertyValuesAs(expected.getSubObject())));    
expected.setSubObject(null);
actual.setSubObject(null);

assertThat(actual, is(samePropertyValuesAs(expected)));

Alors, choisissez votre poison. Framework supplémentaire (par exemple Unitils), erreur inutile (par exemple EqualsBuilder) ou comparaison superficielle (hamcrest).

La bibliothèque Hamcrest 1.3 Utility Matchers a un matcher spécial qui utilise la réflexion au lieu d'égal.

assertThat(obj1, reflectEquals(obj2));

Certaines des méthodes de comparaison de réflexion sont peu profondes

Une autre option consiste à convertir l'objet en json et à comparer les chaînes.

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;    
public static String getJsonString(Object obj) {
 try {
    ObjectMapper objectMapper = new ObjectMapper();
    return bjectMapper.writerWithDefaultPrettyPrinter().writeValueAsString(obj);
     } catch (JsonProcessingException e) {
        LOGGER.error("Error parsing log entry", e);
        return null;
    }
}
...
assertEquals(getJsonString(MyexpectedObject), getJsonString(MyActualObject))

En utilisant Shazamcrest , vous pouvez faire:

assertThat(obj1, sameBeanAs(obj2));

Comparez champ par champ:

assertNotNull("Object 1 is null", obj1);
assertNotNull("Object 2 is null", obj2);
assertEquals("Field A differs", obj1.getFieldA(), obj2.getFieldA());
assertEquals("Field B differs", obj1.getFieldB(), obj2.getFieldB());
...
assertEquals("Objects are not equal.", obj1, obj2);

Les assertions AssertJ peuvent être utilisées pour comparer les valeurs sans #equalsméthode correctement remplacée, par exemple:

import static org.assertj.core.api.Assertions.assertThat; 

// ...

assertThat(actual)
    .usingRecursiveComparison()
    .isEqualTo(expected);

Cette question étant ancienne, je proposerai une autre approche moderne utilisant JUnit 5.

Je n'aime pas cette solution parce que je n'obtiens pas une image complète de l'égalité si une affirmation précoce échoue.

Avec JUnit 5, il existe une méthode appelée Assertions.assertAll()qui vous permettra de regrouper toutes les assertions de votre test, qui exécutera chacune d'elles et affichera toutes les assertions ayant échoué à la fin. Cela signifie que toutes les assertions qui échouent en premier n'arrêteront pas l'exécution des dernières assertions.

assertAll("Test obj1 with obj2 equality",
    () -> assertEquals(obj1.getFieldA(), obj2.getFieldA()),
    () -> assertEquals(obj1.getFieldB(), obj2.getFieldB()),
    () -> assertEquals(obj1.getFieldC(), obj2.getFieldC()));

Vous pouvez utiliser la réflexion pour «automatiser» le test d'égalité complet. vous pouvez implémenter le code de «suivi» d'égalité que vous avez écrit pour un seul champ, puis utiliser la réflexion pour exécuter ce test sur tous les champs de l'objet.

Il s'agit d'une méthode de comparaison générique, qui compare deux objets d'une même classe pour ses valeurs de champs (gardez à l'esprit que ceux-ci sont accessibles par la méthode get)

public static <T> void compare(T a, T b) throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
    AssertionError error = null;
    Class A = a.getClass();
    Class B = a.getClass();
    for (Method mA : A.getDeclaredMethods()) {
        if (mA.getName().startsWith("get")) {
            Method mB = B.getMethod(mA.getName(),null );
            try {
                Assert.assertEquals("Not Matched = ",mA.invoke(a),mB.invoke(b));
            }catch (AssertionError e){
                if(error==null){
                    error = new AssertionError(e);
                }
                else {
                    error.addSuppressed(e);
                }
            }
        }
    }
    if(error!=null){
        throw error ;
    }
}

Je suis tombé sur un cas très similaire.

Je voulais comparer sur un test qu'un objet avait les mêmes valeurs d'attribut comme un autre, mais des méthodes telles que is(), refEq(), etc ne marcherait pas pour des raisons comme mon objet ayant une valeur nulle dans son idattribut.

C'était donc la solution que j'ai trouvée (enfin, un collègue a trouvé):

import static org.apache.commons.lang.builder.CompareToBuilder.reflectionCompare;

assertThat(reflectionCompare(expectedObject, actualObject, new String[]{"fields","to","be","excluded"}), is(0));

Si la valeur obtenue à partir de reflectionCompareest 0, cela signifie qu'ils sont égaux. Si c'est -1 ou 1, ils diffèrent sur certains attributs.

Dans le cas courant avec AssertJ, vous pouvez créer une stratégie de comparaison personnalisée:

assertThat(frodo).usingComparator(raceComparator).isEqualTo(sam)
assertThat(fellowshipOfTheRing).usingElementComparator(raceComparator).contains(sauron);

Utilisation d'une stratégie de comparaison personnalisée dans les assertions

Exemples AssertJ

J'ai eu exactement la même énigme lors du test unitaire d'une application Android, et la solution la plus simple que j'ai trouvée était simplement d'utiliser Gson pour convertir mes objets de valeur réelle et attendue jsonet les comparer sous forme de chaînes.

String actual = new Gson().toJson( myObj.getValues() );
String expected = new Gson().toJson( new MyValues(true,1) );

assertEquals(expected, actual);

L'avantage de cela par rapport à la comparaison manuelle champ par champ est que vous comparez tous vos champs, donc même si vous ajoutez plus tard un nouveau champ à votre classe, il sera automatiquement testé, par rapport à si vous utilisiez un tas de assertEquals()sur tous les champs, qui devraient ensuite être mis à jour si vous ajoutez plus de champs à votre classe.

jUnit affiche également les chaînes pour vous afin que vous puissiez voir directement où elles diffèrent. Vous ne savez pas à quel point la commande sur le terrain Gsonest fiable , cela pourrait être un problème potentiel.

J'ai essayé toutes les réponses et rien n'a vraiment fonctionné pour moi.

J'ai donc créé ma propre méthode qui compare des objets java simples sans aller plus loin dans les structures imbriquées ...

La méthode retourne null si tous les champs correspondent ou une chaîne contenant des détails d'incompatibilité.

Seules les propriétés qui ont une méthode getter sont comparées.

Comment utiliser

        assertNull(TestUtils.diff(obj1,obj2,ignore_field1, ignore_field2));

Exemple de sortie en cas d'incohérence

La sortie affiche les noms de propriétés et les valeurs respectives des objets comparés

alert_id(1:2), city(Moscow:London)

Code (Java 8 et supérieur):

 public static String diff(Object x1, Object x2, String ... ignored) throws Exception{
        final StringBuilder response = new StringBuilder();
        for (Method m:Arrays.stream(x1.getClass().getMethods()).filter(m->m.getName().startsWith("get")
        && m.getParameterCount()==0).collect(toList())){

            final String field = m.getName().substring(3).toLowerCase();
            if (Arrays.stream(ignored).map(x->x.toLowerCase()).noneMatch(ignoredField->ignoredField.equals(field))){
                Object v1 = m.invoke(x1);
                Object v2 = m.invoke(x2);
                if ( (v1!=null && !v1.equals(v2)) || (v2!=null && !v2.equals(v1))){
                    response.append(field).append("(").append(v1).append(":").append(v2).append(")").append(", ");
                }
            }
        }
        return response.length()==0?null:response.substring(0,response.length()-2);
    }

Comme alternative pour junit-only, vous pouvez définir les champs sur null avant l'assertion égale:

    actual.setCreatedDate(null); // excludes date assertion
    expected.setCreatedDate(null);

    assertEquals(expected, actual);

Pouvez-vous mettre le code de comparaison que vous avez publié dans une méthode utilitaire statique?

public static String findDifference(Type obj1, Type obj2) {
    String difference = "";
    if (obj1.getFieldA() == null && obj2.getFieldA() != null
            || !obj1.getFieldA().equals(obj2.getFieldA())) {
        difference += "Difference at field A:" + "obj1 - "
                + obj1.getFieldA() + ", obj2 - " + obj2.getFieldA();
    }
    if (obj1.getFieldB() == null && obj2.getFieldB() != null
            || !obj1.getFieldB().equals(obj2.getFieldB())) {
        difference += "Difference at field B:" + "obj1 - "
                + obj1.getFieldB() + ", obj2 - " + obj2.getFieldB();
        // (...)
    }
    return difference;
}

Ensuite, vous pouvez utiliser cette méthode dans JUnit comme ceci:

assertEquals ("Les objets ne sont pas égaux", "", findDifferences (obj1, obj));

ce qui n'est pas maladroit et vous donne des informations complètes sur les différences, si elles existent (pas exactement sous la forme normale d'assertEqual mais vous obtenez toutes les informations, donc ça devrait être bon).

Cela n'aidera pas l'OP, mais cela pourrait aider tous les développeurs C # qui se retrouvent ici ...

Comme Enrique l'a publié , vous devriez remplacer la méthode d'égalité.

Existe-t-il une meilleure pratique pour obtenir ce que je veux de l'objet, sans sous-classer ni surcharger les égaux (ugh)?

Ma suggestion est de ne pas utiliser de sous-classe. Utilisez une classe partielle.

Définitions partielles de classe (MSDN)

Donc, votre classe ressemblerait à ...

public partial class TheClass
{
    public override bool Equals(Object obj)
    {
        // your implementation here
    }
}

Pour Java, je serais d'accord avec la suggestion d'utiliser la réflexion. N'oubliez pas que vous devez éviter d'utiliser la réflexion autant que possible. Il est lent, difficile à déboguer et encore plus difficile à maintenir dans le futur car les IDE pourraient casser votre code en renommant un champ ou quelque chose comme ça. Faites attention!

De vos commentaires à d'autres réponses, je ne comprends pas ce que vous voulez.

Juste pour le plaisir de la discussion, disons que la classe a remplacé la méthode equals.

Ainsi, votre UT ressemblera à quelque chose comme:

SomeType expected = // bla
SomeType actual = // bli

Assert.assertEquals(expected, actual). 

Et vous avez terminé. De plus, vous ne pouvez pas obtenir une "image d 'égalité complète" si l' assertion échoue.

D'après ce que je comprends, vous dites que même si le type remplaçait égal à égal, cela ne vous intéresserait pas, car vous voulez obtenir une «image d'égalité complète». Il est donc inutile non plus d'étendre et de remplacer les égaux.

Vous avez donc des options: soit comparer propriété par propriété, en utilisant la réflexion ou des vérifications codées en dur, je suggérerais ce dernier. Ou: comparez les représentations lisibles par l'homme de ces objets.

Par exemple, vous pouvez créer une classe d'assistance qui sérialise le type que vous souhaitez comparer à un document XML et ensuite comparer le XML résultant! dans ce cas, vous pouvez voir visuellement ce qui est exactement égal et ce qui ne l'est pas.

Cette approche vous donnera l'opportunité d'avoir une vue d'ensemble mais elle est aussi relativement lourde (et un peu sujette aux erreurs au début).

Vous pouvez remplacer la méthode equals de la classe comme:

@Override
public int hashCode() {
    int hash = 0;
    hash += (app != null ? app.hashCode() : 0);
    return hash;
}

@Override
public boolean equals(Object object) {
    HubRule other = (HubRule) object;

    if (this.app.equals(other.app)) {
        boolean operatorHubList = false;

        if (other.operator != null ? this.operator != null ? this.operator
                .equals(other.operator) : false : true) {
            operatorHubList = true;
        }

        if (operatorHubList) {
            return true;
        } else {
            return false;
        }
    } else {
        return false;
    }
}

Eh bien, si vous voulez comparer deux objets d'une classe, vous devez implémenter d'une manière ou d'une autre les égaux et la méthode de code de hachage