public RemoteTaskNotification CreateTaskNotification(TaskExecutionNode node, ICollection<string> contexts)
        {
            var remoteTask = node.RemoteTask;

            if (remoteTask is RunAssemblyTask)
            {
                return new AssemblyRemoteTaskNotification(node);
            }

            if (remoteTask is ContextTask)
            {
                contexts.Add(((ContextTask)remoteTask).ContextTypeName);

                return new ContextRemoteTaskNotification(node);
            }

            if (remoteTask is ContextSpecificationTask)
            {
                return new ContextSpecificationRemoteTaskNotification(node);
            }

            if (remoteTask is BehaviorSpecificationTask)
            {
                return new BehaviorSpecificationRemoteTaskNotification(node);
            }

            return new SilentRemoteTaskNotification();
        }

    public RemoteTaskNotification CreateTaskNotification(TaskExecutionNode node)
    {
      var remoteTask = node.RemoteTask;

      if (remoteTask is RunAssemblyTask)
      {
        return new AssemblyRemoteTaskNotification(node);
      }
      
      if (remoteTask is ContextTask)
      {
        return new ContextRemoteTaskNotification(node);
      }

      if (remoteTask is ContextSpecificationTask)
      {
        return new ContextSpecificationRemoteTaskNotification(node);
      }

      if (remoteTask is BehaviorSpecificationTask)
      {
        return new BehaviorSpecificationRemoteTaskNotification(node);
      }

      return new SilentRemoteTaskNotification();
    }

 private TaskExecutionNode CreateMethodNode(TaskExecutionNode classNode, Method method)
 {
     var methodNode = new TaskExecutionNode(classNode, method.Task);
     foreach (var theoryTask in method.TheoryTasks)
         methodNode.Children.Add(new TaskExecutionNode(methodNode, theoryTask));
     return methodNode;
 }

        private ExecutionResult ExecuteRecursiveInternal(TaskExecutionNode node)
        {
            Server.TaskStarting(node.RemoteTask);
            ExecutionResult result;
            try
            {
                if (node.RemoteTask is RunProjectTask)
                    SetUpScenarioExecutorForCurrentProject(node);

                if (node.RemoteTask is RunScenarioTask)
                    result = ExecuteScenario(node);
                else
                    result = ExecuteChildTasks(node);
            }
            catch (Exception ex)
            {
                Logger.Log(ex.ToString());
                Server.TaskOutput(node.RemoteTask, ex + "\r\n", TaskOutputType.STDOUT);
                result = new ExecutionResult(TaskResult.Error, ex.ToString());
            }
            if (!(node.RemoteTask is RunProjectTask))
                Server.TaskFinished(node.RemoteTask, result.Message, result.Status);

            return result;
        }

        public override void ExecuteRecursive(TaskExecutionNode node)
        {
            //Debugger.Break();

            var assemblyProviders = new IAssemblyTaskProvider[]
            {
                new MsTestAssemblyTaskProvider(),
                new NUnitAssemblyTaskProvider(),
                new XUnitAssemblyTaskProvider()
            };
            var classProviders = new IClassTaskProvider[]
            {
                new MsTestClassTaskProvider(),
                new NUnitClassTaskProvider(),
                new XUnitClassTaskProvider()
            };
            var methodProviders = new IMethodTaskProvider[]
            {
                new MsTestMethodTaskProvider(),
                new NUnitMethodTaskProvider(),
                new XUnitMethodTaskProvider()
            };

            var taskEnvironment = new TaskEnvironment(Server, assemblyProviders, classProviders, methodProviders);
            var taskNode = new TaskNode(node, taskEnvironment);

            foreach (var silverlightTaskNode in taskNode.GetSilverlightTasks())
            {
                silverlightTaskNode.Execute(Execute);
            }
        }

        private static string GetName(TaskExecutionNode node)
        {
            var test = node.RemoteTask as TestTask;
            if (test != null) return test.Name;

            return null;
        }

 void TryRegisterSpecifications(TaskExecutionNode node)
 {
   if (node.RemoteTask is ContextSpecificationTask)
   {
     _listener.RegisterSpecification(new ExecutableSpecificationInfo(node));
   }
 }

        public static void Report(XDocument doc, IRemoteTaskServer server, TaskExecutionNode node)
        {
            var testCases = Parse(doc);
            if (testCases == null) return;

            var testNodes = from n in node.Flatten(x => x.Children)
                where n.RemoteTask is TestTask
                select n;

            foreach (var testNode in testNodes)
            {
                var key = GetFullName(testNode);
                if (!testCases.ContainsKey(key)) continue;

                var testCase = testCases[key];
                var task = testNode.RemoteTask;

            #if RESHARPER_8
                if (testCase.Duration != null)
                {
                    server.TaskDuration(task, testCase.Duration.Value);
                }
            #endif

                server.TaskFinished(task, testCase.Error, testCase.TaskResult);
            }
        }

    public override TaskResult Start(TaskExecutionNode node)
    {
      ContextTask task = (ContextTask) node.RemoteTask;
      
      _contextAssembly = LoadContextAssembly(task);
      if (_contextAssembly == null)
      {
        return TaskResult.Error;
      }

      _contextClass = _contextAssembly.GetType(task.ContextTypeName);
      if (_contextClass == null)
      {
        Server.TaskExplain(node.RemoteTask,
                           String.Format("Could not load type '{0}' from assembly {1}.",
                                         task.ContextTypeName,
                                         task.AssemblyLocation));
        Server.TaskError(node.RemoteTask, "Could not load context");
        return TaskResult.Error;
      }

      _listener = new PerContextRunListener(Server, node.RemoteTask);
      _runner = new DefaultRunner(_listener, RunOptions.Default);

      return TaskResult.Success;
    }

    public override TaskResult Start(TaskExecutionNode node)
    {
      var task = (RunAssemblyTask) node.RemoteTask;

      _contextAssembly = LoadContextAssembly(task);
      if (_contextAssembly == null)
      {
        return TaskResult.Error;
      }

      var result = VersionCompatibilityChecker.Check(_contextAssembly);
      if (!result.Success)
      {
        Server.TaskExplain(task, result.Explanation);
        Server.TaskError(task, result.ErrorMessage);

        return TaskResult.Error;
      }

      _listener = new PerAssemblyRunListener(Server, task);

      _runner = new DefaultRunner(_listener, RunOptions.Default, false);

      return TaskResult.Success;
    }

        public override void ExecuteRecursive(TaskExecutionNode node)
        {
            var task = (RunAssemblyTask)node.RemoteTask;

            var priorCurrentDirectory = Environment.CurrentDirectory;
            try
            {
                // Use the assembly in the folder that the user has specified, or, if not, use the assembly location
                var assemblyFolder = GetAssemblyFolder(TaskExecutor.Configuration, task);
                var assemblyPath = new AssemblyPath(Path.Combine(assemblyFolder, GetFileName(task.AssemblyLocation)));

                Environment.CurrentDirectory = assemblyFolder;

                var listener = new PerAssemblyRunListener(Server, task);
                var contextList = new List<string>();
                node.Flatten(x => x.Children).Each(children => RegisterRemoteTaskNotifications(listener, children, contextList));

                var runOptions = RunOptions.Custom.FilterBy(contextList);
                var appDomainRunner = new AppDomainRunner(listener, runOptions);

                if (TaskExecutor.Configuration.ShadowCopy)
                {
                    string cachePath = Path.Combine(Path.GetTempPath(), Path.GetRandomFileName());

                    runOptions.ShadowCopyTo(cachePath);
                    this.Server.SetTempFolderPath(cachePath);
                }

                appDomainRunner.RunAssembly(assemblyPath);
            }
            finally
            {
                Environment.CurrentDirectory = priorCurrentDirectory;
            }
        }

 private TaskExecutionNode CreateTaskNodes()
 {
     var assemblyNode = new TaskExecutionNode(null, null);
     foreach (var @class in Classes)
         assemblyNode.Children.Add(CreateClassNode(assemblyNode, @class));
     return assemblyNode;
 }

    private IIntent CreateIntent (TaskExecutionNode node)
    {
      var task = (Task) node.RemoteTask;
      var intent = Intent.Create(task.Identity);

      node.Children.Select(CreateIntent).ForEach(intent.AddIntent);

      return intent;
    }

 public override void ExecuteRecursive(TaskExecutionNode node)
 {
     try
     {
         _result = ExecuteRecursiveInternal(node).Status;
     }
     catch (Exception ex)
     {
         Logger.Log(ex.ToString());
     }
 }

        private TaskExecutionNode CreateClassNode(TaskExecutionNode assemblyNode, Class @class)
        {
            var classNode = new TaskExecutionNode(assemblyNode, @class.ClassTask);

            if (ShouldAddMethods(@class))
            {
                foreach (var method in @class.Methods)
                    classNode.Children.Add(CreateMethodNode(classNode, method));
            }
            return classNode;
        }

        private void CanExecuteRecursive()
        {
            var remoteTaskServer = Substitute.For<IRemoteTaskServer>();

            var taskRunner = new TaskRunner(remoteTaskServer);
            var remoteTask = Substitute.For<RemoteTask>("RemoteTask");
            var node = new TaskExecutionNode(null, remoteTask);
            taskRunner.ExecuteRecursive(node);

            remoteTaskServer.Received().TaskStarting(Arg.Any<RemoteTask>());
            remoteTaskServer.Received().TaskFinished(Arg.Any<RemoteTask>(), Arg.Any<string>(), TaskResult.Success);
        }

    private IRunIntent CreateRunIntent (TaskExecutionNode node)
    {
      var configuration = TaskExecutor.Configuration;

      var runTask = (RunTask) node.RemoteTask;
      var runIntent = RunIntent.Create(configuration.SeparateAppDomain, configuration.ShadowCopy, runTask.VisualStudioProcessId);
      _cancellationTokenSource = runIntent.CancellationTokenSource;

      node.Children.Select(CreateIntent).ForEach(runIntent.AddIntent);

      return runIntent;
    }

        public override TaskResult Execute(TaskExecutionNode node)
        {
            if (node.RemoteTask is RunScenarioTask)
            {
                var result = ExecuteScenario(node);
                if (result.Status != TaskResult.Success)
                    _result = result.Status;
                return result.Status;
            }

            return TaskResult.Success;
        }

    static IEnumerable<TaskExecutionNode> FlattenChildren(TaskExecutionNode node)
    {
      foreach (var child in node.Children)
      {
        yield return child;

        foreach (var descendant in child.Children)
        {
          yield return descendant;
        }
      }
    }

        public override void ExecuteRecursive(TaskExecutionNode node)
        {
            var asm = node.RemoteTask as NBehaveAssemblyTask;
            if (asm == null)
                return;
            Initialize(node);

            var featureTasks = GetFeatureTasks(node);
            NotifyTasksStarting(featureTasks.ToList());
            var runner = new TextRunner(config);
            runner.Run();
        }