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 SetHydraulicBoundaryLocationCalculations_MultipleHydraulicBoundaryLocations_SetsExpectedCalculations()
{
// Setup
var random = new Random(21);
var assessmentSection = new AssessmentSection(random.NextEnumValue <AssessmentSectionComposition>());
assessmentSection.WaterLevelCalculationsForUserDefinedTargetProbabilities.Add(new HydraulicBoundaryLocationCalculationsForTargetProbability(0.1));
assessmentSection.WaveHeightCalculationsForUserDefinedTargetProbabilities.Add(new HydraulicBoundaryLocationCalculationsForTargetProbability(0.01));
var hydraulicBoundaryLocation1 = new TestHydraulicBoundaryLocation();
var hydraulicBoundaryLocation2 = new TestHydraulicBoundaryLocation();
TestHydraulicBoundaryLocation[] hydraulicBoundaryLocations =
{
hydraulicBoundaryLocation1,
hydraulicBoundaryLocation2
};
// Call
assessmentSection.SetHydraulicBoundaryLocationCalculations(hydraulicBoundaryLocations);
// Assert
AssertNumberOfHydraulicBoundaryLocationCalculations(assessmentSection, 2);
AssertDefaultHydraulicBoundaryLocationCalculations(assessmentSection, 0, hydraulicBoundaryLocation1);
AssertDefaultHydraulicBoundaryLocationCalculations(assessmentSection, 1, hydraulicBoundaryLocation2);
}
public void ContextMenuStrip_HydraulicBoundaryLocationCalculationsWithIllustrationPoints_ContextMenuItemClearAllIllustrationPointsEnabledAndTooltipSet(
Func <IAssessmentSection, HydraulicBoundaryLocationCalculation> getHydraulicBoundaryLocationCalculationFunc)
{
// Setup
var random = new Random(21);
var assessmentSection = new AssessmentSection(AssessmentSectionComposition.Dike);
SetHydraulicBoundaryLocationCalculationsForUserDefinedTargetProbabilities(assessmentSection);
assessmentSection.SetHydraulicBoundaryLocationCalculations(new[]
{
new TestHydraulicBoundaryLocation()
});
HydraulicBoundaryLocationCalculation calculation = getHydraulicBoundaryLocationCalculationFunc(assessmentSection);
calculation.Output = new TestHydraulicBoundaryLocationCalculationOutput(random.NextDouble(), new TestGeneralResultSubMechanismIllustrationPoint());
var nodeData = new HydraulicBoundaryDatabaseContext(assessmentSection.HydraulicBoundaryDatabase, assessmentSection);
var mockRepository = new MockRepository();
using (var treeViewControl = new TreeViewControl())
{
IGui gui = StubFactory.CreateGuiStub(mocks);
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
}
public void SetHydraulicBoundaryLocationCalculations_HydraulicBoundaryLocationsNull_ThrowsArgumentNullException()
{
// Setup
var random = new Random(21);
var assessmentSection = new AssessmentSection(random.NextEnumValue <AssessmentSectionComposition>());
// Call
void Call() => assessmentSection.SetHydraulicBoundaryLocationCalculations(null);
// Assert
string paramName = Assert.Throws <ArgumentNullException>(Call).ParamName;
Assert.AreEqual("hydraulicBoundaryLocations", paramName);
}
public void ContextMenuStrip_HydraulicBoundaryDatabaseLinkedToInvalidFile_ContextMenuItemCalculateAllDisabledAndTooltipSet()
{
// Setup
var assessmentSection = new AssessmentSection(AssessmentSectionComposition.Dike)
{
HydraulicBoundaryDatabase =
{
FilePath = "invalidFilePath"
}
};
var hydraulicBoundaryLocation = new TestHydraulicBoundaryLocation("locationName");
assessmentSection.SetHydraulicBoundaryLocationCalculations(new[]
{
hydraulicBoundaryLocation
});
var nodeData = new HydraulicBoundaryDatabaseContext(assessmentSection.HydraulicBoundaryDatabase, assessmentSection);
using (var treeViewControl = new TreeViewControl())
{
IGui gui = StubFactory.CreateGuiStub(mocks);
gui.Stub(cmp => cmp.MainWindow).Return(mocks.Stub <IMainWindow>());
gui.Stub(cmp => cmp.Get(nodeData, treeViewControl)).Return(new CustomItemsOnlyContextMenuBuilder());
mocks.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[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);
}
}
}
mocks.VerifyAll(); // Expect no calls on arguments
}
public void ContextMenuStrip_HydraulicBoundaryDatabaseLinked_ContextMenuItemCalculateAllEnabled()
{
// Setup
using (var treeView = new TreeViewControl())
{
string testDataPath = TestHelper.GetTestDataPath(TestDataPath.Riskeer.Integration.Forms, "HydraulicBoundaryDatabase");
string validFilePath = Path.Combine(testDataPath, "HRD dutch coast south.sqlite");
var assessmentSection = new AssessmentSection(AssessmentSectionComposition.Dike)
{
HydraulicBoundaryDatabase =
{
FilePath = validFilePath
}
};
assessmentSection.SetHydraulicBoundaryLocationCalculations(new[]
{
new TestHydraulicBoundaryLocation()
});
HydraulicBoundaryDatabaseTestHelper.SetHydraulicBoundaryLocationConfigurationSettings(assessmentSection.HydraulicBoundaryDatabase);
var context = new HydraulicLoadsStateRootContext(assessmentSection);
var menuBuilder = new CustomItemsOnlyContextMenuBuilder();
var mocks = new MockRepository();
IGui gui = StubFactory.CreateGuiStub(mocks);
gui.Stub(cmp => cmp.Get(context, treeView)).Return(menuBuilder);
mocks.ReplayAll();
using (var plugin = new RiskeerPlugin())
{
plugin.Gui = gui;
// Call
using (ContextMenuStrip menu = GetInfo(plugin).ContextMenuStrip(context, null, treeView))
{
// Assert
Assert.AreEqual(10, menu.Items.Count);
TestHelper.AssertContextMenuStripContainsItem(
menu, contextMenuCalculateAllIndex,
"Alles be&rekenen",
"Alle hydraulische belastingen berekenen.",
RiskeerCommonFormsResources.CalculateAllIcon);
}
}
}
}
public void Constructor_WithAllData_DataUpdatedToCollectionOfFilledMapData()
{
// Setup
AssessmentSection assessmentSection = CreateAssessmentSectionWithReferenceLine();
assessmentSection.SetHydraulicBoundaryLocationCalculations(new[]
{
new HydraulicBoundaryLocation(1, "test", 1.0, 2.0)
});
// Call
using (new AssemblyToolCalculatorFactoryConfig())
{
var calculatorFactory = (TestAssemblyToolCalculatorFactory)AssemblyToolCalculatorFactory.Instance;
AssessmentSectionAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedAssessmentSectionAssemblyCalculator;
CombinedFailureMechanismSectionAssembly[] failureMechanismSectionAssembly =
{
CombinedFailureMechanismSectionAssemblyTestFactory.Create(assessmentSection, 21)
};
calculator.CombinedFailureMechanismSectionAssemblyOutput = new CombinedFailureMechanismSectionAssemblyResultWrapper(
failureMechanismSectionAssembly, AssemblyMethod.BOI3A1, AssemblyMethod.BOI3B1, AssemblyMethod.BOI3C1);
using (var view = new AssemblyResultPerSectionMapView(assessmentSection))
{
// Assert
Assert.IsInstanceOf <MapDataCollection>(view.Map.Data);
MapDataCollection mapData = view.Map.Data;
Assert.IsNotNull(mapData);
Assert.AreEqual(3, mapData.Collection.Count());
IEnumerable <CombinedFailureMechanismSectionAssemblyResult> expectedResults =
AssessmentSectionAssemblyFactory.AssembleCombinedPerFailureMechanismSection(assessmentSection);
AssertCombinedFailureMechanismSectionAssemblyResultMapData(expectedResults,
assessmentSection.ReferenceLine,
mapData.Collection.ElementAt(assemblyResultsIndex));
MapData hydraulicBoundaryLocationsMapData = mapData.Collection.ElementAt(hydraulicBoundaryLocationsIndex);
MapDataTestHelper.AssertHydraulicBoundaryLocationsMapData(assessmentSection, hydraulicBoundaryLocationsMapData);
MapData referenceLineMapData = mapData.Collection.ElementAt(referenceLineIndex);
AssertReferenceLineMapData(assessmentSection.ReferenceLine, referenceLineMapData);
}
}
}
public void Create_HydraulicBoundaryDatabaseNotLinked_SetsExpectedPropertiesToEntity()
{
// Setup
var assessmentSection = new AssessmentSection(AssessmentSectionComposition.Dike);
assessmentSection.SetHydraulicBoundaryLocationCalculations(assessmentSection.HydraulicBoundaryDatabase.Locations);
var registry = new PersistenceRegistry();
// Call
AssessmentSectionEntity entity = assessmentSection.Create(registry);
// Assert
CollectionAssert.IsEmpty(entity.HydraulicBoundaryDatabaseEntities);
CollectionAssert.IsEmpty(entity.HydraulicLocationEntities);
AssertHydraulicLocationCalculationCollectionEntities(assessmentSection, entity);
}
private static void ReadHydraulicDatabase(this AssessmentSectionEntity entity, AssessmentSection assessmentSection, ReadConversionCollector collector)
{
HydraulicBoundaryDatabaseEntity hydraulicBoundaryDatabaseEntity = entity.HydraulicBoundaryDatabaseEntities.SingleOrDefault();
if (hydraulicBoundaryDatabaseEntity != null)
{
HydraulicBoundaryDatabase hydraulicBoundaryDatabase = assessmentSection.HydraulicBoundaryDatabase;
hydraulicBoundaryDatabaseEntity.Read(hydraulicBoundaryDatabase);
HydraulicBoundaryLocation[] readHydraulicBoundaryLocations = entity.HydraulicLocationEntities
.OrderBy(hl => hl.Order)
.Select(hle => hle.Read(collector))
.ToArray();
hydraulicBoundaryDatabase.Locations.AddRange(readHydraulicBoundaryLocations);
assessmentSection.SetHydraulicBoundaryLocationCalculations(readHydraulicBoundaryLocations);
entity.ReadHydraulicBoundaryLocationCalculations(assessmentSection, collector);
}
}
public void ContextMenuStrip_HydraulicBoundaryLocationCalculationsWithoutIllustrationPoints_ContextMenuItemClearAllIllustrationPointsDisabled()
{
// Setup
var assessmentSection = new AssessmentSection(AssessmentSectionComposition.Dike);
assessmentSection.SetHydraulicBoundaryLocationCalculations(new[]
{
new TestHydraulicBoundaryLocation()
});
var nodeData = new HydraulicBoundaryDatabaseContext(assessmentSection.HydraulicBoundaryDatabase, assessmentSection);
var mockRepository = new MockRepository();
using (var treeViewControl = new TreeViewControl())
{
IGui gui = StubFactory.CreateGuiStub(mocks);
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.IsFalse(contextMenuItem.Enabled);
}
}
}
mockRepository.VerifyAll(); // Expect no calls on arguments
}
private static AssessmentSection GetAssessmentSectionWithHydraulicBoundaryLocationCalculationOutputs()
{
var random = new Random(21);
var assessmentSection = new AssessmentSection(random.NextEnumValue <AssessmentSectionComposition>());
SetHydraulicBoundaryLocationCalculationsForUserDefinedTargetProbabilities(assessmentSection);
assessmentSection.SetHydraulicBoundaryLocationCalculations(new[]
{
new TestHydraulicBoundaryLocation(),
new TestHydraulicBoundaryLocation()
});
SetHydraulicBoundaryLocationOutput(assessmentSection.WaterLevelCalculationsForSignalFloodingProbability);
SetHydraulicBoundaryLocationOutput(assessmentSection.WaterLevelCalculationsForMaximumAllowableFloodingProbability);
SetHydraulicBoundaryLocationOutput(assessmentSection.WaterLevelCalculationsForUserDefinedTargetProbabilities[0].HydraulicBoundaryLocationCalculations);
SetHydraulicBoundaryLocationOutput(assessmentSection.WaterLevelCalculationsForUserDefinedTargetProbabilities[1].HydraulicBoundaryLocationCalculations);
SetHydraulicBoundaryLocationOutput(assessmentSection.WaveHeightCalculationsForUserDefinedTargetProbabilities[0].HydraulicBoundaryLocationCalculations);
SetHydraulicBoundaryLocationOutput(assessmentSection.WaveHeightCalculationsForUserDefinedTargetProbabilities[1].HydraulicBoundaryLocationCalculations);
return(assessmentSection);
}
public void Create_HydraulicBoundaryDatabaseLinked_SetsExpectedPropertiesToEntity()
{
// Setup
var random = new Random(21);
const string testFilePath = "path";
const string testVersion = "1";
var assessmentSection = new AssessmentSection(AssessmentSectionComposition.Dike)
{
HydraulicBoundaryDatabase =
{
FilePath = testFilePath,
Version = testVersion,
Locations =
{
new HydraulicBoundaryLocation(-1, "name", 1, 2)
}
},
WaveHeightCalculationsForUserDefinedTargetProbabilities =
{
new HydraulicBoundaryLocationCalculationsForTargetProbability(random.NextDouble(0, 0.1)),
new HydraulicBoundaryLocationCalculationsForTargetProbability(random.NextDouble(0, 0.1)),
new HydraulicBoundaryLocationCalculationsForTargetProbability(random.NextDouble(0, 0.1))
},
WaterLevelCalculationsForUserDefinedTargetProbabilities =
{
new HydraulicBoundaryLocationCalculationsForTargetProbability(random.NextDouble(0, 0.1)),
new HydraulicBoundaryLocationCalculationsForTargetProbability(random.NextDouble(0, 0.1))
}
};
assessmentSection.SetHydraulicBoundaryLocationCalculations(assessmentSection.HydraulicBoundaryDatabase.Locations);
SetHydraulicBoundaryLocationCalculationInputsOfAssessmentSection(assessmentSection);
var registry = new PersistenceRegistry();
// Call
AssessmentSectionEntity entity = assessmentSection.Create(registry);
// Assert
HydraulicBoundaryDatabaseEntity hydraulicBoundaryDatabaseEntity = entity.HydraulicBoundaryDatabaseEntities.Single();
HydraulicBoundaryDatabase hydraulicBoundaryDatabase = assessmentSection.HydraulicBoundaryDatabase;
Assert.AreEqual(hydraulicBoundaryDatabase.FilePath, hydraulicBoundaryDatabaseEntity.FilePath);
Assert.AreEqual(hydraulicBoundaryDatabase.Version, hydraulicBoundaryDatabaseEntity.Version);
HydraulicLocationConfigurationSettings settings = hydraulicBoundaryDatabase.HydraulicLocationConfigurationSettings;
Assert.AreEqual(settings.FilePath, hydraulicBoundaryDatabaseEntity.HydraulicLocationConfigurationSettingsFilePath);
Assert.AreEqual(settings.ScenarioName, hydraulicBoundaryDatabaseEntity.HydraulicLocationConfigurationSettingsScenarioName);
Assert.AreEqual(settings.Year, hydraulicBoundaryDatabaseEntity.HydraulicLocationConfigurationSettingsYear);
Assert.AreEqual(settings.Scope, hydraulicBoundaryDatabaseEntity.HydraulicLocationConfigurationSettingsScope);
Assert.AreEqual(settings.SeaLevel, hydraulicBoundaryDatabaseEntity.HydraulicLocationConfigurationSettingsSeaLevel);
Assert.AreEqual(settings.RiverDischarge, hydraulicBoundaryDatabaseEntity.HydraulicLocationConfigurationSettingsRiverDischarge);
Assert.AreEqual(settings.LakeLevel, hydraulicBoundaryDatabaseEntity.HydraulicLocationConfigurationSettingsLakeLevel);
Assert.AreEqual(settings.WindDirection, hydraulicBoundaryDatabaseEntity.HydraulicLocationConfigurationSettingsWindDirection);
Assert.AreEqual(settings.WindSpeed, hydraulicBoundaryDatabaseEntity.HydraulicLocationConfigurationSettingsWindSpeed);
Assert.AreEqual(settings.Comment, hydraulicBoundaryDatabaseEntity.HydraulicLocationConfigurationSettingsComment);
int expectedNrOfHydraulicBoundaryLocations = hydraulicBoundaryDatabase.Locations.Count;
Assert.AreEqual(expectedNrOfHydraulicBoundaryLocations, entity.HydraulicLocationEntities.Count);
AssertHydraulicLocationCalculationCollectionEntities(assessmentSection, entity);
}
public void CreateCalculationActivities_WithValidDataAndAllFailureMechanismsRelevant_ExpectedActivitiesCreated()
{
// Setup
AssessmentSection assessmentSection = CreateAssessmentSection();
var hydraulicBoundaryLocation = new TestHydraulicBoundaryLocation();
IEnumerable <HydraulicBoundaryLocation> hydraulicBoundaryLocations = new[]
{
hydraulicBoundaryLocation
};
assessmentSection.SetHydraulicBoundaryLocationCalculations(hydraulicBoundaryLocations);
AddSemiProbabilisticPipingCalculationScenario(assessmentSection, hydraulicBoundaryLocation);
AddProbabilisticPipingCalculationScenario(assessmentSection, hydraulicBoundaryLocation);
AddGrassCoverErosionInwardsCalculation(assessmentSection, hydraulicBoundaryLocation);
AddMacroStabilityInwardsCalculationScenario(assessmentSection, hydraulicBoundaryLocation);
AddHeightStructuresCalculation(assessmentSection, hydraulicBoundaryLocation);
AddClosingStructuresCalculation(assessmentSection, hydraulicBoundaryLocation);
AddStabilityPointStructuresCalculation(assessmentSection, hydraulicBoundaryLocation);
var mocks = new MockRepository();
var calculatorFactory = mocks.StrictMock <IHydraRingCalculatorFactory>();
HydraulicBoundaryCalculationSettings expectedCalculationSettings =
HydraulicBoundaryCalculationSettingsFactory.CreateSettings(assessmentSection.HydraulicBoundaryDatabase);
using (mocks.Ordered())
{
calculatorFactory.Expect(cf => cf.CreatePipingCalculator(Arg <HydraRingCalculationSettings> .Is.NotNull))
.WhenCalled(invocation =>
{
HydraRingCalculationSettingsTestHelper.AssertHydraRingCalculationSettings(
expectedCalculationSettings, (HydraRingCalculationSettings)invocation.Arguments[0]);
})
.Return(new TestPipingCalculator());
calculatorFactory.Expect(cf => cf.CreateOvertoppingCalculator(Arg <HydraRingCalculationSettings> .Is.NotNull))
.WhenCalled(invocation =>
{
HydraRingCalculationSettingsTestHelper.AssertHydraRingCalculationSettings(
expectedCalculationSettings, (HydraRingCalculationSettings)invocation.Arguments[0]);
})
.Return(new TestOvertoppingCalculator());
calculatorFactory.Expect(cf => cf.CreateStructuresCalculator <StructuresOvertoppingCalculationInput>(
Arg <HydraRingCalculationSettings> .Is.NotNull))
.WhenCalled(invocation =>
{
HydraRingCalculationSettingsTestHelper.AssertHydraRingCalculationSettings(
expectedCalculationSettings, (HydraRingCalculationSettings)invocation.Arguments[0]);
})
.Return(new TestStructuresCalculator <StructuresOvertoppingCalculationInput>());
calculatorFactory.Expect(cf => cf.CreateStructuresCalculator <StructuresClosureCalculationInput>(
Arg <HydraRingCalculationSettings> .Is.NotNull))
.WhenCalled(invocation =>
{
HydraRingCalculationSettingsTestHelper.AssertHydraRingCalculationSettings(
expectedCalculationSettings, (HydraRingCalculationSettings)invocation.Arguments[0]);
})
.Return(new TestStructuresCalculator <StructuresClosureCalculationInput>());
calculatorFactory.Expect(cf => cf.CreateStructuresCalculator <StructuresStabilityPointCalculationInput>(
Arg <HydraRingCalculationSettings> .Is.NotNull))
.WhenCalled(invocation =>
{
HydraRingCalculationSettingsTestHelper.AssertHydraRingCalculationSettings(
expectedCalculationSettings, (HydraRingCalculationSettings)invocation.Arguments[0]);
})
.Return(new TestStructuresCalculator <StructuresStabilityPointCalculationInput>());
}
mocks.ReplayAll();
// Call
IEnumerable <CalculatableActivity> activities =
AssessmentSectionCalculationActivityFactory.CreateCalculationActivities(assessmentSection);
// Assert
Assert.AreEqual(7, activities.Count());
using (new HydraRingCalculatorFactoryConfig(calculatorFactory))
using (new PipingSubCalculatorFactoryConfig())
using (new MacroStabilityInwardsCalculatorFactoryConfig())
{
var pipingTestFactory = (TestPipingSubCalculatorFactory)PipingSubCalculatorFactory.Instance;
var macroStabilityTestFactory = (TestMacroStabilityInwardsCalculatorFactory)MacroStabilityInwardsCalculatorFactory.Instance;
Assert.IsFalse(pipingTestFactory.LastCreatedUpliftCalculator.Calculated);
Assert.IsFalse(macroStabilityTestFactory.LastCreatedUpliftVanCalculator.Calculated);
activities.ForEachElementDo(activity => activity.Run());
Assert.IsTrue(pipingTestFactory.LastCreatedUpliftCalculator.Calculated);
Assert.IsTrue(macroStabilityTestFactory.LastCreatedUpliftVanCalculator.Calculated);
}
mocks.VerifyAll();
}
public void CreateHydraulicLoadCalculationActivities_WithValidDataAndAllFailureMechanismsRelevant_ExpectedActivitiesCreated()
{
// Setup
AssessmentSection assessmentSection = CreateAssessmentSection();
var hydraulicBoundaryLocation = new TestHydraulicBoundaryLocation();
IEnumerable <HydraulicBoundaryLocation> hydraulicBoundaryLocations = new[]
{
hydraulicBoundaryLocation
};
assessmentSection.WaterLevelCalculationsForUserDefinedTargetProbabilities.AddRange(
new[]
{
new HydraulicBoundaryLocationCalculationsForTargetProbability(0.1),
new HydraulicBoundaryLocationCalculationsForTargetProbability(0.01)
});
assessmentSection.WaveHeightCalculationsForUserDefinedTargetProbabilities.AddRange(
new[]
{
new HydraulicBoundaryLocationCalculationsForTargetProbability(0.025),
new HydraulicBoundaryLocationCalculationsForTargetProbability(0.0025)
});
assessmentSection.SetHydraulicBoundaryLocationCalculations(hydraulicBoundaryLocations);
AddStabilityStoneCoverCalculation(assessmentSection, hydraulicBoundaryLocation);
AddWaveImpactAsphaltCoverCalculation(assessmentSection, hydraulicBoundaryLocation);
AddGrassCoverErosionOutwardsCalculation(assessmentSection, hydraulicBoundaryLocation);
AddDuneLocationCalculation(assessmentSection);
var mocks = new MockRepository();
var calculatorFactory = mocks.StrictMock <IHydraRingCalculatorFactory>();
HydraulicBoundaryCalculationSettings expectedCalculationSettings =
HydraulicBoundaryCalculationSettingsFactory.CreateSettings(assessmentSection.HydraulicBoundaryDatabase);
using (mocks.Ordered())
{
calculatorFactory.Expect(cf => cf.CreateDesignWaterLevelCalculator(Arg <HydraRingCalculationSettings> .Is.NotNull))
.WhenCalled(invocation =>
{
HydraRingCalculationSettingsTestHelper.AssertHydraRingCalculationSettings(
expectedCalculationSettings, (HydraRingCalculationSettings)invocation.Arguments[0]);
})
.Return(new TestDesignWaterLevelCalculator
{
DesignWaterLevel = 2.0
}).Repeat.Times(4);
calculatorFactory.Expect(cf => cf.CreateWaveHeightCalculator(Arg <HydraRingCalculationSettings> .Is.NotNull))
.WhenCalled(invocation =>
{
HydraRingCalculationSettingsTestHelper.AssertHydraRingCalculationSettings(
expectedCalculationSettings, (HydraRingCalculationSettings)invocation.Arguments[0]);
})
.Return(new TestWaveHeightCalculator()).Repeat.Times(2);
calculatorFactory.Expect(cf => cf.CreateWaveConditionsCosineCalculator(Arg <HydraRingCalculationSettings> .Is.NotNull))
.WhenCalled(invocation =>
{
HydraRingCalculationSettingsTestHelper.AssertHydraRingCalculationSettings(
expectedCalculationSettings, (HydraRingCalculationSettings)invocation.Arguments[0]);
})
.Return(new TestWaveConditionsCosineCalculator()).Repeat.Times(9);
calculatorFactory.Expect(cf => cf.CreateWaveConditionsCosineCalculator(Arg <HydraRingCalculationSettings> .Is.NotNull))
.WhenCalled(invocation =>
{
HydraRingCalculationSettingsTestHelper.AssertHydraRingCalculationSettings(
expectedCalculationSettings, (HydraRingCalculationSettings)invocation.Arguments[0]);
})
.Return(new TestWaveConditionsCosineCalculator()).Repeat.Times(6);
calculatorFactory.Expect(cf => cf.CreateDunesBoundaryConditionsCalculator(Arg <HydraRingCalculationSettings> .Is.NotNull))
.WhenCalled(invocation =>
{
HydraRingCalculationSettingsTestHelper.AssertHydraRingCalculationSettings(
expectedCalculationSettings, (HydraRingCalculationSettings)invocation.Arguments[0]);
})
.Return(new TestDunesBoundaryConditionsCalculator()).Repeat.Once();
}
mocks.ReplayAll();
// Call
IEnumerable <CalculatableActivity> activities =
AssessmentSectionCalculationActivityFactory.CreateHydraulicLoadCalculationActivities(assessmentSection);
// Assert
Assert.AreEqual(10, activities.Count());
using (new HydraRingCalculatorFactoryConfig(calculatorFactory))
{
activities.ForEachElementDo(activity => activity.Run());
}
mocks.VerifyAll();
}
public IEnumerable <IObservable> Update(HydraulicBoundaryDatabase hydraulicBoundaryDatabase, ReadHydraulicBoundaryDatabase readHydraulicBoundaryDatabase,
ReadHydraulicLocationConfigurationDatabase readHydraulicLocationConfigurationDatabase,
IEnumerable <long> excludedLocationIds, string hydraulicBoundaryDatabaseFilePath, string hlcdFilePath)
{
if (hydraulicBoundaryDatabase == null)
{
throw new ArgumentNullException(nameof(hydraulicBoundaryDatabase));
}
if (readHydraulicBoundaryDatabase == null)
{
throw new ArgumentNullException(nameof(readHydraulicBoundaryDatabase));
}
if (readHydraulicLocationConfigurationDatabase == null)
{
throw new ArgumentNullException(nameof(readHydraulicLocationConfigurationDatabase));
}
if (excludedLocationIds == null)
{
throw new ArgumentNullException(nameof(excludedLocationIds));
}
if (hydraulicBoundaryDatabaseFilePath == null)
{
throw new ArgumentNullException(nameof(hydraulicBoundaryDatabaseFilePath));
}
if (hlcdFilePath == null)
{
throw new ArgumentNullException(nameof(hlcdFilePath));
}
if (!IsValidReadHydraulicLocationConfigurationDatabase(readHydraulicLocationConfigurationDatabase))
{
string errorMessage = $"{nameof(readHydraulicLocationConfigurationDatabase)} must be null or contain exactly one item for " +
"the collection of hydraulic location configuration database settings.";
throw new ArgumentException(errorMessage);
}
var changedObjects = new List <IObservable>();
updateLocations = !hydraulicBoundaryDatabase.IsLinked() || hydraulicBoundaryDatabase.Version != readHydraulicBoundaryDatabase.Version;
if (updateLocations)
{
hydraulicBoundaryDatabase.FilePath = hydraulicBoundaryDatabaseFilePath;
hydraulicBoundaryDatabase.Version = readHydraulicBoundaryDatabase.Version;
SetLocations(hydraulicBoundaryDatabase, readHydraulicBoundaryDatabase.Locations,
readHydraulicLocationConfigurationDatabase.LocationIdMappings,
excludedLocationIds.ToArray());
assessmentSection.SetHydraulicBoundaryLocationCalculations(hydraulicBoundaryDatabase.Locations);
duneLocationsReplacementHandler.Replace(hydraulicBoundaryDatabase.Locations);
changedObjects.AddRange(GetLocationsAndCalculationsObservables(hydraulicBoundaryDatabase));
changedObjects.AddRange(RiskeerDataSynchronizationService.ClearAllCalculationOutputAndHydraulicBoundaryLocations(assessmentSection));
}
else
{
if (hydraulicBoundaryDatabase.FilePath != hydraulicBoundaryDatabaseFilePath)
{
hydraulicBoundaryDatabase.FilePath = hydraulicBoundaryDatabaseFilePath;
}
}
HydraulicLocationConfigurationSettingsUpdateHelper.SetHydraulicLocationConfigurationSettings(
hydraulicBoundaryDatabase.HydraulicLocationConfigurationSettings,
readHydraulicLocationConfigurationDatabase.ReadHydraulicLocationConfigurationDatabaseSettings?.Single(),
readHydraulicLocationConfigurationDatabase.UsePreprocessorClosure,
hlcdFilePath);
return(changedObjects);
}
public void GivenValidCalculations_WhenCalculatingAllFromContextMenu_ThenAllCalculationsScheduled()
{
// Given
string validFilePath = Path.Combine(testDataPath, "HRD dutch coast south.sqlite");
var assessmentSection = new AssessmentSection(AssessmentSectionComposition.Dike)
{
HydraulicBoundaryDatabase =
{
FilePath = validFilePath
}
};
HydraulicBoundaryDatabaseTestHelper.SetHydraulicBoundaryLocationConfigurationSettings(assessmentSection.HydraulicBoundaryDatabase);
SetHydraulicBoundaryLocationCalculationsForUserDefinedTargetProbabilities(assessmentSection);
var hydraulicBoundaryLocation = new TestHydraulicBoundaryLocation("locationName");
assessmentSection.SetHydraulicBoundaryLocationCalculations(new[]
{
hydraulicBoundaryLocation
});
var context = new HydraulicBoundaryDatabaseContext(assessmentSection.HydraulicBoundaryDatabase, assessmentSection);
using (var treeViewControl = new TreeViewControl())
using (var plugin = new RiskeerPlugin())
{
IMainWindow mainWindow = MainWindowTestHelper.CreateMainWindowStub(mocks);
IGui gui = StubFactory.CreateGuiStub(mocks);
gui.Stub(g => g.MainWindow).Return(mainWindow);
gui.Stub(cmp => cmp.Get(context, treeViewControl)).Return(new CustomItemsOnlyContextMenuBuilder());
gui.Stub(g => g.DocumentViewController).Return(mocks.Stub <IDocumentViewController>());
gui.Stub(g => g.ViewCommands).Return(mocks.Stub <IViewCommands>());
gui.Stub(g => g.ProjectStore).Return(mocks.Stub <IStoreProject>());
var calculatorFactory = mocks.Stub <IHydraRingCalculatorFactory>();
var designWaterLevelCalculator = new TestDesignWaterLevelCalculator
{
Converged = false
};
var waveHeightCalculator = new TestWaveHeightCalculator
{
Converged = false
};
HydraulicBoundaryCalculationSettings expectedSettings = HydraulicBoundaryCalculationSettingsFactory.CreateSettings(assessmentSection.HydraulicBoundaryDatabase);
calculatorFactory.Expect(cf => cf.CreateDesignWaterLevelCalculator(Arg <HydraRingCalculationSettings> .Is.NotNull))
.WhenCalled(invocation =>
{
HydraRingCalculationSettingsTestHelper.AssertHydraRingCalculationSettings(
expectedSettings, (HydraRingCalculationSettings)invocation.Arguments[0]);
})
.Return(designWaterLevelCalculator)
.Repeat
.Times(4);
calculatorFactory.Expect(cf => cf.CreateWaveHeightCalculator(Arg <HydraRingCalculationSettings> .Is.NotNull))
.WhenCalled(invocation =>
{
HydraRingCalculationSettingsTestHelper.AssertHydraRingCalculationSettings(
expectedSettings, (HydraRingCalculationSettings)invocation.Arguments[0]);
}).Return(waveHeightCalculator)
.Repeat
.Times(2);
mocks.ReplayAll();
TreeNodeInfo info = GetInfo(plugin);
plugin.Gui = gui;
plugin.Activate();
DialogBoxHandler = (name, wnd) =>
{
// Expect an activity dialog which is automatically closed
};
using (ContextMenuStrip contextMenuAdapter = info.ContextMenuStrip(context, null, treeViewControl))
using (new HydraRingCalculatorFactoryConfig(calculatorFactory))
{
// When
void Call() => contextMenuAdapter.Items[contextMenuCalculateAllIndex].PerformClick();
// Then
TestHelper.AssertLogMessages(Call, messages =>
{
string[] msgs = messages.ToArray();
Assert.AreEqual(48, msgs.Length);
const string designWaterLevelCalculationTypeDisplayName = "Waterstand";
const string designWaterLevelCalculationDisplayName = "Waterstand berekening";
HydraulicBoundaryLocationCalculationActivityLogTestHelper.AssertHydraulicBoundaryLocationCalculationMessages(
hydraulicBoundaryLocation.Name, designWaterLevelCalculationTypeDisplayName, designWaterLevelCalculationDisplayName,
"1/30.000",
msgs, 0);
HydraulicBoundaryLocationCalculationActivityLogTestHelper.AssertHydraulicBoundaryLocationCalculationMessages(
hydraulicBoundaryLocation.Name, designWaterLevelCalculationTypeDisplayName, designWaterLevelCalculationDisplayName,
"1/30.000 (1)",
msgs, 8);
HydraulicBoundaryLocationCalculationActivityLogTestHelper.AssertHydraulicBoundaryLocationCalculationMessages(
hydraulicBoundaryLocation.Name, designWaterLevelCalculationTypeDisplayName, designWaterLevelCalculationDisplayName,
"1/10",
msgs, 16);
HydraulicBoundaryLocationCalculationActivityLogTestHelper.AssertHydraulicBoundaryLocationCalculationMessages(
hydraulicBoundaryLocation.Name, designWaterLevelCalculationTypeDisplayName, designWaterLevelCalculationDisplayName,
"1/100",
msgs, 24);
const string waveHeightCalculationTypeDisplayName = "Golfhoogte";
const string waveHeightCalculationDisplayName = "Golfhoogte berekening";
HydraulicBoundaryLocationCalculationActivityLogTestHelper.AssertHydraulicBoundaryLocationCalculationMessages(
hydraulicBoundaryLocation.Name, waveHeightCalculationTypeDisplayName, waveHeightCalculationDisplayName,
"1/40",
msgs, 32);
HydraulicBoundaryLocationCalculationActivityLogTestHelper.AssertHydraulicBoundaryLocationCalculationMessages(
hydraulicBoundaryLocation.Name, waveHeightCalculationTypeDisplayName, waveHeightCalculationDisplayName,
"1/400",
msgs, 40);
});
}
}
mocks.VerifyAll();
}