public void Create_HasCalculationOutputWithColumns_EntityHasOrderedCalculationOutputEntity()
{
// Setup
var registry = new PersistenceRegistry();
var calculation = new StabilityStoneCoverWaveConditionsCalculation
{
Output = StabilityStoneCoverWaveConditionsOutputFactory.CreateOutputWithColumns(new[]
{
new TestWaveConditionsOutput(),
new TestWaveConditionsOutput()
})
};
// Call
StabilityStoneCoverWaveConditionsCalculationEntity entity = calculation.Create(registry, 0);
// Assert
ICollection <StabilityStoneCoverWaveConditionsOutputEntity> outputEntities = entity.StabilityStoneCoverWaveConditionsOutputEntities;
Assert.AreEqual(2, outputEntities.Count);
CollectionAssert.AreEqual(new[]
{
0,
1
}, outputEntities.Select(oe => oe.Order));
Assert.IsTrue(outputEntities.All(o => o.OutputType == Convert.ToByte(StabilityStoneCoverWaveConditionsOutputType.Columns)));
}
public void Run_CalculationPerformed_SetsOutput()
{
// 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())
.Repeat
.Times(GetWaterLevels(calculation, assessmentSection).Count() * 2);
mockRepository.ReplayAll();
using (new HydraRingCalculatorFactoryConfig(calculatorFactory))
{
// Call
activity.Run();
// Assert
Assert.IsNotNull(calculation.Output);
Assert.AreEqual(3, calculation.Output.ColumnsOutput.Count());
Assert.AreEqual(3, calculation.Output.BlocksOutput.Count());
}
mockRepository.VerifyAll();
}
/// <summary>
/// Reads the <see cref="StabilityStoneCoverWaveConditionsCalculationEntity"/> and use the
/// information to update a <see cref="StabilityStoneCoverWaveConditionsCalculation"/>.
/// </summary>
/// <param name="entity">
/// The <see cref="StabilityStoneCoverWaveConditionsCalculationEntity"/>
/// to create <see cref="StabilityStoneCoverWaveConditionsCalculation"/> for.
/// </param>
/// <param name="collector">The object keeping track of read operations.</param>
/// <returns>A new <see cref="StabilityStoneCoverWaveConditionsCalculation"/>.</returns>
/// <exception cref="ArgumentNullException">Thrown when any parameter is <c>null</c>.</exception>
internal static StabilityStoneCoverWaveConditionsCalculation Read(this StabilityStoneCoverWaveConditionsCalculationEntity entity, ReadConversionCollector collector)
{
if (entity == null)
{
throw new ArgumentNullException(nameof(entity));
}
if (collector == null)
{
throw new ArgumentNullException(nameof(collector));
}
var calculation = new StabilityStoneCoverWaveConditionsCalculation
{
Name = entity.Name,
Comments =
{
Body = entity.Comments
}
};
ReadCalculationInputs(calculation.InputParameters, entity, collector);
ReadCalculationOutputs(entity, calculation);
return(calculation);
}
public void CreateCalculationActivitiesForFailureMechanism_WithValidData_ExpectedInputSetToActivities()
{
// Setup
AssessmentSectionStub assessmentSection = CreateAssessmentSection();
StabilityStoneCoverFailureMechanism failureMechanism = new StabilityStoneCoverFailureMechanism();
var hydraulicBoundaryLocation = new TestHydraulicBoundaryLocation("locationName 1");
SetHydraulicBoundaryLocationToAssessmentSection(assessmentSection, hydraulicBoundaryLocation);
StabilityStoneCoverWaveConditionsCalculation calculation1 = CreateValidCalculation(hydraulicBoundaryLocation);
StabilityStoneCoverWaveConditionsCalculation calculation2 = CreateValidCalculation(hydraulicBoundaryLocation);
failureMechanism.CalculationsGroup.Children.AddRange(new[]
{
calculation1,
calculation2
});
// Call
IEnumerable <CalculatableActivity> activities =
StabilityStoneCoverWaveConditionsCalculationActivityFactory.CreateCalculationActivities(
failureMechanism,
assessmentSection);
// Assert
CollectionAssert.AllItemsAreInstancesOfType(activities, typeof(StabilityStoneCoverWaveConditionsCalculationActivity));
Assert.AreEqual(2, activities.Count());
RoundedDouble assessmentLevel = assessmentSection.WaterLevelCalculationsForSignalFloodingProbability.Single().Output.Result;
HydraulicBoundaryDatabase hydraulicBoundaryDatabase = assessmentSection.HydraulicBoundaryDatabase;
AssertStabilityStoneCoverWaveConditionsCalculationActivity(activities.ElementAt(0), calculation1, assessmentLevel, hydraulicBoundaryDatabase);
AssertStabilityStoneCoverWaveConditionsCalculationActivity(activities.ElementAt(1), calculation2, assessmentLevel, hydraulicBoundaryDatabase);
}
public void Create_CalculationWithNaNProperties_ReturnCalculationEntity()
{
// Setup
var calculation = new StabilityStoneCoverWaveConditionsCalculation
{
InputParameters =
{
Orientation = RoundedDouble.NaN,
UpperBoundaryRevetment = RoundedDouble.NaN,
LowerBoundaryRevetment = RoundedDouble.NaN,
UpperBoundaryWaterLevels = RoundedDouble.NaN,
LowerBoundaryWaterLevels = RoundedDouble.NaN,
BreakWater =
{
Height = RoundedDouble.NaN
}
}
};
var registry = new PersistenceRegistry();
// Call
StabilityStoneCoverWaveConditionsCalculationEntity entity = calculation.Create(registry, 1234);
// Assert
Assert.IsNull(entity.Orientation);
Assert.IsNull(entity.UpperBoundaryRevetment);
Assert.IsNull(entity.LowerBoundaryRevetment);
Assert.IsNull(entity.UpperBoundaryWaterLevels);
Assert.IsNull(entity.LowerBoundaryWaterLevels);
Assert.IsNull(entity.BreakWaterHeight);
}
private ContextMenuStrip WaveConditionsCalculationContextContextMenuStrip(StabilityStoneCoverWaveConditionsCalculationContext nodeData,
object parentData,
TreeViewControl treeViewControl)
{
var builder = new RiskeerContextMenuBuilder(Gui.Get(nodeData, treeViewControl));
StabilityStoneCoverWaveConditionsCalculation calculation = nodeData.WrappedData;
return(builder
.AddExportItem()
.AddSeparator()
.AddDuplicateCalculationItem(calculation, nodeData)
.AddSeparator()
.AddRenameItem()
.AddUpdateForeshoreProfileOfCalculationItem(calculation, GetInquiryHelper(),
SynchronizeCalculationWithForeshoreProfileHelper.UpdateForeshoreProfileDerivedCalculationInput)
.AddSeparator()
.AddValidateCalculationItem(nodeData,
Validate,
EnableValidateAndCalculateMenuItemForCalculation)
.AddPerformCalculationItem <StabilityStoneCoverWaveConditionsCalculation, StabilityStoneCoverWaveConditionsCalculationContext>(
nodeData, Calculate, EnableValidateAndCalculateMenuItemForCalculation)
.AddSeparator()
.AddClearCalculationOutputItem(calculation)
.AddDeleteItem()
.AddSeparator()
.AddCollapseAllItem()
.AddExpandAllItem()
.AddSeparator()
.AddPropertiesItem()
.Build());
}
public void Constructor_Always_PropertiesHaveExpectedAttributesValues()
{
// Setup
var mocks = new MockRepository();
var assessmentSection = mocks.Stub <IAssessmentSection>();
var handler = mocks.Stub <IObservablePropertyChangeHandler>();
mocks.ReplayAll();
var calculation = new StabilityStoneCoverWaveConditionsCalculation();
var context = new StabilityStoneCoverWaveConditionsInputContext(
calculation.InputParameters,
calculation,
assessmentSection,
Enumerable.Empty <ForeshoreProfile>());
// Call
var properties = new StabilityStoneCoverWaveConditionsInputContextProperties(
context, AssessmentSectionTestHelper.GetTestAssessmentLevel, handler);
// Assert
PropertyDescriptorCollection dynamicProperties = PropertiesTestHelper.GetAllVisiblePropertyDescriptors(properties);
Assert.AreEqual(16, dynamicProperties.Count);
PropertyDescriptor revetmentTypeProperty = dynamicProperties[10];
Assert.IsInstanceOf <EnumTypeConverter>(revetmentTypeProperty.Converter);
PropertiesTestHelper.AssertRequiredPropertyDescriptorProperties(revetmentTypeProperty,
"Modelinstellingen",
"Type bekleding",
"Het type van de bekleding waarvoor berekend wordt.");
mocks.VerifyAll();
}
/// <summary>
/// Creates a <see cref="StabilityStoneCoverWaveConditionsCalculationEntity"/> based on the information of the
/// <see cref="StabilityStoneCoverWaveConditionsCalculation"/>.
/// </summary>
/// <param name="calculation">The calculation to create a database entity for.</param>
/// <param name="registry">The object keeping track of create operations.</param>
/// <param name="order">The index at which <paramref name="calculation"/> resides within its parent.</param>
/// <returns>A new <see cref="StabilityStoneCoverWaveConditionsCalculationEntity"/>.</returns>
/// <exception cref="ArgumentNullException">Thrown when any parameter is <c>null</c>.</exception>
internal static StabilityStoneCoverWaveConditionsCalculationEntity Create(this StabilityStoneCoverWaveConditionsCalculation calculation,
PersistenceRegistry registry, int order)
{
if (calculation == null)
{
throw new ArgumentNullException(nameof(calculation));
}
if (registry == null)
{
throw new ArgumentNullException(nameof(registry));
}
var entity = new StabilityStoneCoverWaveConditionsCalculationEntity
{
Order = order,
Name = calculation.Name.DeepClone(),
Comments = calculation.Comments.Body.DeepClone()
};
SetInputParameters(entity, calculation.InputParameters, registry);
SetOutputEntities(entity, calculation);
return(entity);
}
public void Create_HasHydraulicLocationCalculationsForTargetProbability_EntityHasHydraulicLocationCalculationForTargetProbabilityCollectionEntity()
{
// Setup
var random = new Random(21);
var hydraulicCalculations = new HydraulicBoundaryLocationCalculationsForTargetProbability(random.NextDouble(0, 0.1));
var hydraulicCalculationsEntity = new HydraulicLocationCalculationForTargetProbabilityCollectionEntity();
var registry = new PersistenceRegistry();
registry.Register(hydraulicCalculationsEntity, hydraulicCalculations);
var calculation = new StabilityStoneCoverWaveConditionsCalculation
{
InputParameters =
{
CalculationsTargetProbability = hydraulicCalculations
}
};
// Call
StabilityStoneCoverWaveConditionsCalculationEntity entity = calculation.Create(registry, 0);
// Assert
Assert.AreSame(hydraulicCalculationsEntity, entity.HydraulicLocationCalculationForTargetProbabilityCollectionEntity);
}
public void CreateInstance_WithContextThatHasInputWithSpecificWaterLevelType_ReturnViewWithCorrespondingAssessmentLevel(
IAssessmentSection assessmentSection,
Action <WaveConditionsInput> configureInputAction,
RoundedDouble expectedAssessmentLevel)
{
// Setup
var calculation = new StabilityStoneCoverWaveConditionsCalculation();
configureInputAction(calculation.InputParameters);
var context = new StabilityStoneCoverWaveConditionsInputContext(
calculation.InputParameters,
calculation,
assessmentSection,
Array.Empty <ForeshoreProfile>());
// Call
var view = (WaveConditionsInputView)info.CreateInstance(context);
// Assert
ChartDataCollection chartData = view.Chart.Data;
var designWaterLevelChartData = (ChartLineData)chartData.Collection.ElementAt(designWaterLevelChartDataIndex);
if (expectedAssessmentLevel != RoundedDouble.NaN)
{
Assert.AreEqual(expectedAssessmentLevel, designWaterLevelChartData.Points.First().Y);
}
else
{
Assert.IsEmpty(designWaterLevelChartData.Points);
}
}
public void CreateInstance_StabilityStoneCoverWaveConditionsInputContext_ReturnViewWithStylingApplied()
{
// Setup
var calculation = new StabilityStoneCoverWaveConditionsCalculation();
var context = new StabilityStoneCoverWaveConditionsInputContext(
new StabilityStoneCoverWaveConditionsInput(),
calculation,
new AssessmentSectionStub(),
Array.Empty <ForeshoreProfile>());
// Call
var view = (WaveConditionsInputView)info.CreateInstance(context);
// Assert
ChartDataCollection chartData = view.Chart.Data;
var lowerBoundaryRevetmentChartData = (ChartLineData)chartData.Collection.ElementAt(lowerBoundaryRevetmentChartDataIndex);
var upperBoundaryRevetmentChartData = (ChartLineData)chartData.Collection.ElementAt(upperBoundaryRevetmentChartDataIndex);
var revetmentBaseChartData = (ChartLineData)chartData.Collection.ElementAt(revetmentBaseChartDataIndex);
var revetmentChartData = (ChartLineData)chartData.Collection.ElementAt(revetmentChartDataIndex);
Color revetmentLineColor = Color.Gray;
Assert.AreEqual(revetmentLineColor, lowerBoundaryRevetmentChartData.Style.Color);
Assert.AreEqual(revetmentLineColor, upperBoundaryRevetmentChartData.Style.Color);
Assert.AreEqual(Color.FromArgb(120, revetmentLineColor), revetmentBaseChartData.Style.Color);
Assert.AreEqual(revetmentLineColor, revetmentChartData.Style.Color);
}
public void Run_HydraulicBoundaryDatabaseWithCanUsePreprocessorFalse_CreateWaveConditionsCosineCalculatorAsExpected()
{
// 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(Arg <HydraRingCalculationSettings> .Is.NotNull))
.WhenCalled(invocation =>
{
HydraRingCalculationSettingsTestHelper.AssertHydraRingCalculationSettings(
HydraulicBoundaryCalculationSettingsFactory.CreateSettings(assessmentSection.HydraulicBoundaryDatabase),
(HydraRingCalculationSettings)invocation.Arguments[0]);
})
.Return(new TestWaveConditionsCosineCalculator())
.Repeat
.Times(GetWaterLevels(calculation, assessmentSection).Count() * 2);
mockRepository.ReplayAll();
using (new HydraRingCalculatorFactoryConfig(calculatorFactory))
{
// Call
activity.Run();
}
// Assert
mockRepository.VerifyAll();
}
public void Read_EntityWithNullValues_ReturnCalculationWithNaNValues()
{
// Setup
var entity = new StabilityStoneCoverWaveConditionsCalculationEntity();
var collector = new ReadConversionCollector();
// Call
StabilityStoneCoverWaveConditionsCalculation calculation = entity.Read(collector);
// Assert
Assert.IsNull(calculation.Name);
Assert.IsNull(calculation.Comments.Body);
StabilityStoneCoverWaveConditionsInput calculationInput = calculation.InputParameters;
Assert.IsNaN(calculationInput.BreakWater.Height);
Assert.IsNaN(calculationInput.Orientation);
Assert.IsNaN(calculationInput.UpperBoundaryRevetment);
Assert.IsNaN(calculationInput.LowerBoundaryRevetment);
Assert.IsNaN(calculationInput.UpperBoundaryWaterLevels);
Assert.IsNaN(calculationInput.LowerBoundaryWaterLevels);
Assert.IsNull(calculationInput.HydraulicBoundaryLocation);
Assert.IsNull(calculationInput.ForeshoreProfile);
Assert.IsNull(calculation.Output);
}
public void CreateCalculationFeatures_GivenCalculations_ReturnsCalculationFeaturesCollection()
{
// Setup
var calculationA = new StabilityStoneCoverWaveConditionsCalculation();
var calculationB = new StabilityStoneCoverWaveConditionsCalculation();
calculationA.InputParameters.ForeshoreProfile = new TestForeshoreProfile(new Point2D(1.0, 3.0));
calculationB.InputParameters.ForeshoreProfile = new TestForeshoreProfile(new Point2D(1.0, 4.0));
calculationA.InputParameters.HydraulicBoundaryLocation = new HydraulicBoundaryLocation(1, string.Empty, 5.0, 4.0);
calculationB.InputParameters.HydraulicBoundaryLocation = new HydraulicBoundaryLocation(1, string.Empty, 2.2, 3.8);
// Call
IEnumerable <MapFeature> features = StabilityStoneCoverMapDataFeaturesFactory.CreateCalculationFeatures(new[]
{
calculationA,
calculationB
});
// Assert
Assert.AreEqual(2, features.Count());
Assert.AreEqual(1, features.ElementAt(0).MapGeometries.Count());
Assert.AreEqual(1, features.ElementAt(1).MapGeometries.Count());
AssertEqualPointCollections(new[]
{
new Point2D(1.0, 3.0),
new Point2D(5.0, 4.0)
}, features.ElementAt(0).MapGeometries.ElementAt(0));
AssertEqualPointCollections(new[]
{
new Point2D(1.0, 4.0),
new Point2D(2.2, 3.8)
}, features.ElementAt(1).MapGeometries.ElementAt(0));
}
public DerivedStabilityStoneCoverWaveConditionsCalculationContext(StabilityStoneCoverWaveConditionsCalculation wrappedData,
CalculationGroup parent,
StabilityStoneCoverFailureMechanism failureMechanism,
IAssessmentSection assessmentSection)
: base(wrappedData, parent, failureMechanism, assessmentSection)
{
}
/// <summary>
/// Method that asserts whether <paramref name="original"/> and <paramref name="clone"/>
/// are clones.
/// </summary>
/// <param name="original">The original object.</param>
/// <param name="clone">The cloned object.</param>
/// <exception cref="AssertionException">Thrown when <paramref name="original"/> and
/// <paramref name="clone"/> are not clones.</exception>
public static void AreClones(StabilityStoneCoverWaveConditionsCalculation original, StabilityStoneCoverWaveConditionsCalculation clone)
{
Assert.AreEqual(original.Name, clone.Name);
CoreCloneAssert.AreObjectClones(original.Comments, clone.Comments, CommonCloneAssert.AreClones);
CoreCloneAssert.AreObjectClones(original.InputParameters, clone.InputParameters, AreClones);
CoreCloneAssert.AreObjectClones(original.Output, clone.Output, AreClones);
}
private IEnumerable <WaveConditionsOutput> CalculateBlocks(StabilityStoneCoverWaveConditionsCalculation calculation,
IAssessmentSection assessmentSection, RoundedDouble assessmentLevel,
GeneralWaveConditionsInput generalInput, double targetProbability)
{
return(Calculate(calculation, assessmentSection, assessmentLevel, generalInput, targetProbability,
Resources.StabilityStoneCoverWaveConditions_Blocks_DisplayName));
}
public void Constructor_ExpectedValues()
{
// Setup
var mockRepository = new MockRepository();
var assessmentSection = mockRepository.Stub <IAssessmentSection>();
var handler = mockRepository.Stub <IObservablePropertyChangeHandler>();
mockRepository.ReplayAll();
var calculation = new StabilityStoneCoverWaveConditionsCalculation();
var context = new StabilityStoneCoverWaveConditionsInputContext(
calculation.InputParameters,
calculation,
assessmentSection,
Enumerable.Empty <ForeshoreProfile>());
// Call
var properties = new StabilityStoneCoverWaveConditionsInputContextProperties(context, () => (RoundedDouble)1.1, handler);
// Assert
Assert.IsInstanceOf <WaveConditionsInputContextProperties <
StabilityStoneCoverWaveConditionsInputContext, StabilityStoneCoverWaveConditionsInput,
StabilityStoneCoverWaveConditionsCalculationType> >(properties);
Assert.AreSame(context, properties.Data);
Assert.AreEqual(calculation.InputParameters.CalculationType, properties.RevetmentType);
mockRepository.VerifyAll();
}
public void RevetmentType_Always_InputChangedAndObservablesNotified()
{
// Setup
var mocks = new MockRepository();
var assessmentSection = mocks.Stub <IAssessmentSection>();
var observable = mocks.StrictMock <IObservable>();
observable.Expect(o => o.NotifyObservers());
mocks.ReplayAll();
var calculation = new StabilityStoneCoverWaveConditionsCalculation();
var context = new StabilityStoneCoverWaveConditionsInputContext(
calculation.InputParameters,
calculation,
assessmentSection,
Enumerable.Empty <ForeshoreProfile>());
var customHandler = new SetPropertyValueAfterConfirmationParameterTester(new[]
{
observable
});
var properties = new StabilityStoneCoverWaveConditionsInputContextProperties(
context, AssessmentSectionTestHelper.GetTestAssessmentLevel, customHandler);
var calculationType = new Random(21).NextEnumValue <StabilityStoneCoverWaveConditionsCalculationType>();
// Call
properties.RevetmentType = calculationType;
// Assert
Assert.IsTrue(customHandler.Called);
mocks.VerifyAll();
}
public void CreateInstance_WithContextThatHasInputWithSpecificWaterLevelType_ExpectedProperties(
IAssessmentSection assessmentSection,
Action <WaveConditionsInput> configureInputAction,
RoundedDouble expectedAssessmentLevel)
{
// Setup
var calculation = new StabilityStoneCoverWaveConditionsCalculation();
configureInputAction(calculation.InputParameters);
var context = new StabilityStoneCoverWaveConditionsInputContext(calculation.InputParameters,
calculation,
assessmentSection,
Array.Empty <ForeshoreProfile>());
using (var plugin = new StabilityStoneCoverPlugin())
{
PropertyInfo info = GetInfo(plugin);
// Call
IObjectProperties objectProperties = info.CreateInstance(context);
// Assert
Assert.IsInstanceOf <StabilityStoneCoverWaveConditionsInputContextProperties>(objectProperties);
Assert.AreSame(context, objectProperties.Data);
Assert.AreEqual(expectedAssessmentLevel, ((StabilityStoneCoverWaveConditionsInputContextProperties)objectProperties).AssessmentLevel);
}
}
public void CreateCalculationActivitiesForCalculationGroup_WithValidCalculations_ReturnsStabilityStoneCoverWaveConditionsCalculationActivitiesWithParametersSet()
{
// Setup
StabilityStoneCoverFailureMechanism failureMechanism = new StabilityStoneCoverFailureMechanism();
AssessmentSectionStub assessmentSection = CreateAssessmentSection();
var hydraulicBoundaryLocation = new TestHydraulicBoundaryLocation();
SetHydraulicBoundaryLocationToAssessmentSection(assessmentSection, hydraulicBoundaryLocation);
StabilityStoneCoverWaveConditionsCalculation calculation1 = CreateValidCalculation(hydraulicBoundaryLocation);
StabilityStoneCoverWaveConditionsCalculation calculation2 = CreateValidCalculation(hydraulicBoundaryLocation);
var calculations = new CalculationGroup
{
Children =
{
calculation1,
calculation2
}
};
// Call
IEnumerable <CalculatableActivity> activities = StabilityStoneCoverWaveConditionsCalculationActivityFactory.CreateCalculationActivities(
calculations, failureMechanism, assessmentSection);
// Assert
CollectionAssert.AllItemsAreInstancesOfType(activities, typeof(StabilityStoneCoverWaveConditionsCalculationActivity));
Assert.AreEqual(2, activities.Count());
RoundedDouble assessmentLevel = assessmentSection.WaterLevelCalculationsForSignalFloodingProbability.Single().Output.Result;
HydraulicBoundaryDatabase hydraulicBoundaryDatabase = assessmentSection.HydraulicBoundaryDatabase;
AssertStabilityStoneCoverWaveConditionsCalculationActivity(activities.First(), calculation1, assessmentLevel, hydraulicBoundaryDatabase);
AssertStabilityStoneCoverWaveConditionsCalculationActivity(activities.ElementAt(1), calculation2, assessmentLevel, hydraulicBoundaryDatabase);
}
private static void Validate(StabilityStoneCoverWaveConditionsCalculationContext context)
{
IAssessmentSection assessmentSection = context.AssessmentSection;
StabilityStoneCoverWaveConditionsCalculation calculation = context.WrappedData;
WaveConditionsCalculationServiceBase.Validate(calculation.InputParameters,
WaveConditionsInputHelper.GetAssessmentLevel(calculation.InputParameters, context.AssessmentSection),
assessmentSection.HydraulicBoundaryDatabase);
}
public void GivenValidCalculations_WhenCalculatingAllFromContextMenu_ThenAllCalculationsScheduled()
{
// Given
var failureMechanism = new StabilityStoneCoverFailureMechanism();
IAssessmentSection assessmentSection = CreateAssessmentSectionWithHydraulicBoundaryOutput();
HydraulicBoundaryLocation hydraulicBoundaryLocation = assessmentSection.HydraulicBoundaryDatabase.Locations.First();
StabilityStoneCoverWaveConditionsCalculation calculationA = GetValidCalculation(hydraulicBoundaryLocation);
StabilityStoneCoverWaveConditionsCalculation calculationB = GetValidCalculation(hydraulicBoundaryLocation);
List <ICalculationBase> calculations = failureMechanism.CalculationsGroup.Children;
calculations.AddRange(new[]
{
calculationA,
calculationB
});
var nodeData = new StabilityStoneCoverFailureMechanismContext(failureMechanism, assessmentSection);
using (var treeViewControl = new TreeViewControl())
{
IMainWindow mainWindow = MainWindowTestHelper.CreateMainWindowStub(mocks);
var gui = mocks.Stub <IGui>();
gui.Stub(g => g.Get(nodeData, treeViewControl)).Return(new CustomItemsOnlyContextMenuBuilder());
gui.Stub(g => g.MainWindow).Return(mainWindow);
var calculatorFactory = mocks.Stub <IHydraRingCalculatorFactory>();
calculatorFactory.Expect(cf => cf.CreateWaveConditionsCosineCalculator(Arg <HydraRingCalculationSettings> .Is.NotNull))
.WhenCalled(invocation =>
{
HydraRingCalculationSettingsTestHelper.AssertHydraRingCalculationSettings(
HydraulicBoundaryCalculationSettingsFactory.CreateSettings(assessmentSection.HydraulicBoundaryDatabase),
(HydraRingCalculationSettings)invocation.Arguments[0]);
})
.Return(new TestWaveConditionsCosineCalculator())
.Repeat
.Times(12);
mocks.ReplayAll();
plugin.Gui = gui;
using (new HydraRingCalculatorFactoryConfig(calculatorFactory))
using (ContextMenuStrip contextMenu = info.ContextMenuStrip(nodeData, null, treeViewControl))
{
// When
contextMenu.Items[contextMenuCalculateAllIndex].PerformClick();
// Then
Assert.AreEqual(3, calculationA.Output.BlocksOutput.Count());
Assert.AreEqual(3, calculationA.Output.ColumnsOutput.Count());
Assert.AreEqual(3, calculationB.Output.BlocksOutput.Count());
Assert.AreEqual(3, calculationB.Output.ColumnsOutput.Count());
}
}
}
public void Cancel_WhenPerformingCalculationForBlocks_CurrentCalculationForWaterLevelCompletesAndSubsequentCalculationsDidNotRun()
{
// 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>();
var calculator = new TestWaveConditionsCosineCalculator();
calculatorFactory.Expect(cf => cf.CreateWaveConditionsCosineCalculator(null))
.IgnoreArguments()
.Return(calculator);
mockRepository.ReplayAll();
using (new HydraRingCalculatorFactoryConfig(calculatorFactory))
{
activity.ProgressChanged += (sender, args) =>
{
if (activity.State != ActivityState.Canceled && activity.ProgressText.Contains("Stap 1 van 6"))
{
// Call
activity.Cancel();
}
};
// Assert
TestHelper.AssertLogMessages(() => activity.Run(), messages =>
{
string[] msgs = messages.ToArray();
RoundedDouble firstWaterLevel = GetWaterLevels(calculation, assessmentSection).First();
Assert.AreEqual(10, msgs.Length);
Assert.AreEqual($"Golfcondities berekenen voor '{calculation.Name}' is gestart.", msgs[0]);
CalculationServiceTestHelper.AssertValidationStartMessage(msgs[1]);
CalculationServiceTestHelper.AssertValidationEndMessage(msgs[2]);
CalculationServiceTestHelper.AssertCalculationStartMessage(msgs[3]);
Assert.AreEqual("Berekening voor blokken is gestart.", msgs[4]);
Assert.AreEqual($"Berekening voor waterstand '{firstWaterLevel}' is gestart.", msgs[5]);
StringAssert.StartsWith("Golfcondities berekening is uitgevoerd op de tijdelijke locatie", msgs[6]);
Assert.AreEqual($"Berekening voor waterstand '{firstWaterLevel}' is beëindigd.", msgs[7]);
Assert.AreEqual("Berekening voor blokken is beëindigd.", msgs[8]);
CalculationServiceTestHelper.AssertCalculationEndMessage(msgs[9]);
});
Assert.AreEqual(ActivityState.Canceled, activity.State);
}
mockRepository.VerifyAll();
}
public void Export_ValidData_ReturnTrueAndWritesFile()
{
// Setup
var calculation1 = new StabilityStoneCoverWaveConditionsCalculation
{
Name = "Calculation A",
InputParameters =
{
ForeshoreProfile = new TestForeshoreProfile("ForeshoreA"),
WaterLevelType = WaveConditionsInputWaterLevelType.MaximumAllowableFloodingProbability
}
};
var calculation2 = new StabilityStoneCoverWaveConditionsCalculation
{
Name = "PK001_0002 W1-6_4_1D1",
InputParameters =
{
HydraulicBoundaryLocation = new HydraulicBoundaryLocation(1, "HydraulicLocationA", 0, 0),
UseBreakWater = true,
CalculationType = StabilityStoneCoverWaveConditionsCalculationType.Blocks
}
};
var calculationGroup2 = new CalculationGroup
{
Name = "PK001_0002",
Children =
{
calculation2
}
};
var calculationGroup = new CalculationGroup
{
Name = "PK001_0001",
Children =
{
calculation1,
calculationGroup2
}
};
string expectedXmlFilePath = TestHelper.GetTestDataPath(TestDataPath.Riskeer.StabilityStoneCover.IO,
Path.Combine(
nameof(StabilityStoneCoverWaveConditionsCalculationConfigurationExporter),
"fullValidConfiguration.xml"));
// Call & Assert
WriteAndValidate(new[]
{
calculationGroup
}, expectedXmlFilePath);
}
public void Clone_NotAllPropertiesSet_ReturnNewInstanceWithCopiedValues()
{
// Setup
var original = new StabilityStoneCoverWaveConditionsCalculation();
// Call
object clone = original.Clone();
// Assert
CoreCloneAssert.AreObjectClones(original, clone, StabilityStoneCoverCloneAssert.AreClones);
}
public void Run_CalculationWithInvalidHydraulicBoundaryDatabaseFilePath_DoesNotPerformCalculationAndLogsError()
{
// Setup
string invalidFilePath = Path.Combine(testDataPath, "NonExisting.sqlite");
var assessmentSection = new AssessmentSectionStub
{
HydraulicBoundaryDatabase =
{
FilePath = invalidFilePath
}
};
var hydraulicBoundaryLocation = new TestHydraulicBoundaryLocation();
assessmentSection.SetHydraulicBoundaryLocationCalculations(new[]
{
hydraulicBoundaryLocation
});
StabilityStoneCoverWaveConditionsCalculation calculation = CreateValidCalculation(hydraulicBoundaryLocation);
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("Herstellen van de verbinding met de hydraulische belastingendatabase is mislukt. " +
$"Fout bij het lezen van bestand '{invalidFilePath}': het bestand bestaat niet.", msgs[2]);
CalculationServiceTestHelper.AssertValidationEndMessage(msgs[3]);
});
Assert.AreEqual(ActivityState.Failed, activity.State);
}
mockRepository.VerifyAll();
}
public void Create_PersistenceRegistryNull_ThrowArgumentNullException()
{
// Setup
var calculation = new StabilityStoneCoverWaveConditionsCalculation();
// Call
TestDelegate call = () => calculation.Create(null, 0);
// Assert
string paramName = Assert.Throws <ArgumentNullException>(call).ParamName;
Assert.AreEqual(paramName, "registry");
}
public void CreateCalculationActivity_AssessmentSectionNull_ThrowsArgumentNullException()
{
// Setup
var calculation = new StabilityStoneCoverWaveConditionsCalculation();
var failureMechanism = new StabilityStoneCoverFailureMechanism();
// Call
void Call() => StabilityStoneCoverWaveConditionsCalculationActivityFactory.CreateCalculationActivity(calculation, failureMechanism, null);
// Assert
var exception = Assert.Throws <ArgumentNullException>(Call);
Assert.AreEqual("assessmentSection", exception.ParamName);
}
private IEnumerable <WaveConditionsOutput> Calculate(StabilityStoneCoverWaveConditionsCalculation calculation,
IAssessmentSection assessmentSection, RoundedDouble assessmentLevel,
GeneralWaveConditionsInput generalInput, double targetProbability,
string calculationType)
{
log.InfoFormat(RevetmentServiceResources.WaveConditionsCalculationService_Calculate_calculationType_0_started, calculationType);
IEnumerable <WaveConditionsOutput> outputs = CalculateWaveConditions(calculation.InputParameters,
assessmentLevel, generalInput.A,
generalInput.B, generalInput.C, targetProbability,
assessmentSection.HydraulicBoundaryDatabase);
log.InfoFormat(RevetmentServiceResources.WaveConditionsCalculationService_Calculate_calculationType_0_ended, calculationType);
return(outputs);
}
