Index: Ringtoets/Common/src/Ringtoets.Common.Service/Structures/StructuresCalculationServiceBase.cs
===================================================================
diff -u -r72fbec29bf25dac587490ccccd1ed3a70e3da188 -r2f37bb8c74690c7f8b8fb2518deaa51f75983f14
--- Ringtoets/Common/src/Ringtoets.Common.Service/Structures/StructuresCalculationServiceBase.cs	(.../StructuresCalculationServiceBase.cs)	(revision 72fbec29bf25dac587490ccccd1ed3a70e3da188)
+++ Ringtoets/Common/src/Ringtoets.Common.Service/Structures/StructuresCalculationServiceBase.cs	(.../StructuresCalculationServiceBase.cs)	(revision 2f37bb8c74690c7f8b8fb2518deaa51f75983f14)
@@ -22,7 +22,6 @@
 using System;
 using System.Collections.Generic;
 using System.ComponentModel;
-using System.IO;
 using System.Linq;
 using Core.Common.Base.IO;
 using log4net;
@@ -122,27 +121,25 @@
         /// </summary>
         /// <param name="calculation">The <see cref="StructuresCalculation{T}"/> that holds all the information required to perform the calculation.</param>
         /// <param name="generalInput">The general inputs used in the calculations.</param>
-        /// <param name="hydraulicBoundaryDatabaseFilePath">The path which points to the hydraulic boundary database file.</param>
-        /// <param name="preprocessorDirectory">The preprocessor directory.</param>
-        /// <remarks>Preprocessing is disabled when <paramref name="preprocessorDirectory"/> equals <see cref="string.Empty"/>.</remarks>
-        /// <exception cref="ArgumentNullException">Thrown when <paramref name="calculation"/>, <paramref name="generalInput"/>,
-        /// <paramref name="hydraulicBoundaryDatabaseFilePath"/> or <paramref name="preprocessorDirectory"/> is <c>null</c>.</exception>
-        /// <exception cref="ArgumentException">Thrown when the <paramref name="hydraulicBoundaryDatabaseFilePath"/> 
+        /// <param name="calculationSettings">The <see cref="HydraulicBoundaryCalculationSettings"/> containing all data
+        /// to perform a hydraulic boundary calculation.</param>
+        /// <remarks>Preprocessing is disabled when the preprocessor directory equals <see cref="string.Empty"/>.</remarks>
+        /// <exception cref="ArgumentNullException">Thrown when any parameter is <c>null</c>.</exception>
+        /// <exception cref="ArgumentException">Thrown when the hydraulic boundary database file path
         /// contains invalid characters.</exception>
         /// <exception cref="InvalidEnumArgumentException">Thrown when an unexpected
         /// enum value is encountered.</exception>
         /// <exception cref="CriticalFileReadException">Thrown when:
         /// <list type="bullet">
