Index: Ringtoets/StabilityPointStructures/src/Ringtoets.StabilityPointStructures.Data/StabilityPointStructuresInput.cs
===================================================================
diff -u -rcd72075e69264b38c0df17a11e7de9096fcf6932 -r3ca074d78bf75ff67c19539c04be91196a0659b0
--- Ringtoets/StabilityPointStructures/src/Ringtoets.StabilityPointStructures.Data/StabilityPointStructuresInput.cs	(.../StabilityPointStructuresInput.cs)	(revision cd72075e69264b38c0df17a11e7de9096fcf6932)
+++ Ringtoets/StabilityPointStructures/src/Ringtoets.StabilityPointStructures.Data/StabilityPointStructuresInput.cs	(.../StabilityPointStructuresInput.cs)	(revision 3ca074d78bf75ff67c19539c04be91196a0659b0)
@@ -479,7 +479,7 @@
             }
             set
             {
-                ProbabilityHelper.ValidateProbability(value, nameof(value), RingtoetsDataCommonResources.FailureProbability_Value_needs_to_be_in_Range_0_);
+                ProbabilityHelper.ValidateProbability(value, null, RingtoetsDataCommonResources.FailureProbability_Value_needs_to_be_in_Range_0_);
                 failureProbabilityRepairClosure = value;
             }
         }
