Index: Ringtoets/Common/src/Ringtoets.Common.IO/Configurations/StructuresCalculationConfiguration.cs
===================================================================
diff -u -rd393a6e22ba176f0ce9731629a37ce3272b1f433 -r43b7d2fe7b1c4209fd2afcd985a5c1f4b7bf14e9
--- Ringtoets/Common/src/Ringtoets.Common.IO/Configurations/StructuresCalculationConfiguration.cs	(.../StructuresCalculationConfiguration.cs)	(revision d393a6e22ba176f0ce9731629a37ce3272b1f433)
+++ Ringtoets/Common/src/Ringtoets.Common.IO/Configurations/StructuresCalculationConfiguration.cs	(.../StructuresCalculationConfiguration.cs)	(revision 43b7d2fe7b1c4209fd2afcd985a5c1f4b7bf14e9)
@@ -61,12 +61,12 @@
         }
 
         /// <summary>
-        /// Gets or sets the stochast configuration for the model factor super critical flow.
+        /// Gets or sets the name of the structure.
         /// </summary>
         public string StructureName { get; set; }
 
         /// <summary>
-        /// Gets or sets the stochast configuration for the model factor super critical flow.
+        /// Gets or sets the name of the hydraulic boundary location.
         /// </summary>
         public string HydraulicBoundaryLocationName { get; set; }
 
@@ -81,7 +81,7 @@
         public MeanVariationCoefficientStochastConfiguration StormDuration { get; set; }
 
         /// <summary>
-        /// Gets or sets the stochast configuration for the structure's normal orientation.
+        /// Gets or sets the structure's normal orientation.
         /// </summary>
         public double? StructureNormalOrientation { get; set; }
 
@@ -106,8 +106,7 @@
         public MeanVariationCoefficientStochastConfiguration CriticalOvertoppingDischarge { get; set; }
 
         /// <summary>
-        /// Gets or sets the stochast configuration for the failure probability of structure
-        /// with erosion.
+        /// Gets or sets the failure probability of structure with erosion.
         /// </summary>
         public double? FailureProbabilityStructureWithErosion { get; set; }
 
Index: Ringtoets/Common/src/Ringtoets.Common.IO/Exporters/CalculationConfigurationExporter.cs
===================================================================
diff -u -r8437756db2a32c47155d3b4b490aaf9f33d21c7f -r43b7d2fe7b1c4209fd2afcd985a5c1f4b7bf14e9
--- Ringtoets/Common/src/Ringtoets.Common.IO/Exporters/CalculationConfigurationExporter.cs	(.../CalculationConfigurationExporter.cs)	(revision 8437756db2a32c47155d3b4b490aaf9f33d21c7f)
+++ Ringtoets/Common/src/Ringtoets.Common.IO/Exporters/CalculationConfigurationExporter.cs	(.../CalculationConfigurationExporter.cs)	(revision 43b7d2fe7b1c4209fd2afcd985a5c1f4b7bf14e9)
@@ -73,7 +73,7 @@
             }
             catch (CriticalFileWriteException e)
             {
-                log.ErrorFormat(Resources.CalculationConfigurationExporter_Export_Exception_0_no_configuration_exported, e.Message);
+                log.ErrorFormat(Resources.CalculationConfigurationExporter_Export_ExceptionMessage_0_no_configuration_exported, e.Message);
                 return false;
             }
 
Index: Ringtoets/Common/src/Ringtoets.Common.IO/Exporters/SchemaCalculationConfigurationExporter.cs
===================================================================
diff -u -re50b6ad32d33acb630c391bce2a6d359cc7e2b28 -r43b7d2fe7b1c4209fd2afcd985a5c1f4b7bf14e9
--- Ringtoets/Common/src/Ringtoets.Common.IO/Exporters/SchemaCalculationConfigurationExporter.cs	(.../SchemaCalculationConfigurationExporter.cs)	(revision e50b6ad32d33acb630c391bce2a6d359cc7e2b28)
+++ Ringtoets/Common/src/Ringtoets.Common.IO/Exporters/SchemaCalculationConfigurationExporter.cs	(.../SchemaCalculationConfigurationExporter.cs)	(revision 43b7d2fe7b1c4209fd2afcd985a5c1f4b7bf14e9)
@@ -27,7 +27,6 @@
 using Ringtoets.Common.Data.Calculation;
 using Ringtoets.Common.IO.Configurations;
 using Ringtoets.Common.IO.Properties;
-using Ringtoets.Common.IO.Readers;
 using Ringtoets.Common.IO.Writers;
 
 namespace Ringtoets.Common.IO.Exporters
@@ -36,9 +35,11 @@
     /// Base class for exporting a calculation configuration and storing it as an XML file.
     /// </summary>
     /// <typeparam name="TWriter">The <see cref="SchemaCalculationConfigurationWriter{T}"/> 
-    /// to use for exporting <see cref="TCalculation"/>.</typeparam>
-    /// <typeparam name="TCalculation">The <see cref="TCalculation"/> type to export.</typeparam>
-    /// <typeparam name="TConfiguration">The type of the calculations after conversion for writing.</typeparam>
+    /// to use for exporting <typeparamref name="TCalculation"/>.</typeparam>
+    /// <typeparam name="TCalculation">The <see cref="ICalculation"/> type to export.</typeparam>
+    /// <typeparam name="TConfiguration">The <see cref="IConfigurationItem"/> type used to convert 
+    /// <typeparamref name="TCalculation"/> into before writing to XML using a <typeparamref name="TWriter"/>.
+    /// </typeparam>
     public abstract class SchemaCalculationConfigurationExporter<TWriter, TCalculation, TConfiguration> : IFileExporter
         where TWriter : SchemaCalculationConfigurationWriter<TConfiguration>
         where TCalculation : class, ICalculation
@@ -51,18 +52,19 @@
         /// <summary>
         /// Creates a new instance of <see cref="SchemaCalculationConfigurationExporter{TWriter,TCalculation,TConfiguration}"/>.
         /// </summary>
-        /// <param name="calculations">The calculation configuration to export.</param>
+        /// <param name="calculations">The hierarchy of calculations to export.</param>
         /// <param name="filePath">The path of the XML file to export to.</param>
         /// <exception cref="ArgumentNullException">Thrown when <paramref name="calculations"/> is <c>null</c>.</exception>
-        /// <exception cref="ArgumentException">Thrown when <paramref name="filePath"/> is invalid.</exception>
+        /// <exception cref="ArgumentException">Thrown when <paramref name="filePath"/> is invalid or when any element
+        /// of <paramref name="calculations"/> is <c>null</c>.</exception>
         protected SchemaCalculationConfigurationExporter(IEnumerable<ICalculationBase> calculations, string filePath)
         {
             if (calculations == null)
             {
                 throw new ArgumentNullException(nameof(calculations));
             }
 
-            writer = (TWriter) Activator.CreateInstance(typeof(TWriter), filePath);
+            writer = CreateWriter(filePath);
             configuration = ToConfiguration(calculations);
         }
 
