Index: Ringtoets/Integration/src/Ringtoets.Integration.Plugin/FileImporters/ForeshoreProfileReplaceDataStrategy.cs
===================================================================
diff -u -r670a5510c7638037a4f7e0c3efea0a261085bfbb -r91d2618c244882958683e28675970ef50bbf2fe6
--- Ringtoets/Integration/src/Ringtoets.Integration.Plugin/FileImporters/ForeshoreProfileReplaceDataStrategy.cs	(.../ForeshoreProfileReplaceDataStrategy.cs)	(revision 670a5510c7638037a4f7e0c3efea0a261085bfbb)
+++ Ringtoets/Integration/src/Ringtoets.Integration.Plugin/FileImporters/ForeshoreProfileReplaceDataStrategy.cs	(.../ForeshoreProfileReplaceDataStrategy.cs)	(revision 91d2618c244882958683e28675970ef50bbf2fe6)
@@ -27,12 +27,12 @@
 using Ringtoets.Common.Data.DikeProfiles;
 using Ringtoets.Common.Data.Exceptions;
 using Ringtoets.Common.Data.FailureMechanism;
-using Ringtoets.Common.Data.Structures;
 using Ringtoets.Common.Data.UpdateDataStrategies;
 using Ringtoets.Common.IO.FileImporters;
 using Ringtoets.GrassCoverErosionOutwards.Data;
 using Ringtoets.HeightStructures.Data;
 using Ringtoets.Integration.Plugin.Properties;
+using Ringtoets.Integration.Service;
 using Ringtoets.StabilityPointStructures.Data;
 using Ringtoets.StabilityStoneCover.Data;
 using Ringtoets.WaveImpactAsphaltCover.Data;
@@ -92,154 +92,40 @@
             var waveImpactAsphaltCoverFailureMechanism = failureMechanism as WaveImpactAsphaltCoverFailureMechanism;
             if (waveImpactAsphaltCoverFailureMechanism != null)
             {
-                return ClearForeshoreProfilesDependentData(waveImpactAsphaltCoverFailureMechanism);
+                return RingtoetsDataSynchronizationService.RemoveAllForeshoreProfiles(waveImpactAsphaltCoverFailureMechanism);
             }
 
             var stabilityStoneCoverFailureMechanism = failureMechanism as StabilityStoneCoverFailureMechanism;
             if (stabilityStoneCoverFailureMechanism != null)
             {
-                return ClearForeshoreProfilesDependentData(stabilityStoneCoverFailureMechanism);
+                return RingtoetsDataSynchronizationService.RemoveAllForeshoreProfiles(stabilityStoneCoverFailureMechanism);
             }
 
             var grassCoverErosionOutwardsFailureMechanism = failureMechanism as GrassCoverErosionOutwardsFailureMechanism;
             if (grassCoverErosionOutwardsFailureMechanism != null)
             {
-                return ClearForeshoreProfilesDependentData(grassCoverErosionOutwardsFailureMechanism);
+                return RingtoetsDataSynchronizationService.RemoveAllForeshoreProfiles(grassCoverErosionOutwardsFailureMechanism);
             }
 
             var heightStructuresFailureMechanism = failureMechanism as HeightStructuresFailureMechanism;
             if (heightStructuresFailureMechanism != null)
             {
-                return ClearForeshoreProfilesDependentData(heightStructuresFailureMechanism);
+                return RingtoetsDataSynchronizationService.RemoveAllForeshoreProfiles(heightStructuresFailureMechanism);
             }
 
             var stabilityPointStructuresFailureMechanism = failureMechanism as StabilityPointStructuresFailureMechanism;
             if (stabilityPointStructuresFailureMechanism != null)
             {
-                return ClearForeshoreProfilesDependentData(stabilityPointStructuresFailureMechanism);
+                return RingtoetsDataSynchronizationService.RemoveAllForeshoreProfiles(stabilityPointStructuresFailureMechanism);
             }
 
             var closingStructuresFailureMechanism = failureMechanism as ClosingStructuresFailureMechanism;
             if (closingStructuresFailureMechanism != null)
             {
-                return ClearForeshoreProfileDependentData(closingStructuresFailureMechanism);
+                return RingtoetsDataSynchronizationService.RemoveAllForeshoreProfiles(closingStructuresFailureMechanism);
             }
 
             return Enumerable.Empty<IObservable>();
         }
