A modern programming language that makes developers happier.

kotlinlang

You need to inject the clock into that function via a parameter and then use the virtual time clock in your test.

```    context(Clock)
	suspend inline fun &lt;T&gt; slowdown(duration: Duration, block: () -&gt; T): T {
		var result: T
		val timeTaken = this@Clock.measureTime {
			result = block()
		}
		delay(duration - timeTaken)
		return result
	}```
then in `runTest` scope, I should use `currentTime` and in normal `runBlocking` scope, `System.currentTimeInMilliSeconds`before and after `block` ...

 I guess that'll work

Thanks Jake!

unrelated, but you could
```val (result, timeTaken) = measureTimedValue { ... }```

I'd use a `TimeSource` instead of `Clock`, defaulting to `Monotonic`, but either way you do have to provide the test value yourself since there isn't a public way of extracting it from the coroutine context

There is a timeSource: <https://kotlinlang.org/api/kotlinx.coroutines/kotlinx-coroutines-test/kotlinx.coroutines.test/test-time-source.html>

So you could use `runTest { testTimeSource.measureTimedValue {} }`

yes, but the `slowdown` function can't pull that out of its context - the test still has to pass it along

Okay that's true. But the `testTimeSource` supports delay-skipping.

yep, that's basically what I was recommending

for this case in particular,
```suspend fun &lt;T&gt; slowdown(duration: Duration, block: () -&gt; T): T = coroutineScope {
    launch { delay(duration) }
    block()
}```
would achieve the same result without having to deal with time, but in general you do need to use the test timesource or create a fake clock based on test time in order to work with test delay skipping