@@ -74,14 +76,21 @@
             }
             catch (CriticalFileWriteException e)
             {
-                log.ErrorFormat(Resources.CalculationConfigurationExporter_Export_Exception_0_no_configuration_exported, e.Message);
+                log.ErrorFormat(Resources.CalculationConfigurationExporter_Export_ExceptionMessage_0_no_configuration_exported, e.Message);
                 return false;
             }
 
             return true;
         }
 
         /// <summary>
+        /// Creates the writer that will be used in the <see cref="SchemaCalculationConfigurationExporter{TWriter,TCalculation,TConfiguration}"/>.
+        /// </summary>
+        /// <param name="filePath">The path of the file to export to.</param>
+        /// <returns>A new <typeparamref name="TWriter"/>.</returns>
+        protected abstract TWriter CreateWriter(string filePath);
+
+        /// <summary>
         /// Converts the <paramref name="calculation"/> to a <typeparamref name="TConfiguration"/>.
         /// </summary>
         /// <param name="calculation">The <typeparamref name="TCalculation"/> to convert.</param>
Index: Ringtoets/Common/src/Ringtoets.Common.IO/Properties/Resources.Designer.cs
===================================================================
diff -u -rd393a6e22ba176f0ce9731629a37ce3272b1f433 -r43b7d2fe7b1c4209fd2afcd985a5c1f4b7bf14e9
--- Ringtoets/Common/src/Ringtoets.Common.IO/Properties/Resources.Designer.cs	(.../Resources.Designer.cs)	(revision d393a6e22ba176f0ce9731629a37ce3272b1f433)
+++ Ringtoets/Common/src/Ringtoets.Common.IO/Properties/Resources.Designer.cs	(.../Resources.Designer.cs)	(revision 43b7d2fe7b1c4209fd2afcd985a5c1f4b7bf14e9)
@@ -84,9 +84,10 @@
         /// <summary>
         ///   Looks up a localized string similar to {0} Er is geen configuratie geëxporteerd..
         /// </summary>
