Index: Ringtoets.sln
===================================================================
diff -u -r9779d1ab6b555c557e8fd18f4430ad207bd003da -ra1d8b4b58632ae45df9bde7fe7eaa69f3864507a
--- Ringtoets.sln	(.../Ringtoets.sln)	(revision 9779d1ab6b555c557e8fd18f4430ad207bd003da)
+++ Ringtoets.sln	(.../Ringtoets.sln)	(revision a1d8b4b58632ae45df9bde7fe7eaa69f3864507a)
@@ -1649,6 +1649,11 @@
 		{C90B77DA-E421-43CC-B82E-529651BC21AC} = {C90B77DA-E421-43CC-B82E-529651BC21AC}
 	EndProjectSection
 EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Ringtoets.GrassCoverErosionInwards.Service.TestUtil", "Ringtoets\GrassCoverErosionInwards\test\Ringtoets.GrassCoverErosionInwards.Service.TestUtil\Ringtoets.GrassCoverErosionInwards.Service.TestUtil.csproj", "{61506E11-2D00-44FE-AB74-44D5766DF457}"
+	ProjectSection(ProjectDependencies) = postProject
+		{C90B77DA-E421-43CC-B82E-529651BC21AC} = {C90B77DA-E421-43CC-B82E-529651BC21AC}
+	EndProjectSection
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		CreateInstaller|x86 = CreateInstaller|x86
@@ -4147,6 +4152,14 @@
 		{52093DA6-D545-476A-ADFD-12F56625E36B}.Release|x86.Build.0 = Release|x86
 		{52093DA6-D545-476A-ADFD-12F56625E36B}.ReleaseForCodeCoverage|x86.ActiveCfg = ReleaseForCodeCoverage|x86
 		{52093DA6-D545-476A-ADFD-12F56625E36B}.ReleaseForCodeCoverage|x86.Build.0 = ReleaseForCodeCoverage|x86
+		{61506E11-2D00-44FE-AB74-44D5766DF457}.CreateInstaller|x86.ActiveCfg = Release|x86
+		{61506E11-2D00-44FE-AB74-44D5766DF457}.CreateInstallerWithDemoProject|x86.ActiveCfg = Release|x86
+		{61506E11-2D00-44FE-AB74-44D5766DF457}.Debug|x86.ActiveCfg = Debug|x86
+		{61506E11-2D00-44FE-AB74-44D5766DF457}.Debug|x86.Build.0 = Debug|x86
+		{61506E11-2D00-44FE-AB74-44D5766DF457}.Release|x86.ActiveCfg = Release|x86
+		{61506E11-2D00-44FE-AB74-44D5766DF457}.Release|x86.Build.0 = Release|x86
+		{61506E11-2D00-44FE-AB74-44D5766DF457}.ReleaseForCodeCoverage|x86.ActiveCfg = ReleaseForCodeCoverage|x86
+		{61506E11-2D00-44FE-AB74-44D5766DF457}.ReleaseForCodeCoverage|x86.Build.0 = ReleaseForCodeCoverage|x86
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE
@@ -4503,6 +4516,7 @@
 		{77F983B7-EEAA-4348-8799-CDF79248BCC9} = {A39CC244-FBB2-4221-82B9-92CC837EF1DC}
 		{1FD22BC2-B3D5-49D5-9E9B-694BE547DB6D} = {D9DC93FF-DCF3-44A4-9193-9911966CDFF4}
 		{52093DA6-D545-476A-ADFD-12F56625E36B} = {B5F4F5A5-FD36-405D-ABA1-56C270207C8F}
+		{61506E11-2D00-44FE-AB74-44D5766DF457} = {1C1E8754-CF61-4858-9CEE-3E5DE344474F}
 	EndGlobalSection
 	GlobalSection(TextTemplating) = postSolution
 		TextTemplating = 1
Index: Ringtoets/GrassCoverErosionInwards/test/Ringtoets.GrassCoverErosionInwards.Integration.Test/GrassCoverErosionInwardsCalculationActivityIntegrationTest.cs
===================================================================
diff -u -r6bc7d332c95f37bc4192dbd574d2ff6ce28ad6c0 -ra1d8b4b58632ae45df9bde7fe7eaa69f3864507a
--- Ringtoets/GrassCoverErosionInwards/test/Ringtoets.GrassCoverErosionInwards.Integration.Test/GrassCoverErosionInwardsCalculationActivityIntegrationTest.cs	(.../GrassCoverErosionInwardsCalculationActivityIntegrationTest.cs)	(revision 6bc7d332c95f37bc4192dbd574d2ff6ce28ad6c0)
+++ Ringtoets/GrassCoverErosionInwards/test/Ringtoets.GrassCoverErosionInwards.Integration.Test/GrassCoverErosionInwardsCalculationActivityIntegrationTest.cs	(.../GrassCoverErosionInwardsCalculationActivityIntegrationTest.cs)	(revision a1d8b4b58632ae45df9bde7fe7eaa69f3864507a)
@@ -38,6 +38,7 @@
 using Ringtoets.Common.Service.TestUtil;
 using Ringtoets.GrassCoverErosionInwards.Data;
 using Ringtoets.GrassCoverErosionInwards.Service;
+using Ringtoets.GrassCoverErosionInwards.Service.TestUtil;
 using Ringtoets.HydraRing.Calculation.Calculator.Factory;
 using Ringtoets.HydraRing.Calculation.Data;
 using Ringtoets.HydraRing.Calculation.Data.Input.Hydraulics;
@@ -51,9 +52,6 @@
     [TestFixture]
     public class GrassCoverErosionInwardsCalculationActivityIntegrationTest
     {
-        private const string overtoppingCalculationDescription = "overloop en overslag";
-        private const string overtoppingRateCalculationDescription = "overslagdebiet";
-        private const string hbnCalculationDescription = "HBN";
         private static readonly string testDataPath = TestHelper.GetTestDataPath(TestDataPath.Ringtoets.Integration.Service, "HydraRingCalculation");
         private static readonly string validFile = Path.Combine(testDataPath, "HRD dutch coast south.sqlite");
 
@@ -215,22 +213,6 @@
                                    });
         }
 
-        private static void AssertCalculationFinishedMessage(string calculationDescription, string calculatorOutputDirectory, string actual)
-        {
-            Assert.AreEqual($"De {calculationDescription} berekening is uitgevoerd op de tijdelijke locatie '{calculatorOutputDirectory}'. " +
-                            "Gedetailleerde invoer en uitvoer kan in de bestanden op deze locatie worden gevonden.",
-                            actual);
-        }
-
-        private static void AssertCalculationFailedMessage(string calculationDescription, string calculationName, string detailedReport, string actual)
-        {
-            Assert.AreEqual($"De {calculationDescription} berekening voor grasbekleding erosie kruin en binnentalud '{calculationName}' is niet gelukt. " +
-                            (detailedReport != null
-                                 ? $"Bekijk het foutrapport door op details te klikken.\r\n{detailedReport}"
-                                 : "Er is geen foutrapport beschikbaar."),
-                            actual);
-        }
-
         #region Overtopping calculations
 
         [Test]
@@ -353,7 +335,7 @@
                     CalculationServiceTestHelper.AssertValidationEndMessage(calculation.Name, msgs[1]);
                     CalculationServiceTestHelper.AssertCalculationStartMessage(calculation.Name, msgs[2]);
                     Assert.AreEqual($"De overloop en overslag berekening voor grasbekleding erosie kruin en binnentalud '{calculation.Name}' is niet gelukt. {detailedReport}", msgs[3]);
