Index: Ringtoets/ClosingStructures/test/Ringtoets.ClosingStructures.Data.Test/ClosingStructuresInputTest.cs
===================================================================
diff -u -r11d8e22d745b1cbb5494ef49c77f6f767c2c74df -r12e5f6a6009617b69828d1b6e31b1eb3deda96b2
--- Ringtoets/ClosingStructures/test/Ringtoets.ClosingStructures.Data.Test/ClosingStructuresInputTest.cs	(.../ClosingStructuresInputTest.cs)	(revision 11d8e22d745b1cbb5494ef49c77f6f767c2c74df)
+++ Ringtoets/ClosingStructures/test/Ringtoets.ClosingStructures.Data.Test/ClosingStructuresInputTest.cs	(.../ClosingStructuresInputTest.cs)	(revision 12e5f6a6009617b69828d1b6e31b1eb3deda96b2)
@@ -331,16 +331,25 @@
         public void Properties_ModelFactorSuperCriticalFlow_ExpectedValues()
         {
             // Setup
+            var random = new Random(22);
             var input = new ClosingStructuresInput();
-            NormalDistribution modelFactorSuperCriticalFlow = GenerateNormalDistribution();
+            var mean = (RoundedDouble) (0.01 + random.NextDouble());
+            var expectedDistribution = new NormalDistribution(2)
+            {
+                Mean = mean,
+                StandardDeviation = input.ModelFactorSuperCriticalFlow.StandardDeviation
+            };
+            var distributionToSet = new NormalDistribution(5)
+            {
+                Mean = mean,
+                StandardDeviation = (RoundedDouble) random.NextDouble()
+            };
 
-            RoundedDouble initialStandardDeviation = input.ModelFactorSuperCriticalFlow.StandardDeviation;
-
             // Call
-            input.ModelFactorSuperCriticalFlow = modelFactorSuperCriticalFlow;
+            input.ModelFactorSuperCriticalFlow = distributionToSet;
 
             // Assert
-            AssertDistributionCorrectlySet(modelFactorSuperCriticalFlow, input.ModelFactorSuperCriticalFlow, initialStandardDeviation);
+            AssertDistributionCorrectlySet(input.ModelFactorSuperCriticalFlow, distributionToSet, expectedDistribution);
         }
 
         [Test]
@@ -364,44 +373,77 @@
         public void Properties_ThresholdHeightOpenWeir_ExpectedValues()
         {
             // Setup
+            var random = new Random(22);
             var input = new ClosingStructuresInput();
-            NormalDistribution thresholdHeightOpenWeir = GenerateNormalDistribution();
+            var mean = (RoundedDouble) (0.01 + random.NextDouble());
+            var standardDeviation = (RoundedDouble) (0.01 + random.NextDouble());
+            var expectedDistribution = new NormalDistribution(2)
+            {
+                Mean = mean,
+                StandardDeviation = standardDeviation
+            };
+            var distributionToSet = new NormalDistribution(5)
+            {
+                Mean = mean,
+                StandardDeviation = standardDeviation
+            };
 
             // Call
-            input.ThresholdHeightOpenWeir = thresholdHeightOpenWeir;
+            input.ThresholdHeightOpenWeir = distributionToSet;
 
             // Assert
-            AssertDistributionCorrectlySet(thresholdHeightOpenWeir, input.ThresholdHeightOpenWeir);
+            AssertDistributionCorrectlySet(input.ThresholdHeightOpenWeir, distributionToSet, expectedDistribution);
         }
 
         [Test]
         public void Properties_DrainCoefficient_ExpectedValues()
         {
             // Setup
+            var random = new Random(22);
             var input = new ClosingStructuresInput();
-            NormalDistribution drainCoefficient = GenerateNormalDistribution();
+            var mean = (RoundedDouble) (0.01 + random.NextDouble());
+            var expectedDistribution = new NormalDistribution(2)
+            {
+                Mean = mean,
+                StandardDeviation = input.DrainCoefficient.StandardDeviation
+            };
+            var distributionToSet = new NormalDistribution(5)
+            {
+                Mean = mean,
+                StandardDeviation = (RoundedDouble) random.NextDouble()
+            };
 
-            RoundedDouble initialStandardDeviation = input.DrainCoefficient.StandardDeviation;
-
             // Call
-            input.DrainCoefficient = drainCoefficient;
+            input.DrainCoefficient = distributionToSet;
 
             // Assert
-            AssertDistributionCorrectlySet(drainCoefficient, input.DrainCoefficient, initialStandardDeviation);
+            AssertDistributionCorrectlySet(input.DrainCoefficient, distributionToSet, expectedDistribution);
         }
 
         [Test]
         public void Properties_AreaFlowApertures_ExpectedValues()
         {
             // Setup
+            var random = new Random(22);
             var input = new ClosingStructuresInput();
-            LogNormalDistribution areaFlowApertures = GenerateLogNormalDistribution();
+            var mean = (RoundedDouble) (0.01 + random.NextDouble());
+            var standardDeviation = (RoundedDouble) (0.01 + random.NextDouble());
+            var expectedDistribution = new LogNormalDistribution(2)
+            {
+                Mean = mean,
+                StandardDeviation = standardDeviation
+            };
+            var distributionToSet = new LogNormalDistribution(5)
+            {
+                Mean = mean,
+                StandardDeviation = standardDeviation
+            };
 
             // Call
-            input.AreaFlowApertures = areaFlowApertures;
+            input.AreaFlowApertures = distributionToSet;
 
             // Assert
-            AssertDistributionCorrectlySet(areaFlowApertures, input.AreaFlowApertures);
+            AssertDistributionCorrectlySet(input.AreaFlowApertures, distributionToSet, expectedDistribution);
         }
 
         [Test]