-        public static string CalculationConfigurationExporter_Export_Exception_0_no_configuration_exported {
+        public static string CalculationConfigurationExporter_Export_ExceptionMessage_0_no_configuration_exported {
             get {
-                return ResourceManager.GetString("CalculationConfigurationExporter_Export_Exception_0_no_configuration_exported", resourceCulture);
+                return ResourceManager.GetString("CalculationConfigurationExporter_Export_ExceptionMessage_0_no_configuration_expor" +
+                        "ted", resourceCulture);
             }
         }
         
Index: Ringtoets/Common/src/Ringtoets.Common.IO/Properties/Resources.resx
===================================================================
diff -u -rd393a6e22ba176f0ce9731629a37ce3272b1f433 -r43b7d2fe7b1c4209fd2afcd985a5c1f4b7bf14e9
--- Ringtoets/Common/src/Ringtoets.Common.IO/Properties/Resources.resx	(.../Resources.resx)	(revision d393a6e22ba176f0ce9731629a37ce3272b1f433)
+++ Ringtoets/Common/src/Ringtoets.Common.IO/Properties/Resources.resx	(.../Resources.resx)	(revision 43b7d2fe7b1c4209fd2afcd985a5c1f4b7bf14e9)
@@ -513,7 +513,7 @@
   <data name="Importer_ProgressText_Validating_imported_data" xml:space="preserve">
     <value>Valideren van ingelezen data.</value>
   </data>
-  <data name="CalculationConfigurationExporter_Export_Exception_0_no_configuration_exported" xml:space="preserve">
+  <data name="CalculationConfigurationExporter_Export_ExceptionMessage_0_no_configuration_exported" xml:space="preserve">
     <value>{0} Er is geen configuratie geëxporteerd.</value>
   </data>
   <data name="ConfiguratieSchema" type="System.Resources.ResXFileRef, System.Windows.Forms">
Index: Ringtoets/Common/src/Ringtoets.Common.IO/Writers/SchemaCalculationConfigurationWriter.cs
===================================================================
diff -u -re50b6ad32d33acb630c391bce2a6d359cc7e2b28 -r43b7d2fe7b1c4209fd2afcd985a5c1f4b7bf14e9
--- Ringtoets/Common/src/Ringtoets.Common.IO/Writers/SchemaCalculationConfigurationWriter.cs	(.../SchemaCalculationConfigurationWriter.cs)	(revision e50b6ad32d33acb630c391bce2a6d359cc7e2b28)
+++ Ringtoets/Common/src/Ringtoets.Common.IO/Writers/SchemaCalculationConfigurationWriter.cs	(.../SchemaCalculationConfigurationWriter.cs)	(revision 43b7d2fe7b1c4209fd2afcd985a5c1f4b7bf14e9)
@@ -26,7 +26,6 @@
 using Core.Common.Utils;
 using Core.Common.Utils.Properties;
 using Ringtoets.Common.IO.Configurations;
-using Ringtoets.Common.IO.Readers;
 using Ringtoets.Common.IO.Schema;
 
 namespace Ringtoets.Common.IO.Writers
@@ -62,8 +61,7 @@
         /// </summary>
         /// <param name="configuration">The calculation configuration to write.</param>
         /// <exception cref="ArgumentNullException">Thrown when any parameter is <c>null</c>.</exception>
-        /// <exception cref="CriticalFileWriteException">Thrown when unable to write the file to the file path provided to
-        /// the <see cref="SchemaCalculationConfigurationWriter{T}"/>.</exception>
+        /// <exception cref="CriticalFileWriteException">Thrown when unable to write the file to the provided file path.</exception>
         public void Write(IEnumerable<IConfigurationItem> configuration)
         {
             if (configuration == null)
@@ -104,6 +102,79 @@
         protected abstract void WriteCalculation(T calculation, XmlWriter writer);
 
         /// <summary>
+        /// Writes a distribution configuration when it has a value.
+        /// </summary>
+        /// <param name="writer">The writer to use for writing.</param>
+        /// <param name="distributionName">The name of the distribution.</param>
+        /// <param name="configuration">The configuration for the distribution that can be <c>null</c>.</param>
+        protected static void WriteDistributionWhenAvailable(XmlWriter writer, string distributionName, MeanVariationCoefficientStochastConfiguration configuration)
+        {
+            if (configuration != null)
+            {
+                writer.WriteDistribution(distributionName, configuration);
+            }
+        }
+
+        /// <summary>
+        /// Writes a distribution configuration when it has a value.
+        /// </summary>
+        /// <param name="writer">The writer to use for writing.</param>
+        /// <param name="distributionName">The name of the distribution.</param>
+        /// <param name="configuration">The configuration for the distribution that can be <c>null</c>.</param>
+        protected static void WriteDistributionWhenAvailable(XmlWriter writer, string distributionName, MeanStandardDeviationStochastConfiguration configuration)
+        {
+            if (configuration != null)
+            {
+                writer.WriteDistribution(distributionName, configuration);
+            }
+        }
+
+        /// <summary>
+        /// Writes an element with some content when the content has a value.
+        /// </summary>
+        /// <param name="writer">The writer to use for writing.</param>
+        /// <param name="elementName">The name of the element.</param>
+        /// <param name="elementContent">The content of the element that can be <c>null</c>.</param>
+        protected static void WriteElementWhenContentAvailable(XmlWriter writer, string elementName, string elementContent)
+        {
+            if (elementContent != null)
+            {
+                writer.WriteElementString(
+                    elementName,
+                    elementContent);
+            }
+        }
+
+        /// <summary>
+        /// Writes an element with some content when the content has a value.
+        /// </summary>
+        /// <param name="writer">The writer to use for writing.</param>
+        /// <param name="elementName">The name of the element.</param>
+        /// <param name="elementContent">The content of the element that can be <c>null</c>.</param>
+        protected static void WriteElementWhenContentAvailable(XmlWriter writer, string elementName, double? elementContent)
+        {
+            if (elementContent.HasValue)
+            {
+                writer.WriteElementString(
+                    elementName,
+                    XmlConvert.ToString(elementContent.Value));
+            }
+        }
+
+        /// <summary>
+        /// Writes a wave reduction configuration when it has a value.
+        /// </summary>
+        /// <param name="writer">The writer to use for writing.</param>
+        /// <param name="configuration">The configuration for the wave reduction that can be <c>null</c>.</param>
+        protected static void WriteWaveReductionWhenAvailable(XmlWriter writer, WaveReductionConfiguration configuration)
+        {
+            if (configuration != null)
+            {
+                writer.WriteWaveReduction(configuration);
+            }
+        }
+
+        /// <summary>
         /// Writes the <paramref name="configuration"/> in XML format to file.
         /// </summary>
         /// <param name="configuration">The calculation group(s) and/or calculation(s) to write.</param>
Index: Ringtoets/Common/src/Ringtoets.Common.IO/Writers/StructureCalculationConfigurationWriter.cs
===================================================================
diff -u -rd393a6e22ba176f0ce9731629a37ce3272b1f433 -r43b7d2fe7b1c4209fd2afcd985a5c1f4b7bf14e9
--- Ringtoets/Common/src/Ringtoets.Common.IO/Writers/StructureCalculationConfigurationWriter.cs	(.../StructureCalculationConfigurationWriter.cs)	(revision d393a6e22ba176f0ce9731629a37ce3272b1f433)
+++ Ringtoets/Common/src/Ringtoets.Common.IO/Writers/StructureCalculationConfigurationWriter.cs	(.../StructureCalculationConfigurationWriter.cs)	(revision 43b7d2fe7b1c4209fd2afcd985a5c1f4b7bf14e9)
@@ -51,84 +51,34 @@
             writer.WriteStartElement(ConfigurationSchemaIdentifiers.CalculationElement);
             writer.WriteAttributeString(ConfigurationSchemaIdentifiers.NameAttribute, configuration.Name);
 
-            if (configuration.HydraulicBoundaryLocationName != null)
-            {
-                writer.WriteElementString(
-                    ConfigurationSchemaIdentifiers.HydraulicBoundaryLocationElement,
-                    configuration.HydraulicBoundaryLocationName);
-            }
+            WriteParameters(configuration, writer);
 
-            if (configuration.StructureName != null)
-            {
-                writer.WriteElementString(
-                    ConfigurationSchemaIdentifiers.StructureElement,
-                    configuration.StructureName);
-            }
+            WriteWaveReductionWhenAvailable(writer, configuration.WaveReduction);
 
-            if (configuration.StructureNormalOrientation.HasValue)
-            {
-                writer.WriteElementString(
-                    ConfigurationSchemaIdentifiers.Orientation,
-                    XmlConvert.ToString(configuration.StructureNormalOrientation.Value));
-            }
+            WriteStochasts(configuration, writer);
 
-            if (configuration.FailureProbabilityStructureWithErosion.HasValue)
-            {
-                writer.WriteElementString(
-                    ConfigurationSchemaIdentifiers.FailureProbabilityStructureWithErosionElement,
-                    XmlConvert.ToString(configuration.FailureProbabilityStructureWithErosion.Value));
-            }
+            writer.WriteEndElement();
+        }
 
-            if (configuration.ForeshoreProfileName != null)
-            {
-                writer.WriteElementString(
-                    ConfigurationSchemaIdentifiers.ForeshoreProfileNameElement,
-                    configuration.ForeshoreProfileName);
-            }
+        private void WriteParameters(T configuration, XmlWriter writer)
+        {
+            WriteElementWhenContentAvailable(writer,
+                                             ConfigurationSchemaIdentifiers.HydraulicBoundaryLocationElement,
+                                             configuration.HydraulicBoundaryLocationName);
+            WriteElementWhenContentAvailable(writer,
+                                             ConfigurationSchemaIdentifiers.StructureElement,
+                                             configuration.StructureName);
+            WriteElementWhenContentAvailable(writer,
+                                             ConfigurationSchemaIdentifiers.Orientation,
+                                             configuration.StructureNormalOrientation);
+            WriteElementWhenContentAvailable(writer,
+                                             ConfigurationSchemaIdentifiers.FailureProbabilityStructureWithErosionElement,
+                                             configuration.FailureProbabilityStructureWithErosion);
+            WriteElementWhenContentAvailable(writer,
+                                             ConfigurationSchemaIdentifiers.ForeshoreProfileNameElement,
+                                             configuration.ForeshoreProfileName);
 
-            if (configuration.WaveReduction != null)
-            {
-                writer.WriteWaveReduction(configuration.WaveReduction);
-            }
-
             WriteSpecificStructureParameters(configuration, writer);
-
-            writer.WriteStartElement(ConfigurationSchemaIdentifiers.StochastsElement);
-
-            if (configuration.FlowWidthAtBottomProtection != null)
-            {
-                writer.WriteDistribution(ConfigurationSchemaIdentifiers.FlowWidthAtBottomProtectionStochastName, configuration.FlowWidthAtBottomProtection);
-            }
-            if (configuration.WidthFlowApertures != null)
-            {
-                writer.WriteDistribution(ConfigurationSchemaIdentifiers.WidthFlowAperturesStochastName, configuration.WidthFlowApertures);
-            }
-            if (configuration.StorageStructureArea != null)
-            {
-                writer.WriteDistribution(ConfigurationSchemaIdentifiers.StorageStructureAreaStochastName, configuration.StorageStructureArea);
-            }
-            if (configuration.CriticalOvertoppingDischarge != null)
-            {
-                writer.WriteDistribution(ConfigurationSchemaIdentifiers.CriticalOvertoppingDischargeStochastName, configuration.CriticalOvertoppingDischarge);
-            }
-            if (configuration.ModelFactorSuperCriticalFlow != null)
-            {
-                writer.WriteDistribution(ConfigurationSchemaIdentifiers.ModelFactorSuperCriticalFlowStochastName, configuration.ModelFactorSuperCriticalFlow);
-            }
-            if (configuration.AllowedLevelIncreaseStorage != null)
-            {
-                writer.WriteDistribution(ConfigurationSchemaIdentifiers.AllowedLevelIncreaseStorageStochastName, configuration.AllowedLevelIncreaseStorage);
-            }
-            if (configuration.StormDuration != null)
-            {
-                writer.WriteDistribution(ConfigurationSchemaIdentifiers.StormDurationStochastName, configuration.StormDuration);
-            }
-
-            WriteSpecificStochasts(configuration, writer);
-
-            writer.WriteEndElement();
-
-            writer.WriteEndElement();
         }
 
         /// <summary>
@@ -140,11 +90,42 @@
         protected abstract void WriteSpecificStructureParameters(T configuration, XmlWriter writer);
 
         /// <summary>        
-        /// Writes stochats definitions specific for a structure of type <typeparamref name="T"/>.
+        /// Writes stochasts definitions specific for a structure of type <typeparamref name="T"/>.
         /// </summary>
         /// <param name="configuration">The instance of type <typeparamref name="T"/> for which
         /// to write the stochasts.</param>
         /// <param name="writer">The writer that should be used to write the parameters.</param>
         protected abstract void WriteSpecificStochasts(T configuration, XmlWriter writer);
+
+        private void WriteStochasts(T configuration, XmlWriter writer)
+        {
+            writer.WriteStartElement(ConfigurationSchemaIdentifiers.StochastsElement);
+
+            WriteDistributionWhenAvailable(writer,
+                                           ConfigurationSchemaIdentifiers.FlowWidthAtBottomProtectionStochastName,
+                                           configuration.FlowWidthAtBottomProtection);
+            WriteDistributionWhenAvailable(writer,
+                                           ConfigurationSchemaIdentifiers.WidthFlowAperturesStochastName,
+                                           configuration.WidthFlowApertures);
+            WriteDistributionWhenAvailable(writer,
+                                           ConfigurationSchemaIdentifiers.StorageStructureAreaStochastName,
+                                           configuration.StorageStructureArea);
+            WriteDistributionWhenAvailable(writer,
+                                           ConfigurationSchemaIdentifiers.CriticalOvertoppingDischargeStochastName,
+                                           configuration.CriticalOvertoppingDischarge);
+            WriteDistributionWhenAvailable(writer,
+                                           ConfigurationSchemaIdentifiers.ModelFactorSuperCriticalFlowStochastName,
+                                           configuration.ModelFactorSuperCriticalFlow);
+            WriteDistributionWhenAvailable(writer,
+                                           ConfigurationSchemaIdentifiers.AllowedLevelIncreaseStorageStochastName,
+                                           configuration.AllowedLevelIncreaseStorage);
+            WriteDistributionWhenAvailable(writer,
+                                           ConfigurationSchemaIdentifiers.StormDurationStochastName,
+                                           configuration.StormDuration);
+
+            WriteSpecificStochasts(configuration, writer);
+
+            writer.WriteEndElement();
+        }
     }
 }
