Destruction (#330)

* perform no damage if the target is already destroyed; correct destruction timer override on sensor-type deployables

* framing vehicle remover tasks differently; screening for valid objects at some places in WSA; fixed router's internal telepad utility

* corrected issue with unique control agent Actor names for Players; propagated change to all dynamic objects (not those instantiated at server time)

* test fix

* another test fix; this time, Travis is having trouble with it

common/src/main/scala/net/psforever/objects/ExplosiveDeployable.scala

@@ -45,7 +45,7 @@ class ExplosiveDeployableDefinition(private val objectId : Int) extends ComplexD
   }
 
   override def Initialize(obj : PlanetSideServerObject with Deployable, context : ActorContext) = {
-    obj.Actor = context.actorOf(Props(classOf[ExplosiveDeployableControl], obj), s"${obj.Definition.Name}_${obj.GUID.guid}")
+    obj.Actor = context.actorOf(Props(classOf[ExplosiveDeployableControl], obj), PlanetSideServerObject.UniqueActorName(obj))
   }
 
   override def Uninitialize(obj : PlanetSideServerObject with Deployable, context : ActorContext) = {

common/src/main/scala/net/psforever/objects/SensorDeployable.scala

@@ -30,7 +30,7 @@ class SensorDeployableDefinition(private val objectId : Int) extends ComplexDepl
   Packet = new SmallDeployableConverter
 
   override def Initialize(obj : PlanetSideServerObject with Deployable, context : ActorContext) = {
-    obj.Actor = context.actorOf(Props(classOf[SensorDeployableControl], obj), s"${obj.Definition.Name}_${obj.GUID.guid}")
+    obj.Actor = context.actorOf(Props(classOf[SensorDeployableControl], obj), PlanetSideServerObject.UniqueActorName(obj))
   }
 
   override def Uninitialize(obj : PlanetSideServerObject with Deployable, context : ActorContext) = {
@@ -126,7 +126,7 @@ object SensorDeployableControl {
     target.Actor ! JammableUnit.ClearJammeredSound()
     target.Actor ! JammableUnit.ClearJammeredStatus()
     val zone = target.Zone
-    Deployables.AnnounceDestroyDeployable(target, Some(0 seconds))
+    Deployables.AnnounceDestroyDeployable(target, None)
     zone.LocalEvents ! LocalServiceMessage(zone.Id, LocalAction.TriggerEffectInfo(Service.defaultPlayerGUID, "on", target.GUID, false, 1000))
     zone.AvatarEvents ! AvatarServiceMessage(zone.Id, AvatarAction.Destroy(target.GUID, attribution, attribution, target.Position))
   }

common/src/main/scala/net/psforever/objects/ShieldGeneratorDeployable.scala

@@ -25,7 +25,7 @@ class ShieldGeneratorDefinition extends ComplexDeployableDefinition(240) {
   DeployCategory = DeployableCategory.ShieldGenerators
 
   override def Initialize(obj : PlanetSideServerObject with Deployable, context : ActorContext) = {
-    obj.Actor = context.actorOf(Props(classOf[ShieldGeneratorControl], obj), s"${obj.Definition.Name}_${obj.GUID.guid}")
+    obj.Actor = context.actorOf(Props(classOf[ShieldGeneratorControl], obj), PlanetSideServerObject.UniqueActorName(obj))
   }
 
   override def Uninitialize(obj : PlanetSideServerObject with Deployable, context : ActorContext) = {

common/src/main/scala/net/psforever/objects/TurretDeployable.scala

@@ -49,7 +49,7 @@ class TurretDeployableDefinition(private val objectId : Int) extends ComplexDepl
   override def MaxHealth_=(max : Int) : Int = super[ComplexDeployableDefinition].MaxHealth_=(max)
 
   override def Initialize(obj : PlanetSideServerObject with Deployable, context : ActorContext) = {
-    obj.Actor = context.actorOf(Props(classOf[TurretControl], obj), s"${obj.Definition.Name}_${obj.GUID.guid}")
+    obj.Actor = context.actorOf(Props(classOf[TurretControl], obj), PlanetSideServerObject.UniqueActorName(obj))
   }
 
   override def Uninitialize(obj : PlanetSideServerObject with Deployable, context : ActorContext) = {

common/src/main/scala/net/psforever/objects/ce/TelepadLike.scala

@@ -2,6 +2,7 @@
 package net.psforever.objects.ce
 
 import akka.actor.ActorContext
+import net.psforever.objects.serverobject.PlanetSideServerObject
 import net.psforever.objects.{PlanetSideGameObject, TelepadDeployable, Vehicle}
 import net.psforever.objects.serverobject.structures.Amenity
 import net.psforever.objects.vehicles.Utility
@@ -49,6 +50,10 @@ object TelepadLike {
     */
   def Setup(obj : Amenity, context : ActorContext) : Unit = {
     obj.asInstanceOf[TelepadLike].Router = obj.Owner.GUID
+    import akka.actor.{ActorRef, Props}
+    if(obj.Actor == ActorRef.noSender) {
+      obj.Actor = context.actorOf(Props(classOf[TelepadControl], obj), PlanetSideServerObject.UniqueActorName(obj))
+    }
   }
 
   /**
@@ -83,3 +88,16 @@ object TelepadLike {
     }
   }
 }
+
+/**
+  * Telepad-like components don't actually use control agents right now, but,
+  * since the `trait` is used for a `Vehicle` `Utility` entity as well as a `Deployable` entity,
+  * and all utilities are supposed to have control agents with which to interface,
+  * a placeholder like this is easy to reason around.
+  * @param obj an entity that extends `TelepadLike`
+  */
+class TelepadControl(obj : TelepadLike) extends akka.actor.Actor {
+  def receive : akka.actor.Actor.Receive = {
+    case _ => ;
+  }
+}

common/src/main/scala/net/psforever/objects/serverobject/PlanetSideServerObject.scala

@@ -3,6 +3,7 @@ package net.psforever.objects.serverobject
 
 import akka.actor.ActorRef
 import net.psforever.objects.PlanetSideGameObject
+import net.psforever.objects.entity.NoGUIDException
 import net.psforever.objects.serverobject.affinity.FactionAffinity
 import net.psforever.objects.zones.ZoneAware
 
@@ -34,3 +35,26 @@ abstract class PlanetSideServerObject extends PlanetSideGameObject
     actor
   }
 }
+
+object PlanetSideServerObject {
+  /**
+    * `Actor` entities require unique names over the course of the lifetime of the `ActorSystem` object.
+    * To produce this name, a composition of three strings separated by underscores is assembled.<br>
+    * - the entity's object name;
+    * uniqueness is very low, less than 50, but helps to identify the object<br>
+    * - the entity's globally unique identifier number;
+    * its uniqueness is much greater but still falls within less than 66535 possible integers;
+    * useful for locating that entity;
+    * an `Exception` can be thrown if this field was never set,
+    * but that is a condition for which it is worth throwing the `Exception`<br>
+    * - the current POSIX time in milliseconds;
+    * results will remain reasonably unique;
+    * useful for taking a rough estimation of how long the entity has existed
+    * @throws `NoGUIDException` if the entity has never been registered to a unique identifier system
+    * @param obj the entity for whom the `Actor` object will be created
+    * @return the unique name
+    */
+  def UniqueActorName(obj : PlanetSideGameObject) : String = {
+    s"${obj.Definition.Name}_${obj.GUID.guid}_${System.currentTimeMillis}"
+  }
+}

common/src/main/scala/net/psforever/objects/serverobject/terminals/MatrixTerminalDefinition.scala

@@ -3,6 +3,7 @@ package net.psforever.objects.serverobject.terminals
 
 import akka.actor.ActorContext
 import net.psforever.objects.Player
+import net.psforever.objects.serverobject.PlanetSideServerObject
 import net.psforever.objects.serverobject.structures.Amenity
 
 /**
@@ -29,7 +30,7 @@ object MatrixTerminalDefinition {
   def Setup(obj : Amenity, context : ActorContext) : Unit = {
     import akka.actor.{ActorRef, Props}
     if(obj.Actor == ActorRef.noSender) {
-      obj.Actor = context.actorOf(Props(classOf[TerminalControl], obj), s"${obj.Definition.Name}_${obj.GUID.guid}")
+      obj.Actor = context.actorOf(Props(classOf[TerminalControl], obj), PlanetSideServerObject.UniqueActorName(obj))
     }
   }
 }

common/src/main/scala/net/psforever/objects/serverobject/terminals/OrderTerminalDefinition.scala

@@ -7,6 +7,7 @@ import net.psforever.objects.{Player, Vehicle}
 import net.psforever.objects.equipment.Equipment
 import net.psforever.objects.loadouts.{InfantryLoadout, VehicleLoadout}
 import net.psforever.objects.inventory.InventoryItem
+import net.psforever.objects.serverobject.PlanetSideServerObject
 import net.psforever.objects.serverobject.structures.Amenity
 import net.psforever.packet.game.ItemTransactionMessage
 import net.psforever.objects.serverobject.terminals.EquipmentTerminalDefinition._
@@ -341,7 +342,7 @@ object OrderTerminalDefinition {
   def Setup(obj : Amenity, context : ActorContext) : Unit = {
     import akka.actor.{ActorRef, Props}
     if(obj.Actor == ActorRef.noSender) {
-      obj.Actor = context.actorOf(Props(classOf[TerminalControl], obj), s"${obj.Definition.Name}_${obj.GUID.guid}")
+      obj.Actor = context.actorOf(Props(classOf[TerminalControl], obj), PlanetSideServerObject.UniqueActorName(obj))
     }
   }
 }

common/src/main/scala/net/psforever/objects/serverobject/terminals/ProximityTerminal.scala

@@ -2,7 +2,7 @@
 package net.psforever.objects.serverobject.terminals
 
 import net.psforever.objects.Player
-import net.psforever.objects.serverobject.CommonMessages
+import net.psforever.objects.serverobject.{CommonMessages, PlanetSideServerObject}
 import net.psforever.objects.serverobject.structures.Amenity
 import net.psforever.types.Vector3
 import services.Service
@@ -76,7 +76,7 @@ object ProximityTerminal {
   def Setup(obj : Amenity, context : ActorContext) : Unit = {
     import akka.actor.{ActorRef, Props}
     if(obj.Actor == ActorRef.noSender) {
-      obj.Actor = context.actorOf(Props(classOf[ProximityTerminalControl], obj), s"${obj.Definition.Name}_${obj.GUID.guid}")
+      obj.Actor = context.actorOf(Props(classOf[ProximityTerminalControl], obj), PlanetSideServerObject.UniqueActorName(obj))
       obj.Actor ! Service.Startup()
     }
   }

common/src/main/scala/net/psforever/objects/serverobject/tube/SpawnTubeDefinition.scala

@@ -5,6 +5,7 @@ import akka.actor.ActorContext
 import net.psforever.objects.SpawnPointDefinition
 import net.psforever.objects.definition.ObjectDefinition
 import net.psforever.objects.definition.converter.SpawnTubeConverter
+import net.psforever.objects.serverobject.PlanetSideServerObject
 import net.psforever.objects.serverobject.structures.Amenity
 
 /**
@@ -25,7 +26,7 @@ object SpawnTubeDefinition {
   def Setup(obj : Amenity, context : ActorContext) : Unit = {
     import akka.actor.{ActorRef, Props}
     if(obj.Actor == ActorRef.noSender) {
-      obj.Actor = context.actorOf(Props(classOf[SpawnTubeControl], obj), s"${obj.Definition.Name}_${obj.GUID.guid}")
+      obj.Actor = context.actorOf(Props(classOf[SpawnTubeControl], obj), PlanetSideServerObject.UniqueActorName(obj))
     }
   }
 }

common/src/main/scala/net/psforever/objects/teamwork/SquadFeatures.scala

@@ -67,7 +67,7 @@ class SquadFeatures(val Squad : Squad) {
   private lazy val channel : String = s"${Squad.Faction}-Squad${Squad.GUID.guid}"
 
   def Start(implicit context : ActorContext) : SquadFeatures = {
-    switchboard = context.actorOf(Props[SquadSwitchboard], s"squad${Squad.GUID.guid}")
+    switchboard = context.actorOf(Props[SquadSwitchboard], s"squad_${Squad.GUID.guid}_${System.currentTimeMillis}")
     waypoints = Array.fill[WaypointData](SquadWaypoints.values.size)(new WaypointData())
     this
   }

common/src/main/scala/net/psforever/objects/vehicles/VehicleControl.scala

@@ -53,32 +53,13 @@ class VehicleControl(vehicle : Vehicle) extends Actor
 
   def Enabled : Receive = checkBehavior
     .orElse(deployBehavior)
-    .orElse(dismountBehavior)
     .orElse(jammableBehavior)
     .orElse {
-      case Mountable.TryMount(user, seat_num) =>
-        val exosuit = user.ExoSuit
-        val restriction = vehicle.Seats(seat_num).ArmorRestriction
-        val seatGroup = vehicle.SeatPermissionGroup(seat_num).getOrElse(AccessPermissionGroup.Passenger)
-        val permission = vehicle.PermissionGroup(seatGroup.id).getOrElse(VehicleLockState.Empire)
-        if(
-          (if(seatGroup == AccessPermissionGroup.Driver) {
-              vehicle.Owner.contains(user.GUID) || vehicle.Owner.isEmpty || permission != VehicleLockState.Locked
-            }
-            else {
-              permission != VehicleLockState.Locked
-            }) &&
-            (exosuit match {
-              case ExoSuitType.MAX => restriction == SeatArmorRestriction.MaxOnly
-              case ExoSuitType.Reinforced => restriction == SeatArmorRestriction.NoMax
-              case _ => restriction != SeatArmorRestriction.MaxOnly
-            })
-        ) {
-          mountBehavior.apply(Mountable.TryMount(user, seat_num))
-        }
-        else {
-          sender ! Mountable.MountMessages(user, Mountable.CanNotMount(vehicle, seat_num))
-        }
+      case msg : Mountable.TryMount =>
+        tryMountBehavior.apply(msg)
+
+      case msg : Mountable.TryDismount =>
+        dismountBehavior.apply(msg)
 
       case Vitality.Damage(damage_func) =>
         if(vehicle.Health > 0) {
@@ -122,9 +103,37 @@ class VehicleControl(vehicle : Vehicle) extends Actor
       case _ => ;
     }
 
+  val tryMountBehavior : Receive = {
+    case msg @ Mountable.TryMount(user, seat_num) =>
+      val exosuit = user.ExoSuit
+      val restriction = vehicle.Seats(seat_num).ArmorRestriction
+      val seatGroup = vehicle.SeatPermissionGroup(seat_num).getOrElse(AccessPermissionGroup.Passenger)
+      val permission = vehicle.PermissionGroup(seatGroup.id).getOrElse(VehicleLockState.Empire)
+      if(
+        (if(seatGroup == AccessPermissionGroup.Driver) {
+          vehicle.Owner.contains(user.GUID) || vehicle.Owner.isEmpty || permission != VehicleLockState.Locked
+        }
+        else {
+          permission != VehicleLockState.Locked
+        }) &&
+          (exosuit match {
+            case ExoSuitType.MAX => restriction == SeatArmorRestriction.MaxOnly
+            case ExoSuitType.Reinforced => restriction == SeatArmorRestriction.NoMax
+            case _ => restriction != SeatArmorRestriction.MaxOnly
+          })
+      ) {
+        mountBehavior.apply(msg)
+      }
+      else {
+        sender ! Mountable.MountMessages(user, Mountable.CanNotMount(vehicle, seat_num))
+      }
+  }
+
   def Disabled : Receive = checkBehavior
-    .orElse(dismountBehavior)
     .orElse {
+      case msg : Mountable.TryDismount =>
+        dismountBehavior.apply(msg)
+
       case Vehicle.Reactivate() =>
         context.become(Enabled)
 

common/src/main/scala/net/psforever/objects/zones/ZonePopulationActor.scala

@@ -39,13 +39,13 @@ class ZonePopulationActor(zone : Zone, playerMap : TrieMap[Avatar, Option[Player
 
     case Zone.Population.Spawn(avatar, player) =>
       PopulationSpawn(avatar, player, playerMap) match {
-        case Some(tplayer) =>
+        case Some((tplayer, newToZone)) =>
           tplayer.Zone = zone
           if(tplayer ne player) {
             sender ! Zone.Population.PlayerAlreadySpawned(zone, player)
           }
-          else {
-            player.Actor = context.actorOf(Props(classOf[PlayerControl], player), s"${player.Name}_${player.GUID.guid}")
+          else if(newToZone) {
+            player.Actor = context.actorOf(Props(classOf[PlayerControl], player),  s"${player.Name}_${player.GUID.guid}_${System.currentTimeMillis}")
             player.Zone = zone
           }
         case None =>
@@ -110,19 +110,21 @@ object ZonePopulationActor {
     * @param avatar an `Avatar` object
     * @param player a `Player` object
     * @param playerMap the mapping of `Avatar` objects to `Player` objects
-    * @return the `Player` object that is associated with the `Avatar` key
+    * @return a `Tuple` object of the `Player` object that is associated with the `Avatar` key
+    *         and whether that player was added to the zone for the first time;
+    *         `None`, if the player should not be introduced to this zone at this time
     */
-  def PopulationSpawn(avatar : Avatar, player : Player, playerMap : TrieMap[Avatar, Option[Player]]) : Option[Player] = {
+  def PopulationSpawn(avatar : Avatar, player : Player, playerMap : TrieMap[Avatar, Option[Player]]) : Option[(Player, Boolean)] = {
     playerMap.get(avatar) match {
       case None =>
         None
       case Some(tplayer) =>
         tplayer match {
           case Some(aplayer) =>
-            Some(aplayer)
+            Some(aplayer, false)
           case None =>
             playerMap(avatar) = Some(player)
-            Some(player)
+            Some(player, true)
         }
     }
   }

common/src/main/scala/net/psforever/objects/zones/ZoneVehicleActor.scala

@@ -3,6 +3,7 @@ package net.psforever.objects.zones
 
 import akka.actor.{Actor, ActorRef, Props}
 import net.psforever.objects.Vehicle
+import net.psforever.objects.serverobject.PlanetSideServerObject
 import net.psforever.objects.vehicles.VehicleControl
 
 import scala.annotation.tailrec
@@ -43,7 +44,7 @@ class ZoneVehicleActor(zone : Zone, vehicleList : ListBuffer[Vehicle]) extends A
       else {
         vehicleList += vehicle
         vehicle.Zone = zone
-        vehicle.Actor = context.actorOf(Props(classOf[VehicleControl], vehicle), s"${vehicle.Definition.Name}_${vehicle.GUID.guid}")
+        vehicle.Actor = context.actorOf(Props(classOf[VehicleControl], vehicle), PlanetSideServerObject.UniqueActorName(vehicle))
       }
 
     case Zone.Vehicle.Despawn(vehicle) =>

common/src/main/scala/services/vehicle/support/VehicleRemover.scala

@@ -22,52 +22,59 @@ class VehicleRemover extends RemoverActor {
   def InitialJob(entry : RemoverActor.Entry) : Unit = { }
 
   def FirstJob(entry : RemoverActor.Entry) : Unit = {
-    val vehicle = entry.obj.asInstanceOf[Vehicle]
-    val vehicleGUID = vehicle.GUID
-    val zoneId = entry.zone.Id
-    vehicle.Actor ! Vehicle.PrepareForDeletion()
-    //escape being someone else's cargo
-    (vehicle.MountedIn match {
-      case Some(carrierGUID) =>
-        entry.zone.Vehicles.find(v => v.GUID == carrierGUID)
-      case None =>
-        None
-    }) match {
-      case Some(carrier : Vehicle) =>
-        val driverName = carrier.Seats(0).Occupant match {
-          case Some(driver) => driver.Name
-          case _ => zoneId
+    val vehicleGUID = entry.obj.GUID
+    entry.zone.GUID(vehicleGUID) match {
+      case Some(vehicle : Vehicle) if vehicle.HasGUID =>
+        val zoneId = entry.zone.Id
+        vehicle.Actor ! Vehicle.PrepareForDeletion()
+        //escape being someone else's cargo
+        (vehicle.MountedIn match {
+          case Some(carrierGUID) =>
+            entry.zone.Vehicles.find(v => v.GUID == carrierGUID)
+          case None =>
+            None
+        }) match {
+          case Some(carrier : Vehicle) =>
+            val driverName = carrier.Seats(0).Occupant match {
+              case Some(driver) => driver.Name
+              case _ => zoneId
+            }
+            context.parent ! VehicleServiceMessage(s"$driverName", VehicleAction.ForceDismountVehicleCargo(PlanetSideGUID(0), vehicleGUID, true, false, false))
+          case _ => ;
         }
-        context.parent ! VehicleServiceMessage(s"$driverName", VehicleAction.ForceDismountVehicleCargo(PlanetSideGUID(0), vehicleGUID, true, false, false))
+        //kick out all passengers
+        vehicle.Seats.values.foreach(seat => {
+          seat.Occupant match {
+            case Some(tplayer) =>
+              seat.Occupant = None
+              tplayer.VehicleSeated = None
+              if(tplayer.HasGUID) {
+                context.parent ! VehicleServiceMessage(zoneId, VehicleAction.KickPassenger(tplayer.GUID, 4, false, vehicleGUID))
+              }
+            case None => ;
+          }
+          //abandon all cargo
+          vehicle.CargoHolds.values
+            .collect { case hold if hold.isOccupied =>
+              val cargo = hold.Occupant.get
+              context.parent ! VehicleServiceMessage(zoneId, VehicleAction.ForceDismountVehicleCargo(PlanetSideGUID(0), cargo.GUID, true, false, false))
+            }
+        })
       case _ => ;
     }
-    //kick out all passengers
-    vehicle.Seats.values.foreach(seat => {
-      seat.Occupant match {
-        case Some(tplayer) =>
-          seat.Occupant = None
-          tplayer.VehicleSeated = None
-          if(tplayer.HasGUID) {
-            context.parent ! VehicleServiceMessage(zoneId, VehicleAction.KickPassenger(tplayer.GUID, 4, false, vehicleGUID))
-          }
-        case None => ;
-      }
-      //abandon all cargo
-      vehicle.CargoHolds.values
-        .collect { case hold if hold.isOccupied =>
-          val cargo = hold.Occupant.get
-          context.parent ! VehicleServiceMessage(zoneId, VehicleAction.ForceDismountVehicleCargo(PlanetSideGUID(0), cargo.GUID, true, false, false))
-        }
-    })
   }
 
   override def SecondJob(entry : RemoverActor.Entry) : Unit = {
-    val vehicle = entry.obj.asInstanceOf[Vehicle]
-    val zone = entry.zone
-    vehicle.DeploymentState = DriveState.Mobile
-    zone.Transport ! Zone.Vehicle.Despawn(vehicle)
-    context.parent ! VehicleServiceMessage(zone.Id, VehicleAction.UnloadVehicle(Service.defaultPlayerGUID, zone, vehicle, vehicle.GUID))
-    super.SecondJob(entry)
+    val vehicleGUID = entry.obj.GUID
+    entry.zone.GUID(vehicleGUID) match {
+      case Some(vehicle : Vehicle) if vehicle.HasGUID =>
+        val zone = entry.zone
+        vehicle.DeploymentState = DriveState.Mobile
+        zone.Transport ! Zone.Vehicle.Despawn(vehicle)
+        context.parent ! VehicleServiceMessage(zone.Id, VehicleAction.UnloadVehicle(Service.defaultPlayerGUID, zone, vehicle, vehicleGUID))
+        super.SecondJob(entry)
+      case _ => ;
+    }
   }
 
   def ClearanceTest(entry : RemoverActor.Entry) : Boolean = entry.obj.asInstanceOf[Vehicle].Seats.values.count(_.isOccupied) == 0

common/src/test/scala/objects/UtilityTest.scala

@@ -217,7 +217,7 @@ class UtilityInternalTelepadTest extends ActorTest {
 
       system.actorOf(Props(classOf[UtilityTest.SetupControl], obj), "test") ! ""
       receiveOne(Duration.create(100, "ms")) //consume and discard
-      assert(obj().Actor == ActorRef.noSender)
+      assert(obj().Actor != ActorRef.noSender)
       assert(obj().asInstanceOf[Utility.InternalTelepad].Router.contains(veh.GUID))
     }
   }

common/src/test/scala/objects/number/UniqueNumberSystemTest.scala

@@ -187,14 +187,14 @@ class UniqueNumberSystemTest5 extends ActorTest() {
       assert(src.CountUsed == 0)
 
       uns ! Register(testObj, "pool2")
-      val msg1 = receiveOne(Duration.create(500, "ms"))
+      val msg1 = receiveOne(Duration.create(2000, "ms"))
       assert(msg1.isInstanceOf[Success[_]])
       assert(testObj.HasGUID)
       assert(pool2.contains(testObj.GUID.guid))
       assert(src.CountUsed == 1)
 
       uns ! Unregister(testObj)
-      val msg2 = receiveOne(Duration.create(500, "ms"))
+      val msg2 = receiveOne(Duration.create(2000, "ms"))
       assert(msg2.isInstanceOf[Success[_]])
       assert(!testObj.HasGUID)
       assert(src.CountUsed == 0)