Khẳng định bằng giữa 2 Danh sách trong Junit

Làm cách nào tôi có thể đưa ra khẳng định bình đẳng giữa các danh sách trong trường hợp kiểm tra JUnit ? Bình đẳng nên giữa các nội dung của danh sách.

Ví dụ:

List<String> numbers = Arrays.asList("one", "two", "three");
List<String> numbers2 = Arrays.asList("one", "two", "three");
List<String> numbers3 = Arrays.asList("one", "two", "four"); 

// numbers should be equal to numbers2
//numbers should not be equal to numbers3

Tôi nhận ra điều này đã được hỏi một vài năm trước đây, có lẽ tính năng này không xuất hiện sau đó. Nhưng bây giờ, thật dễ dàng để làm điều này:

@Test
public void test_array_pass()
{
  List<String> actual = Arrays.asList("fee", "fi", "foe");
  List<String> expected = Arrays.asList("fee", "fi", "foe");

  assertThat(actual, is(expected));
  assertThat(actual, is(not(expected)));
}

Nếu bạn có phiên bản Junit gần đây được cài đặt với hamcrest, chỉ cần thêm các nhập này:

import static org.junit.Assert.*;
import static org.hamcrest.CoreMatchers.*;

http://junit.org/junit4/javadoc/latest/org/junit/Assert.html#assertThat(T, org.hamcrest.Matcher)

http://junit.org/junit4/javadoc/latest/org/hamcrest/CoreMatchers.html

http://junit.org/junit4/javadoc/latest/org/hamcrest/core/Is.html

Đừng biến đổi thành chuỗi và so sánh. Điều này là không tốt cho nước hoa. Trong Junit, bên trong Corematchers, có một người mai mối cho việc này =>hasItems

List<Integer> yourList = Arrays.asList(1,2,3,4)    
assertThat(yourList, CoreMatchers.hasItems(1,2,3,4,5));

Đây là cách tốt hơn mà tôi biết để kiểm tra các yếu tố trong danh sách.

Đây là một câu trả lời kế thừa, phù hợp với JUnit 4.3 trở xuống. Phiên bản hiện đại của JUnit bao gồm các thông báo lỗi có thể đọc được trong phương thức assertThat. Thích câu trả lời khác cho câu hỏi này, nếu có thể.

List<E> a = resultFromTest();
List<E> expected = Arrays.asList(new E(), new E(), ...);
assertTrue("Expected 'a' and 'expected' to be equal."+
            "\n  'a'        = "+a+
            "\n  'expected' = "+expected, 
            expected.equals(a));

Đối với hồ sơ, như @Paul đã đề cập trong bình luận của mình cho câu trả lời này, hai Lists bằng nhau:

nếu và chỉ khi đối tượng được chỉ định cũng là một danh sách, cả hai danh sách có cùng kích thước và tất cả các cặp phần tử tương ứng trong hai danh sách đều bằng nhau. (Hai phần tử e1và e2bằng nhau nếu (e1==null ? e2==null : e1.equals(e2)).) Nói cách khác, hai danh sách được xác định là bằng nhau nếu chúng chứa các phần tử giống nhau theo cùng một thứ tự. Định nghĩa này đảm bảo rằng phương thức bằng hoạt động đúng trong các triển khai khác nhau của Listgiao diện.

Xem JavaDocs của Listgiao diện .

assertEquals(Object, Object)từ JUnit4 / JUnit 5 hoặc assertThat(actual, is(expected));từ Hamcrest được đề xuất trong các câu trả lời khác sẽ chỉ hoạt động khi cả hai equals()và toString()được ghi đè cho các lớp (và sâu) của các đối tượng được so sánh.

Nó quan trọng bởi vì kiểm tra đẳng thức trong khẳng định dựa vào equals()và thông báo lỗi kiểm tra phụ thuộc vào toString()các đối tượng được so sánh.
Đối với các lớp dựng sẵn như String, Integervà vì vậy ... không có vấn đề gì vì các lớp này ghi đè cả equals()và toString(). Vì vậy, nó là hoàn toàn hợp lệ để khẳng định List<String>hoặc List<Integer>với assertEquals(Object,Object).
Và về vấn đề này: bạn phải ghi đè equals()trong một lớp vì nó có ý nghĩa về mặt bình đẳng đối tượng, không chỉ giúp cho các xác nhận dễ dàng hơn trong một thử nghiệm với JUnit.
Để làm cho các xác nhận dễ dàng hơn, bạn có những cách khác.
Là một thực hành tốt, tôi ủng hộ các thư viện khẳng định / so khớp.

