fix: correctly check equality for CaseInsensitiveMap

Author: ianbotsf

.changes/4820850c-8916-47f5-a7e1-8880e6a00d22.json

@@ -0,0 +1,5 @@
+{
+    "id": "4820850c-8916-47f5-a7e1-8880e6a00d22",
+    "type": "bugfix",
+    "description": "Fix errors in equality checks for `CaseInsensitiveMap` which affect `Headers` and `ValuesMap` implementations"
+}

runtime/runtime-core/api/runtime-core.api

@@ -306,6 +306,7 @@ public class aws/smithy/kotlin/runtime/collections/ValuesMapImpl : aws/smithy/ko
 	public fun getAll (Ljava/lang/String;)Ljava/util/List;
 	public fun getCaseInsensitiveName ()Z
 	protected final fun getValues ()Ljava/util/Map;
+	public fun hashCode ()I
 	public fun isEmpty ()Z
 	public fun names ()Ljava/util/Set;
 }

runtime/runtime-core/common/src/aws/smithy/kotlin/runtime/collections/CaseInsensitiveMap.kt

@@ -6,11 +6,11 @@ package aws.smithy.kotlin.runtime.collections
 
 import aws.smithy.kotlin.runtime.InternalApi
 
-private class CaseInsensitiveString(val s: String) {
-    val hash: Int = s.lowercase().hashCode()
-    override fun hashCode(): Int = hash
-    override fun equals(other: Any?): Boolean = other is CaseInsensitiveString && other.s.equals(s, ignoreCase = true)
-    override fun toString(): String = s
+private class CaseInsensitiveString(val original: String) {
+    val normalized = original.lowercase()
+    override fun hashCode() = normalized.hashCode()
+    override fun equals(other: Any?) = other is CaseInsensitiveString && normalized == other.normalized
+    override fun toString() = original
 }
 
 private fun String.toInsensitive(): CaseInsensitiveString =
@@ -36,11 +36,11 @@ internal class CaseInsensitiveMap<Value> : MutableMap<String, Value> {
 
     override val entries: MutableSet<MutableMap.MutableEntry<String, Value>>
         get() = impl.entries.map {
-            Entry(it.key.s, it.value)
+            Entry(it.key.normalized, it.value)
         }.toMutableSet()
 
     override val keys: MutableSet<String>
-        get() = impl.keys.map { it.s }.toMutableSet()
+        get() = impl.keys.map { it.normalized }.toMutableSet()
 
     override val values: MutableCollection<Value>
         get() = impl.values
@@ -57,6 +57,12 @@ internal class CaseInsensitiveMap<Value> : MutableMap<String, Value> {
 
     override fun remove(key: String): Value? = impl.remove(key.toInsensitive())
 
+    override fun hashCode() = impl.hashCode()
+
+    override fun equals(other: Any?) = other is CaseInsensitiveMap<*> && impl == other.impl
+
+    override fun toString() = impl.toString()
+
     private class Entry<Key, Value>(
         override val key: Key,
         override var value: Value,

runtime/runtime-core/common/src/aws/smithy/kotlin/runtime/collections/ValuesMap.kt

@@ -89,15 +89,13 @@ public open class ValuesMapImpl<T>(
 
     override fun isEmpty(): Boolean = values.isEmpty()
 
-    override fun equals(other: Any?): Boolean =
-        other is ValuesMap<*> &&
-            caseInsensitiveName == other.caseInsensitiveName &&
-            names().let { names ->
-                if (names.size != other.names().size) {
-                    return false
-                }
-                names.all { getAll(it) == other.getAll(it) }
-            }
+    override fun equals(other: Any?): Boolean = when (other) {
+        is ValuesMapImpl<*> -> caseInsensitiveName == other.caseInsensitiveName && values == other.values
+        is ValuesMap<*> -> caseInsensitiveName == other.caseInsensitiveName && entries() == other.entries()
+        else -> false
+    }
+
+    override fun hashCode(): Int = values.hashCode()
 
     private fun Map<String, List<T>>.deepCopyValues(): Map<String, List<T>> = mapValues { (_, v) -> v.toList() }
 }

runtime/runtime-core/common/test/aws/smithy/kotlin/runtime/collections/CaseInsensitiveMapTest.kt

@@ -18,4 +18,43 @@ class CaseInsensitiveMapTest {
         assertEquals("json", map["content-type"])
         assertEquals("json", map["CONTENT-TYPE"])
     }
+
+    @Test
+    fun testEquality() {
+        val left = CaseInsensitiveMap<String>()
+        left["A"] = "apple"
+        left["B"] = "banana"
+        left["C"] = "cherry"
+
+        val right = CaseInsensitiveMap<String>()
+        right["c"] = "cherry"
+        right["b"] = "banana"
+        right["a"] = "apple"
+
+        assertEquals(left, right)
+    }
+
+    @Test
+    fun testEntriesEquality() {
+        val left = CaseInsensitiveMap<String>()
+        left["A"] = "apple"
+        left["B"] = "banana"
+        left["C"] = "cherry"
+
+        val right = CaseInsensitiveMap<String>()
+        right["c"] = "cherry"
+        right["b"] = "banana"
+        right["a"] = "apple"
+
+        assertEquals(left.entries, right.entries)
+    }
+
+    @Test
+    fun testToString() {
+        val map = CaseInsensitiveMap<String>()
+        map["A"] = "apple"
+        map["B"] = "banana"
+        map["C"] = "cherry"
+        assertEquals("{A=apple, B=banana, C=cherry}", map.toString())
+    }
 }