private async Task <List <TestRunStepItem> > CompareOutputs(TestReadModel test, TestRunReadModel testRun)
{
var result = new List <TestRunStepItem>();
var testExePath = _paths.TestsData.Execs[test.Name].MainExePaths.Absolute;
var inputsPath = _paths.RunsData[ProcessingRun.Id][testRun.Id].Inputs;
_processingRunData.CurrentItemIndex = 0;
foreach (var inputFile in Directory.GetFiles(inputsPath.Absolute))
{
var started = DateTime.Now;
var inputName = Path.GetFileNameWithoutExtension(inputFile);
_processingRunData.CurrentItemName = inputName;
SendRunData();
var exeOutputPath = _paths.RunsData[ProcessingRun.Id][testRun.Id].Outputs[inputName].Absolute;
var cilantroOutputPath = _paths.RunsData[ProcessingRun.Id][testRun.Id].CilAntroOutputs[Path.GetFileNameWithoutExtension(inputFile)].Absolute;
var exeOutput = await File.ReadAllTextAsync(exeOutputPath);
var cilantroOutput = await File.ReadAllTextAsync(cilantroOutputPath);
var areOutputsIdentical = exeOutput.Equals(cilantroOutput);
var finished = DateTime.Now;
var item = new TestRunStepItem
{
Id = Guid.NewGuid(),
Name = Path.GetFileNameWithoutExtension(inputFile),
ProcessedForMilliseconds = (int)(finished - started).TotalMilliseconds,
Outcome = areOutputsIdentical ? RunOutcome.Ok : RunOutcome.Wrong
};
result.Add(item);
_processingRunData.CurrentItemIndex++;
}
return(result);
}
private async Task <List <TestRunStepItem> > GenerateCilAntroOutputFiles(TestReadModel test, TestRunReadModel testRun)
{
var result = new List <TestRunStepItem>();
var testExePath = _paths.TestsData.Execs[test.Name].MainExePaths.Absolute;
var inputsPath = _paths.RunsData[ProcessingRun.Id][testRun.Id].Inputs;
_processingRunData.CurrentItemIndex = 0;
foreach (var inputFile in Directory.GetFiles(inputsPath.Absolute))
{
string errorText = null;
var inputName = Path.GetFileNameWithoutExtension(inputFile);
var outputPath = _paths.RunsData[ProcessingRun.Id][testRun.Id].CilAntroOutputs[inputName].Absolute;
var errorPath = _paths.RunsData[ProcessingRun.Id][testRun.Id].CilAntroErrors[inputName].Absolute;
var started = DateTime.Now;
try
{
_processingRunData.CurrentItemName = inputName;
SendRunData();
var testIlSourcePath = _paths.TestsData.IlSources[test.Name].MainIlSourcePaths.Absolute;
var processStartInfo = new ProcessStartInfo(_paths.CilAntro, $"--fileName \"{testIlSourcePath}\"")
{
RedirectStandardOutput = true,
RedirectStandardInput = true,
RedirectStandardError = true,
WindowStyle = ProcessWindowStyle.Hidden,
CreateNoWindow = true
};
var outputBuilder = new StringBuilder();
var errorBuilder = new StringBuilder();
using (var cancelTokenSource = new CancellationTokenSource())
{
var token = cancelTokenSource.Token;
var newProcess = new Process
{
StartInfo = processStartInfo
};
var hasStarted = false;
var hasFinished = false;
var attempts = 0;
while (!hasStarted && attempts < 10)
{
hasStarted = newProcess.Start();
attempts++;
}
if (hasStarted)
{
var errorOutputTask = Task.Run(async() =>
{
var errorOutput = newProcess.StandardError;
while (true)
{
if (errorOutput.EndOfStream && !hasFinished)
{
await Task.Delay(100);
continue;
}
else if (errorOutput.EndOfStream)
{
break;
}
var errorLine = await newProcess.StandardError.ReadLineAsync();
errorBuilder.AppendLine(errorLine);
}
}, token);
var exeOutputTask = Task.Run(async() =>
{
var exeOutput = newProcess.StandardOutput;
while (true)
{
if (exeOutput.EndOfStream && !hasFinished)
{
await Task.Delay(100);
continue;
}
else if (exeOutput.EndOfStream)
{
break;
}
var outputLine = await exeOutput.ReadLineAsync();
outputBuilder.AppendLine(outputLine);
}
}, token);
var inputTask = Task.Run(async() =>
{
using (var streamReader = new StreamReader(inputFile))
{
await newProcess.StandardInput.WriteAsync(await streamReader.ReadToEndAsync());
await newProcess.StandardInput.FlushAsync();
}
}, token);
newProcess.WaitForExit();
//if (!newProcess.HasExited)
//{
// newProcess.Kill();
//}
hasFinished = true;
Task.WaitAll(errorOutputTask, exeOutputTask);
//cancelTokenSource.Cancel();
errorText = errorBuilder.ToString();
if (inputTask.IsFaulted)
{
errorText = $"INPUT TASK ERROR\n\n{inputTask.Exception.Message}";
}
else if (exeOutputTask.IsFaulted)
{
errorText = $"EXE OUTPUT TASK ERROR\n\n{exeOutputTask.Exception.Message}";
}
else if (errorOutputTask.IsFaulted)
{
errorText = $"ERROR OUTPUT TASK ERROR\n\n{errorOutputTask.Exception.Message}";
}
}
else
{
errorText = "AFTER 10 ATTEMPTS THE PROCESS HAS NOT BEEN STARTED";
}
}
await File.WriteAllTextAsync(outputPath, outputBuilder.ToString());
}
catch (Exception ex)
{
errorText = $"OTHER EXCEPTION\n\n{ex.Message}";
}
var hasErrors = !string.IsNullOrEmpty(errorText);
await File.WriteAllTextAsync(errorPath, errorText);
var finished = DateTime.Now;
var item = new TestRunStepItem
{
Id = Guid.NewGuid(),
Name = Path.GetFileNameWithoutExtension(inputFile),
ProcessedForMilliseconds = (int)(finished - started).TotalMilliseconds,
Outcome = !hasErrors ? RunOutcome.Ok : RunOutcome.Wrong
};
result.Add(item);
_processingRunData.CurrentItemIndex++;
}
return(result);
}
private async Task <List <TestRunStepItem> > GenerateInputFiles(TestReadModel test, TestRunReadModel testRun)
{
var result = new List <TestRunStepItem>();
_processingRunData.AllItemsCount = ProcessingRun.Type == RunType.Quick ? test.IoExamples.Count + 3 : test.IoExamples.Count + 100;
_processingRunData.CurrentItemIndex = 0;
foreach (var ioExample in test.IoExamples)
{
var started = DateTime.Now;
var inputName = ioExample.Name.Replace(' ', '_');
_processingRunData.CurrentItemName = inputName;
SendRunData();
var inputPath = _paths.RunsData[ProcessingRun.Id][testRun.Id].Inputs[inputName].Absolute;
await File.WriteAllTextAsync(inputPath, ioExample.Input);
var finished = DateTime.Now;
var item = new TestRunStepItem
{
Id = Guid.NewGuid(),
Name = Path.GetFileNameWithoutExtension(inputPath),
ProcessedForMilliseconds = (int)(finished - started).TotalMilliseconds,
Outcome = RunOutcome.Ok
};
result.Add(item);
_processingRunData.CurrentItemIndex++;
}
var randomInputsToGenerate = ProcessingRun.Type == RunType.Full ? 100 : 3;
{
var inputFactory = new InputFactory(test.Input);
for (int i = 1; i <= randomInputsToGenerate; i++)
{
var started = DateTime.Now;
var inputName = $"Random_{i.ToString("D3")}";
_processingRunData.CurrentItemName = inputName;
SendRunData();
var inputPath = _paths.RunsData[ProcessingRun.Id][testRun.Id].Inputs[inputName].Absolute;
var input = inputFactory.GenerateRandomInput();
if (input != null)
{
await File.WriteAllTextAsync(inputPath, input);
}
var finished = DateTime.Now;
var item = new TestRunStepItem
{
Id = Guid.NewGuid(),
Name = Path.GetFileNameWithoutExtension(inputPath),
ProcessedForMilliseconds = (int)(finished - started).TotalMilliseconds,
Outcome = input != null ? RunOutcome.Ok : RunOutcome.Wrong
};
result.Add(item);
_processingRunData.CurrentItemIndex++;
}
}
return(result);
}
