Refactor multi-shot tests

qwwdfsad · qwwdfsad · commit 83464e7b9226 · 2021-07-15T19:07:22.000+03:00
* Wrap them in 'withContext(Job)' instead of 'runTest' to be properly working on JS * Skip few way too slow for JS tests only on JS platform Fixes #2820
diff --git a/kotlinx-coroutines-core/common/test/CancelledParentAttachTest.kt b/kotlinx-coroutines-core/common/test/CancelledParentAttachTest.kt
@@ -11,75 +11,105 @@ import kotlin.test.*
 class CancelledParentAttachTest : TestBase() {
 
     @Test
-    fun testAsync() = CoroutineStart.values().forEach(::testAsyncCancelledParent)
+    fun testAsync() = runTest {
+        CoroutineStart.values().forEach { testAsyncCancelledParent(it) }
+    }
 
-    private fun testAsyncCancelledParent(start: CoroutineStart) =
-        runTest({ it is CancellationException }) {
-            cancel()
-            expect(1)
-            val d = async<Int>(start = start) { 42 }
-            expect(2)
-            d.invokeOnCompletion {
-                finish(3)
-                reset()
+    private suspend fun testAsyncCancelledParent(start: CoroutineStart) {
+        try {
+            withContext(Job()) {
+                cancel()
+                expect(1)
+                val d = async<Int>(start = start) { 42 }
+                expect(2)
+                d.invokeOnCompletion {
+                    finish(3)
+                    reset()
+                }
             }
+            expectUnreached()
+        } catch (e: CancellationException) {
+            // Expected
         }
+    }
 
     @Test
-    fun testLaunch() = CoroutineStart.values().forEach(::testLaunchCancelledParent)
+    fun testLaunch() = runTest {
+        CoroutineStart.values().forEach { testLaunchCancelledParent(it) }
+    }
 
-    private fun testLaunchCancelledParent(start: CoroutineStart) =
-        runTest({ it is CancellationException }) {
-            cancel()
-            expect(1)
-            val d = launch(start = start) { }
-            expect(2)
-            d.invokeOnCompletion {
-                finish(3)
-                reset()
+    private suspend fun testLaunchCancelledParent(start: CoroutineStart) {
+        try {
+            withContext(Job()) {
+                cancel()
+                expect(1)
+                val d = launch(start = start) { }
+                expect(2)
+                d.invokeOnCompletion {
+                    finish(3)
+                    reset()
+                }
             }
+            expectUnreached()
+        } catch (e: CancellationException) {
+            // Expected
         }
+    }
 
     @Test
-    fun testProduce() =
-        runTest({ it is CancellationException }) {
-            cancel()
-            expect(1)
-            val d = produce<Int> { }
-            expect(2)
-            (d as Job).invokeOnCompletion {
-                finish(3)
-                reset()
-            }
+    fun testProduce() = runTest({ it is CancellationException }) {
+        cancel()
+        expect(1)
+        val d = produce<Int> { }
+        expect(2)
+        (d as Job).invokeOnCompletion {
+            finish(3)
+            reset()
         }
+    }
 
     @Test
-    fun testBroadcast() = CoroutineStart.values().forEach(::testBroadcastCancelledParent)
+    fun testBroadcast() = runTest {
+        CoroutineStart.values().forEach { testBroadcastCancelledParent(it) }
+    }
 
-    private fun testBroadcastCancelledParent(start: CoroutineStart) =
-        runTest({ it is CancellationException }) {
-            cancel()
-            expect(1)
-            val bc = broadcast<Int>(start = start) {}
-            expect(2)
-            (bc as Job).invokeOnCompletion {
-                finish(3)
-                reset()
+    private suspend fun testBroadcastCancelledParent(start: CoroutineStart) {
+        try {
+            withContext(Job()) {
+                cancel()
+                expect(1)
+                val bc = broadcast<Int>(start = start) {}
+                expect(2)
+                (bc as Job).invokeOnCompletion {
+                    finish(3)
+                    reset()
+                }
             }
+            expectUnreached()
+        } catch (e: CancellationException) {
+            // Expected
         }
+    }
 
     @Test
-    fun testScopes() {
-        testScope { coroutineScope {  } }
-        testScope { supervisorScope {  } }
-        testScope { flowScope {  } }
-        testScope { withTimeout(Long.MAX_VALUE) {  } }
-        testScope { withContext(Job()) {  } }
-        testScope { withContext(CoroutineName("")) {  } }
+    fun testScopes() = runTest {
+        testScope { coroutineScope { } }
+        testScope { supervisorScope { } }
+        testScope { flowScope { } }
+        testScope { withTimeout(Long.MAX_VALUE) { } }
+        testScope { withContext(Job()) { } }
+        testScope { withContext(CoroutineName("")) { } }
     }
 
-    private inline fun testScope(crossinline block: suspend () -> Unit) = runTest({ it is CancellationException }) {
-        cancel()
-        block()
+    private suspend inline fun testScope(crossinline block: suspend () -> Unit) {
+        try {
+            withContext(Job()) {
+                cancel()
+                block()
+            }
+            expectUnreached()
+        } catch (e: CancellationException) {
+            // Expected
+        }
     }
 }
diff --git a/kotlinx-coroutines-core/common/test/TestBase.common.kt b/kotlinx-coroutines-core/common/test/TestBase.common.kt
@@ -14,6 +14,7 @@ public expect val isStressTest: Boolean
 public expect val stressTestMultiplier: Int
 
 public expect open class TestBase constructor() {
+    public val isJs: Boolean
     public fun error(message: Any, cause: Throwable? = null): Nothing
     public fun expect(index: Int)
     public fun expectUnreached()
diff --git a/kotlinx-coroutines-core/common/test/channels/ChannelUndeliveredElementTest.kt b/kotlinx-coroutines-core/common/test/channels/ChannelUndeliveredElementTest.kt
@@ -10,17 +10,19 @@ import kotlin.test.*
 
 class ChannelUndeliveredElementTest : TestBase() {
     @Test
-    fun testSendSuccessfully() = runAllKindsTest { kind ->
-        val channel = kind.create<Resource> { it.cancel() }
-        val res = Resource("OK")
-        launch {
-            channel.send(res)
+    fun testSendSuccessfully() = runTest {
+        runAllKindsTest { kind ->
+            val channel = kind.create<Resource> { it.cancel() }
+            val res = Resource("OK")
+            launch {
+                channel.send(res)
+            }
+            val ok = channel.receive()
+            assertEquals("OK", ok.value)
+            assertFalse(res.isCancelled) // was not cancelled
+            channel.close()
+            assertFalse(res.isCancelled) // still was not cancelled
         }
-        val ok = channel.receive()
-        assertEquals("OK", ok.value)
-        assertFalse(res.isCancelled) // was not cancelled
-        channel.close()
-        assertFalse(res.isCancelled) // still was not cancelled
     }
 
     @Test
@@ -86,21 +88,23 @@ class ChannelUndeliveredElementTest : TestBase() {
     }
 
     @Test
-    fun testSendToClosedChannel() = runAllKindsTest { kind ->
-        val channel = kind.create<Resource> { it.cancel() }
-        channel.close() // immediately close channel
-        val res = Resource("OK")
-        assertFailsWith<ClosedSendChannelException> {
-            channel.send(res) // send fails to closed channel, resource was not delivered
+    fun testSendToClosedChannel() = runTest {
+        runAllKindsTest { kind ->
+            val channel = kind.create<Resource> { it.cancel() }
+            channel.close() // immediately close channel
+            val res = Resource("OK")
+            assertFailsWith<ClosedSendChannelException> {
+                channel.send(res) // send fails to closed channel, resource was not delivered
+            }
+            assertTrue(res.isCancelled)
         }
-        assertTrue(res.isCancelled)
     }
 
-    private fun runAllKindsTest(test: suspend CoroutineScope.(TestChannelKind) -> Unit) {
+    private suspend fun runAllKindsTest(test: suspend CoroutineScope.(TestChannelKind) -> Unit) {
         for (kind in TestChannelKind.values()) {
             if (kind.viaBroadcast) continue // does not support onUndeliveredElement
             try {
-                runTest {
+                withContext(Job()) {
                     test(kind)
                 }
             } catch(e: Throwable) {
diff --git a/kotlinx-coroutines-core/common/test/flow/sharing/SharedFlowTest.kt b/kotlinx-coroutines-core/common/test/flow/sharing/SharedFlowTest.kt
@@ -439,7 +439,8 @@ class SharedFlowTest : TestBase() {
     }
 
     @Test
-    fun testDifferentBufferedFlowCapacities() {
+    fun testDifferentBufferedFlowCapacities() = runTest {
+        if (isJs) return@runTest // Too slow for JS, bounded by 2 sec. default JS timeout
         for (replay in 0..10) {
             for (extraBufferCapacity in 0..5) {
                 if (replay == 0 && extraBufferCapacity == 0) continue // test only buffered shared flows
@@ -456,7 +457,7 @@ class SharedFlowTest : TestBase() {
         }
     }
 
-    private fun testBufferedFlow(sh: MutableSharedFlow<Int>, replay: Int) = runTest {
+    private suspend fun testBufferedFlow(sh: MutableSharedFlow<Int>, replay: Int) = withContext(Job()) {
         reset()
         expect(1)
         val n = 100 // initially emitted to fill buffer
@@ -678,6 +679,7 @@ class SharedFlowTest : TestBase() {
 
     @Test
     fun testStateFlowModel() = runTest {
+        if (isJs) return@runTest // Too slow for JS, bounded by 2 sec. default JS timeout
         val stateFlow = MutableStateFlow<Data?>(null)
         val expect = modelLog(stateFlow)
         val sharedFlow = MutableSharedFlow<Data?>(
@@ -795,4 +797,4 @@ class SharedFlowTest : TestBase() {
         job.join()
         finish(5)
     }
-}
+}
diff --git a/kotlinx-coroutines-core/js/test/TestBase.kt b/kotlinx-coroutines-core/js/test/TestBase.kt
@@ -10,10 +10,11 @@ public actual val isStressTest: Boolean = false
 public actual val stressTestMultiplier: Int = 1
 
 public actual open class TestBase actual constructor() {
+    public actual val isJs = true
     private var actionIndex = 0
     private var finished = false
     private var error: Throwable? = null
-    private var previousPromise: Promise<*>? = null
+    private var lastTestPromise: Promise<*>? = null
 
     /**
      * Throws [IllegalStateException] like `error` in stdlib, but also ensures that the test will not
@@ -80,7 +81,7 @@ public actual open class TestBase actual constructor() {
     ): dynamic {
         var exCount = 0
         var ex: Throwable? = null
-        if (previousPromise != null) {
+        if (lastTestPromise != null) {
             error("Attempt to run multiple asynchronous test within one @Test method")
         }
         val result = GlobalScope.promise(block = block, context = CoroutineExceptionHandler { context, e ->
@@ -106,7 +107,7 @@ public actual open class TestBase actual constructor() {
             error?.let { throw it }
             check(actionIndex == 0 || finished) { "Expecting that 'finish(...)' was invoked, but it was not" }
         }
-        previousPromise = result
+        lastTestPromise = result
         return result
     }
 }
diff --git a/kotlinx-coroutines-core/jvm/test/TestBase.kt b/kotlinx-coroutines-core/jvm/test/TestBase.kt
@@ -50,6 +50,7 @@ public val stressTestMultiplierCbrt = cbrt(stressTestMultiplier.toDouble()).roun
  * ```
  */
 public actual open class TestBase actual constructor() {
+    public actual val isJs = false
     private var actionIndex = AtomicInteger()
     private var finished = AtomicBoolean()
     private var error = AtomicReference<Throwable>()
diff --git a/kotlinx-coroutines-core/native/test/TestBase.kt b/kotlinx-coroutines-core/native/test/TestBase.kt
@@ -8,6 +8,7 @@ public actual val isStressTest: Boolean = false
 public actual val stressTestMultiplier: Int = 1
 
 public actual open class TestBase actual constructor() {
+    public actual val isJs = false
     private var actionIndex = 0
     private var finished = false
     private var error: Throwable? = null
