From 2ef094f02f2b147621b264d86d8e63f810af6f3e Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jonas=20Bone=CC=81r?= <jonasremove@jonasboner.com>
Date: Tue, 11 Jan 2011 11:16:31 +0100
Subject: [PATCH] Fixed some TypedActor tests

---
 .../remoteinterface/RemoteInterface.scala     |  4 +-
 .../serialization/SerializationProtocol.scala | 18 ++++-
 .../TypedActorGuiceConfiguratorSpec.scala     |  5 +-
 .../typed-actor/TypedActorLifecycleSpec.scala | 72 -------------------
 4 files changed, 19 insertions(+), 80 deletions(-)

diff --git a/akka-actor/src/main/scala/akka/remoteinterface/RemoteInterface.scala b/akka-actor/src/main/scala/akka/remoteinterface/RemoteInterface.scala
index 36f304ba06..35caeffca4 100644
--- a/akka-actor/src/main/scala/akka/remoteinterface/RemoteInterface.scala
+++ b/akka-actor/src/main/scala/akka/remoteinterface/RemoteInterface.scala
@@ -138,14 +138,14 @@ abstract class RemoteSupport extends ListenerManagement with RemoteServerModule
    * If the supplied host and port is identical of the configured local node, it will be a local actor
    * <pre>
    *   import Actor._
-   *   val actor = actorOf(classOf[MyActor],"www.akka.io",2552)
+   *   val actor = actorOf(classOf[MyActor],"www.akka.io", 2552)
    *   actor.start
    *   actor ! message
    *   actor.stop
    * </pre>
    * You can create and start the actor in one statement like this:
    * <pre>
-   *   val actor = actorOf(classOf[MyActor],"www.akka.io",2552).start
+   *   val actor = actorOf(classOf[MyActor],"www.akka.io", 2552).start
    * </pre>
    */
   def actorOf(factory: => Actor, host: String, port: Int): ActorRef =
diff --git a/akka-remote/src/main/scala/akka/serialization/SerializationProtocol.scala b/akka-remote/src/main/scala/akka/serialization/SerializationProtocol.scala
index 738e351840..3494bed0b0 100644
--- a/akka-remote/src/main/scala/akka/serialization/SerializationProtocol.scala
+++ b/akka-remote/src/main/scala/akka/serialization/SerializationProtocol.scala
@@ -76,8 +76,11 @@ trait Format[T <: Actor] extends FromBinary[T] with ToBinary[T]
  * Module for local actor serialization.
  */
 object ActorSerialization {
+  def fromBinary[T <: Actor](bytes: Array[Byte], homeAddress: InetSocketAddress)(implicit format: Format[T]): ActorRef =
+    fromBinaryToLocalActorRef(bytes, Some(homeAddress), format)
+
   def fromBinary[T <: Actor](bytes: Array[Byte])(implicit format: Format[T]): ActorRef =
-    fromBinaryToLocalActorRef(bytes, format)
+    fromBinaryToLocalActorRef(bytes, None, format)
 
   def toBinary[T <: Actor](a: ActorRef, serializeMailBox: Boolean = true)(implicit format: Format[T]): Array[Byte] =
     toSerializedActorRefProtocol(a, format, serializeMailBox).toByteArray
@@ -153,8 +156,17 @@ object ActorSerialization {
     builder.build
   }
 
-  private def fromBinaryToLocalActorRef[T <: Actor](bytes: Array[Byte], format: Format[T]): ActorRef =
-    fromProtobufToLocalActorRef(SerializedActorRefProtocol.newBuilder.mergeFrom(bytes).build, format, None)
+  private def fromBinaryToLocalActorRef[T <: Actor](
+    bytes: Array[Byte], 
+    homeAddress: Option[InetSocketAddress], 
+    format: Format[T]): ActorRef = {
+    val builder = SerializedActorRefProtocol.newBuilder.mergeFrom(bytes)
+    homeAddress.foreach { addr => 
+      val addressProtocol = AddressProtocol.newBuilder.setHostname(addr.getHostName).setPort(addr.getPort).build
+      builder.setOriginalAddress(addressProtocol)
+    }
+    fromProtobufToLocalActorRef(builder.build, format, None)
+  }
 
   private[akka] def fromProtobufToLocalActorRef[T <: Actor](
       protocol: SerializedActorRefProtocol, format: Format[T], loader: Option[ClassLoader]): ActorRef = {
diff --git a/akka-typed-actor/src/test/scala/actor/typed-actor/TypedActorGuiceConfiguratorSpec.scala b/akka-typed-actor/src/test/scala/actor/typed-actor/TypedActorGuiceConfiguratorSpec.scala
index 4584ccf6a6..f145000ea4 100644
--- a/akka-typed-actor/src/test/scala/actor/typed-actor/TypedActorGuiceConfiguratorSpec.scala
+++ b/akka-typed-actor/src/test/scala/actor/typed-actor/TypedActorGuiceConfiguratorSpec.scala
@@ -56,7 +56,7 @@ class TypedActorGuiceConfiguratorSpec extends
   override def afterAll = conf.stop
 
   describe("TypedActorGuiceConfigurator") {
-/*
+
     it("should inject typed actor using guice") {
       messageLog = ""
       val foo = conf.getInstance(classOf[Foo])
@@ -77,7 +77,7 @@ class TypedActorGuiceConfiguratorSpec extends
         fail("exception should have been thrown")
       } catch {
         case e: Exception =>
-          classOf[IllegalStateException] should equal(e.getClass)
+          classOf[IllegalActorStateException] should equal(e.getClass)
       }
     }
 
@@ -125,6 +125,5 @@ class TypedActorGuiceConfiguratorSpec extends
           classOf[RuntimeException] should equal(e.getClass)
       }
     }
-    */
   }
 }
diff --git a/akka-typed-actor/src/test/scala/actor/typed-actor/TypedActorLifecycleSpec.scala b/akka-typed-actor/src/test/scala/actor/typed-actor/TypedActorLifecycleSpec.scala
index 9790c3657e..f9b0726f92 100644
--- a/akka-typed-actor/src/test/scala/actor/typed-actor/TypedActorLifecycleSpec.scala
+++ b/akka-typed-actor/src/test/scala/actor/typed-actor/TypedActorLifecycleSpec.scala
@@ -93,77 +93,5 @@ class TypedActorLifecycleSpec extends Spec with ShouldMatchers with BeforeAndAft
       SimpleJavaPojoImpl._pre should be(true)
       SimpleJavaPojoImpl._post should be(true)
     }
