public void CurrentPath_FailureMechanismSectionsSourcePathSet_ReturnsExpectedPath()
{
// Setup
var mocks = new MockRepository();
var assessmentSection = mocks.Stub <IAssessmentSection>();
mocks.ReplayAll();
var failureMechanism = new WaterPressureAsphaltCoverFailureMechanism();
string sourcePath = TestHelper.GetScratchPadPath();
failureMechanism.SetSections(Enumerable.Empty <FailureMechanismSection>(), sourcePath);
var context = new WaterPressureAsphaltCoverFailureMechanismSectionsContext(failureMechanism, assessmentSection);
using (var plugin = new RiskeerPlugin())
{
UpdateInfo updateInfo = GetUpdateInfo(plugin);
// Call
string currentFilePath = updateInfo.CurrentPath(context);
// Assert
Assert.AreEqual(sourcePath, currentFilePath);
mocks.VerifyAll();
}
}
public void Create_StringPropertiesDoNotShareReference()
{
// Setup
var failureMechanism = new WaterPressureAsphaltCoverFailureMechanism
{
InAssemblyInputComments =
{
Body = "Some input text"
},
InAssemblyOutputComments =
{
Body = "Some output text"
},
NotInAssemblyComments =
{
Body = "Really not in assembly"
}
};
var registry = new PersistenceRegistry();
// Call
FailureMechanismEntity entity = failureMechanism.Create(registry);
// Assert
TestHelper.AssertAreEqualButNotSame(failureMechanism.InAssemblyInputComments.Body, entity.InAssemblyInputComments);
TestHelper.AssertAreEqualButNotSame(failureMechanism.InAssemblyOutputComments.Body, entity.InAssemblyOutputComments);
TestHelper.AssertAreEqualButNotSame(failureMechanism.NotInAssemblyComments.Body, entity.NotInAssemblyComments);
Assert.IsNull(entity.CalculationsInputComments);
}
public void CloseForData_AssessmentSectionRemovedWithoutFailureMechanism_ReturnsFalse()
{
// Setup
var assessmentSection = mocks.Stub <IAssessmentSection>();
assessmentSection.Stub(asm => asm.GetFailureMechanisms()).Return(Array.Empty <IFailureMechanism>());
assessmentSection.Stub(asm => asm.SpecificFailureMechanisms).Return(new ObservableList <SpecificFailureMechanism>());
mocks.ReplayAll();
var failureMechanism = new WaterPressureAsphaltCoverFailureMechanism();
using (var view = new NonAdoptableWithProfileProbabilityFailureMechanismResultView <WaterPressureAsphaltCoverFailureMechanism>(
failureMechanism.SectionResults, failureMechanism, assessmentSection,
(fm, ass) => new FailureMechanismAssemblyResultWrapper(double.NaN, AssemblyMethod.Manual),
fm => fm.GeneralInput.ApplyLengthEffectInSection,
sr => FailureMechanismSectionAssemblyResultWrapperTestFactory.Create()))
{
// Call
bool closeForData = info.CloseForData(view, assessmentSection);
// Assert
Assert.IsFalse(closeForData);
}
mocks.VerifyAll();
}
public void IsEnabled_FailureMechanismSectionsSourcePathSet_ReturnTrue()
{
// Setup
var mocks = new MockRepository();
var assessmentSection = mocks.Stub <IAssessmentSection>();
mocks.ReplayAll();
var failureMechanism = new WaterPressureAsphaltCoverFailureMechanism();
string sourcePath = TestHelper.GetScratchPadPath();
failureMechanism.SetSections(Enumerable.Empty <FailureMechanismSection>(), sourcePath);
var context = new WaterPressureAsphaltCoverFailureMechanismSectionsContext(failureMechanism, assessmentSection);
using (var plugin = new RiskeerPlugin())
{
UpdateInfo importInfo = GetUpdateInfo(plugin);
// Call
bool isEnabled = importInfo.IsEnabled(context);
// Assert
Assert.IsTrue(isEnabled);
}
mocks.VerifyAll();
}
public void CloseForData_ViewNotCorrespondingToRemovedFailureMechanismContext_ReturnsFalse()
{
// Setup
var assessmentSection = mocks.Stub <IAssessmentSection>();
var failureMechanismContext = mocks.StrictMock <IFailureMechanismContext <IFailureMechanism> >();
failureMechanismContext.Expect(fm => fm.WrappedData).Return(new WaterPressureAsphaltCoverFailureMechanism());
mocks.ReplayAll();
var failureMechanism = new WaterPressureAsphaltCoverFailureMechanism();
using (var view = new NonAdoptableWithProfileProbabilityFailureMechanismResultView <WaterPressureAsphaltCoverFailureMechanism>(
failureMechanism.SectionResults, failureMechanism, assessmentSection,
(fm, ass) => new FailureMechanismAssemblyResultWrapper(double.NaN, AssemblyMethod.Manual),
fm => fm.GeneralInput.ApplyLengthEffectInSection,
sr => FailureMechanismSectionAssemblyResultWrapperTestFactory.Create()))
{
// Call
bool closeForData = info.CloseForData(view, failureMechanismContext);
// Assert
Assert.IsFalse(closeForData);
}
mocks.VerifyAll();
}
/// <summary>
/// Creates a <see cref="FailureMechanismEntity"/> based on the information of the <see cref="WaterPressureAsphaltCoverFailureMechanism"/>.
/// </summary>
/// <param name="mechanism">The failure mechanism to create a database entity for.</param>
/// <param name="registry">The object keeping track of create operations.</param>
/// <returns>A new <see cref="FailureMechanismEntity"/>.</returns>
/// <exception cref="ArgumentNullException">Thrown when <paramref name="registry"/> is <c>null</c>.</exception>
internal static FailureMechanismEntity Create(this WaterPressureAsphaltCoverFailureMechanism mechanism, PersistenceRegistry registry)
{
FailureMechanismEntity entity = mechanism.Create(FailureMechanismType.WaterOverpressureAsphaltRevetment, registry);
AddEntitiesForFailureMechanismMeta(mechanism, entity);
AddEntitiesForSectionResults(mechanism.SectionResults, registry);
return(entity);
}
public void Create_WithoutSections_EmptyFailureMechanismSectionEntities()
{
// Setup
var failureMechanism = new WaterPressureAsphaltCoverFailureMechanism();
// Call
FailureMechanismEntity entity = failureMechanism.Create(new PersistenceRegistry());
// Assert
CollectionAssert.IsEmpty(entity.FailureMechanismSectionEntities);
Assert.IsNull(entity.FailureMechanismSectionCollectionSourcePath);
}
public void Create_PersistenceRegistryNull_ThrowsArgumentNullException()
{
// Setup
var failureMechanism = new WaterPressureAsphaltCoverFailureMechanism();
// Call
void Call() => failureMechanism.Create(null);
// Assert
string paramName = Assert.Throws <ArgumentNullException>(Call).ParamName;
Assert.AreEqual("registry", paramName);
}
public void Constructor_ExpectedValues()
{
// Call
var failureMechanism = new WaterPressureAsphaltCoverFailureMechanism();
// Assert
Assert.IsInstanceOf <FailureMechanismBase <NonAdoptableWithProfileProbabilityFailureMechanismSectionResult> >(failureMechanism);
Assert.IsInstanceOf <IHasGeneralInput>(failureMechanism);
Assert.AreEqual("Wateroverdruk bij asfaltbekleding", failureMechanism.Name);
Assert.AreEqual("AWO", failureMechanism.Code);
Assert.IsNotNull(failureMechanism.GeneralInput);
CollectionAssert.IsEmpty(failureMechanism.Sections);
CollectionAssert.IsEmpty(failureMechanism.SectionResults);
}
public void ForeColor_Always_ReturnsControlText()
{
// Setup
var assessmentSection = mocks.Stub <IAssessmentSection>();
mocks.ReplayAll();
var failureMechanism = new WaterPressureAsphaltCoverFailureMechanism();
var context = new WaterPressureAsphaltCoverFailureMechanismContext(failureMechanism, assessmentSection);
// Call
Color textColor = info.ForeColor(context);
// Assert
Assert.AreEqual(Color.FromKnownColor(KnownColor.ControlText), textColor);
}
public void GetViewName_WithFailureMechanismContext_ReturnsNameOfFailureMechanism()
{
// Setup
var assessmentSection = mocks.Stub <IAssessmentSection>();
mocks.ReplayAll();
var failureMechanism = new WaterPressureAsphaltCoverFailureMechanism();
var failureMechanismContext = new WaterPressureAsphaltCoverFailureMechanismContext(failureMechanism, assessmentSection);
// Call
string viewName = info.GetViewName(null, failureMechanismContext);
// Assert
Assert.AreEqual(failureMechanism.Name, viewName);
}
public void CloseForData_ViewCorrespondingToRemovedAssessmentSection_ReturnsTrue()
{
// Setup
var assessmentSection = new AssessmentSectionStub();
var failureMechanism = new WaterPressureAsphaltCoverFailureMechanism();
using (StandAloneFailureMechanismView <WaterPressureAsphaltCoverFailureMechanism, NonAdoptableWithProfileProbabilityFailureMechanismSectionResult> view =
CreateView(failureMechanism, assessmentSection))
{
// Call
bool closeForData = info.CloseForData(view, assessmentSection);
// Assert
Assert.IsTrue(closeForData);
}
}
public void Text_Always_ReturnsName()
{
// Setup
var assessmentSection = mocks.Stub <IAssessmentSection>();
mocks.ReplayAll();
var failureMechanism = new WaterPressureAsphaltCoverFailureMechanism();
var failureMechanismContext = new WaterPressureAsphaltCoverFailureMechanismContext(failureMechanism, assessmentSection);
// Call
string text = info.Text(failureMechanismContext);
// Assert
Assert.AreEqual(failureMechanism.Name, text);
}
public void ChildNodeObjects_FailureMechanismInAssemblyTrue_ReturnChildDataNodes()
{
// Setup
var assessmentSection = mocks.Stub <IAssessmentSection>();
mocks.ReplayAll();
var failureMechanism = new WaterPressureAsphaltCoverFailureMechanism();
var failureMechanismContext = new WaterPressureAsphaltCoverFailureMechanismContext(failureMechanism, assessmentSection);
// Call
object[] children = info.ChildNodeObjects(failureMechanismContext).ToArray();
// Assert
Assert.AreEqual(2, children.Length);
var inputFolder = (CategoryTreeFolder)children[0];
Assert.AreEqual(2, inputFolder.Contents.Count());
Assert.AreEqual("Invoer", inputFolder.Name);
Assert.AreEqual(TreeFolderCategory.Input, inputFolder.Category);
var failureMechanismSectionsContext = (WaterPressureAsphaltCoverFailureMechanismSectionsContext)inputFolder.Contents.ElementAt(0);
Assert.AreSame(failureMechanism, failureMechanismSectionsContext.WrappedData);
Assert.AreSame(assessmentSection, failureMechanismSectionsContext.AssessmentSection);
var inAssemblyInputComments = (Comment)inputFolder.Contents.ElementAt(1);
Assert.AreSame(failureMechanism.InAssemblyInputComments, inAssemblyInputComments);
var outputFolder = (CategoryTreeFolder)children[1];
Assert.AreEqual(2, outputFolder.Contents.Count());
Assert.AreEqual("Oordeel", outputFolder.Name);
Assert.AreEqual(TreeFolderCategory.Output, outputFolder.Category);
var failureMechanismResultsContext = (WaterPressureAsphaltCoverFailureMechanismSectionResultContext)outputFolder.Contents.ElementAt(0);
Assert.AreSame(failureMechanism, failureMechanismResultsContext.FailureMechanism);
Assert.AreSame(assessmentSection, failureMechanismResultsContext.AssessmentSection);
Assert.AreSame(failureMechanism.SectionResults, failureMechanismResultsContext.WrappedData);
var inAssemblyOutputComments = (Comment)outputFolder.Contents.ElementAt(1);
Assert.AreSame(failureMechanism.InAssemblyOutputComments, inAssemblyOutputComments);
}
public void GetViewData_WithContext_ReturnsWrappedFailureMechanismResult()
{
// Setup
var assessmentSection = mocks.Stub <IAssessmentSection>();
mocks.ReplayAll();
var failureMechanism = new WaterPressureAsphaltCoverFailureMechanism();
var context = new WaterPressureAsphaltCoverFailureMechanismSectionResultContext(
failureMechanism.SectionResults, failureMechanism, assessmentSection);
// Call
object viewData = info.GetViewData(context);
// Assert
Assert.AreSame(failureMechanism.SectionResults, viewData);
mocks.VerifyAll();
}
public void CreateInstance_WithContext_ReturnsView()
{
// Setup
var assessmentSection = mocks.Stub <IAssessmentSection>();
var failureMechanism = new WaterPressureAsphaltCoverFailureMechanism();
var context = new WaterPressureAsphaltCoverFailureMechanismSectionResultContext(
failureMechanism.SectionResults, failureMechanism, assessmentSection);
mocks.ReplayAll();
// Call
IView view = info.CreateInstance(context);
// Assert
Assert.IsInstanceOf <NonAdoptableWithProfileProbabilityFailureMechanismResultView <WaterPressureAsphaltCoverFailureMechanism> >(view);
mocks.VerifyAll();
}
public void Constructor_ExpectedValues()
{
// Setup
var mocks = new MockRepository();
var assessmentSection = mocks.Stub <IAssessmentSection>();
mocks.ReplayAll();
var failureMechanism = new WaterPressureAsphaltCoverFailureMechanism();
// Call
var context = new WaterPressureAsphaltCoverFailureMechanismSectionResultContext(
failureMechanism.SectionResults, failureMechanism, assessmentSection);
// Assert
Assert.IsInstanceOf <FailureMechanismSectionResultContext <NonAdoptableWithProfileProbabilityFailureMechanismSectionResult> >(context);
mocks.VerifyAll();
}
public void Constructor_ExpectedValues()
{
// Setup
var mocks = new MockRepository();
var assessmentSection = mocks.Stub <IAssessmentSection>();
mocks.ReplayAll();
var failureMechanism = new WaterPressureAsphaltCoverFailureMechanism();
// Call
var context = new WaterPressureAsphaltCoverFailureMechanismContext(failureMechanism, assessmentSection);
// Assert
Assert.IsInstanceOf <FailureMechanismContext <WaterPressureAsphaltCoverFailureMechanism> >(context);
Assert.AreSame(assessmentSection, context.Parent);
Assert.AreSame(failureMechanism, context.WrappedData);
mocks.VerifyAll();
}
/// <summary>
/// Initializes a new instance of the <see cref="AssessmentSection"/> class.
/// </summary>
/// <param name="composition">The composition of the assessment section, e.g. what
/// type of elements can be found within the assessment section.</param>
/// <param name="maximumAllowableFloodingProbability">The maximum allowable flooding probability of the assessment section.</param>
/// <param name="signalFloodingProbability">The signal flooding probability of the assessment section.</param>
/// <exception cref="ArgumentOutOfRangeException">Thrown when:
/// <list type="bullet">
/// <item><paramref name="maximumAllowableFloodingProbability"/> is not in the interval [0.000001, 0.1] or is <see cref="double.NaN"/>;</item>
/// <item><paramref name="signalFloodingProbability"/> is not in the interval [0.000001, 0.1] or is <see cref="double.NaN"/>;</item>
/// <item>The <paramref name="signalFloodingProbability"/> is larger than <paramref name="maximumAllowableFloodingProbability"/>.</item>
/// </list>
/// </exception>
/// <exception cref="InvalidEnumArgumentException">Thrown when <paramref name="composition"/>
/// is not a valid enum value of <see cref="AssessmentSectionComposition"/>.</exception>
/// <exception cref="NotSupportedException">Thrown when <paramref name="composition"/>
/// is not supported.</exception>
public AssessmentSection(AssessmentSectionComposition composition,
double maximumAllowableFloodingProbability = defaultFloodingProbability,
double signalFloodingProbability = defaultFloodingProbability)
{
Name = Resources.AssessmentSection_DisplayName;
Comments = new Comment();
BackgroundData = new BackgroundData(new WellKnownBackgroundDataConfiguration(defaultWellKnownTileSource))
{
Name = defaultWellKnownTileSource.GetDisplayName()
};
ReferenceLine = new ReferenceLine();
HydraulicBoundaryDatabase = new HydraulicBoundaryDatabase();
SpecificFailureMechanisms = new ObservableList <SpecificFailureMechanism>();
waterLevelCalculationsForSignalFloodingProbability = new ObservableList <HydraulicBoundaryLocationCalculation>();
waterLevelCalculationsForMaximumAllowableFloodingProbability = new ObservableList <HydraulicBoundaryLocationCalculation>();
WaterLevelCalculationsForUserDefinedTargetProbabilities = new ObservableList <HydraulicBoundaryLocationCalculationsForTargetProbability>();
WaveHeightCalculationsForUserDefinedTargetProbabilities = new ObservableList <HydraulicBoundaryLocationCalculationsForTargetProbability>();
Piping = new PipingFailureMechanism();
GrassCoverErosionInwards = new GrassCoverErosionInwardsFailureMechanism();
MacroStabilityInwards = new MacroStabilityInwardsFailureMechanism();
Microstability = new MicrostabilityFailureMechanism();
StabilityStoneCover = new StabilityStoneCoverFailureMechanism();
WaveImpactAsphaltCover = new WaveImpactAsphaltCoverFailureMechanism();
WaterPressureAsphaltCover = new WaterPressureAsphaltCoverFailureMechanism();
GrassCoverErosionOutwards = new GrassCoverErosionOutwardsFailureMechanism();
GrassCoverSlipOffOutwards = new GrassCoverSlipOffOutwardsFailureMechanism();
GrassCoverSlipOffInwards = new GrassCoverSlipOffInwardsFailureMechanism();
HeightStructures = new HeightStructuresFailureMechanism();
ClosingStructures = new ClosingStructuresFailureMechanism();
StabilityPointStructures = new StabilityPointStructuresFailureMechanism();
PipingStructure = new PipingStructureFailureMechanism();
DuneErosion = new DuneErosionFailureMechanism();
FailureMechanismContribution = new FailureMechanismContribution(maximumAllowableFloodingProbability, signalFloodingProbability);
ChangeComposition(composition);
}
public void Create_WithCollectorAndPropertiesSet_ReturnsFailureMechanismEntityWithPropertiesSet(bool inAssembly)
{
// Setup
var failureMechanism = new WaterPressureAsphaltCoverFailureMechanism
{
InAssembly = inAssembly,
InAssemblyInputComments =
{
Body = "Some input text"
},
InAssemblyOutputComments =
{
Body = "Some output text"
},
NotInAssemblyComments =
{
Body = "Really not in assembly"
},
GeneralInput =
{
N = new Random().NextRoundedDouble(1, 20)
}
};
var registry = new PersistenceRegistry();
// Call
FailureMechanismEntity entity = failureMechanism.Create(registry);
// Assert
Assert.IsNotNull(entity);
Assert.AreEqual((short)FailureMechanismType.WaterOverpressureAsphaltRevetment, entity.FailureMechanismType);
Assert.AreEqual(Convert.ToByte(inAssembly), entity.InAssembly);
Assert.AreEqual(failureMechanism.InAssemblyInputComments.Body, entity.InAssemblyInputComments);
Assert.AreEqual(failureMechanism.InAssemblyOutputComments.Body, entity.InAssemblyOutputComments);
Assert.AreEqual(failureMechanism.NotInAssemblyComments.Body, entity.NotInAssemblyComments);
Assert.IsNull(entity.CalculationsInputComments);
WaterPressureAsphaltCoverFailureMechanismMetaEntity metaEntity = entity.WaterPressureAsphaltCoverFailureMechanismMetaEntities.Single();
Assert.AreEqual(failureMechanism.GeneralInput.N, metaEntity.N);
}
public void Create_WithSections_FailureMechanismSectionEntitiesCreated()
{
// Setup
const string filePath = "failureMechanismSections/File/Path";
var failureMechanism = new WaterPressureAsphaltCoverFailureMechanism();
failureMechanism.SetSections(new[]
{
FailureMechanismSectionTestFactory.CreateFailureMechanismSection()
}, filePath);
// Call
FailureMechanismEntity entity = failureMechanism.Create(new PersistenceRegistry());
// Assert
Assert.AreEqual(1, entity.FailureMechanismSectionEntities.Count);
Assert.AreEqual(1, entity.FailureMechanismSectionEntities
.SelectMany(fms => fms.NonAdoptableWithProfileProbabilityFailureMechanismSectionResultEntities)
.Count());
TestHelper.AssertAreEqualButNotSame(filePath, entity.FailureMechanismSectionCollectionSourcePath);
}
public void CreateInstance_WithData_ReturnFailureMechanismView()
{
// Setup
var assessmentSection = new AssessmentSectionStub();
var failureMechanism = new WaterPressureAsphaltCoverFailureMechanism();
var context = new WaterPressureAsphaltCoverFailureMechanismContext(failureMechanism, assessmentSection);
// Call
IView view = info.CreateInstance(context);
// Assert
Assert.IsInstanceOf <StandAloneFailureMechanismView <WaterPressureAsphaltCoverFailureMechanism,
NonAdoptableWithProfileProbabilityFailureMechanismSectionResult> >(view);
var failureMechanismView = (StandAloneFailureMechanismView <WaterPressureAsphaltCoverFailureMechanism,
NonAdoptableWithProfileProbabilityFailureMechanismSectionResult>)view;
Assert.AreSame(failureMechanism, failureMechanismView.FailureMechanism);
Assert.AreSame(assessmentSection, failureMechanismView.AssessmentSection);
}
public void AdditionalDataCheck_Always_ReturnTrueOnlyIfFailureMechanismInAssembly(bool inAssembly)
{
// Setup
var assessmentSection = mocks.Stub <IAssessmentSection>();
mocks.ReplayAll();
var failureMechanism = new WaterPressureAsphaltCoverFailureMechanism
{
InAssembly = inAssembly
};
var context = new WaterPressureAsphaltCoverFailureMechanismContext(failureMechanism, assessmentSection);
// Call
bool result = info.AdditionalDataCheck(context);
// Assert
Assert.AreEqual(inAssembly, result);
mocks.VerifyAll();
}
public void ChildNodeObjects_FailureMechanismInAssemblyFalse_ReturnOnlyFailureMechanismNotInAssemblyComments()
{
// Setup
var assessmentSection = mocks.Stub <IAssessmentSection>();
mocks.ReplayAll();
var failureMechanism = new WaterPressureAsphaltCoverFailureMechanism
{
InAssembly = false
};
var failureMechanismContext = new WaterPressureAsphaltCoverFailureMechanismContext(failureMechanism, assessmentSection);
// Call
object[] children = info.ChildNodeObjects(failureMechanismContext).ToArray();
// Assert
Assert.AreEqual(1, children.Length);
var comment = (Comment)children[0];
Assert.AreSame(failureMechanism.NotInAssemblyComments, comment);
}
public void ContextMenuStrip_FailureMechanismInAssemblyFalse_CallsContextMenuBuilderMethods()
{
// Setup
var failureMechanism = new WaterPressureAsphaltCoverFailureMechanism
{
InAssembly = false
};
var assessmentSection = mocks.Stub <IAssessmentSection>();
var context = new WaterPressureAsphaltCoverFailureMechanismContext(failureMechanism, assessmentSection);
using (var treeView = new TreeViewControl())
{
var menuBuilder = mocks.StrictMock <IContextMenuBuilder>();
using (mocks.Ordered())
{
menuBuilder.Expect(mb => mb.AddCustomItem(null)).IgnoreArguments().Return(menuBuilder);
menuBuilder.Expect(mb => mb.AddSeparator()).Return(menuBuilder);
menuBuilder.Expect(mb => mb.AddCollapseAllItem()).Return(menuBuilder);
menuBuilder.Expect(mb => mb.AddExpandAllItem()).Return(menuBuilder);
menuBuilder.Expect(mb => mb.AddSeparator()).Return(menuBuilder);
menuBuilder.Expect(mb => mb.AddPropertiesItem()).Return(menuBuilder);
menuBuilder.Expect(mb => mb.Build()).Return(null);
}
IGui gui = StubFactory.CreateGuiStub(mocks);
gui.Stub(cmp => cmp.Get(context, treeView)).Return(menuBuilder);
mocks.ReplayAll();
plugin.Gui = gui;
// Call
info.ContextMenuStrip(context, assessmentSection, treeView);
// Assert
// Assert expectancies are called in TearDown()
}
}
public void CreateFileImporter_WithValidData_ReturnsFileImporter()
{
// Setup
var mocks = new MockRepository();
var assessmentSection = mocks.Stub <IAssessmentSection>();
assessmentSection.Stub(a => a.ReferenceLine).Return(new ReferenceLine());
mocks.ReplayAll();
var failureMechanism = new WaterPressureAsphaltCoverFailureMechanism();
var context = new WaterPressureAsphaltCoverFailureMechanismSectionsContext(failureMechanism, assessmentSection);
using (var plugin = new RiskeerPlugin())
{
UpdateInfo updateInfo = GetUpdateInfo(plugin);
// Call
IFileImporter importer = updateInfo.CreateFileImporter(context, string.Empty);
// Assert
Assert.IsInstanceOf <FailureMechanismSectionsImporter>(importer);
mocks.VerifyAll();
}
}
public void IsEnabled_FailureMechanismSectionsSourcePathNull_ReturnFalse()
{
// Setup
var mocks = new MockRepository();
var assessmentSection = mocks.Stub <IAssessmentSection>();
mocks.ReplayAll();
var failureMechanism = new WaterPressureAsphaltCoverFailureMechanism();
var context = new WaterPressureAsphaltCoverFailureMechanismSectionsContext(failureMechanism, assessmentSection);
using (var plugin = new RiskeerPlugin())
{
UpdateInfo importInfo = GetUpdateInfo(plugin);
// Call
bool isEnabled = importInfo.IsEnabled(context);
// Assert
Assert.IsFalse(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();
}
/// <summary>
/// Initializes a new instance of the <see cref="WaterPressureAsphaltCoverFailureMechanismSectionsContext"/> class.
/// </summary>
/// <param name="wrappedData">The <see cref="WaterPressureAsphaltCoverFailureMechanism"/> to wrap.</param>
/// <param name="assessmentSection">The owning assessment section of <paramref name="wrappedData"/>.</param>
/// <exception cref="ArgumentNullException">Thrown when any input argument is <c>null</c>.</exception>
public WaterPressureAsphaltCoverFailureMechanismSectionsContext(WaterPressureAsphaltCoverFailureMechanism wrappedData, IAssessmentSection assessmentSection)
: base(wrappedData, assessmentSection)
{
}
/// <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);
}
