Index: Ringtoets/Common/test/Ringtoets.Common.Forms.Test/TreeNodeInfos/RingtoetsContextMenuBuilderTest.cs
===================================================================
diff -u -r09e76611c2a789b6f015368968a18ea5b9b138cc -ra3357275af675af3714fc89b99c554c288759ae2
--- Ringtoets/Common/test/Ringtoets.Common.Forms.Test/TreeNodeInfos/RingtoetsContextMenuBuilderTest.cs	(.../RingtoetsContextMenuBuilderTest.cs)	(revision 09e76611c2a789b6f015368968a18ea5b9b138cc)
+++ Ringtoets/Common/test/Ringtoets.Common.Forms.Test/TreeNodeInfos/RingtoetsContextMenuBuilderTest.cs	(.../RingtoetsContextMenuBuilderTest.cs)	(revision a3357275af675af3714fc89b99c554c288759ae2)
@@ -19,6 +19,7 @@
 // Stichting Deltares and remain full property of Stichting Deltares at all times.
 // All rights reserved.
 
+using System.Collections.Generic;
 using System.Linq;
 using System.Windows.Forms;
 using Core.Common.Base;
@@ -28,6 +29,7 @@
 using Core.Common.TestUtil;
 using NUnit.Framework;
 using Rhino.Mocks;
+using Ringtoets.Common.Data.AssessmentSection;
 using Ringtoets.Common.Data.Calculation;
 using Ringtoets.Common.Data.FailureMechanism;
 using Ringtoets.Common.Forms.PresentationObjects;
@@ -245,608 +247,737 @@
         }
 
         [Test]
-        public void AddPerformAllCalculationsInGroupItem_WhenBuildWithCalculation_ItemAddedToContextMenuEnabled()
+        [TestCase(true)]
+        [TestCase(false)]
+        public void AddToggleRelevancyOfFailureMechanismItem_WhenBuild_ItemAddedToContextMenuEnabled(bool isRelevant)
         {
             // Setup
             var mocks = new MockRepository();
             var applicationFeatureCommandsMock = mocks.StrictMock<IApplicationFeatureCommands>();
             var exportImportHandlerMock = mocks.StrictMock<IExportImportCommandHandler>();
             var viewCommandsMock = mocks.StrictMock<IViewCommands>();
             var treeViewControlMock = mocks.StrictMock<TreeViewControl>();
-            var failureMechanisMock = mocks.StrictMock<IFailureMechanism>();
-
+            var failureMechanismMock = mocks.StrictMock<IFailureMechanism>();
+            failureMechanismMock.Expect(fm => fm.IsRelevant).Return(isRelevant);
+            var failureMechanismContextMock = mocks.StrictMock<IFailureMechanismContext<IFailureMechanism>>();
+            failureMechanismContextMock.Expect(fmc => fmc.WrappedData).Return(failureMechanismMock);
             mocks.ReplayAll();
 
-            var calculation = new TestCalculation();
-            var calculationGroup = new CalculationGroup
-            {
-                Children =
-                {
-                    calculation
-                }
-            };
-            var calculationGroupContext = new TestCalculationGroupContext(calculationGroup, failureMechanisMock);
-            var contextMenuBuilder = new ContextMenuBuilder(applicationFeatureCommandsMock, exportImportHandlerMock, viewCommandsMock, calculationGroup, treeViewControlMock);
+            var contextMenuBuilder = new ContextMenuBuilder(applicationFeatureCommandsMock, exportImportHandlerMock, viewCommandsMock, failureMechanismMock, treeViewControlMock);
             var ringtoetsContextMenuBuilder = new RingtoetsContextMenuBuilder(contextMenuBuilder);
 
             // Call
-            var result = ringtoetsContextMenuBuilder.AddPerformAllCalculationsInGroupItem(calculationGroup, calculationGroupContext, null, context => true).Build();
+            var result = ringtoetsContextMenuBuilder.AddToggleRelevancyOfFailureMechanismItem(failureMechanismContextMock, null).Build();
 
             // Assert
             Assert.IsInstanceOf<ContextMenuStrip>(result);
             Assert.AreEqual(1, result.Items.Count);
-
+            var checkboxIcon = isRelevant ? RingtoetsFormsResources.Checkbox_empty : RingtoetsFormsResources.Checkbox_ticked;
             TestHelper.AssertContextMenuStripContainsItem(result, 0,
-                                                          RingtoetsFormsResources.Calculate_all,
-                                                          RingtoetsFormsResources.CalculationGroup_CalculateAll_ToolTip,
-                                                          RingtoetsFormsResources.CalculateAllIcon);
+                                                          RingtoetsFormsResources.FailureMechanismContextMenuStrip_Is_relevant,
+                                                          RingtoetsFormsResources.FailureMechanismContextMenuStrip_Is_relevant_Tooltip,
+                                                          checkboxIcon);
 
             mocks.VerifyAll();
         }
 
         [Test]
-        public void AddPerformAllCalculationsInGroupItem_WhenBuildWithoutCalculation_ItemAddedToContextMenuDisabled()
+        public void AddClearCalculationOutputItem_WhenBuildWithCalculationWithOutput_ItemAddedToContextMenuEnabled()
         {
             // Setup
             var mocks = new MockRepository();
             var applicationFeatureCommandsMock = mocks.StrictMock<IApplicationFeatureCommands>();
             var exportImportHandlerMock = mocks.StrictMock<IExportImportCommandHandler>();
             var viewCommandsMock = mocks.StrictMock<IViewCommands>();
             var treeViewControlMock = mocks.StrictMock<TreeViewControl>();
-            var failureMechanisMock = mocks.StrictMock<IFailureMechanism>();
+            var calculationWithOutputMock = mocks.StrictMock<ICalculation>();
 
+            calculationWithOutputMock.Expect(c => c.HasOutput).Return(true);
+
             mocks.ReplayAll();
 
-            var calculationGroup = new CalculationGroup();
-            var calculationGroupContext = new TestCalculationGroupContext(calculationGroup, failureMechanisMock);
-            var contextMenuBuilder = new ContextMenuBuilder(applicationFeatureCommandsMock, exportImportHandlerMock, viewCommandsMock, calculationGroup, treeViewControlMock);
+            var contextMenuBuilder = new ContextMenuBuilder(applicationFeatureCommandsMock, exportImportHandlerMock, viewCommandsMock, calculationWithOutputMock, treeViewControlMock);
             var ringtoetsContextMenuBuilder = new RingtoetsContextMenuBuilder(contextMenuBuilder);
 
             // Call
-            var result = ringtoetsContextMenuBuilder.AddPerformAllCalculationsInGroupItem(calculationGroup, calculationGroupContext, null, context => true).Build();
+            var result = ringtoetsContextMenuBuilder.AddClearCalculationOutputItem(calculationWithOutputMock).Build();
 
             // Assert
             Assert.IsInstanceOf<ContextMenuStrip>(result);
             Assert.AreEqual(1, result.Items.Count);
 
             TestHelper.AssertContextMenuStripContainsItem(result, 0,
-                                                          RingtoetsFormsResources.Calculate_all,
-                                                          RingtoetsFormsResources.CalculationGroup_CalculateAll_No_calculations_to_run,
-                                                          RingtoetsFormsResources.CalculateAllIcon,
-                                                          false);
+                                                          RingtoetsFormsResources.Clear_output,
+                                                          RingtoetsFormsResources.Clear_output_ToolTip,
+                                                          RingtoetsFormsResources.ClearIcon);
 
             mocks.VerifyAll();
         }
 
         [Test]