Index: Ringtoets/StabilityPointStructures/src/Ringtoets.StabilityPointStructures.IO/Configurations/StabilityPointStructuresCalculationConfigurationImporter.cs
===================================================================
diff -u
--- Ringtoets/StabilityPointStructures/src/Ringtoets.StabilityPointStructures.IO/Configurations/StabilityPointStructuresCalculationConfigurationImporter.cs	(revision 0)
+++ Ringtoets/StabilityPointStructures/src/Ringtoets.StabilityPointStructures.IO/Configurations/StabilityPointStructuresCalculationConfigurationImporter.cs	(revision 3ca074d78bf75ff67c19539c04be91196a0659b0)
@@ -0,0 +1,378 @@
+// Copyright (C) Stichting Deltares 2016. All rights reserved.
+//
+// This file is part of Ringtoets.
+//
+// Ringtoets is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+// 
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program. If not, see <http://www.gnu.org/licenses/>.
+//
+// All names, logos, and references to "Deltares" are registered trademarks of
+// Stichting Deltares and remain full property of Stichting Deltares at all times.
+// All rights reserved.
+
+using System;
+using System.Collections.Generic;
+using Core.Common.Base.Data;
+using Ringtoets.Common.Data.Calculation;
+using Ringtoets.Common.Data.DikeProfiles;
+using Ringtoets.Common.Data.Hydraulics;
+using Ringtoets.Common.Data.Structures;
+using Ringtoets.Common.IO.Configurations;
+using Ringtoets.Common.IO.Configurations.Helpers;
+using Ringtoets.Common.IO.Configurations.Import;
+using Ringtoets.StabilityPointStructures.Data;
+using Ringtoets.StabilityPointStructures.IO.Configurations.Helpers;
+using Ringtoets.StabilityPointStructures.IO.Properties;
+using RingtoetsCommonIOResources = Ringtoets.Common.IO.Properties.Resources;
+
+namespace Ringtoets.StabilityPointStructures.IO.Configurations
+{
+    /// <summary>
+    /// Class for importing a configuration of <see cref="StabilityPointStructuresCalculationConfiguration"/> from an XML file and storing
+    /// it on a <see cref="CalculationGroup"/>.
+    /// </summary>
+    public class StabilityPointStructuresCalculationConfigurationImporter
+        : CalculationConfigurationImporter<
+            StabilityPointStructuresCalculationConfigurationReader,
+            StabilityPointStructuresCalculationConfiguration>
+    {
+        private readonly IEnumerable<HydraulicBoundaryLocation> availableHydraulicBoundaryLocations;
+        private readonly IEnumerable<ForeshoreProfile> availableForeshoreProfiles;
+        private readonly IEnumerable<StabilityPointStructure> availableStructures;
+
+        /// <summary>
+        /// Create new instance of <see cref="StabilityPointStructuresCalculationConfigurationImporter"/>
+        /// </summary>
+        /// <param name="xmlFilePath">The path to the XML file to import from.</param>
+        /// <param name="importTarget">The calculation group to update.</param>
+        /// <param name="hydraulicBoundaryLocations">The hydraulic boundary locations
+        /// used to check if the imported objects contain the right location.</param>
+        /// <param name="foreshoreProfiles">The foreshore profiles used to check if 
+        /// the imported objects contain the right foreshore profile.</param>
+        /// <param name="structures">The structures used to check if
+        /// the imported objects contain the right structure.</param>
+        /// <exception cref="ArgumentNullException">Thrown when any input parameter is <c>null</c>.</exception>
+        public StabilityPointStructuresCalculationConfigurationImporter(
+            string xmlFilePath,
+            CalculationGroup importTarget,
+            IEnumerable<HydraulicBoundaryLocation> hydraulicBoundaryLocations,
+            IEnumerable<ForeshoreProfile> foreshoreProfiles,
+            IEnumerable<StabilityPointStructure> structures)
+            : base(xmlFilePath, importTarget)
+        {
+            if (hydraulicBoundaryLocations == null)
+            {
+                throw new ArgumentNullException(nameof(hydraulicBoundaryLocations));
+            }
+            if (foreshoreProfiles == null)
+            {
+                throw new ArgumentNullException(nameof(foreshoreProfiles));
+            }
+            if (structures == null)
+            {
+                throw new ArgumentNullException(nameof(structures));
+            }
+            availableHydraulicBoundaryLocations = hydraulicBoundaryLocations;
+            availableForeshoreProfiles = foreshoreProfiles;
+            availableStructures = structures;
+        }
+
+        protected override StabilityPointStructuresCalculationConfigurationReader CreateCalculationConfigurationReader(
+            string xmlFilePath)
+        {
+            return new StabilityPointStructuresCalculationConfigurationReader(xmlFilePath);
+        }
+
+        protected override ICalculation ParseReadCalculation(StabilityPointStructuresCalculationConfiguration readCalculation)
+        {
+            var calculation = new StructuresCalculation<StabilityPointStructuresInput>
+            {
+                Name = readCalculation.Name
+            };
+
+            if (TrySetStructure(readCalculation.StructureName, calculation)
+                && TrySetHydraulicBoundaryLocation(readCalculation.HydraulicBoundaryLocationName, calculation)
+                && TrySetForeshoreProfile(readCalculation.ForeshoreProfileName, calculation)
+                && TryReadFailureProbabilityRepairClosure(readCalculation, calculation)
+                && TryReadStochasts(readCalculation, calculation)
+                && TryReadOrientation(readCalculation, calculation)
+                && TryReadFailureProbabilityStructureWithErosion(readCalculation, calculation)
+                && TryReadInflowModelType(readCalculation, calculation)
+                && readCalculation.WaveReduction.ValidateWaveReduction(calculation.InputParameters.ForeshoreProfile, calculation.Name, Log))
+            {
+                ReadFactorStormDurationOpenStructure(readCalculation, calculation);
+                ReadWaveReductionParameters(readCalculation.WaveReduction, calculation.InputParameters);
+                return calculation;
+            }
+            return null;
+        }
+
+        private bool TryReadStochasts(StabilityPointStructuresCalculationConfiguration readCalculation, StructuresCalculation<StabilityPointStructuresInput> calculation)
+        {
+            if (!readCalculation.ValidateStructureBaseStochasts(Log))
+            {
+                return false;
+            }
+            if (!ValidateStochasts(readCalculation))
+            {
+                return false;
+            }
+
+            return TryReadStandardDeviationStochast(
+                       ConfigurationSchemaIdentifiers.AllowedLevelIncreaseStorageStochastName,
+                       calculation.Name,
+                       calculation.InputParameters,
+                       readCalculation.AllowedLevelIncreaseStorage,
+                       i => i.AllowedLevelIncreaseStorage, (i, d) => i.AllowedLevelIncreaseStorage = d)
+                   && TryReadStandardDeviationStochast(
+                       ConfigurationSchemaIdentifiers.FlowWidthAtBottomProtectionStochastName,
+                       calculation.Name,
+                       calculation.InputParameters,
+                       readCalculation.FlowWidthAtBottomProtection,
+                       i => i.FlowWidthAtBottomProtection, (i, d) => i.FlowWidthAtBottomProtection = d)
+                   && TryReadStandardDeviationStochast(
+                       ConfigurationSchemaIdentifiers.ModelFactorSuperCriticalFlowStochastName,
+                       calculation.Name,
+                       calculation.InputParameters,
+                       readCalculation.ModelFactorSuperCriticalFlow,
+                       i => i.ModelFactorSuperCriticalFlow, (i, d) => i.ModelFactorSuperCriticalFlow = d)
+                   && TryReadStandardDeviationStochast(
+                       ConfigurationSchemaIdentifiers.WidthFlowAperturesStochastName,
+                       calculation.Name,
+                       calculation.InputParameters,
+                       readCalculation.WidthFlowApertures, i => i.WidthFlowApertures, (i, d) => i.WidthFlowApertures = d)
+                   && TryReadVariationCoefficientStochast(
+                       ConfigurationSchemaIdentifiers.CriticalOvertoppingDischargeStochastName,
+                       calculation.Name,
+                       calculation.InputParameters,
+                       readCalculation.CriticalOvertoppingDischarge,
+                       i => i.CriticalOvertoppingDischarge, (i, d) => i.CriticalOvertoppingDischarge = d)
+                   && TryReadVariationCoefficientStochast(
+                       ConfigurationSchemaIdentifiers.StorageStructureAreaStochastName,
+                       calculation.Name,
+                       calculation.InputParameters,
+                       readCalculation.StorageStructureArea,
+                       i => i.StorageStructureArea, (i, d) => i.StorageStructureArea = d)
+                   && TryReadVariationCoefficientStochast(
+                       ConfigurationSchemaIdentifiers.StormDurationStochastName,
+                       calculation.Name,
+                       calculation.InputParameters,
+                       readCalculation.StormDuration,
+                       i => i.StormDuration, (i, d) => i.StormDuration = d);
+        }
+
+        private bool ValidateStochasts(StabilityPointStructuresCalculationConfiguration configuration)
+        {
+            if (configuration.DrainCoefficient?.StandardDeviation != null
+                || configuration.DrainCoefficient?.VariationCoefficient != null)
+            {
+                Log.LogCalculationConversionError("Er kan geen spreiding voor stochast 'afvoercoefficient' opgegeven worden.",
+                                                  configuration.Name);
+                return false;
+            }
+            return true;
+        }
+
+        /// <summary>
+        /// Reads the orientation.
+        /// </summary>
+        /// <param name="readCalculation">The calculation read from the imported file.</param>
+        /// <param name="calculation">The calculation to configure.</param>
+        /// <returns><c>false</c> when the orientation is invalid or when there is an orientation but
+        /// no structure defined, <c>true</c> otherwise.</returns>
+        private bool TryReadOrientation(StructuresCalculationConfiguration readCalculation, StructuresCalculation<StabilityPointStructuresInput> calculation)
+        {
+            if (!readCalculation.StructureNormalOrientation.HasValue)
+            {
+                return true;
+            }
+
+            if (calculation.InputParameters.Structure == null)
+            {
+                Log.LogCalculationConversionError(string.Format(RingtoetsCommonIOResources.CalculationConfigurationImporter_TryParameter_No_Structure_to_assign_Parameter_0_,
+                                                                RingtoetsCommonIOResources.CalculationConfigurationImporter_Orientation_DisplayName),
+                                                  calculation.Name);
+
+                return false;
+            }
+
+            double orientation = readCalculation.StructureNormalOrientation.Value;
+
+            try
+            {
+                calculation.InputParameters.StructureNormalOrientation = (RoundedDouble) orientation;
+            }
+            catch (ArgumentOutOfRangeException e)
+            {
+                Log.LogOutOfRangeException(string.Format(RingtoetsCommonIOResources.TryReadParameter_Value_0_ParameterName_1_is_invalid,
+                                                         orientation,
+                                                         RingtoetsCommonIOResources.CalculationConfigurationImporter_Orientation_DisplayName),
+                                           calculation.Name,
+                                           e);
+
+                return false;
+            }
+
+            return true;
+        }
+
+        private bool TryReadFailureProbabilityRepairClosure(StabilityPointStructuresCalculationConfiguration readCalculation,
+                                                            StructuresCalculation<StabilityPointStructuresInput> calculation)
+        {
+            if (!readCalculation.FailureProbabilityRepairClosure.HasValue)
+            {
+                return true;
+            }
+
+            if (calculation.InputParameters.Structure == null)
+            {
+                Log.LogCalculationConversionError(string.Format(RingtoetsCommonIOResources.CalculationConfigurationImporter_TryParameter_No_Structure_to_assign_Parameter_0_,
+                                                                Resources.CalculationConfigurationImporter_FailureProbabilityRepairClosure_DisplayName),
+                                                  calculation.Name);
+
+                return false;
+            }
+
+            double failureProbabilityRepairClosure = readCalculation.FailureProbabilityRepairClosure.Value;
+
+            try
+            {
+                calculation.InputParameters.FailureProbabilityRepairClosure = (RoundedDouble) failureProbabilityRepairClosure;
+            }
+            catch (ArgumentOutOfRangeException e)
+            {
+                Log.LogOutOfRangeException(string.Format(RingtoetsCommonIOResources.TryReadParameter_Value_0_ParameterName_1_is_invalid,
+                                                         failureProbabilityRepairClosure,
+                                                         Resources.CalculationConfigurationImporter_FailureProbabilityRepairClosure_DisplayName),
+                                           calculation.Name,
+                                           e);
+
+                return false;
+            }
+
+            return true;
+        }
+
+        /// <summary>
+        /// Reads the failure probability structure with erosion.
+        /// </summary>
+        /// <param name="readCalculation">The calculation read from the imported file.</param>
+        /// <param name="calculation">The calculation to configure.</param>
+        /// <returns><c>false</c> when the orientation is invalid or when there is a failure probability 
+        /// structure with erosion but no structure defined, <c>true</c> otherwise.</returns>
+        private bool TryReadFailureProbabilityStructureWithErosion(StructuresCalculationConfiguration readCalculation, StructuresCalculation<StabilityPointStructuresInput> calculation)
+        {
+            if (readCalculation.FailureProbabilityStructureWithErosion.HasValue)
+            {
+                double failureProbability = readCalculation.FailureProbabilityStructureWithErosion.Value;
+
+                try
+                {
+                    calculation.InputParameters.FailureProbabilityStructureWithErosion = (RoundedDouble) failureProbability;
+                }
+                catch (ArgumentOutOfRangeException e)
+                {
+                    Log.LogOutOfRangeException(string.Format(
+                                                   RingtoetsCommonIOResources.TryReadParameter_Value_0_ParameterName_1_is_invalid,
+                                                   failureProbability,
+                                                   RingtoetsCommonIOResources.CalculationConfigurationImporter_FailureProbabilityStructureWithErosion_DisplayName),
+                                               calculation.Name,
+                                               e);
+
+                    return false;
+                }
+            }
+
+            return true;
+        }
+
+        /// <summary>
+        /// Reads the factor storm duration.
+        /// </summary>
+        /// <param name="readCalculation">The calculation read from the imported file.</param>
+        /// <param name="calculation">The calculation to configure.</param>
+        private void ReadFactorStormDurationOpenStructure(StabilityPointStructuresCalculationConfiguration readCalculation, StructuresCalculation<StabilityPointStructuresInput> calculation)
+        {
+            if (readCalculation.FactorStormDurationOpenStructure.HasValue)
+            {
+                calculation.InputParameters.FactorStormDurationOpenStructure = (RoundedDouble) readCalculation.FactorStormDurationOpenStructure.Value;
+            }
+        }
+
+        /// <summary>
+        /// Reads the inflow model type.
+        /// </summary>
+        /// <param name="readCalculation">The calculation read from the imported file.</param>
+        /// <param name="calculation">The calculation to configure.</param>
+        /// <returns><c>false</c> when the inflow model type is invalid or when there is a 
+        /// inflow model type but no structure defined, <c>true</c> otherwise.</returns>
+        private bool TryReadInflowModelType(StabilityPointStructuresCalculationConfiguration readCalculation, StructuresCalculation<StabilityPointStructuresInput> calculation)
+        {
+            if (readCalculation.InflowModelType.HasValue)
+            {
+                if (calculation.InputParameters.Structure == null)
+                {
+                    Log.LogCalculationConversionError(string.Format(RingtoetsCommonIOResources.CalculationConfigurationImporter_TryParameter_No_Structure_to_assign_Parameter_0_,
+                                                                    RingtoetsCommonIOResources.CalculationConfigurationImporter_InflowModelType_DisplayName),
+                                                      calculation.Name);
+
+                    return false;
+                }
+
+                calculation.InputParameters.InflowModelType = (StabilityPointStructureInflowModelType)
+                    new ConfigurationStabilityPointStructuresInflowModelTypeConverter()
+                        .ConvertTo(readCalculation.InflowModelType.Value, typeof(StabilityPointStructureInflowModelType));
+            }
+
+            return true;
+        }
+
+        private bool TrySetHydraulicBoundaryLocation(string locationName, StructuresCalculation<StabilityPointStructuresInput> calculation)
+        {
+            HydraulicBoundaryLocation location;
+
+            if (TryReadHydraulicBoundaryLocation(locationName, calculation.Name, availableHydraulicBoundaryLocations, out location))
+            {
+                calculation.InputParameters.HydraulicBoundaryLocation = location;
+                return true;
+            }
+
+            return false;
+        }
+
+        private bool TrySetStructure(string structureName, StructuresCalculation<StabilityPointStructuresInput> calculation)
+        {
+            StabilityPointStructure structure;
+
+            if (TryReadStructure(structureName, calculation.Name, availableStructures, out structure))
+            {
+                calculation.InputParameters.Structure = structure;
+                return true;
+            }
+
+            return false;
+        }
+
+        private bool TrySetForeshoreProfile(string foreshoreProfileName, StructuresCalculation<StabilityPointStructuresInput> calculation)
+        {
+            ForeshoreProfile foreshoreProfile;
+
+            if (TryReadForeshoreProfile(foreshoreProfileName, calculation.Name, availableForeshoreProfiles, out foreshoreProfile))
+            {
+                calculation.InputParameters.ForeshoreProfile = foreshoreProfile;
+                return true;
+            }
+
+            return false;
+        }
+    }
+}
\ No newline at end of file
Index: Ringtoets/StabilityPointStructures/src/Ringtoets.StabilityPointStructures.IO/Properties/Resources.Designer.cs
===================================================================
diff -u -rff3bf86946b3c76d494d5ca885464e4afb617788 -r3ca074d78bf75ff67c19539c04be91196a0659b0
--- Ringtoets/StabilityPointStructures/src/Ringtoets.StabilityPointStructures.IO/Properties/Resources.Designer.cs	(.../Resources.Designer.cs)	(revision ff3bf86946b3c76d494d5ca885464e4afb617788)
+++ Ringtoets/StabilityPointStructures/src/Ringtoets.StabilityPointStructures.IO/Properties/Resources.Designer.cs	(.../Resources.Designer.cs)	(revision 3ca074d78bf75ff67c19539c04be91196a0659b0)
@@ -82,6 +82,15 @@
         }
         
         /// <summary>
