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); } }