Index: Ringtoets/Integration/src/Ringtoets.Integration.Service/AssessmentSectionCalculationActivityFactory.cs
===================================================================
diff -u
--- Ringtoets/Integration/src/Ringtoets.Integration.Service/AssessmentSectionCalculationActivityFactory.cs	(revision 0)
+++ Ringtoets/Integration/src/Ringtoets.Integration.Service/AssessmentSectionCalculationActivityFactory.cs	(revision a239b3f889a32a47cd41578a760febc9eb3e6ade)
@@ -0,0 +1,115 @@
+// 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 System;
+using System.Collections.Generic;
+using Ringtoets.ClosingStructures.Service;
+using Ringtoets.Common.Service;
+using Ringtoets.DuneErosion.Service;
+using Ringtoets.GrassCoverErosionInwards.Service;
+using Ringtoets.GrassCoverErosionOutwards.Service;
+using Ringtoets.HeightStructures.Service;
+using Ringtoets.Integration.Data;
+using Ringtoets.MacroStabilityInwards.Service;
+using Ringtoets.Piping.Service;
+using Ringtoets.StabilityPointStructures.Service;
+using Ringtoets.StabilityStoneCover.Service;
+using Ringtoets.WaveImpactAsphaltCover.Service;
+
+namespace Ringtoets.Integration.Service
+{
+    /// <summary>
+    /// This class defines a factory method that can be used to create instances of <see cref="CalculatableActivity"/> for
+    /// all calculations in an <see cref="AssessmentSection"/>.
+    /// </summary>
+    public static class AssessmentSectionCalculationActivityFactory
+    {
+        /// <summary>
+        /// Creates a collection of <see cref="CalculatableActivity"/> for all calculations
+        /// in the given <see cref="AssessmentSection"/>.
+        /// </summary>
+        /// <param name="assessmentSection">The assessment section to create the activities for.</param>
+        /// <returns>A collection of <see cref="CalculatableActivity"/>.</returns>
+        /// <exception cref="ArgumentNullException">Thrown when <paramref name="assessmentSection"/> is <c>null</c>.</exception>
+        public static IEnumerable<CalculatableActivity> CreateActivities(AssessmentSection assessmentSection)
+        {
+            if (assessmentSection == null)
+            {
+                throw new ArgumentNullException(nameof(assessmentSection));
+            }
+
+            var activities = new List<CalculatableActivity>();
+            activities.AddRange(AssessmentSectionHydraulicBoundaryLocationCalculationActivityFactory.CreateHydraulicBoundaryLocationCalculationActivities(assessmentSection));
+            
+            if (assessmentSection.Piping.IsRelevant)
+            {
+                activities.AddRange(PipingCalculationActivityFactory.CreateCalculationActivities(assessmentSection.Piping, assessmentSection));
+            }
+
+            if (assessmentSection.GrassCoverErosionInwards.IsRelevant)
+            {
+                activities.AddRange(GrassCoverErosionInwardsCalculationActivityFactory.CreateCalculationActivities(assessmentSection.GrassCoverErosionInwards, assessmentSection));
+            }
+
+            if (assessmentSection.MacroStabilityInwards.IsRelevant)
+            {
+                activities.AddRange(MacroStabilityInwardsCalculationActivityFactory.CreateCalculationActivities(assessmentSection.MacroStabilityInwards, assessmentSection));
+            }
+
+            if (assessmentSection.StabilityStoneCover.IsRelevant)
+            {
+                activities.AddRange(StabilityStoneCoverWaveConditionsCalculationActivityFactory.CreateCalculationActivities(assessmentSection.StabilityStoneCover, assessmentSection));
+            }
+
+            if (assessmentSection.WaveImpactAsphaltCover.IsRelevant)
+            {
+                activities.AddRange(WaveImpactAsphaltCoverWaveConditionsCalculationActivityFactory.CreateCalculationActivities(assessmentSection.WaveImpactAsphaltCover, assessmentSection));
+            }
+
+            if (assessmentSection.GrassCoverErosionOutwards.IsRelevant)
+            {
+                activities.AddRange(GrassCoverErosionOutwardsCalculationActivityFactory.CreateCalculationActivitiesWithoutAssessmentSectionCalculations(assessmentSection.GrassCoverErosionOutwards, assessmentSection));
+            }
+
+            if (assessmentSection.HeightStructures.IsRelevant)
+            {
+                activities.AddRange(HeightStructuresCalculationActivityFactory.CreateCalculationActivities(assessmentSection.HeightStructures, assessmentSection));
+            }
+
+            if (assessmentSection.ClosingStructures.IsRelevant)
+            {
+                activities.AddRange(ClosingStructuresCalculationActivityFactory.CreateCalculationActivities(assessmentSection.ClosingStructures, assessmentSection));
+            }
+
+            if (assessmentSection.StabilityPointStructures.IsRelevant)
+            {
+                activities.AddRange(StabilityPointStructuresCalculationActivityFactory.CreateCalculationActivities(assessmentSection.StabilityPointStructures, assessmentSection));
+            }
+
+            if (assessmentSection.DuneErosion.IsRelevant)
+            {
+                activities.AddRange(DuneLocationCalculationActivityFactory.CreateCalculationActivities(assessmentSection.DuneErosion, assessmentSection));
+            }
+
+            return activities;
+        }
+    }
+}
\ No newline at end of file
Index: Ringtoets/Integration/src/Ringtoets.Integration.Service/Ringtoets.Integration.Service.csproj
===================================================================
diff -u -r09cbe8d8fd52fcc80a38bcf60ca32890ef9fbbf5 -ra239b3f889a32a47cd41578a760febc9eb3e6ade
--- Ringtoets/Integration/src/Ringtoets.Integration.Service/Ringtoets.Integration.Service.csproj	(.../Ringtoets.Integration.Service.csproj)	(revision 09cbe8d8fd52fcc80a38bcf60ca32890ef9fbbf5)
+++ Ringtoets/Integration/src/Ringtoets.Integration.Service/Ringtoets.Integration.Service.csproj	(.../Ringtoets.Integration.Service.csproj)	(revision a239b3f889a32a47cd41578a760febc9eb3e6ade)
@@ -15,6 +15,7 @@
     <Reference Include="System.Core" />
   </ItemGroup>
   <ItemGroup>
