Index: Ringtoets/DuneErosion/test/Ringtoets.DuneErosion.Forms.Test/GuiServices/DuneLocationCalculationGuiServiceTest.cs
===================================================================
diff -u -r330f2e86f2fb575c436cdbb46b6d31bc246ef6fc -r12d03593998d6ac93c231ef947f00ff87c71e100
--- Ringtoets/DuneErosion/test/Ringtoets.DuneErosion.Forms.Test/GuiServices/DuneLocationCalculationGuiServiceTest.cs	(.../DuneLocationCalculationGuiServiceTest.cs)	(revision 330f2e86f2fb575c436cdbb46b6d31bc246ef6fc)
+++ Ringtoets/DuneErosion/test/Ringtoets.DuneErosion.Forms.Test/GuiServices/DuneLocationCalculationGuiServiceTest.cs	(.../DuneLocationCalculationGuiServiceTest.cs)	(revision 12d03593998d6ac93c231ef947f00ff87c71e100)
@@ -27,8 +27,10 @@
 using Core.Common.Base.Geometry;
 using Core.Common.TestUtil;
 using NUnit.Framework;
+using Rhino.Mocks;
 using Ringtoets.DuneErosion.Data;
 using Ringtoets.DuneErosion.Forms.GuiServices;
+using Ringtoets.HydraRing.Calculation.Calculator.Factory;
 using Ringtoets.HydraRing.Calculation.TestUtil.Calculator;
 
 namespace Ringtoets.DuneErosion.Forms.Test.GuiServices
@@ -120,8 +122,17 @@
                     })
                 });
 
+            var mockRepository = new MockRepository();
+            int calculators = failureMechanism.DuneLocations.Count;
+            var calculatorFactory = mockRepository.StrictMock<IHydraRingCalculatorFactory>();
+            calculatorFactory.Expect(cf => cf.CreateDunesBoundaryConditionsCalculator(testDataPath))
+                             .Return(new TestDunesBoundaryConditionsCalculator())
+                             .Repeat
+                             .Times(calculators);
+            mockRepository.ReplayAll();
+
             using (var viewParent = new Form())
-            using (new HydraRingCalculatorFactoryConfig())
+            using (new HydraRingCalculatorFactoryConfig(calculatorFactory))
             {
                 var guiService = new DuneLocationCalculationGuiService(viewParent);
 
@@ -148,6 +159,8 @@
                                                  Assert.AreEqual("Uitvoeren van 'B' is gelukt.", messageList[9]);
                                              });
             }
+
+            mockRepository.VerifyAll();
         }
     }
 }
\ No newline at end of file
Index: Ringtoets/DuneErosion/test/Ringtoets.DuneErosion.Forms.Test/Ringtoets.DuneErosion.Forms.Test.csproj
===================================================================
diff -u -rf1f94637a6b45b394493bf16a078b317c02d329b -r12d03593998d6ac93c231ef947f00ff87c71e100
--- Ringtoets/DuneErosion/test/Ringtoets.DuneErosion.Forms.Test/Ringtoets.DuneErosion.Forms.Test.csproj	(.../Ringtoets.DuneErosion.Forms.Test.csproj)	(revision f1f94637a6b45b394493bf16a078b317c02d329b)
+++ Ringtoets/DuneErosion/test/Ringtoets.DuneErosion.Forms.Test/Ringtoets.DuneErosion.Forms.Test.csproj	(.../Ringtoets.DuneErosion.Forms.Test.csproj)	(revision 12d03593998d6ac93c231ef947f00ff87c71e100)
@@ -124,6 +124,10 @@
       <Project>{D24FA2F7-28A7-413B-AFD3-EE10E985630B}</Project>
       <Name>Ringtoets.Common.Forms.TestUtil</Name>
     </ProjectReference>
+    <ProjectReference Include="..\..\..\HydraRing\src\Ringtoets.HydraRing.Calculation\Ringtoets.HydraRing.Calculation.csproj">
+      <Project>{888D4097-8BC2-4703-9FB1-8744C94D525E}</Project>
+      <Name>Ringtoets.HydraRing.Calculation</Name>
+    </ProjectReference>
     <ProjectReference Include="..\..\..\HydraRing\test\Ringtoets.HydraRing.Calculation.TestUtil\Ringtoets.HydraRing.Calculation.TestUtil.csproj">
       <Project>{74CBA865-9338-447F-BAD9-28312446AE84}</Project>
       <Name>Ringtoets.HydraRing.Calculation.TestUtil</Name>
Index: Ringtoets/DuneErosion/test/Ringtoets.DuneErosion.Forms.Test/Views/DuneLocationsViewTest.cs
===================================================================
diff -u -r330f2e86f2fb575c436cdbb46b6d31bc246ef6fc -r12d03593998d6ac93c231ef947f00ff87c71e100
--- Ringtoets/DuneErosion/test/Ringtoets.DuneErosion.Forms.Test/Views/DuneLocationsViewTest.cs	(.../DuneLocationsViewTest.cs)	(revision 330f2e86f2fb575c436cdbb46b6d31bc246ef6fc)
+++ Ringtoets/DuneErosion/test/Ringtoets.DuneErosion.Forms.Test/Views/DuneLocationsViewTest.cs	(.../DuneLocationsViewTest.cs)	(revision 12d03593998d6ac93c231ef947f00ff87c71e100)
@@ -41,6 +41,7 @@
 using Ringtoets.DuneErosion.Forms.GuiServices;
 using Ringtoets.DuneErosion.Forms.PresentationObjects;
 using Ringtoets.DuneErosion.Forms.Views;
