Index: Riskeer/AssemblyTool/test/Riskeer.AssemblyTool.IO.Test/SerializableAssemblyWriterTest.cs =================================================================== diff -u -r2dc6ed57b83ae3eef313400ff41ac5cb369f9bc9 -r2077c21eebd3514bbc3f49f2cf9039100760f966 --- Riskeer/AssemblyTool/test/Riskeer.AssemblyTool.IO.Test/SerializableAssemblyWriterTest.cs (.../SerializableAssemblyWriterTest.cs) (revision 2dc6ed57b83ae3eef313400ff41ac5cb369f9bc9) +++ Riskeer/AssemblyTool/test/Riskeer.AssemblyTool.IO.Test/SerializableAssemblyWriterTest.cs (.../SerializableAssemblyWriterTest.cs) (revision 2077c21eebd3514bbc3f49f2cf9039100760f966) @@ -47,21 +47,21 @@ public void WriteAssembly_SerializableAssemblyNull_ThrowsArgumentNullException() { // Call - TestDelegate test = () => SerializableAssemblyWriter.WriteAssembly(null, string.Empty); + void Call() => SerializableAssemblyWriter.WriteAssembly(null, string.Empty); // Assert - var exception = Assert.Throws(test); + var exception = Assert.Throws(Call); Assert.AreEqual("serializableAssembly", exception.ParamName); } [Test] public void WriteAssembly_FilePathNull_ThrowsArgumentNullException() { // Call - TestDelegate test = () => SerializableAssemblyWriter.WriteAssembly(new SerializableAssembly(), null); + void Call() => SerializableAssemblyWriter.WriteAssembly(new SerializableAssembly(), null); // Assert - var exception = Assert.Throws(test); + var exception = Assert.Throws(Call); Assert.AreEqual("filePath", exception.ParamName); } @@ -90,10 +90,10 @@ try { // Call - TestDelegate call = () => SerializableAssemblyWriter.WriteAssembly(assembly, filePath); + void Call() => SerializableAssemblyWriter.WriteAssembly(assembly, filePath); // Assert - var exception = Assert.Throws(call); + var exception = Assert.Throws(Call); Assert.AreEqual($"Er is een onverwachte fout opgetreden tijdens het schrijven van het bestand '{filePath}'.", exception.Message); Assert.IsInstanceOf(exception.InnerException); } @@ -110,10 +110,10 @@ public void WriteAssembly_FilePathInvalid_ThrowsCriticalFileWriteException(string filePath) { // Call - TestDelegate call = () => SerializableAssemblyWriter.WriteAssembly(new SerializableAssembly(), filePath); + void Call() => SerializableAssemblyWriter.WriteAssembly(new SerializableAssembly(), filePath); // Assert - var exception = Assert.Throws(call); + var exception = Assert.Throws(Call); Assert.AreEqual($"Er is een onverwachte fout opgetreden tijdens het schrijven van het bestand '{filePath}'.", exception.Message); Assert.IsInstanceOf(exception.InnerException); } @@ -125,10 +125,10 @@ var filePath = new string('a', 249); // Call - TestDelegate call = () => SerializableAssemblyWriter.WriteAssembly(new SerializableAssembly(), filePath); + void Call() => SerializableAssemblyWriter.WriteAssembly(new SerializableAssembly(), filePath); // Assert - var exception = Assert.Throws(call); + var exception = Assert.Throws(Call); Assert.AreEqual($"Er is een onverwachte fout opgetreden tijdens het schrijven van het bestand '{filePath}'.", exception.Message); Assert.IsInstanceOf(exception.InnerException); } @@ -145,10 +145,10 @@ disposeHelper.LockDirectory(FileSystemRights.Write); // Call - TestDelegate call = () => SerializableAssemblyWriter.WriteAssembly(new SerializableAssembly(), filePath); + void Call() => SerializableAssemblyWriter.WriteAssembly(new SerializableAssembly(), filePath); // Assert - var exception = Assert.Throws(call); + var exception = Assert.Throws(Call); Assert.AreEqual($"Er is een onverwachte fout opgetreden tijdens het schrijven van het bestand '{filePath}'.", exception.Message); Assert.IsInstanceOf(exception.InnerException); } @@ -165,10 +165,10 @@ fileDisposeHelper.LockFiles(); // Call - TestDelegate call = () => SerializableAssemblyWriter.WriteAssembly(new SerializableAssembly(), filePath); + void Call() => SerializableAssemblyWriter.WriteAssembly(new SerializableAssembly(), filePath); // Assert - var exception = Assert.Throws(call); + var exception = Assert.Throws(Call); Assert.AreEqual($"Er is een onverwachte fout opgetreden tijdens het schrijven van het bestand '{filePath}'.", exception.Message); Assert.IsInstanceOf(exception.InnerException); } Index: Riskeer/Integration/src/Riskeer.Integration.IO/Factories/ExportableAssessmentSectionFactory.cs =================================================================== diff -u -r9a185e879a64c1fc1e71c3ffea0f6d77aaff701a -r2077c21eebd3514bbc3f49f2cf9039100760f966 --- Riskeer/Integration/src/Riskeer.Integration.IO/Factories/ExportableAssessmentSectionFactory.cs (.../ExportableAssessmentSectionFactory.cs) (revision 9a185e879a64c1fc1e71c3ffea0f6d77aaff701a) +++ Riskeer/Integration/src/Riskeer.Integration.IO/Factories/ExportableAssessmentSectionFactory.cs (.../ExportableAssessmentSectionFactory.cs) (revision 2077c21eebd3514bbc3f49f2cf9039100760f966) @@ -107,80 +107,79 @@ AddFailureMechanismWhenInAssembly( exportableFailureMechanisms, assessmentSection.Piping, assessmentSection, PipingFailureMechanismAssemblyFactory.AssembleFailureMechanism, - PipingFailureMechanismAssemblyFactory.AssembleSection, ExportableFailureMechanismType.STPH); + PipingFailureMechanismAssemblyFactory.AssembleSection); AddFailureMechanismWhenInAssembly( exportableFailureMechanisms, assessmentSection.MacroStabilityInwards, assessmentSection, MacroStabilityInwardsFailureMechanismAssemblyFactory.AssembleFailureMechanism, - MacroStabilityInwardsFailureMechanismAssemblyFactory.AssembleSection, ExportableFailureMechanismType.STBI); + MacroStabilityInwardsFailureMechanismAssemblyFactory.AssembleSection); AddFailureMechanismWhenInAssembly( exportableFailureMechanisms, assessmentSection.GrassCoverErosionInwards, assessmentSection, GrassCoverErosionInwardsFailureMechanismAssemblyFactory.AssembleFailureMechanism, - GrassCoverErosionInwardsFailureMechanismAssemblyFactory.AssembleSection, ExportableFailureMechanismType.GEKB); + GrassCoverErosionInwardsFailureMechanismAssemblyFactory.AssembleSection); AddFailureMechanismWhenInAssembly( exportableFailureMechanisms, assessmentSection.HeightStructures, assessmentSection, HeightStructuresFailureMechanismAssemblyFactory.AssembleFailureMechanism, - StructuresFailureMechanismAssemblyFactory.AssembleSection, ExportableFailureMechanismType.HTKW); + StructuresFailureMechanismAssemblyFactory.AssembleSection); AddFailureMechanismWhenInAssembly( exportableFailureMechanisms, assessmentSection.ClosingStructures, assessmentSection, ClosingStructuresFailureMechanismAssemblyFactory.AssembleFailureMechanism, - StructuresFailureMechanismAssemblyFactory.AssembleSection, ExportableFailureMechanismType.BSKW); + StructuresFailureMechanismAssemblyFactory.AssembleSection); AddFailureMechanismWhenInAssembly( exportableFailureMechanisms, assessmentSection.StabilityPointStructures, assessmentSection, StabilityPointStructuresFailureMechanismAssemblyFactory.AssembleFailureMechanism, - StructuresFailureMechanismAssemblyFactory.AssembleSection, ExportableFailureMechanismType.STKWp); + StructuresFailureMechanismAssemblyFactory.AssembleSection); AddFailureMechanismWhenInAssembly( exportableFailureMechanisms, assessmentSection.StabilityStoneCover, assessmentSection, StabilityStoneCoverFailureMechanismAssemblyFactory.AssembleFailureMechanism, - StabilityStoneCoverFailureMechanismAssemblyFactory.AssembleSection, ExportableFailureMechanismType.ZST); + StabilityStoneCoverFailureMechanismAssemblyFactory.AssembleSection); AddFailureMechanismWhenInAssembly( exportableFailureMechanisms, assessmentSection.WaveImpactAsphaltCover, assessmentSection, WaveImpactAsphaltCoverFailureMechanismAssemblyFactory.AssembleFailureMechanism, - WaveImpactAsphaltCoverFailureMechanismAssemblyFactory.AssembleSection, ExportableFailureMechanismType.AGK); + WaveImpactAsphaltCoverFailureMechanismAssemblyFactory.AssembleSection); AddFailureMechanismWhenInAssembly( exportableFailureMechanisms, assessmentSection.GrassCoverErosionOutwards, assessmentSection, GrassCoverErosionOutwardsFailureMechanismAssemblyFactory.AssembleFailureMechanism, - GrassCoverErosionOutwardsFailureMechanismAssemblyFactory.AssembleSection, ExportableFailureMechanismType.GEBU); + GrassCoverErosionOutwardsFailureMechanismAssemblyFactory.AssembleSection); AddFailureMechanismWhenInAssembly( exportableFailureMechanisms, assessmentSection.DuneErosion, assessmentSection, DuneErosionFailureMechanismAssemblyFactory.AssembleFailureMechanism, - (sr, fm, ass) => FailureMechanismSectionAssemblyResultFactory.AssembleSection(sr, ass), ExportableFailureMechanismType.DA); + (sr, fm, ass) => FailureMechanismSectionAssemblyResultFactory.AssembleSection(sr, ass)); AddFailureMechanismWhenInAssembly( exportableFailureMechanisms, assessmentSection.Microstability, assessmentSection, FailureMechanismAssemblyFactory.AssembleFailureMechanism, - FailureMechanismAssemblyFactory.AssembleSection, ExportableFailureMechanismType.STMI); + FailureMechanismAssemblyFactory.AssembleSection); AddFailureMechanismWhenInAssembly( exportableFailureMechanisms, assessmentSection.GrassCoverSlipOffOutwards, assessmentSection, FailureMechanismAssemblyFactory.AssembleFailureMechanism, - FailureMechanismAssemblyFactory.AssembleSection, ExportableFailureMechanismType.GABU); + FailureMechanismAssemblyFactory.AssembleSection); AddFailureMechanismWhenInAssembly( exportableFailureMechanisms, assessmentSection.GrassCoverSlipOffInwards, assessmentSection, FailureMechanismAssemblyFactory.AssembleFailureMechanism, - FailureMechanismAssemblyFactory.AssembleSection, ExportableFailureMechanismType.GABI); + FailureMechanismAssemblyFactory.AssembleSection); AddFailureMechanismWhenInAssembly( exportableFailureMechanisms, assessmentSection.PipingStructure, assessmentSection, PipingStructureFailureMechanismAssemblyFactory.AssembleFailureMechanism, - (sr, fm, ass) => FailureMechanismSectionAssemblyResultFactory.AssembleSection(sr, ass), ExportableFailureMechanismType.PKW); + (sr, fm, ass) => FailureMechanismSectionAssemblyResultFactory.AssembleSection(sr, ass)); AddFailureMechanismWhenInAssembly( exportableFailureMechanisms, assessmentSection.WaterPressureAsphaltCover, assessmentSection, FailureMechanismAssemblyFactory.AssembleFailureMechanism, - FailureMechanismAssemblyFactory.AssembleSection, ExportableFailureMechanismType.AWO); + FailureMechanismAssemblyFactory.AssembleSection); return exportableFailureMechanisms; } private static void AddFailureMechanismWhenInAssembly( List exportableFailureMechanisms, TFailureMechanism failureMechanism, IAssessmentSection assessmentSection, Func assembleFailureMechanismFunc, - Func assembleFailureMechanismSectionFunc, - ExportableFailureMechanismType failureMechanismType) + Func assembleFailureMechanismSectionFunc) where TFailureMechanism : IFailurePath where TSectionResult : FailureMechanismSectionResult { if (failureMechanism.InAssembly) { exportableFailureMechanisms.Add( ExportableFailureMechanismFactory.CreateExportableFailureMechanism( - failureMechanism, assessmentSection, assembleFailureMechanismFunc, assembleFailureMechanismSectionFunc, failureMechanismType)); + failureMechanism, assessmentSection, assembleFailureMechanismFunc, assembleFailureMechanismSectionFunc)); } } @@ -190,10 +189,10 @@ /// The assessment section to create a collection of for. /// A . /// Thrown when assembly results cannot be created for . - private static IEnumerable CreateExportableCombinedSectionAssemblyCollection(IAssessmentSection assessmentSection) + private static IEnumerable CreateExportableCombinedSectionAssemblyCollection(AssessmentSection assessmentSection) { IEnumerable assemblyResults = new List(); - return ExportableCombinedSectionAssemblyFactory.CreateExportableCombinedSectionAssemblyCollection(assemblyResults, assessmentSection.ReferenceLine); + return ExportableCombinedSectionAssemblyFactory.CreateExportableCombinedSectionAssemblyCollection(assemblyResults, assessmentSection); } } } \ No newline at end of file Index: Riskeer/Integration/src/Riskeer.Integration.IO/Factories/ExportableCombinedSectionAssemblyFactory.cs =================================================================== diff -u -rdcd80735dd7682025912868373380ff62377cbb7 -r2077c21eebd3514bbc3f49f2cf9039100760f966 --- Riskeer/Integration/src/Riskeer.Integration.IO/Factories/ExportableCombinedSectionAssemblyFactory.cs (.../ExportableCombinedSectionAssemblyFactory.cs) (revision dcd80735dd7682025912868373380ff62377cbb7) +++ Riskeer/Integration/src/Riskeer.Integration.IO/Factories/ExportableCombinedSectionAssemblyFactory.cs (.../ExportableCombinedSectionAssemblyFactory.cs) (revision 2077c21eebd3514bbc3f49f2cf9039100760f966) @@ -23,7 +23,8 @@ using System.Collections.Generic; using System.Linq; using Riskeer.AssemblyTool.Data; -using Riskeer.Common.Data.AssessmentSection; +using Riskeer.Common.Data.FailurePath; +using Riskeer.Integration.Data; using Riskeer.Integration.Data.Assembly; using Riskeer.Integration.IO.Assembly; using Riskeer.Integration.Util; @@ -41,37 +42,37 @@ /// /// A collection of combined section results to /// create a collection of for. - /// The reference line to map the sections to. + /// The the section results belong to. /// A collection of . /// Thrown when any parameter is null. public static IEnumerable CreateExportableCombinedSectionAssemblyCollection( IEnumerable combinedSectionAssemblyResults, - ReferenceLine referenceLine) + AssessmentSection assessmentSection) { if (combinedSectionAssemblyResults == null) { throw new ArgumentNullException(nameof(combinedSectionAssemblyResults)); } - if (referenceLine == null) + if (assessmentSection == null) { - throw new ArgumentNullException(nameof(referenceLine)); + throw new ArgumentNullException(nameof(assessmentSection)); } var sectionResults = new List(); foreach (CombinedFailureMechanismSectionAssemblyResult assemblyResult in combinedSectionAssemblyResults) { var exportableSection = new ExportableCombinedFailureMechanismSection( FailureMechanismSectionHelper.GetFailureMechanismSectionGeometry( - referenceLine, assemblyResult.SectionStart, assemblyResult.SectionEnd), + assessmentSection.ReferenceLine, assemblyResult.SectionStart, assemblyResult.SectionEnd), assemblyResult.SectionStart, assemblyResult.SectionEnd, ExportableAssemblyMethod.WBI3A1); var exportableSectionResult = new ExportableCombinedSectionAssembly( exportableSection, new ExportableFailureMechanismSectionAssemblyResult( exportableSection, assemblyResult.TotalResult, ExportableAssemblyMethod.WBI3C1), - CreateFailureMechanismCombinedSectionAssemblyResults(assemblyResult)); + CreateFailureMechanismCombinedSectionAssemblyResults(assemblyResult, assessmentSection)); sectionResults.Add(exportableSectionResult); } @@ -80,41 +81,41 @@ } private static IEnumerable CreateFailureMechanismCombinedSectionAssemblyResults( - CombinedFailureMechanismSectionAssemblyResult assemblyResult) + CombinedFailureMechanismSectionAssemblyResult assemblyResult, AssessmentSection assessmentSection) { - Tuple[] failureMechanisms = + Tuple[] failureMechanisms = { - CreateTuple(assemblyResult.Piping, ExportableFailureMechanismType.STPH), - CreateTuple(assemblyResult.GrassCoverErosionInwards, ExportableFailureMechanismType.GEKB), - CreateTuple(assemblyResult.MacroStabilityInwards, ExportableFailureMechanismType.STBI), - CreateTuple(assemblyResult.Microstability, ExportableFailureMechanismType.STMI), - CreateTuple(assemblyResult.StabilityStoneCover, ExportableFailureMechanismType.ZST), - CreateTuple(assemblyResult.WaveImpactAsphaltCover, ExportableFailureMechanismType.AGK), - CreateTuple(assemblyResult.WaterPressureAsphaltCover, ExportableFailureMechanismType.AWO), - CreateTuple(assemblyResult.GrassCoverErosionOutwards, ExportableFailureMechanismType.GEBU), - CreateTuple(assemblyResult.GrassCoverSlipOffOutwards, ExportableFailureMechanismType.GABU), - CreateTuple(assemblyResult.GrassCoverSlipOffInwards, ExportableFailureMechanismType.GABI), - CreateTuple(assemblyResult.HeightStructures, ExportableFailureMechanismType.HTKW), - CreateTuple(assemblyResult.ClosingStructures, ExportableFailureMechanismType.BSKW), - CreateTuple(assemblyResult.PipingStructure, ExportableFailureMechanismType.PKW), - CreateTuple(assemblyResult.StabilityPointStructures, ExportableFailureMechanismType.STKWp), - CreateTuple(assemblyResult.DuneErosion, ExportableFailureMechanismType.DA) + CreateTuple(assemblyResult.Piping, assessmentSection.Piping), + CreateTuple(assemblyResult.GrassCoverErosionInwards, assessmentSection.GrassCoverErosionInwards), + CreateTuple(assemblyResult.MacroStabilityInwards, assessmentSection.MacroStabilityInwards), + CreateTuple(assemblyResult.Microstability, assessmentSection.Microstability), + CreateTuple(assemblyResult.StabilityStoneCover, assessmentSection.StabilityStoneCover), + CreateTuple(assemblyResult.WaveImpactAsphaltCover, assessmentSection.WaveImpactAsphaltCover), + CreateTuple(assemblyResult.WaterPressureAsphaltCover, assessmentSection.WaterPressureAsphaltCover), + CreateTuple(assemblyResult.GrassCoverErosionOutwards, assessmentSection.GrassCoverErosionOutwards), + CreateTuple(assemblyResult.GrassCoverSlipOffOutwards, assessmentSection.GrassCoverSlipOffOutwards), + CreateTuple(assemblyResult.GrassCoverSlipOffInwards, assessmentSection.GrassCoverSlipOffInwards), + CreateTuple(assemblyResult.HeightStructures, assessmentSection.HeightStructures), + CreateTuple(assemblyResult.ClosingStructures, assessmentSection.ClosingStructures), + CreateTuple(assemblyResult.PipingStructure, assessmentSection.PipingStructure), + CreateTuple(assemblyResult.StabilityPointStructures, assessmentSection.StabilityPointStructures), + CreateTuple(assemblyResult.DuneErosion, assessmentSection.DuneErosion) }; return failureMechanisms.Where(fm => fm.Item1.HasValue) .Select(fm => CreateExportableFailureMechanismCombinedSectionAssemblyResult(fm.Item1.Value, fm.Item2)) .ToArray(); } - private static Tuple CreateTuple( - FailureMechanismSectionAssemblyGroup? assemblyResultGroup, ExportableFailureMechanismType exportableFailureMechanismType) + private static Tuple CreateTuple( + FailureMechanismSectionAssemblyGroup? assemblyResultGroup, IFailurePath failureMechanism) { - return new Tuple(assemblyResultGroup, exportableFailureMechanismType); + return new Tuple(assemblyResultGroup, failureMechanism.Code); } private static ExportableFailureMechanismCombinedSectionAssemblyResult CreateExportableFailureMechanismCombinedSectionAssemblyResult( FailureMechanismSectionAssemblyGroup sectionAssemblyGroup, - ExportableFailureMechanismType failureMechanismCode) + string failureMechanismCode) { return new ExportableFailureMechanismCombinedSectionAssemblyResult( new ExportableFailureMechanismSubSectionAssemblyResult(sectionAssemblyGroup, ExportableAssemblyMethod.WBI3B1), Index: Riskeer/Integration/src/Riskeer.Integration.IO/Factories/ExportableFailureMechanismFactory.cs =================================================================== diff -u -r8a09d1b08bc5330769c3c2a74aa7cbfcf0e47890 -r2077c21eebd3514bbc3f49f2cf9039100760f966 --- Riskeer/Integration/src/Riskeer.Integration.IO/Factories/ExportableFailureMechanismFactory.cs (.../ExportableFailureMechanismFactory.cs) (revision 8a09d1b08bc5330769c3c2a74aa7cbfcf0e47890) +++ Riskeer/Integration/src/Riskeer.Integration.IO/Factories/ExportableFailureMechanismFactory.cs (.../ExportableFailureMechanismFactory.cs) (revision 2077c21eebd3514bbc3f49f2cf9039100760f966) @@ -47,7 +47,6 @@ /// the failure mechanism assembly. /// The /// to perform the failure mechanism section assembly. - /// The type of the exportable failure mechanism. /// The type of the failure mechanism. /// The type of the section result. /// An with assembly results. @@ -58,8 +57,7 @@ public static ExportableFailureMechanism CreateExportableFailureMechanism( TFailureMechanism failureMechanism, IAssessmentSection assessmentSection, Func assembleFailureMechanismFunc, - Func assembleFailureMechanismSectionFunc, - ExportableFailureMechanismType failureMechanismType) + Func assembleFailureMechanismSectionFunc) where TFailureMechanism : IFailurePath where TSectionResult : FailureMechanismSectionResult { @@ -89,7 +87,7 @@ failureMechanism.AssemblyResult.IsManualProbability()), CreateExportableFailureMechanismSectionResults( failureMechanism, assessmentSection, assembleFailureMechanismSectionFunc), - failureMechanismType); + failureMechanism.Code); } /// Index: Riskeer/Integration/test/Riskeer.Integration.IO.Test/Factories/ExportableAssessmentSectionFactoryTest.cs =================================================================== diff -u -r5043fc31464a612ec3d6f7e0551691b013e70b9d -r2077c21eebd3514bbc3f49f2cf9039100760f966 --- Riskeer/Integration/test/Riskeer.Integration.IO.Test/Factories/ExportableAssessmentSectionFactoryTest.cs (.../ExportableAssessmentSectionFactoryTest.cs) (revision 5043fc31464a612ec3d6f7e0551691b013e70b9d) +++ Riskeer/Integration/test/Riskeer.Integration.IO.Test/Factories/ExportableAssessmentSectionFactoryTest.cs (.../ExportableAssessmentSectionFactoryTest.cs) (revision 2077c21eebd3514bbc3f49f2cf9039100760f966) @@ -137,7 +137,7 @@ FailureMechanismTestHelper.AddSections(assessmentSection.GrassCoverSlipOffInwards, random.Next(1, 10)); FailureMechanismTestHelper.AddSections(assessmentSection.PipingStructure, random.Next(1, 10)); FailureMechanismTestHelper.AddSections(assessmentSection.WaterPressureAsphaltCover, random.Next(1, 10)); - + foreach (IFailureMechanism failureMechanism in assessmentSection.GetFailureMechanisms()) { failureMechanism.InAssembly = false; @@ -169,72 +169,56 @@ { Assert.AreEqual(15, exportableFailureMechanisms.Count()); - AssertExportableFailureMechanism(ExportableFailureMechanismType.STPH, - assessmentSection.Piping, + AssertExportableFailureMechanism(assessmentSection.Piping, exportableFailureMechanisms.ElementAt(0)); - AssertExportableFailureMechanism(ExportableFailureMechanismType.STBI, - assessmentSection.MacroStabilityInwards, + AssertExportableFailureMechanism(assessmentSection.MacroStabilityInwards, exportableFailureMechanisms.ElementAt(1)); - AssertExportableFailureMechanism(ExportableFailureMechanismType.GEKB, - assessmentSection.GrassCoverErosionInwards, + AssertExportableFailureMechanism(assessmentSection.GrassCoverErosionInwards, exportableFailureMechanisms.ElementAt(2)); - AssertExportableFailureMechanism(ExportableFailureMechanismType.HTKW, - assessmentSection.HeightStructures, + AssertExportableFailureMechanism(assessmentSection.HeightStructures, exportableFailureMechanisms.ElementAt(3)); - AssertExportableFailureMechanism(ExportableFailureMechanismType.BSKW, - assessmentSection.ClosingStructures, + AssertExportableFailureMechanism(assessmentSection.ClosingStructures, exportableFailureMechanisms.ElementAt(4)); - AssertExportableFailureMechanism(ExportableFailureMechanismType.STKWp, - assessmentSection.StabilityPointStructures, + AssertExportableFailureMechanism(assessmentSection.StabilityPointStructures, exportableFailureMechanisms.ElementAt(5)); - AssertExportableFailureMechanism(ExportableFailureMechanismType.ZST, - assessmentSection.StabilityStoneCover, + AssertExportableFailureMechanism(assessmentSection.StabilityStoneCover, exportableFailureMechanisms.ElementAt(6)); - AssertExportableFailureMechanism(ExportableFailureMechanismType.AGK, - assessmentSection.WaveImpactAsphaltCover, + AssertExportableFailureMechanism(assessmentSection.WaveImpactAsphaltCover, exportableFailureMechanisms.ElementAt(7)); - AssertExportableFailureMechanism(ExportableFailureMechanismType.GEBU, - assessmentSection.GrassCoverErosionOutwards, + AssertExportableFailureMechanism(assessmentSection.GrassCoverErosionOutwards, exportableFailureMechanisms.ElementAt(8)); - AssertExportableFailureMechanism(ExportableFailureMechanismType.DA, - assessmentSection.DuneErosion, + AssertExportableFailureMechanism(assessmentSection.DuneErosion, exportableFailureMechanisms.ElementAt(9)); - AssertExportableFailureMechanism(ExportableFailureMechanismType.STMI, - assessmentSection.Microstability, + AssertExportableFailureMechanism(assessmentSection.Microstability, exportableFailureMechanisms.ElementAt(10)); - AssertExportableFailureMechanism(ExportableFailureMechanismType.GABU, - assessmentSection.GrassCoverSlipOffOutwards, + AssertExportableFailureMechanism(assessmentSection.GrassCoverSlipOffOutwards, exportableFailureMechanisms.ElementAt(11)); - AssertExportableFailureMechanism(ExportableFailureMechanismType.GABI, - assessmentSection.GrassCoverSlipOffInwards, + AssertExportableFailureMechanism(assessmentSection.GrassCoverSlipOffInwards, exportableFailureMechanisms.ElementAt(12)); - AssertExportableFailureMechanism(ExportableFailureMechanismType.PKW, - assessmentSection.PipingStructure, + AssertExportableFailureMechanism(assessmentSection.PipingStructure, exportableFailureMechanisms.ElementAt(13)); - AssertExportableFailureMechanism(ExportableFailureMechanismType.AWO, - assessmentSection.WaterPressureAsphaltCover, + AssertExportableFailureMechanism(assessmentSection.WaterPressureAsphaltCover, exportableFailureMechanisms.ElementAt(14)); } - private static void AssertExportableFailureMechanism(ExportableFailureMechanismType expectedFailureMechanismCode, - IFailurePath failureMechanism, + private static void AssertExportableFailureMechanism(IFailurePath failureMechanism, ExportableFailureMechanism actualExportableFailureMechanism) { - Assert.AreEqual(expectedFailureMechanismCode, actualExportableFailureMechanism.Code); + Assert.AreEqual(failureMechanism.Code, actualExportableFailureMechanism.Code); ExportableFailureMechanismAssemblyResult exportableFailureMechanismAssemblyResult = actualExportableFailureMechanism.FailureMechanismAssembly; Assert.AreEqual(0, exportableFailureMechanismAssemblyResult.Probability); Index: Riskeer/Integration/test/Riskeer.Integration.IO.Test/Factories/ExportableCombinedSectionAssemblyFactoryTest.cs =================================================================== diff -u -rdcd80735dd7682025912868373380ff62377cbb7 -r2077c21eebd3514bbc3f49f2cf9039100760f966 --- Riskeer/Integration/test/Riskeer.Integration.IO.Test/Factories/ExportableCombinedSectionAssemblyFactoryTest.cs (.../ExportableCombinedSectionAssemblyFactoryTest.cs) (revision dcd80735dd7682025912868373380ff62377cbb7) +++ Riskeer/Integration/test/Riskeer.Integration.IO.Test/Factories/ExportableCombinedSectionAssemblyFactoryTest.cs (.../ExportableCombinedSectionAssemblyFactoryTest.cs) (revision 2077c21eebd3514bbc3f49f2cf9039100760f966) @@ -27,6 +27,7 @@ using NUnit.Framework; using Riskeer.AssemblyTool.Data; using Riskeer.Common.Data.AssessmentSection; +using Riskeer.Integration.Data; using Riskeer.Integration.Data.Assembly; using Riskeer.Integration.IO.Assembly; using Riskeer.Integration.IO.Factories; @@ -42,23 +43,23 @@ { // Call void Call() => ExportableCombinedSectionAssemblyFactory.CreateExportableCombinedSectionAssemblyCollection( - null, new ReferenceLine()); + null, new AssessmentSection(AssessmentSectionComposition.Dike)); // Assert var exception = Assert.Throws(Call); Assert.AreEqual("combinedSectionAssemblyResults", exception.ParamName); } [Test] - public void CreateExportableCombinedSectionAssemblyCollection_ReferenceLineNull_ThrowsArgumentNullException() + public void CreateExportableCombinedSectionAssemblyCollection_AssessmentSectionNull_ThrowsArgumentNullException() { // Call void Call() => ExportableCombinedSectionAssemblyFactory.CreateExportableCombinedSectionAssemblyCollection( Enumerable.Empty(), null); // Assert var exception = Assert.Throws(Call); - Assert.AreEqual("referenceLine", exception.ParamName); + Assert.AreEqual("assessmentSection", exception.ParamName); } [Test] @@ -67,12 +68,13 @@ public void CreateExportableCombinedSectionAssemblyCollection_WithAssemblyResults_ReturnsExportableCombinedSectionAssemblyCollection(bool hasAssemblyGroupResults) { // Setup - var referenceLine = new ReferenceLine(); - referenceLine.SetGeometry(new[] + var assessmentSection = new AssessmentSection(AssessmentSectionComposition.Dike); + assessmentSection.ReferenceLine.SetGeometry(new[] { new Point2D(0, 0), new Point2D(2, 2) }); + CombinedFailureMechanismSectionAssemblyResult[] assemblyResults = { CreateCombinedFailureMechanismSectionAssemblyResult(21, hasAssemblyGroupResults), @@ -81,10 +83,12 @@ // Call IEnumerable exportableCombinedSectionAssemblies = - ExportableCombinedSectionAssemblyFactory.CreateExportableCombinedSectionAssemblyCollection(assemblyResults, referenceLine); + ExportableCombinedSectionAssemblyFactory.CreateExportableCombinedSectionAssemblyCollection(assemblyResults, assessmentSection); // Assert - AssertCombinedFailureMechanismSectionAssemblyResults(assemblyResults, exportableCombinedSectionAssemblies, referenceLine, hasAssemblyGroupResults); + AssertCombinedFailureMechanismSectionAssemblyResults( + assemblyResults, exportableCombinedSectionAssemblies, + assessmentSection.ReferenceLine, hasAssemblyGroupResults); } private static CombinedFailureMechanismSectionAssemblyResult CreateCombinedFailureMechanismSectionAssemblyResult(int seed, bool hasAssemblyGroupResults) @@ -177,49 +181,49 @@ Assert.IsTrue(failureMechanismCombinedSectionResults.All(result => result.SectionAssemblyResult.AssemblyMethod == ExportableAssemblyMethod.WBI3B1)); Assert.AreEqual(expectedSection.Piping, failureMechanismCombinedSectionResults.ElementAt(0).SectionAssemblyResult.AssemblyGroup); - Assert.AreEqual(ExportableFailureMechanismType.STPH, failureMechanismCombinedSectionResults.ElementAt(0).Code); + Assert.AreEqual("STPH", failureMechanismCombinedSectionResults.ElementAt(0).Code); Assert.AreEqual(expectedSection.GrassCoverErosionInwards, failureMechanismCombinedSectionResults.ElementAt(1).SectionAssemblyResult.AssemblyGroup); - Assert.AreEqual(ExportableFailureMechanismType.GEKB, failureMechanismCombinedSectionResults.ElementAt(1).Code); + Assert.AreEqual("GEKB", failureMechanismCombinedSectionResults.ElementAt(1).Code); Assert.AreEqual(expectedSection.MacroStabilityInwards, failureMechanismCombinedSectionResults.ElementAt(2).SectionAssemblyResult.AssemblyGroup); - Assert.AreEqual(ExportableFailureMechanismType.STBI, failureMechanismCombinedSectionResults.ElementAt(2).Code); + Assert.AreEqual("STBI", failureMechanismCombinedSectionResults.ElementAt(2).Code); Assert.AreEqual(expectedSection.Microstability, failureMechanismCombinedSectionResults.ElementAt(3).SectionAssemblyResult.AssemblyGroup); - Assert.AreEqual(ExportableFailureMechanismType.STMI, failureMechanismCombinedSectionResults.ElementAt(3).Code); + Assert.AreEqual("STMI", failureMechanismCombinedSectionResults.ElementAt(3).Code); Assert.AreEqual(expectedSection.StabilityStoneCover, failureMechanismCombinedSectionResults.ElementAt(4).SectionAssemblyResult.AssemblyGroup); - Assert.AreEqual(ExportableFailureMechanismType.ZST, failureMechanismCombinedSectionResults.ElementAt(4).Code); + Assert.AreEqual("ZST", failureMechanismCombinedSectionResults.ElementAt(4).Code); Assert.AreEqual(expectedSection.WaveImpactAsphaltCover, failureMechanismCombinedSectionResults.ElementAt(5).SectionAssemblyResult.AssemblyGroup); - Assert.AreEqual(ExportableFailureMechanismType.AGK, failureMechanismCombinedSectionResults.ElementAt(5).Code); + Assert.AreEqual("AGK", failureMechanismCombinedSectionResults.ElementAt(5).Code); Assert.AreEqual(expectedSection.WaterPressureAsphaltCover, failureMechanismCombinedSectionResults.ElementAt(6).SectionAssemblyResult.AssemblyGroup); - Assert.AreEqual(ExportableFailureMechanismType.AWO, failureMechanismCombinedSectionResults.ElementAt(6).Code); + Assert.AreEqual("AWO", failureMechanismCombinedSectionResults.ElementAt(6).Code); Assert.AreEqual(expectedSection.GrassCoverErosionOutwards, failureMechanismCombinedSectionResults.ElementAt(7).SectionAssemblyResult.AssemblyGroup); - Assert.AreEqual(ExportableFailureMechanismType.GEBU, failureMechanismCombinedSectionResults.ElementAt(7).Code); + Assert.AreEqual("GEBU", failureMechanismCombinedSectionResults.ElementAt(7).Code); Assert.AreEqual(expectedSection.GrassCoverSlipOffOutwards, failureMechanismCombinedSectionResults.ElementAt(8).SectionAssemblyResult.AssemblyGroup); - Assert.AreEqual(ExportableFailureMechanismType.GABU, failureMechanismCombinedSectionResults.ElementAt(8).Code); + Assert.AreEqual("GABU", failureMechanismCombinedSectionResults.ElementAt(8).Code); Assert.AreEqual(expectedSection.GrassCoverSlipOffInwards, failureMechanismCombinedSectionResults.ElementAt(9).SectionAssemblyResult.AssemblyGroup); - Assert.AreEqual(ExportableFailureMechanismType.GABI, failureMechanismCombinedSectionResults.ElementAt(9).Code); + Assert.AreEqual("GABI", failureMechanismCombinedSectionResults.ElementAt(9).Code); Assert.AreEqual(expectedSection.HeightStructures, failureMechanismCombinedSectionResults.ElementAt(10).SectionAssemblyResult.AssemblyGroup); - Assert.AreEqual(ExportableFailureMechanismType.HTKW, failureMechanismCombinedSectionResults.ElementAt(10).Code); + Assert.AreEqual("HTKW", failureMechanismCombinedSectionResults.ElementAt(10).Code); Assert.AreEqual(expectedSection.ClosingStructures, failureMechanismCombinedSectionResults.ElementAt(11).SectionAssemblyResult.AssemblyGroup); - Assert.AreEqual(ExportableFailureMechanismType.BSKW, failureMechanismCombinedSectionResults.ElementAt(11).Code); + Assert.AreEqual("BSKW", failureMechanismCombinedSectionResults.ElementAt(11).Code); Assert.AreEqual(expectedSection.PipingStructure, failureMechanismCombinedSectionResults.ElementAt(12).SectionAssemblyResult.AssemblyGroup); - Assert.AreEqual(ExportableFailureMechanismType.PKW, failureMechanismCombinedSectionResults.ElementAt(12).Code); + Assert.AreEqual("PKW", failureMechanismCombinedSectionResults.ElementAt(12).Code); Assert.AreEqual(expectedSection.StabilityPointStructures, failureMechanismCombinedSectionResults.ElementAt(13).SectionAssemblyResult.AssemblyGroup); - Assert.AreEqual(ExportableFailureMechanismType.STKWp, failureMechanismCombinedSectionResults.ElementAt(13).Code); + Assert.AreEqual("STKWp", failureMechanismCombinedSectionResults.ElementAt(13).Code); Assert.AreEqual(expectedSection.DuneErosion, failureMechanismCombinedSectionResults.ElementAt(14).SectionAssemblyResult.AssemblyGroup); - Assert.AreEqual(ExportableFailureMechanismType.DA, failureMechanismCombinedSectionResults.ElementAt(14).Code); + Assert.AreEqual("DA", failureMechanismCombinedSectionResults.ElementAt(14).Code); } } } \ No newline at end of file Index: Riskeer/Integration/test/Riskeer.Integration.IO.Test/Factories/ExportableFailureMechanismFactoryTest.cs =================================================================== diff -u -r9a185e879a64c1fc1e71c3ffea0f6d77aaff701a -r2077c21eebd3514bbc3f49f2cf9039100760f966 --- Riskeer/Integration/test/Riskeer.Integration.IO.Test/Factories/ExportableFailureMechanismFactoryTest.cs (.../ExportableFailureMechanismFactoryTest.cs) (revision 9a185e879a64c1fc1e71c3ffea0f6d77aaff701a) +++ Riskeer/Integration/test/Riskeer.Integration.IO.Test/Factories/ExportableFailureMechanismFactoryTest.cs (.../ExportableFailureMechanismFactoryTest.cs) (revision 2077c21eebd3514bbc3f49f2cf9039100760f966) @@ -45,12 +45,9 @@ var assessmentSection = mocks.Stub(); mocks.ReplayAll(); - var random = new Random(21); - // Call void Call() => ExportableFailureMechanismFactory.CreateExportableFailureMechanism( - null, assessmentSection, (fm, section) => double.NaN, (sr, fm, section) => null, - random.NextEnumValue()); + null, assessmentSection, (fm, section) => double.NaN, (sr, fm, section) => null); // Assert var exception = Assert.Throws(Call); @@ -61,13 +58,9 @@ [Test] public void CreateExportableFailureMechanism_AssessmentSectionNull_ThrowsArgumentNullException() { - // Setup - var random = new Random(21); - // Call void Call() => ExportableFailureMechanismFactory.CreateExportableFailureMechanism( - new TestFailureMechanism(), null, (fm, section) => double.NaN, (sr, fm, section) => null, - random.NextEnumValue()); + new TestFailureMechanism(), null, (fm, section) => double.NaN, (sr, fm, section) => null); // Assert var exception = Assert.Throws(Call); @@ -82,12 +75,9 @@ var assessmentSection = mocks.Stub(); mocks.ReplayAll(); - var random = new Random(21); - // Call void Call() => ExportableFailureMechanismFactory.CreateExportableFailureMechanism( - new TestFailureMechanism(), assessmentSection, null, (sr, fm, section) => null, - random.NextEnumValue()); + new TestFailureMechanism(), assessmentSection, null, (sr, fm, section) => null); // Assert var exception = Assert.Throws(Call); @@ -103,12 +93,9 @@ var assessmentSection = mocks.Stub(); mocks.ReplayAll(); - var random = new Random(21); - // Call void Call() => ExportableFailureMechanismFactory.CreateExportableFailureMechanism( - new TestFailureMechanism(), assessmentSection, (fm, section) => double.NaN, null, - random.NextEnumValue()); + new TestFailureMechanism(), assessmentSection, (fm, section) => double.NaN, null); // Assert var exception = Assert.Throws(Call); @@ -126,7 +113,6 @@ var assessmentSection = new AssessmentSectionStub(); double probability = random.NextDouble(); - var failureMechanismType = random.NextEnumValue(); var expectedSectionOutput = new FailureMechanismSectionAssemblyResult( random.NextDouble(), random.NextDouble(), random.NextDouble(), random.NextEnumValue()); @@ -135,10 +121,10 @@ ExportableFailureMechanism exportableFailureMechanism = ExportableFailureMechanismFactory.CreateExportableFailureMechanism( failureMechanism, assessmentSection, (fm, section) => probability, - (sr, fm, section) => expectedSectionOutput, failureMechanismType); + (sr, fm, section) => expectedSectionOutput); // Assert - Assert.AreEqual(failureMechanismType, exportableFailureMechanism.Code); + Assert.AreEqual(failureMechanism.Code, exportableFailureMechanism.Code); ExportableFailureMechanismAssemblyResult exportableFailureMechanismAssembly = exportableFailureMechanism.FailureMechanismAssembly; Assert.AreEqual(probability, exportableFailureMechanismAssembly.Probability);