Inheritance: ITestsSelectStrategy
        public async Task <MutationSessionChoices> Run(MethodIdentifier singleMethodToMutate = null, List <string> testAssemblies = null, bool auto = false)
        {
            _sessionCreationWindowShowTime = DateTime.Now;

            SessionCreator sessionCreator = _sessionCreatorFactory.Create();

            Task <List <CciModuleSource> > assembliesTask = _sessionConfiguration.LoadAssemblies();


            //  Task<List<MethodIdentifier>> coveringTask = sessionCreator.FindCoveringTests(assembliesTask, matcher);

            Task <TestsRootNode> testsTask = _sessionConfiguration.LoadTests();


            ITestsSelectStrategy testsSelector;
            bool constrainedMutation = false;
            ICodePartsMatcher matcher;

            if (singleMethodToMutate != null)
            {
                matcher             = new CciMethodMatcher(singleMethodToMutate);
                testsSelector       = new CoveringTestsSelectStrategy(assembliesTask, matcher, testsTask);
                constrainedMutation = true;
            }
            else
            {
                testsSelector = new AllTestsSelectStrategy(testsTask);
                matcher       = new AllMatcher();
            }
            _log.Info("Selecting tests in assemblies: " + testAssemblies.MakeString());
            var testsSelecting = testsSelector.SelectTests(testAssemblies);

            var t1 = sessionCreator.GetOperators();

            var t2 = sessionCreator.BuildAssemblyTree(assembliesTask, constrainedMutation, matcher);

            var t11 = t1.ContinueWith(task =>
            {
                _viewModel.MutationsTree.MutationPackages
                    = new ReadOnlyCollection <PackageNode>(task.Result.Packages);
            }, CancellationToken.None, TaskContinuationOptions.NotOnFaulted, _execute.GuiScheduler);

            var t22 = t2.ContinueWith(task =>
            {
                if (_typesManager.IsAssemblyLoadError)
                {
                    _svc.Logging.ShowWarning(UserMessages.WarningAssemblyNotLoaded());
                }
                var assembliesToMutate = task.Result.Where(a => !testAssemblies.ToEmptyIfNull().Contains(a.AssemblyPath.Path)).ToList();
                //assembliesToMutate = ClassCoverage.UnmarkNotCovered(assembliesToMutate,testAssemblies);
                _viewModel.TypesTreeMutate.Assemblies = new ReadOnlyCollection <AssemblyNode>(assembliesToMutate);
                _whiteSource = assembliesTask.Result;
            }, CancellationToken.None, TaskContinuationOptions.NotOnFaulted, _execute.GuiScheduler);

            var t33 = testsSelecting.ContinueWith(task =>
            {
                _viewModel.TypesTreeToTest.TestAssemblies
                    = new ReadOnlyCollection <TestNodeAssembly>(task.Result);

                if (_options.UseCodeCoverage)
                {
                    ClassCoverage.UnmarkNotCovered(_viewModel.TypesTreeMutate.Assemblies, _viewModel.TypesTreeToTest.TestAssemblies);
                }
            }, CancellationToken.None, TaskContinuationOptions.NotOnFaulted, _execute.GuiScheduler);


            try
            {
                var mainTask = Task.WhenAll(t1, t2, testsSelecting, t11, t22, t33).ContinueWith(t =>
                {
                    if (t.Exception != null)
                    {
                        ShowError(t.Exception);
                        _viewModel.Close();
                        tcs.TrySetCanceled();
                    }
                }, _execute.GuiScheduler);

                var wrappedTask = Task.WhenAll(tcs.Task, mainTask);

                if (_sessionConfiguration.AssemblyLoadProblem)
                {
                    new TaskFactory(_dispatcher.GuiScheduler)
                    .StartNew(() =>
                              _svc.Logging.ShowWarning(UserMessages.WarningAssemblyNotLoaded()));
                }
                return(await WaitForResult(auto, wrappedTask));
            }
            catch (Exception e)
            {
                _log.Error(e);
                throw;
            }
        }
        public async Task<MutationSessionChoices> Run(MethodIdentifier singleMethodToMutate = null, List<string> testAssemblies = null, bool auto = false)
        {
            _sessionCreationWindowShowTime = DateTime.Now;

            SessionCreator sessionCreator = _sessionCreatorFactory.Create();

            Task<List<CciModuleSource>> assembliesTask = _sessionConfiguration.LoadAssemblies();

        
          //  Task<List<MethodIdentifier>> coveringTask = sessionCreator.FindCoveringTests(assembliesTask, matcher);

            Task<TestsRootNode> testsTask = _sessionConfiguration.LoadTests();


            ITestsSelectStrategy testsSelector;
            bool constrainedMutation = false;
            ICodePartsMatcher matcher;
            if (singleMethodToMutate != null)
            {
                matcher = new CciMethodMatcher(singleMethodToMutate);
                testsSelector = new CoveringTestsSelectStrategy(assembliesTask, matcher, testsTask);
                constrainedMutation = true;
            }
            else
            {
                testsSelector = new AllTestsSelectStrategy(testsTask);
                matcher = new AllMatcher();
            }
            _log.Info("Selecting tests in assemblies: "+ testAssemblies.MakeString());
            var testsSelecting = testsSelector.SelectTests(testAssemblies);

            var t1 = sessionCreator.GetOperators();

            var t2 = sessionCreator.BuildAssemblyTree(assembliesTask, constrainedMutation, matcher);

            var t11 = t1.ContinueWith(task =>
            {
                _viewModel.MutationsTree.MutationPackages
                    = new ReadOnlyCollection<PackageNode>(task.Result.Packages);
            },CancellationToken.None, TaskContinuationOptions.NotOnFaulted, _execute.GuiScheduler);

            var t22 = t2.ContinueWith(task =>
            {
                if (_typesManager.IsAssemblyLoadError)
                {
                    _svc.Logging.ShowWarning(UserMessages.WarningAssemblyNotLoaded());
                }
                var assembliesToMutate = task.Result.Where(a => !testAssemblies.ToEmptyIfNull().Contains(a.AssemblyPath.Path)).ToList();
                //assembliesToMutate = ClassCoverage.UnmarkNotCovered(assembliesToMutate,testAssemblies);
                _viewModel.TypesTreeMutate.Assemblies = new ReadOnlyCollection<AssemblyNode>(assembliesToMutate);
                _whiteSource = assembliesTask.Result;
            }, CancellationToken.None, TaskContinuationOptions.NotOnFaulted, _execute.GuiScheduler);

            var t33 = testsSelecting.ContinueWith(task =>
            {
                _viewModel.TypesTreeToTest.TestAssemblies
                                = new ReadOnlyCollection<TestNodeAssembly>(task.Result);

                if (_options.UseCodeCoverage)
                {
                    ClassCoverage.UnmarkNotCovered(_viewModel.TypesTreeMutate.Assemblies, _viewModel.TypesTreeToTest.TestAssemblies);
                }

               
            }, CancellationToken.None, TaskContinuationOptions.NotOnFaulted, _execute.GuiScheduler);

              
            try
            {
                var mainTask = Task.WhenAll(t1, t2, testsSelecting, t11, t22, t33).ContinueWith(t =>
                {
                    
                    if (t.Exception != null)
                    {
                        ShowError(t.Exception);
                        _viewModel.Close();
                        tcs.TrySetCanceled();
                    }
                }, _execute.GuiScheduler);
               
                var wrappedTask = Task.WhenAll(tcs.Task, mainTask);

                if (_sessionConfiguration.AssemblyLoadProblem)
                {
                    new TaskFactory(_dispatcher.GuiScheduler)
                        .StartNew(() =>
                        _svc.Logging.ShowWarning(UserMessages.WarningAssemblyNotLoaded()));
                }
                return await WaitForResult(auto, wrappedTask);
            }
            catch (Exception e)
            {
                _log.Error(e);
                throw;
            }
        }