Index: Ringtoets/Integration/src/Ringtoets.Integration.Forms/Properties/Resources.Designer.cs
===================================================================
diff -u -rcdf0db780e289f3d6fc5a2a6db00f26517a3aec4 -rffa34dc6feb3d5fdf246cb89f7e1c11990ccc960
--- Ringtoets/Integration/src/Ringtoets.Integration.Forms/Properties/Resources.Designer.cs	(.../Resources.Designer.cs)	(revision cdf0db780e289f3d6fc5a2a6db00f26517a3aec4)
+++ Ringtoets/Integration/src/Ringtoets.Integration.Forms/Properties/Resources.Designer.cs	(.../Resources.Designer.cs)	(revision ffa34dc6feb3d5fdf246cb89f7e1c11990ccc960)
@@ -424,24 +424,6 @@
         }
         
         /// <summary>
-        ///   Looks up a localized string similar to Terugkeertijd van de norm, gelijk aan 1/norm..
-        /// </summary>
-        public static string FailureMechanismContribution_ReturnPeriod_Description {
-            get {
-                return ResourceManager.GetString("FailureMechanismContribution_ReturnPeriod_Description", resourceCulture);
-            }
-        }
-        
-        /// <summary>
-        ///   Looks up a localized string similar to Norm (terugkeertijd) [jaar].
-        /// </summary>
-        public static string FailureMechanismContribution_ReturnPeriod_DisplayName {
-            get {
-                return ResourceManager.GetString("FailureMechanismContribution_ReturnPeriod_DisplayName", resourceCulture);
-            }
-        }
-        
-        /// <summary>
         ///   Looks up a localized string similar to De waarde voor de &apos;Norm (terugkeertijd)&apos; moet in het bereik {0} liggen..
         /// </summary>
         public static string FailureMechanismContributionContextProperties_ReturnPeriod_Value_for_ReturnPeriod_Must_be_in_Range_0_ {
Index: Ringtoets/Integration/src/Ringtoets.Integration.Forms/Properties/Resources.resx
===================================================================
diff -u -rcdf0db780e289f3d6fc5a2a6db00f26517a3aec4 -rffa34dc6feb3d5fdf246cb89f7e1c11990ccc960
--- Ringtoets/Integration/src/Ringtoets.Integration.Forms/Properties/Resources.resx	(.../Resources.resx)	(revision cdf0db780e289f3d6fc5a2a6db00f26517a3aec4)
+++ Ringtoets/Integration/src/Ringtoets.Integration.Forms/Properties/Resources.resx	(.../Resources.resx)	(revision ffa34dc6feb3d5fdf246cb89f7e1c11990ccc960)
@@ -276,12 +276,6 @@
   <data name="FailureMechanismContribution_Composition_DisplayName" xml:space="preserve">
     <value>Trajecttype</value>
   </data>
-  <data name="FailureMechanismContribution_ReturnPeriod_Description" xml:space="preserve">
-    <value>Terugkeertijd van de norm, gelijk aan 1/norm.</value>
-  </data>
-  <data name="FailureMechanismContribution_ReturnPeriod_DisplayName" xml:space="preserve">
-    <value>Norm (terugkeertijd) [jaar]</value>
-  </data>
   <data name="FailureMechanismContributionContextProperties_ReturnPeriod_Value_for_ReturnPeriod_Must_be_in_Range_0_" xml:space="preserve">
     <value>De waarde voor de 'Norm (terugkeertijd)' moet in het bereik {0} liggen.</value>
   </data>
Index: Ringtoets/Integration/src/Ringtoets.Integration.Forms/PropertyClasses/FailureMechanismContributionProperties.cs
===================================================================
diff -u -r2e265dc8a3c902ebdfdcdf0f1071f9c3c872d822 -rffa34dc6feb3d5fdf246cb89f7e1c11990ccc960
--- Ringtoets/Integration/src/Ringtoets.Integration.Forms/PropertyClasses/FailureMechanismContributionProperties.cs	(.../FailureMechanismContributionProperties.cs)	(revision 2e265dc8a3c902ebdfdcdf0f1071f9c3c872d822)
+++ Ringtoets/Integration/src/Ringtoets.Integration.Forms/PropertyClasses/FailureMechanismContributionProperties.cs	(.../FailureMechanismContributionProperties.cs)	(revision ffa34dc6feb3d5fdf246cb89f7e1c11990ccc960)
@@ -111,24 +111,6 @@
 
         [PropertyOrder(2)]
         [ResourcesCategory(typeof(RingtoetsCommonFormsResources), nameof(RingtoetsCommonFormsResources.Categories_General))]
-        [ResourcesDisplayName(typeof(Resources), nameof(Resources.FailureMechanismContribution_ReturnPeriod_DisplayName))]
-        [ResourcesDescription(typeof(Resources), nameof(Resources.FailureMechanismContribution_ReturnPeriod_Description))]
-        public int ReturnPeriod
-        {
-            get
-            {
-                return Convert.ToInt32(1.0 / data.Norm);
-            }
-            set
-            {
-                double newNormValue = 1.0 / Convert.ToInt32(value);
-
-                PropertyChangeHelper.ChangePropertyAndNotify(() => assessmentSection.FailureMechanismContribution.Norm = newNormValue, normChangeHandler);
-            }
-        }
-
-        [PropertyOrder(2)]
-        [ResourcesCategory(typeof(RingtoetsCommonFormsResources), nameof(RingtoetsCommonFormsResources.Categories_General))]
         [ResourcesDisplayName(typeof(Resources), nameof(Resources.LowerLimitNorm_DisplayName))]
         [ResourcesDescription(typeof(Resources), nameof(Resources.LowerLimitNorm_Description))]
         public string LowerLimitNorm
@@ -137,6 +119,10 @@
             {
                 return ProbabilityFormattingHelper.Format(data.LowerLimitNorm);
             }
+            set
+            {
+                PropertyChangeHelper.ChangePropertyAndNotify(() => data.LowerLimitNorm = double.Parse(value), normChangeHandler);
+            }
         }
 
         [PropertyOrder(3)]
@@ -149,6 +135,10 @@
             {
                 return ProbabilityFormattingHelper.Format(data.SignalingNorm);
             }
+            set
+            {
+                PropertyChangeHelper.ChangePropertyAndNotify(() => data.SignalingNorm = double.Parse(value), normChangeHandler);
+            }
         }
 
         [PropertyOrder(4)]
@@ -162,6 +152,10 @@
             {
                 return data.NormativeNorm;
             }
+            set
+            {
+                PropertyChangeHelper.ChangePropertyAndNotify(() => data.NormativeNorm = value, normChangeHandler);
+            }
         }
     }
 }
