public void Create_AssessmentSectionNull_ThrowsArgumentNullException()
{
// Call
void Call() => CombinedFailureMechanismSectionAssemblyResultFactory.Create(
new CombinedFailureMechanismSectionAssemblyResultWrapper(
Enumerable.Empty <CombinedFailureMechanismSectionAssembly>(),
AssemblyMethod.BOI3A1, AssemblyMethod.BOI3B1, AssemblyMethod.BOI3C1),
new Dictionary <IFailureMechanism, int>(), null);
// Assert
var exception = Assert.Throws <ArgumentNullException>(Call);
Assert.AreEqual("assessmentSection", exception.ParamName);
}
public void Create_OutputNull_ThrowsArgumentNullException()
{
// Setup
var random = new Random(21);
// Call
void Call() => CombinedFailureMechanismSectionAssemblyResultFactory.Create(
null, new Dictionary <IFailureMechanism, int>(),
new AssessmentSection(random.NextEnumValue <AssessmentSectionComposition>()));
// Assert
var exception = Assert.Throws <ArgumentNullException>(Call);
Assert.AreEqual("output", exception.ParamName);
}
public void Create_FailureMechanismsNull_ThrowsArgumentNullException()
{
// Setup
var random = new Random(21);
// Call
void Call() => CombinedFailureMechanismSectionAssemblyResultFactory.Create(
new CombinedFailureMechanismSectionAssemblyResultWrapper(
Enumerable.Empty <CombinedFailureMechanismSectionAssembly>(),
AssemblyMethod.BOI3A1, AssemblyMethod.BOI3B1, AssemblyMethod.BOI3C1),
null, new AssessmentSection(random.NextEnumValue <AssessmentSectionComposition>()));
// Assert
var exception = Assert.Throws <ArgumentNullException>(Call);
Assert.AreEqual("failureMechanisms", exception.ParamName);
}
public void Create_WithAllFailureMechanisms_ReturnsCombinedFailureMechanismSectionAssemblyResults()
{
// Setup
var random = new Random(21);
var assessmentSection = new AssessmentSection(random.NextEnumValue <AssessmentSectionComposition>());
assessmentSection.SpecificFailureMechanisms.Add(new SpecificFailureMechanism());
Dictionary <IFailureMechanism, int> failureMechanisms = assessmentSection.GetFailureMechanisms()
.Concat(assessmentSection.SpecificFailureMechanisms)
.Where(fm => fm.InAssembly)
.Select((fm, i) => new
{
FailureMechanism = fm,
Index = i
})
.ToDictionary(x => x.FailureMechanism, x => x.Index);
var section1 = new CombinedAssemblyFailureMechanismSection(0, 5, random.NextEnumValue <FailureMechanismSectionAssemblyGroup>());
var section2 = new CombinedAssemblyFailureMechanismSection(5, 11, random.NextEnumValue <FailureMechanismSectionAssemblyGroup>());
var output = new CombinedFailureMechanismSectionAssemblyResultWrapper(
new[]
{
new CombinedFailureMechanismSectionAssembly(section1, GetFailureMechanismsOutput(failureMechanisms.Keys, random)),
new CombinedFailureMechanismSectionAssembly(section2, GetFailureMechanismsOutput(failureMechanisms.Keys, random))
}, AssemblyMethod.BOI3A1, AssemblyMethod.BOI3B1, AssemblyMethod.BOI3C1);
// Call
CombinedFailureMechanismSectionAssemblyResult[] results = CombinedFailureMechanismSectionAssemblyResultFactory.Create(output, failureMechanisms, assessmentSection).ToArray();
// Assert
Assert.AreEqual(output.AssemblyResults.Count(), results.Length);
for (var i = 0; i < output.AssemblyResults.Count(); i++)
{
CombinedFailureMechanismSectionAssembly assemblyResult = output.AssemblyResults.ElementAt(i);
Assert.AreEqual(assemblyResult.Section.SectionStart, results[i].SectionStart);
Assert.AreEqual(assemblyResult.Section.SectionEnd, results[i].SectionEnd);
Assert.AreEqual(assemblyResult.Section.FailureMechanismSectionAssemblyGroup, results[i].TotalResult);
Assert.AreEqual(assemblyResult.FailureMechanismSectionAssemblyGroupResults.ElementAt(failureMechanisms[assessmentSection.Piping]), results[i].Piping);
Assert.AreEqual(assemblyResult.FailureMechanismSectionAssemblyGroupResults.ElementAt(failureMechanisms[assessmentSection.GrassCoverErosionInwards]), results[i].GrassCoverErosionInwards);
Assert.AreEqual(assemblyResult.FailureMechanismSectionAssemblyGroupResults.ElementAt(failureMechanisms[assessmentSection.MacroStabilityInwards]), results[i].MacroStabilityInwards);
Assert.AreEqual(assemblyResult.FailureMechanismSectionAssemblyGroupResults.ElementAt(failureMechanisms[assessmentSection.Microstability]), results[i].Microstability);
Assert.AreEqual(assemblyResult.FailureMechanismSectionAssemblyGroupResults.ElementAt(failureMechanisms[assessmentSection.StabilityStoneCover]), results[i].StabilityStoneCover);
Assert.AreEqual(assemblyResult.FailureMechanismSectionAssemblyGroupResults.ElementAt(failureMechanisms[assessmentSection.WaveImpactAsphaltCover]), results[i].WaveImpactAsphaltCover);
Assert.AreEqual(assemblyResult.FailureMechanismSectionAssemblyGroupResults.ElementAt(failureMechanisms[assessmentSection.WaterPressureAsphaltCover]), results[i].WaterPressureAsphaltCover);
Assert.AreEqual(assemblyResult.FailureMechanismSectionAssemblyGroupResults.ElementAt(failureMechanisms[assessmentSection.GrassCoverErosionOutwards]), results[i].GrassCoverErosionOutwards);
Assert.AreEqual(assemblyResult.FailureMechanismSectionAssemblyGroupResults.ElementAt(failureMechanisms[assessmentSection.GrassCoverSlipOffOutwards]), results[i].GrassCoverSlipOffOutwards);
Assert.AreEqual(assemblyResult.FailureMechanismSectionAssemblyGroupResults.ElementAt(failureMechanisms[assessmentSection.GrassCoverSlipOffInwards]), results[i].GrassCoverSlipOffInwards);
Assert.AreEqual(assemblyResult.FailureMechanismSectionAssemblyGroupResults.ElementAt(failureMechanisms[assessmentSection.HeightStructures]), results[i].HeightStructures);
Assert.AreEqual(assemblyResult.FailureMechanismSectionAssemblyGroupResults.ElementAt(failureMechanisms[assessmentSection.ClosingStructures]), results[i].ClosingStructures);
Assert.AreEqual(assemblyResult.FailureMechanismSectionAssemblyGroupResults.ElementAt(failureMechanisms[assessmentSection.PipingStructure]), results[i].PipingStructure);
Assert.AreEqual(assemblyResult.FailureMechanismSectionAssemblyGroupResults.ElementAt(failureMechanisms[assessmentSection.StabilityPointStructures]), results[i].StabilityPointStructures);
Assert.AreEqual(assemblyResult.FailureMechanismSectionAssemblyGroupResults.ElementAt(failureMechanisms[assessmentSection.DuneErosion]), results[i].DuneErosion);
Assert.AreEqual(assessmentSection.SpecificFailureMechanisms.Count, results[i].SpecificFailureMechanisms.Length);
foreach (SpecificFailureMechanism specificFailureMechanism in assessmentSection.SpecificFailureMechanisms)
{
Assert.AreEqual(assemblyResult.FailureMechanismSectionAssemblyGroupResults.ElementAt(failureMechanisms[specificFailureMechanism]), results[i].SpecificFailureMechanisms.Single());
}
Assert.AreEqual(output.CommonSectionAssemblyMethod, results[i].CommonSectionAssemblyMethod);
Assert.AreEqual(output.FailureMechanismResultsAssemblyMethod, results[i].FailureMechanismResultsAssemblyMethod);
Assert.AreEqual(output.CombinedSectionResultAssemblyMethod, results[i].CombinedSectionResultAssemblyMethod);
}
}
public void AssembleCombinedPerFailureMechanismSection_AssemblyRan_ReturnsOutput()
{
var random = new Random(21);
AssessmentSection assessmentSection = TestDataGenerator.GetAssessmentSectionWithAllFailureMechanismSectionsAndResults(
random.NextEnumValue <AssessmentSectionComposition>());
using (new AssemblyToolCalculatorFactoryConfig())
{
var calculatorFactory = (TestAssemblyToolCalculatorFactory)AssemblyToolCalculatorFactory.Instance;
AssessmentSectionAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedAssessmentSectionAssemblyCalculator;
calculator.CombinedFailureMechanismSectionAssemblyOutput = new CombinedFailureMechanismSectionAssemblyResultWrapper(
new[]
{
CombinedFailureMechanismSectionAssemblyTestFactory.Create(assessmentSection, 20),
CombinedFailureMechanismSectionAssemblyTestFactory.Create(assessmentSection, 21)
}, AssemblyMethod.BOI3A1, AssemblyMethod.BOI3B1, AssemblyMethod.BOI3C1);
// Call
CombinedFailureMechanismSectionAssemblyResult[] output = AssessmentSectionAssemblyFactory.AssembleCombinedPerFailureMechanismSection(
assessmentSection)
.ToArray();
// Assert
Dictionary <IFailureMechanism, int> failureMechanisms = assessmentSection.GetFailureMechanisms()
.Concat(assessmentSection.SpecificFailureMechanisms)
.Where(fm => fm.InAssembly)
.Select((fm, i) => new
{
FailureMechanism = fm,
Index = i
})
.ToDictionary(x => x.FailureMechanism, x => x.Index);
CombinedFailureMechanismSectionAssemblyResult[] expectedOutput = CombinedFailureMechanismSectionAssemblyResultFactory.Create(
calculator.CombinedFailureMechanismSectionAssemblyOutput, failureMechanisms, assessmentSection).ToArray();
Assert.AreEqual(expectedOutput.Length, output.Length);
for (var i = 0; i < expectedOutput.Length; i++)
{
Assert.AreEqual(expectedOutput[i].SectionStart, output[i].SectionStart);
Assert.AreEqual(expectedOutput[i].SectionEnd, output[i].SectionEnd);
Assert.AreEqual(expectedOutput[i].TotalResult, output[i].TotalResult);
Assert.AreEqual(expectedOutput[i].Piping, output[i].Piping);
Assert.AreEqual(expectedOutput[i].GrassCoverErosionInwards, output[i].GrassCoverErosionInwards);
Assert.AreEqual(expectedOutput[i].MacroStabilityInwards, output[i].MacroStabilityInwards);
Assert.AreEqual(expectedOutput[i].Microstability, output[i].Microstability);
Assert.AreEqual(expectedOutput[i].StabilityStoneCover, output[i].StabilityStoneCover);
Assert.AreEqual(expectedOutput[i].WaveImpactAsphaltCover, output[i].WaveImpactAsphaltCover);
Assert.AreEqual(expectedOutput[i].WaterPressureAsphaltCover, output[i].WaterPressureAsphaltCover);
Assert.AreEqual(expectedOutput[i].GrassCoverErosionOutwards, output[i].GrassCoverErosionOutwards);
Assert.AreEqual(expectedOutput[i].GrassCoverSlipOffOutwards, output[i].GrassCoverSlipOffOutwards);
Assert.AreEqual(expectedOutput[i].GrassCoverSlipOffInwards, output[i].GrassCoverSlipOffInwards);
Assert.AreEqual(expectedOutput[i].HeightStructures, output[i].HeightStructures);
Assert.AreEqual(expectedOutput[i].ClosingStructures, output[i].ClosingStructures);
Assert.AreEqual(expectedOutput[i].PipingStructure, output[i].PipingStructure);
Assert.AreEqual(expectedOutput[i].StabilityPointStructures, output[i].StabilityPointStructures);
Assert.AreEqual(expectedOutput[i].DuneErosion, output[i].DuneErosion);
CollectionAssert.AreEqual(expectedOutput[i].SpecificFailureMechanisms, output[i].SpecificFailureMechanisms);
Assert.AreEqual(expectedOutput[i].CommonSectionAssemblyMethod, output[i].CommonSectionAssemblyMethod);
Assert.AreEqual(expectedOutput[i].FailureMechanismResultsAssemblyMethod, output[i].FailureMechanismResultsAssemblyMethod);
Assert.AreEqual(expectedOutput[i].CombinedSectionResultAssemblyMethod, output[i].CombinedSectionResultAssemblyMethod);
}
}
}
