Index: Ringtoets/GrassCoverErosionInwards/test/Ringtoets.GrassCoverErosionInwards.Utils.Test/GrassCoverErosionInwardsHelperTest.cs
===================================================================
diff -u -rd207738be4ce6f50f4e3e00839ea433acea10bbd -r4dcf687d02ad303a8b830cd11c7d15a6f3f25116
--- Ringtoets/GrassCoverErosionInwards/test/Ringtoets.GrassCoverErosionInwards.Utils.Test/GrassCoverErosionInwardsHelperTest.cs	(.../GrassCoverErosionInwardsHelperTest.cs)	(revision d207738be4ce6f50f4e3e00839ea433acea10bbd)
+++ Ringtoets/GrassCoverErosionInwards/test/Ringtoets.GrassCoverErosionInwards.Utils.Test/GrassCoverErosionInwardsHelperTest.cs	(.../GrassCoverErosionInwardsHelperTest.cs)	(revision 4dcf687d02ad303a8b830cd11c7d15a6f3f25116)
@@ -51,7 +51,7 @@
             TestDelegate call = () => GrassCoverErosionInwardsHelper.CollectCalculationsPerSegment(null, calculations);
 
             // Assert
-            var paramName = Assert.Throws<ArgumentNullException>(call).ParamName;
+            string paramName = Assert.Throws<ArgumentNullException>(call).ParamName;
             Assert.AreEqual("sectionResults", paramName);
         }
 
@@ -62,60 +62,73 @@
             TestDelegate call = () => GrassCoverErosionInwardsHelper.CollectCalculationsPerSegment(oneSectionResult, null);
 
             // Assert
-            var paramName = Assert.Throws<ArgumentNullException>(call).ParamName;
+            string paramName = Assert.Throws<ArgumentNullException>(call).ParamName;
             Assert.AreEqual("calculations", paramName);
         }
 
         [Test]
-        public void CollectCalculationsPerSegment_ValidEmptyData_EmptyDictionary()
+        public void CollectCalculationsPerSegment_ValidEmptySectionResults_EmptyDictionary()
         {
             // Setup
+            var emptySectionResults = new GrassCoverErosionInwardsFailureMechanismSectionResult[0];
+
+            // Call
+            Dictionary<string, IList<GrassCoverErosionInwardsCalculation>> collectCalculationsPerSegment = 
+                GrassCoverErosionInwardsHelper.CollectCalculationsPerSegment(emptySectionResults, twoCalculations);
+
+            // Assert
+            Assert.AreEqual(0, collectCalculationsPerSegment.Count);
+        }
+
+        [Test]
+        public void CollectCalculationsPerSegment_ValidEmptyCalculations_EmptyDictionary()
+        {
+            // Setup
             var calculations = new GrassCoverErosionInwardsCalculation[0];
 
             // Call
-            var collectCalculationsPerSegment = GrassCoverErosionInwardsHelper.CollectCalculationsPerSegment(oneSectionResult, calculations);
+            Dictionary<string, IList<GrassCoverErosionInwardsCalculation>> collectCalculationsPerSegment = 
+                GrassCoverErosionInwardsHelper.CollectCalculationsPerSegment(oneSectionResult, calculations);
 
             // Assert
             Assert.AreEqual(0, collectCalculationsPerSegment.Count);
         }
 
         [Test]
