java - collection - junit test list




AssertEquals 2 listas ignoran el orden (5)

Aquí hay una solución que evita la complejidad cuadrática (iterando sobre las listas varias veces). Esto utiliza la clase CollectionUtils de Apache Commons para crear un Mapa de cada elemento a un recuento de frecuencia en la lista. Luego simplemente compara los dos Mapas.

Assert.assertEquals("Verify same metrics series",
    CollectionUtils.getCardinalityMap(expectedSeriesList),
    CollectionUtils.getCardinalityMap(actualSeriesList));

También descubrí CollectionUtils.isEqualCollection que dice hacer exactamente lo que se solicita aquí ...

https://commons.apache.org/proper/commons-collections/apidocs/index.html?org/apache/commons/collections4/CollectionUtils.html

Esa debería ser una pregunta realmente simple, creo. Pero de alguna manera no puedo encontrar una respuesta en Google.

Supongamos que tengo 2 listas de cadenas. Primero contiene "Cadena A" y "Cadena B" , la segunda contiene "Cadena B" y "Cadena A" (notará la diferencia en el orden). Quiero probarlos con JUnit para verificar si contienen exactamente las mismas cadenas.

¿Hay alguna afirmación que verifique la igualdad de cadenas que ignoran el orden? Para el ejemplo dado org.junit.Assert.assertEquals throws AssertionError

java.lang.AssertionError: expected:<[String A, String B]> but was:<[String B, String A]>

El trabajo consiste en ordenar listas en primer lugar y luego pasarlas a la aserción. Pero quiero que mi código sea lo más simple y limpio posible.

Uso Hamcrest 1.3 , JUnit 4.11 , Mockito 1.9.5 .


Como mencionas que usas Hamcrest, yo elegiría una de la colección Matchers

import static org.hamcrest.collection.IsIterableContainingInAnyOrder.containsInAnyOrder;
import static org.junit.Assert.assertThat;

public class CompareListTest {

    @Test
    public void compareList() {
        List<String> expected = Arrays.asList("String A", "String B");
        List<String> actual = Arrays.asList("String B", "String A");

        assertThat("List equality without order", 
            actual, containsInAnyOrder(expected.toArray()));
    }

}

Para una solución rápida, verificaría ambas formas:

assertTrue(first.containsAll(second));
assertTrue(second.containsAll(first));

Y al tratar con una situación en la que el número de los mismos elementos es diferente (por ejemplo, 1, 1, 2 y 1, 2, 2) no obtuve falsos positivos.


Puede usar List.containsAll para verificar que la primera lista contenga todos los elementos de la segunda, y viceversa.

assertTrue(first.size() == second.size() && 
                 first.containsAll(second) && second.containsAll(first));

Tenga en cuenta que la solución de Roberto Izquierdo tiene complejidad cuadrática en general. La solución en HashSets siempre tiene una complejidad lineal:

assertTrue(first.size() == second.size() &&
        new HashSet(first).equals(new HashSet(second)));




assertion