public void AssembleFailureMechanism_WithInput_SetsInputOnCalculator()
{
// Setup
var failureMechanism = new StabilityPointStructuresFailureMechanism
{
AssemblyResult =
{
ProbabilityResultType = FailureMechanismAssemblyProbabilityResultType.Automatic
}
};
failureMechanism.SetSections(new[]
{
FailureMechanismSectionTestFactory.CreateFailureMechanismSection()
}, "APath");
var assessmentSection = new AssessmentSectionStub();
using (new AssemblyToolCalculatorFactoryConfig())
{
var calculatorFactory = (TestAssemblyToolCalculatorFactory)AssemblyToolCalculatorFactory.Instance;
FailureMechanismSectionAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator;
FailureMechanismAssemblyCalculatorStub failureMechanismAssemblyCalculator = calculatorFactory.LastCreatedFailureMechanismAssemblyCalculator;
// Call
StabilityPointStructuresFailureMechanismAssemblyFactory.AssembleFailureMechanism(failureMechanism, assessmentSection);
// Assert
Assert.AreEqual(failureMechanism.GeneralInput.N, failureMechanismAssemblyCalculator.FailureMechanismN);
Assert.AreSame(calculator.FailureMechanismSectionAssemblyResultOutput.AssemblyResult, failureMechanismAssemblyCalculator.SectionAssemblyResultsInput.Single());
Assert.AreEqual(failureMechanism.GeneralInput.ApplyLengthEffectInSection, failureMechanismAssemblyCalculator.ApplyLengthEffect);
}
}
public void Calculations_MultipleChildrenAdded_ReturnStabilityPointStructuresCalculations()
{
// Setup
var mocks = new MockRepository();
var failureMechanism = new StabilityPointStructuresFailureMechanism
{
CalculationsGroup =
{
Children =
{
new CalculationGroup(),
new StructuresCalculation <StabilityPointStructuresInput>(),
new StructuresCalculation <StabilityPointStructuresInput>()
}
}
};
mocks.ReplayAll();
// Call
List <ICalculation> calculations = failureMechanism.Calculations.ToList();
// Assert
Assert.AreEqual(2, calculations.Count);
CollectionAssert.AllItemsAreInstancesOfType(calculations, typeof(StructuresCalculation <StabilityPointStructuresInput>));
mocks.VerifyAll();
}
public void CurrentPath_FailureMechanismSectionsSourcePathSet_ReturnsExpectedPath()
{
// Setup
var mocks = new MockRepository();
var assessmentSection = mocks.Stub <IAssessmentSection>();
mocks.ReplayAll();
var failureMechanism = new StabilityPointStructuresFailureMechanism();
string sourcePath = TestHelper.GetScratchPadPath();
failureMechanism.SetSections(Enumerable.Empty <FailureMechanismSection>(), sourcePath);
var context = new StabilityPointStructuresFailureMechanismSectionsContext(failureMechanism, assessmentSection);
using (var plugin = new StabilityPointStructuresPlugin())
{
UpdateInfo updateInfo = GetUpdateInfo(plugin);
// Call
string currentFilePath = updateInfo.CurrentPath(context);
// Assert
Assert.AreEqual(sourcePath, currentFilePath);
mocks.VerifyAll();
}
}
public void CreateFileImporter_Always_ReturnFileImporter()
{
// Setup
var mocks = new MockRepository();
var assessmentSection = mocks.Stub <IAssessmentSection>();
assessmentSection.Stub(a => a.ReferenceLine).Return(new ReferenceLine());
mocks.ReplayAll();
var failureMechanism = new StabilityPointStructuresFailureMechanism();
var importTarget = new StabilityPointStructuresContext(failureMechanism.StabilityPointStructures,
failureMechanism,
assessmentSection);
using (var plugin = new StabilityPointStructuresPlugin())
{
ImportInfo importInfo = GetImportInfo(plugin);
// Call
IFileImporter importer = importInfo.CreateFileImporter(importTarget, "test");
// Assert
Assert.IsInstanceOf <StabilityPointStructuresImporter>(importer);
}
mocks.VerifyAll();
}
public void ClearReferenceLineDependentData_FullyConfiguredFailureMechanism_RemoveFailureMechanismDependentData()
{
// Setup
StabilityPointStructuresFailureMechanism failureMechanism = CreateFullyConfiguredFailureMechanism();
object[] expectedRemovedObjects = failureMechanism.Sections.OfType <object>()
.Concat(failureMechanism.SectionResults)
.Concat(failureMechanism.CalculationsGroup.GetAllChildrenRecursive())
.Concat(failureMechanism.ForeshoreProfiles)
.Concat(failureMechanism.StabilityPointStructures)
.ToArray();
// Call
ClearResults results = StabilityPointStructuresDataSynchronizationService.ClearReferenceLineDependentData(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.IsEmpty(failureMechanism.Sections);
CollectionAssert.IsEmpty(failureMechanism.SectionResults);
CollectionAssert.IsEmpty(failureMechanism.CalculationsGroup.Children);
CollectionAssert.IsEmpty(failureMechanism.ForeshoreProfiles);
CollectionAssert.IsEmpty(failureMechanism.StabilityPointStructures);
IObservable[] array = results.ChangedObjects.ToArray();
Assert.AreEqual(5, array.Length);
CollectionAssert.Contains(array, failureMechanism);
CollectionAssert.Contains(array, failureMechanism.SectionResults);
CollectionAssert.Contains(array, failureMechanism.CalculationsGroup);
CollectionAssert.Contains(array, failureMechanism.ForeshoreProfiles);
CollectionAssert.Contains(array, failureMechanism.StabilityPointStructures);
CollectionAssert.AreEquivalent(expectedRemovedObjects, results.RemovedObjects);
}
public void CloseForData_ViewCorrespondingToRemovedAssessmentSection_ReturnsTrue()
{
// Setup
var failureMechanism = new StabilityPointStructuresFailureMechanism();
var mocks = new MockRepository();
var assessmentSection = mocks.Stub <IAssessmentSection>();
assessmentSection.Stub(asm => asm.GetFailureMechanisms()).Return(new IFailureMechanism[]
{
failureMechanism
});
mocks.ReplayAll();
using (var view = new StructuresFailureMechanismResultView <StabilityPointStructuresFailureMechanism, StabilityPointStructuresInput>(
failureMechanism.SectionResults, failureMechanism, assessmentSection,
(fm, ass) => new FailureMechanismAssemblyResultWrapper(double.NaN, AssemblyMethod.Manual)))
{
// Call
bool closeForData = info.CloseForData(view, assessmentSection);
// Assert
Assert.IsTrue(closeForData);
}
mocks.VerifyAll();
}
public void IsEnabled_ReferenceLineWithoutGeometry_ReturnFalse()
{
// Setup
var mocks = new MockRepository();
var assessmentSection = mocks.Stub <IAssessmentSection>();
assessmentSection.Stub(a => a.ReferenceLine).Return(new ReferenceLine());
mocks.ReplayAll();
var failureMechanism = new StabilityPointStructuresFailureMechanism();
var context = new StabilityPointStructuresContext(failureMechanism.StabilityPointStructures,
failureMechanism,
assessmentSection);
using (var plugin = new StabilityPointStructuresPlugin())
{
ImportInfo importInfo = GetImportInfo(plugin);
// Call
bool isEnabled = importInfo.IsEnabled(context);
// Assert
Assert.IsFalse(isEnabled);
}
mocks.VerifyAll();
}
public void ScenariosView_ChangeStructureOfCalculation_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);
StabilityPointStructuresFailureMechanism failureMechanism = assessmentSection.StabilityPointStructures;
DataImportHelper.ImportFailureMechanismSections(assessmentSection, failureMechanism);
var view = new StabilityPointStructuresScenariosView(assessmentSection.StabilityPointStructures.CalculationsGroup, assessmentSection.StabilityPointStructures);
form.Controls.Add(view);
form.Show();
var structuresImporter = new StabilityPointStructuresImporter(assessmentSection.StabilityPointStructures.StabilityPointStructures,
assessmentSection.ReferenceLine, filePath, messageProvider,
new StabilityPointStructureReplaceDataStrategy(failureMechanism));
structuresImporter.Import();
foreach (StabilityPointStructure structure in assessmentSection.StabilityPointStructures.StabilityPointStructures)
{
assessmentSection.StabilityPointStructures.CalculationsGroup.Children.Add(new StructuresCalculationScenario <StabilityPointStructuresInput>
{
Name = NamingHelper.GetUniqueName(assessmentSection.StabilityPointStructures.CalculationsGroup.Children, structure.Name + " Calculation", c => c.Name),
InputParameters =
{
Structure = structure
}
});
}
var listBox = (ListBox) new ControlTester("listBox").TheObject;
var dataGridView = (DataGridView) new ControlTester("dataGridView").TheObject;
listBox.SelectedItem = failureMechanism.Sections.ElementAt(50);
// Precondition
DataGridViewRowCollection rows = dataGridView.Rows;
Assert.AreEqual(1, rows.Count);
Assert.AreEqual("Eerste kunstwerk punt 6-3 Calculation", rows[0].Cells[nameColumnIndex].FormattedValue);
// Call
CalculationGroup calculationsGroup = assessmentSection.StabilityPointStructures.CalculationsGroup;
((StructuresCalculation <StabilityPointStructuresInput>)calculationsGroup.Children[1]).InputParameters.Structure =
((StructuresCalculation <StabilityPointStructuresInput>)calculationsGroup.Children[0]).InputParameters.Structure;
calculationsGroup.NotifyObservers();
// Assert
Assert.AreEqual(2, rows.Count);
Assert.AreEqual("Eerste kunstwerk punt 6-3 Calculation", rows[0].Cells[nameColumnIndex].FormattedValue);
Assert.AreEqual("Tweede kunstwerk punt 6-3 Calculation", rows[1].Cells[nameColumnIndex].FormattedValue);
}
mocks.VerifyAll();
}
public void ScenariosView_ImportFailureMechanismSections_ChangesCorrectlyObservedAndSynced()
{
// Setup
using (var form = new Form())
{
var assessmentSection = new AssessmentSection(AssessmentSectionComposition.Dike);
DataImportHelper.ImportReferenceLine(assessmentSection);
var view = new StabilityPointStructuresScenariosView(assessmentSection.StabilityPointStructures.CalculationsGroup, assessmentSection.StabilityPointStructures);
form.Controls.Add(view);
form.Show();
var listBox = (ListBox) new ControlTester("listBox").TheObject;
// Precondition
CollectionAssert.IsEmpty(listBox.Items);
// Call
StabilityPointStructuresFailureMechanism failureMechanism = assessmentSection.StabilityPointStructures;
DataImportHelper.ImportFailureMechanismSections(assessmentSection, failureMechanism);
assessmentSection.StabilityPointStructures.NotifyObservers();
// Assert
CollectionAssert.AreEqual(assessmentSection.StabilityPointStructures.Sections, listBox.Items);
}
}
private FailureMechanismAssemblyResultRow CreateStabilityPointsStructuresFailureMechanismAssemblyResultRow()
{
StabilityPointStructuresFailureMechanism stabilityPointStructures = AssessmentSection.StabilityPointStructures;
return(FailureMechanismAssemblyResultRowFactory.CreateRow(
stabilityPointStructures, () => StabilityPointStructuresFailureMechanismAssemblyFactory.AssembleFailureMechanism(stabilityPointStructures, AssessmentSection)));
}
public void CreateCalculationActivitiesForFailureMechanism_WithValidCalculations_ReturnsStabilityPointStructuresCalculationActivitiesWithParametersSet()
{
// Setup
var failureMechanism = new StabilityPointStructuresFailureMechanism();
var mocks = new MockRepository();
IAssessmentSection assessmentSection = AssessmentSectionTestHelper.CreateAssessmentSectionStub(failureMechanism,
mocks,
validFilePath);
mocks.ReplayAll();
StructuresCalculation <StabilityPointStructuresInput> calculation1 = CreateValidCalculation();
StructuresCalculation <StabilityPointStructuresInput> calculation2 = CreateValidCalculation();
failureMechanism.CalculationsGroup.Children.AddRange(new[]
{
calculation1,
calculation2
});
// Call
IEnumerable <CalculatableActivity> activities = StabilityPointStructuresCalculationActivityFactory.CreateCalculationActivities(
failureMechanism, assessmentSection);
// Assert
CollectionAssert.AllItemsAreInstancesOfType(activities, typeof(StabilityPointStructuresCalculationActivity));
Assert.AreEqual(2, activities.Count());
HydraulicBoundaryDatabase hydraulicBoundaryDatabase = assessmentSection.HydraulicBoundaryDatabase;
AssertStabilityPointStructuresCalculationActivity(activities.First(), calculation1, hydraulicBoundaryDatabase);
AssertStabilityPointStructuresCalculationActivity(activities.ElementAt(1), calculation2, hydraulicBoundaryDatabase);
mocks.VerifyAll();
}
public void Text_Always_ReturnExpectedText()
{
// Setup
var mocks = new MockRepository();
var assessmentSection = mocks.Stub <IAssessmentSection>();
mocks.ReplayAll();
var failureMechanism = new StabilityPointStructuresFailureMechanism();
var context = new StabilityPointStructuresContext(failureMechanism.StabilityPointStructures,
failureMechanism,
assessmentSection);
using (var plugin = new StabilityPointStructuresPlugin())
{
TreeNodeInfo info = GetInfo(plugin);
// Call
string text = info.Text(context);
// Assert
const string expectedText = "Kunstwerken";
Assert.AreEqual(expectedText, text);
}
mocks.VerifyAll();
}
public void ForeColor_CollectionIsEmpty_ReturnGrayText()
{
// Setup
var mocks = new MockRepository();
var assessmentSection = mocks.Stub <IAssessmentSection>();
mocks.ReplayAll();
var failureMechanism = new StabilityPointStructuresFailureMechanism();
// Precondition
CollectionAssert.IsEmpty(failureMechanism.StabilityPointStructures);
var context = new StabilityPointStructuresContext(failureMechanism.StabilityPointStructures,
failureMechanism,
assessmentSection);
using (var plugin = new StabilityPointStructuresPlugin())
{
TreeNodeInfo info = GetInfo(plugin);
// Call
Color color = info.ForeColor(context);
// Assert
Assert.AreEqual(Color.FromKnownColor(KnownColor.GrayText), color);
}
mocks.VerifyAll();
}
public void Image_Always_ReturnExpectedImage()
{
// Setup
var mocks = new MockRepository();
var assessmentSection = mocks.Stub <IAssessmentSection>();
mocks.ReplayAll();
var failureMechanism = new StabilityPointStructuresFailureMechanism();
var context = new StabilityPointStructuresContext(failureMechanism.StabilityPointStructures,
failureMechanism,
assessmentSection);
using (var plugin = new StabilityPointStructuresPlugin())
{
TreeNodeInfo info = GetInfo(plugin);
// Call
Image image = info.Image(context);
// Assert
TestHelper.AssertImagesAreEqual(RiskeerCommonFormsProperties.GeneralFolderIcon, image);
}
mocks.VerifyAll();
}
public DerivedStabilityPointStructuresCalculationScenarioContext(StructuresCalculationScenario <StabilityPointStructuresInput> calculation,
CalculationGroup parent,
StabilityPointStructuresFailureMechanism failureMechanism,
IAssessmentSection assessmentSection)
: base(calculation, parent, failureMechanism, assessmentSection)
{
}
public DerivedStabilityPointStructuresCalculationGroupContext(CalculationGroup calculationsGroup,
CalculationGroup parent,
StabilityPointStructuresFailureMechanism failureMechanism,
IAssessmentSection assessmentSection)
: base(calculationsGroup, parent, failureMechanism, assessmentSection)
{
}
public void CloseForData_ViewNotCorrespondingToRemovedAssessmentSection_ReturnFalse()
{
// Setup
var unrelatedFailureMechanism = new StabilityPointStructuresFailureMechanism();
var mocks = new MockRepository();
var assessmentSection = mocks.Stub <IAssessmentSection>();
assessmentSection.Stub(asm => asm.GetFailureMechanisms()).Return(new[]
{
unrelatedFailureMechanism
});
mocks.ReplayAll();
using (var view = new StabilityPointStructuresScenariosView(new CalculationGroup(), new StabilityPointStructuresFailureMechanism()))
{
// Precondition
Assert.AreNotSame(view.Data, unrelatedFailureMechanism.CalculationsGroup);
// Call
bool closeForData = info.CloseForData(view, assessmentSection);
// Assert
Assert.IsFalse(closeForData);
}
mocks.VerifyAll();
}
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 StabilityPointStructuresFailureMechanism();
CalculationGroup parent = hasParent ? new CalculationGroup() : null;
// Call
var groupContext = new StabilityPointStructuresCalculationGroupContext(calculationGroup, parent, failureMechanism, assessmentSection);
// Assert
Assert.IsInstanceOf <FailureMechanismItemContextBase <CalculationGroup, StabilityPointStructuresFailureMechanism> >(groupContext);
Assert.IsInstanceOf <ICalculationContext <CalculationGroup, StabilityPointStructuresFailureMechanism> >(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.AvailableForeshoreProfiles);
Assert.AreSame(failureMechanism.StabilityPointStructures, groupContext.AvailableStructures);
mockRepository.VerifyAll();
}
public void Constructor_ExpectedValues()
{
// Setup
var failureMechanism = new StabilityPointStructuresFailureMechanism();
// Call
var properties = new StabilityPointStructuresFailureMechanismProperties(failureMechanism);
// Assert
Assert.IsInstanceOf <StabilityPointStructuresFailureMechanismPropertiesBase>(properties);
Assert.AreSame(failureMechanism, properties.Data);
Assert.AreEqual(failureMechanism.Name, properties.Name);
Assert.AreEqual(failureMechanism.Code, properties.Code);
GeneralStabilityPointStructuresInput generalInput = failureMechanism.GeneralInput;
Assert.AreEqual(generalInput.GravitationalAcceleration, properties.GravitationalAcceleration);
Assert.AreEqual(generalInput.ModelFactorStorageVolume.Mean, properties.ModelFactorStorageVolume.Mean);
Assert.AreEqual(generalInput.ModelFactorStorageVolume.StandardDeviation, properties.ModelFactorStorageVolume.StandardDeviation);
Assert.AreEqual(generalInput.ModelFactorCollisionLoad.Mean, properties.ModelFactorCollisionLoad.Mean);
Assert.AreEqual(generalInput.ModelFactorCollisionLoad.CoefficientOfVariation, properties.ModelFactorCollisionLoad.CoefficientOfVariation);
Assert.AreEqual(generalInput.ModelFactorLoadEffect.Mean, properties.ModelFactorLoadEffect.Mean);
Assert.AreEqual(generalInput.ModelFactorLoadEffect.StandardDeviation, properties.ModelFactorLoadEffect.StandardDeviation);
Assert.AreEqual(generalInput.ModelFactorLongThreshold.Mean, properties.ModelFactorLongThreshold.Mean);
Assert.AreEqual(generalInput.ModelFactorLongThreshold.StandardDeviation, properties.ModelFactorLongThreshold.StandardDeviation);
}
public void UpdateStructuresWithImportedData_WithCurrentStructuresAndImportedHasNoOverlap_UpdatesTargetCollection()
{
// Setup
var targetStructure = new TestStabilityPointStructure("target id");
var failureMechanism = new StabilityPointStructuresFailureMechanism();
StructureCollection <StabilityPointStructure> structures = failureMechanism.StabilityPointStructures;
structures.AddRange(new[]
{
targetStructure
}, sourceFilePath);
var readStructure = new TestStabilityPointStructure("read id");
TestStabilityPointStructure[] importedStructures =
{
readStructure
};
var strategy = new StabilityPointStructureUpdateDataStrategy(failureMechanism);
// Call
IEnumerable <IObservable> affectedObjects = strategy.UpdateStructuresWithImportedData(importedStructures,
sourceFilePath);
// Assert
CollectionAssert.AreEqual(importedStructures, structures);
Assert.AreSame(readStructure, structures[0]);
CollectionAssert.AreEquivalent(new IObservable[]
{
structures
}, affectedObjects);
}
public void VerifyUpdates_CalculationWithoutOutputs_ReturnsTrue()
{
// Setup
var mocks = new MockRepository();
var assessmentSection = mocks.Stub <IAssessmentSection>();
var mainWindow = mocks.Stub <IMainWindow>();
var gui = mocks.Stub <IGui>();
gui.Stub(g => g.MainWindow).Return(mainWindow);
mocks.ReplayAll();
var failureMechanism = new StabilityPointStructuresFailureMechanism();
failureMechanism.CalculationsGroup.Children.Add(new StructuresCalculation <StabilityPointStructuresInput>());
var structures = new StructureCollection <StabilityPointStructure>();
var context = new StabilityPointStructuresContext(structures, failureMechanism, assessmentSection);
using (var plugin = new StabilityPointStructuresPlugin())
{
plugin.Gui = gui;
ImportInfo importInfo = GetImportInfo(plugin);
// Call
bool updatesVerified = importInfo.VerifyUpdates(context);
// Assert
Assert.IsTrue(updatesVerified);
mocks.VerifyAll();
}
}
public void UpdateStructuresWithImportedData_SingleChange_UpdatesOnlySingleChange(StabilityPointStructure readStructure)
{
// Setup
StabilityPointStructure structure = new TestStabilityPointStructure();
var failureMechanism = new StabilityPointStructuresFailureMechanism();
StructureCollection <StabilityPointStructure> targetCollection = failureMechanism.StabilityPointStructures;
targetCollection.AddRange(new[]
{
structure
}, sourceFilePath);
var strategy = new StabilityPointStructureUpdateDataStrategy(failureMechanism);
// Call
IEnumerable <IObservable> affectedObjects = strategy.UpdateStructuresWithImportedData(new[]
{
readStructure
},
sourceFilePath);
// Assert
AssertStabilityPointStructure(readStructure, structure);
CollectionAssert.AreEqual(new IObservable[]
{
targetCollection,
structure
}, affectedObjects);
}
public void ClearAllCalculationOutputAndHydraulicBoundaryLocations_WithVariousCalculations_ClearsCalculationsOutputAndReturnsAffectedObjects()
{
// Setup
StabilityPointStructuresFailureMechanism failureMechanism = CreateFullyConfiguredFailureMechanism();
StructuresCalculation <StabilityPointStructuresInput>[] calculations = failureMechanism.Calculations.Cast <StructuresCalculation <StabilityPointStructuresInput> >().ToArray();
IObservable[] expectedAffectedCalculations = calculations.Where(c => c.HasOutput)
.Cast <IObservable>()
.ToArray();
IObservable[] expectedAffectedCalculationInputs = calculations.Select(c => c.InputParameters)
.Where(i => i.HydraulicBoundaryLocation != null)
.Cast <IObservable>()
.ToArray();
// Call
IEnumerable <IObservable> affectedItems =
StabilityPointStructuresDataSynchronizationService.ClearAllCalculationOutputAndHydraulicBoundaryLocations(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:
Assert.IsTrue(failureMechanism.Calculations.Cast <StructuresCalculation <StabilityPointStructuresInput> >()
.All(c => c.InputParameters.HydraulicBoundaryLocation == null && !c.HasOutput));
CollectionAssert.AreEquivalent(expectedAffectedCalculations.Concat(expectedAffectedCalculationInputs),
affectedItems);
}
public void ChildNodeObjects_FailureMechanismInAssemblyFalse_ReturnChildDataNodes()
{
// Setup
var mocks = new MockRepository();
var assessmentSection = mocks.Stub <IAssessmentSection>();
mocks.ReplayAll();
var failureMechanism = new StabilityPointStructuresFailureMechanism
{
InAssembly = false
};
var context = new StabilityPointStructuresFailureMechanismContext(failureMechanism, assessmentSection);
// Call
object[] children = info.ChildNodeObjects(context).ToArray();
// Assert
Assert.AreEqual(1, children.Length);
var comment = (Comment)children[0];
Assert.AreSame(failureMechanism.NotInAssemblyComments, comment);
mocks.VerifyAll();
}
public void Run_CalculationInvalidInput_LogValidationStartAndEndWithError()
{
// Setup
var assessmentSection = new AssessmentSection(AssessmentSectionComposition.Dike)
{
HydraulicBoundaryDatabase =
{
FilePath = Path.Combine(testDataPath, "notexisting.sqlite")
}
};
var failureMechanism = new StabilityPointStructuresFailureMechanism();
var calculation = new StructuresCalculation <StabilityPointStructuresInput>();
CalculatableActivity activity = StabilityPointStructuresCalculationActivityFactory.CreateCalculationActivity(calculation,
failureMechanism,
assessmentSection);
// Call
Action call = () => activity.Run();
// Assert
TestHelper.AssertLogMessages(call, messages =>
{
string[] msgs = messages.ToArray();
Assert.AreEqual(4, msgs.Length);
Assert.AreEqual($"Uitvoeren van berekening '{calculation.Name}' is gestart.", msgs[0]);
CalculationServiceTestHelper.AssertValidationStartMessage(msgs[1]);
StringAssert.StartsWith("Herstellen van de verbinding met de hydraulische belastingendatabase is mislukt. Fout bij het lezen van bestand", msgs[2]);
CalculationServiceTestHelper.AssertValidationEndMessage(msgs[3]);
});
Assert.AreEqual(ActivityState.Failed, activity.State);
}
/// <summary>
/// Clears all data dependent, either directly or indirectly, on the parent reference line.
/// </summary>
/// <param name="failureMechanism">The failure mechanism to be cleared.</param>
/// <returns>The results of the clear action.</returns>
/// <exception cref="ArgumentNullException">Thrown when <paramref name="failureMechanism"/>
/// is <c>null</c>.</exception>
public static ClearResults ClearReferenceLineDependentData(StabilityPointStructuresFailureMechanism failureMechanism)
{
if (failureMechanism == null)
{
throw new ArgumentNullException(nameof(failureMechanism));
}
var changedObjects = new List <IObservable>();
object[] removedObjects = failureMechanism.Sections.OfType <object>()
.Concat(failureMechanism.SectionResults)
.Concat(failureMechanism.CalculationsGroup.GetAllChildrenRecursive())
.Concat(failureMechanism.ForeshoreProfiles)
.Concat(failureMechanism.StabilityPointStructures)
.ToArray();
failureMechanism.ClearAllSections();
changedObjects.Add(failureMechanism);
changedObjects.Add(failureMechanism.SectionResults);
failureMechanism.CalculationsGroup.Children.Clear();
changedObjects.Add(failureMechanism.CalculationsGroup);
failureMechanism.ForeshoreProfiles.Clear();
changedObjects.Add(failureMechanism.ForeshoreProfiles);
failureMechanism.StabilityPointStructures.Clear();
changedObjects.Add(failureMechanism.StabilityPointStructures);
return(new ClearResults(changedObjects, removedObjects));
}
/// <summary>
/// Creates a new instance of <see cref="StabilityPointStructuresInputContext"/>.
/// </summary>
/// <param name="input">The <see cref="StabilityPointStructuresInput"/> instance wrapped by this context object.</param>
/// <param name="calculation">The calculation item which the <paramref name="input"/> belongs to.</param>
/// <param name="failureMechanism">The failure mechanism which the context belongs to.</param>
/// <param name="assessmentSection">The assessment section which the context belongs to.</param>
/// <exception cref="ArgumentNullException">Thrown when any input argument is <c>null</c>.</exception>
public StabilityPointStructuresInputContext(StabilityPointStructuresInput input,
StructuresCalculation <StabilityPointStructuresInput> calculation,
StabilityPointStructuresFailureMechanism failureMechanism,
IAssessmentSection assessmentSection)
: base(input, calculation, failureMechanism, assessmentSection)
{
}
public void Constructor_ExpectedValues()
{
// Setup
var random = new Random(21);
var failureMechanism = new StabilityPointStructuresFailureMechanism
{
InAssembly = random.NextBoolean()
};
// Call
var properties = new StabilityPointStructuresFailureMechanismProperties(failureMechanism);
// Assert
Assert.IsInstanceOf <StabilityPointStructuresFailureMechanismPropertiesBase>(properties);
Assert.AreEqual(failureMechanism.Name, properties.Name);
Assert.AreEqual(failureMechanism.Code, properties.Code);
Assert.AreEqual(failureMechanism.InAssembly, properties.InAssembly);
GeneralStabilityPointStructuresInput generalInput = failureMechanism.GeneralInput;
Assert.AreEqual(2, properties.N.NumberOfDecimalPlaces);
Assert.AreEqual(generalInput.N,
properties.N,
properties.N.GetAccuracy());
Assert.AreEqual(generalInput.ApplyLengthEffectInSection, properties.ApplyLengthEffectInSection);
}
public void IsEnabled_FailureMechanismSectionsSourcePathSet_ReturnTrue()
{
// Setup
var mocks = new MockRepository();
var assessmentSection = mocks.Stub <IAssessmentSection>();
mocks.ReplayAll();
var failureMechanism = new StabilityPointStructuresFailureMechanism();
string sourcePath = TestHelper.GetScratchPadPath();
failureMechanism.SetSections(Enumerable.Empty <FailureMechanismSection>(), sourcePath);
var context = new StabilityPointStructuresFailureMechanismSectionsContext(failureMechanism, assessmentSection);
using (var plugin = new StabilityPointStructuresPlugin())
{
UpdateInfo importInfo = GetUpdateInfo(plugin);
// Call
bool isEnabled = importInfo.IsEnabled(context);
// Assert
Assert.IsTrue(isEnabled);
}
mocks.VerifyAll();
}
public void AssembleFailureMechanism_CalculatorThrowsException_ThrowsAssemblyException()
{
// Setup
var failureMechanism = new StabilityPointStructuresFailureMechanism
{
AssemblyResult =
{
ProbabilityResultType = FailureMechanismAssemblyProbabilityResultType.Automatic
}
};
var assessmentSection = new AssessmentSectionStub();
using (new AssemblyToolCalculatorFactoryConfig())
{
var calculatorFactory = (TestAssemblyToolCalculatorFactory)AssemblyToolCalculatorFactory.Instance;
FailureMechanismAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedFailureMechanismAssemblyCalculator;
calculator.ThrowExceptionOnCalculate = true;
// Call
void Call() => StabilityPointStructuresFailureMechanismAssemblyFactory.AssembleFailureMechanism(failureMechanism, assessmentSection);
// Assert
var exception = Assert.Throws <AssemblyException>(Call);
Exception innerException = exception.InnerException;
Assert.IsInstanceOf <FailureMechanismAssemblyCalculatorException>(innerException);
Assert.AreEqual(innerException.Message, exception.Message);
}
}