-        public void AddPerformAllCalculationsInFailureMechanismItem_WhenBuildWithCalculation_ItemAddedToContextMenuEnabled()
+        public void AddClearCalculationOutputItem_WhenBuildWithCalculationWithoutOutput_ItemAddedToContextMenuDisabled()
         {
             // Setup
             var mocks = new MockRepository();
             var applicationFeatureCommandsMock = mocks.StrictMock<IApplicationFeatureCommands>();
             var exportImportHandlerMock = mocks.StrictMock<IExportImportCommandHandler>();
             var viewCommandsMock = mocks.StrictMock<IViewCommands>();
             var treeViewControlMock = mocks.StrictMock<TreeViewControl>();
-            var failureMechanismMock = mocks.StrictMock<IFailureMechanism>();
-            failureMechanismMock.Expect(fm => fm.Calculations).Return(new[]
-            {
-                new TestCalculation()
-            });
-            var failureMechanismContextMock = mocks.StrictMock<IFailureMechanismContext<IFailureMechanism>>();
-            failureMechanismContextMock.Expect(fmc => fmc.WrappedData).Return(failureMechanismMock);
+            var calculationWithoutOutputMock = mocks.StrictMock<ICalculation>();
+
+            calculationWithoutOutputMock.Expect(c => c.HasOutput).Return(false);
+
             mocks.ReplayAll();
 
-            var contextMenuBuilder = new ContextMenuBuilder(applicationFeatureCommandsMock, exportImportHandlerMock, viewCommandsMock, failureMechanismContextMock, treeViewControlMock);
+            var contextMenuBuilder = new ContextMenuBuilder(applicationFeatureCommandsMock, exportImportHandlerMock, viewCommandsMock, calculationWithoutOutputMock, treeViewControlMock);
             var ringtoetsContextMenuBuilder = new RingtoetsContextMenuBuilder(contextMenuBuilder);
 
             // Call
-            var result = ringtoetsContextMenuBuilder.AddPerformAllCalculationsInFailureMechanismItem(failureMechanismContextMock, null, context => true).Build();
+            var result = ringtoetsContextMenuBuilder.AddClearCalculationOutputItem(calculationWithoutOutputMock).Build();
 
             // Assert
             Assert.IsInstanceOf<ContextMenuStrip>(result);
             Assert.AreEqual(1, result.Items.Count);
+
             TestHelper.AssertContextMenuStripContainsItem(result, 0,
-                                                          RingtoetsFormsResources.Calculate_all,
-                                                          RingtoetsFormsResources.Calculate_all_ToolTip,
-                                                          RingtoetsFormsResources.CalculateAllIcon);
+                                                          RingtoetsFormsResources.Clear_output,
+                                                          RingtoetsFormsResources.ClearOutput_No_output_to_clear,
+                                                          RingtoetsFormsResources.ClearIcon,
+                                                          false);
 
             mocks.VerifyAll();
         }
 
         [Test]
-        public void AddPerformAllCalculationsInFailureMechanismItem_WhenBuildWithoutCalculation_ItemAddedToContextMenuDisabled()
+        public void AddRenameItem_ContextMenuBuilder_CorrectlyDecorated()
         {
             // Setup
             var mocks = new MockRepository();
-            var applicationFeatureCommandsMock = mocks.StrictMock<IApplicationFeatureCommands>();
-            var exportImportHandlerMock = mocks.StrictMock<IExportImportCommandHandler>();
-            var viewCommandsMock = mocks.StrictMock<IViewCommands>();
-            var treeViewControlMock = mocks.StrictMock<TreeViewControl>();
-            var failureMechanismContextMock = mocks.StrictMock<IFailureMechanismContext<IFailureMechanism>>();
-            var failureMechanismMock = mocks.StrictMock<IFailureMechanism>();
-            failureMechanismContextMock.Expect(fmc => fmc.WrappedData).Return(failureMechanismMock);
-            failureMechanismMock.Expect(fm => fm.Calculations).Return(Enumerable.Empty<ICalculation>());
+            var contextMenuBuilderMock = mocks.StrictMock<IContextMenuBuilder>();
+
+            contextMenuBuilderMock.Expect(cmb => cmb.AddRenameItem());
+
             mocks.ReplayAll();
 
-            var contextMenuBuilder = new ContextMenuBuilder(applicationFeatureCommandsMock, exportImportHandlerMock, viewCommandsMock, failureMechanismContextMock, treeViewControlMock);
-            var ringtoetsContextMenuBuilder = new RingtoetsContextMenuBuilder(contextMenuBuilder);
+            var ringtoetsContextMenuBuilder = new RingtoetsContextMenuBuilder(contextMenuBuilderMock);
 
             // Call
-            var result = ringtoetsContextMenuBuilder.AddPerformAllCalculationsInFailureMechanismItem(failureMechanismContextMock, null, context => true).Build();
+            ringtoetsContextMenuBuilder.AddRenameItem();
 
             // Assert
-            Assert.IsInstanceOf<ContextMenuStrip>(result);
-            Assert.AreEqual(1, result.Items.Count);
-            TestHelper.AssertContextMenuStripContainsItem(result, 0,
-                                                          RingtoetsFormsResources.Calculate_all,
-                                                          RingtoetsFormsResources.FailureMechanism_CreateCalculateAllItem_No_calculations_to_run,
-                                                          RingtoetsFormsResources.CalculateAllIcon, false);
-
             mocks.VerifyAll();
         }
 
         [Test]
