public void AssembleFailureMechanism_CalculatorRan_ReturnsExpectedOutput() { // Setup var failureMechanism = new MacroStabilityInwardsFailureMechanism { AssemblyResult = { ProbabilityResultType = FailureMechanismAssemblyProbabilityResultType.Automatic } }; var assessmentSection = new AssessmentSectionStub(); using (new AssemblyToolCalculatorFactoryConfig()) { var calculatorFactory = (TestAssemblyToolCalculatorFactory)AssemblyToolCalculatorFactory.Instance; FailureMechanismAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedFailureMechanismAssemblyCalculator; // Call FailureMechanismAssemblyResultWrapper result = MacroStabilityInwardsFailureMechanismAssemblyFactory.AssembleFailureMechanism(failureMechanism, assessmentSection); // Assert Assert.AreSame(calculator.AssemblyResultOutput, result); } }
public void CalculationsViewWithHydraulicLocation_SpecificUseAssessmentLevelManualInputState_SelectableHydraulicLocationReadonlyAccordingly(bool useAssessmentLevelManualInput) { // Setup var mocks = new MockRepository(); var assessmentSection = mocks.Stub <IAssessmentSection>(); ConfigureHydraulicBoundaryDatabase(assessmentSection); mocks.ReplayAll(); MacroStabilityInwardsFailureMechanism failureMechanism = ConfigureFailureMechanism(); CalculationGroup calculationGroup = ConfigureCalculationGroup(assessmentSection, failureMechanism); ShowMacroStabilityInwardsCalculationsView(calculationGroup, failureMechanism, assessmentSection); var calculation = (MacroStabilityInwardsCalculationScenario)calculationGroup.Children.First(); var dataGridView = (DataGridView) new ControlTester("dataGridView").TheObject; // Call calculation.InputParameters.UseAssessmentLevelManualInput = useAssessmentLevelManualInput; calculation.InputParameters.NotifyObservers(); // Assert Assert.IsFalse(dataGridView.Rows[0].ReadOnly); var currentCellUpdated = (DataGridViewComboBoxCell)dataGridView.Rows[0].Cells[selectableHydraulicBoundaryLocationsColumnIndex]; Assert.AreEqual(useAssessmentLevelManualInput, currentCellUpdated.ReadOnly); mocks.VerifyAll(); }
public void VerifyUpdates_CalculationWithoutOutputs_ReturnsTrue() { // Setup var mocks = new MockRepository(); var assessmentSection = mocks.Stub <IAssessmentSection>(); var mainWindow = mocks.Stub <IMainWindow>(); var gui = mocks.Stub <IGui>(); gui.Stub(g => g.MainWindow).Return(mainWindow); mocks.ReplayAll(); plugin.Gui = gui; var failureMechanism = new MacroStabilityInwardsFailureMechanism(); failureMechanism.CalculationsGroup.Children.Add(new MacroStabilityInwardsCalculationScenario()); var stochasticSoilModelCollection = new MacroStabilityInwardsStochasticSoilModelCollection(); var context = new MacroStabilityInwardsStochasticSoilModelCollectionContext(stochasticSoilModelCollection, failureMechanism, assessmentSection); // Call bool updatesVerified = importInfo.VerifyUpdates(context); // Assert Assert.IsTrue(updatesVerified); mocks.VerifyAll(); }
public void ButtonGenerateScenarios_WithSurfaceLinesAndSoilModels_ButtonEnabled() { // Setup var mocks = new MockRepository(); var assessmentSection = mocks.Stub <IAssessmentSection>(); ConfigureHydraulicBoundaryDatabase(assessmentSection); mocks.ReplayAll(); const string arbitrarySourcePath = "path"; var failureMechanism = new MacroStabilityInwardsFailureMechanism(); failureMechanism.SurfaceLines.AddRange(new[] { new MacroStabilityInwardsSurfaceLine(string.Empty) }, arbitrarySourcePath); failureMechanism.StochasticSoilModels.AddRange(new[] { MacroStabilityInwardsStochasticSoilModelTestFactory.CreateValidStochasticSoilModel() }, arbitrarySourcePath); ShowMacroStabilityInwardsCalculationsView(new CalculationGroup(), failureMechanism, assessmentSection); var button = (Button) new ControlTester("generateButton").TheObject; // Call bool state = button.Enabled; // Assert Assert.IsTrue(state); mocks.VerifyAll(); }
public void Selection_Always_ReturnsTheSelectedRowObject(int selectedRow) { // Setup var mocks = new MockRepository(); var assessmentSection = mocks.Stub <IAssessmentSection>(); ConfigureHydraulicBoundaryDatabase(assessmentSection); mocks.ReplayAll(); MacroStabilityInwardsFailureMechanism failureMechanism = ConfigureFailureMechanism(); MacroStabilityInwardsCalculationsView view = ShowMacroStabilityInwardsCalculationsView(ConfigureCalculationGroup(assessmentSection, failureMechanism), failureMechanism, assessmentSection); var dataGridView = (DataGridView) new ControlTester("dataGridView").TheObject; dataGridView.CurrentCell = dataGridView.Rows[selectedRow].Cells[0]; // Call object selection = view.Selection; // Assert Assert.IsInstanceOf <MacroStabilityInwardsInputContext>(selection); var dataRow = (MacroStabilityInwardsCalculationRow)dataGridView.Rows[selectedRow].DataBoundItem; Assert.AreSame(dataRow.Calculation, ((MacroStabilityInwardsInputContext)selection).MacroStabilityInwardsCalculation); mocks.VerifyAll(); }
public void GivenScenarioRow_WhenOutputSetToNullAndUpdate_ThenDerivedOutputUpdated() { // Given var calculation = new MacroStabilityInwardsCalculationScenario { Output = MacroStabilityInwardsOutputTestFactory.CreateRandomOutput() }; var failureMechanism = new MacroStabilityInwardsFailureMechanism(); FailureMechanismSection failureMechanismSection = FailureMechanismSectionTestFactory.CreateFailureMechanismSection(); var row = new MacroStabilityInwardsScenarioRow(calculation, failureMechanism, failureMechanismSection); // Precondition DerivedMacroStabilityInwardsOutput expectedDerivedOutput = DerivedMacroStabilityInwardsOutputFactory.Create(calculation.Output, failureMechanism.GeneralInput.ModelFactor); Assert.AreEqual(expectedDerivedOutput.MacroStabilityInwardsProbability, row.FailureProbability); Assert.AreEqual(expectedDerivedOutput.MacroStabilityInwardsProbability * failureMechanism.MacroStabilityInwardsProbabilityAssessmentInput.GetN( failureMechanismSection.Length), row.SectionFailureProbability); // When calculation.Output = null; row.Update(); // Then Assert.IsNaN(row.FailureProbability); Assert.IsNaN(row.SectionFailureProbability); }
public void CalculationsView_FailureMechanismWithCorrespondingSoilProfiles_SoilProfilesComboboxCorrectlyInitialized() { // Setup var mocks = new MockRepository(); var assessmentSection = mocks.Stub <IAssessmentSection>(); ConfigureHydraulicBoundaryDatabase(assessmentSection); mocks.ReplayAll(); MacroStabilityInwardsFailureMechanism failureMechanism = ConfigureFailureMechanism(); // Call ShowMacroStabilityInwardsCalculationsView(ConfigureCalculationGroup(assessmentSection, failureMechanism), failureMechanism, assessmentSection); var dataGridView = (DataGridView) new ControlTester("dataGridView").TheObject; // Assert DataGridViewComboBoxCell.ObjectCollection soilProfilesComboboxItems = ((DataGridViewComboBoxCell)dataGridView.Rows[0].Cells[stochasticSoilProfilesColumnIndex]).Items; Assert.AreEqual(3, soilProfilesComboboxItems.Count); Assert.AreEqual("<selecteer>", soilProfilesComboboxItems[0].ToString()); Assert.AreEqual("Profile 1", soilProfilesComboboxItems[1].ToString()); Assert.AreEqual("Profile 2", soilProfilesComboboxItems[2].ToString()); soilProfilesComboboxItems = ((DataGridViewComboBoxCell)dataGridView.Rows[1].Cells[stochasticSoilProfilesColumnIndex]).Items; Assert.AreEqual(2, soilProfilesComboboxItems.Count); Assert.AreEqual("<selecteer>", soilProfilesComboboxItems[0].ToString()); Assert.AreEqual("Profile 5", soilProfilesComboboxItems[1].ToString()); mocks.VerifyAll(); }
public void Create_WithStochasticSoilModels_ReturnsFailureMechanismEntityWithStochasticSoilModelEntities() { // Setup var failureMechanism = new MacroStabilityInwardsFailureMechanism(); MacroStabilityInwardsStochasticSoilModelCollection stochasticSoilModels = failureMechanism.StochasticSoilModels; stochasticSoilModels.AddRange(new[] { MacroStabilityInwardsStochasticSoilModelTestFactory.CreateValidStochasticSoilModel("name"), MacroStabilityInwardsStochasticSoilModelTestFactory.CreateValidStochasticSoilModel("name2") }, "some/path/to/file"); var registry = new PersistenceRegistry(); // Call FailureMechanismEntity entity = failureMechanism.Create(registry); // Assert Assert.IsNotNull(entity); Assert.AreEqual(stochasticSoilModels.Count, entity.StochasticSoilModelEntities.Count); for (var i = 0; i < stochasticSoilModels.Count; i++) { AssertStochasticSoilModel(stochasticSoilModels[i], entity.StochasticSoilModelEntities.ElementAt(i)); } string stochasticSoilModelCollectionSourcePath = entity.MacroStabilityInwardsFailureMechanismMetaEntities .Single() .StochasticSoilModelCollectionSourcePath; TestHelper.AssertAreEqualButNotSame(stochasticSoilModels.SourcePath, stochasticSoilModelCollectionSourcePath); }
public void Create_WithSurfaceLines_ReturnFailureMechanismEntityWithSurfaceLineEntities() { // Setup var failureMechanism = new MacroStabilityInwardsFailureMechanism(); MacroStabilityInwardsSurfaceLineCollection surfaceLines = failureMechanism.SurfaceLines; surfaceLines.AddRange(new[] { CreateSurfaceLine(new Random(31)) }, "path"); var registry = new PersistenceRegistry(); // Call FailureMechanismEntity entity = failureMechanism.Create(registry); // Assert Assert.IsNotNull(entity); Assert.AreEqual(surfaceLines.Count, entity.SurfaceLineEntities.Count); for (var i = 0; i < surfaceLines.Count; i++) { AssertSurfaceLine(surfaceLines[i], entity.SurfaceLineEntities.ElementAt(i)); } string surfaceLineCollectionSourcePath = entity.MacroStabilityInwardsFailureMechanismMetaEntities .Single() .SurfaceLineCollectionSourcePath; TestHelper.AssertAreEqualButNotSame(surfaceLines.SourcePath, surfaceLineCollectionSourcePath); }
public void DynamicVisibleValidationMethod_DependingOnInAssembly_ReturnExpectedVisibility(bool inAssembly) { // Setup var mocks = new MockRepository(); var assessmentSection = mocks.Stub <IAssessmentSection>(); mocks.ReplayAll(); var pipingFailureMechanism = new MacroStabilityInwardsFailureMechanism { InAssembly = inAssembly }; var properties = new MacroStabilityInwardsFailureMechanismProperties(pipingFailureMechanism, assessmentSection); // Assert Assert.IsTrue(properties.DynamicVisibleValidationMethod(nameof(properties.Name))); Assert.IsTrue(properties.DynamicVisibleValidationMethod(nameof(properties.Code))); Assert.IsTrue(properties.DynamicVisibleValidationMethod(nameof(properties.InAssembly))); Assert.AreEqual(inAssembly, properties.DynamicVisibleValidationMethod(nameof(properties.A))); Assert.AreEqual(inAssembly, properties.DynamicVisibleValidationMethod(nameof(properties.B))); Assert.AreEqual(inAssembly, properties.DynamicVisibleValidationMethod(nameof(properties.SectionLength))); Assert.AreEqual(inAssembly, properties.DynamicVisibleValidationMethod(nameof(properties.N))); Assert.AreEqual(inAssembly, properties.DynamicVisibleValidationMethod(nameof(properties.ApplyLengthEffectInSection))); Assert.IsTrue(properties.DynamicVisibleValidationMethod(null)); mocks.VerifyAll(); }
public void Create_StringPropertiesDoNotShareReference() { // Setup var failureMechanism = new MacroStabilityInwardsFailureMechanism { 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 Assert.IsNotNull(entity); 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 A_SetInvalidValue_ThrowsArgumentOutOfRangeExceptionNoNotifications(double value) { // Setup var mocks = new MockRepository(); var assessmentSection = mocks.Stub <IAssessmentSection>(); var observer = mocks.StrictMock <IObserver>(); mocks.ReplayAll(); var failureMechanism = new MacroStabilityInwardsFailureMechanism(); failureMechanism.Attach(observer); var properties = new MacroStabilityInwardsFailureMechanismProperties(failureMechanism, assessmentSection); // Call void Call() => properties.A = value; // Assert const string expectedMessage = "De waarde voor 'a' moet in het bereik [0,0, 1,0] liggen."; TestHelper.AssertThrowsArgumentExceptionAndTestMessage <ArgumentOutOfRangeException>(Call, expectedMessage); mocks.VerifyAll(); }
public void CurrentPath_SurfaceLineCollectionHasPathSet_ReturnsExpectedPath() { // Setup var mocks = new MockRepository(); var assessmentSection = mocks.Stub <IAssessmentSection>(); mocks.ReplayAll(); const string expectedFilePath = "some/path"; var surfaceLines = new MacroStabilityInwardsSurfaceLineCollection(); surfaceLines.AddRange(new[] { new MacroStabilityInwardsSurfaceLine(string.Empty) }, expectedFilePath); var failureMechanism = new MacroStabilityInwardsFailureMechanism(); var context = new MacroStabilityInwardsSurfaceLinesContext(surfaceLines, failureMechanism, assessmentSection); // Call string currentPath = updateInfo.CurrentPath(context); // Assert Assert.AreEqual(expectedFilePath, currentPath); mocks.VerifyAll(); }
public void AssembleFailureMechanism_CalculatorThrowsException_ThrowsAssemblyException() { // Setup var failureMechanism = new MacroStabilityInwardsFailureMechanism { 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() => MacroStabilityInwardsFailureMechanismAssemblyFactory.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 CloseForData_NestedViewCorrespondingToRemovedFailureMechanismContext_ReturnsTrue() { // Setup var assessmentSection = mocks.Stub <IAssessmentSection>(); mocks.ReplayAll(); var calculation = new MacroStabilityInwardsCalculationScenario(); var calculationGroup = new CalculationGroup(); calculationGroup.Children.Add(calculation); var failureMechanism = new MacroStabilityInwardsFailureMechanism(); failureMechanism.CalculationsGroup.Children.Add(calculationGroup); var context = new MacroStabilityInwardsFailureMechanismContext(failureMechanism, assessmentSection); using (var view = new MacroStabilityInwardsInputView(calculation, new GeneralMacroStabilityInwardsInput(), assessmentSection, GetHydraulicBoundaryLocationCalculation)) { // Call bool closeForData = info.CloseForData(view, context); // Assert Assert.IsTrue(closeForData); mocks.VerifyAll(); } }
public void Create_WithoutAllPropertiesSet_ReturnsFailureMechanismEntityWithPropertiesSet() { // Setup var failureMechanism = new MacroStabilityInwardsFailureMechanism(); var registry = new PersistenceRegistry(); // Call FailureMechanismEntity entity = failureMechanism.Create(registry); // Assert Assert.IsNotNull(entity); Assert.AreEqual((short)FailureMechanismType.MacroStabilityInwards, entity.FailureMechanismType); Assert.AreEqual(Convert.ToByte(failureMechanism.InAssembly), entity.InAssembly); Assert.AreEqual(failureMechanism.InAssemblyInputComments.Body, entity.InAssemblyInputComments); Assert.AreEqual(failureMechanism.InAssemblyOutputComments.Body, entity.InAssemblyOutputComments); Assert.AreEqual(failureMechanism.NotInAssemblyComments.Body, entity.NotInAssemblyComments); Assert.AreEqual(failureMechanism.CalculationsInputComments.Body, entity.CalculationsInputComments); Assert.AreEqual(failureMechanism.FailureMechanismSectionSourcePath, entity.FailureMechanismSectionCollectionSourcePath); CollectionAssert.IsEmpty(entity.StochasticSoilModelEntities); MacroStabilityInwardsFailureMechanismMetaEntity failureMechanismMetaEntity = entity.MacroStabilityInwardsFailureMechanismMetaEntities.Single(); Assert.AreEqual(failureMechanism.MacroStabilityInwardsProbabilityAssessmentInput.A, failureMechanismMetaEntity.A); Assert.AreEqual(failureMechanism.SurfaceLines.SourcePath, failureMechanismMetaEntity.SurfaceLineCollectionSourcePath); Assert.AreEqual(failureMechanism.StochasticSoilModels.SourcePath, failureMechanismMetaEntity.StochasticSoilModelCollectionSourcePath); }
public void CloseForData_NestedViewNotCorrespondingToRemovedAssessmentSection_ReturnsFalse() { // Setup var calculation = new MacroStabilityInwardsCalculationScenario(); var calculationGroup = new CalculationGroup(); calculationGroup.Children.Add(calculation); var failureMechanism = new MacroStabilityInwardsFailureMechanism(); failureMechanism.CalculationsGroup.Children.Add(calculationGroup); var assessmentSection = mocks.Stub <IAssessmentSection>(); assessmentSection.Stub(section => section.FailureMechanismContribution).Return(null); assessmentSection.Stub(section => section.GetFailureMechanisms()).Return(new[] { failureMechanism }); mocks.ReplayAll(); using (var view = new MacroStabilityInwardsInputView(new MacroStabilityInwardsCalculationScenario(), new GeneralMacroStabilityInwardsInput(), assessmentSection, GetHydraulicBoundaryLocationCalculation)) { // Call bool closeForData = info.CloseForData(view, assessmentSection); // Assert Assert.IsFalse(closeForData); mocks.VerifyAll(); } }
public void UpdateModelWithImportedData_WithCurrentModelAndImportedModelWithOtherName_ModelReplaced() { // Setup MacroStabilityInwardsStochasticSoilModel existingModel = MacroStabilityInwardsStochasticSoilModelTestFactory.CreateValidStochasticSoilModel("existing"); var failureMechanism = new MacroStabilityInwardsFailureMechanism(); failureMechanism.StochasticSoilModels.AddRange(new[] { existingModel }, sourceFilePath); var strategy = new MacroStabilityInwardsStochasticSoilModelUpdateDataStrategy(failureMechanism); MacroStabilityInwardsStochasticSoilModel readModel = MacroStabilityInwardsStochasticSoilModelTestFactory.CreateValidStochasticSoilModel("read"); // Call IEnumerable <IObservable> affectedObjects = strategy.UpdateModelWithImportedData(new[] { readModel }, sourceFilePath); // Assert Assert.AreSame(readModel, failureMechanism.StochasticSoilModels[0]); CollectionAssert.AreEqual(new[] { failureMechanism.StochasticSoilModels }, affectedObjects); }
public void Constructor_WithCalculationWithOutput_PropertiesFromCalculation(double sectionLength) { // Setup var calculation = new MacroStabilityInwardsCalculationScenario { Output = MacroStabilityInwardsOutputTestFactory.CreateOutput(new MacroStabilityInwardsOutput.ConstructionProperties { FactorOfStability = 0.1 }) }; var failureMechanism = new MacroStabilityInwardsFailureMechanism(); var failureMechanismSection = new FailureMechanismSection("test", new[] { new Point2D(0, 0), new Point2D(sectionLength, 0) }); // Call var row = new MacroStabilityInwardsScenarioRow(calculation, failureMechanism, failureMechanismSection); // Assert DerivedMacroStabilityInwardsOutput expectedDerivedOutput = DerivedMacroStabilityInwardsOutputFactory.Create(calculation.Output, failureMechanism.GeneralInput.ModelFactor); Assert.AreEqual(expectedDerivedOutput.MacroStabilityInwardsProbability, row.FailureProbability); Assert.AreEqual(Math.Min(1.0, expectedDerivedOutput.MacroStabilityInwardsProbability * failureMechanism.MacroStabilityInwardsProbabilityAssessmentInput.GetN( failureMechanismSection.Length)), row.SectionFailureProbability); }
public void UpdateModelWithImportedData_UpdateCurrentModelWithImportedModelWithOtherProfiles_ProfilesAdded() { // Setup const string modelsName = "same model"; MacroStabilityInwardsStochasticSoilModel existingModel = MacroStabilityInwardsStochasticSoilModelTestFactory.CreateValidStochasticSoilModel(modelsName); var failureMechanism = new MacroStabilityInwardsFailureMechanism(); MacroStabilityInwardsStochasticSoilModelCollection targetCollection = failureMechanism.StochasticSoilModels; targetCollection.AddRange(new[] { existingModel }, sourceFilePath); var strategy = new MacroStabilityInwardsStochasticSoilModelUpdateDataStrategy(failureMechanism); MacroStabilityInwardsStochasticSoilModel readModel = CreateSimpleModel(modelsName, "new profile A", "new profile B"); // Call IEnumerable <IObservable> affectedObjects = strategy.UpdateModelWithImportedData(new[] { readModel }, sourceFilePath); // Assert Assert.AreEqual(1, targetCollection.Count); Assert.AreSame(existingModel, targetCollection[0]); Assert.AreEqual(existingModel.StochasticSoilProfiles.Count(), targetCollection[0].StochasticSoilProfiles.Count()); CollectionAssert.AreEquivalent(new IObservable[] { targetCollection, existingModel }, affectedObjects); }
public void ButtonGenerateScenarios_WithoutSoilModels_ButtonDisabled() { // Setup var mocks = new MockRepository(); var assessmentSection = mocks.Stub <IAssessmentSection>(); ConfigureHydraulicBoundaryDatabase(assessmentSection); mocks.ReplayAll(); var failureMechanism = new MacroStabilityInwardsFailureMechanism(); failureMechanism.SurfaceLines.AddRange(new[] { new MacroStabilityInwardsSurfaceLine(string.Empty) }, "path"); ShowMacroStabilityInwardsCalculationsView(new CalculationGroup(), failureMechanism, assessmentSection); var button = (Button) new ControlTester("generateButton").TheObject; // Call bool state = button.Enabled; // Assert Assert.IsFalse(state); mocks.VerifyAll(); }
public void CloseForData_ViewCorrespondingToRemovedAssessmentSection_ReturnsTrue() { // Setup var failureMechanism = new MacroStabilityInwardsFailureMechanism(); var mocks = new MockRepository(); var assessmentSection = mocks.Stub <IAssessmentSection>(); assessmentSection.Stub(a => a.HydraulicBoundaryDatabase).Return(new HydraulicBoundaryDatabase()); assessmentSection.Stub(a => a.GetFailureMechanisms()).Return(new[] { failureMechanism }); mocks.ReplayAll(); using (var view = new MacroStabilityInwardsCalculationsView(failureMechanism.CalculationsGroup, failureMechanism, assessmentSection)) { // Call bool closeForData = info.CloseForData(view, assessmentSection); // Assert Assert.IsTrue(closeForData); } mocks.VerifyAll(); }
public void GivenFailureMechanismWithoutSurfaceLinesAndSoilModels_WhenAddSurfaceLineAndNotify_ThenButtonDisabled() { // Given var mocks = new MockRepository(); var assessmentSection = mocks.Stub <IAssessmentSection>(); ConfigureHydraulicBoundaryDatabase(assessmentSection); mocks.ReplayAll(); var failureMechanism = new MacroStabilityInwardsFailureMechanism(); ShowMacroStabilityInwardsCalculationsView(failureMechanism.CalculationsGroup, failureMechanism, assessmentSection); // When failureMechanism.SurfaceLines.AddRange(new[] { new MacroStabilityInwardsSurfaceLine(string.Empty) }, "path"); failureMechanism.NotifyObservers(); // Then var button = (Button) new ControlTester("generateButton").TheObject; Assert.IsFalse(button.Enabled); mocks.VerifyAll(); }
public void FailureMechanismResultsView_AllDataSet_SetsCorrectInputOnCalculator() { // Setup FailureMechanismSection section = FailureMechanismSectionTestFactory.CreateFailureMechanismSection(); var failureMechanism = new MacroStabilityInwardsFailureMechanism(); FailureMechanismTestHelper.SetSections(failureMechanism, new[] { section }); var assessmentSection = new AssessmentSectionStub(); // Call using (new AssemblyToolCalculatorFactoryConfig()) using (ShowFailureMechanismResultsView(failureMechanism, assessmentSection)) { // Assert var testFactory = (TestAssemblyToolCalculatorFactory)AssemblyToolCalculatorFactory.Instance; FailureMechanismAssemblyCalculatorStub calculator = testFactory.LastCreatedFailureMechanismAssemblyCalculator; double expectedN = failureMechanism.MacroStabilityInwardsProbabilityAssessmentInput.GetN(assessmentSection.ReferenceLine.Length); Assert.AreEqual(expectedN, calculator.FailureMechanismN); } }
public void GivenCalculationsViewGenerateScenariosCancelButtonClicked_WhenDialogClosed_CalculationsNotUpdatedAndCalculationGroupNotNotified() { // Given var mocks = new MockRepository(); var assessmentSection = mocks.Stub <IAssessmentSection>(); ConfigureHydraulicBoundaryDatabase(assessmentSection); var observer = mocks.StrictMock <IObserver>(); mocks.ReplayAll(); MacroStabilityInwardsFailureMechanism failureMechanism = ConfigureSimpleFailureMechanism(); ShowMacroStabilityInwardsCalculationsView(failureMechanism.CalculationsGroup, failureMechanism, assessmentSection); failureMechanism.CalculationsGroup.Attach(observer); var button = new ButtonTester("generateButton", testForm); DialogBoxHandler = (name, wnd) => { var selectionDialog = (MacroStabilityInwardsSurfaceLineSelectionDialog) new FormTester(name).TheObject; var selectionView = (DataGridViewControl) new ControlTester("DataGridViewControl", selectionDialog).TheObject; selectionView.Rows[0].Cells[0].Value = true; // When new ButtonTester("CustomCancelButton", selectionDialog).Click(); }; button.Click(); // Then CollectionAssert.IsEmpty(failureMechanism.Calculations); mocks.VerifyAll(); // No observer notified }
public void GivenViewWithSurfaceLineData_WhenSurfaceLineUpdatedAndNotified_ThenMapDataUpdated() { // Given var surfaceLine = new MacroStabilityInwardsSurfaceLine(string.Empty); var failureMechanism = new MacroStabilityInwardsFailureMechanism(); failureMechanism.SurfaceLines.AddRange(new[] { surfaceLine }, "path"); MacroStabilityInwardsFailureMechanismView view = CreateView(failureMechanism, new AssessmentSectionStub()); IMapControl map = ((RiskeerMapControl)view.Controls[0]).MapControl; var mocks = new MockRepository(); IObserver[] observers = AttachMapDataObservers(mocks, map.Data.Collection); observers[surfaceLinesIndex].Expect(obs => obs.UpdateObserver()); mocks.ReplayAll(); // When surfaceLine.SetGeometry(new[] { new Point3D(7, 8, 9), new Point3D(10, 11, 12) }); surfaceLine.NotifyObservers(); // Then var surfaceLineMapData = (MapLineData)map.Data.Collection.ElementAt(surfaceLinesIndex); AssertSurfaceLinesMapData(failureMechanism.SurfaceLines, surfaceLineMapData); mocks.VerifyAll(); }
public void CurrentPath_StochasticSoilModelCollectionHasPathSet_ReturnsExpectedPath() { // Setup var mocks = new MockRepository(); var assessmentSection = mocks.Stub <IAssessmentSection>(); mocks.ReplayAll(); const string expectedFilePath = "some/path"; var stochasticSoilModelCollection = new MacroStabilityInwardsStochasticSoilModelCollection(); stochasticSoilModelCollection.AddRange(new[] { MacroStabilityInwardsStochasticSoilModelTestFactory.CreateValidStochasticSoilModel() }, expectedFilePath); var failureMechanism = new MacroStabilityInwardsFailureMechanism(); var context = new MacroStabilityInwardsStochasticSoilModelCollectionContext(stochasticSoilModelCollection, failureMechanism, assessmentSection); // Call string currentPath = updateInfo.CurrentPath(context); // Assert Assert.AreEqual(expectedFilePath, currentPath); mocks.VerifyAll(); }
public void GivenViewWithStochasticSoilModels_WhenStochasticSoilModelsUpdatedAndNotified_ThenMapDataUpdated() { // Given var failureMechanism = new MacroStabilityInwardsFailureMechanism(); MacroStabilityInwardsFailureMechanismView view = CreateView(failureMechanism, new AssessmentSectionStub()); IMapControl map = ((RiskeerMapControl)view.Controls[0]).MapControl; var stochasticSoilModelMapData = (MapLineData)map.Data.Collection.ElementAt(stochasticSoilModelsIndex); var mocks = new MockRepository(); IObserver[] observers = AttachMapDataObservers(mocks, map.Data.Collection); observers[stochasticSoilModelsIndex].Expect(obs => obs.UpdateObserver()); mocks.ReplayAll(); // When failureMechanism.StochasticSoilModels.AddRange(new[] { MacroStabilityInwardsStochasticSoilModelTestFactory.CreateValidStochasticSoilModel("", new[] { new Point2D(1, 2), new Point2D(1, 2) }) }, "path"); failureMechanism.StochasticSoilModels.NotifyObservers(); // Then AssertStochasticSoilModelsMapData(failureMechanism.StochasticSoilModels, stochasticSoilModelMapData); mocks.VerifyAll(); }
public void CloseForData_ViewCorrespondingToRemovedAssessmentSection_ReturnsTrue() { // Setup var failureMechanism = new MacroStabilityInwardsFailureMechanism(); var assessmentSection = mocks.Stub <IAssessmentSection>(); assessmentSection.Stub(asm => asm.GetFailureMechanisms()).Return(new IFailureMechanism[] { failureMechanism }); mocks.ReplayAll(); using (var view = new MacroStabilityInwardsFailureMechanismResultView(failureMechanism.SectionResults, failureMechanism, assessmentSection)) { // Call bool closeForData = info.CloseForData(view, assessmentSection); // Assert Assert.IsTrue(closeForData); } mocks.VerifyAll(); }
public void AssembleFailureMechanism_WithInput_SetsInputOnCalculator() { // Setup var failureMechanism = new MacroStabilityInwardsFailureMechanism { 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 MacroStabilityInwardsFailureMechanismAssemblyFactory.AssembleFailureMechanism(failureMechanism, assessmentSection); // Assert double expectedN = failureMechanism.MacroStabilityInwardsProbabilityAssessmentInput.GetN(assessmentSection.ReferenceLine.Length); Assert.AreEqual(expectedN, failureMechanismAssemblyCalculator.FailureMechanismN); Assert.AreSame(calculator.FailureMechanismSectionAssemblyResultOutput.AssemblyResult, failureMechanismAssemblyCalculator.SectionAssemblyResultsInput.Single()); Assert.AreEqual(failureMechanism.GeneralInput.ApplyLengthEffectInSection, failureMechanismAssemblyCalculator.ApplyLengthEffect); } }