public void ContextMenuStrip_HydraulicBoundaryDatabaseLinkedToInvalidFile_ContextMenuItemCalculateAllDisabledAndTooltipSet()
{
// Setup
using (var treeViewControl = new TreeViewControl())
{
IAssessmentSection assessmentSection = AssessmentSectionTestHelper.CreateAssessmentSectionStub(null, mocks, "invalidFilePath");
var context = new DuneLocationCalculationsForUserDefinedTargetProbabilityContext(new DuneLocationCalculationsForTargetProbability(0.1),
new DuneErosionFailureMechanism(),
assessmentSection);
var builder = new CustomItemsOnlyContextMenuBuilder();
var gui = mocks.Stub <IGui>();
gui.Stub(cmp => cmp.Get(context, treeViewControl)).Return(builder);
gui.Stub(g => g.ViewHost).Return(mocks.Stub <IViewHost>());
mocks.ReplayAll();
plugin.Gui = gui;
// Call
using (ContextMenuStrip menu = info.ContextMenuStrip(context, null, treeViewControl))
{
// Assert
ToolStripItem contextMenuItem = menu.Items[contextMenuCalculateAllIndex];
Assert.AreEqual("Alles be&rekenen", contextMenuItem.Text);
StringAssert.Contains("Herstellen van de verbinding met de hydraulische belastingendatabase is mislukt.", contextMenuItem.ToolTipText);
TestHelper.AssertImagesAreEqual(RiskeerCommonFormsResources.CalculateAllIcon, contextMenuItem.Image);
Assert.IsFalse(contextMenuItem.Enabled);
}
}
}
public void CreateFileImporter_Always_ReturnFileImporter()
{
// Setup
var mocks = new MockRepository();
IAssessmentSection assessmentSection = AssessmentSectionTestHelper.CreateAssessmentSectionStub(mocks);
mocks.ReplayAll();
var context = new StabilityPointStructuresCalculationGroupContext(new CalculationGroup(),
null,
new StabilityPointStructuresFailureMechanism(),
assessmentSection);
using (var plugin = new StabilityPointStructuresPlugin())
{
ImportInfo info = GetImportInfo(plugin);
// Call
IFileImporter fileImporter = info.CreateFileImporter(context, "test");
// Assert
Assert.IsInstanceOf <StabilityPointStructuresCalculationConfigurationImporter>(fileImporter);
}
mocks.VerifyAll();
}
public void GetUniqueDisplayNameForWaterLevelCalculations_ValidParameters_ReturnsExpectedDisplayNameForMaximumAllowableFloodingProbability(
double maximumAllowableFloodingProbability, double signalFloodingProbability, double userDefinedTargetProbability1, double userDefinedTargetProbability2, string expectedName)
{
// Setup
var hydraulicBoundaryLocationCalculations = new ObservableList <HydraulicBoundaryLocationCalculation>();
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(hydraulicBoundaryLocationCalculations);
assessmentSection.Stub(a => a.WaterLevelCalculationsForSignalFloodingProbability).Return(new ObservableList <HydraulicBoundaryLocationCalculation>());
assessmentSection.Stub(a => a.WaterLevelCalculationsForUserDefinedTargetProbabilities).Return(
new ObservableList <HydraulicBoundaryLocationCalculationsForTargetProbability>
{
new HydraulicBoundaryLocationCalculationsForTargetProbability(userDefinedTargetProbability1),
new HydraulicBoundaryLocationCalculationsForTargetProbability(userDefinedTargetProbability2)
});
mockRepository.ReplayAll();
// Call
string name = TargetProbabilityCalculationsDisplayNameHelper.GetUniqueDisplayNameForWaterLevelCalculations(hydraulicBoundaryLocationCalculations,
assessmentSection);
// Assert
Assert.AreEqual(expectedName, name);
mockRepository.VerifyAll();
}
public void CalculateWaveHeights_ValidPathOneCalculation_LogsMessages()
{
// Setup
const string hydraulicLocationName = "name";
const string calculationIdentifier = "1/100";
var mocks = new MockRepository();
IAssessmentSection assessmentSection = AssessmentSectionTestHelper.CreateAssessmentSectionStub(mocks);
var calculatorFactory = mocks.StrictMock <IHydraRingCalculatorFactory>();
calculatorFactory.Expect(cf => cf.CreateWaveHeightCalculator(Arg <HydraRingCalculationSettings> .Is.NotNull))
.WhenCalled(invocation =>
{
HydraRingCalculationSettingsTestHelper.AssertHydraRingCalculationSettings(
HydraulicBoundaryCalculationSettingsFactory.CreateSettings(assessmentSection.HydraulicBoundaryDatabase),
(HydraRingCalculationSettings)invocation.Arguments[0]);
})
.Return(new TestWaveHeightCalculator());
mocks.ReplayAll();
assessmentSection.HydraulicBoundaryDatabase.FilePath = validFilePath;
HydraulicBoundaryDatabaseTestHelper.SetHydraulicBoundaryLocationConfigurationSettings(assessmentSection.HydraulicBoundaryDatabase);
DialogBoxHandler = (name, wnd) =>
{
// Expect an activity dialog which is automatically closed
};
using (var viewParent = new TestViewParentForm())
using (new HydraRingCalculatorFactoryConfig(calculatorFactory))
{
var guiService = new HydraulicBoundaryLocationCalculationGuiService(viewParent);
// Call
void Call() =>
guiService.CalculateWaveHeights(new[]
{
new HydraulicBoundaryLocationCalculation(new TestHydraulicBoundaryLocation(hydraulicLocationName))
}, assessmentSection, 0.01, calculationIdentifier);
// Assert
TestHelper.AssertLogMessages(Call, messages =>
{
string[] msgs = messages.ToArray();
Assert.AreEqual(8, msgs.Length);
string activityDescription = GetWaveHeightCalculationActivityDescription(hydraulicLocationName, calculationIdentifier);
Assert.AreEqual($"{activityDescription} is gestart.", msgs[0]);
CalculationServiceTestHelper.AssertValidationStartMessage(msgs[1]);
CalculationServiceTestHelper.AssertValidationEndMessage(msgs[2]);
CalculationServiceTestHelper.AssertCalculationStartMessage(msgs[3]);
Assert.AreEqual($"Golfhoogte berekening voor locatie 'name' ({calculationIdentifier}) is niet geconvergeerd.", msgs[4]);
StringAssert.StartsWith("Golfhoogte berekening is uitgevoerd op de tijdelijke locatie", msgs[5]);
CalculationServiceTestHelper.AssertCalculationEndMessage(msgs[6]);
Assert.AreEqual($"{activityDescription} is gelukt.", msgs[7]);
});
}
mocks.VerifyAll();
}
public void CalculateWaveHeights_ValidPathEmptyCalculationList_NoLog()
{
// Setup
var mocks = new MockRepository();
IAssessmentSection assessmentSection = AssessmentSectionTestHelper.CreateAssessmentSectionStub(mocks);
mocks.ReplayAll();
assessmentSection.HydraulicBoundaryDatabase.FilePath = validFilePath;
HydraulicBoundaryDatabaseTestHelper.SetHydraulicBoundaryLocationConfigurationSettings(assessmentSection.HydraulicBoundaryDatabase);
DialogBoxHandler = (name, wnd) =>
{
// Expect an activity dialog which is automatically closed
};
using (var viewParent = new TestViewParentForm())
{
var guiService = new HydraulicBoundaryLocationCalculationGuiService(viewParent);
// Call
void Call() => guiService.CalculateWaveHeights(Enumerable.Empty <HydraulicBoundaryLocationCalculation>(), assessmentSection, 0.01, "1/100");
// Assert
TestHelper.AssertLogMessagesCount(Call, 0);
}
mocks.VerifyAll();
}
public void CalculateWaveHeights_HydraulicDatabaseDoesNotExist_LogsError()
{
// Setup
var mocks = new MockRepository();
var viewParent = mocks.Stub <IViewParent>();
IAssessmentSection assessmentSection = AssessmentSectionTestHelper.CreateAssessmentSectionStub(mocks);
mocks.ReplayAll();
assessmentSection.HydraulicBoundaryDatabase.FilePath = "Does not exist";
HydraulicBoundaryDatabaseTestHelper.SetHydraulicBoundaryLocationConfigurationSettings(assessmentSection.HydraulicBoundaryDatabase);
var guiService = new HydraulicBoundaryLocationCalculationGuiService(viewParent);
// Call
void Call() => guiService.CalculateWaveHeights(Enumerable.Empty <HydraulicBoundaryLocationCalculation>(), assessmentSection, 0.01, "1/100");
// Assert
TestHelper.AssertLogMessages(Call, messages =>
{
string[] msgs = messages.ToArray();
Assert.AreEqual(1, msgs.Length);
StringAssert.StartsWith("Berekeningen konden niet worden gestart. ", msgs.First());
});
mocks.VerifyAll();
}
public void CreateInstance_ValidData_NewPropertiesWithOutputAsData()
{
// Setup
var failureMechanism = new MacroStabilityInwardsFailureMechanism();
var mocks = new MockRepository();
IAssessmentSection assessmentSection = AssessmentSectionTestHelper.CreateAssessmentSectionStub(failureMechanism, mocks);
mocks.ReplayAll();
var scenario = new MacroStabilityInwardsCalculationScenario
{
Output = MacroStabilityInwardsOutputTestFactory.CreateOutput()
};
var context = new MacroStabilityInwardsOutputContext(scenario, failureMechanism, assessmentSection);
// Call
IObjectProperties objectProperties = info.CreateInstance(context);
// Assert
Assert.IsInstanceOf <MacroStabilityInwardsOutputProperties>(objectProperties);
Assert.AreSame(scenario.Output, objectProperties.Data);
mocks.VerifyAll();
}
public void ContextMenuStrip_HydraulicBoundaryDatabaseNotLinked_ContextMenuItemValidateAllDisabledAndTooltipSet()
{
// Setup
var failureMechanism = new GrassCoverErosionInwardsFailureMechanism();
failureMechanism.CalculationsGroup.Children.Add(new GrassCoverErosionInwardsCalculation());
IAssessmentSection assessmentSection = AssessmentSectionTestHelper.CreateAssessmentSectionStub(mocksRepository);
var nodeData = new GrassCoverErosionInwardsFailureMechanismContext(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
TestHelper.AssertContextMenuStripContainsItem(contextMenu, contextMenuValidateAllIndex,
"Alles &valideren",
"Er is geen hydraulische belastingendatabase geïmporteerd.",
RiskeerCommonFormsResources.ValidateAllIcon,
false);
}
}
}
public void Validate_WithoutImportedHydraulicBoundaryDatabase_LogsErrorAndReturnsFalse()
{
// Setup
var mocks = new MockRepository();
IAssessmentSection assessmentSection = AssessmentSectionTestHelper.CreateAssessmentSectionStub(new TestCalculatableFailureMechanism(),
mocks);
mocks.ReplayAll();
var isValid = false;
// Call
void Call() => isValid = TestStructuresCalculationService.Validate(new TestStructuresCalculation(), assessmentSection);
// Assert
TestHelper.AssertLogMessages(Call, messages =>
{
string[] msgs = messages.ToArray();
Assert.AreEqual(3, msgs.Length);
CalculationServiceTestHelper.AssertValidationStartMessage(msgs[0]);
Assert.AreEqual("Er is geen hydraulische belastingendatabase geïmporteerd.", msgs[1]);
CalculationServiceTestHelper.AssertValidationEndMessage(msgs[2]);
});
Assert.IsFalse(isValid);
mocks.VerifyAll();
}
public void CreateCalculationActivitiesForFailureMechanism_WithValidCalculations_ReturnsGrassCoverErosionInwardsCalculationActivitiesWithParametersSet()
{
// Setup
var failureMechanism = new GrassCoverErosionInwardsFailureMechanism();
var mocks = new MockRepository();
IAssessmentSection assessmentSection = AssessmentSectionTestHelper.CreateAssessmentSectionStub(failureMechanism,
mocks,
validFilePath);
mocks.ReplayAll();
GrassCoverErosionInwardsCalculation calculation1 = CreateValidCalculation();
GrassCoverErosionInwardsCalculation calculation2 = CreateValidCalculation();
failureMechanism.CalculationsGroup.Children.AddRange(new[]
{
calculation1,
calculation2
});
// Call
IEnumerable <CalculatableActivity> activities = GrassCoverErosionInwardsCalculationActivityFactory.CreateCalculationActivities(
failureMechanism, assessmentSection);
// Assert
CollectionAssert.AllItemsAreInstancesOfType(activities, typeof(GrassCoverErosionInwardsCalculationActivity));
Assert.AreEqual(2, activities.Count());
HydraulicBoundaryDatabase hydraulicBoundaryDatabase = assessmentSection.HydraulicBoundaryDatabase;
AssertGrassCoverErosionInwardsCalculationActivity(activities.First(), calculation1, hydraulicBoundaryDatabase);
AssertGrassCoverErosionInwardsCalculationActivity(activities.ElementAt(1), calculation2, hydraulicBoundaryDatabase);
mocks.VerifyAll();
}
public void Validate_ValidCalculationInvalidPreprocessorDirectory_LogsErrorAndReturnsFalse()
{
// 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 = "NonExistingPreprocessorDirectory";
mocks.ReplayAll();
var calculation = new TestStructuresCalculation();
var isValid = true;
// 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("De bestandsmap waar de preprocessor bestanden opslaat is ongeldig. De bestandsmap bestaat niet.", msgs[1]);
CalculationServiceTestHelper.AssertValidationEndMessage(msgs[2]);
});
Assert.IsFalse(isValid);
mocks.VerifyAll();
}
public void Validate_ValidCalculationValidHydraulicBoundaryDatabaseNoSettings_LogsErrorAndReturnsFalse()
{
// Setup
var mocks = new MockRepository();
IAssessmentSection assessmentSection = AssessmentSectionTestHelper.CreateAssessmentSectionStub(new TestCalculatableFailureMechanism(),
mocks,
Path.Combine(testDataPath, "HRD nosettings.sqlite"));
mocks.ReplayAll();
var calculation = new TestStructuresCalculation();
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]);
StringAssert.StartsWith("Herstellen van de verbinding met de hydraulische belastingendatabase is mislukt. " +
"Fout bij het lezen van bestand", msgs[1]);
CalculationServiceTestHelper.AssertValidationEndMessage(msgs[2]);
});
Assert.IsFalse(isValid);
mocks.VerifyAll();
}
public void ContextMenuStrip_HydraulicBoundaryDatabaseLinkedToInvalidFile_ContextMenuItemValidateAllDisabledAndTooltipSet()
{
// Setup
var failureMechanism = new GrassCoverErosionInwardsFailureMechanism();
failureMechanism.CalculationsGroup.Children.Add(new GrassCoverErosionInwardsCalculation());
IAssessmentSection assessmentSection = AssessmentSectionTestHelper.CreateAssessmentSectionStub(null, mocksRepository, "invalidFilePath");
var nodeData = new GrassCoverErosionInwardsFailureMechanismContext(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 contextMenuItem = contextMenu.Items[contextMenuValidateAllIndex];
Assert.AreEqual("Alles &valideren", contextMenuItem.Text);
StringAssert.Contains("Herstellen van de verbinding met de hydraulische belastingendatabase is mislukt.", contextMenuItem.ToolTipText);
TestHelper.AssertImagesAreEqual(RiskeerCommonFormsResources.ValidateAllIcon, contextMenuItem.Image);
Assert.IsFalse(contextMenuItem.Enabled);
}
}
}
public void Constructor_CalculationWithOutput_ExpectedValues(double sectionLength)
{
// Setup
var failureMechanism = new PipingFailureMechanism();
var mocks = new MockRepository();
IAssessmentSection assessmentSection = AssessmentSectionTestHelper.CreateAssessmentSectionStub(failureMechanism, mocks);
mocks.ReplayAll();
var calculation = new SemiProbabilisticPipingCalculationScenario
{
Output = PipingTestDataGenerator.GetRandomSemiProbabilisticPipingOutput()
};
var failureMechanismSection = new FailureMechanismSection("test", new[]
{
new Point2D(0, 0),
new Point2D(sectionLength, 0)
});
// Call
var row = new SemiProbabilisticPipingScenarioRow(calculation, failureMechanism, failureMechanismSection, assessmentSection);
// Assert
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(Math.Min(1.0, expectedDerivedOutput.PipingProbability * failureMechanism.PipingProbabilityAssessmentInput.GetN(
failureMechanismSection.Length)),
row.SectionFailureProbability);
mocks.VerifyAll();
}
public void Validate_ValidCalculationInputAndHydraulicBoundaryDatabase_ReturnsTrue()
{
// Setup
var mockRepository = new MockRepository();
IAssessmentSection assessmentSection = AssessmentSectionTestHelper.CreateAssessmentSectionStub(new HeightStructuresFailureMechanism(),
mockRepository,
validHydraulicBoundaryDatabaseFilePath);
mockRepository.ReplayAll();
var calculation = new TestHeightStructuresCalculationScenario
{
InputParameters =
{
HydraulicBoundaryLocation = new HydraulicBoundaryLocation(1, "name", 2, 2)
}
};
// Call
var isValid = false;
Action call = () => isValid = HeightStructuresCalculationService.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);
mockRepository.VerifyAll();
}
public void Constructor_ExpectedValues()
{
// Setup
var failureMechanism = new PipingFailureMechanism();
var mocks = new MockRepository();
IAssessmentSection assessmentSection = AssessmentSectionTestHelper.CreateAssessmentSectionStub(failureMechanism, mocks);
mocks.ReplayAll();
var calculation = new SemiProbabilisticPipingCalculationScenario();
FailureMechanismSection failureMechanismSection = FailureMechanismSectionTestFactory.CreateFailureMechanismSection();
// Call
var row = new SemiProbabilisticPipingScenarioRow(calculation, failureMechanism, failureMechanismSection, assessmentSection);
// Assert
Assert.IsInstanceOf <PipingScenarioRow <SemiProbabilisticPipingCalculationScenario> >(row);
Assert.AreSame(calculation, row.CalculationScenario);
TestHelper.AssertTypeConverter <SemiProbabilisticPipingScenarioRow, NoProbabilityValueDoubleConverter>(
nameof(SemiProbabilisticPipingScenarioRow.FailureProbabilityUplift));
TestHelper.AssertTypeConverter <SemiProbabilisticPipingScenarioRow, NoProbabilityValueDoubleConverter>(
nameof(SemiProbabilisticPipingScenarioRow.FailureProbabilityHeave));
TestHelper.AssertTypeConverter <SemiProbabilisticPipingScenarioRow, NoProbabilityValueDoubleConverter>(
nameof(SemiProbabilisticPipingScenarioRow.FailureProbabilitySellmeijer));
}
public void ContextMenuStrip_HydraulicBoundaryDatabaseNotLinked_CalculateAllDisabled()
{
// Setup
using (var treeViewControl = new TreeViewControl())
{
var failureMechanism = new WaveImpactAsphaltCoverFailureMechanism();
failureMechanism.CalculationsGroup.Children.Add(new WaveImpactAsphaltCoverWaveConditionsCalculation());
IAssessmentSection assessmentSection = AssessmentSectionTestHelper.CreateAssessmentSectionStub(mocks);
var nodeData = new WaveImpactAsphaltCoverFailureMechanismContext(failureMechanism, assessmentSection);
var menuBuilder = new CustomItemsOnlyContextMenuBuilder();
var gui = mocks.Stub <IGui>();
gui.Stub(g => g.Get(nodeData, treeViewControl)).Return(menuBuilder);
gui.Stub(g => g.MainWindow).Return(mocks.Stub <IMainWindow>());
mocks.ReplayAll();
plugin.Gui = gui;
// Call
using (ContextMenuStrip contextMenu = info.ContextMenuStrip(nodeData, null, treeViewControl))
{
// Assert
ToolStripItem calculateItem = contextMenu.Items[contextMenuCalculateAllIndex];
Assert.IsFalse(calculateItem.Enabled);
Assert.AreEqual("Er is geen hydraulische belastingendatabase geïmporteerd.", calculateItem.ToolTipText);
}
}
}
public void Calculate_PreprocessorDirectorySet_InputPropertiesCorrectlySentToCalculator(bool usePreprocessor)
{
// Setup
string preprocessorDirectory = usePreprocessor
? validPreprocessorDirectory
: string.Empty;
var calculationSettings = new HydraulicBoundaryCalculationSettings(validHydraulicBoundaryDatabaseFilePath,
validHlcdFilePath,
false,
preprocessorDirectory);
var failureMechanism = new HeightStructuresFailureMechanism();
var mockRepository = new MockRepository();
IAssessmentSection assessmentSection = AssessmentSectionTestHelper.CreateAssessmentSectionStub(failureMechanism,
mockRepository);
var calculator = new TestStructuresCalculator <StructuresOvertoppingCalculationInput>();
var calculatorFactory = mockRepository.StrictMock <IHydraRingCalculatorFactory>();
calculatorFactory.Expect(cf => cf.CreateStructuresCalculator <StructuresOvertoppingCalculationInput>(
Arg <HydraRingCalculationSettings> .Is.NotNull))
.WhenCalled(invocation =>
{
HydraRingCalculationSettingsTestHelper.AssertHydraRingCalculationSettings(
calculationSettings, (HydraRingCalculationSettings)invocation.Arguments[0]);
})
.Return(calculator);
mockRepository.ReplayAll();
var calculation = new TestHeightStructuresCalculationScenario
{
InputParameters =
{
HydraulicBoundaryLocation = assessmentSection.HydraulicBoundaryDatabase.Locations.First(hl => hl.Id == 1300001)
}
};
using (new HydraRingCalculatorFactoryConfig(calculatorFactory))
{
// Call
new HeightStructuresCalculationService().Calculate(calculation,
failureMechanism.GeneralInput,
calculationSettings);
// Assert
StructuresOvertoppingCalculationInput[] calculationInputs = calculator.ReceivedInputs.ToArray();
Assert.AreEqual(1, calculationInputs.Length);
StructuresOvertoppingCalculationInput actualInput = calculationInputs[0];
Assert.AreEqual(usePreprocessor, actualInput.PreprocessorSetting.RunPreprocessor);
}
mockRepository.VerifyAll();
}
public void ContextMenuStrip_FailureMechanismWithCalculationsContainingIllustrationPoints_ContextMenuItemClearIllustrationPointsEnabled()
{
// Setup
var calculationWithIllustrationPoints = new TestStabilityPointStructuresCalculationScenario
{
Output = new TestStructuresOutput(new TestGeneralResultFaultTreeIllustrationPoint())
};
var calculationWithOutput = new TestStabilityPointStructuresCalculationScenario
{
Output = new TestStructuresOutput()
};
var failureMechanism = new StabilityPointStructuresFailureMechanism
{
CalculationsGroup =
{
Children =
{
calculationWithIllustrationPoints,
calculationWithOutput,
new TestStabilityPointStructuresCalculationScenario()
}
}
};
IAssessmentSection assessmentSection = AssessmentSectionTestHelper.CreateAssessmentSectionStub(null, mocksRepository, "invalidFilePath");
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();
plugin.Gui = gui;
TreeNodeInfo info = GetInfo(plugin);
using (ContextMenuStrip contextMenu = info.ContextMenuStrip(nodeData, null, treeViewControl))
{
// Call
ToolStripItem toolStripItem = contextMenu.Items[contextMenuClearIllustrationPointsIndex];
// Assert
Assert.IsTrue(toolStripItem.Enabled);
}
}
}
public void ContextMenuStrip_Always_CallsContextMenuBuilderMethods()
{
// Setup
var mockRepository = new MockRepository();
IAssessmentSection assessmentSection = AssessmentSectionTestHelper.CreateAssessmentSectionStub(mockRepository);
var orderedMockRepository = new MockRepository();
var menuBuilder = orderedMockRepository.StrictMock <IContextMenuBuilder>();
using (orderedMockRepository.Ordered())
{
menuBuilder.Expect(mb => mb.AddCustomItem(null)).IgnoreArguments().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.AddDeleteChildrenItem()).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.Build()).Return(null);
}
orderedMockRepository.ReplayAll();
var nodeData = new DuneLocationCalculationsForUserDefinedTargetProbabilitiesGroupContext(
new ObservableList <DuneLocationCalculationsForTargetProbability>(),
new DuneErosionFailureMechanism(),
assessmentSection);
using (var treeViewControl = new TreeViewControl())
{
var gui = mockRepository.Stub <IGui>();
gui.Stub(cmp => cmp.Get(nodeData, treeViewControl)).Return(menuBuilder);
gui.Stub(g => g.ViewHost).Return(mockRepository.Stub <IViewHost>());
mockRepository.ReplayAll();
using (var plugin = new DuneErosionPlugin())
{
TreeNodeInfo info = GetInfo(plugin);
plugin.Gui = gui;
// Call
info.ContextMenuStrip(nodeData, null, treeViewControl);
}
}
// Assert
orderedMockRepository.VerifyAll();
mockRepository.VerifyAll();
}
public void ForeColor_HasOutputFalse_ReturnGrayText()
{
// Setup
var failureMechanism = new MacroStabilityInwardsFailureMechanism();
IAssessmentSection assessmentSection = AssessmentSectionTestHelper.CreateAssessmentSectionStub(failureMechanism, mocks);
var scenario = new MacroStabilityInwardsCalculationScenario();
var context = new MacroStabilityInwardsOutputContext(scenario, failureMechanism, assessmentSection);
// Call
Color color = info.ForeColor(context);
// Assert
Assert.AreEqual(Color.FromKnownColor(KnownColor.GrayText), color);
}
public void Constructor_DataGridViewCorrectlyInitialized()
{
// Setup
IAssessmentSection assessmentSection = AssessmentSectionTestHelper.CreateAssessmentSectionStub(mockRepository);
mockRepository.ReplayAll();
// Call
ShowWaveHeightCalculationsView(new ObservableList <HydraulicBoundaryLocationCalculation>(),
assessmentSection,
0.01,
"1/100",
testForm);
// Assert
DataGridView calculationsDataGridView = GetCalculationsDataGridView();
Assert.AreEqual(6, calculationsDataGridView.ColumnCount);
var calculateColumn = (DataGridViewCheckBoxColumn)calculationsDataGridView.Columns[calculateColumnIndex];
Assert.AreEqual("Berekenen", calculateColumn.HeaderText);
var includeIllustrationPointsColumn = (DataGridViewCheckBoxColumn)calculationsDataGridView.Columns[includeIllustrationPointsColumnIndex];
Assert.AreEqual("Illustratiepunten inlezen", includeIllustrationPointsColumn.HeaderText);
var locationNameColumn = (DataGridViewTextBoxColumn)calculationsDataGridView.Columns[locationNameColumnIndex];
Assert.AreEqual("Naam", locationNameColumn.HeaderText);
var locationIdColumn = (DataGridViewTextBoxColumn)calculationsDataGridView.Columns[locationIdColumnIndex];
Assert.AreEqual("ID", locationIdColumn.HeaderText);
var locationColumn = (DataGridViewTextBoxColumn)calculationsDataGridView.Columns[locationColumnIndex];
Assert.AreEqual("Coördinaten [m]", locationColumn.HeaderText);
var waveHeightColumn = (DataGridViewTextBoxColumn)calculationsDataGridView.Columns[waveHeightColumnIndex];
Assert.AreEqual("Golfhoogte [m]", waveHeightColumn.HeaderText);
var button = (Button)testForm.Controls.Find("CalculateForSelectedButton", true).First();
Assert.IsFalse(button.Enabled);
}
public void ContextMenuStrip_FailureMechanismWithCalculationsContainingIllustrationPoints_ContextMenuItemClearIllustrationPointsEnabled(
GrassCoverErosionInwardsCalculation calculation)
{
// Setup
IAssessmentSection assessmentSection = AssessmentSectionTestHelper.CreateAssessmentSectionStub(mocksRepository);
var calculationWithOutput = new GrassCoverErosionInwardsCalculation
{
Output = new TestGrassCoverErosionInwardsOutput()
};
var failureMechanism = new GrassCoverErosionInwardsFailureMechanism
{
CalculationsGroup =
{
Children =
{
calculation,
calculationWithOutput,
new GrassCoverErosionInwardsCalculation()
}
}
};
var context = new GrassCoverErosionInwardsFailureMechanismContext(failureMechanism, assessmentSection);
var menuBuilder = new CustomItemsOnlyContextMenuBuilder();
using (var treeViewControl = new TreeViewControl())
{
var gui = mocksRepository.Stub <IGui>();
gui.Stub(g => g.Get(context, treeViewControl)).Return(menuBuilder);
gui.Stub(g => g.MainWindow).Return(mocksRepository.Stub <IMainWindow>());
mocksRepository.ReplayAll();
plugin.Gui = gui;
using (ContextMenuStrip contextMenu = info.ContextMenuStrip(context, null, treeViewControl))
{
// Call
ToolStripItem toolStripItem = contextMenu.Items[contextMenuClearIllustrationPointsIndex];
// Assert
Assert.IsTrue(toolStripItem.Enabled);
}
}
}
public void Calculate_ValidCalculationInputAndForeshoreWithInvalidBreakWater_LogStartAndEndAndReturnOutput(double height)
{
// Setup
var failureMechanism = new HeightStructuresFailureMechanism();
var mockRepository = new MockRepository();
IAssessmentSection assessmentSection = AssessmentSectionTestHelper.CreateAssessmentSectionStub(failureMechanism, mockRepository);
var calculatorFactory = mockRepository.StrictMock <IHydraRingCalculatorFactory>();
calculatorFactory.Expect(cf => cf.CreateStructuresCalculator <StructuresOvertoppingCalculationInput>(null))
.IgnoreArguments()
.Return(new TestStructuresCalculator <StructuresOvertoppingCalculationInput>());
mockRepository.ReplayAll();
var calculation = new TestHeightStructuresCalculationScenario
{
InputParameters =
{
HydraulicBoundaryLocation = assessmentSection.HydraulicBoundaryDatabase.Locations.First(hl => hl.Id == 1300001),
ForeshoreProfile = new TestForeshoreProfile(true),
UseBreakWater = false,
UseForeshore = true
}
};
// Call
using (new HydraRingCalculatorFactoryConfig(calculatorFactory))
{
Action call = () => new HeightStructuresCalculationService().Calculate(calculation,
failureMechanism.GeneralInput,
CreateCalculationSettings());
// Assert
TestHelper.AssertLogMessages(call, messages =>
{
string[] msgs = messages.ToArray();
Assert.AreEqual(3, msgs.Length);
CalculationServiceTestHelper.AssertCalculationStartMessage(msgs[0]);
StringAssert.StartsWith("Hoogte kunstwerk berekening is uitgevoerd op de tijdelijke locatie", msgs[1]);
CalculationServiceTestHelper.AssertCalculationEndMessage(msgs[2]);
});
Assert.IsNotNull(calculation.Output);
}
mockRepository.VerifyAll();
}
public void GivenScenarioRow_WhenOutputChangedAndUpdate_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);
var random = new Random(11);
// When
calculation.Output = PipingTestDataGenerator.GetSemiProbabilisticPipingOutput(random.NextDouble(), random.NextDouble(), random.NextDouble());
row.Update();
// Then
DerivedSemiProbabilisticPipingOutput newExpectedDerivedOutput = DerivedSemiProbabilisticPipingOutputFactory.Create(calculation.Output, assessmentSection.FailureMechanismContribution.NormativeProbability);
Assert.AreEqual(newExpectedDerivedOutput.PipingProbability, row.FailureProbability);
Assert.AreEqual(newExpectedDerivedOutput.UpliftProbability, row.FailureProbabilityUplift);
Assert.AreEqual(newExpectedDerivedOutput.HeaveProbability, row.FailureProbabilityHeave);
Assert.AreEqual(newExpectedDerivedOutput.SellmeijerProbability, row.FailureProbabilitySellmeijer);
Assert.AreEqual(newExpectedDerivedOutput.PipingProbability * failureMechanism.PipingProbabilityAssessmentInput.GetN(
failureMechanismSection.Length),
row.SectionFailureProbability);
mocks.VerifyAll();
}
public void Validate_DistributionStandardDeviationInvalid_LogsErrorAndReturnsFalse(double deviationOne, double deviationTwo,
double deviationThree, double deviationFour,
double deviationFive, string parameterName)
{
// Setup
var mockRepository = new MockRepository();
IAssessmentSection assessmentSection = AssessmentSectionTestHelper.CreateAssessmentSectionStub(new HeightStructuresFailureMechanism(),
mockRepository,
validHydraulicBoundaryDatabaseFilePath);
mockRepository.ReplayAll();
string expectedValidationMessage = $"De standaardafwijking 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.ModelFactorSuperCriticalFlow.StandardDeviation = (RoundedDouble)deviationOne;
calculation.InputParameters.LevelCrestStructure.StandardDeviation = (RoundedDouble)deviationTwo;
calculation.InputParameters.AllowedLevelIncreaseStorage.StandardDeviation = (RoundedDouble)deviationThree;
calculation.InputParameters.FlowWidthAtBottomProtection.StandardDeviation = (RoundedDouble)deviationFour;
calculation.InputParameters.WidthFlowApertures.StandardDeviation = (RoundedDouble)deviationFive;
// 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 GetViewData_WithContext_ReturnsWrappedFailureMechanismResult()
{
// Setup
var failureMechanism = new PipingFailureMechanism();
IAssessmentSection assessmentSection = AssessmentSectionTestHelper.CreateAssessmentSectionStub(failureMechanism, mocks);
mocks.ReplayAll();
var context = new PipingFailureMechanismSectionResultContext(
failureMechanism.SectionResults, failureMechanism, assessmentSection);
// Call
object viewData = info.GetViewData(context);
// Assert
Assert.AreSame(failureMechanism.SectionResults, viewData);
mocks.VerifyAll();
}
public void CreateInstance_WithContext_ReturnsView()
{
// Setup
var failureMechanism = new ClosingStructuresFailureMechanism();
IAssessmentSection assessmentSection = AssessmentSectionTestHelper.CreateAssessmentSectionStub(failureMechanism, mocks);
var context = new ClosingStructuresFailureMechanismSectionResultContext(
failureMechanism.SectionResults,
failureMechanism,
assessmentSection);
// Call
IView view = info.CreateInstance(context);
// Assert
Assert.IsInstanceOf <StructuresFailureMechanismResultView <ClosingStructuresFailureMechanism, ClosingStructuresInput> >(view);
mocks.VerifyAll();
}
public void Constructor_ExpectedValues()
{
// Setup
IAssessmentSection assessmentSection = AssessmentSectionTestHelper.CreateAssessmentSectionStub(mockRepository);
mockRepository.ReplayAll();
// Call
using (var view = new WaveHeightCalculationsView(new ObservableList <HydraulicBoundaryLocationCalculation>(),
assessmentSection,
() => 0.01,
() => "1/100"))
{
// Assert
Assert.IsInstanceOf <HydraulicBoundaryCalculationsView>(view);
Assert.IsNull(view.Data);
}
}
public void Constructor_GetCalculationIdentifierFuncNull_ThrowsArgumentNullException()
{
// Setup
IAssessmentSection assessmentSection = AssessmentSectionTestHelper.CreateAssessmentSectionStub(mockRepository);
mockRepository.ReplayAll();
// Call
void Call() => new WaveHeightCalculationsView(new ObservableList <HydraulicBoundaryLocationCalculation>(),
assessmentSection,
() => 0.01,
null);
// Assert
var exception = Assert.Throws <ArgumentNullException>(Call);
Assert.AreEqual("getCalculationIdentifierFunc", exception.ParamName);
}