Index: Ringtoets/Integration/src/Ringtoets.Integration.IO/Factories/ExportableAssessmentSectionFactory.cs
===================================================================
diff -u -r9ef3756cb01fc3a3cf9e6504f550ffe6080429c1 -r7effbe398a2cf5fdb977851cb8d63bed6ebec611
--- Ringtoets/Integration/src/Ringtoets.Integration.IO/Factories/ExportableAssessmentSectionFactory.cs	(.../ExportableAssessmentSectionFactory.cs)	(revision 9ef3756cb01fc3a3cf9e6504f550ffe6080429c1)
+++ Ringtoets/Integration/src/Ringtoets.Integration.IO/Factories/ExportableAssessmentSectionFactory.cs	(.../ExportableAssessmentSectionFactory.cs)	(revision 7effbe398a2cf5fdb977851cb8d63bed6ebec611)
@@ -56,12 +56,24 @@
                                                                  AssessmentSectionAssemblyFactory.AssembleAssessmentSection(assessmentSection));
         }
 
+        /// <summary>
+        /// Creates a collection of <see cref="ExportableFailureMechanism{TFailureMechanismAssemblyResult}"/>
+        /// for failure mechanisms with an assembly result that contains a probability.
+        /// based on <paramref name="assessmentSection"/>.
+        /// </summary>
+        /// <param name="assessmentSection">The assessment section to create a
+        /// collection of <see cref="ExportableFailureMechanism{TFailureMechanismAssemblyResult}"/> with probability for.</param>
+        /// <returns>A a collection of <see cref="ExportableFailureMechanism{TFailureMechanismAssemblyResult}"/> based on failure
+        /// mechanisms with assembly results that have a probability.</returns>
+        /// <exception cref="AssemblyException">Thrown when assembly results cannot be created
+        /// for <paramref name="assessmentSection"/>.</exception>
         private static IEnumerable<ExportableFailureMechanism<ExportableFailureMechanismAssemblyResultWithProbability>> CreateExportableFailureMechanismsWithProbability(AssessmentSection assessmentSection)
         {
             return new []
             {
                 ExportablePipingFailureMechanismFactory.CreateExportablePipingFailureMechanism(assessmentSection.Piping, assessmentSection),
-                ExportableMacroStabilityInwardsFailureMechanismFactory.CreateExportableMacroStabilityInwardsFailureMechanism(assessmentSection.MacroStabilityInwards, assessmentSection)
+                ExportableMacroStabilityInwardsFailureMechanismFactory.CreateExportableMacroStabilityInwardsFailureMechanism(assessmentSection.MacroStabilityInwards, assessmentSection),
+                ExportableGrassCoverErosionInwardsFailureMechanismFactory.CreateExportableGrassCoverErosionInwardsFailureMechanism(assessmentSection.GrassCoverErosionInwards, assessmentSection)
             };
         }
     }