Đây là một giải pháp AssertJ .

org.assertj.core.api.ListAssert.containsExactly() là những gì bạn cần: nó xác minh rằng nhóm thực tế chứa chính xác các giá trị đã cho và không có gì khác, theo thứ tự như đã nêu trong javadoc.

Giả sử một Foolớp nơi bạn thêm các phần tử và nơi bạn có thể nhận được phần tử đó.
Một bài kiểm tra đơn vị Fookhẳng định rằng hai danh sách có cùng nội dung có thể trông giống như:

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

@Test
void add() throws Exception { 
   Foo foo = new Foo();
   foo.add("One", "Two", "Three");
   Assertions.assertThat(foo.getElements())
             .containsExactly("One", "Two", "Three");
}

Một điểm tốt của AssertJ là việc khai Listbáo như mong đợi là không cần thiết: nó làm cho khẳng định trở nên cứng hơn và mã dễ đọc hơn:

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

Nhưng các thư viện Ass ass / matcher là bắt buộc bởi vì những thư viện này sẽ thực sự xa hơn.
Giả sử bây giờ Foo không lưu trữ Strings nhưng Bars.
Đó là một nhu cầu rất phổ biến. Với AssertJ, khẳng định vẫn đơn giản để viết. Tốt hơn là bạn có thể khẳng định rằng nội dung danh sách là bằng nhau ngay cả khi lớp của các phần tử không ghi đè equals()/hashCode()trong khi cách JUnit yêu cầu:

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

@Test
void add() throws Exception {
    Foo foo = new Foo();
    foo.add(new Bar(1, "One"), new Bar(2, "Two"), new Bar(3, "Three"));
    Assertions.assertThat(foo.getElements())
              .extracting(Bar::getId, Bar::getName)
              .containsExactly(tuple(1, "One"),
                               tuple(2, "Two"),
                               tuple(3, "Three"));
}

Nếu bạn không quan tâm đến thứ tự của các yếu tố, tôi khuyên bạn nên sử dụng ListAssert.assertEqualsphần bổ trợ.

Liên kết: http://junit-addons.sourceforge.net/

Dành cho người dùng Maven lười biếng:

    <dependency>
        <groupId>junit-addons</groupId>
        <artifactId>junit-addons</artifactId>
        <version>1.4</version>
        <scope>test</scope>
    </dependency>

Bạn có thể sử dụng assertEquals trong Junit.

import org.junit.Assert;   
import org.junit.Test;

    @Test
    public void test_array_pass()
    {
        List<String> actual = Arrays.asList("fee", "fi", "foe");
        List<String> expected = Arrays.asList("fee", "fi", "foe");
        Assert.assertEquals(actual,expected);
    }

Nếu thứ tự của các phần tử là khác nhau thì nó sẽ trả về lỗi.

Nếu bạn đang xác nhận một danh sách đối tượng mô hình thì bạn nên ghi đè phương thức bằng trong mô hình cụ thể.

    @Override
    public boolean equals(Object obj) {
        if (obj == this) {
            return true;
        }
        if (obj != null && obj instanceof ModelName) {
            ModelName other = (ModelName) obj;
            return this.getItem().equals(other.getItem()) ;
        }
        return false;
    }

nếu bạn không muốn xây dựng một danh sách mảng, bạn cũng có thể thử điều này

@Test
public void test_array_pass()
{
  List<String> list = Arrays.asList("fee", "fi", "foe");
  Strint listToString = list.toString();
  Assert.assertTrue(listToString.contains("[fee, fi, foe]"));   // passes  
}

List<Integer> figureTypes = new ArrayList<Integer>(
                           Arrays.asList(
                                 1,
                                 2
                            ));

List<Integer> figureTypes2 = new ArrayList<Integer>(
                           Arrays.asList(
                                 1,
                                 2));

assertTrue(figureTypes .equals(figureTypes2 ));

Đừng phát minh lại bánh xe!

Có thư viện Google Code thực hiện điều này cho bạn: Hamcrest

[Hamcrest] Cung cấp một thư viện các đối tượng khớp (còn được gọi là các ràng buộc hoặc biến vị ngữ) cho phép các quy tắc 'khớp' được định nghĩa theo cách khai báo, được sử dụng trong các khung khác. Các kịch bản điển hình bao gồm khung kiểm tra, thư viện giả và quy tắc xác thực UI.

