public void SetPropertyValueAfterConfirmation_ConfirmationRequiredAndGivenExceptionInSetValue_ExceptionBubbled() { // Setup DialogBoxHandler = (name, wnd) => { var tester = new MessageBoxTester(wnd); tester.ClickOk(); }; var testFailureMechanism = new TestCalculatableFailureMechanism( new[] { CalculationTestDataFactory.CreateCalculationWithOutput() }); var changeHandler = new FailureMechanismPropertyChangeHandler <ICalculatableFailureMechanism>(); var expectedException = new Exception(); // Call void Call() => changeHandler.SetPropertyValueAfterConfirmation(testFailureMechanism, 3, (f, v) => { throw expectedException; }); // Assert var exception = Assert.Throws <Exception>(Call); Assert.AreSame(expectedException, exception); }
public void ShouldCloseMethod_ViewNotCorrespondingToRemovedAssessmentSectionAndFailureMechanism_ReturnsFalse() { // Setup var otherFailureMechanism = new TestCalculatableFailureMechanism(); var mocks = new MockRepository(); var failureMechanism = mocks.Stub <IFailureMechanism>(); var assessmentSection = mocks.Stub <IAssessmentSection>(); assessmentSection.Stub(asm => asm.GetFailureMechanisms()).Return(new[] { failureMechanism }); assessmentSection.Stub(asm => asm.SpecificFailureMechanisms).Return(new ObservableList <SpecificFailureMechanism>()); mocks.ReplayAll(); using (IView view = GetView(otherFailureMechanism)) { // Call bool closeForData = ShouldCloseMethod(view, assessmentSection); // Assert Assert.IsFalse(closeForData); } mocks.VerifyAll(); }
public void GivenScenariosView_WhenFailureMechanismNotifiesObserver_ThenDataGridViewUpdated() { // Given var failureMechanism = new TestCalculatableFailureMechanism(); ShowFullyConfiguredScenariosView(new CalculationGroup(), failureMechanism); var dataGridView = (DataGridView) new ControlTester("dataGridView").TheObject; TestScenarioRow[] sectionResultRows = dataGridView.Rows.Cast <DataGridViewRow>() .Select(r => r.DataBoundItem) .Cast <TestScenarioRow>() .ToArray(); // When failureMechanism.NotifyObservers(); // Then TestScenarioRow[] updatedRows = dataGridView.Rows.Cast <DataGridViewRow>() .Select(r => r.DataBoundItem) .Cast <TestScenarioRow>() .ToArray(); CollectionAssert.AreNotEquivalent(sectionResultRows, updatedRows); }
private void ShowScenariosView(CalculationGroup calculationGroup, TestCalculatableFailureMechanism failureMechanism) { var scenariosView = new TestScenariosView(calculationGroup, failureMechanism); testForm.Controls.Add(scenariosView); testForm.Show(); }
public void GivenFailureMechanismResultObserverWithCalculationAndAttachedObserver_WhenCalculationInputNotifiesObservers_ThenAttachedObserverNotified() { // Given var failureMechanism = new TestCalculatableFailureMechanism(); var calculation = new TestCalculationWithInput(); failureMechanism.CalculationsGroup.Children.Add(calculation); using (var resultObserver = new CalculatableFailureMechanismResultObserver <TestCalculatableFailureMechanism, FailureMechanismSectionResult, TestCalculationWithInput>(failureMechanism)) { var mocks = new MockRepository(); var observer = mocks.StrictMock <IObserver>(); observer.Expect(o => o.UpdateObserver()); mocks.ReplayAll(); resultObserver.Attach(observer); // When calculation.InputParameters.NotifyObservers(); // Then mocks.VerifyAll(); } }
public DerivedTestStructuresCalculationScenarioContext(StructuresCalculationScenario <TestStructuresInput> calculation, CalculationGroup parent, TestCalculatableFailureMechanism failureMechanism, IAssessmentSection assessmentSection) : base(calculation, parent, failureMechanism, assessmentSection) { }
public void SetPropertyValueAfterConfirmation_ConfirmationRequiredButNotGiven_SetValueNotCalledNoAffectedObjectsReturned() { // Setup DialogBoxHandler = (name, wnd) => { var tester = new MessageBoxTester(wnd); tester.ClickCancel(); }; ICalculation calculationWithOutput = CalculationTestDataFactory.CreateCalculationWithOutput(); ICalculation calculationWithoutOutput = CalculationTestDataFactory.CreateCalculationWithoutOutput(); var testFailureMechanism = new TestCalculatableFailureMechanism( new[] { calculationWithOutput, calculationWithoutOutput }); var propertySet = 0; var changeHandler = new FailureMechanismPropertyChangeHandler <ICalculatableFailureMechanism>(); // Call IEnumerable <IObservable> affectedObjects = changeHandler.SetPropertyValueAfterConfirmation( testFailureMechanism, 3, (f, v) => propertySet++); // Assert Assert.AreEqual(0, propertySet); CollectionAssert.IsEmpty(affectedObjects); Assert.IsTrue(calculationWithOutput.HasOutput); }
public void GivenScenariosView_WhenSelectingDifferentItemInSectionsListBox_ThenDataGridViewUpdated() { // Given var failureMechanism = new TestCalculatableFailureMechanism(); ShowFullyConfiguredScenariosView(new CalculationGroup(), failureMechanism); var listBox = (ListBox) new ControlTester("listBox").TheObject; var dataGridView = (DataGridView) new ControlTester("dataGridView").TheObject; // Precondition Assert.AreSame(failureMechanism.Sections.First(), listBox.SelectedItem); TestScenarioRow[] sectionResultRows = dataGridView.Rows.Cast <DataGridViewRow>() .Select(r => r.DataBoundItem) .Cast <TestScenarioRow>() .ToArray(); // When listBox.SelectedItem = failureMechanism.Sections.Last(); // Then TestScenarioRow[] updatedRows = dataGridView.Rows.Cast <DataGridViewRow>() .Select(r => r.DataBoundItem) .Cast <TestScenarioRow>() .ToArray(); CollectionAssert.AreNotEquivalent(sectionResultRows, updatedRows); }
public void RequireConfirmation_FailureMechanismWithCalculationWithOutput_ReturnTrue() { // Setup var mockRepository = new MockRepository(); var inquiryHandler = mockRepository.StrictMock <IInquiryHelper>(); var calculation = mockRepository.StrictMock <ICalculation>(); calculation.Expect(calc => calc.HasOutput).Return(true); mockRepository.ReplayAll(); var failureMechanism = new TestCalculatableFailureMechanism(new[] { calculation }); var handler = new FailureMechanismCalculationChangeHandler(failureMechanism, string.Empty, inquiryHandler); // Call bool requireConfirmation = handler.RequireConfirmation(); // Assert Assert.IsTrue(requireConfirmation); mockRepository.VerifyAll(); }
public void AssembleSection_CalculatorThrowsException_ThrowsAssemblyException() { // Setup var failureMechanism = new TestCalculatableFailureMechanism(); FailureMechanismSection section = FailureMechanismSectionTestFactory.CreateFailureMechanismSection(); var sectionResult = new AdoptableFailureMechanismSectionResult(section); var assessmentSection = new AssessmentSectionStub(); using (new AssemblyToolCalculatorFactoryConfig()) { var calculatorFactory = (TestAssemblyToolCalculatorFactory)AssemblyToolCalculatorFactory.Instance; FailureMechanismSectionAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator; calculator.ThrowExceptionOnCalculate = true; // Call void Call() => StructuresFailureMechanismAssemblyFactory.AssembleSection <TestStructuresInput>( 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 UpdateForeshoreProfilesWithImportedData_MultipleCalculationsWithOutputAndProfile_UpdatesCalculationWithUpdatedProfile() { // Setup var affectedProfile = new TestForeshoreProfile("Name", "Updated ID"); TestCalculationWithForeshoreProfile affectedCalculation = TestCalculationWithForeshoreProfile.CreateCalculationWithOutput(affectedProfile); ForeshoreProfile profileToUpdateFrom = DeepCloneAndModify(affectedProfile); const string unaffectedProfileId = "Unaffected ID"; const string unaffectedProfileName = "Name"; var unaffectedProfile = new TestForeshoreProfile(unaffectedProfileName, unaffectedProfileId); TestCalculationWithForeshoreProfile unaffectedCalculation = TestCalculationWithForeshoreProfile.CreateCalculationWithOutput(unaffectedProfile); var foreshoreProfiles = new ForeshoreProfileCollection(); TestForeshoreProfile[] originalForeshoreProfiles = { affectedProfile, unaffectedProfile }; foreshoreProfiles.AddRange(originalForeshoreProfiles, sourceFilePath); var failureMechanism = new TestCalculatableFailureMechanism(new[] { affectedCalculation, unaffectedCalculation }); var strategy = new ForeshoreProfileUpdateDataStrategy(failureMechanism, foreshoreProfiles); // Call IEnumerable <IObservable> affectedObjects = strategy.UpdateForeshoreProfilesWithImportedData(new[] { new TestForeshoreProfile(unaffectedProfileName, unaffectedProfileId), profileToUpdateFrom }, sourceFilePath); // Assert Assert.IsTrue(unaffectedCalculation.HasOutput); Assert.AreSame(unaffectedProfile, unaffectedCalculation.InputParameters.ForeshoreProfile); Assert.IsFalse(affectedCalculation.HasOutput); Assert.AreSame(affectedProfile, affectedCalculation.InputParameters.ForeshoreProfile); CollectionAssert.AreEquivalent(originalForeshoreProfiles, foreshoreProfiles); CollectionAssert.AreEquivalent(new IObservable[] { affectedCalculation, affectedCalculation.InputParameters, affectedProfile, foreshoreProfiles }, affectedObjects); }
public TestCalculationsViewWithColumnStateDefinitions(CalculationGroup calculationGroup, TestCalculatableFailureMechanism failureMechanism, IAssessmentSection assessmentSection, bool initialReadOnlyState) : base(calculationGroup, failureMechanism, assessmentSection) { this.initialReadOnlyState = initialReadOnlyState; }
public void UpdateForeshoreProfilesWithImportedData_CalculationWithOutputAndForeshoreProfileUpdatedWithProfileWithoutGeometry_UpdatesCalculation() { // Setup const string id = "profile ID"; IEnumerable <Point2D> geometry = new[] { new Point2D(1, 2), new Point2D(3, 4) }; var affectedProfile = new TestForeshoreProfile(id, geometry); TestCalculationWithForeshoreProfile affectedCalculation = TestCalculationWithForeshoreProfile.CreateCalculationWithOutput(affectedProfile); affectedCalculation.InputParameters.UseForeshore = true; var profileToUpdateFrom = new TestForeshoreProfile(id, Enumerable.Empty <Point2D>()); var foreshoreProfiles = new ForeshoreProfileCollection(); TestForeshoreProfile[] originalForeshoreProfiles = { affectedProfile }; foreshoreProfiles.AddRange(originalForeshoreProfiles, sourceFilePath); var failureMechanism = new TestCalculatableFailureMechanism(new[] { affectedCalculation }); var strategy = new ForeshoreProfileUpdateDataStrategy(failureMechanism, foreshoreProfiles); // Call IEnumerable <IObservable> affectedObjects = strategy.UpdateForeshoreProfilesWithImportedData(new[] { profileToUpdateFrom }, sourceFilePath); // Assert Assert.IsFalse(affectedCalculation.HasOutput); Assert.IsFalse(affectedCalculation.InputParameters.UseForeshore); AssertForeshoreProfile(affectedProfile, profileToUpdateFrom); CollectionAssert.AreEquivalent(new IObservable[] { affectedCalculation, affectedCalculation.InputParameters, affectedProfile, foreshoreProfiles }, affectedObjects); }
public void SetPropertyValueAfterConfirmation_IfConfirmationRequiredThenGiven_SetValueCalledAffectedObjectsReturned(ChangePropertyTestCase testCase) { // Setup bool dialogBoxWillBeShown = testCase.ExpectedAffectedCalculations.Any(); var title = ""; var message = ""; if (dialogBoxWillBeShown) { DialogBoxHandler = (name, wnd) => { var tester = new MessageBoxTester(wnd); title = tester.Title; message = tester.Text; tester.ClickOk(); }; } var testFailureMechanism = new TestCalculatableFailureMechanism(testCase.Calculations); var propertySet = 0; var changeHandler = new FailureMechanismPropertyChangeHandler <ICalculatableFailureMechanism>(); // Precondition Assert.IsTrue(testCase.ExpectedAffectedCalculations.All(c => c.HasOutput)); // Call IEnumerable <IObservable> affectedObjects = changeHandler.SetPropertyValueAfterConfirmation( testFailureMechanism, 3, (f, v) => propertySet++); // Assert if (dialogBoxWillBeShown) { Assert.AreEqual("Bevestigen", title); string expectedMessage = "Als u deze parameter wijzigt, zal de uitvoer van alle berekeningen in dit faalmechanisme verwijderd worden." + Environment.NewLine + Environment.NewLine + "Weet u zeker dat u wilt doorgaan?"; Assert.AreEqual(expectedMessage, message); } Assert.AreEqual(1, propertySet); var expectedAffectedObjects = new List <IObservable>(testCase.ExpectedAffectedCalculations) { testFailureMechanism }; CollectionAssert.AreEqual(expectedAffectedObjects, affectedObjects); Assert.IsTrue(testCase.Calculations.All(c => !c.HasOutput)); }
public void GivenMapLayerWithFailureMechanismSectionAssemblyResults_WhenChangingNestedCalculationScenarioInputDataAndObserversNotified_ThenMapDataUpdated() { // Given var mocks = new MockRepository(); var observer = mocks.StrictMock <IObserver>(); observer.Expect(o => o.UpdateObserver()); mocks.ReplayAll(); var random = new Random(21); var calculationScenario = new TestCalculationScenario(); var failureMechanism = new TestCalculatableFailureMechanism(new[] { calculationScenario }); failureMechanism.SetSections(new[] { FailureMechanismSectionTestFactory.CreateFailureMechanismSection() }, string.Empty); var nestedCalculationScenario = new TestCalculationScenario(); var nestedCalculationGroup = new CalculationGroup(); nestedCalculationGroup.Children.Add(nestedCalculationScenario); failureMechanism.CalculationsGroup.Children.Add(nestedCalculationGroup); var assemblyResult = new FailureMechanismSectionAssemblyResult( random.NextDouble(), random.NextDouble(), random.NextDouble(), random.NextEnumValue <FailureMechanismSectionAssemblyGroup>()); using (var mapLayer = new CalculatableFailureMechanismSectionResultsMapLayer <TestCalculatableFailureMechanism, TestFailureMechanismSectionResult, TestCalculationInput>( failureMechanism, result => assemblyResult)) { mapLayer.MapData.Attach(observer); // Precondition MapDataTestHelper.AssertAssemblyMapData(failureMechanism, assemblyResult, mapLayer.MapData); // When assemblyResult = new FailureMechanismSectionAssemblyResult( random.NextDouble(), random.NextDouble(), random.NextDouble(), random.NextEnumValue <FailureMechanismSectionAssemblyGroup>()); nestedCalculationScenario.InputParameters.HydraulicBoundaryLocation = new TestHydraulicBoundaryLocation(); nestedCalculationScenario.InputParameters.NotifyObservers(); // Then MapDataTestHelper.AssertAssemblyMapData(failureMechanism, assemblyResult, mapLayer.MapData); } mocks.VerifyAll(); }
public void UpdateForeshoreProfilesWithImportedData_CalculationsWithForeshoreProfilesAndOutput_CalculationUpdatedAndReturnsAffectedData() { // Setup var foreshoreProfile = new TestForeshoreProfile(); TestCalculationWithForeshoreProfile calculationWithForeshoreProfileAndOutput = TestCalculationWithForeshoreProfile.CreateCalculationWithOutput(foreshoreProfile); TestCalculationWithForeshoreProfile calculationWithForeshoreProfile = TestCalculationWithForeshoreProfile.CreateCalculationWithoutOutput(foreshoreProfile); TestCalculationWithForeshoreProfile calculationWithoutForeshoreProfile = TestCalculationWithForeshoreProfile.CreateDefaultCalculation(); var failureMechanism = new TestCalculatableFailureMechanism(new[] { calculationWithForeshoreProfileAndOutput, calculationWithForeshoreProfile, calculationWithoutForeshoreProfile }); var foreshoreProfiles = new ForeshoreProfileCollection(); foreshoreProfiles.AddRange(new[] { foreshoreProfile }, sourceFilePath); TestCalculationWithForeshoreProfile[] calculationsWithForeshoreProfile = { calculationWithForeshoreProfileAndOutput, calculationWithForeshoreProfile }; var strategy = new ForeshoreProfileReplaceDataStrategy(failureMechanism, foreshoreProfiles); // Call IEnumerable <IObservable> affectedObjects = strategy.UpdateForeshoreProfilesWithImportedData(Enumerable.Empty <ForeshoreProfile>(), sourceFilePath); // Assert CollectionAssert.IsEmpty(foreshoreProfiles); Assert.IsFalse(calculationWithForeshoreProfileAndOutput.HasOutput); Assert.IsTrue(calculationsWithForeshoreProfile.All(calc => calc.InputParameters.ForeshoreProfile == null)); IEnumerable <IObservable> expectedAffectedObjects = calculationsWithForeshoreProfile.Select(calc => calc.InputParameters) .Concat(new IObservable[] { foreshoreProfiles, calculationWithForeshoreProfileAndOutput }); CollectionAssert.AreEquivalent(expectedAffectedObjects, affectedObjects); }
public void ShouldCloseMethod_ViewCorrespondingToRemovedFailureMechanism_ReturnsTrue() { // Setup var failureMechanism = new TestCalculatableFailureMechanism(); using (IView view = GetView(failureMechanism)) { // Call bool closeForData = ShouldCloseMethod(view, failureMechanism); // Assert Assert.IsTrue(closeForData); } }
public void AssembleSection_AssessmentSectionNull_ThrowsArgumentNullException() { // Setup FailureMechanismSection section = FailureMechanismSectionTestFactory.CreateFailureMechanismSection(); var sectionResult = new AdoptableFailureMechanismSectionResult(section); var failureMechanism = new TestCalculatableFailureMechanism(); // Call void Call() => StructuresFailureMechanismAssemblyFactory.AssembleSection <TestStructuresInput>(sectionResult, failureMechanism, null); // Assert var exception = Assert.Throws <ArgumentNullException>(Call); Assert.AreEqual("assessmentSection", exception.ParamName); }
public void GivenScenariosView_WhenFailureMechanismNotifiesObserver_ThenSectionsListBoxCorrectlyUpdated() { // Given var failureMechanism = new TestCalculatableFailureMechanism(); ShowScenariosView(new CalculationGroup(), failureMechanism); var listBox = (ListBox) new ControlTester("listBox").TheObject; // Precondition CollectionAssert.IsEmpty(listBox.Items); // When var failureMechanismSection1 = new FailureMechanismSection("Section 1", new[] { new Point2D(0.0, 0.0), new Point2D(5.0, 0.0) }); var failureMechanismSection2 = new FailureMechanismSection("Section 2", new[] { new Point2D(5.0, 0.0), new Point2D(10.0, 0.0) }); var failureMechanismSection3 = new FailureMechanismSection("Section 3", new[] { new Point2D(10.0, 0.0), new Point2D(15.0, 0.0) }); FailureMechanismTestHelper.SetSections(failureMechanism, new[] { failureMechanismSection1, failureMechanismSection2, failureMechanismSection3 }); failureMechanism.NotifyObservers(); // Then Assert.AreEqual(3, listBox.Items.Count); Assert.AreSame(failureMechanismSection1, listBox.Items[0]); Assert.AreSame(failureMechanismSection2, listBox.Items[1]); Assert.AreSame(failureMechanismSection3, listBox.Items[2]); Assert.AreSame(failureMechanismSection1, listBox.SelectedItem); }
public void RequireConfirmation_FailureMechanismWithoutCalculations_ReturnsFalse() { // Setup var mockRepository = new MockRepository(); var inquiryHandler = mockRepository.StrictMock <IInquiryHelper>(); mockRepository.ReplayAll(); var failureMechanism = new TestCalculatableFailureMechanism(Enumerable.Empty <ICalculation>()); var handler = new FailureMechanismCalculationChangeHandler(failureMechanism, string.Empty, inquiryHandler); // Call bool requireConfirmation = handler.RequireConfirmation(); // Assert Assert.IsFalse(requireConfirmation); mockRepository.VerifyAll(); }
public void SetPropertyValueAfterConfirmation_ConfirmationNotRequiredExceptionInSetValue_ExceptionBubbled() { // Setup var testFailureMechanism = new TestCalculatableFailureMechanism(); var changeHandler = new FailureMechanismPropertyChangeHandler <ICalculatableFailureMechanism>(); var expectedException = new Exception(); // Call void Call() => changeHandler.SetPropertyValueAfterConfirmation(testFailureMechanism, 3, (f, v) => { throw expectedException; }); // Assert var exception = Assert.Throws <Exception>(Call); Assert.AreSame(expectedException, exception); }
public void UpdateForeshoreProfilesWithImportedData_MultipleCalculationsWithSameReference_OnlyReturnsDistinctCalculations() { // Setup var affectedProfile = new TestForeshoreProfile("Name", "Updated ID"); TestCalculationWithForeshoreProfile affectedCalculation = TestCalculationWithForeshoreProfile.CreateCalculationWithOutput(affectedProfile); ForeshoreProfile profileToUpdateFrom = DeepCloneAndModify(affectedProfile); TestCalculationWithForeshoreProfile calculationSameReference = affectedCalculation; var foreshoreProfiles = new ForeshoreProfileCollection(); TestForeshoreProfile[] originalForeshoreProfiles = { affectedProfile }; foreshoreProfiles.AddRange(originalForeshoreProfiles, sourceFilePath); var failureMechanism = new TestCalculatableFailureMechanism(new[] { affectedCalculation, calculationSameReference }); var strategy = new ForeshoreProfileUpdateDataStrategy(failureMechanism, foreshoreProfiles); // Call IEnumerable <IObservable> affectedObjects = strategy.UpdateForeshoreProfilesWithImportedData(new[] { profileToUpdateFrom }, sourceFilePath); // Assert CollectionAssert.AreEquivalent(new IObservable[] { affectedCalculation, affectedCalculation.InputParameters, affectedProfile, foreshoreProfiles }, affectedObjects); }
public void AssembleSection_SectionResultNull_ThrowsArgumentNullException() { // Setup var mocks = new MockRepository(); var assessmentSection = mocks.Stub <IAssessmentSection>(); mocks.ReplayAll(); var failureMechanism = new TestCalculatableFailureMechanism(); // Call void Call() => StructuresFailureMechanismAssemblyFactory.AssembleSection <TestStructuresInput>(null, failureMechanism, assessmentSection); // Assert var exception = Assert.Throws <ArgumentNullException>(Call); Assert.AreEqual("sectionResult", exception.ParamName); mocks.VerifyAll(); }
public void Constructor_ParentNull_ThrowsArgumentNullException() { // Setup var mockRepository = new MockRepository(); var assessmentSection = mockRepository.Stub <IAssessmentSection>(); mockRepository.ReplayAll(); var calculation = new TestStructuresCalculationScenario(); var failureMechanism = new TestCalculatableFailureMechanism(); // Call void Call() => new TestStructuresCalculationScenarioContext(calculation, null, failureMechanism, assessmentSection); // Assert var exception = Assert.Throws <ArgumentNullException>(Call); Assert.AreEqual("parent", exception.ParamName); mockRepository.VerifyAll(); }
public void ShouldCloseMethod_ViewNotCorrespondingToRemovedFailureMechanism_ReturnsFalse() { // Setup var otherFailureMechanism = new TestCalculatableFailureMechanism(); var mocks = new MockRepository(); var failureMechanism = mocks.Stub <IFailureMechanism>(); mocks.ReplayAll(); using (IView view = GetView(otherFailureMechanism)) { // Call bool closeForData = ShouldCloseMethod(view, failureMechanism); // Assert Assert.IsFalse(closeForData); } mocks.VerifyAll(); }
public void Constructor_ListBoxCorrectlyInitialized() { // Setup var failureMechanism = new TestCalculatableFailureMechanism(); var failureMechanismSection1 = new FailureMechanismSection("Section 1", new[] { new Point2D(0.0, 0.0), new Point2D(5.0, 0.0) }); var failureMechanismSection2 = new FailureMechanismSection("Section 2", new[] { new Point2D(5.0, 0.0), new Point2D(10.0, 0.0) }); var failureMechanismSection3 = new FailureMechanismSection("Section 3", new[] { new Point2D(10.0, 0.0), new Point2D(15.0, 0.0) }); FailureMechanismTestHelper.SetSections(failureMechanism, new[] { failureMechanismSection1, failureMechanismSection2, failureMechanismSection3 }); // Call ShowScenariosView(new CalculationGroup(), failureMechanism); // Assert var listBox = (ListBox) new ControlTester("listBox").TheObject; Assert.AreEqual(nameof(FailureMechanismSection.Name), listBox.DisplayMember); Assert.AreEqual(3, listBox.Items.Count); Assert.AreSame(failureMechanismSection1, listBox.Items[0]); Assert.AreSame(failureMechanismSection2, listBox.Items[1]); Assert.AreSame(failureMechanismSection3, listBox.Items[2]); Assert.AreSame(failureMechanismSection1, listBox.SelectedItem); }
public void AssembleSection_CalculatorRan_ReturnsExpectedOutput() { // Setup var failureMechanism = new TestCalculatableFailureMechanism(); FailureMechanismSection section = FailureMechanismSectionTestFactory.CreateFailureMechanismSection(); var sectionResult = new AdoptableFailureMechanismSectionResult(section); var assessmentSection = new AssessmentSectionStub(); using (new AssemblyToolCalculatorFactoryConfig()) { var calculatorFactory = (TestAssemblyToolCalculatorFactory)AssemblyToolCalculatorFactory.Instance; FailureMechanismSectionAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator; // Call FailureMechanismSectionAssemblyResultWrapper result = StructuresFailureMechanismAssemblyFactory.AssembleSection <TestStructuresInput>( sectionResult, failureMechanism, assessmentSection); // Assert Assert.AreSame(calculator.FailureMechanismSectionAssemblyResultOutput, result); } }
public void AssembleSection_WithInput_SetsInputOnCalculator() { // Setup var random = new Random(21); FailureMechanismSection section = FailureMechanismSectionTestFactory.CreateFailureMechanismSection(); var sectionResult = new AdoptableFailureMechanismSectionResult(section) { IsRelevant = random.NextBoolean(), InitialFailureMechanismResultType = AdoptableInitialFailureMechanismResultType.Manual, FurtherAnalysisType = random.NextEnumValue <FailureMechanismSectionResultFurtherAnalysisType>(), RefinedSectionProbability = random.NextDouble() }; var failureMechanism = new TestCalculatableFailureMechanism(); var assessmentSection = new AssessmentSectionStub(); using (new AssemblyToolCalculatorFactoryConfig()) { var calculatorFactory = (TestAssemblyToolCalculatorFactory)AssemblyToolCalculatorFactory.Instance; FailureMechanismSectionAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator; // Call StructuresFailureMechanismAssemblyFactory.AssembleSection <TestStructuresInput>(sectionResult, failureMechanism, assessmentSection); // Assert FailureMechanismSectionAssemblyInput calculatorInput = calculator.FailureMechanismSectionAssemblyInput; 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.ManualInitialFailureMechanismResultSectionProbability, calculatorInput.InitialSectionProbability); Assert.AreEqual(sectionResult.FurtherAnalysisType, calculatorInput.FurtherAnalysisType); Assert.AreEqual(sectionResult.RefinedSectionProbability, calculatorInput.RefinedSectionProbability); } }
public void Validate_InputInvalidAccordingToValidationRule_LogErrorAndReturnFalse() { // Setup var failureMechanism = new TestCalculatableFailureMechanism(); var mocks = new MockRepository(); IAssessmentSection assessmentSection = AssessmentSectionTestHelper.CreateAssessmentSectionStub( failureMechanism, mocks, validHydraulicBoundaryDatabaseFilePath); mocks.ReplayAll(); var calculation = new TestStructuresCalculation { InputParameters = { Structure = new TestStructure(), HydraulicBoundaryLocation = new TestHydraulicBoundaryLocation(), IsValid = false } }; var isValid = false; // Call void Call() => isValid = TestStructuresCalculationService.Validate(calculation, assessmentSection); // Assert TestHelper.AssertLogMessages(Call, messages => { string[] msgs = messages.ToArray(); Assert.AreEqual(3, msgs.Length); CalculationServiceTestHelper.AssertValidationStartMessage(msgs[0]); Assert.AreEqual("Error message", msgs[1]); CalculationServiceTestHelper.AssertValidationEndMessage(msgs[2]); }); Assert.IsFalse(isValid); mocks.VerifyAll(); }
public void Constructor_ExpectedValues() { // Setup var random = new Random(21); var failureMechanism = new TestCalculatableFailureMechanism(); failureMechanism.SetSections(new[] { FailureMechanismSectionTestFactory.CreateFailureMechanismSection() }, string.Empty); var assemblyResult = new FailureMechanismSectionAssemblyResult( random.NextDouble(), random.NextDouble(), random.NextDouble(), random.NextEnumValue <FailureMechanismSectionAssemblyGroup>()); // Call using (var mapLayer = new CalculatableFailureMechanismSectionResultsMapLayer <TestCalculatableFailureMechanism, TestFailureMechanismSectionResult, TestCalculationInput>( failureMechanism, result => assemblyResult)) { // Assert Assert.IsInstanceOf <NonCalculatableFailureMechanismSectionResultsMapLayer <TestFailureMechanismSectionResult> >(mapLayer); } }