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);
}
public void Read_ValidEntityWithGeneralResultEntity_ReturnsGrassCoverErosionInwardsOutputWithGeneralResult()
{
// Setup
var generalResultEntity = new GeneralResultFaultTreeIllustrationPointEntity
{
GoverningWindDirectionAngle = 10,
GoverningWindDirectionName = "SSE"
};
var entity = new GrassCoverErosionInwardsOutputEntity
{
WaveHeight = null,
IsOvertoppingDominant = Convert.ToByte(true),
Reliability = null,
GeneralResultFaultTreeIllustrationPointEntity = generalResultEntity
};
// Call
GrassCoverErosionInwardsOutput output = entity.Read();
// Assert
OvertoppingOutput overtoppingOutput = output.OvertoppingOutput;
GeneralResultEntityTestHelper.AssertGeneralResultPropertyValues(overtoppingOutput.GeneralResult,
generalResultEntity);
}
public void Create_NaNValues_ReturnGrassCoverErosionInwardsOutputEntity()
{
// Setup
var overtoppingOutput = new OvertoppingOutput(double.NaN, true, double.NaN, null);
var dikeHeightOutput = new TestDikeHeightOutput(double.NaN, CalculationConvergence.CalculatedConverged);
var overtoppingRateOutput = new TestOvertoppingRateOutput(double.NaN, CalculationConvergence.CalculatedConverged);
var output = new GrassCoverErosionInwardsOutput(overtoppingOutput, dikeHeightOutput, overtoppingRateOutput);
// Call
GrassCoverErosionInwardsOutputEntity entity = output.Create();
// Assert
Assert.IsNull(entity.WaveHeight);
Assert.AreEqual(Convert.ToByte(overtoppingOutput.IsOvertoppingDominant), entity.IsOvertoppingDominant);
Assert.IsNull(entity.Reliability);
Assert.IsNull(entity.GeneralResultFaultTreeIllustrationPointEntity);
GrassCoverErosionInwardsDikeHeightOutputEntity dikeHeightEntity = entity.GrassCoverErosionInwardsDikeHeightOutputEntities.Single();
Assert.IsNull(dikeHeightEntity.DikeHeight);
Assert.IsNull(dikeHeightEntity.TargetProbability);
Assert.IsNull(dikeHeightEntity.TargetReliability);
Assert.IsNull(dikeHeightEntity.CalculatedProbability);
Assert.IsNull(dikeHeightEntity.CalculatedReliability);
Assert.AreEqual((byte)dikeHeightOutput.CalculationConvergence, dikeHeightEntity.CalculationConvergence);
GrassCoverErosionInwardsOvertoppingRateOutputEntity overtoppingRateEntity = entity.GrassCoverErosionInwardsOvertoppingRateOutputEntities.Single();
Assert.IsNull(overtoppingRateEntity.OvertoppingRate);
Assert.IsNull(overtoppingRateEntity.TargetProbability);
Assert.IsNull(overtoppingRateEntity.TargetReliability);
Assert.IsNull(overtoppingRateEntity.CalculatedProbability);
Assert.IsNull(overtoppingRateEntity.CalculatedReliability);
Assert.AreEqual((byte)overtoppingRateOutput.CalculationConvergence, overtoppingRateEntity.CalculationConvergence);
}
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);
}
}
public void Clone_AllPropertiesSet_ReturnNewInstanceWithCopiedValues()
{
// Setup
GrassCoverErosionInwardsOutput original = GrassCoverErosionInwardsTestDataGenerator.GetRandomGrassCoverErosionInwardsOutput();
// Call
object clone = original.Clone();
// Assert
CoreCloneAssert.AreObjectClones(original, clone, GrassCoverErosionInwardsCloneAssert.AreClones);
}
public void Clone_NotAllPropertiesSet_ReturnNewInstanceWithCopiedValues()
{
// Setup
var original = new GrassCoverErosionInwardsOutput(GrassCoverErosionInwardsTestDataGenerator.GetRandomOvertoppingOutput(new TestGeneralResultFaultTreeIllustrationPoint()),
null,
null);
// Call
object clone = original.Clone();
// Assert
CoreCloneAssert.AreObjectClones(original, clone, GrassCoverErosionInwardsCloneAssert.AreClones);
}
public void Create_OvertoppingRateOutputIsNull_NoOvertoppingRateOutputEntityCreated()
{
// Setup
var overtoppingOutput = new TestOvertoppingOutput(1);
var dikeHeightOutput = new TestDikeHeightOutput(double.NaN, CalculationConvergence.CalculatedConverged);
var output = new GrassCoverErosionInwardsOutput(overtoppingOutput, dikeHeightOutput, null);
// Call
GrassCoverErosionInwardsOutputEntity entity = output.Create();
// Assert
Assert.IsFalse(entity.GrassCoverErosionInwardsOvertoppingRateOutputEntities.Any());
}
public void ClearIllustrationPoints_NotAllPropertiesSet_IllustrationPointsCleared()
{
// Setup
var overtoppingOutput = new TestOvertoppingOutput(new TestGeneralResultFaultTreeIllustrationPoint());
var output = new GrassCoverErosionInwardsOutput(overtoppingOutput, null, null);
// Call
output.ClearIllustrationPoints();
// Assert
Assert.AreSame(overtoppingOutput, output.OvertoppingOutput);
Assert.IsNull(overtoppingOutput.GeneralResult);
}
/// <summary>
/// Creates a <see cref="GrassCoverErosionInwardsOutputEntity"/> based on
/// the information of the <see cref="GrassCoverErosionInwardsOutput"/>.
/// </summary>
/// <param name="output">The grass cover erosion inwards calculation output to create
/// a database entity for.</param>
/// <returns>A new <see cref="GrassCoverErosionInwardsOutputEntity"/>.</returns>
internal static GrassCoverErosionInwardsOutputEntity Create(this GrassCoverErosionInwardsOutput output)
{
OvertoppingOutput overtoppingOutput = output.OvertoppingOutput;
var entity = new GrassCoverErosionInwardsOutputEntity
{
IsOvertoppingDominant = Convert.ToByte(overtoppingOutput.IsOvertoppingDominant),
WaveHeight = overtoppingOutput.WaveHeight.ToNaNAsNull(),
Reliability = overtoppingOutput.Reliability.ToNaNAsNull(),
GeneralResultFaultTreeIllustrationPointEntity = overtoppingOutput.GeneralResult?.CreateGeneralResultFaultTreeIllustrationPointEntity()
};
AddEntityForDikeHeightOutput(entity, output.DikeHeightOutput);
AddEntityForOvertoppingRateOutput(entity, output.OvertoppingRateOutput);
return(entity);
}
public void Create_WithGeneralResult_ReturnsGrassCoverErosionInwardsOutputEntityWithGeneralResultEntity()
{
// Setup
var overtoppingOutput = new OvertoppingOutput(double.NaN,
true,
double.NaN,
new TestGeneralResultFaultTreeIllustrationPoint());
var output = new GrassCoverErosionInwardsOutput(overtoppingOutput, null, null);
// Call
GrassCoverErosionInwardsOutputEntity entity = output.Create();
// Assert
GeneralResultEntityTestHelper.AssertGeneralResultPropertyValues(output.OvertoppingOutput.GeneralResult, entity.GeneralResultFaultTreeIllustrationPointEntity);
}
public void Read_ValidEntityWithOvertoppingRateOutputEntity_ReturnGrassCoverErosionInwardsOutputWithOvertoppingRateOutput()
{
// Setup
var entity = new GrassCoverErosionInwardsOutputEntity
{
GrassCoverErosionInwardsOvertoppingRateOutputEntities =
{
new GrassCoverErosionInwardsOvertoppingRateOutputEntity()
}
};
// Call
GrassCoverErosionInwardsOutput output = entity.Read();
// Assert
Assert.IsNotNull(output.OvertoppingRateOutput);
}
public void Create_ValidInput_ReturnGrassCoverErosionInwardsOutputEntity()
{
// Setup
var random = new Random(456);
var overtoppingOutput = new OvertoppingOutput(random.NextDouble(), false, random.NextDouble(), null);
var dikeHeightConvergence = random.NextEnumValue <CalculationConvergence>();
var overtoppingRateConvergence = random.NextEnumValue <CalculationConvergence>();
var dikeHeightOutput = new DikeHeightOutput(random.NextDouble(), random.NextDouble(),
random.NextDouble(), random.NextDouble(),
random.NextDouble(), dikeHeightConvergence, null);
var overtoppingRateOutput = new OvertoppingRateOutput(random.NextDouble(), random.NextDouble(),
random.NextDouble(), random.NextDouble(),
random.NextDouble(), overtoppingRateConvergence, null);
var output = new GrassCoverErosionInwardsOutput(overtoppingOutput, dikeHeightOutput, overtoppingRateOutput);
// Call
GrassCoverErosionInwardsOutputEntity entity = output.Create();
// Assert
Assert.AreEqual(overtoppingOutput.WaveHeight.Value, entity.WaveHeight);
Assert.AreEqual(Convert.ToByte(overtoppingOutput.IsOvertoppingDominant), entity.IsOvertoppingDominant);
Assert.AreEqual(overtoppingOutput.Reliability, entity.Reliability);
Assert.IsNull(entity.GeneralResultFaultTreeIllustrationPointEntity);
GrassCoverErosionInwardsDikeHeightOutputEntity dikeHeightEntity = entity.GrassCoverErosionInwardsDikeHeightOutputEntities.Single();
Assert.AreEqual(dikeHeightOutput.DikeHeight, dikeHeightEntity.DikeHeight, dikeHeightOutput.DikeHeight.GetAccuracy());
Assert.AreEqual(dikeHeightOutput.TargetProbability, dikeHeightEntity.TargetProbability);
Assert.AreEqual(dikeHeightOutput.TargetReliability, dikeHeightEntity.TargetReliability, dikeHeightOutput.TargetReliability.GetAccuracy());
Assert.AreEqual(dikeHeightOutput.CalculatedProbability, dikeHeightEntity.CalculatedProbability);
Assert.AreEqual(dikeHeightOutput.CalculatedReliability, dikeHeightEntity.CalculatedReliability, dikeHeightOutput.CalculatedReliability.GetAccuracy());
Assert.AreEqual((byte)dikeHeightOutput.CalculationConvergence, dikeHeightEntity.CalculationConvergence);
GrassCoverErosionInwardsOvertoppingRateOutputEntity overtoppingRateEntity = entity.GrassCoverErosionInwardsOvertoppingRateOutputEntities.Single();
Assert.AreEqual(overtoppingRateOutput.OvertoppingRate, overtoppingRateEntity.OvertoppingRate, overtoppingRateOutput.OvertoppingRate.GetAccuracy());
Assert.AreEqual(overtoppingRateOutput.TargetProbability, overtoppingRateEntity.TargetProbability);
Assert.AreEqual(overtoppingRateOutput.TargetReliability, overtoppingRateEntity.TargetReliability, overtoppingRateOutput.TargetReliability.GetAccuracy());
Assert.AreEqual(overtoppingRateOutput.CalculatedProbability, overtoppingRateEntity.CalculatedProbability);
Assert.AreEqual(overtoppingRateOutput.CalculatedReliability, overtoppingRateEntity.CalculatedReliability, overtoppingRateOutput.CalculatedReliability.GetAccuracy());
Assert.AreEqual((byte)overtoppingRateOutput.CalculationConvergence, overtoppingRateEntity.CalculationConvergence);
}
public void ParameteredConstructor_DefaultValues()
{
// Setup
var overtoppingOutput = new TestOvertoppingOutput(double.NaN);
var dikeHeightOutput = new TestDikeHeightOutput(double.NaN);
var overtoppingRateOutput = new TestOvertoppingRateOutput(double.NaN);
// Call
var output = new GrassCoverErosionInwardsOutput(overtoppingOutput, dikeHeightOutput, overtoppingRateOutput);
// Assert
Assert.IsInstanceOf <ICalculationOutput>(output);
Assert.IsInstanceOf <CloneableObservable>(output);
Assert.AreSame(overtoppingOutput, output.OvertoppingOutput);
Assert.AreSame(dikeHeightOutput, output.DikeHeightOutput);
Assert.AreSame(overtoppingRateOutput, output.OvertoppingRateOutput);
}
public void ClearIllustrationPoints_CalculationWithOutput_ClearsIllustrationPointResult()
{
// Setup
var originalOutput = new GrassCoverErosionInwardsOutput(new TestOvertoppingOutput(new TestGeneralResultFaultTreeIllustrationPoint()),
new TestDikeHeightOutput(new TestGeneralResultFaultTreeIllustrationPoint()),
new TestOvertoppingRateOutput(new TestGeneralResultFaultTreeIllustrationPoint()));
var calculation = new GrassCoverErosionInwardsCalculation
{
Output = originalOutput
};
// Call
calculation.ClearIllustrationPoints();
// Assert
Assert.AreSame(originalOutput, calculation.Output);
Assert.IsNull(originalOutput.OvertoppingOutput.GeneralResult);
Assert.IsNull(originalOutput.DikeHeightOutput.GeneralResult);
Assert.IsNull(originalOutput.OvertoppingRateOutput.GeneralResult);
}
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));
}
public void Read_ValidEntity_ReturnGrassCoverErosionInwardsOutput()
{
// Setup
var entity = new GrassCoverErosionInwardsOutputEntity
{
WaveHeight = 1.1,
IsOvertoppingDominant = Convert.ToByte(false),
Reliability = 0.2
};
// Call
GrassCoverErosionInwardsOutput output = entity.Read();
// Assert
OvertoppingOutput overtoppingOutput = output.OvertoppingOutput;
Assert.AreEqual(entity.WaveHeight, overtoppingOutput.WaveHeight.Value);
Assert.IsFalse(overtoppingOutput.IsOvertoppingDominant);
Assert.IsNull(output.DikeHeightOutput);
Assert.IsNull(output.OvertoppingRateOutput);
Assert.AreEqual(entity.Reliability, overtoppingOutput.Reliability);
}
public void Create_CalculationWithOutput_ReturnEntity()
{
// Setup
var random = new Random(456);
var overtoppingOutput = new OvertoppingOutput(random.NextDouble(), false, random.NextDouble(), null);
var output = new GrassCoverErosionInwardsOutput(overtoppingOutput, null, null);
var calculation = new GrassCoverErosionInwardsCalculationScenario
{
Output = output
};
var registry = new PersistenceRegistry();
// Call
GrassCoverErosionInwardsCalculationEntity entity = calculation.Create(registry, 0);
// Assert
GrassCoverErosionInwardsOutputEntity outputEntity = entity.GrassCoverErosionInwardsOutputEntities.Single();
Assert.AreEqual(overtoppingOutput.WaveHeight, outputEntity.WaveHeight);
Assert.AreEqual(overtoppingOutput.Reliability, outputEntity.Reliability);
Assert.IsNull(outputEntity.GeneralResultFaultTreeIllustrationPointEntity);
}
public void Read_ValidEntityWithNullValues_ReturnGrassCoverErosionInwardsOutput()
{
// Setup
var entity = new GrassCoverErosionInwardsOutputEntity
{
WaveHeight = null,
IsOvertoppingDominant = Convert.ToByte(true),
Reliability = null,
GeneralResultFaultTreeIllustrationPointEntity = null
};
// Call
GrassCoverErosionInwardsOutput output = entity.Read();
// Assert
OvertoppingOutput overtoppingOutput = output.OvertoppingOutput;
Assert.IsNaN(overtoppingOutput.WaveHeight);
Assert.IsTrue(overtoppingOutput.IsOvertoppingDominant);
Assert.IsNull(output.DikeHeightOutput);
Assert.IsNull(output.OvertoppingRateOutput);
Assert.IsNaN(overtoppingOutput.Reliability);
Assert.IsNull(overtoppingOutput.GeneralResult);
}
public void ClearIllustrationPoints_Always_ReturnsAffectedCalculations()
{
// 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()
};
var mocks = new MockRepository();
var inquiryHelper = mocks.StrictMock <IInquiryHelper>();
mocks.ReplayAll();
var handler = new ClearIllustrationPointsOfGrassCoverErosionInwardsCalculationCollectionChangeHandler(
inquiryHelper, calculations);
// Call
IEnumerable <IObservable> affectedObjects = handler.ClearIllustrationPoints();
// 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);
}));
mocks.VerifyAll();
}
/// <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(GrassCoverErosionInwardsOutput original, GrassCoverErosionInwardsOutput clone)
{
CoreCloneAssert.AreObjectClones(original.OvertoppingOutput, clone.OvertoppingOutput, AreClones);
CoreCloneAssert.AreObjectClones(original.DikeHeightOutput, clone.DikeHeightOutput, AreClones);
CoreCloneAssert.AreObjectClones(original.OvertoppingRateOutput, clone.OvertoppingRateOutput, AreClones);
}
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);
}));
}
private static bool HasOverToppingRateOutputWithIllustrationPoints(GrassCoverErosionInwardsOutput output)
{
return(output.OvertoppingRateOutput != null && output.OvertoppingRateOutput.HasGeneralResult);
}
private static bool HasDikeHeightOutputWithIllustrationPoints(GrassCoverErosionInwardsOutput output)
{
return(output.DikeHeightOutput != null && output.DikeHeightOutput.HasGeneralResult);
}
public void GivenCalculationsWithIllustrationPoints_WhenClearIllustrationPointsClickedAndContinued_ThenInquiryAndIllustrationPointsCleared()
{
// Given
var calculationWithIllustrationPoints = new GrassCoverErosionInwardsCalculation
{
Output = new TestGrassCoverErosionInwardsOutput(new TestGeneralResultFaultTreeIllustrationPoint())
};
var calculationWithOutput = new GrassCoverErosionInwardsCalculation
{
Output = new TestGrassCoverErosionInwardsOutput()
};
var affectedCalculationObserver = mocksRepository.StrictMock <IObserver>();
affectedCalculationObserver.Expect(o => o.UpdateObserver());
calculationWithIllustrationPoints.Attach(affectedCalculationObserver);
var unaffectedCalculationObserver = mocksRepository.StrictMock <IObserver>();
calculationWithOutput.Attach(unaffectedCalculationObserver);
var failureMechanism = new GrassCoverErosionInwardsFailureMechanism
{
CalculationsGroup =
{
Children =
{
calculationWithIllustrationPoints,
calculationWithOutput,
new GrassCoverErosionInwardsCalculation()
}
}
};
IAssessmentSection assessmentSection = AssessmentSectionTestHelper.CreateAssessmentSectionStub(mocksRepository);
var nodeData = new GrassCoverErosionInwardsFailureMechanismContext(failureMechanism, assessmentSection);
var messageBoxText = "";
DialogBoxHandler = (name, wnd) =>
{
var helper = new MessageBoxTester(wnd);
messageBoxText = helper.Text;
helper.ClickOk();
};
using (var treeViewControl = new TreeViewControl())
{
var gui = mocksRepository.Stub <IGui>();
gui.Stub(g => g.Get(nodeData, treeViewControl)).Return(new CustomItemsOnlyContextMenuBuilder());
gui.Stub(g => g.MainWindow).Return(mocksRepository.Stub <IMainWindow>());
mocksRepository.ReplayAll();
plugin.Gui = gui;
using (ContextMenuStrip contextMenuStrip = info.ContextMenuStrip(nodeData, null, treeViewControl))
{
// When
contextMenuStrip.Items[contextMenuClearIllustrationPointsIndex].PerformClick();
// Then
Assert.AreEqual("Weet u zeker dat u alle illustratiepunten wilt wissen?", messageBoxText);
Assert.IsTrue(calculationWithOutput.HasOutput);
GrassCoverErosionInwardsOutput output = calculationWithIllustrationPoints.Output;
Assert.IsFalse(output.OvertoppingOutput.HasGeneralResult);
Assert.IsFalse(output.DikeHeightOutput.HasGeneralResult);
Assert.IsFalse(output.OvertoppingRateOutput.HasGeneralResult);
}
}
}
private static bool HasIllustrationPoints(GrassCoverErosionInwardsOutput output)
{
return(output.OvertoppingOutput.HasGeneralResult ||
HasDikeHeightOutputWithIllustrationPoints(output) ||
HasOverToppingRateOutputWithIllustrationPoints(output));
}
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);
}
