Switched app tests to kotlin.test

app/build.gradle.kts

@@ -35,7 +35,8 @@ dependencies {
     kover(projects.lib)
 
 //    testImplementation("com.willowtreeapps.assertk:assertk-jvm:0.25")
-    testImplementation("org.junit.jupiter:junit-jupiter:5.9.1")
+//    testImplementation("org.junit.jupiter:junit-jupiter:5.9.1")
+    testImplementation(kotlin("test"))
 }
 
 base {

app/src/test/kotlin/net/thauvin/erik/urlencoder/UrlEncoderTest.kt

@@ -19,64 +19,64 @@ package net.thauvin.erik.urlencoder
 
 import net.thauvin.erik.urlencoder.UrlEncoder.processMain
 import net.thauvin.erik.urlencoder.UrlEncoder.usage
-import org.junit.jupiter.api.Assertions.assertEquals
+import kotlin.test.Test
-import org.junit.jupiter.api.Assertions.assertThrows
+import kotlin.test.assertEquals
-import org.junit.jupiter.api.Test
+import kotlin.test.assertFailsWith
-import org.junit.jupiter.params.ParameterizedTest
-import org.junit.jupiter.params.provider.Arguments
-import org.junit.jupiter.params.provider.Arguments.arguments
-import org.junit.jupiter.params.provider.MethodSource
-import org.junit.jupiter.params.provider.ValueSource
-import java.util.stream.Stream
 
 class UrlEncoderTest {
-
     companion object {
         @JvmStatic
-        fun invalid() = arrayOf("sdkjfh%", "sdkjfh%6", "sdkjfh%xx", "sdfjfh%-1")
+        var invalid = arrayOf("sdkjfh%", "sdkjfh%6", "sdkjfh%xx", "sdfjfh%-1")
 
         @JvmStatic
-        fun validMap(): Stream<Arguments> = Stream.of(
+        var validMap = arrayOf(
-            arguments("a test &", "a%20test%20%26"),
+            Pair("a test &", "a%20test%20%26"),
-            arguments(
+            Pair(
                 "!abcdefghijklmnopqrstuvwxyz%%ABCDEFGHIJKLMNOPQRSTUVQXYZ0123456789-_.~=",
                 "%21abcdefghijklmnopqrstuvwxyz%25%25ABCDEFGHIJKLMNOPQRSTUVQXYZ0123456789-_.%7E%3D"
             ),
-            arguments("%#okékÉȢ smile!😁", "%25%23ok%C3%A9k%C3%89%C8%A2%20smile%21%F0%9F%98%81"),
+            Pair("%#okékÉȢ smile!😁", "%25%23ok%C3%A9k%C3%89%C8%A2%20smile%21%F0%9F%98%81"),
-            arguments(
+            Pair(
                 "\uD808\uDC00\uD809\uDD00\uD808\uDF00\uD808\uDD00", "%F0%92%80%80%F0%92%94%80%F0%92%8C%80%F0%92%84%80"
             )
         )
     }
 
-    @ParameterizedTest(name = "processMain(-d {1}) should be {0}")
+    @Test
-    @MethodSource("validMap")
+    fun `Main Decode`() {
-    fun `Main Decode`(expected: String, source: String) {
+        for (m in validMap) {
-        val result: UrlEncoder.MainResult = processMain(arrayOf("-d", source))
+            val result: UrlEncoder.MainResult = processMain(arrayOf("-d", m.second))
-        assertEquals(expected, result.output)
+            assertEquals(m.first, result.output)
-        assertEquals(0, result.status, "processMain(-d $source).status")
+            assertEquals(0, result.status, "processMain(-d ${m.second}).status")
+        }
     }
 
-    @ParameterizedTest(name = "processMain(-d {0})")
+    @Test
-    @MethodSource("invalid")
+    fun `Main Decode with Exception`() {
-    fun `Main Decode with Exception`(source: String) {
+        for (source in invalid) {
-        assertThrows(IllegalArgumentException::class.java, { processMain(arrayOf("-d", source)) }, source)
+            assertFailsWith<IllegalArgumentException>(
+                message = source,
+                block = { processMain(arrayOf("-d", source)) }
+            )
+        }
     }
 
-    @ParameterizedTest(name = "processMain(-e {0})")
+    @Test
-    @MethodSource("validMap")
+    fun `Main Encode`() {
-    fun `Main Encode`(source: String, expected: String) {
+        for (m in validMap) {
-        val result = processMain(arrayOf(source))
+            val result = processMain(arrayOf(m.first))
-        assertEquals(expected, result.output)
+            assertEquals(m.second, result.output)
-        assertEquals(0, result.status, "processMain(-e $source).status")
+            assertEquals(0, result.status, "processMain(-e ${m.first}).status")
+        }
     }
 
-    @ParameterizedTest(name = "processMain(-e {0})")
+    @Test
-    @MethodSource("validMap")
+    fun `Main Encode with Option`() {
-    fun `Main Encode with Option`(source: String, expected: String) {
+        for (m in validMap) {
-        val result = processMain(arrayOf("-e", source))
+            val result = processMain(arrayOf("-e", m.first))
-        assertEquals(expected, result.output)
+            assertEquals(m.second, result.output)
-        assertEquals(0, result.status, "processMain(-e $source).status")
+            assertEquals(0, result.status, "processMain(-e ${m.first}).status")
+        }
     }
 
 
@@ -90,13 +90,13 @@ class UrlEncoderTest {
         assertEquals(" ", processMain(arrayOf("-d", " ")).output, "processMain('-d', ' ')")
     }
 
-    @ParameterizedTest
+    @Test
-    @ValueSource(strings = ["", "-d", "-e"])
+    fun `Main Usage with Invalid arg`() {
-    fun `Main Usage with Invalid arg`(arg: String) {
+        for (arg in arrayOf("", "-d", "-e")) {
-        val result = processMain(arrayOf(arg))
+            val result = processMain(arrayOf(arg))
-        assertEquals(usage, result.output, "processMain('$arg')")
+            assertEquals(usage, result.output, "processMain('$arg')")
-        assertEquals(1, result.status, "processMain('$arg').status")
+            assertEquals(1, result.status, "processMain('$arg').status")
-    }
+        }}
 
     @Test
     fun `Main Usage with too Many Args`() {

buildSrc/src/main/kotlin/buildsrc/conventions/lang/kotlin-jvm.gradle.kts

@@ -34,7 +34,7 @@ tasks.withType<KotlinCompile>().configureEach {
 }
 
 tasks.withType<Test>().configureEach {
-    useJUnitPlatform()
+//    useJUnitPlatform()
 
     val testsBadgeApiKey = providers.gradleProperty("testsBadgeApiKey")
     addTestListener(Rife2TestListener(testsBadgeApiKey))

buildSrc/src/main/kotlin/buildsrc/conventions/lang/kotlin-multiplatform-base.gradle.kts

@@ -36,7 +36,7 @@ kotlin {
     targets.withType<KotlinJvmTarget>().configureEach {
         testRuns.configureEach {
             executionTask.configure {
-                useJUnitPlatform()
+                // useJUnitPlatform()
             }
         }
     }