+        ///   Looks up a localized string similar to faalkans herstel van gefaalde situatie.
+        /// </summary>
+        internal static string CalculationConfigurationImporter_FailureProbabilityRepairClosure_DisplayName {
+            get {
+                return ResourceManager.GetString("CalculationConfigurationImporter_FailureProbabilityRepairClosure_DisplayName", resourceCulture);
+            }
+        }
+        
+        /// <summary>
         ///   Looks up a localized string similar to &lt;?xml version=&quot;1.0&quot; encoding=&quot;UTF-8&quot;?&gt;
         ///&lt;!--
         ///Copyright (C) Stichting Deltares 2016. All rights reserved.
Index: Ringtoets/StabilityPointStructures/src/Ringtoets.StabilityPointStructures.IO/Properties/Resources.resx
===================================================================
diff -u -rff3bf86946b3c76d494d5ca885464e4afb617788 -r3ca074d78bf75ff67c19539c04be91196a0659b0
--- Ringtoets/StabilityPointStructures/src/Ringtoets.StabilityPointStructures.IO/Properties/Resources.resx	(.../Resources.resx)	(revision ff3bf86946b3c76d494d5ca885464e4afb617788)
+++ Ringtoets/StabilityPointStructures/src/Ringtoets.StabilityPointStructures.IO/Properties/Resources.resx	(.../Resources.resx)	(revision 3ca074d78bf75ff67c19539c04be91196a0659b0)
@@ -117,6 +117,9 @@
   <resheader name="writer">
     <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
   </resheader>
+  <data name="CalculationConfigurationImporter_FailureProbabilityRepairClosure_DisplayName" xml:space="preserve">
+    <value>faalkans herstel van gefaalde situatie</value>
+  </data>
   <assembly alias="System.Windows.Forms" name="System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" />
   <data name="StabilityPointStructuresConfigurationSchema" type="System.Resources.ResXFileRef, System.Windows.Forms">
     <value>..\Resources\KunstwerkenConstructiefFalenSchema.xsd;System.String, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089;Windows-1252</value>
