A modern programming language that makes developers happier.

kotlinlang

<https://kotlinlang.slack.com/archives/C1CFAFJSK/p1551199064120900>

I think it is in common. I'm currently running tests using it

I have fun into IDE issues before getting it to be recognized

It’s in JVM and Native, but not core. <https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines/run-blocking.html>

Huh. I guess we only build for JVM and native, which explains why that works

Using an instance of `CoroutineDispatcher` local to the test class did the trick: <https://gist.github.com/pardom/74a9f1abc17688badf6b8dc06e13b1d2#file-runtimetest-kt-L13-L17>

You can reimplement runBlocking:

*common*
```
expect fun &lt;T&gt; runBlocking(block: suspend () -&gt; T): T
```
*ios*
```
actual fun &lt;T&gt; runBlocking(block: suspend () -&gt; T): T {
    val expectation = Expectation&lt;T&gt;()

    GlobalScope.launch(MainRunLoopDispatcher) {
        expectation.fulfill(block.invoke())
    }

    return expectation.wait() ?: throw RuntimeException("runBlocking failed")
}

private object MainRunLoopDispatcher : CoroutineDispatcher() {
    override fun dispatch(context: CoroutineContext, block: Runnable) {
        NSRunLoop.mainRunLoop().performBlock {
            block.run()
        }
    }
}

```
*android*
```
actual fun &lt;T&gt; runBlocking(block: suspend () -&gt; T): T = kotlinx.coroutines.runBlocking { block.invoke() }

```

I’m not the original author, but I don’t remember the original author unfortunately. Hope that helps.

the common pattern is to expect/actual it

If you don't need js, you can add your own expect/actual declarations to get runblocking in jvm/native.

even in JS is still works because you can return a promise from the test APIs

this will all be obviated once `@Test suspend fun` lands though

Yeah the ticket for `@Test suspend` has more details on workarounds: <https://youtrack.jetbrains.com/issue/KT-22228>