``` I feel confused about containExactlyInAnyOrder...

# kotest

[Alex Kuznetsov]

I feel confused about containExactlyInAnyOrder

. I'd expect the following to pass, but it fails:

val caseInsensitiveStringEquality: Equality<String> = object : Equality<String> {
               override fun name() = "Case Insensitive String Matcher"

               override fun verify(actual: String, expected: String): EqualityResult {
                  return if(actual.uppercase() == expected.uppercase())
                     EqualityResult.equal(actual, expected, this)
                  else
                     EqualityResult.notEqual(actual, expected, this)
               }
            }
            listOf("apple, Apple") should containExactlyInAnyOrder(listOf("APPLE", "APPLE"), caseInsensitiveStringEquality)

what am I missing?

[LeoColman]

Your matcher seems wrong

[LeoColman]

if(actual.uppsercase() == expected.uppercase())
EqualityResult.equal(actual, expected, this)

[LeoColman]

Shouldn't it be EqualityResult.equal(actual.uppercase(), expected.uppsercase(), this)?

[Alex Kuznetsov]

It does not make any difference. I've modified matcher as follows

[Alex Kuznetsov]

val caseInsensitiveStringEquality: Equality<String> = object : Equality<String> {
               override fun name() = "Case Insensitive String Matcher"

               override fun verify(actual: String, expected: String): EqualityResult {
                  return if(actual.uppercase() == expected.uppercase())
                     EqualityResult.equal(actual.uppercase(), expected.uppercase(), this)
                  else
                     EqualityResult.notEqual(actual.uppercase(), expected.uppercase(), this)
               }
            }

[Alex Kuznetsov]

still getting Collection should contain ["APPLE", "APPLE"] in any order, but was ["apple, Apple"]

[Alex Kuznetsov]

I know why

[Alex Kuznetsov]

fun <T, C : Collection<T>> containExactlyInAnyOrder(
   expected: C,
   verifier: Equality<T>?,
): Matcher<C?> = neverNullMatcher { actual ->

   val valueGroupedCounts: Map<T, Int> = actual.groupBy { it }.mapValues { it.value.size }
   val expectedGroupedCounts: Map<T, Int> = expected.groupBy { it }.mapValues { it.value.size }

   val passed = expectedGroupedCounts.size == valueGroupedCounts.size && // this line is wrong

here we are matching 1 with 2

[Alex Kuznetsov]

because ["APPLE", "APPLE"] has size of 1 after grouping