Your first example causes the outer-most CoroutineScope to be canceled. The second

test.run()

is never called -> One exception printed

Your second example causes the

GlobalScope

to ‘handle’ the exception. It just prints it out and, since it has no

Job

, it never gets canceled, it never finishes. This means that the outer-most CoroutineScope (the one provided by

runBlockingTest

) never gets canceled; the exception didn’t happen in that scope, it happened in the GlobalScope. This means that the code keeps running and

test.run()

is called again

I would like to know what really happens after unhandled exception to the CoroutineScope mixed in to my class with

by CoroutineScope(Dispatchers.Default)

. Can it be "fixed" somehow for later use? Or it's just dead? 🙂

Should I just catch all exceptions in the suspending code I launch? Should I use GlobalScope? Are there more ways to get CoroutineScope and launch suspending functions from my class?

Your outer, but separate CoroutineScope (from runBlockingTest) is never canceled and both `test.run()`s are called. However, since the `Test`’s CoroutineScope was canceled by the first call to

test.run()

(exception happened), the 2nd call to

launch

will be canceled immediately

Be careful with creating new CoroutineScopes. Create them for a component's lifecycle. A new CoroutineScopes is a separate new lifecycle. To stay in the same lifecycle along async code calls, stay within the same CoroutineScope. Create a new CoroutineScope when you enter a brand new lifecycle. This should not be the usual case, be careful doing this.

thx for help