public void ParameteredConstructor_ExpectedValues(bool hasParent)
{
// Setup
var mocks = new MockRepository();
var assessmentSection = mocks.Stub <IAssessmentSection>();
mocks.ReplayAll();
var failureMechanism = new StabilityStoneCoverFailureMechanism();
var calculationGroup = new CalculationGroup();
CalculationGroup parent = hasParent ? new CalculationGroup() : null;
// Call
var context = new StabilityStoneCoverCalculationGroupContext(calculationGroup, parent, failureMechanism, assessmentSection);
// Assert
Assert.IsInstanceOf <StabilityStoneCoverContext <CalculationGroup> >(context);
Assert.IsInstanceOf <ICalculationContext <CalculationGroup, StabilityStoneCoverFailureMechanism> >(context);
Assert.AreSame(calculationGroup, context.WrappedData);
Assert.AreSame(parent, context.Parent);
Assert.AreSame(failureMechanism, context.FailureMechanism);
Assert.AreSame(assessmentSection, context.AssessmentSection);
mocks.VerifyAll();
}
public void IsEnabled_CalculationGroupWithChildren_ReturnTrue(bool hasNestedGroup, bool hasCalculation)
{
// Setup
var assessmentSection = mocks.Stub <IAssessmentSection>();
mocks.ReplayAll();
var calculationGroup = new CalculationGroup();
if (hasNestedGroup)
{
calculationGroup.Children.Add(new CalculationGroup());
}
if (hasCalculation)
{
calculationGroup.Children.Add(new StabilityStoneCoverWaveConditionsCalculation());
}
var context = new StabilityStoneCoverCalculationGroupContext(calculationGroup,
null,
new StabilityStoneCoverFailureMechanism(),
assessmentSection);
// Call
bool isEnabled = info.IsEnabled(context);
// Assert
Assert.IsTrue(isEnabled);
}
private static object[] CalculationGroupContextChildNodeObjects(StabilityStoneCoverCalculationGroupContext nodeData)
{
var childNodeObjects = new List <object>();
foreach (ICalculationBase item in nodeData.WrappedData.Children)
{
if (item is StabilityStoneCoverWaveConditionsCalculation calculation)
{
childNodeObjects.Add(new StabilityStoneCoverWaveConditionsCalculationContext(calculation,
nodeData.WrappedData,
nodeData.FailureMechanism,
nodeData.AssessmentSection));
}
else if (item is CalculationGroup group)
{
childNodeObjects.Add(new StabilityStoneCoverCalculationGroupContext(group,
nodeData.WrappedData,
nodeData.FailureMechanism,
nodeData.AssessmentSection));
}
else
{
childNodeObjects.Add(item);
}
}
return(childNodeObjects.ToArray());
}
private void CalculateAllInCalculationGroup(StabilityStoneCoverCalculationGroupContext context)
{
ActivityProgressDialogRunner.Run(
Gui.MainWindow,
StabilityStoneCoverWaveConditionsCalculationActivityFactory.CreateCalculationActivities(context.WrappedData,
context.FailureMechanism,
context.AssessmentSection));
}
private static void CalculationGroupContextOnNodeRemoved(StabilityStoneCoverCalculationGroupContext nodeData, object parentNodeData)
{
var parentGroupContext = (StabilityStoneCoverCalculationGroupContext)parentNodeData;
parentGroupContext.WrappedData.Children.Remove(nodeData.WrappedData);
parentGroupContext.NotifyObservers();
}
private static void ValidateAllInCalculationGroup(StabilityStoneCoverCalculationGroupContext context)
{
foreach (StabilityStoneCoverWaveConditionsCalculation calculation in context.WrappedData.GetCalculations().OfType <StabilityStoneCoverWaveConditionsCalculation>())
{
WaveConditionsCalculationServiceBase.Validate(calculation.InputParameters,
WaveConditionsInputHelper.GetAssessmentLevel(calculation.InputParameters, context.AssessmentSection),
context.AssessmentSection.HydraulicBoundaryDatabase);
}
}
private void ShowHydraulicBoundaryLocationSelectionDialog(StabilityStoneCoverCalculationGroupContext nodeData)
{
using (var dialog = new HydraulicBoundaryLocationSelectionDialog(Gui.MainWindow, nodeData.AssessmentSection.HydraulicBoundaryDatabase.Locations))
{
dialog.ShowDialog();
if (dialog.SelectedItems.Any())
{
GenerateStabilityStoneCoverCalculations(dialog.SelectedItems,
nodeData.WrappedData.Children,
nodeData.AssessmentSection.FailureMechanismContribution.NormativeProbabilityType);
nodeData.NotifyObservers();
}
}
}
private static void AddWaveConditionsCalculation(StabilityStoneCoverCalculationGroupContext nodeData)
{
var calculation = new StabilityStoneCoverWaveConditionsCalculation
{
Name = NamingHelper.GetUniqueName(nodeData.WrappedData.Children,
RiskeerCommonDataResources.Calculation_DefaultName,
c => c.Name)
};
WaveConditionsInputHelper.SetWaterLevelType(calculation.InputParameters,
nodeData.AssessmentSection.FailureMechanismContribution.NormativeProbabilityType);
nodeData.WrappedData.Children.Add(calculation);
nodeData.WrappedData.NotifyObservers();
}
private StrictContextMenuItem CreateGenerateWaveConditionsCalculationsItem(StabilityStoneCoverCalculationGroupContext nodeData)
{
bool locationsAvailable = nodeData.AssessmentSection.HydraulicBoundaryDatabase.Locations.Any();
string calculationGroupContextToolTip = locationsAvailable
? RiskeerCommonFormsResources.CalculationGroup_CreateGenerateHydraulicBoundaryCalculationsItem_ToolTip
: RiskeerCommonFormsResources.CalculationGroup_No_HydraulicBoundaryDatabase_To_Generate_ToolTip;
return(new StrictContextMenuItem(RiskeerCommonFormsResources.CalculationGroup_Generate_calculations,
calculationGroupContextToolTip,
RiskeerCommonFormsResources.GenerateScenariosIcon,
(sender, args) => ShowHydraulicBoundaryLocationSelectionDialog(nodeData))
{
Enabled = locationsAvailable
});
}
public void IsEnabled_CalculationGroupNoChildren_ReturnFalse()
{
// Setup
var assessmentSection = mocks.Stub <IAssessmentSection>();
mocks.ReplayAll();
var context = new StabilityStoneCoverCalculationGroupContext(new CalculationGroup(),
null,
new StabilityStoneCoverFailureMechanism(),
assessmentSection);
// Call
bool isEnabled = info.IsEnabled(context);
// Assert
Assert.IsFalse(isEnabled);
}
public void CreateFileExporter_Always_ReturnFileExporter()
{
// Setup
var assessmentSection = mocks.Stub <IAssessmentSection>();
mocks.ReplayAll();
var failureMechanism = new StabilityStoneCoverFailureMechanism();
var calculationGroup = new CalculationGroup();
var context = new StabilityStoneCoverCalculationGroupContext(calculationGroup, null, failureMechanism, assessmentSection);
// Call
IFileExporter fileExporter = info.CreateFileExporter(context, "test");
// Assert
Assert.IsInstanceOf <WaveConditionsExporterBase>(fileExporter);
}
public void CreateFileExporter_Always_ReturnFileExporter()
{
// Setup
var assessmentSection = mocks.Stub <IAssessmentSection>();
assessmentSection.Stub(section => section.FailureMechanismContribution).Return(new FailureMechanismContribution(0.1, 0.1));
mocks.ReplayAll();
var context = new StabilityStoneCoverCalculationGroupContext(new CalculationGroup(),
null,
new StabilityStoneCoverFailureMechanism(),
assessmentSection);
// Call
IFileExporter fileExporter = info.CreateFileExporter(context, "test");
// Assert
Assert.IsInstanceOf <StabilityStoneCoverWaveConditionsCalculationConfigurationExporter>(fileExporter);
}
public void IsEnabled_CalculationWithoutOutput_ReturnFalse()
{
// Setup
var assessmentSection = mocks.Stub <IAssessmentSection>();
mocks.ReplayAll();
var failureMechanism = new StabilityStoneCoverFailureMechanism();
var calculationGroup = new CalculationGroup();
calculationGroup.Children.Add(new StabilityStoneCoverWaveConditionsCalculation());
var context = new StabilityStoneCoverCalculationGroupContext(calculationGroup, null, failureMechanism, assessmentSection);
// Call
bool isEnabled = info.IsEnabled(context);
// Assert
Assert.IsFalse(isEnabled);
}
public void IsEnabled_CalculationWithOrWithoutOutputInSubFolder_ReturnExpectedEnabledState(bool hasOutput)
{
// Setup
var assessmentSection = mocks.Stub <IAssessmentSection>();
mocks.ReplayAll();
var failureMechanism = new StabilityStoneCoverFailureMechanism();
var calculationGroup = new CalculationGroup();
StabilityStoneCoverWaveConditionsOutput stabilityStoneCoverWaveConditionsOutput = null;
if (hasOutput)
{
stabilityStoneCoverWaveConditionsOutput = StabilityStoneCoverWaveConditionsOutputTestFactory.Create();
}
calculationGroup.Children.Add(
new CalculationGroup
{
Children =
{
new StabilityStoneCoverWaveConditionsCalculation
{
Output = stabilityStoneCoverWaveConditionsOutput
}
}
});
var context = new StabilityStoneCoverCalculationGroupContext(calculationGroup, null, failureMechanism, assessmentSection);
// Call
bool isEnabled = info.IsEnabled(context);
// Assert
Assert.AreEqual(hasOutput, isEnabled);
}
public void CreateFileImporter_Always_ReturnFileImporter()
{
// Setup
var failureMechanism = new StabilityStoneCoverFailureMechanism();
var mocks = new MockRepository();
IAssessmentSection assessmentSection = AssessmentSectionTestHelper.CreateAssessmentSectionStub(failureMechanism, mocks);
assessmentSection.Stub(section => section.WaterLevelCalculationsForUserDefinedTargetProbabilities)
.Return(new ObservableList <HydraulicBoundaryLocationCalculationsForTargetProbability>());
mocks.ReplayAll();
var context = new StabilityStoneCoverCalculationGroupContext(new CalculationGroup(),
null,
failureMechanism,
assessmentSection);
// Call
IFileImporter importer = importInfo.CreateFileImporter(context, "");
// Assert
Assert.IsInstanceOf <StabilityStoneCoverWaveConditionsCalculationConfigurationImporter>(importer);
mocks.VerifyAll();
}
private ContextMenuStrip CalculationGroupContextContextMenuStrip(StabilityStoneCoverCalculationGroupContext nodeData,
object parentData,
TreeViewControl treeViewControl)
{
CalculationGroup group = nodeData.WrappedData;
IInquiryHelper inquiryHelper = GetInquiryHelper();
var builder = new RiskeerContextMenuBuilder(Gui.Get(nodeData, treeViewControl));
bool isNestedGroup = parentData is StabilityStoneCoverCalculationGroupContext;
StabilityStoneCoverWaveConditionsCalculation[] calculations = group
.GetCalculations()
.OfType <StabilityStoneCoverWaveConditionsCalculation>()
.ToArray();
builder.AddImportItem()
.AddExportItem()
.AddSeparator();
if (isNestedGroup)
{
builder.AddDuplicateCalculationItem(group, nodeData)
.AddSeparator();
}
else
{
builder.AddCustomItem(CreateGenerateWaveConditionsCalculationsItem(nodeData))
.AddSeparator();
}
builder.AddCreateCalculationGroupItem(group)
.AddCreateCalculationItem(nodeData, AddWaveConditionsCalculation, CalculationType.Hydraulic)
.AddSeparator();
if (isNestedGroup)
{
builder.AddRenameItem();
}
builder.AddUpdateForeshoreProfileOfCalculationsItem(calculations, inquiryHelper,
SynchronizeCalculationWithForeshoreProfileHelper.UpdateForeshoreProfileDerivedCalculationInput)
.AddSeparator()
.AddValidateAllCalculationsInGroupItem(nodeData,
ValidateAllInCalculationGroup,
EnableValidateAndCalculateMenuItemForCalculationGroup)
.AddPerformAllCalculationsInGroupItem(nodeData,
CalculateAllInCalculationGroup,
EnableValidateAndCalculateMenuItemForCalculationGroup)
.AddSeparator()
.AddClearAllCalculationOutputInGroupItem(group);
if (isNestedGroup)
{
builder.AddDeleteItem();
}
else
{
builder.AddRemoveAllChildrenItem();
}
return(builder.AddSeparator()
.AddCollapseAllItem()
.AddExpandAllItem()
.AddSeparator()
.AddPropertiesItem()
.Build());
}
private static string EnableValidateAndCalculateMenuItemForCalculationGroup(StabilityStoneCoverCalculationGroupContext context)
{
return(EnableValidateAndCalculateMenuItem(context.AssessmentSection));
}