-        [TestCase(true)]
-        [TestCase(false)]
-        public void AddToggleRelevancyOfFailureMechanismItem_WhenBuild_ItemAddedToContextMenuEnabled(bool isRelevant)
+        public void AddDeleteItem_ContextMenuBuilder_CorrectlyDecorated()
         {
             // Setup
             var mocks = new MockRepository();
-            var applicationFeatureCommandsMock = mocks.StrictMock<IApplicationFeatureCommands>();
-            var exportImportHandlerMock = mocks.StrictMock<IExportImportCommandHandler>();
-            var viewCommandsMock = mocks.StrictMock<IViewCommands>();
-            var treeViewControlMock = mocks.StrictMock<TreeViewControl>();
-            var failureMechanismMock = mocks.StrictMock<IFailureMechanism>();
-            failureMechanismMock.Expect(fm => fm.IsRelevant).Return(isRelevant);
-            var failureMechanismContextMock = mocks.StrictMock<IFailureMechanismContext<IFailureMechanism>>();
-            failureMechanismContextMock.Expect(fmc => fmc.WrappedData).Return(failureMechanismMock);
+            var contextMenuBuilderMock = mocks.StrictMock<IContextMenuBuilder>();
+
+            contextMenuBuilderMock.Expect(cmb => cmb.AddDeleteItem());
+
             mocks.ReplayAll();
 
-            var contextMenuBuilder = new ContextMenuBuilder(applicationFeatureCommandsMock, exportImportHandlerMock, viewCommandsMock, failureMechanismMock, treeViewControlMock);
-            var ringtoetsContextMenuBuilder = new RingtoetsContextMenuBuilder(contextMenuBuilder);
+            var ringtoetsContextMenuBuilder = new RingtoetsContextMenuBuilder(contextMenuBuilderMock);
 
             // Call
-            var result = ringtoetsContextMenuBuilder.AddToggleRelevancyOfFailureMechanismItem(failureMechanismContextMock, null).Build();
+            ringtoetsContextMenuBuilder.AddDeleteItem();
 
             // Assert
-            Assert.IsInstanceOf<ContextMenuStrip>(result);
-            Assert.AreEqual(1, result.Items.Count);
-            var checkboxIcon = isRelevant ? RingtoetsFormsResources.Checkbox_empty : RingtoetsFormsResources.Checkbox_ticked;
-            TestHelper.AssertContextMenuStripContainsItem(result, 0,
-                                                          RingtoetsFormsResources.FailureMechanismContextMenuStrip_Is_relevant,
-                                                          RingtoetsFormsResources.FailureMechanismContextMenuStrip_Is_relevant_Tooltip,
-                                                          checkboxIcon);
-
             mocks.VerifyAll();
         }
 
         [Test]
-        public void AddPerformCalculationItem_WhenBuildWithAllValidData_ItemAddedToContextMenuEnabled()
+        public void AddExpandAllItem_ContextMenuBuilder_CorrectlyDecorated()
         {
             // Setup
             var mocks = new MockRepository();
-            var applicationFeatureCommandsMock = mocks.StrictMock<IApplicationFeatureCommands>();
-            var exportImportHandlerMock = mocks.StrictMock<IExportImportCommandHandler>();
-            var viewCommandsMock = mocks.StrictMock<IViewCommands>();
-            var treeViewControlMock = mocks.StrictMock<TreeViewControl>();
-            var failureMechanisMock = mocks.StrictMock<IFailureMechanism>();
+            var contextMenuBuilderMock = mocks.StrictMock<IContextMenuBuilder>();
 
+            contextMenuBuilderMock.Expect(cmb => cmb.AddExpandAllItem());
+
             mocks.ReplayAll();
 
-            var calculation = new TestCalculation();
-            var calculationContext = new TestCalculationContext(calculation, failureMechanisMock);
-            var contextMenuBuilder = new ContextMenuBuilder(applicationFeatureCommandsMock, exportImportHandlerMock, viewCommandsMock, calculation, treeViewControlMock);
-            var ringtoetsContextMenuBuilder = new RingtoetsContextMenuBuilder(contextMenuBuilder);
+            var ringtoetsContextMenuBuilder = new RingtoetsContextMenuBuilder(contextMenuBuilderMock);
 
             // Call
-            var result = ringtoetsContextMenuBuilder.AddPerformCalculationItem(calculation, calculationContext, null, context => true).Build();
+            ringtoetsContextMenuBuilder.AddExpandAllItem();
 
             // Assert
-            Assert.IsInstanceOf<ContextMenuStrip>(result);
-            Assert.AreEqual(1, result.Items.Count);
-
-            TestHelper.AssertContextMenuStripContainsItem(result, 0,
-                                                          RingtoetsFormsResources.Calculate,
-                                                          RingtoetsFormsResources.Calculate_ToolTip,
-                                                          RingtoetsFormsResources.CalculateIcon);
-
             mocks.VerifyAll();
         }
 
         [Test]
-        public void AddPerformCalculationItem_WhenBuildWithoutAllValidData_ItemAddedToContextMenuDisabled()
+        public void AddCollapseAllItem_ContextMenuBuilder_CorrectlyDecorated()
         {
             // Setup
             var mocks = new MockRepository();
-            var applicationFeatureCommandsMock = mocks.StrictMock<IApplicationFeatureCommands>();
-            var exportImportHandlerMock = mocks.StrictMock<IExportImportCommandHandler>();
-            var viewCommandsMock = mocks.StrictMock<IViewCommands>();
-            var treeViewControlMock = mocks.StrictMock<TreeViewControl>();
-            var failureMechanisMock = mocks.StrictMock<IFailureMechanism>();
+            var contextMenuBuilderMock = mocks.StrictMock<IContextMenuBuilder>();
 
+            contextMenuBuilderMock.Expect(cmb => cmb.AddCollapseAllItem());
+
             mocks.ReplayAll();
 
-            var calculation = new TestCalculation();
-            var calculationContext = new TestCalculationContext(calculation, failureMechanisMock);
-            var contextMenuBuilder = new ContextMenuBuilder(applicationFeatureCommandsMock, exportImportHandlerMock, viewCommandsMock, calculation, treeViewControlMock);
-            var ringtoetsContextMenuBuilder = new RingtoetsContextMenuBuilder(contextMenuBuilder);
+            var ringtoetsContextMenuBuilder = new RingtoetsContextMenuBuilder(contextMenuBuilderMock);
 
             // Call
-            var result = ringtoetsContextMenuBuilder.AddPerformCalculationItem(calculation, calculationContext, null, context => false).Build();
+            ringtoetsContextMenuBuilder.AddCollapseAllItem();
 
             // Assert
-            Assert.IsInstanceOf<ContextMenuStrip>(result);
-            Assert.AreEqual(1, result.Items.Count);
-
-            TestHelper.AssertContextMenuStripContainsItem(result, 0,
-                                                          RingtoetsFormsResources.Calculate,
-                                                          RingtoetsFormsResources.Calculate_ToolTip,
-                                                          RingtoetsFormsResources.CalculateIcon,
-                                                          false);
-
             mocks.VerifyAll();
         }
 
         [Test]
-        public void AddClearCalculationOutputItem_WhenBuildWithCalculationWithOutput_ItemAddedToContextMenuEnabled()
+        public void AddOpenItem_ContextMenuBuilder_CorrectlyDecorated()
         {
             // Setup
             var mocks = new MockRepository();
-            var applicationFeatureCommandsMock = mocks.StrictMock<IApplicationFeatureCommands>();
-            var exportImportHandlerMock = mocks.StrictMock<IExportImportCommandHandler>();
-            var viewCommandsMock = mocks.StrictMock<IViewCommands>();
-            var treeViewControlMock = mocks.StrictMock<TreeViewControl>();
-            var calculationWithOutputMock = mocks.StrictMock<ICalculation>();
+            var contextMenuBuilderMock = mocks.StrictMock<IContextMenuBuilder>();
 
-            calculationWithOutputMock.Expect(c => c.HasOutput).Return(true);
+            contextMenuBuilderMock.Expect(cmb => cmb.AddOpenItem());
 
             mocks.ReplayAll();
 
-            var contextMenuBuilder = new ContextMenuBuilder(applicationFeatureCommandsMock, exportImportHandlerMock, viewCommandsMock, calculationWithOutputMock, treeViewControlMock);
-            var ringtoetsContextMenuBuilder = new RingtoetsContextMenuBuilder(contextMenuBuilder);
+            var ringtoetsContextMenuBuilder = new RingtoetsContextMenuBuilder(contextMenuBuilderMock);
 
             // Call
-            var result = ringtoetsContextMenuBuilder.AddClearCalculationOutputItem(calculationWithOutputMock).Build();
+            ringtoetsContextMenuBuilder.AddOpenItem();
 
             // Assert
-            Assert.IsInstanceOf<ContextMenuStrip>(result);
-            Assert.AreEqual(1, result.Items.Count);
-
-            TestHelper.AssertContextMenuStripContainsItem(result, 0,
-                                                          RingtoetsFormsResources.Clear_output,
-                                                          RingtoetsFormsResources.Clear_output_ToolTip,
-                                                          RingtoetsFormsResources.ClearIcon);
-
             mocks.VerifyAll();
         }
 
         [Test]
