Hamcrest porównuje kolekcje

Próbuję porównać 2 listy:

assertThat(actual.getList(), is(Matchers.containsInAnyOrder(expectedList)));

Ale pomysł

java: no suitable method found for assertThat(java.util.List<Agent>,org.hamcrest.Matcher<java.lang.Iterable<? extends model.Agents>>)
method org.junit.Assert.<T>assertThat(T,org.hamcrest.Matcher<T>) is not applicable
  (no instance(s) of type variable(s) T exist so that argument type org.hamcrest.Matcher<java.lang.Iterable<? extends model.Agents>> conforms to formal parameter type org.hamcrest.Matcher<T>)
method org.junit.Assert.<T>assertThat(java.lang.String,T,org.hamcrest.Matcher<T>) is not applicable
  (cannot instantiate from arguments because actual and formal argument lists differ in length)

Jak mam to napisać?

Jeśli chcesz zapewnić, że te dwie listy są identyczne, nie komplikuj rzeczy z Hamcrestem:

assertEquals(expectedList, actual.getList());

Jeśli naprawdę zamierzasz przeprowadzić porównanie niewrażliwe na kolejność, możesz wywołać containsInAnyOrdermetodę varargs i podać wartości bezpośrednio:

assertThat(actual.getList(), containsInAnyOrder("item1", "item2"));

(Zakładając, że twoja lista to String, a nieAgent w tym przykładzie ).

Jeśli naprawdę chcesz wywołać tę samą metodę z zawartością a List:

assertThat(actual.getList(), containsInAnyOrder(expectedList.toArray(new String[expectedList.size()]));

Bez tego wywołujesz metodę z pojedynczym argumentem i tworzysz element, Matcherktóry oczekuje dopasowania elementu Iterablegdzie każdy element jest List. Nie można tego użyć do dopasowania List.

Oznacza to, że nie możesz dopasować a List<Agent>z a Matcher<Iterable<List<Agent>>, co jest tym, co próbuje twój kod.

List<Long> actual = Arrays.asList(1L, 2L);
List<Long> expected = Arrays.asList(2L, 1L);
assertThat(actual, containsInAnyOrder(expected.toArray()));

Krótsza wersja odpowiedzi @ Joe bez zbędnych parametrów.

Aby uzupełnić odpowiedź @ Joe:

Hamcrest zapewnia trzy główne metody dopasowania listy:

contains Sprawdza dopasowanie wszystkich elementów biorąc pod uwagę kolejność, jeśli lista zawiera mniej lub więcej elementów, zakończy się niepowodzeniem

containsInAnyOrder Sprawdza dopasowanie wszystkich elementów i nie ma znaczenia kolejność, jeśli lista zawiera mniej lub więcej elementów, zakończy się niepowodzeniem

hasItems Sprawdza tylko określone obiekty, nie ma znaczenia, czy lista ma ich więcej

hasItem Sprawdza tylko jeden obiekt, nie ma znaczenia, czy lista ma więcej

Wszystkie z nich mogą otrzymać listę obiektów i użyć equalsmetody do porównania lub mogą być mieszane z innymi dopasowaniami, takimi jak wspomniany @borjab:

assertThat(myList , contains(allOf(hasProperty("id", is(7L)), 
                                   hasProperty("name", is("testName1")),
                                   hasProperty("description", is("testDesc1"))),
                             allOf(hasProperty("id", is(11L)), 
                                   hasProperty("name", is("testName2")),
                                   hasProperty("description", is("testDesc2")))));

http://hamcrest.org/JavaHamcrest/javadoc/1.3/org/hamcrest/Matchers.html#contains (E ...) http://hamcrest.org/JavaHamcrest/javadoc/1.3/org/hamcrest/Matchers.html #containsInAnyOrder (java.util.Collection) http://hamcrest.org/JavaHamcrest/javadoc/1.3/org/hamcrest/Matchers.html#hasItems (T ...)

Z istniejącymi bibliotekami Hamcrest (od wersji 2.0.0.0) jesteś zmuszony użyć metody Collection.toArray () na swojej kolekcji, aby użyć dopasowującego includeInAnyOrder. O wiele przyjemniej byłoby dodać to jako oddzielną metodę do org.hamcrest.Matchers:

public static <T> org.hamcrest.Matcher<java.lang.Iterable<? extends T>> containsInAnyOrder(Collection<T> items) {
    return org.hamcrest.collection.IsIterableContainingInAnyOrder.<T>containsInAnyOrder((T[]) items.toArray());
}

W rzeczywistości dodałem tę metodę do mojej własnej biblioteki testów i użyłem jej do zwiększenia czytelności moich przypadków testowych (ze względu na mniejszą szczegółowość).

Upewnij się, że zdefiniowano na nich Objects na liście equals(). Następnie

    assertThat(generatedList,is(equalTo(expectedList)));

Pracuje.

Aby uzyskać listę obiektów, możesz potrzebować czegoś takiego:

import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.contains;
import static org.hamcrest.Matchers.allOf;
import static org.hamcrest.beans.HasPropertyWithValue.hasProperty;
import static org.hamcrest.Matchers.is;

@Test
@SuppressWarnings("unchecked")
public void test_returnsList(){

    arrange();
  
    List<MyBean> myList = act();
    
    assertThat(myList , contains(allOf(hasProperty("id",          is(7L)), 
                                       hasProperty("name",        is("testName1")),
                                       hasProperty("description", is("testDesc1"))),
                                 allOf(hasProperty("id",          is(11L)), 
                                       hasProperty("name",        is("testName2")),
                                       hasProperty("description", is("testDesc2")))));
}

Użyj opcji containsInAnyOrder, jeśli nie chcesz sprawdzać kolejności obiektów.

PS Każda pomoc w uniknięciu zniesionego ostrzeżenia będzie naprawdę mile widziana.

Aby porównać dwie listy z zachowaną kolejnością użycia,

assertThat(actualList, contains("item1","item2"));