A modern programming language that makes developers happier.

kotlinlang

Is it possible to catch exceptions thrown in a `backgroundScope` _before_ `runTest { }` completes, and prevent it from throwing that exception at the end of the `runTest { }` function?

I want the allowing of uncompleted active coroutines that `backgroundScope` provides, but with the the inline exception throwing of `TestScope` and `UnconfinedTestDispatcher`

My use case is that I want to leverage some type of `assertFailsWith(..)` logic on the exceptions that occurred _before_ runTest completes

Untitled.cpp

I don’t like having to wrap the `runTest { }` in an `assertFailsWith<Exception>{ }`.

```// this works
@Test
fun currentSolution() {
    assertFailsWith<IllegalStateException> {
        executeTest {
            // executed on a background scope
            whenExceptionIsIntentionallyThrown()
        }
    }
}```
I would prefer to be able to do something like this:

```// does not work
@Test
fun doesNotCatchException() = executeTest {
    // executed on a background scope
    whenExceptionIsIntentionallyThrown()
    
    assertFailsWith<IllegalStateException> {
        thenIllegalStateExceptionWasThrown()
    }
}```
I need to access the exceptions thrown under the `backgroundScope` _before_ `runTest { }` completes. Is it possible?

Why do you want to assert the behavior of the background scope? The background scope is meant to model tasks that _are independent_ of the system-under-test. What you're trying to test is intended to run in the foreground scope, so this seems to be a X/Y problem.

&gt; The background scope is meant to model tasks that _are independent_ of the system-under-test
what do you mean by this?

we have a lot of ongoing actor coroutines in our codebase that build ongoing state. we don’t care about manually closing these. In production, `scope.cancel()` is meant to gracefully shut down these actor coroutines. My understanding is that this is what `backgroundScope` is for. Am I wrong here?

Your actors should always gracefully terminate when their input channels close, right? If so, I'd have all actors run in the foreground scope, and they will gracefully terminate at the end of the test when all data has been processed

This way you will also be able to detect actors that stay alive even after their work is done