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); } }
public void MaximumAllowableFloodingProbability_SignalFloodingProbabilityBiggerThanMaximumAllowableFloodingProbability_ThrowsArgumentOutOfRangeException() { // Setup const double probability = 1.0 / 30000; const double newMaximumAllowableFloodingProbability = 1.0 / 1000000; var failureMechanismContribution = new FailureMechanismContribution(probability, probability); // Call void Call() => failureMechanismContribution.MaximumAllowableFloodingProbability = newMaximumAllowableFloodingProbability; // Assert const string expectedMessage = "De omgevingswaarde moet gelijk zijn aan of groter zijn dan de signaleringsparameter."; var exception = Assert.Throws <ArgumentOutOfRangeException>(Call); StringAssert.StartsWith(expectedMessage, exception.Message); Assert.AreEqual(newMaximumAllowableFloodingProbability, exception.ActualValue); }
/// <summary> /// Creates a <see cref="AssessmentSectionEntity"/> based on the information of the <see cref="AssessmentSection"/>. /// </summary> /// <param name="section">The section to create a database entity for.</param> /// <param name="registry">The object keeping track of create operations.</param> /// <returns>A new <see cref="AssessmentSectionEntity"/>.</returns> /// <exception cref="ArgumentNullException">Thrown when <paramref name="registry"/> is <c>null</c>.</exception> internal static AssessmentSectionEntity Create(this AssessmentSection section, PersistenceRegistry registry) { if (registry == null) { throw new ArgumentNullException(nameof(registry)); } FailureMechanismContribution contribution = section.FailureMechanismContribution; var entity = new AssessmentSectionEntity { Id = section.Id.DeepClone(), Name = section.Name.DeepClone(), Composition = Convert.ToByte(section.Composition), Comments = section.Comments.Body.DeepClone(), MaximumAllowableFloodingProbability = contribution.MaximumAllowableFloodingProbability, SignalFloodingProbability = contribution.SignalFloodingProbability, NormativeProbabilityType = Convert.ToByte(contribution.NormativeProbabilityType) }; AddEntityForHydraulicDatabase(section.HydraulicBoundaryDatabase, entity, registry); AddHydraulicLocationCalculationEntities(section, entity, registry); AddHydraulicLocationCalculationForTargetProbabilityCollectionEntities(section, entity, registry); AddEntityForReferenceLine(section, entity); entity.BackgroundDataEntities.Add(section.BackgroundData.Create()); entity.FailureMechanismEntities.Add(section.Piping.Create(registry)); entity.FailureMechanismEntities.Add(section.GrassCoverErosionInwards.Create(registry)); entity.FailureMechanismEntities.Add(section.HeightStructures.Create(registry)); entity.FailureMechanismEntities.Add(section.WaterPressureAsphaltCover.Create(registry)); entity.FailureMechanismEntities.Add(section.ClosingStructures.Create(registry)); entity.FailureMechanismEntities.Add(section.MacroStabilityInwards.Create(registry)); entity.FailureMechanismEntities.Add(section.WaveImpactAsphaltCover.Create(registry)); entity.FailureMechanismEntities.Add(section.GrassCoverErosionOutwards.Create(registry)); entity.FailureMechanismEntities.Add(section.GrassCoverSlipOffInwards.Create(registry)); entity.FailureMechanismEntities.Add(section.GrassCoverSlipOffOutwards.Create(registry)); entity.FailureMechanismEntities.Add(section.Microstability.Create(registry)); entity.FailureMechanismEntities.Add(section.PipingStructure.Create(registry)); entity.FailureMechanismEntities.Add(section.StabilityStoneCover.Create(registry)); entity.FailureMechanismEntities.Add(section.DuneErosion.Create(registry)); entity.FailureMechanismEntities.Add(section.StabilityPointStructures.Create(registry)); AddSpecificFailureMechanismEntities(section, entity, registry); return(entity); }
public void AssembleSection_WithInput_SetsInputOnCalculator() { // Setup var random = new Random(21); FailureMechanismSection section = FailureMechanismSectionTestFactory.CreateFailureMechanismSection(); var sectionResult = new AdoptableWithProfileProbabilityFailureMechanismSectionResult(section) { IsRelevant = random.NextBoolean(), InitialFailureMechanismResultType = AdoptableInitialFailureMechanismResultType.Manual, ManualInitialFailureMechanismResultProfileProbability = random.NextDouble(), ManualInitialFailureMechanismResultSectionProbability = random.NextDouble(), FurtherAnalysisType = random.NextEnumValue <FailureMechanismSectionResultFurtherAnalysisType>(), ProbabilityRefinementType = ProbabilityRefinementType.Both, RefinedProfileProbability = random.NextDouble(), RefinedSectionProbability = random.NextDouble() }; var failureMechanism = new MacroStabilityInwardsFailureMechanism(); var assessmentSection = new AssessmentSectionStub(); using (new AssemblyToolCalculatorFactoryConfig()) { var calculatorFactory = (TestAssemblyToolCalculatorFactory)AssemblyToolCalculatorFactory.Instance; FailureMechanismSectionAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator; // Call MacroStabilityInwardsFailureMechanismAssemblyFactory.AssembleSection(sectionResult, failureMechanism, assessmentSection); // Assert FailureMechanismSectionWithProfileProbabilityAssemblyInput calculatorInput = calculator.FailureMechanismSectionWithProfileProbabilityAssemblyInput; FailureMechanismContribution failureMechanismContribution = assessmentSection.FailureMechanismContribution; Assert.AreEqual(failureMechanismContribution.SignalFloodingProbability, calculatorInput.SignalFloodingProbability); Assert.AreEqual(failureMechanismContribution.MaximumAllowableFloodingProbability, calculatorInput.MaximumAllowableFloodingProbability); Assert.AreEqual(sectionResult.IsRelevant, calculatorInput.IsRelevant); Assert.IsTrue(calculatorInput.HasProbabilitySpecified); Assert.AreEqual(sectionResult.ManualInitialFailureMechanismResultProfileProbability, calculatorInput.InitialProfileProbability); Assert.AreEqual(sectionResult.ManualInitialFailureMechanismResultSectionProbability, calculatorInput.InitialSectionProbability); Assert.AreEqual(sectionResult.FurtherAnalysisType, calculatorInput.FurtherAnalysisType); Assert.AreEqual(sectionResult.RefinedProfileProbability, calculatorInput.RefinedProfileProbability); Assert.AreEqual(sectionResult.RefinedSectionProbability, calculatorInput.RefinedSectionProbability); } }
public void GivenDataModelWithUnmatchableTargetProbabilities_WhenImporting_ThenLogMessageAndContinueImport( FailureMechanismContribution failureMechanismContribution, IEnumerable <HydraulicBoundaryLocationCalculationsForTargetProbability> calculationsForTargetProbabilities) { // Setup string filePath = Path.Combine(path, "validConfigurationFullCalculation.xml"); var calculationGroup = new CalculationGroup(); var hydraulicBoundaryLocation = new HydraulicBoundaryLocation(1, "Locatie", 10, 20); var foreshoreProfile = new ForeshoreProfile(new Point2D(0, 0), new[] { new Point2D(0, 0), new Point2D(1, 1), new Point2D(2, 2) }, new BreakWater(BreakWaterType.Caisson, 0), new ForeshoreProfile.ConstructionProperties { Id = "Voorlandprofiel", Name = "VoorlandProfielName" }); var importer = new TestWaveConditionsCalculationConfigurationImporter( filePath, calculationGroup, new[] { hydraulicBoundaryLocation }, new[] { foreshoreProfile }, failureMechanismContribution, calculationsForTargetProbabilities); // Call var successful = false; Action call = () => successful = importer.Import(); // Assert const string expectedMessage = "De doelkans '0.01' kan niet worden gevonden en kan daarom niet gebruikt worden. Berekening 'Berekening 1' is overgeslagen."; TestHelper.AssertLogMessageWithLevelIsGenerated(call, Tuple.Create(expectedMessage, LogLevelConstant.Error), 2); Assert.IsTrue(successful); CollectionAssert.IsEmpty(calculationGroup.Children); }
/// <summary> /// Creates a new instance of <see cref="AssessmentSectionAssemblyGroupsView"/>. /// </summary> /// <param name="failureMechanismContribution">The failure mechanism contribution belonging to the view.</param> /// <exception cref="ArgumentNullException">Thrown when <paramref name="failureMechanismContribution"/> /// is <c>null</c>.</exception> public AssessmentSectionAssemblyGroupsView(FailureMechanismContribution failureMechanismContribution) { if (failureMechanismContribution == null) { throw new ArgumentNullException(nameof(failureMechanismContribution)); } InitializeComponent(); failureMechanismContributionObserver = new Observer(UpdateTableData) { Observable = failureMechanismContribution }; FailureMechanismContribution = failureMechanismContribution; UpdateTableData(); }
public void Constructor_Always_PropertiesHaveExpectedAttributesValues() { // Setup var mocks = new MockRepository(); var failureMechanismContributionNormChangeHandler = mocks.Stub <IFailureMechanismContributionNormChangeHandler>(); mocks.ReplayAll(); FailureMechanismContribution failureMechanismContribution = FailureMechanismContributionTestFactory.CreateFailureMechanismContribution(); // Call var properties = new NormProperties(failureMechanismContribution, failureMechanismContributionNormChangeHandler); // Assert PropertyDescriptorCollection dynamicProperties = PropertiesTestHelper.GetAllVisiblePropertyDescriptors(properties); Assert.AreEqual(3, dynamicProperties.Count); const string expectedCategory = "Algemeen"; PropertyDescriptor maximumAllowableFloodingProbabilityProperty = dynamicProperties[0]; PropertiesTestHelper.AssertRequiredPropertyDescriptorProperties(maximumAllowableFloodingProbabilityProperty, expectedCategory, "Omgevingswaarde [1/jaar]", "De maximale toelaatbare overstromingskans van het traject."); PropertyDescriptor signalFloodingProbabilityProperty = dynamicProperties[1]; PropertiesTestHelper.AssertRequiredPropertyDescriptorProperties(signalFloodingProbabilityProperty, expectedCategory, "Signaleringsparameter [1/jaar]", "De overstromingskans voor de signalering over de veiligheid van het traject."); PropertyDescriptor normativeProbabilityTypeProperty = dynamicProperties[2]; PropertiesTestHelper.AssertRequiredPropertyDescriptorProperties(normativeProbabilityTypeProperty, expectedCategory, "Rekenwaarde voor waterstanden", "De doelkans die wordt gebruikt om de lokale waterstand te bepalen voor de semi-probabilistische toets voor 'Piping' en 'Macrostabiliteit binnenwaarts'."); mocks.VerifyAll(); }
public void GetProperties_WithData_ReturnExpectedValues() { // Setup var mocks = new MockRepository(); var failureMechanismContributionNormChangeHandler = mocks.Stub <IFailureMechanismContributionNormChangeHandler>(); mocks.ReplayAll(); FailureMechanismContribution failureMechanismContribution = FailureMechanismContributionTestFactory.CreateFailureMechanismContribution(); // Call var properties = new NormProperties(failureMechanismContribution, failureMechanismContributionNormChangeHandler); // Assert Assert.AreEqual(failureMechanismContribution.MaximumAllowableFloodingProbability, properties.MaximumAllowableFloodingProbability); Assert.AreEqual(failureMechanismContribution.SignalFloodingProbability, properties.SignalFloodingProbability); Assert.AreEqual(failureMechanismContribution.NormativeProbabilityType, properties.NormativeProbabilityType); mocks.VerifyAll(); }
public void Constructor_ExpectedValues() { // Setup var mocks = new MockRepository(); var assessmentSection = mocks.Stub <IAssessmentSection>(); mocks.ReplayAll(); FailureMechanismContribution contribution = FailureMechanismContributionTestFactory.CreateFailureMechanismContribution(); // Call var context = new NormContext(contribution, assessmentSection); // Assert Assert.IsInstanceOf <ObservableWrappedObjectContextBase <FailureMechanismContribution> >(context); Assert.AreSame(contribution, context.WrappedData); Assert.AreSame(assessmentSection, context.AssessmentSection); mocks.VerifyAll(); }
private AssessmentSectionAssemblyGroupProperties[] GetAssessmentSectionAssemblyGroups() { FailureMechanismContribution contribution = data.FailureMechanismContribution; AssessmentSectionAssemblyGroupProperties[] dataToSet; try { dataToSet = AssessmentSectionAssemblyGroupBoundariesFactory.CreateAssessmentSectionAssemblyGroupBoundaries(contribution.SignalFloodingProbability, contribution.MaximumAllowableFloodingProbability) .Select(assemblyGroupBoundaries => new AssessmentSectionAssemblyGroupProperties(assemblyGroupBoundaries)) .ToArray(); } catch (AssemblyException) { dataToSet = Array.Empty <AssessmentSectionAssemblyGroupProperties>(); } return(dataToSet); }
public void GivenViewWithFailureMechanismContribution_WhenFailureMechanismContributionUpdated_ThenDataTableUpdated() { // Given var random = new Random(21); var mocks = new MockRepository(); var observer = mocks.StrictMock <IObserver>(); observer.Expect(o => o.UpdateObserver()); mocks.ReplayAll(); FailureMechanismContribution failureMechanismContribution = FailureMechanismContributionTestFactory.CreateFailureMechanismContribution(); failureMechanismContribution.Attach(observer); using (new AssemblyToolCalculatorFactoryConfig()) using (var view = new AssessmentSectionAssemblyGroupsView(failureMechanismContribution)) { var calculatorFactory = (TestAssemblyToolCalculatorFactory)AssemblyToolCalculatorFactory.Instance; AssessmentSectionAssemblyGroupBoundariesCalculatorStub calculator = calculatorFactory.LastCreatedAssessmentSectionAssemblyGroupBoundariesCalculator; AssemblyGroupsTable <AssessmentSectionAssemblyGroup> groupsTable = GetCategoriesTable(view); // Precondition Assert.AreEqual(calculator.AssessmentSectionAssemblyGroupBoundariesOutput.Count(), groupsTable.Rows.Count); // When var newOutput = new[] { new AssessmentSectionAssemblyGroupBoundaries(random.NextDouble(), random.NextDouble(), random.NextEnumValue <AssessmentSectionAssemblyGroup>()) }; calculator.AssessmentSectionAssemblyGroupBoundariesOutput = newOutput; failureMechanismContribution.NotifyObservers(); // Then Assert.AreEqual(newOutput.Length, groupsTable.Rows.Count); } mocks.VerifyAll(); }
/// <summary> /// Initializes a new instance of the <see cref="AssessmentSection"/> class. /// </summary> /// <param name="composition">The composition of the assessment section, e.g. what /// type of elements can be found within the assessment section.</param> /// <param name="maximumAllowableFloodingProbability">The maximum allowable flooding probability of the assessment section.</param> /// <param name="signalFloodingProbability">The signal flooding probability of the assessment section.</param> /// <exception cref="ArgumentOutOfRangeException">Thrown when: /// <list type="bullet"> /// <item><paramref name="maximumAllowableFloodingProbability"/> is not in the interval [0.000001, 0.1] or is <see cref="double.NaN"/>;</item> /// <item><paramref name="signalFloodingProbability"/> is not in the interval [0.000001, 0.1] or is <see cref="double.NaN"/>;</item> /// <item>The <paramref name="signalFloodingProbability"/> is larger than <paramref name="maximumAllowableFloodingProbability"/>.</item> /// </list> /// </exception> /// <exception cref="InvalidEnumArgumentException">Thrown when <paramref name="composition"/> /// is not a valid enum value of <see cref="AssessmentSectionComposition"/>.</exception> /// <exception cref="NotSupportedException">Thrown when <paramref name="composition"/> /// is not supported.</exception> public AssessmentSection(AssessmentSectionComposition composition, double maximumAllowableFloodingProbability = defaultFloodingProbability, double signalFloodingProbability = defaultFloodingProbability) { Name = Resources.AssessmentSection_DisplayName; Comments = new Comment(); BackgroundData = new BackgroundData(new WellKnownBackgroundDataConfiguration(defaultWellKnownTileSource)) { Name = defaultWellKnownTileSource.GetDisplayName() }; ReferenceLine = new ReferenceLine(); HydraulicBoundaryDatabase = new HydraulicBoundaryDatabase(); SpecificFailureMechanisms = new ObservableList <SpecificFailureMechanism>(); waterLevelCalculationsForSignalFloodingProbability = new ObservableList <HydraulicBoundaryLocationCalculation>(); waterLevelCalculationsForMaximumAllowableFloodingProbability = new ObservableList <HydraulicBoundaryLocationCalculation>(); WaterLevelCalculationsForUserDefinedTargetProbabilities = new ObservableList <HydraulicBoundaryLocationCalculationsForTargetProbability>(); WaveHeightCalculationsForUserDefinedTargetProbabilities = new ObservableList <HydraulicBoundaryLocationCalculationsForTargetProbability>(); Piping = new PipingFailureMechanism(); GrassCoverErosionInwards = new GrassCoverErosionInwardsFailureMechanism(); MacroStabilityInwards = new MacroStabilityInwardsFailureMechanism(); Microstability = new MicrostabilityFailureMechanism(); StabilityStoneCover = new StabilityStoneCoverFailureMechanism(); WaveImpactAsphaltCover = new WaveImpactAsphaltCoverFailureMechanism(); WaterPressureAsphaltCover = new WaterPressureAsphaltCoverFailureMechanism(); GrassCoverErosionOutwards = new GrassCoverErosionOutwardsFailureMechanism(); GrassCoverSlipOffOutwards = new GrassCoverSlipOffOutwardsFailureMechanism(); GrassCoverSlipOffInwards = new GrassCoverSlipOffInwardsFailureMechanism(); HeightStructures = new HeightStructuresFailureMechanism(); ClosingStructures = new ClosingStructuresFailureMechanism(); StabilityPointStructures = new StabilityPointStructuresFailureMechanism(); PipingStructure = new PipingStructureFailureMechanism(); DuneErosion = new DuneErosionFailureMechanism(); FailureMechanismContribution = new FailureMechanismContribution(maximumAllowableFloodingProbability, signalFloodingProbability); ChangeComposition(composition); }
public void Constructor_WithFailureMechanismContribution_CreatesViewAndTableWithData() { // Setup FailureMechanismContribution failureMechanismContribution = FailureMechanismContributionTestFactory.CreateFailureMechanismContribution(); // Call using (new AssemblyToolCalculatorFactoryConfig()) using (var view = new AssessmentSectionAssemblyGroupsView(failureMechanismContribution)) { // Assert Assert.IsInstanceOf <UserControl>(view); Assert.IsInstanceOf <IView>(view); Assert.IsNull(view.Data); Assert.AreEqual(1, view.Controls.Count); Assert.AreSame(failureMechanismContribution, view.FailureMechanismContribution); AssemblyGroupsTable <AssessmentSectionAssemblyGroup> tableControl = GetCategoriesTable(view); Assert.AreEqual(DockStyle.Fill, tableControl.Dock); var calculatorFactory = (TestAssemblyToolCalculatorFactory)AssemblyToolCalculatorFactory.Instance; AssessmentSectionAssemblyGroupBoundariesCalculatorStub calculator = calculatorFactory.LastCreatedAssessmentSectionAssemblyGroupBoundariesCalculator; Assert.AreEqual(calculator.AssessmentSectionAssemblyGroupBoundariesOutput.Count(), tableControl.Rows.Count); } }
public void GivenMapLayerWithHydraulicBoundaryLocationsData_WhenFailureMechanismContributionUpdatedAndNotified_ThenMapDataUpdated() { // Given var mocks = new MockRepository(); var observer = mocks.StrictMock <IObserver>(); observer.Expect(o => o.UpdateObserver()); mocks.ReplayAll(); var assessmentSection = new AssessmentSectionStub(); assessmentSection.SetHydraulicBoundaryLocationCalculations(new[] { new HydraulicBoundaryLocation(1, "test1", 1.0, 2.0) }); using (var mapLayer = new HydraulicBoundaryLocationsMapLayer(assessmentSection)) { mapLayer.MapData.Attach(observer); // Precondition MapDataTestHelper.AssertHydraulicBoundaryLocationsMapData(assessmentSection, mapLayer.MapData); // When var random = new Random(21); FailureMechanismContribution contribution = assessmentSection.FailureMechanismContribution; contribution.MaximumAllowableFloodingProbability = random.NextDouble(0.000001, 0.1); contribution.SignalFloodingProbability = contribution.MaximumAllowableFloodingProbability - 0.000001; contribution.NotifyObservers(); // Then MapDataTestHelper.AssertHydraulicBoundaryLocationsMapData(assessmentSection, mapLayer.MapData); } mocks.VerifyAll(); }
/// <inheritdoc /> /// <summary> /// Creates a new instance of <see cref="GrassCoverErosionOutwardsWaveConditionsCalculationConfigurationImporter"/>. /// </summary> public GrassCoverErosionOutwardsWaveConditionsCalculationConfigurationImporter(string xmlFilePath, CalculationGroup importTarget, IEnumerable <HydraulicBoundaryLocation> hydraulicBoundaryLocations, IEnumerable <ForeshoreProfile> foreshoreProfiles, FailureMechanismContribution failureMechanismContribution, IEnumerable <HydraulicBoundaryLocationCalculationsForTargetProbability> calculationsForTargetProbabilities) : base(xmlFilePath, importTarget, hydraulicBoundaryLocations, foreshoreProfiles, failureMechanismContribution, calculationsForTargetProbabilities) { }
public void Import_ValidConfigurationWithValidData_DataAddedToModel(FailureMechanismContribution failureMechanismContribution, HydraulicBoundaryLocationCalculationsForTargetProbability calculationsForTargetProbability, WaveConditionsInputWaterLevelType expectedWaterLevelType) { // Setup string filePath = Path.Combine(path, "validConfigurationFullCalculation.xml"); var calculationGroup = new CalculationGroup(); var hydraulicBoundaryLocation = new HydraulicBoundaryLocation(1, "Locatie", 10, 20); var foreshoreProfile = new ForeshoreProfile(new Point2D(0, 0), new[] { new Point2D(0, 0), new Point2D(1, 1), new Point2D(2, 2) }, new BreakWater(BreakWaterType.Caisson, 0), new ForeshoreProfile.ConstructionProperties { Id = "Voorlandprofiel", Name = "VoorlandProfielName" }); var importer = new TestWaveConditionsCalculationConfigurationImporter( filePath, calculationGroup, new[] { hydraulicBoundaryLocation }, new[] { foreshoreProfile }, failureMechanismContribution, new[] { calculationsForTargetProbability }); // Call var successful = false; Action call = () => successful = importer.Import(); // Assert TestHelper.AssertLogMessageIsGenerated(call, $"Gegevens zijn geïmporteerd vanuit bestand '{filePath}'.", 1); Assert.IsTrue(successful); var expectedCalculation = new TestTargetTestWaveConditionsCalculation { Name = "Berekening 1", InputParameters = { HydraulicBoundaryLocation = hydraulicBoundaryLocation, CalculationsTargetProbability = expectedWaterLevelType == WaveConditionsInputWaterLevelType.UserDefinedTargetProbability ? calculationsForTargetProbability : null, WaterLevelType = expectedWaterLevelType, UpperBoundaryRevetment = (RoundedDouble)10, LowerBoundaryRevetment = (RoundedDouble)2, UpperBoundaryWaterLevels = (RoundedDouble)9, LowerBoundaryWaterLevels = (RoundedDouble)4, StepSize = WaveConditionsInputStepSize.Half, ForeshoreProfile = foreshoreProfile, Orientation = (RoundedDouble)5.5, UseForeshore = false, UseBreakWater = true, BreakWater = { Height = (RoundedDouble)6.6, Type = BreakWaterType.Caisson } } }; Assert.AreEqual(1, calculationGroup.Children.Count); AssertWaveConditionsCalculation(expectedCalculation, (ICalculation <WaveConditionsInput>)calculationGroup.Children[0]); }
public void AssembleSectionAdoptableWithProfileProbability_WithInputAndUseLengthEffectTrue_SetsInputOnCalculator( AdoptableInitialFailureMechanismResultType initialFailureMechanismResultType, bool expectedHasProbabilitySpecified) { // Setup var random = new Random(21); bool isRelevant = random.NextBoolean(); double manualInitialProfileProbability = random.NextDouble(); double manualInitialSectionProbability = random.NextDouble(); double calculatedStrategySectionProbability = random.NextDouble(); double calculatedStrategyProfileSectionProbability = random.NextDouble(); var furtherAnalysisType = random.NextEnumValue <FailureMechanismSectionResultFurtherAnalysisType>(); double manualRefinedSectionProbability = random.NextDouble(); double manualRefinedProfileProbability = random.NextDouble(); var mocks = new MockRepository(); var calculateStrategy = mocks.StrictMock <IFailureMechanismSectionResultCalculateProbabilityStrategy>(); bool isInitialFailureMechanismResultTypeAdopt = IsInitialFailureMechanismResultTypeAdopt(initialFailureMechanismResultType); if (isInitialFailureMechanismResultTypeAdopt) { calculateStrategy.Expect(cs => cs.CalculateProfileProbability()) .Return(calculatedStrategyProfileSectionProbability); calculateStrategy.Expect(cs => cs.CalculateSectionProbability()) .Return(calculatedStrategySectionProbability); } mocks.ReplayAll(); var assessmentSection = new AssessmentSectionStub(); var sectionResult = new AdoptableWithProfileProbabilityFailureMechanismSectionResult(FailureMechanismSectionTestFactory.CreateFailureMechanismSection()) { IsRelevant = isRelevant, InitialFailureMechanismResultType = initialFailureMechanismResultType, ManualInitialFailureMechanismResultProfileProbability = manualInitialProfileProbability, ManualInitialFailureMechanismResultSectionProbability = manualInitialSectionProbability, FurtherAnalysisType = furtherAnalysisType, ProbabilityRefinementType = ProbabilityRefinementType.Both, RefinedProfileProbability = manualRefinedProfileProbability, RefinedSectionProbability = manualRefinedSectionProbability }; using (new AssemblyToolCalculatorFactoryConfig()) { var calculatorFactory = (TestAssemblyToolCalculatorFactory)AssemblyToolCalculatorFactory.Instance; FailureMechanismSectionAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator; // Call FailureMechanismSectionAssemblyResultFactory.AssembleSection( sectionResult, assessmentSection, calculateStrategy, true, random.NextDouble()); // Assert FailureMechanismSectionWithProfileProbabilityAssemblyInput calculatorInput = calculator.FailureMechanismSectionWithProfileProbabilityAssemblyInput; 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 expectedInitialProfileProbability = isInitialFailureMechanismResultTypeAdopt ? calculatedStrategyProfileSectionProbability : manualInitialProfileProbability; Assert.AreEqual(expectedInitialProfileProbability, calculatorInput.InitialProfileProbability); double expectedInitialSectionProbability = isInitialFailureMechanismResultTypeAdopt ? calculatedStrategySectionProbability : manualInitialSectionProbability; Assert.AreEqual(expectedInitialSectionProbability, calculatorInput.InitialSectionProbability); Assert.AreEqual(furtherAnalysisType, calculatorInput.FurtherAnalysisType); Assert.AreEqual(manualRefinedProfileProbability, calculatorInput.RefinedProfileProbability); Assert.AreEqual(manualRefinedSectionProbability, calculatorInput.RefinedSectionProbability); } }