-
-        private static IEnumerable<IObservable> ClearForeshoreProfileDependentData(ClosingStructuresFailureMechanism closingStructuresFailureMechanism)
-        {
-            IEnumerable<StructuresCalculation<ClosingStructuresInput>> affectedCalculations =
-                closingStructuresFailureMechanism.Calculations
-                                                 .OfType<StructuresCalculation<ClosingStructuresInput>>()
-                                                 .Where(calc => calc.InputParameters.ForeshoreProfile != null);
-
-            var affectedObjects = new List<IObservable>();
-            foreach (var calculation in affectedCalculations)
-            {
-                calculation.InputParameters.ForeshoreProfile = null;
-                affectedObjects.Add(calculation.InputParameters);
-            }
-
-            closingStructuresFailureMechanism.ForeshoreProfiles.Clear();
-            affectedObjects.Add(closingStructuresFailureMechanism.ForeshoreProfiles);
-            return affectedObjects;
-        }
-
-        private static IEnumerable<IObservable> ClearForeshoreProfilesDependentData(StabilityPointStructuresFailureMechanism stabilityPointStructuresFailureMechanism)
-        {
-            IEnumerable<StructuresCalculation<StabilityPointStructuresInput>> affectedCalculations =
-                stabilityPointStructuresFailureMechanism.Calculations
-                                                        .OfType<StructuresCalculation<StabilityPointStructuresInput>>()
-                                                        .Where(calc => calc.InputParameters.ForeshoreProfile != null);
-
-            var affectedObjects = new List<IObservable>();
-            foreach (var calculation in affectedCalculations)
-            {
-                calculation.InputParameters.ForeshoreProfile = null;
-                affectedObjects.Add(calculation.InputParameters);
-            }
-
-            stabilityPointStructuresFailureMechanism.ForeshoreProfiles.Clear();
-            affectedObjects.Add(stabilityPointStructuresFailureMechanism.ForeshoreProfiles);
-            return affectedObjects;
-        }
-
-        private static IEnumerable<IObservable> ClearForeshoreProfilesDependentData(HeightStructuresFailureMechanism heightStructuresFailureMechanism)
-        {
-            IEnumerable<StructuresCalculation<HeightStructuresInput>> affectedCalculations =
-                heightStructuresFailureMechanism.Calculations
-                                                .OfType<StructuresCalculation<HeightStructuresInput>>()
-                                                .Where(calc => calc.InputParameters.ForeshoreProfile != null);
-
-            var affectedObjects = new List<IObservable>();
-            foreach (var calculation in affectedCalculations)
-            {
-                calculation.InputParameters.ForeshoreProfile = null;
-                affectedObjects.Add(calculation.InputParameters);
-            }
-
-            heightStructuresFailureMechanism.ForeshoreProfiles.Clear();
-            affectedObjects.Add(heightStructuresFailureMechanism.ForeshoreProfiles);
-            return affectedObjects;
-        }
-
-        private static IEnumerable<IObservable> ClearForeshoreProfilesDependentData(GrassCoverErosionOutwardsFailureMechanism grassCoverErosionOutwardsFailureMechanism)
-        {
-            IEnumerable<GrassCoverErosionOutwardsWaveConditionsCalculation> affectedCalculations =
-                grassCoverErosionOutwardsFailureMechanism.Calculations
-                                                         .OfType<GrassCoverErosionOutwardsWaveConditionsCalculation>()
-                                                         .Where(calc => calc.InputParameters.ForeshoreProfile != null);
-
-            var affectedObjects = new List<IObservable>();
-            foreach (var calculation in affectedCalculations)
-            {
-                calculation.InputParameters.ForeshoreProfile = null;
-                affectedObjects.Add(calculation.InputParameters);
-            }
-
-            grassCoverErosionOutwardsFailureMechanism.ForeshoreProfiles.Clear();
-            affectedObjects.Add(grassCoverErosionOutwardsFailureMechanism.ForeshoreProfiles);
-            return affectedObjects;
-        }
-
-        private static IEnumerable<IObservable> ClearForeshoreProfilesDependentData(StabilityStoneCoverFailureMechanism stabilityStoneCoverFailureMechanism)
-        {
-            IEnumerable<StabilityStoneCoverWaveConditionsCalculation> affectedCalculations =
-                stabilityStoneCoverFailureMechanism.Calculations
-                                                   .OfType<StabilityStoneCoverWaveConditionsCalculation>()
-                                                   .Where(calc => calc.InputParameters.ForeshoreProfile != null);
-
-            var affectedObjects = new List<IObservable>();
-            foreach (var calculation in affectedCalculations)
-            {
-                calculation.InputParameters.ForeshoreProfile = null;
-                affectedObjects.Add(calculation.InputParameters);
-            }
-
-            stabilityStoneCoverFailureMechanism.ForeshoreProfiles.Clear();
-            affectedObjects.Add(stabilityStoneCoverFailureMechanism.ForeshoreProfiles);
-            return affectedObjects;
-        }
-
-        private static IEnumerable<IObservable> ClearForeshoreProfilesDependentData(WaveImpactAsphaltCoverFailureMechanism waveImpactAsphaltCoverFailureMechanism)
-        {
-            IEnumerable<WaveImpactAsphaltCoverWaveConditionsCalculation> affectedCalculations =
-               waveImpactAsphaltCoverFailureMechanism.Calculations
-                                                  .OfType<WaveImpactAsphaltCoverWaveConditionsCalculation>()
-                                                  .Where(calc => calc.InputParameters.ForeshoreProfile != null);
-
-            var affectedObjects = new List<IObservable>();
-            foreach (var calculation in affectedCalculations)
-            {
-                calculation.InputParameters.ForeshoreProfile = null;
-                affectedObjects.Add(calculation.InputParameters);
-            }
-
-            waveImpactAsphaltCoverFailureMechanism.ForeshoreProfiles.Clear();
-            affectedObjects.Add(waveImpactAsphaltCoverFailureMechanism.ForeshoreProfiles);
-            return affectedObjects;
-        }
     }
 }