-        public void CollectCalculationsPerSegment_MultipleCalculationsInSegment_OneSegmentHasAllCalculations()
+        public void CollectCalculationsPerSegment_CalculationsWithoutDikeProfiles_EmptyDictionary()
         {
             // Setup
-            var calculations = new[]
-            {
-                new GrassCoverErosionInwardsCalculation
-                {
-                    InputParameters =
-                    {
-                        DikeProfile = new DikeProfile(new Point2D(1.1, 2.2), new RoughnessPoint[0], new Point2D[0])
-                    }
-                },
-                new GrassCoverErosionInwardsCalculation
-                {
-                    InputParameters =
-                    {
-                        DikeProfile = new DikeProfile(new Point2D(3.3, 4.4), new RoughnessPoint[0], new Point2D[0])
-                    }
-                }
+            GrassCoverErosionInwardsCalculation[] calculations = {
+                new GrassCoverErosionInwardsCalculation(),
+                new GrassCoverErosionInwardsCalculation()
             };
 
             // Call
-            var collectCalculationsPerSegment = GrassCoverErosionInwardsHelper.CollectCalculationsPerSegment(twoSectionResults, calculations);
+            Dictionary<string, IList<GrassCoverErosionInwardsCalculation>> collectCalculationsPerSegment = 
+                GrassCoverErosionInwardsHelper.CollectCalculationsPerSegment(oneSectionResult, calculations);
 
             // Assert
+            Assert.AreEqual(0, collectCalculationsPerSegment.Count);
+        }
+
+        [Test]
+        public void CollectCalculationsPerSegment_MultipleCalculationsInSegment_OneSegmentHasAllCalculations()
+        {
+            // Call
+            Dictionary<string, IList<GrassCoverErosionInwardsCalculation>> collectCalculationsPerSegment = 
+                GrassCoverErosionInwardsHelper.CollectCalculationsPerSegment(twoSectionResults, twoCalculations);
+
+            // Assert
             Assert.AreEqual(1, collectCalculationsPerSegment.Count);
-            Assert.IsTrue(collectCalculationsPerSegment.ContainsKey("firstSection"));
-            Assert.AreEqual(2, collectCalculationsPerSegment["firstSection"].Count);
+            Assert.IsTrue(collectCalculationsPerSegment.ContainsKey(firstSectionName));
+            CollectionAssert.AreEqual(twoCalculations, collectCalculationsPerSegment[firstSectionName]);
         }
 
         [Test]
         public void CollectCalculationsPerSegment_SingleCalculationPerSegment_OneCalculationPerSegment()
         {
             // Setup
-            var calculations = new[]
-            {
+            GrassCoverErosionInwardsCalculation[] calculations = {
                 new GrassCoverErosionInwardsCalculation
                 {
                     InputParameters =
@@ -133,12 +146,15 @@
             };
 
             // Call
-            var collectCalculationsPerSegment = GrassCoverErosionInwardsHelper.CollectCalculationsPerSegment(twoSectionResults, calculations);
+            Dictionary<string, IList<GrassCoverErosionInwardsCalculation>> collectCalculationsPerSegment = 
+                GrassCoverErosionInwardsHelper.CollectCalculationsPerSegment(twoSectionResults, calculations);
 
             // Assert
             Assert.AreEqual(2, collectCalculationsPerSegment.Count);
-            Assert.AreEqual(1, collectCalculationsPerSegment["firstSection"].Count);
-            Assert.AreEqual(1, collectCalculationsPerSegment["secondSection"].Count);
+            Assert.AreEqual(1, collectCalculationsPerSegment[firstSectionName].Count);
+            Assert.AreSame(calculations[0], collectCalculationsPerSegment[firstSectionName][0]);
+            Assert.AreEqual(1, collectCalculationsPerSegment[secondSectionName].Count);
+            Assert.AreSame(calculations[1], collectCalculationsPerSegment[secondSectionName][0]);
         }
 
         [Test]
@@ -161,7 +177,7 @@
             TestDelegate call = () => GrassCoverErosionInwardsHelper.FailureMechanismSectionForCalculation(null, calculation);
 
             // Assert
-            var paramName = Assert.Throws<ArgumentNullException>(call).ParamName;
+            string paramName = Assert.Throws<ArgumentNullException>(call).ParamName;
             Assert.AreEqual("sectionResults", paramName);
         }
 
@@ -172,24 +188,54 @@
             TestDelegate call = () => GrassCoverErosionInwardsHelper.FailureMechanismSectionForCalculation(oneSectionResult, null);
 
             // Assert
-            var paramName = Assert.Throws<ArgumentNullException>(call).ParamName;
+            string paramName = Assert.Throws<ArgumentNullException>(call).ParamName;
             Assert.AreEqual("calculation", paramName);
         }
 
         [Test]
+        public void FailureMechanismSectionForCalculation_CalculationWithoutDikeProfile_ReturnsNull()
+        {
+            // Setup
+            var calculation = new GrassCoverErosionInwardsCalculation();
+
+            // Call
+            FailureMechanismSection failureMechanismSection = 
+                GrassCoverErosionInwardsHelper.FailureMechanismSectionForCalculation(oneSectionResult, calculation);
+
+            // Assert
+            Assert.IsNull(failureMechanismSection);
+        }
+
+        [Test]
         public void FailureMechanismSectionForCalculation_SectionResultsEmpty_ReturnsNull()
         {
             // Setup
             var calculation = new GrassCoverErosionInwardsCalculation();
 
             // Call
-            var failureMechanismSection = GrassCoverErosionInwardsHelper.FailureMechanismSectionForCalculation(oneSectionResult, calculation);
+            FailureMechanismSection failureMechanismSection = 
+                GrassCoverErosionInwardsHelper.FailureMechanismSectionForCalculation(oneSectionResult, calculation);
 
             // Assert
             Assert.IsNull(failureMechanismSection);
         }
 
         [Test]
+        public void FailureMechanismSectionForCalculation_ValidEmptySectionResults_ReturnsNull()
+        {
+            // Setup
+            var emptySectionResults = new GrassCoverErosionInwardsFailureMechanismSectionResult[0];
+            var calculation = new GrassCoverErosionInwardsCalculation();
+
+            // Call
+            FailureMechanismSection failureMechanismSection = 
+                GrassCoverErosionInwardsHelper.FailureMechanismSectionForCalculation(emptySectionResults, calculation);
+
+            // Assert
+            Assert.IsNull(failureMechanismSection);
+        }
+
+        [Test]
         public void FailureMechanismSectionForCalculation_FirstSectionResultContainsCalculation_FailureMechanismSectionOfFirstSectionResult()
         {
             // Setup
@@ -202,7 +248,8 @@
             };
 
             // Call
-            var failureMechanismSection = GrassCoverErosionInwardsHelper.FailureMechanismSectionForCalculation(twoSectionResults, calculation);
+            FailureMechanismSection failureMechanismSection = 
+                GrassCoverErosionInwardsHelper.FailureMechanismSectionForCalculation(twoSectionResults, calculation);
 
             // Assert
             Assert.AreSame(twoSectionResults[0].Section, failureMechanismSection);
@@ -221,35 +268,54 @@
             };
 
             // Call
