public void Constructor_AssemblyRan_ReturnsAssemblyResult()
{
// Setup
var mocks = new MockRepository();
var errorProvider = mocks.Stub <IFailureMechanismSectionResultRowWithCalculatedProbabilityErrorProvider>();
mocks.ReplayAll();
FailureMechanismSection section = FailureMechanismSectionTestFactory.CreateFailureMechanismSection();
var result = new AdoptableFailureMechanismSectionResult(section);
FailureMechanismSectionAssemblyResultWrapper assemblyResultWrapper = FailureMechanismSectionAssemblyResultWrapperTestFactory.Create();
Func <FailureMechanismSectionAssemblyResultWrapper> performAssemblyFunc = () => assemblyResultWrapper;
// Call
var row = new AdoptableFailureMechanismSectionResultRow(result, () => double.NaN, errorProvider,
performAssemblyFunc, ConstructionProperties);
// Assert
var assemblyResult = assemblyResultWrapper.AssemblyResult;
Assert.AreEqual(assemblyResult.SectionProbability, row.SectionProbability);
Assert.AreEqual(EnumDisplayNameHelper.GetDisplayName(assemblyResult.FailureMechanismSectionAssemblyGroup),
row.AssemblyGroup);
mocks.VerifyAll();
}
/// <summary>
/// Gets the value for the initial failure mechanism result per failure mechanism section as a probability.
/// </summary>
/// <param name="sectionResult">The section result to get the initial failure mechanism result probability for.</param>
/// <param name="calculationScenarios">All probabilistic calculation scenarios in the failure mechanism.</param>
/// <typeparam name="T">The type of the structure which can be assigned to the calculation.</typeparam>
/// <returns>The calculated initial failure mechanism result probability; or <see cref="double.NaN"/> when there
/// are no relevant calculations, when not all relevant calculations are performed or when the
/// contributions of the relevant calculations don't add up to 1.</returns>
/// <exception cref="ArgumentNullException">Thrown when any parameter is <c>null</c>.</exception>
public static double GetInitialFailureMechanismResultProbability <T>(this AdoptableFailureMechanismSectionResult sectionResult,
IEnumerable <StructuresCalculationScenario <T> > calculationScenarios)
where T : IStructuresCalculationInput <StructureBase>, new()
{
if (sectionResult == null)
{
throw new ArgumentNullException(nameof(sectionResult));
}
if (calculationScenarios == null)
{
throw new ArgumentNullException(nameof(calculationScenarios));
}
StructuresCalculationScenario <T>[] relevantScenarios = sectionResult.GetRelevantCalculationScenarios <StructuresCalculationScenario <T> >(
calculationScenarios,
(scenario, lineSegments) => scenario.IsStructureIntersectionWithReferenceLineInSection(lineSegments))
.ToArray();
if (!CalculationScenarioHelper.ScenariosAreValid(relevantScenarios))
{
return(double.NaN);
}
double totalInitialFailureMechanismResult = 0;
foreach (StructuresCalculationScenario <T> scenario in relevantScenarios)
{
ProbabilityAssessmentOutput derivedOutput = ProbabilityAssessmentOutputFactory.Create(scenario.Output.Reliability);
totalInitialFailureMechanismResult += derivedOutput.Probability * (double)scenario.Contribution;
}
return(totalInitialFailureMechanismResult);
}
private static void Property_SetNewValue_NotifyObserversAndPropertyChanged <T>(
Action <AdoptableFailureMechanismSectionResultRow> setPropertyAction,
Func <AdoptableFailureMechanismSectionResult, T> assertPropertyFunc,
T newValue)
{
// Setup
var mocks = new MockRepository();
var errorProvider = mocks.Stub <IFailureMechanismSectionResultRowWithCalculatedProbabilityErrorProvider>();
var observer = mocks.StrictMock <IObserver>();
observer.Expect(o => o.UpdateObserver());
mocks.ReplayAll();
FailureMechanismSection section = FailureMechanismSectionTestFactory.CreateFailureMechanismSection();
var result = new AdoptableFailureMechanismSectionResult(section);
result.Attach(observer);
Func <FailureMechanismSectionAssemblyResultWrapper> performAssemblyFunc = FailureMechanismSectionAssemblyResultWrapperTestFactory.Create;
var row = new AdoptableFailureMechanismSectionResultRow(result, () => double.NaN, errorProvider,
performAssemblyFunc, ConstructionProperties);
// Call
setPropertyAction(row);
// Assert
Assert.AreEqual(newValue, assertPropertyFunc(result));
mocks.VerifyAll();
}
private static void ProbabilityProperty_SetInvalidValue_ThrowsArgumentOutOfRangeException(
Action <AdoptableFailureMechanismSectionResultRow> setPropertyAction)
{
// Setup
var mocks = new MockRepository();
var errorProvider = mocks.Stub <IFailureMechanismSectionResultRowWithCalculatedProbabilityErrorProvider>();
mocks.ReplayAll();
FailureMechanismSection section = FailureMechanismSectionTestFactory.CreateFailureMechanismSection();
var result = new AdoptableFailureMechanismSectionResult(section);
Func <FailureMechanismSectionAssemblyResultWrapper> performAssemblyFunc = FailureMechanismSectionAssemblyResultWrapperTestFactory.Create;
var row = new AdoptableFailureMechanismSectionResultRow(result, () => double.NaN, errorProvider,
performAssemblyFunc, 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 GivenRowWithIsRelevantAndInitialFailureMechanismResultType_WhenErrorProviderReturnsError_ThenShowNoError(
bool isRelevant, AdoptableInitialFailureMechanismResultType initialFailureMechanismResultType)
{
// Given
var mocks = new MockRepository();
var errorProvider = mocks.StrictMock <IFailureMechanismSectionResultRowWithCalculatedProbabilityErrorProvider>();
errorProvider.Stub(ep => ep.GetCalculatedProbabilityValidationError(null))
.IgnoreArguments()
.Return("error message");
mocks.ReplayAll();
FailureMechanismSection section = FailureMechanismSectionTestFactory.CreateFailureMechanismSection();
var result = new AdoptableFailureMechanismSectionResult(section)
{
IsRelevant = isRelevant,
InitialFailureMechanismResultType = initialFailureMechanismResultType
};
Func <FailureMechanismSectionAssemblyResultWrapper> performAssemblyFunc = FailureMechanismSectionAssemblyResultWrapperTestFactory.Create;
// When
var row = new AdoptableFailureMechanismSectionResultRow(result, () => double.NaN, errorProvider,
performAssemblyFunc, ConstructionProperties);
// Then
IDictionary <int, DataGridViewColumnStateDefinition> columnStateDefinitions = row.ColumnStateDefinitions;
Assert.AreEqual(string.Empty, columnStateDefinitions[ConstructionProperties.InitialFailureMechanismResultSectionProbabilityIndex].ErrorText);
mocks.VerifyAll();
}
public void GivenRowWithFurtherAnalysisTypeNotExecuted_WhenErrorProviderReturnsError_ThenShowsNoError(FailureMechanismSectionResultFurtherAnalysisType furtherAnalysisType)
{
// Given
var mocks = new MockRepository();
var errorProvider = mocks.StrictMock <IFailureMechanismSectionResultRowWithCalculatedProbabilityErrorProvider>();
errorProvider.Stub(ep => ep.GetCalculatedProbabilityValidationError(null))
.IgnoreArguments()
.Return(string.Empty);
errorProvider.Stub(ep => ep.GetManualProbabilityValidationError(double.NaN))
.IgnoreArguments()
.Return("error message");
mocks.ReplayAll();
FailureMechanismSection section = FailureMechanismSectionTestFactory.CreateFailureMechanismSection();
var result = new AdoptableFailureMechanismSectionResult(section)
{
FurtherAnalysisType = furtherAnalysisType
};
Func <FailureMechanismSectionAssemblyResultWrapper> performAssemblyFunc = FailureMechanismSectionAssemblyResultWrapperTestFactory.Create;
// When
var row = new AdoptableFailureMechanismSectionResultRow(result, () => double.NaN, errorProvider,
performAssemblyFunc, ConstructionProperties);
// Then
IDictionary <int, DataGridViewColumnStateDefinition> columnStateDefinitions = row.ColumnStateDefinitions;
Assert.IsEmpty(columnStateDefinitions[ConstructionProperties.RefinedSectionProbabilityIndex].ErrorText);
mocks.VerifyAll();
}
public void GivenRowWithInitialFailureMechanismResultTypeAdopt_WhenValueChanged_ThenInitialProbabilitiesChanged(AdoptableInitialFailureMechanismResultType newValue)
{
// Given
var mocks = new MockRepository();
var errorProvider = mocks.Stub <IFailureMechanismSectionResultRowWithCalculatedProbabilityErrorProvider>();
mocks.ReplayAll();
FailureMechanismSection section = FailureMechanismSectionTestFactory.CreateFailureMechanismSection();
var result = new AdoptableFailureMechanismSectionResult(section);
double sectionProbability = new Random(21).NextDouble();
Func <FailureMechanismSectionAssemblyResultWrapper> performAssemblyFunc = FailureMechanismSectionAssemblyResultWrapperTestFactory.Create;
var row = new AdoptableFailureMechanismSectionResultRow(result, () => sectionProbability, errorProvider,
performAssemblyFunc, ConstructionProperties);
// Precondition
Assert.AreEqual(sectionProbability, row.InitialFailureMechanismResultSectionProbability);
// When
row.InitialFailureMechanismResultType = newValue;
// Then
Assert.AreEqual(result.ManualInitialFailureMechanismResultSectionProbability, row.InitialFailureMechanismResultSectionProbability);
mocks.VerifyAll();
}
public void Constructor_WithAssemblyGroupSet_ExpectedColumnStates(FailureMechanismSectionAssemblyGroup assemblyGroup,
Color expectedBackgroundColor)
{
// Setup
var mocks = new MockRepository();
var errorProvider = mocks.Stub <IFailureMechanismSectionResultRowWithCalculatedProbabilityErrorProvider>();
mocks.ReplayAll();
FailureMechanismSection section = FailureMechanismSectionTestFactory.CreateFailureMechanismSection();
var result = new AdoptableFailureMechanismSectionResult(section);
Func <FailureMechanismSectionAssemblyResultWrapper> performAssemblyFunc = () =>
new FailureMechanismSectionAssemblyResultWrapper(
FailureMechanismSectionAssemblyResultTestFactory.CreateFailureMechanismSectionAssemblyResult(assemblyGroup),
AssemblyMethod.BOI0A1, AssemblyMethod.BOI0B1);
// Call
var row = new AdoptableFailureMechanismSectionResultRow(result, () => double.NaN, errorProvider,
performAssemblyFunc, ConstructionProperties);
// Assert
IDictionary <int, DataGridViewColumnStateDefinition> columnStateDefinitions = row.ColumnStateDefinitions;
DataGridViewControlColumnStateDefinitionTestHelper.AssertColumnWithColorState(
columnStateDefinitions[ConstructionProperties.AssemblyGroupIndex], expectedBackgroundColor);
mocks.VerifyAll();
}
public void GetInitialFailureMechanismResultProbability_NoRelevantScenarios_ReturnsNaN()
{
// Setup
FailureMechanismSection section = FailureMechanismSectionTestFactory.CreateFailureMechanismSection();
var failureMechanismSectionResult = new AdoptableFailureMechanismSectionResult(section);
var calculationScenario = new TestStructuresCalculationScenario
{
InputParameters =
{
Structure = new TestStructure(section.StartPoint)
},
IsRelevant = false,
Output = new TestStructuresOutput()
};
// Call
double initialFailureMechanismResultProbability = failureMechanismSectionResult.GetInitialFailureMechanismResultProbability(new[]
{
calculationScenario
});
// Assert
Assert.IsNaN(initialFailureMechanismResultProbability);
}
public void AssembleSection_CalculatorThrowsException_ThrowsAssemblyException()
{
// Setup
var failureMechanism = new TestCalculatableFailureMechanism();
FailureMechanismSection section = FailureMechanismSectionTestFactory.CreateFailureMechanismSection();
var sectionResult = new AdoptableFailureMechanismSectionResult(section);
var assessmentSection = new AssessmentSectionStub();
using (new AssemblyToolCalculatorFactoryConfig())
{
var calculatorFactory = (TestAssemblyToolCalculatorFactory)AssemblyToolCalculatorFactory.Instance;
FailureMechanismSectionAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator;
calculator.ThrowExceptionOnCalculate = true;
// Call
void Call() => StructuresFailureMechanismAssemblyFactory.AssembleSection <TestStructuresInput>(
sectionResult, failureMechanism, assessmentSection);
// Assert
var exception = Assert.Throws <AssemblyException>(Call);
Exception innerException = exception.InnerException;
Assert.IsInstanceOf <FailureMechanismSectionAssemblyCalculatorException>(innerException);
Assert.AreEqual(innerException.Message, exception.Message);
}
}
public void ReadAdoptableFailureMechanismSectionResultEntity_ParameterValues_SectionResultWithParameterValues()
{
// Setup
var random = new Random(21);
bool isRelevant = random.NextBoolean();
var initialFailureMechanismResultType = random.NextEnumValue <AdoptableInitialFailureMechanismResultType>();
double manualSectionProbability = random.NextDouble();
var furtherAnalysisType = random.NextEnumValue <FailureMechanismSectionResultFurtherAnalysisType>();
double refinedSectionProbability = random.NextDouble();
var entity = new AdoptableFailureMechanismSectionResultEntity
{
IsRelevant = Convert.ToByte(isRelevant),
InitialFailureMechanismResultType = Convert.ToByte(initialFailureMechanismResultType),
ManualInitialFailureMechanismResultSectionProbability = manualSectionProbability,
FurtherAnalysisType = Convert.ToByte(furtherAnalysisType),
RefinedSectionProbability = refinedSectionProbability
};
var sectionResult = new AdoptableFailureMechanismSectionResult(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 GetInitialFailureMechanismResultProbability_RelevantScenarioContributionsDoNotAddUpTo1_ReturnNaN(double contributionA, double contributionB)
{
// Setup
FailureMechanismSection section = FailureMechanismSectionTestFactory.CreateFailureMechanismSection();
var result = new AdoptableFailureMechanismSectionResult(section);
var calculationScenarioA = new TestStructuresCalculationScenario
{
InputParameters =
{
Structure = new TestStructure(section.StartPoint)
},
Contribution = (RoundedDouble)contributionA,
Output = new TestStructuresOutput(0.1)
};
var calculationScenarioB = new TestStructuresCalculationScenario
{
InputParameters =
{
Structure = new TestStructure(section.StartPoint)
},
Contribution = (RoundedDouble)contributionB,
Output = new TestStructuresOutput(0.2)
};
// Call
double initialFailureMechanismResultProbability = result.GetInitialFailureMechanismResultProbability(new[]
{
calculationScenarioA,
calculationScenarioB
});
// Assert
Assert.IsNaN(initialFailureMechanismResultProbability);
}
public void CreateAdoptableFailureMechanismSectionResult_SectionResultWithValues_ReturnsEntityWithExpectedValues()
{
// Setup
var random = new Random(21);
bool isRelevant = random.NextBoolean();
var initialFailureMechanismResultType = random.NextEnumValue <AdoptableInitialFailureMechanismResultType>();
double manualSectionProbability = random.NextDouble();
var furtherAnalysisType = random.NextEnumValue <FailureMechanismSectionResultFurtherAnalysisType>();
double refinedSectionProbability = random.NextDouble();
var sectionResult = new AdoptableFailureMechanismSectionResult(FailureMechanismSectionTestFactory.CreateFailureMechanismSection())
{
IsRelevant = isRelevant,
InitialFailureMechanismResultType = initialFailureMechanismResultType,
ManualInitialFailureMechanismResultSectionProbability = manualSectionProbability,
FurtherAnalysisType = furtherAnalysisType,
RefinedSectionProbability = refinedSectionProbability
};
// Call
AdoptableFailureMechanismSectionResultEntity 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);
}
/// <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>
/// <param name="calculateProbabilityFunc">The <see cref="Func{TResult}"/> to calculate the probability with.</param>
/// <returns>A <see cref="FailureMechanismSectionAssemblyResultWrapper"/>.</returns>
/// <exception cref="ArgumentNullException">Thrown when any argument is <c>null</c>.</exception>
/// <exception cref="AssemblyException">Thrown when the section could not be successfully assembled.</exception>
public static FailureMechanismSectionAssemblyResultWrapper AssembleSection(
AdoptableFailureMechanismSectionResult sectionResult, IAssessmentSection assessmentSection, Func <double> calculateProbabilityFunc)
{
if (sectionResult == null)
{
throw new ArgumentNullException(nameof(sectionResult));
}
if (assessmentSection == null)
{
throw new ArgumentNullException(nameof(assessmentSection));
}
if (calculateProbabilityFunc == null)
{
throw new ArgumentNullException(nameof(calculateProbabilityFunc));
}
double initialFailureMechanismResultSectionProbability =
sectionResult.InitialFailureMechanismResultType == AdoptableInitialFailureMechanismResultType.Adopt
? calculateProbabilityFunc()
: sectionResult.ManualInitialFailureMechanismResultSectionProbability;
bool hasProbabilitySpecified = sectionResult.InitialFailureMechanismResultType != AdoptableInitialFailureMechanismResultType.NoFailureProbability;
FailureMechanismSectionAssemblyInput input = CreateInput(
assessmentSection, sectionResult.IsRelevant, initialFailureMechanismResultSectionProbability,
sectionResult.FurtherAnalysisType, sectionResult.RefinedSectionProbability, hasProbabilitySpecified);
return(PerformAssembly(input));
}
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 <IFailureMechanismSectionResultRowWithCalculatedProbabilityErrorProvider>();
errorProvider.Expect(ep => ep.GetManualProbabilityValidationError(sectionProbability))
.Return(errorText);
mocks.ReplayAll();
FailureMechanismSection section = FailureMechanismSectionTestFactory.CreateFailureMechanismSection();
var result = new AdoptableFailureMechanismSectionResult(section)
{
InitialFailureMechanismResultType = AdoptableInitialFailureMechanismResultType.Manual,
ManualInitialFailureMechanismResultSectionProbability = sectionProbability
};
Func <FailureMechanismSectionAssemblyResultWrapper> performAssemblyFunc = FailureMechanismSectionAssemblyResultWrapperTestFactory.Create;
// When
var row = new AdoptableFailureMechanismSectionResultRow(result, () => double.NaN, errorProvider,
performAssemblyFunc, ConstructionProperties);
// Then
IDictionary <int, DataGridViewColumnStateDefinition> columnStateDefinitions = row.ColumnStateDefinitions;
Assert.AreEqual(errorText, columnStateDefinitions[ConstructionProperties.InitialFailureMechanismResultSectionProbabilityIndex].ErrorText);
mocks.VerifyAll();
}
public void Constructor_WithFurtherAnalysisType_ExpectedColumnStates(FailureMechanismSectionResultFurtherAnalysisType furtherAnalysisType,
bool expectedEnabled)
{
// Setup
var mocks = new MockRepository();
var errorProvider = mocks.Stub <IFailureMechanismSectionResultRowWithCalculatedProbabilityErrorProvider>();
errorProvider.Stub(ep => ep.GetCalculatedProbabilityValidationError(null))
.IgnoreArguments()
.Return(string.Empty);
errorProvider.Stub(ep => ep.GetManualProbabilityValidationError(double.NaN))
.IgnoreArguments()
.Return(string.Empty);
mocks.ReplayAll();
FailureMechanismSection section = FailureMechanismSectionTestFactory.CreateFailureMechanismSection();
var result = new AdoptableFailureMechanismSectionResult(section)
{
FurtherAnalysisType = furtherAnalysisType
};
Func <FailureMechanismSectionAssemblyResultWrapper> performAssemblyFunc = FailureMechanismSectionAssemblyResultWrapperTestFactory.Create;
// Call
var row = new AdoptableFailureMechanismSectionResultRow(result, () => double.NaN, errorProvider,
performAssemblyFunc, ConstructionProperties);
// Assert
IDictionary <int, DataGridViewColumnStateDefinition> columnStateDefinitions = row.ColumnStateDefinitions;
DataGridViewControlColumnStateDefinitionTestHelper.AssertColumnState(
columnStateDefinitions[ConstructionProperties.RefinedSectionProbabilityIndex], expectedEnabled);
mocks.VerifyAll();
}
public void Constructor_Always_ExpectedColumnStates()
{
// Setup
var mocks = new MockRepository();
var errorProvider = mocks.Stub <IFailureMechanismSectionResultRowWithCalculatedProbabilityErrorProvider>();
mocks.ReplayAll();
FailureMechanismSection section = FailureMechanismSectionTestFactory.CreateFailureMechanismSection();
var result = new AdoptableFailureMechanismSectionResult(section);
Func <FailureMechanismSectionAssemblyResultWrapper> performAssemblyFunc = FailureMechanismSectionAssemblyResultWrapperTestFactory.Create;
// Call
var row = new AdoptableFailureMechanismSectionResultRow(result, () => double.NaN, errorProvider,
performAssemblyFunc, ConstructionProperties);
// Assert
IDictionary <int, DataGridViewColumnStateDefinition> columnStateDefinitions = row.ColumnStateDefinitions;
DataGridViewControlColumnStateDefinitionTestHelper.AssertColumnState(
columnStateDefinitions[ConstructionProperties.SectionProbabilityIndex], true, true);
mocks.VerifyAll();
}
/// <summary>
/// Asserts whether the data of the <see cref="AdoptableFailureMechanismSectionResultEntity"/> and
/// <see cref="AdoptableFailureMechanismSectionResult"/> have equal values.
/// </summary>
/// <param name="sectionResultEntity">The <see cref="AdoptableFailureMechanismSectionResultEntity"/>.</param>
/// <param name="sectionResult">The <see cref="AdoptableFailureMechanismSectionResult"/>.</param>
public static void AssertSectionResult(AdoptableFailureMechanismSectionResultEntity sectionResultEntity,
AdoptableFailureMechanismSectionResult sectionResult)
{
Assert.AreEqual(Convert.ToBoolean(sectionResultEntity.IsRelevant), sectionResult.IsRelevant);
Assert.AreEqual((AdoptableInitialFailureMechanismResultType)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 AdoptableFailureMechanismSectionResult(section);
// Assert
Assert.IsInstanceOf <FailureMechanismSectionResult>(sectionResult);
Assert.AreEqual(AdoptableInitialFailureMechanismResultType.Adopt, sectionResult.InitialFailureMechanismResultType);
}
public void ReadAdoptableFailureMechanismSectionResultEntity_EntityWithNullValues_SectionResultWithNaNValues()
{
// Setup
var entity = new AdoptableFailureMechanismSectionResultEntity();
var sectionResult = new AdoptableFailureMechanismSectionResult(FailureMechanismSectionTestFactory.CreateFailureMechanismSection());
// Call
entity.Read(sectionResult);
// Assert
Assert.IsNaN(sectionResult.ManualInitialFailureMechanismResultSectionProbability);
Assert.IsNaN(sectionResult.RefinedSectionProbability);
}
public void ReadAdoptableFailureMechanismSectionResultEntity_EntityNull_ThrowsArgumentNullException()
{
// Setup
var sectionResult = new AdoptableFailureMechanismSectionResult(FailureMechanismSectionTestFactory.CreateFailureMechanismSection());
// Call
void Call() => ((AdoptableFailureMechanismSectionResultEntity)null).Read(sectionResult);
// Assert
var exception = Assert.Throws <ArgumentNullException>(Call);
Assert.AreEqual("entity", exception.ParamName);
}
public void GetInitialFailureMechanismResultProbability_NoScenarios_ReturnsNaN()
{
// Setup
FailureMechanismSection section = FailureMechanismSectionTestFactory.CreateFailureMechanismSection();
var failureMechanismSectionResult = new AdoptableFailureMechanismSectionResult(section);
// Call
double initialFailureMechanismResultProbability = failureMechanismSectionResult.GetInitialFailureMechanismResultProbability(
Enumerable.Empty <TestStructuresCalculationScenario>());
// Assert
Assert.IsNaN(initialFailureMechanismResultProbability);
}
public void AssembleSectionAdoptableSectionWithoutProfileProbability_AssessmentSectionNull_ThrowsArgumentNullException()
{
// Setup
var sectionResult = new AdoptableFailureMechanismSectionResult(FailureMechanismSectionTestFactory.CreateFailureMechanismSection());
// Call
void Call() => FailureMechanismSectionAssemblyResultFactory.AssembleSection(sectionResult, null, () => double.NaN);
// Assert
var exception = Assert.Throws <ArgumentNullException>(Call);
Assert.AreEqual("assessmentSection", exception.ParamName);
}
public void GetInitialFailureMechanismResultProbability_CalculationScenariosNull_ThrowsArgumentNullException()
{
// Setup
FailureMechanismSection section = FailureMechanismSectionTestFactory.CreateFailureMechanismSection();
var failureMechanismSectionResult = new AdoptableFailureMechanismSectionResult(section);
// Call
void Call() => failureMechanismSectionResult.GetInitialFailureMechanismResultProbability <TestStructuresInput>(null);
// Assert
var exception = Assert.Throws <ArgumentNullException>(Call);
Assert.AreEqual("calculationScenarios", exception.ParamName);
}
/// <summary>
/// Creates an instance of <see cref="AdoptableFailureMechanismSectionResultEntity"/>
/// based on the information of the <see cref="AdoptableFailureMechanismSectionResult"/>.
/// </summary>
/// <param name="result">The result to create a database entity for.</param>
/// <returns>An <see cref="AdoptableFailureMechanismSectionResultEntity"/>.</returns>
/// <exception cref="ArgumentNullException">Thrown when <paramref name="result"/> is <c>null</c>.</exception>
internal static AdoptableFailureMechanismSectionResultEntity Create(this AdoptableFailureMechanismSectionResult result)
{
if (result == null)
{
throw new ArgumentNullException(nameof(result));
}
var sectionResultEntity = new AdoptableFailureMechanismSectionResultEntity
{
InitialFailureMechanismResultType = Convert.ToByte(result.InitialFailureMechanismResultType)
};
sectionResultEntity.SetCommonFailureMechanismSectionResultProperties(result);
return(sectionResultEntity);
}
public void CreateAdoptableFailureMechanismSectionResult_SectionResultWithNaNValues_ReturnsEntityWithExpectedResults()
{
// Setup
var sectionResult = new AdoptableFailureMechanismSectionResult(FailureMechanismSectionTestFactory.CreateFailureMechanismSection())
{
ManualInitialFailureMechanismResultSectionProbability = double.NaN,
RefinedSectionProbability = double.NaN
};
// Call
AdoptableFailureMechanismSectionResultEntity entity = sectionResult.Create();
// Assert
Assert.IsNull(entity.ManualInitialFailureMechanismResultSectionProbability);
Assert.IsNull(entity.RefinedSectionProbability);
}
public void AssembleSection_AssessmentSectionNull_ThrowsArgumentNullException()
{
// Setup
FailureMechanismSection section = FailureMechanismSectionTestFactory.CreateFailureMechanismSection();
var sectionResult = new AdoptableFailureMechanismSectionResult(section);
var failureMechanism = new TestCalculatableFailureMechanism();
// Call
void Call() => StructuresFailureMechanismAssemblyFactory.AssembleSection <TestStructuresInput>(sectionResult, failureMechanism, null);
// Assert
var exception = Assert.Throws <ArgumentNullException>(Call);
Assert.AreEqual("assessmentSection", exception.ParamName);
}
/// <summary>
/// Reads the <see cref="AdoptableFailureMechanismSectionResultEntity"/> and use the information
/// to update an <see cref="AdoptableFailureMechanismSectionResult"/>.
/// </summary>
/// <param name="entity">The <see cref="AdoptableFailureMechanismSectionResultEntity"/> 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 AdoptableFailureMechanismSectionResultEntity entity,
AdoptableFailureMechanismSectionResult sectionResult)
{
if (entity == null)
{
throw new ArgumentNullException(nameof(entity));
}
if (sectionResult == null)
{
throw new ArgumentNullException(nameof(sectionResult));
}
sectionResult.InitialFailureMechanismResultType = (AdoptableInitialFailureMechanismResultType)entity.InitialFailureMechanismResultType;
sectionResult.SetCommonFailureMechanismSectionResultProperties(entity);
}
public void GivenRowWithoutAssemblyErrors_WhenUpdatingAndAssemblyThrowsException_ThenAssemblyPropertiesSetToDefault()
{
// Given
var mocks = new MockRepository();
var errorProvider = mocks.Stub <IFailureMechanismSectionResultRowWithCalculatedProbabilityErrorProvider>();
mocks.ReplayAll();
FailureMechanismSection section = FailureMechanismSectionTestFactory.CreateFailureMechanismSection();
var result = new AdoptableFailureMechanismSectionResult(section);
var nrOfCalls = 0;
FailureMechanismSectionAssemblyResultWrapper assemblyResultWrapper = FailureMechanismSectionAssemblyResultWrapperTestFactory.Create();
Func <FailureMechanismSectionAssemblyResultWrapper> performAssemblyFunc = () =>
{
if (nrOfCalls == 1)
{
throw new AssemblyException();
}
nrOfCalls++;
return(assemblyResultWrapper);
};
var row = new AdoptableFailureMechanismSectionResultRow(result, () => double.NaN, errorProvider,
performAssemblyFunc, ConstructionProperties);
// Precondition
FailureMechanismSectionAssemblyResult assemblyResult = assemblyResultWrapper.AssemblyResult;
Assert.AreEqual(assemblyResult.SectionProbability, row.SectionProbability);
Assert.AreEqual(EnumDisplayNameHelper.GetDisplayName(assemblyResult.FailureMechanismSectionAssemblyGroup),
row.AssemblyGroup);
// When
row.InitialFailureMechanismResultType = AdoptableInitialFailureMechanismResultType.Manual;
// Then
var expectedAssemblyResult = new DefaultFailureMechanismSectionAssemblyResult();
Assert.AreEqual(expectedAssemblyResult.SectionProbability, row.SectionProbability);
Assert.AreEqual(EnumDisplayNameHelper.GetDisplayName(expectedAssemblyResult.FailureMechanismSectionAssemblyGroup),
row.AssemblyGroup);
mocks.VerifyAll();
}
public void AssembleSectionAdoptableSectionWithoutProfileProbability_WithInput_ReturnsExpectedOutput(
AdoptableInitialFailureMechanismResultType initialFailureMechanismResultType, bool expectedHasProbabilitySpecified)
{
// Setup
var random = new Random(21);
bool isRelevant = random.NextBoolean();
double manualSectionProbability = random.NextDouble();
double calculatedSectionProbability = random.NextDouble();
var furtherAnalysisType = random.NextEnumValue <FailureMechanismSectionResultFurtherAnalysisType>();
double refinedSectionProbability = random.NextDouble();
var assessmentSection = new AssessmentSectionStub();
var sectionResult = new AdoptableFailureMechanismSectionResult(FailureMechanismSectionTestFactory.CreateFailureMechanismSection())
{
IsRelevant = isRelevant,
InitialFailureMechanismResultType = initialFailureMechanismResultType,
ManualInitialFailureMechanismResultSectionProbability = manualSectionProbability,
FurtherAnalysisType = furtherAnalysisType,
RefinedSectionProbability = refinedSectionProbability
};
using (new AssemblyToolCalculatorFactoryConfig())
{
var calculatorFactory = (TestAssemblyToolCalculatorFactory)AssemblyToolCalculatorFactory.Instance;
FailureMechanismSectionAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator;
// Call
FailureMechanismSectionAssemblyResultFactory.AssembleSection(sectionResult, assessmentSection, () => calculatedSectionProbability);
// 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);
double expectedInitialSectionProbability = IsInitialFailureMechanismResultTypeAdopt(initialFailureMechanismResultType)
? calculatedSectionProbability
: manualSectionProbability;
Assert.AreEqual(expectedInitialSectionProbability, calculatorInput.InitialSectionProbability);
Assert.AreEqual(furtherAnalysisType, calculatorInput.FurtherAnalysisType);
Assert.AreEqual(refinedSectionProbability, calculatorInput.RefinedSectionProbability);
}
}