\ No newline at end of file
Index: Ringtoets/Integration/test/Ringtoets.Integration.Forms.Test/PropertyClasses/FailureMechanismContributionPropertiesIntegrationTest.cs
===================================================================
diff -u -r2e265dc8a3c902ebdfdcdf0f1071f9c3c872d822 -rffa34dc6feb3d5fdf246cb89f7e1c11990ccc960
--- Ringtoets/Integration/test/Ringtoets.Integration.Forms.Test/PropertyClasses/FailureMechanismContributionPropertiesIntegrationTest.cs	(.../FailureMechanismContributionPropertiesIntegrationTest.cs)	(revision 2e265dc8a3c902ebdfdcdf0f1071f9c3c872d822)
+++ Ringtoets/Integration/test/Ringtoets.Integration.Forms.Test/PropertyClasses/FailureMechanismContributionPropertiesIntegrationTest.cs	(.../FailureMechanismContributionPropertiesIntegrationTest.cs)	(revision ffa34dc6feb3d5fdf246cb89f7e1c11990ccc960)
@@ -30,9 +30,9 @@
 using Ringtoets.Common.Data.AssessmentSection;
 using Ringtoets.Common.Data.Contribution;
 using Ringtoets.Common.Data.Hydraulics;
-using Ringtoets.Common.Data.Probability;
 using Ringtoets.Common.Data.Structures;
 using Ringtoets.Common.Data.TestUtil;
+using Ringtoets.Common.Forms.Helpers;
 using Ringtoets.GrassCoverErosionInwards.Data;
 using Ringtoets.GrassCoverErosionInwards.Data.TestUtil;
 using Ringtoets.HeightStructures.Data;
@@ -52,12 +52,167 @@
             "Alle berekende resultaten voor alle hydraulische randvoorwaardenlocaties zijn verwijderd.";
 
         private const string messageCalculationsremoved = "De resultaten van {0} berekeningen zijn verwijderd.";
+        private const string newLowerLimitNorm = "0.01";
+        private const string newSignalingNorm = "0.000001";
+        private const NormType newNormativeNorm = NormType.Signaling;
 
+        #region AllDataAndOutputSet
+
         [Test]
-        public void ReturnPeriodProperty_ValueChanged_ClearsDependentDataAndNotifiesObserversAndLogsMessages()
+        public void LowerLimitNorm_ValueChanged_ClearsDependentDataAndNotifiesObserversAndLogsMessages()
         {
+            SetPropertyAndVerifyNotifcationsAndOutputForAllDataSet(properties => properties.LowerLimitNorm = newLowerLimitNorm);
+        }
+
+        [Test]
+        public void SignalingNorm_ValueChanged_ClearsDependentDataAndNotifiesObserversAndLogsMessages()
+        {
+            SetPropertyAndVerifyNotifcationsAndOutputForAllDataSet(properties => properties.SignalingNorm = newSignalingNorm);
+        }
+
+        [Test]
+        public void NormativeNorm_ValueChanged_ClearsDependentDataAndNotifiesObserversAndLogsMessages()
+        {
+            SetPropertyAndVerifyNotifcationsAndOutputForAllDataSet(properties => properties.NormativeNorm = newNormativeNorm);
+        }
+
+        #endregion
+
+        #region NoPermissionGiven
+
+        [Test]
+        public void LowerLimitNorm_PermissionNotGiven_DoesnotClearDependentDataNorNotifiesObserversAndLogsMessages()
+        {
+            ChangeValueNoPermissionGivenAndVerifyNoNotifcationsAndOutputForAllDataSet(properties => properties.LowerLimitNorm = newLowerLimitNorm);
+        }
+
+        [Test]
+        public void SignalingNorm_PermissionNotGiven_DoesnotClearDependentDataNorNotifiesObserversAndLogsMessages()
+        {
+            ChangeValueNoPermissionGivenAndVerifyNoNotifcationsAndOutputForAllDataSet(properties => properties.SignalingNorm = newSignalingNorm);
+        }
+
+        [Test]
+        public void NormativeNorm_PermissionNotGiven_DoesnotClearDependentDataNorNotifiesObserversAndLogsMessages()
+        {
+            ChangeValueNoPermissionGivenAndVerifyNoNotifcationsAndOutputForAllDataSet(properties => properties.NormativeNorm = newNormativeNorm);
+        }
+
+        #endregion
+
+        #region HydraulicBoundarySetAndCalculationsNoOutput
+
+        [Test]
+        public void LowerLimitNorm_HydraulicBoundarySetAndCalculationsNoOutput_HydraulicBoundaryDatabaseObserversNotifiedAndMessagesLogged()
+        {
+            SetPropertyAndVerifyNotifcationsAndOutputForHydraulicBoundarySetAndCalculationsNoOutput(properties => properties.LowerLimitNorm = newLowerLimitNorm);
+        }
+
+        [Test]
+        public void SignalingNorm_HydraulicBoundarySetAndCalculationsNoOutput_HydraulicBoundaryDatabaseObserversNotifiedAndMessagesLogged()
+        {
+            SetPropertyAndVerifyNotifcationsAndOutputForHydraulicBoundarySetAndCalculationsNoOutput(properties => properties.SignalingNorm = newSignalingNorm);
+        }
+
+        [Test]
+        public void NormativeNorm_HydraulicBoundarySetAndCalculationsNoOutput_HydraulicBoundaryDatabaseObserversNotifiedAndMessagesLogged()
+        {
+            SetPropertyAndVerifyNotifcationsAndOutputForHydraulicBoundarySetAndCalculationsNoOutput(properties => properties.NormativeNorm = newNormativeNorm);
+        }
+
+        #endregion
+
+        #region HydraulicBoundaryLocationNoOutputAndCalculationWithOutput
+
+        [Test]
+        public void LowerLimitNorm_HydraulicBoundaryLocationNoOutputAndCalculationWithOutputAndValueChanged_CalculationObserverNotifiedAndMessageLogged()
+        {
+            SetPropertyAndVerifyNotifcationsAndOutputForHydraulicBoundaryLocationNoOutputAndCalculationWithOutput(properties => properties.LowerLimitNorm = newLowerLimitNorm);
+        }
+
+        [Test]
+        public void SignalingNorm_HydraulicBoundaryLocationNoOutputAndCalculationWithOutputAndValueChanged_CalculationObserverNotifiedAndMessageLogged()
+        {
+            SetPropertyAndVerifyNotifcationsAndOutputForHydraulicBoundaryLocationNoOutputAndCalculationWithOutput(properties => properties.SignalingNorm = newSignalingNorm);
+        }
+
+        [Test]
+        public void NormativeNorm_HydraulicBoundaryLocationNoOutputAndCalculationWithOutputAndValueChanged_CalculationObserverNotifiedAndMessageLogged()
+        {
+            SetPropertyAndVerifyNotifcationsAndOutputForHydraulicBoundaryLocationNoOutputAndCalculationWithOutput(properties => properties.NormativeNorm = newNormativeNorm);
+        }
+
+        #endregion
+
+        #region NoHydraulicBoundaryLocationNoOutputAndCalculationWithOutput
+
+        [Test]
+        public void LowerLimitNorm_NoHydraulicBoundaryLocationNoOutputAndCalculationWithOutputAndValueChanged_CalculationObserverNotifiedAndMessageLogged()
+        {
+            SetPropertyAndVerifyNotifcationsAndOutputForNoHydraulicBoundaryLocationNoOutputAndCalculationWithOutput(properties => properties.LowerLimitNorm = newLowerLimitNorm);
+        }
+
+        [Test]
+        public void SignalingNorm_NoHydraulicBoundaryLocationNoOutputAndCalculationWithOutputAndValueChanged_CalculationObserverNotifiedAndMessageLogged()
+        {
+            SetPropertyAndVerifyNotifcationsAndOutputForNoHydraulicBoundaryLocationNoOutputAndCalculationWithOutput(properties => properties.SignalingNorm = newSignalingNorm);
+        }
+
+        [Test]
+        public void NormativeNorm_NoHydraulicBoundaryLocationNoOutputAndCalculationWithOutputAndValueChanged_CalculationObserverNotifiedAndMessageLogged()
+        {
+            SetPropertyAndVerifyNotifcationsAndOutputForNoHydraulicBoundaryLocationNoOutputAndCalculationWithOutput(properties => properties.NormativeNorm = newNormativeNorm);
+        }
+
+        #endregion
+
+        #region HydraulicBoundaryLocationNoOutputAndNoCalculationsWithOutput
+
+        [Test]
+        public void LowerLimitNorm_HydraulicBoundaryLocationNoOutputAndNoCalculationsWithOutputAndValueChanged_NoObserversNotifiedAndMessagesLogged()
+        {
+            SetPropertyAndVerifyNotifcationsAndOutputForHydraulicBoundaryLocationNoOutputAndNoCalculationsWithOutput(properties => properties.LowerLimitNorm = newLowerLimitNorm);
+        }
+
+        [Test]
+        public void SignalingNorm_HydraulicBoundaryLocationNoOutputAndNoCalculationsWithOutputAndValueChanged_NoObserversNotifiedAndMessagesLogged()
+        {
+            SetPropertyAndVerifyNotifcationsAndOutputForHydraulicBoundaryLocationNoOutputAndNoCalculationsWithOutput(properties => properties.SignalingNorm = newSignalingNorm);
+        }
+
+        [Test]
+        public void NormativeNorm_HydraulicBoundaryLocationNoOutputAndNoCalculationsWithOutputAndValueChanged_NoObserversNotifiedAndMessagesLogged()
+        {
+            SetPropertyAndVerifyNotifcationsAndOutputForHydraulicBoundaryLocationNoOutputAndNoCalculationsWithOutput(properties => properties.NormativeNorm = newNormativeNorm);
+        }
+
+        #endregion
+
+        #region NoHydraulicBoundaryDatabaseAndNoCalculationsWithOutput
+
+        [Test]
+        public void LowerLimitNorm_NoHydraulicBoundaryDatabaseAndNoCalculationsWithOutputAndValueChanged_NoObserversNotifiedAndMessagesLogged()
+        {
+            SetPropertyAndVerifyNotifcationsAndOutputForNoHydraulicBoundaryDatabaseAndNoCalculationsWithOutput(properties => properties.LowerLimitNorm = newLowerLimitNorm);
+        }
+
+        [Test]
+        public void SignalingNorm_NoHydraulicBoundaryDatabaseAndNoCalculationsWithOutputAndValueChanged_NoObserversNotifiedAndMessagesLogged()
+        {
+            SetPropertyAndVerifyNotifcationsAndOutputForNoHydraulicBoundaryDatabaseAndNoCalculationsWithOutput(properties => properties.SignalingNorm = newSignalingNorm);
+        }
+
+        [Test]
+        public void NormativeNorm_NoHydraulicBoundaryDatabaseAndNoCalculationsWithOutputAndValueChanged_NoObserversNotifiedAndMessagesLogged()
+        {
+            SetPropertyAndVerifyNotifcationsAndOutputForNoHydraulicBoundaryDatabaseAndNoCalculationsWithOutput(properties => properties.NormativeNorm = newNormativeNorm);
+        }
+
+        #endregion
+
+        private void SetPropertyAndVerifyNotifcationsAndOutputForAllDataSet(Action<FailureMechanismContributionProperties> setPropertyAction)
+        {
             // Setup
-            const int newReturnPeriod = 200;
             const int numberOfCalculations = 3;
 
             TestHydraulicBoundaryLocation hydraulicBoundaryLocation = TestHydraulicBoundaryLocation.CreateFullyCalculated();
@@ -105,8 +260,8 @@
             FailureMechanismContribution failureMechanismContribution = assessmentSection.FailureMechanismContribution;
 
             var mockRepository = new MockRepository();
-            var observer = mockRepository.StrictMock<IObserver>();
-            observer.Expect(o => o.UpdateObserver());
+            var failureMechanismContributionObserver = mockRepository.StrictMock<IObserver>();
+            failureMechanismContributionObserver.Expect(o => o.UpdateObserver());
 
             var pipingCalculationObserver = mockRepository.StrictMock<IObserver>();
             pipingCalculationObserver.Expect(o => o.UpdateObserver());
@@ -126,7 +281,7 @@
             var viewCommands = mockRepository.Stub<IViewCommands>();
             mockRepository.ReplayAll();
 
-            failureMechanismContribution.Attach(observer);
+            failureMechanismContribution.Attach(failureMechanismContributionObserver);
             hydraulicBoundaryDatabase.Attach(hydraulicBoundaryDatabaseObserver);
 
             emptyPipingCalculation.Attach(emptyPipingCalculationObserver);
@@ -145,26 +300,14 @@
                 new FailureMechanismContributionNormChangeHandler(assessmentSection),
                 new AssessmentSectionCompositionChangeHandler(viewCommands));
 
