Index: Ringtoets/DuneErosion/test/Ringtoets.DuneErosion.Service.Test/DuneLocationCalculationActivityTest.cs
===================================================================
diff -u -rd97f06dcf08df485826a196e31c05e811ab6dc67 -r74255ec7a1b441b33fd667d2fe0612eb333ed327
--- Ringtoets/DuneErosion/test/Ringtoets.DuneErosion.Service.Test/DuneLocationCalculationActivityTest.cs	(.../DuneLocationCalculationActivityTest.cs)	(revision d97f06dcf08df485826a196e31c05e811ab6dc67)
+++ Ringtoets/DuneErosion/test/Ringtoets.DuneErosion.Service.Test/DuneLocationCalculationActivityTest.cs	(.../DuneLocationCalculationActivityTest.cs)	(revision 74255ec7a1b441b33fd667d2fe0612eb333ed327)
@@ -48,7 +48,8 @@
 
         private MockRepository mockRepository;
         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();
 
         [SetUp]
@@ -66,8 +67,7 @@
 
             // Call
             var activity = new DuneLocationCalculationActivity(new DuneLocationCalculation(new TestDuneLocation(locationName)),
-                                                               validFilePath,
-                                                               validPreprocessorDirectory,
+                                                               CreateCalculationSettings(),
                                                                1.0 / 30000,
                                                                categoryBoundaryName);
 
@@ -87,9 +87,11 @@
             const string categoryBoundaryName = "A";
             const string locationName = "locationName";
 
+            var settings = new HydraulicBoundaryCalculationSettings(invalidFilePath,
+                                                                    validHlcdFilePath,
+                                                                    string.Empty);
             var activity = new DuneLocationCalculationActivity(new DuneLocationCalculation(new TestDuneLocation(locationName)),
-                                                               invalidFilePath,
-                                                               validPreprocessorDirectory,
+                                                               settings,
                                                                0.5,
                                                                categoryBoundaryName);
 
@@ -113,13 +115,14 @@
         public void Run_InvalidPreprocessorDirectory_PerformValidationAndLogStartAndEndAndError()
         {
             // Setup
-            const string invalidPreprocessorDirectory = "NonExistingPreprocessorDirectory";
             const string categoryBoundaryName = "A";
             const string locationName = "locationName";
 
+            var settings = new HydraulicBoundaryCalculationSettings(validHydraulicBoundaryDatabaseFilePath,
+                                                                    validHlcdFilePath,
+                                                                    "NonExistingPreprocessorDirectory");
             var activity = new DuneLocationCalculationActivity(new DuneLocationCalculation(new TestDuneLocation(locationName)),
-                                                               validFilePath,
-                                                               invalidPreprocessorDirectory,
+                                                               settings,
                                                                0.5,
                                                                categoryBoundaryName);
 
@@ -147,8 +150,7 @@
             const string locationName = "locationName";
 
             var activity = new DuneLocationCalculationActivity(new DuneLocationCalculation(new TestDuneLocation(locationName)),
-                                                               validFilePath,
-                                                               validPreprocessorDirectory,
+                                                               CreateCalculationSettings(),
                                                                1.0,
                                                                categoryBoundaryName);
 
@@ -169,7 +171,9 @@
         }
 
         [Test]
-        public void Run_ValidInput_PerformValidationAndCalculationAndLogStartAndEnd()
+        [TestCase(true)]
+        [TestCase(false)]
+        public void Run_VariousValidInputs_PerformsCalculationWithCorrectInput(bool usePreprocessor)
         {
             // Setup
             const double norm = 1.0 / 30;
@@ -181,28 +185,74 @@
                 Converged = true
             };
 
