Why is assertEquals(double,double) deprecated in JUnit?

java junit junit4

I was wondering why assertEquals(double, double) is deprecated.

I used import static org.junit.Assert.assertEquals; and I used JUnit 4.11.

Below is my code:

import org.junit.Test;
import static org.junit.Assert.assertEquals;


public class AccountTest {

@Test
public void test() {
    Account checking = new Account(Account.CHECKING);
    checking.deposit(1000.0);
    checking.withdraw(100.0);
    assertEquals(900.0, checking.getBalance());
   }
}

checking.getBalance() returns a double value.

What could be wrong?

If you simply read the javadoc, you'd be told what to use instead.

Try using it like Assert.assertEquals(2.49, 2.49, 0.1);

If I was JUnit, I would fail the test for using double to represent money amounts instead of some third-party library class or a custom class specifically for money.

Community

It's deprecated because of the double's precision problems.

If you note, there's another method assertEquals(double expected, double actual, double delta) which allows a delta precision loss.

JavaDoc:

Asserts that two doubles are equal to within a positive delta. If they are not, an AssertionError is thrown. If the expected value is infinity then the delta value is ignored.NaNs are considered equal: assertEquals(Double.NaN, Double.NaN, *) passes ... delta - the maximum delta between expected and actual for which both numbers are still considered equal.

@JiajuShen, it depends on your calculations... Let's say if you do 5.1 + 0.1, you would expect 5.2 but the output would be 5.1999.... So the delta can be 0.0001... Or even lesser...

Check out this example from the JUnit source code or this example

Victor Augusto

People explain but don't give samples... So here goes what worked for me:

@Test
public void WhenMakingDepositAccountBalanceIncreases() {
    Account account = new Account();
    account.makeDeposit(10.0);
    assertEquals("Account balance was not correct.", 10.0, account.getBalance(), 0);
}

The 0 in the end;

Using 0.0 as the delta is the same as using the deprecated method. The delta is intended to reflect how close the numbers can be and still be considered equal. Use values like 0.1 or 0.01 or 0.001, etc, depending on how much error the application can tolerate.

This is a bad advise. Using 0 completely defeats the purpose of using the not-deprecated method. It is exactly the same as if using the deprecated variant. This is even more dangerous as you do not get a warning anymore. Acknowledge the reason why it was deprecated and use a small delta like 0.00001.

Eric

assertEquals(double, double) is deprecated because the 2 doubles may be the same but if they are calculated values, the processor may make them slightly different values.

If you try this, it will fail: assertEquals(.1 + .7, .8). This was tested using an Intel® processor.

Calling the deprecated method will trigger fail("Use assertEquals(expected, actual, delta) to compare floating-point numbers"); to be called.

steven35

Old question but this hasn't been said yet and might help someone.

You can use com.google.common.math.DoubleMath.fuzzyEquals(double a, double b, double tolerance) which allows you to specify how close the two doubles should be to each other.

I found it very handy for unit tests where I don't want to hardcode test result values with a lot of decimal places.

Why is assertEquals(double,double) deprecated in JUnit?

Follow WeChat

Want to stay one step ahead of the latest teleworks?

相似问题

Platform

Support

Contact US