Index: Ringtoets/Common/src/Ringtoets.Common.Service/CalculationServiceHelper.cs
===================================================================
diff -u -r12a35732d53e73c149035a212f96d2a0e9604cff -r3d9b418d483c122040e11a7e074d666c64e9d7b5
--- Ringtoets/Common/src/Ringtoets.Common.Service/CalculationServiceHelper.cs	(.../CalculationServiceHelper.cs)	(revision 12a35732d53e73c149035a212f96d2a0e9604cff)
+++ Ringtoets/Common/src/Ringtoets.Common.Service/CalculationServiceHelper.cs	(.../CalculationServiceHelper.cs)	(revision 3d9b418d483c122040e11a7e074d666c64e9d7b5)
@@ -60,26 +60,16 @@
         /// Method for performing calculations. Error and status information is logged during
         /// the execution of the operation.
         /// </summary>
-        /// <typeparam name="T">The output type.</typeparam>
         /// <param name="name">The name of the calculation.</param>
         /// <param name="calculationFunc">The method used to perform the calculation.</param>
-        /// <param name="outputIsNullErrorMessage">The error message to show when the output is <c>null</c>.</param>
-        /// <returns><typeparamref name="T"/> on a successful calculation, <c>null</c> otherwise.</returns>
-        /// <remarks>When <paramref name="calculationFunc"/> throws an exception, this will not be catched in this method.</remarks>
-        public static T PerformCalculation<T>(string name, Func<T> calculationFunc, string outputIsNullErrorMessage)
+        /// <remarks>When <paramref name="calculationFunc"/> throws an exception, this will not be caught in this method.</remarks>
+        public static void PerformCalculation(string name, Action calculationFunc)
         {
             LogCalculationBeginTime(name);
 
             try
             {
-                var output = calculationFunc();
-
-                if (output == null)
-                {
-                    LogMessagesAsError(outputIsNullErrorMessage, name);
-                }
-
-                return output;
+                calculationFunc();
             }
             finally
             {
Index: Ringtoets/Common/test/Ringtoets.Common.Service.Test/CalculationServiceHelperTest.cs
===================================================================
diff -u -r5e6eacaf76f765ba77febee673e9e94895e46feb -r3d9b418d483c122040e11a7e074d666c64e9d7b5
--- Ringtoets/Common/test/Ringtoets.Common.Service.Test/CalculationServiceHelperTest.cs	(.../CalculationServiceHelperTest.cs)	(revision 5e6eacaf76f765ba77febee673e9e94895e46feb)
+++ Ringtoets/Common/test/Ringtoets.Common.Service.Test/CalculationServiceHelperTest.cs	(.../CalculationServiceHelperTest.cs)	(revision 3d9b418d483c122040e11a7e074d666c64e9d7b5)
@@ -80,50 +80,25 @@
         }
 
         [Test]
-        public void PerformCalculation_CalculationFuncReturnsNull_WritesStartAndEndAndErrorLogMessagesAndReturnsNull()
+        public void PerformCalculation_WithCalculation_ExecutesCalculationActionAndWritesStartAndEndAndErrorLogMessages()
         {
             // Setup
             string name = "Test name";
-            string errorMessage = "There was an error: {0}";
 
-            object output = null;
+            int called = 0;
 
             // Call
-            Action call = () => output = CalculationServiceHelper.PerformCalculation<object>(name, () => null, errorMessage);
+            Action call = () => CalculationServiceHelper.PerformCalculation(name, () => called++);
 
             // Assert
             TestHelper.AssertLogMessages(call, messages =>
             {
                 var msgs = messages.ToArray();
-                Assert.AreEqual(3, msgs.Length);
-                StringAssert.StartsWith(string.Format("Berekening van '{0}' gestart om: ", name), msgs[0]);
-                StringAssert.StartsWith(string.Format(errorMessage, name), msgs[1]);
-                StringAssert.StartsWith(string.Format("Berekening van '{0}' beëindigd om: ", name), msgs[2]);
-            });
-            Assert.IsNull(output);
-        }
-
-        [Test]
-        public void PerformCalculation_CalculationFuncReturnsOutput_WritesStartAndEndLogMessagesAndReturnsOutput()
-        {
-            // Setup
-            string name = "Test name";
-            double outputValue = 4.0;
-
-            double output = double.NaN;
-
-            // Call
-            Action call = () => output = CalculationServiceHelper.PerformCalculation(name, () => outputValue, string.Empty);
-
-            // Assert
-            TestHelper.AssertLogMessages(call, messages =>
-            {
-                var msgs = messages.ToArray();
                 Assert.AreEqual(2, msgs.Length);
                 StringAssert.StartsWith(string.Format("Berekening van '{0}' gestart om: ", name), msgs[0]);
                 StringAssert.StartsWith(string.Format("Berekening van '{0}' beëindigd om: ", name), msgs[1]);
             });
-            Assert.AreEqual(outputValue, output);
+            Assert.AreEqual(1, called);
         }
 
         [Test]
Index: Ringtoets/GrassCoverErosionInwards/src/Ringtoets.GrassCoverErosionInwards.Service/GrassCoverErosionInwardsCalculationService.cs
===================================================================
diff -u -r04d96e936610eab56e9ddc09c055526efe9b9652 -r3d9b418d483c122040e11a7e074d666c64e9d7b5
--- Ringtoets/GrassCoverErosionInwards/src/Ringtoets.GrassCoverErosionInwards.Service/GrassCoverErosionInwardsCalculationService.cs	(.../GrassCoverErosionInwardsCalculationService.cs)	(revision 04d96e936610eab56e9ddc09c055526efe9b9652)
+++ Ringtoets/GrassCoverErosionInwards/src/Ringtoets.GrassCoverErosionInwards.Service/GrassCoverErosionInwardsCalculationService.cs	(.../GrassCoverErosionInwardsCalculationService.cs)	(revision 3d9b418d483c122040e11a7e074d666c64e9d7b5)
@@ -21,6 +21,7 @@
 
 using System.Collections.Generic;
 using System.Linq;
+using log4net;
 using Ringtoets.Common.Data.AssessmentSection;
 using Ringtoets.Common.Data.FailureMechanism;
 using Ringtoets.Common.Service;
@@ -29,6 +30,7 @@
 using Ringtoets.HydraRing.Calculation.Data;
 using Ringtoets.HydraRing.Calculation.Data.Input.Overtopping;
 using Ringtoets.HydraRing.Calculation.Data.Output;
+using Ringtoets.HydraRing.Calculation.Parsers;
 using Ringtoets.HydraRing.Calculation.Services;
 using Ringtoets.HydraRing.IO;
 using RingtoetsCommonServiceResources = Ringtoets.Common.Service.Properties.Resources;
@@ -40,6 +42,8 @@
     /// </summary>
     public static class GrassCoverErosionInwardsCalculationService
     {
+        private static readonly ILog log = LogManager.GetLogger(typeof(GrassCoverErosionInwardsCalculationService));
+
         /// <summary>
         /// Performs validation over the values on the given <paramref name="calculation"/>. Error and status information is logged during
         /// the execution of the operation.
@@ -67,12 +71,38 @@
                                                                          string ringId, GeneralGrassCoverErosionInwardsInput generalInput)
         {
             OvertoppingCalculationInput input = CreateInput(calculation, failureMechanismSection, generalInput);
+            var exceedanceProbabilityCalculationParser = new ExceedanceProbabilityCalculationParser();
 
-            return CalculationServiceHelper.PerformCalculation(calculation.Name,
-                                                               () => HydraRingCalculationService.PerformCalculation(hlcdDirectory, ringId, HydraRingTimeIntegrationSchemeType.FerryBorgesCastanheta, HydraRingUncertaintiesType.All, input),
-                                                               Resources.GrassCoverErosionInwardsCalculationService_Calculate_Error_in_grass_cover_erosion_inwards_0_calculation);
+            CalculationServiceHelper.PerformCalculation(
+                calculation.Name,
+                () =>
+                {
+                    HydraRingCalculationService.PerformCalculation(
+                        hlcdDirectory,
+                        ringId,
+                        HydraRingTimeIntegrationSchemeType.FerryBorgesCastanheta,
+                        HydraRingUncertaintiesType.All,
+                        input,
+                        new[]
+                        {
+                            exceedanceProbabilityCalculationParser
+                        });
+
+                    VerifyOutput(exceedanceProbabilityCalculationParser.Output, calculation.Name);
+                });
+
+            return exceedanceProbabilityCalculationParser.Output;
         }
 
+        private static void VerifyOutput(ExceedanceProbabilityCalculationOutput output, string name)
+        {
+            if (output == null)
+            {
+                log.ErrorFormat(Resources.GrassCoverErosionInwardsCalculationService_Calculate_Error_in_grass_cover_erosion_inwards_0_calculation, name);
+            }
+        }
+
+
         private static OvertoppingCalculationInput CreateInput(GrassCoverErosionInwardsCalculation calculation, FailureMechanismSection failureMechanismSection, GeneralGrassCoverErosionInwardsInput generalInput)
         {
             return new OvertoppingCalculationInput(calculation.InputParameters.HydraulicBoundaryLocation.Id,
Index: Ringtoets/GrassCoverErosionInwards/src/Ringtoets.GrassCoverErosionInwards.Service/Ringtoets.GrassCoverErosionInwards.Service.csproj
===================================================================
diff -u -r5e6eacaf76f765ba77febee673e9e94895e46feb -r3d9b418d483c122040e11a7e074d666c64e9d7b5
--- Ringtoets/GrassCoverErosionInwards/src/Ringtoets.GrassCoverErosionInwards.Service/Ringtoets.GrassCoverErosionInwards.Service.csproj	(.../Ringtoets.GrassCoverErosionInwards.Service.csproj)	(revision 5e6eacaf76f765ba77febee673e9e94895e46feb)
+++ Ringtoets/GrassCoverErosionInwards/src/Ringtoets.GrassCoverErosionInwards.Service/Ringtoets.GrassCoverErosionInwards.Service.csproj	(.../Ringtoets.GrassCoverErosionInwards.Service.csproj)	(revision 3d9b418d483c122040e11a7e074d666c64e9d7b5)
@@ -32,6 +32,10 @@
     <CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet>
   </PropertyGroup>
   <ItemGroup>
+    <Reference Include="log4net, Version=1.2.14.0, Culture=neutral, PublicKeyToken=669e0ddf0bb1aa2a, processorArchitecture=MSIL">
+      <HintPath>..\..\..\..\packages\log4net.2.0.4\lib\net40-full\log4net.dll</HintPath>
+      <Private>True</Private>
+    </Reference>
     <Reference Include="System" />
     <Reference Include="System.Core" />
   </ItemGroup>
@@ -94,6 +98,7 @@
     <None Include="..\..\..\..\build\Copying.licenseheader">
       <Link>Copying.licenseheader</Link>
     </None>
+    <None Include="packages.config" />
   </ItemGroup>
   <ItemGroup>
     <EmbeddedResource Include="Properties\Resources.resx">
Fisheye: Tag 5e6eacaf76f765ba77febee673e9e94895e46feb refers to a dead (removed) revision in file `Ringtoets/GrassCoverErosionInwards/src/Ringtoets.GrassCoverErosionInwards.Service/packages.config'.
Fisheye: No comparison available.  Pass `N' to diff?
Index: Ringtoets/HeightStructures/src/Ringtoets.HeightStructures.Service/HeightStructuresCalculationService.cs
===================================================================
diff -u -r20415b2886919a103cb4677f56a8f61abbb7aa8a -r3d9b418d483c122040e11a7e074d666c64e9d7b5
--- Ringtoets/HeightStructures/src/Ringtoets.HeightStructures.Service/HeightStructuresCalculationService.cs	(.../HeightStructuresCalculationService.cs)	(revision 20415b2886919a103cb4677f56a8f61abbb7aa8a)
+++ Ringtoets/HeightStructures/src/Ringtoets.HeightStructures.Service/HeightStructuresCalculationService.cs	(.../HeightStructuresCalculationService.cs)	(revision 3d9b418d483c122040e11a7e074d666c64e9d7b5)
@@ -20,6 +20,7 @@
 // All rights reserved.
 
 using System.Collections.Generic;
+using log4net;
 using Ringtoets.Common.Data.AssessmentSection;
 using Ringtoets.Common.Data.FailureMechanism;
 using Ringtoets.Common.Data.Probabilistics;
@@ -29,6 +30,7 @@
 using Ringtoets.HydraRing.Calculation.Data;
 using Ringtoets.HydraRing.Calculation.Data.Input.Structures;
 using Ringtoets.HydraRing.Calculation.Data.Output;
+using Ringtoets.HydraRing.Calculation.Parsers;
 using Ringtoets.HydraRing.Calculation.Services;
 using Ringtoets.HydraRing.IO;
 using RingtoetsCommonServiceResources = Ringtoets.Common.Service.Properties.Resources;
@@ -40,6 +42,8 @@
     /// </summary>
     public static class HeightStructuresCalculationService
     {
+        private static readonly ILog log = LogManager.GetLogger(typeof(HeightStructuresCalculationService));
+
         /// <summary>
         /// Performs validation over the values on the given <paramref name="calculation"/>. Error and status information is logged during
         /// the execution of the operation.
@@ -66,12 +70,37 @@
                                                                          string hlcdDirectory, FailureMechanismSection failureMechanismSection,
                                                                          string ringId, GeneralHeightStructuresInput generalInput)
         {
-            var input = CreateInput(calculation, failureMechanismSection, generalInput);
-            return CalculationServiceHelper.PerformCalculation(calculation.Name,
-                                                               () => HydraRingCalculationService.PerformCalculation(hlcdDirectory, ringId, HydraRingTimeIntegrationSchemeType.FerryBorgesCastanheta, HydraRingUncertaintiesType.All, input),
-                                                               Resources.HeightStructuresCalculationService_Calculate_Error_in_height_structures_0_calculation);
+            StructuresOvertoppingCalculationInput input = CreateInput(calculation, failureMechanismSection, generalInput);
+            var exceedanceProbabilityCalculationParser = new ExceedanceProbabilityCalculationParser();
+
+            CalculationServiceHelper.PerformCalculation(
+                calculation.Name,
+                () => {
+                    HydraRingCalculationService.PerformCalculation(
+                        hlcdDirectory, 
+                        ringId, 
+                        HydraRingTimeIntegrationSchemeType.FerryBorgesCastanheta, 
+                        HydraRingUncertaintiesType.All, 
+                        input,
+                        new []
+                        {
+                            exceedanceProbabilityCalculationParser
+                        });
+
+                    VerifyOutput(exceedanceProbabilityCalculationParser.Output, calculation.Name);
+                });
+
+            return exceedanceProbabilityCalculationParser.Output;
         }
 
+        private static void VerifyOutput(ExceedanceProbabilityCalculationOutput output, string name)
+        {
+            if (output == null)
+            {
+                log.ErrorFormat(Resources.HeightStructuresCalculationService_Calculate_Error_in_height_structures_0_calculation, name);
+            }
+        }
+
         private static StructuresOvertoppingCalculationInput CreateInput(HeightStructuresCalculation calculation, FailureMechanismSection failureMechanismSection, GeneralHeightStructuresInput generalInput)
         {
             return new StructuresOvertoppingCalculationInput(
Index: Ringtoets/HydraRing/src/Ringtoets.HydraRing.Calculation/Parsers/ExceedanceProbabilityCalculationParser.cs
===================================================================
diff -u -rde4477561032a5d95d5e65e50b719724466648ed -r3d9b418d483c122040e11a7e074d666c64e9d7b5
--- Ringtoets/HydraRing/src/Ringtoets.HydraRing.Calculation/Parsers/ExceedanceProbabilityCalculationParser.cs	(.../ExceedanceProbabilityCalculationParser.cs)	(revision de4477561032a5d95d5e65e50b719724466648ed)
+++ Ringtoets/HydraRing/src/Ringtoets.HydraRing.Calculation/Parsers/ExceedanceProbabilityCalculationParser.cs	(.../ExceedanceProbabilityCalculationParser.cs)	(revision 3d9b418d483c122040e11a7e074d666c64e9d7b5)
@@ -23,18 +23,18 @@
 using System.Collections.Generic;
 using System.Data;
 using System.Data.SQLite;
+using System.IO;
 using Ringtoets.HydraRing.Calculation.Data.Output;
+using Ringtoets.HydraRing.Calculation.Services;
 
 namespace Ringtoets.HydraRing.Calculation.Parsers
 {
     /// <summary>
     /// Parser for the output of a Hydra-Ring type I calculation via Hydra-Ring:
     /// Given a set of random variables, compute the probability of failure.
     /// </summary>
-    internal class ExceedanceProbabilityCalculationParser
+    public class ExceedanceProbabilityCalculationParser : IHydraRingFileParser
     {
-        private ExceedanceProbabilityCalculationOutput output;
-
         private const string betaResultQuery = "SELECT BetaId, RingCombinMethod, PresentationSectionId, MainMechanismId, MainMechanismCombinMethod, MechanismId, LayerId, AlternativeId, Beta " +
                                                "FROM BetaResults " +
                                                "WHERE SectionId = @SectionId " +
@@ -46,29 +46,24 @@
                                                  "ORDER BY BetaId, VariableId, LoadVariableId;";
 
         /// <summary>
-        /// Tries to parse an <see cref="ExceedanceProbabilityCalculationOutput"/> object from the provided <paramref name="outputFilePath"/> and <paramref name="sectionId"/>.
+        /// Gets the output of a successful parse of the output file.
         /// </summary>
-        /// <param name="outputFilePath">The path to the file which contains the output of the Hydra-Ring type I calculation.</param>
-        /// <param name="sectionId">The section id to get the <see cref="ExceedanceProbabilityCalculationOutput"/> object for.</param>
-        public void Parse(string outputFilePath, int sectionId)
+        /// <returns>A <see cref="ExceedanceProbabilityCalculationOutput"/> corresponding to the section id if <see cref="Parse"/> executed
+        /// successfully; or <c>null</c> otherwise.</returns>
+        public ExceedanceProbabilityCalculationOutput Output { get; private set; }
+
+        public void Parse(string workingDirectory, int sectionId)
         {
             try
             {
-                Output = DoParse(outputFilePath, sectionId);
+                Output = DoParse(Path.Combine(workingDirectory, HydraRingFileName.OutputDatabaseFileName), sectionId);
             }
             catch
             {
                 // ignored
             }
         }
 
-        /// <summary>
-        /// Gets the output of a successful parse of the output file.
-        /// </summary>
-        /// <returns>A <see cref="ExceedanceProbabilityCalculationOutput"/> corresponding to the section id if <see cref="Parse"/> executed
-        /// successfully; or <c>null</c> otherwise.</returns>
-        public ExceedanceProbabilityCalculationOutput Output { get; private set; }
-
         private static ExceedanceProbabilityCalculationOutput DoParse(string outputFilePath, int sectionId)
         {
             using (var sqLiteConnection = CreateConnection(outputFilePath))
Index: Ringtoets/HydraRing/src/Ringtoets.HydraRing.Calculation/Parsers/IHydraRingFileParser.cs
===================================================================
diff -u
--- Ringtoets/HydraRing/src/Ringtoets.HydraRing.Calculation/Parsers/IHydraRingFileParser.cs	(revision 0)
+++ Ringtoets/HydraRing/src/Ringtoets.HydraRing.Calculation/Parsers/IHydraRingFileParser.cs	(revision 3d9b418d483c122040e11a7e074d666c64e9d7b5)
@@ -0,0 +1,12 @@
+namespace Ringtoets.HydraRing.Calculation.Parsers
+{
+    public interface IHydraRingFileParser
+    {
+        /// <summary>
+        /// Tries to parse output from a file in the <paramref name="workingDirectory"/> based on a <paramref name="sectionId"/>.
+        /// </summary>
+        /// <param name="workingDirectory">The path to the file which contains the output of the Hydra-Ring type I calculation.</param>
+        /// <param name="sectionId">The section id to get the output for.</param>
+        void Parse(string workingDirectory, int sectionId);
+    }
+}
\ No newline at end of file
Index: Ringtoets/HydraRing/src/Ringtoets.HydraRing.Calculation/Parsers/TargetProbabilityCalculationParser.cs
===================================================================
diff -u -rde4477561032a5d95d5e65e50b719724466648ed -r3d9b418d483c122040e11a7e074d666c64e9d7b5
--- Ringtoets/HydraRing/src/Ringtoets.HydraRing.Calculation/Parsers/TargetProbabilityCalculationParser.cs	(.../TargetProbabilityCalculationParser.cs)	(revision de4477561032a5d95d5e65e50b719724466648ed)
+++ Ringtoets/HydraRing/src/Ringtoets.HydraRing.Calculation/Parsers/TargetProbabilityCalculationParser.cs	(.../TargetProbabilityCalculationParser.cs)	(revision 3d9b418d483c122040e11a7e074d666c64e9d7b5)
@@ -24,25 +24,28 @@
 using System.IO;
 using System.Linq;
 using Ringtoets.HydraRing.Calculation.Data.Output;
+using Ringtoets.HydraRing.Calculation.Services;
 
 namespace Ringtoets.HydraRing.Calculation.Parsers
 {
     /// <summary>
     /// Parser for the output of a Hydra-Ring type II calculation:
     /// Iterate towards a target probability, provided as reliability index.
     /// </summary>
-    internal class TargetProbabilityCalculationParser
+    public class TargetProbabilityCalculationParser : IHydraRingFileParser
     {
         /// <summary>
-        /// Tries to parse a <see cref="TargetProbabilityCalculationOutput"/> object from the provided <paramref name="outputFilePath"/> for the provided <paramref name="sectionId"/>.
+        /// Gets the output of a successful parse of the output file.
         /// </summary>
-        /// <param name="outputFilePath">The path to the file which contains the output of the Hydra-Ring type II calculation.</param>
-        /// <param name="sectionId">The section id to get the <see cref="TargetProbabilityCalculationOutput"/> object for.</param>
-        public void Parse(string outputFilePath, int sectionId)
+        /// <returns>A <see cref="TargetProbabilityCalculationOutput"/> corresponding to the section id if <see cref="Parse"/> executed
+        /// successfully; or <c>null</c> otherwise.</returns>
+        public TargetProbabilityCalculationOutput Output { get; private set; }
+
+        public void Parse(string workingDirectory, int sectionId)
         {
             try
             {
-                using (var streamReader = new StreamReader(outputFilePath))
+                using (var streamReader = new StreamReader(Path.Combine(workingDirectory, HydraRingFileName.DesignTablesFileName)))
                 {
                     var fileContents = streamReader.ReadToEnd();
                     var lines = fileContents.Split('\n');
@@ -64,13 +67,6 @@
             }
         }
 
-        /// <summary>
-        /// Gets the output of a successful parse of the output file.
-        /// </summary>
-        /// <returns>A <see cref="TargetProbabilityCalculationOutput"/> corresponding to the section id if <see cref="Parse"/> executed
-        /// successfully; or <c>null</c> otherwise.</returns>
-        public TargetProbabilityCalculationOutput Output { get; private set; }
-
         private static double GetDoubleValueFromElement(string element)
         {
             return double.Parse(element, CultureInfo.InvariantCulture);
Index: Ringtoets/HydraRing/src/Ringtoets.HydraRing.Calculation/Ringtoets.HydraRing.Calculation.csproj
===================================================================
diff -u -rde4477561032a5d95d5e65e50b719724466648ed -r3d9b418d483c122040e11a7e074d666c64e9d7b5
--- Ringtoets/HydraRing/src/Ringtoets.HydraRing.Calculation/Ringtoets.HydraRing.Calculation.csproj	(.../Ringtoets.HydraRing.Calculation.csproj)	(revision de4477561032a5d95d5e65e50b719724466648ed)
+++ Ringtoets/HydraRing/src/Ringtoets.HydraRing.Calculation/Ringtoets.HydraRing.Calculation.csproj	(.../Ringtoets.HydraRing.Calculation.csproj)	(revision 3d9b418d483c122040e11a7e074d666c64e9d7b5)
@@ -65,6 +65,7 @@
     <Compile Include="Data\Output\ExceedanceProbabilityCalculationOutputBase.cs" />
     <Compile Include="Data\Output\TargetProbabilityCalculationOutput.cs" />
     <Compile Include="Parsers\ExceedanceProbabilityCalculationParser.cs" />
+    <Compile Include="Parsers\IHydraRingFileParser.cs" />
     <Compile Include="Services\HydraRingCalculationService.cs" />
     <Compile Include="Data\Input\Hydraulics\AssessmentLevelCalculationInput.cs" />
     <Compile Include="Data\Input\HydraRingCalculationInput.cs" />
Index: Ringtoets/HydraRing/src/Ringtoets.HydraRing.Calculation/Services/HydraRingCalculationService.cs
===================================================================
diff -u -rde4477561032a5d95d5e65e50b719724466648ed -r3d9b418d483c122040e11a7e074d666c64e9d7b5
--- Ringtoets/HydraRing/src/Ringtoets.HydraRing.Calculation/Services/HydraRingCalculationService.cs	(.../HydraRingCalculationService.cs)	(revision de4477561032a5d95d5e65e50b719724466648ed)
+++ Ringtoets/HydraRing/src/Ringtoets.HydraRing.Calculation/Services/HydraRingCalculationService.cs	(.../HydraRingCalculationService.cs)	(revision 3d9b418d483c122040e11a7e074d666c64e9d7b5)
@@ -19,6 +19,7 @@
 // Stichting Deltares and remain full property of Stichting Deltares at all times.
 // All rights reserved.
 
+using System.Collections.Generic;
 using System.Diagnostics;
 using System.IO;
 using Ringtoets.HydraRing.Calculation.Data;
@@ -44,15 +45,17 @@
         /// <param name="timeIntegrationSchemeType">The <see cref="HydraRingTimeIntegrationSchemeType"/> to use while executing the calculation.</param>
         /// <param name="uncertaintiesType">The <see cref="HydraRingUncertaintiesType"/> to use while executing the calculation.</param>
         /// <param name="targetProbabilityCalculationInput">The input of the calculation to perform.</param>
+        /// <param name="parsers">Parsers that will be invoked after the Hydra-Ring calculation has ran.</param>
         /// <returns>A <see cref="TargetProbabilityCalculationOutput"/> on a successful calculation, <c>null</c> otherwise.</returns>
-        public static TargetProbabilityCalculationOutput PerformCalculation(string hlcdDirectory, string ringId,
-                                                                             HydraRingTimeIntegrationSchemeType timeIntegrationSchemeType,
-                                                                             HydraRingUncertaintiesType uncertaintiesType,
-                                                                             TargetProbabilityCalculationInput targetProbabilityCalculationInput)
+        public static void PerformCalculation(
+            string hlcdDirectory,
+            string ringId,
+            HydraRingTimeIntegrationSchemeType timeIntegrationSchemeType,
+            HydraRingUncertaintiesType uncertaintiesType,
+            HydraRingCalculationInput targetProbabilityCalculationInput,
+            IEnumerable<IHydraRingFileParser> parsers)
         {
             var sectionId = targetProbabilityCalculationInput.Section.SectionId;
-
-            // Create a working directory
             var workingDirectory = CreateWorkingDirectory();
 
             var hydraRingInitializationService = new HydraRingInitializationService(targetProbabilityCalculationInput.FailureMechanismType, sectionId, hlcdDirectory, workingDirectory);
@@ -64,48 +67,10 @@
 
             PerformCalculation(workingDirectory, hydraRingInitializationService);
 
-            // Parse and return the output
-            var targetProbabilityCalculationParser = new TargetProbabilityCalculationParser();
-            targetProbabilityCalculationParser.Parse(hydraRingInitializationService.OutputFilePath, targetProbabilityCalculationInput.Section.SectionId);
-            return targetProbabilityCalculationParser.Output;
+            ExecuteParsers(parsers, hydraRingInitializationService.TemporaryWorkingDirectory, targetProbabilityCalculationInput.Section.SectionId);
         }
 
         /// <summary>
-        /// This method performs a type I calculation via Hydra-Ring:
-        /// Given a set of random variables, compute the probability of failure.
-        /// </summary>
-        /// <param name="hlcdDirectory">The directory of the HLCD file that should be used for performing the calculation.</param>
-        /// <param name="ringId">The id of the ring to perform the calculation for.</param>
-        /// <param name="timeIntegrationSchemeType">The <see cref="HydraRingTimeIntegrationSchemeType"/> to use while executing the calculation.</param>
-        /// <param name="uncertaintiesType">The <see cref="HydraRingUncertaintiesType"/> to use while executing the calculation.</param>
-        /// <param name="exceedanceProbabilityCalculationInput">The input of the calculation to perform.</param>
-        /// <returns>A <see cref="ExceedanceProbabilityCalculationOutput"/> on a successful calculation, <c>null</c> otherwise.</returns>
-        public static ExceedanceProbabilityCalculationOutput PerformCalculation(string hlcdDirectory, string ringId,
-                                                                                 HydraRingTimeIntegrationSchemeType timeIntegrationSchemeType,
-                                                                                 HydraRingUncertaintiesType uncertaintiesType,
-                                                                                 ExceedanceProbabilityCalculationInput exceedanceProbabilityCalculationInput)
-        {
-            var sectionId = exceedanceProbabilityCalculationInput.Section.SectionId;
-
-            // Create a working directory
-            var workingDirectory = CreateWorkingDirectory();
-
-            // Write the initialization script
-            var hydraRingInitializationService = new HydraRingInitializationService(exceedanceProbabilityCalculationInput.FailureMechanismType, sectionId, hlcdDirectory, workingDirectory);
-            hydraRingInitializationService.WriteInitializationScript();
-
-            var hydraRingConfigurationService = new HydraRingConfigurationService(ringId, timeIntegrationSchemeType, uncertaintiesType);
-            hydraRingConfigurationService.AddHydraRingCalculationInput(exceedanceProbabilityCalculationInput);
-            hydraRingConfigurationService.WriteDataBaseCreationScript(hydraRingInitializationService.DatabaseCreationScriptFilePath);
-
-            PerformCalculation(workingDirectory, hydraRingInitializationService);
-
-            var exceedanceProbabilityCalculationParser = new ExceedanceProbabilityCalculationParser();
-            exceedanceProbabilityCalculationParser.Parse(hydraRingInitializationService.OutputDataBasePath, exceedanceProbabilityCalculationInput.Section.SectionId);
-            return exceedanceProbabilityCalculationParser.Output;
-        }
-
-        /// <summary>
         /// Cancels any currently running Hydra-Ring calculation.
         /// </summary>
         public static void CancelRunningCalculation()
@@ -116,6 +81,14 @@
             }
         }
 
+        private static void ExecuteParsers(IEnumerable<IHydraRingFileParser> parsers, string workingDirectory, int sectionId)
+        {
+            foreach (var parser in parsers)
+            {
+                parser.Parse(workingDirectory, sectionId);
+            }
+        }
+
         private static void PerformCalculation(string workingDirectory, HydraRingInitializationService hydraRingInitializationService)
         {
             hydraRingProcess = HydraRingProcessFactory.Create(
Index: Ringtoets/HydraRing/src/Ringtoets.HydraRing.Calculation/Services/HydraRingInitializationService.cs
===================================================================
diff -u -rde4477561032a5d95d5e65e50b719724466648ed -r3d9b418d483c122040e11a7e074d666c64e9d7b5
--- Ringtoets/HydraRing/src/Ringtoets.HydraRing.Calculation/Services/HydraRingInitializationService.cs	(.../HydraRingInitializationService.cs)	(revision de4477561032a5d95d5e65e50b719724466648ed)
+++ Ringtoets/HydraRing/src/Ringtoets.HydraRing.Calculation/Services/HydraRingInitializationService.cs	(.../HydraRingInitializationService.cs)	(revision 3d9b418d483c122040e11a7e074d666c64e9d7b5)
@@ -20,9 +20,11 @@
 // All rights reserved.
 
 using System;
+using System.Collections.Generic;
 using System.IO;
 using System.Reflection;
 using Ringtoets.HydraRing.Calculation.Data;
+using Ringtoets.HydraRing.Calculation.Parsers;
 using Ringtoets.HydraRing.Calculation.Providers;
 
 namespace Ringtoets.HydraRing.Calculation.Services
@@ -48,7 +50,6 @@
         private readonly int sectionId;
 
         // Working directories
-        private readonly string temporaryWorkingDirectory;
         private readonly string hydraRingDirectory;
         private readonly string hlcdDirectory;
 
@@ -58,13 +59,14 @@
         /// <param name="failureMechanismType">The failure mechanism type.</param>
         /// <param name="sectionId">The section id.</param>
         /// <param name="hlcdDirectory">The HLCD directory.</param>
-        /// <param name="temporaryWorkingDirectory">The working directory.</param>
-        public HydraRingInitializationService(HydraRingFailureMechanismType failureMechanismType, int sectionId, string hlcdDirectory, string temporaryWorkingDirectory)
+        /// <param name="temporaryTemporaryWorkingDirectory">The working directory.</param>
+        public HydraRingInitializationService(HydraRingFailureMechanismType failureMechanismType, int sectionId, string hlcdDirectory, string temporaryTemporaryWorkingDirectory)
         {
             mechanismId = new FailureMechanismDefaultsProvider().GetFailureMechanismDefaults(failureMechanismType).MechanismId;
             this.sectionId = sectionId;
 
-            this.temporaryWorkingDirectory = temporaryWorkingDirectory;
+            TemporaryWorkingDirectory = temporaryTemporaryWorkingDirectory;
+
             this.hlcdDirectory = hlcdDirectory;
             hydraRingDirectory = Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location), @"HydraRing");
         }
@@ -76,7 +78,7 @@
         {
             get
             {
-                return Path.Combine(temporaryWorkingDirectory, sectionId + iniFileExtension);
+                return Path.Combine(TemporaryWorkingDirectory, sectionId + iniFileExtension);
             }
         }
 
@@ -87,7 +89,7 @@
         {
             get
             {
-                return Path.Combine(temporaryWorkingDirectory, sectionId + databaseFileExtension);
+                return Path.Combine(TemporaryWorkingDirectory, sectionId + databaseFileExtension);
             }
         }
 
@@ -98,7 +100,7 @@
         {
             get
             {
-                return Path.Combine(temporaryWorkingDirectory, sectionId + logFileExtension);
+                return Path.Combine(TemporaryWorkingDirectory, sectionId + logFileExtension);
             }
         }
 
@@ -109,7 +111,7 @@
         {
             get
             {
-                return Path.Combine(temporaryWorkingDirectory, HydraRingFileName.DesignTablesFileName);
+                return Path.Combine(TemporaryWorkingDirectory, HydraRingFileName.DesignTablesFileName);
             }
         }
 
@@ -120,7 +122,7 @@
         {
             get
             {
-                return Path.Combine(temporaryWorkingDirectory, HydraRingFileName.OutputDatabaseFileName);
+                return Path.Combine(TemporaryWorkingDirectory, HydraRingFileName.OutputDatabaseFileName);
             }
         }
 
@@ -158,6 +160,12 @@
         }
 
         /// <summary>
+        /// Gets the directory in which HydraRing will place temporary input and output files created during a
+        /// calculation.
+        /// </summary>
+        public string TemporaryWorkingDirectory { get; private set; }
+
+        /// <summary>
         /// Generates the initialization script necessary for performing Hydra-Ring calculations.
         /// </summary>
         /// <returns>The initialization script.</returns>
Index: Ringtoets/HydraRing/test/Ringtoets.HydraRing.Calculation.Test/Parsers/ExceedanceProbabilityCalculationParserTest.cs
===================================================================
diff -u -rde4477561032a5d95d5e65e50b719724466648ed -r3d9b418d483c122040e11a7e074d666c64e9d7b5
--- Ringtoets/HydraRing/test/Ringtoets.HydraRing.Calculation.Test/Parsers/ExceedanceProbabilityCalculationParserTest.cs	(.../ExceedanceProbabilityCalculationParserTest.cs)	(revision de4477561032a5d95d5e65e50b719724466648ed)
+++ Ringtoets/HydraRing/test/Ringtoets.HydraRing.Calculation.Test/Parsers/ExceedanceProbabilityCalculationParserTest.cs	(.../ExceedanceProbabilityCalculationParserTest.cs)	(revision 3d9b418d483c122040e11a7e074d666c64e9d7b5)
@@ -25,12 +25,14 @@
 using NUnit.Framework;
 using Ringtoets.HydraRing.Calculation.Data.Output;
 using Ringtoets.HydraRing.Calculation.Parsers;
+using Ringtoets.HydraRing.Calculation.Services;
 
 namespace Ringtoets.HydraRing.Calculation.Test.Parsers
 {
     [TestFixture]
     public class ExceedanceProbabilityCalculationParserTest
     {
+        private const string workingDirectory = "tempDir";
         private readonly string testDataPath = Path.Combine(TestHelper.GetTestDataPath(TestDataPath.Ringtoets.HydraRing.Calculation, "Parsers"), "ExceedanceProbabilityCalculationParser");
 
         [Test]
@@ -40,44 +42,50 @@
             var parser = new ExceedanceProbabilityCalculationParser();
 
             // Assert
+            Assert.IsInstanceOf<IHydraRingFileParser>(parser);
             Assert.IsNull(parser.Output);
         }
 
         [Test]
         public void Parse_NotExistingOutputFile_OutputNull()
         {
             // Setup
-            var filePath = Path.Combine(testDataPath, "notExisting.sqlite");
             var exceedanceProbabilityCalculationParser = new ExceedanceProbabilityCalculationParser();
 
-            // Call
-            exceedanceProbabilityCalculationParser.Parse(filePath, 1);
+            using (new DirectoryDisposeHelper(workingDirectory))
+            {
+                // Call
+                exceedanceProbabilityCalculationParser.Parse(workingDirectory, 1);
+            }
 
             // Assert
             Assert.IsNull(exceedanceProbabilityCalculationParser.Output);
-            Assert.IsFalse(File.Exists(testDataPath));
         }
 
         [Test]
         public void Parse_EmptyOutputFile_OutputNull()
         {
             // Setup
-            var filePath = Path.Combine(testDataPath, "empty.sqlite");
             var exceedanceProbabilityCalculationParser = new ExceedanceProbabilityCalculationParser();
+            var testFile = "empty.sqlite";
 
-            // Call
-            exceedanceProbabilityCalculationParser.Parse(filePath, 1);
+            using (new DirectoryDisposeHelper(workingDirectory))
+            {
+                CopyTestInputToTemporaryOutput(testFile);
 
-            // Assert
-            Assert.IsNull(exceedanceProbabilityCalculationParser.Output);
-            Assert.IsTrue(TestHelper.CanOpenFileForWrite(filePath));
+                // Call
+                exceedanceProbabilityCalculationParser.Parse(workingDirectory, 1);
+
+                // Assert
+                Assert.IsNull(exceedanceProbabilityCalculationParser.Output);
+                Assert.IsTrue(TestHelper.CanOpenFileForWrite(Path.Combine(workingDirectory, testFile)));
+            }
         }
 
         [Test]
         public void Parse_ExampleCompleteOutputFile_ExpectedExceedanceProbabilityCalculationOutputSet()
         {
             // Setup
-            var filePath = Path.Combine(testDataPath, "complete.sqlite");
             var ringCombinMethod = 0;
             var presentationSectionId = 1;
             var mainMechanismId = 101;
@@ -99,72 +107,97 @@
             };
 
             var exceedanceProbabilityCalculationParser = new ExceedanceProbabilityCalculationParser();
+            var testFile = "complete.sqlite";
 
-            // Call
-            exceedanceProbabilityCalculationParser.Parse(filePath, sectionId);
+            using (new DirectoryDisposeHelper(workingDirectory))
+            {
+                CopyTestInputToTemporaryOutput(testFile);
 
-            // Assert
-            ExceedanceProbabilityCalculationOutput exceedanceProbabilityCalculationOutput = exceedanceProbabilityCalculationParser.Output;
-            Assert.IsNotNull(exceedanceProbabilityCalculationOutput);
-            Assert.AreEqual(ringCombinMethod, exceedanceProbabilityCalculationOutput.RingCombinMethod);
-            Assert.AreEqual(presentationSectionId, exceedanceProbabilityCalculationOutput.PresentationSectionId);
-            Assert.AreEqual(mainMechanismId, exceedanceProbabilityCalculationOutput.MainMechanismId);
-            Assert.AreEqual(mainMechanismCombinMethod, exceedanceProbabilityCalculationOutput.MainMechanismCombinMethod);
-            Assert.AreEqual(mechanismId, exceedanceProbabilityCalculationOutput.MechanismId);
-            Assert.AreEqual(layerId, exceedanceProbabilityCalculationOutput.LayerId);
-            Assert.AreEqual(alternativeId, exceedanceProbabilityCalculationOutput.AlternativeId);
-            Assert.AreEqual(beta, exceedanceProbabilityCalculationOutput.Beta);
+                // Call
+                exceedanceProbabilityCalculationParser.Parse(workingDirectory, sectionId);
 
-            Assert.AreEqual(alphaValues.Count, exceedanceProbabilityCalculationOutput.Alphas.Count);
-            for (var i = 0; i < alphaValues.Count; i++)
-            {
-                var expectedAlpha = alphaValues[i];
-                var actualAlpha = exceedanceProbabilityCalculationOutput.Alphas[i];
+                // Assert
+                ExceedanceProbabilityCalculationOutput exceedanceProbabilityCalculationOutput = exceedanceProbabilityCalculationParser.Output;
+                Assert.IsNotNull(exceedanceProbabilityCalculationOutput);
+                Assert.AreEqual(ringCombinMethod, exceedanceProbabilityCalculationOutput.RingCombinMethod);
+                Assert.AreEqual(presentationSectionId, exceedanceProbabilityCalculationOutput.PresentationSectionId);
+                Assert.AreEqual(mainMechanismId, exceedanceProbabilityCalculationOutput.MainMechanismId);
+                Assert.AreEqual(mainMechanismCombinMethod, exceedanceProbabilityCalculationOutput.MainMechanismCombinMethod);
+                Assert.AreEqual(mechanismId, exceedanceProbabilityCalculationOutput.MechanismId);
+                Assert.AreEqual(layerId, exceedanceProbabilityCalculationOutput.LayerId);
+                Assert.AreEqual(alternativeId, exceedanceProbabilityCalculationOutput.AlternativeId);
+                Assert.AreEqual(beta, exceedanceProbabilityCalculationOutput.Beta);
 
-                Assert.AreEqual(expectedAlpha.RingCombinMethod, actualAlpha.RingCombinMethod);
-                Assert.AreEqual(expectedAlpha.PresentationSectionId, actualAlpha.PresentationSectionId);
-                Assert.AreEqual(expectedAlpha.MainMechanismId, actualAlpha.MainMechanismId);
-                Assert.AreEqual(expectedAlpha.MainMechanismCombinMethod, actualAlpha.MainMechanismCombinMethod);
-                Assert.AreEqual(expectedAlpha.MechanismId, actualAlpha.MechanismId);
-                Assert.AreEqual(expectedAlpha.LayerId, actualAlpha.LayerId);
-                Assert.AreEqual(expectedAlpha.AlternativeId, actualAlpha.AlternativeId);
-                Assert.AreEqual(expectedAlpha.VariableId, actualAlpha.VariableId);
-                Assert.AreEqual(expectedAlpha.LoadVariableId, actualAlpha.LoadVariableId);
-                Assert.AreEqual(expectedAlpha.Alpha, actualAlpha.Alpha);
-            }
+                Assert.AreEqual(alphaValues.Count, exceedanceProbabilityCalculationOutput.Alphas.Count);
+                for (var i = 0; i < alphaValues.Count; i++)
+                {
+                    var expectedAlpha = alphaValues[i];
+                    var actualAlpha = exceedanceProbabilityCalculationOutput.Alphas[i];
 
-            Assert.IsTrue(TestHelper.CanOpenFileForWrite(filePath));
+                    Assert.AreEqual(expectedAlpha.RingCombinMethod, actualAlpha.RingCombinMethod);
+                    Assert.AreEqual(expectedAlpha.PresentationSectionId, actualAlpha.PresentationSectionId);
+                    Assert.AreEqual(expectedAlpha.MainMechanismId, actualAlpha.MainMechanismId);
+                    Assert.AreEqual(expectedAlpha.MainMechanismCombinMethod, actualAlpha.MainMechanismCombinMethod);
+                    Assert.AreEqual(expectedAlpha.MechanismId, actualAlpha.MechanismId);
+                    Assert.AreEqual(expectedAlpha.LayerId, actualAlpha.LayerId);
+                    Assert.AreEqual(expectedAlpha.AlternativeId, actualAlpha.AlternativeId);
+                    Assert.AreEqual(expectedAlpha.VariableId, actualAlpha.VariableId);
+                    Assert.AreEqual(expectedAlpha.LoadVariableId, actualAlpha.LoadVariableId);
+                    Assert.AreEqual(expectedAlpha.Alpha, actualAlpha.Alpha);
+                }
+
+                Assert.IsTrue(TestHelper.CanOpenFileForWrite(Path.Combine(workingDirectory, testFile)));
+            }
         }
 
         [Test]
         public void Parse_FileWithoutTableAlphaResults_OutputNull()
         {
             // Setup
-            var filePath = Path.Combine(testDataPath, "withoutAlphaResults.sqlite");
+            var testFile = "withoutAlphaResults.sqlite";
             var exceedanceProbabilityCalculationParser = new ExceedanceProbabilityCalculationParser();
 
-            // Call
-            exceedanceProbabilityCalculationParser.Parse(filePath, 1);
+            using (new DirectoryDisposeHelper(workingDirectory))
+            {
+                // Call
+                exceedanceProbabilityCalculationParser.Parse(workingDirectory, 1);
 
-            // Assert
-            Assert.IsNull(exceedanceProbabilityCalculationParser.Output);
-            Assert.IsTrue(TestHelper.CanOpenFileForWrite(filePath));
+                // Assert
+                Assert.IsNull(exceedanceProbabilityCalculationParser.Output);
+                Assert.IsTrue(TestHelper.CanOpenFileForWrite(Path.Combine(workingDirectory, testFile)));
+            }
         }
 
         [Test]
         public void Parse_ExampleHydraRingOutputFileNotContainingSectionId_OutputNull()
         {
             // Setup
             var sectionId = 1;
-            var filePath = Path.Combine(testDataPath, "complete.sqlite");
+            var testFile = "complete.sqlite";
             var exceedanceProbabilityCalculationParser = new ExceedanceProbabilityCalculationParser();
 
-            // Call
-            exceedanceProbabilityCalculationParser.Parse(filePath, sectionId);
+            using (new DirectoryDisposeHelper(workingDirectory))
+            {
+                // Call
+                exceedanceProbabilityCalculationParser.Parse(workingDirectory, sectionId);
 
-            // Assert
-            Assert.IsNull(exceedanceProbabilityCalculationParser.Output);
-            Assert.IsTrue(TestHelper.CanOpenFileForWrite(filePath));
+                // Assert
+                Assert.IsNull(exceedanceProbabilityCalculationParser.Output);
+                Assert.IsTrue(TestHelper.CanOpenFileForWrite(Path.Combine(workingDirectory, testFile)));
+            }
         }
+
+        /// <summary>
+        /// Copies the testfile from the test directory to the working directory.
+        /// </summary>
+        /// <param name="testFile">The name of the test's input file.</param>
+        /// <remarks>The copied file is removed from the working directory by using the <see cref="DirectoryDisposeHelper"/>,
+        /// which recursively removes all files in the directory.</remarks>
+        private void CopyTestInputToTemporaryOutput(string testFile)
+        {
+            var inputFilePath = Path.Combine(testDataPath, testFile);
+            var outputFilePath = Path.Combine(workingDirectory, HydraRingFileName.OutputDatabaseFileName);
+            File.Copy(inputFilePath, outputFilePath);
+        }
     }
 }
\ No newline at end of file
Index: Ringtoets/HydraRing/test/Ringtoets.HydraRing.Calculation.Test/Parsers/TargetProbabilityCalculationParserTest.cs
===================================================================
diff -u -rde4477561032a5d95d5e65e50b719724466648ed -r3d9b418d483c122040e11a7e074d666c64e9d7b5
--- Ringtoets/HydraRing/test/Ringtoets.HydraRing.Calculation.Test/Parsers/TargetProbabilityCalculationParserTest.cs	(.../TargetProbabilityCalculationParserTest.cs)	(revision de4477561032a5d95d5e65e50b719724466648ed)
+++ Ringtoets/HydraRing/test/Ringtoets.HydraRing.Calculation.Test/Parsers/TargetProbabilityCalculationParserTest.cs	(.../TargetProbabilityCalculationParserTest.cs)	(revision 3d9b418d483c122040e11a7e074d666c64e9d7b5)
@@ -23,22 +23,38 @@
 using Core.Common.TestUtil;
 using NUnit.Framework;
 using Ringtoets.HydraRing.Calculation.Parsers;
+using Ringtoets.HydraRing.Calculation.Services;
 
 namespace Ringtoets.HydraRing.Calculation.Test.Parsers
 {
     [TestFixture]
     public class TargetProbabilityCalculationParserTest
     {
+        private const string workingDirectory = "tempDir";
         private readonly string testDataPath = Path.Combine(TestHelper.GetTestDataPath(TestDataPath.Ringtoets.HydraRing.Calculation, "Parsers"), "TargetProbabilityCalculationParser");
 
         [Test]
+        public void DefaultConstructor_SetDefaultValues()
+        {
+            // Call
+            var parser = new TargetProbabilityCalculationParser();
+
+            // Assert
+            Assert.IsInstanceOf<IHydraRingFileParser>(parser);
+            Assert.IsNull(parser.Output);
+        }
+
+        [Test]
         public void Parse_NotExistingOutputFile_OutputNull()
         {
             // Setup
             var targetProbabilityCalculationParser = new TargetProbabilityCalculationParser();
 
-            // Call
-            targetProbabilityCalculationParser.Parse(Path.Combine(testDataPath, "notExisting.txt"), 1);
+            using (new DirectoryDisposeHelper(workingDirectory))
+            {
+                // Call
+                targetProbabilityCalculationParser.Parse(workingDirectory, 1);
+            }
 
             // Assert
             Assert.IsNull(targetProbabilityCalculationParser.Output);
@@ -50,9 +66,14 @@
             // Setup
             var targetProbabilityCalculationParser = new TargetProbabilityCalculationParser();
 
-            // Call
-            targetProbabilityCalculationParser.Parse(Path.Combine(testDataPath, "empty.txt"), 1);
+            using (new DirectoryDisposeHelper(workingDirectory))
+            {
+                CopyTestInputToTemporaryOutput("empty.txt");
 
+                // Call
+                targetProbabilityCalculationParser.Parse(workingDirectory, 1);
+            }
+
             // Assert
             Assert.IsNull(targetProbabilityCalculationParser.Output);
         }
@@ -63,12 +84,16 @@
         public void Parse_ExampleHydraRingOutputFileContainingSectionIds_ReturnsExpectedTargetProbabilityCalculationResult(int sectionId, double result, double actual)
         {
             // Setup
-            var outputFilePath = Path.Combine(testDataPath, "exampleOutputTable.txt");
             var targetProbabilityCalculationParser = new TargetProbabilityCalculationParser();
 
-            // Call
-            targetProbabilityCalculationParser.Parse(outputFilePath, sectionId);
+            using (new DirectoryDisposeHelper(workingDirectory))
+            {
+                CopyTestInputToTemporaryOutput("exampleOutputTable.txt");
 
+                // Call
+                targetProbabilityCalculationParser.Parse(workingDirectory, sectionId);
+            }
+
             // Assert
             var targetProbabilityCalculationOutput = targetProbabilityCalculationParser.Output;
             Assert.IsNotNull(targetProbabilityCalculationOutput);
@@ -82,11 +107,29 @@
             // Setup
             var targetProbabilityCalculationParser = new TargetProbabilityCalculationParser();
 
-            // Call
-            targetProbabilityCalculationParser.Parse(Path.Combine(testDataPath, "exampleOutputTable.txt"), 2);
+            using (new DirectoryDisposeHelper(workingDirectory))
+            {
+                CopyTestInputToTemporaryOutput("exampleOutputTable.txt");
 
+                // Call
+                targetProbabilityCalculationParser.Parse(workingDirectory, 2);
+            }
+
             // Assert
             Assert.IsNull(targetProbabilityCalculationParser.Output);
         }
+
+        /// <summary>
+        /// Copies the testfile from the test directory to the working directory.
+        /// </summary>
+        /// <param name="testFile">The name of the test's input file.</param>
+        /// <remarks>The copied file is removed from the working directory by using the <see cref="DirectoryDisposeHelper"/>,
+        /// which recursively removes all files in the directory.</remarks>
+        private void CopyTestInputToTemporaryOutput(string testFile)
+        {
+            var inputFilePath = Path.Combine(testDataPath, testFile);
+            var outputFilePath = Path.Combine(workingDirectory, HydraRingFileName.DesignTablesFileName);
+            File.Copy(inputFilePath, outputFilePath);
+        }
     }
 }
\ No newline at end of file
Index: Ringtoets/Integration/src/Ringtoets.Integration.Service/DesignWaterLevelCalculationService.cs
===================================================================
diff -u -re88fa1dfcf62085f7fabc453b73dbc8ac3ff9223 -r3d9b418d483c122040e11a7e074d666c64e9d7b5
--- Ringtoets/Integration/src/Ringtoets.Integration.Service/DesignWaterLevelCalculationService.cs	(.../DesignWaterLevelCalculationService.cs)	(revision e88fa1dfcf62085f7fabc453b73dbc8ac3ff9223)
+++ Ringtoets/Integration/src/Ringtoets.Integration.Service/DesignWaterLevelCalculationService.cs	(.../DesignWaterLevelCalculationService.cs)	(revision 3d9b418d483c122040e11a7e074d666c64e9d7b5)
@@ -20,11 +20,13 @@
 // All rights reserved.
 
 using System.IO;
+using log4net;
 using Ringtoets.Common.Data.AssessmentSection;
 using Ringtoets.Common.Service;
 using Ringtoets.HydraRing.Calculation.Data;
 using Ringtoets.HydraRing.Calculation.Data.Input.Hydraulics;
 using Ringtoets.HydraRing.Calculation.Data.Output;
+using Ringtoets.HydraRing.Calculation.Parsers;
 using Ringtoets.HydraRing.Calculation.Services;
 using Ringtoets.HydraRing.Data;
 using Ringtoets.HydraRing.IO;
@@ -38,8 +40,10 @@
     /// <summary>
     /// Service that provides methods for performing Hydra-Ring calculations for design water level.
     /// </summary>
-    internal static class DesignWaterLevelCalculationService 
+    internal static class DesignWaterLevelCalculationService
     {
+        private static readonly ILog log = LogManager.GetLogger(typeof(DesignWaterLevelCalculationService));
+
         /// <summary>
         /// Performs validation over the values on the given <paramref name="hydraulicBoundaryDatabase"/>. Error information is logged during
         /// the execution of the operation.
@@ -79,12 +83,34 @@
         {
             var hlcdDirectory = Path.GetDirectoryName(hydraulicBoundaryDatabase.FilePath);
             var input = CreateInput(assessmentSection, hydraulicBoundaryLocation);
+            var targetProbabilityCalculationParser = new TargetProbabilityCalculationParser();
 
-            return CalculationServiceHelper.PerformCalculation(hydraulicBoundaryLocation.Id.ToString(),
-                                                               () => HydraRingCalculationService.PerformCalculation(hlcdDirectory, ringId, HydraRingTimeIntegrationSchemeType.FerryBorgesCastanheta, HydraRingUncertaintiesType.All, input),
-                                                               Resources.DesignWaterLevelCalculationService_Calculate_Error_in_design_water_level_0_calculation);
+            CalculationServiceHelper.PerformCalculation(
+                hydraulicBoundaryLocation.Id.ToString(),
+                () =>
+                {
+                    HydraRingCalculationService.PerformCalculation(
+                              hlcdDirectory, 
+                              ringId, 
+                              HydraRingTimeIntegrationSchemeType.FerryBorgesCastanheta, 
+                              HydraRingUncertaintiesType.All, 
+                              input,
+                              new[] { targetProbabilityCalculationParser });
+
+                    VerifyOutput(targetProbabilityCalculationParser.Output, hydraulicBoundaryLocation.Id.ToString());
+                });
+
+            return targetProbabilityCalculationParser.Output;
         }
 
+        private static void VerifyOutput(TargetProbabilityCalculationOutput output, string name)
+        {
+            if (output == null)
+            {
+                log.ErrorFormat(Resources.DesignWaterLevelCalculationService_Calculate_Error_in_design_water_level_0_calculation, name);
+            }
+        }
+
         private static AssessmentLevelCalculationInput CreateInput(IAssessmentSection assessmentSection, HydraulicBoundaryLocation hydraulicBoundaryLocation)
         {
             return new AssessmentLevelCalculationInput(1, hydraulicBoundaryLocation.Id, assessmentSection.FailureMechanismContribution.Norm);