summaryrefslogtreecommitdiff
path: root/test/files/jvm
diff options
context:
space:
mode:
Diffstat (limited to 'test/files/jvm')
-rw-r--r--test/files/jvm/future-spec/FutureTests.scala261
-rw-r--r--test/files/jvm/future-spec/PromiseTests.scala244
2 files changed, 267 insertions, 238 deletions
diff --git a/test/files/jvm/future-spec/FutureTests.scala b/test/files/jvm/future-spec/FutureTests.scala
index 90ed10b93a..9a9cf951bb 100644
--- a/test/files/jvm/future-spec/FutureTests.scala
+++ b/test/files/jvm/future-spec/FutureTests.scala
@@ -162,10 +162,12 @@ object FutureTests extends MinimalScalaTest {
}
"firstCompletedOf" in {
- val futures = Vector.fill[Future[Int]](10) {
+ def futures = Vector.fill[Future[Int]](10) {
Promise[Int]().future
} :+ Promise.successful[Int](5).future
+
Await.result(Future.firstCompletedOf(futures), defaultTimeout) mustBe (5)
+ Await.result(Future.firstCompletedOf(futures.iterator), defaultTimeout) mustBe (5)
}
"find" in {
@@ -176,7 +178,7 @@ object FutureTests extends MinimalScalaTest {
val result = Future.find[Int](futures)(_ == 3)
Await.result(result, defaultTimeout) mustBe (Some(3))
- val notFound = Future.find[Int](futures)(_ == 11)
+ val notFound = Future.find[Int](futures.iterator)(_ == 11)
Await.result(notFound, defaultTimeout) mustBe (None)
}
@@ -208,11 +210,18 @@ object FutureTests extends MinimalScalaTest {
Thread.sleep(wait)
add
}
- def futures = (0 to 9) map {
+
+ val futures = (0 to 9) map {
idx => async(idx, idx * 200)
}
- def folded = Future.fold(futures)(0)(_ + _)
+ val folded = Future.fold(futures)(0)(_ + _)
Await.result(folded, timeout) mustBe (45)
+
+ val futuresit = (0 to 9) map {
+ idx => async(idx, idx * 200)
+ }
+ val foldedit = Future.fold(futures)(0)(_ + _)
+ Await.result(foldedit, timeout) mustBe (45)
}
"fold by composing" in {
@@ -273,9 +282,14 @@ object FutureTests extends MinimalScalaTest {
idx
}
val timeout = 10000 millis
+
val futures = (0 to 9) map { async }
val reduced = Future.reduce(futures)(_ + _)
Await.result(reduced, timeout) mustBe (45)
+
+ val futuresit = (0 to 9) map { async }
+ val reducedit = Future.reduce(futuresit)(_ + _)
+ Await.result(reducedit, timeout) mustBe (45)
}
"shouldReduceResultsWithException" in {
@@ -310,13 +324,17 @@ object FutureTests extends MinimalScalaTest {
}
}
- val oddFutures = List.fill(100)(future { counter.incAndGet() })
+ val oddFutures = List.fill(100)(future { counter.incAndGet() }).iterator
val traversed = Future.sequence(oddFutures)
Await.result(traversed, defaultTimeout).sum mustBe (10000)
val list = (1 to 100).toList
val traversedList = Future.traverse(list)(x => Future(x * 2 - 1))
Await.result(traversedList, defaultTimeout).sum mustBe (10000)
+
+ val iterator = (1 to 100).toList.iterator
+ val traversedIterator = Future.traverse(iterator)(x => Future(x * 2 - 1))
+ Await.result(traversedIterator, defaultTimeout).sum mustBe (10000)
}
"shouldHandleThrowables" in {
@@ -491,236 +509,3 @@ object FutureTests extends MinimalScalaTest {
}
-object PromiseTests extends MinimalScalaTest {
-
- val defaultTimeout = Inf
-
- /* promise specification */
-
- "An empty Promise" should {
-
- "not be completed" in {
- val p = Promise()
- p.future.isCompleted mustBe (false)
- }
-
- "have no value" in {
- val p = Promise()
- p.future.value mustBe (None)
- }
-
- "return supplied value on timeout" in {
- val failure = Promise.failed[String](new RuntimeException("br0ken")).future
- val otherFailure = Promise.failed[String](new RuntimeException("last")).future
- val empty = Promise[String]().future
- val timedOut = Promise.successful[String]("Timedout").future
-
- Await.result(failure fallbackTo timedOut, defaultTimeout) mustBe ("Timedout")
- Await.result(timedOut fallbackTo empty, defaultTimeout) mustBe ("Timedout")
- Await.result(failure fallbackTo failure fallbackTo timedOut, defaultTimeout) mustBe ("Timedout")
- intercept[RuntimeException] {
- Await.result(failure fallbackTo otherFailure, defaultTimeout)
- }.getMessage mustBe ("last")
- }
-
- }
-
- "A successful Promise" should {
- val result = "test value"
- val future = Promise[String]().complete(Right(result)).future
- futureWithResult(_(future, result))
- }
-
- "A failed Promise" should {
- val message = "Expected Exception"
- val future = Promise[String]().complete(Left(new RuntimeException(message))).future
- futureWithException[RuntimeException](_(future, message))
- }
-
- "An interrupted Promise" should {
- val message = "Boxed InterruptedException"
- val future = Promise[String]().complete(Left(new InterruptedException(message))).future
- futureWithException[ExecutionException](_(future, message))
- }
-
- "A NonLocalReturnControl failed Promise" should {
- val result = "test value"
- val future = Promise[String]().complete(Left(new NonLocalReturnControl[String]("test", result))).future
- futureWithResult(_(future, result))
- }
-
- def futureWithResult(f: ((Future[Any], Any) => Unit) => Unit) {
-
- "be completed" in { f((future, _) => future.isCompleted mustBe (true)) }
-
- "contain a value" in { f((future, result) => future.value mustBe (Some(Right(result)))) }
-
- "return result with 'blocking'" in { f((future, result) => blocking(future, defaultTimeout) mustBe (result)) }
-
- "return result with 'Await.result'" in { f((future, result) => Await.result(future, defaultTimeout) mustBe (result)) }
-
- "not timeout" in { f((future, _) => Await.ready(future, 0 millis)) }
-
- "filter result" in {
- f {
- (future, result) =>
- Await.result((future filter (_ => true)), defaultTimeout) mustBe (result)
- intercept[NoSuchElementException] {
- Await.result((future filter (_ => false)), defaultTimeout)
- }
- }
- }
-
- "transform result with map" in { f((future, result) => Await.result((future map (_.toString.length)), defaultTimeout) mustBe (result.toString.length)) }
-
- "compose result with flatMap" in {
- f { (future, result) =>
- val r = for (r <- future; p <- Promise.successful("foo").future) yield r.toString + p
- Await.result(r, defaultTimeout) mustBe (result.toString + "foo")
- }
- }
-
- "perform action with foreach" in {
- f {
- (future, result) =>
- val p = Promise[Any]()
- future foreach p.success
- Await.result(p.future, defaultTimeout) mustBe (result)
- }
- }
-
- "zip properly" in {
- f {
- (future, result) =>
- Await.result(future zip Promise.successful("foo").future, defaultTimeout) mustBe ((result, "foo"))
- intercept[RuntimeException] {
- Await.result(future zip Promise.failed(new RuntimeException("ohnoes")).future, defaultTimeout)
- }.getMessage mustBe ("ohnoes")
- }
- }
-
- "not recover from exception" in { f((future, result) => Await.result(future.recover({ case _ => "pigdog" }), defaultTimeout) mustBe (result)) }
-
- "perform action on result" in {
- f {
- (future, result) =>
- val p = Promise[Any]()
- future.onSuccess { case x => p.success(x) }
- Await.result(p.future, defaultTimeout) mustBe (result)
- }
- }
-
- "not project a failure" in {
- f {
- (future, result) =>
- intercept[NoSuchElementException] {
- Await.result(future.failed, defaultTimeout)
- }.getMessage mustBe ("Future.failed not completed with a throwable. Instead completed with: " + result)
- }
- }
-
- "cast using mapTo" in {
- f {
- (future, result) =>
- Await.result(future.mapTo[Boolean].recover({ case _: ClassCastException ⇒ false }), defaultTimeout) mustBe (false)
- }
- }
-
- }
-
- def futureWithException[E <: Throwable: Manifest](f: ((Future[Any], String) => Unit) => Unit) {
-
- "be completed" in {
- f((future, _) => future.isCompleted mustBe (true))
- }
-
- "contain a value" in {
- f((future, message) => {
- future.value.get.left.get.getMessage mustBe (message)
- })
- }
-
- "throw exception with 'blocking'" in {
- f {
- (future, message) =>
- intercept[E] {
- blocking(future, defaultTimeout)
- }.getMessage mustBe (message)
- }
- }
-
- "throw exception with 'Await.result'" in {
- f {
- (future, message) =>
- intercept[E] {
- Await.result(future, defaultTimeout)
- }.getMessage mustBe (message)
- }
- }
-
- "retain exception with filter" in {
- f {
- (future, message) =>
- intercept[E] { Await.result(future filter (_ => true), defaultTimeout) }.getMessage mustBe (message)
- intercept[E] { Await.result(future filter (_ => false), defaultTimeout) }.getMessage mustBe (message)
- }
- }
-
- "retain exception with map" in {
- f {
- (future, message) =>
- intercept[E] { Await.result(future map (_.toString.length), defaultTimeout) }.getMessage mustBe (message)
- }
- }
-
- "retain exception with flatMap" in {
- f {
- (future, message) =>
- intercept[E] { Await.result(future flatMap (_ => Promise.successful("foo").future), defaultTimeout) }.getMessage mustBe (message)
- }
- }
-
- "zip properly" in {
- f {
- (future, message) =>
- intercept[E] {
- Await.result(future zip Promise.successful("foo").future, defaultTimeout)
- }.getMessage mustBe (message)
- }
- }
-
- "recover from exception" in {
- f {
- (future, message) =>
- Await.result(future.recover({ case e if e.getMessage == message ⇒ "pigdog" }), defaultTimeout) mustBe ("pigdog")
- }
- }
-
- "project a failure" in {
- f((future, message) => Await.result(future.failed, defaultTimeout).getMessage mustBe (message))
- }
-
- "perform action on exception" in {
- f {
- (future, message) =>
- val p = Promise[Any]()
- future.onFailure { case _ => p.success(message) }
- Await.result(p.future, defaultTimeout) mustBe (message)
- }
- }
-
- "always cast successfully using mapTo" in {
- f {
- (future, message) =>
- intercept[E] { Await.result(future.mapTo[java.lang.Thread], defaultTimeout) }.getMessage mustBe (message)
- }
- }
- }
-}
-
-
-
-
-
-
-
diff --git a/test/files/jvm/future-spec/PromiseTests.scala b/test/files/jvm/future-spec/PromiseTests.scala
new file mode 100644
index 0000000000..6016746a23
--- /dev/null
+++ b/test/files/jvm/future-spec/PromiseTests.scala
@@ -0,0 +1,244 @@
+
+
+
+import scala.concurrent._
+import scala.concurrent.util.duration._
+import scala.concurrent.util.Duration.Inf
+import scala.collection._
+import scala.runtime.NonLocalReturnControl
+
+
+
+object PromiseTests extends MinimalScalaTest {
+
+ val defaultTimeout = Inf
+
+ /* promise specification */
+
+ "An empty Promise" should {
+
+ "not be completed" in {
+ val p = Promise()
+ p.future.isCompleted mustBe (false)
+ }
+
+ "have no value" in {
+ val p = Promise()
+ p.future.value mustBe (None)
+ }
+
+ "return supplied value on timeout" in {
+ val failure = Promise.failed[String](new RuntimeException("br0ken")).future
+ val otherFailure = Promise.failed[String](new RuntimeException("last")).future
+ val empty = Promise[String]().future
+ val timedOut = Promise.successful[String]("Timedout").future
+
+ Await.result(failure fallbackTo timedOut, defaultTimeout) mustBe ("Timedout")
+ Await.result(timedOut fallbackTo empty, defaultTimeout) mustBe ("Timedout")
+ Await.result(failure fallbackTo failure fallbackTo timedOut, defaultTimeout) mustBe ("Timedout")
+ intercept[RuntimeException] {
+ Await.result(failure fallbackTo otherFailure, defaultTimeout)
+ }.getMessage mustBe ("last")
+ }
+
+ }
+
+ "A successful Promise" should {
+ val result = "test value"
+ val future = Promise[String]().complete(Right(result)).future
+ futureWithResult(_(future, result))
+ }
+
+ "A failed Promise" should {
+ val message = "Expected Exception"
+ val future = Promise[String]().complete(Left(new RuntimeException(message))).future
+ futureWithException[RuntimeException](_(future, message))
+ }
+
+ "An interrupted Promise" should {
+ val message = "Boxed InterruptedException"
+ val future = Promise[String]().complete(Left(new InterruptedException(message))).future
+ futureWithException[ExecutionException](_(future, message))
+ }
+
+ "A NonLocalReturnControl failed Promise" should {
+ val result = "test value"
+ val future = Promise[String]().complete(Left(new NonLocalReturnControl[String]("test", result))).future
+ futureWithResult(_(future, result))
+ }
+
+ def futureWithResult(f: ((Future[Any], Any) => Unit) => Unit) {
+
+ "be completed" in { f((future, _) => future.isCompleted mustBe (true)) }
+
+ "contain a value" in { f((future, result) => future.value mustBe (Some(Right(result)))) }
+
+ "return result with 'blocking'" in { f((future, result) => blocking(future, defaultTimeout) mustBe (result)) }
+
+ "return result with 'Await.result'" in { f((future, result) => Await.result(future, defaultTimeout) mustBe (result)) }
+
+ "not timeout" in { f((future, _) => Await.ready(future, 0 millis)) }
+
+ "filter result" in {
+ f {
+ (future, result) =>
+ Await.result((future filter (_ => true)), defaultTimeout) mustBe (result)
+ intercept[NoSuchElementException] {
+ Await.result((future filter (_ => false)), defaultTimeout)
+ }
+ }
+ }
+
+ "transform result with map" in { f((future, result) => Await.result((future map (_.toString.length)), defaultTimeout) mustBe (result.toString.length)) }
+
+ "compose result with flatMap" in {
+ f { (future, result) =>
+ val r = for (r <- future; p <- Promise.successful("foo").future) yield r.toString + p
+ Await.result(r, defaultTimeout) mustBe (result.toString + "foo")
+ }
+ }
+
+ "perform action with foreach" in {
+ f {
+ (future, result) =>
+ val p = Promise[Any]()
+ future foreach p.success
+ Await.result(p.future, defaultTimeout) mustBe (result)
+ }
+ }
+
+ "zip properly" in {
+ f {
+ (future, result) =>
+ Await.result(future zip Promise.successful("foo").future, defaultTimeout) mustBe ((result, "foo"))
+ intercept[RuntimeException] {
+ Await.result(future zip Promise.failed(new RuntimeException("ohnoes")).future, defaultTimeout)
+ }.getMessage mustBe ("ohnoes")
+ }
+ }
+
+ "not recover from exception" in { f((future, result) => Await.result(future.recover({ case _ => "pigdog" }), defaultTimeout) mustBe (result)) }
+
+ "perform action on result" in {
+ f {
+ (future, result) =>
+ val p = Promise[Any]()
+ future.onSuccess { case x => p.success(x) }
+ Await.result(p.future, defaultTimeout) mustBe (result)
+ }
+ }
+
+ "not project a failure" in {
+ f {
+ (future, result) =>
+ intercept[NoSuchElementException] {
+ Await.result(future.failed, defaultTimeout)
+ }.getMessage mustBe ("Future.failed not completed with a throwable. Instead completed with: " + result)
+ }
+ }
+
+ "cast using mapTo" in {
+ f {
+ (future, result) =>
+ Await.result(future.mapTo[Boolean].recover({ case _: ClassCastException ⇒ false }), defaultTimeout) mustBe (false)
+ }
+ }
+
+ }
+
+ def futureWithException[E <: Throwable: Manifest](f: ((Future[Any], String) => Unit) => Unit) {
+
+ "be completed" in {
+ f((future, _) => future.isCompleted mustBe (true))
+ }
+
+ "contain a value" in {
+ f((future, message) => {
+ future.value.get.left.get.getMessage mustBe (message)
+ })
+ }
+
+ "throw exception with 'blocking'" in {
+ f {
+ (future, message) =>
+ intercept[E] {
+ blocking(future, defaultTimeout)
+ }.getMessage mustBe (message)
+ }
+ }
+
+ "throw exception with 'Await.result'" in {
+ f {
+ (future, message) =>
+ intercept[E] {
+ Await.result(future, defaultTimeout)
+ }.getMessage mustBe (message)
+ }
+ }
+
+ "retain exception with filter" in {
+ f {
+ (future, message) =>
+ intercept[E] { Await.result(future filter (_ => true), defaultTimeout) }.getMessage mustBe (message)
+ intercept[E] { Await.result(future filter (_ => false), defaultTimeout) }.getMessage mustBe (message)
+ }
+ }
+
+ "retain exception with map" in {
+ f {
+ (future, message) =>
+ intercept[E] { Await.result(future map (_.toString.length), defaultTimeout) }.getMessage mustBe (message)
+ }
+ }
+
+ "retain exception with flatMap" in {
+ f {
+ (future, message) =>
+ intercept[E] { Await.result(future flatMap (_ => Promise.successful("foo").future), defaultTimeout) }.getMessage mustBe (message)
+ }
+ }
+
+ "zip properly" in {
+ f {
+ (future, message) =>
+ intercept[E] {
+ Await.result(future zip Promise.successful("foo").future, defaultTimeout)
+ }.getMessage mustBe (message)
+ }
+ }
+
+ "recover from exception" in {
+ f {
+ (future, message) =>
+ Await.result(future.recover({ case e if e.getMessage == message ⇒ "pigdog" }), defaultTimeout) mustBe ("pigdog")
+ }
+ }
+
+ "project a failure" in {
+ f((future, message) => Await.result(future.failed, defaultTimeout).getMessage mustBe (message))
+ }
+
+ "perform action on exception" in {
+ f {
+ (future, message) =>
+ val p = Promise[Any]()
+ future.onFailure { case _ => p.success(message) }
+ Await.result(p.future, defaultTimeout) mustBe (message)
+ }
+ }
+
+ "always cast successfully using mapTo" in {
+ f {
+ (future, message) =>
+ intercept[E] { Await.result(future.mapTo[java.lang.Thread], defaultTimeout) }.getMessage mustBe (message)
+ }
+ }
+ }
+}
+
+
+
+
+
+
+
generated by cgit v1.2.3 (git 2.39.1) at 2024-08-18 17:23:27 +0000