-            // Precondition
-            int originalReturnPeriodValue = Convert.ToInt32(1.0 / failureMechanismContribution.Norm);
-            Assert.AreEqual(originalReturnPeriodValue, properties.ReturnPeriod);
-            Assert.IsTrue(hydraulicBoundaryLocation.WaveHeightCalculation.HasOutput);
-            Assert.IsTrue(hydraulicBoundaryLocation.DesignWaterLevelCalculation.HasOutput);
-            Assert.IsTrue(grassCoverErosionOutwardsHydraulicBoundaryLocation.WaveHeightCalculation.HasOutput);
-            Assert.IsTrue(grassCoverErosionOutwardsHydraulicBoundaryLocation.DesignWaterLevelCalculation.HasOutput);
-            Assert.IsNotNull(pipingCalculation.Output);
-            Assert.IsNotNull(pipingCalculation.SemiProbabilisticOutput);
-            Assert.IsNotNull(grassCoverErosionInwardsCalculation.Output);
-            Assert.IsNotNull(heightStructuresCalculation.Output);
-
             DialogBoxHandler = (name, wnd) =>
             {
                 var dialogTester = new MessageBoxTester(wnd);
                 dialogTester.ClickOk();
             };
 
             // Call
-            Action call = () => properties.ReturnPeriod = newReturnPeriod;
+            Action call = () => setPropertyAction(properties);
 
             // Assert
             TestHelper.AssertLogMessages(call, msgs =>
@@ -173,28 +316,135 @@
                 Assert.AreEqual(string.Format(messageCalculationsremoved, numberOfCalculations), messages[0]);
                 Assert.AreEqual(messageAllHydraulicBoundaryLocationOutputCleared, messages[1]);
             });
