Index: Riskeer/DuneErosion/src/Riskeer.DuneErosion.Forms/Views/HydraulicLoadsState/DuneErosionFailureMechanismView.cs
===================================================================
diff -u -r1e9842d882c96a9bdde40560b7facfb8cf3db468 -r8ae7522403830ec33cc3543de6dd89f4490cc402
--- Riskeer/DuneErosion/src/Riskeer.DuneErosion.Forms/Views/HydraulicLoadsState/DuneErosionFailureMechanismView.cs	(.../DuneErosionFailureMechanismView.cs)	(revision 1e9842d882c96a9bdde40560b7facfb8cf3db468)
+++ Riskeer/DuneErosion/src/Riskeer.DuneErosion.Forms/Views/HydraulicLoadsState/DuneErosionFailureMechanismView.cs	(.../DuneErosionFailureMechanismView.cs)	(revision 8ae7522403830ec33cc3543de6dd89f4490cc402)
@@ -32,7 +32,7 @@
 namespace Riskeer.DuneErosion.Forms.Views.HydraulicLoadsState
 {
     /// <summary>
-    /// This class is a view showing map data for a dune erosion failure mechanism.
+    /// Hydraulic loads state view showing map data for a dune erosion failure mechanism.
     /// </summary>
     public partial class DuneErosionFailureMechanismView : UserControl, IMapView
     {
Index: Riskeer/DuneErosion/src/Riskeer.DuneErosion.Forms/Views/RegistrationState/DuneErosionFailureMechanismView.cs
===================================================================
diff -u
--- Riskeer/DuneErosion/src/Riskeer.DuneErosion.Forms/Views/RegistrationState/DuneErosionFailureMechanismView.cs	(revision 0)
+++ Riskeer/DuneErosion/src/Riskeer.DuneErosion.Forms/Views/RegistrationState/DuneErosionFailureMechanismView.cs	(revision 8ae7522403830ec33cc3543de6dd89f4490cc402)
@@ -0,0 +1,125 @@
+// Copyright (C) Stichting Deltares 2021. All rights reserved.
+//
+// This file is part of Riskeer.
+//
+// Riskeer is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+// 
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program. If not, see <http://www.gnu.org/licenses/>.
+//
+// All names, logos, and references to "Deltares" are registered trademarks of
+// Stichting Deltares and remain full property of Stichting Deltares at all times.
+// All rights reserved.
+
+using System;
+using System.Collections.Generic;
+using Core.Common.Base;
+using Core.Components.Gis.Data;
+using Riskeer.Common.Data.AssemblyTool;
+using Riskeer.Common.Data.AssessmentSection;
+using Riskeer.Common.Data.FailureMechanism;
+using Riskeer.Common.Forms.Factories;
+using Riskeer.Common.Forms.MapLayers;
+using Riskeer.DuneErosion.Data;
+using DuneErosionDataResources = Riskeer.DuneErosion.Data.Properties.Resources;
+
+namespace Riskeer.DuneErosion.Forms.Views.RegistrationState
+{
+    /// <summary>
+    /// Registration state view showing map data for a dune erosion failure mechanism.
+    /// </summary>
+    public class DuneErosionFailureMechanismView : HydraulicLoadsState.DuneErosionFailureMechanismView
+    {
+        private MapLineData sectionsMapData;
+        private MapPointData sectionsStartPointMapData;
+        private MapPointData sectionsEndPointMapData;
+
+        private NonCalculatableFailureMechanismSectionResultsMapLayer<NonAdoptableFailureMechanismSectionResult> assemblyResultMapLayer;
+
+        private Observer failureMechanismObserver;
+
+        /// <summary>
+        /// Creates a new instance of <see cref="DuneErosionFailureMechanismView"/>.
+        /// </summary>
+        /// <param name="failureMechanism">The failure mechanism to show the data for.</param>
+        /// <param name="assessmentSection">The assessment section in which the <paramref name="failureMechanism"/>
+        /// belongs to.</param>
+        /// <exception cref="ArgumentNullException">Thrown when any parameter is <c>null</c>.</exception>
+        public DuneErosionFailureMechanismView(DuneErosionFailureMechanism failureMechanism,
+                                               IAssessmentSection assessmentSection)
+            : base(failureMechanism, assessmentSection) {}
+
+        protected override void Dispose(bool disposing)
+        {
+            failureMechanismObserver.Dispose();
+            assemblyResultMapLayer.Dispose();
+
+            base.Dispose(disposing);
+        }
+
+        protected override void CreateObservers()
+        {
+            base.CreateObservers();
+
+            failureMechanismObserver = new Observer(UpdateFailureMechanismMapData)
+            {
+                Observable = FailureMechanism
+            };
+        }
+
+        protected override void CreateMapData()
+        {
+            base.CreateMapData();
+
+            MapDataCollection sectionsMapDataCollection = RiskeerMapDataFactory.CreateSectionsMapDataCollection();
+            sectionsMapData = RiskeerMapDataFactory.CreateFailureMechanismSectionsMapData();
+            sectionsStartPointMapData = RiskeerMapDataFactory.CreateFailureMechanismSectionsStartPointMapData();
+            sectionsEndPointMapData = RiskeerMapDataFactory.CreateFailureMechanismSectionsEndPointMapData();
+
+            assemblyResultMapLayer = new NonCalculatableFailureMechanismSectionResultsMapLayer<NonAdoptableFailureMechanismSectionResult>(
+                FailureMechanism, sr => FailureMechanismSectionAssemblyResultFactory.AssembleSection(sr, AssessmentSection));
+
+            sectionsMapDataCollection.Add(sectionsMapData);
+            sectionsMapDataCollection.Add(sectionsStartPointMapData);
+            sectionsMapDataCollection.Add(sectionsEndPointMapData);
+            MapDataCollection.Insert(1, sectionsMapDataCollection);
+
+            MapDataCollection.Insert(2, assemblyResultMapLayer.MapData);
+        }
+
+        protected override void SetAllMapDataFeatures()
+        {
+            base.SetAllMapDataFeatures();
+
+            SetFailureMechanismMapData();
+        }
+
+        #region FailureMechanism MapData
+
+        private void UpdateFailureMechanismMapData()
+        {
+            SetFailureMechanismMapData();
+            sectionsMapData.NotifyObservers();
+            sectionsStartPointMapData.NotifyObservers();
+            sectionsEndPointMapData.NotifyObservers();
+        }
+
+        private void SetFailureMechanismMapData()
+        {
+            IEnumerable<FailureMechanismSection> failureMechanismSections = FailureMechanism.Sections;
+            sectionsMapData.Features = RiskeerMapDataFeaturesFactory.CreateFailureMechanismSectionFeatures(failureMechanismSections);
+            sectionsStartPointMapData.Features = RiskeerMapDataFeaturesFactory.CreateFailureMechanismSectionStartPointFeatures(failureMechanismSections);
+            sectionsEndPointMapData.Features = RiskeerMapDataFeaturesFactory.CreateFailureMechanismSectionEndPointFeatures(failureMechanismSections);
+        }
+
+        #endregion
+    }
+}
\ No newline at end of file
Fisheye: Tag 8ae7522403830ec33cc3543de6dd89f4490cc402 refers to a dead (removed) revision in file `Riskeer/DuneErosion/src/Riskeer.DuneErosion.Forms/Views/RegistrationState/DuneErosionFailurePathView.cs'.
Fisheye: No comparison available.  Pass `N' to diff?
Index: Riskeer/DuneErosion/src/Riskeer.DuneErosion.Plugin/DuneErosionPlugin.cs
===================================================================
diff -u -r1e9842d882c96a9bdde40560b7facfb8cf3db468 -r8ae7522403830ec33cc3543de6dd89f4490cc402
--- Riskeer/DuneErosion/src/Riskeer.DuneErosion.Plugin/DuneErosionPlugin.cs	(.../DuneErosionPlugin.cs)	(revision 1e9842d882c96a9bdde40560b7facfb8cf3db468)
+++ Riskeer/DuneErosion/src/Riskeer.DuneErosion.Plugin/DuneErosionPlugin.cs	(.../DuneErosionPlugin.cs)	(revision 8ae7522403830ec33cc3543de6dd89f4490cc402)
@@ -50,14 +50,14 @@
 using Riskeer.DuneErosion.Forms.PresentationObjects;
 using Riskeer.DuneErosion.Forms.PropertyClasses;
 using Riskeer.DuneErosion.Forms.Views;
-using Riskeer.DuneErosion.Forms.Views.HydraulicLoadsState;
-using Riskeer.DuneErosion.Forms.Views.RegistrationState;
 using Riskeer.DuneErosion.IO;
 using Riskeer.DuneErosion.Plugin.Handlers;
 using Riskeer.DuneErosion.Plugin.Properties;
 using Riskeer.DuneErosion.Service;
 using HydraulicLoadsStateFailureMechanismProperties = Riskeer.DuneErosion.Forms.PropertyClasses.HydraulicLoadsState.DuneErosionFailureMechanismProperties;
 using RegistrationStateFailureMechanismProperties = Riskeer.DuneErosion.Forms.PropertyClasses.RegistrationState.DuneErosionFailureMechanismProperties;
+using HydraulicLoadsStateFailureMechanismView = Riskeer.DuneErosion.Forms.Views.HydraulicLoadsState.DuneErosionFailureMechanismView;
+using RegistrationStateFailureMechanismView = Riskeer.DuneErosion.Forms.Views.RegistrationState.DuneErosionFailureMechanismView;
 using RiskeerCommonDataResources = Riskeer.Common.Data.Properties.Resources;
 using RiskeerCommonFormsResources = Riskeer.Common.Forms.Properties.Resources;
 using RiskeerCommonPluginResources = Riskeer.Common.Plugin.Properties.Resources;
@@ -185,18 +185,18 @@
                     DuneErosionFailureMechanismAssemblyFactory.AssembleFailureMechanism)
             };
 
