public void ParameteredConstructor_ExpectedValues(bool hasParent)
{
// Setup
var mockRepository = new MockRepository();
var assessmentSection = mockRepository.Stub <IAssessmentSection>();
mockRepository.ReplayAll();
var calculationGroup = new CalculationGroup();
var failureMechanism = new WaveImpactAsphaltCoverFailureMechanism();
CalculationGroup parent = hasParent ? new CalculationGroup() : null;
// Call
var groupContext = new WaveImpactAsphaltCoverCalculationGroupContext(calculationGroup, parent, failureMechanism, assessmentSection);
// Assert
Assert.IsInstanceOf <WaveImpactAsphaltCoverContext <CalculationGroup> >(groupContext);
Assert.IsInstanceOf <ICalculationContext <CalculationGroup, WaveImpactAsphaltCoverFailureMechanism> >(groupContext);
Assert.AreSame(calculationGroup, groupContext.WrappedData);
Assert.AreSame(parent, groupContext.Parent);
Assert.AreSame(failureMechanism, groupContext.FailureMechanism);
Assert.AreSame(assessmentSection, groupContext.AssessmentSection);
Assert.AreSame(failureMechanism.ForeshoreProfiles, groupContext.ForeshoreProfiles);
mockRepository.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 WaveImpactAsphaltCoverWaveConditionsCalculation());
}
var context = new WaveImpactAsphaltCoverCalculationGroupContext(calculationGroup,
null,
new WaveImpactAsphaltCoverFailureMechanism(),
assessmentSection);
// Call
bool isEnabled = info.IsEnabled(context);
// Assert
Assert.IsTrue(isEnabled);
}
private static object[] CalculationGroupContextChildNodeObjects(WaveImpactAsphaltCoverCalculationGroupContext nodeData)
{
var childNodeObjects = new List <object>();
foreach (ICalculationBase item in nodeData.WrappedData.Children)
{
if (item is WaveImpactAsphaltCoverWaveConditionsCalculation calculation)
{
childNodeObjects.Add(new WaveImpactAsphaltCoverWaveConditionsCalculationContext(calculation,
nodeData.WrappedData,
nodeData.FailureMechanism,
nodeData.AssessmentSection));
}
else if (item is CalculationGroup group)
{
childNodeObjects.Add(new WaveImpactAsphaltCoverCalculationGroupContext(group,
nodeData.WrappedData,
nodeData.FailureMechanism,
nodeData.AssessmentSection));
}
else
{
childNodeObjects.Add(item);
}
}
return(childNodeObjects.ToArray());
}
public void IsEnabled_CalculationWithOrWithoutOutput_ReturnExpectedEnabledState(bool hasOutput)
{
// Setup
var assessmentSection = mocks.Stub <IAssessmentSection>();
mocks.ReplayAll();
var failureMechanism = new WaveImpactAsphaltCoverFailureMechanism();
var calculationGroup = new CalculationGroup();
var calculation = new WaveImpactAsphaltCoverWaveConditionsCalculation();
if (hasOutput)
{
var output = new[]
{
new TestWaveConditionsOutput()
};
calculation.Output = new WaveImpactAsphaltCoverWaveConditionsOutput(output);
}
calculationGroup.Children.Add(calculation);
var context = new WaveImpactAsphaltCoverCalculationGroupContext(calculationGroup, null, failureMechanism, assessmentSection);
// Call
bool isEnabled = info.IsEnabled(context);
// Assert
Assert.AreEqual(hasOutput, isEnabled);
}
private void CalculateAllInCalculationGroup(WaveImpactAsphaltCoverCalculationGroupContext context)
{
ActivityProgressDialogRunner.Run(
Gui.MainWindow,
WaveImpactAsphaltCoverWaveConditionsCalculationActivityFactory.CreateCalculationActivities(context.WrappedData,
context.FailureMechanism,
context.AssessmentSection));
}
private static void CalculationGroupContextOnNodeRemoved(WaveImpactAsphaltCoverCalculationGroupContext nodeData, object parentNodeData)
{
var parentGroupContext = (WaveImpactAsphaltCoverCalculationGroupContext)parentNodeData;
parentGroupContext.WrappedData.Children.Remove(nodeData.WrappedData);
parentGroupContext.NotifyObservers();
}
private static void ValidateAllInCalculationGroup(WaveImpactAsphaltCoverCalculationGroupContext context)
{
foreach (WaveImpactAsphaltCoverWaveConditionsCalculation calculation in context.WrappedData.GetCalculations().OfType <WaveImpactAsphaltCoverWaveConditionsCalculation>())
{
WaveConditionsCalculationServiceBase.Validate(calculation.InputParameters,
WaveConditionsInputHelper.GetAssessmentLevel(calculation.InputParameters, context.AssessmentSection),
context.AssessmentSection.HydraulicBoundaryDatabase);
}
}
private static void AddWaveConditionsCalculation(WaveImpactAsphaltCoverCalculationGroupContext nodeData)
{
var calculation = new WaveImpactAsphaltCoverWaveConditionsCalculation
{
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(WaveImpactAsphaltCoverCalculationGroupContext nodeData)
{
using (var dialog = new HydraulicBoundaryLocationSelectionDialog(Gui.MainWindow, nodeData.AssessmentSection.HydraulicBoundaryDatabase.Locations))
{
dialog.ShowDialog();
if (dialog.SelectedItems.Any())
{
GenerateWaveImpactAsphaltCoverWaveConditionsCalculations(dialog.SelectedItems,
nodeData.WrappedData.Children,
nodeData.AssessmentSection.FailureMechanismContribution.NormativeProbabilityType);
nodeData.NotifyObservers();
}
}
}
private StrictContextMenuItem CreateGenerateWaveConditionsCalculationsItem(WaveImpactAsphaltCoverCalculationGroupContext 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 WaveImpactAsphaltCoverCalculationGroupContext(new CalculationGroup(),
null,
new WaveImpactAsphaltCoverFailureMechanism(),
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 WaveImpactAsphaltCoverFailureMechanism();
var calculationGroup = new CalculationGroup();
var context = new WaveImpactAsphaltCoverCalculationGroupContext(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 WaveImpactAsphaltCoverCalculationGroupContext(new CalculationGroup(),
null,
new WaveImpactAsphaltCoverFailureMechanism(),
assessmentSection);
// Call
IFileExporter fileExporter = info.CreateFileExporter(context, "test");
// Assert
Assert.IsInstanceOf <WaveImpactAsphaltCoverWaveConditionsCalculationConfigurationExporter>(fileExporter);
}
public void CreateFileImporter_Always_ReturnFileImporter()
{
// Setup
var failureMechanism = new WaveImpactAsphaltCoverFailureMechanism();
var mocks = new MockRepository();
IAssessmentSection assessmentSection = AssessmentSectionTestHelper.CreateAssessmentSectionStub(failureMechanism, mocks);
assessmentSection.Stub(section => section.WaterLevelCalculationsForUserDefinedTargetProbabilities)
.Return(new ObservableList <HydraulicBoundaryLocationCalculationsForTargetProbability>());
mocks.ReplayAll();
var context = new WaveImpactAsphaltCoverCalculationGroupContext(new CalculationGroup(),
null,
failureMechanism,
assessmentSection);
// Call
IFileImporter importer = importInfo.CreateFileImporter(context, "");
// Assert
Assert.IsInstanceOf <WaveImpactAsphaltCoverWaveConditionsCalculationConfigurationImporter>(importer);
mocks.VerifyAll();
}
private static string EnableValidateAndCalculateMenuItemForCalculationGroup(WaveImpactAsphaltCoverCalculationGroupContext context)
{
return(EnableValidateAndCalculateMenuItem(context.AssessmentSection));
}
private ContextMenuStrip CalculationGroupContextContextMenuStrip(WaveImpactAsphaltCoverCalculationGroupContext nodeData,
object parentData, TreeViewControl treeViewControl)
{
CalculationGroup group = nodeData.WrappedData;
IInquiryHelper inquiryHelper = GetInquiryHelper();
var builder = new RiskeerContextMenuBuilder(Gui.Get(nodeData, treeViewControl));
bool isNestedGroup = parentData is WaveImpactAsphaltCoverCalculationGroupContext;
WaveImpactAsphaltCoverWaveConditionsCalculation[] calculations = group
.GetCalculations()
.OfType <WaveImpactAsphaltCoverWaveConditionsCalculation>().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());
}
