public void Read_ValidEntityWithUnreadDikeProfileEntity_ReturnCalculationWithNewDikeProfile()
{
// Setup
var dikeProfileEntity = new DikeProfileEntity
{
Id = "a",
DikeGeometryXml = new RoughnessPointCollectionXmlSerializer().ToXml(new RoughnessPoint[0]),
ForeshoreXml = new Point2DCollectionXmlSerializer().ToXml(new Point2D[0])
};
var entity = new GrassCoverErosionInwardsCalculationEntity
{
DikeProfileEntity = dikeProfileEntity,
ScenarioContribution = 0,
DikeHeightTargetProbability = 0.01,
OvertoppingRateTargetProbability = 0.02
};
var collector = new ReadConversionCollector();
// Call
GrassCoverErosionInwardsCalculationScenario calculation = entity.Read(collector);
// Assert
Assert.IsNotNull(calculation.InputParameters.DikeProfile);
Assert.IsTrue(collector.Contains(dikeProfileEntity));
}
private static void SetOutputEntity(GrassCoverErosionInwardsCalculationEntity entity, GrassCoverErosionInwardsCalculation calculation)
{
if (calculation.HasOutput)
{
entity.GrassCoverErosionInwardsOutputEntities.Add(calculation.Output.Create());
}
}
public void Create_NaNParameters_EntityWithNullFields()
{
// Setup
var calculation = new GrassCoverErosionInwardsCalculationScenario
{
InputParameters =
{
Orientation = RoundedDouble.NaN,
CriticalFlowRate =
{
Mean = RoundedDouble.NaN,
StandardDeviation = RoundedDouble.NaN
},
DikeHeight = RoundedDouble.NaN,
BreakWater =
{
Height = RoundedDouble.NaN
}
}
};
var registry = new PersistenceRegistry();
// Call
GrassCoverErosionInwardsCalculationEntity entity = calculation.Create(registry, 0);
// Assert
Assert.IsNull(entity.Orientation);
Assert.IsNull(entity.CriticalFlowRateMean);
Assert.IsNull(entity.CriticalFlowRateStandardDeviation);
Assert.IsNull(entity.DikeHeight);
Assert.IsNull(entity.BreakWaterHeight);
}
private static void SetInputValues(GrassCoverErosionInwardsCalculationEntity entity, GrassCoverErosionInwardsInput input, PersistenceRegistry registry)
{
if (input.DikeProfile != null)
{
entity.DikeProfileEntity = registry.Get(input.DikeProfile);
}
if (input.HydraulicBoundaryLocation != null)
{
entity.HydraulicLocationEntity = registry.Get(input.HydraulicBoundaryLocation);
}
entity.Orientation = input.Orientation.ToNaNAsNull();
entity.DikeHeight = input.DikeHeight.ToNaNAsNull();
entity.UseForeshore = Convert.ToByte(input.UseForeshore);
entity.UseBreakWater = Convert.ToByte(input.UseBreakWater);
entity.BreakWaterType = Convert.ToByte(input.BreakWater.Type);
entity.BreakWaterHeight = input.BreakWater.Height.ToNaNAsNull();
entity.CriticalFlowRateMean = input.CriticalFlowRate.Mean.ToNaNAsNull();
entity.CriticalFlowRateStandardDeviation = input.CriticalFlowRate.StandardDeviation.ToNaNAsNull();
entity.ShouldOvertoppingOutputIllustrationPointsBeCalculated = Convert.ToByte(input.ShouldOvertoppingOutputIllustrationPointsBeCalculated);
entity.ShouldDikeHeightBeCalculated = Convert.ToByte(input.ShouldDikeHeightBeCalculated);
entity.DikeHeightTargetProbability = input.DikeHeightTargetProbability;
entity.ShouldDikeHeightIllustrationPointsBeCalculated = Convert.ToByte(input.ShouldDikeHeightIllustrationPointsBeCalculated);
entity.ShouldOvertoppingRateBeCalculated = Convert.ToByte(input.ShouldOvertoppingRateBeCalculated);
entity.OvertoppingRateTargetProbability = input.OvertoppingRateTargetProbability;
entity.ShouldOvertoppingRateIllustrationPointsBeCalculated = Convert.ToByte(input.ShouldOvertoppingRateIllustrationPointsBeCalculated);
}
public void Create_StringPropertiesDoNotShareReference()
{
// Setup
const string name = "A";
const string comment = "B";
var calculation = new GrassCoverErosionInwardsCalculationScenario
{
Name = name,
Comments =
{
Body = comment
}
};
var registry = new PersistenceRegistry();
// Call
GrassCoverErosionInwardsCalculationEntity entity = calculation.Create(registry, 0);
// Assert
Assert.AreNotSame(name, entity.Name,
"To create stable binary representations/fingerprints, it's really important that strings are not shared.");
Assert.AreEqual(name, entity.Name);
Assert.AreNotSame(comment, entity.Comments,
"To create stable binary representations/fingerprints, it's really important that strings are not shared.");
Assert.AreEqual(comment, entity.Comments);
}
public void Create_GroupWithChildGrassCoverErosionInwardCalculationScenariosAndChildCalculationGroups_CreateEntities()
{
// Setup
var group = new CalculationGroup
{
Children =
{
new CalculationGroup
{
Name = "A"
},
new GrassCoverErosionInwardsCalculationScenario
{
Name = "B"
},
new CalculationGroup
{
Name = "C"
},
new GrassCoverErosionInwardsCalculationScenario
{
Name = "D"
}
}
};
var registry = new PersistenceRegistry();
// Call
CalculationGroupEntity entity = group.Create(registry, 0);
// Assert
CalculationGroupEntity[] childGroupEntities = entity.CalculationGroupEntity1.ToArray();
GrassCoverErosionInwardsCalculationEntity[] childCalculationEntities = entity.GrassCoverErosionInwardsCalculationEntities.ToArray();
Assert.AreEqual(2, childGroupEntities.Length);
Assert.AreEqual(2, childCalculationEntities.Length);
CalculationGroupEntity childEntity1 = childGroupEntities[0];
Assert.AreEqual("A", childEntity1.Name);
Assert.AreEqual(0, childEntity1.Order);
CollectionAssert.IsEmpty(childEntity1.CalculationGroupEntity1);
GrassCoverErosionInwardsCalculationEntity childEntity2 = childCalculationEntities[0];
Assert.AreEqual("B", childEntity2.Name);
Assert.AreEqual(1, childEntity2.Order);
CalculationGroupEntity childEntity3 = childGroupEntities[1];
Assert.AreEqual("C", childEntity3.Name);
Assert.AreEqual(2, childEntity3.Order);
CollectionAssert.IsEmpty(childEntity3.CalculationGroupEntity1);
GrassCoverErosionInwardsCalculationEntity childEntity4 = childCalculationEntities[1];
Assert.AreEqual("D", childEntity4.Name);
Assert.AreEqual(3, childEntity4.Order);
}
public void Read_ReadConversionCollectorNull_ThrowArgumentNullException()
{
// Setup
var entity = new GrassCoverErosionInwardsCalculationEntity();
// Call
void Call() => entity.Read(null);
// Assert
var exception = Assert.Throws <ArgumentNullException>(Call);
Assert.AreEqual("collector", exception.ParamName);
}
private static void ReadInput(GrassCoverErosionInwardsInput inputParameters, GrassCoverErosionInwardsCalculationEntity entity, ReadConversionCollector collector)
{
inputParameters.DikeProfile = GetDikeProfileValue(entity.DikeProfileEntity, collector);
inputParameters.HydraulicBoundaryLocation = GetHydraulicBoundaryLocationValue(entity.HydraulicLocationEntity, collector);
inputParameters.Orientation = (RoundedDouble)entity.Orientation.ToNullAsNaN();
inputParameters.CriticalFlowRate.Mean = (RoundedDouble)entity.CriticalFlowRateMean.ToNullAsNaN();
inputParameters.CriticalFlowRate.StandardDeviation = (RoundedDouble)entity.CriticalFlowRateStandardDeviation.ToNullAsNaN();
inputParameters.UseForeshore = Convert.ToBoolean(entity.UseForeshore);
inputParameters.DikeHeight = (RoundedDouble)entity.DikeHeight.ToNullAsNaN();
inputParameters.UseBreakWater = Convert.ToBoolean(entity.UseBreakWater);
inputParameters.BreakWater.Height = (RoundedDouble)entity.BreakWaterHeight.ToNullAsNaN();
inputParameters.BreakWater.Type = (BreakWaterType)entity.BreakWaterType;
inputParameters.ShouldOvertoppingOutputIllustrationPointsBeCalculated = Convert.ToBoolean(entity.ShouldOvertoppingOutputIllustrationPointsBeCalculated);
inputParameters.ShouldDikeHeightBeCalculated = Convert.ToBoolean(entity.ShouldDikeHeightBeCalculated);
inputParameters.DikeHeightTargetProbability = entity.DikeHeightTargetProbability;
inputParameters.ShouldDikeHeightIllustrationPointsBeCalculated = Convert.ToBoolean(entity.ShouldDikeHeightIllustrationPointsBeCalculated);
inputParameters.ShouldOvertoppingRateBeCalculated = Convert.ToBoolean(entity.ShouldOvertoppingRateBeCalculated);
inputParameters.OvertoppingRateTargetProbability = entity.OvertoppingRateTargetProbability;
inputParameters.ShouldOvertoppingRateIllustrationPointsBeCalculated = Convert.ToBoolean(entity.ShouldOvertoppingRateIllustrationPointsBeCalculated);
}
public void Read_ValidEntityWithUnreadHydraulicLocationEntity_ReturnCalculationWithNewHydraulicBoundaryLocation()
{
// Setup
HydraulicLocationEntity hydraulicLocationEntity = HydraulicLocationEntityTestFactory.CreateHydraulicLocationEntity();
var entity = new GrassCoverErosionInwardsCalculationEntity
{
HydraulicLocationEntity = hydraulicLocationEntity,
ScenarioContribution = 0,
DikeHeightTargetProbability = 0.01,
OvertoppingRateTargetProbability = 0.02
};
var collector = new ReadConversionCollector();
// Call
GrassCoverErosionInwardsCalculationScenario calculation = entity.Read(collector);
// Assert
Assert.IsNotNull(calculation.InputParameters.HydraulicBoundaryLocation);
Assert.IsTrue(collector.Contains(hydraulicLocationEntity));
}
/// <summary>
/// Creates a <see cref="GrassCoverErosionInwardsCalculationEntity"/> based
/// on the information of the <see cref="GrassCoverErosionInwardsCalculationScenario"/>.
/// </summary>
/// <param name="calculation">The calculation scenario to create a database entity for.</param>
/// <param name="registry">The object keeping track of create operations.</param>
/// <param name="order">The index at where <paramref name="calculation"/> resides
/// in its parent container.</param>
/// <returns>A new <see cref="GrassCoverErosionInwardsCalculationEntity"/>.</returns>
/// <exception cref="ArgumentNullException">Thrown when <paramref name="registry"/> is <c>null</c>.</exception>
internal static GrassCoverErosionInwardsCalculationEntity Create(this GrassCoverErosionInwardsCalculationScenario calculation, PersistenceRegistry registry, int order)
{
if (registry == null)
{
throw new ArgumentNullException(nameof(registry));
}
var entity = new GrassCoverErosionInwardsCalculationEntity
{
Name = calculation.Name.DeepClone(),
Comments = calculation.Comments.Body.DeepClone(),
RelevantForScenario = Convert.ToByte(calculation.IsRelevant),
ScenarioContribution = calculation.Contribution,
Order = order
};
SetInputValues(entity, calculation.InputParameters, registry);
SetOutputEntity(entity, calculation);
return(entity);
}
public void Read_ValidEntityWithOutputEntity_ReturnCalculationWithOutput()
{
// Setup
var entity = new GrassCoverErosionInwardsCalculationEntity
{
GrassCoverErosionInwardsOutputEntities =
{
new GrassCoverErosionInwardsOutputEntity()
},
ScenarioContribution = 0,
DikeHeightTargetProbability = 0.01,
OvertoppingRateTargetProbability = 0.02
};
var collector = new ReadConversionCollector();
// Call
GrassCoverErosionInwardsCalculationScenario calculation = entity.Read(collector);
// Assert
Assert.IsTrue(calculation.HasOutput);
}
public void Read_EntityWithNullValues_ReturnCalculationWithNaNOrNull()
{
// Setup
var entity = new GrassCoverErosionInwardsCalculationEntity
{
Name = null,
ScenarioContribution = 0,
Comments = null,
Orientation = null,
CriticalFlowRateMean = null,
CriticalFlowRateStandardDeviation = null,
DikeHeight = null,
BreakWaterHeight = null,
DikeHeightTargetProbability = 0.01,
OvertoppingRateTargetProbability = 0.02
};
var collector = new ReadConversionCollector();
// Call
GrassCoverErosionInwardsCalculationScenario calculation = entity.Read(collector);
// Assert
Assert.IsNull(calculation.Name);
Assert.IsNull(calculation.Comments.Body);
GrassCoverErosionInwardsInput input = calculation.InputParameters;
Assert.IsNaN(input.Orientation);
Assert.IsNaN(input.CriticalFlowRate.Mean);
Assert.IsNaN(input.CriticalFlowRate.StandardDeviation);
Assert.IsNaN(input.DikeHeight);
Assert.IsNaN(input.BreakWater.Height.Value);
Assert.IsNull(input.DikeProfile);
Assert.IsNull(input.HydraulicBoundaryLocation);
Assert.IsFalse(calculation.HasOutput);
}
public void Read_ValidEntityWithAlreadyReadDikeProfileEntity_ReturnCalculationWithReadDikeProfile()
{
// Setup
DikeProfile dikeProfile = DikeProfileTestFactory.CreateDikeProfile();
var dikeProfileEntity = new DikeProfileEntity();
var entity = new GrassCoverErosionInwardsCalculationEntity
{
DikeProfileEntity = dikeProfileEntity,
ScenarioContribution = 0,
DikeHeightTargetProbability = 0.01,
OvertoppingRateTargetProbability = 0.02
};
var collector = new ReadConversionCollector();
collector.Read(dikeProfileEntity, dikeProfile);
// Call
GrassCoverErosionInwardsCalculationScenario calculation = entity.Read(collector);
// Assert
Assert.AreSame(dikeProfile, calculation.InputParameters.DikeProfile);
}
public void Create_CalculationWithAlreadySavedHydraulicBoundaryLocation_ReturnEntityWithHydraulicLocationEntity()
{
// Setup
var hydraulicBoundaryLocation = new HydraulicBoundaryLocation(1, "A", 1, 1);
var calculation = new GrassCoverErosionInwardsCalculationScenario
{
InputParameters =
{
HydraulicBoundaryLocation = hydraulicBoundaryLocation
}
};
var hydraulicLocationEntity = new HydraulicLocationEntity();
var registry = new PersistenceRegistry();
registry.Register(hydraulicLocationEntity, hydraulicBoundaryLocation);
// Call
GrassCoverErosionInwardsCalculationEntity entity = calculation.Create(registry, 0);
// Assert
Assert.AreSame(hydraulicLocationEntity, entity.HydraulicLocationEntity);
}
public void Create_CalculationWithAlreadySavedDikeProfile_ReturnEntityWithDikeProfileEntity()
{
// Setup
DikeProfile dikeProfile = DikeProfileTestFactory.CreateDikeProfile();
var calculation = new GrassCoverErosionInwardsCalculationScenario
{
InputParameters =
{
DikeProfile = dikeProfile
}
};
var dikeProfileEntity = new DikeProfileEntity();
var registry = new PersistenceRegistry();
registry.Register(dikeProfileEntity, dikeProfile);
// Call
GrassCoverErosionInwardsCalculationEntity entity = calculation.Create(registry, 0);
// Assert
Assert.AreSame(dikeProfileEntity, entity.DikeProfileEntity);
}
public void Read_ValidEntityWithAlreadyReadHydraulicLocationEntity_ReturnCalculationWithReadHydraulicBoundaryLocation()
{
// Setup
var hydraulicBoundaryLocation = new HydraulicBoundaryLocation(1, "A", 0, 0);
var hydraulicLocationEntity = new HydraulicLocationEntity();
var entity = new GrassCoverErosionInwardsCalculationEntity
{
HydraulicLocationEntity = hydraulicLocationEntity,
ScenarioContribution = 0,
DikeHeightTargetProbability = 0.01,
OvertoppingRateTargetProbability = 0.02
};
var collector = new ReadConversionCollector();
collector.Read(hydraulicLocationEntity, hydraulicBoundaryLocation);
// Call
GrassCoverErosionInwardsCalculationScenario calculation = entity.Read(collector);
// Assert
Assert.AreSame(hydraulicBoundaryLocation, calculation.InputParameters.HydraulicBoundaryLocation);
}
/// <summary>
/// Reads the <see cref="GrassCoverErosionInwardsCalculationEntity"/> and use the
/// information to update a <see cref="GrassCoverErosionInwardsCalculation"/>.
/// </summary>
/// <param name="entity">The <see cref="GrassCoverErosionInwardsCalculationEntity"/>
/// to create <see cref="GrassCoverErosionInwardsCalculation"/> for.</param>
/// <param name="collector">The object keeping track of read operations.</param>
/// <returns>A new <see cref="GrassCoverErosionInwardsCalculation"/>.</returns>
/// <exception cref="ArgumentNullException">Thrown when <paramref name="collector"/> is <c>null</c>.</exception>
internal static GrassCoverErosionInwardsCalculationScenario Read(this GrassCoverErosionInwardsCalculationEntity entity, ReadConversionCollector collector)
{
if (collector == null)
{
throw new ArgumentNullException(nameof(collector));
}
var calculation = new GrassCoverErosionInwardsCalculationScenario
{
Name = entity.Name,
Comments =
{
Body = entity.Comments
},
IsRelevant = Convert.ToBoolean(entity.RelevantForScenario),
Contribution = (RoundedDouble)entity.ScenarioContribution
};
ReadInput(calculation.InputParameters, entity, collector);
ReadOutput(calculation, entity);
return(calculation);
}
public void Create_CalculationWithOutput_ReturnEntity()
{
// Setup
var random = new Random(456);
var overtoppingOutput = new OvertoppingOutput(random.NextDouble(), false, random.NextDouble(), null);
var output = new GrassCoverErosionInwardsOutput(overtoppingOutput, null, null);
var calculation = new GrassCoverErosionInwardsCalculationScenario
{
Output = output
};
var registry = new PersistenceRegistry();
// Call
GrassCoverErosionInwardsCalculationEntity entity = calculation.Create(registry, 0);
// Assert
GrassCoverErosionInwardsOutputEntity outputEntity = entity.GrassCoverErosionInwardsOutputEntities.Single();
Assert.AreEqual(overtoppingOutput.WaveHeight, outputEntity.WaveHeight);
Assert.AreEqual(overtoppingOutput.Reliability, outputEntity.Reliability);
Assert.IsNull(outputEntity.GeneralResultFaultTreeIllustrationPointEntity);
}
public void Read_ValidEntity_ReturnCalculation()
{
// Setup
var random = new Random(14);
var breakWaterType = random.NextEnumValue <BreakWaterType>();
var entity = new GrassCoverErosionInwardsCalculationEntity
{
Name = "sodhfksn",
Comments = "s;ohfgwjo5p09u",
HydraulicLocationEntity = null,
DikeProfileEntity = null,
Orientation = 5.6,
CriticalFlowRateMean = 3.4,
CriticalFlowRateStandardDeviation = 1.2,
UseForeshore = Convert.ToByte(random.NextBoolean()),
DikeHeight = 2.3,
UseBreakWater = Convert.ToByte(random.NextBoolean()),
BreakWaterType = Convert.ToByte(breakWaterType),
BreakWaterHeight = 5.7,
ShouldOvertoppingOutputIllustrationPointsBeCalculated = Convert.ToByte(random.NextBoolean()),
ShouldDikeHeightBeCalculated = Convert.ToByte(random.NextBoolean()),
DikeHeightTargetProbability = 0.01,
ShouldDikeHeightIllustrationPointsBeCalculated = Convert.ToByte(random.NextBoolean()),
ShouldOvertoppingRateBeCalculated = Convert.ToByte(random.NextBoolean()),
OvertoppingRateTargetProbability = 0.02,
ShouldOvertoppingRateIllustrationPointsBeCalculated = Convert.ToByte(random.NextBoolean()),
RelevantForScenario = Convert.ToByte(random.NextBoolean()),
ScenarioContribution = 0.45
};
var collector = new ReadConversionCollector();
// Call
GrassCoverErosionInwardsCalculationScenario calculation = entity.Read(collector);
// Assert
Assert.AreEqual(entity.Name, calculation.Name);
Assert.AreEqual(entity.Comments, calculation.Comments.Body);
AssertBoolean(entity.RelevantForScenario, calculation.IsRelevant);
RoundedDoubleTestHelper.AssertRoundedDouble(entity.ScenarioContribution, calculation.Contribution);
GrassCoverErosionInwardsInput input = calculation.InputParameters;
Assert.AreEqual(entity.Orientation, input.Orientation.Value);
Assert.AreEqual(entity.CriticalFlowRateMean, input.CriticalFlowRate.Mean.Value);
Assert.AreEqual(entity.CriticalFlowRateStandardDeviation, input.CriticalFlowRate.StandardDeviation.Value);
AssertBoolean(entity.UseForeshore, input.UseForeshore);
Assert.AreEqual(entity.DikeHeight, input.DikeHeight.Value);
AssertBoolean(entity.UseBreakWater, input.UseBreakWater);
Assert.AreEqual(breakWaterType, input.BreakWater.Type);
Assert.AreEqual(entity.BreakWaterHeight, input.BreakWater.Height.Value);
AssertBoolean(entity.ShouldOvertoppingOutputIllustrationPointsBeCalculated,
input.ShouldOvertoppingOutputIllustrationPointsBeCalculated);
AssertBoolean(entity.ShouldDikeHeightBeCalculated, input.ShouldDikeHeightBeCalculated);
Assert.AreEqual(entity.DikeHeightTargetProbability, input.DikeHeightTargetProbability);
AssertBoolean(entity.ShouldDikeHeightIllustrationPointsBeCalculated,
input.ShouldDikeHeightIllustrationPointsBeCalculated);
AssertBoolean(entity.ShouldOvertoppingRateBeCalculated, input.ShouldOvertoppingRateBeCalculated);
Assert.AreEqual(entity.OvertoppingRateTargetProbability, input.OvertoppingRateTargetProbability);
AssertBoolean(entity.ShouldOvertoppingRateIllustrationPointsBeCalculated,
input.ShouldOvertoppingRateIllustrationPointsBeCalculated);
Assert.IsNull(input.DikeProfile);
Assert.IsNull(input.HydraulicBoundaryLocation);
Assert.IsFalse(calculation.HasOutput);
}
public void Create_ValidCalculation_ReturnEntity(string comment)
{
// Setup
var random = new Random(12);
int order = random.Next();
const string name = "GrassCoverErosionInwardsCalculation Name";
var calculation = new GrassCoverErosionInwardsCalculationScenario
{
Name = name,
Comments =
{
Body = comment
},
IsRelevant = random.NextBoolean(),
Contribution = random.NextRoundedDouble(),
InputParameters =
{
DikeProfile = null,
HydraulicBoundaryLocation = null,
DikeHeight = (RoundedDouble)1.1,
Orientation = (RoundedDouble)2.2,
BreakWater =
{
Height = (RoundedDouble)3.3,
Type = BreakWaterType.Dam
},
CriticalFlowRate =
{
Mean = (RoundedDouble)4.4,
StandardDeviation = (RoundedDouble)5.5
},
UseBreakWater = true,
UseForeshore = false,
ShouldOvertoppingOutputIllustrationPointsBeCalculated = random.NextBoolean(),
ShouldDikeHeightBeCalculated = random.NextBoolean(),
DikeHeightTargetProbability = random.NextDouble(1e-15, 0.1),
ShouldDikeHeightIllustrationPointsBeCalculated = random.NextBoolean(),
ShouldOvertoppingRateBeCalculated = random.NextBoolean(),
OvertoppingRateTargetProbability = random.NextDouble(1e-15, 0.1),
ShouldOvertoppingRateIllustrationPointsBeCalculated = random.NextBoolean()
},
Output = null
};
var registry = new PersistenceRegistry();
// Call
GrassCoverErosionInwardsCalculationEntity entity = calculation.Create(registry, order);
// Assert
Assert.AreEqual(name, entity.Name);
Assert.AreEqual(comment, entity.Comments);
Assert.AreEqual(Convert.ToByte(calculation.IsRelevant), entity.RelevantForScenario);
Assert.AreEqual(calculation.Contribution, entity.ScenarioContribution);
Assert.AreEqual(order, entity.Order);
Assert.IsNull(entity.DikeProfileEntity);
Assert.IsNull(entity.HydraulicLocationEntity);
GrassCoverErosionInwardsInput input = calculation.InputParameters;
Assert.AreEqual(input.BreakWater.Height.Value, entity.BreakWaterHeight);
Assert.AreEqual((short)input.BreakWater.Type, entity.BreakWaterType);
Assert.AreEqual(Convert.ToByte(input.UseBreakWater), entity.UseBreakWater);
Assert.AreEqual(input.CriticalFlowRate.Mean.Value, entity.CriticalFlowRateMean);
Assert.AreEqual(input.CriticalFlowRate.StandardDeviation.Value, entity.CriticalFlowRateStandardDeviation);
Assert.AreEqual(input.Orientation.Value, entity.Orientation);
Assert.AreEqual(input.DikeHeight.Value, entity.DikeHeight);
Assert.AreEqual(Convert.ToByte(input.UseForeshore), entity.UseForeshore);
Assert.AreEqual(Convert.ToByte(input.ShouldOvertoppingOutputIllustrationPointsBeCalculated),
entity.ShouldOvertoppingOutputIllustrationPointsBeCalculated);
Assert.AreEqual(Convert.ToByte(input.ShouldDikeHeightBeCalculated), entity.ShouldDikeHeightBeCalculated);
Assert.AreEqual(input.DikeHeightTargetProbability, entity.DikeHeightTargetProbability);
Assert.AreEqual(Convert.ToByte(input.ShouldDikeHeightIllustrationPointsBeCalculated),
entity.ShouldDikeHeightIllustrationPointsBeCalculated);
Assert.AreEqual(Convert.ToByte(input.ShouldOvertoppingRateBeCalculated), entity.ShouldOvertoppingRateBeCalculated);
Assert.AreEqual(input.OvertoppingRateTargetProbability, entity.OvertoppingRateTargetProbability);
Assert.AreEqual(Convert.ToByte(input.ShouldOvertoppingRateIllustrationPointsBeCalculated),
entity.ShouldOvertoppingRateIllustrationPointsBeCalculated);
Assert.IsFalse(entity.GrassCoverErosionInwardsOutputEntities.Any());
}
private static void ReadOutput(GrassCoverErosionInwardsCalculation calculation, GrassCoverErosionInwardsCalculationEntity entity)
{
GrassCoverErosionInwardsOutputEntity output = entity.GrassCoverErosionInwardsOutputEntities.SingleOrDefault();
if (output != null)
{
calculation.Output = output.Read();
}
}
