Hello, I don't understand why I can't

delay

the emission of values in a flow, during a unit test... The following code fails :

import kotlinx.coroutines.CoroutineDispatcher
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.delay
import kotlinx.coroutines.flow.flow
import kotlinx.coroutines.flow.flowOn
import kotlinx.coroutines.flow.toList
import kotlinx.coroutines.test.TestCoroutineDispatcher
import kotlinx.coroutines.test.TestCoroutineScope
import kotlinx.coroutines.test.resetMain
import kotlinx.coroutines.test.runBlockingTest
import kotlinx.coroutines.test.setMain
import org.junit.Assert.assertEquals
import org.junit.Rule
import org.junit.Test
import org.junit.rules.TestRule
import org.junit.runner.Description
import org.junit.runners.model.Statement

class CatRepository(
    private val coroutineDispatcher: CoroutineDispatcher
) {
    fun getMeowsFlow() = flow {
        emit("Meow #1")

        delay(3_000)

        emit("Meow #2")
    }.flowOn(coroutineDispatcher)
}

class CatRepositoryTest {
    @get:Rule
    val testCoroutineRule = TestCoroutineRule()

    private val catRepository = CatRepository(testCoroutineRule.testCoroutineDispatcher)

    @Test
    fun catShouldMeowOnce() = testCoroutineRule.runBlockingTest {
        pauseDispatcher()

        assertEquals(
            listOf("Meow #1"),
            catRepository.getMeowsFlow().toList()
        )
    }
}

class TestCoroutineRule : TestRule {
    val testCoroutineDispatcher = TestCoroutineDispatcher()
    private val testCoroutineScope = TestCoroutineScope(testCoroutineDispatcher)

    override fun apply(base: Statement, description: Description?) = object : Statement() {
        @Throws(Throwable::class)
        override fun evaluate() {
            Dispatchers.setMain(testCoroutineDispatcher)

            base.evaluate()

            Dispatchers.resetMain() // reset main dispatcher to the original Main dispatcher
            testCoroutineScope.cleanupTestCoroutines()
        }
    }

    fun runBlockingTest(block: suspend TestCoroutineScope.() -> Unit) =
        testCoroutineScope.runBlockingTest { block() }
}

It prints

expected:<[Meow #1]> but was:<[Meow #1, Meow #2]>
Expected :[Meow #1]
Actual   :[Meow #1, Meow #2]

It makes no sense at all ! Since the virtual time is at 0ms, how come the

delay

is completely ignored ? Could someone explain ?

I'm not entirely sure how the virtual time works in

kotlinx-coroutines-test

, but in any case

toList()

would hang forever if the

flow

didn't progress

Doesn't it collect only the available values at that time ?

No, it's a terminal operator that goes to flow completion

So time manipulation has no effect on flows ? 😞

But you're asking for the first element of the flow here, flows are cold, not hot (at least most of them). By default, they don't progress independently of their collector. So

first()

here should return the first element, no matter how long you wait before calling it.

exactly. the flow starts when the collector starts, advancing time before that happens has no impact

you are advancing the time before collecting. Try collecting inside a launch, and then advance the time