Allow MutableRingList to become empty

* Introducing an explicit EmptyNode allows to get rid of one `lateinit`
* make size's getter public and add some assertions in the tests
* add tests for some exceptional cases

Author: rhaendel

src/main/kotlin/de/ronny_h/aoc/extensions/collections/MutableRingList.kt

@@ -3,13 +3,15 @@ package de.ronny_h.aoc.extensions.collections
 import kotlin.math.abs
 
 class MutableRingList<T>() {
-    private data class Node<T>(var value: T) {
-        lateinit var prev: Node<T>
-        lateinit var next: Node<T>
+    private interface Node<T> {
+        var value: T
+        var prev: Node<T>
+        var next: Node<T>
     }
 
-    private lateinit var head: Node<T>
-    private var size = 0
+    private var head: Node<T> = EmptyNode()
+    var size = 0
+        private set
 
     constructor(initialList: List<T>) : this() {
         initialList.forEach { add(it) }
@@ -56,8 +58,12 @@ class MutableRingList<T>() {
             throw IndexOutOfBoundsException("Unable to remove an element from an empty list.")
         }
         size--
-        val node = head.next
         val removed = head.value
+        if (size == 0) {
+            head = EmptyNode()
+            return removed
+        }
+        val node = head.next
         node.prev = head.prev
         node.prev.next = node
         head = node
@@ -139,12 +145,12 @@ class MutableRingList<T>() {
     }
 
     private fun addAsLast(value: T): Node<T> {
-        val newNode = Node(value)
+        val newNode = NodeWithValue(value)
         size++
-        if (this::head.isInitialized) {
-            insertBefore(head, newNode)
-        } else {
+        if (head is EmptyNode) {
             initHead(newNode)
+        } else {
+            insertBefore(head, newNode)
         }
         return newNode
     }
@@ -182,4 +188,21 @@ class MutableRingList<T>() {
         }
         return node
     }
+
+    private data class NodeWithValue<T>(override var value: T) : Node<T> {
+        override lateinit var prev: Node<T>
+        override lateinit var next: Node<T>
+    }
+
+    private class EmptyNode<T>() : Node<T> {
+        override var value: T
+            get() = throw IllegalStateException("An EmptyNode has no value.")
+            set(_) = throw IllegalStateException("An EmptyNode has no value.")
+        override var prev: Node<T>
+            get() = this
+            set(_) = throw IllegalStateException("Setting prev of an EmptyNode is not allowed.")
+        override var next: Node<T>
+            get() = this
+            set(_) = throw IllegalStateException("Setting next of an EmptyNode is not allowed.")
+    }
 }

src/test/kotlin/de/ronny_h/aoc/extensions/collections/MutableRingListTest.kt

@@ -1,7 +1,10 @@
 package de.ronny_h.aoc.extensions.collections
 
 import de.ronny_h.aoc.extensions.collections.MutableRingList.Companion.mutableRingListOf
+import io.kotest.assertions.throwables.shouldThrow
 import io.kotest.core.spec.style.StringSpec
+import io.kotest.data.forAll
+import io.kotest.data.row
 import io.kotest.matchers.shouldBe
 
 class MutableRingListTest : StringSpec({
@@ -15,7 +18,25 @@ class MutableRingListTest : StringSpec({
     }
 
     "a MutableRingList can be created with an initializer function" {
-        MutableRingList(6) { it }.toJoinedString() shouldBe "012345"
+        forAll(
+            row(0, ""),
+            row(1, "0"),
+            row(6, "012345"),
+        ) { size, string ->
+            val list = MutableRingList(size) { it }
+            list.size shouldBe size
+            list.toJoinedString() shouldBe string
+        }
+    }
+
+    "the size of a MutableRingList" {
+        forAll(
+            row("", 0),
+            row("a", 1),
+            row("abcdef", 6),
+        ) { data, size ->
+            mutableRingListOf(data).size shouldBe size
+        }
     }
 
     "get(index) returns the element at index" {
@@ -73,6 +94,25 @@ class MutableRingListTest : StringSpec({
         list.toJoinedString() shouldBe "eabc"
     }
 
+    "removeFirst that makes a list of size 1 empty" {
+        val list = mutableRingListOf("a")
+
+        list.size shouldBe 1
+        list.removeFirst() shouldBe 'a'
+        list.size shouldBe 0
+        list.toJoinedString() shouldBe ""
+
+        list.add('b')
+        list.size shouldBe 1
+        list.toJoinedString() shouldBe "b"
+    }
+
+    "removeFirst fails on an empty list" {
+        shouldThrow<IndexOutOfBoundsException> {
+            mutableRingListOf("").removeFirst()
+        }
+    }
+
     "shiftRight() moves elements from the end to the front" {
         mutableRingListOf("abcde").shiftRight(1).toJoinedString() shouldBe "eabcd"
 
@@ -133,6 +173,13 @@ class MutableRingListTest : StringSpec({
         mutableRingListOf("abcde").swap('c', 'c').toJoinedString() shouldBe "abcde"
     }
 
+    "swap with a non-existent value terminates with an error" {
+        val exception = shouldThrow<IllegalArgumentException> {
+            mutableRingListOf("abc").swap('a', 'd')
+        }
+        exception.message shouldBe "d is not in the list"
+    }
+
     "reversSubList on an unmodified ringList" {
         mutableRingListOf(1, 2, 3, 4, 5, 6).reverseSubList(1, 3).toList() shouldBe listOf(1, 4, 3, 2, 5, 6)
         mutableRingListOf(1, 2, 3, 4, 5, 6).reverseSubList(1, 4).toList() shouldBe listOf(1, 5, 4, 3, 2, 6)