public void ContextMenuStrip_WaterLevelCalculationsWithIllustrationPoints_ContextMenuItemClearAllIllustrationPointsEnabledAndTooltipSet(
Func <IAssessmentSection, HydraulicBoundaryLocationCalculation> getHydraulicLocationCalculationFunc)
{
// Setup
var random = new Random(21);
IAssessmentSection assessmentSection = GetConfiguredAssessmentSectionWithHydraulicBoundaryLocationCalculations();
HydraulicBoundaryLocationCalculation calculation = getHydraulicLocationCalculationFunc(assessmentSection);
calculation.Output = new TestHydraulicBoundaryLocationCalculationOutput(random.NextDouble(), new TestGeneralResultSubMechanismIllustrationPoint());
var nodeData = new WaterLevelCalculationsForNormTargetProbabilitiesGroupContext(new ObservableList <HydraulicBoundaryLocation>(), assessmentSection);
var mockRepository = new MockRepository();
using (var treeViewControl = new TreeViewControl())
{
IGui gui = StubFactory.CreateGuiStub(mockRepository);
gui.Stub(cmp => cmp.Get(nodeData, treeViewControl)).Return(new CustomItemsOnlyContextMenuBuilder());
gui.Stub(cmp => cmp.MainWindow).Return(mockRepository.Stub <IMainWindow>());
mockRepository.ReplayAll();
using (var plugin = new RiskeerPlugin())
{
TreeNodeInfo info = GetInfo(plugin);
plugin.Gui = gui;
// Call
using (ContextMenuStrip contextMenu = info.ContextMenuStrip(nodeData, null, treeViewControl))
{
// Assert
ToolStripItem contextMenuItem = contextMenu.Items[contextMenuClearIllustrationPointsIndex];
Assert.AreEqual("Wis alle illustratiepunten...", contextMenuItem.Text);
Assert.AreEqual("Wis alle berekende illustratiepunten.", contextMenuItem.ToolTipText);
TestHelper.AssertImagesAreEqual(RiskeerCommonFormsResources.ClearIllustrationPointsIcon, contextMenuItem.Image);
Assert.IsTrue(contextMenuItem.Enabled);
}
}
}
mockRepository.VerifyAll(); // Expect no calls on arguments
}
/// <summary>
/// Creates a new instance of <see cref="SelectableTargetProbability"/>.
/// </summary>
/// <param name="assessmentSection">The <see cref="IAssessmentSection"/>.</param>
/// <param name="hydraulicBoundaryLocationCalculations">The collection of <see cref="HydraulicBoundaryLocationCalculation"/>.</param>
/// <param name="waterLevelType">The <see cref="WaveConditionsInputWaterLevelType"/> belonging to the <paramref name="hydraulicBoundaryLocationCalculations"/>.</param>
/// <param name="targetProbability">The target probability belonging to the <paramref name="hydraulicBoundaryLocationCalculations"/>.</param>
/// <exception cref="ArgumentNullException">Thrown when <paramref name="assessmentSection"/> or <paramref name="hydraulicBoundaryLocationCalculations"/> is <c>null</c>.</exception>
public SelectableTargetProbability(IAssessmentSection assessmentSection,
IEnumerable <HydraulicBoundaryLocationCalculation> hydraulicBoundaryLocationCalculations,
WaveConditionsInputWaterLevelType waterLevelType, double targetProbability)
{
if (assessmentSection == null)
{
throw new ArgumentNullException(nameof(assessmentSection));
}
if (hydraulicBoundaryLocationCalculations == null)
{
throw new ArgumentNullException(nameof(hydraulicBoundaryLocationCalculations));
}
this.assessmentSection = assessmentSection;
HydraulicBoundaryLocationCalculations = hydraulicBoundaryLocationCalculations;
WaterLevelType = waterLevelType;
TargetProbability = targetProbability;
}
/// <summary>
/// Initializes a new instance of the <see cref="WaveImpactAsphaltCoverContext{T}"/> class.
/// </summary>
/// <param name="wrappedData">The concrete data instance wrapped by this context object.</param>
/// <param name="failureMechanism">The failure mechanism which the context belongs to.</param>
/// <param name="assessmentSection">The assessment section which the context belongs to.</param>
/// <exception cref="ArgumentNullException">Thrown when any input argument is <c>null</c>.</exception>
protected WaveImpactAsphaltCoverContext(
T wrappedData,
WaveImpactAsphaltCoverFailureMechanism failureMechanism,
IAssessmentSection assessmentSection)
: base(wrappedData)
{
if (failureMechanism == null)
{
throw new ArgumentNullException(nameof(failureMechanism));
}
if (assessmentSection == null)
{
throw new ArgumentNullException(nameof(assessmentSection));
}
FailureMechanism = failureMechanism;
AssessmentSection = assessmentSection;
}
public void Run_Always_SetProgressTexts()
{
// Setup
IAssessmentSection assessmentSection = CreateAssessmentSectionWithHydraulicBoundaryOutput();
StabilityStoneCoverWaveConditionsCalculation calculation = CreateValidCalculation(assessmentSection.HydraulicBoundaryDatabase.Locations.First());
CalculatableActivity activity = StabilityStoneCoverWaveConditionsCalculationActivityFactory.CreateCalculationActivity(
calculation,
new StabilityStoneCoverFailureMechanism(),
assessmentSection);
RoundedDouble[] waterLevels = GetWaterLevels(calculation, assessmentSection).ToArray();
var mockRepository = new MockRepository();
var calculatorFactory = mockRepository.StrictMock <IHydraRingCalculatorFactory>();
calculatorFactory.Expect(cf => cf.CreateWaveConditionsCosineCalculator(null))
.IgnoreArguments()
.Return(new TestWaveConditionsCosineCalculator())
.Repeat
.Times(waterLevels.Length * 2);
mockRepository.ReplayAll();
using (new HydraRingCalculatorFactoryConfig(calculatorFactory))
{
var progressTexts = new List <string>();
activity.ProgressChanged += (sender, args) => progressTexts.Add(activity.ProgressText);
// Call
activity.Run();
// Assert
int totalSteps = waterLevels.Length * 2;
for (var i = 0; i < totalSteps; i++)
{
string revetment = i < waterLevels.Length ? "blokken" : "zuilen";
var text = $"Stap {i + 1} van {totalSteps} | Waterstand '{waterLevels[i % waterLevels.Length]}' [m+NAP] voor {revetment} berekenen.";
Assert.AreEqual(text, progressTexts[i]);
}
}
mockRepository.VerifyAll();
}
public void Validate_DistributionVariationCoefficientInvalid_LogsErrorAndReturnsFalse(
double coefficientOne, double coefficientTwo, double coefficientThree, string parameterName)
{
// Setup
var mockRepository = new MockRepository();
IAssessmentSection assessmentSection = AssessmentSectionTestHelper.CreateAssessmentSectionStub(new HeightStructuresFailureMechanism(),
mockRepository,
validHydraulicBoundaryDatabaseFilePath);
mockRepository.ReplayAll();
string expectedValidationMessage = $"De variatiecoëfficiënt voor '{parameterName}' moet groter zijn dan of gelijk zijn aan 0.";
var calculation = new TestHeightStructuresCalculationScenario
{
InputParameters =
{
HydraulicBoundaryLocation = new HydraulicBoundaryLocation(1, "name", 2, 2)
}
};
calculation.InputParameters.StormDuration.CoefficientOfVariation = (RoundedDouble)coefficientOne;
calculation.InputParameters.StorageStructureArea.CoefficientOfVariation = (RoundedDouble)coefficientTwo;
calculation.InputParameters.CriticalOvertoppingDischarge.CoefficientOfVariation = (RoundedDouble)coefficientThree;
// Call
var isValid = false;
Action call = () => isValid = HeightStructuresCalculationService.Validate(calculation, assessmentSection);
// Assert
TestHelper.AssertLogMessages(call, messages =>
{
string[] msgs = messages.ToArray();
Assert.AreEqual(3, msgs.Length);
CalculationServiceTestHelper.AssertValidationStartMessage(msgs[0]);
Assert.AreEqual(expectedValidationMessage, msgs[1]);
CalculationServiceTestHelper.AssertValidationEndMessage(msgs[2]);
});
Assert.IsFalse(isValid);
mockRepository.VerifyAll();
}
public void Calculate_HydraulicBoundaryDatabaseWithUsePreprocessorFalse_ExpectedPreprocessorDirectorySetToCalculator()
{
// Setup
IAssessmentSection assessmentSection = CreateAssessmentSectionWithHydraulicBoundaryOutput();
assessmentSection.HydraulicBoundaryDatabase.HydraulicLocationConfigurationSettings.CanUsePreprocessor = true;
assessmentSection.HydraulicBoundaryDatabase.HydraulicLocationConfigurationSettings.UsePreprocessor = false;
assessmentSection.HydraulicBoundaryDatabase.HydraulicLocationConfigurationSettings.PreprocessorDirectory = "InvalidPreprocessorDirectory";
WaveImpactAsphaltCoverWaveConditionsCalculation calculation = GetValidCalculation(assessmentSection.HydraulicBoundaryDatabase.Locations.First());
var waveImpactAsphaltCoverFailureMechanism = new WaveImpactAsphaltCoverFailureMechanism();
var calculator = new TestWaveConditionsCosineCalculator();
var mockRepository = new MockRepository();
var calculatorFactory = mockRepository.StrictMock <IHydraRingCalculatorFactory>();
calculatorFactory.Expect(cf => cf.CreateWaveConditionsCosineCalculator(Arg <HydraRingCalculationSettings> .Is.NotNull))
.WhenCalled(invocation =>
{
HydraRingCalculationSettingsTestHelper.AssertHydraRingCalculationSettings(
HydraulicBoundaryCalculationSettingsFactory.CreateSettings(assessmentSection.HydraulicBoundaryDatabase),
(HydraRingCalculationSettings)invocation.Arguments[0]);
})
.Return(calculator)
.Repeat
.Times(3);
mockRepository.ReplayAll();
using (new HydraRingCalculatorFactoryConfig(calculatorFactory))
{
// Call
new WaveImpactAsphaltCoverWaveConditionsCalculationService().Calculate(
calculation,
assessmentSection,
waveImpactAsphaltCoverFailureMechanism.GeneralInput);
}
// Assert
mockRepository.VerifyAll();
}
/// <summary>
/// Gets the assessment level to use during wave conditions calculations based on the provided <paramref name="input"/>.
/// </summary>
/// <param name="input">The wave conditions input to get the assessment level for.</param>
/// <param name="assessmentSection">The assessment section the wave conditions input belongs to.</param>
/// <returns>An assessment level, or <see cref="RoundedDouble.NaN"/> when:
/// <list type="bullet">
/// <item><see cref="WaveConditionsInput.WaterLevelType"/> equals <see cref="WaveConditionsInputWaterLevelType.None"/>;</item>
/// <item><see cref="WaveConditionsInput.HydraulicBoundaryLocation"/> equals <c>null</c>;</item>
/// <item>no assessment level is calculated door the selected <see cref="WaveConditionsInput.HydraulicBoundaryLocation"/>.</item>
/// </list>
/// </returns>
/// <exception cref="ArgumentNullException">Thrown when any input parameter is <c>null</c>.</exception>
/// <exception cref="InvalidEnumArgumentException">Thrown when <see cref="WaveConditionsInput.WaterLevelType"/>
/// is an invalid value.</exception>
/// <exception cref="NotSupportedException">Thrown when <see cref="WaveConditionsInput.WaterLevelType"/>
/// is a valid value, but unsupported.</exception>
public static RoundedDouble GetAssessmentLevel(WaveConditionsInput input, IAssessmentSection assessmentSection)
{
if (input == null)
{
throw new ArgumentNullException(nameof(input));
}
if (assessmentSection == null)
{
throw new ArgumentNullException(nameof(assessmentSection));
}
if (!Enum.IsDefined(typeof(WaveConditionsInputWaterLevelType), input.WaterLevelType))
{
throw new InvalidEnumArgumentException(nameof(input.WaterLevelType),
(int)input.WaterLevelType,
typeof(WaveConditionsInputWaterLevelType));
}
if (input.HydraulicBoundaryLocation == null)
{
return(RoundedDouble.NaN);
}
switch (input.WaterLevelType)
{
case WaveConditionsInputWaterLevelType.None:
return(RoundedDouble.NaN);
case WaveConditionsInputWaterLevelType.MaximumAllowableFloodingProbability:
return(GetAssessmentLevelFromHydraulicBoundaryLocationCalculations(assessmentSection.WaterLevelCalculationsForMaximumAllowableFloodingProbability, input));
case WaveConditionsInputWaterLevelType.SignalFloodingProbability:
return(GetAssessmentLevelFromHydraulicBoundaryLocationCalculations(assessmentSection.WaterLevelCalculationsForSignalFloodingProbability, input));
case WaveConditionsInputWaterLevelType.UserDefinedTargetProbability:
return(GetAssessmentLevelFromHydraulicBoundaryLocationCalculations(input.CalculationsTargetProbability.HydraulicBoundaryLocationCalculations, input));
default:
throw new NotSupportedException();
}
}
public void CreateInstance_WithContext_ReturnsView()
{
// Setup
var failureMechanism = new HeightStructuresFailureMechanism();
var mocks = new MockRepository();
IAssessmentSection assessmentSection = AssessmentSectionTestHelper.CreateAssessmentSectionStub(failureMechanism, mocks);
mocks.ReplayAll();
var context = new HeightStructuresFailureMechanismSectionResultContext(
failureMechanism.SectionResults, failureMechanism, assessmentSection);
// Call
IView view = info.CreateInstance(context);
// Assert
Assert.IsInstanceOf <StructuresFailureMechanismResultView <HeightStructuresFailureMechanism, HeightStructuresInput> >(view);
mocks.VerifyAll();
}
/// <summary>
/// Creates a collection of <see cref="CalculatableActivity"/> based on <paramref name="failureMechanism"/>.
/// </summary>
/// <param name="failureMechanism">The failure mechanism to create activities for.</param>
/// <param name="assessmentSection">The assessment section the failure mechanism belongs to.</param>
/// <returns>A collection of <see cref="CalculatableActivity"/>.</returns>
/// <exception cref="ArgumentNullException">Thrown when <paramref name="failureMechanism"/> or
/// <paramref name="assessmentSection"/> is <c>null</c>.</exception>
public static IEnumerable <CalculatableActivity> CreateCalculationActivities(DuneErosionFailureMechanism failureMechanism,
IAssessmentSection assessmentSection)
{
if (failureMechanism == null)
{
throw new ArgumentNullException(nameof(failureMechanism));
}
if (assessmentSection == null)
{
throw new ArgumentNullException(nameof(assessmentSection));
}
return(failureMechanism.DuneLocationCalculationsForUserDefinedTargetProbabilities
.SelectMany(dlc => CreateCalculationActivities(dlc.DuneLocationCalculations,
assessmentSection,
dlc.TargetProbability,
noProbabilityValueDoubleConverter.ConvertToString(dlc.TargetProbability)))
.ToList());
}
public void CloseForData_ViewCorrespondingToRemovedAssessmentSection_ReturnsTrue()
{
// Setup
var mocks = new MockRepository();
IAssessmentSection assessmentSection = AssessmentSectionTestHelper.CreateAssessmentSectionStub(null, mocks);
mocks.ReplayAll();
using (new AssemblyToolCalculatorFactoryConfig())
using (var view = new AssessmentSectionAssemblyGroupsView(assessmentSection.FailureMechanismContribution))
{
// Call
bool closeForData = info.CloseForData(view, assessmentSection);
// Assert
Assert.IsTrue(closeForData);
}
mocks.VerifyAll();
}
/// <summary>
/// Creates a <see cref="CalculatableActivity"/> based on the provided <paramref name="calculation"/>.
/// </summary>
/// <param name="calculation">The calculation to create a <see cref="CalculatableActivity"/> for.</param>
/// <param name="failureMechanism">The failure mechanism the <paramref name="calculation"/> belongs to.</param>
/// <param name="assessmentSection">The assessment section the <paramref name="calculation"/> belongs to.</param>
/// <returns>A <see cref="CalculatableActivity"/>.</returns>
/// <exception cref="NotSupportedException">Thrown when <see cref="calculation"/> is of a type that is not supported.</exception>
private static CalculatableActivity CreateCalculationActivity(IPipingCalculation <PipingInput> calculation,
PipingFailureMechanism failureMechanism,
IAssessmentSection assessmentSection)
{
switch (calculation)
{
case SemiProbabilisticPipingCalculation semiProbabilisticPipingCalculation:
return(CreateSemiProbabilisticPipingCalculationActivity(semiProbabilisticPipingCalculation,
failureMechanism.GeneralInput,
assessmentSection));
case ProbabilisticPipingCalculation probabilisticPipingCalculation:
return(CreateProbabilisticPipingCalculationActivity(probabilisticPipingCalculation,
failureMechanism,
assessmentSection));
default:
throw new NotSupportedException();
}
}
public void ContextMenuStrip_HydraulicBoundaryDatabaseLinkedToInvalidFile_ContextMenuItemCalculateAllAndValidateAllDisabledAndTooltipSet()
{
// Setup
var failureMechanism = new ClosingStructuresFailureMechanism();
failureMechanism.CalculationsGroup.Children.Add(new StructuresCalculation <ClosingStructuresInput>());
IAssessmentSection assessmentSection = AssessmentSectionTestHelper.CreateAssessmentSectionStub(null, mocksRepository, "invalidFilePath");
var nodeData = new ClosingStructuresFailureMechanismContext(failureMechanism, assessmentSection);
var menuBuilder = new CustomItemsOnlyContextMenuBuilder();
using (var treeViewControl = new TreeViewControl())
{
var gui = mocksRepository.Stub <IGui>();
gui.Stub(g => g.Get(nodeData, treeViewControl)).Return(menuBuilder);
gui.Stub(g => g.MainWindow).Return(mocksRepository.Stub <IMainWindow>());
mocksRepository.ReplayAll();
plugin.Gui = gui;
// Call
using (ContextMenuStrip contextMenu = info.ContextMenuStrip(nodeData, null, treeViewControl))
{
// Assert
ToolStripItem calculateAllContextMenuItem = contextMenu.Items[contextMenuCalculateAllIndex];
Assert.AreEqual("Alles be&rekenen", calculateAllContextMenuItem.Text);
StringAssert.Contains("Herstellen van de verbinding met de hydraulische belastingendatabase is mislukt. ", calculateAllContextMenuItem.ToolTipText);
TestHelper.AssertImagesAreEqual(RiskeerCommonFormsResources.CalculateAllIcon, calculateAllContextMenuItem.Image);
Assert.IsFalse(calculateAllContextMenuItem.Enabled);
ToolStripItem validateAllContextMenuItem = contextMenu.Items[contextMenuValidateAllIndex];
Assert.AreEqual("Alles &valideren", validateAllContextMenuItem.Text);
StringAssert.Contains("Herstellen van de verbinding met de hydraulische belastingendatabase is mislukt. ", validateAllContextMenuItem.ToolTipText);
TestHelper.AssertImagesAreEqual(RiskeerCommonFormsResources.ValidateAllIcon, validateAllContextMenuItem.Image);
Assert.IsFalse(validateAllContextMenuItem.Enabled);
}
}
}
public void ContextMenuStrip_WithContext_CallsContextMenuBuilderMethods()
{
// Setup
var failureMechanism = new DuneErosionFailureMechanism();
IAssessmentSection assessmentSection = AssessmentSectionTestHelper.CreateAssessmentSectionStub(mocksRepository);
var context = new DuneErosionFailureMechanismContext(failureMechanism, assessmentSection);
var orderMocksRepository = new MockRepository();
var menuBuilder = orderMocksRepository.StrictMock <IContextMenuBuilder>();
using (orderMocksRepository.Ordered())
{
menuBuilder.Expect(mb => mb.AddOpenItem()).Return(menuBuilder);
menuBuilder.Expect(mb => mb.AddSeparator()).Return(menuBuilder);
menuBuilder.Expect(mb => mb.AddCustomItem(null)).IgnoreArguments().Return(menuBuilder);
menuBuilder.Expect(mb => mb.AddSeparator()).Return(menuBuilder);
menuBuilder.Expect(mb => mb.AddCollapseAllItem()).Return(menuBuilder);
menuBuilder.Expect(mb => mb.AddExpandAllItem()).Return(menuBuilder);
menuBuilder.Expect(mb => mb.AddSeparator()).Return(menuBuilder);
menuBuilder.Expect(mb => mb.AddPropertiesItem()).Return(menuBuilder);
menuBuilder.Expect(mb => mb.Build()).Return(null);
}
orderMocksRepository.ReplayAll();
using (var treeViewControl = new TreeViewControl())
{
var gui = mocksRepository.Stub <IGui>();
gui.Stub(cmp => cmp.Get(context, treeViewControl)).Return(menuBuilder);
gui.Stub(g => g.ViewHost).Return(mocksRepository.Stub <IViewHost>());
mocksRepository.ReplayAll();
plugin.Gui = gui;
// Call
info.ContextMenuStrip(context, null, treeViewControl);
}
// Assert
orderMocksRepository.VerifyAll();
}
public void Run_WhenCanceled_OutputNull()
{
// Setup
IAssessmentSection assessmentSection = CreateAssessmentSectionWithHydraulicBoundaryOutput();
StabilityStoneCoverWaveConditionsCalculation calculation = CreateValidCalculation(assessmentSection.HydraulicBoundaryDatabase.Locations.First());
CalculatableActivity activity = StabilityStoneCoverWaveConditionsCalculationActivityFactory.CreateCalculationActivity(
calculation,
new StabilityStoneCoverFailureMechanism(),
assessmentSection);
var mockRepository = new MockRepository();
var calculatorFactory = mockRepository.StrictMock <IHydraRingCalculatorFactory>();
calculatorFactory.Expect(cf => cf.CreateWaveConditionsCosineCalculator(null))
.IgnoreArguments()
.Return(new TestWaveConditionsCosineCalculator());
mockRepository.ReplayAll();
using (new HydraRingCalculatorFactoryConfig(calculatorFactory))
{
activity.ProgressChanged += (sender, args) =>
{
if (activity.State != ActivityState.Canceled)
{
activity.Cancel();
}
};
activity.Run();
// Call
activity.Finish();
// Assert
Assert.AreEqual(ActivityState.Canceled, activity.State);
Assert.IsNull(calculation.Output);
}
mockRepository.VerifyAll();
}
public void Validate_NormalDistributionMeanInvalid_LogsErrorAndReturnsFalse(double meanOne, double meanTwo, double meanThree, string parameterName)
{
// Setup
var mockRepository = new MockRepository();
IAssessmentSection assessmentSection = AssessmentSectionTestHelper.CreateAssessmentSectionStub(new HeightStructuresFailureMechanism(),
mockRepository,
validHydraulicBoundaryDatabaseFilePath);
mockRepository.ReplayAll();
string expectedValidationMessage = $"De verwachtingswaarde voor '{parameterName}' moet een concreet getal zijn.";
var calculation = new TestHeightStructuresCalculationScenario
{
InputParameters =
{
HydraulicBoundaryLocation = new HydraulicBoundaryLocation(1, "name", 2, 2)
}
};
calculation.InputParameters.ModelFactorSuperCriticalFlow.Mean = (RoundedDouble)meanOne;
calculation.InputParameters.LevelCrestStructure.Mean = (RoundedDouble)meanTwo;
calculation.InputParameters.WidthFlowApertures.Mean = (RoundedDouble)meanThree;
// Call
var isValid = false;
Action call = () => isValid = HeightStructuresCalculationService.Validate(calculation, assessmentSection);
// Assert
TestHelper.AssertLogMessages(call, messages =>
{
string[] msgs = messages.ToArray();
Assert.AreEqual(3, msgs.Length);
CalculationServiceTestHelper.AssertValidationStartMessage(msgs[0]);
Assert.AreEqual(expectedValidationMessage, msgs[1]);
CalculationServiceTestHelper.AssertValidationEndMessage(msgs[2]);
});
Assert.IsFalse(isValid);
mockRepository.VerifyAll();
}
public void GivenScenarioRow_WhenOutputSetToNullAndUpdate_ThenDerivedOutputUpdated()
{
// Given
var failureMechanism = new PipingFailureMechanism();
var mocks = new MockRepository();
IAssessmentSection assessmentSection = AssessmentSectionTestHelper.CreateAssessmentSectionStub(failureMechanism, mocks);
mocks.ReplayAll();
var calculation = new SemiProbabilisticPipingCalculationScenario
{
Output = PipingTestDataGenerator.GetRandomSemiProbabilisticPipingOutput()
};
FailureMechanismSection failureMechanismSection = FailureMechanismSectionTestFactory.CreateFailureMechanismSection();
var row = new SemiProbabilisticPipingScenarioRow(calculation, failureMechanism, failureMechanismSection, assessmentSection);
// Precondition
DerivedSemiProbabilisticPipingOutput expectedDerivedOutput = DerivedSemiProbabilisticPipingOutputFactory.Create(calculation.Output, assessmentSection.FailureMechanismContribution.NormativeProbability);
Assert.AreEqual(expectedDerivedOutput.PipingProbability, row.FailureProbability);
Assert.AreEqual(expectedDerivedOutput.UpliftProbability, row.FailureProbabilityUplift);
Assert.AreEqual(expectedDerivedOutput.HeaveProbability, row.FailureProbabilityHeave);
Assert.AreEqual(expectedDerivedOutput.SellmeijerProbability, row.FailureProbabilitySellmeijer);
Assert.AreEqual(expectedDerivedOutput.PipingProbability * failureMechanism.PipingProbabilityAssessmentInput.GetN(
failureMechanismSection.Length),
row.SectionFailureProbability);
// When
calculation.Output = null;
row.Update();
// Then
Assert.IsNaN(row.FailureProbability);
Assert.IsNaN(row.FailureProbabilityUplift);
Assert.IsNaN(row.FailureProbabilityHeave);
Assert.IsNaN(row.FailureProbabilitySellmeijer);
Assert.IsNaN(row.SectionFailureProbability);
mocks.VerifyAll();
}
public void ContextMenuStrip_HydraulicBoundaryDatabaseNotLinked_ContextMenuItemCalculateAllAndValidateAllDisabledAndTooltipSet()
{
// Setup
var failureMechanism = new StabilityPointStructuresFailureMechanism();
failureMechanism.CalculationsGroup.Children.Add(new StructuresCalculation <StabilityPointStructuresInput>());
IAssessmentSection assessmentSection = AssessmentSectionTestHelper.CreateAssessmentSectionStub(mocksRepository);
var nodeData = new StabilityPointStructuresFailureMechanismContext(failureMechanism, assessmentSection);
var menuBuilder = new CustomItemsOnlyContextMenuBuilder();
using (var plugin = new StabilityPointStructuresPlugin())
using (var treeViewControl = new TreeViewControl())
{
var gui = mocksRepository.Stub <IGui>();
gui.Stub(g => g.Get(nodeData, treeViewControl)).Return(menuBuilder);
gui.Stub(g => g.MainWindow).Return(mocksRepository.Stub <IMainWindow>());
mocksRepository.ReplayAll();
TreeNodeInfo info = GetInfo(plugin);
plugin.Gui = gui;
// Call
using (ContextMenuStrip contextMenu = info.ContextMenuStrip(nodeData, null, treeViewControl))
{
// Assert
TestHelper.AssertContextMenuStripContainsItem(contextMenu, contextMenuCalculateAllIndex,
"Alles be&rekenen",
"Er is geen hydraulische belastingendatabase geïmporteerd.",
RiskeerCommonFormsResources.CalculateAllIcon,
false);
TestHelper.AssertContextMenuStripContainsItem(contextMenu, contextMenuValidateAllIndex,
"Alles &valideren",
"Er is geen hydraulische belastingendatabase geïmporteerd.",
RiskeerCommonFormsResources.ValidateAllIcon,
false);
}
}
}
public void Validate_ValidInputWithUseProcessorTrue_ReturnsTrue()
{
// Setup
var mocks = new MockRepository();
IAssessmentSection assessmentSection = AssessmentSectionTestHelper.CreateAssessmentSectionStub(
new TestCalculatableFailureMechanism(), mocks, validHydraulicBoundaryDatabaseFilePath);
assessmentSection.HydraulicBoundaryDatabase.HydraulicLocationConfigurationSettings.CanUsePreprocessor = true;
assessmentSection.HydraulicBoundaryDatabase.HydraulicLocationConfigurationSettings.UsePreprocessor = true;
assessmentSection.HydraulicBoundaryDatabase.HydraulicLocationConfigurationSettings.PreprocessorDirectory = TestHelper.GetScratchPadPath();
mocks.ReplayAll();
var calculation = new TestStructuresCalculation
{
InputParameters =
{
Structure = new TestStructure(),
HydraulicBoundaryLocation = new TestHydraulicBoundaryLocation(),
IsValid = true
}
};
var isValid = false;
// Call
void Call() => isValid = TestStructuresCalculationService.Validate(calculation, assessmentSection);
// Assert
TestHelper.AssertLogMessages(Call, messages =>
{
string[] msgs = messages.ToArray();
Assert.AreEqual(2, msgs.Length);
CalculationServiceTestHelper.AssertValidationStartMessage(msgs[0]);
CalculationServiceTestHelper.AssertValidationEndMessage(msgs[1]);
});
Assert.IsTrue(isValid);
mocks.VerifyAll();
}
/// <summary>
/// Creates a new instance of <see cref="WaveHeightCalculationsView"/>.
/// </summary>
/// <param name="calculations">The calculations to show in the view.</param>
/// <param name="assessmentSection">The assessment section which the calculations belong to.</param>
/// <param name="getTargetProbabilityFunc"><see cref="Func{TResult}"/> for getting the target probability to use during calculations.</param>
/// <param name="getCalculationIdentifierFunc"><see cref="Func{TResult}"/> for getting the calculation identifier to use in all messages.</param>
/// <exception cref="ArgumentNullException">Thrown when any parameter is <c>null</c>.</exception>
public WaveHeightCalculationsView(IObservableEnumerable <HydraulicBoundaryLocationCalculation> calculations,
IAssessmentSection assessmentSection,
Func <double> getTargetProbabilityFunc,
Func <string> getCalculationIdentifierFunc)
: base(calculations, assessmentSection)
{
if (getTargetProbabilityFunc == null)
{
throw new ArgumentNullException(nameof(getTargetProbabilityFunc));
}
if (getCalculationIdentifierFunc == null)
{
throw new ArgumentNullException(nameof(getCalculationIdentifierFunc));
}
InitializeComponent();
this.getTargetProbabilityFunc = getTargetProbabilityFunc;
this.getCalculationIdentifierFunc = getCalculationIdentifierFunc;
}
/// <summary>
/// Assembles the section based on the input arguments.
/// </summary>
/// <param name="sectionResult">The section result to assemble.</param>
/// <param name="failureMechanism">The <see cref="GrassCoverErosionOutwardsFailureMechanism"/> the section result belongs to.</param>
/// <param name="assessmentSection">The <see cref="IAssessmentSection"/> the section belongs to.</param>
/// <returns>A <see cref="FailureMechanismSectionAssemblyResultWrapper"/>.</returns>
/// <exception cref="ArgumentNullException">Thrown when any argument is <c>null</c>.</exception>
/// <exception cref="AssemblyException">Thrown when the section could not be assembled.</exception>
public static FailureMechanismSectionAssemblyResultWrapper AssembleSection(NonAdoptableWithProfileProbabilityFailureMechanismSectionResult sectionResult,
GrassCoverErosionOutwardsFailureMechanism failureMechanism,
IAssessmentSection assessmentSection)
{
if (sectionResult == null)
{
throw new ArgumentNullException(nameof(sectionResult));
}
if (failureMechanism == null)
{
throw new ArgumentNullException(nameof(failureMechanism));
}
if (assessmentSection == null)
{
throw new ArgumentNullException(nameof(assessmentSection));
}
return(FailureMechanismSectionAssemblyResultFactory.AssembleSection(sectionResult, assessmentSection, failureMechanism.GeneralInput.ApplyLengthEffectInSection));
}
/// <summary>
/// Creates a new instance of <see cref="GrassCoverErosionInwardsFailureMechanismResultView"/>.
/// </summary>
/// <param name="failureMechanismSectionResults">The collection of
/// <see cref="AdoptableWithProfileProbabilityFailureMechanismSectionResult"/> to show in the view.</param>
/// <param name="failureMechanism">The failure mechanism the results belong to.</param>
/// <param name="assessmentSection">The assessment section the failure mechanism results belong to.</param>
/// <exception cref="ArgumentNullException">Thrown when any parameter is <c>null</c>.</exception>
public GrassCoverErosionInwardsFailureMechanismResultView(IObservableEnumerable <AdoptableWithProfileProbabilityFailureMechanismSectionResult> failureMechanismSectionResults,
GrassCoverErosionInwardsFailureMechanism failureMechanism,
IAssessmentSection assessmentSection)
: base(failureMechanismSectionResults, failureMechanism, assessmentSection, GrassCoverErosionInwardsFailureMechanismAssemblyFactory.AssembleFailureMechanism)
{
// The concat is needed to observe the input of calculations in child groups.
calculationInputsObserver = new RecursiveObserver <CalculationGroup, ICalculationInput>(
UpdateInternalViewData,
cg => cg.Children.Concat <object>(cg.Children
.OfType <GrassCoverErosionInwardsCalculationScenario>()
.Select(c => c.InputParameters)))
{
Observable = failureMechanism.CalculationsGroup
};
calculationGroupObserver = new RecursiveObserver <CalculationGroup, ICalculationBase>(
UpdateInternalViewData,
c => c.Children)
{
Observable = failureMechanism.CalculationsGroup
};
}
public void CreateInstance_WithContext_SetsExpectedViewProperties()
{
// Setup
var mocks = new MockRepository();
IAssessmentSection assessmentSection = AssessmentSectionTestHelper.CreateAssessmentSectionStub(null, mocks);
mocks.ReplayAll();
var context = new AssessmentSectionAssemblyGroupsContext(assessmentSection);
using (new AssemblyToolCalculatorFactoryConfig())
{
// Call
var view = (AssessmentSectionAssemblyGroupsView)info.CreateInstance(context);
// Assert
Assert.AreSame(assessmentSection.FailureMechanismContribution, view.FailureMechanismContribution);
}
mocks.VerifyAll();
}
/// <summary>
/// Assembles a failure mechanism section result based on the input arguments.
/// </summary>
/// <param name="sectionResult">The section result to assemble for.</param>
/// <param name="assessmentSection">The <see cref="IAssessmentSection"/> to assemble with.</param>
/// <returns>A <see cref="FailureMechanismSectionAssemblyResultWrapper"/>.</returns>
/// <exception cref="ArgumentNullException">Thrown when any parameter is <c>null</c>.</exception>
/// <exception cref="AssemblyException">Thrown when the section could not be successfully assembled.</exception>
public static FailureMechanismSectionAssemblyResultWrapper AssembleSection(
NonAdoptableFailureMechanismSectionResult sectionResult, IAssessmentSection assessmentSection)
{
if (sectionResult == null)
{
throw new ArgumentNullException(nameof(sectionResult));
}
if (assessmentSection == null)
{
throw new ArgumentNullException(nameof(assessmentSection));
}
bool hasProbabilitySpecified = sectionResult.InitialFailureMechanismResultType != NonAdoptableInitialFailureMechanismResultType.NoFailureProbability;
FailureMechanismSectionAssemblyInput input = CreateInput(
assessmentSection, sectionResult.IsRelevant, sectionResult.ManualInitialFailureMechanismResultSectionProbability,
sectionResult.FurtherAnalysisType, sectionResult.RefinedSectionProbability, hasProbabilitySpecified);
return(PerformAssembly(input));
}
public void CreateInstance_ValidData_NewPropertiesWithPipingOutputAsData()
{
// Setup
var failureMechanism = new PipingFailureMechanism();
var mocks = new MockRepository();
IAssessmentSection assessmentSection = AssessmentSectionTestHelper.CreateAssessmentSectionStub(failureMechanism, mocks);
mocks.ReplayAll();
SemiProbabilisticPipingOutput output = PipingTestDataGenerator.GetRandomSemiProbabilisticPipingOutput();
var context = new SemiProbabilisticPipingOutputContext(output, failureMechanism, assessmentSection);
// Call
IObjectProperties objectProperties = info.CreateInstance(context);
// Assert
Assert.IsInstanceOf <SemiProbabilisticPipingOutputProperties>(objectProperties);
Assert.AreSame(output, objectProperties.Data);
mocks.VerifyAll();
}
public void Validate_StructureNormalOrientationInvalid_ReturnsFalse()
{
// Setup
var mockRepository = new MockRepository();
IAssessmentSection assessmentSection = AssessmentSectionTestHelper.CreateAssessmentSectionStub(new HeightStructuresFailureMechanism(),
mockRepository,
validHydraulicBoundaryDatabaseFilePath);
mockRepository.ReplayAll();
const string expectedValidationMessage = "De waarde voor 'Oriëntatie' moet een concreet getal zijn.";
var calculation = new TestHeightStructuresCalculationScenario
{
InputParameters =
{
HydraulicBoundaryLocation = new HydraulicBoundaryLocation(1, "name", 2, 2),
Structure = new TestHeightStructure()
}
};
calculation.InputParameters.StructureNormalOrientation = RoundedDouble.NaN;
// Call
var isValid = false;
Action call = () => isValid = HeightStructuresCalculationService.Validate(calculation, assessmentSection);
// Assert
TestHelper.AssertLogMessages(call, messages =>
{
string[] msgs = messages.ToArray();
Assert.AreEqual(3, msgs.Length);
CalculationServiceTestHelper.AssertValidationStartMessage(msgs[0]);
Assert.AreEqual(expectedValidationMessage, msgs[1]);
CalculationServiceTestHelper.AssertValidationEndMessage(msgs[2]);
});
Assert.IsFalse(isValid);
mockRepository.VerifyAll();
}
public void ContextMenuStrip_Always_CallsBuilder()
{
// Setup
using (var treeViewControl = new TreeViewControl())
{
IAssessmentSection assessmentSection = AssessmentSectionTestHelper.CreateAssessmentSectionStub(mocks);
var context = new DuneLocationCalculationsForUserDefinedTargetProbabilityContext(new DuneLocationCalculationsForTargetProbability(0.1),
new DuneErosionFailureMechanism(),
assessmentSection);
var menuBuilder = mocks.StrictMock <IContextMenuBuilder>();
using (mocks.Ordered())
{
menuBuilder.Expect(mb => mb.AddOpenItem()).Return(menuBuilder);
menuBuilder.Expect(mb => mb.AddSeparator()).Return(menuBuilder);
menuBuilder.Expect(mb => mb.AddExportItem()).Return(menuBuilder);
menuBuilder.Expect(mb => mb.AddSeparator()).Return(menuBuilder);
menuBuilder.Expect(mb => mb.AddCustomItem(null)).IgnoreArguments().Return(menuBuilder);
menuBuilder.Expect(mb => mb.AddSeparator()).Return(menuBuilder);
menuBuilder.Expect(mb => mb.AddDeleteItem()).Return(menuBuilder);
menuBuilder.Expect(mb => mb.AddSeparator()).Return(menuBuilder);
menuBuilder.Expect(mb => mb.AddPropertiesItem()).Return(menuBuilder);
menuBuilder.Expect(mb => mb.Build()).Return(null);
}
var gui = mocks.Stub <IGui>();
gui.Stub(cmp => cmp.Get(context, treeViewControl)).Return(menuBuilder);
gui.Stub(g => g.ViewHost).Return(mocks.Stub <IViewHost>());
mocks.ReplayAll();
plugin.Gui = gui;
// Call
info.ContextMenuStrip(context, null, treeViewControl);
}
// Assert
// Done in tearDown
}
public void Calculate_Always_SendsProgressNotifications()
{
// Setup
IAssessmentSection assessmentSection = CreateAssessmentSectionWithHydraulicBoundaryOutput();
WaveImpactAsphaltCoverWaveConditionsCalculation calculation = GetValidCalculation(assessmentSection.HydraulicBoundaryDatabase.Locations.First());
var failureMechanism = new WaveImpactAsphaltCoverFailureMechanism();
var mockRepository = new MockRepository();
var calculatorFactory = mockRepository.Stub <IHydraRingCalculatorFactory>();
RoundedDouble[] waterLevels = GetWaterLevels(calculation, assessmentSection).ToArray();
calculatorFactory.Stub(cf => cf.CreateWaveConditionsCosineCalculator(null))
.IgnoreArguments()
.Return(new TestWaveConditionsCosineCalculator());
mockRepository.ReplayAll();
int nrOfCalculators = waterLevels.Length;
using (new HydraRingCalculatorFactoryConfig(calculatorFactory))
{
var currentStep = 1;
var stabilityStoneCoverWaveConditionsCalculationService = new WaveImpactAsphaltCoverWaveConditionsCalculationService();
stabilityStoneCoverWaveConditionsCalculationService.OnProgressChanged += (description, step, steps) =>
{
// Assert
var text = $"Waterstand '{waterLevels[(step - 1) % waterLevels.Length]}' [m+NAP] voor asfalt berekenen.";
Assert.AreEqual(text, description);
Assert.AreEqual(currentStep++, step);
Assert.AreEqual(nrOfCalculators, steps);
};
// Call
stabilityStoneCoverWaveConditionsCalculationService.Calculate(calculation,
assessmentSection,
failureMechanism.GeneralInput);
}
mockRepository.VerifyAll();
}
public void Finish_VariousCalculationEndStates_NotifiesObserversOfCalculation(bool endInFailure)
{
// Setup
var mockRepository = new MockRepository();
var observer = mockRepository.StrictMock <IObserver>();
observer.Expect(o => o.UpdateObserver());
var calculatorFactory = mockRepository.Stub <IHydraRingCalculatorFactory>();
calculatorFactory.Stub(cf => cf.CreateWaveConditionsCosineCalculator(null))
.IgnoreArguments()
.Return(new TestWaveConditionsCosineCalculator
{
EndInFailure = endInFailure
});
mockRepository.ReplayAll();
IAssessmentSection assessmentSection = CreateAssessmentSectionWithHydraulicBoundaryOutput();
StabilityStoneCoverWaveConditionsCalculation calculation = CreateValidCalculation(assessmentSection.HydraulicBoundaryDatabase.Locations.First());
calculation.Attach(observer);
CalculatableActivity activity = StabilityStoneCoverWaveConditionsCalculationActivityFactory.CreateCalculationActivity(
calculation,
new StabilityStoneCoverFailureMechanism(),
assessmentSection);
using (new HydraRingCalculatorFactoryConfig(calculatorFactory))
{
activity.Run();
}
// Call
activity.Finish();
// Assert
mockRepository.VerifyAll();
}
public void Run_CalculationWithInvalidPreprocessorDirectory_DoesNotPerformCalculationAndLogsError()
{
// Setup
IAssessmentSection assessmentSection = CreateAssessmentSectionWithHydraulicBoundaryOutput();
StabilityStoneCoverWaveConditionsCalculation calculation = CreateValidCalculation(assessmentSection.HydraulicBoundaryDatabase.Locations.First());
assessmentSection.HydraulicBoundaryDatabase.HydraulicLocationConfigurationSettings.CanUsePreprocessor = true;
assessmentSection.HydraulicBoundaryDatabase.HydraulicLocationConfigurationSettings.UsePreprocessor = true;
assessmentSection.HydraulicBoundaryDatabase.HydraulicLocationConfigurationSettings.PreprocessorDirectory = "InvalidPreprocessorDirectory";
CalculatableActivity activity = StabilityStoneCoverWaveConditionsCalculationActivityFactory.CreateCalculationActivity(
calculation,
new StabilityStoneCoverFailureMechanism(),
assessmentSection);
var mockRepository = new MockRepository();
var calculatorFactory = mockRepository.StrictMock <IHydraRingCalculatorFactory>();
mockRepository.ReplayAll();
using (new HydraRingCalculatorFactoryConfig(calculatorFactory))
{
// Call
void Call() => activity.Run();
// Assert
TestHelper.AssertLogMessages(Call, messages =>
{
string[] msgs = messages.ToArray();
Assert.AreEqual(4, msgs.Length);
Assert.AreEqual($"Golfcondities berekenen voor '{calculation.Name}' is gestart.", msgs[0]);
CalculationServiceTestHelper.AssertValidationStartMessage(msgs[1]);
Assert.AreEqual("De bestandsmap waar de preprocessor bestanden opslaat is ongeldig. De bestandsmap bestaat niet.", msgs[2]);
CalculationServiceTestHelper.AssertValidationEndMessage(msgs[3]);
});
Assert.AreEqual(ActivityState.Failed, activity.State);
}
mockRepository.VerifyAll();
}
public void Validate_InputInvalidAccordingToValidationRule_LogErrorAndReturnFalse()
{
// Setup
var failureMechanism = new TestCalculatableFailureMechanism();
var mocks = new MockRepository();
IAssessmentSection assessmentSection = AssessmentSectionTestHelper.CreateAssessmentSectionStub(
failureMechanism, mocks, validHydraulicBoundaryDatabaseFilePath);
mocks.ReplayAll();
var calculation = new TestStructuresCalculation
{
InputParameters =
{
Structure = new TestStructure(),
HydraulicBoundaryLocation = new TestHydraulicBoundaryLocation(),
IsValid = false
}
};
var isValid = false;
// Call
void Call() => isValid = TestStructuresCalculationService.Validate(calculation, assessmentSection);
// Assert
TestHelper.AssertLogMessages(Call, messages =>
{
string[] msgs = messages.ToArray();
Assert.AreEqual(3, msgs.Length);
CalculationServiceTestHelper.AssertValidationStartMessage(msgs[0]);
Assert.AreEqual("Error message", msgs[1]);
CalculationServiceTestHelper.AssertValidationEndMessage(msgs[2]);
});
Assert.IsFalse(isValid);
mocks.VerifyAll();
}
