public void ContextMenuStrip_WithContext_AddCustomItems() { // Setup using (var treeView = new TreeViewControl()) { var assessmentSection = mocks.Stub <IAssessmentSection>(); var failureMechanism = new StabilityStoneCoverFailureMechanism(); var context = new StabilityStoneCoverFailureMechanismContext(failureMechanism, assessmentSection); var menuBuilder = new CustomItemsOnlyContextMenuBuilder(); var gui = mocks.Stub <IGui>(); gui.Stub(cmp => cmp.Get(context, treeView)).Return(menuBuilder); gui.Stub(g => g.ProjectOpened += null).IgnoreArguments(); gui.Stub(g => g.ProjectOpened -= null).IgnoreArguments(); mocks.ReplayAll(); plugin.Gui = gui; // Call using (ContextMenuStrip menu = info.ContextMenuStrip(context, assessmentSection, treeView)) { // Assert Assert.AreEqual(8, menu.Items.Count); TestHelper.AssertContextMenuStripContainsItem(menu, contextMenuCalculateAllIndex, "Alles be&rekenen", "Er zijn geen berekeningen om uit te voeren.", RiskeerCommonFormsResources.CalculateAllIcon, false); } } }
public DerivedStabilityStoneCoverWaveConditionsCalculationContext(StabilityStoneCoverWaveConditionsCalculation wrappedData, CalculationGroup parent, StabilityStoneCoverFailureMechanism failureMechanism, IAssessmentSection assessmentSection) : base(wrappedData, parent, failureMechanism, assessmentSection) { }
public void AssembleFailureMechanism_CalculatorThrowsException_ThrowsAssemblyException() { // Setup var failureMechanism = new StabilityStoneCoverFailureMechanism { 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() => StabilityStoneCoverFailureMechanismAssemblyFactory.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 AssembleFailureMechanism_CalculatorRan_ReturnsExpectedOutput() { // Setup var failureMechanism = new StabilityStoneCoverFailureMechanism { AssemblyResult = { ProbabilityResultType = FailureMechanismAssemblyProbabilityResultType.Automatic } }; var assessmentSection = new AssessmentSectionStub(); using (new AssemblyToolCalculatorFactoryConfig()) { var calculatorFactory = (TestAssemblyToolCalculatorFactory)AssemblyToolCalculatorFactory.Instance; FailureMechanismAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedFailureMechanismAssemblyCalculator; // Call FailureMechanismAssemblyResultWrapper result = StabilityStoneCoverFailureMechanismAssemblyFactory.AssembleFailureMechanism(failureMechanism, assessmentSection); // Assert Assert.AreEqual(calculator.AssemblyResultOutput, result); } }
public void ContextMenuStrip_HydraulicBoundaryDatabaseNotLinked_CalculateAllDisabled() { // Setup using (var treeViewControl = new TreeViewControl()) { var failureMechanism = new StabilityStoneCoverFailureMechanism(); failureMechanism.CalculationsGroup.Children.Add(new StabilityStoneCoverWaveConditionsCalculation()); IAssessmentSection assessmentSection = AssessmentSectionTestHelper.CreateAssessmentSectionStub(mocks); var nodeData = new StabilityStoneCoverFailureMechanismContext(failureMechanism, assessmentSection); var menuBuilder = new CustomItemsOnlyContextMenuBuilder(); var gui = mocks.Stub <IGui>(); gui.Stub(g => g.Get(nodeData, treeViewControl)).Return(menuBuilder); gui.Stub(g => g.MainWindow).Return(mocks.Stub <IMainWindow>()); mocks.ReplayAll(); plugin.Gui = gui; // Call using (ContextMenuStrip contextMenu = info.ContextMenuStrip(nodeData, null, treeViewControl)) { // Assert ToolStripItem calculateItem = contextMenu.Items[contextMenuCalculateAllIndex]; Assert.IsFalse(calculateItem.Enabled); Assert.AreEqual("Er is geen hydraulische belastingendatabase geïmporteerd.", calculateItem.ToolTipText); } } }
public void ChildNodeObjects_FailureMechanismInAssemblyFalse_ReturnChildDataNodes() { // Setup var mocks = new MockRepository(); var assessmentSection = mocks.Stub <IAssessmentSection>(); mocks.ReplayAll(); var failureMechanism = new StabilityStoneCoverFailureMechanism { InAssembly = false }; var context = new StabilityStoneCoverFailureMechanismContext(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 AssembleSection_CalculatorThrowsException_ThrowsAssemblyException() { // Setup FailureMechanismSection section = FailureMechanismSectionTestFactory.CreateFailureMechanismSection(); var sectionResult = new NonAdoptableWithProfileProbabilityFailureMechanismSectionResult(section); var failureMechanism = new StabilityStoneCoverFailureMechanism(); var assessmentSection = new AssessmentSectionStub(); using (new AssemblyToolCalculatorFactoryConfig()) { var calculatorFactory = (TestAssemblyToolCalculatorFactory)AssemblyToolCalculatorFactory.Instance; FailureMechanismSectionAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator; calculator.ThrowExceptionOnCalculate = true; // Call void Call() => StabilityStoneCoverFailureMechanismAssemblyFactory.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); } }
public void ClearReferenceLineDependentData_FullyConfiguredFailureMechanism_RemoveFailureMechanismDependentDataAndReturnAffectedObjects() { // Setup StabilityStoneCoverFailureMechanism failureMechanism = CreateFullyConfiguredFailureMechanism(); object[] expectedRemovedObjects = failureMechanism.Sections.OfType <object>() .Concat(failureMechanism.SectionResults) .Concat(failureMechanism.CalculationsGroup.GetAllChildrenRecursive()) .Concat(failureMechanism.ForeshoreProfiles) .ToArray(); // Call ClearResults results = StabilityStoneCoverDataSynchronizationService.ClearReferenceLineDependentData(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: 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 CloseForData_ViewCorrespondingToRemovedFailureMechanismContext_ReturnsTrue() { // Setup var assessmentSection = mocks.Stub <IAssessmentSection>(); mocks.ReplayAll(); var failureMechanism = new StabilityStoneCoverFailureMechanism(); var context = new StabilityStoneCoverFailureMechanismContext(failureMechanism, assessmentSection); using (var view = new NonAdoptableWithProfileProbabilityFailureMechanismResultView <StabilityStoneCoverFailureMechanism>( 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, context); // Assert Assert.IsTrue(closeForData); } mocks.VerifyAll(); }
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 StabilityStoneCoverFailureMechanism(); using (var view = new NonAdoptableWithProfileProbabilityFailureMechanismResultView <StabilityStoneCoverFailureMechanism>( 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(); }
public void Create_StringPropertiesDoNotShareReference() { // Setup var failureMechanism = new StabilityStoneCoverFailureMechanism { 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 IsEnabled_FailureMechanismSectionsSourcePathSet_ReturnTrue() { // Setup var mocks = new MockRepository(); var assessmentSection = mocks.Stub <IAssessmentSection>(); mocks.ReplayAll(); var failureMechanism = new StabilityStoneCoverFailureMechanism(); string sourcePath = TestHelper.GetScratchPadPath(); failureMechanism.SetSections(Enumerable.Empty <FailureMechanismSection>(), sourcePath); var context = new StabilityStoneCoverFailureMechanismSectionsContext(failureMechanism, assessmentSection); using (var plugin = new StabilityStoneCoverPlugin()) { UpdateInfo importInfo = GetUpdateInfo(plugin); // Call bool isEnabled = importInfo.IsEnabled(context); // Assert Assert.IsTrue(isEnabled); } mocks.VerifyAll(); }
public void CreateCalculationActivitiesForCalculationGroup_WithValidCalculations_ReturnsStabilityStoneCoverWaveConditionsCalculationActivitiesWithParametersSet() { // Setup StabilityStoneCoverFailureMechanism failureMechanism = new StabilityStoneCoverFailureMechanism(); AssessmentSectionStub assessmentSection = CreateAssessmentSection(); var hydraulicBoundaryLocation = new TestHydraulicBoundaryLocation(); SetHydraulicBoundaryLocationToAssessmentSection(assessmentSection, hydraulicBoundaryLocation); StabilityStoneCoverWaveConditionsCalculation calculation1 = CreateValidCalculation(hydraulicBoundaryLocation); StabilityStoneCoverWaveConditionsCalculation calculation2 = CreateValidCalculation(hydraulicBoundaryLocation); var calculations = new CalculationGroup { Children = { calculation1, calculation2 } }; // Call IEnumerable <CalculatableActivity> activities = StabilityStoneCoverWaveConditionsCalculationActivityFactory.CreateCalculationActivities( calculations, failureMechanism, assessmentSection); // Assert CollectionAssert.AllItemsAreInstancesOfType(activities, typeof(StabilityStoneCoverWaveConditionsCalculationActivity)); Assert.AreEqual(2, activities.Count()); RoundedDouble assessmentLevel = assessmentSection.WaterLevelCalculationsForSignalFloodingProbability.Single().Output.Result; HydraulicBoundaryDatabase hydraulicBoundaryDatabase = assessmentSection.HydraulicBoundaryDatabase; AssertStabilityStoneCoverWaveConditionsCalculationActivity(activities.First(), calculation1, assessmentLevel, hydraulicBoundaryDatabase); AssertStabilityStoneCoverWaveConditionsCalculationActivity(activities.ElementAt(1), calculation2, assessmentLevel, hydraulicBoundaryDatabase); }
public void Calculations_MultipleChildrenAdded_ReturnStabilityStoneCoverWaveConditionsCalculations() { // Setup var mocks = new MockRepository(); var failureMechanism = new StabilityStoneCoverFailureMechanism { CalculationsGroup = { Children = { new CalculationGroup(), new StabilityStoneCoverWaveConditionsCalculation(), mocks.StrictMock <ICalculation>(), new StabilityStoneCoverWaveConditionsCalculation() } } }; mocks.ReplayAll(); // Call List <ICalculation> calculations = failureMechanism.Calculations.ToList(); // Assert Assert.AreEqual(2, calculations.Count); Assert.IsTrue(calculations.All(c => c is StabilityStoneCoverWaveConditionsCalculation)); mocks.VerifyAll(); }
public void ParameteredConstructor_ExpectedValues(bool hasParent) { // Setup var mocks = new MockRepository(); var assessmentSection = mocks.Stub <IAssessmentSection>(); mocks.ReplayAll(); var failureMechanism = new StabilityStoneCoverFailureMechanism(); var calculationGroup = new CalculationGroup(); CalculationGroup parent = hasParent ? new CalculationGroup() : null; // Call var context = new StabilityStoneCoverCalculationGroupContext(calculationGroup, parent, failureMechanism, assessmentSection); // Assert Assert.IsInstanceOf <StabilityStoneCoverContext <CalculationGroup> >(context); Assert.IsInstanceOf <ICalculationContext <CalculationGroup, StabilityStoneCoverFailureMechanism> >(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 AssembleFailureMechanism_WithInput_SetsInputOnCalculator() { // Setup var failureMechanism = new StabilityStoneCoverFailureMechanism { 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 StabilityStoneCoverFailureMechanismAssemblyFactory.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); } }
private FailureMechanismAssemblyResultRow CreateStabilityStoneCoverFailureMechanismAssemblyResultRow() { StabilityStoneCoverFailureMechanism stabilityStoneCover = AssessmentSection.StabilityStoneCover; return(FailureMechanismAssemblyResultRowFactory.CreateRow( stabilityStoneCover, () => StabilityStoneCoverFailureMechanismAssemblyFactory.AssembleFailureMechanism(stabilityStoneCover, AssessmentSection))); }
public DerivedStabilityStoneCoverCalculationGroupContext(CalculationGroup calculationGroup, CalculationGroup parent, StabilityStoneCoverFailureMechanism failureMechanism, IAssessmentSection assessmentSection) : base(calculationGroup, parent, failureMechanism, assessmentSection) { }
/// <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(StabilityStoneCoverFailureMechanism 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 Constructor_ExpectedValues() { // Setup var random = new Random(21); var failureMechanism = new StabilityStoneCoverFailureMechanism { InAssembly = random.NextBoolean() }; // Call var properties = new StabilityStoneCoverFailureMechanismProperties(failureMechanism); // Assert Assert.IsInstanceOf <StabilityStoneCoverFailureMechanismPropertiesBase>(properties); Assert.AreEqual(failureMechanism.Name, properties.Name); Assert.AreEqual(failureMechanism.Code, properties.Code); Assert.AreEqual(failureMechanism.InAssembly, properties.InAssembly); GeneralStabilityStoneCoverWaveConditionsInput generalInput = failureMechanism.GeneralInput; Assert.AreEqual(2, properties.N.NumberOfDecimalPlaces); Assert.AreEqual(generalInput.N, properties.N, properties.N.GetAccuracy()); Assert.AreEqual(generalInput.ApplyLengthEffectInSection, properties.ApplyLengthEffectInSection); }
public void Create_WithCalculationGroup_ReturnFailureMechanismEntityWithCalculationGroupEntities() { // Setup var failureMechanism = new StabilityStoneCoverFailureMechanism(); 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 ClearAllWaveConditionsCalculationOutputAndHydraulicBoundaryLocations_WithVariousCalculations_ClearsCalculationsAndReturnsAffectedObjects() { // Setup StabilityStoneCoverFailureMechanism failureMechanism = CreateFullyConfiguredFailureMechanism(); StabilityStoneCoverWaveConditionsCalculation[] calculations = failureMechanism.Calculations.Cast <StabilityStoneCoverWaveConditionsCalculation>().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 = StabilityStoneCoverDataSynchronizationService.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 <StabilityStoneCoverWaveConditionsCalculation>() .All(c => c.InputParameters.HydraulicBoundaryLocation == null && !c.HasOutput)); CollectionAssert.AreEquivalent(expectedAffectedCalculations.Concat(expectedAffectedCalculationInputs), affectedItems); }
public void CreateCalculationActivitiesForFailureMechanism_WithValidData_ExpectedInputSetToActivities() { // Setup AssessmentSectionStub assessmentSection = CreateAssessmentSection(); StabilityStoneCoverFailureMechanism failureMechanism = new StabilityStoneCoverFailureMechanism(); var hydraulicBoundaryLocation = new TestHydraulicBoundaryLocation("locationName 1"); SetHydraulicBoundaryLocationToAssessmentSection(assessmentSection, hydraulicBoundaryLocation); StabilityStoneCoverWaveConditionsCalculation calculation1 = CreateValidCalculation(hydraulicBoundaryLocation); StabilityStoneCoverWaveConditionsCalculation calculation2 = CreateValidCalculation(hydraulicBoundaryLocation); failureMechanism.CalculationsGroup.Children.AddRange(new[] { calculation1, calculation2 }); // Call IEnumerable <CalculatableActivity> activities = StabilityStoneCoverWaveConditionsCalculationActivityFactory.CreateCalculationActivities( failureMechanism, assessmentSection); // Assert CollectionAssert.AllItemsAreInstancesOfType(activities, typeof(StabilityStoneCoverWaveConditionsCalculationActivity)); Assert.AreEqual(2, activities.Count()); RoundedDouble assessmentLevel = assessmentSection.WaterLevelCalculationsForSignalFloodingProbability.Single().Output.Result; HydraulicBoundaryDatabase hydraulicBoundaryDatabase = assessmentSection.HydraulicBoundaryDatabase; AssertStabilityStoneCoverWaveConditionsCalculationActivity(activities.ElementAt(0), calculation1, assessmentLevel, hydraulicBoundaryDatabase); AssertStabilityStoneCoverWaveConditionsCalculationActivity(activities.ElementAt(1), calculation2, assessmentLevel, hydraulicBoundaryDatabase); }
public void CreateInstance_WithContext_SetsFailureMechanismAsData() { // Setup var mocks = new MockRepository(); var assessmentSection = mocks.Stub <IAssessmentSection>(); mocks.ReplayAll(); var failureMechanism = new StabilityStoneCoverFailureMechanism(); var context = new StabilityStoneCoverFailureMechanismContext(failureMechanism, assessmentSection); using (var plugin = new StabilityStoneCoverPlugin()) { PropertyInfo info = GetInfo(plugin); // Call IObjectProperties objectProperties = info.CreateInstance(context); // Assert Assert.IsInstanceOf <StabilityStoneCoverFailureMechanismProperties>(objectProperties); Assert.AreSame(failureMechanism, objectProperties.Data); } mocks.VerifyAll(); }
public void CurrentPath_FailureMechanismSectionsSourcePathSet_ReturnsExpectedPath() { // Setup var mocks = new MockRepository(); var assessmentSection = mocks.Stub <IAssessmentSection>(); mocks.ReplayAll(); var failureMechanism = new StabilityStoneCoverFailureMechanism(); string sourcePath = TestHelper.GetScratchPadPath(); failureMechanism.SetSections(Enumerable.Empty <FailureMechanismSection>(), sourcePath); var context = new StabilityStoneCoverFailureMechanismSectionsContext(failureMechanism, assessmentSection); using (var plugin = new StabilityStoneCoverPlugin()) { UpdateInfo updateInfo = GetUpdateInfo(plugin); // Call string currentFilePath = updateInfo.CurrentPath(context); // Assert Assert.AreEqual(sourcePath, currentFilePath); mocks.VerifyAll(); } }
/// <summary> /// Creates a new instance of <see cref="StabilityStoneCoverFailureMechanismProperties"/>. /// </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 StabilityStoneCoverFailureMechanismProperties(StabilityStoneCoverFailureMechanism data) : base(data, new ConstructionProperties { NamePropertyIndex = namePropertyIndex, CodePropertyIndex = codePropertyIndex }) { }
private StabilityStoneCoverFailureMechanismView CreateView(StabilityStoneCoverFailureMechanism failureMechanism, IAssessmentSection assessmentSection) { var view = new StabilityStoneCoverFailureMechanismView(failureMechanism, assessmentSection); testForm.Controls.Add(view); testForm.Show(); return(view); }
public void GivenValidCalculations_WhenCalculatingAllFromContextMenu_ThenAllCalculationsScheduled() { // Given var failureMechanism = new StabilityStoneCoverFailureMechanism(); IAssessmentSection assessmentSection = CreateAssessmentSectionWithHydraulicBoundaryOutput(); HydraulicBoundaryLocation hydraulicBoundaryLocation = assessmentSection.HydraulicBoundaryDatabase.Locations.First(); StabilityStoneCoverWaveConditionsCalculation calculationA = GetValidCalculation(hydraulicBoundaryLocation); StabilityStoneCoverWaveConditionsCalculation calculationB = GetValidCalculation(hydraulicBoundaryLocation); List <ICalculationBase> calculations = failureMechanism.CalculationsGroup.Children; calculations.AddRange(new[] { calculationA, calculationB }); var nodeData = new StabilityStoneCoverFailureMechanismContext(failureMechanism, assessmentSection); using (var treeViewControl = new TreeViewControl()) { IMainWindow mainWindow = MainWindowTestHelper.CreateMainWindowStub(mocks); var gui = mocks.Stub <IGui>(); gui.Stub(g => g.Get(nodeData, treeViewControl)).Return(new CustomItemsOnlyContextMenuBuilder()); gui.Stub(g => g.MainWindow).Return(mainWindow); var calculatorFactory = mocks.Stub <IHydraRingCalculatorFactory>(); calculatorFactory.Expect(cf => cf.CreateWaveConditionsCosineCalculator(Arg <HydraRingCalculationSettings> .Is.NotNull)) .WhenCalled(invocation => { HydraRingCalculationSettingsTestHelper.AssertHydraRingCalculationSettings( HydraulicBoundaryCalculationSettingsFactory.CreateSettings(assessmentSection.HydraulicBoundaryDatabase), (HydraRingCalculationSettings)invocation.Arguments[0]); }) .Return(new TestWaveConditionsCosineCalculator()) .Repeat .Times(12); mocks.ReplayAll(); plugin.Gui = gui; using (new HydraRingCalculatorFactoryConfig(calculatorFactory)) using (ContextMenuStrip contextMenu = info.ContextMenuStrip(nodeData, null, treeViewControl)) { // When contextMenu.Items[contextMenuCalculateAllIndex].PerformClick(); // Then Assert.AreEqual(3, calculationA.Output.BlocksOutput.Count()); Assert.AreEqual(3, calculationA.Output.ColumnsOutput.Count()); Assert.AreEqual(3, calculationB.Output.BlocksOutput.Count()); Assert.AreEqual(3, calculationB.Output.ColumnsOutput.Count()); } } }
public void Constructor_InAssemblyTrue_PropertiesHaveExpectedAttributesValues() { // Setup var failureMechanism = new StabilityStoneCoverFailureMechanism(); // Call var properties = new StabilityStoneCoverFailureMechanismProperties(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."); }
private static void AddEntitiesForFailureMechanismMeta(StabilityStoneCoverFailureMechanism failureMechanism, FailureMechanismEntity entity) { var metaEntity = new StabilityStoneCoverFailureMechanismMetaEntity { ForeshoreProfileCollectionSourcePath = failureMechanism.ForeshoreProfiles.SourcePath.DeepClone(), N = failureMechanism.GeneralInput.N, ApplyLengthEffectInSection = Convert.ToByte(failureMechanism.GeneralInput.ApplyLengthEffectInSection) }; entity.StabilityStoneCoverFailureMechanismMetaEntities.Add(metaEntity); }