public void Constructor_WithValidData_ReturnsExpectedValues()
{
// Setup
var random = new Random(21);
const string id = "sectionId";
var failureMechanismType = random.NextEnumValue <SerializableFailureMechanismType>();
const string code = "code";
const string name = "name";
const string totalResultId = "totalResultId";
var assemblyResult = new SerializableFailureMechanismAssemblyResult();
// Call
var failureMechanism = new SerializableFailureMechanism(
id, failureMechanismType, code, name,
new SerializableTotalAssemblyResult(
totalResultId, new SerializableAssessmentProcess(),
random.NextEnumValue <SerializableAssemblyMethod>(),
random.NextEnumValue <SerializableAssemblyMethod>(),
random.NextEnumValue <SerializableAssessmentSectionAssemblyGroup>(),
random.NextDouble()),
assemblyResult);
// Assert
Assert.AreEqual(id, failureMechanism.Id);
Assert.AreEqual(totalResultId, failureMechanism.TotalAssemblyResultId);
Assert.AreEqual(failureMechanismType, failureMechanism.FailureMechanismType);
Assert.AreEqual(code, failureMechanism.GenericFailureMechanismCode);
Assert.AreEqual(name, failureMechanism.SpecificFailureMechanismName);
Assert.AreSame(assemblyResult, failureMechanism.FailureMechanismAssemblyResult);
}
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);
}
public void Constructor_WithValidData_ReturnsExpectedValues()
{
// Setup
var random = new Random(39);
double probability = random.NextDouble();
var assemblyMethod = random.NextEnumValue <SerializableAssemblyMethod>();
// Call
var assemblyResult = new SerializableFailureMechanismAssemblyResult(probability, assemblyMethod);
// Assert
Assert.AreEqual(probability, assemblyResult.Probability);
Assert.AreEqual(assemblyMethod, assemblyResult.AssemblyMethod);
Assert.AreEqual("VOLLDG", assemblyResult.Status);
}
public void DefaultConstructor_ReturnsDefaultValues()
{
// Call
var assemblyResult = new SerializableFailureMechanismAssemblyResult();
// Assert
Assert.AreEqual((SerializableAssemblyMethod)0, assemblyResult.AssemblyMethod);
Assert.AreEqual(0, assemblyResult.Probability);
Assert.AreEqual("VOLLDG", assemblyResult.Status);
SerializableAttributeTestHelper.AssertXmlElementAttribute <SerializableFailureMechanismAssemblyResult>(
nameof(SerializableFailureMechanismAssemblyResult.AssemblyMethod), "assemblagemethodeFaalkans");
SerializableAttributeTestHelper.AssertXmlElementAttribute <SerializableFailureMechanismAssemblyResult>(
nameof(SerializableFailureMechanismAssemblyResult.Probability), "faalkans");
SerializableAttributeTestHelper.AssertXmlElementAttribute <SerializableFailureMechanismAssemblyResult>(
nameof(SerializableFailureMechanismAssemblyResult.Status), "status");
}
/// <summary>
/// Creates a new instance of <see cref="SerializableFailureMechanism"/>.
/// </summary>
/// <param name="id">The unique assembly ID.</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>
/// <param name="totalAssemblyResult">The total assembly result the failure mechanism belongs to.</param>
/// <param name="failureMechanismAssemblyResult">The total failure mechanism assembly result.</param>
/// <exception cref="ArgumentNullException">Thrown when any parameter except <paramref name="id"/> is <c>null</c>.</exception>
/// <exception cref="ArgumentException">Thrown when <paramref name="id"/> is invalid.</exception>
public SerializableFailureMechanism(string id, SerializableFailureMechanismType failureMechanismType, string code,
string name, SerializableTotalAssemblyResult totalAssemblyResult,
SerializableFailureMechanismAssemblyResult failureMechanismAssemblyResult)
: this()
{
SerializableIdValidator.ThrowIfInvalid(id);
if (totalAssemblyResult == null)
{
throw new ArgumentNullException(nameof(totalAssemblyResult));
}
if (failureMechanismAssemblyResult == null)
{
throw new ArgumentNullException(nameof(failureMechanismAssemblyResult));
}
Id = id;
FailureMechanismType = failureMechanismType;
TotalAssemblyResultId = totalAssemblyResult.Id;
GenericFailureMechanismCode = code;
SpecificFailureMechanismName = name;
FailureMechanismAssemblyResult = failureMechanismAssemblyResult;
}
/// <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);
}
