Index: Ringtoets/WaveImpactAsphaltCover/src/Ringtoets.WaveImpactAsphaltCover.Data/WaveImpactAsphaltCoverFailureMechanism.cs
===================================================================
diff -u -rbea6e87ff7f6b40ff9fcce4d46ccb55bb3b47535 -r8e97f37e10d4445dfa2aeda2d321f347b5a59921
--- Ringtoets/WaveImpactAsphaltCover/src/Ringtoets.WaveImpactAsphaltCover.Data/WaveImpactAsphaltCoverFailureMechanism.cs	(.../WaveImpactAsphaltCoverFailureMechanism.cs)	(revision bea6e87ff7f6b40ff9fcce4d46ccb55bb3b47535)
+++ Ringtoets/WaveImpactAsphaltCover/src/Ringtoets.WaveImpactAsphaltCover.Data/WaveImpactAsphaltCoverFailureMechanism.cs	(.../WaveImpactAsphaltCoverFailureMechanism.cs)	(revision 8e97f37e10d4445dfa2aeda2d321f347b5a59921)
@@ -20,12 +20,14 @@
 // All rights reserved.
 
 using System.Collections.Generic;
+using System.Linq;
 using Core.Common.Base;
 using Ringtoets.Common.Data.Calculation;
 using Ringtoets.Common.Data.DikeProfiles;
 using Ringtoets.Common.Data.FailureMechanism;
 using Ringtoets.Revetment.Data;
 using Ringtoets.WaveImpactAsphaltCover.Data.Properties;
+using RingtoetsCommonDataResources = Ringtoets.Common.Data.Properties.Resources;
 
 namespace Ringtoets.WaveImpactAsphaltCover.Data
 {
@@ -44,6 +46,7 @@
             : base(Resources.WaveImpactAsphaltCoverFailureMechanism_DisplayName, Resources.WaveImpactAsphaltCoverFailureMechanism_Code)
         {
             sectionResults = new List<WaveImpactAsphaltCoverFailureMechanismSectionResult>();
+            WaveConditionsCalculationGroup = new CalculationGroup(RingtoetsCommonDataResources.HydraulicBoundaryConditions_DisplayName, false);
             ForeshoreProfiles = new ObservableList<ForeshoreProfile>();
             GeneralInput = new GeneralWaveConditionsInput(1.0, 0.0, 0.0);
         }
@@ -52,7 +55,7 @@
         {
             get
             {
-                yield break;
+                return WaveConditionsCalculationGroup.GetCalculations().OfType<WaveImpactAsphaltCoverWaveConditionsCalculation>();
             }
         }
 
@@ -66,6 +69,11 @@
         /// </summary>
         public GeneralWaveConditionsInput GeneralInput { get; private set; }
 
+        /// <summary>
+        /// Gets the container of all wave conditions calculations.
+        /// </summary>
+        public CalculationGroup WaveConditionsCalculationGroup { get; private set; }
+
         public IEnumerable<WaveImpactAsphaltCoverFailureMechanismSectionResult> SectionResults
         {
             get
Index: Ringtoets/WaveImpactAsphaltCover/src/Ringtoets.WaveImpactAsphaltCover.Forms/Ringtoets.WaveImpactAsphaltCover.Forms.csproj
===================================================================
diff -u -r047a56dd0274ea50de6f06ebad47fbe75ba86ba5 -r8e97f37e10d4445dfa2aeda2d321f347b5a59921
--- Ringtoets/WaveImpactAsphaltCover/src/Ringtoets.WaveImpactAsphaltCover.Forms/Ringtoets.WaveImpactAsphaltCover.Forms.csproj	(.../Ringtoets.WaveImpactAsphaltCover.Forms.csproj)	(revision 047a56dd0274ea50de6f06ebad47fbe75ba86ba5)
+++ Ringtoets/WaveImpactAsphaltCover/src/Ringtoets.WaveImpactAsphaltCover.Forms/Ringtoets.WaveImpactAsphaltCover.Forms.csproj	(.../Ringtoets.WaveImpactAsphaltCover.Forms.csproj)	(revision 8e97f37e10d4445dfa2aeda2d321f347b5a59921)
@@ -98,14 +98,17 @@
     <ProjectReference Include="..\..\..\HydraRing\src\Ringtoets.HydraRing.Data\Ringtoets.HydraRing.Data.csproj">
       <Project>{70F8CC9C-5BC8-4FB2-B201-EAE7FA8088C2}</Project>
       <Name>Ringtoets.HydraRing.Data</Name>
+      <Private>False</Private>
     </ProjectReference>
     <ProjectReference Include="..\..\..\Integration\src\Ringtoets.Integration.Data\Ringtoets.Integration.Data.csproj">
       <Project>{11F1F874-45AF-43E4-8AE5-15A5C9593E28}</Project>
       <Name>Ringtoets.Integration.Data</Name>
+      <Private>False</Private>
     </ProjectReference>
     <ProjectReference Include="..\..\..\Revetment\src\Ringtoets.Revetment.Data\Ringtoets.Revetment.Data.csproj">
       <Project>{87C2C553-C0BC-40BF-B1EA-B83BFF357F27}</Project>
       <Name>Ringtoets.Revetment.Data</Name>
+      <Private>False</Private>
     </ProjectReference>
     <ProjectReference Include="..\Ringtoets.WaveImpactAsphaltCover.Data\Ringtoets.WaveImpactAsphaltCover.Data.csproj">
       <Project>{567E0B69-5280-41CE-ADD6-443725A61C86}</Project>
Index: Ringtoets/WaveImpactAsphaltCover/src/Ringtoets.WaveImpactAsphaltCover.Plugin/WaveImpactAsphaltCoverPlugin.cs
===================================================================
diff -u -r047a56dd0274ea50de6f06ebad47fbe75ba86ba5 -r8e97f37e10d4445dfa2aeda2d321f347b5a59921
--- Ringtoets/WaveImpactAsphaltCover/src/Ringtoets.WaveImpactAsphaltCover.Plugin/WaveImpactAsphaltCoverPlugin.cs	(.../WaveImpactAsphaltCoverPlugin.cs)	(revision 047a56dd0274ea50de6f06ebad47fbe75ba86ba5)
+++ Ringtoets/WaveImpactAsphaltCover/src/Ringtoets.WaveImpactAsphaltCover.Plugin/WaveImpactAsphaltCoverPlugin.cs	(.../WaveImpactAsphaltCoverPlugin.cs)	(revision 8e97f37e10d4445dfa2aeda2d321f347b5a59921)
@@ -139,6 +139,7 @@
             return new object[]
             {
                 new CategoryTreeFolder(RingtoetsCommonFormsResources.FailureMechanism_Inputs_DisplayName, GetInputs(wrappedData, failureMechanismContext.Parent), TreeFolderCategory.Input),
+                new WaveImpactAsphaltCoverWaveConditionsCalculationGroupContext(wrappedData.WaveConditionsCalculationGroup, wrappedData, failureMechanismContext.Parent),
                 new CategoryTreeFolder(RingtoetsCommonFormsResources.FailureMechanism_Outputs_DisplayName, GetOutputs(wrappedData), TreeFolderCategory.Output)
             };
         }
@@ -250,7 +251,9 @@
             builder.AddExportItem()
                    .AddSeparator()
                    .AddCreateCalculationGroupItem(group)
-                   .AddCreateCalculationItem(nodeData, AddWaveConditionsCalculation);
+                   // TODO Restore in WTI-819
+                   //.AddCreateCalculationItem(nodeData, AddWaveConditionsCalculation)
+                   ;
 
             if (!isNestedGroup)
             {
@@ -303,8 +306,14 @@
 
         private StrictContextMenuItem CreateGenerateWaveConditionsCalculationsItem(WaveImpactAsphaltCoverWaveConditionsCalculationGroupContext nodeData)
         {
-            // TODO WTI-808
-            return null;
+            // TODO : This is a placeholder, so all corrections, improvements and functionality extensions are part of WTI-808.
+            return new StrictContextMenuItem(RingtoetsCommonFormsResources.CalculationsGroup_Generate_calculations,
+                                             "Er is geen hydraulische randvoorwaardendatabase beschikbaar om de randvoorwaardenberekeningen te genereren.",
+                                             RingtoetsCommonFormsResources.GenerateScenariosIcon,
+                                             (sender, args) => { ShowWaveImpactAsphaltCoverHydraulicBoundaryLocationSelectionDialog(nodeData); })
+            {
+                Enabled = false
+            };
         }
 
         private void ShowWaveImpactAsphaltCoverHydraulicBoundaryLocationSelectionDialog(WaveImpactAsphaltCoverWaveConditionsCalculationGroupContext nodeData)
@@ -319,14 +328,15 @@
 
         private void AddWaveConditionsCalculation(WaveImpactAsphaltCoverWaveConditionsCalculationGroupContext nodeData)
         {
-            var calculation = new WaveImpactAsphaltCoverWaveConditionsCalculation
-            {
-                Name = NamingHelper.GetUniqueName(nodeData.WrappedData.Children,
-                                                  WaveImpactAsphaltCoverDataResources.WaveImpactAsphaltCoverWaveConditionsCalculation_DefaultName,
-                                                  c => c.Name)
-            };
-            nodeData.WrappedData.Children.Add(calculation);
-            nodeData.WrappedData.NotifyObservers();
+            // TODO WTI-819, also add ViewInfo
+//            var calculation = new WaveImpactAsphaltCoverWaveConditionsCalculation
+//            {
+//                Name = NamingHelper.GetUniqueName(nodeData.WrappedData.Children,
+//                                                  WaveImpactAsphaltCoverDataResources.WaveImpactAsphaltCoverWaveConditionsCalculation_DefaultName,
+//                                                  c => c.Name)
+//            };
+//            nodeData.WrappedData.Children.Add(calculation);
+//            nodeData.WrappedData.NotifyObservers();
         }
 
         private void ValidateAll(IEnumerable<WaveImpactAsphaltCoverWaveConditionsCalculation> calculations, GeneralWaveConditionsInput generalInput, int norm, HydraulicBoundaryDatabase database)
Index: Ringtoets/WaveImpactAsphaltCover/test/Ringtoets.WaveImpactAsphaltCover.Data.Test/Ringtoets.WaveImpactAsphaltCover.Data.Test.csproj
===================================================================
diff -u -rbea6e87ff7f6b40ff9fcce4d46ccb55bb3b47535 -r8e97f37e10d4445dfa2aeda2d321f347b5a59921
--- Ringtoets/WaveImpactAsphaltCover/test/Ringtoets.WaveImpactAsphaltCover.Data.Test/Ringtoets.WaveImpactAsphaltCover.Data.Test.csproj	(.../Ringtoets.WaveImpactAsphaltCover.Data.Test.csproj)	(revision bea6e87ff7f6b40ff9fcce4d46ccb55bb3b47535)
+++ Ringtoets/WaveImpactAsphaltCover/test/Ringtoets.WaveImpactAsphaltCover.Data.Test/Ringtoets.WaveImpactAsphaltCover.Data.Test.csproj	(.../Ringtoets.WaveImpactAsphaltCover.Data.Test.csproj)	(revision 8e97f37e10d4445dfa2aeda2d321f347b5a59921)
@@ -41,6 +41,10 @@
       <HintPath>..\..\..\..\packages\NUnit.2.6.4\lib\nunit.framework.dll</HintPath>
       <Private>True</Private>
     </Reference>
+    <Reference Include="Rhino.Mocks, Version=3.6.0.0, Culture=neutral, PublicKeyToken=0b3305902db7183f, processorArchitecture=MSIL">
+      <HintPath>..\..\..\..\packages\RhinoMocks.3.6.1\lib\net\Rhino.Mocks.dll</HintPath>
+      <Private>True</Private>
+    </Reference>
     <Reference Include="System" />
     <Reference Include="System.Core" />
   </ItemGroup>
Index: Ringtoets/WaveImpactAsphaltCover/test/Ringtoets.WaveImpactAsphaltCover.Data.Test/WaveImpactAsphaltCoverFailureMechanismTest.cs
===================================================================
diff -u -rbea6e87ff7f6b40ff9fcce4d46ccb55bb3b47535 -r8e97f37e10d4445dfa2aeda2d321f347b5a59921
--- Ringtoets/WaveImpactAsphaltCover/test/Ringtoets.WaveImpactAsphaltCover.Data.Test/WaveImpactAsphaltCoverFailureMechanismTest.cs	(.../WaveImpactAsphaltCoverFailureMechanismTest.cs)	(revision bea6e87ff7f6b40ff9fcce4d46ccb55bb3b47535)
+++ Ringtoets/WaveImpactAsphaltCover/test/Ringtoets.WaveImpactAsphaltCover.Data.Test/WaveImpactAsphaltCoverFailureMechanismTest.cs	(.../WaveImpactAsphaltCoverFailureMechanismTest.cs)	(revision 8e97f37e10d4445dfa2aeda2d321f347b5a59921)
@@ -19,9 +19,14 @@
 // Stichting Deltares and remain full property of Stichting Deltares at all times.
 // All rights reserved.
 
+using System.Collections.Generic;
 using System.Linq;
+using Core.Common.Base;
 using Core.Common.Base.Geometry;
 using NUnit.Framework;
+using Rhino.Mocks;
+using Ringtoets.Common.Data.Calculation;
+using Ringtoets.Common.Data.DikeProfiles;
 using Ringtoets.Common.Data.FailureMechanism;
 using Ringtoets.Revetment.Data;
 
@@ -40,9 +45,18 @@
             Assert.IsInstanceOf<FailureMechanismBase>(failureMechanism);
             Assert.AreEqual("Dijken en dammen - Golfklappen op asfaltbekleding", failureMechanism.Name);
             Assert.AreEqual("AGK", failureMechanism.Code);
-            CollectionAssert.IsEmpty(failureMechanism.Sections);
+
+            Assert.AreEqual("Hydraulische randvoorwaarden", failureMechanism.WaveConditionsCalculationGroup.Name);
+            Assert.IsFalse(failureMechanism.WaveConditionsCalculationGroup.IsNameEditable);
+            CollectionAssert.IsEmpty(failureMechanism.WaveConditionsCalculationGroup.Children);
+
             CollectionAssert.IsEmpty(failureMechanism.ForeshoreProfiles);
+            Assert.IsInstanceOf<IObservable>(failureMechanism.ForeshoreProfiles);
+            Assert.IsInstanceOf<IList<ForeshoreProfile>>(failureMechanism.ForeshoreProfiles);
 
+            CollectionAssert.IsEmpty(failureMechanism.Sections);
+            CollectionAssert.IsEmpty(failureMechanism.Calculations);
+
             Assert.IsInstanceOf<GeneralWaveConditionsInput>(failureMechanism.GeneralInput);
         }
 
@@ -80,5 +94,35 @@
             CollectionAssert.IsEmpty(failureMechanism.Sections);
             CollectionAssert.IsEmpty(failureMechanism.SectionResults);
         }