+    <Compile Include="AssessmentSectionCalculationActivityFactory.cs" />
     <Compile Include="AssessmentSectionHydraulicBoundaryLocationCalculationActivityFactory.cs" />
     <Compile Include="Comparers\AssessmentSectionMergeComparer.cs" />
     <Compile Include="Comparers\IAssessmentSectionMergeComparer.cs" />
Index: Ringtoets/Integration/test/Ringtoets.Integration.Service.Test/AssessmentSectionCalculationActivityFactoryTest.cs
===================================================================
diff -u
--- Ringtoets/Integration/test/Ringtoets.Integration.Service.Test/AssessmentSectionCalculationActivityFactoryTest.cs	(revision 0)
+++ Ringtoets/Integration/test/Ringtoets.Integration.Service.Test/AssessmentSectionCalculationActivityFactoryTest.cs	(revision a239b3f889a32a47cd41578a760febc9eb3e6ade)
@@ -0,0 +1,507 @@
+// 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 System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using Core.Common.Base.Data;
+using Core.Common.Base.Geometry;
+using Core.Common.TestUtil;
+using Core.Common.Util.Extensions;
+using NUnit.Framework;
+using Rhino.Mocks;
+using Ringtoets.ClosingStructures.Data.TestUtil;
+using Ringtoets.Common.Data.AssessmentSection;
+using Ringtoets.Common.Data.DikeProfiles;
+using Ringtoets.Common.Data.FailureMechanism;
+using Ringtoets.Common.Data.Hydraulics;
+using Ringtoets.Common.Data.TestUtil;
+using Ringtoets.Common.Service;
+using Ringtoets.DuneErosion.Data.TestUtil;
+using Ringtoets.GrassCoverErosionInwards.Data;
+using Ringtoets.GrassCoverErosionOutwards.Data;
+using Ringtoets.HeightStructures.Data.TestUtil;
+using Ringtoets.HydraRing.Calculation.Calculator.Factory;
+using Ringtoets.HydraRing.Calculation.Data.Input.Structures;
+using Ringtoets.HydraRing.Calculation.TestUtil.Calculator;
+using Ringtoets.Integration.Data;
+using Ringtoets.MacroStabilityInwards.Data;
+using Ringtoets.MacroStabilityInwards.Data.TestUtil;
+using Ringtoets.MacroStabilityInwards.KernelWrapper.Kernels;
+using Ringtoets.MacroStabilityInwards.KernelWrapper.TestUtil.Kernels;
+using Ringtoets.Piping.Data;
+using Ringtoets.Piping.Data.TestUtil;
+using Ringtoets.Piping.KernelWrapper.SubCalculator;
+using Ringtoets.Piping.KernelWrapper.TestUtil.SubCalculator;
+using Ringtoets.StabilityPointStructures.Data.TestUtil;
+using Ringtoets.StabilityStoneCover.Data;
+using Ringtoets.WaveImpactAsphaltCover.Data;
+
+namespace Ringtoets.Integration.Service.Test
+{
+    [TestFixture]
+    public class AssessmentSectionCalculationActivityFactoryTest
+    {
+        private static readonly string testDataPath = TestHelper.GetTestDataPath(TestDataPath.Ringtoets.Integration.Service, "HydraRingCalculation");
+        private static readonly string validFilePath = Path.Combine(testDataPath, "HRD ijsselmeer.sqlite");
+
+        [Test]
+        public void CreateActivities_AssessmentSectionNull_ThrowsArgumentNullException()
+        {
+            // Call
+            TestDelegate test = () => AssessmentSectionCalculationActivityFactory.CreateActivities(null);
+
+            // Assert
+            var exception = Assert.Throws<ArgumentNullException>(test);
+            Assert.AreEqual("assessmentSection", exception.ParamName);
+        }
+
+        [Test]
+        public void CreateActivities_WithValidDataAndAllFailureMechanismsRelevant_ExpectedActivitiesCreated()
+        {
+            // Setup
+            AssessmentSection assessmentSection = CreateAssessmentSection();
+
+            var hydraulicBoundaryLocation = new TestHydraulicBoundaryLocation("locationName 1");
+            IEnumerable<HydraulicBoundaryLocation> hydraulicBoundaryLocations = new[]
+            {
+                hydraulicBoundaryLocation
+            };
+            assessmentSection.SetHydraulicBoundaryLocationCalculations(hydraulicBoundaryLocations);
+            assessmentSection.GrassCoverErosionOutwards.SetHydraulicBoundaryLocationCalculations(hydraulicBoundaryLocations);
+
+            AddGrassCoverErosionInwardsCalculation(assessmentSection, hydraulicBoundaryLocation);
+            AddPipingCalculationScenario(assessmentSection, hydraulicBoundaryLocation);
+            AddMacroStabilityInwardsCalculationScenario(assessmentSection, hydraulicBoundaryLocation);
+            AddStabilityStoneCoverCalculation(assessmentSection, hydraulicBoundaryLocation);
+            AddWaveImpactAsphaltCoverCalculation(assessmentSection, hydraulicBoundaryLocation);
+            AddGrassCoverErosionOutwardsCalculation(assessmentSection, hydraulicBoundaryLocation);
+            AddHeightStructuresCalculation(assessmentSection, hydraulicBoundaryLocation);
+            AddClosingStructuresCalculation(assessmentSection, hydraulicBoundaryLocation);
+            AddStabilityPointStructuresCalculation(assessmentSection, hydraulicBoundaryLocation);
+            AddDuneLocationCalculation(assessmentSection);
+
+            var mocks = new MockRepository();
+            var calculatorFactory = mocks.StrictMock<IHydraRingCalculatorFactory>();
+
+            using (mocks.Ordered())
+            {
+                calculatorFactory.Expect(cf => cf.CreateDesignWaterLevelCalculator(testDataPath, ""))
+                                 .Return(new TestDesignWaterLevelCalculator
+                                 {
+                                     DesignWaterLevel = 2.0
+                                 }).Repeat.Times(4);
+                calculatorFactory.Expect(cf => cf.CreateWaveHeightCalculator(testDataPath, ""))
+                                 .Return(new TestWaveHeightCalculator()).Repeat.Times(4);
+
+                calculatorFactory.Expect(cf => cf.CreateOvertoppingCalculator(testDataPath, ""))
+                                 .Return(new TestOvertoppingCalculator());
+
+                calculatorFactory.Expect(cf => cf.CreateWaveConditionsCosineCalculator(testDataPath, ""))
+                                 .Return(new TestWaveConditionsCosineCalculator()).Repeat.Times(9);
+
+                calculatorFactory.Expect(cf => cf.CreateDesignWaterLevelCalculator(testDataPath, ""))
+                                 .Return(new TestDesignWaterLevelCalculator()).Repeat.Times(3);
+                calculatorFactory.Expect(cf => cf.CreateWaveHeightCalculator(testDataPath, ""))
+                                 .Return(new TestWaveHeightCalculator()).Repeat.Times(3);
+
+                calculatorFactory.Expect(cf => cf.CreateWaveConditionsCosineCalculator(testDataPath, ""))
+                                 .Return(new TestWaveConditionsCosineCalculator()).Repeat.Times(3);
+
+                calculatorFactory.Expect(cf => cf.CreateStructuresCalculator<StructuresOvertoppingCalculationInput>(testDataPath, ""))
+                                 .Return(new TestStructuresCalculator<StructuresOvertoppingCalculationInput>());
+
+                calculatorFactory.Expect(cf => cf.CreateStructuresCalculator<StructuresClosureCalculationInput>(testDataPath, ""))
+                                 .Return(new TestStructuresCalculator<StructuresClosureCalculationInput>());
+
+                calculatorFactory.Expect(cf => cf.CreateStructuresCalculator<StructuresStabilityPointCalculationInput>(testDataPath, ""))
+                                 .Return(new TestStructuresCalculator<StructuresStabilityPointCalculationInput>());
+
+                calculatorFactory.Expect(cf => cf.CreateDunesBoundaryConditionsCalculator(testDataPath, ""))
+                                 .Return(new TestDunesBoundaryConditionsCalculator()).Repeat.Times(5);
+            }
+
+            mocks.ReplayAll();
+
+            // Call
+            IEnumerable<CalculatableActivity> activities =
+                AssessmentSectionCalculationActivityFactory.CreateActivities(assessmentSection);
+
+            // Assert
+            Assert.AreEqual(28, activities.Count());
+
+            using (new HydraRingCalculatorFactoryConfig(calculatorFactory))
+            using (new PipingSubCalculatorFactoryConfig())
+            using (new MacroStabilityInwardsKernelFactoryConfig())
+            {
+                // Run hydraulic boundary location calculations first
+                activities.Take(8).ForEachElementDo(activity => activity.Run());
+
+                var pipingTestFactory = (TestPipingSubCalculatorFactory) PipingSubCalculatorFactory.Instance;
+                var macroStabilityTestFactory = (TestMacroStabilityInwardsKernelFactory) MacroStabilityInwardsKernelWrapperFactory.Instance;
+                Assert.IsFalse(pipingTestFactory.LastCreatedUpliftCalculator.Calculated);
+                Assert.IsFalse(macroStabilityTestFactory.LastCreatedUpliftVanKernel.Calculated);
+
+                activities.Skip(8).ForEachElementDo(activity => activity.Run());
+
+                Assert.IsTrue(pipingTestFactory.LastCreatedUpliftCalculator.Calculated);
+                Assert.IsTrue(macroStabilityTestFactory.LastCreatedUpliftVanKernel.Calculated);
+            }
+
+            mocks.VerifyAll();
+        }
+
+        [Test]
+        public void CreateActivities_PipingNotRelevant_NoActivitiesCreated()
+        {
+            // Setup
+            AssessmentSection assessmentSection = CreateAssessmentSection();
+            assessmentSection.Piping.IsRelevant = false;
+
+            AddPipingCalculationScenario(assessmentSection, new TestHydraulicBoundaryLocation());
+
+            // Call
+            IEnumerable<CalculatableActivity> activities =
+                AssessmentSectionCalculationActivityFactory.CreateActivities(assessmentSection);
+
+            // Assert
+            Assert.AreEqual(0, activities.Count());
+        }
+
+        [Test]
+        public void CreateActivities_GrassCoverErosionInwardsNotRelevant_NoActivitiesCreated()
+        {
+            // Setup
+            AssessmentSection assessmentSection = CreateAssessmentSection();
+            assessmentSection.GrassCoverErosionInwards.IsRelevant = false;
+
+            AddGrassCoverErosionInwardsCalculation(assessmentSection, new TestHydraulicBoundaryLocation());
+
+            // Call
+            IEnumerable<CalculatableActivity> activities =
+                AssessmentSectionCalculationActivityFactory.CreateActivities(assessmentSection);
+
+            // Assert
+            Assert.AreEqual(0, activities.Count());
+        }
+
+        [Test]
+        public void CreateActivities_MacroStabilityInwardsNotRelevant_NoActivitiesCreated()
+        {
+            // Setup
+            AssessmentSection assessmentSection = CreateAssessmentSection();
+            assessmentSection.MacroStabilityInwards.IsRelevant = false;
+
+            AddMacroStabilityInwardsCalculationScenario(assessmentSection, new TestHydraulicBoundaryLocation());
+
+            // Call
+            IEnumerable<CalculatableActivity> activities =
+                AssessmentSectionCalculationActivityFactory.CreateActivities(assessmentSection);
+
+            // Assert
+            Assert.AreEqual(0, activities.Count());
+        }
+
+        [Test]
+        public void CreateActivities_StabilityStoneCoverNotRelevant_NoActivitiesCreated()
+        {
+            // Setup
+            AssessmentSection assessmentSection = CreateAssessmentSection();
+            assessmentSection.StabilityStoneCover.IsRelevant = false;
+
+            AddStabilityStoneCoverCalculation(assessmentSection, new TestHydraulicBoundaryLocation());
+
+            // Call
+            IEnumerable<CalculatableActivity> activities =
+                AssessmentSectionCalculationActivityFactory.CreateActivities(assessmentSection);
+
+            // Assert
+            Assert.AreEqual(0, activities.Count());
+        }
+
+        [Test]
+        public void CreateActivities_WaveImpactAsphaltCoverNotRelevant_NoActivitiesCreated()
+        {
+            // Setup
+            AssessmentSection assessmentSection = CreateAssessmentSection();
+            assessmentSection.WaveImpactAsphaltCover.IsRelevant = false;
+
+            AddWaveImpactAsphaltCoverCalculation(assessmentSection, new TestHydraulicBoundaryLocation());
+
+            // Call
+            IEnumerable<CalculatableActivity> activities =
+                AssessmentSectionCalculationActivityFactory.CreateActivities(assessmentSection);
+
+            // Assert
+            Assert.AreEqual(0, activities.Count());
+        }
+
+        [Test]
+        public void CreateActivities_GrassCoverErosionOutwardsNotRelevant_NoActivitiesCreated()
+        {
+            // Setup
+            AssessmentSection assessmentSection = CreateAssessmentSection();
+            assessmentSection.GrassCoverErosionOutwards.IsRelevant = false;
+
+            AddGrassCoverErosionOutwardsCalculation(assessmentSection, new TestHydraulicBoundaryLocation());
+
+            // Call
+            IEnumerable<CalculatableActivity> activities =
+                AssessmentSectionCalculationActivityFactory.CreateActivities(assessmentSection);
+
+            // Assert
+            Assert.AreEqual(0, activities.Count());
+        }
+
+        [Test]
+        public void CreateActivities_HeightStructuresNotRelevant_NoActivitiesCreated()
+        {
+            // Setup
+            AssessmentSection assessmentSection = CreateAssessmentSection();
+            assessmentSection.HeightStructures.IsRelevant = false;
+
+            AddHeightStructuresCalculation(assessmentSection, new TestHydraulicBoundaryLocation());
+
+            // Call
+            IEnumerable<CalculatableActivity> activities =
+                AssessmentSectionCalculationActivityFactory.CreateActivities(assessmentSection);
+
+            // Assert
+            Assert.AreEqual(0, activities.Count());
+        }
+
+        [Test]
+        public void CreateActivities_ClosingStructuresNotRelevant_NoActivitiesCreated()
+        {
+            // Setup
+            AssessmentSection assessmentSection = CreateAssessmentSection();
+            assessmentSection.ClosingStructures.IsRelevant = false;
+
+            AddClosingStructuresCalculation(assessmentSection, new TestHydraulicBoundaryLocation());
+
+            // Call
+            IEnumerable<CalculatableActivity> activities =
+                AssessmentSectionCalculationActivityFactory.CreateActivities(assessmentSection);
+
+            // Assert
+            Assert.AreEqual(0, activities.Count());
+        }
+
+        [Test]
+        public void CreateActivities_StabilityPointStructuresNotRelevant_NoActivitiesCreated()
+        {
+            // Setup
+            AssessmentSection assessmentSection = CreateAssessmentSection();
+            assessmentSection.StabilityPointStructures.IsRelevant = false;
+
+            AddStabilityPointStructuresCalculation(assessmentSection, new TestHydraulicBoundaryLocation());
+
+            // Call
+            IEnumerable<CalculatableActivity> activities =
+                AssessmentSectionCalculationActivityFactory.CreateActivities(assessmentSection);
+
+            // Assert
+            Assert.AreEqual(0, activities.Count());
+        }
+
+        [Test]
+        public void CreateActivities_DuneErosionNotRelevant_NoActivitiesCreated()
+        {
+            // Setup
+            AssessmentSection assessmentSection = CreateAssessmentSection();
+            assessmentSection.DuneErosion.IsRelevant = false;
+
+            AddDuneLocationCalculation(assessmentSection);
+
+            // Call
+            IEnumerable<CalculatableActivity> activities =
+                AssessmentSectionCalculationActivityFactory.CreateActivities(assessmentSection);
+
+            // Assert
+            Assert.AreEqual(0, activities.Count());
+        }
+
+        private static void AddDuneLocationCalculation(AssessmentSection assessmentSection)
+        {
+            var duneLocation = new TestDuneLocation();
+            assessmentSection.DuneErosion.SetDuneLocations(new[]
+            {
+                duneLocation
+            });
+        }
+
+        private static AssessmentSection CreateAssessmentSection()
+        {
+            var assessmentSection = new AssessmentSection(AssessmentSectionComposition.DikeAndDune);
+
+            assessmentSection.HydraulicBoundaryDatabase.FilePath = validFilePath;
+
+            return assessmentSection;
+        }
+
+        private static void AddGrassCoverErosionInwardsCalculation(AssessmentSection assessmentSection,
+                                                                   HydraulicBoundaryLocation hydraulicBoundaryLocation)
+        {
+            assessmentSection.GrassCoverErosionInwards.CalculationsGroup.Children.Add(new GrassCoverErosionInwardsCalculation
+            {
+                InputParameters =
+                {
+                    HydraulicBoundaryLocation = hydraulicBoundaryLocation,
+                    DikeProfile = new DikeProfile(new Point2D(0, 0),
+                                                  new RoughnessPoint[0],
+                                                  new Point2D[0],
+                                                  new BreakWater(BreakWaterType.Dam, new Random(39).NextDouble()),
+                                                  new DikeProfile.ConstructionProperties
+                                                  {
+                                                      Id = "id"
+                                                  })
+                }
+            });
+        }
+
+        private static void AddPipingCalculationScenario(AssessmentSection assessmentSection,
+                                                         HydraulicBoundaryLocation hydraulicBoundaryLocation)
+        {
+            PipingCalculationScenario pipingCalculationScenario = PipingCalculationScenarioTestFactory.CreatePipingCalculationScenarioWithValidInput(hydraulicBoundaryLocation);
+            pipingCalculationScenario.InputParameters.UseAssessmentLevelManualInput = true;
+            pipingCalculationScenario.InputParameters.AssessmentLevel = new Random(39).NextRoundedDouble();
+            assessmentSection.Piping.CalculationsGroup.Children.Add(pipingCalculationScenario);
+        }
+
+        private static void AddMacroStabilityInwardsCalculationScenario(AssessmentSection assessmentSection,
+                                                                        HydraulicBoundaryLocation hydraulicBoundaryLocation)
+        {
+            MacroStabilityInwardsCalculationScenario macroStabilityInwardsCalculationScenario =
+                MacroStabilityInwardsCalculationScenarioTestFactory.CreateMacroStabilityInwardsCalculationScenarioWithValidInput(hydraulicBoundaryLocation);
+            macroStabilityInwardsCalculationScenario.InputParameters.UseAssessmentLevelManualInput = true;
+            macroStabilityInwardsCalculationScenario.InputParameters.AssessmentLevel = new Random(39).NextRoundedDouble();
+            assessmentSection.MacroStabilityInwards.CalculationsGroup.Children.Add(macroStabilityInwardsCalculationScenario);
+        }
+
+        private static void AddStabilityStoneCoverCalculation(AssessmentSection assessmentSection,
+                                                              HydraulicBoundaryLocation hydraulicBoundaryLocation)
+        {
+            assessmentSection.StabilityStoneCover.WaveConditionsCalculationGroup.Children.Add(new StabilityStoneCoverWaveConditionsCalculation
+            {
+                InputParameters =
+                {
+                    HydraulicBoundaryLocation = hydraulicBoundaryLocation,
+                    CategoryType = AssessmentSectionCategoryType.FactorizedLowerLimitNorm,
+                    ForeshoreProfile = new TestForeshoreProfile(true)
+                    {
+                        BreakWater =
+                        {
+                            Height = new Random(39).NextRoundedDouble()
+                        }
+                    },
+                    UseForeshore = true,
+                    UseBreakWater = true,
+                    LowerBoundaryRevetment = (RoundedDouble) 1,
+                    UpperBoundaryRevetment = (RoundedDouble) 3,
+                    LowerBoundaryWaterLevels = (RoundedDouble) 1,
+                    UpperBoundaryWaterLevels = (RoundedDouble) 3
+                }
+            });
+        }
+
+        private static void AddWaveImpactAsphaltCoverCalculation(AssessmentSection assessmentSection,
+                                                                 HydraulicBoundaryLocation hydraulicBoundaryLocation)
+        {
+            assessmentSection.WaveImpactAsphaltCover.WaveConditionsCalculationGroup.Children.Add(new WaveImpactAsphaltCoverWaveConditionsCalculation
+            {
+                InputParameters =
+                {
+                    HydraulicBoundaryLocation = hydraulicBoundaryLocation,
+                    CategoryType = AssessmentSectionCategoryType.FactorizedLowerLimitNorm,
+                    ForeshoreProfile = new TestForeshoreProfile(true)
+                    {
+                        BreakWater =
+                        {
+                            Height = new Random(39).NextRoundedDouble()
+                        }
+                    },
+                    UseForeshore = true,
+                    UseBreakWater = true,
+                    LowerBoundaryRevetment = (RoundedDouble) 1,
+                    UpperBoundaryRevetment = (RoundedDouble) 3,
+                    LowerBoundaryWaterLevels = (RoundedDouble) 1,
+                    UpperBoundaryWaterLevels = (RoundedDouble) 3
+                }
+            });
+        }
+
+        private static void AddGrassCoverErosionOutwardsCalculation(AssessmentSection assessmentSection,
+                                                                    HydraulicBoundaryLocation hydraulicBoundaryLocation)
+        {
+            assessmentSection.GrassCoverErosionOutwards.WaveConditionsCalculationGroup.Children.Add(new GrassCoverErosionOutwardsWaveConditionsCalculation
+            {
+                InputParameters =
+                {
+                    HydraulicBoundaryLocation = hydraulicBoundaryLocation,
+                    CategoryType = FailureMechanismCategoryType.FactorizedLowerLimitNorm,
+                    UseBreakWater = true,
+                    LowerBoundaryRevetment = (RoundedDouble) 1,
+                    UpperBoundaryRevetment = (RoundedDouble) 3,
+                    LowerBoundaryWaterLevels = (RoundedDouble) 1,
+                    UpperBoundaryWaterLevels = (RoundedDouble) 3,
+                    Orientation = (RoundedDouble) 10
+                }
+            });
+        }
+
+        private static void AddHeightStructuresCalculation(AssessmentSection assessmentSection,
+                                                           HydraulicBoundaryLocation hydraulicBoundaryLocation)
+        {
+            assessmentSection.HeightStructures.CalculationsGroup.Children.Add(new TestHeightStructuresCalculation
+            {
+                InputParameters =
+                {
+                    HydraulicBoundaryLocation = hydraulicBoundaryLocation
+                }
+            });
+        }
+
+        private static void AddClosingStructuresCalculation(AssessmentSection assessmentSection,
+                                                            HydraulicBoundaryLocation hydraulicBoundaryLocation)
+        {
+            assessmentSection.ClosingStructures.CalculationsGroup.Children.Add(new TestClosingStructuresCalculation
+            {
+                InputParameters =
+                {
+                    HydraulicBoundaryLocation = hydraulicBoundaryLocation
+                }
+            });
+        }
+
+        private static void AddStabilityPointStructuresCalculation(AssessmentSection assessmentSection,
+                                                                   HydraulicBoundaryLocation hydraulicBoundaryLocation)
+        {
+            assessmentSection.StabilityPointStructures.CalculationsGroup.Children.Add(new TestStabilityPointStructuresCalculation
+            {
+                InputParameters =
+                {
+                    HydraulicBoundaryLocation = hydraulicBoundaryLocation
+                }
+            });
+        }
+    }
+}
\ No newline at end of file
Index: Ringtoets/Integration/test/Ringtoets.Integration.Service.Test/Ringtoets.Integration.Service.Test.csproj
===================================================================
diff -u -r09cbe8d8fd52fcc80a38bcf60ca32890ef9fbbf5 -ra239b3f889a32a47cd41578a760febc9eb3e6ade
--- Ringtoets/Integration/test/Ringtoets.Integration.Service.Test/Ringtoets.Integration.Service.Test.csproj	(.../Ringtoets.Integration.Service.Test.csproj)	(revision 09cbe8d8fd52fcc80a38bcf60ca32890ef9fbbf5)
+++ Ringtoets/Integration/test/Ringtoets.Integration.Service.Test/Ringtoets.Integration.Service.Test.csproj	(.../Ringtoets.Integration.Service.Test.csproj)	(revision a239b3f889a32a47cd41578a760febc9eb3e6ade)
@@ -19,6 +19,7 @@
     <Reference Include="System.Core" />
   </ItemGroup>
   <ItemGroup>