Index: Ringtoets/Integration/src/Ringtoets.Integration.IO/Factories/ExportableGrassCoverErosionInwardsFailureMechanismFactory.cs
===================================================================
diff -u
--- Ringtoets/Integration/src/Ringtoets.Integration.IO/Factories/ExportableGrassCoverErosionInwardsFailureMechanismFactory.cs	(revision 0)
+++ Ringtoets/Integration/src/Ringtoets.Integration.IO/Factories/ExportableGrassCoverErosionInwardsFailureMechanismFactory.cs	(revision 7effbe398a2cf5fdb977851cb8d63bed6ebec611)
@@ -0,0 +1,118 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using Ringtoets.AssemblyTool.Data;
+using Ringtoets.Common.Data.AssessmentSection;
+using Ringtoets.Common.Data.Exceptions;
+using Ringtoets.GrassCoverErosionInwards.Data;
+using Ringtoets.Integration.IO.Assembly;
+
+namespace Ringtoets.Integration.IO.Factories
+{
+    /// <summary>
+    /// Factory to create instances of <see cref="ExportableFailureMechanism{TFailureMechanismAssemblyResult}"/>
+    /// with assembly results for grass cover erosion inwards.
+    /// </summary>
+    public static class ExportableGrassCoverErosionInwardsFailureMechanismFactory
+    {
+        private const ExportableFailureMechanismType failureMechanismCode = ExportableFailureMechanismType.GEKB;
+        private const ExportableFailureMechanismGroup failureMechanismGroup = ExportableFailureMechanismGroup.Group1;
+        private const ExportableAssemblyMethod failureMechanismAssemblyMethod = ExportableAssemblyMethod.WBI1B1;
+
+        /// <summary>
+        /// Creates a <see cref="ExportableFailureMechanism{TFailureMechanismAssemblyResult}"/>
+        /// with assmebly results based on the input parameters.
+        /// </summary>
+        /// <param name="failureMechanism">The <see cref="GrassCoverErosionInwardsFailureMechanism"/> to create a
+        /// <see cref="ExportableFailureMechanism{TFailureMechanismAssemblyResult}"/> for.</param>
+        /// <param name="assessmentSection">The assessment section this failure mechanism belongs to.</param>
+        /// <returns>A <see cref="ExportableFailureMechanism{TFailureMechanismAssemblyResult}"/> with assembly results.</returns>
+        /// <exception cref="ArgumentNullException">Thrown when any parameter is <c>null</c>.</exception>
+        /// <exception cref="AssemblyException">Thrown when assembly results cannot be created.</exception>
+        public static ExportableFailureMechanism<ExportableFailureMechanismAssemblyResultWithProbability> CreateExportableGrassCoverErosionInwardsFailureMechanism(
+            GrassCoverErosionInwardsFailureMechanism failureMechanism,
+            IAssessmentSection assessmentSection)
+        {
+            if (failureMechanism == null)
+            {
+                throw new ArgumentNullException(nameof(failureMechanism));
+            }
+
+            if (assessmentSection == null)
+            {
+                throw new ArgumentNullException(nameof(assessmentSection));
+            }
+
+            if (!failureMechanism.IsRelevant)
+            {
+                return ExportableFailureMechanismFactory.CreateDefaultExportableFailureMechanismWithProbability(failureMechanismCode,
+                                                                                                                failureMechanismGroup,
+                                                                                                                failureMechanismAssemblyMethod);
+            }
+
+            FailureMechanismAssembly failureMechanismAssembly = GrassCoverErosionInwardsFailureMechanismAssemblyFactory.AssembleFailureMechanism(failureMechanism, assessmentSection);
+
+            Dictionary<GrassCoverErosionInwardsFailureMechanismSectionResult, ExportableFailureMechanismSection> failureMechanismSectionsLookup =
+                failureMechanism.SectionResults
+                                .ToDictionary(sectionResult => sectionResult,
+                                              sectionResult => ExportableFailureMechanismSectionFactory.CreateExportableFailureMechanismSection(sectionResult.Section));
+
+            return new ExportableFailureMechanism<ExportableFailureMechanismAssemblyResultWithProbability>(
+                new ExportableFailureMechanismAssemblyResultWithProbability(failureMechanismAssemblyMethod,
+                                                                            failureMechanismAssembly.Group,
+                                                                            failureMechanismAssembly.Probability),
+                failureMechanismSectionsLookup.Values, CreateExportablePipingFailureMechanismSectionResults(failureMechanismSectionsLookup,
+                                                                                                            failureMechanism,
+                                                                                                            assessmentSection),
+                failureMechanismCode,
+                failureMechanismGroup);
+        }
+
+        /// <summary>
+        /// Creates a collection of <see cref="ExportableAggregatedFailureMechanismSectionAssemblyResultWithProbability"/>
+        /// with assembly results based on the sections in <paramref name="failureMechanismSections"/>.
+        /// </summary>
+        /// <param name="failureMechanismSections">The mapping between the <see cref="GrassCoverErosionInwardsFailureMechanismSectionResult"/>
+        /// and <see cref="ExportableFailureMechanismSection"/>.</param>
+        /// <param name="failureMechanism">The <see cref="GrassCoverErosionInwardsFailureMechanism"/> the sections belong to.</param>
+        /// <param name="assessmentSection">The assessment section the sections belong to.</param>
+        /// <returns>A collection of <see cref="ExportableAggregatedFailureMechanismSectionAssemblyResultWithProbability"/>.</returns>
+        /// <exception cref="AssemblyException">Thrown when assembly results cannot be created.</exception>
+        private static IEnumerable<ExportableAggregatedFailureMechanismSectionAssemblyResultWithProbability> CreateExportablePipingFailureMechanismSectionResults(
+            Dictionary<GrassCoverErosionInwardsFailureMechanismSectionResult, ExportableFailureMechanismSection> failureMechanismSections,
+            GrassCoverErosionInwardsFailureMechanism failureMechanism,
+            IAssessmentSection assessmentSection)
+        {
+            var exportableResults = new List<ExportableAggregatedFailureMechanismSectionAssemblyResultWithProbability>();
+            foreach (KeyValuePair<GrassCoverErosionInwardsFailureMechanismSectionResult, ExportableFailureMechanismSection> failureMechanismSectionPair in failureMechanismSections)
+            {
+                GrassCoverErosionInwardsFailureMechanismSectionResult failureMechanismSectionResult = failureMechanismSectionPair.Key;
+                FailureMechanismSectionAssembly simpleAssembly =
+                    GrassCoverErosionInwardsFailureMechanismAssemblyFactory.AssembleSimpleAssessment(failureMechanismSectionResult);
+
+                FailureMechanismSectionAssembly detailedAssembly =
+                    GrassCoverErosionInwardsFailureMechanismAssemblyFactory.AssembleDetailedAssessment(failureMechanismSectionResult,
+                                                                                                       failureMechanism,
+                                                                                                       assessmentSection);
+                FailureMechanismSectionAssembly tailorMadeAssembly =
+                    GrassCoverErosionInwardsFailureMechanismAssemblyFactory.AssembleTailorMadeAssessment(failureMechanismSectionResult,
+                                                                                                         failureMechanism,
+                                                                                                         assessmentSection);
+                FailureMechanismSectionAssembly combinedAssembly =
+                    GrassCoverErosionInwardsFailureMechanismAssemblyFactory.AssembleCombinedAssessment(failureMechanismSectionResult,
+                                                                                                       failureMechanism,
+                                                                                                       assessmentSection);
+
+                exportableResults.Add(
+                    new ExportableAggregatedFailureMechanismSectionAssemblyResultWithProbability(
+                        failureMechanismSectionPair.Value,
+                        ExportableSectionAssemblyResultFactory.CreateExportableSectionAssemblyResultWithProbability(simpleAssembly, ExportableAssemblyMethod.WBI0E3),
+                        ExportableSectionAssemblyResultFactory.CreateExportableSectionAssemblyResultWithProbability(detailedAssembly, ExportableAssemblyMethod.WBI0G3),
+                        ExportableSectionAssemblyResultFactory.CreateExportableSectionAssemblyResultWithProbability(tailorMadeAssembly, ExportableAssemblyMethod.WBI0T3),
+                        ExportableSectionAssemblyResultFactory.CreateExportableSectionAssemblyResultWithProbability(combinedAssembly, ExportableAssemblyMethod.WBI0A1)));
+            }
+
+            return exportableResults;
+        }
+    }
+}
\ No newline at end of file
Index: Ringtoets/Integration/src/Ringtoets.Integration.IO/Factories/ExportableMacroStabilityInwardsFailureMechanismFactory.cs
===================================================================
diff -u -r0fd76a0bde626efdb5058ada2df39285ca4333cf -r7effbe398a2cf5fdb977851cb8d63bed6ebec611
--- Ringtoets/Integration/src/Ringtoets.Integration.IO/Factories/ExportableMacroStabilityInwardsFailureMechanismFactory.cs	(.../ExportableMacroStabilityInwardsFailureMechanismFactory.cs)	(revision 0fd76a0bde626efdb5058ada2df39285ca4333cf)
+++ Ringtoets/Integration/src/Ringtoets.Integration.IO/Factories/ExportableMacroStabilityInwardsFailureMechanismFactory.cs	(.../ExportableMacroStabilityInwardsFailureMechanismFactory.cs)	(revision 7effbe398a2cf5fdb977851cb8d63bed6ebec611)
@@ -23,7 +23,7 @@
         /// Creates a <see cref="ExportableFailureMechanism{TFailureMechanismAssemblyResult}"/>
         /// with assmebly results based on the input parameters.
         /// </summary>
