Exception handling coroutines guide

Author: qwwdfsad

core/kotlinx-coroutines-core/test/guide/example-exceptions-01.kt

@@ -0,0 +1,30 @@
+/*
+ * Copyright 2016-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license.
+ */
+
+// This file was automatically generated from coroutines-guide.md by Knit tool. Do not edit.
+package kotlinx.coroutines.experimental.guide.exceptions01
+
+import kotlinx.coroutines.experimental.*
+
+fun main(args: Array<String>) = runBlocking {
+    val job = launch {
+        println("Throwing exception from launch")
+        throw IndexOutOfBoundsException() // Will be printed to the console by Thread.defaultUncaughtExceptionHandler
+    }
+
+    job.join()
+    println("Joined failed job")
+
+    val deferred = async {
+        println("Throwing exception from async")
+        throw ArithmeticException() // Nothing is printed, relying on user to call await
+    }
+
+    try {
+        deferred.await()
+        println("Unreached")
+    } catch (e: ArithmeticException) {
+        println("Caught ArithmeticException")
+    }
+}

core/kotlinx-coroutines-core/test/guide/example-exceptions-02.kt

@@ -0,0 +1,22 @@
+/*
+ * Copyright 2016-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license.
+ */
+
+// This file was automatically generated from coroutines-guide.md by Knit tool. Do not edit.
+package kotlinx.coroutines.experimental.guide.exceptions02
+
+import kotlinx.coroutines.experimental.*
+
+fun main(args: Array<String>) = runBlocking {
+    val handler = CoroutineExceptionHandler { _, exception -> println("Caught $exception") }
+
+    val job = launch(handler) {
+        throw AssertionError()
+    }
+
+    val deferred = async(handler) {
+        throw ArithmeticException() // Nothing will be printed, relying on user to call deferred.await()
+    }
+
+    joinAll(job, deferred)
+}

core/kotlinx-coroutines-core/test/guide/example-exceptions-03.kt

@@ -0,0 +1,30 @@
+/*
+ * Copyright 2016-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license.
+ */
+
+// This file was automatically generated from coroutines-guide.md by Knit tool. Do not edit.
+package kotlinx.coroutines.experimental.guide.exceptions03
+
+import kotlinx.coroutines.experimental.*
+import kotlin.coroutines.experimental.*
+
+fun main(args: Array<String>) = runBlocking {
+    val job = launch(coroutineContext, parent = Job()) {
+        val child = launch(coroutineContext) {
+            try {
+                delay(Long.MAX_VALUE)
+            } finally {
+                println("Child is cancelled")
+            }
+        }
+
+        yield()
+        println("Cancelling child")
+        child.cancel()
+        child.join()
+        yield()
+        println("Parent is not cancelled")
+    }
+
+    job.join()
+}

core/kotlinx-coroutines-core/test/guide/example-exceptions-04.kt

@@ -0,0 +1,35 @@
+/*
+ * Copyright 2016-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license.
+ */
+
+// This file was automatically generated from coroutines-guide.md by Knit tool. Do not edit.
+package kotlinx.coroutines.experimental.guide.exceptions04
+
+import kotlinx.coroutines.experimental.*
+import kotlin.coroutines.experimental.*
+
+fun main(args: Array<String>) = runBlocking {
+     val handler = CoroutineExceptionHandler { _, exception -> println("Caught $exception") }
+   
+       val job = launch(handler) {
+           val child1 = launch(coroutineContext, start = CoroutineStart.ATOMIC) {
+               try {
+                   delay(Long.MAX_VALUE)
+               } finally {
+                   withContext(NonCancellable) {
+                       println("Children are cancelled, but exception is not handled until children are terminated completely")
+                       delay(100)
+                       println("Last child finished its non cancellable block")
+                   }
+               }
+           }
+   
+           val child2 = launch(coroutineContext, start = CoroutineStart.ATOMIC) {
+               delay(10)
+               println("Child throws an exception")
+               throw ArithmeticException()
+           }
+       }
+   
+       job.join()
+}

core/kotlinx-coroutines-core/test/guide/example-exceptions-05.kt

@@ -0,0 +1,35 @@
+/*
+ * Copyright 2016-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license.
+ */
+
+// This file was automatically generated from coroutines-guide.md by Knit tool. Do not edit.
+package kotlinx.coroutines.experimental.guide.exceptions05
+
+import kotlinx.coroutines.experimental.*
+import kotlinx.coroutines.experimental.exceptions.*
+import java.io.*
+import kotlin.coroutines.experimental.*
+
+fun main(args: Array<String>) = runBlocking {
+    val handler = CoroutineExceptionHandler { _, exception ->
+           println("Caught $exception with suppressed ${exception.suppressed().contentToString()}")
+       }
+   
+       val job = launch(handler + coroutineContext, parent = Job()) {
+           launch(coroutineContext, start = CoroutineStart.ATOMIC) {
+                try {
+                    delay(Long.MAX_VALUE)
+                } finally {
+                    throw ArithmeticException()
+                }
+           }
+           
+           launch(coroutineContext) {
+               throw IOException()
+           }
+   
+           delay(Long.MAX_VALUE)
+       }
+   
+       job.join()
+}