+    <Compile Include="AssessmentSectionCalculationActivityFactoryTest.cs" />
     <Compile Include="Comparers\AssessmentSectionMergeComparerTest.cs" />
     <Compile Include="Exceptions\LoadAssessmentSectionExceptionTest.cs" />
     <Compile Include="Merge\LoadAssessmentSectionsActivityFactoryTest.cs" />
@@ -51,6 +52,10 @@
       <Project>{C6309704-D67B-434C-BC98-9F8910BC1D10}</Project>
       <Name>Ringtoets.ClosingStructures.Data</Name>
     </ProjectReference>
+    <ProjectReference Include="..\..\..\ClosingStructures\test\Ringtoets.ClosingStructures.Data.TestUtil\Ringtoets.ClosingStructures.Data.TestUtil.csproj">
+      <Project>{F5B43C29-6169-4E9A-859E-09090330B94E}</Project>
+      <Name>Ringtoets.ClosingStructures.Data.TestUtil</Name>
+    </ProjectReference>
     <ProjectReference Include="..\..\..\Common\src\Ringtoets.Common.Data\Ringtoets.Common.Data.csproj">
       <Project>{D4200F43-3F72-4F42-AF0A-8CED416A38EC}</Project>
       <Name>Ringtoets.Common.Data</Name>