\ No newline at end of file
Index: Ringtoets/Common/test/Ringtoets.Common.IO.Test/Exporters/SchemaCalculationConfigurationExporterTest.cs
===================================================================
diff -u
--- Ringtoets/Common/test/Ringtoets.Common.IO.Test/Exporters/SchemaCalculationConfigurationExporterTest.cs	(revision 0)
+++ Ringtoets/Common/test/Ringtoets.Common.IO.Test/Exporters/SchemaCalculationConfigurationExporterTest.cs	(revision 43b7d2fe7b1c4209fd2afcd985a5c1f4b7bf14e9)
@@ -0,0 +1,63 @@
+// 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.Collections.Generic;
+using NUnit.Framework;
+using Ringtoets.Common.Data.Calculation;
+using Ringtoets.Common.Data.TestUtil;
+using Ringtoets.Common.IO.Exporters;
+using Ringtoets.Common.IO.TestUtil;
+
+namespace Ringtoets.Common.IO.Test.Exporters
+{
+    [TestFixture]
+    public class SchemaCalculationConfigurationExporterTest
+        : CustomSchemaCalculationConfigurationExporterDesignGuidelinesTestFixture<
+            SimpleStructuresCalculationConfigurationExporter,
+            TestSchemaCalculationConfigurationWriter,
+            TestCalculation,
+            TestConfigurationItem>
+    {
+        protected override TestCalculation CreateCalculation()
+        {
+            return new TestCalculation("some name");
+        }
+
+        protected override SimpleStructuresCalculationConfigurationExporter CallConfigurationFilePathConstructor(IEnumerable<ICalculationBase> calculations, string filePath)
+        {
+            return new SimpleStructuresCalculationConfigurationExporter(calculations, filePath);
+        }
+    }
+
+    public class SimpleStructuresCalculationConfigurationExporter
+        : SchemaCalculationConfigurationExporter<TestSchemaCalculationConfigurationWriter, TestCalculation, TestConfigurationItem> {
+        public SimpleStructuresCalculationConfigurationExporter(IEnumerable<ICalculationBase> calculations, string filePath) : base(calculations, filePath) {}
+        protected override TestSchemaCalculationConfigurationWriter CreateWriter(string filePath)
+        {
+            return new TestSchemaCalculationConfigurationWriter(filePath);
+        }
+
+        protected override TestConfigurationItem ToConfiguration(TestCalculation calculation)
+        {
+            throw new System.NotImplementedException();
+        }
+    }
+}
\ No newline at end of file
Index: Ringtoets/Common/test/Ringtoets.Common.IO.Test/Ringtoets.Common.IO.Test.csproj
===================================================================
diff -u -rcc1268d7cb906524d4cabcd4cbd9ae16676cf059 -r43b7d2fe7b1c4209fd2afcd985a5c1f4b7bf14e9
--- Ringtoets/Common/test/Ringtoets.Common.IO.Test/Ringtoets.Common.IO.Test.csproj	(.../Ringtoets.Common.IO.Test.csproj)	(revision cc1268d7cb906524d4cabcd4cbd9ae16676cf059)
+++ Ringtoets/Common/test/Ringtoets.Common.IO.Test/Ringtoets.Common.IO.Test.csproj	(.../Ringtoets.Common.IO.Test.csproj)	(revision 43b7d2fe7b1c4209fd2afcd985a5c1f4b7bf14e9)
@@ -62,6 +62,7 @@
     <Compile Include="Configurations\MeanVariationCoefficientStochastConfigurationTest.cs" />
     <Compile Include="Configurations\MeanStandardDeviationStochastConfigurationTest.cs" />
     <Compile Include="Configurations\WaveReductionConfigurationTest.cs" />
+    <Compile Include="Exporters\SchemaCalculationConfigurationExporterTest.cs" />
     <Compile Include="IDistributionExtensionsTest.cs" />
     <Compile Include="ReadBreakWaterTypeConverterTest.cs" />
     <Compile Include="DikeProfiles\DikeProfileDataReaderTest.cs" />
Index: Ringtoets/Common/test/Ringtoets.Common.IO.Test/Writers/SchemaCalculationConfigurationWriterTest.cs
===================================================================
diff -u -re50b6ad32d33acb630c391bce2a6d359cc7e2b28 -r43b7d2fe7b1c4209fd2afcd985a5c1f4b7bf14e9
--- Ringtoets/Common/test/Ringtoets.Common.IO.Test/Writers/SchemaCalculationConfigurationWriterTest.cs	(.../SchemaCalculationConfigurationWriterTest.cs)	(revision e50b6ad32d33acb630c391bce2a6d359cc7e2b28)
+++ Ringtoets/Common/test/Ringtoets.Common.IO.Test/Writers/SchemaCalculationConfigurationWriterTest.cs	(.../SchemaCalculationConfigurationWriterTest.cs)	(revision 43b7d2fe7b1c4209fd2afcd985a5c1f4b7bf14e9)
@@ -23,13 +23,11 @@
 using System.IO;
 using System.Linq;
 using System.Xml;