core/kotlinx-coroutines-core/test/guide/example-exceptions-06.kt

@@ -0,0 +1,35 @@
+/*
+ * Copyright 2016-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license.
+ */
+
+// This file was automatically generated from coroutines-guide.md by Knit tool. Do not edit.
+package kotlinx.coroutines.experimental.guide.exceptions06
+
+import kotlinx.coroutines.experimental.*
+import java.io.*
+import kotlin.coroutines.experimental.*
+
+fun main(args: Array<String>) = runBlocking {
+  val handler = CoroutineExceptionHandler { _, exception ->
+         println("Caught original $exception")
+     }
+ 
+     val job = launch(handler) {
+         val inner = launch(coroutineContext) {
+             launch(coroutineContext) {
+                 launch(coroutineContext) {
+                     throw IOException()
+                 }
+             }
+         }
+ 
+         try {
+             inner.join()
+         } catch (e: JobCancellationException) {
+             println("Rethrowing JobCancellationException with original cause")
+             throw e
+         }
+     }
+ 
+     job.join()
+}

core/kotlinx-coroutines-core/test/guide/test/GuideTest.kt

@@ -1,7 +1,7 @@
 // This file was automatically generated from coroutines-guide.md by Knit tool. Do not edit.
 package kotlinx.coroutines.experimental.guide.test
 
-import org.junit.Test
+import org.junit.*
 
 class GuideTest {
 
@@ -267,6 +267,58 @@ class GuideTest {
         )
     }
 
+    @Test
+    fun testKotlinxCoroutinesExperimentalGuideExceptions01() {
+        test("KotlinxCoroutinesExperimentalGuideExceptions01") { kotlinx.coroutines.experimental.guide.exceptions01.main(emptyArray()) }.verifyExceptions(
+            "Throwing exception from launch",
+            "Exception in thread \"ForkJoinPool.commonPool-worker-2 @coroutine#2\" java.lang.IndexOutOfBoundsException",
+            "Joined failed job",
+            "Throwing exception from async",
+            "Caught ArithmeticException"
+        )
+    }
+
+    @Test
+    fun testKotlinxCoroutinesExperimentalGuideExceptions02() {
+        test("KotlinxCoroutinesExperimentalGuideExceptions02") { kotlinx.coroutines.experimental.guide.exceptions02.main(emptyArray()) }.verifyLines(
+            "Caught java.lang.AssertionError"
+        )
+    }
+
+    @Test
+    fun testKotlinxCoroutinesExperimentalGuideExceptions03() {
+        test("KotlinxCoroutinesExperimentalGuideExceptions03") { kotlinx.coroutines.experimental.guide.exceptions03.main(emptyArray()) }.verifyLines(
+            "Cancelling child",
+            "Child is cancelled",
+            "Parent is not cancelled"
+        )
+    }
+
+    @Test
+    fun testKotlinxCoroutinesExperimentalGuideExceptions04() {
+        test("KotlinxCoroutinesExperimentalGuideExceptions04") { kotlinx.coroutines.experimental.guide.exceptions04.main(emptyArray()) }.verifyLines(
+            "Child throws an exception",
+            "Children are cancelled, but exception is not handled until children are terminated completely",
+            "Last child finished its non cancellable block",
+            "Caught java.lang.ArithmeticException"
+        )
+    }
+
+    @Test
+    fun testKotlinxCoroutinesExperimentalGuideExceptions05() {
+        test("KotlinxCoroutinesExperimentalGuideExceptions05") { kotlinx.coroutines.experimental.guide.exceptions05.main(emptyArray()) }.verifyLines(
+            "Caught java.io.IOException with suppressed [java.lang.ArithmeticException]"
+        )
+    }
+
+    @Test
+    fun testKotlinxCoroutinesExperimentalGuideExceptions06() {
+        test("KotlinxCoroutinesExperimentalGuideExceptions06") { kotlinx.coroutines.experimental.guide.exceptions06.main(emptyArray()) }.verifyLines(
+            "Rethrowing JobCancellationException with original cause",
+            "Caught original java.io.IOException"
+        )
+    }
+
     @Test
     fun testKotlinxCoroutinesExperimentalGuideChannel01() {
         test("KotlinxCoroutinesExperimentalGuideChannel01") { kotlinx.coroutines.experimental.guide.channel01.main(emptyArray()) }.verifyLines(

core/kotlinx-coroutines-core/test/guide/test/TestUtil.kt

@@ -169,6 +169,18 @@ fun List<String>.verifyLinesStartUnordered(vararg expected: String) {
     sorted().verifyLinesStart(*expectedSorted)
 }
 
+fun List<String>.verifyExceptions(vararg expected: String) {
+    val actual = filter { !it.startsWith("\tat ") }
+
+    val n = minOf(actual.size, expected.size)
+    for (i in 0 until n) {
+        val exp = sanitize(expected[i], SanitizeMode.FLEXIBLE_THREAD)
+        val act = sanitize(actual[i], SanitizeMode.FLEXIBLE_THREAD)
+        assertEquals("Line ${i + 1}", exp, act)
+    }
+}
+
+
 fun List<String>.verifyLinesStart(vararg expected: String) {
     val n = minOf(size, expected.size)
     for (i in 0 until n) {