Populate sbt.testing.Event.duration on Scala.js

munit/js-native/src/main/scala/munit/internal/junitinterface/JUnitReporter.scala

@@ -34,23 +34,23 @@ final class JUnitReporter(
       AnsiColors.c(s"==> i $method$suffixed ignored", AnsiColors.YELLOW) + " " +
         formatTime(elapsedMillis),
     )
-    emitEvent(method, Status.Ignored)
+    emitEvent(method, Status.Ignored, None, elapsedMillis)
   }
   def reportAssumptionViolation(
       method: String,
-      timeInSeconds: Double,
+      elapsedMillis: Double,
       e: Throwable,
   ): Unit = {
     log(Info, AnsiColors.c(s"==> s $method skipped", AnsiColors.YELLOW))
-    emitEvent(method, Status.Skipped, new OptionalThrowable(e))
+    emitEvent(method, Status.Skipped, Option(e), 0)
   }
   def reportTestPassed(method: String, elapsedMillis: Double): Unit = {
     log(
       Info,
       AnsiColors.c(s"  + $method", AnsiColors.GREEN) + " " +
         formatTime(elapsedMillis),
     )
-    emitEvent(method, Status.Success)
+    emitEvent(method, Status.Success, None, elapsedMillis)
   }
   def reportTestFailed(
       method: String,
@@ -66,7 +66,7 @@ final class JUnitReporter(
         .append(ex.getClass().getName()).append(": ").append(ex.getMessage())
         .toString(),
     )
-    emitEvent(method, Status.Failure, new OptionalThrowable(ex))
+    emitEvent(method, Status.Failure, Option(ex), elapsedMillis)
   }
 
   private def trace(t: Throwable): Unit =
@@ -75,13 +75,20 @@ final class JUnitReporter(
   private def emitEvent(
       method: String,
       status: Status,
-      throwable: OptionalThrowable = new OptionalThrowable,
+      throwable: Option[Throwable],
+      elapsedMillis: Double,
   ): Unit = {
     val testName = taskDef.fullyQualifiedName() + "." +
       settings.decodeName(method)
     val selector = new TestSelector(testName)
-    eventHandler
-      .handle(new JUnitEvent(taskDef, testName, status, selector, throwable))
+    eventHandler.handle(new JUnitEvent(
+      taskDef,
+      testName,
+      status,
+      selector,
+      new OptionalThrowable(throwable.orNull),
+      elapsedMillis.toLong,
+    ))
   }
 
   private def log(level: Level, s: String): Unit =

tests/js/src/test/scala/munit/DurationJSSuite.scala

@@ -0,0 +1,46 @@
+package munit
+
+import munit.internal.PlatformCompat
+
+import sbt.testing.Event
+import sbt.testing.EventHandler
+import sbt.testing.Runner
+import sbt.testing.SuiteSelector
+import sbt.testing.Task
+import sbt.testing.TaskDef
+
+import scala.collection.mutable
+
+class DurationJSTestSuite extends FunSuite {
+  test("success")(assert(true, "Test should pass"))
+  test("ignore".ignore)(assert(false, "Test should be ignored"))
+}
+
+class DurationJSSuite extends FunSuite {
+  private def run(fullyQualifiedName: String): List[Event] = {
+    val framework = new Framework()
+    val runner: Runner = framework
+      .runner(Array(), Array(), PlatformCompat.getThisClassLoader)
+    val events = new mutable.ListBuffer[Event]
+    val eventHandler: EventHandler = new EventHandler {
+      override def handle(event: Event) = events += event
+    }
+    val taskDef: TaskDef = new TaskDef(
+      fullyQualifiedName,
+      framework.munitFingerprint,
+      false,
+      Array(new SuiteSelector()),
+    )
+    val tasks: Array[Task] = runner.tasks(Array(taskDef))
+    assertEquals(tasks.size, 1)
+    tasks(0).execute(eventHandler, Nil.toArray)
+    events.toList
+  }
+
+  test("duration-defined") {
+    val events: List[Event] = run("munit.DurationJSTestSuite")
+    events.foreach(event =>
+      assert(event.duration != -1L, "duration should be defined")
+    )
+  }
+}