-            Assert.AreEqual(1.0 / 30000, failureMechanismContribution.Norm);
-            Assert.IsFalse(hydraulicBoundaryLocation.WaveHeightCalculation.HasOutput);
-            Assert.IsFalse(hydraulicBoundaryLocation.DesignWaterLevelCalculation.HasOutput);
-            Assert.IsFalse(grassCoverErosionOutwardsHydraulicBoundaryLocation.WaveHeightCalculation.HasOutput);
-            Assert.IsFalse(grassCoverErosionOutwardsHydraulicBoundaryLocation.DesignWaterLevelCalculation.HasOutput);
-            Assert.IsNull(pipingCalculation.Output);
-            Assert.IsNull(pipingCalculation.SemiProbabilisticOutput);
-            Assert.IsNull(grassCoverErosionInwardsCalculation.Output);
-            Assert.IsNull(heightStructuresCalculation.Output);
 
+            AssertNormValues(properties, failureMechanismContribution);
+
+            AssertLocationsOutputClear(hydraulicBoundaryLocation, grassCoverErosionOutwardsHydraulicBoundaryLocation);
+            AssertCalculationsOutputClear(pipingCalculation, grassCoverErosionInwardsCalculation, heightStructuresCalculation);
+
             mockRepository.VerifyAll();
         }
 
-        [Test]
-        public void ReturnPeriodProperty_HydraulicBoundarySetAndCalculationsNoOutput_HydraulicBoundaryDatabaseObserversNotifiedAndMessagesLogged()
+        private void ChangeValueNoPermissionGivenAndVerifyNoNotifcationsAndOutputForAllDataSet(Action<FailureMechanismContributionProperties> setPropertyAction)
         {
             // Setup
-            const int newReturnPeriod = 200;
+            TestHydraulicBoundaryLocation hydraulicBoundaryLocation = TestHydraulicBoundaryLocation.CreateFullyCalculated();
             var hydraulicBoundaryDatabase = new HydraulicBoundaryDatabase
             {
                 Locations =
                 {
+                    hydraulicBoundaryLocation
+                }
+            };
+
+            var assessmentSection = new AssessmentSection(AssessmentSectionComposition.Dike)
+            {
+                HydraulicBoundaryDatabase = hydraulicBoundaryDatabase
+            };
+
+            var emptyPipingCalculation = new PipingCalculation(new GeneralPipingInput());
+            var pipingCalculation = new PipingCalculation(new GeneralPipingInput())
+            {
+                Output = new TestPipingOutput(),
+                SemiProbabilisticOutput = new TestPipingSemiProbabilisticOutput()
+            };
+            var emptyGrassCoverErosionInwardsCalculation = new GrassCoverErosionInwardsCalculation();
+            var grassCoverErosionInwardsCalculation = new GrassCoverErosionInwardsCalculation
+            {
+                Output = new TestGrassCoverErosionInwardsOutput()
+            };
+            var emptyHeightStructuresCalculation = new StructuresCalculation<HeightStructuresInput>();
+            var heightStructuresCalculation = new StructuresCalculation<HeightStructuresInput>
+            {
+                Output = new TestStructuresOutput()
+            };
+
+            TestHydraulicBoundaryLocation grassCoverErosionOutwardsHydraulicBoundaryLocation = TestHydraulicBoundaryLocation.CreateFullyCalculated();
+
+            assessmentSection.GrassCoverErosionOutwards.HydraulicBoundaryLocations.Add(grassCoverErosionOutwardsHydraulicBoundaryLocation);
+
+            assessmentSection.PipingFailureMechanism.CalculationsGroup.Children.Add(emptyPipingCalculation);
+            assessmentSection.PipingFailureMechanism.CalculationsGroup.Children.Add(pipingCalculation);
+            assessmentSection.GrassCoverErosionInwards.CalculationsGroup.Children.Add(emptyGrassCoverErosionInwardsCalculation);
+            assessmentSection.GrassCoverErosionInwards.CalculationsGroup.Children.Add(grassCoverErosionInwardsCalculation);
+            assessmentSection.HeightStructures.CalculationsGroup.Children.Add(emptyHeightStructuresCalculation);
+            assessmentSection.HeightStructures.CalculationsGroup.Children.Add(heightStructuresCalculation);
+
+            FailureMechanismContribution failureMechanismContribution = assessmentSection.FailureMechanismContribution;
+
+            var mockRepository = new MockRepository();
+            var failureMechanismContributionObserver = mockRepository.StrictMock<IObserver>();
+            var pipingCalculationObserver = mockRepository.StrictMock<IObserver>();
+            var grassCoverErosionInwardsCalculationObserver = mockRepository.StrictMock<IObserver>();
+            var heightStructuresCalculationObserver = mockRepository.StrictMock<IObserver>();
+            var emptyPipingCalculationObserver = mockRepository.StrictMock<IObserver>();
+            var emptyGrassCoverErosionInwardsCalculationObserver = mockRepository.StrictMock<IObserver>();
+            var emptyHeightStructuresCalculationObserver = mockRepository.StrictMock<IObserver>();
+            var hydraulicBoundaryDatabaseObserver = mockRepository.StrictMock<IObserver>();
+            var grassCoverErosionOutwardsObserver = mockRepository.StrictMock<IObserver>();
+
+            var viewCommands = mockRepository.Stub<IViewCommands>();
+            mockRepository.ReplayAll();
+
+            failureMechanismContribution.Attach(failureMechanismContributionObserver);
+            hydraulicBoundaryDatabase.Attach(hydraulicBoundaryDatabaseObserver);
+
+            emptyPipingCalculation.Attach(emptyPipingCalculationObserver);
+            emptyGrassCoverErosionInwardsCalculation.Attach(emptyGrassCoverErosionInwardsCalculationObserver);
+            emptyHeightStructuresCalculation.Attach(emptyHeightStructuresCalculationObserver);
+
+            pipingCalculation.Attach(pipingCalculationObserver);
+            grassCoverErosionInwardsCalculation.Attach(grassCoverErosionInwardsCalculationObserver);
+            heightStructuresCalculation.Attach(heightStructuresCalculationObserver);
+
+            assessmentSection.GrassCoverErosionOutwards.HydraulicBoundaryLocations.Attach(grassCoverErosionOutwardsObserver);
+
+            var properties = new FailureMechanismContributionProperties(
+                failureMechanismContribution,
+                assessmentSection,
+                new FailureMechanismContributionNormChangeHandler(assessmentSection),
+                new AssessmentSectionCompositionChangeHandler(viewCommands));
+
+            double originalLowerLimitNorm = failureMechanismContribution.LowerLimitNorm;
+            double originalSignalingNorm = failureMechanismContribution.SignalingNorm;
+            NormType originalNormativeNorm = failureMechanismContribution.NormativeNorm;
+            double originalNorm = failureMechanismContribution.Norm;
+
+            DialogBoxHandler = (name, wnd) =>
+            {
+                var dialogTester = new MessageBoxTester(wnd);
+                dialogTester.ClickCancel();
+            };
+
+            // Call
+            Action call = () => setPropertyAction(properties);
+
+            // Assert
+            TestHelper.AssertLogMessagesCount(call, 0);
+            Assert.AreEqual(originalLowerLimitNorm, failureMechanismContribution.LowerLimitNorm);
+            Assert.AreEqual(originalSignalingNorm, failureMechanismContribution.SignalingNorm);
+            Assert.AreEqual(originalNormativeNorm, failureMechanismContribution.NormativeNorm);
+            Assert.AreEqual(originalNorm, failureMechanismContribution.Norm);
+
+            Assert.IsTrue(hydraulicBoundaryLocation.WaveHeightCalculation.HasOutput);
+            Assert.IsTrue(hydraulicBoundaryLocation.DesignWaterLevelCalculation.HasOutput);
+            Assert.IsTrue(grassCoverErosionOutwardsHydraulicBoundaryLocation.WaveHeightCalculation.HasOutput);
+            Assert.IsTrue(grassCoverErosionOutwardsHydraulicBoundaryLocation.DesignWaterLevelCalculation.HasOutput);
+            Assert.IsNotNull(pipingCalculation.Output);
+            Assert.IsNotNull(pipingCalculation.SemiProbabilisticOutput);
+            Assert.IsNotNull(grassCoverErosionInwardsCalculation.Output);
+            Assert.IsNotNull(heightStructuresCalculation.Output);
+
+            mockRepository.VerifyAll();
+        }
+
+        private void SetPropertyAndVerifyNotifcationsAndOutputForHydraulicBoundarySetAndCalculationsNoOutput(Action<FailureMechanismContributionProperties> setPropertyAction)
+        {
+            // Setup
+            var hydraulicBoundaryDatabase = new HydraulicBoundaryDatabase
+            {
+                Locations =
+                {
                     TestHydraulicBoundaryLocation.CreateFullyCalculated()
                 }
             };
@@ -239,36 +489,27 @@
 
             HydraulicBoundaryLocation hydraulicBoundaryLocation = assessmentSection.HydraulicBoundaryDatabase.Locations[0];
 
-            // Precondition
-            int originalReturnPeriodValue = Convert.ToInt32(1.0 / failureMechanismContribution.Norm);
-            Assert.AreEqual(originalReturnPeriodValue, properties.ReturnPeriod);
-            Assert.IsFalse(double.IsNaN(hydraulicBoundaryLocation.WaveHeight));
-            Assert.IsFalse(double.IsNaN(hydraulicBoundaryLocation.DesignWaterLevel));
-
             DialogBoxHandler = (name, wnd) =>
             {
                 var dialogTester = new MessageBoxTester(wnd);
                 dialogTester.ClickOk();
             };
 
             // Call
-            Action call = () => properties.ReturnPeriod = newReturnPeriod;
+            Action call = () => setPropertyAction(properties);
 
             // Assert
             TestHelper.AssertLogMessageIsGenerated(call, messageAllHydraulicBoundaryLocationOutputCleared, 1);
 
-            Assert.AreEqual(1.0 / 30000, failureMechanismContribution.Norm);
-            Assert.IsNaN(hydraulicBoundaryLocation.WaveHeight);
-            Assert.IsNaN(hydraulicBoundaryLocation.DesignWaterLevel);
+            AssertNormValues(properties, failureMechanismContribution);
+            AssertLocationsOutputClear(hydraulicBoundaryLocation);
 
             mockRepository.VerifyAll();
         }
 
