public void AssembleAssessmentSection_AssessmentSectionContainingFailureMechanismsWithRandomInAssemblyState_SetsInputOnCalculator()
{
// Setup
AssessmentSection assessmentSection = CreateAssessmentSectionContainingFailureMechanismsWithRandomInAssemblyState();
using (new AssemblyToolCalculatorFactoryConfig())
{
var calculatorFactory = (TestAssemblyToolCalculatorFactory)AssemblyToolCalculatorFactory.Instance;
FailureMechanismAssemblyCalculatorStub failureMechanismAssemblyCalculator = calculatorFactory.LastCreatedFailureMechanismAssemblyCalculator;
AssessmentSectionAssemblyCalculatorStub assessmentSectionAssemblyCalculator = calculatorFactory.LastCreatedAssessmentSectionAssemblyCalculator;
// Call
AssessmentSectionAssemblyFactory.AssembleAssessmentSection(assessmentSection);
// Assert
FailureMechanismContribution contribution = assessmentSection.FailureMechanismContribution;
Assert.AreEqual(contribution.SignalFloodingProbability, assessmentSectionAssemblyCalculator.SignalFloodingProbability);
Assert.AreEqual(contribution.MaximumAllowableFloodingProbability, assessmentSectionAssemblyCalculator.MaximumAllowableFloodingProbabilityInput);
int expectedNrOfProbabilities = assessmentSection.GetFailureMechanisms()
.Concat(assessmentSection.SpecificFailureMechanisms)
.Count(fp => fp.InAssembly);
IEnumerable <double> calculatorInput = assessmentSectionAssemblyCalculator.FailureMechanismProbabilitiesInput;
Assert.AreEqual(expectedNrOfProbabilities, calculatorInput.Count());
foreach (double failureMechanismProbability in calculatorInput)
{
Assert.AreEqual(failureMechanismAssemblyCalculator.AssemblyResultOutput.AssemblyResult, failureMechanismProbability);
}
}
}
/// <summary>
/// Creates features for the combined failure mechanism section assembly.
/// </summary>
/// <param name="assessmentSection">The <see cref="AssessmentSection"/> to create the features for.</param>
/// <returns>A collection of <see cref="MapFeature"/>.</returns>
/// <exception cref="ArgumentNullException">Thrown when <paramref name="assessmentSection"/>
/// is <c>null</c>.</exception>
public static IEnumerable<MapFeature> CreateCombinedFailureMechanismSectionAssemblyFeatures(AssessmentSection assessmentSection)
{
if (assessmentSection == null)
{
throw new ArgumentNullException(nameof(assessmentSection));
}
IEnumerable<CombinedFailureMechanismSectionAssemblyResult> assemblyResults;
try
{
assemblyResults = AssessmentSectionAssemblyFactory.AssembleCombinedPerFailureMechanismSection(assessmentSection);
}
catch (AssemblyException)
{
return Array.Empty<MapFeature>();
}
var mapFeatures = new List<MapFeature>();
foreach (CombinedFailureMechanismSectionAssemblyResult assemblyResult in assemblyResults)
{
IEnumerable<Point2D> geometry = FailureMechanismSectionHelper.GetFailureMechanismSectionGeometry(
assessmentSection.ReferenceLine, assemblyResult.SectionStart, assemblyResult.SectionEnd);
MapFeature mapFeature = RiskeerMapDataFeaturesFactory.CreateSingleLineMapFeature(geometry);
mapFeature.MetaData[RiskeerCommonFormsResources.AssemblyGroup_DisplayName] =
EnumDisplayNameHelper.GetDisplayName(assemblyResult.TotalResult);
mapFeatures.Add(mapFeature);
}
return mapFeatures;
}
/// <summary>
/// Creates an <see cref="ExportableAssessmentSectionAssemblyResult"/> with the assembly result
/// based on <paramref name="assessmentSection"/>.
/// </summary>
/// <param name="assessmentSection">The assessment section to create an <see cref="ExportableAssessmentSectionAssemblyResult"/> for.</param>
/// <returns>An <see cref="ExportableAssessmentSectionAssemblyResult"/> with assembly result.</returns>
/// <exception cref="AssemblyException">Thrown when assembly result cannot be created for <paramref name="assessmentSection"/>.</exception>
private static ExportableAssessmentSectionAssemblyResult CreateExportableAssessmentSectionAssemblyResult(AssessmentSection assessmentSection)
{
AssessmentSectionAssemblyResultWrapper assemblyResultWrapper = AssessmentSectionAssemblyFactory.AssembleAssessmentSection(assessmentSection);
AssessmentSectionAssemblyResult assemblyResult = assemblyResultWrapper.AssemblyResult;
return(new ExportableAssessmentSectionAssemblyResult(
assemblyResult.AssemblyGroup, assemblyResult.Probability,
ExportableAssemblyMethodFactory.Create(assemblyResultWrapper.AssemblyGroupMethod),
ExportableAssemblyMethodFactory.Create(assemblyResultWrapper.ProbabilityMethod)));
}
public void AssembleAssessmentSection_AssessmentSectionNull_ThrowsArgumentNullException()
{
// Call
void Call() => AssessmentSectionAssemblyFactory.AssembleAssessmentSection(null);
// Assert
var exception = Assert.Throws <ArgumentNullException>(Call);
Assert.AreEqual("assessmentSection", exception.ParamName);
}
public void GivenViewWithAssemblyResults_WhenFailureMechanismNotifiesObserver_ThenAssemblyResultsRefreshed()
{
// Given
var random = new Random(21);
AssessmentSection assessmentSection = CreateAssessmentSectionWithReferenceLine();
using (new AssemblyToolCalculatorFactoryConfig())
{
var calculatorFactory = (TestAssemblyToolCalculatorFactory)AssemblyToolCalculatorFactory.Instance;
AssessmentSectionAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedAssessmentSectionAssemblyCalculator;
calculator.CombinedFailureMechanismSectionAssemblyOutput = new CombinedFailureMechanismSectionAssemblyResultWrapper(
new[]
{
CombinedFailureMechanismSectionAssemblyTestFactory.Create(assessmentSection, 10)
}, AssemblyMethod.BOI3A1, AssemblyMethod.BOI3B1, AssemblyMethod.BOI3C1);
using (var view = new AssemblyResultPerSectionMapView(assessmentSection))
{
// Precondition
MapDataCollection mapData = view.Map.Data;
var mocks = new MockRepository();
IObserver[] observers = AttachMapDataObservers(mocks, mapData.Collection);
observers[referenceLineIndex].Expect(obs => obs.UpdateObserver());
observers[assemblyResultsObserverIndex].Expect(obs => obs.UpdateObserver());
mocks.ReplayAll();
IEnumerable <CombinedFailureMechanismSectionAssemblyResult> expectedResults =
AssessmentSectionAssemblyFactory.AssembleCombinedPerFailureMechanismSection(assessmentSection);
AssertCombinedFailureMechanismSectionAssemblyResultMapData(expectedResults,
assessmentSection.ReferenceLine,
mapData.Collection.ElementAt(assemblyResultsIndex));
// When
calculator.CombinedFailureMechanismSectionAssemblyOutput = new CombinedFailureMechanismSectionAssemblyResultWrapper(
new[]
{
CombinedFailureMechanismSectionAssemblyTestFactory.Create(assessmentSection, 20)
}, AssemblyMethod.BOI3A1, AssemblyMethod.BOI3B1, AssemblyMethod.BOI3C1);
IEnumerable <IFailureMechanism> failureMechanisms = assessmentSection.GetFailureMechanisms();
failureMechanisms.ElementAt(random.Next(failureMechanisms.Count())).NotifyObservers();
// Then
expectedResults = AssessmentSectionAssemblyFactory.AssembleCombinedPerFailureMechanismSection(assessmentSection);
AssertCombinedFailureMechanismSectionAssemblyResultMapData(expectedResults,
assessmentSection.ReferenceLine,
mapData.Collection.ElementAt(assemblyResultsIndex));
mocks.VerifyAll();
}
}
}
public void CreateCombinedFailureMechanismSectionAssemblyFeatures_WithAssessmentSection_ReturnsFeatureCollection()
{
// Setup
var random = new Random(21);
var assessmentSection = new AssessmentSection(random.NextEnumValue <AssessmentSectionComposition>());
assessmentSection.ReferenceLine.SetGeometry(new[]
{
new Point2D(0, 0),
new Point2D(2, 2)
});
using (new AssemblyToolCalculatorFactoryConfig())
{
var calculatorFactory = (TestAssemblyToolCalculatorFactory)AssemblyToolCalculatorFactory.Instance;
AssessmentSectionAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedAssessmentSectionAssemblyCalculator;
CombinedFailureMechanismSectionAssembly[] failureMechanismSectionAssembly =
{
CombinedFailureMechanismSectionAssemblyTestFactory.Create(assessmentSection, 20),
CombinedFailureMechanismSectionAssemblyTestFactory.Create(assessmentSection, 21)
};
calculator.CombinedFailureMechanismSectionAssemblyOutput = new CombinedFailureMechanismSectionAssemblyResultWrapper(
failureMechanismSectionAssembly, AssemblyMethod.BOI3A1, AssemblyMethod.BOI3B1, AssemblyMethod.BOI3C1);
// Call
IEnumerable <MapFeature> features = AssessmentSectionAssemblyMapDataFeaturesFactory.CreateCombinedFailureMechanismSectionAssemblyFeatures(assessmentSection);
// Assert
IEnumerable <CombinedFailureMechanismSectionAssemblyResult> expectedAssemblyResults =
AssessmentSectionAssemblyFactory.AssembleCombinedPerFailureMechanismSection(assessmentSection);
int expectedNrOfResults = expectedAssemblyResults.Count();
Assert.AreEqual(expectedNrOfResults, features.Count());
for (var i = 0; i < expectedNrOfResults; i++)
{
CombinedFailureMechanismSectionAssemblyResult expectedAssemblyResult = expectedAssemblyResults.ElementAt(i);
MapFeature actualFeature = features.ElementAt(i);
MapGeometry mapGeometry = actualFeature.MapGeometries.Single();
AssertEqualPointCollections(assessmentSection.ReferenceLine,
expectedAssemblyResult,
mapGeometry);
Assert.AreEqual(1, actualFeature.MetaData.Keys.Count);
Assert.AreEqual(EnumDisplayNameHelper.GetDisplayName(expectedAssemblyResult.TotalResult),
features.ElementAt(i).MetaData["Duidingsklasse"]);
}
}
}
private void UpdateTotalAssemblyGroupControl()
{
assessmentSectionAssemblyControl.ClearAssemblyResult();
assessmentSectionAssemblyControl.ClearErrors();
try
{
assessmentSectionAssemblyControl.SetAssemblyResult(
AssessmentSectionAssemblyFactory.AssembleAssessmentSection(AssessmentSection).AssemblyResult);
}
catch (AssemblyException e)
{
assessmentSectionAssemblyControl.SetError(e.Message);
}
}
public void AssembleAssessmentSection_AssemblyRan_ReturnsOutput()
{
// Setup
AssessmentSection assessmentSection = CreateAssessmentSectionContainingFailureMechanismsWithInAssemblyTrue();
using (new AssemblyToolCalculatorFactoryConfig())
{
var calculatorFactory = (TestAssemblyToolCalculatorFactory)AssemblyToolCalculatorFactory.Instance;
AssessmentSectionAssemblyCalculatorStub assessmentSectionAssemblyCalculator = calculatorFactory.LastCreatedAssessmentSectionAssemblyCalculator;
// Call
AssessmentSectionAssemblyResultWrapper result = AssessmentSectionAssemblyFactory.AssembleAssessmentSection(assessmentSection);
// Assert
Assert.AreSame(assessmentSectionAssemblyCalculator.AssessmentSectionAssemblyResult, result);
}
}
public void Constructor_WithAllData_DataUpdatedToCollectionOfFilledMapData()
{
// Setup
AssessmentSection assessmentSection = CreateAssessmentSectionWithReferenceLine();
assessmentSection.SetHydraulicBoundaryLocationCalculations(new[]
{
new HydraulicBoundaryLocation(1, "test", 1.0, 2.0)
});
// Call
using (new AssemblyToolCalculatorFactoryConfig())
{
var calculatorFactory = (TestAssemblyToolCalculatorFactory)AssemblyToolCalculatorFactory.Instance;
AssessmentSectionAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedAssessmentSectionAssemblyCalculator;
CombinedFailureMechanismSectionAssembly[] failureMechanismSectionAssembly =
{
CombinedFailureMechanismSectionAssemblyTestFactory.Create(assessmentSection, 21)
};
calculator.CombinedFailureMechanismSectionAssemblyOutput = new CombinedFailureMechanismSectionAssemblyResultWrapper(
failureMechanismSectionAssembly, AssemblyMethod.BOI3A1, AssemblyMethod.BOI3B1, AssemblyMethod.BOI3C1);
using (var view = new AssemblyResultPerSectionMapView(assessmentSection))
{
// Assert
Assert.IsInstanceOf <MapDataCollection>(view.Map.Data);
MapDataCollection mapData = view.Map.Data;
Assert.IsNotNull(mapData);
Assert.AreEqual(3, mapData.Collection.Count());
IEnumerable <CombinedFailureMechanismSectionAssemblyResult> expectedResults =
AssessmentSectionAssemblyFactory.AssembleCombinedPerFailureMechanismSection(assessmentSection);
AssertCombinedFailureMechanismSectionAssemblyResultMapData(expectedResults,
assessmentSection.ReferenceLine,
mapData.Collection.ElementAt(assemblyResultsIndex));
MapData hydraulicBoundaryLocationsMapData = mapData.Collection.ElementAt(hydraulicBoundaryLocationsIndex);
MapDataTestHelper.AssertHydraulicBoundaryLocationsMapData(assessmentSection, hydraulicBoundaryLocationsMapData);
MapData referenceLineMapData = mapData.Collection.ElementAt(referenceLineIndex);
AssertReferenceLineMapData(assessmentSection.ReferenceLine, referenceLineMapData);
}
}
}
public void AssembleAssessmentSection_FailureMechanismCalculatorThrowsException_ThrowsAssemblyException()
{
// Setup
using (new AssemblyToolCalculatorFactoryConfig())
{
var calculatorFactory = (TestAssemblyToolCalculatorFactory)AssemblyToolCalculatorFactory.Instance;
FailureMechanismAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedFailureMechanismAssemblyCalculator;
calculator.ThrowExceptionOnCalculate = true;
// Call
void Call() => AssessmentSectionAssemblyFactory.AssembleAssessmentSection(CreateAssessmentSectionContainingFailureMechanismsWithInAssemblyTrue());
// Assert
var exception = Assert.Throws <AssemblyException>(Call);
Exception innerException = exception.InnerException;
Assert.IsInstanceOf <AssemblyException>(innerException);
Assert.AreEqual("Voor een of meerdere faalmechanismen kan geen assemblageresultaat worden bepaald.", exception.Message);
}
}
public void AssembleAssessmentSection_CalculatorThrowsException_ThrowsAssemblyException()
{
// Setup
using (new AssemblyToolCalculatorFactoryConfig())
{
var calculatorFactory = (TestAssemblyToolCalculatorFactory)AssemblyToolCalculatorFactory.Instance;
AssessmentSectionAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedAssessmentSectionAssemblyCalculator;
calculator.ThrowExceptionOnCalculate = true;
// Call
void Call() => AssessmentSectionAssemblyFactory.AssembleAssessmentSection(CreateAssessmentSectionContainingFailureMechanismsWithInAssemblyTrue());
// Assert
var exception = Assert.Throws <AssemblyException>(Call);
Exception innerException = exception.InnerException;
Assert.IsInstanceOf <AssessmentSectionAssemblyCalculatorException>(innerException);
Assert.AreEqual(innerException.Message, exception.Message);
}
}
private void SetDataSource()
{
ClearCurrentData();
if (!AssessmentSection.ReferenceLine.Points.Any())
{
return;
}
try
{
dataGridViewControl.SetDataSource(AssessmentSectionAssemblyFactory.AssembleCombinedPerFailureMechanismSection(AssessmentSection)
.Select(r => new CombinedFailureMechanismSectionAssemblyResultRow(r))
.ToArray());
}
catch (AssemblyException e)
{
errorProvider.SetError(refreshAssemblyResultsButton, e.Message);
}
}
public void AssembleCombinedPerFailureMechanismSection_CalculatorThrowsException_ThrowsAssemblyException()
{
// Setup
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.ThrowExceptionOnCalculate = true;
// Call
void Call() => AssessmentSectionAssemblyFactory.AssembleCombinedPerFailureMechanismSection(assessmentSection);
// Assert
var exception = Assert.Throws <AssemblyException>(Call);
Exception innerException = exception.InnerException;
Assert.IsInstanceOf <AssessmentSectionAssemblyCalculatorException>(innerException);
Assert.AreEqual(innerException.Message, exception.Message);
}
}
public void AssembleCombinedPerFailureMechanismSection_WithAssessmentSection_SetsInputOnCalculator(bool failureMechanismSectionAssemblyThrowsException)
{
var random = new Random(21);
AssessmentSection assessmentSection = TestDataGenerator.GetAssessmentSectionWithAllFailureMechanismSectionsAndResults(
random.NextEnumValue <AssessmentSectionComposition>());
using (new AssemblyToolCalculatorFactoryConfig())
{
var calculatorFactory = (TestAssemblyToolCalculatorFactory)AssemblyToolCalculatorFactory.Instance;
FailureMechanismSectionAssemblyCalculatorStub failureMechanismSectionAssemblyCalculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator;
failureMechanismSectionAssemblyCalculator.ThrowExceptionOnCalculate = failureMechanismSectionAssemblyThrowsException;
// Call
AssessmentSectionAssemblyFactory.AssembleCombinedPerFailureMechanismSection(assessmentSection);
// Assert
AssessmentSectionAssemblyCalculatorStub assessmentSectionAssemblyCalculator = calculatorFactory.LastCreatedAssessmentSectionAssemblyCalculator;
IEnumerable <CombinedAssemblyFailureMechanismSection>[] actualInput = assessmentSectionAssemblyCalculator.CombinedFailureMechanismSectionsInput.ToArray();
IEnumerable <CombinedAssemblyFailureMechanismSection>[] expectedInput = CombinedAssemblyFailureMechanismSectionFactory.CreateInput(
assessmentSection, assessmentSection.GetFailureMechanisms().Concat(assessmentSection.SpecificFailureMechanisms)).ToArray();
Assert.AreEqual(expectedInput.Length, actualInput.Length);
for (var i = 0; i < expectedInput.Length; i++)
{
CombinedAssemblyFailureMechanismSection[] actualSections = actualInput[i].ToArray();
CombinedAssemblyFailureMechanismSection[] expectedSections = expectedInput[i].ToArray();
Assert.AreEqual(expectedSections.Length, actualSections.Length);
for (var j = 0; j < expectedSections.Length; j++)
{
Assert.AreEqual(expectedSections[j].SectionStart, actualSections[j].SectionStart);
Assert.AreEqual(expectedSections[j].SectionEnd, actualSections[j].SectionEnd);
Assert.AreEqual(expectedSections[j].FailureMechanismSectionAssemblyGroup, actualSections[j].FailureMechanismSectionAssemblyGroup);
}
}
}
}
/// <summary>
/// Creates a collection of <see cref="ExportableCombinedSectionAssembly"/> based on <paramref name="assessmentSection"/>.
/// </summary>
/// <param name="assessmentSection">The assessment section to create a collection of <see cref="ExportableCombinedSectionAssembly"/> for.</param>
/// <returns>A <see cref="CreateExportableCombinedSectionAssemblyCollection"/>.</returns>
/// <exception cref="AssemblyException">Thrown when assembly results cannot be created for <paramref name="assessmentSection"/>.</exception>
private static IEnumerable <ExportableCombinedSectionAssembly> CreateExportableCombinedSectionAssemblyCollection(AssessmentSection assessmentSection)
{
return(ExportableCombinedSectionAssemblyFactory.CreateExportableCombinedSectionAssemblyCollection(
AssessmentSectionAssemblyFactory.AssembleCombinedPerFailureMechanismSection(assessmentSection),
assessmentSection));
}
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);
}
}
}