+using Ringtoets.HydraRing.Calculation.Calculator.Factory;
 using Ringtoets.HydraRing.Calculation.TestUtil.Calculator;
 
 namespace Ringtoets.DuneErosion.Forms.Test.Views
@@ -364,6 +365,10 @@
             };
             assessmentSection.Stub(a => a.Attach(null)).IgnoreArguments();
             assessmentSection.Stub(a => a.Detach(null)).IgnoreArguments();
+
+            var calculatorFactory = mocks.StrictMock<IHydraRingCalculatorFactory>();
+            calculatorFactory.Expect(cf => cf.CreateDunesBoundaryConditionsCalculator(testDataPath))
+                             .Return(new TestDunesBoundaryConditionsCalculator());
             mocks.ReplayAll();
 
             locations.Attach(observer);
@@ -376,7 +381,7 @@
             var buttonTester = new ButtonTester("CalculateForSelectedButton", testForm);
 
             using (var viewParent = new Form())
-            using (new HydraRingCalculatorFactoryConfig())
+            using (new HydraRingCalculatorFactoryConfig(calculatorFactory))
             {
                 view.CalculationGuiService = new DuneLocationCalculationGuiService(viewParent);
 
Index: Ringtoets/DuneErosion/test/Ringtoets.DuneErosion.Integration.Test/DuneErosionBoundaryCalculationActivityIntegrationTest.cs
===================================================================
diff -u -r330f2e86f2fb575c436cdbb46b6d31bc246ef6fc -r12d03593998d6ac93c231ef947f00ff87c71e100
--- Ringtoets/DuneErosion/test/Ringtoets.DuneErosion.Integration.Test/DuneErosionBoundaryCalculationActivityIntegrationTest.cs	(.../DuneErosionBoundaryCalculationActivityIntegrationTest.cs)	(revision 330f2e86f2fb575c436cdbb46b6d31bc246ef6fc)
+++ Ringtoets/DuneErosion/test/Ringtoets.DuneErosion.Integration.Test/DuneErosionBoundaryCalculationActivityIntegrationTest.cs	(.../DuneErosionBoundaryCalculationActivityIntegrationTest.cs)	(revision 12d03593998d6ac93c231ef947f00ff87c71e100)
@@ -26,6 +26,7 @@
 using Core.Common.Base.Service;
 using Core.Common.TestUtil;
 using NUnit.Framework;
+using Rhino.Mocks;
 using Ringtoets.DuneErosion.Data;
 using Ringtoets.DuneErosion.Data.TestUtil;
 using Ringtoets.DuneErosion.Service;
@@ -44,6 +45,12 @@
         public void Run_ValidCalculation_PerformCalculationAndLogStartAndEnd()
         {
             // Setup
+            var mockRepository = new MockRepository();
+            var calculatorFactory = mockRepository.StrictMock<IHydraRingCalculatorFactory>();
+            calculatorFactory.Expect(cf => cf.CreateDunesBoundaryConditionsCalculator(testDataPath))
+                             .Return(new TestDunesBoundaryConditionsCalculator());
+            mockRepository.ReplayAll();
+
             var failureMechanism = new DuneErosionFailureMechanism
             {
                 Contribution = 10
@@ -61,7 +68,7 @@
                                                                       validFilePath,
                                                                       1.0 / 30000);
 
-            using (new HydraRingCalculatorFactoryConfig())
+            using (new HydraRingCalculatorFactoryConfig(calculatorFactory))
             {
                 // Call
                 Action call = () => activity.Run();
@@ -79,6 +86,8 @@
                                              });
                 Assert.AreEqual(ActivityState.Executed, activity.State);
             }
+
+            mockRepository.VerifyAll();
         }
 
         [Test]
@@ -88,6 +97,18 @@
         public void Run_InvalidCalculationAndRan_PerformCalculationAndActivityStateFailed(bool endInFailure, string lastErrorFileContent)
         {
             // Setup
+            var testDunesBoundaryConditionsCalculator = new TestDunesBoundaryConditionsCalculator
+            {
+                EndInFailure = endInFailure,
+                LastErrorFileContent = lastErrorFileContent
+            };
+
+            var mockRepository = new MockRepository();
+            var calculatorFactory = mockRepository.StrictMock<IHydraRingCalculatorFactory>();
+            calculatorFactory.Expect(cf => cf.CreateDunesBoundaryConditionsCalculator(testDataPath))
+                             .Return(testDunesBoundaryConditionsCalculator);
+            mockRepository.ReplayAll();
+
             var failureMechanism = new DuneErosionFailureMechanism();
             var duneLocation = new DuneLocation(1300001, "test", new Point2D(0, 0),
                                                 new DuneLocation.ConstructionProperties
@@ -102,25 +123,26 @@
                                                                       validFilePath,
                                                                       1.0 / 30000);
 
-            using (new HydraRingCalculatorFactoryConfig())
+            using (new HydraRingCalculatorFactoryConfig(calculatorFactory))
             {
-                TestDunesBoundaryConditionsCalculator calculator =
-                    ((TestHydraRingCalculatorFactory) HydraRingCalculatorFactory.Instance).DunesBoundaryConditionsCalculator;
-                calculator.EndInFailure = endInFailure;
-                calculator.LastErrorFileContent = lastErrorFileContent;
-
                 // Call
                 activity.Run();
 
                 // Assert
                 Assert.AreEqual(ActivityState.Failed, activity.State);
             }
+
+            mockRepository.VerifyAll();
         }
 
         [Test]
         public void Run_CalculationAlreadyPerformed_CalculationNotPerformedAndActivityStateSkipped()
         {
             // Setup
+            var mockRepository = new MockRepository();
+            var calculatorFactory = mockRepository.StrictMock<IHydraRingCalculatorFactory>();
+            mockRepository.ReplayAll();
+
             var failureMechanism = new DuneErosionFailureMechanism
             {
                 Contribution = 10
@@ -135,7 +157,7 @@
                                                                       validFilePath,
                                                                       1.0 / 30000);
 
-            using (new HydraRingCalculatorFactoryConfig())
+            using (new HydraRingCalculatorFactoryConfig(calculatorFactory))
             {
                 // Call
                 activity.Run();
@@ -144,6 +166,8 @@
                 Assert.AreEqual(ActivityState.Skipped, activity.State);
                 Assert.AreSame(initialOutput, duneLocation.Output);
             }
+
+            mockRepository.VerifyAll();
         }
     }
 }