+
+        [Test]
+        public void Calculations_MultipleChildrenAdded_ReturnWaveImpactAsphaltCoverCalculations()
+        {
+            // Setup
+            var mocks = new MockRepository();
+            var failureMechanism = new WaveImpactAsphaltCoverFailureMechanism
+            {
+                WaveConditionsCalculationGroup =
+                {
+                    Children =
+                    {
+                        new CalculationGroup(),
+                        new WaveImpactAsphaltCoverWaveConditionsCalculation(),
+                        mocks.StrictMock<ICalculation>(),
+                        new WaveImpactAsphaltCoverWaveConditionsCalculation()
+                    }
+                }
+            };
+
+            mocks.ReplayAll();
+
+            // Call
+            var calculations = failureMechanism.Calculations.ToList();
+
+            // Assert
+            Assert.AreEqual(2, calculations.Count);
+            Assert.IsTrue(calculations.All(c => c is WaveImpactAsphaltCoverWaveConditionsCalculation));
+            mocks.VerifyAll();
+        }
     }
 }
\ No newline at end of file
Index: Ringtoets/WaveImpactAsphaltCover/test/Ringtoets.WaveImpactAsphaltCover.Data.Test/packages.config
===================================================================
diff -u -r944d2501b3f780d208e00015a1b850afad4c3aa8 -r8e97f37e10d4445dfa2aeda2d321f347b5a59921
--- Ringtoets/WaveImpactAsphaltCover/test/Ringtoets.WaveImpactAsphaltCover.Data.Test/packages.config	(.../packages.config)	(revision 944d2501b3f780d208e00015a1b850afad4c3aa8)
+++ Ringtoets/WaveImpactAsphaltCover/test/Ringtoets.WaveImpactAsphaltCover.Data.Test/packages.config	(.../packages.config)	(revision 8e97f37e10d4445dfa2aeda2d321f347b5a59921)
@@ -1,4 +1,5 @@
 <?xml version="1.0" encoding="utf-8"?>
 <packages>
   <package id="NUnit" version="2.6.4" targetFramework="net40" />
+  <package id="RhinoMocks" version="3.6.1" targetFramework="net40" />
 </packages>
\ No newline at end of file
Index: Ringtoets/WaveImpactAsphaltCover/test/Ringtoets.WaveImpactAsphaltCover.Forms.Test/Ringtoets.WaveImpactAsphaltCover.Forms.Test.csproj
===================================================================
diff -u -r047a56dd0274ea50de6f06ebad47fbe75ba86ba5 -r8e97f37e10d4445dfa2aeda2d321f347b5a59921
--- Ringtoets/WaveImpactAsphaltCover/test/Ringtoets.WaveImpactAsphaltCover.Forms.Test/Ringtoets.WaveImpactAsphaltCover.Forms.Test.csproj	(.../Ringtoets.WaveImpactAsphaltCover.Forms.Test.csproj)	(revision 047a56dd0274ea50de6f06ebad47fbe75ba86ba5)
+++ Ringtoets/WaveImpactAsphaltCover/test/Ringtoets.WaveImpactAsphaltCover.Forms.Test/Ringtoets.WaveImpactAsphaltCover.Forms.Test.csproj	(.../Ringtoets.WaveImpactAsphaltCover.Forms.Test.csproj)	(revision 8e97f37e10d4445dfa2aeda2d321f347b5a59921)
@@ -64,6 +64,7 @@
     <Compile Include="PropertyClasses\WaveImpactAsphaltCoverFailureMechanismContextPropertiesTest.cs" />
     <Compile Include="Views\WaveImpactAsphaltCoverFailureMechanismResultViewTest.cs" />
     <Compile Include="Views\WaveImpactAsphaltCoverFailureMechanismSectionResultRowTest.cs" />
+    <Compile Include="TreeNodeInfos\WaveImpactAsphaltCoverWaveConditionsCalculationGroupContextTreeNodeInfoTest.cs" />
   </ItemGroup>
   <ItemGroup>
     <None Include="..\..\..\..\build\Copying.licenseheader">
@@ -76,6 +77,10 @@
       <Project>{3BBFD65B-B277-4E50-AE6D-BD24C3434609}</Project>
       <Name>Core.Common.Base</Name>
     </ProjectReference>
+    <ProjectReference Include="..\..\..\..\Core\Common\src\Core.Common.Controls.TreeView\Core.Common.Controls.TreeView.csproj">
+      <Project>{1D27F91F-4E62-4EAF-A0A8-A32708B9A9B1}</Project>
+      <Name>Core.Common.Controls.TreeView</Name>
+    </ProjectReference>
     <ProjectReference Include="..\..\..\..\Core\Common\src\Core.Common.Controls\Core.Common.Controls.csproj">
       <Project>{9a2d67e6-26ac-4d17-b11a-2b4372f2f572}</Project>
       <Name>Core.Common.Controls</Name>
@@ -88,6 +93,10 @@
       <Project>{F49BD8B2-332A-4C91-A196-8CCE0A2C7D98}</Project>
       <Name>Core.Common.Utils</Name>
     </ProjectReference>
+    <ProjectReference Include="..\..\..\..\Core\Common\test\Core.Common.Gui.TestUtil\Core.Common.Gui.TestUtil.csproj">
+      <Project>{26214BD0-DAFB-4CFC-8EB2-80C5D53C859E}</Project>
+      <Name>Core.Common.Gui.TestUtil</Name>
+    </ProjectReference>
     <ProjectReference Include="..\..\..\..\Core\Common\test\Core.Common.TestUtil\Core.Common.TestUtil.csproj">
       <Project>{D749EE4C-CE50-4C17-BF01-9A953028C126}</Project>
       <Name>Core.Common.TestUtil</Name>
@@ -108,6 +117,18 @@
       <Project>{70F8CC9C-5BC8-4FB2-B201-EAE7FA8088C2}</Project>
       <Name>Ringtoets.HydraRing.Data</Name>
     </ProjectReference>
+    <ProjectReference Include="..\..\..\HydraRing\test\Ringtoets.HydraRing.Calculation.TestUtil\Ringtoets.HydraRing.Calculation.TestUtil.csproj">
+      <Project>{74CBA865-9338-447F-BAD9-28312446AE84}</Project>
+      <Name>Ringtoets.HydraRing.Calculation.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>
+    </ProjectReference>
+    <ProjectReference Include="..\..\..\Revetment\test\Ringtoets.Revetment.Service.TestUtil\Ringtoets.Revetment.Service.TestUtil.csproj">
+      <Project>{EA416DD2-1633-439E-8512-B9933E37B9C5}</Project>
+      <Name>Ringtoets.Revetment.Service.TestUtil</Name>
+    </ProjectReference>
     <ProjectReference Include="..\..\src\Ringtoets.WaveImpactAsphaltCover.Data\Ringtoets.WaveImpactAsphaltCover.Data.csproj">
       <Project>{567E0B69-5280-41CE-ADD6-443725A61C86}</Project>
       <Name>Ringtoets.WaveImpactAsphaltCover.Data</Name>
@@ -116,6 +137,10 @@
       <Project>{1AC97B51-88C2-437D-89E6-65C69AB3CCAD}</Project>
       <Name>Ringtoets.WaveImpactAsphaltCover.Forms</Name>
     </ProjectReference>
+    <ProjectReference Include="..\..\src\Ringtoets.WaveImpactAsphaltCover.Plugin\Ringtoets.WaveImpactAsphaltCover.Plugin.csproj">
+      <Project>{83A782F1-BA78-4D5C-B213-39066605AFD8}</Project>
+      <Name>Ringtoets.WaveImpactAsphaltCover.Plugin</Name>
+    </ProjectReference>
   </ItemGroup>
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
   <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