-            yield return new RiskeerViewInfo<DuneErosionHydraulicLoadsContext, DuneErosionFailureMechanismView>(() => Gui)
+            yield return new RiskeerViewInfo<DuneErosionHydraulicLoadsContext, HydraulicLoadsStateFailureMechanismView>(() => Gui)
             {
                 GetViewName = (view, context) => context.WrappedData.Name,
-                CreateInstance = context => new DuneErosionFailureMechanismView(context.WrappedData, context.Parent)
+                CreateInstance = context => new HydraulicLoadsStateFailureMechanismView(context.WrappedData, context.Parent)
             };
 
-            yield return new RiskeerViewInfo<DuneErosionFailurePathContext, DuneErosionFailurePathView>(() => Gui)
+            yield return new RiskeerViewInfo<DuneErosionFailurePathContext, RegistrationStateFailureMechanismView>(() => Gui)
             {
                 GetViewName = (view, context) => context.WrappedData.Name,
                 AdditionalDataCheck = context => context.WrappedData.InAssembly,
-                CreateInstance = context => new DuneErosionFailurePathView(context.WrappedData, context.Parent),
-                CloseForData = CloseFailurePathViewForData
+                CreateInstance = context => new RegistrationStateFailureMechanismView(context.WrappedData, context.Parent),
+                CloseForData = CloseFailureMechanismViewForData
             };
 
             yield return new RiskeerViewInfo<DuneLocationCalculationsForUserDefinedTargetProbabilityContext, IObservableEnumerable<DuneLocationCalculation>, DuneLocationCalculationsView>(() => Gui)
