Index: Riskeer/Piping/src/Riskeer.Piping.Plugin/PipingPlugin.cs =================================================================== diff -u -rb4611cca8aeb98f81b6c8eebf125ad0f2a2c95d6 -r81be338174a6e1ec2da201a50c8e1ff7d3cb0a24 --- Riskeer/Piping/src/Riskeer.Piping.Plugin/PipingPlugin.cs (.../PipingPlugin.cs) (revision b4611cca8aeb98f81b6c8eebf125ad0f2a2c95d6) +++ Riskeer/Piping/src/Riskeer.Piping.Plugin/PipingPlugin.cs (.../PipingPlugin.cs) (revision 81be338174a6e1ec2da201a50c8e1ff7d3cb0a24) @@ -543,17 +543,20 @@ private static bool ClosePipingInputViewForData(PipingInputView view, object o) { - if (o is SemiProbabilisticPipingCalculationScenarioContext pipingCalculationScenarioContext) + switch (o) { - return ReferenceEquals(view.Data, pipingCalculationScenarioContext.WrappedData); + case ProbabilisticPipingCalculationContext probabilisticPipingCalculationScenarioContext: + return ReferenceEquals(view.Data, probabilisticPipingCalculationScenarioContext.WrappedData); + case SemiProbabilisticPipingCalculationScenarioContext semiProbabilisticPipingCalculationScenarioContext: + return ReferenceEquals(view.Data, semiProbabilisticPipingCalculationScenarioContext.WrappedData); } - IEnumerable calculations = null; + IEnumerable> calculations = null; if (o is PipingCalculationGroupContext pipingCalculationGroupContext) { calculations = pipingCalculationGroupContext.WrappedData.GetCalculations() - .OfType(); + .OfType>(); } var failureMechanism = o as PipingFailureMechanism; @@ -573,7 +576,7 @@ if (failureMechanism != null) { calculations = failureMechanism.CalculationsGroup.GetCalculations() - .OfType(); + .OfType>(); } return calculations != null && calculations.Any(ci => ReferenceEquals(view.Data, ci)); Index: Riskeer/Piping/test/Riskeer.Piping.Plugin.Test/ViewInfos/PipingInputViewInfoTest.cs =================================================================== diff -u -r9d81fce2b4838979d13c48cf0adc054fb240625a -r81be338174a6e1ec2da201a50c8e1ff7d3cb0a24 --- Riskeer/Piping/test/Riskeer.Piping.Plugin.Test/ViewInfos/PipingInputViewInfoTest.cs (.../PipingInputViewInfoTest.cs) (revision 9d81fce2b4838979d13c48cf0adc054fb240625a) +++ Riskeer/Piping/test/Riskeer.Piping.Plugin.Test/ViewInfos/PipingInputViewInfoTest.cs (.../PipingInputViewInfoTest.cs) (revision 81be338174a6e1ec2da201a50c8e1ff7d3cb0a24) @@ -49,7 +49,7 @@ { mocks = new MockRepository(); plugin = new PipingPlugin(); - info = plugin.GetViewInfos().First(tni => tni.ViewType == typeof(PipingInputView)); + info = plugin.GetViewInfos().First(tni => tni.DataType == typeof(SemiProbabilisticPipingInputContext)); } [TearDown] Index: Riskeer/Piping/test/Riskeer.Piping.Plugin.Test/ViewInfos/ProbabilisticPipingInputViewInfoTest.cs =================================================================== diff -u --- Riskeer/Piping/test/Riskeer.Piping.Plugin.Test/ViewInfos/ProbabilisticPipingInputViewInfoTest.cs (revision 0) +++ Riskeer/Piping/test/Riskeer.Piping.Plugin.Test/ViewInfos/ProbabilisticPipingInputViewInfoTest.cs (revision 81be338174a6e1ec2da201a50c8e1ff7d3cb0a24) @@ -0,0 +1,621 @@ +// Copyright (C) Stichting Deltares 2019. 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.Common.Gui.Plugin; +using Core.Common.TestUtil; +using NUnit.Framework; +using Rhino.Mocks; +using Riskeer.Common.Data.AssessmentSection; +using Riskeer.Common.Data.Calculation; +using Riskeer.Piping.Data; +using Riskeer.Piping.Data.Probabilistic; +using Riskeer.Piping.Data.SoilProfile; +using Riskeer.Piping.Forms.PresentationObjects; +using Riskeer.Piping.Forms.PresentationObjects.Probabilistic; +using Riskeer.Piping.Forms.Views; +using Riskeer.Piping.Primitives; +using PipingFormsResources = Riskeer.Piping.Forms.Properties.Resources; + +namespace Riskeer.Piping.Plugin.Test.ViewInfos +{ + [TestFixture] + public class ProbabilisticPipingInputViewInfoTest + { + 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.DataType == typeof(ProbabilisticPipingInputContext)); + } + + [TearDown] + public void TearDown() + { + plugin.Dispose(); + } + + [Test] + public void Initialized_Always_ExpectedPropertiesSet() + { + // Assert + Assert.AreEqual(typeof(ProbabilisticPipingInputContext), info.DataType); + Assert.AreEqual(typeof(ProbabilisticPipingCalculation), info.ViewDataType); + TestHelper.AssertImagesAreEqual(PipingFormsResources.PipingInputIcon, info.Image); + } + + [Test] + public void GetViewName_Always_ReturnsInputResourceName() + { + // Call + string viewName = info.GetViewName(null, null); + + // Assert + Assert.AreEqual("Invoer", viewName); + } + + [Test] + public void GetViewData_Always_ReturnsWrappedCalculation() + { + // Setup + var assessmentSection = mocks.Stub(); + mocks.ReplayAll(); + + var pipingInput = new ProbabilisticPipingInput(new GeneralPipingInput()); + + var calculation = new ProbabilisticPipingCalculation(new GeneralPipingInput()); + var calculationInputContext = new ProbabilisticPipingInputContext(pipingInput, calculation, Enumerable.Empty(), + Enumerable.Empty(), + new PipingFailureMechanism(), + assessmentSection); + + // Call + object viewData = info.GetViewData(calculationInputContext); + + // Assert + Assert.AreSame(calculation, viewData); + mocks.VerifyAll(); + } + + [Test] + public void CloseForData_ViewCorrespondingToRemovedPipingCalculation_ReturnsTrue() + { + // Setup + var assessmentSection = mocks.Stub(); + mocks.ReplayAll(); + + var pipingCalculation = new ProbabilisticPipingCalculation(new GeneralPipingInput()); + var pipingCalculationScenarioContext = new ProbabilisticPipingCalculationContext(pipingCalculation, + new CalculationGroup(), + Enumerable.Empty(), + Enumerable.Empty(), + new PipingFailureMechanism(), + assessmentSection); + + using (var view = new PipingInputView + { + Data = pipingCalculation + }) + { + // Call + bool closeForData = info.CloseForData(view, pipingCalculationScenarioContext); + + // Assert + Assert.IsTrue(closeForData); + mocks.VerifyAll(); + } + } + + [Test] + public void CloseForData_ViewNotCorrespondingToRemovedPipingCalculationScenarioContext_ReturnsFalse() + { + // Setup + var assessmentSection = mocks.Stub(); + mocks.ReplayAll(); + + var pipingCalculation = new ProbabilisticPipingCalculation(new GeneralPipingInput()); + var calculationToRemove = new ProbabilisticPipingCalculation(new GeneralPipingInput()); + + var pipingCalculationScenarioContext = new ProbabilisticPipingCalculationContext(calculationToRemove, + new CalculationGroup(), + Enumerable.Empty(), + Enumerable.Empty(), + new PipingFailureMechanism(), + assessmentSection); + + using (var view = new PipingInputView + { + Data = pipingCalculation + }) + { + // Call + bool closeForData = info.CloseForData(view, pipingCalculationScenarioContext); + + // Assert + Assert.IsFalse(closeForData); + mocks.VerifyAll(); + } + } + + [Test] + public void CloseForData_ViewCorrespondingWithRemovedPipingCalculationGroupContext_ReturnsTrue() + { + // Setup + var assessmentSection = mocks.Stub(); + mocks.ReplayAll(); + + var calculation = new ProbabilisticPipingCalculation(new GeneralPipingInput()); + var calculationGroup = new CalculationGroup(); + calculationGroup.Children.Add(calculation); + + var calculationGroupContext = new PipingCalculationGroupContext(calculationGroup, + null, + Enumerable.Empty(), + Enumerable.Empty(), + new PipingFailureMechanism(), + assessmentSection); + using (var view = new PipingInputView + { + Data = calculation + }) + { + // Call + bool closeForData = info.CloseForData(view, calculationGroupContext); + + // Assert + Assert.IsTrue(closeForData); + mocks.VerifyAll(); + } + } + + [Test] + public void CloseForData_ViewNotCorrespondingWithRemovedPipingCalculationGroupContext_ReturnsFalse() + { + // Setup + var assessmentSection = mocks.Stub(); + mocks.ReplayAll(); + + var calculation = new ProbabilisticPipingCalculation(new GeneralPipingInput()); + var calculationGroup = new CalculationGroup(); + calculationGroup.Children.Add(calculation); + + var calculationGroupContext = new PipingCalculationGroupContext(new CalculationGroup(), + null, + Enumerable.Empty(), + Enumerable.Empty(), + new PipingFailureMechanism(), + assessmentSection); + using (var view = new PipingInputView + { + Data = calculation + }) + { + // Call + bool closeForData = info.CloseForData(view, calculationGroupContext); + + // Assert + Assert.IsFalse(closeForData); + mocks.VerifyAll(); + } + } + + [Test] + public void CloseForData_NestedViewCorrespondingWithRemovedParentPipingCalculationGroupContext_ReturnsTrue() + { + // Setup + var assessmentSection = mocks.Stub(); + mocks.ReplayAll(); + + var calculation = new ProbabilisticPipingCalculation(new GeneralPipingInput()); + var nestedGroup = new CalculationGroup(); + nestedGroup.Children.Add(calculation); + var calculationGroup = new CalculationGroup(); + calculationGroup.Children.Add(nestedGroup); + + var calculationGroupContext = new PipingCalculationGroupContext(calculationGroup, + null, + Enumerable.Empty(), + Enumerable.Empty(), + new PipingFailureMechanism(), + assessmentSection); + using (var view = new PipingInputView + { + Data = calculation + }) + { + // Call + bool closeForData = info.CloseForData(view, calculationGroupContext); + + // Assert + Assert.IsTrue(closeForData); + mocks.VerifyAll(); + } + } + + [Test] + public void CloseForData_NestedViewNotCorrespondingWithRemovedParentPipingCalculationGroupContext_ReturnsFalse() + { + // Setup + var assessmentSection = mocks.Stub(); + mocks.ReplayAll(); + + var calculation = new ProbabilisticPipingCalculation(new GeneralPipingInput()); + var nestedGroup = new CalculationGroup(); + nestedGroup.Children.Add(calculation); + var calculationGroup = new CalculationGroup(); + calculationGroup.Children.Add(nestedGroup); + + var calculationGroupContext = new PipingCalculationGroupContext(new CalculationGroup(), + null, + Enumerable.Empty(), + Enumerable.Empty(), + new PipingFailureMechanism(), + assessmentSection); + using (var view = new PipingInputView + { + Data = calculation + }) + { + // Call + bool closeForData = info.CloseForData(view, calculationGroupContext); + + // Assert + Assert.IsFalse(closeForData); + mocks.VerifyAll(); + } + } + + [Test] + public void CloseForData_ViewCorrespondingToRemovedFailureMechanismContext_ReturnsTrue() + { + // Setup + var assessmentSection = mocks.Stub(); + mocks.ReplayAll(); + + var calculation = new ProbabilisticPipingCalculation(new GeneralPipingInput()); + var failureMechanism = new PipingFailureMechanism(); + failureMechanism.CalculationsGroup.Children.Add(calculation); + + var failureMechanismContext = new PipingFailureMechanismContext(failureMechanism, assessmentSection); + + using (var view = new PipingInputView + { + Data = calculation + }) + { + // Call + bool closeForData = info.CloseForData(view, failureMechanismContext); + + // Assert + Assert.IsTrue(closeForData); + mocks.VerifyAll(); + } + } + + [Test] + public void CloseForData_ViewNotCorrespondingToRemovedFailureMechanismContext_ReturnsFalse() + { + // Setup + var assessmentSection = mocks.Stub(); + mocks.ReplayAll(); + + var calculation = new ProbabilisticPipingCalculation(new GeneralPipingInput()); + var failureMechanism = new PipingFailureMechanism(); + failureMechanism.CalculationsGroup.Children.Add(calculation); + + var failureMechanismContext = new PipingFailureMechanismContext(new PipingFailureMechanism(), assessmentSection); + + using (var view = new PipingInputView + { + Data = calculation + }) + { + // Call + bool closeForData = info.CloseForData(view, failureMechanismContext); + + // Assert + Assert.IsFalse(closeForData); + mocks.VerifyAll(); + } + } + + [Test] + public void CloseForData_NestedViewCorrespondingToRemovedFailureMechanismContext_ReturnsTrue() + { + // Setup + var assessmentSection = mocks.Stub(); + mocks.ReplayAll(); + + var calculation = new ProbabilisticPipingCalculation(new GeneralPipingInput()); + var calculationGroup = new CalculationGroup(); + calculationGroup.Children.Add(calculation); + + var failureMechanism = new PipingFailureMechanism(); + failureMechanism.CalculationsGroup.Children.Add(calculationGroup); + + var failureMechanismContext = new PipingFailureMechanismContext(failureMechanism, assessmentSection); + + using (var view = new PipingInputView + { + Data = calculation + }) + { + // Call + bool closeForData = info.CloseForData(view, failureMechanismContext); + + // Assert + Assert.IsTrue(closeForData); + mocks.VerifyAll(); + } + } + + [Test] + public void CloseForData_NestedViewNotCorrespondingToRemovedFailureMechanismContext_ReturnsFalse() + { + // Setup + var assessmentSection = mocks.Stub(); + mocks.ReplayAll(); + + var calculation = new ProbabilisticPipingCalculation(new GeneralPipingInput()); + var calculationGroup = new CalculationGroup(); + calculationGroup.Children.Add(calculation); + + var failureMechanism = new PipingFailureMechanism(); + failureMechanism.CalculationsGroup.Children.Add(calculationGroup); + + var failureMechanismContext = new PipingFailureMechanismContext(new PipingFailureMechanism(), assessmentSection); + + using (var view = new PipingInputView + { + Data = calculation + }) + { + // Call + bool closeForData = info.CloseForData(view, failureMechanismContext); + + // Assert + Assert.IsFalse(closeForData); + mocks.VerifyAll(); + } + } + + [Test] + public void CloseForData_ViewCorrespondingToRemovedFailureMechanism_ReturnsTrue() + { + // Setup + var calculation = new ProbabilisticPipingCalculation(new GeneralPipingInput()); + var failureMechanism = new PipingFailureMechanism(); + failureMechanism.CalculationsGroup.Children.Add(calculation); + + using (var view = new PipingInputView + { + Data = calculation + }) + { + // Call + bool closeForData = info.CloseForData(view, failureMechanism); + + // Assert + Assert.IsTrue(closeForData); + } + } + + [Test] + public void CloseForData_ViewNotCorrespondingToRemovedFailureMechanism_ReturnsFalse() + { + // Setup + var calculation = new ProbabilisticPipingCalculation(new GeneralPipingInput()); + var failureMechanism = new PipingFailureMechanism(); + failureMechanism.CalculationsGroup.Children.Add(calculation); + + using (var view = new PipingInputView + { + Data = calculation + }) + { + // Call + bool closeForData = info.CloseForData(view, new PipingFailureMechanism()); + + // Assert + Assert.IsFalse(closeForData); + } + } + + [Test] + public void CloseForData_NestedViewCorrespondingToRemovedFailureMechanism_ReturnsTrue() + { + // Setup + var calculation = new ProbabilisticPipingCalculation(new GeneralPipingInput()); + var calculationGroup = new CalculationGroup(); + calculationGroup.Children.Add(calculation); + + var failureMechanism = new PipingFailureMechanism(); + failureMechanism.CalculationsGroup.Children.Add(calculationGroup); + + using (var view = new PipingInputView + { + Data = calculation + }) + { + // Call + bool closeForData = info.CloseForData(view, failureMechanism); + + // Assert + Assert.IsTrue(closeForData); + } + } + + [Test] + public void CloseForData_NestedViewNotCorrespondingToRemovedFailureMechanism_ReturnsFalse() + { + // Setup + var calculation = new ProbabilisticPipingCalculation(new GeneralPipingInput()); + var calculationGroup = new CalculationGroup(); + calculationGroup.Children.Add(calculation); + + var failureMechanism = new PipingFailureMechanism(); + failureMechanism.CalculationsGroup.Children.Add(calculationGroup); + + using (var view = new PipingInputView + { + Data = calculation + }) + { + // Call + bool closeForData = info.CloseForData(view, new PipingFailureMechanism()); + + // Assert + Assert.IsFalse(closeForData); + } + } + + [Test] + public void CloseForData_ViewCorrespondingToRemovedAssessmentSection_ReturnsTrue() + { + // Setup + var calculation = new ProbabilisticPipingCalculation(new GeneralPipingInput()); + var failureMechanism = new PipingFailureMechanism(); + failureMechanism.CalculationsGroup.Children.Add(calculation); + + var assessmentSection = mocks.Stub(); + assessmentSection.Stub(section => section.GetFailureMechanisms()).Return(new[] + { + failureMechanism + }); + + mocks.ReplayAll(); + + using (var view = new PipingInputView + { + Data = calculation + }) + { + // Call + bool closeForData = info.CloseForData(view, assessmentSection); + + // Assert + Assert.IsTrue(closeForData); + mocks.VerifyAll(); + } + } + + [Test] + public void CloseForData_ViewNotCorrespondingToRemovedAssessmentSection_ReturnsFalse() + { + // Setup + var calculation = new ProbabilisticPipingCalculation(new GeneralPipingInput()); + var failureMechanism = new PipingFailureMechanism(); + failureMechanism.CalculationsGroup.Children.Add(calculation); + + var assessmentSection = mocks.Stub(); + assessmentSection.Stub(section => section.GetFailureMechanisms()).Return(new[] + { + failureMechanism + }); + + mocks.ReplayAll(); + + using (var view = new PipingInputView + { + Data = new ProbabilisticPipingCalculation(new GeneralPipingInput()) + }) + { + // Call + bool closeForData = info.CloseForData(view, assessmentSection); + + // Assert + Assert.IsFalse(closeForData); + mocks.VerifyAll(); + } + } + + [Test] + public void CloseForData_NestedViewCorrespondingToRemovedAssessmentSection_ReturnsTrue() + { + // Setup + var calculation = new ProbabilisticPipingCalculation(new GeneralPipingInput()); + var calculationGroup = new CalculationGroup(); + calculationGroup.Children.Add(calculation); + + var failureMechanism = new PipingFailureMechanism(); + failureMechanism.CalculationsGroup.Children.Add(calculationGroup); + + var assessmentSection = mocks.Stub(); + assessmentSection.Stub(section => section.GetFailureMechanisms()).Return(new[] + { + failureMechanism + }); + + mocks.ReplayAll(); + + using (var view = new PipingInputView + { + Data = calculation + }) + { + // Call + bool closeForData = info.CloseForData(view, assessmentSection); + + // Assert + Assert.IsTrue(closeForData); + mocks.VerifyAll(); + } + } + + [Test] + public void CloseForData_NestedViewNotCorrespondingToRemovedAssessmentSection_ReturnsFalse() + { + // Setup + var calculation = new ProbabilisticPipingCalculation(new GeneralPipingInput()); + var calculationGroup = new CalculationGroup(); + calculationGroup.Children.Add(calculation); + + var failureMechanism = new PipingFailureMechanism(); + failureMechanism.CalculationsGroup.Children.Add(calculationGroup); + + var assessmentSection = mocks.Stub(); + assessmentSection.Stub(section => section.GetFailureMechanisms()).Return(new[] + { + failureMechanism + }); + + mocks.ReplayAll(); + + using (var view = new PipingInputView + { + Data = new ProbabilisticPipingCalculation(new GeneralPipingInput()) + }) + { + // Call + bool closeForData = info.CloseForData(view, assessmentSection); + + // Assert + Assert.IsFalse(closeForData); + mocks.VerifyAll(); + } + } + } +} \ No newline at end of file