public void CanDrop_DraggedDataPartOfGroupContext_ReturnsTrue() { // Setup using (var plugin = new DuneErosionPlugin()) { TreeNodeInfo info = GetInfo(plugin); var assessmentSectionStub = new AssessmentSectionStub(); var failureMechanism = new DuneErosionFailureMechanism(); var calculationsForTargetProbability = new DuneLocationCalculationsForTargetProbability(0.1); var targetData = new DuneLocationCalculationsForUserDefinedTargetProbabilitiesGroupContext( new ObservableList <DuneLocationCalculationsForTargetProbability> { calculationsForTargetProbability }, failureMechanism, assessmentSectionStub); var draggedData = new DuneLocationCalculationsForUserDefinedTargetProbabilityContext( calculationsForTargetProbability, failureMechanism, assessmentSectionStub); // Call bool canDrop = info.CanDrop(draggedData, targetData); // Assert Assert.IsTrue(canDrop); } }
public void CreateCalculationActivitiesForCalculationGroup_WithValidCalculations_ReturnsWaveImpactAsphaltCoverWaveConditionsCalculationActivitiesWithParametersSet() { // Setup WaveImpactAsphaltCoverFailureMechanism failureMechanism = new WaveImpactAsphaltCoverFailureMechanism(); AssessmentSectionStub assessmentSection = CreateAssessmentSection(); var hydraulicBoundaryLocation = new TestHydraulicBoundaryLocation(); SetHydraulicBoundaryLocationToAssessmentSection(assessmentSection, hydraulicBoundaryLocation); WaveImpactAsphaltCoverWaveConditionsCalculation calculation1 = CreateValidCalculation(hydraulicBoundaryLocation); WaveImpactAsphaltCoverWaveConditionsCalculation calculation2 = CreateValidCalculation(hydraulicBoundaryLocation); var calculations = new CalculationGroup { Children = { calculation1, calculation2 } }; // Call IEnumerable <CalculatableActivity> activities = WaveImpactAsphaltCoverWaveConditionsCalculationActivityFactory.CreateCalculationActivities( calculations, failureMechanism, assessmentSection); // Assert CollectionAssert.AllItemsAreInstancesOfType(activities, typeof(WaveImpactAsphaltCoverWaveConditionsCalculationActivity)); Assert.AreEqual(2, activities.Count()); RoundedDouble assessmentLevel = assessmentSection.WaterLevelCalculationsForSignalFloodingProbability.Single().Output.Result; HydraulicBoundaryDatabase hydraulicBoundaryDatabase = assessmentSection.HydraulicBoundaryDatabase; AssertWaveImpactAsphaltCoverWaveConditionsCalculationActivity(activities.First(), calculation1, assessmentLevel, hydraulicBoundaryDatabase); AssertWaveImpactAsphaltCoverWaveConditionsCalculationActivity(activities.ElementAt(1), calculation2, assessmentLevel, hydraulicBoundaryDatabase); }
private static IEnumerable <TestCaseData> GetAssessmentSectionConfigurations() { var assessmentSectionWithTargetProbabilities = new AssessmentSectionStub(); assessmentSectionWithTargetProbabilities.SetHydraulicBoundaryLocationCalculations(new[] { new HydraulicBoundaryLocation(123, "aName", 1.1, 2.2) }); yield return(new TestCaseData(assessmentSectionWithTargetProbabilities, new[] { "Waterstanden bij vaste doelkans/Waterstanden_30000.shp", "Waterstanden bij vaste doelkans/Waterstanden_30000 (1).shp", "Waterstanden bij vrije doelkans/Waterstanden_10000.shp", "Waterstanden bij vrije doelkans/Waterstanden_100000.shp", "Golfhoogten bij vrije doelkans/Golfhoogten_4000.shp", "Golfhoogten bij vrije doelkans/Golfhoogten_40000.shp" }).SetName("With UserDefinedTargetProbabilities")); var assessmentSectionWithoutTargetProbabilities = new AssessmentSectionStub(); assessmentSectionWithoutTargetProbabilities.SetHydraulicBoundaryLocationCalculations(new[] { new HydraulicBoundaryLocation(123, "aName", 1.1, 2.2) }); assessmentSectionWithoutTargetProbabilities.WaterLevelCalculationsForUserDefinedTargetProbabilities.Clear(); assessmentSectionWithoutTargetProbabilities.WaveHeightCalculationsForUserDefinedTargetProbabilities.Clear(); yield return(new TestCaseData(assessmentSectionWithoutTargetProbabilities, new[] { "Waterstanden bij vaste doelkans/Waterstanden_30000.shp", "Waterstanden bij vaste doelkans/Waterstanden_30000 (1).shp" }).SetName("Without UserDefinedTargetProbabilities")); }
public void AssembleFailureMechanism_CalculatorThrowsException_ThrowsAssemblyException() { // Setup var failureMechanism = new ClosingStructuresFailureMechanism { 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() => ClosingStructuresFailureMechanismAssemblyFactory.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 GetViewName_WithContext_ReturnsExpectedViewName(double userDefinedTargetProbability1, double userDefinedTargetProbability2, double userDefinedTargetProbability3, string expectedProbabilityText) { // Setup var calculationsForTargetProbability = new HydraulicBoundaryLocationCalculationsForTargetProbability(userDefinedTargetProbability2); var assessmentSection = new AssessmentSectionStub { WaterLevelCalculationsForUserDefinedTargetProbabilities = { new HydraulicBoundaryLocationCalculationsForTargetProbability(userDefinedTargetProbability1), new HydraulicBoundaryLocationCalculationsForTargetProbability(userDefinedTargetProbability3), calculationsForTargetProbability } }; var context = new WaterLevelCalculationsForUserDefinedTargetProbabilityContext(calculationsForTargetProbability, assessmentSection); using (var plugin = new RiskeerPlugin()) { ViewInfo info = GetViewInfo(plugin); // Call string viewName = info.GetViewName(null, context); // Assert Assert.AreEqual($"Waterstanden bij vrije doelkans - {expectedProbabilityText}", viewName); } }
public void GetAssessmentLevel_ValidInputWithHydraulicBoundaryLocation_ReturnsExpectedValue( WaveConditionsInputWaterLevelType waterLevelType, Func <WaveConditionsInput, IAssessmentSection, double> getExpectedAssessmentLevel) { // Setup var assessmentSection = new AssessmentSectionStub(); var hydraulicBoundaryLocation = new TestHydraulicBoundaryLocation(); assessmentSection.SetHydraulicBoundaryLocationCalculations(new[] { hydraulicBoundaryLocation }, true); var input = new WaveConditionsInput { HydraulicBoundaryLocation = hydraulicBoundaryLocation, WaterLevelType = waterLevelType, CalculationsTargetProbability = assessmentSection.WaterLevelCalculationsForUserDefinedTargetProbabilities.First() }; // Call double assessmentLevel = WaveConditionsInputHelper.GetAssessmentLevel(input, assessmentSection); // Assert Assert.AreEqual(getExpectedAssessmentLevel(input, assessmentSection), assessmentLevel); }
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 AssembleSection_CalculatorThrowsException_ThrowsAssemblyException() { // Setup var failureMechanism = new GrassCoverErosionInwardsFailureMechanism(); failureMechanism.SetSections(new[] { FailureMechanismSectionTestFactory.CreateFailureMechanismSection() }, "APath"); AdoptableWithProfileProbabilityFailureMechanismSectionResult sectionResult = failureMechanism.SectionResults.Single(); var assessmentSection = new AssessmentSectionStub(); using (new AssemblyToolCalculatorFactoryConfig()) { var calculatorFactory = (TestAssemblyToolCalculatorFactory)AssemblyToolCalculatorFactory.Instance; FailureMechanismSectionAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator; calculator.ThrowExceptionOnCalculate = true; // Call void Call() => GrassCoverErosionInwardsFailureMechanismAssemblyFactory.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 AssembleSectionAdoptableWithProfileProbability_WithInputAndUseLengthEffectFalse_SetsInputOnCalculator( AdoptableInitialFailureMechanismResultType initialFailureMechanismResultType, bool expectedHasProbabilitySpecified) { // Setup var random = new Random(21); bool isRelevant = random.NextBoolean(); double manualInitialSectionProbability = random.NextDouble(); double calculateStrategySectionProbability = random.NextDouble(); var furtherAnalysisType = random.NextEnumValue <FailureMechanismSectionResultFurtherAnalysisType>(); double refinedSectionProbability = random.NextDouble(); var mocks = new MockRepository(); var calculateStrategy = mocks.StrictMock <IFailureMechanismSectionResultCalculateProbabilityStrategy>(); bool isInitialFailureMechanismResultTypeAdopt = IsInitialFailureMechanismResultTypeAdopt(initialFailureMechanismResultType); if (isInitialFailureMechanismResultTypeAdopt) { calculateStrategy.Expect(cs => cs.CalculateSectionProbability()) .Return(calculateStrategySectionProbability); } mocks.ReplayAll(); var assessmentSection = new AssessmentSectionStub(); var sectionResult = new AdoptableWithProfileProbabilityFailureMechanismSectionResult(FailureMechanismSectionTestFactory.CreateFailureMechanismSection()) { IsRelevant = isRelevant, InitialFailureMechanismResultType = initialFailureMechanismResultType, ManualInitialFailureMechanismResultSectionProbability = manualInitialSectionProbability, FurtherAnalysisType = furtherAnalysisType, RefinedSectionProbability = refinedSectionProbability }; using (new AssemblyToolCalculatorFactoryConfig()) { var calculatorFactory = (TestAssemblyToolCalculatorFactory)AssemblyToolCalculatorFactory.Instance; FailureMechanismSectionAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator; // Call FailureMechanismSectionAssemblyResultFactory.AssembleSection( sectionResult, assessmentSection, calculateStrategy, false, random.NextDouble()); // Assert FailureMechanismSectionAssemblyInput calculatorInput = calculator.FailureMechanismSectionAssemblyInput; FailureMechanismContribution failureMechanismContribution = assessmentSection.FailureMechanismContribution; Assert.AreEqual(failureMechanismContribution.SignalFloodingProbability, calculatorInput.SignalFloodingProbability); Assert.AreEqual(failureMechanismContribution.MaximumAllowableFloodingProbability, calculatorInput.MaximumAllowableFloodingProbability); Assert.AreEqual(isRelevant, calculatorInput.IsRelevant); Assert.AreEqual(expectedHasProbabilitySpecified, calculatorInput.HasProbabilitySpecified); double expectedInitialSectionProbability = isInitialFailureMechanismResultTypeAdopt ? calculateStrategySectionProbability : manualInitialSectionProbability; Assert.AreEqual(expectedInitialSectionProbability, calculatorInput.InitialSectionProbability); Assert.AreEqual(furtherAnalysisType, calculatorInput.FurtherAnalysisType); Assert.AreEqual(refinedSectionProbability, calculatorInput.RefinedSectionProbability); } }
public void ChildNodeObjects_Always_ReturnsChildrenOfData() { // Setup var assessmentSection = new AssessmentSectionStub(); var calculationsForTargetProbabilities = new ObservableList <HydraulicBoundaryLocationCalculationsForTargetProbability> { new HydraulicBoundaryLocationCalculationsForTargetProbability(0.1), new HydraulicBoundaryLocationCalculationsForTargetProbability(0.01) }; var calculationsGroupContext = new WaveHeightCalculationsForUserDefinedTargetProbabilitiesGroupContext(calculationsForTargetProbabilities, assessmentSection); using (var plugin = new RiskeerPlugin()) { TreeNodeInfo info = GetInfo(plugin); // Call object[] childNodeObjects = info.ChildNodeObjects(calculationsGroupContext); // Assert Assert.AreEqual(2, childNodeObjects.Length); WaveHeightCalculationsForUserDefinedTargetProbabilityContext[] calculationsContexts = childNodeObjects.OfType <WaveHeightCalculationsForUserDefinedTargetProbabilityContext>().ToArray(); Assert.AreEqual(2, calculationsContexts.Length); Assert.AreSame(calculationsForTargetProbabilities[0], calculationsContexts[0].WrappedData); Assert.AreSame(assessmentSection, calculationsContexts[0].AssessmentSection); Assert.AreSame(calculationsForTargetProbabilities[1], calculationsContexts[1].WrappedData); Assert.AreSame(assessmentSection, calculationsContexts[1].AssessmentSection); } }
public void CanDrop_DraggedDataPartOfGroupContext_ReturnsTrue() { // Setup using (var plugin = new RiskeerPlugin()) { TreeNodeInfo info = GetInfo(plugin); var assessmentSectionStub = new AssessmentSectionStub(); var calculationsForTargetProbability = new HydraulicBoundaryLocationCalculationsForTargetProbability(0.1); var targetData = new WaveHeightCalculationsForUserDefinedTargetProbabilitiesGroupContext( new ObservableList <HydraulicBoundaryLocationCalculationsForTargetProbability> { calculationsForTargetProbability }, assessmentSectionStub); var draggedData = new WaveHeightCalculationsForUserDefinedTargetProbabilityContext( calculationsForTargetProbability, assessmentSectionStub); // Call bool canDrop = info.CanDrop(draggedData, targetData); // Assert Assert.IsTrue(canDrop); } }
public void GetViewName_WithContext_ReturnsExpectedViewName( Func <IAssessmentSection, IObservableEnumerable <HydraulicBoundaryLocationCalculation> > getCalculationsFunc, double maximumAllowableFloodingProbability, double signalFloodingProbability, string expectedProbabilityText) { // Setup var assessmentSection = new AssessmentSectionStub { FailureMechanismContribution = { MaximumAllowableFloodingProbability = maximumAllowableFloodingProbability, SignalFloodingProbability = signalFloodingProbability } }; var context = new WaterLevelCalculationsForNormTargetProbabilityContext(getCalculationsFunc(assessmentSection), assessmentSection, () => 0.01); using (var plugin = new RiskeerPlugin()) { ViewInfo info = GetViewInfo(plugin); // Call string viewName = info.GetViewName(null, context); // Assert Assert.AreEqual($"Waterstanden bij vaste doelkans - {expectedProbabilityText}", viewName); } }
public void GivenContextWithObserverAttached_WhenNotifyingObserversOfDuneLocationCalculationsForUserDefinedTargetProbability_ThenObserverCorrectlyNotified() { // Given var mockRepository = new MockRepository(); var observer = mockRepository.StrictMock <IObserver>(); observer.Expect(o => o.UpdateObserver()); mockRepository.ReplayAll(); var assessmentSection = new AssessmentSectionStub(); var failureMechanism = new DuneErosionFailureMechanism(); var calculationsForTargetProbability = new DuneLocationCalculationsForTargetProbability(0.1); failureMechanism.DuneLocationCalculationsForUserDefinedTargetProbabilities.Add(calculationsForTargetProbability); var context = new DuneLocationCalculationsForUserDefinedTargetProbabilityContext(calculationsForTargetProbability, failureMechanism, assessmentSection); context.Attach(observer); // When failureMechanism.DuneLocationCalculationsForUserDefinedTargetProbabilities.First().NotifyObservers(); // Then mockRepository.VerifyAll(); }
private IAssessmentSection CreateAssessmentSectionWithHydraulicBoundaryOutput() { var hydraulicBoundaryLocation = new HydraulicBoundaryLocation(1300001, string.Empty, 0, 0); var assessmentSection = new AssessmentSectionStub { HydraulicBoundaryDatabase = { FilePath = validFilePath, Locations = { hydraulicBoundaryLocation } } }; HydraulicBoundaryDatabaseTestHelper.SetHydraulicBoundaryLocationConfigurationSettings(assessmentSection.HydraulicBoundaryDatabase); assessmentSection.SetHydraulicBoundaryLocationCalculations(new[] { hydraulicBoundaryLocation }); assessmentSection.WaterLevelCalculationsForMaximumAllowableFloodingProbability.First().Output = new TestHydraulicBoundaryLocationCalculationOutput(9.3); return(assessmentSection); }
public void FailureMechanismResultsView_AllDataSet_SetsCorrectInputOnCalculator() { // Setup FailureMechanismSection section = FailureMechanismSectionTestFactory.CreateFailureMechanismSection(); var failureMechanism = new GrassCoverErosionInwardsFailureMechanism(); 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; Assert.AreEqual(failureMechanism.GeneralInput.N, calculator.FailureMechanismN); } }
public void AssembleSectionAdoptableSectionWithProfileProbability_CalculatorRan_ReturnsExpectedOutput() { // Setup var random = new Random(21); var mocks = new MockRepository(); var calculateStrategy = mocks.Stub <IFailureMechanismSectionResultCalculateProbabilityStrategy>(); mocks.ReplayAll(); var assessmentSection = new AssessmentSectionStub(); var sectionResult = new AdoptableWithProfileProbabilityFailureMechanismSectionResult(FailureMechanismSectionTestFactory.CreateFailureMechanismSection()); using (new AssemblyToolCalculatorFactoryConfig()) { var calculatorFactory = (TestAssemblyToolCalculatorFactory)AssemblyToolCalculatorFactory.Instance; FailureMechanismSectionAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator; // Call FailureMechanismSectionAssemblyResultWrapper result = FailureMechanismSectionAssemblyResultFactory.AssembleSection( sectionResult, assessmentSection, calculateStrategy, random.NextBoolean(), random.NextDouble()); // Assert Assert.AreSame(calculator.FailureMechanismSectionAssemblyResultOutput, result); } }
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 AssembleSectionAdoptableSectionWithProfileProbability_CalculatorThrowsException_ThrowsAssemblyException() { // Setup var random = new Random(21); var mocks = new MockRepository(); var calculateStrategy = mocks.Stub <IFailureMechanismSectionResultCalculateProbabilityStrategy>(); mocks.ReplayAll(); var assessmentSection = new AssessmentSectionStub(); var sectionResult = new AdoptableWithProfileProbabilityFailureMechanismSectionResult(FailureMechanismSectionTestFactory.CreateFailureMechanismSection()); using (new AssemblyToolCalculatorFactoryConfig()) { var calculatorFactory = (TestAssemblyToolCalculatorFactory)AssemblyToolCalculatorFactory.Instance; FailureMechanismSectionAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator; calculator.ThrowExceptionOnCalculate = true; // Call void Call() => FailureMechanismSectionAssemblyResultFactory.AssembleSection( sectionResult, assessmentSection, calculateStrategy, random.NextBoolean(), random.NextDouble()); // Assert var exception = Assert.Throws <AssemblyException>(Call); Exception innerException = exception.InnerException; Assert.IsInstanceOf <FailureMechanismSectionAssemblyCalculatorException>(innerException); Assert.AreEqual(innerException.Message, exception.Message); } }
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 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); } }
public void AssembleFailureMechanism_CalculatorRan_ReturnsExpectedOutput() { // Setup var failureMechanism = new ClosingStructuresFailureMechanism { AssemblyResult = { ProbabilityResultType = FailureMechanismAssemblyProbabilityResultType.Automatic } }; var assessmentSection = new AssessmentSectionStub(); using (new AssemblyToolCalculatorFactoryConfig()) { var calculatorFactory = (TestAssemblyToolCalculatorFactory)AssemblyToolCalculatorFactory.Instance; FailureMechanismAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedFailureMechanismAssemblyCalculator; // Call FailureMechanismAssemblyResultWrapper result = ClosingStructuresFailureMechanismAssemblyFactory.AssembleFailureMechanism(failureMechanism, assessmentSection); // Assert Assert.AreSame(calculator.AssemblyResultOutput, result); } }
public void Constructor_AssemblyRan_InputCorrectlySetOnCalculator() { // Setup var mocks = new MockRepository(); var errorProvider = mocks.Stub <IFailureMechanismSectionResultRowErrorProvider>(); mocks.ReplayAll(); var assessmentSection = new AssessmentSectionStub(); FailureMechanismSection section = FailureMechanismSectionTestFactory.CreateFailureMechanismSection(); var result = new NonAdoptableFailureMechanismSectionResult(section); using (new AssemblyToolCalculatorFactoryConfig()) { var calculatorFactory = (TestAssemblyToolCalculatorFactory)AssemblyToolCalculatorFactory.Instance; FailureMechanismSectionAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator; // Call var row = new NonAdoptableFailureMechanismSectionResultRow(result, errorProvider, assessmentSection, ConstructionProperties); // Assert FailureMechanismSectionAssemblyInput input = calculator.FailureMechanismSectionAssemblyInput; Assert.AreEqual(assessmentSection.FailureMechanismContribution.SignalFloodingProbability, input.SignalFloodingProbability); Assert.AreEqual(assessmentSection.FailureMechanismContribution.MaximumAllowableFloodingProbability, input.MaximumAllowableFloodingProbability); Assert.AreEqual(row.IsRelevant, input.IsRelevant); Assert.IsTrue(input.HasProbabilitySpecified); Assert.AreEqual(row.InitialFailureMechanismResultSectionProbability, input.InitialSectionProbability); Assert.AreEqual(row.FurtherAnalysisType, input.FurtherAnalysisType); Assert.AreEqual(row.RefinedSectionProbability, input.RefinedSectionProbability); } mocks.VerifyAll(); }
public void AssembleFailureMechanism_WithInput_SetsInputOnCalculator() { // Setup var failureMechanism = new ClosingStructuresFailureMechanism { 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 ClosingStructuresFailureMechanismAssemblyFactory.AssembleFailureMechanism(failureMechanism, assessmentSection); // Assert double expectedN = failureMechanism.GeneralInput.N; Assert.AreEqual(expectedN, failureMechanismAssemblyCalculator.FailureMechanismN); Assert.AreSame(calculator.FailureMechanismSectionAssemblyResultOutput.AssemblyResult, failureMechanismAssemblyCalculator.SectionAssemblyResultsInput.Single()); } }
private static WaveHeightCalculationsView ShowFullyConfiguredWaveHeightCalculationsView(IObservableEnumerable <HydraulicBoundaryLocationCalculation> calculations, Form form) { var assessmentSection = new AssessmentSectionStub(); return(ShowWaveHeightCalculationsView(calculations, assessmentSection, 0.01, "1/100", form)); }
private static IEnumerable <TestCaseData> GetUnequalTestCases() { yield return(new TestCaseData(new SelectableTargetProbability(assessmentSection, assessmentSection.WaterLevelCalculationsForSignalFloodingProbability, WaveConditionsInputWaterLevelType.SignalFloodingProbability, 0.01))); yield return(new TestCaseData(new SelectableTargetProbability(assessmentSection, assessmentSection.WaterLevelCalculationsForSignalFloodingProbability, WaveConditionsInputWaterLevelType.MaximumAllowableFloodingProbability, 0.1))); yield return(new TestCaseData(new SelectableTargetProbability(assessmentSection, assessmentSection.WaterLevelCalculationsForMaximumAllowableFloodingProbability, WaveConditionsInputWaterLevelType.SignalFloodingProbability, 0.1))); var otherAssessmentSection = new AssessmentSectionStub(); yield return(new TestCaseData(new SelectableTargetProbability(otherAssessmentSection, assessmentSection.WaterLevelCalculationsForSignalFloodingProbability, WaveConditionsInputWaterLevelType.SignalFloodingProbability, 0.1)) .SetName("differentAssessmentSection")); }
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 void CreateCalculationActivitiesForFailureMechanism_WithValidData_ExpectedInputSetToActivities() { // Setup AssessmentSectionStub assessmentSection = CreateAssessmentSection(); WaveImpactAsphaltCoverFailureMechanism failureMechanism = new WaveImpactAsphaltCoverFailureMechanism(); var hydraulicBoundaryLocation = new TestHydraulicBoundaryLocation("locationName 1"); SetHydraulicBoundaryLocationToAssessmentSection(assessmentSection, hydraulicBoundaryLocation); WaveImpactAsphaltCoverWaveConditionsCalculation calculation1 = CreateValidCalculation(hydraulicBoundaryLocation); WaveImpactAsphaltCoverWaveConditionsCalculation calculation2 = CreateValidCalculation(hydraulicBoundaryLocation); failureMechanism.CalculationsGroup.Children.AddRange(new[] { calculation1, calculation2 }); // Call IEnumerable <CalculatableActivity> activities = WaveImpactAsphaltCoverWaveConditionsCalculationActivityFactory.CreateCalculationActivities( failureMechanism, assessmentSection); // Assert CollectionAssert.AllItemsAreInstancesOfType(activities, typeof(WaveImpactAsphaltCoverWaveConditionsCalculationActivity)); Assert.AreEqual(2, activities.Count()); RoundedDouble assessmentLevel = assessmentSection.WaterLevelCalculationsForSignalFloodingProbability.Single().Output.Result; HydraulicBoundaryDatabase hydraulicBoundaryDatabase = assessmentSection.HydraulicBoundaryDatabase; AssertWaveImpactAsphaltCoverWaveConditionsCalculationActivity(activities.ElementAt(0), calculation1, assessmentLevel, hydraulicBoundaryDatabase); AssertWaveImpactAsphaltCoverWaveConditionsCalculationActivity(activities.ElementAt(1), calculation2, assessmentLevel, hydraulicBoundaryDatabase); }
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 Export_WithVariousAssessmentSectionConfigurations_ReturnsTrueAndWritesCorrectData( AssessmentSectionStub assessmentSection, IEnumerable <string> expectedFiles) { // Setup string directoryPath = TestHelper.GetScratchPadPath(nameof(Export_WithVariousAssessmentSectionConfigurations_ReturnsTrueAndWritesCorrectData)); Directory.CreateDirectory(directoryPath); string filePath = Path.Combine(directoryPath, "test.zip"); var exporter = new HydraulicBoundaryLocationCalculationsExporter(assessmentSection, filePath); try { // Call bool isExported = exporter.Export(); // Assert Assert.IsTrue(isExported); using (ZipArchive zipArchive = ZipFile.OpenRead(filePath)) { CollectionAssert.IsSubsetOf(expectedFiles, zipArchive.Entries.Select(e => e.FullName)); } } finally { DirectoryHelper.TryDelete(directoryPath); } }
public void GivenViewWithSpecificFailureMechanismData_WhenFailureMechanismNameUpdatedAndNotified_ThenMapDataUpdatedAndObserversNotified() { // Given var mocks = new MockRepository(); var observer = mocks.StrictMock <IObserver>(); observer.Expect(obs => obs.UpdateObserver()); mocks.ReplayAll(); var assessmentSection = new AssessmentSectionStub(); var failureMechanism = new SpecificFailureMechanism(); SpecificFailureMechanismView view = CreateView(failureMechanism, assessmentSection); MapDataCollection mapData = view.Map.Data; mapData.Attach(observer); // Precondition Assert.AreEqual(failureMechanism.Name, mapData.Name); // When const string newFailureMechanismName = "New Failure Mechanism Name"; failureMechanism.Name = newFailureMechanismName; failureMechanism.NotifyObservers(); // Then Assert.AreEqual(newFailureMechanismName, mapData.Name); mocks.VerifyAll(); }