\ No newline at end of file
Index: Ringtoets/Integration/src/Ringtoets.Integration.Service/RingtoetsDataSynchronizationService.cs
===================================================================
diff -u -r802ea30d1fe8fbae93e58dff9ab054dbabca11ae -r91d2618c244882958683e28675970ef50bbf2fe6
--- Ringtoets/Integration/src/Ringtoets.Integration.Service/RingtoetsDataSynchronizationService.cs	(.../RingtoetsDataSynchronizationService.cs)	(revision 802ea30d1fe8fbae93e58dff9ab054dbabca11ae)
+++ Ringtoets/Integration/src/Ringtoets.Integration.Service/RingtoetsDataSynchronizationService.cs	(.../RingtoetsDataSynchronizationService.cs)	(revision 91d2618c244882958683e28675970ef50bbf2fe6)
@@ -205,7 +205,7 @@
         /// Clears the output of the hydraulic boundary locations within the <paramref name="hydraulicBoundaryDatabase"/> and the 
         /// hydraulic boundary locations that are contained within specific failure mechanisms of the <paramref name="assessmentSection"/>.
         /// </summary>
-        /// <param name="hydraulicBoundaryDatabase">The <see cref="HydraulicBoundaryDatabase"/> wich contains the locations.</param>
+        /// <param name="hydraulicBoundaryDatabase">The <see cref="HydraulicBoundaryDatabase"/> which contains the locations.</param>
         /// <param name="assessmentSection">The <see cref="IAssessmentSection"/> which contains the failure mechanisms.</param>
         /// <returns>All objects affected by the operation.</returns>
         /// <exception cref="ArgumentNullException">Thrown when any parameter is <c>null</c>.</exception>
@@ -582,6 +582,204 @@
             return changedObservables;
         }
 
