Beispiel #1
0
        public void PropertyAttributes_WithDikeHeightAndOvertoppingRateCalculated_ReturnExpectedValues()
        {
            // Setup
            var resultOutput = new OvertoppingOutput(10,
                                                     true,
                                                     0,
                                                     null);
            var dikeHeightOutput      = new TestDikeHeightOutput(double.NaN);
            var overtoppingRateOutput = new TestOvertoppingRateOutput(double.NaN);

            var output = new GrassCoverErosionInwardsOutput(resultOutput,
                                                            dikeHeightOutput,
                                                            overtoppingRateOutput);

            // Call
            var properties = new GrassCoverErosionInwardsOutputProperties(output);

            // Assert
            PropertyDescriptorCollection dynamicProperties = PropertiesTestHelper.GetAllVisiblePropertyDescriptors(properties);

            Assert.AreEqual(16, dynamicProperties.Count);

            AssertResultOutputProperties(dynamicProperties);
            AssertDikeHeightOutputProperties(dynamicProperties, firstHydraulicLoadsOutputIndex);
            AssertOvertoppingRateOutputProperties(dynamicProperties, secondHydraulicLoadsOutputIndex);
        }
Beispiel #2
0
        public void Constructor_ExpectedValues()
        {
            // Setup
            var grassCoverErosionInwardsOutput = new TestGrassCoverErosionInwardsOutput();

            // Call
            var properties = new GrassCoverErosionInwardsOutputProperties(grassCoverErosionInwardsOutput);

            // Assert
            Assert.IsInstanceOf <ObjectProperties <GrassCoverErosionInwardsOutput> >(properties);
            Assert.AreSame(grassCoverErosionInwardsOutput, properties.Data);
        }
Beispiel #3
0
        public void PropertyAttributes_WithoutDikeHeightAndOvertoppingRateCalculated_ReturnExpectedValues(double waveHeight)
        {
            // Setup
            var resultOutput = new OvertoppingOutput(waveHeight,
                                                     true,
                                                     0,
                                                     null);

            var output = new GrassCoverErosionInwardsOutput(resultOutput, null, null);

            // Call
            var properties = new GrassCoverErosionInwardsOutputProperties(output);

            // Assert
            int propertiesCount = double.IsNaN(waveHeight) ? 3 : 4;

            PropertyDescriptorCollection dynamicProperties = PropertiesTestHelper.GetAllVisiblePropertyDescriptors(properties);

            Assert.AreEqual(propertiesCount, dynamicProperties.Count);

            AssertResultOutputProperties(dynamicProperties, !double.IsNaN(waveHeight));
        }