-using Core.Common.IO.Exceptions;
 using Core.Common.TestUtil;
 using NUnit.Framework;
 using Rhino.Mocks;
 using Ringtoets.Common.Data.Calculation;
 using Ringtoets.Common.IO.Configurations;
-using Ringtoets.Common.IO.Readers;
 using Ringtoets.Common.IO.TestUtil;
 using Ringtoets.Common.IO.Writers;
 
@@ -38,7 +36,7 @@
     [TestFixture]
     public class SchemaCalculationConfigurationWriterTest
         : CustomSchemaCalculationConfigurationWriterDesignGuidelinesTestFixture<
-            SimpleSchemaCalculationConfigurationWriter,
+            TestSchemaCalculationConfigurationWriter,
             TestConfigurationItem>
     {
         [Test]
@@ -54,7 +52,7 @@
             try
             {
                 // Call
-                new SimpleSchemaCalculationConfigurationWriter(filePath).Write(configuration);
+                new TestSchemaCalculationConfigurationWriter(filePath).Write(configuration);
 
                 // Assert
                 Assert.IsTrue(File.Exists(filePath));
@@ -70,6 +68,203 @@
             }
         }
 
+        [Test]
+        public void WriteDistributionWhenAvailable_MeanStandardDeviationStochastConfigurationNull_WriterNotCalled()
+        {
+            // Setup
+            var mocks = new MockRepository();
+            var xmlWriter = mocks.StrictMock<XmlWriter>();
+            mocks.ReplayAll();
+
+            // Call
+            ExposedSchemaCalculationConfigurationWriter.PublicWriteDistributionWhenAvailable(
+                xmlWriter, 
+                "some name", 
+                (MeanStandardDeviationStochastConfiguration)null);
+
+            // Assert
+            mocks.VerifyAll();
+        }
+
+        [Test]
+        public void WriteDistributionWhenAvailable_MeanStandardDeviationStochastConfigurationSet_WriterCalledWithExpectedParameters()
+        {
+            // Setup
+            const string name = "some name";
+            var configuration = new MeanStandardDeviationStochastConfiguration();
+
+            var mocks = new MockRepository();
+            var xmlWriter = mocks.StrictMock<XmlWriter>();
+            xmlWriter.Expect(w => w.WriteDistribution(name, configuration));
+            mocks.ReplayAll();
+
+            // Call
+            ExposedSchemaCalculationConfigurationWriter.PublicWriteDistributionWhenAvailable(
+                xmlWriter, 
+                name, 
+                configuration);
+
+            // Assert
+            mocks.VerifyAll();
+        }
+
+        [Test]
+        public void WriteDistributionWhenAvailable_MeanVariationCoefficientStochastConfigurationNull_WriterNotCalled()
+        {
+            // Setup
+            var mocks = new MockRepository();
+            var xmlWriter = mocks.StrictMock<XmlWriter>();
+            mocks.ReplayAll();
+
+            // Call
+            ExposedSchemaCalculationConfigurationWriter.PublicWriteDistributionWhenAvailable(
+                xmlWriter, 
+                "some name", 
+                (MeanVariationCoefficientStochastConfiguration)null);
+
+            // Assert
+            mocks.VerifyAll();
+        }
+
+        [Test]
+        public void WriteDistributionWhenAvailable_MeanVariationCoefficientStochastConfigurationSet_WriterCalledWithExpectedParameters()
+        {
+            // Setup
+            const string name = "some name";
+            var configuration = new MeanVariationCoefficientStochastConfiguration();
+
+            var mocks = new MockRepository();
+            var xmlWriter = mocks.StrictMock<XmlWriter>();
+            xmlWriter.Expect(w => w.WriteDistribution(name, configuration));
+            mocks.ReplayAll();
+
+            // Call
+            ExposedSchemaCalculationConfigurationWriter.PublicWriteDistributionWhenAvailable(
+                xmlWriter,
+                name,
+                configuration);
+
+            // Assert
+            mocks.VerifyAll();
+        }
+
+        [Test]
+        public void WriteElementWhenContentAvailable_StringNull_WriterNotCalled()
+        {
+            // Setup
+            var mocks = new MockRepository();
+            var xmlWriter = mocks.StrictMock<XmlWriter>();
+            mocks.ReplayAll();
+
+            // Call
+            ExposedSchemaCalculationConfigurationWriter.PublicWriteElementWhenContentAvailable(
+                xmlWriter, 
+                "some name", 
+                (string)null);
+
+            // Assert
+            mocks.VerifyAll();
+        }
+
+        [Test]
+        public void WriteElementWhenContentAvailable_StringSet_WriterCalledWithExpectedParameters()
+        {
+            // Setup
+            const string name = "some name";
+            const string value = "some value";
+
+            var mocks = new MockRepository();
+            var xmlWriter = mocks.StrictMock<XmlWriter>();
+            xmlWriter.Expect(w => w.WriteElementString(name, value));
+            mocks.ReplayAll();
+
+            // Call
+            ExposedSchemaCalculationConfigurationWriter.PublicWriteElementWhenContentAvailable(
+                xmlWriter, 
+                name, 
+                value);
+
+            // Assert
+            mocks.VerifyAll();
+        }
+
+        [Test]
+        public void WriteElementWhenContentAvailable_DoubleNull_WriterNotCalled()
+        {
+            // Setup
+            var mocks = new MockRepository();
+            var xmlWriter = mocks.StrictMock<XmlWriter>();
+            mocks.ReplayAll();
+
+            // Call
+            ExposedSchemaCalculationConfigurationWriter.PublicWriteElementWhenContentAvailable(
+                xmlWriter, 
+                "some name", 
+                (double?)null);
+
+            // Assert
+            mocks.VerifyAll();
+        }
+
+        [Test]
+        public void WriteElementWhenContentAvailable_DoubleSet_WriterCalledWithExpectedParameters()
+        {
+            // Setup
+            const string name = "some name";
+            const double value = 3.2;
+
+            var mocks = new MockRepository();
+            var xmlWriter = mocks.StrictMock<XmlWriter>();
+            xmlWriter.Expect(w => w.WriteElementString(name, XmlConvert.ToString(value)));
+            mocks.ReplayAll();
+
+            // Call
+            ExposedSchemaCalculationConfigurationWriter.PublicWriteElementWhenContentAvailable(
+                xmlWriter,
+                name,
+                value);
+
+            // Assert
+            mocks.VerifyAll();
+        }
+
+        [Test]
+        public void WriteWaveReductionWhenAvailable_WaveReductionConfigurationNull_WriterNotCalled()
+        {
+            // Setup
+            var mocks = new MockRepository();
+            var xmlWriter = mocks.StrictMock<XmlWriter>();
+            mocks.ReplayAll();
+
+            // Call
+            ExposedSchemaCalculationConfigurationWriter.PublicWriteWaveReductionWhenAvailable(
+                xmlWriter,  
+                null);
+
+            // Assert
+            mocks.VerifyAll();
+        }
+
+        [Test]
+        public void WriteWaveReductionWhenAvailable_WaveReductionConfigurationSet_WriterCalledWithExpectedParameters()
+        {
+            // Setup
+            var configuration = new WaveReductionConfiguration();
+
+            var mocks = new MockRepository();
+            var xmlWriter = mocks.StrictMock<XmlWriter>();
+            xmlWriter.Expect(w => w.WriteWaveReduction(configuration));
+            mocks.ReplayAll();
+
+            // Call
+            ExposedSchemaCalculationConfigurationWriter.PublicWriteWaveReductionWhenAvailable(
+                xmlWriter,
+                configuration);
+
+            // Assert
+            mocks.VerifyAll();
+        }
+
         private static IEnumerable<TestCaseData> GetCalculationConfigurations()
         {
             var calculation1 = new TestConfigurationItem
@@ -120,26 +315,44 @@
                 .SetName("Calculation and group with nesting");
         }
 