-                    AssertCalculationFinishedMessage(overtoppingCalculationDescription, calculator.OutputDirectory, msgs[4]);
+                    GrassCoverErosionInwardsCalculationServiceTestHelper.AssertCalculationFinishedMessage(GrassCoverErosionInwardsCalculationServiceTestHelper.OvertoppingCalculationDescription, calculator.OutputDirectory, msgs[4]);
                     CalculationServiceTestHelper.AssertCalculationEndMessage(calculation.Name, msgs[5]);
                 });
                 Assert.AreEqual(ActivityState.Failed, activity.State);
@@ -400,7 +382,7 @@
                     CalculationServiceTestHelper.AssertValidationStartMessage(calculation.Name, msgs[0]);
                     CalculationServiceTestHelper.AssertValidationEndMessage(calculation.Name, msgs[1]);
                     CalculationServiceTestHelper.AssertCalculationStartMessage(calculation.Name, msgs[2]);
-                    AssertCalculationFinishedMessage(overtoppingCalculationDescription, overtoppingCalculator.OutputDirectory, msgs[3]);
+                    GrassCoverErosionInwardsCalculationServiceTestHelper.AssertCalculationFinishedMessage(GrassCoverErosionInwardsCalculationServiceTestHelper.OvertoppingCalculationDescription, overtoppingCalculator.OutputDirectory, msgs[3]);
                     CalculationServiceTestHelper.AssertCalculationEndMessage(calculation.Name, msgs[4]);
                 });
                 Assert.AreEqual(ActivityState.Executed, activity.State);
@@ -642,9 +624,9 @@
                     CalculationServiceTestHelper.AssertValidationStartMessage(calculation.Name, msgs[0]);
                     CalculationServiceTestHelper.AssertValidationEndMessage(calculation.Name, msgs[1]);
                     CalculationServiceTestHelper.AssertCalculationStartMessage(calculation.Name, msgs[2]);
-                    AssertCalculationFinishedMessage(overtoppingCalculationDescription, overtoppingCalculator.OutputDirectory, msgs[3]);
-                    AssertCalculationFailedMessage(hbnCalculationDescription, calculation.Name, dikeHeightCalculator.LastErrorFileContent, msgs[4]);
-                    AssertCalculationFinishedMessage(hbnCalculationDescription, dikeHeightCalculator.OutputDirectory, msgs[5]);
+                    GrassCoverErosionInwardsCalculationServiceTestHelper.AssertCalculationFinishedMessage(GrassCoverErosionInwardsCalculationServiceTestHelper.OvertoppingCalculationDescription, overtoppingCalculator.OutputDirectory, msgs[3]);
+                    GrassCoverErosionInwardsCalculationServiceTestHelper.AssertCalculationFailedMessage(GrassCoverErosionInwardsCalculationServiceTestHelper.HbnCalculationDescription, calculation.Name, dikeHeightCalculator.LastErrorFileContent, msgs[4]);
+                    GrassCoverErosionInwardsCalculationServiceTestHelper.AssertCalculationFinishedMessage(GrassCoverErosionInwardsCalculationServiceTestHelper.HbnCalculationDescription, dikeHeightCalculator.OutputDirectory, msgs[5]);
                     CalculationServiceTestHelper.AssertCalculationEndMessage(calculation.Name, msgs[6]);
                 });
                 Assert.AreEqual(ActivityState.Executed, activity.State);
@@ -700,9 +682,9 @@
                     CalculationServiceTestHelper.AssertValidationStartMessage(calculation.Name, msgs[0]);
                     CalculationServiceTestHelper.AssertValidationEndMessage(calculation.Name, msgs[1]);
                     CalculationServiceTestHelper.AssertCalculationStartMessage(calculation.Name, msgs[2]);
-                    AssertCalculationFinishedMessage(overtoppingCalculationDescription, overtoppingCalculator.OutputDirectory, msgs[3]);
-                    AssertCalculationFailedMessage(hbnCalculationDescription, calculation.Name, dikeHeightCalculator.LastErrorFileContent, msgs[4]);
-                    AssertCalculationFinishedMessage(hbnCalculationDescription, dikeHeightCalculator.OutputDirectory, msgs[5]);
+                    GrassCoverErosionInwardsCalculationServiceTestHelper.AssertCalculationFinishedMessage(GrassCoverErosionInwardsCalculationServiceTestHelper.OvertoppingCalculationDescription, overtoppingCalculator.OutputDirectory, msgs[3]);
+                    GrassCoverErosionInwardsCalculationServiceTestHelper.AssertCalculationFailedMessage(GrassCoverErosionInwardsCalculationServiceTestHelper.HbnCalculationDescription, calculation.Name, dikeHeightCalculator.LastErrorFileContent, msgs[4]);
+                    GrassCoverErosionInwardsCalculationServiceTestHelper.AssertCalculationFinishedMessage(GrassCoverErosionInwardsCalculationServiceTestHelper.HbnCalculationDescription, dikeHeightCalculator.OutputDirectory, msgs[5]);
                     CalculationServiceTestHelper.AssertCalculationEndMessage(calculation.Name, msgs[6]);
                 });
                 Assert.AreEqual(ActivityState.Executed, activity.State);
@@ -759,9 +741,9 @@
                     CalculationServiceTestHelper.AssertValidationStartMessage(calculation.Name, msgs[0]);
                     CalculationServiceTestHelper.AssertValidationEndMessage(calculation.Name, msgs[1]);
                     CalculationServiceTestHelper.AssertCalculationStartMessage(calculation.Name, msgs[2]);
-                    AssertCalculationFinishedMessage(overtoppingCalculationDescription, overtoppingCalculator.OutputDirectory, msgs[3]);
-                    AssertCalculationFailedMessage(hbnCalculationDescription, calculation.Name, dikeHeightCalculator.LastErrorFileContent, msgs[4]);
-                    AssertCalculationFinishedMessage(hbnCalculationDescription, dikeHeightCalculator.OutputDirectory, msgs[5]);
+                    GrassCoverErosionInwardsCalculationServiceTestHelper.AssertCalculationFinishedMessage(GrassCoverErosionInwardsCalculationServiceTestHelper.OvertoppingCalculationDescription, overtoppingCalculator.OutputDirectory, msgs[3]);
+                    GrassCoverErosionInwardsCalculationServiceTestHelper.AssertCalculationFailedMessage(GrassCoverErosionInwardsCalculationServiceTestHelper.HbnCalculationDescription, calculation.Name, dikeHeightCalculator.LastErrorFileContent, msgs[4]);
+                    GrassCoverErosionInwardsCalculationServiceTestHelper.AssertCalculationFinishedMessage(GrassCoverErosionInwardsCalculationServiceTestHelper.HbnCalculationDescription, dikeHeightCalculator.OutputDirectory, msgs[5]);
                     CalculationServiceTestHelper.AssertCalculationEndMessage(calculation.Name, msgs[6]);
                 });
                 Assert.AreEqual(ActivityState.Executed, activity.State);
@@ -824,8 +806,8 @@
                     CalculationServiceTestHelper.AssertValidationStartMessage(calculation.Name, msgs[0]);
                     CalculationServiceTestHelper.AssertValidationEndMessage(calculation.Name, msgs[1]);
                     CalculationServiceTestHelper.AssertCalculationStartMessage(calculation.Name, msgs[2]);
-                    AssertCalculationFinishedMessage(overtoppingCalculationDescription, overtoppingCalculator.OutputDirectory, msgs[3]);
-                    AssertCalculationFinishedMessage(hbnCalculationDescription, dikeHeightCalculator.OutputDirectory, msgs[4]);
+                    GrassCoverErosionInwardsCalculationServiceTestHelper.AssertCalculationFinishedMessage(GrassCoverErosionInwardsCalculationServiceTestHelper.OvertoppingCalculationDescription, overtoppingCalculator.OutputDirectory, msgs[3]);
+                    GrassCoverErosionInwardsCalculationServiceTestHelper.AssertCalculationFinishedMessage(GrassCoverErosionInwardsCalculationServiceTestHelper.HbnCalculationDescription, dikeHeightCalculator.OutputDirectory, msgs[4]);
                     Assert.AreEqual($"De HBN berekening voor grasbekleding erosie kruin en binnentalud '{calculation.Name}' is niet geconvergeerd.", msgs[5]);
                     CalculationServiceTestHelper.AssertCalculationEndMessage(calculation.Name, msgs[6]);
                 });
