Index: Riskeer/Piping/src/Riskeer.Piping.Forms/Views/CalculationsState/PipingFailureMechanismView.Designer.cs =================================================================== diff -u --- Riskeer/Piping/src/Riskeer.Piping.Forms/Views/CalculationsState/PipingFailureMechanismView.Designer.cs (revision 0) +++ Riskeer/Piping/src/Riskeer.Piping.Forms/Views/CalculationsState/PipingFailureMechanismView.Designer.cs (revision 4833951758a4115a1ae02558a02696f2dedf4950) @@ -0,0 +1,64 @@ +// Copyright (C) Stichting Deltares 2021. All rights reserved. +// +// This file is part of Riskeer. +// +// Riskeer is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this program. If not, see . +// +// All names, logos, and references to "Deltares" are registered trademarks of +// Stichting Deltares and remain full property of Stichting Deltares at all times. +// All rights reserved. + +namespace Riskeer.Piping.Forms.Views.CalculationsState +{ + partial class PipingFailureMechanismView + { + /// + /// Required designer variable. + /// + private System.ComponentModel.IContainer components = null; + + #region Component Designer generated code + + /// + /// Required method for Designer support - do not modify + /// the contents of this method with the code editor. + /// + private void InitializeComponent() + { + this.riskeerMapControl = new Riskeer.Common.Forms.Views.RiskeerMapControl(); + this.SuspendLayout(); + // + // riskeerMapControl + // + this.riskeerMapControl.Dock = System.Windows.Forms.DockStyle.Fill; + this.riskeerMapControl.Location = new System.Drawing.Point(0, 0); + this.riskeerMapControl.Name = "riskeerMapControl"; + this.riskeerMapControl.Size = new System.Drawing.Size(150, 150); + this.riskeerMapControl.TabIndex = 0; + // + // PipingFailureMechanismView + // + this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F); + this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font; + this.Controls.Add(this.riskeerMapControl); + this.Name = "PipingFailureMechanismView"; + this.ResumeLayout(false); + + } + + #endregion + + private Common.Forms.Views.RiskeerMapControl riskeerMapControl; + } +} Index: Riskeer/Piping/src/Riskeer.Piping.Forms/Views/CalculationsState/PipingFailureMechanismView.cs =================================================================== diff -u --- Riskeer/Piping/src/Riskeer.Piping.Forms/Views/CalculationsState/PipingFailureMechanismView.cs (revision 0) +++ Riskeer/Piping/src/Riskeer.Piping.Forms/Views/CalculationsState/PipingFailureMechanismView.cs (revision 4833951758a4115a1ae02558a02696f2dedf4950) @@ -0,0 +1,350 @@ +// Copyright (C) Stichting Deltares 2021. All rights reserved. +// +// This file is part of Riskeer. +// +// Riskeer is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this program. If not, see . +// +// All names, logos, and references to "Deltares" are registered trademarks of +// Stichting Deltares and remain full property of Stichting Deltares at all times. +// All rights reserved. + +using System; +using System.Collections.Generic; +using System.Linq; +using System.Windows.Forms; +using Core.Common.Base; +using Core.Components.Gis.Data; +using Core.Components.Gis.Forms; +using Riskeer.Common.Data.AssessmentSection; +using Riskeer.Common.Data.Calculation; +using Riskeer.Common.Data.FailureMechanism; +using Riskeer.Common.Forms.Factories; +using Riskeer.Common.Forms.MapLayers; +using Riskeer.Piping.Data; +using Riskeer.Piping.Data.Probabilistic; +using Riskeer.Piping.Data.SemiProbabilistic; +using Riskeer.Piping.Data.SoilProfile; +using Riskeer.Piping.Forms.Factories; +using Riskeer.Piping.Primitives; +using PipingDataResources = Riskeer.Piping.Data.Properties.Resources; + +namespace Riskeer.Piping.Forms.Views.CalculationsState +{ + /// + /// Calculations state view showing map data for a piping failure mechanism. + /// + public partial class PipingFailureMechanismView : UserControl, IMapView + { + private HydraulicBoundaryLocationsMapLayer hydraulicBoundaryLocationsMapLayer; + + private MapLineData referenceLineMapData; + private MapLineData stochasticSoilModelsMapData; + private MapLineData surfaceLinesMapData; + private MapLineData semiProbabilisticCalculationsMapData; + private MapLineData probabilisticCalculationsMapData; + + private MapLineData sectionsMapData; + private MapPointData sectionsStartPointMapData; + private MapPointData sectionsEndPointMapData; + + private Observer failureMechanismObserver; + private Observer assessmentSectionObserver; + private Observer referenceLineObserver; + private Observer surfaceLinesObserver; + private Observer stochasticSoilModelsObserver; + + private RecursiveObserver semiProbabilisticCalculationInputObserver; + private RecursiveObserver probabilisticCalculationInputObserver; + private RecursiveObserver calculationGroupObserver; + private RecursiveObserver semiProbabilisticCalculationObserver; + private RecursiveObserver probabilisticCalculationObserver; + private RecursiveObserver surfaceLineObserver; + + /// + /// Creates a new instance of . + /// + /// The failure mechanism to show the data for. + /// The assessment section to show the data for. + /// Thrown when any parameter is null. + public PipingFailureMechanismView(PipingFailureMechanism failureMechanism, IAssessmentSection assessmentSection) + { + if (failureMechanism == null) + { + throw new ArgumentNullException(nameof(failureMechanism)); + } + + if (assessmentSection == null) + { + throw new ArgumentNullException(nameof(assessmentSection)); + } + + InitializeComponent(); + + FailureMechanism = failureMechanism; + AssessmentSection = assessmentSection; + } + + /// + /// Gets the failure mechanism. + /// + public PipingFailureMechanism FailureMechanism { get; } + + /// + /// Gets the assessment section. + /// + public IAssessmentSection AssessmentSection { get; } + + public object Data { get; set; } + + public IMapControl Map + { + get + { + return riskeerMapControl.MapControl; + } + } + + /// + /// Gets the . + /// + protected MapDataCollection MapDataCollection { get; private set; } + + protected override void OnLoad(EventArgs e) + { + CreateObservers(); + + CreateMapData(); + + SetAllMapDataFeatures(); + + riskeerMapControl.SetAllData(MapDataCollection, AssessmentSection.BackgroundData); + + base.OnLoad(e); + } + + protected override void Dispose(bool disposing) + { + hydraulicBoundaryLocationsMapLayer.Dispose(); + failureMechanismObserver.Dispose(); + assessmentSectionObserver.Dispose(); + referenceLineObserver.Dispose(); + stochasticSoilModelsObserver.Dispose(); + semiProbabilisticCalculationInputObserver.Dispose(); + probabilisticCalculationInputObserver.Dispose(); + calculationGroupObserver.Dispose(); + semiProbabilisticCalculationObserver.Dispose(); + probabilisticCalculationObserver.Dispose(); + surfaceLinesObserver.Dispose(); + surfaceLineObserver.Dispose(); + + if (disposing) + { + components?.Dispose(); + } + + base.Dispose(disposing); + } + + /// + /// Creates the map data. + /// + protected virtual void CreateMapData() + { + hydraulicBoundaryLocationsMapLayer = new HydraulicBoundaryLocationsMapLayer(AssessmentSection); + + MapDataCollection = new MapDataCollection(PipingDataResources.PipingFailureMechanism_DisplayName); + referenceLineMapData = RiskeerMapDataFactory.CreateReferenceLineMapData(); + stochasticSoilModelsMapData = RiskeerMapDataFactory.CreateStochasticSoilModelsMapData(); + surfaceLinesMapData = RiskeerMapDataFactory.CreateSurfaceLinesMapData(); + semiProbabilisticCalculationsMapData = PipingMapDataFactory.CreateSemiProbabilisticCalculationsMapData(); + probabilisticCalculationsMapData = PipingMapDataFactory.CreateProbabilisticCalculationsMapData(); + + MapDataCollection sectionsMapDataCollection = RiskeerMapDataFactory.CreateSectionsMapDataCollection(); + sectionsMapData = RiskeerMapDataFactory.CreateFailureMechanismSectionsMapData(); + sectionsStartPointMapData = RiskeerMapDataFactory.CreateFailureMechanismSectionsStartPointMapData(); + sectionsEndPointMapData = RiskeerMapDataFactory.CreateFailureMechanismSectionsEndPointMapData(); + + MapDataCollection.Add(referenceLineMapData); + MapDataCollection.Add(stochasticSoilModelsMapData); + MapDataCollection.Add(surfaceLinesMapData); + + sectionsMapDataCollection.Add(sectionsMapData); + sectionsMapDataCollection.Add(sectionsStartPointMapData); + sectionsMapDataCollection.Add(sectionsEndPointMapData); + MapDataCollection.Add(sectionsMapDataCollection); + MapDataCollection.Add(hydraulicBoundaryLocationsMapLayer.MapData); + MapDataCollection.Add(probabilisticCalculationsMapData); + MapDataCollection.Add(semiProbabilisticCalculationsMapData); + } + + private void CreateObservers() + { + failureMechanismObserver = new Observer(UpdateFailureMechanismMapData) + { + Observable = FailureMechanism + }; + assessmentSectionObserver = new Observer(UpdateReferenceLineMapData) + { + Observable = AssessmentSection + }; + referenceLineObserver = new Observer(UpdateReferenceLineMapData) + { + Observable = AssessmentSection.ReferenceLine + }; + surfaceLinesObserver = new Observer(UpdateSurfaceLinesMapData) + { + Observable = FailureMechanism.SurfaceLines + }; + stochasticSoilModelsObserver = new Observer(UpdateStochasticSoilModelsMapData) + { + Observable = FailureMechanism.StochasticSoilModels + }; + + semiProbabilisticCalculationInputObserver = new RecursiveObserver( + UpdateSemiProbabilisticCalculationsMapData, pcg => pcg.Children.Concat(pcg.Children.OfType().Select(pc => pc.InputParameters))) + { + Observable = FailureMechanism.CalculationsGroup + }; + probabilisticCalculationInputObserver = new RecursiveObserver( + UpdateProbabilisticCalculationsMapData, pcg => pcg.Children.Concat(pcg.Children.OfType().Select(pc => pc.InputParameters))) + { + Observable = FailureMechanism.CalculationsGroup + }; + calculationGroupObserver = new RecursiveObserver(() => + { + UpdateSemiProbabilisticCalculationsMapData(); + UpdateProbabilisticCalculationsMapData(); + }, pcg => pcg.Children) + { + Observable = FailureMechanism.CalculationsGroup + }; + semiProbabilisticCalculationObserver = new RecursiveObserver(UpdateSemiProbabilisticCalculationsMapData, pcg => pcg.Children) + { + Observable = FailureMechanism.CalculationsGroup + }; + probabilisticCalculationObserver = new RecursiveObserver(UpdateProbabilisticCalculationsMapData, pcg => pcg.Children) + { + Observable = FailureMechanism.CalculationsGroup + }; + surfaceLineObserver = new RecursiveObserver(UpdateSurfaceLinesMapData, rpslc => rpslc) + { + Observable = FailureMechanism.SurfaceLines + }; + } + + private void SetAllMapDataFeatures() + { + SetCalculationsMapData(semiProbabilisticCalculationsMapData); + SetCalculationsMapData(probabilisticCalculationsMapData); + SetReferenceLineMapData(); + + SetSectionsMapData(); + SetSurfaceLinesMapData(); + SetStochasticSoilModelsMapData(); + } + + #region Calculations MapData + + private void UpdateSemiProbabilisticCalculationsMapData() + { + SetCalculationsMapData(semiProbabilisticCalculationsMapData); + semiProbabilisticCalculationsMapData.NotifyObservers(); + } + + private void UpdateProbabilisticCalculationsMapData() + { + SetCalculationsMapData(probabilisticCalculationsMapData); + probabilisticCalculationsMapData.NotifyObservers(); + } + + private void SetCalculationsMapData(FeatureBasedMapData calculationsMapData) + where TCalculationScenario : IPipingCalculationScenario + { + IEnumerable calculations = + FailureMechanism.CalculationsGroup.GetCalculations().OfType(); + calculationsMapData.Features = PipingMapDataFeaturesFactory.CreateCalculationFeatures(calculations); + } + + #endregion + + #region AssessmentSection MapData + + private void UpdateReferenceLineMapData() + { + SetReferenceLineMapData(); + referenceLineMapData.NotifyObservers(); + } + + private void SetReferenceLineMapData() + { + ReferenceLine referenceLine = AssessmentSection.ReferenceLine; + referenceLineMapData.Features = RiskeerMapDataFeaturesFactory.CreateReferenceLineFeatures(referenceLine, AssessmentSection.Id, AssessmentSection.Name); + } + + #endregion + + #region FailureMechanism MapData + + private void UpdateFailureMechanismMapData() + { + SetSectionsMapData(); + sectionsMapData.NotifyObservers(); + sectionsStartPointMapData.NotifyObservers(); + sectionsEndPointMapData.NotifyObservers(); + } + + private void SetSectionsMapData() + { + IEnumerable failureMechanismSections = FailureMechanism.Sections; + + sectionsMapData.Features = RiskeerMapDataFeaturesFactory.CreateFailureMechanismSectionFeatures(failureMechanismSections); + sectionsStartPointMapData.Features = RiskeerMapDataFeaturesFactory.CreateFailureMechanismSectionStartPointFeatures(failureMechanismSections); + sectionsEndPointMapData.Features = RiskeerMapDataFeaturesFactory.CreateFailureMechanismSectionEndPointFeatures(failureMechanismSections); + } + + #endregion + + #region SurfaceLines MapData + + private void UpdateSurfaceLinesMapData() + { + SetSurfaceLinesMapData(); + surfaceLinesMapData.NotifyObservers(); + } + + private void SetSurfaceLinesMapData() + { + PipingSurfaceLineCollection pipingSurfaceLines = FailureMechanism.SurfaceLines; + surfaceLinesMapData.Features = PipingMapDataFeaturesFactory.CreateSurfaceLineFeatures(pipingSurfaceLines.ToArray()); + } + + #endregion + + #region StochasticSoilModels MapData + + private void UpdateStochasticSoilModelsMapData() + { + SetStochasticSoilModelsMapData(); + stochasticSoilModelsMapData.NotifyObservers(); + } + + private void SetStochasticSoilModelsMapData() + { + PipingStochasticSoilModelCollection stochasticSoilModels = FailureMechanism.StochasticSoilModels; + stochasticSoilModelsMapData.Features = PipingMapDataFeaturesFactory.CreateStochasticSoilModelFeatures(stochasticSoilModels.ToArray()); + } + + #endregion + } +} \ No newline at end of file Index: Riskeer/Piping/src/Riskeer.Piping.Forms/Views/CalculationsState/PipingFailureMechanismView.resx =================================================================== diff -u --- Riskeer/Piping/src/Riskeer.Piping.Forms/Views/CalculationsState/PipingFailureMechanismView.resx (revision 0) +++ Riskeer/Piping/src/Riskeer.Piping.Forms/Views/CalculationsState/PipingFailureMechanismView.resx (revision 4833951758a4115a1ae02558a02696f2dedf4950) @@ -0,0 +1,120 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 2.0 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + \ No newline at end of file Fisheye: Tag 4833951758a4115a1ae02558a02696f2dedf4950 refers to a dead (removed) revision in file `Riskeer/Piping/src/Riskeer.Piping.Forms/Views/PipingFailureMechanismView.Designer.cs'. Fisheye: No comparison available. Pass `N' to diff? Fisheye: Tag 4833951758a4115a1ae02558a02696f2dedf4950 refers to a dead (removed) revision in file `Riskeer/Piping/src/Riskeer.Piping.Forms/Views/PipingFailureMechanismView.cs'. Fisheye: No comparison available. Pass `N' to diff? Fisheye: Tag 4833951758a4115a1ae02558a02696f2dedf4950 refers to a dead (removed) revision in file `Riskeer/Piping/src/Riskeer.Piping.Forms/Views/PipingFailureMechanismView.resx'. Fisheye: No comparison available. Pass `N' to diff? Fisheye: Tag 4833951758a4115a1ae02558a02696f2dedf4950 refers to a dead (removed) revision in file `Riskeer/Piping/src/Riskeer.Piping.Forms/Views/PipingFailurePathView.cs'. Fisheye: No comparison available. Pass `N' to diff? Index: Riskeer/Piping/src/Riskeer.Piping.Forms/Views/RegistrationState/PipingFailureMechanismView.cs =================================================================== diff -u --- Riskeer/Piping/src/Riskeer.Piping.Forms/Views/RegistrationState/PipingFailureMechanismView.cs (revision 0) +++ Riskeer/Piping/src/Riskeer.Piping.Forms/Views/RegistrationState/PipingFailureMechanismView.cs (revision 4833951758a4115a1ae02558a02696f2dedf4950) @@ -0,0 +1,63 @@ +// Copyright (C) Stichting Deltares 2021. All rights reserved. +// +// This file is part of Riskeer. +// +// Riskeer is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this program. If not, see . +// +// All names, logos, and references to "Deltares" are registered trademarks of +// Stichting Deltares and remain full property of Stichting Deltares at all times. +// All rights reserved. + +using System; +using Riskeer.Common.Data.AssessmentSection; +using Riskeer.Common.Data.FailureMechanism; +using Riskeer.Common.Forms.MapLayers; +using Riskeer.Piping.Data; +using PipingDataResources = Riskeer.Piping.Data.Properties.Resources; + +namespace Riskeer.Piping.Forms.Views.RegistrationState +{ + /// + /// Registration state view showing map data for a piping failure mechanism. + /// + public class PipingFailureMechanismView : CalculationsState.PipingFailureMechanismView + { + private CalculatableFailureMechanismSectionResultsMapLayer assemblyResultMapLayer; + + /// + /// Creates a new instance of . + /// + /// The failure mechanism to show the data for. + /// The assessment section to show the data for. + /// Thrown when any parameter is null. + public PipingFailureMechanismView(PipingFailureMechanism failureMechanism, IAssessmentSection assessmentSection) + : base(failureMechanism, assessmentSection) {} + + protected override void Dispose(bool disposing) + { + assemblyResultMapLayer.Dispose(); + + base.Dispose(disposing); + } + + protected override void CreateMapData() + { + base.CreateMapData(); + + assemblyResultMapLayer = new CalculatableFailureMechanismSectionResultsMapLayer( + FailureMechanism, sr => PipingFailureMechanismAssemblyFactory.AssembleSection(sr, FailureMechanism, AssessmentSection)); + MapDataCollection.Insert(4, assemblyResultMapLayer.MapData); + } + } +} \ No newline at end of file Index: Riskeer/Piping/src/Riskeer.Piping.Plugin/PipingPlugin.cs =================================================================== diff -u -rdc98821fe1215b8fb7512aadff471024c2e81544 -r4833951758a4115a1ae02558a02696f2dedf4950 --- Riskeer/Piping/src/Riskeer.Piping.Plugin/PipingPlugin.cs (.../PipingPlugin.cs) (revision dc98821fe1215b8fb7512aadff471024c2e81544) +++ Riskeer/Piping/src/Riskeer.Piping.Plugin/PipingPlugin.cs (.../PipingPlugin.cs) (revision 4833951758a4115a1ae02558a02696f2dedf4950) @@ -73,6 +73,8 @@ using Riskeer.Piping.Util; using CalculationsStateFailureMechanismProperties = Riskeer.Piping.Forms.PropertyClasses.CalculationsState.PipingFailureMechanismProperties; using RegistrationStateFailureMechanismProperties = Riskeer.Piping.Forms.PropertyClasses.RegistrationState.PipingFailureMechanismProperties; +using CalculationsStateFailureMechanismView = Riskeer.Piping.Forms.Views.CalculationsState.PipingFailureMechanismView; +using RegistrationStateFailureMechanismView = Riskeer.Piping.Forms.Views.RegistrationState.PipingFailureMechanismView; using RiskeerCommonFormsResources = Riskeer.Common.Forms.Properties.Resources; using RiskeerCommonDataResources = Riskeer.Common.Data.Properties.Resources; using PipingFormsResources = Riskeer.Piping.Forms.Properties.Resources; @@ -244,17 +246,17 @@ public override IEnumerable GetViewInfos() { - yield return new RiskeerViewInfo(() => Gui) + yield return new RiskeerViewInfo(() => Gui) { GetViewName = (view, context) => context.WrappedData.Name, - CreateInstance = context => new PipingFailureMechanismView(context.WrappedData, context.Parent) + CreateInstance = context => new CalculationsStateFailureMechanismView(context.WrappedData, context.Parent) }; - yield return new RiskeerViewInfo(() => Gui) + yield return new RiskeerViewInfo(() => Gui) { GetViewName = (view, context) => context.WrappedData.Name, AdditionalDataCheck = context => context.WrappedData.InAssembly, - CreateInstance = context => new PipingFailurePathView(context.WrappedData, context.Parent), + CreateInstance = context => new RegistrationStateFailureMechanismView(context.WrappedData, context.Parent), CloseForData = ClosePipingFailurePathViewForData }; @@ -580,7 +582,7 @@ #region ViewInfos - private static bool ClosePipingFailurePathViewForData(PipingFailurePathView view, object dataToCloseFor) + private static bool ClosePipingFailurePathViewForData(RegistrationStateFailureMechanismView view, object dataToCloseFor) { var pipingFailureMechanism = dataToCloseFor as PipingFailureMechanism; return dataToCloseFor is IAssessmentSection assessmentSection Index: Riskeer/Piping/test/Riskeer.Piping.Forms.Test/Views/CalculationsState/PipingFailureMechanismViewTest.cs =================================================================== diff -u --- Riskeer/Piping/test/Riskeer.Piping.Forms.Test/Views/CalculationsState/PipingFailureMechanismViewTest.cs (revision 0) +++ Riskeer/Piping/test/Riskeer.Piping.Forms.Test/Views/CalculationsState/PipingFailureMechanismViewTest.cs (revision 4833951758a4115a1ae02558a02696f2dedf4950) @@ -0,0 +1,1026 @@ +// Copyright (C) Stichting Deltares 2021. All rights reserved. +// +// This file is part of Riskeer. +// +// Riskeer is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this program. If not, see . +// +// All names, logos, and references to "Deltares" are registered trademarks of +// Stichting Deltares and remain full property of Stichting Deltares at all times. +// All rights reserved. + +using System; +using System.Collections.Generic; +using System.Collections.ObjectModel; +using System.Linq; +using System.Threading; +using System.Windows.Forms; +using Core.Common.Base; +using Core.Common.Base.Geometry; +using Core.Components.Gis.Data; +using Core.Components.Gis.Features; +using Core.Components.Gis.Forms; +using Core.Components.Gis.Geometries; +using NUnit.Framework; +using Rhino.Mocks; +using Riskeer.Common.Data.AssessmentSection; +using Riskeer.Common.Data.FailureMechanism; +using Riskeer.Common.Data.Hydraulics; +using Riskeer.Common.Data.TestUtil; +using Riskeer.Common.Forms.TestUtil; +using Riskeer.Common.Forms.Views; +using Riskeer.Piping.Data; +using Riskeer.Piping.Data.Probabilistic; +using Riskeer.Piping.Data.SemiProbabilistic; +using Riskeer.Piping.Data.SoilProfile; +using Riskeer.Piping.Data.TestUtil; +using Riskeer.Piping.Data.TestUtil.Probabilistic; +using Riskeer.Piping.Data.TestUtil.SemiProbabilistic; +using Riskeer.Piping.Forms.Views.CalculationsState; +using Riskeer.Piping.Primitives; + +namespace Riskeer.Piping.Forms.Test.Views.CalculationsState +{ + [TestFixture] + public class PipingFailureMechanismViewTest + { + private const int referenceLineIndex = 0; + private const int stochasticSoilModelsIndex = 1; + private const int surfaceLinesIndex = 2; + private const int sectionsCollectionIndex = 3; + private const int hydraulicBoundaryLocationsIndex = 4; + private const int probabilisticCalculationsIndex = 5; + private const int semiProbabilisticCalculationsIndex = 6; + + private const int sectionsIndex = 0; + private const int sectionsStartPointIndex = 1; + private const int sectionsEndPointIndex = 2; + + private const int semiProbabilisticCalculationObserverIndex = 3; + private const int probabilisticCalculationObserverIndex = 4; + private const int sectionsObserverIndex = 5; + private const int sectionsStartPointObserverIndex = 6; + private const int sectionsEndPointObserverIndex = 7; + + private Form testForm; + + [SetUp] + public void Setup() + { + testForm = new Form(); + } + + [TearDown] + public void TearDown() + { + testForm.Dispose(); + } + + [Test] + public void Constructor_FailureMechanismNull_ThrowsArgumentNullException() + { + // Setup + var mocks = new MockRepository(); + var assessmentSection = mocks.Stub(); + mocks.ReplayAll(); + + // Call + void Call() => new PipingFailureMechanismView(null, assessmentSection); + + // Assert + var exception = Assert.Throws(Call); + Assert.AreEqual("failureMechanism", exception.ParamName); + mocks.VerifyAll(); + } + + [Test] + public void Constructor_AssessmentSectionNull_ThrowsArgumentNullException() + { + // Call + void Call() => new PipingFailureMechanismView(new PipingFailureMechanism(), null); + + // Assert + var exception = Assert.Throws(Call); + Assert.AreEqual("assessmentSection", exception.ParamName); + } + + [Test] + [Apartment(ApartmentState.STA)] + public void Constructor_ExpectedValues() + { + // Setup + var failureMechanism = new PipingFailureMechanism(); + var assessmentSection = new AssessmentSectionStub(); + + // Call + PipingFailureMechanismView view = CreateView(failureMechanism, assessmentSection); + + // Assert + Assert.IsInstanceOf(view); + Assert.IsInstanceOf(view); + Assert.IsNull(view.Data); + Assert.AreSame(failureMechanism, view.FailureMechanism); + Assert.AreSame(assessmentSection, view.AssessmentSection); + + Assert.AreEqual(1, view.Controls.Count); + Assert.IsInstanceOf(view.Controls[0]); + Assert.AreSame(view.Map, ((RiskeerMapControl) view.Controls[0]).MapControl); + Assert.AreEqual(DockStyle.Fill, ((Control) view.Map).Dock); + AssertEmptyMapData(view.Map.Data); + } + + [Test] + [Apartment(ApartmentState.STA)] + public void Constructor_AssessmentSectionWithBackgroundData_BackgroundDataSet() + { + // Setup + var assessmentSection = new AssessmentSectionStub(); + + // Call + PipingFailureMechanismView view = CreateView(new PipingFailureMechanism(), assessmentSection); + + // Assert + MapDataTestHelper.AssertImageBasedMapData(assessmentSection.BackgroundData, view.Map.BackgroundMapData); + } + + [Test] + [Apartment(ApartmentState.STA)] + public void Constructor_WithAllData_DataUpdatedToCollectionOfFilledMapData() + { + // Setup + PipingStochasticSoilModel stochasticSoilModel1 = PipingStochasticSoilModelTestFactory.CreatePipingStochasticSoilModel("name1", new[] + { + new Point2D(1.0, 2.0), + new Point2D(1.1, 2.2) + }); + + PipingStochasticSoilModel stochasticSoilModel2 = PipingStochasticSoilModelTestFactory.CreatePipingStochasticSoilModel("name2", new[] + { + new Point2D(3.0, 4.0), + new Point2D(3.3, 4.4) + }); + + var surfaceLineA = new PipingSurfaceLine("Line A"); + surfaceLineA.SetGeometry(new[] + { + new Point3D(0.0, 0.0, 1.0), + new Point3D(3.0, 0.0, 1.7) + }); + + var surfaceLineB = new PipingSurfaceLine("Name B"); + surfaceLineB.SetGeometry(new[] + { + new Point3D(0.0, 0.0, 1.5), + new Point3D(3.0, 0.0, 1.8) + }); + surfaceLineA.ReferenceLineIntersectionWorldPoint = new Point2D(1.3, 1.3); + surfaceLineB.ReferenceLineIntersectionWorldPoint = new Point2D(1.5, 1.5); + + var failureMechanism = new PipingFailureMechanism(); + const string arbitraryFilePath = "path"; + var geometryPoints = new[] + { + new Point2D(0.0, 0.0), + new Point2D(2.0, 0.0), + new Point2D(4.0, 4.0), + new Point2D(6.0, 4.0) + }; + failureMechanism.SurfaceLines.AddRange(new[] + { + surfaceLineA, + surfaceLineB + }, arbitraryFilePath); + FailureMechanismTestHelper.SetSections(failureMechanism, new[] + { + new FailureMechanismSection("A", geometryPoints.Take(2)), + new FailureMechanismSection("B", geometryPoints.Skip(1).Take(2)), + new FailureMechanismSection("C", geometryPoints.Skip(2).Take(2)) + }); + failureMechanism.StochasticSoilModels.AddRange(new[] + { + stochasticSoilModel1, + stochasticSoilModel2 + }, arbitraryFilePath); + + var hydraulicBoundaryLocation1 = new HydraulicBoundaryLocation(1, "test", 1.0, 2.0); + var hydraulicBoundaryLocation2 = new HydraulicBoundaryLocation(2, "test", 3.0, 4.0); + + var calculationA = + SemiProbabilisticPipingCalculationTestFactory.CreateCalculationWithValidInput( + hydraulicBoundaryLocation1); + var calculationB = + ProbabilisticPipingCalculationTestFactory.CreateCalculationWithValidInput( + hydraulicBoundaryLocation2); + + calculationA.InputParameters.SurfaceLine = surfaceLineA; + calculationB.InputParameters.SurfaceLine = surfaceLineB; + + failureMechanism.CalculationsGroup.Children.Add(calculationA); + failureMechanism.CalculationsGroup.Children.Add(calculationB); + + var referenceLine = new ReferenceLine(); + referenceLine.SetGeometry(new[] + { + new Point2D(0.0, 3.0), + new Point2D(3.0, 0.0) + }); + + var assessmentSection = new AssessmentSectionStub + { + ReferenceLine = referenceLine + }; + + assessmentSection.SetHydraulicBoundaryLocationCalculations(new[] + { + hydraulicBoundaryLocation1, + hydraulicBoundaryLocation2 + }); + + // Call + PipingFailureMechanismView view = CreateView(failureMechanism, assessmentSection); + + IMapControl map = ((RiskeerMapControl) view.Controls[0]).MapControl; + + // Assert + MapDataCollection mapData = map.Data; + Assert.IsInstanceOf(mapData); + + List mapDataList = mapData.Collection.ToList(); + Assert.AreEqual(7, mapDataList.Count); + MapDataTestHelper.AssertReferenceLineMapData(assessmentSection.ReferenceLine, mapDataList[referenceLineIndex]); + AssertSurfaceLinesMapData(failureMechanism.SurfaceLines, mapDataList[surfaceLinesIndex]); + + IEnumerable sectionsCollection = ((MapDataCollection) mapDataList[sectionsCollectionIndex]).Collection; + MapDataTestHelper.AssertFailureMechanismSectionsMapData(failureMechanism.Sections, sectionsCollection.ElementAt(sectionsIndex)); + MapDataTestHelper.AssertFailureMechanismSectionsStartPointMapData(failureMechanism.Sections, sectionsCollection.ElementAt(sectionsStartPointIndex)); + MapDataTestHelper.AssertFailureMechanismSectionsEndPointMapData(failureMechanism.Sections, sectionsCollection.ElementAt(sectionsEndPointIndex)); + + MapDataTestHelper.AssertHydraulicBoundaryLocationsMapData(assessmentSection, mapDataList[hydraulicBoundaryLocationsIndex]); + AssertStochasticSoilModelsMapData(failureMechanism.StochasticSoilModels, mapDataList[stochasticSoilModelsIndex]); + AssertProbabilisticCalculationsMapData(failureMechanism.Calculations.OfType(), mapDataList[probabilisticCalculationsIndex]); + AssertSemiProbabilisticCalculationsMapData(failureMechanism.Calculations.OfType(), mapDataList[semiProbabilisticCalculationsIndex]); + } + + [Test] + [Apartment(ApartmentState.STA)] + public void GivenViewWithAssessmentSectionData_WhenAssessmentSectionUpdatedAndNotified_ThenMapDataUpdated() + { + // Given + var referenceLine = new ReferenceLine(); + referenceLine.SetGeometry(new List + { + new Point2D(1.0, 2.0), + new Point2D(2.0, 1.0) + }); + var assessmentSection = new AssessmentSectionStub + { + ReferenceLine = referenceLine + }; + + PipingFailureMechanismView view = CreateView(new PipingFailureMechanism(), assessmentSection); + + IMapControl map = ((RiskeerMapControl) view.Controls[0]).MapControl; + + var mocks = new MockRepository(); + IObserver[] observers = AttachMapDataObservers(mocks, map.Data.Collection); + observers[referenceLineIndex].Expect(obs => obs.UpdateObserver()); + mocks.ReplayAll(); + + var referenceLineMapData = (MapLineData) map.Data.Collection.ElementAt(referenceLineIndex); + + // Precondition + MapFeaturesTestHelper.AssertReferenceLineMetaData(assessmentSection.ReferenceLine, assessmentSection, referenceLineMapData.Features); + + // When + assessmentSection.Name = "New name"; + assessmentSection.NotifyObservers(); + + // Then + MapFeaturesTestHelper.AssertReferenceLineMetaData(assessmentSection.ReferenceLine, assessmentSection, referenceLineMapData.Features); + mocks.VerifyAll(); + } + + [Test] + [Apartment(ApartmentState.STA)] + public void GivenViewWithReferenceLineData_WhenReferenceLineUpdatedAndNotified_ThenMapDataUpdated() + { + // Given + var referenceLine = new ReferenceLine(); + referenceLine.SetGeometry(new List + { + new Point2D(1.0, 2.0), + new Point2D(2.0, 1.0) + }); + var assessmentSection = new AssessmentSectionStub + { + ReferenceLine = referenceLine + }; + + PipingFailureMechanismView view = CreateView(new PipingFailureMechanism(), assessmentSection); + + IMapControl map = ((RiskeerMapControl) view.Controls[0]).MapControl; + + var mocks = new MockRepository(); + IObserver[] observers = AttachMapDataObservers(mocks, map.Data.Collection); + observers[referenceLineIndex].Expect(obs => obs.UpdateObserver()); + mocks.ReplayAll(); + + MapData referenceLineMapData = map.Data.Collection.ElementAt(referenceLineIndex); + + // Precondition + MapDataTestHelper.AssertReferenceLineMapData(assessmentSection.ReferenceLine, referenceLineMapData); + + // When + referenceLine.SetGeometry(new List + { + new Point2D(2.0, 5.0), + new Point2D(4.0, 3.0) + }); + referenceLine.NotifyObservers(); + + // Then + MapDataTestHelper.AssertReferenceLineMapData(assessmentSection.ReferenceLine, referenceLineMapData); + mocks.VerifyAll(); + } + + [Test] + [Apartment(ApartmentState.STA)] + public void GivenViewWithSurfaceLinesData_WhenSurfaceLinesUpdatedAndNotified_ThenMapDataUpdated() + { + // Given + var failureMechanism = new PipingFailureMechanism(); + + PipingFailureMechanismView view = CreateView(failureMechanism, new AssessmentSectionStub()); + + IMapControl map = ((RiskeerMapControl) view.Controls[0]).MapControl; + var surfaceLine = new PipingSurfaceLine(string.Empty); + + surfaceLine.SetGeometry(new Collection + { + new Point3D(1, 2, 3), + new Point3D(4, 5, 6) + }); + + var surfaceLineMapData = (MapLineData) map.Data.Collection.ElementAt(surfaceLinesIndex); + + var mocks = new MockRepository(); + IObserver[] observers = AttachMapDataObservers(mocks, map.Data.Collection); + observers[surfaceLinesIndex].Expect(obs => obs.UpdateObserver()); + mocks.ReplayAll(); + + // When + failureMechanism.SurfaceLines.AddRange(new[] + { + surfaceLine + }, "path"); + failureMechanism.SurfaceLines.NotifyObservers(); + + // Then + AssertSurfaceLinesMapData(failureMechanism.SurfaceLines, surfaceLineMapData); + mocks.VerifyAll(); + } + + [Test] + [Apartment(ApartmentState.STA)] + public void GivenViewWithSurfaceLineData_WhenSurfaceLineUpdatedAndNotified_ThenMapDataUpdated() + { + // Given + var surfaceLine = new PipingSurfaceLine(string.Empty); + var failureMechanism = new PipingFailureMechanism(); + failureMechanism.SurfaceLines.AddRange(new[] + { + surfaceLine + }, "path"); + + PipingFailureMechanismView view = CreateView(failureMechanism, new AssessmentSectionStub()); + + IMapControl map = ((RiskeerMapControl) view.Controls[0]).MapControl; + + var mocks = new MockRepository(); + IObserver[] observers = AttachMapDataObservers(mocks, map.Data.Collection); + observers[surfaceLinesIndex].Expect(obs => obs.UpdateObserver()); + mocks.ReplayAll(); + + // When + surfaceLine.SetGeometry(new[] + { + new Point3D(7, 8, 9), + new Point3D(10, 11, 12) + }); + surfaceLine.NotifyObservers(); + + // Then + var surfaceLineMapData = (MapLineData) map.Data.Collection.ElementAt(surfaceLinesIndex); + AssertSurfaceLinesMapData(failureMechanism.SurfaceLines, surfaceLineMapData); + mocks.VerifyAll(); + } + + [Test] + [Apartment(ApartmentState.STA)] + public void GivenViewWithFailureMechanismSectionsData_WhenFailureMechanismSectionsUpdatedAndNotified_ThenMapDataUpdated() + { + // Given + var failureMechanism = new PipingFailureMechanism(); + + PipingFailureMechanismView view = CreateView(failureMechanism, new AssessmentSectionStub()); + + IMapControl map = ((RiskeerMapControl) view.Controls[0]).MapControl; + + IEnumerable sectionsCollection = ((MapDataCollection) map.Data.Collection.ElementAt(sectionsCollectionIndex)).Collection; + var sectionMapData = (MapLineData) sectionsCollection.ElementAt(sectionsIndex); + var sectionStartsMapData = (MapPointData) sectionsCollection.ElementAt(sectionsStartPointIndex); + var sectionsEndsMapData = (MapPointData) sectionsCollection.ElementAt(sectionsEndPointIndex); + + var mocks = new MockRepository(); + IObserver[] observers = AttachMapDataObservers(mocks, map.Data.Collection); + observers[sectionsObserverIndex].Expect(obs => obs.UpdateObserver()); + observers[sectionsStartPointObserverIndex].Expect(obs => obs.UpdateObserver()); + observers[sectionsEndPointObserverIndex].Expect(obs => obs.UpdateObserver()); + mocks.ReplayAll(); + + // When + FailureMechanismTestHelper.SetSections(failureMechanism, new[] + { + new FailureMechanismSection(string.Empty, new[] + { + new Point2D(1, 2), + new Point2D(1, 2) + }) + }); + failureMechanism.NotifyObservers(); + + // Then + MapDataTestHelper.AssertFailureMechanismSectionsMapData(failureMechanism.Sections, sectionMapData); + MapDataTestHelper.AssertFailureMechanismSectionsStartPointMapData(failureMechanism.Sections, sectionStartsMapData); + MapDataTestHelper.AssertFailureMechanismSectionsEndPointMapData(failureMechanism.Sections, sectionsEndsMapData); + mocks.VerifyAll(); + } + + [Test] + [Apartment(ApartmentState.STA)] + public void GivenViewWithStochasticSoilModels_WhenStochasticSoilModelsUpdatedAndNotified_ThenMapDataUpdated() + { + // Given + var failureMechanism = new PipingFailureMechanism(); + + PipingFailureMechanismView view = CreateView(failureMechanism, new AssessmentSectionStub()); + + IMapControl map = ((RiskeerMapControl) view.Controls[0]).MapControl; + + PipingStochasticSoilModel stochasticSoilModel = PipingStochasticSoilModelTestFactory.CreatePipingStochasticSoilModel("", new[] + { + new Point2D(1, 2), + new Point2D(1, 2) + }); + + var stochasticSoilModelMapData = (MapLineData) map.Data.Collection.ElementAt(stochasticSoilModelsIndex); + + var mocks = new MockRepository(); + IObserver[] observers = AttachMapDataObservers(mocks, map.Data.Collection); + observers[stochasticSoilModelsIndex].Expect(obs => obs.UpdateObserver()); + mocks.ReplayAll(); + + // When + failureMechanism.StochasticSoilModels.AddRange(new[] + { + stochasticSoilModel + }, "path"); + failureMechanism.StochasticSoilModels.NotifyObservers(); + + // Then + AssertStochasticSoilModelsMapData(failureMechanism.StochasticSoilModels, stochasticSoilModelMapData); + mocks.VerifyAll(); + } + + [Test] + [Apartment(ApartmentState.STA)] + public void GivenViewWithCalculationGroupData_WhenCalculationGroupUpdatedAndNotified_ThenMapDataUpdated() + { + // Given + var failureMechanism = new PipingFailureMechanism(); + + PipingFailureMechanismView view = CreateView(failureMechanism, new AssessmentSectionStub()); + + IMapControl map = ((RiskeerMapControl) view.Controls[0]).MapControl; + + var surfaceLineA = new PipingSurfaceLine(string.Empty); + surfaceLineA.SetGeometry(new[] + { + new Point3D(0.0, 0.0, 1.0), + new Point3D(3.0, 0.0, 1.7) + }); + + var surfaceLineB = new PipingSurfaceLine(string.Empty); + surfaceLineB.SetGeometry(new[] + { + new Point3D(0.0, 0.0, 1.5), + new Point3D(3.0, 0.0, 1.8) + }); + surfaceLineA.ReferenceLineIntersectionWorldPoint = new Point2D(1.3, 1.3); + surfaceLineB.ReferenceLineIntersectionWorldPoint = new Point2D(1.5, 1.5); + + var calculationA = + SemiProbabilisticPipingCalculationTestFactory.CreateCalculationWithValidInput( + new TestHydraulicBoundaryLocation()); + var calculationB = + ProbabilisticPipingCalculationTestFactory.CreateCalculationWithValidInput( + new TestHydraulicBoundaryLocation()); + + calculationA.InputParameters.SurfaceLine = surfaceLineA; + calculationB.InputParameters.SurfaceLine = surfaceLineB; + + failureMechanism.CalculationsGroup.Children.Add(calculationA); + failureMechanism.CalculationsGroup.Children.Add(calculationB); + + var probabilisticCalculationMapData = (MapLineData) map.Data.Collection.ElementAt(probabilisticCalculationsIndex); + var semiProbabilisticCalculationMapData = (MapLineData) map.Data.Collection.ElementAt(semiProbabilisticCalculationsIndex); + + var mocks = new MockRepository(); + IObserver[] observers = AttachMapDataObservers(mocks, map.Data.Collection); + observers[semiProbabilisticCalculationObserverIndex].Expect(obs => obs.UpdateObserver()); + observers[probabilisticCalculationObserverIndex].Expect(obs => obs.UpdateObserver()); + mocks.ReplayAll(); + + // When + failureMechanism.CalculationsGroup.Children.Add(calculationB); + failureMechanism.CalculationsGroup.NotifyObservers(); + + // Then + AssertSemiProbabilisticCalculationsMapData(failureMechanism.Calculations.OfType(), semiProbabilisticCalculationMapData); + AssertProbabilisticCalculationsMapData(failureMechanism.Calculations.OfType(), probabilisticCalculationMapData); + mocks.VerifyAll(); + } + + [Test] + [Apartment(ApartmentState.STA)] + public void GivenViewWithSemiProbabilisticCalculationInputData_WhenCalculationInputUpdatedAndNotified_ThenMapDataUpdated() + { + // Given + var surfaceLineA = new PipingSurfaceLine(string.Empty); + surfaceLineA.SetGeometry(new[] + { + new Point3D(0.0, 0.0, 1.0), + new Point3D(3.0, 0.0, 1.7) + }); + + var surfaceLineB = new PipingSurfaceLine(string.Empty); + surfaceLineB.SetGeometry(new[] + { + new Point3D(0.0, 0.0, 1.5), + new Point3D(3.0, 0.0, 1.8) + }); + surfaceLineA.ReferenceLineIntersectionWorldPoint = new Point2D(1.3, 1.3); + surfaceLineB.ReferenceLineIntersectionWorldPoint = new Point2D(1.5, 1.5); + + var calculationScenario = + SemiProbabilisticPipingCalculationTestFactory.CreateCalculationWithValidInput( + new TestHydraulicBoundaryLocation()); + + calculationScenario.InputParameters.SurfaceLine = surfaceLineA; + + var failureMechanism = new PipingFailureMechanism(); + failureMechanism.CalculationsGroup.Children.Add(calculationScenario); + + PipingFailureMechanismView view = CreateView(failureMechanism, new AssessmentSectionStub()); + + IMapControl map = ((RiskeerMapControl) view.Controls[0]).MapControl; + + var calculationMapData = (MapLineData) map.Data.Collection.ElementAt(semiProbabilisticCalculationsIndex); + + var mocks = new MockRepository(); + IObserver[] observers = AttachMapDataObservers(mocks, map.Data.Collection); + observers[semiProbabilisticCalculationObserverIndex].Expect(obs => obs.UpdateObserver()); + mocks.ReplayAll(); + + // When + calculationScenario.InputParameters.SurfaceLine = surfaceLineB; + calculationScenario.InputParameters.NotifyObservers(); + + // Then + AssertSemiProbabilisticCalculationsMapData(failureMechanism.Calculations.Cast(), calculationMapData); + mocks.VerifyAll(); + } + + [Test] + [Apartment(ApartmentState.STA)] + public void GivenViewWithProbabilisticCalculationInputData_WhenCalculationInputUpdatedAndNotified_ThenMapDataUpdated() + { + // Given + var surfaceLineA = new PipingSurfaceLine(string.Empty); + surfaceLineA.SetGeometry(new[] + { + new Point3D(0.0, 0.0, 1.0), + new Point3D(3.0, 0.0, 1.7) + }); + + var surfaceLineB = new PipingSurfaceLine(string.Empty); + surfaceLineB.SetGeometry(new[] + { + new Point3D(0.0, 0.0, 1.5), + new Point3D(3.0, 0.0, 1.8) + }); + surfaceLineA.ReferenceLineIntersectionWorldPoint = new Point2D(1.3, 1.3); + surfaceLineB.ReferenceLineIntersectionWorldPoint = new Point2D(1.5, 1.5); + + var calculationScenario = + ProbabilisticPipingCalculationTestFactory.CreateCalculationWithValidInput( + new TestHydraulicBoundaryLocation()); + + calculationScenario.InputParameters.SurfaceLine = surfaceLineA; + + var failureMechanism = new PipingFailureMechanism(); + failureMechanism.CalculationsGroup.Children.Add(calculationScenario); + + PipingFailureMechanismView view = CreateView(failureMechanism, new AssessmentSectionStub()); + + IMapControl map = ((RiskeerMapControl) view.Controls[0]).MapControl; + + var calculationMapData = (MapLineData) map.Data.Collection.ElementAt(probabilisticCalculationsIndex); + + var mocks = new MockRepository(); + IObserver[] observers = AttachMapDataObservers(mocks, map.Data.Collection); + observers[probabilisticCalculationObserverIndex].Expect(obs => obs.UpdateObserver()); + mocks.ReplayAll(); + + // When + calculationScenario.InputParameters.SurfaceLine = surfaceLineB; + calculationScenario.InputParameters.NotifyObservers(); + + // Then + AssertProbabilisticCalculationsMapData(failureMechanism.Calculations.Cast(), calculationMapData); + mocks.VerifyAll(); + } + + [Test] + [Apartment(ApartmentState.STA)] + public void GivenViewWithSemiProbabilisticCalculationData_WhenCalculationUpdatedAndNotified_ThenMapDataUpdated() + { + // Given + var surfaceLineA = new PipingSurfaceLine(string.Empty); + surfaceLineA.SetGeometry(new[] + { + new Point3D(0.0, 0.0, 1.0), + new Point3D(3.0, 0.0, 1.7) + }); + + var surfaceLineB = new PipingSurfaceLine(string.Empty); + surfaceLineB.SetGeometry(new[] + { + new Point3D(0.0, 0.0, 1.5), + new Point3D(3.0, 0.0, 1.8) + }); + surfaceLineA.ReferenceLineIntersectionWorldPoint = new Point2D(1.3, 1.3); + surfaceLineB.ReferenceLineIntersectionWorldPoint = new Point2D(1.5, 1.5); + + var calculationScenario = + SemiProbabilisticPipingCalculationTestFactory.CreateCalculationWithValidInput( + new TestHydraulicBoundaryLocation()); + + calculationScenario.InputParameters.SurfaceLine = surfaceLineA; + + var failureMechanism = new PipingFailureMechanism(); + failureMechanism.CalculationsGroup.Children.Add(calculationScenario); + + PipingFailureMechanismView view = CreateView(failureMechanism, new AssessmentSectionStub()); + + IMapControl map = ((RiskeerMapControl) view.Controls[0]).MapControl; + + var calculationMapData = (MapLineData) map.Data.Collection.ElementAt(semiProbabilisticCalculationsIndex); + + var mocks = new MockRepository(); + IObserver[] observers = AttachMapDataObservers(mocks, map.Data.Collection); + observers[semiProbabilisticCalculationObserverIndex].Expect(obs => obs.UpdateObserver()); + mocks.ReplayAll(); + + // When + calculationScenario.Name = "new name"; + calculationScenario.NotifyObservers(); + + // Then + AssertSemiProbabilisticCalculationsMapData(failureMechanism.Calculations.Cast(), calculationMapData); + mocks.VerifyAll(); + } + + [Test] + [Apartment(ApartmentState.STA)] + public void GivenViewWithProbabilisticCalculationData_WhenCalculationUpdatedAndNotified_ThenMapDataUpdated() + { + // Given + var surfaceLineA = new PipingSurfaceLine(string.Empty); + surfaceLineA.SetGeometry(new[] + { + new Point3D(0.0, 0.0, 1.0), + new Point3D(3.0, 0.0, 1.7) + }); + + var surfaceLineB = new PipingSurfaceLine(string.Empty); + surfaceLineB.SetGeometry(new[] + { + new Point3D(0.0, 0.0, 1.5), + new Point3D(3.0, 0.0, 1.8) + }); + surfaceLineA.ReferenceLineIntersectionWorldPoint = new Point2D(1.3, 1.3); + surfaceLineB.ReferenceLineIntersectionWorldPoint = new Point2D(1.5, 1.5); + + var calculationScenario = + ProbabilisticPipingCalculationTestFactory.CreateCalculationWithValidInput( + new TestHydraulicBoundaryLocation()); + + calculationScenario.InputParameters.SurfaceLine = surfaceLineA; + + var failureMechanism = new PipingFailureMechanism(); + failureMechanism.CalculationsGroup.Children.Add(calculationScenario); + + PipingFailureMechanismView view = CreateView(failureMechanism, new AssessmentSectionStub()); + + IMapControl map = ((RiskeerMapControl) view.Controls[0]).MapControl; + + var calculationMapData = (MapLineData) map.Data.Collection.ElementAt(probabilisticCalculationsIndex); + + var mocks = new MockRepository(); + IObserver[] observers = AttachMapDataObservers(mocks, map.Data.Collection); + observers[probabilisticCalculationObserverIndex].Expect(obs => obs.UpdateObserver()); + mocks.ReplayAll(); + + // When + calculationScenario.Name = "new name"; + calculationScenario.NotifyObservers(); + + // Then + AssertProbabilisticCalculationsMapData(failureMechanism.Calculations.Cast(), calculationMapData); + mocks.VerifyAll(); + } + + [Test] + [Apartment(ApartmentState.STA)] + public void UpdateObserver_DataUpdated_MapLayersSameOrder() + { + // Setup + const int updatedReferenceLineLayerIndex = referenceLineIndex + 6; + const int updatedSurfaceLineLayerIndex = surfaceLinesIndex - 1; + const int updatedSectionCollectionIndex = sectionsCollectionIndex - 1; + const int updatedHydraulicLocationsLayerIndex = hydraulicBoundaryLocationsIndex - 1; + const int updatedStochasticSoilModelsLayerIndex = stochasticSoilModelsIndex - 1; + const int updatedProbabilisticCalculationsIndex = probabilisticCalculationsIndex - 1; + const int updatedSemiProbabilisticCalculationsIndex = semiProbabilisticCalculationsIndex - 1; + + var assessmentSection = new AssessmentSectionStub(); + + PipingFailureMechanismView view = CreateView(new PipingFailureMechanism(), assessmentSection); + + IMapControl map = ((RiskeerMapControl) view.Controls[0]).MapControl; + + MapDataCollection mapData = map.Data; + + var dataToMove = (MapLineData) map.Data.Collection.ElementAt(referenceLineIndex); + mapData.Remove(dataToMove); + mapData.Add(dataToMove); + + IEnumerable mapDataCollection = mapData.Collection; + + // Precondition + var referenceLineData = (MapLineData) mapDataCollection.ElementAt(updatedReferenceLineLayerIndex); + Assert.AreEqual("Referentielijn", referenceLineData.Name); + + var surfaceLineData = (MapLineData) mapDataCollection.ElementAt(updatedSurfaceLineLayerIndex); + Assert.AreEqual("Profielschematisaties", surfaceLineData.Name); + + var sectionsData = (MapDataCollection) mapDataCollection.ElementAt(updatedSectionCollectionIndex); + Assert.AreEqual("Vakindeling", sectionsData.Name); + + var hydraulicLocationsData = (MapPointData) mapDataCollection.ElementAt(updatedHydraulicLocationsLayerIndex); + Assert.AreEqual("Hydraulische belastingen", hydraulicLocationsData.Name); + + var stochasticSoilModelsData = (MapLineData) mapDataCollection.ElementAt(updatedStochasticSoilModelsLayerIndex); + Assert.AreEqual("Stochastische ondergrondmodellen", stochasticSoilModelsData.Name); + + var probabilisticCalculationsData = (MapLineData) mapDataCollection.ElementAt(updatedProbabilisticCalculationsIndex); + Assert.AreEqual("Probabilistische berekeningen", probabilisticCalculationsData.Name); + + var semiProbabilisticCalculationsData = (MapLineData) mapDataCollection.ElementAt(updatedSemiProbabilisticCalculationsIndex); + Assert.AreEqual("Semi-probabilistische berekeningen", semiProbabilisticCalculationsData.Name); + + var points = new List + { + new Point2D(2.0, 5.0), + new Point2D(4.0, 3.0) + }; + var referenceLine = new ReferenceLine(); + referenceLine.SetGeometry(points); + assessmentSection.ReferenceLine = referenceLine; + + // Call + assessmentSection.NotifyObservers(); + + // Assert + var actualReferenceLineData = (MapLineData) mapDataCollection.ElementAt(updatedReferenceLineLayerIndex); + Assert.AreEqual("Referentielijn", actualReferenceLineData.Name); + + var actualSurfaceLineData = (MapLineData) mapDataCollection.ElementAt(updatedSurfaceLineLayerIndex); + Assert.AreEqual("Profielschematisaties", actualSurfaceLineData.Name); + + var actualSectionsData = (MapDataCollection) mapDataCollection.ElementAt(updatedSectionCollectionIndex); + Assert.AreEqual("Vakindeling", actualSectionsData.Name); + + var actualHydraulicLocationsData = (MapPointData) mapDataCollection.ElementAt(updatedHydraulicLocationsLayerIndex); + Assert.AreEqual("Hydraulische belastingen", actualHydraulicLocationsData.Name); + + var actualStochasticSoilModelsData = (MapLineData) mapDataCollection.ElementAt(updatedStochasticSoilModelsLayerIndex); + Assert.AreEqual("Stochastische ondergrondmodellen", actualStochasticSoilModelsData.Name); + + var actualSemiProbabilisticCalculationsData = (MapLineData) mapDataCollection.ElementAt(updatedSemiProbabilisticCalculationsIndex); + Assert.AreEqual("Semi-probabilistische berekeningen", actualSemiProbabilisticCalculationsData.Name); + + var actualProbabilisticCalculationsData = (MapLineData) mapDataCollection.ElementAt(updatedProbabilisticCalculationsIndex); + Assert.AreEqual("Probabilistische berekeningen", actualProbabilisticCalculationsData.Name); + } + + private PipingFailureMechanismView CreateView(PipingFailureMechanism failureMechanism, IAssessmentSection assessmentSection) + { + var view = new PipingFailureMechanismView(failureMechanism, assessmentSection); + + testForm.Controls.Add(view); + testForm.Show(); + + return view; + } + + private static void AssertSurfaceLinesMapData(IEnumerable surfaceLines, MapData mapData) + { + Assert.IsInstanceOf(mapData); + var surfaceLinesMapData = (MapLineData) mapData; + MapFeature[] surfaceLineFeatures = surfaceLinesMapData.Features.ToArray(); + PipingSurfaceLine[] surfaceLinesArray = surfaceLines.ToArray(); + Assert.AreEqual(surfaceLinesArray.Length, surfaceLineFeatures.Length); + + for (var index = 0; index < surfaceLinesArray.Length; index++) + { + Assert.AreEqual(1, surfaceLineFeatures[index].MapGeometries.Count()); + PipingSurfaceLine surfaceLine = surfaceLinesArray[index]; + CollectionAssert.AreEquivalent(surfaceLine.Points.Select(p => new Point2D(p.X, p.Y)), surfaceLineFeatures[index].MapGeometries.First().PointCollections.First()); + } + + Assert.AreEqual("Profielschematisaties", mapData.Name); + } + + private static void AssertStochasticSoilModelsMapData(IEnumerable soilModels, MapData mapData) + { + Assert.IsInstanceOf(mapData); + var soilModelsMapData = (MapLineData) mapData; + MapFeature[] soilModelsFeatures = soilModelsMapData.Features.ToArray(); + PipingStochasticSoilModel[] stochasticSoilModelsArray = soilModels.ToArray(); + Assert.AreEqual(stochasticSoilModelsArray.Length, soilModelsFeatures.Length); + + for (var index = 0; index < stochasticSoilModelsArray.Length; index++) + { + Assert.AreEqual(1, soilModelsFeatures[index].MapGeometries.Count()); + PipingStochasticSoilModel stochasticSoilModel = stochasticSoilModelsArray[index]; + CollectionAssert.AreEquivalent(stochasticSoilModel.Geometry.Select(p => new Point2D(p)), soilModelsFeatures[index].MapGeometries.First().PointCollections.First()); + } + + Assert.AreEqual("Stochastische ondergrondmodellen", mapData.Name); + } + + private static void AssertSemiProbabilisticCalculationsMapData(IEnumerable calculations, MapData mapData) + { + Assert.AreEqual("Semi-probabilistische berekeningen", mapData.Name); + AssertCalculationsMapData(calculations, mapData); + } + + private static void AssertProbabilisticCalculationsMapData(IEnumerable calculations, MapData mapData) + { + Assert.AreEqual("Probabilistische berekeningen", mapData.Name); + AssertCalculationsMapData(calculations, mapData); + } + + private static void AssertCalculationsMapData(IEnumerable calculations, MapData mapData) + where TCalculationScenario : IPipingCalculationScenario + { + Assert.IsInstanceOf(mapData); + var calculationsMapData = (MapLineData) mapData; + TCalculationScenario[] calculationsArray = calculations.ToArray(); + MapFeature[] calculationsFeatures = calculationsMapData.Features.ToArray(); + Assert.AreEqual(calculationsArray.Length, calculationsFeatures.Length); + + for (var index = 0; index < calculationsArray.Length; index++) + { + MapGeometry[] geometries = calculationsFeatures[index].MapGeometries.ToArray(); + Assert.AreEqual(1, geometries.Length); + + TCalculationScenario calculation = calculationsArray[index]; + CollectionAssert.AreEquivalent(new[] + { + calculation.InputParameters.SurfaceLine.ReferenceLineIntersectionWorldPoint, + calculation.InputParameters.HydraulicBoundaryLocation.Location + }, + geometries[0].PointCollections.First()); + } + } + + private static void AssertEmptyMapData(MapDataCollection mapDataCollection) + { + Assert.AreEqual("Piping", mapDataCollection.Name); + + List mapDataList = mapDataCollection.Collection.ToList(); + + Assert.AreEqual(7, mapDataList.Count); + + var referenceLineMapData = (MapLineData) mapDataList[referenceLineIndex]; + var stochasticSoilModelsMapData = (MapLineData) mapDataList[stochasticSoilModelsIndex]; + var surfaceLinesMapData = (MapLineData) mapDataList[surfaceLinesIndex]; + var hydraulicBoundaryLocationsMapData = (MapPointData) mapDataList[hydraulicBoundaryLocationsIndex]; + var probabilisticCalculationsMapData = (MapLineData) mapDataList[probabilisticCalculationsIndex]; + var semiProbabilisticCalculationsMapData = (MapLineData) mapDataList[semiProbabilisticCalculationsIndex]; + + CollectionAssert.IsEmpty(referenceLineMapData.Features); + CollectionAssert.IsEmpty(stochasticSoilModelsMapData.Features); + CollectionAssert.IsEmpty(surfaceLinesMapData.Features); + CollectionAssert.IsEmpty(hydraulicBoundaryLocationsMapData.Features); + CollectionAssert.IsEmpty(probabilisticCalculationsMapData.Features); + CollectionAssert.IsEmpty(semiProbabilisticCalculationsMapData.Features); + + Assert.AreEqual("Referentielijn", referenceLineMapData.Name); + Assert.AreEqual("Stochastische ondergrondmodellen", stochasticSoilModelsMapData.Name); + Assert.AreEqual("Profielschematisaties", surfaceLinesMapData.Name); + Assert.AreEqual("Hydraulische belastingen", hydraulicBoundaryLocationsMapData.Name); + Assert.AreEqual("Probabilistische berekeningen", probabilisticCalculationsMapData.Name); + Assert.AreEqual("Semi-probabilistische berekeningen", semiProbabilisticCalculationsMapData.Name); + + var sectionsMapDataCollection = (MapDataCollection) mapDataList[sectionsCollectionIndex]; + Assert.AreEqual("Vakindeling", sectionsMapDataCollection.Name); + List sectionsDataList = sectionsMapDataCollection.Collection.ToList(); + Assert.AreEqual(3, sectionsDataList.Count); + + var sectionsMapData = (MapLineData) sectionsDataList[sectionsIndex]; + var sectionsStartPointMapData = (MapPointData) sectionsDataList[sectionsStartPointIndex]; + var sectionsEndPointMapData = (MapPointData) sectionsDataList[sectionsEndPointIndex]; + + CollectionAssert.IsEmpty(sectionsEndPointMapData.Features); + CollectionAssert.IsEmpty(sectionsStartPointMapData.Features); + CollectionAssert.IsEmpty(sectionsMapData.Features); + + Assert.AreEqual("Vakindeling (eindpunten)", sectionsEndPointMapData.Name); + Assert.AreEqual("Vakindeling (startpunten)", sectionsStartPointMapData.Name); + Assert.AreEqual("Vakindeling", sectionsMapData.Name); + } + + /// + /// Attaches mocked observers to all map data components. + /// + /// The . + /// The map data collection containing the + /// elements. + /// An array of mocked observers attached to the data in . + private static IObserver[] AttachMapDataObservers(MockRepository mocks, IEnumerable mapData) + { + MapData[] mapDataArray = mapData.ToArray(); + + var referenceLineMapDataObserver = mocks.StrictMock(); + mapDataArray[referenceLineIndex].Attach(referenceLineMapDataObserver); + + var stochasticSoilModelsMapDataObserver = mocks.StrictMock(); + mapDataArray[stochasticSoilModelsIndex].Attach(stochasticSoilModelsMapDataObserver); + + var surfaceLinesMapDataObserver = mocks.StrictMock(); + mapDataArray[surfaceLinesIndex].Attach(surfaceLinesMapDataObserver); + + var probabilisticCalculationsMapDataObserver = mocks.StrictMock(); + mapDataArray[probabilisticCalculationsIndex].Attach(probabilisticCalculationsMapDataObserver); + + var semiProbabilisticCalculationsMapDataObserver = mocks.StrictMock(); + mapDataArray[semiProbabilisticCalculationsIndex].Attach(semiProbabilisticCalculationsMapDataObserver); + + MapData[] sectionsCollection = ((MapDataCollection) mapDataArray[sectionsCollectionIndex]).Collection.ToArray(); + var sectionsMapDataObserver = mocks.StrictMock(); + sectionsCollection[sectionsIndex].Attach(sectionsMapDataObserver); + + var sectionsStartPointMapDataObserver = mocks.StrictMock(); + sectionsCollection[sectionsStartPointIndex].Attach(sectionsStartPointMapDataObserver); + + var sectionsEndPointMapDataObserver = mocks.StrictMock(); + sectionsCollection[sectionsEndPointIndex].Attach(sectionsEndPointMapDataObserver); + + return new[] + { + referenceLineMapDataObserver, + stochasticSoilModelsMapDataObserver, + surfaceLinesMapDataObserver, + semiProbabilisticCalculationsMapDataObserver, + probabilisticCalculationsMapDataObserver, + sectionsMapDataObserver, + sectionsStartPointMapDataObserver, + sectionsEndPointMapDataObserver + }; + } + } +} \ No newline at end of file Fisheye: Tag 4833951758a4115a1ae02558a02696f2dedf4950 refers to a dead (removed) revision in file `Riskeer/Piping/test/Riskeer.Piping.Forms.Test/Views/PipingFailureMechanismViewTest.cs'. Fisheye: No comparison available. Pass `N' to diff? Fisheye: Tag 4833951758a4115a1ae02558a02696f2dedf4950 refers to a dead (removed) revision in file `Riskeer/Piping/test/Riskeer.Piping.Forms.Test/Views/PipingFailurePathViewTest.cs'. Fisheye: No comparison available. Pass `N' to diff? Index: Riskeer/Piping/test/Riskeer.Piping.Forms.Test/Views/RegistrationState/PipingFailureMechanismViewTest.cs =================================================================== diff -u --- Riskeer/Piping/test/Riskeer.Piping.Forms.Test/Views/RegistrationState/PipingFailureMechanismViewTest.cs (revision 0) +++ Riskeer/Piping/test/Riskeer.Piping.Forms.Test/Views/RegistrationState/PipingFailureMechanismViewTest.cs (revision 4833951758a4115a1ae02558a02696f2dedf4950) @@ -0,0 +1,451 @@ +// Copyright (C) Stichting Deltares 2021. All rights reserved. +// +// This file is part of Riskeer. +// +// Riskeer is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this program. If not, see . +// +// All names, logos, and references to "Deltares" are registered trademarks of +// Stichting Deltares and remain full property of Stichting Deltares at all times. +// All rights reserved. + +using System.Collections.Generic; +using System.Linq; +using System.Threading; +using System.Windows.Forms; +using Core.Common.Base.Geometry; +using Core.Components.Gis.Data; +using Core.Components.Gis.Features; +using Core.Components.Gis.Forms; +using Core.Components.Gis.Geometries; +using NUnit.Framework; +using Riskeer.AssemblyTool.KernelWrapper.Calculators; +using Riskeer.AssemblyTool.KernelWrapper.TestUtil.Calculators; +using Riskeer.AssemblyTool.KernelWrapper.TestUtil.Calculators.Assembly; +using Riskeer.Common.Data.AssessmentSection; +using Riskeer.Common.Data.FailureMechanism; +using Riskeer.Common.Data.Hydraulics; +using Riskeer.Common.Data.TestUtil; +using Riskeer.Common.Forms.TestUtil; +using Riskeer.Common.Forms.Views; +using Riskeer.Piping.Data; +using Riskeer.Piping.Data.Probabilistic; +using Riskeer.Piping.Data.SemiProbabilistic; +using Riskeer.Piping.Data.SoilProfile; +using Riskeer.Piping.Data.TestUtil; +using Riskeer.Piping.Data.TestUtil.Probabilistic; +using Riskeer.Piping.Data.TestUtil.SemiProbabilistic; +using Riskeer.Piping.Forms.Views.RegistrationState; +using Riskeer.Piping.Primitives; +using CalculationsStateFailureMechanismView = Riskeer.Piping.Forms.Views.CalculationsState.PipingFailureMechanismView; + +namespace Riskeer.Piping.Forms.Test.Views.RegistrationState +{ + [TestFixture] + public class PipingFailureMechanismViewTest + { + private const int referenceLineIndex = 0; + private const int stochasticSoilModelsIndex = 1; + private const int surfaceLinesIndex = 2; + private const int sectionsCollectionIndex = 3; + private const int assemblyResultsIndex = 4; + private const int hydraulicBoundaryLocationsIndex = 5; + private const int probabilisticCalculationsIndex = 6; + private const int semiProbabilisticCalculationsIndex = 7; + + private const int sectionsIndex = 0; + private const int sectionsStartPointIndex = 1; + private const int sectionsEndPointIndex = 2; + + private Form testForm; + + [SetUp] + public void Setup() + { + testForm = new Form(); + } + + [TearDown] + public void TearDown() + { + testForm.Dispose(); + } + + [Test] + [Apartment(ApartmentState.STA)] + public void Constructor_ExpectedValues() + { + // Setup + var failureMechanism = new PipingFailureMechanism(); + var assessmentSection = new AssessmentSectionStub(); + + // Call + PipingFailureMechanismView view = CreateView(failureMechanism, assessmentSection); + + // Assert + Assert.IsInstanceOf(view); + Assert.IsNull(view.Data); + Assert.AreSame(failureMechanism, view.FailureMechanism); + Assert.AreSame(assessmentSection, view.AssessmentSection); + AssertEmptyMapData(view.Map.Data); + } + + [Test] + [Apartment(ApartmentState.STA)] + public void Constructor_WithAllData_DataUpdatedToCollectionOfFilledMapData() + { + // Setup + PipingStochasticSoilModel stochasticSoilModel1 = PipingStochasticSoilModelTestFactory.CreatePipingStochasticSoilModel("name1", new[] + { + new Point2D(1.0, 2.0), + new Point2D(1.1, 2.2) + }); + + PipingStochasticSoilModel stochasticSoilModel2 = PipingStochasticSoilModelTestFactory.CreatePipingStochasticSoilModel("name2", new[] + { + new Point2D(3.0, 4.0), + new Point2D(3.3, 4.4) + }); + + var surfaceLineA = new PipingSurfaceLine("Line A"); + surfaceLineA.SetGeometry(new[] + { + new Point3D(0.0, 0.0, 1.0), + new Point3D(3.0, 0.0, 1.7) + }); + + var surfaceLineB = new PipingSurfaceLine("Name B"); + surfaceLineB.SetGeometry(new[] + { + new Point3D(0.0, 0.0, 1.5), + new Point3D(3.0, 0.0, 1.8) + }); + surfaceLineA.ReferenceLineIntersectionWorldPoint = new Point2D(1.3, 1.3); + surfaceLineB.ReferenceLineIntersectionWorldPoint = new Point2D(1.5, 1.5); + + var failureMechanism = new PipingFailureMechanism(); + const string arbitraryFilePath = "path"; + var geometryPoints = new[] + { + new Point2D(0.0, 0.0), + new Point2D(2.0, 0.0), + new Point2D(4.0, 4.0), + new Point2D(6.0, 4.0) + }; + failureMechanism.SurfaceLines.AddRange(new[] + { + surfaceLineA, + surfaceLineB + }, arbitraryFilePath); + FailureMechanismTestHelper.SetSections(failureMechanism, new[] + { + new FailureMechanismSection("A", geometryPoints.Take(2)), + new FailureMechanismSection("B", geometryPoints.Skip(1).Take(2)), + new FailureMechanismSection("C", geometryPoints.Skip(2).Take(2)) + }); + failureMechanism.StochasticSoilModels.AddRange(new[] + { + stochasticSoilModel1, + stochasticSoilModel2 + }, arbitraryFilePath); + + var hydraulicBoundaryLocation1 = new HydraulicBoundaryLocation(1, "test", 1.0, 2.0); + var hydraulicBoundaryLocation2 = new HydraulicBoundaryLocation(2, "test", 3.0, 4.0); + + var calculationA = + SemiProbabilisticPipingCalculationTestFactory.CreateCalculationWithValidInput( + hydraulicBoundaryLocation1); + var calculationB = + ProbabilisticPipingCalculationTestFactory.CreateCalculationWithValidInput( + hydraulicBoundaryLocation2); + + calculationA.InputParameters.SurfaceLine = surfaceLineA; + calculationB.InputParameters.SurfaceLine = surfaceLineB; + + failureMechanism.CalculationsGroup.Children.Add(calculationA); + failureMechanism.CalculationsGroup.Children.Add(calculationB); + + var referenceLine = new ReferenceLine(); + referenceLine.SetGeometry(new[] + { + new Point2D(0.0, 3.0), + new Point2D(3.0, 0.0) + }); + + var assessmentSection = new AssessmentSectionStub + { + ReferenceLine = referenceLine + }; + + assessmentSection.SetHydraulicBoundaryLocationCalculations(new[] + { + hydraulicBoundaryLocation1, + hydraulicBoundaryLocation2 + }); + + using (new AssemblyToolCalculatorFactoryConfig()) + { + // Call + PipingFailureMechanismView view = CreateView(failureMechanism, assessmentSection); + + IMapControl map = ((RiskeerMapControl) view.Controls[0]).MapControl; + + // Assert + MapDataCollection mapData = map.Data; + Assert.IsInstanceOf(mapData); + + List mapDataList = mapData.Collection.ToList(); + Assert.AreEqual(8, mapDataList.Count); + MapDataTestHelper.AssertReferenceLineMapData(assessmentSection.ReferenceLine, mapDataList[referenceLineIndex]); + AssertSurfaceLinesMapData(failureMechanism.SurfaceLines, mapDataList[surfaceLinesIndex]); + + IEnumerable sectionsCollection = ((MapDataCollection) mapDataList[sectionsCollectionIndex]).Collection; + MapDataTestHelper.AssertFailureMechanismSectionsMapData(failureMechanism.Sections, sectionsCollection.ElementAt(sectionsIndex)); + MapDataTestHelper.AssertFailureMechanismSectionsStartPointMapData(failureMechanism.Sections, sectionsCollection.ElementAt(sectionsStartPointIndex)); + MapDataTestHelper.AssertFailureMechanismSectionsEndPointMapData(failureMechanism.Sections, sectionsCollection.ElementAt(sectionsEndPointIndex)); + + MapDataTestHelper.AssertHydraulicBoundaryLocationsMapData(assessmentSection, mapDataList[hydraulicBoundaryLocationsIndex]); + AssertStochasticSoilModelsMapData(failureMechanism.StochasticSoilModels, mapDataList[stochasticSoilModelsIndex]); + AssertProbabilisticCalculationsMapData(failureMechanism.Calculations.OfType(), mapDataList[probabilisticCalculationsIndex]); + AssertSemiProbabilisticCalculationsMapData(failureMechanism.Calculations.OfType(), mapDataList[semiProbabilisticCalculationsIndex]); + + var calculatorFactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance; + FailureMechanismSectionAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator; + MapDataTestHelper.AssertAssemblyMapData(failureMechanism, calculator.FailureMechanismSectionAssemblyResultOutput, mapDataList[assemblyResultsIndex]); + } + } + + [Test] + [Apartment(ApartmentState.STA)] + public void UpdateObserver_DataUpdated_MapLayersSameOrder() + { + // Setup + const int updatedReferenceLineLayerIndex = referenceLineIndex + 7; + const int updatedSurfaceLineLayerIndex = surfaceLinesIndex - 1; + const int updatedSectionCollectionIndex = sectionsCollectionIndex - 1; + const int updatedAssemblyResultsIndex = assemblyResultsIndex - 1; + const int updatedHydraulicLocationsLayerIndex = hydraulicBoundaryLocationsIndex - 1; + const int updatedStochasticSoilModelsLayerIndex = stochasticSoilModelsIndex - 1; + const int updatedProbabilisticCalculationsIndex = probabilisticCalculationsIndex - 1; + const int updatedSemiProbabilisticCalculationsIndex = semiProbabilisticCalculationsIndex - 1; + + var assessmentSection = new AssessmentSectionStub(); + + PipingFailureMechanismView view = CreateView(new PipingFailureMechanism(), assessmentSection); + + IMapControl map = ((RiskeerMapControl) view.Controls[0]).MapControl; + + MapDataCollection mapData = map.Data; + + var dataToMove = (MapLineData) map.Data.Collection.ElementAt(referenceLineIndex); + mapData.Remove(dataToMove); + mapData.Add(dataToMove); + + IEnumerable mapDataCollection = mapData.Collection; + + // Precondition + var referenceLineData = (MapLineData) mapDataCollection.ElementAt(updatedReferenceLineLayerIndex); + Assert.AreEqual("Referentielijn", referenceLineData.Name); + + var surfaceLineData = (MapLineData) mapDataCollection.ElementAt(updatedSurfaceLineLayerIndex); + Assert.AreEqual("Profielschematisaties", surfaceLineData.Name); + + var sectionsData = (MapDataCollection) mapDataCollection.ElementAt(updatedSectionCollectionIndex); + Assert.AreEqual("Vakindeling", sectionsData.Name); + + var assemblyResultsData = (MapLineData) mapDataCollection.ElementAt(updatedAssemblyResultsIndex); + Assert.AreEqual("Duidingsklasse per vak", assemblyResultsData.Name); + + var hydraulicLocationsData = (MapPointData) mapDataCollection.ElementAt(updatedHydraulicLocationsLayerIndex); + Assert.AreEqual("Hydraulische belastingen", hydraulicLocationsData.Name); + + var stochasticSoilModelsData = (MapLineData) mapDataCollection.ElementAt(updatedStochasticSoilModelsLayerIndex); + Assert.AreEqual("Stochastische ondergrondmodellen", stochasticSoilModelsData.Name); + + var probabilisticCalculationsData = (MapLineData) mapDataCollection.ElementAt(updatedProbabilisticCalculationsIndex); + Assert.AreEqual("Probabilistische berekeningen", probabilisticCalculationsData.Name); + + var semiProbabilisticCalculationsData = (MapLineData) mapDataCollection.ElementAt(updatedSemiProbabilisticCalculationsIndex); + Assert.AreEqual("Semi-probabilistische berekeningen", semiProbabilisticCalculationsData.Name); + + var points = new List + { + new Point2D(2.0, 5.0), + new Point2D(4.0, 3.0) + }; + var referenceLine = new ReferenceLine(); + referenceLine.SetGeometry(points); + assessmentSection.ReferenceLine = referenceLine; + + // Call + assessmentSection.NotifyObservers(); + + // Assert + var actualReferenceLineData = (MapLineData) mapDataCollection.ElementAt(updatedReferenceLineLayerIndex); + Assert.AreEqual("Referentielijn", actualReferenceLineData.Name); + + var actualSurfaceLineData = (MapLineData) mapDataCollection.ElementAt(updatedSurfaceLineLayerIndex); + Assert.AreEqual("Profielschematisaties", actualSurfaceLineData.Name); + + var actualSectionsData = (MapDataCollection) mapDataCollection.ElementAt(updatedSectionCollectionIndex); + Assert.AreEqual("Vakindeling", actualSectionsData.Name); + + var actualAssemblyResultsData = (MapLineData) mapDataCollection.ElementAt(updatedAssemblyResultsIndex); + Assert.AreEqual("Duidingsklasse per vak", actualAssemblyResultsData.Name); + + var actualHydraulicLocationsData = (MapPointData) mapDataCollection.ElementAt(updatedHydraulicLocationsLayerIndex); + Assert.AreEqual("Hydraulische belastingen", actualHydraulicLocationsData.Name); + + var actualStochasticSoilModelsData = (MapLineData) mapDataCollection.ElementAt(updatedStochasticSoilModelsLayerIndex); + Assert.AreEqual("Stochastische ondergrondmodellen", actualStochasticSoilModelsData.Name); + + var actualSemiProbabilisticCalculationsData = (MapLineData) mapDataCollection.ElementAt(updatedSemiProbabilisticCalculationsIndex); + Assert.AreEqual("Semi-probabilistische berekeningen", actualSemiProbabilisticCalculationsData.Name); + + var actualProbabilisticCalculationsData = (MapLineData) mapDataCollection.ElementAt(updatedProbabilisticCalculationsIndex); + Assert.AreEqual("Probabilistische berekeningen", actualProbabilisticCalculationsData.Name); + } + + private PipingFailureMechanismView CreateView(PipingFailureMechanism failureMechanism, IAssessmentSection assessmentSection) + { + var view = new PipingFailureMechanismView(failureMechanism, assessmentSection); + + testForm.Controls.Add(view); + testForm.Show(); + + return view; + } + + private static void AssertSurfaceLinesMapData(IEnumerable surfaceLines, MapData mapData) + { + Assert.IsInstanceOf(mapData); + var surfaceLinesMapData = (MapLineData) mapData; + MapFeature[] surfaceLineFeatures = surfaceLinesMapData.Features.ToArray(); + PipingSurfaceLine[] surfaceLinesArray = surfaceLines.ToArray(); + Assert.AreEqual(surfaceLinesArray.Length, surfaceLineFeatures.Length); + + for (var index = 0; index < surfaceLinesArray.Length; index++) + { + Assert.AreEqual(1, surfaceLineFeatures[index].MapGeometries.Count()); + PipingSurfaceLine surfaceLine = surfaceLinesArray[index]; + CollectionAssert.AreEquivalent(surfaceLine.Points.Select(p => new Point2D(p.X, p.Y)), surfaceLineFeatures[index].MapGeometries.First().PointCollections.First()); + } + + Assert.AreEqual("Profielschematisaties", mapData.Name); + } + + private static void AssertStochasticSoilModelsMapData(IEnumerable soilModels, MapData mapData) + { + Assert.IsInstanceOf(mapData); + var soilModelsMapData = (MapLineData) mapData; + MapFeature[] soilModelsFeatures = soilModelsMapData.Features.ToArray(); + PipingStochasticSoilModel[] stochasticSoilModelsArray = soilModels.ToArray(); + Assert.AreEqual(stochasticSoilModelsArray.Length, soilModelsFeatures.Length); + + for (var index = 0; index < stochasticSoilModelsArray.Length; index++) + { + Assert.AreEqual(1, soilModelsFeatures[index].MapGeometries.Count()); + PipingStochasticSoilModel stochasticSoilModel = stochasticSoilModelsArray[index]; + CollectionAssert.AreEquivalent(stochasticSoilModel.Geometry.Select(p => new Point2D(p)), soilModelsFeatures[index].MapGeometries.First().PointCollections.First()); + } + + Assert.AreEqual("Stochastische ondergrondmodellen", mapData.Name); + } + + private static void AssertSemiProbabilisticCalculationsMapData(IEnumerable calculations, MapData mapData) + { + Assert.AreEqual("Semi-probabilistische berekeningen", mapData.Name); + AssertCalculationsMapData(calculations, mapData); + } + + private static void AssertProbabilisticCalculationsMapData(IEnumerable calculations, MapData mapData) + { + Assert.AreEqual("Probabilistische berekeningen", mapData.Name); + AssertCalculationsMapData(calculations, mapData); + } + + private static void AssertCalculationsMapData(IEnumerable calculations, MapData mapData) + where TCalculationScenario : IPipingCalculationScenario + { + Assert.IsInstanceOf(mapData); + var calculationsMapData = (MapLineData) mapData; + TCalculationScenario[] calculationsArray = calculations.ToArray(); + MapFeature[] calculationsFeatures = calculationsMapData.Features.ToArray(); + Assert.AreEqual(calculationsArray.Length, calculationsFeatures.Length); + + for (var index = 0; index < calculationsArray.Length; index++) + { + MapGeometry[] geometries = calculationsFeatures[index].MapGeometries.ToArray(); + Assert.AreEqual(1, geometries.Length); + + TCalculationScenario calculation = calculationsArray[index]; + CollectionAssert.AreEquivalent(new[] + { + calculation.InputParameters.SurfaceLine.ReferenceLineIntersectionWorldPoint, + calculation.InputParameters.HydraulicBoundaryLocation.Location + }, + geometries[0].PointCollections.First()); + } + } + + private static void AssertEmptyMapData(MapDataCollection mapDataCollection) + { + Assert.AreEqual("Piping", mapDataCollection.Name); + + List mapDataList = mapDataCollection.Collection.ToList(); + + Assert.AreEqual(8, mapDataList.Count); + + var referenceLineMapData = (MapLineData) mapDataList[referenceLineIndex]; + var stochasticSoilModelsMapData = (MapLineData) mapDataList[stochasticSoilModelsIndex]; + var surfaceLinesMapData = (MapLineData) mapDataList[surfaceLinesIndex]; + var assemblyResultsMapData = (MapLineData) mapDataList[assemblyResultsIndex]; + var hydraulicBoundaryLocationsMapData = (MapPointData) mapDataList[hydraulicBoundaryLocationsIndex]; + var probabilisticCalculationsMapData = (MapLineData) mapDataList[probabilisticCalculationsIndex]; + var semiProbabilisticCalculationsMapData = (MapLineData) mapDataList[semiProbabilisticCalculationsIndex]; + + CollectionAssert.IsEmpty(referenceLineMapData.Features); + CollectionAssert.IsEmpty(stochasticSoilModelsMapData.Features); + CollectionAssert.IsEmpty(surfaceLinesMapData.Features); + CollectionAssert.IsEmpty(assemblyResultsMapData.Features); + CollectionAssert.IsEmpty(hydraulicBoundaryLocationsMapData.Features); + CollectionAssert.IsEmpty(probabilisticCalculationsMapData.Features); + CollectionAssert.IsEmpty(semiProbabilisticCalculationsMapData.Features); + + Assert.AreEqual("Referentielijn", referenceLineMapData.Name); + Assert.AreEqual("Stochastische ondergrondmodellen", stochasticSoilModelsMapData.Name); + Assert.AreEqual("Profielschematisaties", surfaceLinesMapData.Name); + Assert.AreEqual("Duidingsklasse per vak", assemblyResultsMapData.Name); + Assert.AreEqual("Hydraulische belastingen", hydraulicBoundaryLocationsMapData.Name); + Assert.AreEqual("Probabilistische berekeningen", probabilisticCalculationsMapData.Name); + Assert.AreEqual("Semi-probabilistische berekeningen", semiProbabilisticCalculationsMapData.Name); + + var sectionsMapDataCollection = (MapDataCollection) mapDataList[sectionsCollectionIndex]; + Assert.AreEqual("Vakindeling", sectionsMapDataCollection.Name); + List sectionsDataList = sectionsMapDataCollection.Collection.ToList(); + Assert.AreEqual(3, sectionsDataList.Count); + + var sectionsMapData = (MapLineData) sectionsDataList[sectionsIndex]; + var sectionsStartPointMapData = (MapPointData) sectionsDataList[sectionsStartPointIndex]; + var sectionsEndPointMapData = (MapPointData) sectionsDataList[sectionsEndPointIndex]; + + CollectionAssert.IsEmpty(sectionsEndPointMapData.Features); + CollectionAssert.IsEmpty(sectionsStartPointMapData.Features); + CollectionAssert.IsEmpty(sectionsMapData.Features); + + Assert.AreEqual("Vakindeling (eindpunten)", sectionsEndPointMapData.Name); + Assert.AreEqual("Vakindeling (startpunten)", sectionsStartPointMapData.Name); + Assert.AreEqual("Vakindeling", sectionsMapData.Name); + } + } +} \ No newline at end of file Index: Riskeer/Piping/test/Riskeer.Piping.Plugin.Test/PipingPluginTest.cs =================================================================== diff -u -rdc98821fe1215b8fb7512aadff471024c2e81544 -r4833951758a4115a1ae02558a02696f2dedf4950 --- Riskeer/Piping/test/Riskeer.Piping.Plugin.Test/PipingPluginTest.cs (.../PipingPluginTest.cs) (revision dc98821fe1215b8fb7512aadff471024c2e81544) +++ Riskeer/Piping/test/Riskeer.Piping.Plugin.Test/PipingPluginTest.cs (.../PipingPluginTest.cs) (revision 4833951758a4115a1ae02558a02696f2dedf4950) @@ -49,6 +49,8 @@ using Riskeer.Piping.Primitives; using CalculationsStateFailureMechanismProperties = Riskeer.Piping.Forms.PropertyClasses.CalculationsState.PipingFailureMechanismProperties; using RegistrationStateFailureMechanismProperties = Riskeer.Piping.Forms.PropertyClasses.RegistrationState.PipingFailureMechanismProperties; +using CalculationsStateFailureMechanismView = Riskeer.Piping.Forms.Views.CalculationsState.PipingFailureMechanismView; +using RegistrationStateFailureMechanismView = Riskeer.Piping.Forms.Views.RegistrationState.PipingFailureMechanismView; namespace Riskeer.Piping.Plugin.Test { @@ -206,12 +208,12 @@ PluginTestHelper.AssertViewInfoDefined( viewInfos, typeof(PipingCalculationsContext), - typeof(PipingFailureMechanismView)); + typeof(CalculationsStateFailureMechanismView)); PluginTestHelper.AssertViewInfoDefined( viewInfos, typeof(PipingFailurePathContext), - typeof(PipingFailurePathView)); + typeof(RegistrationStateFailureMechanismView)); PluginTestHelper.AssertViewInfoDefined( viewInfos, Index: Riskeer/Piping/test/Riskeer.Piping.Plugin.Test/ViewInfos/CalculationsState/PipingFailureMechanismViewInfoTest.cs =================================================================== diff -u --- Riskeer/Piping/test/Riskeer.Piping.Plugin.Test/ViewInfos/CalculationsState/PipingFailureMechanismViewInfoTest.cs (revision 0) +++ Riskeer/Piping/test/Riskeer.Piping.Plugin.Test/ViewInfos/CalculationsState/PipingFailureMechanismViewInfoTest.cs (revision 4833951758a4115a1ae02558a02696f2dedf4950) @@ -0,0 +1,98 @@ +// Copyright (C) Stichting Deltares 2021. All rights reserved. +// +// This file is part of Riskeer. +// +// Riskeer is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this program. If not, see . +// +// All names, logos, and references to "Deltares" are registered trademarks of +// Stichting Deltares and remain full property of Stichting Deltares at all times. +// All rights reserved. + +using System.Linq; +using Core.Gui.Plugin; +using NUnit.Framework; +using Rhino.Mocks; +using Riskeer.Common.Data.AssessmentSection; +using Riskeer.Common.Data.TestUtil; +using Riskeer.Piping.Data; +using Riskeer.Piping.Forms.PresentationObjects; +using Riskeer.Piping.Forms.Views.CalculationsState; + +namespace Riskeer.Piping.Plugin.Test.ViewInfos.CalculationsState +{ + [TestFixture] + public class PipingFailureMechanismViewInfoTest + { + private MockRepository mocks; + private PipingPlugin plugin; + private ViewInfo info; + + [SetUp] + public void SetUp() + { + mocks = new MockRepository(); + plugin = new PipingPlugin(); + info = plugin.GetViewInfos().First(tni => tni.ViewType == typeof(PipingFailureMechanismView)); + } + + [TearDown] + public void TearDown() + { + plugin.Dispose(); + } + + [Test] + public void Initialized_Always_ExpectedPropertiesSet() + { + // Assert + Assert.AreEqual(typeof(PipingCalculationsContext), info.DataType); + Assert.AreEqual(typeof(PipingCalculationsContext), info.ViewDataType); + } + + [Test] + public void GetViewName_WithPipingFailureMechanismContext_ReturnsNameOfFailureMechanism() + { + // Setup + var assessmentSection = mocks.Stub(); + mocks.ReplayAll(); + + var failureMechanism = new PipingFailureMechanism(); + var context = new PipingCalculationsContext(failureMechanism, assessmentSection); + + // Call + string viewName = info.GetViewName(null, context); + + // Assert + Assert.AreEqual(failureMechanism.Name, viewName); + mocks.VerifyAll(); + } + + [Test] + public void CreateInstance_WithContext_ReturnPipingFailureMechanismView() + { + // Setup + var assessmentSection = new AssessmentSectionStub(); + var failureMechanism = new PipingFailureMechanism(); + + var context = new PipingCalculationsContext(failureMechanism, assessmentSection); + + // Call + var view = (PipingFailureMechanismView) info.CreateInstance(context); + + // Assert + Assert.AreSame(failureMechanism, view.FailureMechanism); + Assert.AreSame(assessmentSection, view.AssessmentSection); + } + } +} \ No newline at end of file Fisheye: Tag 4833951758a4115a1ae02558a02696f2dedf4950 refers to a dead (removed) revision in file `Riskeer/Piping/test/Riskeer.Piping.Plugin.Test/ViewInfos/PipingFailureMechanismViewInfoTest.cs'. Fisheye: No comparison available. Pass `N' to diff? Fisheye: Tag 4833951758a4115a1ae02558a02696f2dedf4950 refers to a dead (removed) revision in file `Riskeer/Piping/test/Riskeer.Piping.Plugin.Test/ViewInfos/PipingFailurePathViewInfoTest.cs'. Fisheye: No comparison available. Pass `N' to diff? Index: Riskeer/Piping/test/Riskeer.Piping.Plugin.Test/ViewInfos/RegistrationState/PipingFailureMechanismViewInfoTest.cs =================================================================== diff -u --- Riskeer/Piping/test/Riskeer.Piping.Plugin.Test/ViewInfos/RegistrationState/PipingFailureMechanismViewInfoTest.cs (revision 0) +++ Riskeer/Piping/test/Riskeer.Piping.Plugin.Test/ViewInfos/RegistrationState/PipingFailureMechanismViewInfoTest.cs (revision 4833951758a4115a1ae02558a02696f2dedf4950) @@ -0,0 +1,192 @@ +// Copyright (C) Stichting Deltares 2021. All rights reserved. +// +// This file is part of Riskeer. +// +// Riskeer is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this program. If not, see . +// +// All names, logos, and references to "Deltares" are registered trademarks of +// Stichting Deltares and remain full property of Stichting Deltares at all times. +// All rights reserved. + +using System.Linq; +using Core.Gui.Plugin; +using NUnit.Framework; +using Rhino.Mocks; +using Riskeer.Common.Data.AssessmentSection; +using Riskeer.Common.Data.TestUtil; +using Riskeer.Piping.Data; +using Riskeer.Piping.Forms.PresentationObjects; +using Riskeer.Piping.Forms.Views.RegistrationState; + +namespace Riskeer.Piping.Plugin.Test.ViewInfos.RegistrationState +{ + [TestFixture] + public class PipingFailureMechanismViewInfoTest + { + private MockRepository mocks; + private PipingPlugin plugin; + private ViewInfo info; + + [SetUp] + public void SetUp() + { + mocks = new MockRepository(); + plugin = new PipingPlugin(); + info = plugin.GetViewInfos().First(tni => tni.ViewType == typeof(PipingFailureMechanismView)); + } + + [TearDown] + public void TearDown() + { + plugin.Dispose(); + } + + [Test] + public void Initialized_Always_ExpectedPropertiesSet() + { + // Assert + Assert.AreEqual(typeof(PipingFailurePathContext), info.DataType); + Assert.AreEqual(typeof(PipingFailurePathContext), info.ViewDataType); + } + + [Test] + public void GetViewName_WithPipingFailureMechanismContext_ReturnsNameOfFailureMechanism() + { + // Setup + var assessmentSection = mocks.Stub(); + mocks.ReplayAll(); + + var failureMechanism = new PipingFailureMechanism(); + var context = new PipingFailurePathContext(failureMechanism, assessmentSection); + + // Call + string viewName = info.GetViewName(null, context); + + // Assert + Assert.AreEqual(failureMechanism.Name, viewName); + mocks.VerifyAll(); + } + + [Test] + [TestCase(true)] + [TestCase(false)] + public void AdditionalDataCheck_Always_ReturnTrueOnlyIfFailureMechanismInAssembly(bool inAssembly) + { + // Setup + var assessmentSection = mocks.Stub(); + mocks.ReplayAll(); + + var failureMechanism = new PipingFailureMechanism + { + InAssembly = inAssembly + }; + + var context = new PipingFailurePathContext(failureMechanism, assessmentSection); + + // Call + bool result = info.AdditionalDataCheck(context); + + // Assert + Assert.AreEqual(inAssembly, result); + mocks.VerifyAll(); + } + + [Test] + public void CreateInstance_WithContext_ReturnPipingFailureMechanismView() + { + // Setup + var assessmentSection = new AssessmentSectionStub(); + var failureMechanism = new PipingFailureMechanism(); + + var context = new PipingFailurePathContext(failureMechanism, assessmentSection); + + // Call + var view = (PipingFailureMechanismView) info.CreateInstance(context); + + // Assert + Assert.AreSame(failureMechanism, view.FailureMechanism); + Assert.AreSame(assessmentSection, view.AssessmentSection); + } + + [Test] + public void CloseForData_ViewNotCorrespondingToRemovedAssessmentSection_ReturnsFalse() + { + // Setup + var otherAssessmentSection = mocks.Stub(); + mocks.ReplayAll(); + + var assessmentSection = new AssessmentSectionStub(); + var failureMechanism = new PipingFailureMechanism(); + + var view = new PipingFailureMechanismView(failureMechanism, assessmentSection); + + // Call + bool closeForData = info.CloseForData(view, otherAssessmentSection); + + // Assert + Assert.IsFalse(closeForData); + + mocks.VerifyAll(); + } + + [Test] + public void CloseForData_ViewCorrespondingToRemovedAssessmentSection_ReturnsTrue() + { + // Setup + var assessmentSection = new AssessmentSectionStub(); + var failureMechanism = new PipingFailureMechanism(); + + var view = new PipingFailureMechanismView(failureMechanism, assessmentSection); + + // Call + bool closeForData = info.CloseForData(view, assessmentSection); + + // Assert + Assert.IsTrue(closeForData); + } + + [Test] + public void CloseForData_ViewNotCorrespondingToRemovedFailureMechanism_ReturnsFalse() + { + // Setup + var assessmentSection = new AssessmentSectionStub(); + var failureMechanism = new PipingFailureMechanism(); + var otherPipingFailureMechanism = new PipingFailureMechanism(); + + var view = new PipingFailureMechanismView(failureMechanism, assessmentSection); + + // Call + bool closeForData = info.CloseForData(view, otherPipingFailureMechanism); + + // Assert + Assert.IsFalse(closeForData); + } + + [Test] + public void CloseForData_ViewCorrespondingToRemovedFailureMechanism_ReturnsTrue() + { + // Setup + var assessmentSection = new AssessmentSectionStub(); + var failureMechanism = new PipingFailureMechanism(); + + var view = new PipingFailureMechanismView(failureMechanism, assessmentSection); + + // Call + bool closeForData = info.CloseForData(view, failureMechanism); + + // Assert + Assert.IsTrue(closeForData); + } + } +} \ No newline at end of file