Index: Core/Common/src/Core.Common.Utils/Extensions/EnumerableExtensions.cs =================================================================== diff -u -re0c69303985f5ad57106c5b7f18700d1a16ae3b3 -ra4bd5433cf68976014c17b17cd9cfb766b135c74 --- Core/Common/src/Core.Common.Utils/Extensions/EnumerableExtensions.cs (.../EnumerableExtensions.cs) (revision e0c69303985f5ad57106c5b7f18700d1a16ae3b3) +++ Core/Common/src/Core.Common.Utils/Extensions/EnumerableExtensions.cs (.../EnumerableExtensions.cs) (revision a4bd5433cf68976014c17b17cd9cfb766b135c74) @@ -63,7 +63,7 @@ /// The type for the key. /// A sequence that contains elements to be acted upon. /// The key selector to validate uniqueness. - /// The elements that are not unique. + /// Whether the elements contain duplicate items. /// Thrown when any input argument is null. public static bool AnyNonDistinct(this IEnumerable source, Func keySelector) { Index: Ringtoets/Common/src/Ringtoets.Common.Data/IllustrationPoints/FaultTreeIllustrationPoint.cs =================================================================== diff -u -r57b198a3f80256e02b871d8de11c05d9f2dcf311 -ra4bd5433cf68976014c17b17cd9cfb766b135c74 --- Ringtoets/Common/src/Ringtoets.Common.Data/IllustrationPoints/FaultTreeIllustrationPoint.cs (.../FaultTreeIllustrationPoint.cs) (revision 57b198a3f80256e02b871d8de11c05d9f2dcf311) +++ Ringtoets/Common/src/Ringtoets.Common.Data/IllustrationPoints/FaultTreeIllustrationPoint.cs (.../FaultTreeIllustrationPoint.cs) (revision a4bd5433cf68976014c17b17cd9cfb766b135c74) @@ -43,6 +43,8 @@ /// tree node element in the fault tree. /// Thrown when or /// is null. + /// Thrown when one of the input parameters + /// is invalid (duplicate items, missing items) public FaultTreeIllustrationPoint(string name, double beta, IEnumerable stochasts, Index: Ringtoets/Common/src/Ringtoets.Common.Data/IllustrationPoints/GeneralResult.cs =================================================================== diff -u -r57b198a3f80256e02b871d8de11c05d9f2dcf311 -ra4bd5433cf68976014c17b17cd9cfb766b135c74 --- Ringtoets/Common/src/Ringtoets.Common.Data/IllustrationPoints/GeneralResult.cs (.../GeneralResult.cs) (revision 57b198a3f80256e02b871d8de11c05d9f2dcf311) +++ Ringtoets/Common/src/Ringtoets.Common.Data/IllustrationPoints/GeneralResult.cs (.../GeneralResult.cs) (revision a4bd5433cf68976014c17b17cd9cfb766b135c74) @@ -44,6 +44,8 @@ /// for every combination of wind directions and closing situations. /// Thrown when any of the input /// parameters is null. + /// Thrown when one of the input parameters + /// is invalid (duplicate items, missing items) public GeneralResult(WindDirection governingWindDirection, IEnumerable stochasts, IEnumerable topLevelIllustrationPoints) Index: Ringtoets/Common/src/Ringtoets.Common.Data/IllustrationPoints/IllustrationPointNode.cs =================================================================== diff -u -r57b198a3f80256e02b871d8de11c05d9f2dcf311 -ra4bd5433cf68976014c17b17cd9cfb766b135c74 --- Ringtoets/Common/src/Ringtoets.Common.Data/IllustrationPoints/IllustrationPointNode.cs (.../IllustrationPointNode.cs) (revision 57b198a3f80256e02b871d8de11c05d9f2dcf311) +++ Ringtoets/Common/src/Ringtoets.Common.Data/IllustrationPoints/IllustrationPointNode.cs (.../IllustrationPointNode.cs) (revision a4bd5433cf68976014c17b17cd9cfb766b135c74) @@ -66,7 +66,7 @@ /// /// The children that are attached to this node. /// Thrown when - /// does not contain 0 or 2 elements. + /// does not contain 0 or 2 elements or when the children are invalid (duplicates, missing items). public void SetChildren(IllustrationPointNode[] children) { if (children == null) Index: Ringtoets/GrassCoverErosionInwards/test/Ringtoets.GrassCoverErosionInwards.Service.Test/GrassCoverErosionInwardsCalculationServiceTest.cs =================================================================== diff -u -r57b198a3f80256e02b871d8de11c05d9f2dcf311 -ra4bd5433cf68976014c17b17cd9cfb766b135c74 --- Ringtoets/GrassCoverErosionInwards/test/Ringtoets.GrassCoverErosionInwards.Service.Test/GrassCoverErosionInwardsCalculationServiceTest.cs (.../GrassCoverErosionInwardsCalculationServiceTest.cs) (revision 57b198a3f80256e02b871d8de11c05d9f2dcf311) +++ Ringtoets/GrassCoverErosionInwards/test/Ringtoets.GrassCoverErosionInwards.Service.Test/GrassCoverErosionInwardsCalculationServiceTest.cs (.../GrassCoverErosionInwardsCalculationServiceTest.cs) (revision a4bd5433cf68976014c17b17cd9cfb766b135c74) @@ -2170,20 +2170,13 @@ { // Setup GrassCoverErosionInwardsFailureMechanism failureMechanism = CreateGrassCoverErosionInwardsFailureMechanism(); - var mockRepository = new MockRepository(); - var stochasts = new[] - { - new Stochast("Stochast A", 0, 0), - new Stochast("Stochast A", 0, 0) - }; - var illustrationPoints = new Dictionary(); IAssessmentSection assessmentSection = AssessmentSectionHelper.CreateAssessmentSectionStub(failureMechanism, mockRepository, validFile); var overtoppingCalculator = new TestOvertoppingCalculator { - IllustrationPointsResult = new GeneralResult(0.5, new TestWindDirection(), stochasts, illustrationPoints) + IllustrationPointsResult = GeneralResultTestFactory.CreateGeneralResultWithNonDistinctStochasts() }; var dikeHeightCalculator = new TestHydraulicLoadsCalculator { @@ -2261,40 +2254,13 @@ { // Setup GrassCoverErosionInwardsFailureMechanism failureMechanism = CreateGrassCoverErosionInwardsFailureMechanism(); - var mockRepository = new MockRepository(); - var stochasts = new[] - { - new Stochast("Stochast A", 0, 0), - new Stochast("Stochast B", 0, 0) - }; - - var faultTreeNode1 = new IllustrationPointTreeNode(new FaultTreeIllustrationPoint("Point A", 0.0, new[] - { - new Stochast("Stochast C", 0, 0) - }, CombinationType.And)); - faultTreeNode1.SetChildren(new[] - { - new IllustrationPointTreeNode(new SubMechanismIllustrationPoint("Point C", new[] - { - new SubMechanismIllustrationPointStochast("Stochast C", 0, 0, 0) - }, Enumerable.Empty(), 0)), - new IllustrationPointTreeNode(new TestSubMechanismIllustrationPoint()) - }); - - var illustrationPoints = new Dictionary - { - { - new WindDirectionClosingSituation(new WindDirection("N", 0.0), "closing A"), - faultTreeNode1 - } - }; IAssessmentSection assessmentSection = AssessmentSectionHelper.CreateAssessmentSectionStub(failureMechanism, mockRepository, validFile); var overtoppingCalculator = new TestOvertoppingCalculator { - IllustrationPointsResult = new GeneralResult(0.5, new TestWindDirection(), stochasts, illustrationPoints) + IllustrationPointsResult = GeneralResultTestFactory.CreateGeneralResultWithIncorrectTopLevelStochasts() }; var dikeHeightCalculator = new TestHydraulicLoadsCalculator { @@ -2372,39 +2338,13 @@ { // Setup GrassCoverErosionInwardsFailureMechanism failureMechanism = CreateGrassCoverErosionInwardsFailureMechanism(); - var mockRepository = new MockRepository(); - var stochasts = new[] - { - new Stochast("Stochast A", 0, 0), - new Stochast("Stochast D", 0, 0) - }; - - var illustrationPointNode = new IllustrationPointTreeNode(new FaultTreeIllustrationPoint("Point A", 0.0, new[] - { - new Stochast("Stochast A", 0, 0) - }, CombinationType.And)); - illustrationPointNode.SetChildren(new[] - { - new IllustrationPointTreeNode(new SubMechanismIllustrationPoint("Point SA", new[] - { - new SubMechanismIllustrationPointStochast("Stochast D", 0, 0, 0) - }, Enumerable.Empty(), 0.0)), - new IllustrationPointTreeNode(new TestFaultTreeIllustrationPoint()) - }); - var illustrationPoints = new Dictionary - { - { - new WindDirectionClosingSituation(new WindDirection("N", 0.0), "closing A"), - illustrationPointNode - } - }; IAssessmentSection assessmentSection = AssessmentSectionHelper.CreateAssessmentSectionStub(failureMechanism, mockRepository, validFile); var overtoppingCalculator = new TestOvertoppingCalculator { - IllustrationPointsResult = new GeneralResult(0.5, new TestWindDirection(), stochasts, illustrationPoints) + IllustrationPointsResult = GeneralResultTestFactory.CreateGeneralResultWithIncorrectStochastsInChildren() }; var dikeHeightCalculator = new TestHydraulicLoadsCalculator { @@ -2482,25 +2422,13 @@ { // Setup GrassCoverErosionInwardsFailureMechanism failureMechanism = CreateGrassCoverErosionInwardsFailureMechanism(); - var mockRepository = new MockRepository(); - var illustrationPoints = new Dictionary - { - { - new WindDirectionClosingSituation(new WindDirection("N", 0.0), "closing A"), - new IllustrationPointTreeNode(new TestFaultTreeIllustrationPoint()) - }, - { - new WindDirectionClosingSituation(new WindDirection("S", 0.0), "closing A"), - new IllustrationPointTreeNode(new TestFaultTreeIllustrationPoint()) - } - }; IAssessmentSection assessmentSection = AssessmentSectionHelper.CreateAssessmentSectionStub(failureMechanism, mockRepository, validFile); var overtoppingCalculator = new TestOvertoppingCalculator { - IllustrationPointsResult = new GeneralResult(0.5, new TestWindDirection(), Enumerable.Empty(), illustrationPoints) + IllustrationPointsResult = GeneralResultTestFactory.CreateGeneralResultWithNonDistinctIllustrationPoints() }; var dikeHeightCalculator = new TestHydraulicLoadsCalculator { @@ -2578,32 +2506,13 @@ { // Setup GrassCoverErosionInwardsFailureMechanism failureMechanism = CreateGrassCoverErosionInwardsFailureMechanism(); - var mockRepository = new MockRepository(); - - var illustrationPointNode = new IllustrationPointTreeNode(new FaultTreeIllustrationPoint("Point A", 0.5, Enumerable.Empty(), CombinationType.And)); - illustrationPointNode.SetChildren(new[] - { - new IllustrationPointTreeNode(new SubMechanismIllustrationPoint("Point SA", Enumerable.Empty(), new[] - { - new IllustrationPointResult("Result A", 0.0), - new IllustrationPointResult("Result A", 1.0) - }, 0.0)), - new IllustrationPointTreeNode(new TestFaultTreeIllustrationPoint()) - }); - var illustrationPoints = new Dictionary - { - { - new WindDirectionClosingSituation(new WindDirection("N", 0.0), "closing A"), - illustrationPointNode - } - }; IAssessmentSection assessmentSection = AssessmentSectionHelper.CreateAssessmentSectionStub(failureMechanism, mockRepository, validFile); var overtoppingCalculator = new TestOvertoppingCalculator { - IllustrationPointsResult = new GeneralResult(0.5, new TestWindDirection(), Enumerable.Empty(), illustrationPoints) + IllustrationPointsResult = GeneralResultTestFactory.CreateGeneralResultWithNonDistinctIllustrationPointResults() }; var dikeHeightCalculator = new TestHydraulicLoadsCalculator { @@ -2681,28 +2590,13 @@ { // Setup GrassCoverErosionInwardsFailureMechanism failureMechanism = CreateGrassCoverErosionInwardsFailureMechanism(); - var mockRepository = new MockRepository(); - - var illustrationPointNode = new IllustrationPointTreeNode(new FaultTreeIllustrationPoint("Point A", 0.5, Enumerable.Empty(), CombinationType.And)); - illustrationPointNode.SetChildren(new[] - { - new IllustrationPointTreeNode(new TestSubMechanismIllustrationPoint("Point B")), - new IllustrationPointTreeNode(new TestSubMechanismIllustrationPoint("Point B")) - }); - var illustrationPoints = new Dictionary - { - { - new WindDirectionClosingSituation(new WindDirection("N", 0.0), "closing A"), - illustrationPointNode - } - }; IAssessmentSection assessmentSection = AssessmentSectionHelper.CreateAssessmentSectionStub(failureMechanism, mockRepository, validFile); var overtoppingCalculator = new TestOvertoppingCalculator { - IllustrationPointsResult = new GeneralResult(0.5, new TestWindDirection(), Enumerable.Empty(), illustrationPoints) + IllustrationPointsResult = GeneralResultTestFactory.CreateGeneralResultWithNonDistinctNamesInChildren() }; var dikeHeightCalculator = new TestHydraulicLoadsCalculator { @@ -2860,6 +2754,510 @@ } [Test] + public void Calculate_ValidInputButOvertoppingRateIllustrationPointResultsWithNonDistinctStochasts_GeneralResultNotSetAndLogsWarning() + { + // Setup + GrassCoverErosionInwardsFailureMechanism failureMechanism = CreateGrassCoverErosionInwardsFailureMechanism(); + var mockRepository = new MockRepository(); + IAssessmentSection assessmentSection = AssessmentSectionHelper.CreateAssessmentSectionStub(failureMechanism, + mockRepository, + validFile); + var overtoppingCalculator = new TestOvertoppingCalculator + { + IllustrationPointsResult = new TestGeneralResult() + }; + var dikeHeightCalculator = new TestHydraulicLoadsCalculator + { + IllustrationPointsResult = new TestGeneralResult() + }; + var overtoppingRateCalculator = new TestHydraulicLoadsCalculator + { + IllustrationPointsResult = GeneralResultTestFactory.CreateGeneralResultWithNonDistinctStochasts() + }; + var calculatorFactory = mockRepository.StrictMock(); + calculatorFactory.Expect(cf => cf.CreateOvertoppingCalculator(testDataPath)).Return(overtoppingCalculator); + calculatorFactory.Expect(cf => cf.CreateDikeHeightCalculator(testDataPath)).Return(dikeHeightCalculator); + calculatorFactory.Expect(cf => cf.CreateOvertoppingRateCalculator(testDataPath)).Return(overtoppingRateCalculator); + mockRepository.ReplayAll(); + + GrassCoverErosionInwardsCalculation calculation = GetValidCalculationWithCalculateIllustrationPointsSettings(); + + using (new HydraRingCalculatorFactoryConfig(calculatorFactory)) + { + // Call + Action call = () => new GrassCoverErosionInwardsCalculationService().Calculate(calculation, + assessmentSection, + failureMechanism.GeneralInput, + failureMechanism.Contribution, + validFile); + + // Assert + TestHelper.AssertLogMessagesWithLevelAndLoggedExceptions(call, messages => + { + Tuple[] tupleArray = messages.ToArray(); + + string[] msgs = tupleArray.Select(tuple => tuple.Item1).ToArray(); + + Assert.AreEqual(8, msgs.Length); + + CalculationServiceTestHelper.AssertCalculationStartMessage(msgs[0]); + GrassCoverErosionInwardsCalculationServiceTestHelper.AssertCalculationFinishedMessage( + GrassCoverErosionInwardsCalculationServiceTestHelper.OvertoppingCalculationDescription, + overtoppingCalculator.OutputDirectory, + msgs[1]); + GrassCoverErosionInwardsCalculationServiceTestHelper.AssertCalculationFinishedMessage( + GrassCoverErosionInwardsCalculationServiceTestHelper.HbnCalculationDescription, + dikeHeightCalculator.OutputDirectory, + msgs[2]); + GrassCoverErosionInwardsCalculationServiceTestHelper.AssertCalculationNotConvergedMessage( + GrassCoverErosionInwardsCalculationServiceTestHelper.HbnCalculationDescription, + calculation.Name, + msgs[3]); + GrassCoverErosionInwardsCalculationServiceTestHelper.AssertCalculationFinishedMessage( + GrassCoverErosionInwardsCalculationServiceTestHelper.OvertoppingRateCalculationDescription, + overtoppingRateCalculator.OutputDirectory, + msgs[4]); + GrassCoverErosionInwardsCalculationServiceTestHelper.AssertCalculationNotConvergedMessage( + GrassCoverErosionInwardsCalculationServiceTestHelper.OvertoppingRateCalculationDescription, + calculation.Name, + msgs[5]); + GrassCoverErosionInwardsCalculationServiceTestHelper.AssertGeneralResultNonDistinctStochasts( + GrassCoverErosionInwardsCalculationServiceTestHelper.OvertoppingRateCalculationDescription, + calculation.Name, + msgs[6]); + CalculationServiceTestHelper.AssertCalculationEndMessage(msgs[7]); + }); + + Assert.IsNotNull(calculation.Output); + Assert.IsTrue(calculation.Output.OvertoppingOutput.HasGeneralResult); + Assert.IsTrue(calculation.Output.DikeHeightOutput.HasGeneralResult); + Assert.IsFalse(calculation.Output.OvertoppingRateOutput.HasGeneralResult); + } + + mockRepository.VerifyAll(); + } + + [Test] + public void Calculate_ValidInputButOvertoppingRateIllustrationPointResultsWithIncorrectTopLevelStochasts_GeneralResultNotSetAndLogsWarning() + { + // Setup + GrassCoverErosionInwardsFailureMechanism failureMechanism = CreateGrassCoverErosionInwardsFailureMechanism(); + var mockRepository = new MockRepository(); + IAssessmentSection assessmentSection = AssessmentSectionHelper.CreateAssessmentSectionStub(failureMechanism, + mockRepository, + validFile); + var overtoppingCalculator = new TestOvertoppingCalculator + { + IllustrationPointsResult = new TestGeneralResult() + }; + var dikeHeightCalculator = new TestHydraulicLoadsCalculator + { + IllustrationPointsResult = new TestGeneralResult() + }; + var overtoppingRateCalculator = new TestHydraulicLoadsCalculator + { + IllustrationPointsResult = GeneralResultTestFactory.CreateGeneralResultWithIncorrectTopLevelStochasts() + }; + var calculatorFactory = mockRepository.StrictMock(); + calculatorFactory.Expect(cf => cf.CreateOvertoppingCalculator(testDataPath)).Return(overtoppingCalculator); + calculatorFactory.Expect(cf => cf.CreateDikeHeightCalculator(testDataPath)).Return(dikeHeightCalculator); + calculatorFactory.Expect(cf => cf.CreateOvertoppingRateCalculator(testDataPath)).Return(overtoppingRateCalculator); + mockRepository.ReplayAll(); + + GrassCoverErosionInwardsCalculation calculation = GetValidCalculationWithCalculateIllustrationPointsSettings(); + + using (new HydraRingCalculatorFactoryConfig(calculatorFactory)) + { + // Call + Action call = () => new GrassCoverErosionInwardsCalculationService().Calculate(calculation, + assessmentSection, + failureMechanism.GeneralInput, + failureMechanism.Contribution, + validFile); + + // Assert + TestHelper.AssertLogMessagesWithLevelAndLoggedExceptions(call, messages => + { + Tuple[] tupleArray = messages.ToArray(); + + string[] msgs = tupleArray.Select(tuple => tuple.Item1).ToArray(); + + Assert.AreEqual(8, msgs.Length); + + CalculationServiceTestHelper.AssertCalculationStartMessage(msgs[0]); + GrassCoverErosionInwardsCalculationServiceTestHelper.AssertCalculationFinishedMessage( + GrassCoverErosionInwardsCalculationServiceTestHelper.OvertoppingCalculationDescription, + overtoppingCalculator.OutputDirectory, + msgs[1]); + GrassCoverErosionInwardsCalculationServiceTestHelper.AssertCalculationFinishedMessage( + GrassCoverErosionInwardsCalculationServiceTestHelper.HbnCalculationDescription, + dikeHeightCalculator.OutputDirectory, + msgs[2]); + GrassCoverErosionInwardsCalculationServiceTestHelper.AssertCalculationNotConvergedMessage( + GrassCoverErosionInwardsCalculationServiceTestHelper.HbnCalculationDescription, + calculation.Name, + msgs[3]); + GrassCoverErosionInwardsCalculationServiceTestHelper.AssertCalculationFinishedMessage( + GrassCoverErosionInwardsCalculationServiceTestHelper.OvertoppingRateCalculationDescription, + overtoppingRateCalculator.OutputDirectory, + msgs[4]); + GrassCoverErosionInwardsCalculationServiceTestHelper.AssertCalculationNotConvergedMessage( + GrassCoverErosionInwardsCalculationServiceTestHelper.OvertoppingRateCalculationDescription, + calculation.Name, + msgs[5]); + GrassCoverErosionInwardsCalculationServiceTestHelper.AssertGeneralResultIncorrectTopLevelStochasts( + GrassCoverErosionInwardsCalculationServiceTestHelper.OvertoppingRateCalculationDescription, + calculation.Name, + msgs[6]); + CalculationServiceTestHelper.AssertCalculationEndMessage(msgs[7]); + }); + + Assert.IsNotNull(calculation.Output); + Assert.IsTrue(calculation.Output.OvertoppingOutput.HasGeneralResult); + Assert.IsTrue(calculation.Output.DikeHeightOutput.HasGeneralResult); + Assert.IsFalse(calculation.Output.OvertoppingRateOutput.HasGeneralResult); + } + + mockRepository.VerifyAll(); + } + + [Test] + public void Calculate_ValidInputButOvertoppingRateIllustrationPointResultsWithIncorrectStochastsInChildren_GeneralResultNotSetAndLogsWarning() + { + // Setup + GrassCoverErosionInwardsFailureMechanism failureMechanism = CreateGrassCoverErosionInwardsFailureMechanism(); + var mockRepository = new MockRepository(); + IAssessmentSection assessmentSection = AssessmentSectionHelper.CreateAssessmentSectionStub(failureMechanism, + mockRepository, + validFile); + var overtoppingCalculator = new TestOvertoppingCalculator + { + IllustrationPointsResult = new TestGeneralResult() + }; + var dikeHeightCalculator = new TestHydraulicLoadsCalculator + { + IllustrationPointsResult = new TestGeneralResult() + }; + var overtoppingRateCalculator = new TestHydraulicLoadsCalculator + { + IllustrationPointsResult = GeneralResultTestFactory.CreateGeneralResultWithIncorrectStochastsInChildren() + }; + var calculatorFactory = mockRepository.StrictMock(); + calculatorFactory.Expect(cf => cf.CreateOvertoppingCalculator(testDataPath)).Return(overtoppingCalculator); + calculatorFactory.Expect(cf => cf.CreateDikeHeightCalculator(testDataPath)).Return(dikeHeightCalculator); + calculatorFactory.Expect(cf => cf.CreateOvertoppingRateCalculator(testDataPath)).Return(overtoppingRateCalculator); + mockRepository.ReplayAll(); + + GrassCoverErosionInwardsCalculation calculation = GetValidCalculationWithCalculateIllustrationPointsSettings(); + + using (new HydraRingCalculatorFactoryConfig(calculatorFactory)) + { + // Call + Action call = () => new GrassCoverErosionInwardsCalculationService().Calculate(calculation, + assessmentSection, + failureMechanism.GeneralInput, + failureMechanism.Contribution, + validFile); + + // Assert + TestHelper.AssertLogMessagesWithLevelAndLoggedExceptions(call, messages => + { + Tuple[] tupleArray = messages.ToArray(); + + string[] msgs = tupleArray.Select(tuple => tuple.Item1).ToArray(); + + Assert.AreEqual(8, msgs.Length); + + CalculationServiceTestHelper.AssertCalculationStartMessage(msgs[0]); + GrassCoverErosionInwardsCalculationServiceTestHelper.AssertCalculationFinishedMessage( + GrassCoverErosionInwardsCalculationServiceTestHelper.OvertoppingCalculationDescription, + overtoppingCalculator.OutputDirectory, + msgs[1]); + GrassCoverErosionInwardsCalculationServiceTestHelper.AssertCalculationFinishedMessage( + GrassCoverErosionInwardsCalculationServiceTestHelper.HbnCalculationDescription, + dikeHeightCalculator.OutputDirectory, + msgs[2]); + GrassCoverErosionInwardsCalculationServiceTestHelper.AssertCalculationNotConvergedMessage( + GrassCoverErosionInwardsCalculationServiceTestHelper.HbnCalculationDescription, + calculation.Name, + msgs[3]); + GrassCoverErosionInwardsCalculationServiceTestHelper.AssertCalculationFinishedMessage( + GrassCoverErosionInwardsCalculationServiceTestHelper.OvertoppingRateCalculationDescription, + overtoppingRateCalculator.OutputDirectory, + msgs[4]); + GrassCoverErosionInwardsCalculationServiceTestHelper.AssertCalculationNotConvergedMessage( + GrassCoverErosionInwardsCalculationServiceTestHelper.OvertoppingRateCalculationDescription, + calculation.Name, + msgs[5]); + GrassCoverErosionInwardsCalculationServiceTestHelper.AssertGeneralResultIncorrectTopLevelStochasts( + GrassCoverErosionInwardsCalculationServiceTestHelper.OvertoppingRateCalculationDescription, + calculation.Name, + msgs[6]); + CalculationServiceTestHelper.AssertCalculationEndMessage(msgs[7]); + }); + + Assert.IsNotNull(calculation.Output); + Assert.IsTrue(calculation.Output.OvertoppingOutput.HasGeneralResult); + Assert.IsTrue(calculation.Output.DikeHeightOutput.HasGeneralResult); + Assert.IsFalse(calculation.Output.OvertoppingRateOutput.HasGeneralResult); + } + + mockRepository.VerifyAll(); + } + + [Test] + public void Calculate_ValidInputButOvertoppingRateIllustrationPointResultsWithNonDistinctIllustrationPoints_GeneralResultNotSetAndLogsWarning() + { + // Setup + GrassCoverErosionInwardsFailureMechanism failureMechanism = CreateGrassCoverErosionInwardsFailureMechanism(); + var mockRepository = new MockRepository(); + IAssessmentSection assessmentSection = AssessmentSectionHelper.CreateAssessmentSectionStub(failureMechanism, + mockRepository, + validFile); + var overtoppingCalculator = new TestOvertoppingCalculator + { + IllustrationPointsResult = new TestGeneralResult() + }; + var dikeHeightCalculator = new TestHydraulicLoadsCalculator + { + IllustrationPointsResult = new TestGeneralResult() + }; + var overtoppingRateCalculator = new TestHydraulicLoadsCalculator + { + IllustrationPointsResult = GeneralResultTestFactory.CreateGeneralResultWithNonDistinctIllustrationPoints() + }; + var calculatorFactory = mockRepository.StrictMock(); + calculatorFactory.Expect(cf => cf.CreateOvertoppingCalculator(testDataPath)).Return(overtoppingCalculator); + calculatorFactory.Expect(cf => cf.CreateDikeHeightCalculator(testDataPath)).Return(dikeHeightCalculator); + calculatorFactory.Expect(cf => cf.CreateOvertoppingRateCalculator(testDataPath)).Return(overtoppingRateCalculator); + mockRepository.ReplayAll(); + + GrassCoverErosionInwardsCalculation calculation = GetValidCalculationWithCalculateIllustrationPointsSettings(); + + using (new HydraRingCalculatorFactoryConfig(calculatorFactory)) + { + // Call + Action call = () => new GrassCoverErosionInwardsCalculationService().Calculate(calculation, + assessmentSection, + failureMechanism.GeneralInput, + failureMechanism.Contribution, + validFile); + + // Assert + TestHelper.AssertLogMessagesWithLevelAndLoggedExceptions(call, messages => + { + Tuple[] tupleArray = messages.ToArray(); + + string[] msgs = tupleArray.Select(tuple => tuple.Item1).ToArray(); + + Assert.AreEqual(8, msgs.Length); + + CalculationServiceTestHelper.AssertCalculationStartMessage(msgs[0]); + GrassCoverErosionInwardsCalculationServiceTestHelper.AssertCalculationFinishedMessage( + GrassCoverErosionInwardsCalculationServiceTestHelper.OvertoppingCalculationDescription, + overtoppingCalculator.OutputDirectory, + msgs[1]); + GrassCoverErosionInwardsCalculationServiceTestHelper.AssertCalculationFinishedMessage( + GrassCoverErosionInwardsCalculationServiceTestHelper.HbnCalculationDescription, + dikeHeightCalculator.OutputDirectory, + msgs[2]); + GrassCoverErosionInwardsCalculationServiceTestHelper.AssertCalculationNotConvergedMessage( + GrassCoverErosionInwardsCalculationServiceTestHelper.HbnCalculationDescription, + calculation.Name, + msgs[3]); + GrassCoverErosionInwardsCalculationServiceTestHelper.AssertCalculationFinishedMessage( + GrassCoverErosionInwardsCalculationServiceTestHelper.OvertoppingRateCalculationDescription, + overtoppingRateCalculator.OutputDirectory, + msgs[4]); + GrassCoverErosionInwardsCalculationServiceTestHelper.AssertCalculationNotConvergedMessage( + GrassCoverErosionInwardsCalculationServiceTestHelper.OvertoppingRateCalculationDescription, + calculation.Name, + msgs[5]); + GrassCoverErosionInwardsCalculationServiceTestHelper.AssertGeneralResultNonDistinctIllustrationPoints( + GrassCoverErosionInwardsCalculationServiceTestHelper.OvertoppingRateCalculationDescription, + calculation.Name, + msgs[6]); + CalculationServiceTestHelper.AssertCalculationEndMessage(msgs[7]); + }); + + Assert.IsNotNull(calculation.Output); + Assert.IsTrue(calculation.Output.OvertoppingOutput.HasGeneralResult); + Assert.IsTrue(calculation.Output.DikeHeightOutput.HasGeneralResult); + Assert.IsFalse(calculation.Output.OvertoppingRateOutput.HasGeneralResult); + } + + mockRepository.VerifyAll(); + } + + [Test] + public void Calculate_ValidInputButOvertoppingRateIllustrationPointResultsWithNonDistinctIllustrationPointResults_GeneralResultNotSetAndLogsWarning() + { + // Setup + GrassCoverErosionInwardsFailureMechanism failureMechanism = CreateGrassCoverErosionInwardsFailureMechanism(); + var mockRepository = new MockRepository(); + IAssessmentSection assessmentSection = AssessmentSectionHelper.CreateAssessmentSectionStub(failureMechanism, + mockRepository, + validFile); + var overtoppingCalculator = new TestOvertoppingCalculator + { + IllustrationPointsResult = new TestGeneralResult() + }; + var dikeHeightCalculator = new TestHydraulicLoadsCalculator + { + IllustrationPointsResult = new TestGeneralResult() + }; + var overtoppingRateCalculator = new TestHydraulicLoadsCalculator + { + IllustrationPointsResult = GeneralResultTestFactory.CreateGeneralResultWithNonDistinctIllustrationPointResults() + }; + var calculatorFactory = mockRepository.StrictMock(); + calculatorFactory.Expect(cf => cf.CreateOvertoppingCalculator(testDataPath)).Return(overtoppingCalculator); + calculatorFactory.Expect(cf => cf.CreateDikeHeightCalculator(testDataPath)).Return(dikeHeightCalculator); + calculatorFactory.Expect(cf => cf.CreateOvertoppingRateCalculator(testDataPath)).Return(overtoppingRateCalculator); + mockRepository.ReplayAll(); + + GrassCoverErosionInwardsCalculation calculation = GetValidCalculationWithCalculateIllustrationPointsSettings(); + + using (new HydraRingCalculatorFactoryConfig(calculatorFactory)) + { + // Call + Action call = () => new GrassCoverErosionInwardsCalculationService().Calculate(calculation, + assessmentSection, + failureMechanism.GeneralInput, + failureMechanism.Contribution, + validFile); + + // Assert + TestHelper.AssertLogMessagesWithLevelAndLoggedExceptions(call, messages => + { + Tuple[] tupleArray = messages.ToArray(); + + string[] msgs = tupleArray.Select(tuple => tuple.Item1).ToArray(); + + Assert.AreEqual(8, msgs.Length); + + CalculationServiceTestHelper.AssertCalculationStartMessage(msgs[0]); + GrassCoverErosionInwardsCalculationServiceTestHelper.AssertCalculationFinishedMessage( + GrassCoverErosionInwardsCalculationServiceTestHelper.OvertoppingCalculationDescription, + overtoppingCalculator.OutputDirectory, + msgs[1]); + GrassCoverErosionInwardsCalculationServiceTestHelper.AssertCalculationFinishedMessage( + GrassCoverErosionInwardsCalculationServiceTestHelper.HbnCalculationDescription, + dikeHeightCalculator.OutputDirectory, + msgs[2]); + GrassCoverErosionInwardsCalculationServiceTestHelper.AssertCalculationNotConvergedMessage( + GrassCoverErosionInwardsCalculationServiceTestHelper.HbnCalculationDescription, + calculation.Name, + msgs[3]); + GrassCoverErosionInwardsCalculationServiceTestHelper.AssertCalculationFinishedMessage( + GrassCoverErosionInwardsCalculationServiceTestHelper.OvertoppingRateCalculationDescription, + overtoppingRateCalculator.OutputDirectory, + msgs[4]); + GrassCoverErosionInwardsCalculationServiceTestHelper.AssertCalculationNotConvergedMessage( + GrassCoverErosionInwardsCalculationServiceTestHelper.OvertoppingRateCalculationDescription, + calculation.Name, + msgs[5]); + GrassCoverErosionInwardsCalculationServiceTestHelper.AssertGeneralResultNonDistinctIllustrationPointResults( + GrassCoverErosionInwardsCalculationServiceTestHelper.OvertoppingRateCalculationDescription, + calculation.Name, + msgs[6]); + CalculationServiceTestHelper.AssertCalculationEndMessage(msgs[7]); + }); + + Assert.IsNotNull(calculation.Output); + Assert.IsTrue(calculation.Output.OvertoppingOutput.HasGeneralResult); + Assert.IsTrue(calculation.Output.DikeHeightOutput.HasGeneralResult); + Assert.IsFalse(calculation.Output.OvertoppingRateOutput.HasGeneralResult); + } + + mockRepository.VerifyAll(); + } + + [Test] + public void Calculate_ValidInputButOvertoppingRateIllustrationPointResultsWithNonDistinctNamesInChildren_GeneralResultNotSetAndLogsWarning() + { + // Setup + GrassCoverErosionInwardsFailureMechanism failureMechanism = CreateGrassCoverErosionInwardsFailureMechanism(); + var mockRepository = new MockRepository(); + IAssessmentSection assessmentSection = AssessmentSectionHelper.CreateAssessmentSectionStub(failureMechanism, + mockRepository, + validFile); + var overtoppingCalculator = new TestOvertoppingCalculator + { + IllustrationPointsResult = new TestGeneralResult() + }; + var dikeHeightCalculator = new TestHydraulicLoadsCalculator + { + IllustrationPointsResult = new TestGeneralResult() + }; + var overtoppingRateCalculator = new TestHydraulicLoadsCalculator + { + IllustrationPointsResult = GeneralResultTestFactory.CreateGeneralResultWithNonDistinctNamesInChildren() + }; + var calculatorFactory = mockRepository.StrictMock(); + calculatorFactory.Expect(cf => cf.CreateOvertoppingCalculator(testDataPath)).Return(overtoppingCalculator); + calculatorFactory.Expect(cf => cf.CreateDikeHeightCalculator(testDataPath)).Return(dikeHeightCalculator); + calculatorFactory.Expect(cf => cf.CreateOvertoppingRateCalculator(testDataPath)).Return(overtoppingRateCalculator); + mockRepository.ReplayAll(); + + GrassCoverErosionInwardsCalculation calculation = GetValidCalculationWithCalculateIllustrationPointsSettings(); + + using (new HydraRingCalculatorFactoryConfig(calculatorFactory)) + { + // Call + Action call = () => new GrassCoverErosionInwardsCalculationService().Calculate(calculation, + assessmentSection, + failureMechanism.GeneralInput, + failureMechanism.Contribution, + validFile); + + // Assert + TestHelper.AssertLogMessagesWithLevelAndLoggedExceptions(call, messages => + { + Tuple[] tupleArray = messages.ToArray(); + + string[] msgs = tupleArray.Select(tuple => tuple.Item1).ToArray(); + + Assert.AreEqual(8, msgs.Length); + + CalculationServiceTestHelper.AssertCalculationStartMessage(msgs[0]); + GrassCoverErosionInwardsCalculationServiceTestHelper.AssertCalculationFinishedMessage( + GrassCoverErosionInwardsCalculationServiceTestHelper.OvertoppingCalculationDescription, + overtoppingCalculator.OutputDirectory, + msgs[1]); + GrassCoverErosionInwardsCalculationServiceTestHelper.AssertCalculationFinishedMessage( + GrassCoverErosionInwardsCalculationServiceTestHelper.HbnCalculationDescription, + dikeHeightCalculator.OutputDirectory, + msgs[2]); + GrassCoverErosionInwardsCalculationServiceTestHelper.AssertCalculationNotConvergedMessage( + GrassCoverErosionInwardsCalculationServiceTestHelper.HbnCalculationDescription, + calculation.Name, + msgs[3]); + GrassCoverErosionInwardsCalculationServiceTestHelper.AssertCalculationFinishedMessage( + GrassCoverErosionInwardsCalculationServiceTestHelper.OvertoppingRateCalculationDescription, + overtoppingRateCalculator.OutputDirectory, + msgs[4]); + GrassCoverErosionInwardsCalculationServiceTestHelper.AssertCalculationNotConvergedMessage( + GrassCoverErosionInwardsCalculationServiceTestHelper.OvertoppingRateCalculationDescription, + calculation.Name, + msgs[5]); + GrassCoverErosionInwardsCalculationServiceTestHelper.AssertGeneralResultNonDistinctChildNames( + GrassCoverErosionInwardsCalculationServiceTestHelper.OvertoppingRateCalculationDescription, + calculation.Name, + msgs[6]); + CalculationServiceTestHelper.AssertCalculationEndMessage(msgs[7]); + }); + + Assert.IsNotNull(calculation.Output); + Assert.IsTrue(calculation.Output.OvertoppingOutput.HasGeneralResult); + Assert.IsTrue(calculation.Output.DikeHeightOutput.HasGeneralResult); + Assert.IsFalse(calculation.Output.OvertoppingRateOutput.HasGeneralResult); + } + + mockRepository.VerifyAll(); + } + + [Test] public void Calculate_ValidInputButDikeHeightIllustrationPointResultsOfIncorrectType_GeneralResultNotSetAndLogsWarning() { // Setup @@ -2943,6 +3341,510 @@ mockRepository.VerifyAll(); } + [Test] + public void Calculate_ValidInputButDikeHeightIllustrationPointResultsWithNonDistinctStochasts_GeneralResultNotSetAndLogsWarning() + { + // Setup + GrassCoverErosionInwardsFailureMechanism failureMechanism = CreateGrassCoverErosionInwardsFailureMechanism(); + var mockRepository = new MockRepository(); + IAssessmentSection assessmentSection = AssessmentSectionHelper.CreateAssessmentSectionStub(failureMechanism, + mockRepository, + validFile); + var overtoppingCalculator = new TestOvertoppingCalculator + { + IllustrationPointsResult = new TestGeneralResult() + }; + var dikeHeightCalculator = new TestHydraulicLoadsCalculator + { + IllustrationPointsResult = GeneralResultTestFactory.CreateGeneralResultWithNonDistinctStochasts() + }; + var overtoppingRateCalculator = new TestHydraulicLoadsCalculator + { + IllustrationPointsResult = new TestGeneralResult() + }; + var calculatorFactory = mockRepository.StrictMock(); + calculatorFactory.Expect(cf => cf.CreateOvertoppingCalculator(testDataPath)).Return(overtoppingCalculator); + calculatorFactory.Expect(cf => cf.CreateDikeHeightCalculator(testDataPath)).Return(dikeHeightCalculator); + calculatorFactory.Expect(cf => cf.CreateOvertoppingRateCalculator(testDataPath)).Return(overtoppingRateCalculator); + mockRepository.ReplayAll(); + + GrassCoverErosionInwardsCalculation calculation = GetValidCalculationWithCalculateIllustrationPointsSettings(); + + using (new HydraRingCalculatorFactoryConfig(calculatorFactory)) + { + // Call + Action call = () => new GrassCoverErosionInwardsCalculationService().Calculate(calculation, + assessmentSection, + failureMechanism.GeneralInput, + failureMechanism.Contribution, + validFile); + + // Assert + TestHelper.AssertLogMessagesWithLevelAndLoggedExceptions(call, messages => + { + Tuple[] tupleArray = messages.ToArray(); + + string[] msgs = tupleArray.Select(tuple => tuple.Item1).ToArray(); + + Assert.AreEqual(8, msgs.Length); + + CalculationServiceTestHelper.AssertCalculationStartMessage(msgs[0]); + GrassCoverErosionInwardsCalculationServiceTestHelper.AssertCalculationFinishedMessage( + GrassCoverErosionInwardsCalculationServiceTestHelper.OvertoppingCalculationDescription, + overtoppingCalculator.OutputDirectory, + msgs[1]); + GrassCoverErosionInwardsCalculationServiceTestHelper.AssertCalculationFinishedMessage( + GrassCoverErosionInwardsCalculationServiceTestHelper.HbnCalculationDescription, + dikeHeightCalculator.OutputDirectory, + msgs[2]); + GrassCoverErosionInwardsCalculationServiceTestHelper.AssertCalculationNotConvergedMessage( + GrassCoverErosionInwardsCalculationServiceTestHelper.HbnCalculationDescription, + calculation.Name, + msgs[3]); + GrassCoverErosionInwardsCalculationServiceTestHelper.AssertGeneralResultNonDistinctStochasts( + GrassCoverErosionInwardsCalculationServiceTestHelper.HbnCalculationDescription, + calculation.Name, + msgs[4]); + GrassCoverErosionInwardsCalculationServiceTestHelper.AssertCalculationFinishedMessage( + GrassCoverErosionInwardsCalculationServiceTestHelper.OvertoppingRateCalculationDescription, + overtoppingRateCalculator.OutputDirectory, + msgs[5]); + GrassCoverErosionInwardsCalculationServiceTestHelper.AssertCalculationNotConvergedMessage( + GrassCoverErosionInwardsCalculationServiceTestHelper.OvertoppingRateCalculationDescription, + calculation.Name, + msgs[6]); + CalculationServiceTestHelper.AssertCalculationEndMessage(msgs[7]); + }); + + Assert.IsNotNull(calculation.Output); + Assert.IsTrue(calculation.Output.OvertoppingOutput.HasGeneralResult); + Assert.IsFalse(calculation.Output.DikeHeightOutput.HasGeneralResult); + Assert.IsTrue(calculation.Output.OvertoppingRateOutput.HasGeneralResult); + } + + mockRepository.VerifyAll(); + } + + [Test] + public void Calculate_ValidInputButDikeHeightIllustrationPointResultsWithIncorrectTopLevelStochasts_GeneralResultNotSetAndLogsWarning() + { + // Setup + GrassCoverErosionInwardsFailureMechanism failureMechanism = CreateGrassCoverErosionInwardsFailureMechanism(); + var mockRepository = new MockRepository(); + IAssessmentSection assessmentSection = AssessmentSectionHelper.CreateAssessmentSectionStub(failureMechanism, + mockRepository, + validFile); + var overtoppingCalculator = new TestOvertoppingCalculator + { + IllustrationPointsResult = new TestGeneralResult() + }; + var dikeHeightCalculator = new TestHydraulicLoadsCalculator + { + IllustrationPointsResult = GeneralResultTestFactory.CreateGeneralResultWithIncorrectTopLevelStochasts() + }; + var overtoppingRateCalculator = new TestHydraulicLoadsCalculator + { + IllustrationPointsResult = new TestGeneralResult() + }; + var calculatorFactory = mockRepository.StrictMock(); + calculatorFactory.Expect(cf => cf.CreateOvertoppingCalculator(testDataPath)).Return(overtoppingCalculator); + calculatorFactory.Expect(cf => cf.CreateDikeHeightCalculator(testDataPath)).Return(dikeHeightCalculator); + calculatorFactory.Expect(cf => cf.CreateOvertoppingRateCalculator(testDataPath)).Return(overtoppingRateCalculator); + mockRepository.ReplayAll(); + + GrassCoverErosionInwardsCalculation calculation = GetValidCalculationWithCalculateIllustrationPointsSettings(); + + using (new HydraRingCalculatorFactoryConfig(calculatorFactory)) + { + // Call + Action call = () => new GrassCoverErosionInwardsCalculationService().Calculate(calculation, + assessmentSection, + failureMechanism.GeneralInput, + failureMechanism.Contribution, + validFile); + + // Assert + TestHelper.AssertLogMessagesWithLevelAndLoggedExceptions(call, messages => + { + Tuple[] tupleArray = messages.ToArray(); + + string[] msgs = tupleArray.Select(tuple => tuple.Item1).ToArray(); + + Assert.AreEqual(8, msgs.Length); + + CalculationServiceTestHelper.AssertCalculationStartMessage(msgs[0]); + GrassCoverErosionInwardsCalculationServiceTestHelper.AssertCalculationFinishedMessage( + GrassCoverErosionInwardsCalculationServiceTestHelper.OvertoppingCalculationDescription, + overtoppingCalculator.OutputDirectory, + msgs[1]); + GrassCoverErosionInwardsCalculationServiceTestHelper.AssertCalculationFinishedMessage( + GrassCoverErosionInwardsCalculationServiceTestHelper.HbnCalculationDescription, + dikeHeightCalculator.OutputDirectory, + msgs[2]); + GrassCoverErosionInwardsCalculationServiceTestHelper.AssertCalculationNotConvergedMessage( + GrassCoverErosionInwardsCalculationServiceTestHelper.HbnCalculationDescription, + calculation.Name, + msgs[3]); + GrassCoverErosionInwardsCalculationServiceTestHelper.AssertGeneralResultIncorrectTopLevelStochasts( + GrassCoverErosionInwardsCalculationServiceTestHelper.HbnCalculationDescription, + calculation.Name, + msgs[4]); + GrassCoverErosionInwardsCalculationServiceTestHelper.AssertCalculationFinishedMessage( + GrassCoverErosionInwardsCalculationServiceTestHelper.OvertoppingRateCalculationDescription, + overtoppingRateCalculator.OutputDirectory, + msgs[5]); + GrassCoverErosionInwardsCalculationServiceTestHelper.AssertCalculationNotConvergedMessage( + GrassCoverErosionInwardsCalculationServiceTestHelper.OvertoppingRateCalculationDescription, + calculation.Name, + msgs[6]); + CalculationServiceTestHelper.AssertCalculationEndMessage(msgs[7]); + }); + + Assert.IsNotNull(calculation.Output); + Assert.IsTrue(calculation.Output.OvertoppingOutput.HasGeneralResult); + Assert.IsFalse(calculation.Output.DikeHeightOutput.HasGeneralResult); + Assert.IsTrue(calculation.Output.OvertoppingRateOutput.HasGeneralResult); + } + + mockRepository.VerifyAll(); + } + + [Test] + public void Calculate_ValidInputButDikeHeightIllustrationPointResultsWithIncorrectStochastsInChildren_GeneralResultNotSetAndLogsWarning() + { + // Setup + GrassCoverErosionInwardsFailureMechanism failureMechanism = CreateGrassCoverErosionInwardsFailureMechanism(); + var mockRepository = new MockRepository(); + IAssessmentSection assessmentSection = AssessmentSectionHelper.CreateAssessmentSectionStub(failureMechanism, + mockRepository, + validFile); + var overtoppingCalculator = new TestOvertoppingCalculator + { + IllustrationPointsResult = new TestGeneralResult() + }; + var dikeHeightCalculator = new TestHydraulicLoadsCalculator + { + IllustrationPointsResult = GeneralResultTestFactory.CreateGeneralResultWithIncorrectStochastsInChildren() + }; + var overtoppingRateCalculator = new TestHydraulicLoadsCalculator + { + IllustrationPointsResult = new TestGeneralResult() + }; + var calculatorFactory = mockRepository.StrictMock(); + calculatorFactory.Expect(cf => cf.CreateOvertoppingCalculator(testDataPath)).Return(overtoppingCalculator); + calculatorFactory.Expect(cf => cf.CreateDikeHeightCalculator(testDataPath)).Return(dikeHeightCalculator); + calculatorFactory.Expect(cf => cf.CreateOvertoppingRateCalculator(testDataPath)).Return(overtoppingRateCalculator); + mockRepository.ReplayAll(); + + GrassCoverErosionInwardsCalculation calculation = GetValidCalculationWithCalculateIllustrationPointsSettings(); + + using (new HydraRingCalculatorFactoryConfig(calculatorFactory)) + { + // Call + Action call = () => new GrassCoverErosionInwardsCalculationService().Calculate(calculation, + assessmentSection, + failureMechanism.GeneralInput, + failureMechanism.Contribution, + validFile); + + // Assert + TestHelper.AssertLogMessagesWithLevelAndLoggedExceptions(call, messages => + { + Tuple[] tupleArray = messages.ToArray(); + + string[] msgs = tupleArray.Select(tuple => tuple.Item1).ToArray(); + + Assert.AreEqual(8, msgs.Length); + + CalculationServiceTestHelper.AssertCalculationStartMessage(msgs[0]); + GrassCoverErosionInwardsCalculationServiceTestHelper.AssertCalculationFinishedMessage( + GrassCoverErosionInwardsCalculationServiceTestHelper.OvertoppingCalculationDescription, + overtoppingCalculator.OutputDirectory, + msgs[1]); + GrassCoverErosionInwardsCalculationServiceTestHelper.AssertCalculationFinishedMessage( + GrassCoverErosionInwardsCalculationServiceTestHelper.HbnCalculationDescription, + dikeHeightCalculator.OutputDirectory, + msgs[2]); + GrassCoverErosionInwardsCalculationServiceTestHelper.AssertCalculationNotConvergedMessage( + GrassCoverErosionInwardsCalculationServiceTestHelper.HbnCalculationDescription, + calculation.Name, + msgs[3]); + GrassCoverErosionInwardsCalculationServiceTestHelper.AssertGeneralResultIncorrectTopLevelStochasts( + GrassCoverErosionInwardsCalculationServiceTestHelper.HbnCalculationDescription, + calculation.Name, + msgs[4]); + GrassCoverErosionInwardsCalculationServiceTestHelper.AssertCalculationFinishedMessage( + GrassCoverErosionInwardsCalculationServiceTestHelper.OvertoppingRateCalculationDescription, + overtoppingRateCalculator.OutputDirectory, + msgs[5]); + GrassCoverErosionInwardsCalculationServiceTestHelper.AssertCalculationNotConvergedMessage( + GrassCoverErosionInwardsCalculationServiceTestHelper.OvertoppingRateCalculationDescription, + calculation.Name, + msgs[6]); + CalculationServiceTestHelper.AssertCalculationEndMessage(msgs[7]); + }); + + Assert.IsNotNull(calculation.Output); + Assert.IsTrue(calculation.Output.OvertoppingOutput.HasGeneralResult); + Assert.IsFalse(calculation.Output.DikeHeightOutput.HasGeneralResult); + Assert.IsTrue(calculation.Output.OvertoppingRateOutput.HasGeneralResult); + } + + mockRepository.VerifyAll(); + } + + [Test] + public void Calculate_ValidInputButDikeHeightIllustrationPointResultsWithNonDistinctIllustrationPoints_GeneralResultNotSetAndLogsWarning() + { + // Setup + GrassCoverErosionInwardsFailureMechanism failureMechanism = CreateGrassCoverErosionInwardsFailureMechanism(); + var mockRepository = new MockRepository(); + IAssessmentSection assessmentSection = AssessmentSectionHelper.CreateAssessmentSectionStub(failureMechanism, + mockRepository, + validFile); + var overtoppingCalculator = new TestOvertoppingCalculator + { + IllustrationPointsResult = new TestGeneralResult() + }; + var dikeHeightCalculator = new TestHydraulicLoadsCalculator + { + IllustrationPointsResult = GeneralResultTestFactory.CreateGeneralResultWithNonDistinctIllustrationPoints() + }; + var overtoppingRateCalculator = new TestHydraulicLoadsCalculator + { + IllustrationPointsResult = new TestGeneralResult() + }; + var calculatorFactory = mockRepository.StrictMock(); + calculatorFactory.Expect(cf => cf.CreateOvertoppingCalculator(testDataPath)).Return(overtoppingCalculator); + calculatorFactory.Expect(cf => cf.CreateDikeHeightCalculator(testDataPath)).Return(dikeHeightCalculator); + calculatorFactory.Expect(cf => cf.CreateOvertoppingRateCalculator(testDataPath)).Return(overtoppingRateCalculator); + mockRepository.ReplayAll(); + + GrassCoverErosionInwardsCalculation calculation = GetValidCalculationWithCalculateIllustrationPointsSettings(); + + using (new HydraRingCalculatorFactoryConfig(calculatorFactory)) + { + // Call + Action call = () => new GrassCoverErosionInwardsCalculationService().Calculate(calculation, + assessmentSection, + failureMechanism.GeneralInput, + failureMechanism.Contribution, + validFile); + + // Assert + TestHelper.AssertLogMessagesWithLevelAndLoggedExceptions(call, messages => + { + Tuple[] tupleArray = messages.ToArray(); + + string[] msgs = tupleArray.Select(tuple => tuple.Item1).ToArray(); + + Assert.AreEqual(8, msgs.Length); + + CalculationServiceTestHelper.AssertCalculationStartMessage(msgs[0]); + GrassCoverErosionInwardsCalculationServiceTestHelper.AssertCalculationFinishedMessage( + GrassCoverErosionInwardsCalculationServiceTestHelper.OvertoppingCalculationDescription, + overtoppingCalculator.OutputDirectory, + msgs[1]); + GrassCoverErosionInwardsCalculationServiceTestHelper.AssertCalculationFinishedMessage( + GrassCoverErosionInwardsCalculationServiceTestHelper.HbnCalculationDescription, + dikeHeightCalculator.OutputDirectory, + msgs[2]); + GrassCoverErosionInwardsCalculationServiceTestHelper.AssertCalculationNotConvergedMessage( + GrassCoverErosionInwardsCalculationServiceTestHelper.HbnCalculationDescription, + calculation.Name, + msgs[3]); + GrassCoverErosionInwardsCalculationServiceTestHelper.AssertGeneralResultNonDistinctIllustrationPoints( + GrassCoverErosionInwardsCalculationServiceTestHelper.HbnCalculationDescription, + calculation.Name, + msgs[4]); + GrassCoverErosionInwardsCalculationServiceTestHelper.AssertCalculationFinishedMessage( + GrassCoverErosionInwardsCalculationServiceTestHelper.OvertoppingRateCalculationDescription, + overtoppingRateCalculator.OutputDirectory, + msgs[5]); + GrassCoverErosionInwardsCalculationServiceTestHelper.AssertCalculationNotConvergedMessage( + GrassCoverErosionInwardsCalculationServiceTestHelper.OvertoppingRateCalculationDescription, + calculation.Name, + msgs[6]); + CalculationServiceTestHelper.AssertCalculationEndMessage(msgs[7]); + }); + + Assert.IsNotNull(calculation.Output); + Assert.IsTrue(calculation.Output.OvertoppingOutput.HasGeneralResult); + Assert.IsFalse(calculation.Output.DikeHeightOutput.HasGeneralResult); + Assert.IsTrue(calculation.Output.OvertoppingRateOutput.HasGeneralResult); + } + + mockRepository.VerifyAll(); + } + + [Test] + public void Calculate_ValidInputButDikeHeightIllustrationPointResultsWithNonDistinctIllustrationPointResults_GeneralResultNotSetAndLogsWarning() + { + // Setup + GrassCoverErosionInwardsFailureMechanism failureMechanism = CreateGrassCoverErosionInwardsFailureMechanism(); + var mockRepository = new MockRepository(); + IAssessmentSection assessmentSection = AssessmentSectionHelper.CreateAssessmentSectionStub(failureMechanism, + mockRepository, + validFile); + var overtoppingCalculator = new TestOvertoppingCalculator + { + IllustrationPointsResult = new TestGeneralResult() + }; + var dikeHeightCalculator = new TestHydraulicLoadsCalculator + { + IllustrationPointsResult = GeneralResultTestFactory.CreateGeneralResultWithNonDistinctIllustrationPointResults() + }; + var overtoppingRateCalculator = new TestHydraulicLoadsCalculator + { + IllustrationPointsResult = new TestGeneralResult() + }; + var calculatorFactory = mockRepository.StrictMock(); + calculatorFactory.Expect(cf => cf.CreateOvertoppingCalculator(testDataPath)).Return(overtoppingCalculator); + calculatorFactory.Expect(cf => cf.CreateDikeHeightCalculator(testDataPath)).Return(dikeHeightCalculator); + calculatorFactory.Expect(cf => cf.CreateOvertoppingRateCalculator(testDataPath)).Return(overtoppingRateCalculator); + mockRepository.ReplayAll(); + + GrassCoverErosionInwardsCalculation calculation = GetValidCalculationWithCalculateIllustrationPointsSettings(); + + using (new HydraRingCalculatorFactoryConfig(calculatorFactory)) + { + // Call + Action call = () => new GrassCoverErosionInwardsCalculationService().Calculate(calculation, + assessmentSection, + failureMechanism.GeneralInput, + failureMechanism.Contribution, + validFile); + + // Assert + TestHelper.AssertLogMessagesWithLevelAndLoggedExceptions(call, messages => + { + Tuple[] tupleArray = messages.ToArray(); + + string[] msgs = tupleArray.Select(tuple => tuple.Item1).ToArray(); + + Assert.AreEqual(8, msgs.Length); + + CalculationServiceTestHelper.AssertCalculationStartMessage(msgs[0]); + GrassCoverErosionInwardsCalculationServiceTestHelper.AssertCalculationFinishedMessage( + GrassCoverErosionInwardsCalculationServiceTestHelper.OvertoppingCalculationDescription, + overtoppingCalculator.OutputDirectory, + msgs[1]); + GrassCoverErosionInwardsCalculationServiceTestHelper.AssertCalculationFinishedMessage( + GrassCoverErosionInwardsCalculationServiceTestHelper.HbnCalculationDescription, + dikeHeightCalculator.OutputDirectory, + msgs[2]); + GrassCoverErosionInwardsCalculationServiceTestHelper.AssertCalculationNotConvergedMessage( + GrassCoverErosionInwardsCalculationServiceTestHelper.HbnCalculationDescription, + calculation.Name, + msgs[3]); + GrassCoverErosionInwardsCalculationServiceTestHelper.AssertGeneralResultNonDistinctIllustrationPointResults( + GrassCoverErosionInwardsCalculationServiceTestHelper.HbnCalculationDescription, + calculation.Name, + msgs[4]); + GrassCoverErosionInwardsCalculationServiceTestHelper.AssertCalculationFinishedMessage( + GrassCoverErosionInwardsCalculationServiceTestHelper.OvertoppingRateCalculationDescription, + overtoppingRateCalculator.OutputDirectory, + msgs[5]); + GrassCoverErosionInwardsCalculationServiceTestHelper.AssertCalculationNotConvergedMessage( + GrassCoverErosionInwardsCalculationServiceTestHelper.OvertoppingRateCalculationDescription, + calculation.Name, + msgs[6]); + CalculationServiceTestHelper.AssertCalculationEndMessage(msgs[7]); + }); + + Assert.IsNotNull(calculation.Output); + Assert.IsTrue(calculation.Output.OvertoppingOutput.HasGeneralResult); + Assert.IsFalse(calculation.Output.DikeHeightOutput.HasGeneralResult); + Assert.IsTrue(calculation.Output.OvertoppingRateOutput.HasGeneralResult); + } + + mockRepository.VerifyAll(); + } + + [Test] + public void Calculate_ValidInputButDikeHeightIllustrationPointResultsWithNonDistinctNamesInChildren_GeneralResultNotSetAndLogsWarning() + { + // Setup + GrassCoverErosionInwardsFailureMechanism failureMechanism = CreateGrassCoverErosionInwardsFailureMechanism(); + var mockRepository = new MockRepository(); + IAssessmentSection assessmentSection = AssessmentSectionHelper.CreateAssessmentSectionStub(failureMechanism, + mockRepository, + validFile); + var overtoppingCalculator = new TestOvertoppingCalculator + { + IllustrationPointsResult = new TestGeneralResult() + }; + var dikeHeightCalculator = new TestHydraulicLoadsCalculator + { + IllustrationPointsResult = GeneralResultTestFactory.CreateGeneralResultWithNonDistinctNamesInChildren() + }; + var overtoppingRateCalculator = new TestHydraulicLoadsCalculator + { + IllustrationPointsResult = new TestGeneralResult() + }; + var calculatorFactory = mockRepository.StrictMock(); + calculatorFactory.Expect(cf => cf.CreateOvertoppingCalculator(testDataPath)).Return(overtoppingCalculator); + calculatorFactory.Expect(cf => cf.CreateDikeHeightCalculator(testDataPath)).Return(dikeHeightCalculator); + calculatorFactory.Expect(cf => cf.CreateOvertoppingRateCalculator(testDataPath)).Return(overtoppingRateCalculator); + mockRepository.ReplayAll(); + + GrassCoverErosionInwardsCalculation calculation = GetValidCalculationWithCalculateIllustrationPointsSettings(); + + using (new HydraRingCalculatorFactoryConfig(calculatorFactory)) + { + // Call + Action call = () => new GrassCoverErosionInwardsCalculationService().Calculate(calculation, + assessmentSection, + failureMechanism.GeneralInput, + failureMechanism.Contribution, + validFile); + + // Assert + TestHelper.AssertLogMessagesWithLevelAndLoggedExceptions(call, messages => + { + Tuple[] tupleArray = messages.ToArray(); + + string[] msgs = tupleArray.Select(tuple => tuple.Item1).ToArray(); + + Assert.AreEqual(8, msgs.Length); + + CalculationServiceTestHelper.AssertCalculationStartMessage(msgs[0]); + GrassCoverErosionInwardsCalculationServiceTestHelper.AssertCalculationFinishedMessage( + GrassCoverErosionInwardsCalculationServiceTestHelper.OvertoppingCalculationDescription, + overtoppingCalculator.OutputDirectory, + msgs[1]); + GrassCoverErosionInwardsCalculationServiceTestHelper.AssertCalculationFinishedMessage( + GrassCoverErosionInwardsCalculationServiceTestHelper.HbnCalculationDescription, + dikeHeightCalculator.OutputDirectory, + msgs[2]); + GrassCoverErosionInwardsCalculationServiceTestHelper.AssertCalculationNotConvergedMessage( + GrassCoverErosionInwardsCalculationServiceTestHelper.HbnCalculationDescription, + calculation.Name, + msgs[3]); + GrassCoverErosionInwardsCalculationServiceTestHelper.AssertGeneralResultNonDistinctChildNames( + GrassCoverErosionInwardsCalculationServiceTestHelper.HbnCalculationDescription, + calculation.Name, + msgs[4]); + GrassCoverErosionInwardsCalculationServiceTestHelper.AssertCalculationFinishedMessage( + GrassCoverErosionInwardsCalculationServiceTestHelper.OvertoppingRateCalculationDescription, + overtoppingRateCalculator.OutputDirectory, + msgs[5]); + GrassCoverErosionInwardsCalculationServiceTestHelper.AssertCalculationNotConvergedMessage( + GrassCoverErosionInwardsCalculationServiceTestHelper.OvertoppingRateCalculationDescription, + calculation.Name, + msgs[6]); + CalculationServiceTestHelper.AssertCalculationEndMessage(msgs[7]); + }); + + Assert.IsNotNull(calculation.Output); + Assert.IsTrue(calculation.Output.OvertoppingOutput.HasGeneralResult); + Assert.IsFalse(calculation.Output.DikeHeightOutput.HasGeneralResult); + Assert.IsTrue(calculation.Output.OvertoppingRateOutput.HasGeneralResult); + } + + mockRepository.VerifyAll(); + } + private static GrassCoverErosionInwardsFailureMechanism CreateGrassCoverErosionInwardsFailureMechanism() { return new GrassCoverErosionInwardsFailureMechanism Index: Ringtoets/HydraRing/test/Ringtoets.HydraRing.Calculation.TestUtil.Test/IllustrationPoints/GeneralResultTestFactoryTest.cs =================================================================== diff -u --- Ringtoets/HydraRing/test/Ringtoets.HydraRing.Calculation.TestUtil.Test/IllustrationPoints/GeneralResultTestFactoryTest.cs (revision 0) +++ Ringtoets/HydraRing/test/Ringtoets.HydraRing.Calculation.TestUtil.Test/IllustrationPoints/GeneralResultTestFactoryTest.cs (revision a4bd5433cf68976014c17b17cd9cfb766b135c74) @@ -0,0 +1,211 @@ +// 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.HydraRing.Calculation.Data.Output.IllustrationPoints; +using Ringtoets.HydraRing.Calculation.TestUtil.IllustrationPoints; + +namespace Ringtoets.HydraRing.Calculation.TestUtil.Test.IllustrationPoints +{ + [TestFixture] + public class GeneralResultTestFactoryTest + { + [Test] + public void CreateGeneralResultWithNonDistinctStochasts_ExpectedProperties() + { + // Call + GeneralResult generalResult = GeneralResultTestFactory.CreateGeneralResultWithNonDistinctStochasts(); + + // Assert + Assert.IsInstanceOf(generalResult); + Assert.AreEqual(0.5, generalResult.Beta); + + var expectedWindDirection = new TestWindDirection(); + AssertWindDirection(expectedWindDirection, generalResult.GoverningWindDirection); + Assert.AreEqual(2, generalResult.Stochasts.Count()); + foreach (Stochast stochast in generalResult.Stochasts) + { + Assert.AreEqual("Stochast A", stochast.Name); + } + CollectionAssert.IsEmpty(generalResult.IllustrationPoints); + } + + [Test] + public void CreateGeneralResultWithIncorrectTopLevelStochasts_ExpectedProperties() + { + // Call + GeneralResult generalResult = GeneralResultTestFactory.CreateGeneralResultWithIncorrectTopLevelStochasts(); + + // Assert + Assert.IsInstanceOf(generalResult); + Assert.AreEqual(0.5, generalResult.Beta); + + var expectedWindDirection = new TestWindDirection(); + AssertWindDirection(expectedWindDirection, generalResult.GoverningWindDirection); + Assert.AreEqual(2, generalResult.Stochasts.Count()); + Stochast[] stochasts = generalResult.Stochasts.ToArray(); + Assert.AreEqual("Stochast A", stochasts[0].Name); + Assert.AreEqual("Stochast B", stochasts[1].Name); + + KeyValuePair topLevelIllustrationPoint = + generalResult.IllustrationPoints.Single(); + + WindDirectionClosingSituation actualWindDirectionClosingSituation = topLevelIllustrationPoint.Key; + AssertWindDirection(expectedWindDirection, actualWindDirectionClosingSituation.WindDirection); + Assert.AreEqual("closing A", actualWindDirectionClosingSituation.ClosingSituation); + + Assert.IsInstanceOf(topLevelIllustrationPoint.Value.Data); + Assert.AreEqual("Point A", ((FaultTreeIllustrationPoint) topLevelIllustrationPoint.Value.Data).Name); + + Stochast topLevelIllustrationPointStochast = ((FaultTreeIllustrationPoint) topLevelIllustrationPoint.Value.Data).Stochasts.Single(); + Assert.AreEqual("Stochast C", topLevelIllustrationPointStochast.Name); + } + + [Test] + public void CreateGeneralResultWithIncorrectStochastsInChildren_ExpectedProperties() + { + // Call + GeneralResult generalResult = GeneralResultTestFactory.CreateGeneralResultWithIncorrectStochastsInChildren(); + + // Assert + Assert.IsInstanceOf(generalResult); + Assert.AreEqual(0.5, generalResult.Beta); + + var expectedWindDirection = new TestWindDirection(); + AssertWindDirection(expectedWindDirection, generalResult.GoverningWindDirection); + Assert.AreEqual(2, generalResult.Stochasts.Count()); + Stochast[] stochasts = generalResult.Stochasts.ToArray(); + Assert.AreEqual("Stochast A", stochasts[0].Name); + Assert.AreEqual("Stochast D", stochasts[1].Name); + + KeyValuePair topLevelIllustrationPoint = + generalResult.IllustrationPoints.Single(); + + WindDirectionClosingSituation actualWindDirectionClosingSituation = topLevelIllustrationPoint.Key; + AssertWindDirection(expectedWindDirection, actualWindDirectionClosingSituation.WindDirection); + Assert.AreEqual("closing A", actualWindDirectionClosingSituation.ClosingSituation); + + Assert.IsInstanceOf(topLevelIllustrationPoint.Value.Data); + Assert.AreEqual("Point A", ((FaultTreeIllustrationPoint) topLevelIllustrationPoint.Value.Data).Name); + + Stochast topLevelIllustrationPointStochast = ((FaultTreeIllustrationPoint) topLevelIllustrationPoint.Value.Data).Stochasts.Single(); + Assert.AreEqual("Stochast A", topLevelIllustrationPointStochast.Name); + + IllustrationPointTreeNode[] children = topLevelIllustrationPoint.Value.Children.ToArray(); + Assert.IsInstanceOf(children[0].Data); + SubMechanismIllustrationPointStochast childStochast = ((SubMechanismIllustrationPoint) children[0].Data).Stochasts.Single(); + Assert.AreEqual("Stochast D", childStochast.Name); + Assert.IsInstanceOf(children[1].Data); + } + + [Test] + public void CreateGeneralResultWithNonDistinctIllustrationPoints_ExpectedProperties() + { + // Call + GeneralResult generalResult = GeneralResultTestFactory.CreateGeneralResultWithNonDistinctIllustrationPoints(); + + // Assert + Assert.IsInstanceOf(generalResult); + Assert.AreEqual(0.5, generalResult.Beta); + + AssertWindDirection(new TestWindDirection(), generalResult.GoverningWindDirection); + + KeyValuePair[] topLevelIllustrationPoints = + generalResult.IllustrationPoints.ToArray(); + Assert.AreEqual(2, topLevelIllustrationPoints.Length); + + AssertWindDirection(new WindDirection("N", 0.0), topLevelIllustrationPoints[0].Key.WindDirection); + Assert.AreEqual("closing A", topLevelIllustrationPoints[0].Key.ClosingSituation); + + AssertWindDirection(new WindDirection("S", 0.0), topLevelIllustrationPoints[1].Key.WindDirection); + Assert.AreEqual("closing A", topLevelIllustrationPoints[1].Key.ClosingSituation); + + Assert.IsInstanceOf(topLevelIllustrationPoints[0].Value.Data); + Assert.IsInstanceOf(topLevelIllustrationPoints[1].Value.Data); + } + + [Test] + public void CreateGeneralResultWithNonDistinctIllustrationPointResults_ExpectedProperties() + { + // Call + GeneralResult generalResult = GeneralResultTestFactory.CreateGeneralResultWithNonDistinctIllustrationPointResults(); + + // Assert + Assert.IsInstanceOf(generalResult); + Assert.AreEqual(0.5, generalResult.Beta); + + var expectedWindDirection = new TestWindDirection(); + AssertWindDirection(expectedWindDirection, generalResult.GoverningWindDirection); + + KeyValuePair topLevelIllustrationPoint = + generalResult.IllustrationPoints.Single(); + + WindDirectionClosingSituation actualWindDirectionClosingSituation = topLevelIllustrationPoint.Key; + AssertWindDirection(expectedWindDirection, actualWindDirectionClosingSituation.WindDirection); + Assert.AreEqual("closing A", actualWindDirectionClosingSituation.ClosingSituation); + + Assert.IsInstanceOf(topLevelIllustrationPoint.Value.Data); + Assert.AreEqual("Point A", ((FaultTreeIllustrationPoint)topLevelIllustrationPoint.Value.Data).Name); + + IllustrationPointTreeNode[] children = topLevelIllustrationPoint.Value.Children.ToArray(); + Assert.IsInstanceOf(children[0].Data); + IllustrationPointResult[] illustrationPointResults = ((SubMechanismIllustrationPoint)children[0].Data).Results.ToArray(); + Assert.AreEqual("Result A", illustrationPointResults[0].Description); + Assert.AreEqual(0.0, illustrationPointResults[0].Value); + Assert.AreEqual("Result A", illustrationPointResults[1].Description); + Assert.AreEqual(1.0, illustrationPointResults[1].Value); + Assert.IsInstanceOf(children[1].Data); + } + + [Test] + public void CreateGeneralResultWithNonDistinctNamesInChildren_ExpectedProperties() + { + // Call + GeneralResult generalResult = GeneralResultTestFactory.CreateGeneralResultWithNonDistinctNamesInChildren(); + + // Assert + Assert.IsInstanceOf(generalResult); + Assert.AreEqual(0.5, generalResult.Beta); + + var expectedWindDirection = new TestWindDirection(); + AssertWindDirection(expectedWindDirection, generalResult.GoverningWindDirection); + + KeyValuePair topLevelIllustrationPoint = + generalResult.IllustrationPoints.Single(); + Assert.IsInstanceOf(topLevelIllustrationPoint.Value.Data); + + var children = topLevelIllustrationPoint.Value.Children.ToArray(); + Assert.AreEqual("Point B", ((SubMechanismIllustrationPoint)children[0].Data).Name); + Assert.AreEqual("Point B", ((SubMechanismIllustrationPoint)children[1].Data).Name); + + Assert.IsInstanceOf(children[0].Data); + Assert.IsInstanceOf(children[1].Data); + } + + private static void AssertWindDirection(WindDirection expected, WindDirection actual) + { + Assert.AreEqual(expected.Name, actual.Name); + Assert.AreEqual(expected.Angle, actual.Angle); + } + } +} \ No newline at end of file Index: Ringtoets/HydraRing/test/Ringtoets.HydraRing.Calculation.TestUtil.Test/Ringtoets.HydraRing.Calculation.TestUtil.Test.csproj =================================================================== diff -u -ra1fa1538918813373bcc864f0bce092bf28fd0ce -ra4bd5433cf68976014c17b17cd9cfb766b135c74 --- Ringtoets/HydraRing/test/Ringtoets.HydraRing.Calculation.TestUtil.Test/Ringtoets.HydraRing.Calculation.TestUtil.Test.csproj (.../Ringtoets.HydraRing.Calculation.TestUtil.Test.csproj) (revision a1fa1538918813373bcc864f0bce092bf28fd0ce) +++ Ringtoets/HydraRing/test/Ringtoets.HydraRing.Calculation.TestUtil.Test/Ringtoets.HydraRing.Calculation.TestUtil.Test.csproj (.../Ringtoets.HydraRing.Calculation.TestUtil.Test.csproj) (revision a4bd5433cf68976014c17b17cd9cfb766b135c74) @@ -54,6 +54,7 @@ + Index: Ringtoets/HydraRing/test/Ringtoets.HydraRing.Calculation.TestUtil/IllustrationPoints/GeneralResultTestFactory.cs =================================================================== diff -u --- Ringtoets/HydraRing/test/Ringtoets.HydraRing.Calculation.TestUtil/IllustrationPoints/GeneralResultTestFactory.cs (revision 0) +++ Ringtoets/HydraRing/test/Ringtoets.HydraRing.Calculation.TestUtil/IllustrationPoints/GeneralResultTestFactory.cs (revision a4bd5433cf68976014c17b17cd9cfb766b135c74) @@ -0,0 +1,193 @@ +// 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 Ringtoets.HydraRing.Calculation.Data.Output.IllustrationPoints; + +namespace Ringtoets.HydraRing.Calculation.TestUtil.IllustrationPoints +{ + public static class GeneralResultTestFactory + { + /// + /// Creates a new instance of + /// with non distinct stochasts + /// + /// A with non distinct stochasts + public static GeneralResult CreateGeneralResultWithNonDistinctStochasts() + { + var stochasts = new[] + { + new Stochast("Stochast A", 0, 0), + new Stochast("Stochast A", 0, 0) + }; + var illustrationPoints = new Dictionary(); + return new GeneralResult(0.5, new TestWindDirection(), stochasts, illustrationPoints); + } + + /// + /// Creates a new instance of + /// with an incomplete list of top level stochasts + /// + /// A with an incomplete list of top level stochasts + public static GeneralResult CreateGeneralResultWithIncorrectTopLevelStochasts() + { + var stochasts = new[] + { + new Stochast("Stochast A", 0, 0), + new Stochast("Stochast B", 0, 0) + }; + + var faultTreeNode1 = new IllustrationPointTreeNode(new FaultTreeIllustrationPoint("Point A", 0.0, new[] + { + new Stochast("Stochast C", 0, 0) + }, CombinationType.And)); + + var illustrationPoints = new Dictionary + { + { + new WindDirectionClosingSituation(new TestWindDirection(), "closing A"), + faultTreeNode1 + } + }; + return new GeneralResult(0.5, new TestWindDirection(), stochasts, illustrationPoints); + } + + /// + /// Creates a new instance of + /// with an incomplete list of stochasts in a fault tree illustration point in the tree + /// + /// A with an incomplete list of stochasts + /// in a fault tree illustration point in the tree + public static GeneralResult CreateGeneralResultWithIncorrectStochastsInChildren() + { + var stochasts = new[] + { + new Stochast("Stochast A", 0, 0), + new Stochast("Stochast D", 0, 0) + }; + + var illustrationPointNode = new IllustrationPointTreeNode(new FaultTreeIllustrationPoint("Point A", 0.0, new[] + { + new Stochast("Stochast A", 0, 0) + }, CombinationType.And)); + + illustrationPointNode.SetChildren(new[] + { + new IllustrationPointTreeNode(new SubMechanismIllustrationPoint("Point SA", new[] + { + new SubMechanismIllustrationPointStochast("Stochast D", 0, 0, 0) + }, Enumerable.Empty(), 0.0)), + new IllustrationPointTreeNode(new TestFaultTreeIllustrationPoint()) + }); + + var illustrationPoints = new Dictionary + { + { + new WindDirectionClosingSituation(new TestWindDirection(), "closing A"), + illustrationPointNode + } + }; + return new GeneralResult(0.5, new TestWindDirection(), stochasts, illustrationPoints); + } + + /// + /// Creates a new instance of + /// with non distinct illustration points + /// + /// A with non distinct illustration points + public static GeneralResult CreateGeneralResultWithNonDistinctIllustrationPoints() + { + var illustrationPoints = new Dictionary + { + { + new WindDirectionClosingSituation(new WindDirection("N", 0.0), "closing A"), + new IllustrationPointTreeNode(new TestFaultTreeIllustrationPoint()) + }, + { + new WindDirectionClosingSituation(new WindDirection("S", 0.0), "closing A"), + new IllustrationPointTreeNode(new TestFaultTreeIllustrationPoint()) + } + }; + return new GeneralResult(0.5, new TestWindDirection(), Enumerable.Empty(), illustrationPoints); + } + + /// + /// Creates a new instance of + /// with non distinct illustration point results + /// + /// A with non distinct illustration point results + public static GeneralResult CreateGeneralResultWithNonDistinctIllustrationPointResults() + { + var illustrationPointNode = new IllustrationPointTreeNode(new FaultTreeIllustrationPoint("Point A", + 0.5, + Enumerable.Empty(), + CombinationType.And)); + + illustrationPointNode.SetChildren(new[] + { + new IllustrationPointTreeNode(new SubMechanismIllustrationPoint("Point SA", + Enumerable.Empty(), + new[] + { + new IllustrationPointResult("Result A", 0.0), + new IllustrationPointResult("Result A", 1.0) + }, 0.0)), + new IllustrationPointTreeNode(new TestFaultTreeIllustrationPoint()) + }); + + var illustrationPoints = new Dictionary + { + { + new WindDirectionClosingSituation(new TestWindDirection(), "closing A"), + illustrationPointNode + } + }; + return new GeneralResult(0.5, new TestWindDirection(), Enumerable.Empty(), illustrationPoints); + } + + /// + /// Creates a new instance of + /// with non distinct illustration point names + /// + /// A with non distinct illustration point names + public static GeneralResult CreateGeneralResultWithNonDistinctNamesInChildren() + { + var illustrationPointNode = new IllustrationPointTreeNode(new FaultTreeIllustrationPoint("Point A", + 0.5, + Enumerable.Empty(), + CombinationType.And)); + illustrationPointNode.SetChildren(new[] + { + new IllustrationPointTreeNode(new TestSubMechanismIllustrationPoint("Point B")), + new IllustrationPointTreeNode(new TestSubMechanismIllustrationPoint("Point B")) + }); + var illustrationPoints = new Dictionary + { + { + new WindDirectionClosingSituation(new TestWindDirection(), "closing A"), + illustrationPointNode + } + }; + return new GeneralResult(0.5, new TestWindDirection(), Enumerable.Empty(), illustrationPoints); + } + } +} \ No newline at end of file Index: Ringtoets/HydraRing/test/Ringtoets.HydraRing.Calculation.TestUtil/Ringtoets.HydraRing.Calculation.TestUtil.csproj =================================================================== diff -u -ra1fa1538918813373bcc864f0bce092bf28fd0ce -ra4bd5433cf68976014c17b17cd9cfb766b135c74 --- Ringtoets/HydraRing/test/Ringtoets.HydraRing.Calculation.TestUtil/Ringtoets.HydraRing.Calculation.TestUtil.csproj (.../Ringtoets.HydraRing.Calculation.TestUtil.csproj) (revision a1fa1538918813373bcc864f0bce092bf28fd0ce) +++ Ringtoets/HydraRing/test/Ringtoets.HydraRing.Calculation.TestUtil/Ringtoets.HydraRing.Calculation.TestUtil.csproj (.../Ringtoets.HydraRing.Calculation.TestUtil.csproj) (revision a4bd5433cf68976014c17b17cd9cfb766b135c74) @@ -55,6 +55,7 @@ +