+        /// <summary>
+        /// Removes all <see cref="ForeshoreProfile"/> from the <see cref="ClosingStructuresFailureMechanism"/>
+        /// and clears all data that depends on it, either directly or indirectly.
+        /// </summary>
+        /// <param name="failureMechanism">The failure mechanism 
+        /// containing the <see cref="ForeshoreProfile"/>.</param>
+        /// <returns>All observable objects affected by this method.</returns>
+        /// <exception cref="ArgumentNullException">Thrown when <paramref name="failureMechanism"/>
+        /// is <c>null</c>.</exception>
+        public static IEnumerable<IObservable> RemoveAllForeshoreProfiles(ClosingStructuresFailureMechanism failureMechanism)
+        {
+            if (failureMechanism == null)
+            {
+                throw new ArgumentNullException(nameof(failureMechanism));
+            }
+
+            IEnumerable<StructuresCalculation<ClosingStructuresInput>> affectedCalculations =
+                failureMechanism.Calculations
+                                .OfType<StructuresCalculation<ClosingStructuresInput>>()
+                                .Where(calc => calc.InputParameters.ForeshoreProfile != null);
+
+            var affectedObjects = new List<IObservable>();
+            foreach (StructuresCalculation<ClosingStructuresInput> calculation in affectedCalculations)
+            {
+                calculation.InputParameters.ForeshoreProfile = null;
+                affectedObjects.Add(calculation.InputParameters);
+            }
+
+            failureMechanism.ForeshoreProfiles.Clear();
+            affectedObjects.Add(failureMechanism.ForeshoreProfiles);
+            return affectedObjects;
+        }
+
+        /// <summary>
+        /// Removes all <see cref="ForeshoreProfile"/> from the <see cref="StabilityPointStructuresFailureMechanism"/>
+        /// and clears all data that depends on it, either directly or indirectly.
+        /// </summary>
+        /// <param name="failureMechanism">The failure mechanism 
+        /// containing the <see cref="ForeshoreProfile"/>.</param>
+        /// <returns>All observable objects affected by this method.</returns>
+        /// <exception cref="ArgumentNullException">Thrown when <paramref name="failureMechanism"/>
+        /// is <c>null</c>.</exception>
+        public static IEnumerable<IObservable> RemoveAllForeshoreProfiles(StabilityPointStructuresFailureMechanism failureMechanism)
+        {
+            if (failureMechanism == null)
+            {
+                throw new ArgumentNullException(nameof(failureMechanism));
+            }
+
+            IEnumerable<StructuresCalculation<StabilityPointStructuresInput>> affectedCalculations =
+                failureMechanism.Calculations
+                                .OfType<StructuresCalculation<StabilityPointStructuresInput>>()
+                                .Where(calc => calc.InputParameters.ForeshoreProfile != null);
+
+            var affectedObjects = new List<IObservable>();
+            foreach (StructuresCalculation<StabilityPointStructuresInput> calculation in affectedCalculations)
+            {
+                calculation.InputParameters.ForeshoreProfile = null;
+                affectedObjects.Add(calculation.InputParameters);
+            }
+
+            failureMechanism.ForeshoreProfiles.Clear();
+            affectedObjects.Add(failureMechanism.ForeshoreProfiles);
+            return affectedObjects;
+        }
+
+        /// <summary>
+        /// Removes all <see cref="ForeshoreProfile"/> from the <see cref="HeightStructuresFailureMechanism"/>
+        /// and clears all data that depends on it, either directly or indirectly.
+        /// </summary>
+        /// <param name="failureMechanism">The failure mechanism 
+        /// containing the <see cref="ForeshoreProfile"/>.</param>
+        /// <returns>All observable objects affected by this method.</returns>
+        /// <exception cref="ArgumentNullException">Thrown when <paramref name="failureMechanism"/>
+        /// is <c>null</c>.</exception>
+        public static IEnumerable<IObservable> RemoveAllForeshoreProfiles(HeightStructuresFailureMechanism failureMechanism)
+        {
+            if (failureMechanism == null)
+            {
+                throw new ArgumentNullException(nameof(failureMechanism));
+            }
+
+            IEnumerable<StructuresCalculation<HeightStructuresInput>> affectedCalculations =
+                failureMechanism.Calculations
+                                .OfType<StructuresCalculation<HeightStructuresInput>>()
+                                .Where(calc => calc.InputParameters.ForeshoreProfile != null);
+
+            var affectedObjects = new List<IObservable>();
+            foreach (StructuresCalculation<HeightStructuresInput> calculation in affectedCalculations)
+            {
+                calculation.InputParameters.ForeshoreProfile = null;
+                affectedObjects.Add(calculation.InputParameters);
+            }
+
+            failureMechanism.ForeshoreProfiles.Clear();
+            affectedObjects.Add(failureMechanism.ForeshoreProfiles);
+            return affectedObjects;
+        }
+
+        /// <summary>
+        /// Removes all <see cref="ForeshoreProfile"/> from the <see cref="GrassCoverErosionOutwardsFailureMechanism"/>
+        /// and clears all data that depends on it, either directly or indirectly.
+        /// </summary>
+        /// <param name="failureMechanism">The failure mechanism 
+        /// containing the <see cref="ForeshoreProfile"/>.</param>
+        /// <returns>All observable objects affected by this method.</returns>
+        /// <exception cref="ArgumentNullException">Thrown when <paramref name="failureMechanism"/>
+        /// is <c>null</c>.</exception>
+        public static IEnumerable<IObservable> RemoveAllForeshoreProfiles(GrassCoverErosionOutwardsFailureMechanism failureMechanism)
+        {
+            if (failureMechanism == null)
+            {
+                throw new ArgumentNullException(nameof(failureMechanism));
+            }
+
+            IEnumerable<GrassCoverErosionOutwardsWaveConditionsCalculation> affectedCalculations =
+                failureMechanism.Calculations
+                                .OfType<GrassCoverErosionOutwardsWaveConditionsCalculation>()
+                                .Where(calc => calc.InputParameters.ForeshoreProfile != null);
+
+            var affectedObjects = new List<IObservable>();
+            foreach (GrassCoverErosionOutwardsWaveConditionsCalculation calculation in affectedCalculations)
+            {
+                calculation.InputParameters.ForeshoreProfile = null;
+                affectedObjects.Add(calculation.InputParameters);
+            }
+
+            failureMechanism.ForeshoreProfiles.Clear();
+            affectedObjects.Add(failureMechanism.ForeshoreProfiles);
+            return affectedObjects;
+        }
+
+        /// <summary>
+        /// Removes all <see cref="ForeshoreProfile"/> from the <see cref="StabilityStoneCoverFailureMechanism"/>
+        /// and clears all data that depends on it, either directly or indirectly.
+        /// </summary>
+        /// <param name="failureMechanism">The failure mechanism 
+        /// containing the <see cref="ForeshoreProfile"/>.</param>
+        /// <returns>All observable objects affected by this method.</returns>
+        /// <exception cref="ArgumentNullException">Thrown when <paramref name="failureMechanism"/>
+        /// is <c>null</c>.</exception>
+        public static IEnumerable<IObservable> RemoveAllForeshoreProfiles(StabilityStoneCoverFailureMechanism failureMechanism)
+        {
+            if (failureMechanism == null)
+            {
+                throw new ArgumentNullException(nameof(failureMechanism));
+            }
+
+            IEnumerable<StabilityStoneCoverWaveConditionsCalculation> affectedCalculations =
+                failureMechanism.Calculations
+                                .OfType<StabilityStoneCoverWaveConditionsCalculation>()
+                                .Where(calc => calc.InputParameters.ForeshoreProfile != null);
+
+            var affectedObjects = new List<IObservable>();
+            foreach (StabilityStoneCoverWaveConditionsCalculation calculation in affectedCalculations)
+            {
+                calculation.InputParameters.ForeshoreProfile = null;
+                affectedObjects.Add(calculation.InputParameters);
+            }
+
+            failureMechanism.ForeshoreProfiles.Clear();
+            affectedObjects.Add(failureMechanism.ForeshoreProfiles);
+            return affectedObjects;
+        }
+
+        /// <summary>
+        /// Removes all <see cref="ForeshoreProfile"/> from the <see cref="WaveImpactAsphaltCoverFailureMechanism"/>
+        /// and clears all data that depends on it, either directly or indirectly.
+        /// </summary>
+        /// <param name="failureMechanism">The failure mechanism 
+        /// containing the <see cref="ForeshoreProfile"/>.</param>
+        /// <returns>All observable objects affected by this method.</returns>
+        /// <exception cref="ArgumentNullException">Thrown when <paramref name="failureMechanism"/>
+        /// is <c>null</c>.</exception>
+        public static IEnumerable<IObservable> RemoveAllForeshoreProfiles(WaveImpactAsphaltCoverFailureMechanism failureMechanism)
+        {
+            if (failureMechanism == null)
+            {
+                throw new ArgumentNullException(nameof(failureMechanism));
+            }
+
+            IEnumerable<WaveImpactAsphaltCoverWaveConditionsCalculation> affectedCalculations =
+                failureMechanism.Calculations
+                                .OfType<WaveImpactAsphaltCoverWaveConditionsCalculation>()
+                                .Where(calc => calc.InputParameters.ForeshoreProfile != null);
+
+            var affectedObjects = new List<IObservable>();
+            foreach (WaveImpactAsphaltCoverWaveConditionsCalculation calculation in affectedCalculations)
+            {
+                calculation.InputParameters.ForeshoreProfile = null;
+                affectedObjects.Add(calculation.InputParameters);
+            }
+
+            failureMechanism.ForeshoreProfiles.Clear();
+            affectedObjects.Add(failureMechanism.ForeshoreProfiles);
+            return affectedObjects;
+        }
+
         private static ClearResults GetClearResultsForFailureMechanism(IFailureMechanism failureMechanism)
         {
             var pipingFailureMechanism = failureMechanism as PipingFailureMechanism;
Index: Ringtoets/Integration/test/Ringtoets.Integration.Plugin.Test/FileImporters/ForeshoreProfileReplaceDataStrategyTest.cs
===================================================================
diff -u -r670a5510c7638037a4f7e0c3efea0a261085bfbb -r91d2618c244882958683e28675970ef50bbf2fe6
--- Ringtoets/Integration/test/Ringtoets.Integration.Plugin.Test/FileImporters/ForeshoreProfileReplaceDataStrategyTest.cs	(.../ForeshoreProfileReplaceDataStrategyTest.cs)	(revision 670a5510c7638037a4f7e0c3efea0a261085bfbb)
+++ Ringtoets/Integration/test/Ringtoets.Integration.Plugin.Test/FileImporters/ForeshoreProfileReplaceDataStrategyTest.cs	(.../ForeshoreProfileReplaceDataStrategyTest.cs)	(revision 91d2618c244882958683e28675970ef50bbf2fe6)
@@ -100,7 +100,7 @@
         }
 
         [Test]