-        /// <param name="failureMechanism">The MmcroStabilityInwards failure mechanism to create a
+        /// <param name="failureMechanism">The <see cref="MacroStabilityInwardsFailureMechanism"/> to create a
         /// <see cref="ExportableFailureMechanism{TFailureMechanismAssemblyResult}"/> for.</param>
         /// <param name="assessmentSection">The assessment section this failure mechanism belongs to.</param>
         /// <returns>A <see cref="ExportableFailureMechanism{TFailureMechanismAssemblyResult}"/> with assembly results.</returns>
@@ -74,8 +74,8 @@
         /// with assembly results based on the sections in <paramref name="failureMechanismSections"/>.
         /// </summary>
         /// <param name="failureMechanismSections">The mapping between the <see cref="MacroStabilityInwardsFailureMechanismSectionResult"/>
-        /// and <see cref="ExportableFailureMechanismSection"/></param>
-        /// <param name="macroStabilityInwardsFailureMechanism">The MacroStabilityInwards failure mechanism the sections belong to.</param>
+        /// and <see cref="ExportableFailureMechanismSection"/>.</param>
+        /// <param name="macroStabilityInwardsFailureMechanism">The <see cref="MacroStabilityInwardsFailureMechanism"/> the sections belong to.</param>
         /// <param name="assessmentSection">The assessment section the sections belong to.</param>
         /// <returns>A collection of <see cref="ExportableAggregatedFailureMechanismSectionAssemblyResultWithProbability"/>.</returns>
         /// <exception cref="AssemblyException">Thrown when assembly results cannot be created.</exception>