Beispiel #4
0
        public void GetProperties_WithData_ReturnExpectedValues()
        {
            // Setup
            var    random                               = new Random(39);
            double waveHeight                           = random.NextDouble();
            bool   isOvertoppingDominant                = Convert.ToBoolean(random.Next(0, 2));
            double reliability                          = random.NextDouble();
            double dikeHeight                           = random.NextDouble();
            double dikeHeightTargetProbability          = random.NextDouble();
            double dikeHeightTargetReliability          = random.NextDouble();
            double dikeHeightCalculatedProbability      = random.NextDouble();
            double dikeHeightCalculatedReliability      = random.NextDouble();
            var    dikeHeightConvergence                = random.NextEnumValue <CalculationConvergence>();
            double overtoppingRate                      = random.NextDouble();
            double overtoppingRateTargetProbability     = random.NextDouble();
            double overtoppingRateTargetReliability     = random.NextDouble();
            double overtoppingRateCalculatedProbability = random.NextDouble();
            double overtoppingRateCalculatedReliability = random.NextDouble();
            var    overtoppingRateConvergence           = random.NextEnumValue <CalculationConvergence>();

            var resultOutput = new OvertoppingOutput(waveHeight,
                                                     isOvertoppingDominant,
                                                     reliability,
                                                     null);

            var dikeHeightOutput = new DikeHeightOutput(dikeHeight,
                                                        dikeHeightTargetProbability,
                                                        dikeHeightTargetReliability,
                                                        dikeHeightCalculatedProbability,
                                                        dikeHeightCalculatedReliability,
                                                        dikeHeightConvergence,
                                                        null);
            var overtoppingRateOutput = new OvertoppingRateOutput(overtoppingRate,
                                                                  overtoppingRateTargetProbability,
                                                                  overtoppingRateTargetReliability,
                                                                  overtoppingRateCalculatedProbability,
                                                                  overtoppingRateCalculatedReliability,
                                                                  overtoppingRateConvergence,
                                                                  null);
            var output = new GrassCoverErosionInwardsOutput(resultOutput, dikeHeightOutput, overtoppingRateOutput);

            // Call
            var properties = new GrassCoverErosionInwardsOutputProperties(output);

            // Assert
            Assert.AreEqual(2, properties.WaveHeight.NumberOfDecimalPlaces);
            Assert.AreEqual(waveHeight, properties.WaveHeight, properties.WaveHeight.GetAccuracy());
            Assert.AreEqual(reliability, properties.Reliability, properties.Reliability.GetAccuracy());

            Assert.AreEqual(ProbabilityFormattingHelper.Format(0.5), properties.Probability);

            Assert.AreEqual(isOvertoppingDominant, properties.IsOvertoppingDominant);

            Assert.AreEqual(2, properties.DikeHeight.NumberOfDecimalPlaces);
            Assert.AreEqual(dikeHeight, properties.DikeHeight, properties.DikeHeight.GetAccuracy());
            Assert.AreEqual(dikeHeightTargetProbability, properties.DikeHeightTargetProbability);
            TestHelper.AssertTypeConverter <GrassCoverErosionInwardsOutputProperties, NoProbabilityValueDoubleConverter>(
                nameof(GrassCoverErosionInwardsOutputProperties.DikeHeightTargetProbability));
            Assert.AreEqual(dikeHeightTargetReliability, properties.DikeHeightTargetReliability, properties.DikeHeightTargetReliability.GetAccuracy());
            TestHelper.AssertTypeConverter <GrassCoverErosionInwardsOutputProperties, NoValueRoundedDoubleConverter>(
                nameof(GrassCoverErosionInwardsOutputProperties.DikeHeightTargetReliability));
            Assert.AreEqual(dikeHeightCalculatedProbability, properties.DikeHeightCalculatedProbability);
            TestHelper.AssertTypeConverter <GrassCoverErosionInwardsOutputProperties, NoProbabilityValueDoubleConverter>(
                nameof(GrassCoverErosionInwardsOutputProperties.DikeHeightCalculatedProbability));
            Assert.AreEqual(dikeHeightCalculatedReliability, properties.DikeHeightCalculatedReliability, properties.DikeHeightCalculatedReliability.GetAccuracy());
            TestHelper.AssertTypeConverter <GrassCoverErosionInwardsOutputProperties, NoValueRoundedDoubleConverter>(
                nameof(GrassCoverErosionInwardsOutputProperties.DikeHeightCalculatedReliability));

            string dikeHeightConvergenceValue = EnumDisplayNameHelper.GetDisplayName(dikeHeightConvergence);

            Assert.AreEqual(dikeHeightConvergenceValue, properties.DikeHeightConvergence);

            Assert.AreEqual(2, properties.OvertoppingRate.NumberOfDecimalPlaces);
            Assert.AreEqual(overtoppingRate * 1000, properties.OvertoppingRate, properties.OvertoppingRate.GetAccuracy());
            Assert.AreEqual(overtoppingRateTargetProbability, properties.OvertoppingRateTargetProbability);
            TestHelper.AssertTypeConverter <GrassCoverErosionInwardsOutputProperties, NoProbabilityValueDoubleConverter>(
                nameof(GrassCoverErosionInwardsOutputProperties.OvertoppingRateTargetProbability));
            Assert.AreEqual(overtoppingRateTargetReliability, properties.OvertoppingRateTargetReliability, properties.OvertoppingRateTargetReliability.GetAccuracy());
            TestHelper.AssertTypeConverter <GrassCoverErosionInwardsOutputProperties, NoValueRoundedDoubleConverter>(
                nameof(GrassCoverErosionInwardsOutputProperties.OvertoppingRateTargetReliability));
            Assert.AreEqual(overtoppingRateCalculatedProbability, properties.OvertoppingRateCalculatedProbability);
            TestHelper.AssertTypeConverter <GrassCoverErosionInwardsOutputProperties, NoProbabilityValueDoubleConverter>(
                nameof(GrassCoverErosionInwardsOutputProperties.OvertoppingRateCalculatedProbability));
            Assert.AreEqual(overtoppingRateCalculatedReliability, properties.OvertoppingRateCalculatedReliability, properties.OvertoppingRateCalculatedReliability.GetAccuracy());
            TestHelper.AssertTypeConverter <GrassCoverErosionInwardsOutputProperties, NoValueRoundedDoubleConverter>(
                nameof(GrassCoverErosionInwardsOutputProperties.OvertoppingRateCalculatedReliability));

            string overtoppingRateConvergenceValue = EnumDisplayNameHelper.GetDisplayName(overtoppingRateConvergence);

            Assert.AreEqual(overtoppingRateConvergenceValue, properties.OvertoppingRateConvergence);
        }