Support Scala Native multithreading

munit/native/src/main/scala/munit/internal/PlatformCompat.scala

@@ -9,12 +9,35 @@ import sbt.testing.EventHandler
 import sbt.testing.Logger
 import scala.concurrent.Await
 import scala.concurrent.Awaitable
+import scala.concurrent.Promise
 import scala.concurrent.duration.Duration
 import scala.concurrent.ExecutionContext
+import java.util.concurrent.{Executors, ThreadFactory, TimeoutException, TimeUnit}
+import java.util.concurrent.atomic.AtomicInteger
+import scala.scalanative.meta.LinktimeInfo.isMultithreadingEnabled
 
+// Delay reachability of multithreading capability
+// Would not force multithreading support unless explicitly configured by the user
+// or if using threads in the tests
+private object LazyMultithreadingSupport {
+  val sh = Executors.newSingleThreadScheduledExecutor(
+    new ThreadFactory {
+      val counter = new AtomicInteger
+      def threadNumber() = counter.incrementAndGet()
+      def newThread(r: Runnable) =
+        new Thread(r, s"munit-scheduler-${threadNumber()}") {
+          setDaemon(true)
+          setPriority(Thread.NORM_PRIORITY)
+        }
+    }
+  )
+}
 object PlatformCompat {
+  import LazyMultithreadingSupport._
+
   def awaitResult[T](awaitable: Awaitable[T]): T = {
-    scalanative.runtime.loop()
+    if (!isMultithreadingEnabled)
+      Thread.`yield`() // invokes SN 0.4 scalanative.runtime.loop()
     Await.result(awaitable, Duration.Inf)
   }
 
@@ -26,18 +49,55 @@ object PlatformCompat {
     task.execute(eventHandler, loggers)
     Future.successful(())
   }
+
   def waitAtMost[T](
       startFuture: () => Future[T],
       duration: Duration,
       ec: ExecutionContext
   ): Future[T] = {
-    startFuture()
+    if (!isMultithreadingEnabled) startFuture()
+    else {
+      val onComplete = Promise[T]()
+      val timeout =
+        if (duration.isFinite)
+          Some(
+            sh.schedule[Unit](
+              () =>
+                onComplete.tryFailure(
+                  new TimeoutException(s"test timed out after $duration")
+                ),
+              duration.toMillis,
+              TimeUnit.MILLISECONDS
+            )
+          )
+        else
+          None
+      ec.execute(new Runnable {
+        def run(): Unit = {
+          startFuture().onComplete { result =>
+            onComplete.tryComplete(result)
+            timeout.foreach(_.cancel(false))
+          }(ec)
+        }
+      })
+      onComplete.future
+    }
   }
+
   def setTimeout(ms: Int)(body: => Unit): () => Unit = {
-    Thread.sleep(ms)
-    body
+    if (!isMultithreadingEnabled) {
+      // Thread.sleep(ms)
+      body
+      () => ()
+    } else {
+      val scheduled = sh.schedule[Unit](
+        () => body,
+        ms,
+        TimeUnit.MILLISECONDS
+      )
 
-    () => ()
+      () => scheduled.cancel(false)
+    }
   }
 
   // Scala Native does not support looking up annotations at runtime.