-        [Test]
-        public void ReturnPeriodProperty_HydraulicBoundaryLocationNoOutputAndCalculationWithOutputAndValueChanged_CalculationObserverNotifiedAndMessageLogged()
+        private void SetPropertyAndVerifyNotifcationsAndOutputForHydraulicBoundaryLocationNoOutputAndCalculationWithOutput(Action<FailureMechanismContributionProperties> setPropertyAction)
         {
             // Setup
-            const int newReturnPeriod = 200;
             const int numberOfCalculations = 3;
 
             var hydraulicBoundaryDatabase = new HydraulicBoundaryDatabase();
@@ -341,42 +582,29 @@
                 new FailureMechanismContributionNormChangeHandler(assessmentSection),
                 new AssessmentSectionCompositionChangeHandler(viewCommands));
 
-            // Precondition
-            int originalReturnPeriodValue = Convert.ToInt32(1.0 / failureMechanismContribution.Norm);
-            Assert.AreEqual(originalReturnPeriodValue, properties.ReturnPeriod);
-            Assert.IsNotNull(pipingCalculation.Output);
-            Assert.IsNotNull(pipingCalculation.SemiProbabilisticOutput);
-            Assert.IsNotNull(grassCoverErosionInwardsCalculation.Output);
-            Assert.IsNotNull(heightStructuresCalculation.Output);
-
             DialogBoxHandler = (name, wnd) =>
             {
                 var dialogTester = new MessageBoxTester(wnd);
                 dialogTester.ClickOk();
             };
 
             // Call
-            Action call = () => properties.ReturnPeriod = newReturnPeriod;
+            Action call = () => setPropertyAction(properties);
 
             // Assert
             string expectedMessage = string.Format(messageCalculationsremoved,
                                                    numberOfCalculations);
             TestHelper.AssertLogMessageIsGenerated(call, expectedMessage, 1);
 
-            Assert.AreEqual(1.0 / 30000, failureMechanismContribution.Norm);
-            Assert.IsNull(pipingCalculation.Output);
-            Assert.IsNull(pipingCalculation.SemiProbabilisticOutput);
-            Assert.IsNull(grassCoverErosionInwardsCalculation.Output);
-            Assert.IsNull(heightStructuresCalculation.Output);
+            AssertNormValues(properties, failureMechanismContribution);
+            AssertCalculationsOutputClear(pipingCalculation, grassCoverErosionInwardsCalculation, heightStructuresCalculation);
 
             mockRepository.VerifyAll();
         }
 
-        [Test]
-        public void ReturnPeriodProperty_NoHydraulicBoundaryLocationNoOutputAndCalculationWithOutputAndValueChanged_CalculationObserverNotifiedAndMessageLogged()
+        private void SetPropertyAndVerifyNotifcationsAndOutputForNoHydraulicBoundaryLocationNoOutputAndCalculationWithOutput(Action<FailureMechanismContributionProperties> setPropertyAction)
         {
             // Setup
-            const int newReturnPeriod = 200;
             const int numberOfCalculations = 3;
 
             var assessmentSection = new AssessmentSection(AssessmentSectionComposition.Dike);
@@ -440,43 +668,29 @@
                 new FailureMechanismContributionNormChangeHandler(assessmentSection),
                 new AssessmentSectionCompositionChangeHandler(viewCommands));
 
-            // Precondition
-            int originalReturnPeriodValue = Convert.ToInt32(1.0 / failureMechanismContribution.Norm);
-            Assert.AreEqual(originalReturnPeriodValue, properties.ReturnPeriod);
-            Assert.IsNotNull(pipingCalculation.Output);
-            Assert.IsNotNull(pipingCalculation.SemiProbabilisticOutput);
-            Assert.IsNotNull(grassCoverErosionInwardsCalculation.Output);
-            Assert.IsNotNull(heightStructuresCalculation.Output);
-
             DialogBoxHandler = (name, wnd) =>
             {
                 var dialogTester = new MessageBoxTester(wnd);
                 dialogTester.ClickOk();
             };
 
             // Call
-            Action call = () => properties.ReturnPeriod = newReturnPeriod;
+            Action call = () => setPropertyAction(properties);
 
             // Assert
             string expectedMessage = string.Format(messageCalculationsremoved,
                                                    numberOfCalculations);
             TestHelper.AssertLogMessageIsGenerated(call, expectedMessage, 1);
 
