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); }