public void Convert_ValidArguments_ExpectedProperties() { // Setup var random = new Random(21); var hydraRingStochast = new HydraRingStochast("hydraRingStochast", random.NextDouble(), random.NextDouble()); var hydraRingFaultTreeIllustrationPoint = new HydraRingFaultTreeIllustrationPoint("name", random.NextDouble(), new[] { hydraRingStochast }, HydraRingCombinationType.And); // Call FaultTreeIllustrationPoint faultTreeIllustrationPoint = FaultTreeIllustrationPointConverter.Convert(hydraRingFaultTreeIllustrationPoint); // Assert Assert.AreEqual(hydraRingFaultTreeIllustrationPoint.Beta, faultTreeIllustrationPoint.Beta, faultTreeIllustrationPoint.Beta.GetAccuracy()); Assert.AreEqual(hydraRingFaultTreeIllustrationPoint.Name, faultTreeIllustrationPoint.Name); Assert.AreEqual(CombinationType.And, faultTreeIllustrationPoint.CombinationType); Stochast stochast = faultTreeIllustrationPoint.Stochasts.Single(); Assert.AreEqual(hydraRingStochast.Alpha, stochast.Alpha, stochast.Alpha.GetAccuracy()); Assert.AreEqual(hydraRingStochast.Duration, stochast.Duration, stochast.Duration.GetAccuracy()); Assert.AreEqual(hydraRingStochast.Name, stochast.Name); }
private static void AssertStochast(StochastEntity stochastEntity, Stochast readStochast) { Assert.AreEqual(stochastEntity.Name, readStochast.Name); Assert.AreEqual(stochastEntity.Alpha, readStochast.Alpha, readStochast.Alpha.GetAccuracy()); Assert.AreEqual(stochastEntity.Duration, readStochast.Duration, readStochast.Duration.GetAccuracy()); }
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)); }
void Start() { targetLevel = transform.position.y; random = new Stochast(); initialize(); generate(); }
private static void AssertStochastEntity(Stochast stochast, StochastEntity stochastEntity, int expectedOrder) { TestHelper.AssertAreEqualButNotSame(stochast.Name, stochastEntity.Name); Assert.AreEqual(stochast.Duration, stochastEntity.Duration, stochast.Duration.GetAccuracy()); Assert.AreEqual(stochast.Alpha, stochastEntity.Alpha, stochast.Alpha.GetAccuracy()); Assert.AreEqual(expectedOrder, stochastEntity.Order); }
public void Clone_Always_ReturnNewInstanceWithCopiedValues() { // Setup var random = new Random(21); var original = new Stochast("Random name", random.NextDouble(), random.NextDouble()); // Call object clone = original.Clone(); // Assert CoreCloneAssert.AreObjectClones(original, clone, CommonCloneAssert.AreClones); }
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)); }
/// <summary> /// Creates a new instance of <see cref="GeneralResult"/> with duplicate stochasts. /// </summary> /// <returns>A <see cref="GeneralResult"/> with duplicate stochasts.</returns> public static GeneralResult CreateGeneralResultWithDuplicateStochasts() { var stochast = new Stochast("Stochast A", 0, 0); return(new GeneralResult(0.5, WindDirectionTestFactory.CreateWindDirection(), new[] { stochast, stochast }, new Dictionary <WindDirectionClosingSituation, IllustrationPointTreeNode>())); }
private static void AssertStochasts(StochastEntity[] stochastEntities, Stochast[] stochasts) { Assert.AreEqual(stochastEntities.Length, stochasts.Length); for (var i = 0; i < stochastEntities.Length; i++) { StochastEntity stochastEntity = stochastEntities[i]; Stochast stochast = stochasts[i]; Assert.AreEqual(stochastEntity.Name, stochast.Name); Assert.AreEqual(stochastEntity.Alpha, stochast.Alpha, stochast.Alpha.GetAccuracy()); Assert.AreEqual(stochastEntity.Duration, stochast.Duration, stochast.Duration.GetAccuracy()); } }
public void Convert_ValidHydraRingFaultTreeIllustrationPointWithoutChildren_ExpectedProperties() { // Setup var random = new Random(21); var hydraRingWindDirection = new HydraRingWindDirection("random name", random.NextDouble()); var hydraRingWindDirectionClosingSituation = new HydraRingWindDirectionClosingSituation(hydraRingWindDirection, "random closing situation"); var hydraRingStochast = new HydraRingStochast("random stochast", random.NextDouble(), random.NextDouble()); var hydraRingFaultTreeIllustrationPoint = new HydraRingFaultTreeIllustrationPoint("fault tree", random.NextDouble(), new[] { hydraRingStochast }, HydraRingCombinationType.And); var treeNode = new HydraRingIllustrationPointTreeNode(hydraRingFaultTreeIllustrationPoint); // Call TopLevelFaultTreeIllustrationPoint topLevelIllustrationPoint = TopLevelFaultTreeIllustrationPointConverter.Convert(hydraRingWindDirectionClosingSituation, treeNode); // Assert WindDirection windDirection = topLevelIllustrationPoint.WindDirection; Assert.AreEqual(hydraRingWindDirection.Angle, windDirection.Angle, windDirection.Angle.GetAccuracy()); Assert.AreEqual(hydraRingWindDirection.Name, windDirection.Name); Assert.AreEqual(hydraRingWindDirectionClosingSituation.ClosingSituation, topLevelIllustrationPoint.ClosingSituation); IllustrationPointNode illustrationPointNode = topLevelIllustrationPoint.FaultTreeNodeRoot; CollectionAssert.IsEmpty(illustrationPointNode.Children); var illustrationPointData = (FaultTreeIllustrationPoint)illustrationPointNode.Data; Assert.AreEqual(hydraRingFaultTreeIllustrationPoint.Name, illustrationPointData.Name); Assert.AreEqual(hydraRingFaultTreeIllustrationPoint.Beta, illustrationPointData.Beta, illustrationPointData.Beta.GetAccuracy()); Assert.AreEqual(CombinationType.And, illustrationPointData.CombinationType); Stochast stochast = illustrationPointData.Stochasts.Single(); Assert.AreEqual(hydraRingStochast.Alpha, stochast.Alpha, stochast.Alpha.GetAccuracy()); Assert.AreEqual(hydraRingStochast.Duration, stochast.Duration, stochast.Duration.GetAccuracy()); Assert.AreEqual(hydraRingStochast.Name, stochast.Name); }
public void Constructor_WithParameters_ReturnsNewInstance() { // Setup const string name = "stochast name"; var random = new Random(21); double duration = random.NextDouble(); double alpha = random.NextDouble(); // Call var stochast = new Stochast(name, duration, alpha); // Assert Assert.AreEqual(name, stochast.Name); Assert.AreEqual(duration, stochast.Duration); Assert.AreEqual(alpha, stochast.Alpha); }
public void Create_ValidStochast_ReturnStochastEntity() { // Setup var random = new Random(123); var stochast = new Stochast("Some description", random.NextDouble(), random.NextDouble()); int order = random.Next(); // Call StochastEntity entity = stochast.Create(order); // Assert TestHelper.AssertAreEqualButNotSame(stochast.Name, entity.Name); Assert.AreEqual(stochast.Alpha, entity.Alpha, stochast.Alpha.GetAccuracy()); Assert.AreEqual(stochast.Duration, entity.Duration, stochast.Duration.GetAccuracy()); Assert.AreEqual(order, entity.Order); }
public void Convert_ValidHydraRingStochastArgument_ExpectedProperties() { // Setup const string name = "name"; var random = new Random(21); double duration = random.NextDouble(); double alpha = random.NextDouble(); var hydraRingStochast = new HydraRingStochast(name, duration, alpha); // Call Stochast stochast = StochastConverter.Convert(hydraRingStochast); // Assert Assert.AreEqual(hydraRingStochast.Alpha, stochast.Alpha, stochast.Alpha.GetAccuracy()); Assert.AreEqual(duration, stochast.Duration, stochast.Duration.GetAccuracy()); Assert.AreEqual(hydraRingStochast.Name, stochast.Name); }
/// <summary> /// Creates a <see cref="StochastEntity"/> based on the information /// of the <paramref name="stochast"/>. /// </summary> /// <param name="stochast">The stochast to create a database entity for.</param> /// <param name="order">The index at which <paramref name="stochast"/> resides within its parent.</param> /// <returns>A new <see cref="StochastEntity"/>.</returns> /// <exception cref="ArgumentNullException">Thrown when <paramref name="stochast"/> /// is <c>null</c>.</exception> internal static StochastEntity Create( this Stochast stochast, int order) { if (stochast == null) { throw new ArgumentNullException(nameof(stochast)); } var entity = new StochastEntity { Name = stochast.Name.DeepClone(), Alpha = stochast.Alpha, Duration = stochast.Duration, Order = order }; return(entity); }
public void Read_ValidEntity_ReturnStochast() { // Setup var random = new Random(123); var entity = new StochastEntity { Name = "Description", Alpha = random.NextDouble(), Duration = random.NextDouble() }; // Call Stochast illustrationPointResult = entity.Read(); // Assert Assert.AreEqual(entity.Name, illustrationPointResult.Name); Assert.AreEqual(entity.Alpha, illustrationPointResult.Alpha, illustrationPointResult.Alpha.GetAccuracy()); Assert.AreEqual(entity.Duration, illustrationPointResult.Duration, illustrationPointResult.Duration.GetAccuracy()); }
public void Constructor_ValidArguments_ReturnExpectedValues() { // Setup const string name = "Stochast name"; var random = new Random(21); double duration = random.NextDouble(); double alpha = random.NextDouble(); // Call var stochast = new Stochast(name, duration, alpha); // Assert Assert.IsInstanceOf <ICloneable>(stochast); Assert.AreEqual(name, stochast.Name); Assert.AreEqual(duration, stochast.Duration, stochast.Duration.GetAccuracy()); Assert.AreEqual(1, stochast.Duration.NumberOfDecimalPlaces); Assert.AreEqual(alpha, stochast.Alpha, stochast.Alpha.GetAccuracy()); Assert.AreEqual(5, stochast.Alpha.NumberOfDecimalPlaces); }
public void Create_IllustrationPointNodeWithFaultTreeIllustrationPointAndStochast_ReturnFaultTreeIllustrationPointEntity() { // Setup var random = new Random(21); var illustrationPoint = new FaultTreeIllustrationPoint( "Illustration point name", random.NextDouble(), new[] { new Stochast("Stochast", random.NextDouble(), random.NextDouble()) }, random.NextEnumValue <CombinationType>()); int order = random.Next(); var node = new IllustrationPointNode(illustrationPoint); // Call FaultTreeIllustrationPointEntity entity = node.Create(order); // Assert Assert.IsNull(entity.FaultTreeIllustrationPointEntity2); TestHelper.AssertAreEqualButNotSame(illustrationPoint.Name, entity.Name); Assert.AreEqual(illustrationPoint.Beta, entity.Beta, illustrationPoint.Beta.GetAccuracy()); byte expectedCombinationType = Convert.ToByte(illustrationPoint.CombinationType); Assert.AreEqual(expectedCombinationType, entity.CombinationType); CollectionAssert.IsEmpty(entity.FaultTreeIllustrationPointEntity1); CollectionAssert.IsEmpty(entity.SubMechanismIllustrationPointEntities); CollectionAssert.IsEmpty(entity.TopLevelFaultTreeIllustrationPointEntities); Assert.AreEqual(order, entity.Order); StochastEntity entityStochastEntity = entity.StochastEntities.Single(); Stochast stochast = illustrationPoint.Stochasts.First(); Assert.AreEqual(stochast.Name, entityStochastEntity.Name); Assert.AreEqual(stochast.Alpha, entityStochastEntity.Alpha); Assert.AreEqual(stochast.Duration, entityStochastEntity.Duration); }
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)); }
public void Convert_ValidHydraRingFaultTreeIllustrationPointWithChildren_ExpectedProperties() { // Setup var random = new Random(21); var hydraRingWindDirection = new HydraRingWindDirection("random name", random.NextDouble()); var hydraRingWindDirectionClosingSituation = new HydraRingWindDirectionClosingSituation(hydraRingWindDirection, "random closing situation"); var hydraRingStochast = new HydraRingStochast("random stochast", random.NextDouble(), random.NextDouble()); var hydraRingFaultTreeIllustrationPointRoot = new HydraRingFaultTreeIllustrationPoint("fault tree root", random.NextDouble(), new[] { hydraRingStochast }, HydraRingCombinationType.And); var hydraRingFaultTreeIllustrationPointChildOne = new HydraRingFaultTreeIllustrationPoint("fault tree child one", random.NextDouble(), new[] { hydraRingStochast }, HydraRingCombinationType.Or); var hydraRingFaultTreeIllustrationPointChildTwo = new HydraRingSubMechanismIllustrationPoint("fault tree child two", Enumerable.Empty <HydraRingSubMechanismIllustrationPointStochast>(), Enumerable.Empty <HydraRingIllustrationPointResult>(), random.NextDouble()); var treeNodeRoot = new HydraRingIllustrationPointTreeNode(hydraRingFaultTreeIllustrationPointRoot); treeNodeRoot.SetChildren(new[] { new HydraRingIllustrationPointTreeNode(hydraRingFaultTreeIllustrationPointChildOne), new HydraRingIllustrationPointTreeNode(hydraRingFaultTreeIllustrationPointChildTwo) }); // Call TopLevelFaultTreeIllustrationPoint topLevelIllustrationPoint = TopLevelFaultTreeIllustrationPointConverter.Convert(hydraRingWindDirectionClosingSituation, treeNodeRoot); // Assert WindDirection windDirection = topLevelIllustrationPoint.WindDirection; Assert.AreEqual(hydraRingWindDirection.Angle, windDirection.Angle, windDirection.Angle.GetAccuracy()); Assert.AreEqual(hydraRingWindDirection.Name, windDirection.Name); Assert.AreEqual(hydraRingWindDirectionClosingSituation.ClosingSituation, topLevelIllustrationPoint.ClosingSituation); IllustrationPointNode illustrationPoint = topLevelIllustrationPoint.FaultTreeNodeRoot; var illustrationPointData = (FaultTreeIllustrationPoint)illustrationPoint.Data; Assert.AreEqual(hydraRingFaultTreeIllustrationPointRoot.Name, illustrationPointData.Name); Assert.AreEqual(hydraRingFaultTreeIllustrationPointRoot.Beta, illustrationPointData.Beta, illustrationPointData.Beta.GetAccuracy()); Assert.AreEqual(CombinationType.And, illustrationPointData.CombinationType); Stochast stochast = illustrationPointData.Stochasts.Single(); Assert.AreEqual(hydraRingStochast.Alpha, stochast.Alpha, stochast.Alpha.GetAccuracy()); Assert.AreEqual(hydraRingStochast.Duration, stochast.Duration, stochast.Duration.GetAccuracy()); Assert.AreEqual(hydraRingStochast.Name, stochast.Name); Assert.AreEqual(treeNodeRoot.Children.Count(), illustrationPoint.Children.Count()); IllustrationPointNode[] children = illustrationPoint.Children.ToArray(); CollectionAssert.IsEmpty(children[0].Children); CollectionAssert.IsEmpty(children[1].Children); var childOne = (FaultTreeIllustrationPoint)children[0].Data; Stochast childStochast = illustrationPointData.Stochasts.Single(); Assert.AreEqual(hydraRingStochast.Alpha, childStochast.Alpha, childStochast.Alpha.GetAccuracy()); Assert.AreEqual(hydraRingStochast.Duration, childStochast.Duration, childStochast.Duration.GetAccuracy()); Assert.AreEqual(hydraRingStochast.Name, childStochast.Name); Assert.AreEqual(hydraRingFaultTreeIllustrationPointChildOne.Name, childOne.Name); Assert.AreEqual(hydraRingFaultTreeIllustrationPointChildOne.Beta, childOne.Beta, childOne.Beta.GetAccuracy()); Assert.AreEqual(CombinationType.Or, childOne.CombinationType); var childTwo = (SubMechanismIllustrationPoint)children[1].Data; CollectionAssert.IsEmpty(childTwo.Stochasts); CollectionAssert.IsEmpty(childTwo.IllustrationPointResults); Assert.AreEqual(hydraRingFaultTreeIllustrationPointChildTwo.Name, childTwo.Name); Assert.AreEqual(hydraRingFaultTreeIllustrationPointChildTwo.Beta, childTwo.Beta, childTwo.Beta.GetAccuracy()); }
public void GetProperties_WithData_ReturnExpectedValues() { // Setup var random = new Random(); double overtoppingRate = random.NextDouble(); double overtoppingRateTargetProbability = random.NextDouble(); double overtoppingRateTargetReliability = random.NextDouble(); double overtoppingRateCalculatedProbability = random.NextDouble(); double overtoppingRateCalculatedReliability = random.NextDouble(); var overtoppingRateConvergence = random.NextEnumValue <CalculationConvergence>(); var generalResult = new TestGeneralResultFaultTreeIllustrationPoint(); var overtoppingRateOutput = new OvertoppingRateOutput(overtoppingRate, overtoppingRateTargetProbability, overtoppingRateTargetReliability, overtoppingRateCalculatedProbability, overtoppingRateCalculatedReliability, overtoppingRateConvergence, generalResult); // Call var properties = new OvertoppingRateOutputProperties(overtoppingRateOutput); // Assert Assert.AreEqual(2, properties.OvertoppingRate.NumberOfDecimalPlaces); Assert.AreEqual(overtoppingRate * 1000, properties.OvertoppingRate, properties.OvertoppingRate.GetAccuracy()); Assert.AreEqual(overtoppingRateTargetProbability, properties.OvertoppingRateTargetProbability); TestHelper.AssertTypeConverter <GrassCoverErosionInwardsOutputProperties, NoProbabilityValueDoubleConverter>( nameof(GrassCoverErosionInwardsOutputProperties.OvertoppingRateTargetProbability)); Assert.AreEqual(overtoppingRateTargetReliability, properties.OvertoppingRateTargetReliability, properties.OvertoppingRateTargetReliability.GetAccuracy()); TestHelper.AssertTypeConverter <GrassCoverErosionInwardsOutputProperties, NoValueRoundedDoubleConverter>( nameof(GrassCoverErosionInwardsOutputProperties.OvertoppingRateTargetReliability)); Assert.AreEqual(overtoppingRateCalculatedProbability, properties.OvertoppingRateCalculatedProbability); TestHelper.AssertTypeConverter <GrassCoverErosionInwardsOutputProperties, NoProbabilityValueDoubleConverter>( nameof(GrassCoverErosionInwardsOutputProperties.OvertoppingRateCalculatedProbability)); Assert.AreEqual(overtoppingRateCalculatedReliability, properties.OvertoppingRateCalculatedReliability, properties.OvertoppingRateCalculatedReliability.GetAccuracy()); TestHelper.AssertTypeConverter <GrassCoverErosionInwardsOutputProperties, NoValueRoundedDoubleConverter>( nameof(GrassCoverErosionInwardsOutputProperties.OvertoppingRateCalculatedReliability)); string overtoppingRateConvergenceValue = EnumDisplayNameHelper.GetDisplayName(overtoppingRateConvergence); Assert.AreEqual(overtoppingRateConvergenceValue, properties.OvertoppingRateConvergence); 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 Constructor_ExpectedValues() { // Setup var stochast = new Stochast("Stochast A", 10.0, 2.5); var illustrationPoint = new FaultTreeIllustrationPoint("Fault tree Test", 1.5, new[] { stochast }, CombinationType.And); var illustrationPointNodeChild1 = new IllustrationPointNode(new FaultTreeIllustrationPoint("Fault tree child", 3.5, new[] { stochast }, CombinationType.Or)); var illustrationPointNodeChild2 = new IllustrationPointNode(new FaultTreeIllustrationPoint("Fault tree child 2", 3.5, new Stochast[0], CombinationType.Or)); IllustrationPointNode[] illustrationPointNodeChildren = { illustrationPointNodeChild1, illustrationPointNodeChild2 }; // Call var properties = new FaultTreeIllustrationPointProperties(illustrationPoint, illustrationPointNodeChildren, "NNE", "closing situation"); // Assert Assert.IsInstanceOf <IllustrationPointProperties>(properties); PropertyDescriptorCollection dynamicProperties = PropertiesTestHelper.GetAllVisiblePropertyDescriptors(properties); PropertyDescriptor alphasProperty = dynamicProperties[alphasPropertyIndex]; Assert.NotNull(alphasProperty.Attributes[typeof(KeyValueElementAttribute)]); PropertyDescriptor durationsProperty = dynamicProperties[durationsPropertyIndex]; Assert.NotNull(durationsProperty.Attributes[typeof(KeyValueElementAttribute)]); Assert.AreEqual("NNE", properties.WindDirection); Assert.AreEqual(illustrationPoint.Beta, properties.Reliability, properties.Reliability.GetAccuracy()); Assert.AreEqual(5, properties.Reliability.NumberOfDecimalPlaces); Assert.AreEqual(StatisticsConverter.ReliabilityToProbability(illustrationPoint.Beta), properties.CalculatedProbability); Assert.AreEqual("closing situation", properties.ClosingSituation); TestHelper.AssertTypeConverter <FaultTreeIllustrationPointProperties, KeyValueExpandableArrayConverter>( nameof(FaultTreeIllustrationPointProperties.AlphaValues)); CollectionAssert.IsNotEmpty(properties.AlphaValues); CollectionAssert.AreEqual(new[] { stochast }, properties.AlphaValues); TestHelper.AssertTypeConverter <FaultTreeIllustrationPointProperties, KeyValueExpandableArrayConverter>( nameof(FaultTreeIllustrationPointProperties.Durations)); CollectionAssert.AreEqual(new[] { stochast }, properties.Durations); TestHelper.AssertTypeConverter <FaultTreeIllustrationPointProperties, ExpandableArrayConverter>( nameof(FaultTreeIllustrationPointProperties.IllustrationPoints)); Assert.AreEqual(2, properties.IllustrationPoints.Length); Assert.AreSame(illustrationPointNodeChild1.Data, properties.IllustrationPoints.ElementAt(0).Data); Assert.AreSame(illustrationPointNodeChild2.Data, properties.IllustrationPoints.ElementAt(1).Data); }
/// <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(Stochast original, Stochast clone) { Assert.AreEqual(original.Name, clone.Name); Assert.AreEqual(original.Alpha, clone.Alpha); Assert.AreEqual(original.Duration, clone.Duration); }