-            Assert.AreEqual(1.0 / 30000, failureMechanismContribution.Norm);
-            Assert.IsNull(pipingCalculation.Output);
-            Assert.IsNull(pipingCalculation.SemiProbabilisticOutput);
-            Assert.IsNull(grassCoverErosionInwardsCalculation.Output);
-            Assert.IsNull(heightStructuresCalculation.Output);
+            AssertNormValues(properties, failureMechanismContribution);
+            AssertCalculationsOutputClear(pipingCalculation, grassCoverErosionInwardsCalculation, heightStructuresCalculation);
 
             mockRepository.VerifyAll();
         }
 
-        [Test]
-        public void ReturnPeriodProperty_HydraulicBoundaryLocationNoOutputAndNoCalculationsWithOutputAndValueChanged_NoObserversNotifiedAndMessagesLogged()
+        private void SetPropertyAndVerifyNotifcationsAndOutputForHydraulicBoundaryLocationNoOutputAndNoCalculationsWithOutput(Action<FailureMechanismContributionProperties> setPropertyAction)
         {
             // Setup
-            const int newReturnPeriod = 200;
-
             var hydraulicBoundaryDatabase = new HydraulicBoundaryDatabase();
             hydraulicBoundaryDatabase.Locations.Add(new TestHydraulicBoundaryLocation());
 
@@ -516,36 +730,29 @@
                 new FailureMechanismContributionNormChangeHandler(assessmentSection),
                 new AssessmentSectionCompositionChangeHandler(viewCommands));
 
-            // Precondition
-            int originalReturnPeriodValue = Convert.ToInt32(1.0 / failureMechanismContribution.Norm);
-            Assert.AreEqual(originalReturnPeriodValue, properties.ReturnPeriod);
-
             DialogBoxHandler = (name, wnd) =>
             {
                 var dialogTester = new MessageBoxTester(wnd);
                 dialogTester.ClickOk();
             };
 
             // Call
-            Action call = () => properties.ReturnPeriod = newReturnPeriod;
+            Action call = () => setPropertyAction(properties);
 
             // Assert
             TestHelper.AssertLogMessagesCount(call, 0);
-            Assert.AreEqual(1.0 / 30000, failureMechanismContribution.Norm);
+            AssertNormValues(properties, failureMechanismContribution);
 
             mockRepository.VerifyAll(); // No update observer expected.
         }
 
-        [Test]
-        public void ReturnPeriodProperty_NoHydraulicBoundaryDatabaseAndNoCalculationsWithOutputAndValueChanged_NoObserversNotifiedAndMessagesLogged()
+        private void SetPropertyAndVerifyNotifcationsAndOutputForNoHydraulicBoundaryDatabaseAndNoCalculationsWithOutput(Action<FailureMechanismContributionProperties> setPropertyAction)
         {
             // Setup
             var mockRepository = new MockRepository();
             var viewCommands = mockRepository.Stub<IViewCommands>();
             mockRepository.ReplayAll();
 
-            const int newReturnPeriod = 200;
-
             var assessmentSection = new AssessmentSection(AssessmentSectionComposition.Dike);
 
             var emptyPipingCalculation = new PipingCalculation(new GeneralPipingInput());
@@ -564,18 +771,55 @@
                 new FailureMechanismContributionNormChangeHandler(assessmentSection),
                 new AssessmentSectionCompositionChangeHandler(viewCommands));
 
-            // Precondition
-            int originalReturnPeriodValue = Convert.ToInt32(1.0 / failureMechanismContribution.Norm);
-            Assert.AreEqual(originalReturnPeriodValue, properties.ReturnPeriod);
+            DialogBoxHandler = (name, wnd) =>
+            {
+                var dialogTester = new MessageBoxTester(wnd);
+                dialogTester.ClickOk();
+            };
 
             // Call
-            failureMechanismContribution.Norm = 1.0 / newReturnPeriod;
-            Action call = () => failureMechanismContribution.NotifyObservers();
+            Action call = () => setPropertyAction(properties);
 
             // Assert
             TestHelper.AssertLogMessagesCount(call, 0);
-            Assert.AreEqual(1.0 / 30000, failureMechanismContribution.Norm);
+            AssertNormValues(properties, failureMechanismContribution);
             mockRepository.VerifyAll();
         }
+
+        #region Asserts
+
+        private static void AssertCalculationsOutputClear(PipingCalculation pipingCalculation,
+                                                          GrassCoverErosionInwardsCalculation grassCoverErosionInwardsCalculation,
+                                                          StructuresCalculation<HeightStructuresInput> heightStructuresCalculation)
+        {
+            Assert.IsNull(pipingCalculation.Output);
+            Assert.IsNull(pipingCalculation.SemiProbabilisticOutput);
+            Assert.IsNull(grassCoverErosionInwardsCalculation.Output);
+            Assert.IsNull(heightStructuresCalculation.Output);
+        }
+
+        private static void AssertLocationsOutputClear(params HydraulicBoundaryLocation[] hydraulicBoundaryLocations)
+        {
+            foreach (HydraulicBoundaryLocation hydraulicBoundaryLocation in hydraulicBoundaryLocations)
+            {
+                Assert.IsFalse(hydraulicBoundaryLocation.WaveHeightCalculation.HasOutput);
+                Assert.IsFalse(hydraulicBoundaryLocation.DesignWaterLevelCalculation.HasOutput);
+            }
+        }
+
+        private static void AssertNormValues(FailureMechanismContributionProperties properties, FailureMechanismContribution failureMechanismContribution)
+        {
+            Assert.AreEqual(properties.LowerLimitNorm, ProbabilityFormattingHelper.Format(failureMechanismContribution.LowerLimitNorm));
+            Assert.AreEqual(properties.SignalingNorm, ProbabilityFormattingHelper.Format(failureMechanismContribution.SignalingNorm));
+            Assert.AreEqual(properties.NormativeNorm, failureMechanismContribution.NormativeNorm);
+
+            double expectedNorm = failureMechanismContribution.NormativeNorm == NormType.LowerLimit
+                                      ? failureMechanismContribution.LowerLimitNorm
+                                      : failureMechanismContribution.SignalingNorm;
+
+            Assert.AreEqual(expectedNorm, failureMechanismContribution.Norm);
+        }
+
+        #endregion
     }
 }
\ No newline at end of file
Index: Ringtoets/Integration/test/Ringtoets.Integration.Forms.Test/PropertyClasses/FailureMechanismContributionPropertiesTest.cs
===================================================================
diff -u -r2e265dc8a3c902ebdfdcdf0f1071f9c3c872d822 -rffa34dc6feb3d5fdf246cb89f7e1c11990ccc960
--- Ringtoets/Integration/test/Ringtoets.Integration.Forms.Test/PropertyClasses/FailureMechanismContributionPropertiesTest.cs	(.../FailureMechanismContributionPropertiesTest.cs)	(revision 2e265dc8a3c902ebdfdcdf0f1071f9c3c872d822)
+++ Ringtoets/Integration/test/Ringtoets.Integration.Forms.Test/PropertyClasses/FailureMechanismContributionPropertiesTest.cs	(.../FailureMechanismContributionPropertiesTest.cs)	(revision ffa34dc6feb3d5fdf246cb89f7e1c11990ccc960)
@@ -20,8 +20,8 @@
 // All rights reserved.
 
 using System;
