How to compare two lists of double in JUnit

Question

In a JUnit 4 test, I have a method getValues() that returns a List<Double> object that I want to compare with a reference list. Up to now, the best solution I've found was to use org.hamcrest.collection.IsArray.hasItems and org.hamcrest.Matchers.closeTo like this:

assertThat(getValues(), hasItems(closeTo(0.2, EPSILON), closeTo(0.3, EPSILON)));

This goes well for a test that returns only few values. But if a test returns more values, this is definitely not the best approach.

I also tried the following code. The downcast to Matcher before hasItems is required for the code to compile:

List<Matcher<Double>> doubleMatcherList = new ArrayList<Matcher<Double>>();
doubleMatcherList.add(closeTo(0.2, EPSILON));
doubleMatcherList.add(closeTo(0.3, EPSILON));
assertThat(getValues(), (Matcher) hasItems(doubleMatcherList));

The comparison failed and I don't understand why :

java.lang.AssertionError: Expected: (a collection containing <[a numeric value within <1.0E-6> of <0.2>, a numeric value within <1.0E-6> of <0.3>]>) got: <[0.2, 0.30000000000000004]>

Is there a better way to compare two large lists of doubles? The difficulty here is that a numerical tolerance is required to validate if the result of getValues() is equal to my reference list. This kind of comparison seems very easy for any lists of objects, but not with lists of Double.

Answer 1

I think the right solution here would be a Custom Matcher. Basically something like IsIterableContainingInOrder that only works on Doubles and supports an error margin.

Answer 2

If you are willing to convert from List<Double> to double[], assertArrayEquals allows specifying a tolerance for error:

assertArrayEquals(new double[] {1, 2}, new double[] {1.01, 2.09}, 1E-1);

In Java 8, the conversion from list to array is relatively clean (see related question). For example:

double[] toArray(List<Double> list) {
    return list.stream().mapToDouble(Number::doubleValue).toArray();
}

And the assert statement could then be as follows:

assertArrayEquals(toArray(refList), toArray(getValues()), 1E-9);

p.s. toArray can be made to work with any Number type by just changing the signature to double[] toArray(List<? extends Number> list).

Answer 3

You need to use contains() rather than hasItems().

Casting the return of hasItems() to Matcher is hiding a type error. Your code is actually checking to see if the result of getValues() is a List that has the 2 Matchers you created, it's not evaluating those Matchers against the result of getValues().

This is because hasItems() doesn't have an overload taking a List<Matcher<? super T>> like contains() does.

This does what you want, without going through the hassle of a custom Matcher:

List<Matcher<? super Double>> doubleMatcherList = new ArrayList<>();
doubleMatcherList.add(closeTo(0.2, EPSILON));
doubleMatcherList.add(closeTo(0.3, EPSILON));
assertThat(getValues(), contains(doubleMatcherList));

Note the parameterised type of the doubleMatcherList. If it's just List<Matcher<Double>> it selects the wrong overload of contains().

Answer 4

If you are willing to change from Hamcrest to AssertJ assertions, here is a solution in java 8.

import static org.assertj.core.api.Assertions.assertThat;
import java.util.Arrays;
import java.util.Comparator;
import java.util.List;
import org.junit.Test;
// import java.util.function.Function;

public class DoubleComparatorTest {

  // private static final Double DELTA = 1E-4;
  // private static final Function<Double, Comparator<Double>> DOUBLE_COMPARATOR_WITH_DELTA =
  // (delta) -> (o1, o2) -> (o1 - o2 < delta) ? 0 : o1.compareTo(o2);

  private Comparator<Double> COMPARATOR = (o1, o2) -> (o1 - o2 < 0.0001) ? 0 : o1.compareTo(o2);

  @Test
  public void testScaleCalculationMaxFirstPositive() {
    List<Double> expected = Arrays.asList(1.1D, 2.2D, 3.3D);
    List<Double> actual = Arrays.asList(1.10001D, 2.2D, 3.30001D);

    assertThat(actual)
        // .usingElementComparator(DOUBLE_COMPARATOR_WITH_DELTA.apply(DELTA))
        .usingElementComparator(COMPARATOR)
        .isEqualTo(expected);
  }
}

Answer 5

There is no hasItems method which takes a list of matchers as argument. But you can use the one with varargs.

First convert your list of matchers to an array

@SuppressWarnings("unchecked")
private Matcher<Double>[] toDoubleMatcherArray(List<Matcher<Double>> doubleMatchers) {
    return doubleMatchers.toArray(new Matcher[0]);
}

and call it like this

assertThat(getValues(), hasItems(toDoubleMatcherArray(doubleMatcherList)));

Answer 6

I don't believe no one mentioned it. If you have the expected list, and

• want the actual list to be in the same order as expected list then use

  assertEquals(expected,actual);

• want the lists to be equal regardless of order then do assertTrue(expected.containsAll(actual) && actual.containsAll(expected));

Answer 7

If the two lists have different lengths then say they are different. If they have the same lengths, then sort the lists. After sorting them compare elements at the same index.

This can be discussed in more details whether you should compare each element from list A to corresponding elements from list B, e.g. compare A[i] with B[i-d], ... B[i], ..., B[i + d].

But for starters this might help you with getting better idea.

Update: If you can't modify the lists, you can always copy them and sort them.