-        public void AddClearCalculationOutputItem_WhenBuildWithCalculationWithoutOutput_ItemAddedToContextMenuDisabled()
+        public void AddExportItem_ContextMenuBuilder_CorrectlyDecorated()
         {
             // Setup
             var mocks = new MockRepository();
-            var applicationFeatureCommandsMock = mocks.StrictMock<IApplicationFeatureCommands>();
-            var exportImportHandlerMock = mocks.StrictMock<IExportImportCommandHandler>();
-            var viewCommandsMock = mocks.StrictMock<IViewCommands>();
-            var treeViewControlMock = mocks.StrictMock<TreeViewControl>();
-            var calculationWithoutOutputMock = mocks.StrictMock<ICalculation>();
+            var contextMenuBuilderMock = mocks.StrictMock<IContextMenuBuilder>();
 
-            calculationWithoutOutputMock.Expect(c => c.HasOutput).Return(false);
+            contextMenuBuilderMock.Expect(cmb => cmb.AddExportItem());
 
             mocks.ReplayAll();
 
-            var contextMenuBuilder = new ContextMenuBuilder(applicationFeatureCommandsMock, exportImportHandlerMock, viewCommandsMock, calculationWithoutOutputMock, treeViewControlMock);
-            var ringtoetsContextMenuBuilder = new RingtoetsContextMenuBuilder(contextMenuBuilder);
+            var ringtoetsContextMenuBuilder = new RingtoetsContextMenuBuilder(contextMenuBuilderMock);
 
             // Call
-            var result = ringtoetsContextMenuBuilder.AddClearCalculationOutputItem(calculationWithoutOutputMock).Build();
+            ringtoetsContextMenuBuilder.AddExportItem();
 
             // Assert
-            Assert.IsInstanceOf<ContextMenuStrip>(result);
-            Assert.AreEqual(1, result.Items.Count);
-
-            TestHelper.AssertContextMenuStripContainsItem(result, 0,
-                                                          RingtoetsFormsResources.Clear_output,
-                                                          RingtoetsFormsResources.ClearOutput_No_output_to_clear,
-                                                          RingtoetsFormsResources.ClearIcon,
-                                                          false);
-
             mocks.VerifyAll();
         }
 
         [Test]
-        public void AddPerformAllCalculationsInFailureMechanismItem_WhenBuildWithAllValidData_ItemAddedToContextmenuEnabled()
+        public void AddImportItem_ContextMenuBuilder_CorrectlyDecorated()
         {
             // Setup
             var mocks = new MockRepository();
-            var applicationFeatureCommandsMock = mocks.StrictMock<IApplicationFeatureCommands>();
-            var exportImportHandlerMock = mocks.StrictMock<IExportImportCommandHandler>();
-            var viewCommandsMock = mocks.StrictMock<IViewCommands>();
-            var treeViewControlMock = mocks.StrictMock<TreeViewControl>();
-            var failureMechanismMock = mocks.StrictMock<IFailureMechanism>();
-            failureMechanismMock.Expect(fm => fm.Calculations).Return(new[]
-            {
-                new TestCalculation()
-            });
+            var contextMenuBuilderMock = mocks.StrictMock<IContextMenuBuilder>();
 
-            var failureMechanismContextMock = mocks.StrictMock<IFailureMechanismContext<IFailureMechanism>>();
-            failureMechanismContextMock.Expect(fmc => fmc.WrappedData).Return(failureMechanismMock);
+            contextMenuBuilderMock.Expect(cmb => cmb.AddImportItem());
 
             mocks.ReplayAll();
 
-            var contextMenuBuilder = new ContextMenuBuilder(applicationFeatureCommandsMock, exportImportHandlerMock, viewCommandsMock, failureMechanismContextMock, treeViewControlMock);
-            var ringtoetsContextMenuBuilder = new RingtoetsContextMenuBuilder(contextMenuBuilder);
+            var ringtoetsContextMenuBuilder = new RingtoetsContextMenuBuilder(contextMenuBuilderMock);
 
             // Call
-            var result = ringtoetsContextMenuBuilder.AddPerformAllCalculationsInFailureMechanismItem(failureMechanismContextMock, null, context => true).Build();
+            ringtoetsContextMenuBuilder.AddImportItem();
 
             // Assert
-            Assert.IsInstanceOf<ContextMenuStrip>(result);
-            Assert.AreEqual(1, result.Items.Count);
-
-            TestHelper.AssertContextMenuStripContainsItem(result, 0,
-                                                          RingtoetsFormsResources.Calculate_all,
-                                                          RingtoetsFormsResources.Calculate_all_ToolTip,
-                                                          RingtoetsFormsResources.CalculateAllIcon);
-
             mocks.VerifyAll();
         }
 
         [Test]
-        public void AddPerformAllCalculationsInFailureMechanismItem_WhenBuildWithoutAllValidData_ItemAddedToContextmenuDisabled()
+        public void AddPropertiesItem_ContextMenuBuilder_CorrectlyDecorated()
         {
             // Setup
             var mocks = new MockRepository();
-            var applicationFeatureCommandsMock = mocks.StrictMock<IApplicationFeatureCommands>();
-            var exportImportHandlerMock = mocks.StrictMock<IExportImportCommandHandler>();
-            var viewCommandsMock = mocks.StrictMock<IViewCommands>();
-            var treeViewControlMock = mocks.StrictMock<TreeViewControl>();
-            var failureMechanismContextMock = mocks.StrictMock<IFailureMechanismContext<IFailureMechanism>>();
+            var contextMenuBuilderMock = mocks.StrictMock<IContextMenuBuilder>();
 
+            contextMenuBuilderMock.Expect(cmb => cmb.AddPropertiesItem());
+
             mocks.ReplayAll();
 
-            var contextMenuBuilder = new ContextMenuBuilder(applicationFeatureCommandsMock, exportImportHandlerMock, viewCommandsMock, failureMechanismContextMock, treeViewControlMock);
-            var ringtoetsContextMenuBuilder = new RingtoetsContextMenuBuilder(contextMenuBuilder);
+            var ringtoetsContextMenuBuilder = new RingtoetsContextMenuBuilder(contextMenuBuilderMock);
 
             // Call
-            var result = ringtoetsContextMenuBuilder.AddPerformAllCalculationsInFailureMechanismItem(failureMechanismContextMock, null, context => false).Build();
+            ringtoetsContextMenuBuilder.AddPropertiesItem();
 
             // Assert
-            Assert.IsInstanceOf<ContextMenuStrip>(result);
-            Assert.AreEqual(1, result.Items.Count);
-
-            TestHelper.AssertContextMenuStripContainsItem(result, 0,
-                                                          RingtoetsFormsResources.Calculate_all,
-                                                          RingtoetsFormsResources.Calculate_all_ToolTip,
-                                                          RingtoetsFormsResources.CalculateAllIcon,
-                                                          false);
-
             mocks.VerifyAll();
         }
 
         [Test]
