diff --git a/Jenkinsfile b/Jenkinsfile
index 466e0a992e..ee7f812629 100644
--- a/Jenkinsfile
+++ b/Jenkinsfile
@@ -146,8 +146,8 @@ def Tasks = [
   "test-suite-ecma-script2015": '''
     setJavaVersion $java
     npm install &&
-    sbtretry ++$scala jUnitTestOutputsJVM/test jUnitTestOutputsJS/test \
-        'set scalaJSStage in Global := FullOptStage' jUnitTestOutputsJS/test &&
+    sbtretry ++$scala jUnitTestOutputsJVM/test jUnitTestOutputsJS/test testBridge/test \
+        'set scalaJSStage in Global := FullOptStage' jUnitTestOutputsJS/test testBridge/test &&
     sbtretry ++$scala $testSuite/test &&
     sbtretry 'set scalaJSStage in Global := FullOptStage' \
         ++$scala $testSuite/test \
diff --git a/junit-test/shared/src/test/scala/org/scalajs/junit/AsyncTest.scala b/junit-test/shared/src/test/scala/org/scalajs/junit/AsyncTest.scala
index cfb12ce6e5..666c389d74 100644
--- a/junit-test/shared/src/test/scala/org/scalajs/junit/AsyncTest.scala
+++ b/junit-test/shared/src/test/scala/org/scalajs/junit/AsyncTest.scala
@@ -23,23 +23,20 @@ import org.scalajs.junit.async._
 
 class AsyncTest {
   @Test
-  def success(): AsyncResult = {
-    val res = Future(1 + 1).filter(_ == 2)
-    await(res)
+  def success(): AsyncResult = await {
+    Future(1 + 1).filter(_ == 2)
   }
 
   @Test(expected = classOf[IllegalArgumentException])
-  def expectedException(): AsyncResult = {
+  def expectedException(): AsyncResult = await {
     // Do not throw synchronously.
-    val res = Future.failed(new IllegalArgumentException)
-    await(res)
+    Future.failed(new IllegalArgumentException)
   }
 
   @Test
-  def asyncFailure(): AsyncResult = {
+  def asyncFailure(): AsyncResult = await {
     // Do not throw synchronously.
-    val res = Future.failed(new IllegalArgumentException)
-    await(res)
+    Future.failed(new IllegalArgumentException)
   }
 }
 
diff --git a/junit-test/shared/src/test/scala/org/scalajs/junit/utils/JUnitTest.scala b/junit-test/shared/src/test/scala/org/scalajs/junit/utils/JUnitTest.scala
index 81ff6dc066..76474fe4d9 100644
--- a/junit-test/shared/src/test/scala/org/scalajs/junit/utils/JUnitTest.scala
+++ b/junit-test/shared/src/test/scala/org/scalajs/junit/utils/JUnitTest.scala
@@ -55,7 +55,7 @@ abstract class JUnitTest {
       List('v', 's', 'n')
   )
 
-  @Test def testJUnitOutput(): AsyncResult = {
+  @Test def testJUnitOutput(): AsyncResult = await {
     val futs = for (args <- frameworkArgss) yield {
       for {
         rawOut <- runTests(args.map("-" + _))
@@ -78,7 +78,7 @@ abstract class JUnitTest {
       }
     }
 
-    await(Future.sequence(futs).map(_ => ()))
+    Future.sequence(futs).map(_ => ())
   }
 
   private def runTests(args: List[String]): Future[List[Output]] = {
diff --git a/linker/shared/src/test/scala/org/scalajs/linker/AnalyzerTest.scala b/linker/shared/src/test/scala/org/scalajs/linker/AnalyzerTest.scala
index 13fc1b3cf2..c4bfb393c5 100644
--- a/linker/shared/src/test/scala/org/scalajs/linker/AnalyzerTest.scala
+++ b/linker/shared/src/test/scala/org/scalajs/linker/AnalyzerTest.scala
@@ -42,20 +42,19 @@ class AnalyzerTest {
   private val EAF = ApplyFlags.empty
 
   @Test
-  def trivialOK(): AsyncResult = {
+  def trivialOK(): AsyncResult = await {
     val analysis = computeAnalysis(Nil)
-    await(assertNoError(analysis))
+    assertNoError(analysis)
   }
 
   @Test
-  def missingJavaLangObject(): AsyncResult = {
+  def missingJavaLangObject(): AsyncResult = await {
     val analysis = computeAnalysis(Nil, stdlib = None)
-    await(assertExactErrors(analysis,
-        MissingJavaLangObjectClass(fromAnalyzer)))
+    assertExactErrors(analysis, MissingJavaLangObjectClass(fromAnalyzer))
   }
 
   @Test
-  def invalidJavaLangObject(): AsyncResult = {
+  def invalidJavaLangObject(): AsyncResult = await {
     val invalidJLObjectDefs = Seq(
         // j.l.Object cannot have a super class
         classDef(ObjectClass, superClass = Some("Lparent")),
@@ -65,17 +64,15 @@ class AnalyzerTest {
         classDef(ObjectClass, interfaces = List("Lparent"))
     )
 
-    val result = Future.traverse(invalidJLObjectDefs) { jlObjectDef =>
+    Future.traverse(invalidJLObjectDefs) { jlObjectDef =>
       val analysis = computeAnalysis(Seq(jlObjectDef), stdlib = None)
       assertExactErrors(analysis,
           InvalidJavaLangObjectClass(fromAnalyzer))
     }
-
-    await(result)
   }
 
   @Test
-  def cycleInInheritanceChainThroughParentClasses(): AsyncResult = {
+  def cycleInInheritanceChainThroughParentClasses(): AsyncResult = await {
     val classDefs = Seq(
         classDef("LA", superClass = Some("LB")),
         classDef("LB", superClass = Some("LA"))
@@ -83,16 +80,13 @@ class AnalyzerTest {
 
     val analysis = computeAnalysis(classDefs, reqsFactory.classData("LA"))
 
-    await {
-      assertContainsError("CycleInInheritanceChain(LA, LB)", analysis) {
-        case CycleInInheritanceChain(List("LA", "LB"), `fromAnalyzer`) =>
-          true
-      }
+    assertContainsError("CycleInInheritanceChain(LA, LB)", analysis) {
+      case CycleInInheritanceChain(List("LA", "LB"), `fromAnalyzer`) => true
     }
   }
 
   @Test
-  def cycleInInheritanceChainThroughInterfaces(): AsyncResult = {
+  def cycleInInheritanceChainThroughInterfaces(): AsyncResult = await {
     val classDefs = Seq(
         classDef("LA", superClass = Some("LB")),
         classDef("LB", superClass = Some(ObjectClass), interfaces = List("LA"))
@@ -100,16 +94,13 @@ class AnalyzerTest {
 
     val analysis = computeAnalysis(classDefs, reqsFactory.classData("LA"))
 
-    await {
-      assertContainsError("CycleInInheritanceChain(LA, LB)", analysis) {
-      case CycleInInheritanceChain(List("LA", "LB"), `fromAnalyzer`) =>
-          true
-      }
+    assertContainsError("CycleInInheritanceChain(LA, LB)", analysis) {
+      case CycleInInheritanceChain(List("LA", "LB"), `fromAnalyzer`) => true
     }
   }
 
   @Test
-  def bigCycleInInheritanceChain(): AsyncResult = {
+  def bigCycleInInheritanceChain(): AsyncResult = await {
     val classDefs = Seq(
         classDef("LA", superClass = Some("LB")),
         classDef("LB", superClass = Some("LC")),
@@ -122,42 +113,35 @@ class AnalyzerTest {
 
     val analysis = computeAnalysis(classDefs, reqsFactory.classData("LA"))
 
-    await {
-      assertContainsError("CycleInInheritanceChain(LB, LC, LD)", analysis) {
-        case CycleInInheritanceChain(List("LC", "LD", "LE"), `fromAnalyzer`) =>
-          true
-      }
+    assertContainsError("CycleInInheritanceChain(LB, LC, LD)", analysis) {
+      case CycleInInheritanceChain(List("LC", "LD", "LE"), `fromAnalyzer`) => true
     }
   }
 
   @Test
-  def missingClassDirect(): AsyncResult = {
+  def missingClassDirect(): AsyncResult = await {
     val analysis = computeAnalysis(Nil, reqsFactory.classData("LA"))
 
-    await {
-      assertContainsError("MissingClass(LA)", analysis) {
-        case MissingClass(ClsInfo("LA"), `fromUnitTest`) => true
-      }
+    assertContainsError("MissingClass(LA)", analysis) {
+      case MissingClass(ClsInfo("LA"), `fromUnitTest`) => true
     }
   }
 
   @Test
-  def missingClassParent(): AsyncResult = {
+  def missingClassParent(): AsyncResult = await {
     val classDefs = Seq(
         classDef("LA", superClass = Some("LB"))
     )
 
     val analysis = computeAnalysis(classDefs, reqsFactory.classData("LA"))
 
-    await {
-      assertContainsError("MissingClass(LB)", analysis) {
-        case MissingClass(ClsInfo("LB"), FromClass(ClsInfo("LA"))) => true
-      }
+    assertContainsError("MissingClass(LB)", analysis) {
+      case MissingClass(ClsInfo("LB"), FromClass(ClsInfo("LA"))) => true
     }
   }
 
   @Test
-  def missingSuperClass(): AsyncResult = {
+  def missingSuperClass(): AsyncResult = await {
     val kinds = Seq(
         ClassKind.Class,
         ClassKind.ModuleClass,
@@ -168,7 +152,7 @@ class AnalyzerTest {
         ClassKind.NativeJSModuleClass
     )
 
-    val result = Future.traverse(kinds) { kind =>
+    Future.traverse(kinds) { kind =>
       val classDefs = Seq(
           classDef("LA", kind = kind, memberDefs = List(trivialCtor("LA")))
       )
@@ -180,12 +164,10 @@ class AnalyzerTest {
         case MissingSuperClass(ClsInfo("LA"), FromClass(ClsInfo("LA"))) => true
       }
     }
-
-    await(result)
   }
 
   @Test
-  def invalidSuperClass(): AsyncResult = {
+  def invalidSuperClass(): AsyncResult = await {
     val kindsSub = Seq(
         ClassKind.Class,
         ClassKind.ModuleClass,
@@ -211,7 +193,7 @@ class AnalyzerTest {
       }
     }
 
-    val result = Future.traverse(kindsSub) { kindSub =>
+    Future.traverse(kindsSub) { kindSub =>
       Future.traverse(kindsBaseFor(kindSub)) { kindBase =>
 
         val classDefs = Seq(
@@ -230,12 +212,10 @@ class AnalyzerTest {
         }
       }
     }
-
-    await(result)
   }
 
   @Test
-  def invalidImplementedInterface(): AsyncResult = {
+  def invalidImplementedInterface(): AsyncResult = await {
     val kindsCls = Seq(
         ClassKind.Class,
         ClassKind.ModuleClass,
@@ -260,7 +240,7 @@ class AnalyzerTest {
       }
     }
 
-    val result = Future.traverse(kindsCls) { kindCls =>
+    Future.traverse(kindsCls) { kindCls =>
       Future.traverse(kindsIntfFor(kindCls)) { kindIntf =>
         val classDefs = Seq(
             classDef("LA", kind = kindCls,
@@ -280,12 +260,10 @@ class AnalyzerTest {
         }
       }
     }
-
-    await(result)
   }
 
   @Test
-  def notAModule(): AsyncResult = {
+  def notAModule(): AsyncResult = await {
     val classDefs = Seq(
         classDef("LA", superClass = Some(ObjectClass),
             memberDefs = List(trivialCtor("LA")))
@@ -293,15 +271,13 @@ class AnalyzerTest {
 
     val analysis = computeAnalysis(classDefs, reqsFactory.accessModule("LA"))
 
-    await {
-      assertContainsError("NotAModule(LA)", analysis) {
-        case NotAModule(ClsInfo("LA"), `fromUnitTest`) => true
-      }
+    assertContainsError("NotAModule(LA)", analysis) {
+      case NotAModule(ClsInfo("LA"), `fromUnitTest`) => true
     }
   }
 
   @Test
-  def missingMethod(): AsyncResult = {
+  def missingMethod(): AsyncResult = await {
     val classDefs = Seq(
         classDef("LA", superClass = Some(ObjectClass),
             memberDefs = List(trivialCtor("LA")))
@@ -311,15 +287,13 @@ class AnalyzerTest {
         reqsFactory.instantiateClass("LA", "init___") ++
         reqsFactory.callMethod("LA", "foo__V"))
 
-    await {
-      assertContainsError("MissingMethod(LA.foo__V)", analysis) {
-        case MissingMethod(MethInfo("LA", "foo__V"), `fromUnitTest`) => true
-      }
+    assertContainsError("MissingMethod(LA.foo__V)", analysis) {
+      case MissingMethod(MethInfo("LA", "foo__V"), `fromUnitTest`) => true
     }
   }
 
   @Test
-  def conflictingDefaultMethods(): AsyncResult = {
+  def conflictingDefaultMethods(): AsyncResult = await {
     val defaultMethodDef = MethodDef(MemberFlags.empty, Ident("foo__V"), Nil,
         NoType, Some(Skip()))(emptyOptHints, None)
     val classDefs = Seq(
@@ -336,23 +310,20 @@ class AnalyzerTest {
         reqsFactory.instantiateClass("LA", "init___") ++
         reqsFactory.callMethod("LA", "foo__V"))
 
-    await {
-      assertContainsError("ConflictingDefaultMethods(LI1.foo__V, LI2.foo__V)",
-          analysis) {
-        case ConflictingDefaultMethods(
-            List(MethInfo("LI1", "foo__V"), MethInfo("LI2", "foo__V")),
-            `fromAnalyzer`) =>
-          true
-        case ConflictingDefaultMethods(
-            List(MethInfo("LI2", "foo__V"), MethInfo("LI1", "foo__V")),
-            `fromAnalyzer`) =>
-          true
-      }
+    assertContainsError("ConflictingDefaultMethods(LI1.foo__V, LI2.foo__V)", analysis) {
+      case ConflictingDefaultMethods(
+          List(MethInfo("LI1", "foo__V"), MethInfo("LI2", "foo__V")),
+          `fromAnalyzer`) =>
+        true
+      case ConflictingDefaultMethods(
+          List(MethInfo("LI2", "foo__V"), MethInfo("LI1", "foo__V")),
+          `fromAnalyzer`) =>
+        true
     }
   }
 
   @Test
-  def conflictingTopLevelExports(): AsyncResult = {
+  def conflictingTopLevelExports(): AsyncResult = await {
     def singleDef(name: String) = {
       classDef(name,
           kind = ClassKind.ModuleClass, superClass = Some(ObjectClass),
@@ -363,18 +334,16 @@ class AnalyzerTest {
     val classDefs = Seq(singleDef("LA"), singleDef("LB"))
     val analysis = computeAnalysis(classDefs)
 
-    await {
-      assertContainsError("ConflictingTopLevelExport(foo, LA, LB)", analysis) {
-        case ConflictingTopLevelExport("foo", List(ClsInfo("LA"), ClsInfo("LB"))) =>
-          true
-        case ConflictingTopLevelExport("foo", List(ClsInfo("LB"), ClsInfo("LA"))) =>
-          true
-      }
+    assertContainsError("ConflictingTopLevelExport(foo, LA, LB)", analysis) {
+      case ConflictingTopLevelExport("foo", List(ClsInfo("LA"), ClsInfo("LB"))) =>
+        true
+      case ConflictingTopLevelExport("foo", List(ClsInfo("LB"), ClsInfo("LA"))) =>
+        true
     }
   }
 
   @Test
-  def degenerateConflictingTopLevelExports(): AsyncResult = {
+  def degenerateConflictingTopLevelExports(): AsyncResult = await {
     val classDefs = Seq(classDef("LA",
         kind = ClassKind.ModuleClass, superClass = Some(ObjectClass),
         memberDefs = List(trivialCtor("LA")),
@@ -383,15 +352,13 @@ class AnalyzerTest {
             TopLevelModuleExportDef("foo"))))
 
     val analysis = computeAnalysis(classDefs)
-    await {
-      assertContainsError("ConflictingTopLevelExport(foo, <degenerate>)", analysis) {
-        case ConflictingTopLevelExport("foo", _) => true
-      }
+    assertContainsError("ConflictingTopLevelExport(foo, <degenerate>)", analysis) {
+      case ConflictingTopLevelExport("foo", _) => true
     }
   }
 
   @Test
-  def juPropertiesNotReachableWhenUsingGetSetClearProperty(): AsyncResult = {
+  def juPropertiesNotReachableWhenUsingGetSetClearProperty(): AsyncResult = await {
     val systemMod = LoadModule(ClassRef("jl_System$"))
     val emptyStr = StringLiteral("")
     val StringType = ClassType(BoxedStringClass)
@@ -408,7 +375,7 @@ class AnalyzerTest {
         ))
     )
 
-    val result = for {
+    for {
       analysis <- computeAnalysis(classDefs,
           reqsFactory.instantiateClass("LA", "init___") ++
           reqsFactory.callMethod("LA", "test__V"),
@@ -421,12 +388,10 @@ class AnalyzerTest {
       assertFalse(juPropertiesClass.areInstanceTestsUsed)
       assertFalse(juPropertiesClass.isDataAccessed)
     }
-
-    await(result)
   }
 
   @Test  // #3571
-  def specificReflectiveProxy(): AsyncResult = {
+  def specificReflectiveProxy(): AsyncResult = await {
     val classDefs = Seq(
         classDef("LA", superClass = Some(ObjectClass)),
         classDef("LB", superClass = Some("LA")),
@@ -441,7 +406,7 @@ class AnalyzerTest {
         )
     )
 
-    val result = for {
+    for {
       analysis <- computeAnalysis(classDefs,
           reqsFactory.instantiateClass("LX", "init___") ++
           reqsFactory.callMethod("LX", "foo__"))
@@ -456,8 +421,6 @@ class AnalyzerTest {
 
       assertEquals("foo__LB", target)
     }
-
-    await(result)
   }
 }
 
diff --git a/linker/shared/src/test/scala/org/scalajs/linker/LinkerTest.scala b/linker/shared/src/test/scala/org/scalajs/linker/LinkerTest.scala
index f5f4fa2681..d6803124ed 100644
--- a/linker/shared/src/test/scala/org/scalajs/linker/LinkerTest.scala
+++ b/linker/shared/src/test/scala/org/scalajs/linker/LinkerTest.scala
@@ -41,7 +41,7 @@ class LinkerTest {
    *  world.
    */
   @Test
-  def linkHelloWorld(): AsyncResult = {
+  def linkHelloWorld(): AsyncResult = await {
     val name = "LHelloWorld$"
     val mainMethodBody = {
       JSBracketMethodApply(JSGlobalRef(Ident("console")), StringLiteral("log"),
@@ -59,14 +59,14 @@ class LinkerTest {
     val moduleInitializers = List(
         ModuleInitializer.mainMethodWithArgs("HelloWorld", "main")
     )
-    await(testLink(classDefs, moduleInitializers))
+    testLink(classDefs, moduleInitializers)
   }
 
   /** This test exposes a problem where a linker in error state is called
    *  multiple times and ends up thinking it is being used concurrently.
    */
   @Test
-  def clean_linking_state(): AsyncResult = {
+  def clean_linking_state(): AsyncResult = await {
     class DummyException extends Exception
 
     val badSeq = new IndexedSeq[IRFile] {
@@ -99,7 +99,7 @@ class LinkerTest {
       }
     }
 
-    await((1 to 4).foldLeft(firstRun)((p, _) => callInFailedState(p)))
+    (1 to 4).foldLeft(firstRun)((p, _) => callInFailedState(p))
   }
 
 }
diff --git a/project/Build.scala b/project/Build.scala
index 8fec246b2b..bb6468939e 100644
--- a/project/Build.scala
+++ b/project/Build.scala
@@ -745,7 +745,7 @@ object Build {
         baseDirectory.value.getParentFile / "test-common/src/main/scala",
       unmanagedSourceDirectories in Test +=
         baseDirectory.value.getParentFile / "test-common/src/test/scala"
-  ).dependsOn(jsEnvs)
+  ).dependsOn(jsEnvs, jUnitAsyncJVM % "test")
 
   lazy val plugin: Project = Project(id = "sbtPlugin", base = file("sbt-plugin")).settings(
       commonSettings,
@@ -1162,12 +1162,12 @@ object Build {
        * `mimaBinaryIssueFilters`.
        */
       unmanagedSourceDirectories in Compile +=
-        baseDirectory.value.getParentFile / "test-common/src/main/scala"
-      /* Note: We cannot add the test-common tests, since they test async
-       * stuff and JUnit does not support async tests. Therefore we need to
-       * block, so we cannot run on JS.
-       */
-  ).withScalaJSCompiler.dependsOn(library, testInterface)
+        baseDirectory.value.getParentFile / "test-common/src/main/scala",
+      unmanagedSourceDirectories in Test +=
+        baseDirectory.value.getParentFile / "test-common/src/test/scala"
+  ).withScalaJSCompiler.withScalaJSJUnitPlugin.dependsOn(
+      library, testInterface, jUnitRuntime % "test", jUnitAsyncJS % "test"
+  )
 
   lazy val jUnitRuntime = (project in file("junit-runtime")).enablePlugins(
       MyScalaJSPlugin
diff --git a/test-common/src/test/scala/org/scalajs/testing/common/RPCCoreTest.scala b/test-common/src/test/scala/org/scalajs/testing/common/RPCCoreTest.scala
index f8260ac9cd..324ce9c3d8 100644
--- a/test-common/src/test/scala/org/scalajs/testing/common/RPCCoreTest.scala
+++ b/test-common/src/test/scala/org/scalajs/testing/common/RPCCoreTest.scala
@@ -13,7 +13,6 @@
 package org.scalajs.testing.common
 
 import scala.concurrent._
-import scala.concurrent.duration._
 import scala.concurrent.ExecutionContext.Implicits.global
 
 import java.util.concurrent.atomic.AtomicInteger
@@ -21,6 +20,8 @@ import java.util.concurrent.atomic.AtomicInteger
 import org.junit.Test
 import org.junit.Assert._
 
+import org.scalajs.junit.async._
+
 class RPCCoreTest {
   import RPCCoreTest._
 
@@ -34,21 +35,15 @@ class RPCCoreTest {
     val msg1: MsgEndpoint.EP[Int] = MsgEndpoint[Int](5)
   }
 
-  private def fail(msg: String): Nothing = {
-    org.junit.Assert.fail(msg)
-    throw new AssertionError("Shouldn't reach here")
-  }
-
   @Test
-  def simpleEndpoint: Unit = {
+  def simpleEndpoint: AsyncResult = await {
     var called = false
     x.attach(eps.simple)((_: Unit) => called = true)
-    Await.result(y.call(eps.simple)(()), atMost = 1.second)
-    assertTrue(called)
+    y.call(eps.simple)(()).map(_ => assertTrue(called))
   }
 
   @Test
-  def multiplePendingCalls: Unit = {
+  def multiplePendingCalls: AsyncResult = await {
     val p = Promise[Int]
 
     x.attachAsync(eps.number)(_ => p.future)
@@ -57,8 +52,7 @@ class RPCCoreTest {
 
     p.success(1)
 
-    val results = Await.result(Future.sequence(futures), atMost = 10.second)
-    assertEquals(List.fill(20)(1), results)
+    Future.sequence(futures).map(res => assertEquals(List.fill(20)(1), res))
   }
 
   @Test
@@ -95,7 +89,7 @@ class RPCCoreTest {
   }
 
   @Test
-  def msgRPCOrdering: Unit = {
+  def msgRPCOrdering: AsyncResult = await {
     val msgsX = new AtomicInteger(0)
     val msgsY = new AtomicInteger(0)
 
@@ -117,11 +111,11 @@ class RPCCoreTest {
     y.send(eps.msg0)(0)
     p.success(())
 
-    Await.result(y.call(eps.simple)(()), atMost = 1.second)
-
-    // Message from x must be here by now.
-    assertEquals(1, msgsX.get())
-    assertEquals(1, msgsY.get())
+    y.call(eps.simple)(()).map { _ =>
+      // Message from x must be here by now.
+      assertEquals(1, msgsX.get())
+      assertEquals(1, msgsY.get())
+    }
   }
 
   @Test
@@ -136,26 +130,25 @@ class RPCCoreTest {
   }
 
   @Test
-  def remoteException: Unit = {
+  def remoteException: AsyncResult = await {
     val msg0 = "My message for the outer exception"
     val msg1 = "My message for the inner exception"
     x.attach(eps.simple)(
         (_: Unit) => throw new Exception(msg0, new Exception(msg1)))
 
-    try {
-      Await.result(y.call(eps.simple)(()), atMost = 1.second)
-      fail("Expected exception")
-    } catch {
-      case e: RPCCore.RPCException =>
-        assertNotNull(e.getCause())
-        assertEquals(msg0, e.getCause().getMessage())
-        assertNotNull(e.getCause().getCause())
-        assertEquals(msg1, e.getCause().getCause().getMessage())
-    }
+    y.call(eps.simple)(())
+      .map(_ => fail("Expected exception"))
+      .recover {
+        case e: RPCCore.RPCException =>
+          assertNotNull(e.getCause())
+          assertEquals(msg0, e.getCause().getMessage())
+          assertNotNull(e.getCause().getCause())
+          assertEquals(msg1, e.getCause().getCause().getMessage())
+      }
   }
 
   @Test
-  def closeChannel: Unit = {
+  def closeChannel: AsyncResult = await {
     // Attach something that never completes.
     x.attachAsync(eps.number)((_: Unit) => Promise[Int].future)
 
@@ -164,13 +157,12 @@ class RPCCoreTest {
     val cause = new Throwable("blah")
     y.close(cause)
 
-    try {
-      Await.result(future, atMost = 1.second)
-      fail("Expected exception")
-    } catch {
-      case e: RPCCore.ClosedException =>
-        assertSame(cause, e.getCause())
-    }
+    future
+      .map(_ => fail("Expected exception"))
+      .recover {
+        case e: RPCCore.ClosedException =>
+          assertSame(cause, e.getCause())
+      }
   }
 }
 
diff --git a/test-common/src/test/scala/org/scalajs/testing/common/RunMuxRPCTest.scala b/test-common/src/test/scala/org/scalajs/testing/common/RunMuxRPCTest.scala
index 06a19aa621..d23b5b7044 100644
--- a/test-common/src/test/scala/org/scalajs/testing/common/RunMuxRPCTest.scala
+++ b/test-common/src/test/scala/org/scalajs/testing/common/RunMuxRPCTest.scala
@@ -13,7 +13,6 @@
 package org.scalajs.testing.common
 
 import scala.concurrent._
-import scala.concurrent.duration._
 import scala.concurrent.ExecutionContext.Implicits.global
 
 import java.util.concurrent.atomic.AtomicInteger
@@ -21,6 +20,8 @@ import java.util.concurrent.atomic.AtomicInteger
 import org.junit.Test
 import org.junit.Assert._
 
+import org.scalajs.junit.async._
+
 class RunMuxRPCTest {
   import RPCCoreTest._
 
@@ -35,23 +36,22 @@ class RunMuxRPCTest {
     val msg: MsgEndpoint.EP[RunMux[Unit]] = MsgEndpoint[RunMux[Unit]](3)
   }
 
-  private def fail(msg: String): Nothing = {
-    org.junit.Assert.fail(msg)
-    throw new AssertionError("Shouldn't reach here")
-  }
-
   @Test
-  def muxedCall: Unit = {
+  def muxedCall: AsyncResult = await {
     val called = Array.fill(10)(false)
 
     for (i <- called.indices)
       x.attach(eps.call, i)(_ => called(i) = true)
 
-    for (i <- called.indices) {
-      Await.result(y.call(eps.call, i)(()), atMost = 1.second)
-      val (needTrue, needFalse) = called.splitAt(i + 1)
-      needTrue.foreach(assertTrue _)
-      needFalse.foreach(assertFalse _)
+    called.indices.foldLeft(Future.successful(())) { (prev, i) =>
+      for {
+        _ <- prev
+        _ <- y.call(eps.call, i)(())
+      } yield {
+        val (needTrue, needFalse) = called.splitAt(i + 1)
+        needTrue.foreach(assertTrue _)
+        needFalse.foreach(assertFalse _)
+      }
     }
   }
 
@@ -71,18 +71,17 @@ class RunMuxRPCTest {
   }
 
   @Test
-  def badRunId: Unit = {
+  def badRunId: AsyncResult = await {
     x.attach(eps.call, 0)(_ => ())
 
-    try {
-      Await.result(y.call(eps.call, 1)(()), atMost = 1.second)
-      fail("Expected exception")
-    } catch {
-      case e: RPCCore.RPCException =>
-        val cause = e.getCause()
-        assertNotNull(s"Did not get cause: $e", cause)
-        assertEquals("Unknown run 1", cause.getMessage())
-    }
+    y.call(eps.call, 1)(())
+      .map(_ => fail("Expected exception"))
+      .recover {
+        case e: RPCCore.RPCException =>
+          val cause = e.getCause()
+          assertNotNull(s"Did not get cause: $e", cause)
+          assertEquals("Unknown run 1", cause.getMessage())
+      }
   }
 
   @Test
diff --git a/test-suite/js/src/test/require-dynamic-import/org/scalajs/testsuite/jsinterop/DynamicImportTest.scala b/test-suite/js/src/test/require-dynamic-import/org/scalajs/testsuite/jsinterop/DynamicImportTest.scala
index 318ee5c300..7df354a086 100644
--- a/test-suite/js/src/test/require-dynamic-import/org/scalajs/testsuite/jsinterop/DynamicImportTest.scala
+++ b/test-suite/js/src/test/require-dynamic-import/org/scalajs/testsuite/jsinterop/DynamicImportTest.scala
@@ -26,20 +26,21 @@ import org.scalajs.junit.async._
 class DynamicImportTest {
   import DynamicImportTest._
 
-  @Test def testSuccessfulImport(): AsyncResult = {
-    await(js.`import`[QueryStringAPI]("querystring").toFuture.map { qs =>
+  @Test def testSuccessfulImport(): AsyncResult = await {
+    js.`import`[QueryStringAPI]("querystring").toFuture.map { qs =>
       assertEquals("object", js.typeOf(qs))
 
       val dict = js.Dictionary("foo" -> "bar", "baz" -> "qux")
 
       assertEquals("foo=bar&baz=qux", qs.stringify(dict))
       assertEquals("foo:bar;baz:qux", qs.stringify(dict, ";", ":"))
-    })
+    }
   }
 
   @Test(expected = classOf[js.JavaScriptException])
-  def testFailedImport(): AsyncResult =
-    await(js.`import`[js.Any]("non-existent-module").toFuture)
+  def testFailedImport(): AsyncResult = await {
+    js.`import`[js.Any]("non-existent-module").toFuture
+  }
 }
 
 object DynamicImportTest {