-using System.Collections.Generic;
 using System.ComponentModel;
+using System.Globalization;
 using System.Linq;
 using Core.Common.Base;
 using Core.Common.Gui.Commands;
@@ -36,10 +36,10 @@
 using Ringtoets.Common.Data.FailureMechanism;
 using Ringtoets.Common.Forms.Helpers;
 using Ringtoets.Common.Forms.PropertyClasses;
+using Ringtoets.Common.Forms.TestUtil;
 using Ringtoets.Integration.Data;
 using Ringtoets.Integration.Forms.PropertyClasses;
 using Ringtoets.Integration.Plugin.Handlers;
-using Ringtoets.Integration.TestUtils;
 
 namespace Ringtoets.Integration.Forms.Test.PropertyClasses
 {
@@ -166,7 +166,7 @@
 
             PropertyDescriptorCollection dynamicProperties = PropertiesTestHelper.GetAllVisiblePropertyDescriptors(properties);
 
-            Assert.AreEqual(5, dynamicProperties.Count);
+            Assert.AreEqual(4, dynamicProperties.Count);
 
             const string expectedCategory = "Algemeen";
 
@@ -176,33 +176,24 @@
                                                                             "Trajecttype",
                                                                             "Selecteer het type traject, bepalend voor de faalkansbegroting.");
 
-            PropertyDescriptor returnPeriodProperty = dynamicProperties[1];
-            PropertiesTestHelper.AssertRequiredPropertyDescriptorProperties(returnPeriodProperty,
-                                                                            expectedCategory,
-                                                                            "Norm (terugkeertijd) [jaar]",
-                                                                            "Terugkeertijd van de norm, gelijk aan 1/norm.");
-
-            PropertyDescriptor lowerLevelNormProperty = dynamicProperties[2];
+            PropertyDescriptor lowerLevelNormProperty = dynamicProperties[1];
             PropertiesTestHelper.AssertRequiredPropertyDescriptorProperties(lowerLevelNormProperty,
                                                                             expectedCategory,
                                                                             "Ondergrens [1/jaar]",
-                                                                            "Overstromingskans van het dijktraject die hoort bij het minimale beschermingsniveau dat de kering moet bieden.",
-                                                                            true);
+                                                                            "Overstromingskans van het dijktraject die hoort bij het minimale beschermingsniveau dat de kering moet bieden.");
 
-            PropertyDescriptor signalingNormProperty = dynamicProperties[3];
+            PropertyDescriptor signalingNormProperty = dynamicProperties[2];
             PropertiesTestHelper.AssertRequiredPropertyDescriptorProperties(signalingNormProperty,
                                                                             expectedCategory,
                                                                             "Signaleringswaarde [1/jaar]",
-                                                                            "Overstromingskans van het dijktraject waarvan overschrijding gemeld moet worden aan de Minister van I en M.",
-                                                                            true);
+                                                                            "Overstromingskans van het dijktraject waarvan overschrijding gemeld moet worden aan de Minister van I en M.");
 
-            PropertyDescriptor normativeNormProperty = dynamicProperties[4];
+            PropertyDescriptor normativeNormProperty = dynamicProperties[3];
             Assert.IsInstanceOf<EnumTypeConverter>(normativeNormProperty.Converter);
             PropertiesTestHelper.AssertRequiredPropertyDescriptorProperties(normativeNormProperty,
                                                                             expectedCategory,
                                                                             "Norm van het dijktraject",
-                                                                            "De kans die wordt gebruikt als de norm van het dijktraject.",
-                                                                            true);
+                                                                            "De kans die wordt gebruikt als de norm van het dijktraject.");
         }
 
         [Test]
@@ -238,85 +229,21 @@
         }
 
         [Test]
-        public void GivenReturnPeriod_WhenConfirmingReturnPeriodValueChange_ThenReturnPeriodSetAndNotifiesObserver()
+        public void LowerLimitNorm_Always_ContributionNotifiedAndPropertyChangedCalled()
         {
-            // Given
-            var assessmentSection = new AssessmentSection(AssessmentSectionComposition.Dike);
-            FailureMechanismContribution failureMechanismContribution = assessmentSection.FailureMechanismContribution;
-
-            var normChangeHandler = new FailureMechanismContributionNormChangeHandler(assessmentSection);
-
-            var mocks = new MockRepository();
-            var compositionChangeHandler = mocks.Stub<IAssessmentSectionCompositionChangeHandler>();
-            mocks.ReplayAll();
-
-            var observer = mocks.StrictMock<IObserver>();
-            failureMechanismContribution.Attach(observer);
-
-            observer.Expect(o => o.UpdateObserver());
-
-            mocks.ReplayAll();
-
-            var properties = new FailureMechanismContributionProperties(
-                failureMechanismContribution,
-                assessmentSection,
-                normChangeHandler,
-                compositionChangeHandler);
-
-            DialogBoxHandler = (name, wnd) =>
-            {
-                var messageBox = new MessageBoxTester(wnd);
-                messageBox.ClickOk();
-            };
-
-            // When
-            const int newReturnPeriod = 200;
-            properties.ReturnPeriod = newReturnPeriod;
-
-            // Then
-            Assert.AreEqual(30000, properties.ReturnPeriod);
-            Assert.AreEqual(1.0 / 30000, failureMechanismContribution.Norm);
-            mocks.VerifyAll();
+            SetPropertyAndVerifyNotifcationsAndOutputForCalculation(properties => properties.LowerLimitNorm = 0.01.ToString(CultureInfo.CurrentCulture));
         }
 
         [Test]
-        public void GivenReturnPeriod_WhenCancelingReturnPeriodValueChange_ThenDataSameObserversNotNotified()
+        public void SignalingNorm_Always_ContributionNotifiedAndPropertyChangedCalled()
         {
-            // Given
-            var assessmentSection = new AssessmentSection(AssessmentSectionComposition.Dike);
-            FailureMechanismContribution failureMechanismContribution = assessmentSection.FailureMechanismContribution;
-            int originalReturnPeriod = Convert.ToInt32(1 / failureMechanismContribution.Norm);
+            SetPropertyAndVerifyNotifcationsAndOutputForCalculation(properties => properties.SignalingNorm = 0.00001.ToString(CultureInfo.CurrentCulture));
+        }
 
-            var normChangeHandler = new FailureMechanismContributionNormChangeHandler(assessmentSection);
-
-            var mocks = new MockRepository();
-            var compositionChangeHandler = mocks.Stub<IAssessmentSectionCompositionChangeHandler>();
-            mocks.ReplayAll();
-
-            var observer = mocks.StrictMock<IObserver>();
-            failureMechanismContribution.Attach(observer);
-            mocks.ReplayAll();
-
-            var properties = new FailureMechanismContributionProperties(
-                failureMechanismContribution,
-                assessmentSection,
-                normChangeHandler,
-                compositionChangeHandler);
-
-            DialogBoxHandler = (name, wnd) =>
-            {
-                var messageBox = new MessageBoxTester(wnd);
-                messageBox.ClickCancel();
-            };
-
-            // When
-            const int newReturnPeriod = 200;
-            properties.ReturnPeriod = newReturnPeriod;
-
-            // Then
-            Assert.AreEqual(originalReturnPeriod, properties.ReturnPeriod);
-            Assert.AreEqual(1.0 / originalReturnPeriod, failureMechanismContribution.Norm);
-            mocks.VerifyAll();
+        [Test]
+        public void NormativeNorm_Always_ContributionNotifiedAndPropertyChangedCalled()
+        {
+            SetPropertyAndVerifyNotifcationsAndOutputForCalculation(properties => properties.NormativeNorm = NormType.Signaling);
         }
 
         [Test]