-        public void AddRenameItem_ContextMenuBuilder_CorrectlyDecorated()
+        public void AddSeparator_ContextMenuBuilder_CorrectlyDecorated()
         {
             // Setup
             var mocks = new MockRepository();
             var contextMenuBuilderMock = mocks.StrictMock<IContextMenuBuilder>();
 
-            contextMenuBuilderMock.Expect(cmb => cmb.AddRenameItem());
+            contextMenuBuilderMock.Expect(cmb => cmb.AddSeparator());
 
             mocks.ReplayAll();
 
             var ringtoetsContextMenuBuilder = new RingtoetsContextMenuBuilder(contextMenuBuilderMock);
 
             // Call
-            ringtoetsContextMenuBuilder.AddRenameItem();
+            ringtoetsContextMenuBuilder.AddSeparator();
 
             // Assert
             mocks.VerifyAll();
         }
 
         [Test]
-        public void AddDeleteItem_ContextMenuBuilder_CorrectlyDecorated()
+        public void AddCustomItem_ContextMenuBuilder_CorrectlyDecorated()
         {
             // Setup
             var mocks = new MockRepository();
+            var contextMenuItemMock = mocks.StrictMock<StrictContextMenuItem>();
             var contextMenuBuilderMock = mocks.StrictMock<IContextMenuBuilder>();
 
-            contextMenuBuilderMock.Expect(cmb => cmb.AddDeleteItem());
+            contextMenuBuilderMock.Expect(cmb => cmb.AddCustomItem(contextMenuItemMock));
 
             mocks.ReplayAll();
 
             var ringtoetsContextMenuBuilder = new RingtoetsContextMenuBuilder(contextMenuBuilderMock);
 
             // Call
-            ringtoetsContextMenuBuilder.AddDeleteItem();
+            ringtoetsContextMenuBuilder.AddCustomItem(contextMenuItemMock);
 
             // Assert
             mocks.VerifyAll();
         }
 
         [Test]
-        public void AddExpandAllItem_ContextMenuBuilder_CorrectlyDecorated()
+        public void Build_ContextMenuBuilder_CorrectlyDecorated()
         {
             // Setup
             var mocks = new MockRepository();
             var contextMenuBuilderMock = mocks.StrictMock<IContextMenuBuilder>();
 
-            contextMenuBuilderMock.Expect(cmb => cmb.AddExpandAllItem());
+            contextMenuBuilderMock.Expect(cmb => cmb.Build());
 
             mocks.ReplayAll();
 
             var ringtoetsContextMenuBuilder = new RingtoetsContextMenuBuilder(contextMenuBuilderMock);
 
             // Call
-            ringtoetsContextMenuBuilder.AddExpandAllItem();
+            ringtoetsContextMenuBuilder.Build();
 
             // Assert
             mocks.VerifyAll();
         }
 
+        #region AddPerformCalculationItem
+
         [Test]
-        public void AddCollapseAllItem_ContextMenuBuilder_CorrectlyDecorated()
+        public void AddPerformCalculationItem_AdditionalValidationNull_ItemAddedToContextMenuEnabled()
         {
             // Setup
             var mocks = new MockRepository();
-            var contextMenuBuilderMock = mocks.StrictMock<IContextMenuBuilder>();
+            var applicationFeatureCommandsMock = mocks.StrictMock<IApplicationFeatureCommands>();
+            var exportImportHandlerMock = mocks.StrictMock<IExportImportCommandHandler>();
+            var viewCommandsMock = mocks.StrictMock<IViewCommands>();
+            var treeViewControlMock = mocks.StrictMock<TreeViewControl>();
+            var failureMechanisMock = mocks.StrictMock<IFailureMechanism>();
 
-            contextMenuBuilderMock.Expect(cmb => cmb.AddCollapseAllItem());
-
             mocks.ReplayAll();
 
-            var ringtoetsContextMenuBuilder = new RingtoetsContextMenuBuilder(contextMenuBuilderMock);
+            var calculation = new TestCalculation();
+            var calculationContext = new TestCalculationContext(calculation, failureMechanisMock);
+            var contextMenuBuilder = new ContextMenuBuilder(applicationFeatureCommandsMock, exportImportHandlerMock, viewCommandsMock, calculation, treeViewControlMock);
+            var ringtoetsContextMenuBuilder = new RingtoetsContextMenuBuilder(contextMenuBuilder);
 
             // Call
-            ringtoetsContextMenuBuilder.AddCollapseAllItem();
+            ContextMenuStrip result = ringtoetsContextMenuBuilder.AddPerformCalculationItem(calculation, calculationContext, null, context => null).Build();
 
             // Assert
+            Assert.IsInstanceOf<ContextMenuStrip>(result);
+            Assert.AreEqual(1, result.Items.Count);
+
+            TestHelper.AssertContextMenuStripContainsItem(result, 0,
+                                                          RingtoetsFormsResources.Calculate,
+                                                          RingtoetsFormsResources.Calculate_ToolTip,
+                                                          RingtoetsFormsResources.CalculateIcon);
+
             mocks.VerifyAll();
         }
 
         [Test]
-        public void AddOpenItem_ContextMenuBuilder_CorrectlyDecorated()
+        public void AddPerformCalculationItem_AdditionalValidationConatainsMessage_ItemAddedToContextMenuDisabledWithMessageInTooltip()
         {
             // Setup
             var mocks = new MockRepository();
-            var contextMenuBuilderMock = mocks.StrictMock<IContextMenuBuilder>();
+            var applicationFeatureCommandsMock = mocks.StrictMock<IApplicationFeatureCommands>();
+            var exportImportHandlerMock = mocks.StrictMock<IExportImportCommandHandler>();
+            var viewCommandsMock = mocks.StrictMock<IViewCommands>();
+            var treeViewControlMock = mocks.StrictMock<TreeViewControl>();
+            var failureMechanisMock = mocks.StrictMock<IFailureMechanism>();
 
-            contextMenuBuilderMock.Expect(cmb => cmb.AddOpenItem());
-
             mocks.ReplayAll();
 
-            var ringtoetsContextMenuBuilder = new RingtoetsContextMenuBuilder(contextMenuBuilderMock);
+            var calculation = new TestCalculation();
+            var calculationContext = new TestCalculationContext(calculation, failureMechanisMock);
+            var contextMenuBuilder = new ContextMenuBuilder(applicationFeatureCommandsMock, exportImportHandlerMock, viewCommandsMock, calculation, treeViewControlMock);
+            var ringtoetsContextMenuBuilder = new RingtoetsContextMenuBuilder(contextMenuBuilder);
+            
+            var errorMessage = "No valid data";
 
             // Call
-            ringtoetsContextMenuBuilder.AddOpenItem();
+            ContextMenuStrip result = ringtoetsContextMenuBuilder.AddPerformCalculationItem(calculation, calculationContext, null, context => errorMessage).Build();
 
             // Assert
+            Assert.IsInstanceOf<ContextMenuStrip>(result);
+            Assert.AreEqual(1, result.Items.Count);
+
+            TestHelper.AssertContextMenuStripContainsItem(result, 0,
+                                                          RingtoetsFormsResources.Calculate,
+                                                          errorMessage,
+                                                          RingtoetsFormsResources.CalculateIcon,
+                                                          false);
+
             mocks.VerifyAll();
         }
 
