private static void Property_SetNewValue_NotifyObserversAndPropertyChanged <T>(
Action <NonAdoptableFailureMechanismSectionResultRow> setPropertyAction,
Func <NonAdoptableFailureMechanismSectionResult, T> assertPropertyFunc,
T newValue)
{
// Setup
var mocks = new MockRepository();
var errorProvider = mocks.Stub <IFailureMechanismSectionResultRowErrorProvider>();
var observer = mocks.StrictMock <IObserver>();
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, errorProvider, new AssessmentSectionStub(), ConstructionProperties);
// Call
setPropertyAction(row);
// Assert
Assert.AreEqual(newValue, assertPropertyFunc(result));
}
mocks.VerifyAll();
}
public void GivenRowWithIsRelevantTrueAndInitialFailureMechanismResultTypeManual_WhenErrorProviderReturnsError_ThenShowError()
{
// Given
var random = new Random(21);
double sectionProbability = random.NextDouble();
const string errorText = "error";
var mocks = new MockRepository();
var errorProvider = mocks.StrictMock <IFailureMechanismSectionResultRowErrorProvider>();
errorProvider.Expect(ep => ep.GetManualProbabilityValidationError(sectionProbability))
.Return(errorText);
mocks.ReplayAll();
FailureMechanismSection section = FailureMechanismSectionTestFactory.CreateFailureMechanismSection();
var result = new NonAdoptableFailureMechanismSectionResult(section)
{
InitialFailureMechanismResultType = NonAdoptableInitialFailureMechanismResultType.Manual,
ManualInitialFailureMechanismResultSectionProbability = sectionProbability
};
using (new AssemblyToolCalculatorFactoryConfig())
{
// When
var row = new NonAdoptableFailureMechanismSectionResultRow(result, errorProvider, new AssessmentSectionStub(), ConstructionProperties);
// Then
IDictionary <int, DataGridViewColumnStateDefinition> columnStateDefinitions = row.ColumnStateDefinitions;
Assert.AreEqual(errorText, columnStateDefinitions[ConstructionProperties.InitialFailureMechanismResultSectionProbabilityIndex].ErrorText);
}
mocks.VerifyAll();
}
public void Constructor_AssemblyRan_InputCorrectlySetOnCalculator()
{
// Setup
var mocks = new MockRepository();
var errorProvider = mocks.Stub <IFailureMechanismSectionResultRowErrorProvider>();
mocks.ReplayAll();
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, errorProvider, assessmentSection, ConstructionProperties);
// Assert
FailureMechanismSectionAssemblyInput input = calculator.FailureMechanismSectionAssemblyInput;
Assert.AreEqual(assessmentSection.FailureMechanismContribution.SignalFloodingProbability, input.SignalFloodingProbability);
Assert.AreEqual(assessmentSection.FailureMechanismContribution.MaximumAllowableFloodingProbability, input.MaximumAllowableFloodingProbability);
Assert.AreEqual(row.IsRelevant, input.IsRelevant);
Assert.IsTrue(input.HasProbabilitySpecified);
Assert.AreEqual(row.InitialFailureMechanismResultSectionProbability, input.InitialSectionProbability);
Assert.AreEqual(row.FurtherAnalysisType, input.FurtherAnalysisType);
Assert.AreEqual(row.RefinedSectionProbability, input.RefinedSectionProbability);
}
mocks.VerifyAll();
}
private static void ProbabilityProperty_SetInvalidValue_ThrowsArgumentOutOfRangeException(
Action <NonAdoptableFailureMechanismSectionResultRow> setPropertyAction)
{
// Setup
var mocks = new MockRepository();
var errorProvider = mocks.Stub <IFailureMechanismSectionResultRowErrorProvider>();
mocks.ReplayAll();
FailureMechanismSection section = FailureMechanismSectionTestFactory.CreateFailureMechanismSection();
var result = new NonAdoptableFailureMechanismSectionResult(section);
using (new AssemblyToolCalculatorFactoryConfig())
{
var row = new NonAdoptableFailureMechanismSectionResultRow(result, errorProvider, 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 <ArgumentOutOfRangeException>(Call, expectedMessage);
}
mocks.VerifyAll();
}
public void GivenRowWithAssemblyErrors_WhenUpdatingAndAssemblyDoesNotThrowException_ThenNoErrorShown()
{
// Given
var mocks = new MockRepository();
var errorProvider = mocks.Stub <IFailureMechanismSectionResultRowErrorProvider>();
mocks.ReplayAll();
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, errorProvider, new AssessmentSectionStub(), ConstructionProperties);
// Precondition
IDictionary <int, DataGridViewColumnStateDefinition> 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.InitialFailureMechanismResultType = NonAdoptableInitialFailureMechanismResultType.NoFailureProbability;
// Then
Assert.AreEqual(string.Empty, columnStateDefinitions[ConstructionProperties.SectionProbabilityIndex].ErrorText);
Assert.AreEqual(string.Empty, columnStateDefinitions[ConstructionProperties.AssemblyGroupIndex].ErrorText);
}
}
public void Constructor_AssemblyRan_ReturnsAssemblyResult()
{
// Setup
var mocks = new MockRepository();
var errorProvider = mocks.Stub <IFailureMechanismSectionResultRowErrorProvider>();
mocks.ReplayAll();
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 FailureMechanismSectionAssemblyResultWrapper(
new FailureMechanismSectionAssemblyResult(random.NextDouble(), random.NextDouble(), random.NextDouble(),
random.NextEnumValue <FailureMechanismSectionAssemblyGroup>()),
random.NextEnumValue <AssemblyMethod>(), random.NextEnumValue <AssemblyMethod>());
// Call
var row = new NonAdoptableFailureMechanismSectionResultRow(result, errorProvider, new AssessmentSectionStub(), ConstructionProperties);
// Assert
FailureMechanismSectionAssemblyResult calculatorOutput = calculator.FailureMechanismSectionAssemblyResultOutput.AssemblyResult;
Assert.AreEqual(calculatorOutput.SectionProbability, row.SectionProbability);
Assert.AreEqual(EnumDisplayNameHelper.GetDisplayName(calculatorOutput.FailureMechanismSectionAssemblyGroup),
row.AssemblyGroup);
}
mocks.VerifyAll();
}
public void Constructor_WithFurtherAnalysisType_ExpectedColumnStates(FailureMechanismSectionResultFurtherAnalysisType furtherAnalysisType,
bool expectedDisabled)
{
// Setup
var mocks = new MockRepository();
var errorProvider = mocks.Stub <IFailureMechanismSectionResultRowErrorProvider>();
errorProvider.Stub(ep => ep.GetManualProbabilityValidationError(double.NaN))
.IgnoreArguments()
.Return(string.Empty);
mocks.ReplayAll();
FailureMechanismSection section = FailureMechanismSectionTestFactory.CreateFailureMechanismSection();
var result = new NonAdoptableFailureMechanismSectionResult(section)
{
FurtherAnalysisType = furtherAnalysisType
};
using (new AssemblyToolCalculatorFactoryConfig())
{
// Call
var row = new NonAdoptableFailureMechanismSectionResultRow(result, errorProvider, new AssessmentSectionStub(), ConstructionProperties);
// Assert
IDictionary <int, DataGridViewColumnStateDefinition> columnStateDefinitions = row.ColumnStateDefinitions;
DataGridViewControlColumnStateDefinitionTestHelper.AssertColumnState(
columnStateDefinitions[ConstructionProperties.RefinedSectionProbabilityIndex], expectedDisabled);
}
mocks.VerifyAll();
}
public void Constructor_Always_ExpectedColumnStates()
{
// Setup
var mocks = new MockRepository();
var errorProvider = mocks.Stub <IFailureMechanismSectionResultRowErrorProvider>();
mocks.ReplayAll();
FailureMechanismSection section = FailureMechanismSectionTestFactory.CreateFailureMechanismSection();
var result = new NonAdoptableFailureMechanismSectionResult(section);
using (new AssemblyToolCalculatorFactoryConfig())
{
// Call
var row = new NonAdoptableFailureMechanismSectionResultRow(result, errorProvider, new AssessmentSectionStub(), ConstructionProperties);
// Assert
IDictionary <int, DataGridViewColumnStateDefinition> columnStateDefinitions = row.ColumnStateDefinitions;
DataGridViewControlColumnStateDefinitionTestHelper.AssertColumnState(
columnStateDefinitions[ConstructionProperties.SectionProbabilityIndex], true, true);
}
mocks.VerifyAll();
}
public void ReadNonAdoptableFailureMechanismSectionResultEntity_ParameterValues_SectionResultWithParameterValues()
{
// Setup
var random = new Random(21);
bool isRelevant = random.NextBoolean();
var initialFailureMechanismResultType = random.NextEnumValue <NonAdoptableInitialFailureMechanismResultType>();
double manualSectionProbability = random.NextDouble();
var furtherAnalysisType = random.NextEnumValue <FailureMechanismSectionResultFurtherAnalysisType>();
double refinedSectionProbability = random.NextDouble();
var entity = new NonAdoptableFailureMechanismSectionResultEntity
{
IsRelevant = Convert.ToByte(isRelevant),
InitialFailureMechanismResultType = Convert.ToByte(initialFailureMechanismResultType),
ManualInitialFailureMechanismResultSectionProbability = manualSectionProbability,
FurtherAnalysisType = Convert.ToByte(furtherAnalysisType),
RefinedSectionProbability = refinedSectionProbability
};
var sectionResult = new NonAdoptableFailureMechanismSectionResult(FailureMechanismSectionTestFactory.CreateFailureMechanismSection());
// Call
entity.Read(sectionResult);
// Assert
Assert.AreEqual(isRelevant, sectionResult.IsRelevant);
Assert.AreEqual(initialFailureMechanismResultType, sectionResult.InitialFailureMechanismResultType);
Assert.AreEqual(manualSectionProbability, sectionResult.ManualInitialFailureMechanismResultSectionProbability);
Assert.AreEqual(furtherAnalysisType, sectionResult.FurtherAnalysisType);
Assert.AreEqual(refinedSectionProbability, sectionResult.RefinedSectionProbability);
}
public void Constructor_WithAssemblyGroupSet_ExpectedColumnStates(FailureMechanismSectionAssemblyGroup assemblyGroup,
Color expectedBackgroundColor)
{
// Setup
var random = new Random(21);
var mocks = new MockRepository();
var errorProvider = mocks.Stub <IFailureMechanismSectionResultRowErrorProvider>();
mocks.ReplayAll();
FailureMechanismSection section = FailureMechanismSectionTestFactory.CreateFailureMechanismSection();
var result = new NonAdoptableFailureMechanismSectionResult(section);
using (new AssemblyToolCalculatorFactoryConfig())
{
var calculatorFactory = (TestAssemblyToolCalculatorFactory)AssemblyToolCalculatorFactory.Instance;
FailureMechanismSectionAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator;
calculator.FailureMechanismSectionAssemblyResultOutput = new FailureMechanismSectionAssemblyResultWrapper(
new FailureMechanismSectionAssemblyResult(double.NaN, double.NaN, double.NaN, assemblyGroup),
random.NextEnumValue <AssemblyMethod>(), random.NextEnumValue <AssemblyMethod>());
// Call
var row = new NonAdoptableFailureMechanismSectionResultRow(result, errorProvider, new AssessmentSectionStub(), ConstructionProperties);
// Assert
IDictionary <int, DataGridViewColumnStateDefinition> columnStateDefinitions = row.ColumnStateDefinitions;
DataGridViewControlColumnStateDefinitionTestHelper.AssertColumnWithColorState(
columnStateDefinitions[ConstructionProperties.AssemblyGroupIndex], expectedBackgroundColor);
}
mocks.VerifyAll();
}
public void CreateNonAdoptableFailureMechanismSectionResult_SectionResultWithValues_ReturnsEntityWithExpectedValues()
{
// Setup
var random = new Random(21);
bool isRelevant = random.NextBoolean();
var initialFailureMechanismResultType = random.NextEnumValue <NonAdoptableInitialFailureMechanismResultType>();
double manualSectionProbability = random.NextDouble();
var furtherAnalysisType = random.NextEnumValue <FailureMechanismSectionResultFurtherAnalysisType>();
double refinedSectionProbability = random.NextDouble();
var sectionResult = new NonAdoptableFailureMechanismSectionResult(FailureMechanismSectionTestFactory.CreateFailureMechanismSection())
{
IsRelevant = isRelevant,
InitialFailureMechanismResultType = initialFailureMechanismResultType,
ManualInitialFailureMechanismResultSectionProbability = manualSectionProbability,
FurtherAnalysisType = furtherAnalysisType,
RefinedSectionProbability = refinedSectionProbability
};
// Call
NonAdoptableFailureMechanismSectionResultEntity entity = sectionResult.Create();
// Assert
Assert.AreEqual(Convert.ToByte(isRelevant), entity.IsRelevant);
Assert.AreEqual(Convert.ToByte(initialFailureMechanismResultType), entity.InitialFailureMechanismResultType);
Assert.AreEqual(manualSectionProbability, entity.ManualInitialFailureMechanismResultSectionProbability);
Assert.AreEqual(Convert.ToByte(furtherAnalysisType), entity.FurtherAnalysisType);
Assert.AreEqual(refinedSectionProbability, entity.RefinedSectionProbability);
}
public void GivenRowWithIsRelevantAndInitialFailureMechanismResultType_WhenErrorProviderReturnsError_ThenShowNoError(
bool isRelevant, NonAdoptableInitialFailureMechanismResultType initialFailureMechanismResultType)
{
// Given
var mocks = new MockRepository();
var errorProvider = mocks.StrictMock <IFailureMechanismSectionResultRowErrorProvider>();
errorProvider.Stub(ep => ep.GetManualProbabilityValidationError(double.NaN))
.IgnoreArguments()
.Return("error message");
mocks.ReplayAll();
FailureMechanismSection section = FailureMechanismSectionTestFactory.CreateFailureMechanismSection();
var result = new NonAdoptableFailureMechanismSectionResult(section)
{
IsRelevant = isRelevant,
InitialFailureMechanismResultType = initialFailureMechanismResultType
};
using (new AssemblyToolCalculatorFactoryConfig())
{
// When
var row = new NonAdoptableFailureMechanismSectionResultRow(result, errorProvider, new AssessmentSectionStub(), ConstructionProperties);
// Then
IDictionary <int, DataGridViewColumnStateDefinition> columnStateDefinitions = row.ColumnStateDefinitions;
Assert.IsEmpty(columnStateDefinitions[ConstructionProperties.InitialFailureMechanismResultSectionProbabilityIndex].ErrorText);
}
mocks.VerifyAll();
}
public void GivenRowWithFurtherAnalysisTypeNotExecuted_WhenErrorProviderReturnsError_ThenShowsNoError(FailureMechanismSectionResultFurtherAnalysisType furtherAnalysisType)
{
// Given
var random = new Random(21);
double sectionProbability = random.NextDouble();
var mocks = new MockRepository();
var errorProvider = mocks.StrictMock <IFailureMechanismSectionResultRowErrorProvider>();
errorProvider.Stub(ep => ep.GetManualProbabilityValidationError(double.NaN))
.IgnoreArguments()
.Return("error");
mocks.ReplayAll();
FailureMechanismSection section = FailureMechanismSectionTestFactory.CreateFailureMechanismSection();
var result = new NonAdoptableFailureMechanismSectionResult(section)
{
InitialFailureMechanismResultType = NonAdoptableInitialFailureMechanismResultType.NoFailureProbability,
FurtherAnalysisType = furtherAnalysisType,
RefinedSectionProbability = sectionProbability
};
using (new AssemblyToolCalculatorFactoryConfig())
{
// When
var row = new NonAdoptableFailureMechanismSectionResultRow(result, errorProvider, new AssessmentSectionStub(), ConstructionProperties);
// Then
IDictionary <int, DataGridViewColumnStateDefinition> columnStateDefinitions = row.ColumnStateDefinitions;
Assert.IsEmpty(columnStateDefinitions[ConstructionProperties.RefinedSectionProbabilityIndex].ErrorText);
}
mocks.VerifyAll();
}
/// <summary>
/// Asserts whether the data of the <see cref="NonAdoptableFailureMechanismSectionResultEntity"/> and
/// <see cref="NonAdoptableFailureMechanismSectionResult"/> have equal values.
/// </summary>
/// <param name="sectionResultEntity">The <see cref="NonAdoptableFailureMechanismSectionResultEntity"/>.</param>
/// <param name="sectionResult">The <see cref="NonAdoptableFailureMechanismSectionResult"/>.</param>
public static void AssertSectionResult(NonAdoptableFailureMechanismSectionResultEntity sectionResultEntity,
NonAdoptableFailureMechanismSectionResult sectionResult)
{
Assert.AreEqual(Convert.ToBoolean(sectionResultEntity.IsRelevant), sectionResult.IsRelevant);
Assert.AreEqual((NonAdoptableInitialFailureMechanismResultType)sectionResultEntity.InitialFailureMechanismResultType, sectionResult.InitialFailureMechanismResultType);
Assert.AreEqual(sectionResultEntity.ManualInitialFailureMechanismResultSectionProbability.ToNullAsNaN(), sectionResult.ManualInitialFailureMechanismResultSectionProbability);
Assert.AreEqual((FailureMechanismSectionResultFurtherAnalysisType)sectionResultEntity.FurtherAnalysisType, sectionResult.FurtherAnalysisType);
Assert.AreEqual(sectionResultEntity.RefinedSectionProbability.ToNullAsNaN(), sectionResult.RefinedSectionProbability);
}
public void Constructor_ExpectedValues()
{
// Setup
FailureMechanismSection section = FailureMechanismSectionTestFactory.CreateFailureMechanismSection();
// Call
var sectionResult = new NonAdoptableFailureMechanismSectionResult(section);
// Assert
Assert.IsInstanceOf <FailureMechanismSectionResult>(sectionResult);
Assert.AreEqual(NonAdoptableInitialFailureMechanismResultType.Manual, sectionResult.InitialFailureMechanismResultType);
}
public void ReadNonAdoptableFailureMechanismSectionResultEntity_EntityNull_ThrowsArgumentNullException()
{
// Setup
var sectionResult = new NonAdoptableFailureMechanismSectionResult(FailureMechanismSectionTestFactory.CreateFailureMechanismSection());
// Call
void Call() => ((NonAdoptableFailureMechanismSectionResultEntity)null).Read(sectionResult);
// Assert
var exception = Assert.Throws <ArgumentNullException>(Call);
Assert.AreEqual("entity", exception.ParamName);
}
public void ReadNonAdoptableFailureMechanismSectionResultEntity_EntityWithNullValues_SectionResultWithNaNValues()
{
// Setup
var entity = new NonAdoptableFailureMechanismSectionResultEntity();
var sectionResult = new NonAdoptableFailureMechanismSectionResult(FailureMechanismSectionTestFactory.CreateFailureMechanismSection());
// Call
entity.Read(sectionResult);
// Assert
Assert.IsNaN(sectionResult.ManualInitialFailureMechanismResultSectionProbability);
Assert.IsNaN(sectionResult.RefinedSectionProbability);
}
/// <summary>
/// Creates an instance of <see cref="NonAdoptableFailureMechanismSectionResultEntity"/>
/// based on the information of the <see cref="NonAdoptableFailureMechanismSectionResult"/>.
/// </summary>
/// <param name="result">The result to create a database entity for.</param>
/// <returns>A <see cref="NonAdoptableFailureMechanismSectionResultEntity"/>.</returns>
/// <exception cref="ArgumentNullException">Thrown when <paramref name="result"/> is <c>null</c>.</exception>
internal static NonAdoptableFailureMechanismSectionResultEntity Create(this NonAdoptableFailureMechanismSectionResult result)
{
if (result == null)
{
throw new ArgumentNullException(nameof(result));
}
var sectionResultEntity = new NonAdoptableFailureMechanismSectionResultEntity
{
InitialFailureMechanismResultType = Convert.ToByte(result.InitialFailureMechanismResultType)
};
sectionResultEntity.SetCommonFailureMechanismSectionResultProperties(result);
return(sectionResultEntity);
}
public void CreateNonAdoptableFailureMechanismSectionResult_SectionResultWithNaNValues_ReturnsEntityWithExpectedResults()
{
// Setup
var sectionResult = new NonAdoptableFailureMechanismSectionResult(FailureMechanismSectionTestFactory.CreateFailureMechanismSection())
{
ManualInitialFailureMechanismResultSectionProbability = double.NaN,
RefinedSectionProbability = double.NaN
};
// Call
NonAdoptableFailureMechanismSectionResultEntity entity = sectionResult.Create();
// Assert
Assert.IsNull(entity.ManualInitialFailureMechanismResultSectionProbability);
Assert.IsNull(entity.RefinedSectionProbability);
}
/// <summary>
/// Reads the <see cref="NonAdoptableFailureMechanismSectionResultEntity"/> and use the information
/// to update a <see cref="NonAdoptableFailureMechanismSectionResult"/>.
/// </summary>
/// <param name="entity">The <see cref="NonAdoptableFailureMechanismSectionResultEntity"/> used to update
/// the <paramref name="sectionResult"/>.</param>
/// <param name="sectionResult">The target of the read operation.</param>
/// <exception cref="ArgumentNullException">Thrown when any input parameter is <c>null</c>.</exception>
internal static void Read(this NonAdoptableFailureMechanismSectionResultEntity entity,
NonAdoptableFailureMechanismSectionResult sectionResult)
{
if (entity == null)
{
throw new ArgumentNullException(nameof(entity));
}
if (sectionResult == null)
{
throw new ArgumentNullException(nameof(sectionResult));
}
sectionResult.InitialFailureMechanismResultType = (NonAdoptableInitialFailureMechanismResultType)entity.InitialFailureMechanismResultType;
sectionResult.SetCommonFailureMechanismSectionResultProperties(entity);
}
public void Constructor_ExpectedValues()
{
// Setup
var mocks = new MockRepository();
var errorProvider = mocks.Stub <IFailureMechanismSectionResultRowErrorProvider>();
mocks.ReplayAll();
FailureMechanismSection section = FailureMechanismSectionTestFactory.CreateFailureMechanismSection();
var result = new NonAdoptableFailureMechanismSectionResult(section);
using (new AssemblyToolCalculatorFactoryConfig())
{
// Call
var row = new NonAdoptableFailureMechanismSectionResultRow(result, errorProvider, new AssessmentSectionStub(), ConstructionProperties);
// Assert
Assert.IsInstanceOf <FailureMechanismSectionResultRow <NonAdoptableFailureMechanismSectionResult> >(row);
Assert.AreEqual(result.IsRelevant, row.IsRelevant);
Assert.AreEqual(result.InitialFailureMechanismResultType, row.InitialFailureMechanismResultType);
Assert.AreEqual(result.ManualInitialFailureMechanismResultSectionProbability, row.InitialFailureMechanismResultSectionProbability);
Assert.AreEqual(result.FurtherAnalysisType, row.FurtherAnalysisType);
Assert.AreEqual(result.RefinedSectionProbability, row.RefinedSectionProbability);
TestHelper.AssertTypeConverter <NonAdoptableFailureMechanismSectionResultRow, NoProbabilityValueDoubleConverter>(
nameof(NonAdoptableFailureMechanismSectionResultRow.InitialFailureMechanismResultSectionProbability));
TestHelper.AssertTypeConverter <NonAdoptableFailureMechanismSectionResultRow, NoProbabilityValueDoubleConverter>(
nameof(NonAdoptableFailureMechanismSectionResultRow.RefinedSectionProbability));
TestHelper.AssertTypeConverter <NonAdoptableFailureMechanismSectionResultRow, NoProbabilityValueDoubleConverter>(
nameof(NonAdoptableFailureMechanismSectionResultRow.SectionProbability));
IDictionary <int, DataGridViewColumnStateDefinition> columnStateDefinitions = row.ColumnStateDefinitions;
Assert.AreEqual(6, columnStateDefinitions.Count);
DataGridViewControlColumnStateDefinitionTestHelper.AssertColumnStateDefinition(columnStateDefinitions, ConstructionProperties.InitialFailureMechanismResultTypeIndex);
DataGridViewControlColumnStateDefinitionTestHelper.AssertColumnStateDefinition(columnStateDefinitions, ConstructionProperties.InitialFailureMechanismResultSectionProbabilityIndex);
DataGridViewControlColumnStateDefinitionTestHelper.AssertColumnStateDefinition(columnStateDefinitions, ConstructionProperties.FurtherAnalysisTypeIndex);
DataGridViewControlColumnStateDefinitionTestHelper.AssertColumnStateDefinition(columnStateDefinitions, ConstructionProperties.RefinedSectionProbabilityIndex);
DataGridViewControlColumnStateDefinitionTestHelper.AssertColumnStateDefinition(columnStateDefinitions, ConstructionProperties.SectionProbabilityIndex);
DataGridViewControlColumnStateDefinitionTestHelper.AssertColumnStateDefinition(columnStateDefinitions, ConstructionProperties.AssemblyGroupIndex);
}
mocks.VerifyAll();
}
public void AssembleSectionNonAdoptableWithoutProfileProbability_WithInputAndUseLengthEffectFalse_SetsInputOnCalculator(
NonAdoptableInitialFailureMechanismResultType initialFailureMechanismResultType, bool expectedHasProbabilitySpecified)
{
// Setup
var random = new Random(21);
bool isRelevant = random.NextBoolean();
double manualInitialSectionProbability = random.NextDouble();
var furtherAnalysisType = random.NextEnumValue <FailureMechanismSectionResultFurtherAnalysisType>();
double refinedSectionProbability = random.NextDouble();
var assessmentSection = new AssessmentSectionStub();
var sectionResult = new NonAdoptableFailureMechanismSectionResult(FailureMechanismSectionTestFactory.CreateFailureMechanismSection())
{
IsRelevant = isRelevant,
InitialFailureMechanismResultType = initialFailureMechanismResultType,
ManualInitialFailureMechanismResultSectionProbability = manualInitialSectionProbability,
FurtherAnalysisType = furtherAnalysisType,
RefinedSectionProbability = refinedSectionProbability
};
using (new AssemblyToolCalculatorFactoryConfig())
{
var calculatorFactory = (TestAssemblyToolCalculatorFactory)AssemblyToolCalculatorFactory.Instance;
FailureMechanismSectionAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator;
// Call
FailureMechanismSectionAssemblyResultFactory.AssembleSection(sectionResult, assessmentSection);
// Assert
FailureMechanismSectionAssemblyInput calculatorInput = calculator.FailureMechanismSectionAssemblyInput;
FailureMechanismContribution failureMechanismContribution = assessmentSection.FailureMechanismContribution;
Assert.AreEqual(failureMechanismContribution.SignalFloodingProbability, calculatorInput.SignalFloodingProbability);
Assert.AreEqual(failureMechanismContribution.MaximumAllowableFloodingProbability, calculatorInput.MaximumAllowableFloodingProbability);
Assert.AreEqual(isRelevant, calculatorInput.IsRelevant);
Assert.AreEqual(expectedHasProbabilitySpecified, calculatorInput.HasProbabilitySpecified);
Assert.AreEqual(manualInitialSectionProbability, calculatorInput.InitialSectionProbability);
Assert.AreEqual(furtherAnalysisType, calculatorInput.FurtherAnalysisType);
Assert.AreEqual(refinedSectionProbability, calculatorInput.RefinedSectionProbability);
}
}
public void AssembleSectionNonAdoptableSectionWithoutProfileProbability_CalculatorRan_ReturnsExpectedOutput()
{
// Setup
var assessmentSection = new AssessmentSectionStub();
var sectionResult = new NonAdoptableFailureMechanismSectionResult(FailureMechanismSectionTestFactory.CreateFailureMechanismSection());
using (new AssemblyToolCalculatorFactoryConfig())
{
var calculatorFactory = (TestAssemblyToolCalculatorFactory)AssemblyToolCalculatorFactory.Instance;
FailureMechanismSectionAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator;
// Call
FailureMechanismSectionAssemblyResultWrapper result = FailureMechanismSectionAssemblyResultFactory.AssembleSection(
sectionResult, assessmentSection);
// Assert
Assert.AreSame(calculator.FailureMechanismSectionAssemblyResultOutput, result);
}
}
public void Constructor_AssessmentSectionNull_ThrowsArgumentNullException()
{
// Setup
var mocks = new MockRepository();
var errorProvider = mocks.Stub <IFailureMechanismSectionResultRowErrorProvider>();
mocks.ReplayAll();
FailureMechanismSection section = FailureMechanismSectionTestFactory.CreateFailureMechanismSection();
var result = new NonAdoptableFailureMechanismSectionResult(section);
// Call
void Call() => new NonAdoptableFailureMechanismSectionResultRow(result, errorProvider, null, ConstructionProperties);
// Assert
var exception = Assert.Throws <ArgumentNullException>(Call);
Assert.AreEqual("assessmentSection", exception.ParamName);
mocks.VerifyAll();
}
/// <summary>
/// Assembles a failure mechanism section result based on the input arguments.
/// </summary>
/// <param name="sectionResult">The section result to assemble for.</param>
/// <param name="assessmentSection">The <see cref="IAssessmentSection"/> to assemble with.</param>
/// <returns>A <see cref="FailureMechanismSectionAssemblyResultWrapper"/>.</returns>
/// <exception cref="ArgumentNullException">Thrown when any parameter is <c>null</c>.</exception>
/// <exception cref="AssemblyException">Thrown when the section could not be successfully assembled.</exception>
public static FailureMechanismSectionAssemblyResultWrapper AssembleSection(
NonAdoptableFailureMechanismSectionResult sectionResult, IAssessmentSection assessmentSection)
{
if (sectionResult == null)
{
throw new ArgumentNullException(nameof(sectionResult));
}
if (assessmentSection == null)
{
throw new ArgumentNullException(nameof(assessmentSection));
}
bool hasProbabilitySpecified = sectionResult.InitialFailureMechanismResultType != NonAdoptableInitialFailureMechanismResultType.NoFailureProbability;
FailureMechanismSectionAssemblyInput input = CreateInput(
assessmentSection, sectionResult.IsRelevant, sectionResult.ManualInitialFailureMechanismResultSectionProbability,
sectionResult.FurtherAnalysisType, sectionResult.RefinedSectionProbability, hasProbabilitySpecified);
return(PerformAssembly(input));
}
public void AssembleSectionNonAdoptableSectionWithoutProfileProbability_CalculatorThrowsException_ThrowsAssemblyException()
{
// Setup
var assessmentSection = new AssessmentSectionStub();
var sectionResult = new NonAdoptableFailureMechanismSectionResult(FailureMechanismSectionTestFactory.CreateFailureMechanismSection());
using (new AssemblyToolCalculatorFactoryConfig())
{
var calculatorFactory = (TestAssemblyToolCalculatorFactory)AssemblyToolCalculatorFactory.Instance;
FailureMechanismSectionAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator;
calculator.ThrowExceptionOnCalculate = true;
// Call
void Call() => FailureMechanismSectionAssemblyResultFactory.AssembleSection(
sectionResult, assessmentSection);
// Assert
var exception = Assert.Throws <AssemblyException>(Call);
Exception innerException = exception.InnerException;
Assert.IsInstanceOf <FailureMechanismSectionAssemblyCalculatorException>(innerException);
Assert.AreEqual(innerException.Message, exception.Message);
}
}
public void GivenRowWithoutAssemblyErrors_WhenUpdatingAndAssemblyThrowsException_ThenAssemblyPropertiesSetToDefault()
{
// Given
var mocks = new MockRepository();
var errorProvider = mocks.Stub <IFailureMechanismSectionResultRowErrorProvider>();
mocks.ReplayAll();
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, errorProvider, new AssessmentSectionStub(), ConstructionProperties);
// Precondition
FailureMechanismSectionAssemblyResult calculatorOutput = calculator.FailureMechanismSectionAssemblyResultOutput.AssemblyResult;
Assert.AreEqual(calculatorOutput.SectionProbability, row.SectionProbability);
Assert.AreEqual(EnumDisplayNameHelper.GetDisplayName(calculatorOutput.FailureMechanismSectionAssemblyGroup),
row.AssemblyGroup);
// When
calculator.ThrowExceptionOnCalculate = true;
row.InitialFailureMechanismResultType = NonAdoptableInitialFailureMechanismResultType.NoFailureProbability;
// Then
var expectedAssemblyResult = new DefaultFailureMechanismSectionAssemblyResult();
Assert.AreEqual(expectedAssemblyResult.SectionProbability, row.SectionProbability);
Assert.AreEqual(EnumDisplayNameHelper.GetDisplayName(expectedAssemblyResult.FailureMechanismSectionAssemblyGroup),
row.AssemblyGroup);
}
mocks.VerifyAll();
}
protected override NonAdoptableFailureMechanismSectionResultRow CreateFailureMechanismSectionResultRow(NonAdoptableFailureMechanismSectionResult sectionResult)
{
return(new NonAdoptableFailureMechanismSectionResultRow(
sectionResult,
CreateErrorProvider(),
AssessmentSection,
new NonAdoptableFailureMechanismSectionResultRow.ConstructionProperties
{
InitialFailureMechanismResultTypeIndex = initialFailureMechanismResultTypeIndex,
InitialFailureMechanismResultSectionProbabilityIndex = initialFailureMechanismResultSectionProbabilityIndex,
FurtherAnalysisTypeIndex = furtherAnalysisTypeIndex,
RefinedSectionProbabilityIndex = refinedSectionProbabilityIndex,
SectionProbabilityIndex = sectionProbabilityIndex,
AssemblyGroupIndex = assemblyGroupIndex
}));
}