\ No newline at end of file
Index: Ringtoets/DuneErosion/test/Ringtoets.DuneErosion.Plugin.Test/Ringtoets.DuneErosion.Plugin.Test.csproj
===================================================================
diff -u -ra70cb733eb761229173777b9f6cd1b977830b24b -r12d03593998d6ac93c231ef947f00ff87c71e100
--- Ringtoets/DuneErosion/test/Ringtoets.DuneErosion.Plugin.Test/Ringtoets.DuneErosion.Plugin.Test.csproj	(.../Ringtoets.DuneErosion.Plugin.Test.csproj)	(revision a70cb733eb761229173777b9f6cd1b977830b24b)
+++ Ringtoets/DuneErosion/test/Ringtoets.DuneErosion.Plugin.Test/Ringtoets.DuneErosion.Plugin.Test.csproj	(.../Ringtoets.DuneErosion.Plugin.Test.csproj)	(revision 12d03593998d6ac93c231ef947f00ff87c71e100)
@@ -119,6 +119,10 @@
       <Project>{4843D6E5-066F-4795-94F5-1D53932DD03C}</Project>
       <Name>Ringtoets.Common.Data.TestUtil</Name>
     </ProjectReference>
+    <ProjectReference Include="..\..\..\HydraRing\src\Ringtoets.HydraRing.Calculation\Ringtoets.HydraRing.Calculation.csproj">
+      <Project>{888D4097-8BC2-4703-9FB1-8744C94D525E}</Project>
+      <Name>Ringtoets.HydraRing.Calculation</Name>
+    </ProjectReference>
     <ProjectReference Include="..\..\..\HydraRing\test\Ringtoets.HydraRing.Calculation.TestUtil\Ringtoets.HydraRing.Calculation.TestUtil.csproj">
       <Project>{74CBA865-9338-447F-BAD9-28312446AE84}</Project>
       <Name>Ringtoets.HydraRing.Calculation.TestUtil</Name>
Index: Ringtoets/DuneErosion/test/Ringtoets.DuneErosion.Plugin.Test/TreeNodeInfos/DuneLocationsContextTreeNodeInfoTest.cs
===================================================================
diff -u -r330f2e86f2fb575c436cdbb46b6d31bc246ef6fc -r12d03593998d6ac93c231ef947f00ff87c71e100
--- Ringtoets/DuneErosion/test/Ringtoets.DuneErosion.Plugin.Test/TreeNodeInfos/DuneLocationsContextTreeNodeInfoTest.cs	(.../DuneLocationsContextTreeNodeInfoTest.cs)	(revision 330f2e86f2fb575c436cdbb46b6d31bc246ef6fc)
+++ Ringtoets/DuneErosion/test/Ringtoets.DuneErosion.Plugin.Test/TreeNodeInfos/DuneLocationsContextTreeNodeInfoTest.cs	(.../DuneLocationsContextTreeNodeInfoTest.cs)	(revision 12d03593998d6ac93c231ef947f00ff87c71e100)
@@ -40,6 +40,7 @@
 using Ringtoets.DuneErosion.Data;
 using Ringtoets.DuneErosion.Data.TestUtil;
 using Ringtoets.DuneErosion.Forms.PresentationObjects;
+using Ringtoets.HydraRing.Calculation.Calculator.Factory;
 using Ringtoets.HydraRing.Calculation.TestUtil.Calculator;
 using RingtoetsCommonFormsResources = Ringtoets.Common.Forms.Properties.Resources;
 
@@ -426,6 +427,13 @@
                 gui.Stub(g => g.MainWindow).Return(mainWindowStub);
                 var observerMock = mocks.StrictMock<IObserver>();
                 observerMock.Expect(o => o.UpdateObserver());
+
+                int calculators = failureMechanism.DuneLocations.Count;
+                var calculatorFactory = mocks.StrictMock<IHydraRingCalculatorFactory>();
+                calculatorFactory.Expect(cf => cf.CreateDunesBoundaryConditionsCalculator(testDataPath))
+                                 .Return(new TestDunesBoundaryConditionsCalculator())
+                                 .Repeat
+                                 .Times(calculators);
                 mocks.ReplayAll();
 
                 failureMechanism.DuneLocations.Attach(observerMock);
@@ -434,7 +442,7 @@
                 plugin.Activate();
 
                 using (ContextMenuStrip contextMenu = info.ContextMenuStrip(context, null, treeViewControl))