+        #endregion
+
+        #region AddPerformAllCalculationsInGroupItem
+
         [Test]
-        public void AddExportItem_ContextMenuBuilder_CorrectlyDecorated()
+        public void AddPerformAllCalculationsInGroupItem_GeneralValidationTrueAdditionalValidationNull_ItemAddedToContextMenuEnabled()
         {
             // Setup
             var mocks = new MockRepository();
-            var contextMenuBuilderMock = mocks.StrictMock<IContextMenuBuilder>();
+            var applicationFeatureCommandsMock = mocks.StrictMock<IApplicationFeatureCommands>();
+            var exportImportHandlerMock = mocks.StrictMock<IExportImportCommandHandler>();
+            var viewCommandsMock = mocks.StrictMock<IViewCommands>();
+            var treeViewControlMock = mocks.StrictMock<TreeViewControl>();
 
-            contextMenuBuilderMock.Expect(cmb => cmb.AddExportItem());
+            mocks.ReplayAll();
 
+            var calculation = new TestCalculation();
+            var calculationGroup = new CalculationGroup
+            {
+                Children =
+                {
+                    calculation
+                }
+            };
+
+            var failureMechanism = new TestFailureMechanism(new[] { calculation });
+
+            var calculationGroupContext = new TestCalculationGroupContext(calculationGroup, failureMechanism);
+            var contextMenuBuilder = new ContextMenuBuilder(applicationFeatureCommandsMock, exportImportHandlerMock, viewCommandsMock, calculationGroup, treeViewControlMock);
+            var ringtoetsContextMenuBuilder = new RingtoetsContextMenuBuilder(contextMenuBuilder);
+
+            // Call
+            ContextMenuStrip result = ringtoetsContextMenuBuilder.AddPerformAllCalculationsInGroupItem(calculationGroup, calculationGroupContext, null, context => null).Build();
+
+            // Assert
+            Assert.IsInstanceOf<ContextMenuStrip>(result);
+            Assert.AreEqual(1, result.Items.Count);
+
+            TestHelper.AssertContextMenuStripContainsItem(result, 0,
+                                                          RingtoetsFormsResources.Calculate_all,
+                                                          RingtoetsFormsResources.CalculationGroup_CalculateAll_ToolTip,
+                                                          RingtoetsFormsResources.CalculateAllIcon);
+
+            mocks.VerifyAll();
+        }
+
+        [Test]
+        public void AddPerformAllCalculationsInGroupItem_GeneralValidationFalseAdditionalValidationNull_ItemAddedToContextMenuDisabledWithGeneralValidationMessageTooltip()
+        {
+            // Setup
+            var mocks = new MockRepository();
+            var applicationFeatureCommandsMock = mocks.StrictMock<IApplicationFeatureCommands>();
+            var exportImportHandlerMock = mocks.StrictMock<IExportImportCommandHandler>();
+            var viewCommandsMock = mocks.StrictMock<IViewCommands>();
+            var treeViewControlMock = mocks.StrictMock<TreeViewControl>();
+
             mocks.ReplayAll();
 
-            var ringtoetsContextMenuBuilder = new RingtoetsContextMenuBuilder(contextMenuBuilderMock);
+            var failureMechanism = new TestFailureMechanism(Enumerable.Empty<ICalculation>());
+            var calculationGroup = new CalculationGroup();
+            var calculationGroupContext = new TestCalculationGroupContext(calculationGroup, failureMechanism);
+            var contextMenuBuilder = new ContextMenuBuilder(applicationFeatureCommandsMock, exportImportHandlerMock, viewCommandsMock, calculationGroup, treeViewControlMock);
+            var ringtoetsContextMenuBuilder = new RingtoetsContextMenuBuilder(contextMenuBuilder);
 
             // Call
-            ringtoetsContextMenuBuilder.AddExportItem();
+            ContextMenuStrip result = ringtoetsContextMenuBuilder.AddPerformAllCalculationsInGroupItem(calculationGroup, calculationGroupContext, null, context => null).Build();
 
             // Assert
+            Assert.IsInstanceOf<ContextMenuStrip>(result);
+            Assert.AreEqual(1, result.Items.Count);
+
+            TestHelper.AssertContextMenuStripContainsItem(result, 0,
+                                                          RingtoetsFormsResources.Calculate_all,
+                                                          RingtoetsFormsResources.CalculationGroup_CalculateAll_No_calculations_to_run,
+                                                          RingtoetsFormsResources.CalculateAllIcon,
+                                                          false);
+
             mocks.VerifyAll();
         }
 
         [Test]
