Index: Ringtoets/ClosingStructures/test/Ringtoets.ClosingStructures.Service.Test/ClosingStructuresCalculationServiceTest.cs
===================================================================
diff -u -r94aa3f043a2db78b3fabafb0aa4556778eae64bd -rd73de75958a45ae87cf4e0a095dc0b58583af575
--- Ringtoets/ClosingStructures/test/Ringtoets.ClosingStructures.Service.Test/ClosingStructuresCalculationServiceTest.cs	(.../ClosingStructuresCalculationServiceTest.cs)	(revision 94aa3f043a2db78b3fabafb0aa4556778eae64bd)
+++ Ringtoets/ClosingStructures/test/Ringtoets.ClosingStructures.Service.Test/ClosingStructuresCalculationServiceTest.cs	(.../ClosingStructuresCalculationServiceTest.cs)	(revision d73de75958a45ae87cf4e0a095dc0b58583af575)
@@ -49,7 +49,8 @@
     public class ClosingStructuresCalculationServiceTest
     {
         private static readonly string testDataPath = TestHelper.GetTestDataPath(TestDataPath.Ringtoets.Integration.Service, "HydraRingCalculation");
-        private static readonly string validFilePath = Path.Combine(testDataPath, "HRD dutch coast south.sqlite");
+        private static readonly string validHydraulicBoundaryDatabaseFilePath = Path.Combine(testDataPath, "HRD dutch coast south.sqlite");
+        private static readonly string validHlcdFilePath = Path.Combine(testDataPath, "Hlcd.sqlite");
         private static readonly string validPreprocessorDirectory = TestHelper.GetScratchPadPath();
 
         [Test]
@@ -332,8 +333,7 @@
                 // Call
                 TestDelegate call = () => service.Calculate(calculation,
                                                             failureMechanism.GeneralInput,
-                                                            validFilePath,
-                                                            validPreprocessorDirectory);
+                                                            CreateCalculationSettings());
 
                 // Assert
                 const string expectedMessage = "The value of argument 'structureInput' (100) is invalid for Enum type 'ClosingStructureInflowModelType'.";
@@ -356,17 +356,10 @@
             var mockRepository = new MockRepository();
             IAssessmentSection assessmentSection = AssessmentSectionTestHelper.CreateAssessmentSectionStub(failureMechanism,
                                                                                                            mockRepository);
-
             var calculator = new TestStructuresCalculator<StructuresClosureCalculationInput>();
             var calculatorFactory = mockRepository.StrictMock<IHydraRingCalculatorFactory>();
-            calculatorFactory.Expect(cf => cf.CreateStructuresCalculator<StructuresClosureCalculationInput>(
-                                         Arg<HydraRingCalculationSettings>.Is.NotNull))
-                             .WhenCalled(invocation =>
-                             {
-                                 var settings = (HydraRingCalculationSettings) invocation.Arguments[0];
-                                 Assert.AreEqual(testDataPath, settings.HlcdFilePath);
-                                 Assert.AreEqual(validPreprocessorDirectory, settings.PreprocessorDirectory);
-                             })
+            calculatorFactory.Expect(cf => cf.CreateStructuresCalculator<StructuresClosureCalculationInput>(null))
+                             .IgnoreArguments()
                              .Return(calculator);
             mockRepository.ReplayAll();
 
@@ -388,8 +381,7 @@
                 // Call
                 new ClosingStructuresCalculationService().Calculate(calculation,
                                                                     failureMechanism.GeneralInput,
-                                                                    validFilePath,
-                                                                    validPreprocessorDirectory);
+                                                                    CreateCalculationSettings());
 
                 // Assert
                 StructuresClosureCalculationInput[] calculationInputs = calculator.ReceivedInputs.ToArray();
@@ -446,14 +438,8 @@
 
             var calculator = new TestStructuresCalculator<StructuresClosureCalculationInput>();
             var calculatorFactory = mockRepository.StrictMock<IHydraRingCalculatorFactory>();
-            calculatorFactory.Expect(cf => cf.CreateStructuresCalculator<StructuresClosureCalculationInput>(
-                                         Arg<HydraRingCalculationSettings>.Is.NotNull))
-                             .WhenCalled(invocation =>
-                             {
-                                 var settings = (HydraRingCalculationSettings) invocation.Arguments[0];
-                                 Assert.AreEqual(testDataPath, settings.HlcdFilePath);
-                                 Assert.AreEqual(validPreprocessorDirectory, settings.PreprocessorDirectory);
-                             })
+            calculatorFactory.Expect(cf => cf.CreateStructuresCalculator<StructuresClosureCalculationInput>(null))
+                             .IgnoreArguments()
                              .Return(calculator);
             mockRepository.ReplayAll();
 
