Index: Ringtoets/Integration/src/Ringtoets.Integration.Forms/Ringtoets.Integration.Forms.csproj
===================================================================
diff -u -raffe257dd529713fe3efe5af0dacbb9898217afb -r2657118de454794167b31aea0b730940c958c5c5
--- Ringtoets/Integration/src/Ringtoets.Integration.Forms/Ringtoets.Integration.Forms.csproj	(.../Ringtoets.Integration.Forms.csproj)	(revision affe257dd529713fe3efe5af0dacbb9898217afb)
+++ Ringtoets/Integration/src/Ringtoets.Integration.Forms/Ringtoets.Integration.Forms.csproj	(.../Ringtoets.Integration.Forms.csproj)	(revision 2657118de454794167b31aea0b730940c958c5c5)
@@ -119,6 +119,12 @@
       <DependentUpon>AssessmentSectionView.cs</DependentUpon>
     </Compile>
     <Compile Include="Views\CombinedFailureMechanismSectionAssemblyResultRow.cs" />
+    <Compile Include="Views\FailureMechanismWithDetailedAssessmentView.cs">
+      <SubType>UserControl</SubType>
+    </Compile>
+    <Compile Include="Views\FailureMechanismWithDetailedAssessmentView.Designer.cs">
+      <DependentUpon>FailureMechanismWithDetailedAssessmentView.cs</DependentUpon>
+    </Compile>
     <Compile Include="Views\FailureMechanismView.cs">
       <SubType>UserControl</SubType>
     </Compile>
@@ -346,6 +352,9 @@
     <EmbeddedResource Include="Views\AssessmentSectionView.resx">
       <DependentUpon>AssessmentSectionView.cs</DependentUpon>
     </EmbeddedResource>
+    <EmbeddedResource Include="Views\FailureMechanismWithDetailedAssessmentView.resx">
+      <DependentUpon>FailureMechanismWithDetailedAssessmentView.cs</DependentUpon>
+    </EmbeddedResource>
     <EmbeddedResource Include="Views\FailureMechanismView.resx">
       <DependentUpon>FailureMechanismView.cs</DependentUpon>
     </EmbeddedResource>
