Try to reproduce second resume (WIP)

Author: elizarov

kotlinx-coroutines-core/jvm/test/channels/ChannelAtomicCancelStressTest.kt

@@ -10,21 +10,49 @@ import org.junit.*
 import org.junit.Assert.*
 import org.junit.runner.*
 import org.junit.runners.*
-import kotlin.random.Random
 import java.util.concurrent.atomic.*
+import kotlin.random.*
+
+private const val DIRECT = 1
+private const val SELECT = 2
 
 /**
  * Tests cancel atomicity for channel send & receive operations, including their select versions.
  */
 @RunWith(Parameterized::class)
-class ChannelAtomicCancelStressTest(private val kind: TestChannelKind) : TestBase() {
+class ChannelAtomicCancelStressTest(
+    private val kind: TestChannelKind,
+    private val mode: Mode
+) : TestBase() {
+
+    enum class Mode(val send: Int, val receive: Int) {
+        SEND_RECEIVE(DIRECT, DIRECT),
+        SELECT_SEND_RECEIVE(SELECT, DIRECT),
+        SEND_SELECT_RECEIVE(DIRECT, SELECT),
+        SELECT_SEND_SELECT_RECEIVE(SELECT, SELECT),
+        RANDOM(DIRECT or SELECT, DIRECT or SELECT)
+    }
+
+    private fun Random.nextOp(mask: Int): Int =
+        when (mask) {
+            DIRECT or SELECT -> nextInt(DIRECT..SELECT)
+            else -> mask
+        }
+
     companion object {
-        @Parameterized.Parameters(name = "{0}")
+        @Parameterized.Parameters(name = "{0}, {1}")
         @JvmStatic
-        fun params(): Collection<Array<Any>> = TestChannelKind.values().map { arrayOf<Any>(it) }
+        fun params(): Collection<Array<Any>> =
+            // todo: all channels, all modes only in stress test
+            listOf(TestChannelKind.RENDEZVOUS).flatMap { kind ->
+                Mode.values().map { mode ->
+                    arrayOf<Any>(kind, mode)
+                }
+            }
     }
 
-    private val TEST_DURATION = 1000L * stressTestMultiplier
+    // todo: restore regular duration
+    private val TEST_DURATION = 10_000L * stressTestMultiplier
 
     private val dispatcher = newFixedThreadPoolContext(2, "ChannelAtomicCancelStressTest")
     private val scope = CoroutineScope(dispatcher)
@@ -104,9 +132,9 @@ class ChannelAtomicCancelStressTest(private val kind: TestChannelKind) : TestBas
                 var counter = 0
                 while (true) {
                     val trySend = lastSent + 1
-                    when (Random.nextInt(2)) {
-                        0 -> channel.send(trySend)
-                        1 -> select { channel.onSend(trySend) {} }
+                    when (Random.nextOp(mode.send)) {
+                        DIRECT -> channel.send(trySend)
+                        SELECT -> select { channel.onSend(trySend) {} }
                         else -> error("cannot happen")
                     }
                     lastSent = trySend // update on success
@@ -131,9 +159,9 @@ class ChannelAtomicCancelStressTest(private val kind: TestChannelKind) : TestBas
         receiver = scope.launch(start = CoroutineStart.ATOMIC) {
             cancellable(receiverDone) {
                 while (true) {
-                    val received = when (Random.nextInt(2)) {
-                        0 -> channel.receive()
-                        1 -> select { channel.onReceive { it } }
+                    val received = when (Random.nextOp(mode.receive)) {
+                        DIRECT -> channel.receive()
+                        SELECT -> select { channel.onReceive { it } }
                         else -> error("cannot happen")
                     }
                     val expected = lastReceived + 1