Fisheye: Tag 826ed5d86e04dbf6e830afa9bcf14b2b2619b10f refers to a dead (removed) revision in file `Riskeer/Integration/src/Riskeer.Integration.Forms/Views/FailureMechanismWithDetailedAssessmentView.Designer.cs'.
Fisheye: No comparison available.  Pass `N' to diff?
Fisheye: Tag 826ed5d86e04dbf6e830afa9bcf14b2b2619b10f refers to a dead (removed) revision in file `Riskeer/Integration/src/Riskeer.Integration.Forms/Views/FailureMechanismWithDetailedAssessmentView.cs'.
Fisheye: No comparison available.  Pass `N' to diff?
Fisheye: Tag 826ed5d86e04dbf6e830afa9bcf14b2b2619b10f refers to a dead (removed) revision in file `Riskeer/Integration/src/Riskeer.Integration.Forms/Views/FailureMechanismWithDetailedAssessmentView.resx'.
Fisheye: No comparison available.  Pass `N' to diff?
Fisheye: Tag 826ed5d86e04dbf6e830afa9bcf14b2b2619b10f refers to a dead (removed) revision in file `Riskeer/Integration/src/Riskeer.Integration.Forms/Views/FailureMechanismWithoutDetailedAssessmentView.Designer.cs'.
Fisheye: No comparison available.  Pass `N' to diff?
Fisheye: Tag 826ed5d86e04dbf6e830afa9bcf14b2b2619b10f refers to a dead (removed) revision in file `Riskeer/Integration/src/Riskeer.Integration.Forms/Views/FailureMechanismWithoutDetailedAssessmentView.cs'.
Fisheye: No comparison available.  Pass `N' to diff?
Fisheye: Tag 826ed5d86e04dbf6e830afa9bcf14b2b2619b10f refers to a dead (removed) revision in file `Riskeer/Integration/src/Riskeer.Integration.Forms/Views/FailureMechanismWithoutDetailedAssessmentView.resx'.
Fisheye: No comparison available.  Pass `N' to diff?
Index: Riskeer/Integration/src/Riskeer.Integration.Forms/Views/StandAloneFailureMechanismView.Designer.cs
===================================================================
diff -u
--- Riskeer/Integration/src/Riskeer.Integration.Forms/Views/StandAloneFailureMechanismView.Designer.cs	(revision 0)
+++ Riskeer/Integration/src/Riskeer.Integration.Forms/Views/StandAloneFailureMechanismView.Designer.cs	(revision 826ed5d86e04dbf6e830afa9bcf14b2b2619b10f)
@@ -0,0 +1,66 @@
+// 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 Riskeer.Common.Forms.Views;
+
+namespace Riskeer.Integration.Forms.Views
+{
+    partial class StandAloneFailureMechanismView<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.riskeerMapControl = new Riskeer.Common.Forms.Views.RiskeerMapControl();
+            this.SuspendLayout();
+            // 
+            // riskeerMapControl
+            // 
+            this.riskeerMapControl.Dock = System.Windows.Forms.DockStyle.Fill;
+            this.riskeerMapControl.Location = new System.Drawing.Point(0, 0);
+            this.riskeerMapControl.Name = "riskeerMapControl";
+            this.riskeerMapControl.Size = new System.Drawing.Size(150, 150);
+            this.riskeerMapControl.TabIndex = 0;
+            // 
+            // FailureMechanismWithDetailedAssessmentView
+            // 
+            this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
+            this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
+            this.Controls.Add(this.riskeerMapControl);
+            this.Name = "StandAloneFailureMechanismView";
+            this.ResumeLayout(false);
+
+        }
+
+        #endregion
+
+        private RiskeerMapControl riskeerMapControl;
+    }
+}
Index: Riskeer/Integration/src/Riskeer.Integration.Forms/Views/StandAloneFailureMechanismView.cs
===================================================================
diff -u
--- Riskeer/Integration/src/Riskeer.Integration.Forms/Views/StandAloneFailureMechanismView.cs	(revision 0)
+++ Riskeer/Integration/src/Riskeer.Integration.Forms/Views/StandAloneFailureMechanismView.cs	(revision 826ed5d86e04dbf6e830afa9bcf14b2b2619b10f)
@@ -0,0 +1,211 @@
+// 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.Windows.Forms;
+using Core.Common.Base;
+using Core.Components.Gis.Data;
+using Core.Components.Gis.Forms;
+using Riskeer.AssemblyTool.Data;
+using Riskeer.Common.Data.AssessmentSection;
+using Riskeer.Common.Data.FailureMechanism;
+using Riskeer.Common.Forms.Factories;
+using Riskeer.Common.Forms.MapLayers;
+
+namespace Riskeer.Integration.Forms.Views
+{
+    /// <summary>
+    /// This class is a view showing map data for a stand alone failure mechanism.
+    /// </summary>
+    public partial class StandAloneFailureMechanismView<TFailureMechanism, TSectionResult> : UserControl, IMapView
+        where TFailureMechanism : IHasSectionResults<FailureMechanismSectionResultOld, TSectionResult>
+        where TSectionResult : FailureMechanismSectionResult
+    {
+        private readonly Func<TSectionResult, FailureMechanismSectionAssemblyResult> performAssemblyFunc;
+
+        private HydraulicBoundaryLocationsMapLayer hydraulicBoundaryLocationsMapLayer;
+        private NonCalculatableFailureMechanismSectionResultsMapLayer<TSectionResult> assemblyResultMapLayer;
+
+        private MapDataCollection mapDataCollection;
+        private MapLineData referenceLineMapData;
+
+        private MapLineData sectionsMapData;
+        private MapPointData sectionsStartPointMapData;
+        private MapPointData sectionsEndPointMapData;
+
+        private Observer failureMechanismObserver;
+        private Observer assessmentSectionObserver;
+        private Observer referenceLineObserver;
+
+        /// <summary>
+        /// Creates a new instance of <see cref="StandAloneFailureMechanismView{TFailureMechanism,TSectionResult}"/>.
+        /// </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="performAssemblyFunc">The <see cref="Func{T1,TResult}"/> used to assemble the result of a section result.</param>
+        /// <exception cref="ArgumentNullException">Thrown when any parameter is <c>null</c>.</exception>
+        public StandAloneFailureMechanismView(TFailureMechanism failureMechanism, IAssessmentSection assessmentSection,
+                                              Func<TSectionResult, FailureMechanismSectionAssemblyResult> performAssemblyFunc)
+        {
+            if (failureMechanism == null)
+            {
+                throw new ArgumentNullException(nameof(failureMechanism));
+            }
+
+            if (assessmentSection == null)
+            {
+                throw new ArgumentNullException(nameof(assessmentSection));
+            }
+
+            if (performAssemblyFunc == null)
+            {
+                throw new ArgumentNullException(nameof(performAssemblyFunc));
+            }
+
+            InitializeComponent();
+
+            FailureMechanism = failureMechanism;
+            AssessmentSection = assessmentSection;
+            this.performAssemblyFunc = performAssemblyFunc;
+
+            CreateObservers();
+
+            CreateMapData();
+            SetAllMapDataFeatures();
+            riskeerMapControl.SetAllData(mapDataCollection, assessmentSection.BackgroundData);
+        }
+
+        /// <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 => riskeerMapControl.MapControl;
+
+        protected override void Dispose(bool disposing)
+        {
+            failureMechanismObserver.Dispose();
+            assessmentSectionObserver.Dispose();
+            referenceLineObserver.Dispose();
+            hydraulicBoundaryLocationsMapLayer.Dispose();
+            assemblyResultMapLayer.Dispose();
+
+            if (disposing)
+            {
+                components?.Dispose();
+            }
+
+            base.Dispose(disposing);
+        }
+
+        private void CreateMapData()
+        {
+            mapDataCollection = new MapDataCollection(FailureMechanism.Name);
+            referenceLineMapData = RiskeerMapDataFactory.CreateReferenceLineMapData();
+            hydraulicBoundaryLocationsMapLayer = new HydraulicBoundaryLocationsMapLayer(AssessmentSection);
+
+            MapDataCollection sectionsMapDataCollection = RiskeerMapDataFactory.CreateSectionsMapDataCollection();
+            sectionsMapData = RiskeerMapDataFactory.CreateFailureMechanismSectionsMapData();
+            sectionsStartPointMapData = RiskeerMapDataFactory.CreateFailureMechanismSectionsStartPointMapData();
+            sectionsEndPointMapData = RiskeerMapDataFactory.CreateFailureMechanismSectionsEndPointMapData();
+
+            assemblyResultMapLayer = new NonCalculatableFailureMechanismSectionResultsMapLayer<TSectionResult>(
+                FailureMechanism, performAssemblyFunc);
+
+            mapDataCollection.Add(referenceLineMapData);
+
+            sectionsMapDataCollection.Add(sectionsMapData);
+            sectionsMapDataCollection.Add(sectionsStartPointMapData);
+            sectionsMapDataCollection.Add(sectionsEndPointMapData);
+            mapDataCollection.Add(sectionsMapDataCollection);
+
+            mapDataCollection.Add(assemblyResultMapLayer.MapData);
+            mapDataCollection.Add(hydraulicBoundaryLocationsMapLayer.MapData);
+        }
+
+        private void CreateObservers()
+        {
+            failureMechanismObserver = new Observer(UpdateFailureMechanismMapData)
+            {
+                Observable = FailureMechanism
+            };
+            assessmentSectionObserver = new Observer(UpdateReferenceLineMapData)
+            {
+                Observable = AssessmentSection
+            };
+            referenceLineObserver = new Observer(UpdateReferenceLineMapData)
+            {
+                Observable = AssessmentSection.ReferenceLine
+            };
+        }
+
+        private void SetAllMapDataFeatures()
+        {
+            SetReferenceLineMapData();
+            SetSectionsMapData();
+        }
+
+        #region AssessmentSection MapData
+
+        private void UpdateReferenceLineMapData()
+        {
+            SetReferenceLineMapData();
+            referenceLineMapData.NotifyObservers();
+        }
+
+        private void SetReferenceLineMapData()
+        {
+            referenceLineMapData.Features = RiskeerMapDataFeaturesFactory.CreateReferenceLineFeatures(
+                AssessmentSection.ReferenceLine, AssessmentSection.Id, AssessmentSection.Name);
+        }
+
+        #endregion
+
+        #region FailureMechanism MapData
+
+        private void UpdateFailureMechanismMapData()
+        {
+            SetSectionsMapData();
+            sectionsMapData.NotifyObservers();
+            sectionsStartPointMapData.NotifyObservers();
+            sectionsEndPointMapData.NotifyObservers();
+        }
+
+        private void SetSectionsMapData()
+        {
+            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
Index: Riskeer/Integration/src/Riskeer.Integration.Forms/Views/StandAloneFailureMechanismView.resx
===================================================================
diff -u
--- Riskeer/Integration/src/Riskeer.Integration.Forms/Views/StandAloneFailureMechanismView.resx	(revision 0)
+++ Riskeer/Integration/src/Riskeer.Integration.Forms/Views/StandAloneFailureMechanismView.resx	(revision 826ed5d86e04dbf6e830afa9bcf14b2b2619b10f)
@@ -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: Riskeer/Integration/src/Riskeer.Integration.Plugin/RiskeerPlugin.cs
===================================================================
diff -u -r432b46a640176168e7bbb391c08f25fc76b877b7 -r826ed5d86e04dbf6e830afa9bcf14b2b2619b10f
--- Riskeer/Integration/src/Riskeer.Integration.Plugin/RiskeerPlugin.cs	(.../RiskeerPlugin.cs)	(revision 432b46a640176168e7bbb391c08f25fc76b877b7)
+++ Riskeer/Integration/src/Riskeer.Integration.Plugin/RiskeerPlugin.cs	(.../RiskeerPlugin.cs)	(revision 826ed5d86e04dbf6e830afa9bcf14b2b2619b10f)
@@ -1387,46 +1387,25 @@
 
         #region FailureMechanismWithDetailedAssessmentView ViewInfo
 
-        private ViewInfo<TFailureMechanismContext, TFailureMechanism, FailureMechanismWithDetailedAssessmentView<TFailureMechanism, TSectionResult>> CreateFailureMechanismWithDetailedAssessmentViewInfo<
+        private ViewInfo<TFailureMechanismContext, TFailureMechanism, StandAloneFailureMechanismView<TFailureMechanism, TSectionResult>> CreateFailureMechanismWithDetailedAssessmentViewInfo<
             TFailureMechanismContext, TFailureMechanism, TSectionResult>(Func<TFailureMechanismContext, TSectionResult, FailureMechanismSectionAssemblyResult> performAssemblyFunc)
             where TSectionResult : FailureMechanismSectionResult
             where TFailureMechanism : FailureMechanismBase, IHasSectionResults<FailureMechanismSectionResultOld, TSectionResult>
             where TFailureMechanismContext : IFailurePathContext<TFailureMechanism>
         {
             return new RiskeerViewInfo<TFailureMechanismContext, TFailureMechanism,
-                FailureMechanismWithDetailedAssessmentView<TFailureMechanism, TSectionResult>>(() => Gui)
+                StandAloneFailureMechanismView<TFailureMechanism, TSectionResult>>(() => Gui)
             {
                 GetViewName = (view, context) => context.WrappedData.Name,
                 CloseForData = (view, dataToCloseFor) => ReferenceEquals(view.AssessmentSection, dataToCloseFor),
                 AdditionalDataCheck = context => context.WrappedData.InAssembly,
-                CreateInstance = context => new FailureMechanismWithDetailedAssessmentView<TFailureMechanism, TSectionResult>(
+                CreateInstance = context => new StandAloneFailureMechanismView<TFailureMechanism, TSectionResult>(
                     context.WrappedData, context.Parent, sr => performAssemblyFunc(context, sr))
             };
         }
 
         #endregion
 
-        #region FailureMechanismWithoutDetailedAssessmentView ViewInfo
-
-        private ViewInfo<TFailureMechanismContext, TFailureMechanism, FailureMechanismWithoutDetailedAssessmentView<TFailureMechanism, TSectionResult>> CreateFailureMechanismWithoutDetailedAssessmentViewInfo<
-            TFailureMechanismContext, TFailureMechanism, TSectionResult>(
-            Func<TFailureMechanismContext, FailureMechanismWithoutDetailedAssessmentView<TFailureMechanism, TSectionResult>> createInstanceFunc)
-            where TSectionResult : FailureMechanismSectionResultOld
-            where TFailureMechanism : FailureMechanismBase, IHasSectionResults<TSectionResult>
-            where TFailureMechanismContext : IFailurePathContext<TFailureMechanism>
-        {
-            return new RiskeerViewInfo<TFailureMechanismContext, TFailureMechanism,
-                FailureMechanismWithoutDetailedAssessmentView<TFailureMechanism, TSectionResult>>(() => Gui)
-            {
-                GetViewName = (view, context) => context.WrappedData.Name,
-                CloseForData = (view, dataToCloseFor) => ReferenceEquals(view.AssessmentSection, dataToCloseFor),
-                AdditionalDataCheck = context => context.WrappedData.InAssembly,
-                CreateInstance = createInstanceFunc
-            };
-        }
-
-        #endregion
-
         #region FailureMechanismResults ViewInfo
 
         private static bool CloseFailureMechanismResultViewForData<TFailureMechanism, TSectionResult, TView, TSectionResultRow>(TView view, object dataToCloseFor)
Fisheye: Tag 826ed5d86e04dbf6e830afa9bcf14b2b2619b10f refers to a dead (removed) revision in file `Riskeer/Integration/test/Riskeer.Integration.Forms.Test/Views/FailureMechanismWithDetailedAssessmentViewTest.cs'.
Fisheye: No comparison available.  Pass `N' to diff?
Fisheye: Tag 826ed5d86e04dbf6e830afa9bcf14b2b2619b10f refers to a dead (removed) revision in file `Riskeer/Integration/test/Riskeer.Integration.Forms.Test/Views/FailureMechanismWithoutDetailedAssessmentViewTest.cs'.
Fisheye: No comparison available.  Pass `N' to diff?
Index: Riskeer/Integration/test/Riskeer.Integration.Forms.Test/Views/StandAloneFailureMechanismViewTest.cs
===================================================================
diff -u
--- Riskeer/Integration/test/Riskeer.Integration.Forms.Test/Views/StandAloneFailureMechanismViewTest.cs	(revision 0)
+++ Riskeer/Integration/test/Riskeer.Integration.Forms.Test/Views/StandAloneFailureMechanismViewTest.cs	(revision 826ed5d86e04dbf6e830afa9bcf14b2b2619b10f)
@@ -0,0 +1,494 @@
+// 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.Windows.Forms;
+using Core.Common.Base;
+using Core.Common.Base.Geometry;
+using Core.Common.TestUtil;
+using Core.Components.Gis.Data;
+using Core.Components.Gis.Forms;
+using NUnit.Framework;
+using Rhino.Mocks;
+using Riskeer.AssemblyTool.Data;
+using Riskeer.Common.Data.AssemblyTool;
+using Riskeer.Common.Data.AssessmentSection;
+using Riskeer.Common.Data.FailureMechanism;
+using Riskeer.Common.Data.Hydraulics;
+using Riskeer.Common.Data.TestUtil;
+using Riskeer.Common.Forms.TestUtil;
+using Riskeer.Common.Forms.Views;
+using Riskeer.Integration.Forms.Views;
+
+namespace Riskeer.Integration.Forms.Test.Views
+{
+    [TestFixture]
+    public class StandAloneFailureMechanismViewTest
+    {
+        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 sectionsObserverIndex = 1;
+        private const int sectionsStartPointObserverIndex = 2;
+        private const int sectionsEndPointObserverIndex = 3;
+
+        [Test]
+        public void Constructor_ExpectedValues()
+        {
+            // Setup
+            var failureMechanism = new TestFailureMechanism();
+            var assessmentSection = new AssessmentSectionStub();
+
+            // Call
+            using (StandAloneFailureMechanismView<IHasSectionResults<FailureMechanismSectionResultOld, 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<RiskeerMapControl>(view.Controls[0]);
+                Assert.AreSame(view.Map, ((RiskeerMapControl) 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
+            void Call() => new StandAloneFailureMechanismView<IHasSectionResults<FailureMechanismSectionResultOld, FailureMechanismSectionResult>, FailureMechanismSectionResult>(
+                null, assessmentSection, sr => null);
+
+            // 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<FailureMechanismSectionResultOld, FailureMechanismSectionResult>>();
+            mocks.ReplayAll();
+
+            // Call
+            void Call() => new StandAloneFailureMechanismView<IHasSectionResults<FailureMechanismSectionResultOld, FailureMechanismSectionResult>, FailureMechanismSectionResult>(
+                failureMechanism, null, sr => null);
+
+            // Assert
+            var exception = Assert.Throws<ArgumentNullException>(Call);
+            Assert.AreEqual("assessmentSection", exception.ParamName);
+            mocks.VerifyAll();
+        }
+
+        [Test]
+        public void Constructor_PerformAssemblyFuncNull_ThrowsArgumentNullException()
+        {
+            // Setup
+            var mocks = new MockRepository();
+            var failureMechanism = mocks.Stub<IHasSectionResults<FailureMechanismSectionResultOld, FailureMechanismSectionResult>>();
+            var assessmentSection = mocks.Stub<IAssessmentSection>();
+            mocks.ReplayAll();
+
+            // Call
+            void Call() => new StandAloneFailureMechanismView<IHasSectionResults<FailureMechanismSectionResultOld, FailureMechanismSectionResult>, FailureMechanismSectionResult>(
+                failureMechanism, assessmentSection, null);
+
+            // Assert
+            var exception = Assert.Throws<ArgumentNullException>(Call);
+            Assert.AreEqual("performAssemblyFunc", exception.ParamName);
+            mocks.VerifyAll();
+        }
+
+        [Test]
+        public void Constructor_AssessmentSectionWithBackgroundData_BackgroundDataSet()
+        {
+            // Setup
+            IAssessmentSection assessmentSection = new AssessmentSectionStub();
+
+            // Call
+            using (StandAloneFailureMechanismView<IHasSectionResults<FailureMechanismSectionResultOld, 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 random = new Random(21);
+            var failureMechanismSectionAssemblyResult = new FailureMechanismSectionAssemblyResult(
+                random.NextDouble(), random.NextDouble(), random.NextDouble(),
+                random.NextEnumValue<FailureMechanismSectionAssemblyGroup>());
+
+            // Call
+            using (var view = new StandAloneFailureMechanismView<IHasSectionResults<FailureMechanismSectionResultOld, FailureMechanismSectionResult>, FailureMechanismSectionResult>(
+                       failureMechanism, assessmentSection, sr => failureMechanismSectionAssemblyResult))
+            {
+                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));
+
+                MapDataTestHelper.AssertHydraulicBoundaryLocationsMapData(assessmentSection, mapDataList[hydraulicBoundaryLocationsIndex]);
+
+                MapDataTestHelper.AssertAssemblyMapData(failureMechanism, failureMechanismSectionAssemblyResult, mapDataList[assemblyResultsIndex]);
+            }
+        }
+
+        [Test]
+        public void UpdateObserver_AssessmentSectionUpdated_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 (StandAloneFailureMechanismView<IHasSectionResults<FailureMechanismSectionResultOld, FailureMechanismSectionResult>, FailureMechanismSectionResult> view =
+                   CreateView(new TestFailureMechanism(), assessmentSection))
+            {
+                IMapControl map = ((RiskeerMapControl) view.Controls[0]).MapControl;
+
+                var mocks = new MockRepository();
+                IObserver[] observers = AttachMapDataObservers(mocks, map.Data.Collection);
+                observers[referenceLineIndex].Expect(obs => obs.UpdateObserver());
+                mocks.ReplayAll();
+
+                var referenceLineMapData = (MapLineData) map.Data.Collection.ElementAt(referenceLineIndex);
+
+                // Precondition
+                MapFeaturesTestHelper.AssertReferenceLineMetaData(assessmentSection.ReferenceLine, assessmentSection, referenceLineMapData.Features);
+
+                // Call
+                assessmentSection.Name = "New name";
+                assessmentSection.NotifyObservers();
+
+                // Assert
+                MapFeaturesTestHelper.AssertReferenceLineMetaData(assessmentSection.ReferenceLine, assessmentSection, referenceLineMapData.Features);
+                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 (StandAloneFailureMechanismView<IHasSectionResults<FailureMechanismSectionResultOld, FailureMechanismSectionResult>, FailureMechanismSectionResult> view =
+                   CreateView(new TestFailureMechanism(), assessmentSection))
+            {
+                IMapControl map = ((RiskeerMapControl) 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
+                referenceLine.SetGeometry(new List<Point2D>
+                {
+                    new Point2D(2.0, 5.0),
+                    new Point2D(4.0, 3.0)
+                });
+                referenceLine.NotifyObservers();
+
+                // Assert
+                MapDataTestHelper.AssertReferenceLineMapData(assessmentSection.ReferenceLine, referenceLineMapData);
+                mocks.VerifyAll();
+            }
+        }
+
+        [Test]
+        public void UpdateObserver_FailureMechanismUpdated_MapDataUpdated()
+        {
+            // Setup
+            var failureMechanism = new TestFailureMechanism();
+
+            using (StandAloneFailureMechanismView<IHasSectionResults<FailureMechanismSectionResultOld, FailureMechanismSectionResult>, FailureMechanismSectionResult> 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();
+
+                // 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 updatedAssemblyResultsIndex = assemblyResultsIndex - 1;
+            const int updatedHydraulicLocationsLayerIndex = hydraulicBoundaryLocationsIndex - 1;
+
+            var assessmentSection = new AssessmentSectionStub();
+            var failureMechanism = new TestFailureMechanism();
+
+            using (StandAloneFailureMechanismView<IHasSectionResults<FailureMechanismSectionResultOld, FailureMechanismSectionResult>, FailureMechanismSectionResult> 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(updatedSectionCollectionIndex);
+                Assert.AreEqual("Vakindeling", sectionsData.Name);
+
+                var assemblyResultsData = (MapLineData) mapDataCollection.ElementAt(updatedAssemblyResultsIndex);
+                Assert.AreEqual("Duidingsklasse per vak", assemblyResultsData.Name);
+
+                var hydraulicLocationsData = (MapPointData) mapDataCollection.ElementAt(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) mapDataCollection.ElementAt(updatedReferenceLineLayerIndex);
+                Assert.AreEqual("Referentielijn", actualReferenceLineData.Name);
+
+                var actualSectionsData = (MapDataCollection) mapDataCollection.ElementAt(updatedSectionCollectionIndex);
+                Assert.AreEqual("Vakindeling", actualSectionsData.Name);
+
+                var actualAssemblyResultsData = (MapLineData) mapDataCollection.ElementAt(updatedAssemblyResultsIndex);
+                Assert.AreEqual("Duidingsklasse per vak", actualAssemblyResultsData.Name);
+
+                var actualHydraulicLocationsData = (MapPointData) mapDataCollection.ElementAt(updatedHydraulicLocationsLayerIndex);
+                Assert.AreEqual("Hydraulische belastingen", actualHydraulicLocationsData.Name);
+            }
+        }
+
+        private static StandAloneFailureMechanismView<IHasSectionResults<FailureMechanismSectionResultOld, FailureMechanismSectionResult>, FailureMechanismSectionResult> CreateView(
+            IHasSectionResults<FailureMechanismSectionResultOld, FailureMechanismSectionResult> failureMechanism,
+            IAssessmentSection assessmentSection)
+        {
+            return new StandAloneFailureMechanismView<IHasSectionResults<FailureMechanismSectionResultOld, FailureMechanismSectionResult>, FailureMechanismSectionResult>(
+                failureMechanism, assessmentSection, sr => new DefaultFailureMechanismSectionAssemblyResult());
+        }
+
+        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 assemblyResultsMapData = (MapLineData) mapDataList[assemblyResultsIndex];
+            var hydraulicBoundaryLocationsMapData = (MapPointData) mapDataList[hydraulicBoundaryLocationsIndex];
+
+            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();
+
+            var referenceLineMapDataObserver = mocks.StrictMock<IObserver>();
+            mapDataArray[referenceLineIndex].Attach(referenceLineMapDataObserver);
+
+            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[]
+            {
+                referenceLineMapDataObserver,
+                sectionsMapDataObserver,
+                sectionsStartPointMapDataObserver,
+                sectionsEndPointMapDataObserver
+            };
+        }
+    }
+}
\ No newline at end of file
Index: Riskeer/Integration/test/Riskeer.Integration.Plugin.Test/RiskeerPluginTest.cs
===================================================================
diff -u -r432b46a640176168e7bbb391c08f25fc76b877b7 -r826ed5d86e04dbf6e830afa9bcf14b2b2619b10f
--- Riskeer/Integration/test/Riskeer.Integration.Plugin.Test/RiskeerPluginTest.cs	(.../RiskeerPluginTest.cs)	(revision 432b46a640176168e7bbb391c08f25fc76b877b7)
+++ Riskeer/Integration/test/Riskeer.Integration.Plugin.Test/RiskeerPluginTest.cs	(.../RiskeerPluginTest.cs)	(revision 826ed5d86e04dbf6e830afa9bcf14b2b2619b10f)
@@ -491,31 +491,31 @@
                     viewInfos,
                     typeof(MicrostabilityFailurePathContext),
                     typeof(MicrostabilityFailureMechanism),
-                    typeof(FailureMechanismWithDetailedAssessmentView<MicrostabilityFailureMechanism, NonAdoptableWithProfileProbabilityFailureMechanismSectionResult>));
+                    typeof(StandAloneFailureMechanismView<MicrostabilityFailureMechanism, NonAdoptableWithProfileProbabilityFailureMechanismSectionResult>));
 
                 PluginTestHelper.AssertViewInfoDefined(
                     viewInfos,
                     typeof(GrassCoverSlipOffOutwardsFailurePathContext),
                     typeof(GrassCoverSlipOffOutwardsFailureMechanism),
-                    typeof(FailureMechanismWithDetailedAssessmentView<GrassCoverSlipOffOutwardsFailureMechanism, NonAdoptableWithProfileProbabilityFailureMechanismSectionResult>));
+                    typeof(StandAloneFailureMechanismView<GrassCoverSlipOffOutwardsFailureMechanism, NonAdoptableWithProfileProbabilityFailureMechanismSectionResult>));
 
                 PluginTestHelper.AssertViewInfoDefined(
                     viewInfos,
                     typeof(GrassCoverSlipOffInwardsFailurePathContext),
                     typeof(GrassCoverSlipOffInwardsFailureMechanism),
-                    typeof(FailureMechanismWithDetailedAssessmentView<GrassCoverSlipOffInwardsFailureMechanism, NonAdoptableWithProfileProbabilityFailureMechanismSectionResult>));
+                    typeof(StandAloneFailureMechanismView<GrassCoverSlipOffInwardsFailureMechanism, NonAdoptableWithProfileProbabilityFailureMechanismSectionResult>));
 
                 PluginTestHelper.AssertViewInfoDefined(
                     viewInfos,
                     typeof(PipingStructureFailurePathContext),
                     typeof(PipingStructureFailureMechanism),
-                    typeof(FailureMechanismWithDetailedAssessmentView<PipingStructureFailureMechanism, NonAdoptableFailureMechanismSectionResult>));
+                    typeof(StandAloneFailureMechanismView<PipingStructureFailureMechanism, NonAdoptableFailureMechanismSectionResult>));
 
                 PluginTestHelper.AssertViewInfoDefined(
                     viewInfos,
                     typeof(WaterPressureAsphaltCoverFailurePathContext),
                     typeof(WaterPressureAsphaltCoverFailureMechanism),
-                    typeof(FailureMechanismWithDetailedAssessmentView<WaterPressureAsphaltCoverFailureMechanism, NonAdoptableWithProfileProbabilityFailureMechanismSectionResult>));
+                    typeof(StandAloneFailureMechanismView<WaterPressureAsphaltCoverFailureMechanism, NonAdoptableWithProfileProbabilityFailureMechanismSectionResult>));
 
                 PluginTestHelper.AssertViewInfoDefined(
                     viewInfos,
Index: Riskeer/Integration/test/Riskeer.Integration.Plugin.Test/ViewInfos/GrassCoverSlipOffInwardsFailureMechanismViewInfoTest.cs
===================================================================
diff -u -r432b46a640176168e7bbb391c08f25fc76b877b7 -r826ed5d86e04dbf6e830afa9bcf14b2b2619b10f
--- Riskeer/Integration/test/Riskeer.Integration.Plugin.Test/ViewInfos/GrassCoverSlipOffInwardsFailureMechanismViewInfoTest.cs	(.../GrassCoverSlipOffInwardsFailureMechanismViewInfoTest.cs)	(revision 432b46a640176168e7bbb391c08f25fc76b877b7)
+++ Riskeer/Integration/test/Riskeer.Integration.Plugin.Test/ViewInfos/GrassCoverSlipOffInwardsFailureMechanismViewInfoTest.cs	(.../GrassCoverSlipOffInwardsFailureMechanismViewInfoTest.cs)	(revision 826ed5d86e04dbf6e830afa9bcf14b2b2619b10f)
@@ -47,7 +47,7 @@
             mocks = new MockRepository();
             plugin = new RiskeerPlugin();
             info = plugin.GetViewInfos().First(
-                tni => tni.ViewType == typeof(FailureMechanismWithDetailedAssessmentView<GrassCoverSlipOffInwardsFailureMechanism,
+                tni => tni.ViewType == typeof(StandAloneFailureMechanismView<GrassCoverSlipOffInwardsFailureMechanism,
                            NonAdoptableWithProfileProbabilityFailureMechanismSectionResult>));
         }
 
@@ -92,7 +92,7 @@
 
             var failureMechanism = new GrassCoverSlipOffInwardsFailureMechanism();
 
-            using (FailureMechanismWithDetailedAssessmentView<GrassCoverSlipOffInwardsFailureMechanism, NonAdoptableWithProfileProbabilityFailureMechanismSectionResult> view =
+            using (StandAloneFailureMechanismView<GrassCoverSlipOffInwardsFailureMechanism, NonAdoptableWithProfileProbabilityFailureMechanismSectionResult> view =
                    CreateView(failureMechanism, assessmentSection))
             {
                 // Call
@@ -112,7 +112,7 @@
             var assessmentSection = new AssessmentSectionStub();
             var failureMechanism = new GrassCoverSlipOffInwardsFailureMechanism();
 
-            using (FailureMechanismWithDetailedAssessmentView<GrassCoverSlipOffInwardsFailureMechanism, NonAdoptableWithProfileProbabilityFailureMechanismSectionResult> view =
+            using (StandAloneFailureMechanismView<GrassCoverSlipOffInwardsFailureMechanism, NonAdoptableWithProfileProbabilityFailureMechanismSectionResult> view =
                    CreateView(failureMechanism, assessmentSection))
             {
                 // Call
@@ -160,20 +160,20 @@
             IView view = info.CreateInstance(context);
 
             // Assert
-            Assert.IsInstanceOf<FailureMechanismWithDetailedAssessmentView<GrassCoverSlipOffInwardsFailureMechanism,
+            Assert.IsInstanceOf<StandAloneFailureMechanismView<GrassCoverSlipOffInwardsFailureMechanism,
                 NonAdoptableWithProfileProbabilityFailureMechanismSectionResult>>(view);
 
-            var failureMechanismView = (FailureMechanismWithDetailedAssessmentView<GrassCoverSlipOffInwardsFailureMechanism,
+            var failureMechanismView = (StandAloneFailureMechanismView<GrassCoverSlipOffInwardsFailureMechanism,
                 NonAdoptableWithProfileProbabilityFailureMechanismSectionResult>) view;
             Assert.AreSame(failureMechanism, failureMechanismView.FailureMechanism);
             Assert.AreSame(assessmentSection, failureMechanismView.AssessmentSection);
         }
 
-        private static FailureMechanismWithDetailedAssessmentView<GrassCoverSlipOffInwardsFailureMechanism, NonAdoptableWithProfileProbabilityFailureMechanismSectionResult> CreateView(
+        private static StandAloneFailureMechanismView<GrassCoverSlipOffInwardsFailureMechanism, NonAdoptableWithProfileProbabilityFailureMechanismSectionResult> CreateView(
             GrassCoverSlipOffInwardsFailureMechanism failureMechanism, IAssessmentSection assessmentSection)
         {
-            return new FailureMechanismWithDetailedAssessmentView<GrassCoverSlipOffInwardsFailureMechanism,
-                NonAdoptableWithProfileProbabilityFailureMechanismSectionResult>(failureMechanism, assessmentSection, sr => new DefaultFailureMechanismSectionAssemblyResult());
+            return new StandAloneFailureMechanismView<GrassCoverSlipOffInwardsFailureMechanism, NonAdoptableWithProfileProbabilityFailureMechanismSectionResult>(
+                failureMechanism, assessmentSection, sr => new DefaultFailureMechanismSectionAssemblyResult());
         }
     }
 }
\ No newline at end of file
Index: Riskeer/Integration/test/Riskeer.Integration.Plugin.Test/ViewInfos/GrassCoverSlipOffOutwardsFailureMechanismViewInfoTest.cs
===================================================================
diff -u -r432b46a640176168e7bbb391c08f25fc76b877b7 -r826ed5d86e04dbf6e830afa9bcf14b2b2619b10f
--- Riskeer/Integration/test/Riskeer.Integration.Plugin.Test/ViewInfos/GrassCoverSlipOffOutwardsFailureMechanismViewInfoTest.cs	(.../GrassCoverSlipOffOutwardsFailureMechanismViewInfoTest.cs)	(revision 432b46a640176168e7bbb391c08f25fc76b877b7)
+++ Riskeer/Integration/test/Riskeer.Integration.Plugin.Test/ViewInfos/GrassCoverSlipOffOutwardsFailureMechanismViewInfoTest.cs	(.../GrassCoverSlipOffOutwardsFailureMechanismViewInfoTest.cs)	(revision 826ed5d86e04dbf6e830afa9bcf14b2b2619b10f)
@@ -47,7 +47,7 @@
             mocks = new MockRepository();
             plugin = new RiskeerPlugin();
             info = plugin.GetViewInfos().First(
-                tni => tni.ViewType == typeof(FailureMechanismWithDetailedAssessmentView<GrassCoverSlipOffOutwardsFailureMechanism,
+                tni => tni.ViewType == typeof(StandAloneFailureMechanismView<GrassCoverSlipOffOutwardsFailureMechanism,
                            NonAdoptableWithProfileProbabilityFailureMechanismSectionResult>));
         }
 
@@ -92,7 +92,7 @@
 
             var failureMechanism = new GrassCoverSlipOffOutwardsFailureMechanism();
 
-            using (FailureMechanismWithDetailedAssessmentView<GrassCoverSlipOffOutwardsFailureMechanism, NonAdoptableWithProfileProbabilityFailureMechanismSectionResult> view =
+            using (StandAloneFailureMechanismView<GrassCoverSlipOffOutwardsFailureMechanism, NonAdoptableWithProfileProbabilityFailureMechanismSectionResult> view =
                    CreateView(failureMechanism, assessmentSection))
             {
                 // Call
@@ -112,7 +112,7 @@
             var assessmentSection = new AssessmentSectionStub();
             var failureMechanism = new GrassCoverSlipOffOutwardsFailureMechanism();
 
-            using (FailureMechanismWithDetailedAssessmentView<GrassCoverSlipOffOutwardsFailureMechanism, NonAdoptableWithProfileProbabilityFailureMechanismSectionResult> view =
+            using (StandAloneFailureMechanismView<GrassCoverSlipOffOutwardsFailureMechanism, NonAdoptableWithProfileProbabilityFailureMechanismSectionResult> view =
                    CreateView(failureMechanism, assessmentSection))
             {
                 // Call
@@ -160,20 +160,19 @@
             IView view = info.CreateInstance(context);
 
             // Assert
-            Assert.IsInstanceOf<FailureMechanismWithDetailedAssessmentView<GrassCoverSlipOffOutwardsFailureMechanism,
+            Assert.IsInstanceOf<StandAloneFailureMechanismView<GrassCoverSlipOffOutwardsFailureMechanism,
                 NonAdoptableWithProfileProbabilityFailureMechanismSectionResult>>(view);
 
-            var failureMechanismView = (FailureMechanismWithDetailedAssessmentView<GrassCoverSlipOffOutwardsFailureMechanism,
+            var failureMechanismView = (StandAloneFailureMechanismView<GrassCoverSlipOffOutwardsFailureMechanism,
                 NonAdoptableWithProfileProbabilityFailureMechanismSectionResult>) view;
             Assert.AreSame(failureMechanism, failureMechanismView.FailureMechanism);
             Assert.AreSame(assessmentSection, failureMechanismView.AssessmentSection);
         }
 
-        private static FailureMechanismWithDetailedAssessmentView<GrassCoverSlipOffOutwardsFailureMechanism, NonAdoptableWithProfileProbabilityFailureMechanismSectionResult> CreateView(
+        private static StandAloneFailureMechanismView<GrassCoverSlipOffOutwardsFailureMechanism, NonAdoptableWithProfileProbabilityFailureMechanismSectionResult> CreateView(
             GrassCoverSlipOffOutwardsFailureMechanism failureMechanism, IAssessmentSection assessmentSection)
         {
-            return new FailureMechanismWithDetailedAssessmentView<GrassCoverSlipOffOutwardsFailureMechanism,
-                NonAdoptableWithProfileProbabilityFailureMechanismSectionResult>(
+            return new StandAloneFailureMechanismView<GrassCoverSlipOffOutwardsFailureMechanism, NonAdoptableWithProfileProbabilityFailureMechanismSectionResult>(
                 failureMechanism, assessmentSection, sr => new DefaultFailureMechanismSectionAssemblyResult());
         }
     }
Index: Riskeer/Integration/test/Riskeer.Integration.Plugin.Test/ViewInfos/MicrostabilityFailureMechanismViewInfoTest.cs
===================================================================
diff -u -r432b46a640176168e7bbb391c08f25fc76b877b7 -r826ed5d86e04dbf6e830afa9bcf14b2b2619b10f
--- Riskeer/Integration/test/Riskeer.Integration.Plugin.Test/ViewInfos/MicrostabilityFailureMechanismViewInfoTest.cs	(.../MicrostabilityFailureMechanismViewInfoTest.cs)	(revision 432b46a640176168e7bbb391c08f25fc76b877b7)
+++ Riskeer/Integration/test/Riskeer.Integration.Plugin.Test/ViewInfos/MicrostabilityFailureMechanismViewInfoTest.cs	(.../MicrostabilityFailureMechanismViewInfoTest.cs)	(revision 826ed5d86e04dbf6e830afa9bcf14b2b2619b10f)
@@ -47,7 +47,7 @@
             mocks = new MockRepository();
             plugin = new RiskeerPlugin();
             info = plugin.GetViewInfos().First(
-                tni => tni.ViewType == typeof(FailureMechanismWithDetailedAssessmentView<MicrostabilityFailureMechanism,
+                tni => tni.ViewType == typeof(StandAloneFailureMechanismView<MicrostabilityFailureMechanism,
                            NonAdoptableWithProfileProbabilityFailureMechanismSectionResult>));
         }
 
@@ -92,7 +92,7 @@
 
             var failureMechanism = new MicrostabilityFailureMechanism();
 
-            using (FailureMechanismWithDetailedAssessmentView<MicrostabilityFailureMechanism, NonAdoptableWithProfileProbabilityFailureMechanismSectionResult> view =
+            using (StandAloneFailureMechanismView<MicrostabilityFailureMechanism, NonAdoptableWithProfileProbabilityFailureMechanismSectionResult> view =
                    CreateView(failureMechanism, assessmentSection))
             {
                 // Call
@@ -112,7 +112,7 @@
             var assessmentSection = new AssessmentSectionStub();
             var failureMechanism = new MicrostabilityFailureMechanism();
 
-            using (FailureMechanismWithDetailedAssessmentView<MicrostabilityFailureMechanism, NonAdoptableWithProfileProbabilityFailureMechanismSectionResult> view =
+            using (StandAloneFailureMechanismView<MicrostabilityFailureMechanism, NonAdoptableWithProfileProbabilityFailureMechanismSectionResult> view =
                    CreateView(failureMechanism, assessmentSection))
             {
                 // Call
@@ -160,20 +160,19 @@
             IView view = info.CreateInstance(context);
 
             // Assert
-            Assert.IsInstanceOf<FailureMechanismWithDetailedAssessmentView<MicrostabilityFailureMechanism,
+            Assert.IsInstanceOf<StandAloneFailureMechanismView<MicrostabilityFailureMechanism,
                 NonAdoptableWithProfileProbabilityFailureMechanismSectionResult>>(view);
 
-            var failureMechanismView = (FailureMechanismWithDetailedAssessmentView<MicrostabilityFailureMechanism,
+            var failureMechanismView = (StandAloneFailureMechanismView<MicrostabilityFailureMechanism,
                 NonAdoptableWithProfileProbabilityFailureMechanismSectionResult>) view;
             Assert.AreSame(failureMechanism, failureMechanismView.FailureMechanism);
             Assert.AreSame(assessmentSection, failureMechanismView.AssessmentSection);
         }
 
-        private static FailureMechanismWithDetailedAssessmentView<MicrostabilityFailureMechanism, NonAdoptableWithProfileProbabilityFailureMechanismSectionResult> CreateView(
+        private static StandAloneFailureMechanismView<MicrostabilityFailureMechanism, NonAdoptableWithProfileProbabilityFailureMechanismSectionResult> CreateView(
             MicrostabilityFailureMechanism failureMechanism, IAssessmentSection assessmentSection)
         {
-            return new FailureMechanismWithDetailedAssessmentView<MicrostabilityFailureMechanism,
-                NonAdoptableWithProfileProbabilityFailureMechanismSectionResult>(
+            return new StandAloneFailureMechanismView<MicrostabilityFailureMechanism, NonAdoptableWithProfileProbabilityFailureMechanismSectionResult>(
                 failureMechanism, assessmentSection, sr => new DefaultFailureMechanismSectionAssemblyResult());
         }
     }
Index: Riskeer/Integration/test/Riskeer.Integration.Plugin.Test/ViewInfos/PipingStructureFailureMechanismViewInfoTest.cs
===================================================================
diff -u -r432b46a640176168e7bbb391c08f25fc76b877b7 -r826ed5d86e04dbf6e830afa9bcf14b2b2619b10f
--- Riskeer/Integration/test/Riskeer.Integration.Plugin.Test/ViewInfos/PipingStructureFailureMechanismViewInfoTest.cs	(.../PipingStructureFailureMechanismViewInfoTest.cs)	(revision 432b46a640176168e7bbb391c08f25fc76b877b7)
+++ Riskeer/Integration/test/Riskeer.Integration.Plugin.Test/ViewInfos/PipingStructureFailureMechanismViewInfoTest.cs	(.../PipingStructureFailureMechanismViewInfoTest.cs)	(revision 826ed5d86e04dbf6e830afa9bcf14b2b2619b10f)
@@ -47,7 +47,7 @@
             mocks = new MockRepository();
             plugin = new RiskeerPlugin();
             info = plugin.GetViewInfos().First(
-                tni => tni.ViewType == typeof(FailureMechanismWithDetailedAssessmentView<PipingStructureFailureMechanism,
+                tni => tni.ViewType == typeof(StandAloneFailureMechanismView<PipingStructureFailureMechanism,
                            NonAdoptableFailureMechanismSectionResult>));
         }
 
@@ -92,7 +92,7 @@
 
             var failureMechanism = new PipingStructureFailureMechanism();
 
-            using (FailureMechanismWithDetailedAssessmentView<PipingStructureFailureMechanism, NonAdoptableFailureMechanismSectionResult> view =
+            using (StandAloneFailureMechanismView<PipingStructureFailureMechanism, NonAdoptableFailureMechanismSectionResult> view =
                    CreateView(failureMechanism, assessmentSection))
             {
                 // Call
@@ -112,7 +112,7 @@
             var assessmentSection = new AssessmentSectionStub();
             var failureMechanism = new PipingStructureFailureMechanism();
 
-            using (FailureMechanismWithDetailedAssessmentView<PipingStructureFailureMechanism, NonAdoptableFailureMechanismSectionResult> view =
+            using (StandAloneFailureMechanismView<PipingStructureFailureMechanism, NonAdoptableFailureMechanismSectionResult> view =
                    CreateView(failureMechanism, assessmentSection))
             {
                 // Call
@@ -160,20 +160,20 @@
             IView view = info.CreateInstance(context);
 
             // Assert
-            Assert.IsInstanceOf<FailureMechanismWithDetailedAssessmentView<PipingStructureFailureMechanism,
+            Assert.IsInstanceOf<StandAloneFailureMechanismView<PipingStructureFailureMechanism,
                 NonAdoptableFailureMechanismSectionResult>>(view);
 
-            var failureMechanismView = (FailureMechanismWithDetailedAssessmentView<PipingStructureFailureMechanism,
+            var failureMechanismView = (StandAloneFailureMechanismView<PipingStructureFailureMechanism,
                 NonAdoptableFailureMechanismSectionResult>) view;
             Assert.AreSame(failureMechanism, failureMechanismView.FailureMechanism);
             Assert.AreSame(assessmentSection, failureMechanismView.AssessmentSection);
         }
 
-        private static FailureMechanismWithDetailedAssessmentView<PipingStructureFailureMechanism, NonAdoptableFailureMechanismSectionResult> CreateView(
+        private static StandAloneFailureMechanismView<PipingStructureFailureMechanism, NonAdoptableFailureMechanismSectionResult> CreateView(
             PipingStructureFailureMechanism failureMechanism, IAssessmentSection assessmentSection)
         {
-            return new FailureMechanismWithDetailedAssessmentView<PipingStructureFailureMechanism,
-                NonAdoptableFailureMechanismSectionResult>(failureMechanism, assessmentSection, sr => new DefaultFailureMechanismSectionAssemblyResult());
+            return new StandAloneFailureMechanismView<PipingStructureFailureMechanism, NonAdoptableFailureMechanismSectionResult>(
+                failureMechanism, assessmentSection, sr => new DefaultFailureMechanismSectionAssemblyResult());
         }
     }
 }
\ No newline at end of file
Index: Riskeer/Integration/test/Riskeer.Integration.Plugin.Test/ViewInfos/WaterPressureAsphaltCoverFailureMechanismViewInfoTest.cs
===================================================================
diff -u -r432b46a640176168e7bbb391c08f25fc76b877b7 -r826ed5d86e04dbf6e830afa9bcf14b2b2619b10f
--- Riskeer/Integration/test/Riskeer.Integration.Plugin.Test/ViewInfos/WaterPressureAsphaltCoverFailureMechanismViewInfoTest.cs	(.../WaterPressureAsphaltCoverFailureMechanismViewInfoTest.cs)	(revision 432b46a640176168e7bbb391c08f25fc76b877b7)
+++ Riskeer/Integration/test/Riskeer.Integration.Plugin.Test/ViewInfos/WaterPressureAsphaltCoverFailureMechanismViewInfoTest.cs	(.../WaterPressureAsphaltCoverFailureMechanismViewInfoTest.cs)	(revision 826ed5d86e04dbf6e830afa9bcf14b2b2619b10f)
@@ -47,7 +47,7 @@
             mocks = new MockRepository();
             plugin = new RiskeerPlugin();
             info = plugin.GetViewInfos().First(
-                tni => tni.ViewType == typeof(FailureMechanismWithDetailedAssessmentView<WaterPressureAsphaltCoverFailureMechanism,
+                tni => tni.ViewType == typeof(StandAloneFailureMechanismView<WaterPressureAsphaltCoverFailureMechanism,
                            NonAdoptableWithProfileProbabilityFailureMechanismSectionResult>));
         }
 
@@ -92,7 +92,7 @@
 
             var failureMechanism = new WaterPressureAsphaltCoverFailureMechanism();
 
-            using (FailureMechanismWithDetailedAssessmentView<WaterPressureAsphaltCoverFailureMechanism, NonAdoptableWithProfileProbabilityFailureMechanismSectionResult> view =
+            using (StandAloneFailureMechanismView<WaterPressureAsphaltCoverFailureMechanism, NonAdoptableWithProfileProbabilityFailureMechanismSectionResult> view =
                    CreateView(failureMechanism, assessmentSection))
             {
                 // Call
@@ -112,7 +112,7 @@
             var assessmentSection = new AssessmentSectionStub();
             var failureMechanism = new WaterPressureAsphaltCoverFailureMechanism();
 
-            using (FailureMechanismWithDetailedAssessmentView<WaterPressureAsphaltCoverFailureMechanism, NonAdoptableWithProfileProbabilityFailureMechanismSectionResult> view =
+            using (StandAloneFailureMechanismView<WaterPressureAsphaltCoverFailureMechanism, NonAdoptableWithProfileProbabilityFailureMechanismSectionResult> view =
                    CreateView(failureMechanism, assessmentSection))
             {
                 // Call
@@ -160,20 +160,19 @@
             IView view = info.CreateInstance(context);
 
             // Assert
-            Assert.IsInstanceOf<FailureMechanismWithDetailedAssessmentView<WaterPressureAsphaltCoverFailureMechanism,
+            Assert.IsInstanceOf<StandAloneFailureMechanismView<WaterPressureAsphaltCoverFailureMechanism,
                 NonAdoptableWithProfileProbabilityFailureMechanismSectionResult>>(view);
 
-            var failureMechanismView = (FailureMechanismWithDetailedAssessmentView<WaterPressureAsphaltCoverFailureMechanism,
+            var failureMechanismView = (StandAloneFailureMechanismView<WaterPressureAsphaltCoverFailureMechanism,
                 NonAdoptableWithProfileProbabilityFailureMechanismSectionResult>) view;
             Assert.AreSame(failureMechanism, failureMechanismView.FailureMechanism);
             Assert.AreSame(assessmentSection, failureMechanismView.AssessmentSection);
         }
 
-        private static FailureMechanismWithDetailedAssessmentView<WaterPressureAsphaltCoverFailureMechanism, NonAdoptableWithProfileProbabilityFailureMechanismSectionResult> CreateView(
+        private static StandAloneFailureMechanismView<WaterPressureAsphaltCoverFailureMechanism, NonAdoptableWithProfileProbabilityFailureMechanismSectionResult> CreateView(
             WaterPressureAsphaltCoverFailureMechanism failureMechanism, IAssessmentSection assessmentSection)
         {
-            return new FailureMechanismWithDetailedAssessmentView<WaterPressureAsphaltCoverFailureMechanism,
-                NonAdoptableWithProfileProbabilityFailureMechanismSectionResult>(
+            return new StandAloneFailureMechanismView<WaterPressureAsphaltCoverFailureMechanism, NonAdoptableWithProfileProbabilityFailureMechanismSectionResult>(
                 failureMechanism, assessmentSection, sr => new DefaultFailureMechanismSectionAssemblyResult());
         }
     }