Kotlin SupervisorJob unexpected behaviour - multithreading

Question

I have the next code:
import kotlin.coroutines.*;
import kotlinx.coroutines.*;
val job = SupervisorJob()
val handler = CoroutineExceptionHandler { _, e ->
println("Catch: $e")
}
val coroutineContext: CoroutineContext = Dispatchers.IO + job + handler
fun main() {
val job1 = GlobalScope.launch(coroutineContext) {
// supervisorScope {
launch {
println("Test0")
for (i in 0..5) {
println("Working! Iteration: $i")
delay(1000)
}
println("Test0 end")
}
launch {
println("Test1")
delay(2000)
throw IllegalAccessException()
}
launch {
println("Test2")
delay(3000)
println("Test2 end")
}
}
//}
runBlocking { job1.join() }
println("Test3")
}
As You can see, I'm using SupervisorJob by passing it in coroutineContext into GlobalScope.launch to avoid canceling of any children on error if it happened anywhere and error must be handled in handler. The documetation says next about SupervisorJob:
Creates a supervisor job object in an active state. Children of a supervisor job can fail independently of each other.
Based on this, I'm expecting something like that:
Test0
Working! Iteration: 0
Test1
Test2
Working! Iteration: 1
Catch: java.lang.IllegalAccessException
Working! Iteration: 2
Working! Iteration: 3
Test2 end
Working! Iteration: 4
Working! Iteration: 5
Test0 end
Test3
But I get:
Test2
Test0
Working! Iteration: 0
Test1
Working! Iteration: 1
Catch: java.lang.IllegalAccessException
Test3
The only that helps is uncomment supervisorScope in code above.
What I'm doing wrong? How I can set expected behaviour globaly in ViewModel, for example, to avoid wrapping every launch in supervisorScope?
Thanks in advance.

Answer 1

As explained in this answer, you can't change the type of the job for a launched coroutine. The only thing under your control is its parent job. Since you first launch a top-level coroutine and then, as its children, launch those whose failure you don't want to influence the others, the best option is what you already discovered, opening an inner supervisorScope.
You cannot specify a global policy on how a given coroutine will behave upon the failure of its children.

Answer 2

Thanks to #MarkoTopolnik, solution that worked for me:
val job = SupervisorJob()
val handler = CoroutineExceptionHandler { _, e ->
println("Catch: $e")
}
val coroutineContext: CoroutineContext = Dispatchers.IO + job + handler
val coroutineScope: CoroutineScope = CoroutineScope(coroutineContext)
fun main() {
val job1 = coroutineScope.launch {
println("Test0 start")
for (i in 0..5) {
println("Test0 iteration: $i")
delay(1000)
}
println("Test0 end")
}
val job2 = coroutineScope.launch {
println("Test4 start")
for (i in 0..5) {
println("Test4 iteration: $i")
delay(1000)
}
println("Test4 end")
}
val job3 = coroutineScope.launch {
println("Test1")
delay(2000)
throw IllegalAccessException()
}
val job4 = coroutineScope.launch {
println("Test2 start")
delay(4000)
println("Test2 end")
}
val jobs = mutableListOf(job1, job2, job3, job4)
runBlocking {
jobs.forEach { it.join() }
}
println("end")
}
Result:
Test0 start
Test0 iteration: 0
Test1
Test4 start
Test4 iteration: 0
Test2 start
Test0 iteration: 1
Test4 iteration: 1
Test0 iteration: 2
Test4 iteration: 2
Catch: java.lang.IllegalAccessException
Test4 iteration: 3
Test0 iteration: 3
Test2 end
Test4 iteration: 4
Test0 iteration: 4
Test4 iteration: 5
Test0 iteration: 5
Test4 end
Test0 end
end