-
-    /*
-        it("should postStop non-supervised, annotated typed actor on TypedActor.stop") {
-          val obj = TypedActor.newInstance(classOf[SamplePojoAnnotated])
-          assert(AspectInitRegistry.initFor(obj) ne null)
-          assert("hello akka" === obj.greet("akka"))
-          TypedActor.stop(obj)
-          assert(AspectInitRegistry.initFor(obj) eq null)
-          assert(!obj.pre)
-          assert(!obj.post)
-          assert(obj.down)
-          try {
-            obj.greet("akka")
-            fail("access to stopped typed actor")
-          } catch {
-            case e: Exception => {}
-          }
-        }
-
-        it("should postStop non-supervised, annotated typed actor on Actor.registry.shutdownAll") {
-          val obj = TypedActor.newInstance(classOf[SamplePojoAnnotated])
-          assert(AspectInitRegistry.initFor(obj) ne null)
-          assert("hello akka" === obj.greet("akka"))
-          Actor.registry.shutdownAll
-          assert(AspectInitRegistry.initFor(obj) eq null)
-          assert(!obj.pre)
-          assert(!obj.post)
-          assert(obj.down)
-          try {
-            obj.greet("akka")
-            fail("access to stopped typed actor")
-          } catch {
-            case e: Exception => { }
-          }
-        }
-
-        it("should restart supervised, annotated typed actor on failure") {
-          val obj = conf1.getInstance[SamplePojoAnnotated](classOf[SamplePojoAnnotated])
-          val cdl = obj.newCountdownLatch(2)
-          assert(AspectInitRegistry.initFor(obj) ne null)
-          try {
-            obj.fail
-            fail("expected exception not thrown")
-          } catch {
-            case e: RuntimeException => {
-              cdl.await
-              assert(obj.pre)
-              assert(obj.post)
-              assert(!obj.down)
-              assert(AspectInitRegistry.initFor(obj) ne null)
-            }
-          }
-        }
-
-        it("should postStop supervised, annotated typed actor on failure") {
-          val obj = conf2.getInstance[SamplePojoAnnotated](classOf[SamplePojoAnnotated])
-          val cdl = obj.newCountdownLatch(1)
-          assert(AspectInitRegistry.initFor(obj) ne null)
-          try {
-            obj.fail
-            fail("expected exception not thrown")
-          } catch {
-            case e: RuntimeException => {
-              cdl.await
-              assert(!obj.pre)
-              assert(!obj.post)
-              assert(obj.down)
-              assert(AspectInitRegistry.initFor(obj) eq null)
-            }
-          }
-        }
-    */
   }
 }