Index: Ringtoets/Integration/src/Ringtoets.Integration.Forms/Views/FailureMechanismWithDetailedAssessmentView.Designer.cs
===================================================================
diff -u
--- Ringtoets/Integration/src/Ringtoets.Integration.Forms/Views/FailureMechanismWithDetailedAssessmentView.Designer.cs	(revision 0)
+++ Ringtoets/Integration/src/Ringtoets.Integration.Forms/Views/FailureMechanismWithDetailedAssessmentView.Designer.cs	(revision 2657118de454794167b31aea0b730940c958c5c5)
@@ -0,0 +1,66 @@
+// Copyright (C) Stichting Deltares 2018. 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.Forms.Views;
+
+namespace Ringtoets.Integration.Forms.Views
+{
+    partial class FailureMechanismWithDetailedAssessmentView<TFailureMechanism, TSectionResult>
+    {
+        /// <summary> 
+        /// Required designer variable.
+        /// </summary>
+        private System.ComponentModel.IContainer components = null;
+
+        #region Component Designer generated code
+
+        /// <summary> 
+        /// Required method for Designer support - do not modify 
+        /// the contents of this method with the code editor.
+        /// </summary>
+        private void InitializeComponent()
+        {
+            this.ringtoetsMapControl = new Ringtoets.Common.Forms.Views.RingtoetsMapControl();
+            this.SuspendLayout();
+            // 
+            // ringtoetsMapControl
+            // 
+            this.ringtoetsMapControl.Dock = System.Windows.Forms.DockStyle.Fill;
+            this.ringtoetsMapControl.Location = new System.Drawing.Point(0, 0);
+            this.ringtoetsMapControl.Name = "ringtoetsMapControl";
+            this.ringtoetsMapControl.Size = new System.Drawing.Size(150, 150);
+            this.ringtoetsMapControl.TabIndex = 0;
+            // 
+            // FailureMechanismWithDetailedAssessmentView
+            // 
+            this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
+            this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
+            this.Controls.Add(this.ringtoetsMapControl);
+            this.Name = "FailureMechanismWithDetailedAssessmentView";
+            this.ResumeLayout(false);
+
+        }
+
+        #endregion
+
+        private RingtoetsMapControl ringtoetsMapControl;
+    }
+}
Index: Ringtoets/Integration/src/Ringtoets.Integration.Forms/Views/FailureMechanismWithDetailedAssessmentView.cs
===================================================================
diff -u
--- Ringtoets/Integration/src/Ringtoets.Integration.Forms/Views/FailureMechanismWithDetailedAssessmentView.cs	(revision 0)
+++ Ringtoets/Integration/src/Ringtoets.Integration.Forms/Views/FailureMechanismWithDetailedAssessmentView.cs	(revision 2657118de454794167b31aea0b730940c958c5c5)
@@ -0,0 +1,341 @@
+// Copyright (C) Stichting Deltares 2018. All rights reserved.
+//
+// This file is part of Ringtoets.
+//
+// Ringtoets is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+// 
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program. If not, see <http://www.gnu.org/licenses/>.
+//
+// All names, logos, and references to "Deltares" are registered trademarks of
+// Stichting Deltares and remain full property of Stichting Deltares at all times.
+// All rights reserved.
+
+using System;
+using System.Collections.Generic;
+using System.Windows.Forms;
+using Core.Common.Base;
+using Core.Components.Gis.Data;
+using Core.Components.Gis.Features;
+using Core.Components.Gis.Forms;
+using Ringtoets.Common.Data.AssessmentSection;
+using Ringtoets.Common.Data.FailureMechanism;
+using Ringtoets.Common.Data.Hydraulics;
+using Ringtoets.Common.Forms.Factories;
+using Ringtoets.Common.Forms.Helpers;
+
+namespace Ringtoets.Integration.Forms.Views
+{
+    /// <summary>
+    /// This class is a view showing map data for a failure mechanism with a detailed assessment.
+    /// </summary>
+    public partial class FailureMechanismWithDetailedAssessmentView<TFailureMechanism, TSectionResult> : UserControl, IMapView
+        where TFailureMechanism : IHasSectionResults<TSectionResult>
+        where TSectionResult : FailureMechanismSectionResult
+    {
+        private readonly Func<IEnumerable<MapFeature>> getSimpleAssemblyFeaturesFunc;
+        private readonly Func<IEnumerable<MapFeature>> getDetailedAssemblyFeaturesFunc;
+        private readonly Func<IEnumerable<MapFeature>> getTailorMadeAssemblyFeaturesFunc;
+        private readonly Func<IEnumerable<MapFeature>> getCombinedAssemblyFeaturesFunc;
+        
+        private MapDataCollection mapDataCollection;
+        private MapLineData referenceLineMapData;
+        private MapPointData hydraulicBoundaryLocationsMapData;
+
+        private MapLineData sectionsMapData;
+        private MapPointData sectionsStartPointMapData;
+        private MapPointData sectionsEndPointMapData;
+
+        private MapLineData simpleAssemblyMapData;
+        private MapLineData detailedAssemblyMapData;
+        private MapLineData tailorMadeAssemblyMapData;
+        private MapLineData combinedAssemblyMapData;
+
+        private Observer failureMechanismObserver;
+        private Observer assessmentSectionObserver;
+        private Observer hydraulicBoundaryLocationsObserver;
+
+        private RecursiveObserver<IObservableEnumerable<HydraulicBoundaryLocationCalculation>, HydraulicBoundaryLocationCalculation> waterLevelCalculationsForFactorizedSignalingNormObserver;
+        private RecursiveObserver<IObservableEnumerable<HydraulicBoundaryLocationCalculation>, HydraulicBoundaryLocationCalculation> waterLevelCalculationsForSignalingNormObserver;
+        private RecursiveObserver<IObservableEnumerable<HydraulicBoundaryLocationCalculation>, HydraulicBoundaryLocationCalculation> waterLevelCalculationsForLowerLimitNormObserver;
+        private RecursiveObserver<IObservableEnumerable<HydraulicBoundaryLocationCalculation>, HydraulicBoundaryLocationCalculation> waterLevelCalculationsForFactorizedLowerLimitNormObserver;
+        private RecursiveObserver<IObservableEnumerable<HydraulicBoundaryLocationCalculation>, HydraulicBoundaryLocationCalculation> waveHeightCalculationsForFactorizedSignalingNormObserver;
+        private RecursiveObserver<IObservableEnumerable<HydraulicBoundaryLocationCalculation>, HydraulicBoundaryLocationCalculation> waveHeightCalculationsForSignalingNormObserver;
+        private RecursiveObserver<IObservableEnumerable<HydraulicBoundaryLocationCalculation>, HydraulicBoundaryLocationCalculation> waveHeightCalculationsForLowerLimitNormObserver;
+        private RecursiveObserver<IObservableEnumerable<HydraulicBoundaryLocationCalculation>, HydraulicBoundaryLocationCalculation> waveHeightCalculationsForFactorizedLowerLimitNormObserver;
+        private RecursiveObserver<IObservableEnumerable<TSectionResult>, TSectionResult> sectionResultObserver;
+
+        /// <summary>
+        /// Creates a new instance of <see cref="FailureMechanismView{T}"/>.
+        /// </summary>
+        /// <param name="failureMechanism">The failure mechanism to show the data for.</param>
+        /// <param name="assessmentSection">The assessment section to show the data for.</param>
+        /// <param name="getSimpleAssemblyFeaturesFunc">The <see cref="Func{T}"/> that returns a collection of <see cref="MapFeature"/> representing
+        /// the simple assembly results for this failure mechanism.</param>
+        /// <param name="getDetailedAssemblyFeaturesFunc">The <see cref="Func{T}"/> that returns a collection of <see cref="MapFeature"/> representing
+        /// the detailed assembly results for this failure mechanism.</param>
+        /// <param name="getTailorMadeAssemblyFeaturesFunc">The <see cref="Func{T}"/> that returns a collection of <see cref="MapFeature"/> representing
+        /// the tailor made assembly results for this failure mechanism.</param>
+        /// <param name="getCombinedAssemblyFeaturesFunc">The <see cref="Func{T}"/> that returns a collection of <see cref="MapFeature"/> representing
+        /// the combined assembly results for this failure mechanism.</param>
+        /// <exception cref="ArgumentNullException">Thrown when any parameter is <c>null</c>.</exception>
+        public FailureMechanismWithDetailedAssessmentView(TFailureMechanism failureMechanism, 
+                                                          IAssessmentSection assessmentSection,
+                                                          Func<IEnumerable<MapFeature>> getSimpleAssemblyFeaturesFunc,
+                                                          Func<IEnumerable<MapFeature>> getDetailedAssemblyFeaturesFunc,
+                                                          Func<IEnumerable<MapFeature>> getTailorMadeAssemblyFeaturesFunc,
+                                                          Func<IEnumerable<MapFeature>> getCombinedAssemblyFeaturesFunc)
+        {
+            if (failureMechanism == null)
+            {
+                throw new ArgumentNullException(nameof(failureMechanism));
+            }
+
+            if (assessmentSection == null)
+            {
+                throw new ArgumentNullException(nameof(assessmentSection));
+            }
+
+            if (getSimpleAssemblyFeaturesFunc == null)
+            {
+                throw new ArgumentNullException(nameof(getSimpleAssemblyFeaturesFunc));
+            }
+
+            if (getDetailedAssemblyFeaturesFunc == null)
+            {
+                throw new ArgumentNullException(nameof(getDetailedAssemblyFeaturesFunc));
+            }
+
+            if (getTailorMadeAssemblyFeaturesFunc == null)
+            {
+                throw new ArgumentNullException(nameof(getTailorMadeAssemblyFeaturesFunc));
+            }
+
+            if (getCombinedAssemblyFeaturesFunc == null)
+            {
+                throw new ArgumentNullException(nameof(getCombinedAssemblyFeaturesFunc));
+            }
+
+            this.getSimpleAssemblyFeaturesFunc = getSimpleAssemblyFeaturesFunc;
+            this.getDetailedAssemblyFeaturesFunc = getDetailedAssemblyFeaturesFunc;
+            this.getTailorMadeAssemblyFeaturesFunc = getTailorMadeAssemblyFeaturesFunc;
+            this.getCombinedAssemblyFeaturesFunc = getCombinedAssemblyFeaturesFunc;
+
+            InitializeComponent();
+
+            FailureMechanism = failureMechanism;
+            AssessmentSection = assessmentSection;
+
+            CreateObservers();
+
+            CreateMapData();
+            SetAllMapDataFeatures();
+            ringtoetsMapControl.SetAllData(mapDataCollection, assessmentSection.BackgroundData);
+        }
+
+        private void CreateMapData()
+        {
+            mapDataCollection = new MapDataCollection(FailureMechanism.Name);
+            referenceLineMapData = RingtoetsMapDataFactory.CreateReferenceLineMapData();
+            hydraulicBoundaryLocationsMapData = RingtoetsMapDataFactory.CreateHydraulicBoundaryLocationsMapData();
+
+            MapDataCollection sectionsMapDataCollection = RingtoetsMapDataFactory.CreateSectionsMapDataCollection();
+            sectionsMapData = RingtoetsMapDataFactory.CreateFailureMechanismSectionsMapData();
+            sectionsStartPointMapData = RingtoetsMapDataFactory.CreateFailureMechanismSectionsStartPointMapData();
+            sectionsEndPointMapData = RingtoetsMapDataFactory.CreateFailureMechanismSectionsEndPointMapData();
+
+            MapDataCollection assemblyMapDataCollection = AssemblyMapDataFactory.CreateAssemblyMapDataCollection();
+            tailorMadeAssemblyMapData = AssemblyMapDataFactory.CreateTailorMadeAssemblyMapData();
+            detailedAssemblyMapData = AssemblyMapDataFactory.CreateDetailedAssemblyMapData();
+            simpleAssemblyMapData = AssemblyMapDataFactory.CreateSimpleAssemblyMapData();
+            combinedAssemblyMapData = AssemblyMapDataFactory.CreateCombinedAssemblyMapData();
+
+            mapDataCollection.Add(referenceLineMapData);
+
+            sectionsMapDataCollection.Add(sectionsMapData);
+            sectionsMapDataCollection.Add(sectionsStartPointMapData);
+            sectionsMapDataCollection.Add(sectionsEndPointMapData);
+            mapDataCollection.Add(sectionsMapDataCollection);
+
+            assemblyMapDataCollection.Add(tailorMadeAssemblyMapData);
+            assemblyMapDataCollection.Add(detailedAssemblyMapData);
+            assemblyMapDataCollection.Add(simpleAssemblyMapData);
+            assemblyMapDataCollection.Add(combinedAssemblyMapData);
+            mapDataCollection.Add(assemblyMapDataCollection);
+
+            mapDataCollection.Add(hydraulicBoundaryLocationsMapData);
+        }
+
+        /// <summary>
+        /// Gets the failure mechanism.
+        /// </summary>
+        public TFailureMechanism FailureMechanism { get; }
+
+        /// <summary>
+        /// Gets the assessment section.
+        /// </summary>
+        public IAssessmentSection AssessmentSection { get; }
+
+        public object Data { get; set; }
+
+        public IMapControl Map
+        {
+            get
+            {
+                return ringtoetsMapControl.MapControl;
+            }
+        }
+
+        protected override void Dispose(bool disposing)
+        {
+            failureMechanismObserver.Dispose();
+            assessmentSectionObserver.Dispose();
+            hydraulicBoundaryLocationsObserver.Dispose();
+            waterLevelCalculationsForFactorizedSignalingNormObserver.Dispose();
+            waterLevelCalculationsForSignalingNormObserver.Dispose();
+            waterLevelCalculationsForLowerLimitNormObserver.Dispose();
+            waterLevelCalculationsForFactorizedLowerLimitNormObserver.Dispose();
+            waveHeightCalculationsForFactorizedSignalingNormObserver.Dispose();
+            waveHeightCalculationsForSignalingNormObserver.Dispose();
+            waveHeightCalculationsForLowerLimitNormObserver.Dispose();
+            waveHeightCalculationsForFactorizedLowerLimitNormObserver.Dispose();
+            sectionResultObserver.Dispose();
+
+            if (disposing)
+            {
+                components?.Dispose();
+            }
+
+            base.Dispose(disposing);
+        }
+
+        private void CreateObservers()
+        {
+            failureMechanismObserver = new Observer(UpdateFailureMechanismMapData)
+            {
+                Observable = FailureMechanism
+            };
+            assessmentSectionObserver = new Observer(UpdateAssessmentSectionMapData)
+            {
+                Observable = AssessmentSection
+            };
+            hydraulicBoundaryLocationsObserver = new Observer(UpdateHydraulicBoundaryLocationsMapData)
+            {
+                Observable = AssessmentSection.HydraulicBoundaryDatabase.Locations
+            };
+
+            waterLevelCalculationsForFactorizedSignalingNormObserver = ObserverHelper.CreateHydraulicBoundaryLocationCalculationsObserver(
+                AssessmentSection.WaterLevelCalculationsForFactorizedSignalingNorm, UpdateHydraulicBoundaryLocationsMapData);
+            waterLevelCalculationsForSignalingNormObserver = ObserverHelper.CreateHydraulicBoundaryLocationCalculationsObserver(
+                AssessmentSection.WaterLevelCalculationsForSignalingNorm, UpdateHydraulicBoundaryLocationsMapData);
+            waterLevelCalculationsForLowerLimitNormObserver = ObserverHelper.CreateHydraulicBoundaryLocationCalculationsObserver(
+                AssessmentSection.WaterLevelCalculationsForLowerLimitNorm, UpdateHydraulicBoundaryLocationsMapData);
+            waterLevelCalculationsForFactorizedLowerLimitNormObserver = ObserverHelper.CreateHydraulicBoundaryLocationCalculationsObserver(
+                AssessmentSection.WaterLevelCalculationsForFactorizedLowerLimitNorm, UpdateHydraulicBoundaryLocationsMapData);
+            waveHeightCalculationsForFactorizedSignalingNormObserver = ObserverHelper.CreateHydraulicBoundaryLocationCalculationsObserver(
+                AssessmentSection.WaveHeightCalculationsForFactorizedSignalingNorm, UpdateHydraulicBoundaryLocationsMapData);
+            waveHeightCalculationsForSignalingNormObserver = ObserverHelper.CreateHydraulicBoundaryLocationCalculationsObserver(
+                AssessmentSection.WaveHeightCalculationsForSignalingNorm, UpdateHydraulicBoundaryLocationsMapData);
+            waveHeightCalculationsForLowerLimitNormObserver = ObserverHelper.CreateHydraulicBoundaryLocationCalculationsObserver(
+                AssessmentSection.WaveHeightCalculationsForLowerLimitNorm, UpdateHydraulicBoundaryLocationsMapData);
+            waveHeightCalculationsForFactorizedLowerLimitNormObserver = ObserverHelper.CreateHydraulicBoundaryLocationCalculationsObserver(
+                AssessmentSection.WaveHeightCalculationsForFactorizedLowerLimitNorm, UpdateHydraulicBoundaryLocationsMapData);
+
+            sectionResultObserver = new RecursiveObserver<IObservableEnumerable<TSectionResult>, TSectionResult>(UpdateAssemblyMapData, sr => sr)
+            {
+                Observable = FailureMechanism.SectionResults
+            };
+        }
+
+        private void SetAllMapDataFeatures()
+        {
+            SetReferenceLineMapData();
+            SetSectionsMapData();
+            SetHydraulicBoundaryLocationsMapData();
+            UpdateAssemblyMapData();
+        }
+
+        #region Assembly MapData
+
+        private void UpdateAssemblyMapData()
+        {
+            SetAssemblyMapData();
+            simpleAssemblyMapData.NotifyObservers();
+            detailedAssemblyMapData.NotifyObservers();
+            tailorMadeAssemblyMapData.NotifyObservers();
+            combinedAssemblyMapData.NotifyObservers();
+        }
+
+        private void SetAssemblyMapData()
+        {
+            simpleAssemblyMapData.Features = getSimpleAssemblyFeaturesFunc();
+            detailedAssemblyMapData.Features = getDetailedAssemblyFeaturesFunc();
+            tailorMadeAssemblyMapData.Features = getTailorMadeAssemblyFeaturesFunc();
+            combinedAssemblyMapData.Features = getCombinedAssemblyFeaturesFunc();
+        }
+
+        #endregion
+
+        #region AssessmentSection MapData
+
+        private void UpdateAssessmentSectionMapData()
+        {
+            SetReferenceLineMapData();
+            referenceLineMapData.NotifyObservers();
+        }
+
+        private void SetReferenceLineMapData()
+        {
+            referenceLineMapData.Features = RingtoetsMapDataFeaturesFactory.CreateReferenceLineFeatures(
+                AssessmentSection.ReferenceLine, AssessmentSection.Id, AssessmentSection.Name);
+        }
+
+        #endregion
+
+        #region FailureMechanism MapData
+
+        private void UpdateFailureMechanismMapData()
+        {
+            SetSectionsMapData();
+            sectionsMapData.NotifyObservers();
+            sectionsStartPointMapData.NotifyObservers();
+            sectionsEndPointMapData.NotifyObservers();
+
+            UpdateAssemblyMapData();
+        }
+
+        private void SetSectionsMapData()
+        {
+            IEnumerable<FailureMechanismSection> failureMechanismSections = FailureMechanism.Sections;
+
+            sectionsMapData.Features = RingtoetsMapDataFeaturesFactory.CreateFailureMechanismSectionFeatures(failureMechanismSections);
+            sectionsStartPointMapData.Features = RingtoetsMapDataFeaturesFactory.CreateFailureMechanismSectionStartPointFeatures(failureMechanismSections);
+            sectionsEndPointMapData.Features = RingtoetsMapDataFeaturesFactory.CreateFailureMechanismSectionEndPointFeatures(failureMechanismSections);
+        }
+
+        #endregion
+
+        #region HydraulicBoundaryLocations MapData
+
+        private void UpdateHydraulicBoundaryLocationsMapData()
+        {
+            SetHydraulicBoundaryLocationsMapData();
+            hydraulicBoundaryLocationsMapData.NotifyObservers();
+        }
+
+        private void SetHydraulicBoundaryLocationsMapData()
+        {
+            hydraulicBoundaryLocationsMapData.Features = RingtoetsMapDataFeaturesFactory.CreateHydraulicBoundaryLocationFeatures(AssessmentSection);
+        }
+
+        #endregion
+    }
+}
\ No newline at end of file
Index: Ringtoets/Integration/src/Ringtoets.Integration.Forms/Views/FailureMechanismWithDetailedAssessmentView.resx
===================================================================
diff -u
--- Ringtoets/Integration/src/Ringtoets.Integration.Forms/Views/FailureMechanismWithDetailedAssessmentView.resx	(revision 0)
+++ Ringtoets/Integration/src/Ringtoets.Integration.Forms/Views/FailureMechanismWithDetailedAssessmentView.resx	(revision 2657118de454794167b31aea0b730940c958c5c5)
@@ -0,0 +1,120 @@
+<?xml version="1.0" encoding="utf-8"?>
+<root>
+  <!-- 
+    Microsoft ResX Schema 
+    
+    Version 2.0
+    
+    The primary goals of this format is to allow a simple XML format 
+    that is mostly human readable. The generation and parsing of the 
+    various data types are done through the TypeConverter classes 
+    associated with the data types.
+    
+    Example:
+    
+    ... ado.net/XML headers & schema ...
+    <resheader name="resmimetype">text/microsoft-resx</resheader>
+    <resheader name="version">2.0</resheader>
+    <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
+    <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
+    <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
+    <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
+    <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
+        <value>[base64 mime encoded serialized .NET Framework object]</value>
+    </data>
+    <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
+        <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
+        <comment>This is a comment</comment>
+    </data>
+                
+    There are any number of "resheader" rows that contain simple 
+    name/value pairs.
+    
+    Each data row contains a name, and value. The row also contains a 
+    type or mimetype. Type corresponds to a .NET class that support 
+    text/value conversion through the TypeConverter architecture. 
+    Classes that don't support this are serialized and stored with the 
+    mimetype set.
+    
+    The mimetype is used for serialized objects, and tells the 
+    ResXResourceReader how to depersist the object. This is currently not 
+    extensible. For a given mimetype the value must be set accordingly:
+    
+    Note - application/x-microsoft.net.object.binary.base64 is the format 
+    that the ResXResourceWriter will generate, however the reader can 
+    read any of the formats listed below.
+    
+    mimetype: application/x-microsoft.net.object.binary.base64
+    value   : The object must be serialized with 
+            : System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
+            : and then encoded with base64 encoding.
+    
+    mimetype: application/x-microsoft.net.object.soap.base64
+    value   : The object must be serialized with 
+            : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
+            : and then encoded with base64 encoding.
+
+    mimetype: application/x-microsoft.net.object.bytearray.base64
+    value   : The object must be serialized into a byte array 
+            : using a System.ComponentModel.TypeConverter
+            : and then encoded with base64 encoding.
+    -->
+  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
+    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
+    <xsd:element name="root" msdata:IsDataSet="true">
+      <xsd:complexType>
+        <xsd:choice maxOccurs="unbounded">
+          <xsd:element name="metadata">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" />
+              </xsd:sequence>
+              <xsd:attribute name="name" use="required" type="xsd:string" />
+              <xsd:attribute name="type" type="xsd:string" />
+              <xsd:attribute name="mimetype" type="xsd:string" />
+              <xsd:attribute ref="xml:space" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="assembly">
+            <xsd:complexType>
+              <xsd:attribute name="alias" type="xsd:string" />
+              <xsd:attribute name="name" type="xsd:string" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="data">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
+              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
+              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
+              <xsd:attribute ref="xml:space" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="resheader">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" use="required" />
+            </xsd:complexType>
+          </xsd:element>
+        </xsd:choice>
+      </xsd:complexType>
+    </xsd:element>
+  </xsd:schema>
+  <resheader name="resmimetype">
+    <value>text/microsoft-resx</value>
+  </resheader>
+  <resheader name="version">
+    <value>2.0</value>
+  </resheader>
+  <resheader name="reader">
+    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </resheader>
+  <resheader name="writer">
+    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </resheader>
+</root>
\ No newline at end of file
Index: Ringtoets/Integration/test/Ringtoets.Integration.Forms.Test/Ringtoets.Integration.Forms.Test.csproj
===================================================================
diff -u -raffe257dd529713fe3efe5af0dacbb9898217afb -r2657118de454794167b31aea0b730940c958c5c5
--- Ringtoets/Integration/test/Ringtoets.Integration.Forms.Test/Ringtoets.Integration.Forms.Test.csproj	(.../Ringtoets.Integration.Forms.Test.csproj)	(revision affe257dd529713fe3efe5af0dacbb9898217afb)
+++ Ringtoets/Integration/test/Ringtoets.Integration.Forms.Test/Ringtoets.Integration.Forms.Test.csproj	(.../Ringtoets.Integration.Forms.Test.csproj)	(revision 2657118de454794167b31aea0b730940c958c5c5)
@@ -88,6 +88,7 @@
     <Compile Include="Views\AssemblyResultCategoriesViewTest.cs" />
     <Compile Include="Views\AssemblyResultPerSectionViewTest.cs" />
     <Compile Include="Views\AssemblyCategoriesTableTest.cs" />