-                using (new HydraRingCalculatorFactoryConfig())
+                using (new HydraRingCalculatorFactoryConfig(calculatorFactory))
                 {
                     // Call
                     TestHelper.AssertLogMessages(() => contextMenu.Items[contextMenuCalculateAllIndex].PerformClick(), messages =>
Index: Ringtoets/DuneErosion/test/Ringtoets.DuneErosion.Service.Test/DuneErosionBoundaryCalculationServiceTest.cs
===================================================================
diff -u -r330f2e86f2fb575c436cdbb46b6d31bc246ef6fc -r12d03593998d6ac93c231ef947f00ff87c71e100
--- Ringtoets/DuneErosion/test/Ringtoets.DuneErosion.Service.Test/DuneErosionBoundaryCalculationServiceTest.cs	(.../DuneErosionBoundaryCalculationServiceTest.cs)	(revision 330f2e86f2fb575c436cdbb46b6d31bc246ef6fc)
+++ Ringtoets/DuneErosion/test/Ringtoets.DuneErosion.Service.Test/DuneErosionBoundaryCalculationServiceTest.cs	(.../DuneErosionBoundaryCalculationServiceTest.cs)	(revision 12d03593998d6ac93c231ef947f00ff87c71e100)
@@ -26,6 +26,7 @@
 using Core.Common.TestUtil;
 using Core.Common.Utils;
 using NUnit.Framework;
+using Rhino.Mocks;
 using Ringtoets.Common.Data.TestUtil;
 using Ringtoets.DuneErosion.Data;
 using Ringtoets.DuneErosion.Data.TestUtil;
@@ -76,6 +77,14 @@
         public void Calculate_ValidData_CalculationStartedWithRightParameters()
         {
             // Setup
+            var testDunesBoundaryConditionsCalculator = new TestDunesBoundaryConditionsCalculator();
+
+            var mockRepository = new MockRepository();
+            var calculatorFactory = mockRepository.StrictMock<IHydraRingCalculatorFactory>();
+            calculatorFactory.Expect(cf => cf.CreateDunesBoundaryConditionsCalculator(testDataPath))
+                             .Return(testDunesBoundaryConditionsCalculator);
+            mockRepository.ReplayAll();
+
             var failureMechanism = new DuneErosionFailureMechanism
             {
                 Contribution = 10
@@ -91,11 +100,8 @@
                                                     D50 = 0.000007
                                                 });
 
-            using (new HydraRingCalculatorFactoryConfig())
+            using (new HydraRingCalculatorFactoryConfig(calculatorFactory))
             {
-                TestDunesBoundaryConditionsCalculator testCalculator =
-                    ((TestHydraRingCalculatorFactory) HydraRingCalculatorFactory.Instance).DunesBoundaryConditionsCalculator;
-
                 // Call
                 new DuneErosionBoundaryCalculationService().Calculate(
                     duneLocation,
@@ -104,18 +110,33 @@
                     validFilePath);
 
                 // Assert
-                Assert.AreEqual(testDataPath, testCalculator.HydraulicBoundaryDatabaseDirectory);
-
                 DunesBoundaryConditionsCalculationInput expectedInput = CreateInput(duneLocation, mechanismSpecificNorm);
-                AssertInput(expectedInput, testCalculator.ReceivedInputs.First());
-                Assert.IsFalse(testCalculator.IsCanceled);
+                AssertInput(expectedInput, testDunesBoundaryConditionsCalculator.ReceivedInputs.First());
+                Assert.IsFalse(testDunesBoundaryConditionsCalculator.IsCanceled);
             }
+
+            mockRepository.VerifyAll();
         }
 
         [Test]
         public void Calculate_CalculationRan_SetOutput()
         {
             // Setup
+            var testDunesBoundaryConditionsCalculator = new TestDunesBoundaryConditionsCalculator
+            {
+                ReliabilityIndex = 3.27052,
+                WaterLevel = 4.82912,
+                WaveHeight = 2.88936,
+                WavePeriod = 10.65437,
+                Converged = true
+            };
+
+            var mockRepository = new MockRepository();
+            var calculatorFactory = mockRepository.StrictMock<IHydraRingCalculatorFactory>();
+            calculatorFactory.Expect(cf => cf.CreateDunesBoundaryConditionsCalculator(testDataPath))
+                             .Return(testDunesBoundaryConditionsCalculator);
+            mockRepository.ReplayAll();
+
             var failureMechanism = new DuneErosionFailureMechanism
             {
                 Contribution = 10
@@ -134,16 +155,8 @@
             // Precondition
             Assert.IsNull(duneLocation.Output);
 
-            using (new HydraRingCalculatorFactoryConfig())
+            using (new HydraRingCalculatorFactoryConfig(calculatorFactory))
             {
-                TestDunesBoundaryConditionsCalculator testCalculator =
-                    ((TestHydraRingCalculatorFactory) HydraRingCalculatorFactory.Instance).DunesBoundaryConditionsCalculator;
-                testCalculator.ReliabilityIndex = 3.27052;
-                testCalculator.WaterLevel = 4.82912;
-                testCalculator.WaveHeight = 2.88936;
-                testCalculator.WavePeriod = 10.65437;
-                testCalculator.Converged = true;
-
                 // Call
                 Action test = () => new DuneErosionBoundaryCalculationService().Calculate(
                     duneLocation,
@@ -163,23 +176,36 @@
                         StringAssert.StartsWith($"Berekening van '{duneLocation.Name}' beëindigd om: ", msgs[2]);
                     });
                 double targetReliability = StatisticsConverter.ProbabilityToReliability(mechanismSpecificNorm);
-                double calculatedProbability = StatisticsConverter.ReliabilityToProbability(testCalculator.ReliabilityIndex);
+                double calculatedProbability = StatisticsConverter.ReliabilityToProbability(testDunesBoundaryConditionsCalculator.ReliabilityIndex);
 
                 Assert.IsNotNull(duneLocation.Output);
-                Assert.AreEqual(testCalculator.ReliabilityIndex, duneLocation.Output.CalculatedReliability.Value);
+                Assert.AreEqual(testDunesBoundaryConditionsCalculator.ReliabilityIndex, duneLocation.Output.CalculatedReliability.Value);
                 Assert.AreEqual(calculatedProbability, duneLocation.Output.CalculatedProbability);
                 Assert.AreEqual(mechanismSpecificNorm, duneLocation.Output.TargetProbability);
                 Assert.AreEqual(targetReliability, duneLocation.Output.TargetReliability, duneLocation.Output.TargetReliability.GetAccuracy());
-                Assert.AreEqual(testCalculator.WaterLevel, duneLocation.Output.WaterLevel, duneLocation.Output.WaterLevel.GetAccuracy());
-                Assert.AreEqual(testCalculator.WaveHeight, duneLocation.Output.WaveHeight, duneLocation.Output.WaveHeight.GetAccuracy());
-                Assert.AreEqual(testCalculator.WavePeriod, duneLocation.Output.WavePeriod, duneLocation.Output.WavePeriod.GetAccuracy());
+                Assert.AreEqual(testDunesBoundaryConditionsCalculator.WaterLevel, duneLocation.Output.WaterLevel, duneLocation.Output.WaterLevel.GetAccuracy());
+                Assert.AreEqual(testDunesBoundaryConditionsCalculator.WaveHeight, duneLocation.Output.WaveHeight, duneLocation.Output.WaveHeight.GetAccuracy());
+                Assert.AreEqual(testDunesBoundaryConditionsCalculator.WavePeriod, duneLocation.Output.WavePeriod, duneLocation.Output.WavePeriod.GetAccuracy());
             }
+
+            mockRepository.VerifyAll();
         }
 
         [Test]
         public void Calculate_CalculationRanNotConverged_LogMessage()
         {
             // Setup
+            var testDunesBoundaryConditionsCalculator = new TestDunesBoundaryConditionsCalculator
+            {
+                ReliabilityIndex = 0.01
+            };
+
+            var mockRepository = new MockRepository();
+            var calculatorFactory = mockRepository.StrictMock<IHydraRingCalculatorFactory>();
+            calculatorFactory.Expect(cf => cf.CreateDunesBoundaryConditionsCalculator(testDataPath))
+                             .Return(testDunesBoundaryConditionsCalculator);
+            mockRepository.ReplayAll();
+
             var failureMechanism = new DuneErosionFailureMechanism
             {
                 Contribution = 10
@@ -194,12 +220,8 @@
                                                     D50 = 0.000007
                                                 });
 
-            using (new HydraRingCalculatorFactoryConfig())
+            using (new HydraRingCalculatorFactoryConfig(calculatorFactory))
             {
-                TestDunesBoundaryConditionsCalculator testCalculator =
-                    ((TestHydraRingCalculatorFactory) HydraRingCalculatorFactory.Instance).DunesBoundaryConditionsCalculator;
-                testCalculator.ReliabilityIndex = 0.01;
-
                 // Call
                 Action test = () => new DuneErosionBoundaryCalculationService().Calculate(
                     duneLocation,
@@ -220,12 +242,22 @@
                         StringAssert.StartsWith($"Berekening van '{duneLocation.Name}' beëindigd om: ", msgs[3]);
                     });
             }
