public void Constructor_ExpectedValues()
{
// Setup
var mocksRepository = new MockRepository();
var assessmentSection = mocksRepository.Stub <IAssessmentSection>();
mocksRepository.ReplayAll();
var calculation = new GrassCoverErosionInwardsCalculationScenario();
var failureMechanism = new GrassCoverErosionInwardsFailureMechanism();
var parent = new CalculationGroup();
// Call
var context = new GrassCoverErosionInwardsCalculationScenarioContext(calculation, parent, failureMechanism, assessmentSection);
// Assert
Assert.IsInstanceOf <GrassCoverErosionInwardsContext <GrassCoverErosionInwardsCalculationScenario> >(context);
Assert.IsInstanceOf <ICalculationContext <GrassCoverErosionInwardsCalculationScenario, GrassCoverErosionInwardsFailureMechanism> >(context);
Assert.AreSame(calculation, context.WrappedData);
Assert.AreSame(parent, context.Parent);
Assert.AreSame(failureMechanism, context.FailureMechanism);
Assert.AreSame(assessmentSection, context.AssessmentSection);
mocksRepository.VerifyAll();
}
public DerivedGrassCoverErosionInwardsCalculationScenarioContext(GrassCoverErosionInwardsCalculationScenario calculation,
CalculationGroup parent,
GrassCoverErosionInwardsFailureMechanism failureMechanism,
IAssessmentSection assessmentSection)
: base(calculation, parent, failureMechanism, assessmentSection)
{
}
public void GetInitialFailureMechanismResultProbability_MultipleScenarios_ReturnsValueBasedOnRelevantScenarios()
{
// Setup
FailureMechanismSection section = FailureMechanismSectionTestFactory.CreateFailureMechanismSection();
var failureMechanismSectionResult = new AdoptableWithProfileProbabilityFailureMechanismSectionResult(section);
GrassCoverErosionInwardsCalculationScenario calculationScenario1 = GrassCoverErosionInwardsCalculationScenarioTestFactory.CreateGrassCoverErosionInwardsCalculationScenario(section);
GrassCoverErosionInwardsCalculationScenario calculationScenario2 = GrassCoverErosionInwardsCalculationScenarioTestFactory.CreateGrassCoverErosionInwardsCalculationScenario(section);
GrassCoverErosionInwardsCalculationScenario calculationScenario3 = GrassCoverErosionInwardsCalculationScenarioTestFactory.CreateGrassCoverErosionInwardsCalculationScenario(section);
calculationScenario1.IsRelevant = true;
calculationScenario1.Contribution = (RoundedDouble)0.2111;
calculationScenario1.Output = new GrassCoverErosionInwardsOutput(new TestOvertoppingOutput(1.1), null, null);
calculationScenario2.IsRelevant = true;
calculationScenario2.Contribution = (RoundedDouble)0.7889;
calculationScenario1.Output = new GrassCoverErosionInwardsOutput(new TestOvertoppingOutput(2.2), null, null);
calculationScenario3.IsRelevant = false;
GrassCoverErosionInwardsCalculationScenario[] calculationScenarios =
{
calculationScenario1,
calculationScenario2,
calculationScenario3
};
// Call
double initialFailureMechanismResultProbability = failureMechanismSectionResult.GetInitialFailureMechanismResultProbability(calculationScenarios);
// Assert
Assert.AreEqual(0.3973850177700996, initialFailureMechanismResultProbability);
}
public void Create_StringPropertiesDoNotShareReference()
{
// Setup
const string name = "A";
const string comment = "B";
var calculation = new GrassCoverErosionInwardsCalculationScenario
{
Name = name,
Comments =
{
Body = comment
}
};
var registry = new PersistenceRegistry();
// Call
GrassCoverErosionInwardsCalculationEntity entity = calculation.Create(registry, 0);
// Assert
Assert.AreNotSame(name, entity.Name,
"To create stable binary representations/fingerprints, it's really important that strings are not shared.");
Assert.AreEqual(name, entity.Name);
Assert.AreNotSame(comment, entity.Comments,
"To create stable binary representations/fingerprints, it's really important that strings are not shared.");
Assert.AreEqual(comment, entity.Comments);
}
public void Create_NaNParameters_EntityWithNullFields()
{
// Setup
var calculation = new GrassCoverErosionInwardsCalculationScenario
{
InputParameters =
{
Orientation = RoundedDouble.NaN,
CriticalFlowRate =
{
Mean = RoundedDouble.NaN,
StandardDeviation = RoundedDouble.NaN
},
DikeHeight = RoundedDouble.NaN,
BreakWater =
{
Height = RoundedDouble.NaN
}
}
};
var registry = new PersistenceRegistry();
// Call
GrassCoverErosionInwardsCalculationEntity entity = calculation.Create(registry, 0);
// Assert
Assert.IsNull(entity.Orientation);
Assert.IsNull(entity.CriticalFlowRateMean);
Assert.IsNull(entity.CriticalFlowRateStandardDeviation);
Assert.IsNull(entity.DikeHeight);
Assert.IsNull(entity.BreakWaterHeight);
}
public void Read_ValidEntityWithUnreadDikeProfileEntity_ReturnCalculationWithNewDikeProfile()
{
// Setup
var dikeProfileEntity = new DikeProfileEntity
{
Id = "a",
DikeGeometryXml = new RoughnessPointCollectionXmlSerializer().ToXml(new RoughnessPoint[0]),
ForeshoreXml = new Point2DCollectionXmlSerializer().ToXml(new Point2D[0])
};
var entity = new GrassCoverErosionInwardsCalculationEntity
{
DikeProfileEntity = dikeProfileEntity,
ScenarioContribution = 0,
DikeHeightTargetProbability = 0.01,
OvertoppingRateTargetProbability = 0.02
};
var collector = new ReadConversionCollector();
// Call
GrassCoverErosionInwardsCalculationScenario calculation = entity.Read(collector);
// Assert
Assert.IsNotNull(calculation.InputParameters.DikeProfile);
Assert.IsTrue(collector.Contains(dikeProfileEntity));
}
public void CloseForData_ViewCorrespondingToRemovedCalculationContext_ReturnsTrue()
{
// Setup
var assessmentSection = mocks.Stub <IAssessmentSection>();
mocks.ReplayAll();
var calculation = new GrassCoverErosionInwardsCalculationScenario();
var calculationContext = new GrassCoverErosionInwardsCalculationScenarioContext(calculation,
new CalculationGroup(),
new GrassCoverErosionInwardsFailureMechanism(),
assessmentSection);
using (var view = new GrassCoverErosionInwardsInputView
{
Data = calculation
})
{
// Call
bool closeForData = info.CloseForData(view, calculationContext);
// Assert
Assert.IsTrue(closeForData);
mocks.VerifyAll();
}
}
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 IsDikeProfileIntersectionWithReferenceLineInSection_EmptySegmentCollection_ThrowsInvalidOperationException()
{
// Setup
DikeProfile dikeProfile = DikeProfileTestFactory.CreateDikeProfile(new Point2D(0.0, 0.0));
var referenceLine = new ReferenceLine();
referenceLine.SetGeometry(new[]
{
new Point2D(0.0, 0.0),
new Point2D(10.0, 0.0)
});
var calculation = new GrassCoverErosionInwardsCalculationScenario
{
InputParameters =
{
DikeProfile = dikeProfile
}
};
// Call
void Call() => calculation.IsDikeProfileIntersectionWithReferenceLineInSection(Enumerable.Empty <Segment2D>());
// Assert
Assert.Throws <InvalidOperationException>(Call);
}
/// <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(GrassCoverErosionInwardsCalculationScenario original,
GrassCoverErosionInwardsCalculationScenario clone)
{
Assert.AreEqual(original.Contribution, clone.Contribution);
Assert.AreEqual(original.IsRelevant, clone.IsRelevant);
AreClones((GrassCoverErosionInwardsCalculation)original, clone);
}
/// <summary>
/// Configures calculations and adds them to the calculation group.
/// </summary>
/// <param name="calculationGroup">The calculation group.</param>
/// <param name="dikeProfiles">The collection of dike profiles.</param>
/// <param name="failureMechanismContribution">The <see cref="FailureMechanismContribution"/>
/// used to get the default target probability.</param>
/// <exception cref="ArgumentNullException">Thrown when any parameter is <c>null</c>.</exception>
public static void GenerateCalculations(CalculationGroup calculationGroup, IEnumerable <DikeProfile> dikeProfiles,
FailureMechanismContribution failureMechanismContribution)
{
if (calculationGroup == null)
{
throw new ArgumentNullException(nameof(calculationGroup));
}
if (dikeProfiles == null)
{
throw new ArgumentNullException(nameof(dikeProfiles));
}
if (failureMechanismContribution == null)
{
throw new ArgumentNullException(nameof(failureMechanismContribution));
}
foreach (DikeProfile profile in dikeProfiles)
{
var calculation = new GrassCoverErosionInwardsCalculationScenario
{
Name = NamingHelper.GetUniqueName(calculationGroup.Children, profile.Name, c => c.Name),
InputParameters =
{
DikeProfile = profile,
DikeHeightTargetProbability = failureMechanismContribution.NormativeProbability,
OvertoppingRateTargetProbability = failureMechanismContribution.NormativeProbability
}
};
calculationGroup.Children.Add(calculation);
}
}
public void GetInitialFailureMechanismResultProbability_ScenarioWithNaNResults_ReturnsNaN()
{
// Setup
FailureMechanismSection section = FailureMechanismSectionTestFactory.CreateFailureMechanismSection();
var failureMechanismSectionResult = new AdoptableWithProfileProbabilityFailureMechanismSectionResult(section);
const double contribution1 = 0.2;
const double contribution2 = 0.8;
GrassCoverErosionInwardsCalculationScenario calculationScenario1 = GrassCoverErosionInwardsCalculationScenarioTestFactory.CreateGrassCoverErosionInwardsCalculationScenario(section);
GrassCoverErosionInwardsCalculationScenario calculationScenario2 = GrassCoverErosionInwardsCalculationScenarioTestFactory.CreateNotCalculatedGrassCoverErosionInwardsCalculationScenario(section);
calculationScenario1.IsRelevant = true;
calculationScenario1.Contribution = (RoundedDouble)contribution1;
calculationScenario2.IsRelevant = true;
calculationScenario2.Contribution = (RoundedDouble)contribution2;
calculationScenario2.Output = new GrassCoverErosionInwardsOutput(new TestOvertoppingOutput(double.NaN), null, null);
GrassCoverErosionInwardsCalculationScenario[] calculationScenarios =
{
calculationScenario1,
calculationScenario2
};
// Call
double initialFailureMechanismResultProbability = failureMechanismSectionResult.GetInitialFailureMechanismResultProbability(calculationScenarios);
// Assert
Assert.IsNaN(initialFailureMechanismResultProbability);
}
public void GivenScenarioRow_WhenOutputChangedAndUpdate_ThenDerivedOutputUpdated()
{
// Given
var calculation = new GrassCoverErosionInwardsCalculationScenario
{
Output = new TestGrassCoverErosionInwardsOutput()
};
var row = new GrassCoverErosionInwardsScenarioRow(calculation);
// Precondition
ProbabilityAssessmentOutput expectedDerivedOutput = ProbabilityAssessmentOutputFactory.Create(calculation.Output.OvertoppingOutput.Reliability);
Assert.AreEqual(expectedDerivedOutput.Probability, row.FailureProbability);
var random = new Random(11);
// When
calculation.Output = new GrassCoverErosionInwardsOutput(new TestOvertoppingOutput(random.NextDouble()), null, null);
row.Update();
// Then
ProbabilityAssessmentOutput newExpectedDerivedOutput = ProbabilityAssessmentOutputFactory.Create(calculation.Output.OvertoppingOutput.Reliability);
Assert.AreEqual(newExpectedDerivedOutput.Probability, row.FailureProbability);
}
public void Constructor_DikeProfileWithForeshoreGeometry_CorrectColumnStates(bool useBreakWater)
{
// Setup
var calculationScenario = new GrassCoverErosionInwardsCalculationScenario
{
InputParameters =
{
DikeProfile = DikeProfileTestFactory.CreateDikeProfile(new[]
{
new Point2D(0.0, 0.0)
}),
UseBreakWater = useBreakWater
}
};
// Call
var row = new GrassCoverErosionInwardsCalculationRow(calculationScenario, new ObservablePropertyChangeHandler(
calculationScenario, new GrassCoverErosionInwardsInput()));
// Assert
IDictionary <int, DataGridViewColumnStateDefinition> columnStateDefinitions = row.ColumnStateDefinitions;
DataGridViewControlColumnStateDefinitionTestHelper.AssertColumnState(columnStateDefinitions[useBreakWaterColumnIndex], true);
DataGridViewControlColumnStateDefinitionTestHelper.AssertColumnState(columnStateDefinitions[breakWaterTypeColumnIndex], useBreakWater);
DataGridViewControlColumnStateDefinitionTestHelper.AssertColumnState(columnStateDefinitions[breakWaterHeightColumnIndex], useBreakWater);
DataGridViewControlColumnStateDefinitionTestHelper.AssertColumnState(columnStateDefinitions[useForeshoreColumnIndex], true);
}
public void DikeProfile_OnChangeToNull_CorrectColumnStates()
{
// Setup
var calculationScenario = new GrassCoverErosionInwardsCalculationScenario
{
InputParameters =
{
DikeProfile = DikeProfileTestFactory.CreateDikeProfile()
}
};
// Call
var row = new GrassCoverErosionInwardsCalculationRow(calculationScenario, new ObservablePropertyChangeHandler(
calculationScenario, new GrassCoverErosionInwardsInput()))
{
DikeProfile = new DataGridViewComboBoxItemWrapper <DikeProfile>(null)
};
// Assert
IDictionary <int, DataGridViewColumnStateDefinition> columnStateDefinitions = row.ColumnStateDefinitions;
DataGridViewControlColumnStateDefinitionTestHelper.AssertColumnState(columnStateDefinitions[useBreakWaterColumnIndex], false);
DataGridViewControlColumnStateDefinitionTestHelper.AssertColumnState(columnStateDefinitions[breakWaterTypeColumnIndex], false);
DataGridViewControlColumnStateDefinitionTestHelper.AssertColumnState(columnStateDefinitions[breakWaterHeightColumnIndex], false);
DataGridViewControlColumnStateDefinitionTestHelper.AssertColumnState(columnStateDefinitions[useForeshoreColumnIndex], false);
}
public void Constructor_ExpectedValues()
{
// Setup
var mocks = new MockRepository();
var handler = mocks.Stub <IObservablePropertyChangeHandler>();
mocks.ReplayAll();
var calculationScenario = new GrassCoverErosionInwardsCalculationScenario();
// Call
var row = new GrassCoverErosionInwardsCalculationRow(calculationScenario, handler);
// Asserts
Assert.IsInstanceOf <CalculationRow <GrassCoverErosionInwardsCalculationScenario> >(row);
Assert.IsInstanceOf <IHasColumnStateDefinitions>(row);
Assert.AreSame(calculationScenario, row.Calculation);
IDictionary <int, DataGridViewColumnStateDefinition> columnStateDefinitions = row.ColumnStateDefinitions;
Assert.AreEqual(4, columnStateDefinitions.Count);
DataGridViewControlColumnStateDefinitionTestHelper.AssertColumnStateDefinition(columnStateDefinitions, useBreakWaterColumnIndex);
DataGridViewControlColumnStateDefinitionTestHelper.AssertColumnStateDefinition(columnStateDefinitions, breakWaterTypeColumnIndex);
DataGridViewControlColumnStateDefinitionTestHelper.AssertColumnStateDefinition(columnStateDefinitions, breakWaterHeightColumnIndex);
DataGridViewControlColumnStateDefinitionTestHelper.AssertColumnStateDefinition(columnStateDefinitions, useForeshoreColumnIndex);
mocks.VerifyAll();
}
private static void AssertPropertyChangeWithOrWithoutCalculationOutput(
Action <GrassCoverErosionInwardsCalculationRow> setProperty,
Action <GrassCoverErosionInwardsCalculationScenario> assertions,
bool hasOutput,
bool expectUpdates)
{
// Setup
var mockRepository = new MockRepository();
var inputObserver = mockRepository.StrictMock <IObserver>();
if (expectUpdates)
{
inputObserver.Expect(o => o.UpdateObserver());
}
var calculationObserver = mockRepository.StrictMock <IObserver>();
if (expectUpdates && hasOutput)
{
calculationObserver.Expect(o => o.UpdateObserver());
}
var handler = mockRepository.Stub <IObservablePropertyChangeHandler>();
mockRepository.ReplayAll();
GrassCoverErosionInwardsOutput assignedOutput = null;
GrassCoverErosionInwardsCalculationScenario calculation = GrassCoverErosionInwardsCalculationScenarioTestFactory.CreateNotCalculatedGrassCoverErosionInwardsCalculationScenario(new FailureMechanismSection("Section 1", new List <Point2D>
{
new Point2D(0.0, 0.0)
}));
calculation.InputParameters.HydraulicBoundaryLocation = new TestHydraulicBoundaryLocation();
if (hasOutput)
{
assignedOutput = new GrassCoverErosionInwardsOutput(new TestOvertoppingOutput(0.2), null, null);
}
calculation.Output = assignedOutput;
var row = new GrassCoverErosionInwardsCalculationRow(calculation, handler);
calculation.Attach(calculationObserver);
calculation.InputParameters.Attach(inputObserver);
// Call
setProperty(row);
// Assert
assertions(calculation);
if (expectUpdates)
{
Assert.IsNull(calculation.Output);
}
else
{
Assert.AreSame(assignedOutput, calculation.Output);
}
}
private static void SetPropertyAndVerifyNotificationsAndOutputForCalculation(
Action <GrassCoverErosionInwardsCalculationRow> setProperty,
GrassCoverErosionInwardsCalculationScenario calculation)
{
// Setup
var mocks = new MockRepository();
var observable = mocks.StrictMock <IObservable>();
observable.Expect(o => o.NotifyObservers());
mocks.ReplayAll();
var handler = new SetPropertyValueAfterConfirmationParameterTester(
new[]
{
observable
});
var row = new GrassCoverErosionInwardsCalculationRow(calculation, handler);
// Call
setProperty(row);
// Assert
Assert.IsTrue(handler.Called);
mocks.VerifyAll();
}
public void Import_ValidConfigurationOnlyCriticalFlowRateNoParametersSet_DataAddedToModel()
{
// Setup
string filePath = Path.Combine(importerPath, "validConfigurationCriticalFlowRateNoParameters.xml");
var calculationGroup = new CalculationGroup();
const double norm = 0.01;
var importer = new GrassCoverErosionInwardsCalculationConfigurationImporter(
filePath,
calculationGroup,
new FailureMechanismContribution(norm, 0.001),
Enumerable.Empty <HydraulicBoundaryLocation>(),
Enumerable.Empty <DikeProfile>());
// Call
bool successful = importer.Import();
// Assert
Assert.IsTrue(successful);
var expectedCalculation = new GrassCoverErosionInwardsCalculationScenario
{
Name = "Berekening 1",
InputParameters =
{
DikeHeightTargetProbability = norm,
OvertoppingRateTargetProbability = norm
}
};
Assert.AreEqual(1, calculationGroup.Children.Count);
AssertCalculationScenario(expectedCalculation, (GrassCoverErosionInwardsCalculationScenario)calculationGroup.Children[0]);
}
public void IsDikeProfileIntersectionWithReferenceLineInSection_DikeProfileDoesNotIntersectReferenceLine_ReturnsFalse()
{
// Setup
DikeProfile dikeProfile = DikeProfileTestFactory.CreateDikeProfile(new Point2D(0.0, 0.0));
var referenceLine = new ReferenceLine();
referenceLine.SetGeometry(new[]
{
new Point2D(10.0, 0.0),
new Point2D(20.0, 0.0)
});
var calculation = new GrassCoverErosionInwardsCalculationScenario
{
InputParameters =
{
DikeProfile = dikeProfile
}
};
IEnumerable <Segment2D> lineSegments = Math2D.ConvertPointsToLineSegments(referenceLine.Points);
// Call
bool intersects = calculation.IsDikeProfileIntersectionWithReferenceLineInSection(lineSegments);
// Assert
Assert.IsFalse(intersects);
}
/// <summary>
/// Creates a calculated scenario for which the surface line on the input intersects with <paramref name="section"/>.
/// </summary>
/// <param name="section">The section for which an intersection will be created.</param>
/// <returns>A new <see cref="GrassCoverErosionInwardsCalculationScenario"/>.</returns>
/// <exception cref="ArgumentNullException">Thrown when <paramref name="section"/> is <c>null</c>.</exception>
public static GrassCoverErosionInwardsCalculationScenario CreateGrassCoverErosionInwardsCalculationScenario(FailureMechanismSection section)
{
GrassCoverErosionInwardsCalculationScenario scenario = CreateNotCalculatedGrassCoverErosionInwardsCalculationScenario(section);
scenario.Output = new TestGrassCoverErosionInwardsOutput();
return(scenario);
}
public void DikeHeight_AlwaysOnChange_NotifyObserverAndCalculationPropertyChanged()
{
// Setup
var newValue = new RoundedDouble(2, 2.08);
var calculation = new GrassCoverErosionInwardsCalculationScenario();
// Call & Assert
SetPropertyAndVerifyNotificationsAndOutputForCalculation(row => row.DikeHeight = newValue, calculation);
}
public void StandardDeviationCriticalFlowRate_AlwaysOnChange_NotifyObserverAndCalculationPropertyChanged()
{
// Setup
var newValue = new RoundedDouble(4, 0.0004);
var calculation = new GrassCoverErosionInwardsCalculationScenario();
// Call & Assert
SetPropertyAndVerifyNotificationsAndOutputForCalculation(row => row.StandardDeviationCriticalFlowRate = newValue, calculation);
}
public void UseForeShoreGeometry_AlwaysOnChange_NotifyObserverAndCalculationPropertyChanged()
{
// Setup
const bool newValue = true;
var calculation = new GrassCoverErosionInwardsCalculationScenario();
// Call & Assert
SetPropertyAndVerifyNotificationsAndOutputForCalculation(row => row.UseForeshoreGeometry = newValue, calculation);
}
public void DikeProfile_AlwaysOnChange_NotifyObserverAndCalculationPropertyChanged()
{
// Setup
DikeProfile newProfile = DikeProfileTestFactory.CreateDikeProfile(new Point2D(0.0, 0.0));
var newValue = new DataGridViewComboBoxItemWrapper <DikeProfile>(newProfile);
var calculation = new GrassCoverErosionInwardsCalculationScenario();
// Call & Assert
SetPropertyAndVerifyNotificationsAndOutputForCalculation(row => row.DikeProfile = newValue, calculation);
}
public void Constructor_WithCalculationWithoutOutput_PropertiesFromCalculation()
{
// Setup
var calculation = new GrassCoverErosionInwardsCalculationScenario();
// Call
var row = new GrassCoverErosionInwardsScenarioRow(calculation);
// Assert
Assert.IsNaN(row.FailureProbability);
}
public void IsDikeProfileIntersectionWithReferenceLineInSection_CalculationWithoutDikeProfile_ReturnsFalse()
{
// Setup
var calculation = new GrassCoverErosionInwardsCalculationScenario();
// Call
bool intersects = calculation.IsDikeProfileIntersectionWithReferenceLineInSection(Enumerable.Empty <Segment2D>());
// Assert
Assert.IsFalse(intersects);
}
public void Clone_NotAllPropertiesSet_ReturnsCopiedInstanceWithPropertiesSet()
{
// Setup
GrassCoverErosionInwardsCalculationScenario original = CreateRandomCalculationScenarioWithoutOutput();
// Call
object clone = original.Clone();
// Assert
CoreCloneAssert.AreObjectClones(original, clone, GrassCoverErosionInwardsCloneAssert.AreClones);
}
public void SelectableHydraulicBoundaryLocation_AlwaysOnChange_NotifyObserverAndCalculationPropertyChanged()
{
// Setup
var newLocation = new TestHydraulicBoundaryLocation();
var selectableHydraulicBoundaryLocation = new SelectableHydraulicBoundaryLocation(newLocation, new Point2D(0, 0));
var newValue = new DataGridViewComboBoxItemWrapper <SelectableHydraulicBoundaryLocation>(selectableHydraulicBoundaryLocation);
var calculation = new GrassCoverErosionInwardsCalculationScenario();
// Call & Assert
SetPropertyAndVerifyNotificationsAndOutputForCalculation(row => row.SelectableHydraulicBoundaryLocation = newValue, calculation);
}
public void Constructor_ExpectedValues()
{
// Setup
var calculation = new GrassCoverErosionInwardsCalculationScenario();
// Call
var row = new GrassCoverErosionInwardsScenarioRow(calculation);
// Assert
Assert.IsInstanceOf <ScenarioRow <GrassCoverErosionInwardsCalculationScenario> >(row);
Assert.AreSame(calculation, row.CalculationScenario);
}