public void DefaultConstructor_ReturnsDefaultValues()
{
// Call
var failureMechanism = new SerializableFailureMechanism();
// Assert
Assert.IsInstanceOf <SerializableFeatureMember>(failureMechanism);
Assert.IsNull(failureMechanism.Id);
Assert.IsNull(failureMechanism.TotalAssemblyResultId);
Assert.AreEqual((SerializableFailureMechanismType)0, failureMechanism.FailureMechanismType);
Assert.IsNull(failureMechanism.GenericFailureMechanismCode);
Assert.IsNull(failureMechanism.SpecificFailureMechanismName);
Assert.IsNull(failureMechanism.FailureMechanismAssemblyResult);
SerializableAttributeTestHelper.AssertXmlTypeAttribute(typeof(SerializableFailureMechanism), "Faalmechanisme");
SerializableAttributeTestHelper.AssertXmlAttributeAttribute <SerializableFailureMechanism>(
nameof(SerializableFailureMechanism.Id), "FaalmechanismeID");
SerializableAttributeTestHelper.AssertXmlAttributeAttribute <SerializableFailureMechanism>(
nameof(SerializableFailureMechanism.TotalAssemblyResultId), "VeiligheidsoordeelIDRef");
SerializableAttributeTestHelper.AssertXmlElementAttribute <SerializableFailureMechanism>(
nameof(SerializableFailureMechanism.FailureMechanismType), "typeFaalmechanisme");
SerializableAttributeTestHelper.AssertXmlElementAttribute <SerializableFailureMechanism>(
nameof(SerializableFailureMechanism.GenericFailureMechanismCode), "generiekFaalmechanisme");
SerializableAttributeTestHelper.AssertXmlElementAttribute <SerializableFailureMechanism>(
nameof(SerializableFailureMechanism.SpecificFailureMechanismName), "specifiekFaalmechanisme");
SerializableAttributeTestHelper.AssertXmlElementAttribute <SerializableFailureMechanism>(
nameof(SerializableFailureMechanism.FailureMechanismAssemblyResult), "analyseFaalmechanisme");
}
private static void AssertSerializableFailureMechanism(string expectedId,
SerializableTotalAssemblyResult expectedSerializableTotalAssembly,
SerializableFailureMechanism serializableFailureMechanism)
{
Assert.AreEqual(expectedSerializableTotalAssembly.Id, serializableFailureMechanism.TotalAssemblyResultId);
Assert.AreEqual(expectedId, serializableFailureMechanism.Id);
}
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);
}
/// <summary>
/// Creates a new instance of <see cref="AggregatedSerializableFailureMechanism"/>.
/// </summary>
/// <param name="failureMechanism">The <see cref="SerializableFailureMechanism"/>.</param>
/// <param name="failureMechanismSectionCollection">The <see cref="SerializableFailureMechanismSectionCollection"/>
/// that belongs to the failure mechanism.</param>
/// <param name="failureMechanismSections">A collection of <see cref="SerializableFailureMechanismSection"/>
/// that belongs to the failure mechanism.</param>
/// <param name="failureMechanismSectionAssemblyResults">A collection of <see cref="SerializableFailureMechanismSectionAssembly"/>
/// that belongs to the failure mechanism.</param>
/// <exception cref="ArgumentNullException">Thrown when any parameter is <c>null</c>.</exception>
public AggregatedSerializableFailureMechanism(SerializableFailureMechanism failureMechanism,
SerializableFailureMechanismSectionCollection failureMechanismSectionCollection,
IEnumerable <SerializableFailureMechanismSection> failureMechanismSections,
IEnumerable <SerializableFailureMechanismSectionAssembly> failureMechanismSectionAssemblyResults)
{
if (failureMechanism == null)
{
throw new ArgumentNullException(nameof(failureMechanism));
}
if (failureMechanismSectionCollection == null)
{
throw new ArgumentNullException(nameof(failureMechanismSectionCollection));
}
if (failureMechanismSections == null)
{
throw new ArgumentNullException(nameof(failureMechanismSections));
}
if (failureMechanismSectionAssemblyResults == null)
{
throw new ArgumentNullException(nameof(failureMechanismSectionAssemblyResults));
}
FailureMechanism = failureMechanism;
FailureMechanismSectionCollection = failureMechanismSectionCollection;
FailureMechanismSections = failureMechanismSections;
FailureMechanismSectionAssemblyResults = failureMechanismSectionAssemblyResults;
}
public void Constructor_WithValidData_ReturnsExpectedValues()
{
// Setup
const string id = "id";
var random = new Random(39);
var failureMechanism = new SerializableFailureMechanism(
"failureMechanismID", random.NextEnumValue <SerializableFailureMechanismType>(),
"code", "name", new SerializableTotalAssemblyResult(), new SerializableFailureMechanismAssemblyResult());
var section = new SerializableFailureMechanismSection("sectionID",
new SerializableFailureMechanismSectionCollection(),
random.NextDouble(),
random.NextDouble(),
new[]
{
new Point2D(random.NextDouble(), random.NextDouble())
},
SerializableFailureMechanismSectionType.FailureMechanism);
var sectionResult = new SerializableFailureMechanismSectionAssemblyResult();
// Call
var sectionAssembly = new SerializableFailureMechanismSectionAssembly(
id, failureMechanism, section, sectionResult);
// Assert
Assert.AreEqual(id, sectionAssembly.Id);
Assert.AreEqual(failureMechanism.Id, sectionAssembly.FailureMechanismId);
Assert.AreEqual(section.Id, sectionAssembly.FailureMechanismSectionId);
Assert.AreSame(sectionResult, sectionAssembly.SectionResult);
}
/// <summary>
/// Creates an instance of <see cref="AggregatedSerializableFailureMechanism"/> based on its input parameters.
/// </summary>
/// <param name="idGenerator">The generator to generate ids for the serializable components.</param>
/// <param name="serializableTotalAssemblyResult">The <see cref="SerializableTotalAssemblyResult"/>
/// the serializable components belong to.</param>
/// <param name="failureMechanism">The <see cref="ExportableFailureMechanism"/>
/// to create an <see cref="AggregatedSerializableFailureMechanism"/> for.</param>
/// <returns>An <see cref="AggregatedSerializableFailureMechanism"/>.</returns>
/// <exception cref="ArgumentNullException">Thrown when any parameter is <c>null</c>.</exception>
/// <exception cref="AssemblyCreatorException">Thrown when <paramref name="failureMechanism"/>
/// is invalid to create a serializable counterpart for.</exception>
/// <exception cref="NotSupportedException">Thrown when the <see cref="ExportableFailureMechanism"/>
/// contains unsupported items in the failure mechanism section assembly results.</exception>
public static AggregatedSerializableFailureMechanism Create(IdentifierGenerator idGenerator,
SerializableTotalAssemblyResult serializableTotalAssemblyResult,
ExportableFailureMechanism failureMechanism)
{
if (idGenerator == null)
{
throw new ArgumentNullException(nameof(idGenerator));
}
if (serializableTotalAssemblyResult == null)
{
throw new ArgumentNullException(nameof(serializableTotalAssemblyResult));
}
if (failureMechanism == null)
{
throw new ArgumentNullException(nameof(failureMechanism));
}
SerializableFailureMechanism serializableFailureMechanism = SerializableFailureMechanismCreator.Create(idGenerator, serializableTotalAssemblyResult, failureMechanism);
var serializableCollection = new SerializableFailureMechanismSectionCollection(idGenerator.GetNewId(Resources.SerializableFailureMechanismSectionCollection_IdPrefix));
AggregatedSerializableFailureMechanismSectionAssembly[] serializableFailureMechanismSectionAssemblyResults =
failureMechanism.SectionAssemblyResults
.Select(sectionAssemblyResult => CreateFailureMechanismSectionAssembly(
idGenerator, serializableFailureMechanism, serializableCollection, sectionAssemblyResult))
.ToArray();
return(new AggregatedSerializableFailureMechanism(serializableFailureMechanism,
serializableCollection,
serializableFailureMechanismSectionAssemblyResults.Select(fmr => fmr.FailureMechanismSection),
serializableFailureMechanismSectionAssemblyResults.Select(fmr => fmr.FailureMechanismSectionAssembly)));
}
private static void AssertSerializableFailureMechanismSectionAssembly(string expectedId,
SerializableFailureMechanism expectedSerializableFailureMechanism,
SerializableFailureMechanismSection expectedSerializableFailureMechanismSection,
SerializableFailureMechanismSectionAssembly serializableFailureMechanismSectionAssembly)
{
Assert.AreEqual(expectedSerializableFailureMechanism.Id, serializableFailureMechanismSectionAssembly.FailureMechanismId);
Assert.AreEqual(expectedSerializableFailureMechanismSection.Id, serializableFailureMechanismSectionAssembly.FailureMechanismSectionId);
Assert.AreEqual(expectedId, serializableFailureMechanismSectionAssembly.Id);
}
public void Create_WithValidArguments_ReturnsAggregatedSerializableFailureMechanism()
{
// Setup
var random = new Random(21);
var failureMechanism = new ExportableFailureMechanism(
ExportableFailureMechanismAssemblyResultTestFactory.CreateResult(),
new[]
{
ExportableFailureMechanismSectionAssemblyResultTestFactory.CreateWithProbability(
ExportableFailureMechanismSectionTestFactory.CreateExportableFailureMechanismSection(random.Next()), random.Next()),
ExportableFailureMechanismSectionAssemblyResultTestFactory.CreateWithProbability(
ExportableFailureMechanismSectionTestFactory.CreateExportableFailureMechanismSection(random.Next()), random.Next())
},
random.NextEnumValue <ExportableFailureMechanismType>(),
"code",
"name");
var idGenerator = new IdentifierGenerator();
const string totalAssemblyId = "totalAssemblyId";
var serializableTotalAssembly = new SerializableTotalAssemblyResult(totalAssemblyId,
new SerializableAssessmentProcess(),
random.NextEnumValue <SerializableAssemblyMethod>(),
random.NextEnumValue <SerializableAssemblyMethod>(),
random.NextEnumValue <SerializableAssessmentSectionAssemblyGroup>(),
random.NextDouble());
// Call
AggregatedSerializableFailureMechanism aggregatedFailureMechanism =
AggregatedSerializableFailureMechanismCreator.Create(idGenerator, serializableTotalAssembly, failureMechanism);
// Assert
SerializableFailureMechanism serializableFailureMechanism = aggregatedFailureMechanism.FailureMechanism;
Assert.AreEqual("Fm.0", serializableFailureMechanism.Id);
Assert.AreEqual(serializableTotalAssembly.Id, serializableFailureMechanism.TotalAssemblyResultId);
Assert.AreEqual(SerializableFailureMechanismTypeCreator.Create(failureMechanism.FailureMechanismType),
serializableFailureMechanism.FailureMechanismType);
Assert.AreEqual(failureMechanism.Code, serializableFailureMechanism.GenericFailureMechanismCode);
SerializableFailureMechanismAssemblyResultTestHelper.AssertSerializableFailureMechanismAssemblyResult(failureMechanism.FailureMechanismAssembly,
serializableFailureMechanism.FailureMechanismAssemblyResult);
SerializableFailureMechanismSectionCollection serializableFailureMechanismSectionCollection = aggregatedFailureMechanism.FailureMechanismSectionCollection;
Assert.AreEqual("Vi.0", serializableFailureMechanismSectionCollection.Id);
AssertFailureMechanismSectionAssemblies(failureMechanism,
serializableFailureMechanismSectionCollection,
serializableFailureMechanism,
aggregatedFailureMechanism.FailureMechanismSections,
aggregatedFailureMechanism.FailureMechanismSectionAssemblyResults);
}
public void GivenSerializableFailureMechanismWithFailureMechanismType_WhenShouldSerializeProperties_ThenReturnsExpectedValues(
SerializableFailureMechanismType failureMechanismType, bool expectedShouldSerializeGeneric, bool expectedShouldSerializeSpecific)
{
// Given
var failureMechanism = new SerializableFailureMechanism(
"id", failureMechanismType, "code", "name", new SerializableTotalAssemblyResult(),
new SerializableFailureMechanismAssemblyResult());
// When
bool shouldSerializeGeneric = failureMechanism.ShouldSerializeGenericFailureMechanismCode();
bool shouldSerializeSpecific = failureMechanism.ShouldSerializeSpecificFailureMechanismName();
// Then
Assert.AreEqual(expectedShouldSerializeGeneric, shouldSerializeGeneric);
Assert.AreEqual(expectedShouldSerializeSpecific, shouldSerializeSpecific);
}
/// <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 Constructor_FailureMechanismSectionAssemblyResultsNull_ThrowsArgumentNullException()
{
// Setup
var failureMechanism = new SerializableFailureMechanism();
var failureMechanismSectionCollection = new SerializableFailureMechanismSectionCollection();
IEnumerable <SerializableFailureMechanismSection> failureMechanismSections =
Enumerable.Empty <SerializableFailureMechanismSection>();
// Call
TestDelegate call = () => new AggregatedSerializableFailureMechanism(failureMechanism,
failureMechanismSectionCollection,
failureMechanismSections,
null);
// Assert
var exception = Assert.Throws <ArgumentNullException>(call);
Assert.AreEqual("failureMechanismSectionAssemblyResults", exception.ParamName);
}
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_WithValidArguments_ExpectedValues()
{
// Setup
var failureMechanism = new SerializableFailureMechanism();
var failureMechanismSectionCollection = new SerializableFailureMechanismSectionCollection();
IEnumerable <SerializableFailureMechanismSection> failureMechanismSections =
Enumerable.Empty <SerializableFailureMechanismSection>();
IEnumerable <SerializableFailureMechanismSectionAssembly> failureMechanismSectionAssemblyResults =
Enumerable.Empty <SerializableFailureMechanismSectionAssembly>();
// Call
var aggregatedFailureMechanism = new AggregatedSerializableFailureMechanism(failureMechanism,
failureMechanismSectionCollection,
failureMechanismSections,
failureMechanismSectionAssemblyResults);
// Assert
Assert.AreSame(failureMechanism, aggregatedFailureMechanism.FailureMechanism);
Assert.AreSame(failureMechanismSectionCollection, aggregatedFailureMechanism.FailureMechanismSectionCollection);
Assert.AreSame(failureMechanismSections, aggregatedFailureMechanism.FailureMechanismSections);
Assert.AreSame(failureMechanismSectionAssemblyResults, aggregatedFailureMechanism.FailureMechanismSectionAssemblyResults);
}
public void Create_WithFailureMechanismAssemblyResult_ReturnsSerializableFailureMechanism()
{
// Setup
var idGenerator = new IdentifierGenerator();
ExportableFailureMechanism failureMechanism = CreateExportableFailureMechanism();
const string totalAssemblyId = "totalAssemblyId";
SerializableTotalAssemblyResult serializableTotalAssembly = CreateSerializableTotalAssembly(totalAssemblyId);
// Call
SerializableFailureMechanism serializableFailureMechanism = SerializableFailureMechanismCreator.Create(idGenerator,
serializableTotalAssembly,
failureMechanism);
// Assert
Assert.AreEqual("Fm.0", serializableFailureMechanism.Id);
Assert.AreEqual(serializableTotalAssembly.Id, serializableFailureMechanism.TotalAssemblyResultId);
Assert.AreEqual(SerializableFailureMechanismTypeCreator.Create(failureMechanism.FailureMechanismType),
serializableFailureMechanism.FailureMechanismType);
Assert.AreEqual(failureMechanism.Code, serializableFailureMechanism.GenericFailureMechanismCode);
SerializableFailureMechanismAssemblyResultTestHelper.AssertSerializableFailureMechanismAssemblyResult(failureMechanism.FailureMechanismAssembly,
serializableFailureMechanism.FailureMechanismAssemblyResult);
}
public void Constructor_WithValidData_ReturnsExpectedValues()
{
// Setup
const string id = "assemblyId1";
var random = new Random(39);
var lowerCorner = new Point2D(random.NextDouble(), random.NextDouble());
var upperCorner = new Point2D(random.NextDouble(), random.NextDouble());
var assessmentSection = new SerializableAssessmentSection();
var assessmentProcess = new SerializableAssessmentProcess();
var totalAssemblyResult = new SerializableTotalAssemblyResult();
var failureMechanism = new SerializableFailureMechanism();
var failureMechanismSectionAssembly = new SerializableFailureMechanismSectionAssembly();
var combinedFailureMechanismSectionAssembly = new SerializableCombinedFailureMechanismSectionAssembly();
var failureMechanismSections = new SerializableFailureMechanismSectionCollection();
var failureMechanismSection = new SerializableFailureMechanismSection();
// Call
var assembly = new SerializableAssembly(id,
lowerCorner,
upperCorner,
assessmentSection,
assessmentProcess,
totalAssemblyResult,
new[]
{
failureMechanism
},
new[]
{
failureMechanismSectionAssembly
},
new[]
{
combinedFailureMechanismSectionAssembly
},
new[]
{
failureMechanismSections
},
new[]
{
failureMechanismSection
});
// Assert
Assert.AreEqual(id, assembly.Id);
Assert.AreEqual(lowerCorner.X.ToString(CultureInfo.InvariantCulture) + " " + lowerCorner.Y.ToString(CultureInfo.InvariantCulture),
assembly.Boundary.Envelope.LowerCorner);
Assert.AreEqual(upperCorner.X.ToString(CultureInfo.InvariantCulture) + " " + upperCorner.Y.ToString(CultureInfo.InvariantCulture),
assembly.Boundary.Envelope.UpperCorner);
CollectionAssert.AreEqual(new SerializableFeatureMember[]
{
assessmentSection,
assessmentProcess,
totalAssemblyResult,
failureMechanism,
failureMechanismSectionAssembly,
combinedFailureMechanismSectionAssembly,
failureMechanismSections,
failureMechanismSection
}, assembly.FeatureMembers);
}
private static SerializableAssembly CreateSerializableAssembly()
{
var assessmentSection = new SerializableAssessmentSection("section1", "Traject A", new[]
{
new Point2D(0, 0),
new Point2D(100.0, 0.0)
});
var assessmentProcess = new SerializableAssessmentProcess("beoordelingsproces1",
assessmentSection);
var totalAssemblyResult = new SerializableTotalAssemblyResult(
"veiligheidsoordeel_1", assessmentProcess,
SerializableAssemblyMethod.BOI2A1, SerializableAssemblyMethod.BOI2B1,
SerializableAssessmentSectionAssemblyGroup.B, 0.00068354);
var failureMechanism = new SerializableFailureMechanism(
"toetsspoorGABI", SerializableFailureMechanismType.Generic, "GABI", "Faalmechanisme GABI", totalAssemblyResult,
new SerializableFailureMechanismAssemblyResult(0.08419, SerializableAssemblyMethod.BOI1A1));
var specificFailureMechanism = new SerializableFailureMechanism(
"specifiekFaalmechanisme", SerializableFailureMechanismType.Specific, "NIEUW", "Specifiek faalmechanisme",
totalAssemblyResult, new SerializableFailureMechanismAssemblyResult(0.002834, SerializableAssemblyMethod.BOI1A1));
var sections1 = new SerializableFailureMechanismSectionCollection("vakindelingGABI");
var section1 = new SerializableFailureMechanismSection(
"vak_GABI_1",
sections1,
0.12,
10.23,
new[]
{
new Point2D(0.23, 0.24),
new Point2D(10.23, 10.24)
},
SerializableFailureMechanismSectionType.FailureMechanism);
var result = new SerializableFailureMechanismSectionAssembly(
"resultaat_GABI_1", failureMechanism, section1,
new SerializableFailureMechanismSectionAssemblyResult(
SerializableAssemblyMethod.BOI0A2, SerializableAssemblyMethod.BOI0B1,
SerializableFailureMechanismSectionAssemblyGroup.III, 0.00073));
var sections2 = new SerializableFailureMechanismSectionCollection("vakindeling_gecombineerd");
var section2 = new SerializableFailureMechanismSection(
"vak_gecombineerd_1",
sections2,
0.12,
10.23,
new[]
{
new Point2D(0.23, 0.24),
new Point2D(10.23, 10.24)
},
SerializableFailureMechanismSectionType.Combined,
SerializableAssemblyMethod.BOI3A1);
var combinedResult = new SerializableCombinedFailureMechanismSectionAssembly(
"resultaat_gecombineerd_1",
totalAssemblyResult,
section2,
new[]
{
new SerializableCombinedFailureMechanismSectionAssemblyResult(
SerializableAssemblyMethod.BOI3B1,
SerializableFailureMechanismType.Generic, "HTKW", "Hoogte kunstwerk",
SerializableFailureMechanismSectionAssemblyGroup.III),
new SerializableCombinedFailureMechanismSectionAssemblyResult(
SerializableAssemblyMethod.BOI3B1,
SerializableFailureMechanismType.Generic, "STPH", "Piping",
SerializableFailureMechanismSectionAssemblyGroup.II),
new SerializableCombinedFailureMechanismSectionAssemblyResult(
SerializableAssemblyMethod.BOI3B1,
SerializableFailureMechanismType.Specific, "NIEUW", "Specifiek",
SerializableFailureMechanismSectionAssemblyGroup.Zero)
},
new SerializableFailureMechanismSubSectionAssemblyResult(
SerializableAssemblyMethod.BOI3C1, SerializableFailureMechanismSectionAssemblyGroup.I));
var assembly = new SerializableAssembly(
"assemblage_1",
new Point2D(12.0, 34.0),
new Point2D(56.053, 78.0002345),
assessmentSection,
assessmentProcess,
totalAssemblyResult,
new[]
{
failureMechanism,
specificFailureMechanism
},
new[]
{
result
},
new[]
{
combinedResult
},
new[]
{
sections1,
sections2
},
new[]
{
section1,
section2
});
return(assembly);
}
