public void CanDrop_DraggedDataPartOfGroupContext_ReturnsTrue()
{
// Setup
using (var plugin = new RiskeerPlugin())
{
TreeNodeInfo info = GetInfo(plugin);
var assessmentSectionStub = new AssessmentSectionStub();
var calculationsForTargetProbability = new HydraulicBoundaryLocationCalculationsForTargetProbability(0.1);
var targetData = new WaveHeightCalculationsForUserDefinedTargetProbabilitiesGroupContext(
new ObservableList <HydraulicBoundaryLocationCalculationsForTargetProbability>
{
calculationsForTargetProbability
},
assessmentSectionStub);
var draggedData = new WaveHeightCalculationsForUserDefinedTargetProbabilityContext(
calculationsForTargetProbability,
assessmentSectionStub);
// Call
bool canDrop = info.CanDrop(draggedData, targetData);
// Assert
Assert.IsTrue(canDrop);
}
}
/// <summary>
/// Reads the <see cref="HydraulicLocationCalculationForTargetProbabilityCollectionEntity"/> and uses
/// the information to create a <see cref="HydraulicBoundaryLocationCalculationsForTargetProbability"/>.
/// </summary>
/// <param name="entity">The <see cref="HydraulicLocationCalculationForTargetProbabilityCollectionEntity"/> to create the
/// <see cref="HydraulicBoundaryLocationCalculationsForTargetProbability"/>.</param>
/// <param name="collector">The object keeping track of the read operations.</param>
/// <exception cref="ArgumentNullException">Thrown when any parameter is <c>null</c>.</exception>
internal static HydraulicBoundaryLocationCalculationsForTargetProbability Read(
this HydraulicLocationCalculationForTargetProbabilityCollectionEntity entity,
ReadConversionCollector collector)
{
if (entity == null)
{
throw new ArgumentNullException(nameof(entity));
}
if (collector == null)
{
throw new ArgumentNullException(nameof(collector));
}
if (collector.Contains(entity))
{
return(collector.Get(entity));
}
var calculations = new HydraulicBoundaryLocationCalculationsForTargetProbability(entity.TargetProbability);
IEnumerable <HydraulicBoundaryLocationCalculation> hydraulicBoundaryLocationCalculations =
entity.HydraulicLocationCalculationEntities
.Select(hlce => CreateHydraulicBoundaryLocationCalculation(hlce, collector))
.ToArray();
calculations.HydraulicBoundaryLocationCalculations.AddRange(hydraulicBoundaryLocationCalculations);
collector.Read(entity, calculations);
return(calculations);
}
public void TargetProbability_Always_InputChangedAndObservablesNotified()
{
// Setup
var mocks = new MockRepository();
var observable = mocks.StrictMock <IObservable>();
observable.Expect(o => o.NotifyObservers());
mocks.ReplayAll();
var customHandler = new SetPropertyValueAfterConfirmationParameterTester(new[]
{
observable
});
var calculationsForTargetProbability = new HydraulicBoundaryLocationCalculationsForTargetProbability(0.1)
{
HydraulicBoundaryLocationCalculations =
{
new HydraulicBoundaryLocationCalculation(new TestHydraulicBoundaryLocation())
}
};
var properties = new WaveHeightCalculationsForUserDefinedTargetProbabilityProperties(
calculationsForTargetProbability, customHandler);
// Call
properties.TargetProbability = 0.01;
// Assert
mocks.VerifyAll();
}
public void ClearAllWaveConditionsCalculationsOutputWithUserDefinedTargetProbability_WithAllData_ClearsOutputAndReturnsAffectedObjects()
{
// Setup
var calculationsForTargetProbabilityToClear = new HydraulicBoundaryLocationCalculationsForTargetProbability(0.1);
var otherCalculationsForTargetProbability = new HydraulicBoundaryLocationCalculationsForTargetProbability(0.01);
var calculation1 = new TestWaveConditionsCalculation <WaveConditionsInput>(new WaveConditionsInput
{
WaterLevelType = WaveConditionsInputWaterLevelType.SignalFloodingProbability,
CalculationsTargetProbability = calculationsForTargetProbabilityToClear
}, true);
var calculation2 = new TestWaveConditionsCalculation <WaveConditionsInput>(new WaveConditionsInput
{
WaterLevelType = WaveConditionsInputWaterLevelType.MaximumAllowableFloodingProbability,
CalculationsTargetProbability = calculationsForTargetProbabilityToClear
}, true);
var calculation3 = new TestWaveConditionsCalculation <WaveConditionsInput>(new WaveConditionsInput
{
WaterLevelType = WaveConditionsInputWaterLevelType.None,
CalculationsTargetProbability = calculationsForTargetProbabilityToClear
}, true);
var calculation4 = new TestWaveConditionsCalculation <WaveConditionsInput>(new WaveConditionsInput
{
WaterLevelType = WaveConditionsInputWaterLevelType.UserDefinedTargetProbability,
CalculationsTargetProbability = calculationsForTargetProbabilityToClear
}, true);
var calculation5 = new TestWaveConditionsCalculation <WaveConditionsInput>(new WaveConditionsInput
{
WaterLevelType = WaveConditionsInputWaterLevelType.UserDefinedTargetProbability,
CalculationsTargetProbability = otherCalculationsForTargetProbability
}, true);
var mocks = new MockRepository();
var failureMechanism = mocks.Stub <ICalculatableFailureMechanism>();
failureMechanism.Stub(fm => fm.Calculations).Return(new[]
{
calculation1,
calculation2,
calculation3,
calculation4,
calculation5
});
mocks.ReplayAll();
TestWaveConditionsCalculation <WaveConditionsInput>[] expectedAffectedCalculations =
{
calculation4
};
// Call
IEnumerable <IObservable> affectedCalculations = WaveConditionsDataSynchronizationService.ClearAllWaveConditionsCalculationOutput <ICalculatableFailureMechanism, TestWaveConditionsCalculation <WaveConditionsInput> >(
failureMechanism, calculationsForTargetProbabilityToClear);
// Assert
CollectionAssert.AreEqual(expectedAffectedCalculations, affectedCalculations);
Assert.IsTrue(expectedAffectedCalculations.All(c => !c.HasOutput));
Assert.IsTrue(failureMechanism.Calculations.Except(expectedAffectedCalculations).All(c => c.HasOutput));
mocks.VerifyAll();
}
public void CreateInstance_WithContext_SetsDataCorrectly()
{
// Setup
var mockRepository = new MockRepository();
var assessmentSection = mockRepository.Stub <IAssessmentSection>();
mockRepository.ReplayAll();
var calculationsForTargetProbability = new HydraulicBoundaryLocationCalculationsForTargetProbability(0.1);
var context = new WaveHeightCalculationsForUserDefinedTargetProbabilityContext(calculationsForTargetProbability,
assessmentSection);
using (var plugin = new RiskeerPlugin())
{
PropertyInfo info = GetInfo(plugin);
// Call
IObjectProperties objectProperties = info.CreateInstance(context);
// Assert
Assert.IsInstanceOf <WaveHeightCalculationsForUserDefinedTargetProbabilityProperties>(objectProperties);
Assert.AreSame(calculationsForTargetProbability.HydraulicBoundaryLocationCalculations, objectProperties.Data);
}
mockRepository.VerifyAll();
}
/// <summary>
/// Creates a <see cref="SelectableTargetProbability"/> that is shown as selected in the drop-down menu.
/// </summary>
/// <returns>The created <see cref="SelectableTargetProbability"/>.</returns>
/// <exception cref="NotSupportedException">Thrown when <see cref="WaveConditionsInputWaterLevelType"/>
/// is not supported.</exception>
private SelectableTargetProbability CreateSelectedSelectableTargetProbability()
{
IAssessmentSection assessmentSection = data.AssessmentSection;
switch (data.WrappedData.WaterLevelType)
{
case WaveConditionsInputWaterLevelType.MaximumAllowableFloodingProbability:
return(CreateSelectableTargetProbability(assessmentSection, assessmentSection.WaterLevelCalculationsForMaximumAllowableFloodingProbability,
WaveConditionsInputWaterLevelType.MaximumAllowableFloodingProbability,
assessmentSection.FailureMechanismContribution.MaximumAllowableFloodingProbability));
case WaveConditionsInputWaterLevelType.SignalFloodingProbability:
return(CreateSelectableTargetProbability(assessmentSection, assessmentSection.WaterLevelCalculationsForSignalFloodingProbability,
WaveConditionsInputWaterLevelType.SignalFloodingProbability,
assessmentSection.FailureMechanismContribution.SignalFloodingProbability));
case WaveConditionsInputWaterLevelType.UserDefinedTargetProbability:
HydraulicBoundaryLocationCalculationsForTargetProbability calculationsForTargetProbability = data.WrappedData.CalculationsTargetProbability;
return(CreateSelectableTargetProbability(assessmentSection, calculationsForTargetProbability.HydraulicBoundaryLocationCalculations,
WaveConditionsInputWaterLevelType.UserDefinedTargetProbability,
calculationsForTargetProbability.TargetProbability));
case WaveConditionsInputWaterLevelType.None:
return(null);
default:
throw new NotSupportedException();
}
}
public void SetHydraulicBoundaryLocationCalculations_Always_PreviousCalculationsCleared()
{
// Setup
var random = new Random(21);
var assessmentSection = new AssessmentSection(random.NextEnumValue <AssessmentSectionComposition>());
var waterLevelCalculationsForTargetProbability = new HydraulicBoundaryLocationCalculationsForTargetProbability(0.1);
assessmentSection.WaterLevelCalculationsForUserDefinedTargetProbabilities.Add(waterLevelCalculationsForTargetProbability);
var waveHeightCalculationsForTargetProbability = new HydraulicBoundaryLocationCalculationsForTargetProbability(0.01);
assessmentSection.WaveHeightCalculationsForUserDefinedTargetProbabilities.Add(waveHeightCalculationsForTargetProbability);
assessmentSection.SetHydraulicBoundaryLocationCalculations(new HydraulicBoundaryLocation[]
{
new TestHydraulicBoundaryLocation()
});
// Precondition
CollectionAssert.IsNotEmpty(assessmentSection.WaterLevelCalculationsForSignalFloodingProbability);
CollectionAssert.IsNotEmpty(assessmentSection.WaterLevelCalculationsForMaximumAllowableFloodingProbability);
CollectionAssert.IsNotEmpty(waterLevelCalculationsForTargetProbability.HydraulicBoundaryLocationCalculations);
CollectionAssert.IsNotEmpty(waveHeightCalculationsForTargetProbability.HydraulicBoundaryLocationCalculations);
// Call
assessmentSection.SetHydraulicBoundaryLocationCalculations(Enumerable.Empty <HydraulicBoundaryLocation>());
// Assert
CollectionAssert.IsEmpty(assessmentSection.WaterLevelCalculationsForSignalFloodingProbability);
CollectionAssert.IsEmpty(assessmentSection.WaterLevelCalculationsForMaximumAllowableFloodingProbability);
CollectionAssert.IsEmpty(waterLevelCalculationsForTargetProbability.HydraulicBoundaryLocationCalculations);
CollectionAssert.IsEmpty(waveHeightCalculationsForTargetProbability.HydraulicBoundaryLocationCalculations);
}
public void GetViewName_WithContext_ReturnsExpectedViewName(double userDefinedTargetProbability1,
double userDefinedTargetProbability2,
double userDefinedTargetProbability3,
string expectedProbabilityText)
{
// Setup
var calculationsForTargetProbability = new HydraulicBoundaryLocationCalculationsForTargetProbability(userDefinedTargetProbability2);
var assessmentSection = new AssessmentSectionStub
{
WaterLevelCalculationsForUserDefinedTargetProbabilities =
{
new HydraulicBoundaryLocationCalculationsForTargetProbability(userDefinedTargetProbability1),
new HydraulicBoundaryLocationCalculationsForTargetProbability(userDefinedTargetProbability3),
calculationsForTargetProbability
}
};
var context = new WaterLevelCalculationsForUserDefinedTargetProbabilityContext(calculationsForTargetProbability,
assessmentSection);
using (var plugin = new RiskeerPlugin())
{
ViewInfo info = GetViewInfo(plugin);
// Call
string viewName = info.GetViewName(null, context);
// Assert
Assert.AreEqual($"Waterstanden bij vrije doelkans - {expectedProbabilityText}", viewName);
}
}
public void GetUniqueDisplayNameForWaterLevelCalculations_ValidParameters_ReturnsExpectedDisplayNameForUserDefinedTargetProbability(
double maximumAllowableFloodingProbability, double signalFloodingProbability, double userDefinedTargetProbability1, double userDefinedTargetProbability2, string expectedName)
{
// Setup
var calculationsForTargetProbability = new HydraulicBoundaryLocationCalculationsForTargetProbability(userDefinedTargetProbability2);
var mockRepository = new MockRepository();
IAssessmentSection assessmentSection = AssessmentSectionTestHelper.CreateAssessmentSectionStub(mockRepository);
assessmentSection.Stub(a => a.FailureMechanismContribution).Return(new FailureMechanismContribution(maximumAllowableFloodingProbability, signalFloodingProbability));
assessmentSection.Stub(a => a.WaterLevelCalculationsForMaximumAllowableFloodingProbability).Return(new ObservableList <HydraulicBoundaryLocationCalculation>());
assessmentSection.Stub(a => a.WaterLevelCalculationsForSignalFloodingProbability).Return(new ObservableList <HydraulicBoundaryLocationCalculation>());
assessmentSection.Stub(a => a.WaterLevelCalculationsForUserDefinedTargetProbabilities).Return(
new ObservableList <HydraulicBoundaryLocationCalculationsForTargetProbability>
{
new HydraulicBoundaryLocationCalculationsForTargetProbability(userDefinedTargetProbability1),
calculationsForTargetProbability
});
mockRepository.ReplayAll();
// Call
string name = TargetProbabilityCalculationsDisplayNameHelper.GetUniqueDisplayNameForWaterLevelCalculations(calculationsForTargetProbability.HydraulicBoundaryLocationCalculations,
assessmentSection);
// Assert
Assert.AreEqual(expectedName, name);
mockRepository.VerifyAll();
}
public void SetPropertyValueAfterConfirmation_CalculationsForTargetProbabilityWithAndWithoutOutput_AllCalculationOutputClearedAndReturnsAllAffectedObjects()
{
// Setup
DialogBoxHandler = (name, wnd) =>
{
var tester = new MessageBoxTester(wnd);
tester.ClickOk();
};
HydraulicBoundaryLocationCalculationsForTargetProbability calculationsForTargetProbability = CreateCalculationsForTargetProbabilityWithAndWithoutOutput();
List <IObservable> expectedAffectedObjects = calculationsForTargetProbability.HydraulicBoundaryLocationCalculations
.Where(hblc => hblc.HasOutput)
.Cast <IObservable>()
.ToList();
expectedAffectedObjects.Add(calculationsForTargetProbability);
var handler = new HydraulicBoundaryLocationCalculationsForTargetProbabilityChangeHandler(calculationsForTargetProbability);
IEnumerable <IObservable> affectedObjects = null;
// Call
void Call() => affectedObjects = handler.SetPropertyValueAfterConfirmation(() => {});
// Assert
var expectedMessages = new[]
{
"Alle bijbehorende hydraulische belastingen zijn verwijderd."
};
TestHelper.AssertLogMessagesAreGenerated(Call, expectedMessages, 1);
CollectionAssert.IsEmpty(calculationsForTargetProbability.HydraulicBoundaryLocationCalculations.Where(c => c.HasOutput));
CollectionAssert.AreEquivalent(expectedAffectedObjects, affectedObjects);
}
/// <summary>
/// Clears the output for all calculations that corresponds with the <paramref name="calculationsForTargetProbability"/>
/// in the given <paramref name="failureMechanism"/>.
/// </summary>
/// <param name="failureMechanism">The failure mechanism which contains the calculations.</param>
/// <param name="calculationsForTargetProbability">The <see cref="HydraulicBoundaryLocationCalculationsForTargetProbability"/>
/// to clear for.</param>
/// <typeparam name="TFailureMechanism">The type of the calculatable failure mechanism.</typeparam>
/// <typeparam name="TCalculation">The type of the calculation.</typeparam>
/// <returns>An <see cref="IEnumerable{T}"/> of calculations which are affected by clearing the output.</returns>
/// <exception cref="ArgumentNullException">Thrown when any parameter is <c>null</c>.</exception>
public static IEnumerable <IObservable> ClearAllWaveConditionsCalculationOutput <TFailureMechanism, TCalculation>(
TFailureMechanism failureMechanism, HydraulicBoundaryLocationCalculationsForTargetProbability calculationsForTargetProbability)
where TFailureMechanism : ICalculatableFailureMechanism
where TCalculation : ICalculation <WaveConditionsInput>
{
if (failureMechanism == null)
{
throw new ArgumentNullException(nameof(failureMechanism));
}
if (calculationsForTargetProbability == null)
{
throw new ArgumentNullException(nameof(calculationsForTargetProbability));
}
var affectedItems = new List <IObservable>();
foreach (TCalculation calculation in failureMechanism.Calculations
.Cast <TCalculation>()
.Where(c => c.InputParameters.WaterLevelType == WaveConditionsInputWaterLevelType.UserDefinedTargetProbability &&
c.InputParameters.CalculationsTargetProbability == calculationsForTargetProbability))
{
affectedItems.AddRange(RiskeerCommonDataSynchronizationService.ClearCalculationOutput(calculation));
}
return(affectedItems);
}
public void GetProperties_WithData_ReturnExpectedValues()
{
// Setup
var mocks = new MockRepository();
var targetProbabilityChangeHandler = mocks.Stub <IObservablePropertyChangeHandler>();
mocks.ReplayAll();
var calculationsForTargetProbability = new HydraulicBoundaryLocationCalculationsForTargetProbability(0.1)
{
HydraulicBoundaryLocationCalculations =
{
new HydraulicBoundaryLocationCalculation(new TestHydraulicBoundaryLocation())
}
};
// Call
var properties = new WaveHeightCalculationsForUserDefinedTargetProbabilityProperties(
calculationsForTargetProbability, targetProbabilityChangeHandler);
// Assert
Assert.AreEqual(calculationsForTargetProbability.TargetProbability, properties.TargetProbability);
Assert.AreEqual(1, properties.Calculations.Length);
mocks.VerifyAll();
}
public void Create_HasHydraulicLocationCalculationsForTargetProbability_EntityHasHydraulicLocationCalculationForTargetProbabilityCollectionEntity()
{
// Setup
var random = new Random(21);
var hydraulicCalculations = new HydraulicBoundaryLocationCalculationsForTargetProbability(random.NextDouble(0, 0.1));
var hydraulicCalculationsEntity = new HydraulicLocationCalculationForTargetProbabilityCollectionEntity();
var registry = new PersistenceRegistry();
registry.Register(hydraulicCalculationsEntity, hydraulicCalculations);
var calculation = new WaveImpactAsphaltCoverWaveConditionsCalculation
{
InputParameters =
{
CalculationsTargetProbability = hydraulicCalculations
}
};
// Call
WaveImpactAsphaltCoverWaveConditionsCalculationEntity entity = calculation.Create(registry, 0);
// Assert
Assert.AreSame(hydraulicCalculationsEntity, entity.HydraulicLocationCalculationForTargetProbabilityCollectionEntity);
}
private static void AssertHydraulicLocationCalculationForTargetProbabilityCollectionEntity(
HydraulicBoundaryLocationCalculationsForTargetProbability expectedCalculations,
HydraulicLocationCalculationForTargetProbabilityCollectionEntity entity)
{
Assert.AreEqual(expectedCalculations.TargetProbability, entity.TargetProbability);
AssertHydraulicLocationCalculationCollectionEntity(expectedCalculations.HydraulicBoundaryLocationCalculations,
entity.HydraulicLocationCalculationEntities);
}
/// <summary>
/// Gets a collection of <see cref="TestCaseData"/> containing an assessment level configuration for all types
/// of <see cref="WaveConditionsInputWaterLevelType"/>.
/// </summary>
/// <returns>A collection of <see cref="TestCaseData"/>, in which each item contains:
/// <list type="bullet">
/// <item>the configured assessment section;</item>
/// <item>a method for configuring the wave conditions input at stake;</item>
/// <item>the expected assessment level given the combination of the before-mentioned assessment section, the configured
/// hydraulic boundary location and the configured water level type.</item>
/// </list>
/// </returns>
public static IEnumerable <TestCaseData> GetAssessmentLevelConfigurationPerWaterLevelType()
{
var calculationsForTargetProbability = new HydraulicBoundaryLocationCalculationsForTargetProbability(0.01);
var assessmentSection = new AssessmentSectionStub
{
WaterLevelCalculationsForUserDefinedTargetProbabilities =
{
calculationsForTargetProbability
}
};
var hydraulicBoundaryLocation = new TestHydraulicBoundaryLocation();
assessmentSection.SetHydraulicBoundaryLocationCalculations(new[]
{
hydraulicBoundaryLocation
}, true);
yield return(new TestCaseData(
assessmentSection,
new Action <WaveConditionsInput>(input =>
{
input.HydraulicBoundaryLocation = hydraulicBoundaryLocation;
input.WaterLevelType = WaveConditionsInputWaterLevelType.None;
}),
RoundedDouble.NaN));
yield return(new TestCaseData(
assessmentSection,
new Action <WaveConditionsInput>(input =>
{
input.HydraulicBoundaryLocation = hydraulicBoundaryLocation;
input.WaterLevelType = WaveConditionsInputWaterLevelType.MaximumAllowableFloodingProbability;
}),
assessmentSection.WaterLevelCalculationsForMaximumAllowableFloodingProbability.First().Output.Result));
yield return(new TestCaseData(
assessmentSection,
new Action <WaveConditionsInput>(input =>
{
input.HydraulicBoundaryLocation = hydraulicBoundaryLocation;
input.WaterLevelType = WaveConditionsInputWaterLevelType.SignalFloodingProbability;
}),
assessmentSection.WaterLevelCalculationsForSignalFloodingProbability.First().Output.Result));
yield return(new TestCaseData(
assessmentSection,
new Action <WaveConditionsInput>(input =>
{
input.HydraulicBoundaryLocation = hydraulicBoundaryLocation;
input.WaterLevelType = WaveConditionsInputWaterLevelType.UserDefinedTargetProbability;
input.CalculationsTargetProbability = calculationsForTargetProbability;
}),
calculationsForTargetProbability.HydraulicBoundaryLocationCalculations.First().Output.Result));
}
public void Constructor_ValidTargetProbability_ExpectedProperties(double validValue)
{
// Call
var calculationsForTargetProbability = new HydraulicBoundaryLocationCalculationsForTargetProbability(validValue);
// Assert
Assert.IsInstanceOf <Observable>(calculationsForTargetProbability);
Assert.AreEqual(validValue, calculationsForTargetProbability.TargetProbability);
Assert.IsEmpty(calculationsForTargetProbability.HydraulicBoundaryLocationCalculations);
}
/// <summary>
/// Creates a new instance of <see cref="HydraulicBoundaryLocationCalculationsForTargetProbabilityChangeHandler"/>.
/// </summary>
/// <param name="calculationsForTargetProbability">The calculations to change the target probability for.</param>
/// <exception cref="ArgumentNullException">Thrown when <paramref name="calculationsForTargetProbability"/> is <c>null</c>.</exception>
public HydraulicBoundaryLocationCalculationsForTargetProbabilityChangeHandler(
HydraulicBoundaryLocationCalculationsForTargetProbability calculationsForTargetProbability)
{
if (calculationsForTargetProbability == null)
{
throw new ArgumentNullException(nameof(calculationsForTargetProbability));
}
CalculationsForTargetProbability = calculationsForTargetProbability;
}
public void SetPropertyValueAfterConfirmation_CalculationsForTargetProbabilityWithAndWithoutOutput_AllCalculationOutputClearedAndReturnsAllAffectedObjects()
{
// Setup
DialogBoxHandler = (name, wnd) =>
{
var tester = new MessageBoxTester(wnd);
tester.ClickOk();
};
AssessmentSection assessmentSection = TestDataGenerator.GetAssessmentSectionWithAllCalculationConfigurations();
HydraulicBoundaryLocationCalculationsForTargetProbability calculationsForTargetProbability = assessmentSection.WaterLevelCalculationsForUserDefinedTargetProbabilities
.First();
var waveConditionsCalculations = new List <ICalculation <WaveConditionsInput> >();
waveConditionsCalculations.AddRange(assessmentSection.GrassCoverErosionOutwards.Calculations
.Cast <GrassCoverErosionOutwardsWaveConditionsCalculation>());
waveConditionsCalculations.AddRange(assessmentSection.StabilityStoneCover.Calculations
.Cast <StabilityStoneCoverWaveConditionsCalculation>());
waveConditionsCalculations.AddRange(assessmentSection.WaveImpactAsphaltCover.Calculations
.Cast <WaveImpactAsphaltCoverWaveConditionsCalculation>());
waveConditionsCalculations.ForEachElementDo(c =>
{
c.InputParameters.WaterLevelType = WaveConditionsInputWaterLevelType.UserDefinedTargetProbability;
c.InputParameters.CalculationsTargetProbability = calculationsForTargetProbability;
});
var expectedAffectedObjects = new List <IObservable>
{
calculationsForTargetProbability
};
expectedAffectedObjects.AddRange(calculationsForTargetProbability.HydraulicBoundaryLocationCalculations.Where(c => c.HasOutput));
expectedAffectedObjects.AddRange(waveConditionsCalculations.Where(c => c.HasOutput));
var handler = new WaterLevelHydraulicBoundaryLocationCalculationsForTargetProbabilityChangeHandler(calculationsForTargetProbability, assessmentSection);
IEnumerable <IObservable> affectedObjects = null;
// Call
void Call() => affectedObjects = handler.SetPropertyValueAfterConfirmation(() => {});
// Assert
var expectedMessages = new[]
{
"Alle bijbehorende hydraulische belastingen zijn verwijderd."
};
TestHelper.AssertLogMessagesAreGenerated(Call, expectedMessages, 1);
CollectionAssert.AreEquivalent(expectedAffectedObjects, affectedObjects);
CollectionAssert.IsEmpty(calculationsForTargetProbability.HydraulicBoundaryLocationCalculations.Where(c => c.HasOutput));
CollectionAssert.IsEmpty(waveConditionsCalculations.Where(c => c.HasOutput));
}
/// <summary>
/// Creates a new instance of <see cref="WaterLevelHydraulicBoundaryLocationCalculationsForTargetProbabilityChangeHandler"/>.
/// </summary>
/// <param name="calculationsForTargetProbability">The calculations to change the target probability for.</param>
/// <param name="assessmentSection">The <see cref="IAssessmentSection"/> that contains the <paramref name="calculationsForTargetProbability"/>.</param>
/// <exception cref="ArgumentNullException">Thrown when any parameter is <c>null</c>.</exception>
public WaterLevelHydraulicBoundaryLocationCalculationsForTargetProbabilityChangeHandler(
HydraulicBoundaryLocationCalculationsForTargetProbability calculationsForTargetProbability, IAssessmentSection assessmentSection)
: base(calculationsForTargetProbability)
{
if (assessmentSection == null)
{
throw new ArgumentNullException(nameof(assessmentSection));
}
this.assessmentSection = assessmentSection;
}
public void TargetProbability_ValidValue_NewValueSet(double validValue)
{
// Setup
var calculationsForTargetProbability = new HydraulicBoundaryLocationCalculationsForTargetProbability(0.01);
// Call
calculationsForTargetProbability.TargetProbability = validValue;
// Assert
Assert.AreEqual(validValue, calculationsForTargetProbability.TargetProbability);
}
/// <summary>
/// Creates a new instance of <see cref="WaveHeightCalculationsForUserDefinedTargetProbabilityProperties"/>.
/// </summary>
/// <param name="calculationsForTargetProbability">The <see cref="HydraulicBoundaryLocationCalculationsForTargetProbability"/> to show the properties for.</param>
/// <param name="targetProbabilityChangeHandler">The <see cref="IObservablePropertyChangeHandler"/> for when the target probability changes.</param>
/// <exception cref="ArgumentNullException">Thrown when any parameter is <c>null</c>.</exception>
public WaveHeightCalculationsForUserDefinedTargetProbabilityProperties(HydraulicBoundaryLocationCalculationsForTargetProbability calculationsForTargetProbability,
IObservablePropertyChangeHandler targetProbabilityChangeHandler)
: base(calculationsForTargetProbability?.HydraulicBoundaryLocationCalculations ?? throw new ArgumentNullException(nameof(calculationsForTargetProbability)))
{
if (targetProbabilityChangeHandler == null)
{
throw new ArgumentNullException(nameof(targetProbabilityChangeHandler));
}
this.calculationsForTargetProbability = calculationsForTargetProbability;
this.targetProbabilityChangeHandler = targetProbabilityChangeHandler;
}
public void TargetProbability_InvalidValue_ThrowsArgumentOutOfRangeException(double invalidValue)
{
// Setup
var calculationsForTargetProbability = new HydraulicBoundaryLocationCalculationsForTargetProbability(0.01);
// Call
void Call() => calculationsForTargetProbability.TargetProbability = invalidValue;
// Assert
const string expectedMessage = "De waarde van de doelkans moet groter zijn dan 0 en kleiner dan of gelijk aan 0,1.";
var exception = Assert.Throws <ArgumentOutOfRangeException>(Call);
StringAssert.StartsWith(expectedMessage, exception.Message);
}
public void OnDrop_DataDroppedToDifferentIndex_DroppedDataCorrectlyMovedAndObserversNotified()
{
// Setup
using (var plugin = new RiskeerPlugin())
{
TreeNodeInfo info = GetInfo(plugin);
var assessmentSectionStub = new AssessmentSectionStub();
var calculationsForTargetProbability1 = new HydraulicBoundaryLocationCalculationsForTargetProbability(0.1);
var calculationsForTargetProbability2 = new HydraulicBoundaryLocationCalculationsForTargetProbability(0.01);
var calculationsForTargetProbability3 = new HydraulicBoundaryLocationCalculationsForTargetProbability(0.001);
var calculationsForTargetProbabilities = new ObservableList <HydraulicBoundaryLocationCalculationsForTargetProbability>
{
calculationsForTargetProbability1,
calculationsForTargetProbability2,
calculationsForTargetProbability3
};
var parentData = new WaveHeightCalculationsForUserDefinedTargetProbabilitiesGroupContext(
calculationsForTargetProbabilities,
assessmentSectionStub);
var droppedData = new WaveHeightCalculationsForUserDefinedTargetProbabilityContext(
calculationsForTargetProbability3,
assessmentSectionStub);
var mockRepository = new MockRepository();
var observer = mockRepository.StrictMock <IObserver>();
observer.Expect(o => o.UpdateObserver());
mockRepository.ReplayAll();
calculationsForTargetProbabilities.Attach(observer);
// Call
info.OnDrop(droppedData, parentData, parentData, 1, null);
// Assert
CollectionAssert.AreEqual(new[]
{
calculationsForTargetProbability1,
calculationsForTargetProbability3,
calculationsForTargetProbability2
}, calculationsForTargetProbabilities);
mockRepository.VerifyAll();
}
}
public void Create_PersistenceRegistryNull_ThrowsArgumentNullException()
{
// Setup
var random = new Random(21);
var calculationType = random.NextEnumValue <HydraulicBoundaryLocationCalculationType>();
var calculations = new HydraulicBoundaryLocationCalculationsForTargetProbability(random.NextDouble(0, 0.1));
// Call
void Call() => calculations.Create(calculationType, random.Next(), null);
// Assert
var exception = Assert.Throws <ArgumentNullException>(Call);
Assert.AreEqual("registry", exception.ParamName);
}
public void Create_HydraulicLocationCalculationForTargetProbabilitySavedMultipleTimes_ReturnsSameEntity()
{
// Setup
var random = new Random(21);
var calculations = new HydraulicBoundaryLocationCalculationsForTargetProbability(random.NextDouble(0, 0.1));
var registry = new PersistenceRegistry();
// Call
HydraulicLocationCalculationForTargetProbabilityCollectionEntity entityOne =
calculations.Create(random.NextEnumValue <HydraulicBoundaryLocationCalculationType>(), random.Next(), registry);
HydraulicLocationCalculationForTargetProbabilityCollectionEntity entityTwo =
calculations.Create(random.NextEnumValue <HydraulicBoundaryLocationCalculationType>(), random.Next(), registry);
// Assert
Assert.AreSame(entityOne, entityTwo);
}
private static IEnumerable <IObservable> MergeCalculations(
IEnumerable <HydraulicBoundaryLocationCalculationsForTargetProbability> targetCalculations,
IEnumerable <HydraulicBoundaryLocationCalculationsForTargetProbability> sourceCalculations)
{
var changedObjects = new List <IObservable>();
foreach (HydraulicBoundaryLocationCalculationsForTargetProbability sourceCalculationsForTargetProbability in sourceCalculations)
{
HydraulicBoundaryLocationCalculationsForTargetProbability targetCalculationsForTargetProbability = targetCalculations.First(
c => c.TargetProbability.Equals(sourceCalculationsForTargetProbability.TargetProbability));
changedObjects.AddRange(MergeHydraulicBoundaryLocationCalculations(targetCalculationsForTargetProbability.HydraulicBoundaryLocationCalculations,
sourceCalculationsForTargetProbability.HydraulicBoundaryLocationCalculations));
}
return(changedObjects);
}
public void Create_WithValidCollection_ReturnsEntityWithExpectedResults()
{
// Setup
var random = new Random(21);
int order = random.Next();
var calculationType = random.NextEnumValue <HydraulicBoundaryLocationCalculationType>();
var hydraulicBoundaryLocation = new TestHydraulicBoundaryLocation();
var calculation = new HydraulicBoundaryLocationCalculation(hydraulicBoundaryLocation)
{
InputParameters =
{
ShouldIllustrationPointsBeCalculated = random.NextBoolean()
}
};
var calculations = new HydraulicBoundaryLocationCalculationsForTargetProbability(random.NextDouble(0, 0.1))
{
HydraulicBoundaryLocationCalculations =
{
calculation
}
};
var hydraulicLocationEntity = new HydraulicLocationEntity();
var registry = new PersistenceRegistry();
registry.Register(hydraulicLocationEntity, hydraulicBoundaryLocation);
// Call
HydraulicLocationCalculationForTargetProbabilityCollectionEntity entity = calculations.Create(calculationType, order, registry);
// Assert
Assert.IsNotNull(entity);
Assert.AreEqual(order, entity.Order);
Assert.AreEqual(calculations.TargetProbability, entity.TargetProbability);
Assert.AreEqual(Convert.ToByte(calculationType), entity.HydraulicBoundaryLocationCalculationType);
HydraulicLocationCalculationEntity hydraulicLocationCalculationEntity = entity.HydraulicLocationCalculationEntities.Single();
Assert.AreSame(hydraulicLocationEntity, hydraulicLocationCalculationEntity.HydraulicLocationEntity);
Assert.AreEqual(Convert.ToByte(calculation.InputParameters.ShouldIllustrationPointsBeCalculated),
hydraulicLocationCalculationEntity.ShouldIllustrationPointsBeCalculated);
CollectionAssert.IsEmpty(hydraulicLocationCalculationEntity.HydraulicLocationOutputEntities);
}
public void Read_SameHydraulicLocationCalculationForTargetProbabilityCollectionEntityTwice_ReturnsSameHydraulicBoundaryLocationCalculationsForTargetProbability()
{
// Setup
var random = new Random(21);
var collectionEntity = new HydraulicLocationCalculationForTargetProbabilityCollectionEntity
{
TargetProbability = random.NextDouble(0, 0.1)
};
var collector = new ReadConversionCollector();
// Call
HydraulicBoundaryLocationCalculationsForTargetProbability calculationsOne = collectionEntity.Read(collector);
HydraulicBoundaryLocationCalculationsForTargetProbability calculationsTwo = collectionEntity.Read(collector);
// Assert
Assert.AreSame(calculationsOne, calculationsTwo);
}
public void GivenMapLayerWithHydraulicBoundaryLocationsData_WhenCalculationsForUserDefinedTargetProbabilitiesUpdatedAndNotified_ThenMapDataUpdated(
Func <IAssessmentSection, ObservableList <HydraulicBoundaryLocationCalculationsForTargetProbability> > getTargetProbabilitiesFunc)
{
// Given
var mocks = new MockRepository();
var observer = mocks.StrictMock <IObserver>();
observer.Expect(o => o.UpdateObserver());
mocks.ReplayAll();
var hydraulicBoundaryLocation = new HydraulicBoundaryLocation(1, "test1", 1.0, 2.0);
var assessmentSection = new AssessmentSectionStub();
assessmentSection.SetHydraulicBoundaryLocationCalculations(new[]
{
hydraulicBoundaryLocation
});
using (var mapLayer = new HydraulicBoundaryLocationsMapLayer(assessmentSection))
{
ObservableList <HydraulicBoundaryLocationCalculationsForTargetProbability> targetProbabilities = getTargetProbabilitiesFunc(assessmentSection);
var newTargetProbability = new HydraulicBoundaryLocationCalculationsForTargetProbability(0.1);
newTargetProbability.HydraulicBoundaryLocationCalculations.AddRange(assessmentSection.HydraulicBoundaryDatabase.Locations
.Select(l => new HydraulicBoundaryLocationCalculation(l))
.ToArray());
targetProbabilities.Add(newTargetProbability);
targetProbabilities.NotifyObservers();
mapLayer.MapData.Attach(observer);
// Precondition
MapDataTestHelper.AssertHydraulicBoundaryLocationsMapData(assessmentSection, mapLayer.MapData);
// When
HydraulicBoundaryLocationCalculation calculation = newTargetProbability.HydraulicBoundaryLocationCalculations.First();
calculation.Output = new TestHydraulicBoundaryLocationCalculationOutput(new Random(21).NextDouble());
calculation.NotifyObservers();
// Then
MapDataTestHelper.AssertHydraulicBoundaryLocationsMapData(assessmentSection, mapLayer.MapData);
}
mocks.VerifyAll();
}
public void CreateInstance_WithContext_SetsExpectedDataGridViewData()
{
// Setup
var random = new Random();
var calculationsForTargetProbability = new HydraulicBoundaryLocationCalculationsForTargetProbability(0.1)
{
HydraulicBoundaryLocationCalculations =
{
new HydraulicBoundaryLocationCalculation(new TestHydraulicBoundaryLocation())
{
Output = new TestHydraulicBoundaryLocationCalculationOutput(random.NextDouble())
},
new HydraulicBoundaryLocationCalculation(new TestHydraulicBoundaryLocation())
{
Output = new TestHydraulicBoundaryLocationCalculationOutput(random.NextDouble())
}
}
};
var context = new WaterLevelCalculationsForUserDefinedTargetProbabilityContext(calculationsForTargetProbability, new AssessmentSectionStub());
using (var plugin = new RiskeerPlugin())
{
ViewInfo info = GetViewInfo(plugin);
// Call
var view = (DesignWaterLevelCalculationsView)info.CreateInstance(context);
using (var testForm = new Form())
{
testForm.Controls.Add(view);
testForm.Show();
// Assert
DataGridView calculationsDataGridView = ControlTestHelper.GetDataGridView(view, "DataGridView");
DataGridViewRowCollection rows = calculationsDataGridView.Rows;
Assert.AreEqual(2, rows.Count);
Assert.AreEqual(calculationsForTargetProbability.HydraulicBoundaryLocationCalculations[0].Output.Result.ToString(), rows[0].Cells[waterLevelColumnIndex].FormattedValue);
Assert.AreEqual(calculationsForTargetProbability.HydraulicBoundaryLocationCalculations[1].Output.Result.ToString(), rows[1].Cells[waterLevelColumnIndex].FormattedValue);
}
}
}