Index: Ringtoets/WaveImpactAsphaltCover/test/Ringtoets.WaveImpactAsphaltCover.Forms.Test/TreeNodeInfos/WaveImpactAsphaltCoverWaveConditionsCalculationGroupContextTreeNodeInfoTest.cs
===================================================================
diff -u
--- Ringtoets/WaveImpactAsphaltCover/test/Ringtoets.WaveImpactAsphaltCover.Forms.Test/TreeNodeInfos/WaveImpactAsphaltCoverWaveConditionsCalculationGroupContextTreeNodeInfoTest.cs	(revision 0)
+++ Ringtoets/WaveImpactAsphaltCover/test/Ringtoets.WaveImpactAsphaltCover.Forms.Test/TreeNodeInfos/WaveImpactAsphaltCoverWaveConditionsCalculationGroupContextTreeNodeInfoTest.cs	(revision 8e97f37e10d4445dfa2aeda2d321f347b5a59921)
@@ -0,0 +1,1582 @@
+// Copyright (C) Stichting Deltares 2016. 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.Drawing;
+using System.IO;
+using System.Linq;
+using System.Windows.Forms;
+using Core.Common.Base;
+using Core.Common.Base.Data;
+using Core.Common.Base.Geometry;
+using Core.Common.Controls.TreeView;
+using Core.Common.Gui;
+using Core.Common.Gui.Commands;
+using Core.Common.Gui.ContextMenu;
+using Core.Common.Gui.Forms.MainWindow;
+using Core.Common.Gui.TestUtil.ContextMenu;
+using Core.Common.TestUtil;
+using NUnit.Extensions.Forms;
+using NUnit.Framework;
+using Rhino.Mocks;
+using Ringtoets.Common.Data.AssessmentSection;
+using Ringtoets.Common.Data.Calculation;
+using Ringtoets.Common.Data.Contribution;
+using Ringtoets.Common.Data.DikeProfiles;
+using Ringtoets.Common.Data.FailureMechanism;
+using Ringtoets.HydraRing.Calculation.TestUtil;
+using Ringtoets.HydraRing.Data;
+using Ringtoets.Revetment.Data;
+using Ringtoets.Revetment.Service.TestUtil;
+using Ringtoets.WaveImpactAsphaltCover.Data;
+using Ringtoets.WaveImpactAsphaltCover.Forms.PresentationObjects;
+using Ringtoets.WaveImpactAsphaltCover.Plugin;
+using RingtoetsCommonFormsResources = Ringtoets.Common.Forms.Properties.Resources;
+using CoreCommonGuiResources = Core.Common.Gui.Properties.Resources;
+
+namespace Ringtoets.WaveImpactAsphaltCover.Forms.Test.TreeNodeInfos
+{
+    [TestFixture]
+    public class WaveImpactAsphaltCoverWaveConditionsCalculationGroupContextTreeNodeInfoTest : NUnitFormTest
+    {
+        private const int contextMenuAddCalculationGroupIndexRootGroup = 3;
+        private const int contextMenuAddCalculationIndexRootGroup = 4;
+        private const int contextMenuRemoveAllChildrenIndexRootGroup = 6;
+        private const int contextMenuValidateAllIndexRootGroup = 8;
+        private const int contextMenuCalculateAllIndexRootGroup = 9;
+        private const int contextMenuClearOutputIndexRootGroup = 10;
+        private const int contextMenuExpandAllIndexRootGroup = 12;
+        private const int contextMenuCollapseAllIndexRootGroup = 13;
+        private const int contextMenuPropertiesIndexRootGroup = 15;
+
+        private const int contextMenuAddCalculationGroupIndexNestedGroup = 2;
+        private const int contextMenuAddCalculationIndexNestedGroup = 3;
+        private const int contextMenuValidateAllIndexNestedGroup = 5;
+        private const int contextMenuCalculateAllIndexNestedGroup = 6;
+        private const int contextMenuClearOutputNestedGroupIndex = 7;
+
+        private const int customOnlyContextMenuAddGenerateCalculationsIndex = 0;
+        private const int contextMenuValidateAllIndexNestedGroupNoCalculations = 4;
+        private const int contextMenuCalculateAllIndexNestedGroupNoCalculations = 5;
+
+        private const int contextMenuRemoveAllInGroup = 5;
+
+        private const int customOnlyContextMenuRemoveAllChildrenIndex = 5;
+        private MockRepository mocks;
+        private WaveImpactAsphaltCoverPlugin plugin;
+        private TreeNodeInfo info;
+
+        [SetUp]
+        public void SetUp()
+        {
+            mocks = new MockRepository();
+            plugin = new WaveImpactAsphaltCoverPlugin();
+            info = plugin.GetTreeNodeInfos().First(tni => tni.TagType == typeof(WaveImpactAsphaltCoverWaveConditionsCalculationGroupContext));
+        }
+
+        [TearDown]
+        public override void TearDown()
+        {
+            plugin.Dispose();
+            mocks.VerifyAll();
+
+            base.TearDown();
+        }
+
+        [Test]
+        public void Initialized_Always_ExpectedPropertiesSet()
+        {
+            // Setup
+            mocks.ReplayAll();
+
+            // Assert
+            Assert.AreEqual(typeof(WaveImpactAsphaltCoverWaveConditionsCalculationGroupContext), info.TagType);
+
+            Assert.IsNull(info.ForeColor);
+            Assert.IsNull(info.CanCheck);
+            Assert.IsNull(info.IsChecked);
+            Assert.IsNull(info.OnNodeChecked);
+        }
+
+        [Test]
+        public void Text_Always_ReturnGroupName()
+        {
+            // Setup
+            var assessmentSection = mocks.Stub<IAssessmentSection>();
+            mocks.ReplayAll();
+
+            var failureMechanism = new WaveImpactAsphaltCoverFailureMechanism();
+            var context = new WaveImpactAsphaltCoverWaveConditionsCalculationGroupContext(failureMechanism.WaveConditionsCalculationGroup,
+                                                                                       failureMechanism,
+                                                                                       assessmentSection);
+
+            // Call
+            string text = info.Text(context);
+
+            // Assert
+            Assert.AreEqual("Hydraulische randvoorwaarden", text);
+        }
+
+        [Test]
+        public void Image_Always_ReturnCalculationGroupIcon()
+        {
+            // Setup
+            var assessmentSection = mocks.Stub<IAssessmentSection>();
+            mocks.ReplayAll();
+
+            var failureMechanism = new WaveImpactAsphaltCoverFailureMechanism();
+            var context = new WaveImpactAsphaltCoverWaveConditionsCalculationGroupContext(failureMechanism.WaveConditionsCalculationGroup,
+                                                                                       failureMechanism,
+                                                                                       assessmentSection);
+
+            // Call
+            Image icon = info.Image(context);
+
+            // Assert
+            TestHelper.AssertImagesAreEqual(RingtoetsCommonFormsResources.GeneralFolderIcon, icon);
+        }
+
+        [Test]
+        public void ChildNodeObjects_EmptyGroup_ReturnEmpty()
+        {
+            // Setup
+            var assessmentSection = mocks.Stub<IAssessmentSection>();
+            mocks.ReplayAll();
+
+            var failureMechanism = new WaveImpactAsphaltCoverFailureMechanism();
+
+            var groupContext = new WaveImpactAsphaltCoverWaveConditionsCalculationGroupContext(failureMechanism.WaveConditionsCalculationGroup,
+                                                                                            failureMechanism,
+                                                                                            assessmentSection);
+
+            // Call
+            var children = info.ChildNodeObjects(groupContext);
+
+            // Assert
+            CollectionAssert.IsEmpty(children);
+        }
+
+        [Test]
+        public void ChildNodeObjects_GroupWithChildren_ReturnChildren()
+        {
+            // Setup
+            var assessmentSection = mocks.Stub<IAssessmentSection>();
+            var calculationItem = mocks.StrictMock<ICalculationBase>();
+            mocks.ReplayAll();
+
+            var childGroup = new CalculationGroup();
+
+            var failureMechanism = new WaveImpactAsphaltCoverFailureMechanism();
+            failureMechanism.WaveConditionsCalculationGroup.Children.Add(calculationItem);
+            failureMechanism.WaveConditionsCalculationGroup.Children.Add(childGroup);
+
+            var nodeData = new WaveImpactAsphaltCoverWaveConditionsCalculationGroupContext(failureMechanism.WaveConditionsCalculationGroup,
+                                                                                        failureMechanism,
+                                                                                        assessmentSection);
+
+            // Call
+            var children = info.ChildNodeObjects(nodeData).ToArray();
+
+            // Assert
+            Assert.AreEqual(failureMechanism.WaveConditionsCalculationGroup.Children.Count, children.Length);
+            Assert.AreSame(calculationItem, children[0]);
+            var returnedCalculationGroupContext = (WaveImpactAsphaltCoverWaveConditionsCalculationGroupContext)children[1];
+            Assert.AreSame(childGroup, returnedCalculationGroupContext.WrappedData);
+            Assert.AreSame(failureMechanism, returnedCalculationGroupContext.FailureMechanism);
+        }
+
+        [Test]
+        public void ContextMenuStrip_NestedCalculationGroup_ReturnContextMenuWithItems()
+        {
+            // Setup
+            var group = new CalculationGroup();
+
+            var failureMechanism = new WaveImpactAsphaltCoverFailureMechanism();
+            failureMechanism.WaveConditionsCalculationGroup.Children.Add(group);
+
+            var assessmentSection = mocks.Stub<IAssessmentSection>();
+
+            var nodeData = new WaveImpactAsphaltCoverWaveConditionsCalculationGroupContext(group,
+                                                                                        failureMechanism,
+                                                                                        assessmentSection);
+            var parentNodeData = new WaveImpactAsphaltCoverWaveConditionsCalculationGroupContext(failureMechanism.WaveConditionsCalculationGroup,
+                                                                                              failureMechanism,
+                                                                                              assessmentSection);
+
+            var applicationFeatureCommandHandler = mocks.Stub<IApplicationFeatureCommands>();
+            var importHandlerMock = mocks.StrictMock<IImportCommandHandler>();
+            var exportHandlerMock = mocks.StrictMock<IExportCommandHandler>();
+            exportHandlerMock.Expect(ehm => ehm.CanExportFrom(nodeData)).Return(true);
+            var viewCommandsHandler = mocks.StrictMock<IViewCommands>();
+            var treeViewControl = mocks.StrictMock<TreeViewControl>();
+
+            var menuBuilder = new ContextMenuBuilder(applicationFeatureCommandHandler,
+                                                     importHandlerMock,
+                                                     exportHandlerMock,
+                                                     viewCommandsHandler,
+                                                     nodeData,
+                                                     treeViewControl);
+
+            var gui = mocks.Stub<IGui>();
+            gui.Stub(g => g.Get(nodeData, treeViewControl)).Return(menuBuilder);
+
+            treeViewControl.Expect(tvc => tvc.CanRemoveNodeForData(nodeData)).Return(true);
+            treeViewControl.Expect(tvc => tvc.CanRenameNodeForData(nodeData)).Return(true);
+            treeViewControl.Expect(tvc => tvc.CanExpandOrCollapseForData(nodeData)).Repeat.Twice().Return(false);
+
+            mocks.ReplayAll();
+
+            plugin.Gui = gui;
+
+            // Call
+            using (ContextMenuStrip menu = info.ContextMenuStrip(nodeData, parentNodeData, treeViewControl))
+            {
+                // Assert
+                Assert.AreEqual(15, menu.Items.Count);
+
+                TestHelper.AssertContextMenuStripContainsItem(menu, 0,
+                                                              CoreCommonGuiResources.Export,
+                                                              CoreCommonGuiResources.Export_ToolTip,
+                                                              CoreCommonGuiResources.ExportIcon);
+
+                TestHelper.AssertContextMenuStripContainsItem(menu, contextMenuAddCalculationGroupIndexNestedGroup,
+                                                              RingtoetsCommonFormsResources.CalculationGroup_Add_CalculationGroup,
+                                                              "Voeg een nieuwe berekeningsmap toe aan deze berekeningsmap.",
+                                                              RingtoetsCommonFormsResources.AddFolderIcon);
+                // TODO WTI-819
+                //TestHelper.AssertContextMenuStripContainsItem(menu, contextMenuAddCalculationIndexNestedGroup,
+                //                                              RingtoetsCommonFormsResources.CalculationGroup_Add_Calculation,
+                //                                              "Voeg een nieuwe berekening toe aan deze berekeningsmap.",
+                //                                              RingtoetsCommonFormsResources.FailureMechanismIcon);
+                TestHelper.AssertContextMenuStripContainsItem(menu, contextMenuValidateAllIndexNestedGroup-1,
+                                                              RingtoetsCommonFormsResources.Validate_all,
+                                                              "Er zijn geen berekeningen om te valideren.",
+                                                              RingtoetsCommonFormsResources.ValidateAllIcon,
+                                                              false);
+                TestHelper.AssertContextMenuStripContainsItem(menu, contextMenuCalculateAllIndexNestedGroup-1,
+                                                              RingtoetsCommonFormsResources.Calculate_all,
+                                                              "Er zijn geen berekeningen om uit te voeren.",
+                                                              RingtoetsCommonFormsResources.CalculateAllIcon,
+                                                              false);
+                TestHelper.AssertContextMenuStripContainsItem(menu, contextMenuClearOutputNestedGroupIndex-1,
+                                                              "&Wis alle uitvoer...",
+                                                              "Er zijn geen berekeningen met uitvoer om te wissen.",
+                                                              RingtoetsCommonFormsResources.ClearIcon,
+                                                              false);
+
+                TestHelper.AssertContextMenuStripContainsItem(menu, 9-1,
+                                                              CoreCommonGuiResources.Rename,
+                                                              CoreCommonGuiResources.Rename_ToolTip,
+                                                              CoreCommonGuiResources.RenameIcon);
+                TestHelper.AssertContextMenuStripContainsItem(menu, 10-1,
+                                                              CoreCommonGuiResources.Delete,
+                                                              CoreCommonGuiResources.Delete_ToolTip,
+                                                              CoreCommonGuiResources.DeleteIcon);
+
+                TestHelper.AssertContextMenuStripContainsItem(menu, 12-1,
+                                                              CoreCommonGuiResources.Expand_all,
+                                                              CoreCommonGuiResources.Expand_all_ToolTip,
+                                                              CoreCommonGuiResources.ExpandAllIcon,
+                                                              false);
+                TestHelper.AssertContextMenuStripContainsItem(menu, 13-1,
+                                                              CoreCommonGuiResources.Collapse_all,
+                                                              CoreCommonGuiResources.Collapse_all_ToolTip,
+                                                              CoreCommonGuiResources.CollapseAllIcon,
+                                                              false);
+
+                TestHelper.AssertContextMenuStripContainsItem(menu, 15-1,
+                                                              CoreCommonGuiResources.Properties,
+                                                              CoreCommonGuiResources.Properties_ToolTip,
+                                                              CoreCommonGuiResources.PropertiesHS,
+                                                              false);
+
+                CollectionAssert.AllItemsAreInstancesOfType(new[]
+                {
+                    menu.Items[1],
+                    menu.Items[4-1],
+                    menu.Items[8-1],
+                    menu.Items[11-1],
+                    menu.Items[14-1]
+                }, typeof(ToolStripSeparator));
+            }
+        }
+
+        [Test]
+        public void ContextMenuStrip_WithoutParentNodeWithoutHydraulicLocationsDefaultBehavior_ReturnContextMenuWithoutRenameRemove()
+        {
+            // Setup
+            var assessmentSection = mocks.Stub<IAssessmentSection>();
+
+            var failureMechanism = new WaveImpactAsphaltCoverFailureMechanism();
+
+            var nodeData = new WaveImpactAsphaltCoverWaveConditionsCalculationGroupContext(failureMechanism.WaveConditionsCalculationGroup,
+                                                                                        failureMechanism,
+                                                                                        assessmentSection);
+
+            var applicationFeatureCommandHandler = mocks.Stub<IApplicationFeatureCommands>();
+            var importHandlerMock = mocks.StrictMock<IImportCommandHandler>();
+            var exportHandlerMock = mocks.StrictMock<IExportCommandHandler>();
+            exportHandlerMock.Expect(ehm => ehm.CanExportFrom(nodeData)).Return(true);
+            var viewCommandsHandler = mocks.StrictMock<IViewCommands>();
+            using (var treeViewControl = new TreeViewControl())
+            {
+                var menuBuilder = new ContextMenuBuilder(applicationFeatureCommandHandler,
+                                                         importHandlerMock,
+                                                         exportHandlerMock,
+                                                         viewCommandsHandler,
+                                                         nodeData,
+                                                         treeViewControl);
+
+                var gui = mocks.Stub<IGui>();
+                gui.Stub(g => g.Get(nodeData, treeViewControl)).Return(menuBuilder);
+                gui.Stub(cmp => cmp.ViewCommands).Return(mocks.Stub<IViewCommands>());
+                mocks.ReplayAll();
+
+                plugin.Gui = gui;
+
+                // Call
+                using (ContextMenuStrip menu = info.ContextMenuStrip(nodeData, null, treeViewControl))
+                {
+                    // Assert
+                    Assert.AreEqual(15, menu.Items.Count);
+                    TestHelper.AssertContextMenuStripContainsItem(menu, customOnlyContextMenuAddGenerateCalculationsIndex,
+                                                                  RingtoetsCommonFormsResources.CalculationsGroup_Generate_calculations,
+                                                                  "Er is geen hydraulische randvoorwaardendatabase beschikbaar om de randvoorwaardenberekeningen te genereren.",
+                                                                  RingtoetsCommonFormsResources.GenerateScenariosIcon, false);
+                    TestHelper.AssertContextMenuStripContainsItem(menu, contextMenuAddCalculationGroupIndexRootGroup,
+                                                                  RingtoetsCommonFormsResources.CalculationGroup_Add_CalculationGroup,
+                                                                  "Voeg een nieuwe berekeningsmap toe aan deze berekeningsmap.",
+                                                                  RingtoetsCommonFormsResources.AddFolderIcon);
+                    // TODO WTI-819
+                    //TestHelper.AssertContextMenuStripContainsItem(menu, contextMenuAddCalculationIndexRootGroup,
+                    //                                              RingtoetsCommonFormsResources.CalculationGroup_Add_Calculation,
+                    //                                              "Voeg een nieuwe berekening toe aan deze berekeningsmap.",
+                    //                                              RingtoetsCommonFormsResources.FailureMechanismIcon);
+                    TestHelper.AssertContextMenuStripContainsItem(menu, contextMenuRemoveAllChildrenIndexRootGroup-1,
+                                                                  RingtoetsCommonFormsResources.CalculationGroup_RemoveAllChildrenFromGroup_Remove_all,
+                                                                  "Er zijn geen berekeningen of mappen om te verwijderen.",
+                                                                  RingtoetsCommonFormsResources.RemoveAllIcon,
+                                                                  false);
+                    TestHelper.AssertContextMenuStripContainsItem(menu, contextMenuValidateAllIndexRootGroup-1,
+                                                                  RingtoetsCommonFormsResources.Validate_all,
+                                                                  "Er zijn geen berekeningen om te valideren.",
+                                                                  RingtoetsCommonFormsResources.ValidateAllIcon,
+                                                                  false);
+                    TestHelper.AssertContextMenuStripContainsItem(menu, contextMenuCalculateAllIndexRootGroup-1,
+                                                                  RingtoetsCommonFormsResources.Calculate_all,
+                                                                  "Er zijn geen berekeningen om uit te voeren.",
+                                                                  RingtoetsCommonFormsResources.CalculateAllIcon,
+                                                                  false);
+                    TestHelper.AssertContextMenuStripContainsItem(menu, contextMenuClearOutputIndexRootGroup-1,
+                                                                  "&Wis alle uitvoer...",
+                                                                  "Er zijn geen berekeningen met uitvoer om te wissen.",
+                                                                  RingtoetsCommonFormsResources.ClearIcon,
+                                                                  false);
+
+                    TestHelper.AssertContextMenuStripContainsItem(menu, contextMenuExpandAllIndexRootGroup-1,
+                                                                  CoreCommonGuiResources.Expand_all,
+                                                                  CoreCommonGuiResources.Expand_all_ToolTip,
+                                                                  CoreCommonGuiResources.ExpandAllIcon,
+                                                                  false);
+                    TestHelper.AssertContextMenuStripContainsItem(menu, contextMenuCollapseAllIndexRootGroup-1,
+                                                                  CoreCommonGuiResources.Collapse_all,
+                                                                  CoreCommonGuiResources.Collapse_all_ToolTip,
+                                                                  CoreCommonGuiResources.CollapseAllIcon,
+                                                                  false);
+
+                    TestHelper.AssertContextMenuStripContainsItem(menu, contextMenuPropertiesIndexRootGroup-1,
+                                                                  CoreCommonGuiResources.Properties,
+                                                                  CoreCommonGuiResources.Properties_ToolTip,
+                                                                  CoreCommonGuiResources.PropertiesHS,
+                                                                  false);
+                    CollectionAssert.AllItemsAreInstancesOfType(new[]
+                    {
+                        menu.Items[2],
+                        menu.Items[5-1],
+                        menu.Items[7-1],
+                        menu.Items[11-1],
+                        menu.Items[14-1]
+                    }, typeof(ToolStripSeparator));
+                }
+            }
+        }
+
+        // TODO WTI-819
+        //[Test]
+        //public void ContextMenuStrip_WithoutParentNodeWithHydraulicLocationsDefaultBehavior_ReturnContextMenuWithoutRenameRemove()
+        //{
+        //    // Setup
+        //    var assessmentSection = mocks.Stub<IAssessmentSection>();
+        //    assessmentSection.HydraulicBoundaryDatabase = new HydraulicBoundaryDatabase
+        //    {
+        //        Locations =
+        //        {
+        //            new HydraulicBoundaryLocation(1, "1", 1, 1)
+        //        }
+        //    };
+        //    var failureMechanism = new WaveImpactAsphaltCoverFailureMechanism();
+
+        //    var nodeData = new WaveImpactAsphaltCoverWaveConditionsCalculationGroupContext(failureMechanism.WaveConditionsCalculationGroup,
+        //                                                                                failureMechanism,
+        //                                                                                assessmentSection);
+
+        //    var applicationFeatureCommandHandler = mocks.Stub<IApplicationFeatureCommands>();
+        //    var importHandlerMock = mocks.StrictMock<IImportCommandHandler>();
+        //    var exportHandlerMock = mocks.StrictMock<IExportCommandHandler>();
+        //    exportHandlerMock.Expect(ehm => ehm.CanExportFrom(nodeData)).Return(true);
+        //    var viewCommandsHandler = mocks.StrictMock<IViewCommands>();
+        //    using (var treeViewControl = new TreeViewControl())
+        //    {
+        //        var menuBuilder = new ContextMenuBuilder(applicationFeatureCommandHandler,
+        //                                                 importHandlerMock,
+        //                                                 exportHandlerMock,
+        //                                                 viewCommandsHandler,
+        //                                                 nodeData,
+        //                                                 treeViewControl);
+
+        //        var gui = mocks.Stub<IGui>();
+        //        gui.Stub(g => g.Get(nodeData, treeViewControl)).Return(menuBuilder);
+        //        gui.Stub(cmp => cmp.ViewCommands).Return(mocks.Stub<IViewCommands>());
+        //        mocks.ReplayAll();
+
+        //        plugin.Gui = gui;
+
+        //        // Call
+        //        using (ContextMenuStrip menu = info.ContextMenuStrip(nodeData, null, treeViewControl))
+        //        {
+        //            // Assert
+        //            Assert.AreEqual(16, menu.Items.Count);
+        //            TestHelper.AssertContextMenuStripContainsItem(menu, customOnlyContextMenuAddGenerateCalculationsIndex,
+        //                                                          RingtoetsCommonFormsResources.CalculationsGroup_Generate_calculations,
+        //                                                          "Genereer randvoorwaardenberekeningen.",
+        //                                                          RingtoetsCommonFormsResources.GenerateScenariosIcon);
+        //            TestHelper.AssertContextMenuStripContainsItem(menu, contextMenuAddCalculationGroupIndexRootGroup,
+        //                                                          RingtoetsCommonFormsResources.CalculationGroup_Add_CalculationGroup,
+        //                                                          "Voeg een nieuwe berekeningsmap toe aan deze berekeningsmap.",
+        //                                                          RingtoetsCommonFormsResources.AddFolderIcon);
+        //            TestHelper.AssertContextMenuStripContainsItem(menu, contextMenuAddCalculationIndexRootGroup,
+        //                                                          RingtoetsCommonFormsResources.CalculationGroup_Add_Calculation,
+        //                                                          "Voeg een nieuwe berekening toe aan deze berekeningsmap.",
+        //                                                          RingtoetsCommonFormsResources.FailureMechanismIcon);
+
+        //            TestHelper.AssertContextMenuStripContainsItem(menu, contextMenuRemoveAllChildrenIndexRootGroup,
+        //                                                          RingtoetsCommonFormsResources.CalculationGroup_RemoveAllChildrenFromGroup_Remove_all,
+        //                                                          "Er zijn geen berekeningen of mappen om te verwijderen.",
+        //                                                          RingtoetsCommonFormsResources.RemoveAllIcon,
+        //                                                          false);
+
+        //            TestHelper.AssertContextMenuStripContainsItem(menu, contextMenuValidateAllIndexRootGroup,
+        //                                                          RingtoetsCommonFormsResources.Validate_all,
+        //                                                          "Er zijn geen berekeningen om te valideren.",
+        //                                                          RingtoetsCommonFormsResources.ValidateAllIcon,
+        //                                                          false);
+        //            TestHelper.AssertContextMenuStripContainsItem(menu, contextMenuCalculateAllIndexRootGroup,
+        //                                                          RingtoetsCommonFormsResources.Calculate_all,
+        //                                                          "Er zijn geen berekeningen om uit te voeren.",
+        //                                                          RingtoetsCommonFormsResources.CalculateAllIcon,
+        //                                                          false);
+        //            TestHelper.AssertContextMenuStripContainsItem(menu, contextMenuClearOutputIndexRootGroup,
+        //                                                          "&Wis alle uitvoer...",
+        //                                                          "Er zijn geen berekeningen met uitvoer om te wissen.",
+        //                                                          RingtoetsCommonFormsResources.ClearIcon,
+        //                                                          false);
+
+        //            TestHelper.AssertContextMenuStripContainsItem(menu, contextMenuExpandAllIndexRootGroup,
+        //                                                          CoreCommonGuiResources.Expand_all,
+        //                                                          CoreCommonGuiResources.Expand_all_ToolTip,
+        //                                                          CoreCommonGuiResources.ExpandAllIcon,
+        //                                                          false);
+        //            TestHelper.AssertContextMenuStripContainsItem(menu, contextMenuCollapseAllIndexRootGroup,
+        //                                                          CoreCommonGuiResources.Collapse_all,
+        //                                                          CoreCommonGuiResources.Collapse_all_ToolTip,
+        //                                                          CoreCommonGuiResources.CollapseAllIcon,
+        //                                                          false);
+
+        //            TestHelper.AssertContextMenuStripContainsItem(menu, contextMenuPropertiesIndexRootGroup,
+        //                                                          CoreCommonGuiResources.Properties,
+        //                                                          CoreCommonGuiResources.Properties_ToolTip,
+        //                                                          CoreCommonGuiResources.PropertiesHS,
+        //                                                          false);
+        //            CollectionAssert.AllItemsAreInstancesOfType(new[]
+        //            {
+        //                menu.Items[2],
+        //                menu.Items[5],
+        //                menu.Items[7],
+        //                menu.Items[11],
+        //                menu.Items[14]
+        //            }, typeof(ToolStripSeparator));
+        //        }
+        //    }
+        //}
+
+        // TODO WTI-819
+        //[Test]
+        //public void ContextMenuStrip_NestedCalculationGroupWithNoCalculations_ValidateAndCalculateAllDisabled()
+        //{
+        //    // Setup
+        //    using (var treeViewControl = new TreeViewControl())
+        //    {
+        //        var failureMechanism = new WaveImpactAsphaltCoverFailureMechanism();
+        //        var group = new CalculationGroup();
+        //        failureMechanism.WaveConditionsCalculationGroup.Children.Add(group);
+        //        var assessmentSection = mocks.Stub<IAssessmentSection>();
+        //        var nodeData = new WaveImpactAsphaltCoverWaveConditionsCalculationGroupContext(group,
+        //                                                                                    failureMechanism,
+        //                                                                                    assessmentSection);
+        //        var parentNodeData = new WaveImpactAsphaltCoverWaveConditionsCalculationGroupContext(failureMechanism.WaveConditionsCalculationGroup,
+        //                                                                                          failureMechanism,
+        //                                                                                          assessmentSection);
+
+        //        var menuBuilder = new CustomItemsOnlyContextMenuBuilder();
+
+        //        var gui = mocks.Stub<IGui>();
+        //        gui.Stub(cmp => cmp.Get(nodeData, treeViewControl)).Return(menuBuilder);
+
+        //        mocks.ReplayAll();
+
+        //        plugin.Gui = gui;
+
+        //        // Call
+        //        using (ContextMenuStrip contextMenu = info.ContextMenuStrip(nodeData, parentNodeData, treeViewControl))
+        //        {
+        //            // Assert
+        //            ToolStripItem validateItem = contextMenu.Items[contextMenuValidateAllIndexNestedGroupNoCalculations];
+        //            ToolStripItem calculateItem = contextMenu.Items[contextMenuCalculateAllIndexNestedGroupNoCalculations];
+        //            Assert.IsFalse(validateItem.Enabled);
+        //            Assert.IsFalse(calculateItem.Enabled);
+        //            Assert.AreEqual(RingtoetsCommonFormsResources.FailureMechanism_CreateCalculateAllItem_No_calculations_to_run, calculateItem.ToolTipText);
+        //            Assert.AreEqual(RingtoetsCommonFormsResources.FailureMechanism_CreateValidateAllItem_No_calculations_to_validate, validateItem.ToolTipText);
+        //        }
+        //    }
+        //}
+
+        // TODO WTI-819
+        //[Test]
+        //public void ContextMenuStrip_FailureMechanismWithNoSections_ValidateAndCalculateAllDisabled()
+        //{
+        //    // Setup
+        //    using (var treeViewControl = new TreeViewControl())
+        //    {
+        //        var failureMechanism = new WaveImpactAsphaltCoverFailureMechanism();
+        //        var group = new CalculationGroup();
+        //        group.Children.Add(new WaveImpactAsphaltCoverWaveConditionsCalculation());
+        //        failureMechanism.WaveConditionsCalculationGroup.Children.Add(group);
+        //        var assessmentSection = mocks.Stub<IAssessmentSection>();
+        //        var nodeData = new WaveImpactAsphaltCoverWaveConditionsCalculationGroupContext(group,
+        //                                                                                    failureMechanism,
+        //                                                                                    assessmentSection);
+        //        var parentNodeData = new WaveImpactAsphaltCoverWaveConditionsCalculationGroupContext(failureMechanism.WaveConditionsCalculationGroup,
+        //                                                                                          failureMechanism,
+        //                                                                                          assessmentSection);
+
+        //        var menuBuilder = new CustomItemsOnlyContextMenuBuilder();
+
+        //        var gui = mocks.Stub<IGui>();
+        //        gui.Stub(cmp => cmp.Get(nodeData, treeViewControl)).Return(menuBuilder);
+
+        //        mocks.ReplayAll();
+
+        //        plugin.Gui = gui;
+
+        //        // Call
+        //        using (ContextMenuStrip contextMenu = info.ContextMenuStrip(nodeData, parentNodeData, treeViewControl))
+        //        {
+        //            // Assert
+        //            ToolStripItem validateItem = contextMenu.Items[contextMenuValidateAllIndexNestedGroupNoCalculations];
+        //            ToolStripItem calculateItem = contextMenu.Items[contextMenuCalculateAllIndexNestedGroupNoCalculations];
+        //            Assert.IsFalse(validateItem.Enabled);
+        //            Assert.IsFalse(calculateItem.Enabled);
+        //            Assert.AreEqual(RingtoetsCommonFormsResources.Plugin_AllDataAvailable_No_failure_mechanism_sections_imported, calculateItem.ToolTipText);
+        //            Assert.AreEqual(RingtoetsCommonFormsResources.Plugin_AllDataAvailable_No_failure_mechanism_sections_imported, validateItem.ToolTipText);
+        //        }
+        //    }
+        //}
+
+        // TODO WTI-856
+        //[Test]
+        //public void ContextMenuStrip_AssessmentSectionWithoutHydraulicBoundaryDatabase_ValidateAndCalculateAllDisabled()
+        //{
+        //    // Setup
+        //    using (var treeViewControl = new TreeViewControl())
+        //    {
+        //        var failureMechanism = new WaveImpactAsphaltCoverFailureMechanism();
+        //        failureMechanism.AddSection(new FailureMechanismSection("", new[]
+        //        {
+        //            new Point2D(0, 0)
+        //        }));
+        //        var group = new CalculationGroup();
+        //        group.Children.Add(new WaveImpactAsphaltCoverWaveConditionsCalculation());
+        //        failureMechanism.WaveConditionsCalculationGroup.Children.Add(group);
+        //        var assessmentSection = mocks.Stub<IAssessmentSection>();
+        //        var nodeData = new WaveImpactAsphaltCoverWaveConditionsCalculationGroupContext(group,
+        //                                                                                    failureMechanism,
+        //                                                                                    assessmentSection);
+        //        var parentNodeData = new WaveImpactAsphaltCoverWaveConditionsCalculationGroupContext(failureMechanism.WaveConditionsCalculationGroup,
+        //                                                                                          failureMechanism,
+        //                                                                                          assessmentSection);
+
+        //        var menuBuilder = new CustomItemsOnlyContextMenuBuilder();
+
+        //        var gui = mocks.Stub<IGui>();
+        //        gui.Stub(cmp => cmp.Get(nodeData, treeViewControl)).Return(menuBuilder);
+
+        //        mocks.ReplayAll();
+
+        //        plugin.Gui = gui;
+
+        //        // Call
+        //        using (ContextMenuStrip contextMenu = info.ContextMenuStrip(nodeData, parentNodeData, treeViewControl))
+        //        {
+        //            // Assert
+        //            ToolStripItem validateItem = contextMenu.Items[contextMenuValidateAllIndexNestedGroupNoCalculations];
+        //            ToolStripItem calculateItem = contextMenu.Items[contextMenuCalculateAllIndexNestedGroupNoCalculations];
+        //            Assert.IsFalse(validateItem.Enabled);
+        //            Assert.IsFalse(calculateItem.Enabled);
+        //            Assert.AreEqual(RingtoetsCommonFormsResources.Plugin_AllDataAvailable_No_hydraulic_boundary_database_imported, calculateItem.ToolTipText);
+        //            Assert.AreEqual(RingtoetsCommonFormsResources.Plugin_AllDataAvailable_No_hydraulic_boundary_database_imported, validateItem.ToolTipText);
+        //        }
+        //    }
+        //}
+
+        // TODO WTI-856
+        //[Test]
+        //public void ContextMenuStrip_AssessmentSectionWithInvalidHydraulicBoundaryDatabasePath_ValidateAndCalculateAllDisabled()
+        //{
+        //    // Setup
+        //    using (var treeViewControl = new TreeViewControl())
+        //    {
+        //        var failureMechanism = new WaveImpactAsphaltCoverFailureMechanism();
+        //        failureMechanism.AddSection(new FailureMechanismSection("", new[]
+        //        {
+        //            new Point2D(0, 0)
+        //        }));
+        //        var group = new CalculationGroup();
+        //        group.Children.Add(new WaveImpactAsphaltCoverWaveConditionsCalculation());
+        //        failureMechanism.WaveConditionsCalculationGroup.Children.Add(group);
+        //        var assessmentSection = mocks.Stub<IAssessmentSection>();
+        //        assessmentSection.HydraulicBoundaryDatabase = new HydraulicBoundaryDatabase
+        //        {
+        //            FilePath = ""
+        //        };
+        //        var nodeData = new WaveImpactAsphaltCoverWaveConditionsCalculationGroupContext(group,
+        //                                                                                    failureMechanism,
+        //                                                                                    assessmentSection);
+        //        var parentNodeData = new WaveImpactAsphaltCoverWaveConditionsCalculationGroupContext(failureMechanism.WaveConditionsCalculationGroup,
+        //                                                                                          failureMechanism,
+        //                                                                                          assessmentSection);
+
+        //        var menuBuilder = new CustomItemsOnlyContextMenuBuilder();
+
+        //        var gui = mocks.Stub<IGui>();
+        //        gui.Stub(cmp => cmp.Get(nodeData, treeViewControl)).Return(menuBuilder);
+
+        //        mocks.ReplayAll();
+
+        //        plugin.Gui = gui;
+
+        //        // Call
+        //        using (ContextMenuStrip contextMenu = info.ContextMenuStrip(nodeData, parentNodeData, treeViewControl))
+        //        {
+        //            // Assert
+        //            ToolStripItem validateItem = contextMenu.Items[contextMenuValidateAllIndexNestedGroupNoCalculations];
+        //            ToolStripItem calculateItem = contextMenu.Items[contextMenuCalculateAllIndexNestedGroupNoCalculations];
+        //            Assert.IsFalse(validateItem.Enabled);
+        //            Assert.IsFalse(calculateItem.Enabled);
+        //            var message = "Herstellen van de verbinding met de hydraulische randvoorwaardendatabase is mislukt. Fout bij het lezen van bestand '': Bestandspad mag niet leeg of ongedefinieerd zijn.";
+        //            Assert.AreEqual(message, calculateItem.ToolTipText);
+        //            Assert.AreEqual(message, validateItem.ToolTipText);
+        //        }
+        //    }
+        //}
+
+        // TODO WTI-856
+        //[Test]
+        //public void ContextMenuStrip_TwoCalculationsClickOnValidateAllInGroup_ValidationMessagesLogged()
+        //{
+        //    string hrdPath = TestHelper.GetTestDataPath(TestDataPath.Ringtoets.Integration.Service, "HydraRingCalculation");
+
+        //    var assessmentSection = mocks.Stub<IAssessmentSection>();
+        //    assessmentSection.HydraulicBoundaryDatabase = new HydraulicBoundaryDatabase
+        //    {
+        //        FilePath = Path.Combine(hrdPath, "HRD ijsselmeer.sqlite")
+        //    };
+        //    assessmentSection.Stub(a => a.FailureMechanismContribution).Return(
+        //        new FailureMechanismContribution(Enumerable.Empty<IFailureMechanism>(), 30, 2));
+
+        //    var group = new CalculationGroup();
+        //    group.Children.Add(new WaveImpactAsphaltCoverWaveConditionsCalculation());
+        //    group.Children.Add(new WaveImpactAsphaltCoverWaveConditionsCalculation());
+
+        //    var failureMechanism = new WaveImpactAsphaltCoverFailureMechanism();
+        //    failureMechanism.AddSection(new FailureMechanismSection("", new[]
+        //    {
+        //        new Point2D(0, 0)
+        //    }));
+        //    failureMechanism.WaveConditionsCalculationGroup.Children.Add(group);
+        //    var nodeData = new WaveImpactAsphaltCoverWaveConditionsCalculationGroupContext(group,
+        //                                                                                failureMechanism,
+        //                                                                                assessmentSection);
+        //    var parentNodeData = new WaveImpactAsphaltCoverWaveConditionsCalculationGroupContext(failureMechanism.WaveConditionsCalculationGroup,
+        //                                                                                      failureMechanism,
+        //                                                                                      assessmentSection);
+
+        //    var menuBuilder = new CustomItemsOnlyContextMenuBuilder();
+
+        //    // Setup
+        //    using (var treeViewControl = new TreeViewControl())
+        //    {
+        //        var gui = mocks.Stub<IGui>();
+        //        gui.Stub(cmp => cmp.Get(nodeData, treeViewControl)).Return(menuBuilder);
+
+        //        mocks.ReplayAll();
+
+        //        plugin.Gui = gui;
+
+        //        using (ContextMenuStrip contextMenu = info.ContextMenuStrip(nodeData, parentNodeData, treeViewControl))
+        //        {
+        //            // Call
+        //            Action test = () => contextMenu.Items[4].PerformClick();
+
+        //            // Assert
+        //            TestHelper.AssertLogMessages(test, m =>
+        //            {
+        //                var messages = m.ToArray();
+        //                Assert.AreEqual(4, messages.Length);
+        //                StringAssert.StartsWith("Validatie van 'Nieuwe berekening' gestart om: ", messages[0]);
+        //                StringAssert.StartsWith("Validatie van 'Nieuwe berekening' beëindigd om: ", messages[1]);
+        //                StringAssert.StartsWith("Validatie van 'Nieuwe berekening' gestart om: ", messages[2]);
+        //                StringAssert.StartsWith("Validatie van 'Nieuwe berekening' beëindigd om: ", messages[3]);
+        //            });
+        //        }
+        //    }
+        //}
+
+        // TODO WTI-808
+        //[Test]
+        //public void ContextMenuStrip_TwoCalculationsClickOnCalculateAllInGroup_MessagesLogged()
+        //{
+        //    string hrdPath = TestHelper.GetTestDataPath(TestDataPath.Ringtoets.Integration.Service, "HydraRingCalculation");
+
+        //    var assessmentSection = mocks.Stub<IAssessmentSection>();
+        //    assessmentSection.HydraulicBoundaryDatabase = new HydraulicBoundaryDatabase
+        //    {
+        //        FilePath = Path.Combine(hrdPath, "HRD ijsselmeer.sqlite")
+        //    };
+        //    assessmentSection.Stub(a => a.FailureMechanismContribution).Return(
+        //        new FailureMechanismContribution(Enumerable.Empty<IFailureMechanism>(), 30, 2));
+        //    assessmentSection.Stub(a => a.Id).Return("someId");
+
+        //    var observerA = mocks.StrictMock<IObserver>();
+        //    observerA.Expect(o => o.UpdateObserver());
+        //    var observerB = mocks.StrictMock<IObserver>();
+        //    observerB.Expect(o => o.UpdateObserver());
+
+        //    var group = new CalculationGroup();
+        //    var calculationA = GetValidCalculation();
+        //    var calculationB = GetValidCalculation();
+        //    calculationA.Attach(observerA);
+        //    calculationB.Attach(observerB);
+        //    group.Children.Add(calculationA);
+        //    group.Children.Add(calculationB);
+
+        //    var failureMechanism = new WaveImpactAsphaltCoverFailureMechanism();
+        //    failureMechanism.AddSection(new FailureMechanismSection("", new[]
+        //    {
+        //        new Point2D(0, 0)
+        //    }));
+        //    failureMechanism.WaveConditionsCalculationGroup.Children.Add(group);
+        //    var nodeData = new WaveImpactAsphaltCoverWaveConditionsCalculationGroupContext(group,
+        //                                                                                failureMechanism,
+        //                                                                                assessmentSection);
+        //    var parentNodeData = new WaveImpactAsphaltCoverWaveConditionsCalculationGroupContext(failureMechanism.WaveConditionsCalculationGroup,
+        //                                                                                      failureMechanism,
+        //                                                                                      assessmentSection);
+
+        //    var menuBuilder = new CustomItemsOnlyContextMenuBuilder();
+
+        //    DialogBoxHandler = (name, wnd) =>
+        //    {
+        //        // Expect an activity dialog which is automatically closed
+        //    };
+
+        //    // Setup
+        //    using (var treeViewControl = new TreeViewControl())
+        //    {
+        //        var mainWindow = mocks.Stub<IMainWindow>();
+
+        //        var gui = mocks.Stub<IGui>();
+        //        gui.Stub(cmp => cmp.Get(nodeData, treeViewControl)).Return(menuBuilder);
+        //        gui.Stub(g => g.MainWindow).Return(mainWindow);
+
+        //        mocks.ReplayAll();
+
+        //        plugin.Gui = gui;
+
+        //        using (new HydraRingCalculationServiceConfig())
+        //        using (new WaveConditionsCalculationServiceConfig())
+        //        using (ContextMenuStrip contextMenu = info.ContextMenuStrip(nodeData, parentNodeData, treeViewControl))
+        //        {
+        //            // Call
+        //            Action test = () => contextMenu.Items[5].PerformClick();
+
+        //            // Assert
+        //            TestHelper.AssertLogMessages(test, m =>
+        //            {
+        //                var messages = m.ToArray();
+        //                Assert.AreEqual(30, messages.Length);
+        //                StringAssert.StartsWith("Berekening van 'Nieuwe berekening' gestart om: ", messages[0]);
+        //                StringAssert.StartsWith("Berekening van 'Nieuwe berekening' beëindigd om: ", messages[13]);
+        //                StringAssert.StartsWith("Berekening van 'Nieuwe berekening' gestart om: ", messages[14]);
+        //                StringAssert.StartsWith("Berekening van 'Nieuwe berekening' beëindigd om: ", messages[27]);
+        //                Assert.AreEqual("Uitvoeren van 'Nieuwe berekening' is gelukt.", messages[28]);
+        //                Assert.AreEqual("Uitvoeren van 'Nieuwe berekening' is gelukt.", messages[29]);
+        //            });
+        //        }
+        //    }
+        //}
+
+        // TODO WTI-808
+        //[Test]
+        //public void ContextMenuStrip_NoCalculations_ClearAllOutputItemDisabled()
+        //{
+        //    string hrdPath = TestHelper.GetTestDataPath(TestDataPath.Ringtoets.Integration.Service, "HydraRingCalculation");
+
+        //    var assessmentSection = mocks.Stub<IAssessmentSection>();
+        //    assessmentSection.HydraulicBoundaryDatabase = new HydraulicBoundaryDatabase
+        //    {
+        //        FilePath = Path.Combine(hrdPath, "HRD ijsselmeer.sqlite")
+        //    };
+        //    assessmentSection.Stub(a => a.FailureMechanismContribution).Return(
+        //        new FailureMechanismContribution(Enumerable.Empty<IFailureMechanism>(), 30, 2));
+        //    assessmentSection.Stub(a => a.Id).Return("someId");
+
+        //    var group = new CalculationGroup();
+
+        //    var failureMechanism = new WaveImpactAsphaltCoverFailureMechanism();
+        //    failureMechanism.AddSection(new FailureMechanismSection("", new[]
+        //    {
+        //        new Point2D(0, 0)
+        //    }));
+        //    failureMechanism.WaveConditionsCalculationGroup.Children.Add(group);
+        //    var nodeData = new WaveImpactAsphaltCoverWaveConditionsCalculationGroupContext(group,
+        //                                                                                failureMechanism,
+        //                                                                                assessmentSection);
+        //    var parentNodeData = new WaveImpactAsphaltCoverWaveConditionsCalculationGroupContext(failureMechanism.WaveConditionsCalculationGroup,
+        //                                                                                      failureMechanism,
+        //                                                                                      assessmentSection);
+
+        //    var menuBuilder = new CustomItemsOnlyContextMenuBuilder();
+
+        //    // Setup
+        //    using (var treeViewControl = new TreeViewControl())
+        //    {
+        //        var mainWindow = mocks.Stub<IMainWindow>();
+
+        //        var gui = mocks.Stub<IGui>();
+        //        gui.Stub(cmp => cmp.Get(nodeData, treeViewControl)).Return(menuBuilder);
+        //        gui.Stub(g => g.MainWindow).Return(mainWindow);
+
+        //        mocks.ReplayAll();
+
+        //        plugin.Gui = gui;
+
+        //        using (new HydraRingCalculationServiceConfig())
+        //        using (new WaveConditionsCalculationServiceConfig())
+        //        using (ContextMenuStrip contextMenu = info.ContextMenuStrip(nodeData, parentNodeData, treeViewControl))
+        //        {
+        //            // Call
+        //            var clearAllOutputItem = contextMenu.Items[5];
+
+        //            // Assert
+        //            Assert.IsFalse(clearAllOutputItem.Enabled);
+        //        }
+        //    }
+        //}
+
+        // TODO WTI-819
+        //[Test]
+        //public void ContextMenuStrip_TwoCalculationsWithoutOutput_ClearAllOutputItemDisabled()
+        //{
+        //    string hrdPath = TestHelper.GetTestDataPath(TestDataPath.Ringtoets.Integration.Service, "HydraRingCalculation");
+
+        //    var assessmentSection = mocks.Stub<IAssessmentSection>();
+        //    assessmentSection.HydraulicBoundaryDatabase = new HydraulicBoundaryDatabase
+        //    {
+        //        FilePath = Path.Combine(hrdPath, "HRD ijsselmeer.sqlite")
+        //    };
+        //    assessmentSection.Stub(a => a.FailureMechanismContribution).Return(
+        //        new FailureMechanismContribution(Enumerable.Empty<IFailureMechanism>(), 30, 2));
+        //    assessmentSection.Stub(a => a.Id).Return("someId");
+
+        //    var group = new CalculationGroup();
+        //    var calculationA = GetValidCalculation();
+        //    var calculationB = GetValidCalculation();
+        //    group.Children.Add(calculationA);
+        //    group.Children.Add(calculationB);
+
+        //    var failureMechanism = new WaveImpactAsphaltCoverFailureMechanism();
+        //    failureMechanism.AddSection(new FailureMechanismSection("", new[]
+        //    {
+        //        new Point2D(0, 0)
+        //    }));
+        //    failureMechanism.WaveConditionsCalculationGroup.Children.Add(group);
+        //    var nodeData = new WaveImpactAsphaltCoverWaveConditionsCalculationGroupContext(group,
+        //                                                                                failureMechanism,
+        //                                                                                assessmentSection);
+        //    var parentNodeData = new WaveImpactAsphaltCoverWaveConditionsCalculationGroupContext(failureMechanism.WaveConditionsCalculationGroup,
+        //                                                                                      failureMechanism,
+        //                                                                                      assessmentSection);
+
+        //    var menuBuilder = new CustomItemsOnlyContextMenuBuilder();
+
+        //    // Setup
+        //    using (var treeViewControl = new TreeViewControl())
+        //    {
+        //        var mainWindow = mocks.Stub<IMainWindow>();
+
+        //        var gui = mocks.Stub<IGui>();
+        //        gui.Stub(cmp => cmp.Get(nodeData, treeViewControl)).Return(menuBuilder);
+        //        gui.Stub(g => g.MainWindow).Return(mainWindow);
+
+        //        mocks.ReplayAll();
+
+        //        plugin.Gui = gui;
+
+        //        using (new HydraRingCalculationServiceConfig())
+        //        using (new WaveConditionsCalculationServiceConfig())
+        //        using (ContextMenuStrip contextMenu = info.ContextMenuStrip(nodeData, parentNodeData, treeViewControl))
+        //        {
+        //            // Call
+        //            var clearAllOutputItem = contextMenu.Items[6];
+
+        //            // Assert
+        //            Assert.IsFalse(clearAllOutputItem.Enabled);
+        //        }
+        //    }
+        //}
+
+        // TODO WTI-819
+        //[Test]
+        //[TestCase(true)]
+        //[TestCase(false)]
+        //public void ContextMenuStrip_TwoCalculationsWithOutputClickOnClearAllOutput_OutputRemovedForCalculationsAfterConfirmation(bool confirm)
+        //{
+        //    string hrdPath = TestHelper.GetTestDataPath(TestDataPath.Ringtoets.Integration.Service, "HydraRingCalculation");
+
+        //    var assessmentSection = mocks.Stub<IAssessmentSection>();
+        //    assessmentSection.HydraulicBoundaryDatabase = new HydraulicBoundaryDatabase
+        //    {
+        //        FilePath = Path.Combine(hrdPath, "HRD ijsselmeer.sqlite")
+        //    };
+        //    assessmentSection.Stub(a => a.FailureMechanismContribution).Return(
+        //        new FailureMechanismContribution(Enumerable.Empty<IFailureMechanism>(), 30, 2));
+        //    assessmentSection.Stub(a => a.Id).Return("someId");
+
+        //    var observerA = mocks.StrictMock<IObserver>();
+        //    var observerB = mocks.StrictMock<IObserver>();
+        //    if (confirm)
+        //    {
+        //        observerA.Expect(o => o.UpdateObserver());
+        //        observerB.Expect(o => o.UpdateObserver());
+        //    }
+
+        //    var group = new CalculationGroup();
+        //    var calculationA = GetValidCalculation();
+        //    calculationA.Output = new WaveImpactAsphaltCoverWaveConditionsOutput(Enumerable.Empty<WaveConditionsOutput>());
+        //    var calculationB = GetValidCalculation();
+        //    calculationB.Output = new WaveImpactAsphaltCoverWaveConditionsOutput(Enumerable.Empty<WaveConditionsOutput>());
+        //    group.Children.Add(calculationA);
+        //    group.Children.Add(calculationB);
+        //    calculationA.Attach(observerA);
+        //    calculationB.Attach(observerB);
+
+        //    var failureMechanism = new WaveImpactAsphaltCoverFailureMechanism();
+        //    failureMechanism.AddSection(new FailureMechanismSection("", new[]
+        //    {
+        //        new Point2D(0, 0)
+        //    }));
+        //    failureMechanism.WaveConditionsCalculationGroup.Children.Add(group);
+        //    var nodeData = new WaveImpactAsphaltCoverWaveConditionsCalculationGroupContext(group,
+        //                                                                                failureMechanism,
+        //                                                                                assessmentSection);
+        //    var parentNodeData = new WaveImpactAsphaltCoverWaveConditionsCalculationGroupContext(failureMechanism.WaveConditionsCalculationGroup,
+        //                                                                                      failureMechanism,
+        //                                                                                      assessmentSection);
+
+        //    var menuBuilder = new CustomItemsOnlyContextMenuBuilder();
+
+        //    DialogBoxHandler = (name, wnd) =>
+        //    {
+        //        var dialog = new MessageBoxTester(wnd);
+        //        if (confirm)
+        //        {
+        //            dialog.ClickOk();
+        //        }
+        //        else
+        //        {
+        //            dialog.ClickCancel();
+        //        }
+        //    };
+
+        //    // Setup
+        //    using (var treeViewControl = new TreeViewControl())
+        //    {
+        //        var mainWindow = mocks.Stub<IMainWindow>();
+
+        //        var gui = mocks.Stub<IGui>();
+        //        gui.Stub(cmp => cmp.Get(nodeData, treeViewControl)).Return(menuBuilder);
+        //        gui.Stub(g => g.MainWindow).Return(mainWindow);
+
+        //        mocks.ReplayAll();
+
+        //        plugin.Gui = gui;
+
+        //        using (new HydraRingCalculationServiceConfig())
+        //        using (new WaveConditionsCalculationServiceConfig())
+        //        using (ContextMenuStrip contextMenu = info.ContextMenuStrip(nodeData, parentNodeData, treeViewControl))
+        //        {
+        //            // Call
+        //            contextMenu.Items[6].PerformClick();
+
+        //            // Assert
+        //            if (confirm)
+        //            {
+        //                Assert.IsNull(calculationA.Output);
+        //                Assert.IsNull(calculationB.Output);
+        //            }
+        //        }
+        //    }
+        //}
+
+        // TODO WTI-819
+        //[Test]
+        //public void ContextMenuStrip_WithoutParentNodeWithNoChildren_RemoveAllChildrenDisabled()
+        //{
+        //    // Setup
+        //    using (var treeViewControl = new TreeViewControl())
+        //    {
+        //        var assessmentSection = mocks.Stub<IAssessmentSection>();
+
+        //        var failureMechanism = new WaveImpactAsphaltCoverFailureMechanism();
+        //        var nodeData = new WaveImpactAsphaltCoverWaveConditionsCalculationGroupContext(failureMechanism.WaveConditionsCalculationGroup,
+        //                                                                                    failureMechanism,
+        //                                                                                    assessmentSection);
+
+        //        var menuBuilder = new CustomItemsOnlyContextMenuBuilder();
+
+        //        var gui = mocks.Stub<IGui>();
+        //        gui.Stub(cmp => cmp.Get(nodeData, treeViewControl)).Return(menuBuilder);
+        //        gui.Stub(cmp => cmp.ViewCommands).Return(mocks.Stub<IViewCommands>());
+
+        //        mocks.ReplayAll();
+
+        //        plugin.Gui = gui;
+
+        //        // Call
+        //        using (ContextMenuStrip contextMenu = info.ContextMenuStrip(nodeData, null, treeViewControl))
+        //        {
+        //            // Assert
+        //            ToolStripItem removeAllItemDisabled = contextMenu.Items[customOnlyContextMenuRemoveAllChildrenIndex];
+        //            Assert.IsFalse(removeAllItemDisabled.Enabled);
+        //            Assert.AreEqual(RingtoetsCommonFormsResources.CalculationGroup_RemoveAllChildrenFromGroup_No_Calculation_or_Group_to_remove, removeAllItemDisabled.ToolTipText);
+        //        }
+        //    }
+        //}
+
+        // TODO WTI-819
+        //[Test]
+        //public void ContextMenuStrip_WithoutParentNodeWithChildren_RemoveAllChildrenEnabled()
+        //{
+        //    // Setup
+        //    using (var treeViewControl = new TreeViewControl())
+        //    {
+        //        var assessmentSection = mocks.Stub<IAssessmentSection>();
+        //        var failureMechanism = new WaveImpactAsphaltCoverFailureMechanism();
+        //        failureMechanism.WaveConditionsCalculationGroup.Children.Add(mocks.Stub<ICalculation>());
+        //        var nodeData = new WaveImpactAsphaltCoverWaveConditionsCalculationGroupContext(failureMechanism.WaveConditionsCalculationGroup,
+        //                                                                                    failureMechanism,
+        //                                                                                    assessmentSection);
+
+        //        var menuBuilder = new CustomItemsOnlyContextMenuBuilder();
+
+        //        var gui = mocks.Stub<IGui>();
+        //        gui.Stub(cmp => cmp.Get(nodeData, treeViewControl)).Return(menuBuilder);
+        //        gui.Stub(cmp => cmp.ViewCommands).Return(mocks.Stub<IViewCommands>());
+
+        //        mocks.ReplayAll();
+
+        //        plugin.Gui = gui;
+
+        //        // Call
+        //        using (ContextMenuStrip contextMenu = info.ContextMenuStrip(nodeData, null, treeViewControl))
+        //        {
+        //            // Assert
+        //            ToolStripItem removeAllItemEnabled = contextMenu.Items[customOnlyContextMenuRemoveAllChildrenIndex];
+        //            Assert.IsTrue(removeAllItemEnabled.Enabled);
+        //            Assert.AreEqual(RingtoetsCommonFormsResources.CalculationGroup_RemoveAllChildrenFromGroup_Remove_all_Tooltip, removeAllItemEnabled.ToolTipText);
+        //        }
+        //    }
+        //}
+
+        [Test]
+        public void ContextMenuStrip_ClickOnAddGroupItem_AddGroupToCalculationGroupAndNotifyObservers()
+        {
+            // Setup
+            using (var treeViewControl = new TreeViewControl())
+            {
+                var assessmentSection = mocks.Stub<IAssessmentSection>();
+
+                var group = new CalculationGroup();
+                var failureMechanism = new WaveImpactAsphaltCoverFailureMechanism();
+                failureMechanism.WaveConditionsCalculationGroup.Children.Add(group);
+
+                var nodeData = new WaveImpactAsphaltCoverWaveConditionsCalculationGroupContext(group,
+                                                                                            failureMechanism,
+                                                                                            assessmentSection);
+                var parentNodeData = new WaveImpactAsphaltCoverWaveConditionsCalculationGroupContext(failureMechanism.WaveConditionsCalculationGroup,
+                                                                                                  failureMechanism,
+                                                                                                  assessmentSection);
+
+                var menuBuilder = new CustomItemsOnlyContextMenuBuilder();
+
+                var gui = mocks.Stub<IGui>();
+                gui.Stub(cmp => cmp.Get(nodeData, treeViewControl)).Return(menuBuilder);
+
+                var observer = mocks.StrictMock<IObserver>();
+                observer.Expect(o => o.UpdateObserver());
+                mocks.ReplayAll();
+
+                plugin.Gui = gui;
+
+                var calculationItem = new CalculationGroup
+                {
+                    Name = "Nieuwe map"
+                };
+                group.Children.Add(calculationItem);
+
+                nodeData.Attach(observer);
+
+                using (ContextMenuStrip contextMenu = info.ContextMenuStrip(nodeData, parentNodeData, treeViewControl))
+                {
+                    // Precondition
+                    Assert.AreEqual(1, group.Children.Count);
+
+                    // Call
+                    contextMenu.Items[1].PerformClick();
+
+                    // Assert
+                    Assert.AreEqual(2, group.Children.Count);
+                    var newlyAddedItem = group.Children.Last();
+                    Assert.IsInstanceOf<CalculationGroup>(newlyAddedItem);
+                    Assert.AreEqual("Nieuwe map (1)", newlyAddedItem.Name,
+                                    "An item with the same name default name already exists, therefore '(1)' needs to be appended.");
+                }
+            }
+        }
+
+        // TODO WTI-819
+        //[Test]
+        //public void ContextMenuStrip_ClickOnRemoveAllInGroupAndConfirm_RemovesAllChildren()
+        //{
+        //    // Setup
+        //    using (var treeViewControl = new TreeViewControl())
+        //    {
+        //        var assessmentSection = mocks.Stub<IAssessmentSection>();
+        //        var calculation = mocks.Stub<ICalculation>();
+        //        var failureMechanism = new WaveImpactAsphaltCoverFailureMechanism();
+        //        failureMechanism.WaveConditionsCalculationGroup.Children.Add(calculation);
+        //        var nodeData = new WaveImpactAsphaltCoverWaveConditionsCalculationGroupContext(failureMechanism.WaveConditionsCalculationGroup,
+        //                                                                                    failureMechanism,
+        //                                                                                    assessmentSection);
+
+        //        var menuBuilder = new CustomItemsOnlyContextMenuBuilder();
+        //        var viewCommandsMock = mocks.StrictMock<IViewCommands>();
+        //        viewCommandsMock.Expect(vc => vc.RemoveAllViewsForItem(calculation));
+
+        //        var observer = mocks.StrictMock<IObserver>();
+        //        observer.Expect(o => o.UpdateObserver());
+        //        failureMechanism.WaveConditionsCalculationGroup.Attach(observer);
+
+        //        var gui = mocks.Stub<IGui>();
+        //        gui.Stub(cmp => cmp.Get(nodeData, treeViewControl)).Return(menuBuilder);
+        //        gui.Stub(cmp => cmp.ViewCommands).Return(viewCommandsMock);
+
+        //        mocks.ReplayAll();
+
+        //        plugin.Gui = gui;
+
+        //        DialogBoxHandler = (name, wnd) =>
+        //        {
+        //            var dialog = new MessageBoxTester(wnd);
+        //            dialog.ClickOk();
+        //        };
+
+        //        using (ContextMenuStrip contextMenu = info.ContextMenuStrip(nodeData, null, treeViewControl))
+        //        {
+        //            // Call
+        //            contextMenu.Items[contextMenuRemoveAllInGroup].PerformClick();
+
+        //            // Assert
+        //            Assert.IsEmpty(failureMechanism.WaveConditionsCalculationGroup.Children);
+        //        }
+        //    }
+        //}
+
+        // TODO WTI-819
+        //[Test]
+        //public void ContextMenuStrip_ClickOnRemoveAllInGroupAndCancel_ChildrenNotRemoved()
+        //{
+        //    // Setup
+        //    using (var treeViewControl = new TreeViewControl())
+        //    {
+        //        var assessmentSection = mocks.Stub<IAssessmentSection>();
+        //        var calculation = mocks.Stub<ICalculation>();
+        //        var failureMechanism = new WaveImpactAsphaltCoverFailureMechanism();
+        //        failureMechanism.WaveConditionsCalculationGroup.Children.Add(calculation);
+        //        var nodeData = new WaveImpactAsphaltCoverWaveConditionsCalculationGroupContext(failureMechanism.WaveConditionsCalculationGroup,
+        //                                                                                    failureMechanism,
+        //                                                                                    assessmentSection);
+
+        //        var menuBuilder = new CustomItemsOnlyContextMenuBuilder();
+        //        var viewCommandsMock = mocks.StrictMock<IViewCommands>();
+
+        //        var gui = mocks.Stub<IGui>();
+        //        gui.Stub(cmp => cmp.Get(nodeData, treeViewControl)).Return(menuBuilder);
+        //        gui.Stub(cmp => cmp.ViewCommands).Return(viewCommandsMock);
+
+        //        mocks.ReplayAll();
+
+        //        plugin.Gui = gui;
+
+        //        DialogBoxHandler = (name, wnd) =>
+        //        {
+        //            var dialog = new MessageBoxTester(wnd);
+        //            dialog.ClickCancel();
+        //        };
+
+        //        using (ContextMenuStrip contextMenu = info.ContextMenuStrip(nodeData, null, treeViewControl))
+        //        {
+        //            // Call
+        //            contextMenu.Items[contextMenuRemoveAllInGroup].PerformClick();
+
+        //            // Assert
+        //            Assert.AreEqual(new[]
+        //            {
+        //                calculation
+        //            }, failureMechanism.WaveConditionsCalculationGroup.Children);
+        //        }
+        //    }
+        //}
+
+        // TODO WTI-808
+        //[Test]
+        //public void GivenDialogGenerateCalculationButtonClicked_WhenCalculationSelectedAndDialogClosed_ThenUpdateCalculationGroup()
+        //{
+        //    // Given
+        //    using (var treeViewControl = new TreeViewControl())
+        //    {
+        //        var group = new CalculationGroup();
+        //        var failureMechanism = new WaveImpactAsphaltCoverFailureMechanism();
+        //        var assessmentSection = mocks.Stub<IAssessmentSection>();
+        //        assessmentSection.HydraulicBoundaryDatabase = new HydraulicBoundaryDatabase
+        //        {
+        //            Locations =
+        //            {
+        //                new HydraulicBoundaryLocation(1, "1", 1, 1),
+        //                new HydraulicBoundaryLocation(2, "2", 2, 2)
+        //            }
+        //        };
+
+        //        var observerMock = mocks.StrictMock<IObserver>();
+        //        observerMock.Expect(o => o.UpdateObserver());
+        //        var nodeData = new WaveImpactAsphaltCoverWaveConditionsCalculationGroupContext(group,
+        //                                                                                    failureMechanism,
+        //                                                                                    assessmentSection);
+
+        //        var menuBuilder = new CustomItemsOnlyContextMenuBuilder();
+        //        var mainWindow = mocks.Stub<IMainWindow>();
+        //        var viewCommandsMock = mocks.StrictMock<IViewCommands>();
+
+        //        var gui = mocks.Stub<IGui>();
+        //        gui.Stub(cmp => cmp.Get(nodeData, treeViewControl)).Return(menuBuilder);
+        //        gui.Expect(cmp => cmp.MainWindow).Return(mainWindow);
+        //        gui.Stub(cmp => cmp.ViewCommands).Return(viewCommandsMock);
+
+        //        mocks.ReplayAll();
+
+        //        plugin.Gui = gui;
+        //        nodeData.Attach(observerMock);
+
+        //        WaveImpactAsphaltCoverHydraulicBoundaryLocationSelectionDialog dialog = null;
+        //        DataGridViewControl grid = null;
+        //        DialogBoxHandler = (name, wnd) =>
+        //        {
+        //            dialog = (WaveImpactAsphaltCoverHydraulicBoundaryLocationSelectionDialog)new FormTester(name).TheObject;
+        //            grid = (DataGridViewControl)new ControlTester("DataGridViewControl", dialog).TheObject;
+        //            grid.Rows[0].Cells[0].Value = true;
+        //            grid.Rows[1].Cells[0].Value = true;
+        //            new ButtonTester("DoForSelectedButton", dialog).Click();
+        //        };
+
+        //        // When
+        //        using (ContextMenuStrip contextMenu = info.ContextMenuStrip(nodeData, null, treeViewControl))
+        //        {
+        //            contextMenu.Items[customOnlyContextMenuAddGenerateCalculationsIndex].PerformClick();
+        //        }
+
+        //        // Then
+        //        Assert.AreEqual(2, group.Children.Count);
+        //        Assert.NotNull(dialog);
+        //        Assert.NotNull(grid);
+        //    }
+        //}
+
+        // TODO WTI-819
+        //[Test]
+        //public void GivenDialogGenerateCalculationButtonClicked_WhenCancelButtonClickedAndDialogClosed_ThenCalculationGroupNotUpdated()
+        //{
+        //    // Given
+        //    using (var treeViewControl = new TreeViewControl())
+        //    {
+        //        var group = new CalculationGroup();
+        //        var failureMechanism = new WaveImpactAsphaltCoverFailureMechanism();
+        //        var assessmentSectionMock = mocks.Stub<IAssessmentSection>();
+        //        assessmentSectionMock.HydraulicBoundaryDatabase = new HydraulicBoundaryDatabase
+        //        {
+        //            Locations =
+        //            {
+        //                new HydraulicBoundaryLocation(1, "1", 1, 1)
+        //            }
+        //        };
+
+        //        var observerMock = mocks.StrictMock<IObserver>();
+        //        var nodeData = new WaveImpactAsphaltCoverWaveConditionsCalculationGroupContext(group,
+        //                                                                                    failureMechanism,
+        //                                                                                    assessmentSectionMock);
+
+        //        var menuBuilder = new CustomItemsOnlyContextMenuBuilder();
+        //        var mainWindow = mocks.Stub<IMainWindow>();
+        //        var viewCommandsMock = mocks.StrictMock<IViewCommands>();
+
+        //        var gui = mocks.Stub<IGui>();
+        //        gui.Stub(cmp => cmp.Get(nodeData, treeViewControl)).Return(menuBuilder);
+        //        gui.Expect(cmp => cmp.MainWindow).Return(mainWindow);
+        //        gui.Stub(cmp => cmp.ViewCommands).Return(viewCommandsMock);
+
+        //        mocks.ReplayAll();
+
+        //        plugin.Gui = gui;
+        //        nodeData.Attach(observerMock);
+
+        //        WaveImpactAsphaltCoverHydraulicBoundaryLocationSelectionDialog dialog = null;
+        //        DataGridViewControl grid = null;
+        //        DialogBoxHandler = (name, wnd) =>
+        //        {
+        //            dialog = (WaveImpactAsphaltCoverHydraulicBoundaryLocationSelectionDialog)new FormTester(name).TheObject;
+        //            grid = (DataGridViewControl)new ControlTester("DataGridViewControl", dialog).TheObject;
+        //            grid.Rows[0].Cells[0].Value = true;
+        //            new ButtonTester("CustomCancelButton", dialog).Click();
+        //        };
+
+        //        // When
+        //        using (ContextMenuStrip contextMenu = info.ContextMenuStrip(nodeData, null, treeViewControl))
+        //        {
+        //            contextMenu.Items[customOnlyContextMenuAddGenerateCalculationsIndex].PerformClick();
+        //        }
+
+        //        // Then
+        //        Assert.AreEqual(0, group.Children.Count);
+        //        Assert.NotNull(dialog);
+        //        Assert.NotNull(grid);
+        //    }
+        //}
+
+        [Test]
+        public void OnNodeRemoved_ParentIsWaveConditionsCalculationGroupContainingGroup_RemoveGroupAndNotifyObservers()
+        {
+            // Setup
+            var observer = mocks.StrictMock<IObserver>();
+            observer.Expect(o => o.UpdateObserver());
+
+            var assessmentSection = mocks.Stub<IAssessmentSection>();
+            mocks.ReplayAll();
+
+            var group = new CalculationGroup();
+            var failureMechanism = new WaveImpactAsphaltCoverFailureMechanism();
+
+            var nodeData = new WaveImpactAsphaltCoverWaveConditionsCalculationGroupContext(group,
+                                                                                        failureMechanism,
+                                                                                        assessmentSection);
+
+            failureMechanism.WaveConditionsCalculationGroup.Children.Add(group);
+            var parentNodeData = new WaveImpactAsphaltCoverWaveConditionsCalculationGroupContext(failureMechanism.WaveConditionsCalculationGroup,
+                                                                                              failureMechanism,
+                                                                                              assessmentSection);
+            parentNodeData.Attach(observer);
+
+            // Precondition
+            Assert.IsTrue(info.CanRemove(nodeData, parentNodeData));
+
+            // Call
+            info.OnNodeRemoved(nodeData, parentNodeData);
+
+            // Assert
+            CollectionAssert.DoesNotContain(failureMechanism.WaveConditionsCalculationGroup.Children, group);
+        }
+
+        // TODO WTI-819
+        //[Test]
+        //public void GivenCalculationWithoutOutput_ThenClearOutputItemDisabled()
+        //{
+        //    // Given
+        //    var failureMechanism = new WaveImpactAsphaltCoverFailureMechanism();
+        //    var assessmentSection = mocks.Stub<IAssessmentSection>();
+
+        //    var context = new WaveImpactAsphaltCoverWaveConditionsCalculationGroupContext(failureMechanism.WaveConditionsCalculationGroup,
+        //                                                                               failureMechanism,
+        //                                                                               assessmentSection);
+
+        //    using (var treeViewControl = new TreeViewControl())
+        //    {
+        //        var appFeatureCommandHandler = mocks.Stub<IApplicationFeatureCommands>();
+        //        var importHandler = mocks.Stub<IImportCommandHandler>();
+        //        var exportHandler = mocks.Stub<IExportCommandHandler>();
+        //        var viewCommands = mocks.Stub<IViewCommands>();
+        //        var menuBuilderMock = new ContextMenuBuilder(appFeatureCommandHandler,
+        //                                                     importHandler,
+        //                                                     exportHandler,
+        //                                                     viewCommands,
+        //                                                     context,
+        //                                                     treeViewControl);
+
+        //        var gui = mocks.Stub<IGui>();
+        //        gui.Stub(g => g.ViewCommands).Return(viewCommands);
+        //        gui.Stub(g => g.Get(context, treeViewControl)).Return(menuBuilderMock);
+
+        //        mocks.ReplayAll();
+
+        //        plugin.Gui = gui;
+
+        //        // When
+        //        using (ContextMenuStrip contextMenu = info.ContextMenuStrip(context, null, treeViewControl))
+        //        {
+        //            // Then
+        //            TestHelper.AssertContextMenuStripContainsItem(contextMenu,
+        //                                                          contextMenuAddCalculationIndexRootGroup,
+        //                                                          "Berekening &toevoegen",
+        //                                                          "Voeg een nieuwe berekening toe aan deze berekeningsmap.",
+        //                                                          RingtoetsCommonFormsResources.FailureMechanismIcon);
+        //        }
+        //    }
+        //}
+
+        // TODO WTI-819
+        //[Test]
+        //public void GivenCalculationWithOutput_WhenClearingOutput_ThenClearOutput()
+        //{
+        //    // Given
+        //    var observer = mocks.Stub<IObserver>();
+        //    observer.Expect(o => o.UpdateObserver());
+
+        //    var failureMechanism = new WaveImpactAsphaltCoverFailureMechanism();
+        //    failureMechanism.WaveConditionsCalculationGroup.Attach(observer);
+        //    var assessmentSection = mocks.Stub<IAssessmentSection>();
+
+        //    var context = new WaveImpactAsphaltCoverWaveConditionsCalculationGroupContext(failureMechanism.WaveConditionsCalculationGroup,
+        //                                                                               failureMechanism,
+        //                                                                               assessmentSection);
+
+        //    using (var treeViewControl = new TreeViewControl())
+        //    {
+        //        var appFeatureCommandHandler = mocks.Stub<IApplicationFeatureCommands>();
+        //        var importHandler = mocks.Stub<IImportCommandHandler>();
+        //        var exportHandler = mocks.Stub<IExportCommandHandler>();
+        //        var viewCommands = mocks.Stub<IViewCommands>();
+        //        var menuBuilderMock = new ContextMenuBuilder(appFeatureCommandHandler,
+        //                                                     importHandler,
+        //                                                     exportHandler,
+        //                                                     viewCommands,
+        //                                                     context,
+        //                                                     treeViewControl);
+
+        //        var gui = mocks.Stub<IGui>();
+        //        gui.Stub(g => g.ViewCommands).Return(viewCommands);
+        //        gui.Stub(g => g.Get(context, treeViewControl)).Return(menuBuilderMock);
+
+        //        mocks.ReplayAll();
+
+        //        plugin.Gui = gui;
+
+        //        using (ContextMenuStrip contextMenu = info.ContextMenuStrip(context, null, treeViewControl))
+        //        {
+        //            // Precondition
+        //            TestHelper.AssertContextMenuStripContainsItem(contextMenu,
+        //                                                          contextMenuAddCalculationIndexRootGroup,
+        //                                                          "Berekening &toevoegen",
+        //                                                          "Voeg een nieuwe berekening toe aan deze berekeningsmap.",
+        //                                                          RingtoetsCommonFormsResources.FailureMechanismIcon);
+
+        //            // When
+        //            ToolStripItem validateMenuItem = contextMenu.Items[contextMenuAddCalculationIndexRootGroup];
+        //            validateMenuItem.PerformClick();
+
+        //            // Then
+        //            Assert.AreEqual(1, failureMechanism.WaveConditionsCalculationGroup.Children.Count);
+        //            Assert.IsInstanceOf<WaveImpactAsphaltCoverWaveConditionsCalculation>(failureMechanism.WaveConditionsCalculationGroup.Children[0]);
+        //            // Check expectancies in TearDown()
+        //        }
+        //    }
+        //}
+
+        private static WaveImpactAsphaltCoverWaveConditionsCalculation GetValidCalculation()
+        {
+            var calculation = new WaveImpactAsphaltCoverWaveConditionsCalculation
+            {
+                InputParameters =
+                {
+                    HydraulicBoundaryLocation = new HydraulicBoundaryLocation(1300001, "", 0.0, 0.0),
+                    ForeshoreProfile = CreateForeshoreProfile(),
+                    UseForeshore = true,
+                    UseBreakWater = true,
+                    StepSize = WaveConditionsInputStepSize.Half,
+                    LowerBoundaryRevetment = (RoundedDouble)4,
+                    UpperBoundaryRevetment = (RoundedDouble)10,
+                    UpperBoundaryWaterLevels = (RoundedDouble)8,
+                    LowerBoundaryWaterLevels = (RoundedDouble)7.1
+                }
+            };
+            calculation.InputParameters.HydraulicBoundaryLocation.DesignWaterLevel = (RoundedDouble)9.3;
+            return calculation;
+        }
+
+        private static ForeshoreProfile CreateForeshoreProfile()
+        {
+            return new ForeshoreProfile(new Point2D(0, 0),
+                                        new[]
+                                        {
+                                            new Point2D(3.3, 4.4),
+                                            new Point2D(5.5, 6.6)
+                                        },
+                                        new BreakWater(BreakWaterType.Dam, 10.0),
+                                        new ForeshoreProfile.ConstructionProperties());
+        }
+    }
+}
\ No newline at end of file
Index: Ringtoets/WaveImpactAsphaltCover/test/Ringtoets.WaveImpactAsphaltCover.Plugin.Test/TreeNodeInfos/WaveImpactAsphaltCoverFailureMechanismContextTreeNodeInfoTest.cs
===================================================================
diff -u -r944d2501b3f780d208e00015a1b850afad4c3aa8 -r8e97f37e10d4445dfa2aeda2d321f347b5a59921
--- Ringtoets/WaveImpactAsphaltCover/test/Ringtoets.WaveImpactAsphaltCover.Plugin.Test/TreeNodeInfos/WaveImpactAsphaltCoverFailureMechanismContextTreeNodeInfoTest.cs	(.../WaveImpactAsphaltCoverFailureMechanismContextTreeNodeInfoTest.cs)	(revision 944d2501b3f780d208e00015a1b850afad4c3aa8)
+++ Ringtoets/WaveImpactAsphaltCover/test/Ringtoets.WaveImpactAsphaltCover.Plugin.Test/TreeNodeInfos/WaveImpactAsphaltCoverFailureMechanismContextTreeNodeInfoTest.cs	(.../WaveImpactAsphaltCoverFailureMechanismContextTreeNodeInfoTest.cs)	(revision 8e97f37e10d4445dfa2aeda2d321f347b5a59921)
@@ -197,7 +197,8 @@
                 object[] children = info.ChildNodeObjects(failureMechanismContext).ToArray();
 
                 // Assert