@@ -1073,9 +1055,9 @@
                     CalculationServiceTestHelper.AssertValidationStartMessage(calculation.Name, msgs[0]);
                     CalculationServiceTestHelper.AssertValidationEndMessage(calculation.Name, msgs[1]);
                     CalculationServiceTestHelper.AssertCalculationStartMessage(calculation.Name, msgs[2]);
-                    AssertCalculationFinishedMessage(overtoppingCalculationDescription, overtoppingCalculator.OutputDirectory, msgs[3]);
-                    AssertCalculationFailedMessage(overtoppingRateCalculationDescription, calculation.Name, overtoppingRateCalculator.LastErrorFileContent, msgs[4]);
-                    AssertCalculationFinishedMessage(overtoppingRateCalculationDescription, overtoppingRateCalculator.OutputDirectory, msgs[5]);
+                    GrassCoverErosionInwardsCalculationServiceTestHelper.AssertCalculationFinishedMessage(GrassCoverErosionInwardsCalculationServiceTestHelper.OvertoppingCalculationDescription, overtoppingCalculator.OutputDirectory, msgs[3]);
+                    GrassCoverErosionInwardsCalculationServiceTestHelper.AssertCalculationFailedMessage(GrassCoverErosionInwardsCalculationServiceTestHelper.OvertoppingRateCalculationDescription, calculation.Name, overtoppingRateCalculator.LastErrorFileContent, msgs[4]);
+                    GrassCoverErosionInwardsCalculationServiceTestHelper.AssertCalculationFinishedMessage(GrassCoverErosionInwardsCalculationServiceTestHelper.OvertoppingRateCalculationDescription, overtoppingRateCalculator.OutputDirectory, msgs[5]);
                     CalculationServiceTestHelper.AssertCalculationEndMessage(calculation.Name, msgs[6]);
                 });
                 Assert.AreEqual(ActivityState.Executed, activity.State);
@@ -1131,9 +1113,9 @@
                     CalculationServiceTestHelper.AssertValidationStartMessage(calculation.Name, msgs[0]);
                     CalculationServiceTestHelper.AssertValidationEndMessage(calculation.Name, msgs[1]);
                     CalculationServiceTestHelper.AssertCalculationStartMessage(calculation.Name, msgs[2]);
-                    AssertCalculationFinishedMessage(overtoppingCalculationDescription, overtoppingCalculator.OutputDirectory, msgs[3]);
-                    AssertCalculationFailedMessage(overtoppingRateCalculationDescription, calculation.Name, overtoppingRateCalculator.LastErrorFileContent, msgs[4]);
-                    AssertCalculationFinishedMessage(overtoppingRateCalculationDescription, overtoppingRateCalculator.OutputDirectory, msgs[5]);
+                    GrassCoverErosionInwardsCalculationServiceTestHelper.AssertCalculationFinishedMessage(GrassCoverErosionInwardsCalculationServiceTestHelper.OvertoppingCalculationDescription, overtoppingCalculator.OutputDirectory, msgs[3]);
+                    GrassCoverErosionInwardsCalculationServiceTestHelper.AssertCalculationFailedMessage(GrassCoverErosionInwardsCalculationServiceTestHelper.OvertoppingRateCalculationDescription, calculation.Name, overtoppingRateCalculator.LastErrorFileContent, msgs[4]);
+                    GrassCoverErosionInwardsCalculationServiceTestHelper.AssertCalculationFinishedMessage(GrassCoverErosionInwardsCalculationServiceTestHelper.OvertoppingRateCalculationDescription, overtoppingRateCalculator.OutputDirectory, msgs[5]);
                     CalculationServiceTestHelper.AssertCalculationEndMessage(calculation.Name, msgs[6]);
                 });
                 Assert.AreEqual(ActivityState.Executed, activity.State);
@@ -1190,9 +1172,9 @@
                     CalculationServiceTestHelper.AssertValidationStartMessage(calculation.Name, msgs[0]);
                     CalculationServiceTestHelper.AssertValidationEndMessage(calculation.Name, msgs[1]);
                     CalculationServiceTestHelper.AssertCalculationStartMessage(calculation.Name, msgs[2]);
-                    AssertCalculationFinishedMessage(overtoppingCalculationDescription, overtoppingCalculator.OutputDirectory, msgs[3]);
-                    AssertCalculationFailedMessage(overtoppingRateCalculationDescription, calculation.Name, overtoppingRateCalculator.LastErrorFileContent, msgs[4]);
-                    AssertCalculationFinishedMessage(overtoppingRateCalculationDescription, overtoppingRateCalculator.OutputDirectory, msgs[5]);
+                    GrassCoverErosionInwardsCalculationServiceTestHelper.AssertCalculationFinishedMessage(GrassCoverErosionInwardsCalculationServiceTestHelper.OvertoppingCalculationDescription, overtoppingCalculator.OutputDirectory, msgs[3]);
+                    GrassCoverErosionInwardsCalculationServiceTestHelper.AssertCalculationFailedMessage(GrassCoverErosionInwardsCalculationServiceTestHelper.OvertoppingRateCalculationDescription, calculation.Name, overtoppingRateCalculator.LastErrorFileContent, msgs[4]);
+                    GrassCoverErosionInwardsCalculationServiceTestHelper.AssertCalculationFinishedMessage(GrassCoverErosionInwardsCalculationServiceTestHelper.OvertoppingRateCalculationDescription, overtoppingRateCalculator.OutputDirectory, msgs[5]);
                     CalculationServiceTestHelper.AssertCalculationEndMessage(calculation.Name, msgs[6]);
                 });
                 Assert.AreEqual(ActivityState.Executed, activity.State);
@@ -1255,8 +1237,8 @@
                     CalculationServiceTestHelper.AssertValidationStartMessage(calculation.Name, msgs[0]);
                     CalculationServiceTestHelper.AssertValidationEndMessage(calculation.Name, msgs[1]);
                     CalculationServiceTestHelper.AssertCalculationStartMessage(calculation.Name, msgs[2]);
-                    AssertCalculationFinishedMessage(overtoppingCalculationDescription, overtoppingCalculator.OutputDirectory, msgs[3]);
-                    AssertCalculationFinishedMessage(overtoppingRateCalculationDescription, overtoppingRateCalculator.OutputDirectory, msgs[4]);
+                    GrassCoverErosionInwardsCalculationServiceTestHelper.AssertCalculationFinishedMessage(GrassCoverErosionInwardsCalculationServiceTestHelper.OvertoppingCalculationDescription, overtoppingCalculator.OutputDirectory, msgs[3]);
+                    GrassCoverErosionInwardsCalculationServiceTestHelper.AssertCalculationFinishedMessage(GrassCoverErosionInwardsCalculationServiceTestHelper.OvertoppingRateCalculationDescription, overtoppingRateCalculator.OutputDirectory, msgs[4]);
                     Assert.AreEqual($"De overslagdebiet berekening voor grasbekleding erosie kruin en binnentalud '{calculation.Name}' is niet geconvergeerd.", msgs[5]);
                     CalculationServiceTestHelper.AssertCalculationEndMessage(calculation.Name, msgs[6]);
                 });
