Hamcrest confronta le raccolte

Sto cercando di confrontare 2 elenchi:

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

Ma idea

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)

Come dovrei scriverlo?

Se vuoi affermare che i due elenchi sono identici, non complicare le cose con Hamcrest:

assertEquals(expectedList, actual.getList());

Se intendi davvero eseguire un confronto insensibile all'ordine, puoi chiamare il containsInAnyOrdermetodo varargs e fornire direttamente i valori:

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

(Supponendo che la tua lista sia di String, piuttosto che Agent, per questo esempio.)

Se vuoi davvero chiamare lo stesso metodo con il contenuto di a List:

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

Senza questo, stai chiamando il metodo con un singolo argomento e creando un file Matcherche si aspetta di trovare una corrispondenza in Iterablecui ogni elemento è un List. Non può essere utilizzato per abbinare un file List.

Cioè, non puoi abbinare a List<Agent>con a Matcher<Iterable<List<Agent>>, che è ciò che il tuo codice sta tentando.

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

Versione più breve della risposta di @ Joe senza parametri ridondanti.

Per completare la risposta di @ Joe:

Hamcrest ti fornisce tre metodi principali per abbinare un elenco:

contains Controlla la corrispondenza di tutti gli elementi tenendo conto dell'ordine, se l'elenco ha più o meno elementi, fallirà

containsInAnyOrder Controlla la corrispondenza di tutti gli elementi e non importa l'ordine, se l'elenco contiene più o meno elementi, fallirà

hasItems Controlla solo gli oggetti specificati, non importa se l'elenco ne ha di più

hasItem Controlla solo un oggetto, non importa se l'elenco ne ha di più

Tutti possono ricevere un elenco di oggetti e utilizzare il equalsmetodo per il confronto o possono essere combinati con altri abbinamenti come @borjab menzionato:

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 ...)

Con le librerie Hamcrest esistenti (a partire dalla v.2.0.0.0) sei costretto a utilizzare il metodo Collection.toArray () sulla tua raccolta per utilizzare containsInAnyOrder Matcher. Molto più bello sarebbe aggiungerlo come metodo separato a 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());
}

In realtà ho finito per aggiungere questo metodo alla mia libreria di test personalizzata e usarlo per aumentare la leggibilità dei miei casi di test (a causa della minore verbosità).

Assicurati che Objecti messaggi nella tua lista siano equals()definiti su di essi. Poi

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

lavori.

Per l'elenco degli oggetti potresti aver bisogno di qualcosa del genere:

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")))));
}

Utilizzare containsInAnyOrder se non si desidera controllare l'ordine degli oggetti.

PS Qualsiasi aiuto per evitare l'avvertimento soppresso sarà molto apprezzato.

Per confrontare due elenchi con l'ordine conservato utilizzare,

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