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, )", analysis) { - case ConflictingTopLevelExport("foo", _) => true - } + assertContainsError("ConflictingTopLevelExport(foo, )", 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 {