Index: Ringtoets/StabilityPointStructures/src/Ringtoets.StabilityPointStructures.IO/Ringtoets.StabilityPointStructures.IO.csproj
===================================================================
diff -u -r48eac104ea815699b299e93b512b6498e8cb92ec -r3ca074d78bf75ff67c19539c04be91196a0659b0
--- Ringtoets/StabilityPointStructures/src/Ringtoets.StabilityPointStructures.IO/Ringtoets.StabilityPointStructures.IO.csproj	(.../Ringtoets.StabilityPointStructures.IO.csproj)	(revision 48eac104ea815699b299e93b512b6498e8cb92ec)
+++ Ringtoets/StabilityPointStructures/src/Ringtoets.StabilityPointStructures.IO/Ringtoets.StabilityPointStructures.IO.csproj	(.../Ringtoets.StabilityPointStructures.IO.csproj)	(revision 3ca074d78bf75ff67c19539c04be91196a0659b0)
@@ -50,6 +50,7 @@
     <Compile Include="Configurations\ConfigurationStabilityPointStructuresLoadSchematizationType.cs" />
     <Compile Include="Configurations\Helpers\ConfigurationStabilityPointStructuresLoadSchematizationTypeConverter.cs" />
     <Compile Include="Configurations\StabilityPointStructuresCalculationConfigurationExporter.cs" />
+    <Compile Include="Configurations\StabilityPointStructuresCalculationConfigurationImporter.cs" />
     <Compile Include="Properties\Resources.Designer.cs">
       <AutoGen>True</AutoGen>
       <DesignTime>True</DesignTime>
