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 GrassCoverErosionOutwardsWaveConditionsCalculation());
}
var context = new GrassCoverErosionOutwardsCalculationGroupContext(calculationGroup,
null,
new GrassCoverErosionOutwardsFailureMechanism(),
assessmentSection);
// Call
bool isEnabled = info.IsEnabled(context);
// Assert
Assert.IsTrue(isEnabled);
}
public void ParameteredConstructor_ExpectedValues(bool hasParent)
{
// Setup
var mocks = new MockRepository();
var assessmentSection = mocks.Stub <IAssessmentSection>();
mocks.ReplayAll();
var calculationGroup = new CalculationGroup();
var failureMechanism = new GrassCoverErosionOutwardsFailureMechanism();
CalculationGroup parent = hasParent ? new CalculationGroup() : null;
// Call
var context = new GrassCoverErosionOutwardsCalculationGroupContext(calculationGroup, parent, failureMechanism, assessmentSection);
// Assert
Assert.IsInstanceOf <GrassCoverErosionOutwardsContext <CalculationGroup> >(context);
Assert.IsInstanceOf <ICalculationContext <CalculationGroup, GrassCoverErosionOutwardsFailureMechanism> >(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_CalculationWithOrWithoutOutput_ReturnExpectedEnabledState(bool hasOutput)
{
// Setup
var assessmentSection = mocks.Stub <IAssessmentSection>();
mocks.ReplayAll();
var failureMechanism = new GrassCoverErosionOutwardsFailureMechanism();
var calculationGroup = new CalculationGroup();
var calculation = new GrassCoverErosionOutwardsWaveConditionsCalculation();
if (hasOutput)
{
calculation.Output = GrassCoverErosionOutwardsWaveConditionsOutputTestFactory.Create();
}
calculationGroup.Children.Add(calculation);
var context = new GrassCoverErosionOutwardsCalculationGroupContext(calculationGroup, null, failureMechanism, assessmentSection);
// Call
bool isEnabled = info.IsEnabled(context);
// Assert
Assert.AreEqual(hasOutput, isEnabled);
}
private static object[] CalculationGroupChildrenNodeObjects(GrassCoverErosionOutwardsCalculationGroupContext nodeData)
{
var childNodeObjects = new List <object>();
foreach (ICalculationBase item in nodeData.WrappedData.Children)
{
if (item is GrassCoverErosionOutwardsWaveConditionsCalculation calculation)
{
childNodeObjects.Add(new GrassCoverErosionOutwardsWaveConditionsCalculationContext(calculation,
nodeData.WrappedData,
nodeData.FailureMechanism,
nodeData.AssessmentSection));
}
else if (item is CalculationGroup group)
{
childNodeObjects.Add(new GrassCoverErosionOutwardsCalculationGroupContext(group,
nodeData.WrappedData,
nodeData.FailureMechanism,
nodeData.AssessmentSection));
}
else
{
childNodeObjects.Add(item);
}
}
return(childNodeObjects.ToArray());
}
private void CalculateAllInCalculationGroup(GrassCoverErosionOutwardsCalculationGroupContext context)
{
ActivityProgressDialogRunner.Run(
Gui.MainWindow,
GrassCoverErosionOutwardsCalculationActivityFactory.CreateWaveConditionsCalculationActivities(context.WrappedData,
context.FailureMechanism,
context.AssessmentSection));
}
private static void CalculationGroupContextOnNodeRemoved(GrassCoverErosionOutwardsCalculationGroupContext nodeData,
object parentNodeData)
{
var parentGroupContext = (GrassCoverErosionOutwardsCalculationGroupContext)parentNodeData;
parentGroupContext.WrappedData.Children.Remove(nodeData.WrappedData);
parentGroupContext.NotifyObservers();
}
private static void ValidateAllInCalculationGroup(GrassCoverErosionOutwardsCalculationGroupContext context)
{
CalculationGroup calculationGroup = context.WrappedData;
foreach (GrassCoverErosionOutwardsWaveConditionsCalculation calculation in calculationGroup.GetCalculations().OfType <GrassCoverErosionOutwardsWaveConditionsCalculation>())
{
WaveConditionsCalculationServiceBase.Validate(
calculation.InputParameters,
WaveConditionsInputHelper.GetAssessmentLevel(calculation.InputParameters, context.AssessmentSection),
context.AssessmentSection.HydraulicBoundaryDatabase);
}
}
private static void AddWaveConditionsCalculation(GrassCoverErosionOutwardsCalculationGroupContext nodeData)
{
var calculation = new GrassCoverErosionOutwardsWaveConditionsCalculation
{
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 void ShowHydraulicBoundaryLocationSelectionDialog(GrassCoverErosionOutwardsCalculationGroupContext nodeData)
{
using (var dialog = new HydraulicBoundaryLocationSelectionDialog(Gui.MainWindow, nodeData.AssessmentSection.HydraulicBoundaryDatabase.Locations))
{
dialog.ShowDialog();
if (dialog.SelectedItems.Any())
{
GenerateGrassCoverErosionOutwardsWaveConditionsCalculations(dialog.SelectedItems,
nodeData.WrappedData.Children,
nodeData.AssessmentSection.FailureMechanismContribution.NormativeProbabilityType);
nodeData.NotifyObservers();
}
}
}
private StrictContextMenuItem CreateGenerateWaveConditionsCalculationsItem(GrassCoverErosionOutwardsCalculationGroupContext 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 GrassCoverErosionOutwardsCalculationGroupContext(new CalculationGroup(),
null,
new GrassCoverErosionOutwardsFailureMechanism(),
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 GrassCoverErosionOutwardsFailureMechanism();
var calculationGroup = new CalculationGroup();
var context = new GrassCoverErosionOutwardsCalculationGroupContext(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 GrassCoverErosionOutwardsCalculationGroupContext(new CalculationGroup(),
null,
new GrassCoverErosionOutwardsFailureMechanism(),
assessmentSection);
// Call
IFileExporter fileExporter = info.CreateFileExporter(context, "test");
// Assert
Assert.IsInstanceOf <GrassCoverErosionOutwardsWaveConditionsCalculationConfigurationExporter>(fileExporter);
}
public void CreateFileImporter_Always_ReturnFileImporter()
{
// Setup
var failureMechanism = new GrassCoverErosionOutwardsFailureMechanism();
var mocks = new MockRepository();
IAssessmentSection assessmentSection = AssessmentSectionTestHelper.CreateAssessmentSectionStub(failureMechanism, mocks);
assessmentSection.Stub(section => section.WaterLevelCalculationsForUserDefinedTargetProbabilities)
.Return(new ObservableList <HydraulicBoundaryLocationCalculationsForTargetProbability>());
mocks.ReplayAll();
var context = new GrassCoverErosionOutwardsCalculationGroupContext(new CalculationGroup(),
null,
failureMechanism,
assessmentSection);
// Call
IFileImporter importer = importInfo.CreateFileImporter(context, "");
// Assert
Assert.IsInstanceOf <GrassCoverErosionOutwardsWaveConditionsCalculationConfigurationImporter>(importer);
mocks.VerifyAll();
}
private static string EnableValidateAndCalculateMenuItemForCalculationGroup(GrassCoverErosionOutwardsCalculationGroupContext context)
{
return(EnableValidateAndCalculateMenuItem(context.AssessmentSection));
}
private ContextMenuStrip CalculationGroupContextMenuStrip(GrassCoverErosionOutwardsCalculationGroupContext nodeData,
object parentData,
TreeViewControl treeViewControl)
{
CalculationGroup group = nodeData.WrappedData;
IInquiryHelper inquiryHelper = GetInquiryHelper();
var builder = new RiskeerContextMenuBuilder(Gui.Get(nodeData, treeViewControl));
bool isNestedGroup = parentData is GrassCoverErosionOutwardsCalculationGroupContext;
GrassCoverErosionOutwardsWaveConditionsCalculation[] calculations = group
.GetCalculations()
.OfType <GrassCoverErosionOutwardsWaveConditionsCalculation>()
.ToArray();
StrictContextMenuItem generateCalculationsItem = CreateGenerateWaveConditionsCalculationsItem(nodeData);
builder.AddImportItem()
.AddExportItem()
.AddSeparator();
if (isNestedGroup)
{
builder.AddDuplicateCalculationItem(group, nodeData)
.AddSeparator();
}
else
{
builder.AddCustomItem(generateCalculationsItem)
.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());
}