@@ -402,82 +329,6 @@
         }
 
         [Test]
-        public void ReturnPeriod_ValueChanges_NotifiesChangedObjectsInAssessmentSection()
-        {
-            // Setup
-            const int returnPeriod = 200;
-
-            var assessmentSection = new AssessmentSection(AssessmentSectionComposition.Dike);
-
-            var mocks = new MockRepository();
-            var observable1 = mocks.StrictMock<IObservable>();
-            observable1.Expect(o => o.NotifyObservers());
-            var observable2 = mocks.StrictMock<IObservable>();
-            observable2.Expect(o => o.NotifyObservers());
-
-            var normChangeHandler = mocks.StrictMock<IObservablePropertyChangeHandler>();
-            normChangeHandler.Expect(h => h.SetPropertyValueAfterConfirmation(null)).IgnoreArguments()
-                             .Return(new[]
-                             {
-                                 observable1,
-                                 observable2
-                             });
-            var viewCommands = mocks.Stub<IViewCommands>();
-            mocks.ReplayAll();
-
-            var properties = new FailureMechanismContributionProperties(
-                assessmentSection.FailureMechanismContribution,
-                assessmentSection,
-                normChangeHandler,
-                new AssessmentSectionCompositionChangeHandler(viewCommands));
-
-            // Call
-            properties.ReturnPeriod = returnPeriod;
-
-            // Assert
-            mocks.VerifyAll();
-        }
-
-        [Test]
-        [TestCase(int.MinValue)]
-        [TestCase(int.MaxValue)]
-        [TestCase(9)]
-        [TestCase(1000001)]
-        [TestCase(0)]
-        [SetCulture("nl-NL")]
-        public void ReturnPeriod_InvalidValue_ThrowsArgumentOutOfRangeException(int invalidReturnPeriod)
-        {
-            // Setup
-            DialogBoxHandler = (name, wnd) =>
-            {
-                var tester = new MessageBoxTester(wnd);
-                tester.ClickOk();
-            };
-
-            AssessmentSection assessmentSection = TestDataGenerator.GetAssessmentSectionWithAllCalculationConfigurations();
-
-            var mocks = new MockRepository();
-            var viewCommands = mocks.Stub<IViewCommands>();
-            mocks.ReplayAll();
-
-            IEnumerable<IFailureMechanism> failureMechanisms = Enumerable.Empty<IFailureMechanism>();
-            var contribution = new FailureMechanismContribution(failureMechanisms, 1.1);
-
-            var properties = new FailureMechanismContributionProperties(
-                contribution,
-                assessmentSection,
-                new FailureMechanismContributionNormChangeHandler(assessmentSection),
-                new AssessmentSectionCompositionChangeHandler(viewCommands));
-
-            // Call
-            TestDelegate call = () => properties.ReturnPeriod = invalidReturnPeriod;
-
-            // Assert
-            const string expectedMessage = "De waarde van de norm moet in het bereik [0,000001, 0,1] liggen.";
-            TestHelper.AssertThrowsArgumentExceptionAndTestMessage<ArgumentOutOfRangeException>(call, expectedMessage);
-        }
-
-        [Test]
         [TestCase(AssessmentSectionComposition.Dike, AssessmentSectionComposition.Dune)]
         [TestCase(AssessmentSectionComposition.Dike, AssessmentSectionComposition.DikeAndDune)]
         [TestCase(AssessmentSectionComposition.Dune, AssessmentSectionComposition.Dike)]
@@ -520,6 +371,37 @@
             mocks.VerifyAll();
         }
 
+        private static void SetPropertyAndVerifyNotifcationsAndOutputForCalculation(Action<FailureMechanismContributionProperties> setProperty)
+        {
+            // Setup
+            var assessmentSection = new AssessmentSection(AssessmentSectionComposition.Dike);
+            FailureMechanismContribution failureMechanismContribution = assessmentSection.FailureMechanismContribution;
+
+            var mocks = new MockRepository();
+            var compositionChangeHandler = mocks.Stub<IAssessmentSectionCompositionChangeHandler>();
+            var observable = mocks.StrictMock<IObservable>();
+            observable.Expect(o => o.NotifyObservers());
+            mocks.ReplayAll();
+
+            var handler = new SetPropertyValueAfterConfirmationParameterTester(new[]
+            {
+                observable
+            });
+
+            var properties = new FailureMechanismContributionProperties(
+                failureMechanismContribution,
+                assessmentSection,
+                handler,
+                compositionChangeHandler);
+
+            // Call
+            setProperty(properties);
+
+            // Assert
+            Assert.IsTrue(handler.Called);
+            mocks.VerifyAll();
+        }
+
         private static FailureMechanismContribution CreateFailureMechanismContribution()
         {
             return new FailureMechanismContribution(Enumerable.Empty<IFailureMechanism>(), new Random(21).Next(0, 100));
Index: Ringtoets/Integration/test/Ringtoets.Integration.Forms.Test/Ringtoets.Integration.Forms.Test.csproj
===================================================================
diff -u -r5b300c761d0d8b3748f2ebacb051ff695293e4c6 -rffa34dc6feb3d5fdf246cb89f7e1c11990ccc960
--- Ringtoets/Integration/test/Ringtoets.Integration.Forms.Test/Ringtoets.Integration.Forms.Test.csproj	(.../Ringtoets.Integration.Forms.Test.csproj)	(revision 5b300c761d0d8b3748f2ebacb051ff695293e4c6)
+++ Ringtoets/Integration/test/Ringtoets.Integration.Forms.Test/Ringtoets.Integration.Forms.Test.csproj	(.../Ringtoets.Integration.Forms.Test.csproj)	(revision ffa34dc6feb3d5fdf246cb89f7e1c11990ccc960)
@@ -212,6 +212,10 @@
       <Project>{27E0A5C9-3ABF-426A-A3DA-7D0B83A218C8}</Project>
       <Name>Ringtoets.Piping.KernelWrapper.TestUtil</Name>
     </ProjectReference>
+    <ProjectReference Include="..\..\..\StabilityPointStructures\src\Ringtoets.StabilityPointStructures.Data\Ringtoets.StabilityPointStructures.Data.csproj">
+      <Project>{3D4B9740-8348-4434-8D77-B611FC6EE57F}</Project>
+      <Name>Ringtoets.StabilityPointStructures.Data</Name>
+    </ProjectReference>
     <ProjectReference Include="..\..\src\Ringtoets.Integration.Data\Ringtoets.Integration.Data.csproj">
       <Project>{11f1f874-45af-43e4-8ae5-15a5c9593e28}</Project>
       <Name>Ringtoets.Integration.Data</Name>