fixed error in hashcode implementations of various objects so ring works as expected

src/commonTest/kotlin/KDFTest.kt

@@ -0,0 +1,41 @@
+import kotlinx.coroutines.test.runTest
+import net.sergeych.crypto2.KDF
+import net.sergeych.crypto2.initCrypto
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertFalse
+
+class KDFTest {
+    @Test
+    fun testCacheKey() = runTest{
+        initCrypto()
+        val k1 = KDF.Argon.create(KDF.Complexity.Interactive, KDF.Argon.randomSalt(), 128)
+        val k2 = KDF.Argon.create(KDF.Complexity.Interactive, k1.salt, 128)
+
+        assertEquals(k1, k2)
+        assertEquals(k1.hashCode(), k2.hashCode())
+
+        val key1 = KDF.Instance(k1, "foo")
+        val key2 = KDF.Instance(k2, "foo")
+        val key3 = KDF.Instance(k2, "bar")
+
+        assertEquals(key1, key2)
+        assertEquals(key1.hashCode(), key2.hashCode())
+        assertFalse { key3 == key2 }
+        assertFalse { key3.hashCode() == key2.hashCode() }
+
+        val m = mutableMapOf<KDF.Instance, String>()
+        m[key1] = "foo"
+        m[key2] = "bar"
+        m[key3] = "foobar"
+
+        assertEquals("bar", m[key1])
+        assertEquals("bar", m[key2])
+        assertEquals("foobar", m[key3])
+
+        val set1 = setOf(key1, key2, key3)
+        val set2 = setOf(key3, key2, key1)
+        assertEquals(set2, set1)
+    }
+
+}

src/commonTest/kotlin/KeysTest.kt

@@ -172,4 +172,76 @@ class KeysTest {
 //        println(j.encodeToString(sk1))
     }
 
+
+    @Test
+    fun testUniKeys() = runTest {
+        initCrypto()
+        val sy1 = SymmetricKey.random()
+        val sy2 = SymmetricKey(sy1.keyBytes)
+        val sy3 = SymmetricKey.random()
+
+        assertEquals(sy1, sy2)
+        assertEquals(sy2, sy1)
+        assertFalse { sy1 == sy3 }
+
+        assertEquals(sy1, deepCopy(sy1), "symmetric key should be equal to the restored copy")
+        assertEquals(sy1.hashCode(), deepCopy(sy1).hashCode(), "hashcode of the restored symmetric key is wrong")
+
+        val usy1 = UniversalKey.from(sy1)
+        val usy2 = UniversalKey.from(sy2)
+        val usy3 = UniversalKey.from(sy3)
+
+        assertEquals(usy1, usy2)
+        assertEquals(usy2, usy1)
+        assertFalse { usy1 == usy3 }
+
+        val sk1 = Asymmetric.randomSecretKey()
+        val sk2 = Asymmetric.SecretKey(sk1.keyBytes)
+        val sk3 = Asymmetric.randomSecretKey()
+
+        assertEquals(sk1, sk2)
+        assertEquals(sk2, sk1)
+        assertFalse { sk1 == sk3 }
+
+        var usk1 = UniversalKey.from(sk1)
+        var usk2 = UniversalKey.from(sk2)
+        var usk3 = UniversalKey.from(sk3)
+        val usk4 = UniversalKey.from(sy3)
+
+        assertEquals(usk1, usk2)
+        assertEquals(usk2, usk1)
+        assertFalse { usk1 == usk3 }
+
+        var a = setOf(sy1, sy2, sk1, sk2)
+        var b = setOf(sk1, sk2, sy2, sy1)
+
+        assertEquals(a,b)
+
+        a = setOf(usk1, usk2, usk3, usk4)
+        b = setOf(usk1, usk2, usk3, usk4)
+
+        assertEquals(a, b)
+        // usk1 and usk2 are equal so set with only one of should be the same
+        assertEquals(a, setOf(usk1, usk3, usk4))
+
+        usk1 = deepCopy(usk1)
+        usk2 = deepCopy(usk2)
+        usk3 = deepCopy(usk3)
+
+        assertEquals(usk1.hashCode(),usk2.hashCode())
+
+        assertEquals(usk1, usk2)
+        assertEquals(usk2, usk1)
+        assertFalse { usk1 == usk3 }
+
+        a = setOf(usk1, usk2, usk3, usk4)
+        b = setOf(usk4, usk3, usk2, usk1)
+
+        assertEquals(3, a.size)
+        assertEquals(3, b.size)
+
+        assertEquals(a, b)
+        // usk1 and usk2 are equal so set with only one of should be the same
+        assertEquals(a, setOf(usk1, usk3, usk4))
+    }
 }

src/commonTest/kotlin/RingTest.kt

@@ -46,9 +46,13 @@ class RingTest {
         assertContains(r2, k1)
         assertFalse { k3 in r2 }
 
+        println("\r\n")
         println(r)
         println(r2)
 
+//        Kr[U.Sym:XYjneNaPFbg-PZJIYjgIz7F-DsH1dEY8Mg6LCirko2QBFA,U.Sec:FzuzDbrS0xR5nTkdd-mYvrqsfQn9HbQgtFnIw9CEirIAlw]
+//        Kr[U.Sym:XYjneNaPFbg-PZJIYjgIz7F-DsH1dEY8Mg6LCirko2QBFA,U.Sec:FzuzDbrS0xR5nTkdd-mYvrqsfQn9HbQgtFnIw9CEirIAlw]
+
         assertEquals(r, r2)
     }
 

src/commonTest/kotlin/test_tools.kt

@@ -0,0 +1,5 @@
+import net.sergeych.bipack.BipackDecoder
+import net.sergeych.bipack.BipackEncoder
+
+inline fun <reified T>deepCopy(x: T):T =
+    BipackDecoder.decode(BipackEncoder.encode(x))