+            string preprocessoryDirectory = usePreprocessor ? validPreprocessorDirectory : string.Empty;
+            var calculationSettings = new HydraulicBoundaryCalculationSettings(validHydraulicBoundaryDatabaseFilePath,
+                                                                               validHlcdFilePath,
+                                                                               preprocessoryDirectory);
+
             var calculatorFactory = mockRepository.StrictMock<IHydraRingCalculatorFactory>();
             calculatorFactory.Expect(cf => cf.CreateDunesBoundaryConditionsCalculator(Arg<HydraRingCalculationSettings>.Is.NotNull))
                              .WhenCalled(invocation =>
                              {
-                                 var settings = (HydraRingCalculationSettings) invocation.Arguments[0];
-                                 Assert.AreEqual(validFilePath, settings.HlcdFilePath);
-                                 Assert.AreEqual(validPreprocessorDirectory, settings.PreprocessorDirectory);
+                                 var hydraRingCalculationSettings = (HydraRingCalculationSettings) invocation.Arguments[0];
+                                 HydraRingCalculationSettingsTestHelper.AssertHydraRingCalculationSettings(calculationSettings,
+                                                                                                           hydraRingCalculationSettings);
                              })
                              .Return(calculator);
             mockRepository.ReplayAll();
 
             var duneLocation = new TestDuneLocation(locationName);
 
             var activity = new DuneLocationCalculationActivity(new DuneLocationCalculation(duneLocation),
-                                                               validFilePath,
-                                                               validPreprocessorDirectory,
+                                                               calculationSettings,
                                                                norm,
                                                                categoryBoundaryName);
 
             using (new HydraRingCalculatorFactoryConfig(calculatorFactory))
             {
                 // Call
+                activity.Run();
+
+                // Assert
+                DunesBoundaryConditionsCalculationInput calculationInput = calculator.ReceivedInputs.Single();
+                Assert.AreEqual(duneLocation.Id, calculationInput.HydraulicBoundaryLocationId);
+                Assert.AreEqual(StatisticsConverter.ProbabilityToReliability(norm), calculationInput.Beta);
+            }
+
+            mockRepository.VerifyAll();
+        }
+
+        [Test]
+        public void Run_ValidInput_PerformValidationAndCalculationAndLogStartAndEnd()
+        {
+            // Setup
+            const double norm = 1.0 / 30;
+            const string categoryBoundaryName = "A";
+            const string locationName = "locationName";
+
+            var calculator = new TestDunesBoundaryConditionsCalculator
+            {
+                Converged = true
+            };
+
+            HydraulicBoundaryCalculationSettings calculationSettings = CreateCalculationSettings();
+
+            var calculatorFactory = mockRepository.StrictMock<IHydraRingCalculatorFactory>();
+            calculatorFactory.Expect(cf => cf.CreateDunesBoundaryConditionsCalculator(null))
+                             .IgnoreArguments()
+                             .Return(calculator);
+            mockRepository.ReplayAll();
+
+            var duneLocation = new TestDuneLocation(locationName);
+
+            var activity = new DuneLocationCalculationActivity(new DuneLocationCalculation(duneLocation),
+                                                               calculationSettings,
+                                                               norm,
+                                                               categoryBoundaryName);
+
+            using (new HydraRingCalculatorFactoryConfig(calculatorFactory))
+            {
+                // Call
                 Action call = () => activity.Run();
 
                 // Assert
@@ -217,11 +267,6 @@
                     StringAssert.StartsWith("Hydraulische belastingenberekening is uitgevoerd op de tijdelijke locatie", messages[4]);
                     CalculationServiceTestHelper.AssertCalculationEndMessage(messages[5]);
                 });
-
-                DunesBoundaryConditionsCalculationInput calculationInput = calculator.ReceivedInputs.Single();
-
-                Assert.AreEqual(duneLocation.Id, calculationInput.HydraulicBoundaryLocationId);
-                Assert.AreEqual(StatisticsConverter.ProbabilityToReliability(norm), calculationInput.Beta);
             }
 
             Assert.AreEqual(ActivityState.Executed, activity.State);
@@ -249,19 +294,13 @@
             };
 
             var calculatorFactory = mockRepository.StrictMock<IHydraRingCalculatorFactory>();
-            calculatorFactory.Expect(cf => cf.CreateDunesBoundaryConditionsCalculator(Arg<HydraRingCalculationSettings>.Is.NotNull))
-                             .WhenCalled(invocation =>
-                             {
-                                 var settings = (HydraRingCalculationSettings) invocation.Arguments[0];
-                                 Assert.AreEqual(validFilePath, settings.HlcdFilePath);
-                                 Assert.AreEqual(validPreprocessorDirectory, settings.PreprocessorDirectory);
-                             })
+            calculatorFactory.Expect(cf => cf.CreateDunesBoundaryConditionsCalculator(null))
+                             .IgnoreArguments()
                              .Return(calculator);
             mockRepository.ReplayAll();
 
             var activity = new DuneLocationCalculationActivity(duneLocationCalculation,
-                                                               validFilePath,
-                                                               validPreprocessorDirectory,
+                                                               CreateCalculationSettings(),
                                                                validNorm,
                                                                "A");
 
@@ -300,19 +339,13 @@
             };
 
             var calculatorFactory = mockRepository.StrictMock<IHydraRingCalculatorFactory>();