-            var failureMechanismSection = GrassCoverErosionInwardsHelper.FailureMechanismSectionForCalculation(twoSectionResults, calculation);
+            FailureMechanismSection failureMechanismSection = 
+                GrassCoverErosionInwardsHelper.FailureMechanismSectionForCalculation(twoSectionResults, calculation);
 
             // Assert
             Assert.AreSame(twoSectionResults[1].Section, failureMechanismSection);
         }
 
-        private readonly GrassCoverErosionInwardsFailureMechanismSectionResult[] oneSectionResult = new[]
-        {
+        private const string firstSectionName = "firstSection";
+        private const string secondSectionName = "secondSection";
+
+        private readonly GrassCoverErosionInwardsFailureMechanismSectionResult[] oneSectionResult = {
             new GrassCoverErosionInwardsFailureMechanismSectionResult(
                 new FailureMechanismSection("testFailureMechanismSection", new List<Point2D>
                 {
                     new Point2D(0.0, 0.0)
                 }))
         };
 
-        private readonly GrassCoverErosionInwardsFailureMechanismSectionResult[] twoSectionResults = new[]
-        {
+        private readonly GrassCoverErosionInwardsFailureMechanismSectionResult[] twoSectionResults = {
             new GrassCoverErosionInwardsFailureMechanismSectionResult(
-                new FailureMechanismSection("firstSection", new List<Point2D>
+                new FailureMechanismSection(firstSectionName, new List<Point2D>
                 {
                     new Point2D(0.0, 0.0),
                     new Point2D(10.0, 10.0),
                 })),
             new GrassCoverErosionInwardsFailureMechanismSectionResult(
-                new FailureMechanismSection("secondSection", new List<Point2D>
+                new FailureMechanismSection(secondSectionName, new List<Point2D>
                 {
                     new Point2D(11.0, 11.0),
                     new Point2D(100.0, 100.0),
                 }))
         };
+
+        private readonly GrassCoverErosionInwardsCalculation[] twoCalculations = {
+            new GrassCoverErosionInwardsCalculation
+            {
+                InputParameters =
+                {
+                    DikeProfile = new DikeProfile(new Point2D(1.1, 2.2), new RoughnessPoint[0], new Point2D[0])
+                }
+            },
+            new GrassCoverErosionInwardsCalculation
+            {
+                InputParameters =
+                {
+                    DikeProfile = new DikeProfile(new Point2D(3.3, 4.4), new RoughnessPoint[0], new Point2D[0])
+                }
+            }
+        };
     }
 }
\ No newline at end of file