public void Validate_KernelReturnsValidationResults_ReturnsEnumerableWithOnlyErrorsAndWarnings() { // Setup using (new MacroStabilityInwardsKernelFactoryConfig()) { var factory = (TestMacroStabilityInwardsKernelFactory)MacroStabilityInwardsKernelWrapperFactory.Instance; WaternetKernelStub waternetKernel = factory.LastCreatedWaternetExtremeKernel; waternetKernel.ReturnValidationResults = true; WaternetCalculatorInput input = WaternetCalculatorInputTestFactory.CreateValidCalculatorInput(); var calculator = new TestWaternetCalculator(input, factory); // Call IEnumerable <MacroStabilityInwardsKernelMessage> kernelMessages = calculator.Validate(); // Assert Assert.AreEqual(2, kernelMessages.Count()); MacroStabilityInwardsKernelMessage firstMessage = kernelMessages.ElementAt(0); Assert.AreEqual("Validation Warning", firstMessage.Message); Assert.AreEqual(MacroStabilityInwardsKernelMessageType.Warning, firstMessage.Type); MacroStabilityInwardsKernelMessage secondMessage = kernelMessages.ElementAt(1); Assert.AreEqual("Validation Error", secondMessage.Message); Assert.AreEqual(MacroStabilityInwardsKernelMessageType.Error, secondMessage.Type); } }
public void Calculate_KernelWithCompleteOutput_OutputCorrectlyReturnedByCalculator() { // Setup WaternetCalculatorInput input = WaternetCalculatorInputTestFactory.CreateValidCalculatorInput(); using (new MacroStabilityInwardsKernelFactoryConfig()) { var factory = (TestMacroStabilityInwardsKernelFactory)MacroStabilityInwardsKernelWrapperFactory.Instance; WaternetKernelStub kernel = factory.LastCreatedWaternetExtremeKernel; SetCompleteKernelOutput(kernel); // Call WaternetCalculatorResult result = new TestWaternetCalculator(input, factory).Calculate(); // Assert Assert.IsNotNull(result); var expectedPhreaticLines = new List <HeadLine> { kernel.Waternet.PhreaticLine }; expectedPhreaticLines.AddRange(kernel.Waternet.HeadLines); WaternetCalculatorOutputAssert.AssertPhreaticLines(expectedPhreaticLines.ToArray(), result.PhreaticLines.ToArray()); WaternetCalculatorOutputAssert.AssertReferenceLines(kernel.Waternet.ReferenceLines.ToArray(), result.WaternetLines.ToArray()); } }
public void Calculate_CalculatorWithCompleteInput_InputCorrectlySetToKernel() { // Setup WaternetCalculatorInput input = WaternetCalculatorInputTestFactory.CreateCompleteCalculatorInput(); using (new MacroStabilityInwardsKernelFactoryConfig()) { var factory = (TestMacroStabilityInwardsKernelFactory)MacroStabilityInwardsKernelWrapperFactory.Instance; WaternetKernelStub waternetKernel = factory.LastCreatedWaternetExtremeKernel; waternetKernel.Waternet = new CSharpWrapperWaternet { HeadLines = new List <HeadLine>(), ReferenceLines = new List <ReferenceLine>(), PhreaticLine = new HeadLine { Name = string.Empty } }; // Call new WaternetExtremeCalculator(input, factory).Calculate(); // Assert WaternetKernelInputAssert.AssertMacroStabilityInput(MacroStabilityInputCreator.CreateWaternet(input), waternetKernel.KernelInput); } }
public void Constructor_FactoryNull_ArgumentNullException() { // Setup WaternetCalculatorInput input = WaternetCalculatorInputTestFactory.CreateValidCalculatorInput(); // Call void Call() => new TestWaternetCalculator(input, null); // Assert var exception = Assert.Throws <ArgumentNullException>(Call); Assert.AreEqual("factory", exception.ParamName); }
/// <summary> /// Creates <see cref="MacroStabilityInput"/> objects based on the given input for the Waternet calculation. /// </summary> /// <param name="waternetInput">The <see cref="WaternetCalculatorInput"/> containing all the values required /// for performing the Waternet calculation.</param> /// <returns>The created <see cref="MacroStabilityInput"/>.</returns> /// <exception cref="ArgumentNullException">Thrown when any parameter is <c>null</c>.</exception> public static MacroStabilityInput CreateWaternet(WaternetCalculatorInput waternetInput) { if (waternetInput == null) { throw new ArgumentNullException(nameof(waternetInput)); } LayerWithSoil[] layersWithSoil = LayerWithSoilCreator.Create(waternetInput.SoilProfile, out IDictionary <SoilLayer, LayerWithSoil> _); return(CreateWaternet( layersWithSoil.Select(lws => lws.Soil).ToList(), SurfaceLineCreator.Create(waternetInput.SurfaceLine), SoilProfileCreator.Create(layersWithSoil), WaternetCreatorInputCreator.Create(waternetInput))); }
/// <summary> /// Creates a new instance of <see cref="WaternetCalculator"/>. /// </summary> /// <param name="input">The <see cref="WaternetCalculatorInput"/> containing all the values /// required for performing the Waternet calculation.</param> /// <param name="factory">The factory responsible for creating the Waternet kernel.</param> /// <exception cref="ArgumentNullException">Thrown when any parameter /// is <c>null</c>.</exception> protected WaternetCalculator(WaternetCalculatorInput input, IMacroStabilityInwardsKernelFactory factory) { if (input == null) { throw new ArgumentNullException(nameof(input)); } if (factory == null) { throw new ArgumentNullException(nameof(factory)); } Input = input; Factory = factory; }
public void CalculateDaily_WithInput_SetsInputOnCalculator() { // Setup MacroStabilityInwardsInput input = testCalculation.InputParameters; using (new MacroStabilityInwardsCalculatorFactoryConfig()) { // Call WaternetCalculationService.CalculateDaily(input, new GeneralMacroStabilityInwardsInput()); // Assert var factory = (TestMacroStabilityInwardsCalculatorFactory)MacroStabilityInwardsCalculatorFactory.Instance; WaternetCalculatorInput actualInput = factory.LastCreatedWaternetDailyCalculator.Input; CalculatorInputAssert.AssertDailyInput(input, actualInput); } }
public void Validate_CalculatorWithValidInput_KernelValidateMethodCalled() { // Setup using (new MacroStabilityInwardsKernelFactoryConfig()) { var factory = (TestMacroStabilityInwardsKernelFactory)MacroStabilityInwardsKernelWrapperFactory.Instance; WaternetCalculatorInput input = WaternetCalculatorInputTestFactory.CreateValidCalculatorInput(); var calculator = new TestWaternetCalculator(input, factory); // Call calculator.Validate(); // Assert Assert.IsTrue(factory.LastCreatedWaternetExtremeKernel.Validated); } }
public void Validate_CalculatorWithValidInput_ReturnEmptyEnumerable() { // Setup using (new MacroStabilityInwardsKernelFactoryConfig()) { var factory = (TestMacroStabilityInwardsKernelFactory)MacroStabilityInwardsKernelWrapperFactory.Instance; WaternetCalculatorInput input = WaternetCalculatorInputTestFactory.CreateValidCalculatorInput(); var calculator = new TestWaternetCalculator(input, factory); // Call IEnumerable <MacroStabilityInwardsKernelMessage> kernelMessages = calculator.Validate(); // Assert CollectionAssert.IsEmpty(kernelMessages); } }
public void Constructor_ExpectedValues() { // Setup var mocks = new MockRepository(); var factory = mocks.Stub <IMacroStabilityInwardsKernelFactory>(); mocks.ReplayAll(); WaternetCalculatorInput input = WaternetCalculatorInputTestFactory.CreateValidCalculatorInput(); // Call var calculator = new WaternetExtremeCalculator(input, factory); // Assert Assert.IsInstanceOf <WaternetCalculator>(calculator); mocks.VerifyAll(); }
public void ValidateExtreme_WithInput_SetsInputOnCalculator() { // Setup RoundedDouble assessmentLevel = new Random(21).NextRoundedDouble(); MacroStabilityInwardsInput input = testCalculation.InputParameters; using (new MacroStabilityInwardsCalculatorFactoryConfig()) { // Call WaternetCalculationService.ValidateExtreme(input, new GeneralMacroStabilityInwardsInput(), assessmentLevel); // Assert var factory = (TestMacroStabilityInwardsCalculatorFactory)MacroStabilityInwardsCalculatorFactory.Instance; WaternetCalculatorInput actualInput = factory.LastCreatedWaternetExtremeCalculator.Input; CalculatorInputAssert.AssertExtremeInput(input, actualInput, assessmentLevel); } }
public void Calculate_CalculatorWithValidInput_KernelCalculateMethodCalled() { // Setup WaternetCalculatorInput input = WaternetCalculatorInputTestFactory.CreateValidCalculatorInput(); using (new MacroStabilityInwardsKernelFactoryConfig()) { var factory = (TestMacroStabilityInwardsKernelFactory)MacroStabilityInwardsKernelWrapperFactory.Instance; WaternetKernelStub waternetKernel = factory.LastCreatedWaternetExtremeKernel; SetCompleteKernelOutput(waternetKernel); // Call new TestWaternetCalculator(input, factory).Calculate(); // Assert Assert.IsTrue(waternetKernel.Calculated); } }
public void Create_ValidDikeSoilScenario_ReturnInputWithDikeSoilScenario(MacroStabilityInwardsDikeSoilScenario macroStabilityInwardsDikeSoilScenario, DikeSoilScenario expectedDikeSoilScenario) { // Setup var input = new WaternetCalculatorInput( new WaternetCalculatorInput.ConstructionProperties { DrainageConstruction = new DrainageConstruction(), PhreaticLineOffsets = new PhreaticLineOffsets(), SurfaceLine = new MacroStabilityInwardsSurfaceLine("test"), SoilProfile = new TestSoilProfile(), DikeSoilScenario = macroStabilityInwardsDikeSoilScenario }); // Call WaternetCreatorInput waternetCreatorInput = WaternetCreatorInputCreator.Create(input); // Assert Assert.AreEqual(expectedDikeSoilScenario, waternetCreatorInput.DikeSoilScenario); }
public void Calculate_KernelThrowsWaternetKernelWrapperException_ThrowWaternetCalculatorException() { // Setup WaternetCalculatorInput input = WaternetCalculatorInputTestFactory.CreateValidCalculatorInput(); using (new MacroStabilityInwardsKernelFactoryConfig()) { var factory = (TestMacroStabilityInwardsKernelFactory)MacroStabilityInwardsKernelWrapperFactory.Instance; WaternetKernelStub waternetKernel = factory.LastCreatedWaternetExtremeKernel; waternetKernel.ThrowExceptionOnCalculate = true; // Call void Call() => new TestWaternetCalculator(input, factory).Calculate(); // Assert var exception = Assert.Throws <WaternetCalculatorException>(Call); Assert.IsInstanceOf <WaternetKernelWrapperException>(exception.InnerException); Assert.AreEqual(exception.InnerException.Message, exception.Message); } }
public void CreateWaternet_ValidData_ReturnMacroStabilityInput() { // Setup WaternetCalculatorInput input = WaternetCalculatorInputTestFactory.CreateValidCalculatorInput(); // Call MacroStabilityInput macroStabilityInput = MacroStabilityInputCreator.CreateWaternet(input); // Assert LayerWithSoil[] layersWithSoil = LayerWithSoilCreator.Create(input.SoilProfile, out IDictionary <SoilLayer, LayerWithSoil> _); CollectionAssert.AreEqual(layersWithSoil.Select(lws => lws.Soil).ToList(), macroStabilityInput.StabilityModel.Soils, new SoilComparer()); KernelInputAssert.AssertSoilProfile(SoilProfileCreator.Create(layersWithSoil), macroStabilityInput.StabilityModel.ConstructionStages.Single().SoilProfile); PreConstructionStage preConstructionStage = macroStabilityInput.PreprocessingInput.PreConstructionStages.Single(); KernelInputAssert.AssertSurfaceLine(SurfaceLineCreator.Create(input.SurfaceLine), preConstructionStage.SurfaceLine); Assert.IsTrue(preConstructionStage.CreateWaternet); KernelInputAssert.AssertWaternetCreatorInput(WaternetCreatorInputCreator.Create(input), preConstructionStage.WaternetCreatorInput); }
public void Create_InvalidDikeSoilScenario_ThrowInvalidEnumArgumentException() { // Setup var input = new WaternetCalculatorInput( new WaternetCalculatorInput.ConstructionProperties { SurfaceLine = new MacroStabilityInwardsSurfaceLine("test"), SoilProfile = new TestSoilProfile(), PhreaticLineOffsets = new PhreaticLineOffsets(), DrainageConstruction = new DrainageConstruction(), DikeSoilScenario = (MacroStabilityInwardsDikeSoilScenario)99 }); // Call void Call() => WaternetCreatorInputCreator.Create(input); // Assert string message = $"The value of argument 'dikeSoilScenario' ({99}) is invalid for Enum type '{nameof(MacroStabilityInwardsDikeSoilScenario)}'."; TestHelper.AssertThrowsArgumentExceptionAndTestMessage <InvalidEnumArgumentException>(Call, message); }
/// <summary> /// Creates a <see cref="WaternetCreatorInput"/> based on the given <paramref name="input"/> /// which can be used by <see cref="IWaternetKernel"/>. /// </summary> /// <param name="input">The <see cref="WaternetCalculatorInput"/> to get the information from.</param> /// <returns>A new <see cref="WaternetCreatorInput"/> with the given information from <paramref name="input"/>.</returns> /// <exception cref="ArgumentNullException">Thrown when <paramref name="input"/> is <c>null</c>.</exception> /// <exception cref="InvalidEnumArgumentException">Thrown when <see cref="WaternetCalculatorInput.DikeSoilScenario"/> /// is an invalid value.</exception> /// <exception cref="NotSupportedException">Thrown when <see cref="WaternetCalculatorInput.DikeSoilScenario"/> /// is a valid value, but unsupported.</exception> public static WaternetCreatorInput Create(WaternetCalculatorInput input) { if (input == null) { throw new ArgumentNullException(nameof(input)); } return(new WaternetCreatorInput { DikeSoilScenario = WaternetCreatorInputHelper.ConvertDikeSoilScenario(input.DikeSoilScenario), WaterLevelRiver = input.AssessmentLevel, HeadInPlLine3 = input.AssessmentLevel, HeadInPlLine4 = input.AssessmentLevel, WaterLevelRiverAverage = input.WaterLevelRiverAverage, WaterLevelPolder = input.WaterLevelPolder, DrainageConstructionPresent = input.DrainageConstruction.IsPresent, DrainageConstruction = input.DrainageConstruction.IsPresent ? new Point2D(input.DrainageConstruction.XCoordinate, input.DrainageConstruction.ZCoordinate) : null, MinimumLevelPhreaticLineAtDikeTopRiver = input.MinimumLevelPhreaticLineAtDikeTopRiver, MinimumLevelPhreaticLineAtDikeTopPolder = input.MinimumLevelPhreaticLineAtDikeTopPolder, UseDefaultOffsets = input.PhreaticLineOffsets.UseDefaults, PlLineOffsetBelowPointBRingtoetsWti2017 = input.PhreaticLineOffsets.BelowDikeTopAtRiver, PlLineOffsetBelowDikeTopAtPolder = input.PhreaticLineOffsets.BelowDikeTopAtPolder, PlLineOffsetBelowShoulderBaseInside = input.PhreaticLineOffsets.BelowShoulderBaseInside, PlLineOffsetBelowDikeToeAtPolder = input.PhreaticLineOffsets.BelowDikeToeAtPolder, AdjustPl3And4ForUplift = input.AdjustPhreaticLine3And4ForUplift, LeakageLengthOutwardsPl3 = input.LeakageLengthOutwardsPhreaticLine3, LeakageLengthInwardsPl3 = input.LeakageLengthInwardsPhreaticLine3, LeakageLengthOutwardsPl4 = input.LeakageLengthOutwardsPhreaticLine4, LeakageLengthInwardsPl4 = input.LeakageLengthInwardsPhreaticLine4, HeadInPlLine2Outwards = input.PiezometricHeadPhreaticLine2Outwards, HeadInPlLine2Inwards = input.PiezometricHeadPhreaticLine2Inwards, PenetrationLength = input.PenetrationLength, UnitWeightWater = input.WaterVolumetricWeight }); }
public void Constructor_EmptyConstructionProperties_ExpectedValues() { // Setup var surfaceLine = new MacroStabilityInwardsSurfaceLine(string.Empty); var soilProfile = new TestSoilProfile(); var drainageConstruction = new DrainageConstruction(); var phreaticLineOffsets = new PhreaticLineOffsets(); // Call var input = new WaternetCalculatorInput( new WaternetCalculatorInput.ConstructionProperties { SurfaceLine = surfaceLine, SoilProfile = soilProfile, DrainageConstruction = drainageConstruction, PhreaticLineOffsets = phreaticLineOffsets }); // Assert Assert.IsNaN(input.AssessmentLevel); Assert.IsNaN(input.WaterLevelRiverAverage); Assert.IsNaN(input.WaterLevelPolder); Assert.IsNaN(input.MinimumLevelPhreaticLineAtDikeTopRiver); Assert.IsNaN(input.MinimumLevelPhreaticLineAtDikeTopPolder); Assert.IsNaN(input.LeakageLengthOutwardsPhreaticLine3); Assert.IsNaN(input.LeakageLengthInwardsPhreaticLine3); Assert.IsNaN(input.LeakageLengthOutwardsPhreaticLine4); Assert.IsNaN(input.LeakageLengthInwardsPhreaticLine4); Assert.IsNaN(input.PiezometricHeadPhreaticLine2Outwards); Assert.IsNaN(input.PiezometricHeadPhreaticLine2Inwards); Assert.IsNaN(input.PenetrationLength); Assert.IsFalse(input.AdjustPhreaticLine3And4ForUplift); Assert.IsNaN(input.WaterVolumetricWeight); Assert.AreEqual(MacroStabilityInwardsDikeSoilScenario.ClayDikeOnClay, input.DikeSoilScenario); }
public void Create_WithInput_ReturnWaternetCreatorInput([Values(true, false)] bool drainageConstructionPresent, [Values(true, false)] bool useDefaultOffsets) { // Setup var random = new Random(21); double assessmentLevel = random.Next(); double waterLevelRiverAverage = random.Next(); double waterLevelPolderExtreme = random.Next(); double minimumLevelPhreaticLineAtDikeTopRiver = random.Next(); double minimumLevelPhreaticLineAtDikeTopPolder = random.Next(); bool adjustPhreaticLine3And4ForUplift = random.NextBoolean(); double leakageLengthOutwardsPhreaticLine3 = random.Next(); double leakageLengthInwardsPhreaticLine3 = random.Next(); double leakageLengthOutwardsPhreaticLine4 = random.Next(); double leakageLengthInwardsPhreaticLine4 = random.Next(); double piezometricHeadPhreaticLine2Outwards = random.Next(); double piezometricHeadPhreaticLine2Inwards = random.Next(); double penetrationLength = random.Next(); double waterVolumetricWeight = random.Next(); DrainageConstruction drainageConstruction = drainageConstructionPresent ? new DrainageConstruction(random.Next(), random.Next()) : new DrainageConstruction(); PhreaticLineOffsets phreaticLineOffsets = useDefaultOffsets ? new PhreaticLineOffsets() : new PhreaticLineOffsets(random.Next(), random.Next(), random.Next(), random.Next()); var input = new WaternetCalculatorInput( new WaternetCalculatorInput.ConstructionProperties { SurfaceLine = new MacroStabilityInwardsSurfaceLine("test"), SoilProfile = new TestSoilProfile(), DikeSoilScenario = MacroStabilityInwardsDikeSoilScenario.SandDikeOnClay, AssessmentLevel = assessmentLevel, WaterLevelRiverAverage = waterLevelRiverAverage, WaterLevelPolder = waterLevelPolderExtreme, DrainageConstruction = drainageConstruction, PhreaticLineOffsets = phreaticLineOffsets, MinimumLevelPhreaticLineAtDikeTopRiver = minimumLevelPhreaticLineAtDikeTopRiver, MinimumLevelPhreaticLineAtDikeTopPolder = minimumLevelPhreaticLineAtDikeTopPolder, AdjustPhreaticLine3And4ForUplift = adjustPhreaticLine3And4ForUplift, LeakageLengthOutwardsPhreaticLine3 = leakageLengthOutwardsPhreaticLine3, LeakageLengthInwardsPhreaticLine3 = leakageLengthInwardsPhreaticLine3, LeakageLengthOutwardsPhreaticLine4 = leakageLengthOutwardsPhreaticLine4, LeakageLengthInwardsPhreaticLine4 = leakageLengthInwardsPhreaticLine4, PiezometricHeadPhreaticLine2Outwards = piezometricHeadPhreaticLine2Outwards, PiezometricHeadPhreaticLine2Inwards = piezometricHeadPhreaticLine2Inwards, PenetrationLength = penetrationLength, WaterVolumetricWeight = waterVolumetricWeight }); // Call WaternetCreatorInput waternetCreatorInput = WaternetCreatorInputCreator.Create(input); // Assert Assert.AreEqual(DikeSoilScenario.SandDikeOnClay, waternetCreatorInput.DikeSoilScenario); Assert.AreEqual(assessmentLevel, waternetCreatorInput.WaterLevelRiver); Assert.AreEqual(assessmentLevel, waternetCreatorInput.HeadInPlLine3); Assert.AreEqual(assessmentLevel, waternetCreatorInput.HeadInPlLine4); Assert.AreEqual(waterLevelRiverAverage, waternetCreatorInput.WaterLevelRiverAverage); Assert.AreEqual(waterLevelPolderExtreme, waternetCreatorInput.WaterLevelPolder); Assert.AreEqual(drainageConstruction.IsPresent, waternetCreatorInput.DrainageConstructionPresent); if (drainageConstructionPresent) { Assert.AreEqual(drainageConstruction.XCoordinate, waternetCreatorInput.DrainageConstruction.X); Assert.AreEqual(drainageConstruction.ZCoordinate, waternetCreatorInput.DrainageConstruction.Z); } Assert.AreEqual(minimumLevelPhreaticLineAtDikeTopRiver, waternetCreatorInput.MinimumLevelPhreaticLineAtDikeTopRiver); Assert.AreEqual(minimumLevelPhreaticLineAtDikeTopPolder, waternetCreatorInput.MinimumLevelPhreaticLineAtDikeTopPolder); Assert.AreEqual(phreaticLineOffsets.UseDefaults, waternetCreatorInput.UseDefaultOffsets); Assert.AreEqual(phreaticLineOffsets.BelowDikeTopAtRiver, waternetCreatorInput.PlLineOffsetBelowPointBRingtoetsWti2017); Assert.AreEqual(phreaticLineOffsets.BelowDikeTopAtPolder, waternetCreatorInput.PlLineOffsetBelowDikeTopAtPolder); Assert.AreEqual(phreaticLineOffsets.BelowShoulderBaseInside, waternetCreatorInput.PlLineOffsetBelowShoulderBaseInside); Assert.AreEqual(phreaticLineOffsets.BelowDikeToeAtPolder, waternetCreatorInput.PlLineOffsetBelowDikeToeAtPolder); Assert.AreEqual(adjustPhreaticLine3And4ForUplift, waternetCreatorInput.AdjustPl3And4ForUplift); Assert.AreEqual(leakageLengthOutwardsPhreaticLine3, waternetCreatorInput.LeakageLengthOutwardsPl3); Assert.AreEqual(leakageLengthInwardsPhreaticLine3, waternetCreatorInput.LeakageLengthInwardsPl3); Assert.AreEqual(leakageLengthOutwardsPhreaticLine4, waternetCreatorInput.LeakageLengthOutwardsPl4); Assert.AreEqual(leakageLengthInwardsPhreaticLine4, waternetCreatorInput.LeakageLengthInwardsPl4); Assert.AreEqual(piezometricHeadPhreaticLine2Outwards, waternetCreatorInput.HeadInPlLine2Outwards); Assert.AreEqual(piezometricHeadPhreaticLine2Inwards, waternetCreatorInput.HeadInPlLine2Inwards); Assert.AreEqual(penetrationLength, waternetCreatorInput.PenetrationLength); Assert.AreEqual(waterVolumetricWeight, waternetCreatorInput.UnitWeightWater); AssertIrrelevantValues(waternetCreatorInput); }
public TestWaternetCalculator(WaternetCalculatorInput input, IMacroStabilityInwardsKernelFactory factory) : base(input, factory) { }
/// <summary> /// Asserts whether <paramref name="actual"/> corresponds to <paramref name="original"/>. /// </summary> /// <param name="original">The original <see cref="IMacroStabilityInwardsWaternetInput"/>.</param> /// <param name="actual">The actual <see cref="WaternetCalculatorInput"/>.</param> /// <exception cref="AssertionException">Thrown when <paramref name="actual"/> /// does not correspond to <paramref name="original"/>.</exception> private static void AssertGenericInput(IMacroStabilityInwardsWaternetInput original, WaternetCalculatorInput actual) { AssertSoilProfile(original.SoilProfileUnderSurfaceLine, actual.SoilProfile); AssertDrainageConstruction(original, actual.DrainageConstruction); Assert.AreSame(original.SurfaceLine, actual.SurfaceLine); Assert.AreEqual(original.DikeSoilScenario, actual.DikeSoilScenario); Assert.AreEqual(original.WaterLevelRiverAverage, actual.WaterLevelRiverAverage); Assert.AreEqual(original.MinimumLevelPhreaticLineAtDikeTopRiver, actual.MinimumLevelPhreaticLineAtDikeTopRiver); Assert.AreEqual(original.MinimumLevelPhreaticLineAtDikeTopPolder, actual.MinimumLevelPhreaticLineAtDikeTopPolder); Assert.AreEqual(original.LeakageLengthOutwardsPhreaticLine3, actual.LeakageLengthOutwardsPhreaticLine3); Assert.AreEqual(original.LeakageLengthInwardsPhreaticLine3, actual.LeakageLengthInwardsPhreaticLine3); Assert.AreEqual(original.LeakageLengthOutwardsPhreaticLine4, actual.LeakageLengthOutwardsPhreaticLine4); Assert.AreEqual(original.LeakageLengthInwardsPhreaticLine4, actual.LeakageLengthInwardsPhreaticLine4); Assert.AreEqual(original.PiezometricHeadPhreaticLine2Outwards, actual.PiezometricHeadPhreaticLine2Outwards); Assert.AreEqual(original.PiezometricHeadPhreaticLine2Inwards, actual.PiezometricHeadPhreaticLine2Inwards); Assert.AreEqual(original.AdjustPhreaticLine3And4ForUplift, actual.AdjustPhreaticLine3And4ForUplift); }
/// <summary> /// Asserts whether <paramref name="actual"/> corresponds to <paramref name="original"/>. /// </summary> /// <param name="original">The original <see cref="IMacroStabilityInwardsWaternetInput"/>.</param> /// <param name="actual">The actual <see cref="WaternetCalculatorInput"/>.</param> /// <exception cref="AssertionException">Thrown when <paramref name="actual"/> /// does not correspond to <paramref name="original"/>.</exception> public static void AssertDailyInput(IMacroStabilityInwardsWaternetInput original, WaternetCalculatorInput actual) { AssertPhreaticLineOffsets(original.LocationInputDaily, actual.PhreaticLineOffsets); Assert.AreEqual(original.LocationInputDaily.WaterLevelPolder, actual.WaterLevelPolder); Assert.AreEqual(original.LocationInputDaily.PenetrationLength, actual.PenetrationLength); Assert.AreEqual(original.WaterLevelRiverAverage, actual.AssessmentLevel); AssertGenericInput(original, actual); }
/// <summary> /// Asserts whether <paramref name="actual"/> corresponds to <paramref name="original"/>. /// </summary> /// <param name="original">The original <see cref="IMacroStabilityInwardsWaternetInput"/>.</param> /// <param name="actual">The actual <see cref="WaternetCalculatorInput"/>.</param> /// <param name="assessmentLevel">The assessment level to assert.</param> /// <exception cref="AssertionException">Thrown when <paramref name="actual"/> /// does not correspond to <paramref name="original"/> or <paramref name="assessmentLevel"/>.</exception> public static void AssertExtremeInput(IMacroStabilityInwardsWaternetInput original, WaternetCalculatorInput actual, double assessmentLevel) { AssertPhreaticLineOffsets(original.LocationInputExtreme, actual.PhreaticLineOffsets); Assert.AreEqual(original.LocationInputExtreme.WaterLevelPolder, actual.WaterLevelPolder); Assert.AreEqual(original.LocationInputExtreme.PenetrationLength, actual.PenetrationLength); Assert.AreEqual(assessmentLevel, actual.AssessmentLevel); AssertGenericInput(original, actual); }
private IWaternetCalculator CreateWaternetCalculator(WaternetCalculatorInput input, WaternetCalculatorStub calculator) { calculator.Input = input; return(calculator); }
public IWaternetCalculator CreateWaternetExtremeCalculator(WaternetCalculatorInput input, IMacroStabilityInwardsKernelFactory factory) { return(new WaternetExtremeCalculator(input, factory)); }
public void Constructor_WithConstructionProperties_PropertiesAreSet() { // Setup var random = new Random(11); double assessmentLevel = random.NextDouble(); var surfaceLine = new MacroStabilityInwardsSurfaceLine(string.Empty); var soilProfile = new TestSoilProfile(); var drainageConstruction = new DrainageConstruction(); var phreaticLineOffsets = new PhreaticLineOffsets(); double waterLevelRiverAverage = random.NextDouble(); double waterLevelPolder = random.NextDouble(); double minimumLevelPhreaticLineAtDikeTopRiver = random.NextDouble(); double minimumLevelPhreaticLineAtDikeTopPolder = random.NextDouble(); double leakageLengthOutwardsPhreaticLine3 = random.NextDouble(); double leakageLengthInwardsPhreaticLine3 = random.NextDouble(); double leakageLengthOutwardsPhreaticLine4 = random.NextDouble(); double leakageLengthInwardsPhreaticLine4 = random.NextDouble(); double piezometricHeadPhreaticLine2Outwards = random.NextDouble(); double piezometricHeadPhreaticLine2Inwards = random.NextDouble(); double penetrationLength = random.NextDouble(); bool adjustPhreaticLine3And4ForUplift = random.NextBoolean(); var dikeSoilScenario = random.NextEnumValue <MacroStabilityInwardsDikeSoilScenario>(); double waterVolumetricWeight = random.NextDouble(); // Call var input = new WaternetCalculatorInput( new WaternetCalculatorInput.ConstructionProperties { AssessmentLevel = assessmentLevel, SurfaceLine = surfaceLine, SoilProfile = soilProfile, DrainageConstruction = drainageConstruction, PhreaticLineOffsets = phreaticLineOffsets, WaterLevelRiverAverage = waterLevelRiverAverage, WaterLevelPolder = waterLevelPolder, MinimumLevelPhreaticLineAtDikeTopRiver = minimumLevelPhreaticLineAtDikeTopRiver, MinimumLevelPhreaticLineAtDikeTopPolder = minimumLevelPhreaticLineAtDikeTopPolder, LeakageLengthOutwardsPhreaticLine3 = leakageLengthOutwardsPhreaticLine3, LeakageLengthInwardsPhreaticLine3 = leakageLengthInwardsPhreaticLine3, LeakageLengthOutwardsPhreaticLine4 = leakageLengthOutwardsPhreaticLine4, LeakageLengthInwardsPhreaticLine4 = leakageLengthInwardsPhreaticLine4, PiezometricHeadPhreaticLine2Outwards = piezometricHeadPhreaticLine2Outwards, PiezometricHeadPhreaticLine2Inwards = piezometricHeadPhreaticLine2Inwards, PenetrationLength = penetrationLength, AdjustPhreaticLine3And4ForUplift = adjustPhreaticLine3And4ForUplift, DikeSoilScenario = dikeSoilScenario, WaterVolumetricWeight = waterVolumetricWeight }); // Assert Assert.AreEqual(assessmentLevel, input.AssessmentLevel); Assert.AreSame(surfaceLine, input.SurfaceLine); Assert.AreSame(soilProfile, input.SoilProfile); Assert.AreSame(drainageConstruction, input.DrainageConstruction); Assert.AreSame(phreaticLineOffsets, input.PhreaticLineOffsets); Assert.AreEqual(waterLevelRiverAverage, input.WaterLevelRiverAverage); Assert.AreEqual(waterLevelPolder, input.WaterLevelPolder); Assert.AreEqual(minimumLevelPhreaticLineAtDikeTopRiver, input.MinimumLevelPhreaticLineAtDikeTopRiver); Assert.AreEqual(minimumLevelPhreaticLineAtDikeTopPolder, input.MinimumLevelPhreaticLineAtDikeTopPolder); Assert.AreEqual(leakageLengthOutwardsPhreaticLine3, input.LeakageLengthOutwardsPhreaticLine3); Assert.AreEqual(leakageLengthInwardsPhreaticLine3, input.LeakageLengthInwardsPhreaticLine3); Assert.AreEqual(leakageLengthOutwardsPhreaticLine4, input.LeakageLengthOutwardsPhreaticLine4); Assert.AreEqual(leakageLengthInwardsPhreaticLine4, input.LeakageLengthInwardsPhreaticLine4); Assert.AreEqual(piezometricHeadPhreaticLine2Outwards, input.PiezometricHeadPhreaticLine2Outwards); Assert.AreEqual(piezometricHeadPhreaticLine2Inwards, input.PiezometricHeadPhreaticLine2Inwards); Assert.AreEqual(penetrationLength, input.PenetrationLength); Assert.AreEqual(adjustPhreaticLine3And4ForUplift, input.AdjustPhreaticLine3And4ForUplift); Assert.AreEqual(dikeSoilScenario, input.DikeSoilScenario); Assert.AreEqual(waterVolumetricWeight, input.WaterVolumetricWeight); }
public IWaternetCalculator CreateWaternetDailyCalculator(WaternetCalculatorInput input, IMacroStabilityInwardsKernelFactory factory) { return(CreateWaternetCalculator(input, LastCreatedWaternetDailyCalculator)); }