Fix contract in a test. To break compilation if contract is not applied.

Author: nsk90

kstatemachine/src/commonMain/kotlin/ru/nsk/kstatemachine/statemachine/StateMachine.kt

@@ -22,6 +22,9 @@ import ru.nsk.kstatemachine.transition.EventAndArgument
 import ru.nsk.kstatemachine.transition.TransitionParams
 import ru.nsk.kstatemachine.visitors.CoVisitor
 import ru.nsk.kstatemachine.visitors.Visitor
+import kotlin.contracts.ExperimentalContracts
+import kotlin.contracts.InvocationKind
+import kotlin.contracts.contract
 
 @DslMarker
 annotation class StateMachineDslMarker
@@ -242,13 +245,17 @@ interface BuildingStateMachine : StateMachine {
  * Factory method for creating [StateMachine].
  * Suspendable code will be called via Kotlin Standard library (without Kotlin Coroutines library support).
  */
+@OptIn(ExperimentalContracts::class)
 fun createStdLibStateMachine(
     name: String? = null,
     childMode: ChildMode = ChildMode.EXCLUSIVE,
     start: Boolean = true,
     creationArguments: CreationArguments = buildCreationArguments {},
     init: suspend BuildingStateMachine.() -> Unit
 ): StateMachine {
+    contract {
+        callsInPlace(init, InvocationKind.EXACTLY_ONCE)
+    }
     return with(StdLibCoroutineAbstraction()) {
         runBlocking {
             createStateMachine(name, childMode, start, creationArguments, init)

tests/src/commonTest/kotlin/ru/nsk/kstatemachine/TestUtils.kt

@@ -19,6 +19,9 @@ import ru.nsk.kstatemachine.state.*
 import ru.nsk.kstatemachine.statemachine.*
 import ru.nsk.kstatemachine.transition.TransitionBuilder
 import ru.nsk.kstatemachine.transition.onTriggered
+import kotlin.contracts.ExperimentalContracts
+import kotlin.contracts.InvocationKind
+import kotlin.contracts.contract
 import kotlin.coroutines.EmptyCoroutineContext
 
 typealias Callback<T> = (T) -> Unit
@@ -81,54 +84,61 @@ enum class CoroutineStarterType {
 
 @OptIn(ExperimentalCoroutinesApi::class)
 private val singleThreadContext = newSingleThreadContext("test single thread context") // context leaks
+
 /**
  * Wraps [createStdLibStateMachine] so it can be easily switched to [createStdLibStateMachine]
  */
+@OptIn(ExperimentalContracts::class)
 suspend fun createTestStateMachine(
     coroutineStarterType: CoroutineStarterType,
     name: String? = null,
     childMode: ChildMode = ChildMode.EXCLUSIVE,
     start: Boolean = true,
     creationArguments: CreationArguments = buildCreationArguments {},
     init: suspend BuildingStateMachine.() -> Unit
-) = when (coroutineStarterType) {
-    CoroutineStarterType.STD_LIB -> createStdLibStateMachine(
-        name,
-        childMode,
-        start,
-        creationArguments,
-        init = init
-    )
-    CoroutineStarterType.COROUTINES_LIB_EMPTY_CONTEXT -> createStateMachine(
-        CoroutineScope(EmptyCoroutineContext), // does not perform internal context switching
-        name,
-        childMode,
-        start,
-        creationArguments,
-        init = init
-    )
-    CoroutineStarterType.COROUTINES_LIB_UNCONFINED_DISPATCHER -> createStateMachine(
-        CoroutineScope(Dispatchers.Unconfined),
-        name,
-        childMode,
-        start,
-        creationArguments,
-        init = init
-    )
-    CoroutineStarterType.COROUTINES_LIB_SINGLE_THREAD_DISPATCHER -> createStateMachine(
-        CoroutineScope(singleThreadContext),
-        name,
-        childMode,
-        start,
-        creationArguments,
-        init = init
-    )
-    CoroutineStarterType.COROUTINES_LIB_DEFAULT_LIMITED_DISPATCHER -> createStateMachine(
-        CoroutineScope(Dispatchers.Default.limitedParallelism(1)), // does not guarantee same thread for each task
-        name,
-        childMode,
-        start,
-        creationArguments,
-        init = init
-    )
+): StateMachine {
+    contract {
+        callsInPlace(init, InvocationKind.EXACTLY_ONCE)
+    }
+    return when (coroutineStarterType) {
+        CoroutineStarterType.STD_LIB -> createStdLibStateMachine(
+            name,
+            childMode,
+            start,
+            creationArguments,
+            init = init
+        )
+        CoroutineStarterType.COROUTINES_LIB_EMPTY_CONTEXT -> createStateMachine(
+            CoroutineScope(EmptyCoroutineContext), // does not perform internal context switching
+            name,
+            childMode,
+            start,
+            creationArguments,
+            init = init
+        )
+        CoroutineStarterType.COROUTINES_LIB_UNCONFINED_DISPATCHER -> createStateMachine(
+            CoroutineScope(Dispatchers.Unconfined),
+            name,
+            childMode,
+            start,
+            creationArguments,
+            init = init
+        )
+        CoroutineStarterType.COROUTINES_LIB_SINGLE_THREAD_DISPATCHER -> createStateMachine(
+            CoroutineScope(singleThreadContext),
+            name,
+            childMode,
+            start,
+            creationArguments,
+            init = init
+        )
+        CoroutineStarterType.COROUTINES_LIB_DEFAULT_LIMITED_DISPATCHER -> createStateMachine(
+            CoroutineScope(Dispatchers.Default.limitedParallelism(1)), // does not guarantee same thread for each task
+            name,
+            childMode,
+            start,
+            creationArguments,
+            init = init
+        )
+    }
 }

tests/src/commonTest/kotlin/ru/nsk/kstatemachine/statemachine/StateMachineTest.kt

@@ -53,8 +53,8 @@ class StateMachineTest : FreeSpec({
             "on off dsl sample" {
                 val callbacks = mockkCallbacks()
 
-                lateinit var on: State
-                lateinit var off: State
+                val on: State
+                val off: State
 
                 val machine = createTestStateMachine(coroutineStarterType) {
                     on = initialState("on") {