Fisheye: Tag 4cced5dc46fe7dd8896ad15d1ec190dec9b2358e refers to a dead (removed) revision in file `Ringtoets/Piping/src/Ringtoets.Piping.Data/PipingFailureMechanismSection2aAssessmentResultExtensions.cs'. Fisheye: No comparison available. Pass `N' to diff? Index: Ringtoets/Piping/src/Ringtoets.Piping.Data/PipingFailureMechanismSectionDetailedAssessmentResultExtensions.cs =================================================================== diff -u --- Ringtoets/Piping/src/Ringtoets.Piping.Data/PipingFailureMechanismSectionDetailedAssessmentResultExtensions.cs (revision 0) +++ Ringtoets/Piping/src/Ringtoets.Piping.Data/PipingFailureMechanismSectionDetailedAssessmentResultExtensions.cs (revision 4cced5dc46fe7dd8896ad15d1ec190dec9b2358e) @@ -0,0 +1,171 @@ +// Copyright (C) Stichting Deltares 2017. All rights reserved. +// +// This file is part of Ringtoets. +// +// Ringtoets 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.ComponentModel; +using System.Linq; +using Core.Common.Base.Data; +using Core.Common.Base.Geometry; +using Ringtoets.Common.Data.AssessmentSection; +using Ringtoets.Common.Data.Calculation; + +namespace Ringtoets.Piping.Data +{ + /// + /// Extension methods for obtaining detailed assessment results from output for an assessment of the piping failure mechanism. + /// + public static class PipingFailureMechanismSectionDetailedAssessmentResultExtensions + { + /// + /// Gets the value for the detailed assessment of safety per failure mechanism section as a probability. + /// + /// The section result to get the assessment layer 2A for. + /// All calculations in the failure mechanism. + /// The failure mechanism the calculations belong to. + /// The assessment section the calculations belong to. + /// The calculated assessment layer 2A; or when there are no + /// performed calculations. + /// Thrown when any parameter is null. + public static double GetDetailedAssessmentProbability(this PipingFailureMechanismSectionResult sectionResult, + IEnumerable calculations, + PipingFailureMechanism failureMechanism, + IAssessmentSection assessmentSection) + { + if (sectionResult == null) + { + throw new ArgumentNullException(nameof(sectionResult)); + } + + if (calculations == null) + { + throw new ArgumentNullException(nameof(calculations)); + } + + if (failureMechanism == null) + { + throw new ArgumentNullException(nameof(failureMechanism)); + } + + if (assessmentSection == null) + { + throw new ArgumentNullException(nameof(assessmentSection)); + } + + IEnumerable calculationScenarios = sectionResult + .GetCalculationScenarios(calculations) + .Where(cs => cs.Status == CalculationScenarioStatus.Done); + + if (calculationScenarios.Any()) + { + double totalDetailedAssessment = 0; + foreach (PipingCalculationScenario scenario in calculationScenarios) + { + DerivedPipingOutput derivedOutput = DerivedPipingOutputFactory.Create(scenario.Output, failureMechanism, assessmentSection); + + totalDetailedAssessment += derivedOutput.PipingProbability * (double) scenario.Contribution; + } + + return totalDetailedAssessment; + } + + return double.NaN; + } + + /// + /// Gets the contribution of all relevant together. + /// + /// The result to get the result for. + /// All calculations in the failure mechanism. + public static RoundedDouble GetTotalContribution(this PipingFailureMechanismSectionResult pipingFailureMechanismSectionResult, + IEnumerable calculations) + { + return (RoundedDouble) pipingFailureMechanismSectionResult + .GetCalculationScenarios(calculations) + .Aggregate(0, (current, calculationScenario) => current + calculationScenario.Contribution); + } + + /// + /// Gets a list of the relevant . + /// + /// The result to get the result for. + /// All calculations in the failure mechanism. + public static IEnumerable GetCalculationScenarios(this PipingFailureMechanismSectionResult pipingFailureMechanismSectionResult, + IEnumerable calculations) + { + IEnumerable lineSegments = Math2D.ConvertLinePointsToLineSegments(pipingFailureMechanismSectionResult.Section.Points); + + return calculations + .Where(pc => pc.IsRelevant && pc.IsSurfaceLineIntersectionWithReferenceLineInSection(lineSegments)); + } + + /// + /// Gets the status of the section result depending on the relevant calculation scenarios. + /// + /// The result to get the result for. + /// All calculations in the failure mechanism. + /// Thrown when any of the relevant calculations + /// in has an invalid . + /// Thrown when any of the relevant scenarios has an unsupported value of . + public static CalculationScenarioStatus GetCalculationScenarioStatus(this PipingFailureMechanismSectionResult pipingFailureMechanismSectionResult, + IEnumerable calculations) + { + var failed = false; + var notCalculated = false; + foreach (PipingCalculationScenario calculationScenario in pipingFailureMechanismSectionResult.GetCalculationScenarios(calculations).Where(cs => cs.IsRelevant)) + { + CalculationScenarioStatus calculationScenarioStatus = calculationScenario.Status; + if (!Enum.IsDefined(typeof(CalculationScenarioStatus), calculationScenarioStatus)) + { + throw new InvalidEnumArgumentException(nameof(pipingFailureMechanismSectionResult), + (int) calculationScenarioStatus, + typeof(CalculationScenarioStatus)); + } + + switch (calculationScenarioStatus) + { + case CalculationScenarioStatus.Failed: + failed = true; + break; + case CalculationScenarioStatus.NotCalculated: + notCalculated = true; + break; + case CalculationScenarioStatus.Done: + continue; + default: + throw new NotSupportedException($"The enum value {nameof(CalculationScenarioStatus)}.{calculationScenarioStatus} is not supported."); + } + } + + if (failed) + { + return CalculationScenarioStatus.Failed; + } + + if (notCalculated) + { + return CalculationScenarioStatus.NotCalculated; + } + + return CalculationScenarioStatus.Done; + } + } +} \ No newline at end of file Index: Ringtoets/Piping/src/Ringtoets.Piping.Data/Ringtoets.Piping.Data.csproj =================================================================== diff -u -rd7696913d8f9239cb80eb2c3bac6cc0ccf23d479 -r4cced5dc46fe7dd8896ad15d1ec190dec9b2358e --- Ringtoets/Piping/src/Ringtoets.Piping.Data/Ringtoets.Piping.Data.csproj (.../Ringtoets.Piping.Data.csproj) (revision d7696913d8f9239cb80eb2c3bac6cc0ccf23d479) +++ Ringtoets/Piping/src/Ringtoets.Piping.Data/Ringtoets.Piping.Data.csproj (.../Ringtoets.Piping.Data.csproj) (revision 4cced5dc46fe7dd8896ad15d1ec190dec9b2358e) @@ -19,7 +19,7 @@ - + Index: Ringtoets/Piping/src/Ringtoets.Piping.Forms/Views/PipingFailureMechanismResultView.cs =================================================================== diff -u -r2c8012ba40f0290a41ed277712a4eb8fc5ce8431 -r4cced5dc46fe7dd8896ad15d1ec190dec9b2358e --- Ringtoets/Piping/src/Ringtoets.Piping.Forms/Views/PipingFailureMechanismResultView.cs (.../PipingFailureMechanismResultView.cs) (revision 2c8012ba40f0290a41ed277712a4eb8fc5ce8431) +++ Ringtoets/Piping/src/Ringtoets.Piping.Forms/Views/PipingFailureMechanismResultView.cs (.../PipingFailureMechanismResultView.cs) (revision 4cced5dc46fe7dd8896ad15d1ec190dec9b2358e) @@ -39,7 +39,7 @@ /// public class PipingFailureMechanismResultView : FailureMechanismResultView { - private const int assessmentLayerTwoAIndex = 2; + private const int detailedAssessmentIndex = 2; private const double tolerance = 1e-6; private readonly RecursiveObserver calculationInputObserver; private readonly RecursiveObserver calculationOutputObserver; @@ -69,7 +69,7 @@ Observable = failureMechanism }; - DataGridViewControl.CellFormatting += ShowAssessmentLayerTwoAErrors; + DataGridViewControl.CellFormatting += ShowDetailedAssessmentErrors; DataGridViewControl.CellFormatting += DisableIrrelevantFieldsFormatting; // The concat is needed to observe the input of calculations in child groups. @@ -97,7 +97,7 @@ protected override void Dispose(bool disposing) { - DataGridViewControl.CellFormatting -= ShowAssessmentLayerTwoAErrors; + DataGridViewControl.CellFormatting -= ShowDetailedAssessmentErrors; DataGridViewControl.CellFormatting -= DisableIrrelevantFieldsFormatting; calculationInputObserver.Dispose(); @@ -132,7 +132,7 @@ nameof(EnumDisplayWrapper.DisplayName)); DataGridViewControl.AddTextBoxColumn( - nameof(PipingFailureMechanismSectionResultRow.AssessmentLayerTwoA), + nameof(PipingFailureMechanismSectionResultRow.DetailedAssessment), RingtoetsCommonFormsResources.FailureMechanismResultView_DetailedAssessment_ColumnHeader, true); DataGridViewControl.AddTextBoxColumn( @@ -160,9 +160,9 @@ } } - private void ShowAssessmentLayerTwoAErrors(object sender, DataGridViewCellFormattingEventArgs e) + private void ShowDetailedAssessmentErrors(object sender, DataGridViewCellFormattingEventArgs e) { - if (e.ColumnIndex != assessmentLayerTwoAIndex) + if (e.ColumnIndex != detailedAssessmentIndex) { return; } @@ -200,7 +200,7 @@ return; } - if (double.IsNaN(resultRow.AssessmentLayerTwoA)) + if (double.IsNaN(resultRow.DetailedAssessment)) { currentDataGridViewCell.ErrorText = RingtoetsCommonFormsResources.FailureMechanismResultView_DataGridViewCellFormatting_All_calculations_must_have_valid_output; return; Index: Ringtoets/Piping/src/Ringtoets.Piping.Forms/Views/PipingFailureMechanismSectionResultRow.cs =================================================================== diff -u -r2c8012ba40f0290a41ed277712a4eb8fc5ce8431 -r4cced5dc46fe7dd8896ad15d1ec190dec9b2358e --- Ringtoets/Piping/src/Ringtoets.Piping.Forms/Views/PipingFailureMechanismSectionResultRow.cs (.../PipingFailureMechanismSectionResultRow.cs) (revision 2c8012ba40f0290a41ed277712a4eb8fc5ce8431) +++ Ringtoets/Piping/src/Ringtoets.Piping.Forms/Views/PipingFailureMechanismSectionResultRow.cs (.../PipingFailureMechanismSectionResultRow.cs) (revision 4cced5dc46fe7dd8896ad15d1ec190dec9b2358e) @@ -113,10 +113,10 @@ } /// - /// Gets the assessment layer two a of the . + /// Gets the detailed assessment probability a of the . /// [TypeConverter(typeof(NoProbabilityValueDoubleConverter))] - public double AssessmentLayerTwoA + public double DetailedAssessment { get { @@ -133,7 +133,7 @@ return double.NaN; } - return SectionResult.GetAssessmentLayerTwoA(relevantScenarios, failureMechanism, assessmentSection); + return SectionResult.GetDetailedAssessmentProbability(relevantScenarios, failureMechanism, assessmentSection); } } Fisheye: Tag 4cced5dc46fe7dd8896ad15d1ec190dec9b2358e refers to a dead (removed) revision in file `Ringtoets/Piping/test/Ringtoets.Piping.Data.Test/PipingFailureMechanismSection2aAssessmentResultExtensionsTest.cs'. Fisheye: No comparison available. Pass `N' to diff? Index: Ringtoets/Piping/test/Ringtoets.Piping.Data.Test/PipingFailureMechanismSectionDetailedAssessmentResultExtensionsTest.cs =================================================================== diff -u --- Ringtoets/Piping/test/Ringtoets.Piping.Data.Test/PipingFailureMechanismSectionDetailedAssessmentResultExtensionsTest.cs (revision 0) +++ Ringtoets/Piping/test/Ringtoets.Piping.Data.Test/PipingFailureMechanismSectionDetailedAssessmentResultExtensionsTest.cs (revision 4cced5dc46fe7dd8896ad15d1ec190dec9b2358e) @@ -0,0 +1,386 @@ +// Copyright (C) Stichting Deltares 2017. All rights reserved. +// +// This file is part of Ringtoets. +// +// Ringtoets 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.Linq; +using Core.Common.Base.Data; +using NUnit.Framework; +using Rhino.Mocks; +using Ringtoets.Common.Data.AssessmentSection; +using Ringtoets.Common.Data.Calculation; +using Ringtoets.Common.Data.FailureMechanism; +using Ringtoets.Common.Data.TestUtil; +using Ringtoets.Piping.Data.TestUtil; + +namespace Ringtoets.Piping.Data.Test +{ + [TestFixture] + public class PipingFailureMechanismSectionDetailedAssessmentResultExtensionsTest + { + [Test] + public void GetDetailedAssessmentProbability_SectionResultNull_ThrowsArgumentNullException() + { + // Setup + var mocks = new MockRepository(); + var assessmentSection = mocks.Stub(); + mocks.ReplayAll(); + + // Call + TestDelegate call = () => PipingFailureMechanismSectionDetailedAssessmentResultExtensions.GetDetailedAssessmentProbability( + null, Enumerable.Empty(), + new PipingFailureMechanism(), assessmentSection); + + // Assert + var exception = Assert.Throws(call); + Assert.AreEqual("sectionResult", exception.ParamName); + mocks.VerifyAll(); + } + + [Test] + public void GetDetailedAssessmentProbability_CalculationsNull_ThrowsArgumentNullException() + { + // Setup + var mocks = new MockRepository(); + var assessmentSection = mocks.Stub(); + mocks.ReplayAll(); + + FailureMechanismSection section = FailureMechanismSectionTestFactory.CreateFailureMechanismSection(); + var failureMechanismSectionResult = new PipingFailureMechanismSectionResult(section); + + // Call + TestDelegate call = () => failureMechanismSectionResult.GetDetailedAssessmentProbability(null, new PipingFailureMechanism(), assessmentSection); + + // Assert + var exception = Assert.Throws(call); + Assert.AreEqual("calculations", exception.ParamName); + mocks.VerifyAll(); + } + + [Test] + public void GetDetailedAssessmentProbability_FailureMechanismNull_ThrowsArgumentNullException() + { + // Setup + var mocks = new MockRepository(); + var assessmentSection = mocks.Stub(); + mocks.ReplayAll(); + + FailureMechanismSection section = FailureMechanismSectionTestFactory.CreateFailureMechanismSection(); + var failureMechanismSectionResult = new PipingFailureMechanismSectionResult(section); + + // Call + TestDelegate call = () => failureMechanismSectionResult.GetDetailedAssessmentProbability(Enumerable.Empty(), + null, + assessmentSection); + + // Assert + var exception = Assert.Throws(call); + Assert.AreEqual("failureMechanism", exception.ParamName); + mocks.VerifyAll(); + } + + [Test] + public void GetDetailedAssessmentProbability_AssessmentSectionNull_ThrowsArgumentNullException() + { + // Setup + FailureMechanismSection section = FailureMechanismSectionTestFactory.CreateFailureMechanismSection(); + var failureMechanismSectionResult = new PipingFailureMechanismSectionResult(section); + + // Call + TestDelegate call = () => failureMechanismSectionResult.GetDetailedAssessmentProbability(Enumerable.Empty(), + new PipingFailureMechanism(), + null); + + // Assert + var exception = Assert.Throws(call); + Assert.AreEqual("assessmentSection", exception.ParamName); + } + + [Test] + public void GetDetailedAssessmentProbability_MultipleScenarios_ReturnsValueBasedOnRelevantAndDoneScenarios() + { + // Setup + var failureMechanism = new PipingFailureMechanism(); + + var mocks = new MockRepository(); + IAssessmentSection assessmentSection = AssessmentSectionHelper.CreateAssessmentSectionStub(failureMechanism, mocks); + mocks.ReplayAll(); + + FailureMechanismSection section = FailureMechanismSectionTestFactory.CreateFailureMechanismSection(); + var failureMechanismSectionResult = new PipingFailureMechanismSectionResult(section); + + const double contribution1 = 0.2; + const double contribution2 = 0.8; + + PipingCalculationScenario pipingCalculationScenario1 = PipingCalculationScenarioTestFactory.CreatePipingCalculationScenario(section); + PipingCalculationScenario pipingCalculationScenario2 = PipingCalculationScenarioTestFactory.CreatePipingCalculationScenario(section); + PipingCalculationScenario pipingCalculationScenario3 = PipingCalculationScenarioTestFactory.CreatePipingCalculationScenario(section); + PipingCalculationScenario pipingCalculationScenario4 = PipingCalculationScenarioTestFactory.CreateNotCalculatedPipingCalculationScenario(section); + + pipingCalculationScenario1.IsRelevant = true; + pipingCalculationScenario1.Contribution = (RoundedDouble) contribution1; + + pipingCalculationScenario2.IsRelevant = true; + pipingCalculationScenario2.Contribution = (RoundedDouble) contribution2; + + pipingCalculationScenario3.IsRelevant = false; + + pipingCalculationScenario4.IsRelevant = true; + + var calculations = new[] + { + pipingCalculationScenario1, + pipingCalculationScenario2, + pipingCalculationScenario3, + pipingCalculationScenario4 + }; + + // Call + double detailedAssessment = failureMechanismSectionResult.GetDetailedAssessmentProbability(calculations, failureMechanism, assessmentSection); + + // Assert + Assert.AreEqual(0.028693041013187315, detailedAssessment); + mocks.VerifyAll(); + } + + [Test] + public void GetDetailedAssessmentProbability_NoScenarios_ReturnsNaN() + { + // Setup + var mocks = new MockRepository(); + var assessmentSection = mocks.Stub(); + mocks.ReplayAll(); + + var failureMechanism = new PipingFailureMechanism(); + + FailureMechanismSection section = FailureMechanismSectionTestFactory.CreateFailureMechanismSection(); + var failureMechanismSectionResult = new PipingFailureMechanismSectionResult(section); + + // Call + double detailedAssessment = failureMechanismSectionResult.GetDetailedAssessmentProbability(Enumerable.Empty(), + failureMechanism, + assessmentSection); + + // Assert + Assert.IsNaN(detailedAssessment); + mocks.VerifyAll(); + } + + [Test] + public void GetDetailedAssessmentProbability_NoRelevantScenarios_ReturnsNaN() + { + // Setup + var mocks = new MockRepository(); + var assessmentSection = mocks.Stub(); + mocks.ReplayAll(); + + var failureMechanism = new PipingFailureMechanism(); + + FailureMechanismSection section = FailureMechanismSectionTestFactory.CreateFailureMechanismSection(); + var failureMechanismSectionResult = new PipingFailureMechanismSectionResult(section); + + PipingCalculationScenario calculationScenario1 = PipingCalculationScenarioTestFactory.CreateIrrelevantPipingCalculationScenario(section); + PipingCalculationScenario calculationScenario2 = PipingCalculationScenarioTestFactory.CreateIrrelevantPipingCalculationScenario(section); + + var calculationScenarios = new[] + { + calculationScenario1, + calculationScenario2 + }; + + // Call + double detailedAssessment = failureMechanismSectionResult.GetDetailedAssessmentProbability(calculationScenarios, + failureMechanism, + assessmentSection); + + // Assert + Assert.IsNaN(detailedAssessment); + mocks.VerifyAll(); + } + + [Test] + public void GetDetailedAssessmentProbability_ScenarioNotCalculated_ReturnsNaN() + { + // Setup + var mocks = new MockRepository(); + var assessmentSection = mocks.Stub(); + mocks.ReplayAll(); + + var failureMechanism = new PipingFailureMechanism(); + + FailureMechanismSection section = FailureMechanismSectionTestFactory.CreateFailureMechanismSection(); + var failureMechanismSectionResult = new PipingFailureMechanismSectionResult(section); + + PipingCalculationScenario pipingCalculationScenario = PipingCalculationScenarioTestFactory.CreateNotCalculatedPipingCalculationScenario(section); + + // Call + double detailedAssessment = failureMechanismSectionResult.GetDetailedAssessmentProbability(new[] + { + pipingCalculationScenario + }, failureMechanism, assessmentSection); + + // Assert + Assert.IsNaN(detailedAssessment); + mocks.VerifyAll(); + } + + [Test] + public void GetDetailedAssessmentProbability_ScenarioWithNanResults_ReturnsNaN() + { + // Setup + var failureMechanism = new PipingFailureMechanism(); + + var mocks = new MockRepository(); + IAssessmentSection assessmentSection = AssessmentSectionHelper.CreateAssessmentSectionStub(failureMechanism, mocks); + mocks.ReplayAll(); + + FailureMechanismSection section = FailureMechanismSectionTestFactory.CreateFailureMechanismSection(); + var failureMechanismSectionResult = new PipingFailureMechanismSectionResult(section); + + const double contribution1 = 0.2; + const double contribution2 = 0.8; + + PipingCalculationScenario pipingCalculationScenario1 = PipingCalculationScenarioTestFactory.CreatePipingCalculationScenario(section); + PipingCalculationScenario pipingCalculationScenario2 = PipingCalculationScenarioTestFactory.CreateNotCalculatedPipingCalculationScenario(section); + + pipingCalculationScenario1.IsRelevant = true; + pipingCalculationScenario1.Contribution = (RoundedDouble) contribution1; + + pipingCalculationScenario2.IsRelevant = true; + pipingCalculationScenario2.Contribution = (RoundedDouble) contribution2; + pipingCalculationScenario2.Output = new PipingOutput(new PipingOutput.ConstructionProperties()); + + var calculations = new[] + { + pipingCalculationScenario1, + pipingCalculationScenario2 + }; + + // Call + double detailedAssessment = failureMechanismSectionResult.GetDetailedAssessmentProbability(calculations, failureMechanism, assessmentSection); + + // Assert + Assert.IsNaN(detailedAssessment); + mocks.VerifyAll(); + } + + [Test] + public void GetTotalContribution_Always_ReturnsTotalRelevantScenarioContribution() + { + // Setup + FailureMechanismSection section = FailureMechanismSectionTestFactory.CreateFailureMechanismSection(); + var failureMechanismSectionResult = new PipingFailureMechanismSectionResult(section); + + PipingCalculationScenario pipingCalculationScenario = PipingCalculationScenarioTestFactory.CreateNotCalculatedPipingCalculationScenario(section); + pipingCalculationScenario.Contribution = (RoundedDouble) 0.3; + + PipingCalculationScenario pipingCalculationScenario2 = PipingCalculationScenarioTestFactory.CreateNotCalculatedPipingCalculationScenario(section); + pipingCalculationScenario2.Contribution = (RoundedDouble) 0.5; + + PipingCalculationScenario pipingCalculationScenario3 = PipingCalculationScenarioTestFactory.CreateIrrelevantPipingCalculationScenario(section); + + var calculationScenarios = new[] + { + pipingCalculationScenario, + pipingCalculationScenario2, + pipingCalculationScenario3 + }; + + // Call + RoundedDouble totalContribution = failureMechanismSectionResult.GetTotalContribution(calculationScenarios); + + // Assert + Assert.AreEqual((RoundedDouble) 0.8, totalContribution); + } + + [Test] + public void GetCalculationScenarioStatus_ScenarioNotCalculated_ReturnsStatusNotCalculated() + { + // Setup + FailureMechanismSection section = FailureMechanismSectionTestFactory.CreateFailureMechanismSection(); + var failureMechanismSectionResult = new PipingFailureMechanismSectionResult(section); + + PipingCalculationScenario pipingCalculationScenario = PipingCalculationScenarioTestFactory.CreateNotCalculatedPipingCalculationScenario(section); + + // Call + CalculationScenarioStatus status = failureMechanismSectionResult.GetCalculationScenarioStatus(new[] + { + pipingCalculationScenario + }); + + // Assert + Assert.AreEqual(CalculationScenarioStatus.NotCalculated, status); + } + + [Test] + public void GetCalculationScenarioStatus_ScenarioCalculated_ReturnsStatusDone() + { + // Setup + FailureMechanismSection section = FailureMechanismSectionTestFactory.CreateFailureMechanismSection(); + var failureMechanismSectionResult = new PipingFailureMechanismSectionResult(section); + + PipingCalculationScenario pipingCalculationScenario = PipingCalculationScenarioTestFactory.CreatePipingCalculationScenario(section); + + // Call + CalculationScenarioStatus status = failureMechanismSectionResult.GetCalculationScenarioStatus(new[] + { + pipingCalculationScenario + }); + + // Assert + Assert.AreEqual(CalculationScenarioStatus.Done, status); + } + + [Test] + public void GetCalculationScenarioStatus_NoScenarios_ReturnsStatusDone() + { + // Setup + FailureMechanismSection section = FailureMechanismSectionTestFactory.CreateFailureMechanismSection(); + var failureMechanismSectionResult = new PipingFailureMechanismSectionResult(section); + + // Call + CalculationScenarioStatus status = failureMechanismSectionResult.GetCalculationScenarioStatus(Enumerable.Empty()); + + // Assert + Assert.AreEqual(CalculationScenarioStatus.Done, status); + } + + [Test] + public void GetCalculationScenarioStatus_DifferentScenarios_ReturnsStatusNotCalculated() + { + // Setup + FailureMechanismSection section = FailureMechanismSectionTestFactory.CreateFailureMechanismSection(); + var failureMechanismSectionResult = new PipingFailureMechanismSectionResult(section); + + PipingCalculationScenario pipingCalculationScenario1 = PipingCalculationScenarioTestFactory.CreateNotCalculatedPipingCalculationScenario(section); + PipingCalculationScenario pipingCalculationScenario2 = PipingCalculationScenarioTestFactory.CreatePipingCalculationScenario(section); + + // Call + CalculationScenarioStatus status = failureMechanismSectionResult.GetCalculationScenarioStatus(new[] + { + pipingCalculationScenario1, + pipingCalculationScenario2 + }); + + // Assert + Assert.AreEqual(CalculationScenarioStatus.NotCalculated, status); + } + } +} \ No newline at end of file Index: Ringtoets/Piping/test/Ringtoets.Piping.Data.Test/Ringtoets.Piping.Data.Test.csproj =================================================================== diff -u -rd7696913d8f9239cb80eb2c3bac6cc0ccf23d479 -r4cced5dc46fe7dd8896ad15d1ec190dec9b2358e --- Ringtoets/Piping/test/Ringtoets.Piping.Data.Test/Ringtoets.Piping.Data.Test.csproj (.../Ringtoets.Piping.Data.Test.csproj) (revision d7696913d8f9239cb80eb2c3bac6cc0ccf23d479) +++ Ringtoets/Piping/test/Ringtoets.Piping.Data.Test/Ringtoets.Piping.Data.Test.csproj (.../Ringtoets.Piping.Data.Test.csproj) (revision 4cced5dc46fe7dd8896ad15d1ec190dec9b2358e) @@ -27,7 +27,7 @@ - + Index: Ringtoets/Piping/test/Ringtoets.Piping.Forms.Test/Views/PipingFailureMechanismResultViewTest.cs =================================================================== diff -u -rd7696913d8f9239cb80eb2c3bac6cc0ccf23d479 -r4cced5dc46fe7dd8896ad15d1ec190dec9b2358e --- Ringtoets/Piping/test/Ringtoets.Piping.Forms.Test/Views/PipingFailureMechanismResultViewTest.cs (.../PipingFailureMechanismResultViewTest.cs) (revision d7696913d8f9239cb80eb2c3bac6cc0ccf23d479) +++ Ringtoets/Piping/test/Ringtoets.Piping.Forms.Test/Views/PipingFailureMechanismResultViewTest.cs (.../PipingFailureMechanismResultViewTest.cs) (revision 4cced5dc46fe7dd8896ad15d1ec190dec9b2358e) @@ -47,7 +47,7 @@ { private const int nameColumnIndex = 0; private const int simpleAssessmentIndex = 1; - private const int assessmentLayerTwoAIndex = 2; + private const int detailedAssessmentIndex = 2; private const int assessmentLayerThreeIndex = 3; private Form testForm; @@ -114,13 +114,13 @@ var dataGridView = (DataGridView) new ControlTester("dataGridView").TheObject; Assert.AreEqual(4, dataGridView.ColumnCount); - Assert.IsTrue(dataGridView.Columns[assessmentLayerTwoAIndex].ReadOnly); + Assert.IsTrue(dataGridView.Columns[detailedAssessmentIndex].ReadOnly); Assert.IsInstanceOf(dataGridView.Columns[simpleAssessmentIndex]); - Assert.IsInstanceOf(dataGridView.Columns[assessmentLayerTwoAIndex]); + Assert.IsInstanceOf(dataGridView.Columns[detailedAssessmentIndex]); Assert.IsInstanceOf(dataGridView.Columns[assessmentLayerThreeIndex]); Assert.AreEqual("Eenvoudige toets", dataGridView.Columns[simpleAssessmentIndex].HeaderText); - Assert.AreEqual("Gedetailleerde toets per vak", dataGridView.Columns[assessmentLayerTwoAIndex].HeaderText); + Assert.AreEqual("Gedetailleerde toets per vak", dataGridView.Columns[detailedAssessmentIndex].HeaderText); Assert.AreEqual("Toets op maat", dataGridView.Columns[assessmentLayerThreeIndex].HeaderText); Assert.AreEqual(DataGridViewAutoSizeColumnsMode.AllCells, dataGridView.AutoSizeColumnsMode); @@ -147,14 +147,14 @@ Assert.AreEqual(4, cells.Count); Assert.AreEqual("Section 1", cells[nameColumnIndex].FormattedValue); Assert.AreEqual(SimpleAssessmentResultType.None, cells[simpleAssessmentIndex].Value); - Assert.AreEqual("-", cells[assessmentLayerTwoAIndex].FormattedValue); + Assert.AreEqual("-", cells[detailedAssessmentIndex].FormattedValue); Assert.AreEqual("-", cells[assessmentLayerThreeIndex].FormattedValue); cells = rows[1].Cells; Assert.AreEqual(4, cells.Count); Assert.AreEqual("Section 2", cells[nameColumnIndex].FormattedValue); Assert.AreEqual(SimpleAssessmentResultType.None, cells[simpleAssessmentIndex].Value); - Assert.AreEqual("-", cells[assessmentLayerTwoAIndex].FormattedValue); + Assert.AreEqual("-", cells[detailedAssessmentIndex].FormattedValue); Assert.AreEqual("-", cells[assessmentLayerThreeIndex].FormattedValue); } } @@ -183,24 +183,24 @@ DataGridViewCellCollection cells = rows[0].Cells; Assert.AreEqual(4, cells.Count); Assert.AreEqual("Section 1", cells[nameColumnIndex].FormattedValue); - DataGridViewCell cellAssessmentLayerTwoA = cells[assessmentLayerTwoAIndex]; + DataGridViewCell cellDetailedAssessment = cells[detailedAssessmentIndex]; DataGridViewCell cellAssessmentLayerThree = cells[assessmentLayerThreeIndex]; Assert.AreEqual(simpleAssessmentType, cells[simpleAssessmentIndex].Value); - Assert.AreEqual("-", cellAssessmentLayerTwoA.FormattedValue); + Assert.AreEqual("-", cellDetailedAssessment.FormattedValue); Assert.AreEqual("-", cellAssessmentLayerThree.FormattedValue); if (simpleAssessmentType == SimpleAssessmentResultType.ProbabilityNegligible || simpleAssessmentType == SimpleAssessmentResultType.NotApplicable) { - DataGridViewTestHelper.AssertCellIsDisabled(cellAssessmentLayerTwoA); + DataGridViewTestHelper.AssertCellIsDisabled(cellDetailedAssessment); DataGridViewTestHelper.AssertCellIsDisabled(cellAssessmentLayerThree); Assert.IsTrue(cellAssessmentLayerThree.ReadOnly); } else { - DataGridViewTestHelper.AssertCellIsEnabled(cellAssessmentLayerTwoA, true); + DataGridViewTestHelper.AssertCellIsEnabled(cellDetailedAssessment, true); DataGridViewTestHelper.AssertCellIsEnabled(cellAssessmentLayerThree); Assert.IsFalse(cellAssessmentLayerThree.ReadOnly); @@ -292,7 +292,7 @@ var gridTester = new ControlTester("dataGridView"); var dataGridView = (DataGridView) gridTester.TheObject; - DataGridViewCell dataGridViewCell = dataGridView.Rows[rowIndex].Cells[assessmentLayerTwoAIndex]; + DataGridViewCell dataGridViewCell = dataGridView.Rows[rowIndex].Cells[detailedAssessmentIndex]; dataGridView.Rows[rowIndex].Cells[simpleAssessmentIndex].Value = simpleAssessmentType; // Call @@ -309,7 +309,7 @@ [SetCulture("nl-NL")] [TestCase(SimpleAssessmentResultType.None)] [TestCase(SimpleAssessmentResultType.AssessFurther)] - public void FailureMechanismResultView_AssessmentLayerTwoAHasValue_DoesNotShowsErrorTooltip( + public void FailureMechanismResultView_DetailedAssessmentHasValue_DoesNotShowsErrorTooltip( SimpleAssessmentResultType simpleAssessmentType) { // Setup @@ -324,7 +324,7 @@ var gridTester = new ControlTester("dataGridView"); var dataGridView = (DataGridView) gridTester.TheObject; - DataGridViewCell dataGridViewCell = dataGridView.Rows[rowIndex].Cells[assessmentLayerTwoAIndex]; + DataGridViewCell dataGridViewCell = dataGridView.Rows[rowIndex].Cells[detailedAssessmentIndex]; dataGridView.Rows[rowIndex].Cells[simpleAssessmentIndex].Value = simpleAssessmentType; // Call @@ -340,7 +340,7 @@ [Test] [TestCase(SimpleAssessmentResultType.None)] [TestCase(SimpleAssessmentResultType.AssessFurther)] - public void FailureMechanismResultView_AssessmentLayerTwoANull_ShowsErrorTooltip(SimpleAssessmentResultType simpleAssessmentType) + public void FailureMechanismResultView_DetailedAssessmentNull_ShowsErrorTooltip(SimpleAssessmentResultType simpleAssessmentType) { // Setup const int rowIndex = 0; @@ -354,7 +354,7 @@ var gridTester = new ControlTester("dataGridView"); var dataGridView = (DataGridView) gridTester.TheObject; - DataGridViewCell dataGridViewCell = dataGridView.Rows[rowIndex].Cells[assessmentLayerTwoAIndex]; + DataGridViewCell dataGridViewCell = dataGridView.Rows[rowIndex].Cells[detailedAssessmentIndex]; dataGridView.Rows[rowIndex].Cells[simpleAssessmentIndex].Value = simpleAssessmentType; // Call @@ -370,7 +370,7 @@ [Test] [TestCase(SimpleAssessmentResultType.None)] [TestCase(SimpleAssessmentResultType.AssessFurther)] - public void FailureMechanismResultView_AssessmentLayerTwoANaN_ShowsErrorTooltip(SimpleAssessmentResultType simpleAssessmentType) + public void FailureMechanismResultView_DetailedAssessmentNaN_ShowsErrorTooltip(SimpleAssessmentResultType simpleAssessmentType) { // Setup const int rowIndex = 0; @@ -385,7 +385,7 @@ var gridTester = new ControlTester("dataGridView"); var dataGridView = (DataGridView) gridTester.TheObject; - DataGridViewCell dataGridViewCell = dataGridView.Rows[rowIndex].Cells[assessmentLayerTwoAIndex]; + DataGridViewCell dataGridViewCell = dataGridView.Rows[rowIndex].Cells[detailedAssessmentIndex]; dataGridView.Rows[rowIndex].Cells[simpleAssessmentIndex].Value = simpleAssessmentType; // Call @@ -411,7 +411,7 @@ var gridTester = new ControlTester("dataGridView"); var dataGridView = (DataGridView) gridTester.TheObject; - DataGridViewCell dataGridViewCell = dataGridView.Rows[rowIndex].Cells[assessmentLayerTwoAIndex]; + DataGridViewCell dataGridViewCell = dataGridView.Rows[rowIndex].Cells[detailedAssessmentIndex]; dataGridView.Rows[rowIndex].Cells[simpleAssessmentIndex].Value = simpleAssessmentType; // Call @@ -442,7 +442,7 @@ var gridTester = new ControlTester("dataGridView"); var dataGridView = (DataGridView) gridTester.TheObject; - DataGridViewCell dataGridViewCell = dataGridView.Rows[rowIndex].Cells[assessmentLayerTwoAIndex]; + DataGridViewCell dataGridViewCell = dataGridView.Rows[rowIndex].Cells[detailedAssessmentIndex]; dataGridView.Rows[rowIndex].Cells[simpleAssessmentIndex].Value = simpleAssessmentType; // Call @@ -456,7 +456,7 @@ } [Test] - public void FailureMechanismResultView_SimpleAssessmentProbabilityNegligibleAndAssessmentLayerTwoANaN_DoesNotShowError() + public void FailureMechanismResultView_SimpleAssessmentProbabilityNegligibleAndDetailedAssessmentNaN_DoesNotShowError() { // Setup const int rowIndex = 0; @@ -471,7 +471,7 @@ var gridTester = new ControlTester("dataGridView"); var dataGridView = (DataGridView) gridTester.TheObject; - DataGridViewCell dataGridViewCell = dataGridView.Rows[rowIndex].Cells[assessmentLayerTwoAIndex]; + DataGridViewCell dataGridViewCell = dataGridView.Rows[rowIndex].Cells[detailedAssessmentIndex]; // Call dataGridView.Rows[rowIndex].Cells[simpleAssessmentIndex].Value = SimpleAssessmentResultType.ProbabilityNegligible; Index: Ringtoets/Piping/test/Ringtoets.Piping.Forms.Test/Views/PipingFailureMechanismSectionResultRowTest.cs =================================================================== diff -u -r2c8012ba40f0290a41ed277712a4eb8fc5ce8431 -r4cced5dc46fe7dd8896ad15d1ec190dec9b2358e --- Ringtoets/Piping/test/Ringtoets.Piping.Forms.Test/Views/PipingFailureMechanismSectionResultRowTest.cs (.../PipingFailureMechanismSectionResultRowTest.cs) (revision 2c8012ba40f0290a41ed277712a4eb8fc5ce8431) +++ Ringtoets/Piping/test/Ringtoets.Piping.Forms.Test/Views/PipingFailureMechanismSectionResultRowTest.cs (.../PipingFailureMechanismSectionResultRowTest.cs) (revision 4cced5dc46fe7dd8896ad15d1ec190dec9b2358e) @@ -61,13 +61,13 @@ // Assert Assert.IsInstanceOf>(row); Assert.AreEqual(row.SimpleAssessmentResult, result.SimpleAssessmentResult); - Assert.AreEqual(result.GetAssessmentLayerTwoA(Enumerable.Empty(), - failureMechanism, assessmentSection), - row.AssessmentLayerTwoA); + Assert.AreEqual(result.GetDetailedAssessmentProbability(Enumerable.Empty(), + failureMechanism, assessmentSection), + row.DetailedAssessment); Assert.AreEqual(row.AssessmentLayerThree, result.AssessmentLayerThree); TestHelper.AssertTypeConverter( - nameof(PipingFailureMechanismSectionResultRow.AssessmentLayerTwoA)); + nameof(PipingFailureMechanismSectionResultRow.DetailedAssessment)); TestHelper.AssertTypeConverter( nameof(PipingFailureMechanismSectionResultRow.AssessmentLayerThree)); mocks.VerifyAll(); @@ -161,7 +161,7 @@ } [Test] - public void AssessmentLayerTwoA_NoScenarios_ReturnNaN() + public void DetailedAssessment_NoScenarios_ReturnNaN() { // Setup var mocks = new MockRepository(); @@ -178,7 +178,7 @@ failureMechanism, assessmentSection); // Assert - Assert.IsNaN(row.AssessmentLayerTwoA); + Assert.IsNaN(row.DetailedAssessment); mocks.VerifyAll(); } @@ -188,7 +188,7 @@ [TestCase(0.3, 0.7 + 1e-5)] [TestCase(-5, -8)] [TestCase(13, 2)] - public void AssessmentLayerTwoA_RelevantScenarioContributionDontAddUpTo1_ReturnNaN(double contributionA, double contributionB) + public void DetailedAssessment_RelevantScenarioContributionDontAddUpTo1_ReturnNaN(double contributionA, double contributionB) { // Setup var mocks = new MockRepository(); @@ -212,15 +212,15 @@ }, failureMechanism, assessmentSection); // Call - double assessmentLayerTwoA = row.AssessmentLayerTwoA; + double detailedAssessment = row.DetailedAssessment; // Assert - Assert.IsNaN(assessmentLayerTwoA); + Assert.IsNaN(detailedAssessment); mocks.VerifyAll(); } [Test] - public void AssessmentLayerTwoA_NoRelevantScenariosDone_ReturnNaN() + public void DetailedAssessment_NoRelevantScenariosDone_ReturnNaN() { // Setup var mocks = new MockRepository(); @@ -240,15 +240,15 @@ }, failureMechanism, assessmentSection); // Call - double assessmentLayerTwoA = row.AssessmentLayerTwoA; + double detailedAssessment = row.DetailedAssessment; // Assert - Assert.IsNaN(assessmentLayerTwoA); + Assert.IsNaN(detailedAssessment); mocks.VerifyAll(); } [Test] - public void AssessmentLayerTwoA_RelevantScenariosDone_ResultOfSection() + public void DetailedAssessment_RelevantScenariosDone_ResultOfSection() { // Setup var failureMechanism = new PipingFailureMechanism(); @@ -268,14 +268,14 @@ }, failureMechanism, assessmentSection); // Call - double assessmentLayerTwoA = row.AssessmentLayerTwoA; + double detailedAssessment = row.DetailedAssessment; // Assert - double expected = result.GetAssessmentLayerTwoA(new[] + double expected = result.GetDetailedAssessmentProbability(new[] { scenario }, failureMechanism, assessmentSection); - Assert.AreEqual(expected, assessmentLayerTwoA, 1e-6); + Assert.AreEqual(expected, detailedAssessment, 1e-6); mocks.VerifyAll(); } Index: Ringtoets/Piping/test/Ringtoets.Piping.Integration.Test/PipingFailureMechanismResultViewIntegrationTest.cs =================================================================== diff -u -r7c037110f82f8b11269ece9edeef02c7f4d59c9b -r4cced5dc46fe7dd8896ad15d1ec190dec9b2358e --- Ringtoets/Piping/test/Ringtoets.Piping.Integration.Test/PipingFailureMechanismResultViewIntegrationTest.cs (.../PipingFailureMechanismResultViewIntegrationTest.cs) (revision 7c037110f82f8b11269ece9edeef02c7f4d59c9b) +++ Ringtoets/Piping/test/Ringtoets.Piping.Integration.Test/PipingFailureMechanismResultViewIntegrationTest.cs (.../PipingFailureMechanismResultViewIntegrationTest.cs) (revision 4cced5dc46fe7dd8896ad15d1ec190dec9b2358e) @@ -40,7 +40,7 @@ [TestFixture] public class PipingFailureMechanismResultViewIntegrationTest { - private const int assessmentLayerTwoAIndex = 2; + private const int detailedAssessmentIndex = 2; [Test] [SetCulture("nl-NL")] @@ -66,9 +66,9 @@ IFailureMechanism failureMechanism = assessmentSection.Piping; DataImportHelper.ImportFailureMechanismSections(assessmentSection, failureMechanism); Assert.AreEqual(283, dataGridView.Rows.Count); - Assert.AreEqual("-", dataGridView.Rows[22].Cells[assessmentLayerTwoAIndex].FormattedValue); + Assert.AreEqual("-", dataGridView.Rows[22].Cells[detailedAssessmentIndex].FormattedValue); Assert.AreEqual("Er moet minimaal één maatgevende berekening voor dit vak worden geselecteerd.", - dataGridView.Rows[22].Cells[assessmentLayerTwoAIndex].ErrorText); + dataGridView.Rows[22].Cells[detailedAssessmentIndex].ErrorText); // Import surface lines DataImportHelper.ImportPipingSurfaceLines(assessmentSection); @@ -94,87 +94,87 @@ // Add a piping calculation and ensure it is shown in the data grid view assessmentSection.Piping.CalculationsGroup.Children.Add(pipingCalculation1); assessmentSection.Piping.CalculationsGroup.NotifyObservers(); - Assert.AreEqual("-", dataGridView.Rows[22].Cells[assessmentLayerTwoAIndex].FormattedValue); + Assert.AreEqual("-", dataGridView.Rows[22].Cells[detailedAssessmentIndex].FormattedValue); Assert.AreEqual("Alle berekeningen voor dit vak moeten uitgevoerd zijn.", - dataGridView.Rows[22].Cells[assessmentLayerTwoAIndex].ErrorText); + dataGridView.Rows[22].Cells[detailedAssessmentIndex].ErrorText); // Add group and ensure the data grid view is not changed var nestedPipingCalculationGroup = new CalculationGroup(); assessmentSection.Piping.CalculationsGroup.Children.Add(nestedPipingCalculationGroup); assessmentSection.Piping.CalculationsGroup.NotifyObservers(); - Assert.AreEqual("-", dataGridView.Rows[22].Cells[assessmentLayerTwoAIndex].FormattedValue); + Assert.AreEqual("-", dataGridView.Rows[22].Cells[detailedAssessmentIndex].FormattedValue); Assert.AreEqual("Alle berekeningen voor dit vak moeten uitgevoerd zijn.", - dataGridView.Rows[22].Cells[assessmentLayerTwoAIndex].ErrorText); + dataGridView.Rows[22].Cells[detailedAssessmentIndex].ErrorText); // Add another, nested calculation and ensure the data grid view is updated nestedPipingCalculationGroup.Children.Add(pipingCalculation2); nestedPipingCalculationGroup.NotifyObservers(); - Assert.AreEqual("-", dataGridView.Rows[22].Cells[assessmentLayerTwoAIndex].FormattedValue); + Assert.AreEqual("-", dataGridView.Rows[22].Cells[detailedAssessmentIndex].FormattedValue); Assert.AreEqual("Bijdrage van de geselecteerde scenario's voor dit vak moet opgeteld gelijk zijn aan 100%.", - dataGridView.Rows[22].Cells[assessmentLayerTwoAIndex].ErrorText); + dataGridView.Rows[22].Cells[detailedAssessmentIndex].ErrorText); // Set the second calculation to not relevant and ensure the data grid view is updated pipingCalculation2.IsRelevant = false; pipingCalculation2.NotifyObservers(); - Assert.AreEqual("-", dataGridView.Rows[22].Cells[assessmentLayerTwoAIndex].FormattedValue); + Assert.AreEqual("-", dataGridView.Rows[22].Cells[detailedAssessmentIndex].FormattedValue); Assert.AreEqual("Alle berekeningen voor dit vak moeten uitgevoerd zijn.", - dataGridView.Rows[22].Cells[assessmentLayerTwoAIndex].ErrorText); + dataGridView.Rows[22].Cells[detailedAssessmentIndex].ErrorText); // Execute the first calculation and ensure the data grid view is updated pipingCalculation1.Output = PipingOutputTestFactory.Create(0.26065, 0.81398, 0.38024); pipingCalculation1.NotifyObservers(); Assert.AreEqual(ProbabilityFormattingHelper.Format(2.425418e-4), - dataGridView.Rows[22].Cells[assessmentLayerTwoAIndex].FormattedValue); - Assert.IsEmpty(dataGridView.Rows[22].Cells[assessmentLayerTwoAIndex].ErrorText); + dataGridView.Rows[22].Cells[detailedAssessmentIndex].FormattedValue); + Assert.IsEmpty(dataGridView.Rows[22].Cells[detailedAssessmentIndex].ErrorText); // Add another, nested calculation without surface line and ensure the data grid view is updated when the surface line is set var pipingCalculation3 = new PipingCalculationScenario(new GeneralPipingInput()); nestedPipingCalculationGroup.Children.Add(pipingCalculation3); nestedPipingCalculationGroup.NotifyObservers(); Assert.AreEqual(ProbabilityFormattingHelper.Format(2.425418e-4), - dataGridView.Rows[22].Cells[assessmentLayerTwoAIndex].FormattedValue); - Assert.IsEmpty(dataGridView.Rows[22].Cells[assessmentLayerTwoAIndex].ErrorText); + dataGridView.Rows[22].Cells[detailedAssessmentIndex].FormattedValue); + Assert.IsEmpty(dataGridView.Rows[22].Cells[detailedAssessmentIndex].ErrorText); pipingCalculation3.InputParameters.SurfaceLine = assessmentSection.Piping.SurfaceLines.First( sl => sl.Name == "PK001_0001"); pipingCalculation3.InputParameters.NotifyObservers(); - Assert.AreEqual("-", dataGridView.Rows[22].Cells[assessmentLayerTwoAIndex].FormattedValue); + Assert.AreEqual("-", dataGridView.Rows[22].Cells[detailedAssessmentIndex].FormattedValue); Assert.AreEqual("Bijdrage van de geselecteerde scenario's voor dit vak moet opgeteld gelijk zijn aan 100%.", - dataGridView.Rows[22].Cells[assessmentLayerTwoAIndex].ErrorText); + dataGridView.Rows[22].Cells[detailedAssessmentIndex].ErrorText); // Change the contribution of the calculation and make sure the data grid view is updated pipingCalculation3.Contribution = (RoundedDouble) 0.3; pipingCalculation3.NotifyObservers(); - Assert.AreEqual("-", dataGridView.Rows[22].Cells[assessmentLayerTwoAIndex].FormattedValue); + Assert.AreEqual("-", dataGridView.Rows[22].Cells[detailedAssessmentIndex].FormattedValue); Assert.AreEqual("Bijdrage van de geselecteerde scenario's voor dit vak moet opgeteld gelijk zijn aan 100%.", - dataGridView.Rows[22].Cells[assessmentLayerTwoAIndex].ErrorText); + dataGridView.Rows[22].Cells[detailedAssessmentIndex].ErrorText); pipingCalculation1.Contribution = (RoundedDouble) 0.7; pipingCalculation1.NotifyObservers(); - Assert.AreEqual("-", dataGridView.Rows[22].Cells[assessmentLayerTwoAIndex].FormattedValue); + Assert.AreEqual("-", dataGridView.Rows[22].Cells[detailedAssessmentIndex].FormattedValue); Assert.AreEqual("Alle berekeningen voor dit vak moeten uitgevoerd zijn.", - dataGridView.Rows[22].Cells[assessmentLayerTwoAIndex].ErrorText); + dataGridView.Rows[22].Cells[detailedAssessmentIndex].ErrorText); // Remove a calculation and make sure the data grid view is updated nestedPipingCalculationGroup.Children.Remove(pipingCalculation3); nestedPipingCalculationGroup.NotifyObservers(); - Assert.AreEqual("-", dataGridView.Rows[22].Cells[assessmentLayerTwoAIndex].FormattedValue); + Assert.AreEqual("-", dataGridView.Rows[22].Cells[detailedAssessmentIndex].FormattedValue); Assert.AreEqual("Bijdrage van de geselecteerde scenario's voor dit vak moet opgeteld gelijk zijn aan 100%.", - dataGridView.Rows[22].Cells[assessmentLayerTwoAIndex].ErrorText); + dataGridView.Rows[22].Cells[detailedAssessmentIndex].ErrorText); // Set contribution again so we have a probability. pipingCalculation1.Contribution = (RoundedDouble) 1.0; pipingCalculation1.NotifyObservers(); Assert.AreEqual(ProbabilityFormattingHelper.Format(2.425418e-4), - dataGridView.Rows[22].Cells[assessmentLayerTwoAIndex].FormattedValue); - Assert.IsEmpty(dataGridView.Rows[22].Cells[assessmentLayerTwoAIndex].ErrorText); + dataGridView.Rows[22].Cells[detailedAssessmentIndex].FormattedValue); + Assert.IsEmpty(dataGridView.Rows[22].Cells[detailedAssessmentIndex].ErrorText); // Clear the output of the calculation and make sure the data grid view is updated PipingDataSynchronizationService.ClearCalculationOutput(pipingCalculation1); pipingCalculation1.NotifyObservers(); - Assert.AreEqual("-", dataGridView.Rows[22].Cells[assessmentLayerTwoAIndex].FormattedValue); + Assert.AreEqual("-", dataGridView.Rows[22].Cells[detailedAssessmentIndex].FormattedValue); Assert.AreEqual("Alle berekeningen voor dit vak moeten uitgevoerd zijn.", - dataGridView.Rows[22].Cells[assessmentLayerTwoAIndex].ErrorText); + dataGridView.Rows[22].Cells[detailedAssessmentIndex].ErrorText); } } }