-        public void AddImportItem_ContextMenuBuilder_CorrectlyDecorated()
+        public void AddPerformAllCalculationsInGroupItem_GeneralValidationTrueAdditionalValidationContainsMessage_ItemAddedToContextMenuDisabledWithMessageTooltip()
         {
             // Setup
             var mocks = new MockRepository();
-            var contextMenuBuilderMock = mocks.StrictMock<IContextMenuBuilder>();
+            var applicationFeatureCommandsMock = mocks.StrictMock<IApplicationFeatureCommands>();
+            var exportImportHandlerMock = mocks.StrictMock<IExportImportCommandHandler>();
+            var viewCommandsMock = mocks.StrictMock<IViewCommands>();
+            var treeViewControlMock = mocks.StrictMock<TreeViewControl>();
 
-            contextMenuBuilderMock.Expect(cmb => cmb.AddImportItem());
+            mocks.ReplayAll();
 
+            var calculation = new TestCalculation();
+            var calculationGroup = new CalculationGroup
+            {
+                Children =
+                {
+                    calculation
+                }
+            };
+
+            var failureMechanism = new TestFailureMechanism(new[] { calculation });
+
+            var calculationGroupContext = new TestCalculationGroupContext(calculationGroup, failureMechanism);
+            var contextMenuBuilder = new ContextMenuBuilder(applicationFeatureCommandsMock, exportImportHandlerMock, viewCommandsMock, calculationGroup, treeViewControlMock);
+            var ringtoetsContextMenuBuilder = new RingtoetsContextMenuBuilder(contextMenuBuilder);
+
+            var errorMessage = "Additional validation failed.";
+
+            // Call
+            ContextMenuStrip result = ringtoetsContextMenuBuilder.AddPerformAllCalculationsInGroupItem(calculationGroup, calculationGroupContext, null, context => errorMessage).Build();
+
+            // Assert
+            Assert.IsInstanceOf<ContextMenuStrip>(result);
+            Assert.AreEqual(1, result.Items.Count);
+
+            TestHelper.AssertContextMenuStripContainsItem(result, 0,
+                                                          RingtoetsFormsResources.Calculate_all,
+                                                          errorMessage,
+                                                          RingtoetsFormsResources.CalculateAllIcon,
+                                                          false);
+
+            mocks.VerifyAll();
+        }
+
+        [Test]
+        public void AddPerformAllCalculationsInGroupItem_GeneralValidationFalseAdditionalValidationContainsMessage_ItemAddedToContextMenuDisabledWithGeneralValidationMessageTooltip()
+        {
+            // Setup
+            var mocks = new MockRepository();
+            var applicationFeatureCommandsMock = mocks.StrictMock<IApplicationFeatureCommands>();
+            var exportImportHandlerMock = mocks.StrictMock<IExportImportCommandHandler>();
+            var viewCommandsMock = mocks.StrictMock<IViewCommands>();
+            var treeViewControlMock = mocks.StrictMock<TreeViewControl>();
+
             mocks.ReplayAll();
 
-            var ringtoetsContextMenuBuilder = new RingtoetsContextMenuBuilder(contextMenuBuilderMock);
+            var failureMechanism = new TestFailureMechanism(Enumerable.Empty<ICalculation>());
+            var calculationGroup = new CalculationGroup();
+            var calculationGroupContext = new TestCalculationGroupContext(calculationGroup, failureMechanism);
+            var contextMenuBuilder = new ContextMenuBuilder(applicationFeatureCommandsMock, exportImportHandlerMock, viewCommandsMock, calculationGroup, treeViewControlMock);
+            var ringtoetsContextMenuBuilder = new RingtoetsContextMenuBuilder(contextMenuBuilder);
 
+            var errorMessage = "Additional validation failed.";
+
             // Call
-            ringtoetsContextMenuBuilder.AddImportItem();
+            ContextMenuStrip result = ringtoetsContextMenuBuilder.AddPerformAllCalculationsInGroupItem(calculationGroup, calculationGroupContext, null, context => errorMessage).Build();
 
             // Assert
+            Assert.IsInstanceOf<ContextMenuStrip>(result);
+            Assert.AreEqual(1, result.Items.Count);
+
+            TestHelper.AssertContextMenuStripContainsItem(result, 0,
+                                                          RingtoetsFormsResources.Calculate_all,
+                                                          RingtoetsFormsResources.CalculationGroup_CalculateAll_No_calculations_to_run,
+                                                          RingtoetsFormsResources.CalculateAllIcon,
+                                                          false);
+
             mocks.VerifyAll();
         }
 
+        #endregion
+
+        #region AddPerformAllCalculationsInFailureMechanismItem
+
         [Test]
-        public void AddPropertiesItem_ContextMenuBuilder_CorrectlyDecorated()
+        public void AddPerformAllCalculationsInFailureMechanismItem_GeneralValidationTrueAdditionalValidationNull_ItemAddedToContextMenuEnabled()
         {
             // Setup
             var mocks = new MockRepository();
-            var contextMenuBuilderMock = mocks.StrictMock<IContextMenuBuilder>();
+            var applicationFeatureCommandsMock = mocks.StrictMock<IApplicationFeatureCommands>();
+            var exportImportHandlerMock = mocks.StrictMock<IExportImportCommandHandler>();
+            var viewCommandsMock = mocks.StrictMock<IViewCommands>();
+            var treeViewControlMock = mocks.StrictMock<TreeViewControl>();
+            var assessmentSectionMock = mocks.StrictMock<IAssessmentSection>();
 
-            contextMenuBuilderMock.Expect(cmb => cmb.AddPropertiesItem());
+            var failureMechanism = new TestFailureMechanism(new[] { new TestCalculation() });
+            var failureMechanismContext = new TestFailureMechanismContext(failureMechanism, assessmentSectionMock);
 
             mocks.ReplayAll();
 
-            var ringtoetsContextMenuBuilder = new RingtoetsContextMenuBuilder(contextMenuBuilderMock);
+            var contextMenuBuilder = new ContextMenuBuilder(applicationFeatureCommandsMock, exportImportHandlerMock, viewCommandsMock, failureMechanismContext, treeViewControlMock);
+            var ringtoetsContextMenuBuilder = new RingtoetsContextMenuBuilder(contextMenuBuilder);
 
             // Call
-            ringtoetsContextMenuBuilder.AddPropertiesItem();
+            ContextMenuStrip result = ringtoetsContextMenuBuilder.AddPerformAllCalculationsInFailureMechanismItem(failureMechanismContext, null, context => null).Build();
 
             // Assert
+            Assert.IsInstanceOf<ContextMenuStrip>(result);
+            Assert.AreEqual(1, result.Items.Count);
+            TestHelper.AssertContextMenuStripContainsItem(result, 0,
+                                                          RingtoetsFormsResources.Calculate_all,
+                                                          RingtoetsFormsResources.Calculate_all_ToolTip,
+                                                          RingtoetsFormsResources.CalculateAllIcon);
+
             mocks.VerifyAll();
         }
 
         [Test]
-        public void AddSeparator_ContextMenuBuilder_CorrectlyDecorated()
+        public void AddPerformAllCalculationsInFailureMechanismItem_GeneralValidationFalseAdditionalValidationNull_ItemAddedToContextMenuDisabledWithGeneralValidationMessageTooltip()
         {
             // Setup
             var mocks = new MockRepository();
-            var contextMenuBuilderMock = mocks.StrictMock<IContextMenuBuilder>();
+            var applicationFeatureCommandsMock = mocks.StrictMock<IApplicationFeatureCommands>();
+            var exportImportHandlerMock = mocks.StrictMock<IExportImportCommandHandler>();
+            var viewCommandsMock = mocks.StrictMock<IViewCommands>();
+            var treeViewControlMock = mocks.StrictMock<TreeViewControl>();
+            var assessmentSectionMock = mocks.StrictMock<IAssessmentSection>();
 
-            contextMenuBuilderMock.Expect(cmb => cmb.AddSeparator());
+            var failureMechanism = new TestFailureMechanism(Enumerable.Empty<ICalculation>());
+            var failureMechanismContext = new TestFailureMechanismContext(failureMechanism, assessmentSectionMock);
 
             mocks.ReplayAll();
 
-            var ringtoetsContextMenuBuilder = new RingtoetsContextMenuBuilder(contextMenuBuilderMock);
+            var contextMenuBuilder = new ContextMenuBuilder(applicationFeatureCommandsMock, exportImportHandlerMock, viewCommandsMock, failureMechanismContext, treeViewControlMock);
+            var ringtoetsContextMenuBuilder = new RingtoetsContextMenuBuilder(contextMenuBuilder);
 
             // Call
-            ringtoetsContextMenuBuilder.AddSeparator();
+            ContextMenuStrip result = ringtoetsContextMenuBuilder.AddPerformAllCalculationsInFailureMechanismItem(failureMechanismContext, null, context => null).Build();
 
             // Assert
+            Assert.IsInstanceOf<ContextMenuStrip>(result);
+            Assert.AreEqual(1, result.Items.Count);
+            TestHelper.AssertContextMenuStripContainsItem(result, 0,
+                                                          RingtoetsFormsResources.Calculate_all,
+                                                          RingtoetsFormsResources.FailureMechanism_CreateCalculateAllItem_No_calculations_to_run,
+                                                          RingtoetsFormsResources.CalculateAllIcon,
+                                                          false);
+
             mocks.VerifyAll();
         }
 
         [Test]
