Improve the performance of `containsExactly` from quadratic to linear complexity

Summary

The performance of the containsExactly function of Iterables is currently quadratic, while it could be linear. It seems to be because of the IterableDiff class it uses, which checks the extra and missing elements with an algorithm suitable for checking the elements in any order. However, this is not necessary, since they have to be present in the exact order and so a more efficient linear solution could look something like this:

boolean compare(expected, actual) {
    if (expected.size() != actual.size()) return false;
    for (int i = 0; i < expected.size(); i++) {
       if (expected.get(i) != actual.get(i)) return false;
    }
    return true;
}

We ran a scalability analysis on various assertions, which you can find here if you are interested.

[joel-costigliola]

containsExactly is not a good fit for some Set like HashSets (but it’s fine for SortedSets or LinkedHashSet), on this one we expect users to know the semantics of the iterables being tested. If the iteration order is not consistent then the assertion will likely fail and that is fine since the iterable did not honor the assertion contract.

containsExactlyInAnyOrder can be used with HashSet aspointed out by @sarajuhosova.

Plus, it seems that that IterableDiff_Test lacks testing with iterables that aren’t ArrayLists where the ordering could be different, like HashSets.

I agree that we could have used different iterable types but only those with consistent iteration order (so no HashSet).

In my experience we should not rely on HashSet iteration even though it could look consistent, I remember on one project tests that relied on this and failed once we migrated to a newer version of java that changes the underlying HashSet iteration order.

So moving forward, we should continue treating iterable as if they had a consistent iteration order for containsExactly and let users the responsibility to choose the correct assertion for HashSet, what we can do though is to enhance the javadoc with a warning to prefer containsExactlyInAnyOrder over containsExactly for HashSet or any iterable whose iteration order is not predictable.

Good discussion btw!

[joel-costigliola]

one comment about the issue is that we want to keep the error message as it is.