public void Create_IllustrationPointNodeWithValidChildren_ReturnFaultTreeIllustrationPointEntity(
IEnumerable <IllustrationPointNode> children)
{
// Setup
var random = new Random(21);
var illustrationPoint = new FaultTreeIllustrationPoint("Illustration point name A",
random.NextDouble(),
Enumerable.Empty <Stochast>(),
random.NextEnumValue <CombinationType>());
int order = random.Next();
var node = new IllustrationPointNode(illustrationPoint);
node.SetChildren(children.ToArray());
// Call
FaultTreeIllustrationPointEntity entity = node.Create(order);
// Assert
AssertFaultTreeIllustrationPointEntity(illustrationPoint, entity);
AssertIllustrationPointEntities(node.Children.ToArray(),
entity.SubMechanismIllustrationPointEntities.ToArray(),
entity.FaultTreeIllustrationPointEntity1.ToArray());
Assert.AreEqual(order, entity.Order);
}
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());
}
}
}
public void Create_IllustrationPointNodeWithFaultTreeIllustrationPoint_ReturnFaultTreeIllustrationPointEntity()
{
// Setup
var random = new Random(21);
var illustrationPoint = new FaultTreeIllustrationPoint("Illustration point name",
random.NextDouble(),
Enumerable.Empty <Stochast>(),
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.StochastEntities);
CollectionAssert.IsEmpty(entity.SubMechanismIllustrationPointEntities);
CollectionAssert.IsEmpty(entity.TopLevelFaultTreeIllustrationPointEntities);
Assert.AreEqual(order, entity.Order);
}
private static FaultTreeIllustrationPoint GetFaultTreeIllustrationPoint(FaultTreeIllustrationPointEntity entity)
{
IEnumerable <Stochast> stochasts = GetReadStochasts(entity.StochastEntities);
return(new FaultTreeIllustrationPoint(entity.Name,
entity.Beta,
stochasts,
GetCombinationType(entity)));
}
private static void AssertFaultTreeIllustrationPointEntity(FaultTreeIllustrationPoint illustrationPoint,
FaultTreeIllustrationPointEntity illustrationPointEntity)
{
Assert.IsNotNull(illustrationPoint);
Assert.AreEqual(illustrationPoint.Beta, illustrationPointEntity.Beta, illustrationPoint.Beta.GetAccuracy());
Assert.AreEqual(Convert.ToByte(illustrationPoint.CombinationType), illustrationPointEntity.CombinationType);
TestHelper.AssertAreEqualButNotSame(illustrationPoint.Name, illustrationPointEntity.Name);
CollectionAssert.IsEmpty(illustrationPointEntity.StochastEntities);
}
private static void AddEntitiesForStochasts(FaultTreeIllustrationPointEntity entity,
IEnumerable <Stochast> stochasts)
{
var order = 0;
foreach (Stochast stochast in stochasts)
{
entity.StochastEntities.Add(stochast.Create(order++));
}
}
/// <summary>
/// Reads the <see cref="FaultTreeIllustrationPointEntity"/> and uses
/// the information to construct a <see cref="IllustrationPointNode"/>.
/// </summary>
/// <param name="entity">The <see cref="FaultTreeIllustrationPointEntity"/>
/// to create a <see cref="IllustrationPointNode"/> for.</param>
/// <returns>A new <see cref="IllustrationPointNode"/>.</returns>
/// <exception cref="ArgumentNullException">Thrown when <paramref name="entity"/>
/// is <c>null</c>.</exception>
public static IllustrationPointNode Read(this FaultTreeIllustrationPointEntity entity)
{
if (entity == null)
{
throw new ArgumentNullException(nameof(entity));
}
var node = new IllustrationPointNode(GetFaultTreeIllustrationPoint(entity));
node.SetChildren(GetChildren(entity).ToArray());
return(node);
}
private static void AssertFaultTreeIllustrationPointNode(FaultTreeIllustrationPointEntity entity,
IllustrationPointNode node)
{
var illustrationPoint = node.Data as FaultTreeIllustrationPoint;
Assert.IsNotNull(illustrationPoint);
Assert.AreEqual(entity.Name, illustrationPoint.Name);
Assert.AreEqual(entity.Beta, illustrationPoint.Beta, illustrationPoint.Beta.GetAccuracy());
Assert.AreEqual((CombinationType)entity.CombinationType, illustrationPoint.CombinationType);
AssertStochasts(entity.StochastEntities.ToArray(), illustrationPoint.Stochasts.ToArray());
AssertIllustrationPointNodes(entity.FaultTreeIllustrationPointEntity1, node.Children);
AssertIllustrationPointNodes(entity.SubMechanismIllustrationPointEntities, node.Children);
}
private static FaultTreeIllustrationPointEntity CreateFaultTreeIllustrationPoint(
FaultTreeIllustrationPoint illustrationPoint,
int order)
{
var entity = new FaultTreeIllustrationPointEntity
{
Beta = illustrationPoint.Beta,
CombinationType = Convert.ToByte(illustrationPoint.CombinationType),
Name = illustrationPoint.Name.DeepClone(),
Order = order
};
AddEntitiesForStochasts(entity, illustrationPoint.Stochasts);
return(entity);
}
private static void AssertIllustrationPointNodes(ICollection <FaultTreeIllustrationPointEntity> entities,
IEnumerable <IllustrationPointNode> nodes)
{
FaultTreeIllustrationPointEntity[] entitiesArray = entities.OrderBy(ip => ip.Order).ToArray();
IllustrationPointNode[] faultTreeNodes = nodes.Where(n => n.Data.GetType() == typeof(FaultTreeIllustrationPoint)).ToArray();
Assert.AreEqual(entitiesArray.Length, faultTreeNodes.Length);
for (var i = 0; i < entitiesArray.Length; i++)
{
FaultTreeIllustrationPointEntity entity = entitiesArray[i];
IllustrationPointNode node = faultTreeNodes[i];
AssertFaultTreeIllustrationPointNode(entity, node);
}
}
public void Read_ValidEntityWithIllustrationPoints_ReturnsIllustrationPointNode()
{
// Setup
var random = new Random(21);
var entity = new FaultTreeIllustrationPointEntity
{
Name = "FaultTreeIllustrationPointEntity",
Beta = random.NextDouble(),
CombinationType = Convert.ToByte(random.NextEnumValue <CombinationType>()),
SubMechanismIllustrationPointEntities =
{
new SubMechanismIllustrationPointEntity
{
Name = "SubMechanismIllustrationPointEntity",
Beta = random.NextDouble(),
Order = 10
}
},
FaultTreeIllustrationPointEntity1 =
{
new FaultTreeIllustrationPointEntity
{
Name = "FaultTreeIllustrationPointEntity",
Beta = random.NextDouble(),
CombinationType = Convert.ToByte(random.NextEnumValue <CombinationType>()),
Order = 5
}
}
};
// Call
IllustrationPointNode node = entity.Read();
// Assert
var illustrationPoint = node.Data as FaultTreeIllustrationPoint;
Assert.IsNotNull(illustrationPoint);
Assert.AreEqual(entity.Name, illustrationPoint.Name);
Assert.AreEqual(entity.Beta, illustrationPoint.Beta, illustrationPoint.Beta.GetAccuracy());
Assert.AreEqual((CombinationType)entity.CombinationType, illustrationPoint.CombinationType);
IllustrationPointNode[] children = node.Children.ToArray();
Assert.AreEqual(2, children.Length);
AssertFaultTreeIllustrationPointNode(entity.FaultTreeIllustrationPointEntity1.First(), children[0]);
AssertSubMechanismIllustrationPointNode(entity.SubMechanismIllustrationPointEntities.First(), children[1]);
}
private static IEnumerable <IllustrationPointNode> GetChildren(FaultTreeIllustrationPointEntity entity)
{
foreach (object childEntity in GetChildEntitiesInOrder(entity))
{
var faultTreeIllustrationPointEntity = childEntity as FaultTreeIllustrationPointEntity;
if (faultTreeIllustrationPointEntity != null)
{
yield return(faultTreeIllustrationPointEntity.Read());
}
var subMechanismIllustrationPointEntity = childEntity as SubMechanismIllustrationPointEntity;
if (subMechanismIllustrationPointEntity != null)
{
yield return(new IllustrationPointNode(subMechanismIllustrationPointEntity.Read()));
}
}
}
private static IEnumerable GetChildEntitiesInOrder(FaultTreeIllustrationPointEntity entity)
{
var sortedList = new SortedList();
foreach (FaultTreeIllustrationPointEntity childEntity in entity.FaultTreeIllustrationPointEntity1
.OrderBy(ip => ip.Order))
{
sortedList.Add(childEntity.Order, childEntity);
}
foreach (SubMechanismIllustrationPointEntity childEntity in entity.SubMechanismIllustrationPointEntities
.OrderBy(ip => ip.Order))
{
sortedList.Add(childEntity.Order, childEntity);
}
return(sortedList.Values);
}
public void Read_ValidEntity_ReturnsTopLevelFaultTreeIllustrationPoint()
{
// Setup
var random = new Random(21);
var combinationType = random.NextEnumValue <CombinationType>();
var illustrationPointEntity = new FaultTreeIllustrationPointEntity
{
Name = "Illustration point name",
Beta = random.NextDouble(),
CombinationType = Convert.ToByte(combinationType)
};
var entity = new TopLevelFaultTreeIllustrationPointEntity
{
ClosingSituation = "closingSituation",
WindDirectionName = "WindDirectionName",
WindDirectionAngle = random.NextDouble(),
FaultTreeIllustrationPointEntity = illustrationPointEntity
};
// Call
TopLevelFaultTreeIllustrationPoint topLevelIllustrationPoint = entity.Read();
// Assert
Assert.AreEqual(entity.ClosingSituation, topLevelIllustrationPoint.ClosingSituation);
WindDirection actualWindDirection = topLevelIllustrationPoint.WindDirection;
Assert.AreEqual(entity.WindDirectionName, actualWindDirection.Name);
Assert.AreEqual(entity.WindDirectionAngle, actualWindDirection.Angle,
actualWindDirection.Angle.GetAccuracy());
IllustrationPointNode rootNode = topLevelIllustrationPoint.FaultTreeNodeRoot;
var illustrationPoint = rootNode.Data as FaultTreeIllustrationPoint;
Assert.IsNotNull(illustrationPoint);
Assert.AreEqual(illustrationPointEntity.Beta, illustrationPoint.Beta, illustrationPoint.Beta.GetAccuracy());
Assert.AreEqual(illustrationPointEntity.Name, illustrationPoint.Name);
Assert.AreEqual(combinationType, illustrationPoint.CombinationType);
CollectionAssert.IsEmpty(illustrationPoint.Stochasts);
CollectionAssert.IsEmpty(rootNode.Children);
}
/// <summary>
/// Creates a <see cref="FaultTreeIllustrationPointEntity"/> based on the information
/// of <paramref name="illustrationPointNode"/>.
/// </summary>
/// <param name="illustrationPointNode">The illustration point node to create a database
/// entity for.</param>
/// <param name="order">The index at which <paramref name="illustrationPointNode"/>
/// resides within its parent.</param>
/// <returns>A new <see cref="FaultTreeIllustrationPointEntity"/>.</returns>
/// <exception cref="ArgumentNullException">Thrown when <paramref name="illustrationPointNode"/>
/// is <c>null</c>.</exception>
/// <exception cref="NotSupportedException">Thrown when <see cref="IllustrationPointNode.Data"/>
/// is not of type <see cref="FaultTreeIllustrationPoint"/>.</exception>
public static FaultTreeIllustrationPointEntity Create(
this IllustrationPointNode illustrationPointNode,
int order)
{
if (illustrationPointNode == null)
{
throw new ArgumentNullException(nameof(illustrationPointNode));
}
var faultTreeIllustrationPoint = illustrationPointNode.Data as FaultTreeIllustrationPoint;
if (faultTreeIllustrationPoint == null)
{
throw new NotSupportedException($"Illustration point type '{illustrationPointNode.Data.GetType()}' is not supported.");
}
FaultTreeIllustrationPointEntity entity = CreateFaultTreeIllustrationPoint(faultTreeIllustrationPoint,
order);
CreateChildElements(illustrationPointNode.Children, entity);
return(entity);
}
private static void CreateChildElements(IEnumerable <IllustrationPointNode> illustrationPointNodes,
FaultTreeIllustrationPointEntity entity)
{
var i = 0;
foreach (IllustrationPointNode node in illustrationPointNodes)
{
var faultTreeIllustrationPoint = node.Data as FaultTreeIllustrationPoint;
if (faultTreeIllustrationPoint != null)
{
entity.FaultTreeIllustrationPointEntity1.Add(node.Create(i));
}
var subMechanismIllustrationPoint = node.Data as SubMechanismIllustrationPoint;
if (subMechanismIllustrationPoint != null)
{
entity.SubMechanismIllustrationPointEntities.Add(subMechanismIllustrationPoint.Create(i));
}
i++;
}
}
public void Read_ValidEntityWithStochasts_ReturnsIllustrationPointNode()
{
// Setup
var random = new Random(21);
var combinationType = random.NextEnumValue <CombinationType>();
var entity = new FaultTreeIllustrationPointEntity
{
Name = "FaultTreeIllustrationPointEntity",
Beta = random.NextDouble(),
CombinationType = Convert.ToByte(combinationType),
StochastEntities =
{
new StochastEntity
{
Alpha = random.NextDouble(),
Duration = random.NextDouble(),
Name = "StochastEntity"
}
}
};
// Call
IllustrationPointNode node = entity.Read();
// Assert
var illustrationPoint = node.Data as FaultTreeIllustrationPoint;
Assert.IsNotNull(illustrationPoint);
Assert.AreEqual(entity.Name, illustrationPoint.Name);
Assert.AreEqual(entity.Beta, illustrationPoint.Beta, illustrationPoint.Beta.GetAccuracy());
Assert.AreEqual(combinationType, illustrationPoint.CombinationType);
AssertStochasts(entity.StochastEntities.ToArray(), illustrationPoint.Stochasts.ToArray());
CollectionAssert.IsEmpty(node.Children);
}
private static CombinationType GetCombinationType(FaultTreeIllustrationPointEntity entity)
{
return((CombinationType)entity.CombinationType);
}
