TOC

Hamcrest Common Core Matchers

Hamcrest Common Core Matchers

1. Vue d'ensemble

Dans ce rapide tutoriel, nous allons explorer la classeCoreMatchers  du frameworkHamcrest populaire pour écrire des cas de test simples et plus expressifs.

L’idée est de faire en sorte que les déclarations d’assertion soient lues comme un langage naturel.

2. Configuration de Hamcrest

Nous pouvons utiliser Hamcrest avec Maven en ajoutant la dépendance suivante à notre fichierpom.xml: 


    org.hamcrest
    java-hamcrest
    2.0.0.0
    test

La dernière version de cette bibliothèque peut toujours être trouvéehere.

3. Correspondants de base communs

3.1. is(T) etis(Matcher<T>)

Leis(T) prend un objet comme paramètre pour vérifier l'égalité etis(Matcher<T>) prend un autre matcher permettant à la déclaration d'égalité d'être plus expressive.

We can use this with almost all of the methods: 

String testString = "hamcrest core";

assertThat(testString, is("hamcrest core"));
assertThat(testString, is(equalTo("hamcrest core")));

3.2. equalTo(T)

LeequalTo(T) prend un objet comme paramètre et vérifie son égalité avec un autre objet. This is frequently used with is(Matcher<T>): 

String actualString = "equalTo match";
List actualList = Lists.newArrayList("equalTo", "match");

assertThat(actualString, is(equalTo("equalTo match")));
assertThat(actualList, is(equalTo(Lists.newArrayList("equalTo", "match"))));

Nous pouvons également utiliserequalToObject(Object operand) – w qui vérifie l’égalité et n’impose pas que deux objets soient du même type statique: 

Object original = 100;
assertThat(original, equalToObject(100));

3.3. not(T)ablenot(Matcher<T>)

Lesnot(T) etnot(Matcher<T>) sont utilisés pour vérifier la non-égalité d'objets donnés. La première prend un objet comme argument et la seconde prend un autre matcher: 

String testString = "troy kingdom";

assertThat(testString, not("german kingdom"));
assertThat(testString, is(not(equalTo("german kingdom"))));
assertThat(testString, is(not(instanceOf(Integer.class))));

3.4. nullValue() etnullValue(Class<T>)

Le schémanullValue() pour la valeurnull  par rapport à l'objet examiné. Le schémanullValue(Class<T>) vérifie la nullité d'un objet de type de classe donné: 

Integer nullObject = null;

assertThat(nullObject, is(nullValue()));
assertThat(nullObject, is(nullValue(Integer.class)));

3.5. notNullValue() etnotNullValue(Class<T>)

These are a shortcut to frequently used is(not(nullValue)). Ces vérifications pour l'égalité non nulle d'un objet ou avec le type de classe: 

Integer testNumber = 123;

assertThat(testNumber, is(notNullValue()));
assertThat(testNumber, is(notNullValue(Integer.class)));

3.6. instanceOf(Class<?>)

LeinstanceOf(Class<?>) correspond si l'objet examiné est une instance du stypeClass pécifié.

To verify, this method internally calls theisIntance(Object) of Class classe: 

assertThat("instanceOf example", is(instanceOf(String.class)));

3.7. isA(Class<T> type)

LeisA(Class<T> type) est un raccourci vers lesinstanceOf(Class<?>) ci-dessus. It takes the exact same type of argument as an instanceOf(Class<?>): 

assertThat("Drogon is biggest dragon", isA(String.class));

3.8. sameInstance()

LesameInstance() correspond si deux variables de référence pointent vers le même objet dans un tas: 

String string1 = "Viseron";
String string2 = string1;

assertThat(string1, is(sameInstance(string2)));

3.9. any(Class<T>)

Le schémaany(Class<T>)vérifie si la classe est du même type que l'objet réel: 

assertThat("test string", is(any(String.class)));
assertThat("test string", is(any(Object.class)));

3.10. allOf(Matcher<? extends T>…) and anyOf(Matcher<? extends T>…)

Nous pouvons utiliserallOf(Matcher<? extends T>…) pour affirmer si l'objet réel correspond à toutes les conditions spécifiées: 

String testString = "Achilles is powerful";
assertThat(testString, allOf(startsWith("Achi"), endsWith("ul"), containsString("Achilles")));

LeanyOf(Matcher<? extends T>…) se comporte commeallOf(Matcher<? extends T>… ) mais correspond si l'objet examiné correspond à l'une des conditions spécifiées: 

String testString = "Hector killed Achilles";
assertThat(testString, anyOf(startsWith("Hec"), containsString("example")));

3.11. hasItem(T) ethasItem(Matcher<? extends T>)

Celles-ci correspondent si le scollectionIterable examiné correspond à un objet ou un matcher donné à l'intérieur dehasItem() ouhasItem(Matcher<? extends T>).

Voyons comment cela fonctionne: 

List list = Lists.newArrayList("java", "spring", "example");

assertThat(list, hasItem("java"));
assertThat(list, hasItem(isA(String.class)));

Similarly, we can also assert against more than one items using hasItems(T…)and hasItems(Matcher<? extends T>…): 

List list = Lists.newArrayList("java", "spring", "example");

assertThat(list, hasItems("java", "example"));
assertThat(list, hasItems(isA(String.class), endsWith("ing")));

3.12. both(Matcher<? extends T>) and either(Matcher<? extends T>)

Comme son nom l'indique, leboth(Matcher<? extends T>) e rapproche lorsque les deux conditions spécifiées correspondent à l'objet examiné: 

String testString = "daenerys targaryen";
assertThat(testString, both(startsWith("daene")).and(containsString("yen")));

eteither(Matcher<? extends T>)correspond lorsque l'une des conditions spécifiées correspond à l'objet examiné: 

String testString = "daenerys targaryen";
assertThat(testString, either(startsWith("tar")).or(containsString("targaryen")));

4. Chaîne Comparaison

Nous pouvons utilisercontainsString(String) oucontainsStringIgnoringCase(String) t pour affirmer si la chaîne réelle contient une chaîne de test: 

String testString = "Rhaegar Targaryen";
assertThat(testString, containsString("aegar"));
assertThat(testString, containsStringIgnoringCase("AEGAR"));

OustartsWith(String) etstartsWithIgnoringCase(String) to assert si la chaîne réelle commence par la chaîne de test: 

assertThat(testString, startsWith("Rhae"));
assertThat(testString, startsWithIgnoringCase("rhae"));

Nous pouvons également utiliserendsWith(String) orendsWithIgnoringCase(String) pour affirmer si la chaîne réelle se termine par une chaîne de test: 

assertThat(testString, endsWith("aryen"));
assertThat(testString, endsWithIgnoringCase("ARYEN"));

5. Conclusion

Dans cet article, nous avons discuté des différentes méthodes deCoreMatchers class dans la slibraryHamcrest .

Et, comme toujours, le code source des exemples peut être trouvéover on GitHub.

Related