missing initial files + publishing

src/commonTest/kotlin/KeysTest.kt

@@ -0,0 +1,58 @@
+import com.ionspin.kotlin.crypto.secretbox.SecretBox
+import com.ionspin.kotlin.crypto.util.decodeFromUByteArray
+import com.ionspin.kotlin.crypto.util.encodeToUByteArray
+import kotlinx.coroutines.test.runTest
+import net.sergeych.crypto2.*
+import net.sergeych.utools.pack
+import net.sergeych.utools.unpack
+import kotlin.test.*
+
+class KeysTest {
+    @Test
+    fun testCreationAndMap() = runTest {
+        initCrypto()
+        val (stk,pbk) = SigningKey.Secret.pair()
+
+        val x = mapOf( stk to "STK!", pbk to "PBK!")
+        assertEquals("STK!", x[stk])
+        val s1 = SigningKey.Secret(stk.packed)
+        assertEquals(stk, s1)
+        assertEquals("STK!", x[s1])
+        assertEquals("PBK!", x[pbk])
+
+        val data = "8 rays dev!".encodeToUByteArray()
+        val data1 = "8 rays dev!".encodeToUByteArray()
+        val s = stk.seal(data)
+        assertTrue(s.verify(data))
+
+        data1[0] = 0x01u
+        assertFalse(s.verify(data1))
+        val p2 = SigningKey.Secret.pair()
+        val p3 = SigningKey.Secret.pair()
+
+        val ms = SignedBox(data, s1) + p2.signing
+
+        // non tampered:
+        val ms1 = unpack<SignedBox>(pack(ms))
+        assertContentEquals(data, ms1.message)
+        assertTrue(pbk in ms1)
+        assertTrue(p2.aPublic in ms1)
+        assertTrue(p3.aPublic !in ms1)
+
+        assertThrows<IllegalSignatureException> {
+            unpack<SignedBox>(pack(ms).also { it[3] = 1u })
+        }
+    }
+
+    @Test
+    fun secretEncryptTest() = runTest {
+        initCrypto()
+        val key = SecretBox.keygen()
+        val key1 = SecretBox.keygen()
+        assertEquals("hello", decrypt(key, encrypt(key, "hello".encodeToUByteArray())).decodeFromUByteArray())
+        assertThrows<DecryptionFailedException> {
+            decrypt(key, encrypt(key1, "hello".encodeToUByteArray())).decodeFromUByteArray()
+        }
+    }
+
+}

src/commonTest/kotlin/PackTest.kt

@@ -0,0 +1,35 @@
+import kotlinx.coroutines.test.runTest
+import kotlinx.datetime.Instant
+import net.sergeych.crypto2.initCrypto
+import net.sergeych.utools.nowToSeconds
+import net.sergeych.utools.pack
+import net.sergeych.utools.unpack
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import kotlin.time.Duration.Companion.microseconds
+
+class PackTest {
+        inline fun <reified T>check(x: T?) {
+            assertEquals(x, unpack<T>(pack(x)))
+        }
+    @Test
+    fun testNullPack() = runTest {
+        initCrypto()
+        val d = pack("Hello")
+        assertEquals(6, d.size)
+        check(1)
+        check(2L)
+        check(1.00)
+        check("hello")
+        check<String>(null)
+        check<Long?>(null)
+    }
+    @Test
+    fun testTimePack() = runTest {
+        initCrypto()
+        val t1 = nowToSeconds()
+        val t2 = t1 + 1.microseconds
+        assertEquals(t1, unpack<Instant>(pack(t2)))
+    }
+
+}

src/commonTest/kotlin/ToolsTest.kt

@@ -0,0 +1,20 @@
+import kotlinx.coroutines.test.runTest
+import net.sergeych.crypto2.createContrail
+import net.sergeych.crypto2.initCrypto
+import net.sergeych.crypto2.isValidContrail
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertFalse
+import kotlin.test.assertTrue
+
+class ToolsTest {
+    @Test
+    fun testContrails() = runTest {
+        initCrypto()
+        val c = createContrail(ubyteArrayOf(1u, 2u, 3u, 4u, 5u))
+        assertEquals(134u, c[0])
+        assertTrue { isValidContrail(c) }
+        c[2] = 11u
+        assertFalse { isValidContrail(c) }
+    }
+}

src/commonTest/kotlin/assertThrows.kt

@@ -0,0 +1,13 @@
+import kotlin.test.fail
+
+inline fun <reified T: Throwable>assertThrows(f: ()->Unit): T {
+    val name = T::class.simpleName
+    try {
+        f()
+        fail("expected to throw $name but threw nothing")
+    }
+    catch(x: Throwable) {
+        if( x is T ) return x
+        fail("expected to throw $name but instead threw ${x::class.simpleName}: $x")
+    }
+}