suspendCoroutine hangs when resumeWithException is called with mockk mock

I have an external API that I want to test against, but in which I cannot construct exceptional types myself. Consider this following small example:

import kotlinx.coroutines.DelicateCoroutinesApi
import kotlinx.coroutines.GlobalScope
import kotlinx.coroutines.async
import kotlinx.coroutines.delay
import kotlinx.coroutines.launch
import kotlinx.coroutines.runBlocking
import org.junit.jupiter.api.Test
import kotlin.coroutines.resume
import kotlin.coroutines.resumeWithException
import kotlin.coroutines.suspendCoroutine

class Foo {
    lateinit var cb: Callback

    interface Callback {
        fun good()
        fun bad(e: Throwable)
    }

    fun something(cb: Callback) {
        this.cb = cb
    }
}

class Test {
    @OptIn(DelicateCoroutinesApi::class)
    @Test
    fun test() {
        val foo = Foo()
        runBlocking {
            launch {
                delay(300)
                //foo.cb.bad(mockk<IllegalStateException>(relaxed = true))
                foo.cb.bad(IllegalStateException())
            }
            GlobalScope.async {
                suspendCoroutine { cont ->
                    foo.something(object : Foo.Callback {
                        override fun good() {
                            cont.resume(Unit)
                        }

                        override fun bad(e: Throwable) {
                            cont.resumeWithException(e)
                        }
                    })
                }
            }.await()
        }
    }
}

If I execute this test as-is, the exception is thrown and the test turns red, just as expected. If I however comment out the call with the IllegalStateException constructor and use the mockk mock instead, the test hangs indefinitely and I never return from the suspendCoroutine block. What can I do?

The behavior arises from the fact that you use a relaxed mock of an Exception that returns a relaxed mock when getCause is called. This leads to an infinite recursion when some mechanism inside of resumeWithException tries to get the root cause of your exception.

You can fix this by simply specifying the cause of your mocked exception, e.g.

mockk<IllegalStateException>(relaxed = true) {
    every { cause } returns null
}