private static IEnumerable <object> GetRegistrationStateFailureMechanismOutputs(ClosingStructuresFailureMechanism failureMechanism, IAssessmentSection assessmentSection)
{
return(new object[]
{
new ClosingStructuresScenariosContext(failureMechanism.CalculationsGroup, failureMechanism),
new ClosingStructuresFailureMechanismSectionResultContext(
failureMechanism.SectionResults, failureMechanism, assessmentSection),
failureMechanism.InAssemblyOutputComments
});
}
private bool VerifyStructuresShouldUpdate(ClosingStructuresFailureMechanism failureMechanism, string query)
{
var changeHandler = new FailureMechanismCalculationChangeHandler(failureMechanism, query, GetInquiryHelper());
return(!changeHandler.RequireConfirmation() || changeHandler.InquireConfirmation());
}
private static CalculationGroup ConfigureCalculationGroup(ClosingStructuresFailureMechanism failureMechanism, IAssessmentSection assessmentSection)
{
var random = new Random(12);
return(new CalculationGroup
{
Children =
{
new StructuresCalculationScenario <ClosingStructuresInput>
{
Name = "Calculation 1",
Comments =
{
Body = "Comment for Calculation 1"
},
InputParameters =
{
Structure = failureMechanism.ClosingStructures.FirstOrDefault(),
InsideWaterLevel =
{
Mean = (RoundedDouble)0.30
},
CriticalOvertoppingDischarge =
{
Mean = (RoundedDouble)0.01
},
AllowedLevelIncreaseStorage =
{
Mean = (RoundedDouble)100.0
},
InflowModelType = random.NextEnumValue <ClosingStructureInflowModelType>(),
ForeshoreProfile = failureMechanism.ForeshoreProfiles.FirstOrDefault(),
HydraulicBoundaryLocation = assessmentSection.HydraulicBoundaryDatabase.Locations.First(),
BreakWater =
{
Height = (RoundedDouble)3.3,
Type = BreakWaterType.Dam
},
UseBreakWater = false,
UseForeshore = false
},
Output = null
},
new StructuresCalculationScenario <ClosingStructuresInput>
{
Name = "Calculation 2",
Comments =
{
Body = "Comment for Calculation 2"
},
InputParameters =
{
Structure = failureMechanism.ClosingStructures.LastOrDefault(),
InsideWaterLevel =
{
Mean = (RoundedDouble)0.30
},
CriticalOvertoppingDischarge =
{
Mean = (RoundedDouble)0.01
},
AllowedLevelIncreaseStorage =
{
Mean = (RoundedDouble)100.0
},
InflowModelType = random.NextEnumValue <ClosingStructureInflowModelType>(),
ForeshoreProfile = failureMechanism.ForeshoreProfiles.LastOrDefault(),
HydraulicBoundaryLocation = assessmentSection.HydraulicBoundaryDatabase.Locations.Last(),
BreakWater =
{
Height = (RoundedDouble)3.3,
Type = BreakWaterType.Dam
},
UseBreakWater = false,
UseForeshore = false
},
Output = null
}
}
});
}
/// <summary>
/// Clears the <see cref="HydraulicBoundaryLocation"/> and output for all the calculations
/// in the <see cref="StructuresCalculation{T}"/>.
/// </summary>
/// <param name="failureMechanism">The <see cref="ClosingStructuresFailureMechanism"/>
/// which contains the calculations.</param>
/// <returns>An <see cref="IEnumerable{T}"/> of objects which are affected by removing data.</returns>
/// <exception cref="ArgumentNullException">Thrown when <paramref name="failureMechanism"/>
/// is <c>null</c>.</exception>
public static IEnumerable <IObservable> ClearAllCalculationOutputAndHydraulicBoundaryLocations(ClosingStructuresFailureMechanism failureMechanism)
{
if (failureMechanism == null)
{
throw new ArgumentNullException(nameof(failureMechanism));
}
var affectedItems = new List <IObservable>();
foreach (StructuresCalculation <ClosingStructuresInput> calculation in failureMechanism.Calculations.Cast <StructuresCalculation <ClosingStructuresInput> >())
{
affectedItems.AddRange(RiskeerCommonDataSynchronizationService.ClearCalculationOutput(calculation));
affectedItems.AddRange(RiskeerCommonDataSynchronizationService.ClearHydraulicBoundaryLocation(calculation.InputParameters));
}
return(affectedItems);
}
private ClosingStructuresFailureMechanism CreateFullyConfiguredFailureMechanism()
{
var section1 = new FailureMechanismSection("A", new[]
{
new Point2D(-1, 0),
new Point2D(2, 0)
});
var section2 = new FailureMechanismSection("B", new[]
{
new Point2D(2, 0),
new Point2D(4, 0)
});
var structure1 = new TestClosingStructure(new Point2D(1, 0), "structure1");
var structure2 = new TestClosingStructure(new Point2D(3, 0), "structure2");
var profile = new TestForeshoreProfile();
StructuresCalculation <ClosingStructuresInput> calculation1 = new TestClosingStructuresCalculationScenario
{
InputParameters =
{
ForeshoreProfile = profile,
Structure = structure1
},
Output = new TestStructuresOutput()
};
StructuresCalculation <ClosingStructuresInput> calculation2 = new TestClosingStructuresCalculationScenario
{
InputParameters =
{
ForeshoreProfile = profile,
Structure = structure2
}
};
StructuresCalculation <ClosingStructuresInput> calculation3 = new TestClosingStructuresCalculationScenario
{
InputParameters =
{
ForeshoreProfile = profile,
Structure = structure1
}
};
var failureMechanism = new ClosingStructuresFailureMechanism
{
CalculationsGroup =
{
Children =
{
calculation1,
new CalculationGroup
{
Children =
{
calculation2
}
},
calculation3
}
}
};
failureMechanism.ClosingStructures.AddRange(new[]
{
structure1,
structure2
}, "some path");
failureMechanism.ForeshoreProfiles.AddRange(new[]
{
profile
}, "path");
FailureMechanismTestHelper.SetSections(failureMechanism, new[]
{
section1,
section2
});
return(failureMechanism);
}
public void ScenariosView_GenerateCalculations_ChangesCorrectlyObservedAndSynced()
{
// Setup
var mocks = new MockRepository();
var messageProvider = mocks.Stub <IImporterMessageProvider>();
mocks.ReplayAll();
using (var form = new Form())
{
var assessmentSection = new AssessmentSection(AssessmentSectionComposition.Dike);
DataImportHelper.ImportReferenceLine(assessmentSection);
ClosingStructuresFailureMechanism failureMechanism = assessmentSection.ClosingStructures;
DataImportHelper.ImportFailureMechanismSections(assessmentSection, failureMechanism);
CalculationGroup calculationsGroup = assessmentSection.ClosingStructures.CalculationsGroup;
var view = new ClosingStructuresScenariosView(calculationsGroup, assessmentSection.ClosingStructures);
form.Controls.Add(view);
form.Show();
var structuresImporter = new ClosingStructuresImporter(assessmentSection.ClosingStructures.ClosingStructures,
assessmentSection.ReferenceLine, filePath, messageProvider,
new ClosingStructureReplaceDataStrategy(failureMechanism));
structuresImporter.Import();
var listBox = (ListBox) new ControlTester("listBox").TheObject;
var dataGridView = (DataGridView) new ControlTester("dataGridView").TheObject;
listBox.SelectedItem = failureMechanism.Sections.ElementAt(32);
// Precondition
DataGridViewRowCollection rows = dataGridView.Rows;
CollectionAssert.IsEmpty(rows);
// Call
foreach (ClosingStructure structure in assessmentSection.ClosingStructures.ClosingStructures)
{
calculationsGroup.Children.Add(new StructuresCalculationScenario <ClosingStructuresInput>
{
Name = NamingHelper.GetUniqueName(((CalculationGroup)view.Data).Children, structure.Name, c => c.Name),
InputParameters =
{
Structure = structure
}
});
}
calculationsGroup.NotifyObservers();
// Assert
Assert.AreEqual(1, rows.Count);
DataGridViewCellCollection cells = rows[0].Cells;
Assert.AreEqual(4, cells.Count);
Assert.IsTrue(Convert.ToBoolean(cells[isRelevantColumnIndex].FormattedValue));
Assert.AreEqual(new RoundedDouble(2, 100).ToString(), cells[contributionColumnIndex].FormattedValue);
Assert.AreEqual("Eerste kunstwerk sluiting 6-3", cells[nameColumnIndex].FormattedValue);
Assert.AreEqual("-", cells[failureProbabilityColumnIndex].FormattedValue);
}
mocks.VerifyAll();
}
/// <summary>
/// Creates a new instance of <see cref="ClosingStructuresFailureMechanismView"/>.
/// </summary>
/// <param name="failureMechanism">The failure mechanism to show the data for.</param>
/// <param name="assessmentSection">The assessment section to show the data for.</param>
/// <exception cref="ArgumentNullException">Thrown when any parameter is <c>null</c>.</exception>
public ClosingStructuresFailureMechanismView(ClosingStructuresFailureMechanism failureMechanism,
IAssessmentSection assessmentSection)
: base(failureMechanism, assessmentSection)
{
}
public void UpdateStructuresWithImportedData_SectionResultWithStructureImportedStructureWithSameId_UpdatesCalculationInput()
{
// Setup
const string sameId = "sameId";
var originalMatchingPoint = new Point2D(0, 0);
var updatedMatchingPoint = new Point2D(20, 20);
ClosingStructure readStructure = new TestClosingStructure(updatedMatchingPoint, sameId);
ClosingStructure structure = new TestClosingStructure(originalMatchingPoint, sameId);
var calculation = new TestClosingStructuresCalculationScenario
{
InputParameters =
{
Structure = structure
}
};
var failureMechanism = new ClosingStructuresFailureMechanism
{
CalculationsGroup =
{
Children =
{
calculation
}
}
};
failureMechanism.ClosingStructures.AddRange(new[]
{
structure
}, sourceFilePath);
var intersectionPoint = new Point2D(10, 10);
FailureMechanismTestHelper.SetSections(failureMechanism, new[]
{
new FailureMechanismSection("OldSection", new[]
{
originalMatchingPoint,
intersectionPoint
}),
new FailureMechanismSection("NewSection", new[]
{
intersectionPoint,
updatedMatchingPoint
})
});
var strategy = new ClosingStructureUpdateDataStrategy(failureMechanism);
// Call
IEnumerable <IObservable> affectedObjects = strategy.UpdateStructuresWithImportedData(new[]
{
readStructure
},
sourceFilePath);
// Assert
AssertClosingStructures(readStructure, structure);
CollectionAssert.AreEqual(new IObservable[]
{
failureMechanism.ClosingStructures,
structure,
calculation.InputParameters
}, affectedObjects);
}
/// <summary>
/// Creates a new instance of <see cref="ClosingStructuresCalculationsView"/>.
/// </summary>
/// <param name="data">The data.</param>
/// <param name="failureMechanism">The failure mechanism.</param>
/// <param name="assessmentSection">The assessment section.</param>
/// <exception cref="ArgumentNullException">Thrown when any parameter is <c>null</c>.</exception>
public ClosingStructuresCalculationsView(CalculationGroup data, ClosingStructuresFailureMechanism failureMechanism, IAssessmentSection assessmentSection)
: base(data, failureMechanism, assessmentSection)
{
}
public void Constructor_WithAllData_DataUpdatedToCollectionOfFilledMapData()
{
// Setup
var calculationA = new StructuresCalculationScenario <ClosingStructuresInput>
{
InputParameters =
{
HydraulicBoundaryLocation = new HydraulicBoundaryLocation(1, string.Empty, 1.3, 2.3),
Structure = new TestClosingStructure(new Point2D(1.2, 2.3))
}
};
var calculationB = new StructuresCalculationScenario <ClosingStructuresInput>
{
InputParameters =
{
HydraulicBoundaryLocation = new HydraulicBoundaryLocation(1, string.Empty, 7.7, 12.6),
Structure = new TestClosingStructure(new Point2D(2.7, 2.0))
}
};
var geometryPoints = new[]
{
new Point2D(0.0, 0.0),
new Point2D(2.0, 0.0),
new Point2D(4.0, 4.0),
new Point2D(6.0, 4.0)
};
var failureMechanism = new ClosingStructuresFailureMechanism();
FailureMechanismTestHelper.SetSections(failureMechanism, new[]
{
new FailureMechanismSection("A", geometryPoints.Take(2)),
new FailureMechanismSection("B", geometryPoints.Skip(1).Take(2)),
new FailureMechanismSection("C", geometryPoints.Skip(2).Take(2))
});
var profile1 = new TestForeshoreProfile("profile1 ID", new[]
{
new Point2D(0, 0),
new Point2D(1, 1)
});
var profile2 = new TestForeshoreProfile("profile2 ID", new[]
{
new Point2D(2, 2),
new Point2D(3, 3)
});
failureMechanism.ForeshoreProfiles.AddRange(new[]
{
profile1,
profile2
}, "path");
failureMechanism.CalculationsGroup.Children.Add(calculationA);
failureMechanism.CalculationsGroup.Children.Add(calculationB);
var referenceLine = new ReferenceLine();
referenceLine.SetGeometry(new[]
{
new Point2D(1.0, 2.0),
new Point2D(2.0, 1.0)
});
var assessmentSection = new AssessmentSectionStub
{
ReferenceLine = referenceLine
};
assessmentSection.SetHydraulicBoundaryLocationCalculations(new[]
{
new HydraulicBoundaryLocation(1, "test", 1.0, 2.0)
});
// Call
ClosingStructuresFailureMechanismView view = CreateView(failureMechanism, assessmentSection);
IMapControl map = ((RiskeerMapControl)view.Controls[0]).MapControl;
// Assert
MapDataCollection mapData = map.Data;
Assert.IsInstanceOf <MapDataCollection>(mapData);
List <MapData> mapDataList = mapData.Collection.ToList();
Assert.AreEqual(5, mapDataList.Count);
MapDataTestHelper.AssertReferenceLineMapData(assessmentSection.ReferenceLine, mapDataList[referenceLineIndex]);
MapDataTestHelper.AssertHydraulicBoundaryLocationsMapData(assessmentSection, mapDataList[hydraulicBoundaryLocationsIndex]);
MapDataTestHelper.AssertForeshoreProfilesMapData(failureMechanism.ForeshoreProfiles, mapDataList[foreshoreProfilesIndex]);
AssertCalculationsMapData(
failureMechanism.Calculations.Cast <StructuresCalculation <ClosingStructuresInput> >(),
mapDataList[calculationsIndex]);
}
public void GivenCalculationsWithIllustrationPoints_WhenClearIllustrationPointsClickedAndContinued_ThenInquiryAndIllustrationPointsCleared()
{
// Given
var calculationWithIllustrationPoints = new TestClosingStructuresCalculationScenario
{
Output = new TestStructuresOutput(new TestGeneralResultFaultTreeIllustrationPoint())
};
var calculationWithOutput = new TestClosingStructuresCalculationScenario
{
Output = new TestStructuresOutput()
};
var failureMechanism = new ClosingStructuresFailureMechanism
{
CalculationsGroup =
{
Children =
{
calculationWithIllustrationPoints,
calculationWithOutput,
new TestClosingStructuresCalculationScenario()
}
}
};
var affectedCalculationObserver = mocksRepository.StrictMock <IObserver>();
affectedCalculationObserver.Expect(o => o.UpdateObserver());
calculationWithIllustrationPoints.Attach(affectedCalculationObserver);
var unaffectedCalculationObserver = mocksRepository.StrictMock <IObserver>();
calculationWithOutput.Attach(unaffectedCalculationObserver);
IAssessmentSection assessmentSection = AssessmentSectionTestHelper.CreateAssessmentSectionStub(null, mocksRepository, "invalidFilePath");
var nodeData = new ClosingStructuresFailureMechanismContext(failureMechanism, assessmentSection);
var menuBuilder = new CustomItemsOnlyContextMenuBuilder();
var messageBoxText = "";
DialogBoxHandler = (name, wnd) =>
{
var helper = new MessageBoxTester(wnd);
messageBoxText = helper.Text;
helper.ClickOk();
};
using (var treeViewControl = new TreeViewControl())
{
var gui = mocksRepository.Stub <IGui>();
gui.Stub(g => g.Get(nodeData, treeViewControl)).Return(menuBuilder);
gui.Stub(g => g.MainWindow).Return(mocksRepository.Stub <IMainWindow>());
mocksRepository.ReplayAll();
plugin.Gui = gui;
using (ContextMenuStrip contextMenu = info.ContextMenuStrip(nodeData, null, treeViewControl))
{
// When
contextMenu.Items[contextMenuClearIllustrationPointsIndex].PerformClick();
// Then
Assert.AreEqual("Weet u zeker dat u alle illustratiepunten wilt wissen?", messageBoxText);
Assert.IsTrue(calculationWithOutput.HasOutput);
Assert.IsFalse(calculationWithIllustrationPoints.Output.HasGeneralResult);
}
}
}
public void ContextMenuStrip_ClickOnValidateAllItem_ValidateAllChildCalculations()
{
// Setup
var failureMechanism = new ClosingStructuresFailureMechanism();
failureMechanism.CalculationsGroup.Children.Add(new TestClosingStructuresCalculationScenario
{
Name = "A",
InputParameters =
{
HydraulicBoundaryLocation = new TestHydraulicBoundaryLocation()
}
});
failureMechanism.CalculationsGroup.Children.Add(new TestClosingStructuresCalculationScenario
{
Name = "B",
InputParameters =
{
HydraulicBoundaryLocation = new TestHydraulicBoundaryLocation()
}
});
string validFilePath = Path.Combine(testDataPath, "complete.sqlite");
var hydraulicBoundaryDatabase = new HydraulicBoundaryDatabase
{
FilePath = validFilePath
};
HydraulicBoundaryDatabaseTestHelper.SetHydraulicBoundaryLocationConfigurationSettings(hydraulicBoundaryDatabase);
var assessmentSection = mocksRepository.Stub <IAssessmentSection>();
assessmentSection.Stub(a => a.HydraulicBoundaryDatabase).Return(hydraulicBoundaryDatabase);
var context = new ClosingStructuresFailureMechanismContext(failureMechanism, assessmentSection);
using (var treeViewControl = new TreeViewControl())
{
var menuBuilder = new CustomItemsOnlyContextMenuBuilder();
var gui = mocksRepository.Stub <IGui>();
gui.Stub(g => g.Get(context, treeViewControl)).Return(menuBuilder);
gui.Stub(g => g.MainWindow).Return(mocksRepository.Stub <IMainWindow>());
mocksRepository.ReplayAll();
plugin.Gui = gui;
using (ContextMenuStrip contextMenu = info.ContextMenuStrip(context, null, treeViewControl))
{
// Call
void Call() => contextMenu.Items[contextMenuValidateAllIndex].PerformClick();
// Assert
TestHelper.AssertLogMessages(Call, messages =>
{
string[] messageList = messages.ToArray();
Assert.AreEqual(4, messageList.Length);
CalculationServiceTestHelper.AssertValidationStartMessage(messageList[0]);
CalculationServiceTestHelper.AssertValidationEndMessage(messageList[1]);
CalculationServiceTestHelper.AssertValidationStartMessage(messageList[2]);
CalculationServiceTestHelper.AssertValidationEndMessage(messageList[3]);
});
}
}
}
public void ContextMenuStrip_ClickOnCalculateAllItem_ScheduleAllChildCalculations()
{
// Setup
IMainWindow mainWindow = MainWindowTestHelper.CreateMainWindowStub(mocksRepository);
var menuBuilder = new CustomItemsOnlyContextMenuBuilder();
var failureMechanism = new ClosingStructuresFailureMechanism();
failureMechanism.CalculationsGroup.Children.Add(new TestClosingStructuresCalculationScenario
{
Name = "A",
InputParameters =
{
HydraulicBoundaryLocation = new TestHydraulicBoundaryLocation()
}
});
failureMechanism.CalculationsGroup.Children.Add(new TestClosingStructuresCalculationScenario
{
Name = "B",
InputParameters =
{
HydraulicBoundaryLocation = new TestHydraulicBoundaryLocation()
}
});
var hydraulicBoundaryDatabase = new HydraulicBoundaryDatabase
{
FilePath = Path.Combine(testDataPath, "complete.sqlite")
};
HydraulicBoundaryDatabaseTestHelper.SetHydraulicBoundaryLocationConfigurationSettings(hydraulicBoundaryDatabase);
var assessmentSection = mocksRepository.Stub <IAssessmentSection>();
assessmentSection.Stub(a => a.Id).Return(string.Empty);
assessmentSection.Stub(a => a.FailureMechanismContribution).Return(FailureMechanismContributionTestFactory.CreateFailureMechanismContribution());
assessmentSection.Stub(a => a.HydraulicBoundaryDatabase).Return(hydraulicBoundaryDatabase);
var context = new ClosingStructuresFailureMechanismContext(failureMechanism, assessmentSection);
using (var treeViewControl = new TreeViewControl())
{
var gui = mocksRepository.Stub <IGui>();
gui.Stub(g => g.Get(context, treeViewControl)).Return(menuBuilder);
gui.Stub(g => g.MainWindow).Return(mainWindow);
int nrOfCalculators = failureMechanism.Calculations.Count();
var calculatorFactory = mocksRepository.Stub <IHydraRingCalculatorFactory>();
calculatorFactory.Expect(cf => cf.CreateStructuresCalculator <StructuresClosureCalculationInput>(
Arg <HydraRingCalculationSettings> .Is.NotNull))
.WhenCalled(invocation =>
{
HydraRingCalculationSettingsTestHelper.AssertHydraRingCalculationSettings(
HydraulicBoundaryCalculationSettingsFactory.CreateSettings(hydraulicBoundaryDatabase),
(HydraRingCalculationSettings)invocation.Arguments[0]);
})
.Return(new TestStructuresCalculator <StructuresClosureCalculationInput>())
.Repeat
.Times(nrOfCalculators);
mocksRepository.ReplayAll();
plugin.Gui = gui;
DialogBoxHandler = (name, wnd) =>
{
// Expect an activity dialog which is automatically closed
};
using (ContextMenuStrip contextMenu = info.ContextMenuStrip(context, null, treeViewControl))
using (new HydraRingCalculatorFactoryConfig(calculatorFactory))
{
// Call
TestHelper.AssertLogMessages(() => contextMenu.Items[contextMenuCalculateAllIndex].PerformClick(), messages =>
{
List <string> messageList = messages.ToList();
// Assert
Assert.AreEqual(14, messageList.Count);
Assert.AreEqual("Uitvoeren van berekening 'A' is gestart.", messageList[0]);
CalculationServiceTestHelper.AssertValidationStartMessage(messageList[1]);
CalculationServiceTestHelper.AssertValidationEndMessage(messageList[2]);
CalculationServiceTestHelper.AssertCalculationStartMessage(messageList[3]);
StringAssert.StartsWith("Betrouwbaarheid sluiting kunstwerk berekening is uitgevoerd op de tijdelijke locatie", messageList[4]);
CalculationServiceTestHelper.AssertCalculationEndMessage(messageList[5]);
Assert.AreEqual("Uitvoeren van berekening 'A' is gelukt.", messageList[6]);
Assert.AreEqual("Uitvoeren van berekening 'B' is gestart.", messageList[7]);
CalculationServiceTestHelper.AssertValidationStartMessage(messageList[8]);
CalculationServiceTestHelper.AssertValidationEndMessage(messageList[9]);
CalculationServiceTestHelper.AssertCalculationStartMessage(messageList[10]);
StringAssert.StartsWith("Betrouwbaarheid sluiting kunstwerk berekening is uitgevoerd op de tijdelijke locatie", messageList[11]);
CalculationServiceTestHelper.AssertCalculationEndMessage(messageList[12]);
Assert.AreEqual("Uitvoeren van berekening 'B' is gelukt.", messageList[13]);
});
}
}
}
private static IEnumerable <TestCaseData> GetSupportedFailureMechanisms()
{
const string unaffectedProfileName = "Custom Profile";
const string unaffectedProfileId = "Custom ID";
var unaffectedForeshoreProfile = new TestForeshoreProfile(unaffectedProfileName, unaffectedProfileId);
WaveImpactAsphaltCoverFailureMechanism waveImpactAsphaltCoverFailureMechanism =
CreateWaveImpactAsphaltCoverFailureMechanismWithAllUpdateForeshoreProfileScenarios(unaffectedForeshoreProfile);
yield return(new TestCaseData(
waveImpactAsphaltCoverFailureMechanism,
waveImpactAsphaltCoverFailureMechanism.ForeshoreProfiles,
unaffectedForeshoreProfile)
.SetName("WaveImpactAsphaltCoverFailureMechanism"));
GrassCoverErosionOutwardsFailureMechanism grassCoverErosionOutwardsFailureMechanism =
CreateGrassCoverErosionOutwardsFailureMechanismWithAllUpdateForeshoreProfileScenarios(unaffectedForeshoreProfile);
yield return(new TestCaseData(
grassCoverErosionOutwardsFailureMechanism,
grassCoverErosionOutwardsFailureMechanism.ForeshoreProfiles,
unaffectedForeshoreProfile)
.SetName("GrassCoverErosionOutwardsFailureMechanism"));
StabilityStoneCoverFailureMechanism stabilityStoneCoverFailureMechanism =
CreateStabilityStoneCoverFailureMechanismWithAllUpdateForeshoreProfileScenarios(unaffectedForeshoreProfile);
yield return(new TestCaseData(
stabilityStoneCoverFailureMechanism,
stabilityStoneCoverFailureMechanism.ForeshoreProfiles,
unaffectedForeshoreProfile)
.SetName("StabilityStoneCoverFailureMechanism"));
StabilityPointStructuresFailureMechanism stabilityPointStructuresFailureMechanism =
CreateStabilityPointStructuresFailureMechanismWithAllUpdateForeshoreProfileScenarios(unaffectedForeshoreProfile);
yield return(new TestCaseData(
stabilityPointStructuresFailureMechanism,
stabilityPointStructuresFailureMechanism.ForeshoreProfiles,
unaffectedForeshoreProfile)
.SetName("StabilityPointStructuresFailureMechanism"));
ClosingStructuresFailureMechanism closingStructuresFailureMechanism =
CreateClosingStructuresFailureMechanismWithAllUpdateForeshoreProfileScenarios(unaffectedForeshoreProfile);
yield return(new TestCaseData(
closingStructuresFailureMechanism,
closingStructuresFailureMechanism.ForeshoreProfiles,
unaffectedForeshoreProfile)
.SetName("ClosingStructuresFailureMechanism"));
HeightStructuresFailureMechanism heightStructuresFailureMechanism =
CreateHeightStructuresFailureMechanismWithAllUpdateForeshoreProfileScenarios(unaffectedForeshoreProfile);
yield return(new TestCaseData(
heightStructuresFailureMechanism,
heightStructuresFailureMechanism.ForeshoreProfiles,
unaffectedForeshoreProfile)
.SetName("HeightStructuresFailureMechanism"));
}
public TestClosingStructuresFailureMechanismProperties(ClosingStructuresFailureMechanism data,
ConstructionProperties constructionProperties)
: base(data, constructionProperties)
{
}
public void UpdateStructuresWithImportedData_MultipleCalculationWithStructureOneWithRemovedStructure_OnlyUpdatesCalculationWithRemovedStructure()
{
// Setup
const string removedId = "affectedId";
const string unaffectedId = "unaffectedId";
const string unaffectedStructureName = "unaffectedStructure";
var removedStructure = new TestClosingStructure(removedId, "Old name");
var unaffectedStructure = new TestClosingStructure(unaffectedId, unaffectedStructureName);
var affectedCalculation = new TestClosingStructuresCalculationScenario
{
InputParameters =
{
Structure = removedStructure
},
Output = new TestStructuresOutput()
};
var unaffectedCalculation = new TestClosingStructuresCalculationScenario
{
InputParameters =
{
Structure = unaffectedStructure
},
Output = new TestStructuresOutput()
};
var failureMechanism = new ClosingStructuresFailureMechanism
{
CalculationsGroup =
{
Children =
{
affectedCalculation,
unaffectedCalculation
}
}
};
StructureCollection <ClosingStructure> targetDataCollection = failureMechanism.ClosingStructures;
targetDataCollection.AddRange(new[]
{
removedStructure,
unaffectedStructure
}, sourceFilePath);
var strategy = new ClosingStructureUpdateDataStrategy(failureMechanism);
ClosingStructure readUnaffectedStructure = new TestClosingStructure(unaffectedId, unaffectedStructureName);
// Call
IEnumerable <IObservable> affectedObjects = strategy.UpdateStructuresWithImportedData(new[]
{
readUnaffectedStructure
}, sourceFilePath);
// Assert
Assert.IsFalse(affectedCalculation.HasOutput);
Assert.IsNull(affectedCalculation.InputParameters.Structure);
Assert.IsTrue(unaffectedCalculation.HasOutput);
ClosingStructure inputParametersUnaffectedStructure = unaffectedCalculation.InputParameters.Structure;
Assert.AreSame(unaffectedStructure, inputParametersUnaffectedStructure);
AssertClosingStructures(readUnaffectedStructure, inputParametersUnaffectedStructure);
CollectionAssert.AreEquivalent(new IObservable[]
{
affectedCalculation,
affectedCalculation.InputParameters,
targetDataCollection
}, affectedObjects);
}
/// <summary>
/// Creates a new instance of <see cref="ClosingStructuresScenariosView"/>.
/// </summary>
/// <param name="calculationGroup">The data to show in this view.</param>
/// <param name="failureMechanism">The <see cref="ClosingStructuresFailureMechanism"/>
/// the <paramref name="calculationGroup"/> belongs to.</param>
/// <exception cref="ArgumentNullException">Thrown when any parameter is <c>null</c>.</exception>
public ClosingStructuresScenariosView(CalculationGroup calculationGroup, ClosingStructuresFailureMechanism failureMechanism)
: base(calculationGroup, failureMechanism)
{
}
public void Update_FullyConfiguredAssessmentSection_AllReferenceLineDependentDataCleared()
{
// Setup
var mocks = new MockRepository();
var viewCommands = mocks.Stub <IViewCommands>();
mocks.ReplayAll();
AssessmentSection assessmentSection = TestDataGenerator.GetAssessmentSectionWithAllCalculationConfigurations();
var handler = new ReferenceLineUpdateHandler(assessmentSection, viewCommands);
ReferenceLine referenceLine = ReferenceLineTestFactory.CreateReferenceLineWithGeometry();
// Call
IObservable[] observables = handler.Update(assessmentSection.ReferenceLine, referenceLine).ToArray();
// Assert
Assert.AreEqual(56, observables.Length);
PipingFailureMechanism pipingFailureMechanism = assessmentSection.Piping;
CollectionAssert.IsEmpty(pipingFailureMechanism.Sections);
CollectionAssert.IsEmpty(pipingFailureMechanism.SectionResults);
CollectionAssert.IsEmpty(pipingFailureMechanism.ScenarioConfigurationsPerFailureMechanismSection);
CollectionAssert.Contains(observables, pipingFailureMechanism);
CollectionAssert.Contains(observables, pipingFailureMechanism.SectionResults);
CollectionAssert.Contains(observables, pipingFailureMechanism.ScenarioConfigurationsPerFailureMechanismSection);
CollectionAssert.IsEmpty(pipingFailureMechanism.CalculationsGroup.Children);
CollectionAssert.Contains(observables, pipingFailureMechanism.CalculationsGroup);
CollectionAssert.IsEmpty(pipingFailureMechanism.StochasticSoilModels);
CollectionAssert.Contains(observables, pipingFailureMechanism.StochasticSoilModels);
CollectionAssert.IsEmpty(pipingFailureMechanism.SurfaceLines);
CollectionAssert.Contains(observables, pipingFailureMechanism.SurfaceLines);
GrassCoverErosionInwardsFailureMechanism grassCoverErosionInwardsFailureMechanism = assessmentSection.GrassCoverErosionInwards;
CollectionAssert.IsEmpty(grassCoverErosionInwardsFailureMechanism.Sections);
CollectionAssert.IsEmpty(grassCoverErosionInwardsFailureMechanism.SectionResults);
CollectionAssert.Contains(observables, grassCoverErosionInwardsFailureMechanism);
CollectionAssert.Contains(observables, grassCoverErosionInwardsFailureMechanism.SectionResults);
CollectionAssert.IsEmpty(grassCoverErosionInwardsFailureMechanism.CalculationsGroup.Children);
CollectionAssert.Contains(observables, grassCoverErosionInwardsFailureMechanism.CalculationsGroup);
CollectionAssert.IsEmpty(grassCoverErosionInwardsFailureMechanism.DikeProfiles);
CollectionAssert.Contains(observables, grassCoverErosionInwardsFailureMechanism.DikeProfiles);
GrassCoverErosionOutwardsFailureMechanism grassCoverErosionOutwardsFailureMechanism = assessmentSection.GrassCoverErosionOutwards;
CollectionAssert.IsEmpty(grassCoverErosionOutwardsFailureMechanism.Sections);
CollectionAssert.IsEmpty(grassCoverErosionOutwardsFailureMechanism.SectionResults);
CollectionAssert.Contains(observables, grassCoverErosionOutwardsFailureMechanism);
CollectionAssert.Contains(observables, grassCoverErosionOutwardsFailureMechanism.SectionResults);
CollectionAssert.IsEmpty(grassCoverErosionOutwardsFailureMechanism.CalculationsGroup.Children);
CollectionAssert.Contains(observables, grassCoverErosionOutwardsFailureMechanism.CalculationsGroup);
CollectionAssert.IsEmpty(grassCoverErosionOutwardsFailureMechanism.ForeshoreProfiles);
CollectionAssert.Contains(observables, grassCoverErosionOutwardsFailureMechanism.ForeshoreProfiles);
WaveImpactAsphaltCoverFailureMechanism waveImpactAsphaltCoverFailureMechanism = assessmentSection.WaveImpactAsphaltCover;
CollectionAssert.IsEmpty(waveImpactAsphaltCoverFailureMechanism.Sections);
CollectionAssert.IsEmpty(waveImpactAsphaltCoverFailureMechanism.SectionResults);
CollectionAssert.Contains(observables, waveImpactAsphaltCoverFailureMechanism);
CollectionAssert.Contains(observables, waveImpactAsphaltCoverFailureMechanism.SectionResults);
CollectionAssert.IsEmpty(waveImpactAsphaltCoverFailureMechanism.CalculationsGroup.Children);
CollectionAssert.Contains(observables, waveImpactAsphaltCoverFailureMechanism.CalculationsGroup);
CollectionAssert.IsEmpty(waveImpactAsphaltCoverFailureMechanism.ForeshoreProfiles);
CollectionAssert.Contains(observables, waveImpactAsphaltCoverFailureMechanism.ForeshoreProfiles);
StabilityStoneCoverFailureMechanism stabilityStoneCoverFailureMechanism = assessmentSection.StabilityStoneCover;
CollectionAssert.IsEmpty(stabilityStoneCoverFailureMechanism.Sections);
CollectionAssert.IsEmpty(stabilityStoneCoverFailureMechanism.SectionResults);
CollectionAssert.Contains(observables, stabilityStoneCoverFailureMechanism);
CollectionAssert.Contains(observables, stabilityStoneCoverFailureMechanism.SectionResults);
CollectionAssert.IsEmpty(stabilityStoneCoverFailureMechanism.CalculationsGroup.Children);
CollectionAssert.Contains(observables, stabilityStoneCoverFailureMechanism.CalculationsGroup);
CollectionAssert.IsEmpty(stabilityStoneCoverFailureMechanism.ForeshoreProfiles);
CollectionAssert.Contains(observables, stabilityStoneCoverFailureMechanism.ForeshoreProfiles);
ClosingStructuresFailureMechanism closingStructuresFailureMechanism = assessmentSection.ClosingStructures;
CollectionAssert.IsEmpty(closingStructuresFailureMechanism.Sections);
CollectionAssert.IsEmpty(closingStructuresFailureMechanism.SectionResults);
CollectionAssert.Contains(observables, closingStructuresFailureMechanism);
CollectionAssert.Contains(observables, closingStructuresFailureMechanism.SectionResults);
CollectionAssert.IsEmpty(closingStructuresFailureMechanism.CalculationsGroup.Children);
CollectionAssert.Contains(observables, closingStructuresFailureMechanism.CalculationsGroup);
CollectionAssert.IsEmpty(closingStructuresFailureMechanism.ForeshoreProfiles);
CollectionAssert.Contains(observables, closingStructuresFailureMechanism.ForeshoreProfiles);
CollectionAssert.IsEmpty(closingStructuresFailureMechanism.ClosingStructures);
CollectionAssert.Contains(observables, closingStructuresFailureMechanism.ClosingStructures);
HeightStructuresFailureMechanism heightStructuresFailureMechanism = assessmentSection.HeightStructures;
CollectionAssert.IsEmpty(heightStructuresFailureMechanism.Sections);
CollectionAssert.IsEmpty(heightStructuresFailureMechanism.SectionResults);
CollectionAssert.Contains(observables, heightStructuresFailureMechanism);
CollectionAssert.Contains(observables, heightStructuresFailureMechanism.SectionResults);
CollectionAssert.IsEmpty(heightStructuresFailureMechanism.CalculationsGroup.Children);
CollectionAssert.Contains(observables, heightStructuresFailureMechanism.CalculationsGroup);
CollectionAssert.IsEmpty(heightStructuresFailureMechanism.ForeshoreProfiles);
CollectionAssert.Contains(observables, heightStructuresFailureMechanism.ForeshoreProfiles);
CollectionAssert.IsEmpty(heightStructuresFailureMechanism.HeightStructures);
CollectionAssert.Contains(observables, heightStructuresFailureMechanism.HeightStructures);
StabilityPointStructuresFailureMechanism stabilityPointStructuresFailureMechanism = assessmentSection.StabilityPointStructures;
CollectionAssert.IsEmpty(stabilityPointStructuresFailureMechanism.Sections);
CollectionAssert.IsEmpty(stabilityPointStructuresFailureMechanism.SectionResults);
CollectionAssert.Contains(observables, stabilityPointStructuresFailureMechanism);
CollectionAssert.Contains(observables, stabilityPointStructuresFailureMechanism.SectionResults);
CollectionAssert.IsEmpty(stabilityPointStructuresFailureMechanism.CalculationsGroup.Children);
CollectionAssert.Contains(observables, stabilityPointStructuresFailureMechanism.CalculationsGroup);
CollectionAssert.IsEmpty(stabilityPointStructuresFailureMechanism.ForeshoreProfiles);
CollectionAssert.Contains(observables, stabilityPointStructuresFailureMechanism.ForeshoreProfiles);
CollectionAssert.IsEmpty(stabilityPointStructuresFailureMechanism.StabilityPointStructures);
CollectionAssert.Contains(observables, stabilityPointStructuresFailureMechanism.StabilityPointStructures);
DuneErosionFailureMechanism duneErosionFailureMechanism = assessmentSection.DuneErosion;
CollectionAssert.IsEmpty(duneErosionFailureMechanism.Sections);
CollectionAssert.IsEmpty(duneErosionFailureMechanism.SectionResults);
CollectionAssert.Contains(observables, duneErosionFailureMechanism);
CollectionAssert.Contains(observables, duneErosionFailureMechanism.SectionResults);
MacroStabilityInwardsFailureMechanism macroStabilityInwardsFailureMechanism = assessmentSection.MacroStabilityInwards;
CollectionAssert.IsEmpty(macroStabilityInwardsFailureMechanism.Sections);
CollectionAssert.IsEmpty(macroStabilityInwardsFailureMechanism.SectionResults);
CollectionAssert.Contains(observables, macroStabilityInwardsFailureMechanism);
CollectionAssert.Contains(observables, macroStabilityInwardsFailureMechanism.SectionResults);
CollectionAssert.IsEmpty(macroStabilityInwardsFailureMechanism.CalculationsGroup.Children);
CollectionAssert.Contains(observables, macroStabilityInwardsFailureMechanism.CalculationsGroup);
CollectionAssert.IsEmpty(macroStabilityInwardsFailureMechanism.StochasticSoilModels);
CollectionAssert.Contains(observables, macroStabilityInwardsFailureMechanism.StochasticSoilModels);
CollectionAssert.IsEmpty(macroStabilityInwardsFailureMechanism.SurfaceLines);
CollectionAssert.Contains(observables, macroStabilityInwardsFailureMechanism.SurfaceLines);
MicrostabilityFailureMechanism microstabilityFailureMechanism = assessmentSection.Microstability;
CollectionAssert.IsEmpty(microstabilityFailureMechanism.Sections);
CollectionAssert.IsEmpty(microstabilityFailureMechanism.SectionResults);
CollectionAssert.Contains(observables, microstabilityFailureMechanism);
CollectionAssert.Contains(observables, microstabilityFailureMechanism.SectionResults);
WaterPressureAsphaltCoverFailureMechanism waterPressureAsphaltCoverFailureMechanism = assessmentSection.WaterPressureAsphaltCover;
CollectionAssert.IsEmpty(waterPressureAsphaltCoverFailureMechanism.Sections);
CollectionAssert.IsEmpty(waterPressureAsphaltCoverFailureMechanism.SectionResults);
CollectionAssert.Contains(observables, waterPressureAsphaltCoverFailureMechanism);
CollectionAssert.Contains(observables, waterPressureAsphaltCoverFailureMechanism.SectionResults);
GrassCoverSlipOffOutwardsFailureMechanism grassCoverSlipOffOutwardsFailureMechanism = assessmentSection.GrassCoverSlipOffOutwards;
CollectionAssert.IsEmpty(grassCoverSlipOffOutwardsFailureMechanism.Sections);
CollectionAssert.IsEmpty(grassCoverSlipOffOutwardsFailureMechanism.SectionResults);
CollectionAssert.Contains(observables, grassCoverSlipOffOutwardsFailureMechanism);
CollectionAssert.Contains(observables, grassCoverSlipOffOutwardsFailureMechanism.SectionResults);
GrassCoverSlipOffInwardsFailureMechanism grassCoverSlipOffInwardsFailureMechanism = assessmentSection.GrassCoverSlipOffInwards;
CollectionAssert.IsEmpty(grassCoverSlipOffInwardsFailureMechanism.Sections);
CollectionAssert.IsEmpty(grassCoverSlipOffInwardsFailureMechanism.SectionResults);
CollectionAssert.Contains(observables, grassCoverSlipOffInwardsFailureMechanism);
CollectionAssert.Contains(observables, grassCoverSlipOffInwardsFailureMechanism.SectionResults);
PipingStructureFailureMechanism pipingStructureFailureMechanism = assessmentSection.PipingStructure;
CollectionAssert.IsEmpty(pipingStructureFailureMechanism.Sections);
CollectionAssert.IsEmpty(pipingStructureFailureMechanism.SectionResults);
CollectionAssert.Contains(observables, pipingStructureFailureMechanism);
CollectionAssert.Contains(observables, pipingStructureFailureMechanism.SectionResults);
CollectionAssert.AreEqual(referenceLine.Points, assessmentSection.ReferenceLine.Points);
SpecificFailureMechanism failureMechanism = assessmentSection.SpecificFailureMechanisms.First();
CollectionAssert.IsEmpty(failureMechanism.Sections);
CollectionAssert.IsEmpty(failureMechanism.SectionResults);
CollectionAssert.Contains(observables, failureMechanism);
CollectionAssert.Contains(observables, failureMechanism.SectionResults);
mocks.VerifyAll();
}
private static void AssertFailureMechanismRows(AssessmentSection assessmentSection,
double assemblyOutput,
DataGridViewRowCollection rows)
{
int nrOfExpectedRows = assessmentSection.GetFailureMechanisms().Count() +
assessmentSection.SpecificFailureMechanisms.Count;
Assert.AreEqual(nrOfExpectedRows, rows.Count);
PipingFailureMechanism piping = assessmentSection.Piping;
AssertAssemblyCells(piping, assemblyOutput, rows[0].Cells);
GrassCoverErosionInwardsFailureMechanism grassCoverErosionInwards = assessmentSection.GrassCoverErosionInwards;
AssertAssemblyCells(grassCoverErosionInwards, assemblyOutput, rows[1].Cells);
MacroStabilityInwardsFailureMechanism macroStabilityInwards = assessmentSection.MacroStabilityInwards;
AssertAssemblyCells(macroStabilityInwards, assemblyOutput, rows[2].Cells);
MicrostabilityFailureMechanism microStability = assessmentSection.Microstability;
AssertAssemblyCells(microStability, assemblyOutput, rows[3].Cells);
StabilityStoneCoverFailureMechanism stabilityStoneCover = assessmentSection.StabilityStoneCover;
AssertAssemblyCells(stabilityStoneCover, assemblyOutput, rows[4].Cells);
WaveImpactAsphaltCoverFailureMechanism waveImpactAsphaltCover = assessmentSection.WaveImpactAsphaltCover;
AssertAssemblyCells(waveImpactAsphaltCover, assemblyOutput, rows[5].Cells);
WaterPressureAsphaltCoverFailureMechanism waterPressureAsphaltCover = assessmentSection.WaterPressureAsphaltCover;
AssertAssemblyCells(waterPressureAsphaltCover, assemblyOutput, rows[6].Cells);
GrassCoverErosionOutwardsFailureMechanism grassCoverErosionOutwards = assessmentSection.GrassCoverErosionOutwards;
AssertAssemblyCells(grassCoverErosionOutwards, assemblyOutput, rows[7].Cells);
GrassCoverSlipOffOutwardsFailureMechanism grassCoverSlipOffOutwards = assessmentSection.GrassCoverSlipOffOutwards;
AssertAssemblyCells(grassCoverSlipOffOutwards, assemblyOutput, rows[8].Cells);
GrassCoverSlipOffInwardsFailureMechanism grassCoverSlipOffInwards = assessmentSection.GrassCoverSlipOffInwards;
AssertAssemblyCells(grassCoverSlipOffInwards, assemblyOutput, rows[9].Cells);
HeightStructuresFailureMechanism heightStructures = assessmentSection.HeightStructures;
AssertAssemblyCells(heightStructures, assemblyOutput, rows[10].Cells);
ClosingStructuresFailureMechanism closingStructures = assessmentSection.ClosingStructures;
AssertAssemblyCells(closingStructures, assemblyOutput, rows[11].Cells);
PipingStructureFailureMechanism pipingStructure = assessmentSection.PipingStructure;
AssertAssemblyCells(pipingStructure, assemblyOutput, rows[12].Cells);
StabilityPointStructuresFailureMechanism stabilityPointStructures = assessmentSection.StabilityPointStructures;
AssertAssemblyCells(stabilityPointStructures, assemblyOutput, rows[13].Cells);
DuneErosionFailureMechanism duneErosion = assessmentSection.DuneErosion;
AssertAssemblyCells(duneErosion, assemblyOutput, rows[14].Cells);
int startIndexFailureMechanismRow = 15;
for (int i = startIndexFailureMechanismRow; i < nrOfExpectedRows; i++)
{
SpecificFailureMechanism specificFailureMechanism = assessmentSection.SpecificFailureMechanisms[i - startIndexFailureMechanismRow];
AssertAssemblyCells(specificFailureMechanism, assemblyOutput, rows[i].Cells);
}
}
public void RemoveStructure_FullyConfiguredFailureMechanism_RemovesStructureAndClearsDependentData()
{
// Setup
var failureMechanism = new ClosingStructuresFailureMechanism();
var structureToRemove = new TestClosingStructure(new Point2D(0, 0), "id1");
var structureToKeep = new TestClosingStructure(new Point2D(2, 2), "id2");
failureMechanism.ClosingStructures.AddRange(new[]
{
structureToRemove,
structureToKeep
}, "path/to/structures");
var calculationWithOutput = new TestClosingStructuresCalculationScenario
{
Output = new TestStructuresOutput()
};
var calculationWithStructureToRemove = new TestClosingStructuresCalculationScenario
{
InputParameters =
{
Structure = structureToRemove
}
};
var calculationWithStructureToKeepAndOutput = new TestClosingStructuresCalculationScenario
{
InputParameters =
{
Structure = structureToKeep
},
Output = new TestStructuresOutput()
};
var calculationWithStructureToRemoveAndOutput = new TestClosingStructuresCalculationScenario
{
InputParameters =
{
Structure = structureToRemove
},
Output = new TestStructuresOutput()
};
failureMechanism.CalculationsGroup.Children.AddRange(new[]
{
calculationWithOutput,
calculationWithStructureToRemove,
calculationWithStructureToKeepAndOutput,
calculationWithStructureToRemoveAndOutput
});
// Call
IEnumerable <IObservable> affectedObjects = ClosingStructuresDataSynchronizationService.RemoveStructure(
structureToRemove, failureMechanism);
// Assert
// Note: To make sure the clear is performed regardless of what is done with
// the return result, no ToArray() should be called before these assertions:
CollectionAssert.DoesNotContain(failureMechanism.ClosingStructures, structureToRemove);
Assert.IsNull(calculationWithStructureToRemove.InputParameters.Structure);
Assert.IsNull(calculationWithStructureToRemoveAndOutput.InputParameters.Structure);
Assert.IsNull(calculationWithStructureToRemoveAndOutput.Output);
Assert.IsNotNull(calculationWithOutput.Output);
Assert.IsNotNull(calculationWithStructureToKeepAndOutput.Output);
Assert.IsNotNull(calculationWithStructureToKeepAndOutput.InputParameters.Structure);
IObservable[] expectedAffectedObjects =
{
calculationWithStructureToRemove.InputParameters,
calculationWithStructureToRemoveAndOutput,
calculationWithStructureToRemoveAndOutput.InputParameters,
failureMechanism.ClosingStructures
};
CollectionAssert.AreEquivalent(expectedAffectedObjects, affectedObjects);
}
private static IEnumerable <object> GetCalculationsStateFailureMechanismInputs(ClosingStructuresFailureMechanism failureMechanism, IAssessmentSection assessmentSection)
{
return(new object[]
{
new ForeshoreProfilesContext(failureMechanism.ForeshoreProfiles, failureMechanism, assessmentSection),
new ClosingStructuresContext(failureMechanism.ClosingStructures, failureMechanism, assessmentSection),
failureMechanism.CalculationsInputComments
});
}
private ClosingStructuresCalculationsView ShowCalculationsView(CalculationGroup calculationGroup, ClosingStructuresFailureMechanism failureMechanism, IAssessmentSection assessmentSection)
{
var calculationsView = new ClosingStructuresCalculationsView(calculationGroup, failureMechanism, assessmentSection);
testForm.Controls.Add(calculationsView);
testForm.Show();
return(calculationsView);
}
private static IEnumerable <object> GetRegistrationStateFailureMechanismInputs(ClosingStructuresFailureMechanism failureMechanism, IAssessmentSection assessmentSection)
{
return(new object[]
{
new ClosingStructuresFailureMechanismSectionsContext(failureMechanism, assessmentSection),
failureMechanism.InAssemblyInputComments
});
}
/// <summary>
/// Creates a collection of <see cref="CombinedAssemblyFailureMechanismSection"/> collections.
/// </summary>
/// <param name="assessmentSection">The assessment section to use.</param>
/// <param name="failureMechanisms">The failure mechanisms to build input for.</param>
/// <returns>A collection of <see cref="CombinedAssemblyFailureMechanismSection"/> collections.</returns>
/// <exception cref="ArgumentNullException">Thrown when any parameter is <c>null</c>.</exception>
public static IEnumerable <IEnumerable <CombinedAssemblyFailureMechanismSection> > CreateInput(
AssessmentSection assessmentSection, IEnumerable <IFailureMechanism> failureMechanisms)
{
if (assessmentSection == null)
{
throw new ArgumentNullException(nameof(assessmentSection));
}
if (failureMechanisms == null)
{
throw new ArgumentNullException(nameof(failureMechanisms));
}
var inputs = new List <IEnumerable <CombinedAssemblyFailureMechanismSection> >();
PipingFailureMechanism pipingFailureMechanism = assessmentSection.Piping;
if (failureMechanisms.Contains(pipingFailureMechanism))
{
inputs.Add(CreateCombinedSections(pipingFailureMechanism.SectionResults, assessmentSection, PipingAssemblyFunc));
}
GrassCoverErosionInwardsFailureMechanism grassCoverErosionInwardsFailureMechanism = assessmentSection.GrassCoverErosionInwards;
if (failureMechanisms.Contains(grassCoverErosionInwardsFailureMechanism))
{
inputs.Add(CreateCombinedSections(grassCoverErosionInwardsFailureMechanism.SectionResults, assessmentSection, GrassCoverErosionInwardsAssemblyFunc));
}
MacroStabilityInwardsFailureMechanism macroStabilityInwardsFailureMechanism = assessmentSection.MacroStabilityInwards;
if (failureMechanisms.Contains(macroStabilityInwardsFailureMechanism))
{
inputs.Add(CreateCombinedSections(macroStabilityInwardsFailureMechanism.SectionResults, assessmentSection, MacroStabilityInwardsAssemblyFunc));
}
MicrostabilityFailureMechanism microstabilityFailureMechanism = assessmentSection.Microstability;
if (failureMechanisms.Contains(microstabilityFailureMechanism))
{
inputs.Add(CreateCombinedSections(microstabilityFailureMechanism.SectionResults, assessmentSection, MicrostabilityAssemblyFunc));
}
StabilityStoneCoverFailureMechanism stabilityStoneCoverFailureMechanism = assessmentSection.StabilityStoneCover;
if (failureMechanisms.Contains(stabilityStoneCoverFailureMechanism))
{
inputs.Add(CreateCombinedSections(stabilityStoneCoverFailureMechanism.SectionResults, assessmentSection, StabilityStoneCoverAssemblyFunc));
}
WaveImpactAsphaltCoverFailureMechanism waveImpactAsphaltCoverFailureMechanism = assessmentSection.WaveImpactAsphaltCover;
if (failureMechanisms.Contains(waveImpactAsphaltCoverFailureMechanism))
{
inputs.Add(CreateCombinedSections(waveImpactAsphaltCoverFailureMechanism.SectionResults, assessmentSection, WaveImpactAsphaltCoverAssemblyFunc));
}
WaterPressureAsphaltCoverFailureMechanism waterPressureAsphaltCoverFailureMechanism = assessmentSection.WaterPressureAsphaltCover;
if (failureMechanisms.Contains(waterPressureAsphaltCoverFailureMechanism))
{
inputs.Add(CreateCombinedSections(waterPressureAsphaltCoverFailureMechanism.SectionResults, assessmentSection, WaterPressureAsphaltCoverAssemblyFunc));
}
GrassCoverErosionOutwardsFailureMechanism grassCoverErosionOutwardsFailureMechanism = assessmentSection.GrassCoverErosionOutwards;
if (failureMechanisms.Contains(grassCoverErosionOutwardsFailureMechanism))
{
inputs.Add(CreateCombinedSections(grassCoverErosionOutwardsFailureMechanism.SectionResults, assessmentSection, GrassCoverErosionOutwardsAssemblyFunc));
}
GrassCoverSlipOffOutwardsFailureMechanism grassCoverSlipOffOutwardsFailureMechanism = assessmentSection.GrassCoverSlipOffOutwards;
if (failureMechanisms.Contains(grassCoverSlipOffOutwardsFailureMechanism))
{
inputs.Add(CreateCombinedSections(grassCoverSlipOffOutwardsFailureMechanism.SectionResults, assessmentSection, GrassCoverSlipOffOutwardsAssemblyFunc));
}
GrassCoverSlipOffInwardsFailureMechanism grassCoverSlipOffInwardsFailureMechanism = assessmentSection.GrassCoverSlipOffInwards;
if (failureMechanisms.Contains(grassCoverSlipOffInwardsFailureMechanism))
{
inputs.Add(CreateCombinedSections(grassCoverSlipOffInwardsFailureMechanism.SectionResults, assessmentSection, GrassCoverSlipOffInwardsAssemblyFunc));
}
HeightStructuresFailureMechanism heightStructuresFailureMechanism = assessmentSection.HeightStructures;
if (failureMechanisms.Contains(heightStructuresFailureMechanism))
{
inputs.Add(CreateCombinedSections(heightStructuresFailureMechanism.SectionResults, assessmentSection, HeightStructuresAssemblyFunc));
}
ClosingStructuresFailureMechanism closingStructuresFailureMechanism = assessmentSection.ClosingStructures;
if (failureMechanisms.Contains(closingStructuresFailureMechanism))
{
inputs.Add(CreateCombinedSections(closingStructuresFailureMechanism.SectionResults, assessmentSection, ClosingStructuresAssemblyFunc));
}
PipingStructureFailureMechanism pipingStructureFailureMechanism = assessmentSection.PipingStructure;
if (failureMechanisms.Contains(pipingStructureFailureMechanism))
{
inputs.Add(CreateCombinedSections(pipingStructureFailureMechanism.SectionResults, assessmentSection, PipingStructureAssemblyFunc));
}
StabilityPointStructuresFailureMechanism stabilityPointStructuresFailureMechanism = assessmentSection.StabilityPointStructures;
if (failureMechanisms.Contains(stabilityPointStructuresFailureMechanism))
{
inputs.Add(CreateCombinedSections(stabilityPointStructuresFailureMechanism.SectionResults, assessmentSection, StabilityPointStructuresAssemblyFunc));
}
DuneErosionFailureMechanism duneErosionFailureMechanism = assessmentSection.DuneErosion;
if (failureMechanisms.Contains(duneErosionFailureMechanism))
{
inputs.Add(CreateCombinedSections(duneErosionFailureMechanism.SectionResults, assessmentSection, DuneErosionAssemblyFunc));
}
foreach (SpecificFailureMechanism specificFailureMechanism in assessmentSection.SpecificFailureMechanisms)
{
if (failureMechanisms.Contains(specificFailureMechanism))
{
inputs.Add(CreateCombinedSections(specificFailureMechanism.SectionResults, assessmentSection,
(sectionResult, section) => FailureMechanismAssemblyFactory.AssembleSection(sectionResult, specificFailureMechanism, section)));
}
}
return(inputs);
}
/// <summary>
/// Initializes a new instance of the <see cref="ClosingStructuresFailureMechanismSectionsContext"/> class.
/// </summary>
/// <param name="wrappedData">The <see cref="ClosingStructuresFailureMechanism"/> to wrap.</param>
/// <param name="assessmentSection">The owning assessment section of <paramref name="wrappedData"/>.</param>
/// <exception cref="ArgumentNullException">Thrown when any input argument is <c>null</c>.</exception>
public ClosingStructuresFailureMechanismSectionsContext(ClosingStructuresFailureMechanism wrappedData, IAssessmentSection assessmentSection)
: base(wrappedData, assessmentSection)
{
}
