public void ChildNodeObjects_Always_ReturnsCollectionWithOutputObjects(bool hasOutput)
{
// Setup
var grassCoverErosionInwardsCalculation = new GrassCoverErosionInwardsCalculation
{
Output = hasOutput ? new TestGrassCoverErosionInwardsOutput() : null
};
var grassCoverErosionInwardsOutputContext = new GrassCoverErosionInwardsOutputContext(grassCoverErosionInwardsCalculation);
// Call
object[] children = info.ChildNodeObjects(grassCoverErosionInwardsOutputContext).ToArray();
// Assert
Assert.AreEqual(3, children.Length);
var overtoppingOutputContext = children[0] as OvertoppingOutputContext;
Assert.IsNotNull(overtoppingOutputContext);
Assert.AreSame(grassCoverErosionInwardsCalculation, overtoppingOutputContext.WrappedData);
var dikeHeightOutputContext = children[1] as DikeHeightOutputContext;
Assert.IsNotNull(dikeHeightOutputContext);
Assert.AreSame(grassCoverErosionInwardsCalculation, dikeHeightOutputContext.WrappedData);
var overtoppingRateOutputContext = children[2] as OvertoppingRateOutputContext;
Assert.IsNotNull(overtoppingRateOutputContext);
Assert.AreSame(grassCoverErosionInwardsCalculation, overtoppingRateOutputContext.WrappedData);
}
public void CloseForData_NestedViewCorrespondingToRemovedFailureMechanismContext_ReturnsTrue()
{
// Setup
var assessmentSection = mocks.Stub <IAssessmentSection>();
mocks.ReplayAll();
var calculation = new GrassCoverErosionInwardsCalculation();
var calculationGroup = new CalculationGroup();
calculationGroup.Children.Add(calculation);
var failureMechanism = new GrassCoverErosionInwardsFailureMechanism();
failureMechanism.CalculationsGroup.Children.Add(calculationGroup);
var context = new GrassCoverErosionInwardsFailureMechanismContext(failureMechanism, assessmentSection);
using (var view = new GrassCoverErosionInwardsInputView
{
Data = calculation
})
{
// Call
bool closeForData = info.CloseForData(view, context);
// Assert
Assert.IsTrue(closeForData);
mocks.VerifyAll();
}
}
public void CloseForData_NestedViewNotCorrespondingToRemovedAssessmentSection_ReturnsFalse()
{
// Setup
var calculation = new GrassCoverErosionInwardsCalculation();
var calculationGroup = new CalculationGroup();
calculationGroup.Children.Add(calculation);
var failureMechanism = new GrassCoverErosionInwardsFailureMechanism();
failureMechanism.CalculationsGroup.Children.Add(calculationGroup);
var assessmentSection = mocks.Stub <IAssessmentSection>();
assessmentSection.Stub(section => section.GetFailureMechanisms()).Return(new[]
{
failureMechanism
});
mocks.ReplayAll();
using (var view = new GrassCoverErosionInwardsInputView
{
Data = new GrassCoverErosionInwardsCalculation()
})
{
// Call
bool closeForData = info.CloseForData(view, assessmentSection);
// Assert
Assert.IsFalse(closeForData);
mocks.VerifyAll();
}
}
public void NotifyObservers_DataUpdatedNotifyObserversOnOldData_NoUpdateInViewData()
{
// Setup
using (var view = new GrassCoverErosionInwardsInputView())
{
DikeProfile dikeProfile = GetDikeProfileWithGeometry();
var calculation1 = new GrassCoverErosionInwardsCalculation
{
InputParameters =
{
DikeProfile = dikeProfile
}
};
var calculation2 = new GrassCoverErosionInwardsCalculation();
view.Data = calculation1;
ChartData dataBeforeUpdate = view.Chart.Data;
view.Data = calculation2;
DikeProfile dikeProfile2 = GetSecondDikeProfileWithGeometry();
calculation1.InputParameters.DikeProfile = dikeProfile2;
// Call
calculation1.InputParameters.NotifyObservers();
// Assert
Assert.AreEqual(dataBeforeUpdate, view.Chart.Data);
}
}
public void CloseForData_NestedViewNotCorrespondingWithRemovedParentCalculationGroupContext_ReturnsFalse()
{
// Setup
var assessmentSection = mocks.Stub <IAssessmentSection>();
mocks.ReplayAll();
var calculation = new GrassCoverErosionInwardsCalculation();
var calculationGroup = new CalculationGroup();
var nestedGroup = new CalculationGroup();
nestedGroup.Children.Add(calculation);
calculationGroup.Children.Add(nestedGroup);
var calculationGroupContext = new GrassCoverErosionInwardsCalculationGroupContext(new CalculationGroup(),
null,
new GrassCoverErosionInwardsFailureMechanism(),
assessmentSection);
using (var view = new GrassCoverErosionInwardsInputView
{
Data = calculation
})
{
// Call
bool closeForData = info.CloseForData(view, calculationGroupContext);
// Assert
Assert.IsFalse(closeForData);
mocks.VerifyAll();
}
}
public void UpdateObserver_PreviousCalculationNameUpdated_ChartTitleNotUpdated()
{
// Setup
using (var view = new GrassCoverErosionInwardsInputView())
{
const string initialName = "Initial name";
const string updatedName = "Updated name";
var calculation = new GrassCoverErosionInwardsCalculation
{
Name = initialName
};
view.Data = calculation;
// Precondition
Assert.AreEqual(initialName, view.Chart.ChartTitle);
view.Data = new GrassCoverErosionInwardsCalculation
{
Name = initialName
};
calculation.Name = updatedName;
// Call
calculation.NotifyObservers();
// Assert
Assert.AreEqual(initialName, view.Chart.ChartTitle);
}
}
public void Data_UseForeshoreFalse_SetEmptyForeshoreDataOnChart()
{
// Setup
using (var view = new GrassCoverErosionInwardsInputView())
{
DikeProfile dikeProfile = GetDikeProfileWithGeometry();
var calculation = new GrassCoverErosionInwardsCalculation
{
InputParameters =
{
DikeProfile = dikeProfile,
UseForeshore = false
}
};
// Call
view.Data = calculation;
// Assert
Assert.AreSame(calculation, view.Data);
ChartDataCollection chartData = view.Chart.Data;
Assert.IsInstanceOf <ChartDataCollection>(chartData);
Assert.AreEqual(3, chartData.Collection.Count());
var dikeGeometryData = (ChartLineData)chartData.Collection.ElementAt(dikeProfileIndex);
var foreshoreData = (ChartLineData)chartData.Collection.ElementAt(foreshoreIndex);
var dikeHeightData = (ChartLineData)chartData.Collection.ElementAt(dikeHeightIndex);
CollectionAssert.IsEmpty(foreshoreData.Points);
Assert.AreEqual("Voorlandprofiel", foreshoreData.Name);
AssertDikeProfileChartData(dikeProfile, dikeGeometryData);
AssertDikeHeightChartData(dikeProfile, dikeHeightData);
}
}
public void Data_SetChartData_ChartDataSet()
{
// Setup
using (var view = new GrassCoverErosionInwardsInputView())
{
DikeProfile dikeProfile = GetDikeProfileWithGeometry();
var calculation = new GrassCoverErosionInwardsCalculation
{
InputParameters =
{
DikeProfile = dikeProfile
}
};
// Call
view.Data = calculation;
// Assert
Assert.AreSame(calculation, view.Data);
ChartDataCollection chartData = view.Chart.Data;
Assert.IsInstanceOf <ChartDataCollection>(chartData);
Assert.AreEqual(3, chartData.Collection.Count());
AssertDikeProfileChartData(dikeProfile, chartData.Collection.ElementAt(dikeProfileIndex));
AssertForeshoreChartData(dikeProfile, chartData.Collection.ElementAt(foreshoreIndex));
AssertDikeHeightChartData(dikeProfile, chartData.Collection.ElementAt(dikeHeightIndex));
}
}
private static void AssertCalculationsMapData(IEnumerable <GrassCoverErosionInwardsCalculation> calculations, MapData mapData)
{
Assert.IsInstanceOf <MapLineData>(mapData);
var calculationsMapData = (MapLineData)mapData;
GrassCoverErosionInwardsCalculation[] calculationsArray = calculations.ToArray();
MapFeature[] calculationsFeatures = calculationsMapData.Features.ToArray();
int calculationsCount = calculationsArray.Length;
Assert.AreEqual(calculationsCount, calculationsFeatures.Length);
for (var index = 0; index < calculationsCount; index++)
{
MapGeometry[] geometries = calculationsFeatures[index].MapGeometries.ToArray();
Assert.AreEqual(1, geometries.Length);
GrassCoverErosionInwardsCalculation calculation = calculationsArray[index];
CollectionAssert.AreEquivalent(new[]
{
calculation.InputParameters.DikeProfile.WorldReferencePoint,
calculation.InputParameters.HydraulicBoundaryLocation.Location
},
geometries[0].PointCollections.First());
}
Assert.AreEqual("Berekeningen", mapData.Name);
}
/// <summary>
/// Validation to check if the defined wave reduction parameters are valid.
/// </summary>
/// <param name="calculationConfiguration">The calculation read from the imported file.</param>
/// <param name="calculation">The calculation to configure.</param>
/// <returns><c>false</c> when there is an invalid wave reduction parameter defined, <c>true</c> otherwise.</returns>
private bool ValidateWaveReduction(GrassCoverErosionInwardsCalculationConfiguration calculationConfiguration,
GrassCoverErosionInwardsCalculation calculation)
{
WaveReductionConfiguration waveReductionConfiguration = calculationConfiguration.WaveReduction;
if (calculation.InputParameters.DikeProfile == null)
{
if (waveReductionConfiguration != null &&
(waveReductionConfiguration.UseBreakWater.HasValue ||
waveReductionConfiguration.UseForeshoreProfile.HasValue ||
waveReductionConfiguration.BreakWaterHeight != null ||
waveReductionConfiguration.BreakWaterType != null))
{
Log.LogCalculationConversionError(Resources.GrassCoverErosionInwardsCalculationConfigurationImporter_ValidateWaveReduction_No_DikeProfile_provided_for_BreakWater_parameters,
calculation.Name);
return(false);
}
}
else if (!calculation.InputParameters.ForeshoreGeometry.Any() &&
waveReductionConfiguration?.UseForeshoreProfile != null &&
waveReductionConfiguration.UseForeshoreProfile.Value)
{
Log.LogCalculationConversionError(string.Format(
Resources.GrassCoverErosionInwardsCalculationConfigurationImporter_ValidateWaveReduction_DikeProfile_0_has_no_geometry_and_cannot_be_used,
calculationConfiguration.DikeProfileId),
calculation.Name);
return(false);
}
return(true);
}
/// <summary>
/// Creates an instance of <see cref="OvertoppingRateCalculationInput"/> for calculation purposes.
/// </summary>
/// <param name="calculation">The calculation containing the input for the overtopping rate calculation.</param>
/// <param name="generalInput">The general grass cover erosion inwards calculation input parameters.</param>
/// <param name="hydraulicBoundaryDatabaseFilePath">The path which points to the hydraulic boundary database file.</param>
/// <param name="usePreprocessor">Indicator whether to use the preprocessor in the calculation.</param>
/// <returns>A new <see cref="OvertoppingRateCalculationInput"/> instance.</returns>
/// <exception cref="ArgumentException">Thrown when the <paramref name="hydraulicBoundaryDatabaseFilePath"/>
/// contains invalid characters.</exception>
/// <exception cref="CriticalFileReadException">Thrown when:
/// <list type="bullet">
/// <item>No settings database file could be found at the location of <paramref name="hydraulicBoundaryDatabaseFilePath"/>
/// with the same name.</item>
/// <item>Unable to open settings database file.</item>
/// <item>Unable to read required data from database file.</item>
/// </list>
/// </exception>
private static OvertoppingRateCalculationInput CreateOvertoppingRateInput(GrassCoverErosionInwardsCalculation calculation,
GeneralGrassCoverErosionInwardsInput generalInput,
string hydraulicBoundaryDatabaseFilePath,
bool usePreprocessor)
{
var overtoppingRateCalculationInput = new OvertoppingRateCalculationInput(calculation.InputParameters.HydraulicBoundaryLocation.Id,
calculation.InputParameters.OvertoppingRateTargetProbability,
calculation.InputParameters.Orientation,
ParseProfilePoints(calculation.InputParameters.DikeGeometry),
HydraRingInputParser.ParseForeshore(calculation.InputParameters),
HydraRingInputParser.ParseBreakWater(calculation.InputParameters),
calculation.InputParameters.DikeHeight,
generalInput.CriticalOvertoppingModelFactor,
generalInput.FbFactor.Mean,
generalInput.FbFactor.StandardDeviation,
generalInput.FbFactor.LowerBoundary,
generalInput.FbFactor.UpperBoundary,
generalInput.FnFactor.Mean,
generalInput.FnFactor.StandardDeviation,
generalInput.FnFactor.LowerBoundary,
generalInput.FnFactor.UpperBoundary,
generalInput.OvertoppingModelFactor,
generalInput.FrunupModelFactor.Mean,
generalInput.FrunupModelFactor.StandardDeviation,
generalInput.FrunupModelFactor.LowerBoundary,
generalInput.FrunupModelFactor.UpperBoundary,
generalInput.FshallowModelFactor.Mean,
generalInput.FshallowModelFactor.StandardDeviation,
generalInput.FshallowModelFactor.LowerBoundary,
generalInput.FshallowModelFactor.UpperBoundary);
HydraRingSettingsDatabaseHelper.AssignSettingsFromDatabase(overtoppingRateCalculationInput, hydraulicBoundaryDatabaseFilePath, usePreprocessor);
return(overtoppingRateCalculationInput);
}
/// <summary>
/// Assigns the orientation.
/// </summary>
/// <param name="calculationConfiguration">The calculation read from the imported file.</param>
/// <param name="calculation">The calculation to configure.</param>
/// <returns><c>false</c> when the orientation is invalid or when there is an orientation but
/// no dike profile defined, <c>true</c> otherwise.</returns>
private bool TrySetOrientation(GrassCoverErosionInwardsCalculationConfiguration calculationConfiguration,
GrassCoverErosionInwardsCalculation calculation)
{
if (calculationConfiguration.Orientation.HasValue)
{
if (calculation.InputParameters.DikeProfile == null)
{
Log.LogCalculationConversionError(Resources.GrassCoverErosionInwardsCalculationConfigurationImporter_ValidateWaveReduction_No_DikeProfile_provided_for_Orientation,
calculation.Name);
return(false);
}
double orientation = calculationConfiguration.Orientation.Value;
try
{
calculation.InputParameters.Orientation = (RoundedDouble)orientation;
}
catch (ArgumentOutOfRangeException e)
{
Log.LogOutOfRangeException(string.Format(Resources.GrassCoverErosionInwardsCalculationConfigurationImporter_ReadOrientation_Orientation_0_invalid, orientation),
calculation.Name,
e);
return(false);
}
}
return(true);
}
public void CreateCalculationActivitiesForFailureMechanism_WithValidCalculations_ReturnsGrassCoverErosionInwardsCalculationActivitiesWithParametersSet()
{
// Setup
var failureMechanism = new GrassCoverErosionInwardsFailureMechanism();
var mocks = new MockRepository();
IAssessmentSection assessmentSection = AssessmentSectionTestHelper.CreateAssessmentSectionStub(failureMechanism,
mocks,
validFilePath);
mocks.ReplayAll();
GrassCoverErosionInwardsCalculation calculation1 = CreateValidCalculation();
GrassCoverErosionInwardsCalculation calculation2 = CreateValidCalculation();
failureMechanism.CalculationsGroup.Children.AddRange(new[]
{
calculation1,
calculation2
});
// Call
IEnumerable <CalculatableActivity> activities = GrassCoverErosionInwardsCalculationActivityFactory.CreateCalculationActivities(
failureMechanism, assessmentSection);
// Assert
CollectionAssert.AllItemsAreInstancesOfType(activities, typeof(GrassCoverErosionInwardsCalculationActivity));
Assert.AreEqual(2, activities.Count());
HydraulicBoundaryDatabase hydraulicBoundaryDatabase = assessmentSection.HydraulicBoundaryDatabase;
AssertGrassCoverErosionInwardsCalculationActivity(activities.First(), calculation1, hydraulicBoundaryDatabase);
AssertGrassCoverErosionInwardsCalculationActivity(activities.ElementAt(1), calculation2, hydraulicBoundaryDatabase);
mocks.VerifyAll();
}
private static void AssertGrassCoverErosionInwardsCalculationActivity(Activity activity,
GrassCoverErosionInwardsCalculation calculation,
HydraulicBoundaryDatabase hydraulicBoundaryDatabase)
{
var mocks = new MockRepository();
var testCalculator = new TestOvertoppingCalculator();
var calculatorFactory = mocks.StrictMock <IHydraRingCalculatorFactory>();
calculatorFactory.Expect(cf => cf.CreateOvertoppingCalculator(Arg <HydraRingCalculationSettings> .Is.NotNull))
.WhenCalled(invocation =>
{
HydraRingCalculationSettingsTestHelper.AssertHydraRingCalculationSettings(
HydraulicBoundaryCalculationSettingsFactory.CreateSettings(hydraulicBoundaryDatabase),
(HydraRingCalculationSettings)invocation.Arguments[0]);
})
.Return(testCalculator);
mocks.ReplayAll();
using (new HydraRingCalculatorFactoryConfig(calculatorFactory))
{
activity.Run();
Assert.AreEqual(calculation.InputParameters.BreakWater.Height, testCalculator.ReceivedInputs.Single().BreakWater.Height);
}
mocks.VerifyAll();
}
public void CreateInstance_WithContext_NewPropertiesWithInputContextAsData()
{
// Setup
var mocks = new MockRepository();
var assessmentSection = mocks.Stub <IAssessmentSection>();
mocks.ReplayAll();
var calculation = new GrassCoverErosionInwardsCalculation();
var failureMechanism = new GrassCoverErosionInwardsFailureMechanism();
var context = new GrassCoverErosionInwardsInputContext(
calculation.InputParameters,
calculation,
failureMechanism,
assessmentSection);
// Call
IObjectProperties objectProperties = info.CreateInstance(context);
// Assert
Assert.IsInstanceOf <GrassCoverErosionInwardsInputContextProperties>(objectProperties);
Assert.AreSame(context, objectProperties.Data);
mocks.VerifyAll();
}
private static IEnumerable <TestCaseData> GetCalculationConfigurationsWithIllustrationPoints()
{
var random = new Random(21);
var calculationWithOverToppingOutputWithIllustrationPoints = new GrassCoverErosionInwardsCalculation
{
Output = new GrassCoverErosionInwardsOutput(new TestOvertoppingOutput(new TestGeneralResultFaultTreeIllustrationPoint()),
null,
null)
};
var calculationWithDikeHeightRateWithIllustrationPoints = new GrassCoverErosionInwardsCalculation
{
Output = new GrassCoverErosionInwardsOutput(new TestOvertoppingOutput(random.NextDouble()),
new TestDikeHeightOutput(new TestGeneralResultFaultTreeIllustrationPoint()),
null)
};
var calculationWithOvertoppingRateWithIllustrationPoints = new GrassCoverErosionInwardsCalculation
{
Output = new GrassCoverErosionInwardsOutput(new TestOvertoppingOutput(random.NextDouble()),
null,
new TestOvertoppingRateOutput(new TestGeneralResultFaultTreeIllustrationPoint()))
};
yield return(new TestCaseData(calculationWithOverToppingOutputWithIllustrationPoints));
yield return(new TestCaseData(calculationWithDikeHeightRateWithIllustrationPoints));
yield return(new TestCaseData(calculationWithOvertoppingRateWithIllustrationPoints));
}
/// <summary>
/// Assigns the overtopping rate calculation parameters.
/// </summary>
/// <param name="calculationConfiguration">The calculation read from the imported file.</param>
/// <param name="calculation">The calculation to configure.</param>
private bool TrySetOvertoppingRateParameters(GrassCoverErosionInwardsCalculationConfiguration calculationConfiguration,
GrassCoverErosionInwardsCalculation calculation)
{
if (calculationConfiguration.ShouldOvertoppingRateBeCalculated.HasValue)
{
calculation.InputParameters.ShouldOvertoppingRateBeCalculated = calculationConfiguration.ShouldOvertoppingRateBeCalculated.Value;
}
double overtoppingRateTargetProbability = calculationConfiguration.OvertoppingRateTargetProbability ?? failureMechanismContribution.NormativeProbability;
try
{
calculation.InputParameters.OvertoppingRateTargetProbability = overtoppingRateTargetProbability;
}
catch (ArgumentOutOfRangeException e)
{
Log.LogOutOfRangeException(string.Format(Resources.GrassCoverErosionInwardsCalculationConfigurationImporter_ReadTargetProbability_TargetProbability_0_invalid, overtoppingRateTargetProbability),
calculation.Name,
e);
return(false);
}
if (calculationConfiguration.ShouldOvertoppingRateIllustrationPointsBeCalculated.HasValue)
{
calculation.InputParameters.ShouldOvertoppingRateIllustrationPointsBeCalculated = calculationConfiguration.ShouldOvertoppingRateIllustrationPointsBeCalculated.Value;
}
return(true);
}
/// <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(GrassCoverErosionInwardsCalculation original, GrassCoverErosionInwardsCalculation clone)
{
Assert.AreEqual(original.Name, clone.Name);
CoreCloneAssert.AreObjectClones(original.Comments, clone.Comments, CommonCloneAssert.AreClones);
CoreCloneAssert.AreObjectClones(original.InputParameters, clone.InputParameters, AreClones);
CoreCloneAssert.AreObjectClones(original.Output, clone.Output, AreClones);
}
public void CreateCalculationFeatures_GivenCalculations_ReturnsCalculationFeaturesCollection()
{
// Setup
var calculationA = new GrassCoverErosionInwardsCalculation();
var calculationB = new GrassCoverErosionInwardsCalculation();
calculationA.InputParameters.DikeProfile = DikeProfileTestFactory.CreateDikeProfile(new Point2D(1.0, 3.0));
calculationB.InputParameters.DikeProfile = DikeProfileTestFactory.CreateDikeProfile(new Point2D(1.0, 4.0));
calculationA.InputParameters.HydraulicBoundaryLocation = new HydraulicBoundaryLocation(1, string.Empty, 5.0, 4.0);
calculationB.InputParameters.HydraulicBoundaryLocation = new HydraulicBoundaryLocation(1, string.Empty, 2.2, 3.8);
// Call
IEnumerable <MapFeature> features = GrassCoverErosionInwardsMapDataFeaturesFactory.CreateCalculationFeatures(new[]
{
calculationA,
calculationB
});
// Assert
Assert.AreEqual(2, features.Count());
Assert.AreEqual(1, features.ElementAt(0).MapGeometries.Count());
Assert.AreEqual(1, features.ElementAt(1).MapGeometries.Count());
AssertEqualPointCollections(new[]
{
new Point2D(1.0, 3.0),
new Point2D(5.0, 4.0)
}, features.ElementAt(0).MapGeometries.ElementAt(0));
AssertEqualPointCollections(new[]
{
new Point2D(1.0, 4.0),
new Point2D(2.2, 3.8)
}, features.ElementAt(1).MapGeometries.ElementAt(0));
}
/// <summary>
/// Assigns the property defining whether the illustration points need to be read.
/// </summary>
/// <param name="calculationConfiguration">The calculation read from the imported file.</param>
/// <param name="calculation">The calculation to configure.</param>
private static void SetShouldIllustrationPointsBeCalculated(GrassCoverErosionInwardsCalculationConfiguration calculationConfiguration,
GrassCoverErosionInwardsCalculation calculation)
{
if (calculationConfiguration.ShouldOvertoppingOutputIllustrationPointsBeCalculated.HasValue)
{
calculation.InputParameters.ShouldOvertoppingOutputIllustrationPointsBeCalculated = calculationConfiguration.ShouldOvertoppingOutputIllustrationPointsBeCalculated.Value;
}
}
/// <summary>
/// Determines whether a <see cref="GrassCoverErosionInwardsCalculation"/> has illustration point results.
/// </summary>
/// <param name="calculation">The calculation to check.</param>
/// <returns><c>true</c> when <paramref name="calculation"/> has illustration point results, <c>false</c> otherwise.</returns>
/// <exception cref="ArgumentNullException">Thrown when <paramref name="calculation"/> is <c>null</c>.</exception>
public static bool HasIllustrationPoints(GrassCoverErosionInwardsCalculation calculation)
{
if (calculation == null)
{
throw new ArgumentNullException(nameof(calculation));
}
return(calculation.HasOutput && HasIllustrationPoints(calculation.Output));
}
public void ShouldCalculate_Always_ReturnsExpectedValue(GrassCoverErosionInwardsCalculation calculation,
bool expectedShouldCalculate)
{
// Call
bool shouldCalculate = calculation.ShouldCalculate;
// Assert
Assert.AreEqual(expectedShouldCalculate, shouldCalculate);
}
private static void ReadOutput(GrassCoverErosionInwardsCalculation calculation, GrassCoverErosionInwardsCalculationEntity entity)
{
GrassCoverErosionInwardsOutputEntity output = entity.GrassCoverErosionInwardsOutputEntities.SingleOrDefault();
if (output != null)
{
calculation.Output = output.Read();
}
}
private bool TrySetHydraulicBoundaryLocation(string locationName, GrassCoverErosionInwardsCalculation calculation)
{
if (TryReadHydraulicBoundaryLocation(locationName, calculation.Name, availableHydraulicBoundaryLocations, out HydraulicBoundaryLocation location))
{
calculation.InputParameters.HydraulicBoundaryLocation = location;
return(true);
}
return(false);
}
public void HasIllustrationPoints_WithVariousCalculationConfigurations_ReturnsExpectedResult(
GrassCoverErosionInwardsCalculation calculation,
bool expectedHasIllustrationPoints)
{
// Call
bool hasIllustrationPoints = GrassCoverErosionInwardsIllustrationPointsHelper.HasIllustrationPoints(calculation);
// Assert
Assert.AreEqual(expectedHasIllustrationPoints, hasIllustrationPoints);
}
public void ForeColor_HasNoOutput_ReturnGrayText()
{
// Setup
var calculation = new GrassCoverErosionInwardsCalculation();
// Call
Color color = info.ForeColor(new OvertoppingOutputContext(calculation));
// Assert
Assert.AreEqual(Color.FromKnownColor(KnownColor.GrayText), color);
}
public void Clone_NotAllPropertiesSet_ReturnNewInstanceWithCopiedValues()
{
// Setup
GrassCoverErosionInwardsCalculation original = CreateRandomCalculationWithoutOutput();
// Call
object clone = original.Clone();
// Assert
CoreCloneAssert.AreObjectClones(original, clone, GrassCoverErosionInwardsCloneAssert.AreClones);
}
public void Property_Comments_ReturnsExpectedValues(string comments)
{
// Setup
var calculation = new GrassCoverErosionInwardsCalculation();
// Call
calculation.Comments.Body = comments;
// Assert
Assert.AreEqual(comments, calculation.Comments.Body);
}
public void Properties_Name_ReturnsExpectedValues(string name)
{
// Setup
var calculation = new GrassCoverErosionInwardsCalculation();
// Call
calculation.Name = name;
// Assert
Assert.AreEqual(name, calculation.Name);
}
public void ClearIllustrationPoints_CalculationWithoutOutput_DoesNotThrow()
{
// Setup
var calculation = new GrassCoverErosionInwardsCalculation();
// Call
void Call() => calculation.ClearIllustrationPoints();
// Assert
Assert.DoesNotThrow(Call);
}
