JUnit 4 comparar conjuntos

Como você afirmaria sucintamente a igualdade dos Collectionelementos, especificamente a Setna JUnit 4?

Você pode afirmar que os dois Sets são iguais um ao outro, o que invoca o Set equals()método .

public class SimpleTest {

    private Set<String> setA;
    private Set<String> setB;

    @Before
    public void setUp() {
        setA = new HashSet<String>();
        setA.add("Testing...");
        setB = new HashSet<String>();
        setB.add("Testing...");
    }

    @Test
    public void testEqualSets() {
        assertEquals( setA, setB );
    }
}

Isso @Testpassará se os dois Sets tiverem o mesmo tamanho e contiverem os mesmos elementos.

Apache commons para o resgate novamente.

assertTrue(CollectionUtils.isEqualCollection(coll1, coll2));

Funciona como um encanto. Não sei por que, mas descobri que com coleções o seguinte assertEquals(coll1, coll2)nem sempre funciona. No caso em que falhou para mim, eu tinha duas coleções apoiadas por Sets. Nem hamcrest nem junit diriam que as coleções eram iguais, embora eu tivesse certeza de que eram. Usando CollectionUtils funciona perfeitamente.

com hamcrest :

assertThat(s1, is(s2));

com afirmação simples:

assertEquals(s1, s2);

NB: t o método equals () da classe de conjunto concreto é usado

Um caso particularmente interessante é quando você compara

   java.util.Arrays$ArrayList<[[name,value,type], [name1,value1,type1]]> 

e

   java.util.Collections$UnmodifiableCollection<[[name,value,type], [name1,value1,type1]]>

Até agora, a única solução que vejo é transformar os dois em conjuntos

assertEquals(new HashSet<CustomAttribute>(customAttributes), new HashSet<CustomAttribute>(result.getCustomAttributes()));

Ou eu poderia compará-los elemento por elemento.

Como um método adicional baseado em array ... você pode considerar o uso de asserções de array não ordenadas em junitx. Embora o exemplo do Apache CollectionUtils funcione, também há uma série de extensões de asserção sólidas:

Eu acho que o

ArrayAssert.assertEquivalenceArrays(new Integer[]{1,2,3}, new Integer[]{1,3,2});

A abordagem será muito mais legível e depurável para você (todas as Coleções suportam toArray (), portanto, deve ser fácil o suficiente para usar os métodos ArrayAssert.

Claro que a desvantagem aqui é que, junitx é um arquivo jar adicional ou uma entrada maven ...

 <dependency org="junit-addons" name="junit-addons" rev="1.4"/>

Verifique este artigo . Um exemplo disso:

@Test  
public void listEquality() {  
    List<Integer> expected = new ArrayList<Integer>();  
    expected.add(5);  

    List<Integer> actual = new ArrayList<Integer>();  
    actual.add(5);  

    assertEquals(expected, actual);  
}  

Usando Hamcrest:

assertThat( set1, both(everyItem(isIn(set2))).and(containsInAnyOrder(set1)));

Isso também funciona quando os conjuntos têm diferentes tipos de dados e relata a diferença em vez de apenas falhar.

Se você deseja verificar se uma Lista ou Conjunto contém um conjunto de valores específicos (em vez de compará-lo com uma coleção já existente), muitas vezes o método toString de coleções é útil:

String[] actualResult = calltestedmethod();
assertEquals("[foo, bar]", Arrays.asList(actualResult).toString());

List otherResult = callothertestedmethod();
assertEquals("[42, mice]", otherResult.toString());

Isso é um pouco mais curto do que primeiro construir a coleção esperada e compará-la com a coleção real, e mais fácil de escrever e corrigir.

(Reconhecidamente, este não é um método particularmente limpo e não consegue distinguir um elemento "foo, bar" de dois elementos "foo" e "bar". Mas, na prática, acho que é mais importante que seja fácil e rápido escrever testes , caso contrário, muitos desenvolvedores simplesmente não o farão sem serem pressionados.)

Gosto da solução de Hans-Peter Störr ... Mas acho que não está totalmente correta. Infelizmente containsInAnyOrder, não aceita Collectionobjetos para comparar. Portanto, tem que ser um Collectionde Matchers:

assertThat(set1, containsInAnyOrder(set2.stream().map(IsEqual::equalTo).collect(toList())))

As importações são:

import static java.util.stream.Collectors.toList;
import static org.hamcrest.Matchers.containsInAnyOrder;
import static org.junit.Assert.assertThat;