Index: Ringtoets/GrassCoverErosionInwards/test/Ringtoets.GrassCoverErosionInwards.Integration.Test/Ringtoets.GrassCoverErosionInwards.Integration.Test.csproj
===================================================================
diff -u -r9779d1ab6b555c557e8fd18f4430ad207bd003da -ra1d8b4b58632ae45df9bde7fe7eaa69f3864507a
--- Ringtoets/GrassCoverErosionInwards/test/Ringtoets.GrassCoverErosionInwards.Integration.Test/Ringtoets.GrassCoverErosionInwards.Integration.Test.csproj	(.../Ringtoets.GrassCoverErosionInwards.Integration.Test.csproj)	(revision 9779d1ab6b555c557e8fd18f4430ad207bd003da)
+++ Ringtoets/GrassCoverErosionInwards/test/Ringtoets.GrassCoverErosionInwards.Integration.Test/Ringtoets.GrassCoverErosionInwards.Integration.Test.csproj	(.../Ringtoets.GrassCoverErosionInwards.Integration.Test.csproj)	(revision a1d8b4b58632ae45df9bde7fe7eaa69f3864507a)
@@ -145,6 +145,10 @@
       <Project>{5D158D8E-A5EB-489C-A885-87E13BC0D3B3}</Project>
       <Name>Ringtoets.GrassCoverErosionInwards.Service</Name>
     </ProjectReference>
+    <ProjectReference Include="..\Ringtoets.GrassCoverErosionInwards.Service.TestUtil\Ringtoets.GrassCoverErosionInwards.Service.TestUtil.csproj">
+      <Project>{61506E11-2D00-44FE-AB74-44D5766DF457}</Project>
+      <Name>Ringtoets.GrassCoverErosionInwards.Service.TestUtil</Name>
+    </ProjectReference>
   </ItemGroup>
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
   <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
Index: Ringtoets/GrassCoverErosionInwards/test/Ringtoets.GrassCoverErosionInwards.Service.Test/GrassCoverErosionInwardsCalculationServiceTest.cs
===================================================================
diff -u -r9779d1ab6b555c557e8fd18f4430ad207bd003da -ra1d8b4b58632ae45df9bde7fe7eaa69f3864507a
--- Ringtoets/GrassCoverErosionInwards/test/Ringtoets.GrassCoverErosionInwards.Service.Test/GrassCoverErosionInwardsCalculationServiceTest.cs	(.../GrassCoverErosionInwardsCalculationServiceTest.cs)	(revision 9779d1ab6b555c557e8fd18f4430ad207bd003da)
+++ Ringtoets/GrassCoverErosionInwards/test/Ringtoets.GrassCoverErosionInwards.Service.Test/GrassCoverErosionInwardsCalculationServiceTest.cs	(.../GrassCoverErosionInwardsCalculationServiceTest.cs)	(revision a1d8b4b58632ae45df9bde7fe7eaa69f3864507a)
@@ -34,6 +34,7 @@
 using Ringtoets.Common.Data.TestUtil;
 using Ringtoets.Common.Service.TestUtil;
 using Ringtoets.GrassCoverErosionInwards.Data;
+using Ringtoets.GrassCoverErosionInwards.Service.TestUtil;
 using Ringtoets.HydraRing.Calculation.Calculator.Factory;
 using Ringtoets.HydraRing.Calculation.Exceptions;
 using Ringtoets.HydraRing.Calculation.TestUtil.Calculator;
@@ -608,8 +609,9 @@
             {
                 EndInFailure = true
             };
+            var overtoppingCalculator = new TestOvertoppingCalculator();
             var calculatorFactory = mockRepository.StrictMock<IHydraRingCalculatorFactory>();
-            calculatorFactory.Expect(cf => cf.CreateOvertoppingCalculator(testDataPath)).Return(new TestOvertoppingCalculator());
+            calculatorFactory.Expect(cf => cf.CreateOvertoppingCalculator(testDataPath)).Return(overtoppingCalculator);
             calculatorFactory.Expect(cf => cf.CreateDikeHeightCalculator(testDataPath)).Return(dikeHeightCalculator);
             mockRepository.ReplayAll();
 
@@ -653,9 +655,19 @@
                 string[] msgs = messages.ToArray();
                 Assert.AreEqual(5, msgs.Length);
                 CalculationServiceTestHelper.AssertCalculationStartMessage(calculation.Name, msgs[0]);
-                StringAssert.StartsWith("De overloop en overslag berekening is uitgevoerd op de tijdelijke locatie", msgs[1]);
-                StringAssert.StartsWith($"De HBN berekening voor grasbekleding erosie kruin en binnentalud '{calculation.Name}' is niet gelukt.", msgs[2]);
-                StringAssert.StartsWith("De HBN berekening is uitgevoerd op de tijdelijke locatie", msgs[3]);
+                GrassCoverErosionInwardsCalculationServiceTestHelper.AssertCalculationFinishedMessage(
+                    GrassCoverErosionInwardsCalculationServiceTestHelper.OvertoppingCalculationDescription,
+                    overtoppingCalculator.OutputDirectory,
+                    msgs[1]);
+                GrassCoverErosionInwardsCalculationServiceTestHelper.AssertCalculationFailedMessage(
+                    GrassCoverErosionInwardsCalculationServiceTestHelper.HbnCalculationDescription,
+                    calculation.Name,
+                    dikeHeightCalculator.LastErrorFileContent,
+                    msgs[2]);
+                GrassCoverErosionInwardsCalculationServiceTestHelper.AssertCalculationFinishedMessage(
+                    GrassCoverErosionInwardsCalculationServiceTestHelper.HbnCalculationDescription,
+                    dikeHeightCalculator.OutputDirectory,
+                    msgs[3]);
                 CalculationServiceTestHelper.AssertCalculationEndMessage(calculation.Name, msgs[4]);
             });
             Assert.IsFalse(expectedExceptionThrown);
@@ -680,8 +692,9 @@
             {
                 EndInFailure = true
             };
+            var overtoppingCalculator = new TestOvertoppingCalculator();
             var calculatorFactory = mockRepository.StrictMock<IHydraRingCalculatorFactory>();
-            calculatorFactory.Expect(cf => cf.CreateOvertoppingCalculator(testDataPath)).Return(new TestOvertoppingCalculator());
+            calculatorFactory.Expect(cf => cf.CreateOvertoppingCalculator(testDataPath)).Return(overtoppingCalculator);
             calculatorFactory.Expect(cf => cf.CreateOvertoppingRateCalculator(testDataPath)).Return(overtoppingRateCalculator);
             mockRepository.ReplayAll();
 
@@ -725,9 +738,19 @@
                 string[] msgs = messages.ToArray();
                 Assert.AreEqual(5, msgs.Length);
                 CalculationServiceTestHelper.AssertCalculationStartMessage(calculation.Name, msgs[0]);
-                StringAssert.StartsWith("De overloop en overslag berekening is uitgevoerd op de tijdelijke locatie", msgs[1]);
-                StringAssert.StartsWith($"De overslagdebiet berekening voor grasbekleding erosie kruin en binnentalud '{calculation.Name}' is niet gelukt.", msgs[2]);
-                StringAssert.StartsWith("De overslagdebiet berekening is uitgevoerd op de tijdelijke locatie", msgs[3]);
+                GrassCoverErosionInwardsCalculationServiceTestHelper.AssertCalculationFinishedMessage(
+                    GrassCoverErosionInwardsCalculationServiceTestHelper.OvertoppingCalculationDescription,
+                    overtoppingCalculator.OutputDirectory,
+                    msgs[1]);
+                GrassCoverErosionInwardsCalculationServiceTestHelper.AssertCalculationFailedMessage(
+                    GrassCoverErosionInwardsCalculationServiceTestHelper.OvertoppingRateCalculationDescription,
+                    calculation.Name,
+                    overtoppingRateCalculator.LastErrorFileContent,
+                    msgs[2]);
+                GrassCoverErosionInwardsCalculationServiceTestHelper.AssertCalculationFinishedMessage(
+                    GrassCoverErosionInwardsCalculationServiceTestHelper.OvertoppingRateCalculationDescription,
+                    overtoppingRateCalculator.OutputDirectory,
+                    msgs[3]);
                 CalculationServiceTestHelper.AssertCalculationEndMessage(calculation.Name, msgs[4]);
             });
             Assert.IsFalse(expectedExceptionThrown);
