public async Task <IEmulatorTaskResult> ExecuteEmulationAsync(IEmulatorTask task)
{
// IFileRecord fileToExecute = task.EmulatingGame.WithFiles().FirstOrDefault(f => this.Properties.Mimetypes.Contains(f.MimeType));
IFileRecord fileToExecute = null;
if (fileToExecute == null)
{
throw new FileNotFoundException(
$"Unable to find a compatible ROM for game {task.EmulatingGame.RecordId}.");
}
IEmulatorTaskResult result = new RetroArchTaskResult(task.ProcessTaskRoot, task.GameSaveLocation);
IProcessBuilder builder = this.RetroArchExecutable.GetProcessBuilder();
builder.WithArgument("--verbose")
.WithArgument("-s", task.ProcessTaskRoot.SaveDirectory.FullName)
.WithArgument("-c", Path.Combine(task.ProcessTaskRoot.ConfigurationDirectory.FullName, "retroarch.cfg"))
.WithArgument("-L", Path.Combine(this.CoreDirectory.FullName, task.Pragmas["retroarch_core"]));
// .WithArgument(fileToExecute.);
foreach (var cfg in this.BuildConfiguration(task.EmulatorConfiguration, task.ControllerConfiguration))
{
await File.WriteAllTextAsync(Path.Combine(task.ProcessTaskRoot.ConfigurationDirectory.FullName,
task.EmulatorConfiguration.Descriptor.Outputs[cfg.Key].Destination), cfg.Value);
}
var psi = builder.ToProcessStartInfo();
var process = Process.Start(psi);
process.Exited += (s, e) => result.Closed();
return(result);
}
public void AddProcess(string name, IProcessTemplate template)
{
IProcessBuilder builder = ProcessBuilder.GetProcessBuilder();
IProcess process = builder.Build(this, template);
this.processes.Add(name, process);
}
public void SetUp()
{
mockProcessBuilder = Mock.Of <IProcessBuilder>();
mockProcess = Mock.Of <IProcess>();
imageTarball = Mock.Of <IImageTarball>();
Mock.Get(mockProcessBuilder).Setup(m => m.Start()).Returns(mockProcess);
Mock.Get(imageTarball).Setup(i => i.WriteToAsync(It.IsAny <Stream>()))
.Returns <Stream>(async s => await s.WriteAsync(Encoding.UTF8.GetBytes("fib")));
}
public SetCreateProcessRateParameterCommand(bool createProcessRate, IProcessBuilder processBuilder, IBuildingBlock buildingBlock) : base(buildingBlock)
{
_processBuilder = processBuilder;
_processBuilderId = processBuilder.Id;
_createProcessRate = createProcessRate;
_oldCreateProcessRate = _processBuilder.CreateProcessRateParameter;
CommandType = AppConstants.Commands.EditCommand;
ObjectType = processBuilder.IsAnImplementationOf <IReactionBuilder>() ? ObjectTypes.Reaction : ObjectTypes.ApplicationTransport;
Description = AppConstants.Commands.EditDescription(ObjectType, AppConstants.Captions.CreateProcessRateParameter, _oldCreateProcessRate.ToString(), _createProcessRate.ToString(), _processBuilder.Name);
}
public TestBuilder(IProcessBuilder processBuilder, ILogger <TestBuilder> logger)
{
_processBuilder = processBuilder;
_logger = logger;
if (!Directory.Exists(_runnerDir))
{
Directory.CreateDirectory(_runnerDir);
CopyRunnerFiles(_runnerDir);
}
}
public static TestExecuterResult Execute(IProcessBuilder builder)
{
var result = new TestExecuterResult
{
Process = builder.Build(),
};
result.MutatedRows = result.Process.Evaluate().TakeRowsAndReleaseOwnership().ToList();
return(result);
}
public IProcessBuilder GetBuilder(ProcessStartupParam parm)
{
IProcessBuilder result = null;
if (!_builders.ContainsKey(parm.Flag))
{
//throw new Exception($"{parm.Flag}不支持");
result = _standardProcess;
}
else
{
result = _builders[parm.Flag];
}
result.StartupParam = parm;
return(result);
}
protected override void Context()
{
base.Context();
_buildConfiguration = A.Fake <IBuildConfiguration>();
_processBuilder = new ReactionBuilder();
_processBuilder.CreateProcessRateParameter = true;
_kinetic = new ExplicitFormula("(A+B)*fu/BW");
_formulaUsablePathA = new FormulaUsablePath(new[] { ObjectPath.PARENT_CONTAINER, "A" }).WithAlias("A");
_kinetic.AddObjectPath(_formulaUsablePathA);
_formulaUsablePathB = new FormulaUsablePath(new[] { "B" }).WithAlias("B");
_kinetic.AddObjectPath(_formulaUsablePathB);
_formulaUsablePathFU = new FormulaUsablePath(new[] { ObjectPathKeywords.MOLECULE, "fu" }).WithAlias("fu");
_kinetic.AddObjectPath(_formulaUsablePathFU);
_formulaUsablePathBW = new FormulaUsablePath(new[] { "Organism", "BW" }).WithAlias("BW");
_kinetic.AddObjectPath(_formulaUsablePathBW);
_processBuilder.CreateProcessRateParameter = true;
_processBuilder.ProcessRateParameterPersistable = true;
A.CallTo(() => _formulaMapper.MapFrom(_kinetic, _buildConfiguration)).Returns(_kinetic);
_processBuilder.Name = "Reaction";
_processBuilder.Formula = _kinetic;
_processRateParameter = new Parameter();
A.CallTo(() => _objectBaseFactory.Create <IParameter>()).Returns(_processRateParameter);
}
public IParameter CreateProcessRateParameterFor(IProcessBuilder processBuilder, IBuildConfiguration buildConfiguration)
{
var parameter = _objectBaseFactory
.Create<IParameter>()
.WithName(Constants.Parameters.PROCESS_RATE)
.WithDimension(processBuilder.Dimension)
.WithFormula(_formulaMapper.MapFrom(processBuilder.Formula, buildConfiguration));
parameter.Visible = false;
parameter.Editable = false;
parameter.IsDefault = true;
addAdditionalParentReference(parameter.Formula);
buildConfiguration.AddBuilderReference(parameter, processBuilder);
if (processBuilder.ProcessRateParameterPersistable)
parameter.Persistable = true;
parameter.AddTag(processBuilder.Name);
parameter.AddTag(Constants.Parameters.PROCESS_RATE);
return parameter;
}
protected override void Context()
{
_processBuilder = A.Fake <IProcessBuilder>();
}
public override void RestoreExecutionData(IMoBiContext context)
{
base.RestoreExecutionData(context);
_processBuilder = context.Get <IProcessBuilder>(_processBuilderId);
}
protected override void ClearReferences()
{
base.ClearReferences();
_processBuilder = null;
}
