Improvements

try to make it run on Android (still unsuccessful)

domain/build.gradle.kts

@@ -1,43 +1,38 @@
-import org.jetbrains.kotlin.gradle.dsl.JvmTarget
-import org.jetbrains.kotlin.gradle.tasks.KotlinJvmCompile
-
 plugins {
     alias(libs.plugins.kotlin.multiplatform)
     alias(libs.plugins.android.library)
 }
 
 kotlin {
-    jvm{
-        tasks.withType<KotlinJvmCompile>().configureEach {
-            compilerOptions {
-                jvmTarget.set(JvmTarget.JVM_17)
-            }
-        }
-    }
+    jvmToolchain(libs.versions.jdk.get().toInt())
 
-    androidTarget{
-        tasks.withType<KotlinJvmCompile>().configureEach {
-            compilerOptions {
-                jvmTarget.set(JvmTarget.JVM_11)
-            }
-        }
-    }
+    jvm()
+    androidTarget()
 
-    android.apply {
-        compileSdk = libs.versions.android.compileSdk.get().toInt()
-        namespace = "ch.dissem.yaep.domain"
-        compileOptions {
-            sourceCompatibility = JavaVersion.VERSION_11
-            targetCompatibility = JavaVersion.VERSION_11
-        }
-    }
+//    @OptIn(ExperimentalWasmDsl::class)
+//    wasmJs {
+//        moduleName = "yaep-commonUI"
+//        browser()
+//        binaries.executable()
+//    }
 
     sourceSets {
-        val commonTest by getting {
+        commonMain {
+            dependencies {
+                implementation(libs.logging)
+            }
+        }
+
+        commonTest {
             dependencies {
                 implementation(libs.kotlin.test)
                 implementation(libs.atrium)
             }
         }
     }
+}
+
+android {
+    compileSdk = libs.versions.android.compileSdk.get().toInt()
+    namespace = "ch.dissem.yaep.domain"
 }

domain/src/commonTest/kotlin/ch/dissem/yaep/domain/GameTest.kt

@@ -9,6 +9,7 @@ import ch.tutteli.atrium.api.fluent.en_GB.toBeGreaterThan
 import ch.tutteli.atrium.api.fluent.en_GB.toBeLessThan
 import ch.tutteli.atrium.api.fluent.en_GB.toEqual
 import ch.tutteli.atrium.api.verbs.expect
+import co.touchlab.kermit.Logger
 import kotlin.test.Test
 import kotlin.time.Duration.Companion.milliseconds
 import kotlin.time.measureTime
@@ -17,7 +18,7 @@ class GameTest {
 
     @Test
     fun `ensure generated games are solvable`() {
-        val tries = 2000
+        val tries = 1000
         var fastest = 500.milliseconds
         var slowest = 0.milliseconds
         var total = 0.milliseconds
@@ -29,10 +30,10 @@ class GameTest {
             val time = measureTime {
                 game = generateGame()
             }
-            println("Generated game #$i in ${time.inWholeMilliseconds}ms")
+            Logger.i { "Generated game #$i in ${time.inWholeMilliseconds}ms" }
             val solvable = solve(game.grid, game.clues)
             if (solvable != SOLVABLE) {
-                println("Puzzle:\n$game")
+                Logger.i { "Puzzle:\n$game" }
             }
             expect(solvable).toEqual(SOLVABLE)
             expect(time).toBeLessThan(500.milliseconds)
@@ -43,22 +44,22 @@ class GameTest {
                 slowest = time
             }
             total += time
-            if (game.clues.size > most){
+            if (game.clues.size > most) {
                 most = game.clues.size
             }
-            if (game.clues.size < least){
+            if (game.clues.size < least) {
                 least = game.clues.size
             }
             totalClues += game.clues.size
         }
 
-        println("Slowest: $slowest")
-        println("Fastest: $fastest")
-        println("Average: ${total / tries}")
-        println("Clues:")
-        println("Most: $most")
-        println("Least: $least")
-        println("Average: ${totalClues / tries}")
+        Logger.i { "Slowest: $slowest" }
+        Logger.i { "Fastest: $fastest" }
+        Logger.i { "Average: ${total / tries}" }
+        Logger.i { "Clues:" }
+        Logger.i { "Most: $most" }
+        Logger.i { "Least: $least" }
+        Logger.i { "Average: ${totalClues / tries}" }
     }
 
     @Test
@@ -75,8 +76,8 @@ class GameTest {
                 feature(Collection<Clue>::size).toBeLessThan(30)
             }
         }
-        println("Clues: ${game.clues.size}")
-        println("Time: $time")
+        Logger.i{"Clues: ${game.clues.size}"}
+        Logger.i{"Time: $time"}
         expect(solve(game.grid, game.clues)).toEqual(SOLVABLE)
         expect(time).toBeLessThan(500.milliseconds)
     }
@@ -130,7 +131,8 @@ class GameTest {
 
     @Test
     fun `ensure specific game is solvable`() {
-        val game = Game.parse("""
+        val game = Game.parse(
+            """
             👩🏿‍⚕️👨🏽‍🎤👩🏿‍⚕️  👩🏾‍🚀🧑🏿‍🏫
             🐜🐕  🐐  🐐
             🍉🥭🍐🍇🍍  
@@ -162,7 +164,8 @@ class GameTest {
             * ROCK_STAR and UNITED_KINGDOM are in the same column
             * ROCK_STAR is next to DOUGHNUT
             * PINEAPPLE is between the neighbours TEACHER and GRAPES to both sides
-        """.trimIndent())
+        """.trimIndent()
+        )
 
         expect(solve(game.grid, game.clues)).toEqual(SOLVABLE)
     }