power assert and collection asserts

[christophsturm]

I wonder what a good way to do asserts on collections would be in power assert, especially where to show the diffs.

I have this helper

fun <T> Iterable<T>.containsExactlyInAnyOrder(vararg elements: T) =
    this.containsExactlyInAnyOrder(elements.asList())

and I use it like this:

        describe("containsExactlyInAnyOrder") {
            describe("simple") {
                it("returns true when the elements are the same") {
                    assert(listOf("a", "b").containsExactlyInAnyOrder("b", "a"))
                }
                it("returns true false the elements are not the same") {
                    assert(!listOf("a", "b", "c").containsExactlyInAnyOrder("b", "a"))
                }
            }

assertion errors look like this:

java.lang.AssertionError: Assertion failed
assert(listOf("a", "b", "c").containsExactlyInAnyOrder("b", "a"))
       |      |              |                         |
       |      |              |                         [Ljava.lang.String;@7579bc7
       |      |              false
       |      [Ljava.lang.String;@34cfd455
       [a, b, c]

which is easy to read unless the collection gets too long. But for longer collections a diff would be nice.

One quick idea would be to have the containsExactlyInOrder() helper return a list of differences, and write the assert like this:

assert(listOf("a", "b").containsExactlyInAnyOrder("b", "a").isEmpty())

maybe there could be an assert that asserts on an empty list, for especially this use case. or a sealed class

sealed class DiffResult
class NotSame(val difference:Difference):DiffResult
object Same:DiffResult

and a containsExactlyInAnyOrder returns DiffResult and we have an assert that asserts that DiffResult == Same
then i could just write

assert(listOf("a", "b").containsExactlyInAnyOrder("b", "a"))

and still get a diff result. I like this version best, but its also akward to have a containsExactlyInAnyOrder function that does not return boolean, so maybe that function would need to have a different name.

lastly there is of course the option to do an separate assert for this:

assertContainsExactlyInAnyOrder(listOf("a","b"), listOf("b","c"))

[bnorm]

One of the ways I have handled this is by pre-calculating the missing and unexpected values in the collection like so:

val unknown = actual- expected
val missing = expected- actual.key
assert(unknown.size + missing.size == 0) // Add sizes so both values are diagramed.

I think this is another reason to start tackling #45. These sorts of diffs would be a fantastic enhancement for assertion libraries.

I've also opened #80 based on your example assertion which includes the vararg array. The array itself is constant so can probably be excluded while still including the values within the array.