Index: Ringtoets/Integration/src/Ringtoets.Integration.Data/Assembly/CombinedAssemblyFailureMechanismSectionFactory.cs
===================================================================
diff -u -r4346ce5754a1bf0bc10aaf5bd24d1a2f487acab1 -r8eaa7df3b7a3e67d1fa4ae26fe4f17a8e25ec0b4
--- Ringtoets/Integration/src/Ringtoets.Integration.Data/Assembly/CombinedAssemblyFailureMechanismSectionFactory.cs (.../CombinedAssemblyFailureMechanismSectionFactory.cs) (revision 4346ce5754a1bf0bc10aaf5bd24d1a2f487acab1)
+++ Ringtoets/Integration/src/Ringtoets.Integration.Data/Assembly/CombinedAssemblyFailureMechanismSectionFactory.cs (.../CombinedAssemblyFailureMechanismSectionFactory.cs) (revision 8eaa7df3b7a3e67d1fa4ae26fe4f17a8e25ec0b4)
@@ -50,10 +50,12 @@
///
/// The assessment section to use.
/// The failure mechanisms to build input for.
+ /// Indicator that determines whether the manual assembly should be considered when assembling the result.
/// A collection of collections.
/// Thrown when any parameter is null.
public static IEnumerable> CreateInput(AssessmentSection assessmentSection,
- IEnumerable failureMechanisms)
+ IEnumerable failureMechanisms,
+ bool useManual)
{
if (assessmentSection == null)
{
@@ -71,126 +73,126 @@
if (failureMechanisms.Contains(pipingFailureMechanism))
{
inputs.Add(CreateCombinedSections(pipingFailureMechanism.SectionResults,
- assessmentSection, PipingAssemblyFunc));
+ assessmentSection, PipingAssemblyFunc, useManual));
}
GrassCoverErosionInwardsFailureMechanism grassCoverErosionInwardsFailureMechanism = assessmentSection.GrassCoverErosionInwards;
if (failureMechanisms.Contains(grassCoverErosionInwardsFailureMechanism))
{
inputs.Add(CreateCombinedSections(grassCoverErosionInwardsFailureMechanism.SectionResults,
- assessmentSection, GrassCoverErosionInwardsAssemblyFunc));
+ assessmentSection, GrassCoverErosionInwardsAssemblyFunc, useManual));
}
MacroStabilityInwardsFailureMechanism macroStabilityInwardsFailureMechanism = assessmentSection.MacroStabilityInwards;
if (failureMechanisms.Contains(macroStabilityInwardsFailureMechanism))
{
inputs.Add(CreateCombinedSections(macroStabilityInwardsFailureMechanism.SectionResults,
- assessmentSection, MacroStabilityInwardsAssemblyFunc));
+ assessmentSection, MacroStabilityInwardsAssemblyFunc, useManual));
}
MacroStabilityOutwardsFailureMechanism macroStabilityOutwardsFailureMechanism = assessmentSection.MacroStabilityOutwards;
if (failureMechanisms.Contains(macroStabilityOutwardsFailureMechanism))
{
inputs.Add(CreateCombinedSections(macroStabilityOutwardsFailureMechanism.SectionResults,
- assessmentSection, MacroStabilityOutwardsAssemblyFunc));
+ assessmentSection, MacroStabilityOutwardsAssemblyFunc, useManual));
}
MicrostabilityFailureMechanism microstabilityFailureMechanism = assessmentSection.Microstability;
if (failureMechanisms.Contains(microstabilityFailureMechanism))
{
inputs.Add(CreateCombinedSections(microstabilityFailureMechanism.SectionResults,
- MicrostabilityAssemblyFunc));
+ MicrostabilityAssemblyFunc, useManual));
}
StabilityStoneCoverFailureMechanism stabilityStoneCoverFailureMechanism = assessmentSection.StabilityStoneCover;
if (failureMechanisms.Contains(stabilityStoneCoverFailureMechanism))
{
inputs.Add(CreateCombinedSections(stabilityStoneCoverFailureMechanism.SectionResults,
- StabilityStoneCoverAssemblyFunc));
+ StabilityStoneCoverAssemblyFunc, useManual));
}
WaveImpactAsphaltCoverFailureMechanism waveImpactAsphaltCoverFailureMechanism = assessmentSection.WaveImpactAsphaltCover;
if (failureMechanisms.Contains(waveImpactAsphaltCoverFailureMechanism))
{
inputs.Add(CreateCombinedSections(waveImpactAsphaltCoverFailureMechanism.SectionResults,
- WaveImpactAsphaltCoverAssemblyFunc));
+ WaveImpactAsphaltCoverAssemblyFunc, useManual));
}
WaterPressureAsphaltCoverFailureMechanism waterPressureAsphaltCoverFailureMechanism = assessmentSection.WaterPressureAsphaltCover;
if (failureMechanisms.Contains(waterPressureAsphaltCoverFailureMechanism))
{
inputs.Add(CreateCombinedSections(waterPressureAsphaltCoverFailureMechanism.SectionResults,
- WaterPressureAsphaltCoverAssemblyFunc));
+ WaterPressureAsphaltCoverAssemblyFunc, useManual));
}
GrassCoverErosionOutwardsFailureMechanism grassCoverErosionOutwardsFailureMechanism = assessmentSection.GrassCoverErosionOutwards;
if (failureMechanisms.Contains(grassCoverErosionOutwardsFailureMechanism))
{
inputs.Add(CreateCombinedSections(grassCoverErosionOutwardsFailureMechanism.SectionResults,
- GrassCoverErosionOutwardsAssemblyFunc));
+ GrassCoverErosionOutwardsAssemblyFunc, useManual));
}
GrassCoverSlipOffOutwardsFailureMechanism grassCoverSlipOffOutwardsFailureMechanism = assessmentSection.GrassCoverSlipOffOutwards;
if (failureMechanisms.Contains(grassCoverSlipOffOutwardsFailureMechanism))
{
inputs.Add(CreateCombinedSections(grassCoverSlipOffOutwardsFailureMechanism.SectionResults,
- GrassCoverSlipOffOutwardsAssemblyFunc));
+ GrassCoverSlipOffOutwardsAssemblyFunc, useManual));
}
GrassCoverSlipOffInwardsFailureMechanism grassCoverSlipOffInwardsFailureMechanism = assessmentSection.GrassCoverSlipOffInwards;
if (failureMechanisms.Contains(grassCoverSlipOffInwardsFailureMechanism))
{
inputs.Add(CreateCombinedSections(grassCoverSlipOffInwardsFailureMechanism.SectionResults,
- GrassCoverSlipOffInwardsAssemblyFunc));
+ GrassCoverSlipOffInwardsAssemblyFunc, useManual));
}
HeightStructuresFailureMechanism heightStructuresFailureMechanism = assessmentSection.HeightStructures;
if (failureMechanisms.Contains(heightStructuresFailureMechanism))
{
inputs.Add(CreateCombinedSections(heightStructuresFailureMechanism.SectionResults,
- assessmentSection, HeightStructuresAssemblyFunc));
+ assessmentSection, HeightStructuresAssemblyFunc, useManual));
}
ClosingStructuresFailureMechanism closingStructuresFailureMechanism = assessmentSection.ClosingStructures;
if (failureMechanisms.Contains(closingStructuresFailureMechanism))
{
inputs.Add(CreateCombinedSections(closingStructuresFailureMechanism.SectionResults,
- assessmentSection, ClosingStructuresAssemblyFunc));
+ assessmentSection, ClosingStructuresAssemblyFunc, useManual));
}
PipingStructureFailureMechanism pipingStructureFailureMechanism = assessmentSection.PipingStructure;
if (failureMechanisms.Contains(pipingStructureFailureMechanism))
{
inputs.Add(CreateCombinedSections(pipingStructureFailureMechanism.SectionResults,
- PipingStructureAssemblyFunc));
+ PipingStructureAssemblyFunc, useManual));
}
StabilityPointStructuresFailureMechanism stabilityPointStructuresFailureMechanism = assessmentSection.StabilityPointStructures;
if (failureMechanisms.Contains(stabilityPointStructuresFailureMechanism))
{
inputs.Add(CreateCombinedSections(stabilityPointStructuresFailureMechanism.SectionResults,
- assessmentSection, StabilityPointStructuresAssemblyFunc));
+ assessmentSection, StabilityPointStructuresAssemblyFunc, useManual));
}
StrengthStabilityLengthwiseConstructionFailureMechanism strengthStabilityLengthwiseConstructionFailureMechanism = assessmentSection.StrengthStabilityLengthwiseConstruction;
if (failureMechanisms.Contains(strengthStabilityLengthwiseConstructionFailureMechanism))
{
inputs.Add(CreateCombinedSections(strengthStabilityLengthwiseConstructionFailureMechanism.SectionResults,
- StrengthStabilityLengthwiseConstructionAssemblyFunc));
+ StrengthStabilityLengthwiseConstructionAssemblyFunc, useManual));
}
DuneErosionFailureMechanism duneErosionFailureMechanism = assessmentSection.DuneErosion;
if (failureMechanisms.Contains(duneErosionFailureMechanism))
{
inputs.Add(CreateCombinedSections(duneErosionFailureMechanism.SectionResults,
- DuneErosionAssemblyFunc));
+ DuneErosionAssemblyFunc, useManual));
}
TechnicalInnovationFailureMechanism technicalInnovationFailureMechanism = assessmentSection.TechnicalInnovation;
if (failureMechanisms.Contains(technicalInnovationFailureMechanism))
{
inputs.Add(CreateCombinedSections(technicalInnovationFailureMechanism.SectionResults,
- TechnicalInnovationAssemblyFunc));
+ TechnicalInnovationAssemblyFunc, useManual));
}
return inputs;
@@ -199,14 +201,19 @@
private static IEnumerable CreateCombinedSections(
IEnumerable sectionResults,
AssessmentSection assessmentSection,
- Func getAssemblyFunc)
+ Func getAssemblyFunc,
+ bool useManual)
where TFailureMechanismSectionResult : FailureMechanismSectionResult
{
double totalSectionsLength = 0;
return sectionResults.Select(sectionResult =>
{
- CombinedAssemblyFailureMechanismSection section = CreateSection(sectionResult, getAssemblyFunc(sectionResult, assessmentSection), totalSectionsLength);
+ CombinedAssemblyFailureMechanismSection section = CreateSection(sectionResult,
+ getAssemblyFunc(sectionResult,
+ assessmentSection,
+ useManual),
+ totalSectionsLength);
totalSectionsLength = section.SectionEnd;
return section;
})
@@ -215,14 +222,15 @@
private static IEnumerable CreateCombinedSections(
IEnumerable sectionResults,
- Func getAssemblyFunc)
+ Func getAssemblyFunc,
+ bool useManual)
where TFailureMechanismSectionResult : FailureMechanismSectionResult
{
double totalSectionsLength = 0;
return sectionResults.Select(sectionResult =>
{
- CombinedAssemblyFailureMechanismSection section = CreateSection(sectionResult, getAssemblyFunc(sectionResult), totalSectionsLength);
+ CombinedAssemblyFailureMechanismSection section = CreateSection(sectionResult, getAssemblyFunc(sectionResult, useManual), totalSectionsLength);
totalSectionsLength = section.SectionEnd;
return section;
})
@@ -240,150 +248,150 @@
#region Assembly Funcs
- private static Func PipingAssemblyFunc
+ private static Func PipingAssemblyFunc
{
get
{
- return (sectionResult, assessmentSection) => PipingFailureMechanismAssemblyFactory.GetSectionAssemblyCategoryGroup(
- sectionResult, assessmentSection.Piping, assessmentSection);
+ return (sectionResult, assessmentSection, useManual) => PipingFailureMechanismAssemblyFactory.GetSectionAssemblyCategoryGroup(
+ sectionResult, assessmentSection.Piping, assessmentSection, useManual);
}
}
- private static Func GrassCoverErosionInwardsAssemblyFunc
+ private static Func GrassCoverErosionInwardsAssemblyFunc
{
get
{
- return (sectionResult, assessmentSection) => GrassCoverErosionInwardsFailureMechanismAssemblyFactory.GetSectionAssemblyCategoryGroup(
- sectionResult, assessmentSection.GrassCoverErosionInwards, assessmentSection);
+ return (sectionResult, assessmentSection, useManual) => GrassCoverErosionInwardsFailureMechanismAssemblyFactory.GetSectionAssemblyCategoryGroup(
+ sectionResult, assessmentSection.GrassCoverErosionInwards, assessmentSection, useManual);
}
}
- private static Func MacroStabilityInwardsAssemblyFunc
+ private static Func MacroStabilityInwardsAssemblyFunc
{
get
{
- return (sectionResult, assessmentSection) => MacroStabilityInwardsFailureMechanismAssemblyFactory.GetSectionAssemblyCategoryGroup(
- sectionResult, assessmentSection.MacroStabilityInwards, assessmentSection);
+ return (sectionResult, assessmentSection, useManual) => MacroStabilityInwardsFailureMechanismAssemblyFactory.GetSectionAssemblyCategoryGroup(
+ sectionResult, assessmentSection.MacroStabilityInwards, assessmentSection, useManual);
}
}
- private static Func MacroStabilityOutwardsAssemblyFunc
+ private static Func MacroStabilityOutwardsAssemblyFunc
{
get
{
- return (sectionResult, assessmentSection) => MacroStabilityOutwardsFailureMechanismAssemblyFactory.GetSectionAssemblyCategoryGroup(
- sectionResult, assessmentSection.MacroStabilityOutwards, assessmentSection);
+ return (sectionResult, assessmentSection, useManual) => MacroStabilityOutwardsFailureMechanismAssemblyFactory.GetSectionAssemblyCategoryGroup(
+ sectionResult, assessmentSection.MacroStabilityOutwards, assessmentSection, useManual);
}
}
- private static Func MicrostabilityAssemblyFunc
+ private static Func MicrostabilityAssemblyFunc
{
get
{
return MicrostabilityFailureMechanismAssemblyFactory.GetSectionAssemblyCategoryGroup;
}
}
- private static Func StabilityStoneCoverAssemblyFunc
+ private static Func StabilityStoneCoverAssemblyFunc
{
get
{
return StabilityStoneCoverFailureMechanismAssemblyFactory.GetSectionAssemblyCategoryGroup;
}
}
- private static Func WaveImpactAsphaltCoverAssemblyFunc
+ private static Func WaveImpactAsphaltCoverAssemblyFunc
{
get
{
return WaveImpactAsphaltCoverFailureMechanismAssemblyFactory.GetSectionAssemblyCategoryGroup;
}
}
- private static Func WaterPressureAsphaltCoverAssemblyFunc
+ private static Func WaterPressureAsphaltCoverAssemblyFunc
{
get
{
return WaterPressureAsphaltCoverFailureMechanismAssemblyFactory.GetSectionAssemblyCategoryGroup;
}
}
- private static Func GrassCoverErosionOutwardsAssemblyFunc
+ private static Func GrassCoverErosionOutwardsAssemblyFunc
{
get
{
return GrassCoverErosionOutwardsFailureMechanismAssemblyFactory.GetSectionAssemblyCategoryGroup;
}
}
- private static Func GrassCoverSlipOffOutwardsAssemblyFunc
+ private static Func GrassCoverSlipOffOutwardsAssemblyFunc
{
get
{
return GrassCoverSlipOffOutwardsFailureMechanismAssemblyFactory.GetSectionAssemblyCategoryGroup;
}
}
- private static Func GrassCoverSlipOffInwardsAssemblyFunc
+ private static Func GrassCoverSlipOffInwardsAssemblyFunc
{
get
{
return GrassCoverSlipOffInwardsFailureMechanismAssemblyFactory.GetSectionAssemblyCategoryGroup;
}
}
- private static Func HeightStructuresAssemblyFunc
+ private static Func HeightStructuresAssemblyFunc
{
get
{
- return (sectionResult, assessmentSection) => HeightStructuresFailureMechanismAssemblyFactory.GetSectionAssemblyCategoryGroup(
- sectionResult, assessmentSection.HeightStructures, assessmentSection);
+ return (sectionResult, assessmentSection, useManual) => HeightStructuresFailureMechanismAssemblyFactory.GetSectionAssemblyCategoryGroup(
+ sectionResult, assessmentSection.HeightStructures, assessmentSection, useManual);
}
}
- private static Func ClosingStructuresAssemblyFunc
+ private static Func ClosingStructuresAssemblyFunc
{
get
{
- return (sectionResult, assessmentSection) => ClosingStructuresFailureMechanismAssemblyFactory.GetSectionAssemblyCategoryGroup(
- sectionResult, assessmentSection.ClosingStructures, assessmentSection);
+ return (sectionResult, assessmentSection, useManual) => ClosingStructuresFailureMechanismAssemblyFactory.GetSectionAssemblyCategoryGroup(
+ sectionResult, assessmentSection.ClosingStructures, assessmentSection, useManual);
}
}
- private static Func PipingStructureAssemblyFunc
+ private static Func PipingStructureAssemblyFunc
{
get
{
return PipingStructureFailureMechanismAssemblyFactory.GetSectionAssemblyCategoryGroup;
}
}
- private static Func StabilityPointStructuresAssemblyFunc
+ private static Func StabilityPointStructuresAssemblyFunc
{
get
{
- return (sectionResult, assessmentSection) => StabilityPointStructuresFailureMechanismAssemblyFactory.GetSectionAssemblyCategoryGroup(
- sectionResult, assessmentSection.StabilityPointStructures, assessmentSection);
+ return (sectionResult, assessmentSection, useManual) => StabilityPointStructuresFailureMechanismAssemblyFactory.GetSectionAssemblyCategoryGroup(
+ sectionResult, assessmentSection.StabilityPointStructures, assessmentSection, useManual);
}
}
- private static Func StrengthStabilityLengthwiseConstructionAssemblyFunc
+ private static Func StrengthStabilityLengthwiseConstructionAssemblyFunc
{
get
{
return StrengthStabilityLengthwiseConstructionFailureMechanismAssemblyFactory.GetSectionAssemblyCategoryGroup;
}
}
- private static Func DuneErosionAssemblyFunc
+ private static Func DuneErosionAssemblyFunc
{
get
{
return DuneErosionFailureMechanismAssemblyFactory.GetSectionAssemblyCategoryGroup;
}
}
- private static Func TechnicalInnovationAssemblyFunc
+ private static Func TechnicalInnovationAssemblyFunc
{
get
{
Index: Ringtoets/Integration/test/Ringtoets.Integration.Data.Test/Assembly/CombinedAssemblyFailureMechanismSectionFactoryTest.cs
===================================================================
diff -u -ra90ecfec7dc128234360d4a55ee646928c133b75 -r8eaa7df3b7a3e67d1fa4ae26fe4f17a8e25ec0b4
--- Ringtoets/Integration/test/Ringtoets.Integration.Data.Test/Assembly/CombinedAssemblyFailureMechanismSectionFactoryTest.cs (.../CombinedAssemblyFailureMechanismSectionFactoryTest.cs) (revision a90ecfec7dc128234360d4a55ee646928c133b75)
+++ Ringtoets/Integration/test/Ringtoets.Integration.Data.Test/Assembly/CombinedAssemblyFailureMechanismSectionFactoryTest.cs (.../CombinedAssemblyFailureMechanismSectionFactoryTest.cs) (revision 8eaa7df3b7a3e67d1fa4ae26fe4f17a8e25ec0b4)
@@ -26,11 +26,28 @@
using Core.Common.Util.Extensions;
using NUnit.Framework;
using Ringtoets.AssemblyTool.Data;
+using Ringtoets.AssemblyTool.KernelWrapper.Calculators;
using Ringtoets.AssemblyTool.KernelWrapper.TestUtil.Calculators;
+using Ringtoets.AssemblyTool.KernelWrapper.TestUtil.Calculators.Assembly;
+using Ringtoets.ClosingStructures.Data;
+using Ringtoets.Common.Data.AssemblyTool;
using Ringtoets.Common.Data.AssessmentSection;
using Ringtoets.Common.Data.FailureMechanism;
+using Ringtoets.Common.Data.TestUtil;
+using Ringtoets.Common.Primitives;
+using Ringtoets.DuneErosion.Data;
+using Ringtoets.GrassCoverErosionInwards.Data;
+using Ringtoets.GrassCoverErosionOutwards.Data;
+using Ringtoets.HeightStructures.Data;
using Ringtoets.Integration.Data.Assembly;
+using Ringtoets.Integration.Data.StandAlone;
+using Ringtoets.Integration.Data.StandAlone.SectionResults;
using Ringtoets.Integration.TestUtil;
+using Ringtoets.MacroStabilityInwards.Data;
+using Ringtoets.Piping.Data;
+using Ringtoets.StabilityPointStructures.Data;
+using Ringtoets.StabilityStoneCover.Data;
+using Ringtoets.WaveImpactAsphaltCover.Data;
namespace Ringtoets.Integration.Data.Test.Assembly
{
@@ -41,7 +58,9 @@
public void CreateInput_AssessmentSectionNull_ThrowsArgumentNullException()
{
// Call
- TestDelegate call = () => CombinedAssemblyFailureMechanismSectionFactory.CreateInput(null, Enumerable.Empty());
+ TestDelegate call = () => CombinedAssemblyFailureMechanismSectionFactory.CreateInput(null,
+ Enumerable.Empty(),
+ new Random(39).NextBoolean());
// Assert
var exception = Assert.Throws(call);
@@ -55,7 +74,9 @@
var assessmentSection = new AssessmentSection(new Random(21).NextEnumValue());
// Call
- TestDelegate call = () => CombinedAssemblyFailureMechanismSectionFactory.CreateInput(assessmentSection, null);
+ TestDelegate call = () => CombinedAssemblyFailureMechanismSectionFactory.CreateInput(assessmentSection,
+ null,
+ new Random(39).NextBoolean());
// Assert
var exception = Assert.Throws(call);
@@ -73,7 +94,7 @@
{
// Call
IEnumerable> inputs = CombinedAssemblyFailureMechanismSectionFactory.CreateInput(
- assessmentSection, assessmentSection.GetFailureMechanisms());
+ assessmentSection, assessmentSection.GetFailureMechanisms(), new Random(39).NextBoolean());
// Assert
Assert.AreEqual(18, inputs.Count());
@@ -112,7 +133,7 @@
assessmentSection, new[]
{
relevantFailureMechanism
- });
+ }, new Random(39).NextBoolean());
// Assert
AssertSections(((IHasSectionResults) relevantFailureMechanism).SectionResults, inputs.Single());
@@ -172,5 +193,1121 @@
Assert.AreEqual(FailureMechanismSectionAssemblyCategoryGroup.VIv, inputSections.ElementAt(i).CategoryGroup);
}
}
+
+ #region Manual Assembly
+
+ #region Piping
+
+ [Test]
+ public void GivenPipingFailureMechanismAndManualAssemblyAndUseManualTrue_WhenCreatingInput_ThenManualAssemblyUsed()
+ {
+ // Given
+ var random = new Random(21);
+ var assessmentSection = new AssessmentSection(random.NextEnumValue());
+ PipingFailureMechanism piping = assessmentSection.Piping;
+ FailureMechanismTestHelper.SetSections(piping, new[]
+ {
+ FailureMechanismSectionTestFactory.CreateFailureMechanismSection()
+ });
+ PipingFailureMechanismSectionResult sectionResult = piping.SectionResults.Single();
+ sectionResult.UseManualAssemblyProbability = true;
+ sectionResult.ManualAssemblyProbability = random.NextDouble();
+
+ using (new AssemblyToolCalculatorFactoryConfig())
+ {
+ // When
+ CombinedAssemblyFailureMechanismSectionFactory.CreateInput(assessmentSection, new[]
+ {
+ assessmentSection.Piping
+ }, true);
+
+ // Then
+ var calculatorFactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance;
+ FailureMechanismSectionAssemblyCalculatorStub sectionCalculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator;
+ Assert.AreEqual(sectionResult.ManualAssemblyProbability, sectionCalculator.ManualAssemblyProbabilityInput);
+ }
+ }
+
+ [Test]
+ public void GivenPipingFailureMechanismAndManualAssemblyAndUseManualFalse_WhenCreatingInput_ThenManualAssemblyIgnored()
+ {
+ // Given
+ var random = new Random(21);
+ var assessmentSection = new AssessmentSection(random.NextEnumValue());
+ PipingFailureMechanism piping = assessmentSection.Piping;
+ FailureMechanismTestHelper.SetSections(piping, new[]
+ {
+ FailureMechanismSectionTestFactory.CreateFailureMechanismSection()
+ });
+ PipingFailureMechanismSectionResult sectionResult = piping.SectionResults.Single();
+ sectionResult.UseManualAssemblyProbability = true;
+ sectionResult.ManualAssemblyProbability = random.NextDouble();
+
+ using (new AssemblyToolCalculatorFactoryConfig())
+ {
+ // When
+ CombinedAssemblyFailureMechanismSectionFactory.CreateInput(assessmentSection, new[]
+ {
+ assessmentSection.Piping
+ }, false);
+
+ // Then
+ var calculatorFactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance;
+ FailureMechanismSectionAssemblyCalculatorStub sectionCalculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator;
+ Assert.Zero(sectionCalculator.ManualAssemblyProbabilityInput);
+ }
+ }
+
+ #endregion
+
+ #region GrassCoverErosionInwards
+
+ [Test]
+ public void GivenGrassCoverErosionInwardsFailureMechanismAndManualAssemblyAndUseManualTrue_WhenCreatingInput_ThenManualAssemblyUsed()
+ {
+ // Given
+ var random = new Random(21);
+ var assessmentSection = new AssessmentSection(random.NextEnumValue());
+ GrassCoverErosionInwardsFailureMechanism failureMechanism = assessmentSection.GrassCoverErosionInwards;
+ FailureMechanismTestHelper.SetSections(failureMechanism, new[]
+ {
+ FailureMechanismSectionTestFactory.CreateFailureMechanismSection()
+ });
+ GrassCoverErosionInwardsFailureMechanismSectionResult sectionResult = failureMechanism.SectionResults.Single();
+ sectionResult.UseManualAssemblyProbability = true;
+ sectionResult.ManualAssemblyProbability = random.NextDouble();
+
+ using (new AssemblyToolCalculatorFactoryConfig())
+ {
+ // When
+ CombinedAssemblyFailureMechanismSectionFactory.CreateInput(assessmentSection, new[]
+ {
+ assessmentSection.GrassCoverErosionInwards
+ }, true);
+
+ // Then
+ var calculatorFactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance;
+ FailureMechanismSectionAssemblyCalculatorStub sectionCalculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator;
+ Assert.AreEqual(sectionResult.ManualAssemblyProbability, sectionCalculator.ManualAssemblyProbabilityInput);
+ }
+ }
+
+ [Test]
+ public void GivenGrassCoverErosionInwardsFailureMechanismAndManualAssemblyAndUseManualFalse_WhenCreatingInput_ThenManualAssemblyIgnored()
+ {
+ // Given
+ var random = new Random(21);
+ var assessmentSection = new AssessmentSection(random.NextEnumValue());
+ GrassCoverErosionInwardsFailureMechanism failureMechanism = assessmentSection.GrassCoverErosionInwards;
+ FailureMechanismTestHelper.SetSections(failureMechanism, new[]
+ {
+ FailureMechanismSectionTestFactory.CreateFailureMechanismSection()
+ });
+ GrassCoverErosionInwardsFailureMechanismSectionResult sectionResult = failureMechanism.SectionResults.Single();
+ sectionResult.UseManualAssemblyProbability = true;
+ sectionResult.ManualAssemblyProbability = random.NextDouble();
+
+ using (new AssemblyToolCalculatorFactoryConfig())
+ {
+ // When
+ CombinedAssemblyFailureMechanismSectionFactory.CreateInput(assessmentSection, new[]
+ {
+ assessmentSection.GrassCoverErosionInwards
+ }, false);
+
+ // Then
+ var calculatorFactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance;
+ FailureMechanismSectionAssemblyCalculatorStub sectionCalculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator;
+ Assert.Zero(sectionCalculator.ManualAssemblyProbabilityInput);
+ }
+ }
+
+ #endregion
+
+ #region MacroStabilityInwards
+
+ [Test]
+ public void GivenMacroStabilityInwardsFailureMechanismAndManualAssemblyAndUseManualTrue_WhenCreatingInput_ThenManualAssemblyUsed()
+ {
+ // Given
+ var random = new Random(21);
+ var assessmentSection = new AssessmentSection(random.NextEnumValue());
+ MacroStabilityInwardsFailureMechanism failureMechanism = assessmentSection.MacroStabilityInwards;
+ FailureMechanismTestHelper.SetSections(failureMechanism, new[]
+ {
+ FailureMechanismSectionTestFactory.CreateFailureMechanismSection()
+ });
+ MacroStabilityInwardsFailureMechanismSectionResult sectionResult = failureMechanism.SectionResults.Single();
+ sectionResult.UseManualAssemblyProbability = true;
+ sectionResult.ManualAssemblyProbability = random.NextDouble();
+
+ using (new AssemblyToolCalculatorFactoryConfig())
+ {
+ // When
+ CombinedAssemblyFailureMechanismSectionFactory.CreateInput(assessmentSection, new[]
+ {
+ assessmentSection.MacroStabilityInwards
+ }, true);
+
+ // Then
+ var calculatorFactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance;
+ FailureMechanismSectionAssemblyCalculatorStub sectionCalculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator;
+ Assert.AreEqual(sectionResult.ManualAssemblyProbability, sectionCalculator.ManualAssemblyProbabilityInput);
+ }
+ }
+
+ [Test]
+ public void GivenMacroStabilityInwardsFailureMechanismAndManualAssemblyAndUseManualFalse_WhenCreatingInput_ThenManualAssemblyIgnored()
+ {
+ // Given
+ var random = new Random(21);
+ var assessmentSection = new AssessmentSection(random.NextEnumValue());
+ MacroStabilityInwardsFailureMechanism failureMechanism = assessmentSection.MacroStabilityInwards;
+ FailureMechanismTestHelper.SetSections(failureMechanism, new[]
+ {
+ FailureMechanismSectionTestFactory.CreateFailureMechanismSection()
+ });
+ MacroStabilityInwardsFailureMechanismSectionResult sectionResult = failureMechanism.SectionResults.Single();
+ sectionResult.UseManualAssemblyProbability = true;
+ sectionResult.ManualAssemblyProbability = random.NextDouble();
+
+ using (new AssemblyToolCalculatorFactoryConfig())
+ {
+ // When
+ CombinedAssemblyFailureMechanismSectionFactory.CreateInput(assessmentSection, new[]
+ {
+ assessmentSection.MacroStabilityInwards
+ }, false);
+
+ // Then
+ var calculatorFactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance;
+ FailureMechanismSectionAssemblyCalculatorStub sectionCalculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator;
+ Assert.Zero(sectionCalculator.ManualAssemblyProbabilityInput);
+ }
+ }
+
+ #endregion
+
+ #region HeightStructures
+
+ [Test]
+ public void GivenHeightStructuresFailureMechanismAndManualAssemblyAndUseManualTrue_WhenCreatingInput_ThenManualAssemblyUsed()
+ {
+ // Given
+ var random = new Random(21);
+ var assessmentSection = new AssessmentSection(random.NextEnumValue());
+ HeightStructuresFailureMechanism failureMechanism = assessmentSection.HeightStructures;
+ FailureMechanismTestHelper.SetSections(failureMechanism, new[]
+ {
+ FailureMechanismSectionTestFactory.CreateFailureMechanismSection()
+ });
+ HeightStructuresFailureMechanismSectionResult sectionResult = failureMechanism.SectionResults.Single();
+ sectionResult.UseManualAssemblyProbability = true;
+ sectionResult.ManualAssemblyProbability = random.NextDouble();
+
+ using (new AssemblyToolCalculatorFactoryConfig())
+ {
+ // When
+ CombinedAssemblyFailureMechanismSectionFactory.CreateInput(assessmentSection, new[]
+ {
+ assessmentSection.HeightStructures
+ }, true);
+
+ // Then
+ var calculatorFactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance;
+ FailureMechanismSectionAssemblyCalculatorStub sectionCalculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator;
+ Assert.AreEqual(sectionResult.ManualAssemblyProbability, sectionCalculator.ManualAssemblyProbabilityInput);
+ }
+ }
+
+ [Test]
+ public void GivenHeightStructuresFailureMechanismAndManualAssemblyAndUseManualFalse_WhenCreatingInput_ThenManualAssemblyIgnored()
+ {
+ // Given
+ var random = new Random(21);
+ var assessmentSection = new AssessmentSection(random.NextEnumValue());
+ HeightStructuresFailureMechanism failureMechanism = assessmentSection.HeightStructures;
+ FailureMechanismTestHelper.SetSections(failureMechanism, new[]
+ {
+ FailureMechanismSectionTestFactory.CreateFailureMechanismSection()
+ });
+ HeightStructuresFailureMechanismSectionResult sectionResult = failureMechanism.SectionResults.Single();
+ sectionResult.UseManualAssemblyProbability = true;
+ sectionResult.ManualAssemblyProbability = random.NextDouble();
+
+ using (new AssemblyToolCalculatorFactoryConfig())
+ {
+ // When
+ CombinedAssemblyFailureMechanismSectionFactory.CreateInput(assessmentSection, new[]
+ {
+ assessmentSection.HeightStructures
+ }, false);
+
+ // Then
+ var calculatorFactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance;
+ FailureMechanismSectionAssemblyCalculatorStub sectionCalculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator;
+ Assert.Zero(sectionCalculator.ManualAssemblyProbabilityInput);
+ }
+ }
+
+ #endregion
+
+ #region ClosingStructures
+
+ [Test]
+ public void GivenClosingStructuresFailureMechanismAndManualAssemblyAndUseManualTrue_WhenCreatingInput_ThenManualAssemblyUsed()
+ {
+ // Given
+ var random = new Random(21);
+ var assessmentSection = new AssessmentSection(random.NextEnumValue());
+ ClosingStructuresFailureMechanism failureMechanism = assessmentSection.ClosingStructures;
+ FailureMechanismTestHelper.SetSections(failureMechanism, new[]
+ {
+ FailureMechanismSectionTestFactory.CreateFailureMechanismSection()
+ });
+ ClosingStructuresFailureMechanismSectionResult sectionResult = failureMechanism.SectionResults.Single();
+ sectionResult.UseManualAssemblyProbability = true;
+ sectionResult.ManualAssemblyProbability = random.NextDouble();
+
+ using (new AssemblyToolCalculatorFactoryConfig())
+ {
+ // When
+ CombinedAssemblyFailureMechanismSectionFactory.CreateInput(assessmentSection, new[]
+ {
+ assessmentSection.ClosingStructures
+ }, true);
+
+ // Then
+ var calculatorFactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance;
+ FailureMechanismSectionAssemblyCalculatorStub sectionCalculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator;
+ Assert.AreEqual(sectionResult.ManualAssemblyProbability, sectionCalculator.ManualAssemblyProbabilityInput);
+ }
+ }
+
+ [Test]
+ public void GivenClosingStructuresFailureMechanismAndManualAssemblyAndUseManualFalse_WhenCreatingInput_ThenManualAssemblyIgnored()
+ {
+ // Given
+ var random = new Random(21);
+ var assessmentSection = new AssessmentSection(random.NextEnumValue());
+ ClosingStructuresFailureMechanism failureMechanism = assessmentSection.ClosingStructures;
+ FailureMechanismTestHelper.SetSections(failureMechanism, new[]
+ {
+ FailureMechanismSectionTestFactory.CreateFailureMechanismSection()
+ });
+ ClosingStructuresFailureMechanismSectionResult sectionResult = failureMechanism.SectionResults.Single();
+ sectionResult.UseManualAssemblyProbability = true;
+ sectionResult.ManualAssemblyProbability = random.NextDouble();
+
+ using (new AssemblyToolCalculatorFactoryConfig())
+ {
+ // When
+ CombinedAssemblyFailureMechanismSectionFactory.CreateInput(assessmentSection, new[]
+ {
+ assessmentSection.ClosingStructures
+ }, false);
+
+ // Then
+ var calculatorFactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance;
+ FailureMechanismSectionAssemblyCalculatorStub sectionCalculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator;
+ Assert.Zero(sectionCalculator.ManualAssemblyProbabilityInput);
+ }
+ }
+
+ #endregion
+
+ #region StabilityPointStructures
+
+ [Test]
+ public void GivenStabilityPointStructuresFailureMechanismAndManualAssemblyAndUseManualTrue_WhenCreatingInput_ThenManualAssemblyUsed()
+ {
+ // Given
+ var random = new Random(21);
+ var assessmentSection = new AssessmentSection(random.NextEnumValue());
+ StabilityPointStructuresFailureMechanism failureMechanism = assessmentSection.StabilityPointStructures;
+ FailureMechanismTestHelper.SetSections(failureMechanism, new[]
+ {
+ FailureMechanismSectionTestFactory.CreateFailureMechanismSection()
+ });
+ StabilityPointStructuresFailureMechanismSectionResult sectionResult = failureMechanism.SectionResults.Single();
+ sectionResult.UseManualAssemblyProbability = true;
+ sectionResult.ManualAssemblyProbability = random.NextDouble();
+
+ using (new AssemblyToolCalculatorFactoryConfig())
+ {
+ // When
+ CombinedAssemblyFailureMechanismSectionFactory.CreateInput(assessmentSection, new[]
+ {
+ assessmentSection.StabilityPointStructures
+ }, true);
+
+ // Then
+ var calculatorFactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance;
+ FailureMechanismSectionAssemblyCalculatorStub sectionCalculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator;
+ Assert.AreEqual(sectionResult.ManualAssemblyProbability, sectionCalculator.ManualAssemblyProbabilityInput);
+ }
+ }
+
+ [Test]
+ public void GivenStabilityPointStructuresFailureMechanismAndManualAssemblyAndUseManualFalse_WhenCreatingInput_ThenManualAssemblyIgnored()
+ {
+ // Given
+ var random = new Random(21);
+ var assessmentSection = new AssessmentSection(random.NextEnumValue());
+ StabilityPointStructuresFailureMechanism failureMechanism = assessmentSection.StabilityPointStructures;
+ FailureMechanismTestHelper.SetSections(failureMechanism, new[]
+ {
+ FailureMechanismSectionTestFactory.CreateFailureMechanismSection()
+ });
+ StabilityPointStructuresFailureMechanismSectionResult sectionResult = failureMechanism.SectionResults.Single();
+ sectionResult.UseManualAssemblyProbability = true;
+ sectionResult.ManualAssemblyProbability = random.NextDouble();
+
+ using (new AssemblyToolCalculatorFactoryConfig())
+ {
+ // When
+ CombinedAssemblyFailureMechanismSectionFactory.CreateInput(assessmentSection, new[]
+ {
+ assessmentSection.StabilityPointStructures
+ }, false);
+
+ // Then
+ var calculatorFactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance;
+ FailureMechanismSectionAssemblyCalculatorStub sectionCalculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator;
+ Assert.Zero(sectionCalculator.ManualAssemblyProbabilityInput);
+ }
+ }
+
+ #endregion
+
+ #region GrassCoverErosionOutwards
+
+ [Test]
+ public void GivenGrassCoverErosionOutwardsFailureMechanismAndManualAssemblyAndUseManualTrue_WhenCreatingInput_ThenManualAssemblyUsed()
+ {
+ // Given
+ var random = new Random(21);
+ var assessmentSection = new AssessmentSection(random.NextEnumValue());
+ GrassCoverErosionOutwardsFailureMechanism failureMechanism = assessmentSection.GrassCoverErosionOutwards;
+ FailureMechanismTestHelper.SetSections(failureMechanism, new[]
+ {
+ FailureMechanismSectionTestFactory.CreateFailureMechanismSection()
+ });
+ GrassCoverErosionOutwardsFailureMechanismSectionResult sectionResult = failureMechanism.SectionResults.Single();
+ sectionResult.UseManualAssemblyCategoryGroup = true;
+ sectionResult.ManualAssemblyCategoryGroup = random.NextEnumValue();
+
+ using (new AssemblyToolCalculatorFactoryConfig())
+ {
+ // When
+ IEnumerable> input = CombinedAssemblyFailureMechanismSectionFactory.CreateInput(assessmentSection, new[]
+ {
+ assessmentSection.GrassCoverErosionOutwards
+ }, true);
+
+ // Then
+ Assert.AreEqual(sectionResult.ManualAssemblyCategoryGroup, input.Single().Single().CategoryGroup);
+ }
+ }
+
+ [Test]
+ public void GivenGrassCoverErosionOutwardsFailureMechanismAndManualAssemblyAndUseManualFalse_WhenCreatingInput_ThenManualAssemblyIgnored()
+ {
+ // Given
+ var random = new Random(21);
+ var assessmentSection = new AssessmentSection(random.NextEnumValue());
+ GrassCoverErosionOutwardsFailureMechanism failureMechanism = assessmentSection.GrassCoverErosionOutwards;
+ FailureMechanismTestHelper.SetSections(failureMechanism, new[]
+ {
+ FailureMechanismSectionTestFactory.CreateFailureMechanismSection()
+ });
+ GrassCoverErosionOutwardsFailureMechanismSectionResult sectionResult = failureMechanism.SectionResults.Single();
+ sectionResult.UseManualAssemblyCategoryGroup = true;
+ sectionResult.ManualAssemblyCategoryGroup = FailureMechanismSectionAssemblyCategoryGroup.IVv;
+
+ using (new AssemblyToolCalculatorFactoryConfig())
+ {
+ // When
+ IEnumerable> input = CombinedAssemblyFailureMechanismSectionFactory.CreateInput(assessmentSection, new[]
+ {
+ assessmentSection.GrassCoverErosionOutwards
+ }, false);
+
+ // Then
+ Assert.AreEqual(FailureMechanismSectionAssemblyCategoryGroup.Iv, input.Single().Single().CategoryGroup);
+ }
+ }
+
+ #endregion
+
+ #region StabilityStoneCover
+
+ [Test]
+ public void GivenStabilityStoneCoverFailureMechanismAndManualAssemblyAndUseManualTrue_WhenCreatingInput_ThenManualAssemblyUsed()
+ {
+ // Given
+ var random = new Random(21);
+ var assessmentSection = new AssessmentSection(random.NextEnumValue());
+ StabilityStoneCoverFailureMechanism failureMechanism = assessmentSection.StabilityStoneCover;
+ FailureMechanismTestHelper.SetSections(failureMechanism, new[]
+ {
+ FailureMechanismSectionTestFactory.CreateFailureMechanismSection()
+ });
+ StabilityStoneCoverFailureMechanismSectionResult sectionResult = failureMechanism.SectionResults.Single();
+ sectionResult.UseManualAssemblyCategoryGroup = true;
+ sectionResult.ManualAssemblyCategoryGroup = random.NextEnumValue();
+
+ using (new AssemblyToolCalculatorFactoryConfig())
+ {
+ // When
+ IEnumerable> input = CombinedAssemblyFailureMechanismSectionFactory.CreateInput(assessmentSection, new[]
+ {
+ assessmentSection.StabilityStoneCover
+ }, true);
+
+ // Then
+ Assert.AreEqual(sectionResult.ManualAssemblyCategoryGroup, input.Single().Single().CategoryGroup);
+ }
+ }
+
+ [Test]
+ public void GivenStabilityStoneCoverFailureMechanismAndManualAssemblyAndUseManualFalse_WhenCreatingInput_ThenManualAssemblyIgnored()
+ {
+ // Given
+ var random = new Random(21);
+ var assessmentSection = new AssessmentSection(random.NextEnumValue());
+ StabilityStoneCoverFailureMechanism failureMechanism = assessmentSection.StabilityStoneCover;
+ FailureMechanismTestHelper.SetSections(failureMechanism, new[]
+ {
+ FailureMechanismSectionTestFactory.CreateFailureMechanismSection()
+ });
+ StabilityStoneCoverFailureMechanismSectionResult sectionResult = failureMechanism.SectionResults.Single();
+ sectionResult.UseManualAssemblyCategoryGroup = true;
+ sectionResult.ManualAssemblyCategoryGroup = FailureMechanismSectionAssemblyCategoryGroup.IVv;
+
+ using (new AssemblyToolCalculatorFactoryConfig())
+ {
+ // When
+ IEnumerable> input = CombinedAssemblyFailureMechanismSectionFactory.CreateInput(assessmentSection, new[]
+ {
+ assessmentSection.StabilityStoneCover
+ }, false);
+
+ // Then
+ Assert.AreEqual(FailureMechanismSectionAssemblyCategoryGroup.Iv, input.Single().Single().CategoryGroup);
+ }
+ }
+
+ #endregion
+
+ #region WaveImpactAsphaltCover
+
+ [Test]
+ public void GivenWaveImpactAsphaltCoverFailureMechanismAndManualAssemblyAndUseManualTrue_WhenCreatingInput_ThenManualAssemblyUsed()
+ {
+ // Given
+ var random = new Random(21);
+ var assessmentSection = new AssessmentSection(random.NextEnumValue());
+ WaveImpactAsphaltCoverFailureMechanism failureMechanism = assessmentSection.WaveImpactAsphaltCover;
+ FailureMechanismTestHelper.SetSections(failureMechanism, new[]
+ {
+ FailureMechanismSectionTestFactory.CreateFailureMechanismSection()
+ });
+ WaveImpactAsphaltCoverFailureMechanismSectionResult sectionResult = failureMechanism.SectionResults.Single();
+ sectionResult.UseManualAssemblyCategoryGroup = true;
+ sectionResult.ManualAssemblyCategoryGroup = random.NextEnumValue();
+
+ using (new AssemblyToolCalculatorFactoryConfig())
+ {
+ // When
+ IEnumerable> input = CombinedAssemblyFailureMechanismSectionFactory.CreateInput(assessmentSection, new[]
+ {
+ assessmentSection.WaveImpactAsphaltCover
+ }, true);
+
+ // Then
+ Assert.AreEqual(sectionResult.ManualAssemblyCategoryGroup, input.Single().Single().CategoryGroup);
+ }
+ }
+
+ [Test]
+ public void GivenWaveImpactAsphaltCoverFailureMechanismAndManualAssemblyAndUseManualFalse_WhenCreatingInput_ThenManualAssemblyIgnored()
+ {
+ // Given
+ var random = new Random(21);
+ var assessmentSection = new AssessmentSection(random.NextEnumValue());
+ WaveImpactAsphaltCoverFailureMechanism failureMechanism = assessmentSection.WaveImpactAsphaltCover;
+ FailureMechanismTestHelper.SetSections(failureMechanism, new[]
+ {
+ FailureMechanismSectionTestFactory.CreateFailureMechanismSection()
+ });
+ WaveImpactAsphaltCoverFailureMechanismSectionResult sectionResult = failureMechanism.SectionResults.Single();
+ sectionResult.UseManualAssemblyCategoryGroup = true;
+ sectionResult.ManualAssemblyCategoryGroup = FailureMechanismSectionAssemblyCategoryGroup.IVv;
+
+ using (new AssemblyToolCalculatorFactoryConfig())
+ {
+ // When
+ IEnumerable> input = CombinedAssemblyFailureMechanismSectionFactory.CreateInput(assessmentSection, new[]
+ {
+ assessmentSection.WaveImpactAsphaltCover
+ }, false);
+
+ // Then
+ Assert.AreEqual(FailureMechanismSectionAssemblyCategoryGroup.Iv, input.Single().Single().CategoryGroup);
+ }
+ }
+
+ #endregion
+
+ #region DuneErosion
+
+ [Test]
+ public void GivenDuneErosionFailureMechanismAndManualAssemblyAndUseManualTrue_WhenCreatingInput_ThenManualAssemblyUsed()
+ {
+ // Given
+ var random = new Random(21);
+ var assessmentSection = new AssessmentSection(random.NextEnumValue());
+ DuneErosionFailureMechanism failureMechanism = assessmentSection.DuneErosion;
+ FailureMechanismTestHelper.SetSections(failureMechanism, new[]
+ {
+ FailureMechanismSectionTestFactory.CreateFailureMechanismSection()
+ });
+ DuneErosionFailureMechanismSectionResult sectionResult = failureMechanism.SectionResults.Single();
+ sectionResult.UseManualAssemblyCategoryGroup = true;
+ sectionResult.ManualAssemblyCategoryGroup = random.NextEnumValue();
+
+ using (new AssemblyToolCalculatorFactoryConfig())
+ {
+ // When
+ IEnumerable> input = CombinedAssemblyFailureMechanismSectionFactory.CreateInput(assessmentSection, new[]
+ {
+ assessmentSection.DuneErosion
+ }, true);
+
+ // Then
+ Assert.AreEqual(sectionResult.ManualAssemblyCategoryGroup, input.Single().Single().CategoryGroup);
+ }
+ }
+
+ [Test]
+ public void GivenDuneErosionFailureMechanismAndManualAssemblyAndUseManualFalse_WhenCreatingInput_ThenManualAssemblyIgnored()
+ {
+ // Given
+ var random = new Random(21);
+ var assessmentSection = new AssessmentSection(random.NextEnumValue());
+ DuneErosionFailureMechanism failureMechanism = assessmentSection.DuneErosion;
+ FailureMechanismTestHelper.SetSections(failureMechanism, new[]
+ {
+ FailureMechanismSectionTestFactory.CreateFailureMechanismSection()
+ });
+ DuneErosionFailureMechanismSectionResult sectionResult = failureMechanism.SectionResults.Single();
+ sectionResult.UseManualAssemblyCategoryGroup = true;
+ sectionResult.ManualAssemblyCategoryGroup = FailureMechanismSectionAssemblyCategoryGroup.IVv;
+
+ using (new AssemblyToolCalculatorFactoryConfig())
+ {
+ // When
+ IEnumerable> input = CombinedAssemblyFailureMechanismSectionFactory.CreateInput(assessmentSection, new[]
+ {
+ assessmentSection.DuneErosion
+ }, false);
+
+ // Then
+ Assert.AreEqual(FailureMechanismSectionAssemblyCategoryGroup.Iv, input.Single().Single().CategoryGroup);
+ }
+ }
+
+ #endregion
+
+ #region GrassCoverSlipOffInwards
+
+ [Test]
+ public void GivenGrassCoverSlipOffInwardsFailureMechanismAndManualAssemblyAndUseManualTrue_WhenCreatingInput_ThenManualAssemblyUsed()
+ {
+ // Given
+ var random = new Random(21);
+ var assessmentSection = new AssessmentSection(random.NextEnumValue());
+ GrassCoverSlipOffInwardsFailureMechanism failureMechanism = assessmentSection.GrassCoverSlipOffInwards;
+ FailureMechanismTestHelper.SetSections(failureMechanism, new[]
+ {
+ FailureMechanismSectionTestFactory.CreateFailureMechanismSection()
+ });
+ GrassCoverSlipOffInwardsFailureMechanismSectionResult sectionResult = failureMechanism.SectionResults.Single();
+ sectionResult.UseManualAssemblyCategoryGroup = true;
+ sectionResult.ManualAssemblyCategoryGroup = random.NextEnumValue();
+
+ using (new AssemblyToolCalculatorFactoryConfig())
+ {
+ // When
+ IEnumerable> input = CombinedAssemblyFailureMechanismSectionFactory.CreateInput(assessmentSection, new[]
+ {
+ assessmentSection.GrassCoverSlipOffInwards
+ }, true);
+
+ // Then
+ Assert.AreEqual(ManualFailureMechanismSectionAssemblyCategoryGroupConverter.Convert(sectionResult.ManualAssemblyCategoryGroup),
+ input.Single().Single().CategoryGroup);
+ }
+ }
+
+ [Test]
+ public void GivenGrassCoverSlipOffInwardsFailureMechanismAndManualAssemblyAndUseManualFalse_WhenCreatingInput_ThenManualAssemblyIgnored()
+ {
+ // Given
+ var random = new Random(21);
+ var assessmentSection = new AssessmentSection(random.NextEnumValue());
+ GrassCoverSlipOffInwardsFailureMechanism failureMechanism = assessmentSection.GrassCoverSlipOffInwards;
+ FailureMechanismTestHelper.SetSections(failureMechanism, new[]
+ {
+ FailureMechanismSectionTestFactory.CreateFailureMechanismSection()
+ });
+ GrassCoverSlipOffInwardsFailureMechanismSectionResult sectionResult = failureMechanism.SectionResults.Single();
+ sectionResult.UseManualAssemblyCategoryGroup = true;
+ sectionResult.ManualAssemblyCategoryGroup = ManualFailureMechanismSectionAssemblyCategoryGroup.Iv;
+
+ using (new AssemblyToolCalculatorFactoryConfig())
+ {
+ // When
+ IEnumerable> input = CombinedAssemblyFailureMechanismSectionFactory.CreateInput(assessmentSection, new[]
+ {
+ assessmentSection.GrassCoverSlipOffInwards
+ }, false);
+
+ // Then
+ Assert.AreEqual(FailureMechanismSectionAssemblyCategoryGroup.IIv, input.Single().Single().CategoryGroup);
+ }
+ }
+
+ #endregion
+
+ #region GrassCoverSlipOffOutwards
+
+ [Test]
+ public void GivenGrassCoverSlipOffOutwardsFailureMechanismAndManualAssemblyAndUseManualTrue_WhenCreatingInput_ThenManualAssemblyUsed()
+ {
+ // Given
+ var random = new Random(21);
+ var assessmentSection = new AssessmentSection(random.NextEnumValue());
+ GrassCoverSlipOffOutwardsFailureMechanism failureMechanism = assessmentSection.GrassCoverSlipOffOutwards;
+ FailureMechanismTestHelper.SetSections(failureMechanism, new[]
+ {
+ FailureMechanismSectionTestFactory.CreateFailureMechanismSection()
+ });
+ GrassCoverSlipOffOutwardsFailureMechanismSectionResult sectionResult = failureMechanism.SectionResults.Single();
+ sectionResult.UseManualAssemblyCategoryGroup = true;
+ sectionResult.ManualAssemblyCategoryGroup = random.NextEnumValue();
+
+ using (new AssemblyToolCalculatorFactoryConfig())
+ {
+ // When
+ IEnumerable> input = CombinedAssemblyFailureMechanismSectionFactory.CreateInput(assessmentSection, new[]
+ {
+ assessmentSection.GrassCoverSlipOffOutwards
+ }, true);
+
+ // Then
+ Assert.AreEqual(ManualFailureMechanismSectionAssemblyCategoryGroupConverter.Convert(sectionResult.ManualAssemblyCategoryGroup),
+ input.Single().Single().CategoryGroup);
+ }
+ }
+
+ [Test]
+ public void GivenGrassCoverSlipOffOutwardsFailureMechanismAndManualAssemblyAndUseManualFalse_WhenCreatingInput_ThenManualAssemblyIgnored()
+ {
+ // Given
+ var random = new Random(21);
+ var assessmentSection = new AssessmentSection(random.NextEnumValue());
+ GrassCoverSlipOffOutwardsFailureMechanism failureMechanism = assessmentSection.GrassCoverSlipOffOutwards;
+ FailureMechanismTestHelper.SetSections(failureMechanism, new[]
+ {
+ FailureMechanismSectionTestFactory.CreateFailureMechanismSection()
+ });
+ GrassCoverSlipOffOutwardsFailureMechanismSectionResult sectionResult = failureMechanism.SectionResults.Single();
+ sectionResult.UseManualAssemblyCategoryGroup = true;
+ sectionResult.ManualAssemblyCategoryGroup = ManualFailureMechanismSectionAssemblyCategoryGroup.Iv;
+
+ using (new AssemblyToolCalculatorFactoryConfig())
+ {
+ // When
+ IEnumerable> input = CombinedAssemblyFailureMechanismSectionFactory.CreateInput(assessmentSection, new[]
+ {
+ assessmentSection.GrassCoverSlipOffOutwards
+ }, false);
+
+ // Then
+ Assert.AreEqual(FailureMechanismSectionAssemblyCategoryGroup.IIv, input.Single().Single().CategoryGroup);
+ }
+ }
+
+ #endregion
+
+ #region Microstability
+
+ [Test]
+ public void GivenMicrostabilityFailureMechanismAndManualAssemblyAndUseManualTrue_WhenCreatingInput_ThenManualAssemblyUsed()
+ {
+ // Given
+ var random = new Random(21);
+ var assessmentSection = new AssessmentSection(random.NextEnumValue());
+ MicrostabilityFailureMechanism failureMechanism = assessmentSection.Microstability;
+ FailureMechanismTestHelper.SetSections(failureMechanism, new[]
+ {
+ FailureMechanismSectionTestFactory.CreateFailureMechanismSection()
+ });
+ MicrostabilityFailureMechanismSectionResult sectionResult = failureMechanism.SectionResults.Single();
+ sectionResult.UseManualAssemblyCategoryGroup = true;
+ sectionResult.ManualAssemblyCategoryGroup = random.NextEnumValue();
+
+ using (new AssemblyToolCalculatorFactoryConfig())
+ {
+ // When
+ IEnumerable> input = CombinedAssemblyFailureMechanismSectionFactory.CreateInput(assessmentSection, new[]
+ {
+ assessmentSection.Microstability
+ }, true);
+
+ // Then
+ Assert.AreEqual(ManualFailureMechanismSectionAssemblyCategoryGroupConverter.Convert(sectionResult.ManualAssemblyCategoryGroup),
+ input.Single().Single().CategoryGroup);
+ }
+ }
+
+ [Test]
+ public void GivenMicrostabilityFailureMechanismAndManualAssemblyAndUseManualFalse_WhenCreatingInput_ThenManualAssemblyIgnored()
+ {
+ // Given
+ var random = new Random(21);
+ var assessmentSection = new AssessmentSection(random.NextEnumValue());
+ MicrostabilityFailureMechanism failureMechanism = assessmentSection.Microstability;
+ FailureMechanismTestHelper.SetSections(failureMechanism, new[]
+ {
+ FailureMechanismSectionTestFactory.CreateFailureMechanismSection()
+ });
+ MicrostabilityFailureMechanismSectionResult sectionResult = failureMechanism.SectionResults.Single();
+ sectionResult.UseManualAssemblyCategoryGroup = true;
+ sectionResult.ManualAssemblyCategoryGroup = ManualFailureMechanismSectionAssemblyCategoryGroup.Iv;
+
+ using (new AssemblyToolCalculatorFactoryConfig())
+ {
+ // When
+ IEnumerable> input = CombinedAssemblyFailureMechanismSectionFactory.CreateInput(assessmentSection, new[]
+ {
+ assessmentSection.Microstability
+ }, false);
+
+ // Then
+ Assert.AreEqual(FailureMechanismSectionAssemblyCategoryGroup.IIv, input.Single().Single().CategoryGroup);
+ }
+ }
+
+ #endregion
+
+ #region MacroStabilityOutwards
+
+ [Test]
+ public void GivenMacroStabilityOutwardsFailureMechanismAndManualAssemblyAndUseManualTrue_WhenCreatingInput_ThenManualAssemblyUsed()
+ {
+ // Given
+ var random = new Random(21);
+ var assessmentSection = new AssessmentSection(random.NextEnumValue());
+ MacroStabilityOutwardsFailureMechanism failureMechanism = assessmentSection.MacroStabilityOutwards;
+ FailureMechanismTestHelper.SetSections(failureMechanism, new[]
+ {
+ FailureMechanismSectionTestFactory.CreateFailureMechanismSection()
+ });
+ MacroStabilityOutwardsFailureMechanismSectionResult sectionResult = failureMechanism.SectionResults.Single();
+ sectionResult.UseManualAssemblyCategoryGroup = true;
+ sectionResult.ManualAssemblyCategoryGroup = random.NextEnumValue();
+
+ using (new AssemblyToolCalculatorFactoryConfig())
+ {
+ // When
+ IEnumerable> input = CombinedAssemblyFailureMechanismSectionFactory.CreateInput(assessmentSection, new[]
+ {
+ assessmentSection.MacroStabilityOutwards
+ }, true);
+
+ // Then
+ Assert.AreEqual(ManualFailureMechanismSectionAssemblyCategoryGroupConverter.Convert(sectionResult.ManualAssemblyCategoryGroup),
+ input.Single().Single().CategoryGroup);
+ }
+ }
+
+ [Test]
+ public void GivenMacroStabilityOutwardsFailureMechanismAndManualAssemblyAndUseManualFalse_WhenCreatingInput_ThenManualAssemblyIgnored()
+ {
+ // Given
+ var random = new Random(21);
+ var assessmentSection = new AssessmentSection(random.NextEnumValue());
+ MacroStabilityOutwardsFailureMechanism failureMechanism = assessmentSection.MacroStabilityOutwards;
+ FailureMechanismTestHelper.SetSections(failureMechanism, new[]
+ {
+ FailureMechanismSectionTestFactory.CreateFailureMechanismSection()
+ });
+ MacroStabilityOutwardsFailureMechanismSectionResult sectionResult = failureMechanism.SectionResults.Single();
+ sectionResult.UseManualAssemblyCategoryGroup = true;
+ sectionResult.ManualAssemblyCategoryGroup = ManualFailureMechanismSectionAssemblyCategoryGroup.Iv;
+
+ using (new AssemblyToolCalculatorFactoryConfig())
+ {
+ // When
+ IEnumerable> input = CombinedAssemblyFailureMechanismSectionFactory.CreateInput(assessmentSection, new[]
+ {
+ assessmentSection.MacroStabilityOutwards
+ }, false);
+
+ // Then
+ Assert.AreEqual(FailureMechanismSectionAssemblyCategoryGroup.VIv, input.Single().Single().CategoryGroup);
+ }
+ }
+
+ #endregion
+
+ #region PipingStructure
+
+ [Test]
+ public void GivenPipingStructureFailureMechanismAndManualAssemblyAndUseManualTrue_WhenCreatingInput_ThenManualAssemblyUsed()
+ {
+ // Given
+ var random = new Random(21);
+ var assessmentSection = new AssessmentSection(random.NextEnumValue());
+ PipingStructureFailureMechanism failureMechanism = assessmentSection.PipingStructure;
+ FailureMechanismTestHelper.SetSections(failureMechanism, new[]
+ {
+ FailureMechanismSectionTestFactory.CreateFailureMechanismSection()
+ });
+ PipingStructureFailureMechanismSectionResult sectionResult = failureMechanism.SectionResults.Single();
+ sectionResult.UseManualAssemblyCategoryGroup = true;
+ sectionResult.ManualAssemblyCategoryGroup = random.NextEnumValue();
+
+ using (new AssemblyToolCalculatorFactoryConfig())
+ {
+ // When
+ IEnumerable> input = CombinedAssemblyFailureMechanismSectionFactory.CreateInput(assessmentSection, new[]
+ {
+ assessmentSection.PipingStructure
+ }, true);
+
+ // Then
+ Assert.AreEqual(ManualFailureMechanismSectionAssemblyCategoryGroupConverter.Convert(sectionResult.ManualAssemblyCategoryGroup),
+ input.Single().Single().CategoryGroup);
+ }
+ }
+
+ [Test]
+ public void GivenPipingStructureFailureMechanismAndManualAssemblyAndUseManualFalse_WhenCreatingInput_ThenManualAssemblyIgnored()
+ {
+ // Given
+ var random = new Random(21);
+ var assessmentSection = new AssessmentSection(random.NextEnumValue());
+ PipingStructureFailureMechanism failureMechanism = assessmentSection.PipingStructure;
+ FailureMechanismTestHelper.SetSections(failureMechanism, new[]
+ {
+ FailureMechanismSectionTestFactory.CreateFailureMechanismSection()
+ });
+ PipingStructureFailureMechanismSectionResult sectionResult = failureMechanism.SectionResults.Single();
+ sectionResult.UseManualAssemblyCategoryGroup = true;
+ sectionResult.ManualAssemblyCategoryGroup = ManualFailureMechanismSectionAssemblyCategoryGroup.Iv;
+
+ using (new AssemblyToolCalculatorFactoryConfig())
+ {
+ // When
+ IEnumerable> input = CombinedAssemblyFailureMechanismSectionFactory.CreateInput(assessmentSection, new[]
+ {
+ assessmentSection.PipingStructure
+ }, false);
+
+ // Then
+ Assert.AreEqual(FailureMechanismSectionAssemblyCategoryGroup.IIv, input.Single().Single().CategoryGroup);
+ }
+ }
+
+ #endregion
+
+ #region StrengthStabilityLengthwiseConstruction
+
+ [Test]
+ public void GivenStrengthStabilityLengthwiseConstructionFailureMechanismAndManualAssemblyAndUseManualTrue_WhenCreatingInput_ThenManualAssemblyUsed()
+ {
+ // Given
+ var random = new Random(21);
+ var assessmentSection = new AssessmentSection(random.NextEnumValue());
+ StrengthStabilityLengthwiseConstructionFailureMechanism failureMechanism = assessmentSection.StrengthStabilityLengthwiseConstruction;
+ FailureMechanismTestHelper.SetSections(failureMechanism, new[]
+ {
+ FailureMechanismSectionTestFactory.CreateFailureMechanismSection()
+ });
+ StrengthStabilityLengthwiseConstructionFailureMechanismSectionResult sectionResult = failureMechanism.SectionResults.Single();
+ sectionResult.UseManualAssemblyCategoryGroup = true;
+ sectionResult.ManualAssemblyCategoryGroup = random.NextEnumValue();
+
+ using (new AssemblyToolCalculatorFactoryConfig())
+ {
+ // When
+ IEnumerable> input = CombinedAssemblyFailureMechanismSectionFactory.CreateInput(assessmentSection, new[]
+ {
+ assessmentSection.StrengthStabilityLengthwiseConstruction
+ }, true);
+
+ // Then
+ Assert.AreEqual(ManualFailureMechanismSectionAssemblyCategoryGroupConverter.Convert(sectionResult.ManualAssemblyCategoryGroup),
+ input.Single().Single().CategoryGroup);
+ }
+ }
+
+ [Test]
+ public void GivenStrengthStabilityLengthwiseConstructionFailureMechanismAndManualAssemblyAndUseManualFalse_WhenCreatingInput_ThenManualAssemblyIgnored()
+ {
+ // Given
+ var random = new Random(21);
+ var assessmentSection = new AssessmentSection(random.NextEnumValue());
+ StrengthStabilityLengthwiseConstructionFailureMechanism failureMechanism = assessmentSection.StrengthStabilityLengthwiseConstruction;
+ FailureMechanismTestHelper.SetSections(failureMechanism, new[]
+ {
+ FailureMechanismSectionTestFactory.CreateFailureMechanismSection()
+ });
+ StrengthStabilityLengthwiseConstructionFailureMechanismSectionResult sectionResult = failureMechanism.SectionResults.Single();
+ sectionResult.UseManualAssemblyCategoryGroup = true;
+ sectionResult.ManualAssemblyCategoryGroup = ManualFailureMechanismSectionAssemblyCategoryGroup.Iv;
+
+ using (new AssemblyToolCalculatorFactoryConfig())
+ {
+ // When
+ IEnumerable> input = CombinedAssemblyFailureMechanismSectionFactory.CreateInput(assessmentSection, new[]
+ {
+ assessmentSection.StrengthStabilityLengthwiseConstruction
+ }, false);
+
+ // Then
+ Assert.AreEqual(FailureMechanismSectionAssemblyCategoryGroup.IIv, input.Single().Single().CategoryGroup);
+ }
+ }
+
+ #endregion
+
+ #region TechnicalInnovation
+
+ [Test]
+ public void GivenTechnicalInnovationFailureMechanismAndManualAssemblyAndUseManualTrue_WhenCreatingInput_ThenManualAssemblyUsed()
+ {
+ // Given
+ var random = new Random(21);
+ var assessmentSection = new AssessmentSection(random.NextEnumValue());
+ TechnicalInnovationFailureMechanism failureMechanism = assessmentSection.TechnicalInnovation;
+ FailureMechanismTestHelper.SetSections(failureMechanism, new[]
+ {
+ FailureMechanismSectionTestFactory.CreateFailureMechanismSection()
+ });
+ TechnicalInnovationFailureMechanismSectionResult sectionResult = failureMechanism.SectionResults.Single();
+ sectionResult.UseManualAssemblyCategoryGroup = true;
+ sectionResult.ManualAssemblyCategoryGroup = random.NextEnumValue();
+
+ using (new AssemblyToolCalculatorFactoryConfig())
+ {
+ // When
+ IEnumerable> input = CombinedAssemblyFailureMechanismSectionFactory.CreateInput(assessmentSection, new[]
+ {
+ assessmentSection.TechnicalInnovation
+ }, true);
+
+ // Then
+ Assert.AreEqual(ManualFailureMechanismSectionAssemblyCategoryGroupConverter.Convert(sectionResult.ManualAssemblyCategoryGroup),
+ input.Single().Single().CategoryGroup);
+ }
+ }
+
+ [Test]
+ public void GivenTechnicalInnovationFailureMechanismAndManualAssemblyAndUseManualFalse_WhenCreatingInput_ThenManualAssemblyIgnored()
+ {
+ // Given
+ var random = new Random(21);
+ var assessmentSection = new AssessmentSection(random.NextEnumValue());
+ TechnicalInnovationFailureMechanism failureMechanism = assessmentSection.TechnicalInnovation;
+ FailureMechanismTestHelper.SetSections(failureMechanism, new[]
+ {
+ FailureMechanismSectionTestFactory.CreateFailureMechanismSection()
+ });
+ TechnicalInnovationFailureMechanismSectionResult sectionResult = failureMechanism.SectionResults.Single();
+ sectionResult.UseManualAssemblyCategoryGroup = true;
+ sectionResult.ManualAssemblyCategoryGroup = ManualFailureMechanismSectionAssemblyCategoryGroup.Iv;
+
+ using (new AssemblyToolCalculatorFactoryConfig())
+ {
+ // When
+ IEnumerable> input = CombinedAssemblyFailureMechanismSectionFactory.CreateInput(assessmentSection, new[]
+ {
+ assessmentSection.TechnicalInnovation
+ }, false);
+
+ // Then
+ Assert.AreEqual(FailureMechanismSectionAssemblyCategoryGroup.IIv, input.Single().Single().CategoryGroup);
+ }
+ }
+
+ #endregion
+
+ #region WaterPressureAsphaltCover
+
+ [Test]
+ public void GivenWaterPressureAsphaltCoverFailureMechanismAndManualAssemblyAndUseManualTrue_WhenCreatingInput_ThenManualAssemblyUsed()
+ {
+ // Given
+ var random = new Random(21);
+ var assessmentSection = new AssessmentSection(random.NextEnumValue());
+ WaterPressureAsphaltCoverFailureMechanism failureMechanism = assessmentSection.WaterPressureAsphaltCover;
+ FailureMechanismTestHelper.SetSections(failureMechanism, new[]
+ {
+ FailureMechanismSectionTestFactory.CreateFailureMechanismSection()
+ });
+ WaterPressureAsphaltCoverFailureMechanismSectionResult sectionResult = failureMechanism.SectionResults.Single();
+ sectionResult.UseManualAssemblyCategoryGroup = true;
+ sectionResult.ManualAssemblyCategoryGroup = random.NextEnumValue();
+
+ using (new AssemblyToolCalculatorFactoryConfig())
+ {
+ // When
+ IEnumerable> input = CombinedAssemblyFailureMechanismSectionFactory.CreateInput(assessmentSection, new[]
+ {
+ assessmentSection.WaterPressureAsphaltCover
+ }, true);
+
+ // Then
+ Assert.AreEqual(ManualFailureMechanismSectionAssemblyCategoryGroupConverter.Convert(sectionResult.ManualAssemblyCategoryGroup),
+ input.Single().Single().CategoryGroup);
+ }
+ }
+
+ [Test]
+ public void GivenWaterPressureAsphaltCoverFailureMechanismAndManualAssemblyAndUseManualFalse_WhenCreatingInput_ThenManualAssemblyIgnored()
+ {
+ // Given
+ var random = new Random(21);
+ var assessmentSection = new AssessmentSection(random.NextEnumValue());
+ WaterPressureAsphaltCoverFailureMechanism failureMechanism = assessmentSection.WaterPressureAsphaltCover;
+ FailureMechanismTestHelper.SetSections(failureMechanism, new[]
+ {
+ FailureMechanismSectionTestFactory.CreateFailureMechanismSection()
+ });
+ WaterPressureAsphaltCoverFailureMechanismSectionResult sectionResult = failureMechanism.SectionResults.Single();
+ sectionResult.UseManualAssemblyCategoryGroup = true;
+ sectionResult.ManualAssemblyCategoryGroup = ManualFailureMechanismSectionAssemblyCategoryGroup.Iv;
+
+ using (new AssemblyToolCalculatorFactoryConfig())
+ {
+ // When
+ IEnumerable> input = CombinedAssemblyFailureMechanismSectionFactory.CreateInput(assessmentSection, new[]
+ {
+ assessmentSection.WaterPressureAsphaltCover
+ }, false);
+
+ // Then
+ Assert.AreEqual(FailureMechanismSectionAssemblyCategoryGroup.IIv, input.Single().Single().CategoryGroup);
+ }
+ }
+
+ #endregion
+
+ #endregion
}
}
\ No newline at end of file