@BeforeEach
    fun before() {
        testCollectionScope = CoroutineScope(UnconfinedTestDispatcher())

        scheduledDispatcher = StandardTestDispatcher()
        Dispatchers.setMain(scheduledDispatcher)

        scheduledScope = CoroutineScope(scheduledDispatcher)
    }

    @AfterEach
    fun after() = Dispatchers.resetMain()

    @Test
    fun subscriptionTimeoutTest() = runTest(scheduledDispatcher.scheduler) {
        val sender = Channel<String>()

        var didComplete = false
        val sharedFlow = sender.receiveAsFlow()
            .onCompletion { didComplete = true }
            .shareIn(
                scope = scheduledScope,
                started = SharingStarted.WhileSubscribed(5.seconds),
            )

        sharedFlow.produceIn(testCollectionScope).apply {
            sender.send("event 1")
            assertEquals("event 1", receive())
        }.cancel()

        advanceTimeBy(5.seconds)
//        runCurrent() // - Should succeed without, should fail with

        assertFalse(didComplete, "Completion detected before resubscription")

        sharedFlow.produceIn(testCollectionScope).apply {
            assertFalse(didComplete, "Completion detected at resubscription")
            sender.send("event 2")
            assertEquals("event 2", receive())
            assertFalse(didComplete, "Completion detected after resubscription")
        }.cancel()
    }