+
+            mockRepository.VerifyAll();
         }
 
         [Test]
         public void Calculate_CancelCalculationWithValidInput_CancelsCalculator()
         {
             // Setup
+            var testDunesBoundaryConditionsCalculator = new TestDunesBoundaryConditionsCalculator();
+
+            var mockRepository = new MockRepository();
+            var calculatorFactory = mockRepository.StrictMock<IHydraRingCalculatorFactory>();
+            calculatorFactory.Expect(cf => cf.CreateDunesBoundaryConditionsCalculator(testDataPath))
+                             .Return(testDunesBoundaryConditionsCalculator);
+            mockRepository.ReplayAll();
+
             var failureMechanism = new DuneErosionFailureMechanism
             {
                 Contribution = 10
@@ -240,13 +272,10 @@
                                                     D50 = 0.000007
                                                 });
 
-            using (new HydraRingCalculatorFactoryConfig())
+            using (new HydraRingCalculatorFactoryConfig(calculatorFactory))
             {
-                TestDunesBoundaryConditionsCalculator testCalculator =
-                    ((TestHydraRingCalculatorFactory) HydraRingCalculatorFactory.Instance).DunesBoundaryConditionsCalculator;
-
                 var service = new DuneErosionBoundaryCalculationService();
-                testCalculator.CalculationFinishedHandler += (s, e) => service.Cancel();
+                testDunesBoundaryConditionsCalculator.CalculationFinishedHandler += (s, e) => service.Cancel();
 
                 // Call
                 service.Calculate(
@@ -256,14 +285,28 @@
                     validFilePath);
 
                 // Assert
-                Assert.IsTrue(testCalculator.IsCanceled);
+                Assert.IsTrue(testDunesBoundaryConditionsCalculator.IsCanceled);
             }
+
+            mockRepository.VerifyAll();
         }
 
         [Test]
         public void Calculate_CalculationFailedWithExceptionAndLastErrorPresent_LogErrorAndThrowException()
         {
             // Setup
+            var testDunesBoundaryConditionsCalculator = new TestDunesBoundaryConditionsCalculator
+            {
+                LastErrorFileContent = "An error occurred",
+                EndInFailure = true
+            };
+
+            var mockRepository = new MockRepository();
+            var calculatorFactory = mockRepository.StrictMock<IHydraRingCalculatorFactory>();
+            calculatorFactory.Expect(cf => cf.CreateDunesBoundaryConditionsCalculator(testDataPath))
+                             .Return(testDunesBoundaryConditionsCalculator);
+            mockRepository.ReplayAll();
+
             var failureMechanism = new DuneErosionFailureMechanism
             {
                 Contribution = 10
@@ -278,13 +321,8 @@
                                                     D50 = 0.000007
                                                 });
 