-                Assert.AreEqual(2, children.Length);
+                Assert.AreEqual(3, children.Length);
+
                 var inputsFolder = (CategoryTreeFolder) children[0];
                 Assert.AreEqual("Invoer", inputsFolder.Name);
                 Assert.AreEqual(TreeFolderCategory.Input, inputsFolder.Category);
@@ -214,7 +215,11 @@
                 var commentContext = (CommentContext<ICommentable>) inputsFolder.Contents[2];
                 Assert.AreSame(failureMechanism, commentContext.WrappedData);
 
-                var outputsFolder = (CategoryTreeFolder) children[1];
+                var hydraulicBoundariesCalculationGroup = (WaveImpactAsphaltCoverWaveConditionsCalculationGroupContext)children[1];
+                Assert.AreSame(failureMechanism.WaveConditionsCalculationGroup, hydraulicBoundariesCalculationGroup.WrappedData);
+                Assert.AreSame(failureMechanism, hydraulicBoundariesCalculationGroup.FailureMechanism);
+
+                var outputsFolder = (CategoryTreeFolder) children[2];
                 Assert.AreEqual("Oordeel", outputsFolder.Name);
                 Assert.AreEqual(TreeFolderCategory.Output, outputsFolder.Category);
                 Assert.AreEqual(1, outputsFolder.Contents.Count);