@@ -63,10 +68,6 @@
       <Project>{4843d6e5-066f-4795-94f5-1d53932dd03c}</Project>
       <Name>Ringtoets.Common.Data.TestUtil</Name>
     </ProjectReference>
-    <ProjectReference Include="..\..\..\Common\test\Ringtoets.Common.Service.TestUtil\Ringtoets.Common.Service.TestUtil.csproj">
-      <Project>{52093DA6-D545-476A-ADFD-12F56625E36B}</Project>
-      <Name>Ringtoets.Common.Service.TestUtil</Name>
-    </ProjectReference>
     <ProjectReference Include="..\..\..\DuneErosion\src\Ringtoets.DuneErosion.Data\Ringtoets.DuneErosion.Data.csproj">
       <Project>{D1068432-C172-4AA6-847B-D9DEB4C6DE26}</Project>
       <Name>Ringtoets.DuneErosion.Data</Name>
@@ -91,6 +92,10 @@
       <Project>{1C0017D8-35B5-4CA0-8FC7-A83F46DBDC99}</Project>
       <Name>Ringtoets.HeightStructures.Data</Name>
     </ProjectReference>
+    <ProjectReference Include="..\..\..\HeightStructures\test\Ringtoets.HeightStructures.Data.TestUtil\Ringtoets.HeightStructures.Data.TestUtil.csproj">
+      <Project>{F67E8AE8-1FF0-4680-9817-99E025CD9FF6}</Project>
+      <Name>Ringtoets.HeightStructures.Data.TestUtil</Name>
+    </ProjectReference>
     <ProjectReference Include="..\..\..\HydraRing\src\Ringtoets.HydraRing.Calculation\Ringtoets.HydraRing.Calculation.csproj">
       <Project>{888D4097-8BC2-4703-9FB1-8744C94D525E}</Project>
       <Name>Ringtoets.HydraRing.Calculation</Name>
