protected override void Context()
{
base.Context();
_dp = CreateObject <DistributedParameter>().WithName("Diana").WithDimension(DimensionLength);
ConstantFormula dpMeanFormula = CreateObject <ConstantFormula>().WithValue(3.0);
IParameter dpMean = CreateObject <Parameter>().WithName("Mean").WithFormula(dpMeanFormula);
ConstantFormula dpDeviationFormula = CreateObject <ConstantFormula>().WithValue(1.0);
IParameter dpDeviation = CreateObject <Parameter>().WithName("Deviation").WithFormula(dpDeviationFormula);
ConstantFormula dpPercentileFormula = CreateObject <ConstantFormula>().WithValue(0.5);
IParameter dpPercentile = CreateObject <Parameter>().WithName("Percentile").WithFormula(dpPercentileFormula);
_dp.Add(dpMean);
_dp.Add(dpDeviation);
_dp.Add(dpPercentile);
IDistributionFormula noDiFo = CreateObject <NormalDistributionFormula>().WithDimension(DimensionLength);
noDiFo.AddObjectPath(new FormulaUsablePath(new[] { Constants.Distribution.MEAN })
{
Alias = Constants.Distribution.MEAN, Dimension = DimensionLength
});
noDiFo.AddObjectPath(new FormulaUsablePath(new[] { Constants.Distribution.DEVIATION })
{
Alias = Constants.Distribution.DEVIATION, Dimension = DimensionLength
});
noDiFo.AddObjectPath(new FormulaUsablePath(new[] { Constants.Distribution.PERCENTILE })
{
Alias = Constants.Distribution.PERCENTILE, Dimension = DimensionLength
});
_dp.Formula = noDiFo;
_dp.Formula.ResolveObjectPathsFor(_dp);
_dp.RHSFormula = CreateObject <ConstantFormula>().WithDimension(DimensionLength).WithValue(23.4);
}
protected override void Context()
{
base.Context();
_constantFormula = new ConstantFormula(5);
_parameter.Formula = _constantFormula;
_parameter.Value = 10;
}
protected override void Context()
{
base.Context();
var displayUnitRetriever = IoC.Resolve <IDisplayUnitRetriever>();
var f1 = new ExplicitFormula("CL*conc").WithName("formula");
var r1 = new ReactionBuilder().WithName("Reaction").WithFormula(f1);
r1.AddEduct(new ReactionPartnerBuilder("Drug", 1));
r1.AddEduct(new ReactionPartnerBuilder("Metab", 1));
r1.AddModifier("Cyp");
var concentrationDimension = DomainHelperForSpecs.ConcentrationDimensionForSpecs();
var p1Formula = new ConstantFormula(2).WithDimension(concentrationDimension);
var p11 = new Parameter().WithName("P1").WithFormula(p1Formula).WithParentContainer(r1);
var f2 = new ExplicitFormula("CL*conc").WithName("formula");
var r2 = new ReactionBuilder().WithName("Reaction").WithFormula(f2);
r2.AddEduct(new ReactionPartnerBuilder("Drug", 1));
r2.AddEduct(new ReactionPartnerBuilder("Metab", 1));
r2.AddModifier("Cyp");
var p12Forumla = new ConstantFormula(3).WithDimension(concentrationDimension);
var p12 = new Parameter().WithName("P1").WithFormula(p12Forumla).WithParentContainer(r2);
_object1 = r1;
_object2 = r2;
_preferredUnit = concentrationDimension.Units.ElementAt(0);
A.CallTo(() => displayUnitRetriever.PreferredUnitFor(p1Formula, null)).Returns(_preferredUnit);
A.CallTo(() => displayUnitRetriever.PreferredUnitFor(p12Forumla, null)).Returns(_preferredUnit);
}
protected override void Context()
{
base.Context();
_buidingBlockWithFormulaCache = A.Fake <IBuildingBlock>();
_parameter = new Parameter().WithDimension(A.Fake <IDimension>());
var constantFormula = new ConstantFormula().WithDimension(_parameter.Dimension);
A.CallTo(() => _formulaTask.CreateNewFormula <ConstantFormula>(_parameter.Dimension)).Returns(constantFormula);
}
protected override void Context()
{
base.Context();
_constantFormula = new ConstantFormula(2).WithDimension(A.Fake <IDimension>());
_formula = _constantFormula;
_usingFormula = A.Fake <IUsingFormula>();
_usingFormula.Formula = _formula;
A.CallTo(() => _dimensionMapper.ConversionFactor(_formula)).Returns(15);
}
/// <summary>
/// Sets a constant value into a constant value formula
/// </summary>
/// <param name="constantFormula">The constant formula being edited</param>
/// <param name="newValue">The new value being applied to the formula</param>
/// <param name="displayUnit">The new value new display unit</param>
/// <param name="oldUnit">The old value display unit</param>
/// <param name="buildingBlock">The building block that this formula is a member of</param>
/// <param name="formulaOwner">The entity that owns the formula</param>
public SetConstantFormulaValueCommand(ConstantFormula constantFormula, double newValue, Unit displayUnit, Unit oldUnit, IBuildingBlock buildingBlock, IEntity formulaOwner) : base(buildingBlock)
{
_constantFormula = constantFormula;
_newValue = newValue;
_oldValue = _constantFormula.Value;
FormulaId = _constantFormula.Id;
ObjectType = new ObjectTypeResolver().TypeFor(formulaOwner);
CommandType = AppConstants.Commands.EditCommand;
_ownerId = formulaOwner.Id;
_owner = formulaOwner;
_displayUnit = displayUnit;
_oldDisplayUnit = oldUnit;
}
protected override void Context()
{
base.Context();
_formula = new ConstantFormula(1);
_parameter = new Parameter().WithName("P1");
_parameter.Dimension = DomainHelperForSpecs.AmountDimension;
_parameter.DisplayUnit = _parameter.Dimension.DefaultUnit;
_parameter.IsDefault = false;
A.CallTo(() => _parametersInBuildingBlockRetriever.AllFrom(_buildingBlock, A <Func <IParameter, bool> > ._)).Returns(new[] { _parameter });
_updateCommand = new MoBiEmptyCommand();
A.CallTo(() => _quantityTask.UpdateDefaultStateAndValueOriginFor(_parameter, _buildingBlock)).Returns(_updateCommand);
}
protected override void Context()
{
base.Context();
var f1 = new ConstantFormula(5);
var f2 = new ConstantFormula(10);
_object1 = new Parameter().WithFormula(f1);
var parameter = new Parameter().WithFormula(f2);
_object2 = parameter;
_comparerSettings.FormulaComparison = FormulaComparison.Formula;
_comparerSettings.CompareHiddenEntities = false;
}
public ConstantFormulaBuilderDTO MapFrom(ConstantFormula constantFormula, Unit displayUnit)
{
var dto = Map <ConstantFormulaBuilderDTO>(constantFormula);
dto.Dimension = constantFormula.Dimension ?? _dimensionFactory.Dimension(Constants.Dimension.DIMENSIONLESS);
//set the kernel value after the fact (afer display unit);
var valueDTO = new ValueEditDTO {
Dimension = dto.Dimension, DisplayUnit = displayUnit, KernelValue = constantFormula.Value
};
constantFormula.Changed += o => { valueDTO.KernelValue = constantFormula.Value; };
dto.Value = valueDTO;
return(dto);
}
protected override void Context()
{
base.Context();
_moleculeBuildingBlock = new MoleculeBuildingBlock();
_createMoleculePresenter = A.Fake <ICreatePKSimMoleculePresenter>();
_molecule = new MoleculeBuilder();
_molecule.DefaultStartFormula = A.Fake <IFormula>();
A.CallTo(() => _createMoleculePresenter.CreateMolecule(_moleculeBuildingBlock)).Returns(_molecule);
A.CallTo(() => _interactionTaskContext.ApplicationController.Start <ICreatePKSimMoleculePresenter>()).Returns(_createMoleculePresenter);
_defaultStartFormula = new ConstantFormula();
A.CallTo(_formulaTask).WithReturnType <ConstantFormula>().Returns(_defaultStartFormula);
A.CallTo(() => _context.AddToHistory(A <ICommand> ._))
.Invokes(x => _command = x.GetArgument <ICommand>(0));
}
public void TestSerialization()
{
ConstantFormula x1 = CreateObject <ConstantFormula>().WithName("Fortunato").WithDimension(DimensionLength).WithValue(5.3);
x1.AddObjectPath(ObjectPathFactory.CreateAbsoluteFormulaUsablePath(P1));
x1.AddObjectPath(ObjectPathFactory.CreateRelativeFormulaUsablePath(P, P0));
x1.AddObjectPath(ObjectPathFactory.CreateRelativeFormulaUsablePath(P, P2).WithAlias("Pitter"));
x1.ResolveObjectPathsFor(P);
ConstantFormula x2 = SerializeAndDeserialize(x1);
x2.ResolveObjectPathsFor(P);
AssertForSpecs.AreEqualConstantFormula(x2, x1);
}
protected override void Context()
{
_context = A.Fake <IMoBiContext>();
_owner = new Parameter {
Id = "id", Name = "Parameter"
};
_formula = new ConstantFormula(3.0);
sut = new SetConstantFormulaValueCommand(
constantFormula: _formula,
newValue: 4.0,
displayUnit: DomainHelperForSpecs.AmountDimension.DefaultUnit,
oldUnit: DomainHelperForSpecs.ConcentrationDimension.DefaultUnit,
buildingBlock: new ParameterStartValuesBuildingBlock(),
formulaOwner: _owner);
A.CallTo(() => _context.Get <IEntity>("id")).Returns(_owner);
}
protected override void Context()
{
base.Context();
_dimension = A.Fake <IDimension>();
_buildingBlock = A.Fake <IBuildingBlock>();
_parentContainer = new ReactionBuilder();
var modalPresenter = A.Fake <IModalPresenter>();
var editParameterPresenter = A.Fake <IEditParameterPresenter>();
_parameter = new Parameter();
A.CallTo(() => _context.Context.Create <IParameter>()).Returns(_parameter);
A.CallTo(() => _context.UserSettings.ParameterDefaultDimension).Returns("UNKNOWN");
A.CallTo(_context.ApplicationController).WithReturnType <IModalPresenter>().Returns(modalPresenter);
A.CallTo(() => modalPresenter.Show()).Returns(true);
A.CallTo(() => modalPresenter.SubPresenter).Returns(editParameterPresenter);
A.CallTo(() => _context.ApplicationController.Start <ISelectReferenceAtParameterPresenter>()).Returns(A.Fake <ISelectReferenceAtParameterPresenter>());
A.CallTo(_dimensionFactory).WithReturnType <IDimension>().Returns(_dimension);
_defaultConstantFormula = new ConstantFormula();
A.CallTo(_formulaTask).WithReturnType <ConstantFormula>().Returns(_defaultConstantFormula);
}
protected override void Context()
{
base.Context();
_modalPresenter = A.Fake <IModalPresenter>();
_amountDimension = A.Fake <IDimension>();
_displayUnit = A.Fake <Unit>();
_editMoleculeBuilderPresenter = A.Fake <IEditPresenter <IMoleculeBuilder> >();
_moleculeBuilderBuildingBlock = new MoleculeBuildingBlock();
A.CallTo(() => _context.Create <IMoleculeBuilder>()).Returns(new MoleculeBuilder());
A.CallTo(() => _dimensionRetriever.MoleculeDimension).Returns(_amountDimension);
A.CallTo(_interactionTaskContext.ApplicationController).WithReturnType <IModalPresenter>().Returns(_modalPresenter);
A.CallTo(_interactionTaskContext).WithReturnType <Unit>().Returns(_displayUnit);
A.CallTo(() => _modalPresenter.SubPresenter).Returns(_editMoleculeBuilderPresenter);
A.CallTo(() => _parameterFactory.CreateConcentrationParameter(_moleculeBuilderBuildingBlock.FormulaCache)).Returns(new Parameter {
Name = AppConstants.Parameters.CONCENTRATION
});
_defaultStartFormula = new ConstantFormula();
A.CallTo(_formulaTask).WithReturnType <ConstantFormula>().Returns(_defaultStartFormula);
}
protected override void Context()
{
base.Context();
_formula = new ConstantFormula(5);
A.CallTo(() => _dimensionMapper.ConversionFactor(_formula)).Returns(10);
}
protected override void Because()
{
_result = sut.ValueFor(_parameterValueDefinition) as ConstantFormula;
}
public IMoBiCommand SetConstantFormulaValue(ConstantFormula formula, double kernelValue, Unit newDisplayUnit, Unit oldDisplayUnit, IBuildingBlock buildingBlock, IEntity formulaOwner)
{
var command = new SetConstantFormulaValueCommand(formula, kernelValue, newDisplayUnit, oldDisplayUnit, buildingBlock, formulaOwner).Run(_context);
return(withUpdatedDefaultStateAndValueOrigin(command, formula, buildingBlock));
}
/// <summary>
/// Checks to see if the constant formula equals the double StartValue
/// </summary>
/// <param name="startValue">The start value to check</param>
/// <param name="targetFormula">The formula being evaluated</param>
/// <returns>True if the formula is constant and evaluates to the same value as startValue.StartValue</returns>
private static bool isConstantFormulaEqualToStartValue(IStartValue startValue, ConstantFormula targetFormula)
{
return(startValue.StartValue.HasValue && ValueComparer.AreValuesEqual(startValue.StartValue.Value, targetFormula.Calculate(null)));
}
public override void RestoreExecutionData(IMoBiContext context)
{
_constantFormula = context.Get <ConstantFormula>(FormulaId);
_owner = context.Get <IEntity>(_ownerId);
}
protected override void ClearReferences()
{
base.ClearReferences();
_constantFormula = null;
_owner = null;
}
protected override void Because()
{
sut = new ConstantFormula(_value);
}
