Jak Sprawdzić, że dwie listy zawierają te same elementy w tej samej kolejności?

Dlaczego po prostu nie użyć List#equals?

assertEquals(argumentComponents, imapPathComponents);

Umowa o List#equals:

Dwie listy są zdefiniowane jako równe, jeśli zawierają te same elementy w tej samej kolejności.

Metoda equals () na twojej liście powinna być porównywana elementwise, więc

assertEquals(argumentComponents, returnedComponents);

org.junit.Assert.assertEquals() i wykonaj swoją pracę.

Aby uniknąć kolejnych pytań: jeśli chcesz zignorować kolejność ustaw wszystkie elementy, a następnie porównaj: Assert.assertEquals(new HashSet<String>(one), new HashSet<String>(two))

Jeśli jednak chcesz po prostu zignorować duplikaty, ale zachować kolejność zawiń listę za pomocą LinkedHashSet.

Dla doskonałej czytelności kodu, Fest Assertions ma dobre wsparcie dla asserting list

Więc w tym przypadku coś w stylu:

Assertions.assertThat(returnedComponents).containsExactly("One", "Two", "Three");

Lub dodać oczekiwaną listę do tablicy, ale wolę powyższe podejście, ponieważ jest bardziej przejrzyste.

Assertions.assertThat(returnedComponents).containsExactly(argumentComponents.toArray());

AssertTrue () / assertFalse (): aby używać tylko do assert boolean result returned

AssertTrue(Iterables.elementsEqual(argumentprzypisy, returnedComponents));

Chcesz użyć Assert.assertTrue() lub Assert.assertFalse(), ponieważ testowana metoda zwraca wartość boolean.
Ponieważ metoda zwraca konkretną rzecz, taką jak List, która powinna zawierać pewne oczekiwane elementy, twierdząc za pomocą assertTrue() w ten sposób: Assert.assertTrue(myActualList.containsAll(myExpectedList) to anty wzór.
Ułatwia twierdzenie nie jest to jednak możliwe, ponieważ test nie powiódł się, więc trudno jest go debugować, ponieważ test runner powie Ci tylko coś w stylu:

Oczekiwane true ale rzeczywiste to false

Assert.assertEquals(Object, Object) W JUnit4 lub Assertions.assertIterableEquals(Iterable, Iterable) w JUnit 5: aby używać tylko jako equals() i {[16] } są przesłonięte dla klas (i głęboko) porównywanych obiektów

Ma to znaczenie, ponieważ test równości w twierdzeniu opiera się na equals(), a Komunikat o niepowodzeniu testu opiera się na toString() z porównywanych obiektów.
Ponieważ String zastępuje zarówno equals(), jak i toString(), jest całkowicie poprawne twierdzenie List<String> z assertEquals(Object,Object). A co do tej sprawy : musisz nadpisać equals() w klasie, ponieważ ma to sens w kategoriach równości obiektów, nie tylko po to, aby ułatwić twierdzenia w teście z JUnit.
Aby ułatwić twierdzenia, masz inne sposoby (które możesz zobaczyć w kolejnych punktach odpowiedzi).

Czy guawa jest sposobem na wykonywanie / budowanie twierdzeń testów jednostkowych ?

Jest Google Guava Iterables.elementsEqual() najlepszy sposób, pod warunkiem, że mam bibliotekę w mojej ścieżce budowania, aby porównać te dwie listy?

Jaki jest kanoniczny sposób porównywania list do testów jednostkowych?

Jako dobra praktyka faworyzuję biblioteki assertion/matcher.

Nie mogę zachęcaj JUnit do wykonywania określonych twierdzeń, ponieważ zapewnia to naprawdę zbyt mało i ograniczone funkcje : wykonuje tylko twierdzenie z głęboką równością.
Czasami chcesz zezwolić na dowolną kolejność w elementach, czasami chcesz zezwolić, aby dowolne elementy oczekiwanego dopasowania do rzeczywistego, i tak dla...

Więc użycie biblioteki assertion/matcher testu jednostkowego, takiej jak Hamcrest lub AssertJ, jest właściwym sposobem.
Rzeczywista odpowiedź zapewnia Hamcrest rozwiązanie. Oto AssertJ rozwiązanie.

org.assertj.core.api.ListAssert.containsExactly() jest to, czego potrzebujesz : sprawdza, czy rzeczywista grupa zawiera dokładnie podane wartości i nic więcej, w kolejności jak podano: {]}

Sprawdza, czy rzeczywista grupa zawiera dokładnie podane wartości i nic więcej, w porządku.

Twój test może wyglądać następująco:

import org.assertj.core.api.Assertions;
import org.junit.jupiter.api.Test;

@Test
void ofComponent_AssertJ() throws Exception {
   MyObject myObject = MyObject.ofComponents("One", "Two", "Three");
   Assertions.assertThat(myObject.getComponents())
             .containsExactly("One", "Two", "Three");
}

Dobrym punktem jest to, że deklarowanie List zgodnie z oczekiwaniami jest niepotrzebne : sprawia, że twierdzenie jest prostsze, a kod bardziej czytelny:

Assertions.assertThat(myObject.getComponents())
         .containsExactly("One", "Two", "Three");

A jeśli test się nie powiedzie:

// Fail : Three was not expected 
Assertions.assertThat(myObject.getComponents())
          .containsExactly("One", "Two");

Otrzymujesz bardzo jasny komunikat, taki jak:

Java.lang.AssertionError:

Zawierać dokładnie (i w tej samej kolejności):

Ale niektórych elementów nie oczekiwano:

Assertion / matcher biblioteki są koniecznością, ponieważ te będą naprawdę dalej

Załóżmy, że MyObject nie przechowuje StringS, ale Foos instancji takich jak:

public class MyFooObject {

    private List<Foo> values;
    @SafeVarargs
    public static MyFooObject ofComponents(Foo... values) {
        // ...
    }

    public List<Foo> getComponents(){
        return new ArrayList<>(values);
    }
}

import org.assertj.core.api.Assertions;
import static org.assertj.core.groups.Tuple.tuple;
import org.junit.jupiter.api.Test;

@Test
void ofComponent() throws Exception {
    MyFooObject myObject = MyFooObject.ofComponents(new Foo(1, "One"), new Foo(2, "Two"), new Foo(3, "Three"));

    Assertions.assertThat(myObject.getComponents())
              .extracting(Foo::getId, Foo::getName)
              .containsExactly(tuple(1, "One"),
                               tuple(2, "Two"),
                               tuple(3, "Three"));
}

• moja odpowiedź czy {[0] } jest najlepszym wyborem:

Iterables.elementsEqual wystarczy porównać 2 List s.

Iterables.elementsEqual jest używany w bardziej ogólnych scenariuszach, przyjmuje bardziej ogólne typy: Iterable. Oznacza to, że można nawet porównać List z Set. (według kolejności iteracji, jest to ważne)

Jasne ArrayList i LinkedList definiują równe całkiem dobre, można wywołać równe bezpośrednio. Podczas gdy używasz niezbyt zdefiniowanej listy, Iterables.elementsEqual jest najlepszym wyborem. Jedna rzecz powinna być zauważona: Iterables.elementsEqual nie akceptuje null

• Konwersja listy do tablicy: Iterables.toArray jest łatwiejsza.

• W przypadku testu jednostkowego polecam dodać pustą listę do swojego przypadku testowego.