Index: Ringtoets/StabilityPointStructures/test/Ringtoets.StabilityPointStructures.IO.Test/Configurations/StabilityPointStructuresCalculationConfigurationImporterTest.cs
===================================================================
diff -u
--- Ringtoets/StabilityPointStructures/test/Ringtoets.StabilityPointStructures.IO.Test/Configurations/StabilityPointStructuresCalculationConfigurationImporterTest.cs	(revision 0)
+++ Ringtoets/StabilityPointStructures/test/Ringtoets.StabilityPointStructures.IO.Test/Configurations/StabilityPointStructuresCalculationConfigurationImporterTest.cs	(revision 3ca074d78bf75ff67c19539c04be91196a0659b0)
@@ -0,0 +1,274 @@
+// Copyright (C) Stichting Deltares 2016. All rights reserved.
+//
+// This file is part of Ringtoets.
+//
+// Ringtoets is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+// 
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program. If not, see <http://www.gnu.org/licenses/>.
+//
+// All names, logos, and references to "Deltares" are registered trademarks of
+// Stichting Deltares and remain full property of Stichting Deltares at all times.
+// All rights reserved.
+
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using Core.Common.TestUtil;
+using NUnit.Framework;
+using Ringtoets.Common.Data.Calculation;
+using Ringtoets.Common.Data.DikeProfiles;
+using Ringtoets.Common.Data.Hydraulics;
+using Ringtoets.Common.Data.Structures;
+using Ringtoets.Common.Data.TestUtil;
+using Ringtoets.Common.IO.Configurations.Import;
+using Ringtoets.StabilityPointStructures.Data;
+using Ringtoets.StabilityPointStructures.Data.TestUtil;
+using Ringtoets.StabilityPointStructures.IO.Configurations;
+
+namespace Ringtoets.StabilityPointStructures.IO.Test.Configurations
+{
+    [TestFixture]
+    public class StabilityPointStructuresCalculationConfigurationImporterTest
+    {
+        private readonly string importerPath = TestHelper.GetTestDataPath(TestDataPath.Ringtoets.StabilityPointStructures.IO,
+                                                                          nameof(StabilityPointStructuresCalculationConfigurationImporter));
+
+        private static IEnumerable<TestCaseData> ValidConfigurationInvalidData
+        {
+            get
+            {
+                yield return new TestCaseData(
+                    "validConfigurationInvalidFailureProbabilityStructureErosion.xml",
+                    "Een waarde van '1,1' als faalkans gegeven erosie bodem is ongeldig. De waarde voor de faalkans moet in het bereik [0,0, 1,0] liggen.");
+                yield return new TestCaseData(
+                    "validConfigurationInvalidFailureProbabilityRepairClosureElement.xml",
+                    "Een waarde van '1,1' als faalkans herstel van gefaalde situatie is ongeldig. De waarde voor de faalkans moet in het bereik [0,0, 1,0] liggen.");
+            }
+        }
+
+        [Test]
+        public void Constructor_ExpectedValues()
+        {
+            // Call
+            var importer = new StabilityPointStructuresCalculationConfigurationImporter("",
+                                                                                        new CalculationGroup(),
+                                                                                        Enumerable.Empty<HydraulicBoundaryLocation>(),
+                                                                                        Enumerable.Empty<ForeshoreProfile>(),
+                                                                                        Enumerable.Empty<StabilityPointStructure>());
+
+            // Assert
+            Assert.IsInstanceOf<CalculationConfigurationImporter<StabilityPointStructuresCalculationConfigurationReader,
+                StabilityPointStructuresCalculationConfiguration>>(importer);
+        }
+
+        [Test]
+        public void Constructor_HydraulicBoundaryLocationsNull_ThrowArgumentNullException()
+        {
+            // Call
+            TestDelegate test = () => new StabilityPointStructuresCalculationConfigurationImporter("",
+                                                                                                   new CalculationGroup(),
+                                                                                                   null,
+                                                                                                   Enumerable.Empty<ForeshoreProfile>(),
+                                                                                                   Enumerable.Empty<StabilityPointStructure>());
+
+            // Assert
+            var exception = Assert.Throws<ArgumentNullException>(test);
+            Assert.AreEqual("hydraulicBoundaryLocations", exception.ParamName);
+        }
+
+        [Test]
+        public void Constructor_ForeshoreProfilesNull_ThrowArgumentNullException()
+        {
+            // Call
+            TestDelegate test = () => new StabilityPointStructuresCalculationConfigurationImporter("",
+                                                                                                   new CalculationGroup(),
+                                                                                                   Enumerable.Empty<HydraulicBoundaryLocation>(),
+                                                                                                   null,
+                                                                                                   Enumerable.Empty<StabilityPointStructure>());
+
+            // Assert
+            var exception = Assert.Throws<ArgumentNullException>(test);
+            Assert.AreEqual("foreshoreProfiles", exception.ParamName);
+        }
+
+        [Test]
+        public void Constructor_StructuresNull_ThrowArgumentNullException()
+        {
+            // Call
+            TestDelegate test = () => new StabilityPointStructuresCalculationConfigurationImporter("",
+                                                                                                   new CalculationGroup(),
+                                                                                                   Enumerable.Empty<HydraulicBoundaryLocation>(),
+                                                                                                   Enumerable.Empty<ForeshoreProfile>(),
+                                                                                                   null);
+
+            // Assert
+            var exception = Assert.Throws<ArgumentNullException>(test);
+            Assert.AreEqual("structures", exception.ParamName);
+        }
+
+        [Test]
+        [SetCulture("nl-NL")]
+        [TestCaseSource(nameof(ValidConfigurationInvalidData))]
+        public void Import_ValidConfigurationInvalidData_LogMessageAndContinueImport(string file, string expectedErrorMessage)
+        {
+            // Setup
+            string filePath = Path.Combine(importerPath, file);
+
+            var calculationGroup = new CalculationGroup();
+            var structure = new TestStabilityPointStructure("kunstwerk1");
+            var foreshoreProfile = new TestForeshoreProfile("profiel 1");
+
+            var importer = new StabilityPointStructuresCalculationConfigurationImporter(filePath,
+                                                                                        calculationGroup,
+                                                                                        Enumerable.Empty<HydraulicBoundaryLocation>(),
+                                                                                        new ForeshoreProfile[]
+                                                                                        {
+                                                                                            foreshoreProfile
+                                                                                        },
+                                                                                        new StabilityPointStructure[]
+                                                                                        {
+                                                                                            structure
+                                                                                        });
+            var successful = false;
+
+            // Call
+            Action call = () => successful = importer.Import();
+
+            // Assert
+            string expectedMessage = $"{expectedErrorMessage} Berekening 'Berekening 1' is overgeslagen.";
+            TestHelper.AssertLogMessageWithLevelIsGenerated(call, Tuple.Create(expectedMessage, LogLevelConstant.Error), 1);
+            Assert.IsTrue(successful);
+            CollectionAssert.IsEmpty(calculationGroup.Children);
+        }
+
+        [Test]
+        [TestCase("validConfigurationEmptyCalculation.xml")]
+        [TestCase("validConfigurationEmptyStochasts.xml")]
+        [TestCase("validConfigurationEmptyStochastElements.xml")]
+        [TestCase("validConfigurationEmptyWaveReduction.xml")]
+        public void Import_EmptyConfigurations_DataAddedToModel(string file)
+        {
+            // Setup
+            string filePath = Path.Combine(importerPath, file);
+
+            var calculationGroup = new CalculationGroup();
+            var structure = new TestStabilityPointStructure("kunstwerk1");
+            var importer = new StabilityPointStructuresCalculationConfigurationImporter(
+                filePath,
+                calculationGroup,
+                Enumerable.Empty<HydraulicBoundaryLocation>(),
+                Enumerable.Empty<ForeshoreProfile>(),
+                new[]
+                {
+                    structure
+                });
+
+            var expectedCalculation = new StructuresCalculation<StabilityPointStructuresInput>
+            {
+                Name = "Berekening 1"
+            };
+
+            // Call
+            bool successful = importer.Import();
+
+            // Assert
+            Assert.IsTrue(successful);
+            Assert.AreEqual(1, calculationGroup.Children.Count);
+            AssertCalculation(expectedCalculation, (StructuresCalculation<StabilityPointStructuresInput>) calculationGroup.Children[0]);
+        }
+
+        [TestCase("validConfigurationUnknownForeshoreProfile.xml",
+            "Het voorlandprofiel 'unknown' bestaat niet.")]
+        [TestCase("validConfigurationUnknownHydraulicBoundaryLocation.xml",
+            "De locatie met hydraulische randvoorwaarden 'unknown' bestaat niet.")]
+        [TestCase("validConfigurationUnknownStructure.xml",
+            "Het kunstwerk 'unknown' bestaat niet.")]
+        public void Import_ValidConfigurationUnknownData_LogMessageAndContinueImport(string file, string expectedErrorMessage)
+        {
+            // Setup
+            string filePath = Path.Combine(importerPath, file);
+
+            var calculationGroup = new CalculationGroup();
+
+            var importer = new StabilityPointStructuresCalculationConfigurationImporter(filePath,
+                                                                                        calculationGroup,
+                                                                                        Enumerable.Empty<HydraulicBoundaryLocation>(),
+                                                                                        Enumerable.Empty<ForeshoreProfile>(),
+                                                                                        Enumerable.Empty<StabilityPointStructure>());
+            var successful = false;
+
+            // Call
+            Action call = () => successful = importer.Import();
+
+            // Assert
+            string expectedMessage = $"{expectedErrorMessage} Berekening 'Berekening 1' is overgeslagen.";
+            TestHelper.AssertLogMessageWithLevelIsGenerated(call, Tuple.Create(expectedMessage, LogLevelConstant.Error), 1);
+            Assert.IsTrue(successful);
+            CollectionAssert.IsEmpty(calculationGroup.Children);
+        }
+
+        private static void AssertCalculation(StructuresCalculation<StabilityPointStructuresInput> expectedCalculation,
+                                              StructuresCalculation<StabilityPointStructuresInput> actualCalculation)
+        {
+            Assert.AreEqual(expectedCalculation.Name, actualCalculation.Name);
+            Assert.AreEqual(expectedCalculation.InputParameters.BreakWater.Height, actualCalculation.InputParameters.BreakWater.Height);
+            Assert.AreEqual(expectedCalculation.InputParameters.BreakWater.Type, actualCalculation.InputParameters.BreakWater.Type);
+            Assert.AreEqual(expectedCalculation.InputParameters.EvaluationLevel, actualCalculation.InputParameters.EvaluationLevel);
+
+            Assert.AreEqual(expectedCalculation.InputParameters.FactorStormDurationOpenStructure, actualCalculation.InputParameters.FactorStormDurationOpenStructure);
+            Assert.AreEqual(expectedCalculation.InputParameters.FailureProbabilityRepairClosure, actualCalculation.InputParameters.FailureProbabilityRepairClosure);
+            Assert.AreEqual(expectedCalculation.InputParameters.FailureProbabilityStructureWithErosion, actualCalculation.InputParameters.FailureProbabilityStructureWithErosion);
+            Assert.AreSame(expectedCalculation.InputParameters.ForeshoreProfile, actualCalculation.InputParameters.ForeshoreProfile);
+
+            Assert.AreEqual(expectedCalculation.InputParameters.InflowModelType, actualCalculation.InputParameters.InflowModelType);
+            Assert.AreEqual(expectedCalculation.InputParameters.LevellingCount, actualCalculation.InputParameters.LevellingCount);
+            Assert.AreEqual(expectedCalculation.InputParameters.LoadSchematizationType, actualCalculation.InputParameters.LoadSchematizationType);
+            Assert.AreEqual(expectedCalculation.InputParameters.ProbabilityCollisionSecondaryStructure, actualCalculation.InputParameters.ProbabilityCollisionSecondaryStructure);
+
+            Assert.AreSame(expectedCalculation.InputParameters.Structure, actualCalculation.InputParameters.Structure);
+            Assert.AreEqual(expectedCalculation.InputParameters.StructureNormalOrientation, actualCalculation.InputParameters.StructureNormalOrientation);
+            Assert.AreEqual(expectedCalculation.InputParameters.UseForeshore, actualCalculation.InputParameters.UseForeshore);
+            Assert.AreEqual(expectedCalculation.InputParameters.UseBreakWater, actualCalculation.InputParameters.UseBreakWater);
+
+            Assert.AreEqual(expectedCalculation.InputParameters.VerticalDistance, actualCalculation.InputParameters.VerticalDistance);
+            Assert.AreEqual(expectedCalculation.InputParameters.VolumicWeightWater, actualCalculation.InputParameters.VolumicWeightWater);
+            DistributionAssert.AreEqual(expectedCalculation.InputParameters.AllowedLevelIncreaseStorage, actualCalculation.InputParameters.AllowedLevelIncreaseStorage);
+            DistributionAssert.AreEqual(expectedCalculation.InputParameters.AreaFlowApertures, actualCalculation.InputParameters.AreaFlowApertures);
+
+            DistributionAssert.AreEqual(expectedCalculation.InputParameters.BankWidth, actualCalculation.InputParameters.BankWidth);
+            DistributionAssert.AreEqual(expectedCalculation.InputParameters.ConstructiveStrengthLinearLoadModel, actualCalculation.InputParameters.ConstructiveStrengthLinearLoadModel);
+            DistributionAssert.AreEqual(expectedCalculation.InputParameters.ConstructiveStrengthQuadraticLoadModel, actualCalculation.InputParameters.ConstructiveStrengthQuadraticLoadModel);
+            DistributionAssert.AreEqual(expectedCalculation.InputParameters.CriticalOvertoppingDischarge, actualCalculation.InputParameters.CriticalOvertoppingDischarge);
+
+            DistributionAssert.AreEqual(expectedCalculation.InputParameters.DrainCoefficient, actualCalculation.InputParameters.DrainCoefficient);
+            DistributionAssert.AreEqual(expectedCalculation.InputParameters.FailureCollisionEnergy, actualCalculation.InputParameters.FailureCollisionEnergy);
+            DistributionAssert.AreEqual(expectedCalculation.InputParameters.FlowVelocityStructureClosable, actualCalculation.InputParameters.FlowVelocityStructureClosable);
+            DistributionAssert.AreEqual(expectedCalculation.InputParameters.FlowWidthAtBottomProtection, actualCalculation.InputParameters.FlowWidthAtBottomProtection);
+
+            DistributionAssert.AreEqual(expectedCalculation.InputParameters.InsideWaterLevel, actualCalculation.InputParameters.InsideWaterLevel);
+            DistributionAssert.AreEqual(expectedCalculation.InputParameters.InsideWaterLevelFailureConstruction, actualCalculation.InputParameters.InsideWaterLevelFailureConstruction);
+            DistributionAssert.AreEqual(expectedCalculation.InputParameters.LevelCrestStructure, actualCalculation.InputParameters.LevelCrestStructure);
+            DistributionAssert.AreEqual(expectedCalculation.InputParameters.ModelFactorSuperCriticalFlow, actualCalculation.InputParameters.ModelFactorSuperCriticalFlow);
+
+            DistributionAssert.AreEqual(expectedCalculation.InputParameters.ShipMass, actualCalculation.InputParameters.ShipMass);
+            DistributionAssert.AreEqual(expectedCalculation.InputParameters.ShipVelocity, actualCalculation.InputParameters.ShipVelocity);
+            DistributionAssert.AreEqual(expectedCalculation.InputParameters.StabilityLinearLoadModel, actualCalculation.InputParameters.StabilityLinearLoadModel);
+            DistributionAssert.AreEqual(expectedCalculation.InputParameters.StabilityQuadraticLoadModel, actualCalculation.InputParameters.StabilityQuadraticLoadModel);
+
+            DistributionAssert.AreEqual(expectedCalculation.InputParameters.StorageStructureArea, actualCalculation.InputParameters.StorageStructureArea);
+            DistributionAssert.AreEqual(expectedCalculation.InputParameters.StormDuration, actualCalculation.InputParameters.StormDuration);
+            DistributionAssert.AreEqual(expectedCalculation.InputParameters.WidthFlowApertures, actualCalculation.InputParameters.WidthFlowApertures);
+            DistributionAssert.AreEqual(expectedCalculation.InputParameters.ThresholdHeightOpenWeir, actualCalculation.InputParameters.ThresholdHeightOpenWeir);
+        }
+    }
+}
\ No newline at end of file
Index: Ringtoets/StabilityPointStructures/test/Ringtoets.StabilityPointStructures.IO.Test/Ringtoets.StabilityPointStructures.IO.Test.csproj
===================================================================
diff -u -r48eac104ea815699b299e93b512b6498e8cb92ec -r3ca074d78bf75ff67c19539c04be91196a0659b0
--- Ringtoets/StabilityPointStructures/test/Ringtoets.StabilityPointStructures.IO.Test/Ringtoets.StabilityPointStructures.IO.Test.csproj	(.../Ringtoets.StabilityPointStructures.IO.Test.csproj)	(revision 48eac104ea815699b299e93b512b6498e8cb92ec)
+++ Ringtoets/StabilityPointStructures/test/Ringtoets.StabilityPointStructures.IO.Test/Ringtoets.StabilityPointStructures.IO.Test.csproj	(.../Ringtoets.StabilityPointStructures.IO.Test.csproj)	(revision 3ca074d78bf75ff67c19539c04be91196a0659b0)
@@ -51,6 +51,7 @@
     <Compile Include="Configurations\Helpers\ConfigurationStabilityPointStructuresInflowModelTypeConverterTest.cs" />
     <Compile Include="Configurations\Helpers\ConfigurationStabilityPointStructuresLoadSchematizationTypeConverterTest.cs" />
     <Compile Include="Configurations\StabilityPointStructuresCalculationConfigurationExporterTest.cs" />
