Index: Ringtoets/GrassCoverErosionInwards/src/Ringtoets.GrassCoverErosionInwards.Service/GrassCoverErosionInwardsCalculationService.cs =================================================================== diff -u -raca65a56029a6646ce2e997d7c14e547356b5b65 -rdb71b309ed4ce429385a3ce6e8fb0a357f4e9135 --- Ringtoets/GrassCoverErosionInwards/src/Ringtoets.GrassCoverErosionInwards.Service/GrassCoverErosionInwardsCalculationService.cs (.../GrassCoverErosionInwardsCalculationService.cs) (revision aca65a56029a6646ce2e997d7c14e547356b5b65) +++ Ringtoets/GrassCoverErosionInwards/src/Ringtoets.GrassCoverErosionInwards.Service/GrassCoverErosionInwardsCalculationService.cs (.../GrassCoverErosionInwardsCalculationService.cs) (revision db71b309ed4ce429385a3ce6e8fb0a357f4e9135) @@ -250,7 +250,7 @@ var numberOfCalculators = 1; var settings = new HydraRingCalculationSettings(hlcdDirectory, preprocessorDirectory); - overtoppingCalculator = HydraRingCalculatorFactory.Instance.CreateOvertoppingCalculator(hlcdDirectory, preprocessorDirectory); + overtoppingCalculator = HydraRingCalculatorFactory.Instance.CreateOvertoppingCalculator(settings); bool dikeHeightNormValid = TargetProbabilityCalculationServiceHelper.ValidateTargetProbability( GetNormForDikeHeight(calculation.InputParameters, Index: Ringtoets/GrassCoverErosionInwards/test/Ringtoets.GrassCoverErosionInwards.Integration.Test/GrassCoverErosionInwardsCalculationActivityIntegrationTest.cs =================================================================== diff -u -raca65a56029a6646ce2e997d7c14e547356b5b65 -rdb71b309ed4ce429385a3ce6e8fb0a357f4e9135 --- Ringtoets/GrassCoverErosionInwards/test/Ringtoets.GrassCoverErosionInwards.Integration.Test/GrassCoverErosionInwardsCalculationActivityIntegrationTest.cs (.../GrassCoverErosionInwardsCalculationActivityIntegrationTest.cs) (revision aca65a56029a6646ce2e997d7c14e547356b5b65) +++ Ringtoets/GrassCoverErosionInwards/test/Ringtoets.GrassCoverErosionInwards.Integration.Test/GrassCoverErosionInwardsCalculationActivityIntegrationTest.cs (.../GrassCoverErosionInwardsCalculationActivityIntegrationTest.cs) (revision db71b309ed4ce429385a3ce6e8fb0a357f4e9135) @@ -116,7 +116,13 @@ { var mockRepository = new MockRepository(); var calculatorFactory = mockRepository.StrictMock(); - calculatorFactory.Stub(cf => cf.CreateOvertoppingCalculator(testDataPath, string.Empty)).Return(new TestOvertoppingCalculator()); + calculatorFactory.Stub(cf => cf.CreateOvertoppingCalculator(Arg.Is.NotNull)) + .WhenCalled(invocation => + { + var settings = (HydraRingCalculationSettings)invocation.Arguments[0]; + Assert.AreEqual(testDataPath, settings.HlcdFilePath); + Assert.IsEmpty(settings.PreprocessorDirectory); + }).Return(new TestOvertoppingCalculator()); calculatorFactory.Stub(cf => cf.CreateOvertoppingRateCalculator(Arg.Is.NotNull)) .WhenCalled(invocation => { @@ -245,7 +251,14 @@ var calculator = new TestOvertoppingCalculator(); var mockRepository = new MockRepository(); var calculatorFactory = mockRepository.StrictMock(); - calculatorFactory.Expect(cf => cf.CreateOvertoppingCalculator(testDataPath, string.Empty)).Return(calculator); + calculatorFactory.Expect(cf => cf.CreateOvertoppingCalculator(Arg.Is.NotNull)) + .WhenCalled(invocation => + { + var settings = (HydraRingCalculationSettings)invocation.Arguments[0]; + Assert.AreEqual(testDataPath, settings.HlcdFilePath); + Assert.IsEmpty(settings.PreprocessorDirectory); + }) + .Return(calculator); mockRepository.ReplayAll(); CalculatableActivity activity = GrassCoverErosionInwardsCalculationActivityFactory.CreateCalculationActivity(calculation, @@ -326,7 +339,14 @@ }; var mockRepository = new MockRepository(); var calculatorFactory = mockRepository.StrictMock(); - calculatorFactory.Expect(cf => cf.CreateOvertoppingCalculator(testDataPath, string.Empty)).Return(calculator); + calculatorFactory.Expect(cf => cf.CreateOvertoppingCalculator(Arg.Is.NotNull)) + .WhenCalled(invocation => + { + var settings = (HydraRingCalculationSettings)invocation.Arguments[0]; + Assert.AreEqual(testDataPath, settings.HlcdFilePath); + Assert.IsEmpty(settings.PreprocessorDirectory); + }) + .Return(calculator); mockRepository.ReplayAll(); using (new HydraRingCalculatorFactoryConfig(calculatorFactory)) @@ -375,7 +395,14 @@ var mockRepository = new MockRepository(); var calculatorFactory = mockRepository.StrictMock(); - calculatorFactory.Expect(cf => cf.CreateOvertoppingCalculator(testDataPath, string.Empty)).Return(overtoppingCalculator); + calculatorFactory.Expect(cf => cf.CreateOvertoppingCalculator(Arg.Is.NotNull)) + .WhenCalled(invocation => + { + var settings = (HydraRingCalculationSettings)invocation.Arguments[0]; + Assert.AreEqual(testDataPath, settings.HlcdFilePath); + Assert.IsEmpty(settings.PreprocessorDirectory); + }) + .Return(overtoppingCalculator); mockRepository.ReplayAll(); CalculatableActivity activity = GrassCoverErosionInwardsCalculationActivityFactory.CreateCalculationActivity(calculation, @@ -423,7 +450,14 @@ LastErrorFileContent = lastErrorFileContent }; var calculatorFactory = mockRepository.StrictMock(); - calculatorFactory.Expect(cf => cf.CreateOvertoppingCalculator(testDataPath, string.Empty)).Return(calculator); + calculatorFactory.Expect(cf => cf.CreateOvertoppingCalculator(Arg.Is.NotNull)) + .WhenCalled(invocation => + { + var settings = (HydraRingCalculationSettings)invocation.Arguments[0]; + Assert.AreEqual(testDataPath, settings.HlcdFilePath); + Assert.IsEmpty(settings.PreprocessorDirectory); + }) + .Return(calculator); mockRepository.ReplayAll(); var assessmentSection = new AssessmentSection(AssessmentSectionComposition.Dike); @@ -465,7 +499,14 @@ observer.Expect(o => o.UpdateObserver()); var calculatorFactory = mockRepository.StrictMock(); - calculatorFactory.Expect(cf => cf.CreateOvertoppingCalculator(testDataPath, string.Empty)).Return(new TestOvertoppingCalculator()); + calculatorFactory.Expect(cf => cf.CreateOvertoppingCalculator(Arg.Is.NotNull)) + .WhenCalled(invocation => + { + var settings = (HydraRingCalculationSettings)invocation.Arguments[0]; + Assert.AreEqual(testDataPath, settings.HlcdFilePath); + Assert.IsEmpty(settings.PreprocessorDirectory); + }) + .Return(new TestOvertoppingCalculator()); mockRepository.ReplayAll(); var assessmentSection = new AssessmentSection(AssessmentSectionComposition.Dike); @@ -520,7 +561,14 @@ var mockRepository = new MockRepository(); var calculatorFactory = mockRepository.StrictMock(); - calculatorFactory.Expect(cf => cf.CreateOvertoppingCalculator(testDataPath, string.Empty)).Return(new TestOvertoppingCalculator()); + calculatorFactory.Expect(cf => cf.CreateOvertoppingCalculator(Arg.Is.NotNull)) + .WhenCalled(invocation => + { + var settings = (HydraRingCalculationSettings)invocation.Arguments[0]; + Assert.AreEqual(testDataPath, settings.HlcdFilePath); + Assert.IsEmpty(settings.PreprocessorDirectory); + }) + .Return(new TestOvertoppingCalculator()); calculatorFactory.Expect(cf => cf.CreateDikeHeightCalculator(Arg.Is.NotNull)) .WhenCalled(invocation => { @@ -619,7 +667,14 @@ var mockRepository = new MockRepository(); var calculatorFactory = mockRepository.StrictMock(); var overtoppingCalculator = new TestOvertoppingCalculator(); - calculatorFactory.Expect(cf => cf.CreateOvertoppingCalculator(testDataPath, string.Empty)).Return(overtoppingCalculator); + calculatorFactory.Expect(cf => cf.CreateOvertoppingCalculator(Arg.Is.NotNull)) + .WhenCalled(invocation => + { + var settings = (HydraRingCalculationSettings)invocation.Arguments[0]; + Assert.AreEqual(testDataPath, settings.HlcdFilePath); + Assert.IsEmpty(settings.PreprocessorDirectory); + }) + .Return(overtoppingCalculator); calculatorFactory.Expect(cf => cf.CreateDikeHeightCalculator(Arg.Is.NotNull)) .WhenCalled(invocation => { @@ -685,7 +740,14 @@ var mockRepository = new MockRepository(); var calculatorFactory = mockRepository.StrictMock(); - calculatorFactory.Expect(cf => cf.CreateOvertoppingCalculator(testDataPath, string.Empty)).Return(overtoppingCalculator); + calculatorFactory.Expect(cf => cf.CreateOvertoppingCalculator(Arg.Is.NotNull)) + .WhenCalled(invocation => + { + var settings = (HydraRingCalculationSettings)invocation.Arguments[0]; + Assert.AreEqual(testDataPath, settings.HlcdFilePath); + Assert.IsEmpty(settings.PreprocessorDirectory); + }) + .Return(overtoppingCalculator); calculatorFactory.Expect(cf => cf.CreateDikeHeightCalculator(Arg.Is.NotNull)) .WhenCalled(invocation => { @@ -752,7 +814,14 @@ var mockRepository = new MockRepository(); var calculatorFactory = mockRepository.StrictMock(); - calculatorFactory.Expect(cf => cf.CreateOvertoppingCalculator(testDataPath, string.Empty)).Return(overtoppingCalculator); + calculatorFactory.Expect(cf => cf.CreateOvertoppingCalculator(Arg.Is.NotNull)) + .WhenCalled(invocation => + { + var settings = (HydraRingCalculationSettings)invocation.Arguments[0]; + Assert.AreEqual(testDataPath, settings.HlcdFilePath); + Assert.IsEmpty(settings.PreprocessorDirectory); + }) + .Return(overtoppingCalculator); calculatorFactory.Expect(cf => cf.CreateDikeHeightCalculator(Arg.Is.NotNull)) .WhenCalled(invocation => { @@ -819,7 +888,14 @@ var mockRepository = new MockRepository(); var calculatorFactory = mockRepository.StrictMock(); - calculatorFactory.Expect(cf => cf.CreateOvertoppingCalculator(testDataPath, string.Empty)).Return(overtoppingCalculator); + calculatorFactory.Expect(cf => cf.CreateOvertoppingCalculator(Arg.Is.NotNull)) + .WhenCalled(invocation => + { + var settings = (HydraRingCalculationSettings)invocation.Arguments[0]; + Assert.AreEqual(testDataPath, settings.HlcdFilePath); + Assert.IsEmpty(settings.PreprocessorDirectory); + }) + .Return(overtoppingCalculator); calculatorFactory.Expect(cf => cf.CreateDikeHeightCalculator(Arg.Is.NotNull)) .WhenCalled(invocation => { @@ -887,7 +963,14 @@ EndInFailure = true }; var calculatorFactory = mockRepository.StrictMock(); - calculatorFactory.Expect(cf => cf.CreateOvertoppingCalculator(testDataPath, string.Empty)).Return(new TestOvertoppingCalculator()); + calculatorFactory.Expect(cf => cf.CreateOvertoppingCalculator(Arg.Is.NotNull)) + .WhenCalled(invocation => + { + var settings = (HydraRingCalculationSettings)invocation.Arguments[0]; + Assert.AreEqual(testDataPath, settings.HlcdFilePath); + Assert.IsEmpty(settings.PreprocessorDirectory); + }) + .Return(new TestOvertoppingCalculator()); calculatorFactory.Expect(cf => cf.CreateDikeHeightCalculator(Arg.Is.NotNull)) .WhenCalled(invocation => { @@ -941,7 +1024,14 @@ observer.Expect(o => o.UpdateObserver()); var calculatorFactory = mockRepository.StrictMock(); - calculatorFactory.Expect(cf => cf.CreateOvertoppingCalculator(testDataPath, string.Empty)).Return(new TestOvertoppingCalculator()); + calculatorFactory.Expect(cf => cf.CreateOvertoppingCalculator(Arg.Is.NotNull)) + .WhenCalled(invocation => + { + var settings = (HydraRingCalculationSettings)invocation.Arguments[0]; + Assert.AreEqual(testDataPath, settings.HlcdFilePath); + Assert.IsEmpty(settings.PreprocessorDirectory); + }) + .Return(new TestOvertoppingCalculator()); calculatorFactory.Expect(cf => cf.CreateDikeHeightCalculator(Arg.Is.NotNull)) .WhenCalled(invocation => { @@ -1006,7 +1096,14 @@ var mockRepository = new MockRepository(); var calculatorFactory = mockRepository.StrictMock(); - calculatorFactory.Expect(cf => cf.CreateOvertoppingCalculator(testDataPath, string.Empty)).Return(new TestOvertoppingCalculator()); + calculatorFactory.Expect(cf => cf.CreateOvertoppingCalculator(Arg.Is.NotNull)) + .WhenCalled(invocation => + { + var settings = (HydraRingCalculationSettings)invocation.Arguments[0]; + Assert.AreEqual(testDataPath, settings.HlcdFilePath); + Assert.IsEmpty(settings.PreprocessorDirectory); + }) + .Return(new TestOvertoppingCalculator()); calculatorFactory.Expect(cf => cf.CreateOvertoppingRateCalculator(Arg.Is.NotNull)) .WhenCalled(invocation => { @@ -1104,7 +1201,14 @@ var mockRepository = new MockRepository(); var calculatorFactory = mockRepository.StrictMock(); - calculatorFactory.Expect(cf => cf.CreateOvertoppingCalculator(testDataPath, string.Empty)).Return(overtoppingCalculator); + calculatorFactory.Expect(cf => cf.CreateOvertoppingCalculator(Arg.Is.NotNull)) + .WhenCalled(invocation => + { + var settings = (HydraRingCalculationSettings)invocation.Arguments[0]; + Assert.AreEqual(testDataPath, settings.HlcdFilePath); + Assert.IsEmpty(settings.PreprocessorDirectory); + }) + .Return(overtoppingCalculator); calculatorFactory.Expect(cf => cf.CreateOvertoppingRateCalculator(Arg.Is.NotNull)) .WhenCalled(invocation => { @@ -1170,7 +1274,14 @@ var mockRepository = new MockRepository(); var calculatorFactory = mockRepository.StrictMock(); - calculatorFactory.Expect(cf => cf.CreateOvertoppingCalculator(testDataPath, string.Empty)).Return(overtoppingCalculator); + calculatorFactory.Expect(cf => cf.CreateOvertoppingCalculator(Arg.Is.NotNull)) + .WhenCalled(invocation => + { + var settings = (HydraRingCalculationSettings)invocation.Arguments[0]; + Assert.AreEqual(testDataPath, settings.HlcdFilePath); + Assert.IsEmpty(settings.PreprocessorDirectory); + }) + .Return(overtoppingCalculator); calculatorFactory.Expect(cf => cf.CreateOvertoppingRateCalculator(Arg.Is.NotNull)) .WhenCalled(invocation => { @@ -1237,7 +1348,14 @@ var mockRepository = new MockRepository(); var calculatorFactory = mockRepository.StrictMock(); - calculatorFactory.Expect(cf => cf.CreateOvertoppingCalculator(testDataPath, string.Empty)).Return(overtoppingCalculator); + calculatorFactory.Expect(cf => cf.CreateOvertoppingCalculator(Arg.Is.NotNull)) + .WhenCalled(invocation => + { + var settings = (HydraRingCalculationSettings)invocation.Arguments[0]; + Assert.AreEqual(testDataPath, settings.HlcdFilePath); + Assert.IsEmpty(settings.PreprocessorDirectory); + }) + .Return(overtoppingCalculator); calculatorFactory.Expect(cf => cf.CreateOvertoppingRateCalculator(Arg.Is.NotNull)) .WhenCalled(invocation => { @@ -1304,7 +1422,14 @@ var mockRepository = new MockRepository(); var calculatorFactory = mockRepository.StrictMock(); - calculatorFactory.Expect(cf => cf.CreateOvertoppingCalculator(testDataPath, string.Empty)).Return(overtoppingCalculator); + calculatorFactory.Expect(cf => cf.CreateOvertoppingCalculator(Arg.Is.NotNull)) + .WhenCalled(invocation => + { + var settings = (HydraRingCalculationSettings)invocation.Arguments[0]; + Assert.AreEqual(testDataPath, settings.HlcdFilePath); + Assert.IsEmpty(settings.PreprocessorDirectory); + }) + .Return(overtoppingCalculator); calculatorFactory.Expect(cf => cf.CreateOvertoppingRateCalculator(Arg.Is.NotNull)) .WhenCalled(invocation => { @@ -1372,7 +1497,14 @@ EndInFailure = true }; var calculatorFactory = mockRepository.StrictMock(); - calculatorFactory.Expect(cf => cf.CreateOvertoppingCalculator(testDataPath, string.Empty)).Return(new TestOvertoppingCalculator()); + calculatorFactory.Expect(cf => cf.CreateOvertoppingCalculator(Arg.Is.NotNull)) + .WhenCalled(invocation => + { + var settings = (HydraRingCalculationSettings)invocation.Arguments[0]; + Assert.AreEqual(testDataPath, settings.HlcdFilePath); + Assert.IsEmpty(settings.PreprocessorDirectory); + }) + .Return(new TestOvertoppingCalculator()); calculatorFactory.Expect(cf => cf.CreateOvertoppingRateCalculator(Arg.Is.NotNull)) .WhenCalled(invocation => { @@ -1426,7 +1558,14 @@ observer.Expect(o => o.UpdateObserver()); var calculatorFactory = mockRepository.StrictMock(); - calculatorFactory.Expect(cf => cf.CreateOvertoppingCalculator(testDataPath, string.Empty)).Return(new TestOvertoppingCalculator()); + calculatorFactory.Expect(cf => cf.CreateOvertoppingCalculator(Arg.Is.NotNull)) + .WhenCalled(invocation => + { + var settings = (HydraRingCalculationSettings)invocation.Arguments[0]; + Assert.AreEqual(testDataPath, settings.HlcdFilePath); + Assert.IsEmpty(settings.PreprocessorDirectory); + }) + .Return(new TestOvertoppingCalculator()); calculatorFactory.Expect(cf => cf.CreateOvertoppingRateCalculator(Arg.Is.NotNull)) .WhenCalled(invocation => { Index: Ringtoets/GrassCoverErosionInwards/test/Ringtoets.GrassCoverErosionInwards.Plugin.Test/TreeNodeInfos/GrassCoverErosionInwardsCalculationContextTreeNodeInfoTest.cs =================================================================== diff -u -r798e2aebb171726447c40c41ab3a2f7ff9ea4cf0 -rdb71b309ed4ce429385a3ce6e8fb0a357f4e9135 --- Ringtoets/GrassCoverErosionInwards/test/Ringtoets.GrassCoverErosionInwards.Plugin.Test/TreeNodeInfos/GrassCoverErosionInwardsCalculationContextTreeNodeInfoTest.cs (.../GrassCoverErosionInwardsCalculationContextTreeNodeInfoTest.cs) (revision 798e2aebb171726447c40c41ab3a2f7ff9ea4cf0) +++ Ringtoets/GrassCoverErosionInwards/test/Ringtoets.GrassCoverErosionInwards.Plugin.Test/TreeNodeInfos/GrassCoverErosionInwardsCalculationContextTreeNodeInfoTest.cs (.../GrassCoverErosionInwardsCalculationContextTreeNodeInfoTest.cs) (revision db71b309ed4ce429385a3ce6e8fb0a357f4e9135) @@ -47,6 +47,7 @@ using Ringtoets.GrassCoverErosionInwards.Data.TestUtil; using Ringtoets.GrassCoverErosionInwards.Forms.PresentationObjects; using Ringtoets.HydraRing.Calculation.Calculator.Factory; +using Ringtoets.HydraRing.Calculation.Data.Input; using Ringtoets.HydraRing.Calculation.TestUtil.Calculator; using RingtoetsCommonFormsResources = Ringtoets.Common.Forms.Properties.Resources; @@ -794,7 +795,14 @@ gui.Stub(g => g.MainWindow).Return(mainWindow); var calculatorFactory = mocks.Stub(); - calculatorFactory.Expect(cf => cf.CreateOvertoppingCalculator(testDataPath, string.Empty)).Return(new TestOvertoppingCalculator()); + calculatorFactory.Expect(cf => cf.CreateOvertoppingCalculator(Arg.Is.NotNull)) + .WhenCalled(invocation => + { + var settings = (HydraRingCalculationSettings) invocation.Arguments[0]; + Assert.AreEqual(testDataPath, settings.HlcdFilePath); + Assert.IsEmpty(settings.PreprocessorDirectory); + }) + .Return(new TestOvertoppingCalculator()); mocks.ReplayAll(); plugin.Gui = gui; Index: Ringtoets/GrassCoverErosionInwards/test/Ringtoets.GrassCoverErosionInwards.Plugin.Test/TreeNodeInfos/GrassCoverErosionInwardsCalculationGroupContextTreeNodeInfoTest.cs =================================================================== diff -u -r798e2aebb171726447c40c41ab3a2f7ff9ea4cf0 -rdb71b309ed4ce429385a3ce6e8fb0a357f4e9135 --- Ringtoets/GrassCoverErosionInwards/test/Ringtoets.GrassCoverErosionInwards.Plugin.Test/TreeNodeInfos/GrassCoverErosionInwardsCalculationGroupContextTreeNodeInfoTest.cs (.../GrassCoverErosionInwardsCalculationGroupContextTreeNodeInfoTest.cs) (revision 798e2aebb171726447c40c41ab3a2f7ff9ea4cf0) +++ Ringtoets/GrassCoverErosionInwards/test/Ringtoets.GrassCoverErosionInwards.Plugin.Test/TreeNodeInfos/GrassCoverErosionInwardsCalculationGroupContextTreeNodeInfoTest.cs (.../GrassCoverErosionInwardsCalculationGroupContextTreeNodeInfoTest.cs) (revision db71b309ed4ce429385a3ce6e8fb0a357f4e9135) @@ -50,6 +50,7 @@ using Ringtoets.GrassCoverErosionInwards.Forms; using Ringtoets.GrassCoverErosionInwards.Forms.PresentationObjects; using Ringtoets.HydraRing.Calculation.Calculator.Factory; +using Ringtoets.HydraRing.Calculation.Data.Input; using Ringtoets.HydraRing.Calculation.TestUtil.Calculator; using RingtoetsCommonFormsResources = Ringtoets.Common.Forms.Properties.Resources; using GrassCoverErosionInwardsPluginResources = Ringtoets.GrassCoverErosionInwards.Plugin.Properties.Resources; @@ -1352,7 +1353,13 @@ int nrOfCalculators = failureMechanism.Calculations.Count(); var calculatorFactory = mocks.Stub(); - calculatorFactory.Expect(cf => cf.CreateOvertoppingCalculator(testDataPath, string.Empty)) + calculatorFactory.Expect(cf => cf.CreateOvertoppingCalculator(Arg.Is.NotNull)) + .WhenCalled(invocation => + { + var settings = (HydraRingCalculationSettings) invocation.Arguments[0]; + Assert.AreEqual(testDataPath, settings.HlcdFilePath); + Assert.IsEmpty(settings.PreprocessorDirectory); + }) .Return(new TestOvertoppingCalculator()) .Repeat .Times(nrOfCalculators); Index: Ringtoets/GrassCoverErosionInwards/test/Ringtoets.GrassCoverErosionInwards.Plugin.Test/TreeNodeInfos/GrassCoverErosionInwardsFailureMechanismContextTreeNodeInfoTest.cs =================================================================== diff -u -r798e2aebb171726447c40c41ab3a2f7ff9ea4cf0 -rdb71b309ed4ce429385a3ce6e8fb0a357f4e9135 --- Ringtoets/GrassCoverErosionInwards/test/Ringtoets.GrassCoverErosionInwards.Plugin.Test/TreeNodeInfos/GrassCoverErosionInwardsFailureMechanismContextTreeNodeInfoTest.cs (.../GrassCoverErosionInwardsFailureMechanismContextTreeNodeInfoTest.cs) (revision 798e2aebb171726447c40c41ab3a2f7ff9ea4cf0) +++ Ringtoets/GrassCoverErosionInwards/test/Ringtoets.GrassCoverErosionInwards.Plugin.Test/TreeNodeInfos/GrassCoverErosionInwardsFailureMechanismContextTreeNodeInfoTest.cs (.../GrassCoverErosionInwardsFailureMechanismContextTreeNodeInfoTest.cs) (revision db71b309ed4ce429385a3ce6e8fb0a357f4e9135) @@ -46,6 +46,7 @@ using Ringtoets.GrassCoverErosionInwards.Data.TestUtil; using Ringtoets.GrassCoverErosionInwards.Forms.PresentationObjects; using Ringtoets.HydraRing.Calculation.Calculator.Factory; +using Ringtoets.HydraRing.Calculation.Data.Input; using Ringtoets.HydraRing.Calculation.TestUtil.Calculator; using RingtoetsCommonFormsResources = Ringtoets.Common.Forms.Properties.Resources; @@ -677,7 +678,13 @@ int nrOfCalculators = failureMechanism.Calculations.Count(); var calculatorFactory = mocksRepository.Stub(); - calculatorFactory.Expect(cf => cf.CreateOvertoppingCalculator(testDataPath, string.Empty)) + calculatorFactory.Expect(cf => cf.CreateOvertoppingCalculator(Arg.Is.NotNull)) + .WhenCalled(invocation => + { + var settings = (HydraRingCalculationSettings) invocation.Arguments[0]; + Assert.AreEqual(testDataPath, settings.HlcdFilePath); + Assert.IsEmpty(settings.PreprocessorDirectory); + }) .Return(new TestOvertoppingCalculator()) .Repeat .Times(nrOfCalculators); Index: Ringtoets/GrassCoverErosionInwards/test/Ringtoets.GrassCoverErosionInwards.Service.Test/GrassCoverErosionInwardsCalculationActivityFactoryTest.cs =================================================================== diff -u -r2a81f01756e227d5ce93717b21b87e8a5cd5fcbb -rdb71b309ed4ce429385a3ce6e8fb0a357f4e9135 --- Ringtoets/GrassCoverErosionInwards/test/Ringtoets.GrassCoverErosionInwards.Service.Test/GrassCoverErosionInwardsCalculationActivityFactoryTest.cs (.../GrassCoverErosionInwardsCalculationActivityFactoryTest.cs) (revision 2a81f01756e227d5ce93717b21b87e8a5cd5fcbb) +++ Ringtoets/GrassCoverErosionInwards/test/Ringtoets.GrassCoverErosionInwards.Service.Test/GrassCoverErosionInwardsCalculationActivityFactoryTest.cs (.../GrassCoverErosionInwardsCalculationActivityFactoryTest.cs) (revision db71b309ed4ce429385a3ce6e8fb0a357f4e9135) @@ -36,6 +36,7 @@ using Ringtoets.Common.Service; using Ringtoets.GrassCoverErosionInwards.Data; using Ringtoets.HydraRing.Calculation.Calculator.Factory; +using Ringtoets.HydraRing.Calculation.Data.Input; using Ringtoets.HydraRing.Calculation.TestUtil.Calculator; namespace Ringtoets.GrassCoverErosionInwards.Service.Test @@ -302,7 +303,13 @@ var mocks = new MockRepository(); var testCalculator = new TestOvertoppingCalculator(); var calculatorFactory = mocks.StrictMock(); - calculatorFactory.Expect(cf => cf.CreateOvertoppingCalculator(testDataPath, "")) + calculatorFactory.Expect(cf => cf.CreateOvertoppingCalculator(Arg.Is.NotNull)) + .WhenCalled(invocation => + { + var settings = (HydraRingCalculationSettings) invocation.Arguments[0]; + Assert.AreEqual(testDataPath, settings.HlcdFilePath); + Assert.IsEmpty(settings.PreprocessorDirectory); + }) .Return(testCalculator); mocks.ReplayAll(); Index: Ringtoets/GrassCoverErosionInwards/test/Ringtoets.GrassCoverErosionInwards.Service.Test/GrassCoverErosionInwardsCalculationServiceTest.cs =================================================================== diff -u -raca65a56029a6646ce2e997d7c14e547356b5b65 -rdb71b309ed4ce429385a3ce6e8fb0a357f4e9135 --- Ringtoets/GrassCoverErosionInwards/test/Ringtoets.GrassCoverErosionInwards.Service.Test/GrassCoverErosionInwardsCalculationServiceTest.cs (.../GrassCoverErosionInwardsCalculationServiceTest.cs) (revision aca65a56029a6646ce2e997d7c14e547356b5b65) +++ Ringtoets/GrassCoverErosionInwards/test/Ringtoets.GrassCoverErosionInwards.Service.Test/GrassCoverErosionInwardsCalculationServiceTest.cs (.../GrassCoverErosionInwardsCalculationServiceTest.cs) (revision db71b309ed4ce429385a3ce6e8fb0a357f4e9135) @@ -776,31 +776,38 @@ var mockRepository = new MockRepository(); var calculatorFactory = mockRepository.StrictMock(); - calculatorFactory.Expect(cf => cf.CreateOvertoppingCalculator(testDataPath, string.Empty)).Return(new TestOvertoppingCalculator - { - IllustrationPointsResult = new TestGeneralResult() - }); + calculatorFactory.Expect(cf => cf.CreateOvertoppingCalculator(Arg.Is.NotNull)) + .WhenCalled(invocation => + { + var settings = (HydraRingCalculationSettings) invocation.Arguments[0]; + Assert.AreEqual(testDataPath, settings.HlcdFilePath); + Assert.IsEmpty(settings.PreprocessorDirectory); + }) + .Return(new TestOvertoppingCalculator + { + IllustrationPointsResult = new TestGeneralResult() + }); calculatorFactory.Stub(cf => cf.CreateDikeHeightCalculator(Arg.Is.NotNull)) .WhenCalled(invocation => { - var settings = (HydraRingCalculationSettings)invocation.Arguments[0]; + var settings = (HydraRingCalculationSettings) invocation.Arguments[0]; Assert.AreEqual(testDataPath, settings.HlcdFilePath); Assert.IsEmpty(settings.PreprocessorDirectory); }).Return(new TestHydraulicLoadsCalculator - { - IllustrationPointsResult = new TestGeneralResult() - }); + { + IllustrationPointsResult = new TestGeneralResult() + }); calculatorFactory.Stub(cf => cf.CreateOvertoppingRateCalculator(Arg.Is.NotNull)) .WhenCalled(invocation => { - var settings = (HydraRingCalculationSettings)invocation.Arguments[0]; + var settings = (HydraRingCalculationSettings) invocation.Arguments[0]; Assert.AreEqual(testDataPath, settings.HlcdFilePath); Assert.IsEmpty(settings.PreprocessorDirectory); }) .Return(new TestHydraulicLoadsCalculator - { - IllustrationPointsResult = new TestGeneralResult() - }); + { + IllustrationPointsResult = new TestGeneralResult() + }); IAssessmentSection assessmentSection = AssessmentSectionTestHelper.CreateAssessmentSectionStub(failureMechanism, mockRepository, validFilePath); @@ -901,11 +908,18 @@ }; var overtoppingCalculator = new TestOvertoppingCalculator(); var calculatorFactory = mockRepository.StrictMock(); - calculatorFactory.Expect(cf => cf.CreateOvertoppingCalculator(testDataPath, string.Empty)).Return(overtoppingCalculator); + calculatorFactory.Expect(cf => cf.CreateOvertoppingCalculator(Arg.Is.NotNull)) + .WhenCalled(invocation => + { + var settings = (HydraRingCalculationSettings) invocation.Arguments[0]; + Assert.AreEqual(testDataPath, settings.HlcdFilePath); + Assert.IsEmpty(settings.PreprocessorDirectory); + }) + .Return(overtoppingCalculator); calculatorFactory.Expect(cf => cf.CreateDikeHeightCalculator(Arg.Is.NotNull)) .WhenCalled(invocation => { - var settings = (HydraRingCalculationSettings)invocation.Arguments[0]; + var settings = (HydraRingCalculationSettings) invocation.Arguments[0]; Assert.AreEqual(testDataPath, settings.HlcdFilePath); Assert.IsEmpty(settings.PreprocessorDirectory); }) @@ -981,11 +995,18 @@ }; var overtoppingCalculator = new TestOvertoppingCalculator(); var calculatorFactory = mockRepository.StrictMock(); - calculatorFactory.Expect(cf => cf.CreateOvertoppingCalculator(testDataPath, string.Empty)).Return(overtoppingCalculator); + calculatorFactory.Expect(cf => cf.CreateOvertoppingCalculator(Arg.Is.NotNull)) + .WhenCalled(invocation => + { + var settings = (HydraRingCalculationSettings) invocation.Arguments[0]; + Assert.AreEqual(testDataPath, settings.HlcdFilePath); + Assert.IsEmpty(settings.PreprocessorDirectory); + }) + .Return(overtoppingCalculator); calculatorFactory.Expect(cf => cf.CreateOvertoppingRateCalculator(Arg.Is.NotNull)) .WhenCalled(invocation => { - var settings = (HydraRingCalculationSettings)invocation.Arguments[0]; + var settings = (HydraRingCalculationSettings) invocation.Arguments[0]; Assert.AreEqual(testDataPath, settings.HlcdFilePath); Assert.IsEmpty(settings.PreprocessorDirectory); }) @@ -1055,7 +1076,14 @@ validFilePath); var overtoppingCalculator = new TestOvertoppingCalculator(); var calculatorFactory = mockRepository.StrictMock(); - calculatorFactory.Expect(cf => cf.CreateOvertoppingCalculator(testDataPath, string.Empty)).Return(overtoppingCalculator); + calculatorFactory.Expect(cf => cf.CreateOvertoppingCalculator(Arg.Is.NotNull)) + .WhenCalled(invocation => + { + var settings = (HydraRingCalculationSettings) invocation.Arguments[0]; + Assert.AreEqual(testDataPath, settings.HlcdFilePath); + Assert.IsEmpty(settings.PreprocessorDirectory); + }) + .Return(overtoppingCalculator); mockRepository.ReplayAll(); var calculation = new GrassCoverErosionInwardsCalculation @@ -1103,12 +1131,19 @@ validFilePath); var overtoppingCalculator = new TestOvertoppingCalculator(); var calculatorFactory = mockRepository.StrictMock(); - calculatorFactory.Expect(cf => cf.CreateOvertoppingCalculator(testDataPath, string.Empty)).Return(overtoppingCalculator); + calculatorFactory.Expect(cf => cf.CreateOvertoppingCalculator(Arg.Is.NotNull)) + .WhenCalled(invocation => + { + var settings = (HydraRingCalculationSettings) invocation.Arguments[0]; + Assert.AreEqual(testDataPath, settings.HlcdFilePath); + Assert.IsEmpty(settings.PreprocessorDirectory); + }) + .Return(overtoppingCalculator); var dikeHeightCalculator = new TestHydraulicLoadsCalculator(); calculatorFactory.Expect(cf => cf.CreateDikeHeightCalculator(Arg.Is.NotNull)) .WhenCalled(invocation => { - var settings = (HydraRingCalculationSettings)invocation.Arguments[0]; + var settings = (HydraRingCalculationSettings) invocation.Arguments[0]; Assert.AreEqual(testDataPath, settings.HlcdFilePath); Assert.IsEmpty(settings.PreprocessorDirectory); }) @@ -1171,19 +1206,26 @@ var overtoppingCalculator = new TestOvertoppingCalculator(); var overtoppingRateCalculator = new TestHydraulicLoadsCalculator(); var calculatorFactory = mockRepository.StrictMock(); - calculatorFactory.Expect(cf => cf.CreateOvertoppingCalculator(testDataPath, string.Empty)).Return(overtoppingCalculator); + calculatorFactory.Expect(cf => cf.CreateOvertoppingCalculator(Arg.Is.NotNull)) + .WhenCalled(invocation => + { + var settings = (HydraRingCalculationSettings) invocation.Arguments[0]; + Assert.AreEqual(testDataPath, settings.HlcdFilePath); + Assert.IsEmpty(settings.PreprocessorDirectory); + }) + .Return(overtoppingCalculator); calculatorFactory.Expect(cf => cf.CreateDikeHeightCalculator(Arg.Is.NotNull)) .WhenCalled(invocation => { - var settings = (HydraRingCalculationSettings)invocation.Arguments[0]; + var settings = (HydraRingCalculationSettings) invocation.Arguments[0]; Assert.AreEqual(testDataPath, settings.HlcdFilePath); Assert.IsEmpty(settings.PreprocessorDirectory); }) .Return(new TestHydraulicLoadsCalculator()); calculatorFactory.Expect(cf => cf.CreateOvertoppingRateCalculator(Arg.Is.NotNull)) .WhenCalled(invocation => { - var settings = (HydraRingCalculationSettings)invocation.Arguments[0]; + var settings = (HydraRingCalculationSettings) invocation.Arguments[0]; Assert.AreEqual(testDataPath, settings.HlcdFilePath); Assert.IsEmpty(settings.PreprocessorDirectory); }) @@ -1244,7 +1286,14 @@ EndInFailure = true }; var calculatorFactory = mockRepository.StrictMock(); - calculatorFactory.Expect(cf => cf.CreateOvertoppingCalculator(testDataPath, string.Empty)).Return(overtoppingCalculator); + calculatorFactory.Expect(cf => cf.CreateOvertoppingCalculator(Arg.Is.NotNull)) + .WhenCalled(invocation => + { + var settings = (HydraRingCalculationSettings) invocation.Arguments[0]; + Assert.AreEqual(testDataPath, settings.HlcdFilePath); + Assert.IsEmpty(settings.PreprocessorDirectory); + }) + .Return(overtoppingCalculator); mockRepository.ReplayAll(); DikeProfile dikeProfile = GetDikeProfile(); @@ -1316,7 +1365,14 @@ EndInFailure = true }; var calculatorFactory = mockRepository.StrictMock(); - calculatorFactory.Expect(cf => cf.CreateOvertoppingCalculator(testDataPath, string.Empty)).Return(overtoppingCalculator); + calculatorFactory.Expect(cf => cf.CreateOvertoppingCalculator(Arg.Is.NotNull)) + .WhenCalled(invocation => + { + var settings = (HydraRingCalculationSettings) invocation.Arguments[0]; + Assert.AreEqual(testDataPath, settings.HlcdFilePath); + Assert.IsEmpty(settings.PreprocessorDirectory); + }) + .Return(overtoppingCalculator); mockRepository.ReplayAll(); DikeProfile dikeProfile = GetDikeProfile(); @@ -1389,7 +1445,14 @@ EndInFailure = false }; var calculatorFactory = mockRepository.StrictMock(); - calculatorFactory.Expect(cf => cf.CreateOvertoppingCalculator(testDataPath, string.Empty)).Return(overtoppingCalculator); + calculatorFactory.Expect(cf => cf.CreateOvertoppingCalculator(Arg.Is.NotNull)) + .WhenCalled(invocation => + { + var settings = (HydraRingCalculationSettings) invocation.Arguments[0]; + Assert.AreEqual(testDataPath, settings.HlcdFilePath); + Assert.IsEmpty(settings.PreprocessorDirectory); + }) + .Return(overtoppingCalculator); mockRepository.ReplayAll(); DikeProfile dikeProfile = GetDikeProfile(); @@ -1466,11 +1529,18 @@ }; var overtoppingCalculator = new TestOvertoppingCalculator(); var calculatorFactory = mockRepository.StrictMock(); - calculatorFactory.Expect(cf => cf.CreateOvertoppingCalculator(testDataPath, string.Empty)).Return(overtoppingCalculator); + calculatorFactory.Expect(cf => cf.CreateOvertoppingCalculator(Arg.Is.NotNull)) + .WhenCalled(invocation => + { + var settings = (HydraRingCalculationSettings) invocation.Arguments[0]; + Assert.AreEqual(testDataPath, settings.HlcdFilePath); + Assert.IsEmpty(settings.PreprocessorDirectory); + }) + .Return(overtoppingCalculator); calculatorFactory.Expect(cf => cf.CreateDikeHeightCalculator(Arg.Is.NotNull)) .WhenCalled(invocation => { - var settings = (HydraRingCalculationSettings)invocation.Arguments[0]; + var settings = (HydraRingCalculationSettings) invocation.Arguments[0]; Assert.AreEqual(testDataPath, settings.HlcdFilePath); Assert.IsEmpty(settings.PreprocessorDirectory); }) @@ -1544,11 +1614,18 @@ }; var overtoppingCalculator = new TestOvertoppingCalculator(); var calculatorFactory = mockRepository.StrictMock(); - calculatorFactory.Expect(cf => cf.CreateOvertoppingCalculator(testDataPath, string.Empty)).Return(overtoppingCalculator); + calculatorFactory.Expect(cf => cf.CreateOvertoppingCalculator(Arg.Is.NotNull)) + .WhenCalled(invocation => + { + var settings = (HydraRingCalculationSettings) invocation.Arguments[0]; + Assert.AreEqual(testDataPath, settings.HlcdFilePath); + Assert.IsEmpty(settings.PreprocessorDirectory); + }) + .Return(overtoppingCalculator); calculatorFactory.Expect(cf => cf.CreateDikeHeightCalculator(Arg.Is.NotNull)) .WhenCalled(invocation => { - var settings = (HydraRingCalculationSettings)invocation.Arguments[0]; + var settings = (HydraRingCalculationSettings) invocation.Arguments[0]; Assert.AreEqual(testDataPath, settings.HlcdFilePath); Assert.IsEmpty(settings.PreprocessorDirectory); }) @@ -1623,11 +1700,18 @@ }; var calculatorFactory = mockRepository.StrictMock(); var overtoppingCalculator = new TestOvertoppingCalculator(); - calculatorFactory.Expect(cf => cf.CreateOvertoppingCalculator(testDataPath, string.Empty)).Return(overtoppingCalculator); + calculatorFactory.Expect(cf => cf.CreateOvertoppingCalculator(Arg.Is.NotNull)) + .WhenCalled(invocation => + { + var settings = (HydraRingCalculationSettings) invocation.Arguments[0]; + Assert.AreEqual(testDataPath, settings.HlcdFilePath); + Assert.IsEmpty(settings.PreprocessorDirectory); + }) + .Return(overtoppingCalculator); calculatorFactory.Expect(cf => cf.CreateDikeHeightCalculator(Arg.Is.NotNull)) .WhenCalled(invocation => { - var settings = (HydraRingCalculationSettings)invocation.Arguments[0]; + var settings = (HydraRingCalculationSettings) invocation.Arguments[0]; Assert.AreEqual(testDataPath, settings.HlcdFilePath); Assert.IsEmpty(settings.PreprocessorDirectory); }) @@ -1703,19 +1787,26 @@ var overtoppingCalculator = new TestOvertoppingCalculator(); var calculatorFactory = mockRepository.StrictMock(); - calculatorFactory.Expect(cf => cf.CreateOvertoppingCalculator(testDataPath, string.Empty)).Return(overtoppingCalculator); + calculatorFactory.Expect(cf => cf.CreateOvertoppingCalculator(Arg.Is.NotNull)) + .WhenCalled(invocation => + { + var settings = (HydraRingCalculationSettings) invocation.Arguments[0]; + Assert.AreEqual(testDataPath, settings.HlcdFilePath); + Assert.IsEmpty(settings.PreprocessorDirectory); + }) + .Return(overtoppingCalculator); calculatorFactory.Expect(cf => cf.CreateDikeHeightCalculator(Arg.Is.NotNull)) .WhenCalled(invocation => { - var settings = (HydraRingCalculationSettings)invocation.Arguments[0]; + var settings = (HydraRingCalculationSettings) invocation.Arguments[0]; Assert.AreEqual(testDataPath, settings.HlcdFilePath); Assert.IsEmpty(settings.PreprocessorDirectory); }) .Return(new TestHydraulicLoadsCalculator()); calculatorFactory.Expect(cf => cf.CreateOvertoppingRateCalculator(Arg.Is.NotNull)) .WhenCalled(invocation => { - var settings = (HydraRingCalculationSettings)invocation.Arguments[0]; + var settings = (HydraRingCalculationSettings) invocation.Arguments[0]; Assert.AreEqual(testDataPath, settings.HlcdFilePath); Assert.IsEmpty(settings.PreprocessorDirectory); }).Return(overtoppingRateCalculator); @@ -1788,19 +1879,26 @@ }; var overtoppingCalculator = new TestOvertoppingCalculator(); var calculatorFactory = mockRepository.StrictMock(); - calculatorFactory.Expect(cf => cf.CreateOvertoppingCalculator(testDataPath, string.Empty)).Return(overtoppingCalculator); + calculatorFactory.Expect(cf => cf.CreateOvertoppingCalculator(Arg.Is.NotNull)) + .WhenCalled(invocation => + { + var settings = (HydraRingCalculationSettings) invocation.Arguments[0]; + Assert.AreEqual(testDataPath, settings.HlcdFilePath); + Assert.IsEmpty(settings.PreprocessorDirectory); + }) + .Return(overtoppingCalculator); calculatorFactory.Expect(cf => cf.CreateDikeHeightCalculator(Arg.Is.NotNull)) .WhenCalled(invocation => { - var settings = (HydraRingCalculationSettings)invocation.Arguments[0]; + var settings = (HydraRingCalculationSettings) invocation.Arguments[0]; Assert.AreEqual(testDataPath, settings.HlcdFilePath); Assert.IsEmpty(settings.PreprocessorDirectory); }) .Return(new TestHydraulicLoadsCalculator()); calculatorFactory.Expect(cf => cf.CreateOvertoppingRateCalculator(Arg.Is.NotNull)) .WhenCalled(invocation => { - var settings = (HydraRingCalculationSettings)invocation.Arguments[0]; + var settings = (HydraRingCalculationSettings) invocation.Arguments[0]; Assert.AreEqual(testDataPath, settings.HlcdFilePath); Assert.IsEmpty(settings.PreprocessorDirectory); }) @@ -1870,7 +1968,14 @@ validFilePath); var calculatorFactory = mockRepository.StrictMock(); var overtoppingCalculator = new TestOvertoppingCalculator(); - calculatorFactory.Expect(cf => cf.CreateOvertoppingCalculator(testDataPath, string.Empty)).Return(overtoppingCalculator); + calculatorFactory.Expect(cf => cf.CreateOvertoppingCalculator(Arg.Is.NotNull)) + .WhenCalled(invocation => + { + var settings = (HydraRingCalculationSettings) invocation.Arguments[0]; + Assert.AreEqual(testDataPath, settings.HlcdFilePath); + Assert.IsEmpty(settings.PreprocessorDirectory); + }) + .Return(overtoppingCalculator); var overtoppingRateCalculator = new TestHydraulicLoadsCalculator { EndInFailure = false, @@ -1879,7 +1984,7 @@ calculatorFactory.Expect(cf => cf.CreateOvertoppingRateCalculator(Arg.Is.NotNull)) .WhenCalled(invocation => { - var settings = (HydraRingCalculationSettings)invocation.Arguments[0]; + var settings = (HydraRingCalculationSettings) invocation.Arguments[0]; Assert.AreEqual(testDataPath, settings.HlcdFilePath); Assert.IsEmpty(settings.PreprocessorDirectory); }) @@ -1959,19 +2064,26 @@ IllustrationPointsResult = new TestGeneralResult() }; var calculatorFactory = mockRepository.StrictMock(); - calculatorFactory.Expect(cf => cf.CreateOvertoppingCalculator(testDataPath, string.Empty)).Return(overtoppingCalculator); + calculatorFactory.Expect(cf => cf.CreateOvertoppingCalculator(Arg.Is.NotNull)) + .WhenCalled(invocation => + { + var settings = (HydraRingCalculationSettings) invocation.Arguments[0]; + Assert.AreEqual(testDataPath, settings.HlcdFilePath); + Assert.IsEmpty(settings.PreprocessorDirectory); + }) + .Return(overtoppingCalculator); calculatorFactory.Expect(cf => cf.CreateDikeHeightCalculator(Arg.Is.NotNull)) .WhenCalled(invocation => { - var settings = (HydraRingCalculationSettings)invocation.Arguments[0]; + var settings = (HydraRingCalculationSettings) invocation.Arguments[0]; Assert.AreEqual(testDataPath, settings.HlcdFilePath); Assert.IsEmpty(settings.PreprocessorDirectory); }) .Return(dikeHeightCalculator); calculatorFactory.Expect(cf => cf.CreateOvertoppingRateCalculator(Arg.Is.NotNull)) .WhenCalled(invocation => { - var settings = (HydraRingCalculationSettings)invocation.Arguments[0]; + var settings = (HydraRingCalculationSettings) invocation.Arguments[0]; Assert.AreEqual(testDataPath, settings.HlcdFilePath); Assert.IsEmpty(settings.PreprocessorDirectory); }) @@ -2055,19 +2167,26 @@ IllustrationPointsResult = new TestGeneralResult() }; var calculatorFactory = mockRepository.StrictMock(); - calculatorFactory.Expect(cf => cf.CreateOvertoppingCalculator(testDataPath, string.Empty)).Return(overtoppingCalculator); + calculatorFactory.Expect(cf => cf.CreateOvertoppingCalculator(Arg.Is.NotNull)) + .WhenCalled(invocation => + { + var settings = (HydraRingCalculationSettings) invocation.Arguments[0]; + Assert.AreEqual(testDataPath, settings.HlcdFilePath); + Assert.IsEmpty(settings.PreprocessorDirectory); + }) + .Return(overtoppingCalculator); calculatorFactory.Expect(cf => cf.CreateDikeHeightCalculator(Arg.Is.NotNull)) .WhenCalled(invocation => { - var settings = (HydraRingCalculationSettings)invocation.Arguments[0]; + var settings = (HydraRingCalculationSettings) invocation.Arguments[0]; Assert.AreEqual(testDataPath, settings.HlcdFilePath); Assert.IsEmpty(settings.PreprocessorDirectory); }) .Return(dikeHeightCalculator); calculatorFactory.Expect(cf => cf.CreateOvertoppingRateCalculator(Arg.Is.NotNull)) .WhenCalled(invocation => { - var settings = (HydraRingCalculationSettings)invocation.Arguments[0]; + var settings = (HydraRingCalculationSettings) invocation.Arguments[0]; Assert.AreEqual(testDataPath, settings.HlcdFilePath); Assert.IsEmpty(settings.PreprocessorDirectory); }) @@ -2151,19 +2270,26 @@ IllustrationPointsParserErrorMessage = parserError }; var calculatorFactory = mockRepository.StrictMock(); - calculatorFactory.Expect(cf => cf.CreateOvertoppingCalculator(testDataPath, string.Empty)).Return(overtoppingCalculator); + calculatorFactory.Expect(cf => cf.CreateOvertoppingCalculator(Arg.Is.NotNull)) + .WhenCalled(invocation => + { + var settings = (HydraRingCalculationSettings) invocation.Arguments[0]; + Assert.AreEqual(testDataPath, settings.HlcdFilePath); + Assert.IsEmpty(settings.PreprocessorDirectory); + }) + .Return(overtoppingCalculator); calculatorFactory.Expect(cf => cf.CreateDikeHeightCalculator(Arg.Is.NotNull)) .WhenCalled(invocation => { - var settings = (HydraRingCalculationSettings)invocation.Arguments[0]; + var settings = (HydraRingCalculationSettings) invocation.Arguments[0]; Assert.AreEqual(testDataPath, settings.HlcdFilePath); Assert.IsEmpty(settings.PreprocessorDirectory); }) .Return(dikeHeightCalculator); calculatorFactory.Expect(cf => cf.CreateOvertoppingRateCalculator(Arg.Is.NotNull)) .WhenCalled(invocation => { - var settings = (HydraRingCalculationSettings)invocation.Arguments[0]; + var settings = (HydraRingCalculationSettings) invocation.Arguments[0]; Assert.AreEqual(testDataPath, settings.HlcdFilePath); Assert.IsEmpty(settings.PreprocessorDirectory); }) @@ -2247,19 +2373,26 @@ IllustrationPointsParserErrorMessage = parserError }; var calculatorFactory = mockRepository.StrictMock(); - calculatorFactory.Expect(cf => cf.CreateOvertoppingCalculator(testDataPath, string.Empty)).Return(overtoppingCalculator); + calculatorFactory.Expect(cf => cf.CreateOvertoppingCalculator(Arg.Is.NotNull)) + .WhenCalled(invocation => + { + var settings = (HydraRingCalculationSettings) invocation.Arguments[0]; + Assert.AreEqual(testDataPath, settings.HlcdFilePath); + Assert.IsEmpty(settings.PreprocessorDirectory); + }) + .Return(overtoppingCalculator); calculatorFactory.Expect(cf => cf.CreateDikeHeightCalculator(Arg.Is.NotNull)) .WhenCalled(invocation => { - var settings = (HydraRingCalculationSettings)invocation.Arguments[0]; + var settings = (HydraRingCalculationSettings) invocation.Arguments[0]; Assert.AreEqual(testDataPath, settings.HlcdFilePath); Assert.IsEmpty(settings.PreprocessorDirectory); }) .Return(dikeHeightCalculator); calculatorFactory.Expect(cf => cf.CreateOvertoppingRateCalculator(Arg.Is.NotNull)) .WhenCalled(invocation => { - var settings = (HydraRingCalculationSettings)invocation.Arguments[0]; + var settings = (HydraRingCalculationSettings) invocation.Arguments[0]; Assert.AreEqual(testDataPath, settings.HlcdFilePath); Assert.IsEmpty(settings.PreprocessorDirectory); }) @@ -2343,19 +2476,26 @@ IllustrationPointsResult = new TestGeneralResult() }; var calculatorFactory = mockRepository.StrictMock(); - calculatorFactory.Expect(cf => cf.CreateOvertoppingCalculator(testDataPath, string.Empty)).Return(overtoppingCalculator); + calculatorFactory.Expect(cf => cf.CreateOvertoppingCalculator(Arg.Is.NotNull)) + .WhenCalled(invocation => + { + var settings = (HydraRingCalculationSettings) invocation.Arguments[0]; + Assert.AreEqual(testDataPath, settings.HlcdFilePath); + Assert.IsEmpty(settings.PreprocessorDirectory); + }) + .Return(overtoppingCalculator); calculatorFactory.Expect(cf => cf.CreateDikeHeightCalculator(Arg.Is.NotNull)) .WhenCalled(invocation => { - var settings = (HydraRingCalculationSettings)invocation.Arguments[0]; + var settings = (HydraRingCalculationSettings) invocation.Arguments[0]; Assert.AreEqual(testDataPath, settings.HlcdFilePath); Assert.IsEmpty(settings.PreprocessorDirectory); }) .Return(dikeHeightCalculator); calculatorFactory.Expect(cf => cf.CreateOvertoppingRateCalculator(Arg.Is.NotNull)) .WhenCalled(invocation => { - var settings = (HydraRingCalculationSettings)invocation.Arguments[0]; + var settings = (HydraRingCalculationSettings) invocation.Arguments[0]; Assert.AreEqual(testDataPath, settings.HlcdFilePath); Assert.IsEmpty(settings.PreprocessorDirectory); }) @@ -2439,19 +2579,26 @@ IllustrationPointsResult = new TestGeneralResult() }; var calculatorFactory = mockRepository.StrictMock(); - calculatorFactory.Expect(cf => cf.CreateOvertoppingCalculator(testDataPath, string.Empty)).Return(overtoppingCalculator); + calculatorFactory.Expect(cf => cf.CreateOvertoppingCalculator(Arg.Is.NotNull)) + .WhenCalled(invocation => + { + var settings = (HydraRingCalculationSettings) invocation.Arguments[0]; + Assert.AreEqual(testDataPath, settings.HlcdFilePath); + Assert.IsEmpty(settings.PreprocessorDirectory); + }) + .Return(overtoppingCalculator); calculatorFactory.Expect(cf => cf.CreateDikeHeightCalculator(Arg.Is.NotNull)) .WhenCalled(invocation => { - var settings = (HydraRingCalculationSettings)invocation.Arguments[0]; + var settings = (HydraRingCalculationSettings) invocation.Arguments[0]; Assert.AreEqual(testDataPath, settings.HlcdFilePath); Assert.IsEmpty(settings.PreprocessorDirectory); }) .Return(dikeHeightCalculator); calculatorFactory.Expect(cf => cf.CreateOvertoppingRateCalculator(Arg.Is.NotNull)) .WhenCalled(invocation => { - var settings = (HydraRingCalculationSettings)invocation.Arguments[0]; + var settings = (HydraRingCalculationSettings) invocation.Arguments[0]; Assert.AreEqual(testDataPath, settings.HlcdFilePath); Assert.IsEmpty(settings.PreprocessorDirectory); }) @@ -2534,19 +2681,26 @@ IllustrationPointsResult = new TestGeneralResult() }; var calculatorFactory = mockRepository.StrictMock(); - calculatorFactory.Expect(cf => cf.CreateOvertoppingCalculator(testDataPath, string.Empty)).Return(overtoppingCalculator); + calculatorFactory.Expect(cf => cf.CreateOvertoppingCalculator(Arg.Is.NotNull)) + .WhenCalled(invocation => + { + var settings = (HydraRingCalculationSettings) invocation.Arguments[0]; + Assert.AreEqual(testDataPath, settings.HlcdFilePath); + Assert.IsEmpty(settings.PreprocessorDirectory); + }) + .Return(overtoppingCalculator); calculatorFactory.Expect(cf => cf.CreateDikeHeightCalculator(Arg.Is.NotNull)) .WhenCalled(invocation => { - var settings = (HydraRingCalculationSettings)invocation.Arguments[0]; + var settings = (HydraRingCalculationSettings) invocation.Arguments[0]; Assert.AreEqual(testDataPath, settings.HlcdFilePath); Assert.IsEmpty(settings.PreprocessorDirectory); }) .Return(dikeHeightCalculator); calculatorFactory.Expect(cf => cf.CreateOvertoppingRateCalculator(Arg.Is.NotNull)) .WhenCalled(invocation => { - var settings = (HydraRingCalculationSettings)invocation.Arguments[0]; + var settings = (HydraRingCalculationSettings) invocation.Arguments[0]; Assert.AreEqual(testDataPath, settings.HlcdFilePath); Assert.IsEmpty(settings.PreprocessorDirectory); }) @@ -2631,19 +2785,26 @@ IllustrationPointsResult = new TestGeneralResult() }; var calculatorFactory = mockRepository.StrictMock(); - calculatorFactory.Expect(cf => cf.CreateOvertoppingCalculator(testDataPath, string.Empty)).Return(overtoppingCalculator); + calculatorFactory.Expect(cf => cf.CreateOvertoppingCalculator(Arg.Is.NotNull)) + .WhenCalled(invocation => + { + var settings = (HydraRingCalculationSettings) invocation.Arguments[0]; + Assert.AreEqual(testDataPath, settings.HlcdFilePath); + Assert.IsEmpty(settings.PreprocessorDirectory); + }) + .Return(overtoppingCalculator); calculatorFactory.Expect(cf => cf.CreateDikeHeightCalculator(Arg.Is.NotNull)) .WhenCalled(invocation => { - var settings = (HydraRingCalculationSettings)invocation.Arguments[0]; + var settings = (HydraRingCalculationSettings) invocation.Arguments[0]; Assert.AreEqual(testDataPath, settings.HlcdFilePath); Assert.IsEmpty(settings.PreprocessorDirectory); }) .Return(dikeHeightCalculator); calculatorFactory.Expect(cf => cf.CreateOvertoppingRateCalculator(Arg.Is.NotNull)) .WhenCalled(invocation => { - var settings = (HydraRingCalculationSettings)invocation.Arguments[0]; + var settings = (HydraRingCalculationSettings) invocation.Arguments[0]; Assert.AreEqual(testDataPath, settings.HlcdFilePath); Assert.IsEmpty(settings.PreprocessorDirectory); }) @@ -2730,19 +2891,26 @@ IllustrationPointsResult = TestGeneralResult.CreateGeneralResultWithSubMechanismIllustrationPoints() }; var calculatorFactory = mockRepository.StrictMock(); - calculatorFactory.Expect(cf => cf.CreateOvertoppingCalculator(testDataPath, string.Empty)).Return(overtoppingCalculator); + calculatorFactory.Expect(cf => cf.CreateOvertoppingCalculator(Arg.Is.NotNull)) + .WhenCalled(invocation => + { + var settings = (HydraRingCalculationSettings) invocation.Arguments[0]; + Assert.AreEqual(testDataPath, settings.HlcdFilePath); + Assert.IsEmpty(settings.PreprocessorDirectory); + }) + .Return(overtoppingCalculator); calculatorFactory.Expect(cf => cf.CreateDikeHeightCalculator(Arg.Is.NotNull)) .WhenCalled(invocation => { - var settings = (HydraRingCalculationSettings)invocation.Arguments[0]; + var settings = (HydraRingCalculationSettings) invocation.Arguments[0]; Assert.AreEqual(testDataPath, settings.HlcdFilePath); Assert.IsEmpty(settings.PreprocessorDirectory); }) .Return(dikeHeightCalculator); calculatorFactory.Expect(cf => cf.CreateOvertoppingRateCalculator(Arg.Is.NotNull)) .WhenCalled(invocation => { - var settings = (HydraRingCalculationSettings)invocation.Arguments[0]; + var settings = (HydraRingCalculationSettings) invocation.Arguments[0]; Assert.AreEqual(testDataPath, settings.HlcdFilePath); Assert.IsEmpty(settings.PreprocessorDirectory); }) @@ -2827,19 +2995,26 @@ IllustrationPointsResult = GeneralResultTestFactory.CreateGeneralResultWithDuplicateStochasts() }; var calculatorFactory = mockRepository.StrictMock(); - calculatorFactory.Expect(cf => cf.CreateOvertoppingCalculator(testDataPath, string.Empty)).Return(overtoppingCalculator); + calculatorFactory.Expect(cf => cf.CreateOvertoppingCalculator(Arg.Is.NotNull)) + .WhenCalled(invocation => + { + var settings = (HydraRingCalculationSettings) invocation.Arguments[0]; + Assert.AreEqual(testDataPath, settings.HlcdFilePath); + Assert.IsEmpty(settings.PreprocessorDirectory); + }) + .Return(overtoppingCalculator); calculatorFactory.Expect(cf => cf.CreateDikeHeightCalculator(Arg.Is.NotNull)) .WhenCalled(invocation => { - var settings = (HydraRingCalculationSettings)invocation.Arguments[0]; + var settings = (HydraRingCalculationSettings) invocation.Arguments[0]; Assert.AreEqual(testDataPath, settings.HlcdFilePath); Assert.IsEmpty(settings.PreprocessorDirectory); }) .Return(dikeHeightCalculator); calculatorFactory.Expect(cf => cf.CreateOvertoppingRateCalculator(Arg.Is.NotNull)) .WhenCalled(invocation => { - var settings = (HydraRingCalculationSettings)invocation.Arguments[0]; + var settings = (HydraRingCalculationSettings) invocation.Arguments[0]; Assert.AreEqual(testDataPath, settings.HlcdFilePath); Assert.IsEmpty(settings.PreprocessorDirectory); }) @@ -2926,19 +3101,26 @@ IllustrationPointsResult = new TestGeneralResult() }; var calculatorFactory = mockRepository.StrictMock(); - calculatorFactory.Expect(cf => cf.CreateOvertoppingCalculator(testDataPath, string.Empty)).Return(overtoppingCalculator); + calculatorFactory.Expect(cf => cf.CreateOvertoppingCalculator(Arg.Is.NotNull)) + .WhenCalled(invocation => + { + var settings = (HydraRingCalculationSettings) invocation.Arguments[0]; + Assert.AreEqual(testDataPath, settings.HlcdFilePath); + Assert.IsEmpty(settings.PreprocessorDirectory); + }) + .Return(overtoppingCalculator); calculatorFactory.Expect(cf => cf.CreateDikeHeightCalculator(Arg.Is.NotNull)) .WhenCalled(invocation => { - var settings = (HydraRingCalculationSettings)invocation.Arguments[0]; + var settings = (HydraRingCalculationSettings) invocation.Arguments[0]; Assert.AreEqual(testDataPath, settings.HlcdFilePath); Assert.IsEmpty(settings.PreprocessorDirectory); }) .Return(dikeHeightCalculator); calculatorFactory.Expect(cf => cf.CreateOvertoppingRateCalculator(Arg.Is.NotNull)) .WhenCalled(invocation => { - var settings = (HydraRingCalculationSettings)invocation.Arguments[0]; + var settings = (HydraRingCalculationSettings) invocation.Arguments[0]; Assert.AreEqual(testDataPath, settings.HlcdFilePath); Assert.IsEmpty(settings.PreprocessorDirectory); }) @@ -3023,19 +3205,26 @@ IllustrationPointsResult = new TestGeneralResult() }; var calculatorFactory = mockRepository.StrictMock(); - calculatorFactory.Expect(cf => cf.CreateOvertoppingCalculator(testDataPath, string.Empty)).Return(overtoppingCalculator); + calculatorFactory.Expect(cf => cf.CreateOvertoppingCalculator(Arg.Is.NotNull)) + .WhenCalled(invocation => + { + var settings = (HydraRingCalculationSettings) invocation.Arguments[0]; + Assert.AreEqual(testDataPath, settings.HlcdFilePath); + Assert.IsEmpty(settings.PreprocessorDirectory); + }) + .Return(overtoppingCalculator); calculatorFactory.Expect(cf => cf.CreateDikeHeightCalculator(Arg.Is.NotNull)) .WhenCalled(invocation => { - var settings = (HydraRingCalculationSettings)invocation.Arguments[0]; + var settings = (HydraRingCalculationSettings) invocation.Arguments[0]; Assert.AreEqual(testDataPath, settings.HlcdFilePath); Assert.IsEmpty(settings.PreprocessorDirectory); }) .Return(dikeHeightCalculator); calculatorFactory.Expect(cf => cf.CreateOvertoppingRateCalculator(Arg.Is.NotNull)) .WhenCalled(invocation => { - var settings = (HydraRingCalculationSettings)invocation.Arguments[0]; + var settings = (HydraRingCalculationSettings) invocation.Arguments[0]; Assert.AreEqual(testDataPath, settings.HlcdFilePath); Assert.IsEmpty(settings.PreprocessorDirectory); }) @@ -3113,19 +3302,26 @@ var dikeHeightCalculator = new TestHydraulicLoadsCalculator(); var overtoppingRateCalculator = new TestHydraulicLoadsCalculator(); var calculatorFactory = mockRepository.StrictMock(); - calculatorFactory.Expect(cf => cf.CreateOvertoppingCalculator(testDataPath, string.Empty)).Return(overtoppingCalculator); + calculatorFactory.Expect(cf => cf.CreateOvertoppingCalculator(Arg.Is.NotNull)) + .WhenCalled(invocation => + { + var settings = (HydraRingCalculationSettings) invocation.Arguments[0]; + Assert.AreEqual(testDataPath, settings.HlcdFilePath); + Assert.IsEmpty(settings.PreprocessorDirectory); + }) + .Return(overtoppingCalculator); calculatorFactory.Expect(cf => cf.CreateDikeHeightCalculator(Arg.Is.NotNull)) .WhenCalled(invocation => { - var settings = (HydraRingCalculationSettings)invocation.Arguments[0]; + var settings = (HydraRingCalculationSettings) invocation.Arguments[0]; Assert.AreEqual(testDataPath, settings.HlcdFilePath); Assert.IsEmpty(settings.PreprocessorDirectory); }) .Return(dikeHeightCalculator); calculatorFactory.Expect(cf => cf.CreateOvertoppingRateCalculator(Arg.Is.NotNull)) .WhenCalled(invocation => { - var settings = (HydraRingCalculationSettings)invocation.Arguments[0]; + var settings = (HydraRingCalculationSettings) invocation.Arguments[0]; Assert.AreEqual(testDataPath, settings.HlcdFilePath); Assert.IsEmpty(settings.PreprocessorDirectory); }) @@ -3172,19 +3368,26 @@ var dikeHeightCalculator = new TestHydraulicLoadsCalculator(); var overtoppingRateCalculator = new TestHydraulicLoadsCalculator(); var calculatorFactory = mockRepository.StrictMock(); - calculatorFactory.Expect(cf => cf.CreateOvertoppingCalculator(testDataPath, validPreprocessorDirectory)).Return(overtoppingCalculator); + calculatorFactory.Expect(cf => cf.CreateOvertoppingCalculator(Arg.Is.NotNull)) + .WhenCalled(invocation => + { + var settings = (HydraRingCalculationSettings) invocation.Arguments[0]; + Assert.AreEqual(testDataPath, settings.HlcdFilePath); + Assert.AreEqual(validPreprocessorDirectory, settings.PreprocessorDirectory); + }) + .Return(overtoppingCalculator); calculatorFactory.Expect(cf => cf.CreateDikeHeightCalculator(Arg.Is.NotNull)) .WhenCalled(invocation => { - var settings = (HydraRingCalculationSettings)invocation.Arguments[0]; + var settings = (HydraRingCalculationSettings) invocation.Arguments[0]; Assert.AreEqual(testDataPath, settings.HlcdFilePath); Assert.AreEqual(validPreprocessorDirectory, settings.PreprocessorDirectory); }) .Return(dikeHeightCalculator); calculatorFactory.Expect(cf => cf.CreateOvertoppingRateCalculator(Arg.Is.NotNull)) .WhenCalled(invocation => { - var settings = (HydraRingCalculationSettings)invocation.Arguments[0]; + var settings = (HydraRingCalculationSettings) invocation.Arguments[0]; Assert.AreEqual(testDataPath, settings.HlcdFilePath); Assert.AreEqual(validPreprocessorDirectory, settings.PreprocessorDirectory); }) @@ -3236,19 +3439,26 @@ var dikeHeightCalculator = new TestHydraulicLoadsCalculator(); var overtoppingRateCalculator = new TestHydraulicLoadsCalculator(); var calculatorFactory = mockRepository.StrictMock(); - calculatorFactory.Expect(cf => cf.CreateOvertoppingCalculator(testDataPath, string.Empty)).Return(overtoppingCalculator); + calculatorFactory.Expect(cf => cf.CreateOvertoppingCalculator(Arg.Is.NotNull)) + .WhenCalled(invocation => + { + var settings = (HydraRingCalculationSettings) invocation.Arguments[0]; + Assert.AreEqual(testDataPath, settings.HlcdFilePath); + Assert.IsEmpty(settings.PreprocessorDirectory); + }) + .Return(overtoppingCalculator); calculatorFactory.Expect(cf => cf.CreateDikeHeightCalculator(Arg.Is.NotNull)) .WhenCalled(invocation => { - var settings = (HydraRingCalculationSettings)invocation.Arguments[0]; + var settings = (HydraRingCalculationSettings) invocation.Arguments[0]; Assert.AreEqual(testDataPath, settings.HlcdFilePath); Assert.IsEmpty(settings.PreprocessorDirectory); }) .Return(dikeHeightCalculator); calculatorFactory.Expect(cf => cf.CreateOvertoppingRateCalculator(Arg.Is.NotNull)) .WhenCalled(invocation => { - var settings = (HydraRingCalculationSettings)invocation.Arguments[0]; + var settings = (HydraRingCalculationSettings) invocation.Arguments[0]; Assert.AreEqual(testDataPath, settings.HlcdFilePath); Assert.IsEmpty(settings.PreprocessorDirectory); }) @@ -3300,7 +3510,14 @@ validFilePath); var overtoppingCalculator = new TestOvertoppingCalculator(); var calculatorFactory = mockRepository.StrictMock(); - calculatorFactory.Expect(cf => cf.CreateOvertoppingCalculator(testDataPath, string.Empty)).Return(overtoppingCalculator); + calculatorFactory.Expect(cf => cf.CreateOvertoppingCalculator(Arg.Is.NotNull)) + .WhenCalled(invocation => + { + var settings = (HydraRingCalculationSettings) invocation.Arguments[0]; + Assert.AreEqual(testDataPath, settings.HlcdFilePath); + Assert.IsEmpty(settings.PreprocessorDirectory); + }) + .Return(overtoppingCalculator); mockRepository.ReplayAll(); var calculation = new GrassCoverErosionInwardsCalculation @@ -3341,7 +3558,14 @@ validFilePath); var overtoppingCalculator = new TestOvertoppingCalculator(); var calculatorFactory = mockRepository.StrictMock(); - calculatorFactory.Expect(cf => cf.CreateOvertoppingCalculator(testDataPath, string.Empty)).Return(overtoppingCalculator); + calculatorFactory.Expect(cf => cf.CreateOvertoppingCalculator(Arg.Is.NotNull)) + .WhenCalled(invocation => + { + var settings = (HydraRingCalculationSettings) invocation.Arguments[0]; + Assert.AreEqual(testDataPath, settings.HlcdFilePath); + Assert.IsEmpty(settings.PreprocessorDirectory); + }) + .Return(overtoppingCalculator); mockRepository.ReplayAll(); var calculation = new GrassCoverErosionInwardsCalculation Index: Ringtoets/HydraRing/src/Ringtoets.HydraRing.Calculation/Calculator/Factory/HydraRingCalculatorFactory.cs =================================================================== diff -u -raca65a56029a6646ce2e997d7c14e547356b5b65 -rdb71b309ed4ce429385a3ce6e8fb0a357f4e9135 --- Ringtoets/HydraRing/src/Ringtoets.HydraRing.Calculation/Calculator/Factory/HydraRingCalculatorFactory.cs (.../HydraRingCalculatorFactory.cs) (revision aca65a56029a6646ce2e997d7c14e547356b5b65) +++ Ringtoets/HydraRing/src/Ringtoets.HydraRing.Calculation/Calculator/Factory/HydraRingCalculatorFactory.cs (.../HydraRingCalculatorFactory.cs) (revision db71b309ed4ce429385a3ce6e8fb0a357f4e9135) @@ -52,10 +52,9 @@ return new DesignWaterLevelCalculator(settings); } - public IOvertoppingCalculator CreateOvertoppingCalculator(string hlcdDirectory, string preprocessorDirectory) + public IOvertoppingCalculator CreateOvertoppingCalculator(HydraRingCalculationSettings calculationSettings) { - var settings = new HydraRingCalculationSettings(hlcdDirectory, preprocessorDirectory); - return new OvertoppingCalculator(settings); + return new OvertoppingCalculator(calculationSettings); } public IHydraulicLoadsCalculator CreateDikeHeightCalculator(HydraRingCalculationSettings calculationSettings) Index: Ringtoets/HydraRing/src/Ringtoets.HydraRing.Calculation/Calculator/Factory/IHydraRingCalculatorFactory.cs =================================================================== diff -u -raca65a56029a6646ce2e997d7c14e547356b5b65 -rdb71b309ed4ce429385a3ce6e8fb0a357f4e9135 --- Ringtoets/HydraRing/src/Ringtoets.HydraRing.Calculation/Calculator/Factory/IHydraRingCalculatorFactory.cs (.../IHydraRingCalculatorFactory.cs) (revision aca65a56029a6646ce2e997d7c14e547356b5b65) +++ Ringtoets/HydraRing/src/Ringtoets.HydraRing.Calculation/Calculator/Factory/IHydraRingCalculatorFactory.cs (.../IHydraRingCalculatorFactory.cs) (revision db71b309ed4ce429385a3ce6e8fb0a357f4e9135) @@ -45,14 +45,14 @@ /// /// Creates a calculator for performing an overtopping calculation. /// - /// The directory where the hydraulic database can be found. - /// The preprocessor directory. - /// Preprocessing is disabled when + /// The with the + /// general information for a Hydra-Ring calculation. + /// A new .> + /// Thrown when + /// is null. + /// Preprocessing is disabled when /// equals . - /// A new . - /// Thrown when - /// or is null. - IOvertoppingCalculator CreateOvertoppingCalculator(string hlcdDirectory, string preprocessorDirectory); + IOvertoppingCalculator CreateOvertoppingCalculator(HydraRingCalculationSettings calculationSettings); /// /// Creates a calculator for calculating a dike height. Index: Ringtoets/Integration/test/Ringtoets.Integration.Plugin.Test/TreeNodeInfos/AssessmentSectionTreeNodeInfoTest.cs =================================================================== diff -u -rd97f06dcf08df485826a196e31c05e811ab6dc67 -rdb71b309ed4ce429385a3ce6e8fb0a357f4e9135 --- Ringtoets/Integration/test/Ringtoets.Integration.Plugin.Test/TreeNodeInfos/AssessmentSectionTreeNodeInfoTest.cs (.../AssessmentSectionTreeNodeInfoTest.cs) (revision d97f06dcf08df485826a196e31c05e811ab6dc67) +++ Ringtoets/Integration/test/Ringtoets.Integration.Plugin.Test/TreeNodeInfos/AssessmentSectionTreeNodeInfoTest.cs (.../AssessmentSectionTreeNodeInfoTest.cs) (revision db71b309ed4ce429385a3ce6e8fb0a357f4e9135) @@ -541,7 +541,13 @@ calculatorFactory.Expect(cf => cf.CreateWaveHeightCalculator(testDataPath, "")) .Return(new TestWaveHeightCalculator()).Repeat.Times(4); - calculatorFactory.Expect(cf => cf.CreateOvertoppingCalculator(testDataPath, "")) + calculatorFactory.Expect(cf => cf.CreateOvertoppingCalculator(Arg.Is.NotNull)) + .WhenCalled(invocation => + { + var settings = (HydraRingCalculationSettings) invocation.Arguments[0]; + Assert.AreEqual(testDataPath, settings.HlcdFilePath); + Assert.IsEmpty(settings.PreprocessorDirectory); + }) .Return(new TestOvertoppingCalculator()); calculatorFactory.Expect(cf => cf.CreateWaveConditionsCosineCalculator(testDataPath, "")) Index: Ringtoets/Integration/test/Ringtoets.Integration.Service.Test/AssessmentSectionCalculationActivityFactoryTest.cs =================================================================== diff -u -rd97f06dcf08df485826a196e31c05e811ab6dc67 -rdb71b309ed4ce429385a3ce6e8fb0a357f4e9135 --- Ringtoets/Integration/test/Ringtoets.Integration.Service.Test/AssessmentSectionCalculationActivityFactoryTest.cs (.../AssessmentSectionCalculationActivityFactoryTest.cs) (revision d97f06dcf08df485826a196e31c05e811ab6dc67) +++ Ringtoets/Integration/test/Ringtoets.Integration.Service.Test/AssessmentSectionCalculationActivityFactoryTest.cs (.../AssessmentSectionCalculationActivityFactoryTest.cs) (revision db71b309ed4ce429385a3ce6e8fb0a357f4e9135) @@ -111,7 +111,13 @@ calculatorFactory.Expect(cf => cf.CreateWaveHeightCalculator(testDataPath, "")) .Return(new TestWaveHeightCalculator()).Repeat.Times(4); - calculatorFactory.Expect(cf => cf.CreateOvertoppingCalculator(testDataPath, "")) + calculatorFactory.Expect(cf => cf.CreateOvertoppingCalculator(Arg.Is.NotNull)) + .WhenCalled(invocation => + { + var settings = (HydraRingCalculationSettings) invocation.Arguments[0]; + Assert.AreEqual(testDataPath, settings.HlcdFilePath); + Assert.IsEmpty(settings.PreprocessorDirectory); + }) .Return(new TestOvertoppingCalculator()); calculatorFactory.Expect(cf => cf.CreateWaveConditionsCosineCalculator(testDataPath, "")) @@ -137,7 +143,7 @@ calculatorFactory.Expect(cf => cf.CreateDunesBoundaryConditionsCalculator(Arg.Is.NotNull)) .WhenCalled(invocation => { - var settings = (HydraRingCalculationSettings)invocation.Arguments[0]; + var settings = (HydraRingCalculationSettings) invocation.Arguments[0]; Assert.AreEqual(testDataPath, settings.HlcdFilePath); Assert.IsEmpty(settings.PreprocessorDirectory); })