-            using (new HydraRingCalculatorFactoryConfig())
+            using (new HydraRingCalculatorFactoryConfig(calculatorFactory))
             {
-                TestDunesBoundaryConditionsCalculator calculator =
-                    ((TestHydraRingCalculatorFactory) HydraRingCalculatorFactory.Instance).DunesBoundaryConditionsCalculator;
-                calculator.LastErrorFileContent = "An error occurred";
-                calculator.EndInFailure = true;
-
                 var exceptionThrown = false;
 
                 // Call
@@ -319,12 +357,25 @@
                 Assert.IsTrue(exceptionThrown);
                 Assert.IsNull(duneLocation.Output);
             }
+
+            mockRepository.VerifyAll();
         }
 
         [Test]
         public void Calculate_CalculationFailedWithExceptionAndNoLastErrorPresent_LogErrorAndThrowException()
         {
             // Setup
+            var testDunesBoundaryConditionsCalculator = new TestDunesBoundaryConditionsCalculator
+            {
+                EndInFailure = true
+            };
+
+            var mockRepository = new MockRepository();
+            var calculatorFactory = mockRepository.StrictMock<IHydraRingCalculatorFactory>();
+            calculatorFactory.Expect(cf => cf.CreateDunesBoundaryConditionsCalculator(testDataPath))
+                             .Return(testDunesBoundaryConditionsCalculator);
+            mockRepository.ReplayAll();
+
             var failureMechanism = new DuneErosionFailureMechanism
             {
                 Contribution = 10
@@ -339,12 +390,8 @@
                                                     D50 = 0.000007
                                                 });
 
-            using (new HydraRingCalculatorFactoryConfig())
+            using (new HydraRingCalculatorFactoryConfig(calculatorFactory))
             {
-                TestDunesBoundaryConditionsCalculator calculator =
-                    ((TestHydraRingCalculatorFactory) HydraRingCalculatorFactory.Instance).DunesBoundaryConditionsCalculator;
-                calculator.EndInFailure = true;
-
                 var exceptionThrown = false;
 
                 // Call
@@ -379,12 +426,26 @@
                 Assert.IsTrue(exceptionThrown);
                 Assert.IsNull(duneLocation.Output);
             }
+
+            mockRepository.VerifyAll();
         }
 
         [Test]
         public void Calculate_CalculationFailedWithoutExceptionAndWithLastErrorPresent_LogErrorAndThrowException()
         {
             // Setup
+            var testDunesBoundaryConditionsCalculator = new TestDunesBoundaryConditionsCalculator
+            {
+                EndInFailure = false,
+                LastErrorFileContent = "An error occurred"
+            };
+
+            var mockRepository = new MockRepository();
+            var calculatorFactory = mockRepository.StrictMock<IHydraRingCalculatorFactory>();
+            calculatorFactory.Expect(cf => cf.CreateDunesBoundaryConditionsCalculator(testDataPath))
+                             .Return(testDunesBoundaryConditionsCalculator);
+            mockRepository.ReplayAll();
+
             var failureMechanism = new DuneErosionFailureMechanism
             {
                 Contribution = 10
@@ -399,13 +460,8 @@
                                                     D50 = 0.000007
                                                 });
 
-            using (new HydraRingCalculatorFactoryConfig())
+            using (new HydraRingCalculatorFactoryConfig(calculatorFactory))
             {
-                TestDunesBoundaryConditionsCalculator calculator =
-                    ((TestHydraRingCalculatorFactory) HydraRingCalculatorFactory.Instance).DunesBoundaryConditionsCalculator;
-                calculator.EndInFailure = false;
-                calculator.LastErrorFileContent = "An error occurred";
-
                 var exceptionThrown = false;
                 string exceptionMessage = string.Empty;
 
@@ -441,8 +497,9 @@
                     });
                 Assert.IsTrue(exceptionThrown);
                 Assert.IsNull(duneLocation.Output);
-                Assert.AreEqual(calculator.LastErrorFileContent, exceptionMessage);
             }
+
+            mockRepository.VerifyAll();
         }
 
         private static void AssertInput(DunesBoundaryConditionsCalculationInput expectedInput, DunesBoundaryConditionsCalculationInput actualInput)
Index: Ringtoets/DuneErosion/test/Ringtoets.DuneErosion.Service.Test/Ringtoets.DuneErosion.Service.Test.csproj
===================================================================
diff -u -r8aeff3f1153aaac2b2980ca207e298b6d764947b -r12d03593998d6ac93c231ef947f00ff87c71e100
--- Ringtoets/DuneErosion/test/Ringtoets.DuneErosion.Service.Test/Ringtoets.DuneErosion.Service.Test.csproj	(.../Ringtoets.DuneErosion.Service.Test.csproj)	(revision 8aeff3f1153aaac2b2980ca207e298b6d764947b)
+++ Ringtoets/DuneErosion/test/Ringtoets.DuneErosion.Service.Test/Ringtoets.DuneErosion.Service.Test.csproj	(.../Ringtoets.DuneErosion.Service.Test.csproj)	(revision 12d03593998d6ac93c231ef947f00ff87c71e100)
@@ -42,6 +42,10 @@
       <HintPath>..\..\..\..\packages\NUnit.3.6.0\lib\net40\nunit.framework.dll</HintPath>
       <Private>True</Private>
     </Reference>
+    <Reference Include="Rhino.Mocks, Version=3.6.0.0, Culture=neutral, PublicKeyToken=0b3305902db7183f, processorArchitecture=MSIL">
+      <HintPath>..\..\..\..\packages\RhinoMocks.3.6.1\lib\net\Rhino.Mocks.dll</HintPath>
+      <Private>True</Private>
+    </Reference>
     <Reference Include="System" />
     <Reference Include="System.Core" />
   </ItemGroup>
