Clear pending events on stop()/destroy() call from notification callback

Author: nsk90

kstatemachine/src/main/kotlin/ru/nsk/kstatemachine/PendingEventHandler.kt

@@ -10,19 +10,25 @@ fun StateMachine.throwingPendingEventHandler() = StateMachine.PendingEventHandle
     )
 }
 
-fun StateMachine.queuePendingEventHandler(): StateMachine.PendingEventHandler = QueuePendingEventHandler(this)
+fun StateMachine.queuePendingEventHandler(): QueuePendingEventHandler = QueuePendingEventHandlerImpl(this)
 
-internal class QueuePendingEventHandler(private val machine: StateMachine) : StateMachine.PendingEventHandler {
+interface QueuePendingEventHandler : StateMachine.PendingEventHandler {
+    fun checkEmpty()
+    fun nextEventAndArgument(): EventAndArgument<*>?
+    fun clear()
+}
+
+private class QueuePendingEventHandlerImpl(private val machine: StateMachine) : QueuePendingEventHandler {
     private val queue = ArrayDeque<EventAndArgument<*>>()
 
-    fun checkEmpty() = check(queue.isEmpty()) { "Event queue is not empty, internal error" }
+    override fun checkEmpty() = check(queue.isEmpty()) { "Event queue is not empty, internal error" }
 
     override fun onPendingEvent(pendingEvent: Event, argument: Any?) {
         machine.log { "$machine queued event $pendingEvent with argument $argument " }
         queue.add(EventAndArgument(pendingEvent, argument))
     }
 
-    fun nextEventAndArgument() = queue.removeFirstOrNull()
+    override fun nextEventAndArgument() = queue.removeFirstOrNull()
 
-    fun clear() = queue.clear()
+    override fun clear() = queue.clear()
 }

kstatemachine/src/main/kotlin/ru/nsk/kstatemachine/StateMachineImpl.kt

@@ -23,7 +23,7 @@ internal class StateMachineImpl(
     override val machineListeners: Collection<StateMachine.Listener> get() = _machineListeners
     override var logger: StateMachine.Logger = NullLogger
     override var ignoredEventHandler = StateMachine.IgnoredEventHandler { _, _ -> }
-    override var pendingEventHandler = queuePendingEventHandler()
+    override var pendingEventHandler: StateMachine.PendingEventHandler = queuePendingEventHandler()
     override var listenerExceptionHandler = StateMachine.ListenerExceptionHandler { throw it }
     private var _isDestroyed: Boolean = false
     override val isDestroyed get() = _isDestroyed
@@ -165,6 +165,10 @@ internal class StateMachineImpl(
             queue?.let {
                 var eventAndArgument = it.nextEventAndArgument()
                 while (eventAndArgument != null) {
+                    if (isDestroyed || !isRunning) { // if it happens while event processing
+                        it.clear()
+                        return result
+                    }
                     process(eventAndArgument)
 
                     eventAndArgument = it.nextEventAndArgument()
@@ -251,9 +255,11 @@ internal class StateMachineImpl(
     }
 
     override fun destroy(stop: Boolean) {
+        if (_isDestroyed) return
         if (stop) stop()
         accept(CleanupVisitor())
         _isDestroyed = true
+        log { "$this destroyed" }
     }
 }
 

kstatemachine/src/test/kotlin/ru/nsk/kstatemachine/FinishedEventTest.kt

@@ -88,4 +88,25 @@ class FinishedEventTest : StringSpec({
             callbacks.onTriggeredTransition(ofType<FinishedDataEvent<Int>>())
         }
     }
+
+    "FinishedEvent in parallel child mode" {
+        val callbacks = mockkCallbacks()
+
+        createStateMachine {
+            initialState(childMode = ChildMode.PARALLEL) {
+                state("state1") {
+                    setInitialState(finalState("state11"))
+                }
+                state("state2") {
+                    setInitialState(finalState("state21"))
+                }
+                transition<FinishedEvent> {
+                    callbacks.listen(this)
+                }
+            }
+        }
+        verifySequence {
+            callbacks.onTriggeredTransition(ofType<FinishedEvent>())
+        }
+    }
 })

kstatemachine/src/test/kotlin/ru/nsk/kstatemachine/PendingEventHandlerTest.kt

@@ -98,4 +98,39 @@ class PendingEventHandlerTest : StringSpec({
         machine.processEvent(SwitchEvent)
         machine.isDestroyed shouldBe false
     }
+
+    "pending events are cleared on stop() from notification callback" {
+        val machine = createStateMachine {
+            val state2 = state("state2") {
+                onEntry {
+                    machine.processEvent(SwitchEvent) shouldBe PENDING
+                    machine.processEvent(SwitchEvent) shouldBe PENDING
+                    machine.stop()
+                }
+            }
+            initialState("state1") {
+                transition<SwitchEvent>(targetState = state2)
+            }
+        }
+        machine.processEvent(SwitchEvent)
+        machine.isRunning shouldBe false
+        machine.start()
+    }
+
+    "pending events are cleared on destroy() from notification callback" {
+        val machine = createStateMachine {
+            val state2 = state("state2") {
+                onEntry {
+                    machine.processEvent(SwitchEvent) shouldBe PENDING
+                    machine.processEvent(SwitchEvent) shouldBe PENDING
+                    machine.destroy(false)
+                }
+            }
+            initialState("state1") {
+                transition<SwitchEvent>(targetState = state2)
+            }
+        }
+        machine.processEvent(SwitchEvent)
+        machine.isDestroyed shouldBe true
+    }
 })