public void Create_AllOutputValuesSet_ReturnEntity()
{
// Setup
var random = new Random(21);
int order = random.Next();
var outputType = random.NextEnumValue <GrassCoverErosionOutwardsWaveConditionsOutputType>();
var output = new TestWaveConditionsOutput();
// Call
GrassCoverErosionOutwardsWaveConditionsOutputEntity entity = output.CreateGrassCoverErosionOutwardsWaveConditionsOutputEntity(outputType, order);
// Assert
Assert.AreEqual(output.WaterLevel, entity.WaterLevel, output.WaterLevel.GetAccuracy());
Assert.AreEqual(output.WaveHeight, entity.WaveHeight, output.WaveHeight.GetAccuracy());
Assert.AreEqual(output.WavePeakPeriod, entity.WavePeakPeriod, output.WavePeakPeriod.GetAccuracy());
Assert.AreEqual(output.WaveAngle, entity.WaveAngle, output.WaveAngle.GetAccuracy());
Assert.AreEqual(output.WaveDirection, entity.WaveDirection, output.WaveDirection.GetAccuracy());
Assert.AreEqual(output.TargetProbability, entity.TargetProbability);
Assert.AreEqual(output.TargetReliability, entity.TargetReliability, output.TargetReliability.GetAccuracy());
Assert.AreEqual(output.CalculatedProbability, entity.CalculatedProbability);
Assert.AreEqual(output.CalculatedReliability, entity.CalculatedReliability, output.CalculatedReliability.GetAccuracy());
Assert.AreEqual(output.CalculationConvergence, (CalculationConvergence)entity.CalculationConvergence);
Assert.AreEqual(Convert.ToByte(outputType), entity.OutputType);
Assert.IsNull(entity.GrassCoverErosionOutwardsWaveConditionsCalculationEntity);
}
public void Read_ValidEntityWithNullParameterValues_ReturnOutputWithNaNValues()
{
// Setup
var entity = new GrassCoverErosionOutwardsWaveConditionsOutputEntity
{
CalculationConvergence = Convert.ToByte(CalculationConvergence.NotCalculated),
WaterLevel = null,
WaveHeight = null,
WavePeakPeriod = null,
WaveAngle = null,
WaveDirection = null,
TargetProbability = null,
TargetReliability = null,
CalculatedProbability = null,
CalculatedReliability = null
};
// Call
WaveConditionsOutput output = entity.Read();
// Assert
Assert.IsNaN(output.WaterLevel);
Assert.IsNaN(output.WaveHeight);
Assert.IsNaN(output.WavePeakPeriod);
Assert.IsNaN(output.WaveAngle);
Assert.IsNaN(output.WaveDirection);
Assert.IsNaN(output.TargetProbability);
Assert.IsNaN(output.TargetReliability);
Assert.IsNaN(output.CalculatedProbability);
Assert.IsNaN(output.CalculatedReliability);
}
public void Read_ValidEntity_ReturnOutputWithValues()
{
// Setup
var random = new Random(12);
var entity = new GrassCoverErosionOutwardsWaveConditionsOutputEntity
{
WaterLevel = random.NextDouble(),
WaveHeight = random.NextDouble(),
WavePeakPeriod = random.NextDouble(),
WaveAngle = random.NextDouble(),
WaveDirection = random.NextDouble(),
TargetProbability = random.NextDouble(),
TargetReliability = random.NextDouble(),
CalculatedProbability = random.NextDouble(),
CalculatedReliability = random.NextDouble(),
CalculationConvergence = Convert.ToByte(CalculationConvergence.CalculatedConverged)
};
// Call
WaveConditionsOutput output = entity.Read();
// Assert
Assert.IsNotNull(entity.WaterLevel);
Assert.AreEqual(entity.WaterLevel.Value, output.WaterLevel, output.WaterLevel.GetAccuracy());
Assert.IsNotNull(entity.WaveHeight);
Assert.AreEqual(entity.WaveHeight.Value, output.WaveHeight, output.WaveHeight.GetAccuracy());
Assert.IsNotNull(entity.WavePeakPeriod);
Assert.AreEqual(entity.WavePeakPeriod.Value, output.WavePeakPeriod, output.WavePeakPeriod.GetAccuracy());
Assert.IsNotNull(entity.WaveAngle);
Assert.AreEqual(entity.WaveAngle.Value, output.WaveAngle, output.WaveAngle.GetAccuracy());
Assert.IsNotNull(entity.WaveDirection);
Assert.AreEqual(entity.WaveDirection.Value, output.WaveDirection, output.WaveDirection.GetAccuracy());
Assert.IsNotNull(entity.TargetProbability);
Assert.AreEqual(entity.TargetProbability.Value, output.TargetProbability);
Assert.IsNotNull(entity.TargetReliability);
Assert.AreEqual(entity.TargetReliability.Value, output.TargetReliability, output.TargetReliability.GetAccuracy());
Assert.IsNotNull(entity.CalculatedProbability);
Assert.AreEqual(entity.CalculatedProbability.Value, output.CalculatedProbability);
Assert.IsNotNull(entity.CalculatedReliability);
Assert.AreEqual(entity.CalculatedReliability.Value, output.CalculatedReliability, output.CalculatedReliability.GetAccuracy());
Assert.IsNotNull(entity.CalculationConvergence);
Assert.AreEqual(CalculationConvergence.CalculatedConverged, output.CalculationConvergence);
}
/// <summary>
/// Reads the <see cref="GrassCoverErosionOutwardsWaveConditionsOutputEntity"/>
/// and use the information to construct a <see cref="WaveConditionsOutput"/>.
/// </summary>
/// <param name="entity">The <see cref="GrassCoverErosionOutwardsWaveConditionsOutputEntity"/>
/// to create <see cref="WaveConditionsOutput"/> for.</param>
/// <returns>A new <see cref="WaveConditionsOutput"/>.</returns>
internal static WaveConditionsOutput Read(this GrassCoverErosionOutwardsWaveConditionsOutputEntity entity)
{
return(new WaveConditionsOutput(entity.WaterLevel.ToNullAsNaN(),
entity.WaveHeight.ToNullAsNaN(),
entity.WavePeakPeriod.ToNullAsNaN(),
entity.WaveAngle.ToNullAsNaN(),
entity.WaveDirection.ToNullAsNaN(),
entity.TargetProbability.ToNullAsNaN(),
entity.TargetReliability.ToNullAsNaN(),
entity.CalculatedProbability.ToNullAsNaN(),
entity.CalculatedReliability.ToNullAsNaN(),
(CalculationConvergence)entity.CalculationConvergence));
}
/// <summary>
/// Creates a <see cref="GrassCoverErosionOutwardsWaveConditionsOutputEntity"/> based on the information
/// of the <see cref="WaveConditionsOutput"/>.
/// </summary>
/// <param name="output">The calculation output for grass cover erosion outwards failure mechanism to
/// create a database entity for.</param>
/// <param name="type">The type of <see cref="GrassCoverErosionOutwardsWaveConditionsOutputType"/>.</param>
/// <param name="order">The position of <paramref name="output"/> in the list of all outputs.</param>
/// <returns>A new <see cref="GrassCoverErosionOutwardsWaveConditionsOutputEntity"/>.</returns>
internal static GrassCoverErosionOutwardsWaveConditionsOutputEntity CreateGrassCoverErosionOutwardsWaveConditionsOutputEntity(
this WaveConditionsOutput output, GrassCoverErosionOutwardsWaveConditionsOutputType type, int order)
{
var entity = new GrassCoverErosionOutwardsWaveConditionsOutputEntity
{
Order = order,
OutputType = Convert.ToByte(type),
WaterLevel = output.WaterLevel.ToNaNAsNull(),
WaveHeight = output.WaveHeight.ToNaNAsNull(),
WavePeakPeriod = output.WavePeakPeriod.ToNaNAsNull(),
WaveAngle = output.WaveAngle.ToNaNAsNull(),
WaveDirection = output.WaveDirection.ToNaNAsNull(),
TargetProbability = output.TargetProbability.ToNaNAsNull(),
TargetReliability = output.TargetReliability.ToNaNAsNull(),
CalculatedProbability = output.CalculatedProbability.ToNaNAsNull(),
CalculatedReliability = output.CalculatedReliability.ToNaNAsNull(),
CalculationConvergence = Convert.ToByte(output.CalculationConvergence)
};
return(entity);
}
public void Create_AllOutputValuesNaN_ReturnEntityWithNullValues()
{
// Setup
var output = new WaveConditionsOutput(double.NaN, double.NaN, double.NaN, double.NaN, double.NaN, double.NaN,
double.NaN, double.NaN, double.NaN, CalculationConvergence.NotCalculated);
// Call
GrassCoverErosionOutwardsWaveConditionsOutputEntity entity =
output.CreateGrassCoverErosionOutwardsWaveConditionsOutputEntity(GrassCoverErosionOutwardsWaveConditionsOutputType.WaveImpact, 1);
// Assert
Assert.IsNull(entity.WaterLevel);
Assert.IsNull(entity.WaveHeight);
Assert.IsNull(entity.WavePeakPeriod);
Assert.IsNull(entity.WaveAngle);
Assert.IsNull(entity.WaveDirection);
Assert.IsNull(entity.TargetProbability);
Assert.IsNull(entity.TargetReliability);
Assert.IsNull(entity.CalculatedProbability);
Assert.IsNull(entity.CalculatedReliability);
Assert.IsNull(entity.GrassCoverErosionOutwardsWaveConditionsCalculationEntity);
}
