Index: Ringtoets/Integration/test/Ringtoets.Integration.Forms.Test/TreeNodeInfos/DikeProfileTreeNodeInfoTest.cs
===================================================================
diff -u -r5b132f482c79bbf041e6f8ebc20bd79b3f5037e8 -raaad7a7ca8557c045aa8d6d4031be9133d2f34a6
--- Ringtoets/Integration/test/Ringtoets.Integration.Forms.Test/TreeNodeInfos/DikeProfileTreeNodeInfoTest.cs	(.../DikeProfileTreeNodeInfoTest.cs)	(revision 5b132f482c79bbf041e6f8ebc20bd79b3f5037e8)
+++ Ringtoets/Integration/test/Ringtoets.Integration.Forms.Test/TreeNodeInfos/DikeProfileTreeNodeInfoTest.cs	(.../DikeProfileTreeNodeInfoTest.cs)	(revision aaad7a7ca8557c045aa8d6d4031be9133d2f34a6)
@@ -21,14 +21,20 @@
 
 using System.Drawing;
 using System.Linq;
+using Core.Common.Base;
 using Core.Common.Base.Geometry;
 using Core.Common.Controls.TreeView;
 using Core.Common.Gui;
 using Core.Common.Gui.ContextMenu;
 using Core.Common.TestUtil;
 using NUnit.Framework;
 using Rhino.Mocks;
+using Ringtoets.Common.Data.AssessmentSection;
+using Ringtoets.Common.Data.Calculation;
 using Ringtoets.Common.Data.DikeProfiles;
+using Ringtoets.Common.Data.FailureMechanism;
+using Ringtoets.GrassCoverErosionInwards.Data;
+using Ringtoets.GrassCoverErosionInwards.Forms.PresentationObjects;
 using Ringtoets.Integration.Plugin;
 using RingtoetsCommonFormsResources = Ringtoets.Common.Forms.Properties.Resources;
 
@@ -66,8 +72,6 @@
             Assert.IsNull(info.EnsureVisibleOnCreate);
             Assert.IsNull(info.CanRename);
             Assert.IsNull(info.OnNodeRenamed);
-            Assert.IsNull(info.CanRemove);
-            Assert.IsNull(info.OnNodeRemoved);
             Assert.IsNull(info.CanCheck);
             Assert.IsNull(info.IsChecked);
             Assert.IsNull(info.OnNodeChecked);
@@ -106,11 +110,250 @@
         }
 
         [Test]