-        public void AddCustomItem_ContextMenuBuilder_CorrectlyDecorated()
+        public void AddPerformAllCalculationsInFailureMechanismItem_GeneralValidationTrueAdditionalValidationContainsMessage_ItemAddedToContextMenuDisabledWithMessageTooltip()
         {
             // Setup
             var mocks = new MockRepository();
-            var contextMenuItemMock = mocks.StrictMock<StrictContextMenuItem>();
-            var contextMenuBuilderMock = mocks.StrictMock<IContextMenuBuilder>();
+            var applicationFeatureCommandsMock = mocks.StrictMock<IApplicationFeatureCommands>();
+            var exportImportHandlerMock = mocks.StrictMock<IExportImportCommandHandler>();
+            var viewCommandsMock = mocks.StrictMock<IViewCommands>();
+            var treeViewControlMock = mocks.StrictMock<TreeViewControl>();
+            var assessmentSectionMock = mocks.StrictMock<IAssessmentSection>();
 
-            contextMenuBuilderMock.Expect(cmb => cmb.AddCustomItem(contextMenuItemMock));
+            var failureMechanism = new TestFailureMechanism(new[] { new TestCalculation() });
+            var failureMechanismContext = new TestFailureMechanismContext(failureMechanism, assessmentSectionMock);
 
             mocks.ReplayAll();
 
-            var ringtoetsContextMenuBuilder = new RingtoetsContextMenuBuilder(contextMenuBuilderMock);
+            var contextMenuBuilder = new ContextMenuBuilder(applicationFeatureCommandsMock, exportImportHandlerMock, viewCommandsMock, failureMechanismContext, treeViewControlMock);
+            var ringtoetsContextMenuBuilder = new RingtoetsContextMenuBuilder(contextMenuBuilder);
 
+            var errorMessage = "Additional validation failed.";
+
             // Call
-            ringtoetsContextMenuBuilder.AddCustomItem(contextMenuItemMock);
+            ContextMenuStrip result = ringtoetsContextMenuBuilder.AddPerformAllCalculationsInFailureMechanismItem(failureMechanismContext, null, context => errorMessage).Build();
 
             // Assert
+            Assert.IsInstanceOf<ContextMenuStrip>(result);
+            Assert.AreEqual(1, result.Items.Count);
+            TestHelper.AssertContextMenuStripContainsItem(result, 0,
+                                                          RingtoetsFormsResources.Calculate_all,
+                                                          errorMessage,
+                                                          RingtoetsFormsResources.CalculateAllIcon,
+                                                          false);
+
             mocks.VerifyAll();
         }
 
         [Test]
-        public void Build_ContextMenuBuilder_CorrectlyDecorated()
+        public void AddPerformAllCalculationsInFailureMechanismItem_GeneralValidationFalseAdditionalValidationContainsMessage_ItemAddedToContextMenuDisabledWithGeneralValidationMessageTooltip()
         {
             // Setup
             var mocks = new MockRepository();
-            var contextMenuBuilderMock = mocks.StrictMock<IContextMenuBuilder>();
+            var applicationFeatureCommandsMock = mocks.StrictMock<IApplicationFeatureCommands>();
+            var exportImportHandlerMock = mocks.StrictMock<IExportImportCommandHandler>();
+            var viewCommandsMock = mocks.StrictMock<IViewCommands>();
+            var treeViewControlMock = mocks.StrictMock<TreeViewControl>();
+            var assessmentSectionMock = mocks.StrictMock<IAssessmentSection>();
 
-            contextMenuBuilderMock.Expect(cmb => cmb.Build());
+            var failureMechanism = new TestFailureMechanism(Enumerable.Empty<ICalculation>());
+            var failureMechanismContext = new TestFailureMechanismContext(failureMechanism, assessmentSectionMock);
 
             mocks.ReplayAll();
 
-            var ringtoetsContextMenuBuilder = new RingtoetsContextMenuBuilder(contextMenuBuilderMock);
+            var contextMenuBuilder = new ContextMenuBuilder(applicationFeatureCommandsMock, exportImportHandlerMock, viewCommandsMock, failureMechanismContext, treeViewControlMock);
+            var ringtoetsContextMenuBuilder = new RingtoetsContextMenuBuilder(contextMenuBuilder);
 
+            var errorMessage = "Additional validation failed.";
+
             // Call
-            ringtoetsContextMenuBuilder.Build();
+            ContextMenuStrip result = ringtoetsContextMenuBuilder.AddPerformAllCalculationsInFailureMechanismItem(failureMechanismContext, null, context => errorMessage).Build();
 
             // Assert
+            Assert.IsInstanceOf<ContextMenuStrip>(result);
+            Assert.AreEqual(1, result.Items.Count);
+            TestHelper.AssertContextMenuStripContainsItem(result, 0,
+                                                          RingtoetsFormsResources.Calculate_all,
+                                                          RingtoetsFormsResources.FailureMechanism_CreateCalculateAllItem_No_calculations_to_run,
+                                                          RingtoetsFormsResources.CalculateAllIcon,
+                                                          false);
+
             mocks.VerifyAll();
         }
 
+        #endregion
+
         # region Nested types
+        
+        private class TestFailureMechanismContext : FailureMechanismContext<IFailureMechanism>
+        {
+            public TestFailureMechanismContext(IFailureMechanism wrappedFailureMechanism, IAssessmentSection parent) :
+                base(wrappedFailureMechanism, parent) { }
+        }
 
+        private class TestFailureMechanism : FailureMechanismBase<FailureMechanismSectionResult>
+        {
+            private readonly IEnumerable<ICalculation> calculations;
+
+            public TestFailureMechanism(IEnumerable<ICalculation> calculations)
+                : base("Name", "Code")
+            {
+                this.calculations = calculations;
+            }
+
+            public override IEnumerable<ICalculation> Calculations
+            {
+                get
+                {
+                    return calculations;
+                }
+            }
+
+            protected override FailureMechanismSectionResult CreateFailureMechanismSectionResult(FailureMechanismSection section)
+            {
+                return null;
+            }
+        }
+
         private class TestCalculationGroupContext : Observable, ICalculationContext<CalculationGroup, IFailureMechanism>
         {
             public TestCalculationGroupContext(CalculationGroup wrappedData, IFailureMechanism failureMechanism)