protected override void Context()
{
_pivotAnalysis = new PopulationPivotAnalysis();
_pivotAnalysis.Add(_genderField);
_pivotAnalysis.Add(_raceField);
_pivotAnalysis.Add(_bmiField);
_pivotAnalysis.Add(_cmaxField);
var grouping = new FixedLimitsGroupingDefinition(_bmiField.Name);
grouping.SetLimits(new[] { 25d }.OrderBy(x => x));
grouping.AddItems(PopulationAnalysisHelperForSpecs.BMIGroups);
_bmiClass = new PopulationAnalysisGroupingField(grouping)
{
Name = "BMI class"
};
_pivotAnalysis.Add(_bmiClass);
_dimensionRepository = A.Fake <IDimensionRepository>();
_pivotResultCreator = A.Fake <IPivotResultCreator>();
var userSettings = A.Fake <ICoreUserSettings>();
userSettings.NumberOfIndividualsPerBin = 1;
userSettings.NumberOfBins = 2;
_binIntervalsCreator = new BinIntervalsCreator(userSettings);
sut = new RangeChartDataCreator(_dimensionRepository, _pivotResultCreator, _binIntervalsCreator);
}
private void removeFieldsFromAnalysis(IPopulationAnalysisField field, PopulationAnalysis populationAnalysis)
{
var allDerivedFields = populationAnalysis.AllFieldsReferencing(field);
allDerivedFields.Each(populationAnalysis.Remove);
populationAnalysis.Remove(field);
}
protected override void Context()
{
base.Context();
_covariateField = A.Fake <PopulationAnalysisCovariateField>();
_covariateField.PopulationAnalysis = _populationAnalysis;
sut.CreateGrouping(_covariateField, _populationDataCollector);
}
protected override void Context()
{
_renamedField = new PopulationAnalysisParameterField {
Name = _oldName, ParameterPath = "Path"
};
_groupingFieldUsing1 = new PopulationAnalysisGroupingField(new NumberOfBinsGroupingDefinition(_oldName)
{
NumberOfBins = 5
})
{
Name = "Using1"
};
_groupingFieldUsing2 = new PopulationAnalysisGroupingField(new FixedLimitsGroupingDefinition(_oldName))
{
Name = "Using2"
};
_groupingFieldNotUsing = new PopulationAnalysisGroupingField(new FixedLimitsGroupingDefinition("ANOTHER NAME"))
{
Name = "NotUsing"
};
_expressionField = new PopulationAnalysisExpressionField($"[{_oldName}] + [Field2]")
{
Name = "Expression"
};
sut = new PopulationPivotAnalysis();
sut.Add(_renamedField);
sut.Add(_groupingFieldUsing1);
sut.Add(_groupingFieldNotUsing);
sut.Add(_groupingFieldUsing2);
sut.Add(_expressionField);
}
protected override Task Context()
{
_fieldMapper = A.Fake <PopulationAnalysisFieldMapper>();
sut = new PopulationAnalysisMapper(_fieldMapper);
_populationStatisticalAnalysis = new PopulationStatisticalAnalysis();
_selectedStatisticalAnalysis = new PredefinedStatisticalAggregation {
Method = StatisticalAggregationType.Max, Selected = true, LineStyle = LineStyles.Dash
};
_populationStatisticalAnalysis.AddStatistic(_selectedStatisticalAnalysis);
_populationStatisticalAnalysis.AddStatistic(new PredefinedStatisticalAggregation {
Method = StatisticalAggregationType.Min, Selected = false
});
_populationBoxWiskerAnalysis = new PopulationBoxWhiskerAnalysis {
ShowOutliers = true
};
_field1 = A.Fake <IPopulationAnalysisField>().WithName("Field1");
_field2 = A.Fake <IPopulationAnalysisField>().WithName("Field2");
_populationPivotAnalysis = new PopulationPivotAnalysis();
_populationPivotAnalysis.Add(_field1);
_populationPivotAnalysis.Add(_field2);
_populationPivotAnalysis.SetPosition(_field1, PivotArea.FilterArea, 1);
_populationPivotAnalysis.SetPosition(_field2, PivotArea.RowArea, 2);
_snapshotField1 = new PopulationAnalysisField().WithName(_field1.Name);
_snapshotField2 = new PopulationAnalysisField().WithName(_field2.Name);
A.CallTo(() => _fieldMapper.MapToSnapshot(_field1)).Returns(_snapshotField1);
A.CallTo(() => _fieldMapper.MapToSnapshot(_field2)).Returns(_snapshotField2);
return(_completed);
}
public PopulationAnalysisFieldDTO MapFrom(IPopulationAnalysisField field)
{
return(new PopulationAnalysisFieldDTO(field)
{
Dimension = _dimensionRepository.MergedDimensionFor(field)
});
}
protected override void Context()
{
_view = A.Fake <IXAndYNumericFieldsView>();
_eventPublisher = A.Fake <IEventPublisher>();
sut = new XAndYNumericFieldsPresenter(_view, _eventPublisher);
//common context for all tests
A.CallTo(() => _view.BindTo(A <XandYFieldsSelectionDTO> ._))
.Invokes(x => _dto = x.GetArgument <XandYFieldsSelectionDTO>(0));
_field1 = A.Fake <PopulationAnalysisNumericField>();
_field2 = A.Fake <PopulationAnalysisNumericField>();
_field3 = A.Fake <PopulationAnalysisNumericField>();
_populationDataCollector = A.Fake <IPopulationDataCollector>();
_populationAnalysis = A.Fake <PopulationPivotAnalysis>();
_allDataFields = new List <IPopulationAnalysisField>();
_allNumericFields = new List <IPopulationAnalysisField>();
A.CallTo(() => _populationAnalysis.AllFieldsOn(PivotArea.DataArea)).Returns(_allDataFields);
A.CallTo(() => _populationAnalysis.All(typeof(INumericValueField), false)).Returns(_allNumericFields);
sut.StartAnalysis(_populationDataCollector, _populationAnalysis);
}
protected override void Context()
{
_pivotAnalysis = new PopulationBoxWhiskerAnalysis();
_aggregate = AggregationFunctions.BoxWhisker90Aggregation;
_pivotAnalysis.Add(_genderField);
_pivotAnalysis.Add(_raceField);
_pivotAnalysis.Add(_bmiField);
_pivotAnalysis.Add(_cmaxField);
var grouping = new FixedLimitsGroupingDefinition(_bmiField.Name);
grouping.SetLimits(new[] { 25d }.OrderBy(x => x));
grouping.AddItems(PopulationAnalysisHelperForSpecs.BMIGroups);
_bmiClass = new PopulationAnalysisGroupingField(grouping)
{
Name = "BMI class"
};
_pivotAnalysis.Add(_bmiClass);
_pivotAnalysis.SetPosition(_genderField, PivotArea.RowArea, 0);
_pivotAnalysis.SetPosition(_raceField, PivotArea.RowArea, 1);
_pivotAnalysis.SetPosition(_bmiClass, PivotArea.ColumnArea, 0);
_pivotAnalysis.SetPosition(_cmaxField, PivotArea.DataArea, 0);
_dimensionRepository = A.Fake <IDimensionRepository>();
_pivotResultCreator = A.Fake <IPivotResultCreator>();
sut = new BoxWhiskerChartDataCreator(_dimensionRepository, _pivotResultCreator);
}
private void updateToUniqueAreaPosition(IPopulationAnalysisField field, PivotArea area)
{
var fieldsOnArea = AllFieldsOn(area);
var firstAvailableFilterIndex = AllFieldsOn(PivotArea.FilterArea).Count;
fieldsOnArea.Each(f => SetPosition(f, PivotArea.FilterArea, firstAvailableFilterIndex++));
SetPosition(field, area, 0);
}
public virtual void SetPosition(IPopulationAnalysisField field, PivotPosition pivotPosition)
{
if (field == null)
{
return;
}
_fieldPositions[field] = pivotPosition;
}
protected override void Context()
{
base.Context();
_field = A.Fake <IPopulationAnalysisField>();
_namePresenter = A.Fake <INameTemplatePresenter>();
A.CallTo(_namePresenter).WithReturnType <bool>().Returns(false);
A.CallTo(() => _applicationController.Start <INameTemplatePresenter>()).Returns(_namePresenter);
}
protected override void Context()
{
base.Context();
_templatePresenter = A.Fake <ITemplatePresenter>();
_template = A.Fake <IPopulationAnalysisField>();
A.CallTo(() => _applicationController.Start <ITemplatePresenter>()).Returns(_templatePresenter);
A.CallTo(() => _templatePresenter.LoadFromTemplate <IPopulationAnalysisField>(TemplateType.PopulationAnalysisField)).Returns(new[] { _template });
}
private void updatePosition(IPopulationAnalysisField field, int index)
{
if (field == _nullField)
{
return;
}
_populationAnalysis.SetPosition(field, PivotArea.DataArea, index);
}
public virtual void Remove(IPopulationAnalysisField populationAnalysisField)
{
if (populationAnalysisField == null)
{
return;
}
_allPopulationAnalysisFields.Remove(populationAnalysisField);
}
protected override void Context()
{
base.Context();
_field1 = A.Fake <IPopulationAnalysisField>();
_field2 = A.Fake <IPopulationAnalysisField>();
_populationDataCollector = A.Fake <IPopulationDataCollector>();
_templatePopulationAnalysis = A.Fake <PopulationAnalysis>();
A.CallTo(() => _templatePopulationAnalysis.AllFields).Returns(new[] { _field1, _field2 });
A.CallTo(_templateTask).WithReturnType <PopulationAnalysis>().Returns(_templatePopulationAnalysis);
}
private void updateGroupingEnable(IPopulationAnalysisField populationAnalysisField)
{
if (populationAnalysisField == null)
{
_view.CreateGroupingButtonEnabled = false;
}
else
{
_view.CreateGroupingButtonEnabled = populationAnalysisField.IsAnImplementationOf <PopulationAnalysisDataField>();
}
}
protected override void Context()
{
base.Context();
_fields = new List <IPopulationAnalysisField>();
_target = A.Fake <IPopulationAnalysisField>();
sut.FieldsMoved += (o, e) =>
{
_presenter = o;
_args = e;
};
}
protected override async Task Context()
{
await base.Context();
_field1 = A.Fake <IPopulationAnalysisField>();
_field2 = A.Fake <IPopulationAnalysisField>();
_populationDataCollector = A.Fake <IPopulationDataCollector>();
_templatePopulationAnalysis = A.Fake <PopulationAnalysis>();
A.CallTo(() => _templatePopulationAnalysis.AllFields).Returns(new[] { _field1, _field2 });
A.CallTo(_templateTask).WithReturnType <Task <IReadOnlyList <PopulationAnalysis> > >().Returns(new[] { _templatePopulationAnalysis });
}
private void editOrRemoveFieldButtonClicked(EditorButton button, IPopulationAnalysisField field)
{
if (button.Index == _editButtonIndex)
{
_presenter.EditDerivedField(field.DowncastTo <PopulationAnalysisDerivedField>());
}
else
{
_presenter.RemoveField(field);
}
}
protected override void Context()
{
base.Context();
_field1 = A.Fake <IPopulationAnalysisField>();
_field2 = A.Fake <IPopulationAnalysisField>();
_target = A.Fake <IPopulationAnalysisField>();
_fields = new List <IPopulationAnalysisField> {
_field1, _field2
};
A.CallTo(() => _populationAnalysis.GetAreaIndex(_target)).Returns(3);
sut.StartAnalysis(_populationDataCollector, _populationAnalysis);
}
protected override void Context()
{
_applicationController = A.Fake<IApplicationController>();
_populationDataCollector = A.Fake<IPopulationDataCollector>();
_populationAnalysisFieldFactory = A.Fake<IPopulationAnalysisFieldFactory>();
_field = A.Fake<IPopulationAnalysisField>();
sut = new PopulationAnalysisGroupingFieldCreator(_applicationController, _populationAnalysisFieldFactory);
_groupingFieldPresenter = A.Fake<ICreatePopulationAnalysisGroupingFieldPresenter>();
A.CallTo(() => _applicationController.Start<ICreatePopulationAnalysisGroupingFieldPresenter>()).Returns(_groupingFieldPresenter);
}
protected override void Context()
{
base.Context();
_field = A.Fake <IPopulationAnalysisField>();
_namePresenter = A.Fake <INameTemplatePresenter>();
A.CallTo(_namePresenter).WithReturnType <bool>().Returns(true);
A.CallTo(() => _namePresenter.Name).Returns("NEW_NAME");
A.CallTo(() => _namePresenter.Description).Returns("DESCRIPTION");
A.CallTo(() => _applicationController.Start <INameTemplatePresenter>()).Returns(_namePresenter);
A.CallTo(() => _templateTaskQuery.SaveToTemplate(A <Template> ._))
.Invokes(x => _templateItem = x.GetArgument <Template>(0));
}
protected override void Context()
{
base.Context();
_field1 = A.Fake <IPopulationAnalysisField>();
_field2 = A.Fake <IPopulationAnalysisField>();
_fields = new List <IPopulationAnalysisField> {
_field1, _field2
};
sut.StartAnalysis(_populationDataCollector, _populationAnalysis);
A.CallTo(() => _eventPublisher.PublishEvent(A <FieldsMovedInPopulationAnalysisEvent> ._))
.Invokes(x => _event = x.GetArgument <FieldsMovedInPopulationAnalysisEvent>(0));
}
protected override void Context()
{
base.Context();
_selectedField = new PopulationAnalysisGroupingField(new NumberOfBinsGroupingDefinition("Field")
{
NumberOfBins = 5
});
sut.DerivedFieldSelected += (o, e) =>
{
_raised = true;
_derivedField = e.DerivedField;
};
}
protected override void Context()
{
base.Context();
_selectedField = new PopulationAnalysisParameterField {
ParameterPath = _parameterPath
};
sut.ParameterFieldSelected += (o, e) =>
{
_raised = true;
_selectedParameter = e.Parameter;
};
sut.AddParameter(_parameter);
}
protected override void Context()
{
base.Context();
_selectedField = new PopulationAnalysisCovariateField {
Covariate = "TOTO"
};
sut.CovariateFieldSelected += (o, e) =>
{
_raised = true;
_covariate = e.Covariate;
};
sut.AddParameter(_parameter);
}
public IGroupingDefinition CreateGrouping(IPopulationAnalysisField populationAnalysisField, IPopulationDataCollector populationDataCollector)
{
_populationAnalysisField = populationAnalysisField;
_populationDataCollector = populationDataCollector;
_groupingFieldDTO.AddUsedNames(populationAnalysisField.PopulationAnalysis.AllFields.Select(x => x.Name));
_view.Caption = PKSimConstants.UI.CreateGroupingForField(populationAnalysisField.Name);
//initialize the default grouping definition depending on the available groupings
_groupingFieldDTO.GroupingDefinitionItem = AvailableGroupings.First();
updateView();
_view.Display();
return(_view.Canceled ? null : _activePresenter.GroupingDefinition);
}
public PopulationAnalysisGroupingField CreateGroupingFieldFor(IPopulationAnalysisField populationAnalysisField, IPopulationDataCollector populationDataCollector)
{
using (var presenter = _applicationController.Start <ICreatePopulationAnalysisGroupingFieldPresenter>())
{
var groupingDefiniton = presenter.CreateGrouping(populationAnalysisField, populationDataCollector);
if (groupingDefiniton == null)
{
return(null);
}
return(_populationAnalysisFieldFactory.CreateGroupingField(groupingDefiniton, populationAnalysisField)
.WithName(presenter.FieldName));
}
}
public virtual bool Has(IPopulationAnalysisField populationAnalysisField)
{
if (populationAnalysisField == null)
{
return(false);
}
if (string.IsNullOrEmpty(populationAnalysisField.Id))
{
return(_allPopulationAnalysisFields.Contains(populationAnalysisField));
}
return(_allPopulationAnalysisFields.Any(x => string.Equals(x.Id, populationAnalysisField.Id)));
}
public override void FieldSelected(IPopulationAnalysisField populationAnalysisField)
{
base.FieldSelected(populationAnalysisField);
switch (populationAnalysisField)
{
case PopulationAnalysisParameterField parameterField:
ParameterFieldSelected(this, new ParameterFieldSelectedEventArgs(parameterFromField(parameterField), parameterField));
return;
case PopulationAnalysisCovariateField covariateField:
CovariateFieldSelected(this, new CovariateFieldSelectedEventArgs(covariateField.Covariate, covariateField));
return;
}
}
