/// <summary>
/// Reads the <see cref="TopLevelFaultTreeIllustrationPointEntity"/> and
/// uses the information to construct a <see cref="TopLevelFaultTreeIllustrationPoint"/>.
/// </summary>
/// <param name="entity">The <see cref="TopLevelFaultTreeIllustrationPointEntity"/>
/// to create a <see cref="TopLevelFaultTreeIllustrationPoint"/> for.</param>
/// <returns>A new <see cref="TopLevelFaultTreeIllustrationPoint"/>.</returns>
/// <exception cref="ArgumentNullException">Thrown when <paramref name="entity"/>
/// is <c>null</c>.</exception>
public static TopLevelFaultTreeIllustrationPoint Read(this TopLevelFaultTreeIllustrationPointEntity entity)
{
if (entity == null)
{
throw new ArgumentNullException(nameof(entity));
}
WindDirection windDirection = GetWindDirection(entity);
IllustrationPointNode node = entity.FaultTreeIllustrationPointEntity.Read();
return(new TopLevelFaultTreeIllustrationPoint(windDirection, entity.ClosingSituation, node));
}
private static void AssertTopLevelFaultTreeIllustrationPoint(
TopLevelFaultTreeIllustrationPointEntity illustrationPointEntity,
TopLevelFaultTreeIllustrationPoint illustrationPoint)
{
Assert.AreEqual(illustrationPointEntity.ClosingSituation, illustrationPoint.ClosingSituation);
WindDirection actualWindDirection = illustrationPoint.WindDirection;
Assert.AreEqual(illustrationPointEntity.WindDirectionName, actualWindDirection.Name);
Assert.AreEqual(illustrationPointEntity.WindDirectionAngle, actualWindDirection.Angle, actualWindDirection.Angle);
Assert.IsNotNull(illustrationPoint.FaultTreeNodeRoot);
}
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);
}
}
private static void AssertTopLevelIllustrationPointEntity <TTopLevelIllustrationPoint>(
TTopLevelIllustrationPoint illustrationPoint,
TopLevelFaultTreeIllustrationPointEntity illustrationPointEntity,
int expectedOrder)
where TTopLevelIllustrationPoint : TopLevelIllustrationPointBase
{
TestHelper.AssertAreEqualButNotSame(illustrationPoint.ClosingSituation,
illustrationPointEntity.ClosingSituation);
WindDirection expectedWindDirection = illustrationPoint.WindDirection;
TestHelper.AssertAreEqualButNotSame(expectedWindDirection.Name, illustrationPointEntity.WindDirectionName);
Assert.AreEqual(expectedWindDirection.Angle, illustrationPointEntity.WindDirectionAngle,
expectedWindDirection.Angle.GetAccuracy());
TestHelper.AssertAreEqualButNotSame(illustrationPoint.ClosingSituation, illustrationPointEntity.ClosingSituation);
Assert.AreEqual(expectedOrder, illustrationPointEntity.Order);
}
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);
}
public void Create_ValidTopLevelFaultTreeIllustrationPoint_ReturnsTopLevelFaultTreeIllustrationPointEntity()
{
// Setup
var random = new Random(21);
var windDirection = new WindDirection("WindDirection Name", random.NextDouble());
var illustrationPoint = new TopLevelFaultTreeIllustrationPoint(
windDirection,
"Just a situation",
new IllustrationPointNode(FaultTreeIllustrationPointTestFactory.CreateTestFaultTreeIllustrationPoint()));
int order = random.Next();
// Call
TopLevelFaultTreeIllustrationPointEntity entity = illustrationPoint.Create(order);
// Assert
TestHelper.AssertAreEqualButNotSame(illustrationPoint.ClosingSituation, entity.ClosingSituation);
TestHelper.AssertAreEqualButNotSame(windDirection.Name, entity.WindDirectionName);
Assert.AreEqual(windDirection.Angle, entity.WindDirectionAngle, windDirection.Angle.GetAccuracy());
CollectionAssert.IsEmpty(entity.FaultTreeIllustrationPointEntity.SubMechanismIllustrationPointEntities);
CollectionAssert.IsEmpty(entity.FaultTreeIllustrationPointEntity.FaultTreeIllustrationPointEntity1);
Assert.AreEqual(order, entity.Order);
}
private static WindDirection GetWindDirection(TopLevelFaultTreeIllustrationPointEntity entity)
{
return(new WindDirection(entity.WindDirectionName,
entity.WindDirectionAngle));
}
