public void AssembleFailureMechanism_CalculatorRan_ReturnsExpectedOutput()
{
// Setup
var failureMechanism = new TestFailureMechanism
{
AssemblyResult =
{
ProbabilityResultType = FailureMechanismAssemblyProbabilityResultType.Automatic
}
};
var assessmentSection = new AssessmentSectionStub();
using (new AssemblyToolCalculatorFactoryConfig())
{
var calculatorFactory = (TestAssemblyToolCalculatorFactory)AssemblyToolCalculatorFactory.Instance;
FailureMechanismAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedFailureMechanismAssemblyCalculator;
// Call
FailureMechanismAssemblyResultWrapper result = FailureMechanismAssemblyFactory.AssembleFailureMechanism(failureMechanism, assessmentSection);
// Assert
Assert.AreSame(calculator.AssemblyResultOutput, result);
}
}
public void AssembleFailureMechanism_CalculatorThrowsException_ThrowsAssemblyException()
{
// Setup
var failureMechanism = new TestFailureMechanism
{
AssemblyResult =
{
ProbabilityResultType = FailureMechanismAssemblyProbabilityResultType.Automatic
}
};
var assessmentSection = new AssessmentSectionStub();
using (new AssemblyToolCalculatorFactoryConfig())
{
var calculatorFactory = (TestAssemblyToolCalculatorFactory)AssemblyToolCalculatorFactory.Instance;
FailureMechanismAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedFailureMechanismAssemblyCalculator;
calculator.ThrowExceptionOnCalculate = true;
// Call
void Call() => FailureMechanismAssemblyFactory.AssembleFailureMechanism(failureMechanism, assessmentSection);
// Assert
var exception = Assert.Throws <AssemblyException>(Call);
Exception innerException = exception.InnerException;
Assert.IsInstanceOf <FailureMechanismAssemblyCalculatorException>(innerException);
Assert.AreEqual(innerException.Message, exception.Message);
}
}
public void AssembleSection_CalculatorThrowsException_ThrowsAssemblyException()
{
// Setup
FailureMechanismSection section = FailureMechanismSectionTestFactory.CreateFailureMechanismSection();
var sectionResult = new NonAdoptableWithProfileProbabilityFailureMechanismSectionResult(section);
var failureMechanism = new TestFailureMechanism();
var assessmentSection = new AssessmentSectionStub();
using (new AssemblyToolCalculatorFactoryConfig())
{
var calculatorFactory = (TestAssemblyToolCalculatorFactory)AssemblyToolCalculatorFactory.Instance;
FailureMechanismSectionAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator;
calculator.ThrowExceptionOnCalculate = true;
// Call
void Call() => FailureMechanismAssemblyFactory.AssembleSection(
sectionResult, failureMechanism, assessmentSection);
// Assert
var exception = Assert.Throws <AssemblyException>(Call);
Exception innerException = exception.InnerException;
Assert.IsInstanceOf <FailureMechanismSectionAssemblyCalculatorException>(innerException);
Assert.AreEqual(innerException.Message, exception.Message);
}
}
public void AssembleFailureMechanism_WithInput_SetsInputOnCalculator()
{
// Setup
var failureMechanism = new TestFailureMechanism
{
AssemblyResult =
{
ProbabilityResultType = FailureMechanismAssemblyProbabilityResultType.Automatic
}
};
failureMechanism.SetSections(new[]
{
FailureMechanismSectionTestFactory.CreateFailureMechanismSection()
}, "APath");
var assessmentSection = new AssessmentSectionStub();
using (new AssemblyToolCalculatorFactoryConfig())
{
var calculatorFactory = (TestAssemblyToolCalculatorFactory)AssemblyToolCalculatorFactory.Instance;
FailureMechanismSectionAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator;
FailureMechanismAssemblyCalculatorStub failureMechanismAssemblyCalculator = calculatorFactory.LastCreatedFailureMechanismAssemblyCalculator;
// Call
FailureMechanismAssemblyFactory.AssembleFailureMechanism(failureMechanism, assessmentSection);
// Assert
Assert.AreEqual(failureMechanism.GeneralInput.N, failureMechanismAssemblyCalculator.FailureMechanismN);
Assert.AreSame(calculator.FailureMechanismSectionAssemblyResultOutput.AssemblyResult, failureMechanismAssemblyCalculator.SectionAssemblyResultsInput.Single());
Assert.AreEqual(failureMechanism.GeneralInput.ApplyLengthEffectInSection, failureMechanismAssemblyCalculator.ApplyLengthEffect);
}
}
private IEnumerable <FailureMechanismAssemblyResultRow> CreateSpecificFailureMechanismResultRows()
{
return(AssessmentSection.SpecificFailureMechanisms
.Select(fp => FailureMechanismAssemblyResultRowFactory.CreateRow(
fp, () => FailureMechanismAssemblyFactory.AssembleFailureMechanism(fp, AssessmentSection))
)
.ToArray());
}
public void AssembleFailureMechanism_AssessmentSectionNull_ThrowsArgumentNullException()
{
// Setup
var failureMechanism = new TestFailureMechanism();
// Call
void Call() => FailureMechanismAssemblyFactory.AssembleFailureMechanism(failureMechanism, null);
// Assert
var exception = Assert.Throws <ArgumentNullException>(Call);
Assert.AreEqual("assessmentSection", exception.ParamName);
}
public void AssembleSection_AssessmentSectionNull_ThrowsArgumentNullException()
{
// Setup
FailureMechanismSection section = FailureMechanismSectionTestFactory.CreateFailureMechanismSection();
var sectionResult = new NonAdoptableWithProfileProbabilityFailureMechanismSectionResult(section);
var failureMechanism = new TestFailureMechanism();
// Call
void Call() => FailureMechanismAssemblyFactory.AssembleSection(sectionResult, failureMechanism, null);
// Assert
var exception = Assert.Throws <ArgumentNullException>(Call);
Assert.AreEqual("assessmentSection", exception.ParamName);
}
public void AssembleFailureMechanism_FailureMechanismNull_ThrowsArgumentNullException()
{
// Setup
var mocks = new MockRepository();
var assessmentSection = mocks.Stub <IAssessmentSection>();
mocks.ReplayAll();
// Call
void Call() => FailureMechanismAssemblyFactory.AssembleFailureMechanism <TestFailureMechanism>(null, assessmentSection);
// Assert
var exception = Assert.Throws <ArgumentNullException>(Call);
Assert.AreEqual("failureMechanism", exception.ParamName);
mocks.VerifyAll();
}
/// <summary>
/// Gets the failure mechanism assembly results based on the input arguments.
/// </summary>
/// <param name="assessmentSection">The <see cref="AssessmentSection"/> to retrieve the failure mechanism assembly results
/// for.</param>
/// <returns>A collection of failure mechanism assembly results.</returns>
/// <exception cref="AssemblyException">Thrown when the results could not be assembled.</exception>
private static IEnumerable <double> GetFailureMechanismAssemblyResults(AssessmentSection assessmentSection)
{
var failureMechanismAssemblies = new List <double>();
AssembleWhenApplicable(failureMechanismAssemblies, assessmentSection.Piping, assessmentSection,
PipingFailureMechanismAssemblyFactory.AssembleFailureMechanism);
AssembleWhenApplicable(failureMechanismAssemblies, assessmentSection.MacroStabilityInwards, assessmentSection,
MacroStabilityInwardsFailureMechanismAssemblyFactory.AssembleFailureMechanism);
AssembleWhenApplicable(failureMechanismAssemblies, assessmentSection.GrassCoverErosionInwards, assessmentSection,
GrassCoverErosionInwardsFailureMechanismAssemblyFactory.AssembleFailureMechanism);
AssembleWhenApplicable(failureMechanismAssemblies, assessmentSection.ClosingStructures, assessmentSection,
ClosingStructuresFailureMechanismAssemblyFactory.AssembleFailureMechanism);
AssembleWhenApplicable(failureMechanismAssemblies, assessmentSection.HeightStructures, assessmentSection,
HeightStructuresFailureMechanismAssemblyFactory.AssembleFailureMechanism);
AssembleWhenApplicable(failureMechanismAssemblies, assessmentSection.StabilityPointStructures, assessmentSection,
StabilityPointStructuresFailureMechanismAssemblyFactory.AssembleFailureMechanism);
AssembleWhenApplicable(failureMechanismAssemblies, assessmentSection.GrassCoverErosionOutwards, assessmentSection,
GrassCoverErosionOutwardsFailureMechanismAssemblyFactory.AssembleFailureMechanism);
AssembleWhenApplicable(failureMechanismAssemblies, assessmentSection.StabilityStoneCover, assessmentSection,
StabilityStoneCoverFailureMechanismAssemblyFactory.AssembleFailureMechanism);
AssembleWhenApplicable(failureMechanismAssemblies, assessmentSection.WaveImpactAsphaltCover, assessmentSection,
WaveImpactAsphaltCoverFailureMechanismAssemblyFactory.AssembleFailureMechanism);
AssembleWhenApplicable(failureMechanismAssemblies, assessmentSection.DuneErosion, assessmentSection,
DuneErosionFailureMechanismAssemblyFactory.AssembleFailureMechanism);
AssembleWhenApplicable(failureMechanismAssemblies, assessmentSection.PipingStructure, assessmentSection,
PipingStructureFailureMechanismAssemblyFactory.AssembleFailureMechanism);
AssembleWhenApplicable(failureMechanismAssemblies, assessmentSection.GrassCoverSlipOffInwards, assessmentSection,
FailureMechanismAssemblyFactory.AssembleFailureMechanism);
AssembleWhenApplicable(failureMechanismAssemblies, assessmentSection.GrassCoverSlipOffOutwards, assessmentSection,
FailureMechanismAssemblyFactory.AssembleFailureMechanism);
AssembleWhenApplicable(failureMechanismAssemblies, assessmentSection.Microstability, assessmentSection,
FailureMechanismAssemblyFactory.AssembleFailureMechanism);
AssembleWhenApplicable(failureMechanismAssemblies, assessmentSection.WaterPressureAsphaltCover, assessmentSection,
FailureMechanismAssemblyFactory.AssembleFailureMechanism);
failureMechanismAssemblies.AddRange(assessmentSection.SpecificFailureMechanisms
.Where(fp => fp.InAssembly)
.Select(fp => FailureMechanismAssemblyFactory.AssembleFailureMechanism(fp, assessmentSection)
.AssemblyResult));
return(failureMechanismAssemblies);
}
public void AssembleSection_FailureMechanismNull_ThrowsArgumentNullException()
{
// Setup
var mocks = new MockRepository();
var assessmentSection = mocks.Stub <IAssessmentSection>();
mocks.ReplayAll();
FailureMechanismSection section = FailureMechanismSectionTestFactory.CreateFailureMechanismSection();
var sectionResult = new NonAdoptableWithProfileProbabilityFailureMechanismSectionResult(section);
// Call
void Call() => FailureMechanismAssemblyFactory.AssembleSection(sectionResult, null, assessmentSection);
// Assert
var exception = Assert.Throws <ArgumentNullException>(Call);
Assert.AreEqual("failureMechanism", exception.ParamName);
mocks.VerifyAll();
}
public void AssembleSection_WithInput_SetsInputOnCalculator()
{
// Setup
var random = new Random(21);
FailureMechanismSection section = FailureMechanismSectionTestFactory.CreateFailureMechanismSection();
var sectionResult = new NonAdoptableWithProfileProbabilityFailureMechanismSectionResult(section)
{
IsRelevant = random.NextBoolean(),
InitialFailureMechanismResultType = NonAdoptableInitialFailureMechanismResultType.Manual,
ManualInitialFailureMechanismResultSectionProbability = random.NextDouble(),
FurtherAnalysisType = random.NextEnumValue <FailureMechanismSectionResultFurtherAnalysisType>(),
RefinedSectionProbability = random.NextDouble()
};
var failureMechanism = new TestFailureMechanism();
var assessmentSection = new AssessmentSectionStub();
using (new AssemblyToolCalculatorFactoryConfig())
{
var calculatorFactory = (TestAssemblyToolCalculatorFactory)AssemblyToolCalculatorFactory.Instance;
FailureMechanismSectionAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator;
// Call
FailureMechanismAssemblyFactory.AssembleSection(sectionResult, failureMechanism, assessmentSection);
// Assert
FailureMechanismSectionAssemblyInput calculatorInput = calculator.FailureMechanismSectionAssemblyInput;
FailureMechanismContribution failureMechanismContribution = assessmentSection.FailureMechanismContribution;
Assert.AreEqual(failureMechanismContribution.SignalFloodingProbability, calculatorInput.SignalFloodingProbability);
Assert.AreEqual(failureMechanismContribution.MaximumAllowableFloodingProbability, calculatorInput.MaximumAllowableFloodingProbability);
Assert.AreEqual(sectionResult.IsRelevant, calculatorInput.IsRelevant);
Assert.IsTrue(calculatorInput.HasProbabilitySpecified);
Assert.AreEqual(sectionResult.ManualInitialFailureMechanismResultSectionProbability, calculatorInput.InitialSectionProbability);
Assert.AreEqual(sectionResult.FurtherAnalysisType, calculatorInput.FurtherAnalysisType);
Assert.AreEqual(sectionResult.RefinedSectionProbability, calculatorInput.RefinedSectionProbability);
}
}
public void AssembleSection_CalculatorRan_ReturnsExpectedOutput()
{
// Setup
FailureMechanismSection section = FailureMechanismSectionTestFactory.CreateFailureMechanismSection();
var sectionResult = new NonAdoptableWithProfileProbabilityFailureMechanismSectionResult(section);
var failureMechanism = new TestFailureMechanism();
var assessmentSection = new AssessmentSectionStub();
using (new AssemblyToolCalculatorFactoryConfig())
{
var calculatorFactory = (TestAssemblyToolCalculatorFactory)AssemblyToolCalculatorFactory.Instance;
FailureMechanismSectionAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator;
// Call
FailureMechanismSectionAssemblyResultWrapper result = FailureMechanismAssemblyFactory.AssembleSection(
sectionResult, failureMechanism, assessmentSection);
// Assert
Assert.AreSame(calculator.FailureMechanismSectionAssemblyResultOutput, result);
}
}
private void CreateMapData()
{
failureMechanismMapDataCollection = new MapDataCollection(failureMechanism.Name);
hydraulicBoundaryLocationsMapLayer = new HydraulicBoundaryLocationsMapLayer(assessmentSection);
referenceLineMapData = RiskeerMapDataFactory.CreateReferenceLineMapData();
MapDataCollection sectionsMapDataCollection = RiskeerMapDataFactory.CreateSectionsMapDataCollection();
sectionsMapData = RiskeerMapDataFactory.CreateFailureMechanismSectionsMapData();
sectionsStartPointMapData = RiskeerMapDataFactory.CreateFailureMechanismSectionsStartPointMapData();
sectionsEndPointMapData = RiskeerMapDataFactory.CreateFailureMechanismSectionsEndPointMapData();
sectionsMapDataCollection.Add(sectionsMapData);
sectionsMapDataCollection.Add(sectionsStartPointMapData);
sectionsMapDataCollection.Add(sectionsEndPointMapData);
assemblyResultMapLayer = new NonCalculatableFailureMechanismSectionResultsMapLayer <NonAdoptableWithProfileProbabilityFailureMechanismSectionResult>(
failureMechanism, sr => FailureMechanismAssemblyFactory.AssembleSection(sr, failureMechanism, assessmentSection).AssemblyResult);
failureMechanismMapDataCollection.Add(referenceLineMapData);
failureMechanismMapDataCollection.Add(sectionsMapDataCollection);
failureMechanismMapDataCollection.Add(assemblyResultMapLayer.MapData);
failureMechanismMapDataCollection.Add(hydraulicBoundaryLocationsMapLayer.MapData);
}
/// <summary>
/// Creates a collection of <see cref="CombinedAssemblyFailureMechanismSection"/> collections.
/// </summary>
/// <param name="assessmentSection">The assessment section to use.</param>
/// <param name="failureMechanisms">The failure mechanisms to build input for.</param>
/// <returns>A collection of <see cref="CombinedAssemblyFailureMechanismSection"/> collections.</returns>
/// <exception cref="ArgumentNullException">Thrown when any parameter is <c>null</c>.</exception>
public static IEnumerable <IEnumerable <CombinedAssemblyFailureMechanismSection> > CreateInput(
AssessmentSection assessmentSection, IEnumerable <IFailureMechanism> failureMechanisms)
{
if (assessmentSection == null)
{
throw new ArgumentNullException(nameof(assessmentSection));
}
if (failureMechanisms == null)
{
throw new ArgumentNullException(nameof(failureMechanisms));
}
var inputs = new List <IEnumerable <CombinedAssemblyFailureMechanismSection> >();
PipingFailureMechanism pipingFailureMechanism = assessmentSection.Piping;
if (failureMechanisms.Contains(pipingFailureMechanism))
{
inputs.Add(CreateCombinedSections(pipingFailureMechanism.SectionResults, assessmentSection, PipingAssemblyFunc));
}
GrassCoverErosionInwardsFailureMechanism grassCoverErosionInwardsFailureMechanism = assessmentSection.GrassCoverErosionInwards;
if (failureMechanisms.Contains(grassCoverErosionInwardsFailureMechanism))
{
inputs.Add(CreateCombinedSections(grassCoverErosionInwardsFailureMechanism.SectionResults, assessmentSection, GrassCoverErosionInwardsAssemblyFunc));
}
MacroStabilityInwardsFailureMechanism macroStabilityInwardsFailureMechanism = assessmentSection.MacroStabilityInwards;
if (failureMechanisms.Contains(macroStabilityInwardsFailureMechanism))
{
inputs.Add(CreateCombinedSections(macroStabilityInwardsFailureMechanism.SectionResults, assessmentSection, MacroStabilityInwardsAssemblyFunc));
}
MicrostabilityFailureMechanism microstabilityFailureMechanism = assessmentSection.Microstability;
if (failureMechanisms.Contains(microstabilityFailureMechanism))
{
inputs.Add(CreateCombinedSections(microstabilityFailureMechanism.SectionResults, assessmentSection, MicrostabilityAssemblyFunc));
}
StabilityStoneCoverFailureMechanism stabilityStoneCoverFailureMechanism = assessmentSection.StabilityStoneCover;
if (failureMechanisms.Contains(stabilityStoneCoverFailureMechanism))
{
inputs.Add(CreateCombinedSections(stabilityStoneCoverFailureMechanism.SectionResults, assessmentSection, StabilityStoneCoverAssemblyFunc));
}
WaveImpactAsphaltCoverFailureMechanism waveImpactAsphaltCoverFailureMechanism = assessmentSection.WaveImpactAsphaltCover;
if (failureMechanisms.Contains(waveImpactAsphaltCoverFailureMechanism))
{
inputs.Add(CreateCombinedSections(waveImpactAsphaltCoverFailureMechanism.SectionResults, assessmentSection, WaveImpactAsphaltCoverAssemblyFunc));
}
WaterPressureAsphaltCoverFailureMechanism waterPressureAsphaltCoverFailureMechanism = assessmentSection.WaterPressureAsphaltCover;
if (failureMechanisms.Contains(waterPressureAsphaltCoverFailureMechanism))
{
inputs.Add(CreateCombinedSections(waterPressureAsphaltCoverFailureMechanism.SectionResults, assessmentSection, WaterPressureAsphaltCoverAssemblyFunc));
}
GrassCoverErosionOutwardsFailureMechanism grassCoverErosionOutwardsFailureMechanism = assessmentSection.GrassCoverErosionOutwards;
if (failureMechanisms.Contains(grassCoverErosionOutwardsFailureMechanism))
{
inputs.Add(CreateCombinedSections(grassCoverErosionOutwardsFailureMechanism.SectionResults, assessmentSection, GrassCoverErosionOutwardsAssemblyFunc));
}
GrassCoverSlipOffOutwardsFailureMechanism grassCoverSlipOffOutwardsFailureMechanism = assessmentSection.GrassCoverSlipOffOutwards;
if (failureMechanisms.Contains(grassCoverSlipOffOutwardsFailureMechanism))
{
inputs.Add(CreateCombinedSections(grassCoverSlipOffOutwardsFailureMechanism.SectionResults, assessmentSection, GrassCoverSlipOffOutwardsAssemblyFunc));
}
GrassCoverSlipOffInwardsFailureMechanism grassCoverSlipOffInwardsFailureMechanism = assessmentSection.GrassCoverSlipOffInwards;
if (failureMechanisms.Contains(grassCoverSlipOffInwardsFailureMechanism))
{
inputs.Add(CreateCombinedSections(grassCoverSlipOffInwardsFailureMechanism.SectionResults, assessmentSection, GrassCoverSlipOffInwardsAssemblyFunc));
}
HeightStructuresFailureMechanism heightStructuresFailureMechanism = assessmentSection.HeightStructures;
if (failureMechanisms.Contains(heightStructuresFailureMechanism))
{
inputs.Add(CreateCombinedSections(heightStructuresFailureMechanism.SectionResults, assessmentSection, HeightStructuresAssemblyFunc));
}
ClosingStructuresFailureMechanism closingStructuresFailureMechanism = assessmentSection.ClosingStructures;
if (failureMechanisms.Contains(closingStructuresFailureMechanism))
{
inputs.Add(CreateCombinedSections(closingStructuresFailureMechanism.SectionResults, assessmentSection, ClosingStructuresAssemblyFunc));
}
PipingStructureFailureMechanism pipingStructureFailureMechanism = assessmentSection.PipingStructure;
if (failureMechanisms.Contains(pipingStructureFailureMechanism))
{
inputs.Add(CreateCombinedSections(pipingStructureFailureMechanism.SectionResults, assessmentSection, PipingStructureAssemblyFunc));
}
StabilityPointStructuresFailureMechanism stabilityPointStructuresFailureMechanism = assessmentSection.StabilityPointStructures;
if (failureMechanisms.Contains(stabilityPointStructuresFailureMechanism))
{
inputs.Add(CreateCombinedSections(stabilityPointStructuresFailureMechanism.SectionResults, assessmentSection, StabilityPointStructuresAssemblyFunc));
}
DuneErosionFailureMechanism duneErosionFailureMechanism = assessmentSection.DuneErosion;
if (failureMechanisms.Contains(duneErosionFailureMechanism))
{
inputs.Add(CreateCombinedSections(duneErosionFailureMechanism.SectionResults, assessmentSection, DuneErosionAssemblyFunc));
}
foreach (SpecificFailureMechanism specificFailureMechanism in assessmentSection.SpecificFailureMechanisms)
{
if (failureMechanisms.Contains(specificFailureMechanism))
{
inputs.Add(CreateCombinedSections(specificFailureMechanism.SectionResults, assessmentSection,
(sectionResult, section) => FailureMechanismAssemblyFactory.AssembleSection(sectionResult, specificFailureMechanism, section)));
}
}
return(inputs);
}
private FailureMechanismAssemblyResultRow CreateStandAloneFailureMechanismAssemblyResultRow <TFailureMechanism>(TFailureMechanism failureMechanism)
where TFailureMechanism : IHasGeneralInput, IFailureMechanism <NonAdoptableWithProfileProbabilityFailureMechanismSectionResult>
{
return(FailureMechanismAssemblyResultRowFactory.CreateRow(
failureMechanism, () => FailureMechanismAssemblyFactory.AssembleFailureMechanism(failureMechanism, AssessmentSection)));
}