+    <Compile Include="Views\FailureMechanismWithDetailedAssessmentViewTest.cs" />
     <Compile Include="Views\FailureMechanismViewTest.cs" />
     <Compile Include="Views\MacroStabilityOutwardsAssemblyCategoriesViewTest.cs" />
     <Compile Include="Views\FailureMechanismAssemblyCategoriesViewTest.cs" />
Index: Ringtoets/Integration/test/Ringtoets.Integration.Forms.Test/Views/FailureMechanismWithDetailedAssessmentViewTest.cs
===================================================================
diff -u
--- Ringtoets/Integration/test/Ringtoets.Integration.Forms.Test/Views/FailureMechanismWithDetailedAssessmentViewTest.cs	(revision 0)
+++ Ringtoets/Integration/test/Ringtoets.Integration.Forms.Test/Views/FailureMechanismWithDetailedAssessmentViewTest.cs	(revision 2657118de454794167b31aea0b730940c958c5c5)
@@ -0,0 +1,588 @@
+// Copyright (C) Stichting Deltares 2018. All rights reserved.
+//
+// This file is part of Ringtoets.
+//
+// Ringtoets is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+// 
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program. If not, see <http://www.gnu.org/licenses/>.
+//
+// All names, logos, and references to "Deltares" are registered trademarks of
+// Stichting Deltares and remain full property of Stichting Deltares at all times.
+// All rights reserved.
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Windows.Forms;
+using Core.Common.Base;
+using Core.Common.Base.Geometry;
+using Core.Components.Gis.Data;
+using Core.Components.Gis.Features;
+using Core.Components.Gis.Forms;
+using Core.Components.Gis.Geometries;
+using NUnit.Framework;
+using Rhino.Mocks;
+using Ringtoets.Common.Data.AssessmentSection;
+using Ringtoets.Common.Data.FailureMechanism;
+using Ringtoets.Common.Data.Hydraulics;
+using Ringtoets.Common.Data.TestUtil;
+using Ringtoets.Common.Forms.TestUtil;
+using Ringtoets.Common.Forms.Views;
+using Ringtoets.Integration.Forms.Views;
+
+namespace Ringtoets.Integration.Forms.Test.Views
+{
+    [TestFixture]
+    public class FailureMechanismWithDetailedAssessmentViewTest
+    {
+        private const int referenceLineIndex = 0;
+        private const int sectionsCollectionIndex = 1;
+        private const int assemblyResultsIndex = 2;
+        private const int hydraulicBoundaryLocationsIndex = 3;
+
+        private const int sectionsIndex = 0;
+        private const int sectionsStartPointIndex = 1;
+        private const int sectionsEndPointIndex = 2;
+
+        private const int tailorMadeAssemblyIndex = 0;
+        private const int detailedAssemblyIndex = 1;
+        private const int simpleAssemblyIndex = 2;
+        private const int combinedAssemblyIndex = 3;
+
+        private const int hydraulicBoundaryLocationsObserverIndex = 1;
+        private const int sectionsObserverIndex = 2;
+        private const int sectionsStartPointObserverIndex = 3;
+        private const int sectionsEndPointObserverIndex = 4;
+        private const int simpleAssemblyObserverIndex = 5;
+        private const int detailedAssemblyObserverIndex = 6;
+        private const int tailorMadeAssemblyObserverIndex = 7;
+        private const int combinedAssemblyObserverIndex = 8;
+
+        [Test]
+        public void Constructor_ExpectedValues()
+        {
+            // Setup
+            var failureMechanism = new TestFailureMechanism();
+            var assessmentSection = new AssessmentSectionStub();
+
+            // Call
+            using (FailureMechanismWithDetailedAssessmentView<IHasSectionResults<FailureMechanismSectionResult>, FailureMechanismSectionResult> view =
+                CreateView(failureMechanism, assessmentSection))
+            {
+                // Assert
+                Assert.IsInstanceOf<UserControl>(view);
+                Assert.IsInstanceOf<IMapView>(view);
+                Assert.IsNull(view.Data);
+                Assert.AreSame(failureMechanism, view.FailureMechanism);
+                Assert.AreSame(assessmentSection, view.AssessmentSection);
+
+                Assert.AreEqual(1, view.Controls.Count);
+                Assert.IsInstanceOf<RingtoetsMapControl>(view.Controls[0]);
+                Assert.AreSame(view.Map, ((RingtoetsMapControl) view.Controls[0]).MapControl);
+                Assert.AreEqual(DockStyle.Fill, ((Control) view.Map).Dock);
+                AssertEmptyMapData(view.Map.Data);
+            }
+        }
+
+        [Test]
+        public void Constructor_FailureMechanismNull_ThrowsArgumentNullException()
+        {
+            // Setup
+            var mocks = new MockRepository();
+            var assessmentSection = mocks.Stub<IAssessmentSection>();
+            mocks.ReplayAll();
+
+            // Call
+            TestDelegate call = () => CreateView(null, assessmentSection);
+
+            // Assert
+            var exception = Assert.Throws<ArgumentNullException>(call);
+            Assert.AreEqual("failureMechanism", exception.ParamName);
+            mocks.VerifyAll();
+        }
+
+        [Test]
+        public void Constructor_AssessmentSectionNull_ThrowsArgumentNullException()
+        {
+            // Setup
+            var mocks = new MockRepository();
+            var failureMechanism = mocks.Stub<IHasSectionResults<FailureMechanismSectionResult>>();
+            mocks.ReplayAll();
+
+            // Call
+            TestDelegate call = () => CreateView(failureMechanism, null);
+
+            // Assert
+            var exception = Assert.Throws<ArgumentNullException>(call);
+            Assert.AreEqual("assessmentSection", exception.ParamName);
+            mocks.VerifyAll();
+        }
+
+        [Test]
+        public void Constructor_AssessmentSectionWithBackgroundData_BackgroundDataSet()
+        {
+            // Setup
+            IAssessmentSection assessmentSection = new AssessmentSectionStub();
+
+            // Call
+            using (FailureMechanismWithDetailedAssessmentView<IHasSectionResults<FailureMechanismSectionResult>, FailureMechanismSectionResult> view =
+                CreateView(new TestFailureMechanism(), assessmentSection))
+            {
+                // Assert
+                MapDataTestHelper.AssertImageBasedMapData(assessmentSection.BackgroundData, view.Map.BackgroundMapData);
+            }
+        }
+
+        [Test]
+        public void Constructor_WithAllData_DataUpdatedToCollectionOfFilledMapData()
+        {
+            // Setup
+            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 referenceLine = new ReferenceLine();
+            referenceLine.SetGeometry(new[]
+            {
+                new Point2D(1.0, 2.0),
+                new Point2D(2.0, 1.0)
+            });
+
+            var assessmentSection = new AssessmentSectionStub
+            {
+                ReferenceLine = referenceLine
+            };
+            assessmentSection.SetHydraulicBoundaryLocationCalculations(new[]
+            {
+                new HydraulicBoundaryLocation(1, "test", 1.0, 2.0)
+            });
+
+            var failureMechanism = new TestFailureMechanism();
+            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))
+            });
+
+            var simpleAssemblyFeatures = new[]
+            {
+                new MapFeature(Enumerable.Empty<MapGeometry>())
+            };
+            var detailedAssemblyFeatures = new[]
+            {
+                new MapFeature(Enumerable.Empty<MapGeometry>())
+            };
+            var tailorMadeAssemblyFeatures = new[]
+            {
+                new MapFeature(Enumerable.Empty<MapGeometry>())
+            };
+            var combinedAssemblyFeatures = new[]
+            {
+                new MapFeature(Enumerable.Empty<MapGeometry>())
+            };
+
+            // Call
+            using (var view = new FailureMechanismWithDetailedAssessmentView<TestFailureMechanism, FailureMechanismSectionResult>(
+                failureMechanism,
+                assessmentSection,
+                () => simpleAssemblyFeatures,
+                () => detailedAssemblyFeatures,
+                () => tailorMadeAssemblyFeatures,
+                () => combinedAssemblyFeatures))
+            {
+                IMapControl map = ((RingtoetsMapControl) 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));
+
+                MapDataTestHelper.AssertHydraulicBoundaryLocationsMapData(assessmentSection, mapDataList[hydraulicBoundaryLocationsIndex]);
+
+                IEnumerable<MapData> assemblyMapDataList = ((MapDataCollection) mapDataList[assemblyResultsIndex]).Collection;
+                Assert.AreEqual(4, assemblyMapDataList.Count());
+                CollectionAssert.AreEqual(simpleAssemblyFeatures, ((MapLineData) assemblyMapDataList.ElementAt(simpleAssemblyIndex)).Features);
+                CollectionAssert.AreEqual(detailedAssemblyFeatures, ((MapLineData) assemblyMapDataList.ElementAt(detailedAssemblyIndex)).Features);
+                CollectionAssert.AreEqual(tailorMadeAssemblyFeatures, ((MapLineData) assemblyMapDataList.ElementAt(tailorMadeAssemblyIndex)).Features);
+                CollectionAssert.AreEqual(combinedAssemblyFeatures, ((MapLineData) assemblyMapDataList.ElementAt(combinedAssemblyIndex)).Features);
+            }
+        }
+
+        [Test]
+        [TestCaseSource(typeof(MapViewTestHelper), nameof(MapViewTestHelper.GetCalculationFuncs))]
+        public void GivenViewWithHydraulicBoundaryLocationsData_WhenHydraulicBoundaryLocationCalculationUpdatedAndNotified_ThenMapDataUpdated(
+            Func<IAssessmentSection, HydraulicBoundaryLocationCalculation> getCalculationFunc)
+        {
+            // Given
+            var hydraulicBoundaryLocation = new HydraulicBoundaryLocation(1, "test1", 1.0, 2.0);
+            var assessmentSection = new AssessmentSectionStub();
+            assessmentSection.SetHydraulicBoundaryLocationCalculations(new[]
+            {
+                hydraulicBoundaryLocation
+            });
+
+            using (FailureMechanismWithDetailedAssessmentView<IHasSectionResults<FailureMechanismSectionResult>, FailureMechanismSectionResult> view =
+                CreateView(new TestFailureMechanism(), assessmentSection))
+            {
+                IMapControl map = ((RingtoetsMapControl) view.Controls[0]).MapControl;
+
+                var mocks = new MockRepository();
+                IObserver[] observers = AttachMapDataObservers(mocks, map.Data.Collection);
+                observers[hydraulicBoundaryLocationsObserverIndex].Expect(obs => obs.UpdateObserver());
+                mocks.ReplayAll();
+
+                MapData hydraulicBoundaryLocationsMapData = map.Data.Collection.ElementAt(hydraulicBoundaryLocationsIndex);
+
+                // Precondition
+                MapDataTestHelper.AssertHydraulicBoundaryLocationsMapData(assessmentSection, hydraulicBoundaryLocationsMapData);
+
+                // When
+                HydraulicBoundaryLocationCalculation calculation = getCalculationFunc(assessmentSection);
+                calculation.Output = new TestHydraulicBoundaryLocationCalculationOutput(new Random(21).NextDouble());
+                calculation.NotifyObservers();
+
+                // Then
+                MapDataTestHelper.AssertHydraulicBoundaryLocationsMapData(assessmentSection, hydraulicBoundaryLocationsMapData);
+                mocks.VerifyAll();
+            }
+        }
+
+        [Test]
+        public void UpdateObserver_HydraulicBoundaryLocationsDataUpdated_MapDataUpdated()
+        {
+            // Setup
+            var assessmentSection = new AssessmentSectionStub();
+            assessmentSection.SetHydraulicBoundaryLocationCalculations(new[]
+            {
+                new HydraulicBoundaryLocation(1, "test1", 1.0, 2.0)
+            });
+
+            using (FailureMechanismWithDetailedAssessmentView<IHasSectionResults<FailureMechanismSectionResult>, FailureMechanismSectionResult> view =
+                CreateView(new TestFailureMechanism(), assessmentSection))
+            {
+                IMapControl map = ((RingtoetsMapControl) view.Controls[0]).MapControl;
+
+                var mocks = new MockRepository();
+                IObserver[] observers = AttachMapDataObservers(mocks, map.Data.Collection);
+                observers[hydraulicBoundaryLocationsObserverIndex].Expect(obs => obs.UpdateObserver());
+                mocks.ReplayAll();
+
+                MapData hydraulicBoundaryLocationsMapData = map.Data.Collection.ElementAt(hydraulicBoundaryLocationsIndex);
+
+                // Precondition
+                MapDataTestHelper.AssertHydraulicBoundaryLocationsMapData(assessmentSection, hydraulicBoundaryLocationsMapData);
+
+                // Call
+                assessmentSection.SetHydraulicBoundaryLocationCalculations(new[]
+                {
+                    new HydraulicBoundaryLocation(2, "test2", 3.0, 4.0)
+                });
+                assessmentSection.HydraulicBoundaryDatabase.Locations.NotifyObservers();
+
+                // Assert
+                MapDataTestHelper.AssertHydraulicBoundaryLocationsMapData(assessmentSection, hydraulicBoundaryLocationsMapData);
+                mocks.VerifyAll();
+            }
+        }
+
+        [Test]
+        public void UpdateObserver_ReferenceLineUpdated_MapDataUpdated()
+        {
+            // Setup
+            var referenceLine = new ReferenceLine();
+            referenceLine.SetGeometry(new List<Point2D>
+            {
+                new Point2D(1.0, 2.0),
+                new Point2D(2.0, 1.0)
+            });
+
+            var assessmentSection = new AssessmentSectionStub
+            {
+                ReferenceLine = referenceLine
+            };
+
+            using (FailureMechanismWithDetailedAssessmentView<IHasSectionResults<FailureMechanismSectionResult>, FailureMechanismSectionResult> view =
+                CreateView(new TestFailureMechanism(), assessmentSection))
+            {
+                IMapControl map = ((RingtoetsMapControl) view.Controls[0]).MapControl;
+
+                var mocks = new MockRepository();
+                IObserver[] observers = AttachMapDataObservers(mocks, map.Data.Collection);
+                observers[referenceLineIndex].Expect(obs => obs.UpdateObserver());
+                mocks.ReplayAll();
+
+                MapData referenceLineMapData = map.Data.Collection.ElementAt(referenceLineIndex);
+
+                // Precondition
+                MapDataTestHelper.AssertReferenceLineMapData(assessmentSection.ReferenceLine, referenceLineMapData);
+
+                // Call
+                assessmentSection.ReferenceLine.SetGeometry(new List<Point2D>
+                {
+                    new Point2D(2.0, 5.0),
+                    new Point2D(4.0, 3.0)
+                });
+                assessmentSection.NotifyObservers();
+
+                // Assert
+                MapDataTestHelper.AssertReferenceLineMapData(assessmentSection.ReferenceLine, referenceLineMapData);
+                mocks.VerifyAll();
+            }
+        }
+
+        [Test]
+        public void UpdateObserver_FailureMechanismSectionsUpdated_MapDataUpdated()
+        {
+            // Setup
+            var failureMechanism = new TestFailureMechanism();
+
+            using (FailureMechanismWithDetailedAssessmentView<IHasSectionResults<FailureMechanismSectionResult>, FailureMechanismSectionResult> view =
+                CreateView(failureMechanism, new AssessmentSectionStub()))
+            {
+                IMapControl map = ((RingtoetsMapControl) 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());
+                observers[simpleAssemblyObserverIndex].Expect(obs => obs.UpdateObserver());
+                observers[detailedAssemblyObserverIndex].Expect(obs => obs.UpdateObserver());
+                observers[tailorMadeAssemblyObserverIndex].Expect(obs => obs.UpdateObserver());
+                observers[combinedAssemblyObserverIndex].Expect(obs => obs.UpdateObserver());
+                mocks.ReplayAll();
+
+                // Call
+                FailureMechanismTestHelper.SetSections(failureMechanism, new[]
+                {
+                    new FailureMechanismSection(string.Empty, new[]
+                    {
+                        new Point2D(1, 2),
+                        new Point2D(1, 2)
+                    })
+                });
+                failureMechanism.NotifyObservers();
+
+                // Assert
+                MapDataTestHelper.AssertFailureMechanismSectionsMapData(failureMechanism.Sections, sectionMapData);
+                MapDataTestHelper.AssertFailureMechanismSectionsStartPointMapData(failureMechanism.Sections, sectionStartsMapData);
+                MapDataTestHelper.AssertFailureMechanismSectionsEndPointMapData(failureMechanism.Sections, sectionsEndsMapData);
+                mocks.VerifyAll();
+            }
+        }
+
+        [Test]
+        public void UpdateObserver_DataUpdated_MapLayersSameOrder()
+        {
+            // Setup
+            const int updatedReferenceLineLayerIndex = referenceLineIndex + 3;
+            const int updatedSectionCollectionIndex = sectionsCollectionIndex - 1;
+            const int updatedAssemblyResultsCollectionIndex = assemblyResultsIndex - 1;
+            const int updatedHydraulicLocationsLayerIndex = hydraulicBoundaryLocationsIndex - 1;
+
+            var assessmentSection = new AssessmentSectionStub();
+            var failureMechanism = new TestFailureMechanism();
+
+            using (FailureMechanismWithDetailedAssessmentView<IHasSectionResults<FailureMechanismSectionResult>, FailureMechanismSectionResult> view =
+                CreateView(failureMechanism, assessmentSection))
+            {
+                IMapControl map = ((RingtoetsMapControl) view.Controls[0]).MapControl;
+
+                MapDataCollection mapData = map.Data;
+
+                var dataToMove = (MapLineData) map.Data.Collection.ElementAt(referenceLineIndex);
+                mapData.Remove(dataToMove);
+                mapData.Add(dataToMove);
+
+                List<MapData> mapDataList = mapData.Collection.ToList();
+
+                // Precondition
+                var referenceLineData = (MapLineData) mapDataList[updatedReferenceLineLayerIndex];
+                Assert.AreEqual("Referentielijn", referenceLineData.Name);
+
+                var sectionsData = (MapDataCollection) mapDataList[updatedSectionCollectionIndex];
+                Assert.AreEqual("Vakindeling", sectionsData.Name);
+
+                var assemblyResultsData = (MapDataCollection) mapDataList[updatedAssemblyResultsCollectionIndex];
+                Assert.AreEqual("Toetsoordeel", assemblyResultsData.Name);
+
+                var hydraulicLocationsData = (MapPointData) mapDataList[updatedHydraulicLocationsLayerIndex];
+                Assert.AreEqual("Hydraulische belastingen", hydraulicLocationsData.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) mapDataList[updatedReferenceLineLayerIndex];
+                Assert.AreEqual("Referentielijn", actualReferenceLineData.Name);
+
+                var actualSectionsData = (MapDataCollection) mapDataList[updatedSectionCollectionIndex];
+                Assert.AreEqual("Vakindeling", actualSectionsData.Name);
+
+                var actualAssemblyResultsData = (MapDataCollection) mapDataList[updatedAssemblyResultsCollectionIndex];
+                Assert.AreEqual("Toetsoordeel", actualAssemblyResultsData.Name);
+
+                var actualHydraulicLocationsData = (MapPointData) mapDataList[updatedHydraulicLocationsLayerIndex];
+                Assert.AreEqual("Hydraulische belastingen", actualHydraulicLocationsData.Name);
+            }
+        }
+
+        private static FailureMechanismWithDetailedAssessmentView<IHasSectionResults<FailureMechanismSectionResult>, FailureMechanismSectionResult> CreateView(
+            IHasSectionResults<FailureMechanismSectionResult> failureMechanism,
+            IAssessmentSection assessmentSection)
+        {
+            return new FailureMechanismWithDetailedAssessmentView<IHasSectionResults<FailureMechanismSectionResult>, FailureMechanismSectionResult>(
+                failureMechanism,
+                assessmentSection,
+                Enumerable.Empty<MapFeature>,
+                Enumerable.Empty<MapFeature>,
+                Enumerable.Empty<MapFeature>,
+                Enumerable.Empty<MapFeature>);
+        }
+
+        private static void AssertEmptyMapData(MapDataCollection mapDataCollection)
+        {
+            Assert.AreEqual("Test failure mechanism", mapDataCollection.Name);
+
+            List<MapData> mapDataList = mapDataCollection.Collection.ToList();
+
+            Assert.AreEqual(4, mapDataList.Count);
+
+            var referenceLineMapData = (MapLineData) mapDataList[referenceLineIndex];
+            var hydraulicBoundaryLocationsMapData = (MapPointData) mapDataList[hydraulicBoundaryLocationsIndex];
+
+            CollectionAssert.IsEmpty(referenceLineMapData.Features);
+            CollectionAssert.IsEmpty(hydraulicBoundaryLocationsMapData.Features);
+
+            Assert.AreEqual("Referentielijn", referenceLineMapData.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);
+
+            var assemblyResultsMapDataCollection = (MapDataCollection) mapDataList[assemblyResultsIndex];
+            Assert.AreEqual("Toetsoordeel", assemblyResultsMapDataCollection.Name);
+            List<MapData> assemblyMapDataList = assemblyResultsMapDataCollection.Collection.ToList();
+            Assert.AreEqual(4, assemblyMapDataList.Count);
+
+            var combinedAssemblyMapData = (MapLineData) assemblyMapDataList[combinedAssemblyIndex];
+            var simpleAssemblyMapData = (MapLineData) assemblyMapDataList[simpleAssemblyIndex];
+            var detailedAssemblyMapData = (MapLineData) assemblyMapDataList[detailedAssemblyIndex];
+            var tailorMadeAssemblyMapData = (MapLineData) assemblyMapDataList[tailorMadeAssemblyIndex];
+
+            CollectionAssert.IsEmpty(combinedAssemblyMapData.Features);
+            CollectionAssert.IsEmpty(simpleAssemblyMapData.Features);
+            CollectionAssert.IsEmpty(detailedAssemblyMapData.Features);
+            CollectionAssert.IsEmpty(tailorMadeAssemblyMapData.Features);
+
+            Assert.AreEqual("Gecombineerd toetsoordeel", combinedAssemblyMapData.Name);
+            Assert.AreEqual("Toetsoordeel eenvoudige toets", simpleAssemblyMapData.Name);
+            Assert.AreEqual("Toetsoordeel gedetailleerde toets", detailedAssemblyMapData.Name);
+            Assert.AreEqual("Toetsoordeel toets op maat", tailorMadeAssemblyMapData.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();
+
+            var referenceLineMapDataObserver = mocks.StrictMock<IObserver>();
+            mapDataArray[referenceLineIndex].Attach(referenceLineMapDataObserver);
+
+            var hydraulicBoundaryLocationsMapDataObserver = mocks.StrictMock<IObserver>();
+            mapDataArray[hydraulicBoundaryLocationsIndex].Attach(hydraulicBoundaryLocationsMapDataObserver);
+
+            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);
+
+            MapData[] assemblyResultsCollection = ((MapDataCollection) mapDataArray[assemblyResultsIndex]).Collection.ToArray();
+            var simpleAssemblyMapDataObserver = mocks.StrictMock<IObserver>();
+            assemblyResultsCollection[simpleAssemblyIndex].Attach(simpleAssemblyMapDataObserver);
+
+            var detailedAssemblyMapDataObserver = mocks.StrictMock<IObserver>();
+            assemblyResultsCollection[detailedAssemblyIndex].Attach(detailedAssemblyMapDataObserver);
+
+            var tailorMadeAssemblyMapDataObserver = mocks.StrictMock<IObserver>();
+            assemblyResultsCollection[tailorMadeAssemblyIndex].Attach(tailorMadeAssemblyMapDataObserver);
+
+            var combinedAssemblyMapDataObserver = mocks.StrictMock<IObserver>();
+            assemblyResultsCollection[combinedAssemblyIndex].Attach(combinedAssemblyMapDataObserver);
+
+            return new[]
+            {
+                referenceLineMapDataObserver,
+                hydraulicBoundaryLocationsMapDataObserver,
+                sectionsMapDataObserver,
+                sectionsStartPointMapDataObserver,
+                sectionsEndPointMapDataObserver,
+                simpleAssemblyMapDataObserver,
+                detailedAssemblyMapDataObserver,
+                tailorMadeAssemblyMapDataObserver,
+                combinedAssemblyMapDataObserver
+            };
+        }
+    }
+}
\ No newline at end of file