Index: Ringtoets/DuneErosion/test/Ringtoets.DuneErosion.Service.Test/DuneLocationCalculationActivityFactoryTest.cs
===================================================================
diff -u -rd97f06dcf08df485826a196e31c05e811ab6dc67 -r74255ec7a1b441b33fd667d2fe0612eb333ed327
--- Ringtoets/DuneErosion/test/Ringtoets.DuneErosion.Service.Test/DuneLocationCalculationActivityFactoryTest.cs	(.../DuneLocationCalculationActivityFactoryTest.cs)	(revision d97f06dcf08df485826a196e31c05e811ab6dc67)
+++ Ringtoets/DuneErosion/test/Ringtoets.DuneErosion.Service.Test/DuneLocationCalculationActivityFactoryTest.cs	(.../DuneLocationCalculationActivityFactoryTest.cs)	(revision 74255ec7a1b441b33fd667d2fe0612eb333ed327)
@@ -30,8 +30,10 @@
 using Rhino.Mocks;
 using Ringtoets.Common.Data.AssessmentSection;
 using Ringtoets.Common.Data.FailureMechanism;
+using Ringtoets.Common.Data.Hydraulics;
 using Ringtoets.Common.Data.TestUtil;
 using Ringtoets.Common.Service;
+using Ringtoets.Common.Service.TestUtil;
 using Ringtoets.DuneErosion.Data;
 using Ringtoets.HydraRing.Calculation.Calculator.Factory;
 using Ringtoets.HydraRing.Calculation.Data.Input;
@@ -110,8 +112,9 @@
             CollectionAssert.AllItemsAreInstancesOfType(activities, typeof(DuneLocationCalculationActivity));
             Assert.AreEqual(2, activities.Length);
 
-            AssertDuneLocationCalculationActivity(activities[0], categoryBoundaryName, duneLocation1.Name, duneLocation1.Id, norm, usePreprocessor);
-            AssertDuneLocationCalculationActivity(activities[1], categoryBoundaryName, duneLocation2.Name, duneLocation2.Id, norm, usePreprocessor);
+            HydraulicBoundaryDatabase hydraulicBoundaryDatabase = assessmentSection.HydraulicBoundaryDatabase;
+            AssertDuneLocationCalculationActivity(activities[0], categoryBoundaryName, duneLocation1.Name, duneLocation1.Id, norm, hydraulicBoundaryDatabase);
+            AssertDuneLocationCalculationActivity(activities[1], categoryBoundaryName, duneLocation2.Name, duneLocation2.Id, norm, hydraulicBoundaryDatabase);
         }
 
         [Test]
@@ -172,75 +175,76 @@
             // Assert
             Assert.AreEqual(10, activities.Length);
 