@@ -488,84 +530,156 @@
         public void Properties_LevelCrestStructureNotClosing_ExpectedValues()
         {
             // Setup
+            var random = new Random(22);
             var input = new ClosingStructuresInput();
-            NormalDistribution levelCrestStructureNotClosing = GenerateNormalDistribution();
+            var mean = (RoundedDouble) (0.01 + random.NextDouble());
+            var standardDeviation = (RoundedDouble) (0.01 + random.NextDouble());
+            var expectedDistribution = new NormalDistribution(2)
+            {
+                Mean = mean,
+                StandardDeviation = standardDeviation
+            };
+            var distributionToSet = new NormalDistribution(5)
+            {
+                Mean = mean,
+                StandardDeviation = standardDeviation
+            };
 
             // Call
-            input.LevelCrestStructureNotClosing = levelCrestStructureNotClosing;
+            input.LevelCrestStructureNotClosing = distributionToSet;
 
             // Assert
-            AssertDistributionCorrectlySet(levelCrestStructureNotClosing, input.LevelCrestStructureNotClosing);
+            AssertDistributionCorrectlySet(input.LevelCrestStructureNotClosing, distributionToSet, expectedDistribution);
         }
 
         [Test]
         public void Properties_InsideWaterLevel_ExpectedValues()
         {
             // Setup
+            var random = new Random(22);
             var input = new ClosingStructuresInput();
-            NormalDistribution insideWaterLevel = GenerateNormalDistribution();
+            var mean = (RoundedDouble) (0.01 + random.NextDouble());
+            var standardDeviation = (RoundedDouble) (0.01 + random.NextDouble());
+            var expectedDistribution = new NormalDistribution(2)
+            {
+                Mean = mean,
+                StandardDeviation = standardDeviation
+            };
+            var distributionToSet = new NormalDistribution(5)
+            {
+                Mean = mean,
+                StandardDeviation = standardDeviation
+            };
 
             // Call
-            input.InsideWaterLevel = insideWaterLevel;
+            input.InsideWaterLevel = distributionToSet;
 
             // Assert
-            AssertDistributionCorrectlySet(insideWaterLevel, input.InsideWaterLevel);
+            AssertDistributionCorrectlySet(input.InsideWaterLevel, distributionToSet, expectedDistribution);
         }
 
         [Test]
         public void Properties_AllowedLevelIncreaseStorage_ExpectedValues()
         {
             // Setup
+            var random = new Random(22);
             var input = new ClosingStructuresInput();
-            LogNormalDistribution allowedLevelIncreaseStorage = GenerateLogNormalDistribution();
+            var mean = (RoundedDouble) (0.01 + random.NextDouble());
+            var standardDeviation = (RoundedDouble) (0.01 + random.NextDouble());
+            var expectedDistribution = new LogNormalDistribution(2)
+            {
+                Mean = mean,
+                StandardDeviation = standardDeviation
+            };
+            var distributionToSet = new LogNormalDistribution(5)
+            {
+                Mean = mean,
+                StandardDeviation = standardDeviation
+            };
 
             // Call
-            input.AllowedLevelIncreaseStorage = allowedLevelIncreaseStorage;
+            input.AllowedLevelIncreaseStorage = distributionToSet;
 
             // Assert
-            AssertDistributionCorrectlySet(allowedLevelIncreaseStorage, input.AllowedLevelIncreaseStorage);
+            AssertDistributionCorrectlySet(input.AllowedLevelIncreaseStorage, distributionToSet, expectedDistribution);
         }
 
         [Test]
         public void Properties_StorageStructureArea_ExpectedValues()
         {
             // Setup
+            var random = new Random(22);
             var input = new ClosingStructuresInput();
-            VariationCoefficientLogNormalDistribution storageStructureArea = GenerateVariationCoefficientLogNormalDistribution();
+            var mean = (RoundedDouble) (0.01 + random.NextDouble());
+            var variation = (RoundedDouble) (0.01 + random.NextDouble());
+            var expectedDistribution = new VariationCoefficientLogNormalDistribution(2)
+            {
+                Mean = mean,
+                CoefficientOfVariation = variation
+            };
+            var distributionToSet = new VariationCoefficientLogNormalDistribution(5)
+            {
+                Mean = mean,
+                CoefficientOfVariation = variation
+            };
 
             // Call
-            input.StorageStructureArea = storageStructureArea;
+            input.StorageStructureArea = distributionToSet;
 
             // Assert
-            AssertDistributionCorrectlySet(storageStructureArea, input.StorageStructureArea);
+            AssertDistributionCorrectlySet(input.StorageStructureArea, distributionToSet, expectedDistribution);
         }
 
         [Test]
         public void Properties_FlowWidthAtBottomProtection_ExpectedValues()
         {
             // Setup
+            var random = new Random(22);
             var input = new ClosingStructuresInput();
-            LogNormalDistribution flowWidthAtBottomProtection = GenerateLogNormalDistribution();
+            var mean = (RoundedDouble) (0.01 + random.NextDouble());
+            var standardDeviation = (RoundedDouble) (0.01 + random.NextDouble());
+            var expectedDistribution = new LogNormalDistribution(2)
+            {
+                Mean = mean,
+                StandardDeviation = standardDeviation
+            };
+            var distributionToSet = new LogNormalDistribution(5)
+            {
+                Mean = mean,
+                StandardDeviation = standardDeviation
+            };
 
             // Call
-            input.FlowWidthAtBottomProtection = flowWidthAtBottomProtection;
+            input.FlowWidthAtBottomProtection = distributionToSet;
 
             // Assert
-            AssertDistributionCorrectlySet(flowWidthAtBottomProtection, input.FlowWidthAtBottomProtection);
+            AssertDistributionCorrectlySet(input.FlowWidthAtBottomProtection, distributionToSet, expectedDistribution);
         }
 
         [Test]
         public void Properties_CriticalOvertoppingDischarge_ExpectedValues()
         {
             // Setup
+            var random = new Random(22);
             var input = new ClosingStructuresInput();
-            VariationCoefficientLogNormalDistribution criticalOvertoppingDischarge = GenerateVariationCoefficientLogNormalDistribution();
+            var mean = (RoundedDouble) (0.01 + random.NextDouble());
+            var variation = (RoundedDouble) (0.01 + random.NextDouble());
+            var expectedDistribution = new VariationCoefficientLogNormalDistribution(2)
+            {
+                Mean = mean,
+                CoefficientOfVariation = variation
+            };
+            var distributionToSet = new VariationCoefficientLogNormalDistribution(5)
+            {
+                Mean = mean,
+                CoefficientOfVariation = variation
+            };
 
             // Call
-            input.CriticalOvertoppingDischarge = criticalOvertoppingDischarge;
+            input.CriticalOvertoppingDischarge = distributionToSet;
 
             // Assert
-            AssertDistributionCorrectlySet(criticalOvertoppingDischarge, input.CriticalOvertoppingDischarge);
+            AssertDistributionCorrectlySet(input.CriticalOvertoppingDischarge, distributionToSet, expectedDistribution);
         }
 
         [Test]