-        /// <item>No settings database file could be found at the location of <paramref name="hydraulicBoundaryDatabaseFilePath"/>
+        /// <item>No settings database file could be found at the location of the hydraulic boundary database file path
         /// with the same name.</item>
         /// <item>Unable to open settings database file.</item>
         /// <item>Unable to read required data from database file.</item>
         /// </list></exception>
         /// <exception cref="HydraRingCalculationException">Thrown when an error occurs while performing the calculation.</exception>
         public void Calculate(StructuresCalculation<TStructureInput> calculation,
                               TGeneralInput generalInput,
-                              string hydraulicBoundaryDatabaseFilePath,
-                              string preprocessorDirectory)
+                              HydraulicBoundaryCalculationSettings calculationSettings)
         {
             if (calculation == null)
             {
@@ -154,11 +151,18 @@
                 throw new ArgumentNullException(nameof(generalInput));
             }
 
-            TCalculationInput input = CreateInput(calculation.InputParameters, generalInput, hydraulicBoundaryDatabaseFilePath, !string.IsNullOrEmpty(preprocessorDirectory));
+            if (calculationSettings == null)
+            {
+                throw new ArgumentNullException(nameof(calculationSettings));
+            }
 
-            string hlcdDirectory = Path.GetDirectoryName(hydraulicBoundaryDatabaseFilePath);
-            var settings = new HydraRingCalculationSettings(hlcdDirectory, preprocessorDirectory);
-            calculator = HydraRingCalculatorFactory.Instance.CreateStructuresCalculator<TCalculationInput>(settings);
+            TCalculationInput input = CreateInput(calculation.InputParameters,
+                                                  generalInput,
+                                                  calculationSettings.HydraulicBoundaryDatabaseFilePath,
+                                                  !string.IsNullOrEmpty(calculationSettings.PreprocessorDirectory));
+
+            calculator = HydraRingCalculatorFactory.Instance.CreateStructuresCalculator<TCalculationInput>(
+                HydraRingCalculationSettingsFactory.CreateSettings(calculationSettings));
             string calculationName = calculation.Name;
 
             CalculationServiceHelper.LogCalculationBegin();
Index: Ringtoets/Common/test/Ringtoets.Common.Service.Test/Structures/StructuresCalculationServiceBaseTest.cs
===================================================================
diff -u -r72fbec29bf25dac587490ccccd1ed3a70e3da188 -r2f37bb8c74690c7f8b8fb2518deaa51f75983f14
--- Ringtoets/Common/test/Ringtoets.Common.Service.Test/Structures/StructuresCalculationServiceBaseTest.cs	(.../StructuresCalculationServiceBaseTest.cs)	(revision 72fbec29bf25dac587490ccccd1ed3a70e3da188)
+++ Ringtoets/Common/test/Ringtoets.Common.Service.Test/Structures/StructuresCalculationServiceBaseTest.cs	(.../StructuresCalculationServiceBaseTest.cs)	(revision 2f37bb8c74690c7f8b8fb2518deaa51f75983f14)
@@ -28,6 +28,7 @@
 using Rhino.Mocks;
 using Ringtoets.Common.Data.AssessmentSection;
 using Ringtoets.Common.Data.Exceptions;
+using Ringtoets.Common.Data.Hydraulics;
 using Ringtoets.Common.Data.TestUtil;
 using Ringtoets.Common.Service.MessageProviders;
 using Ringtoets.Common.Service.Structures;
@@ -46,7 +47,8 @@
     public class StructuresCalculationServiceBaseTest
     {
         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]
@@ -130,7 +132,7 @@
             var mocks = new MockRepository();
 
             IAssessmentSection assessmentSection = AssessmentSectionTestHelper.CreateAssessmentSectionStub(
-                new TestFailureMechanism(), mocks, validFilePath);
+                new TestFailureMechanism(), mocks, validHydraulicBoundaryDatabaseFilePath);
 
             assessmentSection.HydraulicBoundaryDatabase.CanUsePreprocessor = true;
             assessmentSection.HydraulicBoundaryDatabase.UsePreprocessor = true;
@@ -226,7 +228,7 @@
             var mocks = new MockRepository();
             IAssessmentSection assessmentSection = AssessmentSectionTestHelper.CreateAssessmentSectionStub(new TestFailureMechanism(),
                                                                                                            mocks,
-                                                                                                           validFilePath);
+                                                                                                           validHydraulicBoundaryDatabaseFilePath);
             mocks.ReplayAll();
 
             var calculation = new TestStructuresCalculation
@@ -264,7 +266,7 @@
 
             var mocks = new MockRepository();
             IAssessmentSection assessmentSection = AssessmentSectionTestHelper.CreateAssessmentSectionStub(
-                failureMechanism, mocks, validFilePath);
+                failureMechanism, mocks, validHydraulicBoundaryDatabaseFilePath);
             mocks.ReplayAll();
 
             var calculation = new TestStructuresCalculation
