private static ExportableFailureMechanismCombinedSectionAssemblyResult CreateExportableFailureMechanismCombinedSectionAssemblyResult(
FailureMechanismSectionAssemblyGroup sectionAssemblyGroup, AssemblyMethod assemblyMethod,
ExportableFailureMechanismType failureMechanismType, string failureMechanismCode, string failureMechanismName)
{
return(new ExportableFailureMechanismCombinedSectionAssemblyResult(
new ExportableFailureMechanismSubSectionAssemblyResult(sectionAssemblyGroup, ExportableAssemblyMethodFactory.Create(assemblyMethod)),
failureMechanismType, failureMechanismCode, failureMechanismName));
}
private static void AssertSubSection(FailureMechanismSectionAssemblyGroup?subSectionGroup, string subSectionCode,
ExportableFailureMechanismType failureMechanismType,
ExportableFailureMechanismCombinedSectionAssemblyResult actualResult)
{
Assert.AreEqual(subSectionGroup, actualResult.SectionAssemblyResult.AssemblyGroup);
Assert.AreEqual(subSectionCode, actualResult.Code);
Assert.AreEqual(failureMechanismType, actualResult.FailureMechanismType);
}
public void Create_WithFailureMechanismType_ReturnsExpectedValues(
ExportableFailureMechanismType failureMechanismType, SerializableFailureMechanismType expectedFailureMechanismType)
{
// Call
SerializableFailureMechanismType serializableFailureMechanismType = SerializableFailureMechanismTypeCreator.Create(
failureMechanismType);
// Assert
Assert.AreEqual(expectedFailureMechanismType, serializableFailureMechanismType);
}
public void Create_InvalidFailureMechanismType_ThrowInvalidEnumArgumentException()
{
// Setup
const ExportableFailureMechanismType failureMechanismType = (ExportableFailureMechanismType)999;
// Call
void Call() => SerializableFailureMechanismTypeCreator.Create(failureMechanismType);
// Assert
var message = $"The value of argument 'failureMechanismType' ({failureMechanismType}) is invalid for Enum type '{nameof(ExportableFailureMechanismType)}'.";
TestHelper.AssertThrowsArgumentExceptionAndTestMessage <InvalidEnumArgumentException>(Call, message);
}
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());
}
private static void AddFailureMechanismWhenInAssembly <TFailureMechanism, TSectionResult>(
List <ExportableFailureMechanism> exportableFailureMechanisms, TFailureMechanism failureMechanism, IAssessmentSection assessmentSection,
Func <TFailureMechanism, IAssessmentSection, FailureMechanismAssemblyResultWrapper> assembleFailureMechanismFunc,
Func <TSectionResult, TFailureMechanism, IAssessmentSection, FailureMechanismSectionAssemblyResultWrapper> assembleFailureMechanismSectionFunc,
ExportableFailureMechanismType failureMechanismType)
where TFailureMechanism : IFailureMechanism <TSectionResult>
where TSectionResult : FailureMechanismSectionResult
{
if (failureMechanism.InAssembly)
{
exportableFailureMechanisms.Add(
ExportableFailureMechanismFactory.CreateExportableFailureMechanism(
failureMechanism, assessmentSection, assembleFailureMechanismFunc, assembleFailureMechanismSectionFunc, failureMechanismType));
}
}
/// <summary>
/// Creates a new instance of <see cref="ExportableFailureMechanismCombinedSectionAssemblyResult"/>
/// </summary>
/// <param name="sectionAssemblyResult">The assembly result of the combined section.</param>
/// <param name="failureMechanismType">The type of the failure mechanism.</param>
/// <param name="code">The code of the failure mechanism.</param>
/// <param name="name">The name of the failure mechanism.</param>
/// <exception cref="ArgumentNullException">Thrown when <paramref name="sectionAssemblyResult"/> is <c>null</c>.</exception>
public ExportableFailureMechanismCombinedSectionAssemblyResult(ExportableFailureMechanismSubSectionAssemblyResult sectionAssemblyResult,
ExportableFailureMechanismType failureMechanismType,
string code,
string name)
{
if (sectionAssemblyResult == null)
{
throw new ArgumentNullException(nameof(sectionAssemblyResult));
}
SectionAssemblyResult = sectionAssemblyResult;
FailureMechanismType = failureMechanismType;
Code = code;
Name = name;
}
/// <summary>
/// Creates a new instance of <see cref="ExportableFailureMechanism"/>.
/// </summary>
/// <param name="failureMechanismAssembly">The assembly result of the failure mechanism.</param>
/// <param name="sectionAssemblyResults">The assembly results for the failure mechanism sections.</param>
/// <param name="failureMechanismType">The type of the failure mechanism.</param>
/// <param name="code">The code of the failure mechanism.</param>
/// <param name="name">The name of the failure mechanism.</param>
/// <exception cref="ArgumentNullException">Thrown when <paramref name="failureMechanismAssembly"/>
/// or <paramref name="sectionAssemblyResults"/> is <c>null</c>.</exception>
public ExportableFailureMechanism(ExportableFailureMechanismAssemblyResult failureMechanismAssembly,
IEnumerable <ExportableFailureMechanismSectionAssemblyWithProbabilityResult> sectionAssemblyResults,
ExportableFailureMechanismType failureMechanismType, string code, string name)
{
if (failureMechanismAssembly == null)
{
throw new ArgumentNullException(nameof(failureMechanismAssembly));
}
if (sectionAssemblyResults == null)
{
throw new ArgumentNullException(nameof(sectionAssemblyResults));
}
FailureMechanismAssembly = failureMechanismAssembly;
SectionAssemblyResults = sectionAssemblyResults;
FailureMechanismType = failureMechanismType;
Code = code;
Name = name;
}
/// <summary>
/// Creates a <see cref="SerializableFailureMechanismType"/> based on <paramref name="failureMechanismType"/>.
/// </summary>
/// <param name="failureMechanismType">The <see cref="ExportableFailureMechanismType"/> to
/// create a <see cref="SerializableFailureMechanismType"/> for.</param>
/// <returns>A <see cref="SerializableFailureMechanismType"/>.</returns>
/// <exception cref="InvalidEnumArgumentException">Thrown when <paramref name="failureMechanismType"/>
/// is an invalid value.</exception>
/// <exception cref="NotSupportedException">Thrown when <paramref name="failureMechanismType"/>
/// is a valid value, but unsupported.</exception>
public static SerializableFailureMechanismType Create(ExportableFailureMechanismType failureMechanismType)
{
if (!Enum.IsDefined(typeof(ExportableFailureMechanismType), failureMechanismType))
{
throw new InvalidEnumArgumentException(nameof(failureMechanismType),
(int)failureMechanismType,
typeof(ExportableFailureMechanismType));
}
switch (failureMechanismType)
{
case ExportableFailureMechanismType.Generic:
return(SerializableFailureMechanismType.Generic);
case ExportableFailureMechanismType.Specific:
return(SerializableFailureMechanismType.Specific);
default:
throw new NotSupportedException();
}
}
/// <summary>
/// Creates an <see cref="ExportableFailureMechanism"/>
/// with assembly results based on the input parameters.
/// </summary>
/// <param name="failureMechanism">The failure mechanism to create an <see cref="ExportableFailureMechanism"/> for.</param>
/// <param name="assessmentSection">The assessment section the failure mechanism belongs to.</param>
/// <param name="assembleFailureMechanismFunc">The <see cref="Func{T1,T2,TResult}"/> to perform
/// the failure mechanism assembly.</param>
/// <param name="assembleFailureMechanismSectionFunc">The <see cref="Func{T1,T2,T3,TResult}"/>
/// to perform the failure mechanism section assembly.</param>
/// <param name="failureMechanismType">The type of the failure mechanism.</param>
/// <typeparam name="TFailureMechanism">The type of the failure mechanism.</typeparam>
/// <typeparam name="TSectionResult">The type of the section result.</typeparam>
/// <returns>An <see cref="ExportableFailureMechanism"/> with assembly results.</returns>
/// <exception cref="ArgumentNullException">Thrown when <paramref name="failureMechanism"/>,
/// <paramref name="assessmentSection"/>, <paramref name="assembleFailureMechanismFunc"/> or
/// <paramref name="assembleFailureMechanismSectionFunc"/> is <c>null</c>.</exception>
/// <exception cref="AssemblyException">Thrown when assembly results cannot be created.</exception>
public static ExportableFailureMechanism CreateExportableFailureMechanism <TFailureMechanism, TSectionResult>(
TFailureMechanism failureMechanism, IAssessmentSection assessmentSection,
Func <TFailureMechanism, IAssessmentSection, FailureMechanismAssemblyResultWrapper> assembleFailureMechanismFunc,
Func <TSectionResult, TFailureMechanism, IAssessmentSection, FailureMechanismSectionAssemblyResultWrapper> assembleFailureMechanismSectionFunc,
ExportableFailureMechanismType failureMechanismType)
where TFailureMechanism : IFailureMechanism <TSectionResult>
where TSectionResult : FailureMechanismSectionResult
{
if (failureMechanism == null)
{
throw new ArgumentNullException(nameof(failureMechanism));
}
if (assessmentSection == null)
{
throw new ArgumentNullException(nameof(assessmentSection));
}
if (assembleFailureMechanismFunc == null)
{
throw new ArgumentNullException(nameof(assembleFailureMechanismFunc));
}
if (assembleFailureMechanismSectionFunc == null)
{
throw new ArgumentNullException(nameof(assembleFailureMechanismSectionFunc));
}
FailureMechanismAssemblyResultWrapper assemblyResultWrapper = assembleFailureMechanismFunc(failureMechanism, assessmentSection);
return(new ExportableFailureMechanism(
new ExportableFailureMechanismAssemblyResult(
assemblyResultWrapper.AssemblyResult,
ExportableAssemblyMethodFactory.Create(assemblyResultWrapper.AssemblyMethod)),
CreateExportableFailureMechanismSectionResults(
failureMechanism, assessmentSection, assembleFailureMechanismSectionFunc),
failureMechanismType, failureMechanism.Code, failureMechanism.Name));
}
private static void AssertExportableFailureMechanismCombinedSectionAssemblyResult(IFailureMechanism failureMechanism,
ExportableFailureMechanismType expectedFailureMechanismType,
ExportableFailureMechanismCombinedSectionAssemblyResult actualExportableFailureMechanismCombinedSectionAssemblyResult)
{
Assert.AreEqual(failureMechanism.Code, actualExportableFailureMechanismCombinedSectionAssemblyResult.Code);
Assert.AreEqual(expectedFailureMechanismType, actualExportableFailureMechanismCombinedSectionAssemblyResult.FailureMechanismType);
Assert.AreEqual(failureMechanism.Name, actualExportableFailureMechanismCombinedSectionAssemblyResult.Name);
Assert.AreEqual(FailureMechanismSectionAssemblyGroup.Dominant, actualExportableFailureMechanismCombinedSectionAssemblyResult.SectionAssemblyResult.AssemblyGroup);
Assert.AreEqual(ExportableAssemblyMethod.BOI3B1, actualExportableFailureMechanismCombinedSectionAssemblyResult.SectionAssemblyResult.AssemblyMethod);
}
