public void Create_NaNValues_ReturnGrassCoverErosionInwardsOutputEntity()
{
// Setup
var overtoppingOutput = new OvertoppingOutput(double.NaN, true, double.NaN, null);
var dikeHeightOutput = new TestDikeHeightOutput(double.NaN, CalculationConvergence.CalculatedConverged);
var overtoppingRateOutput = new TestOvertoppingRateOutput(double.NaN, CalculationConvergence.CalculatedConverged);
var output = new GrassCoverErosionInwardsOutput(overtoppingOutput, dikeHeightOutput, overtoppingRateOutput);
// Call
GrassCoverErosionInwardsOutputEntity entity = output.Create();
// Assert
Assert.IsNull(entity.WaveHeight);
Assert.AreEqual(Convert.ToByte(overtoppingOutput.IsOvertoppingDominant), entity.IsOvertoppingDominant);
Assert.IsNull(entity.Reliability);
Assert.IsNull(entity.GeneralResultFaultTreeIllustrationPointEntity);
GrassCoverErosionInwardsDikeHeightOutputEntity dikeHeightEntity = entity.GrassCoverErosionInwardsDikeHeightOutputEntities.Single();
Assert.IsNull(dikeHeightEntity.DikeHeight);
Assert.IsNull(dikeHeightEntity.TargetProbability);
Assert.IsNull(dikeHeightEntity.TargetReliability);
Assert.IsNull(dikeHeightEntity.CalculatedProbability);
Assert.IsNull(dikeHeightEntity.CalculatedReliability);
Assert.AreEqual((byte)dikeHeightOutput.CalculationConvergence, dikeHeightEntity.CalculationConvergence);
GrassCoverErosionInwardsOvertoppingRateOutputEntity overtoppingRateEntity = entity.GrassCoverErosionInwardsOvertoppingRateOutputEntities.Single();
Assert.IsNull(overtoppingRateEntity.OvertoppingRate);
Assert.IsNull(overtoppingRateEntity.TargetProbability);
Assert.IsNull(overtoppingRateEntity.TargetReliability);
Assert.IsNull(overtoppingRateEntity.CalculatedProbability);
Assert.IsNull(overtoppingRateEntity.CalculatedReliability);
Assert.AreEqual((byte)overtoppingRateOutput.CalculationConvergence, overtoppingRateEntity.CalculationConvergence);
}
private static OvertoppingOutput GetOvertoppingOutput(GrassCoverErosionInwardsOutputEntity entity)
{
return(new OvertoppingOutput(entity.WaveHeight.ToNullAsNaN(),
Convert.ToBoolean(entity.IsOvertoppingDominant),
entity.Reliability.ToNullAsNaN(),
entity.GeneralResultFaultTreeIllustrationPointEntity?.Read()));
}
public void Read_ValidEntityWithGeneralResultEntity_ReturnsGrassCoverErosionInwardsOutputWithGeneralResult()
{
// Setup
var generalResultEntity = new GeneralResultFaultTreeIllustrationPointEntity
{
GoverningWindDirectionAngle = 10,
GoverningWindDirectionName = "SSE"
};
var entity = new GrassCoverErosionInwardsOutputEntity
{
WaveHeight = null,
IsOvertoppingDominant = Convert.ToByte(true),
Reliability = null,
GeneralResultFaultTreeIllustrationPointEntity = generalResultEntity
};
// Call
GrassCoverErosionInwardsOutput output = entity.Read();
// Assert
OvertoppingOutput overtoppingOutput = output.OvertoppingOutput;
GeneralResultEntityTestHelper.AssertGeneralResultPropertyValues(overtoppingOutput.GeneralResult,
generalResultEntity);
}
private static void AddEntityForOvertoppingRateOutput(GrassCoverErosionInwardsOutputEntity entity,
OvertoppingRateOutput output)
{
if (output != null)
{
entity.GrassCoverErosionInwardsOvertoppingRateOutputEntities.Add(output.Create());
}
}
private static void AddEntityForDikeHeightOutput(GrassCoverErosionInwardsOutputEntity entity,
DikeHeightOutput output)
{
if (output != null)
{
entity.GrassCoverErosionInwardsDikeHeightOutputEntities.Add(output.Create());
}
}
private static void ReadOutput(GrassCoverErosionInwardsCalculation calculation, GrassCoverErosionInwardsCalculationEntity entity)
{
GrassCoverErosionInwardsOutputEntity output = entity.GrassCoverErosionInwardsOutputEntities.SingleOrDefault();
if (output != null)
{
calculation.Output = output.Read();
}
}
/// <summary>
/// Reads the <see cref="GrassCoverErosionInwardsOutputEntity"/>
/// and use the information to construct a <see cref="GrassCoverErosionInwardsOutput"/>.
/// </summary>
/// <param name="entity">The <see cref="GrassCoverErosionInwardsOutputEntity"/>
/// to create <see cref="GeneralGrassCoverErosionInwardsInput"/> for.</param>
/// <returns>A new <see cref="GrassCoverErosionInwardsOutput"/>.</returns>
/// <exception cref="ArgumentNullException">Thrown when <paramref name="entity"/>
/// is <c>null</c>.</exception>
internal static GrassCoverErosionInwardsOutput Read(this GrassCoverErosionInwardsOutputEntity entity)
{
if (entity == null)
{
throw new ArgumentNullException(nameof(entity));
}
return(new GrassCoverErosionInwardsOutput(GetOvertoppingOutput(entity),
GetDikeHeightOutput(entity),
GetOvertoppingRateOutput(entity)));
}
public void Create_OvertoppingRateOutputIsNull_NoOvertoppingRateOutputEntityCreated()
{
// Setup
var overtoppingOutput = new TestOvertoppingOutput(1);
var dikeHeightOutput = new TestDikeHeightOutput(double.NaN, CalculationConvergence.CalculatedConverged);
var output = new GrassCoverErosionInwardsOutput(overtoppingOutput, dikeHeightOutput, null);
// Call
GrassCoverErosionInwardsOutputEntity entity = output.Create();
// Assert
Assert.IsFalse(entity.GrassCoverErosionInwardsOvertoppingRateOutputEntities.Any());
}
/// <summary>
/// Creates a <see cref="GrassCoverErosionInwardsOutputEntity"/> based on
/// the information of the <see cref="GrassCoverErosionInwardsOutput"/>.
/// </summary>
/// <param name="output">The grass cover erosion inwards calculation output to create
/// a database entity for.</param>
/// <returns>A new <see cref="GrassCoverErosionInwardsOutputEntity"/>.</returns>
internal static GrassCoverErosionInwardsOutputEntity Create(this GrassCoverErosionInwardsOutput output)
{
OvertoppingOutput overtoppingOutput = output.OvertoppingOutput;
var entity = new GrassCoverErosionInwardsOutputEntity
{
IsOvertoppingDominant = Convert.ToByte(overtoppingOutput.IsOvertoppingDominant),
WaveHeight = overtoppingOutput.WaveHeight.ToNaNAsNull(),
Reliability = overtoppingOutput.Reliability.ToNaNAsNull(),
GeneralResultFaultTreeIllustrationPointEntity = overtoppingOutput.GeneralResult?.CreateGeneralResultFaultTreeIllustrationPointEntity()
};
AddEntityForDikeHeightOutput(entity, output.DikeHeightOutput);
AddEntityForOvertoppingRateOutput(entity, output.OvertoppingRateOutput);
return(entity);
}
public void Create_WithGeneralResult_ReturnsGrassCoverErosionInwardsOutputEntityWithGeneralResultEntity()
{
// Setup
var overtoppingOutput = new OvertoppingOutput(double.NaN,
true,
double.NaN,
new TestGeneralResultFaultTreeIllustrationPoint());
var output = new GrassCoverErosionInwardsOutput(overtoppingOutput, null, null);
// Call
GrassCoverErosionInwardsOutputEntity entity = output.Create();
// Assert
GeneralResultEntityTestHelper.AssertGeneralResultPropertyValues(output.OvertoppingOutput.GeneralResult, entity.GeneralResultFaultTreeIllustrationPointEntity);
}
public void Read_ValidEntityWithOvertoppingRateOutputEntity_ReturnGrassCoverErosionInwardsOutputWithOvertoppingRateOutput()
{
// Setup
var entity = new GrassCoverErosionInwardsOutputEntity
{
GrassCoverErosionInwardsOvertoppingRateOutputEntities =
{
new GrassCoverErosionInwardsOvertoppingRateOutputEntity()
}
};
// Call
GrassCoverErosionInwardsOutput output = entity.Read();
// Assert
Assert.IsNotNull(output.OvertoppingRateOutput);
}
public void Create_ValidInput_ReturnGrassCoverErosionInwardsOutputEntity()
{
// Setup
var random = new Random(456);
var overtoppingOutput = new OvertoppingOutput(random.NextDouble(), false, random.NextDouble(), null);
var dikeHeightConvergence = random.NextEnumValue <CalculationConvergence>();
var overtoppingRateConvergence = random.NextEnumValue <CalculationConvergence>();
var dikeHeightOutput = new DikeHeightOutput(random.NextDouble(), random.NextDouble(),
random.NextDouble(), random.NextDouble(),
random.NextDouble(), dikeHeightConvergence, null);
var overtoppingRateOutput = new OvertoppingRateOutput(random.NextDouble(), random.NextDouble(),
random.NextDouble(), random.NextDouble(),
random.NextDouble(), overtoppingRateConvergence, null);
var output = new GrassCoverErosionInwardsOutput(overtoppingOutput, dikeHeightOutput, overtoppingRateOutput);
// Call
GrassCoverErosionInwardsOutputEntity entity = output.Create();
// Assert
Assert.AreEqual(overtoppingOutput.WaveHeight.Value, entity.WaveHeight);
Assert.AreEqual(Convert.ToByte(overtoppingOutput.IsOvertoppingDominant), entity.IsOvertoppingDominant);
Assert.AreEqual(overtoppingOutput.Reliability, entity.Reliability);
Assert.IsNull(entity.GeneralResultFaultTreeIllustrationPointEntity);
GrassCoverErosionInwardsDikeHeightOutputEntity dikeHeightEntity = entity.GrassCoverErosionInwardsDikeHeightOutputEntities.Single();
Assert.AreEqual(dikeHeightOutput.DikeHeight, dikeHeightEntity.DikeHeight, dikeHeightOutput.DikeHeight.GetAccuracy());
Assert.AreEqual(dikeHeightOutput.TargetProbability, dikeHeightEntity.TargetProbability);
Assert.AreEqual(dikeHeightOutput.TargetReliability, dikeHeightEntity.TargetReliability, dikeHeightOutput.TargetReliability.GetAccuracy());
Assert.AreEqual(dikeHeightOutput.CalculatedProbability, dikeHeightEntity.CalculatedProbability);
Assert.AreEqual(dikeHeightOutput.CalculatedReliability, dikeHeightEntity.CalculatedReliability, dikeHeightOutput.CalculatedReliability.GetAccuracy());
Assert.AreEqual((byte)dikeHeightOutput.CalculationConvergence, dikeHeightEntity.CalculationConvergence);
GrassCoverErosionInwardsOvertoppingRateOutputEntity overtoppingRateEntity = entity.GrassCoverErosionInwardsOvertoppingRateOutputEntities.Single();
Assert.AreEqual(overtoppingRateOutput.OvertoppingRate, overtoppingRateEntity.OvertoppingRate, overtoppingRateOutput.OvertoppingRate.GetAccuracy());
Assert.AreEqual(overtoppingRateOutput.TargetProbability, overtoppingRateEntity.TargetProbability);
Assert.AreEqual(overtoppingRateOutput.TargetReliability, overtoppingRateEntity.TargetReliability, overtoppingRateOutput.TargetReliability.GetAccuracy());
Assert.AreEqual(overtoppingRateOutput.CalculatedProbability, overtoppingRateEntity.CalculatedProbability);
Assert.AreEqual(overtoppingRateOutput.CalculatedReliability, overtoppingRateEntity.CalculatedReliability, overtoppingRateOutput.CalculatedReliability.GetAccuracy());
Assert.AreEqual((byte)overtoppingRateOutput.CalculationConvergence, overtoppingRateEntity.CalculationConvergence);
}
public void Read_ValidEntity_ReturnGrassCoverErosionInwardsOutput()
{
// Setup
var entity = new GrassCoverErosionInwardsOutputEntity
{
WaveHeight = 1.1,
IsOvertoppingDominant = Convert.ToByte(false),
Reliability = 0.2
};
// Call
GrassCoverErosionInwardsOutput output = entity.Read();
// Assert
OvertoppingOutput overtoppingOutput = output.OvertoppingOutput;
Assert.AreEqual(entity.WaveHeight, overtoppingOutput.WaveHeight.Value);
Assert.IsFalse(overtoppingOutput.IsOvertoppingDominant);
Assert.IsNull(output.DikeHeightOutput);
Assert.IsNull(output.OvertoppingRateOutput);
Assert.AreEqual(entity.Reliability, overtoppingOutput.Reliability);
}
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_ValidEntityWithNullValues_ReturnGrassCoverErosionInwardsOutput()
{
// Setup
var entity = new GrassCoverErosionInwardsOutputEntity
{
WaveHeight = null,
IsOvertoppingDominant = Convert.ToByte(true),
Reliability = null,
GeneralResultFaultTreeIllustrationPointEntity = null
};
// Call
GrassCoverErosionInwardsOutput output = entity.Read();
// Assert
OvertoppingOutput overtoppingOutput = output.OvertoppingOutput;
Assert.IsNaN(overtoppingOutput.WaveHeight);
Assert.IsTrue(overtoppingOutput.IsOvertoppingDominant);
Assert.IsNull(output.DikeHeightOutput);
Assert.IsNull(output.OvertoppingRateOutput);
Assert.IsNaN(overtoppingOutput.Reliability);
Assert.IsNull(overtoppingOutput.GeneralResult);
}
private static OvertoppingRateOutput GetOvertoppingRateOutput(GrassCoverErosionInwardsOutputEntity entity)
{
GrassCoverErosionInwardsOvertoppingRateOutputEntity overtoppingRateOutputEntity = entity.GrassCoverErosionInwardsOvertoppingRateOutputEntities.SingleOrDefault();
return(overtoppingRateOutputEntity?.Read());
}
private static DikeHeightOutput GetDikeHeightOutput(GrassCoverErosionInwardsOutputEntity entity)
{
GrassCoverErosionInwardsDikeHeightOutputEntity dikeHeightOutputEntity = entity.GrassCoverErosionInwardsDikeHeightOutputEntities.SingleOrDefault();
return(dikeHeightOutputEntity?.Read());
}
