Index: Riskeer/Common/src/Riskeer.Common.Forms/Views/NonAdoptableFailureMechanismSectionResultRow.cs =================================================================== diff -u --- Riskeer/Common/src/Riskeer.Common.Forms/Views/NonAdoptableFailureMechanismSectionResultRow.cs (revision 0) +++ Riskeer/Common/src/Riskeer.Common.Forms/Views/NonAdoptableFailureMechanismSectionResultRow.cs (revision 2ddd84f785961f7df17c7deba831cd96d05463e8) @@ -0,0 +1,272 @@ +// 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.ComponentModel; +using Core.Common.Controls.DataGrid; +using Riskeer.Common.Data.AssemblyTool; +using Riskeer.Common.Data.AssessmentSection; +using Riskeer.Common.Data.Exceptions; +using Riskeer.Common.Data.FailureMechanism; +using Riskeer.Common.Forms.Helpers; +using Riskeer.Common.Forms.TypeConverters; + +namespace Riskeer.Common.Forms.Views +{ + /// + /// This class represents a row of . + /// + public class NonAdoptableFailureMechanismSectionResultRow : FailureMechanismSectionResultRow + { + private readonly int initialFailureMechanismResultIndex; + private readonly int initialFailureMechanismResultSectionProbabilityIndex; + private readonly int furtherAnalysisNeededIndex; + private readonly int refinedSectionProbabilityIndex; + private readonly int sectionProbabilityIndex; + private readonly int assemblyGroupIndex; + + private readonly IAssessmentSection assessmentSection; + + /// + /// Creates a new instance of . + /// + /// The that is + /// the source of this row. + /// The assessment section the section result belongs to. + /// The property values required to create an instance of + /// . + /// Throw when any parameter is null. + public NonAdoptableFailureMechanismSectionResultRow(NonAdoptableFailureMechanismSectionResult sectionResult, + IAssessmentSection assessmentSection, + ConstructionProperties constructionProperties) + : base(sectionResult) + { + if (assessmentSection == null) + { + throw new ArgumentNullException(nameof(assessmentSection)); + } + + if (constructionProperties == null) + { + throw new ArgumentNullException(nameof(constructionProperties)); + } + + this.assessmentSection = assessmentSection; + + initialFailureMechanismResultIndex = constructionProperties.InitialFailureMechanismResultIndex; + initialFailureMechanismResultSectionProbabilityIndex = constructionProperties.InitialFailureMechanismResultSectionProbabilityIndex; + furtherAnalysisNeededIndex = constructionProperties.FurtherAnalysisNeededIndex; + refinedSectionProbabilityIndex = constructionProperties.RefinedSectionProbabilityIndex; + sectionProbabilityIndex = constructionProperties.SectionProbabilityIndex; + assemblyGroupIndex = constructionProperties.AssemblyGroupIndex; + + CreateColumnStateDefinitions(); + + Update(); + } + + /// + /// Gets or sets whether the section is relevant. + /// + public bool IsRelevant + { + get => SectionResult.IsRelevant; + set + { + SectionResult.IsRelevant = value; + UpdateInternalData(); + } + } + + /// + /// Gets or sets the initial failure mechanism result. + /// + public NonAdoptableInitialFailureMechanismResultType InitialFailureMechanismResult + { + get => SectionResult.InitialFailureMechanismResult; + set + { + SectionResult.InitialFailureMechanismResult = value; + UpdateInternalData(); + } + } + + /// + /// Gets or sets the value of the initial failure mechanism result per failure mechanism section as a probability. + /// + /// Thrown when is not in range [0,1]. + [TypeConverter(typeof(NoProbabilityValueDoubleConverter))] + public double InitialFailureMechanismResultSectionProbability + { + get => SectionResult.ManualInitialFailureMechanismResultSectionProbability; + set + { + SectionResult.ManualInitialFailureMechanismResultSectionProbability = value; + UpdateInternalData(); + } + } + + /// + /// Gets or sets whether further analysis is needed. + /// + public bool FurtherAnalysisNeeded + { + get => SectionResult.FurtherAnalysisNeeded; + set + { + SectionResult.FurtherAnalysisNeeded = value; + UpdateInternalData(); + } + } + + /// + /// Gets or sets the value of the refined probability per failure mechanism section. + /// + /// Thrown when is not in range [0,1].\ + [TypeConverter(typeof(NoProbabilityValueDoubleConverter))] + public object RefinedSectionProbability + { + get => SectionResult.RefinedSectionProbability; + set + { + SectionResult.RefinedSectionProbability = (double) value; + UpdateInternalData(); + } + } + + /// + /// Gets the section probability. + /// + [TypeConverter(typeof(NoProbabilityValueDoubleConverter))] + public double SectionProbability => AssemblyResult.SectionProbability; + + /// + /// Gets the assembly group. + /// + public string AssemblyGroup => FailureMechanismSectionAssemblyGroupDisplayHelper.GetAssemblyGroupDisplayName(AssemblyResult.AssemblyGroup); + + public override void Update() + { + UpdateDerivedData(); + UpdateColumnStateDefinitions(); + } + + private void UpdateDerivedData() + { + ResetErrorTexts(); + TryGetAssemblyResult(); + } + + private void ResetErrorTexts() + { + ColumnStateDefinitions[initialFailureMechanismResultSectionProbabilityIndex].ErrorText = string.Empty; + ColumnStateDefinitions[sectionProbabilityIndex].ErrorText = string.Empty; + ColumnStateDefinitions[assemblyGroupIndex].ErrorText = string.Empty; + } + + private void TryGetAssemblyResult() + { + try + { + AssemblyResult = FailureMechanismSectionAssemblyGroupFactory.AssembleSection( + assessmentSection, IsRelevant, InitialFailureMechanismResult, + InitialFailureMechanismResultSectionProbability, FurtherAnalysisNeeded, + SectionResult.RefinedSectionProbability); + } + catch (AssemblyException e) + { + AssemblyResult = new DefaultFailureMechanismSectionAssemblyResult(); + ColumnStateDefinitions[sectionProbabilityIndex].ErrorText = e.Message; + ColumnStateDefinitions[assemblyGroupIndex].ErrorText = e.Message; + } + } + + private void CreateColumnStateDefinitions() + { + ColumnStateDefinitions.Add(initialFailureMechanismResultIndex, new DataGridViewColumnStateDefinition()); + ColumnStateDefinitions.Add(initialFailureMechanismResultSectionProbabilityIndex, new DataGridViewColumnStateDefinition()); + ColumnStateDefinitions.Add(furtherAnalysisNeededIndex, new DataGridViewColumnStateDefinition()); + ColumnStateDefinitions.Add(refinedSectionProbabilityIndex, new DataGridViewColumnStateDefinition()); + ColumnStateDefinitions.Add(sectionProbabilityIndex, DataGridViewColumnStateDefinitionFactory.CreateReadOnlyColumnStateDefinition()); + ColumnStateDefinitions.Add(assemblyGroupIndex, DataGridViewColumnStateDefinitionFactory.CreateReadOnlyColumnStateDefinition()); + } + + private void UpdateColumnStateDefinitions() + { + ColumnStateHelper.SetColumnState(ColumnStateDefinitions[initialFailureMechanismResultIndex], !IsRelevant); + + if (!IsRelevant || InitialFailureMechanismResult == NonAdoptableInitialFailureMechanismResultType.NoFailureProbability) + { + ColumnStateHelper.DisableColumn(ColumnStateDefinitions[initialFailureMechanismResultSectionProbabilityIndex]); + } + else + { + ColumnStateHelper.EnableColumn(ColumnStateDefinitions[initialFailureMechanismResultSectionProbabilityIndex]); + } + + ColumnStateHelper.SetColumnState(ColumnStateDefinitions[furtherAnalysisNeededIndex], !IsRelevant); + + if (!IsRelevant || !FurtherAnalysisNeeded) + { + ColumnStateHelper.DisableColumn(ColumnStateDefinitions[refinedSectionProbabilityIndex]); + } + else + { + ColumnStateHelper.EnableColumn(ColumnStateDefinitions[refinedSectionProbabilityIndex]); + } + + FailureMechanismSectionResultRowHelper.SetAssemblyGroupStyle(ColumnStateDefinitions[assemblyGroupIndex], AssemblyResult.AssemblyGroup); + } + + public class ConstructionProperties + { + /// + /// Sets the initial failure mechanism result index. + /// + public int InitialFailureMechanismResultIndex { internal get; set; } + + /// + /// Sets the initial failure mechanism result section probability index. + /// + public int InitialFailureMechanismResultSectionProbabilityIndex { internal get; set; } + + /// + /// Sets the further analysis needed index. + /// + public int FurtherAnalysisNeededIndex { internal get; set; } + + /// + /// Sets the refined section probability index. + /// + public int RefinedSectionProbabilityIndex { internal get; set; } + + /// + /// Sets the section probability index. + /// + public int SectionProbabilityIndex { internal get; set; } + + /// + /// Sets the assembly group index. + /// + public int AssemblyGroupIndex { internal get; set; } + } + } +} \ No newline at end of file Index: Riskeer/Common/test/Riskeer.Common.Forms.Test/Views/AdoptableFailureMechanismSectionResultRowTest.cs =================================================================== diff -u -r712e462c20fd4a4b41cdc7df9731b6b50789909d -r2ddd84f785961f7df17c7deba831cd96d05463e8 --- Riskeer/Common/test/Riskeer.Common.Forms.Test/Views/AdoptableFailureMechanismSectionResultRowTest.cs (.../AdoptableFailureMechanismSectionResultRowTest.cs) (revision 712e462c20fd4a4b41cdc7df9731b6b50789909d) +++ Riskeer/Common/test/Riskeer.Common.Forms.Test/Views/AdoptableFailureMechanismSectionResultRowTest.cs (.../AdoptableFailureMechanismSectionResultRowTest.cs) (revision 2ddd84f785961f7df17c7deba831cd96d05463e8) @@ -156,7 +156,7 @@ new AssessmentSectionStub(), ConstructionProperties); // Assert - Assert.IsInstanceOf(row); + Assert.IsInstanceOf>(row); Assert.AreEqual(result.IsRelevant, row.IsRelevant); Assert.AreEqual(result.InitialFailureMechanismResult, row.InitialFailureMechanismResult); Assert.AreEqual(initialFailureMechanismResultProbability, row.InitialFailureMechanismResultSectionProbability); Index: Riskeer/Common/test/Riskeer.Common.Forms.Test/Views/NonAdoptableFailureMechanismSectionResultRowTest.cs =================================================================== diff -u --- Riskeer/Common/test/Riskeer.Common.Forms.Test/Views/NonAdoptableFailureMechanismSectionResultRowTest.cs (revision 0) +++ Riskeer/Common/test/Riskeer.Common.Forms.Test/Views/NonAdoptableFailureMechanismSectionResultRowTest.cs (revision 2ddd84f785961f7df17c7deba831cd96d05463e8) @@ -0,0 +1,549 @@ +// 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.Drawing; +using Core.Common.Base; +using Core.Common.Controls.DataGrid; +using Core.Common.TestUtil; +using NUnit.Framework; +using Rhino.Mocks; +using Riskeer.AssemblyTool.Data; +using Riskeer.AssemblyTool.KernelWrapper.Calculators; +using Riskeer.AssemblyTool.KernelWrapper.TestUtil.Calculators; +using Riskeer.AssemblyTool.KernelWrapper.TestUtil.Calculators.Assembly; +using Riskeer.Common.Data.AssemblyTool; +using Riskeer.Common.Data.FailureMechanism; +using Riskeer.Common.Data.TestUtil; +using Riskeer.Common.Data.TestUtil.Probability; +using Riskeer.Common.Forms.Helpers; +using Riskeer.Common.Forms.TestUtil; +using Riskeer.Common.Forms.TypeConverters; +using Riskeer.Common.Forms.Views; + +namespace Riskeer.Common.Forms.Test.Views +{ + [TestFixture] + public class NonAdoptableFailureMechanismSectionResultRowTest + { + private static NonAdoptableFailureMechanismSectionResultRow.ConstructionProperties ConstructionProperties => + new NonAdoptableFailureMechanismSectionResultRow.ConstructionProperties + { + InitialFailureMechanismResultIndex = 2, + InitialFailureMechanismResultSectionProbabilityIndex = 3, + FurtherAnalysisNeededIndex = 4, + RefinedSectionProbabilityIndex = 5, + SectionProbabilityIndex = 6, + AssemblyGroupIndex = 7 + }; + + [Test] + public void Constructor_AssessmentSectionNull_ThrowsArgumentNullException() + { + // Setup + FailureMechanismSection section = FailureMechanismSectionTestFactory.CreateFailureMechanismSection(); + var result = new NonAdoptableFailureMechanismSectionResult(section); + + // Call + void Call() => new NonAdoptableFailureMechanismSectionResultRow(result, null, ConstructionProperties); + + // Assert + var exception = Assert.Throws(Call); + Assert.AreEqual("assessmentSection", exception.ParamName); + } + + [Test] + public void Constructor_ConstructionPropertiesNull_ThrowsArgumentNullException() + { + // Setup + FailureMechanismSection section = FailureMechanismSectionTestFactory.CreateFailureMechanismSection(); + var result = new NonAdoptableFailureMechanismSectionResult(section); + + // Call + void Call() => new NonAdoptableFailureMechanismSectionResultRow(result, new AssessmentSectionStub(), null); + + // Assert + var exception = Assert.Throws(Call); + Assert.AreEqual("constructionProperties", exception.ParamName); + } + + [Test] + public void Constructor_ExpectedValues() + { + // Setup + FailureMechanismSection section = FailureMechanismSectionTestFactory.CreateFailureMechanismSection(); + var result = new NonAdoptableFailureMechanismSectionResult(section); + + using (new AssemblyToolCalculatorFactoryConfig()) + { + // Call + var row = new NonAdoptableFailureMechanismSectionResultRow(result, new AssessmentSectionStub(), ConstructionProperties); + + // Assert + Assert.IsInstanceOf>(row); + Assert.AreEqual(result.IsRelevant, row.IsRelevant); + Assert.AreEqual(result.InitialFailureMechanismResult, row.InitialFailureMechanismResult); + Assert.AreEqual(result.ManualInitialFailureMechanismResultSectionProbability, row.InitialFailureMechanismResultSectionProbability); + Assert.AreEqual(result.FurtherAnalysisNeeded, row.FurtherAnalysisNeeded); + Assert.AreEqual(result.RefinedSectionProbability, row.RefinedSectionProbability); + + TestHelper.AssertTypeConverter( + nameof(NonAdoptableFailureMechanismSectionResultRow.InitialFailureMechanismResultSectionProbability)); + TestHelper.AssertTypeConverter( + nameof(NonAdoptableFailureMechanismSectionResultRow.RefinedSectionProbability)); + TestHelper.AssertTypeConverter( + nameof(NonAdoptableFailureMechanismSectionResultRow.SectionProbability)); + + IDictionary columnStateDefinitions = row.ColumnStateDefinitions; + Assert.AreEqual(6, columnStateDefinitions.Count); + + DataGridViewControlColumnStateDefinitionTestHelper.AssertColumnStateDefinition(columnStateDefinitions, ConstructionProperties.InitialFailureMechanismResultIndex); + DataGridViewControlColumnStateDefinitionTestHelper.AssertColumnStateDefinition(columnStateDefinitions, ConstructionProperties.InitialFailureMechanismResultSectionProbabilityIndex); + DataGridViewControlColumnStateDefinitionTestHelper.AssertColumnStateDefinition(columnStateDefinitions, ConstructionProperties.FurtherAnalysisNeededIndex); + DataGridViewControlColumnStateDefinitionTestHelper.AssertColumnStateDefinition(columnStateDefinitions, ConstructionProperties.RefinedSectionProbabilityIndex); + DataGridViewControlColumnStateDefinitionTestHelper.AssertColumnStateDefinition(columnStateDefinitions, ConstructionProperties.SectionProbabilityIndex); + DataGridViewControlColumnStateDefinitionTestHelper.AssertColumnStateDefinition(columnStateDefinitions, ConstructionProperties.AssemblyGroupIndex); + } + } + + #region Registration + + [Test] + public void IsRelevant_SetNewValue_NotifyObserversAndPropertyChanged() + { + const bool newValue = false; + Property_SetNewValue_NotifyObserversAndPropertyChanged( + row => row.IsRelevant = newValue, + result => result.IsRelevant, + newValue); + } + + [Test] + public void InitialFailureMechanismResult_SetNewValue_NotifyObserversAndPropertyChanged() + { + const NonAdoptableInitialFailureMechanismResultType newValue = NonAdoptableInitialFailureMechanismResultType.NoFailureProbability; + Property_SetNewValue_NotifyObserversAndPropertyChanged( + row => row.InitialFailureMechanismResult = newValue, + result => result.InitialFailureMechanismResult, + newValue); + } + + [Test] + [TestCaseSource(typeof(ProbabilityTestHelper), nameof(ProbabilityTestHelper.GetValidProbabilities))] + public void InitialFailureMechanismResultSectionProbability_SetNewValue_NotifyObserversAndPropertyChanged(double newValue) + { + Property_SetNewValue_NotifyObserversAndPropertyChanged( + row => row.InitialFailureMechanismResultSectionProbability = newValue, + result => result.ManualInitialFailureMechanismResultSectionProbability, + newValue); + } + + [Test] + [SetCulture("nl-NL")] + [TestCaseSource(typeof(ProbabilityTestHelper), nameof(ProbabilityTestHelper.GetInvalidProbabilities))] + public void InitialFailureMechanismResultSectionProbability_InvalidValue_ThrowsArgumentOutOfRangeException(double value) + { + ProbabilityProperty_SetInvalidValue_ThrowsArgumentOutOfRangeException(row => row.InitialFailureMechanismResultSectionProbability = value); + } + + [Test] + public void FurtherAnalysisNeeded_SetNewValue_NotifyObserversAndPropertyChanged() + { + const bool newValue = true; + Property_SetNewValue_NotifyObserversAndPropertyChanged( + row => row.FurtherAnalysisNeeded = newValue, + result => result.FurtherAnalysisNeeded, + newValue); + } + + [Test] + [TestCaseSource(typeof(ProbabilityTestHelper), nameof(ProbabilityTestHelper.GetValidProbabilities))] + public void RefinedSectionProbability_SetNewValue_NotifyObserversAndPropertyChanged(double newValue) + { + Property_SetNewValue_NotifyObserversAndPropertyChanged( + row => row.RefinedSectionProbability = newValue, + result => result.RefinedSectionProbability, + newValue); + } + + [Test] + [SetCulture("nl-NL")] + [TestCaseSource(typeof(ProbabilityTestHelper), nameof(ProbabilityTestHelper.GetInvalidProbabilities))] + public void RefinedSectionProbability_InvalidValue_ThrowsArgumentOutOfRangeException(double value) + { + ProbabilityProperty_SetInvalidValue_ThrowsArgumentOutOfRangeException(row => row.RefinedSectionProbability = value); + } + + private static void Property_SetNewValue_NotifyObserversAndPropertyChanged( + Action setPropertyAction, + Func assertPropertyFunc, + T newValue) + { + // Setup + var mocks = new MockRepository(); + var observer = mocks.StrictMock(); + observer.Expect(o => o.UpdateObserver()); + mocks.ReplayAll(); + + FailureMechanismSection section = FailureMechanismSectionTestFactory.CreateFailureMechanismSection(); + var result = new NonAdoptableFailureMechanismSectionResult(section); + result.Attach(observer); + + using (new AssemblyToolCalculatorFactoryConfig()) + { + var row = new NonAdoptableFailureMechanismSectionResultRow(result, new AssessmentSectionStub(), ConstructionProperties); + + // Call + setPropertyAction(row); + + // Assert + Assert.AreEqual(newValue, assertPropertyFunc(result)); + } + + mocks.VerifyAll(); + } + + private static void ProbabilityProperty_SetInvalidValue_ThrowsArgumentOutOfRangeException( + Action setPropertyAction) + { + // Setup + FailureMechanismSection section = FailureMechanismSectionTestFactory.CreateFailureMechanismSection(); + var result = new NonAdoptableFailureMechanismSectionResult(section); + + using (new AssemblyToolCalculatorFactoryConfig()) + { + var row = new NonAdoptableFailureMechanismSectionResultRow(result, new AssessmentSectionStub(), ConstructionProperties); + + // Call + void Call() => setPropertyAction(row); + + // Assert + const string expectedMessage = "De waarde voor de faalkans moet in het bereik [0,0, 1,0] liggen."; + TestHelper.AssertThrowsArgumentExceptionAndTestMessage(Call, expectedMessage); + } + } + + #endregion + + #region Assembly + + [Test] + public void Constructor_AssemblyRan_InputCorrectlySetOnCalculator() + { + // Setup + var assessmentSection = new AssessmentSectionStub(); + + FailureMechanismSection section = FailureMechanismSectionTestFactory.CreateFailureMechanismSection(); + var result = new NonAdoptableFailureMechanismSectionResult(section); + + using (new AssemblyToolCalculatorFactoryConfig()) + { + var calculatorFactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance; + FailureMechanismSectionAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator; + + // Call + var row = new NonAdoptableFailureMechanismSectionResultRow(result, assessmentSection, ConstructionProperties); + + // Assert + FailureMechanismSectionAssemblyInput input = calculator.FailureMechanismSectionAssemblyInput; + Assert.AreEqual(assessmentSection.FailureMechanismContribution.SignalingNorm, input.SignalingNorm); + Assert.AreEqual(assessmentSection.FailureMechanismContribution.LowerLimitNorm, input.LowerLimitNorm); + Assert.AreEqual(row.IsRelevant, input.IsRelevant); + Assert.IsTrue(input.HasProbabilitySpecified); + Assert.AreEqual(row.InitialFailureMechanismResultSectionProbability, input.InitialProfileProbability); + Assert.AreEqual(row.InitialFailureMechanismResultSectionProbability, input.InitialSectionProbability); + Assert.AreEqual(row.FurtherAnalysisNeeded, input.FurtherAnalysisNeeded); + Assert.AreEqual(row.RefinedSectionProbability, input.RefinedProfileProbability); + Assert.AreEqual(row.RefinedSectionProbability, input.RefinedSectionProbability); + } + } + + [Test] + public void Constructor_AssemblyRan_ReturnCategoryGroups() + { + // Setup + var random = new Random(39); + + FailureMechanismSection section = FailureMechanismSectionTestFactory.CreateFailureMechanismSection(); + var result = new NonAdoptableFailureMechanismSectionResult(section); + + using (new AssemblyToolCalculatorFactoryConfig()) + { + var calculatorFactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance; + FailureMechanismSectionAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator; + calculator.FailureMechanismSectionAssemblyResultOutput = new FailureMechanismSectionAssemblyResult( + random.NextDouble(), random.NextDouble(), random.NextDouble(), random.NextEnumValue()); + + // Call + var row = new NonAdoptableFailureMechanismSectionResultRow(result, new AssessmentSectionStub(), ConstructionProperties); + + // Assert + FailureMechanismSectionAssemblyResult calculatorOutput = calculator.FailureMechanismSectionAssemblyResultOutput; + FailureMechanismSectionAssemblyResult rowAssemblyResult = row.AssemblyResult; + AssertFailureMechanismSectionAssemblyResult(calculatorOutput, rowAssemblyResult); + + Assert.AreEqual(rowAssemblyResult.SectionProbability, row.SectionProbability); + Assert.AreEqual(FailureMechanismSectionAssemblyGroupDisplayHelper.GetAssemblyGroupDisplayName(rowAssemblyResult.AssemblyGroup), + row.AssemblyGroup); + } + } + + [Test] + public void GivenRowWithoutAssemblyErrors_WhenUpdatingAndAssemblyThrowsException_ThenAssemblyPropertiesSetToDefault() + { + // Given + var random = new Random(39); + + FailureMechanismSection section = FailureMechanismSectionTestFactory.CreateFailureMechanismSection(); + var result = new NonAdoptableFailureMechanismSectionResult(section); + + using (new AssemblyToolCalculatorFactoryConfig()) + { + var calculatorFactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance; + FailureMechanismSectionAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator; + calculator.FailureMechanismSectionAssemblyResultOutput = new FailureMechanismSectionAssemblyResult( + random.NextDouble(), random.NextDouble(), random.NextDouble(), random.NextEnumValue()); + + var row = new NonAdoptableFailureMechanismSectionResultRow(result, new AssessmentSectionStub(), ConstructionProperties); + + // Precondition + FailureMechanismSectionAssemblyResult calculatorOutput = calculator.FailureMechanismSectionAssemblyResultOutput; + AssertFailureMechanismSectionAssemblyResult(calculatorOutput, row.AssemblyResult); + + // When + calculator.ThrowExceptionOnCalculate = true; + row.InitialFailureMechanismResult = NonAdoptableInitialFailureMechanismResultType.NoFailureProbability; + + // Then + AssertFailureMechanismSectionAssemblyResult(new DefaultFailureMechanismSectionAssemblyResult(), row.AssemblyResult); + } + } + + [Test] + public void GivenRowWithoutAssemblyErrors_WhenUpdatingAndAssemblyThrowsException_ThenShowError() + { + // Given + FailureMechanismSection section = FailureMechanismSectionTestFactory.CreateFailureMechanismSection(); + var result = new NonAdoptableFailureMechanismSectionResult(section); + + using (new AssemblyToolCalculatorFactoryConfig()) + { + var calculatorFactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance; + FailureMechanismSectionAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator; + + var row = new NonAdoptableFailureMechanismSectionResultRow(result, new AssessmentSectionStub(), ConstructionProperties); + + // Precondition + IDictionary columnStateDefinitions = row.ColumnStateDefinitions; + Assert.AreEqual(string.Empty, columnStateDefinitions[ConstructionProperties.SectionProbabilityIndex].ErrorText); + Assert.AreEqual(string.Empty, columnStateDefinitions[ConstructionProperties.AssemblyGroupIndex].ErrorText); + + // When + calculator.ThrowExceptionOnCalculate = true; + row.InitialFailureMechanismResult = NonAdoptableInitialFailureMechanismResultType.NoFailureProbability; + + // Then + const string expectedErrorText = "Message"; + + Assert.AreEqual(expectedErrorText, columnStateDefinitions[ConstructionProperties.SectionProbabilityIndex].ErrorText); + Assert.AreEqual(expectedErrorText, columnStateDefinitions[ConstructionProperties.AssemblyGroupIndex].ErrorText); + } + } + + [Test] + public void GivenRowWithAssemblyErrors_WhenUpdatingAndAssemblyDoesNotThrowException_ThenNoErrorShown() + { + // Given + FailureMechanismSection section = FailureMechanismSectionTestFactory.CreateFailureMechanismSection(); + var result = new NonAdoptableFailureMechanismSectionResult(section); + + using (new AssemblyToolCalculatorFactoryConfig()) + { + var calculatorFactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance; + FailureMechanismSectionAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator; + calculator.ThrowExceptionOnCalculate = true; + + var row = new NonAdoptableFailureMechanismSectionResultRow(result, new AssessmentSectionStub(), ConstructionProperties); + + // Precondition + IDictionary columnStateDefinitions = row.ColumnStateDefinitions; + const string expectedErrorText = "Message"; + + Assert.AreEqual(expectedErrorText, columnStateDefinitions[ConstructionProperties.SectionProbabilityIndex].ErrorText); + Assert.AreEqual(expectedErrorText, columnStateDefinitions[ConstructionProperties.AssemblyGroupIndex].ErrorText); + + // When + calculator.ThrowExceptionOnCalculate = false; + row.InitialFailureMechanismResult = NonAdoptableInitialFailureMechanismResultType.NoFailureProbability; + + // Then + Assert.AreEqual(string.Empty, columnStateDefinitions[ConstructionProperties.SectionProbabilityIndex].ErrorText); + Assert.AreEqual(string.Empty, columnStateDefinitions[ConstructionProperties.AssemblyGroupIndex].ErrorText); + } + } + + private static void AssertFailureMechanismSectionAssemblyResult(FailureMechanismSectionAssemblyResult expected, + FailureMechanismSectionAssemblyResult actual) + { + Assert.AreEqual(expected.N, actual.N); + Assert.AreEqual(expected.SectionProbability, actual.SectionProbability); + Assert.AreEqual(expected.ProfileProbability, actual.ProfileProbability); + Assert.AreEqual(expected.AssemblyGroup, actual.AssemblyGroup); + } + + #endregion + + #region Column States + + [Test] + public void Constructor_Always_ExpectedColumnStates() + { + // Setup + FailureMechanismSection section = FailureMechanismSectionTestFactory.CreateFailureMechanismSection(); + var result = new NonAdoptableFailureMechanismSectionResult(section); + + using (new AssemblyToolCalculatorFactoryConfig()) + { + // Call + var row = new NonAdoptableFailureMechanismSectionResultRow(result, new AssessmentSectionStub(), ConstructionProperties); + + // Assert + IDictionary columnStateDefinitions = row.ColumnStateDefinitions; + + DataGridViewControlColumnStateDefinitionTestHelper.AssertColumnState( + columnStateDefinitions[ConstructionProperties.SectionProbabilityIndex], true, true); + } + } + + [Test] + [TestCase(true)] + [TestCase(false)] + public void Constructor_WithIsRelevant_ExpectedColumnStates(bool isRelevant) + { + // Setup + FailureMechanismSection section = FailureMechanismSectionTestFactory.CreateFailureMechanismSection(); + var result = new NonAdoptableFailureMechanismSectionResult(section) + { + IsRelevant = isRelevant, + FurtherAnalysisNeeded = true, + InitialFailureMechanismResult = NonAdoptableInitialFailureMechanismResultType.Manual + }; + + using (new AssemblyToolCalculatorFactoryConfig()) + { + // Call + var row = new NonAdoptableFailureMechanismSectionResultRow(result, new AssessmentSectionStub(), ConstructionProperties); + + // Assert + IDictionary columnStateDefinitions = row.ColumnStateDefinitions; + + DataGridViewControlColumnStateDefinitionTestHelper.AssertColumnState( + columnStateDefinitions[ConstructionProperties.InitialFailureMechanismResultIndex], isRelevant); + DataGridViewControlColumnStateDefinitionTestHelper.AssertColumnState( + columnStateDefinitions[ConstructionProperties.InitialFailureMechanismResultSectionProbabilityIndex], isRelevant); + DataGridViewControlColumnStateDefinitionTestHelper.AssertColumnState( + columnStateDefinitions[ConstructionProperties.FurtherAnalysisNeededIndex], isRelevant); + DataGridViewControlColumnStateDefinitionTestHelper.AssertColumnState( + columnStateDefinitions[ConstructionProperties.RefinedSectionProbabilityIndex], isRelevant); + } + } + + [Test] + [TestCase(NonAdoptableInitialFailureMechanismResultType.Manual, true, false)] + [TestCase(NonAdoptableInitialFailureMechanismResultType.NoFailureProbability, false, true)] + public void Constructor_WithInitialFailureMechanismResult_ExpectedColumnStates(NonAdoptableInitialFailureMechanismResultType initialFailureMechanismResultType, + bool isEnabled, bool isReadOnly) + { + // Setup + FailureMechanismSection section = FailureMechanismSectionTestFactory.CreateFailureMechanismSection(); + var result = new NonAdoptableFailureMechanismSectionResult(section) + { + InitialFailureMechanismResult = initialFailureMechanismResultType + }; + + using (new AssemblyToolCalculatorFactoryConfig()) + { + // Call + var row = new NonAdoptableFailureMechanismSectionResultRow(result, new AssessmentSectionStub(), ConstructionProperties); + + // Assert + IDictionary columnStateDefinitions = row.ColumnStateDefinitions; + + DataGridViewControlColumnStateDefinitionTestHelper.AssertColumnState( + columnStateDefinitions[ConstructionProperties.InitialFailureMechanismResultSectionProbabilityIndex], isEnabled, isReadOnly); + } + } + + [Test] + [TestCase(true)] + [TestCase(false)] + public void Constructor_WithFurtherAnalysisNeeded_ExpectedColumnStates(bool furtherAnalysisNeeded) + { + // Setup + FailureMechanismSection section = FailureMechanismSectionTestFactory.CreateFailureMechanismSection(); + var result = new NonAdoptableFailureMechanismSectionResult(section) + { + FurtherAnalysisNeeded = furtherAnalysisNeeded + }; + + using (new AssemblyToolCalculatorFactoryConfig()) + { + // Call + var row = new NonAdoptableFailureMechanismSectionResultRow(result, new AssessmentSectionStub(), ConstructionProperties); + + // Assert + IDictionary columnStateDefinitions = row.ColumnStateDefinitions; + + DataGridViewControlColumnStateDefinitionTestHelper.AssertColumnState( + columnStateDefinitions[ConstructionProperties.RefinedSectionProbabilityIndex], furtherAnalysisNeeded); + } + } + + [Test] + [TestCaseSource(typeof(AssemblyGroupColorTestHelper), nameof(AssemblyGroupColorTestHelper.FailureMechanismSectionAssemblyGroupColorCases))] + public void Constructor_WithAssemblyGroupsSet_ExpectedColumnStates(FailureMechanismSectionAssemblyGroup assemblyGroup, + Color expectedBackgroundColor) + { + // Setup + FailureMechanismSection section = FailureMechanismSectionTestFactory.CreateFailureMechanismSection(); + var result = new NonAdoptableFailureMechanismSectionResult(section); + + using (new AssemblyToolCalculatorFactoryConfig()) + { + var calculatorFactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance; + FailureMechanismSectionAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator; + calculator.FailureMechanismSectionAssemblyResultOutput = new FailureMechanismSectionAssemblyResult(double.NaN, double.NaN, double.NaN, assemblyGroup); + + // Call + var row = new NonAdoptableFailureMechanismSectionResultRow(result, new AssessmentSectionStub(), ConstructionProperties); + + // Assert + IDictionary columnStateDefinitions = row.ColumnStateDefinitions; + + DataGridViewControlColumnStateDefinitionTestHelper.AssertColumnWithColorState( + columnStateDefinitions[ConstructionProperties.AssemblyGroupIndex], expectedBackgroundColor); + } + } + + #endregion + } +} \ No newline at end of file