@@ -604,14 +718,26 @@
         public void Properties_WidthFlowApertures_ExpectedValues()
         {
             // Setup
+            var random = new Random(22);
             var input = new ClosingStructuresInput();
-            VariationCoefficientNormalDistribution widthFlowApertures = GenerateVariationCoefficientNormalDistribution();
+            var mean = (RoundedDouble) (0.01 + random.NextDouble());
+            var variation = (RoundedDouble) (0.01 + random.NextDouble());
+            var expectedDistribution = new VariationCoefficientNormalDistribution(2)
+            {
+                Mean = mean,
+                CoefficientOfVariation = variation
+            };
+            var distributionToSet = new VariationCoefficientNormalDistribution(5)
+            {
+                Mean = mean,
+                CoefficientOfVariation = variation
+            };
 
             // Call
-            input.WidthFlowApertures = widthFlowApertures;
+            input.WidthFlowApertures = distributionToSet;
 
             // Assert
-            AssertDistributionCorrectlySet(widthFlowApertures, input.WidthFlowApertures);
+            AssertDistributionCorrectlySet(input.WidthFlowApertures, distributionToSet, expectedDistribution);
         }
 
         [Test]
@@ -635,16 +761,25 @@
         public void Properties_StormDuration_ExpectedValues()
         {
             // Setup
+            var random = new Random(22);
             var input = new ClosingStructuresInput();
-            VariationCoefficientLogNormalDistribution stormDuration = GenerateVariationCoefficientLogNormalDistribution();
+            var mean = (RoundedDouble) (0.01 + random.NextDouble());
+            var expectedDistribution = new VariationCoefficientLogNormalDistribution(2)
+            {
+                Mean = mean,
+                CoefficientOfVariation = input.StormDuration.CoefficientOfVariation
+            };
+            var distributionToSet = new VariationCoefficientLogNormalDistribution(5)
+            {
+                Mean = mean,
+                CoefficientOfVariation = (RoundedDouble) random.NextDouble()
+            };
 
-            RoundedDouble initialVariation = input.StormDuration.CoefficientOfVariation;
-
             // Call
-            input.StormDuration = stormDuration;
+            input.StormDuration = distributionToSet;
 
             // Assert
-            AssertDistributionCorrectlySet(stormDuration, input.StormDuration, initialVariation);
+            AssertDistributionCorrectlySet(input.StormDuration, distributionToSet, expectedDistribution);
         }
 
         [Test]