-        protected override SimpleSchemaCalculationConfigurationWriter CreateWriterInstance(string filePath)
+        protected override TestSchemaCalculationConfigurationWriter CreateWriterInstance(string filePath)
         {
-            return new SimpleSchemaCalculationConfigurationWriter(filePath);
+            return new TestSchemaCalculationConfigurationWriter(filePath);
         }
     }
 
-    public class SimpleSchemaCalculationConfigurationWriter : SchemaCalculationConfigurationWriter<TestConfigurationItem>
+    public class ExposedSchemaCalculationConfigurationWriter : SchemaCalculationConfigurationWriter<TestConfigurationItem>
     {
-        public const string CalculationElementTag = "calculation";
+        public ExposedSchemaCalculationConfigurationWriter(string filePath) : base(filePath) {}
 
-        public SimpleSchemaCalculationConfigurationWriter(string filePath) : base(filePath) {}
+        public static void PublicWriteDistributionWhenAvailable(XmlWriter writer, string distributionName, MeanVariationCoefficientStochastConfiguration configuration)
+        {
+            WriteDistributionWhenAvailable(writer, distributionName, configuration);
+        }
 
+        public static void PublicWriteDistributionWhenAvailable(XmlWriter writer, string distributionName, MeanStandardDeviationStochastConfiguration configuration)
+        {
+            WriteDistributionWhenAvailable(writer, distributionName, configuration);
+        }
+
+        public static void PublicWriteElementWhenContentAvailable(XmlWriter writer, string elementName, string elementContent)
+        {
+            WriteElementWhenContentAvailable(writer, elementName, elementContent);
+        }
+
+        public static void PublicWriteElementWhenContentAvailable(XmlWriter writer, string elementName, double? elementContent)
+        {
+            WriteElementWhenContentAvailable(writer, elementName, elementContent);
+        }
+
+        public static void PublicWriteWaveReductionWhenAvailable(XmlWriter writer, WaveReductionConfiguration configuration)
+        {
+            WriteWaveReductionWhenAvailable(writer, configuration);
+        }
+
         protected override void WriteCalculation(TestConfigurationItem calculation, XmlWriter writer)
         {
-            writer.WriteElementString(CalculationElementTag, calculation.Name);
+            throw new System.NotImplementedException();
         }
     }
-
-    public class TestConfigurationItem : IConfigurationItem
-    {
-        public string Name { get; set; }
-    }
 }
\ No newline at end of file
Index: Ringtoets/Common/test/Ringtoets.Common.IO.Test/Writers/StructureCalculationConfigurationWriterTest.cs
===================================================================
diff -u -rd393a6e22ba176f0ce9731629a37ce3272b1f433 -r43b7d2fe7b1c4209fd2afcd985a5c1f4b7bf14e9
--- Ringtoets/Common/test/Ringtoets.Common.IO.Test/Writers/StructureCalculationConfigurationWriterTest.cs	(.../StructureCalculationConfigurationWriterTest.cs)	(revision d393a6e22ba176f0ce9731629a37ce3272b1f433)
+++ Ringtoets/Common/test/Ringtoets.Common.IO.Test/Writers/StructureCalculationConfigurationWriterTest.cs	(.../StructureCalculationConfigurationWriterTest.cs)	(revision 43b7d2fe7b1c4209fd2afcd985a5c1f4b7bf14e9)
@@ -37,26 +37,13 @@
             TestDataPath.Ringtoets.Common.IO,
             nameof(StructureCalculationConfigurationWriter<StructuresCalculationConfiguration>));
 
-        public static IEnumerable<TestCaseData> GetStructureCalculationsWithProperties()
-        {
-            yield return new TestCaseData(
-                    new SimpleStructuresCalculationConfiguration("some name"),
-                    "structureCalculationWithoutParametersSet.xml")
-                .SetName("Structure calculation without any of its paramters set.");
-
-            yield return new TestCaseData(
-                    CreateStructureWithAllParametersSet("some other name"),
-                    "structureCalculationWithAllParametersSet.xml")
-                .SetName("Structure calculation with all of its paramters set.");
-        }
-
         [Test]
         public void Write_WithoutConfiguration_ThrowsArgumentNullException()
         {
             // Setup
             string filePath = TestHelper.GetScratchPadPath("test.xml");
 
-            var writer = new SimpleStructureCalculationConfigurationWriter(filePath);
+            var writer = new SimpleStructureCalculationConfigurationWriter(filePath, false);
             {
                 // Call
                 TestDelegate test = () => writer.Write(null);
@@ -68,21 +55,20 @@
         }
 
         [Test]
-        [TestCaseSource(nameof(GetStructureCalculationsWithProperties))]
-        public void Write_WithoutDifferentSetParameters_WritesSetStructureProperties(StructuresCalculationConfiguration structuresCalculation, string fileName)
+        public void Write_WithAllParametersSet_WritesCalculationWithAllParametersAndStochasts()
         {
             // Setup
-            string filePath = TestHelper.GetScratchPadPath(nameof(Write_WithoutDifferentSetParameters_WritesSetStructureProperties));
+            string filePath = TestHelper.GetScratchPadPath(nameof(Write_WithAllParametersSet_WritesCalculationWithAllParametersAndStochasts));
             try
             {
-                var writer = new SimpleStructureCalculationConfigurationWriter(filePath);
+                var writer = new SimpleStructureCalculationConfigurationWriter(filePath, true);
 
                 // Call
-                writer.Write(new [] { structuresCalculation });
+                writer.Write(new [] { CreateStructureWithAllParametersSet("some other name") });
 
                 // Assert
                 string actualXml = File.ReadAllText(filePath);
-                string expectedXml = GetTestFileContent(fileName);
+                string expectedXml = GetTestFileContent("structureCalculationWithAllParametersSet.xml");
                 Assert.AreEqual(expectedXml, actualXml);
             }
             finally
@@ -91,6 +77,29 @@
             }
         }
 