@@ -302,7 +304,7 @@
 
             var mocks = new MockRepository();
             IAssessmentSection assessmentSection = AssessmentSectionTestHelper.CreateAssessmentSectionStub(
-                failureMechanism, mocks, validFilePath);
+                failureMechanism, mocks, validHydraulicBoundaryDatabaseFilePath);
             mocks.ReplayAll();
 
             var calculation = new TestStructuresCalculation
@@ -342,7 +344,7 @@
 
             var mocks = new MockRepository();
             IAssessmentSection assessmentSection = AssessmentSectionTestHelper.CreateAssessmentSectionStub(
-                failureMechanism, mocks, validFilePath);
+                failureMechanism, mocks, validHydraulicBoundaryDatabaseFilePath);
             mocks.ReplayAll();
 
             var calculation = new TestStructuresCalculation
@@ -380,7 +382,7 @@
             var mocks = new MockRepository();
 
             IAssessmentSection assessmentSection = AssessmentSectionTestHelper.CreateAssessmentSectionStub(
-                new TestFailureMechanism(), mocks, validFilePath);
+                new TestFailureMechanism(), mocks, validHydraulicBoundaryDatabaseFilePath);
 
             assessmentSection.HydraulicBoundaryDatabase.CanUsePreprocessor = true;
             assessmentSection.HydraulicBoundaryDatabase.UsePreprocessor = false;
@@ -423,7 +425,7 @@
             var mocks = new MockRepository();
 
             IAssessmentSection assessmentSection = AssessmentSectionTestHelper.CreateAssessmentSectionStub(
-                new TestFailureMechanism(), mocks, validFilePath);
+                new TestFailureMechanism(), mocks, validHydraulicBoundaryDatabaseFilePath);
 
             assessmentSection.HydraulicBoundaryDatabase.CanUsePreprocessor = true;
             assessmentSection.HydraulicBoundaryDatabase.UsePreprocessor = true;
@@ -469,7 +471,7 @@
 
             // Call
             TestDelegate test = () => new TestStructuresCalculationService(messageProvider)
-                .Calculate(null, new GeneralTestInput(), string.Empty, string.Empty);
+                .Calculate(null, new GeneralTestInput(), HydraulicBoundaryCalculationSettingsTestFactory.CreateSettings());
 
             // Assert
             var exception = Assert.Throws<ArgumentNullException>(test);
@@ -485,11 +487,9 @@
             var messageProvider = mocks.Stub<IStructuresCalculationMessageProvider>();
             mocks.ReplayAll();
 
-            var calculation = new TestStructuresCalculation();
-
             // Call
             TestDelegate test = () => new TestStructuresCalculationService(messageProvider)
-                .Calculate(calculation, null, string.Empty, string.Empty);
+                .Calculate(new TestStructuresCalculation(), null, HydraulicBoundaryCalculationSettingsTestFactory.CreateSettings());
 
             // Assert
             var exception = Assert.Throws<ArgumentNullException>(test);
@@ -498,38 +498,113 @@
         }
 
         [Test]
+        public void Calculate_CalculationSettingsNull_ThrowsArgumentNullException()
+        {
+            // Setup
+            var mocks = new MockRepository();
+            var messageProvider = mocks.Stub<IStructuresCalculationMessageProvider>();
+            mocks.ReplayAll();
+
+            // Call
+            TestDelegate call = () => new TestStructuresCalculationService(messageProvider)
+                .Calculate(new TestStructuresCalculation(), new GeneralTestInput(), null);
+
+            // Assert
+            var exception = Assert.Throws<ArgumentNullException>(call);
+            Assert.AreEqual("calculationSettings", exception.ParamName);
+            mocks.VerifyAll();
+        }
+
+        [Test]
         [TestCase(true)]
         [TestCase(false)]
