Adding custom error messages that Promises&Future are not serializable

  * Complete with regression test verifying that they all throw
    NotSerializableException

Author: viktorklang

src/library/scala/concurrent/Future.scala

@@ -13,7 +13,7 @@
 package scala.concurrent
 
 import scala.language.higherKinds
-import java.util.concurrent.{CountDownLatch, TimeUnit}
+import java.util.concurrent.{ CountDownLatch, TimeUnit }
 import java.util.concurrent.atomic.AtomicReference
 
 import scala.util.control.{NonFatal, NoStackTrace}

src/library/scala/concurrent/impl/Promise.scala

@@ -21,6 +21,7 @@ import scala.runtime.NonLocalReturnControl
 import java.util.concurrent.locks.AbstractQueuedSynchronizer
 import java.util.concurrent.atomic.{ AtomicReference, AtomicBoolean }
 import java.util.Objects.requireNonNull
+import java.io.{ NotSerializableException, IOException, ObjectInputStream, ObjectOutputStream }
 
 /**
   * Latch used to implement waiting on a DefaultPromise's result.
@@ -331,6 +332,15 @@ private[concurrent] object Promise {
         next.unlink(resolved)
       } else tryComplete0(state, resolved)
     }
+
+    @throws[IOException]
+    private def writeObject(out: ObjectOutputStream): Unit =
+      throw new NotSerializableException("Promises and Futures cannot be serialized")
+
+    @throws[IOException]
+    @throws[ClassNotFoundException]
+    private def readObject(in: ObjectInputStream): Unit =
+      throw new NotSerializableException("Promises and Futures cannot be deserialized")
   }
 
   // Constant byte tags for unpacking transformation function inputs or outputs

test/files/jvm/future-spec/FutureTests.scala

@@ -78,6 +78,25 @@ class FutureTests extends MinimalScalaTest {
   }
 
   "Futures" should {
+
+    "not be serializable" in {
+
+      def verifyNonSerializabilityFor(p: Future[_]): Unit = {
+        import java.io._
+        val out = new ObjectOutputStream(new ByteArrayOutputStream())
+        intercept[NotSerializableException] {
+          out.writeObject(p)
+        }
+      }
+      verifyNonSerializabilityFor(Await.ready(Future.unit.map(_ => ())(ExecutionContext.global), defaultTimeout))
+      verifyNonSerializabilityFor(Future.unit)
+      verifyNonSerializabilityFor(Future.failed(new NullPointerException))
+      verifyNonSerializabilityFor(Future.successful("test"))
+      verifyNonSerializabilityFor(Future.fromTry(Success("test")))
+      verifyNonSerializabilityFor(Future.fromTry(Failure(new NullPointerException)))
+      verifyNonSerializabilityFor(Future.never)
+    }
+
     "have proper toString representations" in {
       import ExecutionContext.Implicits.global
       val s = 5

test/files/jvm/future-spec/PromiseTests.scala

@@ -131,6 +131,23 @@ class PromiseTests extends MinimalScalaTest {
     futureWithResult(_(future, result))
   }
 
+  "A Promise should not be serializable" should {
+
+    def verifyNonSerializabilityFor(p: Promise[_]): Unit = {
+      import java.io._
+      val out = new ObjectOutputStream(new ByteArrayOutputStream())
+      intercept[NotSerializableException] {
+        out.writeObject(p)
+      }.getMessage mustBe "Promises and Futures cannot be serialized"
+    }
+
+    verifyNonSerializabilityFor(Promise[Unit]())
+    verifyNonSerializabilityFor(Promise.failed(new NullPointerException))
+    verifyNonSerializabilityFor(Promise.successful("test"))
+    verifyNonSerializabilityFor(Promise.fromTry(Success("test")))
+    verifyNonSerializabilityFor(Promise.fromTry(Failure(new NullPointerException)))
+  }
+
   def futureWithResult(f: ((Future[Any], Any) => Unit) => Unit): Unit = {
 
     "be completed" in { f((future, _) => future.isCompleted mustBe (true)) }