Even though async is already cancelled, it may fail with other Exceptions.

[yamasa]

I have a question about this test code.

class CancelBlockingCallTest {

    private fun someBlockingIO(): String {
        Thread.sleep(3000L)
        println("throwing IOException...")
        throw IOException()
    }

    @Test
    fun testWithContext() = runBlocking {
        val job = launch(Dispatchers.Default) {
            try {
                val result = withContext(Dispatchers.IO) {
                    someBlockingIO()
                }
                println("result: $result")
            } catch (e: IOException) {
                println("exception: $e")
            }
        }
        delay(1000L)
        job.cancel()
        job.join()
    }

    @Test
    fun testAsync() = runBlocking {
        val job = launch(Dispatchers.Default) {
            try {
                val deferred = async(Dispatchers.IO) {
                    someBlockingIO()
                }
                println("result: ${deferred.await()}")
            } catch (e: IOException) {
                println("exception: $e")
            }
        }
        delay(1000L)
        job.cancel()
        job.join()
    }

    @Test
    fun testCoroutineScopeAndAsync() = runBlocking {
        val job = launch(Dispatchers.Default) {
            try {
                coroutineScope {
                    val deferred = async(Dispatchers.IO) {
                        someBlockingIO()
                    }
                    println("result: ${deferred.await()}")
                }
            } catch (e: IOException) {
                println("exception: $e")
            }
        }
        delay(1000L)
        job.cancel()
        job.join()
    }
}

testWithContext() is a typical code that calls a blocking IO function.
In this test, the job is cancelled before returning from someBlockingIO(). As a result, the IOException is just ignored.

testAsync() is just using async instead of withContext. But, its result is different from testWithContext(). Even though the job was already cancelled, async and its parent are failed with IOException.

I think if async has already been cancelled, it should ignore any other Exceptions. What do you think?

[elizarov]

Ignoring exceptions is a really, really bad idea for any serious production code. I actually think that ignoring exception in testWithContext case is actually a bug and it should behave more like async/await and coroutineScope.