Fisheye: Tag 872302182641ae7c8acfbbdb87554dfe5d8c2a32 refers to a dead (removed) revision in file `Riskeer/Piping/src/Riskeer.Piping.Forms/PropertyClasses/PipingOutputProperties.cs'. Fisheye: No comparison available. Pass `N' to diff? Index: Riskeer/Piping/src/Riskeer.Piping.Forms/PropertyClasses/SemiProbabilisticPipingOutputProperties.cs =================================================================== diff -u --- Riskeer/Piping/src/Riskeer.Piping.Forms/PropertyClasses/SemiProbabilisticPipingOutputProperties.cs (revision 0) +++ Riskeer/Piping/src/Riskeer.Piping.Forms/PropertyClasses/SemiProbabilisticPipingOutputProperties.cs (revision 872302182641ae7c8acfbbdb87554dfe5d8c2a32) @@ -0,0 +1,306 @@ +// Copyright (C) Stichting Deltares 2019. All rights reserved. +// +// This file is part of Riskeer. +// +// Riskeer is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this program. If not, see . +// +// All names, logos, and references to "Deltares" are registered trademarks of +// Stichting Deltares and remain full property of Stichting Deltares at all times. +// All rights reserved. + +using System; +using Core.Common.Base.Data; +using Core.Common.Gui.Attributes; +using Core.Common.Gui.PropertyBag; +using Core.Common.Util.Attributes; +using Riskeer.Common.Data.AssessmentSection; +using Riskeer.Common.Forms.Helpers; +using Riskeer.Piping.Data; +using Riskeer.Piping.Data.SemiProbabilistic; +using Riskeer.Piping.Forms.Properties; + +namespace Riskeer.Piping.Forms.PropertyClasses +{ + /// + /// ViewModel of for properties panel. + /// + public class SemiProbabilisticPipingOutputProperties : ObjectProperties + { + private DerivedSemiProbabilisticPipingOutput derivedOutput; + + /// + /// Creates a new instance of . + /// + /// The output to show the properties for. + /// The failure mechanism the output belongs to. + /// The assessment section the output belongs to. + /// Thrown when any parameter + /// is null. + public SemiProbabilisticPipingOutputProperties(SemiProbabilisticPipingOutput output, PipingFailureMechanism failureMechanism, IAssessmentSection assessmentSection) + { + if (output == null) + { + throw new ArgumentNullException(nameof(output)); + } + + if (failureMechanism == null) + { + throw new ArgumentNullException(nameof(failureMechanism)); + } + + if (assessmentSection == null) + { + throw new ArgumentNullException(nameof(assessmentSection)); + } + + Data = output; + + CreateDerivedOutput(output, failureMechanism, assessmentSection); + } + + [ResourcesCategory(typeof(Resources), nameof(Resources.Categories_Uplift), 1, 4)] + [ResourcesDisplayName(typeof(Resources), nameof(Resources.PipingOutput_UpliftEffectiveStress_DisplayName))] + [ResourcesDescription(typeof(Resources), nameof(Resources.PipingOutput_UpliftEffectiveStress_Description))] + [PropertyOrder(1)] + public RoundedDouble UpliftEffectiveStress + { + get + { + return data.UpliftEffectiveStress; + } + } + + [ResourcesCategory(typeof(Resources), nameof(Resources.Categories_Uplift), 1, 4)] + [ResourcesDisplayName(typeof(Resources), nameof(Resources.PipingOutput_UpliftFactorOfSafety_DisplayName))] + [ResourcesDescription(typeof(Resources), nameof(Resources.PipingOutput_UpliftFactorOfSafety_Description))] + [PropertyOrder(2)] + public RoundedDouble UpliftFactorOfSafety + { + get + { + return derivedOutput.UpliftFactorOfSafety; + } + } + + [ResourcesCategory(typeof(Resources), nameof(Resources.Categories_Uplift), 1, 4)] + [ResourcesDisplayName(typeof(Resources), nameof(Resources.PipingOutput_UpliftReliability_DisplayName))] + [ResourcesDescription(typeof(Resources), nameof(Resources.PipingOutput_UpliftReliability_Description))] + [PropertyOrder(3)] + public RoundedDouble UpliftReliability + { + get + { + return derivedOutput.UpliftReliability; + } + } + + [ResourcesCategory(typeof(Resources), nameof(Resources.Categories_Uplift), 1, 4)] + [ResourcesDisplayName(typeof(Resources), nameof(Resources.PipingOutput_UpliftProbability_DisplayName))] + [ResourcesDescription(typeof(Resources), nameof(Resources.PipingOutput_UpliftProbability_Description))] + [PropertyOrder(4)] + public string UpliftProbability + { + get + { + return ProbabilityFormattingHelper.Format(derivedOutput.UpliftProbability); + } + } + + [ResourcesCategory(typeof(Resources), nameof(Resources.Categories_Heave), 2, 4)] + [ResourcesDisplayName(typeof(Resources), nameof(Resources.PipingOutput_HeaveGradient_DisplayName))] + [ResourcesDescription(typeof(Resources), nameof(Resources.PipingOutput_HeaveGradient_Description))] + [PropertyOrder(11)] + public RoundedDouble HeaveGradient + { + get + { + return data.HeaveGradient; + } + } + + [ResourcesCategory(typeof(Resources), nameof(Resources.Categories_Heave), 2, 4)] + [ResourcesDisplayName(typeof(Resources), nameof(Resources.PipingOutput_HeaveFactorOfSafety_DisplayName))] + [ResourcesDescription(typeof(Resources), nameof(Resources.PipingOutput_HeaveFactorOfSafety_Description))] + [PropertyOrder(12)] + public RoundedDouble HeaveFactorOfSafety + { + get + { + return derivedOutput.HeaveFactorOfSafety; + } + } + + [ResourcesCategory(typeof(Resources), nameof(Resources.Categories_Heave), 2, 4)] + [ResourcesDisplayName(typeof(Resources), nameof(Resources.PipingOutput_HeaveReliability_DisplayName))] + [ResourcesDescription(typeof(Resources), nameof(Resources.PipingOutput_HeaveReliability_Description))] + [PropertyOrder(13)] + public RoundedDouble HeaveReliability + { + get + { + return derivedOutput.HeaveReliability; + } + } + + [ResourcesCategory(typeof(Resources), nameof(Resources.Categories_Heave), 2, 4)] + [ResourcesDisplayName(typeof(Resources), nameof(Resources.PipingOutput_HeaveProbability_DisplayName))] + [ResourcesDescription(typeof(Resources), nameof(Resources.PipingOutput_HeaveProbability_Description))] + [PropertyOrder(14)] + public string HeaveProbability + { + get + { + return ProbabilityFormattingHelper.Format(derivedOutput.HeaveProbability); + } + } + + [ResourcesCategory(typeof(Resources), nameof(Resources.Categories_Sellmeijer), 3, 4)] + [ResourcesDisplayName(typeof(Resources), nameof(Resources.PipingOutput_SellmeijerCreepCoefficient_DisplayName))] + [ResourcesDescription(typeof(Resources), nameof(Resources.PipingOutput_SellmeijerCreepCoefficient_Description))] + [PropertyOrder(21)] + public RoundedDouble SellmeijerCreepCoefficient + { + get + { + return data.SellmeijerCreepCoefficient; + } + } + + [ResourcesCategory(typeof(Resources), nameof(Resources.Categories_Sellmeijer), 3, 4)] + [ResourcesDisplayName(typeof(Resources), nameof(Resources.PipingOutput_SellmeijerCriticalFall_DisplayName))] + [ResourcesDescription(typeof(Resources), nameof(Resources.PipingOutput_SellmeijerCriticalFall_Description))] + [PropertyOrder(22)] + public RoundedDouble SellmeijerCriticalFall + { + get + { + return data.SellmeijerCriticalFall; + } + } + + [ResourcesCategory(typeof(Resources), nameof(Resources.Categories_Sellmeijer), 3, 4)] + [ResourcesDisplayName(typeof(Resources), nameof(Resources.PipingOutput_SellmeijerReducedFall_DisplayName))] + [ResourcesDescription(typeof(Resources), nameof(Resources.PipingOutput_SellmeijerReducedFall_Description))] + [PropertyOrder(23)] + public RoundedDouble SellmeijerReducedFall + { + get + { + return data.SellmeijerReducedFall; + } + } + + [ResourcesCategory(typeof(Resources), nameof(Resources.Categories_Sellmeijer), 3, 4)] + [ResourcesDisplayName(typeof(Resources), nameof(Resources.PipingOutput_SellmeijerFactorOfSafety_DisplayName))] + [ResourcesDescription(typeof(Resources), nameof(Resources.PipingOutput_SellmeijerFactorOfSafety_Description))] + [PropertyOrder(24)] + public RoundedDouble SellmeijerFactorOfSafety + { + get + { + return derivedOutput.SellmeijerFactorOfSafety; + } + } + + [ResourcesCategory(typeof(Resources), nameof(Resources.Categories_Sellmeijer), 3, 4)] + [ResourcesDisplayName(typeof(Resources), nameof(Resources.PipingOutput_SellmeijerReliability_DisplayName))] + [ResourcesDescription(typeof(Resources), nameof(Resources.PipingOutput_SellmeijerReliability_Description))] + [PropertyOrder(25)] + public RoundedDouble SellmeijerReliability + { + get + { + return derivedOutput.SellmeijerReliability; + } + } + + [ResourcesCategory(typeof(Resources), nameof(Resources.Categories_Sellmeijer), 3, 4)] + [ResourcesDisplayName(typeof(Resources), nameof(Resources.PipingOutput_SellmeijerProbability_DisplayName))] + [ResourcesDescription(typeof(Resources), nameof(Resources.PipingOutput_SellmeijerProbability_Description))] + [PropertyOrder(26)] + public string SellmeijerProbability + { + get + { + return ProbabilityFormattingHelper.Format(derivedOutput.SellmeijerProbability); + } + } + + [ResourcesCategory(typeof(Resources), nameof(Resources.Categories_Piping), 4, 4)] + [ResourcesDisplayName(typeof(Resources), nameof(Resources.PipingOutput_RequiredProbability_DisplayName))] + [ResourcesDescription(typeof(Resources), nameof(Resources.PipingOutput_RequiredProbability_Description))] + [PropertyOrder(31)] + public string RequiredProbability + { + get + { + return ProbabilityFormattingHelper.Format(derivedOutput.RequiredProbability); + } + } + + [ResourcesCategory(typeof(Resources), nameof(Resources.Categories_Piping), 4, 4)] + [ResourcesDisplayName(typeof(Resources), nameof(Resources.PipingOutput_RequiredReliability_DisplayName))] + [ResourcesDescription(typeof(Resources), nameof(Resources.PipingOutput_RequiredReliability_Description))] + [PropertyOrder(32)] + public RoundedDouble RequiredReliability + { + get + { + return derivedOutput.RequiredReliability; + } + } + + [ResourcesCategory(typeof(Resources), nameof(Resources.Categories_Piping), 4, 4)] + [ResourcesDisplayName(typeof(Resources), nameof(Resources.PipingOutput_PipingProbability_DisplayName))] + [ResourcesDescription(typeof(Resources), nameof(Resources.PipingOutput_PipingProbability_Description))] + [PropertyOrder(33)] + public string PipingProbability + { + get + { + return ProbabilityFormattingHelper.Format(derivedOutput.PipingProbability); + } + } + + [ResourcesCategory(typeof(Resources), nameof(Resources.Categories_Piping), 4, 4)] + [ResourcesDisplayName(typeof(Resources), nameof(Resources.PipingOutput_PipingReliability_DisplayName))] + [ResourcesDescription(typeof(Resources), nameof(Resources.PipingOutput_PipingReliability_Description))] + [PropertyOrder(34)] + public RoundedDouble PipingReliability + { + get + { + return derivedOutput.PipingReliability; + } + } + + [ResourcesCategory(typeof(Resources), nameof(Resources.Categories_Piping), 4, 4)] + [ResourcesDisplayName(typeof(Resources), nameof(Resources.PipingOutput_PipingFactorOfSafety_DisplayName))] + [ResourcesDescription(typeof(Resources), nameof(Resources.PipingOutput_PipingFactorOfSafety_Description))] + [PropertyOrder(35)] + public RoundedDouble PipingFactorOfSafety + { + get + { + return derivedOutput.PipingFactorOfSafety; + } + } + + private void CreateDerivedOutput(SemiProbabilisticPipingOutput output, PipingFailureMechanism failureMechanism, + IAssessmentSection assessmentSection) + { + derivedOutput = DerivedSemiProbabilisticPipingOutputFactory.Create(output, failureMechanism, assessmentSection); + } + } +} \ No newline at end of file Index: Riskeer/Piping/src/Riskeer.Piping.Plugin/PipingPlugin.cs =================================================================== diff -u -rd9aa4d20777db5bdadc8330ea5d26f47c4f32c1c -r872302182641ae7c8acfbbdb87554dfe5d8c2a32 --- Riskeer/Piping/src/Riskeer.Piping.Plugin/PipingPlugin.cs (.../PipingPlugin.cs) (revision d9aa4d20777db5bdadc8330ea5d26f47c4f32c1c) +++ Riskeer/Piping/src/Riskeer.Piping.Plugin/PipingPlugin.cs (.../PipingPlugin.cs) (revision 872302182641ae7c8acfbbdb87554dfe5d8c2a32) @@ -90,9 +90,9 @@ () => GetNormativeAssessmentLevel(context.AssessmentSection, context.PipingCalculation), new ObservablePropertyChangeHandler(context.PipingCalculation, context.WrappedData)) }; - yield return new PropertyInfo + yield return new PropertyInfo { - CreateInstance = context => new PipingOutputProperties(context.WrappedData, context.FailureMechanism, context.AssessmentSection) + CreateInstance = context => new SemiProbabilisticPipingOutputProperties(context.WrappedData, context.FailureMechanism, context.AssessmentSection) }; yield return new PropertyInfo { Fisheye: Tag 872302182641ae7c8acfbbdb87554dfe5d8c2a32 refers to a dead (removed) revision in file `Riskeer/Piping/test/Riskeer.Piping.Forms.Test/PropertyClasses/PipingOutputPropertiesTest.cs'. Fisheye: No comparison available. Pass `N' to diff? Index: Riskeer/Piping/test/Riskeer.Piping.Forms.Test/PropertyClasses/SemiProbabilisticPipingOutputPropertiesTest.cs =================================================================== diff -u --- Riskeer/Piping/test/Riskeer.Piping.Forms.Test/PropertyClasses/SemiProbabilisticPipingOutputPropertiesTest.cs (revision 0) +++ Riskeer/Piping/test/Riskeer.Piping.Forms.Test/PropertyClasses/SemiProbabilisticPipingOutputPropertiesTest.cs (revision 872302182641ae7c8acfbbdb87554dfe5d8c2a32) @@ -0,0 +1,324 @@ +// Copyright (C) Stichting Deltares 2019. All rights reserved. +// +// This file is part of Riskeer. +// +// Riskeer is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this program. If not, see . +// +// All names, logos, and references to "Deltares" are registered trademarks of +// Stichting Deltares and remain full property of Stichting Deltares at all times. +// All rights reserved. + +using System; +using System.ComponentModel; +using Core.Common.Gui.PropertyBag; +using Core.Common.TestUtil; +using NUnit.Framework; +using Rhino.Mocks; +using Riskeer.Common.Data.AssessmentSection; +using Riskeer.Common.Data.TestUtil; +using Riskeer.Common.Forms.Helpers; +using Riskeer.Piping.Data; +using Riskeer.Piping.Data.SemiProbabilistic; +using Riskeer.Piping.Data.TestUtil; +using Riskeer.Piping.Forms.PropertyClasses; + +namespace Riskeer.Piping.Forms.Test.PropertyClasses +{ + [TestFixture] + public class SemiProbabilisticPipingOutputPropertiesTest + { + [Test] + public void Constructor_OutputNull_ThrowsArgumentNullException() + { + // Setup + var mocks = new MockRepository(); + var assessmentSection = mocks.Stub(); + mocks.ReplayAll(); + + // Call + TestDelegate test = () => new SemiProbabilisticPipingOutputProperties(null, new PipingFailureMechanism(), assessmentSection); + + // Assert + string paramName = Assert.Throws(test).ParamName; + Assert.AreEqual("output", paramName); + mocks.VerifyAll(); + } + + [Test] + public void Constructor_FailureMechanismNull_ThrowsArgumentNullException() + { + // Setup + var mocks = new MockRepository(); + var assessmentSection = mocks.Stub(); + mocks.ReplayAll(); + + // Call + TestDelegate test = () => new SemiProbabilisticPipingOutputProperties(PipingOutputTestFactory.Create(), null, assessmentSection); + + // Assert + string paramName = Assert.Throws(test).ParamName; + Assert.AreEqual("failureMechanism", paramName); + mocks.VerifyAll(); + } + + [Test] + public void Constructor_AssessmentSectionNull_ThrowsArgumentNullException() + { + // Call + TestDelegate call = () => new SemiProbabilisticPipingOutputProperties(PipingOutputTestFactory.Create(), new PipingFailureMechanism(), null); + + // Assert + var exception = Assert.Throws(call); + Assert.AreEqual("assessmentSection", exception.ParamName); + } + + [Test] + public void Constructor_ExpectedValues() + { + // Setup + var failureMechanism = new PipingFailureMechanism(); + + var mocks = new MockRepository(); + IAssessmentSection assessmentSection = AssessmentSectionTestHelper.CreateAssessmentSectionStub(failureMechanism, mocks); + mocks.ReplayAll(); + + SemiProbabilisticPipingOutput output = PipingOutputTestFactory.Create(); + + // Call + var properties = new SemiProbabilisticPipingOutputProperties(output, failureMechanism, assessmentSection); + + // Assert + Assert.IsInstanceOf>(properties); + Assert.AreSame(output, properties.Data); + mocks.VerifyAll(); + } + + [Test] + public void GetProperties_WithData_ReturnExpectedValues() + { + // Setup + var failureMechanism = new PipingFailureMechanism(); + + var mocks = new MockRepository(); + IAssessmentSection assessmentSection = AssessmentSectionTestHelper.CreateAssessmentSectionStub(failureMechanism, mocks); + mocks.ReplayAll(); + + 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, failureMechanism, assessmentSection); + + // Assert + DerivedSemiProbabilisticPipingOutput expectedDerivedOutput = DerivedSemiProbabilisticPipingOutputFactory.Create(output, failureMechanism, assessmentSection); + 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.RequiredProbability), properties.RequiredProbability); + Assert.AreEqual(expectedDerivedOutput.RequiredReliability, properties.RequiredReliability, properties.RequiredReliability.GetAccuracy()); + Assert.AreEqual(ProbabilityFormattingHelper.Format(expectedDerivedOutput.PipingProbability), properties.PipingProbability); + Assert.AreEqual(expectedDerivedOutput.PipingReliability, properties.PipingReliability, properties.PipingReliability.GetAccuracy()); + Assert.AreEqual(expectedDerivedOutput.PipingFactorOfSafety, properties.PipingFactorOfSafety, properties.PipingFactorOfSafety.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()); + mocks.VerifyAll(); + } + + [Test] + public void Constructor_Always_PropertiesHaveExpectedAttributesValues() + { + // Setup + var failureMechanism = new PipingFailureMechanism(); + + var mocks = new MockRepository(); + IAssessmentSection assessmentSection = AssessmentSectionTestHelper.CreateAssessmentSectionStub(failureMechanism, mocks); + mocks.ReplayAll(); + + // Call + var properties = new SemiProbabilisticPipingOutputProperties(PipingOutputTestFactory.Create(), failureMechanism, assessmentSection); + + // Assert + PropertyDescriptorCollection dynamicProperties = PropertiesTestHelper.GetAllVisiblePropertyDescriptors(properties); + Assert.AreEqual(19, dynamicProperties.Count); + + const string heaveCategory = "\t\tHeave"; + const string upliftCategory = "\t\t\tOpbarsten"; + const string sellmeijerCategory = "\tTerugschrijdende erosie (Sellmeijer)"; + const string pipingCategory = "Piping"; + + PropertyDescriptor upliftEffectiveStress = dynamicProperties[0]; + PropertiesTestHelper.AssertRequiredPropertyDescriptorProperties(upliftEffectiveStress, + upliftCategory, + "Gewicht van de deklaag [kN/m²]", + "Het effectieve gewicht van de deklaag.", + true); + + PropertyDescriptor upliftFactorOfSafetyProperty = dynamicProperties[1]; + PropertiesTestHelper.AssertRequiredPropertyDescriptorProperties(upliftFactorOfSafetyProperty, + upliftCategory, + "Veiligheidsfactor [-]", + "De veiligheidsfactor voor het submechanisme opbarsten voor deze berekening.", + true); + + PropertyDescriptor upliftReliabilityProperty = dynamicProperties[2]; + PropertiesTestHelper.AssertRequiredPropertyDescriptorProperties(upliftReliabilityProperty, + upliftCategory, + "Betrouwbaarheidsindex [-]", + "De betrouwbaarheidsindex voor het submechanisme opbarsten voor deze berekening.", + true); + + PropertyDescriptor upliftProbabilityProperty = dynamicProperties[3]; + PropertiesTestHelper.AssertRequiredPropertyDescriptorProperties(upliftProbabilityProperty, + upliftCategory, + "Kans van voorkomen [1/jaar]", + "De kans dat het submechanisme opbarsten optreedt voor deze berekening.", + true); + + PropertyDescriptor heaveGradientProperty = dynamicProperties[4]; + PropertiesTestHelper.AssertRequiredPropertyDescriptorProperties(heaveGradientProperty, + heaveCategory, + "Heave gradiënt [-]", + "De optredende verticale gradiënt in het opbarstkanaal.", + true); + + PropertyDescriptor heaveFactorOfSafetyProperty = dynamicProperties[5]; + PropertiesTestHelper.AssertRequiredPropertyDescriptorProperties(heaveFactorOfSafetyProperty, + heaveCategory, + "Veiligheidsfactor [-]", + "De veiligheidsfactor voor het submechanisme heave voor deze berekening.", + true); + + PropertyDescriptor heaveReliabilityProperty = dynamicProperties[6]; + PropertiesTestHelper.AssertRequiredPropertyDescriptorProperties(heaveReliabilityProperty, + heaveCategory, + "Betrouwbaarheidsindex [-]", + "De betrouwbaarheidsindex voor het submechanisme heave voor deze berekening.", + true); + + PropertyDescriptor heaveProbabilityProperty = dynamicProperties[7]; + PropertiesTestHelper.AssertRequiredPropertyDescriptorProperties(heaveProbabilityProperty, + heaveCategory, + "Kans van voorkomen [1/jaar]", + "De kans dat het submechanisme heave optreedt voor deze berekening.", + true); + + PropertyDescriptor sellmeijerCreepCoefficientProperty = dynamicProperties[8]; + PropertiesTestHelper.AssertRequiredPropertyDescriptorProperties(sellmeijerCreepCoefficientProperty, + sellmeijerCategory, + "Creep coëfficiënt [-]", + "De verhouding tussen de kwelweglengte en het berekende kritieke verval op basis van de regel van Sellmeijer (analoog aan de vuistregel van Bligh).", + true); + + PropertyDescriptor sellmeijerCriticalFallProperty = dynamicProperties[9]; + PropertiesTestHelper.AssertRequiredPropertyDescriptorProperties(sellmeijerCriticalFallProperty, + sellmeijerCategory, + "Kritiek verval [m]", + "Het kritieke verval over de waterkering.", + true); + + PropertyDescriptor sellmeijerReducedFallProperty = dynamicProperties[10]; + PropertiesTestHelper.AssertRequiredPropertyDescriptorProperties(sellmeijerReducedFallProperty, + sellmeijerCategory, + "Gereduceerd verval [m]", + "Het verschil tussen de buitenwaterstand en de binnenwaterstand, gecorrigeerd voor de drukval in het opbarstkanaal.", + true); + + PropertyDescriptor sellmeijerFactorOfSafetyProperty = dynamicProperties[11]; + PropertiesTestHelper.AssertRequiredPropertyDescriptorProperties(sellmeijerFactorOfSafetyProperty, + sellmeijerCategory, + "Veiligheidsfactor [-]", + "De veiligheidsfactor voor het submechanisme terugschrijdende erosie (Sellmeijer) voor deze berekening.", + true); + + PropertyDescriptor sellmeijerReliabilityProperty = dynamicProperties[12]; + PropertiesTestHelper.AssertRequiredPropertyDescriptorProperties(sellmeijerReliabilityProperty, + sellmeijerCategory, + "Betrouwbaarheidsindex [-]", + "De betrouwbaarheidsindex voor het submechanisme terugschrijdende erosie (Sellmeijer) voor deze berekening.", + true); + + PropertyDescriptor sellmeijerProbabilityProperty = dynamicProperties[13]; + PropertiesTestHelper.AssertRequiredPropertyDescriptorProperties(sellmeijerProbabilityProperty, + sellmeijerCategory, + "Kans van voorkomen [1/jaar]", + "De kans dat het submechanisme terugschrijdende erosie (Sellmeijer) optreedt voor deze berekening.", + true); + + PropertyDescriptor requiredProbabilityProperty = dynamicProperties[14]; + PropertiesTestHelper.AssertRequiredPropertyDescriptorProperties(requiredProbabilityProperty, + pipingCategory, + "Faalkanseis [1/jaar]", + "De maximaal toegestane kans dat het toetsspoor piping optreedt.", + true); + + PropertyDescriptor requiredReliabilityProperty = dynamicProperties[15]; + PropertiesTestHelper.AssertRequiredPropertyDescriptorProperties(requiredReliabilityProperty, + pipingCategory, + "Betrouwbaarheidsindex faalkanseis [-]", + "De betrouwbaarheidsindex van de faalkanseis voor het toetsspoor piping.", + true); + + PropertyDescriptor pipingProbabilityProperty = dynamicProperties[16]; + PropertiesTestHelper.AssertRequiredPropertyDescriptorProperties(pipingProbabilityProperty, + pipingCategory, + "Benaderde faalkans [1/jaar]", + "De benaderde kans dat het toetsspoor piping optreedt voor deze berekening.", + true); + + PropertyDescriptor pipingReliabilityProperty = dynamicProperties[17]; + PropertiesTestHelper.AssertRequiredPropertyDescriptorProperties(pipingReliabilityProperty, + pipingCategory, + "Betrouwbaarheidsindex faalkans [-]", + "De betrouwbaarheidsindex van de faalkans voor deze berekening.", + true); + + PropertyDescriptor pipingFactorOfSafetyProperty = dynamicProperties[18]; + PropertiesTestHelper.AssertRequiredPropertyDescriptorProperties(pipingFactorOfSafetyProperty, + pipingCategory, + "Veiligheidsfactor [-]", + "De veiligheidsfactor voor deze berekening.", + true); + mocks.VerifyAll(); + } + } +} \ No newline at end of file Index: Riskeer/Piping/test/Riskeer.Piping.Plugin.Test/PipingPluginTest.cs =================================================================== diff -u -rd9aa4d20777db5bdadc8330ea5d26f47c4f32c1c -r872302182641ae7c8acfbbdb87554dfe5d8c2a32 --- Riskeer/Piping/test/Riskeer.Piping.Plugin.Test/PipingPluginTest.cs (.../PipingPluginTest.cs) (revision d9aa4d20777db5bdadc8330ea5d26f47c4f32c1c) +++ Riskeer/Piping/test/Riskeer.Piping.Plugin.Test/PipingPluginTest.cs (.../PipingPluginTest.cs) (revision 872302182641ae7c8acfbbdb87554dfe5d8c2a32) @@ -88,7 +88,7 @@ PluginTestHelper.AssertPropertyInfoDefined( propertyInfos, typeof(SemiProbabilisticPipingOutputContext), - typeof(PipingOutputProperties)); + typeof(SemiProbabilisticPipingOutputProperties)); PluginTestHelper.AssertPropertyInfoDefined( propertyInfos, Index: Riskeer/Piping/test/Riskeer.Piping.Plugin.Test/PropertyInfos/PipingOutputPropertyInfoTest.cs =================================================================== diff -u -r4de992e770b6741a2480d50042c76d0ce07ceee8 -r872302182641ae7c8acfbbdb87554dfe5d8c2a32 --- Riskeer/Piping/test/Riskeer.Piping.Plugin.Test/PropertyInfos/PipingOutputPropertyInfoTest.cs (.../PipingOutputPropertyInfoTest.cs) (revision 4de992e770b6741a2480d50042c76d0ce07ceee8) +++ Riskeer/Piping/test/Riskeer.Piping.Plugin.Test/PropertyInfos/PipingOutputPropertyInfoTest.cs (.../PipingOutputPropertyInfoTest.cs) (revision 872302182641ae7c8acfbbdb87554dfe5d8c2a32) @@ -45,7 +45,7 @@ public void SetUp() { plugin = new PipingPlugin(); - info = plugin.GetPropertyInfos().First(tni => tni.PropertyObjectType == typeof(PipingOutputProperties)); + info = plugin.GetPropertyInfos().First(tni => tni.PropertyObjectType == typeof(SemiProbabilisticPipingOutputProperties)); } [TearDown] @@ -78,7 +78,7 @@ IObjectProperties objectProperties = info.CreateInstance(context); // Assert - Assert.IsInstanceOf(objectProperties); + Assert.IsInstanceOf(objectProperties); Assert.AreSame(output, objectProperties.Data); mocks.VerifyAll(); }