+        [Test]
+        public void Write_WithoutParametersSet_WritesCalculationWithOnlyEmptyStochasts()
+        {
+            // Setup
+            string filePath = TestHelper.GetScratchPadPath(nameof(Write_WithoutParametersSet_WritesCalculationWithOnlyEmptyStochasts));
+            try
+            {
+                var writer = new SimpleStructureCalculationConfigurationWriter(filePath, false);
+
+                // Call
+                writer.Write(new [] { new SimpleStructuresCalculationConfiguration("some name") });
+
+                // Assert
+                string actualXml = File.ReadAllText(filePath);
+                string expectedXml = GetTestFileContent("structureCalculationWithoutParametersSet.xml");
+                Assert.AreEqual(expectedXml, actualXml);
+            }
+            finally
+            {
+                File.Delete(filePath);
+            }
+        }
+
         private static SimpleStructuresCalculationConfiguration CreateStructureWithAllParametersSet(string name)
         {
             return new SimpleStructuresCalculationConfiguration(name)
@@ -145,15 +154,6 @@
             };
         }
 
-        private static XmlWriter CreateXmlWriter(string filePath)
-        {
-            return XmlWriter.Create(filePath, new XmlWriterSettings
-            {
-                Indent = true,
-                ConformanceLevel = ConformanceLevel.Fragment
-            });
-        }
-
         private string GetTestFileContent(string testFile)
         {
             return File.ReadAllText(Path.Combine(testDirectory, testFile));
@@ -163,18 +163,30 @@
         {
             public SimpleStructuresCalculationConfiguration(string name) : base(name) {}
         }
+
         private class SimpleStructureCalculationConfigurationWriter : StructureCalculationConfigurationWriter<SimpleStructuresCalculationConfiguration>
         {
-            public SimpleStructureCalculationConfigurationWriter(string filePath) : base(filePath) {}
+            private readonly bool writeExtraParameterAndStochast;
 
+            public SimpleStructureCalculationConfigurationWriter(string filePath, bool writeExtraParameterAndStochast) : base(filePath)
+            {
+                this.writeExtraParameterAndStochast = writeExtraParameterAndStochast;
+            }
+
             protected override void WriteSpecificStructureParameters(SimpleStructuresCalculationConfiguration configuration, XmlWriter writer)
             {
-                // no specific parameters
+                if (writeExtraParameterAndStochast)
+                {
+                    writer.WriteElementString("testName", "testValue");
+                }
             }
 
             protected override void WriteSpecificStochasts(SimpleStructuresCalculationConfiguration configuration, XmlWriter writer)
             {
-                // no specific stochasts
+                if (writeExtraParameterAndStochast)
+                {
+                    writer.WriteDistribution("testStochastName", new MeanStandardDeviationStochastConfiguration());
+                }
             }
         }
     }
Index: Ringtoets/Common/test/Ringtoets.Common.IO.Test/test-data/StructureCalculationConfigurationWriter/structureCalculationWithAllParametersSet.xml
===================================================================
diff -u -rcc1268d7cb906524d4cabcd4cbd9ae16676cf059 -r43b7d2fe7b1c4209fd2afcd985a5c1f4b7bf14e9
--- Ringtoets/Common/test/Ringtoets.Common.IO.Test/test-data/StructureCalculationConfigurationWriter/structureCalculationWithAllParametersSet.xml	(.../structureCalculationWithAllParametersSet.xml)	(revision cc1268d7cb906524d4cabcd4cbd9ae16676cf059)
+++ Ringtoets/Common/test/Ringtoets.Common.IO.Test/test-data/StructureCalculationConfigurationWriter/structureCalculationWithAllParametersSet.xml	(.../structureCalculationWithAllParametersSet.xml)	(revision 43b7d2fe7b1c4209fd2afcd985a5c1f4b7bf14e9)
@@ -6,6 +6,7 @@
     <orientatie>5.6</orientatie>
     <faalkansgegevenerosiebodem>2.1</faalkansgegevenerosiebodem>
     <voorlandprofiel>Voorland</voorlandprofiel>
+    <testName>testValue</testName>
     <golfreductie>
       <damgebruiken>false</damgebruiken>
       <damtype>caisson</damtype>
@@ -41,6 +42,7 @@
         <verwachtingswaarde>21.22</verwachtingswaarde>
         <variatiecoefficient>1.2</variatiecoefficient>
       </stochast>
+      <stochast naam="testStochastName" />
     </stochasten>
   </berekening>
 </configuratie>
\ No newline at end of file
Index: Ringtoets/Common/test/Ringtoets.Common.IO.TestUtil/CustomSchemaCalculationConfigurationExporterDesignGuidelinesTestFixture.cs
===================================================================
diff -u -rcc1268d7cb906524d4cabcd4cbd9ae16676cf059 -r43b7d2fe7b1c4209fd2afcd985a5c1f4b7bf14e9
--- Ringtoets/Common/test/Ringtoets.Common.IO.TestUtil/CustomSchemaCalculationConfigurationExporterDesignGuidelinesTestFixture.cs	(.../CustomSchemaCalculationConfigurationExporterDesignGuidelinesTestFixture.cs)	(revision cc1268d7cb906524d4cabcd4cbd9ae16676cf059)
+++ Ringtoets/Common/test/Ringtoets.Common.IO.TestUtil/CustomSchemaCalculationConfigurationExporterDesignGuidelinesTestFixture.cs	(.../CustomSchemaCalculationConfigurationExporterDesignGuidelinesTestFixture.cs)	(revision 43b7d2fe7b1c4209fd2afcd985a5c1f4b7bf14e9)
@@ -23,15 +23,13 @@
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
-using System.Reflection;
 using System.Security.AccessControl;
 using System.Text;
 using Core.Common.TestUtil;
 using NUnit.Framework;
 using Ringtoets.Common.Data.Calculation;
 using Ringtoets.Common.IO.Configurations;
 using Ringtoets.Common.IO.Exporters;
-using Ringtoets.Common.IO.Readers;
 using Ringtoets.Common.IO.Writers;
 
 namespace Ringtoets.Common.IO.TestUtil
@@ -62,8 +60,7 @@
             TestDelegate test = () => CallConfigurationFilePathConstructor(Enumerable.Empty<ICalculationBase>(), filePath);
 
             // Assert
-            var activatorException = Assert.Throws<TargetInvocationException>(test);
-            var exception = (ArgumentException) activatorException.InnerException;
+            var exception = Assert.Throws<ArgumentException>(test);
             AssertInvalidFilePath(exception);
         }
 
Index: Ringtoets/Common/test/Ringtoets.Common.IO.TestUtil/Ringtoets.Common.IO.TestUtil.csproj
===================================================================
diff -u -rcc1268d7cb906524d4cabcd4cbd9ae16676cf059 -r43b7d2fe7b1c4209fd2afcd985a5c1f4b7bf14e9
--- Ringtoets/Common/test/Ringtoets.Common.IO.TestUtil/Ringtoets.Common.IO.TestUtil.csproj	(.../Ringtoets.Common.IO.TestUtil.csproj)	(revision cc1268d7cb906524d4cabcd4cbd9ae16676cf059)
+++ Ringtoets/Common/test/Ringtoets.Common.IO.TestUtil/Ringtoets.Common.IO.TestUtil.csproj	(.../Ringtoets.Common.IO.TestUtil.csproj)	(revision 43b7d2fe7b1c4209fd2afcd985a5c1f4b7bf14e9)
@@ -44,6 +44,7 @@
     </Reference>
     <Reference Include="System" />
     <Reference Include="System.Core" />