Index: Ringtoets/Integration/src/Ringtoets.Integration.IO/Factories/ExportablePipingFailureMechanismFactory.cs
===================================================================
diff -u -r0fd76a0bde626efdb5058ada2df39285ca4333cf -r7effbe398a2cf5fdb977851cb8d63bed6ebec611
--- Ringtoets/Integration/src/Ringtoets.Integration.IO/Factories/ExportablePipingFailureMechanismFactory.cs	(.../ExportablePipingFailureMechanismFactory.cs)	(revision 0fd76a0bde626efdb5058ada2df39285ca4333cf)
+++ Ringtoets/Integration/src/Ringtoets.Integration.IO/Factories/ExportablePipingFailureMechanismFactory.cs	(.../ExportablePipingFailureMechanismFactory.cs)	(revision 7effbe398a2cf5fdb977851cb8d63bed6ebec611)
@@ -23,7 +23,7 @@
         /// Creates a <see cref="ExportableFailureMechanism{TFailureMechanismAssemblyResult}"/>
         /// with assmebly results based on the input parameters.
         /// </summary>
-        /// <param name="failureMechanism">The piping failure mechanism to create a
+        /// <param name="failureMechanism">The <see cref="PipingFailureMechanism"/> to create a
         /// <see cref="ExportableFailureMechanism{TFailureMechanismAssemblyResult}"/> for.</param>
         /// <param name="assessmentSection">The assessment section this failure mechanism belongs to.</param>
         /// <returns>A <see cref="ExportableFailureMechanism{TFailureMechanismAssemblyResult}"/> with assembly results.</returns>
@@ -73,8 +73,8 @@
         /// with assembly results based on the sections in <paramref name="failureMechanismSections"/>.
         /// </summary>
         /// <param name="failureMechanismSections">The mapping between the <see cref="PipingFailureMechanismSectionResult"/>
-        /// and <see cref="ExportableFailureMechanismSection"/></param>
-        /// <param name="pipingFailureMechanism">The piping failure mechanism the sections belong to.</param>
+        /// and <see cref="ExportableFailureMechanismSection"/>.</param>
+        /// <param name="pipingFailureMechanism">The <see cref="PipingFailureMechanism"/> the sections belong to.</param>
         /// <param name="assessmentSection">The assessment section the sections belong to.</param>
         /// <returns>A collection of <see cref="ExportableAggregatedFailureMechanismSectionAssemblyResultWithProbability"/>.</returns>
         /// <exception cref="AssemblyException">Thrown when assembly results cannot be created.</exception>
Index: Ringtoets/Integration/src/Ringtoets.Integration.IO/Ringtoets.Integration.IO.csproj
===================================================================
diff -u -r0fd76a0bde626efdb5058ada2df39285ca4333cf -r7effbe398a2cf5fdb977851cb8d63bed6ebec611
--- Ringtoets/Integration/src/Ringtoets.Integration.IO/Ringtoets.Integration.IO.csproj	(.../Ringtoets.Integration.IO.csproj)	(revision 0fd76a0bde626efdb5058ada2df39285ca4333cf)
+++ Ringtoets/Integration/src/Ringtoets.Integration.IO/Ringtoets.Integration.IO.csproj	(.../Ringtoets.Integration.IO.csproj)	(revision 7effbe398a2cf5fdb977851cb8d63bed6ebec611)
@@ -39,6 +39,7 @@
     <Compile Include="Factories\ExportableAssessmentSectionFactory.cs" />
     <Compile Include="Factories\ExportableFailureMechanismFactory.cs" />
     <Compile Include="Factories\ExportableFailureMechanismSectionFactory.cs" />
+    <Compile Include="Factories\ExportableGrassCoverErosionInwardsFailureMechanismFactory.cs" />
     <Compile Include="Factories\ExportableMacroStabilityInwardsFailureMechanismFactory.cs" />
     <Compile Include="Factories\ExportablePipingFailureMechanismFactory.cs" />
     <Compile Include="Factories\ExportableSectionAssemblyResultFactory.cs" />
