A modern programming language that makes developers happier.

kotlinlang

In a `TestScope`, how can I manually control the passing of virtual time inside a suspending function?
```suspend fun doSomethingDelayed() {
    delay(10.seconds)
    println("Delayed action completed")
}```

The test (in Kotest):
```        "test do something delayed" {
            doSomethingDelayed()
            testCoroutineScheduler.advanceTimeBy(5.seconds)
            testCoroutineScheduler.runCurrent()
            println("5 seconds passed")
            testCoroutineScheduler.advanceTimeBy(5.seconds)
            testCoroutineScheduler.runCurrent()
            println("Test completed")
        }```

It prints
```Delayed action completed
5 seconds passed
Test completed```

And then `advanceTimeBy()` inside or outside of `launch()`?

Relevant: <https://github.com/Kotlin/kotlinx.coroutines/issues/3919>
`advanceTimeBy()` can be replaced by a `delay` in most cases.

Outside. The test scheduler handles the execution (delay) of the launched coroutine and you controls the scheduler from outside.

The test actually works as expected like this:
```        "test do something delayed" {
            launch {
                doSomethingDelayed()
            }
            delay(5.seconds)
            println("5 seconds passed")

            delay(5.seconds)
            println("Test completed")
        }```

<@U013DCMNJTH> why does `advanceTimeBy()` not work as expected here?

I'd expect it, too, to work here. Does it not? What happens instead?
If you send me a full file, I'll take a look and explain what's going on.

Oh, wait, I think I got it. Are you asking why this doesn't work?
```        "test do something delayed" {
            launch {
                doSomethingDelayed()
            }
            advanceUntilIdle(5.seconds)
            println("5 seconds passed")

            advanceUntilIdle(5.seconds)
            println("Test completed")
        }```


If yes, it's because `advanceTimeBy(duration)` stops *right before* executing the tasks scheduled to execute `duration` later. To execute those tasks, `advanceTimeBy` should be followed by `runCurrent`. This gives much more flexible control in the technical scenarios where manually controlling virtual time is actually necessary.

So in my reproducer project I couldn't reproduce this problem with `advanceTimeBy()` anymore. It must lie somehow in my Kotest configuration in my main project.