protected ExecutionResult CompileExecuteAndCheck(ExecutionContext executionContext, Func<CompilerType, string> getCompilerPathFunc, IExecutor executor)
{
var result = new ExecutionResult();
// Compile the file
var compilerPath = getCompilerPathFunc(executionContext.CompilerType);
var compilerResult = this.Compile(executionContext.CompilerType, compilerPath, executionContext.AdditionalCompilerArguments, executionContext.Code);
result.IsCompiledSuccessfully = compilerResult.IsCompiledSuccessfully;
result.CompilerComment = compilerResult.CompilerComment;
if (!compilerResult.IsCompiledSuccessfully)
{
return result;
}
var outputFile = compilerResult.OutputFile;
// Execute and check each test
IChecker checker = Checker.CreateChecker(executionContext.CheckerAssemblyName, executionContext.CheckerTypeName, executionContext.CheckerParameter);
foreach (var test in executionContext.Tests)
{
var processExecutionResult = executor.Execute(outputFile, test.Input, executionContext.TimeLimit, executionContext.MemoryLimit);
var testResult = this.ExecuteAndCheckTest(test, processExecutionResult, checker, processExecutionResult.ReceivedOutput);
result.TestResults.Add(testResult);
}
// Clean our mess
File.Delete(outputFile);
return result;
}
public override ExecutionResult Execute(ExecutionContext executionContext)
{
var result = new ExecutionResult();
// PHP code is not compiled
result.IsCompiledSuccessfully = true;
var codeSavePath = FileHelpers.SaveStringToTempFile(executionContext.Code);
// Process the submission and check each test
var executor = new RestrictedProcessExecutor();
var checker = Checker.CreateChecker(executionContext.CheckerAssemblyName, executionContext.CheckerTypeName, executionContext.CheckerParameter);
result.TestResults = new List<TestResult>();
foreach (var test in executionContext.Tests)
{
var processExecutionResult = executor.Execute(
this.phpCliExecutablePath,
test.Input,
executionContext.TimeLimit,
executionContext.MemoryLimit,
new[] { codeSavePath });
var testResult = this.ExecuteAndCheckTest(test, processExecutionResult, checker, processExecutionResult.ReceivedOutput);
result.TestResults.Add(testResult);
}
// Clean up
File.Delete(codeSavePath);
return result;
}
public override ExecutionResult Execute(ExecutionContext executionContext)
{
var result = new ExecutionResult();
// Create a temp file with the submission code
string submissionFilePath;
try
{
submissionFilePath = this.CreateSubmissionFile(executionContext.Code);
}
catch (ArgumentException exception)
{
result.IsCompiledSuccessfully = false;
result.CompilerComment = exception.Message;
return result;
}
// Create a sandbox executor source file in the working directory
var sandboxExecutorSourceFilePath = $"{this.workingDirectory}\\{SandboxExecutorClassName}";
File.WriteAllText(sandboxExecutorSourceFilePath, this.SandboxExecutorCode);
// Compile all source files - sandbox executor and submission file
var compilerPath = this.getCompilerPathFunc(executionContext.CompilerType);
var compilerResult = this.CompileSourceFiles(
executionContext.CompilerType,
compilerPath,
executionContext.AdditionalCompilerArguments,
new[] { submissionFilePath, sandboxExecutorSourceFilePath });
// Assign compiled result info to the execution result
result.IsCompiledSuccessfully = compilerResult.IsCompiledSuccessfully;
result.CompilerComment = compilerResult.CompilerComment;
if (!result.IsCompiledSuccessfully)
{
return result;
}
// Prepare execution process arguments and time measurement info
var classPathArgument = $"-classpath \"{this.workingDirectory}\"";
var submissionFilePathLastIndexOfSlash = submissionFilePath.LastIndexOf('\\');
var classToExecute = submissionFilePath.Substring(submissionFilePathLastIndexOfSlash + 1);
var timeMeasurementFilePath = $"{this.workingDirectory}\\{TimeMeasurementFileName}";
// Create an executor and a checker
var executor = new StandardProcessExecutor();
var checker = Checker.CreateChecker(executionContext.CheckerAssemblyName, executionContext.CheckerTypeName, executionContext.CheckerParameter);
// Process the submission and check each test
foreach (var test in executionContext.Tests)
{
var processExecutionResult = executor.Execute(
this.javaExecutablePath,
test.Input,
executionContext.TimeLimit,
executionContext.MemoryLimit,
new[] { classPathArgument, SandboxExecutorClassName, classToExecute, $"\"{timeMeasurementFilePath}\"" });
UpdateExecutionTime(timeMeasurementFilePath, processExecutionResult, executionContext.TimeLimit);
var testResult = this.ExecuteAndCheckTest(test, processExecutionResult, checker, processExecutionResult.ReceivedOutput);
result.TestResults.Add(testResult);
}
return result;
}
public override ExecutionResult Execute(ExecutionContext executionContext)
{
var result = new ExecutionResult();
// setting the IsCompiledSuccessfully variable to true as in the NodeJS
// execution strategy there is no compilation
result.IsCompiledSuccessfully = true;
// Preprocess the user submission
var codeToExecute = this.PreprocessJsSubmission(this.JsCodeTemplate, executionContext.Code);
// Save the preprocessed submission which is ready for execution
var codeSavePath = this.SaveStringToTempFile(codeToExecute);
// Process the submission and check each test
IExecutor executor = new RestrictedProcessExecutor();
IChecker checker = Checker.CreateChecker(executionContext.CheckerAssemblyName, executionContext.CheckerTypeName, executionContext.CheckerParameter);
result.TestResults = new List<TestResult>();
foreach (var test in executionContext.Tests)
{
var processExecutionResult = executor.Execute(this.nodeJsExecutablePath, test.Input, executionContext.TimeLimit, executionContext.MemoryLimit, new[] { codeSavePath });
var testResult = this.ExecuteAndCheckTest(test, processExecutionResult, checker, processExecutionResult.ReceivedOutput);
result.TestResults.Add(testResult);
}
// Clean up
File.Delete(codeSavePath);
return result;
}
public override ExecutionResult Execute(ExecutionContext executionContext)
{
var result = new ExecutionResult();
// Copy the sandbox executor source code to a file in the working directory
File.WriteAllText(this.SandboxExecutorSourceFilePath, this.SandboxExecutorCode);
// Create a temp file with the submission code
string submissionFilePath;
try
{
submissionFilePath = this.CreateSubmissionFile(executionContext);
}
catch (ArgumentException exception)
{
result.IsCompiledSuccessfully = false;
result.CompilerComment = exception.Message;
return result;
}
var compilerResult = this.DoCompile(executionContext, submissionFilePath);
// Assign compiled result info to the execution result
result.IsCompiledSuccessfully = compilerResult.IsCompiledSuccessfully;
result.CompilerComment = compilerResult.CompilerComment;
if (!result.IsCompiledSuccessfully)
{
return result;
}
// Prepare execution process arguments and time measurement info
var classPathArgument = $"-classpath \"{this.WorkingDirectory}\"";
var classToExecuteFilePath = compilerResult.OutputFile;
var classToExecute = classToExecuteFilePath
.Substring(
this.WorkingDirectory.Length + 1,
classToExecuteFilePath.Length - this.WorkingDirectory.Length - JavaCompiledFileExtension.Length - 1)
.Replace('\\', '.');
var timeMeasurementFilePath = $"{this.WorkingDirectory}\\{TimeMeasurementFileName}";
// Create an executor and a checker
var executor = new StandardProcessExecutor();
var checker = Checker.CreateChecker(executionContext.CheckerAssemblyName, executionContext.CheckerTypeName, executionContext.CheckerParameter);
// Process the submission and check each test
foreach (var test in executionContext.Tests)
{
var processExecutionResult = executor.Execute(
this.javaExecutablePath,
test.Input,
executionContext.TimeLimit * 2, // Java virtual machine takes more time to start up
executionContext.MemoryLimit,
new[] { classPathArgument, SandboxExecutorClassName, classToExecute, $"\"{timeMeasurementFilePath}\"" });
UpdateExecutionTime(timeMeasurementFilePath, processExecutionResult, executionContext.TimeLimit);
var testResult = this.ExecuteAndCheckTest(test, processExecutionResult, checker, processExecutionResult.ReceivedOutput);
result.TestResults.Add(testResult);
}
return result;
}
public override ExecutionResult Execute(ExecutionContext executionContext)
{
var result = new ExecutionResult();
// setting the IsCompiledSuccessfully variable to true as in the NodeJS
// execution strategy there is no compilation
result.IsCompiledSuccessfully = true;
// Preprocess the user submission
var codeToExecute = this.PreprocessJsSubmission(this.JsCodeTemplate, executionContext.Code);
// Save the preprocessed submission which is ready for execution
var codeSavePath = FileHelpers.SaveStringToTempFile(codeToExecute);
// Process the submission and check each test
IExecutor executor = new RestrictedProcessExecutor();
IChecker checker = Checker.CreateChecker(executionContext.CheckerAssemblyName, executionContext.CheckerTypeName, executionContext.CheckerParameter);
result.TestResults = this.ProcessTests(executionContext, executor, checker, codeSavePath);
// Clean up
File.Delete(codeSavePath);
return result;
}
private void ProcessTests(ProcessExecutionResult processExecutionResult, ExecutionContext executionContext, ExecutionResult result)
{
var jsonResult = JsonExecutionResult.Parse(processExecutionResult.ReceivedOutput, true, true);
var index = 0;
result.TestResults = new List<TestResult>();
foreach (var test in executionContext.Tests)
{
var testResult = new TestResult
{
Id = test.Id,
TimeUsed = (int)processExecutionResult.TimeWorked.TotalMilliseconds,
MemoryUsed = (int)processExecutionResult.MemoryUsed,
};
if (jsonResult.PassingIndexes.Contains(index))
{
testResult.ResultType = TestRunResultType.CorrectAnswer;
}
else
{
testResult.ResultType = TestRunResultType.WrongAnswer;
testResult.CheckerDetails = new CheckerDetails { Comment = "Test failed." };
}
result.TestResults.Add(testResult);
index++;
}
}
public override ExecutionResult Execute(ExecutionContext executionContext)
{
var solution = executionContext.FileContent;
var result = new ExecutionResult();
var compileResult = this.ExecuteCompiling(executionContext, this.getCompilerPathFunc, result);
if (!compileResult.IsCompiledSuccessfully)
{
return result;
}
var outputAssemblyPath = this.PreprocessAndCompileTestRunner(executionContext, compileResult.OutputFile);
IExecutor executor = new RestrictedProcessExecutor();
var processExecutionResult = executor.Execute(outputAssemblyPath, string.Empty, executionContext.TimeLimit, executionContext.MemoryLimit);
var workingDirectory = compileResult.OutputFile;
if (Directory.Exists(workingDirectory))
{
Directory.Delete(workingDirectory, true);
}
this.ProcessTests(processExecutionResult, executionContext, result);
return result;
}
protected CompileResult ExecuteCompiling(ExecutionContext executionContext, Func<CompilerType, string> getCompilerPathFunc, ExecutionResult result)
{
var submissionFilePath = string.IsNullOrEmpty(executionContext.AllowedFileExtensions)
? FileHelpers.SaveStringToTempFile(executionContext.Code)
: FileHelpers.SaveByteArrayToTempFile(executionContext.FileContent);
var compilerPath = getCompilerPathFunc(executionContext.CompilerType);
var compilerResult = this.Compile(executionContext.CompilerType, compilerPath, executionContext.AdditionalCompilerArguments, submissionFilePath);
result.IsCompiledSuccessfully = compilerResult.IsCompiledSuccessfully;
result.CompilerComment = compilerResult.CompilerComment;
return compilerResult;
}
protected override ExecutionResult <TestResult> RunUnitTests(
string consoleRunnerPath,
IExecutionContext <TestsInputModel> executionContext,
IExecutor executor,
IChecker checker,
ExecutionResult <TestResult> result,
string csProjFilePath,
string additionalExecutionArguments)
{
var projectDirectory = Path.GetDirectoryName(csProjFilePath);
var testedCodePath =
$"{projectDirectory}\\{UnitTestStrategiesHelper.TestedCodeFileNameWithExtension}";
var originalTestsPassed = -1;
var count = 0;
var compilerPath = this.GetCompilerPathFunc(executionContext.CompilerType);
var tests = executionContext.Input.Tests.OrderBy(x => x.IsTrialTest).ThenBy(x => x.OrderBy);
foreach (var test in tests)
{
File.WriteAllText(this.SetupFixturePath, SetupFixtureTemplate);
File.WriteAllText(testedCodePath, test.Input);
// Compiling
var compilerResult = this.Compile(
executionContext.CompilerType,
compilerPath,
executionContext.AdditionalCompilerArguments,
csProjFilePath);
result.IsCompiledSuccessfully = compilerResult.IsCompiledSuccessfully;
result.CompilerComment = compilerResult.CompilerComment;
if (!compilerResult.IsCompiledSuccessfully)
{
return(result);
}
// Delete tests before execution so the user can't acces them
FileHelpers.DeleteFiles(testedCodePath, this.SetupFixturePath);
var arguments = new List <string> {
compilerResult.OutputFile
};
arguments.AddRange(additionalExecutionArguments.Split(' '));
var processExecutionResult = executor.Execute(
consoleRunnerPath,
string.Empty,
executionContext.TimeLimit,
executionContext.MemoryLimit,
arguments,
null,
false,
true);
var processExecutionTestResult = UnitTestStrategiesHelper.GetTestResult(
processExecutionResult.ReceivedOutput,
TestResultsRegex,
originalTestsPassed,
count == 0);
var message = processExecutionTestResult.message;
originalTestsPassed = processExecutionTestResult.originalTestsPassed;
var testResult = this.ExecuteAndCheckTest(test, processExecutionResult, checker, message);
result.Results.Add(testResult);
count++;
}
return(result);
}
public override ExecutionResult Execute(ExecutionContext executionContext)
{
var result = new ExecutionResult();
// Copy the sandbox executor source code to a file in the working directory
File.WriteAllText(this.SandboxExecutorSourceFilePath, this.SandboxExecutorCode);
// Create a temp file with the submission code
string submissionFilePath;
try
{
submissionFilePath = this.CreateSubmissionFile(executionContext);
}
catch (ArgumentException exception)
{
result.IsCompiledSuccessfully = false;
result.CompilerComment = exception.Message;
return(result);
}
var compilerResult = this.DoCompile(executionContext, submissionFilePath);
// Assign compiled result info to the execution result
result.IsCompiledSuccessfully = compilerResult.IsCompiledSuccessfully;
result.CompilerComment = compilerResult.CompilerComment;
if (!result.IsCompiledSuccessfully)
{
return(result);
}
// Prepare execution process arguments and time measurement info
var classPathArgument = $"-classpath \"{this.WorkingDirectory}\"";
var classToExecuteFilePath = compilerResult.OutputFile;
var classToExecute = classToExecuteFilePath
.Substring(
this.WorkingDirectory.Length + 1,
classToExecuteFilePath.Length - this.WorkingDirectory.Length - JavaCompiledFileExtension.Length - 1)
.Replace('\\', '.');
var timeMeasurementFilePath = $"{this.WorkingDirectory}\\{TimeMeasurementFileName}";
// Create an executor and a checker
var executor = new StandardProcessExecutor();
var checker = Checker.CreateChecker(executionContext.CheckerAssemblyName, executionContext.CheckerTypeName, executionContext.CheckerParameter);
// Process the submission and check each test
foreach (var test in executionContext.Tests)
{
var processExecutionResult = executor.Execute(
this.JavaExecutablePath,
test.Input,
executionContext.TimeLimit * 2, // Java virtual machine takes more time to start up
executionContext.MemoryLimit,
new[] { classPathArgument, SandboxExecutorClassName, classToExecute, $"\"{timeMeasurementFilePath}\"" },
null,
false,
true);
UpdateExecutionTime(timeMeasurementFilePath, processExecutionResult, executionContext.TimeLimit);
var testResult = this.ExecuteAndCheckTest(test, processExecutionResult, checker, processExecutionResult.ReceivedOutput);
result.TestResults.Add(testResult);
}
return(result);
}