@@ -102,6 +103,11 @@
       <Name>Ringtoets.Common.Util</Name>
       <Private>False</Private>
     </ProjectReference>
+    <ProjectReference Include="..\..\..\GrassCoverErosionInwards\src\Ringtoets.GrassCoverErosionInwards.Data\Ringtoets.GrassCoverErosionInwards.Data.csproj">
+      <Project>{90de728e-48ef-4665-ab38-3d88e41d9f4d}</Project>
+      <Name>Ringtoets.GrassCoverErosionInwards.Data</Name>
+      <Private>False</Private>
+    </ProjectReference>
     <ProjectReference Include="..\..\..\MacroStabilityInwards\src\Ringtoets.MacroStabilityInwards.Data\Ringtoets.MacroStabilityInwards.Data.csproj">
       <Project>{83d6b73e-91d5-46b0-9218-955da1f75f7c}</Project>
       <Name>Ringtoets.MacroStabilityInwards.Data</Name>
Index: Ringtoets/Integration/test/Ringtoets.Integration.IO.Test/Factories/ExportableAssessmentSectionFactoryTest.cs
===================================================================
diff -u -r9ef3756cb01fc3a3cf9e6504f550ffe6080429c1 -r7effbe398a2cf5fdb977851cb8d63bed6ebec611
--- Ringtoets/Integration/test/Ringtoets.Integration.IO.Test/Factories/ExportableAssessmentSectionFactoryTest.cs	(.../ExportableAssessmentSectionFactoryTest.cs)	(revision 9ef3756cb01fc3a3cf9e6504f550ffe6080429c1)
+++ Ringtoets/Integration/test/Ringtoets.Integration.IO.Test/Factories/ExportableAssessmentSectionFactoryTest.cs	(.../ExportableAssessmentSectionFactoryTest.cs)	(revision 7effbe398a2cf5fdb977851cb8d63bed6ebec611)
@@ -83,7 +83,7 @@
             FailureMechanismAssemblyCalculatorStub failureMechanismAssemblyCalculator,
             AssessmentSection assessmentSection)
         {
-            Assert.AreEqual(2, exportableFailureMechanisms.Count());
+            Assert.AreEqual(3, exportableFailureMechanisms.Count());
             ExportableFailureMechanism<ExportableFailureMechanismAssemblyResultWithProbability> piping = exportableFailureMechanisms.First();
             Assert.AreEqual(failureMechanismAssemblyCalculator.FailureMechanismAssemblyOutput.Group, piping.FailureMechanismAssembly.AssemblyCategory);
             Assert.AreEqual(failureMechanismAssemblyCalculator.FailureMechanismAssemblyOutput.Probability, piping.FailureMechanismAssembly.Probability);
@@ -99,6 +99,14 @@
             Assert.AreEqual(ExportableFailureMechanismGroup.Group2, macroStabilityInwards.Group);
             Assert.AreEqual(assessmentSection.MacroStabilityInwards.Sections.Count(), macroStabilityInwards.Sections.Count());
             Assert.AreEqual(assessmentSection.MacroStabilityInwards.SectionResults.Count(), macroStabilityInwards.SectionAssemblyResults.Count());
+
+            ExportableFailureMechanism<ExportableFailureMechanismAssemblyResultWithProbability> grassCoverErosionInwards = exportableFailureMechanisms.ElementAt(2);
+            Assert.AreEqual(failureMechanismAssemblyCalculator.FailureMechanismAssemblyOutput.Group, grassCoverErosionInwards.FailureMechanismAssembly.AssemblyCategory);
+            Assert.AreEqual(failureMechanismAssemblyCalculator.FailureMechanismAssemblyOutput.Probability, grassCoverErosionInwards.FailureMechanismAssembly.Probability);
+            Assert.AreEqual(ExportableFailureMechanismType.GEKB, grassCoverErosionInwards.Code);
+            Assert.AreEqual(ExportableFailureMechanismGroup.Group1, grassCoverErosionInwards.Group);
+            Assert.AreEqual(assessmentSection.GrassCoverErosionInwards.Sections.Count(), grassCoverErosionInwards.Sections.Count());
+            Assert.AreEqual(assessmentSection.GrassCoverErosionInwards.SectionResults.Count(), grassCoverErosionInwards.SectionAssemblyResults.Count());
         }
     }
 }
