Add tests

composeApp/build.gradle.kts

@@ -3,7 +3,6 @@ import org.jetbrains.kotlin.gradle.dsl.JvmTarget
 import org.jetbrains.kotlin.gradle.tasks.KotlinJvmCompile
 
 plugins {
-    alias(libs.plugins.jetbrainsKotlinJvm)
     alias(libs.plugins.kotlinMultiplatform)
     alias(libs.plugins.androidApplication)
     alias(libs.plugins.jetbrainsCompose)
@@ -20,6 +19,7 @@ kotlin {
     androidTarget()
     jvm("desktop")
 
+    @OptIn(org.jetbrains.compose.ExperimentalComposeLibrary::class)
     sourceSets {
         val androidUnitTest by getting
         val desktopMain by getting
@@ -42,18 +42,16 @@ kotlin {
             implementation(compose.desktop.currentOs)
         }
         androidUnitTest.dependencies {
-            implementation(kotlin("test"))
+            implementation(libs.kotlin.test)
+            implementation(compose.uiTest)
             implementation(libs.atrium)
         }
         commonTest.dependencies {
-            implementation(kotlin("test"))
+            implementation(libs.kotlin.test)
             implementation(libs.atrium)
-
-            @OptIn(org.jetbrains.compose.ExperimentalComposeLibrary::class)
-            implementation(compose.uiTest)
         }
         desktopTest.dependencies {
-            implementation(kotlin("test"))
+            implementation(libs.kotlin.test)
             implementation(libs.atrium)
             implementation(compose.desktop.uiTestJUnit4)
             implementation(compose.desktop.currentOs)

composeApp/src/commonMain/kotlin/domain/clues.kt

@@ -56,14 +56,16 @@ class TripletClue<C : ItemClass<C>>(val a: Item<C>, val b: Item<C>, val c: Item<
         val ib = grid.indexOf(bType)
         val ic = grid.indexOf(cType)
 
+        if (ib == 0 || ib == grid.size) {
+            return true
+        }
+
         if (ia == -1 && ic == -1) {
             return false
         }
 
         if (ia != -1 && ic != -1) {
-            if (ia + 2 == ic || ia == ic + 2) {
-                return true
-            }
+            return !(ia + 2 == ic || ia == ic + 2)
         }
 
         if (isNeighbourRuleViolated(ia, ib) || isNeighbourRuleViolated(ib, ic)) {

composeApp/src/commonTest/kotlin/domain/ClueTest.kt

@@ -0,0 +1,25 @@
+package domain
+
+abstract class ClueTest {
+    protected val size = 6
+
+    protected fun createGrid(selection: (Item<ItemClass<*>>) -> Item<ItemClass<*>>? = { it }) = Grid(
+        ItemClass.randomClasses(size)
+            .map {
+                it.randomItems(size).map { item -> Item(item) }
+            }
+            .map { row ->
+                GameRow(
+                    category = row.first().itemType.companion,
+                    options = row,
+                    cells = row.map {
+                        GameCell(
+                            selection = selection(it),
+                            solution = it,
+                            options = mutableListOf()
+                        )
+                    }
+                )
+            }
+    )
+}

composeApp/src/commonTest/kotlin/domain/NeighbourClueTest.kt

@@ -1,36 +1,94 @@
 package domain
 
-import ch.tutteli.atrium.api.fluent.en_GB.feature
-import ch.tutteli.atrium.api.fluent.en_GB.size
-import ch.tutteli.atrium.api.fluent.en_GB.toBeLessThan
 import ch.tutteli.atrium.api.fluent.en_GB.toEqual
-import ch.tutteli.atrium.api.fluent.en_GB.toHaveSize
 import ch.tutteli.atrium.api.verbs.expect
-import domain.Item
 import kotlin.test.Test
 
-class NeighbourClueTest {
+class NeighbourClueTest : ClueTest() {
+
     @Test
     fun `ensure actual neighbours are valid`() {
-        val size = 5
-        val grid = ItemClass.randomClasses(size)
-            .map {
-                it.randomItems(size).map { item -> Item(item) }
-            }
-            .map { row ->
-                GameRow(
-                    category = row.first().itemType.companion,
-                    options = row,
-                    cells = row.map {
-                        GameCell(
-                            selection = it,
-                            solution = it,
-                            options = mutableListOf()
-                        )
-                    }
-                )
-            }
+        val grid = createGrid()
+        for (ia in 0 until size) {
+            for (ib in 0 until size) {
+                for (j in 1 until size) {
+                    val a = grid[ia][j - 1]
+                    val b = grid[ib][j]
 
-        NeighbourClue(Item(Animals.ANT), Item(Profession.ASTRONAUT))
+                    expect(NeighbourClue(a.solution, b.solution).isRuleViolated(grid))
+                        .toEqual(false)
+                    expect(NeighbourClue(b.solution, a.solution).isRuleViolated(grid))
+                        .toEqual(false)
+                }
+            }
+        }
     }
+
+    @Test
+    fun `ensure non-neighbours are invalid`() {
+        val grid = createGrid()
+        for (ia in 0 until size) {
+            for (ib in 0 until size) {
+                for (ja in 0 until size) {
+                    for (jb in 0 until size) {
+                        if (ja == jb + 1 || ja == jb - 1) {
+                            continue
+                        }
+                        val a = grid[ia][ja]
+                        val b = grid[ib][jb]
+
+                        expect(NeighbourClue(a.solution, b.solution).isRuleViolated(grid))
+                            .toEqual(true)
+                        expect(NeighbourClue(b.solution, a.solution).isRuleViolated(grid))
+                            .toEqual(true)
+                    }
+                }
+            }
+        }
+    }
+
+    @Test
+    fun `ensure grid with one neighbour not set is considered valid`() {
+        val grid = createGrid()
+        for (ia in 0 until size) {
+            for (ib in 0 until size) {
+                for (j in 1 until size) {
+                    val a = grid[ia][j - 1]
+                    val b = grid[ib][j]
+
+                    a.selection = null
+                    b.selection = b.solution
+
+                    expect(NeighbourClue(a.solution, b.solution).isRuleViolated(grid))
+                        .toEqual(false)
+                    expect(NeighbourClue(b.solution, a.solution).isRuleViolated(grid))
+                        .toEqual(false)
+
+                    a.selection = a.solution
+                    b.selection = null
+
+                    expect(NeighbourClue(a.solution, b.solution).isRuleViolated(grid))
+                        .toEqual(false)
+                    expect(NeighbourClue(b.solution, a.solution).isRuleViolated(grid))
+                        .toEqual(false)
+                }
+            }
+        }
+    }
+
+    @Test
+    fun `ensure grid with a and c more than one cell between is not considered valid`() {
+        val grid = createGrid { null }
+        val a = grid[2][1]
+        val b = grid[0][2]
+
+        a.selection = a.solution
+        grid[0][3].selection = b.solution
+
+        expect(NeighbourClue(a.solution, b.solution).isRuleViolated(grid))
+            .toEqual(true)
+        expect(NeighbourClue(b.solution, a.solution).isRuleViolated(grid))
+            .toEqual(true)
+    }
+
 }

composeApp/src/commonTest/kotlin/domain/OrderClueTest.kt

@@ -0,0 +1,28 @@
+package domain
+
+import ch.tutteli.atrium.api.fluent.en_GB.toEqual
+import ch.tutteli.atrium.api.verbs.expect
+import kotlin.test.Test
+
+class OrderClueTest : ClueTest() {
+    @Test
+    fun `ensure items in correct order are valid`() {
+        val grid = createGrid()
+        for (ia in 0 until size) {
+            for (ib in 0 until size) {
+                for (ic in 0 until size) {
+                    for (ja in 0 until size - 1) {
+                        for (jb in ja + 1 until size) {
+                            val a = grid[ia][ja]
+                            val b = grid[ib][jb]
+
+                            expect(OrderClue(a.solution, b.solution).isRuleViolated(grid))
+                                .toEqual(false)
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+}

composeApp/src/commonTest/kotlin/domain/TripletClueTest.kt

@@ -0,0 +1,46 @@
+package domain
+
+import ch.tutteli.atrium.api.fluent.en_GB.toEqual
+import ch.tutteli.atrium.api.verbs.expect
+import kotlin.test.Test
+
+class TripletClueTest : ClueTest() {
+
+    @Test
+    fun `ensure actual triplets are valid`() {
+        val grid = createGrid()
+        for (ia in 0 until size) {
+            for (ib in 0 until size) {
+                for (ic in 0 until size) {
+                    for (j in 2 until size) {
+                        val a = grid[ia][j - 2]
+                        val b = grid[ib][j - 1]
+                        val c = grid[ic][j]
+
+                        expect(TripletClue(a.solution, b.solution, c.solution).isRuleViolated(grid))
+                            .toEqual(false)
+                        expect(TripletClue(a.solution, b.solution, c.solution).isRuleViolated(grid))
+                            .toEqual(false)
+                    }
+                }
+            }
+        }
+    }
+
+    @Test
+    fun `ensure grid with a and c more than one cell between is not considered valid`() {
+        val grid = createGrid { null }
+        val a = grid[2][1]
+        val b = grid[0][2]
+        val c = grid[1][3]
+
+        a.selection = a.solution
+        grid[1][4].selection = c.solution
+
+        expect(TripletClue(a.solution, b.solution, c.solution).isRuleViolated(grid))
+            .toEqual(true)
+        expect(TripletClue(a.solution, b.solution, c.solution).isRuleViolated(grid))
+            .toEqual(true)
+    }
+
+}