public void Create_ValidTopLevelSubMechanismIllustrationPoint_ReturnsEntityWithSubMechanismIllustrationPointEntity() { // Setup var random = new Random(21); var illustrationPoint = new SubMechanismIllustrationPoint("Illustration point name", random.NextDouble(), Enumerable.Empty <SubMechanismIllustrationPointStochast>(), Enumerable.Empty <IllustrationPointResult>()); var windDirection = new WindDirection("WindDirection Name", random.NextDouble()); var topLevelSubMechanismIllustrationPoint = new TopLevelSubMechanismIllustrationPoint(windDirection, "Just a situation", illustrationPoint); int order = random.Next(); // Call TopLevelSubMechanismIllustrationPointEntity entity = topLevelSubMechanismIllustrationPoint.Create(order); // Assert TestHelper.AssertAreEqualButNotSame(topLevelSubMechanismIllustrationPoint.ClosingSituation, entity.ClosingSituation); Assert.AreEqual(order, entity.Order); TestHelper.AssertAreEqualButNotSame(windDirection.Name, entity.WindDirectionName); Assert.AreEqual(windDirection.Angle, entity.WindDirectionAngle, windDirection.Angle.GetAccuracy()); SubMechanismIllustrationPointEntity subMechanismIllustrationPointEntity = entity.SubMechanismIllustrationPointEntity; TestHelper.AssertAreEqualButNotSame(illustrationPoint.Name, subMechanismIllustrationPointEntity.Name); Assert.AreEqual(illustrationPoint.Beta, subMechanismIllustrationPointEntity.Beta, illustrationPoint.Beta.GetAccuracy()); CollectionAssert.IsEmpty(subMechanismIllustrationPointEntity.IllustrationPointResultEntities); CollectionAssert.IsEmpty(subMechanismIllustrationPointEntity.SubMechanismIllustrationPointStochastEntities); }
private static void AssertIllustrationPointEntities( IllustrationPointNode[] children, IEnumerable <SubMechanismIllustrationPointEntity> subMechanismIllustrationPointEntities, IEnumerable <FaultTreeIllustrationPointEntity> faultTreeIllustrationPointEntity ) { for (var i = 0; i < children.Length; i++) { int nrOfTotalCreatedEntities = subMechanismIllustrationPointEntities.Count() + faultTreeIllustrationPointEntity.Count(); Assert.AreEqual(nrOfTotalCreatedEntities, children.Length); IllustrationPointNode child = children[i]; var subMechanismIllustrationPoint = child.Data as SubMechanismIllustrationPoint; if (subMechanismIllustrationPoint != null) { SubMechanismIllustrationPointEntity illustrationPointEntity = subMechanismIllustrationPointEntities.Single(s => s.Order == i); AssertSubMechanismIllustrationPointEntity(subMechanismIllustrationPoint, illustrationPointEntity); } var faultTreeIllustrationPoint = child.Data as FaultTreeIllustrationPoint; if (faultTreeIllustrationPoint != null) { FaultTreeIllustrationPointEntity illustrationPointEntity = faultTreeIllustrationPointEntity.Single(f => f.Order == i); AssertFaultTreeIllustrationPointEntity(faultTreeIllustrationPoint, illustrationPointEntity); AssertIllustrationPointEntities(child.Children.ToArray(), illustrationPointEntity.SubMechanismIllustrationPointEntities.ToArray(), illustrationPointEntity.FaultTreeIllustrationPointEntity1.ToArray()); } } }
private static void AssertSubMechanismIllustrationPointEntity(IllustrationPointBase illustrationPoint, SubMechanismIllustrationPointEntity illustrationPointEntity) { Assert.IsNotNull(illustrationPoint); Assert.AreEqual(illustrationPoint.Beta, illustrationPointEntity.Beta, illustrationPoint.Beta.GetAccuracy()); TestHelper.AssertAreEqualButNotSame(illustrationPoint.Name, illustrationPointEntity.Name); CollectionAssert.IsEmpty(illustrationPointEntity.IllustrationPointResultEntities); CollectionAssert.IsEmpty(illustrationPointEntity.SubMechanismIllustrationPointStochastEntities); }
private static void AddEntitiesForIllustrationPointResults(SubMechanismIllustrationPointEntity entity, IEnumerable <IllustrationPointResult> illustrationPointResults) { var order = 0; foreach (IllustrationPointResult illustrationPointResult in illustrationPointResults) { entity.IllustrationPointResultEntities.Add( illustrationPointResult.Create(order++)); } }
private static void AddEntitiesForSubMechanismIllustrationPointsStochasts( SubMechanismIllustrationPointEntity entity, IEnumerable <SubMechanismIllustrationPointStochast> stochasts) { var order = 0; foreach (SubMechanismIllustrationPointStochast subMechanismIllustrationPointStochast in stochasts) { entity.SubMechanismIllustrationPointStochastEntities.Add( subMechanismIllustrationPointStochast.Create(order++)); } }
public void Create_ValidIllustrationPointWithStochasts_ReturnSubMechanismIllustrationPointEntityWithStochastEntities() { // Setup var random = new Random(21); var stochastOne = new SubMechanismIllustrationPointStochast("stochast name", "-", random.NextDouble(), random.NextDouble(), random.NextDouble()); var stochastTwo = new SubMechanismIllustrationPointStochast("Stochast name two", "-", random.NextDouble(), random.NextDouble(), random.NextDouble()); SubMechanismIllustrationPointStochast[] stochasts = { stochastOne, stochastTwo }; var illustrationPoint = new SubMechanismIllustrationPoint("Illustration point name", random.NextDouble(), stochasts, Enumerable.Empty <IllustrationPointResult>()); int order = random.Next(); // Call SubMechanismIllustrationPointEntity entity = illustrationPoint.Create(order); // Assert AssertCommonProperties(illustrationPoint, entity); Assert.AreEqual(order, entity.Order); SubMechanismIllustrationPointStochastEntity[] stochastEntities = entity.SubMechanismIllustrationPointStochastEntities.ToArray(); int expectedNrOfStochasts = stochasts.Length; Assert.AreEqual(expectedNrOfStochasts, stochastEntities.Length); for (var i = 0; i < expectedNrOfStochasts; i++) { SubMechanismIllustrationPointStochast stochast = stochasts[i]; SubMechanismIllustrationPointStochastEntity stochastEntity = stochastEntities[i]; TestHelper.AssertAreEqualButNotSame(stochast.Name, stochastEntity.Name); TestHelper.AssertAreEqualButNotSame(stochast.Unit, stochastEntity.Unit); Assert.AreEqual(stochast.Duration, stochastEntity.Duration, stochast.Duration.GetAccuracy()); Assert.AreEqual(stochast.Alpha, stochastEntity.Alpha, stochast.Alpha.GetAccuracy()); Assert.AreEqual(stochast.Realization, stochastEntity.Realization, stochast.Realization.GetAccuracy()); Assert.AreEqual(i, stochastEntity.Order); } }
private static void AssertSubMechanismIllustrationPointNode(SubMechanismIllustrationPointEntity entity, IllustrationPointNode node) { var illustrationPoint = node.Data as SubMechanismIllustrationPoint; Assert.IsNotNull(illustrationPoint); Assert.AreEqual(entity.Name, illustrationPoint.Name); Assert.AreEqual(entity.Beta, illustrationPoint.Beta, illustrationPoint.Beta.GetAccuracy()); AssertStochasts(entity.SubMechanismIllustrationPointStochastEntities.ToArray(), illustrationPoint.Stochasts.ToArray()); CollectionAssert.IsEmpty(illustrationPoint.Stochasts); CollectionAssert.IsEmpty(illustrationPoint.IllustrationPointResults); CollectionAssert.IsEmpty(node.Children); }
public void Read_ValidEntityWithStochasts_ReturnsSubMechanismIllustrationPointWithStochasts() { // Setup var random = new Random(21); var stochastEntityOne = new SubMechanismIllustrationPointStochastEntity { Name = "Stochast", Unit = "-", Alpha = random.NextDouble(), Duration = random.NextDouble(), Realization = random.NextDouble(), Order = 0 }; var stochastEntityTwo = new SubMechanismIllustrationPointStochastEntity { Name = "Stochast_Two", Unit = "m", Alpha = random.NextDouble(), Duration = random.NextDouble(), Realization = random.NextDouble(), Order = 1 }; const string illustrationPointName = "Name"; double beta = random.NextDouble(); var entity = new SubMechanismIllustrationPointEntity { Name = illustrationPointName, Beta = beta, SubMechanismIllustrationPointStochastEntities = new[] { stochastEntityTwo, stochastEntityOne } }; // Call SubMechanismIllustrationPoint illustrationPoint = entity.Read(); // Assert AssertCommonProperties(entity, illustrationPoint); SubMechanismIllustrationPointStochast[] stochasts = illustrationPoint.Stochasts.ToArray(); Assert.AreEqual(2, stochasts.Length); AssertReadStochast(stochastEntityOne, stochasts[0]); AssertReadStochast(stochastEntityTwo, stochasts[1]); }
private static void AssertIllustrationPointNodes(ICollection <SubMechanismIllustrationPointEntity> entities, IEnumerable <IllustrationPointNode> nodes) { SubMechanismIllustrationPointEntity[] entitiesArray = entities.OrderBy(ip => ip.Order).ToArray(); IllustrationPointNode[] subMechanismNodes = nodes.Where(n => n.Data.GetType() == typeof(SubMechanismIllustrationPoint)).ToArray(); Assert.AreEqual(entitiesArray.Length, subMechanismNodes.Length); for (var i = 0; i < entitiesArray.Length; i++) { SubMechanismIllustrationPointEntity entity = entitiesArray[i]; IllustrationPointNode node = subMechanismNodes[i]; AssertSubMechanismIllustrationPointNode(entity, node); } }
public void Create_ValidTopLevelFaultTreeIllustrationPointWithChildren_ReturnsTopLevelFaultTreeIllustrationPointEntityWithChildren() { // Setup var random = new Random(21); var windDirection = new WindDirection("WindDirection Name", random.NextDouble()); var illustrationPointNode = new IllustrationPointNode(FaultTreeIllustrationPointTestFactory.CreateTestFaultTreeIllustrationPoint()); illustrationPointNode.SetChildren(new[] { new IllustrationPointNode(new TestSubMechanismIllustrationPoint("Point A")), new IllustrationPointNode(new TestSubMechanismIllustrationPoint("Point B")) }); var topLevelIllustrationPoint = new TopLevelFaultTreeIllustrationPoint( windDirection, "Just a situation", illustrationPointNode); int order = random.Next(); // Call TopLevelFaultTreeIllustrationPointEntity entity = topLevelIllustrationPoint.Create(order); // Assert TestHelper.AssertAreEqualButNotSame(topLevelIllustrationPoint.ClosingSituation, entity.ClosingSituation); TestHelper.AssertAreEqualButNotSame(windDirection.Name, entity.WindDirectionName); Assert.AreEqual(windDirection.Angle, entity.WindDirectionAngle, windDirection.Angle.GetAccuracy()); Assert.AreEqual(order, entity.Order); SubMechanismIllustrationPointEntity[] subMechanismIllustrationPointEntities = entity.FaultTreeIllustrationPointEntity.SubMechanismIllustrationPointEntities.ToArray(); Assert.AreEqual(2, subMechanismIllustrationPointEntities.Length); for (var i = 0; i < 2; i++) { var expectedIllustrationPoint = new TestSubMechanismIllustrationPoint(subMechanismIllustrationPointEntities[i].Name); SubMechanismIllustrationPointEntity illustrationPointEntity = subMechanismIllustrationPointEntities[i]; Assert.AreEqual(expectedIllustrationPoint.Name, illustrationPointEntity.Name); Assert.AreEqual(expectedIllustrationPoint.Beta, illustrationPointEntity.Beta, expectedIllustrationPoint.Beta.GetAccuracy()); Assert.AreEqual(expectedIllustrationPoint.IllustrationPointResults.Count(), illustrationPointEntity.IllustrationPointResultEntities.Count); Assert.AreEqual(expectedIllustrationPoint.Stochasts.Count(), illustrationPointEntity.IllustrationPointResultEntities.Count); Assert.AreEqual(i, illustrationPointEntity.Order); } }
/// <summary> /// Reads the <see cref="SubMechanismIllustrationPointEntity"/> and uses /// the information to construct a <see cref="SubMechanismIllustrationPoint"/>. /// </summary> /// <param name="entity">The <see cref="SubMechanismIllustrationPointEntity"/> /// to create a <see cref="SubMechanismIllustrationPoint"/> for.</param> /// <returns>A new <see cref="SubMechanismIllustrationPoint"/>.</returns> /// <exception cref="ArgumentNullException">Thrown when <paramref name="entity"/> /// is <c>null</c>.</exception> internal static SubMechanismIllustrationPoint Read(this SubMechanismIllustrationPointEntity entity) { if (entity == null) { throw new ArgumentNullException(nameof(entity)); } IEnumerable <SubMechanismIllustrationPointStochast> stochasts = GetReadSubMechanismIllustrationPointStochasts(entity.SubMechanismIllustrationPointStochastEntities); IEnumerable <IllustrationPointResult> illustrationPointResults = GetReadIllustrationPointResults(entity.IllustrationPointResultEntities); return(new SubMechanismIllustrationPoint(entity.Name, entity.Beta, stochasts, illustrationPointResults)); }
public void Read_ValidEntityWithoutStochastsAndIllustrationPointResults_ReturnsSubMechanismIllustrationPoint() { // Setup var random = new Random(21); var entity = new SubMechanismIllustrationPointEntity { Name = "Name", Beta = random.NextDouble() }; // Call SubMechanismIllustrationPoint illustrationPoint = entity.Read(); // Assert AssertCommonProperties(entity, illustrationPoint); CollectionAssert.IsEmpty(illustrationPoint.IllustrationPointResults); CollectionAssert.IsEmpty(illustrationPoint.Stochasts); }
public void Read_ValidEntityWithIllustrationPointResults_ReturnsSubMechanismIllustrationPointWithResults() { // Setup var random = new Random(21); var illustrationPointResultEntityOne = new IllustrationPointResultEntity { Description = "Description", Unit = "-", Value = random.NextDouble(), Order = 0 }; var illustrationPointResultEntityTwo = new IllustrationPointResultEntity { Description = "Description_Two", Unit = "m", Value = random.NextDouble(), Order = 1 }; var entity = new SubMechanismIllustrationPointEntity { Name = "Name", Beta = random.NextDouble(), IllustrationPointResultEntities = new[] { illustrationPointResultEntityTwo, illustrationPointResultEntityOne } }; // Call SubMechanismIllustrationPoint illustrationPoint = entity.Read(); // Assert AssertCommonProperties(entity, illustrationPoint); IllustrationPointResult[] illustrationPointResults = illustrationPoint.IllustrationPointResults.ToArray(); Assert.AreEqual(2, illustrationPointResults.Length); AssertReadIllustrationPointResult(illustrationPointResultEntityOne, illustrationPointResults[0]); AssertReadIllustrationPointResult(illustrationPointResultEntityTwo, illustrationPointResults[1]); }
public void Create_MultipleResultsAndValidIllustrationPoint_ReturnSubMechanismIllustrationPointEntityWithResultEntities() { // Setup var random = new Random(21); var illustrationPointResultOne = new IllustrationPointResult("result description", "-", random.NextDouble()); var illustrationPointResultTwo = new IllustrationPointResult("result description two", "kN", random.NextDouble()); IllustrationPointResult[] illustrationPointResults = { illustrationPointResultOne, illustrationPointResultTwo }; var illustrationPoint = new SubMechanismIllustrationPoint("Illustration point name", random.NextDouble(), Enumerable.Empty <SubMechanismIllustrationPointStochast>(), illustrationPointResults); int order = random.Next(); // Call SubMechanismIllustrationPointEntity entity = illustrationPoint.Create(order); // Assert AssertCommonProperties(illustrationPoint, entity); Assert.AreEqual(order, entity.Order); IllustrationPointResultEntity[] resultEntities = entity.IllustrationPointResultEntities.ToArray(); int expectedNrOfIllustrationPoints = illustrationPointResults.Length; Assert.AreEqual(expectedNrOfIllustrationPoints, resultEntities.Length); for (var i = 0; i < expectedNrOfIllustrationPoints; i++) { IllustrationPointResult illustrationPointResult = illustrationPointResults[i]; IllustrationPointResultEntity illustrationPointResultEntity = resultEntities[i]; TestHelper.AssertAreEqualButNotSame(illustrationPointResult.Description, illustrationPointResultEntity.Description); TestHelper.AssertAreEqualButNotSame(illustrationPointResult.Unit, illustrationPointResultEntity.Unit); Assert.AreEqual(illustrationPointResult.Value, illustrationPointResultEntity.Value, illustrationPointResult.Value.GetAccuracy()); Assert.AreEqual(i, illustrationPointResultEntity.Order); } }
public void Create_SubMechanismIllustrationPointWithoutResultsAndStochasts_ReturnSubMechanismIllustrationPointEntityWithoutResultsAndStochastsEntities() { // Setup var random = new Random(21); var illustrationPoint = new SubMechanismIllustrationPoint("Illustration point name", random.NextDouble(), Enumerable.Empty <SubMechanismIllustrationPointStochast>(), Enumerable.Empty <IllustrationPointResult>()); int order = random.Next(); // Call SubMechanismIllustrationPointEntity entity = illustrationPoint.Create(order); // Assert AssertCommonProperties(illustrationPoint, entity); Assert.AreEqual(order, entity.Order); CollectionAssert.IsEmpty(entity.IllustrationPointResultEntities); CollectionAssert.IsEmpty(entity.SubMechanismIllustrationPointStochastEntities); }
/// <summary> /// Creates a <see cref="SubMechanismIllustrationPointEntity"/> based on /// the information of <paramref name="subMechanismIllustrationPoint"/>. /// </summary> /// <param name="subMechanismIllustrationPoint">The sub mechanism illustration /// point to create a database entity for.</param> /// <param name="order">The index at which <paramref name="subMechanismIllustrationPoint"/> /// resides within its parent.</param> /// <returns>A new <see cref="SubMechanismIllustrationPointEntity"/>.</returns> /// <exception cref="ArgumentNullException">Thrown when /// <paramref name="subMechanismIllustrationPoint"/> is <c>null</c>.</exception> internal static SubMechanismIllustrationPointEntity Create( this SubMechanismIllustrationPoint subMechanismIllustrationPoint, int order) { if (subMechanismIllustrationPoint == null) { throw new ArgumentNullException(nameof(subMechanismIllustrationPoint)); } var entity = new SubMechanismIllustrationPointEntity { Beta = subMechanismIllustrationPoint.Beta, Name = subMechanismIllustrationPoint.Name.DeepClone(), Order = order }; AddEntitiesForSubMechanismIllustrationPointsStochasts(entity, subMechanismIllustrationPoint.Stochasts); AddEntitiesForIllustrationPointResults(entity, subMechanismIllustrationPoint.IllustrationPointResults); return(entity); }
public void Read_ValidEntity_ReturnsTopLevelSubMechanismIllustrationPoint() { // Setup var random = new Random(21); var subMechanismIllustrationPointEntity = new SubMechanismIllustrationPointEntity { Name = "Illustration point name", Beta = random.NextDouble() }; var entity = new TopLevelSubMechanismIllustrationPointEntity { ClosingSituation = "closingSituation", WindDirectionName = "WindDirectionName", WindDirectionAngle = random.NextDouble(), SubMechanismIllustrationPointEntity = subMechanismIllustrationPointEntity }; // Call TopLevelSubMechanismIllustrationPoint topLevelSubMechanismIllustrationPoint = entity.Read(); // Assert Assert.AreEqual(entity.ClosingSituation, topLevelSubMechanismIllustrationPoint.ClosingSituation); WindDirection actualWindDirection = topLevelSubMechanismIllustrationPoint.WindDirection; Assert.AreEqual(entity.WindDirectionName, actualWindDirection.Name); Assert.AreEqual(entity.WindDirectionAngle, actualWindDirection.Angle, actualWindDirection.Angle.GetAccuracy()); SubMechanismIllustrationPoint actualIllustrationPoint = topLevelSubMechanismIllustrationPoint.SubMechanismIllustrationPoint; Assert.AreEqual(subMechanismIllustrationPointEntity.Name, actualIllustrationPoint.Name); Assert.AreEqual(subMechanismIllustrationPointEntity.Beta, actualIllustrationPoint.Beta, actualIllustrationPoint.Beta.GetAccuracy()); CollectionAssert.IsEmpty(actualIllustrationPoint.Stochasts); CollectionAssert.IsEmpty(actualIllustrationPoint.IllustrationPointResults); }
private static void AssertCommonProperties(SubMechanismIllustrationPoint illustrationPoint, SubMechanismIllustrationPointEntity entity) { TestHelper.AssertAreEqualButNotSame(illustrationPoint.Name, entity.Name); Assert.AreEqual(illustrationPoint.Beta, entity.Beta, illustrationPoint.Beta.GetAccuracy()); }
private static void AssertCommonProperties(SubMechanismIllustrationPointEntity expectedEntity, SubMechanismIllustrationPoint illustrationPoint) { Assert.AreEqual(expectedEntity.Name, illustrationPoint.Name); Assert.AreEqual(expectedEntity.Beta, illustrationPoint.Beta, illustrationPoint.Beta.GetAccuracy()); }