public void Read_EntityWithOutput_ReturnsCalculationScenarioWithOutput()
{
// Setup
var random = new Random(31);
var tangentLines = new RoundedDouble[0];
var slices = new MacroStabilityInwardsSlice[0];
var calculationOutputEntity = new MacroStabilityInwardsCalculationOutputEntity
{
SlipPlaneTangentLinesXml = new TangentLineCollectionXmlSerializer().ToXml(tangentLines),
SlidingCurveSliceXML = new MacroStabilityInwardsSliceCollectionXmlSerializer().ToXml(slices),
SlipPlaneLeftGridNrOfHorizontalPoints = random.Next(1, 100),
SlipPlaneLeftGridNrOfVerticalPoints = random.Next(1, 100),
SlipPlaneRightGridNrOfHorizontalPoints = random.Next(1, 100),
SlipPlaneRightGridNrOfVerticalPoints = random.Next(1, 100)
};
MacroStabilityInwardsCalculationEntity entity = CreateValidCalculationEntity();
entity.MacroStabilityInwardsCalculationOutputEntities.Add(calculationOutputEntity);
var collector = new ReadConversionCollector();
// Call
MacroStabilityInwardsCalculationScenario calculation = entity.Read(collector);
// Assert
MacroStabilityInwardsOutput output = calculation.Output;
Assert.IsNotNull(output);
MacroStabilityInwardsCalculationOutputEntityTestHelper.AssertOutputPropertyValues(output, calculationOutputEntity);
}
public void Clone_Always_ReturnNewInstanceWithCopiedValues()
{
// Setup
var random = new Random(21);
var slidingCurve = new MacroStabilityInwardsSlidingCurve(MacroStabilityInwardsSlidingCircleTestFactory.Create(),
MacroStabilityInwardsSlidingCircleTestFactory.Create(),
new[]
{
MacroStabilityInwardsSliceTestFactory.CreateSlice()
},
random.NextDouble(),
random.NextDouble());
var slipPlane = new MacroStabilityInwardsSlipPlaneUpliftVan(MacroStabilityInwardsGridTestFactory.Create(),
MacroStabilityInwardsGridTestFactory.Create(),
new[]
{
random.NextRoundedDouble()
});
var properties = new MacroStabilityInwardsOutput.ConstructionProperties
{
FactorOfStability = random.NextDouble(),
ForbiddenZonesXEntryMin = random.NextDouble(),
ForbiddenZonesXEntryMax = random.NextDouble()
};
var original = new MacroStabilityInwardsOutput(slidingCurve, slipPlane, properties);
// Call
object clone = original.Clone();
// Assert
CoreCloneAssert.AreObjectClones(original, clone, MacroStabilityInwardsCloneAssert.AreClones);
}
public void GivenViewWithOutputSet_WhenOutputUpdated_ThenTableUpdated()
{
// Given
MacroStabilityInwardsOutput outputWithoutSlices = MacroStabilityInwardsOutputTestFactory.CreateOutputWithoutSlices();
var calculation = new MacroStabilityInwardsCalculationScenario
{
Output = outputWithoutSlices
};
using (var view = new MacroStabilityInwardsOutputView(calculation,
new GeneralMacroStabilityInwardsInput(),
AssessmentSectionTestHelper.GetTestAssessmentLevel))
{
MacroStabilityInwardsSlicesTable slicesTable = GetSlicesTable(view);
// Precondition
Assert.AreEqual(0, slicesTable.Rows.Count);
// When
calculation.Output = MacroStabilityInwardsOutputTestFactory.CreateOutput();
calculation.NotifyObservers();
// Then
Assert.AreEqual(3, slicesTable.Rows.Count);
}
}
private static void AddEntityForMacroStabilityInwardsOutput(MacroStabilityInwardsCalculationEntity entity,
MacroStabilityInwardsOutput output)
{
if (output != null)
{
entity.MacroStabilityInwardsCalculationOutputEntities.Add(output.Create());
}
}
public void Read_EntityWithValues_ReturnExpectedOutput()
{
// Setup
var random = new Random(21);
IEnumerable <MacroStabilityInwardsSlice> slices = new[]
{
MacroStabilityInwardsSliceTestFactory.CreateSlice()
};
IEnumerable <RoundedDouble> tangentLines = new[]
{
new RoundedDouble(2, random.NextDouble())
};
var entity = new MacroStabilityInwardsCalculationOutputEntity
{
FactorOfStability = random.NextDouble(),
ForbiddenZonesXEntryMin = random.NextDouble(),
ForbiddenZonesXEntryMax = random.NextDouble(),
SlidingCurveSliceXML = new MacroStabilityInwardsSliceCollectionXmlSerializer().ToXml(slices),
SlidingCurveNonIteratedHorizontalForce = random.NextDouble(),
SlidingCurveIteratedHorizontalForce = random.NextDouble(),
SlidingCurveLeftSlidingCircleCenterX = random.NextDouble(),
SlidingCurveLeftSlidingCircleCenterY = random.NextDouble(),
SlidingCurveLeftSlidingCircleRadius = random.NextDouble(),
SlidingCurveLeftSlidingCircleIsActive = Convert.ToByte(random.NextBoolean()),
SlidingCurveLeftSlidingCircleNonIteratedForce = random.NextDouble(),
SlidingCurveLeftSlidingCircleIteratedForce = random.NextDouble(),
SlidingCurveLeftSlidingCircleDrivingMoment = random.NextDouble(),
SlidingCurveLeftSlidingCircleResistingMoment = random.NextDouble(),
SlidingCurveRightSlidingCircleCenterX = random.NextDouble(),
SlidingCurveRightSlidingCircleCenterY = random.NextDouble(),
SlidingCurveRightSlidingCircleRadius = random.NextDouble(),
SlidingCurveRightSlidingCircleIsActive = Convert.ToByte(random.NextBoolean()),
SlidingCurveRightSlidingCircleNonIteratedForce = random.NextDouble(),
SlidingCurveRightSlidingCircleIteratedForce = random.NextDouble(),
SlidingCurveRightSlidingCircleDrivingMoment = random.NextDouble(),
SlidingCurveRightSlidingCircleResistingMoment = random.NextDouble(),
SlipPlaneTangentLinesXml = new TangentLineCollectionXmlSerializer().ToXml(tangentLines),
SlipPlaneLeftGridXLeft = random.NextDouble(0.0, 1.0),
SlipPlaneLeftGridXRight = random.NextDouble(2.0, 3.0),
SlipPlaneLeftGridNrOfHorizontalPoints = random.Next(1, 100),
SlipPlaneLeftGridZTop = random.NextDouble(2.0, 3.0),
SlipPlaneLeftGridZBottom = random.NextDouble(0.0, 1.0),
SlipPlaneLeftGridNrOfVerticalPoints = random.Next(1, 100),
SlipPlaneRightGridXLeft = random.NextDouble(0.0, 1.0),
SlipPlaneRightGridXRight = random.NextDouble(2.0, 3.0),
SlipPlaneRightGridNrOfHorizontalPoints = random.Next(1, 100),
SlipPlaneRightGridZTop = random.NextDouble(2.0, 3.0),
SlipPlaneRightGridZBottom = random.NextDouble(0.0, 1.0),
SlipPlaneRightGridNrOfVerticalPoints = random.Next(1, 100)
};
// Call
MacroStabilityInwardsOutput output = entity.Read();
// Assert
MacroStabilityInwardsCalculationOutputEntityTestHelper.AssertOutputPropertyValues(output, entity);
}
private static void AssertPropertyChangeWithOrWithoutCalculationOutput(
Action <MacroStabilityInwardsCalculationRow> setProperty,
Action <MacroStabilityInwardsCalculationScenario> assertions,
bool hasOutput,
bool expectUpdates)
{
// Setup
var mockRepository = new MockRepository();
var inputObserver = mockRepository.StrictMock <IObserver>();
if (expectUpdates)
{
inputObserver.Expect(o => o.UpdateObserver());
}
var calculationObserver = mockRepository.StrictMock <IObserver>();
if (expectUpdates && hasOutput)
{
calculationObserver.Expect(o => o.UpdateObserver());
}
var handler = mockRepository.Stub <IObservablePropertyChangeHandler>();
mockRepository.ReplayAll();
MacroStabilityInwardsOutput assignedOutput = null;
MacroStabilityInwardsCalculationScenario calculation = MacroStabilityInwardsCalculationScenarioTestFactory.CreateMacroStabilityInwardsCalculationScenarioWithValidInput(new TestHydraulicBoundaryLocation());
if (hasOutput)
{
assignedOutput = MacroStabilityInwardsOutputTestFactory.CreateOutput();
}
calculation.Output = assignedOutput;
var row = new MacroStabilityInwardsCalculationRow(calculation, handler);
calculation.Attach(calculationObserver);
calculation.InputParameters.Attach(inputObserver);
// Call
setProperty(row);
// Assert
assertions(calculation);
if (expectUpdates)
{
Assert.IsNull(calculation.Output);
}
else
{
Assert.AreSame(assignedOutput, calculation.Output);
}
mockRepository.VerifyAll();
}
/// <summary>
/// Method that asserts whether <paramref name="original"/> and <paramref name="clone"/>
/// are clones.
/// </summary>
/// <param name="original">The original object.</param>
/// <param name="clone">The cloned object.</param>
/// <exception cref="AssertionException">Thrown when <paramref name="original"/> and
/// <paramref name="clone"/> are not clones.</exception>
public static void AreClones(MacroStabilityInwardsOutput original,
MacroStabilityInwardsOutput clone)
{
CoreCloneAssert.AreObjectClones(original.SlidingCurve, clone.SlidingCurve, AreClones);
CoreCloneAssert.AreObjectClones(original.SlipPlane, clone.SlipPlane, AreClones);
Assert.AreEqual(original.FactorOfStability, clone.FactorOfStability);
Assert.AreEqual(original.ForbiddenZonesXEntryMin, clone.ForbiddenZonesXEntryMin);
Assert.AreEqual(original.ForbiddenZonesXEntryMax, clone.ForbiddenZonesXEntryMax);
}
public void Create_WithNaNValues_ReturnsPropertyWithExpectedPropertiesSet()
{
// Setup
MacroStabilityInwardsSlidingCircle leftCircle = CreateSlidingCircleWithNaNValues();
MacroStabilityInwardsSlidingCircle rightCircle = CreateSlidingCircleWithNaNValues();
var slidingCurve = new MacroStabilityInwardsSlidingCurve(leftCircle,
rightCircle,
new MacroStabilityInwardsSlice[0],
double.NaN,
double.NaN);
var slipPlane = new MacroStabilityInwardsSlipPlaneUpliftVan(CreateGridWithNaNValues(),
CreateGridWithNaNValues(),
new RoundedDouble[0]);
var output = new MacroStabilityInwardsOutput(slidingCurve, slipPlane, new MacroStabilityInwardsOutput.ConstructionProperties());
// Call
MacroStabilityInwardsCalculationOutputEntity entity = output.Create();
// Assert
Assert.IsNotNull(entity);
Assert.IsNull(entity.FactorOfStability);
Assert.IsNull(entity.ForbiddenZonesXEntryMin);
Assert.IsNull(entity.ForbiddenZonesXEntryMax);
Assert.IsNull(entity.SlipPlaneLeftGridXLeft);
Assert.IsNull(entity.SlipPlaneLeftGridXRight);
Assert.IsNull(entity.SlipPlaneLeftGridZTop);
Assert.IsNull(entity.SlipPlaneLeftGridZBottom);
Assert.IsNull(entity.SlipPlaneRightGridXLeft);
Assert.IsNull(entity.SlipPlaneRightGridXRight);
Assert.IsNull(entity.SlipPlaneRightGridZTop);
Assert.IsNull(entity.SlipPlaneRightGridZBottom);
Assert.IsNull(entity.SlidingCurveIteratedHorizontalForce);
Assert.IsNull(entity.SlidingCurveNonIteratedHorizontalForce);
Assert.IsNull(entity.SlidingCurveLeftSlidingCircleCenterX);
Assert.IsNull(entity.SlidingCurveLeftSlidingCircleCenterY);
Assert.IsNull(entity.SlidingCurveLeftSlidingCircleRadius);
Assert.IsNull(entity.SlidingCurveLeftSlidingCircleIteratedForce);
Assert.IsNull(entity.SlidingCurveLeftSlidingCircleNonIteratedForce);
Assert.IsNull(entity.SlidingCurveLeftSlidingCircleDrivingMoment);
Assert.IsNull(entity.SlidingCurveLeftSlidingCircleResistingMoment);
Assert.IsNull(entity.SlidingCurveRightSlidingCircleCenterX);
Assert.IsNull(entity.SlidingCurveRightSlidingCircleCenterY);
Assert.IsNull(entity.SlidingCurveRightSlidingCircleRadius);
Assert.IsNull(entity.SlidingCurveRightSlidingCircleIteratedForce);
Assert.IsNull(entity.SlidingCurveRightSlidingCircleNonIteratedForce);
Assert.IsNull(entity.SlidingCurveRightSlidingCircleDrivingMoment);
Assert.IsNull(entity.SlidingCurveRightSlidingCircleResistingMoment);
}
public void Read_EntityWithNullValues_ReturnExpectedOutputWithNaNValues()
{
// Setup
MacroStabilityInwardsCalculationOutputEntity entity = CreateValidCalculationOutputEntity();
// Call
MacroStabilityInwardsOutput output = entity.Read();
// Assert
MacroStabilityInwardsCalculationOutputEntityTestHelper.AssertOutputPropertyValues(output, entity);
}
public void Constructor_ExpectedValues()
{
// Setup
MacroStabilityInwardsOutput output = MacroStabilityInwardsOutputTestFactory.CreateOutput();
// Call
var properties = new MacroStabilityInwardsOutputProperties(output, 1.1);
// Assert
Assert.IsInstanceOf <ObjectProperties <MacroStabilityInwardsOutput> >(properties);
Assert.AreSame(output, properties.Data);
}
private void UpdateOutputChartData()
{
MacroStabilityInwardsOutput output = data.Output;
leftGridChartData.Points = MacroStabilityInwardsChartDataPointsFactory.CreateGridPoints(output?.SlipPlane.LeftGrid);
rightGridChartData.Points = MacroStabilityInwardsChartDataPointsFactory.CreateGridPoints(output?.SlipPlane.RightGrid);
slipPlaneChartData.Points = MacroStabilityInwardsChartDataPointsFactory.CreateSlipPlanePoints(output?.SlidingCurve);
leftCircleRadiusChartData.Points = MacroStabilityInwardsChartDataPointsFactory.CreateLeftCircleRadiusPoints(output?.SlidingCurve);
rightCircleRadiusChartData.Points = MacroStabilityInwardsChartDataPointsFactory.CreateRightCircleRadiusPoints(output?.SlidingCurve);
slicesChartData.Areas = MacroStabilityInwardsSliceChartDataPointsFactory.CreateSliceAreas(output?.SlidingCurve);
tangentLinesChartData.Lines = MacroStabilityInwardsChartDataPointsFactory.CreateTangentLines(output?.SlipPlane.TangentLines,
data.InputParameters.SurfaceLine);
SetSliceParameterChartData(output?.SlidingCurve);
}
public void Create_ValidData_ReturnsExpectedValue()
{
// Setup
MacroStabilityInwardsOutput output = MacroStabilityInwardsOutputTestFactory.CreateOutput(new MacroStabilityInwardsOutput.ConstructionProperties
{
FactorOfStability = new Random(21).NextDouble()
});
// Call
DerivedMacroStabilityInwardsOutput derivedOutput = DerivedMacroStabilityInwardsOutputFactory.Create(output, 1.1);
// Assert
Assert.AreEqual(output.FactorOfStability, derivedOutput.FactorOfStability, derivedOutput.FactorOfStability.GetAccuracy());
Assert.AreEqual(0.067853, derivedOutput.MacroStabilityInwardsProbability, 1e-6);
Assert.AreEqual(1.49197, derivedOutput.MacroStabilityInwardsReliability, derivedOutput.MacroStabilityInwardsReliability.GetAccuracy());
}
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 Constructor_ConstructionPropertiesWithoutValuesSet_PropertiesAreDefault()
{
// Setup
var slidingCurve = new MacroStabilityInwardsSlidingCurve(MacroStabilityInwardsSlidingCircleTestFactory.Create(),
MacroStabilityInwardsSlidingCircleTestFactory.Create(),
new MacroStabilityInwardsSlice[0], 0, 0);
var slipPlane = new MacroStabilityInwardsSlipPlaneUpliftVan(MacroStabilityInwardsGridTestFactory.Create(),
MacroStabilityInwardsGridTestFactory.Create(),
new RoundedDouble[0]);
// Call
var output = new MacroStabilityInwardsOutput(slidingCurve, slipPlane, new MacroStabilityInwardsOutput.ConstructionProperties());
// Assert
Assert.IsNaN(output.FactorOfStability);
Assert.IsNaN(output.ForbiddenZonesXEntryMin);
Assert.IsNaN(output.ForbiddenZonesXEntryMax);
}
/// <summary>
/// Creates a <see cref="MacroStabilityInwardsCalculationOutputEntity"/> based on the information
/// of the <see cref="MacroStabilityInwardsOutput"/>.
/// </summary>
/// <param name="output">The calculation output for macro stability inwards failure mechanism to
/// create a database entity for.</param>
/// <returns>A new <see cref="MacroStabilityInwardsCalculationOutputEntity"/>.</returns>
/// <exception cref="ArgumentNullException">Thrown when <paramref name="output"/>
/// is <c>null</c>.</exception>
public static MacroStabilityInwardsCalculationOutputEntity Create(this MacroStabilityInwardsOutput output)
{
if (output == null)
{
throw new ArgumentNullException(nameof(output));
}
var entity = new MacroStabilityInwardsCalculationOutputEntity
{
FactorOfStability = output.FactorOfStability.ToNaNAsNull(),
ForbiddenZonesXEntryMin = output.ForbiddenZonesXEntryMin.ToNaNAsNull(),
ForbiddenZonesXEntryMax = output.ForbiddenZonesXEntryMax.ToNaNAsNull()
};
SetSlidingCurveParametersToEntity(entity, output.SlidingCurve);
SetSlipPlaneParametersToEntity(entity, output.SlipPlane);
return(entity);
}
/// <summary>
/// Determines for each property of <paramref name="entity"/> whether the matching
/// property of <paramref name="output"/> has an equal value.
/// </summary>
/// <param name="output">The <see cref="MacroStabilityInwardsOutput"/> to compare.</param>
/// <param name="entity">The <see cref="MacroStabilityInwardsCalculationOutputEntity"/>
/// to compare.</param>
/// <exception cref="ArgumentNullException">Thrown if any of the argument is <c>null</c>.</exception>
/// <exception cref="AssertionException">Thrown when any of the values of the
/// <see cref="MacroStabilityInwardsOutput"/> and its nested elements do not match.
/// </exception>
public static void AssertOutputPropertyValues(MacroStabilityInwardsOutput output,
MacroStabilityInwardsCalculationOutputEntity entity)
{
if (output == null)
{
throw new ArgumentNullException(nameof(output));
}
if (entity == null)
{
throw new ArgumentNullException(nameof(entity));
}
AssertAreEqual(output.FactorOfStability, entity.FactorOfStability);
AssertAreEqual(output.ForbiddenZonesXEntryMin, entity.ForbiddenZonesXEntryMin);
AssertAreEqual(output.ForbiddenZonesXEntryMax, entity.ForbiddenZonesXEntryMax);
AssertSlidingCurveProperties(output.SlidingCurve, entity);
AssertSlipPlaneProperties(output.SlipPlane, entity);
}
public void Create_WithValidValues_ReturnsEntityWithExpectedPropertiesSet()
{
// Setup
var random = new Random(21);
MacroStabilityInwardsSlidingCircle leftCircle = CreateSlidingCircle(13);
MacroStabilityInwardsSlidingCircle rightCircle = CreateSlidingCircle(34);
IEnumerable<MacroStabilityInwardsSlice> slices = new[]
{
MacroStabilityInwardsSliceTestFactory.CreateSlice()
};
var slidingCurve = new MacroStabilityInwardsSlidingCurve(leftCircle,
rightCircle,
slices,
random.NextDouble(),
random.NextDouble());
MacroStabilityInwardsGrid leftGrid = MacroStabilityInwardsGridTestFactory.Create();
MacroStabilityInwardsGrid rightGrid = MacroStabilityInwardsGridTestFactory.Create();
RoundedDouble[] tangentLines =
{
random.NextRoundedDouble()
};
var slipPlane = new MacroStabilityInwardsSlipPlaneUpliftVan(leftGrid, rightGrid, tangentLines);
var output = new MacroStabilityInwardsOutput(slidingCurve, slipPlane, new MacroStabilityInwardsOutput.ConstructionProperties
{
FactorOfStability = random.NextDouble(),
ForbiddenZonesXEntryMax = random.NextDouble(),
ForbiddenZonesXEntryMin = random.NextDouble()
});
// Call
MacroStabilityInwardsCalculationOutputEntity entity = output.Create();
// Assert
Assert.IsNotNull(entity);
MacroStabilityInwardsCalculationOutputEntityTestHelper.AssertOutputPropertyValues(output, entity);
}
public void Constructor_ExpectedValues()
{
// Setup
var slidingCurve = new MacroStabilityInwardsSlidingCurve(MacroStabilityInwardsSlidingCircleTestFactory.Create(),
MacroStabilityInwardsSlidingCircleTestFactory.Create(),
new MacroStabilityInwardsSlice[0], 0, 0);
var slipPlane = new MacroStabilityInwardsSlipPlaneUpliftVan(MacroStabilityInwardsGridTestFactory.Create(),
MacroStabilityInwardsGridTestFactory.Create(),
new RoundedDouble[0]);
var random = new Random(21);
double factorOfStability = random.NextDouble();
double zValue = random.NextDouble();
double xEntryMin = random.NextDouble();
double xEntryMax = random.NextDouble();
var properties = new MacroStabilityInwardsOutput.ConstructionProperties
{
FactorOfStability = factorOfStability,
ForbiddenZonesXEntryMin = xEntryMin,
ForbiddenZonesXEntryMax = xEntryMax
};
// Call
var output = new MacroStabilityInwardsOutput(slidingCurve, slipPlane, properties);
// Assert
Assert.IsInstanceOf <CloneableObservable>(output);
Assert.IsInstanceOf <ICalculationOutput>(output);
Assert.AreSame(slidingCurve, output.SlidingCurve);
Assert.AreSame(slipPlane, output.SlipPlane);
Assert.AreEqual(factorOfStability, output.FactorOfStability);
Assert.AreEqual(xEntryMin, output.ForbiddenZonesXEntryMin);
Assert.AreEqual(xEntryMax, output.ForbiddenZonesXEntryMax);
}
public void Constructor_Always_PropertiesHaveExpectedAttributesValues()
{
MacroStabilityInwardsOutput output = MacroStabilityInwardsOutputTestFactory.CreateOutput();
// Call
var properties = new MacroStabilityInwardsOutputProperties(output, 1.1);
// Assert
PropertyDescriptorCollection dynamicProperties = PropertiesTestHelper.GetAllVisiblePropertyDescriptors(properties);
Assert.AreEqual(3, dynamicProperties.Count);
const string macroStabilityInwardsCategory = "Macrostabiliteit binnenwaarts";
PropertyDescriptor stabilityFactorProperty = dynamicProperties[0];
PropertiesTestHelper.AssertRequiredPropertyDescriptorProperties(stabilityFactorProperty,
macroStabilityInwardsCategory,
"Stabiliteitsfactor [-]",
"Het quotiënt van de weerstandbiedende- en aandrijvende krachten langs een glijvlak.",
true);
PropertyDescriptor macroStabilityInwardsProbabilityProperty = dynamicProperties[1];
PropertiesTestHelper.AssertRequiredPropertyDescriptorProperties(macroStabilityInwardsProbabilityProperty,
macroStabilityInwardsCategory,
"Benaderde faalkans [1/jaar]",
"De benaderde kans dat het faalmechanisme macrostabiliteit binnenwaarts optreedt voor deze berekening.",
true);
PropertyDescriptor macroStabilityInwardsReliabilityProperty = dynamicProperties[2];
PropertiesTestHelper.AssertRequiredPropertyDescriptorProperties(macroStabilityInwardsReliabilityProperty,
macroStabilityInwardsCategory,
"Betrouwbaarheidsindex faalkans [-]",
"De betrouwbaarheidsindex van de faalkans voor deze berekening.",
true);
}