@@ -477,8 +463,7 @@
                 // Call
                 new ClosingStructuresCalculationService().Calculate(calculation,
                                                                     failureMechanism.GeneralInput,
-                                                                    validFilePath,
-                                                                    validPreprocessorDirectory);
+                                                                    CreateCalculationSettings());
 
                 // Assert
                 StructuresClosureCalculationInput[] calculationInputs = calculator.ReceivedInputs.ToArray();
@@ -534,14 +519,8 @@
 
             var calculator = new TestStructuresCalculator<StructuresClosureCalculationInput>();
             var calculatorFactory = mockRepository.StrictMock<IHydraRingCalculatorFactory>();
-            calculatorFactory.Expect(cf => cf.CreateStructuresCalculator<StructuresClosureCalculationInput>(
-                                         Arg<HydraRingCalculationSettings>.Is.NotNull))
-                             .WhenCalled(invocation =>
-                             {
-                                 var settings = (HydraRingCalculationSettings) invocation.Arguments[0];
-                                 Assert.AreEqual(testDataPath, settings.HlcdFilePath);
-                                 Assert.AreEqual(validPreprocessorDirectory, settings.PreprocessorDirectory);
-                             })
+            calculatorFactory.Expect(cf => cf.CreateStructuresCalculator<StructuresClosureCalculationInput>(null))
+                             .IgnoreArguments()
                              .Return(calculator);
             mockRepository.ReplayAll();
 
@@ -564,8 +543,7 @@
                 // Call
                 new ClosingStructuresCalculationService().Calculate(calculation,
                                                                     failureMechanism.GeneralInput,
-                                                                    validFilePath,
-                                                                    validPreprocessorDirectory);
+                                                                    CreateCalculationSettings());
 
                 // Assert
                 StructuresClosureCalculationInput[] calculationInputs = calculator.ReceivedInputs.ToArray();
@@ -620,14 +598,8 @@
 
             var calculator = new TestStructuresCalculator<StructuresClosureCalculationInput>();
             var calculatorFactory = mockRepository.StrictMock<IHydraRingCalculatorFactory>();
-            calculatorFactory.Expect(cf => cf.CreateStructuresCalculator<StructuresClosureCalculationInput>(
-                                         Arg<HydraRingCalculationSettings>.Is.NotNull))
-                             .WhenCalled(invocation =>
-                             {
-                                 var settings = (HydraRingCalculationSettings) invocation.Arguments[0];
-                                 Assert.AreEqual(testDataPath, settings.HlcdFilePath);
-                                 Assert.AreEqual(validPreprocessorDirectory, settings.PreprocessorDirectory);
-                             })
+            calculatorFactory.Expect(cf => cf.CreateStructuresCalculator<StructuresClosureCalculationInput>(null))
+                             .IgnoreArguments()
                              .Return(calculator);
             mockRepository.ReplayAll();
 
@@ -652,8 +624,7 @@
                 // Call
                 new ClosingStructuresCalculationService().Calculate(calculation,
                                                                     failureMechanism.GeneralInput,
-                                                                    validFilePath,
-                                                                    validPreprocessorDirectory);
+                                                                    CreateCalculationSettings());
 
                 // Assert
                 StructuresClosureCalculationInput[] calculationInputs = calculator.ReceivedInputs.ToArray();
@@ -706,14 +677,8 @@
                                                                                                            mockRepository);
             var calculator = new TestStructuresCalculator<StructuresClosureCalculationInput>();
             var calculatorFactory = mockRepository.StrictMock<IHydraRingCalculatorFactory>();
-            calculatorFactory.Expect(cf => cf.CreateStructuresCalculator<StructuresClosureCalculationInput>(
-                                         Arg<HydraRingCalculationSettings>.Is.NotNull))
-                             .WhenCalled(invocation =>
-                             {
-                                 var settings = (HydraRingCalculationSettings) invocation.Arguments[0];
-                                 Assert.AreEqual(testDataPath, settings.HlcdFilePath);
-                                 Assert.AreEqual(validPreprocessorDirectory, settings.PreprocessorDirectory);
-                             })
+            calculatorFactory.Expect(cf => cf.CreateStructuresCalculator<StructuresClosureCalculationInput>(null))
+                             .IgnoreArguments()
                              .Return(calculator);
             mockRepository.ReplayAll();
 
@@ -736,8 +701,7 @@
                 // Call
                 new ClosingStructuresCalculationService().Calculate(calculation,
                                                                     failureMechanism.GeneralInput,
-                                                                    validFilePath,
-                                                                    validPreprocessorDirectory);
+                                                                    CreateCalculationSettings());
 
                 // Assert
                 StructuresClosureCalculationInput[] calculationInputs = calculator.ReceivedInputs.ToArray();
