/// <summary>
/// Gets the running options for the GenValAppRunner
/// </summary>
/// <param name="parsedParameters">The parsed command line arguments.</param>
/// <returns></returns>
public static GenValRunningOptions GetRunningOptions(ArgumentParsingTarget parsedParameters)
{
var genValMode = DetermineRunningMode(parsedParameters);
var algoMode = DetermineAlgoMode(parsedParameters, genValMode);
return(new GenValRunningOptions(algoMode, genValMode));
}
public async Task ShouldNotRunWithoutSettingRunningMode()
{
var parameters = new ArgumentParsingTarget();
_subject = new FakeGenValRunner(_fakeAutofac.GetContainer().BeginLifetimeScope());
var result = await _subject.Run(parameters, GenValMode.Unset);
Assert.AreNotEqual(0, result);
}
public ArgumentParsingTarget Parse(string[] args)
{
var parsedParameters = new ArgumentParsingTarget();
_parser.ExtractArgumentAttributes(parsedParameters);
args = GetArgsWhenNotProvided(args);
_parser.ParseCommandLine(args);
return(parsedParameters);
}
public void ShouldCorrectlySetRunningMode(GenValMode genValMode)
{
var parameters = new ArgumentParsingTarget
{
RegistrationFile = genValMode == GenValMode.Generate ? new FileInfo("registration.json") : null,
ResponseFile = genValMode == GenValMode.Validate ? new FileInfo("response.json") : null,
AnswerFile = genValMode == GenValMode.Validate ? new FileInfo("answer.json") : null
};
var result = RunningOptionsHelper.DetermineRunningMode(parameters);
Assert.AreEqual(genValMode, result);
}
/// <summary>
/// Determines if the runner is running for generation or validation,
/// determined via parsed command arguments.
/// </summary>
/// <param name="parsedParameters">The parsed command line arguments.</param>
public static GenValMode DetermineRunningMode(ArgumentParsingTarget parsedParameters)
{
if (parsedParameters.RegistrationFile != null)
{
return(GenValMode.Generate);
}
if (parsedParameters.AnswerFile != null && parsedParameters.ResponseFile != null)
{
return(GenValMode.Validate);
}
return(GenValMode.Unset);
}
/// <summary>
/// Determine the <see cref="AlgoMode"/> from the <see cref="ArgumentParsingTarget"/> and <see cref="GenValMode"/>.
/// </summary>
/// <param name="parsedParameters">The parsed command line arguments.</param>
/// <param name="genValMode">The running mode.</param>
/// <returns></returns>
public static AlgoMode DetermineAlgoMode(ArgumentParsingTarget parsedParameters, GenValMode genValMode)
{
switch (genValMode)
{
case GenValMode.Generate:
var parameters = JsonConvert.DeserializeObject <ParametersBase>(File.ReadAllText(parsedParameters.RegistrationFile.FullName));
return(AlgoModeLookupHelper.GetAlgoModeFromStrings(parameters.Algorithm, parameters.Mode, parameters.Revision));
case GenValMode.Validate:
var internalProjection = JsonConvert.DeserializeObject <TestVectorSetBase>(File.ReadAllText(parsedParameters.AnswerFile.FullName));
return(AlgoModeLookupHelper.GetAlgoModeFromStrings(internalProjection.Algorithm, internalProjection.Mode, internalProjection.Revision));
default:
throw new ArgumentException(nameof(genValMode));
}
}
/// <summary>
/// Configure logging for the app run.
/// </summary>
/// <param name="parsedParameters">The parsed arguments into the app</param>
/// <param name="runningOptions">The algorithm and running mode.</param>
private static void ConfigureLogging(ArgumentParsingTarget parsedParameters, GenValRunningOptions runningOptions)
{
string filePath;
switch (runningOptions.GenValMode)
{
case GenValMode.Generate:
filePath = parsedParameters.RegistrationFile.FullName;
break;
case GenValMode.Validate:
filePath = parsedParameters.AnswerFile.FullName;
break;
default:
filePath = string.Empty;
break;
}
var logName = $"{runningOptions.GenValMode}";
LoggingHelper.ConfigureLogging(filePath, logName);
}
public async Task ShouldRun(GenValMode genValMode, string registrationFile, string responseFile, string answerFile, int returnCode)
{
var parameters = new ArgumentParsingTarget
{
RegistrationFile = genValMode == GenValMode.Generate ? new FileInfo(registrationFile) : null,
ResponseFile = genValMode == GenValMode.Validate ? new FileInfo(responseFile) : null,
AnswerFile = genValMode == GenValMode.Validate ? new FileInfo(answerFile) : null
};
var result = int.MinValue;
try
{
_subject = new FakeGenValRunner(_fakeAutofac.GetContainer().BeginLifetimeScope());
result = await _subject.Run(parameters, genValMode);
}
catch (Exception e)
{
Console.WriteLine(e);
}
Assert.AreEqual(returnCode, result);
}
/// <summary>
/// Run Generation or Validation, dependent on determined run mode..
/// </summary>
/// <param name="parsedParameters"></param>
/// <returns></returns>
public async Task <int> Run(ArgumentParsingTarget parsedParameters, GenValMode genValMode)
{
string errorMessage;
try
{
switch (genValMode)
{
case GenValMode.Generate:
{
FileDirectory = Path.GetDirectoryName(parsedParameters.RegistrationFile.FullName);
var registrationFile = parsedParameters.RegistrationFile.FullName;
var result = await RunGeneration(registrationFile);
var outputDirPath = Path.GetDirectoryName(registrationFile);
if (result.Success)
{
// Write out the produced vector files
FileService.WriteFile(
Path.Combine(outputDirPath, "internalProjection.json"),
result.InternalProjection,
true);
FileService.WriteFile(
Path.Combine(outputDirPath, "prompt.json"),
result.PromptProjection,
true);
FileService.WriteFile(
Path.Combine(outputDirPath, "expectedResults.json"),
result.ResultProjection,
true);
return((int)result.StatusCode);
}
// Write out the error file
FileService.WriteFile(
Path.Combine(outputDirPath, "error.txt"),
result.ErrorMessage,
true);
errorMessage = $"ERROR! Generating Test Vectors for {registrationFile}: {result.ErrorMessage}";
Console.Error.WriteLine(errorMessage);
Program.Logger.Error($"Status Code: {result.StatusCode}");
Program.Logger.Error(errorMessage);
ErrorLogger.LogError(result.StatusCode, "generator", result.ErrorMessage, FileDirectory);
return((int)result.StatusCode);
}
case GenValMode.Validate:
{
FileDirectory = Path.GetDirectoryName(parsedParameters.ResponseFile.FullName);
var responseFile = parsedParameters.ResponseFile.FullName;
var answerFile = parsedParameters.AnswerFile.FullName;
var showExpected = parsedParameters.ShowExpected;
var result = await RunValidation(responseFile, answerFile, showExpected);
var outputDirPath = Path.GetDirectoryName(responseFile);
if (result.Success)
{
// Write out the response from the validation.
FileService.WriteFile(
Path.Combine(outputDirPath, "validation.json"),
result.ValidationResult,
true);
return((int)result.StatusCode);
}
// Write out the error file
FileService.WriteFile(
Path.Combine(outputDirPath, "error.txt"),
result.ErrorMessage,
true);
errorMessage = $"ERROR! Validating Test Vectors for {responseFile}: {result.ErrorMessage}";
Console.Error.WriteLine(errorMessage);
Program.Logger.Error($"Status Code: {result.StatusCode}");
Program.Logger.Error(errorMessage);
ErrorLogger.LogError(result.StatusCode, "validator", result.ErrorMessage, FileDirectory);
return((int)result.StatusCode);
}
default:
errorMessage = "ERROR! Unable to find running mode";
Console.Error.WriteLine(errorMessage);
return((int)StatusCode.ModeError);
}
}
catch (Exception ex)
{
errorMessage = $"ERROR: {ex.Message}";
Console.WriteLine(errorMessage);
Console.WriteLine(ex.StackTrace);
Logger.Error($"Status Code: {StatusCode.Exception}");
Logger.Error(errorMessage);
ErrorLogger.LogError(StatusCode.Exception, "driver", ex.Message, FileDirectory);
return((int)StatusCode.Exception);
}
}