-        public void Constructor_UnsupportedFailureMechanism_ThrowsUnsupportedException()
+        public void Constructor_UnsupportedFailureMechanism_ThrowsNotSupportedException()
         {
             // Call
             TestDelegate call = () => new ForeshoreProfileReplaceDataStrategy(new TestFailureMechanism());
@@ -305,38 +305,6 @@
             }, affectedObjects);
         }
 
-        [Test]
-        [TestCaseSource(nameof(SupportedFailureMechanismsAndEmptyForeshoreProfileCollection))]
-        public void UpdateForeshoreProfilesWithImportedData_CalculationsWithForeshoreProfile_CalculationUpdatedAndReturnsAffectedData(
-            IFailureMechanism failureMechanism, ForeshoreProfileCollection foreshoreProfiles)
-        {
-            // Setup
-            var foreshoreProfile = new TestForeshoreProfile("Profile 1", "ID 1");
-            foreshoreProfiles.AddRange(new[]
-            {
-                foreshoreProfile
-            }, sourceFilePath);
-
-            var strategy = new ForeshoreProfileReplaceDataStrategy(failureMechanism);
-
-            var importedForeshoreProfiles = new[]
-            {
-                new TestForeshoreProfile("Profile 2", "ID 2")
-            };
-
-            // Call 
-            IEnumerable<IObservable> affectedObjects = strategy.UpdateForeshoreProfilesWithImportedData(foreshoreProfiles,
-                                                                                                        importedForeshoreProfiles,
-                                                                                                        sourceFilePath);
-
-            // Assert
-            CollectionAssert.AreEqual(importedForeshoreProfiles, foreshoreProfiles);
-            CollectionAssert.AreEqual(new IObservable[]
-            {
-                foreshoreProfiles
-            }, affectedObjects);
-        }
-
         #region Wave Impact Asphalt Cover
 
         [Test]
