From 12e7d79863b0da4eaba84225f3adcd3c755edbe0 Mon Sep 17 00:00:00 2001 From: Daan Vanden Bosch Date: Sat, 19 Jun 2021 10:04:06 +0200 Subject: [PATCH] Improvements to several observables and more unit tests. --- FEATURES.md | 10 ++ .../cell/list/AbstractDependentListCell.kt | 33 ++++- .../observable/cell/list/FilteredListCell.kt | 14 +- .../observable/cell/list/ListCellCreation.kt | 5 + .../observable/cell/list/ListWrapper.kt | 30 ----- .../observable/cell/list/SimpleListCell.kt | 62 +++++---- .../phantasmal/observable/DependencyTests.kt | 47 +++++++ .../phantasmal/observable/ObservableTests.kt | 9 +- .../observable/cell/DependentCellTests.kt | 6 +- .../cell/list/DependentListCellTests.kt | 8 +- .../cell/list/FilteredListCellTests.kt | 6 +- ...ndentListCellDirectDependencyEmitsTests.kt | 8 +- ...tListCellTransitiveDependencyEmitsTests.kt | 4 +- .../cell/list/ListCellCreationTests.kt | 17 +++ .../cell/list/SimpleListCellTests.kt | 120 ++++++++++++++++-- .../world/phantasmal/observable/test/Utils.kt | 10 ++ 16 files changed, 285 insertions(+), 104 deletions(-) delete mode 100644 observable/src/commonMain/kotlin/world/phantasmal/observable/cell/list/ListWrapper.kt create mode 100644 observable/src/commonTest/kotlin/world/phantasmal/observable/DependencyTests.kt create mode 100644 observable/src/commonTest/kotlin/world/phantasmal/observable/cell/list/ListCellCreationTests.kt create mode 100644 observable/src/commonTest/kotlin/world/phantasmal/observable/test/Utils.kt diff --git a/FEATURES.md b/FEATURES.md index cd973a63..22dd4175 100644 --- a/FEATURES.md +++ b/FEATURES.md @@ -157,6 +157,16 @@ Features that are in ***bold italics*** are planned but not yet implemented. - ***Support different sets of instructions (older versions had no stack)*** +## Verification/Warnings + +- ***Entities with nonexistent event section*** +- ***Entities with wave that's never triggered*** +- ***Duplicate event IDs*** +- ***Events with nonexistent event section*** +- ***Event waves with no enemies*** +- ***Events that trigger nonexistent events*** +- ***Events that lock/unlock nonexistent doors*** + ## Bugs - When a modal dialog is open, global keybindings should be disabled diff --git a/observable/src/commonMain/kotlin/world/phantasmal/observable/cell/list/AbstractDependentListCell.kt b/observable/src/commonMain/kotlin/world/phantasmal/observable/cell/list/AbstractDependentListCell.kt index be93e940..3934ed6d 100644 --- a/observable/src/commonMain/kotlin/world/phantasmal/observable/cell/list/AbstractDependentListCell.kt +++ b/observable/src/commonMain/kotlin/world/phantasmal/observable/cell/list/AbstractDependentListCell.kt @@ -1,13 +1,13 @@ package world.phantasmal.observable.cell.list import world.phantasmal.core.disposable.Disposable +import world.phantasmal.core.unsafe.unsafeAssertNotNull import world.phantasmal.observable.CallbackObserver import world.phantasmal.observable.Dependent import world.phantasmal.observable.Observer import world.phantasmal.observable.cell.AbstractDependentCell import world.phantasmal.observable.cell.Cell import world.phantasmal.observable.cell.DependentCell -import world.phantasmal.observable.cell.not abstract class AbstractDependentListCell : AbstractDependentCell>(), @@ -25,12 +25,35 @@ abstract class AbstractDependentListCell : return elements } - @Suppress("LeakingThis") - final override val size: Cell = DependentCell(this) { elements.size } + private var _size: Cell? = null + final override val size: Cell + get() { + if (_size == null) { + _size = DependentCell(this) { value.size } + } - final override val empty: Cell = size.map { it == 0 } + return unsafeAssertNotNull(_size) + } - final override val notEmpty: Cell = !empty + private var _empty: Cell? = null + final override val empty: Cell + get() { + if (_empty == null) { + _empty = DependentCell(this) { value.isEmpty() } + } + + return unsafeAssertNotNull(_empty) + } + + private var _notEmpty: Cell? = null + final override val notEmpty: Cell + get() { + if (_notEmpty == null) { + _notEmpty = DependentCell(this) { value.isNotEmpty() } + } + + return unsafeAssertNotNull(_notEmpty) + } final override fun observe(callNow: Boolean, observer: Observer>): Disposable = observeList(callNow, observer as ListObserver) diff --git a/observable/src/commonMain/kotlin/world/phantasmal/observable/cell/list/FilteredListCell.kt b/observable/src/commonMain/kotlin/world/phantasmal/observable/cell/list/FilteredListCell.kt index 878d55cb..10a9ef26 100644 --- a/observable/src/commonMain/kotlin/world/phantasmal/observable/cell/list/FilteredListCell.kt +++ b/observable/src/commonMain/kotlin/world/phantasmal/observable/cell/list/FilteredListCell.kt @@ -14,7 +14,7 @@ class FilteredListCell( */ private val indexMap = mutableListOf() - private var elements: ListWrapper = ListWrapper(mutableListOf()) + private val elements = mutableListOf() override val value: List get() { @@ -125,7 +125,7 @@ class FilteredListCell( } } - elements = elements.mutate { add(insertIndex, change.updated) } + elements.add(insertIndex, change.updated) indexMap[change.index] = insertIndex for (depIdx in (change.index + 1)..indexMap.lastIndex) { @@ -151,7 +151,7 @@ class FilteredListCell( if (index != -1) { // If the element now doesn't pass the test and it previously did // pass, remove it and emit a structural change. - elements = elements.mutate { removeAt(index) } + elements.removeAt(index) indexMap[change.index] = -1 for (depIdx in (change.index + 1)..indexMap.lastIndex) { @@ -195,18 +195,16 @@ class FilteredListCell( } private fun recompute() { - val newElements = mutableListOf() + elements.clear() indexMap.clear() dependency.value.forEach { element -> if (predicate(element)) { - newElements.add(element) - indexMap.add(newElements.lastIndex) + elements.add(element) + indexMap.add(elements.lastIndex) } else { indexMap.add(-1) } } - - elements = ListWrapper(newElements) } } diff --git a/observable/src/commonMain/kotlin/world/phantasmal/observable/cell/list/ListCellCreation.kt b/observable/src/commonMain/kotlin/world/phantasmal/observable/cell/list/ListCellCreation.kt index f4e678a2..997645c1 100644 --- a/observable/src/commonMain/kotlin/world/phantasmal/observable/cell/list/ListCellCreation.kt +++ b/observable/src/commonMain/kotlin/world/phantasmal/observable/cell/list/ListCellCreation.kt @@ -14,6 +14,11 @@ fun mutableListCell( ): MutableListCell = SimpleListCell(mutableListOf(*elements), extractDependencies) +fun Cell.flatMapToList( + transform: (T) -> ListCell, +): ListCell = + FlatteningDependentListCell(this) { transform(value) } + fun flatMapToList( c1: Cell, c2: Cell, diff --git a/observable/src/commonMain/kotlin/world/phantasmal/observable/cell/list/ListWrapper.kt b/observable/src/commonMain/kotlin/world/phantasmal/observable/cell/list/ListWrapper.kt deleted file mode 100644 index cfc6b434..00000000 --- a/observable/src/commonMain/kotlin/world/phantasmal/observable/cell/list/ListWrapper.kt +++ /dev/null @@ -1,30 +0,0 @@ -package world.phantasmal.observable.cell.list - -import kotlin.contracts.InvocationKind -import kotlin.contracts.contract - -/** - * ListWrapper is used to ensure that ListCell.value of some implementations references a new object - * after every change to the ListCell. This is done to honor the contract that emission of a - * ChangeEvent implies that Cell.value is no longer equal to the previous value. - * When a change is made to the ListCell, the underlying list of ListWrapper is usually mutated and - * then a new wrapper is created that points to the same underlying list. - */ -internal class ListWrapper(private val mut: MutableList) : List by mut { - inline fun mutate(mutator: MutableList.() -> Unit): ListWrapper { - contract { callsInPlace(mutator, InvocationKind.EXACTLY_ONCE) } - mut.mutator() - return ListWrapper(mut) - } - - override fun equals(other: Any?): Boolean { - if (this === other) return true - // If other is also a ListWrapper but it's not the exact same object then it's not equal. - if (other == null || this::class == other::class || other !is List<*>) return false - // If other is a list but not a ListWrapper, call its equals method for a structured - // comparison. - return other == this - } - - override fun hashCode(): Int = mut.hashCode() -} diff --git a/observable/src/commonMain/kotlin/world/phantasmal/observable/cell/list/SimpleListCell.kt b/observable/src/commonMain/kotlin/world/phantasmal/observable/cell/list/SimpleListCell.kt index 86e94a1a..d61622e4 100644 --- a/observable/src/commonMain/kotlin/world/phantasmal/observable/cell/list/SimpleListCell.kt +++ b/observable/src/commonMain/kotlin/world/phantasmal/observable/cell/list/SimpleListCell.kt @@ -1,11 +1,12 @@ package world.phantasmal.observable.cell.list import world.phantasmal.core.disposable.Disposable +import world.phantasmal.core.replaceAll import world.phantasmal.core.unsafe.unsafeAssertNotNull import world.phantasmal.observable.ChangeEvent +import world.phantasmal.observable.ChangeManager import world.phantasmal.observable.Dependency import world.phantasmal.observable.Dependent -import world.phantasmal.observable.ChangeManager typealias DependenciesExtractor = (element: E) -> Array @@ -16,12 +17,10 @@ typealias DependenciesExtractor = (element: E) -> Array * event. */ class SimpleListCell( - elements: MutableList, + private val elements: MutableList, private val extractDependencies: DependenciesExtractor? = null, ) : AbstractListCell(), MutableListCell { - private var elements = ListWrapper(elements) - /** * Dependents of dependencies related to this list's elements. Allows us to propagate changes to * elements via [ListChangeEvent]s. @@ -43,10 +42,9 @@ class SimpleListCell( checkIndex(index, elements.lastIndex) emitMightChange() - val removed: E - elements = elements.mutate { removed = set(index, element) } + val removed = elements.set(index, element) - if (extractDependencies != null) { + if (dependents.isNotEmpty() && extractDependencies != null) { elementDependents[index].dispose() elementDependents[index] = ElementDependent(index, element) } @@ -61,7 +59,7 @@ class SimpleListCell( emitMightChange() val index = elements.size - elements = elements.mutate { add(index, element) } + elements.add(element) finalizeStructuralChange(index, emptyList(), listOf(element)) } @@ -70,7 +68,7 @@ class SimpleListCell( checkIndex(index, elements.size) emitMightChange() - elements = elements.mutate { add(index, element) } + elements.add(index, element) finalizeStructuralChange(index, emptyList(), listOf(element)) } @@ -90,8 +88,7 @@ class SimpleListCell( checkIndex(index, elements.lastIndex) emitMightChange() - val removed: E - elements = elements.mutate { removed = removeAt(index) } + val removed = elements.removeAt(index) finalizeStructuralChange(index, listOf(removed), emptyList()) return removed @@ -100,30 +97,32 @@ class SimpleListCell( override fun replaceAll(elements: Iterable) { emitMightChange() - val removed = this.elements - this.elements = ListWrapper(elements.toMutableList()) + val removed = ArrayList(this.elements) + this.elements.replaceAll(elements) - finalizeStructuralChange(0, removed, this.elements) + finalizeStructuralChange(0, removed, ArrayList(this.elements)) } override fun replaceAll(elements: Sequence) { emitMightChange() - val removed = this.elements - this.elements = ListWrapper(elements.toMutableList()) + val removed = ArrayList(this.elements) + this.elements.replaceAll(elements) - finalizeStructuralChange(0, removed, this.elements) + finalizeStructuralChange(0, removed, ArrayList(this.elements)) } override fun splice(fromIndex: Int, removeCount: Int, newElement: E) { - val removed = ArrayList(elements.subList(fromIndex, fromIndex + removeCount)) + val removed = ArrayList(removeCount) + + for (i in fromIndex until (fromIndex + removeCount)) { + removed.add(elements[i]) + } emitMightChange() - elements = elements.mutate { - repeat(removeCount) { removeAt(fromIndex) } - add(fromIndex, newElement) - } + repeat(removeCount) { elements.removeAt(fromIndex) } + elements.add(fromIndex, newElement) finalizeStructuralChange(fromIndex, removed, listOf(newElement)) } @@ -131,8 +130,8 @@ class SimpleListCell( override fun clear() { emitMightChange() - val removed = elements - elements = ListWrapper(mutableListOf()) + val removed = ArrayList(this.elements) + elements.clear() finalizeStructuralChange(0, removed, emptyList()) } @@ -140,15 +139,16 @@ class SimpleListCell( override fun sortWith(comparator: Comparator) { emitMightChange() + val removed = ArrayList(elements) var throwable: Throwable? = null try { - elements = elements.mutate { sortWith(comparator) } + elements.sortWith(comparator) } catch (e: Throwable) { throwable = e } - finalizeStructuralChange(0, elements, elements) + finalizeStructuralChange(0, removed, ArrayList(elements)) if (throwable != null) { throw throwable @@ -178,11 +178,9 @@ class SimpleListCell( } override fun emitDependencyChanged() { - try { - emitDependencyChanged(ListChangeEvent(elements, changes)) - } finally { - changes = mutableListOf() - } + val currentChanges = changes + changes = mutableListOf() + emitDependencyChanged(ListChangeEvent(elements, currentChanges)) } private fun checkIndex(index: Int, maxIndex: Int) { @@ -194,7 +192,7 @@ class SimpleListCell( } private fun finalizeStructuralChange(index: Int, removed: List, inserted: List) { - if (extractDependencies != null) { + if (dependents.isNotEmpty() && extractDependencies != null) { repeat(removed.size) { elementDependents.removeAt(index).dispose() } diff --git a/observable/src/commonTest/kotlin/world/phantasmal/observable/DependencyTests.kt b/observable/src/commonTest/kotlin/world/phantasmal/observable/DependencyTests.kt new file mode 100644 index 00000000..fcd1c993 --- /dev/null +++ b/observable/src/commonTest/kotlin/world/phantasmal/observable/DependencyTests.kt @@ -0,0 +1,47 @@ +package world.phantasmal.observable + +import world.phantasmal.observable.test.ObservableTestSuite +import kotlin.test.* + +interface DependencyTests : ObservableTestSuite { + fun createProvider(): Provider + + @Test + fun correctly_emits_changes_to_its_dependents() = test { + val p = createProvider() + var dependencyMightChangeCalled = false + var dependencyChangedCalled = false + + p.dependency.addDependent(object : Dependent { + override fun dependencyMightChange() { + assertFalse(dependencyMightChangeCalled) + assertFalse(dependencyChangedCalled) + dependencyMightChangeCalled = true + } + + override fun dependencyChanged(dependency: Dependency, event: ChangeEvent<*>?) { + assertTrue(dependencyMightChangeCalled) + assertFalse(dependencyChangedCalled) + assertEquals(p.dependency, dependency) + assertNotNull(event) + dependencyChangedCalled = true + } + }) + + repeat(5) { index -> + dependencyMightChangeCalled = false + dependencyChangedCalled = false + + p.emit() + + assertTrue(dependencyMightChangeCalled, "repetition $index") + assertTrue(dependencyChangedCalled, "repetition $index") + } + } + + interface Provider { + val dependency: Dependency + + fun emit() + } +} diff --git a/observable/src/commonTest/kotlin/world/phantasmal/observable/ObservableTests.kt b/observable/src/commonTest/kotlin/world/phantasmal/observable/ObservableTests.kt index d8d4b409..0a4f2fd3 100644 --- a/observable/src/commonTest/kotlin/world/phantasmal/observable/ObservableTests.kt +++ b/observable/src/commonTest/kotlin/world/phantasmal/observable/ObservableTests.kt @@ -1,6 +1,5 @@ package world.phantasmal.observable -import world.phantasmal.observable.test.ObservableTestSuite import kotlin.test.Test import kotlin.test.assertEquals @@ -8,8 +7,8 @@ import kotlin.test.assertEquals * Test suite for all [Observable] implementations. There is a subclass of this suite for every * [Observable] implementation. */ -interface ObservableTests : ObservableTestSuite { - fun createProvider(): Provider +interface ObservableTests : DependencyTests { + override fun createProvider(): Provider @Test fun calls_observers_when_events_are_emitted() = test { @@ -55,9 +54,9 @@ interface ObservableTests : ObservableTestSuite { assertEquals(1, changes) } - interface Provider { + interface Provider : DependencyTests.Provider { val observable: Observable<*> - fun emit() + override val dependency: Dependency get() = observable } } diff --git a/observable/src/commonTest/kotlin/world/phantasmal/observable/cell/DependentCellTests.kt b/observable/src/commonTest/kotlin/world/phantasmal/observable/cell/DependentCellTests.kt index d4630c12..d48da842 100644 --- a/observable/src/commonTest/kotlin/world/phantasmal/observable/cell/DependentCellTests.kt +++ b/observable/src/commonTest/kotlin/world/phantasmal/observable/cell/DependentCellTests.kt @@ -9,12 +9,12 @@ class DependentCellTests : RegularCellTests, CellWithDependenciesTests { } class Provider : CellTests.Provider, CellWithDependenciesTests.Provider { - private val dependency = SimpleCell(1) + private val dependencyCell = SimpleCell(1) - override val observable = DependentCell(dependency) { 2 * dependency.value } + override val observable = DependentCell(dependencyCell) { 2 * dependencyCell.value } override fun emit() { - dependency.value += 2 + dependencyCell.value += 2 } override fun createWithDependencies(vararg dependencies: Cell) = diff --git a/observable/src/commonTest/kotlin/world/phantasmal/observable/cell/list/DependentListCellTests.kt b/observable/src/commonTest/kotlin/world/phantasmal/observable/cell/list/DependentListCellTests.kt index d06c89c5..56dc3a6b 100644 --- a/observable/src/commonTest/kotlin/world/phantasmal/observable/cell/list/DependentListCellTests.kt +++ b/observable/src/commonTest/kotlin/world/phantasmal/observable/cell/list/DependentListCellTests.kt @@ -9,12 +9,14 @@ class DependentListCellTests : ListCellTests, CellWithDependenciesTests { override fun createListProvider(empty: Boolean) = Provider(empty) class Provider(empty: Boolean) : ListCellTests.Provider, CellWithDependenciesTests.Provider { - private val dependency = SimpleListCell(if (empty) mutableListOf() else mutableListOf(5)) + private val dependencyCell = + SimpleListCell(if (empty) mutableListOf() else mutableListOf(5)) - override val observable = DependentListCell(dependency) { dependency.value.map { 2 * it } } + override val observable = + DependentListCell(dependencyCell) { dependencyCell.value.map { 2 * it } } override fun addElement() { - dependency.add(4) + dependencyCell.add(4) } override fun createWithDependencies(vararg dependencies: Cell): Cell = diff --git a/observable/src/commonTest/kotlin/world/phantasmal/observable/cell/list/FilteredListCellTests.kt b/observable/src/commonTest/kotlin/world/phantasmal/observable/cell/list/FilteredListCellTests.kt index ddf398ae..c1b2db68 100644 --- a/observable/src/commonTest/kotlin/world/phantasmal/observable/cell/list/FilteredListCellTests.kt +++ b/observable/src/commonTest/kotlin/world/phantasmal/observable/cell/list/FilteredListCellTests.kt @@ -5,13 +5,13 @@ import kotlin.test.* class FilteredListCellTests : ListCellTests { override fun createListProvider(empty: Boolean) = object : ListCellTests.Provider { - private val dependency = + private val dependencyCell = SimpleListCell(if (empty) mutableListOf(5) else mutableListOf(5, 10)) - override val observable = FilteredListCell(dependency, predicate = { it % 2 == 0 }) + override val observable = FilteredListCell(dependencyCell, predicate = { it % 2 == 0 }) override fun addElement() { - dependency.add(4) + dependencyCell.add(4) } } diff --git a/observable/src/commonTest/kotlin/world/phantasmal/observable/cell/list/FlatteningDependentListCellDirectDependencyEmitsTests.kt b/observable/src/commonTest/kotlin/world/phantasmal/observable/cell/list/FlatteningDependentListCellDirectDependencyEmitsTests.kt index fe50a07b..f5dddebc 100644 --- a/observable/src/commonTest/kotlin/world/phantasmal/observable/cell/list/FlatteningDependentListCellDirectDependencyEmitsTests.kt +++ b/observable/src/commonTest/kotlin/world/phantasmal/observable/cell/list/FlatteningDependentListCellDirectDependencyEmitsTests.kt @@ -11,15 +11,15 @@ class FlatteningDependentListCellDirectDependencyEmitsTests : ListCellTests { private val transitiveDependency = StaticListCell(if (empty) emptyList() else listOf(7)) // The direct dependency of the list under test can change. - private val dependency = SimpleCell>(transitiveDependency) + private val directDependency = SimpleCell>(transitiveDependency) override val observable = - FlatteningDependentListCell(dependency) { dependency.value } + FlatteningDependentListCell(directDependency) { directDependency.value } override fun addElement() { // Update the direct dependency. - val oldTransitiveDependency: ListCell = dependency.value - dependency.value = StaticListCell(oldTransitiveDependency.value + 4) + val oldTransitiveDependency: ListCell = directDependency.value + directDependency.value = StaticListCell(oldTransitiveDependency.value + 4) } } } diff --git a/observable/src/commonTest/kotlin/world/phantasmal/observable/cell/list/FlatteningDependentListCellTransitiveDependencyEmitsTests.kt b/observable/src/commonTest/kotlin/world/phantasmal/observable/cell/list/FlatteningDependentListCellTransitiveDependencyEmitsTests.kt index aebce5a6..70db664b 100644 --- a/observable/src/commonTest/kotlin/world/phantasmal/observable/cell/list/FlatteningDependentListCellTransitiveDependencyEmitsTests.kt +++ b/observable/src/commonTest/kotlin/world/phantasmal/observable/cell/list/FlatteningDependentListCellTransitiveDependencyEmitsTests.kt @@ -21,10 +21,10 @@ class FlatteningDependentListCellTransitiveDependencyEmitsTests : SimpleListCell(if (empty) mutableListOf() else mutableListOf(7)) // The direct dependency of the list under test can't change. - private val dependency = StaticCell>(transitiveDependency) + private val directDependency = StaticCell>(transitiveDependency) override val observable = - FlatteningDependentListCell(dependency) { dependency.value } + FlatteningDependentListCell(directDependency) { directDependency.value } override fun addElement() { // Update the transitive dependency. diff --git a/observable/src/commonTest/kotlin/world/phantasmal/observable/cell/list/ListCellCreationTests.kt b/observable/src/commonTest/kotlin/world/phantasmal/observable/cell/list/ListCellCreationTests.kt new file mode 100644 index 00000000..8e7101c5 --- /dev/null +++ b/observable/src/commonTest/kotlin/world/phantasmal/observable/cell/list/ListCellCreationTests.kt @@ -0,0 +1,17 @@ +package world.phantasmal.observable.cell.list + +import world.phantasmal.observable.cell.SimpleCell +import world.phantasmal.observable.test.ObservableTestSuite +import world.phantasmal.observable.test.assertListCellEquals +import kotlin.test.Test + +class ListCellCreationTests : ObservableTestSuite { + @Test + fun test_flatMapToList() = test { + val cell = SimpleCell(SimpleListCell(mutableListOf(1, 2, 3, 4, 5))) + + val mapped = cell.flatMapToList { it } + + assertListCellEquals(listOf(1, 2, 3, 4, 5), mapped) + } +} diff --git a/observable/src/commonTest/kotlin/world/phantasmal/observable/cell/list/SimpleListCellTests.kt b/observable/src/commonTest/kotlin/world/phantasmal/observable/cell/list/SimpleListCellTests.kt index c69eefcf..94f9d733 100644 --- a/observable/src/commonTest/kotlin/world/phantasmal/observable/cell/list/SimpleListCellTests.kt +++ b/observable/src/commonTest/kotlin/world/phantasmal/observable/cell/list/SimpleListCellTests.kt @@ -1,6 +1,7 @@ package world.phantasmal.observable.cell.list import world.phantasmal.observable.cell.SimpleCell +import world.phantasmal.observable.test.assertListCellEquals import world.phantasmal.testUtils.TestContext import kotlin.test.* @@ -25,11 +26,30 @@ class SimpleListCellTests : MutableListCellTests { fun instantiates_correctly() = test { val list = SimpleListCell(mutableListOf(1, 2, 3)) - assertEquals(3, list.size.value) - assertEquals(3, list.value.size) - assertEquals(1, list[0]) - assertEquals(2, list[1]) - assertEquals(3, list[2]) + assertListCellEquals(listOf(1, 2, 3), list) + } + + @Test + fun set() = test { + testSet(SimpleListCell(mutableListOf("a", "b", "c"))) + } + + @Test + fun set_with_extractDependencies() = test { + testSet(SimpleListCell(mutableListOf("a", "b", "c")) { arrayOf() }) + } + + private fun testSet(list: SimpleListCell) { + list[1] = "test" + list[2] = "test2" + assertFailsWith { + list[-1] = "should not be in list" + } + assertFailsWith { + list[3] = "should not be in list" + } + + assertListCellEquals(listOf("a", "test", "test2"), list) } @Test @@ -40,10 +60,92 @@ class SimpleListCellTests : MutableListCellTests { list.add(1, "c") list.add(0, "a") - assertEquals(3, list.size.value) - assertEquals("a", list[0]) - assertEquals("b", list[1]) - assertEquals("c", list[2]) + assertListCellEquals(listOf("a", "b", "c"), list) + } + + @Test + fun remove() = test { + val list = SimpleListCell(mutableListOf("a", "b", "c", "d", "e")) + + assertTrue(list.remove("c")) + + assertListCellEquals(listOf("a", "b", "d", "e"), list) + + assertTrue(list.remove("a")) + + assertListCellEquals(listOf("b", "d", "e"), list) + + assertTrue(list.remove("e")) + + assertListCellEquals(listOf("b", "d"), list) + + // The following values are not in the list (anymore). + assertFalse(list.remove("x")) + assertFalse(list.remove("a")) + assertFalse(list.remove("c")) + + // List should remain unchanged after removal attempts of nonexistent elements. + assertListCellEquals(listOf("b", "d"), list) + } + + @Test + fun removeAt() = test { + val list = SimpleListCell(mutableListOf("a", "b", "c", "d", "e")) + + list.removeAt(2) + + assertListCellEquals(listOf("a", "b", "d", "e"), list) + + list.removeAt(0) + + assertListCellEquals(listOf("b", "d", "e"), list) + + list.removeAt(2) + + assertListCellEquals(listOf("b", "d"), list) + + assertFailsWith { + list.removeAt(-1) + } + assertFailsWith { + list.removeAt(list.size.value) + } + + // List should remain unchanged after invalid calls. + assertListCellEquals(listOf("b", "d"), list) + } + + @Test + fun splice() = test { + val list = SimpleListCell((0..9).toMutableList()) + + list.splice(fromIndex = 3, removeCount = 5, newElement = 100) + + assertListCellEquals(listOf(0, 1, 2, 100, 8, 9), list) + + list.splice(fromIndex = 0, removeCount = 0, newElement = 101) + + assertListCellEquals(listOf(101, 0, 1, 2, 100, 8, 9), list) + + list.splice(fromIndex = list.size.value, removeCount = 0, newElement = 102) + + assertListCellEquals(listOf(101, 0, 1, 2, 100, 8, 9, 102), list) + + // Negative fromIndex. + assertFailsWith { + list.splice(fromIndex = -1, removeCount = 0, newElement = 200) + } + // fromIndex too large. + assertFailsWith { + list.splice(fromIndex = list.size.value + 1, removeCount = 0, newElement = 201) + } + // removeCount too large. + assertFailsWith { + list.splice(fromIndex = 0, removeCount = 50, newElement = 202) + } + + // List should remain unchanged after invalid calls. + assertListCellEquals(listOf(101, 0, 1, 2, 100, 8, 9, 102), list) } @Test diff --git a/observable/src/commonTest/kotlin/world/phantasmal/observable/test/Utils.kt b/observable/src/commonTest/kotlin/world/phantasmal/observable/test/Utils.kt new file mode 100644 index 00000000..933e8ad2 --- /dev/null +++ b/observable/src/commonTest/kotlin/world/phantasmal/observable/test/Utils.kt @@ -0,0 +1,10 @@ +package world.phantasmal.observable.test + +import world.phantasmal.observable.cell.list.ListCell +import kotlin.test.assertEquals + +fun assertListCellEquals(expected: List, actual: ListCell) { + assertEquals(expected.size, actual.size.value) + assertEquals(expected.size, actual.value.size) + assertEquals(expected, actual.value) +}