/// <summary>
/// Creates an instance of <see cref="SerializableFailureMechanismAssemblyResult"/>
/// based on <paramref name="result"/>.
/// </summary>
/// <param name="result">The <see cref="ExportableFailureMechanismAssemblyResult"/>
/// to create a <see cref="SerializableFailureMechanismAssemblyResult"/> for.</param>
/// <returns>A <see cref="SerializableFailureMechanismAssemblyResult"/>.</returns>
/// <exception cref="ArgumentNullException">Thrown when <paramref name="result"/>
/// is <c>null</c>.</exception>>
public static SerializableFailureMechanismAssemblyResult Create(ExportableFailureMechanismAssemblyResult result)
{
if (result == null)
{
throw new ArgumentNullException(nameof(result));
}
return(new SerializableFailureMechanismAssemblyResult(
result.Probability, SerializableAssemblyMethodCreator.Create(result.AssemblyMethod)));
}
public void Create_WithExportableFailureMechanismAssemblyResult_ReturnsSerializableFailureMechanismAssemblyResult()
{
// Setup
var random = new Random(21);
var result = new ExportableFailureMechanismAssemblyResult(random.NextDouble(), random.NextEnumValue <ExportableAssemblyMethod>());
// Call
SerializableFailureMechanismAssemblyResult serializableAssemblyResult = SerializableFailureMechanismResultCreator.Create(result);
// Assert
SerializableFailureMechanismAssemblyResultTestHelper.AssertSerializableFailureMechanismAssemblyResult(result, serializableAssemblyResult);
}
private static void AssertExportableFailureMechanism(IFailureMechanism <FailureMechanismSectionResult> failureMechanism,
ExportableFailureMechanismType expectedFailureMechanismType,
ExportableFailureMechanism actualExportableFailureMechanism)
{
Assert.AreEqual(expectedFailureMechanismType, actualExportableFailureMechanism.FailureMechanismType);
Assert.AreEqual(failureMechanism.Code, actualExportableFailureMechanism.Code);
ExportableFailureMechanismAssemblyResult exportableFailureMechanismAssemblyResult = actualExportableFailureMechanism.FailureMechanismAssembly;
Assert.AreEqual(0.1, exportableFailureMechanismAssemblyResult.Probability);
Assert.AreEqual(ExportableAssemblyMethod.BOI1A1, exportableFailureMechanismAssemblyResult.AssemblyMethod);
Assert.AreEqual(failureMechanism.SectionResults.Count(), actualExportableFailureMechanism.SectionAssemblyResults.Count());
}
public void Constructor_ExpectedValues()
{
// Setup
var random = new Random(21);
double probability = random.NextDouble();
var assemblyMethod = random.NextEnumValue <ExportableAssemblyMethod>();
// Call
var assemblyResult = new ExportableFailureMechanismAssemblyResult(probability, assemblyMethod);
// Assert
Assert.AreEqual(probability, assemblyResult.Probability);
Assert.AreEqual(assemblyMethod, assemblyResult.AssemblyMethod);
}
public void CreateExportableFailureMechanism_WithValidData_ReturnsExportableFailureMechanism()
{
// Setup
var random = new Random(21);
var failureMechanism = new TestFailureMechanism();
FailureMechanismTestHelper.AddSections(failureMechanism, random.Next(2, 10));
var assessmentSection = new AssessmentSectionStub();
double probability = random.NextDouble();
var assemblyMethod = random.NextEnumValue <AssemblyMethod>();
FailureMechanismSectionAssemblyResultWrapper expectedSectionOutput = FailureMechanismSectionAssemblyResultWrapperTestFactory.Create();
var failureMechanismType = random.NextEnumValue <ExportableFailureMechanismType>();
// Call
ExportableFailureMechanism exportableFailureMechanism =
ExportableFailureMechanismFactory.CreateExportableFailureMechanism <TestFailureMechanism, TestFailureMechanismSectionResult>(
failureMechanism, assessmentSection, (fm, section) => new FailureMechanismAssemblyResultWrapper(probability, assemblyMethod),
(sr, fm, section) => expectedSectionOutput, failureMechanismType);
// Assert
Assert.AreEqual(failureMechanismType, exportableFailureMechanism.FailureMechanismType);
Assert.AreEqual(failureMechanism.Code, exportableFailureMechanism.Code);
ExportableFailureMechanismAssemblyResult exportableFailureMechanismAssembly = exportableFailureMechanism.FailureMechanismAssembly;
Assert.AreEqual(probability, exportableFailureMechanismAssembly.Probability);
Assert.AreEqual(ExportableAssemblyMethodFactory.Create(assemblyMethod), exportableFailureMechanismAssembly.AssemblyMethod);
IEnumerable <ExportableFailureMechanismSection> exportableFailureMechanismSections = exportableFailureMechanism.SectionAssemblyResults
.Select(sar => sar.FailureMechanismSection);
ExportableFailureMechanismSectionTestHelper.AssertExportableFailureMechanismSections(failureMechanism.Sections, exportableFailureMechanismSections);
ExportableFailureMechanismSectionAssemblyResultTestHelper.AssertExportableFailureMechanismSectionResults(
expectedSectionOutput, exportableFailureMechanismSections, exportableFailureMechanism.SectionAssemblyResults);
}
public void Constructor_ExpectedValues()
{
// Setup
var random = new Random(21);
ExportableFailureMechanismAssemblyResult failureMechanismAssembly =
ExportableFailureMechanismAssemblyResultTestFactory.CreateResult();
IEnumerable <ExportableFailureMechanismSectionAssemblyWithProbabilityResult> sectionAssemblyResults =
Enumerable.Empty <ExportableFailureMechanismSectionAssemblyWithProbabilityResult>();
var failureMechanismType = random.NextEnumValue <ExportableFailureMechanismType>();
const string code = "code";
const string name = "name";
// Call
var failureMechanism = new ExportableFailureMechanism(
failureMechanismAssembly, sectionAssemblyResults, failureMechanismType, code, name);
// Assert
Assert.AreSame(failureMechanismAssembly, failureMechanism.FailureMechanismAssembly);
Assert.AreSame(sectionAssemblyResults, failureMechanism.SectionAssemblyResults);
Assert.AreEqual(failureMechanismType, failureMechanism.FailureMechanismType);
Assert.AreEqual(code, failureMechanism.Code);
Assert.AreEqual(name, failureMechanism.Name);
}
/// <summary>
/// Asserts a <see cref="SerializableFailureMechanismAssemblyResult"/> against an
/// <see cref="ExportableFailureMechanismAssemblyResult"/>.
/// </summary>
/// <param name="expectedResult">The <see cref="ExportableFailureMechanismAssemblyResult"/> to assert against.</param>
/// <param name="actualResult">The <see cref="SerializableFailureMechanismAssemblyResult"/> to assert.</param>
/// <exception cref="AssertionException">Thrown when:
/// <list type="bullet">
/// <item>The assembly methods do not match, </item>
/// <item>The probabilities do not match.</item>
/// </list></exception>
public static void AssertSerializableFailureMechanismAssemblyResult(ExportableFailureMechanismAssemblyResult expectedResult,
SerializableFailureMechanismAssemblyResult actualResult)
{
Assert.AreEqual(expectedResult.Probability, actualResult.Probability);
Assert.AreEqual(SerializableAssemblyMethodCreator.Create(expectedResult.AssemblyMethod), actualResult.AssemblyMethod);
}
