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