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());
}
