Cómo comprobar si la colección contiene elementos en un determinado orden con Hamcrest

Cómo comprobar la utilización de Hamcrest si la colección contiene artículos determinados en el orden dado? Traté de hasItems pero simplemente ignora la orden.

List<String> list = Arrays.asList("foo", "bar", "boo");

assertThat(list, hasItems("foo", "boo"));

//I want this to fail, because the order is different than in "list"
assertThat(list, hasItems("boo", "foo")); 
  • Considere la posibilidad de cambiar el aceptado respuesta. Normalmente, cuando realizamos la búsqueda de un comparador, estamos a favor de los que ya están en la API, dejando personalizado dispositivos de correspondencia a los inevitables casos.
  • El aceptó respuesta no responde a la pregunta. La pregunta se pide un comparador que simplemente se comprueba que los elementos están contenidos en la lista en el orden dado, pero no que TODOS estos son los elementos reales. El Matchers.contains método comprueba que la lista contiene exactamente el esperado.
  • En esta pregunta los otros dispositivos de comparación se explican stackoverflow.com/a/44030511/1195507

6 Kommentare

  1. 54

    Puede utilizar contains comparador lugar, pero probablemente necesitará usar la última versión de Hamcrest. Que método de cheques a la orden.

    assertThat(list, contains("foo", "boo"));

    También puede intentar usar containsInAnyOrder si no importa el orden para usted.

    Que es el código para contains comparador:

      public static <E> Matcher<Iterable<? extends E>> contains(List<Matcher<? super E>> itemMatchers)
      {
        return IsIterableContainingInOrder.contains(itemMatchers);
      }
    • +1 Sí, la actualización a la última JUnit y Hamcrest, aunque contains ha estado alrededor por un tiempo.
    • ¿Qué versión de Hamcrest? Para mí, 1.3 está causando: java.lang.AssertionError: Espera: iterable que contiene [«foo», «boo»] pero: No coincide: «bar»
    • la solución no funciona para un determinado subconjunto de la lista de resultados, debido a que contiene-Comparador no con cualquier elemento adicional que no se da en la espera elemento de la matriz.
  2. 7

    Para comprobar tha colección contiene elementos en espera (dado) de la orden puede utilizar Hamcrest del containsInRelativeOrder método.

    De javadoc:

    Crea un comparador para Iterable que los partidos cuando un solo pase
    el examinado Iterable de los rendimientos de una serie de elementos, que contiene los elementos
    lógicamente igual a la del elemento correspondiente en los elementos especificados, en
    el mismo orden relativo Por ejemplo: assertThat(Matrices.asList(«un»,
    «b», «c», «d», «e»), containsInRelativeOrder(«b», «d»)).

    Real para Java Hamcrest 2.0.0.0.

    Espero que esto ayude.

  3. 2

    Que usted necesita para implementar una costumbre Comparador, algo como esto

    class ListMatcher extends BaseMatcher {
        String[] items;
    
        ListMatcher(String... items) {
            this.items = items;
        }
    
        @Override
        public boolean matches(Object item) {
            List list = (List) (item);
            int l = -1;
            for (String s : items) {
                int i = list.indexOf(s);
                if (i == -1 || i < l) {
                    return false;
                }
                l = i;
            }
            return true;
        }
    
        @Override
        public void describeTo(Description description) {
            //not implemented
        }
    }
    
    @Test
    public void test1() {
        List<String> list = Arrays.asList("foo", "bar", "boo");
        Assert.assertThat(list, new ListMatcher("foo", "boo"));
        Assert.assertThat(list, new ListMatcher("boo", "foo"));
    }
    • OMG. Este comparador es feo y buggy. Se debe extender TypeSafeMatcher. O menos, comprobar ejemplo de elemento en los partidos() métodos – en la actualidad se puede obtener ClassCastExecption. Y debe ser un tipo genérico, ya que en la actualidad funciona sólo para las secuencias. Y debe controlar null. Y los partidos() O(n^2) complejidad. Y …
  4. 1

    Aceptado la respuesta no está funcionando para mí. El error persiste, diciendo

    Expected: iterable containing ["foo", "boo"] but: Not matched: "bar"

    Así que escribí mi propia IsIterableContainingInRelativeOrder, y presentado como un parche.

    • En realidad, usted debe cambiar su afirmación de buscar también «barra». Es la unidad de la prueba, seguramente usted debe saber que el resultado de su SUT incluye el elemento de la «barra» de estar en la lista?
  5. 1

    He encontrado una solución en http://www.baeldung.com/hamcrest-collections-arrays

    Busque la sección que tiene un ejemplo con un orden estricto.

    List<String> collection = Lists.newArrayList("ab", "cd", "ef");
    assertThat(collection, contains("ab", "cd", "ef"));

    Básicamente, usted necesita usar la contiene Comparador (org.hamcrest.Matchers.contains)

    • Bienvenido a Desbordamiento de Pila. Aquí, es mejor incluir a importantes partes de código en su respuesta.
  6. 0

    Puede combinar is y equalTo de los dispositivos de comparación de la biblioteca. La instrucción assert se ve más, pero el mensaje de error es mejor. Desde contains es fallar en primer lugar en el que se rompe cuando se encuentra el primer desajuste y no encontrar fallas más abajo en la lista. Donde como is y equalTo imprimirá la lista completa de los que ves todos los desajustes.

    Ejemplo de uso de contains

    List<String> list = Arrays.asList("foo", "bar", "boo");
    assertThat(list, contains("foo", "boo", "bar"));

    Da el siguiente mensaje de error:

    Expected: iterable containing ["foo", "boo", "bar"]
     but: item 1: was "bar"

    Ejemplo de uso de is and equalTo

    List<String> list = Arrays.asList("foo", "bar", "boo");
    assertThat(list, is(equalTo(Lists.newArrayList("foo", "boo", "bar"))));

    Da el siguiente mensaje de error:

    Expected: is <[foo, boo, bar]>
         but: was <[foo, bar, boo]>

    El segundo método no indica el índice en el que el desajuste es, pero para mí, este es todavía mejor que usted puede corregir la prueba mirando el mensaje de error de sólo una vez. Mientras que en el método uno, primero debes solucionar índice 1, ejecute la prueba, detectar la falta de coincidencia en el índice 2 y hacer la corrección final.

Kommentieren Sie den Artikel

Bitte geben Sie Ihren Kommentar ein!
Bitte geben Sie hier Ihren Namen ein

Pruebas en línea