protected override void Context()
{
sut = new PopulationAnalysisFlatTableCreator();
_populationDataCollector = A.Fake <PopulationSimulationComparison>();
_populationAnalysis = new PopulationPivotAnalysis();
_ageField = new PopulationAnalysisParameterField {
ParameterPath = "Path", Name = "Age"
};
_populationAnalysis.Add(_ageField);
//add derived field age class
var groupingDefinition = new FixedLimitsGroupingDefinition("Age");
groupingDefinition.SetLimits(new[] { 14d }.OrderBy(x => x));
groupingDefinition.AddItems(new[]
{
new GroupingItem {
Label = "Children", Color = Color.Blue
},
new GroupingItem {
Label = "Adults", Color = Color.Red
}
});
_ageClassField = new PopulationAnalysisGroupingField(groupingDefinition)
{
Name = "AgeClass"
};
_populationAnalysis.Add(_ageClassField);
_ageValues = new List <double> {
8d, 14d, 21d
};
_ageClassValues = new[] { "Children", "Adults", "Adults" };
}
private void convertPKAnalysisField(PopulationAnalysis populationAnalysis)
{
populationAnalysis?.All <PopulationAnalysisPKParameterField>().Each(pkField =>
{
pkField.PKParameter = _converter730To90.ConvertPKParameterName(pkField.PKParameter);
});
}
protected override void Context()
{
base.Context();
_populationDataCollector = A.Fake <IPopulationDataCollector>();
_templatePopulationAnalysis = new PopulationPivotAnalysis();
A.CallTo(_templateTask).WithReturnType <PopulationAnalysis>().Returns(_templatePopulationAnalysis);
}
protected override void Context()
{
_populationAnalysis = new PopulationPivotAnalysis();
_anotherField = new PopulationAnalysisParameterField().WithName("NAME");
sut = new PopulationAnalysisParameterField();
_populationAnalysis.Add(_anotherField);
}
public void StartAnalysis(IPopulationDataCollector populationDataCollector, PopulationAnalysis populationAnalysis)
{
_boxWiskerAnalysis = populationAnalysis.DowncastTo <PopulationBoxWhiskerAnalysis>();
_multipleNumericFieldsPresenter.StartAnalysis(populationDataCollector, populationAnalysis);
_dto.ShowOutliers = _boxWiskerAnalysis.ShowOutliers;
_view.BindTo(_dto);
}
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();
_populationAnalyses = A.Fake <PopulationAnalysis>();
_derivedField = A.Fake <PopulationAnalysisGroupingField>();
A.CallTo(() => _populationAnalyses.FieldByName(_fieldName)).Returns(_derivedField);
sut.PopulationAnalysis = _populationAnalyses;
}
protected override void Context()
{
base.Context();
_populationPivotAnalysis = new PopulationPivotAnalysis();
_populationDataCollector = A.Fake <IPopulationDataCollector>();
_derivedField = A.Fake <PopulationAnalysisDerivedField>().WithName("Toto");
sut.StartAnalysis(_populationDataCollector, _populationPivotAnalysis);
}
public void should_return_false_if_the_grouping_definition_has_no_fields()
{
_populationAnalyses = A.Fake <PopulationAnalysis>();
sut = new PopulationAnalysisGroupingField(new FixedLimitsGroupingDefinition(null))
{
Name = _sutName, PopulationAnalysis = _populationAnalyses
};
sut.IsDerivedTypeFor <PopulationAnalysisParameterField>().ShouldBeFalse();
}
protected override void Context()
{
base.Context();
_populationAnalysis = A.Fake <PopulationAnalysis>();
_derivedField = A.Fake <PopulationAnalysisDerivedField>().WithName("Toto");
_dataTable = new DataTable();
_dataTable.AddColumn <string>(_derivedField.Name);
A.CallTo(_flatTableCreator).WithReturnType <DataTable>().Returns(_dataTable);
}
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 convertCovariates(PopulationAnalysis populationAnalysis)
{
if (!(populationAnalysis.FieldByName(ConverterConstants.Population.RACE) is PopulationAnalysisCovariateField raceCovariateField))
{
return;
}
populationAnalysis.RenameField(ConverterConstants.Population.RACE, Constants.Population.POPULATION);
raceCovariateField.Covariate = Constants.Population.POPULATION;
}
protected override void Context()
{
base.Context();
_populationAnalysis = new PopulationPivotAnalysis();
_dataField = A.Fake <PopulationAnalysisDataField>().WithName("DATA");
_derivedField = A.Fake <PopulationAnalysisDerivedField>().WithName("DERIVED");
A.CallTo(_templateTask).WithReturnType <PopulationAnalysisDerivedField>().Returns(_derivedField);
_populationAnalysis.Add(_dataField);
}
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 });
}
public void StartAnalysis(IPopulationDataCollector populationDataCollector, PopulationAnalysis populationAnalysis)
{
_populationAnalysis = populationAnalysis.DowncastTo <PopulationStatisticalAnalysis>();
_allOutputsPresenter.UpdateColumnSettings(populationDataCollector);
var allOutputs = _outputsRetriever.OutputsFrom(populationDataCollector);
_allOutputsPresenter.Edit(allOutputs);
_selectedOutputsPresenter.StartAnalysis(populationDataCollector, populationAnalysis);
_statisticsSelectionPresenter.StartAnalysis(populationDataCollector, populationAnalysis);
addDefaultSelectionIfRequired(allOutputs);
_view.BindTo(_populationAnalysis);
}
private void updateUsedField(PopulationAnalysis populationAnalysis, PopulationSimulation populationSimulation)
{
if (populationAnalysis == null)
{
return;
}
foreach (var quantityField in populationAnalysis.All <IQuantityField>().Where(field => !populationHasOutputFor(populationSimulation, field.QuantityPath)).ToList())
{
removeFieldsFromAnalysis(quantityField, populationAnalysis);
}
}
private TPopulationAnalysis convertedAnalysis <TPopulationAnalysis>(PopulationAnalysis templatePopulationAnalysis) where TPopulationAnalysis : PopulationAnalysis, new()
{
//same type? No need to convert the template. It can be use as is
if (templatePopulationAnalysis.GetType() == typeof(TPopulationAnalysis))
{
return(templatePopulationAnalysis.DowncastTo <TPopulationAnalysis>());
}
var typedAnalysis = new TPopulationAnalysis();
typedAnalysis.UpdatePropertiesFrom(templatePopulationAnalysis, _cloner);
return(typedAnalysis);
}
private void synchronizeCovariates(PopulationAnalysis populationAnalysis, IPopulationDataCollector populationDataCollector, List <string> allErrors)
{
//ToList() because we are removing in the iteration
foreach (var covariateField in populationAnalysis.AllFields.OfType <PopulationAnalysisCovariateField>().ToList())
{
if (populationDataCollector.AllCovariateNames.Contains(covariateField.Covariate))
{
continue;
}
populationAnalysis.Remove(covariateField);
allErrors.Add(PKSimConstants.Error.CovariateNotFoundWillBeRemovedFromAnalysis(covariateField.Covariate));
}
}
protected override void Context()
{
base.Context();
_quantity1 = A.Fake <IQuantity>();
_quantity2 = A.Fake <IQuantity>();
_populationDataCollector = A.Fake <IPopulationDataCollector>();
_templatePopulationAnalysis = A.Fake <PopulationAnalysis>();
A.CallTo(_templateTask).WithReturnType <PopulationAnalysis>().Returns(_templatePopulationAnalysis);
_pathCacheQuantity = new PathCacheForSpecs <IQuantity> {
{ "Path1", _quantity1 }, { "Path2", _quantity2 }
};
A.CallTo(() => _entitiesInContainerRetriever.OutputsFrom(_populationDataCollector)).Returns(_pathCacheQuantity);
A.CallTo(() => _keyPathMapper.MapFrom("Path1", _quantity1.QuantityType, true)).Returns(new KeyPathMap(path: "Path"));
A.CallTo(() => _keyPathMapper.MapFrom("Path2", _quantity2.QuantityType, true)).Returns(new KeyPathMap(path: "Path"));
}
private void synchronizeParameters(PopulationAnalysis populationAnalysis, IPopulationDataCollector populationDataCollector, List <string> allErrors)
{
var allParameters = _entitiesInContainerRetriever.ParametersFrom(populationDataCollector);
//ToList() because we are removing in the iteration
foreach (var parameterField in populationAnalysis.AllFields.OfType <PopulationAnalysisParameterField>().ToList())
{
if (allParameters.Contains(parameterField.ParameterPath))
{
continue;
}
populationAnalysis.Remove(parameterField);
allErrors.Add(PKSimConstants.Error.ParameterNotFoundWillBeRemovedFromAnalysis(parameterField.ParameterPath));
}
}
protected override void Context()
{
_groupingDefinitionPresenterMapper = A.Fake <IGroupingDefinitionToGroupingDefinitionPresenterMapper>();
_view = A.Fake <ICreatePopulationAnalysisGroupingFieldView>();
_eventPublisher = A.Fake <IEventPublisher>();
_field = A.Fake <PopulationAnalysisNumericField>();
_populationAnalysis = A.Fake <PopulationAnalysis>();
_field.PopulationAnalysis = _populationAnalysis;
A.CallTo(() => _populationAnalysis.AllFields).Returns(_existingFields);
_populationDataCollector = A.Fake <IPopulationDataCollector>();
sut = new CreatePopulationAnalysisGroupingFieldPresenter(_view, _groupingDefinitionPresenterMapper, _eventPublisher);
A.CallTo(() => _view.BindTo(A <GroupingFieldDTO> ._))
.Invokes(x => _groupingFieldDTO = x.GetArgument <GroupingFieldDTO>(0));
}
private bool synchronizeFieldsWithPopulation(PopulationAnalysis populationAnalysis, IPopulationDataCollector populationDataCollector)
{
var allErrors = new List <string>();
synchronizeOutputs(populationAnalysis, populationDataCollector, allErrors);
synchronizeCovariates(populationAnalysis, populationDataCollector, allErrors);
synchronizeParameters(populationAnalysis, populationDataCollector, allErrors);
synchronizePKParameters(populationAnalysis, populationDataCollector, allErrors);
if (!allErrors.Any())
{
return(true);
}
allErrors.Insert(0, PKSimConstants.Error.ErrorWhileImportingPopulationAnalyses);
var result = _dialogCreator.MessageBoxYesNo(allErrors.ToString("\n"), PKSimConstants.UI.ImportAnyway, PKSimConstants.UI.CancelButton);
return(result == ViewResult.Yes);
}
protected override void Context()
{
_populationDataCollector = A.Fake <IPopulationDataCollector>();
_populationAnalysis = A.Fake <PopulationAnalysis>();
A.CallTo(() => _populationDataCollector.NumberOfItems).Returns(100);
_numericField = A.Fake <PopulationAnalysisNumericField>();
A.CallTo(() => _populationAnalysis.FieldByName(_fieldName)).Returns(_numericField);
_fixedLimitsGroupingDefinition = new FixedLimitsGroupingDefinition(_fieldName);
_fixedLimitsGroupingDefinition.AddItems(PopulationAnalysisHelperForSpecs.AgeGroups);
_fixedLimitsGroupingDefinition.SetLimits((new[] { 14D, 18D }).OrderBy(x => x));
_dt = createData();
A.CallTo(() => _numericField.GetValues(_populationDataCollector)).Returns(_dt.AllValuesInColumn <double>(_fieldName).ToList());
sut = new PopulationAnalysisGroupingField(_fixedLimitsGroupingDefinition)
{
Name = _sutName
};
}
private void synchronizeOutputs(PopulationAnalysis populationAnalysis, IPopulationDataCollector populationDataCollector, List <string> allErrors)
{
var statiscalAnalsysis = populationAnalysis as PopulationStatisticalAnalysis;
var keyPathCache = outputKeyPathCacheFor(populationDataCollector);
foreach (var outputField in populationAnalysis.AllFields.OfType <PopulationAnalysisOutputField>().ToList())
{
if (statiscalAnalsysis == null)
{
populationAnalysis.Remove(outputField);
allErrors.Add(PKSimConstants.Error.OutputFieldCannotBeUsedInAnalysis(outputField.Name));
continue;
}
if (fieldForOutputWasRemoved(outputField, keyPathCache, populationAnalysis, allErrors))
{
continue;
}
}
}
public PopulationAnalysisDerivedField LoadDerivedFieldFor(PopulationAnalysis populationAnalysis, PopulationAnalysisDataField populationAnalysisDataField)
{
var field = _templateTask.LoadFromTemplate <PopulationAnalysisDerivedField>(TemplateType.PopulationAnalysisField);
if (field == null)
{
return(null);
}
//validate data type
if (!field.CanBeUsedFor(populationAnalysisDataField.DataType))
{
throw new PKSimException(PKSimConstants.Error.DerivedFieldCannotBeUsedForFieldOfType(field.Name, populationAnalysisDataField.Name, populationAnalysisDataField.DataType));
}
//Rename referenced once loaded
var groupingField = field as PopulationAnalysisGroupingField;
if (groupingField != null)
{
if (!validateReferenceFieldInGrouping(populationAnalysisDataField, groupingField))
{
return(null);
}
}
//rename field if required
if (populationAnalysis.Has(field.Name))
{
var name = renameFieldAfterImport(populationAnalysis, field);
if (string.IsNullOrEmpty(name))
{
return(null);
}
field.Name = name;
}
return(field);
}
protected override void Context()
{
_view = A.Fake <INumberOfBinsGroupingView>();
_populationDataCollector = A.Fake <IPopulationDataCollector>();
_populationAnalysis = new PopulationPivotAnalysis();
_field = A.Fake <PopulationAnalysisParameterField>().WithName("Field");
A.CallTo(() => _field.CanBeUsedForGroupingIn(_populationDataCollector)).Returns(true);
A.CallTo(() => _field.GetValues(_populationDataCollector)).Returns(_values);
_populationAnalysis.Add(_field);
_groupingLabelGenerator = A.Fake <IGroupingLabelGenerator>();
_colorGradientGenerator = A.Fake <IColorGradientGenerator>();
sut = new NumberOfBinsGroupingPresenter(_view, _groupingLabelGenerator, _colorGradientGenerator);
//standard action for all tests
_dimension = A.Fake <IDimension>();
_unit = A.Fake <Unit>();
_field.Dimension = _dimension;
_field.DisplayUnit = _unit;
A.CallTo(() => _view.BindTo(A <BinSizeGroupingDTO> ._))
.Invokes(x => _dto = x.GetArgument <BinSizeGroupingDTO>(0));
}
private void synchronizePKParameters(PopulationAnalysis populationAnalysis, IPopulationDataCollector populationDataCollector, List <string> allErrors)
{
//path where compound name has been removed
var keyPathCache = outputKeyPathCacheFor(populationDataCollector);
foreach (var pkParameterField in populationAnalysis.AllFields.OfType <PopulationAnalysisPKParameterField>().ToList())
{
if (fieldForOutputWasRemoved(pkParameterField, keyPathCache, populationAnalysis, allErrors))
{
continue;
}
var path = pathFrom(pkParameterField.QuantityPath, pkParameterField.QuantityType);
//quantity was found. Yet it's not over. We need to verify that the pk parameter is also available
pkParameterField.QuantityPath = keyPathCache[path];
if (!populationDataCollector.HasPKParameterFor(pkParameterField.QuantityPath, pkParameterField.PKParameter))
{
populationAnalysis.Remove(pkParameterField);
allErrors.Add(PKSimConstants.Error.PKParameterWasNotCalculatedForQuantity(pkParameterField.PKParameter, pkParameterField.QuantityPath));
}
}
}
public void StartAnalysis(IPopulationDataCollector populationDataCollector, PopulationAnalysis populationAnalysis)
{
_populationPivotAnalysis = populationAnalysis.DowncastTo<PopulationPivotAnalysis>();
_populationDataCollector = populationDataCollector;
_fieldSelectionPresenter.StartAnalysis(populationDataCollector, _populationPivotAnalysis);
}
public void Plot(IPopulationDataCollector populationDataCollector, PopulationAnalysisDerivedField derivedField, PopulationAnalysis populationAnalysis)
{
var fields = new List <IPopulationAnalysisField>(populationAnalysis.AllFieldsReferencedBy(derivedField))
{
derivedField
};
plotDiscreteData(populationDataCollector, fields, derivedField);
}
public void StartAnalysis(IPopulationDataCollector populationDataCollector, PopulationAnalysis populationAnalysis)
{
_populationAnalysis = populationAnalysis.DowncastTo <PopulationPivotAnalysis>();
}