+    <Compile Include="Configurations\StabilityPointStructuresCalculationConfigurationImporterTest.cs" />
     <Compile Include="Configurations\StabilityPointStructuresCalculationConfigurationReaderTest.cs" />
     <Compile Include="Configurations\StabilityPointStructuresCalculationConfigurationWriterTest.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
Index: Ringtoets/StabilityPointStructures/test/Ringtoets.StabilityPointStructures.IO.Test/test-data/StabilityPointStructuresCalculationConfigurationImporter/validConfigurationEmptyCalculation.xml
===================================================================
diff -u
--- Ringtoets/StabilityPointStructures/test/Ringtoets.StabilityPointStructures.IO.Test/test-data/StabilityPointStructuresCalculationConfigurationImporter/validConfigurationEmptyCalculation.xml	(revision 0)
+++ Ringtoets/StabilityPointStructures/test/Ringtoets.StabilityPointStructures.IO.Test/test-data/StabilityPointStructuresCalculationConfigurationImporter/validConfigurationEmptyCalculation.xml	(revision 3ca074d78bf75ff67c19539c04be91196a0659b0)
@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<configuratie>
+  <berekening naam="Berekening 1" />
+</configuratie>
Index: Ringtoets/StabilityPointStructures/test/Ringtoets.StabilityPointStructures.IO.Test/test-data/StabilityPointStructuresCalculationConfigurationImporter/validConfigurationEmptyStochastElements.xml
===================================================================
diff -u
--- Ringtoets/StabilityPointStructures/test/Ringtoets.StabilityPointStructures.IO.Test/test-data/StabilityPointStructuresCalculationConfigurationImporter/validConfigurationEmptyStochastElements.xml	(revision 0)
+++ Ringtoets/StabilityPointStructures/test/Ringtoets.StabilityPointStructures.IO.Test/test-data/StabilityPointStructuresCalculationConfigurationImporter/validConfigurationEmptyStochastElements.xml	(revision 3ca074d78bf75ff67c19539c04be91196a0659b0)
@@ -0,0 +1,29 @@
+<?xml version="1.0" encoding="utf-8"?>
+<configuratie>
+  <berekening naam="Berekening 1">
+    <stochasten>
+      <stochast naam="stormduur" />
+      <stochast naam="binnenwaterstand" />
+      <stochast naam="binnenwaterstandbijfalen" />
+      <stochast naam="modelfactoroverloopdebiet" />
+      <stochast naam="afvoercoefficient" />
+      <stochast naam="breedtedoorstroomopening" />
+      <stochast naam="doorstroomoppervlak" />
+      <stochast naam="breedtebodembescherming" />
+      <stochast naam="kombergendoppervlak" />
+      <stochast naam="peilverhogingkomberging" />
+      <stochast naam="kerendehoogte" />
+      <stochast naam="drempelhoogte" />
+      <stochast naam="kritiekinstromenddebiet" />
+      <stochast naam="kritiekestroomsnelheid" />
+      <stochast naam="kwadratischebelastingschematiseringsterkte" />
+      <stochast naam="lineairebelastingschematiseringsterkte" />
+      <stochast naam="bermbreedte" />
+      <stochast naam="aanvaarenergie" />
+      <stochast naam="massaschip" />
+      <stochast naam="aanvaarsnelheid" />
+      <stochast naam="kwadratischebelastingschematiseringstabiliteit" />
+      <stochast naam="lineairebelastingschematiseringstabiliteit" />
+    </stochasten>
+  </berekening>
+</configuratie>
\ No newline at end of file
Index: Ringtoets/StabilityPointStructures/test/Ringtoets.StabilityPointStructures.IO.Test/test-data/StabilityPointStructuresCalculationConfigurationImporter/validConfigurationEmptyStochasts.xml
===================================================================
diff -u
--- Ringtoets/StabilityPointStructures/test/Ringtoets.StabilityPointStructures.IO.Test/test-data/StabilityPointStructuresCalculationConfigurationImporter/validConfigurationEmptyStochasts.xml	(revision 0)
+++ Ringtoets/StabilityPointStructures/test/Ringtoets.StabilityPointStructures.IO.Test/test-data/StabilityPointStructuresCalculationConfigurationImporter/validConfigurationEmptyStochasts.xml	(revision 3ca074d78bf75ff67c19539c04be91196a0659b0)
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="utf-8"?>
+<configuratie>
+  <berekening naam="Berekening 1">
+    <stochasten />
+  </berekening>
+</configuratie>
\ No newline at end of file
Index: Ringtoets/StabilityPointStructures/test/Ringtoets.StabilityPointStructures.IO.Test/test-data/StabilityPointStructuresCalculationConfigurationImporter/validConfigurationEmptyWaveReduction.xml
===================================================================
diff -u
--- Ringtoets/StabilityPointStructures/test/Ringtoets.StabilityPointStructures.IO.Test/test-data/StabilityPointStructuresCalculationConfigurationImporter/validConfigurationEmptyWaveReduction.xml	(revision 0)
+++ Ringtoets/StabilityPointStructures/test/Ringtoets.StabilityPointStructures.IO.Test/test-data/StabilityPointStructuresCalculationConfigurationImporter/validConfigurationEmptyWaveReduction.xml	(revision 3ca074d78bf75ff67c19539c04be91196a0659b0)
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="utf-8"?>
+<configuratie>
+  <berekening naam="Berekening 1">
+    <golfreductie />
+  </berekening>
+</configuratie>
Index: Ringtoets/StabilityPointStructures/test/Ringtoets.StabilityPointStructures.IO.Test/test-data/StabilityPointStructuresCalculationConfigurationImporter/validConfigurationInvalidFailureProbabilityRepairClosureElement.xml
===================================================================
diff -u
--- Ringtoets/StabilityPointStructures/test/Ringtoets.StabilityPointStructures.IO.Test/test-data/StabilityPointStructuresCalculationConfigurationImporter/validConfigurationInvalidFailureProbabilityRepairClosureElement.xml	(revision 0)
+++ Ringtoets/StabilityPointStructures/test/Ringtoets.StabilityPointStructures.IO.Test/test-data/StabilityPointStructuresCalculationConfigurationImporter/validConfigurationInvalidFailureProbabilityRepairClosureElement.xml	(revision 3ca074d78bf75ff67c19539c04be91196a0659b0)
@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="utf-8"?>
+<configuratie>
+  <berekening naam="Berekening 1">
+    <kunstwerk>kunstwerk1</kunstwerk>
+    <faalkansherstel>1.1</faalkansherstel>
+  </berekening>
+</configuratie>
Index: Ringtoets/StabilityPointStructures/test/Ringtoets.StabilityPointStructures.IO.Test/test-data/StabilityPointStructuresCalculationConfigurationImporter/validConfigurationInvalidFailureProbabilityStructureErosion.xml
===================================================================
diff -u
--- Ringtoets/StabilityPointStructures/test/Ringtoets.StabilityPointStructures.IO.Test/test-data/StabilityPointStructuresCalculationConfigurationImporter/validConfigurationInvalidFailureProbabilityStructureErosion.xml	(revision 0)
+++ Ringtoets/StabilityPointStructures/test/Ringtoets.StabilityPointStructures.IO.Test/test-data/StabilityPointStructuresCalculationConfigurationImporter/validConfigurationInvalidFailureProbabilityStructureErosion.xml	(revision 3ca074d78bf75ff67c19539c04be91196a0659b0)
@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="utf-8"?>
+<configuratie>
+  <berekening naam="Berekening 1">
+    <kunstwerk>kunstwerk1</kunstwerk>
+    <faalkansgegevenerosiebodem>1.1</faalkansgegevenerosiebodem>
+  </berekening>
+</configuratie>
Index: Ringtoets/StabilityPointStructures/test/Ringtoets.StabilityPointStructures.IO.Test/test-data/StabilityPointStructuresCalculationConfigurationImporter/validConfigurationStochastStandardDeviationVariationCoefficientOnly.xml
===================================================================
diff -u
--- Ringtoets/StabilityPointStructures/test/Ringtoets.StabilityPointStructures.IO.Test/test-data/StabilityPointStructuresCalculationConfigurationImporter/validConfigurationStochastStandardDeviationVariationCoefficientOnly.xml	(revision 0)
+++ Ringtoets/StabilityPointStructures/test/Ringtoets.StabilityPointStructures.IO.Test/test-data/StabilityPointStructuresCalculationConfigurationImporter/validConfigurationStochastStandardDeviationVariationCoefficientOnly.xml	(revision 3ca074d78bf75ff67c19539c04be91196a0659b0)
@@ -0,0 +1,93 @@
+<?xml version="1.0" encoding="utf-8"?>
+<configuratie>
+  <berekening naam="Berekening 1">
+    <kunstwerk>kunstwerk1</kunstwerk>
+    <stochasten>
+      <stochast naam="stormduur" />
+      <stochast naam="binnenwaterstand">
+        <verwachtingswaarde>0.5</verwachtingswaarde>
+        <standaardafwijking>0.1</standaardafwijking>
+      </stochast>
+      <stochast naam="binnenwaterstandbijfalen">
+        <verwachtingswaarde>0.7</verwachtingswaarde>
+        <standaardafwijking>0.1</standaardafwijking>
+      </stochast>
+      <stochast naam="modelfactoroverloopdebiet">
+        <verwachtingswaarde>0.1</verwachtingswaarde>
+        <standaardafwijking>0.12</standaardafwijking>
+      </stochast>
+      <stochast naam="afvoercoefficient">
+        <verwachtingswaarde>0.1</verwachtingswaarde>
+        <standaardafwijking>0.12</standaardafwijking>
+      </stochast>
+      <stochast naam="breedtedoorstroomopening">
+        <verwachtingswaarde>15.2</verwachtingswaarde>
+        <standaardafwijking>0.1</standaardafwijking>
+      </stochast>
+      <stochast naam="doorstroomoppervlak">
+        <verwachtingswaarde>80.5</verwachtingswaarde>
+        <standaardafwijking>1</standaardafwijking>
+      </stochast>
+      <stochast naam="breedtebodembescherming">
+        <verwachtingswaarde>15.2</verwachtingswaarde>
+        <standaardafwijking>0.1</standaardafwijking>
+      </stochast>
+      <stochast naam="kombergendoppervlak">
+        <verwachtingswaarde>15000</verwachtingswaarde>
+        <variatiecoefficient>0.01</variatiecoefficient>
+      </stochast>
+      <stochast naam="peilverhogingkomberging">
+        <verwachtingswaarde>0.2</verwachtingswaarde>
+        <standaardafwijking>0.01</standaardafwijking>
+      </stochast>
+      <stochast naam="kerendehoogte">
+        <verwachtingswaarde>4.3</verwachtingswaarde>
+        <standaardafwijking>0.1</standaardafwijking>
+      </stochast>
+      <stochast naam="drempelhoogte">
+        <verwachtingswaarde>1.2</verwachtingswaarde>
+        <standaardafwijking>0.1</standaardafwijking>
+      </stochast>
+      <stochast naam="kritiekinstromenddebiet">
+        <verwachtingswaarde>2</verwachtingswaarde>
+        <variatiecoefficient>0.1</variatiecoefficient>
+      </stochast>
+      <stochast naam="kritiekestroomsnelheid">
+        <verwachtingswaarde>1.1</verwachtingswaarde>
+        <variatiecoefficient>0.12</variatiecoefficient>
+      </stochast>
+      <stochast naam="kwadratischebelastingschematiseringsterkte">
+        <verwachtingswaarde>2</verwachtingswaarde>
+        <variatiecoefficient>0.1</variatiecoefficient>
+      </stochast>
+      <stochast naam="lineairebelastingschematiseringsterkte">
+        <verwachtingswaarde>2</verwachtingswaarde>
+        <variatiecoefficient>0.1</variatiecoefficient>
+      </stochast>
+      <stochast naam="bermbreedte">
+        <verwachtingswaarde>1.2</verwachtingswaarde>
+        <standaardafwijking>0.1</standaardafwijking>
+      </stochast>
+      <stochast naam="aanvaarenergie">
+        <verwachtingswaarde>1.2</verwachtingswaarde>
+        <variatiecoefficient>0.1</variatiecoefficient>
+      </stochast>
+      <stochast naam="massaschip">
+        <verwachtingswaarde>16000</verwachtingswaarde>
+        <variatiecoefficient>0.1</variatiecoefficient>
+      </stochast>
+      <stochast naam="aanvaarsnelheid">
+        <verwachtingswaarde>1.2</verwachtingswaarde>
+        <variatiecoefficient>0.1</variatiecoefficient>
+      </stochast>
+      <stochast naam="kwadratischebelastingschematiseringstabiliteit">
+        <verwachtingswaarde>1.2</verwachtingswaarde>
+        <variatiecoefficient>0.1</variatiecoefficient>
+      </stochast>
+      <stochast naam="lineairebelastingschematiseringstabiliteit">
+        <verwachtingswaarde>1.2</verwachtingswaarde>
+        <variatiecoefficient>0.1</variatiecoefficient>
+      </stochast>
+    </stochasten>
+  </berekening>
+</configuratie>
\ No newline at end of file
Index: Ringtoets/StabilityPointStructures/test/Ringtoets.StabilityPointStructures.IO.Test/test-data/StabilityPointStructuresCalculationConfigurationImporter/validConfigurationUnknownForeshoreProfile.xml
===================================================================
diff -u
--- Ringtoets/StabilityPointStructures/test/Ringtoets.StabilityPointStructures.IO.Test/test-data/StabilityPointStructuresCalculationConfigurationImporter/validConfigurationUnknownForeshoreProfile.xml	(revision 0)
+++ Ringtoets/StabilityPointStructures/test/Ringtoets.StabilityPointStructures.IO.Test/test-data/StabilityPointStructuresCalculationConfigurationImporter/validConfigurationUnknownForeshoreProfile.xml	(revision 3ca074d78bf75ff67c19539c04be91196a0659b0)
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="utf-8"?>
+<configuratie>
+  <berekening naam="Berekening 1">
+    <voorlandprofiel>unknown</voorlandprofiel>
+  </berekening>
+</configuratie>
Index: Ringtoets/StabilityPointStructures/test/Ringtoets.StabilityPointStructures.IO.Test/test-data/StabilityPointStructuresCalculationConfigurationImporter/validConfigurationUnknownHydraulicBoundaryLocation.xml
===================================================================
diff -u
--- Ringtoets/StabilityPointStructures/test/Ringtoets.StabilityPointStructures.IO.Test/test-data/StabilityPointStructuresCalculationConfigurationImporter/validConfigurationUnknownHydraulicBoundaryLocation.xml	(revision 0)
+++ Ringtoets/StabilityPointStructures/test/Ringtoets.StabilityPointStructures.IO.Test/test-data/StabilityPointStructuresCalculationConfigurationImporter/validConfigurationUnknownHydraulicBoundaryLocation.xml	(revision 3ca074d78bf75ff67c19539c04be91196a0659b0)
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="utf-8"?>
+<configuratie>
+  <berekening naam="Berekening 1">
+    <hrlocatie>unknown</hrlocatie>
+  </berekening>
+</configuratie>
Index: Ringtoets/StabilityPointStructures/test/Ringtoets.StabilityPointStructures.IO.Test/test-data/StabilityPointStructuresCalculationConfigurationImporter/validConfigurationUnknownStructure.xml
===================================================================
diff -u
--- Ringtoets/StabilityPointStructures/test/Ringtoets.StabilityPointStructures.IO.Test/test-data/StabilityPointStructuresCalculationConfigurationImporter/validConfigurationUnknownStructure.xml	(revision 0)
+++ Ringtoets/StabilityPointStructures/test/Ringtoets.StabilityPointStructures.IO.Test/test-data/StabilityPointStructuresCalculationConfigurationImporter/validConfigurationUnknownStructure.xml	(revision 3ca074d78bf75ff67c19539c04be91196a0659b0)
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="utf-8"?>
+<configuratie>
+  <berekening naam="Berekening 1">
+    <kunstwerk>unknown</kunstwerk>
+  </berekening>
+</configuratie>