public CoverageResult CalculateForMethod(string projectName, MethodDeclarationSyntax method)
        {
            var projects = _testExplorer.GetUnignoredTestProjectsWithCoveredProjectsAsync().Result;
            var project = projects.FirstOrDefault(x => x.Name == projectName);

            if (project == null)
                return new CoverageResult(new LineCoverage[0]);

            var rewritter = new SolutionRewriter(new RewrittenDocumentsStorage(), _auditVariablesRewriter);
            RewrittenDocument rewrittenDocument = rewritter.RewriteDocumentWithAssemblyInfo(project, projects, method.SyntaxTree.FilePath, method.SyntaxTree.ToString());

            LineCoverage[] coverage = null;

            using (var appDomainTestExecutorScriptEngine = new AppDomainTestExecutorScriptEngine())
            {
                var lineCoverageCalc = new LineCoverageCalc(_testExplorer, new RoslynCompiler(),
                    new TestRunner(new NUnitTestExtractor(), appDomainTestExecutorScriptEngine, _solutionExplorer));

                coverage = lineCoverageCalc.CalculateForMethod(project, rewrittenDocument, method);
            }

            _coverageStore.Append(coverage);

            return new CoverageResult(coverage);
        }
        public async Task<CoverageResult> CalculateForAllDocumentsAsync()
        {
            var rewritter = new SolutionRewriter(new RewrittenDocumentsStorage(), _auditVariablesRewriter);

            //TODO: Change a method to async and don't use .Result
            var projects = await _testExplorer.GetUnignoredTestProjectsWithCoveredProjectsAsync().ConfigureAwait(false);
            RewriteResult rewrittenResult = rewritter.RewriteAllClasses(projects);

            LineCoverage[] coverage = null;

            using (var appDomainTestExecutorScriptEngine = new AppDomainTestExecutorScriptEngine())
            {
                var lineCoverageCalc = new LineCoverageCalc(_testExplorer, new RoslynCompiler(), new TestRunner(new NUnitTestExtractor(), appDomainTestExecutorScriptEngine, _solutionExplorer));

                coverage = lineCoverageCalc.CalculateForAllTests(rewrittenResult);
            }

            _coverageStore.WriteAll(coverage);

            return new CoverageResult(coverage);
        }
        public void Setup()
        {
            _compilerMock = Substitute.For<ICompiler>();
            _solutionExplorerMock = Substitute.For<ISolutionExplorer>();
            _testRunnerMock = Substitute.For<ITestRunner>();
            _compiledAllItems = new List<ICompiledItem>();
            _compiledSingleProjectItems=new List<ICompiledItem>();
            _testExplorerMock = Substitute.For<ITestExplorer>();

            _testExplorerMock.SolutionExplorer.Returns(_solutionExplorerMock);

            _sut = new LineCoverageCalc(_testExplorerMock,
                _compilerMock,
                _testRunnerMock);

            _compilerMock.Compile(Arg.Any<CompilationItem>(), Arg.Any<IEnumerable<string>>())
                .Returns((x) => _compiledSingleProjectItems.ToArray());

            _compilerMock.Compile(Arg.Any<IEnumerable<CompilationItem>>())
                .Returns((x) => _compiledAllItems.ToArray());
        }