@@ -964,8 +987,15 @@
                     string[] msgs = messages.ToArray();
                     Assert.AreEqual(4, msgs.Length);
                     CalculationServiceTestHelper.AssertCalculationStartMessage(calculation.Name, msgs[0]);
-                    StringAssert.StartsWith($"De overloop en overslag berekening voor grasbekleding erosie kruin en binnentalud '{calculation.Name}' is niet gelukt. Bekijk het foutrapport door op details te klikken.", msgs[1]);
-                    StringAssert.StartsWith("De overloop en overslag berekening is uitgevoerd op de tijdelijke locatie", msgs[2]);
+                    GrassCoverErosionInwardsCalculationServiceTestHelper.AssertCalculationFailedMessage(
+                        GrassCoverErosionInwardsCalculationServiceTestHelper.OvertoppingCalculationDescription,
+                        calculation.Name,
+                        overtoppingCalculator.LastErrorFileContent,
+                        msgs[1]);
+                    GrassCoverErosionInwardsCalculationServiceTestHelper.AssertCalculationFinishedMessage(
+                        GrassCoverErosionInwardsCalculationServiceTestHelper.OvertoppingCalculationDescription,
+                        overtoppingCalculator.OutputDirectory,
+                        msgs[2]);
                     CalculationServiceTestHelper.AssertCalculationEndMessage(calculation.Name, msgs[3]);
                 });
                 Assert.IsNull(calculation.Output);
@@ -1029,8 +1059,15 @@
                     string[] msgs = messages.ToArray();
                     Assert.AreEqual(4, msgs.Length);
                     CalculationServiceTestHelper.AssertCalculationStartMessage(calculation.Name, msgs[0]);
-                    Assert.AreEqual($"De overloop en overslag berekening voor grasbekleding erosie kruin en binnentalud '{calculation.Name}' is niet gelukt. Er is geen foutrapport beschikbaar.", msgs[1]);
-                    StringAssert.StartsWith("De overloop en overslag berekening is uitgevoerd op de tijdelijke locatie", msgs[2]);
+                    GrassCoverErosionInwardsCalculationServiceTestHelper.AssertCalculationFailedMessage(
+                        GrassCoverErosionInwardsCalculationServiceTestHelper.OvertoppingCalculationDescription,
+                        calculation.Name,
+                        overtoppingCalculator.LastErrorFileContent,
+                        msgs[1]);
+                    GrassCoverErosionInwardsCalculationServiceTestHelper.AssertCalculationFinishedMessage(
+                        GrassCoverErosionInwardsCalculationServiceTestHelper.OvertoppingCalculationDescription,
+                        overtoppingCalculator.OutputDirectory,
+                        msgs[2]);
                     CalculationServiceTestHelper.AssertCalculationEndMessage(calculation.Name, msgs[3]);
                 });
                 Assert.IsTrue(exceptionThrown);
@@ -1095,8 +1132,15 @@
                     string[] msgs = messages.ToArray();
                     Assert.AreEqual(4, msgs.Length);
                     CalculationServiceTestHelper.AssertCalculationStartMessage(calculation.Name, msgs[0]);
-                    StringAssert.StartsWith($"De overloop en overslag berekening voor grasbekleding erosie kruin en binnentalud '{calculation.Name}' is niet gelukt. Bekijk het foutrapport door op details te klikken.", msgs[1]);
-                    StringAssert.StartsWith("De overloop en overslag berekening is uitgevoerd op de tijdelijke locatie", msgs[2]);
+                    GrassCoverErosionInwardsCalculationServiceTestHelper.AssertCalculationFailedMessage(
+                        GrassCoverErosionInwardsCalculationServiceTestHelper.OvertoppingCalculationDescription,
+                        calculation.Name,
+                        overtoppingCalculator.LastErrorFileContent,
+                        msgs[1]);
+                    GrassCoverErosionInwardsCalculationServiceTestHelper.AssertCalculationFinishedMessage(
+                        GrassCoverErosionInwardsCalculationServiceTestHelper.OvertoppingCalculationDescription,
+                        overtoppingCalculator.OutputDirectory,
+                        msgs[2]);
                     CalculationServiceTestHelper.AssertCalculationEndMessage(calculation.Name, msgs[3]);
                 });
                 Assert.IsInstanceOf<HydraRingCalculationException>(exception);
@@ -1122,8 +1166,9 @@
                 LastErrorFileContent = "An error occurred",
                 EndInFailure = true
             };
+            var overtoppingCalculator = new TestOvertoppingCalculator();
             var calculatorFactory = mockRepository.StrictMock<IHydraRingCalculatorFactory>();
-            calculatorFactory.Expect(cf => cf.CreateOvertoppingCalculator(testDataPath)).Return(new TestOvertoppingCalculator());
+            calculatorFactory.Expect(cf => cf.CreateOvertoppingCalculator(testDataPath)).Return(overtoppingCalculator);
             calculatorFactory.Expect(cf => cf.CreateDikeHeightCalculator(testDataPath)).Return(dikeHeightCalculator);
             mockRepository.ReplayAll();
 
@@ -1166,9 +1211,19 @@
                     string[] msgs = messages.ToArray();
                     Assert.AreEqual(5, msgs.Length);
                     CalculationServiceTestHelper.AssertCalculationStartMessage(calculation.Name, msgs[0]);
-                    StringAssert.StartsWith("De overloop en overslag berekening is uitgevoerd op de tijdelijke locatie", msgs[1]);
-                    StringAssert.StartsWith($"De HBN berekening voor grasbekleding erosie kruin en binnentalud '{calculation.Name}' is niet gelukt. Bekijk het foutrapport door op details te klikken.", msgs[2]);
-                    StringAssert.StartsWith("De HBN berekening is uitgevoerd op de tijdelijke locatie", msgs[3]);
+                    GrassCoverErosionInwardsCalculationServiceTestHelper.AssertCalculationFinishedMessage(
+                        GrassCoverErosionInwardsCalculationServiceTestHelper.OvertoppingCalculationDescription,
+                        overtoppingCalculator.OutputDirectory,
+                        msgs[1]);
+                    GrassCoverErosionInwardsCalculationServiceTestHelper.AssertCalculationFailedMessage(
+                        GrassCoverErosionInwardsCalculationServiceTestHelper.HbnCalculationDescription,
+                        calculation.Name,
+                        dikeHeightCalculator.LastErrorFileContent,
+                        msgs[2]);
+                    GrassCoverErosionInwardsCalculationServiceTestHelper.AssertCalculationFinishedMessage(
+                        GrassCoverErosionInwardsCalculationServiceTestHelper.HbnCalculationDescription,
+                        dikeHeightCalculator.OutputDirectory,
+                        msgs[3]);
                     CalculationServiceTestHelper.AssertCalculationEndMessage(calculation.Name, msgs[4]);
                 });
                 Assert.IsNotNull(calculation.Output);
@@ -1192,8 +1247,9 @@
             {
                 EndInFailure = true
             };
+            var overtoppingCalculator = new TestOvertoppingCalculator();
             var calculatorFactory = mockRepository.StrictMock<IHydraRingCalculatorFactory>();
