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); } }