public RemoteTaskWrapper(RemoteTask remoteTask, IRemoteTaskServer server)
        {
            RemoteTask = remoteTask;
            this.server = server;

            result = TaskResult.Inconclusive;
        }

 public static TaskMessages OfTask(this IEnumerable<TaskMessage> taskMessages, RemoteTask task)
 {
     var sameTasks = from tm in taskMessages
         where Equals(tm.Task, task) && tm.Task.Id == task.Id
         select tm;
     return new TaskMessages(task, "same", sameTasks.ToList());
 }

 public TaskMessages(RemoteTask task, string taskMatchStyle, IList<TaskMessage> taskMessages)
 {
     this.task = task;
     this.taskMatchStyle = taskMatchStyle;
     messages = taskMessages.Select(tm => tm.Message).ToList();
     serverActions = taskMessages.Select(tm => tm.ServerAction).ToList();
 }

        public void TaskStarting(RemoteTask remoteTask)
        {
            Assert.NotNull(remoteTask);

            tasks.Push(remoteTask);
            TaskStartingCalls.Add(remoteTask);
        }

 private static void AssertTaskFinishedCalled(FakeRemoteTaskServer.TaskFinishedParameters taskFinishedCall,
                                              RemoteTask remoteTask, string message, TaskResult result)
 {
     Assert.Equal(remoteTask, taskFinishedCall.RemoteTask);
     Assert.Equal(message, taskFinishedCall.Message);
     Assert.Equal(result, taskFinishedCall.Result);
 }

        public override bool Equals(RemoteTask other)
        {
            if (other == null) return false;

            return ReferenceEquals(this, other) ||
                Equals(other as LoadContextAssemblyTask);
        }

 public static TaskMessages OfEquivalentTask(this IEnumerable<TaskMessage> taskMessages, RemoteTask task)
 {
     var equivalentTasks = from tm in taskMessages
         where Equals(tm.Task, task)
         select tm;
     return new TaskMessages(task, "equal", equivalentTasks.ToList());
 }

        private IStorEvilJob GetJob(RemoteTask remoteTask, IScenario scenario)
        {
            InPlaceStoryRunner handler = BuildInPlaceRunner(remoteTask);
            IStoryProvider provider = new SingleScenarioStoryProvider(scenario);

            return new StorEvilJob(provider, handler);
        }

        private InPlaceStoryRunner BuildInPlaceRunner(RemoteTask remoteTask)
        {
            _listener = new ResharperResultListener(_server, remoteTask);
            IScenarioPreprocessor preprocessor = new ScenarioPreprocessor();

            return new InPlaceStoryRunner(_listener, preprocessor, new ScenarioInterpreter(new InterpreterForTypeFactory(new ExtensionMethodHandler())), new IncludeAllFilter(), _factory );
        }

        public string GetFullMethodName(RemoteTask task)
        {
            var typeName = task.GetProperty<string>("TypeName");
            var shortName = task.GetProperty<string>("ShortName");

            return string.Format("{0}.{1}", typeName, shortName);
        }

 public TaskState(RemoteTask task, TaskState parentState, string message = "Internal Error (xunit runner): No status reported", TaskResult result = TaskResult.Inconclusive)
 {
     Task = task;
     Message = message;
     Result = result;
     ParentState = parentState;
 }

        private TaskMessage(RemoteTask task, ServerAction serverAction, params object[] parameters)
        {
            Assert.NotNull(task);

            Task = task;
            ServerAction = serverAction;
            Message = ServerMessage.Format(serverAction, parameters);
        }

        public IUnitTestElement GetDynamicElement(RemoteTask remoteTask, Dictionary<RemoteTask, IUnitTestElement> tasks)
        {
            var caseTask = remoteTask as TestCaseTask;
            if (caseTask != null)
                return GetDynamicCaseElement(tasks, caseTask);

            return null;
        }

        public bool TaskStarting(RemoteTask remoteTask)
        {
            Assert.NotNull(remoteTask);

            tasks.Push(remoteTask);
            TaskStartingCalls.Add(remoteTask);

            return true;
        }

        public void TaskFinished(RemoteTask remoteTask, string message, TaskResult result, TimeSpan duration)
        {
            Debug.Assert(result != TaskResult.Inconclusive);

            clientController.TaskFinished(remoteTask);
            if (result == TaskResult.Skipped)
                server.TaskExplain(remoteTask, message);
            if (duration >= TimeSpan.Zero)
                server.TaskDuration(remoteTask, duration);
            server.TaskFinished(remoteTask, message, result);
        }

        public bool TaskProgress(RemoteTask remoteTask, string message)
        {
            Assert.NotNull(remoteTask);
            Assert.Same(tasks.Peek(), remoteTask);

            if (!TaskProgressCalls.ContainsKey(remoteTask))
                TaskProgressCalls.Add(remoteTask, new List<string>());
            TaskProgressCalls[remoteTask].Add(message);

            return true;
        }

        public IUnitTestElement GetDynamicElement(RemoteTask remoteTask, Dictionary<string, IUnitTestElement> taskIdsToElements)
        {
            var theoryTask = remoteTask as XunitTestTheoryTask;
            if (theoryTask != null)
                return GetDynamicTheoryElement(taskIdsToElements, theoryTask);

            var methodTask = remoteTask as XunitTestMethodTask;
            if (methodTask != null)
                return GetDynamicMethodElement(taskIdsToElements, methodTask);

            return null;
        }

        public string GetFullMethodName(RemoteTask task)
        {
            var typeName = task.GetProperty<string>("TypeName");

            string methodName;

            try
            {
                methodName = task.GetProperty<string>("MethodName");
            }
            catch (Exception)
            {
                methodName = task.GetProperty<string>("ShortName");
            }

            return string.Format("{0}.{1}", typeName, methodName);
        }

        public IUnitTestElement GetDynamicElement(RemoteTask remoteTask, Func<string, ITestElement> elementProvider)
        {
            var dynamicTask = (DynamicTask) remoteTask;
              var parentElement = elementProvider(dynamicTask.ParentGuid);
              Trace.Assert(parentElement != null, "parentElement != null");

              var elementTypeFullName = typeof(ChildTestElement).FullName;
              var project = parentElement.GetProject().AssertNotNull();
              var entity = new TestEntitySurrogate(dynamicTask.Identity, project, new string[0], dynamicTask.Text);

              var elementFactory = project.GetComponent<ITestElementFactory>();
              var element = elementFactory.GetOrCreateTestElement(elementTypeFullName, entity, parentElement);

              // TODO: parameter for elementFactory instead?
              element.State = UnitTestElementState.Dynamic;

              return element;
        }

        public TaskResult Execute(RemoteTask remoteTask)
        {
            try
            {
                var scenario = ((RunScenarioTask) remoteTask).GetScenario();
                var job = GetJob(remoteTask, scenario);

                job.Run();

                return _listener.Result;
            }
            catch (Exception ex)
            {
                Logger.Log(ex.ToString());
                _server.TaskOutput(remoteTask, "Exception!\r\n", TaskOutputType.STDOUT);
                _server.TaskOutput(remoteTask, ex.ToString(), TaskOutputType.STDOUT);

                return TaskResult.Exception;
            }
        }