@@ -790,14 +754,8 @@
                                                                                                            mockRepository);
             var calculator = new TestStructuresCalculator<StructuresClosureCalculationInput>();
             var calculatorFactory = mockRepository.StrictMock<IHydraRingCalculatorFactory>();
-            calculatorFactory.Expect(cf => cf.CreateStructuresCalculator<StructuresClosureCalculationInput>(
-                                         Arg<HydraRingCalculationSettings>.Is.NotNull))
-                             .WhenCalled(invocation =>
-                             {
-                                 var settings = (HydraRingCalculationSettings) invocation.Arguments[0];
-                                 Assert.AreEqual(testDataPath, settings.HlcdFilePath);
-                                 Assert.AreEqual(validPreprocessorDirectory, settings.PreprocessorDirectory);
-                             })
+            calculatorFactory.Expect(cf => cf.CreateStructuresCalculator<StructuresClosureCalculationInput>(null))
+                             .IgnoreArguments()
                              .Return(calculator);
             mockRepository.ReplayAll();
 
@@ -822,8 +780,7 @@
                 // Call
                 new ClosingStructuresCalculationService().Calculate(calculation,
                                                                     failureMechanism.GeneralInput,
-                                                                    validFilePath,
-                                                                    validPreprocessorDirectory);
+                                                                    CreateCalculationSettings());
 
                 // Assert
                 StructuresClosureCalculationInput[] calculationInputs = calculator.ReceivedInputs.ToArray();
@@ -863,13 +820,17 @@
         }
 
         [Test]
-        [Combinatorial]
-        public void Calculate_PreprocessorDirectorySet_InputPropertiesCorrectlySentToCalculator([Values(true, false)] bool usePreprocessor)
+        [TestCase(true)]
+        [TestCase(false)]
+        public void Calculate_PreprocessorDirectorySet_InputPropertiesCorrectlySentToCalculator(bool usePreprocessor)
         {
             // Setup
             string preprocessorDirectory = usePreprocessor
                                                ? validPreprocessorDirectory
                                                : string.Empty;
+            var calculationSettings = new HydraulicBoundaryCalculationSettings(validHydraulicBoundaryDatabaseFilePath,
+                                                                               validHlcdFilePath,
+                                                                               preprocessorDirectory);
 
             var failureMechanism = new ClosingStructuresFailureMechanism();
 
@@ -882,9 +843,8 @@
                                          Arg<HydraRingCalculationSettings>.Is.NotNull))
                              .WhenCalled(invocation =>
                              {
-                                 var settings = (HydraRingCalculationSettings) invocation.Arguments[0];
-                                 Assert.AreEqual(testDataPath, settings.HlcdFilePath);
-                                 Assert.AreEqual(preprocessorDirectory, settings.PreprocessorDirectory);
+                                 HydraRingCalculationSettingsTestHelper.AssertHydraRingCalculationSettings(
+                                     calculationSettings, (HydraRingCalculationSettings) invocation.Arguments[0]);
                              })
                              .Return(calculator);
             mockRepository.ReplayAll();
@@ -902,8 +862,7 @@
                 // Call
                 new ClosingStructuresCalculationService().Calculate(calculation,
                                                                     failureMechanism.GeneralInput,
-                                                                    validFilePath,
-                                                                    preprocessorDirectory);
+                                                                    calculationSettings);
 
                 // Assert
                 StructuresClosureCalculationInput[] calculationInputs = calculator.ReceivedInputs.ToArray();
@@ -931,14 +890,8 @@
             IAssessmentSection assessmentSection = AssessmentSectionTestHelper.CreateAssessmentSectionStub(failureMechanism,
                                                                                                            mockRepository);
             var calculatorFactory = mockRepository.StrictMock<IHydraRingCalculatorFactory>();
-            calculatorFactory.Expect(cf => cf.CreateStructuresCalculator<StructuresClosureCalculationInput>(
-                                         Arg<HydraRingCalculationSettings>.Is.NotNull))
-                             .WhenCalled(invocation =>
-                             {
-                                 var settings = (HydraRingCalculationSettings) invocation.Arguments[0];
-                                 Assert.AreEqual(testDataPath, settings.HlcdFilePath);
-                                 Assert.AreEqual(validPreprocessorDirectory, settings.PreprocessorDirectory);
-                             })
+            calculatorFactory.Expect(cf => cf.CreateStructuresCalculator<StructuresClosureCalculationInput>(null))
+                             .IgnoreArguments()
                              .Return(new TestStructuresCalculator<StructuresClosureCalculationInput>());
             mockRepository.ReplayAll();
 
