public async Task <bool> ExecuteTests()
{
try
{
var log = _outputLogger.GetLogFromOutput(TestsExecutionOutput, string.Empty);
var document = MutationDocumentManagerService.CreateDocument(nameof(CommandPromptOutputViewer), log);
var test = new TestExecutor(Settings, _source.TestClaz.ClassLibrary);
document.Title = TestsExecutionOutput;
if (!_silently)
{
document.Show();
}
void OutputData(object sender, string args) => log.CommandPromptOutput += args.Encode().PrintWithPreTag();
test.EnableCustomOptions = ChkEnableCodeCoverage.IsChecked;
test.EnableLogging = false;
test.OutputDataReceived += OutputData;
test.X64TargetPlatform = _source.X64TargetPlatform;
test.FullyQualifiedName = _source.TestClaz.MethodDetails.Count > Convert.ToInt32(Settings.UseClassFilterTestsThreshold) ||
ChkUseClassFilter.IsChecked || _source.TestClaz.BaseClass != null
? _source.TestClaz.Claz.Syntax.FullName()
: string.Empty;
if (_silently)
{
test.FullyQualifiedName = _source.TestClaz.Claz.Syntax.FullName();
}
await test.ExecuteTests(_source.TestClaz.MethodDetails);
var coverageAnalyzer = new CoverageAnalyzer();
coverageAnalyzer.FindCoverage(_source, test.CodeCoverage);
if (test.LastTestExecutionStatus == TestExecutionStatus.Success)
{
if (!_silently)
{
document.Close();
}
return(true);
}
}
catch (Exception exp)
{
Trace.TraceError("Tests Execution Failed [{0}]", exp);
MessageBoxService.Show(exp.Message);
}
return(false);
}
public void PrintReport()
{
if (_mutationProcessLog == null || string.IsNullOrWhiteSpace(_mutationProcessLog.ToString()))
{
MessageBoxService.Show("No any Report Exist");
return;
}
_printDocument = MutationDocumentManagerService.CreateDocument(
nameof(CommandPromptOutputViewer),
_outputLogger.GetLogFromOutput($"{_source.Claz.Syntax.ClassName()}_Dynamic_Mutation_Analysis", _mutationProcessLog.ToString()));
_printDocument.Show();
}
private async Task <bool> ExecuteBuild()
{
try
{
var buildLog = _outputLogger.GetLogFromOutput(MSBuildOutput, string.Empty);
var document = MutationDocumentManagerService.CreateDocument(nameof(CommandPromptOutputViewer), buildLog);
document.Title = MSBuildOutput;
document.Show();
buildLog.CommandPromptOutput += "Building Test Project...".PrintWithPreTag();
void OutputData(object sender, string args) => buildLog.CommandPromptOutput += args.Encode().PrintWithPreTag();
var testCodeBuild = new BuildExecutor(Settings, _source.TestClaz.ClassProject)
{
BaseAddress = Settings.ServiceAddress,
EnableLogging = ChkEnableDiagnostic.IsChecked,
QuietWithSymbols = true
};
testCodeBuild.OutputDataReceived += OutputData;
if (_source.BuildInReleaseMode)
{
await testCodeBuild.ExecuteBuildInReleaseModeWithoutDependencies();
}
else
{
await testCodeBuild.ExecuteBuildInDebugModeWithoutDependencies();
}
testCodeBuild.OutputDataReceived -= OutputData;
if (testCodeBuild.LastBuildStatus != BuildExecutionStatus.Failed)
{
document.Close();
}
else
{
MessageBoxService.Show("\nTest Project Build is failed!");
}
return(testCodeBuild.LastBuildStatus == BuildExecutionStatus.Success);
}
catch (Exception e)
{
MessageBoxService.Show(e.Message);
Trace.TraceError("Unknown Exception Occurred On Test Project Build {0}", e);
return(false);
}
}
public async Task BtnApplyMutantsClick()
{
_numberOfMutantsExecutingInParallel = Convert.ToByte(NumberOfMutantsExecutedInParallel);
if (SelectedMutants.All(x => x.Level != MutantLevel.Mutant))
{
if (!_silently)
{
MessageBoxService.Show("Click Find Mutants Or Select At Least One Mutant");
}
return;
}
try
{
await InitializeMutants((ObservableCollection <object>) _selectedMutators);
IsSplashScreenShown = true;
if (ChkEnableDiagnostic.IsChecked)
{
_testDiagnosticDocument = MutationDocumentManagerService.CreateDocument(
nameof(CommandPromptOutputViewer), _testDiagnosticDocumentViewModel);
_buildDiagnosticDocument = MutationDocumentManagerService.CreateDocument(
nameof(CommandPromptOutputViewer), _buildDiagnosticDocumentViewModel);
_testDiagnosticDocument.Show();
_buildDiagnosticDocument.Show();
}
MutantOperationsEnabled = false;
ProgressBarMutationVisible = Visibility.Visible;
MinimumProgress = 0;
CurrentProgress = 0;
var stopWatch = new Stopwatch();
stopWatch.Start();
_mutationProcessLog = new StringBuilder();
if (!_source.MethodDetails.SelectMany(x => x.Mutants).Any())
{
if (!_silently)
{
MessageBoxService.Show(MutantsNotExist);
}
return;
}
var selectedMutants = SelectedMutants.Where(x => x.Level == MutantLevel.Mutant).ToList();
foreach (var mutant in _source.MethodDetails.SelectMany(x => x.Mutants))
{
if (selectedMutants.All(x => x.MutantId != mutant.Id && mutant.ResultStatus == MutantStatus.NotRun))
{
mutant.ResultStatus = MutantStatus.Skipped;
}
}
_directoryFactory.BuildExtensions = BuildExtensions;
_directoryFactory.NumberOfMutantsExecutingInParallel = _numberOfMutantsExecutingInParallel;
_directoryFactory.DeleteDirectories();
await _directoryFactory.PrepareDirectoriesAndFiles();
var methodDetails = _source.MethodDetails.Where(x => x.TestMethods.Any()).ToList();
MaximumProgress = methodDetails.SelectMany(x => x.NotRunMutants).Count();
if (!methodDetails.Any())
{
if (!_silently)
{
MessageBoxService.Show(NoAnyTestsExist);
}
return;
}
IsSplashScreenShown = false;
_mutantExecutor = new MutantExecutor(_source, Settings)
{
EnableDiagnostics = ChkEnableDiagnostic.IsChecked,
NumberOfMutantsExecutingInParallel = _numberOfMutantsExecutingInParallel,
UseClassFilter = ChkUseClassFilter.IsChecked ||
_source.TestClaz.MethodDetails.Count > Convert.ToInt32(Settings.UseClassFilterTestsThreshold) ||
_source.TestClaz.BaseClass != null,
BaseAddress = Settings.ServiceAddress
};
if (_silently)
{
_mutantExecutor.UseClassFilter = true;
}
_testDiagnosticDocumentViewModel.CommandPromptOutput = HtmlTemplate;
_buildDiagnosticDocumentViewModel.CommandPromptOutput = HtmlTemplate;
void MutantExecutorOnMutantExecuted(object sender, MutantEventArgs e)
{
if (ChkEnableDiagnostic.IsChecked)
{
_testDiagnosticDocumentViewModel.CommandPromptOutput += e.TestLog;
_buildDiagnosticDocumentViewModel.CommandPromptOutput += e.BuildLog;
}
CurrentProgress++;
}
_mutantExecutor.MutantExecuted += MutantExecutorOnMutantExecuted;
await _mutantExecutor.ExecuteMutants();
_mutationProcessLog.Append(_mutantExecutor.LastExecutionOutput);
_mutantExecutor.MutantExecuted -= MutantExecutorOnMutantExecuted;
if (!_silently &&
ChkAnalyzeExternalCoverage.IsChecked &&
_source.ExternalCoveredClassesIncluded.Any())
{
const string title = "Analyzing External Coverage";
var externalCoverageLog = _outputLogger.GetLogFromOutput(title, string.Empty);
externalCoverageLog.CommandPromptOutput = HtmlTemplate;
var chalkHtml = new ChalkHtml();
void OutputDataReceived(object sender, string output) => externalCoverageLog.CommandPromptOutput += output;
chalkHtml.OutputDataReceived += OutputDataReceived;
var mutantAnalyzer = new MutantAnalyzer(chalkHtml, Settings)
{
BuildInReleaseMode = _source.BuildInReleaseMode,
ConcurrentTestRunners = _numberOfMutantsExecutingInParallel,
EnableDiagnostics = ChkEnableDiagnostic.IsChecked,
ExecuteAllTests = ChkExecuteAllTests.IsChecked,
IncludeNestedClasses = _source.IncludeNestedClasses,
IncludePartialClasses = _source.TestClaz.PartialClassNodesAdded,
SourceProjectLibrary = _source.ClassLibrary,
SurvivedThreshold = 0.01,
TestClass = _source.TestClaz.FilePath,
TestProject = _source.TestClaz.ClassProject,
TestProjectLibrary = _source.TestClaz.ClassLibrary,
UseClassFilter = ChkUseClassFilter.IsChecked,
X64TargetPlatform = _source.X64TargetPlatform,
UseExternalCodeCoverage = true,
ProgressIndicator = '*',
MutantsPerLine = Convert.ToInt32(MutantsPerLine)
};
var document = MutationDocumentManagerService.CreateDocument(nameof(CommandPromptOutputViewer), externalCoverageLog);
document.Title = title;
document.Show();
foreach (var acc in _source.ExternalCoveredClassesIncluded)
{
mutantAnalyzer.ExternalCoveredMutants.AddRange(acc.MutantsLines);
var projectFile = new FileInfo(acc.ClassPath).FindProjectFile();
mutantAnalyzer.SourceProjectLibrary = projectFile.FindLibraryPath()?.FullName;
if (!string.IsNullOrWhiteSpace(mutantAnalyzer.SourceProjectLibrary))
{
var accClass = await mutantAnalyzer.Analyze(
acc.ClassPath,
acc.ClassName,
projectFile.FullName);
accClass.CalculateMutationScore();
if (accClass.MutationScore.Survived == 0)
{
acc.ZeroSurvivedMutants = true;
}
}
}
chalkHtml.OutputDataReceived -= OutputDataReceived;
mutantAnalyzer.ExternalCoveredMutants.Clear();
}
stopWatch.Stop();
_mutantExecutor.PrintMutatorSummary(_mutationProcessLog);
_mutantExecutor.PrintClassSummary(_mutationProcessLog);
_mutationProcessLog.AppendLine("<fieldset style=\"margin-bottom:10; margin-top:10;\">");
_mutationProcessLog.AppendLine("Execution Time: ".PrintImportantWithLegend());
_mutationProcessLog.Append($"{stopWatch.Elapsed}".PrintWithPreTagWithMarginImportant());
_mutationProcessLog.AppendLine("</fieldset>");
_previousMutants.Clear();
foreach (var mutant in _source.MethodDetails.SelectMany(x => x.Mutants))
{
var key = $"{mutant.Mutation.Location} - {mutant.Mutation.DisplayName}";
if (!_previousMutants.ContainsKey(key))
{
_previousMutants.Add(key, mutant.ResultStatus);
}
}
PrintMutants();
RunFileWatcherService();
}
catch (Exception exception)
{
Trace.TraceError("Unknown Exception Occurred by Mutation Analyzer {0}", exception.StackTrace);
MessageBoxService.Show(exception.Message);
}
finally
{
MutantOperationsEnabled = true;
IsSplashScreenShown = false;
ProgressBarMutationVisible = Visibility.Hidden;
_directoryFactory.DeleteDirectories();
_idle = true;
_silently = false;
var notification = NotificationService.CreatePredefinedNotification(MutationIsCompletedNotification, string.Empty, string.Empty);
await notification.ShowAsync();
}
}