private static void AssertCalculationScenario(GrassCoverErosionInwardsCalculationScenario expectedCalculation, GrassCoverErosionInwardsCalculationScenario actualCalculation)
{
Assert.AreEqual(expectedCalculation.Name, actualCalculation.Name);
Assert.AreEqual(expectedCalculation.IsRelevant, actualCalculation.IsRelevant);
Assert.AreEqual(expectedCalculation.Contribution, actualCalculation.Contribution);
GrassCoverErosionInwardsInput expectedInput = expectedCalculation.InputParameters;
GrassCoverErosionInwardsInput actualInput = actualCalculation.InputParameters;
Assert.AreSame(expectedInput.HydraulicBoundaryLocation, actualInput.HydraulicBoundaryLocation);
Assert.AreEqual(expectedInput.Orientation, actualInput.Orientation);
Assert.AreSame(expectedInput.DikeProfile, actualInput.DikeProfile);
Assert.AreEqual(expectedInput.DikeHeight, actualInput.DikeHeight);
Assert.AreEqual(expectedInput.UseForeshore, actualInput.UseForeshore);
Assert.AreEqual(expectedInput.UseBreakWater, actualInput.UseBreakWater);
Assert.AreEqual(expectedInput.BreakWater.Height, actualInput.BreakWater.Height);
Assert.AreEqual(expectedInput.BreakWater.Type, actualInput.BreakWater.Type);
DistributionAssert.AreEqual(expectedInput.CriticalFlowRate, actualInput.CriticalFlowRate);
Assert.AreEqual(expectedInput.ShouldOvertoppingOutputIllustrationPointsBeCalculated,
actualInput.ShouldOvertoppingOutputIllustrationPointsBeCalculated);
Assert.AreEqual(expectedInput.ShouldDikeHeightBeCalculated, actualInput.ShouldDikeHeightBeCalculated);
Assert.AreEqual(expectedInput.DikeHeightTargetProbability, actualInput.DikeHeightTargetProbability);
Assert.AreEqual(expectedInput.ShouldDikeHeightIllustrationPointsBeCalculated,
actualInput.ShouldDikeHeightIllustrationPointsBeCalculated);
Assert.AreEqual(expectedInput.ShouldOvertoppingRateBeCalculated, actualInput.ShouldOvertoppingRateBeCalculated);
Assert.AreEqual(expectedInput.OvertoppingRateTargetProbability, actualInput.OvertoppingRateTargetProbability);
Assert.AreEqual(expectedInput.ShouldOvertoppingRateIllustrationPointsBeCalculated,
actualInput.ShouldOvertoppingRateIllustrationPointsBeCalculated);
}
public void CriticalFlowRate_SetNewValue_GetNewValues()
{
// Setup
var random = new Random(22);
var input = new GrassCoverErosionInwardsInput();
RoundedDouble mean = random.NextRoundedDouble(0.01, double.MaxValue);
RoundedDouble standardDeviation = random.NextRoundedDouble(0.01, double.MaxValue);
var expectedDistribution = new LogNormalDistribution(4)
{
Mean = mean,
StandardDeviation = standardDeviation
};
var distributionToSet = new LogNormalDistribution(5)
{
Mean = mean,
StandardDeviation = standardDeviation
};
// Call
input.CriticalFlowRate = distributionToSet;
// Assert
DistributionTestHelper.AssertDistributionCorrectlySet(input.CriticalFlowRate,
distributionToSet,
expectedDistribution);
}
public void Constructor_ExpectedValues()
{
// Setup
var criticalFlowRate = new LogNormalDistribution(4)
{
Mean = (RoundedDouble)0.004,
StandardDeviation = (RoundedDouble)0.0006
};
// Call
var input = new GrassCoverErosionInwardsInput();
// Assert
Assert.IsInstanceOf <CloneableObservable>(input);
Assert.IsInstanceOf <ICalculationInputWithHydraulicBoundaryLocation>(input);
Assert.IsInstanceOf <IUseBreakWater>(input);
Assert.IsInstanceOf <IUseForeshore>(input);
Assert.AreEqual(2, input.Orientation.NumberOfDecimalPlaces);
Assert.AreEqual(2, input.DikeHeight.NumberOfDecimalPlaces);
AssertDefaultDikeProfileInput(input);
Assert.IsNull(input.HydraulicBoundaryLocation);
Assert.IsFalse(input.ShouldDikeHeightBeCalculated);
Assert.IsFalse(input.ShouldOvertoppingRateBeCalculated);
Assert.AreEqual(0, input.DikeHeightTargetProbability);
Assert.AreEqual(0, input.OvertoppingRateTargetProbability);
DistributionAssert.AreEqual(criticalFlowRate, input.CriticalFlowRate);
}
/// <summary>
/// This method sets random data values to all properties of <paramref name="input"/>.
/// </summary>
/// <param name="input">The input to set the random data values to.</param>
public static void SetRandomDataToGrassCoverErosionInwardsInput(GrassCoverErosionInwardsInput input)
{
var random = new Random(21);
input.Orientation = random.NextRoundedDouble();
input.DikeHeight = random.NextRoundedDouble();
input.CriticalFlowRate = new LogNormalDistribution
{
Mean = random.NextRoundedDouble(),
StandardDeviation = random.NextRoundedDouble()
};
input.HydraulicBoundaryLocation = new TestHydraulicBoundaryLocation();
input.ShouldDikeHeightBeCalculated = random.NextBoolean();
input.DikeHeightTargetProbability = random.NextDouble(1e-15, 0.1);
input.ShouldDikeHeightIllustrationPointsBeCalculated = random.NextBoolean();
input.ShouldOvertoppingRateBeCalculated = random.NextBoolean();
input.OvertoppingRateTargetProbability = random.NextDouble(1e-15, 0.1);
input.ShouldOvertoppingRateIllustrationPointsBeCalculated = random.NextBoolean();
input.ShouldOvertoppingOutputIllustrationPointsBeCalculated = random.NextBoolean();
input.DikeProfile = DikeProfileTestFactory.CreateDikeProfile();
input.UseBreakWater = random.NextBoolean();
input.BreakWater.Type = random.NextEnumValue <BreakWaterType>();
input.BreakWater.Height = random.NextRoundedDouble();
input.UseForeshore = random.NextBoolean();
}
public void OvertoppingRateTargetProbability_ValidValue_NewValueSet(double newValue)
{
// Setup
var input = new GrassCoverErosionInwardsInput();
// Call
input.OvertoppingRateTargetProbability = newValue;
// Assert
Assert.AreEqual(newValue, input.OvertoppingRateTargetProbability);
}
public void SynchronizeDikeProfileInput_DikeProfileNotSet_ExpectedValues()
{
// Setup
var input = new GrassCoverErosionInwardsInput();
// Call
input.SynchronizeDikeProfileInput();
// Assert
AssertDefaultDikeProfileInput(input);
}
public void DikeProfile_SetNewValue_InputSyncedAccordingly(DikeProfile newDikeProfile)
{
// Setup
var input = new GrassCoverErosionInwardsInput();
// Call
input.DikeProfile = newDikeProfile;
// Assert
AssertDikeProfileInput(newDikeProfile, input);
}
public void IsDikeProfileInputSynchronized_DikeProfileNotSet_ReturnFalse()
{
// Setup
var input = new GrassCoverErosionInwardsInput();
// Call
bool synchronized = input.IsDikeProfileInputSynchronized;
// Assert
Assert.IsFalse(synchronized);
}
private static void AssertDefaultDikeProfileInput(GrassCoverErosionInwardsInput input)
{
Assert.IsNull(input.DikeProfile);
Assert.IsNaN(input.Orientation);
Assert.IsFalse(input.UseBreakWater);
Assert.AreEqual(BreakWaterType.Dam, input.BreakWater.Type);
Assert.AreEqual(0, input.BreakWater.Height, input.BreakWater.Height.GetAccuracy());
Assert.IsFalse(input.UseForeshore);
CollectionAssert.IsEmpty(input.ForeshoreGeometry);
CollectionAssert.IsEmpty(input.DikeGeometry);
Assert.IsNaN(input.DikeHeight);
}
private void SetChartData()
{
GrassCoverErosionInwardsInput input = data.InputParameters;
DikeProfile dikeProfile = input.DikeProfile;
GrassCoverErosionInwardsChartDataFactory.UpdateForeshoreGeometryChartDataName(foreshoreChartData, input);
GrassCoverErosionInwardsChartDataFactory.UpdateDikeGeometryChartDataName(dikeGeometryChartData, dikeProfile);
foreshoreChartData.Points = GrassCoverErosionInwardsChartDataPointsFactory.CreateForeshoreGeometryPoints(input);
dikeGeometryChartData.Points = GrassCoverErosionInwardsChartDataPointsFactory.CreateDikeGeometryPoints(dikeProfile);
dikeHeightChartData.Points = GrassCoverErosionInwardsChartDataPointsFactory.CreateDikeHeightPoints(input);
}
public void Orientation_SetInvalidValue_ThrowsArgumentOutOfRangeException(double invalidOrientation)
{
// Setup
var input = new GrassCoverErosionInwardsInput();
// Call
void Call() => input.Orientation = (RoundedDouble)invalidOrientation;
// Assert
const string expectedMessage = "De waarde voor de oriëntatie moet in het bereik [0,00, 360,00] liggen.";
TestHelper.AssertThrowsArgumentExceptionAndTestMessage <ArgumentOutOfRangeException>(Call, expectedMessage);
}
private static IEnumerable <IObservable> ClearDikeProfile(GrassCoverErosionInwardsInput inputParameters)
{
if (inputParameters.DikeProfile != null)
{
inputParameters.DikeProfile = null;
return(new[]
{
inputParameters
});
}
return(Enumerable.Empty <IObservable>());
}
public void Clone_AllPropertiesSet_ReturnNewInstanceWithCopiedValues()
{
// Setup
var original = new GrassCoverErosionInwardsInput();
GrassCoverErosionInwardsTestDataGenerator.SetRandomDataToGrassCoverErosionInwardsInput(original);
// Call
object clone = original.Clone();
// Assert
CoreCloneAssert.AreObjectClones(original, clone, GrassCoverErosionInwardsCloneAssert.AreClones);
}
private static IEnumerable <IObservable> ClearHydraulicBoundaryLocation(GrassCoverErosionInwardsInput input)
{
if (input.HydraulicBoundaryLocation != null)
{
input.HydraulicBoundaryLocation = null;
return(new[]
{
input
});
}
return(Enumerable.Empty <IObservable>());
}
public void CreateForeshoreGeometryPoints_DikeProfileNull_ReturnsEmptyCollection()
{
// Setup
var input = new GrassCoverErosionInwardsInput
{
UseForeshore = true
};
// Call
IEnumerable <Point2D> points = GrassCoverErosionInwardsChartDataPointsFactory.CreateForeshoreGeometryPoints(input);
// Assert
CollectionAssert.IsEmpty(points);
}
public void Orientation_SetNewValue_ValueIsRounded(double validOrientation)
{
// Setup
var input = new GrassCoverErosionInwardsInput();
int originalNumberOfDecimalPlaces = input.Orientation.NumberOfDecimalPlaces;
// Call
input.Orientation = new RoundedDouble(5, validOrientation);
// Assert
Assert.AreEqual(originalNumberOfDecimalPlaces, input.Orientation.NumberOfDecimalPlaces);
Assert.AreEqual(validOrientation, input.Orientation.Value, input.Orientation.GetAccuracy());
}
public void DikeHeight_SetNewValue_ValueIsRounded()
{
// Setup
var input = new GrassCoverErosionInwardsInput();
int originalNumberOfDecimalPlaces = input.DikeHeight.NumberOfDecimalPlaces;
// Call
input.DikeHeight = new RoundedDouble(5, 1.23456);
// Assert
Assert.AreEqual(originalNumberOfDecimalPlaces, input.DikeHeight.NumberOfDecimalPlaces);
Assert.AreEqual(1.23, input.DikeHeight.Value);
}
public void OvertoppingRateTargetProbability_InvalidValue_ThrowsArgumentOutOfRangeException(double invalidValue)
{
// Setup
var input = new GrassCoverErosionInwardsInput();
// Call
void Call() => input.OvertoppingRateTargetProbability = invalidValue;
// Assert
const string expectedMessage = "De waarde van de doelkans moet groter zijn dan 0 en kleiner dan of gelijk aan 0,1.";
var exception = Assert.Throws <ArgumentOutOfRangeException>(Call);
StringAssert.StartsWith(expectedMessage, exception.Message);
}
public void EditValue_WithCurrentItemInAvailableItems_ReturnsCurrentItem()
{
// Setup
DikeProfile dikeProfile = DikeProfileTestFactory.CreateDikeProfile();
var failureMechanism = new GrassCoverErosionInwardsFailureMechanism();
failureMechanism.DikeProfiles.AddRange(new[]
{
dikeProfile
}, "path");
var grassCoverErosionInwardsInput = new GrassCoverErosionInwardsInput
{
DikeProfile = dikeProfile
};
var grassCoverErosionInwardsCalculation = new GrassCoverErosionInwardsCalculation();
var assessmentSection = mockRepository.Stub <IAssessmentSection>();
var inputContext = new GrassCoverErosionInwardsInputContext(grassCoverErosionInwardsInput,
grassCoverErosionInwardsCalculation,
failureMechanism,
assessmentSection);
var handler = mockRepository.Stub <IObservablePropertyChangeHandler>();
var properties = new GrassCoverErosionInwardsInputContextProperties(inputContext, handler);
var editor = new GrassCoverErosionInwardsInputContextDikeProfileEditor();
var propertyBag = new DynamicPropertyBag(properties);
var serviceProvider = mockRepository.StrictMock <IServiceProvider>();
var service = mockRepository.StrictMock <IWindowsFormsEditorService>();
var descriptorContext = mockRepository.StrictMock <ITypeDescriptorContext>();
serviceProvider.Expect(p => p.GetService(null)).IgnoreArguments().Return(service);
service.Expect(s => s.DropDownControl(null)).IgnoreArguments();
service.Expect(s => s.CloseDropDown()).IgnoreArguments();
descriptorContext.Expect(c => c.Instance).Return(propertyBag).Repeat.Twice();
mockRepository.ReplayAll();
var someValue = new object();
// Call
object result = editor.EditValue(descriptorContext, serviceProvider, someValue);
// Assert
Assert.AreSame(dikeProfile, result);
mockRepository.VerifyAll();
}
public void UpdateForeshoreGeometryChartDataName_DikeProfileNull_NameSetToDefaultName()
{
// Setup
var chartData = new ChartLineData("test name");
var input = new GrassCoverErosionInwardsInput
{
UseForeshore = true
};
// Call
GrassCoverErosionInwardsChartDataFactory.UpdateForeshoreGeometryChartDataName(chartData, input);
// Assert
Assert.AreEqual("Voorlandprofiel", chartData.Name);
}
public void DikeProfile_SetNullValue_InputSyncedToDefaults()
{
// Setup
DikeProfile dikeProfile = CreateTestDikeProfile();
var input = new GrassCoverErosionInwardsInput
{
DikeProfile = dikeProfile
};
// Call
input.DikeProfile = null;
// Assert
AssertDefaultDikeProfileInput(input);
}
public void UpdateForeshoreGeometryChartDataName_DikeProfileSetUseForeshoreFalse_NameSetToDefaultName()
{
// Setup
var chartData = new ChartLineData("test name");
var input = new GrassCoverErosionInwardsInput
{
DikeProfile = DikeProfileTestFactory.CreateDikeProfile("dike profile name"),
UseForeshore = false
};
// Call
GrassCoverErosionInwardsChartDataFactory.UpdateForeshoreGeometryChartDataName(chartData, input);
// Assert
Assert.AreEqual("Voorlandprofiel", chartData.Name);
}
/// <summary>
/// Create dike height points in 2D space based on the provided <paramref name="input"/>.
/// </summary>
/// <param name="input">The <see cref="GrassCoverErosionInwardsInput"/> to create the dike height points for.</param>
/// <returns>A collection of points in 2D space or an empty collection when:
/// <list type="bullet">
/// <item><paramref name="input"/> is <c>null</c>;</item>
/// <item>the dike profile in <paramref name="input"/> is <c>null</c>;</item>
/// <item>the dike height in <paramref name="input"/> is <c>double.NaN</c>;</item>
/// <item>the dike geometry in <paramref name="input"/> contains less than two points.</item>
/// </list>
/// </returns>
public static IEnumerable <Point2D> CreateDikeHeightPoints(GrassCoverErosionInwardsInput input)
{
if (input?.DikeProfile == null || double.IsNaN(input.DikeHeight) || input.DikeProfile.DikeGeometry.Count() < 2)
{
return(new Point2D[0]);
}
DikeProfile dikeProfile = input.DikeProfile;
IEnumerable <RoughnessPoint> roughnessPoints = dikeProfile.DikeGeometry;
return(new[]
{
new Point2D(roughnessPoints.First().Point.X, input.DikeHeight),
new Point2D(roughnessPoints.Last().Point.X, input.DikeHeight)
});
}
public void CreateDikeHeightPoints_DikeProfileSetDikeGeometryLessThanTwoPoints_ReturnsEmptyCollection()
{
// Setup
var input = new GrassCoverErosionInwardsInput
{
DikeProfile = DikeProfileTestFactory.CreateDikeProfile(new[]
{
new RoughnessPoint(new Point2D(1.1, 2.2), 0.5)
}),
DikeHeight = (RoundedDouble)5.5
};
// Call
IEnumerable <Point2D> points = GrassCoverErosionInwardsChartDataPointsFactory.CreateDikeHeightPoints(input);
// Assert
CollectionAssert.IsEmpty(points);
}
public void UpdateForeshoreGeometryChartDataName_DikeProfileSetUseForeshoreTrue_NameSetToDikeProfileName()
{
// Setup
var chartData = new ChartLineData("test name");
var input = new GrassCoverErosionInwardsInput
{
DikeProfile = DikeProfileTestFactory.CreateDikeProfile("dike profile name"),
UseForeshore = true
};
// Call
GrassCoverErosionInwardsChartDataFactory.UpdateForeshoreGeometryChartDataName(chartData, input);
// Assert
string expectedName = $"{input.DikeProfile.Name} - Voorlandprofiel";
Assert.AreEqual(expectedName, chartData.Name);
}
public void IsDikeProfileInputSynchronized_InputParametersAndDikeProfileNotInSync_ReturnFalse(DikeProfile newDikeProfile)
{
// Setup
DikeProfile dikeProfile = CreateTestDikeProfile();
var input = new GrassCoverErosionInwardsInput
{
DikeProfile = dikeProfile
};
dikeProfile.CopyProperties(newDikeProfile);
// Call
bool synchronized = input.IsDikeProfileInputSynchronized;
// Assert
Assert.IsFalse(synchronized);
}
private static void AssertDikeProfileInput(DikeProfile expectedDikeProfile, GrassCoverErosionInwardsInput input)
{
Assert.AreEqual(expectedDikeProfile.Orientation, input.Orientation, input.Orientation.GetAccuracy());
Assert.AreEqual(expectedDikeProfile.HasBreakWater, input.UseBreakWater);
Assert.AreEqual(expectedDikeProfile.HasBreakWater
? expectedDikeProfile.BreakWater.Type
: BreakWaterType.Dam,
input.BreakWater.Type);
Assert.AreEqual(expectedDikeProfile.HasBreakWater
? expectedDikeProfile.BreakWater.Height
: 0.0,
input.BreakWater.Height);
Assert.AreEqual(expectedDikeProfile.ForeshoreGeometry.Any(), input.UseForeshore);
CollectionAssert.AreEqual(expectedDikeProfile.ForeshoreGeometry, input.ForeshoreGeometry);
CollectionAssert.AreEqual(expectedDikeProfile.DikeGeometry, input.DikeGeometry);
Assert.AreEqual(expectedDikeProfile.DikeHeight, input.DikeHeight, input.DikeHeight.GetAccuracy());
}
/// <summary>
/// Method that asserts whether <paramref name="original"/> and <paramref name="clone"/>
/// are clones.
/// </summary>
/// <param name="original">The original object.</param>
/// <param name="clone">The cloned object.</param>
/// <exception cref="AssertionException">Thrown when <paramref name="original"/> and
/// <paramref name="clone"/> are not clones.</exception>
public static void AreClones(GrassCoverErosionInwardsInput original, GrassCoverErosionInwardsInput clone)
{
Assert.AreSame(original.DikeProfile, clone.DikeProfile);
Assert.AreEqual(original.Orientation, clone.Orientation);
Assert.AreEqual(original.DikeHeight, clone.DikeHeight);
CoreCloneAssert.AreObjectClones(original.CriticalFlowRate, clone.CriticalFlowRate, DistributionAssert.AreEqual);
Assert.AreSame(original.HydraulicBoundaryLocation, clone.HydraulicBoundaryLocation);
Assert.AreEqual(original.ShouldDikeHeightBeCalculated, clone.ShouldDikeHeightBeCalculated);
Assert.AreEqual(original.DikeHeightTargetProbability, clone.DikeHeightTargetProbability);
Assert.AreEqual(original.ShouldDikeHeightIllustrationPointsBeCalculated, clone.ShouldDikeHeightIllustrationPointsBeCalculated);
Assert.AreEqual(original.ShouldOvertoppingRateBeCalculated, clone.ShouldOvertoppingRateBeCalculated);
Assert.AreEqual(original.OvertoppingRateTargetProbability, clone.OvertoppingRateTargetProbability);
Assert.AreEqual(original.ShouldOvertoppingRateIllustrationPointsBeCalculated, clone.ShouldOvertoppingRateIllustrationPointsBeCalculated);
Assert.AreEqual(original.ShouldOvertoppingOutputIllustrationPointsBeCalculated, clone.ShouldOvertoppingOutputIllustrationPointsBeCalculated);
Assert.AreEqual(original.UseBreakWater, clone.UseBreakWater);
CoreCloneAssert.AreObjectClones(original.BreakWater, clone.BreakWater, CommonCloneAssert.AreClones);
Assert.AreEqual(original.UseForeshore, clone.UseForeshore);
}
public void SynchronizeDikeProfileInput_ChangedDikeProfile_ExpectedValues(DikeProfile newDikeProfile)
{
// Setup
DikeProfile dikeProfile = CreateTestDikeProfile();
var input = new GrassCoverErosionInwardsInput
{
DikeProfile = dikeProfile
};
dikeProfile.CopyProperties(newDikeProfile);
// Call
input.SynchronizeDikeProfileInput();
// Assert
AssertDikeProfileInput(newDikeProfile, input);
}
public void IsDikeProfileInputSynchronized_InputParametersAndDikeProfileInSync_ReturnTrue()
{
// Setup
var input = new GrassCoverErosionInwardsInput
{
DikeProfile = DikeProfileTestFactory.CreateDikeProfile(new[]
{
new Point2D(3.3, 4.4),
new Point2D(5.5, 6.6)
})
};
// Call
bool synchronized = input.IsDikeProfileInputSynchronized;
// Assert
Assert.IsTrue(synchronized);
}