-            calculatorFactory.Expect(cf => cf.CreateDunesBoundaryConditionsCalculator(Arg<HydraRingCalculationSettings>.Is.NotNull))
-                             .WhenCalled(invocation =>
-                             {
-                                 var settings = (HydraRingCalculationSettings) invocation.Arguments[0];
-                                 Assert.AreEqual(validFilePath, settings.HlcdFilePath);
-                                 Assert.AreEqual(validPreprocessorDirectory, settings.PreprocessorDirectory);
-                             })
+            calculatorFactory.Expect(cf => cf.CreateDunesBoundaryConditionsCalculator(null))
+                             .IgnoreArguments()
                              .Return(calculator);
             mockRepository.ReplayAll();
 
             var activity = new DuneLocationCalculationActivity(new DuneLocationCalculation(new TestDuneLocation(locationName)),
-                                                               validFilePath,
-                                                               validPreprocessorDirectory,
+                                                               CreateCalculationSettings(),
                                                                0.5,
                                                                categoryBoundaryName);
 
@@ -345,21 +378,15 @@
             };
 
             var calculatorFactory = mockRepository.StrictMock<IHydraRingCalculatorFactory>();
-            calculatorFactory.Expect(cf => cf.CreateDunesBoundaryConditionsCalculator(Arg<HydraRingCalculationSettings>.Is.NotNull))
-                             .WhenCalled(invocation =>
-                             {
-                                 var settings = (HydraRingCalculationSettings) invocation.Arguments[0];
-                                 Assert.AreEqual(validFilePath, settings.HlcdFilePath);
-                                 Assert.AreEqual(validPreprocessorDirectory, settings.PreprocessorDirectory);
-                             })
+            calculatorFactory.Expect(cf => cf.CreateDunesBoundaryConditionsCalculator(null))
+                             .IgnoreArguments()
                              .Return(calculator);
             mockRepository.ReplayAll();
 
             var duneLocationCalculation = new DuneLocationCalculation(new TestDuneLocation(locationName));
 
             var activity = new DuneLocationCalculationActivity(duneLocationCalculation,
-                                                               validFilePath,
-                                                               validPreprocessorDirectory,
+                                                               CreateCalculationSettings(),
                                                                0.5,
                                                                categoryBoundaryName);
 
@@ -397,19 +424,13 @@
             };
 
             var calculatorFactory = mockRepository.StrictMock<IHydraRingCalculatorFactory>();
-            calculatorFactory.Expect(cf => cf.CreateDunesBoundaryConditionsCalculator(Arg<HydraRingCalculationSettings>.Is.NotNull))
-                             .WhenCalled(invocation =>
-                             {
-                                 var settings = (HydraRingCalculationSettings) invocation.Arguments[0];
-                                 Assert.AreEqual(validFilePath, settings.HlcdFilePath);
-                                 Assert.AreEqual(validPreprocessorDirectory, settings.PreprocessorDirectory);
-                             })
+            calculatorFactory.Expect(cf => cf.CreateDunesBoundaryConditionsCalculator(null))
+                             .IgnoreArguments()
                              .Return(calculator);
             mockRepository.ReplayAll();
 
             var activity = new DuneLocationCalculationActivity(new DuneLocationCalculation(new TestDuneLocation(locationName)),
-                                                               validFilePath,
-                                                               validPreprocessorDirectory,
+                                                               CreateCalculationSettings(),
                                                                0.5,
                                                                "A");
 
@@ -441,8 +462,7 @@
             mockRepository.ReplayAll();
 
             var activity = new DuneLocationCalculationActivityWithState(duneLocationCalculation,
-                                                                        validFilePath,
-                                                                        validPreprocessorDirectory,
+                                                                        CreateCalculationSettings(),
                                                                         1.0,
                                                                         "A",
                                                                         state);
@@ -454,17 +474,21 @@
             mockRepository.VerifyAll();
         }
 
+        private static HydraulicBoundaryCalculationSettings CreateCalculationSettings()
+        {
+            return new HydraulicBoundaryCalculationSettings(validHydraulicBoundaryDatabaseFilePath,
+                                                            validHlcdFilePath,
+                                                            string.Empty);
+        }
+
         private class DuneLocationCalculationActivityWithState : DuneLocationCalculationActivity
         {
             public DuneLocationCalculationActivityWithState(DuneLocationCalculation duneLocationCalculation,
-                                                            string hydraulicBoundaryDatabaseFilePath,
-                                                            string preprocessorDirectory,
+                                                            HydraulicBoundaryCalculationSettings calculationSettings,
                                                             double norm,
                                                             string categoryBoundaryName,
                                                             ActivityState state)
-                : base(duneLocationCalculation,
-                       hydraulicBoundaryDatabaseFilePath,
-                       preprocessorDirectory,
+                : base(duneLocationCalculation, calculationSettings,
                        norm,
                        categoryBoundaryName)
             {