Tôi biết đã có nhiều lựa chọn để giải quyết vấn đề này, nhưng tôi muốn làm như sau để khẳng định hai danh sách trong bất kỳ oder nào :

assertTrue(result.containsAll(expected) && expected.containsAll(result))

assertEquals(expected, result);làm việc cho tôi Vì hàm này có hai đối tượng, bạn có thể truyền bất cứ thứ gì cho nó.

public static void assertEquals(Object expected, Object actual) {
    AssertEquals.assertEquals(expected, actual);
}

Tôi không biết tất cả các câu trả lời trên đang đưa ra giải pháp chính xác để so sánh hai danh sách Đối tượng. Hầu hết các cách tiếp cận trên có thể hữu ích trong giới hạn so sánh chỉ sau - So sánh kích thước - So sánh tham chiếu

Nhưng nếu chúng ta có các danh sách đối tượng có cùng kích thước và dữ liệu khác nhau ở cấp độ đối tượng thì phương pháp so sánh này sẽ không hữu ích.

Tôi nghĩ rằng cách tiếp cận sau đây sẽ hoạt động hoàn hảo với ghi đè bằng và phương thức mã băm trên đối tượng do người dùng xác định.

Tôi đã sử dụng lib Xstream để ghi đè bằng và mã băm nhưng chúng tôi cũng có thể ghi đè bằng và mã băm bằng cách ra logic / so sánh thắng.

Dưới đây là ví dụ để bạn tham khảo

    import com.thoughtworks.xstream.XStream;

    import java.text.ParseException;
    import java.util.ArrayList;
    import java.util.List;

    class TestClass {
      private String name;
      private String id;

      public void setName(String value) {
        this.name = value;
      }

      public String getName() {
        return this.name;
      }

      public String getId() {
        return id;
      }

      public void setId(String id) {
        this.id = id;
      }

      /**
       * @see java.lang.Object#equals(java.lang.Object)
       */
      @Override
      public boolean equals(Object o) {
        XStream xstream = new XStream();
        String oxml = xstream.toXML(o);
        String myxml = xstream.toXML(this);

        return myxml.equals(oxml);
      }

      /**
       * @see java.lang.Object#hashCode()
       */
      @Override
      public int hashCode() {
        XStream xstream = new XStream();
        String myxml = xstream.toXML(this);
        return myxml.hashCode();
      }
    }

    public class XstreamCompareTest {
      public static void main(String[] args) throws ParseException {
      checkObjectEquals();
}

      private static void checkObjectEquals() {
        List<TestClass> testList1 = new ArrayList<TestClass>();
        TestClass tObj1 = new TestClass();
        tObj1.setId("test3");
        tObj1.setName("testname3");
        testList1.add(tObj1);

        TestClass tObj2 = new TestClass();
        tObj2.setId("test2");
        tObj2.setName("testname2");
        testList1.add(tObj2);

        testList1.sort((TestClass t1, TestClass t2) -> t1.getId().compareTo(t2.getId()));

        List<TestClass> testList2 = new ArrayList<TestClass>();
        TestClass tObj3 = new TestClass();
        tObj3.setId("test3");
        tObj3.setName("testname3");
        testList2.add(tObj3);

        TestClass tObj4 = new TestClass();
        tObj4.setId("test2");
        tObj4.setName("testname2");
        testList2.add(tObj4);

        testList2.sort((TestClass t1, TestClass t2) -> t1.getId().compareTo(t2.getId()));

        if (isNotMatch(testList1, testList2)) {
          System.out.println("The list are not matched");
        } else {
          System.out.println("The list are matched");
        }

      }

      private static boolean isNotMatch(List<TestClass> clist1, List<TestClass> clist2) {
        return clist1.size() != clist2.size() || !clist1.equals(clist2);
      }
    }

Điều quan trọng nhất là bạn có thể bỏ qua các trường bằng Chú thích (@XStreamOmitField) nếu bạn không muốn bao gồm bất kỳ trường nào trong phần kiểm tra đối tượng bằng nhau. Có nhiều chú thích như thế này để cấu hình, vì vậy hãy nhìn sâu vào các chú thích của lib này.

Tôi chắc chắn câu trả lời này sẽ tiết kiệm thời gian của bạn để xác định cách tiếp cận chính xác để so sánh hai danh sách các đối tượng :). Hãy bình luận nếu bạn thấy bất kỳ vấn đề về điều này.