@@ -684,70 +819,16 @@
             Assert.AreEqual(expectedValue, actualValue, actualValue.GetAccuracy());
         }
 
-        private static LogNormalDistribution GenerateLogNormalDistribution()
+        private static void AssertDistributionCorrectlySet(IDistribution distributionToAssert, IDistribution setDistribution, IDistribution expectedDistribution)
         {
-            var random = new Random(22);
-            return new LogNormalDistribution(2)
-            {
-                Mean = (RoundedDouble) (0.01 + random.NextDouble()),
-                StandardDeviation = (RoundedDouble) random.NextDouble()
-            };
+            Assert.AreNotSame(setDistribution, distributionToAssert);
+            DistributionAssert.AreEqual(expectedDistribution, distributionToAssert);
         }
 
-        private static VariationCoefficientLogNormalDistribution GenerateVariationCoefficientLogNormalDistribution()
+        private static void AssertDistributionCorrectlySet(IVariationCoefficientDistribution distributionToAssert, IVariationCoefficientDistribution setDistribution, IVariationCoefficientDistribution expectedDistribution)
         {
-            var random = new Random(22);
-            return new VariationCoefficientLogNormalDistribution(2)
-            {
-                Mean = (RoundedDouble) (0.01 + random.NextDouble()),
-                CoefficientOfVariation = (RoundedDouble) random.NextDouble()
-            };
+            Assert.AreNotSame(setDistribution, distributionToAssert);
+            DistributionAssert.AreEqual(expectedDistribution, distributionToAssert);
         }
-
-        private static NormalDistribution GenerateNormalDistribution()
-        {
-            var random = new Random(22);
-            return new NormalDistribution(2)
-            {
-                Mean = (RoundedDouble) (0.01 + random.NextDouble()),
-                StandardDeviation = (RoundedDouble) random.NextDouble()
-            };
-        }
-
-        private static VariationCoefficientNormalDistribution GenerateVariationCoefficientNormalDistribution()
-        {
-            var random = new Random(22);
-            return new VariationCoefficientNormalDistribution(2)
-            {
-                Mean = (RoundedDouble) (0.01 + random.NextDouble()),
-                CoefficientOfVariation = (RoundedDouble) random.NextDouble()
-            };
-        }
-
-        private static void AssertDistributionCorrectlySet(IDistribution expectedDistribution, IDistribution distribution, RoundedDouble? initialStandardDeviation = null)
-        {
-            Assert.AreNotSame(expectedDistribution, distribution);
-
-            // If necessary, first adapt the expected distribution
-            if (initialStandardDeviation != null)
-            {
-                expectedDistribution.StandardDeviation = (RoundedDouble) initialStandardDeviation;
-            }
-
-            DistributionAssert.AreEqual(expectedDistribution, distribution);
-        }
-
-        private static void AssertDistributionCorrectlySet(IVariationCoefficientDistribution expectedDistribution, IVariationCoefficientDistribution distribution, RoundedDouble? initialCoefficientOfVariation = null)
-        {
-            Assert.AreNotSame(expectedDistribution, distribution);
-
-            // If necessary, first adapt the expected distribution
-            if (initialCoefficientOfVariation != null)
-            {
-                expectedDistribution.CoefficientOfVariation = (RoundedDouble) initialCoefficientOfVariation;
-            }
-
-            DistributionAssert.AreEqual(expectedDistribution, distribution);
-        }
     }
 }
\ No newline at end of file