private void OpenCompleteDocumentTab(MutationDocumentResult obj)
{
if (obj != null)
{
_mutationModuleTabOpener.OpenDocumentResultTab(obj);
}
}
public void AddResult(MutationDocumentResult result)
{
if (!string.IsNullOrEmpty(result.UnexpectedError))
{
// Unexpected error so will just ignore it in all statistics
return;
}
System.Windows.Application.Current.Dispatcher.BeginInvoke(new Action(() => CompletedMutationDocuments.Add(result)));
FinishedMutationsCount++;
if (!result.CompilationResult.IsSuccess)
{
FailedToCompileMutationsCount++;
return;
}
if (result.Survived)
{
MutationsSurvivedCount.Value++;
System.Windows.Application.Current.Dispatcher.BeginInvoke(new Action(() => SurvivedMutationDocuments.Add(result)));
}
else
{
MutationsKilledCount.Value++;
}
MutationScore = $"{Math.Round((MutationsKilledCount.Value / (MutationsKilledCount.Value + MutationsSurvivedCount.Value)) * 100)}%";
}
public void MutationDocumentCompleted(MutationDocumentResult result)
{
_environmentService.JoinableTaskFactory.RunAsync(async() =>
{
await _environmentService.JoinableTaskFactory.SwitchToMainThreadAsync();
var runDocument = _mutations.FirstOrDefault(r => r.Document.Id == result.Id);
if (runDocument != null)
{
runDocument.Result = result;
if (result.CompilationResult != null && !result.CompilationResult.IsSuccess)
{
runDocument.Status = MutationRunItem.TestRunStatusEnum.CompletedWithUnknownReason;
runDocument.InfoText = "Failed to compile.";
return;
}
if (result.UnexpectedError != null)
{
runDocument.Status = MutationRunItem.TestRunStatusEnum.CompletedWithUnknownReason;
runDocument.InfoText = result.UnexpectedError;
return;
}
runDocument.Status = result.Survived
? MutationRunItem.TestRunStatusEnum.CompleteAndSurvived
: MutationRunItem.TestRunStatusEnum.CompleteAndKilled;
runDocument.InfoText = $"{result.FailedTests.Count} of {result.TestsRunCount} tests failed";
runDocument.InfoText += result.Survived ? " (mutation survived)" : " (mutation killed)";
}
});
}
public MutationDocumentResultView(MutationDocumentResult result)
{
InitializeComponent();
var dataContext = DataContext as MutationDocumentResultViewModel;
dataContext.SetMutationDocumentTestResult(result);
}
private void MutationDocumentCompleted(MutationDocumentResult result)
{
lock (RunningDocuments)
{
var runDocument = RunningDocuments.FirstOrDefault(r => r.Document.Id == result.Id);
if (runDocument != null)
{
System.Windows.Application.Current.Dispatcher.BeginInvoke(new Action(() => RunningDocuments.Remove(runDocument)));
}
MutationDocumentsExecutionResults.AddResult(result);
}
}
public void SetMutationDocumentTestResult(MutationDocumentResult result)
{
Result = result;
Title = $"Test results for {result.FileName} - {result.Location}";
ShowFullCode(false);
}
public async Task <MutationDocumentResult> ExecuteMutationAsync(UnimaConfig config, MutationDocument mutationDocument)
{
var mutationResult = new MutationDocumentResult
{
Id = mutationDocument.Id,
MutationName = mutationDocument.MutationName,
ProjectName = mutationDocument.ProjectName,
FileName = mutationDocument.FileName,
Location = mutationDocument.MutationDetails.Location,
Orginal = mutationDocument.MutationDetails.Orginal.ToFullString(),
FullOrginal = mutationDocument.MutationDetails.FullOrginal.ToFullString(),
Mutation = mutationDocument.MutationDetails.Mutation.ToFullString(),
FullMutation = mutationDocument.MutationDetails.FullMutation.ToFullString()
};
mutationResult.GenerateHash();
LogTo.Info($"Running mutation: \"{mutationDocument.MutationName}\"");
var results = new List <TestSuiteResult>();
// Create the temporary "head" mutation directory to run all tests
var mutationDirectoryPath = Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location), "TestRun", mutationDocument.Id.ToString());
// Where we should save our compiled mutation
var mutationDllPath = Path.Combine(mutationDirectoryPath, $"{config.MutationProjects.FirstOrDefault(m => m.Name == mutationDocument.ProjectName).OutputFileName}");
Directory.CreateDirectory(mutationDirectoryPath);
mutationResult.CompilationResult = await _compiler.CompileAsync(mutationDllPath, mutationDocument);
if (!mutationResult.CompilationResult.IsSuccess)
{
return(mutationResult);
}
foreach (var testProject in config.TestProjects)
{
var baseline = config.BaselineInfos.FirstOrDefault(b => b.TestProjectName.Equals(testProject.Project.Name, StringComparison.OrdinalIgnoreCase));
var result = await RunTestAsync(testProject, mutationDirectoryPath, mutationDllPath, config.DotNetPath, baseline?.GetTestProjectTimeout() ?? TimeSpan.FromMinutes(config.MaxTestTimeMin));
results.Add(result);
if (results.Any(r => !r.IsSuccess))
{
break;
}
}
try
{
Directory.Delete(mutationDirectoryPath, true);
}
catch (Exception ex)
{
LogTo.Error($"Failed to delete test directory: {ex.Message}");
}
var final = CombineResult(mutationDocument.FileName, results);
LogTo.Info($"\"{mutationDocument.MutationName}\" done. Ran {final.TestResults.Count} tests and {final.TestResults.Count(t => !t.IsSuccess)} failed.");
mutationResult.FailedTests = final.TestResults.Where(t => !t.IsSuccess).ToList();
mutationResult.TestsRunCount = final.TestResults.Count;
return(mutationResult);
}
public async Task <MutationRunResult> Handle(ExecuteMutationsCommand command, CancellationToken cancellationToken)
{
var semaphoreSlim = new SemaphoreSlim(command.Config.NumberOfTestRunInstances, command.Config.NumberOfTestRunInstances);
var results = new List <MutationDocumentResult>();
var mutationDocuments = new Queue <MutationDocument>(command.MutationDocuments);
var currentRunningDocuments = new List <Task>();
var start = DateTime.Now;
var numberOfMutationsLeft = command.MutationDocuments.Count;
_mutationRunLoggerManager.Initialize(command.Config.MutationRunLoggers);
Log.Info($"Total number of mutations generated: {numberOfMutationsLeft}");
_mutationRunLoggerManager.LogBeforeRun(command.MutationDocuments);
await Task.Run(() =>
{
while (mutationDocuments.Any())
{
if (cancellationToken.IsCancellationRequested)
{
Log.Info("Cancellation requested (mutation run)");
return;
}
semaphoreSlim.Wait();
var document = mutationDocuments.Dequeue();
currentRunningDocuments.Add(Task.Run(async() =>
{
MutationDocumentResult result = null;
try
{
_mutationRunLoggerManager.LogBeforeMutation(document);
command.MutationDocumentStartedCallback?.Invoke(document);
var resultTask = _mutationDocumentExecutor.ExecuteMutationAsync(command.Config, document, cancellationToken);
result = await resultTask;
}
catch (Exception ex)
{
Log.Warn($"Unexpected exception when running {document.MutationName}", ex);
Log.Info("Will put it in the unknown category.");
result = new MutationDocumentResult
{
Id = document.Id,
UnexpectedError = ex.Message,
};
}
finally
{
lock (results)
{
results.Add(result);
Interlocked.Decrement(ref numberOfMutationsLeft);
_mutationRunLoggerManager.LogAfterMutation(document, results, numberOfMutationsLeft);
}
semaphoreSlim.Release();
command.MutationDocumentCompledtedCallback?.Invoke(result);
}
}));
}
});
// Wait for the final ones
await Task.WhenAll(currentRunningDocuments);
var mutationRunResult = new MutationRunResult(results, cancellationToken.IsCancellationRequested, DateTime.Now - start);
if (cancellationToken.IsCancellationRequested)
{
Log.Info("Mutation run was cancelled");
}
else
{
Log.Info($"Your mutation score: {mutationRunResult.GetMutationScore()}%");
}
return(mutationRunResult);
}
public async Task <MutationDocumentResult> ExecuteMutationAsync(
MutationConfig config,
MutationDocument mutationDocument,
CancellationToken cancellationToken = default(CancellationToken))
{
var mutationResult = new MutationDocumentResult
{
Id = mutationDocument.Id,
MutationName = mutationDocument.MutationName,
ProjectName = mutationDocument.ProjectName,
FileName = mutationDocument.FileName,
Location = mutationDocument.MutationDetails.Location,
Orginal = mutationDocument.MutationDetails.Original.ToFullString(),
FullOrginal = mutationDocument.MutationDetails.FullOriginal.ToFullString(),
Mutation = mutationDocument.MutationDetails.Mutation.ToFullString(),
FullMutation = mutationDocument.MutationDetails.FullMutation.ToFullString(),
Category = mutationDocument.MutationDetails.Category
};
mutationResult.GenerateHash();
Log.Info($"Running mutation: \"{mutationDocument.MutationName}\"");
var results = new List <TestSuiteResult>();
// Create the temporary "head" mutation directory to run all tests
var mutationDirectoryPath = Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location), "TestRun", mutationDocument.Id.ToString());
// Where we should save our compiled mutation
var mutationDllPath = Path.Combine(mutationDirectoryPath, $"{config.MutationProjects.FirstOrDefault(m => m.Project.Name == mutationDocument.ProjectName).Project.OutputFileName}");
_fileSystem.Directory.DeleteDirectoryAndCheckForException(mutationDirectoryPath);
try
{
cancellationToken.ThrowIfCancellationRequested();
_fileSystem.Directory.CreateDirectory(mutationDirectoryPath);
mutationResult.CompilationResult = await _compiler.CompileAsync(mutationDllPath, mutationDocument);
if (!mutationResult.CompilationResult.IsSuccess)
{
return(mutationResult);
}
foreach (var testProject in config.TestProjects)
{
cancellationToken.ThrowIfCancellationRequested();
if (ShouldIgnoreTestProject(mutationDocument, config.MutationProjects, testProject))
{
continue;
}
var baseline = config.BaselineInfos.FirstOrDefault(b => b.TestProjectName.Equals(testProject.Project.Name, StringComparison.OrdinalIgnoreCase));
var result = await RunTestAsync(
testProject,
mutationDirectoryPath,
mutationDllPath,
config.DotNetPath,
baseline?.GetTestProjectTimeout() ?? TimeSpan.FromMinutes(config.MaxTestTimeMin),
cancellationToken);
results.Add(result);
if (results.Any(r => !r.IsSuccess))
{
break;
}
}
var final = CombineResult(mutationDocument.FileName, results);
if (final.TestResults.Count == 0)
{
throw new MutationDocumentException($"Unknown error when running, we should not have 0 tests. Also make sure that you don't have bad project mapping. Error: \"{final.Name}\"");
}
Log.Info($"\"{mutationDocument.MutationName}\" done. Ran {final.TestResults.Count} tests and {final.TestResults.Count(t => !t.IsSuccess)} failed.");
mutationResult.FailedTests = final.TestResults.Where(t => !t.IsSuccess).ToList();
mutationResult.TestsRunCount = final.TestResults.Count;
}
catch (OperationCanceledException)
{
Log.Info("Cancellation requested (single mutation)");
mutationResult.UnexpectedError = "Mutation cancelled";
}
catch (Exception)
{
throw;
}
finally
{
_fileSystem.Directory.DeleteDirectoryAndCheckForException(mutationDirectoryPath);
}
return(mutationResult);
}
public void OpenDocumentResultTab(MutationDocumentResult result)
{
_mainTabContainer.AddTab(new MutationDocumentResultView(result));
}
