Index: Ringtoets/ClosingStructures/test/Ringtoets.ClosingStructures.IO.Test/Configurations/ClosingStructuresCalculationConfigurationImporterTest.cs
===================================================================
diff -u -rf88343c0590cb04c7135ce141872940e59325927 -rf4c28926da2401b1fddbbe7f907fd663f0f5f4dc
--- Ringtoets/ClosingStructures/test/Ringtoets.ClosingStructures.IO.Test/Configurations/ClosingStructuresCalculationConfigurationImporterTest.cs	(.../ClosingStructuresCalculationConfigurationImporterTest.cs)	(revision f88343c0590cb04c7135ce141872940e59325927)
+++ Ringtoets/ClosingStructures/test/Ringtoets.ClosingStructures.IO.Test/Configurations/ClosingStructuresCalculationConfigurationImporterTest.cs	(.../ClosingStructuresCalculationConfigurationImporterTest.cs)	(revision f4c28926da2401b1fddbbe7f907fd663f0f5f4dc)
@@ -32,6 +32,7 @@
 using Ringtoets.ClosingStructures.IO.Configurations;
 using Ringtoets.Common.Data.Calculation;
 using Ringtoets.Common.Data.DikeProfiles;
+using Ringtoets.Common.Data.FailureMechanism;
 using Ringtoets.Common.Data.Hydraulics;
 using Ringtoets.Common.Data.Structures;
 using Ringtoets.Common.Data.TestUtil;
@@ -215,7 +216,8 @@
                                                                                  new CalculationGroup(),
                                                                                  Enumerable.Empty<HydraulicBoundaryLocation>(),
                                                                                  Enumerable.Empty<ForeshoreProfile>(),
-                                                                                 Enumerable.Empty<ClosingStructure>());
+                                                                                 Enumerable.Empty<ClosingStructure>(),
+                                                                                 new ClosingStructuresFailureMechanism());
 
             // Assert
             Assert.IsInstanceOf<CalculationConfigurationImporter<ClosingStructuresCalculationConfigurationReader, ClosingStructuresCalculationConfiguration>>(importer);
@@ -229,7 +231,8 @@
                                                                                             new CalculationGroup(),
                                                                                             null,
                                                                                             Enumerable.Empty<ForeshoreProfile>(),
-                                                                                            Enumerable.Empty<ClosingStructure>());
+                                                                                            Enumerable.Empty<ClosingStructure>(),
+                                                                                            new ClosingStructuresFailureMechanism());
 
             // Assert
             var exception = Assert.Throws<ArgumentNullException>(test);
@@ -244,7 +247,8 @@
                                                                                             new CalculationGroup(),
                                                                                             Enumerable.Empty<HydraulicBoundaryLocation>(),
                                                                                             null,
-                                                                                            Enumerable.Empty<ClosingStructure>());
+                                                                                            Enumerable.Empty<ClosingStructure>(),
+                                                                                            new ClosingStructuresFailureMechanism());
 
             // Assert
             var exception = Assert.Throws<ArgumentNullException>(test);
@@ -259,14 +263,31 @@
                                                                                             new CalculationGroup(),
                                                                                             Enumerable.Empty<HydraulicBoundaryLocation>(),
                                                                                             Enumerable.Empty<ForeshoreProfile>(),
-                                                                                            null);
+                                                                                            null,
+                                                                                            new ClosingStructuresFailureMechanism());
 
             // Assert
             var exception = Assert.Throws<ArgumentNullException>(test);
             Assert.AreEqual("structures", exception.ParamName);
         }
 
         [Test]
+        public void Constructor_FailureMechanismNull_ThrowArgumentNullException()
+        {
+            // Call
+            TestDelegate test = () => new ClosingStructuresCalculationConfigurationImporter("",
+                                                                                            new CalculationGroup(),
+                                                                                            Enumerable.Empty<HydraulicBoundaryLocation>(),
+                                                                                            Enumerable.Empty<ForeshoreProfile>(),
+                                                                                            Enumerable.Empty<ClosingStructure>(),
+                                                                                            null);
+
+            // Assert
+            var exception = Assert.Throws<ArgumentNullException>(test);
+            Assert.AreEqual("failureMechanism", exception.ParamName);
+        }
+
+        [Test]
         [SetCulture("nl-NL")]
         [TestCaseSource(nameof(ValidConfigurationInvalidData))]
         public void Import_ValidConfigurationInvalidData_LogMessageAndContinueImport(string file, string expectedErrorMessage)