\ No newline at end of file
Index: Ringtoets/Integration/test/Ringtoets.Integration.IO.Test/Factories/ExportableGrassCoverErosionInwardsFailureMechanismFactoryTest.cs
===================================================================
diff -u
--- Ringtoets/Integration/test/Ringtoets.Integration.IO.Test/Factories/ExportableGrassCoverErosionInwardsFailureMechanismFactoryTest.cs	(revision 0)
+++ Ringtoets/Integration/test/Ringtoets.Integration.IO.Test/Factories/ExportableGrassCoverErosionInwardsFailureMechanismFactoryTest.cs	(revision 7effbe398a2cf5fdb977851cb8d63bed6ebec611)
@@ -0,0 +1,175 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using NUnit.Framework;
+using Rhino.Mocks;
+using Ringtoets.AssemblyTool.Data;
+using Ringtoets.AssemblyTool.KernelWrapper.Calculators;
+using Ringtoets.AssemblyTool.KernelWrapper.TestUtil.Calculators;
+using Ringtoets.AssemblyTool.KernelWrapper.TestUtil.Calculators.Assembly;
+using Ringtoets.Common.Data.AssessmentSection;
+using Ringtoets.Common.Data.TestUtil;
+using Ringtoets.GrassCoverErosionInwards.Data;
+using Ringtoets.Integration.IO.Assembly;
+using Ringtoets.Integration.IO.Factories;
+using Ringtoets.Integration.IO.TestUtil;
+
+namespace Ringtoets.Integration.IO.Test.Factories
+{
+    [TestFixture]
+    public class ExportableGrassCoverErosionInwardsFailureMechanismFactoryTest
+    {
+        [Test]
+        public void CreateExportableGrassCoverErosionInwardsFailureMechanism_FailureMechanismNull_ThrowsArgumentNullException()
+        {
+            // Setup
+            var mocks = new MockRepository();
+            var assessmentSection = mocks.Stub<IAssessmentSection>();
+            mocks.ReplayAll();
+
+            // Call
+            TestDelegate call = () =>
+                ExportableGrassCoverErosionInwardsFailureMechanismFactory.CreateExportableGrassCoverErosionInwardsFailureMechanism(null,
+                                                                                                                                   assessmentSection);
+
+            // Assert
+            var exception = Assert.Throws<ArgumentNullException>(call);
+            Assert.AreEqual("failureMechanism", exception.ParamName);
+
+            mocks.VerifyAll();
+        }
+
+        [Test]
+        public void CreateExportableGrassCoverErosionInwardsFailureMechanism_AssessmentSectionNull_ThrowsArgumentNullException()
+        {
+            // Call
+            TestDelegate call = () =>
+                ExportableGrassCoverErosionInwardsFailureMechanismFactory.CreateExportableGrassCoverErosionInwardsFailureMechanism(new GrassCoverErosionInwardsFailureMechanism(),
+                                                                                                                                   null);
+
+            // Assert
+            var exception = Assert.Throws<ArgumentNullException>(call);
+            Assert.AreEqual("assessmentSection", exception.ParamName);
+        }
+
+        [Test]
+        public void CreateExportableGrassCoverErosionInwardsFailureMechanism_WithFailureMechanismNotRelevant_ReturnsDefaultExportableFailureMechanism()
+        {
+            // Setup
+            var random = new Random(21);
+            var failureMechanism = new GrassCoverErosionInwardsFailureMechanism
+            {
+                IsRelevant = false
+            };
+            FailureMechanismTestHelper.AddSections(failureMechanism, random.Next(2, 10));
+
+            var assessmentSection = new AssessmentSectionStub();
+
+            // Call
+            ExportableFailureMechanism<ExportableFailureMechanismAssemblyResultWithProbability> exportableFailureMechanism =
+                ExportableGrassCoverErosionInwardsFailureMechanismFactory.CreateExportableGrassCoverErosionInwardsFailureMechanism(failureMechanism, assessmentSection);
+
+            // Assert
+            Assert.AreEqual(ExportableFailureMechanismType.GEKB, exportableFailureMechanism.Code);
+            Assert.AreEqual(ExportableFailureMechanismGroup.Group1, exportableFailureMechanism.Group);
+
+            ExportableFailureMechanismAssemblyResultWithProbability failureMechanismAssemblyResult = exportableFailureMechanism.FailureMechanismAssembly;
+            Assert.AreEqual(ExportableAssemblyMethod.WBI1B1, failureMechanismAssemblyResult.AssemblyMethod);
+            Assert.AreEqual(FailureMechanismAssemblyCategoryGroup.NotApplicable, failureMechanismAssemblyResult.AssemblyCategory);
+            Assert.AreEqual(0, failureMechanismAssemblyResult.Probability);
+
+            CollectionAssert.IsEmpty(exportableFailureMechanism.Sections);
+            CollectionAssert.IsEmpty(exportableFailureMechanism.SectionAssemblyResults);
+        }
+
+        [Test]
+        public void CreateExportableGrassCoverErosionInwardsFailureMechanism_WithFailureMechanismRelevant_ReturnsExportableFailureMechanism()
+        {
+            // Setup
+            var random = new Random(21);
+            var failureMechanism = new GrassCoverErosionInwardsFailureMechanism();
+            FailureMechanismTestHelper.AddSections(failureMechanism, random.Next(2, 10));
+
+            var assessmentSection = new AssessmentSectionStub();
+
+            using (new AssemblyToolCalculatorFactoryConfig())
+            {
+                var calculatorfactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance;
+                FailureMechanismAssemblyCalculatorStub failureMechanismAssemblyCalculator = calculatorfactory.LastCreatedFailureMechanismAssemblyCalculator;
+                FailureMechanismSectionAssemblyCalculatorStub failureMechanismSectionAssemblyCalculator = calculatorfactory.LastCreatedFailureMechanismSectionAssemblyCalculator;
+
+                // Call
+                ExportableFailureMechanism<ExportableFailureMechanismAssemblyResultWithProbability> exportableFailureMechanism =
+                    ExportableGrassCoverErosionInwardsFailureMechanismFactory.CreateExportableGrassCoverErosionInwardsFailureMechanism(failureMechanism, assessmentSection);
+
+                // Assert
+                Assert.AreEqual(ExportableFailureMechanismType.GEKB, exportableFailureMechanism.Code);
+                Assert.AreEqual(ExportableFailureMechanismGroup.Group1, exportableFailureMechanism.Group);
+
+                FailureMechanismAssembly calculatorOutput = failureMechanismAssemblyCalculator.FailureMechanismAssemblyOutput;
+                ExportableFailureMechanismAssemblyResultWithProbability exportableFailureMechanismAssembly = exportableFailureMechanism.FailureMechanismAssembly;
+                Assert.AreEqual(calculatorOutput.Group, exportableFailureMechanismAssembly.AssemblyCategory);
+                Assert.AreEqual(calculatorOutput.Probability, exportableFailureMechanismAssembly.Probability);
+                Assert.AreEqual(ExportableAssemblyMethod.WBI1B1, exportableFailureMechanismAssembly.AssemblyMethod);
+
+                ExportableFailureMechanismSectionTestHelper.AssertExportableFailureMechanismSections(failureMechanism.Sections, exportableFailureMechanism.Sections);
+                AssertExportableFailureMechanismSectionResults(failureMechanismSectionAssemblyCalculator.SimpleAssessmentAssemblyOutput,
+                                                               failureMechanismSectionAssemblyCalculator.DetailedAssessmentAssemblyOutput,
+                                                               failureMechanismSectionAssemblyCalculator.TailorMadeAssessmentAssemblyOutput,
+                                                               failureMechanismSectionAssemblyCalculator.CombinedAssemblyOutput,
+                                                               exportableFailureMechanism.Sections,
+                                                               exportableFailureMechanism.SectionAssemblyResults.Cast<ExportableAggregatedFailureMechanismSectionAssemblyResultWithProbability>());
+            }
+        }
+
+        private static void AssertExportableFailureMechanismSectionResults(FailureMechanismSectionAssembly expectedSimpleAssembly,
+                                                                           FailureMechanismSectionAssembly expectedDetailedAssembly,
+                                                                           FailureMechanismSectionAssembly expectedTailorMadeAssembly,
+                                                                           FailureMechanismSectionAssembly expectedCombinedAssembly,
+                                                                           IEnumerable<ExportableFailureMechanismSection> sections,
+                                                                           IEnumerable<ExportableAggregatedFailureMechanismSectionAssemblyResultWithProbability> results)
+        {
+            int expectedNrOfResults = sections.Count();
+            Assert.AreEqual(expectedNrOfResults, results.Count());
+
+            for (var i = 0; i < expectedNrOfResults; i++)
+            {
+                ExportableFailureMechanismSection section = sections.ElementAt(i);
+                ExportableAggregatedFailureMechanismSectionAssemblyResultWithProbability result = results.ElementAt(i);
+
+                AssertExportableFailureMechanismSectionResult(expectedSimpleAssembly,
+                                                              expectedDetailedAssembly,
+                                                              expectedTailorMadeAssembly,
+                                                              expectedCombinedAssembly,
+                                                              section,
+                                                              result);
+            }
+        }
+
+        private static void AssertExportableFailureMechanismSectionResult(FailureMechanismSectionAssembly expectedSimpleAssembly,
+                                                                          FailureMechanismSectionAssembly expectedDetailedAssembly,
+                                                                          FailureMechanismSectionAssembly expectedTailorMadeAssembly,
+                                                                          FailureMechanismSectionAssembly expectedCombinedAssembly,
+                                                                          ExportableFailureMechanismSection expectedSection,
+                                                                          ExportableAggregatedFailureMechanismSectionAssemblyResultWithProbability actualResult)
+        {
+            Assert.AreSame(expectedSection, actualResult.FailureMechanismSection);
+
+            ExportableSectionAssemblyResultTestHelper.AssertExportableSectionAssemblyResult(expectedSimpleAssembly,
+                                                                                            ExportableAssemblyMethod.WBI0E3,
+                                                                                            actualResult.SimpleAssembly);
+
+            ExportableSectionAssemblyResultTestHelper.AssertExportableSectionAssemblyResult(expectedDetailedAssembly,
+                                                                                            ExportableAssemblyMethod.WBI0G3,
+                                                                                            actualResult.DetailedAssembly);
+
+            ExportableSectionAssemblyResultTestHelper.AssertExportableSectionAssemblyResult(expectedTailorMadeAssembly,
+                                                                                            ExportableAssemblyMethod.WBI0T3,
+                                                                                            actualResult.TailorMadeAssembly);
+
+            ExportableSectionAssemblyResultTestHelper.AssertExportableSectionAssemblyResult(expectedCombinedAssembly,
+                                                                                            ExportableAssemblyMethod.WBI0A1,
+                                                                                            actualResult.CombinedAssembly);
+        }
+    }
+}
\ No newline at end of file
Index: Ringtoets/Integration/test/Ringtoets.Integration.IO.Test/Ringtoets.Integration.IO.Test.csproj
===================================================================
diff -u -r0fd76a0bde626efdb5058ada2df39285ca4333cf -r7effbe398a2cf5fdb977851cb8d63bed6ebec611
--- Ringtoets/Integration/test/Ringtoets.Integration.IO.Test/Ringtoets.Integration.IO.Test.csproj	(.../Ringtoets.Integration.IO.Test.csproj)	(revision 0fd76a0bde626efdb5058ada2df39285ca4333cf)
+++ Ringtoets/Integration/test/Ringtoets.Integration.IO.Test/Ringtoets.Integration.IO.Test.csproj	(.../Ringtoets.Integration.IO.Test.csproj)	(revision 7effbe398a2cf5fdb977851cb8d63bed6ebec611)
@@ -41,6 +41,7 @@
     <Compile Include="Exporters\HydraulicBoundaryLocationsWriterTest.cs" />
     <Compile Include="Factories\ExportableFailureMechanismFactoryTest.cs" />
     <Compile Include="Factories\ExportableFailureMechanismSectionFactoryTest.cs" />