-            calculatorFactory.Expect(cf => cf.CreateOvertoppingCalculator(testDataPath)).Return(new TestOvertoppingCalculator());
+            calculatorFactory.Expect(cf => cf.CreateOvertoppingCalculator(testDataPath)).Return(overtoppingCalculator);
             calculatorFactory.Expect(cf => cf.CreateDikeHeightCalculator(testDataPath)).Return(dikeHeightCalculator);
             mockRepository.ReplayAll();
 
@@ -1236,9 +1292,19 @@
                     string[] msgs = messages.ToArray();
                     Assert.AreEqual(5, msgs.Length);
                     CalculationServiceTestHelper.AssertCalculationStartMessage(calculation.Name, msgs[0]);
-                    StringAssert.StartsWith("De overloop en overslag berekening is uitgevoerd op de tijdelijke locatie", msgs[1]);
-                    Assert.AreEqual($"De HBN berekening voor grasbekleding erosie kruin en binnentalud '{calculation.Name}' is niet gelukt. Er is geen foutrapport beschikbaar.", msgs[2]);
-                    StringAssert.StartsWith("De HBN berekening is uitgevoerd op de tijdelijke locatie", msgs[3]);
+                    GrassCoverErosionInwardsCalculationServiceTestHelper.AssertCalculationFinishedMessage(
+                        GrassCoverErosionInwardsCalculationServiceTestHelper.OvertoppingCalculationDescription,
+                        overtoppingCalculator.OutputDirectory,
+                        msgs[1]);
+                    GrassCoverErosionInwardsCalculationServiceTestHelper.AssertCalculationFailedMessage(
+                        GrassCoverErosionInwardsCalculationServiceTestHelper.HbnCalculationDescription,
+                        calculation.Name,
+                        dikeHeightCalculator.LastErrorFileContent,
+                        msgs[2]);
+                    GrassCoverErosionInwardsCalculationServiceTestHelper.AssertCalculationFinishedMessage(
+                        GrassCoverErosionInwardsCalculationServiceTestHelper.HbnCalculationDescription,
+                        dikeHeightCalculator.OutputDirectory,
+                        msgs[3]);
                     CalculationServiceTestHelper.AssertCalculationEndMessage(calculation.Name, msgs[4]);
                 });
                 Assert.IsNotNull(calculation.Output);
@@ -1264,7 +1330,8 @@
                 EndInFailure = false
             };
             var calculatorFactory = mockRepository.StrictMock<IHydraRingCalculatorFactory>();
-            calculatorFactory.Expect(cf => cf.CreateOvertoppingCalculator(testDataPath)).Return(new TestOvertoppingCalculator());
+            var overtoppingCalculator = new TestOvertoppingCalculator();
+            calculatorFactory.Expect(cf => cf.CreateOvertoppingCalculator(testDataPath)).Return(overtoppingCalculator);
             calculatorFactory.Expect(cf => cf.CreateDikeHeightCalculator(testDataPath)).Return(dikeHeightCalculator);
             mockRepository.ReplayAll();
 
@@ -1306,9 +1373,20 @@
                 {
                     string[] msgs = messages.ToArray();
                     CalculationServiceTestHelper.AssertCalculationStartMessage(calculation.Name, msgs[0]);
-                    StringAssert.StartsWith("De overloop en overslag berekening is uitgevoerd op de tijdelijke locatie", msgs[1]);
-                    StringAssert.StartsWith($"De HBN berekening voor grasbekleding erosie kruin en binnentalud '{calculation.Name}' is niet gelukt. Bekijk het foutrapport door op details te klikken.", msgs[2]);
-                    StringAssert.StartsWith("De HBN berekening is uitgevoerd op de tijdelijke locatie", msgs[3]);
+                    CalculationServiceTestHelper.AssertCalculationStartMessage(calculation.Name, msgs[0]);
+                    GrassCoverErosionInwardsCalculationServiceTestHelper.AssertCalculationFinishedMessage(
+                        GrassCoverErosionInwardsCalculationServiceTestHelper.OvertoppingCalculationDescription,
+                        overtoppingCalculator.OutputDirectory,
+                        msgs[1]);
+                    GrassCoverErosionInwardsCalculationServiceTestHelper.AssertCalculationFailedMessage(
+                        GrassCoverErosionInwardsCalculationServiceTestHelper.HbnCalculationDescription,
+                        calculation.Name,
+                        dikeHeightCalculator.LastErrorFileContent,
+                        msgs[2]);
+                    GrassCoverErosionInwardsCalculationServiceTestHelper.AssertCalculationFinishedMessage(
+                        GrassCoverErosionInwardsCalculationServiceTestHelper.HbnCalculationDescription,
+                        dikeHeightCalculator.OutputDirectory,
+                        msgs[3]);
                     CalculationServiceTestHelper.AssertCalculationEndMessage(calculation.Name, msgs[4]);
                     Assert.AreEqual(5, msgs.Length);
                 });
@@ -1334,8 +1412,10 @@
                 LastErrorFileContent = "An error occurred",
                 EndInFailure = true
             };
+            var overtoppingCalculator = new TestOvertoppingCalculator();
             var calculatorFactory = mockRepository.StrictMock<IHydraRingCalculatorFactory>();
-            calculatorFactory.Expect(cf => cf.CreateOvertoppingCalculator(testDataPath)).Return(new TestOvertoppingCalculator());
+
+            calculatorFactory.Expect(cf => cf.CreateOvertoppingCalculator(testDataPath)).Return(overtoppingCalculator);
             calculatorFactory.Expect(cf => cf.CreateDikeHeightCalculator(testDataPath)).Return(new TestHydraulicLoadsCalculator());
             calculatorFactory.Expect(cf => cf.CreateOvertoppingRateCalculator(testDataPath)).Return(overtoppingRateCalculator);
             mockRepository.ReplayAll();
@@ -1379,9 +1459,19 @@
                     string[] msgs = messages.ToArray();
                     Assert.AreEqual(5, msgs.Length);
                     CalculationServiceTestHelper.AssertCalculationStartMessage(calculation.Name, msgs[0]);
-                    StringAssert.StartsWith("De overloop en overslag berekening is uitgevoerd op de tijdelijke locatie", msgs[1]);
-                    StringAssert.StartsWith($"De overslagdebiet berekening voor grasbekleding erosie kruin en binnentalud '{calculation.Name}' is niet gelukt. Bekijk het foutrapport door op details te klikken.", msgs[2]);
-                    StringAssert.StartsWith("De overslagdebiet berekening is uitgevoerd op de tijdelijke locatie", msgs[3]);
+                    GrassCoverErosionInwardsCalculationServiceTestHelper.AssertCalculationFinishedMessage(
+                        GrassCoverErosionInwardsCalculationServiceTestHelper.OvertoppingCalculationDescription,
+                        overtoppingCalculator.OutputDirectory,
+                        msgs[1]);
+                    GrassCoverErosionInwardsCalculationServiceTestHelper.AssertCalculationFailedMessage(
+                        GrassCoverErosionInwardsCalculationServiceTestHelper.OvertoppingRateCalculationDescription,
+                        calculation.Name,
+                        overtoppingRateCalculator.LastErrorFileContent,
+                        msgs[2]);
+                    GrassCoverErosionInwardsCalculationServiceTestHelper.AssertCalculationFinishedMessage(
+                        GrassCoverErosionInwardsCalculationServiceTestHelper.OvertoppingRateCalculationDescription,
+                        overtoppingRateCalculator.OutputDirectory,
+                        msgs[3]);
                     CalculationServiceTestHelper.AssertCalculationEndMessage(calculation.Name, msgs[4]);
                 });
                 Assert.IsNotNull(calculation.Output);
@@ -1405,8 +1495,9 @@
             {
                 EndInFailure = true
             };
+            var overtoppingCalculator = new TestOvertoppingCalculator();
             var calculatorFactory = mockRepository.StrictMock<IHydraRingCalculatorFactory>();