Index: Ringtoets/Integration/test/Ringtoets.Integration.Service.Test/RingtoetsDataSynchronizationServiceTest.cs
===================================================================
diff -u -r20e9bfea15dfe132ee137283a9f24bc4c413ce4a -r91d2618c244882958683e28675970ef50bbf2fe6
--- Ringtoets/Integration/test/Ringtoets.Integration.Service.Test/RingtoetsDataSynchronizationServiceTest.cs	(.../RingtoetsDataSynchronizationServiceTest.cs)	(revision 20e9bfea15dfe132ee137283a9f24bc4c413ce4a)
+++ Ringtoets/Integration/test/Ringtoets.Integration.Service.Test/RingtoetsDataSynchronizationServiceTest.cs	(.../RingtoetsDataSynchronizationServiceTest.cs)	(revision 91d2618c244882958683e28675970ef50bbf2fe6)
@@ -1236,6 +1236,258 @@
         }
 
         [Test]
+        public void RemoveAllForeshoreProfile_ClosingStructuresFailureMechanismNull_ThrowsArgumentNullException()
+        {
+            // Call
+            TestDelegate call = () => RingtoetsDataSynchronizationService.RemoveAllForeshoreProfiles((ClosingStructuresFailureMechanism) null);
+
+            // Assert
+            var exception = Assert.Throws<ArgumentNullException>(call);
+            Assert.AreEqual("failureMechanism", exception.ParamName);
+        }
+
+        [Test]
+        public void RemoveAllForeshoreProfile_FullyConfiguredClosingStructuresFailureMechanism_RemovesAllForeshoreProfilesAndDependentData()
+        {
+            // Setup
+            ClosingStructuresFailureMechanism failureMechanism = TestDataGenerator.GetClosingStructuresFailureMechanismWithAllCalculationConfigurations();
+
+            StructuresCalculation<ClosingStructuresInput>[] calculationsWithForeshoreProfiles = failureMechanism.Calculations
+                                                                                                                .Cast<StructuresCalculation<ClosingStructuresInput>>()
+                                                                                                                .Where(calc => calc.InputParameters.ForeshoreProfile != null)
+                                                                                                                .ToArray();
+
+            // Pre-condition
+            CollectionAssert.IsNotEmpty(calculationsWithForeshoreProfiles);
+
+            // Call
+            IEnumerable<IObservable> affectedObjects = RingtoetsDataSynchronizationService.RemoveAllForeshoreProfiles(failureMechanism);
+
+            // Assert
+            // Note: To make sure the clear is performed regardless of what is done with
+            // the return result, no ToArray() should be called before these assertions:
+            CollectionAssert.IsEmpty(failureMechanism.ForeshoreProfiles);
+
+            IEnumerable<IObservable> expectedAffectedObjects =
+                calculationsWithForeshoreProfiles.Select(calc => calc.InputParameters)
+                                                 .Concat(new IObservable[]
+                                                 {
+                                                     failureMechanism.ForeshoreProfiles
+                                                 });
+            CollectionAssert.AreEquivalent(expectedAffectedObjects, affectedObjects);
+        }
+
+        [Test]
+        public void RemoveAllForeshoreProfile_StabilityPointStructuresFailureMechanismNull_ThrowsArgumentNullException()
+        {
+            // Call
+            TestDelegate call = () => RingtoetsDataSynchronizationService.RemoveAllForeshoreProfiles((StabilityPointStructuresFailureMechanism) null);
+
+            // Assert
+            var exception = Assert.Throws<ArgumentNullException>(call);
+            Assert.AreEqual("failureMechanism", exception.ParamName);
+        }
+
+        [Test]
+        public void RemoveAllForeshoreProfile_FullyConfiguredStabilityPointStructuresFailureMechanism_RemovesAllForeshoreProfilesAndDependentData()
+        {
+            // Setup
+            StabilityPointStructuresFailureMechanism failureMechanism = TestDataGenerator.GetStabilityPointStructuresFailureMechanismWithAllCalculationConfigurations();
+
+            StructuresCalculation<StabilityPointStructuresInput>[] calculationsWithForeshoreProfiles = failureMechanism.Calculations
+                                                                                                                       .Cast<StructuresCalculation<StabilityPointStructuresInput>>()
+                                                                                                                       .Where(calc => calc.InputParameters.ForeshoreProfile != null)
+                                                                                                                       .ToArray();
+
+            // Pre-condition
+            CollectionAssert.IsNotEmpty(calculationsWithForeshoreProfiles);
+
+            // Call
+            IEnumerable<IObservable> affectedObjects = RingtoetsDataSynchronizationService.RemoveAllForeshoreProfiles(failureMechanism);
+
+            // Assert
+            // Note: To make sure the clear is performed regardless of what is done with
+            // the return result, no ToArray() should be called before these assertions:
+            CollectionAssert.IsEmpty(failureMechanism.ForeshoreProfiles);
+
+            IEnumerable<IObservable> expectedAffectedObjects =
+                calculationsWithForeshoreProfiles.Select(calc => calc.InputParameters)
+                                                 .Concat(new IObservable[]
+                                                 {
+                                                     failureMechanism.ForeshoreProfiles
+                                                 });
+            CollectionAssert.AreEquivalent(expectedAffectedObjects, affectedObjects);
+        }
+
+        [Test]
+        public void RemoveAllForeshoreProfile_HeightStructuresFailureMechanismNull_ThrowsArgumentNullException()
+        {
+            // Call
+            TestDelegate call = () => RingtoetsDataSynchronizationService.RemoveAllForeshoreProfiles((HeightStructuresFailureMechanism) null);
+
+            // Assert
+            var exception = Assert.Throws<ArgumentNullException>(call);
+            Assert.AreEqual("failureMechanism", exception.ParamName);
+        }
+
+        [Test]
+        public void RemoveAllForeshoreProfile_FullyConfiguredHeightStructuresFailureMechanism_RemovesAllForeshoreProfilesAndDependentData()
+        {
+            // Setup
+            HeightStructuresFailureMechanism failureMechanism = TestDataGenerator.GetHeightStructuresFailureMechanismWithAlLCalculationConfigurations();
+
+            StructuresCalculation<HeightStructuresInput>[] calculationsWithForeshoreProfiles = failureMechanism.Calculations
+                                                                                                               .Cast<StructuresCalculation<HeightStructuresInput>>()
+                                                                                                               .Where(calc => calc.InputParameters.ForeshoreProfile != null)
+                                                                                                               .ToArray();
+
+            // Pre-condition
+            CollectionAssert.IsNotEmpty(calculationsWithForeshoreProfiles);
+
+            // Call
+            IEnumerable<IObservable> affectedObjects = RingtoetsDataSynchronizationService.RemoveAllForeshoreProfiles(failureMechanism);
+
+            // Assert
+            // Note: To make sure the clear is performed regardless of what is done with
+            // the return result, no ToArray() should be called before these assertions:
+            CollectionAssert.IsEmpty(failureMechanism.ForeshoreProfiles);
+
+            IEnumerable<IObservable> expectedAffectedObjects =
+                calculationsWithForeshoreProfiles.Select(calc => calc.InputParameters)
+                                                 .Concat(new IObservable[]
+                                                 {
+                                                     failureMechanism.ForeshoreProfiles
+                                                 });
+            CollectionAssert.AreEquivalent(expectedAffectedObjects, affectedObjects);
+        }
+
+        [Test]
+        public void RemoveAllForeshoreProfile_GrassCoverErosionOutwardsFailureMechanismNull_ThrowsArgumentNullException()
+        {
+            // Call
+            TestDelegate call = () => RingtoetsDataSynchronizationService.RemoveAllForeshoreProfiles((GrassCoverErosionOutwardsFailureMechanism) null);
+
+            // Assert
+            var exception = Assert.Throws<ArgumentNullException>(call);
+            Assert.AreEqual("failureMechanism", exception.ParamName);
+        }
+
+        [Test]
+        public void RemoveAllForeshoreProfile_FullyConfiguredGrassCoverErosionOutwardsFailureMechanism_RemovesAllForeshoreProfilesAndDependentData()
+        {
+            // Setup
+            GrassCoverErosionOutwardsFailureMechanism failureMechanism = TestDataGenerator.GetGrassCoverErosionOutwardsFailureMechanismWithAllCalculationConfigurations();
+
+            GrassCoverErosionOutwardsWaveConditionsCalculation[] calculationsWithForeshoreProfiles = failureMechanism.Calculations
+                                                                                                                     .Cast<GrassCoverErosionOutwardsWaveConditionsCalculation>()
+                                                                                                                     .Where(calc => calc.InputParameters.ForeshoreProfile != null)
+                                                                                                                     .ToArray();
+
+            // Pre-condition
+            CollectionAssert.IsNotEmpty(calculationsWithForeshoreProfiles);
+
+            // Call
+            IEnumerable<IObservable> affectedObjects = RingtoetsDataSynchronizationService.RemoveAllForeshoreProfiles(failureMechanism);
+
+            // Assert
+            // Note: To make sure the clear is performed regardless of what is done with
+            // the return result, no ToArray() should be called before these assertions:
+            CollectionAssert.IsEmpty(failureMechanism.ForeshoreProfiles);
+
+            IEnumerable<IObservable> expectedAffectedObjects =
+                calculationsWithForeshoreProfiles.Select(calc => calc.InputParameters)
+                                                 .Concat(new IObservable[]
+                                                 {
+                                                     failureMechanism.ForeshoreProfiles
+                                                 });
+            CollectionAssert.AreEquivalent(expectedAffectedObjects, affectedObjects);
+        }
+
+        [Test]
+        public void RemoveAllForeshoreProfile_StabilityStoneCoverFailureMechanismNull_ThrowsArgumentNullException()
+        {
+            // Call
+            TestDelegate call = () => RingtoetsDataSynchronizationService.RemoveAllForeshoreProfiles((StabilityStoneCoverFailureMechanism) null);
+
+            // Assert
+            var exception = Assert.Throws<ArgumentNullException>(call);
+            Assert.AreEqual("failureMechanism", exception.ParamName);
+        }
+
+        [Test]
+        public void RemoveAllForeshoreProfile_FullyConfiguredStabilityStoneCoverFailureMechanism_RemovesAllForeshoreProfilesAndDependentData()
+        {
+            // Setup
+            StabilityStoneCoverFailureMechanism failureMechanism = TestDataGenerator.GetStabilityStoneCoverFailureMechanismWithAllCalculationConfigurations();
+
+            StabilityStoneCoverWaveConditionsCalculation[] calculationsWithForeshoreProfiles = failureMechanism.Calculations
+                                                                                                               .Cast<StabilityStoneCoverWaveConditionsCalculation>()
+                                                                                                               .Where(calc => calc.InputParameters.ForeshoreProfile != null)
+                                                                                                               .ToArray();
+
+            // Pre-condition
+            CollectionAssert.IsNotEmpty(calculationsWithForeshoreProfiles);
+
+            // Call
+            IEnumerable<IObservable> affectedObjects = RingtoetsDataSynchronizationService.RemoveAllForeshoreProfiles(failureMechanism);
+
+            // Assert
+            // Note: To make sure the clear is performed regardless of what is done with
+            // the return result, no ToArray() should be called before these assertions:
+            CollectionAssert.IsEmpty(failureMechanism.ForeshoreProfiles);
+
+            IEnumerable<IObservable> expectedAffectedObjects =
+                calculationsWithForeshoreProfiles.Select(calc => calc.InputParameters)
+                                                 .Concat(new IObservable[]
+                                                 {
+                                                     failureMechanism.ForeshoreProfiles
+                                                 });
+            CollectionAssert.AreEquivalent(expectedAffectedObjects, affectedObjects);
+        }
+
+        [Test]
+        public void RemoveAllForeshoreProfile_WaveImpactAsphaltCoverFailureMechanismNull_ThrowsArgumentNullException()
+        {
+            // Call
+            TestDelegate call = () => RingtoetsDataSynchronizationService.RemoveAllForeshoreProfiles((WaveImpactAsphaltCoverFailureMechanism) null);
+
+            // Assert
+            var exception = Assert.Throws<ArgumentNullException>(call);
+            Assert.AreEqual("failureMechanism", exception.ParamName);
+        }
+
+        [Test]
+        public void RemoveAllForeshoreProfile_FullyConfiguredWaveImpactAsphaltCoverFailureMechanism_RemovesAllForeshoreProfilesAndDependentData()
+        {
+            // Setup
+            WaveImpactAsphaltCoverFailureMechanism failureMechanism = TestDataGenerator.GetWaveImpactAsphaltCoverFailureMechanismWithAllCalculationConfigurations();
+
+            WaveImpactAsphaltCoverWaveConditionsCalculation[] calculationsWithForeshoreProfiles = failureMechanism.Calculations
+                                                                                                                  .Cast<WaveImpactAsphaltCoverWaveConditionsCalculation>()
+                                                                                                                  .Where(calc => calc.InputParameters.ForeshoreProfile != null)
+                                                                                                                  .ToArray();
+
+            // Pre-condition
+            CollectionAssert.IsNotEmpty(calculationsWithForeshoreProfiles);
+
+            // Call
+            IEnumerable<IObservable> affectedObjects = RingtoetsDataSynchronizationService.RemoveAllForeshoreProfiles(failureMechanism);
+
+            // Assert
+            // Note: To make sure the clear is performed regardless of what is done with
+            // the return result, no ToArray() should be called before these assertions:
+            CollectionAssert.IsEmpty(failureMechanism.ForeshoreProfiles);
+
+            IEnumerable<IObservable> expectedAffectedObjects =
+                calculationsWithForeshoreProfiles.Select(calc => calc.InputParameters)
+                                                 .Concat(new IObservable[]
+                                                 {
+                                                     failureMechanism.ForeshoreProfiles
+                                                 });
+            CollectionAssert.AreEquivalent(expectedAffectedObjects, affectedObjects);
+        }
+
+        [Test]
         public void RemoveDikeProfile_GrassCoverErosionInwardsFailureMechanismNull_ThrowsArgumentNullException()
         {
             // Setup