-        public void Calculate_ValidInput_InputPropertiesCorrectlySentToCalculatorAndLogs(bool readIllustrationPoints)
+        public void Calculate_ValidInput_InputPropertiesCorrectlySentToCalculator(bool usePreprocessor)
         {
             // Setup
+            string preprocessorDirectory = usePreprocessor
+                                               ? validPreprocessorDirectory
+                                               : string.Empty;
+
+            var calculationSettings = new HydraulicBoundaryCalculationSettings(validHydraulicBoundaryDatabaseFilePath,
+                                                                               validHlcdFilePath,
+                                                                               preprocessorDirectory);
+
             var mocks = new MockRepository();
             var calculator = new TestStructuresCalculator<ExceedanceProbabilityCalculationInput>
             {
-                OutputDirectory = validFilePath,
-                IllustrationPointsResult = new TestGeneralResult()
+                OutputDirectory = validHydraulicBoundaryDatabaseFilePath
             };
             var calculatorFactory = mocks.StrictMock<IHydraRingCalculatorFactory>();
             calculatorFactory.Expect(cf => cf.CreateStructuresCalculator<ExceedanceProbabilityCalculationInput>(
                                          Arg<HydraRingCalculationSettings>.Is.NotNull))
                              .WhenCalled(invocation =>
                              {
-                                 var settings = (HydraRingCalculationSettings) invocation.Arguments[0];
-                                 Assert.AreEqual(testDataPath, settings.HlcdFilePath);
-                                 Assert.AreEqual(validPreprocessorDirectory, settings.PreprocessorDirectory);
+                                 HydraRingCalculationSettingsTestHelper.AssertHydraRingCalculationSettings(
+                                     calculationSettings, (HydraRingCalculationSettings) invocation.Arguments[0]);
                              })
                              .Return(calculator);
 
             const string performedCalculationMessage = "Calculation successful";
             var messageProvider = mocks.StrictMock<IStructuresCalculationMessageProvider>();
-            messageProvider.Expect(mp => mp.GetCalculationPerformedMessage(validFilePath)).Return(performedCalculationMessage);
+            messageProvider.Expect(mp => mp.GetCalculationPerformedMessage(validHydraulicBoundaryDatabaseFilePath)).Return(performedCalculationMessage);
             mocks.ReplayAll();
 
             var hydraulicBoundaryLocation = new TestHydraulicBoundaryLocation();
             var calculation = new TestStructuresCalculation
             {
                 InputParameters =
                 {
+                    HydraulicBoundaryLocation = hydraulicBoundaryLocation
+                }
+            };
+
+            using (new HydraRingCalculatorFactoryConfig(calculatorFactory))
+            {
+                var service = new TestStructuresCalculationService(messageProvider);
+
+                // Call
+                service.Calculate(calculation, new GeneralTestInput(), calculationSettings);
+
+                // Assert
+                ExceedanceProbabilityCalculationInput[] calculationInputs = calculator.ReceivedInputs.ToArray();
+                Assert.AreEqual(1, calculationInputs.Length);
+
+                var expectedInput = new TestExceedanceProbabilityCalculationInput(hydraulicBoundaryLocation.Id);
+                ExceedanceProbabilityCalculationInput actualInput = calculationInputs[0];
+                HydraRingDataEqualityHelper.AreEqual(expectedInput, actualInput);
+                Assert.IsFalse(calculator.IsCanceled);
+            }
+
+            mocks.VerifyAll();
+        }
+
+        [Test]
+        [TestCase(true)]
+        [TestCase(false)]
+        public void Calculate_ValidStructuresCalculation_SetsOutputAndLogs(bool readIllustrationPoints)
+        {
+            // Setup
+            var mocks = new MockRepository();
+            var calculator = new TestStructuresCalculator<ExceedanceProbabilityCalculationInput>
+            {
+                OutputDirectory = validHydraulicBoundaryDatabaseFilePath,
+                IllustrationPointsResult = new TestGeneralResult()
+            };
+            var calculatorFactory = mocks.StrictMock<IHydraRingCalculatorFactory>();
+            calculatorFactory.Expect(cf => cf.CreateStructuresCalculator<ExceedanceProbabilityCalculationInput>(null))
+                             .IgnoreArguments()
+                             .Return(calculator);
+
+            const string performedCalculationMessage = "Calculation successful";
+            var messageProvider = mocks.StrictMock<IStructuresCalculationMessageProvider>();
+            messageProvider.Expect(mp => mp.GetCalculationPerformedMessage(validHydraulicBoundaryDatabaseFilePath)).Return(performedCalculationMessage);
+            mocks.ReplayAll();
+
+            var hydraulicBoundaryLocation = new TestHydraulicBoundaryLocation();
+            var calculation = new TestStructuresCalculation
+            {
+                InputParameters =
+                {
                     HydraulicBoundaryLocation = hydraulicBoundaryLocation,
                     ShouldIllustrationPointsBeCalculated = readIllustrationPoints
                 }
@@ -540,7 +615,7 @@
                 var service = new TestStructuresCalculationService(messageProvider);
 
                 // Call
-                Action call = () => service.Calculate(calculation, new GeneralTestInput(), validFilePath, validPreprocessorDirectory);
+                Action call = () => service.Calculate(calculation, new GeneralTestInput(), CreateCalculationSettings());
 
                 // Assert
                 TestHelper.AssertLogMessages(call, messages =>
@@ -552,14 +627,9 @@
                     CalculationServiceTestHelper.AssertCalculationEndMessage(msgs[2]);
                 });
 
-                ExceedanceProbabilityCalculationInput[] calculationInputs = calculator.ReceivedInputs.ToArray();
-                Assert.AreEqual(1, calculationInputs.Length);
+                Assert.IsFalse(calculator.IsCanceled);
 
-                var expectedInput = new TestExceedanceProbabilityCalculationInput(hydraulicBoundaryLocation.Id);
-                ExceedanceProbabilityCalculationInput actualInput = calculationInputs[0];
-                HydraRingDataEqualityHelper.AreEqual(expectedInput, actualInput);
                 Assert.IsNotNull(calculation.Output);
-                Assert.IsFalse(calculator.IsCanceled);
                 Assert.AreEqual(readIllustrationPoints, calculation.Output.HasGeneralResult);
             }
 
