ความหมายของอาร์กิวเมนต์ epsilon ของ assertEquals สำหรับค่า double

ฉันมีคำถามเกี่ยวกับ Junit assertEqualsเพื่อทดสอบค่าสองเท่า อ่านเอกสาร API ที่ฉันเห็น:

@Deprecated
public static void assertEquals(double expected, double actual)

เลิก ใช้ assertEquals (คาดว่าจะเป็นสองเท่า, จริงสองเท่า, epsilon สองเท่า) แทน

สิ่งที่ไม่epsilonคุ้มค่าหมายถึงอะไร? (เอปไซลอนเป็นตัวอักษรในอักษรกรีกใช่มั้ย)

มีคนอธิบายให้ฉันรู้ถึงวิธีการใช้

Epsilon เป็นค่าที่สามารถปิดตัวเลข 2 ตัวได้ ดังนั้นมันจะยืนยันความจริงตราบเท่าที่Math.abs(expected - actual) < epsilon

รุ่นนี้ของ JUnit คืออะไร? ฉันเคยเห็นเดลต้าไม่ใช่เอปไซลอน - แต่นั่นเป็นปัญหาด้านข้าง!

จาก JUnit javadoc :

เดลต้า - เดลต้าสูงสุดระหว่างที่คาดหวังและเกิดขึ้นจริงซึ่งตัวเลขทั้งสองยังคงถือว่าเท่ากัน

อาจเป็น overkill แต่โดยทั่วไปฉันใช้จำนวนน้อยมากเช่น

private static final double DELTA = 1e-15;

@Test
public void testDelta(){
    assertEquals(123.456, 123.456, DELTA);
}

หากคุณกำลังใช้การยืนยันhamcrestคุณสามารถใช้มาตรฐานที่equalTo()มีสอง doubles (ไม่ใช้เดลตา) อย่างไรก็ตามหากคุณต้องการเดลต้าคุณสามารถใช้closeTo()(ดูjavadoc ) เช่น

private static final double DELTA = 1e-15;

@Test
public void testDelta(){
    assertThat(123.456, equalTo(123.456));
    assertThat(123.456, closeTo(123.456, DELTA));
}

FYI JUnit 5 ที่กำลังจะมาถึงจะทำให้เดลต้าเป็นตัวเลือกเมื่อโทรassertEquals()ด้วยสองคู่ การดำเนินการ (หากคุณสนใจ) คือ:

private static boolean doublesAreEqual(double value1, double value2) {
    return Double.doubleToLongBits(value1) == Double.doubleToLongBits(value2);
}

การคำนวณจุดลอยตัวไม่แน่นอน - มักจะมีข้อผิดพลาดในการปัดเศษและข้อผิดพลาดเนื่องจากการเป็นตัวแทน (ตัวอย่างเช่น 0.1 ไม่สามารถแสดงได้อย่างแน่นอนในทศนิยมเลขฐานสอง)

ด้วยเหตุนี้การเปรียบเทียบค่าทศนิยมสองค่าโดยตรงเพื่อความเท่าเทียมจึงไม่ใช่ความคิดที่ดีเพราะอาจแตกต่างกันเล็กน้อยโดยขึ้นอยู่กับวิธีคำนวณ

"เดลต้า" ซึ่งถูกเรียกใน JUnit javadocsอธิบายถึงจำนวนของความแตกต่างที่คุณสามารถยอมรับได้ในค่าสำหรับพวกเขาที่จะถือว่ายังคงเท่ากัน ขนาดของค่านี้ขึ้นอยู่กับค่าที่คุณกำลังเปรียบเทียบทั้งหมด เมื่อเปรียบเทียบกันเป็นสองเท่าฉันมักจะใช้ค่าที่คาดหวังหารด้วย 10 ^ 6

ประเด็นก็คือว่าสองเท่าอาจไม่เท่ากันเนื่องจากปัญหาความแม่นยำซึ่งมีอยู่ในเลขทศนิยม ด้วยค่าของเดลต้านี้คุณสามารถควบคุมการประเมินความเท่าเทียมกันตามปัจจัยข้อผิดพลาด

นอกจากนี้ค่าบางจุดลอยตัวสามารถมีค่าพิเศษเช่น NAN และ -Infinity / + Infinity ซึ่งสามารถมีอิทธิพลต่อผลลัพธ์

หากคุณตั้งใจจะเปรียบเทียบว่าสองคู่มีค่าเท่ากันจริง ๆ แล้วเปรียบเทียบให้ดีที่สุดว่าเป็นการแสดงที่ยาวนาน

Assert.assertEquals(Double.doubleToLongBits(expected), Double.doubleToLongBits(result));

หรือ

Assert.assertEquals(0, Double.compareTo(expected, result));

ซึ่งสามารถนำความแตกต่างเหล่านี้มาพิจารณา

ฉันไม่ได้เจาะลึกถึงวิธีการยืนยันที่เป็นปัญหา แต่ฉันสามารถสันนิษฐานได้ว่าปัญหาก่อนหน้านี้ไม่ได้รับการสนับสนุนสำหรับปัญหาประเภทนี้และวิธีการใหม่จะคำนึงถึงพวกเขา

Epsilon คือความแตกต่างระหว่างexpectedและactualค่าซึ่งคุณสามารถยอมรับได้ว่าพวกเขาเท่ากัน คุณสามารถตั้งค่า.1เช่น

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

public interface Foo {
    double getDefaultValue();
}

public class FooImpl implements Foo {
    public double getDefaultValue() { return Double.MIN_VALUE; }
}

ในกรณีนี้คุณต้องการตรวจสอบให้แน่ใจว่าเป็นจริงMIN_VALUEไม่ใช่ศูนย์หรือ-MIN_VALUEหรือMIN_NORMALหรือมีค่าน้อยมาก ๆ คุณสามารถพูดได้

double defaultValue = new FooImpl().getDefaultValue();
assertEquals(Double.MIN_VALUE, defaultValue);

แต่สิ่งนี้จะทำให้คุณได้รับคำเตือนเรื่องเลิกใช้งาน หากต้องการหลีกเลี่ยงปัญหาดังกล่าวคุณสามารถโทรไปที่assertEquals(Object, Object):

// really you just need one cast because of autoboxing, but let's be clear
assertEquals((Object)Double.MIN_VALUE, (Object)defaultValue);

และถ้าคุณต้องการดูฉลาด:

assertEquals(
    Double.doubleToLongBits(Double.MIN_VALUE), 
    Double.doubleToLongBits(defaultValue)
);

หรือคุณสามารถใช้ Hamcrest สไตล์คล่องแคล่วยืนยัน:

// equivalent to assertEquals((Object)Double.MIN_VALUE, (Object)defaultValue);
assertThat(defaultValue, is(Double.MIN_VALUE));

หากค่าที่คุณกำลังตรวจสอบไม่มาจากการทำคณิตศาสตร์บางส่วน แต่ใช้ epsilon

Assert.assertTrue(Math.abs(actual-expected) == 0)