Перейти к основному содержимому

Hamcrest Common Core Matchers

· 4 мин. чтения

1. Обзор​

В этом кратком руководстве мы рассмотрим класс CoreMatchers из популярной платформы Hamcrest для написания простых и более выразительных тестовых случаев.

Идея состоит в том, чтобы утверждения утверждения читались как естественный язык.

2. Установка подколенного гребня​

Мы можем использовать Hamcrest с Maven, добавив следующую зависимость в наш файл pom.xml :

<dependency>
    <groupId>org.hamcrest</groupId>
    <artifactId>java-hamcrest</artifactId>
    <version>2.0.0.0</version>
    <scope>test</scope>
</dependency>

Последнюю версию этой библиотеки всегда можно найти здесь .

3. Общие основные совпадения​

3.1. есть (T) и есть (Matcher<T>)​

is ( T) принимает объект в качестве параметра для проверки равенства, а is(Matcher<T>) принимает другой сопоставитель, что позволяет оператору равенства быть более выразительным.

Мы можем использовать это почти со всеми методами :

String testString = "hamcrest core";

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

3.2. равно (T)​

Метод equalTo(T) принимает объект в качестве параметра и проверяет его равенство с другим объектом. Это часто используется с is(Matcher<T>) :

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

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

Мы также можем использовать equalToObject (операнд объекта) — который проверяет равенство и не требует, чтобы два объекта имели один и тот же статический тип:

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

3.3. не(T) и не(Matcher<T>)​

Not (T) и not(Matcher<T>) используются для проверки неравноправия заданных объектов. Первый принимает объект в качестве аргумента, а второй — другой сопоставитель:

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() и nullValue(Class<T>)​

Функция nullValue() проверяет нулевое значение для исследуемого объекта. nullValue (Class<T>) проверяет допустимость значения NULL для данного объекта типа класса:

Integer nullObject = null;

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

3.5. notNullValue() и notNullValue(Class<T>)​

Это ярлык для часто используемого is(not(nullValue)) . Они проверяют ненулевое равенство объекта или типа класса:

Integer testNumber = 123;

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

3.6. instanceOf(Класс<?>)​

instanceOf ( Class<?>) совпадает, если проверяемый объект является экземпляром указанного типа класса .

Для проверки этот метод внутренне вызывает isIntance(Object) класса Class :

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

3.7. isA (тип Class<T>)​

Тип isA(Class<T>) является ярлыком для вышеуказанного instanceOf(Class<?>) . Он принимает аргумент того же типа, что и instanceOf(Class<?>) :

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

3.8. тот же экземпляр ()​

Функция sameInstance() соответствует, если две ссылочные переменные указывают на один и тот же объект в куче:

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

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

3.9. любой (Класс <T>)​

Any (Class<T>) проверяет, имеет ли класс тот же тип, что и фактический объект:

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

3.10. allOf(Matcher<? расширяет T>…) и anyOf(Matcher<? расширяет T>…)​

Мы можем использовать allOf(Matcher<? extends T>…) , чтобы подтвердить, соответствует ли фактический объект всем указанным условиям:

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

AnyOf (Matcher<? extends T>…) ведет себя как allOf(Matcher<? extends T>… ) , но срабатывает, если проверяемый объект соответствует любому из указанных условий:

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

3.11. hasItem(T) и hasItem(Matcher<? расширяет T>)​

Они совпадают, если проверяемая коллекция Iterable соответствует заданному объекту или сопоставителю внутри hasItem() или hasItem(Matcher<? extends T>) .

Давайте разберемся, как это работает:

List<String> list = Lists.newArrayList("java", "spring", "foreach");

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

Точно так же мы можем утверждать против более чем одного элемента, используя hasItems(T…) и hasItems(Matcher<? extends T>…) :

List<String> list = Lists.newArrayList("java", "spring", "foreach");

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

3.12. оба (Matcher<? extends T>) и либо (Matcher<? extends T>)​

Как следует из названия, оба (Matcher<? extends T>) совпадают, когда оба указанных условия соответствуют проверяемому объекту:

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

и либо (Matcher<? extends T>) соответствует, когда любое из указанных условий соответствует проверяемому объекту:

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

4. Сравнение строк ****​

Мы можем использовать containsString(String) или containsStringIgnoringCase(String) , чтобы подтвердить, содержит ли фактическая строка тестовую строку:

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

Или startWith(String) иstartWithIgnoringCase (String) для утверждения, начинается ли фактическая строка с тестовой строки:

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

Мы также можем использовать endWith(String) или endWithIgnoringCase(String) , чтобы подтвердить, заканчивается ли фактическая строка тестовой строкой:

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

5. Вывод​

В этой статье мы обсудили различные методы класса CoreMatchers в библиотеке Hamcrest .

И, как всегда, исходный код примеров можно найти на GitHub .