public void CreateAssemblyGroupFeatures_PerformAssemblyFuncThrowsAssemblyExceptionOnFirstSection_FirstSectionSkipped()
{
// Setup
var random = new Random(39);
var failureMechanism = new TestFailureMechanism();
FailureMechanismTestHelper.AddSections(failureMechanism, 2);
var expectedAssemblyResult = new FailureMechanismSectionAssemblyResult(
random.NextDouble(), random.NextDouble(), random.NextDouble(),
random.NextEnumValue <FailureMechanismSectionAssemblyGroup>());
// Call
var shouldThrowException = true;
IEnumerable <MapFeature> features = AssemblyMapDataFeaturesFactory.CreateAssemblyGroupFeatures <FailureMechanismSectionResult>(
failureMechanism, sr =>
{
if (shouldThrowException)
{
shouldThrowException = false;
throw new AssemblyException();
}
return(expectedAssemblyResult);
});
// Assert
AssertAssemblyGroupMapFeature(failureMechanism.Sections.ElementAt(1), features.Single(), expectedAssemblyResult);
}
public void Constructor_PerformAssemblyFuncReturnsResult_ReturnsAssemblyResult()
{
// Setup
var mocks = new MockRepository();
var errorProvider = mocks.Stub <IFailureMechanismSectionResultRowErrorProvider>();
mocks.ReplayAll();
FailureMechanismSection section = FailureMechanismSectionTestFactory.CreateFailureMechanismSection();
var result = new NonAdoptableWithProfileProbabilityFailureMechanismSectionResult(section);
FailureMechanismSectionAssemblyResultWrapper assemblyResultWrapper = FailureMechanismSectionAssemblyResultWrapperTestFactory.Create();
Func <FailureMechanismSectionAssemblyResultWrapper> performAssemblyFunc = () => assemblyResultWrapper;
// Call
var row = new NonAdoptableWithProfileProbabilityFailureMechanismSectionResultRow(result, errorProvider, performAssemblyFunc, ConstructionProperties);
// Assert
FailureMechanismSectionAssemblyResult assemblyResult = assemblyResultWrapper.AssemblyResult;
Assert.AreEqual(assemblyResult.ProfileProbability, row.ProfileProbability);
Assert.AreEqual(assemblyResult.SectionProbability, row.SectionProbability);
Assert.AreEqual(assemblyResult.N, row.SectionN, row.SectionN.GetAccuracy());
Assert.AreEqual(2, row.SectionN.NumberOfDecimalPlaces);
Assert.AreEqual(EnumDisplayNameHelper.GetDisplayName(assemblyResult.FailureMechanismSectionAssemblyGroup),
row.AssemblyGroup);
mocks.VerifyAll();
}
/// <summary>
/// Asserts whether the <see cref="MapData"/> contains the data that is representative
/// for the <paramref name="expectedAssemblyResult"/>.
/// </summary>
/// <param name="failureMechanism">The <see cref="IFailureMechanism"/> the that contains the original data.</param>
/// <param name="expectedAssemblyResult">The expected <see cref="FailureMechanismSectionAssemblyResult"/> that contains the original data.</param>
/// <param name="mapData">The <see cref="MapDataCollection"/> that needs to be asserted.</param>
/// <exception cref="AssertionException">Thrown when:
/// <list type="bullet">
/// <item>the name of the <see cref="MapData"/> is not <c>Duidingsklasse per vak</c>;</item>
/// <item>the amount of features in <paramref name="mapData"/> is not equal to the
/// amount of the <see cref="IFailureMechanism.Sections"/>;</item>
/// <item>the geometries of the features in <paramref name="mapData"/> are not equal to
/// the expected geometry of the <see cref="IFailureMechanism.Sections"/>;</item>
/// <item>the meta data does not contain the <see cref="FailureMechanismSectionAssemblyGroup"/>.</item>
/// </list>
/// </exception>
public static void AssertAssemblyMapData(IFailureMechanism failureMechanism,
FailureMechanismSectionAssemblyResult expectedAssemblyResult,
MapData mapData)
{
var assemblyMapLineData = (MapLineData)mapData;
Assert.AreEqual("Duidingsklasse per vak", assemblyMapLineData.Name);
MapFeature[] features = assemblyMapLineData.Features.ToArray();
FailureMechanismSection[] sections = failureMechanism.Sections.ToArray();
Assert.AreEqual(sections.Length, features.Length);
for (var index = 0; index < sections.Length; index++)
{
MapFeature feature = features[index];
FailureMechanismSection failureMechanismSection = sections[index];
CollectionAssert.AreEqual(failureMechanismSection.Points, feature.MapGeometries.Single().PointCollections.Single());
Assert.AreEqual(2, feature.MetaData.Count);
Assert.AreEqual(EnumDisplayNameHelper.GetDisplayName(expectedAssemblyResult.FailureMechanismSectionAssemblyGroup),
feature.MetaData["Duidingsklasse"]);
Assert.AreEqual(expectedAssemblyResult.SectionProbability, feature.MetaData["Rekenwaarde faalkans per vak"]);
}
}
public void CreateAssemblyGroupFeatures_ValidParameters_ReturnsExpectedFeatures()
{
// Setup
var random = new Random(39);
var failureMechanism = new TestFailureMechanism();
FailureMechanismTestHelper.AddSections(failureMechanism, random.Next(0, 10));
var expectedAssemblyResult = new FailureMechanismSectionAssemblyResult(
random.NextDouble(), random.NextDouble(), random.NextDouble(),
random.NextEnumValue <FailureMechanismSectionAssemblyGroup>());
// Call
IEnumerable <MapFeature> features = AssemblyMapDataFeaturesFactory.CreateAssemblyGroupFeatures <FailureMechanismSectionResult>(
failureMechanism, sr => expectedAssemblyResult);
// Assert
Assert.AreEqual(failureMechanism.Sections.Count(), features.Count());
for (var i = 0; i < features.Count(); i++)
{
FailureMechanismSection section = failureMechanism.Sections.ElementAt(i);
MapFeature mapFeature = features.ElementAt(i);
AssertAssemblyGroupMapFeature(section, mapFeature, expectedAssemblyResult);
}
}
/// <summary>
/// Creates a collection of <see cref="ExportableFailureMechanismSectionAssemblyWithProbabilityResult"/>
/// with assembly results based on <paramref name="failureMechanism"/>.
/// </summary>
/// <param name="failureMechanism">The failure mechanism to create a collection of
/// <see cref="ExportableFailureMechanismSectionAssemblyWithProbabilityResult"/> for.</param>
/// <param name="assessmentSection">The <see cref="IAssessmentSection"/> to use in the assembly.</param>
/// <param name="assembleFailureMechanismSectionFunc">The <see cref="Func{T1,T2,T3,TResult}"/>
/// to perform the failure mechanism section assembly.</param>
/// <typeparam name="TFailureMechanism">The type of the failure mechanism.</typeparam>
/// <typeparam name="TSectionResult">The type of the section result.</typeparam>
/// <returns>A collection of <see cref="ExportableFailureMechanismSectionAssemblyWithProbabilityResult"/>.</returns>
/// <exception cref="AssemblyException">Thrown when assembly results cannot be created.</exception>
private static IEnumerable <ExportableFailureMechanismSectionAssemblyWithProbabilityResult> CreateExportableFailureMechanismSectionResults
<TFailureMechanism, TSectionResult>(
TFailureMechanism failureMechanism, IAssessmentSection assessmentSection,
Func <TSectionResult, TFailureMechanism, IAssessmentSection, FailureMechanismSectionAssemblyResultWrapper> assembleFailureMechanismSectionFunc)
where TFailureMechanism : IFailureMechanism <TSectionResult>
where TSectionResult : FailureMechanismSectionResult
{
IDictionary <TSectionResult, ExportableFailureMechanismSection> failureMechanismSectionsLookup =
ExportableFailureMechanismSectionHelper.CreateFailureMechanismSectionResultLookup(failureMechanism.SectionResults);
var exportableResults = new List <ExportableFailureMechanismSectionAssemblyWithProbabilityResult>();
foreach (KeyValuePair <TSectionResult, ExportableFailureMechanismSection> failureMechanismSectionPair in failureMechanismSectionsLookup)
{
FailureMechanismSectionAssemblyResultWrapper assemblyResultWrapper = assembleFailureMechanismSectionFunc(
failureMechanismSectionPair.Key, failureMechanism, assessmentSection);
FailureMechanismSectionAssemblyResult assemblyResult = assemblyResultWrapper.AssemblyResult;
exportableResults.Add(
new ExportableFailureMechanismSectionAssemblyWithProbabilityResult(
failureMechanismSectionPair.Value, assemblyResult.FailureMechanismSectionAssemblyGroup, assemblyResult.SectionProbability,
ExportableAssemblyMethodFactory.Create(assemblyResultWrapper.AssemblyGroupMethod),
ExportableAssemblyMethodFactory.Create(assemblyResultWrapper.ProbabilityMethod)));
}
return(exportableResults);
}
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 FailureMechanismSection(FailureMechanismSectionAssemblyResult result, string failureMechanismType, double sectionStart,
double sectionEnd)
{
Result = result;
FailureMechanismType = failureMechanismType;
SectionStart = sectionStart;
SectionEnd = sectionEnd;
}
public void FailureMechanismSectionAssemblyResultConstructorChecksValidProbabilities(double probabilityProfile, double probabilitySection, EInterpretationCategory interpretationCategory, double expectedNValue)
{
var result = new FailureMechanismSectionAssemblyResult((Probability)probabilityProfile, (Probability)probabilitySection, interpretationCategory);
Assert.AreEqual(expectedNValue, result.NSection);
Assert.AreEqual(probabilityProfile, result.ProbabilityProfile.Value);
Assert.AreEqual(probabilitySection, result.ProbabilitySection.Value);
Assert.AreEqual(interpretationCategory, result.InterpretationCategory);
}
public void AssembleFailureMechanismSection_PerformSectionAssemblyFuncThrowsAssemblyException_ReturnsDefaultFailureMechanismSectionAssemblyResult()
{
// Setup
var sectionResult = new TestFailureMechanismSectionResult(FailureMechanismSectionTestFactory.CreateFailureMechanismSection());
// Call
FailureMechanismSectionAssemblyResult assemblyResult = AssemblyToolHelper.AssembleFailureMechanismSection(
sectionResult, sr => throw new AssemblyException());
// Assert
Assert.IsInstanceOf <DefaultFailureMechanismSectionAssemblyResult>(assemblyResult);
}
public void GivenMapLayerWithFailureMechanismSectionAssemblyResults_WhenChangingNestedCalculationScenarioInputDataAndObserversNotified_ThenMapDataUpdated()
{
// Given
var mocks = new MockRepository();
var observer = mocks.StrictMock <IObserver>();
observer.Expect(o => o.UpdateObserver());
mocks.ReplayAll();
var random = new Random(21);
var calculationScenario = new TestCalculationScenario();
var failureMechanism = new TestCalculatableFailureMechanism(new[]
{
calculationScenario
});
failureMechanism.SetSections(new[]
{
FailureMechanismSectionTestFactory.CreateFailureMechanismSection()
}, string.Empty);
var nestedCalculationScenario = new TestCalculationScenario();
var nestedCalculationGroup = new CalculationGroup();
nestedCalculationGroup.Children.Add(nestedCalculationScenario);
failureMechanism.CalculationsGroup.Children.Add(nestedCalculationGroup);
var assemblyResult = new FailureMechanismSectionAssemblyResult(
random.NextDouble(), random.NextDouble(), random.NextDouble(),
random.NextEnumValue <FailureMechanismSectionAssemblyGroup>());
using (var mapLayer = new CalculatableFailureMechanismSectionResultsMapLayer <TestCalculatableFailureMechanism, TestFailureMechanismSectionResult, TestCalculationInput>(
failureMechanism, result => assemblyResult))
{
mapLayer.MapData.Attach(observer);
// Precondition
MapDataTestHelper.AssertAssemblyMapData(failureMechanism, assemblyResult, mapLayer.MapData);
// When
assemblyResult = new FailureMechanismSectionAssemblyResult(
random.NextDouble(), random.NextDouble(), random.NextDouble(),
random.NextEnumValue <FailureMechanismSectionAssemblyGroup>());
nestedCalculationScenario.InputParameters.HydraulicBoundaryLocation = new TestHydraulicBoundaryLocation();
nestedCalculationScenario.InputParameters.NotifyObservers();
// Then
MapDataTestHelper.AssertAssemblyMapData(failureMechanism, assemblyResult, mapLayer.MapData);
}
mocks.VerifyAll();
}
public void GivenRowWithoutAssemblyErrors_WhenUpdatingAndPerformAssemblyThrowsException_ThenShowError()
{
// Given
var mocks = new MockRepository();
var errorProvider = mocks.Stub <IFailureMechanismSectionResultRowErrorProvider>();
mocks.ReplayAll();
FailureMechanismSection section = FailureMechanismSectionTestFactory.CreateFailureMechanismSection();
var result = new NonAdoptableWithProfileProbabilityFailureMechanismSectionResult(section);
var nrOfCalls = 0;
FailureMechanismSectionAssemblyResultWrapper assemblyResultWrapper = FailureMechanismSectionAssemblyResultWrapperTestFactory.Create();
Func <FailureMechanismSectionAssemblyResultWrapper> performAssemblyFunc = () =>
{
if (nrOfCalls == 1)
{
throw new AssemblyException();
}
nrOfCalls++;
return(assemblyResultWrapper);
};
var row = new NonAdoptableWithProfileProbabilityFailureMechanismSectionResultRow(result, errorProvider, performAssemblyFunc, ConstructionProperties);
// Precondition
FailureMechanismSectionAssemblyResult assemblyResult = assemblyResultWrapper.AssemblyResult;
Assert.AreEqual(assemblyResult.ProfileProbability, row.ProfileProbability);
Assert.AreEqual(assemblyResult.SectionProbability, row.SectionProbability);
Assert.AreEqual(assemblyResult.N, row.SectionN, row.SectionN.GetAccuracy());
Assert.AreEqual(2, row.SectionN.NumberOfDecimalPlaces);
Assert.AreEqual(EnumDisplayNameHelper.GetDisplayName(assemblyResult.FailureMechanismSectionAssemblyGroup),
row.AssemblyGroup);
// When
row.InitialFailureMechanismResultType = NonAdoptableInitialFailureMechanismResultType.NoFailureProbability;
// Then
var expectedAssemblyResult = new DefaultFailureMechanismSectionAssemblyResult();
Assert.AreEqual(expectedAssemblyResult.ProfileProbability, row.ProfileProbability);
Assert.AreEqual(expectedAssemblyResult.SectionProbability, row.SectionProbability);
Assert.AreEqual(expectedAssemblyResult.N, row.SectionN, row.SectionN.GetAccuracy());
Assert.AreEqual(2, row.SectionN.NumberOfDecimalPlaces);
Assert.AreEqual(EnumDisplayNameHelper.GetDisplayName(expectedAssemblyResult.FailureMechanismSectionAssemblyGroup),
row.AssemblyGroup);
mocks.VerifyAll();
}
public void GivenMapLayerWithFailureMechanismSectionAssemblyResults_WhenChangingFailureMechanismDataAndObserversNotified_ThenMapDataUpdated()
{
// Given
var mocks = new MockRepository();
var observer = mocks.StrictMock <IObserver>();
observer.Expect(o => o.UpdateObserver());
mocks.ReplayAll();
var random = new Random(21);
var failureMechanism = new TestFailureMechanism();
failureMechanism.SetSections(new[]
{
FailureMechanismSectionTestFactory.CreateFailureMechanismSection()
}, string.Empty);
var assemblyResult = new FailureMechanismSectionAssemblyResult(
random.NextDouble(), random.NextDouble(), random.NextDouble(),
random.NextEnumValue <FailureMechanismSectionAssemblyGroup>());
using (var mapLayer = new NonCalculatableFailureMechanismSectionResultsMapLayer <TestFailureMechanismSectionResult>(
failureMechanism, result => assemblyResult))
{
mapLayer.MapData.Attach(observer);
// Precondition
MapDataTestHelper.AssertAssemblyMapData(failureMechanism, assemblyResult, mapLayer.MapData);
// When
failureMechanism.SetSections(new[]
{
FailureMechanismSectionTestFactory.CreateFailureMechanismSection(new[]
{
new Point2D(0, 0),
new Point2D(1, 1)
}),
FailureMechanismSectionTestFactory.CreateFailureMechanismSection(new[]
{
new Point2D(1, 1),
new Point2D(2, 2)
})
}, string.Empty);
failureMechanism.NotifyObservers();
// Then
MapDataTestHelper.AssertAssemblyMapData(failureMechanism, assemblyResult, mapLayer.MapData);
}
mocks.VerifyAll();
}
public void ConstructorChecksInputForNotNaNValuesWithCorrespondingCategories(double profileValue, double sectionValue, EInterpretationCategory category)
{
try
{
var result = new FailureMechanismSectionAssemblyResult((Probability)profileValue, (Probability)sectionValue, category);
}
catch (AssemblyException e)
{
Assert.AreEqual(1, e.Errors.Count());
Assert.AreEqual(EAssemblyErrors.ValueMayNotBeNaN, e.Errors.First().ErrorCode);
Assert.Pass();
}
Assert.Fail("Expected error was not thrown");
}
public void ConstructorChecksInputForInconsistentProbabilitiesNotRelevantCategory(double profileProbability, double sectionProbability, EInterpretationCategory interpretationCategory)
{
try
{
var result = new FailureMechanismSectionAssemblyResult((Probability)profileProbability, (Probability)sectionProbability, interpretationCategory);
}
catch (AssemblyException e)
{
Assert.AreEqual(1, e.Errors.Count());
Assert.AreEqual(EAssemblyErrors.NonMatchingProbabilityValues, e.Errors.First().ErrorCode);
Assert.Pass();
}
Assert.Fail("Expected error was not thrown");
}
public void ConstructorChecksForValidCategory()
{
try
{
var result = new FailureMechanismSectionAssemblyResult((Probability)0.1, (Probability)0.2, (EInterpretationCategory)(-1));
}
catch (AssemblyException e)
{
Assert.AreEqual(1, e.Errors.Count());
Assert.AreEqual(EAssemblyErrors.InvalidCategoryValue, e.Errors.First().ErrorCode);
Assert.Pass();
}
Assert.Fail("Expected error was not thrown");
}
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 AssembleFailureMechanismSection_WithValidData_ReturnsFailureMechanismSectionAssemblyResult()
{
// Setup
var sectionResult = new TestFailureMechanismSectionResult(FailureMechanismSectionTestFactory.CreateFailureMechanismSection());
var random = new Random(21);
var expectedAssemblyResult = new FailureMechanismSectionAssemblyResult(
random.NextDouble(), random.NextDouble(), random.NextDouble(),
random.NextEnumValue <FailureMechanismSectionAssemblyGroup>());
// Call
FailureMechanismSectionAssemblyResult assemblyResult = AssemblyToolHelper.AssembleFailureMechanismSection(
sectionResult, sr => new FailureMechanismSectionAssemblyResultWrapper(expectedAssemblyResult, random.NextEnumValue <AssemblyMethod>(),
random.NextEnumValue <AssemblyMethod>()));
// Assert
Assert.AreSame(expectedAssemblyResult, assemblyResult);
}
public void Constructor_ExpectedValues()
{
// Setup
var random = new Random(21);
var assemblyResult = new FailureMechanismSectionAssemblyResult(
random.NextDouble(), random.NextDouble(), random.NextDouble(),
random.NextEnumValue <FailureMechanismSectionAssemblyGroup>());
var probabilityMethod = random.NextEnumValue <AssemblyMethod>();
var assemblyGroupMethod = random.NextEnumValue <AssemblyMethod>();
// Call
var wrapper = new FailureMechanismSectionAssemblyResultWrapper(assemblyResult, probabilityMethod, assemblyGroupMethod);
// Assert
Assert.AreSame(assemblyResult, wrapper.AssemblyResult);
Assert.AreEqual(probabilityMethod, wrapper.ProbabilityMethod);
Assert.AreEqual(assemblyGroupMethod, wrapper.AssemblyGroupMethod);
}
public void CreateInput_WithAllFailureMechanisms_ReturnsInputCollection()
{
// Setup
var random = new Random(21);
AssessmentSection assessmentSection = TestDataGenerator.GetAssessmentSectionWithAllFailureMechanismSectionsAndResults(
random.NextEnumValue <AssessmentSectionComposition>());
using (new AssemblyToolCalculatorFactoryConfig())
{
var calculatorFactory = (TestAssemblyToolCalculatorFactory)AssemblyToolCalculatorFactory.Instance;
FailureMechanismSectionAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator;
// Call
IEnumerable <IEnumerable <CombinedAssemblyFailureMechanismSection> > inputs = CombinedAssemblyFailureMechanismSectionFactory.CreateInput(
assessmentSection, assessmentSection.GetFailureMechanisms().Concat(assessmentSection.SpecificFailureMechanisms));
// Assert
int expectedNrOfGeneralSectionResults = assessmentSection.GetFailureMechanisms().Count();
int expectedNrOfSpecificSectionResults = assessmentSection.SpecificFailureMechanisms.Count;
Assert.AreEqual(expectedNrOfGeneralSectionResults + expectedNrOfSpecificSectionResults, inputs.Count());
FailureMechanismSectionAssemblyResult assemblyResult = calculator.FailureMechanismSectionAssemblyResultOutput.AssemblyResult;
AssertSectionsWithResult(assessmentSection.Piping.SectionResults, assemblyResult.FailureMechanismSectionAssemblyGroup, inputs.ElementAt(0));
AssertSectionsWithResult(assessmentSection.GrassCoverErosionInwards.SectionResults, assemblyResult.FailureMechanismSectionAssemblyGroup, inputs.ElementAt(1));
AssertSectionsWithResult(assessmentSection.MacroStabilityInwards.SectionResults, assemblyResult.FailureMechanismSectionAssemblyGroup, inputs.ElementAt(2));
AssertSectionsWithResult(assessmentSection.Microstability.SectionResults, assemblyResult.FailureMechanismSectionAssemblyGroup, inputs.ElementAt(3));
AssertSectionsWithResult(assessmentSection.StabilityStoneCover.SectionResults, assemblyResult.FailureMechanismSectionAssemblyGroup, inputs.ElementAt(4));
AssertSectionsWithResult(assessmentSection.WaveImpactAsphaltCover.SectionResults, assemblyResult.FailureMechanismSectionAssemblyGroup, inputs.ElementAt(5));
AssertSectionsWithResult(assessmentSection.WaterPressureAsphaltCover.SectionResults, assemblyResult.FailureMechanismSectionAssemblyGroup, inputs.ElementAt(6));
AssertSectionsWithResult(assessmentSection.GrassCoverErosionOutwards.SectionResults, assemblyResult.FailureMechanismSectionAssemblyGroup, inputs.ElementAt(7));
AssertSectionsWithResult(assessmentSection.GrassCoverSlipOffOutwards.SectionResults, assemblyResult.FailureMechanismSectionAssemblyGroup, inputs.ElementAt(8));
AssertSectionsWithResult(assessmentSection.GrassCoverSlipOffInwards.SectionResults, assemblyResult.FailureMechanismSectionAssemblyGroup, inputs.ElementAt(9));
AssertSectionsWithResult(assessmentSection.HeightStructures.SectionResults, assemblyResult.FailureMechanismSectionAssemblyGroup, inputs.ElementAt(10));
AssertSectionsWithResult(assessmentSection.ClosingStructures.SectionResults, assemblyResult.FailureMechanismSectionAssemblyGroup, inputs.ElementAt(11));
AssertSectionsWithResult(assessmentSection.PipingStructure.SectionResults, assemblyResult.FailureMechanismSectionAssemblyGroup, inputs.ElementAt(12));
AssertSectionsWithResult(assessmentSection.StabilityPointStructures.SectionResults, assemblyResult.FailureMechanismSectionAssemblyGroup, inputs.ElementAt(13));
AssertSectionsWithResult(assessmentSection.DuneErosion.SectionResults, assemblyResult.FailureMechanismSectionAssemblyGroup, inputs.ElementAt(14));
for (var i = 0; i < expectedNrOfSpecificSectionResults; i++)
{
AssertSectionsWithResult(assessmentSection.SpecificFailureMechanisms[i].SectionResults, assemblyResult.FailureMechanismSectionAssemblyGroup,
inputs.ElementAt(expectedNrOfGeneralSectionResults + i));
}
}
}
private static IEnumerable <CombinedAssemblyFailureMechanismSection> CreateCombinedSections <TFailureMechanismSectionResult>(
IEnumerable <TFailureMechanismSectionResult> sectionResults, AssessmentSection assessmentSection,
Func <TFailureMechanismSectionResult, AssessmentSection, FailureMechanismSectionAssemblyResultWrapper> getAssemblyFunc)
where TFailureMechanismSectionResult : FailureMechanismSectionResult
{
double totalSectionsLength = 0;
return(sectionResults.Select(sectionResult =>
{
FailureMechanismSectionAssemblyResult failureMechanismSectionAssemblyResult = AssemblyToolHelper.AssembleFailureMechanismSection(
sectionResult, sr => getAssemblyFunc(sr, assessmentSection));
CombinedAssemblyFailureMechanismSection section = CreateSection(
sectionResult, failureMechanismSectionAssemblyResult.FailureMechanismSectionAssemblyGroup, totalSectionsLength);
totalSectionsLength = section.SectionEnd;
return section;
})
.ToArray());
}
public void Constructor_WithArguments_ExpectedValues()
{
// Setup
var random = new Random(21);
double profileProbability = random.NextDouble();
double sectionProbability = random.NextDouble();
double n = random.NextDouble();
var assemblyGroup = random.NextEnumValue <FailureMechanismSectionAssemblyGroup>();
// Call
var assembly = new FailureMechanismSectionAssemblyResult(
profileProbability, sectionProbability, n, assemblyGroup);
// Assert
Assert.AreEqual(profileProbability, assembly.ProfileProbability);
Assert.AreEqual(sectionProbability, assembly.SectionProbability);
Assert.AreEqual(n, assembly.N);
Assert.AreEqual(assemblyGroup, assembly.FailureMechanismSectionAssemblyGroup);
}
public void Constructor_ExpectedValues()
{
// Setup
var random = new Random(21);
var failureMechanism = new TestCalculatableFailureMechanism();
failureMechanism.SetSections(new[]
{
FailureMechanismSectionTestFactory.CreateFailureMechanismSection()
}, string.Empty);
var assemblyResult = new FailureMechanismSectionAssemblyResult(
random.NextDouble(), random.NextDouble(), random.NextDouble(),
random.NextEnumValue <FailureMechanismSectionAssemblyGroup>());
// Call
using (var mapLayer = new CalculatableFailureMechanismSectionResultsMapLayer <TestCalculatableFailureMechanism, TestFailureMechanismSectionResult, TestCalculationInput>(
failureMechanism, result => assemblyResult))
{
// Assert
Assert.IsInstanceOf <NonCalculatableFailureMechanismSectionResultsMapLayer <TestFailureMechanismSectionResult> >(mapLayer);
}
}
/// <summary>
/// Asserts a collection of <see cref="ExportableFailureMechanismSectionAssemblyWithProbabilityResult"/>
/// against the assembly result.
/// </summary>
/// <param name="expectedAssemblyResultWrapper">The expected <see cref="FailureMechanismSectionAssemblyResultWrapper"/>.</param>
/// <param name="sections">The actual exportable sections.</param>
/// <param name="results">The actual exportable assembly results.</param>
/// <exception cref="AssertionException">Thrown when:
/// <list type="bullet">
/// <item>The number of <paramref name="sections"/> and number of <paramref name="results"/> do not match.</item>
/// <item>The values between <paramref name="expectedAssemblyResultWrapper"/> and <paramref name="results"/>
/// do not match.</item>
/// </list></exception>
public static void AssertExportableFailureMechanismSectionResults(FailureMechanismSectionAssemblyResultWrapper expectedAssemblyResultWrapper,
IEnumerable <ExportableFailureMechanismSection> sections,
IEnumerable <ExportableFailureMechanismSectionAssemblyWithProbabilityResult> results)
{
int expectedNrOfResults = sections.Count();
Assert.AreEqual(expectedNrOfResults, results.Count());
for (var i = 0; i < expectedNrOfResults; i++)
{
ExportableFailureMechanismSection section = sections.ElementAt(i);
ExportableFailureMechanismSectionAssemblyWithProbabilityResult actualExportableAssemblyResult = results.ElementAt(i);
Assert.AreSame(section, actualExportableAssemblyResult.FailureMechanismSection);
FailureMechanismSectionAssemblyResult expectedAssemblyResult = expectedAssemblyResultWrapper.AssemblyResult;
Assert.AreEqual(expectedAssemblyResult.FailureMechanismSectionAssemblyGroup, actualExportableAssemblyResult.AssemblyGroup);
Assert.AreEqual(expectedAssemblyResult.SectionProbability, actualExportableAssemblyResult.Probability);
Assert.AreEqual(ExportableAssemblyMethodFactory.Create(expectedAssemblyResultWrapper.AssemblyGroupMethod),
actualExportableAssemblyResult.AssemblyGroupAssemblyMethod);
Assert.AreEqual(ExportableAssemblyMethodFactory.Create(expectedAssemblyResultWrapper.ProbabilityMethod),
actualExportableAssemblyResult.ProbabilityAssemblyMethod);
}
}
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();
}
public void Constructor_WithAllData_DataUpdatedToCollectionOfFilledMapData()
{
// Setup
var geometryPoints = new[]
{
new Point2D(0.0, 0.0),
new Point2D(2.0, 0.0),
new Point2D(4.0, 4.0),
new Point2D(6.0, 4.0)
};
var referenceLine = new ReferenceLine();
referenceLine.SetGeometry(new[]
{
new Point2D(1.0, 2.0),
new Point2D(2.0, 1.0)
});
var assessmentSection = new AssessmentSectionStub
{
ReferenceLine = referenceLine
};
assessmentSection.SetHydraulicBoundaryLocationCalculations(new[]
{
new HydraulicBoundaryLocation(1, "test", 1.0, 2.0)
});
var failureMechanism = new TestFailureMechanism();
FailureMechanismTestHelper.SetSections(failureMechanism, new[]
{
new FailureMechanismSection("A", geometryPoints.Take(2)),
new FailureMechanismSection("B", geometryPoints.Skip(1).Take(2)),
new FailureMechanismSection("C", geometryPoints.Skip(2).Take(2))
});
var random = new Random(21);
var failureMechanismSectionAssemblyResult = new FailureMechanismSectionAssemblyResult(
random.NextDouble(), random.NextDouble(), random.NextDouble(),
random.NextEnumValue <FailureMechanismSectionAssemblyGroup>());
// Call
using (var view = new StandAloneFailureMechanismView <IFailureMechanism <FailureMechanismSectionResult>, FailureMechanismSectionResult>(
failureMechanism, assessmentSection, sr => failureMechanismSectionAssemblyResult))
{
IMapControl map = ((RiskeerMapControl)view.Controls[0]).MapControl;
// Assert
MapDataCollection mapData = map.Data;
Assert.IsInstanceOf <MapDataCollection>(mapData);
List <MapData> mapDataList = mapData.Collection.ToList();
Assert.AreEqual(4, mapDataList.Count);
MapDataTestHelper.AssertReferenceLineMapData(assessmentSection.ReferenceLine, mapDataList[referenceLineIndex]);
IEnumerable <MapData> sectionsCollection = ((MapDataCollection)mapDataList[sectionsCollectionIndex]).Collection;
MapDataTestHelper.AssertFailureMechanismSectionsMapData(failureMechanism.Sections, sectionsCollection.ElementAt(sectionsIndex));
MapDataTestHelper.AssertFailureMechanismSectionsStartPointMapData(failureMechanism.Sections, sectionsCollection.ElementAt(sectionsStartPointIndex));
MapDataTestHelper.AssertFailureMechanismSectionsEndPointMapData(failureMechanism.Sections, sectionsCollection.ElementAt(sectionsEndPointIndex));
MapDataTestHelper.AssertHydraulicBoundaryLocationsMapData(assessmentSection, mapDataList[hydraulicBoundaryLocationsIndex]);
MapDataTestHelper.AssertAssemblyMapData(failureMechanism, failureMechanismSectionAssemblyResult, mapDataList[assemblyResultsIndex]);
}
}
private static void AssertAssemblyGroupMapFeature(FailureMechanismSection section, MapFeature mapFeature, FailureMechanismSectionAssemblyResult expectedAssemblyResult)
{
IEnumerable <MapGeometry> mapGeometries = mapFeature.MapGeometries;
Assert.AreEqual(1, mapGeometries.Count());
CollectionAssert.AreEqual(section.Points, mapGeometries.Single().PointCollections.First());
Assert.AreEqual(2, mapFeature.MetaData.Keys.Count);
Assert.AreEqual(EnumDisplayNameHelper.GetDisplayName(expectedAssemblyResult.FailureMechanismSectionAssemblyGroup),
mapFeature.MetaData["Duidingsklasse"]);
Assert.AreEqual(expectedAssemblyResult.SectionProbability, mapFeature.MetaData["Rekenwaarde faalkans per vak"]);
}
public void FailureMechanismSectionAssemblyResultToStringTest()
{
var result = new FailureMechanismSectionAssemblyResult((Probability)0.2, (Probability)0.4, EInterpretationCategory.III);
Assert.AreEqual("FailureMechanismSectionAssemblyResult [III Pprofile:0.2, Psection:0.4]", result.ToString());
}
