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 ClearIllustrationPoints_OutputWithoutGeneralResult_OtherOutputIsNotAffected()
{
// Setup
var random = new Random(32);
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 output = new HydraulicBoundaryLocationCalculationOutput(result,
targetProbability,
targetReliability,
calculatedProbability,
calculatedReliability,
convergence,
null);
// Call
output.ClearIllustrationPoints();
// 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);
Assert.IsFalse(output.HasGeneralResult);
}
protected override IEnumerable <IllustrationPointControlItem> GetIllustrationPointControlItems()
{
DataGridViewRow currentRow = dataGridViewControl.CurrentRow;
if (currentRow == null)
{
return(Enumerable.Empty <IllustrationPointControlItem>());
}
HydraulicBoundaryLocationCalculation hydraulicBoundaryLocationCalculation = ((HydraulicBoundaryLocationCalculationRow)currentRow.DataBoundItem).CalculatableObject;
HydraulicBoundaryLocationCalculationOutput hydraulicBoundaryLocationCalculationOutput = hydraulicBoundaryLocationCalculation.Output;
if (hydraulicBoundaryLocationCalculation.HasOutput &&
hydraulicBoundaryLocationCalculationOutput.HasGeneralResult)
{
return(hydraulicBoundaryLocationCalculationOutput.GeneralResult.TopLevelIllustrationPoints.Select(
topLevelSubMechanismIllustrationPoint =>
{
SubMechanismIllustrationPoint subMechanismIllustrationPoint =
topLevelSubMechanismIllustrationPoint.SubMechanismIllustrationPoint;
return new IllustrationPointControlItem(topLevelSubMechanismIllustrationPoint,
topLevelSubMechanismIllustrationPoint.WindDirection.Name,
topLevelSubMechanismIllustrationPoint.ClosingSituation,
subMechanismIllustrationPoint.Stochasts,
subMechanismIllustrationPoint.Beta);
}).ToArray());
}
return(Enumerable.Empty <IllustrationPointControlItem>());
}
public void Constructor_ValidInputAndGeneralResultNull_ExpectedProperties()
{
// Setup
var random = new Random(32);
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>();
// Call
var output = new HydraulicBoundaryLocationCalculationOutput(result,
targetProbability,
targetReliability,
calculatedProbability,
calculatedReliability,
convergence,
null);
// 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);
Assert.IsFalse(output.HasGeneralResult);
}
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);
}
private static void CreateHydraulicBoundaryLocationCalculationOutput(HydraulicLocationCalculationEntity hydraulicLocationCalculationEntity,
HydraulicBoundaryLocationCalculationOutput output)
{
if (output != null)
{
hydraulicLocationCalculationEntity.HydraulicLocationOutputEntities.Add(output.CreateHydraulicLocationOutputEntity());
}
}
public void Calculate_ValidDesignWaterLevelCalculationAndConverges_SetsOutputAndLogs(bool readIllustrationPoints)
{
// Setup
var calculator = new TestDesignWaterLevelCalculator
{
IllustrationPointsResult = new TestGeneralResult(),
Converged = true
};
var mockRepository = new MockRepository();
var calculatorFactory = mockRepository.StrictMock <IHydraRingCalculatorFactory>();
calculatorFactory.Expect(cf => cf.CreateDesignWaterLevelCalculator(null))
.IgnoreArguments()
.Return(calculator);
var calculationMessageProvider = mockRepository.StrictMock <ICalculationMessageProvider>();
mockRepository.ReplayAll();
var hydraulicBoundaryLocation = new TestHydraulicBoundaryLocation();
var hydraulicBoundaryLocationCalculation = new HydraulicBoundaryLocationCalculation(hydraulicBoundaryLocation)
{
InputParameters =
{
ShouldIllustrationPointsBeCalculated = readIllustrationPoints
}
};
using (new HydraRingCalculatorFactoryConfig(calculatorFactory))
{
// Call
Action call = () => new DesignWaterLevelCalculationService().Calculate(hydraulicBoundaryLocationCalculation,
CreateCalculationSettings(),
1.0 / 30,
calculationMessageProvider);
// Assert
TestHelper.AssertLogMessages(call, messages =>
{
string[] msgs = messages.ToArray();
Assert.AreEqual(3, msgs.Length);
CalculationServiceTestHelper.AssertCalculationStartMessage(msgs[0]);
Assert.AreEqual($"Waterstand berekening is uitgevoerd op de tijdelijke locatie '{calculator.OutputDirectory}'. " +
"Gedetailleerde invoer en uitvoer kan in de bestanden op deze locatie worden gevonden.", msgs[1]);
CalculationServiceTestHelper.AssertCalculationEndMessage(msgs[2]);
});
Assert.IsFalse(calculator.IsCanceled);
HydraulicBoundaryLocationCalculationOutput actualOutput = hydraulicBoundaryLocationCalculation.Output;
Assert.IsNotNull(actualOutput);
Assert.AreEqual(readIllustrationPoints, actualOutput.HasGeneralResult);
}
mockRepository.VerifyAll();
}
private static void AssertHydraulicBoundaryLocationOutput(HydraulicBoundaryLocationCalculationOutput expectedOutput,
HydraulicBoundaryLocationCalculationOutput actualOutput)
{
Assert.AreEqual(expectedOutput.Result, actualOutput.Result);
Assert.AreEqual(expectedOutput.CalculatedProbability, actualOutput.CalculatedProbability);
Assert.AreEqual(expectedOutput.CalculatedReliability, actualOutput.CalculatedReliability);
Assert.AreEqual(expectedOutput.TargetProbability, actualOutput.TargetProbability);
Assert.AreEqual(expectedOutput.TargetReliability, actualOutput.TargetReliability);
Assert.AreEqual(expectedOutput.CalculationConvergence, actualOutput.CalculationConvergence);
}
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);
}
public void Run_ValidCalculation_SetsDesignWaterLevelAndConvergence(HydraulicBoundaryLocationCalculation hydraulicBoundaryLocationCalculation)
{
// Setup
const double targetProbability = 0.01;
const double expectedDesignWaterLevel = 3.5;
var calculator = new TestDesignWaterLevelCalculator
{
Converged = true,
DesignWaterLevel = expectedDesignWaterLevel
};
if (hydraulicBoundaryLocationCalculation.InputParameters.ShouldIllustrationPointsBeCalculated)
{
calculator.IllustrationPointsResult = new TestGeneralResult();
}
var mockRepository = new MockRepository();
var calculatorFactory = mockRepository.StrictMock <IHydraRingCalculatorFactory>();
calculatorFactory.Expect(cf => cf.CreateDesignWaterLevelCalculator(null))
.IgnoreArguments()
.Return(calculator);
mockRepository.ReplayAll();
var activity = new DesignWaterLevelCalculationActivity(hydraulicBoundaryLocationCalculation,
CreateCalculationSettings(),
targetProbability,
"1/100");
using (new HydraRingCalculatorFactoryConfig(calculatorFactory))
{
// Call
activity.Run();
}
// Assert
HydraulicBoundaryLocationCalculationOutput calculationOutput = hydraulicBoundaryLocationCalculation.Output;
Assert.IsNotNull(calculationOutput);
Assert.AreEqual(expectedDesignWaterLevel, calculationOutput.Result, calculationOutput.Result.GetAccuracy());
Assert.AreEqual(CalculationConvergence.CalculatedConverged, calculationOutput.CalculationConvergence);
mockRepository.VerifyAll();
}
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);
}
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);
}
/// <summary>
/// Performs a calculation for the design water level.
/// </summary>
/// <param name="hydraulicBoundaryLocationCalculation">The hydraulic boundary location calculation to perform.</param>
/// <param name="calculationSettings">The <see cref="HydraulicBoundaryCalculationSettings"/> with the
/// hydraulic boundary calculation settings.</param>
/// <param name="targetProbability">The target probability to use during the calculation.</param>
/// <param name="messageProvider">The object which is used to build log messages.</param>
/// <exception cref="CriticalFileReadException">Thrown when:
/// <list type="bullet">
/// <item>No settings database file could be found at the location of the hydraulic boundary database file path
/// with the same name.</item>
/// <item>Unable to open settings database file.</item>
/// <item>Unable to read required data from database file.</item>
/// </list></exception>
/// <exception cref="HydraRingCalculationException">Thrown when an error occurs while performing the calculation.</exception>
private void PerformCalculation(HydraulicBoundaryLocationCalculation hydraulicBoundaryLocationCalculation,
HydraulicBoundaryCalculationSettings calculationSettings,
double targetProbability,
ICalculationMessageProvider messageProvider)
{
HydraulicBoundaryLocation hydraulicBoundaryLocation = hydraulicBoundaryLocationCalculation.HydraulicBoundaryLocation;
AssessmentLevelCalculationInput calculationInput = CreateInput(hydraulicBoundaryLocation.Id, targetProbability, calculationSettings);
calculator.Calculate(calculationInput);
if (canceled || !string.IsNullOrEmpty(calculator.LastErrorFileContent))
{
return;
}
GeneralResult <TopLevelSubMechanismIllustrationPoint> generalResult = null;
try
{
generalResult = hydraulicBoundaryLocationCalculation.InputParameters.ShouldIllustrationPointsBeCalculated
? GetGeneralResult(calculator.IllustrationPointsResult)
: null;
}
catch (ArgumentException e)
{
log.Warn(string.Format(Resources.CalculationService_Error_in_reading_illustrationPoints_for_CalculationName_0_with_ErrorMessage_1,
hydraulicBoundaryLocation.Name,
e.Message));
}
HydraulicBoundaryLocationCalculationOutput hydraulicBoundaryLocationCalculationOutput = CreateOutput(
messageProvider, hydraulicBoundaryLocation.Name, calculationInput.Beta, targetProbability, calculator.Converged, generalResult);
hydraulicBoundaryLocationCalculation.Output = hydraulicBoundaryLocationCalculationOutput;
}
private static RoundedDouble GetCalculationResult(HydraulicBoundaryLocationCalculationOutput output)
{
return(output?.Result ?? RoundedDouble.NaN);
}
public void GetProperties_ValidData_ReturnsExpectedValues(bool withIllustrationPoints)
{
// Setup
var random = new Random();
double targetProbability = random.NextDouble();
double targetReliability = random.NextDouble();
double calculatedProbability = random.NextDouble();
double calculatedReliability = random.NextDouble();
double result = random.NextDouble();
var convergence = random.NextEnumValue <CalculationConvergence>();
var illustrationPoints = new[]
{
new TopLevelSubMechanismIllustrationPoint(new WindDirection("WEST", 4), "sluit", new TestSubMechanismIllustrationPoint())
};
var stochasts = new[]
{
new Stochast("a", 2, 3)
};
const string governingWindDirection = "EAST";
GeneralResult <TopLevelSubMechanismIllustrationPoint> generalResult =
withIllustrationPoints
? new GeneralResult <TopLevelSubMechanismIllustrationPoint>(new WindDirection(governingWindDirection, 2),
stochasts,
illustrationPoints)
: null;
var hydraulicBoundaryLocationCalculationOutput = new HydraulicBoundaryLocationCalculationOutput(result,
targetProbability,
targetReliability,
calculatedProbability,
calculatedReliability,
convergence,
generalResult);
var calculation = new HydraulicBoundaryLocationCalculation(new TestHydraulicBoundaryLocation())
{
Output = hydraulicBoundaryLocationCalculationOutput
};
// Call
var properties = new TestHydraulicBoundaryLocationCalculationBaseProperties(calculation);
// Assert
Assert.AreEqual(targetProbability, properties.TargetProbability);
Assert.AreEqual(targetReliability, properties.TargetReliability, properties.TargetReliability.GetAccuracy());
Assert.AreEqual(calculatedProbability, properties.CalculatedProbability);
Assert.AreEqual(calculatedReliability, properties.CalculatedReliability, properties.CalculatedReliability.GetAccuracy());
Assert.AreEqual(convergence, properties.Convergence);
Assert.AreEqual(calculation.InputParameters.ShouldIllustrationPointsBeCalculated, properties.ShouldIllustrationPointsBeCalculated);
if (withIllustrationPoints)
{
GeneralResult <TopLevelSubMechanismIllustrationPoint> expectedGeneralResult = hydraulicBoundaryLocationCalculationOutput.GeneralResult;
CollectionAssert.AreEqual(expectedGeneralResult.Stochasts, properties.AlphaValues);
CollectionAssert.AreEqual(expectedGeneralResult.Stochasts, properties.Durations);
CollectionAssert.AreEqual(expectedGeneralResult.TopLevelIllustrationPoints, properties.IllustrationPoints.Select(ip => ip.Data));
Assert.AreEqual(expectedGeneralResult.GoverningWindDirection.Name, properties.GoverningWindDirection);
}
}
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);
}
private static void AssertHydraulicBoundaryLocationCalculationOutput(IDesignWaterLevelCalculator designWaterLevelCalculator,
HydraulicBoundaryLocationCalculationOutput actualOutput)
{
Assert.AreEqual(designWaterLevelCalculator.DesignWaterLevel, actualOutput.Result, actualOutput.Result.GetAccuracy());
Assert.AreEqual(CalculationConvergence.CalculatedNotConverged, actualOutput.CalculationConvergence);
}
/// <summary>
/// Creates a <see cref="HydraulicLocationOutputEntity"/> based
/// on the information of the <see cref="HydraulicBoundaryLocationCalculationOutput"/>.
/// </summary>
/// <param name="output">The output to create a database entity for.</param>
/// <returns>A new <see cref="HydraulicLocationOutputEntity"/>.</returns>
/// <exception cref="ArgumentNullException">Thrown when <paramref name="output"/> is <c>null</c>.</exception>
internal static HydraulicLocationOutputEntity CreateHydraulicLocationOutputEntity(this HydraulicBoundaryLocationCalculationOutput output)
{
if (output == null)
{
throw new ArgumentNullException(nameof(output));
}
return(new HydraulicLocationOutputEntity
{
Result = output.Result.ToNaNAsNull(),
TargetProbability = output.TargetProbability.ToNaNAsNull(),
TargetReliability = output.TargetReliability.ToNaNAsNull(),
CalculatedProbability = output.CalculatedProbability.ToNaNAsNull(),
CalculatedReliability = output.CalculatedReliability.ToNaNAsNull(),
CalculationConvergence = Convert.ToByte(output.CalculationConvergence),
GeneralResultSubMechanismIllustrationPointEntity = output.GeneralResult?.CreateGeneralResultSubMechanismIllustrationPointEntity()
});
}
private static void AssertHydraulicBoundaryLocationCalculationOutput(IWaveHeightCalculator waveHeightCalculator,
HydraulicBoundaryLocationCalculationOutput actualOutput)
{
Assert.AreEqual(waveHeightCalculator.WaveHeight, actualOutput.Result, actualOutput.Result.GetAccuracy());
Assert.AreEqual(CalculationConvergence.CalculatedNotConverged, actualOutput.CalculationConvergence);
}
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());
}
