public void ClearIllustrationPoints_CalculationsNull_ThrowsArgumentNullException()
        {
            // Call
            void Call() => GrassCoverErosionInwardsDataSynchronizationService.ClearIllustrationPoints(null);

            // Assert
            var exception = Assert.Throws <ArgumentNullException>(Call);

            Assert.AreEqual("calculations", exception.ParamName);
        }
 public override IEnumerable <IObservable> ClearIllustrationPoints()
 {
     return(GrassCoverErosionInwardsDataSynchronizationService.ClearIllustrationPoints(calculations));
 }
        public void ClearIllustrationPoints_CalculationsWithAndWithoutIllustrationPoints_ReturnsAffectedObjects()
        {
            // Setup
            var random = new Random(21);

            var overtoppingOutputWithIllustrationPoints = new GrassCoverErosionInwardsOutput(new TestOvertoppingOutput(new TestGeneralResultFaultTreeIllustrationPoint()),
                                                                                             null,
                                                                                             null);
            var calculationWithOverToppingOutputWithIllustrationPoints = new GrassCoverErosionInwardsCalculation
            {
                Output = overtoppingOutputWithIllustrationPoints
            };

            var dikeHeightOutputWithIllustrationPoints = new GrassCoverErosionInwardsOutput(new TestOvertoppingOutput(random.NextDouble()),
                                                                                            new TestDikeHeightOutput(new TestGeneralResultFaultTreeIllustrationPoint()),
                                                                                            null);
            var calculationWithDikeHeightWithIllustrationPoints = new GrassCoverErosionInwardsCalculation
            {
                Output = dikeHeightOutputWithIllustrationPoints
            };

            var overtoppingRateOutputWithIllustrationPoints = new GrassCoverErosionInwardsOutput(new TestOvertoppingOutput(random.NextDouble()),
                                                                                                 null,
                                                                                                 new TestOvertoppingRateOutput(new TestGeneralResultFaultTreeIllustrationPoint()));
            var calculationWithOvertoppingRateWithIllustrationPoints = new GrassCoverErosionInwardsCalculation
            {
                Output = overtoppingRateOutputWithIllustrationPoints
            };

            var outputWithNoIllustrationPoints = new GrassCoverErosionInwardsOutput(new TestOvertoppingOutput(random.NextDouble()),
                                                                                    null,
                                                                                    null);
            var calculationWitNoIllustrationPoints = new GrassCoverErosionInwardsCalculation
            {
                Output = outputWithNoIllustrationPoints
            };

            GrassCoverErosionInwardsCalculation[] calculations =
            {
                calculationWitNoIllustrationPoints,
                calculationWithOverToppingOutputWithIllustrationPoints,
                calculationWithOvertoppingRateWithIllustrationPoints,
                calculationWithDikeHeightWithIllustrationPoints,
                new GrassCoverErosionInwardsCalculation()
            };

            // Call
            IEnumerable <IObservable> affectedObjects = GrassCoverErosionInwardsDataSynchronizationService.ClearIllustrationPoints(calculations);

            // Assert
            CollectionAssert.AreEquivalent(new[]
            {
                calculationWithOverToppingOutputWithIllustrationPoints,
                calculationWithOvertoppingRateWithIllustrationPoints,
                calculationWithDikeHeightWithIllustrationPoints
            }, affectedObjects);

            GrassCoverErosionInwardsCalculation[] calculationsWithOutput =
            {
                calculationWitNoIllustrationPoints,
                calculationWithOverToppingOutputWithIllustrationPoints,
                calculationWithOvertoppingRateWithIllustrationPoints,
                calculationWithDikeHeightWithIllustrationPoints
            };
            Assert.IsTrue(calculationsWithOutput.All(calc => calc.HasOutput));

            Assert.IsTrue(calculationsWithOutput.All(calc =>
            {
                GrassCoverErosionInwardsOutput output = calc.Output;

                return(!output.OvertoppingOutput.HasGeneralResult &&
                       output.DikeHeightOutput?.GeneralResult == null &&
                       output.OvertoppingRateOutput?.GeneralResult == null);
            }));
        }