public void ConstructorWithData_Always_ExpectedPropertiesSet()
{
// Setup
var mocks = new MockRepository();
var assessmentSection = mocks.Stub <IAssessmentSection>();
mocks.ReplayAll();
var surfaceLines = new[]
{
new PipingSurfaceLine(string.Empty)
};
PipingStochasticSoilModel[] soilModels =
{
PipingStochasticSoilModelTestFactory.CreatePipingStochasticSoilModel()
};
var calculation = new SemiProbabilisticPipingCalculationScenario();
var failureMechanism = new PipingFailureMechanism();
var parent = new CalculationGroup();
// Call
var presentationObject = new SemiProbabilisticPipingCalculationScenarioContext(calculation,
parent,
surfaceLines,
soilModels,
failureMechanism,
assessmentSection);
// Assert
Assert.IsInstanceOf <PipingContext <SemiProbabilisticPipingCalculationScenario> >(presentationObject);
Assert.IsInstanceOf <ICalculationContext <SemiProbabilisticPipingCalculationScenario, PipingFailureMechanism> >(presentationObject);
Assert.AreSame(calculation, presentationObject.WrappedData);
Assert.AreSame(parent, presentationObject.Parent);
Assert.AreSame(surfaceLines, presentationObject.AvailablePipingSurfaceLines);
Assert.AreSame(soilModels, presentationObject.AvailableStochasticSoilModels);
Assert.AreSame(failureMechanism, presentationObject.FailureMechanism);
Assert.AreSame(assessmentSection, presentationObject.AssessmentSection);
mocks.VerifyAll();
}
public void Export_NestedCalculationGroupWithoutCalculations_FolderNotExportedAndReturnsTrue()
{
// Setup
string folderPath = TestHelper.GetScratchPadPath($"{nameof(MacroStabilityInwardsCalculationGroupExporterTest)}.{nameof(Export_CalculationGroupsWithSameName_WritesFilesAndReturnsTrue)}");
Directory.CreateDirectory(folderPath);
string filePath = Path.Combine(folderPath, "export.zip");
var rootGroup = new CalculationGroup
{
Name = "root"
};
var nestedGroup1 = new CalculationGroup
{
Name = "group1"
};
rootGroup.Children.Add(nestedGroup1);
var exporter = new MacroStabilityInwardsCalculationGroupExporter(rootGroup, new GeneralMacroStabilityInwardsInput(),
new PersistenceFactory(), filePath, fileExtension,
c => AssessmentSectionTestHelper.GetTestAssessmentLevel());
try
{
using (new MacroStabilityInwardsCalculatorFactoryConfig())
{
// Call
bool exportResult = exporter.Export();
// Assert
Assert.IsTrue(exportResult);
Assert.IsFalse(File.Exists(filePath));
}
}
finally
{
DirectoryHelper.TryDelete(folderPath);
}
}
public void Import_UseForeshoreFalseButProfileWithoutForeshoreGeometry_DataAddedToModel()
{
// Setup
string filePath = Path.Combine(path, "validConfigurationCalculationUseForeshoreFalseForeshoreProfileWithoutGeometry.xml");
var calculationGroup = new CalculationGroup();
var foreshoreProfile = new TestForeshoreProfile("Voorlandprofiel");
var importer = new TestWaveConditionsCalculationConfigurationImporter(
filePath,
calculationGroup,
Enumerable.Empty <HydraulicBoundaryLocation>(),
new[]
{
foreshoreProfile
},
new FailureMechanismContribution(0.1, 0.1),
Enumerable.Empty <HydraulicBoundaryLocationCalculationsForTargetProbability>());
// Call
bool successful = importer.Import();
// Assert
Assert.IsTrue(successful);
var expectedCalculation = new TestTargetTestWaveConditionsCalculation
{
Name = "Berekening 1",
InputParameters =
{
UseForeshore = false,
Orientation = (RoundedDouble)0,
ForeshoreProfile = foreshoreProfile,
WaterLevelType = WaveConditionsInputWaterLevelType.MaximumAllowableFloodingProbability
}
};
Assert.AreEqual(1, calculationGroup.Children.Count);
AssertWaveConditionsCalculation(expectedCalculation, (ICalculation <WaveConditionsInput>)calculationGroup.Children[0]);
}
/// <summary>
/// Creates a structure of <see cref="CalculationGroup"/> and <see cref="IPipingCalculationScenario{TPipingInput}"/>
/// based on combination of the <paramref name="surfaceLines"/> and the <paramref name="soilModels"/>.
/// </summary>
/// <param name="surfaceLines">Surface lines to generate the structure for and to use to configure
/// <see cref="IPipingCalculationScenario{TPipingInput}"/> with.</param>
/// <param name="generateSemiProbabilistic">Indicator whether to generate <see cref="SemiProbabilisticPipingCalculationScenario"/>.</param>
/// <param name="generateProbabilistic">Indicator whether to generate <see cref="ProbabilisticPipingCalculationScenario"/>.</param>
/// <param name="soilModels">The soil models from which profiles are taken to configure
/// <see cref="IPipingCalculationScenario{TPipingInput}"/> with.</param>
/// <returns>A structure of <see cref="ICalculationBase"/> matching combinations of <paramref name="surfaceLines"/> and
/// profiles of intersecting <paramref name="soilModels"/>.</returns>
/// <exception cref="ArgumentNullException">Throw when <paramref name="surfaceLines"/> or <paramref name="soilModels"/>
/// is <c>null</c>.</exception>
public static IEnumerable <ICalculationBase> GenerateCalculationItemsStructure(IEnumerable <PipingSurfaceLine> surfaceLines,
bool generateSemiProbabilistic,
bool generateProbabilistic,
IEnumerable <PipingStochasticSoilModel> soilModels)
{
if (surfaceLines == null)
{
throw new ArgumentNullException(nameof(surfaceLines));
}
if (soilModels == null)
{
throw new ArgumentNullException(nameof(soilModels));
}
var groups = new List <CalculationGroup>();
if (!generateSemiProbabilistic && !generateProbabilistic)
{
return(groups);
}
foreach (PipingSurfaceLine surfaceLine in surfaceLines)
{
CalculationGroup group = CreateCalculationGroup(surfaceLine, generateSemiProbabilistic, generateProbabilistic, soilModels);
if (group.GetCalculations().Any())
{
groups.Add(group);
}
else
{
log.WarnFormat(
Resources.PipingCalculationConfigurationHelper_GenerateCalculationsStructure_No_PipingSoilProfile_found_for_PipingSurfaceLine_0_skipped,
surfaceLine.Name);
}
}
return(groups);
}
public void Create_GroupWithoutChildren_CreateEntity(int order)
{
// Setup
const string name = "blaballab";
var group = new CalculationGroup
{
Name = name
};
var registry = new PersistenceRegistry();
// Call
CalculationGroupEntity entity = group.Create(registry, order);
// Assert
Assert.AreEqual(name, entity.Name);
Assert.AreEqual(order, entity.Order);
CollectionAssert.IsEmpty(entity.CalculationGroupEntity1);
CollectionAssert.IsEmpty(entity.FailureMechanismEntities);
Assert.IsNull(entity.CalculationGroupEntity2);
}
public void Import_ScenarioWithRelevantSet_DataAddedToModel()
{
// Setup
string filePath = Path.Combine(importerPath, "validConfigurationScenarioRelevantOnly.xml");
var calculationGroup = new CalculationGroup();
const double norm = 0.01;
var importer = new GrassCoverErosionInwardsCalculationConfigurationImporter(
filePath,
calculationGroup,
new FailureMechanismContribution(norm, 0.001),
Enumerable.Empty <HydraulicBoundaryLocation>(),
Enumerable.Empty <DikeProfile>());
// Call
var successful = false;
void Call() => successful = importer.Import();
// Assert
TestHelper.AssertLogMessageIsGenerated(Call, $"Gegevens zijn geïmporteerd vanuit bestand '{filePath}'.", 1);
Assert.IsTrue(successful);
var expectedCalculation = new GrassCoverErosionInwardsCalculationScenario
{
Name = "Calculation",
IsRelevant = false,
InputParameters =
{
DikeHeightTargetProbability = norm,
OvertoppingRateTargetProbability = norm
}
};
Assert.AreEqual(1, calculationGroup.Children.Count);
AssertCalculationScenario(expectedCalculation, (GrassCoverErosionInwardsCalculationScenario)calculationGroup.Children[0]);
}
public void Export_CalculationExportReturnsFalse_LogsErrorAndReturnsFalse(CalculationGroup calculationGroup)
{
// Setup
string folderPath = TestHelper.GetScratchPadPath($"{nameof(MacroStabilityInwardsCalculationGroupExporterTest)}.{nameof(Export_CalculationExportReturnsFalse_LogsErrorAndReturnsFalse)}");
Directory.CreateDirectory(folderPath);
string filePath = Path.Combine(folderPath, "export.zip");
using (new MacroStabilityInwardsCalculatorFactoryConfig())
{
var persistenceFactory = new MacroStabilityInwardsTestPersistenceFactory
{
ThrowException = true
};
var exporter = new MacroStabilityInwardsCalculationGroupExporter(calculationGroup, new GeneralMacroStabilityInwardsInput(),
persistenceFactory, filePath, fileExtension,
c => AssessmentSectionTestHelper.GetTestAssessmentLevel());
try
{
// Call
var exportResult = true;
void Call() => exportResult = exporter.Export();
// Assert
ICalculation calculation = calculationGroup.GetCalculations().First();
var expectedMessage = $"Er is een onverwachte fout opgetreden tijdens het exporteren van '{calculation.Name}'. Er is geen D-GEO Suite Stability Project geëxporteerd.";
TestHelper.AssertLogMessageWithLevelIsGenerated(Call, new Tuple <string, LogLevelConstant>(expectedMessage, LogLevelConstant.Error));
Assert.IsFalse(exportResult);
Assert.IsFalse(File.Exists(filePath));
}
finally
{
DirectoryHelper.TryDelete(folderPath);
}
}
}
public void Import_ValidConfigurationOnlyCriticalFlowRateStandardDeviationSet_DataAddedToModel()
{
// Setup
string filePath = Path.Combine(importerPath, "validConfigurationCriticalFlowRateStandardDeviationOnly.xml");
var calculationGroup = new CalculationGroup();
const double norm = 0.01;
var importer = new GrassCoverErosionInwardsCalculationConfigurationImporter(
filePath,
calculationGroup,
new FailureMechanismContribution(norm, 0.001),
Enumerable.Empty <HydraulicBoundaryLocation>(),
Enumerable.Empty <DikeProfile>());
// Call
bool successful = importer.Import();
// Assert
Assert.IsTrue(successful);
var expectedCalculation = new GrassCoverErosionInwardsCalculationScenario
{
Name = "Berekening 1",
InputParameters =
{
CriticalFlowRate =
{
StandardDeviation = (RoundedDouble)1.1
},
DikeHeightTargetProbability = norm,
OvertoppingRateTargetProbability = norm
}
};
Assert.AreEqual(1, calculationGroup.Children.Count);
AssertCalculationScenario(expectedCalculation, (GrassCoverErosionInwardsCalculationScenario)calculationGroup.Children[0]);
}
public void CreateCalculationActivitiesForCalculationGroup_WithValidCalculations_ReturnsGrassCoverErosionInwardsCalculationActivitiesWithParametersSet()
{
// Setup
var failureMechanism = new GrassCoverErosionInwardsFailureMechanism();
var mocks = new MockRepository();
IAssessmentSection assessmentSection = AssessmentSectionTestHelper.CreateAssessmentSectionStub(failureMechanism,
mocks,
validFilePath);
mocks.ReplayAll();
GrassCoverErosionInwardsCalculation calculation1 = CreateValidCalculation();
GrassCoverErosionInwardsCalculation calculation2 = CreateValidCalculation();
var calculations = new CalculationGroup
{
Children =
{
calculation1,
calculation2
}
};
// Call
IEnumerable <CalculatableActivity> activities = GrassCoverErosionInwardsCalculationActivityFactory.CreateCalculationActivities(
calculations, failureMechanism, assessmentSection);
// Assert
CollectionAssert.AllItemsAreInstancesOfType(activities, typeof(GrassCoverErosionInwardsCalculationActivity));
Assert.AreEqual(2, activities.Count());
HydraulicBoundaryDatabase hydraulicBoundaryDatabase = assessmentSection.HydraulicBoundaryDatabase;
AssertGrassCoverErosionInwardsCalculationActivity(activities.First(), calculation1, hydraulicBoundaryDatabase);
AssertGrassCoverErosionInwardsCalculationActivity(activities.ElementAt(1), calculation2, hydraulicBoundaryDatabase);
mocks.VerifyAll();
}
/// <summary>
/// Creates a new instance of <see cref="PipingScenariosView"/>.
/// </summary>
/// <param name="calculationGroup">The <see cref="CalculationGroup"/>
/// to get the calculations from.</param>
/// <param name="failureMechanism">The <see cref="PipingFailureMechanism"/>
/// to get the sections from.</param>
/// <param name="assessmentSection">The assessment section the scenarios belong to.</param>
/// <exception cref="ArgumentNullException">Thrown when any parameter
/// is <c>null</c>.</exception>
public PipingScenariosView(CalculationGroup calculationGroup, PipingFailureMechanism failureMechanism, IAssessmentSection assessmentSection)
{
if (calculationGroup == null)
{
throw new ArgumentNullException(nameof(calculationGroup));
}
if (failureMechanism == null)
{
throw new ArgumentNullException(nameof(failureMechanism));
}
if (assessmentSection == null)
{
throw new ArgumentNullException(nameof(assessmentSection));
}
this.calculationGroup = calculationGroup;
this.failureMechanism = failureMechanism;
this.assessmentSection = assessmentSection;
InitializeObservers();
InitializeComponent();
InitializeCombobox();
InitializeWarningIcon();
checkedRadioButton = radioButtonSemiProbabilistic;
InitializeListBox();
InitializeDataGridView();
UpdateSectionsListBox();
UpdateDataGridViewDataSource();
UpdateVisibility();
}
public void ButtonGenerateCalculations_StructuresPresent_ButtonEnabled()
{
// Setup
var mocks = new MockRepository();
var assessmentSection = mocks.Stub <IAssessmentSection>();
ConfigureHydraulicBoundaryDatabase(assessmentSection);
mocks.ReplayAll();
ClosingStructuresFailureMechanism failureMechanism = ConfigureFailureMechanism();
CalculationGroup calculationGroup = ConfigureCalculationGroup(failureMechanism, assessmentSection);
ShowCalculationsView(calculationGroup, failureMechanism, assessmentSection);
var button = (Button) new ControlTester("generateButton").TheObject;
// Call
bool state = button.Enabled;
// Assert
Assert.IsTrue(state);
mocks.VerifyAll();
}
public void ConstructorWithData_Always_ExpectedPropertiesSet()
{
// Setup
var mocksRepository = new MockRepository();
var assessmentSection = mocksRepository.Stub <IAssessmentSection>();
mocksRepository.ReplayAll();
var calculation = new StructuresCalculationScenario <HeightStructuresInput>();
var failureMechanism = new HeightStructuresFailureMechanism();
var parent = new CalculationGroup();
// Call
var context = new HeightStructuresCalculationScenarioContext(calculation, parent, failureMechanism, assessmentSection);
// Assert
Assert.IsInstanceOf <StructuresCalculationScenarioContext <HeightStructuresInput, HeightStructuresFailureMechanism> >(context);
Assert.AreSame(calculation, context.WrappedData);
Assert.AreSame(parent, context.Parent);
Assert.AreSame(failureMechanism, context.FailureMechanism);
Assert.AreSame(assessmentSection, context.AssessmentSection);
mocksRepository.VerifyAll();
}
public void CalculationsView_EditValueInvalid_ShowsErrorTooltip(string newValue, int cellIndex)
{
// Setup
var mocks = new MockRepository();
var assessmentSection = mocks.Stub <IAssessmentSection>();
ConfigureHydraulicBoundaryDatabase(assessmentSection);
mocks.ReplayAll();
ClosingStructuresFailureMechanism failureMechanism = ConfigureFailureMechanism();
CalculationGroup calculationGroup = ConfigureCalculationGroup(failureMechanism, assessmentSection);
ShowCalculationsView(calculationGroup, failureMechanism, assessmentSection);
var dataGridView = (DataGridView) new ControlTester("dataGridView").TheObject;
// Call
dataGridView.Rows[0].Cells[cellIndex].Value = newValue;
// Assert
Assert.AreEqual("De tekst moet een getal zijn.", dataGridView.Rows[0].ErrorText);
mocks.VerifyAll();
}
public void IsEnabled_CalculationWithOutput_ReturnTrue()
{
// Setup
var assessmentSection = mocks.Stub <IAssessmentSection>();
mocks.ReplayAll();
var failureMechanism = new StabilityStoneCoverFailureMechanism();
var calculationGroup = new CalculationGroup();
calculationGroup.Children.Add(new StabilityStoneCoverWaveConditionsCalculation
{
Output = StabilityStoneCoverWaveConditionsOutputTestFactory.Create()
});
var context = new StabilityStoneCoverCalculationGroupContext(calculationGroup, null, failureMechanism, assessmentSection);
// Call
bool isEnabled = info.IsEnabled(context);
// Assert
Assert.IsTrue(isEnabled);
}
public void Children_RemoveCalculationGroup_CalculationRemovedFromCollection(int index)
{
// Setup
var existingGroup = new CalculationGroup();
var groupToInsert = new CalculationGroup();
var group = new CalculationGroup();
group.Children.Add(existingGroup);
// Call
group.Children.Insert(index, groupToInsert);
// Assert
Assert.AreEqual(2, group.Children.Count);
Assert.AreSame(groupToInsert, group.Children[index]);
CollectionAssert.AreEquivalent(new[]
{
groupToInsert,
existingGroup
}, group.Children,
"Already existing items should have remained in collection and new item should be added.");
}
public void FailureMechanismResultView_EditValueValid_DoNotShowErrorToolTipAndEditValue(double newValue, int cellIndex)
{
// Setup
var mocks = new MockRepository();
var assessmentSection = mocks.Stub <IAssessmentSection>();
ConfigureHydraulicBoundaryDatabase(assessmentSection);
mocks.ReplayAll();
ClosingStructuresFailureMechanism failureMechanism = ConfigureFailureMechanism();
CalculationGroup calculationGroup = ConfigureCalculationGroup(failureMechanism, assessmentSection);
ShowCalculationsView(calculationGroup, failureMechanism, assessmentSection);
var dataGridView = (DataGridView) new ControlTester("dataGridView").TheObject;
// Call
dataGridView.Rows[0].Cells[cellIndex].Value = (RoundedDouble)newValue;
// Assert
Assert.IsEmpty(dataGridView.Rows[0].ErrorText);
mocks.VerifyAll();
}
public void CloseForData_AssessmentSectionRemovedWithoutFailureMechanism_ReturnsFalse()
{
// Setup
var calculationsGroup = new CalculationGroup();
var mocks = new MockRepository();
var assessmentSection = mocks.Stub <IAssessmentSection>();
assessmentSection.Stub(asm => asm.GetFailureMechanisms()).Return(new IFailureMechanism[0]);
mocks.ReplayAll();
using (var view = new MacroStabilityInwardsScenariosView(calculationsGroup, new MacroStabilityInwardsFailureMechanism()))
{
// Call
bool closeForData = info.CloseForData(view, assessmentSection);
// Assert
Assert.IsFalse(closeForData);
}
mocks.VerifyAll();
}
public void IsEnabled_CalculationWithOrWithoutOutputInSubFolder_ReturnExpectedEnabledState(bool hasOutput)
{
// Setup
var assessmentSection = mocks.Stub <IAssessmentSection>();
mocks.ReplayAll();
var failureMechanism = new GrassCoverErosionOutwardsFailureMechanism();
var calculationGroup = new CalculationGroup();
GrassCoverErosionOutwardsWaveConditionsOutput grassCoverErosionOutwardsWaveConditionsOutput = null;
if (hasOutput)
{
grassCoverErosionOutwardsWaveConditionsOutput = GrassCoverErosionOutwardsWaveConditionsOutputTestFactory.Create();
}
calculationGroup.Children.Add(
new CalculationGroup
{
Children =
{
new GrassCoverErosionOutwardsWaveConditionsCalculation
{
Output = grassCoverErosionOutwardsWaveConditionsOutput
}
}
});
var context = new GrassCoverErosionOutwardsCalculationGroupContext(calculationGroup, null, failureMechanism, assessmentSection);
// Call
bool isEnabled = info.IsEnabled(context);
// Assert
Assert.AreEqual(hasOutput, isEnabled);
}
public void Import_StochastsWithStandardDeviationSet_DataAddedToModel()
{
// Setup
string filePath = TestHelper.GetScratchPadPath(nameof(Import_StochastsWithStandardDeviationSet_DataAddedToModel));
SetCalculationType(Path.Combine(importerPath, "validConfigurationStochastsStandardDeviationOnly.xml"), filePath);
var calculationGroup = new CalculationGroup();
var pipingFailureMechanism = new PipingFailureMechanism();
var importer = new PipingCalculationConfigurationImporter(
filePath, calculationGroup, Enumerable.Empty <HydraulicBoundaryLocation>(), pipingFailureMechanism);
try
{
// Call
var successful = false;
void Call() => successful = importer.Import();
// Assert
TestHelper.AssertLogMessageIsGenerated(Call, $"Gegevens zijn geïmporteerd vanuit bestand '{filePath}'.", 1);
Assert.IsTrue(successful);
TCalculationScenario expectedCalculation = CreateCalculationScenario();
expectedCalculation.Name = "Calculation";
expectedCalculation.InputParameters.PhreaticLevelExit.StandardDeviation = (RoundedDouble)5.5;
expectedCalculation.InputParameters.DampingFactorExit.StandardDeviation = (RoundedDouble)7.7;
Assert.AreEqual(1, calculationGroup.Children.Count);
AssertPipingCalculationScenario(expectedCalculation, (TCalculationScenario)calculationGroup.Children[0]);
}
finally
{
File.Delete(filePath);
}
}
public void Create_WithCalculationGroup_ReturnFailureMechanismWithCalculationGroupEntities()
{
// Setup
var calculationGroup = new CalculationGroup();
var calculation = new MacroStabilityInwardsCalculationScenario();
var failureMechanism = new MacroStabilityInwardsFailureMechanism();
failureMechanism.CalculationsGroup.Children.Add(calculationGroup);
failureMechanism.CalculationsGroup.Children.Add(calculation);
// Call
FailureMechanismEntity entity = failureMechanism.Create(new PersistenceRegistry());
// Assert
Assert.IsNotNull(entity);
Assert.AreEqual(failureMechanism.CalculationsGroup.Name, entity.CalculationGroupEntity.Name);
Assert.AreEqual(0, entity.CalculationGroupEntity.Order);
CalculationGroupEntity[] childGroupEntities = entity.CalculationGroupEntity.CalculationGroupEntity1
.OrderBy(cge => cge.Order)
.ToArray();
Assert.AreEqual(1, childGroupEntities.Length);
CalculationGroupEntity childGroupEntity = childGroupEntities[0];
Assert.AreEqual(calculationGroup.Name, childGroupEntity.Name);
Assert.AreEqual(0, childGroupEntity.Order);
MacroStabilityInwardsCalculationEntity[] calculationEntities = entity.CalculationGroupEntity.MacroStabilityInwardsCalculationEntities
.OrderBy(ce => ce.Order)
.ToArray();
Assert.AreEqual(1, calculationEntities.Length);
MacroStabilityInwardsCalculationEntity calculationEntity = calculationEntities[0];
Assert.AreEqual(calculation.Name, calculationEntity.Name);
Assert.AreEqual(1, calculationEntity.Order);
}
public void Create_GroupWithMacroStabilityInwardsCalculations_CreatesEntities()
{
// Setup
var group = new CalculationGroup
{
Children =
{
new MacroStabilityInwardsCalculationScenario
{
Name = "A"
},
new MacroStabilityInwardsCalculationScenario
{
Name = "B"
}
}
};
var registry = new PersistenceRegistry();
// Call
CalculationGroupEntity entity = group.Create(registry, 0);
// Assert
MacroStabilityInwardsCalculationEntity[] childCalculationEntities = entity.MacroStabilityInwardsCalculationEntities.ToArray();
Assert.AreEqual(2, childCalculationEntities.Length);
MacroStabilityInwardsCalculationEntity childEntity1 = childCalculationEntities[0];
Assert.AreEqual("A", childEntity1.Name);
Assert.AreEqual(0, childEntity1.Order);
MacroStabilityInwardsCalculationEntity childEntity2 = childCalculationEntities[1];
Assert.AreEqual("B", childEntity2.Name);
Assert.AreEqual(1, childEntity2.Order);
}
public void ParameteredConstructor_ExpectedValues(bool hasParent)
{
// Setup
var mocks = new MockRepository();
var assessmentSection = mocks.Stub <IAssessmentSection>();
mocks.ReplayAll();
var calculationGroup = new CalculationGroup();
var surfaceLines = new[]
{
new PipingSurfaceLine(string.Empty)
};
PipingStochasticSoilModel[] soilModels =
{
PipingStochasticSoilModelTestFactory.CreatePipingStochasticSoilModel()
};
CalculationGroup parent = hasParent ? new CalculationGroup() : null;
var failureMechanism = new PipingFailureMechanism();
// Call
var groupContext = new PipingCalculationGroupContext(calculationGroup, parent, surfaceLines, soilModels, failureMechanism, assessmentSection);
// Assert
Assert.IsInstanceOf <PipingContext <CalculationGroup> >(groupContext);
Assert.IsInstanceOf <ICalculationContext <CalculationGroup, PipingFailureMechanism> >(groupContext);
Assert.AreSame(calculationGroup, groupContext.WrappedData);
Assert.AreSame(parent, groupContext.Parent);
Assert.AreSame(surfaceLines, groupContext.AvailablePipingSurfaceLines);
Assert.AreSame(soilModels, groupContext.AvailableStochasticSoilModels);
Assert.AreSame(failureMechanism, groupContext.FailureMechanism);
Assert.AreSame(assessmentSection, groupContext.AssessmentSection);
mocks.VerifyAll();
}
public void IsEnabled_CalculationGroupChildIsCalculationWithoutOutput_ReturnFalse()
{
// Setup
var assessmentSection = mocks.Stub <IAssessmentSection>();
mocks.ReplayAll();
var calculationGroup = new CalculationGroup();
calculationGroup.Children.Add(new MacroStabilityInwardsCalculationScenario());
var context = new MacroStabilityInwardsCalculationGroupContext(calculationGroup,
null,
Enumerable.Empty <MacroStabilityInwardsSurfaceLine>(),
Enumerable.Empty <MacroStabilityInwardsStochasticSoilModel>(),
new MacroStabilityInwardsFailureMechanism(),
assessmentSection);
// Call
bool isEnabled = info.IsEnabled(context);
// Assert
Assert.IsFalse(isEnabled);
}
public void ConstructorWithData_Always_ExpectedPropertiesSet()
{
// Setup
var mocks = new MockRepository();
var assessmentSection = mocks.Stub <IAssessmentSection>();
mocks.ReplayAll();
var calculation = new GrassCoverErosionOutwardsWaveConditionsCalculation();
var failureMechanism = new GrassCoverErosionOutwardsFailureMechanism();
var parent = new CalculationGroup();
// Call
var context = new GrassCoverErosionOutwardsWaveConditionsCalculationContext(calculation, parent, failureMechanism, assessmentSection);
// Assert
Assert.IsInstanceOf <GrassCoverErosionOutwardsContext <GrassCoverErosionOutwardsWaveConditionsCalculation> >(context);
Assert.IsInstanceOf <ICalculationContext <GrassCoverErosionOutwardsWaveConditionsCalculation, GrassCoverErosionOutwardsFailureMechanism> >(context);
Assert.AreSame(calculation, context.WrappedData);
Assert.AreSame(parent, context.Parent);
Assert.AreSame(failureMechanism, context.FailureMechanism);
Assert.AreSame(assessmentSection, context.AssessmentSection);
mocks.VerifyAll();
}
public void Create_GroupWithChildClosingStructuresCalculations_CreateEntities()
{
// Setup
var group = new CalculationGroup
{
Children =
{
new StructuresCalculationScenario <ClosingStructuresInput>
{
Name = "A"
},
new StructuresCalculationScenario <ClosingStructuresInput>
{
Name = "B"
}
}
};
var registry = new PersistenceRegistry();
// Call
CalculationGroupEntity entity = group.Create(registry, 0);
// Assert
ClosingStructuresCalculationEntity[] childCalculationEntities = entity.ClosingStructuresCalculationEntities.ToArray();
Assert.AreEqual(2, childCalculationEntities.Length);
ClosingStructuresCalculationEntity childEntity1 = childCalculationEntities[0];
Assert.AreEqual("A", childEntity1.Name);
Assert.AreEqual(0, childEntity1.Order);
ClosingStructuresCalculationEntity childEntity2 = childCalculationEntities[1];
Assert.AreEqual("B", childEntity2.Name);
Assert.AreEqual(1, childEntity2.Order);
}
/// <summary>
/// Creates a new instance of <see cref="MacroStabilityInwardsCalculationGroupExporter"/>.
/// </summary>
/// <param name="calculationGroup">The calculation group to export.</param>
/// <param name="generalInput">General calculation parameters that are the same across all calculations.</param>
/// <param name="persistenceFactory">The persistence factory to use.</param>
/// <param name="filePath">The file path to export to.</param>
/// <param name="fileExtension">The extension of the files.</param>
/// <param name="getNormativeAssessmentLevelFunc"><see cref="Func{T1,TResult}"/>
/// for obtaining the normative assessment level.</param>
/// <exception cref="ArgumentNullException">Thrown when <paramref name="calculationGroup"/>, <paramref name="generalInput"/>,
/// <paramref name="persistenceFactory"/>, or <paramref name="getNormativeAssessmentLevelFunc"/> is <c>null</c>.</exception>
/// <exception cref="ArgumentException">Thrown when <paramref name="filePath"/> is invalid.</exception>
/// <remarks>A valid path:<list type="bullet">
/// <item>is not empty or <c>null</c>,</item>
/// <item>does not consist out of only whitespace characters,</item>
/// <item>does not contain an invalid character,</item>
/// <item>is not too long.</item>
/// </list></remarks>
public MacroStabilityInwardsCalculationGroupExporter(CalculationGroup calculationGroup, GeneralMacroStabilityInwardsInput generalInput,
IPersistenceFactory persistenceFactory, string filePath,
string fileExtension, Func <MacroStabilityInwardsCalculation, RoundedDouble> getNormativeAssessmentLevelFunc)
{
if (calculationGroup == null)
{
throw new ArgumentNullException(nameof(calculationGroup));
}
if (generalInput == null)
{
throw new ArgumentNullException(nameof(generalInput));
}
if (persistenceFactory == null)
{
throw new ArgumentNullException(nameof(persistenceFactory));
}
if (getNormativeAssessmentLevelFunc == null)
{
throw new ArgumentNullException(nameof(getNormativeAssessmentLevelFunc));
}
IOUtils.ValidateFilePath(filePath);
this.calculationGroup = calculationGroup;
this.generalInput = generalInput;
this.persistenceFactory = persistenceFactory;
this.filePath = filePath;
string folderPath = Path.GetDirectoryName(filePath);
tempFolderPath = Path.Combine(folderPath, "~temp");
this.fileExtension = fileExtension;
this.getNormativeAssessmentLevelFunc = getNormativeAssessmentLevelFunc;
}
/// <summary>
/// Creates a collection of <see cref="CalculatableActivity"/> based on the calculations in
/// <paramref name="calculationGroup"/>.
/// </summary>
/// <param name="calculationGroup">The calculation group to create activities for.</param>
/// <param name="failureMechanism">The failure mechanism the calculations belongs to.</param>
/// <param name="assessmentSection">The assessment section the calculations in <paramref name="calculationGroup"/>
/// belong to.</param>
/// <returns>A collection of <see cref="CalculatableActivity"/>.</returns>
/// <exception cref="ArgumentNullException">Thrown when any parameter is <c>null</c>.</exception>
public static IEnumerable <CalculatableActivity> CreateCalculationActivities(CalculationGroup calculationGroup,
GrassCoverErosionInwardsFailureMechanism failureMechanism,
IAssessmentSection assessmentSection)
{
if (calculationGroup == null)
{
throw new ArgumentNullException(nameof(calculationGroup));
}
if (failureMechanism == null)
{
throw new ArgumentNullException(nameof(failureMechanism));
}
if (assessmentSection == null)
{
throw new ArgumentNullException(nameof(assessmentSection));
}
return(calculationGroup.GetCalculations()
.Cast <GrassCoverErosionInwardsCalculation>()
.Select(calc => CreateCalculationActivity(calc, failureMechanism, assessmentSection))
.ToArray());
}
/// <summary>
/// Creates a collection of <see cref="CalculatableActivity"/> based on the calculations in
/// <paramref name="calculationGroup"/>.
/// </summary>
/// <param name="calculationGroup">The calculation group to create activities for.</param>
/// <param name="failureMechanism">The failure mechanism the calculations belongs to.</param>
/// <param name="assessmentSection">The assessment section the calculations in <paramref name="calculationGroup"/>
/// belong to.</param>
/// <returns>A collection of <see cref="CalculatableActivity"/>.</returns>
/// <exception cref="ArgumentNullException">Thrown when any parameter is <c>null</c>.</exception>
public static IEnumerable <CalculatableActivity> CreateCalculationActivities(CalculationGroup calculationGroup,
StabilityPointStructuresFailureMechanism failureMechanism,
IAssessmentSection assessmentSection)
{
if (calculationGroup == null)
{
throw new ArgumentNullException(nameof(calculationGroup));
}
if (failureMechanism == null)
{
throw new ArgumentNullException(nameof(failureMechanism));
}
if (assessmentSection == null)
{
throw new ArgumentNullException(nameof(assessmentSection));
}
return(calculationGroup.GetCalculations()
.Cast <StructuresCalculation <StabilityPointStructuresInput> >()
.Select(calc => CreateCalculationActivity(calc, failureMechanism, assessmentSection))
.ToArray());
}
public void GetViewName_WithContext_ReturnsCalculationGroupName()
{
// Setup
const string calculationGroupName = "Test";
var mocks = new MockRepository();
var assessmentSection = mocks.Stub <IAssessmentSection>();
assessmentSection.Stub(a => a.HydraulicBoundaryDatabase).Return(new HydraulicBoundaryDatabase());
mocks.ReplayAll();
var calculationGroup = new CalculationGroup
{
Name = calculationGroupName
};
var failureMechanism = new MacroStabilityInwardsFailureMechanism();
using (var calculationsView = new MacroStabilityInwardsCalculationsView(calculationGroup, failureMechanism, assessmentSection))
{
var context = new MacroStabilityInwardsCalculationGroupContext(calculationGroup,
null,
Enumerable.Empty <MacroStabilityInwardsSurfaceLine>(),
Enumerable.Empty <MacroStabilityInwardsStochasticSoilModel>(),
failureMechanism,
assessmentSection);
// Call
string name = info.GetViewName(calculationsView, context);
// Assert
Assert.AreEqual(calculationGroupName, name);
}
mocks.VerifyAll();
}
public void AdditionalDataCheck_CalculationGroupContextWithoutFailureMechanismParent_ReturnsFalse()
{
// Setup
var mocks = new MockRepository();
var assessmentSection = mocks.Stub <IAssessmentSection>();
mocks.ReplayAll();
var failureMechanism = new MacroStabilityInwardsFailureMechanism();
var calculationGroup = new CalculationGroup();
var context = new MacroStabilityInwardsCalculationGroupContext(calculationGroup,
null,
Enumerable.Empty <MacroStabilityInwardsSurfaceLine>(),
Enumerable.Empty <MacroStabilityInwardsStochasticSoilModel>(),
failureMechanism,
assessmentSection);
// Call
bool additionalDataCheck = info.AdditionalDataCheck(context);
// Assert
Assert.IsFalse(additionalDataCheck);
mocks.VerifyAll();
}
