public void Create_SoilProfileWithMultiplePreconsolidationStressesOnOneLayer_ReturnsPersistableStates()
{
// Setup
MacroStabilityInwardsCalculationScenario calculation = MacroStabilityInwardsCalculationScenarioTestFactory.CreateMacroStabilityInwardsCalculationScenarioWithValidInput(
new TestHydraulicBoundaryLocation());
calculation.InputParameters.StochasticSoilProfile = MacroStabilityInwardsStochasticSoilProfileTestFactory.CreateMacroStabilityInwardsStochasticSoilProfile2D(new[]
{
MacroStabilityInwardsPreconsolidationStressTestFactory.CreateMacroStabilityInwardsPreconsolidationStress(new Point2D(2, 1)),
MacroStabilityInwardsPreconsolidationStressTestFactory.CreateMacroStabilityInwardsPreconsolidationStress(new Point2D(2, 2))
});
IMacroStabilityInwardsSoilProfileUnderSurfaceLine soilProfile = calculation.InputParameters.SoilProfileUnderSurfaceLine;
var idFactory = new IdFactory();
var registry = new MacroStabilityInwardsExportRegistry();
PersistableGeometryFactory.Create(soilProfile, idFactory, registry);
// Call
IEnumerable <PersistableState> states = PersistableStateFactory.Create(soilProfile, idFactory, registry);
// Assert
Assert.AreEqual(1, states.Count());
PersistableState state = states.First();
Assert.IsNotNull(state.Id);
CollectionAssert.IsEmpty(state.StateLines);
CollectionAssert.IsEmpty(state.StatePoints);
}
public void Create_WithValidData_ReturnsPersistableStates()
{
// Setup
MacroStabilityInwardsCalculationScenario calculation = MacroStabilityInwardsCalculationScenarioTestFactory.CreateMacroStabilityInwardsCalculationScenarioWithValidInput(new TestHydraulicBoundaryLocation());
MacroStabilityInwardsStochasticSoilProfile stochasticSoilProfile = MacroStabilityInwardsStochasticSoilProfileTestFactory.CreateMacroStabilityInwardsStochasticSoilProfile2D(new[]
{
MacroStabilityInwardsPreconsolidationStressTestFactory.CreateMacroStabilityInwardsPreconsolidationStress(new Point2D(2, 1))
});
IMacroStabilityInwardsSoilLayer lastLayer = stochasticSoilProfile.SoilProfile.Layers.Last();
lastLayer.Data.UsePop = true;
lastLayer.Data.Pop = new VariationCoefficientLogNormalDistribution
{
Mean = (RoundedDouble)1,
CoefficientOfVariation = (RoundedDouble)2
};
calculation.InputParameters.StochasticSoilProfile = stochasticSoilProfile;
IMacroStabilityInwardsSoilProfileUnderSurfaceLine soilProfile = calculation.InputParameters.SoilProfileUnderSurfaceLine;
var idFactory = new IdFactory();
var registry = new MacroStabilityInwardsExportRegistry();
PersistableGeometryFactory.Create(soilProfile, idFactory, registry);
// Call
IEnumerable <PersistableState> states = PersistableStateFactory.Create(soilProfile, idFactory, registry);
// Assert
PersistableDataModelTestHelper.AssertStates(soilProfile, states);
PersistableState state = states.First();
Assert.AreEqual(registry.States[MacroStabilityInwardsExportStageType.Daily], state.Id);
}
private static MacroStabilityInwardsCalculationScenario CreateValidCalculation(HydraulicBoundaryLocation hydraulicBoundaryLocation)
{
MacroStabilityInwardsCalculationScenario calculation = MacroStabilityInwardsCalculationScenarioTestFactory.CreateMacroStabilityInwardsCalculationScenarioWithValidInput(hydraulicBoundaryLocation);
calculation.InputParameters.LeakageLengthInwardsPhreaticLine3 = new Random(39).NextRoundedDouble();
return(calculation);
}
public void CreateCalculationFeatures_GivenCalculations_ReturnsCalculationFeaturesCollection()
{
// Setup
MacroStabilityInwardsCalculationScenario calculationA = MacroStabilityInwardsCalculationScenarioTestFactory.CreateMacroStabilityInwardsCalculationScenarioWithValidInput(new HydraulicBoundaryLocation(1, string.Empty, 5.0, 4.0));
MacroStabilityInwardsCalculationScenario calculationB = MacroStabilityInwardsCalculationScenarioTestFactory.CreateMacroStabilityInwardsCalculationScenarioWithValidInput(new HydraulicBoundaryLocation(1, string.Empty, 2.2, 3.8));
calculationA.InputParameters.SurfaceLine.ReferenceLineIntersectionWorldPoint = new Point2D(1.0, 3.0);
calculationB.InputParameters.SurfaceLine.ReferenceLineIntersectionWorldPoint = new Point2D(1.0, 4.0);
// Call
IEnumerable <MapFeature> features = MacroStabilityInwardsMapDataFeaturesFactory.CreateCalculationFeatures(new[]
{
calculationA,
calculationB
});
// Assert
Assert.AreEqual(2, features.Count());
Assert.AreEqual(1, features.ElementAt(0).MapGeometries.Count());
Assert.AreEqual(1, features.ElementAt(1).MapGeometries.Count());
AssertEqualPointCollections(new[]
{
new Point2D(1.0, 3.0),
new Point2D(5.0, 4.0)
}, features.ElementAt(0).MapGeometries.ElementAt(0));
AssertEqualPointCollections(new[]
{
new Point2D(1.0, 4.0),
new Point2D(2.2, 3.8)
}, features.ElementAt(1).MapGeometries.ElementAt(0));
}
public void Create_WithValidData_ReturnsPersistableWaternetCreatorSettingsCollection()
{
// Setup
MacroStabilityInwardsCalculationScenario calculation = MacroStabilityInwardsCalculationScenarioTestFactory.CreateMacroStabilityInwardsCalculationScenarioWithValidInput(
new TestHydraulicBoundaryLocation());
MacroStabilityInwardsInput input = calculation.InputParameters;
RoundedDouble normativeAssessmentLevel = RoundedDouble.NaN;
var idFactory = new IdFactory();
var registry = new MacroStabilityInwardsExportRegistry();
PersistableGeometryFactory.Create(input.SoilProfileUnderSurfaceLine, idFactory, registry);
// Call
IEnumerable <PersistableWaternetCreatorSettings> waternetCreatorSettingsCollection = PersistableWaternetCreatorSettingsFactory.Create(input, normativeAssessmentLevel,
idFactory, registry);
// Assert
var stages = new[]
{
MacroStabilityInwardsExportStageType.Daily,
MacroStabilityInwardsExportStageType.Extreme
};
PersistableDataModelTestHelper.AssertWaternetCreatorSettings(input, waternetCreatorSettingsCollection, normativeAssessmentLevel, stages);
AssertRegistry(registry, stages, waternetCreatorSettingsCollection);
}
public void Export_PersistenceFactoryThrowsException_LogsErrorAndReturnsFalse()
{
// Setup
const string filePath = "ValidFilePath";
MacroStabilityInwardsCalculationScenario calculation = MacroStabilityInwardsCalculationScenarioTestFactory.CreateMacroStabilityInwardsCalculationScenarioWithValidInput(new TestHydraulicBoundaryLocation());
calculation.Output = MacroStabilityInwardsOutputTestFactory.CreateRandomOutput();
using (new MacroStabilityInwardsCalculatorFactoryConfig())
{
var persistenceFactory = new MacroStabilityInwardsTestPersistenceFactory
{
ThrowException = true
};
var exporter = new MacroStabilityInwardsCalculationExporter(calculation, new GeneralMacroStabilityInwardsInput(), persistenceFactory, filePath, AssessmentSectionTestHelper.GetTestAssessmentLevel);
// Call
var exportResult = true;
void Call() => exportResult = exporter.Export();
// Assert
string expectedMessage = $"Er is een onverwachte fout opgetreden tijdens het schrijven van het bestand '{filePath}'. Er is geen D-GEO Suite Stability Project geëxporteerd.";
TestHelper.AssertLogMessageWithLevelIsGenerated(Call, new Tuple <string, LogLevelConstant>(expectedMessage, LogLevelConstant.Error));
Assert.IsFalse(exportResult);
}
}
public void Export_SoilProfileWithMultiplePreconsolidationStressesOnOneLayer_LogsWarningAndReturnsTrue()
{
// Setup
string filePath = TestHelper.GetScratchPadPath($"{nameof(MacroStabilityInwardsCalculationExporterTest)}.{nameof(Export_SoilProfileWithMultiplePreconsolidationStressesOnOneLayer_LogsWarningAndReturnsTrue)}.ValidFile.stix");
MacroStabilityInwardsCalculationScenario calculation = MacroStabilityInwardsCalculationScenarioTestFactory.CreateMacroStabilityInwardsCalculationScenarioWithValidInput(new TestHydraulicBoundaryLocation());
calculation.InputParameters.StochasticSoilProfile = MacroStabilityInwardsStochasticSoilProfileTestFactory.CreateMacroStabilityInwardsStochasticSoilProfile2D(new[]
{
MacroStabilityInwardsPreconsolidationStressTestFactory.CreateMacroStabilityInwardsPreconsolidationStress(new Point2D(2, 1)),
MacroStabilityInwardsPreconsolidationStressTestFactory.CreateMacroStabilityInwardsPreconsolidationStress(new Point2D(2, 2))
});
calculation.Output = MacroStabilityInwardsOutputTestFactory.CreateRandomOutput();
var exporter = new MacroStabilityInwardsCalculationExporter(calculation, new GeneralMacroStabilityInwardsInput(), new PersistenceFactory(), filePath, AssessmentSectionTestHelper.GetTestAssessmentLevel);
try
{
using (new MacroStabilityInwardsCalculatorFactoryConfig())
{
// Call
var exportResult = false;
void Call() => exportResult = exporter.Export();
// Assert
var expectedMessage = $"'{calculation.Name}': De schematisatie van de berekening bevat meerdere stresspunten binnen één laag of stresspunten die niet aan een laag gekoppeld kunnen worden. Er worden daarom geen POP en grensspanningen geëxporteerd.";
TestHelper.AssertLogMessageWithLevelIsGenerated(Call, new Tuple <string, LogLevelConstant>(expectedMessage, LogLevelConstant.Warn));
Assert.IsTrue(exportResult);
}
}
finally
{
File.Delete(filePath);
}
}
public void Export_SoilProfileWithMultipleAquiferLayers_LogsWarningAndReturnsTrue()
{
// Setup
string filePath = TestHelper.GetScratchPadPath($"{nameof(MacroStabilityInwardsCalculationExporterTest)}.{nameof(Export_MaximumSliceWidthNotOne_LogsWarningAndReturnsTrue)}.ValidFile.stix");
MacroStabilityInwardsCalculationScenario calculation = MacroStabilityInwardsCalculationScenarioTestFactory.CreateMacroStabilityInwardsCalculationScenarioWithValidInput(new TestHydraulicBoundaryLocation());
calculation.InputParameters.StochasticSoilProfile.SoilProfile.Layers.ForEachElementDo(layer => layer.Data.IsAquifer = true);
calculation.Output = MacroStabilityInwardsOutputTestFactory.CreateRandomOutput();
var exporter = new MacroStabilityInwardsCalculationExporter(calculation, new GeneralMacroStabilityInwardsInput(), new PersistenceFactory(), filePath, AssessmentSectionTestHelper.GetTestAssessmentLevel);
try
{
using (new MacroStabilityInwardsCalculatorFactoryConfig())
{
// Call
var exportResult = false;
void Call() => exportResult = exporter.Export();
// Assert
var expectedMessage = $"'{calculation.Name}': De schematisatie van de berekening bevat meerdere aquifer lagen. De volgorde van de aquifer lagen kan niet bepaald worden tijdens exporteren. Er worden daarom geen lagen als aquifer geëxporteerd.";
TestHelper.AssertLogMessageWithLevelIsGenerated(Call, new Tuple <string, LogLevelConstant>(expectedMessage, LogLevelConstant.Warn));
Assert.IsTrue(exportResult);
}
}
finally
{
File.Delete(filePath);
}
}
public void Export_RunsSuccessful_WritesFileAndRemovesTempFile()
{
// Setup
string filePath = TestHelper.GetScratchPadPath($"{nameof(MacroStabilityInwardsCalculationExporterTest)}.{nameof(Export_RunsSuccessful_WritesFileAndRemovesTempFile)}.ValidFile.stix");
MacroStabilityInwardsCalculationScenario calculation = MacroStabilityInwardsCalculationScenarioTestFactory.CreateMacroStabilityInwardsCalculationScenarioWithValidInput(new TestHydraulicBoundaryLocation());
calculation.Output = MacroStabilityInwardsOutputTestFactory.CreateRandomOutput();
var exporter = new MacroStabilityInwardsCalculationExporter(calculation, new GeneralMacroStabilityInwardsInput(), new PersistenceFactory(), filePath, AssessmentSectionTestHelper.GetTestAssessmentLevel);
try
{
using (new MacroStabilityInwardsCalculatorFactoryConfig())
{
// Call
bool exportResult = exporter.Export();
// Assert
Assert.IsTrue(exportResult);
Assert.IsTrue(File.Exists(filePath));
Assert.IsFalse(File.Exists($"{filePath}.temp"));
}
}
finally
{
File.Delete(filePath);
}
}
public void Export_MaximumSliceWidthNotOne_LogsWarningAndReturnsTrue(double maximumSliceWidth)
{
// Setup
string filePath = TestHelper.GetScratchPadPath($"{nameof(MacroStabilityInwardsCalculationExporterTest)}.{nameof(Export_MaximumSliceWidthNotOne_LogsWarningAndReturnsTrue)}.ValidFile.stix");
MacroStabilityInwardsCalculationScenario calculation = MacroStabilityInwardsCalculationScenarioTestFactory.CreateMacroStabilityInwardsCalculationScenarioWithValidInput(new TestHydraulicBoundaryLocation());
calculation.InputParameters.MaximumSliceWidth = (RoundedDouble)maximumSliceWidth;
calculation.Output = MacroStabilityInwardsOutputTestFactory.CreateRandomOutput();
var exporter = new MacroStabilityInwardsCalculationExporter(calculation, new GeneralMacroStabilityInwardsInput(), new PersistenceFactory(), filePath, AssessmentSectionTestHelper.GetTestAssessmentLevel);
try
{
using (new MacroStabilityInwardsCalculatorFactoryConfig())
{
// Call
var exportResult = false;
void Call() => exportResult = exporter.Export();
// Assert
var expectedMessage = $"'{calculation.Name}': De berekening bevat een lamelbreedte van {calculation.InputParameters.MaximumSliceWidth.ToString(null, CultureInfo.CurrentCulture)} meter. D-GEO Suite Stability ondersteunt enkel een maximale lamelbreedte van 1 meter. Er wordt daarom een lamelbreedte van 1 meter geëxporteerd.";
TestHelper.AssertLogMessageWithLevelIsGenerated(Call, new Tuple <string, LogLevelConstant>(expectedMessage, LogLevelConstant.Warn));
Assert.IsTrue(exportResult);
}
}
finally
{
File.Delete(filePath);
}
}
public void Export_PersistenceFactoryThrowsException_NoFileWritten()
{
// Setup
string filePath = TestHelper.GetScratchPadPath($"{nameof(MacroStabilityInwardsCalculationExporterTest)}.{nameof(Export_PersistenceFactoryThrowsException_NoFileWritten)}.ValidFile.stix");
MacroStabilityInwardsCalculationScenario calculation = MacroStabilityInwardsCalculationScenarioTestFactory.CreateMacroStabilityInwardsCalculationScenarioWithValidInput(new TestHydraulicBoundaryLocation());
calculation.Output = MacroStabilityInwardsOutputTestFactory.CreateRandomOutput();
using (new MacroStabilityInwardsCalculatorFactoryConfig())
{
var persistenceFactory = new MacroStabilityInwardsTestPersistenceFactory
{
ThrowException = true,
WriteFile = true
};
var exporter = new MacroStabilityInwardsCalculationExporter(calculation, new GeneralMacroStabilityInwardsInput(), persistenceFactory, filePath, AssessmentSectionTestHelper.GetTestAssessmentLevel);
// Call
exporter.Export();
// Assert
Assert.IsFalse(File.Exists(filePath));
Assert.IsFalse(File.Exists($"{filePath}.temp"));
}
}
private static void AssertPropertyChangeWithOrWithoutCalculationOutput(
Action <MacroStabilityInwardsCalculationRow> setProperty,
Action <MacroStabilityInwardsCalculationScenario> assertions,
bool hasOutput,
bool expectUpdates)
{
// Setup
var mockRepository = new MockRepository();
var inputObserver = mockRepository.StrictMock <IObserver>();
if (expectUpdates)
{
inputObserver.Expect(o => o.UpdateObserver());
}
var calculationObserver = mockRepository.StrictMock <IObserver>();
if (expectUpdates && hasOutput)
{
calculationObserver.Expect(o => o.UpdateObserver());
}
var handler = mockRepository.Stub <IObservablePropertyChangeHandler>();
mockRepository.ReplayAll();
MacroStabilityInwardsOutput assignedOutput = null;
MacroStabilityInwardsCalculationScenario calculation = MacroStabilityInwardsCalculationScenarioTestFactory.CreateMacroStabilityInwardsCalculationScenarioWithValidInput(new TestHydraulicBoundaryLocation());
if (hasOutput)
{
assignedOutput = MacroStabilityInwardsOutputTestFactory.CreateOutput();
}
calculation.Output = assignedOutput;
var row = new MacroStabilityInwardsCalculationRow(calculation, handler);
calculation.Attach(calculationObserver);
calculation.InputParameters.Attach(inputObserver);
// Call
setProperty(row);
// Assert
assertions(calculation);
if (expectUpdates)
{
Assert.IsNull(calculation.Output);
}
else
{
Assert.AreSame(assignedOutput, calculation.Output);
}
mockRepository.VerifyAll();
}
private static void AddMacroStabilityInwardsCalculationScenario(AssessmentSection assessmentSection,
HydraulicBoundaryLocation hydraulicBoundaryLocation)
{
MacroStabilityInwardsCalculationScenario macroStabilityInwardsCalculationScenario =
MacroStabilityInwardsCalculationScenarioTestFactory.CreateMacroStabilityInwardsCalculationScenarioWithValidInput(hydraulicBoundaryLocation);
macroStabilityInwardsCalculationScenario.InputParameters.UseAssessmentLevelManualInput = true;
macroStabilityInwardsCalculationScenario.InputParameters.AssessmentLevel = new Random(39).NextRoundedDouble();
assessmentSection.MacroStabilityInwards.CalculationsGroup.Children.Add(macroStabilityInwardsCalculationScenario);
}
public void ContextMenuStrip_ClickOnValidateAllItem_ValidateAllChildCalculations()
{
// Setup
using (var treeViewControl = new TreeViewControl())
{
var assessmentSection = new AssessmentSectionStub();
var hydraulicBoundaryLocation = new TestHydraulicBoundaryLocation();
assessmentSection.SetHydraulicBoundaryLocationCalculations(new[]
{
hydraulicBoundaryLocation
}, true);
var failureMechanism = new MacroStabilityInwardsFailureMechanism();
MacroStabilityInwardsCalculationScenario validCalculation = MacroStabilityInwardsCalculationScenarioTestFactory.CreateMacroStabilityInwardsCalculationScenarioWithValidInput(hydraulicBoundaryLocation);
validCalculation.Name = "A";
MacroStabilityInwardsCalculationScenario invalidCalculation = MacroStabilityInwardsCalculationScenarioTestFactory.CreateMacroStabilityInwardsCalculationScenarioWithInvalidInput();
invalidCalculation.Name = "B";
failureMechanism.CalculationsGroup.Children.Add(validCalculation);
failureMechanism.CalculationsGroup.Children.Add(invalidCalculation);
var context = new MacroStabilityInwardsFailureMechanismContext(failureMechanism, assessmentSection);
var menuBuilder = new CustomItemsOnlyContextMenuBuilder();
var gui = mocks.Stub <IGui>();
gui.Stub(g => g.Get(context, treeViewControl)).Return(menuBuilder);
mocks.ReplayAll();
plugin.Gui = gui;
using (ContextMenuStrip contextMenu = info.ContextMenuStrip(context, null, treeViewControl))
using (new MacroStabilityInwardsCalculatorFactoryConfig())
{
// Call
void Call() => contextMenu.Items[contextMenuValidateAllIndex].PerformClick();
// Assert
TestHelper.AssertLogMessages(Call, messages =>
{
string[] msgs = messages.ToArray();
Assert.AreEqual(9, msgs.Length);
CalculationServiceTestHelper.AssertValidationStartMessage(msgs[0]);
Assert.AreEqual("Validatie van waterspanningen in extreme omstandigheden is gestart.", msgs[1]);
Assert.AreEqual("Validatie van waterspanningen in dagelijkse omstandigheden is gestart.", msgs[2]);
CalculationServiceTestHelper.AssertValidationEndMessage(msgs[3]);
CalculationServiceTestHelper.AssertValidationStartMessage(msgs[4]);
CalculationServiceTestHelper.AssertValidationEndMessage(msgs[8]);
});
}
}
}
public void GivenViewWithCalculationGroupData_WhenCalculationGroupUpdatedAndNotified_ThenMapDataUpdated()
{
// Given
var surfaceLineA = new MacroStabilityInwardsSurfaceLine(string.Empty);
surfaceLineA.SetGeometry(new[]
{
new Point3D(0.0, 0.0, 1.0),
new Point3D(3.0, 0.0, 1.7)
});
surfaceLineA.ReferenceLineIntersectionWorldPoint = new Point2D(1.3, 1.3);
MacroStabilityInwardsCalculationScenario calculationA = MacroStabilityInwardsCalculationScenarioTestFactory.CreateMacroStabilityInwardsCalculationScenarioWithValidInput(new TestHydraulicBoundaryLocation());
calculationA.InputParameters.SurfaceLine = surfaceLineA;
var failureMechanism = new MacroStabilityInwardsFailureMechanism();
failureMechanism.CalculationsGroup.Children.Add(calculationA);
MacroStabilityInwardsFailureMechanismView view = CreateView(failureMechanism, new AssessmentSectionStub());
IMapControl map = ((RiskeerMapControl)view.Controls[0]).MapControl;
var surfaceLineB = new MacroStabilityInwardsSurfaceLine(string.Empty);
surfaceLineB.SetGeometry(new[]
{
new Point3D(0.0, 0.0, 1.5),
new Point3D(3.0, 0.0, 1.8)
});
surfaceLineB.ReferenceLineIntersectionWorldPoint = new Point2D(1.5, 1.5);
MacroStabilityInwardsCalculationScenario calculationB = MacroStabilityInwardsCalculationScenarioTestFactory.CreateMacroStabilityInwardsCalculationScenarioWithValidInput(new TestHydraulicBoundaryLocation());
calculationB.InputParameters.SurfaceLine = surfaceLineB;
var calculationMapData = (MapLineData)map.Data.Collection.ElementAt(calculationsIndex);
var mocks = new MockRepository();
IObserver[] observers = AttachMapDataObservers(mocks, map.Data.Collection);
observers[calculationObserverIndex].Expect(obs => obs.UpdateObserver());
mocks.ReplayAll();
// When
failureMechanism.CalculationsGroup.Children.Add(calculationB);
failureMechanism.CalculationsGroup.NotifyObservers();
// Then
AssertCalculationsMapData(failureMechanism.Calculations.Cast <MacroStabilityInwardsCalculationScenario>(), calculationMapData);
mocks.VerifyAll();
}
public void Create_WithValidData_ReturnsPersistableProjectInfo()
{
// Setup
MacroStabilityInwardsCalculationScenario calculation = MacroStabilityInwardsCalculationScenarioTestFactory.CreateMacroStabilityInwardsCalculationScenarioWithValidInput(new TestHydraulicBoundaryLocation());
const string filePath = "SomeFilePath";
// Call
PersistableProjectInfo persistableProjectInfo = PersistableProjectInfoFactory.Create(calculation, filePath);
// Assert
PersistableDataModelTestHelper.AssertProjectInfo(calculation, filePath, persistableProjectInfo);
}
private static MacroStabilityInwardsCalculationScenario CreateCalculation(string calculationName, bool setOutput = true)
{
MacroStabilityInwardsCalculationScenario calculation = MacroStabilityInwardsCalculationScenarioTestFactory.CreateMacroStabilityInwardsCalculationScenarioWithValidInput(new TestHydraulicBoundaryLocation());
calculation.Name = calculationName;
if (setOutput)
{
calculation.Output = MacroStabilityInwardsOutputTestFactory.CreateRandomOutput();
}
return(calculation);
}
public void GetWaternetExtreme_GeneralInputNull_ThrowsArgumentNullException()
{
// Setup
MacroStabilityInwardsCalculationScenario calculation = MacroStabilityInwardsCalculationScenarioTestFactory.CreateMacroStabilityInwardsCalculationScenarioWithValidInput(new TestHydraulicBoundaryLocation());
// Call
void Call() => DerivedMacroStabilityInwardsInput.GetWaternetExtreme(calculation.InputParameters, null, RoundedDouble.NaN);
// Assert
var exception = Assert.Throws <ArgumentNullException>(Call);
Assert.AreEqual("generalInput", exception.ParamName);
}
public void Create_CalculationWithoutOutput_ThrowsInvalidOperationException()
{
// Setup
MacroStabilityInwardsCalculationScenario calculation = MacroStabilityInwardsCalculationScenarioTestFactory.CreateMacroStabilityInwardsCalculationScenarioWithValidInput(new TestHydraulicBoundaryLocation());
// Call
void Call() => PersistableDataModelFactory.Create(calculation, new GeneralMacroStabilityInwardsInput(), AssessmentSectionTestHelper.GetTestAssessmentLevel, string.Empty);
// Assert
var exception = Assert.Throws <InvalidOperationException>(Call);
Assert.AreEqual("Calculation must have output.", exception.Message);
}
public void ContextMenuStrip_AllRequiredInputSet_ContextMenuItemCalculateAllAndValidateAllEnabled()
{
// Setup
using (var treeViewControl = new TreeViewControl())
{
var assessmentSection = new AssessmentSectionStub();
var hydraulicBoundaryLocation = new TestHydraulicBoundaryLocation();
assessmentSection.SetHydraulicBoundaryLocationCalculations(new[]
{
hydraulicBoundaryLocation
}, true);
var failureMechanism = new MacroStabilityInwardsFailureMechanism
{
CalculationsGroup =
{
Children =
{
MacroStabilityInwardsCalculationScenarioTestFactory.CreateMacroStabilityInwardsCalculationScenarioWithValidInput(hydraulicBoundaryLocation)
}
}
};
var context = new MacroStabilityInwardsFailureMechanismContext(failureMechanism, assessmentSection);
var menuBuilder = new CustomItemsOnlyContextMenuBuilder();
var gui = mocks.Stub <IGui>();
gui.Stub(cmp => cmp.Get(context, treeViewControl)).Return(menuBuilder);
mocks.ReplayAll();
plugin.Gui = gui;
// Call
using (ContextMenuStrip contextMenu = info.ContextMenuStrip(context, null, treeViewControl))
{
// Assert
TestHelper.AssertContextMenuStripContainsItem(contextMenu, contextMenuCalculateAllIndex,
"Alles be&rekenen",
"Voer alle berekeningen binnen dit faalmechanisme uit.",
RiskeerCommonFormsResources.CalculateAllIcon);
TestHelper.AssertContextMenuStripContainsItem(contextMenu, contextMenuValidateAllIndex,
"Alles &valideren",
"Valideer alle berekeningen binnen dit faalmechanisme.",
RiskeerCommonFormsResources.ValidateAllIcon);
}
}
}
public void GetWaternetDaily_ValidInput_ReturnsMacroStabilityInwardsWaternet()
{
// Setup
MacroStabilityInwardsCalculationScenario calculation = MacroStabilityInwardsCalculationScenarioTestFactory.CreateMacroStabilityInwardsCalculationScenarioWithValidInput(new TestHydraulicBoundaryLocation());
using (new MacroStabilityInwardsCalculatorFactoryConfig())
{
// Call
MacroStabilityInwardsWaternet waternet = DerivedMacroStabilityInwardsInput.GetWaternetDaily(calculation.InputParameters, new GeneralMacroStabilityInwardsInput());
// Assert
var calculatorFactory = (TestMacroStabilityInwardsCalculatorFactory)MacroStabilityInwardsCalculatorFactory.Instance;
CalculatorOutputAssert.AssertWaternet(calculatorFactory.LastCreatedWaternetDailyCalculator.Output, waternet);
}
}
public void Create_InvalidDikeSoilScenarios_ThrowsInvalidEnumArgumentException()
{
// Setup
MacroStabilityInwardsCalculationScenario calculation = MacroStabilityInwardsCalculationScenarioTestFactory.CreateMacroStabilityInwardsCalculationScenarioWithValidInput(
new TestHydraulicBoundaryLocation());
MacroStabilityInwardsInput input = calculation.InputParameters;
input.DikeSoilScenario = (MacroStabilityInwardsDikeSoilScenario)99;
// Call
void Call() => PersistableWaternetCreatorSettingsFactory.Create(input, RoundedDouble.NaN, new IdFactory(), new MacroStabilityInwardsExportRegistry());
// Assert
string expectedMessage = $"The value of argument 'dikeSoilScenario' ({input.DikeSoilScenario}) is invalid for Enum type '{nameof(MacroStabilityInwardsDikeSoilScenario)}'.";
TestHelper.AssertThrowsArgumentExceptionAndTestMessage <InvalidEnumArgumentException>(Call, expectedMessage);
}
public void Create_WithValidData_ReturnsPersistableDataModel()
{
// Setup
const string filePath = "ValidFilePath";
MacroStabilityInwardsCalculationScenario calculation = MacroStabilityInwardsCalculationScenarioTestFactory.CreateMacroStabilityInwardsCalculationScenarioWithValidInput(new TestHydraulicBoundaryLocation());
calculation.Output = MacroStabilityInwardsOutputTestFactory.CreateRandomOutput();
using (new MacroStabilityInwardsCalculatorFactoryConfig())
{
// Call
PersistableDataModel persistableDataModel = PersistableDataModelFactory.Create(calculation, new GeneralMacroStabilityInwardsInput(), AssessmentSectionTestHelper.GetTestAssessmentLevel, filePath);
// Assert
PersistableDataModelTestHelper.AssertPersistableDataModel(calculation, filePath, persistableDataModel);
}
}
public void GetProperties_WithData_ReturnExpectedValues()
{
// Setup
var mocks = new MockRepository();
var propertyChangeHandler = mocks.Stub <IObservablePropertyChangeHandler>();
mocks.ReplayAll();
RoundedDouble assessmentLevel = new Random(21).NextRoundedDouble();
MacroStabilityInwardsCalculationScenario calculation = MacroStabilityInwardsCalculationScenarioTestFactory.CreateMacroStabilityInwardsCalculationScenarioWithValidInput(new TestHydraulicBoundaryLocation());
MacroStabilityInwardsInput input = calculation.InputParameters;
// Call
var properties = new MacroStabilityInwardsWaterStressesProperties(input, new GeneralMacroStabilityInwardsInput(), assessmentLevel, propertyChangeHandler);
// Assert
Assert.AreEqual(input.WaterLevelRiverAverage, properties.WaterLevelRiverAverage);
Assert.AreSame(input.LocationInputExtreme, properties.LocationExtreme.Data);
Assert.AreSame(input.LocationInputDaily, properties.LocationDaily.Data);
Assert.AreSame(input, properties.WaterStressLines.Data);
using (new MacroStabilityInwardsCalculatorFactoryConfig())
{
MacroStabilityInwardsWaternetProperties waternetProperties = properties.WaterStressLines.WaternetExtreme;
var calculatorFactory = (TestMacroStabilityInwardsCalculatorFactory)MacroStabilityInwardsCalculatorFactory.Instance;
WaternetCalculatorStub calculator = calculatorFactory.LastCreatedWaternetExtremeCalculator;
Assert.AreEqual(assessmentLevel, calculator.Input.AssessmentLevel);
CalculatorOutputAssert.AssertWaternet(calculator.Output, (MacroStabilityInwardsWaternet)waternetProperties.Data);
}
Assert.AreSame(input, properties.Drainage.Data);
Assert.AreEqual(input.MinimumLevelPhreaticLineAtDikeTopRiver, properties.MinimumLevelPhreaticLineAtDikeTopRiver);
Assert.AreEqual(input.MinimumLevelPhreaticLineAtDikeTopPolder, properties.MinimumLevelPhreaticLineAtDikeTopPolder);
Assert.AreEqual(input.AdjustPhreaticLine3And4ForUplift, properties.AdjustPhreaticLine3And4ForUplift);
Assert.AreEqual(input.LeakageLengthOutwardsPhreaticLine3, properties.LeakageLengthOutwardsPhreaticLine3);
Assert.AreEqual(input.LeakageLengthInwardsPhreaticLine3, properties.LeakageLengthInwardsPhreaticLine3);
Assert.AreEqual(input.LeakageLengthOutwardsPhreaticLine4, properties.LeakageLengthOutwardsPhreaticLine4);
Assert.AreEqual(input.LeakageLengthInwardsPhreaticLine4, properties.LeakageLengthInwardsPhreaticLine4);
Assert.AreEqual(input.PiezometricHeadPhreaticLine2Outwards, properties.PiezometricHeadPhreaticLine2Outwards);
Assert.AreEqual(input.PiezometricHeadPhreaticLine2Inwards, properties.PiezometricHeadPhreaticLine2Inwards);
mocks.VerifyAll();
}
public void GetWaternetExtreme_SurfaceLineNull_ReturnsMacroStabilityInwardsWaternet()
{
// Setup
MacroStabilityInwardsCalculationScenario calculation = MacroStabilityInwardsCalculationScenarioTestFactory.CreateMacroStabilityInwardsCalculationScenarioWithValidInput(new TestHydraulicBoundaryLocation());
calculation.InputParameters.SurfaceLine = null;
using (new MacroStabilityInwardsCalculatorFactoryConfig())
{
// Call
MacroStabilityInwardsWaternet waternet = DerivedMacroStabilityInwardsInput.GetWaternetExtreme(calculation.InputParameters, new GeneralMacroStabilityInwardsInput(), RoundedDouble.NaN);
// Assert
Assert.IsNotNull(waternet);
CollectionAssert.IsEmpty(waternet.PhreaticLines);
CollectionAssert.IsEmpty(waternet.WaternetLines);
}
}
public void Create_WithMultipleAquiferLayers_ReturnsPersistableWaternetCreatorSettingsCollection()
{
// Setup
MacroStabilityInwardsCalculationScenario calculation = MacroStabilityInwardsCalculationScenarioTestFactory.CreateMacroStabilityInwardsCalculationScenarioWithValidInput(
new TestHydraulicBoundaryLocation());
MacroStabilityInwardsInput input = calculation.InputParameters;
foreach (IMacroStabilityInwardsSoilLayer layer in input.StochasticSoilProfile.SoilProfile.Layers)
{
layer.Data.IsAquifer = true;
}
// Call
IEnumerable <PersistableWaternetCreatorSettings> waternetCreatorSettingsCollection = PersistableWaternetCreatorSettingsFactory.Create(
input, RoundedDouble.NaN, new IdFactory(), new MacroStabilityInwardsExportRegistry());
// Assert
Assert.IsTrue(waternetCreatorSettingsCollection.All(wcsc => wcsc.AquiferLayerId == null));
}
public void GetWaternetExtreme_ValidInput_SetsAssessmentLevelToCalculatorInputAndReturnsMacroStabilityInwardsWaternet()
{
// Setup
RoundedDouble assessmentLevel = new Random(21).NextRoundedDouble();
MacroStabilityInwardsCalculationScenario calculation = MacroStabilityInwardsCalculationScenarioTestFactory.CreateMacroStabilityInwardsCalculationScenarioWithValidInput(new TestHydraulicBoundaryLocation());
using (new MacroStabilityInwardsCalculatorFactoryConfig())
{
// Call
MacroStabilityInwardsWaternet waternet = DerivedMacroStabilityInwardsInput.GetWaternetExtreme(calculation.InputParameters, new GeneralMacroStabilityInwardsInput(), assessmentLevel);
// Assert
var calculatorFactory = (TestMacroStabilityInwardsCalculatorFactory)MacroStabilityInwardsCalculatorFactory.Instance;
WaternetCalculatorStub calculator = calculatorFactory.LastCreatedWaternetExtremeCalculator;
Assert.AreEqual(assessmentLevel, calculator.Input.AssessmentLevel);
CalculatorOutputAssert.AssertWaternet(calculator.Output, waternet);
}
}
public void WaternetDaily_ValidWaternet_ExpectedValue()
{
// Setup
MacroStabilityInwardsCalculationScenario calculation = MacroStabilityInwardsCalculationScenarioTestFactory.CreateMacroStabilityInwardsCalculationScenarioWithValidInput(new TestHydraulicBoundaryLocation());
var properties = new MacroStabilityInwardsWaterStressLinesProperties(calculation.InputParameters,
new GeneralMacroStabilityInwardsInput(),
AssessmentSectionTestHelper.GetTestAssessmentLevel());
using (new MacroStabilityInwardsCalculatorFactoryConfig())
{
// Call
MacroStabilityInwardsWaternetProperties waternetProperties = properties.WaternetDaily;
// Assert
var calculatorFactory = (TestMacroStabilityInwardsCalculatorFactory)MacroStabilityInwardsCalculatorFactory.Instance;
CalculatorOutputAssert.AssertWaternet(calculatorFactory.LastCreatedWaternetDailyCalculator.Output, (MacroStabilityInwardsWaternet)waternetProperties.Data);
}
}
public void WaternetExtreme_ValidWaternet_ExpectedValue()
{
// Setup
RoundedDouble assessmentLevel = new Random(21).NextRoundedDouble();
MacroStabilityInwardsCalculationScenario calculation = MacroStabilityInwardsCalculationScenarioTestFactory.CreateMacroStabilityInwardsCalculationScenarioWithValidInput(new TestHydraulicBoundaryLocation());
var properties = new MacroStabilityInwardsWaterStressLinesProperties(calculation.InputParameters, new GeneralMacroStabilityInwardsInput(), assessmentLevel);
using (new MacroStabilityInwardsCalculatorFactoryConfig())
{
// Call
MacroStabilityInwardsWaternetProperties waternetProperties = properties.WaternetExtreme;
// Assert
var calculatorFactory = (TestMacroStabilityInwardsCalculatorFactory)MacroStabilityInwardsCalculatorFactory.Instance;
WaternetCalculatorStub calculator = calculatorFactory.LastCreatedWaternetExtremeCalculator;
Assert.AreEqual(assessmentLevel, calculator.Input.AssessmentLevel);
CalculatorOutputAssert.AssertWaternet(calculator.Output, (MacroStabilityInwardsWaternet)waternetProperties.Data);
}
}
public void Constructor_CalculationWithOutput_DataSetToChartControl()
{
// Setup
MacroStabilityInwardsCalculationScenario calculation = MacroStabilityInwardsCalculationScenarioTestFactory.CreateMacroStabilityInwardsCalculationScenarioWithValidInput(new TestHydraulicBoundaryLocation());
calculation.Output = MacroStabilityInwardsOutputTestFactory.CreateOutput();
// Call
using (new MacroStabilityInwardsCalculatorFactoryConfig())
using (var view = new MacroStabilityInwardsOutputView(calculation, new GeneralMacroStabilityInwardsInput(), AssessmentSectionTestHelper.GetTestAssessmentLevel))
using (var form = new Form())
{
form.Controls.Add(view);
form.Show();
MacroStabilityInwardsOutputChartControl chartControl = GetChartControl(form);
// Assert
Assert.AreSame(calculation, chartControl.Data);
}
}
