ยืนยันเท่ากับระหว่าง 2 รายการใน Junit

ฉันจะยืนยันความเท่าเทียมกันระหว่างรายการในกรณีทดสอบJUnit ได้อย่างไร ความเท่าเทียมกันควรอยู่ระหว่างเนื้อหาของรายการ

ตัวอย่างเช่น:

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

ฉันรู้ว่าสิ่งนี้ถูกถามเมื่อสองสามปีก่อนอาจเป็นเพราะคุณสมบัตินี้ไม่ได้อยู่ในนั้น แต่ตอนนี้มันง่ายที่จะทำสิ่งนี้:

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

หากคุณมี Junit รุ่นล่าสุดติดตั้งด้วย hamcrest เพียงเพิ่มการนำเข้าเหล่านี้:

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

อย่าแปลงเป็นสตริงและเปรียบเทียบ สิ่งนี้ไม่ดีสำหรับความสมบูรณ์ ใน Junit ภายใน Corematchers มีผู้จับคู่สำหรับสิ่งนี้ =>hasItems

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

นี่เป็นวิธีที่ดีกว่าที่ฉันรู้ในการตรวจสอบองค์ประกอบในรายการ

นี่เป็นคำตอบเดิมซึ่งเหมาะสำหรับ JUnit 4.3 และต่ำกว่า JUnit เวอร์ชันทันสมัยมีข้อความล้มเหลวที่สามารถอ่านได้ในตัวในเมธอด assertThat ต้องการคำตอบอื่น ๆ สำหรับคำถามนี้ถ้าเป็นไปได้

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

สำหรับเร็กคอร์ดตามที่ @Paul กล่าวถึงในความคิดเห็นของเขาต่อคำตอบนี้สองLists จะเท่ากัน:

ถ้าและถ้าวัตถุที่ระบุเป็นรายการทั้งสองรายการจะมีขนาดเท่ากันและคู่ขององค์ประกอบที่สอดคล้องกันทั้งหมดในรายการทั้งสองจะเท่ากัน (สององค์ประกอบe1และe2เท่ากับถ้า(e1==null ? e2==null : e1.equals(e2)).) ในคำอื่น ๆ สองรายการจะถูกกำหนดให้เท่ากับหากพวกเขามีองค์ประกอบเดียวกันในลำดับเดียวกัน คำจำกัดความนี้ทำให้มั่นใจได้ว่าวิธีการที่เท่าเทียมกันทำงานได้อย่างถูกต้องในการใช้งานที่แตกต่างกันของListอินเตอร์เฟซ

ดูJavaDocs ของListอินเตอร์เฟซ

assertEquals(Object, Object)จาก JUnit4 / JUnit 5 หรือ assertThat(actual, is(expected));จาก Hamcrest ที่เสนอในคำตอบอื่น ๆ จะใช้งานได้ทั้งในฐานะที่เป็นequals()และtoString()ถูกแทนที่สำหรับชั้นเรียน (และลึก) ของวัตถุที่เปรียบเทียบ

มันมีความสำคัญเนื่องจากการทดสอบความเท่าเทียมกันในการยืนยันนั้นอาศัยequals()และข้อความทดสอบความล้มเหลวนั้นขึ้นอยู่toString()กับวัตถุที่เปรียบเทียบ
สำหรับในตัวชั้นเรียนเช่นString, Integerและอื่น ๆ สำหรับปัญหา ... เป็นแทนที่เหล่านี้ไม่มีทั้งสองและequals() toString()ดังนั้นจึงเป็นสิ่งที่ถูกต้องสมบูรณ์ที่จะยืนยันList<String>หรือกับList<Integer> และเกี่ยวกับเรื่องนี้: คุณต้องแทนที่ในชั้นเรียนเพราะมันสมเหตุสมผลในแง่ของความเสมอภาคของวัตถุไม่ใช่เพียงเพื่อให้การยืนยันง่ายขึ้นในการทดสอบกับ JUnit เพื่อให้การยืนยันง่ายขึ้นคุณมีวิธีอื่น ตามแนวทางปฏิบัติที่ดีฉันชอบห้องสมุดการยืนยัน / การจับคู่ assertEquals(Object,Object)
equals()

นี่คือวิธีแก้ปัญหา AssertJ

org.assertj.core.api.ListAssert.containsExactly() คือสิ่งที่คุณต้องการ: มันจะตรวจสอบว่ากลุ่มจริงมีค่าที่กำหนดอย่างแน่นอนและไม่มีอะไรอื่นตามที่ระบุไว้ใน javadoc

สมมติFooคลาสที่คุณเพิ่มอิลิเมนต์และที่ที่คุณสามารถรับได้
การทดสอบหน่วยของFooยืนยันว่าทั้งสองรายการมีเนื้อหาเหมือนกันอาจมีลักษณะดังนี้:

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

