Index: Riskeer/Integration/src/Riskeer.Integration.Data/Assembly/AssessmentSectionAssemblyFactory.cs =================================================================== diff -u -rffec70662c33e5a611430ae73fa4d8cef5cdf147 -r89039d4a60d80904883f2ea76f98108595a9accf --- Riskeer/Integration/src/Riskeer.Integration.Data/Assembly/AssessmentSectionAssemblyFactory.cs (.../AssessmentSectionAssemblyFactory.cs) (revision ffec70662c33e5a611430ae73fa4d8cef5cdf147) +++ Riskeer/Integration/src/Riskeer.Integration.Data/Assembly/AssessmentSectionAssemblyFactory.cs (.../AssessmentSectionAssemblyFactory.cs) (revision 89039d4a60d80904883f2ea76f98108595a9accf) @@ -174,9 +174,9 @@ try { - IAssemblyToolCalculatorFactoryOld calculatorFactory = AssemblyToolCalculatorFactoryOld.Instance; - IAssessmentSectionAssemblyCalculatorOld calculator = - calculatorFactory.CreateAssessmentSectionAssemblyCalculator(AssemblyToolKernelFactoryOld.Instance); + IAssemblyToolCalculatorFactory calculatorFactory = AssemblyToolCalculatorFactory.Instance; + IAssessmentSectionAssemblyCalculator calculator = calculatorFactory.CreateAssessmentSectionAssemblyCalculator( + AssemblyToolKernelFactory.Instance); Dictionary failureMechanismsToAssemble = assessmentSection.GetFailureMechanisms() .Where(fm => fm.InAssembly) @@ -187,8 +187,8 @@ }) .ToDictionary(x => x.FailureMechanism, x => x.Index); - IEnumerable output = calculator.AssembleCombinedFailureMechanismSections( - CombinedAssemblyFailureMechanismSectionFactory.CreateInput(assessmentSection, failureMechanismsToAssemble.Keys, useManual), + IEnumerable output = calculator.AssembleCombinedFailureMechanismSections( + CombinedAssemblyFailureMechanismSectionFactory.CreateInput(assessmentSection, failureMechanismsToAssemble.Keys), assessmentSection.ReferenceLine.Length); return CombinedFailureMechanismSectionAssemblyResultFactory.Create(output, failureMechanismsToAssemble, assessmentSection); Index: Riskeer/Integration/src/Riskeer.Integration.Data/Assembly/CombinedAssemblyFailureMechanismSectionFactory.cs =================================================================== diff -u -rbc62f7dca76fde0cf2b8f50603b14e251ccd1372 -r89039d4a60d80904883f2ea76f98108595a9accf --- Riskeer/Integration/src/Riskeer.Integration.Data/Assembly/CombinedAssemblyFailureMechanismSectionFactory.cs (.../CombinedAssemblyFailureMechanismSectionFactory.cs) (revision bc62f7dca76fde0cf2b8f50603b14e251ccd1372) +++ Riskeer/Integration/src/Riskeer.Integration.Data/Assembly/CombinedAssemblyFailureMechanismSectionFactory.cs (.../CombinedAssemblyFailureMechanismSectionFactory.cs) (revision 89039d4a60d80904883f2ea76f98108595a9accf) @@ -170,8 +170,9 @@ return sectionResults.Select(sectionResult => { + FailureMechanismSectionAssemblyResult failureMechanismSectionAssemblyResult = getAssemblyFunc(sectionResult, assessmentSection); CombinedAssemblyFailureMechanismSection section = CreateSection( - sectionResult, getAssemblyFunc(sectionResult, assessmentSection).AssemblyGroup, totalSectionsLength); + sectionResult, failureMechanismSectionAssemblyResult.AssemblyGroup, totalSectionsLength); totalSectionsLength = section.SectionEnd; return section; }) Index: Riskeer/Integration/src/Riskeer.Integration.Data/Assembly/CombinedFailureMechanismSectionAssemblyResult.cs =================================================================== diff -u -r520b3153840dada327c8bd936a4d6a7a07427331 -r89039d4a60d80904883f2ea76f98108595a9accf --- Riskeer/Integration/src/Riskeer.Integration.Data/Assembly/CombinedFailureMechanismSectionAssemblyResult.cs (.../CombinedFailureMechanismSectionAssemblyResult.cs) (revision 520b3153840dada327c8bd936a4d6a7a07427331) +++ Riskeer/Integration/src/Riskeer.Integration.Data/Assembly/CombinedFailureMechanismSectionAssemblyResult.cs (.../CombinedFailureMechanismSectionAssemblyResult.cs) (revision 89039d4a60d80904883f2ea76f98108595a9accf) @@ -43,7 +43,7 @@ /// Thrown when /// is null. public CombinedFailureMechanismSectionAssemblyResult(int sectionNumber, double sectionStart, double sectionEnd, - FailureMechanismSectionAssemblyCategoryGroup totalResult, + FailureMechanismSectionAssemblyGroup totalResult, ConstructionProperties properties) { if (properties == null) @@ -92,82 +92,82 @@ /// /// Gets the total assembly result. /// - public FailureMechanismSectionAssemblyCategoryGroup TotalResult { get; } + public FailureMechanismSectionAssemblyGroup TotalResult { get; } /// /// Gets the assembly result for piping. /// - public FailureMechanismSectionAssemblyCategoryGroup Piping { get; } + public FailureMechanismSectionAssemblyGroup Piping { get; } /// /// Gets the assembly result for grass cover erosion inwards. /// - public FailureMechanismSectionAssemblyCategoryGroup GrassCoverErosionInwards { get; } + public FailureMechanismSectionAssemblyGroup GrassCoverErosionInwards { get; } /// /// Gets the assembly result for macro stability inwards. /// - public FailureMechanismSectionAssemblyCategoryGroup MacroStabilityInwards { get; } + public FailureMechanismSectionAssemblyGroup MacroStabilityInwards { get; } /// /// Gets the assembly result for microstability. /// - public FailureMechanismSectionAssemblyCategoryGroup Microstability { get; } + public FailureMechanismSectionAssemblyGroup Microstability { get; } /// /// Gets the assembly result for stability stone cover. /// - public FailureMechanismSectionAssemblyCategoryGroup StabilityStoneCover { get; } + public FailureMechanismSectionAssemblyGroup StabilityStoneCover { get; } /// /// Gets the assembly result for wave impact asphalt cover. /// - public FailureMechanismSectionAssemblyCategoryGroup WaveImpactAsphaltCover { get; } + public FailureMechanismSectionAssemblyGroup WaveImpactAsphaltCover { get; } /// /// Gets the assembly result for water pressure asphalt cover. /// - public FailureMechanismSectionAssemblyCategoryGroup WaterPressureAsphaltCover { get; } + public FailureMechanismSectionAssemblyGroup WaterPressureAsphaltCover { get; } /// /// Gets the assembly result for grass cover erosion outwards. /// - public FailureMechanismSectionAssemblyCategoryGroup GrassCoverErosionOutwards { get; } + public FailureMechanismSectionAssemblyGroup GrassCoverErosionOutwards { get; } /// /// Gets the assembly result for grass cover slip off outwards. /// - public FailureMechanismSectionAssemblyCategoryGroup GrassCoverSlipOffOutwards { get; } + public FailureMechanismSectionAssemblyGroup GrassCoverSlipOffOutwards { get; } /// /// Gets the assembly result for grass cover slip off inwards. /// - public FailureMechanismSectionAssemblyCategoryGroup GrassCoverSlipOffInwards { get; } + public FailureMechanismSectionAssemblyGroup GrassCoverSlipOffInwards { get; } /// /// Gets the assembly result for height structures. /// - public FailureMechanismSectionAssemblyCategoryGroup HeightStructures { get; } + public FailureMechanismSectionAssemblyGroup HeightStructures { get; } /// /// Gets the assembly result for closing structures. /// - public FailureMechanismSectionAssemblyCategoryGroup ClosingStructures { get; } + public FailureMechanismSectionAssemblyGroup ClosingStructures { get; } /// /// Gets the assembly result for piping structure. /// - public FailureMechanismSectionAssemblyCategoryGroup PipingStructure { get; } + public FailureMechanismSectionAssemblyGroup PipingStructure { get; } /// /// Gets the assembly result for stability point structures. /// - public FailureMechanismSectionAssemblyCategoryGroup StabilityPointStructures { get; } + public FailureMechanismSectionAssemblyGroup StabilityPointStructures { get; } /// /// Gets the assembly result for dune erosion. /// - public FailureMechanismSectionAssemblyCategoryGroup DuneErosion { get; } + public FailureMechanismSectionAssemblyGroup DuneErosion { get; } /// /// Container for properties for constructing a . @@ -179,97 +179,97 @@ /// public ConstructionProperties() { - Piping = FailureMechanismSectionAssemblyCategoryGroup.None; - GrassCoverErosionInwards = FailureMechanismSectionAssemblyCategoryGroup.None; - MacroStabilityInwards = FailureMechanismSectionAssemblyCategoryGroup.None; - Microstability = FailureMechanismSectionAssemblyCategoryGroup.None; - StabilityStoneCover = FailureMechanismSectionAssemblyCategoryGroup.None; - WaveImpactAsphaltCover = FailureMechanismSectionAssemblyCategoryGroup.None; - WaterPressureAsphaltCover = FailureMechanismSectionAssemblyCategoryGroup.None; - GrassCoverErosionOutwards = FailureMechanismSectionAssemblyCategoryGroup.None; - GrassCoverSlipOffOutwards = FailureMechanismSectionAssemblyCategoryGroup.None; - GrassCoverSlipOffInwards = FailureMechanismSectionAssemblyCategoryGroup.None; - HeightStructures = FailureMechanismSectionAssemblyCategoryGroup.None; - ClosingStructures = FailureMechanismSectionAssemblyCategoryGroup.None; - PipingStructure = FailureMechanismSectionAssemblyCategoryGroup.None; - StabilityPointStructures = FailureMechanismSectionAssemblyCategoryGroup.None; - DuneErosion = FailureMechanismSectionAssemblyCategoryGroup.None; + Piping = FailureMechanismSectionAssemblyGroup.Gr; + GrassCoverErosionInwards = FailureMechanismSectionAssemblyGroup.Gr; + MacroStabilityInwards = FailureMechanismSectionAssemblyGroup.Gr; + Microstability = FailureMechanismSectionAssemblyGroup.Gr; + StabilityStoneCover = FailureMechanismSectionAssemblyGroup.Gr; + WaveImpactAsphaltCover = FailureMechanismSectionAssemblyGroup.Gr; + WaterPressureAsphaltCover = FailureMechanismSectionAssemblyGroup.Gr; + GrassCoverErosionOutwards = FailureMechanismSectionAssemblyGroup.Gr; + GrassCoverSlipOffOutwards = FailureMechanismSectionAssemblyGroup.Gr; + GrassCoverSlipOffInwards = FailureMechanismSectionAssemblyGroup.Gr; + HeightStructures = FailureMechanismSectionAssemblyGroup.Gr; + ClosingStructures = FailureMechanismSectionAssemblyGroup.Gr; + PipingStructure = FailureMechanismSectionAssemblyGroup.Gr; + StabilityPointStructures = FailureMechanismSectionAssemblyGroup.Gr; + DuneErosion = FailureMechanismSectionAssemblyGroup.Gr; } /// /// Gets or sets the assembly result for piping. /// - public FailureMechanismSectionAssemblyCategoryGroup Piping { internal get; set; } + public FailureMechanismSectionAssemblyGroup Piping { internal get; set; } /// /// Gets or sets the assembly result for grass cover erosion inwards. /// - public FailureMechanismSectionAssemblyCategoryGroup GrassCoverErosionInwards { internal get; set; } + public FailureMechanismSectionAssemblyGroup GrassCoverErosionInwards { internal get; set; } /// /// Gets or sets the assembly result for macro stability inwards. /// - public FailureMechanismSectionAssemblyCategoryGroup MacroStabilityInwards { internal get; set; } + public FailureMechanismSectionAssemblyGroup MacroStabilityInwards { internal get; set; } /// /// Gets or sets the assembly result for microstability. /// - public FailureMechanismSectionAssemblyCategoryGroup Microstability { internal get; set; } + public FailureMechanismSectionAssemblyGroup Microstability { internal get; set; } /// /// Gets or sets the assembly result for stability stone cover. /// - public FailureMechanismSectionAssemblyCategoryGroup StabilityStoneCover { internal get; set; } + public FailureMechanismSectionAssemblyGroup StabilityStoneCover { internal get; set; } /// /// Gets or sets the assembly result for wave impact asphalt cover. /// - public FailureMechanismSectionAssemblyCategoryGroup WaveImpactAsphaltCover { internal get; set; } + public FailureMechanismSectionAssemblyGroup WaveImpactAsphaltCover { internal get; set; } /// /// Gets or sets the assembly result for water pressure asphalt cover. /// - public FailureMechanismSectionAssemblyCategoryGroup WaterPressureAsphaltCover { internal get; set; } + public FailureMechanismSectionAssemblyGroup WaterPressureAsphaltCover { internal get; set; } /// /// Gets or sets the assembly result for grass cover erosion outwards. /// - public FailureMechanismSectionAssemblyCategoryGroup GrassCoverErosionOutwards { internal get; set; } + public FailureMechanismSectionAssemblyGroup GrassCoverErosionOutwards { internal get; set; } /// /// Gets or sets the assembly result for grass cover slip off outwards. /// - public FailureMechanismSectionAssemblyCategoryGroup GrassCoverSlipOffOutwards { internal get; set; } + public FailureMechanismSectionAssemblyGroup GrassCoverSlipOffOutwards { internal get; set; } /// /// Gets or sets the assembly result for grass cover slip off inwards. /// - public FailureMechanismSectionAssemblyCategoryGroup GrassCoverSlipOffInwards { internal get; set; } + public FailureMechanismSectionAssemblyGroup GrassCoverSlipOffInwards { internal get; set; } /// /// Gets or sets the assembly result for height structures. /// - public FailureMechanismSectionAssemblyCategoryGroup HeightStructures { internal get; set; } + public FailureMechanismSectionAssemblyGroup HeightStructures { internal get; set; } /// /// Gets or sets the assembly result for closing structures. /// - public FailureMechanismSectionAssemblyCategoryGroup ClosingStructures { internal get; set; } + public FailureMechanismSectionAssemblyGroup ClosingStructures { internal get; set; } /// /// Gets or sets the assembly result for piping structure. /// - public FailureMechanismSectionAssemblyCategoryGroup PipingStructure { internal get; set; } + public FailureMechanismSectionAssemblyGroup PipingStructure { internal get; set; } /// /// Gets or sets the assembly result for stability point structures. /// - public FailureMechanismSectionAssemblyCategoryGroup StabilityPointStructures { internal get; set; } + public FailureMechanismSectionAssemblyGroup StabilityPointStructures { internal get; set; } /// /// Gets or sets the assembly result for dune erosion. /// - public FailureMechanismSectionAssemblyCategoryGroup DuneErosion { internal get; set; } + public FailureMechanismSectionAssemblyGroup DuneErosion { internal get; set; } } } } \ No newline at end of file Index: Riskeer/Integration/src/Riskeer.Integration.Data/Assembly/CombinedFailureMechanismSectionAssemblyResultFactory.cs =================================================================== diff -u -rffec70662c33e5a611430ae73fa4d8cef5cdf147 -r89039d4a60d80904883f2ea76f98108595a9accf --- Riskeer/Integration/src/Riskeer.Integration.Data/Assembly/CombinedFailureMechanismSectionAssemblyResultFactory.cs (.../CombinedFailureMechanismSectionAssemblyResultFactory.cs) (revision ffec70662c33e5a611430ae73fa4d8cef5cdf147) +++ Riskeer/Integration/src/Riskeer.Integration.Data/Assembly/CombinedFailureMechanismSectionAssemblyResultFactory.cs (.../CombinedFailureMechanismSectionAssemblyResultFactory.cs) (revision 89039d4a60d80904883f2ea76f98108595a9accf) @@ -41,7 +41,7 @@ /// The assessment section to use while creating the results. /// A collection of . /// Thrown when any parameter is null. - public static IEnumerable Create(IEnumerable output, + public static IEnumerable Create(IEnumerable output, IDictionary failureMechanisms, AssessmentSection assessmentSection) { @@ -64,14 +64,14 @@ sectionNumber + 1, assembly.Section.SectionStart, assembly.Section.SectionEnd, - assembly.Section.CategoryGroup, - CreateFailureMechanismResults(assembly.FailureMechanismResults, + assembly.Section.AssemblyGroup, + CreateFailureMechanismResults(assembly.FailureMechanismAssemblyGroupResults, failureMechanisms, assessmentSection))) .ToArray(); } private static CombinedFailureMechanismSectionAssemblyResult.ConstructionProperties CreateFailureMechanismResults( - IEnumerable failureMechanismResults, + IEnumerable failureMechanismResults, IDictionary failureMechanisms, AssessmentSection assessmentSection) { @@ -97,13 +97,13 @@ return constructionProperties; } - private static FailureMechanismSectionAssemblyCategoryGroup GetCategoryGroup(IFailureMechanism failureMechanism, - IDictionary failureMechanisms, - IEnumerable failureMechanismResults) + private static FailureMechanismSectionAssemblyGroup GetCategoryGroup(IFailureMechanism failureMechanism, + IDictionary failureMechanisms, + IEnumerable failureMechanismResults) { return failureMechanisms.ContainsKey(failureMechanism) ? failureMechanismResults.ElementAt(failureMechanisms[failureMechanism]) - : FailureMechanismSectionAssemblyCategoryGroup.NotApplicable; + : FailureMechanismSectionAssemblyGroup.Gr; } } } \ No newline at end of file Index: Riskeer/Integration/src/Riskeer.Integration.Forms/Factories/AssessmentSectionAssemblyMapDataFeaturesFactory.cs =================================================================== diff -u -rc36b47c2e1e8cf948767cca33f80ad735f370ad0 -r89039d4a60d80904883f2ea76f98108595a9accf --- Riskeer/Integration/src/Riskeer.Integration.Forms/Factories/AssessmentSectionAssemblyMapDataFeaturesFactory.cs (.../AssessmentSectionAssemblyMapDataFeaturesFactory.cs) (revision c36b47c2e1e8cf948767cca33f80ad735f370ad0) +++ Riskeer/Integration/src/Riskeer.Integration.Forms/Factories/AssessmentSectionAssemblyMapDataFeaturesFactory.cs (.../AssessmentSectionAssemblyMapDataFeaturesFactory.cs) (revision 89039d4a60d80904883f2ea76f98108595a9accf) @@ -63,7 +63,7 @@ } catch (AssemblyException) { - return new MapFeature[0]; + return Array.Empty(); } var mapFeatures = new List(); @@ -75,8 +75,8 @@ MapFeature mapFeature = RiskeerMapDataFeaturesFactory.CreateSingleLineMapFeature(geometry); mapFeature.MetaData[RiskeerCommonFormsResources.AssemblyCategory_Group_DisplayName] = - new EnumDisplayWrapper( - DisplayFailureMechanismSectionAssemblyCategoryGroupConverter.Convert(assemblyResult.TotalResult)).DisplayName; + new EnumDisplayWrapper( + DisplayFailureMechanismSectionAssemblyGroupConverter.Convert(assemblyResult.TotalResult)).DisplayName; mapFeature.MetaData[Resources.SectionNumber_DisplayName] = assemblyResult.SectionNumber; mapFeatures.Add(mapFeature); Index: Riskeer/Integration/src/Riskeer.Integration.Forms/Views/CombinedFailureMechanismSectionAssemblyResultRow.cs =================================================================== diff -u -r520b3153840dada327c8bd936a4d6a7a07427331 -r89039d4a60d80904883f2ea76f98108595a9accf --- Riskeer/Integration/src/Riskeer.Integration.Forms/Views/CombinedFailureMechanismSectionAssemblyResultRow.cs (.../CombinedFailureMechanismSectionAssemblyResultRow.cs) (revision 520b3153840dada327c8bd936a4d6a7a07427331) +++ Riskeer/Integration/src/Riskeer.Integration.Forms/Views/CombinedFailureMechanismSectionAssemblyResultRow.cs (.../CombinedFailureMechanismSectionAssemblyResultRow.cs) (revision 89039d4a60d80904883f2ea76f98108595a9accf) @@ -118,7 +118,7 @@ { get { - return FailureMechanismSectionAssemblyCategoryGroupHelper.GetCategoryGroupDisplayName(combinedFailureMechanismSectionAssemblyResult.TotalResult); + return FailureMechanismSectionAssemblyGroupDisplayHelper.GetAssemblyGroupDisplayName(combinedFailureMechanismSectionAssemblyResult.TotalResult); } } @@ -129,7 +129,7 @@ { get { - return FailureMechanismSectionAssemblyCategoryGroupHelper.GetCategoryGroupDisplayName(combinedFailureMechanismSectionAssemblyResult.Piping); + return FailureMechanismSectionAssemblyGroupDisplayHelper.GetAssemblyGroupDisplayName(combinedFailureMechanismSectionAssemblyResult.Piping); } } @@ -140,7 +140,7 @@ { get { - return FailureMechanismSectionAssemblyCategoryGroupHelper.GetCategoryGroupDisplayName(combinedFailureMechanismSectionAssemblyResult.GrassCoverErosionInwards); + return FailureMechanismSectionAssemblyGroupDisplayHelper.GetAssemblyGroupDisplayName(combinedFailureMechanismSectionAssemblyResult.GrassCoverErosionInwards); } } @@ -151,7 +151,7 @@ { get { - return FailureMechanismSectionAssemblyCategoryGroupHelper.GetCategoryGroupDisplayName(combinedFailureMechanismSectionAssemblyResult.MacroStabilityInwards); + return FailureMechanismSectionAssemblyGroupDisplayHelper.GetAssemblyGroupDisplayName(combinedFailureMechanismSectionAssemblyResult.MacroStabilityInwards); } } @@ -162,7 +162,7 @@ { get { - return FailureMechanismSectionAssemblyCategoryGroupHelper.GetCategoryGroupDisplayName(combinedFailureMechanismSectionAssemblyResult.Microstability); + return FailureMechanismSectionAssemblyGroupDisplayHelper.GetAssemblyGroupDisplayName(combinedFailureMechanismSectionAssemblyResult.Microstability); } } @@ -173,7 +173,7 @@ { get { - return FailureMechanismSectionAssemblyCategoryGroupHelper.GetCategoryGroupDisplayName(combinedFailureMechanismSectionAssemblyResult.StabilityStoneCover); + return FailureMechanismSectionAssemblyGroupDisplayHelper.GetAssemblyGroupDisplayName(combinedFailureMechanismSectionAssemblyResult.StabilityStoneCover); } } @@ -184,7 +184,7 @@ { get { - return FailureMechanismSectionAssemblyCategoryGroupHelper.GetCategoryGroupDisplayName(combinedFailureMechanismSectionAssemblyResult.WaveImpactAsphaltCover); + return FailureMechanismSectionAssemblyGroupDisplayHelper.GetAssemblyGroupDisplayName(combinedFailureMechanismSectionAssemblyResult.WaveImpactAsphaltCover); } } @@ -195,7 +195,7 @@ { get { - return FailureMechanismSectionAssemblyCategoryGroupHelper.GetCategoryGroupDisplayName(combinedFailureMechanismSectionAssemblyResult.WaterPressureAsphaltCover); + return FailureMechanismSectionAssemblyGroupDisplayHelper.GetAssemblyGroupDisplayName(combinedFailureMechanismSectionAssemblyResult.WaterPressureAsphaltCover); } } @@ -206,7 +206,7 @@ { get { - return FailureMechanismSectionAssemblyCategoryGroupHelper.GetCategoryGroupDisplayName(combinedFailureMechanismSectionAssemblyResult.GrassCoverErosionOutwards); + return FailureMechanismSectionAssemblyGroupDisplayHelper.GetAssemblyGroupDisplayName(combinedFailureMechanismSectionAssemblyResult.GrassCoverErosionOutwards); } } @@ -217,7 +217,7 @@ { get { - return FailureMechanismSectionAssemblyCategoryGroupHelper.GetCategoryGroupDisplayName(combinedFailureMechanismSectionAssemblyResult.GrassCoverSlipOffOutwards); + return FailureMechanismSectionAssemblyGroupDisplayHelper.GetAssemblyGroupDisplayName(combinedFailureMechanismSectionAssemblyResult.GrassCoverSlipOffOutwards); } } @@ -228,7 +228,7 @@ { get { - return FailureMechanismSectionAssemblyCategoryGroupHelper.GetCategoryGroupDisplayName(combinedFailureMechanismSectionAssemblyResult.GrassCoverSlipOffInwards); + return FailureMechanismSectionAssemblyGroupDisplayHelper.GetAssemblyGroupDisplayName(combinedFailureMechanismSectionAssemblyResult.GrassCoverSlipOffInwards); } } @@ -239,7 +239,7 @@ { get { - return FailureMechanismSectionAssemblyCategoryGroupHelper.GetCategoryGroupDisplayName(combinedFailureMechanismSectionAssemblyResult.HeightStructures); + return FailureMechanismSectionAssemblyGroupDisplayHelper.GetAssemblyGroupDisplayName(combinedFailureMechanismSectionAssemblyResult.HeightStructures); } } @@ -250,7 +250,7 @@ { get { - return FailureMechanismSectionAssemblyCategoryGroupHelper.GetCategoryGroupDisplayName(combinedFailureMechanismSectionAssemblyResult.ClosingStructures); + return FailureMechanismSectionAssemblyGroupDisplayHelper.GetAssemblyGroupDisplayName(combinedFailureMechanismSectionAssemblyResult.ClosingStructures); } } @@ -261,7 +261,7 @@ { get { - return FailureMechanismSectionAssemblyCategoryGroupHelper.GetCategoryGroupDisplayName(combinedFailureMechanismSectionAssemblyResult.PipingStructure); + return FailureMechanismSectionAssemblyGroupDisplayHelper.GetAssemblyGroupDisplayName(combinedFailureMechanismSectionAssemblyResult.PipingStructure); } } @@ -272,7 +272,7 @@ { get { - return FailureMechanismSectionAssemblyCategoryGroupHelper.GetCategoryGroupDisplayName(combinedFailureMechanismSectionAssemblyResult.StabilityPointStructures); + return FailureMechanismSectionAssemblyGroupDisplayHelper.GetAssemblyGroupDisplayName(combinedFailureMechanismSectionAssemblyResult.StabilityPointStructures); } } @@ -283,7 +283,7 @@ { get { - return FailureMechanismSectionAssemblyCategoryGroupHelper.GetCategoryGroupDisplayName(combinedFailureMechanismSectionAssemblyResult.DuneErosion); + return FailureMechanismSectionAssemblyGroupDisplayHelper.GetAssemblyGroupDisplayName(combinedFailureMechanismSectionAssemblyResult.DuneErosion); } } @@ -329,10 +329,10 @@ ColumnStateDefinitions[duneErosionIndex].Style = CreateCellStyle(combinedFailureMechanismSectionAssemblyResult.DuneErosion); } - private static CellStyle CreateCellStyle(FailureMechanismSectionAssemblyCategoryGroup assemblyCategoryGroup) + private static CellStyle CreateCellStyle(FailureMechanismSectionAssemblyGroup assemblyCategoryGroup) { return new CellStyle(Color.FromKnownColor(KnownColor.ControlText), - AssemblyCategoryGroupColorHelper.GetFailureMechanismSectionAssemblyCategoryGroupColor(assemblyCategoryGroup)); + AssemblyGroupColorHelper.GetFailureMechanismSectionAssemblyCategoryGroupColor(assemblyCategoryGroup)); } } } \ No newline at end of file Index: Riskeer/Integration/src/Riskeer.Integration.IO/Factories/ExportableCombinedSectionAssemblyFactory.cs =================================================================== diff -u -r3cc451ebd61f1deb89b028a5cac31a29ef50e614 -r89039d4a60d80904883f2ea76f98108595a9accf --- Riskeer/Integration/src/Riskeer.Integration.IO/Factories/ExportableCombinedSectionAssemblyFactory.cs (.../ExportableCombinedSectionAssemblyFactory.cs) (revision 3cc451ebd61f1deb89b028a5cac31a29ef50e614) +++ Riskeer/Integration/src/Riskeer.Integration.IO/Factories/ExportableCombinedSectionAssemblyFactory.cs (.../ExportableCombinedSectionAssemblyFactory.cs) (revision 89039d4a60d80904883f2ea76f98108595a9accf) @@ -67,47 +67,45 @@ assemblyResult.SectionEnd, ExportableAssemblyMethod.WBI3A1); - var exportableSectionResult = new ExportableCombinedSectionAssembly(exportableSection, - new ExportableSectionAssemblyResult(ExportableAssemblyMethod.WBI3C1, - assemblyResult.TotalResult), - CreateFailureMechanismCombinedSectionAssemblyResults(assemblyResult)); + var exportableSectionResult = new ExportableCombinedSectionAssembly( + exportableSection, new ExportableSectionAssemblyResult(ExportableAssemblyMethod.WBI3C1, FailureMechanismSectionAssemblyCategoryGroup.None), + CreateFailureMechanismCombinedSectionAssemblyResults()); sectionResults.Add(exportableSectionResult); } return sectionResults; } - private static IEnumerable CreateFailureMechanismCombinedSectionAssemblyResults( - CombinedFailureMechanismSectionAssemblyResult assemblyResult) + private static IEnumerable CreateFailureMechanismCombinedSectionAssemblyResults() { return new[] { - CreateExportableFailureMechanismCombinedSectionAssemblyResult(assemblyResult.Piping, ExportableFailureMechanismType.STPH), - CreateExportableFailureMechanismCombinedSectionAssemblyResult(assemblyResult.GrassCoverErosionInwards, ExportableFailureMechanismType.GEKB), - CreateExportableFailureMechanismCombinedSectionAssemblyResult(assemblyResult.MacroStabilityInwards, ExportableFailureMechanismType.STBI), - CreateExportableFailureMechanismCombinedSectionAssemblyResult(assemblyResult.Microstability, ExportableFailureMechanismType.STMI), - CreateExportableFailureMechanismCombinedSectionAssemblyResult(assemblyResult.StabilityStoneCover, ExportableFailureMechanismType.ZST), - CreateExportableFailureMechanismCombinedSectionAssemblyResult(assemblyResult.WaveImpactAsphaltCover, ExportableFailureMechanismType.AGK), - CreateExportableFailureMechanismCombinedSectionAssemblyResult(assemblyResult.WaterPressureAsphaltCover, ExportableFailureMechanismType.AWO), - CreateExportableFailureMechanismCombinedSectionAssemblyResult(assemblyResult.GrassCoverErosionOutwards, ExportableFailureMechanismType.GEBU), - CreateExportableFailureMechanismCombinedSectionAssemblyResult(assemblyResult.GrassCoverSlipOffOutwards, ExportableFailureMechanismType.GABU), - CreateExportableFailureMechanismCombinedSectionAssemblyResult(assemblyResult.GrassCoverSlipOffInwards, ExportableFailureMechanismType.GABI), - CreateExportableFailureMechanismCombinedSectionAssemblyResult(assemblyResult.HeightStructures, ExportableFailureMechanismType.HTKW), - CreateExportableFailureMechanismCombinedSectionAssemblyResult(assemblyResult.ClosingStructures, ExportableFailureMechanismType.BSKW), - CreateExportableFailureMechanismCombinedSectionAssemblyResult(assemblyResult.PipingStructure, ExportableFailureMechanismType.PKW), - CreateExportableFailureMechanismCombinedSectionAssemblyResult(assemblyResult.StabilityPointStructures, ExportableFailureMechanismType.STKWp), - CreateExportableFailureMechanismCombinedSectionAssemblyResult(assemblyResult.DuneErosion, ExportableFailureMechanismType.DA) + CreateExportableFailureMechanismCombinedSectionAssemblyResult(FailureMechanismSectionAssemblyCategoryGroup.None, ExportableFailureMechanismType.STPH), + CreateExportableFailureMechanismCombinedSectionAssemblyResult(FailureMechanismSectionAssemblyCategoryGroup.None, ExportableFailureMechanismType.GEKB), + CreateExportableFailureMechanismCombinedSectionAssemblyResult(FailureMechanismSectionAssemblyCategoryGroup.None, ExportableFailureMechanismType.STBI), + CreateExportableFailureMechanismCombinedSectionAssemblyResult(FailureMechanismSectionAssemblyCategoryGroup.None, ExportableFailureMechanismType.STMI), + CreateExportableFailureMechanismCombinedSectionAssemblyResult(FailureMechanismSectionAssemblyCategoryGroup.None, ExportableFailureMechanismType.ZST), + CreateExportableFailureMechanismCombinedSectionAssemblyResult(FailureMechanismSectionAssemblyCategoryGroup.None, ExportableFailureMechanismType.AGK), + CreateExportableFailureMechanismCombinedSectionAssemblyResult(FailureMechanismSectionAssemblyCategoryGroup.None, ExportableFailureMechanismType.AWO), + CreateExportableFailureMechanismCombinedSectionAssemblyResult(FailureMechanismSectionAssemblyCategoryGroup.None, ExportableFailureMechanismType.GEBU), + CreateExportableFailureMechanismCombinedSectionAssemblyResult(FailureMechanismSectionAssemblyCategoryGroup.None, ExportableFailureMechanismType.GABU), + CreateExportableFailureMechanismCombinedSectionAssemblyResult(FailureMechanismSectionAssemblyCategoryGroup.None, ExportableFailureMechanismType.GABI), + CreateExportableFailureMechanismCombinedSectionAssemblyResult(FailureMechanismSectionAssemblyCategoryGroup.None, ExportableFailureMechanismType.HTKW), + CreateExportableFailureMechanismCombinedSectionAssemblyResult(FailureMechanismSectionAssemblyCategoryGroup.None, ExportableFailureMechanismType.BSKW), + CreateExportableFailureMechanismCombinedSectionAssemblyResult(FailureMechanismSectionAssemblyCategoryGroup.None, ExportableFailureMechanismType.PKW), + CreateExportableFailureMechanismCombinedSectionAssemblyResult(FailureMechanismSectionAssemblyCategoryGroup.None, ExportableFailureMechanismType.STKWp), + CreateExportableFailureMechanismCombinedSectionAssemblyResult(FailureMechanismSectionAssemblyCategoryGroup.None, ExportableFailureMechanismType.DA) }; } private static ExportableFailureMechanismCombinedSectionAssemblyResult CreateExportableFailureMechanismCombinedSectionAssemblyResult( FailureMechanismSectionAssemblyCategoryGroup sectionAssemblyResult, ExportableFailureMechanismType failureMechanismCode) { - return new ExportableFailureMechanismCombinedSectionAssemblyResult(new ExportableSectionAssemblyResult(ExportableAssemblyMethod.WBI3B1, - sectionAssemblyResult), - failureMechanismCode); + return new ExportableFailureMechanismCombinedSectionAssemblyResult( + new ExportableSectionAssemblyResult(ExportableAssemblyMethod.WBI3B1, sectionAssemblyResult), + failureMechanismCode); } } } \ No newline at end of file Index: Riskeer/Integration/test/Riskeer.Integration.Data.Test/Assembly/AssessmentSectionAssemblyFactoryTest.cs =================================================================== diff -u -r8a067d513f440f079818bcec9deb1c86f8360ed6 -r89039d4a60d80904883f2ea76f98108595a9accf --- Riskeer/Integration/test/Riskeer.Integration.Data.Test/Assembly/AssessmentSectionAssemblyFactoryTest.cs (.../AssessmentSectionAssemblyFactoryTest.cs) (revision 8a067d513f440f079818bcec9deb1c86f8360ed6) +++ Riskeer/Integration/test/Riskeer.Integration.Data.Test/Assembly/AssessmentSectionAssemblyFactoryTest.cs (.../AssessmentSectionAssemblyFactoryTest.cs) (revision 89039d4a60d80904883f2ea76f98108595a9accf) @@ -669,47 +669,46 @@ public void AssembleCombinedPerFailureMechanismSection_AssessmentSectionNull_ThrowsArgumentNullException() { // Call - TestDelegate call = () => AssessmentSectionAssemblyFactory.AssembleCombinedPerFailureMechanismSection(null, - new Random(39).NextBoolean()); + void Call() => AssessmentSectionAssemblyFactory.AssembleCombinedPerFailureMechanismSection(null, new Random(39).NextBoolean()); // Assert - var exception = Assert.Throws(call); + var exception = Assert.Throws(Call); Assert.AreEqual("assessmentSection", exception.ParamName); } [Test] - public void AssembleCombinedPerFailureMechanismSection_WithAssessmentSectionWithoutManualSectionAssemblyResults_SetsInputOnCalculator() + public void AssembleCombinedPerFailureMechanismSection_WithAssessmentSection_SetsInputOnCalculator() { var random = new Random(21); AssessmentSection assessmentSection = TestDataGenerator.GetAssessmentSectionWithAllFailureMechanismSectionsAndResults( random.NextEnumValue()); - using (new AssemblyToolCalculatorFactoryConfigOld()) + using (new AssemblyToolCalculatorFactoryConfig()) { - var calculatorFactory = (TestAssemblyToolCalculatorFactoryOld) AssemblyToolCalculatorFactoryOld.Instance; - AssessmentSectionAssemblyCalculatorStubOld calculator = calculatorFactory.LastCreatedAssessmentSectionAssemblyCalculator; - calculator.CombinedFailureMechanismSectionAssemblyOutput = new CombinedFailureMechanismSectionAssemblyOld[0]; + var calculatorFactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance; + AssessmentSectionAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedAssessmentSectionAssemblyCalculator; + calculator.CombinedFailureMechanismSectionAssemblyOutput = Array.Empty(); // Call AssessmentSectionAssemblyFactory.AssembleCombinedPerFailureMechanismSection(assessmentSection, random.NextBoolean()); // Assert - IEnumerable[] actualInput = calculator.CombinedFailureMechanismSectionsInput.ToArray(); - IEnumerable[] expectedInput = CombinedAssemblyFailureMechanismSectionFactory.CreateInput( - assessmentSection, assessmentSection.GetFailureMechanisms(), random.NextBoolean()).ToArray(); + IEnumerable[] actualInput = calculator.CombinedFailureMechanismSectionsInput.ToArray(); + IEnumerable[] expectedInput = CombinedAssemblyFailureMechanismSectionFactory.CreateInput( + assessmentSection, assessmentSection.GetFailureMechanisms()).ToArray(); Assert.AreEqual(expectedInput.Length, actualInput.Length); for (var i = 0; i < expectedInput.Length; i++) { - CombinedAssemblyFailureMechanismSectionOld[] actualSections = actualInput[i].ToArray(); - CombinedAssemblyFailureMechanismSectionOld[] expectedSections = expectedInput[i].ToArray(); + CombinedAssemblyFailureMechanismSection[] actualSections = actualInput[i].ToArray(); + CombinedAssemblyFailureMechanismSection[] expectedSections = expectedInput[i].ToArray(); Assert.AreEqual(expectedSections.Length, actualSections.Length); for (var j = 0; j < expectedSections.Length; j++) { Assert.AreEqual(expectedSections[j].SectionStart, actualSections[j].SectionStart); Assert.AreEqual(expectedSections[j].SectionEnd, actualSections[j].SectionEnd); - Assert.AreEqual(expectedSections[j].CategoryGroup, actualSections[j].CategoryGroup); + Assert.AreEqual(expectedSections[j].AssemblyGroup, actualSections[j].AssemblyGroup); } } } @@ -722,10 +721,10 @@ AssessmentSection assessmentSection = TestDataGenerator.GetAssessmentSectionWithAllFailureMechanismSectionsAndResults( random.NextEnumValue()); - using (new AssemblyToolCalculatorFactoryConfigOld()) + using (new AssemblyToolCalculatorFactoryConfig()) { - var calculatorFactory = (TestAssemblyToolCalculatorFactoryOld) AssemblyToolCalculatorFactoryOld.Instance; - AssessmentSectionAssemblyCalculatorStubOld calculator = calculatorFactory.LastCreatedAssessmentSectionAssemblyCalculator; + var calculatorFactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance; + AssessmentSectionAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedAssessmentSectionAssemblyCalculator; calculator.CombinedFailureMechanismSectionAssemblyOutput = new[] { CreateCombinedFailureMechanismSectionAssembly(assessmentSection, 20), @@ -782,18 +781,17 @@ AssessmentSection assessmentSection = TestDataGenerator.GetAssessmentSectionWithAllFailureMechanismSectionsAndResults( random.NextEnumValue()); - using (new AssemblyToolCalculatorFactoryConfigOld()) + using (new AssemblyToolCalculatorFactoryConfig()) { - var calculatorFactory = (TestAssemblyToolCalculatorFactoryOld) AssemblyToolCalculatorFactoryOld.Instance; - AssessmentSectionAssemblyCalculatorStubOld calculator = calculatorFactory.LastCreatedAssessmentSectionAssemblyCalculator; + var calculatorFactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance; + AssessmentSectionAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedAssessmentSectionAssemblyCalculator; calculator.ThrowExceptionOnCalculate = true; // Call - TestDelegate call = () => AssessmentSectionAssemblyFactory.AssembleCombinedPerFailureMechanismSection(assessmentSection, - random.NextBoolean()); + void Call() => AssessmentSectionAssemblyFactory.AssembleCombinedPerFailureMechanismSection(assessmentSection, random.NextBoolean()); // Assert - var exception = Assert.Throws(call); + var exception = Assert.Throws(Call); Exception innerException = exception.InnerException; Assert.IsInstanceOf(innerException); Assert.AreEqual(innerException.Message, exception.Message); @@ -808,80 +806,25 @@ AssessmentSection assessmentSection = TestDataGenerator.GetAssessmentSectionWithAllFailureMechanismSectionsAndResults( random.NextEnumValue()); - using (new AssemblyToolCalculatorFactoryConfigOld()) + using (new AssemblyToolCalculatorFactoryConfig()) { - var calculatorFactory = (TestAssemblyToolCalculatorFactoryOld) AssemblyToolCalculatorFactoryOld.Instance; - FailureMechanismSectionAssemblyCalculatorOldStub calculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator; + var calculatorFactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance; + FailureMechanismSectionAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator; calculator.ThrowExceptionOnCalculate = true; // Call - TestDelegate call = () => AssessmentSectionAssemblyFactory.AssembleCombinedPerFailureMechanismSection(assessmentSection, - random.NextBoolean()); + void Call() => AssessmentSectionAssemblyFactory.AssembleCombinedPerFailureMechanismSection(assessmentSection, random.NextBoolean()); // Assert - var exception = Assert.Throws(call); + var exception = Assert.Throws(Call); Exception innerException = exception.InnerException; Assert.IsInstanceOf(innerException); Assert.AreEqual("Voor een of meerdere toetssporen kan geen oordeel worden bepaald.", exception.Message); } } - #region Manual Assembly Used - - [Test] - public void AssembleCombinedPerFailureMechanismSection_FailureMechanismHasManualSectionAssemblyAndUseManualTrue_SetsManualAssemblyInputOnCalculator() - { - // Given - AssessmentSection assessmentSection = CreateAssessmentSection(); - PipingFailureMechanism failureMechanism = assessmentSection.Piping; - FailureMechanismTestHelper.AddSections(failureMechanism, 1); - - PipingFailureMechanismSectionResultOld sectionResult = failureMechanism.SectionResultsOld.Single(); - sectionResult.UseManualAssembly = true; - double probability = new Random(39).NextDouble(); - sectionResult.ManualAssemblyProbability = probability; - - using (new AssemblyToolCalculatorFactoryConfigOld()) - { - // When - AssessmentSectionAssemblyFactory.AssembleCombinedPerFailureMechanismSection(assessmentSection, true); - - // Then - var calculatorFactory = (TestAssemblyToolCalculatorFactoryOld) AssemblyToolCalculatorFactoryOld.Instance; - FailureMechanismSectionAssemblyCalculatorOldStub failureMechanismSectionAssemblyCalculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator; - Assert.AreEqual(probability, failureMechanismSectionAssemblyCalculator.ManualAssemblyProbabilityInput); - } - } - - [Test] - public void AssembleCombinedPerFailureMechanismSection_FailureMechanismHasManualSectionAssemblyAndUseManualFalse_SetsAssemblyInputOnCalculator() - { - // Given - AssessmentSection assessmentSection = CreateAssessmentSection(); - PipingFailureMechanism failureMechanism = assessmentSection.Piping; - FailureMechanismTestHelper.AddSections(failureMechanism, 1); - - PipingFailureMechanismSectionResultOld sectionResult = failureMechanism.SectionResultsOld.Single(); - sectionResult.UseManualAssembly = true; - double probability = new Random(39).NextDouble(); - sectionResult.ManualAssemblyProbability = probability; - - using (new AssemblyToolCalculatorFactoryConfigOld()) - { - // When - AssessmentSectionAssemblyFactory.AssembleCombinedPerFailureMechanismSection(assessmentSection, false); - - // Then - var calculatorFactory = (TestAssemblyToolCalculatorFactoryOld) AssemblyToolCalculatorFactoryOld.Instance; - FailureMechanismSectionAssemblyCalculatorOldStub failureMechanismSectionAssemblyCalculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator; - Assert.IsNull(failureMechanismSectionAssemblyCalculator.ManualAssemblyAssemblyOutput); - } - } - #endregion - #endregion - #region Helpers private static AssessmentSection CreateAssessmentSectionWithFailureMechanismsNotPartOfAssembly() @@ -891,15 +834,15 @@ return assessmentSection; } - private static CombinedFailureMechanismSectionAssemblyOld CreateCombinedFailureMechanismSectionAssembly(AssessmentSection assessmentSection, int seed) + private static CombinedFailureMechanismSectionAssembly CreateCombinedFailureMechanismSectionAssembly(AssessmentSection assessmentSection, int seed) { var random = new Random(seed); - return new CombinedFailureMechanismSectionAssemblyOld(new CombinedAssemblyFailureMechanismSectionOld(random.NextDouble(), - random.NextDouble(), - random.NextEnumValue()), - assessmentSection.GetFailureMechanisms() - .Where(fm => fm.InAssembly) - .Select(fm => random.NextEnumValue()).ToArray()); + return new CombinedFailureMechanismSectionAssembly( + new CombinedAssemblyFailureMechanismSection(random.NextDouble(), random.NextDouble(), random.NextEnumValue()), + assessmentSection.GetFailureMechanisms() + .Where(fm => fm.InAssembly) + .Select(fm => random.NextEnumValue()) + .ToArray()); } private static void AssertGroup1And2FailureMechanismInputs(AssessmentSection assessmentSection, Index: Riskeer/Integration/test/Riskeer.Integration.Data.Test/Assembly/CombinedAssemblyFailureMechanismSectionFactoryTest.cs =================================================================== diff -u -rbc62f7dca76fde0cf2b8f50603b14e251ccd1372 -r89039d4a60d80904883f2ea76f98108595a9accf --- Riskeer/Integration/test/Riskeer.Integration.Data.Test/Assembly/CombinedAssemblyFailureMechanismSectionFactoryTest.cs (.../CombinedAssemblyFailureMechanismSectionFactoryTest.cs) (revision bc62f7dca76fde0cf2b8f50603b14e251ccd1372) +++ Riskeer/Integration/test/Riskeer.Integration.Data.Test/Assembly/CombinedAssemblyFailureMechanismSectionFactoryTest.cs (.../CombinedAssemblyFailureMechanismSectionFactoryTest.cs) (revision 89039d4a60d80904883f2ea76f98108595a9accf) @@ -22,6 +22,7 @@ using System; using System.Collections.Generic; using System.Linq; +using Core.Common.Base; using Core.Common.TestUtil; using Core.Common.Util.Extensions; using NUnit.Framework; @@ -112,9 +113,6 @@ using (new AssemblyToolCalculatorFactoryConfig()) { - var calculatorFactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance; - FailureMechanismSectionAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator; - // Call IEnumerable> inputs = CombinedAssemblyFailureMechanismSectionFactory.CreateInput( assessmentSection, new[] @@ -123,9 +121,8 @@ }); // Assert - AssertSectionsWithResult(((IHasSectionResults) failureMechanismInAssembly).SectionResults, - calculator.FailureMechanismSectionAssemblyResultOutput.AssemblyGroup, - inputs.Single()); + IObservableEnumerable failureMechanismSectionResults = ((IHasSectionResults) failureMechanismInAssembly).SectionResults; + AssertSections(failureMechanismSectionResults, inputs.Single()); } } Index: Riskeer/Integration/test/Riskeer.Integration.Data.Test/Assembly/CombinedFailureMechanismSectionAssemblyResultFactoryTest.cs =================================================================== diff -u -r8a067d513f440f079818bcec9deb1c86f8360ed6 -r89039d4a60d80904883f2ea76f98108595a9accf --- Riskeer/Integration/test/Riskeer.Integration.Data.Test/Assembly/CombinedFailureMechanismSectionAssemblyResultFactoryTest.cs (.../CombinedFailureMechanismSectionAssemblyResultFactoryTest.cs) (revision 8a067d513f440f079818bcec9deb1c86f8360ed6) +++ Riskeer/Integration/test/Riskeer.Integration.Data.Test/Assembly/CombinedFailureMechanismSectionAssemblyResultFactoryTest.cs (.../CombinedFailureMechanismSectionAssemblyResultFactoryTest.cs) (revision 89039d4a60d80904883f2ea76f98108595a9accf) @@ -40,11 +40,12 @@ var random = new Random(21); // Call - TestDelegate call = () => CombinedFailureMechanismSectionAssemblyResultFactory.Create(null, new Dictionary(), - new AssessmentSection(random.NextEnumValue())); + void Call() => CombinedFailureMechanismSectionAssemblyResultFactory.Create( + null, new Dictionary(), + new AssessmentSection(random.NextEnumValue())); // Assert - var exception = Assert.Throws(call); + var exception = Assert.Throws(Call); Assert.AreEqual("output", exception.ParamName); } @@ -55,23 +56,25 @@ var random = new Random(21); // Call - TestDelegate call = () => CombinedFailureMechanismSectionAssemblyResultFactory.Create(Enumerable.Empty(), - null, new AssessmentSection(random.NextEnumValue())); + void Call() => CombinedFailureMechanismSectionAssemblyResultFactory.Create( + Enumerable.Empty(), null, + new AssessmentSection(random.NextEnumValue())); // Assert - var exception = Assert.Throws(call); + var exception = Assert.Throws(Call); Assert.AreEqual("failureMechanisms", exception.ParamName); } [Test] public void Create_AssessmentSectionNull_ThrowsArgumentNullException() { // Call - TestDelegate call = () => CombinedFailureMechanismSectionAssemblyResultFactory.Create(Enumerable.Empty(), - new Dictionary(), null); + void Call() => CombinedFailureMechanismSectionAssemblyResultFactory.Create( + Enumerable.Empty(), + new Dictionary(), null); // Assert - var exception = Assert.Throws(call); + var exception = Assert.Throws(Call); Assert.AreEqual("assessmentSection", exception.ParamName); } @@ -90,12 +93,12 @@ }) .ToDictionary(x => x.FailureMechanism, x => x.Index); - var section1 = new CombinedAssemblyFailureMechanismSectionOld(0, 5, random.NextEnumValue()); - var section2 = new CombinedAssemblyFailureMechanismSectionOld(5, 11, random.NextEnumValue()); + var section1 = new CombinedAssemblyFailureMechanismSection(0, 5, random.NextEnumValue()); + var section2 = new CombinedAssemblyFailureMechanismSection(5, 11, random.NextEnumValue()); var output = new[] { - new CombinedFailureMechanismSectionAssemblyOld(section1, GetFailureMechanismsOutput(failureMechanisms.Keys, random)), - new CombinedFailureMechanismSectionAssemblyOld(section2, GetFailureMechanismsOutput(failureMechanisms.Keys, random)) + new CombinedFailureMechanismSectionAssembly(section1, GetFailureMechanismsOutput(failureMechanisms.Keys, random)), + new CombinedFailureMechanismSectionAssembly(section2, GetFailureMechanismsOutput(failureMechanisms.Keys, random)) }; // Call @@ -108,23 +111,23 @@ Assert.AreEqual(i + 1, results[i].SectionNumber); Assert.AreEqual(output[i].Section.SectionStart, results[i].SectionStart); Assert.AreEqual(output[i].Section.SectionEnd, results[i].SectionEnd); - Assert.AreEqual(output[i].Section.CategoryGroup, results[i].TotalResult); + Assert.AreEqual(output[i].Section.AssemblyGroup, results[i].TotalResult); - Assert.AreEqual(output[i].FailureMechanismResults.ElementAt(failureMechanisms[assessmentSection.Piping]), results[i].Piping); - Assert.AreEqual(output[i].FailureMechanismResults.ElementAt(failureMechanisms[assessmentSection.GrassCoverErosionInwards]), results[i].GrassCoverErosionInwards); - Assert.AreEqual(output[i].FailureMechanismResults.ElementAt(failureMechanisms[assessmentSection.MacroStabilityInwards]), results[i].MacroStabilityInwards); - Assert.AreEqual(output[i].FailureMechanismResults.ElementAt(failureMechanisms[assessmentSection.Microstability]), results[i].Microstability); - Assert.AreEqual(output[i].FailureMechanismResults.ElementAt(failureMechanisms[assessmentSection.StabilityStoneCover]), results[i].StabilityStoneCover); - Assert.AreEqual(output[i].FailureMechanismResults.ElementAt(failureMechanisms[assessmentSection.WaveImpactAsphaltCover]), results[i].WaveImpactAsphaltCover); - Assert.AreEqual(output[i].FailureMechanismResults.ElementAt(failureMechanisms[assessmentSection.WaterPressureAsphaltCover]), results[i].WaterPressureAsphaltCover); - Assert.AreEqual(output[i].FailureMechanismResults.ElementAt(failureMechanisms[assessmentSection.GrassCoverErosionOutwards]), results[i].GrassCoverErosionOutwards); - Assert.AreEqual(output[i].FailureMechanismResults.ElementAt(failureMechanisms[assessmentSection.GrassCoverSlipOffOutwards]), results[i].GrassCoverSlipOffOutwards); - Assert.AreEqual(output[i].FailureMechanismResults.ElementAt(failureMechanisms[assessmentSection.GrassCoverSlipOffInwards]), results[i].GrassCoverSlipOffInwards); - Assert.AreEqual(output[i].FailureMechanismResults.ElementAt(failureMechanisms[assessmentSection.HeightStructures]), results[i].HeightStructures); - Assert.AreEqual(output[i].FailureMechanismResults.ElementAt(failureMechanisms[assessmentSection.ClosingStructures]), results[i].ClosingStructures); - Assert.AreEqual(output[i].FailureMechanismResults.ElementAt(failureMechanisms[assessmentSection.PipingStructure]), results[i].PipingStructure); - Assert.AreEqual(output[i].FailureMechanismResults.ElementAt(failureMechanisms[assessmentSection.StabilityPointStructures]), results[i].StabilityPointStructures); - Assert.AreEqual(output[i].FailureMechanismResults.ElementAt(failureMechanisms[assessmentSection.DuneErosion]), results[i].DuneErosion); + Assert.AreEqual(output[i].FailureMechanismAssemblyGroupResults.ElementAt(failureMechanisms[assessmentSection.Piping]), results[i].Piping); + Assert.AreEqual(output[i].FailureMechanismAssemblyGroupResults.ElementAt(failureMechanisms[assessmentSection.GrassCoverErosionInwards]), results[i].GrassCoverErosionInwards); + Assert.AreEqual(output[i].FailureMechanismAssemblyGroupResults.ElementAt(failureMechanisms[assessmentSection.MacroStabilityInwards]), results[i].MacroStabilityInwards); + Assert.AreEqual(output[i].FailureMechanismAssemblyGroupResults.ElementAt(failureMechanisms[assessmentSection.Microstability]), results[i].Microstability); + Assert.AreEqual(output[i].FailureMechanismAssemblyGroupResults.ElementAt(failureMechanisms[assessmentSection.StabilityStoneCover]), results[i].StabilityStoneCover); + Assert.AreEqual(output[i].FailureMechanismAssemblyGroupResults.ElementAt(failureMechanisms[assessmentSection.WaveImpactAsphaltCover]), results[i].WaveImpactAsphaltCover); + Assert.AreEqual(output[i].FailureMechanismAssemblyGroupResults.ElementAt(failureMechanisms[assessmentSection.WaterPressureAsphaltCover]), results[i].WaterPressureAsphaltCover); + Assert.AreEqual(output[i].FailureMechanismAssemblyGroupResults.ElementAt(failureMechanisms[assessmentSection.GrassCoverErosionOutwards]), results[i].GrassCoverErosionOutwards); + Assert.AreEqual(output[i].FailureMechanismAssemblyGroupResults.ElementAt(failureMechanisms[assessmentSection.GrassCoverSlipOffOutwards]), results[i].GrassCoverSlipOffOutwards); + Assert.AreEqual(output[i].FailureMechanismAssemblyGroupResults.ElementAt(failureMechanisms[assessmentSection.GrassCoverSlipOffInwards]), results[i].GrassCoverSlipOffInwards); + Assert.AreEqual(output[i].FailureMechanismAssemblyGroupResults.ElementAt(failureMechanisms[assessmentSection.HeightStructures]), results[i].HeightStructures); + Assert.AreEqual(output[i].FailureMechanismAssemblyGroupResults.ElementAt(failureMechanisms[assessmentSection.ClosingStructures]), results[i].ClosingStructures); + Assert.AreEqual(output[i].FailureMechanismAssemblyGroupResults.ElementAt(failureMechanisms[assessmentSection.PipingStructure]), results[i].PipingStructure); + Assert.AreEqual(output[i].FailureMechanismAssemblyGroupResults.ElementAt(failureMechanisms[assessmentSection.StabilityPointStructures]), results[i].StabilityPointStructures); + Assert.AreEqual(output[i].FailureMechanismAssemblyGroupResults.ElementAt(failureMechanisms[assessmentSection.DuneErosion]), results[i].DuneErosion); } } @@ -143,49 +146,48 @@ }) .ToDictionary(x => x.FailureMechanism, x => x.Index); - var section1 = new CombinedAssemblyFailureMechanismSectionOld(0, 5, random.NextEnumValue()); - var section2 = new CombinedAssemblyFailureMechanismSectionOld(5, 11, random.NextEnumValue()); + var section1 = new CombinedAssemblyFailureMechanismSection(0, 5, random.NextEnumValue()); + var section2 = new CombinedAssemblyFailureMechanismSection(5, 11, random.NextEnumValue()); var output = new[] { - new CombinedFailureMechanismSectionAssemblyOld(section1, GetFailureMechanismsOutput(failureMechanisms.Keys, random)), - new CombinedFailureMechanismSectionAssemblyOld(section2, GetFailureMechanismsOutput(failureMechanisms.Keys, random)) + new CombinedFailureMechanismSectionAssembly(section1, GetFailureMechanismsOutput(failureMechanisms.Keys, random)), + new CombinedFailureMechanismSectionAssembly(section2, GetFailureMechanismsOutput(failureMechanisms.Keys, random)) }; // Call - CombinedFailureMechanismSectionAssemblyResult[] results = CombinedFailureMechanismSectionAssemblyResultFactory.Create(output, - new Dictionary(), - assessmentSection).ToArray(); + CombinedFailureMechanismSectionAssemblyResult[] results = CombinedFailureMechanismSectionAssemblyResultFactory.Create( + output, new Dictionary(), assessmentSection).ToArray(); // Assert Assert.AreEqual(output.Length, results.Length); for (var i = 0; i < output.Length; i++) { Assert.AreEqual(output[i].Section.SectionStart, results[i].SectionStart); Assert.AreEqual(output[i].Section.SectionEnd, results[i].SectionEnd); - Assert.AreEqual(output[i].Section.CategoryGroup, results[i].TotalResult); + Assert.AreEqual(output[i].Section.AssemblyGroup, results[i].TotalResult); - Assert.AreEqual(FailureMechanismSectionAssemblyCategoryGroup.NotApplicable, results[i].Piping); - Assert.AreEqual(FailureMechanismSectionAssemblyCategoryGroup.NotApplicable, results[i].GrassCoverErosionInwards); - Assert.AreEqual(FailureMechanismSectionAssemblyCategoryGroup.NotApplicable, results[i].MacroStabilityInwards); - Assert.AreEqual(FailureMechanismSectionAssemblyCategoryGroup.NotApplicable, results[i].Microstability); - Assert.AreEqual(FailureMechanismSectionAssemblyCategoryGroup.NotApplicable, results[i].StabilityStoneCover); - Assert.AreEqual(FailureMechanismSectionAssemblyCategoryGroup.NotApplicable, results[i].WaveImpactAsphaltCover); - Assert.AreEqual(FailureMechanismSectionAssemblyCategoryGroup.NotApplicable, results[i].WaterPressureAsphaltCover); - Assert.AreEqual(FailureMechanismSectionAssemblyCategoryGroup.NotApplicable, results[i].GrassCoverErosionOutwards); - Assert.AreEqual(FailureMechanismSectionAssemblyCategoryGroup.NotApplicable, results[i].GrassCoverSlipOffOutwards); - Assert.AreEqual(FailureMechanismSectionAssemblyCategoryGroup.NotApplicable, results[i].GrassCoverSlipOffInwards); - Assert.AreEqual(FailureMechanismSectionAssemblyCategoryGroup.NotApplicable, results[i].HeightStructures); - Assert.AreEqual(FailureMechanismSectionAssemblyCategoryGroup.NotApplicable, results[i].ClosingStructures); - Assert.AreEqual(FailureMechanismSectionAssemblyCategoryGroup.NotApplicable, results[i].PipingStructure); - Assert.AreEqual(FailureMechanismSectionAssemblyCategoryGroup.NotApplicable, results[i].StabilityPointStructures); - Assert.AreEqual(FailureMechanismSectionAssemblyCategoryGroup.NotApplicable, results[i].DuneErosion); + Assert.AreEqual(FailureMechanismSectionAssemblyGroup.Gr, results[i].Piping); + Assert.AreEqual(FailureMechanismSectionAssemblyGroup.Gr, results[i].GrassCoverErosionInwards); + Assert.AreEqual(FailureMechanismSectionAssemblyGroup.Gr, results[i].MacroStabilityInwards); + Assert.AreEqual(FailureMechanismSectionAssemblyGroup.Gr, results[i].Microstability); + Assert.AreEqual(FailureMechanismSectionAssemblyGroup.Gr, results[i].StabilityStoneCover); + Assert.AreEqual(FailureMechanismSectionAssemblyGroup.Gr, results[i].WaveImpactAsphaltCover); + Assert.AreEqual(FailureMechanismSectionAssemblyGroup.Gr, results[i].WaterPressureAsphaltCover); + Assert.AreEqual(FailureMechanismSectionAssemblyGroup.Gr, results[i].GrassCoverErosionOutwards); + Assert.AreEqual(FailureMechanismSectionAssemblyGroup.Gr, results[i].GrassCoverSlipOffOutwards); + Assert.AreEqual(FailureMechanismSectionAssemblyGroup.Gr, results[i].GrassCoverSlipOffInwards); + Assert.AreEqual(FailureMechanismSectionAssemblyGroup.Gr, results[i].HeightStructures); + Assert.AreEqual(FailureMechanismSectionAssemblyGroup.Gr, results[i].ClosingStructures); + Assert.AreEqual(FailureMechanismSectionAssemblyGroup.Gr, results[i].PipingStructure); + Assert.AreEqual(FailureMechanismSectionAssemblyGroup.Gr, results[i].StabilityPointStructures); + Assert.AreEqual(FailureMechanismSectionAssemblyGroup.Gr, results[i].DuneErosion); } } - private static IEnumerable GetFailureMechanismsOutput(IEnumerable failureMechanisms, - Random random) + private static IEnumerable GetFailureMechanismsOutput( + IEnumerable failureMechanisms, Random random) { - return failureMechanisms.Select(fm => random.NextEnumValue()).ToArray(); + return failureMechanisms.Select(fm => random.NextEnumValue()).ToArray(); } } } \ No newline at end of file Index: Riskeer/Integration/test/Riskeer.Integration.Data.Test/Assembly/CombinedFailureMechanismSectionAssemblyResultTest.cs =================================================================== diff -u -r520b3153840dada327c8bd936a4d6a7a07427331 -r89039d4a60d80904883f2ea76f98108595a9accf --- Riskeer/Integration/test/Riskeer.Integration.Data.Test/Assembly/CombinedFailureMechanismSectionAssemblyResultTest.cs (.../CombinedFailureMechanismSectionAssemblyResultTest.cs) (revision 520b3153840dada327c8bd936a4d6a7a07427331) +++ Riskeer/Integration/test/Riskeer.Integration.Data.Test/Assembly/CombinedFailureMechanismSectionAssemblyResultTest.cs (.../CombinedFailureMechanismSectionAssemblyResultTest.cs) (revision 89039d4a60d80904883f2ea76f98108595a9accf) @@ -37,11 +37,12 @@ var random = new Random(21); // Call - TestDelegate call = () => new CombinedFailureMechanismSectionAssemblyResult(random.Next(), random.NextDouble(), random.NextDouble(), - random.NextEnumValue(), null); + void Call() => new CombinedFailureMechanismSectionAssemblyResult( + random.Next(), random.NextDouble(), random.NextDouble(), + random.NextEnumValue(), null); // Assert - var exception = Assert.Throws(call); + var exception = Assert.Throws(Call); Assert.AreEqual("properties", exception.ParamName); } @@ -53,32 +54,33 @@ int sectionNumber = random.Next(); double sectionStart = random.NextDouble(); double sectionEnd = random.NextDouble(); - var totalResult = random.NextEnumValue(); + var totalResult = random.NextEnumValue(); // Call - var result = new CombinedFailureMechanismSectionAssemblyResult(sectionNumber, sectionStart, sectionEnd, totalResult, - new CombinedFailureMechanismSectionAssemblyResult.ConstructionProperties()); + var result = new CombinedFailureMechanismSectionAssemblyResult( + sectionNumber, sectionStart, sectionEnd, totalResult, + new CombinedFailureMechanismSectionAssemblyResult.ConstructionProperties()); // Assert Assert.AreEqual(sectionNumber, result.SectionNumber); Assert.AreEqual(sectionStart, result.SectionStart); Assert.AreEqual(sectionEnd, result.SectionEnd); Assert.AreEqual(totalResult, result.TotalResult); - Assert.AreEqual(FailureMechanismSectionAssemblyCategoryGroup.None, result.Piping); - Assert.AreEqual(FailureMechanismSectionAssemblyCategoryGroup.None, result.GrassCoverErosionInwards); - Assert.AreEqual(FailureMechanismSectionAssemblyCategoryGroup.None, result.MacroStabilityInwards); - Assert.AreEqual(FailureMechanismSectionAssemblyCategoryGroup.None, result.Microstability); - Assert.AreEqual(FailureMechanismSectionAssemblyCategoryGroup.None, result.StabilityStoneCover); - Assert.AreEqual(FailureMechanismSectionAssemblyCategoryGroup.None, result.WaveImpactAsphaltCover); - Assert.AreEqual(FailureMechanismSectionAssemblyCategoryGroup.None, result.WaterPressureAsphaltCover); - Assert.AreEqual(FailureMechanismSectionAssemblyCategoryGroup.None, result.GrassCoverErosionOutwards); - Assert.AreEqual(FailureMechanismSectionAssemblyCategoryGroup.None, result.GrassCoverSlipOffOutwards); - Assert.AreEqual(FailureMechanismSectionAssemblyCategoryGroup.None, result.GrassCoverSlipOffInwards); - Assert.AreEqual(FailureMechanismSectionAssemblyCategoryGroup.None, result.HeightStructures); - Assert.AreEqual(FailureMechanismSectionAssemblyCategoryGroup.None, result.ClosingStructures); - Assert.AreEqual(FailureMechanismSectionAssemblyCategoryGroup.None, result.PipingStructure); - Assert.AreEqual(FailureMechanismSectionAssemblyCategoryGroup.None, result.StabilityPointStructures); - Assert.AreEqual(FailureMechanismSectionAssemblyCategoryGroup.None, result.DuneErosion); + Assert.AreEqual(FailureMechanismSectionAssemblyGroup.Gr, result.Piping); + Assert.AreEqual(FailureMechanismSectionAssemblyGroup.Gr, result.GrassCoverErosionInwards); + Assert.AreEqual(FailureMechanismSectionAssemblyGroup.Gr, result.MacroStabilityInwards); + Assert.AreEqual(FailureMechanismSectionAssemblyGroup.Gr, result.Microstability); + Assert.AreEqual(FailureMechanismSectionAssemblyGroup.Gr, result.StabilityStoneCover); + Assert.AreEqual(FailureMechanismSectionAssemblyGroup.Gr, result.WaveImpactAsphaltCover); + Assert.AreEqual(FailureMechanismSectionAssemblyGroup.Gr, result.WaterPressureAsphaltCover); + Assert.AreEqual(FailureMechanismSectionAssemblyGroup.Gr, result.GrassCoverErosionOutwards); + Assert.AreEqual(FailureMechanismSectionAssemblyGroup.Gr, result.GrassCoverSlipOffOutwards); + Assert.AreEqual(FailureMechanismSectionAssemblyGroup.Gr, result.GrassCoverSlipOffInwards); + Assert.AreEqual(FailureMechanismSectionAssemblyGroup.Gr, result.HeightStructures); + Assert.AreEqual(FailureMechanismSectionAssemblyGroup.Gr, result.ClosingStructures); + Assert.AreEqual(FailureMechanismSectionAssemblyGroup.Gr, result.PipingStructure); + Assert.AreEqual(FailureMechanismSectionAssemblyGroup.Gr, result.StabilityPointStructures); + Assert.AreEqual(FailureMechanismSectionAssemblyGroup.Gr, result.DuneErosion); } [Test] @@ -89,43 +91,44 @@ int sectionNumber = random.Next(); double sectionStart = random.NextDouble(); double sectionEnd = random.NextDouble(); - var totalResult = random.NextEnumValue(); - var pipingResult = random.NextEnumValue(); - var grassCoverErosionInwardsResult = random.NextEnumValue(); - var macroStabilityInwardsResult = random.NextEnumValue(); - var microstabilityResult = random.NextEnumValue(); - var stabilityStoneCoverResult = random.NextEnumValue(); - var waveImpactAsphaltCoverResult = random.NextEnumValue(); - var waterPressureAsphaltCoverResult = random.NextEnumValue(); - var grassCoverErosionOutwardsResult = random.NextEnumValue(); - var grassCoverSlipOffOutwardsResult = random.NextEnumValue(); - var grassCoverSlipOffInwardsResult = random.NextEnumValue(); - var heightStructuresResult = random.NextEnumValue(); - var closingStructuresResult = random.NextEnumValue(); - var pipingStructureResult = random.NextEnumValue(); - var stabilityPointStructuresResult = random.NextEnumValue(); - var duneErosionResult = random.NextEnumValue(); + var totalResult = random.NextEnumValue(); + var pipingResult = random.NextEnumValue(); + var grassCoverErosionInwardsResult = random.NextEnumValue(); + var macroStabilityInwardsResult = random.NextEnumValue(); + var microstabilityResult = random.NextEnumValue(); + var stabilityStoneCoverResult = random.NextEnumValue(); + var waveImpactAsphaltCoverResult = random.NextEnumValue(); + var waterPressureAsphaltCoverResult = random.NextEnumValue(); + var grassCoverErosionOutwardsResult = random.NextEnumValue(); + var grassCoverSlipOffOutwardsResult = random.NextEnumValue(); + var grassCoverSlipOffInwardsResult = random.NextEnumValue(); + var heightStructuresResult = random.NextEnumValue(); + var closingStructuresResult = random.NextEnumValue(); + var pipingStructureResult = random.NextEnumValue(); + var stabilityPointStructuresResult = random.NextEnumValue(); + var duneErosionResult = random.NextEnumValue(); // Call - var result = new CombinedFailureMechanismSectionAssemblyResult(sectionNumber, sectionStart, sectionEnd, totalResult, - new CombinedFailureMechanismSectionAssemblyResult.ConstructionProperties - { - Piping = pipingResult, - GrassCoverErosionInwards = grassCoverErosionInwardsResult, - MacroStabilityInwards = macroStabilityInwardsResult, - Microstability = microstabilityResult, - StabilityStoneCover = stabilityStoneCoverResult, - WaveImpactAsphaltCover = waveImpactAsphaltCoverResult, - WaterPressureAsphaltCover = waterPressureAsphaltCoverResult, - GrassCoverErosionOutwards = grassCoverErosionOutwardsResult, - GrassCoverSlipOffOutwards = grassCoverSlipOffOutwardsResult, - GrassCoverSlipOffInwards = grassCoverSlipOffInwardsResult, - HeightStructures = heightStructuresResult, - ClosingStructures = closingStructuresResult, - PipingStructure = pipingStructureResult, - StabilityPointStructures = stabilityPointStructuresResult, - DuneErosion = duneErosionResult - }); + var result = new CombinedFailureMechanismSectionAssemblyResult( + sectionNumber, sectionStart, sectionEnd, totalResult, + new CombinedFailureMechanismSectionAssemblyResult.ConstructionProperties + { + Piping = pipingResult, + GrassCoverErosionInwards = grassCoverErosionInwardsResult, + MacroStabilityInwards = macroStabilityInwardsResult, + Microstability = microstabilityResult, + StabilityStoneCover = stabilityStoneCoverResult, + WaveImpactAsphaltCover = waveImpactAsphaltCoverResult, + WaterPressureAsphaltCover = waterPressureAsphaltCoverResult, + GrassCoverErosionOutwards = grassCoverErosionOutwardsResult, + GrassCoverSlipOffOutwards = grassCoverSlipOffOutwardsResult, + GrassCoverSlipOffInwards = grassCoverSlipOffInwardsResult, + HeightStructures = heightStructuresResult, + ClosingStructures = closingStructuresResult, + PipingStructure = pipingStructureResult, + StabilityPointStructures = stabilityPointStructuresResult, + DuneErosion = duneErosionResult + }); // Assert Assert.AreEqual(sectionNumber, result.SectionNumber); Index: Riskeer/Integration/test/Riskeer.Integration.Forms.Test/Factories/AssessmentSectionAssemblyMapDataFeaturesFactoryTest.cs =================================================================== diff -u -r8a067d513f440f079818bcec9deb1c86f8360ed6 -r89039d4a60d80904883f2ea76f98108595a9accf --- Riskeer/Integration/test/Riskeer.Integration.Forms.Test/Factories/AssessmentSectionAssemblyMapDataFeaturesFactoryTest.cs (.../AssessmentSectionAssemblyMapDataFeaturesFactoryTest.cs) (revision 8a067d513f440f079818bcec9deb1c86f8360ed6) +++ Riskeer/Integration/test/Riskeer.Integration.Forms.Test/Factories/AssessmentSectionAssemblyMapDataFeaturesFactoryTest.cs (.../AssessmentSectionAssemblyMapDataFeaturesFactoryTest.cs) (revision 89039d4a60d80904883f2ea76f98108595a9accf) @@ -37,9 +37,7 @@ using Riskeer.Integration.Data; using Riskeer.Integration.Data.Assembly; using Riskeer.Integration.Forms.Factories; -using Riskeer.Integration.TestUtil; using Riskeer.Integration.Util; -using Riskeer.MacroStabilityInwards.Data; namespace Riskeer.Integration.Forms.Test.Factories { @@ -50,10 +48,10 @@ public void CreateCombinedFailureMechanismSectionAssemblyFeatures_AssessmentSectionNull_ThrowsArgumentNullException() { // Call - TestDelegate call = () => AssessmentSectionAssemblyMapDataFeaturesFactory.CreateCombinedFailureMechanismSectionAssemblyFeatures(null); + void Call() => AssessmentSectionAssemblyMapDataFeaturesFactory.CreateCombinedFailureMechanismSectionAssemblyFeatures(null); // Assert - var exception = Assert.Throws(call); + var exception = Assert.Throws(Call); Assert.AreEqual("assessmentSection", exception.ParamName); } @@ -70,11 +68,11 @@ new Point2D(2, 2) }); - using (new AssemblyToolCalculatorFactoryConfigOld()) + using (new AssemblyToolCalculatorFactoryConfig()) { - var calculatorFactory = (TestAssemblyToolCalculatorFactoryOld) AssemblyToolCalculatorFactoryOld.Instance; - AssessmentSectionAssemblyCalculatorStubOld calculator = calculatorFactory.LastCreatedAssessmentSectionAssemblyCalculator; - CombinedFailureMechanismSectionAssemblyOld[] failureMechanismSectionAssembly = + var calculatorFactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance; + AssessmentSectionAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedAssessmentSectionAssemblyCalculator; + CombinedFailureMechanismSectionAssembly[] failureMechanismSectionAssembly = { CreateCombinedFailureMechanismSectionAssembly(assessmentSection, 20), CreateCombinedFailureMechanismSectionAssembly(assessmentSection, 21) @@ -102,38 +100,14 @@ Assert.AreEqual(2, actualFeature.MetaData.Keys.Count); Assert.AreEqual(expectedAssemblyResult.SectionNumber, actualFeature.MetaData["Vaknummer"]); - Assert.AreEqual(new EnumDisplayWrapper( - DisplayFailureMechanismSectionAssemblyCategoryGroupConverter.Convert(expectedAssemblyResult.TotalResult)).DisplayName, + Assert.AreEqual(new EnumDisplayWrapper( + DisplayFailureMechanismSectionAssemblyGroupConverter.Convert(expectedAssemblyResult.TotalResult)).DisplayName, features.ElementAt(i).MetaData["Categorie"]); } } } [Test] - public void CreateCombinedFailureMechanismSectionAssemblyFeatures_WithAssessmentSection_ManualAssemblyUsed() - { - // Setup - var random = new Random(21); - AssessmentSection assessmentSection = TestDataGenerator.GetAssessmentSectionWithAllFailureMechanismSectionsAndResults( - random.NextEnumValue()); - MacroStabilityInwardsFailureMechanismSectionResultOld sectionResult = assessmentSection.MacroStabilityInwards.SectionResultsOld.First(); - sectionResult.UseManualAssembly = true; - sectionResult.ManualAssemblyProbability = random.NextDouble(); - - using (new AssemblyToolCalculatorFactoryConfigOld()) - { - var calculatorFactory = (TestAssemblyToolCalculatorFactoryOld) AssemblyToolCalculatorFactoryOld.Instance; - FailureMechanismSectionAssemblyCalculatorOldStub calculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator; - - // Call - AssessmentSectionAssemblyMapDataFeaturesFactory.CreateCombinedFailureMechanismSectionAssemblyFeatures(assessmentSection); - - // Assert - Assert.AreEqual(sectionResult.ManualAssemblyProbability, calculator.ManualAssemblyProbabilityInput); - } - } - - [Test] public void CreateCombinedFailureMechanismSectionAssemblyFeatures_AssemblyCalculatorThrowsException_ReturnsEmptyFeatureCollection() { // Setup @@ -146,10 +120,10 @@ new Point2D(2, 2) }); - using (new AssemblyToolCalculatorFactoryConfigOld()) + using (new AssemblyToolCalculatorFactoryConfig()) { - var calculatorFactory = (TestAssemblyToolCalculatorFactoryOld) AssemblyToolCalculatorFactoryOld.Instance; - AssessmentSectionAssemblyCalculatorStubOld calculator = calculatorFactory.LastCreatedAssessmentSectionAssemblyCalculator; + var calculatorFactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance; + AssessmentSectionAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedAssessmentSectionAssemblyCalculator; calculator.ThrowExceptionOnCalculate = true; // Call @@ -160,15 +134,15 @@ } } - private static CombinedFailureMechanismSectionAssemblyOld CreateCombinedFailureMechanismSectionAssembly(AssessmentSection assessmentSection, int seed) + private static CombinedFailureMechanismSectionAssembly CreateCombinedFailureMechanismSectionAssembly(IAssessmentSection assessmentSection, int seed) { var random = new Random(seed); - return new CombinedFailureMechanismSectionAssemblyOld(new CombinedAssemblyFailureMechanismSectionOld(random.NextDouble(), - random.NextDouble(), - random.NextEnumValue()), - assessmentSection.GetFailureMechanisms() - .Where(fm => fm.InAssembly) - .Select(fm => random.NextEnumValue()).ToArray()); + return new CombinedFailureMechanismSectionAssembly( + new CombinedAssemblyFailureMechanismSection(random.NextDouble(), random.NextDouble(), random.NextEnumValue()), + assessmentSection.GetFailureMechanisms() + .Where(fm => fm.InAssembly) + .Select(fm => random.NextEnumValue()) + .ToArray()); } private static void AssertEqualPointCollections(ReferenceLine referenceLine, Index: Riskeer/Integration/test/Riskeer.Integration.Forms.Test/Views/AssemblyResultPerSectionMapViewTest.cs =================================================================== diff -u -r8a067d513f440f079818bcec9deb1c86f8360ed6 -r89039d4a60d80904883f2ea76f98108595a9accf --- Riskeer/Integration/test/Riskeer.Integration.Forms.Test/Views/AssemblyResultPerSectionMapViewTest.cs (.../AssemblyResultPerSectionMapViewTest.cs) (revision 8a067d513f440f079818bcec9deb1c86f8360ed6) +++ Riskeer/Integration/test/Riskeer.Integration.Forms.Test/Views/AssemblyResultPerSectionMapViewTest.cs (.../AssemblyResultPerSectionMapViewTest.cs) (revision 89039d4a60d80904883f2ea76f98108595a9accf) @@ -149,7 +149,7 @@ }); // Call - using (new AssemblyToolCalculatorFactoryConfigOld()) + using (new AssemblyToolCalculatorFactoryConfig()) { var calculatorFactory = (TestAssemblyToolCalculatorFactoryOld) AssemblyToolCalculatorFactoryOld.Instance; AssessmentSectionAssemblyCalculatorStubOld calculator = calculatorFactory.LastCreatedAssessmentSectionAssemblyCalculator; @@ -488,8 +488,8 @@ Assert.AreEqual(2, actualFeature.MetaData.Keys.Count); Assert.AreEqual(expectedAssemblyResult.SectionNumber, actualFeature.MetaData["Vaknummer"]); - Assert.AreEqual(new EnumDisplayWrapper( - DisplayFailureMechanismSectionAssemblyCategoryGroupConverter.Convert(expectedAssemblyResult.TotalResult)).DisplayName, + Assert.AreEqual(new EnumDisplayWrapper( + DisplayFailureMechanismSectionAssemblyGroupConverter.Convert(expectedAssemblyResult.TotalResult)).DisplayName, mapFeatures.ElementAt(i).MetaData["Categorie"]); } } Index: Riskeer/Integration/test/Riskeer.Integration.Forms.Test/Views/CombinedFailureMechanismSectionAssemblyResultRowTest.cs =================================================================== diff -u -r520b3153840dada327c8bd936a4d6a7a07427331 -r89039d4a60d80904883f2ea76f98108595a9accf --- Riskeer/Integration/test/Riskeer.Integration.Forms.Test/Views/CombinedFailureMechanismSectionAssemblyResultRowTest.cs (.../CombinedFailureMechanismSectionAssemblyResultRowTest.cs) (revision 520b3153840dada327c8bd936a4d6a7a07427331) +++ Riskeer/Integration/test/Riskeer.Integration.Forms.Test/Views/CombinedFailureMechanismSectionAssemblyResultRowTest.cs (.../CombinedFailureMechanismSectionAssemblyResultRowTest.cs) (revision 89039d4a60d80904883f2ea76f98108595a9accf) @@ -58,10 +58,10 @@ public void Constructor_CombinedFailureMechanismAssemblyResultNull_ThrowsArgumentNullException() { // Call - TestDelegate call = () => new CombinedFailureMechanismSectionAssemblyResultRow(null); + void Call() => new CombinedFailureMechanismSectionAssemblyResultRow(null); // Assert - var exception = Assert.Throws(call); + var exception = Assert.Throws(Call); Assert.AreEqual("combinedFailureMechanismSectionAssemblyResult", exception.ParamName); } @@ -101,28 +101,28 @@ Assert.AreEqual(result.SectionStart, row.SectionStart, row.SectionStart.GetAccuracy()); Assert.AreEqual(2, row.SectionStart.NumberOfDecimalPlaces); Assert.AreEqual(result.SectionEnd, row.SectionEnd, row.SectionEnd.GetAccuracy()); - Assert.AreEqual(FailureMechanismSectionAssemblyCategoryGroupHelper.GetCategoryGroupDisplayName(result.TotalResult), row.TotalResult); - Assert.AreEqual(FailureMechanismSectionAssemblyCategoryGroupHelper.GetCategoryGroupDisplayName(result.Piping), row.Piping); - Assert.AreEqual(FailureMechanismSectionAssemblyCategoryGroupHelper.GetCategoryGroupDisplayName(result.GrassCoverErosionInwards), row.GrassCoverErosionInwards); - Assert.AreEqual(FailureMechanismSectionAssemblyCategoryGroupHelper.GetCategoryGroupDisplayName(result.MacroStabilityInwards), row.MacroStabilityInwards); - Assert.AreEqual(FailureMechanismSectionAssemblyCategoryGroupHelper.GetCategoryGroupDisplayName(result.Microstability), row.Microstability); - Assert.AreEqual(FailureMechanismSectionAssemblyCategoryGroupHelper.GetCategoryGroupDisplayName(result.StabilityStoneCover), row.StabilityStoneCover); - Assert.AreEqual(FailureMechanismSectionAssemblyCategoryGroupHelper.GetCategoryGroupDisplayName(result.WaveImpactAsphaltCover), row.WaveImpactAsphaltCover); - Assert.AreEqual(FailureMechanismSectionAssemblyCategoryGroupHelper.GetCategoryGroupDisplayName(result.WaterPressureAsphaltCover), row.WaterPressureAsphaltCover); - Assert.AreEqual(FailureMechanismSectionAssemblyCategoryGroupHelper.GetCategoryGroupDisplayName(result.GrassCoverErosionOutwards), row.GrassCoverErosionOutwards); - Assert.AreEqual(FailureMechanismSectionAssemblyCategoryGroupHelper.GetCategoryGroupDisplayName(result.GrassCoverSlipOffOutwards), row.GrassCoverSlipOffOutwards); - Assert.AreEqual(FailureMechanismSectionAssemblyCategoryGroupHelper.GetCategoryGroupDisplayName(result.GrassCoverSlipOffInwards), row.GrassCoverSlipOffInwards); - Assert.AreEqual(FailureMechanismSectionAssemblyCategoryGroupHelper.GetCategoryGroupDisplayName(result.HeightStructures), row.HeightStructures); - Assert.AreEqual(FailureMechanismSectionAssemblyCategoryGroupHelper.GetCategoryGroupDisplayName(result.ClosingStructures), row.ClosingStructures); - Assert.AreEqual(FailureMechanismSectionAssemblyCategoryGroupHelper.GetCategoryGroupDisplayName(result.PipingStructure), row.PipingStructure); - Assert.AreEqual(FailureMechanismSectionAssemblyCategoryGroupHelper.GetCategoryGroupDisplayName(result.StabilityPointStructures), row.StabilityPointStructures); - Assert.AreEqual(FailureMechanismSectionAssemblyCategoryGroupHelper.GetCategoryGroupDisplayName(result.DuneErosion), row.DuneErosion); + Assert.AreEqual(FailureMechanismSectionAssemblyGroupDisplayHelper.GetAssemblyGroupDisplayName(result.TotalResult), row.TotalResult); + Assert.AreEqual(FailureMechanismSectionAssemblyGroupDisplayHelper.GetAssemblyGroupDisplayName(result.Piping), row.Piping); + Assert.AreEqual(FailureMechanismSectionAssemblyGroupDisplayHelper.GetAssemblyGroupDisplayName(result.GrassCoverErosionInwards), row.GrassCoverErosionInwards); + Assert.AreEqual(FailureMechanismSectionAssemblyGroupDisplayHelper.GetAssemblyGroupDisplayName(result.MacroStabilityInwards), row.MacroStabilityInwards); + Assert.AreEqual(FailureMechanismSectionAssemblyGroupDisplayHelper.GetAssemblyGroupDisplayName(result.Microstability), row.Microstability); + Assert.AreEqual(FailureMechanismSectionAssemblyGroupDisplayHelper.GetAssemblyGroupDisplayName(result.StabilityStoneCover), row.StabilityStoneCover); + Assert.AreEqual(FailureMechanismSectionAssemblyGroupDisplayHelper.GetAssemblyGroupDisplayName(result.WaveImpactAsphaltCover), row.WaveImpactAsphaltCover); + Assert.AreEqual(FailureMechanismSectionAssemblyGroupDisplayHelper.GetAssemblyGroupDisplayName(result.WaterPressureAsphaltCover), row.WaterPressureAsphaltCover); + Assert.AreEqual(FailureMechanismSectionAssemblyGroupDisplayHelper.GetAssemblyGroupDisplayName(result.GrassCoverErosionOutwards), row.GrassCoverErosionOutwards); + Assert.AreEqual(FailureMechanismSectionAssemblyGroupDisplayHelper.GetAssemblyGroupDisplayName(result.GrassCoverSlipOffOutwards), row.GrassCoverSlipOffOutwards); + Assert.AreEqual(FailureMechanismSectionAssemblyGroupDisplayHelper.GetAssemblyGroupDisplayName(result.GrassCoverSlipOffInwards), row.GrassCoverSlipOffInwards); + Assert.AreEqual(FailureMechanismSectionAssemblyGroupDisplayHelper.GetAssemblyGroupDisplayName(result.HeightStructures), row.HeightStructures); + Assert.AreEqual(FailureMechanismSectionAssemblyGroupDisplayHelper.GetAssemblyGroupDisplayName(result.ClosingStructures), row.ClosingStructures); + Assert.AreEqual(FailureMechanismSectionAssemblyGroupDisplayHelper.GetAssemblyGroupDisplayName(result.PipingStructure), row.PipingStructure); + Assert.AreEqual(FailureMechanismSectionAssemblyGroupDisplayHelper.GetAssemblyGroupDisplayName(result.StabilityPointStructures), row.StabilityPointStructures); + Assert.AreEqual(FailureMechanismSectionAssemblyGroupDisplayHelper.GetAssemblyGroupDisplayName(result.DuneErosion), row.DuneErosion); } [Test] - [TestCaseSource(typeof(AssemblyCategoryColorTestHelper), nameof(AssemblyCategoryColorTestHelper.FailureMechanismSectionAssemblyCategoryGroupColorCases))] + [TestCaseSource(typeof(AssemblyGroupColorTestHelper), nameof(AssemblyGroupColorTestHelper.FailureMechanismSectionAssemblyGroupColorCases))] public void Constructor_WithCombinedFailureMechanismAssemblyResult_ExpectedColumnStates( - FailureMechanismSectionAssemblyCategoryGroup categoryGroup, + FailureMechanismSectionAssemblyGroup categoryGroup, Color expectedBackgroundColor) { // Setup @@ -183,24 +183,24 @@ random.Next(), random.NextDouble(), random.NextDouble(), - random.NextEnumValue(), + random.NextEnumValue(), new CombinedFailureMechanismSectionAssemblyResult.ConstructionProperties { - Piping = random.NextEnumValue(), - GrassCoverErosionInwards = random.NextEnumValue(), - MacroStabilityInwards = random.NextEnumValue(), - Microstability = random.NextEnumValue(), - StabilityStoneCover = random.NextEnumValue(), - WaveImpactAsphaltCover = random.NextEnumValue(), - WaterPressureAsphaltCover = random.NextEnumValue(), - GrassCoverErosionOutwards = random.NextEnumValue(), - GrassCoverSlipOffOutwards = random.NextEnumValue(), - GrassCoverSlipOffInwards = random.NextEnumValue(), - HeightStructures = random.NextEnumValue(), - ClosingStructures = random.NextEnumValue(), - PipingStructure = random.NextEnumValue(), - StabilityPointStructures = random.NextEnumValue(), - DuneErosion = random.NextEnumValue() + Piping = random.NextEnumValue(), + GrassCoverErosionInwards = random.NextEnumValue(), + MacroStabilityInwards = random.NextEnumValue(), + Microstability = random.NextEnumValue(), + StabilityStoneCover = random.NextEnumValue(), + WaveImpactAsphaltCover = random.NextEnumValue(), + WaterPressureAsphaltCover = random.NextEnumValue(), + GrassCoverErosionOutwards = random.NextEnumValue(), + GrassCoverSlipOffOutwards = random.NextEnumValue(), + GrassCoverSlipOffInwards = random.NextEnumValue(), + HeightStructures = random.NextEnumValue(), + ClosingStructures = random.NextEnumValue(), + PipingStructure = random.NextEnumValue(), + StabilityPointStructures = random.NextEnumValue(), + DuneErosion = random.NextEnumValue() }); } } Index: Riskeer/Integration/test/Riskeer.Integration.IO.Test/Factories/ExportableCombinedSectionAssemblyFactoryTest.cs =================================================================== diff -u -r520b3153840dada327c8bd936a4d6a7a07427331 -r89039d4a60d80904883f2ea76f98108595a9accf --- Riskeer/Integration/test/Riskeer.Integration.IO.Test/Factories/ExportableCombinedSectionAssemblyFactoryTest.cs (.../ExportableCombinedSectionAssemblyFactoryTest.cs) (revision 520b3153840dada327c8bd936a4d6a7a07427331) +++ Riskeer/Integration/test/Riskeer.Integration.IO.Test/Factories/ExportableCombinedSectionAssemblyFactoryTest.cs (.../ExportableCombinedSectionAssemblyFactoryTest.cs) (revision 89039d4a60d80904883f2ea76f98108595a9accf) @@ -78,55 +78,54 @@ }; // Call - IEnumerable exportableCombinedSectionAssembly = + IEnumerable exportableCombinedSectionAssemblies = ExportableCombinedSectionAssemblyFactory.CreateExportableCombinedSectionAssemblyCollection(assemblyResults, referenceLine); // Assert - AssertCombinedFailureMechanismSectionAssemblyResults(assemblyResults, exportableCombinedSectionAssembly, referenceLine); + AssertCombinedFailureMechanismSectionAssemblyResults(assemblyResults, exportableCombinedSectionAssemblies, referenceLine); } private static CombinedFailureMechanismSectionAssemblyResult CreateCombinedFailureMechanismSectionAssemblyResult(int seed) { var random = new Random(seed); - return new CombinedFailureMechanismSectionAssemblyResult(random.Next(), - random.NextDouble(), - random.NextDouble(), - random.NextEnumValue(), - new CombinedFailureMechanismSectionAssemblyResult.ConstructionProperties - { - Piping = random.NextEnumValue(), - GrassCoverErosionInwards = random.NextEnumValue(), - MacroStabilityInwards = random.NextEnumValue(), - Microstability = random.NextEnumValue(), - StabilityStoneCover = random.NextEnumValue(), - WaveImpactAsphaltCover = random.NextEnumValue(), - WaterPressureAsphaltCover = random.NextEnumValue(), - GrassCoverErosionOutwards = random.NextEnumValue(), - GrassCoverSlipOffOutwards = random.NextEnumValue(), - GrassCoverSlipOffInwards = random.NextEnumValue(), - HeightStructures = random.NextEnumValue(), - ClosingStructures = random.NextEnumValue(), - PipingStructure = random.NextEnumValue(), - StabilityPointStructures = random.NextEnumValue(), - DuneErosion = random.NextEnumValue() - }); + return new CombinedFailureMechanismSectionAssemblyResult( + random.Next(), random.NextDouble(), random.NextDouble(), + random.NextEnumValue(), + new CombinedFailureMechanismSectionAssemblyResult.ConstructionProperties + { + Piping = random.NextEnumValue(), + GrassCoverErosionInwards = random.NextEnumValue(), + MacroStabilityInwards = random.NextEnumValue(), + Microstability = random.NextEnumValue(), + StabilityStoneCover = random.NextEnumValue(), + WaveImpactAsphaltCover = random.NextEnumValue(), + WaterPressureAsphaltCover = random.NextEnumValue(), + GrassCoverErosionOutwards = random.NextEnumValue(), + GrassCoverSlipOffOutwards = random.NextEnumValue(), + GrassCoverSlipOffInwards = random.NextEnumValue(), + HeightStructures = random.NextEnumValue(), + ClosingStructures = random.NextEnumValue(), + PipingStructure = random.NextEnumValue(), + StabilityPointStructures = random.NextEnumValue(), + DuneErosion = random.NextEnumValue() + }); } - private static void AssertCombinedFailureMechanismSectionAssemblyResults(IEnumerable expectedSectionResults, - IEnumerable combinedSectionAssemblies, + private static void AssertCombinedFailureMechanismSectionAssemblyResults(IEnumerable assemblyResults, + IEnumerable exportableCombinedSectionAssemblies, ReferenceLine referenceLine) { - int expectedNrOfSections = expectedSectionResults.Count(); - Assert.AreEqual(expectedNrOfSections, combinedSectionAssemblies.Count()); + int expectedNrOfSections = assemblyResults.Count(); + Assert.AreEqual(expectedNrOfSections, exportableCombinedSectionAssemblies.Count()); for (var i = 0; i < expectedNrOfSections; i++) { - CombinedFailureMechanismSectionAssemblyResult expectedSection = expectedSectionResults.ElementAt(i); - ExportableCombinedSectionAssembly actualSectionResult = combinedSectionAssemblies.ElementAt(i); + CombinedFailureMechanismSectionAssemblyResult combinedFailureMechanismSectionAssemblyResult = assemblyResults.ElementAt(i); + ExportableCombinedSectionAssembly exportableCombinedSectionAssembly = exportableCombinedSectionAssemblies.ElementAt(i); - AssertExportableCombinedFailureMechanismSection(expectedSection, actualSectionResult.Section, referenceLine); - AssertExportableCombinedFailureMechanismSectionResult(actualSectionResult, actualSectionResult.Section, expectedSection); + AssertExportableCombinedFailureMechanismSection(combinedFailureMechanismSectionAssemblyResult, exportableCombinedSectionAssembly.Section, referenceLine); + AssertExportableCombinedFailureMechanismSectionResult(combinedFailureMechanismSectionAssemblyResult, exportableCombinedSectionAssembly.Section, exportableCombinedSectionAssembly); } } @@ -146,61 +145,61 @@ Assert.AreEqual(ExportableAssemblyMethod.WBI3A1, actualSection.AssemblyMethod); } - private static void AssertExportableCombinedFailureMechanismSectionResult(ExportableCombinedSectionAssembly expectedSectionResult, - ExportableCombinedFailureMechanismSection expectedSection, - CombinedFailureMechanismSectionAssemblyResult actualCombinedSectionAssemblyResult) + private static void AssertExportableCombinedFailureMechanismSectionResult(CombinedFailureMechanismSectionAssemblyResult expectedSection, + ExportableCombinedFailureMechanismSection actualSection, + ExportableCombinedSectionAssembly actualSectionResult) { - Assert.AreSame(expectedSection, expectedSectionResult.Section); - Assert.AreEqual(actualCombinedSectionAssemblyResult.TotalResult, expectedSectionResult.CombinedSectionAssemblyResult.AssemblyCategory); - Assert.AreEqual(ExportableAssemblyMethod.WBI3C1, expectedSectionResult.CombinedSectionAssemblyResult.AssemblyMethod); + Assert.AreSame(actualSection, actualSectionResult.Section); + Assert.AreEqual(FailureMechanismSectionAssemblyCategoryGroup.None, actualSectionResult.CombinedSectionAssemblyResult.AssemblyCategory); + Assert.AreEqual(ExportableAssemblyMethod.WBI3C1, actualSectionResult.CombinedSectionAssemblyResult.AssemblyMethod); - IEnumerable failureMechanismCombinedSectionResults = expectedSectionResult.FailureMechanismResults; + IEnumerable failureMechanismCombinedSectionResults = actualSectionResult.FailureMechanismResults; Assert.AreEqual(15, failureMechanismCombinedSectionResults.Count()); Assert.IsTrue(failureMechanismCombinedSectionResults.All(result => result.SectionAssemblyResult.AssemblyMethod == ExportableAssemblyMethod.WBI3B1)); - Assert.AreEqual(actualCombinedSectionAssemblyResult.Piping, failureMechanismCombinedSectionResults.ElementAt(0).SectionAssemblyResult.AssemblyCategory); + Assert.AreEqual(FailureMechanismSectionAssemblyCategoryGroup.None, failureMechanismCombinedSectionResults.ElementAt(0).SectionAssemblyResult.AssemblyCategory); Assert.AreEqual(ExportableFailureMechanismType.STPH, failureMechanismCombinedSectionResults.ElementAt(0).Code); - Assert.AreEqual(actualCombinedSectionAssemblyResult.GrassCoverErosionInwards, failureMechanismCombinedSectionResults.ElementAt(1).SectionAssemblyResult.AssemblyCategory); + Assert.AreEqual(FailureMechanismSectionAssemblyCategoryGroup.None, failureMechanismCombinedSectionResults.ElementAt(1).SectionAssemblyResult.AssemblyCategory); Assert.AreEqual(ExportableFailureMechanismType.GEKB, failureMechanismCombinedSectionResults.ElementAt(1).Code); - Assert.AreEqual(actualCombinedSectionAssemblyResult.MacroStabilityInwards, failureMechanismCombinedSectionResults.ElementAt(2).SectionAssemblyResult.AssemblyCategory); + Assert.AreEqual(FailureMechanismSectionAssemblyCategoryGroup.None, failureMechanismCombinedSectionResults.ElementAt(2).SectionAssemblyResult.AssemblyCategory); Assert.AreEqual(ExportableFailureMechanismType.STBI, failureMechanismCombinedSectionResults.ElementAt(2).Code); - Assert.AreEqual(actualCombinedSectionAssemblyResult.Microstability, failureMechanismCombinedSectionResults.ElementAt(3).SectionAssemblyResult.AssemblyCategory); + Assert.AreEqual(FailureMechanismSectionAssemblyCategoryGroup.None, failureMechanismCombinedSectionResults.ElementAt(3).SectionAssemblyResult.AssemblyCategory); Assert.AreEqual(ExportableFailureMechanismType.STMI, failureMechanismCombinedSectionResults.ElementAt(3).Code); - Assert.AreEqual(actualCombinedSectionAssemblyResult.StabilityStoneCover, failureMechanismCombinedSectionResults.ElementAt(4).SectionAssemblyResult.AssemblyCategory); + Assert.AreEqual(FailureMechanismSectionAssemblyCategoryGroup.None, failureMechanismCombinedSectionResults.ElementAt(4).SectionAssemblyResult.AssemblyCategory); Assert.AreEqual(ExportableFailureMechanismType.ZST, failureMechanismCombinedSectionResults.ElementAt(4).Code); - Assert.AreEqual(actualCombinedSectionAssemblyResult.WaveImpactAsphaltCover, failureMechanismCombinedSectionResults.ElementAt(5).SectionAssemblyResult.AssemblyCategory); + Assert.AreEqual(FailureMechanismSectionAssemblyCategoryGroup.None, failureMechanismCombinedSectionResults.ElementAt(5).SectionAssemblyResult.AssemblyCategory); Assert.AreEqual(ExportableFailureMechanismType.AGK, failureMechanismCombinedSectionResults.ElementAt(5).Code); - Assert.AreEqual(actualCombinedSectionAssemblyResult.WaterPressureAsphaltCover, failureMechanismCombinedSectionResults.ElementAt(6).SectionAssemblyResult.AssemblyCategory); + Assert.AreEqual(FailureMechanismSectionAssemblyCategoryGroup.None, failureMechanismCombinedSectionResults.ElementAt(6).SectionAssemblyResult.AssemblyCategory); Assert.AreEqual(ExportableFailureMechanismType.AWO, failureMechanismCombinedSectionResults.ElementAt(6).Code); - Assert.AreEqual(actualCombinedSectionAssemblyResult.GrassCoverErosionOutwards, failureMechanismCombinedSectionResults.ElementAt(7).SectionAssemblyResult.AssemblyCategory); + Assert.AreEqual(FailureMechanismSectionAssemblyCategoryGroup.None, failureMechanismCombinedSectionResults.ElementAt(7).SectionAssemblyResult.AssemblyCategory); Assert.AreEqual(ExportableFailureMechanismType.GEBU, failureMechanismCombinedSectionResults.ElementAt(7).Code); - Assert.AreEqual(actualCombinedSectionAssemblyResult.GrassCoverSlipOffOutwards, failureMechanismCombinedSectionResults.ElementAt(8).SectionAssemblyResult.AssemblyCategory); + Assert.AreEqual(FailureMechanismSectionAssemblyCategoryGroup.None, failureMechanismCombinedSectionResults.ElementAt(8).SectionAssemblyResult.AssemblyCategory); Assert.AreEqual(ExportableFailureMechanismType.GABU, failureMechanismCombinedSectionResults.ElementAt(8).Code); - Assert.AreEqual(actualCombinedSectionAssemblyResult.GrassCoverSlipOffInwards, failureMechanismCombinedSectionResults.ElementAt(9).SectionAssemblyResult.AssemblyCategory); + Assert.AreEqual(FailureMechanismSectionAssemblyCategoryGroup.None, failureMechanismCombinedSectionResults.ElementAt(9).SectionAssemblyResult.AssemblyCategory); Assert.AreEqual(ExportableFailureMechanismType.GABI, failureMechanismCombinedSectionResults.ElementAt(9).Code); - Assert.AreEqual(actualCombinedSectionAssemblyResult.HeightStructures, failureMechanismCombinedSectionResults.ElementAt(10).SectionAssemblyResult.AssemblyCategory); + Assert.AreEqual(FailureMechanismSectionAssemblyCategoryGroup.None, failureMechanismCombinedSectionResults.ElementAt(10).SectionAssemblyResult.AssemblyCategory); Assert.AreEqual(ExportableFailureMechanismType.HTKW, failureMechanismCombinedSectionResults.ElementAt(10).Code); - Assert.AreEqual(actualCombinedSectionAssemblyResult.ClosingStructures, failureMechanismCombinedSectionResults.ElementAt(11).SectionAssemblyResult.AssemblyCategory); + Assert.AreEqual(FailureMechanismSectionAssemblyCategoryGroup.None, failureMechanismCombinedSectionResults.ElementAt(11).SectionAssemblyResult.AssemblyCategory); Assert.AreEqual(ExportableFailureMechanismType.BSKW, failureMechanismCombinedSectionResults.ElementAt(11).Code); - Assert.AreEqual(actualCombinedSectionAssemblyResult.PipingStructure, failureMechanismCombinedSectionResults.ElementAt(12).SectionAssemblyResult.AssemblyCategory); + Assert.AreEqual(FailureMechanismSectionAssemblyCategoryGroup.None, failureMechanismCombinedSectionResults.ElementAt(12).SectionAssemblyResult.AssemblyCategory); Assert.AreEqual(ExportableFailureMechanismType.PKW, failureMechanismCombinedSectionResults.ElementAt(12).Code); - Assert.AreEqual(actualCombinedSectionAssemblyResult.StabilityPointStructures, failureMechanismCombinedSectionResults.ElementAt(13).SectionAssemblyResult.AssemblyCategory); + Assert.AreEqual(FailureMechanismSectionAssemblyCategoryGroup.None, failureMechanismCombinedSectionResults.ElementAt(13).SectionAssemblyResult.AssemblyCategory); Assert.AreEqual(ExportableFailureMechanismType.STKWp, failureMechanismCombinedSectionResults.ElementAt(13).Code); - Assert.AreEqual(actualCombinedSectionAssemblyResult.DuneErosion, failureMechanismCombinedSectionResults.ElementAt(14).SectionAssemblyResult.AssemblyCategory); + Assert.AreEqual(FailureMechanismSectionAssemblyCategoryGroup.None, failureMechanismCombinedSectionResults.ElementAt(14).SectionAssemblyResult.AssemblyCategory); Assert.AreEqual(ExportableFailureMechanismType.DA, failureMechanismCombinedSectionResults.ElementAt(14).Code); } }