Fixed JDK16 tests & links in guide

elizarov · elizarov · commit 54617b7e4f25 · 2018-09-28T18:51:40.000+03:00
Fixes #625
diff --git a/core/kotlinx-coroutines-core/build.gradle b/core/kotlinx-coroutines-core/build.gradle
@@ -46,20 +46,18 @@ task jdk16Test(type: Test, dependsOn: [testClasses, checkJdk16]) {
     executable = "$System.env.JDK_16/bin/java"
     exclude '**/*LinearizabilityTest.*'
     exclude '**/*LFTest.*'
-    exclude '**/exceptions/.*'
+    exclude '**/exceptions/**'
+    exclude '**/ExceptionsGuideTest.*'
 }
 
-// Always run those tests
-task moreTest(dependsOn: [lockFreedomTest])
-
 // Run these tests only during nightly stress test
-task extraTest(dependsOn: [jdk16Test])
+jdk16Test.onlyIf { project.properties['stressTest'] != null }
 
+// Always run those tests
+task moreTest(dependsOn: [lockFreedomTest, jdk16Test])
 
 build.dependsOn moreTest
 
-extraTest.onlyIf { project.properties['stressTest'] != null }
-
 task testsJar(type: Jar, dependsOn: testClasses) {
     classifier = 'tests'
     from sourceSets.test.output
diff --git a/core/kotlinx-coroutines-core/test/exceptions/CoroutineExceptionHandlerJvmTest.kt b/core/kotlinx-coroutines-core/test/exceptions/CoroutineExceptionHandlerJvmTest.kt
@@ -35,7 +35,7 @@ class CoroutineExceptionHandlerJvmTest : TestBase() {
         job.join()
         assertTrue(caughtException is RuntimeException)
         assertTrue(caughtException.cause is AssertionError)
-        assertTrue(caughtException.suppressed()[0] is TestException)
+        assertTrue(caughtException.suppressed[0] is TestException)
 
         finish(3)
     }
diff --git a/core/kotlinx-coroutines-core/test/exceptions/Exceptions.kt b/core/kotlinx-coroutines-core/test/exceptions/Exceptions.kt
@@ -14,15 +14,16 @@ import kotlin.test.*
  * Proxy for [Throwable.getSuppressed] for tests, which are compiled for both JDK 1.6 and JDK 1.8,
  * but run only under JDK 1.8
  */
-fun Throwable.suppressed(): Array<Throwable> {
+@Suppress("ConflictingExtensionProperty")
+val Throwable.suppressed: Array<Throwable> get() {
     val method = this::class.java.getMethod("getSuppressed") ?: error("This test can only be run using JDK 1.7")
     @Suppress("UNCHECKED_CAST")
     return method.invoke(this) as Array<Throwable>
 }
 
 internal inline fun <reified T : Throwable> checkException(exception: Throwable): Boolean {
     assertTrue(exception is T)
-    assertTrue(exception.suppressed().isEmpty())
+    assertTrue(exception.suppressed.isEmpty())
     assertNull(exception.cause)
     return true
 }
diff --git a/core/kotlinx-coroutines-core/test/exceptions/JobBasicCancellationTest.kt b/core/kotlinx-coroutines-core/test/exceptions/JobBasicCancellationTest.kt
@@ -152,6 +152,6 @@ class JobBasicCancellationTest : TestBase() {
         val cause = deferred.getCancellationException().cause!!
         assertTrue(cause is IndexOutOfBoundsException)
         assertNull(cause.cause)
-        assertTrue(cause.suppressed().isEmpty())
+        assertTrue(cause.suppressed.isEmpty())
     }
 }
diff --git a/core/kotlinx-coroutines-core/test/exceptions/JobExceptionHandlingTest.kt b/core/kotlinx-coroutines-core/test/exceptions/JobExceptionHandlingTest.kt
@@ -48,7 +48,7 @@ class JobExceptionHandlingTest : TestBase() {
             deferred.await()
             expectUnreached()
         } catch (e: IOException) {
-            assertTrue(e.suppressed().isEmpty())
+            assertTrue(e.suppressed.isEmpty())
             finish(3)
         }
     }
