java - junit test collection

AssertEquals 2 listas ignoran el orden

Question

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 .

Answer 1

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

Answer 2

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

}

Answer 3

Estoy llegando tarde a la fiesta, pero esta es mi solución solo con Junit. Cualquier pensamiento es bienvenido

List<String> actual = new ArrayList<>();
actual.add("A");
actual.add("A");
actual.add("B");

List<String> expected = new ArrayList<>();
actual.add("A");
actual.add("B");
actual.add("B");

//Step 1: assert for size
assertEquals(actual.size(), expected.size());

//Step 2: Iterate
for(String e: expected){
    assertTrue(actual.contains(e));
    actual.remove(e);
}

Answer 4

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.

Answer 5

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

Answer 6

Puedes usar ListAssert que viene en junt-addons jar.

ListAssert.assertEquals(yourList, Arrays.asList(3, 4, 5));

Answer 7

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