Index: Application/Ringtoets/src/Application.Ringtoets.Storage/Create/CalculationGroupCreateExtensions.cs =================================================================== diff -u -r3fb0df0ed6e64657154700ee7706e035d5bf99f5 -rc6f21599d10c85adba65b4e50985b17ba1b44a22 --- Application/Ringtoets/src/Application.Ringtoets.Storage/Create/CalculationGroupCreateExtensions.cs (.../CalculationGroupCreateExtensions.cs) (revision 3fb0df0ed6e64657154700ee7706e035d5bf99f5) +++ Application/Ringtoets/src/Application.Ringtoets.Storage/Create/CalculationGroupCreateExtensions.cs (.../CalculationGroupCreateExtensions.cs) (revision c6f21599d10c85adba65b4e50985b17ba1b44a22) @@ -22,6 +22,7 @@ using System; using Application.Ringtoets.Storage.Create.GrassCoverErosionInwards; using Application.Ringtoets.Storage.Create.GrassCoverErosionOutwards; +using Application.Ringtoets.Storage.Create.MacroStabilityInwards; using Application.Ringtoets.Storage.Create.Piping; using Application.Ringtoets.Storage.Create.StabilityStoneCover; using Application.Ringtoets.Storage.Create.WaveImpactAsphaltCover; @@ -33,6 +34,7 @@ using Ringtoets.GrassCoverErosionInwards.Data; using Ringtoets.GrassCoverErosionOutwards.Data; using Ringtoets.HeightStructures.Data; +using Ringtoets.MacroStabilityInwards.Data; using Ringtoets.Piping.Data; using Ringtoets.StabilityPointStructures.Data; using Ringtoets.StabilityStoneCover.Data; @@ -86,6 +88,11 @@ { entity.PipingCalculationEntities.Add(childPipingCalculation.Create(registry, i)); } + var childMacroStabilityInwardsCalculation = calculationBase as MacroStabilityInwardsCalculationScenario; + if (childMacroStabilityInwardsCalculation != null) + { + entity.MacroStabilityInwardsCalculationEntities.Add(childMacroStabilityInwardsCalculation.Create(registry, i)); + } var childGrassCoverErosionInwardsCalculation = calculationBase as GrassCoverErosionInwardsCalculation; if (childGrassCoverErosionInwardsCalculation != null) { Index: Application/Ringtoets/src/Application.Ringtoets.Storage/Read/CalculationGroupEntityReadExtentions.cs =================================================================== diff -u -r3fb0df0ed6e64657154700ee7706e035d5bf99f5 -rc6f21599d10c85adba65b4e50985b17ba1b44a22 --- Application/Ringtoets/src/Application.Ringtoets.Storage/Read/CalculationGroupEntityReadExtentions.cs (.../CalculationGroupEntityReadExtentions.cs) (revision 3fb0df0ed6e64657154700ee7706e035d5bf99f5) +++ Application/Ringtoets/src/Application.Ringtoets.Storage/Read/CalculationGroupEntityReadExtentions.cs (.../CalculationGroupEntityReadExtentions.cs) (revision c6f21599d10c85adba65b4e50985b17ba1b44a22) @@ -26,6 +26,7 @@ using Application.Ringtoets.Storage.Read.GrassCoverErosionInwards; using Application.Ringtoets.Storage.Read.GrassCoverErosionOutwards; using Application.Ringtoets.Storage.Read.HeightStructures; +using Application.Ringtoets.Storage.Read.MacroStabilityInwards; using Application.Ringtoets.Storage.Read.Piping; using Application.Ringtoets.Storage.Read.StabilityPointStructures; using Application.Ringtoets.Storage.Read.StabilityStoneCover; @@ -92,6 +93,42 @@ /// The object keeping track of read operations. /// A new . /// Thrown when is null. + internal static CalculationGroup ReadAsMacroStabilityInwardsCalculationGroup(this CalculationGroupEntity entity, + ReadConversionCollector collector) + { + if (collector == null) + { + throw new ArgumentNullException(nameof(collector)); + } + + var group = new CalculationGroup(entity.Name, true); + + foreach (object childEntity in GetChildEntitiesInOrder(entity)) + { + var childCalculationGroupEntity = childEntity as CalculationGroupEntity; + if (childCalculationGroupEntity != null) + { + group.Children.Add(childCalculationGroupEntity.ReadAsMacroStabilityInwardsCalculationGroup(collector)); + } + var childCalculationEntity = childEntity as MacroStabilityInwardsCalculationEntity; + if (childCalculationEntity != null) + { + group.Children.Add(childCalculationEntity.Read(collector)); + } + } + + return group; + } + + /// + /// Read the and use the information to construct + /// a . + /// + /// The to create + /// for. + /// The object keeping track of read operations. + /// A new . + /// Thrown when is null. internal static CalculationGroup ReadAsGrassCoverErosionInwardsCalculationGroup(this CalculationGroupEntity entity, ReadConversionCollector collector) { @@ -374,6 +411,10 @@ { sortedList.Add(calculationEntity.Order, calculationEntity); } + foreach (MacroStabilityInwardsCalculationEntity calculationEntity in entity.MacroStabilityInwardsCalculationEntities) + { + sortedList.Add(calculationEntity.Order, calculationEntity); + } return sortedList.Values; } } Index: Application/Ringtoets/test/Application.Ringtoets.Storage.Test/Create/CalculationGroupCreateExtensionsTest.cs =================================================================== diff -u -r3fb0df0ed6e64657154700ee7706e035d5bf99f5 -rc6f21599d10c85adba65b4e50985b17ba1b44a22 --- Application/Ringtoets/test/Application.Ringtoets.Storage.Test/Create/CalculationGroupCreateExtensionsTest.cs (.../CalculationGroupCreateExtensionsTest.cs) (revision 3fb0df0ed6e64657154700ee7706e035d5bf99f5) +++ Application/Ringtoets/test/Application.Ringtoets.Storage.Test/Create/CalculationGroupCreateExtensionsTest.cs (.../CalculationGroupCreateExtensionsTest.cs) (revision c6f21599d10c85adba65b4e50985b17ba1b44a22) @@ -30,6 +30,7 @@ using Ringtoets.GrassCoverErosionInwards.Data; using Ringtoets.GrassCoverErosionOutwards.Data; using Ringtoets.HeightStructures.Data; +using Ringtoets.MacroStabilityInwards.Data; using Ringtoets.Piping.Data; using Ringtoets.StabilityPointStructures.Data; using Ringtoets.StabilityStoneCover.Data; @@ -235,6 +236,94 @@ } [Test] + public void Create_GroupWithMacroStabilityInwardsCalculations_CreatesEntities() + { + // Setup + var group = new CalculationGroup("root", true) + { + Children = + { + new MacroStabilityInwardsCalculationScenario + { + Name = "A" + }, + new MacroStabilityInwardsCalculationScenario + { + Name = "B" + } + } + }; + + var registry = new PersistenceRegistry(); + + // Call + CalculationGroupEntity entity = group.Create(registry, 0); + + // Assert + MacroStabilityInwardsCalculationEntity[] childCalculationEntities = entity.MacroStabilityInwardsCalculationEntities.ToArray(); + Assert.AreEqual(2, childCalculationEntities.Length); + + MacroStabilityInwardsCalculationEntity childEntity1 = childCalculationEntities[0]; + Assert.AreEqual("A", childEntity1.Name); + Assert.AreEqual(0, childEntity1.Order); + + MacroStabilityInwardsCalculationEntity childEntity2 = childCalculationEntities[1]; + Assert.AreEqual("B", childEntity2.Name); + Assert.AreEqual(1, childEntity2.Order); + } + + [Test] + public void Create_GroupWithChildMacroStabilityInwardsCalculationsAndChildCalculationGroups_CreateEntities() + { + // Setup + var group = new CalculationGroup("root", true) + { + Children = + { + new CalculationGroup("A", true), + new MacroStabilityInwardsCalculationScenario + { + Name = "B" + }, + new CalculationGroup("C", true), + new MacroStabilityInwardsCalculationScenario + { + Name = "D" + } + } + }; + + var registry = new PersistenceRegistry(); + + // Call + CalculationGroupEntity entity = group.Create(registry, 0); + + // Assert + CalculationGroupEntity[] childGroupEntities = entity.CalculationGroupEntity1.ToArray(); + MacroStabilityInwardsCalculationEntity[] childCalculationEntities = entity.MacroStabilityInwardsCalculationEntities.ToArray(); + Assert.AreEqual(2, childGroupEntities.Length); + Assert.AreEqual(2, childCalculationEntities.Length); + + CalculationGroupEntity childEntity1 = childGroupEntities[0]; + Assert.AreEqual("A", childEntity1.Name); + Assert.AreEqual(0, childEntity1.Order); + CollectionAssert.IsEmpty(childEntity1.CalculationGroupEntity1); + + MacroStabilityInwardsCalculationEntity childEntity2 = childCalculationEntities[0]; + Assert.AreEqual("B", childEntity2.Name); + Assert.AreEqual(1, childEntity2.Order); + + CalculationGroupEntity childEntity3 = childGroupEntities[1]; + Assert.AreEqual("C", childEntity3.Name); + Assert.AreEqual(2, childEntity3.Order); + CollectionAssert.IsEmpty(childEntity3.CalculationGroupEntity1); + + MacroStabilityInwardsCalculationEntity childEntity4 = childCalculationEntities[1]; + Assert.AreEqual("D", childEntity4.Name); + Assert.AreEqual(3, childEntity4.Order); + } + + [Test] public void Create_GroupWithChildGrassCoverErosionInwardsCalculations_CreateEntities() { // Setup Index: Application/Ringtoets/test/Application.Ringtoets.Storage.Test/Create/Piping/PipingCalculationScenarioCreateExtensionsTest.cs =================================================================== diff -u -r33d8b4610b6bc2979e35aa3e23b881a9933e40b5 -rc6f21599d10c85adba65b4e50985b17ba1b44a22 --- Application/Ringtoets/test/Application.Ringtoets.Storage.Test/Create/Piping/PipingCalculationScenarioCreateExtensionsTest.cs (.../PipingCalculationScenarioCreateExtensionsTest.cs) (revision 33d8b4610b6bc2979e35aa3e23b881a9933e40b5) +++ Application/Ringtoets/test/Application.Ringtoets.Storage.Test/Create/Piping/PipingCalculationScenarioCreateExtensionsTest.cs (.../PipingCalculationScenarioCreateExtensionsTest.cs) (revision c6f21599d10c85adba65b4e50985b17ba1b44a22) @@ -29,6 +29,7 @@ using Core.Common.TestUtil; using NUnit.Framework; using Ringtoets.Common.Data.Hydraulics; +using Ringtoets.Common.Data.TestUtil; using Ringtoets.Piping.Data; using Ringtoets.Piping.Data.SoilProfile; using Ringtoets.Piping.Data.TestUtil; @@ -281,7 +282,20 @@ PipingCalculationEntity entity = calculation.Create(registry, 0); // Assert - Assert.AreEqual(1, entity.PipingCalculationOutputEntities.Count); + PipingCalculationOutputEntity outputEntity = entity.PipingCalculationOutputEntities.FirstOrDefault(); + + Assert.IsNotNull(outputEntity); + Assert.AreEqual(newOutput.HeaveFactorOfSafety, outputEntity.HeaveFactorOfSafety); + Assert.AreEqual(newOutput.HeaveZValue, outputEntity.HeaveZValue); + Assert.AreEqual(newOutput.SellmeijerFactorOfSafety, outputEntity.SellmeijerFactorOfSafety); + Assert.AreEqual(newOutput.SellmeijerZValue, outputEntity.SellmeijerZValue); + Assert.AreEqual(newOutput.UpliftFactorOfSafety, outputEntity.UpliftFactorOfSafety); + Assert.AreEqual(newOutput.UpliftZValue, outputEntity.UpliftZValue); + Assert.AreEqual(newOutput.UpliftEffectiveStress, outputEntity.UpliftEffectiveStress, newOutput.UpliftEffectiveStress.GetAccuracy()); + Assert.AreEqual(newOutput.HeaveGradient, outputEntity.HeaveGradient, newOutput.HeaveGradient.GetAccuracy()); + Assert.AreEqual(newOutput.SellmeijerCreepCoefficient, outputEntity.SellmeijerCreepCoefficient, newOutput.SellmeijerCreepCoefficient.GetAccuracy()); + Assert.AreEqual(newOutput.SellmeijerCriticalFall, outputEntity.SellmeijerCriticalFall, newOutput.SellmeijerCriticalFall.GetAccuracy()); + Assert.AreEqual(newOutput.SellmeijerReducedFall, outputEntity.SellmeijerReducedFall, newOutput.SellmeijerReducedFall.GetAccuracy()); } [Test] @@ -304,7 +318,23 @@ PipingCalculationEntity entity = calculation.Create(registry, 0); // Assert - Assert.AreEqual(1, entity.PipingSemiProbabilisticOutputEntities.Count); + PipingSemiProbabilisticOutputEntity outputEntity = entity.PipingSemiProbabilisticOutputEntities.FirstOrDefault(); + + Assert.IsNotNull(outputEntity); + Assert.AreEqual(newOutput.UpliftFactorOfSafety, outputEntity.UpliftFactorOfSafety, newOutput.UpliftFactorOfSafety.GetAccuracy()); + Assert.AreEqual(newOutput.UpliftReliability, outputEntity.UpliftReliability, newOutput.UpliftReliability.GetAccuracy()); + Assert.AreEqual(newOutput.UpliftProbability, outputEntity.UpliftProbability); + Assert.AreEqual(newOutput.HeaveFactorOfSafety, outputEntity.HeaveFactorOfSafety, newOutput.HeaveFactorOfSafety.GetAccuracy()); + Assert.AreEqual(newOutput.HeaveReliability, outputEntity.HeaveReliability, newOutput.HeaveReliability.GetAccuracy()); + Assert.AreEqual(newOutput.HeaveProbability, outputEntity.HeaveProbability); + Assert.AreEqual(newOutput.SellmeijerFactorOfSafety, outputEntity.SellmeijerFactorOfSafety, newOutput.SellmeijerFactorOfSafety.GetAccuracy()); + Assert.AreEqual(newOutput.SellmeijerReliability, outputEntity.SellmeijerReliability, newOutput.SellmeijerReliability.GetAccuracy()); + Assert.AreEqual(newOutput.SellmeijerProbability, outputEntity.SellmeijerProbability); + Assert.AreEqual(newOutput.RequiredProbability, outputEntity.RequiredProbability); + Assert.AreEqual(newOutput.RequiredReliability, outputEntity.RequiredReliability, newOutput.RequiredReliability.GetAccuracy()); + Assert.AreEqual(newOutput.PipingProbability, outputEntity.PipingProbability); + Assert.AreEqual(newOutput.PipingReliability, outputEntity.PipingReliability, newOutput.PipingReliability.GetAccuracy()); + Assert.AreEqual(newOutput.PipingFactorOfSafety, outputEntity.PipingFactorOfSafety, newOutput.PipingFactorOfSafety.GetAccuracy()); } } } \ No newline at end of file Index: Application/Ringtoets/test/Application.Ringtoets.Storage.Test/Create/Piping/PipingOutputCreateExtensionsTest.cs =================================================================== diff -u -r5276b5e82afd56701abd55dd098651fb9ac504e2 -rc6f21599d10c85adba65b4e50985b17ba1b44a22 --- Application/Ringtoets/test/Application.Ringtoets.Storage.Test/Create/Piping/PipingOutputCreateExtensionsTest.cs (.../PipingOutputCreateExtensionsTest.cs) (revision 5276b5e82afd56701abd55dd098651fb9ac504e2) +++ Application/Ringtoets/test/Application.Ringtoets.Storage.Test/Create/Piping/PipingOutputCreateExtensionsTest.cs (.../PipingOutputCreateExtensionsTest.cs) (revision c6f21599d10c85adba65b4e50985b17ba1b44a22) @@ -23,6 +23,7 @@ using Application.Ringtoets.Storage.Create.Piping; using Application.Ringtoets.Storage.DbContext; using NUnit.Framework; +using Ringtoets.Common.Data.TestUtil; using Ringtoets.Piping.Data; namespace Application.Ringtoets.Storage.Test.Create.Piping @@ -70,11 +71,11 @@ Assert.AreEqual(pipingOutput.SellmeijerZValue, entity.SellmeijerZValue); Assert.AreEqual(pipingOutput.UpliftFactorOfSafety, entity.UpliftFactorOfSafety); Assert.AreEqual(pipingOutput.UpliftZValue, entity.UpliftZValue); - Assert.AreEqual(pipingOutput.UpliftEffectiveStress.Value, entity.UpliftEffectiveStress); - Assert.AreEqual(pipingOutput.HeaveGradient.Value, entity.HeaveGradient); - Assert.AreEqual(pipingOutput.SellmeijerCreepCoefficient.Value, entity.SellmeijerCreepCoefficient); - Assert.AreEqual(pipingOutput.SellmeijerCriticalFall.Value, entity.SellmeijerCriticalFall); - Assert.AreEqual(pipingOutput.SellmeijerReducedFall.Value, entity.SellmeijerReducedFall); + Assert.AreEqual(pipingOutput.UpliftEffectiveStress, entity.UpliftEffectiveStress, pipingOutput.UpliftEffectiveStress.GetAccuracy()); + Assert.AreEqual(pipingOutput.HeaveGradient, entity.HeaveGradient, pipingOutput.HeaveGradient.GetAccuracy()); + Assert.AreEqual(pipingOutput.SellmeijerCreepCoefficient, entity.SellmeijerCreepCoefficient, pipingOutput.SellmeijerCreepCoefficient.GetAccuracy()); + Assert.AreEqual(pipingOutput.SellmeijerCriticalFall, entity.SellmeijerCriticalFall, pipingOutput.SellmeijerCriticalFall.GetAccuracy()); + Assert.AreEqual(pipingOutput.SellmeijerReducedFall, entity.SellmeijerReducedFall, pipingOutput.SellmeijerReducedFall.GetAccuracy()); } [Test] Index: Application/Ringtoets/test/Application.Ringtoets.Storage.Test/Read/CalculationGroupEntityReadExtentionsTest.cs =================================================================== diff -u -r8e213638a22dd9f04d965d875bb58156db019be5 -rc6f21599d10c85adba65b4e50985b17ba1b44a22 --- Application/Ringtoets/test/Application.Ringtoets.Storage.Test/Read/CalculationGroupEntityReadExtentionsTest.cs (.../CalculationGroupEntityReadExtentionsTest.cs) (revision 8e213638a22dd9f04d965d875bb58156db019be5) +++ Application/Ringtoets/test/Application.Ringtoets.Storage.Test/Read/CalculationGroupEntityReadExtentionsTest.cs (.../CalculationGroupEntityReadExtentionsTest.cs) (revision c6f21599d10c85adba65b4e50985b17ba1b44a22) @@ -30,6 +30,7 @@ using Ringtoets.GrassCoverErosionInwards.Data; using Ringtoets.GrassCoverErosionOutwards.Data; using Ringtoets.HeightStructures.Data; +using Ringtoets.MacroStabilityInwards.Data; using Ringtoets.Piping.Data; using Ringtoets.StabilityPointStructures.Data; using Ringtoets.StabilityStoneCover.Data; @@ -258,6 +259,204 @@ #endregion + #region Macro Stability Inwards + + [Test] + public void ReadAsMacroStabilityInwardsCalculationGroup_ReadConversionCollectorIsNull_ThrowArgumentNullException() + { + // Setup + var entity = new CalculationGroupEntity(); + + // Call + TestDelegate call = () => entity.ReadAsMacroStabilityInwardsCalculationGroup(null); + + // Assert + string paramName = Assert.Throws(call).ParamName; + Assert.AreEqual("collector", paramName); + } + + [Test] + [TestCase("A")] + [TestCase("b")] + public void ReadAsMacroStabilityInwardsCalculationGroup_EntityWithoutChildren_CreateCalculationGroupWithoutChildren( + string name) + { + // Setup + var entity = new CalculationGroupEntity + { + Name = name + }; + + var collector = new ReadConversionCollector(); + + // Call + CalculationGroup group = entity.ReadAsMacroStabilityInwardsCalculationGroup(collector); + + // Assert + Assert.AreEqual(name, group.Name); + CollectionAssert.IsEmpty(group.Children); + } + + [Test] + public void ReadAsMacroStabilityInwardsCalculationGroup_EntityWithChildGroups_CreateCalculationGroupWithChildGroups() + { + // Setup + var rootGroupEntity = new CalculationGroupEntity + { + Name = "A", + CalculationGroupEntity1 = + { + new CalculationGroupEntity + { + Name = "AA", + Order = 0 + }, + new CalculationGroupEntity + { + Name = "AB", + CalculationGroupEntity1 = + { + new CalculationGroupEntity + { + Name = "ABB", + Order = 1 + }, + new CalculationGroupEntity + { + Name = "ABA", + Order = 0 + } + }, + Order = 1 + } + } + }; + + var collector = new ReadConversionCollector(); + + // Call + CalculationGroup rootGroup = rootGroupEntity.ReadAsMacroStabilityInwardsCalculationGroup(collector); + + // Assert + Assert.AreEqual("A", rootGroup.Name); + + List rootChildren = rootGroup.Children; + var rootChildGroup1 = (CalculationGroup) rootChildren[0]; + Assert.AreEqual("AA", rootChildGroup1.Name); + CollectionAssert.IsEmpty(rootChildGroup1.Children); + var rootChildGroup2 = (CalculationGroup) rootChildren[1]; + Assert.AreEqual("AB", rootChildGroup2.Name); + + List rootChildGroup2Children = rootChildGroup2.Children; + var rootChildGroup1Child1 = (CalculationGroup) rootChildGroup2Children[0]; + Assert.AreEqual("ABA", rootChildGroup1Child1.Name); + CollectionAssert.IsEmpty(rootChildGroup1Child1.Children); + var rootChildGroup1Child2 = (CalculationGroup) rootChildGroup2Children[1]; + Assert.AreEqual("ABB", rootChildGroup1Child2.Name); + CollectionAssert.IsEmpty(rootChildGroup1Child2.Children); + } + + [Test] + public void ReadAsMacroStabilityInwardsCalculationGroup_EntityWithChildMacroStabilityInwardsCalculations_CreateCalculationGroupWithChildCalculations() + { + // Setup + var rootGroupEntity = new CalculationGroupEntity + { + Name = "A", + MacroStabilityInwardsCalculationEntities = + { + new MacroStabilityInwardsCalculationEntity + { + Order = 1, + Name = "2", + TangentLineNumber = 1 + }, + new MacroStabilityInwardsCalculationEntity + { + Order = 0, + Name = "1", + TangentLineNumber = 1 + } + } + }; + + var collector = new ReadConversionCollector(); + + // Call + CalculationGroup rootGroup = rootGroupEntity.ReadAsMacroStabilityInwardsCalculationGroup(collector); + + // Assert + List rootChildren = rootGroup.Children; + Assert.AreEqual(2, rootChildren.Count); + + var rootChildCalculation1 = (MacroStabilityInwardsCalculationScenario) rootChildren[0]; + Assert.AreEqual("1", rootChildCalculation1.Name); + + var rootChildCalculation2 = (MacroStabilityInwardsCalculationScenario) rootChildren[1]; + Assert.AreEqual("2", rootChildCalculation2.Name); + } + + [Test] + public void ReadAsMacroStabilityInwardsCalculationGroup_EntityWithChildMacroStabilityInwardsCalculationsAndGroups_CreateCalculationGroupWithChildCalculationsAndGroups() + { + // Setup + var rootGroupEntity = new CalculationGroupEntity + { + Name = "A", + MacroStabilityInwardsCalculationEntities = + { + new MacroStabilityInwardsCalculationEntity + { + Order = 0, + Name = "calculation1", + TangentLineNumber = 1 + }, + new MacroStabilityInwardsCalculationEntity + { + Order = 2, + Name = "calculation2", + TangentLineNumber = 2 + } + }, + CalculationGroupEntity1 = + { + new CalculationGroupEntity + { + Order = 3, + Name = "group2" + }, + new CalculationGroupEntity + { + Order = 1, + Name = "group1" + } + } + }; + + var collector = new ReadConversionCollector(); + + // Call + CalculationGroup rootGroup = rootGroupEntity.ReadAsMacroStabilityInwardsCalculationGroup(collector); + + // Assert + List rootChildren = rootGroup.Children; + Assert.AreEqual(4, rootChildren.Count); + + var rootChildCalculation1 = (MacroStabilityInwardsCalculationScenario) rootChildren[0]; + Assert.AreEqual("calculation1", rootChildCalculation1.Name); + + var rootChildGroup1 = (CalculationGroup) rootChildren[1]; + Assert.AreEqual("group1", rootChildGroup1.Name); + + var rootChildCalculation2 = (MacroStabilityInwardsCalculationScenario) rootChildren[2]; + Assert.AreEqual("calculation2", rootChildCalculation2.Name); + + var rootChildGroup2 = (CalculationGroup) rootChildren[3]; + Assert.AreEqual("group2", rootChildGroup2.Name); + } + + #endregion + #region Grass Cover Erosion Inwards [Test] Index: Application/Ringtoets/test/Application.Ringtoets.Storage.Test/Read/Piping/PipingCalculationEntityReadExtensionsTest.cs =================================================================== diff -u -r33d8b4610b6bc2979e35aa3e23b881a9933e40b5 -rc6f21599d10c85adba65b4e50985b17ba1b44a22 --- Application/Ringtoets/test/Application.Ringtoets.Storage.Test/Read/Piping/PipingCalculationEntityReadExtensionsTest.cs (.../PipingCalculationEntityReadExtensionsTest.cs) (revision 33d8b4610b6bc2979e35aa3e23b881a9933e40b5) +++ Application/Ringtoets/test/Application.Ringtoets.Storage.Test/Read/Piping/PipingCalculationEntityReadExtensionsTest.cs (.../PipingCalculationEntityReadExtensionsTest.cs) (revision c6f21599d10c85adba65b4e50985b17ba1b44a22) @@ -349,7 +349,20 @@ PipingCalculationScenario calculation = entity.Read(collector, new GeneralPipingInput()); // Assert - Assert.IsNotNull(calculation.Output); + PipingOutput output = calculation.Output; + Assert.IsNotNull(output); + + Assert.IsNaN(output.HeaveFactorOfSafety); + Assert.IsNaN(output.HeaveZValue); + Assert.IsNaN(output.SellmeijerFactorOfSafety); + Assert.IsNaN(output.SellmeijerZValue); + Assert.IsNaN(output.UpliftZValue); + Assert.IsNaN(output.UpliftFactorOfSafety); + Assert.IsNaN(output.UpliftEffectiveStress); + Assert.IsNaN(output.HeaveGradient); + Assert.IsNaN(output.SellmeijerCreepCoefficient); + Assert.IsNaN(output.SellmeijerCriticalFall); + Assert.IsNaN(output.SellmeijerReducedFall); } [Test] @@ -363,10 +376,7 @@ DampingFactorExitMean = 1, PipingSemiProbabilisticOutputEntities = { - new PipingSemiProbabilisticOutputEntity - { - HeaveFactorOfSafety = 1.0 - } + new PipingSemiProbabilisticOutputEntity() } }; @@ -376,7 +386,23 @@ PipingCalculationScenario calculation = entity.Read(collector, new GeneralPipingInput()); // Assert - Assert.IsNotNull(calculation.SemiProbabilisticOutput); + PipingSemiProbabilisticOutput output = calculation.SemiProbabilisticOutput; + Assert.IsNotNull(output); + + Assert.IsNaN(output.HeaveFactorOfSafety); + Assert.IsNaN(output.HeaveProbability); + Assert.IsNaN(output.HeaveReliability); + Assert.IsNaN(output.PipingFactorOfSafety); + Assert.IsNaN(output.PipingProbability); + Assert.IsNaN(output.PipingReliability); + Assert.IsNaN(output.UpliftFactorOfSafety); + Assert.IsNaN(output.UpliftProbability); + Assert.IsNaN(output.UpliftReliability); + Assert.IsNaN(output.SellmeijerFactorOfSafety); + Assert.IsNaN(output.SellmeijerProbability); + Assert.IsNaN(output.SellmeijerReliability); + Assert.IsNaN(output.RequiredProbability); + Assert.IsNaN(output.RequiredReliability); } private static void AssertRoundedDouble(double? expectedValue, RoundedDouble actualValue)