public void Read_NaNParameters_ReturnsHydraulicBoundaryLocationCalculationOutputWithNaN() { // Setup var random = new Random(21); var convergence = random.NextEnumValue <CalculationConvergence>(); var entity = new HydraulicLocationOutputEntity { Result = double.NaN, TargetProbability = double.NaN, TargetReliability = double.NaN, CalculatedProbability = double.NaN, CalculatedReliability = double.NaN, CalculationConvergence = Convert.ToByte(convergence) }; // Call HydraulicBoundaryLocationCalculationOutput output = entity.Read(); // Assert Assert.IsNaN(output.Result); Assert.IsNaN(output.TargetProbability); Assert.IsNaN(output.TargetReliability); Assert.IsNaN(output.CalculatedProbability); Assert.IsNaN(output.CalculatedReliability); Assert.AreEqual(convergence, output.CalculationConvergence); Assert.IsNull(output.GeneralResult); }
public void Read_ValidParameters_ReturnsHydraulicBoundaryLocationCalculationOutput() { // Setup var random = new Random(22); double result = random.NextDouble(); double targetProbability = random.NextDouble(); double targetReliability = random.NextDouble(); double calculatedProbability = random.NextDouble(); double calculatedReliability = random.NextDouble(); var convergence = random.NextEnumValue <CalculationConvergence>(); var entity = new HydraulicLocationOutputEntity { Result = result, TargetProbability = targetProbability, TargetReliability = targetReliability, CalculatedProbability = calculatedProbability, CalculatedReliability = calculatedReliability, CalculationConvergence = Convert.ToByte(convergence) }; // Call HydraulicBoundaryLocationCalculationOutput output = entity.Read(); // Assert Assert.AreEqual(result, output.Result, output.Result.GetAccuracy()); Assert.AreEqual(targetProbability, output.TargetProbability); Assert.AreEqual(targetReliability, output.TargetReliability, output.TargetReliability.GetAccuracy()); Assert.AreEqual(calculatedProbability, output.CalculatedProbability); Assert.AreEqual(calculatedReliability, output.CalculatedReliability, output.CalculatedReliability.GetAccuracy()); Assert.AreEqual(convergence, output.CalculationConvergence); Assert.IsNull(output.GeneralResult); }
public void CreateHydraulicLocationOutputEntity_WithGeneralResult_ReturnsHydraulicLocationEntityWithGeneralResult() { // Setup var random = new Random(21); var output = new HydraulicBoundaryLocationCalculationOutput(double.NaN, double.NaN, double.NaN, double.NaN, double.NaN, random.NextEnumValue <CalculationConvergence>(), GetGeneralResult()); // Call HydraulicLocationOutputEntity entity = output.CreateHydraulicLocationOutputEntity(); // Assert GeneralResultEntityTestHelper.AssertGeneralResultPropertyValues(output.GeneralResult, entity.GeneralResultSubMechanismIllustrationPointEntity); }
private static HydraulicLocationOutputEntity CreateHydraulicOutputEntity(int seed) { var random = new Random(seed); var hydraulicLocationOutputEntity = new HydraulicLocationOutputEntity { Result = random.NextDouble(), TargetProbability = random.NextDouble(), TargetReliability = random.NextDouble(), CalculatedProbability = random.NextDouble(), CalculatedReliability = random.NextDouble(), CalculationConvergence = Convert.ToByte(CalculationConvergence.NotCalculated) }; return(hydraulicLocationOutputEntity); }
/// <summary> /// Read the <see cref="HydraulicLocationOutputEntity"/> and use the information to construct a <see cref="HydraulicBoundaryLocationCalculationOutput"/>. /// </summary> /// <param name="entity">The <see cref="HydraulicLocationOutputEntity"/> to create <see cref="HydraulicBoundaryLocationCalculationOutput"/> for.</param> /// <returns>A new <see cref="HydraulicBoundaryLocationCalculationOutput"/>.</returns> /// <exception cref="ArgumentNullException">Thrown when <paramref name="entity"/> is <c>null</c>.</exception> internal static HydraulicBoundaryLocationCalculationOutput Read(this HydraulicLocationOutputEntity entity) { if (entity == null) { throw new ArgumentNullException(nameof(entity)); } return(new HydraulicBoundaryLocationCalculationOutput(entity.Result.ToNullAsNaN(), entity.TargetProbability.ToNullAsNaN(), entity.TargetReliability.ToNullAsNaN(), entity.CalculatedProbability.ToNullAsNaN(), entity.CalculatedReliability.ToNullAsNaN(), (CalculationConvergence)entity.CalculationConvergence, entity.GeneralResultSubMechanismIllustrationPointEntity?.Read())); }
private static HydraulicLocationCalculationEntity CreateCalculationEntityWithOutputAndGeneralResultEntity(int seed) { var random = new Random(seed); var generalResultEntity = new GeneralResultSubMechanismIllustrationPointEntity { GoverningWindDirectionName = "A wind direction", GoverningWindDirectionAngle = random.NextDouble() }; HydraulicLocationOutputEntity hydraulicLocationOutputEntity = CreateHydraulicOutputEntity(seed); hydraulicLocationOutputEntity.GeneralResultSubMechanismIllustrationPointEntity = generalResultEntity; HydraulicLocationCalculationEntity calculationEntity = CreateCalculationEntity(seed); calculationEntity.HydraulicLocationOutputEntities.Add(hydraulicLocationOutputEntity); return(calculationEntity); }
public void Create_CalculationWithOutput_ReturnsHydraulicLocationCalculationEntityWithOutput() { // Setup var random = new Random(33); bool shouldIllustrationPointsBeCalculated = random.NextBoolean(); var hydraulicBoundaryLocation = new TestHydraulicBoundaryLocation(); var calculation = new HydraulicBoundaryLocationCalculation(hydraulicBoundaryLocation) { InputParameters = { ShouldIllustrationPointsBeCalculated = shouldIllustrationPointsBeCalculated }, Output = new HydraulicBoundaryLocationCalculationOutput( random.NextDouble(), random.NextDouble(), random.NextDouble(), random.NextDouble(), random.NextDouble(), random.NextEnumValue <CalculationConvergence>(), null) }; var registry = new PersistenceRegistry(); var hydraulicLocationEntity = new HydraulicLocationEntity(); registry.Register(hydraulicLocationEntity, hydraulicBoundaryLocation); // Call HydraulicLocationCalculationEntity entity = calculation.Create(registry); // Assert Assert.IsNotNull(entity); Assert.AreEqual(Convert.ToByte(shouldIllustrationPointsBeCalculated), entity.ShouldIllustrationPointsBeCalculated); HydraulicLocationOutputEntity outputEntity = entity.HydraulicLocationOutputEntities.Single(); HydraulicBoundaryLocationCalculationOutput expectedOutput = calculation.Output; Assert.AreEqual(expectedOutput.CalculatedProbability, outputEntity.CalculatedProbability); Assert.AreEqual(expectedOutput.CalculatedReliability, outputEntity.CalculatedReliability); Assert.AreEqual(expectedOutput.TargetReliability, outputEntity.TargetReliability); Assert.AreEqual(expectedOutput.TargetProbability, outputEntity.TargetProbability); Assert.IsNull(outputEntity.GeneralResultSubMechanismIllustrationPointEntity); Assert.AreEqual(Convert.ToByte(expectedOutput.CalculationConvergence), outputEntity.CalculationConvergence); }
/// <summary> /// Reads the <see cref="HydraulicLocationCalculationEntity"/> and uses the information to update a /// <see cref="HydraulicBoundaryLocationCalculation"/>. /// </summary> /// <param name="entity">The <see cref="HydraulicLocationCalculationEntity"/> to update the /// <see cref="HydraulicBoundaryLocationCalculation"/>.</param> /// <param name="calculation">The target of the read operation.</param> /// <exception cref="ArgumentNullException">Thrown when any parameter is <c>null</c>.</exception> internal static void Read(this HydraulicLocationCalculationEntity entity, HydraulicBoundaryLocationCalculation calculation) { if (entity == null) { throw new ArgumentNullException(nameof(entity)); } if (calculation == null) { throw new ArgumentNullException(nameof(calculation)); } calculation.InputParameters.ShouldIllustrationPointsBeCalculated = Convert.ToBoolean(entity.ShouldIllustrationPointsBeCalculated); HydraulicLocationOutputEntity outputEntity = entity.HydraulicLocationOutputEntities.SingleOrDefault(); if (outputEntity != null) { calculation.Output = outputEntity.Read(); } }
public void CreateHydraulicLocationOutputEntity_WithNaNParameters_ReturnsHydraulicLocationEntityWithOutputNaN() { // Setup var random = new Random(21); var output = new HydraulicBoundaryLocationCalculationOutput(double.NaN, double.NaN, double.NaN, double.NaN, double.NaN, random.NextEnumValue <CalculationConvergence>(), null); // Call HydraulicLocationOutputEntity entity = output.CreateHydraulicLocationOutputEntity(); // Assert Assert.IsNotNull(entity); Assert.IsNull(entity.Result); Assert.IsNull(entity.TargetProbability); Assert.IsNull(entity.TargetReliability); Assert.IsNull(entity.CalculatedProbability); Assert.IsNull(entity.CalculatedReliability); Assert.AreEqual((byte)output.CalculationConvergence, entity.CalculationConvergence); Assert.IsNull(entity.GeneralResultSubMechanismIllustrationPointEntity); }
private static void AssertHydraulicBoundaryLocationCalculationOutput(HydraulicLocationOutputEntity expected, HydraulicBoundaryLocationCalculationOutput actual) { if (expected == null) { Assert.IsNull(actual); return; } Assert.IsNotNull(expected.Result); Assert.AreEqual((RoundedDouble)expected.Result, actual.Result, actual.Result.GetAccuracy()); Assert.IsNotNull(expected.TargetReliability); Assert.AreEqual((RoundedDouble)expected.TargetReliability, actual.TargetReliability, actual.TargetReliability.GetAccuracy()); Assert.IsNotNull(expected.TargetProbability); Assert.AreEqual(expected.TargetProbability, actual.TargetProbability); Assert.IsNotNull(expected.CalculatedReliability); Assert.AreEqual((RoundedDouble)expected.CalculatedReliability, actual.CalculatedReliability, actual.CalculatedReliability.GetAccuracy()); Assert.IsNotNull(expected.CalculatedProbability); Assert.AreEqual(expected.CalculatedProbability, actual.CalculatedProbability); Assert.AreEqual((CalculationConvergence)expected.CalculationConvergence, actual.CalculationConvergence); AssertGeneralResult(expected.GeneralResultSubMechanismIllustrationPointEntity, actual.GeneralResult); }
public void Read_EntityWithIllustrationPoints_ReturnsHydraulicBoundaryLocationCalculationOutputWithGeneralResult() { // Setup var random = new Random(21); var stochastEntities = new[] { new StochastEntity { Name = "stochastEntityOne", Duration = random.NextDouble(), Alpha = random.NextDouble(), Order = 0 } }; var topLevelIllustrationPointEntities = new[] { new TopLevelSubMechanismIllustrationPointEntity { WindDirectionName = "WindDirectionTwo", WindDirectionAngle = random.NextDouble(), ClosingSituation = "ClosingSituationTwo", SubMechanismIllustrationPointEntity = new SubMechanismIllustrationPointEntity { Beta = random.NextDouble(), Name = "IllustrationPointTwo" }, Order = 0 } }; var entity = new HydraulicLocationOutputEntity { Result = double.NaN, TargetProbability = double.NaN, TargetReliability = double.NaN, CalculatedProbability = double.NaN, CalculatedReliability = double.NaN, CalculationConvergence = Convert.ToByte(random.NextEnumValue <CalculationConvergence>()), GeneralResultSubMechanismIllustrationPointEntity = new GeneralResultSubMechanismIllustrationPointEntity { GoverningWindDirectionName = "SSE", GoverningWindDirectionAngle = random.NextDouble(), StochastEntities = stochastEntities, TopLevelSubMechanismIllustrationPointEntities = topLevelIllustrationPointEntities } }; // Call HydraulicBoundaryLocationCalculationOutput output = entity.Read(); // Assert GeneralResult <TopLevelSubMechanismIllustrationPoint> generalResult = output.GeneralResult; GeneralResultSubMechanismIllustrationPointEntity generalResultEntity = entity.GeneralResultSubMechanismIllustrationPointEntity; AssertWindDirection(generalResultEntity, generalResult.GoverningWindDirection); AssertStochasts(generalResultEntity.StochastEntities.ToArray(), generalResult.Stochasts.ToArray()); AssertIllustrationPoints(generalResultEntity.TopLevelSubMechanismIllustrationPointEntities.ToArray(), generalResult.TopLevelIllustrationPoints.ToArray()); }