จุดที่ดีของ AssertJ ก็คือการประกาศ a Listอย่างที่คาดไว้นั้นไม่จำเป็น: มันทำให้การยืนยันตรงและโค้ดอ่านง่ายขึ้น:

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

แต่ห้องสมุด Assertion / matcher นั้นเป็นสิ่งที่ต้องทำเพราะสิ่งเหล่านี้จะเพิ่มมากขึ้น
สมมติว่าตอนนี้Foo ไม่ได้เก็บStrings แต่Barอินสแตนซ์ของ
นั่นคือความต้องการที่พบบ่อยมาก ด้วย AssertJ การยืนยันยังง่ายต่อการเขียน ดีกว่าคุณสามารถยืนยันว่าเนื้อหารายการเท่ากันแม้ว่าคลาสขององค์ประกอบจะไม่แทนที่equals()/hashCode()ในขณะที่วิธี JUnit ต้องการ:

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

หากคุณไม่สนใจคำสั่งขององค์ประกอบฉันแนะนำ ListAssert.assertEqualsใน junit-addons

Link: http://junit-addons.sourceforge.net/

สำหรับผู้ใช้ Maven ขี้เกียจ:

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

คุณสามารถใช้assertEqualsใน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);
    }

หากลำดับขององค์ประกอบแตกต่างจากนั้นจะส่งคืนข้อผิดพลาด

หากคุณยืนยันรายการวัตถุแบบจำลองคุณควรแทนที่วิธีการเท่ากับในรูปแบบเฉพาะ

    @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;
    }

หากคุณไม่ต้องการสร้างรายการอาร์เรย์คุณสามารถลองทำสิ่งนี้ได้เช่นกัน

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

อย่าประดิษฐ์ล้อใหม่!

มีห้องสมุด Google Code ที่ทำสิ่งนี้เพื่อคุณ: Hamcrest

[Hamcrest] จัดเตรียมไลบรารีของวัตถุตัวจับคู่ (หรือที่เรียกว่าข้อ จำกัด หรือภาคแสดง) ที่อนุญาตให้กำหนดกฎ 'จับคู่' ไว้อย่างชัดเจนเพื่อใช้ในกรอบงานอื่น สถานการณ์โดยทั่วไปรวมถึงกรอบการทดสอบ, การจำลองไลบรารีและกฎการตรวจสอบ UI

ฉันรู้ว่ามีตัวเลือกมากมายในการแก้ปัญหานี้ แต่ฉันอยากจะทำสิ่งต่อไปนี้เพื่อยืนยันสองรายการในรายการอื่น :

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

assertEquals(expected, result);ทำงานได้สำหรับฉัน เนื่องจากฟังก์ชั่นนี้รับวัตถุสองชิ้นคุณจึงสามารถผ่านสิ่งใดไปได้

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

ฉันไม่ได้นี่คือคำตอบทั้งหมดที่กล่าวมาข้างต้นคือให้คำตอบที่ถูกต้องสำหรับการเปรียบเทียบสองรายการของวัตถุ วิธีการข้างต้นส่วนใหญ่มีประโยชน์ในการ จำกัด การเปรียบเทียบเท่านั้น - การเปรียบเทียบขนาด - การเปรียบเทียบการอ้างอิง

แต่ถ้าเรามีรายการวัตถุขนาดเท่ากันและข้อมูลที่แตกต่างกันในระดับวัตถุวิธีการเปรียบเทียบนี้จะไม่ช่วย

ฉันคิดว่าวิธีการต่อไปนี้จะทำงานอย่างสมบูรณ์แบบด้วยการเอาชนะเท่ากับและวิธีแฮชโค้ดบนวัตถุที่ผู้ใช้กำหนด

ฉันใช้Xstream lib สำหรับแทนที่ค่าเท่ากับและ hashcode แต่เราสามารถแทนที่ค่าเท่ากับและ hashcode ได้โดยไม่ชนะ logics / การเปรียบเทียบเช่นกัน

นี่คือตัวอย่างสำหรับการอ้างอิงของคุณ

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

สิ่งที่สำคัญที่สุดคือคุณสามารถละเว้นฟิลด์ด้วย Annotation (@XStreamOmitField) หากคุณไม่ต้องการรวมฟิลด์ใด ๆ ในการตรวจสอบวัตถุที่เท่ากัน มีคำอธิบายประกอบมากมายเช่นนี้เพื่อกำหนดค่าดังนั้นให้มองลึกลงไปเกี่ยวกับคำอธิบายประกอบของ lib นี้

ฉันมั่นใจว่าคำตอบนี้จะประหยัดเวลาของคุณในการระบุวิธีการที่ถูกต้องสำหรับการเปรียบเทียบสองรายการของวัตถุ :) โปรดแสดงความคิดเห็นหากคุณเห็นปัญหาใด ๆ เกี่ยวกับเรื่องนี้