+    <Compile Include="Factories\ExportableGrassCoverErosionInwardsFailureMechanismFactoryTest.cs" />
     <Compile Include="Factories\ExportableMacroStabilityInwardsFailureMechanismFactoryTest.cs" />
     <Compile Include="Factories\ExportablePipingFailureMechanismFactoryTest.cs" />
     <Compile Include="Factories\ExportableSectionAssemblyResultFactoryTest.cs" />
@@ -93,6 +94,10 @@
       <Project>{54DF6303-BF9A-4AE9-BE09-4AF50EF27412}</Project>
       <Name>Ringtoets.Common.Util.TestUtil</Name>
     </ProjectReference>
+    <ProjectReference Include="..\..\..\GrassCoverErosionInwards\src\Ringtoets.GrassCoverErosionInwards.Data\Ringtoets.GrassCoverErosionInwards.Data.csproj">
+      <Project>{90DE728E-48EF-4665-AB38-3D88E41D9F4D}</Project>
+      <Name>Ringtoets.GrassCoverErosionInwards.Data</Name>
+    </ProjectReference>
     <ProjectReference Include="..\..\..\MacroStabilityInwards\src\Ringtoets.MacroStabilityInwards.Data\Ringtoets.MacroStabilityInwards.Data.csproj">
       <Project>{83D6B73E-91D5-46B0-9218-955DA1F75F7C}</Project>
       <Name>Ringtoets.MacroStabilityInwards.Data</Name>