Index: Application/Ringtoets/src/Application.Ringtoets.Storage/Create/DuneErosion/DuneErosionFailureMechanismCreateExtensions.cs
===================================================================
diff -u -r3fb0df0ed6e64657154700ee7706e035d5bf99f5 -r3a2b7bafda45345163d076483eb2388b8e0601a3
--- Application/Ringtoets/src/Application.Ringtoets.Storage/Create/DuneErosion/DuneErosionFailureMechanismCreateExtensions.cs	(.../DuneErosionFailureMechanismCreateExtensions.cs)	(revision 3fb0df0ed6e64657154700ee7706e035d5bf99f5)
+++ Application/Ringtoets/src/Application.Ringtoets.Storage/Create/DuneErosion/DuneErosionFailureMechanismCreateExtensions.cs	(.../DuneErosionFailureMechanismCreateExtensions.cs)	(revision 3a2b7bafda45345163d076483eb2388b8e0601a3)
@@ -42,7 +42,7 @@
         {
             FailureMechanismEntity entity = mechanism.Create(FailureMechanismType.DuneErosion, registry);
             AddEntitiesForSectionResults(mechanism.SectionResults, registry);
-            AddEntitiesForFailureMechanismMeta(mechanism.GeneralInput, entity);
+            AddEntitiesForFailureMechanismMeta(mechanism, entity, registry);
             AddEntitiesForDuneLocations(mechanism.DuneLocations, entity, registry);
             return entity;
         }
@@ -59,9 +59,21 @@
             }
         }
 
-        private static void AddEntitiesForFailureMechanismMeta(GeneralDuneErosionInput generalInput, FailureMechanismEntity entity)
+        private static void AddEntitiesForFailureMechanismMeta(DuneErosionFailureMechanism failureMechanism,
+                                                               FailureMechanismEntity entity,
+                                                               PersistenceRegistry registry)
         {
-            entity.DuneErosionFailureMechanismMetaEntities.Add(generalInput.Create());
+            var metaEntity = new DuneErosionFailureMechanismMetaEntity
+            {
+                N = failureMechanism.GeneralInput.N,
+                DuneLocationCalculationCollectionEntity4 = failureMechanism.CalculationsForMechanismSpecificFactorizedSignalingNorm.Create(registry),
+                DuneLocationCalculationCollectionEntity3 = failureMechanism.CalculationsForMechanismSpecificSignalingNorm.Create(registry),
+                DuneLocationCalculationCollectionEntity2 = failureMechanism.CalculationsForMechanismSpecificLowerLimitNorm.Create(registry),
+                DuneLocationCalculationCollectionEntity1 = failureMechanism.CalculationsForLowerLimitNorm.Create(registry),
+                DuneLocationCalculationCollectionEntity = failureMechanism.CalculationsForFactorizedLowerLimitNorm.Create(registry),
+            };
+
+            entity.DuneErosionFailureMechanismMetaEntities.Add(metaEntity);
         }
 
         private static void AddEntitiesForDuneLocations(IEnumerable<DuneLocation> locations, FailureMechanismEntity entity, PersistenceRegistry registry)
Index: Application/Ringtoets/test/Application.Ringtoets.Storage.Test/Create/DuneErosion/DuneErosionFailureMechanismCreateExtensionsTest.cs
===================================================================
diff -u -r5b8d41d544dfd206c00b6c35d735a9d0851662f0 -r3a2b7bafda45345163d076483eb2388b8e0601a3
--- Application/Ringtoets/test/Application.Ringtoets.Storage.Test/Create/DuneErosion/DuneErosionFailureMechanismCreateExtensionsTest.cs	(.../DuneErosionFailureMechanismCreateExtensionsTest.cs)	(revision 5b8d41d544dfd206c00b6c35d735a9d0851662f0)
+++ Application/Ringtoets/test/Application.Ringtoets.Storage.Test/Create/DuneErosion/DuneErosionFailureMechanismCreateExtensionsTest.cs	(.../DuneErosionFailureMechanismCreateExtensionsTest.cs)	(revision 3a2b7bafda45345163d076483eb2388b8e0601a3)
@@ -20,6 +20,7 @@
 // All rights reserved.
 
 using System;
+using System.Collections.Generic;
 using System.Linq;
 using Application.Ringtoets.Storage.Create;
 using Application.Ringtoets.Storage.Create.DuneErosion;
@@ -29,6 +30,7 @@
 using NUnit.Framework;
 using Ringtoets.Common.Data.TestUtil;
 using Ringtoets.DuneErosion.Data;
+using Ringtoets.DuneErosion.Data.TestUtil;
 
 namespace Application.Ringtoets.Storage.Test.Create.DuneErosion
 {
@@ -158,5 +160,120 @@
             Assert.AreEqual(1, entity.FailureMechanismSectionEntities.Count);
             Assert.AreEqual(1, entity.FailureMechanismSectionEntities.SelectMany(fms => fms.DuneErosionSectionResultEntities).Count());
         }