@@ -103,18 +108,42 @@
       <Project>{83D6B73E-91D5-46B0-9218-955DA1F75F7C}</Project>
       <Name>Ringtoets.MacroStabilityInwards.Data</Name>
     </ProjectReference>
+    <ProjectReference Include="..\..\..\MacroStabilityInwards\src\Ringtoets.MacroStabilityInwards.KernelWrapper\Ringtoets.MacroStabilityInwards.KernelWrapper.csproj">
+      <Project>{3C0D3B38-A9F7-4B22-9705-513DA26AE2CC}</Project>
+      <Name>Ringtoets.MacroStabilityInwards.KernelWrapper</Name>
+    </ProjectReference>
     <ProjectReference Include="..\..\..\MacroStabilityInwards\src\Ringtoets.MacroStabilityInwards.Primitives\Ringtoets.MacroStabilityInwards.Primitives.csproj">
       <Project>{E9B39743-2DC9-4922-9E0F-6BA3E0E54189}</Project>
       <Name>Ringtoets.MacroStabilityInwards.Primitives</Name>
     </ProjectReference>
+    <ProjectReference Include="..\..\..\MacroStabilityInwards\test\Ringtoets.MacroStabilityInwards.Data.TestUtil\Ringtoets.MacroStabilityInwards.Data.TestUtil.csproj">
+      <Project>{2B78CF04-4785-4F27-A6E5-45BDDBB7BF04}</Project>
+      <Name>Ringtoets.MacroStabilityInwards.Data.TestUtil</Name>
+    </ProjectReference>
+    <ProjectReference Include="..\..\..\MacroStabilityInwards\test\Ringtoets.MacroStabilityInwards.KernelWrapper.TestUtil\Ringtoets.MacroStabilityInwards.KernelWrapper.TestUtil.csproj">
+      <Project>{3810D738-6412-47D1-8BC0-729D55BC951F}</Project>
+      <Name>Ringtoets.MacroStabilityInwards.KernelWrapper.TestUtil</Name>
+    </ProjectReference>
     <ProjectReference Include="..\..\..\Piping\src\Ringtoets.Piping.Data\Ringtoets.Piping.Data.csproj">
       <Project>{CE994CC9-6F6A-48AC-B4BE-02C30A21F4DB}</Project>
       <Name>Ringtoets.Piping.Data</Name>
     </ProjectReference>