@@ -68,7 +68,7 @@ class JobExceptionHandlingTest : TestBase() {
             deferred.await()
             expectUnreached()
         } catch (e: IOException) {
-            assertTrue(e.suppressed().isEmpty())
+            assertTrue(e.suppressed.isEmpty())
             finish(3)
         }
     }
@@ -122,7 +122,7 @@ class JobExceptionHandlingTest : TestBase() {
         }
 
         assertTrue(exception is ArithmeticException)
-        val suppressed = exception.suppressed()
+        val suppressed = exception.suppressed
         assertEquals(2, suppressed.size)
         checkException<NullPointerException>(suppressed[0])
         checkException<IOException>(suppressed[1])
@@ -225,7 +225,7 @@ class JobExceptionHandlingTest : TestBase() {
 
         assertTrue(exception is IOException)
         assertNull(exception.cause)
-        val suppressed = exception.suppressed()
+        val suppressed = exception.suppressed
         assertEquals(1, suppressed.size)
         checkException<ArithmeticException>(suppressed[0])
     }
@@ -266,7 +266,7 @@ class JobExceptionHandlingTest : TestBase() {
         }
 
         assertTrue(exception is ArithmeticException)
-        val suppressed = exception.suppressed()
+        val suppressed = exception.suppressed
         assertEquals(2, suppressed.size)
         assertTrue(suppressed[0] is IOException)
         assertTrue(suppressed[1] is IllegalArgumentException)
@@ -303,7 +303,7 @@ class JobExceptionHandlingTest : TestBase() {
         }
 
         assertTrue(exception is AssertionError)
-        val suppressed = exception.suppressed()
+        val suppressed = exception.suppressed
         assertEquals(2, suppressed.size)
         assertTrue(suppressed[0] is IOException)
         assertTrue(suppressed[1] is IllegalArgumentException)
diff --git a/core/kotlinx-coroutines-core/test/exceptions/JobExceptionsStressTest.kt b/core/kotlinx-coroutines-core/test/exceptions/JobExceptionsStressTest.kt
@@ -53,7 +53,7 @@ class JobExceptionsStressTest : TestBase() {
                 TestException2::class,
                 TestException3::class
             )
-            val suppressedExceptions = exception.suppressed().toSet()
+            val suppressedExceptions = exception.suppressed.toSet()
             assertTrue(classes.remove(exception::class),
                 "Failed to remove ${exception::class} from $suppressedExceptions"
             )
diff --git a/core/kotlinx-coroutines-core/test/exceptions/JobNestedExceptionsTest.kt b/core/kotlinx-coroutines-core/test/exceptions/JobNestedExceptionsTest.kt
@@ -81,7 +81,7 @@ class JobNestedExceptionsTest : TestBase() {
             finish(5)
         }
         assertTrue(exception is ArithmeticException, "Found $exception")
-        checkException<IOException>(exception.suppressed()[0])
+        checkException<IOException>(exception.suppressed[0])
     }
 
     @Test
@@ -111,10 +111,10 @@ class JobNestedExceptionsTest : TestBase() {
         assertEquals(1, exceptions.size, "Found $exceptions")
         val exception = exceptions[0]
         assertTrue(exception is ArithmeticException, "Exception is $exception")
-        val suppressed = exception.suppressed()
+        val suppressed = exception.suppressed
         val ioe = suppressed[0]
         assertTrue(ioe is IOException)
-        checkException<NullPointerException>(ioe.suppressed()[0])
+        checkException<NullPointerException>(ioe.suppressed[0])
         checkCycles(exception)
     }
 }