+
+        [Test]
+        public void Create_WithoutDuneLocations_ReturnsEntityWithoutDuneLocations()
+        {
+            // Setup
+            var failureMechanism = new DuneErosionFailureMechanism();
+            var registry = new PersistenceRegistry();
+
+            // Call
+            FailureMechanismEntity entity = failureMechanism.Create(registry);
+
+            // Assert
+            CollectionAssert.IsEmpty(entity.DuneLocationEntities);
+
+            DuneErosionFailureMechanismMetaEntity metaEntity = entity.DuneErosionFailureMechanismMetaEntities.Single();
+            AssertDuneLocationCalculationCollectionEntities(failureMechanism, registry, metaEntity);
+        }
+
+        [Test]
+        public void Create_WithDuneLocations_ReturnsEntityWithDuneLocations()
+        {
+            // Setup
+            var duneLocation = new TestDuneLocation();
+            var failureMechanism = new DuneErosionFailureMechanism();
+            failureMechanism.SetDuneLocations(new[]
+            {
+                duneLocation
+            });
+            SetDuneLocationCalculationOutput(failureMechanism);
+
+            var duneLocationEntity = new DuneLocationEntity();
+            var registry = new PersistenceRegistry();
+            registry.Register(duneLocationEntity, duneLocation);
+
+            // Call
+            FailureMechanismEntity entity = failureMechanism.Create(registry);
+
+            // Assert
+            DuneLocationEntity actualDuneLocationEntity = entity.DuneLocationEntities.Single();
+            Assert.AreSame(duneLocationEntity, actualDuneLocationEntity);
+
+            DuneErosionFailureMechanismMetaEntity metaEntity = entity.DuneErosionFailureMechanismMetaEntities.Single();
+            AssertDuneLocationCalculationCollectionEntities(failureMechanism, registry, metaEntity);
+        }
+
+        private static void AssertDuneLocationCalculationCollectionEntities(DuneErosionFailureMechanism failureMechanism,
+                                                                            PersistenceRegistry registry, 
+                                                                            DuneErosionFailureMechanismMetaEntity metaEntity)
+        {
+            AssertDuneLocationCalculationCollectionEntity(failureMechanism.CalculationsForFactorizedLowerLimitNorm,
+                                                          registry,
+                                                          metaEntity.DuneLocationCalculationCollectionEntity);
+            AssertDuneLocationCalculationCollectionEntity(failureMechanism.CalculationsForLowerLimitNorm,
+                                                          registry,
+                                                          metaEntity.DuneLocationCalculationCollectionEntity1);
+            AssertDuneLocationCalculationCollectionEntity(failureMechanism.CalculationsForMechanismSpecificLowerLimitNorm,
+                                                          registry,
+                                                          metaEntity.DuneLocationCalculationCollectionEntity2);
+            AssertDuneLocationCalculationCollectionEntity(failureMechanism.CalculationsForMechanismSpecificSignalingNorm,
+                                                          registry,
+                                                          metaEntity.DuneLocationCalculationCollectionEntity3);
+            AssertDuneLocationCalculationCollectionEntity(failureMechanism.CalculationsForMechanismSpecificFactorizedSignalingNorm,
+                                                          registry,
+                                                          metaEntity.DuneLocationCalculationCollectionEntity4);
+        }
+
+        private static void SetDuneLocationCalculationOutput(DuneErosionFailureMechanism failureMechanism)
+        {
+            SetDuneLocationCalculationOutput(failureMechanism.CalculationsForMechanismSpecificFactorizedSignalingNorm, 1);
+            SetDuneLocationCalculationOutput(failureMechanism.CalculationsForMechanismSpecificSignalingNorm, 2);
+            SetDuneLocationCalculationOutput(failureMechanism.CalculationsForMechanismSpecificLowerLimitNorm, 3);
+            SetDuneLocationCalculationOutput(failureMechanism.CalculationsForLowerLimitNorm, 4);
+            SetDuneLocationCalculationOutput(failureMechanism.CalculationsForFactorizedLowerLimitNorm, 5);
+        }
+
+        private static void SetDuneLocationCalculationOutput(IEnumerable<DuneLocationCalculation> calculations,
+                                                             int seed)
+        {
+            var random = new Random(seed);
+            foreach (DuneLocationCalculation calculation in calculations)
+            {
+                calculation.Output = random.NextBoolean()
+                                         ? new TestDuneLocationCalculationOutput()
+                                         : null;
+            }
+        }
+
+        private static void AssertDuneLocationCalculationCollectionEntity(IEnumerable<DuneLocationCalculation> expectedCalculations,
+                                                                          PersistenceRegistry registry, 
+                                                                          DuneLocationCalculationCollectionEntity actualCollectionEntity)
+        {
+            Assert.IsNotNull(actualCollectionEntity);
+            ICollection<DuneLocationCalculationEntity> duneLocationCalculationEntities = actualCollectionEntity.DuneLocationCalculationEntities;
+            Assert.AreEqual(expectedCalculations.Count(), duneLocationCalculationEntities.Count);
+
+            var i = 0;
+            foreach (DuneLocationCalculationEntity duneLocationCalculationEntity in duneLocationCalculationEntities)
+            {
+                DuneLocationCalculation expectedDuneLocationCalculation = expectedCalculations.ElementAt(i);
+                DuneLocation expectedDuneLocation = expectedDuneLocationCalculation.DuneLocation;
+                Assert.AreSame(registry.Get(expectedDuneLocation), duneLocationCalculationEntity.DuneLocationEntity);
+
+                DuneLocationOutputEntity actualOutput = duneLocationCalculationEntity.DuneLocationOutputEntities.SingleOrDefault();
+                if (expectedDuneLocationCalculation.Output != null)
+                {
+                    Assert.IsNotNull(actualOutput);
+                }
+                else
+                {
+                    Assert.IsNull(actualOutput);
+                }
+
+                i++;
+            }
+        }
     }
 }
\ No newline at end of file