Move most tests in the test module to common code

Author: dkhalanskyjb

kotlinx-coroutines-test/jvm/test/TestCoroutineDispatcherOrderTest.kt renamed to kotlinx-coroutines-test/common/test/TestCoroutineDispatcherOrderTest.kt

@@ -2,11 +2,26 @@
  * Copyright 2016-2021 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license.
  */
 
+import kotlinx.atomicfu.*
 import kotlinx.coroutines.*
 import kotlinx.coroutines.test.*
 import kotlin.test.*
 
-class TestCoroutineDispatcherOrderTest : TestBase() {
+class TestCoroutineDispatcherOrderTest {
+
+    private val actionIndex = atomic(0)
+    private val finished = atomic(false)
+
+    private fun expect(index: Int) {
+        val wasIndex = actionIndex.incrementAndGet()
+        // println("expect($index), wasIndex=$wasIndex")
+        check(index == wasIndex) { "Expecting action index $index but it is actually $wasIndex" }
+    }
+
+    private fun finish(index: Int) {
+        expect(index)
+        check(!finished.getAndSet(true)) { "Should call 'finish(...)' at most once" }
+    }
 
     @Test
     fun testAdvanceTimeBy_progressesOnEachDelay() {

kotlinx-coroutines-test/jvm/test/TestRunBlockingOrderTest.kt renamed to kotlinx-coroutines-test/common/test/TestRunBlockingOrderTest.kt

@@ -2,11 +2,27 @@
  * Copyright 2016-2021 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license.
  */
 
+import kotlinx.atomicfu.*
 import kotlinx.coroutines.*
 import kotlinx.coroutines.test.*
 import kotlin.test.*
 
-class TestRunBlockingOrderTest : TestBase() {
+class TestRunBlockingOrderTest {
+
+    private val actionIndex = atomic(0)
+    private val finished = atomic(false)
+
+    private fun expect(index: Int) {
+        val wasIndex = actionIndex.incrementAndGet()
+        // println("expect($index), wasIndex=$wasIndex")
+        check(index == wasIndex) { "Expecting action index $index but it is actually $wasIndex" }
+    }
+
+    private fun finish(index: Int) {
+        expect(index)
+        check(!finished.getAndSet(true)) { "Should call 'finish(...)' at most once" }
+    }
+
     @Test
     fun testLaunchImmediate() = runBlockingTest {
         expect(1)

kotlinx-coroutines-test/common/test/TestRunBlockingTest.kt

@@ -73,28 +73,6 @@ class TestRunBlockingTest {
         }
     }
 
-    @Test
-    fun kryak() {
-        class ClassUnderTest(private val mainScope: CoroutineScope, private val bgDispatcher: CoroutineDispatcher) {
-            fun doSomething() {
-                mainScope.launch {
-                    val data = withContext(bgDispatcher) {
-                        delay(1000)
-                        42
-                    }
-                    println(data)
-                }
-            }
-        }
-
-        val testBgDispatcher = TestCoroutineDispatcher()
-        val testScope = TestCoroutineScope()
-        val subject = ClassUnderTest(testScope, testBgDispatcher)
-
-        subject.doSomething()
-        testScope.advanceUntilIdle()
-    }
-
     @Test
     fun whenUsingTimeout_triggersWhenWaiting() {
         assertFailsWith<TimeoutCancellationException> {

kotlinx-coroutines-test/jvm/test/TestDispatchersTest.kt

@@ -2,25 +2,39 @@
  * Copyright 2016-2021 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license.
  */
 
+import kotlinx.atomicfu.*
 import kotlinx.coroutines.*
 import kotlinx.coroutines.test.*
 import kotlin.coroutines.*
 import kotlin.test.*
 
-class TestDispatchersTest : TestBase() {
+class TestDispatchersTest {
+    private val actionIndex = atomic(0)
+    private val finished = atomic(false)
+
+    private fun expect(index: Int) {
+        val wasIndex = actionIndex.incrementAndGet()
+        println("expect($index), wasIndex=$wasIndex")
+        check(index == wasIndex) { "Expecting action index $index but it is actually $wasIndex" }
+    }
+
+    private fun finish(index: Int) {
+        expect(index)
+        check(!finished.getAndSet(true)) { "Should call 'finish(...)' at most once" }
+    }
 
     @BeforeTest
     fun setUp() {
         Dispatchers.resetMain()
     }
 
     @Test
-    fun testSelfSet() = runTest {
+    fun testSelfSet() {
         assertFailsWith<IllegalArgumentException> { Dispatchers.setMain(Dispatchers.Main) }
     }
 
     @Test
-    fun testImmediateDispatcher() = runTest {
+    fun testImmediateDispatcher() = runBlockingTest {
         Dispatchers.setMain(ImmediateDispatcher())
         expect(1)
         withContext(Dispatchers.Main) {
@@ -41,7 +55,7 @@ class TestDispatchersTest : TestBase() {
             return false
         }
 
-        override fun dispatch(context: CoroutineContext, block: Runnable) = expectUnreached()
+        override fun dispatch(context: CoroutineContext, block: Runnable) = throw RuntimeException("Shouldn't be reached")
     }
 
     private inner class RegularDispatcher : CoroutineDispatcher() {

kotlinx-coroutines-test/npm/package.json

@@ -19,8 +19,5 @@
     "coroutines",
     "JetBrains",
     "test"
-  ],
-  "dependencies": {
-    "kotlinx-coroutines-core": "~$version"
-  }
-}
+  ]
+}