@@ -288,7 +309,8 @@
                                                                                  new ClosingStructure[]
                                                                                  {
                                                                                      structure
-                                                                                 });
+                                                                                 },
+                                                                                 new ClosingStructuresFailureMechanism());
             var successful = false;
 
             // Call
@@ -317,7 +339,8 @@
                 {
                     foreshoreProfile
                 },
-                Enumerable.Empty<ClosingStructure>());
+                Enumerable.Empty<ClosingStructure>(),
+                new ClosingStructuresFailureMechanism());
 
             var successful = false;
 
@@ -358,7 +381,8 @@
                 new[]
                 {
                     structure
-                });
+                },
+                new ClosingStructuresFailureMechanism());
 
             // Call
             bool successful = importer.Import();
@@ -468,7 +492,8 @@
                 new[]
                 {
                     structure
-                });
+                },
+                new ClosingStructuresFailureMechanism());
 
             var expectedCalculation = new StructuresCalculation<ClosingStructuresInput>
             {
@@ -552,7 +577,8 @@
                 new[]
                 {
                     structure
-                });
+                },
+                new ClosingStructuresFailureMechanism());
 
             var expectedCalculation = new StructuresCalculation<ClosingStructuresInput>
             {
@@ -628,7 +654,8 @@
                 new[]
                 {
                     structure
-                });
+                },
+                new ClosingStructuresFailureMechanism());
 
             var expectedCalculation = new StructuresCalculation<ClosingStructuresInput>
             {
@@ -661,7 +688,8 @@
                                                                                  calculationGroup,
                                                                                  Enumerable.Empty<HydraulicBoundaryLocation>(),
                                                                                  Enumerable.Empty<ForeshoreProfile>(),
-                                                                                 Enumerable.Empty<ClosingStructure>());
+                                                                                 Enumerable.Empty<ClosingStructure>(),
+                                                                                 new ClosingStructuresFailureMechanism());
             var successful = false;
 
             // Call
@@ -674,6 +702,50 @@
             CollectionAssert.IsEmpty(calculationGroup.Children);
         }
 
+        [Test]
+        public void DoPostImport_WithNewSectionResults_AssignsCalculationToSectionResult()
+        {
+            // Setup
+            string filePath = Path.Combine(importerPath, "validConfigurationFullCalculation.xml");
+            var calculationGroup = new CalculationGroup();
+
+            var failureMechanism = new ClosingStructuresFailureMechanism();
+
+            failureMechanism.AddSection(new FailureMechanismSection("name", new[]
+            {
+                new Point2D(0, 0),
+                new Point2D(10, 10)
+            }));
+
+            var calculation = new StructuresCalculation<ClosingStructuresInput>
+            {
+                InputParameters =
+                {
+                    Structure = new TestClosingStructure(new Point2D(5, 5))
+                }
+            };
+            failureMechanism.CalculationsGroup.Children.Add(
+                calculation);
+
+            var importer = new ClosingStructuresCalculationConfigurationImporter(
+                filePath,
+                calculationGroup,
+                Enumerable.Empty<HydraulicBoundaryLocation>(),
+                Enumerable.Empty<ForeshoreProfile>(),
+                Enumerable.Empty<ClosingStructure>(),
+                failureMechanism);
+
+            // Preconditions
+            Assert.AreEqual(1, failureMechanism.SectionResults.Count());
+            Assert.IsNull(failureMechanism.SectionResults.ElementAt(0).Calculation);
+
+            // Call
+            importer.DoPostImport();
+
+            // Assert
+            Assert.AreSame(calculation, failureMechanism.SectionResults.ElementAt(0).Calculation);
+        }
+
         private static void AssertCalculation(StructuresCalculation<ClosingStructuresInput> expectedCalculation, StructuresCalculation<ClosingStructuresInput> actualCalculation)
         {
             Assert.AreEqual(expectedCalculation.Name, actualCalculation.Name);