MPP: Simple JS tests are passing

Author: elizarov

common/kotlinx-coroutines-core-common/src/test/kotlin/kotlinx/coroutines/experimental/CommonCoroutinesTest.kt

@@ -287,19 +287,6 @@ class CommonCoroutinesTest : TestBase() {
         expectUnreached()
     }
 
-    @Test
-    fun testCancelManyCompletedAttachedChildren() = runTest {
-        val parent = launch(coroutineContext) { /* do nothing */ }
-        val n = 10_000 * stressTestMultiplier
-        repeat(n) {
-            // create a child that already completed
-            val child = launch(coroutineContext, CoroutineStart.UNDISPATCHED) { /* do nothing */ }
-            // attach it manually
-            parent.attachChild(child)
-        }
-        parent.cancelAndJoin() // cancel parent, make sure no stack overflow
-    }
-
     @Test
     fun testCancelAndJoinChildren() = runTest {
         expect(1)

core/kotlinx-coroutines-core/src/test/kotlin/kotlinx/coroutines/experimental/CoroutinesTest.kt

@@ -63,6 +63,19 @@ class CoroutinesTest : TestBase() {
         d.await()
     }
 
+    @Test
+    fun testCancelManyCompletedAttachedChildren() = runTest {
+        val parent = launch(coroutineContext) { /* do nothing */ }
+        val n = 10_000 * stressTestMultiplier
+        repeat(n) {
+            // create a child that already completed
+            val child = launch(coroutineContext, CoroutineStart.UNDISPATCHED) { /* do nothing */ }
+            // attach it manually
+            parent.attachChild(child)
+        }
+        parent.cancelAndJoin() // cancel parent, make sure no stack overflow
+    }
+
     private fun throwTestException(): Unit = throw TestException()
 
     private class TestException : Exception {

js/kotlinx-coroutines-core-js/package.json

@@ -0,0 +1,6 @@
+{
+  "name" : "kotlinx-coroutines-core-js",
+  "devDependencies": {
+      "mocha" : "4.0.1"
+  }
+}

js/kotlinx-coroutines-core-js/src/main/kotlin/kotlinx/coroutines/experimental/Builders.kt

@@ -105,8 +105,10 @@ private class BlockingCoroutine<T>(
         while (true) {
             val delay = eventLoop?.processNextEvent() ?: Double.MAX_VALUE
             if (isCompleted) break
-            if (delay > 0) throw IllegalStateException("JS thread cannot be blocked, " +
-                "runBlocking { ... } cannot be waiting for its completion with timeout")
+            if (delay > 0) {
+                throw IllegalStateException("JS thread cannot be blocked, " +
+                    "runBlocking { ... } cannot be waiting for its completion with timeout")
+            }
         }
         // process queued events (that could have been added after last processNextEvent and before cancel
         if (privateEventLoop) (eventLoop as BlockingEventLoop).apply {

js/kotlinx-coroutines-core-js/src/main/kotlin/kotlinx/coroutines/experimental/CancellableContinuation.kt

@@ -256,6 +256,9 @@ internal class CancellableContinuationImpl<in T>(
     @Suppress("UNCHECKED_CAST")
     override fun <T> getSuccessfulResult(state: Any?): T =
         if (state is CompletedIdempotentResult) state.result as T else state as T
+
+    override fun toString(): String =
+        "CancellableContinuation{${stateString()}}[$delegate]"
 }
 
 private class CompletedIdempotentResult(

js/kotlinx-coroutines-core-js/src/main/kotlin/kotlinx/coroutines/experimental/CoroutineDispatcher.kt

@@ -72,10 +72,10 @@ public actual interface Runnable {
 }
 
 internal class DispatchTask<in T>(
-        private val continuation: Continuation<T>,
-        private val value: Any?, // T | Throwable
-        private val exception: Boolean,
-        private val cancellable: Boolean
+    private val continuation: Continuation<T>,
+    private val value: Any?, // T | Throwable
+    private val exception: Boolean,
+    private val cancellable: Boolean
 ) : Runnable {
     @Suppress("UNCHECKED_CAST")
     override fun run() {
@@ -91,6 +91,9 @@ internal class DispatchTask<in T>(
             throw RuntimeException("Unexpected exception running $this: $e")
         }
     }
+
+    override fun toString(): String =
+        "DispatchTask[$continuation, cancellable=$cancellable]"
 }
 
 internal class DispatchedContinuation<in T>(

js/kotlinx-coroutines-core-js/src/main/kotlin/kotlinx/coroutines/experimental/EventLoop.kt

@@ -44,14 +44,14 @@ private const val RESCHEDULED = 2
 
 internal abstract class EventLoopBase: CoroutineDispatcher(), Delay, EventLoop {
     private val queue = LinkedListHead()
-    private val delayed = Heap<DelayedTask>()
+    private var delayed: Heap<DelayedTask>? = null
 
     protected abstract val isCompleted: Boolean
 
     private val nextTime: Double
         get() {
             if (!queue.isEmpty) return 0.0
-            val nextDelayedTask = delayed.peek() ?: return Double.MAX_VALUE
+            val nextDelayedTask = delayed?.peek() ?: return Double.MAX_VALUE
             return (nextDelayedTask.time - now()).coerceAtLeast(0.0)
         }
 
@@ -66,7 +66,8 @@ internal abstract class EventLoopBase: CoroutineDispatcher(), Delay, EventLoop {
 
     override fun processNextEvent(): Double {
         // queue all delayed tasks that are due to be executed
-        if (!delayed.isEmpty) {
+        val delayed = this.delayed
+        if (delayed?.isEmpty == false) {
             val now = now()
             while (true) {
                 delayed.removeFirstIf {
@@ -106,13 +107,14 @@ internal abstract class EventLoopBase: CoroutineDispatcher(), Delay, EventLoop {
 
     private fun scheduleImpl(delayedTask: DelayedTask): Boolean {
         if (isCompleted) return false
+        val delayed = delayed ?: Heap<DelayedTask>().also { this.delayed = it }
         delayed.addLast(delayedTask)
         return true
     }
 
     protected fun rescheduleAllDelayed() {
         while (true) {
-            val delayedTask = delayed.removeFirstOrNull() ?: break
+            val delayedTask = delayed?.removeFirstOrNull() ?: break
             delayedTask.rescheduleOnShutdown()
         }
     }
@@ -147,16 +149,16 @@ internal abstract class EventLoopBase: CoroutineDispatcher(), Delay, EventLoop {
 
         fun rescheduleOnShutdown() {
             if (state != DELAYED) return
-            if (delayed.remove(this)) {
+            if (delayed?.remove(this) == true) {
                 state = RESCHEDULED
                 handle = DefaultExecutor.schedule(time,this)
             } else
                 state = REMOVED
         }
 
-        override final fun dispose() {
+        final override fun dispose() {
             when (state) {
-                DELAYED -> delayed.remove(this)
+                DELAYED -> delayed?.remove(this)
                 RESCHEDULED -> DefaultExecutor.removeScheduled(handle)
                 else -> return
             }

js/kotlinx-coroutines-core-js/src/main/kotlin/kotlinx/coroutines/experimental/Job.kt

@@ -352,6 +352,7 @@ public actual object NonDisposableHandle : DisposableHandle {
 
 // --------------- helper classes to simplify job implementation
 
+
 /**
  * A concrete implementation of [Job]. It is optionally a child to a parent job.
  * This job is cancelled when the parent is complete, but not vise-versa.
@@ -741,7 +742,7 @@ public open class JobSupport(active: Boolean) : Job {
             // must promote to list to correct operate on child lists
             if (state is JobNode<*>) {
                 promoteSingleToNodeList(state)
-                return@loop // retry
+                continue@loop // retry
             }
             // cancel all children in list on exceptional completion
             if (proposedUpdate is CompletedExceptionally)
@@ -839,9 +840,9 @@ public open class JobSupport(active: Boolean) : Job {
     protected open fun afterCompletion(state: Any?, mode: Int) {}
 
     // for nicer debugging
-    override final fun toString(): String = "Job{${stateString()}}"
+    override fun toString(): String = "Job{${stateString()}}"
 
-    private fun stateString(): String {
+    protected fun stateString(): String {
         val state = this.state
         return when (state) {
             is Finishing -> buildString {

js/kotlinx-coroutines-core-js/src/test/kotlin/kotlinx/coroutines/experimental/internal/LinkedListTest.kt

@@ -0,0 +1,43 @@
+package kotlinx.coroutines.experimental.internal
+
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertFalse
+import kotlin.test.assertTrue
+
+class LinkedListTest {
+    data class IntNode(val i: Int) : LinkedListNode()
+
+    @Test
+    fun testSimpleAddLastRemove() {
+        val list = LinkedListHead()
+        assertContents(list)
+        val n1 = IntNode(1).apply { list.addLast(this) }
+        assertContents(list, 1)
+        val n2 = IntNode(2).apply { list.addLast(this) }
+        assertContents(list, 1, 2)
+        val n3 = IntNode(3).apply { list.addLast(this) }
+        assertContents(list, 1, 2, 3)
+        val n4 = IntNode(4).apply { list.addLast(this) }
+        assertContents(list, 1, 2, 3, 4)
+        assertTrue(n1.remove())
+        assertContents(list, 2, 3, 4)
+        assertTrue(n3.remove())
+        assertContents(list, 2, 4)
+        assertTrue(n4.remove())
+        assertContents(list, 2)
+        assertTrue(n2.remove())
+        assertFalse(n2.remove())
+        assertContents(list)
+    }
+
+    private fun assertContents(list: LinkedListHead, vararg expected: Int) {
+        val n = expected.size
+        val actual = IntArray(n)
+        var index = 0
+        list.forEach<IntNode> { actual[index++] = it.i }
+        assertEquals(n, index)
+        for (i in 0 until n) assertEquals(expected[i], actual[i], "item i")
+        assertEquals(expected.isEmpty(), list.isEmpty)
+    }
+}