@@ -574,23 +644,17 @@
             var mocks = new MockRepository();
             var calculator = new TestStructuresCalculator<ExceedanceProbabilityCalculationInput>
             {
-                OutputDirectory = validFilePath,
+                OutputDirectory = validHydraulicBoundaryDatabaseFilePath,
                 IllustrationPointsParserErrorMessage = parserMessage
             };
             var calculatorFactory = mocks.StrictMock<IHydraRingCalculatorFactory>();
-            calculatorFactory.Expect(cf => cf.CreateStructuresCalculator<ExceedanceProbabilityCalculationInput>(
-                                         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<ExceedanceProbabilityCalculationInput>(null))
+                             .IgnoreArguments()
                              .Return(calculator);
 
             const string performedCalculationMessage = "Calculation successful";
             var messageProvider = mocks.StrictMock<IStructuresCalculationMessageProvider>();
-            messageProvider.Expect(mp => mp.GetCalculationPerformedMessage(validFilePath)).Return(performedCalculationMessage);
+            messageProvider.Expect(mp => mp.GetCalculationPerformedMessage(validHydraulicBoundaryDatabaseFilePath)).Return(performedCalculationMessage);
             mocks.ReplayAll();
 
             var hydraulicBoundaryLocation = new TestHydraulicBoundaryLocation();
@@ -608,7 +672,7 @@
                 var service = new TestStructuresCalculationService(messageProvider);
 
                 // Call
-                Action call = () => service.Calculate(calculation, new GeneralTestInput(), validFilePath, validPreprocessorDirectory);
+                Action call = () => service.Calculate(calculation, new GeneralTestInput(), CreateCalculationSettings());
 
                 // Assert
                 TestHelper.AssertLogMessages(call, messages =>
@@ -635,23 +699,17 @@
             var mocks = new MockRepository();
             var calculator = new TestStructuresCalculator<ExceedanceProbabilityCalculationInput>
             {
-                OutputDirectory = validFilePath,
+                OutputDirectory = validHydraulicBoundaryDatabaseFilePath,
                 IllustrationPointsParserErrorMessage = "Parser error"
             };
             var calculatorFactory = mocks.StrictMock<IHydraRingCalculatorFactory>();
-            calculatorFactory.Expect(cf => cf.CreateStructuresCalculator<ExceedanceProbabilityCalculationInput>(
-                                         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<ExceedanceProbabilityCalculationInput>(null))
+                             .IgnoreArguments()
                              .Return(calculator);
 
             const string performedCalculationMessage = "Calculation successful";
             var messageProvider = mocks.StrictMock<IStructuresCalculationMessageProvider>();
-            messageProvider.Expect(mp => mp.GetCalculationPerformedMessage(validFilePath)).Return(performedCalculationMessage);
+            messageProvider.Expect(mp => mp.GetCalculationPerformedMessage(validHydraulicBoundaryDatabaseFilePath)).Return(performedCalculationMessage);
             mocks.ReplayAll();
 
             var hydraulicBoundaryLocation = new TestHydraulicBoundaryLocation();
@@ -669,7 +727,7 @@
                 var service = new TestStructuresCalculationService(messageProvider);
 
                 // Call
-                Action call = () => service.Calculate(calculation, new GeneralTestInput(), validFilePath, validPreprocessorDirectory);
+                Action call = () => service.Calculate(calculation, new GeneralTestInput(), CreateCalculationSettings());
 
                 // Assert
                 TestHelper.AssertLogMessages(call, messages =>
@@ -695,23 +753,17 @@
             var mocks = new MockRepository();
             var calculator = new TestStructuresCalculator<ExceedanceProbabilityCalculationInput>
             {
-                OutputDirectory = validFilePath,
+                OutputDirectory = validHydraulicBoundaryDatabaseFilePath,
                 IllustrationPointsResult = TestGeneralResult.CreateGeneralResultWithSubMechanismIllustrationPoints()
             };
             var calculatorFactory = mocks.StrictMock<IHydraRingCalculatorFactory>();
-            calculatorFactory.Expect(cf => cf.CreateStructuresCalculator<ExceedanceProbabilityCalculationInput>(
-                                         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<ExceedanceProbabilityCalculationInput>(null))
+                             .IgnoreArguments()
                              .Return(calculator);
 
             const string performedCalculationMessage = "Calculation successful";
             var messageProvider = mocks.StrictMock<IStructuresCalculationMessageProvider>();
-            messageProvider.Expect(mp => mp.GetCalculationPerformedMessage(validFilePath)).Return(performedCalculationMessage);
+            messageProvider.Expect(mp => mp.GetCalculationPerformedMessage(validHydraulicBoundaryDatabaseFilePath)).Return(performedCalculationMessage);
             mocks.ReplayAll();
 
             var hydraulicBoundaryLocation = new TestHydraulicBoundaryLocation();
@@ -729,7 +781,7 @@
                 var service = new TestStructuresCalculationService(messageProvider);
 
                 // Call
-                Action call = () => service.Calculate(calculation, new GeneralTestInput(), validFilePath, validPreprocessorDirectory);
+                Action call = () => service.Calculate(calculation, new GeneralTestInput(), CreateCalculationSettings());
 
                 // Assert
                 TestHelper.AssertLogMessagesWithLevelAndLoggedExceptions(call, messages =>
@@ -760,23 +812,17 @@
             var mocks = new MockRepository();
             var calculator = new TestStructuresCalculator<ExceedanceProbabilityCalculationInput>
             {
-                OutputDirectory = validFilePath,
+                OutputDirectory = validHydraulicBoundaryDatabaseFilePath,
                 IllustrationPointsResult = GeneralResultTestFactory.CreateGeneralResultWithDuplicateStochasts()
             };
             var calculatorFactory = mocks.StrictMock<IHydraRingCalculatorFactory>();
-            calculatorFactory.Expect(cf => cf.CreateStructuresCalculator<ExceedanceProbabilityCalculationInput>(
-                                         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<ExceedanceProbabilityCalculationInput>(null))
+                             .IgnoreArguments()
                              .Return(calculator);
 
             const string performedCalculationMessage = "Calculation successful";
             var messageProvider = mocks.StrictMock<IStructuresCalculationMessageProvider>();
-            messageProvider.Expect(mp => mp.GetCalculationPerformedMessage(validFilePath)).Return(performedCalculationMessage);
+            messageProvider.Expect(mp => mp.GetCalculationPerformedMessage(validHydraulicBoundaryDatabaseFilePath)).Return(performedCalculationMessage);
             mocks.ReplayAll();
 
             var hydraulicBoundaryLocation = new TestHydraulicBoundaryLocation();
@@ -794,7 +840,7 @@
                 var service = new TestStructuresCalculationService(messageProvider);
 
                 // Call
-                Action call = () => service.Calculate(calculation, new GeneralTestInput(), validFilePath, validPreprocessorDirectory);
+                Action call = () => service.Calculate(calculation, new GeneralTestInput(), CreateCalculationSettings());
 
                 // Assert
                 TestHelper.AssertLogMessagesWithLevelAndLoggedExceptions(call, messages =>
@@ -833,14 +879,8 @@
             var mocks = new MockRepository();
             var calculator = new TestStructuresCalculator<ExceedanceProbabilityCalculationInput>();
             var calculatorFactory = mocks.StrictMock<IHydraRingCalculatorFactory>();
-            calculatorFactory.Expect(cf => cf.CreateStructuresCalculator<ExceedanceProbabilityCalculationInput>(
-                                         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<ExceedanceProbabilityCalculationInput>(null))
+                             .IgnoreArguments()
                              .Return(calculator);
 
             var messageProvider = mocks.Stub<IStructuresCalculationMessageProvider>();
@@ -852,7 +892,7 @@
                 calculator.CalculationFinishedHandler += (s, e) => service.Cancel();
 
                 // Call
-                service.Calculate(calculation, new GeneralTestInput(), validFilePath, validPreprocessorDirectory);
+                service.Calculate(calculation, new GeneralTestInput(), CreateCalculationSettings());
 
                 // Assert
                 Assert.IsNull(calculation.Output);
@@ -888,14 +928,8 @@
                 LastErrorFileContent = lastErrorFileContent
             };
             var calculatorFactory = mocks.StrictMock<IHydraRingCalculatorFactory>();
-            calculatorFactory.Expect(cf => cf.CreateStructuresCalculator<ExceedanceProbabilityCalculationInput>(
-                                         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<ExceedanceProbabilityCalculationInput>(null))
+                             .IgnoreArguments()
                              .Return(calculator);
 
             const string calculationFailedMessage = "Calculation failed";
@@ -928,7 +962,7 @@
                 {
                     try
                     {
-                        structuresCalculationService.Calculate(calculation, new GeneralTestInput(), validFilePath, validPreprocessorDirectory);
+                        structuresCalculationService.Calculate(calculation, new GeneralTestInput(), CreateCalculationSettings());
                     }
                     catch (HydraRingCalculationException)
                     {
@@ -953,6 +987,13 @@
             mocks.VerifyAll();
         }
 
+        private static HydraulicBoundaryCalculationSettings CreateCalculationSettings()
+        {
+            return new HydraulicBoundaryCalculationSettings(validHydraulicBoundaryDatabaseFilePath,
+                                                            validHlcdFilePath,
+                                                            string.Empty);
+        }
+
         private class TestStructuresCalculationService : StructuresCalculationServiceBase<TestStructureValidationRulesRegistry,
             TestStructuresInput, TestStructure, GeneralTestInput, ExceedanceProbabilityCalculationInput>
         {