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));
}
