public RoutedActorCell(ActorSystem system, InternalActorRef supervisor, Props routerProps, Props routeeProps, ActorPath path,
            Mailbox mailbox)
            : base(system, supervisor, routerProps, path, mailbox)
        {
            RouteeProps = routeeProps;
            routerConfig = routerProps.RouterConfig;
            Router = routerConfig.CreateRouter(system);
            routerConfig.Match()
                .With<Pool>(r =>
                {
                    var routees = new List<Routee>();
                    for (int i = 0; i < r.NrOfInstances; i++)
                    {
                        var routee = this.ActorOf(RouteeProps);
                        routees.Add(new ActorRefRoutee(routee));
                    }
                    AddRoutees(routees.ToArray());
                })
                .With<Group>(r =>
                {
                    var routees = routerConfig.GetRoutees(this).ToArray();
                    AddRoutees(routees);
                });



            Self = new RoutedActorRef(path, this);
        }

 public Delivery(ActorPath destination, object message, DateTime timestamp, int attempt)
 {
     Destination = destination;
     Message = message;
     Timestamp = timestamp;
     Attempt = attempt;
 }

        public void CreateFromStringAndToString()
        {
            string path ="abc\\def";
            var ap = new ActorPath(path);

            Assert.AreEqual(path, ap.ToString());
        }

 public FutureActorRef(TaskCompletionSource<object> result, ActorRef sender, Action unregister, ActorPath path)
 {
     _result = result;
     _sender = sender ?? ActorRef.NoSender;
     _unregister = unregister;
     Path = path;
 }

 public RootGuardianSupervisor(RootActorPath root, IActorRefProvider provider, TaskCompletionSource<Status> terminationPromise, ILoggingAdapter log)
 {
     _log = log;
     _terminationPromise = terminationPromise;
     _provider = provider;
     _path = root / "_Root-guardian-supervisor";   //In akka this is root / "bubble-walker" 
 }

 public RootGuardianActorRef(ActorSystemImpl system, Props props, MessageDispatcher dispatcher, Func<Mailbox> createMailbox, //TODO: switch from  Func<Mailbox> createMailbox to MailboxType mailboxType
     IInternalActorRef supervisor, ActorPath path, IInternalActorRef deadLetters, IReadOnlyDictionary<string, IInternalActorRef> extraNames)
     : base(system,props,dispatcher,createMailbox,supervisor,path)
 {
     _deadLetters = deadLetters;
     _extraNames = extraNames;
 }

 public FutureActorRef(TaskCompletionSource<object> result, ActorRef sender, Action unregister, ActorPath path)
 {
     this.result = result;
     this.sender = sender;
     this.unregister = unregister;
     Path = path;
 }

        public void CreateFromParentAndToString()
        {
            var ap1 = new ActorPath("");
            var ap2 = new ActorPath("test", ap1);

            Assert.AreEqual("\\test", ap2.ToString());
        }

            public static SurrogateForActorPath Convert(ActorPath value)
            {
                if (value == null)
                    return null;

                var path = ((ActorPath.Surrogate)value.ToSurrogate(CurrentSystem)).Path;
                return new SurrogateForActorPath { Path = path };
            }

 public void WhenAddChild_ThenNewActorRefPathIncludesCurrentPlusChild()
 {
     var actorPath = new ActorPath("root", null);
     ActorPath childPath = actorPath.AddChild("child");
     string[] elements = childPath.Elements.ToArray();
     Assert.AreEqual("root", elements[0]);
     Assert.AreEqual("child", elements[1]);
 }

 public void Setup(BenchmarkContext context)
 {
     _selectionOpCounter = context.GetCounter(ActorSelectionCounterName);
     System = ActorSystem.Create("MailboxThroughputSpecBase" + Counter.GetAndIncrement());
     _receiver = System.ActorOf(Props.Create(() => new BenchmarkActor(_selectionOpCounter, NumberOfMessages, _resetEvent)));
     _receiverActorPath = _receiver.Path;
     _oneMessageBenchmarkProps = Props.Create(() => new BenchmarkActor(_selectionOpCounter, 1, _resetEvent));
 }

        public Deploy Lookup(ActorPath path)
        {
            if (path.Elements.Head() != "user" || path.Elements.Count() < 2)
                return Deploy.None;

            var elements = path.Elements.Drop(1);
            return Lookup(elements);
        }

        public void EqualsTest()
        {
            var ap1 = new ActorPath("");
            var ap2 = new ActorPath("test", ap1);
            var ap3 = new ActorPath("\\test");

            Assert.IsTrue(ap2 == ap3);
            Assert.IsFalse(ap1 == ap3);
        }

 public RepointableActorRef(ActorSystemImpl system, Props props, MessageDispatcher dispatcher, MailboxType mailboxType, IInternalActorRef supervisor, ActorPath path)
 {
     System = system;
     Props = props;
     Dispatcher = dispatcher;
     MailboxType = mailboxType;
     Supervisor = supervisor;
     _path = path;
 }

        async Task Activate(ActorPath path)
        {
            var system = ClusterActorSystem.Current;

            actor = Activator.Activate(path.Type);
            actor.Initialize(path.Id, system, this, ActorPrototype.Of(path.Type));

            await actor.OnActivate();
        }

 public RepointableActorRef(ActorSystemImpl system, Props props, MessageDispatcher dispatcher, Func<Mailbox> createMailbox, IInternalActorRef supervisor, ActorPath path)
 {
     _system = system;
     _props = props;
     _dispatcher = dispatcher;
     _createMailbox = createMailbox;
     _supervisor = supervisor;
     _path = path;
 }

 public void WhenAddDescendant_ThenNewActorRefPathIncludesCurrentPlusAllDescendants()
 {
     var actorPath = new ActorPath("root", null);
     ActorPath childPath1 = actorPath.AddChild("child1");
     ActorPath childPath2 = childPath1.AddChild("child2");
     string[] elements = childPath2.Elements.ToArray();
     Assert.AreEqual("root", elements[0]);
     Assert.AreEqual("child1", elements[1]);
     Assert.AreEqual("child2", elements[2]);
 }

 public void WhenAddDescendantsWithPathString_ThenNewActorRefPathIncludesCurrentPlusChild()
 {
     var actorPath = new ActorPath("root", null);
     ActorPath childPath = actorPath.AddDescendant("child1/child2/child3");
     string[] elements = childPath.Elements.ToArray();
     Assert.AreEqual("root", elements[0]);
     Assert.AreEqual("child1", elements[1]);
     Assert.AreEqual("child2", elements[2]);
     Assert.AreEqual(actorPath, childPath.Root);
 }

        public static IActorEndpoint Proxy(ActorPath path)
        {
            var factory = factories.Find(path.Type);

            if (factory == null)
               throw new InvalidOperationException(
                   string.Format("Type: '{0}' is not registered as an Actor or Worker", path.Type));

            return (IActorEndpoint)factory(path.ToString());
        }

 /// <summary>
 /// Inheritors should only call this constructor
 /// </summary>
 internal protected  LocalActorRef(ActorSystem system, Props props, MessageDispatcher dispatcher, Func<Mailbox> createMailbox, IInternalActorRef supervisor, ActorPath path, Func<LocalActorRef, ActorCell> createActorCell) //TODO: switch from  Func<Mailbox> createMailbox to MailboxType mailboxType      
 {
     _system = system;
     _props = props;
     _dispatcher = dispatcher;
     _createMailbox = createMailbox;
     _supervisor = supervisor;
     _path = path;
     _cell = createActorCell(this);
 }