Index: Ringtoets/DuneErosion/test/Ringtoets.DuneErosion.Service.Test/packages.config
===================================================================
diff -u -r330f2e86f2fb575c436cdbb46b6d31bc246ef6fc -r12d03593998d6ac93c231ef947f00ff87c71e100
--- Ringtoets/DuneErosion/test/Ringtoets.DuneErosion.Service.Test/packages.config	(.../packages.config)	(revision 330f2e86f2fb575c436cdbb46b6d31bc246ef6fc)
+++ Ringtoets/DuneErosion/test/Ringtoets.DuneErosion.Service.Test/packages.config	(.../packages.config)	(revision 12d03593998d6ac93c231ef947f00ff87c71e100)
@@ -1,4 +1,5 @@
-<?xml version="1.0" encoding="utf-8"?><!--
+<?xml version="1.0" encoding="utf-8"?>
+<!--
 Copyright (C) Stichting Deltares 2017. All rights reserved.
 
 This file is part of Ringtoets.
@@ -22,4 +23,5 @@
 -->
 <packages>
   <package id="NUnit" version="3.6.0" targetFramework="net40" />
+  <package id="RhinoMocks" version="3.6.1" targetFramework="net40" />
 </packages>
\ No newline at end of file
Index: Ringtoets/StabilityPointStructures/test/Ringtoets.StabilityPointStructures.Integration.Test/StabilityPointStructuresCalculationActivityIntegrationTest.cs
===================================================================
diff -u -rff948d4633181ead2677ab35467a93b4118c6751 -r12d03593998d6ac93c231ef947f00ff87c71e100
--- Ringtoets/StabilityPointStructures/test/Ringtoets.StabilityPointStructures.Integration.Test/StabilityPointStructuresCalculationActivityIntegrationTest.cs	(.../StabilityPointStructuresCalculationActivityIntegrationTest.cs)	(revision ff948d4633181ead2677ab35467a93b4118c6751)
+++ Ringtoets/StabilityPointStructures/test/Ringtoets.StabilityPointStructures.Integration.Test/StabilityPointStructuresCalculationActivityIntegrationTest.cs	(.../StabilityPointStructuresCalculationActivityIntegrationTest.cs)	(revision 12d03593998d6ac93c231ef947f00ff87c71e100)
@@ -79,9 +79,9 @@
             {
                 string[] msgs = messages.ToArray();
                 Assert.AreEqual(3, msgs.Length);
-                StringAssert.StartsWith(string.Format("Validatie van '{0}' gestart om: ", calculation.Name), msgs[0]);
+                StringAssert.StartsWith($"Validatie van '{calculation.Name}' gestart om: ", msgs[0]);
                 StringAssert.StartsWith("Validatie mislukt: Fout bij het lezen van bestand", msgs[1]);
-                StringAssert.StartsWith(string.Format("Validatie van '{0}' beëindigd om: ", calculation.Name), msgs[2]);
+                StringAssert.StartsWith($"Validatie van '{calculation.Name}' beëindigd om: ", msgs[2]);
             });
             Assert.AreEqual(ActivityState.Failed, activity.State);
         }
@@ -90,6 +90,12 @@
         public void Run_ValidCalculation_PerformValidationAndCalculationAndLogStartAndEnd()
         {
             // Setup
+            var mockRepository = new MockRepository();
+            var calculatorFactory = mockRepository.Stub<IHydraRingCalculatorFactory>();
+            calculatorFactory.Expect(cf => cf.CreateStructuresStabilityPointCalculator(testDataPath))
+                             .Return(new TestStructuresStabilityPointCalculator());
+            mockRepository.ReplayAll();
+
             var assessmentSection = new AssessmentSection(AssessmentSectionComposition.Dike);
 
             using (var importer = new HydraulicBoundaryDatabaseImporter())
@@ -115,7 +121,7 @@
             };
 
             var activity = new StabilityPointStructuresCalculationActivity(calculation, validFilePath, failureMechanism, assessmentSection);
-            using (new HydraRingCalculatorFactoryConfig())
+            using (new HydraRingCalculatorFactoryConfig(calculatorFactory))
             {
                 // Call
                 Action call = () => activity.Run();
@@ -125,14 +131,16 @@
                 {
                     string[] msgs = messages.ToArray();
                     Assert.AreEqual(5, msgs.Length);
-                    StringAssert.StartsWith(string.Format("Validatie van '{0}' gestart om: ", calculation.Name), msgs[0]);
-                    StringAssert.StartsWith(string.Format("Validatie van '{0}' beëindigd om: ", calculation.Name), msgs[1]);
-                    StringAssert.StartsWith(string.Format("Berekening van '{0}' gestart om: ", calculation.Name), msgs[2]);
+                    StringAssert.StartsWith($"Validatie van '{calculation.Name}' gestart om: ", msgs[0]);
+                    StringAssert.StartsWith($"Validatie van '{calculation.Name}' beëindigd om: ", msgs[1]);
+                    StringAssert.StartsWith($"Berekening van '{calculation.Name}' gestart om: ", msgs[2]);
                     StringAssert.StartsWith("Puntconstructies berekening is uitgevoerd op de tijdelijke locatie", msgs[3]);
-                    StringAssert.StartsWith(string.Format("Berekening van '{0}' beëindigd om: ", calculation.Name), msgs[4]);
+                    StringAssert.StartsWith($"Berekening van '{calculation.Name}' beëindigd om: ", msgs[4]);
                 });
                 Assert.AreEqual(ActivityState.Executed, activity.State);
             }