diff --git a/core/kotlinx-coroutines-core/test/exceptions/ProduceExceptionsTest.kt b/core/kotlinx-coroutines-core/test/exceptions/ProduceExceptionsTest.kt
@@ -33,7 +33,7 @@ class ProduceExceptionsTest : TestBase() {
 
     @Test
     fun testSuppressedExceptionUncaught() =
-        runTest(unhandled = listOf({ e -> e is TestException && e.suppressed()[0] is TestException2 })) {
+        runTest(unhandled = listOf({ e -> e is TestException && e.suppressed[0] is TestException2 })) {
             val produce = produce<Int>(Job()) {
                 launch(start = CoroutineStart.ATOMIC) {
                     throw TestException()
@@ -66,7 +66,7 @@ class ProduceExceptionsTest : TestBase() {
             produce.receive()
             expectUnreached()
         } catch (e: TestException) {
-            assertTrue(e.suppressed()[0] is TestException2)
+            assertTrue(e.suppressed[0] is TestException2)
         }
     }
 
@@ -89,7 +89,7 @@ class ProduceExceptionsTest : TestBase() {
         try {
             channel.receive()
         } catch (e: ClosedReceiveChannelException) {
-            assertTrue(e.suppressed().isEmpty())
+            assertTrue(e.suppressed.isEmpty())
             finish(4)
         }
     }
@@ -114,7 +114,7 @@ class ProduceExceptionsTest : TestBase() {
         try {
             channel.receive()
         } catch (e: TestException) {
-            assertTrue(e.suppressed().isEmpty())
+            assertTrue(e.suppressed.isEmpty())
             finish(4)
         }
     }
@@ -138,7 +138,7 @@ class ProduceExceptionsTest : TestBase() {
         try {
             channel.receive()
         } catch (e: CancellationException) {
-            assertTrue(e.suppressed().isEmpty())
+            assertTrue(e.suppressed.isEmpty())
             finish(4)
         }
     }
diff --git a/core/kotlinx-coroutines-core/test/exceptions/SuppresionTests.kt b/core/kotlinx-coroutines-core/test/exceptions/SuppresionTests.kt
@@ -26,7 +26,7 @@ class SuppresionTests : TestBase() {
         try {
             deferred.await()
         } catch (e: IOException) {
-            checkException<ArithmeticException>(e.suppressed()[0])
+            checkException<ArithmeticException>(e.suppressed[0])
             finish(3)
         }
     }
@@ -42,7 +42,7 @@ class SuppresionTests : TestBase() {
 
             override fun onCancellation(cause: Throwable?) {
                 assertTrue(cause is ArithmeticException)
-                assertTrue(cause!!.suppressed().isEmpty())
+                assertTrue(cause!!.suppressed.isEmpty())
                 expect(5)
             }
 
@@ -52,20 +52,20 @@ class SuppresionTests : TestBase() {
 
             override fun onCompletedExceptionally(exception: Throwable) {
                 assertTrue(exception is ArithmeticException)
-                checkException<IOException>(exception.suppressed()[0])
+                checkException<IOException>(exception.suppressed[0])
                 expect(9)
             }
         }
 
         coroutine.invokeOnCompletion(onCancelling = true) {
             assertTrue(it is ArithmeticException)
-            assertTrue(it!!.suppressed().isEmpty())
+            assertTrue(it!!.suppressed.isEmpty())
             expect(6)
         }
 
         coroutine.invokeOnCompletion {
             assertTrue(it is ArithmeticException)
-            checkException<IOException>(it!!.suppressed()[0])
+            checkException<IOException>(it!!.suppressed[0])
             expect(8)
         }
 
diff --git a/core/kotlinx-coroutines-core/test/exceptions/WithContextCancellationStressTest.kt b/core/kotlinx-coroutines-core/test/exceptions/WithContextCancellationStressTest.kt
@@ -2,9 +2,9 @@
  * Copyright 2016-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license.
  */
 
-package kotlinx.coroutines.experimental
+package kotlinx.coroutines.experimental.exceptions
 
-import kotlinx.coroutines.experimental.exceptions.*
+import kotlinx.coroutines.experimental.*
 import org.junit.*
 import org.junit.Test
 import java.io.*
@@ -92,7 +92,7 @@ class WithContextCancellationStressTest : TestBase() {
         aeException: Boolean = false,
         aioobException: Boolean = false
     ) {
-        val suppressed = suppressed()
+        val suppressed: Array<Throwable> = suppressed
 
         try {
             if (ioException) {
diff --git a/core/kotlinx-coroutines-core/test/exceptions/WithContextExceptionHandlingTest.kt b/core/kotlinx-coroutines-core/test/exceptions/WithContextExceptionHandlingTest.kt
@@ -30,7 +30,7 @@ class WithContextExceptionHandlingTest(private val withContext: Boolean) : TestB
         runCancellation(null, IllegalStateException()) { e ->
             assertTrue(e is IllegalStateException)
             assertNull(e.cause)
-            val suppressed = e.suppressed()
+            val suppressed = e.suppressed
             assertTrue(suppressed.isEmpty())
         }
     }
@@ -46,7 +46,7 @@ class WithContextExceptionHandlingTest(private val withContext: Boolean) : TestB
         runCancellation(cancellationCause, IllegalStateException()) { e ->
             assertTrue(e is IOException)
             assertNull(e.cause)
-            val suppressed = e.suppressed()
+            val suppressed = e.suppressed
             assertEquals(suppressed.size, 1)
             assertTrue(suppressed[0] is IllegalStateException)
         }
@@ -63,7 +63,7 @@ class WithContextExceptionHandlingTest(private val withContext: Boolean) : TestB
         runCancellation(cancellationCause, cancellationCause) { e ->
             assertTrue(e is IllegalStateException)
             assertNull(e.cause)
-            val suppressed = e.suppressed()
+            val suppressed = e.suppressed
             assertTrue(suppressed.isEmpty())
         }
     }
@@ -79,7 +79,7 @@ class WithContextExceptionHandlingTest(private val withContext: Boolean) : TestB
         runCancellation(cancellationCause, cancellationCause) { e ->
             assertSame(e, cancellationCause)
             assertNull(e.cause)
-            val suppressed = e.suppressed()
+            val suppressed = e.suppressed
             assertTrue(suppressed.isEmpty())
         }
     }
@@ -97,7 +97,7 @@ class WithContextExceptionHandlingTest(private val withContext: Boolean) : TestB
         runCancellation(cancellationCause, exception) { e ->
             assertSame(exception, e)
             assertNull(e.cause)
-            assertTrue(e.suppressed().isEmpty())
+            assertTrue(e.suppressed.isEmpty())
         }
     }
 
@@ -113,7 +113,7 @@ class WithContextExceptionHandlingTest(private val withContext: Boolean) : TestB
         thrown.initCause(IOException())
         runCancellation(cancellationCause, thrown) { e ->
             assertSame(cancellationCause, e)
-            val suppressed = e.suppressed()
+            val suppressed = e.suppressed
             assertEquals(1, suppressed.size)
             assertTrue(suppressed[0] is IOException)
         }
@@ -130,7 +130,7 @@ class WithContextExceptionHandlingTest(private val withContext: Boolean) : TestB
         val thrown = CancellationException()
         runCancellation(cancellationCause, thrown) { e ->
             assertSame(cancellationCause, e)
-            val suppressed = e.suppressed()
+            val suppressed = e.suppressed
             assertTrue(suppressed.isEmpty())
         }
     }
@@ -147,7 +147,7 @@ class WithContextExceptionHandlingTest(private val withContext: Boolean) : TestB
         runCancellation(cancellationCause, thrown) { e ->
             assertSame(cancellationCause, e)
             assertNull(e.cause)
-            assertTrue(e.suppressed().isEmpty())
+            assertTrue(e.suppressed.isEmpty())
         }
     }
 
@@ -172,7 +172,7 @@ class WithContextExceptionHandlingTest(private val withContext: Boolean) : TestB
     fun testCancel() = runTest {
         runOnlyCancellation(null) { e ->
             assertNull(e.cause)
-            assertTrue(e.suppressed().isEmpty())
+            assertTrue(e.suppressed.isEmpty())
         }
     }
 
@@ -181,7 +181,7 @@ class WithContextExceptionHandlingTest(private val withContext: Boolean) : TestB
         val cause = IOException()
         runOnlyCancellation(cause) { e ->
             assertSame(cause, e)
-            assertTrue(e.suppressed().isEmpty())
+            assertTrue(e.suppressed.isEmpty())
         }
     }
 
@@ -191,7 +191,7 @@ class WithContextExceptionHandlingTest(private val withContext: Boolean) : TestB
         runThrowing(cause) { e ->
             assertSame(cause, e)
             assertNull(e.cause)
-            assertTrue(e.suppressed().isEmpty())
+            assertTrue(e.suppressed.isEmpty())
         }
     }
 