-            calculatorFactory.Expect(cf => cf.CreateOvertoppingCalculator(testDataPath)).Return(new TestOvertoppingCalculator());
+            calculatorFactory.Expect(cf => cf.CreateOvertoppingCalculator(testDataPath)).Return(overtoppingCalculator);
             calculatorFactory.Expect(cf => cf.CreateDikeHeightCalculator(testDataPath)).Return(new TestHydraulicLoadsCalculator());
             calculatorFactory.Expect(cf => cf.CreateOvertoppingRateCalculator(testDataPath)).Return(overtoppingRateCalculator);
             mockRepository.ReplayAll();
@@ -1450,9 +1541,19 @@
                     string[] msgs = messages.ToArray();
                     Assert.AreEqual(5, msgs.Length);
                     CalculationServiceTestHelper.AssertCalculationStartMessage(calculation.Name, msgs[0]);
-                    StringAssert.StartsWith("De overloop en overslag berekening is uitgevoerd op de tijdelijke locatie", msgs[1]);
-                    Assert.AreEqual($"De overslagdebiet berekening voor grasbekleding erosie kruin en binnentalud '{calculation.Name}' is niet gelukt. Er is geen foutrapport beschikbaar.", msgs[2]);
-                    StringAssert.StartsWith("De overslagdebiet berekening is uitgevoerd op de tijdelijke locatie", msgs[3]);
+                    GrassCoverErosionInwardsCalculationServiceTestHelper.AssertCalculationFinishedMessage(
+                        GrassCoverErosionInwardsCalculationServiceTestHelper.OvertoppingCalculationDescription,
+                        overtoppingCalculator.OutputDirectory,
+                        msgs[1]);
+                    GrassCoverErosionInwardsCalculationServiceTestHelper.AssertCalculationFailedMessage(
+                        GrassCoverErosionInwardsCalculationServiceTestHelper.OvertoppingRateCalculationDescription,
+                        calculation.Name,
+                        overtoppingRateCalculator.LastErrorFileContent,
+                        msgs[2]);
+                    GrassCoverErosionInwardsCalculationServiceTestHelper.AssertCalculationFinishedMessage(
+                        GrassCoverErosionInwardsCalculationServiceTestHelper.OvertoppingRateCalculationDescription,
+                        overtoppingRateCalculator.OutputDirectory,
+                        msgs[3]);
                     CalculationServiceTestHelper.AssertCalculationEndMessage(calculation.Name, msgs[4]);
                 });
                 Assert.IsNotNull(calculation.Output);
@@ -1473,7 +1574,8 @@
                                                                                                            mockRepository,
                                                                                                            validFile);
             var calculatorFactory = mockRepository.StrictMock<IHydraRingCalculatorFactory>();
-            calculatorFactory.Expect(cf => cf.CreateOvertoppingCalculator(testDataPath)).Return(new TestOvertoppingCalculator());
+            var overtoppingCalculator = new TestOvertoppingCalculator();
+            calculatorFactory.Expect(cf => cf.CreateOvertoppingCalculator(testDataPath)).Return(overtoppingCalculator);
             var overtoppingRateCalculator = new TestHydraulicLoadsCalculator
             {
                 EndInFailure = false,
@@ -1520,9 +1622,19 @@
                 {
                     string[] msgs = messages.ToArray();
                     CalculationServiceTestHelper.AssertCalculationStartMessage(calculation.Name, msgs[0]);
-                    StringAssert.StartsWith("De overloop en overslag berekening is uitgevoerd op de tijdelijke locatie", msgs[1]);
-                    StringAssert.StartsWith($"De overslagdebiet berekening voor grasbekleding erosie kruin en binnentalud '{calculation.Name}' is niet gelukt. Bekijk het foutrapport door op details te klikken.", msgs[2]);
-                    StringAssert.StartsWith("De overslagdebiet berekening is uitgevoerd op de tijdelijke locatie", msgs[3]);
+                    GrassCoverErosionInwardsCalculationServiceTestHelper.AssertCalculationFinishedMessage(
+                        GrassCoverErosionInwardsCalculationServiceTestHelper.OvertoppingCalculationDescription,
+                        overtoppingCalculator.OutputDirectory,
+                        msgs[1]);
+                    GrassCoverErosionInwardsCalculationServiceTestHelper.AssertCalculationFailedMessage(
+                        GrassCoverErosionInwardsCalculationServiceTestHelper.OvertoppingRateCalculationDescription,
+                        calculation.Name,
+                        overtoppingRateCalculator.LastErrorFileContent,
+                        msgs[2]);
+                    GrassCoverErosionInwardsCalculationServiceTestHelper.AssertCalculationFinishedMessage(
+                        GrassCoverErosionInwardsCalculationServiceTestHelper.OvertoppingRateCalculationDescription,
+                        overtoppingRateCalculator.OutputDirectory,
+                        msgs[3]);
                     CalculationServiceTestHelper.AssertCalculationEndMessage(calculation.Name, msgs[4]);
                     Assert.AreEqual(5, msgs.Length);
                 });
Index: Ringtoets/GrassCoverErosionInwards/test/Ringtoets.GrassCoverErosionInwards.Service.Test/Ringtoets.GrassCoverErosionInwards.Service.Test.csproj
===================================================================
diff -u -r9779d1ab6b555c557e8fd18f4430ad207bd003da -ra1d8b4b58632ae45df9bde7fe7eaa69f3864507a
--- Ringtoets/GrassCoverErosionInwards/test/Ringtoets.GrassCoverErosionInwards.Service.Test/Ringtoets.GrassCoverErosionInwards.Service.Test.csproj	(.../Ringtoets.GrassCoverErosionInwards.Service.Test.csproj)	(revision 9779d1ab6b555c557e8fd18f4430ad207bd003da)
+++ Ringtoets/GrassCoverErosionInwards/test/Ringtoets.GrassCoverErosionInwards.Service.Test/Ringtoets.GrassCoverErosionInwards.Service.Test.csproj	(.../Ringtoets.GrassCoverErosionInwards.Service.Test.csproj)	(revision a1d8b4b58632ae45df9bde7fe7eaa69f3864507a)
@@ -100,6 +100,10 @@
       <Project>{5D158D8E-A5EB-489C-A885-87E13BC0D3B3}</Project>
       <Name>Ringtoets.GrassCoverErosionInwards.Service</Name>
     </ProjectReference>
+    <ProjectReference Include="..\Ringtoets.GrassCoverErosionInwards.Service.TestUtil\Ringtoets.GrassCoverErosionInwards.Service.TestUtil.csproj">
+      <Project>{61506E11-2D00-44FE-AB74-44D5766DF457}</Project>
+      <Name>Ringtoets.GrassCoverErosionInwards.Service.TestUtil</Name>
+    </ProjectReference>
   </ItemGroup>
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
   <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
