public void CreateCalculationActivity_WithValidCalculation_ReturnsGrassCoverErosionOutwardsWaveConditionsCalculationActivityWithParametersSet() { // Setup GrassCoverErosionOutwardsFailureMechanism failureMechanism = new GrassCoverErosionOutwardsFailureMechanism(); var assessmentSection = new AssessmentSectionStub(); HydraulicBoundaryDatabase hydraulicBoundaryDatabase = assessmentSection.HydraulicBoundaryDatabase; hydraulicBoundaryDatabase.FilePath = validFilePath; var hydraulicBoundaryLocation = new TestHydraulicBoundaryLocation("locationName 1"); assessmentSection.SetHydraulicBoundaryLocationCalculations(new[] { hydraulicBoundaryLocation }, true); GrassCoverErosionOutwardsWaveConditionsCalculation calculation = CreateValidCalculation(hydraulicBoundaryLocation); // Call CalculatableActivity activity = GrassCoverErosionOutwardsCalculationActivityFactory.CreateWaveConditionsCalculationActivity(calculation, failureMechanism, assessmentSection); // Assert Assert.IsInstanceOf <GrassCoverErosionOutwardsWaveConditionsCalculationActivity>(activity); AssertGrassCoverErosionOutwardsWaveConditionsCalculationActivity( activity, calculation, assessmentSection.WaterLevelCalculationsForSignalFloodingProbability.Single().Output.Result, hydraulicBoundaryDatabase); }
public void AssembleFailureMechanism_WithInput_SetsInputOnCalculator() { // Setup var failureMechanism = new GrassCoverErosionOutwardsFailureMechanism { AssemblyResult = { ProbabilityResultType = FailureMechanismAssemblyProbabilityResultType.Automatic } }; failureMechanism.SetSections(new[] { FailureMechanismSectionTestFactory.CreateFailureMechanismSection() }, "APath"); var assessmentSection = new AssessmentSectionStub(); using (new AssemblyToolCalculatorFactoryConfig()) { var calculatorFactory = (TestAssemblyToolCalculatorFactory)AssemblyToolCalculatorFactory.Instance; FailureMechanismSectionAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator; FailureMechanismAssemblyCalculatorStub failureMechanismAssemblyCalculator = calculatorFactory.LastCreatedFailureMechanismAssemblyCalculator; // Call GrassCoverErosionOutwardsFailureMechanismAssemblyFactory.AssembleFailureMechanism(failureMechanism, assessmentSection); // Assert Assert.AreEqual(failureMechanism.GeneralInput.N, failureMechanismAssemblyCalculator.FailureMechanismN); Assert.AreSame(calculator.FailureMechanismSectionAssemblyResultOutput.AssemblyResult, failureMechanismAssemblyCalculator.SectionAssemblyResultsInput.Single()); Assert.AreEqual(failureMechanism.GeneralInput.ApplyLengthEffectInSection, failureMechanismAssemblyCalculator.ApplyLengthEffect); } }
public DerivedGrassCoverErosionOutwardsWaveConditionsCalculationContext(GrassCoverErosionOutwardsWaveConditionsCalculation calculation, CalculationGroup parent, GrassCoverErosionOutwardsFailureMechanism failureMechanism, IAssessmentSection assessmentSection) : base(calculation, parent, failureMechanism, assessmentSection) { }
public void AssembleFailureMechanism_CalculatorRan_ReturnsExpectedOutput() { // Setup var failureMechanism = new GrassCoverErosionOutwardsFailureMechanism { AssemblyResult = { ProbabilityResultType = FailureMechanismAssemblyProbabilityResultType.Automatic } }; var assessmentSection = new AssessmentSectionStub(); using (new AssemblyToolCalculatorFactoryConfig()) { var calculatorFactory = (TestAssemblyToolCalculatorFactory)AssemblyToolCalculatorFactory.Instance; FailureMechanismAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedFailureMechanismAssemblyCalculator; // Call FailureMechanismAssemblyResultWrapper result = GrassCoverErosionOutwardsFailureMechanismAssemblyFactory.AssembleFailureMechanism(failureMechanism, assessmentSection); // Assert Assert.AreSame(calculator.AssemblyResultOutput, result); } }
public void Calculations_MultipleChildrenAdded_ReturnGrassCoverErosionOutwardsWaveConditionsCalculations() { // Setup var mocks = new MockRepository(); var failureMechanism = new GrassCoverErosionOutwardsFailureMechanism { CalculationsGroup = { Children = { new CalculationGroup(), new GrassCoverErosionOutwardsWaveConditionsCalculation(), mocks.Stub <ICalculation>(), new GrassCoverErosionOutwardsWaveConditionsCalculation() } } }; mocks.ReplayAll(); // Call List <ICalculation> calculations = failureMechanism.Calculations.ToList(); // Assert Assert.AreEqual(2, calculations.Count); Assert.IsTrue(calculations.All(c => c is GrassCoverErosionOutwardsWaveConditionsCalculation)); mocks.VerifyAll(); }
public void CurrentPath_FailureMechanismSectionsSourcePathSet_ReturnsExpectedPath() { // Setup var mocks = new MockRepository(); var assessmentSection = mocks.Stub <IAssessmentSection>(); mocks.ReplayAll(); var failureMechanism = new GrassCoverErosionOutwardsFailureMechanism(); string sourcePath = TestHelper.GetScratchPadPath(); failureMechanism.SetSections(Enumerable.Empty <FailureMechanismSection>(), sourcePath); var context = new GrassCoverErosionOutwardsFailureMechanismSectionsContext(failureMechanism, assessmentSection); using (var plugin = new GrassCoverErosionOutwardsPlugin()) { UpdateInfo updateInfo = GetUpdateInfo(plugin); // Call string currentFilePath = updateInfo.CurrentPath(context); // Assert Assert.AreEqual(sourcePath, currentFilePath); mocks.VerifyAll(); } }
public void IsEnabled_FailureMechanismSectionsSourcePathSet_ReturnTrue() { // Setup var mocks = new MockRepository(); var assessmentSection = mocks.Stub <IAssessmentSection>(); mocks.ReplayAll(); var failureMechanism = new GrassCoverErosionOutwardsFailureMechanism(); string sourcePath = TestHelper.GetScratchPadPath(); failureMechanism.SetSections(Enumerable.Empty <FailureMechanismSection>(), sourcePath); var context = new GrassCoverErosionOutwardsFailureMechanismSectionsContext(failureMechanism, assessmentSection); using (var plugin = new GrassCoverErosionOutwardsPlugin()) { UpdateInfo importInfo = GetUpdateInfo(plugin); // Call bool isEnabled = importInfo.IsEnabled(context); // Assert Assert.IsTrue(isEnabled); } mocks.VerifyAll(); }
public void Create_WithCalculationGroup_ReturnFailureMechanismEntityWithCalculationGroupEntities(bool inAssembly) { // Setup var failureMechanism = new GrassCoverErosionOutwardsFailureMechanism(); failureMechanism.CalculationsGroup.Children.Add(new CalculationGroup { Name = "A" }); failureMechanism.CalculationsGroup.Children.Add(new CalculationGroup { Name = "B" }); var registry = new PersistenceRegistry(); // Call FailureMechanismEntity entity = failureMechanism.Create(registry); // Assert Assert.IsNotNull(entity); Assert.AreEqual(failureMechanism.CalculationsGroup.Name, entity.CalculationGroupEntity.Name); Assert.AreEqual(0, entity.CalculationGroupEntity.Order); CalculationGroupEntity[] childGroupEntities = entity.CalculationGroupEntity.CalculationGroupEntity1 .OrderBy(cge => cge.Order) .ToArray(); Assert.AreEqual(2, childGroupEntities.Length); Assert.AreEqual("A", childGroupEntities[0].Name); Assert.AreEqual(0, childGroupEntities[0].Order); Assert.AreEqual("B", childGroupEntities[1].Name); Assert.AreEqual(1, childGroupEntities[1].Order); }
public void Create_StringPropertiesDoNotShareReference() { // Setup var failureMechanism = new GrassCoverErosionOutwardsFailureMechanism { InAssemblyInputComments = { Body = "Some input text" }, InAssemblyOutputComments = { Body = "Some output text" }, NotInAssemblyComments = { Body = "Really not in assembly" }, CalculationsInputComments = { Body = "Some calculation text" } }; var registry = new PersistenceRegistry(); // Call FailureMechanismEntity entity = failureMechanism.Create(registry); // Assert TestHelper.AssertAreEqualButNotSame(failureMechanism.InAssemblyInputComments.Body, entity.InAssemblyInputComments); TestHelper.AssertAreEqualButNotSame(failureMechanism.InAssemblyOutputComments.Body, entity.InAssemblyOutputComments); TestHelper.AssertAreEqualButNotSame(failureMechanism.NotInAssemblyComments.Body, entity.NotInAssemblyComments); TestHelper.AssertAreEqualButNotSame(failureMechanism.CalculationsInputComments.Body, entity.CalculationsInputComments); }
public void ClearAllWaveConditionsCalculationOutputAndHydraulicBoundaryLocations_WithVariousCalculations_ClearsOutputAndReturnsAffectedObjects() { // Setup GrassCoverErosionOutwardsFailureMechanism failureMechanism = CreateFullyConfiguredFailureMechanism(); GrassCoverErosionOutwardsWaveConditionsCalculation[] calculations = failureMechanism.Calculations.Cast <GrassCoverErosionOutwardsWaveConditionsCalculation>().ToArray(); IObservable[] expectedAffectedCalculations = calculations.Where(c => c.HasOutput) .Cast <IObservable>() .ToArray(); IObservable[] expectedAffectedCalculationInputs = calculations.Select(c => c.InputParameters) .Where(i => i.HydraulicBoundaryLocation != null) .Cast <IObservable>() .ToArray(); // Call IEnumerable <IObservable> affectedItems = GrassCoverErosionOutwardsDataSynchronizationService.ClearAllWaveConditionsCalculationOutputAndHydraulicBoundaryLocations(failureMechanism); // Assert // Note: To make sure the clear is performed regardless of what is done with // the return result, no ToArray() should be called before these assertions: Assert.IsTrue(failureMechanism.Calculations.Cast <GrassCoverErosionOutwardsWaveConditionsCalculation>() .All(c => c.InputParameters.HydraulicBoundaryLocation == null && !c.HasOutput)); CollectionAssert.AreEquivalent(expectedAffectedCalculations.Concat(expectedAffectedCalculationInputs), affectedItems); }
public void CloseForData_AssessmentSectionRemovedWithoutFailureMechanism_ReturnsFalse() { // Setup var assessmentSection = mocks.Stub <IAssessmentSection>(); assessmentSection.Stub(asm => asm.GetFailureMechanisms()).Return(Array.Empty <IFailureMechanism>()); mocks.ReplayAll(); var failureMechanism = new GrassCoverErosionOutwardsFailureMechanism(); using (var view = new NonAdoptableWithProfileProbabilityFailureMechanismResultView <GrassCoverErosionOutwardsFailureMechanism>( failureMechanism.SectionResults, failureMechanism, assessmentSection, (fm, ass) => new FailureMechanismAssemblyResultWrapper(double.NaN, AssemblyMethod.Manual), fm => fm.GeneralInput.ApplyLengthEffectInSection, sr => FailureMechanismSectionAssemblyResultWrapperTestFactory.Create())) { // Call bool closeForData = info.CloseForData(view, assessmentSection); // Assert Assert.IsFalse(closeForData); } mocks.VerifyAll(); }
private FailureMechanismAssemblyResultRow CreateGrassCoverErosionOutwardsFailureMechanismAssemblyResultRow() { GrassCoverErosionOutwardsFailureMechanism grassCoverErosionOutwards = AssessmentSection.GrassCoverErosionOutwards; return(FailureMechanismAssemblyResultRowFactory.CreateRow( grassCoverErosionOutwards, () => GrassCoverErosionOutwardsFailureMechanismAssemblyFactory.AssembleFailureMechanism(grassCoverErosionOutwards, AssessmentSection))); }
public void CreateInstance_WithContext_SetsFailureMechanismAsData() { // Setup var mocks = new MockRepository(); var assessmentSection = mocks.Stub <IAssessmentSection>(); mocks.ReplayAll(); var failureMechanism = new GrassCoverErosionOutwardsFailureMechanism(); var context = new GrassCoverErosionOutwardsFailureMechanismContext(failureMechanism, assessmentSection); using (var plugin = new GrassCoverErosionOutwardsPlugin()) { PropertyInfo info = GetInfo(plugin); // Call IObjectProperties objectProperties = info.CreateInstance(context); // Assert Assert.IsInstanceOf <GrassCoverErosionOutwardsFailureMechanismProperties>(objectProperties); Assert.AreSame(failureMechanism, objectProperties.Data); } mocks.VerifyAll(); }
public void ChildNodeObjects_FailureMechanismInAssemblyFalse_ReturnChildDataNodes() { // Setup var mocks = new MockRepository(); var assessmentSection = mocks.Stub <IAssessmentSection>(); mocks.ReplayAll(); var failureMechanism = new GrassCoverErosionOutwardsFailureMechanism { InAssembly = false }; var context = new GrassCoverErosionOutwardsFailureMechanismContext(failureMechanism, assessmentSection); // Call object[] children = info.ChildNodeObjects(context).ToArray(); // Assert Assert.AreEqual(1, children.Length); var comment = (Comment)children[0]; Assert.AreSame(failureMechanism.NotInAssemblyComments, comment); mocks.VerifyAll(); }
public void AssembleFailureMechanism_CalculatorThrowsException_ThrowsAssemblyException() { // Setup var failureMechanism = new GrassCoverErosionOutwardsFailureMechanism { AssemblyResult = { ProbabilityResultType = FailureMechanismAssemblyProbabilityResultType.Automatic } }; var assessmentSection = new AssessmentSectionStub(); using (new AssemblyToolCalculatorFactoryConfig()) { var calculatorFactory = (TestAssemblyToolCalculatorFactory)AssemblyToolCalculatorFactory.Instance; FailureMechanismAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedFailureMechanismAssemblyCalculator; calculator.ThrowExceptionOnCalculate = true; // Call void Call() => GrassCoverErosionOutwardsFailureMechanismAssemblyFactory.AssembleFailureMechanism(failureMechanism, assessmentSection); // Assert var exception = Assert.Throws <AssemblyException>(Call); Exception innerException = exception.InnerException; Assert.IsInstanceOf <FailureMechanismAssemblyCalculatorException>(innerException); Assert.AreEqual(innerException.Message, exception.Message); } }
public void ContextMenuStrip_HydraulicBoundaryDatabaseNotLinked_ContextMenuItemCalculateAllDisabledAndTooltipSet() { // Setup var failureMechanism = new GrassCoverErosionOutwardsFailureMechanism(); var assessmentSection = new AssessmentSectionStub(); var context = new GrassCoverErosionOutwardsFailureMechanismContext(failureMechanism, assessmentSection); using (var treeViewControl = new TreeViewControl()) { var gui = mocks.Stub <IGui>(); gui.Stub(g => g.ProjectOpened += null).IgnoreArguments(); gui.Stub(g => g.ProjectOpened -= null).IgnoreArguments(); gui.Stub(cmp => cmp.Get(context, treeViewControl)).Return(new CustomItemsOnlyContextMenuBuilder()); mocks.ReplayAll(); plugin.Gui = gui; // Call using (ContextMenuStrip contextMenu = info.ContextMenuStrip(context, null, treeViewControl)) { // Assert ToolStripItem contextMenuItem = contextMenu.Items[contextMenuCalculateAllIndex]; Assert.AreEqual("Alles be&rekenen", contextMenuItem.Text); StringAssert.Contains("Er is geen hydraulische belastingendatabase geĆÆmporteerd.", contextMenuItem.ToolTipText); TestHelper.AssertImagesAreEqual(RiskeerCommonFormsResources.CalculateAllIcon, contextMenuItem.Image); Assert.IsFalse(contextMenuItem.Enabled); } } }
public void Cancel_WhenPerformingCalculation_CurrentCalculationForWaterLevelCompletesAndSubsequentCalculationsDidNotRun() { // Setup AssessmentSectionStub assessmentSection = CreateAssessmentSection(); ConfigureAssessmentSectionWithHydraulicBoundaryOutput(assessmentSection); GrassCoverErosionOutwardsWaveConditionsCalculation calculation = CreateValidCalculation(assessmentSection.HydraulicBoundaryDatabase.Locations.First()); var failureMechanism = new GrassCoverErosionOutwardsFailureMechanism(); CalculatableActivity activity = GrassCoverErosionOutwardsCalculationActivityFactory.CreateWaveConditionsCalculationActivity(calculation, failureMechanism, assessmentSection); var mockRepository = new MockRepository(); var calculatorFactory = mockRepository.StrictMock <IHydraRingCalculatorFactory>(); calculatorFactory.Expect(cf => cf.CreateWaveConditionsCosineCalculator(null)) .IgnoreArguments() .Return(new TestWaveConditionsCosineCalculator()); mockRepository.ReplayAll(); using (new HydraRingCalculatorFactoryConfig(calculatorFactory)) { activity.ProgressChanged += (sender, args) => { if (activity.State != ActivityState.Canceled) { // Call activity.Cancel(); } }; // Assert TestHelper.AssertLogMessages(() => activity.Run(), messages => { string[] msgs = messages.ToArray(); RoundedDouble firstWaterLevel = GetWaterLevels(calculation, assessmentSection).First(); Assert.AreEqual(10, msgs.Length); Assert.AreEqual($"Golfcondities berekenen voor '{calculation.Name}' is gestart.", msgs[0]); CalculationServiceTestHelper.AssertValidationStartMessage(msgs[1]); CalculationServiceTestHelper.AssertValidationEndMessage(msgs[2]); CalculationServiceTestHelper.AssertCalculationStartMessage(msgs[3]); Assert.AreEqual("Berekening voor golfoploop is gestart.", msgs[4]); Assert.AreEqual($"Berekening voor waterstand '{firstWaterLevel}' is gestart.", msgs[5]); StringAssert.StartsWith("Golfcondities berekening is uitgevoerd op de tijdelijke locatie", msgs[6]); Assert.AreEqual($"Berekening voor waterstand '{firstWaterLevel}' is beƫindigd.", msgs[7]); Assert.AreEqual("Berekening voor golfoploop is beƫindigd.", msgs[8]); CalculationServiceTestHelper.AssertCalculationEndMessage(msgs[9]); }); Assert.AreEqual(ActivityState.Canceled, activity.State); Assert.IsNull(calculation.Output); } mockRepository.VerifyAll(); }
public void IsEnabled_CalculationWithOrWithoutOutput_ReturnExpectedEnabledState(bool hasOutput) { // Setup var assessmentSection = mocks.Stub <IAssessmentSection>(); mocks.ReplayAll(); var failureMechanism = new GrassCoverErosionOutwardsFailureMechanism(); var calculationGroup = new CalculationGroup(); var calculation = new GrassCoverErosionOutwardsWaveConditionsCalculation(); if (hasOutput) { calculation.Output = GrassCoverErosionOutwardsWaveConditionsOutputTestFactory.Create(); } calculationGroup.Children.Add(calculation); var context = new GrassCoverErosionOutwardsCalculationGroupContext(calculationGroup, null, failureMechanism, assessmentSection); // Call bool isEnabled = info.IsEnabled(context); // Assert Assert.AreEqual(hasOutput, isEnabled); }
public void ChildNodeObjects_WithContext_ReturnChildDataNodes() { // Setup var assessmentSection = new AssessmentSectionStub(); var failureMechanism = new GrassCoverErosionOutwardsFailureMechanism(); var context = new GrassCoverErosionOutwardsFailureMechanismContext(failureMechanism, assessmentSection); // Call object[] children = info.ChildNodeObjects(context).ToArray(); // Assert Assert.AreEqual(2, children.Length); var inputsFolder = (CategoryTreeFolder)children[0]; Assert.AreEqual("Invoer", inputsFolder.Name); Assert.AreEqual(TreeFolderCategory.Input, inputsFolder.Category); Assert.AreEqual(2, inputsFolder.Contents.Count()); var foreshoreProfilesContext = (ForeshoreProfilesContext)inputsFolder.Contents.ElementAt(0); Assert.AreSame(failureMechanism.ForeshoreProfiles, foreshoreProfilesContext.WrappedData); Assert.AreSame(failureMechanism, foreshoreProfilesContext.ParentFailureMechanism); Assert.AreSame(assessmentSection, foreshoreProfilesContext.ParentAssessmentSection); var calculationsInputComments = (Comment)inputsFolder.Contents.ElementAt(1); Assert.AreSame(failureMechanism.CalculationsInputComments, calculationsInputComments); var calculationGroupContext = (GrassCoverErosionOutwardsCalculationGroupContext)children[1]; Assert.AreSame(failureMechanism.CalculationsGroup, calculationGroupContext.WrappedData); Assert.IsNull(calculationGroupContext.Parent); Assert.AreSame(failureMechanism, calculationGroupContext.FailureMechanism); Assert.AreSame(assessmentSection, calculationGroupContext.AssessmentSection); }
public DerivedGrassCoverErosionOutwardsCalculationGroupContext(CalculationGroup calculationGroup, CalculationGroup parent, GrassCoverErosionOutwardsFailureMechanism failureMechanism, IAssessmentSection assessmentSection) : base(calculationGroup, parent, failureMechanism, assessmentSection) { }
public void ParameteredConstructor_ExpectedValues(bool hasParent) { // Setup var mocks = new MockRepository(); var assessmentSection = mocks.Stub <IAssessmentSection>(); mocks.ReplayAll(); var calculationGroup = new CalculationGroup(); var failureMechanism = new GrassCoverErosionOutwardsFailureMechanism(); CalculationGroup parent = hasParent ? new CalculationGroup() : null; // Call var context = new GrassCoverErosionOutwardsCalculationGroupContext(calculationGroup, parent, failureMechanism, assessmentSection); // Assert Assert.IsInstanceOf <GrassCoverErosionOutwardsContext <CalculationGroup> >(context); Assert.IsInstanceOf <ICalculationContext <CalculationGroup, GrassCoverErosionOutwardsFailureMechanism> >(context); Assert.AreSame(calculationGroup, context.WrappedData); Assert.AreSame(parent, context.Parent); Assert.AreSame(failureMechanism, context.FailureMechanism); Assert.AreSame(assessmentSection, context.AssessmentSection); mocks.VerifyAll(); }
public void ClearReferenceLineDependentData_FullyConfiguredFailureMechanism_RemoveFailureMechanismDependentData() { // Setup GrassCoverErosionOutwardsFailureMechanism failureMechanism = CreateFullyConfiguredFailureMechanism(); object[] expectedRemovedObjects = failureMechanism.Sections.OfType <object>() .Concat(failureMechanism.SectionResults) .Concat(failureMechanism.CalculationsGroup.GetAllChildrenRecursive()) .Concat(failureMechanism.ForeshoreProfiles) .ToArray(); // Call ClearResults results = GrassCoverErosionOutwardsDataSynchronizationService.ClearReferenceLineDependentData(failureMechanism); // Assert CollectionAssert.IsEmpty(failureMechanism.Sections); CollectionAssert.IsEmpty(failureMechanism.SectionResults); CollectionAssert.IsEmpty(failureMechanism.CalculationsGroup.Children); CollectionAssert.IsEmpty(failureMechanism.ForeshoreProfiles); IObservable[] array = results.ChangedObjects.ToArray(); Assert.AreEqual(4, array.Length); CollectionAssert.Contains(array, failureMechanism); CollectionAssert.Contains(array, failureMechanism.SectionResults); CollectionAssert.Contains(array, failureMechanism.CalculationsGroup); CollectionAssert.Contains(array, failureMechanism.ForeshoreProfiles); CollectionAssert.AreEquivalent(expectedRemovedObjects, results.RemovedObjects); }
public void Constructor_ExpectedValues() { // Setup var random = new Random(21); var failureMechanism = new GrassCoverErosionOutwardsFailureMechanism { InAssembly = random.NextBoolean(), GeneralInput = { ApplyLengthEffectInSection = random.NextBoolean() } }; // Call var properties = new GrassCoverErosionOutwardsFailureMechanismProperties(failureMechanism); // Assert Assert.IsInstanceOf <GrassCoverErosionOutwardsFailureMechanismPropertiesBase>(properties); Assert.AreEqual(failureMechanism.Name, properties.Name); Assert.AreEqual(failureMechanism.Code, properties.Code); Assert.AreEqual(failureMechanism.InAssembly, properties.InAssembly); GeneralGrassCoverErosionOutwardsInput generalInput = failureMechanism.GeneralInput; Assert.AreEqual(2, properties.N.NumberOfDecimalPlaces); Assert.AreEqual(generalInput.N, properties.N, properties.N.GetAccuracy()); Assert.AreEqual(generalInput.ApplyLengthEffectInSection, properties.ApplyLengthEffectInSection); }
/// <summary> /// Clears all data dependent, either directly or indirectly, on the parent reference line. /// </summary> /// <param name="failureMechanism">The failure mechanism to be cleared.</param> /// <returns>The results of the clear action.</returns> /// <exception cref="ArgumentNullException">Thrown when <paramref name="failureMechanism"/> /// is <c>null</c>.</exception> public static ClearResults ClearReferenceLineDependentData(GrassCoverErosionOutwardsFailureMechanism failureMechanism) { if (failureMechanism == null) { throw new ArgumentNullException(nameof(failureMechanism)); } var changedObjects = new List <IObservable>(); object[] removedObjects = failureMechanism.Sections.OfType <object>() .Concat(failureMechanism.SectionResults) .Concat(failureMechanism.CalculationsGroup.GetAllChildrenRecursive()) .Concat(failureMechanism.ForeshoreProfiles) .ToArray(); failureMechanism.ClearAllSections(); changedObjects.Add(failureMechanism); changedObjects.Add(failureMechanism.SectionResults); failureMechanism.CalculationsGroup.Children.Clear(); changedObjects.Add(failureMechanism.CalculationsGroup); failureMechanism.ForeshoreProfiles.Clear(); changedObjects.Add(failureMechanism.ForeshoreProfiles); return(new ClearResults(changedObjects, removedObjects)); }
public void AssembleSection_CalculatorThrowsException_ThrowsAssemblyException() { // Setup FailureMechanismSection section = FailureMechanismSectionTestFactory.CreateFailureMechanismSection(); var sectionResult = new NonAdoptableWithProfileProbabilityFailureMechanismSectionResult(section); var failureMechanism = new GrassCoverErosionOutwardsFailureMechanism(); var assessmentSection = new AssessmentSectionStub(); using (new AssemblyToolCalculatorFactoryConfig()) { var calculatorFactory = (TestAssemblyToolCalculatorFactory)AssemblyToolCalculatorFactory.Instance; FailureMechanismSectionAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator; calculator.ThrowExceptionOnCalculate = true; // Call void Call() => GrassCoverErosionOutwardsFailureMechanismAssemblyFactory.AssembleSection( sectionResult, failureMechanism, assessmentSection); // Assert var exception = Assert.Throws <AssemblyException>(Call); Exception innerException = exception.InnerException; Assert.IsInstanceOf <FailureMechanismSectionAssemblyCalculatorException>(innerException); Assert.AreEqual(innerException.Message, exception.Message); } }
/// <summary> /// Creates a new instance of <see cref="GrassCoverErosionOutwardsFailureMechanismProperties"/>. /// </summary> /// <param name="data">The instance to show the properties of.</param> /// <exception cref="ArgumentNullException">Thrown when <paramref name="data"/> is <c>null</c>.</exception> public GrassCoverErosionOutwardsFailureMechanismProperties(GrassCoverErosionOutwardsFailureMechanism data) : base(data, new ConstructionProperties { NamePropertyIndex = namePropertyIndex, CodePropertyIndex = codePropertyIndex }) { }
private GrassCoverErosionOutwardsFailureMechanismView CreateView(GrassCoverErosionOutwardsFailureMechanism failureMechanism, IAssessmentSection assessmentSection) { var view = new GrassCoverErosionOutwardsFailureMechanismView(failureMechanism, assessmentSection); testForm.Controls.Add(view); testForm.Show(); return(view); }
private IEnumerable <WaveConditionsOutput> CalculateWaveImpact(GrassCoverErosionOutwardsWaveConditionsCalculation calculation, GrassCoverErosionOutwardsFailureMechanism failureMechanism, HydraulicBoundaryDatabase hydraulicBoundaryDatabase, RoundedDouble assessmentLevel, double targetProbability) { return(Calculate(calculation, hydraulicBoundaryDatabase, targetProbability, assessmentLevel, failureMechanism.GeneralInput.GeneralWaveImpactWaveConditionsInput, Resources.GrassCoverErosionOutwardsWaveConditions_WaveImpact_DisplayName)); }
public void Constructor_InAssemblyTrue_PropertiesHaveExpectedAttributesValues() { // Setup var failureMechanism = new GrassCoverErosionOutwardsFailureMechanism(); // Call var properties = new GrassCoverErosionOutwardsFailureMechanismProperties(failureMechanism); // Assert PropertyDescriptorCollection dynamicProperties = PropertiesTestHelper.GetAllVisiblePropertyDescriptors(properties); Assert.AreEqual(5, dynamicProperties.Count); const string generalCategory = "Algemeen"; const string lengthEffectCategory = "Lengte-effect"; PropertyDescriptor nameProperty = dynamicProperties[namePropertyIndex]; PropertiesTestHelper.AssertRequiredPropertyDescriptorProperties(nameProperty, generalCategory, "Naam", "De naam van het faalmechanisme.", true); PropertyDescriptor labelProperty = dynamicProperties[codePropertyIndex]; PropertiesTestHelper.AssertRequiredPropertyDescriptorProperties(labelProperty, generalCategory, "Label", "Het label van het faalmechanisme.", true); PropertyDescriptor inAssemblyProperty = dynamicProperties[inAssemblyPropertyIndex]; PropertiesTestHelper.AssertRequiredPropertyDescriptorProperties(inAssemblyProperty, generalCategory, "In assemblage", "Geeft aan of dit faalmechanisme wordt meegenomen in de assemblage.", true); PropertyDescriptor nProperty = dynamicProperties[nPropertyIndex]; PropertiesTestHelper.AssertRequiredPropertyDescriptorProperties(nProperty, lengthEffectCategory, "N [-]", "De parameter 'N' die gebruikt wordt om het lengte-effect mee te nemen in de beoordeling."); PropertyDescriptor applySectionLengthInSectionProperty = dynamicProperties[applyLengthEffectInSectionPropertyIndex]; PropertiesTestHelper.AssertRequiredPropertyDescriptorProperties(applySectionLengthInSectionProperty, lengthEffectCategory, "Toepassen lengte-effect binnen vak", "Geeft aan of het lengte-effect binnen een vak toegepast wordt."); }
/// <summary> /// Creates a <see cref="FailureMechanismEntity"/> based on the information of the <see cref="GrassCoverErosionOutwardsFailureMechanism"/>. /// </summary> /// <param name="mechanism">The failure mechanism to create a database entity for.</param> /// <param name="registry">The object keeping track of create operations.</param> /// <returns>A new <see cref="FailureMechanismEntity"/>.</returns> /// <exception cref="ArgumentNullException">Thrown when <paramref name="registry"/> is <c>null</c>.</exception> internal static FailureMechanismEntity Create(this GrassCoverErosionOutwardsFailureMechanism mechanism, PersistenceRegistry registry) { FailureMechanismEntity entity = mechanism.Create(FailureMechanismType.GrassRevetmentErosionOutwards, registry); AddEntitiesForSectionResults(mechanism.SectionResults, registry); AddEntitiesForFailureMechanismMeta(mechanism, entity); AddEntitiesForForeshoreProfiles(mechanism.ForeshoreProfiles, entity, registry); entity.CalculationGroupEntity = mechanism.CalculationsGroup.Create(registry, 0); return(entity); }