+        public void CanRemove_ParentIsDikeProfilesContext_ReturnTrue()
+        {
+            // Setup
+            var mocks = new MockRepository();
+            var assessmentSection = mocks.Stub<IAssessmentSection>();
+            mocks.ReplayAll();
+
+            var failureMechanism = new GrassCoverErosionInwardsFailureMechanism();
+
+            var parentData = new DikeProfilesContext(failureMechanism.DikeProfiles, failureMechanism, assessmentSection);
+
+            // Call
+            bool canRemove = info.CanRemove(null, parentData);
+
+            // Assert
+            Assert.IsTrue(canRemove);
+            mocks.VerifyAll();
+        }
+
+        [Test]
+        public void CanRemove_ParentIsNotDikeProfilesContext_ReturnFalse()
+        {
+            // Call
+            bool canRemove = info.CanRemove(null, null);
+
+            // Assert
+            Assert.IsFalse(canRemove);
+        }
+
+        [Test]
+        public void OnNodeRemoved_RemovingProfileFromContainer_ProfileRemovedFromContainer()
+        {
+            // Setup
+            var mocks = new MockRepository();
+            var assessmentSection = mocks.Stub<IAssessmentSection>();
+            var observer = mocks.StrictMock<IObserver>();
+            observer.Expect(o => o.UpdateObserver());
+            mocks.ReplayAll();
+
+            var nodeData = new DikeProfile(new Point2D(0,0), new RoughnessPoint[0], new Point2D[0], null, new DikeProfile.ConstructionProperties());
+            var failureMechanism = new GrassCoverErosionInwardsFailureMechanism
+            {
+                DikeProfiles =
+                {
+                    nodeData
+                }
+            };
+            failureMechanism.DikeProfiles.Attach(observer);
+
+            var parentData = new DikeProfilesContext(failureMechanism.DikeProfiles, failureMechanism, assessmentSection);
+
+            // Call
+            info.OnNodeRemoved(nodeData, parentData);
+
+            // Assert
+            CollectionAssert.DoesNotContain(failureMechanism.DikeProfiles, nodeData);
+            mocks.VerifyAll();
+        }
+
+        [Test]
+        public void OnNodeRemoved_RemovingProfilePartOfCalculation_CalculationProfileCleared()
+        {
+            // Setup
+            var mocks = new MockRepository();
+            var assessmentSection = mocks.Stub<IAssessmentSection>();
+            var observer = mocks.StrictMock<IObserver>();
+            observer.Expect(o => o.UpdateObserver());
+            var calculation1Observer = mocks.StrictMock<IObserver>();
+            calculation1Observer.Expect(o => o.UpdateObserver());
+            var calculation2Observer = mocks.StrictMock<IObserver>();
+            calculation2Observer.Expect(o => o.UpdateObserver());
+            var calculation3Observer = mocks.StrictMock<IObserver>();
+            calculation3Observer.Expect(o => o.UpdateObserver()).Repeat.Never();
+            mocks.ReplayAll();
+
+            var nodeData = new DikeProfile(new Point2D(0, 0), new RoughnessPoint[0], new Point2D[0], null, new DikeProfile.ConstructionProperties());
+            var otherProfile = new DikeProfile(new Point2D(1, 1), new RoughnessPoint[0], new Point2D[0], null, new DikeProfile.ConstructionProperties());
+
+            var calculation1 = new GrassCoverErosionInwardsCalculation
+            {
+                InputParameters =
+                {
+                    DikeProfile = nodeData
+                }
+            };
+            calculation1.InputParameters.Attach(calculation1Observer);
+            var calculation2 = new GrassCoverErosionInwardsCalculation
+            {
+                InputParameters =
+                {
+                    DikeProfile = nodeData
+                }
+            };
+            calculation2.InputParameters.Attach(calculation2Observer);
+            var calculation3 = new GrassCoverErosionInwardsCalculation
+            {
+                InputParameters =
+                {
+                    DikeProfile = otherProfile
+                }
+            };
+            calculation3.InputParameters.Attach(calculation3Observer);
+
+            var calculationGroup = new CalculationGroup("A", true)
+            {
+                Children =
+                {
+                    calculation2
+                }
+            };
+
+            var failureMechanism = new GrassCoverErosionInwardsFailureMechanism
+            {
+                DikeProfiles =
+                {
+                    nodeData,
+                    otherProfile
+                },
+                CalculationsGroup =
+                {
+                    Children =
+                    {
+                        calculation1,
+                        calculationGroup,
+                        calculation3
+                    }
+                }
+            };
+            failureMechanism.DikeProfiles.Attach(observer);
+
+            var parentData = new DikeProfilesContext(failureMechanism.DikeProfiles, failureMechanism, assessmentSection);
+
+            // Call
+            info.OnNodeRemoved(nodeData, parentData);
+
+            // Assert
+            CollectionAssert.DoesNotContain(failureMechanism.DikeProfiles, nodeData);
+
+            Assert.IsNull(calculation1.InputParameters.DikeProfile);
+            Assert.IsNull(calculation2.InputParameters.DikeProfile);
+            Assert.IsNotNull(calculation3.InputParameters.DikeProfile);
+            mocks.VerifyAll();
+        }
+
+        [Test]
+        public void OnNodeRemoved_RemovingProfilePartOfCalculationOfSectionResult_SectionResultCalculationCleared()
+        {
+            // Setup
+            var mocks = new MockRepository();
+            var assessmentSection = mocks.Stub<IAssessmentSection>();
+            var observer = mocks.StrictMock<IObserver>();
+            observer.Expect(o => o.UpdateObserver());
+            var calculation1Observer = mocks.StrictMock<IObserver>();
+            calculation1Observer.Expect(o => o.UpdateObserver());
+            var calculation2Observer = mocks.StrictMock<IObserver>();
+            calculation2Observer.Expect(o => o.UpdateObserver()).Repeat.Never();
+            var calculation3Observer = mocks.StrictMock<IObserver>();
+            calculation3Observer.Expect(o => o.UpdateObserver()).Repeat.Never();
+            mocks.ReplayAll();
+
+            var nodeData = new DikeProfile(new Point2D(1, 0), new RoughnessPoint[0], new Point2D[0], null, new DikeProfile.ConstructionProperties());
+            var otherProfile1 = new DikeProfile(new Point2D(2, 0), new RoughnessPoint[0], new Point2D[0], null, new DikeProfile.ConstructionProperties());
+            var otherProfile2 = new DikeProfile(new Point2D(7, 0), new RoughnessPoint[0], new Point2D[0], null, new DikeProfile.ConstructionProperties());
+
+            var calculation1 = new GrassCoverErosionInwardsCalculation
+            {
+                InputParameters =
+                {
+                    DikeProfile = nodeData
+                }
+            };
+            calculation1.InputParameters.Attach(calculation1Observer);
+            var calculation2 = new GrassCoverErosionInwardsCalculation
+            {
+                InputParameters =
+                {
+                    DikeProfile = otherProfile1
+                }
+            };
+            calculation2.InputParameters.Attach(calculation2Observer);
+            var calculation3 = new GrassCoverErosionInwardsCalculation
+            {
+                InputParameters =
+                {
+                    DikeProfile = otherProfile2
+                }
+            };
+            calculation3.InputParameters.Attach(calculation3Observer);
+
+            var failureMechanism = new GrassCoverErosionInwardsFailureMechanism
+            {
+                DikeProfiles =
+                {
+                    nodeData,
+                    otherProfile1,
+                    otherProfile2
+                },
+                CalculationsGroup =
+                {
+                    Children =
+                    {
+                        calculation1,
+                        calculation2
+                    }
+                }
+            };
+            failureMechanism.AddSection(new FailureMechanismSection("A", new []
+            {
+                new Point2D(0, 0), 
+                new Point2D(4, 0)
+            }));
+            failureMechanism.AddSection(new FailureMechanismSection("B", new[]
+            {
+                new Point2D(4, 0), 
+                new Point2D(9, 0)
+            }));
+            failureMechanism.DikeProfiles.Attach(observer);
+            failureMechanism.SectionResults.ElementAt(0).Calculation = calculation1;
+            failureMechanism.SectionResults.ElementAt(1).Calculation = calculation3;
+
+            var parentData = new DikeProfilesContext(failureMechanism.DikeProfiles, failureMechanism, assessmentSection);
+
+            // Call
+            info.OnNodeRemoved(nodeData, parentData);
+
+            // Assert
+            CollectionAssert.DoesNotContain(failureMechanism.DikeProfiles, nodeData);
+
+            Assert.IsNull(calculation1.InputParameters.DikeProfile);
+            Assert.IsNotNull(calculation2.InputParameters.DikeProfile);
+            
+            Assert.AreSame(calculation2, failureMechanism.SectionResults.ElementAt(0).Calculation);
+            Assert.AreSame(calculation3, failureMechanism.SectionResults.ElementAt(1).Calculation);
+            mocks.VerifyAll();
+        }
+
+        [Test]
         public void ContextMenuStrip_Always_CallsBuilder()
         {
             // Setup
             var mocks = new MockRepository();
             var menuBuilderMock = mocks.StrictMock<IContextMenuBuilder>();
+            menuBuilderMock.Expect(mb => mb.AddDeleteItem()).Return(menuBuilderMock);
+            menuBuilderMock.Expect(mb => mb.AddSeparator()).Return(menuBuilderMock);
             menuBuilderMock.Expect(mb => mb.AddPropertiesItem()).Return(menuBuilderMock);
             menuBuilderMock.Expect(mb => mb.Build()).Return(null);