Quand je regarde les exemples de la classe Assert JavaDoc

assertThat("Help! Integers don't work", 0, is(1)); // fails:
// failure message:
// Help! Integers don't work
// expected: is <1> 
// got value: <0>
assertThat("Zero is one", 0, is(not(1))) // passes

Je ne vois pas un grand avantage sur, disons que, assertEquals( 0, 1 ).

C'est bien peut-être pour les messages si les constructions deviennent plus compliquées mais voyez-vous plus d'avantages? Lisibilité?

Il n'y a pas de gros avantage pour les cas où un assertFooexiste qui correspond exactement à votre intention. Dans ces cas, ils se comportent presque de la même manière.

Mais lorsque vous arrivez à des contrôles un peu plus complexes, l'avantage devient plus visible:

assertTrue(foo.contains("someValue") && foo.contains("anotherValue"));

contre.

assertThat(foo, hasItems("someValue", "anotherValue"));

On peut discuter de celui qui est le plus facile à lire, mais une fois que l'assertion échoue, vous obtiendrez un bon message d'erreur assertThat, mais seulement une quantité très minimale d'informations assertTrue.

assertThatvous dira quelle était l'affirmation et ce que vous avez obtenu à la place. assertTruevous dira seulement que vous êtes arrivé falselà où vous vous attendiez true.

Les notes de publication de JUnit pour la version 4.4 (où il a été introduit) présentent quatre avantages:

• Plus lisible et typable: cette syntaxe permet de penser en termes de sujet, verbe, objet (assert "x is 3") plutôt que assertEquals , qui utilise verbe, objet, sujet (assert "equals 3 x")
• Combinaisons: toute instruction de correspondance peut être annulée ( pas (s) ), combinée ( soit (s) .ou (t) ), mappée à une collection ( chacune (s) ), ou utilisée dans des combinaisons personnalisées (après cinq secondes (s) )
• Messages d'échec lisibles. (...)
• Matchers personnalisés. En mettant en œuvre la matcher l' interface vous - même, vous pouvez obtenir tous les avantages ci - dessus pour vos propres affirmations personnalisées.

Argumentation plus détaillée du type qui a créé la nouvelle syntaxe: ici .

Fondamentalement, pour augmenter la lisibilité du code .

Outre hamcrest, vous pouvez également utiliser les assertions fest . Ils présentent quelques avantages par rapport à hamcrest tels que:

• ils sont plus lisibles
  ( assertEquals(123, actual); // reads "assert equals 123 is actual"vs
  assertThat(actual).isEqualTo(123); // reads "assert that actual is equal to 123")
• ils sont découvrables ( vous pouvez faire fonctionner l'autocomplétion avec n'importe quel IDE ).

Quelques exemples

import static org.fest.assertions.api.Assertions.*;

// common assertions
assertThat(yoda).isInstanceOf(Jedi.class);
assertThat(frodo.getName()).isEqualTo("Frodo");
assertThat(frodo).isNotEqualTo(sauron);
assertThat(frodo).isIn(fellowshipOfTheRing);
assertThat(sauron).isNotIn(fellowshipOfTheRing);

// String specific assertions
assertThat(frodo.getName()).startsWith("Fro").endsWith("do")
                           .isEqualToIgnoringCase("frodo");

// collection specific assertions
assertThat(fellowshipOfTheRing).hasSize(9)
                               .contains(frodo, sam)
                               .excludes(sauron);


// map specific assertions (One ring and elves ring bearers initialized before)
assertThat(ringBearers).hasSize(4)
                       .includes(entry(Ring.oneRing, frodo), entry(Ring.nenya, galadriel))
                       .excludes(entry(Ring.oneRing, aragorn));

Mise à jour du 17 octobre 2016

Fest n'est plus actif, utilisez AssertJ à la place.

Une justification très basique est qu'il est difficile de gâcher la nouvelle syntaxe.

Supposons qu'une valeur particulière, foo, devrait être 1 après un test.

assertEqual(1, foo);

--OU--

assertThat(foo, is(1));

Avec la première approche, il est très facile d'oublier l'ordre correct et de le saisir à l'envers. Alors plutôt que de dire que le test a échoué parce qu'il attendait 1 et obtenait 2, le message est inversé. Pas de problème lorsque le test réussit, mais peut prêter à confusion lorsque le test échoue.

Avec la deuxième version, il est presque impossible de faire cette erreur.

Exemple:

assertThat(5 , allOf(greaterThan(1),lessThan(3)));
//  java.lang.AssertionError:
//  Expected: (a value greater than <1> and a value less than <3>)
//       got: <5>
assertTrue("Number not between 1 and 3!", 1 < 5 && 5 < 3);
//  java.lang.AssertionError: Number not between 1 and 3!

1. vous pouvez rendre vos tests plus particuliers
2. vous obtenez une exception plus détaillée si les tests échouent
3. plus facile à lire le test

btw: vous pouvez aussi écrire du texte dans assertXXX ...

assertThat(frodo.getName()).isEqualTo("Frodo");

Est proche du langage naturel.

Code plus facile à lire et à analyser. Le programmeur passe plus de temps à analyser le code qu'à en écrire un nouveau. Donc, si le code est facile à analyser, le développeur devrait être plus productif.

Le code PS doit être un livre aussi bien écrit. Code auto-documenté.

il y a des avantages à affirmer que par rapport à assertEquals -
1) plus lisible
2) plus d'informations sur l'échec
3) des erreurs de temps de compilation - plutôt que des erreurs d'exécution
4) flexibilité avec l'écriture des conditions de test
5) portable - si vous utilisez hamcrest - vous pouvez utiliser jUnit ou TestNG comme cadre sous-jacent.