+            HydraulicBoundaryDatabase hydraulicBoundaryDatabase = assessmentSection.HydraulicBoundaryDatabase;
             double mechanismSpecificFactorizedSignalingNorm = failureMechanism.GetNorm(assessmentSection, FailureMechanismCategoryType.MechanismSpecificFactorizedSignalingNorm);
             AssertDuneLocationCalculationActivity(activities[0],
                                                   "Iv",
                                                   duneLocation1.Name,
                                                   duneLocation1.Id,
                                                   mechanismSpecificFactorizedSignalingNorm,
-                                                  usePreprocessor);
+                                                  hydraulicBoundaryDatabase);
             AssertDuneLocationCalculationActivity(activities[1],
                                                   "Iv",
                                                   duneLocation2.Name,
                                                   duneLocation2.Id,
                                                   mechanismSpecificFactorizedSignalingNorm,
-                                                  usePreprocessor);
+                                                  hydraulicBoundaryDatabase);
 
             double mechanismSpecificSignalingNorm = failureMechanism.GetNorm(assessmentSection, FailureMechanismCategoryType.MechanismSpecificSignalingNorm);
             AssertDuneLocationCalculationActivity(activities[2],
                                                   "IIv",
                                                   duneLocation1.Name,
                                                   duneLocation1.Id,
                                                   mechanismSpecificSignalingNorm,
-                                                  usePreprocessor);
+                                                  hydraulicBoundaryDatabase);
             AssertDuneLocationCalculationActivity(activities[3],
                                                   "IIv",
                                                   duneLocation2.Name,
                                                   duneLocation2.Id,
                                                   mechanismSpecificSignalingNorm,
-                                                  usePreprocessor);
+                                                  hydraulicBoundaryDatabase);
 
             double mechanismSpecificLowerLimitNorm = failureMechanism.GetNorm(assessmentSection, FailureMechanismCategoryType.MechanismSpecificLowerLimitNorm);
             AssertDuneLocationCalculationActivity(activities[4],
                                                   "IIIv",
                                                   duneLocation1.Name,
                                                   duneLocation1.Id,
                                                   mechanismSpecificLowerLimitNorm,
-                                                  usePreprocessor);
+                                                  hydraulicBoundaryDatabase);
             AssertDuneLocationCalculationActivity(activities[5],
                                                   "IIIv",
                                                   duneLocation2.Name,
                                                   duneLocation2.Id,
                                                   mechanismSpecificLowerLimitNorm,
-                                                  usePreprocessor);
+                                                  hydraulicBoundaryDatabase);
 
             double lowerLimitNorm = failureMechanism.GetNorm(assessmentSection, FailureMechanismCategoryType.LowerLimitNorm);
             AssertDuneLocationCalculationActivity(activities[6],
                                                   "IVv",
                                                   duneLocation1.Name,
                                                   duneLocation1.Id,
                                                   lowerLimitNorm,
-                                                  usePreprocessor);
+                                                  hydraulicBoundaryDatabase);
             AssertDuneLocationCalculationActivity(activities[7],
                                                   "IVv",
                                                   duneLocation2.Name,
                                                   duneLocation2.Id,
                                                   lowerLimitNorm,
-                                                  usePreprocessor);
+                                                  hydraulicBoundaryDatabase);
 
             double factorizedLowerLimitNorm = failureMechanism.GetNorm(assessmentSection, FailureMechanismCategoryType.FactorizedLowerLimitNorm);
             AssertDuneLocationCalculationActivity(activities[8],
                                                   "Vv",
                                                   duneLocation1.Name,
                                                   duneLocation1.Id,
                                                   factorizedLowerLimitNorm,
-                                                  usePreprocessor);
+                                                  hydraulicBoundaryDatabase);
             AssertDuneLocationCalculationActivity(activities[9],
                                                   "Vv",
                                                   duneLocation2.Name,
                                                   duneLocation2.Id,
                                                   factorizedLowerLimitNorm,
-                                                  usePreprocessor);
+                                                  hydraulicBoundaryDatabase);
         }
 
         private static AssessmentSectionStub CreateAssessmentSection(bool usePreprocessor)
@@ -260,20 +264,20 @@
                                                                   string locationName,
                                                                   long locationId,
                                                                   double norm,
-                                                                  bool usePreprocessor)
+                                                                  HydraulicBoundaryDatabase hydraulicBoundaryDatabase)
         {
             var calculator = new TestDunesBoundaryConditionsCalculator();
 
             var mocks = new MockRepository();
             var calculatorFactory = mocks.StrictMock<IHydraRingCalculatorFactory>();
 
-            string expectedPreprocessorDirectory = usePreprocessor ? validPreprocessorDirectory : string.Empty;
+            HydraulicBoundaryCalculationSettings expectedCalculationSettings = HydraulicBoundaryCalculationSettingsFactory.CreateSettings(hydraulicBoundaryDatabase);
             calculatorFactory.Expect(cf => cf.CreateDunesBoundaryConditionsCalculator(Arg<HydraRingCalculationSettings>.Is.NotNull))
                              .WhenCalled(invocation =>
                              {
-                                 var settings = (HydraRingCalculationSettings)invocation.Arguments[0];
-                                 Assert.AreEqual(validFilePath, settings.HlcdFilePath);
-                                 Assert.AreEqual(expectedPreprocessorDirectory, settings.PreprocessorDirectory);
+                                 var hydraRingCalculationSettings = (HydraRingCalculationSettings) invocation.Arguments[0];
+                                 HydraRingCalculationSettingsTestHelper.AssertHydraRingCalculationSettings(expectedCalculationSettings,
+                                                                                                           hydraRingCalculationSettings);
                              })
                              .Return(calculator);
             mocks.ReplayAll();