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); }