Merge pull request #103 from dokar3/dokar/improve-execute-pending-job

Improve the calling of executePendingJob

quickjs/src/commonTest/kotlin/com/dokar/quickjs/test/JsPromiseTest.kt

@@ -0,0 +1,72 @@
+package com.dokar.quickjs.test
+
+import com.dokar.quickjs.binding.function
+import com.dokar.quickjs.quickJs
+import kotlinx.coroutines.test.runTest
+import kotlin.test.Test
+import kotlin.test.assertEquals
+
+class JsPromiseTest {
+    @Test
+    fun asyncFunction() = runTest {
+        quickJs {
+            val result = evaluate<Int>(
+                """
+                async function add(a, b) {
+                    return a + b;
+                }
+                await add(1, 2)
+                """.trimIndent()
+            )
+            assertEquals(3, result)
+        }
+    }
+
+    @Test
+    fun promise() = runTest {
+        quickJs {
+            val result = evaluate<Int>(
+                """
+                await new Promise((resolve) => resolve(1))
+                    .then((result) => result + 1)
+                """.trimIndent()
+            )
+            assertEquals(2, result)
+        }
+    }
+
+    @Test
+    fun promiseDotAll() = runTest {
+        quickJs {
+            val result = evaluate<List<*>>(
+                """
+                async function add(a, b) {
+                    return a + b;
+                }
+                await Promise.all([add(1, 2), add(3, 4)])
+                """.trimIndent()
+            )
+            assertEquals(listOf(3L, 7L), result)
+        }
+    }
+
+    @Test
+    fun promiseWithoutAwait() = runTest {
+        quickJs {
+            val logs = mutableListOf<String>()
+
+            function<String, Unit>("log") { logs += it }
+
+            evaluate<Any?>(
+                """
+                log("Start");
+                new Promise((resolve) => resolve())
+                    .then(() => log("Then"));
+                log("End");
+                """.trimIndent()
+            )
+
+            assertEquals(listOf("Start", "End", "Then"), logs)
+        }
+    }
+}

quickjs/src/jniMain/kotlin/com/dokar/quickjs/QuickJs.jni.kt

@@ -352,15 +352,14 @@ actual class QuickJs private constructor(
     }
 
     private suspend fun awaitAsyncJobs() {
-        /**
-         * This is our simple 'event loop'.
-         */
+        jsMutex.withLock {
+            do {
+                // Execute JS Promises, putting this in while(true) is unnecessary
+                // since we have the same loop after every asyncFunction call
+                val executed = executePendingJob(context, globals)
+            } while (executed)
+        }
         while (true) {
-            jsMutex.withLock {
-                do {
-                    val executed = executePendingJob(context, globals)
-                } while (executed)
-            }
             val jobs = jobsMutex.withLock { asyncJobs.filter { it.isActive } }
             if (jobs.isEmpty()) {
                 // No jobs to run
@@ -415,15 +414,18 @@ actual class QuickJs private constructor(
                 }
             }
             jsMutex.withLock {
-                while (executePendingJob(context, globals)) {
-                    // The job is completed, see what we can do next
-                }
+                // The job is completed, see what we can do next:
+                // - Execute subsequent Promises
+                // - Cancel all jobs and fail, if rejected and JS didn't handle it
+                do {
+                    val executed = executePendingJob(context, globals)
+                } while (executed)
             }
         }
+        jobsMutex.withLockSync { asyncJobs += job }
         job.invokeOnCompletion {
             jobsMutex.withLockSync { asyncJobs -= job }
         }
-        jobsMutex.withLockSync { asyncJobs += job }
     }
 
     private fun promiseHandlesFromArgs(args: Array<Any?>): Pair<Long, Long> {

quickjs/src/nativeMain/kotlin/com/dokar/quickjs/QuickJs.native.kt

@@ -292,15 +292,18 @@ actual class QuickJs private constructor(
                 }
             }
             jsMutex.withLock {
-                while (executePendingJob(runtime) == ExecuteJobResult.Success) {
-                    // The job is completed, see what we can do next
-                }
+                // The job is completed, see what we can do next:
+                // - Execute subsequent Promises
+                // - Cancel all jobs and fail, if rejected and JS didn't handle it
+                do {
+                    val result = executePendingJob(runtime)
+                } while (result == ExecuteJobResult.Success)
             }
         }
+        jobsMutex.withLockSync { asyncJobs += job }
         job.invokeOnCompletion {
             jobsMutex.withLockSync { asyncJobs -= job }
         }
-        jobsMutex.withLockSync { asyncJobs += job }
     }
 
     private suspend inline fun evalAndAwait(
@@ -324,15 +327,17 @@ actual class QuickJs private constructor(
     }
 
     private suspend fun awaitAsyncJobs() {
+        jsMutex.withLock {
+            do {
+                // Execute JS Promises, putting this in while(true) is unnecessary
+                // since we have the same loop after every asyncFunction call
+                val execResult = executePendingJob(runtime)
+                if (execResult is ExecuteJobResult.Failure) {
+                    throw execResult.error
+                }
+            } while (execResult == ExecuteJobResult.Success)
+        }
         while (true) {
-            jsMutex.withLock {
-                do {
-                    val execResult = executePendingJob(runtime)
-                    if (execResult is ExecuteJobResult.Failure) {
-                        throw execResult.error
-                    }
-                } while (execResult == ExecuteJobResult.Success)
-            }
             val jobs = jobsMutex.withLock { asyncJobs.filter { it.isActive } }
             if (jobs.isEmpty()) {
                 // No jobs to run