public void Constructor_DataGridViewCorrectlyInitialized()
{
// Call
ShowFullyConfiguredScenariosView(new CalculationGroup(), new TestCalculatableFailureMechanism());
var dataGridView = (DataGridView) new ControlTester("dataGridView").TheObject;
// Assert
Assert.IsFalse(dataGridView.AutoGenerateColumns);
Assert.AreEqual(4, dataGridView.ColumnCount);
Assert.AreEqual("In oordeel", dataGridView.Columns[isRelevantColumnIndex].HeaderText);
Assert.AreEqual("Bijdrage aan\r\nscenario\r\n[%]", dataGridView.Columns[contributionColumnIndex].HeaderText);
Assert.AreEqual("Naam", dataGridView.Columns[nameColumnIndex].HeaderText);
Assert.AreEqual("Faalkans\r\n[1/jaar]", dataGridView.Columns[failureProbabilityColumnIndex].HeaderText);
DataGridViewRowCollection rows = dataGridView.Rows;
Assert.AreEqual(2, rows.Count);
DataGridViewCellCollection cells = rows[0].Cells;
Assert.AreEqual(4, cells.Count);
Assert.IsTrue(Convert.ToBoolean(cells[isRelevantColumnIndex].FormattedValue));
Assert.AreEqual(new RoundedDouble(2, 100).ToString(), cells[contributionColumnIndex].FormattedValue);
Assert.AreEqual("Calculation 1", cells[nameColumnIndex].FormattedValue);
Assert.AreEqual(ProbabilityFormattingHelper.Format(1), cells[failureProbabilityColumnIndex].FormattedValue);
cells = rows[1].Cells;
Assert.AreEqual(4, cells.Count);
Assert.IsFalse(Convert.ToBoolean(cells[isRelevantColumnIndex].FormattedValue));
Assert.AreEqual(new RoundedDouble(2, 100).ToString(), cells[contributionColumnIndex].FormattedValue);
Assert.AreEqual("Calculation 2", cells[nameColumnIndex].FormattedValue);
Assert.AreEqual(ProbabilityFormattingHelper.Format(1), cells[failureProbabilityColumnIndex].FormattedValue);
}
public void GrassCoverErosionInwardsScenarioView_CalculationsWithAllDataSet_DataGridViewCorrectlyInitialized()
{
// Call
ShowFullyConfiguredGrassCoverErosionInwardsScenariosView();
var dataGridView = (DataGridView) new ControlTester("dataGridView").TheObject;
// Assert
DataGridViewRowCollection rows = dataGridView.Rows;
Assert.AreEqual(2, rows.Count);
DataGridViewCellCollection cells = rows[0].Cells;
Assert.AreEqual(4, cells.Count);
Assert.IsTrue(Convert.ToBoolean(cells[isRelevantColumnIndex].FormattedValue));
Assert.AreEqual(new RoundedDouble(2, 100).ToString(), cells[contributionColumnIndex].FormattedValue);
Assert.AreEqual("Calculation 1", cells[nameColumnIndex].FormattedValue);
Assert.AreEqual("-", cells[failureProbabilityColumnIndex].FormattedValue);
cells = rows[1].Cells;
Assert.AreEqual(4, cells.Count);
Assert.IsTrue(Convert.ToBoolean(cells[isRelevantColumnIndex].FormattedValue));
Assert.AreEqual(new RoundedDouble(2, 100).ToString(), cells[contributionColumnIndex].FormattedValue);
Assert.AreEqual("Calculation 2", cells[nameColumnIndex].FormattedValue);
Assert.AreEqual(ProbabilityFormattingHelper.Format(0.5), cells[failureProbabilityColumnIndex].FormattedValue);
}
/// <summary>
/// Adds target probability related meta data to the given <paramref name="feature"/>.
/// </summary>
/// <param name="feature">The feature to add the meta data to.</param>
/// <param name="targetProbabilities">The collection of target probabilities to add.</param>
/// <param name="displayNameFormat">The display name format of the meta data.</param>
/// <exception cref="ArgumentNullException">Thrown when any parameter is <c>null</c>.</exception>
/// <exception cref="FormatException">Thrown when <paramref name="displayNameFormat"/> is invalid;
/// or the index of a format item is not zero.</exception>
public static void AddTargetProbabilityMetaData(MapFeature feature, IEnumerable <Tuple <double, RoundedDouble> > targetProbabilities, string displayNameFormat)
{
if (feature == null)
{
throw new ArgumentNullException(nameof(feature));
}
if (targetProbabilities == null)
{
throw new ArgumentNullException(nameof(targetProbabilities));
}
if (displayNameFormat == null)
{
throw new ArgumentNullException(nameof(displayNameFormat));
}
var addedMetaDataItems = new List <string>();
foreach (Tuple <double, RoundedDouble> calculationOutputForTargetProbability in targetProbabilities)
{
string uniqueName = NamingHelper.GetUniqueName(
addedMetaDataItems, string.Format(displayNameFormat, ProbabilityFormattingHelper.Format(calculationOutputForTargetProbability.Item1)),
v => v);
feature.MetaData[uniqueName] = calculationOutputForTargetProbability.Item2.ToString();
addedMetaDataItems.Add(uniqueName);
}
}
public void CreateHydraulicBoundaryLocationFeatures_WithLocations_ReturnsLocationFeaturesCollection(bool setOutput)
{
// Setup
var assessmentSection = new AssessmentSectionStub();
assessmentSection.SetHydraulicBoundaryLocationCalculations(new[]
{
new HydraulicBoundaryLocation(1, "location1", 1, 1),
new HydraulicBoundaryLocation(2, "location2", 2, 2)
}, setOutput);
Dictionary <IObservableEnumerable <HydraulicBoundaryLocationCalculation>, string> waterLevels =
assessmentSection.WaterLevelCalculationsForUserDefinedTargetProbabilities.ToDictionary(
tp => (IObservableEnumerable <HydraulicBoundaryLocationCalculation>)tp.HydraulicBoundaryLocationCalculations,
tp => $"h - {ProbabilityFormattingHelper.Format(tp.TargetProbability)}");
waterLevels.Add(assessmentSection.WaterLevelCalculationsForMaximumAllowableFloodingProbability, "h - 1/30.000");
waterLevels.Add(assessmentSection.WaterLevelCalculationsForSignalFloodingProbability, "h - 1/30.000 (1)");
IEnumerable <AggregatedHydraulicBoundaryLocation> locations = AggregatedHydraulicBoundaryLocationFactory.CreateAggregatedHydraulicBoundaryLocations(
assessmentSection.HydraulicBoundaryDatabase.Locations,
waterLevels,
assessmentSection.WaveHeightCalculationsForUserDefinedTargetProbabilities.ToDictionary(
tp => (IObservableEnumerable <HydraulicBoundaryLocationCalculation>)tp.HydraulicBoundaryLocationCalculations,
tp => $"Hs - {ProbabilityFormattingHelper.Format(tp.TargetProbability)}"));
// Call
IEnumerable <MapFeature> features = RiskeerMapDataFeaturesFactory.CreateHydraulicBoundaryLocationFeatures(locations);
// Assert
MapFeaturesTestHelper.AssertHydraulicBoundaryFeaturesData(assessmentSection, features);
}
public void GetProperties_WithData_ReturnExpectedValues()
{
// Setup
PartialProbabilisticFaultTreePipingOutput output = PipingTestDataGenerator.GetRandomPartialProbabilisticFaultTreePipingOutput();
// Call
var properties = new ProbabilisticFaultTreePipingOutputProperties(output);
// Assert
Assert.AreEqual(ProbabilityFormattingHelper.Format(StatisticsConverter.ReliabilityToProbability(output.Reliability)), properties.Probability);
Assert.AreEqual(output.Reliability, properties.Reliability, properties.Reliability.GetAccuracy());
GeneralResult <TopLevelFaultTreeIllustrationPoint> generalResult = output.GeneralResult;
Assert.AreEqual(generalResult.GoverningWindDirection.Name, properties.WindDirection);
int nrOfExpectedStochasts = generalResult.Stochasts.Count();
Assert.AreEqual(nrOfExpectedStochasts, properties.AlphaValues.Length);
Assert.AreEqual(nrOfExpectedStochasts, properties.Durations.Length);
Stochast expectedStochast = generalResult.Stochasts.First();
Assert.AreEqual(expectedStochast.Alpha, properties.AlphaValues[0].Alpha);
Assert.AreEqual(expectedStochast.Duration, properties.Durations[0].Duration);
int nrOfExpectedTopLevelIllustrationPoints = generalResult.TopLevelIllustrationPoints.Count();
Assert.AreEqual(nrOfExpectedTopLevelIllustrationPoints, properties.IllustrationPoints.Length);
CollectionAssert.AreEqual(generalResult.TopLevelIllustrationPoints, properties.IllustrationPoints.Select(i => i.Data));
}
public void FormatFromReturnPeriod_ReturnPeriodNotZero_ReturnOneOverReturnPeriod(int returnPeriod, string expectedText)
{
// Call
string text = ProbabilityFormattingHelper.FormatFromReturnPeriod(returnPeriod);
// Assert
Assert.AreEqual(expectedText, text);
}
public void FormatWithDiscreteNumbers_ProbabilityIsZero_ReturnOneOverInfinity()
{
// Call
string text = ProbabilityFormattingHelper.FormatWithDiscreteNumbers(0);
// Assert
Assert.AreEqual("1/Oneindig", text);
}
public void FormatWithDiscreteNumbers_ProbabilityDiscreteNumber_ReturnsExpectedTextRepresentation(double probability, string expectedText)
{
// Call
string text = ProbabilityFormattingHelper.FormatWithDiscreteNumbers(probability);
// Assert
Assert.AreEqual(expectedText, text);
}
public void FormatWithDiscreteNumbers_ProbabilityNotZero_ReturnOneOverReturnPeriod(double probability, string expectedText)
{
// Call
string text = ProbabilityFormattingHelper.FormatWithDiscreteNumbers(probability);
// Assert
Assert.AreEqual(expectedText, text);
}
public void FormatFromReturnPeriod_ReturnPeriodIsZero_ReturnOneOverInfinity()
{
// Call
string text = ProbabilityFormattingHelper.FormatFromReturnPeriod(0);
// Assert
Assert.AreEqual("1/Oneindig", text);
}
private static void AssertAssemblyCells(IFailureMechanism failureMechanism, double assemblyResult, DataGridViewCellCollection cells)
{
Assert.AreEqual(expectedColumnCount, cells.Count);
Assert.AreEqual(failureMechanism.Name, cells[failureMechanismNameColumnIndex].Value);
Assert.AreEqual(failureMechanism.Code, cells[failureMechanismCodeColumnIndex].Value);
Assert.AreEqual(ProbabilityFormattingHelper.FormatWithDiscreteNumbers(assemblyResult),
cells[failureMechanismProbabilityColumnIndex].FormattedValue);
}
public void GivenMapLayerWithHydraulicBoundaryLocationsData_WhenSelectedWaveHeightTargetProbabilityIndexUpdatedAndCollectionNotified_ThenMapDataAndSelectedMetaDataAttributeUpdated(
Action <ObservableList <HydraulicBoundaryLocationCalculationsForTargetProbability> > shiftItemAction,
string selectedTargetProbabilityFormat, string expectedSelectedTargetProbabilityFormat)
{
// Given
var mocks = new MockRepository();
var observer = mocks.StrictMock <IObserver>();
observer.Expect(o => o.UpdateObserver());
mocks.ReplayAll();
const double targetProbability = 0.001;
var assessmentSection = new AssessmentSectionStub();
assessmentSection.WaveHeightCalculationsForUserDefinedTargetProbabilities.Clear();
assessmentSection.WaveHeightCalculationsForUserDefinedTargetProbabilities.AddRange(new[]
{
new HydraulicBoundaryLocationCalculationsForTargetProbability(targetProbability),
new HydraulicBoundaryLocationCalculationsForTargetProbability(targetProbability),
new HydraulicBoundaryLocationCalculationsForTargetProbability(targetProbability)
});
var hydraulicBoundaryLocation = new HydraulicBoundaryLocation(1, "test1", 1.0, 2.0);
assessmentSection.SetHydraulicBoundaryLocationCalculations(new[]
{
hydraulicBoundaryLocation
});
using (var mapLayer = new HydraulicBoundaryLocationsMapLayer(assessmentSection))
{
string targetProbabilityString = ProbabilityFormattingHelper.Format(targetProbability);
string selectedProbabilityString = string.Format(selectedTargetProbabilityFormat, targetProbabilityString);
mapLayer.MapData.SelectedMetaDataAttribute = string.Format(waveHeightDisplayNameFormat, selectedProbabilityString);
mapLayer.MapData.NotifyObservers();
mapLayer.MapData.Attach(observer);
// Precondition
MapDataTestHelper.AssertHydraulicBoundaryLocationsMapData(assessmentSection, mapLayer.MapData);
// When
ObservableList <HydraulicBoundaryLocationCalculationsForTargetProbability> waveHeightCalculationsForUserDefinedTargetProbabilities =
assessmentSection.WaveHeightCalculationsForUserDefinedTargetProbabilities;
shiftItemAction(waveHeightCalculationsForUserDefinedTargetProbabilities);
waveHeightCalculationsForUserDefinedTargetProbabilities.NotifyObservers();
// Then
MapDataTestHelper.AssertHydraulicBoundaryLocationsMapData(assessmentSection, mapLayer.MapData);
string expectedSelectedProbabilityString = string.Format(expectedSelectedTargetProbabilityFormat, targetProbabilityString);
Assert.AreEqual(string.Format(waveHeightDisplayNameFormat, expectedSelectedProbabilityString),
mapLayer.MapData.SelectedMetaDataAttribute);
}
mocks.VerifyAll();
}
public override object ConvertTo(ITypeDescriptorContext context, CultureInfo culture, object value, Type destinationType)
{
var doubleValue = (double)value;
if (destinationType == typeof(string))
{
return(ProbabilityFormattingHelper.FormatWithDiscreteNumbers(doubleValue));
}
return(base.ConvertTo(context, culture, value, destinationType));
}
/// <summary>
/// Sets the value of <paramref name="result"/> on the control.
/// </summary>
/// <param name="result">The <see cref="AssessmentSectionAssemblyResult"/> to set on the control.</param>
/// <exception cref="ArgumentNullException">Thrown when <paramref name="result"/> is <c>null</c>.</exception>
/// <exception cref="InvalidEnumArgumentException">Thrown when <paramref name="result"/>
/// has an invalid value for <see cref="AssessmentSectionAssemblyGroup"/>.</exception>
/// <exception cref="NotSupportedException">Thrown when <paramref name="result"/>
/// is not supported.</exception>
public void SetAssemblyResult(AssessmentSectionAssemblyResult result)
{
if (result == null)
{
throw new ArgumentNullException(nameof(result));
}
groupLabel.Text = EnumDisplayNameHelper.GetDisplayName(result.AssemblyGroup);
groupLabel.BackColor = AssessmentSectionAssemblyGroupColorHelper.GetAssessmentSectionAssemblyGroupColor(result.AssemblyGroup);
probabilityLabel.Text = ProbabilityFormattingHelper.FormatWithDiscreteNumbers(result.Probability);
}
public void GivenMapLayerWithDuneLocations_WhenSelectedTargetProbabilityIndexUpdatedAndCollectionNotified_ThenMapDataAndSelectedMetaDataAttributeUpdated(
Action <ObservableList <DuneLocationCalculationsForTargetProbability> > shiftItemAction,
string selectedMetaDataAttributeFormat, string expectedSelectedMetadataAttributeFormat)
{
// Given
var mocks = new MockRepository();
var observer = mocks.StrictMock <IObserver>();
observer.Expect(o => o.UpdateObserver());
mocks.ReplayAll();
const double targetProbability = 0.1;
var failureMechanism = new DuneErosionFailureMechanism
{
DuneLocationCalculationsForUserDefinedTargetProbabilities =
{
new DuneLocationCalculationsForTargetProbability(targetProbability),
new DuneLocationCalculationsForTargetProbability(targetProbability),
new DuneLocationCalculationsForTargetProbability(targetProbability)
}
};
failureMechanism.SetDuneLocations(new[]
{
new TestDuneLocation("test1")
});
using (var mapLayer = new DuneErosionLocationsMapLayer(failureMechanism))
{
string targetProbabilityString = ProbabilityFormattingHelper.Format(targetProbability);
string selectedProbabilityAttribute = string.Format(selectedMetaDataAttributeFormat, targetProbabilityString);
mapLayer.MapData.SelectedMetaDataAttribute = selectedProbabilityAttribute;
mapLayer.MapData.NotifyObservers();
mapLayer.MapData.Attach(observer);
// Precondition
AssertDuneLocationsMapData(failureMechanism, mapLayer.MapData);
// When
ObservableList <DuneLocationCalculationsForTargetProbability> duneLocationCalculationsForUserDefinedTargetProbabilities =
failureMechanism.DuneLocationCalculationsForUserDefinedTargetProbabilities;
shiftItemAction(duneLocationCalculationsForUserDefinedTargetProbabilities);
duneLocationCalculationsForUserDefinedTargetProbabilities.NotifyObservers();
// Then
AssertDuneLocationsMapData(failureMechanism, mapLayer.MapData);
Assert.AreEqual(string.Format(expectedSelectedMetadataAttributeFormat, targetProbabilityString),
mapLayer.MapData.SelectedMetaDataAttribute);
}
mocks.VerifyAll();
}
public void GetProperties_WithData_ReturnExpectedValues()
{
// Setup
PartialProbabilisticPipingOutput <TestTopLevelIllustrationPoint> output = PipingTestDataGenerator.GetRandomPartialProbabilisticPipingOutput();
// Call
var properties = new TestProbabilisticPipingOutputProperties(output);
// Assert
Assert.AreEqual(ProbabilityFormattingHelper.Format(StatisticsConverter.ReliabilityToProbability(output.Reliability)), properties.Probability);
Assert.AreEqual(output.Reliability, properties.Reliability, properties.Reliability.GetAccuracy());
}
public void GetProperties_WithData_ReturnExpectedValues()
{
// Setup
var random = new Random(39);
double waveHeight = random.NextDouble();
bool isOvertoppingDominant = random.NextBoolean();
double reliability = random.NextDouble();
var generalResult = new TestGeneralResultFaultTreeIllustrationPoint();
var overtoppingOutput = new OvertoppingOutput(waveHeight,
isOvertoppingDominant,
reliability,
generalResult);
// Call
var properties = new OvertoppingOutputProperties(overtoppingOutput);
// Assert
Assert.AreEqual(2, properties.WaveHeight.NumberOfDecimalPlaces);
Assert.AreEqual(waveHeight, properties.WaveHeight, properties.WaveHeight.GetAccuracy());
Assert.AreEqual(reliability, properties.Reliability, properties.Reliability.GetAccuracy());
Assert.AreEqual(ProbabilityFormattingHelper.Format(0.5), properties.Probability);
Assert.AreEqual(isOvertoppingDominant, properties.IsOvertoppingDominant);
Assert.AreEqual(generalResult.GoverningWindDirection.Name, properties.WindDirection);
TestHelper.AssertTypeConverter <StructuresOutputProperties, KeyValueExpandableArrayConverter>(
nameof(StructuresOutputProperties.AlphaValues));
TestHelper.AssertTypeConverter <StructuresOutputProperties, KeyValueExpandableArrayConverter>(
nameof(StructuresOutputProperties.Durations));
int nrOfExpectedStochasts = generalResult.Stochasts.Count();
Assert.AreEqual(nrOfExpectedStochasts, properties.AlphaValues.Length);
Assert.AreEqual(nrOfExpectedStochasts, properties.Durations.Length);
Stochast expectedStochast = generalResult.Stochasts.First();
Assert.AreEqual(expectedStochast.Alpha, properties.AlphaValues[0].Alpha);
Assert.AreEqual(expectedStochast.Duration, properties.Durations[0].Duration);
TestHelper.AssertTypeConverter <StructuresOutputProperties, ExpandableArrayConverter>(
nameof(StructuresOutputProperties.IllustrationPoints));
int nrOfExpectedTopLevelIllustrationPoints = generalResult.TopLevelIllustrationPoints.Count();
Assert.AreEqual(nrOfExpectedTopLevelIllustrationPoints, properties.IllustrationPoints.Length);
CollectionAssert.AreEqual(generalResult.TopLevelIllustrationPoints, properties.IllustrationPoints.Select(i => i.Data));
}
public void ConvertTo_NumberToString_ReturnStringInLocalEnglishCulture(double value)
{
// Setup
var converter = new NoProbabilityValueDoubleConverter();
// Call
var text = (string)converter.ConvertTo(value, typeof(string));
// Assert
string expectedText = ProbabilityFormattingHelper.Format(value);
Assert.AreEqual(expectedText, text);
}
private static void AssertMetaData(IEnumerable <HydraulicBoundaryLocationCalculation> calculations, HydraulicBoundaryLocation hydraulicBoundaryLocation,
MapFeature mapFeature, double targetProbability, string displayName, List <string> presentedMetaDataItems)
{
string uniqueName = NamingHelper.GetUniqueName(
presentedMetaDataItems, string.Format(displayName, ProbabilityFormattingHelper.Format(targetProbability)),
v => v);
MapFeaturesMetaDataTestHelper.AssertMetaData(
GetExpectedResult(calculations, hydraulicBoundaryLocation),
mapFeature, uniqueName);
presentedMetaDataItems.Add(uniqueName);
}
public void GetProperties_WithData_ReturnExpectedValues()
{
// Setup
const double norm = 0.1;
var random = new Random(22);
double upliftEffectiveStress = random.NextDouble();
double heaveGradient = random.NextDouble();
double sellmeijerCreepCoefficient = random.NextDouble();
double sellmeijerCriticalFall = random.NextDouble();
double sellmeijerReducedFall = random.NextDouble();
double upliftFactorOfSafety = random.NextDouble();
double heaveFactorOfSafety = random.NextDouble();
double sellmeijerFactorOfSafety = random.NextDouble();
var output = new SemiProbabilisticPipingOutput(new SemiProbabilisticPipingOutput.ConstructionProperties
{
UpliftEffectiveStress = upliftEffectiveStress,
HeaveGradient = heaveGradient,
SellmeijerCreepCoefficient = sellmeijerCreepCoefficient,
SellmeijerCriticalFall = sellmeijerCriticalFall,
SellmeijerReducedFall = sellmeijerReducedFall,
UpliftFactorOfSafety = upliftFactorOfSafety,
HeaveFactorOfSafety = heaveFactorOfSafety,
SellmeijerFactorOfSafety = sellmeijerFactorOfSafety
});
// Call
var properties = new SemiProbabilisticPipingOutputProperties(output, norm);
// Assert
DerivedSemiProbabilisticPipingOutput expectedDerivedOutput = DerivedSemiProbabilisticPipingOutputFactory.Create(output, norm);
Assert.AreEqual(upliftFactorOfSafety, properties.UpliftFactorOfSafety, properties.UpliftFactorOfSafety.GetAccuracy());
Assert.AreEqual(expectedDerivedOutput.UpliftReliability, properties.UpliftReliability, properties.UpliftReliability.GetAccuracy());
Assert.AreEqual(ProbabilityFormattingHelper.Format(expectedDerivedOutput.UpliftProbability), properties.UpliftProbability);
Assert.AreEqual(heaveFactorOfSafety, properties.HeaveFactorOfSafety, properties.HeaveFactorOfSafety.GetAccuracy());
Assert.AreEqual(expectedDerivedOutput.HeaveReliability, properties.HeaveReliability, properties.HeaveReliability.GetAccuracy());
Assert.AreEqual(ProbabilityFormattingHelper.Format(expectedDerivedOutput.HeaveProbability), properties.HeaveProbability);
Assert.AreEqual(sellmeijerFactorOfSafety, properties.SellmeijerFactorOfSafety, properties.SellmeijerFactorOfSafety.GetAccuracy());
Assert.AreEqual(expectedDerivedOutput.SellmeijerReliability, properties.SellmeijerReliability, properties.SellmeijerReliability.GetAccuracy());
Assert.AreEqual(ProbabilityFormattingHelper.Format(expectedDerivedOutput.SellmeijerProbability), properties.SellmeijerProbability);
Assert.AreEqual(ProbabilityFormattingHelper.Format(expectedDerivedOutput.PipingProbability), properties.PipingProbability);
Assert.AreEqual(expectedDerivedOutput.PipingReliability, properties.PipingReliability, properties.PipingReliability.GetAccuracy());
Assert.AreEqual(upliftEffectiveStress, properties.UpliftEffectiveStress, properties.UpliftEffectiveStress.GetAccuracy());
Assert.AreEqual(heaveGradient, properties.HeaveGradient, properties.HeaveGradient.GetAccuracy());
Assert.AreEqual(sellmeijerCreepCoefficient, properties.SellmeijerCreepCoefficient, properties.SellmeijerCreepCoefficient.GetAccuracy());
Assert.AreEqual(sellmeijerCriticalFall, properties.SellmeijerCriticalFall, properties.SellmeijerCriticalFall.GetAccuracy());
Assert.AreEqual(sellmeijerReducedFall, properties.SellmeijerReducedFall, properties.SellmeijerReducedFall.GetAccuracy());
}
private static string CreateGraphNodeContent(RoundedDouble beta)
{
double probability = StatisticsConverter.ReliabilityToProbability(beta);
if (probability == 0)
{
return(string.Format(Resources.GraphNodeConverter_GraphNodeContent_Probability_0_Beta_1, probability, beta));
}
return(string.Format(Resources.GraphNodeConverter_GraphNodeContent_Probability_0_Beta_1,
probability >= 0.00001
? ProbabilityFormattingHelper.Format(StatisticsConverter.ReliabilityToProbability(beta))
: probability.ToString("0.#####E+0", CultureInfo.CurrentCulture), beta));
}
public void Constructor_WithParentAndReferenceLineMetas_ShowsExpectedGrid(
[Values("", "10")] string assessmentSectionId,
[Values(null, int.MinValue, -1, 0, 1, int.MaxValue)]
int?signalFloodingProbability,
[Values(int.MinValue, -1, 0, 1, int.MaxValue)]
int maximumAllowableFloodingProbability)
{
// Setup
var referenceLineMetas = new[]
{
new ReferenceLineMeta
{
AssessmentSectionId = assessmentSectionId,
SignalFloodingProbability = signalFloodingProbability,
MaximumAllowableFloodingProbability = maximumAllowableFloodingProbability
}
};
using (var viewParent = new Form())
{
// Call
using (var dialog = new ReferenceLineMetaSelectionDialog(viewParent, referenceLineMetas))
{
// Assert
var grid = (DataGridViewControl) new ControlTester("ReferenceLineMetaDataGridViewControl", dialog).TheObject;
DataGridView dataGridView = grid.Controls.OfType <DataGridView>().First();
Assert.AreEqual(1, dataGridView.Rows.Count);
object currentIdValue = dataGridView[assessmentSectionIdColumn, 0].FormattedValue;
Assert.IsNotNull(currentIdValue);
Assert.AreEqual(assessmentSectionId, currentIdValue.ToString());
object currentSignalFloodingProbability = dataGridView[signalFloodingProbabilityColumn, 0].FormattedValue;
Assert.IsNotNull(currentSignalFloodingProbability);
string expectedSignalFloodingProbability = signalFloodingProbability.HasValue && signalFloodingProbability.Value > 0
? ProbabilityFormattingHelper.FormatFromReturnPeriod(signalFloodingProbability.Value)
: string.Empty;
Assert.AreEqual(expectedSignalFloodingProbability, currentSignalFloodingProbability.ToString());
object currentMaximumAllowableFloodingProbability = dataGridView[maximumAllowableFloodingProbabilityColumn, 0].FormattedValue;
Assert.IsNotNull(currentMaximumAllowableFloodingProbability);
string expectedMaximumAllowableFloodingProbability = maximumAllowableFloodingProbability > 0
? ProbabilityFormattingHelper.FormatFromReturnPeriod(maximumAllowableFloodingProbability)
: string.Empty;
Assert.AreEqual(expectedMaximumAllowableFloodingProbability, currentMaximumAllowableFloodingProbability.ToString());
}
}
}
private void SetTextBoxValue(double probability)
{
failureMechanismAssemblyProbabilityTextBox.Text = ProbabilityFormattingHelper.FormatWithDiscreteNumbers(probability);
FailureMechanismAssemblyResult assemblyResult = FailureMechanism.AssemblyResult;
bool hasManualProbability = assemblyResult.IsManualProbability();
if (hasManualProbability && !HasSections())
{
SetErrorMessage(Resources.FailureMechanismResultView_To_Enter_An_AssemblyProbability_Failure_Mechanism_Sections_Must_Be_Imported);
}
else if (hasManualProbability)
{
SetErrorMessage(FailureMechanismAssemblyResultValidationHelper.GetValidationError(assemblyResult));
}
}
public void Data_SetNewHeightStructureInstance_ReturnCorrectPropertyValues()
{
// Setup
var structure = new TestHeightStructure();
var properties = new HeightStructureProperties();
// Call
properties.Data = structure;
// Assert
Assert.AreEqual(structure.Id, properties.Id);
Assert.AreEqual(structure.Name, properties.Name);
Assert.AreEqual(structure.Location, properties.Location);
Assert.AreEqual(structure.StructureNormalOrientation, properties.StructureNormalOrientation);
Assert.AreEqual("Lognormaal", properties.FlowWidthAtBottomProtection.DistributionType);
Assert.AreEqual(structure.FlowWidthAtBottomProtection, properties.FlowWidthAtBottomProtection.Data);
Assert.IsTrue(properties.FlowWidthAtBottomProtection.DynamicReadOnlyValidationMethod("Mean"));
Assert.IsTrue(properties.FlowWidthAtBottomProtection.DynamicReadOnlyValidationMethod("StandardDeviation"));
Assert.AreEqual("Normaal", properties.WidthFlowApertures.DistributionType);
Assert.AreEqual(structure.WidthFlowApertures, properties.WidthFlowApertures.Data);
Assert.IsTrue(properties.WidthFlowApertures.DynamicReadOnlyValidationMethod("Mean"));
Assert.IsTrue(properties.WidthFlowApertures.DynamicReadOnlyValidationMethod("StandardDeviation"));
Assert.AreEqual("Lognormaal", properties.StorageStructureArea.DistributionType);
Assert.AreEqual(structure.StorageStructureArea, properties.StorageStructureArea.Data);
Assert.IsTrue(properties.StorageStructureArea.DynamicReadOnlyValidationMethod("Mean"));
Assert.IsTrue(properties.StorageStructureArea.DynamicReadOnlyValidationMethod("CoefficientOfVariation"));
Assert.AreEqual("Lognormaal", properties.AllowedLevelIncreaseStorage.DistributionType);
Assert.AreEqual(structure.AllowedLevelIncreaseStorage, properties.AllowedLevelIncreaseStorage.Data);
Assert.IsTrue(properties.AllowedLevelIncreaseStorage.DynamicReadOnlyValidationMethod("Mean"));
Assert.IsTrue(properties.AllowedLevelIncreaseStorage.DynamicReadOnlyValidationMethod("StandardDeviation"));
Assert.AreEqual("Normaal", properties.LevelCrestStructure.DistributionType);
Assert.AreEqual(structure.LevelCrestStructure, properties.LevelCrestStructure.Data);
Assert.IsTrue(properties.LevelCrestStructure.DynamicReadOnlyValidationMethod("Mean"));
Assert.IsTrue(properties.LevelCrestStructure.DynamicReadOnlyValidationMethod("StandardDeviation"));
Assert.AreEqual("Lognormaal", properties.CriticalOvertoppingDischarge.DistributionType);
Assert.AreEqual(structure.CriticalOvertoppingDischarge, properties.CriticalOvertoppingDischarge.Data);
Assert.IsTrue(properties.CriticalOvertoppingDischarge.DynamicReadOnlyValidationMethod("Mean"));
Assert.IsTrue(properties.CriticalOvertoppingDischarge.DynamicReadOnlyValidationMethod("CoefficientOfVariation"));
Assert.AreEqual(ProbabilityFormattingHelper.Format(structure.FailureProbabilityStructureWithErosion), properties.FailureProbabilityStructureWithErosion);
}
public void GivenMapLayerWithDuneLocations_WhenNotSelectedTargetProbabilityRemovedAndNotified_ThenMapDataUpdated(string displayName)
{
// Given
var mocks = new MockRepository();
var observer = mocks.StrictMock <IObserver>();
observer.Expect(o => o.UpdateObserver());
mocks.ReplayAll();
var failureMechanism = new DuneErosionFailureMechanism();
failureMechanism.DuneLocationCalculationsForUserDefinedTargetProbabilities.Add(
new DuneLocationCalculationsForTargetProbability(0.1));
failureMechanism.DuneLocationCalculationsForUserDefinedTargetProbabilities.Add(
new DuneLocationCalculationsForTargetProbability(0.001));
failureMechanism.SetDuneLocations(new[]
{
new TestDuneLocation("test1")
});
using (var mapLayer = new DuneErosionLocationsMapLayer(failureMechanism))
{
DuneLocationCalculationsForTargetProbability calculationsForTargetProbabilityToRemove = failureMechanism.DuneLocationCalculationsForUserDefinedTargetProbabilities.First();
DuneLocationCalculationsForTargetProbability calculationsForTargetProbability = failureMechanism.DuneLocationCalculationsForUserDefinedTargetProbabilities.Last();
mapLayer.MapData.SelectedMetaDataAttribute = string.Format(displayName, ProbabilityFormattingHelper.Format(calculationsForTargetProbability.TargetProbability));
mapLayer.MapData.NotifyObservers();
mapLayer.MapData.Attach(observer);
// Precondition
AssertDuneLocationsMapData(failureMechanism, mapLayer.MapData);
// When
failureMechanism.DuneLocationCalculationsForUserDefinedTargetProbabilities.Remove(calculationsForTargetProbabilityToRemove);
failureMechanism.DuneLocationCalculationsForUserDefinedTargetProbabilities.NotifyObservers();
// Then
AssertDuneLocationsMapData(failureMechanism, mapLayer.MapData);
Assert.AreEqual(string.Format(displayName, ProbabilityFormattingHelper.Format(calculationsForTargetProbability.TargetProbability)),
mapLayer.MapData.SelectedMetaDataAttribute);
}
mocks.VerifyAll();
}
public void GetProperties_WithData_ReturnExpectedValues()
{
// Setup
PartialProbabilisticSubMechanismPipingOutput output = PipingTestDataGenerator.GetRandomPartialProbabilisticSubMechanismPipingOutput();
// Call
var properties = new ProbabilisticSubMechanismPipingOutputProperties(output);
// Assert
Assert.AreEqual(ProbabilityFormattingHelper.Format(StatisticsConverter.ReliabilityToProbability(output.Reliability)), properties.Probability);
Assert.AreEqual(output.Reliability, properties.Reliability, properties.Reliability.GetAccuracy());
GeneralResult <TopLevelSubMechanismIllustrationPoint> generalResult = output.GeneralResult;
CollectionAssert.AreEqual(generalResult.Stochasts, properties.AlphaValues);
CollectionAssert.AreEqual(generalResult.Stochasts, properties.Durations);
CollectionAssert.AreEqual(generalResult.TopLevelIllustrationPoints, properties.IllustrationPoints.Select(ip => ip.Data));
Assert.AreEqual(generalResult.GoverningWindDirection.Name, properties.WindDirection);
}
public void GetProperties_WithData_ReturnExpectedValues()
{
// Setup
const double modelFactor = 1.1;
MacroStabilityInwardsOutput output = MacroStabilityInwardsOutputTestFactory.CreateRandomOutput();
// Call
var properties = new MacroStabilityInwardsOutputProperties(output, modelFactor);
// Assert
DerivedMacroStabilityInwardsOutput expectedDerivedOutput = DerivedMacroStabilityInwardsOutputFactory.Create(output, modelFactor);
Assert.AreEqual(expectedDerivedOutput.FactorOfStability, properties.MacroStabilityInwardsFactorOfStability,
properties.MacroStabilityInwardsFactorOfStability.GetAccuracy());
Assert.AreEqual(ProbabilityFormattingHelper.Format(expectedDerivedOutput.MacroStabilityInwardsProbability), properties.MacroStabilityInwardsProbability);
Assert.AreEqual(expectedDerivedOutput.MacroStabilityInwardsReliability, properties.MacroStabilityInwardsReliability, properties.MacroStabilityInwardsReliability.GetAccuracy());
}
public void GivenMapLayerWithHydraulicBoundaryLocationsData_WhenNotSelectedTargetProbabilityRemovedAndNotified_ThenMapDataUpdated(
Func <IAssessmentSection, ObservableList <HydraulicBoundaryLocationCalculationsForTargetProbability> > getTargetProbabilitiesFunc, string displayName)
{
// Given
var mocks = new MockRepository();
var observer = mocks.StrictMock <IObserver>();
observer.Expect(o => o.UpdateObserver());
mocks.ReplayAll();
var hydraulicBoundaryLocation = new HydraulicBoundaryLocation(1, "test1", 1.0, 2.0);
var assessmentSection = new AssessmentSectionStub();
assessmentSection.SetHydraulicBoundaryLocationCalculations(new[]
{
hydraulicBoundaryLocation
});
using (var mapLayer = new HydraulicBoundaryLocationsMapLayer(assessmentSection))
{
ObservableList <HydraulicBoundaryLocationCalculationsForTargetProbability> targetProbabilities = getTargetProbabilitiesFunc(assessmentSection);
HydraulicBoundaryLocationCalculationsForTargetProbability calculationsForTargetProbabilityToRemove = targetProbabilities.First();
HydraulicBoundaryLocationCalculationsForTargetProbability calculationsForTargetProbability = targetProbabilities.Last();
mapLayer.MapData.SelectedMetaDataAttribute = string.Format(displayName, ProbabilityFormattingHelper.Format(calculationsForTargetProbability.TargetProbability));
mapLayer.MapData.NotifyObservers();
mapLayer.MapData.Attach(observer);
// Precondition
MapDataTestHelper.AssertHydraulicBoundaryLocationsMapData(assessmentSection, mapLayer.MapData);
// When
targetProbabilities.Remove(calculationsForTargetProbabilityToRemove);
targetProbabilities.NotifyObservers();
// Then
MapDataTestHelper.AssertHydraulicBoundaryLocationsMapData(assessmentSection, mapLayer.MapData);
Assert.AreEqual(string.Format(displayName, ProbabilityFormattingHelper.Format(calculationsForTargetProbability.TargetProbability)),
mapLayer.MapData.SelectedMetaDataAttribute);
}
mocks.VerifyAll();
}
public void GetProperties_WithData_ReturnExpectedValues()
{
// Setup
var generalResult = new TestGeneralResultFaultTreeIllustrationPoint();
var structuresOutput = new TestStructuresOutput(generalResult);
// Call
var properties = new StructuresOutputProperties(structuresOutput);
// Assert
Assert.AreEqual(generalResult.GoverningWindDirection.Name, properties.WindDirection);
Assert.AreEqual(ProbabilityFormattingHelper.Format(0.5), properties.Probability);
Assert.AreEqual(0, properties.Reliability, properties.Reliability.GetAccuracy());
TestHelper.AssertTypeConverter <StructuresOutputProperties, KeyValueExpandableArrayConverter>(
nameof(StructuresOutputProperties.AlphaValues));
TestHelper.AssertTypeConverter <StructuresOutputProperties, KeyValueExpandableArrayConverter>(
nameof(StructuresOutputProperties.Durations));
int nrOfExpectedStochasts = generalResult.Stochasts.Count();
Assert.AreEqual(nrOfExpectedStochasts, properties.AlphaValues.Length);
Assert.AreEqual(nrOfExpectedStochasts, properties.Durations.Length);
Stochast expectedStochast = generalResult.Stochasts.First();
Assert.AreEqual(expectedStochast.Alpha, properties.AlphaValues[0].Alpha);
Assert.AreEqual(expectedStochast.Duration, properties.Durations[0].Duration);
TestHelper.AssertTypeConverter <StructuresOutputProperties, ExpandableArrayConverter>(
nameof(StructuresOutputProperties.IllustrationPoints));
int nrOfExpectedTopLevelIllustrationPoints = generalResult.TopLevelIllustrationPoints.Count();
Assert.AreEqual(nrOfExpectedTopLevelIllustrationPoints, properties.IllustrationPoints.Length);
CollectionAssert.AreEqual(generalResult.TopLevelIllustrationPoints, properties.IllustrationPoints.Select(i => i.Data));
}
/// <summary>
/// Tries to create the <see cref="AssessmentSection"/>.
/// </summary>
/// <param name="selectedItem">The selected <see cref="ReferenceLineMeta"/>.</param>
/// <param name="maximumAllowableFloodingProbability">The maximum allowable flooding probability of the assessment section.</param>
/// <param name="signalFloodingProbability">The signal flooding probability of the assessment section.</param>
/// <param name="normativeProbabilityType">The normative probability type of the assessment section.</param>
/// <returns>The created <see cref="AssessmentSection"/>.</returns>
/// <exception cref="CriticalFileValidationException">Thrown when:
/// <list type="bullet">
/// <item><paramref name="maximumAllowableFloodingProbability"/> is not in the interval [0.000001, 0.1] or is <see cref="double.NaN"/>;</item>
/// <item><paramref name="signalFloodingProbability"/> is not in the interval [0.000001, 0.1] or is <see cref="double.NaN"/>;</item>
/// <item>The <paramref name="signalFloodingProbability"/> is larger than <paramref name="maximumAllowableFloodingProbability"/>.</item>
/// </list>
/// </exception>
private AssessmentSection TryCreateAssessmentSection(ReferenceLineMeta selectedItem,
double maximumAllowableFloodingProbability,
double signalFloodingProbability,
NormativeProbabilityType normativeProbabilityType)
{
try
{
return(CreateAssessmentSection(selectedItem,
maximumAllowableFloodingProbability,
signalFloodingProbability,
normativeProbabilityType));
}
catch (ArgumentOutOfRangeException exception)
{
var normValidityRange = new Range <double>(1.0 / 1000000, 1.0 / 10);
string message = string.Format(Resources.AssessmentSectionFromFileCommandHandler_Unable_to_create_assessmentSection_with_MaximumAllowableFloodingProbability_0_and_SignalFloodingProbability_1_Probabilities_should_be_in_Range_2_,
ProbabilityFormattingHelper.Format(maximumAllowableFloodingProbability),
ProbabilityFormattingHelper.Format(signalFloodingProbability),
normValidityRange.ToString(FormattableConstants.ShowAtLeastOneDecimal, CultureInfo.CurrentCulture));
throw new CriticalFileValidationException(message, exception);
}
}
