protected override void Context()
{
base.Context();
_visitor = A.Fake <IVisitor>();
_simulationOutput = A.Fake <OutputSchema>();
sut.OutputSchema = _simulationOutput;
}
protected override void Context()
{
base.Context();
A.CallTo(() => _objectBaseFactory.Create <OutputInterval>()).Returns(new OutputInterval());
A.CallTo(() => _objectBaseFactory.Create <ConstantFormula>()).ReturnsLazily(x => new ConstantFormula());
_schema = new OutputSchema();
_schema.AddInterval(new OutputInterval());
}
protected override void Context()
{
_outputSchema = new OutputSchema();
_defaultInterval = new OutputInterval();
_objectBaseFactory = A.Fake <IObjectBaseFactory>();
_outputIntervalFactory = A.Fake <IOutputIntervalFactory>();
A.CallTo(() => _objectBaseFactory.Create <OutputSchema>()).Returns(_outputSchema);
A.CallTo(() => _outputIntervalFactory.CreateDefault()).Returns(_defaultInterval);
sut = new OutputSchemaFactory(_objectBaseFactory, _outputIntervalFactory);
}
protected override async Task Context()
{
await base.Context();
_snapshot = await sut.MapToSnapshot(_individualSimulation, _project);
var individualSimulation = new IndividualSimulation
{
Properties = _simulationProperties,
SimulationSettings = _settings,
Model = _model
};
individualSimulation.AddUsedBuildingBlock(new UsedBuildingBlock("IndTemplateId", PKSimBuildingBlockType.Individual)
{
Name = _individual.Name,
BuildingBlock = _individual
});
_modelProperties = new ModelProperties();
A.CallTo(() => _modelPropertiesTask.DefaultFor(_individual.OriginData, _snapshot.Model)).Returns(_modelProperties);
A.CallTo(() => _simulationFactory.CreateFrom(_individual, A <IReadOnlyList <Compound> > ._, _modelProperties, null)).Returns(individualSimulation);
_outputSelection = new OSPSuite.Core.Domain.OutputSelections();
_outputSelection.AddOutput(new QuantitySelection("PATH", QuantityType.BaseGrid));
A.CallTo(() => _outputSelectionMapper.MapToModel(_snapshot.OutputSelections, individualSimulation)).Returns(_outputSelection);
_solver = new SolverSettings();
A.CallTo(() => _solverSettingsMapper.MapToModel(_snapshot.Solver)).Returns(_solver);
_outputSchema = new OutputSchema();
A.CallTo(() => _outputSchemaMapper.MapToModel(_snapshot.OutputSchema)).Returns(_outputSchema);
A.CallTo(() => _curveChartMapper.MapToModel(_snapshotSimulationTimeProfile, A <SimulationAnalysisContext> ._))
.Invokes(x => _context = x.GetArgument <SimulationAnalysisContext>(1))
.Returns(_simulationTimeProfile);
//ensure that run will be performed
_snapshot.HasResults = true;
_calculatedDataRepository = DomainHelperForSpecs.ObservedData("Calculated");
A.CallTo(() => _simulationRunner.RunSimulation(individualSimulation, A <SimulationRunOptions> ._))
.Invokes(x => { individualSimulation.DataRepository = _calculatedDataRepository; });
A.CallTo(() => _eventMappingMapper.MapToModel(_eventSelection, _project)).Returns(_eventMapping);
A.CallTo(() => _observerSetMappingMapper.MapToModel(_observerSetSelection, _project)).Returns(_observerSetMapping);
}
public OutputInterval CreateFor(OutputSchema outputSchema, double startTimeInMinute, double endTimeInMinute, double resolutionInPtsPerMin)
{
return(Create(startTimeInMinute, endTimeInMinute, resolutionInPtsPerMin)
.WithName(_containerTask.CreateUniqueName(outputSchema, Constants.OUTPUT_INTERVAL, canUseBaseName: true)));
}
protected override void Because()
{
_result = sut.Create(_min, _max, _resolution);
}
protected override void Because()
{
_result = sut.CreateDefault();
}