@@ -327,7 +327,7 @@
 
         #region ViewInfos
 
-        private static bool CloseFailurePathViewForData(DuneErosionFailurePathView view, object dataToCloseFor)
+        private static bool CloseFailureMechanismViewForData(RegistrationStateFailureMechanismView view, object dataToCloseFor)
         {
             var assessmentSection = dataToCloseFor as IAssessmentSection;
             var failureMechanism = dataToCloseFor as DuneErosionFailureMechanism;
Index: Riskeer/DuneErosion/test/Riskeer.DuneErosion.Forms.Test/Views/RegistrationState/DuneErosionFailureMechanismViewTest.cs
===================================================================
diff -u
--- Riskeer/DuneErosion/test/Riskeer.DuneErosion.Forms.Test/Views/RegistrationState/DuneErosionFailureMechanismViewTest.cs	(revision 0)
+++ Riskeer/DuneErosion/test/Riskeer.DuneErosion.Forms.Test/Views/RegistrationState/DuneErosionFailureMechanismViewTest.cs	(revision 8ae7522403830ec33cc3543de6dd89f4490cc402)
@@ -0,0 +1,355 @@
+// Copyright (C) Stichting Deltares 2021. All rights reserved.
+//
+// This file is part of Riskeer.
+//
+// Riskeer is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+// 
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program. If not, see <http://www.gnu.org/licenses/>.
+//
+// All names, logos, and references to "Deltares" are registered trademarks of
+// Stichting Deltares and remain full property of Stichting Deltares at all times.
+// All rights reserved.
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using System.Windows.Forms;
+using Core.Common.Base;
+using Core.Common.Base.Geometry;
+using Core.Components.Gis.Data;
+using Core.Components.Gis.Forms;
+using NUnit.Framework;
+using Rhino.Mocks;
+using Riskeer.AssemblyTool.KernelWrapper.Calculators;
+using Riskeer.AssemblyTool.KernelWrapper.TestUtil.Calculators;
+using Riskeer.AssemblyTool.KernelWrapper.TestUtil.Calculators.Assembly;
+using Riskeer.Common.Data.AssessmentSection;
+using Riskeer.Common.Data.FailureMechanism;
+using Riskeer.Common.Data.TestUtil;
+using Riskeer.Common.Forms.TestUtil;
+using Riskeer.Common.Forms.Views;
+using Riskeer.DuneErosion.Data;
+using Riskeer.DuneErosion.Data.TestUtil;
+using Riskeer.DuneErosion.Forms.TestUtil;
+using Riskeer.DuneErosion.Forms.Views.RegistrationState;
+using HydraulicLoadsStateFailureMechanismView = Riskeer.DuneErosion.Forms.Views.HydraulicLoadsState.DuneErosionFailureMechanismView;
+
+namespace Riskeer.DuneErosion.Forms.Test.Views.RegistrationState
+{
+    [TestFixture]
+    public class DuneErosionFailureMechanismViewTest
+    {
+        private const int referenceLineIndex = 0;
+        private const int sectionsCollectionIndex = 1;
+        private const int assemblyResultsIndex = 2;
+        private const int duneLocationsIndex = 3;
+
+        private const int sectionsIndex = 0;
+        private const int sectionsStartPointIndex = 1;
+        private const int sectionsEndPointIndex = 2;
+
+        private const int sectionsObserverIndex = 0;
+        private const int sectionsStartPointObserverIndex = 1;
+        private const int sectionsEndPointObserverIndex = 2;
+
+        private Form testForm;
+
+        [SetUp]
+        public void Setup()
+        {
+            testForm = new Form();
+        }
+
+        [TearDown]
+        public void TearDown()
+        {
+            testForm.Dispose();
+        }
+
+        [Test]
+        [Apartment(ApartmentState.STA)]
+        public void Constructor_ExpectedValues()
+        {
+            // Setup
+            var failureMechanism = new DuneErosionFailureMechanism();
+            var assessmentSection = new AssessmentSectionStub();
+
+            // Call
+            DuneErosionFailureMechanismView view = CreateView(failureMechanism, assessmentSection);
+
+            // Assert
+            Assert.IsInstanceOf<HydraulicLoadsStateFailureMechanismView>(view);
+            Assert.IsNull(view.Data);
+            Assert.AreSame(failureMechanism, view.FailureMechanism);
+            Assert.AreSame(assessmentSection, view.AssessmentSection);
+            AssertEmptyMapData(view.Map.Data);
+        }
+
+        [Test]
+        [Apartment(ApartmentState.STA)]
+        public void Constructor_WithAllData_DataUpdatedToCollectionOfFilledMapData()
+        {
+            // Setup
+            var random = new Random(39);
+
+            var assessmentSection = new AssessmentSectionStub
+            {
+                ReferenceLine = new ReferenceLine()
+            };
+            assessmentSection.ReferenceLine.SetGeometry(new[]
+            {
+                new Point2D(1.0, 2.0),
+                new Point2D(2.0, 1.0)
+            });
+
+            var geometryPoints = new[]
+            {
+                new Point2D(0.0, 0.0),
+                new Point2D(2.0, 0.0),
+                new Point2D(4.0, 4.0),
+                new Point2D(6.0, 4.0)
+            };
+
+            var failureMechanism = new DuneErosionFailureMechanism();
+            failureMechanism.SetDuneLocations(new[]
+            {
+                new TestDuneLocation()
+            });
+            FailureMechanismTestHelper.SetSections(failureMechanism, new[]
+            {
+                new FailureMechanismSection("A", geometryPoints.Take(2)),
+                new FailureMechanismSection("B", geometryPoints.Skip(1).Take(2)),
+                new FailureMechanismSection("C", geometryPoints.Skip(2).Take(2))
+            });
+
+            using (new AssemblyToolCalculatorFactoryConfig())
+            {
+                // Call
+                DuneErosionFailureMechanismView view = CreateView(failureMechanism, assessmentSection);
+
+                IMapControl map = ((RiskeerMapControl) view.Controls[0]).MapControl;
+
+                // Assert
+                MapDataCollection mapData = map.Data;
+                Assert.IsInstanceOf<MapDataCollection>(mapData);
+
+                List<MapData> mapDataList = mapData.Collection.ToList();
+                Assert.AreEqual(4, mapDataList.Count);
+                MapDataTestHelper.AssertReferenceLineMapData(assessmentSection.ReferenceLine, mapDataList[referenceLineIndex]);
+
+                IEnumerable<MapData> sectionsCollection = ((MapDataCollection) mapDataList[sectionsCollectionIndex]).Collection;
+                MapDataTestHelper.AssertFailureMechanismSectionsMapData(failureMechanism.Sections, sectionsCollection.ElementAt(sectionsIndex));
+                MapDataTestHelper.AssertFailureMechanismSectionsStartPointMapData(failureMechanism.Sections, sectionsCollection.ElementAt(sectionsStartPointIndex));
+                MapDataTestHelper.AssertFailureMechanismSectionsEndPointMapData(failureMechanism.Sections, sectionsCollection.ElementAt(sectionsEndPointIndex));
+
+                AssertDuneLocationsMapData(failureMechanism, mapDataList[duneLocationsIndex]);
+
+                var calculatorFactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance;
+                FailureMechanismSectionAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator;
+                MapDataTestHelper.AssertAssemblyMapData(failureMechanism, calculator.FailureMechanismSectionAssemblyResultOutput, mapDataList[assemblyResultsIndex]);
+            }
+        }
+
+        [Test]
+        [Apartment(ApartmentState.STA)]
+        public void GivenViewWithFailureMechanismSectionsData_WhenFailureMechanismUpdatedAndNotified_ThenMapDataUpdated()
+        {
+            // Given
+            var failureMechanism = new DuneErosionFailureMechanism();
+
+            DuneErosionFailureMechanismView view = CreateView(failureMechanism, new AssessmentSectionStub());
+
+            IMapControl map = ((RiskeerMapControl) view.Controls[0]).MapControl;
+
+            IEnumerable<MapData> sectionsCollection = ((MapDataCollection) map.Data.Collection.ElementAt(sectionsCollectionIndex)).Collection;
+            var sectionMapData = (MapLineData) sectionsCollection.ElementAt(sectionsIndex);
+            var sectionStartsMapData = (MapPointData) sectionsCollection.ElementAt(sectionsStartPointIndex);
+            var sectionsEndsMapData = (MapPointData) sectionsCollection.ElementAt(sectionsEndPointIndex);
+
+            var mocks = new MockRepository();
+            IObserver[] observers = AttachMapDataObservers(mocks, map.Data.Collection);
+            observers[sectionsObserverIndex].Expect(obs => obs.UpdateObserver());
+            observers[sectionsStartPointObserverIndex].Expect(obs => obs.UpdateObserver());
+            observers[sectionsEndPointObserverIndex].Expect(obs => obs.UpdateObserver());
+            mocks.ReplayAll();
+
+            // When
+            FailureMechanismTestHelper.SetSections(failureMechanism, new[]
+            {
+                new FailureMechanismSection(string.Empty, new[]
+                {
+                    new Point2D(1, 2),
+                    new Point2D(1, 2)
+                })
+            });
+            failureMechanism.NotifyObservers();
+
+            // Then
+            MapDataTestHelper.AssertFailureMechanismSectionsMapData(failureMechanism.Sections, sectionMapData);
+            MapDataTestHelper.AssertFailureMechanismSectionsStartPointMapData(failureMechanism.Sections, sectionStartsMapData);
+            MapDataTestHelper.AssertFailureMechanismSectionsEndPointMapData(failureMechanism.Sections, sectionsEndsMapData);
+            mocks.VerifyAll();
+        }
+
+        [Test]
+        [Apartment(ApartmentState.STA)]
+        public void UpdateObserver_DataUpdated_MapLayersSameOrder()
+        {
+            // Setup
+            const int updatedReferenceLineLayerIndex = referenceLineIndex + 3;
+            const int updatedSectionsLayerIndex = sectionsCollectionIndex - 1;
+            const int updatedAssemblyResultsCollectionIndex = assemblyResultsIndex - 1;
+            const int updatedDuneLocationsLayerIndex = duneLocationsIndex - 1;
+
+            var assessmentSection = new AssessmentSectionStub();
+            var failureMechanism = new DuneErosionFailureMechanism();
+
+            DuneErosionFailureMechanismView view = CreateView(failureMechanism, assessmentSection);
+
+            IMapControl map = ((RiskeerMapControl) view.Controls[0]).MapControl;
+
+            MapDataCollection mapData = map.Data;
+
+            var dataToMove = (MapLineData) map.Data.Collection.ElementAt(referenceLineIndex);
+            mapData.Remove(dataToMove);
+            mapData.Add(dataToMove);
+
+            IEnumerable<MapData> mapDataCollection = mapData.Collection;
+
+            // Precondition
+            var referenceLineData = (MapLineData) mapDataCollection.ElementAt(updatedReferenceLineLayerIndex);
+            Assert.AreEqual("Referentielijn", referenceLineData.Name);
+
+            var sectionsData = (MapDataCollection) mapDataCollection.ElementAt(updatedSectionsLayerIndex);
+            Assert.AreEqual("Vakindeling", sectionsData.Name);
+
+            var assemblyResultsData = (MapLineData) mapDataCollection.ElementAt(updatedAssemblyResultsCollectionIndex);
+            Assert.AreEqual("Duidingsklasse per vak", assemblyResultsData.Name);
+
+            var duneLocationsData = (MapPointData) mapDataCollection.ElementAt(updatedDuneLocationsLayerIndex);
+            Assert.AreEqual("Hydraulische belastingen", duneLocationsData.Name);
+
+            var points = new List<Point2D>
+            {
+                new Point2D(2.0, 5.0),
+                new Point2D(4.0, 3.0)
+            };
+            var referenceLine = new ReferenceLine();
+            referenceLine.SetGeometry(points);
+            assessmentSection.ReferenceLine = referenceLine;
+
+            // Call
+            assessmentSection.NotifyObservers();
+
+            // Assert
+            var actualReferenceLineData = (MapLineData) mapDataCollection.ElementAt(updatedReferenceLineLayerIndex);
+            Assert.AreEqual("Referentielijn", actualReferenceLineData.Name);
+
+            var actualSectionsData = (MapDataCollection) mapDataCollection.ElementAt(updatedSectionsLayerIndex);
+            Assert.AreEqual("Vakindeling", actualSectionsData.Name);
+
+            var actualAssemblyResultsData = (MapLineData) mapDataCollection.ElementAt(updatedAssemblyResultsCollectionIndex);
+            Assert.AreEqual("Duidingsklasse per vak", actualAssemblyResultsData.Name);
+
+            var actualDuneLocationsData = (MapPointData) mapDataCollection.ElementAt(updatedDuneLocationsLayerIndex);
+            Assert.AreEqual("Hydraulische belastingen", actualDuneLocationsData.Name);
+        }
+
+        private DuneErosionFailureMechanismView CreateView(DuneErosionFailureMechanism failureMechanism, IAssessmentSection assessmentSection)
+        {
+            var view = new DuneErosionFailureMechanismView(failureMechanism, assessmentSection);
+
+            testForm.Controls.Add(view);
+            testForm.Show();
+
+            return view;
+        }
+
+        private static void AssertEmptyMapData(MapDataCollection mapDataCollection)
+        {
+            Assert.AreEqual("Duinafslag", mapDataCollection.Name);
+
+            List<MapData> mapDataList = mapDataCollection.Collection.ToList();
+
+            Assert.AreEqual(4, mapDataList.Count);
+
+            var referenceLineMapData = (MapLineData) mapDataList[referenceLineIndex];
+            var assemblyResultsMapData = (MapLineData) mapDataList[assemblyResultsIndex];
+            var hydraulicBoundaryLocationsMapData = (MapPointData) mapDataList[duneLocationsIndex];
+
+            CollectionAssert.IsEmpty(referenceLineMapData.Features);
+            CollectionAssert.IsEmpty(assemblyResultsMapData.Features);
+            CollectionAssert.IsEmpty(hydraulicBoundaryLocationsMapData.Features);
+
+            Assert.AreEqual("Referentielijn", referenceLineMapData.Name);
+            Assert.AreEqual("Duidingsklasse per vak", assemblyResultsMapData.Name);
+            Assert.AreEqual("Hydraulische belastingen", hydraulicBoundaryLocationsMapData.Name);
+
+            var sectionsMapDataCollection = (MapDataCollection) mapDataList[sectionsCollectionIndex];
+            Assert.AreEqual("Vakindeling", sectionsMapDataCollection.Name);
+            List<MapData> sectionsDataList = sectionsMapDataCollection.Collection.ToList();
+            Assert.AreEqual(3, sectionsDataList.Count);
+
+            var sectionsMapData = (MapLineData) sectionsDataList[sectionsIndex];
+            var sectionsStartPointMapData = (MapPointData) sectionsDataList[sectionsStartPointIndex];
+            var sectionsEndPointMapData = (MapPointData) sectionsDataList[sectionsEndPointIndex];
+
+            CollectionAssert.IsEmpty(sectionsEndPointMapData.Features);
+            CollectionAssert.IsEmpty(sectionsStartPointMapData.Features);
+            CollectionAssert.IsEmpty(sectionsMapData.Features);
+
+            Assert.AreEqual("Vakindeling (eindpunten)", sectionsEndPointMapData.Name);
+            Assert.AreEqual("Vakindeling (startpunten)", sectionsStartPointMapData.Name);
+            Assert.AreEqual("Vakindeling", sectionsMapData.Name);
+        }
+
+        /// <summary>
+        /// Attaches mocked observers to all <see cref="IObservable"/> map data components.
+        /// </summary>
+        /// <param name="mocks">The <see cref="MockRepository"/>.</param>
+        /// <param name="mapData">The map data collection containing the <see cref="IObservable"/>
+        /// elements.</param>
+        /// <returns>An array of mocked observers attached to the data in <paramref name="mapData"/>.</returns>
+        private static IObserver[] AttachMapDataObservers(MockRepository mocks, IEnumerable<MapData> mapData)
+        {
+            MapData[] mapDataArray = mapData.ToArray();
+
+            MapData[] sectionsCollection = ((MapDataCollection) mapDataArray[sectionsCollectionIndex]).Collection.ToArray();
+            var sectionsMapDataObserver = mocks.StrictMock<IObserver>();
+            sectionsCollection[sectionsIndex].Attach(sectionsMapDataObserver);
+
+            var sectionsStartPointMapDataObserver = mocks.StrictMock<IObserver>();
+            sectionsCollection[sectionsStartPointIndex].Attach(sectionsStartPointMapDataObserver);
+
+            var sectionsEndPointMapDataObserver = mocks.StrictMock<IObserver>();
+            sectionsCollection[sectionsEndPointIndex].Attach(sectionsEndPointMapDataObserver);
+
+            return new[]
+            {
+                sectionsMapDataObserver,
+                sectionsStartPointMapDataObserver,
+                sectionsEndPointMapDataObserver
+            };
+        }
+
+        private static void AssertDuneLocationsMapData(DuneErosionFailureMechanism failureMechanism,
+                                                       MapData mapData)
+        {
+            Assert.IsInstanceOf<MapPointData>(mapData);
+            Assert.AreEqual("Hydraulische belastingen", mapData.Name);
+
+            var duneLocationsMapData = (MapPointData) mapData;
+            DuneErosionMapFeaturesTestHelper.AssertDuneLocationFeaturesData(failureMechanism, duneLocationsMapData.Features);
+        }
+    }
+}
\ No newline at end of file
Fisheye: Tag 8ae7522403830ec33cc3543de6dd89f4490cc402 refers to a dead (removed) revision in file `Riskeer/DuneErosion/test/Riskeer.DuneErosion.Forms.Test/Views/RegistrationState/DuneErosionFailurePathViewTest.cs'.
Fisheye: No comparison available.  Pass `N' to diff?
Index: Riskeer/DuneErosion/test/Riskeer.DuneErosion.Plugin.Test/DuneErosionPluginTest.cs
===================================================================
diff -u -r1e9842d882c96a9bdde40560b7facfb8cf3db468 -r8ae7522403830ec33cc3543de6dd89f4490cc402
--- Riskeer/DuneErosion/test/Riskeer.DuneErosion.Plugin.Test/DuneErosionPluginTest.cs	(.../DuneErosionPluginTest.cs)	(revision 1e9842d882c96a9bdde40560b7facfb8cf3db468)
+++ Riskeer/DuneErosion/test/Riskeer.DuneErosion.Plugin.Test/DuneErosionPluginTest.cs	(.../DuneErosionPluginTest.cs)	(revision 8ae7522403830ec33cc3543de6dd89f4490cc402)
@@ -44,10 +44,10 @@
 using Riskeer.DuneErosion.Forms.PresentationObjects;
 using Riskeer.DuneErosion.Forms.PropertyClasses;
 using Riskeer.DuneErosion.Forms.Views;
-using Riskeer.DuneErosion.Forms.Views.HydraulicLoadsState;
-using Riskeer.DuneErosion.Forms.Views.RegistrationState;
 using HydraulicLoadsStateFailureMechanismProperties = Riskeer.DuneErosion.Forms.PropertyClasses.HydraulicLoadsState.DuneErosionFailureMechanismProperties;
 using RegistrationStateFailureMechanismProperties = Riskeer.DuneErosion.Forms.PropertyClasses.RegistrationState.DuneErosionFailureMechanismProperties;
+using HydraulicLoadsStateFailureMechanismView = Riskeer.DuneErosion.Forms.Views.HydraulicLoadsState.DuneErosionFailureMechanismView;
+using RegistrationStateFailureMechanismView = Riskeer.DuneErosion.Forms.Views.RegistrationState.DuneErosionFailureMechanismView;
 
 namespace Riskeer.DuneErosion.Plugin.Test
 {
@@ -163,12 +163,12 @@
                 PluginTestHelper.AssertViewInfoDefined(
                     viewInfos,
                     typeof(DuneErosionHydraulicLoadsContext),
-                    typeof(DuneErosionFailureMechanismView));
+                    typeof(HydraulicLoadsStateFailureMechanismView));
 
                 PluginTestHelper.AssertViewInfoDefined(
                     viewInfos,
                     typeof(DuneErosionFailurePathContext),
-                    typeof(DuneErosionFailurePathView));
+                    typeof(RegistrationStateFailureMechanismView));
 
                 PluginTestHelper.AssertViewInfoDefined(
                     viewInfos,
Index: Riskeer/DuneErosion/test/Riskeer.DuneErosion.Plugin.Test/ViewInfos/RegistrationState/DuneErosionFailureMechanismViewInfoTest.cs
===================================================================
diff -u
--- Riskeer/DuneErosion/test/Riskeer.DuneErosion.Plugin.Test/ViewInfos/RegistrationState/DuneErosionFailureMechanismViewInfoTest.cs	(revision 0)
+++ Riskeer/DuneErosion/test/Riskeer.DuneErosion.Plugin.Test/ViewInfos/RegistrationState/DuneErosionFailureMechanismViewInfoTest.cs	(revision 8ae7522403830ec33cc3543de6dd89f4490cc402)
@@ -0,0 +1,201 @@
+// Copyright (C) Stichting Deltares 2021. All rights reserved.
+//
+// This file is part of Riskeer.
+//
+// Riskeer 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.Linq;
+using System.Threading;
+using System.Windows.Forms;
+using Core.Gui.Plugin;
+using NUnit.Framework;
+using Rhino.Mocks;
+using Riskeer.Common.Data.AssessmentSection;
+using Riskeer.Common.Data.TestUtil;
+using Riskeer.DuneErosion.Data;
+using Riskeer.DuneErosion.Forms.PresentationObjects;
+using Riskeer.DuneErosion.Forms.Views.RegistrationState;
+
+namespace Riskeer.DuneErosion.Plugin.Test.ViewInfos.RegistrationState
+{
+    [TestFixture]
+    public class DuneErosionFailureMechanismViewInfoTest
+    {
+        private MockRepository mocks;
+        private DuneErosionPlugin plugin;
+        private ViewInfo info;
+
+        [SetUp]
+        public void SetUp()
+        {
+            mocks = new MockRepository();
+            plugin = new DuneErosionPlugin();
+            info = plugin.GetViewInfos().First(tni => tni.ViewType == typeof(DuneErosionFailureMechanismView));
+        }
+
+        [TearDown]
+        public void TearDown()
+        {
+            plugin.Dispose();
+        }
+
+        [Test]
+        public void Initialized_Always_ExpectedPropertiesSet()
+        {
+            // Assert
+            Assert.AreEqual(typeof(DuneErosionFailurePathContext), info.DataType);
+            Assert.AreEqual(typeof(DuneErosionFailurePathContext), info.ViewDataType);
+        }
+
+        [Test]
+        public void GetViewName_WithContext_ReturnsNameOfFailureMechanism()
+        {
+            // Setup
+            var assessmentSection = mocks.Stub<IAssessmentSection>();
+            mocks.ReplayAll();
+
+            var failureMechanism = new DuneErosionFailureMechanism();
+            var context = new DuneErosionFailurePathContext(failureMechanism, assessmentSection);
+
+            // Call
+            string viewName = info.GetViewName(null, context);
+
+            // Assert
+            Assert.AreEqual(failureMechanism.Name, viewName);
+            mocks.VerifyAll();
+        }
+
+        [Test]
+        [TestCase(true)]
+        [TestCase(false)]
+        public void AdditionalDataCheck_Always_ReturnTrueOnlyIfFailureMechanismInAssembly(bool inAssembly)
+        {
+            // Setup
+            var assessmentSection = mocks.Stub<IAssessmentSection>();
+            mocks.ReplayAll();
+
+            var failureMechanism = new DuneErosionFailureMechanism
+            {
+                InAssembly = inAssembly
+            };
+
+            var context = new DuneErosionFailurePathContext(failureMechanism, assessmentSection);
+
+            // Call
+            bool result = info.AdditionalDataCheck(context);
+
+            // Assert
+            Assert.AreEqual(inAssembly, result);
+            mocks.VerifyAll();
+        }
+
+        [Test]
+        [Apartment(ApartmentState.STA)]
+        public void CreateInstance_WithContext_ReturnDuneFailureMechanismView()
+        {
+            // Setup
+            var assessmentSection = new AssessmentSectionStub();
+            var failureMechanism = new DuneErosionFailureMechanism();
+
+            var context = new DuneErosionFailurePathContext(failureMechanism, assessmentSection);
+
+            using (var testForm = new Form())
+            {
+                // Call
+                var view = info.CreateInstance(context) as DuneErosionFailureMechanismView;
+
+                testForm.Controls.Add(view);
+                testForm.Show();
+
+                // Assert
+                Assert.AreSame(failureMechanism, view.FailureMechanism);
+                Assert.AreSame(assessmentSection, view.AssessmentSection);
+            }
+        }
+
+        [Test]
+        public void CloseForData_ViewNotCorrespondingToRemovedAssessmentSection_ReturnsFalse()
+        {
+            // Setup
+            var assessmentSection = new AssessmentSectionStub();
+            var otherAssessmentSection = mocks.Stub<IAssessmentSection>();
+            mocks.ReplayAll();
+
+            var failureMechanism = new DuneErosionFailureMechanism();
+
+            var view = new DuneErosionFailureMechanismView(failureMechanism, assessmentSection);
+
+            // Call
+            bool closeForData = info.CloseForData(view, otherAssessmentSection);
+
+            // Assert
+            Assert.IsFalse(closeForData);
+
+            mocks.VerifyAll();
+        }
+
+        [Test]
+        public void CloseForData_ViewCorrespondingToRemovedAssessmentSection_ReturnsTrue()
+        {
+            // Setup
+            var assessmentSection = new AssessmentSectionStub();
+            var failureMechanism = new DuneErosionFailureMechanism();
+
+            var view = new DuneErosionFailureMechanismView(failureMechanism, assessmentSection);
+
+            // Call
+            bool closeForData = info.CloseForData(view, assessmentSection);
+
+            // Assert
+            Assert.IsTrue(closeForData);
+        }
+
+        [Test]
+        public void CloseForData_ViewNotCorrespondingToRemovedFailureMechanism_ReturnsFalse()
+        {
+            // Setup
+            var assessmentSection = new AssessmentSectionStub();
+            var failureMechanism = new DuneErosionFailureMechanism();
+            var otherFailureMechanism = new DuneErosionFailureMechanism();
+
+            var view = new DuneErosionFailureMechanismView(failureMechanism, assessmentSection);
+
+            // Call
+            bool closeForData = info.CloseForData(view, otherFailureMechanism);
+
+            // Assert
+            Assert.IsFalse(closeForData);
+        }
+
+        [Test]
+        public void CloseForData_ViewCorrespondingToRemovedFailureMechanism_ReturnsTrue()
+        {
+            // Setup
+            var assessmentSection = new AssessmentSectionStub();
+            var failureMechanism = new DuneErosionFailureMechanism();
+
+            var view = new DuneErosionFailureMechanismView(failureMechanism, assessmentSection);
+
+            // Call
+            bool closeForData = info.CloseForData(view, failureMechanism);
+
+            // Assert
+            Assert.IsTrue(closeForData);
+        }
+    }
+}
\ No newline at end of file
Fisheye: Tag 8ae7522403830ec33cc3543de6dd89f4490cc402 refers to a dead (removed) revision in file `Riskeer/DuneErosion/test/Riskeer.DuneErosion.Plugin.Test/ViewInfos/RegistrationState/DuneErosionFailurePathViewInfoTest.cs'.
Fisheye: No comparison available.  Pass `N' to diff?