/// <summary>
/// Creates an instance of <see cref="SerializableFailureMechanismSectionAssemblyResult"/>
/// based on its input parameters.
/// </summary>
/// <param name="sectionResult">The <see cref="ExportableFailureMechanismSectionAssemblyWithProbabilityResult"/> to create a
/// <see cref="SerializableFailureMechanismSectionAssemblyResult"/> for.</param>
/// <returns>A <see cref="SerializableFailureMechanismSectionAssemblyResult"/>.</returns>
/// <exception cref="ArgumentNullException">Thrown when <paramref name="sectionResult"/> is <c>null</c>.</exception>
/// <exception cref="AssemblyCreatorException">Thrown when <paramref name="sectionResult"/> is invalid to
/// create a serializable counterpart for.</exception>
public static SerializableFailureMechanismSectionAssemblyResult Create(ExportableFailureMechanismSectionAssemblyWithProbabilityResult sectionResult)
{
if (sectionResult == null)
{
throw new ArgumentNullException(nameof(sectionResult));
}
ValidateAssemblyResult(sectionResult);
return(new SerializableFailureMechanismSectionAssemblyResult(
SerializableAssemblyMethodCreator.Create(sectionResult.ProbabilityAssemblyMethod),
SerializableAssemblyMethodCreator.Create(sectionResult.AssemblyGroupAssemblyMethod),
SerializableFailureMechanismSectionAssemblyGroupCreator.Create(sectionResult.AssemblyGroup),
sectionResult.Probability));
}
/// <summary>
/// Creates an instance of <see cref="AggregatedSerializableFailureMechanismSectionAssembly"/> based on its input parameters.
/// </summary>
/// <param name="idGenerator">The id generator to generate the id for the serializable components.</param>
/// <param name="serializableFailureMechanism">The <see cref="SerializableFailureMechanism"/> the section assembly belongs to.</param>
/// <param name="serializableCollection">The <see cref="SerializableFailureMechanismSectionCollection"/> the section assembly belongs to.</param>
/// <param name="failureMechanismSectionAssemblyResult">An aggregated failure mechanism section assembly result to
/// create an <see cref="AggregatedSerializableFailureMechanismSectionAssembly"/> for.</param>
/// <returns>An <see cref="AggregatedSerializableFailureMechanismSectionAssembly"/>.</returns>
/// <exception cref="AssemblyCreatorException">Thrown when <paramref name="failureMechanismSectionAssemblyResult"/> is invalid to create a serializable counterpart for.</exception>
/// <exception cref="NotSupportedException">Thrown when an <see cref="AggregatedSerializableFailureMechanismSectionAssembly"/>
/// cannot be created for <paramref name="failureMechanismSectionAssemblyResult"/>.</exception>
private static AggregatedSerializableFailureMechanismSectionAssembly CreateFailureMechanismSectionAssembly(
IdentifierGenerator idGenerator,
SerializableFailureMechanism serializableFailureMechanism,
SerializableFailureMechanismSectionCollection serializableCollection,
ExportableFailureMechanismSectionAssemblyWithProbabilityResult failureMechanismSectionAssemblyResult)
{
SerializableFailureMechanismSection failureMechanismSection = SerializableFailureMechanismSectionCreator.Create(
idGenerator, serializableCollection, failureMechanismSectionAssemblyResult.FailureMechanismSection);
var failureMechanismSectionAssembly = new SerializableFailureMechanismSectionAssembly(
idGenerator.GetNewId(Resources.SerializableFailureMechanismSectionAssembly_IdPrefix),
serializableFailureMechanism, failureMechanismSection,
SerializableFailureMechanismSectionAssemblyResultCreator.Create(failureMechanismSectionAssemblyResult));
return(new AggregatedSerializableFailureMechanismSectionAssembly(failureMechanismSection, failureMechanismSectionAssembly));
}
public void Create_SectionResultHasInvalidAssemblyGroup_ThrowsAssemblyCreatorException(FailureMechanismSectionAssemblyGroup assemblyGroup)
{
// Setup
var random = new Random(21);
var sectionResult = new ExportableFailureMechanismSectionAssemblyWithProbabilityResult(
ExportableFailureMechanismSectionTestFactory.CreateExportableFailureMechanismSection(),
assemblyGroup, random.NextDouble(), random.NextEnumValue <ExportableAssemblyMethod>(),
random.NextEnumValue <ExportableAssemblyMethod>());
// Call
void Call() => SerializableFailureMechanismSectionAssemblyResultCreator.Create(sectionResult);
// Assert
var exception = Assert.Throws <AssemblyCreatorException>(Call);
Assert.AreEqual("The assembly result is invalid and cannot be created.", exception.Message);
}
public void Create_ValidData_ReturnsSerializableFailureMechanismAssemblyResult()
{
// Setup
ExportableFailureMechanismSectionAssemblyWithProbabilityResult sectionResult = ExportableFailureMechanismSectionAssemblyResultTestFactory.CreateWithProbability(
ExportableFailureMechanismSectionTestFactory.CreateExportableFailureMechanismSection(), 21);
// Call
SerializableFailureMechanismSectionAssemblyResult serializableAssemblyResult = SerializableFailureMechanismSectionAssemblyResultCreator.Create(sectionResult);
// Assert
Assert.AreEqual(SerializableAssemblyMethodCreator.Create(sectionResult.ProbabilityAssemblyMethod),
serializableAssemblyResult.ProbabilityAssemblyMethod);
Assert.AreEqual(SerializableAssemblyMethodCreator.Create(sectionResult.AssemblyGroupAssemblyMethod),
serializableAssemblyResult.AssemblyGroupAssemblyMethod);
Assert.AreEqual(SerializableFailureMechanismSectionAssemblyGroupCreator.Create(
sectionResult.AssemblyGroup), serializableAssemblyResult.AssemblyGroup);
Assert.AreEqual(sectionResult.Probability, serializableAssemblyResult.Probability);
}
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);
}
}
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 assemblyGroupAssemblyMethod = random.NextEnumValue <ExportableAssemblyMethod>();
var probabilityAssemblyMethod = random.NextEnumValue <ExportableAssemblyMethod>();
double probability = random.NextDouble();
// Call
var result = new ExportableFailureMechanismSectionAssemblyWithProbabilityResult(
section, assemblyGroup, probability, assemblyGroupAssemblyMethod, probabilityAssemblyMethod);
// Assert
Assert.IsInstanceOf <ExportableFailureMechanismSectionAssemblyResult>(result);
Assert.AreSame(section, result.FailureMechanismSection);
Assert.AreEqual(assemblyGroup, result.AssemblyGroup);
Assert.AreEqual(assemblyGroupAssemblyMethod, result.AssemblyGroupAssemblyMethod);
Assert.AreEqual(probabilityAssemblyMethod, result.ProbabilityAssemblyMethod);
Assert.AreEqual(probability, result.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);
}
}