+
+            mockRepository.VerifyAll();
         }
 
         [Test]
@@ -142,6 +150,18 @@
         public void Run_InvalidCalculationRan_PerformValidationAndCalculationActivityStateFailed(bool endInFailure, string lastErrorFileContent)
         {
             // Setup
+            var testStructuresStabilityPointCalculator = new TestStructuresStabilityPointCalculator
+            {
+                EndInFailure = endInFailure,
+                LastErrorFileContent = lastErrorFileContent
+            };
+
+            var mockRepository = new MockRepository();
+            var calculatorFactory = mockRepository.Stub<IHydraRingCalculatorFactory>();
+            calculatorFactory.Expect(cf => cf.CreateStructuresStabilityPointCalculator(testDataPath))
+                             .Return(testStructuresStabilityPointCalculator);
+            mockRepository.ReplayAll();
+
             var assessmentSection = new AssessmentSection(AssessmentSectionComposition.Dike);
 
             using (var importer = new HydraulicBoundaryDatabaseImporter())
@@ -168,29 +188,31 @@
 
             var activity = new StabilityPointStructuresCalculationActivity(calculation, validFilePath, failureMechanism, assessmentSection);
 
-            using (new HydraRingCalculatorFactoryConfig())
+            using (new HydraRingCalculatorFactoryConfig(calculatorFactory))
             {
-                TestStructuresStabilityPointCalculator calculator = ((TestHydraRingCalculatorFactory) HydraRingCalculatorFactory.Instance).StructuresStabilityPointCalculator;
-                calculator.EndInFailure = endInFailure;
-                calculator.LastErrorFileContent = lastErrorFileContent;
-
                 // Call
                 activity.Run();
 
                 // Assert
                 Assert.AreEqual(ActivityState.Failed, activity.State);
             }
+
+            mockRepository.VerifyAll();
         }
 
         [Test]
         public void Finish_ValidCalculationAndRan_SetsOutputAndNotifyObserversOfCalculation()
         {
             // Setup
-            var mocks = new MockRepository();
-            var observerMock = mocks.StrictMock<IObserver>();
+            var mockRepository = new MockRepository();
+            var observerMock = mockRepository.StrictMock<IObserver>();
             observerMock.Expect(o => o.UpdateObserver());
-            mocks.ReplayAll();
 
+            var calculatorFactory = mockRepository.Stub<IHydraRingCalculatorFactory>();
+            calculatorFactory.Expect(cf => cf.CreateStructuresStabilityPointCalculator(testDataPath))
+                             .Return(new TestStructuresStabilityPointCalculator());
+            mockRepository.ReplayAll();
+
             var assessmentSection = new AssessmentSection(AssessmentSectionComposition.Dike);
 
             using (var importer = new HydraulicBoundaryDatabaseImporter())
@@ -219,7 +241,7 @@
 
             var activity = new StabilityPointStructuresCalculationActivity(calculation, validFilePath, failureMechanism, assessmentSection);
 
-            using (new HydraRingCalculatorFactoryConfig())
+            using (new HydraRingCalculatorFactoryConfig(calculatorFactory))
             {
                 activity.Run();
             }
@@ -229,18 +251,26 @@
 
             // Assert
             Assert.IsNotNull(calculation.Output);
-            mocks.VerifyAll();
+            mockRepository.VerifyAll();
         }
 
         [Test]
         public void Finish_InvalidCalculationAndRan_DoesNotSetOutputAndNotifyObserversOfCalculation()
         {
             // Setup
-            var mocks = new MockRepository();
-            var observerMock = mocks.StrictMock<IObserver>();
+            var mockRepository = new MockRepository();
+            var observerMock = mockRepository.StrictMock<IObserver>();
             observerMock.Expect(o => o.UpdateObserver());
-            mocks.ReplayAll();
 
+            var testStructuresStabilityPointCalculator = new TestStructuresStabilityPointCalculator
+            {
+                EndInFailure = true
+            };
+            var calculatorFactory = mockRepository.Stub<IHydraRingCalculatorFactory>();
+            calculatorFactory.Expect(cf => cf.CreateStructuresStabilityPointCalculator(testDataPath))
+                             .Return(testStructuresStabilityPointCalculator);
+            mockRepository.ReplayAll();
+
             var assessmentSection = new AssessmentSection(AssessmentSectionComposition.Dike);
 
             using (var importer = new HydraulicBoundaryDatabaseImporter())
@@ -259,19 +289,17 @@
             {
                 InputParameters =
                 {
-                    HydraulicBoundaryLocation = new HydraulicBoundaryLocation(1, "test", 1, 1)
+                    HydraulicBoundaryLocation = new HydraulicBoundaryLocation(1, "test", 1, 1),
+                    Structure = new TestStabilityPointStructure()
                 }
             };
 
             calculation.Attach(observerMock);
 
             var activity = new StabilityPointStructuresCalculationActivity(calculation, validFilePath, failureMechanism, assessmentSection);
 
-            using (new HydraRingCalculatorFactoryConfig())
+            using (new HydraRingCalculatorFactoryConfig(calculatorFactory))
             {
-                TestStructuresStabilityPointCalculator calculator = ((TestHydraRingCalculatorFactory) HydraRingCalculatorFactory.Instance).StructuresStabilityPointCalculator;
-                calculator.EndInFailure = true;
-
                 activity.Run();
             }
 
@@ -280,7 +308,7 @@
 
             // Assert
             Assert.IsNull(calculation.Output);
-            mocks.VerifyAll();
+            mockRepository.VerifyAll();
         }
     }
 }
\ No newline at end of file