diff --git a/core/kotlinx-coroutines-core/test/guide/example-exceptions-05.kt b/core/kotlinx-coroutines-core/test/guide/example-exceptions-05.kt
@@ -12,7 +12,7 @@ import java.io.*
 
 fun main(args: Array<String>) = runBlocking {
     val handler = CoroutineExceptionHandler { _, exception ->
-        println("Caught $exception with suppressed ${exception.suppressed().contentToString()}")
+        println("Caught $exception with suppressed ${exception.suppressed.contentToString()}")
     }
     val job = GlobalScope.launch(handler) {
         launch {
diff --git a/docs/exception-handling.md b/docs/exception-handling.md
@@ -268,7 +268,7 @@ import java.io.*
 ```kotlin
 fun main(args: Array<String>) = runBlocking {
     val handler = CoroutineExceptionHandler { _, exception ->
-        println("Caught $exception with suppressed ${exception.suppressed().contentToString()}")
+        println("Caught $exception with suppressed ${exception.suppressed.contentToString()}")
     }
     val job = GlobalScope.launch(handler) {
         launch {
@@ -292,6 +292,8 @@ fun main(args: Array<String>) = runBlocking {
 
 > You can get full code [here](../core/kotlinx-coroutines-core/test/guide/example-exceptions-05.kt)
 
+> Note: This above code will work properly only on JDK7+ that supports `suppressed` exceptions
+
 The output of this code is:
 
 ```text
@@ -510,10 +512,11 @@ Scope is completed
 <!--- MODULE kotlinx-coroutines-core -->
 <!--- INDEX kotlinx.coroutines.experimental -->
 [CancellationException]: https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines.experimental/-cancellation-exception/index.html
+[launch]: https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines.experimental/launch.html
+[async]: https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines.experimental/async.html
 [Deferred.await]: https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines.experimental/-deferred/await.html
 [GlobalScope]: https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines.experimental/-global-scope/index.html
 [CoroutineExceptionHandler]: https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines.experimental/-coroutine-exception-handler/index.html
-[async]: https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines.experimental/async.html
 [Job.cancel]: https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines.experimental/-job/cancel.html
 [runBlocking]: https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines.experimental/run-blocking.html
 [SupervisorJob()]: https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines.experimental/-supervisor-job.html
diff --git a/knit/src/Knit.kt b/knit/src/Knit.kt

Original file line number	Diff line number	Diff line change
`@@ -35,7 +35,7 @@ class CoroutineExceptionHandlerJvmTest : TestBase() {`
`35`	`35`	`job.join()`
`36`	`36`	`assertTrue(caughtException is RuntimeException)`
`37`	`37`	`assertTrue(caughtException.cause is AssertionError)`
`38`		`- assertTrue(caughtException.suppressed()[0] is TestException)`
	`38`	`+ assertTrue(caughtException.suppressed[0] is TestException)`
`39`	`39`
`40`	`40`	`finish(3)`
`41`	`41`	`}`
Original file line number	Diff line number	Diff line change
`@@ -152,6 +152,6 @@ class JobBasicCancellationTest : TestBase() {`
`152`	`152`	`val cause = deferred.getCancellationException().cause!!`
`153`	`153`	`assertTrue(cause is IndexOutOfBoundsException)`
`154`	`154`	`assertNull(cause.cause)`
`155`		`- assertTrue(cause.suppressed().isEmpty())`
	`155`	`+ assertTrue(cause.suppressed.isEmpty())`
`156`	`156`	`}`
`157`	`157`	`}`
Original file line number	Diff line number	Diff line change
`@@ -53,7 +53,7 @@ class JobExceptionsStressTest : TestBase() {`
`53`	`53`	`TestException2::class,`
`54`	`54`	`TestException3::class`
`55`	`55`	`)`
`56`		`- val suppressedExceptions = exception.suppressed().toSet()`
	`56`	`+ val suppressedExceptions = exception.suppressed.toSet()`
`57`	`57`	`assertTrue(classes.remove(exception::class),`
`58`	`58`	`"Failed to remove ${exception::class} from $suppressedExceptions"`
`59`	`59`	`)`
Original file line number	Diff line number	Diff line change
`@@ -81,7 +81,7 @@ class JobNestedExceptionsTest : TestBase() {`
`81`	`81`	`finish(5)`
`82`	`82`	`}`
`83`	`83`	`assertTrue(exception is ArithmeticException, "Found $exception")`
`84`		`- checkException<IOException>(exception.suppressed()[0])`
	`84`	`+ checkException<IOException>(exception.suppressed[0])`
`85`	`85`	`}`
`86`	`86`
`87`	`87`	`@Test`
`@@ -111,10 +111,10 @@ class JobNestedExceptionsTest : TestBase() {`
`111`	`111`	`assertEquals(1, exceptions.size, "Found $exceptions")`
`112`	`112`	`val exception = exceptions[0]`
`113`	`113`	`assertTrue(exception is ArithmeticException, "Exception is $exception")`
`114`		`- val suppressed = exception.suppressed()`
	`114`	`+ val suppressed = exception.suppressed`
`115`	`115`	`val ioe = suppressed[0]`
`116`	`116`	`assertTrue(ioe is IOException)`
`117`		`- checkException<NullPointerException>(ioe.suppressed()[0])`
	`117`	`+ checkException<NullPointerException>(ioe.suppressed[0])`
`118`	`118`	`checkCycles(exception)`
`119`	`119`	`}`
`120`	`120`	`}`
Original file line number	Diff line number	Diff line change
`@@ -33,7 +33,7 @@ class ProduceExceptionsTest : TestBase() {`
`33`	`33`
`34`	`34`	`@Test`
`35`	`35`	`fun testSuppressedExceptionUncaught() =`
`36`		`- runTest(unhandled = listOf({ e -> e is TestException && e.suppressed()[0] is TestException2 })) {`
	`36`	`+ runTest(unhandled = listOf({ e -> e is TestException && e.suppressed[0] is TestException2 })) {`
`37`	`37`	`val produce = produce<Int>(Job()) {`
`38`	`38`	`launch(start = CoroutineStart.ATOMIC) {`
`39`	`39`	`throw TestException()`
`@@ -66,7 +66,7 @@ class ProduceExceptionsTest : TestBase() {`
`66`	`66`	`produce.receive()`
`67`	`67`	`expectUnreached()`
`68`	`68`	`} catch (e: TestException) {`
`69`		`- assertTrue(e.suppressed()[0] is TestException2)`
	`69`	`+ assertTrue(e.suppressed[0] is TestException2)`
`70`	`70`	`}`
`71`	`71`	`}`
`72`	`72`
`@@ -89,7 +89,7 @@ class ProduceExceptionsTest : TestBase() {`
`89`	`89`	`try {`
`90`	`90`	`channel.receive()`
`91`	`91`	`} catch (e: ClosedReceiveChannelException) {`
`92`		`- assertTrue(e.suppressed().isEmpty())`
	`92`	`+ assertTrue(e.suppressed.isEmpty())`
`93`	`93`	`finish(4)`
`94`	`94`	`}`
`95`	`95`	`}`
`@@ -114,7 +114,7 @@ class ProduceExceptionsTest : TestBase() {`
`114`	`114`	`try {`
`115`	`115`	`channel.receive()`
`116`	`116`	`} catch (e: TestException) {`
`117`		`- assertTrue(e.suppressed().isEmpty())`
	`117`	`+ assertTrue(e.suppressed.isEmpty())`
`118`	`118`	`finish(4)`
`119`	`119`	`}`
`120`	`120`	`}`
`@@ -138,7 +138,7 @@ class ProduceExceptionsTest : TestBase() {`
`138`	`138`	`try {`
`139`	`139`	`channel.receive()`
`140`	`140`	`} catch (e: CancellationException) {`
`141`		`- assertTrue(e.suppressed().isEmpty())`
	`141`	`+ assertTrue(e.suppressed.isEmpty())`
`142`	`142`	`finish(4)`
`143`	`143`	`}`
`144`	`144`	`}`
Original file line number	Diff line number	Diff line change
`@@ -26,7 +26,7 @@ class SuppresionTests : TestBase() {`
`26`	`26`	`try {`
`27`	`27`	`deferred.await()`
`28`	`28`	`} catch (e: IOException) {`
`29`		`- checkException<ArithmeticException>(e.suppressed()[0])`
	`29`	`+ checkException<ArithmeticException>(e.suppressed[0])`
`30`	`30`	`finish(3)`
`31`	`31`	`}`
`32`	`32`	`}`
`@@ -42,7 +42,7 @@ class SuppresionTests : TestBase() {`
`42`	`42`
`43`	`43`	`override fun onCancellation(cause: Throwable?) {`
`44`	`44`	`assertTrue(cause is ArithmeticException)`
`45`		`- assertTrue(cause!!.suppressed().isEmpty())`
	`45`	`+ assertTrue(cause!!.suppressed.isEmpty())`
`46`	`46`	`expect(5)`
`47`	`47`	`}`
`48`	`48`
`@@ -52,20 +52,20 @@ class SuppresionTests : TestBase() {`
`52`	`52`
`53`	`53`	`override fun onCompletedExceptionally(exception: Throwable) {`
`54`	`54`	`assertTrue(exception is ArithmeticException)`
`55`		`- checkException<IOException>(exception.suppressed()[0])`
	`55`	`+ checkException<IOException>(exception.suppressed[0])`
`56`	`56`	`expect(9)`
`57`	`57`	`}`
`58`	`58`	`}`
`59`	`59`
`60`	`60`	`coroutine.invokeOnCompletion(onCancelling = true) {`
`61`	`61`	`assertTrue(it is ArithmeticException)`
`62`		`- assertTrue(it!!.suppressed().isEmpty())`
	`62`	`+ assertTrue(it!!.suppressed.isEmpty())`
`63`	`63`	`expect(6)`
`64`	`64`	`}`
`65`	`65`
`66`	`66`	`coroutine.invokeOnCompletion {`
`67`	`67`	`assertTrue(it is ArithmeticException)`
`68`		`- checkException<IOException>(it!!.suppressed()[0])`
	`68`	`+ checkException<IOException>(it!!.suppressed[0])`
`69`	`69`	`expect(8)`
`70`	`70`	`}`
`71`	`71`