@@ -974,8 +927,7 @@
             {
                 Action call = () => new ClosingStructuresCalculationService().Calculate(calculation,
                                                                                         failureMechanism.GeneralInput,
-                                                                                        validFilePath,
-                                                                                        validPreprocessorDirectory);
+                                                                                        CreateCalculationSettings());
 
                 // Assert
                 TestHelper.AssertLogMessages(call, messages =>
@@ -1007,14 +959,8 @@
                 EndInFailure = true
             };
             var calculatorFactory = mockRepository.StrictMock<IHydraRingCalculatorFactory>();
-            calculatorFactory.Expect(cf => cf.CreateStructuresCalculator<StructuresClosureCalculationInput>(
-                                         Arg<HydraRingCalculationSettings>.Is.NotNull))
-                             .WhenCalled(invocation =>
-                             {
-                                 var settings = (HydraRingCalculationSettings) invocation.Arguments[0];
-                                 Assert.AreEqual(testDataPath, settings.HlcdFilePath);
-                                 Assert.AreEqual(validPreprocessorDirectory, settings.PreprocessorDirectory);
-                             })
+            calculatorFactory.Expect(cf => cf.CreateStructuresCalculator<StructuresClosureCalculationInput>(null))
+                             .IgnoreArguments()
                              .Return(calculator);
             mockRepository.ReplayAll();
 
@@ -1037,8 +983,7 @@
                     {
                         new ClosingStructuresCalculationService().Calculate(calculation,
                                                                             failureMechanism.GeneralInput,
-                                                                            validFilePath,
-                                                                            validPreprocessorDirectory);
+                                                                            CreateCalculationSettings());
                     }
                     catch (HydraRingCalculationException)
                     {
@@ -1077,14 +1022,8 @@
                 EndInFailure = true
             };
             var calculatorFactory = mockRepository.StrictMock<IHydraRingCalculatorFactory>();
-            calculatorFactory.Expect(cf => cf.CreateStructuresCalculator<StructuresClosureCalculationInput>(
-                                         Arg<HydraRingCalculationSettings>.Is.NotNull))
-                             .WhenCalled(invocation =>
-                             {
-                                 var settings = (HydraRingCalculationSettings) invocation.Arguments[0];
-                                 Assert.AreEqual(testDataPath, settings.HlcdFilePath);
-                                 Assert.AreEqual(validPreprocessorDirectory, settings.PreprocessorDirectory);
-                             })
+            calculatorFactory.Expect(cf => cf.CreateStructuresCalculator<StructuresClosureCalculationInput>(null))
+                             .IgnoreArguments()
                              .Return(calculator);
             mockRepository.ReplayAll();
 
@@ -1107,8 +1046,7 @@
                     {
                         new ClosingStructuresCalculationService().Calculate(calculation,
                                                                             failureMechanism.GeneralInput,
-                                                                            validFilePath,
-                                                                            validPreprocessorDirectory);
+                                                                            CreateCalculationSettings());
                     }
                     catch (HydraRingCalculationException)
                     {
@@ -1148,14 +1086,8 @@
                 LastErrorFileContent = "An error occurred"
             };
             var calculatorFactory = mockRepository.StrictMock<IHydraRingCalculatorFactory>();
-            calculatorFactory.Expect(cf => cf.CreateStructuresCalculator<StructuresClosureCalculationInput>(
-                                         Arg<HydraRingCalculationSettings>.Is.NotNull))
-                             .WhenCalled(invocation =>
-                             {
-                                 var settings = (HydraRingCalculationSettings) invocation.Arguments[0];
-                                 Assert.AreEqual(testDataPath, settings.HlcdFilePath);
-                                 Assert.AreEqual(validPreprocessorDirectory, settings.PreprocessorDirectory);
-                             })
+            calculatorFactory.Expect(cf => cf.CreateStructuresCalculator<StructuresClosureCalculationInput>(null))
+                             .IgnoreArguments()
                              .Return(calculator);
             mockRepository.ReplayAll();
 
@@ -1179,8 +1111,7 @@
                     {
                         new ClosingStructuresCalculationService().Calculate(calculation,
                                                                             failureMechanism.GeneralInput,
-                                                                            validFilePath,
-                                                                            validPreprocessorDirectory);
+                                                                            CreateCalculationSettings());
                     }
                     catch (HydraRingCalculationException e)
                     {
@@ -1207,6 +1138,13 @@
             mockRepository.VerifyAll();
         }
 
+        private static HydraulicBoundaryCalculationSettings CreateCalculationSettings()
+        {
+            return new HydraulicBoundaryCalculationSettings(validHydraulicBoundaryDatabaseFilePath,
+                                                            validHlcdFilePath,
+                                                            string.Empty);
+        }
+
         /// <summary>
         /// Sets all input parameters of <see cref="ClosingStructuresInput"/> to invalid values.
         /// </summary>