Add NHSupport.setState safe overload and fix tests

mirai-core/src/commonMain/kotlin/QQAndroidBot.kt

@@ -54,7 +54,9 @@ internal fun Bot.asQQAndroidBot(): QQAndroidBot {
 
 // for tests
 internal class BotDebugConfiguration(
-    var stateObserver: StateObserver? = LOGGING
+    var stateObserver: StateObserver? = LOGGING,
+    var recordExceptionInPacketDecoding: Boolean = false,
+    var allowReinitActions: Boolean = false,
 )
 
 @Suppress("INVISIBLE_MEMBER", "BooleanLiteralArgument", "OverridingDeprecatedMember")
@@ -66,6 +68,7 @@ internal open class QQAndroidBot constructor(
     override val bot: QQAndroidBot get() = this
     val client get() = components[SsoProcessor].client
 
+
     ///////////////////////////////////////////////////////////////////////////
     // network
     ///////////////////////////////////////////////////////////////////////////
@@ -77,6 +80,7 @@ internal open class QQAndroidBot constructor(
             components[BotInitProcessor].asObserver(),
             object : StateChangedObserver(State.OK) {
                 private val shouldBroadcastRelogin = atomic(false)
+
                 override fun stateChanged0(
                     networkHandler: NetworkHandlerSupport,
                     previous: BaseStateImpl,
@@ -120,6 +124,10 @@ internal open class QQAndroidBot constructor(
     override val components: ConcurrentComponentStorage by lazy {
         ConcurrentComponentStorage().apply {
             val components = this // avoid mistakes
+
+            // There's no need to interrupt a broadcasting event when network handler closed.
+            set(EventDispatcher, EventDispatcherImpl(bot.coroutineContext, logger.subLogger("EventDispatcher")))
+
             set(SsoProcessorContext, SsoProcessorContextImpl(bot))
             set(SsoProcessor, SsoProcessorImpl(get(SsoProcessorContext)))
             set(HeartbeatProcessor, HeartbeatProcessorImpl())
@@ -139,7 +147,7 @@ internal open class QQAndroidBot constructor(
             set(
                 PacketHandler, PacketHandlerChain(
                     LoggingPacketHandlerAdapter(get(PacketLoggingStrategy), networkLogger),
-                    EventBroadcasterPacketHandler(bot, networkLogger),
+                    EventBroadcasterPacketHandler(components),
                     CallPacketFactoryPacketHandler(bot)
                 )
             )

mirai-core/src/commonMain/kotlin/network/handler/NetworkHandlerSupport.kt

@@ -192,6 +192,15 @@ internal abstract class NetworkHandlerSupport(
      * Attempts to change state. Returns null if new state has same [class][KClass] as current.
      */
     protected inline fun <reified S : BaseStateImpl> setState(noinline new: () -> S): S? = setState(S::class, new)
+    protected inline fun <reified S : BaseStateImpl> setState(
+        old: BaseStateImpl, noinline new: () -> S
+    ): S? = synchronized(this) {
+        if (_state === old) {
+            setState(new)
+        } else {
+            null
+        }
+    }
 
     /**
      * Calculate [new state][new] and set it as the current, returning the new state,

mirai-core/src/commonMain/kotlin/network/impl/netty/NettyNetworkHandler.kt

@@ -185,7 +185,7 @@ internal open class NettyNetworkHandler(
         }
 
         override suspend fun resumeConnection0() {
-            setState { StateConnecting(ExceptionCollector()) }
+            setState(this) { StateConnecting(ExceptionCollector()) }
                 ?.resumeConnection()
                 ?: this@NettyNetworkHandler.resumeConnection() // concurrently closed by other thread.
         }
@@ -251,7 +251,7 @@ internal open class NettyNetworkHandler(
         override suspend fun resumeConnection0() {
             connectResult.await() // propagates exceptions
             val connection = connection.await()
-            setState { StateLoading(connection) }
+            setState(this) { StateLoading(connection) }
                 ?.resumeConnection()
                 ?: this@NettyNetworkHandler.resumeConnection() // concurrently closed by other thread.
         }
@@ -290,7 +290,7 @@ internal open class NettyNetworkHandler(
                 join()
             }
             joinCompleted(configPush) // throw exception
-            setState { StateOK(connection, configPush) }
+            setState(this) { StateOK(connection, configPush) }
         } // noop
 
         override fun toString(): String = "StateLoading"

mirai-core/src/commonTest/kotlin/network/framework/AbstractRealNetworkHandlerTest.kt

@@ -42,7 +42,7 @@ import kotlin.test.assertEquals
 @TestInstance(TestInstance.Lifecycle.PER_METHOD)
 internal abstract class AbstractRealNetworkHandlerTest<H : NetworkHandler> : AbstractTest() {
     init {
-        System.setProperty("mirai.debug.network.state.observer.logging", "true")
+        System.setProperty("mirai.debug.network.state.observer.logging", "full")
         System.setProperty("mirai.debug.network.show.all.components", "true")
     }
 

mirai-core/src/commonTest/kotlin/network/impl/netty/NettyHandlerEventTest.kt

@@ -24,11 +24,14 @@ import net.mamoe.mirai.internal.network.handler.NetworkHandler.State.INITIALIZED
 import net.mamoe.mirai.internal.network.handler.NetworkHandler.State.OK
 import net.mamoe.mirai.internal.test.assertEventBroadcasts
 import net.mamoe.mirai.internal.test.runBlockingUnit
+import org.junit.jupiter.api.TestInstance
+import java.util.concurrent.atomic.AtomicReference
 import kotlin.test.Test
 import kotlin.test.assertEquals
 import kotlin.time.seconds
 
 
+@TestInstance(TestInstance.Lifecycle.PER_METHOD)
 internal class NettyHandlerEventTest : AbstractNettyNHTest() {
     @Test
     fun `BotOnlineEvent after successful logon`() = runBlockingUnit {
@@ -118,23 +121,24 @@ internal class NettyHandlerEventTest : AbstractNettyNHTest() {
 
     @Test
     fun `from CONNECTING TO OK the second time`() = runBlockingUnit {
-        var ok = CompletableDeferred<Unit>()
+        val ok = AtomicReference(CompletableDeferred<Unit>())
         defaultComponents[SsoProcessor] = object : SsoProcessor by defaultComponents[SsoProcessor] {
-            override suspend fun login(handler: NetworkHandler) = ok.join()
+            override suspend fun login(handler: NetworkHandler) = ok.get().join()
         }
 
         assertState(INITIALIZED)
 
         network.setStateConnecting()
-        ok.complete(Unit)
+        ok.get().complete(Unit)
         network.resumeConnection()
         assertState(OK)
 
-        ok = CompletableDeferred()
+        ok.set(CompletableDeferred())
         network.setStateConnecting()
         delay(2000)
+        println("Starting receiving events")
         assertEventBroadcasts<Event>(2) {
-            ok.complete(Unit)
+            ok.get().complete(Unit)
             network.resumeConnection()
             delay(2000)
         }.let { event ->