Index: Riskeer/Storage/src/Riskeer.Storage.Core/Read/AssessmentSectionEntityReadExtensions.cs
===================================================================
diff -u -r366957369348a28ea2c32c26678d57389560e69d -r48499e35b845fc712d21f7200ba8de3e3f8029b7
--- Riskeer/Storage/src/Riskeer.Storage.Core/Read/AssessmentSectionEntityReadExtensions.cs (.../AssessmentSectionEntityReadExtensions.cs) (revision 366957369348a28ea2c32c26678d57389560e69d)
+++ Riskeer/Storage/src/Riskeer.Storage.Core/Read/AssessmentSectionEntityReadExtensions.cs (.../AssessmentSectionEntityReadExtensions.cs) (revision 48499e35b845fc712d21f7200ba8de3e3f8029b7)
@@ -28,7 +28,6 @@
using Riskeer.Common.Data.Hydraulics;
using Riskeer.Integration.Data;
using Riskeer.Storage.Core.DbContext;
-using Riskeer.Storage.Core.Read.SpecificFailurePaths;
using Riskeer.Storage.Core.Serializers;
namespace Riskeer.Storage.Core.Read
@@ -287,7 +286,7 @@
entity.SpecificFailurePathEntities
.OrderBy(e => e.Order);
- assessmentSection.SpecificFailurePaths.AddRange(specificFailurePathEntities.Select(e => e.Read(collector)).ToArray());
+ assessmentSection.SpecificFailurePaths.AddRange(specificFailurePathEntities.Select(e => e.ReadSpecificFailurePath(collector)).ToArray());
}
}
}
\ No newline at end of file
Index: Riskeer/Storage/src/Riskeer.Storage.Core/Read/FailureMechanismEntityReadExtensions.cs
===================================================================
diff -u -rcd9917aa7aad303a58eae5ca1fac7e4ac7e54ded -r48499e35b845fc712d21f7200ba8de3e3f8029b7
--- Riskeer/Storage/src/Riskeer.Storage.Core/Read/FailureMechanismEntityReadExtensions.cs (.../FailureMechanismEntityReadExtensions.cs) (revision cd9917aa7aad303a58eae5ca1fac7e4ac7e54ded)
+++ Riskeer/Storage/src/Riskeer.Storage.Core/Read/FailureMechanismEntityReadExtensions.cs (.../FailureMechanismEntityReadExtensions.cs) (revision 48499e35b845fc712d21f7200ba8de3e3f8029b7)
@@ -60,40 +60,6 @@
///
internal static class FailureMechanismEntityReadExtensions
{
- ///
- /// Read the and use the information to update a .
- ///
- /// The to read into a .
- /// The target of the read operation.
- /// The object keeping track of read operations.
- internal static void ReadCommonFailureMechanismProperties(this FailureMechanismEntity entity,
- IFailureMechanism failureMechanism,
- ReadConversionCollector collector)
- {
- failureMechanism.InAssembly = Convert.ToBoolean(entity.InAssembly);
- failureMechanism.InAssemblyInputComments.Body = entity.InAssemblyInputComments;
- failureMechanism.InAssemblyOutputComments.Body = entity.InAssemblyOutputComments;
- failureMechanism.CalculationsInputComments.Body = entity.CalculationsInputComments;
- failureMechanism.NotInAssemblyComments.Body = entity.NotInAssemblyComments;
-
- entity.ReadFailureMechanismSections(failureMechanism, collector);
- entity.Read(failureMechanism.AssemblyResult);
- }
-
- private static void ReadFailureMechanismSections(this FailureMechanismEntity entity,
- IFailureMechanism failureMechanism,
- ReadConversionCollector collector)
- {
- FailureMechanismSection[] readFailureMechanismSections = entity.FailureMechanismSectionEntities
- .Select(failureMechanismSectionEntity =>
- failureMechanismSectionEntity.Read(collector))
- .ToArray();
- if (readFailureMechanismSections.Any())
- {
- failureMechanism.SetSections(readFailureMechanismSections, entity.FailureMechanismSectionCollectionSourcePath);
- }
- }
-
private static void ReadForeshoreProfiles(this FailureMechanismEntity entity,
ForeshoreProfileCollection foreshoreProfiles,
string foreshoreProfileSourcePath,
Fisheye: Tag 48499e35b845fc712d21f7200ba8de3e3f8029b7 refers to a dead (removed) revision in file `Riskeer/Storage/src/Riskeer.Storage.Core/Read/FailurePathAssemblyResultEntityReadExtensions.cs'.
Fisheye: No comparison available. Pass `N' to diff?
Index: Riskeer/Storage/src/Riskeer.Storage.Core/Read/FailurePathEntityReadExtensions.cs
===================================================================
diff -u
--- Riskeer/Storage/src/Riskeer.Storage.Core/Read/FailurePathEntityReadExtensions.cs (revision 0)
+++ Riskeer/Storage/src/Riskeer.Storage.Core/Read/FailurePathEntityReadExtensions.cs (revision 48499e35b845fc712d21f7200ba8de3e3f8029b7)
@@ -0,0 +1,135 @@
+// 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 .
+//
+// 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.Linq;
+using Core.Common.Base.Data;
+using Riskeer.Common.Data.FailureMechanism;
+using Riskeer.Common.Data.FailurePath;
+using Riskeer.Integration.Data.FailurePath;
+using Riskeer.Storage.Core.DbContext;
+
+namespace Riskeer.Storage.Core.Read
+{
+ ///
+ /// This class defines extension methods for read operations for an implementation based on the
+ ///
+ ///
+ internal static class FailurePathEntityReadExtensions
+ {
+ ///
+ /// Read the and use the information to update a .
+ ///
+ /// The to read into a .
+ /// The target of the read operation.
+ /// The object keeping track of read operations.
+ /// Thrown when any parameter is null.
+ internal static void ReadCommonFailureMechanismProperties(this FailureMechanismEntity entity,
+ IFailureMechanism failureMechanism,
+ ReadConversionCollector collector)
+ {
+ if (entity == null)
+ {
+ throw new ArgumentNullException(nameof(entity));
+ }
+
+ if (failureMechanism == null)
+ {
+ throw new ArgumentNullException(nameof(failureMechanism));
+ }
+
+ if (collector == null)
+ {
+ throw new ArgumentNullException(nameof(collector));
+ }
+
+ entity.ReadCommonFailurePathProperties(failureMechanism, collector);
+ failureMechanism.CalculationsInputComments.Body = entity.CalculationsInputComments;
+ }
+
+ ///
+ /// Reads the and uses the information to create a .
+ ///
+ /// The to create a with.
+ /// The object keeping track of read operations.
+ /// Thrown when any argument is null.
+ internal static SpecificFailurePath ReadSpecificFailurePath(this SpecificFailurePathEntity entity,
+ ReadConversionCollector collector)
+ {
+ if (entity == null)
+ {
+ throw new ArgumentNullException(nameof(entity));
+ }
+
+ if (collector == null)
+ {
+ throw new ArgumentNullException(nameof(collector));
+ }
+
+ var specificFailurePath = new SpecificFailurePath
+ {
+ Name = entity.Name,
+ Input =
+ {
+ N = (RoundedDouble) entity.N
+ }
+ };
+ entity.ReadCommonFailurePathProperties(specificFailurePath, collector);
+ return specificFailurePath;
+ }
+
+ private static void ReadCommonFailurePathProperties(this T entity, IFailurePath failurePath, ReadConversionCollector collector)
+ where T : IFailurePathEntity
+ {
+ failurePath.InAssembly = Convert.ToBoolean(entity.InAssembly);
+ failurePath.InAssemblyInputComments.Body = entity.InAssemblyInputComments;
+ failurePath.InAssemblyOutputComments.Body = entity.InAssemblyOutputComments;
+ failurePath.NotInAssemblyComments.Body = entity.NotInAssemblyComments;
+
+ entity.ReadFailureMechanismSections(failurePath, collector);
+ ReadAssemblyResult(entity, failurePath);
+ }
+
+ private static void ReadAssemblyResult(IFailurePathEntity entity, IFailurePath failurePath)
+ {
+ FailurePathAssemblyResult assemblyResult = failurePath.AssemblyResult;
+ assemblyResult.ProbabilityResultType = (FailurePathAssemblyProbabilityResultType) entity.FailurePathAssemblyProbabilityResultType;
+ if (entity.ManualFailurePathAssemblyProbability != null)
+ {
+ assemblyResult.ManualFailurePathAssemblyProbability = entity.ManualFailurePathAssemblyProbability.ToNullAsNaN();
+ }
+ }
+
+ private static void ReadFailureMechanismSections(this IFailurePathEntity entity,
+ IFailurePath specificFailurePath,
+ ReadConversionCollector collector)
+ {
+ FailureMechanismSection[] readFailureMechanismSections = entity.FailureMechanismSectionEntities
+ .Select(failureMechanismSectionEntity =>
+ failureMechanismSectionEntity.Read(collector))
+ .ToArray();
+ if (readFailureMechanismSections.Any())
+ {
+ specificFailurePath.SetSections(readFailureMechanismSections, entity.FailureMechanismSectionCollectionSourcePath);
+ }
+ }
+ }
+}
\ No newline at end of file
Fisheye: Tag 48499e35b845fc712d21f7200ba8de3e3f8029b7 refers to a dead (removed) revision in file `Riskeer/Storage/src/Riskeer.Storage.Core/Read/SpecificFailurePaths/SpecificFailurePathEntityReadExtensions.cs'.
Fisheye: No comparison available. Pass `N' to diff?
Index: Riskeer/Storage/test/Riskeer.Storage.Core.Test/Read/FailureMechanismEntityReadExtensionsTest.cs
===================================================================
diff -u -rcd9917aa7aad303a58eae5ca1fac7e4ac7e54ded -r48499e35b845fc712d21f7200ba8de3e3f8029b7
--- Riskeer/Storage/test/Riskeer.Storage.Core.Test/Read/FailureMechanismEntityReadExtensionsTest.cs (.../FailureMechanismEntityReadExtensionsTest.cs) (revision cd9917aa7aad303a58eae5ca1fac7e4ac7e54ded)
+++ Riskeer/Storage/test/Riskeer.Storage.Core.Test/Read/FailureMechanismEntityReadExtensionsTest.cs (.../FailureMechanismEntityReadExtensionsTest.cs) (revision 48499e35b845fc712d21f7200ba8de3e3f8029b7)
@@ -31,7 +31,6 @@
using Riskeer.Common.Data;
using Riskeer.Common.Data.Calculation;
using Riskeer.Common.Data.DikeProfiles;
-using Riskeer.Common.Data.FailurePath;
using Riskeer.Common.Data.Structures;
using Riskeer.Common.Data.TestUtil;
using Riskeer.DuneErosion.Data;
@@ -58,92 +57,6 @@
[TestFixture]
public class FailureMechanismEntityReadExtensionsTest
{
- [Test]
- [TestCase(true)]
- [TestCase(false)]
- public void ReadCommonFailureMechanismProperties_WithoutSectionsSet_ReturnsNewStandAloneFailureMechanism(bool inAssembly)
- {
- // Setup
- var random = new Random(21);
- var assemblyResultType = random.NextEnumValue();
-
- var entity = new FailureMechanismEntity
- {
- InAssembly = Convert.ToByte(inAssembly),
- InAssemblyInputComments = "Some input text",
- InAssemblyOutputComments = "Some output text",
- CalculationsInputComments = "Some calculation text",
- NotInAssemblyComments = "Really not in assembly",
- FailurePathAssemblyProbabilityResultType = Convert.ToByte(assemblyResultType),
- ManualFailurePathAssemblyProbability = random.NextDouble()
- };
- var collector = new ReadConversionCollector();
- var failureMechanism = new TestFailureMechanism();
-
- // Call
- entity.ReadCommonFailureMechanismProperties(failureMechanism, collector);
-
- // Assert
- CollectionAssert.IsEmpty(failureMechanism.Sections);
- Assert.AreEqual(inAssembly, failureMechanism.InAssembly);
- Assert.AreEqual(entity.InAssemblyInputComments, failureMechanism.InAssemblyInputComments.Body);
- Assert.AreEqual(entity.InAssemblyOutputComments, failureMechanism.InAssemblyOutputComments.Body);
- Assert.AreEqual(entity.NotInAssemblyComments, failureMechanism.NotInAssemblyComments.Body);
- Assert.AreEqual(entity.CalculationsInputComments, failureMechanism.CalculationsInputComments.Body);
- CollectionAssert.IsEmpty(failureMechanism.Sections);
- Assert.IsNull(failureMechanism.FailureMechanismSectionSourcePath);
-
- FailurePathAssemblyResult assemblyResult = failureMechanism.AssemblyResult;
- Assert.AreEqual(assemblyResultType, assemblyResult.ProbabilityResultType);
- Assert.AreEqual(entity.ManualFailurePathAssemblyProbability, assemblyResult.ManualFailurePathAssemblyProbability);
- }
-
- [Test]
- public void ReadCommonFailureMechanismProperties_WithNullValues_ReturnsNewStandAloneFailureMechanism()
- {
- // Setup
- var entity = new FailureMechanismEntity();
- var collector = new ReadConversionCollector();
- var failureMechanism = new TestFailureMechanism();
-
- // Call
- entity.ReadCommonFailureMechanismProperties(failureMechanism, collector);
-
- // Assert
- Assert.IsNull(failureMechanism.InAssemblyInputComments.Body);
- Assert.IsNull(failureMechanism.InAssemblyOutputComments.Body);
- Assert.IsNull(failureMechanism.NotInAssemblyComments.Body);
- Assert.IsNull(failureMechanism.CalculationsInputComments.Body);
- CollectionAssert.IsEmpty(failureMechanism.Sections);
- Assert.IsNull(failureMechanism.FailureMechanismSectionSourcePath);
-
- Assert.IsNaN(failureMechanism.AssemblyResult.ManualFailurePathAssemblyProbability);
- }
-
- [Test]
- public void ReadCommonFailureMechanismProperties_WithSectionsSet_ReturnsNewStandAloneFailureMechanismWithFailureMechanismSections()
- {
- // Setup
- const string filePath = "failureMechanismSections/File/Path";
- var entity = new FailureMechanismEntity
- {
- FailureMechanismSectionCollectionSourcePath = filePath,
- FailureMechanismSectionEntities =
- {
- CreateSimpleFailureMechanismSectionEntity()
- }
- };
- var collector = new ReadConversionCollector();
- var failureMechanism = new TestFailureMechanism();
-
- // Call
- entity.ReadCommonFailureMechanismProperties(failureMechanism, collector);
-
- // Assert
- Assert.AreEqual(entity.FailureMechanismSectionEntities.Count, failureMechanism.Sections.Count());
- Assert.AreEqual(filePath, failureMechanism.FailureMechanismSectionSourcePath);
- }
-
#region Microstability
[Test]
Fisheye: Tag 48499e35b845fc712d21f7200ba8de3e3f8029b7 refers to a dead (removed) revision in file `Riskeer/Storage/test/Riskeer.Storage.Core.Test/Read/FailurePathAssemblyResultEntityReadExtensionsTest.cs'.
Fisheye: No comparison available. Pass `N' to diff?
Index: Riskeer/Storage/test/Riskeer.Storage.Core.Test/Read/FailurePathEntityReadExtensionsTest.cs
===================================================================
diff -u
--- Riskeer/Storage/test/Riskeer.Storage.Core.Test/Read/FailurePathEntityReadExtensionsTest.cs (revision 0)
+++ Riskeer/Storage/test/Riskeer.Storage.Core.Test/Read/FailurePathEntityReadExtensionsTest.cs (revision 48499e35b845fc712d21f7200ba8de3e3f8029b7)
@@ -0,0 +1,302 @@
+// 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 .
+//
+// 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.Linq;
+using Core.Common.Base.Geometry;
+using Core.Common.TestUtil;
+using NUnit.Framework;
+using Rhino.Mocks;
+using Riskeer.Common.Data.FailureMechanism;
+using Riskeer.Common.Data.FailurePath;
+using Riskeer.Common.Data.TestUtil;
+using Riskeer.Integration.Data.FailurePath;
+using Riskeer.Storage.Core.DbContext;
+using Riskeer.Storage.Core.Read;
+using Riskeer.Storage.Core.Serializers;
+
+namespace Riskeer.Storage.Core.Test.Read
+{
+ [TestFixture]
+ public class FailurePathEntityReadExtensionsTest
+ {
+ [Test]
+ public void ReadCommonFailureMechanismProperties_EntityNull_ThrowsArgumentNullException()
+ {
+ // Setup
+ var mocks = new MockRepository();
+ var failureMechanism = mocks.Stub();
+ mocks.ReplayAll();
+
+ // Call
+ void Call() => ((FailureMechanismEntity) null).ReadCommonFailureMechanismProperties(failureMechanism, new ReadConversionCollector());
+
+ // Assert
+ var exception = Assert.Throws(Call);
+ Assert.AreEqual("entity", exception.ParamName);
+ mocks.VerifyAll();
+ }
+
+ [Test]
+ public void ReadCommonFailureMechanismProperties_FailureMechanismNull_ThrowsArgumentNullException()
+ {
+ // Setup
+ var entity = new FailureMechanismEntity();
+
+ // Call
+ void Call() => entity.ReadCommonFailureMechanismProperties(null, new ReadConversionCollector());
+
+ // Assert
+ var exception = Assert.Throws(Call);
+ Assert.AreEqual("failureMechanism", exception.ParamName);
+ }
+
+ [Test]
+ public void ReadCommonFailureMechanismProperties_CollectorNull_ThrowsArgumentNullException()
+ {
+ // Setup
+ var mocks = new MockRepository();
+ var failureMechanism = mocks.Stub();
+ mocks.ReplayAll();
+
+ var entity = new FailureMechanismEntity();
+
+ // Call
+ void Call() => entity.ReadCommonFailureMechanismProperties(failureMechanism, null);
+
+ // Assert
+ var exception = Assert.Throws(Call);
+ Assert.AreEqual("collector", exception.ParamName);
+ mocks.VerifyAll();
+ }
+
+ [Test]
+ [TestCase(true)]
+ [TestCase(false)]
+ public void ReadCommonFailureMechanismProperties_WithoutSectionsSet_ReturnsNewStandAloneFailureMechanism(bool inAssembly)
+ {
+ // Setup
+ var random = new Random(21);
+ var assemblyResultType = random.NextEnumValue();
+
+ var entity = new FailureMechanismEntity
+ {
+ InAssembly = Convert.ToByte(inAssembly),
+ InAssemblyInputComments = "Some input text",
+ InAssemblyOutputComments = "Some output text",
+ CalculationsInputComments = "Some calculation text",
+ NotInAssemblyComments = "Really not in assembly",
+ FailurePathAssemblyProbabilityResultType = Convert.ToByte(assemblyResultType),
+ ManualFailurePathAssemblyProbability = random.NextDouble()
+ };
+ var collector = new ReadConversionCollector();
+ var failureMechanism = new TestFailureMechanism();
+
+ // Call
+ entity.ReadCommonFailureMechanismProperties(failureMechanism, collector);
+
+ // Assert
+ AssertCommonFailurePathProperties(entity, failureMechanism);
+ Assert.AreEqual(entity.CalculationsInputComments, failureMechanism.CalculationsInputComments.Body);
+ CollectionAssert.IsEmpty(failureMechanism.Sections);
+ Assert.IsNull(failureMechanism.FailureMechanismSectionSourcePath);
+ }
+
+ [Test]
+ public void ReadCommonFailureMechanismProperties_WithNullValues_ReturnsNewStandAloneFailureMechanism()
+ {
+ // Setup
+ var entity = new FailureMechanismEntity();
+ var collector = new ReadConversionCollector();
+ var failureMechanism = new TestFailureMechanism();
+
+ // Call
+ entity.ReadCommonFailureMechanismProperties(failureMechanism, collector);
+
+ // Assert
+ Assert.IsNull(failureMechanism.InAssemblyInputComments.Body);
+ Assert.IsNull(failureMechanism.InAssemblyOutputComments.Body);
+ Assert.IsNull(failureMechanism.NotInAssemblyComments.Body);
+ Assert.IsNull(failureMechanism.CalculationsInputComments.Body);
+ CollectionAssert.IsEmpty(failureMechanism.Sections);
+ Assert.IsNull(failureMechanism.FailureMechanismSectionSourcePath);
+
+ Assert.IsNaN(failureMechanism.AssemblyResult.ManualFailurePathAssemblyProbability);
+ }
+
+ [Test]
+ public void ReadCommonFailureMechanismProperties_WithSectionsSet_ReturnsNewStandAloneFailureMechanismWithFailureMechanismSections()
+ {
+ // Setup
+ const string filePath = "failureMechanismSections/File/Path";
+ var entity = new FailureMechanismEntity
+ {
+ FailureMechanismSectionCollectionSourcePath = filePath,
+ FailureMechanismSectionEntities =
+ {
+ CreateSimpleFailureMechanismSectionEntity()
+ }
+ };
+ var collector = new ReadConversionCollector();
+ var failureMechanism = new TestFailureMechanism();
+
+ // Call
+ entity.ReadCommonFailureMechanismProperties(failureMechanism, collector);
+
+ // Assert
+ Assert.AreEqual(entity.FailureMechanismSectionEntities.Count, failureMechanism.Sections.Count());
+ Assert.AreEqual(filePath, failureMechanism.FailureMechanismSectionSourcePath);
+ }
+
+ [Test]
+ public void ReadSpecificFailurePath_EntityNull_ThrowArgumentNullException()
+ {
+ // Call
+ void Call() => ((SpecificFailurePathEntity) null).ReadSpecificFailurePath(new ReadConversionCollector());
+
+ // Assert
+ string paramName = Assert.Throws(Call).ParamName;
+ Assert.AreEqual("entity", paramName);
+ }
+
+ [Test]
+ public void ReadSpecificFailurePath_CollectorNull_ThrowArgumentNullException()
+ {
+ // Setup
+ var entity = new SpecificFailurePathEntity();
+
+ // Call
+ void Call() => entity.ReadSpecificFailurePath(null);
+
+ // Assert
+ string paramName = Assert.Throws(Call).ParamName;
+ Assert.AreEqual("collector", paramName);
+ }
+
+ [Test]
+ public void ReadSpecificFailurePath_ValidEntity_ReturnSpecificFailurePath()
+ {
+ // Setup
+ var random = new Random(21);
+ bool inAssembly = random.NextBoolean();
+ var probabilityResultType = random.NextEnumValue();
+
+ const string filePath = "failureMechanismSections/File/Path";
+ var entity = new SpecificFailurePathEntity
+ {
+ Name = "Specific failure path name",
+ N = random.NextDouble(1.0, 20.0),
+ InAssembly = Convert.ToByte(inAssembly),
+ InAssemblyInputComments = "Some input text",
+ InAssemblyOutputComments = "Some output text",
+ NotInAssemblyComments = "Some not in assembly text",
+ FailureMechanismSectionCollectionSourcePath = filePath,
+ FailurePathAssemblyProbabilityResultType = Convert.ToByte(probabilityResultType),
+ ManualFailurePathAssemblyProbability = random.NextDouble(),
+ FailureMechanismSectionEntities =
+ {
+ CreateSimpleFailureMechanismSectionEntity()
+ }
+ };
+
+ var collector = new ReadConversionCollector();
+
+ // Call
+ SpecificFailurePath specificFailurePath = entity.ReadSpecificFailurePath(collector);
+
+ // Assert
+ AssertCommonFailurePathProperties(entity, specificFailurePath);
+
+ Assert.AreEqual(entity.Name, specificFailurePath.Name);
+ Assert.AreEqual(entity.FailureMechanismSectionEntities.Count, specificFailurePath.Sections.Count());
+ Assert.AreEqual(filePath, specificFailurePath.FailureMechanismSectionSourcePath);
+
+ Assert.AreEqual(entity.N, specificFailurePath.Input.N, specificFailurePath.Input.N.GetAccuracy());
+ }
+
+ [Test]
+ public void ReadSpecificFailurePath_EntityWithNullValues_ReturnSpecificFailurePath()
+ {
+ // Setup
+ var entity = new SpecificFailurePathEntity
+ {
+ N = 1.1
+ };
+ var collector = new ReadConversionCollector();
+
+ // Call
+ SpecificFailurePath specificFailurePath = entity.ReadSpecificFailurePath(collector);
+
+ // Assert
+ FailurePathAssemblyResult assemblyResult = specificFailurePath.AssemblyResult;
+ Assert.IsNaN(assemblyResult.ManualFailurePathAssemblyProbability);
+ }
+
+ [Test]
+ public void ReadSpecificFailurePath_ValidEntityWithoutSections_ReturnSpecificFailurePath()
+ {
+ // Setup
+ var entity = new SpecificFailurePathEntity
+ {
+ N = 1.1
+ };
+
+ var collector = new ReadConversionCollector();
+
+ // Call
+ SpecificFailurePath specificFailurePath = entity.ReadSpecificFailurePath(collector);
+
+ // Assert
+ Assert.AreEqual(entity.FailureMechanismSectionEntities.Count, specificFailurePath.Sections.Count());
+ Assert.IsNull(specificFailurePath.FailureMechanismSectionSourcePath);
+ }
+
+ private static void AssertCommonFailurePathProperties(IFailurePathEntity entity, IFailurePath failurePath)
+ {
+ var inAssembly = Convert.ToBoolean(entity.InAssembly);
+
+ Assert.AreEqual(inAssembly, failurePath.InAssembly);
+ Assert.AreEqual(entity.InAssemblyInputComments, failurePath.InAssemblyInputComments.Body);
+ Assert.AreEqual(entity.InAssemblyOutputComments, failurePath.InAssemblyOutputComments.Body);
+ Assert.AreEqual(entity.NotInAssemblyComments, failurePath.NotInAssemblyComments.Body);
+
+ var probabilityResultType = (FailurePathAssemblyProbabilityResultType) entity.FailurePathAssemblyProbabilityResultType;
+ FailurePathAssemblyResult assemblyResult = failurePath.AssemblyResult;
+ Assert.AreEqual(probabilityResultType, assemblyResult.ProbabilityResultType);
+ Assert.AreEqual(entity.ManualFailurePathAssemblyProbability, assemblyResult.ManualFailurePathAssemblyProbability);
+ }
+
+ private static FailureMechanismSectionEntity CreateSimpleFailureMechanismSectionEntity()
+ {
+ var dummyPoints = new[]
+ {
+ new Point2D(0, 0)
+ };
+ string dummyPointXml = new Point2DCollectionXmlSerializer().ToXml(dummyPoints);
+ var failureMechanismSectionEntity = new FailureMechanismSectionEntity
+ {
+ Name = "section",
+ FailureMechanismSectionPointXml = dummyPointXml
+ };
+ return failureMechanismSectionEntity;
+ }
+ }
+}
\ No newline at end of file
Fisheye: Tag 48499e35b845fc712d21f7200ba8de3e3f8029b7 refers to a dead (removed) revision in file `Riskeer/Storage/test/Riskeer.Storage.Core.Test/Read/SpecificFailurePaths/SpecificFailurePathEntityReadExtensionsTest.cs'.
Fisheye: No comparison available. Pass `N' to diff?