Index: Riskeer/Common/src/Riskeer.Common.Forms/Views/AdoptableFailureMechanismSectionResultRow.cs
===================================================================
diff -u -rbb016ddc95a38ada23790e69740d6cd3d5cb12f0 -red4f25fd91db395c473db1973fcce187fe436035
--- Riskeer/Common/src/Riskeer.Common.Forms/Views/AdoptableFailureMechanismSectionResultRow.cs (.../AdoptableFailureMechanismSectionResultRow.cs) (revision bb016ddc95a38ada23790e69740d6cd3d5cb12f0)
+++ Riskeer/Common/src/Riskeer.Common.Forms/Views/AdoptableFailureMechanismSectionResultRow.cs (.../AdoptableFailureMechanismSectionResultRow.cs) (revision ed4f25fd91db395c473db1973fcce187fe436035)
@@ -22,7 +22,9 @@
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;
@@ -97,6 +99,8 @@
assemblyGroupIndex = constructionProperties.AssemblyGroupIndex;
CreateColumnStateDefinitions();
+
+ Update();
}
///
@@ -181,8 +185,52 @@
///
public string AssemblyGroup => FailureMechanismSectionAssemblyGroupDisplayHelper.GetAssemblyGroupDisplayName(AssemblyResult.AssemblyGroup);
- public override void Update() {}
-
+ public override void Update()
+ {
+ UpdateDerivedData();
+ UpdateColumnStateDefinitions();
+ UpdateInitialFailureMechanismResultErrors();
+ }
+
+ private void UpdateInitialFailureMechanismResultErrors()
+ {
+ if (SectionResult.IsRelevant && SectionResult.InitialFailureMechanismResult == InitialFailureMechanismResultType.Adopt)
+ {
+ ColumnStateDefinitions[initialFailureMechanismResultSectionProbabilityIndex].ErrorText = initialFailureMechanismResultErrorProvider.GetProbabilityValidationError(
+ calculateInitialFailureMechanismResultProbabilityFunc);
+ }
+ }
+
+ 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());
@@ -193,6 +241,34 @@
ColumnStateDefinitions.Add(assemblyGroupIndex, DataGridViewColumnStateDefinitionFactory.CreateReadOnlyColumnStateDefinition());
}
+ private void UpdateColumnStateDefinitions()
+ {
+ ColumnStateHelper.SetColumnState(ColumnStateDefinitions[initialFailureMechanismResultIndex], !IsRelevant);
+
+ if (!IsRelevant || InitialFailureMechanismResult == InitialFailureMechanismResultType.NoFailureProbability)
+ {
+ ColumnStateHelper.DisableColumn(ColumnStateDefinitions[initialFailureMechanismResultSectionProbabilityIndex]);
+ }
+ else
+ {
+ ColumnStateHelper.EnableColumn(ColumnStateDefinitions[initialFailureMechanismResultSectionProbabilityIndex],
+ InitialFailureMechanismResult == InitialFailureMechanismResultType.Adopt);
+ }
+
+ 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
{
///
Index: Riskeer/Common/test/Riskeer.Common.Forms.Test/Views/AdoptableFailureMechanismSectionResultRowTest.cs
===================================================================
diff -u -rbb016ddc95a38ada23790e69740d6cd3d5cb12f0 -red4f25fd91db395c473db1973fcce187fe436035
--- Riskeer/Common/test/Riskeer.Common.Forms.Test/Views/AdoptableFailureMechanismSectionResultRowTest.cs (.../AdoptableFailureMechanismSectionResultRowTest.cs) (revision bb016ddc95a38ada23790e69740d6cd3d5cb12f0)
+++ Riskeer/Common/test/Riskeer.Common.Forms.Test/Views/AdoptableFailureMechanismSectionResultRowTest.cs (.../AdoptableFailureMechanismSectionResultRowTest.cs) (revision ed4f25fd91db395c473db1973fcce187fe436035)
@@ -21,15 +21,21 @@
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;
@@ -162,9 +168,9 @@
nameof(AdoptableFailureMechanismSectionResultRow.RefinedSectionProbability));
TestHelper.AssertTypeConverter(
nameof(AdoptableFailureMechanismSectionResultRow.SectionProbability));
-
+
IDictionary columnStateDefinitions = row.ColumnStateDefinitions;
- Assert.AreEqual(6 , columnStateDefinitions.Count);
+ Assert.AreEqual(6, columnStateDefinitions.Count);
DataGridViewControlColumnStateDefinitionTestHelper.AssertColumnStateDefinition(columnStateDefinitions, ConstructionProperties.InitialFailureMechanismResultIndex);
DataGridViewControlColumnStateDefinitionTestHelper.AssertColumnStateDefinition(columnStateDefinitions, ConstructionProperties.InitialFailureMechanismResultSectionProbabilityIndex);
@@ -177,6 +183,104 @@
mocks.VerifyAll();
}
+ [Test]
+ [TestCase(InitialFailureMechanismResultType.Manual)]
+ [TestCase(InitialFailureMechanismResultType.NoFailureProbability)]
+ public void GivenRowWithInitialFailureMechanismResultAdopt_WhenValueChanged_ThenInitialProbabilitiesChanged(InitialFailureMechanismResultType newValue)
+ {
+ // Given
+ var mocks = new MockRepository();
+ var errorProvider = mocks.Stub();
+ mocks.ReplayAll();
+
+ FailureMechanismSection section = FailureMechanismSectionTestFactory.CreateFailureMechanismSection();
+ var result = new AdoptableFailureMechanismSectionResult(section);
+
+ double sectionProbability = new Random(21).NextDouble();
+
+ using (new AssemblyToolCalculatorFactoryConfig())
+ {
+ var row = new AdoptableFailureMechanismSectionResultRow(result, () => sectionProbability, errorProvider,
+ new AssessmentSectionStub(), ConstructionProperties);
+
+ // Precondition
+ Assert.AreEqual(sectionProbability, row.InitialFailureMechanismResultSectionProbability);
+
+ // When
+ row.InitialFailureMechanismResult = newValue;
+
+ // Then
+ Assert.AreEqual(result.ManualInitialFailureMechanismResultSectionProbability, row.InitialFailureMechanismResultSectionProbability);
+ }
+
+ mocks.VerifyAll();
+ }
+
+ [Test]
+ public void GivenRowWithIsRelevantTrueAndInitialFailureMechanismResultAdopt_WhenErrorProviderReturnsError_ThenShowError()
+ {
+ // Given
+ const string errorText = "error";
+ var mocks = new MockRepository();
+ var errorProvider = mocks.StrictMock();
+ errorProvider.Expect(ep => ep.GetProbabilityValidationError(null))
+ .IgnoreArguments()
+ .Return(errorText);
+ mocks.ReplayAll();
+
+ FailureMechanismSection section = FailureMechanismSectionTestFactory.CreateFailureMechanismSection();
+ var result = new AdoptableFailureMechanismSectionResult(section);
+
+ using (new AssemblyToolCalculatorFactoryConfig())
+ {
+ // When
+ var row = new AdoptableFailureMechanismSectionResultRow(result, () => double.NaN, errorProvider,
+ new AssessmentSectionStub(), ConstructionProperties);
+
+ // Then
+ IDictionary columnStateDefinitions = row.ColumnStateDefinitions;
+ Assert.AreEqual(errorText, columnStateDefinitions[ConstructionProperties.InitialFailureMechanismResultSectionProbabilityIndex].ErrorText);
+ }
+
+ mocks.VerifyAll();
+ }
+
+ [Test]
+ [TestCase(false, InitialFailureMechanismResultType.Adopt)]
+ [TestCase(true, InitialFailureMechanismResultType.Manual)]
+ [TestCase(true, InitialFailureMechanismResultType.NoFailureProbability)]
+ public void GivenRowWithIsRelevantAndInitialFailureMechanismResult_WhenErrorProviderReturnsError_ThenShowNoError(
+ bool isRelevant, InitialFailureMechanismResultType initialFailureMechanismResultType)
+ {
+ // Given
+ var mocks = new MockRepository();
+ var errorProvider = mocks.StrictMock();
+ errorProvider.Stub(ep => ep.GetProbabilityValidationError(null))
+ .IgnoreArguments()
+ .Return("error message");
+ mocks.ReplayAll();
+
+ FailureMechanismSection section = FailureMechanismSectionTestFactory.CreateFailureMechanismSection();
+ var result = new AdoptableFailureMechanismSectionResult(section)
+ {
+ IsRelevant = isRelevant,
+ InitialFailureMechanismResult = initialFailureMechanismResultType
+ };
+
+ using (new AssemblyToolCalculatorFactoryConfig())
+ {
+ // When
+ var row = new AdoptableFailureMechanismSectionResultRow(result, () => double.NaN, errorProvider,
+ new AssessmentSectionStub(), ConstructionProperties);
+
+ // Then
+ IDictionary columnStateDefinitions = row.ColumnStateDefinitions;
+ Assert.AreEqual(string.Empty, columnStateDefinitions[ConstructionProperties.InitialFailureMechanismResultSectionProbabilityIndex].ErrorText);
+ }
+
+ mocks.VerifyAll();
+ }
+
#region Registration
[Test]
@@ -304,5 +408,343 @@
}
#endregion
+
+ #region Assembly
+
+ [Test]
+ public void Constructor_AssemblyRan_ReturnCategoryGroups()
+ {
+ // Setup
+ var mocks = new MockRepository();
+ var errorProvider = mocks.Stub();
+ mocks.ReplayAll();
+
+ var random = new Random(39);
+
+ FailureMechanismSection section = FailureMechanismSectionTestFactory.CreateFailureMechanismSection();
+ var result = new AdoptableFailureMechanismSectionResult(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 AdoptableFailureMechanismSectionResultRow(result, () => double.NaN, errorProvider,
+ 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);
+ }
+
+ mocks.VerifyAll();
+ }
+
+ [Test]
+ public void GivenRowWithoutAssemblyErrors_WhenUpdatingAndAssemblyThrowsException_ThenAssemblyPropertiesSetToDefault()
+ {
+ // Given
+ var mocks = new MockRepository();
+ var errorProvider = mocks.Stub();
+ mocks.ReplayAll();
+
+ var random = new Random(39);
+
+ FailureMechanismSection section = FailureMechanismSectionTestFactory.CreateFailureMechanismSection();
+ var result = new AdoptableFailureMechanismSectionResult(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 AdoptableFailureMechanismSectionResultRow(result, () => double.NaN, errorProvider,
+ new AssessmentSectionStub(), ConstructionProperties);
+
+ // Precondition
+ FailureMechanismSectionAssemblyResult calculatorOutput = calculator.FailureMechanismSectionAssemblyResultOutput;
+ AssertFailureMechanismSectionAssemblyResult(calculatorOutput, row.AssemblyResult);
+
+ // When
+ calculator.ThrowExceptionOnCalculate = true;
+ row.InitialFailureMechanismResult = InitialFailureMechanismResultType.Manual;
+
+ // Then
+ AssertFailureMechanismSectionAssemblyResult(new DefaultFailureMechanismSectionAssemblyResult(), row.AssemblyResult);
+ }
+
+ mocks.VerifyAll();
+ }
+
+ [Test]
+ public void GivenRowWithoutAssemblyErrors_WhenUpdatingAndAssemblyThrowsException_ThenShowError()
+ {
+ // Given
+ var mocks = new MockRepository();
+ var errorProvider = mocks.Stub();
+ mocks.ReplayAll();
+
+ FailureMechanismSection section = FailureMechanismSectionTestFactory.CreateFailureMechanismSection();
+ var result = new AdoptableFailureMechanismSectionResult(section);
+
+ using (new AssemblyToolCalculatorFactoryConfig())
+ {
+ var calculatorFactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance;
+ FailureMechanismSectionAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator;
+
+ var row = new AdoptableFailureMechanismSectionResultRow(result, () => double.NaN, errorProvider,
+ 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 = InitialFailureMechanismResultType.Manual;
+
+ // Then
+ const string expectedErrorText = "Message";
+
+ Assert.AreEqual(expectedErrorText, columnStateDefinitions[ConstructionProperties.SectionProbabilityIndex].ErrorText);
+ Assert.AreEqual(expectedErrorText, columnStateDefinitions[ConstructionProperties.AssemblyGroupIndex].ErrorText);
+ }
+
+ mocks.VerifyAll();
+ }
+
+ [Test]
+ public void GivenRowWithAssemblyErrors_WhenUpdatingAndAssemblyDoesNotThrowException_ThenNoErrorShown()
+ {
+ // Given
+ var mocks = new MockRepository();
+ var errorProvider = mocks.Stub();
+ mocks.ReplayAll();
+
+ FailureMechanismSection section = FailureMechanismSectionTestFactory.CreateFailureMechanismSection();
+ var result = new AdoptableFailureMechanismSectionResult(section);
+
+ using (new AssemblyToolCalculatorFactoryConfig())
+ {
+ var calculatorFactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance;
+ FailureMechanismSectionAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator;
+ calculator.ThrowExceptionOnCalculate = true;
+
+ var row = new AdoptableFailureMechanismSectionResultRow(result, () => double.NaN, errorProvider,
+ 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 = InitialFailureMechanismResultType.Manual;
+
+ // Then
+ Assert.AreEqual(string.Empty, columnStateDefinitions[ConstructionProperties.SectionProbabilityIndex].ErrorText);
+ Assert.AreEqual(string.Empty, columnStateDefinitions[ConstructionProperties.AssemblyGroupIndex].ErrorText);
+ }
+
+ mocks.VerifyAll();
+ }
+
+ 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
+ var mocks = new MockRepository();
+ var errorProvider = mocks.Stub();
+ mocks.ReplayAll();
+
+ FailureMechanismSection section = FailureMechanismSectionTestFactory.CreateFailureMechanismSection();
+ var result = new AdoptableFailureMechanismSectionResult(section);
+
+ using (new AssemblyToolCalculatorFactoryConfig())
+ {
+ // Call
+ var row = new AdoptableFailureMechanismSectionResultRow(result, () => double.NaN, errorProvider,
+ new AssessmentSectionStub(), ConstructionProperties);
+
+ // Assert
+ IDictionary columnStateDefinitions = row.ColumnStateDefinitions;
+
+ DataGridViewControlColumnStateDefinitionTestHelper.AssertColumnState(
+ columnStateDefinitions[ConstructionProperties.SectionProbabilityIndex], true, true);
+ }
+
+ mocks.VerifyAll();
+ }
+
+ [Test]
+ [TestCase(true)]
+ [TestCase(false)]
+ public void Constructor_WithIsRelevant_ExpectedColumnStates(bool isRelevant)
+ {
+ // Setup
+ var mocks = new MockRepository();
+ var errorProvider = mocks.Stub();
+ mocks.ReplayAll();
+
+ FailureMechanismSection section = FailureMechanismSectionTestFactory.CreateFailureMechanismSection();
+ var result = new AdoptableFailureMechanismSectionResult(section)
+ {
+ IsRelevant = isRelevant,
+ FurtherAnalysisNeeded = true,
+ InitialFailureMechanismResult = InitialFailureMechanismResultType.Manual
+ };
+
+ using (new AssemblyToolCalculatorFactoryConfig())
+ {
+ // Call
+ var row = new AdoptableFailureMechanismSectionResultRow(result, () => double.NaN, errorProvider,
+ 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);
+ }
+
+ mocks.VerifyAll();
+ }
+
+ [Test]
+ [TestCase(InitialFailureMechanismResultType.Adopt, true, true)]
+ [TestCase(InitialFailureMechanismResultType.Manual, true, false)]
+ [TestCase(InitialFailureMechanismResultType.NoFailureProbability, false, true)]
+ public void Constructor_WithInitialFailureMechanismResult_ExpectedColumnStates(InitialFailureMechanismResultType initialFailureMechanismResultType,
+ bool isEnabled, bool isReadOnly)
+ {
+ // Setup
+ var mocks = new MockRepository();
+ var errorProvider = mocks.Stub();
+ errorProvider.Stub(ep => ep.GetProbabilityValidationError(null))
+ .IgnoreArguments()
+ .Return(string.Empty);
+ mocks.ReplayAll();
+
+ FailureMechanismSection section = FailureMechanismSectionTestFactory.CreateFailureMechanismSection();
+ var result = new AdoptableFailureMechanismSectionResult(section)
+ {
+ InitialFailureMechanismResult = initialFailureMechanismResultType
+ };
+
+ using (new AssemblyToolCalculatorFactoryConfig())
+ {
+ // Call
+ var row = new AdoptableFailureMechanismSectionResultRow(result, () => double.NaN, errorProvider,
+ new AssessmentSectionStub(), ConstructionProperties);
+
+ // Assert
+ IDictionary columnStateDefinitions = row.ColumnStateDefinitions;
+
+ DataGridViewControlColumnStateDefinitionTestHelper.AssertColumnState(
+ columnStateDefinitions[ConstructionProperties.InitialFailureMechanismResultSectionProbabilityIndex], isEnabled, isReadOnly);
+ }
+
+ mocks.VerifyAll();
+ }
+
+ [Test]
+ [TestCase(true)]
+ [TestCase(false)]
+ public void Constructor_WithFurtherAnalysisNeeded_ExpectedColumnStates(bool furtherAnalysisNeeded)
+ {
+ // Setup
+ var mocks = new MockRepository();
+ var errorProvider = mocks.Stub();
+ mocks.ReplayAll();
+
+ FailureMechanismSection section = FailureMechanismSectionTestFactory.CreateFailureMechanismSection();
+ var result = new AdoptableFailureMechanismSectionResult(section)
+ {
+ FurtherAnalysisNeeded = furtherAnalysisNeeded
+ };
+
+ using (new AssemblyToolCalculatorFactoryConfig())
+ {
+ // Call
+ var row = new AdoptableFailureMechanismSectionResultRow(result, () => double.NaN, errorProvider,
+ new AssessmentSectionStub(), ConstructionProperties);
+
+ // Assert
+ IDictionary columnStateDefinitions = row.ColumnStateDefinitions;
+
+ DataGridViewControlColumnStateDefinitionTestHelper.AssertColumnState(
+ columnStateDefinitions[ConstructionProperties.RefinedSectionProbabilityIndex], furtherAnalysisNeeded);
+ }
+
+ mocks.VerifyAll();
+ }
+
+ [Test]
+ [TestCaseSource(typeof(AssemblyGroupColorTestHelper), nameof(AssemblyGroupColorTestHelper.FailureMechanismSectionAssemblyGroupColorCases))]
+ public void Constructor_WithAssemblyGroupsSet_ExpectedColumnStates(FailureMechanismSectionAssemblyGroup assemblyGroup,
+ Color expectedBackgroundColor)
+ {
+ // Setup
+ var mocks = new MockRepository();
+ var errorProvider = mocks.Stub();
+ mocks.ReplayAll();
+
+ FailureMechanismSection section = FailureMechanismSectionTestFactory.CreateFailureMechanismSection();
+ var result = new AdoptableFailureMechanismSectionResult(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 AdoptableFailureMechanismSectionResultRow(result, () => double.NaN, errorProvider,
+ new AssessmentSectionStub(), ConstructionProperties);
+
+ // Assert
+ IDictionary columnStateDefinitions = row.ColumnStateDefinitions;
+
+ DataGridViewControlColumnStateDefinitionTestHelper.AssertColumnWithColorState(
+ columnStateDefinitions[ConstructionProperties.AssemblyGroupIndex], expectedBackgroundColor);
+ }
+
+ mocks.VerifyAll();
+ }
+
+ #endregion
}
}
\ No newline at end of file