Index: Ringtoets/GrassCoverErosionInwards/test/Ringtoets.GrassCoverErosionInwards.Service.TestUtil/GrassCoverErosionInwardsCalculationServiceTestHelper.cs
===================================================================
diff -u
--- Ringtoets/GrassCoverErosionInwards/test/Ringtoets.GrassCoverErosionInwards.Service.TestUtil/GrassCoverErosionInwardsCalculationServiceTestHelper.cs	(revision 0)
+++ Ringtoets/GrassCoverErosionInwards/test/Ringtoets.GrassCoverErosionInwards.Service.TestUtil/GrassCoverErosionInwardsCalculationServiceTestHelper.cs	(revision a1d8b4b58632ae45df9bde7fe7eaa69f3864507a)
@@ -0,0 +1,48 @@
+// Copyright (C) Stichting Deltares 2017. All rights reserved.
+//
+// This file is part of Ringtoets.
+//
+// Ringtoets is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+// 
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program. If not, see <http://www.gnu.org/licenses/>.
+//
+// All names, logos, and references to "Deltares" are registered trademarks of
+// Stichting Deltares and remain full property of Stichting Deltares at all times.
+// All rights reserved.
+
+using NUnit.Framework;
+
+namespace Ringtoets.GrassCoverErosionInwards.Service.TestUtil
+{
+    public static class GrassCoverErosionInwardsCalculationServiceTestHelper
+    {
+        public const string OvertoppingCalculationDescription = "overloop en overslag";
+        public const string OvertoppingRateCalculationDescription = "overslagdebiet";
+        public const string HbnCalculationDescription = "HBN";
+
+        public static void AssertCalculationFinishedMessage(string calculationDescription, string calculatorOutputDirectory, string actual)
+        {
+            Assert.AreEqual($"De {calculationDescription} berekening is uitgevoerd op de tijdelijke locatie '{calculatorOutputDirectory}'. " +
+                            "Gedetailleerde invoer en uitvoer kan in de bestanden op deze locatie worden gevonden.",
+                            actual);
+        }
+
+        public static void AssertCalculationFailedMessage(string calculationDescription, string calculationName, string detailedReport, string actual)
+        {
+            Assert.AreEqual($"De {calculationDescription} berekening voor grasbekleding erosie kruin en binnentalud '{calculationName}' is niet gelukt. " +
+                            (detailedReport != null
+                                 ? $"Bekijk het foutrapport door op details te klikken.\r\n{detailedReport}"
+                                 : "Er is geen foutrapport beschikbaar."),
+                            actual);
+        }
+    }
+}
\ No newline at end of file
Index: Ringtoets/GrassCoverErosionInwards/test/Ringtoets.GrassCoverErosionInwards.Service.TestUtil/Properties/AssemblyInfo.cs
===================================================================
diff -u
--- Ringtoets/GrassCoverErosionInwards/test/Ringtoets.GrassCoverErosionInwards.Service.TestUtil/Properties/AssemblyInfo.cs	(revision 0)
+++ Ringtoets/GrassCoverErosionInwards/test/Ringtoets.GrassCoverErosionInwards.Service.TestUtil/Properties/AssemblyInfo.cs	(revision a1d8b4b58632ae45df9bde7fe7eaa69f3864507a)
@@ -0,0 +1,6 @@
+using System.Reflection;
+using System.Runtime.InteropServices;
+
+[assembly: AssemblyTitle("Ringtoets.GrassCoverErosionInwards.Service.TestUtil")]
+[assembly: AssemblyProduct("Ringtoets.GrassCoverErosionInwards.Service.TestUtil")]
+[assembly: Guid("61506e11-2d00-44fe-ab74-44d5766df457")]
Index: Ringtoets/GrassCoverErosionInwards/test/Ringtoets.GrassCoverErosionInwards.Service.TestUtil/Ringtoets.GrassCoverErosionInwards.Service.TestUtil.csproj
===================================================================
diff -u
--- Ringtoets/GrassCoverErosionInwards/test/Ringtoets.GrassCoverErosionInwards.Service.TestUtil/Ringtoets.GrassCoverErosionInwards.Service.TestUtil.csproj	(revision 0)
+++ Ringtoets/GrassCoverErosionInwards/test/Ringtoets.GrassCoverErosionInwards.Service.TestUtil/Ringtoets.GrassCoverErosionInwards.Service.TestUtil.csproj	(revision a1d8b4b58632ae45df9bde7fe7eaa69f3864507a)
@@ -0,0 +1,70 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="14.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <PropertyGroup>
+    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
+    <Platform Condition=" '$(Platform)' == '' ">x86</Platform>
+    <ProjectGuid>{61506E11-2D00-44FE-AB74-44D5766DF457}</ProjectGuid>
+    <OutputType>Library</OutputType>
+    <AppDesignerFolder>Properties</AppDesignerFolder>
+    <RootNamespace>Ringtoets.GrassCoverErosionInwards.Service.TestUtil</RootNamespace>
+    <AssemblyName>Ringtoets.GrassCoverErosionInwards.Service.TestUtil</AssemblyName>
+    <TargetFrameworkVersion>v4.0</TargetFrameworkVersion>
+    <FileAlignment>512</FileAlignment>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Debug|x86'">
+    <DebugSymbols>true</DebugSymbols>
+    <OutputPath>bin\Debug\</OutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <DebugType>full</DebugType>
+    <PlatformTarget>x86</PlatformTarget>
+    <ErrorReport>prompt</ErrorReport>
+    <CodeAnalysisRuleSet>MinimumRecommendedRules.ruleset</CodeAnalysisRuleSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Release|x86'">
+    <OutputPath>bin\Release\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <Optimize>true</Optimize>
+    <DebugType>none</DebugType>
+    <PlatformTarget>x86</PlatformTarget>
+    <ErrorReport>prompt</ErrorReport>
+    <CodeAnalysisRuleSet>MinimumRecommendedRules.ruleset</CodeAnalysisRuleSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'ReleaseForCodeCoverage|x86'">
+    <OutputPath>bin\ReleaseForCodeCoverage\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <Optimize>true</Optimize>
+    <DebugType>pdbonly</DebugType>
+    <PlatformTarget>x86</PlatformTarget>
+    <ErrorReport>prompt</ErrorReport>
+    <CodeAnalysisRuleSet>MinimumRecommendedRules.ruleset</CodeAnalysisRuleSet>
+  </PropertyGroup>
+  <ItemGroup>
+    <Reference Include="nunit.framework, Version=3.6.0.0, Culture=neutral, PublicKeyToken=2638cd05610744eb, processorArchitecture=MSIL">
+      <HintPath>..\..\..\..\packages\NUnit.3.6.0\lib\net40\nunit.framework.dll</HintPath>
+      <Private>True</Private>
+    </Reference>
+    <Reference Include="System" />
+    <Reference Include="System.Core" />
+  </ItemGroup>
+  <ItemGroup>
+    <Compile Include="..\..\..\..\Core\Common\src\Core.Common.Version\GlobalAssembly.cs">
+      <Link>Properties\GlobalAssembly.cs</Link>
+    </Compile>
+    <Compile Include="GrassCoverErosionInwardsCalculationServiceTestHelper.cs" />
+    <Compile Include="Properties\AssemblyInfo.cs" />
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="..\..\..\..\build\Copying.licenseheader">
+      <Link>Copying.licenseheader</Link>
+    </None>
+    <None Include="packages.config" />
+  </ItemGroup>
+  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
+  <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
+       Other similar extension points exist, see Microsoft.Common.targets.
+  <Target Name="BeforeBuild">
+  </Target>
+  <Target Name="AfterBuild">
+  </Target>
+  -->
+</Project>
\ No newline at end of file
Index: Ringtoets/GrassCoverErosionInwards/test/Ringtoets.GrassCoverErosionInwards.Service.TestUtil/packages.config
===================================================================
diff -u
--- Ringtoets/GrassCoverErosionInwards/test/Ringtoets.GrassCoverErosionInwards.Service.TestUtil/packages.config	(revision 0)
+++ Ringtoets/GrassCoverErosionInwards/test/Ringtoets.GrassCoverErosionInwards.Service.TestUtil/packages.config	(revision a1d8b4b58632ae45df9bde7fe7eaa69f3864507a)
@@ -0,0 +1,26 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+Copyright (C) Stichting Deltares 2017. All rights reserved.
+
+This file is part of Ringtoets.
+
+Ringtoets is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program. If not, see <http://www.gnu.org/licenses/>.
+
+All names, logos, and references to "Deltares" are registered trademarks of
+Stichting Deltares and remain full property of Stichting Deltares at all times.
+All rights reserved.
+-->
+<packages>
+  <package id="NUnit" version="3.6.0" targetFramework="net40" />
+</packages>
\ No newline at end of file