/// <summary>
/// Creates a <see cref="SerializableFailureMechanismSection"/> based on
/// its input parameters.
/// </summary>
/// <param name="idGenerator">The generator to generate an id
/// for the <see cref="SerializableFailureMechanismSection"/>.</param>
/// <param name="serializableCollection">The <see cref="SerializableFailureMechanismSectionCollection"/>
/// this section belongs to.</param>
/// <param name="section">The <see cref="ExportableFailureMechanismSection"/>
/// to create a <see cref="SerializableFailureMechanismSection"/> for.</param>
/// <returns>A <see cref="SerializableFailureMechanismSection"/>.</returns>
/// <exception cref="ArgumentNullException">Thrown when any parameter is <c>null</c>.</exception>
public static SerializableFailureMechanismSection Create(IdentifierGenerator idGenerator,
SerializableFailureMechanismSectionCollection serializableCollection,
ExportableFailureMechanismSection section)
{
if (idGenerator == null)
{
throw new ArgumentNullException(nameof(idGenerator));
}
if (serializableCollection == null)
{
throw new ArgumentNullException(nameof(serializableCollection));
}
if (section == null)
{
throw new ArgumentNullException(nameof(section));
}
return(new SerializableFailureMechanismSection(idGenerator.GetNewId(Resources.SerializableFailureMechanismSection_IdPrefix),
serializableCollection,
section.StartDistance,
section.EndDistance,
section.Geometry,
SerializableFailureMechanismSectionType.FailureMechanism));
}
/// <summary>
/// Creates a lookup between failure mechanism section results and the corresponding
/// <see cref="ExportableFailureMechanismSection"/>.
/// </summary>
/// <typeparam name="TSectionResult">The type of <see cref="FailureMechanismSectionResult"/>.</typeparam>
/// <param name="failureMechanismSectionResults">The failure mechanism sections results to create a
/// <see cref="ExportableFailureMechanismSection"/> for.</param>
/// <returns>A <see cref="IDictionary{TKey,TValue}"/> between the failure mechanism section results
/// and <see cref="ExportableFailureMechanismSection"/>.</returns>
/// <exception cref="ArgumentNullException">Thrown when <paramref name="failureMechanismSectionResults"/> is <c>null</c>.</exception>
public static IDictionary <TSectionResult, ExportableFailureMechanismSection> CreateFailureMechanismSectionResultLookup <TSectionResult>(
IEnumerable <TSectionResult> failureMechanismSectionResults)
where TSectionResult : FailureMechanismSectionResult
{
if (failureMechanismSectionResults == null)
{
throw new ArgumentNullException(nameof(failureMechanismSectionResults));
}
var failureMechanismSectionsLookup = new Dictionary <TSectionResult, ExportableFailureMechanismSection>();
double startDistance = 0;
foreach (TSectionResult sectionResult in failureMechanismSectionResults)
{
FailureMechanismSection failureMechanismSection = sectionResult.Section;
double endDistance = startDistance + failureMechanismSection.Length;
failureMechanismSectionsLookup[sectionResult] = new ExportableFailureMechanismSection(failureMechanismSection.Points,
startDistance,
endDistance);
startDistance = endDistance;
}
return(failureMechanismSectionsLookup);
}
public void CreateFailureMechanismSectionResultLookup_WithFailureMechanismSectionResults_ReturnsExpectedDictionary()
{
// Setup
var failureMechanismSectionResults = new[]
{
new TestFailureMechanismSectionResult(FailureMechanismSectionTestFactory.CreateFailureMechanismSection(new[]
{
new Point2D(0, 0),
new Point2D(0, 10)
})),
new TestFailureMechanismSectionResult(FailureMechanismSectionTestFactory.CreateFailureMechanismSection(new[]
{
new Point2D(0, 10),
new Point2D(0, 20)
})),
new TestFailureMechanismSectionResult(FailureMechanismSectionTestFactory.CreateFailureMechanismSection(new[]
{
new Point2D(0, 20),
new Point2D(0, 40)
}))
};
// Call
IDictionary <TestFailureMechanismSectionResult, ExportableFailureMechanismSection> failureMechanismSectionResultsLookup =
ExportableFailureMechanismSectionHelper.CreateFailureMechanismSectionResultLookup(failureMechanismSectionResults);
// Assert
CollectionAssert.AreEqual(failureMechanismSectionResults, failureMechanismSectionResultsLookup.Keys);
TestFailureMechanismSectionResult firstSectionResult = failureMechanismSectionResults[0];
ExportableFailureMechanismSection firstExportableSection = failureMechanismSectionResultsLookup[firstSectionResult];
Assert.AreSame(firstSectionResult.Section.Points, firstExportableSection.Geometry);
Assert.AreEqual(0, firstExportableSection.StartDistance);
Assert.AreEqual(10, firstExportableSection.EndDistance);
TestFailureMechanismSectionResult secondSectionResult = failureMechanismSectionResults[1];
ExportableFailureMechanismSection secondExportableSection = failureMechanismSectionResultsLookup[secondSectionResult];
Assert.AreSame(secondSectionResult.Section.Points, secondExportableSection.Geometry);
Assert.AreEqual(10, secondExportableSection.StartDistance);
Assert.AreEqual(20, secondExportableSection.EndDistance);
TestFailureMechanismSectionResult thirdSectionResult = failureMechanismSectionResults[2];
ExportableFailureMechanismSection thirdExportableSection = failureMechanismSectionResultsLookup[thirdSectionResult];
Assert.AreSame(thirdSectionResult.Section.Points, thirdExportableSection.Geometry);
Assert.AreEqual(20, thirdExportableSection.StartDistance);
Assert.AreEqual(40, thirdExportableSection.EndDistance);
}
private static ExportableFailureMechanism CreateFailureMechanism()
{
var random = new Random(21);
ExportableFailureMechanismSection failureMechanismSection = ExportableFailureMechanismSectionTestFactory.CreateExportableFailureMechanismSection();
return(new ExportableFailureMechanism(
ExportableFailureMechanismAssemblyResultTestFactory.CreateResult(),
new[]
{
ExportableFailureMechanismSectionAssemblyResultTestFactory.CreateWithProbability(failureMechanismSection, random.Next())
},
random.NextEnumValue <ExportableFailureMechanismType>(),
"code",
"name"));
}
public void Constructor_SectionNull_ThrowsArgumentNullException()
{
// Setup
ExportableFailureMechanismSection section = ExportableFailureMechanismSectionTestFactory.CreateExportableFailureMechanismSection();
ExportableFailureMechanismSectionAssemblyResult combinedAssemblyResult = ExportableFailureMechanismSectionAssemblyResultTestFactory.Create(section, 21);
// Call
void Call() => new ExportableCombinedSectionAssembly(
null, combinedAssemblyResult, Enumerable.Empty <ExportableFailureMechanismCombinedSectionAssemblyResult>());
// Assert
var exception = Assert.Throws <ArgumentNullException>(Call);
Assert.AreEqual("section", exception.ParamName);
}
/// <summary>
/// Asserts a <see cref="SerializableFailureMechanismSection"/> against
/// an <see cref="ExportableFailureMechanismSection"/>.
/// </summary>
/// <param name="expectedSection">The <see cref="ExportableFailureMechanismSection"/> to assert against.</param>
/// <param name="expectedCollection">The <see cref="SerializableFailureMechanismSectionCollection"/> the section belongs to.</param>
/// <param name="actualSerializableSection">The <see cref="SerializableFailureMechanismSection"/> to assert.</param>
/// <param name="expectedId">The expected id for the <see cref="SerializableFailureMechanismSection"/>.</param>
/// <exception cref="AssertionException">Thrown when:
/// <list type="bullet">
/// <item>The id does not match with the expected id.</item>
/// <item>The id of the failure mechanism section collection does not match.</item>
/// <item>The geometry, start distance or the end distance of the failure mechanism section does not match.</item>
/// <item>The failure mechanism section type does not match.</item>
/// <item>The used assembly method to obtain the section does not match.</item>
/// </list>
/// </exception>
public static void AssertFailureMechanismSection(ExportableFailureMechanismSection expectedSection,
SerializableFailureMechanismSectionCollection expectedCollection,
SerializableFailureMechanismSection actualSerializableSection,
int expectedId = 0)
{
Assert.AreEqual($"Bv.{expectedId}", actualSerializableSection.Id);
Assert.AreEqual(expectedCollection.Id, actualSerializableSection.FailureMechanismSectionCollectionId);
Assert.AreEqual(GeometrySerializationFormatter.Format(expectedSection.Geometry),
actualSerializableSection.Geometry.LineString.Geometry);
Assert.AreEqual(expectedSection.StartDistance, actualSerializableSection.StartDistance.Value);
Assert.AreEqual(expectedSection.EndDistance, actualSerializableSection.EndDistance.Value);
Assert.AreEqual(SerializableFailureMechanismSectionType.FailureMechanism,
actualSerializableSection.FailureMechanismSectionType);
Assert.IsNull(actualSerializableSection.AssemblyMethod);
}
public void Constructor_WithGeometry_ExpectedValues()
{
// Setup
var random = new Random(21);
IEnumerable <Point2D> geometry = Enumerable.Empty <Point2D>();
double startDistance = random.NextDouble();
double endDistance = random.NextDouble();
// Call
var section = new ExportableFailureMechanismSection(geometry, startDistance, endDistance);
// Assert
Assert.AreSame(geometry, section.Geometry);
Assert.AreEqual(startDistance, section.StartDistance);
Assert.AreEqual(endDistance, section.EndDistance);
}
public void Constructor_ExpectedValues()
{
// Setup
var random = new Random(21);
var section = new ExportableFailureMechanismSection(Enumerable.Empty <Point2D>(), random.NextDouble(), random.NextDouble());
var assemblyGroup = random.NextEnumValue <FailureMechanismSectionAssemblyGroup>();
var assemblyMethod = random.NextEnumValue <ExportableAssemblyMethod>();
// Call
var result = new ExportableFailureMechanismSectionAssemblyResult(section, assemblyGroup, assemblyMethod);
// Assert
Assert.AreSame(section, result.FailureMechanismSection);
Assert.AreEqual(assemblyGroup, result.AssemblyGroup);
Assert.AreEqual(assemblyMethod, result.AssemblyGroupAssemblyMethod);
}
public void Create_WithSection_ReturnsSerializableFailureMechanismSection()
{
// Setup
const string collectionId = "collectionId";
var collection = new SerializableFailureMechanismSectionCollection(collectionId);
var idGenerator = new IdentifierGenerator();
ExportableFailureMechanismSection section = ExportableFailureMechanismSectionTestFactory.CreateExportableFailureMechanismSection();
// Call
SerializableFailureMechanismSection serializableSection =
SerializableFailureMechanismSectionCreator.Create(idGenerator, collection, section);
// Assert
SerializableFailureMechanismSectionTestHelper.AssertFailureMechanismSection(section, collection, serializableSection);
}
/// <summary>
/// Creates a new instance of <see cref="ExportableFailureMechanismSectionAssemblyResult"/>.
/// </summary>
/// <param name="section">The <see cref="ExportableFailureMechanismSection"/>.</param>
/// <param name="seed">The seed to use.</param>
/// <returns>The created <see cref="ExportableFailureMechanismSectionAssemblyResult"/></returns>
public static ExportableFailureMechanismSectionAssemblyResult Create(
ExportableFailureMechanismSection section, int seed)
{
var random = new Random(seed);
return(new ExportableFailureMechanismSectionAssemblyResult(
section,
random.NextEnumValue(new[]
{
FailureMechanismSectionAssemblyGroup.NotDominant,
FailureMechanismSectionAssemblyGroup.III,
FailureMechanismSectionAssemblyGroup.II,
FailureMechanismSectionAssemblyGroup.I,
FailureMechanismSectionAssemblyGroup.Zero,
FailureMechanismSectionAssemblyGroup.IMin,
FailureMechanismSectionAssemblyGroup.IIMin,
FailureMechanismSectionAssemblyGroup.IIIMin,
FailureMechanismSectionAssemblyGroup.NotRelevant
}),
random.NextEnumValue <ExportableAssemblyMethod>()));
}
private static void AssertFailureMechanismSectionAssemblies(
ExportableFailureMechanism expectedFailureMechanism,
SerializableFailureMechanismSectionCollection expectedSerializableFailureMechanismSectionCollection,
SerializableFailureMechanism expectedSerializableFailureMechanism,
IEnumerable <SerializableFailureMechanismSection> serializableFailureMechanismSections,
IEnumerable <SerializableFailureMechanismSectionAssembly> serializableFailureMechanismSectionAssemblies)
{
IEnumerable <ExportableFailureMechanismSection> expectedSections = expectedFailureMechanism.SectionAssemblyResults.Select(sar => sar.FailureMechanismSection);
int expectedNrOfSections = expectedSections.Count();
Assert.AreEqual(expectedNrOfSections, serializableFailureMechanismSections.Count());
IEnumerable <ExportableFailureMechanismSectionAssemblyWithProbabilityResult> expectedSectionAssemblyResults = expectedFailureMechanism.SectionAssemblyResults;
Assert.AreEqual(expectedSectionAssemblyResults.Count(), serializableFailureMechanismSectionAssemblies.Count());
var sectionId = 0;
var sectionAssemblyId = 0;
for (var i = 0; i < expectedNrOfSections; i++)
{
ExportableFailureMechanismSection expectedSection = expectedSections.ElementAt(i);
SerializableFailureMechanismSection actualSection = serializableFailureMechanismSections.ElementAt(i);
SerializableFailureMechanismSectionTestHelper.AssertFailureMechanismSection(expectedSection,
expectedSerializableFailureMechanismSectionCollection,
actualSection,
sectionId++);
ExportableFailureMechanismSectionAssemblyWithProbabilityResult expectedSectionAssemblyResult = expectedSectionAssemblyResults.ElementAt(i);
SerializableFailureMechanismSectionAssembly actualSectionAssemblyResult = serializableFailureMechanismSectionAssemblies.ElementAt(i);
Assert.AreEqual($"Fa.{sectionAssemblyId++}", actualSectionAssemblyResult.Id);
Assert.AreEqual(expectedSerializableFailureMechanism.Id, actualSectionAssemblyResult.FailureMechanismId);
Assert.AreEqual(actualSection.Id, actualSectionAssemblyResult.FailureMechanismSectionId);
Assert.AreEqual(SerializableFailureMechanismSectionAssemblyGroupCreator.Create(
expectedSectionAssemblyResult.AssemblyGroup), actualSectionAssemblyResult.SectionResult.AssemblyGroup);
Assert.AreEqual(expectedSectionAssemblyResult.Probability, actualSectionAssemblyResult.SectionResult.Probability);
}
}
/// <summary>
/// Asserts a collection of <see cref="ExportableFailureMechanismSectionAssemblyWithProbabilityResult"/>
/// against the assembly result.
/// </summary>
/// <param name="expectedAssemblyResultWrapper">The expected <see cref="FailureMechanismSectionAssemblyResultWrapper"/>.</param>
/// <param name="sections">The actual exportable sections.</param>
/// <param name="results">The actual exportable assembly results.</param>
/// <exception cref="AssertionException">Thrown when:
/// <list type="bullet">
/// <item>The number of <paramref name="sections"/> and number of <paramref name="results"/> do not match.</item>
/// <item>The values between <paramref name="expectedAssemblyResultWrapper"/> and <paramref name="results"/>
/// do not match.</item>
/// </list></exception>
public static void AssertExportableFailureMechanismSectionResults(FailureMechanismSectionAssemblyResultWrapper expectedAssemblyResultWrapper,
IEnumerable <ExportableFailureMechanismSection> sections,
IEnumerable <ExportableFailureMechanismSectionAssemblyWithProbabilityResult> results)
{
int expectedNrOfResults = sections.Count();
Assert.AreEqual(expectedNrOfResults, results.Count());
for (var i = 0; i < expectedNrOfResults; i++)
{
ExportableFailureMechanismSection section = sections.ElementAt(i);
ExportableFailureMechanismSectionAssemblyWithProbabilityResult actualExportableAssemblyResult = results.ElementAt(i);
Assert.AreSame(section, actualExportableAssemblyResult.FailureMechanismSection);
FailureMechanismSectionAssemblyResult expectedAssemblyResult = expectedAssemblyResultWrapper.AssemblyResult;
Assert.AreEqual(expectedAssemblyResult.FailureMechanismSectionAssemblyGroup, actualExportableAssemblyResult.AssemblyGroup);
Assert.AreEqual(expectedAssemblyResult.SectionProbability, actualExportableAssemblyResult.Probability);
Assert.AreEqual(ExportableAssemblyMethodFactory.Create(expectedAssemblyResultWrapper.AssemblyGroupMethod),
actualExportableAssemblyResult.AssemblyGroupAssemblyMethod);
Assert.AreEqual(ExportableAssemblyMethodFactory.Create(expectedAssemblyResultWrapper.ProbabilityMethod),
actualExportableAssemblyResult.ProbabilityAssemblyMethod);
}
}
/// <summary>
/// Asserts a collection of <see cref="ExportableFailureMechanismSection"/>
/// against a collection of <see cref="FailureMechanismSection"/>.
/// </summary>
/// <param name="expectedSections">The expected collection of <see cref="FailureMechanismSection"/>.</param>
/// <param name="actualSections">The actual <see cref="ExportableFailureMechanismSection"/> to assert against.</param>
/// <exception cref="AssertionException">Thrown when:
/// <list type="bullet">
/// <item>The number of sections between <paramref name="expectedSections"/> and <paramref name="actualSections"/>
/// do not match. </item>
/// <item>The geometry of any the sections are not equal.</item>
/// </list></exception>
public static void AssertExportableFailureMechanismSections(IEnumerable <FailureMechanismSection> expectedSections,
IEnumerable <ExportableFailureMechanismSection> actualSections)
{
int expectedNrOfSections = expectedSections.Count();
Assert.AreEqual(expectedNrOfSections, actualSections.Count());
double expectedStartDistance = 0;
for (var i = 0; i < expectedNrOfSections; i++)
{
FailureMechanismSection expectedSection = expectedSections.ElementAt(i);
ExportableFailureMechanismSection actualSection = actualSections.ElementAt(i);
double expectedEndDistance = expectedStartDistance + Math2D.Length(expectedSection.Points);
Assert.AreEqual(expectedStartDistance, actualSection.StartDistance);
Assert.AreEqual(expectedEndDistance, actualSection.EndDistance);
CollectionAssert.AreEqual(expectedSection.Points, actualSection.Geometry);
expectedStartDistance = expectedEndDistance;
}
}
