public void AssembleAssessmentSection_AssessmentSectionContainingFailureMechanismsWithRandomInAssemblyState_SetsInputOnCalculator() { // Setup AssessmentSection assessmentSection = CreateAssessmentSectionContainingFailureMechanismsWithRandomInAssemblyState(); using (new AssemblyToolCalculatorFactoryConfig()) { var calculatorFactory = (TestAssemblyToolCalculatorFactory)AssemblyToolCalculatorFactory.Instance; FailureMechanismAssemblyCalculatorStub failureMechanismAssemblyCalculator = calculatorFactory.LastCreatedFailureMechanismAssemblyCalculator; AssessmentSectionAssemblyCalculatorStub assessmentSectionAssemblyCalculator = calculatorFactory.LastCreatedAssessmentSectionAssemblyCalculator; // Call AssessmentSectionAssemblyFactory.AssembleAssessmentSection(assessmentSection); // Assert FailureMechanismContribution contribution = assessmentSection.FailureMechanismContribution; Assert.AreEqual(contribution.SignalFloodingProbability, assessmentSectionAssemblyCalculator.SignalFloodingProbability); Assert.AreEqual(contribution.MaximumAllowableFloodingProbability, assessmentSectionAssemblyCalculator.MaximumAllowableFloodingProbabilityInput); int expectedNrOfProbabilities = assessmentSection.GetFailureMechanisms() .Concat(assessmentSection.SpecificFailureMechanisms) .Count(fp => fp.InAssembly); IEnumerable <double> calculatorInput = assessmentSectionAssemblyCalculator.FailureMechanismProbabilitiesInput; Assert.AreEqual(expectedNrOfProbabilities, calculatorInput.Count()); foreach (double failureMechanismProbability in calculatorInput) { Assert.AreEqual(failureMechanismAssemblyCalculator.AssemblyResultOutput.AssemblyResult, failureMechanismProbability); } } }
/// <summary> /// Creates features for the combined failure mechanism section assembly. /// </summary> /// <param name="assessmentSection">The <see cref="AssessmentSection"/> to create the features for.</param> /// <returns>A collection of <see cref="MapFeature"/>.</returns> /// <exception cref="ArgumentNullException">Thrown when <paramref name="assessmentSection"/> /// is <c>null</c>.</exception> public static IEnumerable<MapFeature> CreateCombinedFailureMechanismSectionAssemblyFeatures(AssessmentSection assessmentSection) { if (assessmentSection == null) { throw new ArgumentNullException(nameof(assessmentSection)); } IEnumerable<CombinedFailureMechanismSectionAssemblyResult> assemblyResults; try { assemblyResults = AssessmentSectionAssemblyFactory.AssembleCombinedPerFailureMechanismSection(assessmentSection); } catch (AssemblyException) { return Array.Empty<MapFeature>(); } var mapFeatures = new List<MapFeature>(); foreach (CombinedFailureMechanismSectionAssemblyResult assemblyResult in assemblyResults) { IEnumerable<Point2D> geometry = FailureMechanismSectionHelper.GetFailureMechanismSectionGeometry( assessmentSection.ReferenceLine, assemblyResult.SectionStart, assemblyResult.SectionEnd); MapFeature mapFeature = RiskeerMapDataFeaturesFactory.CreateSingleLineMapFeature(geometry); mapFeature.MetaData[RiskeerCommonFormsResources.AssemblyGroup_DisplayName] = EnumDisplayNameHelper.GetDisplayName(assemblyResult.TotalResult); mapFeatures.Add(mapFeature); } return mapFeatures; }
/// <summary> /// Creates an <see cref="ExportableAssessmentSectionAssemblyResult"/> with the assembly result /// based on <paramref name="assessmentSection"/>. /// </summary> /// <param name="assessmentSection">The assessment section to create an <see cref="ExportableAssessmentSectionAssemblyResult"/> for.</param> /// <returns>An <see cref="ExportableAssessmentSectionAssemblyResult"/> with assembly result.</returns> /// <exception cref="AssemblyException">Thrown when assembly result cannot be created for <paramref name="assessmentSection"/>.</exception> private static ExportableAssessmentSectionAssemblyResult CreateExportableAssessmentSectionAssemblyResult(AssessmentSection assessmentSection) { AssessmentSectionAssemblyResultWrapper assemblyResultWrapper = AssessmentSectionAssemblyFactory.AssembleAssessmentSection(assessmentSection); AssessmentSectionAssemblyResult assemblyResult = assemblyResultWrapper.AssemblyResult; return(new ExportableAssessmentSectionAssemblyResult( assemblyResult.AssemblyGroup, assemblyResult.Probability, ExportableAssemblyMethodFactory.Create(assemblyResultWrapper.AssemblyGroupMethod), ExportableAssemblyMethodFactory.Create(assemblyResultWrapper.ProbabilityMethod))); }
public void AssembleAssessmentSection_AssessmentSectionNull_ThrowsArgumentNullException() { // Call void Call() => AssessmentSectionAssemblyFactory.AssembleAssessmentSection(null); // Assert var exception = Assert.Throws <ArgumentNullException>(Call); Assert.AreEqual("assessmentSection", exception.ParamName); }
public void GivenViewWithAssemblyResults_WhenFailureMechanismNotifiesObserver_ThenAssemblyResultsRefreshed() { // Given var random = new Random(21); AssessmentSection assessmentSection = CreateAssessmentSectionWithReferenceLine(); using (new AssemblyToolCalculatorFactoryConfig()) { var calculatorFactory = (TestAssemblyToolCalculatorFactory)AssemblyToolCalculatorFactory.Instance; AssessmentSectionAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedAssessmentSectionAssemblyCalculator; calculator.CombinedFailureMechanismSectionAssemblyOutput = new CombinedFailureMechanismSectionAssemblyResultWrapper( new[] { CombinedFailureMechanismSectionAssemblyTestFactory.Create(assessmentSection, 10) }, AssemblyMethod.BOI3A1, AssemblyMethod.BOI3B1, AssemblyMethod.BOI3C1); using (var view = new AssemblyResultPerSectionMapView(assessmentSection)) { // Precondition MapDataCollection mapData = view.Map.Data; var mocks = new MockRepository(); IObserver[] observers = AttachMapDataObservers(mocks, mapData.Collection); observers[referenceLineIndex].Expect(obs => obs.UpdateObserver()); observers[assemblyResultsObserverIndex].Expect(obs => obs.UpdateObserver()); mocks.ReplayAll(); IEnumerable <CombinedFailureMechanismSectionAssemblyResult> expectedResults = AssessmentSectionAssemblyFactory.AssembleCombinedPerFailureMechanismSection(assessmentSection); AssertCombinedFailureMechanismSectionAssemblyResultMapData(expectedResults, assessmentSection.ReferenceLine, mapData.Collection.ElementAt(assemblyResultsIndex)); // When calculator.CombinedFailureMechanismSectionAssemblyOutput = new CombinedFailureMechanismSectionAssemblyResultWrapper( new[] { CombinedFailureMechanismSectionAssemblyTestFactory.Create(assessmentSection, 20) }, AssemblyMethod.BOI3A1, AssemblyMethod.BOI3B1, AssemblyMethod.BOI3C1); IEnumerable <IFailureMechanism> failureMechanisms = assessmentSection.GetFailureMechanisms(); failureMechanisms.ElementAt(random.Next(failureMechanisms.Count())).NotifyObservers(); // Then expectedResults = AssessmentSectionAssemblyFactory.AssembleCombinedPerFailureMechanismSection(assessmentSection); AssertCombinedFailureMechanismSectionAssemblyResultMapData(expectedResults, assessmentSection.ReferenceLine, mapData.Collection.ElementAt(assemblyResultsIndex)); mocks.VerifyAll(); } } }
public void CreateCombinedFailureMechanismSectionAssemblyFeatures_WithAssessmentSection_ReturnsFeatureCollection() { // Setup var random = new Random(21); var assessmentSection = new AssessmentSection(random.NextEnumValue <AssessmentSectionComposition>()); assessmentSection.ReferenceLine.SetGeometry(new[] { new Point2D(0, 0), new Point2D(2, 2) }); using (new AssemblyToolCalculatorFactoryConfig()) { var calculatorFactory = (TestAssemblyToolCalculatorFactory)AssemblyToolCalculatorFactory.Instance; AssessmentSectionAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedAssessmentSectionAssemblyCalculator; CombinedFailureMechanismSectionAssembly[] failureMechanismSectionAssembly = { CombinedFailureMechanismSectionAssemblyTestFactory.Create(assessmentSection, 20), CombinedFailureMechanismSectionAssemblyTestFactory.Create(assessmentSection, 21) }; calculator.CombinedFailureMechanismSectionAssemblyOutput = new CombinedFailureMechanismSectionAssemblyResultWrapper( failureMechanismSectionAssembly, AssemblyMethod.BOI3A1, AssemblyMethod.BOI3B1, AssemblyMethod.BOI3C1); // Call IEnumerable <MapFeature> features = AssessmentSectionAssemblyMapDataFeaturesFactory.CreateCombinedFailureMechanismSectionAssemblyFeatures(assessmentSection); // Assert IEnumerable <CombinedFailureMechanismSectionAssemblyResult> expectedAssemblyResults = AssessmentSectionAssemblyFactory.AssembleCombinedPerFailureMechanismSection(assessmentSection); int expectedNrOfResults = expectedAssemblyResults.Count(); Assert.AreEqual(expectedNrOfResults, features.Count()); for (var i = 0; i < expectedNrOfResults; i++) { CombinedFailureMechanismSectionAssemblyResult expectedAssemblyResult = expectedAssemblyResults.ElementAt(i); MapFeature actualFeature = features.ElementAt(i); MapGeometry mapGeometry = actualFeature.MapGeometries.Single(); AssertEqualPointCollections(assessmentSection.ReferenceLine, expectedAssemblyResult, mapGeometry); Assert.AreEqual(1, actualFeature.MetaData.Keys.Count); Assert.AreEqual(EnumDisplayNameHelper.GetDisplayName(expectedAssemblyResult.TotalResult), features.ElementAt(i).MetaData["Duidingsklasse"]); } } }
private void UpdateTotalAssemblyGroupControl() { assessmentSectionAssemblyControl.ClearAssemblyResult(); assessmentSectionAssemblyControl.ClearErrors(); try { assessmentSectionAssemblyControl.SetAssemblyResult( AssessmentSectionAssemblyFactory.AssembleAssessmentSection(AssessmentSection).AssemblyResult); } catch (AssemblyException e) { assessmentSectionAssemblyControl.SetError(e.Message); } }
public void AssembleAssessmentSection_AssemblyRan_ReturnsOutput() { // Setup AssessmentSection assessmentSection = CreateAssessmentSectionContainingFailureMechanismsWithInAssemblyTrue(); using (new AssemblyToolCalculatorFactoryConfig()) { var calculatorFactory = (TestAssemblyToolCalculatorFactory)AssemblyToolCalculatorFactory.Instance; AssessmentSectionAssemblyCalculatorStub assessmentSectionAssemblyCalculator = calculatorFactory.LastCreatedAssessmentSectionAssemblyCalculator; // Call AssessmentSectionAssemblyResultWrapper result = AssessmentSectionAssemblyFactory.AssembleAssessmentSection(assessmentSection); // Assert Assert.AreSame(assessmentSectionAssemblyCalculator.AssessmentSectionAssemblyResult, result); } }
public void Constructor_WithAllData_DataUpdatedToCollectionOfFilledMapData() { // Setup AssessmentSection assessmentSection = CreateAssessmentSectionWithReferenceLine(); assessmentSection.SetHydraulicBoundaryLocationCalculations(new[] { new HydraulicBoundaryLocation(1, "test", 1.0, 2.0) }); // Call using (new AssemblyToolCalculatorFactoryConfig()) { var calculatorFactory = (TestAssemblyToolCalculatorFactory)AssemblyToolCalculatorFactory.Instance; AssessmentSectionAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedAssessmentSectionAssemblyCalculator; CombinedFailureMechanismSectionAssembly[] failureMechanismSectionAssembly = { CombinedFailureMechanismSectionAssemblyTestFactory.Create(assessmentSection, 21) }; calculator.CombinedFailureMechanismSectionAssemblyOutput = new CombinedFailureMechanismSectionAssemblyResultWrapper( failureMechanismSectionAssembly, AssemblyMethod.BOI3A1, AssemblyMethod.BOI3B1, AssemblyMethod.BOI3C1); using (var view = new AssemblyResultPerSectionMapView(assessmentSection)) { // Assert Assert.IsInstanceOf <MapDataCollection>(view.Map.Data); MapDataCollection mapData = view.Map.Data; Assert.IsNotNull(mapData); Assert.AreEqual(3, mapData.Collection.Count()); IEnumerable <CombinedFailureMechanismSectionAssemblyResult> expectedResults = AssessmentSectionAssemblyFactory.AssembleCombinedPerFailureMechanismSection(assessmentSection); AssertCombinedFailureMechanismSectionAssemblyResultMapData(expectedResults, assessmentSection.ReferenceLine, mapData.Collection.ElementAt(assemblyResultsIndex)); MapData hydraulicBoundaryLocationsMapData = mapData.Collection.ElementAt(hydraulicBoundaryLocationsIndex); MapDataTestHelper.AssertHydraulicBoundaryLocationsMapData(assessmentSection, hydraulicBoundaryLocationsMapData); MapData referenceLineMapData = mapData.Collection.ElementAt(referenceLineIndex); AssertReferenceLineMapData(assessmentSection.ReferenceLine, referenceLineMapData); } } }
public void AssembleAssessmentSection_FailureMechanismCalculatorThrowsException_ThrowsAssemblyException() { // Setup using (new AssemblyToolCalculatorFactoryConfig()) { var calculatorFactory = (TestAssemblyToolCalculatorFactory)AssemblyToolCalculatorFactory.Instance; FailureMechanismAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedFailureMechanismAssemblyCalculator; calculator.ThrowExceptionOnCalculate = true; // Call void Call() => AssessmentSectionAssemblyFactory.AssembleAssessmentSection(CreateAssessmentSectionContainingFailureMechanismsWithInAssemblyTrue()); // Assert var exception = Assert.Throws <AssemblyException>(Call); Exception innerException = exception.InnerException; Assert.IsInstanceOf <AssemblyException>(innerException); Assert.AreEqual("Voor een of meerdere faalmechanismen kan geen assemblageresultaat worden bepaald.", exception.Message); } }
public void AssembleAssessmentSection_CalculatorThrowsException_ThrowsAssemblyException() { // Setup using (new AssemblyToolCalculatorFactoryConfig()) { var calculatorFactory = (TestAssemblyToolCalculatorFactory)AssemblyToolCalculatorFactory.Instance; AssessmentSectionAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedAssessmentSectionAssemblyCalculator; calculator.ThrowExceptionOnCalculate = true; // Call void Call() => AssessmentSectionAssemblyFactory.AssembleAssessmentSection(CreateAssessmentSectionContainingFailureMechanismsWithInAssemblyTrue()); // Assert var exception = Assert.Throws <AssemblyException>(Call); Exception innerException = exception.InnerException; Assert.IsInstanceOf <AssessmentSectionAssemblyCalculatorException>(innerException); Assert.AreEqual(innerException.Message, exception.Message); } }
private void SetDataSource() { ClearCurrentData(); if (!AssessmentSection.ReferenceLine.Points.Any()) { return; } try { dataGridViewControl.SetDataSource(AssessmentSectionAssemblyFactory.AssembleCombinedPerFailureMechanismSection(AssessmentSection) .Select(r => new CombinedFailureMechanismSectionAssemblyResultRow(r)) .ToArray()); } catch (AssemblyException e) { errorProvider.SetError(refreshAssemblyResultsButton, e.Message); } }
public void AssembleCombinedPerFailureMechanismSection_CalculatorThrowsException_ThrowsAssemblyException() { // Setup var random = new Random(21); AssessmentSection assessmentSection = TestDataGenerator.GetAssessmentSectionWithAllFailureMechanismSectionsAndResults( random.NextEnumValue <AssessmentSectionComposition>()); using (new AssemblyToolCalculatorFactoryConfig()) { var calculatorFactory = (TestAssemblyToolCalculatorFactory)AssemblyToolCalculatorFactory.Instance; AssessmentSectionAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedAssessmentSectionAssemblyCalculator; calculator.ThrowExceptionOnCalculate = true; // Call void Call() => AssessmentSectionAssemblyFactory.AssembleCombinedPerFailureMechanismSection(assessmentSection); // Assert var exception = Assert.Throws <AssemblyException>(Call); Exception innerException = exception.InnerException; Assert.IsInstanceOf <AssessmentSectionAssemblyCalculatorException>(innerException); Assert.AreEqual(innerException.Message, exception.Message); } }
public void AssembleCombinedPerFailureMechanismSection_WithAssessmentSection_SetsInputOnCalculator(bool failureMechanismSectionAssemblyThrowsException) { var random = new Random(21); AssessmentSection assessmentSection = TestDataGenerator.GetAssessmentSectionWithAllFailureMechanismSectionsAndResults( random.NextEnumValue <AssessmentSectionComposition>()); using (new AssemblyToolCalculatorFactoryConfig()) { var calculatorFactory = (TestAssemblyToolCalculatorFactory)AssemblyToolCalculatorFactory.Instance; FailureMechanismSectionAssemblyCalculatorStub failureMechanismSectionAssemblyCalculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator; failureMechanismSectionAssemblyCalculator.ThrowExceptionOnCalculate = failureMechanismSectionAssemblyThrowsException; // Call AssessmentSectionAssemblyFactory.AssembleCombinedPerFailureMechanismSection(assessmentSection); // Assert AssessmentSectionAssemblyCalculatorStub assessmentSectionAssemblyCalculator = calculatorFactory.LastCreatedAssessmentSectionAssemblyCalculator; IEnumerable <CombinedAssemblyFailureMechanismSection>[] actualInput = assessmentSectionAssemblyCalculator.CombinedFailureMechanismSectionsInput.ToArray(); IEnumerable <CombinedAssemblyFailureMechanismSection>[] expectedInput = CombinedAssemblyFailureMechanismSectionFactory.CreateInput( assessmentSection, assessmentSection.GetFailureMechanisms().Concat(assessmentSection.SpecificFailureMechanisms)).ToArray(); Assert.AreEqual(expectedInput.Length, actualInput.Length); for (var i = 0; i < expectedInput.Length; i++) { CombinedAssemblyFailureMechanismSection[] actualSections = actualInput[i].ToArray(); CombinedAssemblyFailureMechanismSection[] expectedSections = expectedInput[i].ToArray(); Assert.AreEqual(expectedSections.Length, actualSections.Length); for (var j = 0; j < expectedSections.Length; j++) { Assert.AreEqual(expectedSections[j].SectionStart, actualSections[j].SectionStart); Assert.AreEqual(expectedSections[j].SectionEnd, actualSections[j].SectionEnd); Assert.AreEqual(expectedSections[j].FailureMechanismSectionAssemblyGroup, actualSections[j].FailureMechanismSectionAssemblyGroup); } } } }
/// <summary> /// Creates a collection of <see cref="ExportableCombinedSectionAssembly"/> based on <paramref name="assessmentSection"/>. /// </summary> /// <param name="assessmentSection">The assessment section to create a collection of <see cref="ExportableCombinedSectionAssembly"/> for.</param> /// <returns>A <see cref="CreateExportableCombinedSectionAssemblyCollection"/>.</returns> /// <exception cref="AssemblyException">Thrown when assembly results cannot be created for <paramref name="assessmentSection"/>.</exception> private static IEnumerable <ExportableCombinedSectionAssembly> CreateExportableCombinedSectionAssemblyCollection(AssessmentSection assessmentSection) { return(ExportableCombinedSectionAssemblyFactory.CreateExportableCombinedSectionAssemblyCollection( AssessmentSectionAssemblyFactory.AssembleCombinedPerFailureMechanismSection(assessmentSection), assessmentSection)); }
public void AssembleCombinedPerFailureMechanismSection_AssemblyRan_ReturnsOutput() { var random = new Random(21); AssessmentSection assessmentSection = TestDataGenerator.GetAssessmentSectionWithAllFailureMechanismSectionsAndResults( random.NextEnumValue <AssessmentSectionComposition>()); using (new AssemblyToolCalculatorFactoryConfig()) { var calculatorFactory = (TestAssemblyToolCalculatorFactory)AssemblyToolCalculatorFactory.Instance; AssessmentSectionAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedAssessmentSectionAssemblyCalculator; calculator.CombinedFailureMechanismSectionAssemblyOutput = new CombinedFailureMechanismSectionAssemblyResultWrapper( new[] { CombinedFailureMechanismSectionAssemblyTestFactory.Create(assessmentSection, 20), CombinedFailureMechanismSectionAssemblyTestFactory.Create(assessmentSection, 21) }, AssemblyMethod.BOI3A1, AssemblyMethod.BOI3B1, AssemblyMethod.BOI3C1); // Call CombinedFailureMechanismSectionAssemblyResult[] output = AssessmentSectionAssemblyFactory.AssembleCombinedPerFailureMechanismSection( assessmentSection) .ToArray(); // Assert Dictionary <IFailureMechanism, int> failureMechanisms = assessmentSection.GetFailureMechanisms() .Concat(assessmentSection.SpecificFailureMechanisms) .Where(fm => fm.InAssembly) .Select((fm, i) => new { FailureMechanism = fm, Index = i }) .ToDictionary(x => x.FailureMechanism, x => x.Index); CombinedFailureMechanismSectionAssemblyResult[] expectedOutput = CombinedFailureMechanismSectionAssemblyResultFactory.Create( calculator.CombinedFailureMechanismSectionAssemblyOutput, failureMechanisms, assessmentSection).ToArray(); Assert.AreEqual(expectedOutput.Length, output.Length); for (var i = 0; i < expectedOutput.Length; i++) { Assert.AreEqual(expectedOutput[i].SectionStart, output[i].SectionStart); Assert.AreEqual(expectedOutput[i].SectionEnd, output[i].SectionEnd); Assert.AreEqual(expectedOutput[i].TotalResult, output[i].TotalResult); Assert.AreEqual(expectedOutput[i].Piping, output[i].Piping); Assert.AreEqual(expectedOutput[i].GrassCoverErosionInwards, output[i].GrassCoverErosionInwards); Assert.AreEqual(expectedOutput[i].MacroStabilityInwards, output[i].MacroStabilityInwards); Assert.AreEqual(expectedOutput[i].Microstability, output[i].Microstability); Assert.AreEqual(expectedOutput[i].StabilityStoneCover, output[i].StabilityStoneCover); Assert.AreEqual(expectedOutput[i].WaveImpactAsphaltCover, output[i].WaveImpactAsphaltCover); Assert.AreEqual(expectedOutput[i].WaterPressureAsphaltCover, output[i].WaterPressureAsphaltCover); Assert.AreEqual(expectedOutput[i].GrassCoverErosionOutwards, output[i].GrassCoverErosionOutwards); Assert.AreEqual(expectedOutput[i].GrassCoverSlipOffOutwards, output[i].GrassCoverSlipOffOutwards); Assert.AreEqual(expectedOutput[i].GrassCoverSlipOffInwards, output[i].GrassCoverSlipOffInwards); Assert.AreEqual(expectedOutput[i].HeightStructures, output[i].HeightStructures); Assert.AreEqual(expectedOutput[i].ClosingStructures, output[i].ClosingStructures); Assert.AreEqual(expectedOutput[i].PipingStructure, output[i].PipingStructure); Assert.AreEqual(expectedOutput[i].StabilityPointStructures, output[i].StabilityPointStructures); Assert.AreEqual(expectedOutput[i].DuneErosion, output[i].DuneErosion); CollectionAssert.AreEqual(expectedOutput[i].SpecificFailureMechanisms, output[i].SpecificFailureMechanisms); Assert.AreEqual(expectedOutput[i].CommonSectionAssemblyMethod, output[i].CommonSectionAssemblyMethod); Assert.AreEqual(expectedOutput[i].FailureMechanismResultsAssemblyMethod, output[i].FailureMechanismResultsAssemblyMethod); Assert.AreEqual(expectedOutput[i].CombinedSectionResultAssemblyMethod, output[i].CombinedSectionResultAssemblyMethod); } } }