+    <ProjectReference Include="..\..\..\Piping\src\Ringtoets.Piping.KernelWrapper\Ringtoets.Piping.KernelWrapper.csproj">
+      <Project>{D64E4F0E-E341-496F-82B2-941AD202B4E3}</Project>
+      <Name>Ringtoets.Piping.KernelWrapper</Name>
+    </ProjectReference>
     <ProjectReference Include="..\..\..\Piping\src\Ringtoets.Piping.Primitives\Ringtoets.Piping.Primitives.csproj">
       <Project>{14c6f716-64e2-4bc4-a1ef-05865fcefa4c}</Project>
       <Name>Ringtoets.Piping.Primitives</Name>
     </ProjectReference>
+    <ProjectReference Include="..\..\..\Piping\test\Ringtoets.Piping.Data.TestUtil\Ringtoets.Piping.Data.TestUtil.csproj">
+      <Project>{955E574D-67CE-4347-AA6B-7DF8A04ED754}</Project>
+      <Name>Ringtoets.Piping.Data.TestUtil</Name>
+    </ProjectReference>
+    <ProjectReference Include="..\..\..\Piping\test\Ringtoets.Piping.KernelWrapper.TestUtil\Ringtoets.Piping.KernelWrapper.TestUtil.csproj">
+      <Project>{27E0A5C9-3ABF-426A-A3DA-7D0B83A218C8}</Project>
+      <Name>Ringtoets.Piping.KernelWrapper.TestUtil</Name>
+    </ProjectReference>
     <ProjectReference Include="..\..\..\Revetment\src\Ringtoets.Revetment.Data\Ringtoets.Revetment.Data.csproj">
       <Project>{87C2C553-C0BC-40BF-B1EA-B83BFF357F27}</Project>
       <Name>Ringtoets.Revetment.Data</Name>
@@ -123,6 +152,10 @@
       <Project>{3D4B9740-8348-4434-8D77-B611FC6EE57F}</Project>
       <Name>Ringtoets.StabilityPointStructures.Data</Name>
     </ProjectReference>
+    <ProjectReference Include="..\..\..\StabilityPointStructures\test\Ringtoets.StabilityPointStructures.Data.TestUtil\Ringtoets.StabilityPointStructures.Data.TestUtil.csproj">
+      <Project>{E9AC095B-8F10-41D2-9456-4A85E3BA91AD}</Project>
+      <Name>Ringtoets.StabilityPointStructures.Data.TestUtil</Name>
+    </ProjectReference>
     <ProjectReference Include="..\..\..\StabilityStoneCover\src\Ringtoets.StabilityStoneCover.Data\Ringtoets.StabilityStoneCover.Data.csproj">
       <Project>{B479E3AF-7C34-488C-BB73-D324100D36C9}</Project>
       <Name>Ringtoets.StabilityStoneCover.Data</Name>