public void IsEnabled_ReferenceLineWithGeometry_ReturnTrue()
{
// Setup
var mocks = new MockRepository();
var assessmentSection = mocks.Stub <IAssessmentSection>();
assessmentSection.Stub(a => a.ReferenceLine).Return(ReferenceLineTestFactory.CreateReferenceLineWithGeometry());
mocks.ReplayAll();
var failureMechanism = new HeightStructuresFailureMechanism();
var context = new HeightStructuresContext(failureMechanism.HeightStructures,
failureMechanism, assessmentSection);
using (var plugin = new HeightStructuresPlugin())
{
ImportInfo importInfo = GetImportInfo(plugin);
// Call
bool isEnabled = importInfo.IsEnabled(context);
// Assert
Assert.IsTrue(isEnabled);
}
mocks.VerifyAll();
}
public void DoPostImportUpdates_CancelingImport_DoNotNotifyObserversAndNotDoPostReplacementUpdates()
{
// Setup
string path = TestHelper.GetTestDataPath(TestDataPath.Riskeer.Common.IO, "traject_10-2.shp");
ReferenceLine referenceLine = ReferenceLineTestFactory.CreateReferenceLineWithGeometry();
var mocks = new MockRepository();
var observer = mocks.StrictMock <IObserver>();
var handler = mocks.StrictMock <IReferenceLineUpdateHandler>();
var importer = new ReferenceLineImporter(referenceLine, handler, path);
handler.Expect(h => h.ConfirmUpdate())
.WhenCalled(invocation => importer.Cancel())
.Return(true);
mocks.ReplayAll();
referenceLine.Attach(observer);
// Precondition
Assert.IsFalse(importer.Import());
// Call
importer.DoPostImport();
// Assert
mocks.VerifyAll(); // Expect no NotifyObserver calls
}
public void Constructor_ReferenceLineWithGeometry_PropertiesHaveExpectedAttributeValues()
{
// Call
var properties = new ReferenceLineProperties(ReferenceLineTestFactory.CreateReferenceLineWithGeometry());
// Assert
PropertyDescriptorCollection dynamicProperties = PropertiesTestHelper.GetAllVisiblePropertyDescriptors(properties);
Assert.AreEqual(2, dynamicProperties.Count);
const string generalCategoryName = "Algemeen";
PropertyDescriptor lengthProperty = dynamicProperties[0];
PropertiesTestHelper.AssertRequiredPropertyDescriptorProperties(lengthProperty,
generalCategoryName,
"Lengte* [m]",
"Totale lengte van het traject in meters (afgerond).",
true);
PropertyDescriptor geometryProperty = dynamicProperties[1];
PropertiesTestHelper.AssertRequiredPropertyDescriptorProperties(geometryProperty,
generalCategoryName,
"Coördinaten",
"Lijst van alle coördinaten (X-coördinaat, Y-coördinaat) " +
"die samen de referentielijn vormen.",
true);
}
public void DoPostImportUpdates_ReferenceLineHasGeometryAndAnswerDialogToContinue_NotifyObserversOfTargetAndClearedObjects()
{
// Setup
string path = TestHelper.GetTestDataPath(TestDataPath.Riskeer.Common.IO, Path.Combine("ReferenceLine", "traject_10-2.shp"));
ReferenceLine referenceLine = ReferenceLineTestFactory.CreateReferenceLineWithGeometry();
var mocks = new MockRepository();
var referenceLineObserver = mocks.Stub <IObserver>();
referenceLineObserver.Expect(o => o.UpdateObserver());
var observable1 = mocks.StrictMock <IObservable>();
observable1.Expect(o => o.NotifyObservers());
var observable2 = mocks.StrictMock <IObservable>();
observable2.Expect(o => o.NotifyObservers());
var handler = mocks.StrictMock <IReferenceLineUpdateHandler>();
handler.Expect(h => h.ConfirmUpdate()).Return(true);
handler.Expect(h => h.Update(Arg <ReferenceLine> .Is.Same(referenceLine),
Arg <ReferenceLine> .Is.NotNull))
.Return(new[]
{
observable1,
observable2
});
handler.Expect(h => h.DoPostUpdateActions());
mocks.ReplayAll();
referenceLine.Attach(referenceLineObserver);
var importer = new ReferenceLineImporter(referenceLine, handler, path);
// Precondition
Assert.IsTrue(importer.Import());
// Call
importer.DoPostImport();
// Assert
mocks.VerifyAll(); // Expect NotifyObservers on cleared calculations
}
public void IsEnabled_ReferenceLineWithGeometry_ReturnTrue()
{
// Setup
var mocks = new MockRepository();
var failureMechanism = mocks.Stub <IFailureMechanism <FailureMechanismSectionResult> >();
var assessmentSection = mocks.Stub <IAssessmentSection>();
assessmentSection.Stub(a => a.ReferenceLine).Return(ReferenceLineTestFactory.CreateReferenceLineWithGeometry());
mocks.ReplayAll();
var context = new FailureMechanismSectionsContext(failureMechanism, assessmentSection);
// Call
bool isEnabled = importInfo.IsEnabled(context);
// Assert
Assert.IsTrue(isEnabled);
mocks.VerifyAll();
}
public void GivenReferenceLineWithGeometry_WhenCancelingReferenceLineImport_ThenKeepOriginalReferenceLine()
{
// Given
var mocks = new MockRepository();
var viewCommands = mocks.Stub <IViewCommands>();
mocks.ReplayAll();
var assessmentSection = new AssessmentSection(AssessmentSectionComposition.Dike);
ReferenceLineTestFactory.SetReferenceLineGeometry(assessmentSection.ReferenceLine);
Point2D[] originalReferenceLineGeometry = assessmentSection.ReferenceLine.Points.ToArray();
var handler = new ReferenceLineUpdateHandler(assessmentSection, viewCommands);
string path = TestHelper.GetTestDataPath(TestDataPath.Riskeer.Common.IO, "traject_10-2.shp");
var importer = new ReferenceLineImporter(assessmentSection.ReferenceLine, handler, path);
string messageBoxTitle = null, messageBoxText = null;
DialogBoxHandler = (name, wnd) =>
{
var messageBoxTester = new MessageBoxTester(wnd);
messageBoxTitle = messageBoxTester.Title;
messageBoxText = messageBoxTester.Text;
messageBoxTester.ClickCancel();
};
// When
bool importSuccessful = importer.Import();
// Then
Assert.IsFalse(importSuccessful);
CollectionAssert.AreEqual(originalReferenceLineGeometry, assessmentSection.ReferenceLine.Points);
Assert.AreEqual("Bevestigen", messageBoxTitle);
string expectedText = "Na het importeren van een aangepaste ligging van de referentielijn zullen alle geïmporteerde en berekende gegevens van alle faalmechanismen worden gewist." + Environment.NewLine +
Environment.NewLine + "Wilt u doorgaan?";
Assert.AreEqual(expectedText, messageBoxText);
mocks.VerifyAll();
}
public void IsEnabled_ReferenceLineWithGeometry_ReturnTrue()
{
// Setup
var mocks = new MockRepository();
var assessmentSection = mocks.Stub <IAssessmentSection>();
assessmentSection.Stub(a => a.ReferenceLine).Return(ReferenceLineTestFactory.CreateReferenceLineWithGeometry());
mocks.ReplayAll();
var failureMechanism = new MacroStabilityInwardsFailureMechanism();
var context = new MacroStabilityInwardsStochasticSoilModelCollectionContext(failureMechanism.StochasticSoilModels, failureMechanism, assessmentSection);
// Call
bool isEnabled = importInfo.IsEnabled(context);
// Assert
Assert.IsTrue(isEnabled);
mocks.VerifyAll();
}
public void IsEnabled_ReferenceLineWithGeometry_ReturnTrue()
{
// Setup
var mocks = new MockRepository();
var inquiryHelper = mocks.Stub <IInquiryHelper>();
var assessmentSection = mocks.Stub <IAssessmentSection>();
assessmentSection.Stub(a => a.ReferenceLine).Return(ReferenceLineTestFactory.CreateReferenceLineWithGeometry());
mocks.ReplayAll();
var context = new PipingFailureMechanismSectionsContext(new PipingFailureMechanism(), assessmentSection);
ImportInfo <PipingFailureMechanismSectionsContext> importInfo = GetImportInfo(inquiryHelper);
// Call
bool isEnabled = importInfo.IsEnabled(context);
// Assert
Assert.IsTrue(isEnabled);
mocks.VerifyAll();
}
public void ForeColor_ContextHasReferenceLineWithGeometry_ReturnControlText()
{
// Setup
var assessmentSection = mocks.Stub <IAssessmentSection>();
mocks.ReplayAll();
var referenceLineContext = new ReferenceLineContext(ReferenceLineTestFactory.CreateReferenceLineWithGeometry(),
assessmentSection);
using (var plugin = new RiskeerPlugin())
{
TreeNodeInfo info = GetInfo(plugin);
// Call
Color color = info.ForeColor(referenceLineContext);
// Assert
Assert.AreEqual(Color.FromKnownColor(KnownColor.ControlText), color);
}
mocks.VerifyAll();
}
public void Import_CancelImportDuringDialogInteraction_GenerateCanceledLogMessageAndReturnsFalse()
{
// Setup
var mocks = new MockRepository();
var handler = mocks.StrictMock <IReferenceLineUpdateHandler>();
handler.Expect(h => h.ConfirmUpdate()).Return(false);
mocks.ReplayAll();
string path = TestHelper.GetTestDataPath(TestDataPath.Riskeer.Common.IO, "traject_10-2.shp");
var importer = new ReferenceLineImporter(ReferenceLineTestFactory.CreateReferenceLineWithGeometry(), handler, path);
var importResult = true;
// Call
Action call = () => importResult = importer.Import();
// Assert
TestHelper.AssertLogMessageIsGenerated(call, "Referentielijn importeren afgebroken. Geen gegevens gewijzigd.", 1);
Assert.IsFalse(importResult);
mocks.VerifyAll();
}
public void IsEnabled_ReferenceLineWithGeometry_ReturnTrue()
{
// Setup
var mocks = new MockRepository();
var assessmentSection = mocks.Stub <IAssessmentSection>();
assessmentSection.Stub(a => a.ReferenceLine).Return(ReferenceLineTestFactory.CreateReferenceLineWithGeometry());
mocks.ReplayAll();
var context = new ReferenceLineContext(assessmentSection.ReferenceLine, assessmentSection);
using (var plugin = new RiskeerPlugin())
{
ExportInfo info = GetExportInfo(plugin);
// Call
bool isEnabled = info.IsEnabled(context);
// Assert
Assert.IsTrue(isEnabled);
}
mocks.VerifyAll();
}
public void Update_FullyConfiguredAssessmentSection_AllReferenceLineDependentDataCleared()
{
// Setup
var mocks = new MockRepository();
var viewCommands = mocks.Stub <IViewCommands>();
mocks.ReplayAll();
AssessmentSection assessmentSection = TestDataGenerator.GetAssessmentSectionWithAllCalculationConfigurations();
var handler = new ReferenceLineUpdateHandler(assessmentSection, viewCommands);
ReferenceLine referenceLine = ReferenceLineTestFactory.CreateReferenceLineWithGeometry();
// Call
IObservable[] observables = handler.Update(assessmentSection.ReferenceLine, referenceLine).ToArray();
// Assert
Assert.AreEqual(56, observables.Length);
PipingFailureMechanism pipingFailureMechanism = assessmentSection.Piping;
CollectionAssert.IsEmpty(pipingFailureMechanism.Sections);
CollectionAssert.IsEmpty(pipingFailureMechanism.SectionResults);
CollectionAssert.IsEmpty(pipingFailureMechanism.ScenarioConfigurationsPerFailureMechanismSection);
CollectionAssert.Contains(observables, pipingFailureMechanism);
CollectionAssert.Contains(observables, pipingFailureMechanism.SectionResults);
CollectionAssert.Contains(observables, pipingFailureMechanism.ScenarioConfigurationsPerFailureMechanismSection);
CollectionAssert.IsEmpty(pipingFailureMechanism.CalculationsGroup.Children);
CollectionAssert.Contains(observables, pipingFailureMechanism.CalculationsGroup);
CollectionAssert.IsEmpty(pipingFailureMechanism.StochasticSoilModels);
CollectionAssert.Contains(observables, pipingFailureMechanism.StochasticSoilModels);
CollectionAssert.IsEmpty(pipingFailureMechanism.SurfaceLines);
CollectionAssert.Contains(observables, pipingFailureMechanism.SurfaceLines);
GrassCoverErosionInwardsFailureMechanism grassCoverErosionInwardsFailureMechanism = assessmentSection.GrassCoverErosionInwards;
CollectionAssert.IsEmpty(grassCoverErosionInwardsFailureMechanism.Sections);
CollectionAssert.IsEmpty(grassCoverErosionInwardsFailureMechanism.SectionResults);
CollectionAssert.Contains(observables, grassCoverErosionInwardsFailureMechanism);
CollectionAssert.Contains(observables, grassCoverErosionInwardsFailureMechanism.SectionResults);
CollectionAssert.IsEmpty(grassCoverErosionInwardsFailureMechanism.CalculationsGroup.Children);
CollectionAssert.Contains(observables, grassCoverErosionInwardsFailureMechanism.CalculationsGroup);
CollectionAssert.IsEmpty(grassCoverErosionInwardsFailureMechanism.DikeProfiles);
CollectionAssert.Contains(observables, grassCoverErosionInwardsFailureMechanism.DikeProfiles);
GrassCoverErosionOutwardsFailureMechanism grassCoverErosionOutwardsFailureMechanism = assessmentSection.GrassCoverErosionOutwards;
CollectionAssert.IsEmpty(grassCoverErosionOutwardsFailureMechanism.Sections);
CollectionAssert.IsEmpty(grassCoverErosionOutwardsFailureMechanism.SectionResults);
CollectionAssert.Contains(observables, grassCoverErosionOutwardsFailureMechanism);
CollectionAssert.Contains(observables, grassCoverErosionOutwardsFailureMechanism.SectionResults);
CollectionAssert.IsEmpty(grassCoverErosionOutwardsFailureMechanism.CalculationsGroup.Children);
CollectionAssert.Contains(observables, grassCoverErosionOutwardsFailureMechanism.CalculationsGroup);
CollectionAssert.IsEmpty(grassCoverErosionOutwardsFailureMechanism.ForeshoreProfiles);
CollectionAssert.Contains(observables, grassCoverErosionOutwardsFailureMechanism.ForeshoreProfiles);
WaveImpactAsphaltCoverFailureMechanism waveImpactAsphaltCoverFailureMechanism = assessmentSection.WaveImpactAsphaltCover;
CollectionAssert.IsEmpty(waveImpactAsphaltCoverFailureMechanism.Sections);
CollectionAssert.IsEmpty(waveImpactAsphaltCoverFailureMechanism.SectionResults);
CollectionAssert.Contains(observables, waveImpactAsphaltCoverFailureMechanism);
CollectionAssert.Contains(observables, waveImpactAsphaltCoverFailureMechanism.SectionResults);
CollectionAssert.IsEmpty(waveImpactAsphaltCoverFailureMechanism.CalculationsGroup.Children);
CollectionAssert.Contains(observables, waveImpactAsphaltCoverFailureMechanism.CalculationsGroup);
CollectionAssert.IsEmpty(waveImpactAsphaltCoverFailureMechanism.ForeshoreProfiles);
CollectionAssert.Contains(observables, waveImpactAsphaltCoverFailureMechanism.ForeshoreProfiles);
StabilityStoneCoverFailureMechanism stabilityStoneCoverFailureMechanism = assessmentSection.StabilityStoneCover;
CollectionAssert.IsEmpty(stabilityStoneCoverFailureMechanism.Sections);
CollectionAssert.IsEmpty(stabilityStoneCoverFailureMechanism.SectionResults);
CollectionAssert.Contains(observables, stabilityStoneCoverFailureMechanism);
CollectionAssert.Contains(observables, stabilityStoneCoverFailureMechanism.SectionResults);
CollectionAssert.IsEmpty(stabilityStoneCoverFailureMechanism.CalculationsGroup.Children);
CollectionAssert.Contains(observables, stabilityStoneCoverFailureMechanism.CalculationsGroup);
CollectionAssert.IsEmpty(stabilityStoneCoverFailureMechanism.ForeshoreProfiles);
CollectionAssert.Contains(observables, stabilityStoneCoverFailureMechanism.ForeshoreProfiles);
ClosingStructuresFailureMechanism closingStructuresFailureMechanism = assessmentSection.ClosingStructures;
CollectionAssert.IsEmpty(closingStructuresFailureMechanism.Sections);
CollectionAssert.IsEmpty(closingStructuresFailureMechanism.SectionResults);
CollectionAssert.Contains(observables, closingStructuresFailureMechanism);
CollectionAssert.Contains(observables, closingStructuresFailureMechanism.SectionResults);
CollectionAssert.IsEmpty(closingStructuresFailureMechanism.CalculationsGroup.Children);
CollectionAssert.Contains(observables, closingStructuresFailureMechanism.CalculationsGroup);
CollectionAssert.IsEmpty(closingStructuresFailureMechanism.ForeshoreProfiles);
CollectionAssert.Contains(observables, closingStructuresFailureMechanism.ForeshoreProfiles);
CollectionAssert.IsEmpty(closingStructuresFailureMechanism.ClosingStructures);
CollectionAssert.Contains(observables, closingStructuresFailureMechanism.ClosingStructures);
HeightStructuresFailureMechanism heightStructuresFailureMechanism = assessmentSection.HeightStructures;
CollectionAssert.IsEmpty(heightStructuresFailureMechanism.Sections);
CollectionAssert.IsEmpty(heightStructuresFailureMechanism.SectionResults);
CollectionAssert.Contains(observables, heightStructuresFailureMechanism);
CollectionAssert.Contains(observables, heightStructuresFailureMechanism.SectionResults);
CollectionAssert.IsEmpty(heightStructuresFailureMechanism.CalculationsGroup.Children);
CollectionAssert.Contains(observables, heightStructuresFailureMechanism.CalculationsGroup);
CollectionAssert.IsEmpty(heightStructuresFailureMechanism.ForeshoreProfiles);
CollectionAssert.Contains(observables, heightStructuresFailureMechanism.ForeshoreProfiles);
CollectionAssert.IsEmpty(heightStructuresFailureMechanism.HeightStructures);
CollectionAssert.Contains(observables, heightStructuresFailureMechanism.HeightStructures);
StabilityPointStructuresFailureMechanism stabilityPointStructuresFailureMechanism = assessmentSection.StabilityPointStructures;
CollectionAssert.IsEmpty(stabilityPointStructuresFailureMechanism.Sections);
CollectionAssert.IsEmpty(stabilityPointStructuresFailureMechanism.SectionResults);
CollectionAssert.Contains(observables, stabilityPointStructuresFailureMechanism);
CollectionAssert.Contains(observables, stabilityPointStructuresFailureMechanism.SectionResults);
CollectionAssert.IsEmpty(stabilityPointStructuresFailureMechanism.CalculationsGroup.Children);
CollectionAssert.Contains(observables, stabilityPointStructuresFailureMechanism.CalculationsGroup);
CollectionAssert.IsEmpty(stabilityPointStructuresFailureMechanism.ForeshoreProfiles);
CollectionAssert.Contains(observables, stabilityPointStructuresFailureMechanism.ForeshoreProfiles);
CollectionAssert.IsEmpty(stabilityPointStructuresFailureMechanism.StabilityPointStructures);
CollectionAssert.Contains(observables, stabilityPointStructuresFailureMechanism.StabilityPointStructures);
DuneErosionFailureMechanism duneErosionFailureMechanism = assessmentSection.DuneErosion;
CollectionAssert.IsEmpty(duneErosionFailureMechanism.Sections);
CollectionAssert.IsEmpty(duneErosionFailureMechanism.SectionResults);
CollectionAssert.Contains(observables, duneErosionFailureMechanism);
CollectionAssert.Contains(observables, duneErosionFailureMechanism.SectionResults);
MacroStabilityInwardsFailureMechanism macroStabilityInwardsFailureMechanism = assessmentSection.MacroStabilityInwards;
CollectionAssert.IsEmpty(macroStabilityInwardsFailureMechanism.Sections);
CollectionAssert.IsEmpty(macroStabilityInwardsFailureMechanism.SectionResults);
CollectionAssert.Contains(observables, macroStabilityInwardsFailureMechanism);
CollectionAssert.Contains(observables, macroStabilityInwardsFailureMechanism.SectionResults);
CollectionAssert.IsEmpty(macroStabilityInwardsFailureMechanism.CalculationsGroup.Children);
CollectionAssert.Contains(observables, macroStabilityInwardsFailureMechanism.CalculationsGroup);
CollectionAssert.IsEmpty(macroStabilityInwardsFailureMechanism.StochasticSoilModels);
CollectionAssert.Contains(observables, macroStabilityInwardsFailureMechanism.StochasticSoilModels);
CollectionAssert.IsEmpty(macroStabilityInwardsFailureMechanism.SurfaceLines);
CollectionAssert.Contains(observables, macroStabilityInwardsFailureMechanism.SurfaceLines);
MicrostabilityFailureMechanism microstabilityFailureMechanism = assessmentSection.Microstability;
CollectionAssert.IsEmpty(microstabilityFailureMechanism.Sections);
CollectionAssert.IsEmpty(microstabilityFailureMechanism.SectionResults);
CollectionAssert.Contains(observables, microstabilityFailureMechanism);
CollectionAssert.Contains(observables, microstabilityFailureMechanism.SectionResults);
WaterPressureAsphaltCoverFailureMechanism waterPressureAsphaltCoverFailureMechanism = assessmentSection.WaterPressureAsphaltCover;
CollectionAssert.IsEmpty(waterPressureAsphaltCoverFailureMechanism.Sections);
CollectionAssert.IsEmpty(waterPressureAsphaltCoverFailureMechanism.SectionResults);
CollectionAssert.Contains(observables, waterPressureAsphaltCoverFailureMechanism);
CollectionAssert.Contains(observables, waterPressureAsphaltCoverFailureMechanism.SectionResults);
GrassCoverSlipOffOutwardsFailureMechanism grassCoverSlipOffOutwardsFailureMechanism = assessmentSection.GrassCoverSlipOffOutwards;
CollectionAssert.IsEmpty(grassCoverSlipOffOutwardsFailureMechanism.Sections);
CollectionAssert.IsEmpty(grassCoverSlipOffOutwardsFailureMechanism.SectionResults);
CollectionAssert.Contains(observables, grassCoverSlipOffOutwardsFailureMechanism);
CollectionAssert.Contains(observables, grassCoverSlipOffOutwardsFailureMechanism.SectionResults);
GrassCoverSlipOffInwardsFailureMechanism grassCoverSlipOffInwardsFailureMechanism = assessmentSection.GrassCoverSlipOffInwards;
CollectionAssert.IsEmpty(grassCoverSlipOffInwardsFailureMechanism.Sections);
CollectionAssert.IsEmpty(grassCoverSlipOffInwardsFailureMechanism.SectionResults);
CollectionAssert.Contains(observables, grassCoverSlipOffInwardsFailureMechanism);
CollectionAssert.Contains(observables, grassCoverSlipOffInwardsFailureMechanism.SectionResults);
PipingStructureFailureMechanism pipingStructureFailureMechanism = assessmentSection.PipingStructure;
CollectionAssert.IsEmpty(pipingStructureFailureMechanism.Sections);
CollectionAssert.IsEmpty(pipingStructureFailureMechanism.SectionResults);
CollectionAssert.Contains(observables, pipingStructureFailureMechanism);
CollectionAssert.Contains(observables, pipingStructureFailureMechanism.SectionResults);
CollectionAssert.AreEqual(referenceLine.Points, assessmentSection.ReferenceLine.Points);
SpecificFailureMechanism failureMechanism = assessmentSection.SpecificFailureMechanisms.First();
CollectionAssert.IsEmpty(failureMechanism.Sections);
CollectionAssert.IsEmpty(failureMechanism.SectionResults);
CollectionAssert.Contains(observables, failureMechanism);
CollectionAssert.Contains(observables, failureMechanism.SectionResults);
mocks.VerifyAll();
}
public void CreateExportableAssessmentSection_WithAssessmentSectionWithReferenceLine_ReturnsExpectedValues()
{
// Setup
const string name = "assessmentSectionName";
const string id = "assessmentSectionId";
var random = new Random(21);
var assessmentSection = new AssessmentSection(random.NextEnumValue <AssessmentSectionComposition>())
{
Name = name,
Id = id
};
ReferenceLineTestFactory.SetReferenceLineGeometry(assessmentSection.ReferenceLine);
assessmentSection.SpecificFailureMechanisms.Add(new SpecificFailureMechanism());
assessmentSection.SpecificFailureMechanisms.Add(new SpecificFailureMechanism());
FailureMechanismTestHelper.AddSections(assessmentSection.Piping, random.Next(1, 10));
FailureMechanismTestHelper.AddSections(assessmentSection.MacroStabilityInwards, random.Next(1, 10));
FailureMechanismTestHelper.AddSections(assessmentSection.GrassCoverErosionInwards, random.Next(1, 10));
FailureMechanismTestHelper.AddSections(assessmentSection.HeightStructures, random.Next(1, 10));
FailureMechanismTestHelper.AddSections(assessmentSection.ClosingStructures, random.Next(1, 10));
FailureMechanismTestHelper.AddSections(assessmentSection.StabilityPointStructures, random.Next(1, 10));
FailureMechanismTestHelper.AddSections(assessmentSection.StabilityStoneCover, random.Next(1, 10));
FailureMechanismTestHelper.AddSections(assessmentSection.WaveImpactAsphaltCover, random.Next(1, 10));
FailureMechanismTestHelper.AddSections(assessmentSection.GrassCoverErosionOutwards, random.Next(1, 10));
FailureMechanismTestHelper.AddSections(assessmentSection.DuneErosion, random.Next(1, 10));
FailureMechanismTestHelper.AddSections(assessmentSection.Microstability, random.Next(1, 10));
FailureMechanismTestHelper.AddSections(assessmentSection.GrassCoverSlipOffOutwards, random.Next(1, 10));
FailureMechanismTestHelper.AddSections(assessmentSection.GrassCoverSlipOffInwards, random.Next(1, 10));
FailureMechanismTestHelper.AddSections(assessmentSection.PipingStructure, random.Next(1, 10));
FailureMechanismTestHelper.AddSections(assessmentSection.WaterPressureAsphaltCover, random.Next(1, 10));
FailureMechanismTestHelper.AddSections(assessmentSection.SpecificFailureMechanisms.First(), random.Next(1, 10));
FailureMechanismTestHelper.AddSections(assessmentSection.SpecificFailureMechanisms.Last(), random.Next(1, 10));
using (new AssemblyToolCalculatorFactoryConfig())
{
// Call
ExportableAssessmentSection exportableAssessmentSection = ExportableAssessmentSectionFactory.CreateExportableAssessmentSection(assessmentSection);
// Assert
Assert.AreEqual(name, exportableAssessmentSection.Name);
Assert.AreEqual(id, exportableAssessmentSection.Id);
CollectionAssert.AreEqual(assessmentSection.ReferenceLine.Points, exportableAssessmentSection.Geometry);
ExportableAssessmentSectionAssemblyResult exportableAssessmentSectionAssemblyResult = exportableAssessmentSection.AssessmentSectionAssembly;
Assert.AreEqual(ExportableAssemblyMethod.BOI2A1, exportableAssessmentSectionAssemblyResult.ProbabilityAssemblyMethod);
Assert.AreEqual(ExportableAssemblyMethod.BOI2B1, exportableAssessmentSectionAssemblyResult.AssemblyGroupAssemblyMethod);
Assert.AreEqual(AssessmentSectionAssemblyGroup.APlus, exportableAssessmentSectionAssemblyResult.AssemblyGroup);
Assert.AreEqual(0.14, exportableAssessmentSectionAssemblyResult.Probability);
AssertExportableFailureMechanisms(exportableAssessmentSection.FailureMechanisms, assessmentSection);
Assert.AreEqual(1, exportableAssessmentSection.CombinedSectionAssemblies.Count());
ExportableCombinedSectionAssembly exportableCombinedSectionAssembly = exportableAssessmentSection.CombinedSectionAssemblies.ElementAt(0);
Assert.AreEqual(FailureMechanismSectionAssemblyGroup.Zero, exportableCombinedSectionAssembly.CombinedSectionAssemblyResult.AssemblyGroup);
Assert.AreEqual(ExportableAssemblyMethod.BOI3C1, exportableCombinedSectionAssembly.CombinedSectionAssemblyResult.AssemblyGroupAssemblyMethod);
Assert.AreEqual(0.0, exportableCombinedSectionAssembly.CombinedSectionAssemblyResult.FailureMechanismSection.StartDistance);
Assert.AreEqual(1.0, exportableCombinedSectionAssembly.CombinedSectionAssemblyResult.FailureMechanismSection.EndDistance);
AssertExportableFailureMechanismCombinedSectionAssemblyResults(exportableCombinedSectionAssembly.FailureMechanismResults, assessmentSection);
Assert.AreEqual(ExportableAssemblyMethod.BOI3A1, exportableCombinedSectionAssembly.Section.AssemblyMethod);
Assert.AreEqual(0.0, exportableCombinedSectionAssembly.Section.StartDistance);
Assert.AreEqual(1.0, exportableCombinedSectionAssembly.Section.EndDistance);
}
}
