Index: Ringtoets.sln =================================================================== diff -u -r117a54dfd9b5972086a1f3386923edda2e7a334b -r5d822eca2d7467c9781a4a3a54d796ac4229e4a3 --- Ringtoets.sln (.../Ringtoets.sln) (revision 117a54dfd9b5972086a1f3386923edda2e7a334b) +++ Ringtoets.sln (.../Ringtoets.sln) (revision 5d822eca2d7467c9781a4a3a54d796ac4229e4a3) @@ -1,6 +1,6 @@ Microsoft Visual Studio Solution File, Format Version 12.00 # Visual Studio 15 -VisualStudioVersion = 15.0.27004.2009 +VisualStudioVersion = 15.0.27130.0 MinimumVisualStudioVersion = 10.0.40219.1 Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Core", "Core", "{89F6BC2C-78E6-42F1-A056-704C877B5453}" EndProject @@ -1174,7 +1174,7 @@ {C90B77DA-E421-43CC-B82E-529651BC21AC} = {C90B77DA-E421-43CC-B82E-529651BC21AC} EndProjectSection EndProject -Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Ringtoets.Integration.TestUtils", "Ringtoets\Integration\test\Ringtoets.Integration.TestUtils\Ringtoets.Integration.TestUtils.csproj", "{174BA68D-6176-4AC5-8DFD-98CDD2C4D971}" +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Ringtoets.Integration.TestUtil", "Ringtoets\Integration\test\Ringtoets.Integration.TestUtil\Ringtoets.Integration.TestUtil.csproj", "{174BA68D-6176-4AC5-8DFD-98CDD2C4D971}" ProjectSection(ProjectDependencies) = postProject {C90B77DA-E421-43CC-B82E-529651BC21AC} = {C90B77DA-E421-43CC-B82E-529651BC21AC} EndProjectSection @@ -1385,7 +1385,7 @@ {C90B77DA-E421-43CC-B82E-529651BC21AC} = {C90B77DA-E421-43CC-B82E-529651BC21AC} EndProjectSection EndProject -Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Ringtoets.Integration.TestUtils.Test", "Ringtoets\Integration\test\Ringtoets.Integration.TestUtils.Test\Ringtoets.Integration.TestUtils.Test.csproj", "{EA3E979C-FB00-443B-B6A0-273254F24802}" +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Ringtoets.Integration.TestUtil.Test", "Ringtoets\Integration\test\Ringtoets.Integration.TestUtil.Test\Ringtoets.Integration.TestUtil.Test.csproj", "{EA3E979C-FB00-443B-B6A0-273254F24802}" ProjectSection(ProjectDependencies) = postProject {C90B77DA-E421-43CC-B82E-529651BC21AC} = {C90B77DA-E421-43CC-B82E-529651BC21AC} EndProjectSection @@ -4933,6 +4933,9 @@ {0B1AECB4-109F-4301-AC33-902AA3554803} = {0D9858E1-CF2D-4DE5-AC0E-64401900D531} {85765B22-A2DD-43F7-BF54-B5EB8EE69780} = {A39CC244-FBB2-4221-82B9-92CC837EF1DC} EndGlobalSection + GlobalSection(ExtensibilityGlobals) = postSolution + SolutionGuid = {039D31AA-B517-4354-B8CD-0B2B826D0B1F} + EndGlobalSection GlobalSection(TextTemplating) = postSolution TextTemplating = 1 EndGlobalSection Index: Ringtoets/GrassCoverErosionInwards/test/Ringtoets.GrassCoverErosionInwards.Integration.Test/GrassCoverErosionInwardsScenariosViewIntegrationTest.cs =================================================================== diff -u -raeb6e1a439617630e7613b9ed5af152c345fa2c6 -r5d822eca2d7467c9781a4a3a54d796ac4229e4a3 --- Ringtoets/GrassCoverErosionInwards/test/Ringtoets.GrassCoverErosionInwards.Integration.Test/GrassCoverErosionInwardsScenariosViewIntegrationTest.cs (.../GrassCoverErosionInwardsScenariosViewIntegrationTest.cs) (revision aeb6e1a439617630e7613b9ed5af152c345fa2c6) +++ Ringtoets/GrassCoverErosionInwards/test/Ringtoets.GrassCoverErosionInwards.Integration.Test/GrassCoverErosionInwardsScenariosViewIntegrationTest.cs (.../GrassCoverErosionInwardsScenariosViewIntegrationTest.cs) (revision 5d822eca2d7467c9781a4a3a54d796ac4229e4a3) @@ -38,7 +38,7 @@ using Ringtoets.GrassCoverErosionInwards.Forms.Views; using Ringtoets.GrassCoverErosionInwards.Plugin.FileImporters; using Ringtoets.Integration.Data; -using Ringtoets.Integration.TestUtils; +using Ringtoets.Integration.TestUtil; namespace Ringtoets.GrassCoverErosionInwards.Integration.Test { Index: Ringtoets/GrassCoverErosionInwards/test/Ringtoets.GrassCoverErosionInwards.Integration.Test/Ringtoets.GrassCoverErosionInwards.Integration.Test.csproj =================================================================== diff -u -r63fc151e9cf722527465c1eddfa6567a90feb5e6 -r5d822eca2d7467c9781a4a3a54d796ac4229e4a3 --- Ringtoets/GrassCoverErosionInwards/test/Ringtoets.GrassCoverErosionInwards.Integration.Test/Ringtoets.GrassCoverErosionInwards.Integration.Test.csproj (.../Ringtoets.GrassCoverErosionInwards.Integration.Test.csproj) (revision 63fc151e9cf722527465c1eddfa6567a90feb5e6) +++ Ringtoets/GrassCoverErosionInwards/test/Ringtoets.GrassCoverErosionInwards.Integration.Test/Ringtoets.GrassCoverErosionInwards.Integration.Test.csproj (.../Ringtoets.GrassCoverErosionInwards.Integration.Test.csproj) (revision 5d822eca2d7467c9781a4a3a54d796ac4229e4a3) @@ -91,9 +91,9 @@ {11F1F874-45AF-43E4-8AE5-15A5C9593E28} Ringtoets.Integration.Data - + {174ba68d-6176-4ac5-8dfd-98cdd2c4d971} - Ringtoets.Integration.TestUtils + Ringtoets.Integration.TestUtil {90DE728E-48EF-4665-AB38-3D88E41D9F4D} Index: Ringtoets/HeightStructures/test/Ringtoets.HeightStructures.Integration.Test/HeightStructuresScenariosViewIntegrationTest.cs =================================================================== diff -u -r8e74b5d6680386fce48486c8253b62331f7d7055 -r5d822eca2d7467c9781a4a3a54d796ac4229e4a3 --- Ringtoets/HeightStructures/test/Ringtoets.HeightStructures.Integration.Test/HeightStructuresScenariosViewIntegrationTest.cs (.../HeightStructuresScenariosViewIntegrationTest.cs) (revision 8e74b5d6680386fce48486c8253b62331f7d7055) +++ Ringtoets/HeightStructures/test/Ringtoets.HeightStructures.Integration.Test/HeightStructuresScenariosViewIntegrationTest.cs (.../HeightStructuresScenariosViewIntegrationTest.cs) (revision 5d822eca2d7467c9781a4a3a54d796ac4229e4a3) @@ -38,7 +38,7 @@ using Ringtoets.HeightStructures.IO; using Ringtoets.HeightStructures.Plugin.FileImporters; using Ringtoets.Integration.Data; -using Ringtoets.Integration.TestUtils; +using Ringtoets.Integration.TestUtil; namespace Ringtoets.HeightStructures.Integration.Test { Index: Ringtoets/HeightStructures/test/Ringtoets.HeightStructures.Integration.Test/Ringtoets.HeightStructures.Integration.Test.csproj =================================================================== diff -u -r63fc151e9cf722527465c1eddfa6567a90feb5e6 -r5d822eca2d7467c9781a4a3a54d796ac4229e4a3 --- Ringtoets/HeightStructures/test/Ringtoets.HeightStructures.Integration.Test/Ringtoets.HeightStructures.Integration.Test.csproj (.../Ringtoets.HeightStructures.Integration.Test.csproj) (revision 63fc151e9cf722527465c1eddfa6567a90feb5e6) +++ Ringtoets/HeightStructures/test/Ringtoets.HeightStructures.Integration.Test/Ringtoets.HeightStructures.Integration.Test.csproj (.../Ringtoets.HeightStructures.Integration.Test.csproj) (revision 5d822eca2d7467c9781a4a3a54d796ac4229e4a3) @@ -73,9 +73,9 @@ {11F1F874-45AF-43E4-8AE5-15A5C9593E28} Ringtoets.Integration.Data - + {174ba68d-6176-4ac5-8dfd-98cdd2c4d971} - Ringtoets.Integration.TestUtils + Ringtoets.Integration.TestUtil {1C0017D8-35B5-4CA0-8FC7-A83F46DBDC99} Index: Ringtoets/Integration/test/Ringtoets.Integration.Plugin.Test/Handlers/AssessmentSectionCompositionChangeHandlerTest.cs =================================================================== diff -u -r1f0cd3fafaa7340a446612870810629587474302 -r5d822eca2d7467c9781a4a3a54d796ac4229e4a3 --- Ringtoets/Integration/test/Ringtoets.Integration.Plugin.Test/Handlers/AssessmentSectionCompositionChangeHandlerTest.cs (.../AssessmentSectionCompositionChangeHandlerTest.cs) (revision 1f0cd3fafaa7340a446612870810629587474302) +++ Ringtoets/Integration/test/Ringtoets.Integration.Plugin.Test/Handlers/AssessmentSectionCompositionChangeHandlerTest.cs (.../AssessmentSectionCompositionChangeHandlerTest.cs) (revision 5d822eca2d7467c9781a4a3a54d796ac4229e4a3) @@ -40,7 +40,7 @@ using Ringtoets.Integration.Data; using Ringtoets.Integration.Forms.PropertyClasses; using Ringtoets.Integration.Plugin.Handlers; -using Ringtoets.Integration.TestUtils; +using Ringtoets.Integration.TestUtil; using Ringtoets.Piping.Data; using Ringtoets.StabilityPointStructures.Data; using Ringtoets.StabilityStoneCover.Data; Index: Ringtoets/Integration/test/Ringtoets.Integration.Plugin.Test/Handlers/FailureMechanismContributionNormChangeHandlerTest.cs =================================================================== diff -u -ra8700b1afad48f78474132bf4745ba00a47df584 -r5d822eca2d7467c9781a4a3a54d796ac4229e4a3 --- Ringtoets/Integration/test/Ringtoets.Integration.Plugin.Test/Handlers/FailureMechanismContributionNormChangeHandlerTest.cs (.../FailureMechanismContributionNormChangeHandlerTest.cs) (revision a8700b1afad48f78474132bf4745ba00a47df584) +++ Ringtoets/Integration/test/Ringtoets.Integration.Plugin.Test/Handlers/FailureMechanismContributionNormChangeHandlerTest.cs (.../FailureMechanismContributionNormChangeHandlerTest.cs) (revision 5d822eca2d7467c9781a4a3a54d796ac4229e4a3) @@ -34,7 +34,7 @@ using Ringtoets.DuneErosion.Data; using Ringtoets.Integration.Data; using Ringtoets.Integration.Plugin.Handlers; -using Ringtoets.Integration.TestUtils; +using Ringtoets.Integration.TestUtil; namespace Ringtoets.Integration.Plugin.Test.Handlers { Index: Ringtoets/Integration/test/Ringtoets.Integration.Plugin.Test/Handlers/ReferenceLineReplacementHandlerTest.cs =================================================================== diff -u -r1f0cd3fafaa7340a446612870810629587474302 -r5d822eca2d7467c9781a4a3a54d796ac4229e4a3 --- Ringtoets/Integration/test/Ringtoets.Integration.Plugin.Test/Handlers/ReferenceLineReplacementHandlerTest.cs (.../ReferenceLineReplacementHandlerTest.cs) (revision 1f0cd3fafaa7340a446612870810629587474302) +++ Ringtoets/Integration/test/Ringtoets.Integration.Plugin.Test/Handlers/ReferenceLineReplacementHandlerTest.cs (.../ReferenceLineReplacementHandlerTest.cs) (revision 5d822eca2d7467c9781a4a3a54d796ac4229e4a3) @@ -36,7 +36,7 @@ using Ringtoets.Integration.Data; using Ringtoets.Integration.Data.StandAlone; using Ringtoets.Integration.Plugin.Handlers; -using Ringtoets.Integration.TestUtils; +using Ringtoets.Integration.TestUtil; using Ringtoets.MacroStabilityInwards.Data; using Ringtoets.Piping.Data; using Ringtoets.StabilityPointStructures.Data; Index: Ringtoets/Integration/test/Ringtoets.Integration.Plugin.Test/Ringtoets.Integration.Plugin.Test.csproj =================================================================== diff -u -r63fc151e9cf722527465c1eddfa6567a90feb5e6 -r5d822eca2d7467c9781a4a3a54d796ac4229e4a3 --- Ringtoets/Integration/test/Ringtoets.Integration.Plugin.Test/Ringtoets.Integration.Plugin.Test.csproj (.../Ringtoets.Integration.Plugin.Test.csproj) (revision 63fc151e9cf722527465c1eddfa6567a90feb5e6) +++ Ringtoets/Integration/test/Ringtoets.Integration.Plugin.Test/Ringtoets.Integration.Plugin.Test.csproj (.../Ringtoets.Integration.Plugin.Test.csproj) (revision 5d822eca2d7467c9781a4a3a54d796ac4229e4a3) @@ -267,10 +267,6 @@ {955E574D-67CE-4347-AA6B-7DF8A04ED754} Ringtoets.Piping.Data.TestUtil - - {27E0A5C9-3ABF-426A-A3DA-7D0B83A218C8} - Ringtoets.Piping.KernelWrapper.TestUtil - {87c2c553-c0bc-40bf-b1ea-b83bff357f27} Ringtoets.Revetment.Data @@ -323,9 +319,9 @@ {c8383b76-b3f1-4e6e-b56c-527b469fa20a} Ringtoets.Integration.Plugin - + {174ba68d-6176-4ac5-8dfd-98cdd2c4d971} - Ringtoets.Integration.TestUtils + Ringtoets.Integration.TestUtil Index: Ringtoets/Integration/test/Ringtoets.Integration.Service.Test/Ringtoets.Integration.Service.Test.csproj =================================================================== diff -u -r63fc151e9cf722527465c1eddfa6567a90feb5e6 -r5d822eca2d7467c9781a4a3a54d796ac4229e4a3 --- Ringtoets/Integration/test/Ringtoets.Integration.Service.Test/Ringtoets.Integration.Service.Test.csproj (.../Ringtoets.Integration.Service.Test.csproj) (revision 63fc151e9cf722527465c1eddfa6567a90feb5e6) +++ Ringtoets/Integration/test/Ringtoets.Integration.Service.Test/Ringtoets.Integration.Service.Test.csproj (.../Ringtoets.Integration.Service.Test.csproj) (revision 5d822eca2d7467c9781a4a3a54d796ac4229e4a3) @@ -111,9 +111,9 @@ {28811C4A-6C18-42C1-88B2-A03A3784E2D0} Ringtoets.Integration.Service - + {174ba68d-6176-4ac5-8dfd-98cdd2c4d971} - Ringtoets.Integration.TestUtils + Ringtoets.Integration.TestUtil \ No newline at end of file Index: Ringtoets/Integration/test/Ringtoets.Integration.Service.Test/RingtoetsDataSynchronizationServiceTest.cs =================================================================== diff -u -r8b567830c978aa32ef7fbe0a16d71f637ff383e3 -r5d822eca2d7467c9781a4a3a54d796ac4229e4a3 --- Ringtoets/Integration/test/Ringtoets.Integration.Service.Test/RingtoetsDataSynchronizationServiceTest.cs (.../RingtoetsDataSynchronizationServiceTest.cs) (revision 8b567830c978aa32ef7fbe0a16d71f637ff383e3) +++ Ringtoets/Integration/test/Ringtoets.Integration.Service.Test/RingtoetsDataSynchronizationServiceTest.cs (.../RingtoetsDataSynchronizationServiceTest.cs) (revision 5d822eca2d7467c9781a4a3a54d796ac4229e4a3) @@ -41,7 +41,7 @@ using Ringtoets.HeightStructures.Data; using Ringtoets.Integration.Data; using Ringtoets.Integration.Data.StandAlone; -using Ringtoets.Integration.TestUtils; +using Ringtoets.Integration.TestUtil; using Ringtoets.MacroStabilityInwards.Data; using Ringtoets.MacroStabilityInwards.Data.SoilProfile; using Ringtoets.MacroStabilityInwards.Primitives; Index: Ringtoets/Integration/test/Ringtoets.Integration.Test/FileImporters/ForeshoreProfileReplaceDataStrategyIntegrationTest.cs =================================================================== diff -u -ra940166534b3dd6e778de2e7c8e7e5241f3d3381 -r5d822eca2d7467c9781a4a3a54d796ac4229e4a3 --- Ringtoets/Integration/test/Ringtoets.Integration.Test/FileImporters/ForeshoreProfileReplaceDataStrategyIntegrationTest.cs (.../ForeshoreProfileReplaceDataStrategyIntegrationTest.cs) (revision a940166534b3dd6e778de2e7c8e7e5241f3d3381) +++ Ringtoets/Integration/test/Ringtoets.Integration.Test/FileImporters/ForeshoreProfileReplaceDataStrategyIntegrationTest.cs (.../ForeshoreProfileReplaceDataStrategyIntegrationTest.cs) (revision 5d822eca2d7467c9781a4a3a54d796ac4229e4a3) @@ -30,7 +30,7 @@ using Ringtoets.GrassCoverErosionOutwards.Data; using Ringtoets.HeightStructures.Data; using Ringtoets.Integration.Plugin.FileImporters; -using Ringtoets.Integration.TestUtils; +using Ringtoets.Integration.TestUtil; using Ringtoets.StabilityPointStructures.Data; using Ringtoets.StabilityStoneCover.Data; using Ringtoets.WaveImpactAsphaltCover.Data; Index: Ringtoets/Integration/test/Ringtoets.Integration.Test/FileImporters/ForeshoreProfileUpdateDataStrategyIntegrationTest.cs =================================================================== diff -u -ra940166534b3dd6e778de2e7c8e7e5241f3d3381 -r5d822eca2d7467c9781a4a3a54d796ac4229e4a3 --- Ringtoets/Integration/test/Ringtoets.Integration.Test/FileImporters/ForeshoreProfileUpdateDataStrategyIntegrationTest.cs (.../ForeshoreProfileUpdateDataStrategyIntegrationTest.cs) (revision a940166534b3dd6e778de2e7c8e7e5241f3d3381) +++ Ringtoets/Integration/test/Ringtoets.Integration.Test/FileImporters/ForeshoreProfileUpdateDataStrategyIntegrationTest.cs (.../ForeshoreProfileUpdateDataStrategyIntegrationTest.cs) (revision 5d822eca2d7467c9781a4a3a54d796ac4229e4a3) @@ -37,7 +37,7 @@ using Ringtoets.HeightStructures.Data; using Ringtoets.HeightStructures.Data.TestUtil; using Ringtoets.Integration.Plugin.FileImporters; -using Ringtoets.Integration.TestUtils; +using Ringtoets.Integration.TestUtil; using Ringtoets.Revetment.Data.TestUtil; using Ringtoets.StabilityPointStructures.Data; using Ringtoets.StabilityPointStructures.Data.TestUtil; Index: Ringtoets/Integration/test/Ringtoets.Integration.Test/ReferenceLineImporterIntegrationTest.cs =================================================================== diff -u -r1f0cd3fafaa7340a446612870810629587474302 -r5d822eca2d7467c9781a4a3a54d796ac4229e4a3 --- Ringtoets/Integration/test/Ringtoets.Integration.Test/ReferenceLineImporterIntegrationTest.cs (.../ReferenceLineImporterIntegrationTest.cs) (revision 1f0cd3fafaa7340a446612870810629587474302) +++ Ringtoets/Integration/test/Ringtoets.Integration.Test/ReferenceLineImporterIntegrationTest.cs (.../ReferenceLineImporterIntegrationTest.cs) (revision 5d822eca2d7467c9781a4a3a54d796ac4229e4a3) @@ -34,7 +34,7 @@ using Ringtoets.Common.IO.ReferenceLines; using Ringtoets.Integration.Data; using Ringtoets.Integration.Plugin.Handlers; -using Ringtoets.Integration.TestUtils; +using Ringtoets.Integration.TestUtil; namespace Ringtoets.Integration.Test { Index: Ringtoets/Integration/test/Ringtoets.Integration.Test/Ringtoets.Integration.Test.csproj =================================================================== diff -u -r63fc151e9cf722527465c1eddfa6567a90feb5e6 -r5d822eca2d7467c9781a4a3a54d796ac4229e4a3 --- Ringtoets/Integration/test/Ringtoets.Integration.Test/Ringtoets.Integration.Test.csproj (.../Ringtoets.Integration.Test.csproj) (revision 63fc151e9cf722527465c1eddfa6567a90feb5e6) +++ Ringtoets/Integration/test/Ringtoets.Integration.Test/Ringtoets.Integration.Test.csproj (.../Ringtoets.Integration.Test.csproj) (revision 5d822eca2d7467c9781a4a3a54d796ac4229e4a3) @@ -118,9 +118,9 @@ {c8383b76-b3f1-4e6e-b56c-527b469fa20a} Ringtoets.Integration.Plugin - + {174ba68d-6176-4ac5-8dfd-98cdd2c4d971} - Ringtoets.Integration.TestUtils + Ringtoets.Integration.TestUtil \ No newline at end of file Index: Ringtoets/Integration/test/Ringtoets.Integration.TestUtil.Test/DataImportHelperTest.cs =================================================================== diff -u --- Ringtoets/Integration/test/Ringtoets.Integration.TestUtil.Test/DataImportHelperTest.cs (revision 0) +++ Ringtoets/Integration/test/Ringtoets.Integration.TestUtil.Test/DataImportHelperTest.cs (revision 5d822eca2d7467c9781a4a3a54d796ac4229e4a3) @@ -0,0 +1,282 @@ +// Copyright (C) Stichting Deltares 2017. All rights reserved. +// +// This file is part of Ringtoets. +// +// Ringtoets is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this program. If not, see . +// +// 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 NUnit.Framework; +using Ringtoets.Common.Data.AssessmentSection; +using Ringtoets.Common.Data.FailureMechanism; +using Ringtoets.Integration.Data; + +namespace Ringtoets.Integration.TestUtil.Test +{ + [TestFixture] + public class DataImportHelperTest + { + private AssessmentSection dikeSection; + + [SetUp] + public void SetUp() + { + dikeSection = new AssessmentSection(AssessmentSectionComposition.Dike); + } + + [Test] + public void ImportReferenceLine_AssesmentSectionNull_ThrowsArgumentNullException() + { + // Call + TestDelegate test = () => DataImportHelper.ImportReferenceLine(null); + + // Assert + string paramName = Assert.Throws(test).ParamName; + Assert.AreEqual("importTarget", paramName); + } + + [Test] + public void ImportReferenceLine_ValidAssessmentSection_AddsReferenceLineGeometry() + { + // Call + DataImportHelper.ImportReferenceLine(dikeSection); + + // Assert + Assert.AreEqual(2380, dikeSection.ReferenceLine.Points.Count()); + } + + [Test] + public void ImportFailureMechanismSections_WithoutReferenceLine_ArgumentNullException() + { + // Setup + IFailureMechanism failureMechanism = dikeSection.GetFailureMechanisms().ElementAt(new Random(21).Next(0, 18)); + + // Call + TestDelegate test = () => DataImportHelper.ImportFailureMechanismSections(dikeSection, failureMechanism); + + // Assert + var exception = Assert.Throws(test); + Assert.AreEqual("referenceLine", exception.ParamName); + } + + [Test] + public void ImportFailureMechanismSections_WithReferenceLine_AddsSectionsToSuppliedFailureMechanismOnly() + { + // Setup + DataImportHelper.ImportReferenceLine(dikeSection); + const int failureMechanismCount = 18; + int chosenFailureMechanismIndex = new Random(21).Next(0, failureMechanismCount); + IFailureMechanism failureMechanism = dikeSection.GetFailureMechanisms().ElementAt(chosenFailureMechanismIndex); + + // Call + DataImportHelper.ImportFailureMechanismSections(dikeSection, failureMechanism); + + // Assert + int[] expectedSectionCounts = Enumerable.Repeat(0, failureMechanismCount).ToArray(); + expectedSectionCounts[chosenFailureMechanismIndex] = 283; + CollectionAssert.AreEqual(expectedSectionCounts, dikeSection.GetFailureMechanisms().Select(fm => fm.Sections.Count())); + } + + [Test] + public void ImportFailureMechanismSections_MultipleFailureMechanismsWithoutReferenceLine_ArgumentNullException() + { + // Setup + IFailureMechanism failureMechanism = dikeSection.GetFailureMechanisms().ElementAt(new Random(21).Next(0, 18)); + + // Call + TestDelegate test = () => DataImportHelper.ImportFailureMechanismSections(dikeSection, new[] + { + failureMechanism + }); + + // Assert + var exception = Assert.Throws(test); + Assert.AreEqual("referenceLine", exception.ParamName); + } + + [Test] + public void ImportFailureMechanismSections_MultipleFailureMechanismsWithReferenceLine_AddsSectionsToSuppliedFailureMechanismOnly() + { + // Setup + DataImportHelper.ImportReferenceLine(dikeSection); + const int failureMechanismCount = 18; + var random = new Random(21); + IEnumerable chosenNumbers = new[] + { + random.Next(failureMechanismCount), + random.Next(failureMechanismCount), + random.Next(failureMechanismCount) + }.Distinct(); + IEnumerable sectionFailureMechanisms = dikeSection.GetFailureMechanisms().ToArray(); + IEnumerable failureMechanisms = sectionFailureMechanisms.Where((fm, i) => chosenNumbers.Contains(i)); + + // Call + DataImportHelper.ImportFailureMechanismSections(dikeSection, failureMechanisms); + + // Assert + int[] expectedSectionCounts = Enumerable.Repeat(0, failureMechanismCount).ToArray(); + foreach (int chosenNumber in chosenNumbers) + { + expectedSectionCounts[chosenNumber] = 283; + } + CollectionAssert.AreEqual(expectedSectionCounts, sectionFailureMechanisms.Select(fm => fm.Sections.Count())); + } + + [Test] + public void ImportHydraulicBoundaryDatabase_AssessmentSectionNull_ThrowsArgumentNullException() + { + // Call + TestDelegate test = () => DataImportHelper.ImportHydraulicBoundaryDatabase(null); + + // Assert + string paramName = Assert.Throws(test).ParamName; + Assert.AreEqual("targetItem", paramName); + } + + [Test] + public void ImportHydraulicBoundaryDatabase_ValidAssessmentSection_AddsFourSurfaceLines() + { + // Call + DataImportHelper.ImportHydraulicBoundaryDatabase(dikeSection); + + // Assert + Assert.AreEqual(18, dikeSection.HydraulicBoundaryDatabase.Locations.Count); + } + + [Test] + public void ImportPipingSurfaceLines_WithoutReferenceLine_ArgumentNullException() + { + // Call + TestDelegate test = () => DataImportHelper.ImportPipingSurfaceLines(dikeSection); + + // Assert + var exception = Assert.Throws(test); + Assert.AreEqual("referenceLine", exception.ParamName); + } + + [Test] + public void ImportPipingSurfaceLines_WithReferenceLine_AddsFourSurfaceLines() + { + // Setup + DataImportHelper.ImportReferenceLine(dikeSection); + + // Call + DataImportHelper.ImportPipingSurfaceLines(dikeSection); + + // Assert + CollectionAssert.AreEqual(new[] + { + "PK001_0001", + "PK001_0002", + "PK001_0003", + "PK001_0004" + }, dikeSection.Piping.SurfaceLines.Select(sm => sm.Name)); + } + + [Test] + public void ImportPipingStochasticSoilModels_Always_AddsFourSoilModelsWithProfiles() + { + // Call + DataImportHelper.ImportPipingStochasticSoilModels(dikeSection); + + // Assert + CollectionAssert.AreEqual(new[] + { + "PK001_0001_Piping", + "PK001_0002_Piping", + "PK001_0003_Piping", + "PK001_0004_Piping" + }, dikeSection.Piping.StochasticSoilModels.Select(sm => sm.Name)); + CollectionAssert.AreEqual(new[] + { + 1, + 1, + 1, + 1 + }, dikeSection.Piping.StochasticSoilModels.SelectMany(sm => sm.StochasticSoilProfiles.Select(sp => sp.Probability))); + CollectionAssert.AreEqual(new[] + { + "W1-6_0_1D1", + "W1-6_4_1D1", + "W1-7_0_1D1", + "W1-8_6_1D1" + }, dikeSection.Piping.StochasticSoilModels.SelectMany(sm => sm.StochasticSoilProfiles.Select(sp => sp.SoilProfile.Name))); + } + + [Test] + public void ImportMacroStabilityInwardsSurfaceLines_WithoutReferenceLine_ArgumentNullException() + { + // Call + TestDelegate test = () => DataImportHelper.ImportMacroStabilityInwardsSurfaceLines(dikeSection); + + // Assert + var exception = Assert.Throws(test); + Assert.AreEqual("referenceLine", exception.ParamName); + } + + [Test] + public void ImportMacroStabilityInwardsSurfaceLines_WithReferenceLine_AddsFourSurfaceLines() + { + // Setup + DataImportHelper.ImportReferenceLine(dikeSection); + + // Call + DataImportHelper.ImportMacroStabilityInwardsSurfaceLines(dikeSection); + + // Assert + CollectionAssert.AreEqual(new[] + { + "PK001_0001", + "PK001_0002", + "PK001_0003", + "PK001_0004" + }, dikeSection.MacroStabilityInwards.SurfaceLines.Select(sm => sm.Name)); + } + + [Test] + public void ImportMacroStabilityInwardsStochasticSoilModels_Always_AddsFourSoilModelsWithProfiles() + { + // Call + DataImportHelper.ImportMacroStabilityInwardsStochasticSoilModels(dikeSection); + + // Assert + CollectionAssert.AreEqual(new[] + { + "PK001_0001_Stability", + "PK001_0002_Stability", + "PK001_0003_Stability", + "PK001_0004_Stability" + }, dikeSection.MacroStabilityInwards.StochasticSoilModels.Select(sm => sm.Name)); + CollectionAssert.AreEqual(new[] + { + 1, + 1, + 1, + 1 + }, dikeSection.MacroStabilityInwards.StochasticSoilModels.SelectMany(sm => sm.StochasticSoilProfiles.Select(sp => sp.Probability))); + CollectionAssert.AreEqual(new[] + { + "W1-6_0_1D1", + "W1-6_4_1D1", + "W1-7_0_1D1", + "W1-8_6_1D1" + }, dikeSection.MacroStabilityInwards.StochasticSoilModels.SelectMany(sm => sm.StochasticSoilProfiles.Select(sp => sp.SoilProfile.Name))); + } + } +} \ No newline at end of file Index: Ringtoets/Integration/test/Ringtoets.Integration.TestUtil.Test/DataUpdateHelperTest.cs =================================================================== diff -u --- Ringtoets/Integration/test/Ringtoets.Integration.TestUtil.Test/DataUpdateHelperTest.cs (revision 0) +++ Ringtoets/Integration/test/Ringtoets.Integration.TestUtil.Test/DataUpdateHelperTest.cs (revision 5d822eca2d7467c9781a4a3a54d796ac4229e4a3) @@ -0,0 +1,112 @@ +// Copyright (C) Stichting Deltares 2017. All rights reserved. +// +// This file is part of Ringtoets. +// +// Ringtoets is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this program. If not, see . +// +// All names, logos, and references to "Deltares" are registered trademarks of +// Stichting Deltares and remain full property of Stichting Deltares at all times. +// All rights reserved. + +using System.Linq; +using NUnit.Framework; +using Ringtoets.Common.Data.AssessmentSection; +using Ringtoets.Integration.Data; + +namespace Ringtoets.Integration.TestUtil.Test +{ + [TestFixture] + public class DataUpdateHelperTest + { + private AssessmentSection dikeSection; + + [SetUp] + public void SetUp() + { + dikeSection = new AssessmentSection(AssessmentSectionComposition.Dike); + } + + [Test] + public void ImportPipingStochasticSoilModels_ValidAssessmentSection_AddsThreeSoilModelsWithProfiles() + { + // Call + DataUpdateHelper.UpdatePipingStochasticSoilModels(dikeSection); + + // Assert + CollectionAssert.AreEqual(new[] + { + "PK001_0001_Piping", + "PK001_0002_Piping", + "PK001_0003_Piping" + }, dikeSection.Piping.StochasticSoilModels.Select(sm => sm.Name)); + CollectionAssert.AreEqual(new[] + { + 1, + 2, + 1 + }, dikeSection.Piping.StochasticSoilModels.Select(sm => sm.StochasticSoilProfiles.Count())); + CollectionAssert.AreEqual(new[] + { + 0.5, + 0.5, + 0.5, + 1.0 + }, dikeSection.Piping.StochasticSoilModels.SelectMany(sm => sm.StochasticSoilProfiles.Select(sp => sp.Probability))); + CollectionAssert.AreEqual(new[] + { + "W1-6_0_1D1", + "W1-6_0_1D1", + "W1-7_0_1D1", + "W1-7_0_1D1" + }, dikeSection.Piping.StochasticSoilModels.SelectMany(sm => sm.StochasticSoilProfiles.Select(sp => sp.SoilProfile.Name))); + } + + [Test] + public void UpdateMacroStabilityInwardsStochasticSoilModels_ValidAssessmentSection_AddsThreeSoilModelsWithProfiles() + { + // Call + DataUpdateHelper.UpdateMacroStabilityInwardsStochasticSoilModels(dikeSection); + + // Assert + CollectionAssert.AreEqual(new[] + { + "PK001_0001_Stability", + "PK001_0002_Stability", + "PK001_0003_Stability", + "PK001_0004_Stability" + }, dikeSection.MacroStabilityInwards.StochasticSoilModels.Select(sm => sm.Name)); + CollectionAssert.AreEqual(new[] + { + 1, + 1, + 1, + 1 + }, dikeSection.MacroStabilityInwards.StochasticSoilModels.Select(sm => sm.StochasticSoilProfiles.Count())); + CollectionAssert.AreEqual(new[] + { + 1.0, + 1.0, + 1.0, + 1.0 + }, dikeSection.MacroStabilityInwards.StochasticSoilModels.SelectMany(sm => sm.StochasticSoilProfiles.Select(sp => sp.Probability))); + CollectionAssert.AreEqual(new[] + { + "W1-6_0_1D1", + "W1-6_4_1D1", + "W1-7_0_1D1", + "W1-8_6_1D1" + }, dikeSection.MacroStabilityInwards.StochasticSoilModels.SelectMany(sm => sm.StochasticSoilProfiles.Select(sp => sp.SoilProfile.Name))); + } + } +} \ No newline at end of file Index: Ringtoets/Integration/test/Ringtoets.Integration.TestUtil.Test/Properties/AssemblyInfo.cs =================================================================== diff -u --- Ringtoets/Integration/test/Ringtoets.Integration.TestUtil.Test/Properties/AssemblyInfo.cs (revision 0) +++ Ringtoets/Integration/test/Ringtoets.Integration.TestUtil.Test/Properties/AssemblyInfo.cs (revision 5d822eca2d7467c9781a4a3a54d796ac4229e4a3) @@ -0,0 +1,25 @@ +// Copyright (C) Stichting Deltares 2017. All rights reserved. +// +// This file is part of Ringtoets. +// +// Ringtoets is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this program. If not, see . +// +// 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.Reflection; + +[assembly: AssemblyTitle("Ringtoets.Integration.TestUtil.Test")] +[assembly: AssemblyProduct("Ringtoets.Integration.TestUtil.Test")] \ No newline at end of file Index: Ringtoets/Integration/test/Ringtoets.Integration.TestUtil.Test/Ringtoets.Integration.TestUtil.Test.csproj =================================================================== diff -u --- Ringtoets/Integration/test/Ringtoets.Integration.TestUtil.Test/Ringtoets.Integration.TestUtil.Test.csproj (revision 0) +++ Ringtoets/Integration/test/Ringtoets.Integration.TestUtil.Test/Ringtoets.Integration.TestUtil.Test.csproj (revision 5d822eca2d7467c9781a4a3a54d796ac4229e4a3) @@ -0,0 +1,107 @@ + + + + {EA3E979C-FB00-443B-B6A0-273254F24802} + Ringtoets.Integration.TestUtil.Test + Ringtoets.Integration.TestUtil.Test + + + + + ..\..\..\..\packages\NUnit.3.8.1\lib\net40\nunit.framework.dll + True + + + + + + + + + + + + + Copying.licenseheader + + + + + + {3bbfd65b-b277-4e50-ae6d-bd24c3434609} + Core.Common.Base + + + {c6309704-d67b-434c-bc98-9f8910bc1d10} + Ringtoets.ClosingStructures.Data + + + {d4200f43-3f72-4f42-af0a-8ced416a38ec} + Ringtoets.Common.Data + + + {d1068432-c172-4aa6-847b-d9deb4c6de26} + Ringtoets.DuneErosion.Data + + + {90de728e-48ef-4665-ab38-3d88e41d9f4d} + Ringtoets.GrassCoverErosionInwards.Data + + + {e7225477-577f-4a17-b7ec-6721158e1543} + Ringtoets.GrassCoverErosionOutwards.Data + + + {1c0017d8-35b5-4ca0-8fc7-a83f46dbdc99} + Ringtoets.HeightStructures.Data + + + {83d6b73e-91d5-46b0-9218-955da1f75f7c} + Ringtoets.MacroStabilityInwards.Data + + + {e9b39743-2dc9-4922-9e0f-6ba3e0e54189} + Ringtoets.MacroStabilityInwards.Primitives + + + {2B78CF04-4785-4F27-A6E5-45BDDBB7BF04} + Ringtoets.MacroStabilityInwards.Data.TestUtil + + + {ce994cc9-6f6a-48ac-b4be-02c30a21f4db} + Ringtoets.Piping.Data + + + {14C6F716-64E2-4BC4-A1EF-05865FCEFA4C} + Ringtoets.Piping.Primitives + + + {955E574D-67CE-4347-AA6B-7DF8A04ED754} + Ringtoets.Piping.Data.TestUtil + + + {87c2c553-c0bc-40bf-b1ea-b83bff357f27} + Ringtoets.Revetment.Data + + + {3d4b9740-8348-4434-8d77-b611fc6ee57f} + Ringtoets.StabilityPointStructures.Data + + + {b479e3af-7c34-488c-bb73-d324100d36c9} + Ringtoets.StabilityStoneCover.Data + + + {567e0b69-5280-41ce-add6-443725a61c86} + Ringtoets.WaveImpactAsphaltCover.Data + + + {11f1f874-45af-43e4-8ae5-15a5c9593e28} + Ringtoets.Integration.Data + + + {174ba68d-6176-4ac5-8dfd-98cdd2c4d971} + Ringtoets.Integration.TestUtil + + + \ No newline at end of file Index: Ringtoets/Integration/test/Ringtoets.Integration.TestUtil.Test/TestDataGeneratorTest.cs =================================================================== diff -u --- Ringtoets/Integration/test/Ringtoets.Integration.TestUtil.Test/TestDataGeneratorTest.cs (revision 0) +++ Ringtoets/Integration/test/Ringtoets.Integration.TestUtil.Test/TestDataGeneratorTest.cs (revision 5d822eca2d7467c9781a4a3a54d796ac4229e4a3) @@ -0,0 +1,819 @@ +// Copyright (C) Stichting Deltares 2017. All rights reserved. +// +// This file is part of Ringtoets. +// +// Ringtoets is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this program. If not, see . +// +// 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.Collections.Generic; +using System.Linq; +using NUnit.Framework; +using Ringtoets.ClosingStructures.Data; +using Ringtoets.Common.Data; +using Ringtoets.Common.Data.AssessmentSection; +using Ringtoets.Common.Data.Calculation; +using Ringtoets.Common.Data.FailureMechanism; +using Ringtoets.Common.Data.Structures; +using Ringtoets.DuneErosion.Data; +using Ringtoets.GrassCoverErosionInwards.Data; +using Ringtoets.GrassCoverErosionOutwards.Data; +using Ringtoets.HeightStructures.Data; +using Ringtoets.Integration.Data; +using Ringtoets.MacroStabilityInwards.Data; +using Ringtoets.MacroStabilityInwards.Data.TestUtil; +using Ringtoets.Piping.Data; +using Ringtoets.Piping.Data.TestUtil; +using Ringtoets.StabilityPointStructures.Data; +using Ringtoets.StabilityStoneCover.Data; +using Ringtoets.WaveImpactAsphaltCover.Data; + +namespace Ringtoets.Integration.TestUtil.Test +{ + [TestFixture] + public class TestDataGeneratorTest + { + [Test] + public void GetAssessmentSectionWithAllCalculationConfigurations_DefaultComposition_ReturnsWithAllPossibleCalculationConfigurations() + { + // Call + AssessmentSection assessmentSection = TestDataGenerator.GetAssessmentSectionWithAllCalculationConfigurations(); + + // Assert + Assert.AreEqual(AssessmentSectionComposition.Dike, assessmentSection.Composition); + AssertFailureMechanismsHaveAllPossibleCalculationConfigurations(assessmentSection); + Assert.True(assessmentSection.GrassCoverErosionOutwards.HydraulicBoundaryLocations.All(loc => loc.DesignWaterLevelCalculation.HasOutput + && loc.WaveHeightCalculation.HasOutput)); + + DuneErosionFailureMechanism duneErosionFailureMechanism = assessmentSection.GetFailureMechanisms() + .OfType() + .Single(); + AssertDuneErosionFailureMechanismCalculationConfigurationsWithoutOutputs(duneErosionFailureMechanism); + AssertDuneErosionFailureMechanismCalculationConfigurationsWithOutputs(duneErosionFailureMechanism); + } + + [Test] + [TestCase(AssessmentSectionComposition.Dike)] + [TestCase(AssessmentSectionComposition.DikeAndDune)] + [TestCase(AssessmentSectionComposition.Dune)] + public void GetAssessmentSectionWithAllCalculationConfigurations_CompositionGiven_ReturnWithCompositionAndAllPossibleCalculationConfigurations( + AssessmentSectionComposition composition) + { + // Call + AssessmentSection assessmentSection = TestDataGenerator.GetAssessmentSectionWithAllCalculationConfigurations(composition); + + // Assert + Assert.AreEqual(composition, assessmentSection.Composition); + AssertFailureMechanismsHaveAllPossibleCalculationConfigurations(assessmentSection); + Assert.True(assessmentSection.GrassCoverErosionOutwards.HydraulicBoundaryLocations.All(loc => loc.DesignWaterLevelCalculation.HasOutput + && loc.WaveHeightCalculation.HasOutput)); + + DuneErosionFailureMechanism duneErosionFailureMechanism = assessmentSection.GetFailureMechanisms() + .OfType() + .Single(); + AssertDuneErosionFailureMechanismCalculationConfigurationsWithoutOutputs(duneErosionFailureMechanism); + AssertDuneErosionFailureMechanismCalculationConfigurationsWithOutputs(duneErosionFailureMechanism); + } + + [Test] + public void GetAssessmentSectionWithAllCalculationConfigurationsWithoutHydraulicBoundaryLocationAndDuneOutput_DefaultComposition_ReturnWithOnlyCalculationOutputsAndComposition() + { + // Call + AssessmentSection assessmentSection = TestDataGenerator.GetAssessmentSectionWithAllCalculationConfigurationsWithoutHydraulicBoundaryLocationAndDuneOutput(); + + // Assert + Assert.AreEqual(AssessmentSectionComposition.Dike, assessmentSection.Composition); + AssertFailureMechanismsHaveAllPossibleCalculationConfigurations(assessmentSection); + Assert.True(assessmentSection.GrassCoverErosionOutwards.HydraulicBoundaryLocations.All(loc => !(loc.DesignWaterLevelCalculation.HasOutput + && loc.WaveHeightCalculation.HasOutput))); + Assert.True(assessmentSection.DuneErosion.DuneLocations.All(dl => dl.Output == null)); + } + + [Test] + [TestCase(AssessmentSectionComposition.Dike, TestName = "GetAssessmentSectionWithAllCalculationConfigurationsWithoutHydraulicBoundaryLocationAndDuneOutput_Composition_CalculationsAndComposition(Dike)")] + [TestCase(AssessmentSectionComposition.DikeAndDune, TestName = "GetAssessmentSectionWithAllCalculationConfigurationsWithoutHydraulicBoundaryLocationAndDuneOutput_Composition_CalculationsAndComposition(DikeAndDune)")] + [TestCase(AssessmentSectionComposition.Dune, TestName = "GetAssessmentSectionWithAllCalculationConfigurationsWithoutHydraulicBoundaryLocationAndDuneOutput_Composition_CalculationsAndComposition(Dune)")] + public void GetAssessmentSectionWithAllCalculationConfigurationsWithoutHydraulicBoundaryLocationAndDuneOutput_CompositionGiven_ReturnWithOnlyCalculationOutputsAndComposition( + AssessmentSectionComposition composition) + { + // Call + AssessmentSection assessmentSection = TestDataGenerator.GetAssessmentSectionWithAllCalculationConfigurationsWithoutHydraulicBoundaryLocationAndDuneOutput(composition); + + // Assert + Assert.AreEqual(composition, assessmentSection.Composition); + AssertFailureMechanismsHaveAllPossibleCalculationConfigurations(assessmentSection); + Assert.True(assessmentSection.GrassCoverErosionOutwards.HydraulicBoundaryLocations.All(loc => !(loc.DesignWaterLevelCalculation.HasOutput + && loc.WaveHeightCalculation.HasOutput))); + Assert.True(assessmentSection.DuneErosion.DuneLocations.All(dl => dl.Output == null)); + } + + [Test] + public void GetAssessmentSectionWithAllCalculationConfigurationsWithoutCalculationOutput_DefaultComposition_ReturnWithOnlyHydraulicBoundaryLocationAndDuneLocationOutputsAndComposition() + { + // Call + AssessmentSection assessmentSection = TestDataGenerator.GetAssessmentSectionWithAllCalculationConfigurationsWithoutCalculationOutput(); + + // Assert + Assert.AreEqual(AssessmentSectionComposition.Dike, assessmentSection.Composition); + AssertFailureMechanismsHaveAllCalculationConfigurationsWithoutCalculationOutputs(assessmentSection); + Assert.False(assessmentSection.GetFailureMechanisms().SelectMany(fm => fm.Calculations).All(calc => calc.HasOutput)); + Assert.True(assessmentSection.GrassCoverErosionOutwards.HydraulicBoundaryLocations.All(loc => loc.DesignWaterLevelCalculation.HasOutput + && loc.WaveHeightCalculation.HasOutput)); + + DuneErosionFailureMechanism duneErosionFailureMechanism = assessmentSection.GetFailureMechanisms() + .OfType() + .Single(); + AssertDuneErosionFailureMechanismCalculationConfigurationsWithoutOutputs(duneErosionFailureMechanism); + AssertDuneErosionFailureMechanismCalculationConfigurationsWithOutputs(duneErosionFailureMechanism); + } + + [Test] + [TestCase(AssessmentSectionComposition.Dike, TestName = "GetAssessmentSectionWithAllCalculationConfigurationsWithoutCalculationOutput_WithComposition_CompositionSetAndOnlyHydraulicOutputs(Dike)")] + [TestCase(AssessmentSectionComposition.DikeAndDune, TestName = "GetAssessmentSectionWithAllCalculationConfigurationsWithoutCalculationOutput_CompositionGiven_CompositionSetAndOnlyHydraulicOutputs(DikeAndDune)")] + [TestCase(AssessmentSectionComposition.Dune, TestName = "GetAssessmentSectionWithAllCalculationConfigurationsWithoutCalculationOutput_CompositionGiven_CompositionSetAndOnlyHydraulicOutputs(Dune)")] + public void GetAssessmentSectionWithAllCalculationConfigurationsWithoutCalculationOutput_CompositionGiven_CompositionSetAndReturnWithOnlyHydraulicBoundaryLocationAndDuneLocationOutputs( + AssessmentSectionComposition composition) + { + // Call + AssessmentSection assessmentSection = TestDataGenerator.GetAssessmentSectionWithAllCalculationConfigurationsWithoutCalculationOutput(composition); + + // Assert + Assert.AreEqual(composition, assessmentSection.Composition); + AssertFailureMechanismsHaveAllCalculationConfigurationsWithoutCalculationOutputs(assessmentSection); + Assert.False(assessmentSection.GetFailureMechanisms().SelectMany(fm => fm.Calculations).All(calc => calc.HasOutput)); + Assert.True(assessmentSection.GrassCoverErosionOutwards.HydraulicBoundaryLocations.All(loc => loc.DesignWaterLevelCalculation.HasOutput + && loc.WaveHeightCalculation.HasOutput)); + + DuneErosionFailureMechanism duneErosionFailureMechanism = assessmentSection.GetFailureMechanisms() + .OfType() + .Single(); + AssertDuneErosionFailureMechanismCalculationConfigurationsWithoutOutputs(duneErosionFailureMechanism); + AssertDuneErosionFailureMechanismCalculationConfigurationsWithOutputs(duneErosionFailureMechanism); + } + + private static void AssertFailureMechanismsHaveAllPossibleCalculationConfigurations(IAssessmentSection assessmentSection) + { + var containsClosingStructuresFailureMechanism = false; + var containsGrassCoverErosionInwardsFailureMechanism = false; + var containsGrassCoverErosionOutwardsFailureMechanism = false; + var containsHeightStructuresFailureMechanism = false; + var containsPipingFailureMechanism = false; + var containsStabilityPointStructuresFailureMechanism = false; + var containsStabilityStoneCoverFailureMechanism = false; + var containsWaveImpactAsphaltCoverFailureMechanism = false; + var containsDuneErosionFailureMechanism = false; + var containsMacroStabilityInwardsFailureMechanism = false; + + foreach (IFailureMechanism failureMechanism in assessmentSection.GetFailureMechanisms()) + { + var closingStructuresFailureMechanism = failureMechanism as ClosingStructuresFailureMechanism; + var grassCoverErosionInwardsFailureMechanism = failureMechanism as GrassCoverErosionInwardsFailureMechanism; + var grassCoverErosionOutwardsFailureMechanism = failureMechanism as GrassCoverErosionOutwardsFailureMechanism; + var heightStructuresFailureMechanism = failureMechanism as HeightStructuresFailureMechanism; + var pipingFailureMechanism = failureMechanism as PipingFailureMechanism; + var stabilityPointStructuresFailureMechanism = failureMechanism as StabilityPointStructuresFailureMechanism; + var stabilityStoneCoverFailureMechanism = failureMechanism as StabilityStoneCoverFailureMechanism; + var waveImpactAsphaltCoverFailureMechanism = failureMechanism as WaveImpactAsphaltCoverFailureMechanism; + var duneErosionFailureMechanism = failureMechanism as DuneErosionFailureMechanism; + var macroStabilityInwardsFailureMechanism = failureMechanism as MacroStabilityInwardsFailureMechanism; + + if (closingStructuresFailureMechanism != null) + { + AssertHasForeshoreProfiles(closingStructuresFailureMechanism); + AssertClosingStructureFailureMechanismCalculationConfigurationsWithOutputs(closingStructuresFailureMechanism); + AssertClosingStructureFailureMechanismCalculationConfigurationsWithoutOutputs(closingStructuresFailureMechanism); + containsClosingStructuresFailureMechanism = true; + } + + if (grassCoverErosionInwardsFailureMechanism != null) + { + AssertHasDikeProfiles(grassCoverErosionInwardsFailureMechanism); + AssertGrassCoverErosionInwardsFailureMechanismCalculationConfigurationsWithOutputs(grassCoverErosionInwardsFailureMechanism); + AssertGrassCoverErosionInwardsFailureMechanismCalculationConfigurationsWithoutOutputs(grassCoverErosionInwardsFailureMechanism); + containsGrassCoverErosionInwardsFailureMechanism = true; + } + + if (grassCoverErosionOutwardsFailureMechanism != null) + { + AssertHasForeshoreProfiles(grassCoverErosionOutwardsFailureMechanism); + AssertGrassCoverErosionOutwardsFailureMechanismCalculationConfigurationsWithOutputs(grassCoverErosionOutwardsFailureMechanism); + AssertGrassCoverErosionOutwardsFailureMechanismCalculationConfigurationsWithoutOutputs(grassCoverErosionOutwardsFailureMechanism); + containsGrassCoverErosionOutwardsFailureMechanism = true; + } + + if (heightStructuresFailureMechanism != null) + { + AssertHasForeshoreProfiles(heightStructuresFailureMechanism); + AssertHeightStructuresFailureMechanismCalculationConfigurationsWithOutputs(heightStructuresFailureMechanism); + AssertHeightStructuresFailureMechanismCalculationConfigurationsWithoutOutputs(heightStructuresFailureMechanism); + containsHeightStructuresFailureMechanism = true; + } + + if (pipingFailureMechanism != null) + { + PipingTestDataGeneratorHelper.AssertHasStochasticSoilModels(pipingFailureMechanism); + PipingTestDataGeneratorHelper.AssertHasSurfaceLines(pipingFailureMechanism); + PipingTestDataGeneratorHelper.AssertHasAllPossibleCalculationConfigurationsWithOutputs(pipingFailureMechanism); + PipingTestDataGeneratorHelper.AssertHasAllPossibleCalculationConfigurationsWithoutOutputs(pipingFailureMechanism); + containsPipingFailureMechanism = true; + } + + if (stabilityPointStructuresFailureMechanism != null) + { + AssertHasForeshoreProfiles(stabilityPointStructuresFailureMechanism); + AssertStabilityPointStructuresFailureMechanismCalculationConfigurationsWithOutputs(stabilityPointStructuresFailureMechanism); + AssertStabilityPointStructuresFailureMechanismCalculationConfigurationsWithoutOutputs(stabilityPointStructuresFailureMechanism); + containsStabilityPointStructuresFailureMechanism = true; + } + + if (stabilityStoneCoverFailureMechanism != null) + { + AssertHasForeshoreProfiles(stabilityStoneCoverFailureMechanism); + AssertStabilityStoneCoverFailureMechanismCalculationConfigurationsWithOutputs(stabilityStoneCoverFailureMechanism); + AssertStabilityStoneCoverFailureMechanismCalculationConfigurationsWithoutOutputs(stabilityStoneCoverFailureMechanism); + containsStabilityStoneCoverFailureMechanism = true; + } + + if (waveImpactAsphaltCoverFailureMechanism != null) + { + AssertHasForeshoreProfiles(waveImpactAsphaltCoverFailureMechanism); + AssertWaveImpactAsphaltCoverFailureMechanismCalculationConfigurationsWithOutputs(waveImpactAsphaltCoverFailureMechanism); + AssertWaveImpactAsphaltCoverFailureMechanismCalculationConfigurationsWithoutOutputs(waveImpactAsphaltCoverFailureMechanism); + containsWaveImpactAsphaltCoverFailureMechanism = true; + } + + if (duneErosionFailureMechanism != null) + { + containsDuneErosionFailureMechanism = true; + } + + if (macroStabilityInwardsFailureMechanism != null) + { + MacroStabilityInwardsTestDataGeneratorHelper.AssertHasStochasticSoilModels(macroStabilityInwardsFailureMechanism); + MacroStabilityInwardsTestDataGeneratorHelper.AssertHasSurfaceLines(macroStabilityInwardsFailureMechanism); + MacroStabilityInwardsTestDataGeneratorHelper.AssertHasAllPossibleCalculationConfigurationsWithOutputs(macroStabilityInwardsFailureMechanism); + MacroStabilityInwardsTestDataGeneratorHelper.AssertHasAllPossibleCalculationConfigurationsWithoutOutputs(macroStabilityInwardsFailureMechanism); + containsMacroStabilityInwardsFailureMechanism = true; + } + } + + Assert.IsTrue(containsClosingStructuresFailureMechanism); + Assert.IsTrue(containsGrassCoverErosionInwardsFailureMechanism); + Assert.IsTrue(containsGrassCoverErosionOutwardsFailureMechanism); + Assert.IsTrue(containsHeightStructuresFailureMechanism); + Assert.IsTrue(containsPipingFailureMechanism); + Assert.IsTrue(containsStabilityPointStructuresFailureMechanism); + Assert.IsTrue(containsStabilityStoneCoverFailureMechanism); + Assert.IsTrue(containsWaveImpactAsphaltCoverFailureMechanism); + Assert.IsTrue(containsDuneErosionFailureMechanism); + Assert.IsTrue(containsMacroStabilityInwardsFailureMechanism); + } + + private static void AssertFailureMechanismsHaveAllCalculationConfigurationsWithoutCalculationOutputs(IAssessmentSection assessmentSection) + { + var containsClosingStructuresFailureMechanism = false; + var containsGrassCoverErosionInwardsFailureMechanism = false; + var containsGrassCoverErosionOutwardsFailureMechanism = false; + var containsHeightStructuresFailureMechanism = false; + var containsPipingFailureMechanism = false; + var containsStabilityPointStructuresFailureMechanism = false; + var containsStabilityStoneCoverFailureMechanism = false; + var containsWaveImpactAsphaltCoverFailureMechanism = false; + var containsDuneErosionFailureMechanism = false; + var containsMacroStabilityInwardsFailureMechanism = false; + + foreach (IFailureMechanism failureMechanism in assessmentSection.GetFailureMechanisms()) + { + var closingStructuresFailureMechanism = failureMechanism as ClosingStructuresFailureMechanism; + var grassCoverErosionInwardsFailureMechanism = failureMechanism as GrassCoverErosionInwardsFailureMechanism; + var coverErosionOutwards = failureMechanism as GrassCoverErosionOutwardsFailureMechanism; + var heightStructuresFailureMechanism = failureMechanism as HeightStructuresFailureMechanism; + var pipingFailureMechanism = failureMechanism as PipingFailureMechanism; + var stabilityPointStructuresFailureMechanism = failureMechanism as StabilityPointStructuresFailureMechanism; + var stabilityStoneCoverFailureMechanism = failureMechanism as StabilityStoneCoverFailureMechanism; + var waveImpactAsphaltCoverFailureMechanism = failureMechanism as WaveImpactAsphaltCoverFailureMechanism; + var duneErosionFailureMechanism = failureMechanism as DuneErosionFailureMechanism; + var macroStabilityInwardsFailureMechanism = failureMechanism as MacroStabilityInwardsFailureMechanism; + + if (closingStructuresFailureMechanism != null) + { + AssertHasForeshoreProfiles(closingStructuresFailureMechanism); + AssertClosingStructureFailureMechanismCalculationConfigurationsWithoutOutputs(closingStructuresFailureMechanism); + containsClosingStructuresFailureMechanism = true; + } + + if (grassCoverErosionInwardsFailureMechanism != null) + { + AssertHasDikeProfiles(grassCoverErosionInwardsFailureMechanism); + AssertGrassCoverErosionInwardsFailureMechanismCalculationConfigurationsWithoutOutputs(grassCoverErosionInwardsFailureMechanism); + containsGrassCoverErosionInwardsFailureMechanism = true; + } + + if (coverErosionOutwards != null) + { + AssertHasForeshoreProfiles(coverErosionOutwards); + AssertGrassCoverErosionOutwardsFailureMechanismCalculationConfigurationsWithoutOutputs(coverErosionOutwards); + containsGrassCoverErosionOutwardsFailureMechanism = true; + } + + if (heightStructuresFailureMechanism != null) + { + AssertHasForeshoreProfiles(heightStructuresFailureMechanism); + AssertHeightStructuresFailureMechanismCalculationConfigurationsWithoutOutputs(heightStructuresFailureMechanism); + containsHeightStructuresFailureMechanism = true; + } + + if (pipingFailureMechanism != null) + { + PipingTestDataGeneratorHelper.AssertHasStochasticSoilModels(pipingFailureMechanism); + PipingTestDataGeneratorHelper.AssertHasSurfaceLines(pipingFailureMechanism); + PipingTestDataGeneratorHelper.AssertHasAllPossibleCalculationConfigurationsWithoutOutputs(pipingFailureMechanism); + containsPipingFailureMechanism = true; + } + + if (stabilityPointStructuresFailureMechanism != null) + { + AssertHasForeshoreProfiles(stabilityPointStructuresFailureMechanism); + AssertStabilityPointStructuresFailureMechanismCalculationConfigurationsWithoutOutputs(stabilityPointStructuresFailureMechanism); + containsStabilityPointStructuresFailureMechanism = true; + } + + if (stabilityStoneCoverFailureMechanism != null) + { + AssertHasForeshoreProfiles(stabilityStoneCoverFailureMechanism); + AssertStabilityStoneCoverFailureMechanismCalculationConfigurationsWithoutOutputs(stabilityStoneCoverFailureMechanism); + containsStabilityStoneCoverFailureMechanism = true; + } + + if (waveImpactAsphaltCoverFailureMechanism != null) + { + AssertHasForeshoreProfiles(waveImpactAsphaltCoverFailureMechanism); + AssertWaveImpactAsphaltCoverFailureMechanismCalculationConfigurationsWithoutOutputs(waveImpactAsphaltCoverFailureMechanism); + containsWaveImpactAsphaltCoverFailureMechanism = true; + } + + if (duneErosionFailureMechanism != null) + { + containsDuneErosionFailureMechanism = true; + } + + if (macroStabilityInwardsFailureMechanism != null) + { + MacroStabilityInwardsTestDataGeneratorHelper.AssertHasStochasticSoilModels(macroStabilityInwardsFailureMechanism); + MacroStabilityInwardsTestDataGeneratorHelper.AssertHasSurfaceLines(macroStabilityInwardsFailureMechanism); + MacroStabilityInwardsTestDataGeneratorHelper.AssertHasAllPossibleCalculationConfigurationsWithoutOutputs(macroStabilityInwardsFailureMechanism); + containsMacroStabilityInwardsFailureMechanism = true; + } + } + + Assert.IsTrue(containsClosingStructuresFailureMechanism); + Assert.IsTrue(containsGrassCoverErosionOutwardsFailureMechanism); + Assert.IsTrue(containsHeightStructuresFailureMechanism); + Assert.IsTrue(containsPipingFailureMechanism); + Assert.IsTrue(containsStabilityPointStructuresFailureMechanism); + Assert.IsTrue(containsStabilityStoneCoverFailureMechanism); + Assert.IsTrue(containsWaveImpactAsphaltCoverFailureMechanism); + Assert.IsTrue(containsDuneErosionFailureMechanism); + Assert.IsTrue(containsGrassCoverErosionInwardsFailureMechanism); + Assert.IsTrue(containsMacroStabilityInwardsFailureMechanism); + } + + #region Grass Cover Erosion Inwards + + [Test] + public void GetGrassCoverErosionInwardsFailureMechanismWithAllCalculationConfigurations_ReturnsAllPossibleCalculationConfigurations() + { + // Call + GrassCoverErosionInwardsFailureMechanism failureMechanism = TestDataGenerator.GetGrassCoverErosionInwardsFailureMechanismWithAllCalculationConfigurations(); + + // Assert + AssertHasDikeProfiles(failureMechanism); + AssertGrassCoverErosionInwardsFailureMechanismCalculationConfigurationsWithOutputs(failureMechanism); + AssertGrassCoverErosionInwardsFailureMechanismCalculationConfigurationsWithoutOutputs(failureMechanism); + } + + private static void AssertGrassCoverErosionInwardsFailureMechanismCalculationConfigurationsWithOutputs(GrassCoverErosionInwardsFailureMechanism failureMechanism) + { + IEnumerable calculationRoot = failureMechanism.CalculationsGroup.Children; + AssertGrassCoverErosionInwardsCalculationGroupWithOutput(calculationRoot.OfType()); + + CalculationGroup nestedCalculations = calculationRoot.OfType().First(); + AssertGrassCoverErosionInwardsCalculationGroupWithOutput(nestedCalculations.Children.OfType()); + } + + private static void AssertGrassCoverErosionInwardsFailureMechanismCalculationConfigurationsWithoutOutputs(GrassCoverErosionInwardsFailureMechanism failureMechanism) + { + IEnumerable calculationRoot = failureMechanism.CalculationsGroup.Children; + AssertGrassCoverErosionInwardsCalculationGroupWithoutOutput(calculationRoot.OfType()); + + CalculationGroup nestedCalculations = calculationRoot.OfType().First(); + AssertGrassCoverErosionInwardsCalculationGroupWithoutOutput(nestedCalculations.Children.OfType()); + } + + private static void AssertGrassCoverErosionInwardsCalculationGroupWithOutput(IEnumerable children) + { + AssertCalculationConfig(children, true, false, true); + AssertCalculationConfig(children, true, true, true); + } + + private static void AssertGrassCoverErosionInwardsCalculationGroupWithoutOutput(IEnumerable children) + { + AssertCalculationConfig(children, false, false, false); + AssertCalculationConfig(children, true, false, false); + AssertCalculationConfig(children, true, true, false); + } + + private static void AssertCalculationConfig( + IEnumerable children, bool hasHydraulicBoundaryLocation, bool hasDikeProfile, bool hasOutput) + { + Assert.NotNull(children.FirstOrDefault(calc => calc.InputParameters.HydraulicBoundaryLocation != null == hasHydraulicBoundaryLocation + && calc.InputParameters.DikeProfile != null == hasDikeProfile + && calc.HasOutput == hasOutput)); + } + + private static void AssertHasDikeProfiles(GrassCoverErosionInwardsFailureMechanism failureMechanism) + { + CollectionAssert.IsNotEmpty(failureMechanism.DikeProfiles); + } + + #endregion + + #region Stability Stone Cover + + [Test] + public void GetStabilityStoneCoverFailureMechanismWithAllCalculationConfigurations_ReturnsAllPossibleCalculationConfigurations() + { + // Call + StabilityStoneCoverFailureMechanism failureMechanism = TestDataGenerator.GetStabilityStoneCoverFailureMechanismWithAllCalculationConfigurations(); + + // Assert + AssertHasForeshoreProfiles(failureMechanism); + AssertStabilityStoneCoverFailureMechanismCalculationConfigurationsWithOutputs(failureMechanism); + AssertStabilityStoneCoverFailureMechanismCalculationConfigurationsWithoutOutputs(failureMechanism); + } + + private static void AssertStabilityStoneCoverFailureMechanismCalculationConfigurationsWithOutputs( + StabilityStoneCoverFailureMechanism failureMechanism) + { + IEnumerable calculationRoot = failureMechanism.WaveConditionsCalculationGroup.Children; + AssertStabilityStoneCoverWaveConditionsCalculationGroupWithOutput( + calculationRoot.OfType()); + + CalculationGroup nestedCalculations = calculationRoot.OfType().First(); + AssertStabilityStoneCoverWaveConditionsCalculationGroupWithOutput( + nestedCalculations.Children.OfType()); + } + + private static void AssertStabilityStoneCoverFailureMechanismCalculationConfigurationsWithoutOutputs(StabilityStoneCoverFailureMechanism failureMechanism) + { + IEnumerable calculationRoot = failureMechanism.WaveConditionsCalculationGroup.Children; + AssertStabilityStoneCoverWaveCalculationGroupWithoutOutput(calculationRoot.OfType()); + + CalculationGroup nestedCalculations = calculationRoot.OfType().First(); + AssertStabilityStoneCoverWaveCalculationGroupWithoutOutput(nestedCalculations.Children.OfType()); + } + + private static void AssertStabilityStoneCoverWaveConditionsCalculationGroupWithOutput(IEnumerable children) + { + AssertCalculationConfig(children, true, false, true); + AssertCalculationConfig(children, true, true, true); + } + + private static void AssertStabilityStoneCoverWaveCalculationGroupWithoutOutput(IEnumerable children) + { + AssertCalculationConfig(children, false, false, false); + AssertCalculationConfig(children, true, false, false); + AssertCalculationConfig(children, true, true, false); + } + + private static void AssertCalculationConfig( + IEnumerable children, bool hasHydraulicBoundaryLocation, bool hasDikeProfile, bool hasOutput) + { + Assert.NotNull(children.FirstOrDefault(calc => calc.InputParameters.HydraulicBoundaryLocation != null == hasHydraulicBoundaryLocation + && calc.InputParameters.ForeshoreProfile != null == hasDikeProfile + && calc.HasOutput == hasOutput)); + } + + private static void AssertHasForeshoreProfiles(StabilityStoneCoverFailureMechanism failureMechanism) + { + CollectionAssert.IsNotEmpty(failureMechanism.ForeshoreProfiles); + } + + #endregion + + #region Wave Impact Asphalt Cover + + [Test] + public void GetWaveImpactAsphaltCoverFailureMechanismWithAllCalculationConfigurations_ReturnsAllPossibleCalculationConfigurations() + { + // Call + WaveImpactAsphaltCoverFailureMechanism failureMechanism = TestDataGenerator.GetWaveImpactAsphaltCoverFailureMechanismWithAllCalculationConfigurations(); + + // Assert + AssertHasForeshoreProfiles(failureMechanism); + AssertWaveImpactAsphaltCoverFailureMechanismCalculationConfigurationsWithOutputs(failureMechanism); + AssertWaveImpactAsphaltCoverFailureMechanismCalculationConfigurationsWithoutOutputs(failureMechanism); + } + + private static void AssertWaveImpactAsphaltCoverFailureMechanismCalculationConfigurationsWithOutputs( + WaveImpactAsphaltCoverFailureMechanism failureMechanism) + { + IEnumerable calculationRoot = failureMechanism.WaveConditionsCalculationGroup.Children; + AssertWaveImpactAsphaltCoverCalculationGroupWithOutput( + calculationRoot.OfType()); + + CalculationGroup nestedCalculations = calculationRoot.OfType().First(); + AssertWaveImpactAsphaltCoverCalculationGroupWithOutput( + nestedCalculations.Children.OfType()); + } + + private static void AssertWaveImpactAsphaltCoverFailureMechanismCalculationConfigurationsWithoutOutputs( + WaveImpactAsphaltCoverFailureMechanism failureMechanism) + { + IEnumerable calculationRoot = failureMechanism.WaveConditionsCalculationGroup.Children; + AssertWaveImpactAsphaltCoverCalculationGroupWithoutOutput(calculationRoot.OfType()); + + CalculationGroup nestedCalculations = calculationRoot.OfType().First(); + AssertWaveImpactAsphaltCoverCalculationGroupWithoutOutput(nestedCalculations.Children.OfType()); + } + + private static void AssertWaveImpactAsphaltCoverCalculationGroupWithOutput(IEnumerable children) + { + AssertCalculationConfig(children, true, false, true); + AssertCalculationConfig(children, true, true, true); + } + + private static void AssertWaveImpactAsphaltCoverCalculationGroupWithoutOutput(IEnumerable children) + { + AssertCalculationConfig(children, false, false, false); + AssertCalculationConfig(children, true, false, false); + AssertCalculationConfig(children, true, true, false); + } + + private static void AssertCalculationConfig( + IEnumerable children, bool hasHydraulicBoundaryLocation, bool hasDikeProfile, bool hasOutput) + { + Assert.NotNull(children.FirstOrDefault(calc => calc.InputParameters.HydraulicBoundaryLocation != null == hasHydraulicBoundaryLocation + && calc.InputParameters.ForeshoreProfile != null == hasDikeProfile + && calc.HasOutput == hasOutput)); + } + + private static void AssertHasForeshoreProfiles(WaveImpactAsphaltCoverFailureMechanism failureMechanism) + { + CollectionAssert.IsNotEmpty(failureMechanism.ForeshoreProfiles); + } + + #endregion + + #region Grass Cover Erosion Outwards + + [Test] + public void GetGrassCoverErosionOutwardsFailureMechanismWithAllCalculationConfigurations_ReturnsAllPossibleCalculationConfigurations() + { + // Call + GrassCoverErosionOutwardsFailureMechanism failureMechanism = TestDataGenerator.GetGrassCoverErosionOutwardsFailureMechanismWithAllCalculationConfigurations(); + + // Assert + Assert.IsTrue(failureMechanism.HydraulicBoundaryLocations.All(loc => loc.DesignWaterLevelCalculation.HasOutput + && loc.WaveHeightCalculation.HasOutput)); + AssertHasForeshoreProfiles(failureMechanism); + AssertGrassCoverErosionOutwardsFailureMechanismCalculationConfigurationsWithOutputs(failureMechanism); + AssertGrassCoverErosionOutwardsFailureMechanismCalculationConfigurationsWithoutOutputs(failureMechanism); + } + + private static void AssertGrassCoverErosionOutwardsFailureMechanismCalculationConfigurationsWithOutputs(GrassCoverErosionOutwardsFailureMechanism failureMechanism) + { + IEnumerable calculationRoot = failureMechanism.WaveConditionsCalculationGroup.Children; + AssertGrassCoverErosionCalculationGroupWithOutput(calculationRoot.OfType()); + + CalculationGroup nestedCalculations = calculationRoot.OfType().First(); + AssertGrassCoverErosionCalculationGroupWithOutput(nestedCalculations.Children.OfType()); + } + + private static void AssertGrassCoverErosionOutwardsFailureMechanismCalculationConfigurationsWithoutOutputs(GrassCoverErosionOutwardsFailureMechanism failureMechanism) + { + IEnumerable calculationRoot = failureMechanism.WaveConditionsCalculationGroup.Children; + AssertGrassCoverErosionCalculationGroupWithoutOutput(calculationRoot.OfType()); + + CalculationGroup nestedCalculations = calculationRoot.OfType().First(); + AssertGrassCoverErosionCalculationGroupWithoutOutput(nestedCalculations.Children.OfType()); + } + + private static void AssertGrassCoverErosionCalculationGroupWithOutput(IEnumerable children) + { + AssertCalculationConfig(children, true, false, true); + AssertCalculationConfig(children, true, true, true); + } + + private static void AssertGrassCoverErosionCalculationGroupWithoutOutput(IEnumerable children) + { + AssertCalculationConfig(children, false, false, false); + AssertCalculationConfig(children, true, false, false); + AssertCalculationConfig(children, true, true, false); + } + + private static void AssertCalculationConfig( + IEnumerable children, bool hasHydraulicBoundaryLocation, bool hasDikeProfile, bool hasOutput) + { + Assert.NotNull(children.FirstOrDefault(calc => calc.InputParameters.HydraulicBoundaryLocation != null == hasHydraulicBoundaryLocation + && calc.InputParameters.ForeshoreProfile != null == hasDikeProfile + && calc.HasOutput == hasOutput)); + } + + private static void AssertHasForeshoreProfiles(GrassCoverErosionOutwardsFailureMechanism failureMechanism) + { + CollectionAssert.IsNotEmpty(failureMechanism.ForeshoreProfiles); + } + + #endregion + + #region Dune Erosion + + private static void AssertDuneErosionFailureMechanismCalculationConfigurationsWithOutputs(DuneErosionFailureMechanism failureMechanism) + { + Assert.True(failureMechanism.DuneLocations.Any(dl => dl.Output != null)); + } + + private static void AssertDuneErosionFailureMechanismCalculationConfigurationsWithoutOutputs(DuneErosionFailureMechanism failureMechanism) + { + Assert.True(failureMechanism.DuneLocations.Any(dl => dl.Output == null)); + } + + #endregion + + #region Structures + + #region ClosingStructures + + [Test] + public void GetClosingStructuresFailureMechanismWithAllCalculationConfigurations_ReturnsAllPossibleCalculationConfigurations() + { + // Call + ClosingStructuresFailureMechanism failureMechanism = TestDataGenerator.GetClosingStructuresFailureMechanismWithAllCalculationConfigurations(); + + // Assert + AssertHasForeshoreProfiles(failureMechanism); + AssertClosingStructureFailureMechanismCalculationConfigurationsWithOutputs(failureMechanism); + AssertClosingStructureFailureMechanismCalculationConfigurationsWithoutOutputs(failureMechanism); + } + + private static void AssertClosingStructureFailureMechanismCalculationConfigurationsWithOutputs(ClosingStructuresFailureMechanism failureMechanism) + { + IEnumerable calculationsRoot = failureMechanism.CalculationsGroup.Children; + AssertStructuresCalculationGroupConfigurationWithOutputs( + calculationsRoot.OfType>()); + + CalculationGroup nestedCalculations = calculationsRoot.OfType().First(); + AssertStructuresCalculationGroupConfigurationWithOutputs( + nestedCalculations.Children.OfType>()); + } + + private static void AssertClosingStructureFailureMechanismCalculationConfigurationsWithoutOutputs(ClosingStructuresFailureMechanism failureMechanism) + { + IEnumerable calculationsRoot = failureMechanism.CalculationsGroup.Children; + AssertStructuresCalculationGroupConfigurationWithoutOutputs( + calculationsRoot.OfType>()); + + CalculationGroup nestedCalculations = calculationsRoot.OfType().First(); + AssertStructuresCalculationGroupConfigurationWithoutOutputs( + nestedCalculations.Children.OfType>()); + } + + private static void AssertHasForeshoreProfiles(ClosingStructuresFailureMechanism failureMechanism) + { + CollectionAssert.IsNotEmpty(failureMechanism.ForeshoreProfiles); + } + + #endregion + + #region StabilityPointStructures + + [Test] + public void GetStabilityPointStructuresFailureMechanismWithAllCalculationConfigurations_ReturnsAllPossibleCalculationConfigurations() + { + // Call + StabilityPointStructuresFailureMechanism failureMechanism = TestDataGenerator.GetStabilityPointStructuresFailureMechanismWithAllCalculationConfigurations(); + + // Assert + AssertHasForeshoreProfiles(failureMechanism); + AssertStabilityPointStructuresFailureMechanismCalculationConfigurationsWithOutputs(failureMechanism); + AssertStabilityPointStructuresFailureMechanismCalculationConfigurationsWithoutOutputs(failureMechanism); + } + + private static void AssertStabilityPointStructuresFailureMechanismCalculationConfigurationsWithOutputs(StabilityPointStructuresFailureMechanism failureMechanism) + { + IEnumerable calculationsRoot = failureMechanism.CalculationsGroup.Children; + AssertStructuresCalculationGroupConfigurationWithOutputs( + calculationsRoot.OfType>()); + + CalculationGroup nestedCalculations = calculationsRoot.OfType().First(); + AssertStructuresCalculationGroupConfigurationWithOutputs( + nestedCalculations.Children.OfType>()); + } + + private static void AssertStabilityPointStructuresFailureMechanismCalculationConfigurationsWithoutOutputs(StabilityPointStructuresFailureMechanism failureMechanism) + { + IEnumerable calculationsRoot = failureMechanism.CalculationsGroup.Children; + AssertStructuresCalculationGroupConfigurationWithoutOutputs( + calculationsRoot.OfType>()); + + CalculationGroup nestedCalculations = calculationsRoot.OfType().First(); + AssertStructuresCalculationGroupConfigurationWithoutOutputs( + nestedCalculations.Children.OfType>()); + } + + private static void AssertHasForeshoreProfiles(StabilityPointStructuresFailureMechanism failureMechanism) + { + CollectionAssert.IsNotEmpty(failureMechanism.ForeshoreProfiles); + } + + #endregion + + #region HeightStructures + + [Test] + public void GetHeightStructuresFailureMechanismWithAllCalculationConfigurations_ReturnsAllPossibleCalculationConfigurations() + { + // Call + HeightStructuresFailureMechanism failureMechanism = TestDataGenerator.GetHeightStructuresFailureMechanismWithAlLCalculationConfigurations(); + + // Assert + AssertHasForeshoreProfiles(failureMechanism); + AssertHeightStructuresFailureMechanismCalculationConfigurationsWithOutputs(failureMechanism); + AssertHeightStructuresFailureMechanismCalculationConfigurationsWithoutOutputs(failureMechanism); + } + + private static void AssertHeightStructuresFailureMechanismCalculationConfigurationsWithOutputs(HeightStructuresFailureMechanism failureMechanism) + { + IEnumerable calculationsRoot = failureMechanism.CalculationsGroup.Children; + AssertStructuresCalculationGroupConfigurationWithOutputs( + calculationsRoot.OfType>()); + + CalculationGroup nestedCalculations = calculationsRoot.OfType().First(); + AssertStructuresCalculationGroupConfigurationWithOutputs( + nestedCalculations.Children.OfType>()); + } + + private static void AssertHeightStructuresFailureMechanismCalculationConfigurationsWithoutOutputs(HeightStructuresFailureMechanism failureMechanism) + { + IEnumerable calculationsRoot = failureMechanism.CalculationsGroup.Children; + AssertStructuresCalculationGroupConfigurationWithoutOutputs( + calculationsRoot.OfType>()); + + CalculationGroup nestedCalculations = calculationsRoot.OfType().First(); + AssertStructuresCalculationGroupConfigurationWithoutOutputs( + nestedCalculations.Children.OfType>()); + } + + private static void AssertHasForeshoreProfiles(HeightStructuresFailureMechanism failureMechanism) + { + CollectionAssert.IsNotEmpty(failureMechanism.ForeshoreProfiles); + } + + #endregion + + private static void AssertStructuresCalculationGroupConfigurationWithOutputs( + IEnumerable> children) + where TStructureBase : StructureBase + where TCalculationInput : StructuresInputBase, new() + { + AssertCalculationConfig(children, true, false, true); + AssertCalculationConfig(children, true, true, true); + } + + private static void AssertStructuresCalculationGroupConfigurationWithoutOutputs( + IEnumerable> children) + where TStructureBase : StructureBase + where TCalculationInput : StructuresInputBase, new() + { + AssertCalculationConfig(children, false, false, false); + AssertCalculationConfig(children, true, false, false); + AssertCalculationConfig(children, true, true, false); + } + + private static void AssertCalculationConfig( + IEnumerable> children, bool hasHydraulicBoundaryLocation, bool hasDikeProfile, bool hasOutput) + where TStructureBase : StructureBase + where TCalculationInput : StructuresInputBase, new() + { + Assert.NotNull(children.FirstOrDefault(calc => calc.InputParameters.HydraulicBoundaryLocation != null == hasHydraulicBoundaryLocation + && calc.InputParameters.ForeshoreProfile != null == hasDikeProfile + && calc.HasOutput == hasOutput)); + } + + #endregion + } +} \ No newline at end of file Index: Ringtoets/Integration/test/Ringtoets.Integration.TestUtil.Test/packages.config =================================================================== diff -u --- Ringtoets/Integration/test/Ringtoets.Integration.TestUtil.Test/packages.config (revision 0) +++ Ringtoets/Integration/test/Ringtoets.Integration.TestUtil.Test/packages.config (revision 5d822eca2d7467c9781a4a3a54d796ac4229e4a3) @@ -0,0 +1,26 @@ + + + + + \ No newline at end of file Index: Ringtoets/Integration/test/Ringtoets.Integration.TestUtil/DataImportHelper.cs =================================================================== diff -u --- Ringtoets/Integration/test/Ringtoets.Integration.TestUtil/DataImportHelper.cs (revision 0) +++ Ringtoets/Integration/test/Ringtoets.Integration.TestUtil/DataImportHelper.cs (revision 5d822eca2d7467c9781a4a3a54d796ac4229e4a3) @@ -0,0 +1,289 @@ +// Copyright (C) Stichting Deltares 2017. All rights reserved. +// +// This file is part of Ringtoets. +// +// Ringtoets is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this program. If not, see . +// +// 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.Collections.Generic; +using System.IO; +using System.Linq; +using Core.Common.Base.Geometry; +using Core.Common.Base.Service; +using Core.Common.Gui.Commands; +using Core.Common.Utils.IO; +using Rhino.Mocks; +using Ringtoets.Common.Data.AssessmentSection; +using Ringtoets.Common.Data.FailureMechanism; +using Ringtoets.Common.Data.Hydraulics; +using Ringtoets.Common.IO.FileImporters; +using Ringtoets.Common.IO.FileImporters.MessageProviders; +using Ringtoets.Common.IO.ReferenceLines; +using Ringtoets.Common.IO.SoilProfile; +using Ringtoets.Common.IO.SurfaceLines; +using Ringtoets.Integration.Data; +using Ringtoets.Integration.Plugin.Handlers; +using Ringtoets.MacroStabilityInwards.Data; +using Ringtoets.MacroStabilityInwards.Data.SoilProfile; +using Ringtoets.MacroStabilityInwards.Plugin.FileImporter; +using Ringtoets.MacroStabilityInwards.Primitives; +using Ringtoets.Piping.Data; +using Ringtoets.Piping.Data.SoilProfile; +using Ringtoets.Piping.Plugin.FileImporter; +using Ringtoets.Piping.Primitives; +using PipingSurfaceLinesCsvImporterConfigurationFactory = Ringtoets.Piping.Plugin.FileImporter.SurfaceLinesCsvImporterConfigurationFactory; +using MacroStabilityInwardsSurfaceLinesCsvImporterConfigurationFactory = Ringtoets.MacroStabilityInwards.Plugin.FileImporter.SurfaceLinesCsvImporterConfigurationFactory; + +namespace Ringtoets.Integration.TestUtil +{ + /// + /// Helper methods related to importing data for integration tests. + /// + public static class DataImportHelper + { + /// + /// Imports the on the . + /// + /// The to import the reference line on. + public static void ImportReferenceLine(AssessmentSection assessmentSection) + { + using (var embeddedResourceFileWriter = new EmbeddedResourceFileWriter(typeof(DataImportHelper).Assembly, + true, + "traject_6-3.shp", + "traject_6-3.dbf", + "traject_6-3.prj", + "traject_6-3.shx")) + { + string filePath = Path.Combine(embeddedResourceFileWriter.TargetFolderPath, "traject_6-3.shp"); + var mocks = new MockRepository(); + var viewCommands = mocks.Stub(); + mocks.ReplayAll(); + var activity = new FileImportActivity(new ReferenceLineImporter(assessmentSection, + new ReferenceLineReplacementHandler(viewCommands), + filePath), + "ReferenceLineImporter"); + activity.Run(); + activity.Finish(); + mocks.VerifyAll(); + } + } + + /// + /// Imports the data for a given . + /// + /// The to import on. + /// The to import on. + /// + /// This will import 283 failure mechanism sections. + /// Imports using . + /// + /// + public static void ImportFailureMechanismSections(AssessmentSection assessmentSection, IFailureMechanism failureMechanism) + { + using (var embeddedResourceFileWriter = new EmbeddedResourceFileWriter(typeof(DataImportHelper).Assembly, + true, + "traject_6-3_vakken.shp", + "traject_6-3_vakken.dbf", + "traject_6-3_vakken.prj", + "traject_6-3_vakken.shx")) + { + string filePath = Path.Combine(embeddedResourceFileWriter.TargetFolderPath, "traject_6-3_vakken.shp"); + var activity = new FileImportActivity(new FailureMechanismSectionsImporter(failureMechanism, assessmentSection.ReferenceLine, filePath), + "FailureMechanismSectionsImporter"); + activity.Run(); + activity.Finish(); + } + } + + /// + /// Imports the data for a given . + /// + /// The to import on. + /// The to import on. + /// + /// This will import the same 283 failure mechanism sections on all failure mechanisms. + /// Does not import using . + /// + /// + public static void ImportFailureMechanismSections(AssessmentSection assessmentSection, IEnumerable targetFailureMechanisms) + { + using (var embeddedResourceFileWriter = new EmbeddedResourceFileWriter(typeof(DataImportHelper).Assembly, + true, + "traject_6-3_vakken.shp", + "traject_6-3_vakken.dbf", + "traject_6-3_vakken.prj", + "traject_6-3_vakken.shx")) + { + IFailureMechanism[] failureMechanisms = targetFailureMechanisms.ToArray(); + for (var i = 0; i < failureMechanisms.Length; i++) + { + if (i == 0) + { + string filePath = Path.Combine(embeddedResourceFileWriter.TargetFolderPath, + "traject_6-3_vakken.shp"); + var importer = new FailureMechanismSectionsImporter(failureMechanisms[i], + assessmentSection.ReferenceLine, + filePath); + importer.Import(); + } + else + { + // Copy same FailureMechanismSection instances to other failure mechanisms + foreach (FailureMechanismSection section in failureMechanisms[0].Sections) + { + FailureMechanismSection clonedSection = DeepCloneSection(section); + failureMechanisms[i].AddSection(clonedSection); + } + } + } + } + } + + /// + /// Imports the for the given . + /// + /// The to import on. + /// This will import 19 Hydraulic boundary locations. + public static void ImportHydraulicBoundaryDatabase(AssessmentSection assessmentSection) + { + using (var embeddedResourceFileWriter = new EmbeddedResourceFileWriter(typeof(DataImportHelper).Assembly, + false, + "HRD dutch coast south.sqlite", + "HLCD.sqlite", + "HRD dutch coast south.config.sqlite")) + using (var hydraulicBoundaryDatabaseImporter = new HydraulicBoundaryDatabaseImporter()) + { + string filePath = Path.Combine(embeddedResourceFileWriter.TargetFolderPath, "HRD dutch coast south.sqlite"); + hydraulicBoundaryDatabaseImporter.Import(assessmentSection, filePath); + } + } + + private static FailureMechanismSection DeepCloneSection(FailureMechanismSection section) + { + return new FailureMechanismSection(section.Name, + section.Points.Select(p => new Point2D(p))); + } + + #region Piping Specific Imports + + /// + /// Imports the data for the + /// of the given . + /// + /// The to import on. + /// This will import 4 surface lines. + public static void ImportPipingSurfaceLines(AssessmentSection assessmentSection) + { + using (var embeddedResourceFileWriter = new EmbeddedResourceFileWriter(typeof(DataImportHelper).Assembly, + true, + "DR6_surfacelines.csv", + "DR6_surfacelines.krp.csv")) + { + string filePath = Path.Combine(embeddedResourceFileWriter.TargetFolderPath, "DR6_surfacelines.csv"); + var activity = new FileImportActivity(new SurfaceLinesCsvImporter( + assessmentSection.Piping.SurfaceLines, + filePath, + new ImportMessageProvider(), + PipingSurfaceLinesCsvImporterConfigurationFactory.CreateReplaceStrategyConfiguration(assessmentSection.Piping, assessmentSection.ReferenceLine)), + "PipingSurfaceLinesCsvImporter") + ; + activity.Run(); + activity.Finish(); + } + } + + /// + /// Imports the data for the + /// of the given . + /// + /// The to import on. + /// This will import 4 soil models with one profile each. + public static void ImportPipingStochasticSoilModels(AssessmentSection assessmentSection) + { + using (var embeddedResourceFileWriter = new EmbeddedResourceFileWriter(typeof(DataImportHelper).Assembly, + true, + "DR6.soil")) + { + string filePath = Path.Combine(embeddedResourceFileWriter.TargetFolderPath, "DR6.soil"); + var activity = new FileImportActivity( + new StochasticSoilModelImporter( + assessmentSection.Piping.StochasticSoilModels, + filePath, + new ImportMessageProvider(), + PipingStochasticSoilModelImporterConfigurationFactory.CreateReplaceStrategyConfiguration(assessmentSection.Piping)), + "StochasticSoilModelImporter"); + activity.Run(); + activity.Finish(); + } + } + + #endregion + + #region MacroStabilityInwards Specific Imports + + /// + /// Imports the data for the + /// of the given . + /// + /// The to import on. + /// This will import 4 surface lines. + public static void ImportMacroStabilityInwardsSurfaceLines(AssessmentSection assessmentSection) + { + using (var embeddedResourceFileWriter = new EmbeddedResourceFileWriter(typeof(DataImportHelper).Assembly, + true, + "DR6_surfacelines.csv", + "DR6_surfacelines.krp.csv")) + { + string filePath = Path.Combine(embeddedResourceFileWriter.TargetFolderPath, "DR6_surfacelines.csv"); + var activity = new FileImportActivity(new SurfaceLinesCsvImporter( + assessmentSection.MacroStabilityInwards.SurfaceLines, + filePath, + new ImportMessageProvider(), + MacroStabilityInwardsSurfaceLinesCsvImporterConfigurationFactory.CreateReplaceStrategyConfiguration(assessmentSection.MacroStabilityInwards, assessmentSection.ReferenceLine)), + "MacroStabilityInwardsSurfaceLinesCsvImporter"); + activity.Run(); + activity.Finish(); + } + } + + /// + /// Imports the data for the + /// of the given . + /// + /// The to import on. + /// This will import 4 soil models with one profile each. + public static void ImportMacroStabilityInwardsStochasticSoilModels(AssessmentSection assessmentSection) + { + using (var embeddedResourceFileWriter = new EmbeddedResourceFileWriter(typeof(DataImportHelper).Assembly, + true, + "DR6.soil")) + { + string filePath = Path.Combine(embeddedResourceFileWriter.TargetFolderPath, "DR6.soil"); + var activity = new FileImportActivity(new StochasticSoilModelImporter( + assessmentSection.MacroStabilityInwards.StochasticSoilModels, + filePath, + new ImportMessageProvider(), + MacroStabilityInwardsStochasticSoilModelImporterConfigurationFactory.CreateReplaceStrategyConfiguration(assessmentSection.MacroStabilityInwards)), + "MacroStabilityInwardsStochasticSoilModelImporter"); + activity.Run(); + activity.Finish(); + } + } + + #endregion + } +} \ No newline at end of file Index: Ringtoets/Integration/test/Ringtoets.Integration.TestUtil/DataUpdateHelper.cs =================================================================== diff -u --- Ringtoets/Integration/test/Ringtoets.Integration.TestUtil/DataUpdateHelper.cs (revision 0) +++ Ringtoets/Integration/test/Ringtoets.Integration.TestUtil/DataUpdateHelper.cs (revision 5d822eca2d7467c9781a4a3a54d796ac4229e4a3) @@ -0,0 +1,97 @@ +// Copyright (C) Stichting Deltares 2017. All rights reserved. +// +// This file is part of Ringtoets. +// +// Ringtoets is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this program. If not, see . +// +// 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.IO; +using Core.Common.Base.Service; +using Core.Common.Utils.IO; +using Ringtoets.Common.Data.AssessmentSection; +using Ringtoets.Common.IO.FileImporters.MessageProviders; +using Ringtoets.Common.IO.SoilProfile; +using Ringtoets.Integration.Data; +using Ringtoets.MacroStabilityInwards.Data.SoilProfile; +using Ringtoets.MacroStabilityInwards.Plugin.FileImporter; +using Ringtoets.Piping.Data; +using Ringtoets.Piping.Data.SoilProfile; +using Ringtoets.Piping.Plugin.FileImporter; + +namespace Ringtoets.Integration.TestUtil +{ + /// + /// Helper methods related to importing data for integration tests. + /// + public static class DataUpdateHelper + { + /// + /// Imports the data for the + /// of the given and updates existing data based upon the imported + /// data. + /// + /// The to import on. + /// When data from is added first, + /// then calling this method will remove soil model 'PK001_0004_Piping', stochastic soil profile 'W1-6_4_1D1' + /// and update the probability of stochastic soil profile '6-3_22' (100% to 50%). + public static void UpdatePipingStochasticSoilModels(AssessmentSection assessmentSection) + { + using (var embeddedResourceFileWriter = new EmbeddedResourceFileWriter(typeof(DataUpdateHelper).Assembly, + true, + "DR6_updated.soil")) + { + string filePath = Path.Combine(embeddedResourceFileWriter.TargetFolderPath, "DR6_updated.soil"); + var activity = new FileImportActivity( + new StochasticSoilModelImporter( + assessmentSection.Piping.StochasticSoilModels, + filePath, + new UpdateMessageProvider(), + PipingStochasticSoilModelImporterConfigurationFactory.CreateUpdateStrategyConfiguration(assessmentSection.Piping)), + "StochasticSoilModelUpdater"); + activity.Run(); + activity.Finish(); + } + } + + /// + /// Imports the data for the + /// of the given and updates existing data based upon the imported + /// data. + /// + /// The to import on. + /// When data from is added first, + /// then calling this method will remove soil model 'PK001_0004_Piping', stochastic soil profile 'W1-6_4_1D1' + /// and update the probability of stochastic soil profile '6-3_22' (100% to 50%). + public static void UpdateMacroStabilityInwardsStochasticSoilModels(AssessmentSection assessmentSection) + { + using (var embeddedResourceFileWriter = new EmbeddedResourceFileWriter(typeof(DataUpdateHelper).Assembly, + true, + "DR6_updated.soil")) + { + string filePath = Path.Combine(embeddedResourceFileWriter.TargetFolderPath, "DR6_updated.soil"); + var activity = new FileImportActivity(new StochasticSoilModelImporter( + assessmentSection.MacroStabilityInwards.StochasticSoilModels, + filePath, + new ImportMessageProvider(), + MacroStabilityInwardsStochasticSoilModelImporterConfigurationFactory.CreateUpdateStrategyConfiguration(assessmentSection.MacroStabilityInwards)), + "MacroStabilityInwardsStochasticSoilModelUpdater"); + activity.Run(); + activity.Finish(); + } + } + } +} \ No newline at end of file Index: Ringtoets/Integration/test/Ringtoets.Integration.TestUtil/EmbeddedResources/DR6.soil =================================================================== diff -u Binary files differ Index: Ringtoets/Integration/test/Ringtoets.Integration.TestUtil/EmbeddedResources/DR6_surfacelines.csv =================================================================== diff -u --- Ringtoets/Integration/test/Ringtoets.Integration.TestUtil/EmbeddedResources/DR6_surfacelines.csv (revision 0) +++ Ringtoets/Integration/test/Ringtoets.Integration.TestUtil/EmbeddedResources/DR6_surfacelines.csv (revision 5d822eca2d7467c9781a4a3a54d796ac4229e4a3) @@ -0,0 +1,5 @@ +LOCATIONID;X1;Y1;Z1;.....;Xn;Yn;Zn;(Profiel)A9;A10;A11;A12;A13;A14;A15;A16;A17;A18;A19;A20;A21;A22;A23;A24;A25;A26;A27;A28;A29;A30;A31;A32;A33;A34;A35;A36;A37;A38;A39;A40;A41;A42;A43;A44;A45;A46;A47;A48;A49;A50;A51;A52;A53;A54;A55;A56;A57;A58;A59;A60;A61;A62;A63;A64;A65;A66;A67;A68;A69;A70;A71;A72;A73;A74;A75;A76;A77;A78;A79;A80;A81;A82;A83;A84;A85;A86;A87;A88;A89;A90;A91;A92;A93;A94;A95;A96;A97;A98;A99;A100;A101;A102;A103;A104;A105;A106;A107;A108;A109;A110;A111;A112;A113;A114;A115;A116;A117;A118;A119;A120;A121;A122;A123;A124;A125;A126;A127;A128;A129;A130;A131;A132;A133;A134;A135;A136;A137;A138;A139;A140;A141;A142;A143;A144;A145;A146;A147;A148;A149;A150;A151;A152;A153;A154;A155;A156;A157;A158;A159;A160;A161;A162;A163;A164;A165;A166;A167;A168;A169;A170;A171;A172;A173;A174;A175;A176;A177;A178;A179;A180;A181;A182;A183;A184;A185;A186;A187;A188;A189;A190;A191;A192;A193;A194;A195;A196;A197;A198;A199;A200;A201;A202;A203;A204;A205;A206;A207;A208;A209;A210;A211;A212;A213;A214;A215;A216;A217;A218;A219;A220;A221;A222;A223;A224;A225;A226;A227;A228;A229;A230;A231;A232;A233;A234;A235;A236;A237;A238;A239;A240;A241;A242;A243;A244;A245;A246;A247;A248;A249;A250;A251;A252;A253;A254;A255;A256;A257;A258;A259;A260;A261;A262;A263;A264;A265;A266;A267;A268;A269;A270;A271;A272;A273;A274;A275;A276;A277;A278;A279;A280;A281;A282;A283;A284;A285;A286;A287;A288;A289;A290;A291;A292;A293;A294;A295;A296;A297;A298;A299;A300;A301;A302;A303;A304;A305;A306;A307;A308;A309;A310;A311;A312;A313;A314;A315;A316;A317;A318;A319;A320;A321;A322;A323;A324;A325;A326;A327;A328;A329;A330;A331;A332;A333;A334;A335;A336;A337;A338;A339;A340;A341;A342;A343;A344;A345;A346;A347;A348;A349;A350;A351;A352;A353;A354;A355;A356;A357;A358;A359;A360;A361;A362;A363;A364;A365;A366;A367;A368;A369;A370;A371;A372;A373;A374;A375;A376;A377;A378;A379;A380;A381;A382;A383;A384;A385;A386;A387;A388;A389;A390;A391;A392;A393;A394;A395;A396;A397;A398;A399;A400;A401;A402;A403;A404;A405;A406;A407;A408;A409;A410;A411;A412;A413;A414;A415;A416;A417;A418;A419;A420;A421;A422;A423;A424;A425;A426;A427;A428;A429;A430;A431;A432;A433;A434;A435;A436;A437;A438;A439;A440;A441;A442;A443;A444;A445;A446;A447;A448;A449;A450;A451;A452;A453;A454;A455;A456;A457;A458;A459;A460;A461;A462;A463;A464;A465;A466;A467;A468;A469;A470;A471;A472;A473;A474;A475;A476;A477;A478;A479;A480;A481;A482;A483;A484;A485;A486;A487;A488;A489;A490;A491;A492;A493;A494;A495;A496;A497;A498;A499;A500;A501;A502;A503;A504;A505;A506;A507;A508;A509;A510;A511;A512;A513;A514;A515;A516;A517;A518;A519;A520;A521;A522;A523;A524;A525;A526;A527;A528;A529;A530;A531;A532;A533;A534;A535;A536;A537;A538;A539;A540;A541;A542;A543;A544;A545;A546;A547;A548;A549;A550;A551;A552;A553;A554;A555;A556;A557;A558;A559;A560;A561;A562;A563;A564;A565;A566;A567;A568;A569;A570;A571;A572;A573;A574;A575;A576;A577;A578;A579;A580;A581;A582;A583;A584;A585;A586;A587;A588;A589;A590;A591;A592;A593;A594;A595;A596;A597;A598;A599;A600;A601;A602;A603;A604;A605;A606;A607;A608;A609;A610;A611;A612;A613;A614;A615;A616;A617;A618;A619;A620;A621;A622;A623;A624;A625;A626;A627;A628;A629;A630;A631;A632;A633;A634;A635;A636;A637;A638;A639;A640;A641;A642;A643;A644;A645;A646;A647;A648;A649;A650;A651;A652;A653;A654;A655;A656;A657;A658;A659;A660;A661;A662;A663;A664;A665;A666;A667;A668;A669;A670;A671;A672;A673;A674;A675;A676;A677;A678;A679;A680;A681;A682;A683;A684;A685;A686;A687;A688;A689;A690;A691;A692;A693;A694;A695;A696;A697;A698;A699;A700;A701;A702;A703;A704;A705;A706;A707;A708;A709;A710;A711;A712;A713;A714;A715;A716;A717;A718;A719;A720;A721;A722;A723;A724;A725;A726;A727;A728;A729;A730;A731;A732;A733;A734;A735;A736;A737;A738;A739;A740;A741;A742;A743;A744;A745;A746;A747;A748;A749;A750;A751;A752;A753;A754;A755;A756;A757;A758;A759;A760;A761;A762;A763;A764;A765;A766;A767;A768;A769;A770;A771;A772;A773;A774;A775;A776;A777;A778;A779;A780;A781;A782;A783;A784;A785;A786;A787;A788;A789;A790;A791;A792;A793;A794;A795;A796;A797;A798;A799;A800;A801;A802;A803;A804;A805;A806;A807;A808;A809;A810;A811;A812;A813;A814;A815;A816;A817;A818;A819;A820;A821;A822;A823;A824;A825;A826;A827;A828;A829;A830;A831;A832;A833;A834;A835;A836;A837;A838;A839;A840; +PK001_0001;155790.132;569960.564;-4.000;155797.109;569953.400;-4.000;155811.446;569938.677;0.110;155811.500;569938.622;0.110;155811.849;569938.264;0.240;155812.197;569937.906;0.410;155812.546;569937.547;0.510;155812.895;569937.189;0.530;155813.244;569936.831;0.680;155813.593;569936.473;0.800;155813.942;569936.114;0.800;155814.290;569935.756;0.970;155814.639;569935.398;1.100;155814.988;569935.040;1.100;155815.337;569934.682;1.110;155815.686;569934.323;1.370;155816.035;569933.965;1.530;155816.383;569933.607;1.530;155816.732;569933.249;1.580;155817.081;569932.891;1.730;155817.430;569932.532;1.730;155817.779;569932.174;1.860;155818.128;569931.816;2.070;155818.476;569931.458;2.070;155818.825;569931.099;2.200;155819.174;569930.741;2.310;155819.523;569930.383;2.440;155819.872;569930.025;2.440;155820.221;569929.667;2.590;155820.569;569929.308;2.710;155820.918;569928.950;2.790;155821.267;569928.592;2.910;155821.616;569928.234;3.040;155821.965;569927.876;3.120;155822.314;569927.517;3.140;155822.662;569927.159;3.340;155823.011;569926.801;3.470;155823.360;569926.443;3.490;155823.709;569926.085;3.600;155824.058;569925.726;3.700;155824.407;569925.368;3.750;155824.755;569925.010;3.810;155825.104;569924.652;3.950;155825.453;569924.293;4.050;155825.802;569923.935;4.210;155826.151;569923.577;4.320;155826.500;569923.219;4.400;155826.848;569922.861;4.540;155827.197;569922.502;4.660;155827.546;569922.144;4.790;155827.895;569921.786;4.880;155828.244;569921.428;4.990;155828.593;569921.070;5.050;155828.941;569920.711;5.040;155829.290;569920.353;5.260;155829.639;569919.995;5.380;155829.988;569919.637;5.380;155830.337;569919.278;5.520;155830.686;569918.920;5.640;155831.034;569918.562;5.750;155831.383;569918.204;5.820;155831.732;569917.846;5.970;155832.081;569917.487;6.120;155832.430;569917.129;6.120;155832.778;569916.771;6.200;155833.127;569916.413;6.290;155833.476;569916.055;6.290;155833.825;569915.696;6.370;155834.174;569915.338;6.520;155834.523;569914.980;6.540;155834.871;569914.622;6.540;155835.220;569914.264;6.640;155835.569;569913.905;6.770;155835.918;569913.547;6.770;155836.267;569913.189;6.900;155836.616;569912.831;7.160;155836.964;569912.472;7.270;155837.313;569912.114;7.350;155837.662;569911.756;7.570;155838.011;569911.398;7.750;155838.360;569911.040;7.750;155838.709;569910.681;7.960;155839.057;569910.323;8.130;155839.406;569909.965;8.200;155839.755;569909.607;8.300;155840.104;569909.249;8.410;155840.453;569908.890;8.510;155840.802;569908.532;8.560;155841.150;569908.174;8.720;155841.499;569907.816;8.830;155841.848;569907.458;8.960;155842.197;569907.099;9.000;155842.546;569906.741;9.170;155842.895;569906.383;9.220;155843.243;569906.025;9.310;155843.592;569905.666;9.430;155843.941;569905.308;9.500;155844.290;569904.950;9.620;155844.639;569904.592;9.680;155844.988;569904.234;9.690;155845.336;569903.875;9.710;155845.685;569903.517;9.720;155846.034;569903.159;9.640;155846.383;569902.801;9.590;155846.732;569902.443;9.390;155847.081;569902.084;9.280;155847.429;569901.726;9.180;155847.778;569901.368;8.890;155848.127;569901.010;8.780;155848.476;569900.651;8.670;155848.825;569900.293;8.440;155849.174;569899.935;8.230;155849.522;569899.577;8.110;155849.871;569899.219;8.010;155850.220;569898.860;7.830;155850.569;569898.502;7.680;155850.918;569898.144;7.500;155851.267;569897.786;7.280;155851.615;569897.428;7.040;155851.964;569897.069;7.040;155852.313;569896.711;6.840;155852.662;569896.353;6.580;155853.011;569895.995;6.360;155853.360;569895.636;6.360;155853.708;569895.278;6.100;155854.057;569894.920;5.860;155854.406;569894.562;5.860;155854.755;569894.204;5.610;155855.104;569893.845;5.370;155855.453;569893.487;5.170;155855.801;569893.129;5.060;155856.150;569892.771;4.850;155856.499;569892.413;4.710;155856.848;569892.054;4.540;155857.197;569891.696;4.260;155857.546;569891.338;4.000;155857.894;569890.980;3.890;155858.243;569890.622;3.720;155858.592;569890.263;3.500;155858.941;569889.905;3.330;155859.290;569889.547;3.260;155859.639;569889.189;3.000;155859.987;569888.830;2.900;155860.336;569888.472;2.650;155860.685;569888.114;2.530;155861.034;569887.756;2.310;155861.383;569887.398;2.130;155861.732;569887.039;2.010;155862.080;569886.681;1.690;155862.429;569886.323;1.550;155862.778;569885.965;1.350;155863.127;569885.607;1.370;155863.476;569885.248;1.380;155863.825;569884.890;1.090;155864.173;569884.532;0.950;155864.522;569884.174;1.030;155864.871;569883.815;1.100;155865.220;569883.457;1.210;155865.569;569883.099;1.270;155865.918;569882.741;1.280;155866.266;569882.383;1.310;155866.615;569882.024;1.380;155866.964;569881.666;1.370;155867.313;569881.308;1.400;155867.662;569880.950;1.410;155868.011;569880.592;1.450;155868.359;569880.233;1.440;155868.708;569879.875;1.460;155869.057;569879.517;1.450;155869.406;569879.159;1.460;155869.755;569878.801;1.410;155870.104;569878.442;1.350;155870.452;569878.084;1.350;155870.801;569877.726;1.290;155871.150;569877.368;1.180;155871.499;569877.009;1.180;155871.848;569876.651;1.140;155872.197;569876.293;0.910;155872.224;569876.265;0.910;155874.184;569874.252;-1.900;155882.067;569866.157;-1.900;155883.762;569864.416;0.530;155884.057;569864.114;0.280;155884.406;569863.756;0.480;155884.755;569863.397;0.410;155885.103;569863.039;0.690;155885.452;569862.681;0.670;155885.801;569862.323;0.730;155886.150;569861.965;0.750;155886.499;569861.606;0.750;155886.848;569861.248;0.750;155887.196;569860.890;0.780;155887.545;569860.532;0.840;155887.894;569860.174;0.790;155888.243;569859.815;0.790;155888.592;569859.457;0.830;155888.941;569859.099;0.830;155889.289;569858.741;0.800;155889.638;569858.382;0.780;155889.987;569858.024;0.780;155890.336;569857.666;0.900;155890.685;569857.308;0.920;155891.034;569856.950;0.970;155891.382;569856.591;0.970;155891.731;569856.233;0.960;155892.080;569855.875;0.980;155892.429;569855.517;0.980;155892.778;569855.159;1.010;155893.127;569854.800;1.070;155893.475;569854.442;1.030;155893.824;569854.084;1.020;155894.173;569853.726;1.060;155894.522;569853.367;1.020;155894.871;569853.009;1.020;155895.220;569852.651;1.050;155895.568;569852.293;1.090;155895.917;569851.935;1.070;155896.266;569851.576;1.060;155896.615;569851.218;1.020;155896.964;569850.860;0.990;155897.313;569850.502;1.010;155897.661;569850.144;1.030;155898.010;569849.785;1.040;155898.359;569849.427;1.010;155898.708;569849.069;1.080;155899.057;569848.711;1.080;155899.406;569848.353;1.040;155899.754;569847.994;1.100;155900.103;569847.636;1.110;155900.452;569847.278;1.130;155900.801;569846.920;1.110;155901.150;569846.561;1.110;155901.499;569846.203;1.110;155901.847;569845.845;1.080;155902.196;569845.487;1.030;155902.545;569845.129;1.000;155902.894;569844.770;1.070;155903.243;569844.412;0.990;155903.592;569844.054;0.990;155903.940;569843.696;0.960;155904.289;569843.338;0.920;155904.638;569842.979;0.910;155904.987;569842.621;0.910;155905.336;569842.263;0.910;155905.685;569841.905;0.850;155906.033;569841.546;0.820;155906.382;569841.188;0.780;155906.731;569840.830;0.710;155907.080;569840.472;0.660;155907.429;569840.114;0.660;155907.778;569839.755;0.670;155908.126;569839.397;0.830;155908.475;569839.039;0.830;155908.824;569838.681;0.860;155909.173;569838.323;0.980;155909.522;569837.964;1.060;155909.871;569837.606;1.060;155910.219;569837.248;1.120;155910.568;569836.890;1.240;155910.917;569836.532;1.240;155911.266;569836.173;1.260;155911.615;569835.815;1.160;155911.964;569835.457;1.020;155912.312;569835.099;1.010;155912.661;569834.740;0.900;155913.010;569834.382;0.400;155913.359;569834.024;0.400;155913.708;569833.666;-0.080;155914.057;569833.308;-0.460 +PK001_0002;155499.819;569709.619;-4.000;155505.259;569701.229;-4.000;155516.875;569683.315;0.270;155517.134;569682.916;0.410;155517.406;569682.497;0.420;155517.678;569682.077;0.560;155517.950;569681.658;0.600;155518.222;569681.238;0.710;155518.494;569680.819;0.870;155518.766;569680.399;0.910;155519.038;569679.980;1.100;155519.310;569679.560;1.100;155519.582;569679.141;1.180;155519.854;569678.721;1.250;155520.126;569678.302;1.370;155520.398;569677.882;1.470;155520.670;569677.463;1.640;155520.942;569677.043;1.640;155521.214;569676.623;1.760;155521.486;569676.204;1.720;155521.758;569675.784;2.060;155522.030;569675.365;2.160;155522.302;569674.945;2.260;155522.574;569674.526;2.360;155522.846;569674.106;2.450;155523.118;569673.687;2.620;155523.390;569673.267;2.710;155523.662;569672.848;2.880;155523.934;569672.428;2.890;155524.206;569672.009;2.970;155524.478;569671.589;3.110;155524.750;569671.170;3.240;155525.022;569670.750;3.390;155525.294;569670.331;3.520;155525.566;569669.911;3.640;155525.838;569669.492;3.730;155526.110;569669.072;3.780;155526.382;569668.652;3.890;155526.654;569668.233;4.020;155526.927;569667.813;4.090;155527.199;569667.394;4.270;155527.471;569666.974;4.340;155527.743;569666.555;4.330;155528.015;569666.135;4.530;155528.287;569665.716;4.640;155528.559;569665.296;4.710;155528.831;569664.877;4.820;155529.103;569664.457;4.890;155529.375;569664.038;4.890;155529.647;569663.618;5.010;155529.919;569663.199;5.080;155530.191;569662.779;5.240;155530.463;569662.360;5.340;155530.735;569661.940;5.490;155531.007;569661.521;5.550;155531.279;569661.101;5.630;155531.551;569660.681;5.810;155531.823;569660.262;5.860;155532.095;569659.842;5.960;155532.367;569659.423;6.050;155532.639;569659.003;6.080;155532.911;569658.584;6.160;155533.183;569658.164;6.290;155533.455;569657.745;6.400;155533.727;569657.325;6.460;155533.999;569656.906;6.540;155534.271;569656.486;6.610;155534.543;569656.067;6.640;155534.815;569655.647;6.720;155535.087;569655.228;6.870;155535.359;569654.808;6.930;155535.631;569654.389;7.100;155535.903;569653.969;7.230;155536.175;569653.550;7.280;155536.447;569653.130;7.390;155536.719;569652.711;7.570;155536.991;569652.291;7.670;155537.264;569651.871;7.870;155537.536;569651.452;8.030;155537.808;569651.032;8.030;155538.080;569650.613;8.210;155538.352;569650.193;8.290;155538.624;569649.774;8.440;155538.896;569649.354;8.500;155539.168;569648.935;8.670;155539.440;569648.515;8.670;155539.712;569648.096;8.850;155539.984;569647.676;8.890;155540.256;569647.257;9.070;155540.528;569646.837;9.200;155540.800;569646.418;9.280;155541.072;569645.998;9.430;155541.344;569645.579;9.430;155541.616;569645.159;9.560;155541.888;569644.740;9.630;155542.160;569644.320;9.680;155542.432;569643.901;9.720;155542.704;569643.481;9.750;155542.976;569643.061;9.750;155543.248;569642.642;9.730;155543.520;569642.222;9.690;155543.792;569641.803;9.640;155544.064;569641.383;9.550;155544.336;569640.964;9.560;155544.608;569640.545;9.540;155544.608;569640.544;9.540;155544.880;569640.125;9.540;155545.152;569639.705;9.520;155545.424;569639.286;9.490;155545.696;569638.866;9.520;155545.968;569638.447;9.550;155546.240;569638.027;9.500;155546.512;569637.608;9.420;155546.784;569637.188;9.270;155547.056;569636.769;9.030;155547.328;569636.349;8.860;155547.601;569635.930;8.620;155547.873;569635.510;8.620;155548.145;569635.090;8.430;155548.417;569634.671;8.340;155548.689;569634.251;8.060;155548.961;569633.832;7.880;155549.233;569633.412;7.650;155549.505;569632.993;7.420;155549.777;569632.573;7.420;155550.049;569632.154;7.230;155550.321;569631.734;6.980;155550.593;569631.315;6.750;155550.865;569630.895;6.530;155551.137;569630.476;6.330;155551.409;569630.056;6.330;155551.681;569629.637;6.060;155551.953;569629.217;5.830;155552.225;569628.798;5.590;155552.497;569628.378;5.500;155552.769;569627.959;5.150;155553.041;569627.539;5.030;155553.313;569627.119;4.860;155553.585;569626.700;4.610;155553.857;569626.280;4.450;155554.129;569625.861;4.180;155554.401;569625.441;3.980;155554.673;569625.022;3.810;155554.945;569624.602;3.710;155555.217;569624.183;3.370;155555.489;569623.763;3.220;155555.761;569623.344;2.940;155556.033;569622.924;2.720;155556.305;569622.505;2.720;155556.577;569622.085;2.490;155556.849;569621.666;2.250;155557.121;569621.246;2.140;155557.393;569620.827;2.000;155557.666;569620.407;1.770;155557.938;569619.988;1.650;155558.210;569619.568;1.680;155558.482;569619.149;1.660;155558.754;569618.729;1.450;155559.026;569618.309;1.380;155559.298;569617.890;1.410;155559.570;569617.470;1.460;155559.842;569617.051;1.460;155560.114;569616.631;1.470;155560.386;569616.212;1.520;155560.658;569615.792;1.540;155560.930;569615.373;1.530;155561.202;569614.953;1.480;155561.474;569614.534;1.480;155561.746;569614.114;1.490;155562.018;569613.695;1.450;155562.290;569613.275;1.460;155562.562;569612.856;1.410;155562.834;569612.436;1.320;155563.106;569612.017;1.320;155563.378;569611.597;1.270;155563.650;569611.178;1.120;155563.922;569610.758;1.030;155564.194;569610.338;0.820;155564.466;569609.919;0.690;155564.738;569609.499;0.430;155565.010;569609.080;0.330;155565.282;569608.660;0.320;155565.554;569608.241;0.400;155565.826;569607.821;0.410;155566.098;569607.402;0.400;155566.370;569606.982;0.370;155566.914;569606.143;0.380;155567.186;569605.724;0.380;155567.458;569605.304;0.360;155567.731;569604.885;0.320;155568.003;569604.465;0.350;155568.275;569604.046;0.350;155568.547;569603.626;0.390;155568.819;569603.207;0.410;155569.091;569602.787;0.390;155570.179;569601.109;0.470;155570.451;569600.689;0.480;155570.723;569600.270;0.360;155570.995;569599.850;0.420;155571.267;569599.431;0.350;155571.539;569599.011;0.390;155571.811;569598.592;0.370;155572.083;569598.172;0.400;155572.355;569597.753;0.350;155572.627;569597.333;0.340;155572.899;569596.914;0.360;155573.171;569596.494;0.310;155573.443;569596.075;0.310;155573.715;569595.655;0.270;155573.987;569595.236;0.310;155574.259;569594.816;0.320;155574.531;569594.397;0.290;155574.803;569593.977;0.300;155575.075;569593.557;0.280;155575.347;569593.138;0.300;155575.619;569592.718;0.310;155575.891;569592.299;0.270;155576.163;569591.879;0.320;155576.435;569591.460;0.280;155576.707;569591.040;0.330;155576.979;569590.621;0.290;155577.251;569590.201;0.300;155577.523;569589.782;0.340;155577.796;569589.362;0.320;155578.068;569588.943;0.310;155578.340;569588.523;0.310;155578.612;569588.104;0.330;155578.884;569587.684;0.340;155579.156;569587.265;0.340;155579.428;569586.845;0.310;155579.700;569586.426;0.310;155579.972;569586.006;0.310;155580.244;569585.587;0.290;155580.516;569585.167;0.330;155580.788;569584.747;0.360;155581.060;569584.328;0.300;155581.332;569583.908;0.320;155581.604;569583.489;0.340;155581.876;569583.069;0.340;155582.148;569582.650;0.280;155582.420;569582.230;0.260;155582.692;569581.811;0.220;155582.964;569581.391;0.250;155583.236;569580.972;0.290;155583.508;569580.552;0.270;155583.780;569580.133;0.260;155584.052;569579.713;0.250;155584.324;569579.294;0.270;155584.596;569578.874;0.220;155584.868;569578.455;0.240;155585.140;569578.035;0.170;155585.412;569577.616;0.210;155585.684;569577.196;0.160;155585.956;569576.776;0.160;155586.228;569576.357;0.120;155586.500;569575.937;0.150;155586.772;569575.518;0.150;155587.044;569575.098;0.100;155587.316;569574.679;0.070;155587.588;569574.259;-0.010;155587.861;569573.840;0.080;155588.133;569573.420;-0.090;155588.405;569573.001;-0.090;155588.677;569572.581;-0.220;155588.949;569572.162;-0.240;155589.221;569571.742;-0.100;155589.493;569571.323;-0.200;155589.765;569570.903;-0.070;155590.037;569570.484;-0.100;155590.309;569570.064;-0.100;155594.117;569564.191;-0.460;155594.389;569563.771;-0.390;155594.661;569563.352;-0.320;155594.933;569562.932;-0.260;155595.205;569562.513;-0.130;155595.477;569562.093;-0.150;155595.749;569561.674;0.000;155596.021;569561.254;0.070;155596.293;569560.835;0.070;155596.565;569560.415;0.120 +PK001_0003;154993.839;569391.981;-4.000;154999.006;569383.419;-4.000;155009.650;569365.782;0.120;155009.869;569365.418;0.290;155010.128;569364.990;0.430;155010.386;569364.562;0.430;155010.644;569364.134;0.610;155010.903;569363.706;0.730;155011.161;569363.277;0.860;155011.419;569362.849;0.900;155011.678;569362.421;0.970;155011.936;569361.993;1.060;155012.194;569361.565;1.160;155012.453;569361.137;1.260;155012.711;569360.709;1.400;155012.969;569360.281;1.520;155013.228;569359.853;1.680;155013.486;569359.425;1.810;155013.744;569358.997;2.010;155014.003;569358.569;2.020;155014.261;569358.140;2.130;155014.519;569357.712;2.310;155014.778;569357.284;2.370;155015.036;569356.856;2.490;155015.294;569356.428;2.630;155015.553;569356.000;2.750;155015.811;569355.572;2.750;155016.069;569355.144;2.940;155016.328;569354.716;3.060;155016.586;569354.288;3.210;155016.845;569353.860;3.350;155017.103;569353.431;3.420;155017.361;569353.003;3.420;155017.620;569352.575;3.600;155017.878;569352.147;3.760;155018.136;569351.719;3.870;155018.395;569351.291;3.990;155018.653;569350.863;4.120;155018.911;569350.435;4.190;155019.170;569350.007;4.270;155019.428;569349.579;4.370;155019.686;569349.151;4.530;155019.945;569348.722;4.660;155020.203;569348.294;4.760;155020.461;569347.866;4.870;155020.720;569347.438;4.980;155020.978;569347.010;4.980;155021.236;569346.582;5.090;155021.495;569346.154;5.230;155021.753;569345.726;5.300;155022.011;569345.298;5.410;155022.270;569344.870;5.510;155022.528;569344.442;5.610;155022.786;569344.014;5.610;155023.045;569343.585;5.740;155023.303;569343.157;5.840;155023.561;569342.729;5.940;155023.820;569342.301;5.990;155024.078;569341.873;6.140;155024.336;569341.445;6.240;155024.595;569341.017;6.250;155024.853;569340.589;6.350;155025.111;569340.161;6.420;155025.370;569339.733;6.510;155025.628;569339.305;6.540;155025.886;569338.876;6.550;155026.145;569338.448;6.690;155026.403;569338.020;6.690;155026.661;569337.592;6.760;155026.920;569337.164;6.870;155027.178;569336.736;7.030;155027.437;569336.308;7.120;155027.695;569335.880;7.290;155027.953;569335.452;7.390;155028.212;569335.024;7.430;155028.470;569334.596;7.530;155028.728;569334.167;7.640;155028.987;569333.739;7.790;155029.245;569333.311;7.930;155029.503;569332.883;8.080;155029.762;569332.455;8.200;155030.020;569332.027;8.210;155030.278;569331.599;8.360;155030.537;569331.171;8.450;155030.795;569330.743;8.530;155031.053;569330.315;8.690;155031.312;569329.887;8.750;155031.570;569329.459;8.870;155031.828;569329.030;8.870;155032.087;569328.602;9.010;155032.345;569328.174;9.070;155032.603;569327.746;9.190;155032.862;569327.318;9.250;155033.120;569326.890;9.330;155033.378;569326.462;9.380;155033.637;569326.034;9.460;155033.895;569325.606;9.450;155034.153;569325.178;9.490;155034.412;569324.750;9.440;155034.670;569324.321;9.400;155034.928;569323.893;9.300;155035.187;569323.465;9.170;155035.445;569323.037;9.170;155035.703;569322.609;8.930;155035.962;569322.181;8.880;155036.220;569321.753;8.650;155036.478;569321.325;8.530;155036.737;569320.897;8.340;155036.995;569320.469;8.230;155037.253;569320.041;8.150;155037.512;569319.612;7.870;155037.770;569319.184;7.790;155038.028;569318.756;7.570;155038.287;569318.328;7.420;155038.545;569317.900;7.230;155038.804;569317.472;7.120;155039.062;569317.044;6.980;155039.320;569316.616;6.860;155039.579;569316.188;6.640;155039.837;569315.760;6.440;155040.095;569315.332;6.230;155040.354;569314.904;6.070;155040.612;569314.475;5.840;155040.870;569314.047;5.840;155041.129;569313.619;5.570;155041.387;569313.191;5.530;155041.645;569312.763;5.180;155041.904;569312.335;5.090;155042.162;569311.907;4.850;155042.420;569311.479;4.680;155042.679;569311.051;4.620;155042.937;569310.623;4.430;155043.195;569310.195;4.140;155043.454;569309.766;4.080;155043.712;569309.338;3.780;155043.970;569308.910;3.680;155044.229;569308.482;3.370;155044.487;569308.054;3.370;155044.745;569307.626;3.080;155045.004;569307.198;2.810;155045.262;569306.770;2.670;155045.520;569306.342;2.390;155045.779;569305.914;2.270;155046.037;569305.486;2.020;155046.295;569305.057;2.020;155046.554;569304.629;1.770;155046.812;569304.201;1.680;155047.070;569303.773;1.540;155047.329;569303.345;1.490;155047.587;569302.917;1.420;155047.845;569302.489;1.420;155048.104;569302.061;1.310;155048.362;569301.633;1.300;155048.620;569301.205;1.300;155048.879;569300.777;1.330;155049.137;569300.349;1.320;155049.395;569299.920;1.300;155049.654;569299.492;1.350;155049.912;569299.064;1.350;155050.171;569298.636;1.350;155050.429;569298.208;1.360;155050.687;569297.780;1.420;155050.946;569297.352;1.380;155051.204;569296.924;1.340;155051.462;569296.496;1.340;155051.721;569296.068;1.310;155051.979;569295.640;1.360;155052.237;569295.211;1.250;155052.496;569294.783;1.260;155052.754;569294.355;1.210;155053.012;569293.927;1.130;155053.271;569293.499;0.990;155053.529;569293.071;0.950;155053.787;569292.643;0.770;155054.046;569292.215;0.460;155054.304;569291.787;0.320;155054.562;569291.359;0.170;155054.821;569290.931;0.020;155055.079;569290.502;-0.050;155055.337;569290.074;-0.070;155055.596;569289.646;-0.150;155055.854;569289.218;-0.250;155056.112;569288.790;-0.310;155056.297;569288.485;-0.370;155056.855;569287.560;-1.450;155063.272;569276.926;-1.450;155063.763;569276.113;-0.500;155063.863;569275.947;-0.360;155064.121;569275.519;-0.490;155064.379;569275.091;-0.420;155064.638;569274.663;-0.490;155064.896;569274.235;-0.440;155065.154;569273.807;-0.480;155065.413;569273.379;-0.520;155065.671;569272.951;-0.450;155065.929;569272.523;-0.450;155066.188;569272.095;-0.440;155066.446;569271.667;-0.440;155066.704;569271.238;-0.460;155066.963;569270.810;-0.460;155067.221;569270.382;-0.410;155067.479;569269.954;-0.410;155067.738;569269.526;-0.400;155067.996;569269.098;-0.390;155068.254;569268.670;-0.410;155068.513;569268.242;-0.430;155068.771;569267.814;-0.490;155069.029;569267.386;-0.470;155069.288;569266.958;-0.510;155069.546;569266.530;-0.490;155069.804;569266.101;-0.480;155070.063;569265.673;-0.430;155070.321;569265.245;-0.360;155070.579;569264.817;-0.330;155070.838;569264.389;-0.300;155071.096;569263.961;-0.290;155071.354;569263.533;-0.290;155071.613;569263.105;-0.320;155071.871;569262.677;-0.310;155072.130;569262.249;-0.360;155072.388;569261.821;-0.400;155072.646;569261.392;-0.650;155072.905;569260.964;-0.680;155073.163;569260.536;-0.670;155074.196;569258.824;-0.570;155074.455;569258.396;-0.410;155074.713;569257.968;-0.340;155074.971;569257.540;-0.340;155075.230;569257.112;-0.290;155075.488;569256.683;-0.320;155075.746;569256.255;-0.310;155076.005;569255.827;-0.300;155076.263;569255.399;-0.300;155076.521;569254.971;-0.310;155076.780;569254.543;-0.310;155077.038;569254.115;-0.330;155077.296;569253.687;-0.290;155077.555;569253.259;-0.370;155077.813;569252.831;-0.340;155078.071;569252.403;-0.350;155078.330;569251.974;-0.360;155078.588;569251.546;-0.360;155078.846;569251.118;-0.340;155079.105;569250.690;-0.370;155079.363;569250.262;-0.370;155079.621;569249.834;-0.350;155079.880;569249.406;-0.350;155080.138;569248.978;-0.350;155080.396;569248.550;-0.350;155080.655;569248.122;-0.330;155080.913;569247.694;-0.320;155081.171;569247.266;-0.370;155081.430;569246.837;-0.380;155081.688;569246.409;-0.390;155081.946;569245.981;-0.460;155082.205;569245.553;-0.430;155082.463;569245.125;-0.460;155082.722;569244.697;-0.470;155082.980;569244.269;-0.460;155083.238;569243.841;-0.390;155083.497;569243.413;-0.380;155083.755;569242.985;-0.350;155084.013;569242.557;-0.320;155084.272;569242.128;-0.350;155084.530;569241.700;-0.330;155084.788;569241.272;-0.330 +PK001_0004;154576.111;568119.849;-4.000;154586.088;568119.170;-4.000;154608.536;568117.644;0.500;154608.554;568117.643;0.500;154609.052;568117.609;0.680;154609.551;568117.575;0.700;154610.050;568117.541;0.580;154610.549;568117.507;0.680;154611.048;568117.473;0.560;154611.547;568117.439;0.580;154612.046;568117.405;0.740;154612.544;568117.371;0.860;154613.043;568117.338;1.000;154613.542;568117.304;1.150;154614.041;568117.270;1.290;154614.540;568117.236;1.410;154615.039;568117.202;1.520;154615.538;568117.168;1.650;154616.036;568117.134;1.790;154616.535;568117.100;1.910;154617.034;568117.066;2.030;154617.533;568117.032;2.150;154618.032;568116.998;2.290;154618.531;568116.964;2.410;154619.029;568116.931;2.570;154619.528;568116.897;2.660;154620.027;568116.863;2.820;154620.526;568116.829;2.930;154621.025;568116.795;3.000;154621.524;568116.761;3.140;154622.023;568116.727;3.270;154622.521;568116.693;3.330;154623.020;568116.659;3.440;154623.519;568116.625;3.600;154624.018;568116.591;3.720;154624.517;568116.557;3.780;154625.016;568116.523;3.960;154625.514;568116.490;4.090;154626.013;568116.456;4.200;154626.512;568116.422;4.290;154627.011;568116.388;4.400;154627.510;568116.354;4.470;154628.009;568116.320;4.600;154628.508;568116.286;4.760;154629.006;568116.252;4.830;154629.505;568116.218;4.940;154630.004;568116.184;5.000;154630.503;568116.150;5.100;154631.002;568116.116;5.260;154631.501;568116.083;5.340;154632.000;568116.049;5.340;154632.498;568116.015;5.460;154632.997;568115.981;5.530;154633.496;568115.947;5.710;154633.995;568115.913;5.800;154634.494;568115.879;5.910;154634.993;568115.845;6.000;154635.491;568115.811;6.090;154635.990;568115.777;6.160;154636.489;568115.743;6.340;154636.988;568115.709;6.380;154637.487;568115.675;6.460;154637.986;568115.642;6.500;154638.485;568115.608;6.580;154638.983;568115.574;6.650;154639.482;568115.540;6.620;154639.981;568115.506;6.680;154640.480;568115.472;6.830;154640.979;568115.438;6.920;154641.478;568115.404;7.030;154641.976;568115.370;7.150;154642.475;568115.336;7.290;154642.974;568115.302;7.350;154643.473;568115.268;7.500;154643.972;568115.234;7.560;154644.471;568115.201;7.630;154644.970;568115.167;7.760;154645.468;568115.133;7.840;154645.967;568115.099;7.970;154646.466;568115.065;8.070;154646.965;568115.031;8.090;154647.464;568114.997;8.260;154647.963;568114.963;8.260;154648.461;568114.929;8.360;154648.960;568114.895;8.450;154649.459;568114.861;8.510;154649.958;568114.827;8.590;154650.457;568114.794;8.690;154650.956;568114.760;8.820;154651.455;568114.726;8.900;154651.953;568114.692;8.990;154652.452;568114.658;9.050;154652.951;568114.624;9.160;154653.450;568114.590;9.150;154653.949;568114.556;9.240;154654.448;568114.522;9.270;154654.947;568114.488;9.280;154655.445;568114.454;9.280;154655.944;568114.420;9.310;154656.443;568114.386;9.290;154656.942;568114.353;9.190;154657.441;568114.319;9.110;154657.940;568114.285;9.020;154658.438;568114.251;8.850;154658.937;568114.217;8.720;154659.436;568114.183;8.590;154659.935;568114.149;8.380;154660.434;568114.115;8.220;154660.933;568114.081;8.070;154661.432;568114.047;7.910;154661.930;568114.013;7.730;154662.429;568113.979;7.540;154662.928;568113.946;7.390;154663.427;568113.912;7.200;154663.926;568113.878;7.110;154664.425;568113.844;7.010;154664.924;568113.810;6.900;154665.422;568113.776;6.790;154665.921;568113.742;6.860;154666.420;568113.708;6.830;154666.919;568113.674;6.820;154667.418;568113.640;6.820;154667.917;568113.606;6.810;154668.415;568113.572;6.820;154668.914;568113.538;6.800;154669.413;568113.505;6.810;154669.912;568113.471;6.800;154670.411;568113.437;6.710;154670.910;568113.403;6.650;154671.409;568113.369;6.660;154671.907;568113.335;6.530;154672.406;568113.301;6.420;154672.905;568113.267;6.150;154673.404;568113.233;5.900;154673.903;568113.199;5.660;154674.402;568113.165;5.400;154674.900;568113.131;5.060;154675.399;568113.097;4.820;154675.898;568113.064;4.600;154676.397;568113.030;4.320;154676.896;568112.996;4.040;154677.395;568112.962;3.720;154677.894;568112.928;3.450;154678.392;568112.894;3.220;154678.891;568112.860;2.980;154679.390;568112.826;2.710;154679.889;568112.792;2.440;154680.388;568112.758;2.170;154680.887;568112.724;1.930;154681.385;568112.690;1.810;154681.884;568112.657;1.670;154682.383;568112.623;1.550;154682.882;568112.589;1.560;154683.381;568112.555;1.570;154683.880;568112.521;1.580;154684.379;568112.487;1.580;154684.877;568112.453;1.600;154685.376;568112.419;1.600;154685.875;568112.385;1.620;154686.374;568112.351;1.600;154686.873;568112.317;1.630;154687.372;568112.283;1.650;154687.871;568112.249;1.630;154688.369;568112.216;1.660;154688.868;568112.182;1.670;154689.367;568112.148;1.660;154689.866;568112.114;1.690;154690.365;568112.080;1.690;154690.864;568112.046;1.680;154691.362;568112.012;1.670;154691.861;568111.978;1.630;154692.360;568111.944;1.580;154692.859;568111.910;1.590;154693.358;568111.876;1.560;154693.857;568111.842;1.540;154694.356;568111.809;1.460;154694.854;568111.775;1.470;154695.353;568111.741;1.510;154695.852;568111.707;1.480;154696.351;568111.673;1.440;154696.850;568111.639;1.430;154697.349;568111.605;1.420;154697.847;568111.571;1.400;154698.346;568111.537;1.340;154698.845;568111.503;1.300;154699.344;568111.469;1.320;154699.843;568111.435;1.300;154700.342;568111.401;1.300;154700.841;568111.368;1.290;154701.339;568111.334;1.250;154701.838;568111.300;1.170;154702.337;568111.266;1.150;154702.836;568111.232;1.060;154703.335;568111.198;0.950;154703.834;568111.164;0.930;154704.333;568111.130;1.100;154704.831;568111.096;1.180;154705.330;568111.062;1.220;154705.829;568111.028;1.300;154706.328;568110.994;1.310;154706.827;568110.960;1.360;154707.326;568110.927;1.360;154707.824;568110.893;1.360;154708.323;568110.859;1.340;154708.822;568110.825;1.330;154709.321;568110.791;1.330;154709.820;568110.757;1.300;154710.319;568110.723;1.310;154710.818;568110.689;1.290;154711.316;568110.655;1.250;154711.815;568110.621;1.270;154712.314;568110.587;1.270;154712.813;568110.553;1.250;154713.312;568110.520;1.220;154713.811;568110.486;1.200;154714.309;568110.452;1.220;154714.808;568110.418;1.190;154715.307;568110.384;1.160;154715.806;568110.350;1.170;154716.305;568110.316;1.150;154716.804;568110.282;1.180;154717.303;568110.248;1.130;154717.801;568110.214;1.100;154718.300;568110.180;1.120;154718.799;568110.146;1.070;154719.298;568110.112;1.090;154719.797;568110.079;1.030;154720.296;568110.045;1.050;154720.794;568110.011;1.020;154721.293;568109.977;1.040;154721.792;568109.943;1.020;154722.291;568109.909;1.000;154722.790;568109.875;0.970;154723.289;568109.841;0.960;154723.788;568109.807;0.960;154724.286;568109.773;0.940;154724.785;568109.739;0.930;154725.284;568109.705;0.910;154725.783;568109.672;0.930;154726.282;568109.638;0.900;154726.781;568109.604;0.910;154727.280;568109.570;0.940;154727.778;568109.536;1.010;154728.277;568109.502;1.020;154728.776;568109.468;1.000;154729.275;568109.434;1.060;154729.774;568109.400;1.060;154730.273;568109.366;1.110;154730.771;568109.332;1.110;154731.270;568109.298;1.090;154731.769;568109.264;1.110;154732.268;568109.231;1.110;154732.767;568109.197;1.060;154733.266;568109.163;1.030;154733.765;568109.129;1.050;154734.263;568109.095;1.020;154734.762;568109.061;0.980;154735.261;568109.027;1.000;154735.760;568108.993;0.990;154736.259;568108.959;0.960;154736.758;568108.925;0.970;154737.256;568108.891;0.920;154737.755;568108.857;0.900;154738.254;568108.823;0.900;154738.753;568108.790;0.900;154739.252;568108.756;0.910;154739.751;568108.722;0.890;154740.250;568108.688;0.870;154740.748;568108.654;0.870;154741.247;568108.620;0.870;154741.746;568108.586;0.770;154742.245;568108.552;0.850;154742.744;568108.518;0.830;154743.243;568108.484;0.820;154743.741;568108.450;0.790;154744.240;568108.416;0.770;154744.739;568108.383;0.740;154745.238;568108.349;0.750;154745.737;568108.315;0.730 Index: Ringtoets/Integration/test/Ringtoets.Integration.TestUtil/EmbeddedResources/DR6_surfacelines.krp.csv =================================================================== diff -u --- Ringtoets/Integration/test/Ringtoets.Integration.TestUtil/EmbeddedResources/DR6_surfacelines.krp.csv (revision 0) +++ Ringtoets/Integration/test/Ringtoets.Integration.TestUtil/EmbeddedResources/DR6_surfacelines.krp.csv (revision 5d822eca2d7467c9781a4a3a54d796ac4229e4a3) @@ -0,0 +1,5 @@ +LOCATIONID;X_Maaiveld binnenwaarts;Y_Maaiveld binnenwaarts;Z_Maaiveld binnenwaarts;X_Insteek sloot polderzijde;Y_Insteek sloot polderzijde;Z_Insteek sloot polderzijde;X_Slootbodem polderzijde;Y_Slootbodem polderzijde;Z_Slootbodem polderzijde;X_Slootbodem dijkzijde;Y_Slootbodem dijkzijde;Z_Slootbodem dijkzijde;X_Insteek sloot dijkzijde;Y_Insteek_sloot dijkzijde;Z_Insteek sloot dijkzijde;X_Teen dijk binnenwaarts;Y_Teen dijk binnenwaarts;Z_Teen dijk binnenwaarts;X_Kruin binnenberm;Y_Kruin binnenberm;Z_Kruin binnenberm;X_Insteek binnenberm;Y_Insteek binnenberm;Z_Insteek binnenberm;X_Kruin binnentalud;Y_Kruin binnentalud;Z_Kruin binnentalud;X_Verkeersbelasting kant binnenwaarts;Y_Verkeersbelasting kant binnenwaarts;Z_Verkeersbelasting kant binnenwaarts;X_Verkeersbelasting kant buitenwaarts;Y_Verkeersbelasting kant buitenwaarts;Z_Verkeersbelasting kant buitenwaarts;X_Kruin buitentalud;Y_Kruin buitentalud;Z_Kruin buitentalud;X_Insteek buitenberm;Y_Insteek buitenberm;Z_Insteek buitenberm;X_Kruin buitenberm;Y_Kruin buitenberm;Z_Kruin buitenberm;X_Teen dijk buitenwaarts;Y_Teen dijk buitenwaarts;Z_Teen dijk buitenwaarts;X_Insteek geul;Y_Insteek geul;Z_Insteek geul;X_Teen geul;Y_Teen geul;Z_Teen geul;X_Maaiveld buitenwaarts;Y_Maaiveld buitenwaarts;Z_Maaiveld buitenwaarts +PK001_0001;155914.057;569833.308;-0.460;155883.762;569864.416;0.530;155882.067;569866.157;-1.900;155874.184;569874.252;-1.900;155872.224;569876.265;0.910;155864.173;569884.532;0.950;-1.000;-1.000;-1.000;-1.000;-1.000;-1.000;155846.034;569903.159;9.640;155846.034;569903.159;9.640;155844.290;569904.950;9.620;155844.290;569904.950;9.620;-1.000;-1.000;-1.000;-1.000;-1.000;-1.000;155797.109;569953.400;-4.000;-1.000;-1.000;-1.000;-1.000;-1.000;-1.000;155790.132;569960.564;-4.000 +PK001_0002;155596.565;569560.415;0.120;-1.000;-1.000;-1.000;-1.000;-1.000;-1.000;-1.000;-1.000;-1.000;-1.000;-1.000;-1.000;155558.754;569618.729;1.450;-1.000;-1.000;-1.000;-1.000;-1.000;-1.000;155546.240;569638.027;9.500;155545.968;569638.447;9.550;155544.608;569640.545;9.540;155542.160;569644.320;9.680;-1.000;-1.000;-1.000;-1.000;-1.000;-1.000;155505.259;569701.229;-4.000;-1.000;-1.000;-1.000;-1.000;-1.000;-1.000;155499.819;569709.619;-4.000 +PK001_0003;155084.788;569241.272;-0.330;155063.763;569276.113;-0.500;155063.272;569276.926;-1.450;155056.855;569287.560;-1.450;155056.297;569288.485;-0.370;155047.587;569302.917;1.420;-1.000;-1.000;-1.000;-1.000;-1.000;-1.000;155034.928;569323.893;9.300;155034.928;569323.893;9.300;155033.637;569326.034;9.460;155033.378;569326.462;9.380;-1.000;-1.000;-1.000;-1.000;-1.000;-1.000;154999.006;569383.419;-4.000;-1.000;-1.000;-1.000;-1.000;-1.000;-1.000;154993.839;569391.981;-4.000 +PK001_0004;154745.737;568108.315;0.730;-1.000;-1.000;-1.000;-1.000;-1.000;-1.000;-1.000;-1.000;-1.000;-1.000;-1.000;-1.000;154682.383;568112.623;1.550;154671.907;568113.335;6.530;154664.924;568113.810;6.900;154656.942;568114.353;9.190;154656.942;568114.353;9.190;154654.448;568114.522;9.270;154653.450;568114.590;9.150;-1.000;-1.000;-1.000;-1.000;-1.000;-1.000;154586.088;568119.170;-4.000;-1.000;-1.000;-1.000;-1.000;-1.000;-1.000;154576.111;568119.849;-4.000 Index: Ringtoets/Integration/test/Ringtoets.Integration.TestUtil/EmbeddedResources/DR6_updated.soil =================================================================== diff -u Binary files differ Index: Ringtoets/Integration/test/Ringtoets.Integration.TestUtil/EmbeddedResources/HLCD.sqlite =================================================================== diff -u Binary files differ Index: Ringtoets/Integration/test/Ringtoets.Integration.TestUtil/EmbeddedResources/HRD dutch coast south.config.sqlite =================================================================== diff -u Binary files differ Index: Ringtoets/Integration/test/Ringtoets.Integration.TestUtil/EmbeddedResources/HRD dutch coast south.sqlite =================================================================== diff -u Binary files differ Index: Ringtoets/Integration/test/Ringtoets.Integration.TestUtil/EmbeddedResources/traject_6-3.dbf =================================================================== diff -u Binary files differ Index: Ringtoets/Integration/test/Ringtoets.Integration.TestUtil/EmbeddedResources/traject_6-3.prj =================================================================== diff -u --- Ringtoets/Integration/test/Ringtoets.Integration.TestUtil/EmbeddedResources/traject_6-3.prj (revision 0) +++ Ringtoets/Integration/test/Ringtoets.Integration.TestUtil/EmbeddedResources/traject_6-3.prj (revision 5d822eca2d7467c9781a4a3a54d796ac4229e4a3) @@ -0,0 +1 @@ +PROJCS["RD_New",GEOGCS["GCS_Amersfoort",DATUM["D_Amersfoort",SPHEROID["Bessel_1841",6377397.155,299.1528128]],PRIMEM["Greenwich",0.0],UNIT["Degree",0.0174532925199433]],PROJECTION["Double_Stereographic"],PARAMETER["False_Easting",155000.0],PARAMETER["False_Northing",463000.0],PARAMETER["Central_Meridian",5.38763888888889],PARAMETER["Scale_Factor",0.9999079],PARAMETER["Latitude_Of_Origin",52.15616055555555],UNIT["Meter",1.0]] \ No newline at end of file Index: Ringtoets/Integration/test/Ringtoets.Integration.TestUtil/EmbeddedResources/traject_6-3.shp =================================================================== diff -u Binary files differ Index: Ringtoets/Integration/test/Ringtoets.Integration.TestUtil/EmbeddedResources/traject_6-3.shx =================================================================== diff -u Binary files differ Index: Ringtoets/Integration/test/Ringtoets.Integration.TestUtil/EmbeddedResources/traject_6-3_vakken.dbf =================================================================== diff -u Binary files differ Index: Ringtoets/Integration/test/Ringtoets.Integration.TestUtil/EmbeddedResources/traject_6-3_vakken.prj =================================================================== diff -u --- Ringtoets/Integration/test/Ringtoets.Integration.TestUtil/EmbeddedResources/traject_6-3_vakken.prj (revision 0) +++ Ringtoets/Integration/test/Ringtoets.Integration.TestUtil/EmbeddedResources/traject_6-3_vakken.prj (revision 5d822eca2d7467c9781a4a3a54d796ac4229e4a3) @@ -0,0 +1 @@ +PROJCS["RD_New",GEOGCS["GCS_Amersfoort",DATUM["D_Amersfoort",SPHEROID["Bessel_1841",6377397.155,299.1528128]],PRIMEM["Greenwich",0.0],UNIT["Degree",0.0174532925199433]],PROJECTION["Double_Stereographic"],PARAMETER["False_Easting",155000.0],PARAMETER["False_Northing",463000.0],PARAMETER["Central_Meridian",5.38763888888889],PARAMETER["Scale_Factor",0.9999079],PARAMETER["Latitude_Of_Origin",52.15616055555555],UNIT["Meter",1.0]] \ No newline at end of file Index: Ringtoets/Integration/test/Ringtoets.Integration.TestUtil/EmbeddedResources/traject_6-3_vakken.shp =================================================================== diff -u Binary files differ Index: Ringtoets/Integration/test/Ringtoets.Integration.TestUtil/EmbeddedResources/traject_6-3_vakken.shx =================================================================== diff -u Binary files differ Index: Ringtoets/Integration/test/Ringtoets.Integration.TestUtil/Properties/AssemblyInfo.cs =================================================================== diff -u --- Ringtoets/Integration/test/Ringtoets.Integration.TestUtil/Properties/AssemblyInfo.cs (revision 0) +++ Ringtoets/Integration/test/Ringtoets.Integration.TestUtil/Properties/AssemblyInfo.cs (revision 5d822eca2d7467c9781a4a3a54d796ac4229e4a3) @@ -0,0 +1,25 @@ +// Copyright (C) Stichting Deltares 2017. All rights reserved. +// +// This file is part of Ringtoets. +// +// Ringtoets is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this program. If not, see . +// +// 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.Reflection; + +[assembly: AssemblyTitle("Ringtoets.Integration.TestUtil")] +[assembly: AssemblyProduct("Ringtoets.Integration.TestUtil")] \ No newline at end of file Index: Ringtoets/Integration/test/Ringtoets.Integration.TestUtil/Ringtoets.Integration.TestUtil.csproj =================================================================== diff -u --- Ringtoets/Integration/test/Ringtoets.Integration.TestUtil/Ringtoets.Integration.TestUtil.csproj (revision 0) +++ Ringtoets/Integration/test/Ringtoets.Integration.TestUtil/Ringtoets.Integration.TestUtil.csproj (revision 5d822eca2d7467c9781a4a3a54d796ac4229e4a3) @@ -0,0 +1,162 @@ + + + + {174BA68D-6176-4AC5-8DFD-98CDD2C4D971} + Ringtoets.Integration.TestUtil + Ringtoets.Integration.TestUtil + + + + + ..\..\..\..\packages\RhinoMocks.3.6.1\lib\net\Rhino.Mocks.dll + True + + + + + + + + + + + + + Copying.licenseheader + + + + + + + + + + + + + + + + + + + + + {3bbfd65b-b277-4e50-ae6d-bd24c3434609} + Core.Common.Base + + + {30e4c2ae-719e-4d70-9fa9-668a9767fbfa} + Core.Common.Gui + + + {f49bd8b2-332a-4c91-a196-8cce0a2c7d98} + Core.Common.Utils + + + {c6309704-d67b-434c-bc98-9f8910bc1d10} + Ringtoets.ClosingStructures.Data + + + {d4200f43-3f72-4f42-af0a-8ced416a38ec} + Ringtoets.Common.Data + + + {52ba7627-cbab-4209-be77-3b5f31378277} + Ringtoets.Common.IO + + + {4843D6E5-066F-4795-94F5-1D53932DD03C} + Ringtoets.Common.Data.TestUtil + + + {D1068432-C172-4AA6-847B-D9DEB4C6DE26} + Ringtoets.DuneErosion.Data + + + {90de728e-48ef-4665-ab38-3d88e41d9f4d} + Ringtoets.GrassCoverErosionInwards.Data + + + {BF753DB5-973B-4ADF-B0F6-9437325C3466} + Ringtoets.GrassCoverErosionInwards.Data.TestUtil + + + {e7225477-577f-4a17-b7ec-6721158e1543} + Ringtoets.GrassCoverErosionOutwards.Data + + + {1c0017d8-35b5-4ca0-8fc7-a83f46dbdc99} + Ringtoets.HeightStructures.Data + + + {83d6b73e-91d5-46b0-9218-955da1f75f7c} + Ringtoets.MacroStabilityInwards.Data + + + {0943dda8-8fab-4d0b-8e9c-8a1a9b3273b4} + Ringtoets.MacroStabilityInwards.IO + + + {B6B27968-6B39-48DF-B2E5-CBABF362808C} + Ringtoets.MacroStabilityInwards.Plugin + + + {E9B39743-2DC9-4922-9E0F-6BA3E0E54189} + Ringtoets.MacroStabilityInwards.Primitives + + + {2B78CF04-4785-4F27-A6E5-45BDDBB7BF04} + Ringtoets.MacroStabilityInwards.Data.TestUtil + + + {ce994cc9-6f6a-48ac-b4be-02c30a21f4db} + Ringtoets.Piping.Data + + + {35B87B7A-7F50-4139-B563-589EE522B1ED} + Ringtoets.Piping.IO + + + {1d3d58b6-ef7e-401e-92a0-104067d222ee} + Ringtoets.Piping.Plugin + + + {14c6f716-64e2-4bc4-a1ef-05865fcefa4c} + Ringtoets.Piping.Primitives + + + {955E574D-67CE-4347-AA6B-7DF8A04ED754} + Ringtoets.Piping.Data.TestUtil + + + {87c2c553-c0bc-40bf-b1ea-b83bff357f27} + Ringtoets.Revetment.Data + + + {3d4b9740-8348-4434-8d77-b611fc6ee57f} + Ringtoets.StabilityPointStructures.Data + + + {b479e3af-7c34-488c-bb73-d324100d36c9} + Ringtoets.StabilityStoneCover.Data + + + {567e0b69-5280-41ce-add6-443725a61c86} + Ringtoets.WaveImpactAsphaltCover.Data + + + {11f1f874-45af-43e4-8ae5-15a5c9593e28} + Ringtoets.Integration.Data + + + {c8383b76-b3f1-4e6e-b56c-527b469fa20a} + Ringtoets.Integration.Plugin + + + {28811c4a-6c18-42c1-88b2-a03a3784e2d0} + Ringtoets.Integration.Service + + + \ No newline at end of file Index: Ringtoets/Integration/test/Ringtoets.Integration.TestUtil/TestDataGenerator.cs =================================================================== diff -u --- Ringtoets/Integration/test/Ringtoets.Integration.TestUtil/TestDataGenerator.cs (revision 0) +++ Ringtoets/Integration/test/Ringtoets.Integration.TestUtil/TestDataGenerator.cs (revision 5d822eca2d7467c9781a4a3a54d796ac4229e4a3) @@ -0,0 +1,1034 @@ +// Copyright (C) Stichting Deltares 2017. All rights reserved. +// +// This file is part of Ringtoets. +// +// Ringtoets is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this program. If not, see . +// +// All names, logos, and references to "Deltares" are registered trademarks of +// Stichting Deltares and remain full property of Stichting Deltares at all times. +// All rights reserved. + +using System.Linq; +using Core.Common.Base.Geometry; +using Ringtoets.ClosingStructures.Data; +using Ringtoets.Common.Data; +using Ringtoets.Common.Data.AssessmentSection; +using Ringtoets.Common.Data.Calculation; +using Ringtoets.Common.Data.DikeProfiles; +using Ringtoets.Common.Data.FailureMechanism; +using Ringtoets.Common.Data.Hydraulics; +using Ringtoets.Common.Data.Structures; +using Ringtoets.Common.Data.TestUtil; +using Ringtoets.DuneErosion.Data; +using Ringtoets.GrassCoverErosionInwards.Data; +using Ringtoets.GrassCoverErosionInwards.Data.TestUtil; +using Ringtoets.GrassCoverErosionOutwards.Data; +using Ringtoets.HeightStructures.Data; +using Ringtoets.Integration.Data; +using Ringtoets.Integration.Service; +using Ringtoets.MacroStabilityInwards.Data.TestUtil; +using Ringtoets.Piping.Data.TestUtil; +using Ringtoets.Revetment.Data; +using Ringtoets.StabilityPointStructures.Data; +using Ringtoets.StabilityStoneCover.Data; +using Ringtoets.WaveImpactAsphaltCover.Data; + +namespace Ringtoets.Integration.TestUtil +{ + /// + /// Class that generates fully configured Ringtoets objects. + /// + public static class TestDataGenerator + { + /// + /// Gets a fully configured with a desired + /// and with all possible configurations for the parent and nested calculations of the failure mechanisms. + /// + /// The desired to initialize the with. + /// A fully configured with all possible configurations of + /// the parent and nested calculation inside the failure mechanisms. + public static AssessmentSection GetAssessmentSectionWithAllCalculationConfigurations( + AssessmentSectionComposition composition = AssessmentSectionComposition.Dike) + { + var hydraulicBoundaryLocation = new HydraulicBoundaryLocation(1, string.Empty, 0, 0) + { + DesignWaterLevelCalculation = + { + Output = new HydraulicBoundaryLocationOutput( + 1.1, double.NaN, double.NaN, double.NaN, double.NaN, CalculationConvergence.CalculatedConverged, null) + }, + WaveHeightCalculation = + { + Output = new HydraulicBoundaryLocationOutput( + 2.2, double.NaN, double.NaN, double.NaN, double.NaN, CalculationConvergence.CalculatedConverged, null) + } + }; + + var assessmentSection = new AssessmentSection(composition) + { + ReferenceLine = new ReferenceLine(), + HydraulicBoundaryDatabase = new HydraulicBoundaryDatabase + { + Locations = + { + hydraulicBoundaryLocation + } + } + }; + + SetFullyConfiguredFailureMechanism(assessmentSection.ClosingStructures, hydraulicBoundaryLocation); + SetFullyConfiguredFailureMechanism(assessmentSection.GrassCoverErosionInwards, hydraulicBoundaryLocation); + MacroStabilityInwardsTestDataGenerator.ConfigureFailureMechanismWithAllCalculationConfigurations(assessmentSection.MacroStabilityInwards, hydraulicBoundaryLocation); + SetFullyConfiguredFailureMechanism(assessmentSection.GrassCoverErosionOutwards, hydraulicBoundaryLocation); + SetFullyConfiguredFailureMechanism(assessmentSection.HeightStructures, hydraulicBoundaryLocation); + PipingTestDataGenerator.ConfigureFailureMechanismWithAllCalculationConfigurations(assessmentSection.Piping, hydraulicBoundaryLocation); + SetFullyConfiguredFailureMechanism(assessmentSection.StabilityPointStructures, hydraulicBoundaryLocation); + SetFullyConfiguredFailureMechanism(assessmentSection.StabilityStoneCover, hydraulicBoundaryLocation); + SetFullyConfiguredFailureMechanism(assessmentSection.WaveImpactAsphaltCover, hydraulicBoundaryLocation); + SetFullyConfiguredFailureMechanism(assessmentSection.DuneErosion, hydraulicBoundaryLocation); + + return assessmentSection; + } + + /// + /// Gets a fully configured with a desired and + /// possible configurations of the parent and nested calculations, but without the output of the + /// , + /// and . + /// + /// The desired to initialize the with. + /// A fully configured with all possible calculation configurations of the parent and + /// nested calculations inside the failure mechanisms, but without the output of the + /// , and . + public static AssessmentSection GetAssessmentSectionWithAllCalculationConfigurationsWithoutHydraulicBoundaryLocationAndDuneOutput( + AssessmentSectionComposition composition = AssessmentSectionComposition.Dike) + { + AssessmentSection assessmentSection = GetAssessmentSectionWithAllCalculationConfigurations(composition); + RingtoetsDataSynchronizationService.ClearHydraulicBoundaryLocationOutput(assessmentSection.HydraulicBoundaryDatabase, assessmentSection); + + return assessmentSection; + } + + /// + /// Gets a fully configured with a desired and + /// possible configurations of the parent and nested calculations, but without any calculation output of the failure mechanisms. + /// + /// The desired to initialize the with. + /// A fully configured with all possible configurations of the parent and nested calculations + /// of the failure mechanisms, but without any calculation output. + public static AssessmentSection GetAssessmentSectionWithAllCalculationConfigurationsWithoutCalculationOutput( + AssessmentSectionComposition composition = AssessmentSectionComposition.Dike) + { + AssessmentSection assessmentSection = GetAssessmentSectionWithAllCalculationConfigurations(composition); + RingtoetsDataSynchronizationService.ClearFailureMechanismCalculationOutputs(assessmentSection); + + return assessmentSection; + } + + /// + /// Gets a fully configured with all + /// possible parent and nested calculation configurations. + /// + public static StabilityStoneCoverFailureMechanism GetStabilityStoneCoverFailureMechanismWithAllCalculationConfigurations() + { + var failureMechanism = new StabilityStoneCoverFailureMechanism(); + var hydroLocation = new HydraulicBoundaryLocation(1, "", 0, 0); + SetFullyConfiguredFailureMechanism(failureMechanism, hydroLocation); + + return failureMechanism; + } + + /// + /// Gets a fully configured with + /// all possible parent and nested calculation configurations. + /// + public static WaveImpactAsphaltCoverFailureMechanism GetWaveImpactAsphaltCoverFailureMechanismWithAllCalculationConfigurations() + { + var failureMechanism = new WaveImpactAsphaltCoverFailureMechanism(); + var hydroLocation = new HydraulicBoundaryLocation(1, "", 0, 0); + SetFullyConfiguredFailureMechanism(failureMechanism, hydroLocation); + + return failureMechanism; + } + + /// + /// Gets a fully configured with + /// all possible parent and nested calculation configurations. + /// + public static GrassCoverErosionOutwardsFailureMechanism GetGrassCoverErosionOutwardsFailureMechanismWithAllCalculationConfigurations() + { + var failureMechanism = new GrassCoverErosionOutwardsFailureMechanism(); + var hydroLocation = new HydraulicBoundaryLocation(1, "", 0, 0); + SetFullyConfiguredFailureMechanism(failureMechanism, hydroLocation); + + return failureMechanism; + } + + /// + /// Gets a fully configured with all possible + /// parent and nested calculation configurations. + /// + public static HeightStructuresFailureMechanism GetHeightStructuresFailureMechanismWithAlLCalculationConfigurations() + { + var failureMechanism = new HeightStructuresFailureMechanism(); + var hydroLocation = new HydraulicBoundaryLocation(1, "", 0, 0); + SetFullyConfiguredFailureMechanism(failureMechanism, hydroLocation); + + return failureMechanism; + } + + /// + /// Gets a fully configured with all possible + /// parent and nested calculation configurations. + /// + public static ClosingStructuresFailureMechanism GetClosingStructuresFailureMechanismWithAllCalculationConfigurations() + { + var failureMechanism = new ClosingStructuresFailureMechanism(); + var hydroLocation = new HydraulicBoundaryLocation(1, "", 0, 0); + SetFullyConfiguredFailureMechanism(failureMechanism, hydroLocation); + + return failureMechanism; + } + + /// + /// Gets a fully configured with all possible + /// parent and nested calculation configurations. + /// + public static StabilityPointStructuresFailureMechanism GetStabilityPointStructuresFailureMechanismWithAllCalculationConfigurations() + { + var failureMechanism = new StabilityPointStructuresFailureMechanism(); + var hydroLocation = new HydraulicBoundaryLocation(1, "", 0, 0); + SetFullyConfiguredFailureMechanism(failureMechanism, hydroLocation); + + return failureMechanism; + } + + /// + /// Gets a fully configured with all possible + /// parent and nested calculation configurations. + /// + public static GrassCoverErosionInwardsFailureMechanism GetGrassCoverErosionInwardsFailureMechanismWithAllCalculationConfigurations() + { + var failureMechanism = new GrassCoverErosionInwardsFailureMechanism(); + var hydroLocation = new HydraulicBoundaryLocation(1, "", 0, 0); + SetFullyConfiguredFailureMechanism(failureMechanism, hydroLocation); + + return failureMechanism; + } + + private static void SetFullyConfiguredFailureMechanism(GrassCoverErosionInwardsFailureMechanism failureMechanism, + HydraulicBoundaryLocation hydraulicBoundaryLocation) + { + var dikeprofile1 = new DikeProfile(new Point2D(0, 0), + new[] + { + new RoughnessPoint(new Point2D(0, 0), 0.5), + new RoughnessPoint(new Point2D(1, 1), 0.6), + new RoughnessPoint(new Point2D(4, 5), 0.8), + new RoughnessPoint(new Point2D(10, 1), 1.0) + }, + new[] + { + new Point2D(0, 0), + new Point2D(1, 1), + new Point2D(4, 5), + new Point2D(10, 1) + }, + new BreakWater(BreakWaterType.Caisson, 1.3), + new DikeProfile.ConstructionProperties + { + Id = "aid", + Name = "A", + DikeHeight = 5, + Orientation = 20, + X0 = 0 + }); + var dikeprofile2 = new DikeProfile(new Point2D(10, 10), + new[] + { + new RoughnessPoint(new Point2D(0, 1), 1.0), + new RoughnessPoint(new Point2D(1, 2), 0.6), + new RoughnessPoint(new Point2D(4, 2), 0.5), + new RoughnessPoint(new Point2D(10, 0), 0.8) + }, + new[] + { + new Point2D(0, 1), + new Point2D(1, 2), + new Point2D(4, 2), + new Point2D(10, 0) + }, + new BreakWater(BreakWaterType.Caisson, 1.3), + new DikeProfile.ConstructionProperties + { + Id = "bid", + Name = "B", + DikeHeight = 3, + Orientation = 20, + X0 = 0 + }); + + failureMechanism.DikeProfiles.AddRange(new[] + { + dikeprofile1, + dikeprofile2 + }, "some/path/to/dikeprofiles"); + + var calculation = new GrassCoverErosionInwardsCalculation(); + var calculationWithOutputAndDikeProfileAndHydraulicBoundaryLocation = new GrassCoverErosionInwardsCalculation + { + InputParameters = + { + HydraulicBoundaryLocation = hydraulicBoundaryLocation, + DikeProfile = dikeprofile1 + }, + Output = new GrassCoverErosionInwardsOutput(new TestOvertoppingOutput(0), + new TestDikeHeightOutput(0, CalculationConvergence.CalculatedConverged), + new TestOvertoppingRateOutput(0, CalculationConvergence.CalculatedConverged)) + }; + var calculationWithOutputAndHydraulicBoundaryLocation = new GrassCoverErosionInwardsCalculation + { + InputParameters = + { + HydraulicBoundaryLocation = hydraulicBoundaryLocation + }, + Output = new GrassCoverErosionInwardsOutput(new TestOvertoppingOutput(0), + new TestDikeHeightOutput(0, CalculationConvergence.CalculatedConverged), + new TestOvertoppingRateOutput(0, CalculationConvergence.CalculatedConverged)) + }; + var calculationWithHydraulicBoundaryLocation = new GrassCoverErosionInwardsCalculation + { + InputParameters = + { + HydraulicBoundaryLocation = hydraulicBoundaryLocation + } + }; + var calculationWithDikeProfileAndHydraulicBoundaryLocation = new GrassCoverErosionInwardsCalculation + { + InputParameters = + { + HydraulicBoundaryLocation = hydraulicBoundaryLocation, + DikeProfile = dikeprofile2 + } + }; + + var subCalculation = new GrassCoverErosionInwardsCalculation(); + var subCalculationWithOutputAndDikeProfileAndHydraulicBoundaryLocation = new GrassCoverErosionInwardsCalculation + { + InputParameters = + { + HydraulicBoundaryLocation = hydraulicBoundaryLocation, + DikeProfile = dikeprofile2 + }, + Output = new GrassCoverErosionInwardsOutput(new TestOvertoppingOutput(0), + new TestDikeHeightOutput(0, CalculationConvergence.CalculatedConverged), + new TestOvertoppingRateOutput(0, CalculationConvergence.CalculatedConverged)) + }; + var subCalculationWithOutputAndHydraulicBoundaryLocation = new GrassCoverErosionInwardsCalculation + { + InputParameters = + { + HydraulicBoundaryLocation = hydraulicBoundaryLocation + }, + Output = new GrassCoverErosionInwardsOutput(new TestOvertoppingOutput(0), + new TestDikeHeightOutput(0, CalculationConvergence.CalculatedConverged), + new TestOvertoppingRateOutput(0, CalculationConvergence.CalculatedConverged)) + }; + var subCalculationWithHydraulicBoundaryLocation = new GrassCoverErosionInwardsCalculation + { + InputParameters = + { + HydraulicBoundaryLocation = hydraulicBoundaryLocation + } + }; + var subCalculationWithDikeProfileAndHydraulicBoundaryLocation = new GrassCoverErosionInwardsCalculation + { + InputParameters = + { + HydraulicBoundaryLocation = hydraulicBoundaryLocation, + DikeProfile = dikeprofile2 + } + }; + + failureMechanism.CalculationsGroup.Children.Add(calculation); + failureMechanism.CalculationsGroup.Children.Add(calculationWithOutputAndDikeProfileAndHydraulicBoundaryLocation); + failureMechanism.CalculationsGroup.Children.Add(calculationWithOutputAndHydraulicBoundaryLocation); + failureMechanism.CalculationsGroup.Children.Add(calculationWithHydraulicBoundaryLocation); + failureMechanism.CalculationsGroup.Children.Add(calculationWithDikeProfileAndHydraulicBoundaryLocation); + failureMechanism.CalculationsGroup.Children.Add(new CalculationGroup + { + Children = + { + subCalculation, + subCalculationWithOutputAndDikeProfileAndHydraulicBoundaryLocation, + subCalculationWithOutputAndHydraulicBoundaryLocation, + subCalculationWithHydraulicBoundaryLocation, + subCalculationWithDikeProfileAndHydraulicBoundaryLocation + } + }); + + var section1 = new FailureMechanismSection("1", + new[] + { + new Point2D(-1, -1), + new Point2D(5, 5) + }); + var section2 = new FailureMechanismSection("2", + new[] + { + new Point2D(5, 5), + new Point2D(15, 15) + }); + failureMechanism.AddSection(section1); + failureMechanism.AddSection(section2); + + failureMechanism.SectionResults.ElementAt(0).Calculation = calculationWithOutputAndDikeProfileAndHydraulicBoundaryLocation; + failureMechanism.SectionResults.ElementAt(1).Calculation = subCalculationWithOutputAndDikeProfileAndHydraulicBoundaryLocation; + } + + private static void SetFullyConfiguredFailureMechanism(HeightStructuresFailureMechanism failureMechanism, + HydraulicBoundaryLocation hydraulicBoundaryLocation) + { + var profile1 = new ForeshoreProfile(new Point2D(0, 0), + new[] + { + new Point2D(0, 0), + new Point2D(10, 0) + }, + new BreakWater(BreakWaterType.Caisson, 1.1), new ForeshoreProfile.ConstructionProperties + { + Id = "aid", + Name = "A", + Orientation = 30, + X0 = 0 + }); + var profile2 = new ForeshoreProfile(new Point2D(10, 10), + new[] + { + new Point2D(0, 2), + new Point2D(20, 2) + }, + new BreakWater(BreakWaterType.Dam, 2.2), new ForeshoreProfile.ConstructionProperties + { + Id = "bid", + Name = "B", + Orientation = 50, + X0 = 10 + }); + + failureMechanism.ForeshoreProfiles.AddRange(new[] + { + profile1, + profile2 + }, "path"); + + SetConfiguredStructuresCalculations(failureMechanism, hydraulicBoundaryLocation, profile1, profile2); + } + + private static void SetFullyConfiguredFailureMechanism(ClosingStructuresFailureMechanism failureMechanism, + HydraulicBoundaryLocation hydraulicBoundaryLocation) + { + var profile1 = new ForeshoreProfile(new Point2D(0, 0), + new[] + { + new Point2D(0, 0), + new Point2D(10, 0) + }, + new BreakWater(BreakWaterType.Caisson, 1.1), new ForeshoreProfile.ConstructionProperties + { + Id = "aid", + Name = "A", + Orientation = 30, + X0 = 0 + }); + var profile2 = new ForeshoreProfile(new Point2D(10, 10), + new[] + { + new Point2D(0, 2), + new Point2D(20, 2) + }, + new BreakWater(BreakWaterType.Dam, 2.2), new ForeshoreProfile.ConstructionProperties + { + Id = "bid", + Name = "B", + Orientation = 50, + X0 = 10 + }); + + failureMechanism.ForeshoreProfiles.AddRange(new[] + { + profile1, + profile2 + }, "some/path/to/foreshoreprofiles"); + SetConfiguredStructuresCalculations(failureMechanism, hydraulicBoundaryLocation, profile1, profile2); + } + + private static void SetFullyConfiguredFailureMechanism(StabilityPointStructuresFailureMechanism failureMechanism, + HydraulicBoundaryLocation hydraulicBoundaryLocation) + { + var profile1 = new ForeshoreProfile(new Point2D(0, 0), + new[] + { + new Point2D(0, 0), + new Point2D(10, 0) + }, + new BreakWater(BreakWaterType.Caisson, 1.1), new ForeshoreProfile.ConstructionProperties + { + Id = "aid", + Name = "A", + Orientation = 30, + X0 = 0 + }); + var profile2 = new ForeshoreProfile(new Point2D(10, 10), + new[] + { + new Point2D(0, 2), + new Point2D(20, 2) + }, + new BreakWater(BreakWaterType.Dam, 2.2), new ForeshoreProfile.ConstructionProperties + { + Id = "bid", + Name = "B", + Orientation = 50, + X0 = 10 + }); + + failureMechanism.ForeshoreProfiles.AddRange(new[] + { + profile1, + profile2 + }, "some/path/to/foreshoreprofiles"); + SetConfiguredStructuresCalculations(failureMechanism, hydraulicBoundaryLocation, profile1, profile2); + } + + private static void SetConfiguredStructuresCalculations( + ICalculatableFailureMechanism failureMechanism, + HydraulicBoundaryLocation hydraulicBoundaryLocation, + ForeshoreProfile profile1, + ForeshoreProfile profile2) + where TStructureBase : StructureBase + where TCalculationInput : StructuresInputBase, new() + { + var calculation = new StructuresCalculation(); + var calculationWithOutputAndHydraulicBoundaryLocation = new StructuresCalculation + { + InputParameters = + { + HydraulicBoundaryLocation = hydraulicBoundaryLocation + }, + Output = new TestStructuresOutput() + }; + var calculationWithHydraulicBoundaryLocationAndForeshoreProfile = new StructuresCalculation + { + InputParameters = + { + HydraulicBoundaryLocation = hydraulicBoundaryLocation, + ForeshoreProfile = profile1 + } + }; + var calculationWithOutputAndHydraulicBoundaryLocationAndForeshoreProfiles = new StructuresCalculation + { + InputParameters = + { + HydraulicBoundaryLocation = hydraulicBoundaryLocation, + ForeshoreProfile = profile2 + }, + Output = new TestStructuresOutput() + }; + var calculationWithHydraulicBoundaryLocation = new StructuresCalculation + { + InputParameters = + { + HydraulicBoundaryLocation = hydraulicBoundaryLocation + } + }; + + var subCalculation = new StructuresCalculation(); + var subCalculationWithOutputAndHydraulicBoundaryLocation = new StructuresCalculation + { + InputParameters = + { + HydraulicBoundaryLocation = hydraulicBoundaryLocation + }, + Output = new TestStructuresOutput() + }; + var subCalculationWithOutputAndHydraulicBoundaryLocationAndForeshoreProfile = new StructuresCalculation + { + InputParameters = + { + HydraulicBoundaryLocation = hydraulicBoundaryLocation, + ForeshoreProfile = profile2 + }, + Output = new TestStructuresOutput() + }; + var subCalculationWithHydraulicBoundaryLocation = new StructuresCalculation + { + InputParameters = + { + HydraulicBoundaryLocation = hydraulicBoundaryLocation + } + }; + var subCalculationWithHydraulicBoundaryLocationAndForeshoreProfile = new StructuresCalculation + { + InputParameters = + { + HydraulicBoundaryLocation = hydraulicBoundaryLocation, + ForeshoreProfile = profile1 + } + }; + + failureMechanism.CalculationsGroup.Children.Add(calculation); + failureMechanism.CalculationsGroup.Children.Add(calculationWithOutputAndHydraulicBoundaryLocation); + failureMechanism.CalculationsGroup.Children.Add(calculationWithHydraulicBoundaryLocationAndForeshoreProfile); + failureMechanism.CalculationsGroup.Children.Add(calculationWithOutputAndHydraulicBoundaryLocationAndForeshoreProfiles); + failureMechanism.CalculationsGroup.Children.Add(calculationWithHydraulicBoundaryLocation); + failureMechanism.CalculationsGroup.Children.Add(new CalculationGroup + { + Children = + { + subCalculation, + subCalculationWithOutputAndHydraulicBoundaryLocation, + subCalculationWithOutputAndHydraulicBoundaryLocationAndForeshoreProfile, + subCalculationWithHydraulicBoundaryLocation, + subCalculationWithHydraulicBoundaryLocationAndForeshoreProfile + } + }); + } + + private static void SetFullyConfiguredFailureMechanism(StabilityStoneCoverFailureMechanism failureMechanism, + HydraulicBoundaryLocation hydraulicBoundaryLocation) + { + var profile1 = new ForeshoreProfile(new Point2D(0, 0), + new[] + { + new Point2D(0, 0), + new Point2D(10, 0) + }, + new BreakWater(BreakWaterType.Caisson, 1.1), new ForeshoreProfile.ConstructionProperties + { + Id = "aid", + Name = "A", + Orientation = 30, + X0 = 0 + }); + var profile2 = new ForeshoreProfile(new Point2D(10, 10), + new[] + { + new Point2D(0, 2), + new Point2D(20, 2) + }, + new BreakWater(BreakWaterType.Dam, 2.2), new ForeshoreProfile.ConstructionProperties + { + Id = "bid", + Name = "B", + Orientation = 50, + X0 = 10 + }); + + failureMechanism.ForeshoreProfiles.AddRange(new[] + { + profile1, + profile2 + }, "path"); + var calculation = new StabilityStoneCoverWaveConditionsCalculation(); + var calculationWithOutputAndHydraulicBoundaryLocation = new StabilityStoneCoverWaveConditionsCalculation + { + InputParameters = + { + HydraulicBoundaryLocation = hydraulicBoundaryLocation + }, + Output = new StabilityStoneCoverWaveConditionsOutput(Enumerable.Empty(), + Enumerable.Empty()) + }; + var calculationWithForeshoreProfile = new StabilityStoneCoverWaveConditionsCalculation + { + InputParameters = + { + HydraulicBoundaryLocation = hydraulicBoundaryLocation, + ForeshoreProfile = profile1 + } + }; + var calculationWithOutputAndHydraulicBoundaryLocationAndForeshoreProfile = new StabilityStoneCoverWaveConditionsCalculation + { + InputParameters = + { + HydraulicBoundaryLocation = hydraulicBoundaryLocation, + ForeshoreProfile = profile2 + }, + Output = new StabilityStoneCoverWaveConditionsOutput(Enumerable.Empty(), + Enumerable.Empty()) + }; + var calculationWithHydraulicBoundaryLocation = new StabilityStoneCoverWaveConditionsCalculation + { + InputParameters = + { + HydraulicBoundaryLocation = hydraulicBoundaryLocation + } + }; + + var subCalculation = new StabilityStoneCoverWaveConditionsCalculation(); + var subCalculationWithOutputAndHydraulicBoundarLocationAndForeshoreProfile = new StabilityStoneCoverWaveConditionsCalculation + { + InputParameters = + { + HydraulicBoundaryLocation = hydraulicBoundaryLocation, + ForeshoreProfile = profile2 + }, + Output = new StabilityStoneCoverWaveConditionsOutput(Enumerable.Empty(), + Enumerable.Empty()) + }; + var subCalculationWithOutputAndHydraulicBoundaryLocation = new StabilityStoneCoverWaveConditionsCalculation + { + InputParameters = + { + HydraulicBoundaryLocation = hydraulicBoundaryLocation + }, + Output = new StabilityStoneCoverWaveConditionsOutput(Enumerable.Empty(), + Enumerable.Empty()) + }; + var subCalculationWithHydraulicBoundaryLocation = new StabilityStoneCoverWaveConditionsCalculation + { + InputParameters = + { + HydraulicBoundaryLocation = hydraulicBoundaryLocation + } + }; + var subCalculationWithHydraulicBoundaryLocationAndForeshoreProfile = new StabilityStoneCoverWaveConditionsCalculation + { + InputParameters = + { + HydraulicBoundaryLocation = hydraulicBoundaryLocation, + ForeshoreProfile = profile2 + } + }; + + failureMechanism.WaveConditionsCalculationGroup.Children.Add(calculation); + failureMechanism.WaveConditionsCalculationGroup.Children.Add(calculationWithOutputAndHydraulicBoundaryLocation); + failureMechanism.WaveConditionsCalculationGroup.Children.Add(calculationWithForeshoreProfile); + failureMechanism.WaveConditionsCalculationGroup.Children.Add(calculationWithOutputAndHydraulicBoundaryLocationAndForeshoreProfile); + failureMechanism.WaveConditionsCalculationGroup.Children.Add(calculationWithHydraulicBoundaryLocation); + failureMechanism.WaveConditionsCalculationGroup.Children.Add(new CalculationGroup + { + Children = + { + subCalculation, + subCalculationWithOutputAndHydraulicBoundarLocationAndForeshoreProfile, + subCalculationWithOutputAndHydraulicBoundaryLocation, + subCalculationWithHydraulicBoundaryLocation, + subCalculationWithHydraulicBoundaryLocationAndForeshoreProfile + } + }); + } + + private static void SetFullyConfiguredFailureMechanism(WaveImpactAsphaltCoverFailureMechanism failureMechanism, + HydraulicBoundaryLocation hydraulicBoundaryLocation) + { + var profile1 = new ForeshoreProfile(new Point2D(0, 0), + new[] + { + new Point2D(0, 0), + new Point2D(10, 0) + }, + new BreakWater(BreakWaterType.Caisson, 1.1), new ForeshoreProfile.ConstructionProperties + { + Id = "aid", + Name = "A", + Orientation = 30, + X0 = 0 + }); + var profile2 = new ForeshoreProfile(new Point2D(10, 10), + new[] + { + new Point2D(0, 2), + new Point2D(20, 2) + }, + new BreakWater(BreakWaterType.Dam, 2.2), new ForeshoreProfile.ConstructionProperties + { + Id = "bid", + Name = "B", + Orientation = 50, + X0 = 10 + }); + + failureMechanism.ForeshoreProfiles.AddRange(new[] + { + profile1, + profile2 + }, "path"); + + var calculation = new WaveImpactAsphaltCoverWaveConditionsCalculation(); + var calculationWithOutputAndHydraulicBoundaryLocation = new WaveImpactAsphaltCoverWaveConditionsCalculation + { + InputParameters = + { + HydraulicBoundaryLocation = hydraulicBoundaryLocation + }, + Output = new WaveImpactAsphaltCoverWaveConditionsOutput(Enumerable.Empty()) + }; + var calculationWithForeshoreProfile = new WaveImpactAsphaltCoverWaveConditionsCalculation + { + InputParameters = + { + HydraulicBoundaryLocation = hydraulicBoundaryLocation, + ForeshoreProfile = profile1 + } + }; + var calculationWithOutputAndHydraulicBoundaryLocationAndForeshoreProfile = new WaveImpactAsphaltCoverWaveConditionsCalculation + { + InputParameters = + { + HydraulicBoundaryLocation = hydraulicBoundaryLocation, + ForeshoreProfile = profile2 + }, + Output = new WaveImpactAsphaltCoverWaveConditionsOutput(Enumerable.Empty()) + }; + var calculationWithHydraulicBoundaryLocation = new WaveImpactAsphaltCoverWaveConditionsCalculation + { + InputParameters = + { + HydraulicBoundaryLocation = hydraulicBoundaryLocation + } + }; + + var subCalculation = new WaveImpactAsphaltCoverWaveConditionsCalculation(); + var subCalculationWithOutputAndHydraulicBoundarLocationAndForeshoreProfile = new WaveImpactAsphaltCoverWaveConditionsCalculation + { + InputParameters = + { + HydraulicBoundaryLocation = hydraulicBoundaryLocation, + ForeshoreProfile = profile2 + }, + Output = new WaveImpactAsphaltCoverWaveConditionsOutput(Enumerable.Empty()) + }; + var subCalculationWithOutputAndHydraulicBoundaryLocation = new WaveImpactAsphaltCoverWaveConditionsCalculation + { + InputParameters = + { + HydraulicBoundaryLocation = hydraulicBoundaryLocation + }, + Output = new WaveImpactAsphaltCoverWaveConditionsOutput(Enumerable.Empty()) + }; + var subCalculationWithHydraulicBoundaryLocation = new WaveImpactAsphaltCoverWaveConditionsCalculation + { + InputParameters = + { + HydraulicBoundaryLocation = hydraulicBoundaryLocation + } + }; + var subCalculationWithHydraulicBoundaryLocationAndForeshoreProfile = new WaveImpactAsphaltCoverWaveConditionsCalculation + { + InputParameters = + { + HydraulicBoundaryLocation = hydraulicBoundaryLocation, + ForeshoreProfile = profile2 + } + }; + + failureMechanism.WaveConditionsCalculationGroup.Children.Add(calculation); + failureMechanism.WaveConditionsCalculationGroup.Children.Add(calculationWithOutputAndHydraulicBoundaryLocation); + failureMechanism.WaveConditionsCalculationGroup.Children.Add(calculationWithForeshoreProfile); + failureMechanism.WaveConditionsCalculationGroup.Children.Add(calculationWithOutputAndHydraulicBoundaryLocationAndForeshoreProfile); + failureMechanism.WaveConditionsCalculationGroup.Children.Add(calculationWithHydraulicBoundaryLocation); + failureMechanism.WaveConditionsCalculationGroup.Children.Add(new CalculationGroup + { + Children = + { + subCalculation, + subCalculationWithOutputAndHydraulicBoundarLocationAndForeshoreProfile, + subCalculationWithOutputAndHydraulicBoundaryLocation, + subCalculationWithHydraulicBoundaryLocation, + subCalculationWithHydraulicBoundaryLocationAndForeshoreProfile + } + }); + } + + private static void SetFullyConfiguredFailureMechanism(GrassCoverErosionOutwardsFailureMechanism failureMechanism, + HydraulicBoundaryLocation hydraulicBoundaryLocation) + { + var internalHydroLocation = new HydraulicBoundaryLocation(hydraulicBoundaryLocation.Id, + hydraulicBoundaryLocation.Name, + hydraulicBoundaryLocation.Location.X, + hydraulicBoundaryLocation.Location.Y) + { + WaveHeightCalculation = + { + Output = new HydraulicBoundaryLocationOutput( + hydraulicBoundaryLocation.WaveHeight + 0.2, double.NaN, double.NaN, double.NaN, double.NaN, + hydraulicBoundaryLocation.WaveHeightCalculationConvergence, null) + }, + DesignWaterLevelCalculation = + { + Output = new HydraulicBoundaryLocationOutput( + hydraulicBoundaryLocation.DesignWaterLevel + 0.3, double.NaN, double.NaN, double.NaN, double.NaN, + hydraulicBoundaryLocation.DesignWaterLevelCalculationConvergence, null) + } + }; + failureMechanism.HydraulicBoundaryLocations.Add(internalHydroLocation); + var profile1 = new ForeshoreProfile(new Point2D(0, 0), + new[] + { + new Point2D(0, 0), + new Point2D(10, 0) + }, + new BreakWater(BreakWaterType.Caisson, 1.1), new ForeshoreProfile.ConstructionProperties + { + Id = "aid", + Name = "A", + Orientation = 30, + X0 = 0 + }); + var profile2 = new ForeshoreProfile(new Point2D(10, 10), + new[] + { + new Point2D(0, 2), + new Point2D(20, 2) + }, + new BreakWater(BreakWaterType.Dam, 2.2), new ForeshoreProfile.ConstructionProperties + { + Id = "bid", + Name = "B", + Orientation = 50, + X0 = 10 + }); + + failureMechanism.ForeshoreProfiles.AddRange(new[] + { + profile1, + profile2 + }, "path"); + + var calculation = new GrassCoverErosionOutwardsWaveConditionsCalculation(); + var calculationWithOutputAndHydraulicBoundaryLocation = new GrassCoverErosionOutwardsWaveConditionsCalculation + { + InputParameters = + { + HydraulicBoundaryLocation = hydraulicBoundaryLocation + }, + Output = new GrassCoverErosionOutwardsWaveConditionsOutput(Enumerable.Empty()) + }; + var calculationWithHydraulicBoundaryLocationAndhForeshoreProfile = new GrassCoverErosionOutwardsWaveConditionsCalculation + { + InputParameters = + { + HydraulicBoundaryLocation = hydraulicBoundaryLocation, + ForeshoreProfile = profile1 + } + }; + var calculationWithOutputAndHydraulicBoundaryLocationAndForeshoreProfile = new GrassCoverErosionOutwardsWaveConditionsCalculation + { + InputParameters = + { + HydraulicBoundaryLocation = hydraulicBoundaryLocation, + ForeshoreProfile = profile2 + }, + Output = new GrassCoverErosionOutwardsWaveConditionsOutput(Enumerable.Empty()) + }; + var calculationWithHydraulicBoundaryLocation = new GrassCoverErosionOutwardsWaveConditionsCalculation + { + InputParameters = + { + HydraulicBoundaryLocation = hydraulicBoundaryLocation + } + }; + + var subCalculation = new GrassCoverErosionOutwardsWaveConditionsCalculation(); + var subCalculationWithOutputAndHydraulicBoundarLocationAndForeshoreProfile = new GrassCoverErosionOutwardsWaveConditionsCalculation + { + InputParameters = + { + HydraulicBoundaryLocation = hydraulicBoundaryLocation, + ForeshoreProfile = profile2 + }, + Output = new GrassCoverErosionOutwardsWaveConditionsOutput(Enumerable.Empty()) + }; + var subCalculationWithOutputAndHydraulicBoundaryLocation = new GrassCoverErosionOutwardsWaveConditionsCalculation + { + InputParameters = + { + HydraulicBoundaryLocation = hydraulicBoundaryLocation + }, + Output = new GrassCoverErosionOutwardsWaveConditionsOutput(Enumerable.Empty()) + }; + var subCalculationWithHydraulicBoundaryLocation = new GrassCoverErosionOutwardsWaveConditionsCalculation + { + InputParameters = + { + HydraulicBoundaryLocation = hydraulicBoundaryLocation + } + }; + var subCalculationWithHydraulicBoundaryLocationAndForeshoreProfile = new GrassCoverErosionOutwardsWaveConditionsCalculation + { + InputParameters = + { + HydraulicBoundaryLocation = hydraulicBoundaryLocation, + ForeshoreProfile = profile2 + } + }; + + failureMechanism.WaveConditionsCalculationGroup.Children.Add(calculation); + failureMechanism.WaveConditionsCalculationGroup.Children.Add(calculationWithOutputAndHydraulicBoundaryLocation); + failureMechanism.WaveConditionsCalculationGroup.Children.Add(calculationWithHydraulicBoundaryLocationAndhForeshoreProfile); + failureMechanism.WaveConditionsCalculationGroup.Children.Add(calculationWithOutputAndHydraulicBoundaryLocationAndForeshoreProfile); + failureMechanism.WaveConditionsCalculationGroup.Children.Add(calculationWithHydraulicBoundaryLocation); + failureMechanism.WaveConditionsCalculationGroup.Children.Add(new CalculationGroup + { + Children = + { + subCalculation, + subCalculationWithOutputAndHydraulicBoundarLocationAndForeshoreProfile, + subCalculationWithOutputAndHydraulicBoundaryLocation, + subCalculationWithHydraulicBoundaryLocation, + subCalculationWithHydraulicBoundaryLocationAndForeshoreProfile + } + }); + } + + private static void SetFullyConfiguredFailureMechanism(DuneErosionFailureMechanism failureMechanism, + HydraulicBoundaryLocation hydraulicBoundaryLocation) + { + var duneLocation = new DuneLocation(hydraulicBoundaryLocation.Id, + hydraulicBoundaryLocation.Name, + new Point2D(hydraulicBoundaryLocation.Location), + new DuneLocation.ConstructionProperties + { + CoastalAreaId = 7, + Offset = 20, + Orientation = 180, + D50 = 0.00008 + }); + + var duneLocationWithOutput = new DuneLocation(hydraulicBoundaryLocation.Id, + hydraulicBoundaryLocation.Name, + new Point2D(hydraulicBoundaryLocation.Location), + new DuneLocation.ConstructionProperties + { + CoastalAreaId = 7, + Offset = 20, + Orientation = 180, + D50 = 0.00008 + }) + { + Output = new DuneLocationOutput(CalculationConvergence.CalculatedConverged, new DuneLocationOutput.ConstructionProperties + { + WaterLevel = hydraulicBoundaryLocation.DesignWaterLevel + 0.2, + WaveHeight = hydraulicBoundaryLocation.WaveHeight + 0.3, + WavePeriod = 10 + }) + }; + + failureMechanism.DuneLocations.Add(duneLocation); + failureMechanism.DuneLocations.Add(duneLocationWithOutput); + } + } +} \ No newline at end of file Index: Ringtoets/Integration/test/Ringtoets.Integration.TestUtil/packages.config =================================================================== diff -u --- Ringtoets/Integration/test/Ringtoets.Integration.TestUtil/packages.config (revision 0) +++ Ringtoets/Integration/test/Ringtoets.Integration.TestUtil/packages.config (revision 5d822eca2d7467c9781a4a3a54d796ac4229e4a3) @@ -0,0 +1,25 @@ + + + + \ No newline at end of file Fisheye: Tag 5d822eca2d7467c9781a4a3a54d796ac4229e4a3 refers to a dead (removed) revision in file `Ringtoets/Integration/test/Ringtoets.Integration.TestUtils.Test/DataImportHelperTest.cs'. Fisheye: No comparison available. Pass `N' to diff? Fisheye: Tag 5d822eca2d7467c9781a4a3a54d796ac4229e4a3 refers to a dead (removed) revision in file `Ringtoets/Integration/test/Ringtoets.Integration.TestUtils.Test/DataUpdateHelperTest.cs'. Fisheye: No comparison available. Pass `N' to diff? Fisheye: Tag 5d822eca2d7467c9781a4a3a54d796ac4229e4a3 refers to a dead (removed) revision in file `Ringtoets/Integration/test/Ringtoets.Integration.TestUtils.Test/Properties/AssemblyInfo.cs'. Fisheye: No comparison available. Pass `N' to diff? Fisheye: Tag 5d822eca2d7467c9781a4a3a54d796ac4229e4a3 refers to a dead (removed) revision in file `Ringtoets/Integration/test/Ringtoets.Integration.TestUtils.Test/Ringtoets.Integration.TestUtils.Test.csproj'. Fisheye: No comparison available. Pass `N' to diff? Fisheye: Tag 5d822eca2d7467c9781a4a3a54d796ac4229e4a3 refers to a dead (removed) revision in file `Ringtoets/Integration/test/Ringtoets.Integration.TestUtils.Test/TestDataGeneratorTest.cs'. Fisheye: No comparison available. Pass `N' to diff? Fisheye: Tag 5d822eca2d7467c9781a4a3a54d796ac4229e4a3 refers to a dead (removed) revision in file `Ringtoets/Integration/test/Ringtoets.Integration.TestUtils.Test/packages.config'. Fisheye: No comparison available. Pass `N' to diff? Fisheye: Tag 5d822eca2d7467c9781a4a3a54d796ac4229e4a3 refers to a dead (removed) revision in file `Ringtoets/Integration/test/Ringtoets.Integration.TestUtils/DataImportHelper.cs'. Fisheye: No comparison available. Pass `N' to diff? Fisheye: Tag 5d822eca2d7467c9781a4a3a54d796ac4229e4a3 refers to a dead (removed) revision in file `Ringtoets/Integration/test/Ringtoets.Integration.TestUtils/DataUpdateHelper.cs'. Fisheye: No comparison available. Pass `N' to diff? Index: Ringtoets/Integration/test/Ringtoets.Integration.TestUtils/EmbeddedResources/DR6.soil =================================================================== diff -u -r9c559a5caa7beee491208b136a7d55f813308007 -r5d822eca2d7467c9781a4a3a54d796ac4229e4a3 Binary files differ Fisheye: Tag 5d822eca2d7467c9781a4a3a54d796ac4229e4a3 refers to a dead (removed) revision in file `Ringtoets/Integration/test/Ringtoets.Integration.TestUtils/EmbeddedResources/DR6_surfacelines.csv'. Fisheye: No comparison available. Pass `N' to diff? Fisheye: Tag 5d822eca2d7467c9781a4a3a54d796ac4229e4a3 refers to a dead (removed) revision in file `Ringtoets/Integration/test/Ringtoets.Integration.TestUtils/EmbeddedResources/DR6_surfacelines.krp.csv'. Fisheye: No comparison available. Pass `N' to diff? Index: Ringtoets/Integration/test/Ringtoets.Integration.TestUtils/EmbeddedResources/DR6_updated.soil =================================================================== diff -u -r9c559a5caa7beee491208b136a7d55f813308007 -r5d822eca2d7467c9781a4a3a54d796ac4229e4a3 Binary files differ Index: Ringtoets/Integration/test/Ringtoets.Integration.TestUtils/EmbeddedResources/HLCD.sqlite =================================================================== diff -u -rf8c28b3b04cdabb62ea37772efcb1f4ebbbf2b9e -r5d822eca2d7467c9781a4a3a54d796ac4229e4a3 Binary files differ Index: Ringtoets/Integration/test/Ringtoets.Integration.TestUtils/EmbeddedResources/HRD dutch coast south.config.sqlite =================================================================== diff -u -r97fd85a69fb9570efb56640cb3c301f4af9f3b62 -r5d822eca2d7467c9781a4a3a54d796ac4229e4a3 Binary files differ Index: Ringtoets/Integration/test/Ringtoets.Integration.TestUtils/EmbeddedResources/HRD dutch coast south.sqlite =================================================================== diff -u -r97fd85a69fb9570efb56640cb3c301f4af9f3b62 -r5d822eca2d7467c9781a4a3a54d796ac4229e4a3 Binary files differ Index: Ringtoets/Integration/test/Ringtoets.Integration.TestUtils/EmbeddedResources/traject_6-3.dbf =================================================================== diff -u -r97fd85a69fb9570efb56640cb3c301f4af9f3b62 -r5d822eca2d7467c9781a4a3a54d796ac4229e4a3 Binary files differ Fisheye: Tag 5d822eca2d7467c9781a4a3a54d796ac4229e4a3 refers to a dead (removed) revision in file `Ringtoets/Integration/test/Ringtoets.Integration.TestUtils/EmbeddedResources/traject_6-3.prj'. Fisheye: No comparison available. Pass `N' to diff? Index: Ringtoets/Integration/test/Ringtoets.Integration.TestUtils/EmbeddedResources/traject_6-3.shp =================================================================== diff -u -r97fd85a69fb9570efb56640cb3c301f4af9f3b62 -r5d822eca2d7467c9781a4a3a54d796ac4229e4a3 Binary files differ Index: Ringtoets/Integration/test/Ringtoets.Integration.TestUtils/EmbeddedResources/traject_6-3.shx =================================================================== diff -u -r97fd85a69fb9570efb56640cb3c301f4af9f3b62 -r5d822eca2d7467c9781a4a3a54d796ac4229e4a3 Binary files differ Index: Ringtoets/Integration/test/Ringtoets.Integration.TestUtils/EmbeddedResources/traject_6-3_vakken.dbf =================================================================== diff -u -r97fd85a69fb9570efb56640cb3c301f4af9f3b62 -r5d822eca2d7467c9781a4a3a54d796ac4229e4a3 Binary files differ Fisheye: Tag 5d822eca2d7467c9781a4a3a54d796ac4229e4a3 refers to a dead (removed) revision in file `Ringtoets/Integration/test/Ringtoets.Integration.TestUtils/EmbeddedResources/traject_6-3_vakken.prj'. Fisheye: No comparison available. Pass `N' to diff? Index: Ringtoets/Integration/test/Ringtoets.Integration.TestUtils/EmbeddedResources/traject_6-3_vakken.shp =================================================================== diff -u -r97fd85a69fb9570efb56640cb3c301f4af9f3b62 -r5d822eca2d7467c9781a4a3a54d796ac4229e4a3 Binary files differ Index: Ringtoets/Integration/test/Ringtoets.Integration.TestUtils/EmbeddedResources/traject_6-3_vakken.shx =================================================================== diff -u -r97fd85a69fb9570efb56640cb3c301f4af9f3b62 -r5d822eca2d7467c9781a4a3a54d796ac4229e4a3 Binary files differ Fisheye: Tag 5d822eca2d7467c9781a4a3a54d796ac4229e4a3 refers to a dead (removed) revision in file `Ringtoets/Integration/test/Ringtoets.Integration.TestUtils/Properties/AssemblyInfo.cs'. Fisheye: No comparison available. Pass `N' to diff? Fisheye: Tag 5d822eca2d7467c9781a4a3a54d796ac4229e4a3 refers to a dead (removed) revision in file `Ringtoets/Integration/test/Ringtoets.Integration.TestUtils/Ringtoets.Integration.TestUtils.csproj'. Fisheye: No comparison available. Pass `N' to diff? Fisheye: Tag 5d822eca2d7467c9781a4a3a54d796ac4229e4a3 refers to a dead (removed) revision in file `Ringtoets/Integration/test/Ringtoets.Integration.TestUtils/TestDataGenerator.cs'. Fisheye: No comparison available. Pass `N' to diff? Fisheye: Tag 5d822eca2d7467c9781a4a3a54d796ac4229e4a3 refers to a dead (removed) revision in file `Ringtoets/Integration/test/Ringtoets.Integration.TestUtils/packages.config'. Fisheye: No comparison available. Pass `N' to diff? Index: Ringtoets/MacroStabilityInwards/test/Ringtoets.MacroStabilityInwards.Integration.Test/MacroStabilityInwardsCalculationsViewIntegrationTest.cs =================================================================== diff -u -r49621ecdce5a2a8f7c8bb689e8cfd6759dfb8fc6 -r5d822eca2d7467c9781a4a3a54d796ac4229e4a3 --- Ringtoets/MacroStabilityInwards/test/Ringtoets.MacroStabilityInwards.Integration.Test/MacroStabilityInwardsCalculationsViewIntegrationTest.cs (.../MacroStabilityInwardsCalculationsViewIntegrationTest.cs) (revision 49621ecdce5a2a8f7c8bb689e8cfd6759dfb8fc6) +++ Ringtoets/MacroStabilityInwards/test/Ringtoets.MacroStabilityInwards.Integration.Test/MacroStabilityInwardsCalculationsViewIntegrationTest.cs (.../MacroStabilityInwardsCalculationsViewIntegrationTest.cs) (revision 5d822eca2d7467c9781a4a3a54d796ac4229e4a3) @@ -27,7 +27,7 @@ using Ringtoets.Common.Data.Calculation; using Ringtoets.Common.Data.FailureMechanism; using Ringtoets.Integration.Data; -using Ringtoets.Integration.TestUtils; +using Ringtoets.Integration.TestUtil; using Ringtoets.MacroStabilityInwards.Data; using Ringtoets.MacroStabilityInwards.Data.SoilProfile; using Ringtoets.MacroStabilityInwards.Forms.Views; Index: Ringtoets/MacroStabilityInwards/test/Ringtoets.MacroStabilityInwards.Integration.Test/MacroStabilityInwardsFailureMechanismResultViewIntegrationTest.cs =================================================================== diff -u -r49621ecdce5a2a8f7c8bb689e8cfd6759dfb8fc6 -r5d822eca2d7467c9781a4a3a54d796ac4229e4a3 --- Ringtoets/MacroStabilityInwards/test/Ringtoets.MacroStabilityInwards.Integration.Test/MacroStabilityInwardsFailureMechanismResultViewIntegrationTest.cs (.../MacroStabilityInwardsFailureMechanismResultViewIntegrationTest.cs) (revision 49621ecdce5a2a8f7c8bb689e8cfd6759dfb8fc6) +++ Ringtoets/MacroStabilityInwards/test/Ringtoets.MacroStabilityInwards.Integration.Test/MacroStabilityInwardsFailureMechanismResultViewIntegrationTest.cs (.../MacroStabilityInwardsFailureMechanismResultViewIntegrationTest.cs) (revision 5d822eca2d7467c9781a4a3a54d796ac4229e4a3) @@ -28,7 +28,7 @@ using Ringtoets.Common.Data.Calculation; using Ringtoets.Common.Data.FailureMechanism; using Ringtoets.Integration.Data; -using Ringtoets.Integration.TestUtils; +using Ringtoets.Integration.TestUtil; using Ringtoets.MacroStabilityInwards.Data; using Ringtoets.MacroStabilityInwards.Data.TestUtil; using Ringtoets.MacroStabilityInwards.Forms.Views; Index: Ringtoets/MacroStabilityInwards/test/Ringtoets.MacroStabilityInwards.Integration.Test/Ringtoets.MacroStabilityInwards.Integration.Test.csproj =================================================================== diff -u -r63fc151e9cf722527465c1eddfa6567a90feb5e6 -r5d822eca2d7467c9781a4a3a54d796ac4229e4a3 --- Ringtoets/MacroStabilityInwards/test/Ringtoets.MacroStabilityInwards.Integration.Test/Ringtoets.MacroStabilityInwards.Integration.Test.csproj (.../Ringtoets.MacroStabilityInwards.Integration.Test.csproj) (revision 63fc151e9cf722527465c1eddfa6567a90feb5e6) +++ Ringtoets/MacroStabilityInwards/test/Ringtoets.MacroStabilityInwards.Integration.Test/Ringtoets.MacroStabilityInwards.Integration.Test.csproj (.../Ringtoets.MacroStabilityInwards.Integration.Test.csproj) (revision 5d822eca2d7467c9781a4a3a54d796ac4229e4a3) @@ -44,9 +44,9 @@ {11F1F874-45AF-43E4-8AE5-15A5C9593E28} Ringtoets.Integration.Data - + {174ba68d-6176-4ac5-8dfd-98cdd2c4d971} - Ringtoets.Integration.TestUtils + Ringtoets.Integration.TestUtil {83d6b73e-91d5-46b0-9218-955da1f75f7c} Index: Ringtoets/Piping/test/Ringtoets.Piping.Integration.Test/PipingCalculationsViewIntegrationTest.cs =================================================================== diff -u -r49621ecdce5a2a8f7c8bb689e8cfd6759dfb8fc6 -r5d822eca2d7467c9781a4a3a54d796ac4229e4a3 --- Ringtoets/Piping/test/Ringtoets.Piping.Integration.Test/PipingCalculationsViewIntegrationTest.cs (.../PipingCalculationsViewIntegrationTest.cs) (revision 49621ecdce5a2a8f7c8bb689e8cfd6759dfb8fc6) +++ Ringtoets/Piping/test/Ringtoets.Piping.Integration.Test/PipingCalculationsViewIntegrationTest.cs (.../PipingCalculationsViewIntegrationTest.cs) (revision 5d822eca2d7467c9781a4a3a54d796ac4229e4a3) @@ -29,7 +29,7 @@ using Ringtoets.Common.Data.Calculation; using Ringtoets.Common.Data.FailureMechanism; using Ringtoets.Integration.Data; -using Ringtoets.Integration.TestUtils; +using Ringtoets.Integration.TestUtil; using Ringtoets.Piping.Data; using Ringtoets.Piping.Data.SoilProfile; using Ringtoets.Piping.Forms.Views; Index: Ringtoets/Piping/test/Ringtoets.Piping.Integration.Test/PipingFailureMechanismResultViewIntegrationTest.cs =================================================================== diff -u -r49621ecdce5a2a8f7c8bb689e8cfd6759dfb8fc6 -r5d822eca2d7467c9781a4a3a54d796ac4229e4a3 --- Ringtoets/Piping/test/Ringtoets.Piping.Integration.Test/PipingFailureMechanismResultViewIntegrationTest.cs (.../PipingFailureMechanismResultViewIntegrationTest.cs) (revision 49621ecdce5a2a8f7c8bb689e8cfd6759dfb8fc6) +++ Ringtoets/Piping/test/Ringtoets.Piping.Integration.Test/PipingFailureMechanismResultViewIntegrationTest.cs (.../PipingFailureMechanismResultViewIntegrationTest.cs) (revision 5d822eca2d7467c9781a4a3a54d796ac4229e4a3) @@ -28,7 +28,7 @@ using Ringtoets.Common.Data.Calculation; using Ringtoets.Common.Data.FailureMechanism; using Ringtoets.Integration.Data; -using Ringtoets.Integration.TestUtils; +using Ringtoets.Integration.TestUtil; using Ringtoets.Piping.Data; using Ringtoets.Piping.Data.TestUtil; using Ringtoets.Piping.Forms.Views; Index: Ringtoets/Piping/test/Ringtoets.Piping.Integration.Test/Ringtoets.Piping.Integration.Test.csproj =================================================================== diff -u -r63fc151e9cf722527465c1eddfa6567a90feb5e6 -r5d822eca2d7467c9781a4a3a54d796ac4229e4a3 --- Ringtoets/Piping/test/Ringtoets.Piping.Integration.Test/Ringtoets.Piping.Integration.Test.csproj (.../Ringtoets.Piping.Integration.Test.csproj) (revision 63fc151e9cf722527465c1eddfa6567a90feb5e6) +++ Ringtoets/Piping/test/Ringtoets.Piping.Integration.Test/Ringtoets.Piping.Integration.Test.csproj (.../Ringtoets.Piping.Integration.Test.csproj) (revision 5d822eca2d7467c9781a4a3a54d796ac4229e4a3) @@ -48,9 +48,9 @@ {11F1F874-45AF-43E4-8AE5-15A5C9593E28} Ringtoets.Integration.Data - + {174ba68d-6176-4ac5-8dfd-98cdd2c4d971} - Ringtoets.Integration.TestUtils + Ringtoets.Integration.TestUtil {7cd038e1-e111-4969-aced-22c5bd2974e1}