private static void SetInputParameters(GrassCoverErosionOutwardsWaveConditionsCalculationEntity entity,
GrassCoverErosionOutwardsWaveConditionsInput calculationInput,
PersistenceRegistry registry)
{
HydraulicBoundaryLocation hydraulicBoundaryLocation = calculationInput.HydraulicBoundaryLocation;
if (hydraulicBoundaryLocation != null)
{
entity.HydraulicLocationEntity = registry.Get(hydraulicBoundaryLocation);
}
if (calculationInput.ForeshoreProfile != null)
{
entity.ForeshoreProfileEntity = calculationInput.ForeshoreProfile.Create(registry, 0);
}
if (calculationInput.CalculationsTargetProbability != null)
{
entity.HydraulicLocationCalculationForTargetProbabilityCollectionEntity =
calculationInput.CalculationsTargetProbability.Create(HydraulicBoundaryLocationCalculationType.WaterLevel, 0, registry);
}
entity.Orientation = calculationInput.Orientation.ToNaNAsNull();
entity.UseBreakWater = Convert.ToByte(calculationInput.UseBreakWater);
entity.BreakWaterType = Convert.ToByte(calculationInput.BreakWater.Type);
entity.BreakWaterHeight = calculationInput.BreakWater.Height.ToNaNAsNull();
entity.UseForeshore = Convert.ToByte(calculationInput.UseForeshore);
entity.UpperBoundaryRevetment = calculationInput.UpperBoundaryRevetment.ToNaNAsNull();
entity.LowerBoundaryRevetment = calculationInput.LowerBoundaryRevetment.ToNaNAsNull();
entity.UpperBoundaryWaterLevels = calculationInput.UpperBoundaryWaterLevels.ToNaNAsNull();
entity.LowerBoundaryWaterLevels = calculationInput.LowerBoundaryWaterLevels.ToNaNAsNull();
entity.StepSize = Convert.ToByte(calculationInput.StepSize);
entity.CalculationType = Convert.ToByte(calculationInput.CalculationType);
entity.WaterLevelType = Convert.ToByte(calculationInput.WaterLevelType);
}
public void AddCalculationsFromLocations_MultipleLocationsEmptyCalculationBase_ReturnsUniquelyNamedCalculationsWithCorrectInputSet(
NormativeProbabilityType normativeProbabilityType,
WaveConditionsInputWaterLevelType expectedWaveConditionsInputWaterLevelType)
{
// Setup
const string name = "name";
var locations = new[]
{
new HydraulicBoundaryLocation(1, name, 1, 1),
new HydraulicBoundaryLocation(2, name, 2, 2)
};
var calculationBases = new List <ICalculationBase>();
// Call
GrassCoverErosionOutwardsWaveConditionsCalculationHelper.AddCalculationsFromLocations(locations, calculationBases, normativeProbabilityType);
// Assert
Assert.AreEqual(2, calculationBases.Count);
var firstCalculation = (GrassCoverErosionOutwardsWaveConditionsCalculation)calculationBases.First();
Assert.AreEqual(name, firstCalculation.Name);
GrassCoverErosionOutwardsWaveConditionsInput firstCalculationInput = firstCalculation.InputParameters;
Assert.AreEqual(locations[0], firstCalculationInput.HydraulicBoundaryLocation);
Assert.AreEqual(expectedWaveConditionsInputWaterLevelType, firstCalculationInput.WaterLevelType);
var secondCalculation = (GrassCoverErosionOutwardsWaveConditionsCalculation)calculationBases.ElementAt(1);
Assert.AreEqual($"{name} (1)", secondCalculation.Name);
GrassCoverErosionOutwardsWaveConditionsInput secondCalculationInput = secondCalculation.InputParameters;
Assert.AreSame(locations[1], secondCalculationInput.HydraulicBoundaryLocation);
Assert.AreEqual(expectedWaveConditionsInputWaterLevelType, secondCalculationInput.WaterLevelType);
}
public void Constructor_CalculationTypeWaveRunUpOrWaveImpact_PropertiesHaveExpectedAttributesValues(
GrassCoverErosionOutwardsWaveConditionsCalculationType calculationType, string expectedDisplayName, string expectedDescription)
{
// Setup
GrassCoverErosionOutwardsWaveConditionsOutput output = GrassCoverErosionOutwardsWaveConditionsOutputTestFactory.Create();
var input = new GrassCoverErosionOutwardsWaveConditionsInput
{
CalculationType = calculationType
};
// Call
var properties = new GrassCoverErosionOutwardsWaveConditionsOutputProperties(output, input);
// Assert
PropertyDescriptorCollection dynamicProperties = PropertiesTestHelper.GetAllVisiblePropertyDescriptors(properties);
Assert.AreEqual(1, dynamicProperties.Count);
PropertyDescriptor outputProperty = dynamicProperties[0];
PropertiesTestHelper.AssertRequiredPropertyDescriptorProperties(outputProperty,
"Resultaat",
expectedDisplayName,
expectedDescription,
true);
}
public void Read_EntityWithNullValues_ReturnCalculationWithNaNValues()
{
// Setup
var entity = new GrassCoverErosionOutwardsWaveConditionsCalculationEntity();
var collector = new ReadConversionCollector();
// Call
GrassCoverErosionOutwardsWaveConditionsCalculation calculation = entity.Read(collector);
// Assert
Assert.IsNull(calculation.Name);
Assert.IsNull(calculation.Comments.Body);
GrassCoverErosionOutwardsWaveConditionsInput calculationInput = calculation.InputParameters;
Assert.IsNaN(calculationInput.BreakWater.Height);
Assert.IsNaN(calculationInput.Orientation);
Assert.IsNaN(calculationInput.UpperBoundaryRevetment);
Assert.IsNaN(calculationInput.LowerBoundaryRevetment);
Assert.IsNaN(calculationInput.UpperBoundaryWaterLevels);
Assert.IsNaN(calculationInput.LowerBoundaryWaterLevels);
Assert.IsNull(calculationInput.HydraulicBoundaryLocation);
Assert.IsNull(calculationInput.ForeshoreProfile);
Assert.IsNull(calculation.Output);
}
public void Constructor_ExpectedValues()
{
// Call
var input = new GrassCoverErosionOutwardsWaveConditionsInput();
// Assert
Assert.IsInstanceOf <WaveConditionsInput>(input);
Assert.AreEqual(GrassCoverErosionOutwardsWaveConditionsCalculationType.WaveRunUpAndWaveImpact, input.CalculationType);
}
/// <summary>
/// Creates a new instance of <see cref="GrassCoverErosionOutwardsWaveConditionsOutputContext"/>.
/// </summary>
/// <param name="wrappedData">The wrapped data.</param>
/// <param name="input">The input belonging to the wrapped data.</param>
/// <exception cref="ArgumentNullException">Thrown when any parameter is <c>null</c>.</exception>
public GrassCoverErosionOutwardsWaveConditionsOutputContext(GrassCoverErosionOutwardsWaveConditionsOutput wrappedData,
GrassCoverErosionOutwardsWaveConditionsInput input)
: base(wrappedData)
{
if (input == null)
{
throw new ArgumentNullException(nameof(input));
}
Input = input;
}
public void Constructor_WithArguments_ExpectedValues()
{
// Setup
GrassCoverErosionOutwardsWaveConditionsOutput output = GrassCoverErosionOutwardsWaveConditionsOutputTestFactory.Create();
var input = new GrassCoverErosionOutwardsWaveConditionsInput();
// Call
var context = new GrassCoverErosionOutwardsWaveConditionsOutputContext(output, input);
// Assert
Assert.IsInstanceOf <ObservableWrappedObjectContextBase <GrassCoverErosionOutwardsWaveConditionsOutput> >(context);
Assert.AreSame(input, context.Input);
Assert.AreSame(output, context.WrappedData);
}
public void Create_CalculationWithPropertiesSet_ReturnCalculationEntity()
{
// Setup
var random = new Random(21);
int order = random.Next();
var calculation = new GrassCoverErosionOutwardsWaveConditionsCalculation
{
InputParameters =
{
Orientation = random.NextRoundedDouble(0, 360),
UseBreakWater = random.NextBoolean(),
UseForeshore = random.NextBoolean(),
UpperBoundaryRevetment = (RoundedDouble)6.10,
LowerBoundaryRevetment = (RoundedDouble)3.58,
UpperBoundaryWaterLevels = (RoundedDouble)5.88,
LowerBoundaryWaterLevels = (RoundedDouble)3.40,
StepSize = random.NextEnumValue <WaveConditionsInputStepSize>(),
CalculationType = random.NextEnumValue <GrassCoverErosionOutwardsWaveConditionsCalculationType>(),
WaterLevelType = random.NextEnumValue <WaveConditionsInputWaterLevelType>()
}
};
var registry = new PersistenceRegistry();
// Call
GrassCoverErosionOutwardsWaveConditionsCalculationEntity entity = calculation.Create(registry, order);
// Assert
GrassCoverErosionOutwardsWaveConditionsInput input = calculation.InputParameters;
Assert.AreEqual(input.Orientation, entity.Orientation, input.Orientation.GetAccuracy());
Assert.AreEqual(Convert.ToByte(input.UseBreakWater), entity.UseBreakWater);
Assert.AreEqual(Convert.ToByte(input.UseForeshore), entity.UseForeshore);
Assert.AreEqual(input.UpperBoundaryRevetment, entity.UpperBoundaryRevetment, input.UpperBoundaryRevetment.GetAccuracy());
Assert.AreEqual(input.LowerBoundaryRevetment, entity.LowerBoundaryRevetment, input.LowerBoundaryRevetment.GetAccuracy());
Assert.AreEqual(input.UpperBoundaryWaterLevels, entity.UpperBoundaryWaterLevels, input.UpperBoundaryWaterLevels.GetAccuracy());
Assert.AreEqual(input.LowerBoundaryWaterLevels, entity.LowerBoundaryWaterLevels, input.LowerBoundaryWaterLevels.GetAccuracy());
Assert.AreEqual(Convert.ToByte(input.StepSize), entity.StepSize);
Assert.AreEqual(Convert.ToByte(input.CalculationType), entity.CalculationType);
Assert.AreEqual(Convert.ToByte(input.WaterLevelType), entity.WaterLevelType);
Assert.AreEqual(order, entity.Order);
Assert.IsNull(entity.CalculationGroupEntity);
CollectionAssert.IsEmpty(entity.GrassCoverErosionOutwardsWaveConditionsOutputEntities);
Assert.IsNull(entity.ForeshoreProfileEntity);
Assert.IsNull(entity.HydraulicLocationEntity);
Assert.IsNull(entity.HydraulicLocationCalculationForTargetProbabilityCollectionEntity);
}
public void Clone_AllPropertiesSet_ReturnNewInstanceWithCopiedValues()
{
// Setup
var random = new Random(21);
var original = new GrassCoverErosionOutwardsWaveConditionsInput();
WaveConditionsTestDataGenerator.SetRandomDataToWaveConditionsInput(original);
original.CalculationType = random.NextEnumValue <GrassCoverErosionOutwardsWaveConditionsCalculationType>();
// Call
object clone = original.Clone();
// Assert
CoreCloneAssert.AreObjectClones(original, clone, GrassCoverErosionOutwardsCloneAssert.AreClones);
}
public void Clone_NotAllPropertiesSet_ReturnNewInstanceWithCopiedValues()
{
// Setup
var original = new GrassCoverErosionOutwardsWaveConditionsInput();
WaveConditionsTestDataGenerator.SetRandomDataToWaveConditionsInput(original);
original.ForeshoreProfile = null;
original.HydraulicBoundaryLocation = null;
// Call
object clone = original.Clone();
// Assert
CoreCloneAssert.AreObjectClones(original, clone, GrassCoverErosionOutwardsCloneAssert.AreClones);
}
/// <summary>
/// Creates a new instance of <see cref="GrassCoverErosionOutwardsWaveConditionsOutputProperties"/>.
/// </summary>
/// <param name="output">The data to show.</param>
/// <param name="input">The input belonging to the output.</param>
/// <exception cref="ArgumentNullException">Thrown when any parameter is <c>null</c>.</exception>
public GrassCoverErosionOutwardsWaveConditionsOutputProperties(GrassCoverErosionOutwardsWaveConditionsOutput output,
GrassCoverErosionOutwardsWaveConditionsInput input)
{
if (output == null)
{
throw new ArgumentNullException(nameof(output));
}
if (input == null)
{
throw new ArgumentNullException(nameof(input));
}
this.input = input;
Data = output;
}
public void DynamicVisibleValidationMethod_DependingOnRelevancy_ReturnExpectedVisibility(
GrassCoverErosionOutwardsWaveConditionsCalculationType calculationType, bool waveRunUpVisible, bool waveImpactVisible, bool waveImpactWithWaveDirectionVisible)
{
// Setup
GrassCoverErosionOutwardsWaveConditionsOutput output = GrassCoverErosionOutwardsWaveConditionsOutputTestFactory.Create();
var input = new GrassCoverErosionOutwardsWaveConditionsInput
{
CalculationType = calculationType
};
var properties = new GrassCoverErosionOutwardsWaveConditionsOutputProperties(output, input);
// Call & Assert
Assert.AreEqual(waveRunUpVisible, properties.DynamicVisibleValidationMethod(nameof(properties.WaveRunUpOutput)));
Assert.AreEqual(waveImpactVisible, properties.DynamicVisibleValidationMethod(nameof(properties.WaveImpactOutput)));
Assert.AreEqual(waveImpactWithWaveDirectionVisible, properties.DynamicVisibleValidationMethod(nameof(properties.WaveImpactWithWaveDirectionOutput)));
Assert.IsFalse(properties.DynamicVisibleValidationMethod(null));
}
public void Constructor_CalculationTypeAll_PropertiesHaveExpectedAttributesValues()
{
// Setup
GrassCoverErosionOutwardsWaveConditionsOutput output = GrassCoverErosionOutwardsWaveConditionsOutputTestFactory.Create();
var input = new GrassCoverErosionOutwardsWaveConditionsInput
{
CalculationType = GrassCoverErosionOutwardsWaveConditionsCalculationType.All
};
// Precondition
Assert.AreEqual(GrassCoverErosionOutwardsWaveConditionsCalculationType.All, input.CalculationType);
// Call
var properties = new GrassCoverErosionOutwardsWaveConditionsOutputProperties(output, input);
// Assert
PropertyDescriptorCollection dynamicProperties = PropertiesTestHelper.GetAllVisiblePropertyDescriptors(properties);
Assert.AreEqual(3, dynamicProperties.Count);
PropertyDescriptor waveRunUpProperty = dynamicProperties[waveRunUpPropertyIndex];
PropertiesTestHelper.AssertRequiredPropertyDescriptorProperties(waveRunUpProperty,
"Resultaat",
"Hydraulische belastingen voor golfoploop",
"Berekende hydraulische belastingen voor golfoploop.",
true);
PropertyDescriptor waveImpactProperty = dynamicProperties[waveImpactPropertyIndex];
PropertiesTestHelper.AssertRequiredPropertyDescriptorProperties(waveImpactProperty,
"Resultaat",
"Hydraulische belastingen voor golfklap",
"Berekende hydraulische belastingen voor golfklap zonder invloed van de golfinvalshoek.",
true);
PropertyDescriptor waveImpactWithWaveDirectionProperty = dynamicProperties[waveImpactWithWaveDirectionPropertyIndex];
PropertiesTestHelper.AssertRequiredPropertyDescriptorProperties(waveImpactWithWaveDirectionProperty,
"Resultaat",
"Hydraulische belastingen voor golfklap met golfrichting",
"Berekende hydraulische belastingen voor golfklap met invloed van de golfinvalshoek.",
true);
}
private void DetermineTotalWaterLevelCalculations(GrassCoverErosionOutwardsWaveConditionsInput calculationInput,
RoundedDouble assessmentLevel)
{
int waterLevelCount = calculationInput.GetWaterLevels(assessmentLevel).Count();
GrassCoverErosionOutwardsWaveConditionsCalculationType calculationType = calculationInput.CalculationType;
if (calculationType == GrassCoverErosionOutwardsWaveConditionsCalculationType.All)
{
TotalWaterLevelCalculations = waterLevelCount * 3;
return;
}
if (calculationType == GrassCoverErosionOutwardsWaveConditionsCalculationType.WaveRunUpAndWaveImpact ||
calculationType == GrassCoverErosionOutwardsWaveConditionsCalculationType.WaveRunUpAndWaveImpactWithWaveDirection)
{
TotalWaterLevelCalculations = waterLevelCount * 2;
return;
}
TotalWaterLevelCalculations = waterLevelCount;
}
private static void ReadCalculationInputs(GrassCoverErosionOutwardsWaveConditionsInput inputParameters,
GrassCoverErosionOutwardsWaveConditionsCalculationEntity entity,
ReadConversionCollector collector)
{
inputParameters.ForeshoreProfile = GetDikeProfileValue(entity.ForeshoreProfileEntity, collector);
inputParameters.HydraulicBoundaryLocation = GetHydraulicBoundaryLocationValue(entity.HydraulicLocationEntity, collector);
inputParameters.CalculationsTargetProbability = GetHydraulicBoundaryLocationCalculationsForTargetProbabilityValue(
entity.HydraulicLocationCalculationForTargetProbabilityCollectionEntity, collector);
inputParameters.Orientation = (RoundedDouble)entity.Orientation.ToNullAsNaN();
inputParameters.UseForeshore = Convert.ToBoolean(entity.UseForeshore);
inputParameters.UseBreakWater = Convert.ToBoolean(entity.UseBreakWater);
inputParameters.BreakWater.Height = (RoundedDouble)entity.BreakWaterHeight.ToNullAsNaN();
inputParameters.BreakWater.Type = (BreakWaterType)entity.BreakWaterType;
inputParameters.UpperBoundaryRevetment = (RoundedDouble)entity.UpperBoundaryRevetment.ToNullAsNaN();
inputParameters.LowerBoundaryRevetment = (RoundedDouble)entity.LowerBoundaryRevetment.ToNullAsNaN();
inputParameters.UpperBoundaryWaterLevels = (RoundedDouble)entity.UpperBoundaryWaterLevels.ToNullAsNaN();
inputParameters.LowerBoundaryWaterLevels = (RoundedDouble)entity.LowerBoundaryWaterLevels.ToNullAsNaN();
inputParameters.StepSize = (WaveConditionsInputStepSize)entity.StepSize;
inputParameters.CalculationType = (GrassCoverErosionOutwardsWaveConditionsCalculationType)entity.CalculationType;
inputParameters.WaterLevelType = (WaveConditionsInputWaterLevelType)entity.WaterLevelType;
}
/// <summary>
/// Performs a wave conditions calculation for the grass cover erosion outwards failure mechanism based on the supplied
/// <see cref="GrassCoverErosionOutwardsWaveConditionsCalculation"/> and sets
/// <see cref="GrassCoverErosionOutwardsWaveConditionsCalculation.Output"/> if the calculation was successful.
/// Error and status information is logged during the execution of the operation.
/// </summary>
/// <param name="calculation">The <see cref="GrassCoverErosionOutwardsWaveConditionsCalculation"/> that holds all the information required to perform the calculation.</param>
/// <param name="failureMechanism">The grass cover erosion outwards failure mechanism, which contains general parameters that apply to all
/// <see cref="GrassCoverErosionOutwardsWaveConditionsCalculation"/> instances.</param>
/// <param name="assessmentSection">The <see cref="IAssessmentSection"/> that holds information about the target probability used in the calculation.</param>
/// <exception cref="ArgumentNullException">Thrown when <paramref name="calculation"/>, <paramref name="failureMechanism"/>
/// or <paramref name="assessmentSection"/> is <c>null</c>.</exception>
/// <exception cref="ArgumentException">Thrown when:
/// <list type="bullet">
/// <item>the hydraulic boundary database file path contains invalid characters.</item>
/// <item><paramref name="failureMechanism"/> has no (0) contribution.</item>
/// </list></exception>
/// <exception cref="InvalidEnumArgumentException">Thrown when an unexpected
/// enum value is encountered.</exception>
/// <exception cref="CriticalFileReadException">Thrown when:
/// <list type="bullet">
/// <item>No settings database file could be found at the location of the hydraulic boundary database file path
/// with the same name.</item>
/// <item>Unable to open settings database file.</item>
/// <item>Unable to read required data from database file.</item>
/// </list>
/// </exception>
/// <exception cref="ArgumentOutOfRangeException">Thrown when the target probability or
/// calculated probability falls outside the [0.0, 1.0] range and is not <see cref="double.NaN"/>.</exception>
/// <exception cref="HydraRingFileParserException">Thrown when an error occurs during parsing of the Hydra-Ring output.</exception>
/// <exception cref="HydraRingCalculationException">Thrown when an error occurs during the calculation.</exception>
/// <exception cref="NotSupportedException">Thrown when <see cref="GrassCoverErosionOutwardsWaveConditionsCalculationType"/>
/// is a valid value, but unsupported.</exception>
public void Calculate(GrassCoverErosionOutwardsWaveConditionsCalculation calculation,
GrassCoverErosionOutwardsFailureMechanism failureMechanism,
IAssessmentSection assessmentSection)
{
if (calculation == null)
{
throw new ArgumentNullException(nameof(calculation));
}
if (failureMechanism == null)
{
throw new ArgumentNullException(nameof(failureMechanism));
}
if (assessmentSection == null)
{
throw new ArgumentNullException(nameof(assessmentSection));
}
GrassCoverErosionOutwardsWaveConditionsInput calculationInput = calculation.InputParameters;
GrassCoverErosionOutwardsWaveConditionsCalculationType calculationType = calculationInput.CalculationType;
if (!Enum.IsDefined(typeof(GrassCoverErosionOutwardsWaveConditionsCalculationType), calculationType))
{
throw new InvalidEnumArgumentException(nameof(calculationType), (int)calculationType,
typeof(GrassCoverErosionOutwardsWaveConditionsCalculationType));
}
CalculationServiceHelper.LogCalculationBegin();
RoundedDouble assessmentLevel = WaveConditionsInputHelper.GetAssessmentLevel(calculationInput, assessmentSection);
double targetProbability = WaveConditionsInputHelper.GetTargetProbability(calculationInput, assessmentSection);
HydraulicBoundaryDatabase hydraulicBoundaryDatabase = assessmentSection.HydraulicBoundaryDatabase;
DetermineTotalWaterLevelCalculations(calculationInput, assessmentLevel);
try
{
IEnumerable <WaveConditionsOutput> waveRunUpOutput = null;
if (ShouldCalculateWaveRunUp(calculationType))
{
CurrentCalculationType = Resources.GrassCoverErosionOutwardsWaveConditions_WaveRunUp_DisplayName;
waveRunUpOutput = CalculateWaveRunUp(calculation, failureMechanism, hydraulicBoundaryDatabase, assessmentLevel, targetProbability);
}
if (Canceled)
{
return;
}
IEnumerable <WaveConditionsOutput> waveImpactOutput = null;
if (ShouldCalculateWaveImpact(calculationType))
{
CurrentCalculationType = Resources.GrassCoverErosionOutwardsWaveConditions_WaveImpact_DisplayName;
waveImpactOutput = CalculateWaveImpact(calculation, failureMechanism, hydraulicBoundaryDatabase, assessmentLevel, targetProbability);
}
IEnumerable <WaveConditionsOutput> waveImpactWithWaveDirectionOutput = null;
if (ShouldCalculateWaveImpactWithWaveDirection(calculationType))
{
CurrentCalculationType = Resources.GrassCoverErosionOutwardsWaveConditions_WaveImpactWithWaveDirection_DisplayName;
waveImpactWithWaveDirectionOutput = CalculateWaveImpactWithWaveDirection(calculation, failureMechanism, hydraulicBoundaryDatabase, assessmentLevel, targetProbability);
}
if (!Canceled)
{
calculation.Output = CreateOutput(calculationType, waveRunUpOutput, waveImpactOutput, waveImpactWithWaveDirectionOutput);
}
}
finally
{
CalculationServiceHelper.LogCalculationEnd();
}
}
public void Read_ValidEntity_ReturnCalculation()
{
// Setup
const string name = "Calculation Name";
const string comments = "Calculation Comment";
var random = new Random(21);
double orientation = random.NextDouble();
bool useBreakWater = random.NextBoolean();
var breakWaterType = random.NextEnumValue <BreakWaterType>();
double breakWaterHeight = random.NextDouble();
bool useForeshore = random.NextBoolean();
const double lowerBoundaryRevetment = 3.58;
const double upperBoundaryRevetment = 6.10;
const double lowerBoundaryWaterLevels = 3.40;
const double upperBoundaryWaterLevels = 5.88;
var stepSize = random.NextEnumValue <WaveConditionsInputStepSize>();
var calculationType = random.NextEnumValue <GrassCoverErosionOutwardsWaveConditionsCalculationType>();
var waterLevelType = random.NextEnumValue <WaveConditionsInputWaterLevelType>();
var entity = new GrassCoverErosionOutwardsWaveConditionsCalculationEntity
{
Name = name,
Comments = comments,
UseBreakWater = Convert.ToByte(useBreakWater),
BreakWaterType = Convert.ToByte(breakWaterType),
BreakWaterHeight = breakWaterHeight,
UseForeshore = Convert.ToByte(useForeshore),
Orientation = orientation,
UpperBoundaryRevetment = upperBoundaryRevetment,
LowerBoundaryRevetment = lowerBoundaryRevetment,
UpperBoundaryWaterLevels = upperBoundaryWaterLevels,
LowerBoundaryWaterLevels = lowerBoundaryWaterLevels,
StepSize = Convert.ToByte(stepSize),
CalculationType = Convert.ToByte(calculationType),
WaterLevelType = Convert.ToByte(waterLevelType)
};
var collector = new ReadConversionCollector();
// Call
GrassCoverErosionOutwardsWaveConditionsCalculation calculation = entity.Read(collector);
// Assert
Assert.AreEqual(name, calculation.Name);
Assert.AreEqual(comments, calculation.Comments.Body);
GrassCoverErosionOutwardsWaveConditionsInput calculationInput = calculation.InputParameters;
Assert.AreEqual(useBreakWater, calculationInput.UseBreakWater);
Assert.AreEqual(breakWaterType, calculationInput.BreakWater.Type);
RoundedDoubleTestHelper.AssertRoundedDouble(breakWaterHeight, calculationInput.BreakWater.Height);
Assert.AreEqual(useForeshore, calculationInput.UseForeshore);
RoundedDoubleTestHelper.AssertRoundedDouble(orientation, calculationInput.Orientation);
RoundedDoubleTestHelper.AssertRoundedDouble(upperBoundaryRevetment, calculationInput.UpperBoundaryRevetment);
RoundedDoubleTestHelper.AssertRoundedDouble(lowerBoundaryRevetment, calculationInput.LowerBoundaryRevetment);
RoundedDoubleTestHelper.AssertRoundedDouble(upperBoundaryWaterLevels, calculationInput.UpperBoundaryWaterLevels);
RoundedDoubleTestHelper.AssertRoundedDouble(lowerBoundaryWaterLevels, calculationInput.LowerBoundaryWaterLevels);
Assert.AreEqual(stepSize, calculationInput.StepSize);
Assert.AreEqual(calculationType, calculationInput.CalculationType);
Assert.AreEqual(waterLevelType, calculationInput.WaterLevelType);
Assert.IsNull(calculationInput.HydraulicBoundaryLocation);
Assert.IsNull(calculationInput.ForeshoreProfile);
Assert.IsNull(calculationInput.CalculationsTargetProbability);
Assert.IsNull(calculation.Output);
}
/// <summary>
/// Method that asserts whether <paramref name="original"/> and <paramref name="clone"/>
/// are clones.
/// </summary>
/// <param name="original">The original object.</param>
/// <param name="clone">The cloned object.</param>
/// <exception cref="AssertionException">Thrown when <paramref name="original"/> and
/// <paramref name="clone"/> are not clones.</exception>
public static void AreClones(GrassCoverErosionOutwardsWaveConditionsInput original, GrassCoverErosionOutwardsWaveConditionsInput clone)
{
Assert.AreEqual(original.CalculationType, clone.CalculationType);
WaveConditionsCloneAssert.AreClones(original, clone);
}
