public async Task <ITestsExecutionResult <TTestCase> > ProcessTests(IList <TTestCase> impactedTests, StructuralDelta <TestsModel <TTestCase>, TTestCase> testsDelta, TProgramDelta programDelta,
                                                                            CancellationToken cancellationToken)
        {
            using (instrumentor)
            {
                applicationClosedHandler.AddApplicationClosedListener(instrumentor);

                await instrumentor.Instrument(programDelta.NewModel, impactedTests, cancellationToken);

                executor.TestResultAvailable += TestResultAvailable;
                var result = await executor.ProcessTests(impactedTests, testsDelta, programDelta, cancellationToken);

                executor.TestResultAvailable -= TestResultAvailable;

                CorrespondenceLinks coverage = instrumentor.GetCorrespondenceLinks();

                var failedTests = result.TestcasesResults.Where(x => x.Outcome == TestExecutionOutcome.Failed).Select(x => x.TestCase.Id).ToList();

                var coveredTests         = coverage.Links.Select(x => x.Item1).Distinct().ToList();
                var testsWithoutCoverage = impactedTests.Where(x => !coveredTests.Contains(x.Id)).Select(x => x.Id).ToList();

                testsWithoutCoverage.ForEach(x => loggingHelper.WriteMessage("Not covered: " + x));
                failedTests.ForEach(x => loggingHelper.WriteMessage("Failed Tests: " + x));

                testsWithoutCoverage.Except(failedTests).ForEach(x => loggingHelper.WriteMessage("Not covered and not failed Tests: " + x));

                correspondenceModelManager.UpdateCorrespondenceModel(coverage, programDelta, testsDelta, failedTests);

                applicationClosedHandler.RemovedApplicationClosedListener(instrumentor);
                return(result);
            }
        }
Ejemplo n.º 2
0
        private Dictionary <string, HashSet <string> > ConvertLinks(CorrespondenceLinks correspondenceLinks)
        {
            var links = correspondenceLinks.Links.Select(x => x.Item1).Distinct().ToDictionary(x => x, x => new HashSet <string>());

            foreach (var coverageEntry in correspondenceLinks.Links)
            {
                if (!links[coverageEntry.Item1].Contains(coverageEntry.Item2))
                {
                    links[coverageEntry.Item1].Add(coverageEntry.Item2);
                }
            }
            return(links);
        }
Ejemplo n.º 3
0
        public void UpdateCorrespondenceModel <TProgramDelta, TTestCase>(CorrespondenceLinks correspondenceLinks, TProgramDelta programDelta, StructuralDelta <TestsModel <TTestCase>, TTestCase> testsDelta, IEnumerable <string> failedTests)
            where TProgramDelta : IDelta <TModel>
            where TTestCase : ITestCase
        {
            var oldCorrespondenceModel = GetCorrespondenceModel(programDelta.OldModel, testsDelta.OldModel);
            var newCorrespondenceModel = CloneModel(oldCorrespondenceModel, programDelta.NewModel.VersionId);

            UpdateByNewLinks(newCorrespondenceModel, ConvertLinks(correspondenceLinks));
            RemoveDeletedTests(newCorrespondenceModel, testsDelta);
            RemoveFailedTests(newCorrespondenceModel, failedTests);

            PersistCorrespondenceModel(newCorrespondenceModel);
        }