+    <Reference Include="System.Xml" />
   </ItemGroup>
   <ItemGroup>
     <Compile Include="..\..\..\..\Core\Common\src\Core.Common.Version\GlobalAssembly.cs">
@@ -54,6 +55,8 @@
     <Compile Include="CustomSchemaCalculationConfigurationWriterDesignGuidelinesTestFixture.cs" />
     <Compile Include="CustomCalculationConfigurationWriterDesignGuidelinesTestFixture.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
+    <Compile Include="TestConfigurationItem.cs" />
+    <Compile Include="TestSchemaCalculationConfigurationWriter.cs" />
   </ItemGroup>
   <ItemGroup>
     <None Include="..\..\..\..\build\Copying.licenseheader">
Index: Ringtoets/Common/test/Ringtoets.Common.IO.TestUtil/TestConfigurationItem.cs
===================================================================
diff -u
--- Ringtoets/Common/test/Ringtoets.Common.IO.TestUtil/TestConfigurationItem.cs	(revision 0)
+++ Ringtoets/Common/test/Ringtoets.Common.IO.TestUtil/TestConfigurationItem.cs	(revision 43b7d2fe7b1c4209fd2afcd985a5c1f4b7bf14e9)
@@ -0,0 +1,33 @@
+// 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 Ringtoets.Common.IO.Configurations;
+
+namespace Ringtoets.Common.IO.TestUtil
+{
+    /// <summary>
+    /// A simple implementation of <see cref="IConfigurationItem"/> that can be used for testing purposes.
+    /// </summary>
+    public class TestConfigurationItem : IConfigurationItem
+    {
+        public string Name { get; set; }
+    }
+}
\ No newline at end of file
Index: Ringtoets/Common/test/Ringtoets.Common.IO.TestUtil/TestSchemaCalculationConfigurationWriter.cs
===================================================================
diff -u
--- Ringtoets/Common/test/Ringtoets.Common.IO.TestUtil/TestSchemaCalculationConfigurationWriter.cs	(revision 0)
+++ Ringtoets/Common/test/Ringtoets.Common.IO.TestUtil/TestSchemaCalculationConfigurationWriter.cs	(revision 43b7d2fe7b1c4209fd2afcd985a5c1f4b7bf14e9)
@@ -0,0 +1,47 @@
+// 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.Xml;
+using Ringtoets.Common.IO.Writers;
+
+namespace Ringtoets.Common.IO.TestUtil
+{
+    /// <summary>
+    /// Simple <see cref="SchemaCalculationConfigurationWriter{T}"/> that can be used for testing purposes.
+    /// </summary>
+    public class TestSchemaCalculationConfigurationWriter : SchemaCalculationConfigurationWriter<TestConfigurationItem>
+    {
+        private const string calculationElementTag = "calculation";
+
+        /// <summary>
+        /// Creates a new instance of <see cref="TestSchemaCalculationConfigurationWriter"/>
+        /// </summary>
+        /// <param name="filePath">The path of the file to write to.</param>
+        /// <exception cref="ArgumentException">Thrown when <paramref name="filePath"/> is invalid.</exception>
+        public TestSchemaCalculationConfigurationWriter(string filePath) : base(filePath) {}
+
+        protected override void WriteCalculation(TestConfigurationItem calculation, XmlWriter writer)
+        {
+            writer.WriteElementString(calculationElementTag, calculation.Name);
+        }
+    }
+}
\ No newline at end of file
Index: Ringtoets/HeightStructures/src/Ringtoets.HeightStructures.IO/HeightStructuresCalculationConfigurationExporter.cs
===================================================================
diff -u -rd393a6e22ba176f0ce9731629a37ce3272b1f433 -r43b7d2fe7b1c4209fd2afcd985a5c1f4b7bf14e9
--- Ringtoets/HeightStructures/src/Ringtoets.HeightStructures.IO/HeightStructuresCalculationConfigurationExporter.cs	(.../HeightStructuresCalculationConfigurationExporter.cs)	(revision d393a6e22ba176f0ce9731629a37ce3272b1f433)
+++ Ringtoets/HeightStructures/src/Ringtoets.HeightStructures.IO/HeightStructuresCalculationConfigurationExporter.cs	(.../HeightStructuresCalculationConfigurationExporter.cs)	(revision 43b7d2fe7b1c4209fd2afcd985a5c1f4b7bf14e9)
@@ -120,5 +120,10 @@
 
             return calculationConfiguration;
         }
+
+        protected override HeightStructuresCalculationConfigurationWriter CreateWriter(string filePath)
+        {
+            return new HeightStructuresCalculationConfigurationWriter(filePath);
+        }
     }
 }
\ No newline at end of file
Index: Ringtoets/HeightStructures/src/Ringtoets.HeightStructures.IO/HeightStructuresCalculationConfigurationWriter.cs
===================================================================
diff -u -rd393a6e22ba176f0ce9731629a37ce3272b1f433 -r43b7d2fe7b1c4209fd2afcd985a5c1f4b7bf14e9
--- Ringtoets/HeightStructures/src/Ringtoets.HeightStructures.IO/HeightStructuresCalculationConfigurationWriter.cs	(.../HeightStructuresCalculationConfigurationWriter.cs)	(revision d393a6e22ba176f0ce9731629a37ce3272b1f433)
+++ Ringtoets/HeightStructures/src/Ringtoets.HeightStructures.IO/HeightStructuresCalculationConfigurationWriter.cs	(.../HeightStructuresCalculationConfigurationWriter.cs)	(revision 43b7d2fe7b1c4209fd2afcd985a5c1f4b7bf14e9)
@@ -43,17 +43,14 @@
         /// <item>does not end with a directory or path separator (empty file name).</item>
         /// </list></remarks>
         public HeightStructuresCalculationConfigurationWriter(string filePath) : base(filePath) {}
-        
-        protected override void WriteSpecificStructureParameters(HeightStructuresCalculationConfiguration configuration, XmlWriter writer)
-        {
-        }
 
+        protected override void WriteSpecificStructureParameters(HeightStructuresCalculationConfiguration configuration, XmlWriter writer) {}
+
         protected override void WriteSpecificStochasts(HeightStructuresCalculationConfiguration configuration, XmlWriter writer)
         {
-            if (configuration.LevelCrestStructure != null)
-            {
-                writer.WriteDistribution(HeightStructuresConfigurationSchemaIdentifiers.LevelCrestStructureStochastName, configuration.LevelCrestStructure);
-            }
+            WriteDistributionWhenAvailable(writer,
+                                           HeightStructuresConfigurationSchemaIdentifiers.LevelCrestStructureStochastName,
+                                           configuration.LevelCrestStructure);
         }
     }
 }
\ No newline at end of file