public void UpdateSectionsWithImportedData_WithInvalidSections_ThrowsUpdateDataException() { // Setup string sourcePath = TestHelper.GetScratchPadPath(); var failureMechanism = new TestFailureMechanism(); FailureMechanismSection failureMechanismSection1 = FailureMechanismSectionTestFactory.CreateFailureMechanismSection(new[] { new Point2D(0.0, 0.0), new Point2D(5.0, 5.0) }); FailureMechanismSection failureMechanismSection2 = FailureMechanismSectionTestFactory.CreateFailureMechanismSection(new[] { new Point2D(10.0, 10.0), new Point2D(15.0, 15.0) }); var failureMechanismSectionReplaceStrategy = new FailureMechanismSectionReplaceStrategy(failureMechanism); FailureMechanismSection[] sections = { failureMechanismSection1, failureMechanismSection2 }; // Call void Call() => failureMechanismSectionReplaceStrategy.UpdateSectionsWithImportedData(sections, sourcePath); // Assert var exception = Assert.Throws <UpdateDataException>(Call); Assert.IsInstanceOf <ArgumentException>(exception.InnerException); Assert.AreEqual(exception.InnerException.Message, exception.Message); }
public void CreateAssemblyGroupFeatures_PerformAssemblyFuncThrowsAssemblyExceptionOnFirstSection_FirstSectionSkipped() { // Setup var random = new Random(39); var failureMechanism = new TestFailureMechanism(); FailureMechanismTestHelper.AddSections(failureMechanism, 2); var expectedAssemblyResult = new FailureMechanismSectionAssemblyResult( random.NextDouble(), random.NextDouble(), random.NextDouble(), random.NextEnumValue <FailureMechanismSectionAssemblyGroup>()); // Call var shouldThrowException = true; IEnumerable <MapFeature> features = AssemblyMapDataFeaturesFactory.CreateAssemblyGroupFeatures <FailureMechanismSectionResult>( failureMechanism, sr => { if (shouldThrowException) { shouldThrowException = false; throw new AssemblyException(); } return(expectedAssemblyResult); }); // Assert AssertAssemblyGroupMapFeature(failureMechanism.Sections.ElementAt(1), features.Single(), expectedAssemblyResult); }
public void AssembleSection_CalculatorThrowsException_ThrowsAssemblyException() { // Setup FailureMechanismSection section = FailureMechanismSectionTestFactory.CreateFailureMechanismSection(); var sectionResult = new NonAdoptableWithProfileProbabilityFailureMechanismSectionResult(section); var failureMechanism = new TestFailureMechanism(); var assessmentSection = new AssessmentSectionStub(); using (new AssemblyToolCalculatorFactoryConfig()) { var calculatorFactory = (TestAssemblyToolCalculatorFactory)AssemblyToolCalculatorFactory.Instance; FailureMechanismSectionAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator; calculator.ThrowExceptionOnCalculate = true; // Call void Call() => FailureMechanismAssemblyFactory.AssembleSection( sectionResult, failureMechanism, assessmentSection); // Assert var exception = Assert.Throws <AssemblyException>(Call); Exception innerException = exception.InnerException; Assert.IsInstanceOf <FailureMechanismSectionAssemblyCalculatorException>(innerException); Assert.AreEqual(innerException.Message, exception.Message); } }
public void UpdateSectionsWithImportedData_WithEmptyData_ClearsSectionsAndUpdatesPathAndReturnsAffectedObjects() { // Setup const string oldSourcePath = "old/path"; string sourcePath = TestHelper.GetScratchPadPath(); var failureMechanism = new TestFailureMechanism(); failureMechanism.SetSections(new[] { FailureMechanismSectionTestFactory.CreateFailureMechanismSection() }, oldSourcePath); var failureMechanismSectionReplaceStrategy = new FailureMechanismSectionReplaceStrategy(failureMechanism); // Precondition IEnumerable <FailureMechanismSection> failureMechanismSections = failureMechanism.Sections; Assert.AreEqual(1, failureMechanismSections.Count()); Assert.AreEqual(oldSourcePath, failureMechanism.FailureMechanismSectionSourcePath); // Call IEnumerable <IObservable> affectedObjects = failureMechanismSectionReplaceStrategy.UpdateSectionsWithImportedData(Enumerable.Empty <FailureMechanismSection>(), sourcePath); // Assert Assert.AreEqual(sourcePath, failureMechanism.FailureMechanismSectionSourcePath); Assert.IsEmpty(failureMechanismSections); CollectionAssert.AreEqual(new IObservable[] { failureMechanism, failureMechanism.SectionResults }, affectedObjects); }
public void Constructor_ExpectedValues() { // Setup var random = new Random(39); var failureMechanism = new TestFailureMechanism { InAssembly = random.NextBoolean(), GeneralInput = { ApplyLengthEffectInSection = random.NextBoolean() } }; // Call var properties = new StandAloneFailureMechanismProperties(failureMechanism); // Assert Assert.IsInstanceOf <ObjectProperties <IHasGeneralInput> >(properties); Assert.AreSame(failureMechanism, properties.Data); Assert.AreEqual(failureMechanism.Name, properties.Name); Assert.AreEqual(failureMechanism.Code, properties.Code); Assert.AreEqual(failureMechanism.InAssembly, properties.InAssembly); Assert.AreEqual(failureMechanism.GeneralInput.N, properties.N); Assert.AreEqual(failureMechanism.GeneralInput.ApplyLengthEffectInSection, properties.ApplyLengthEffectInSection); }
public void GivenViewWithSections_WhenFailureMechanismNotifiesChangeAndSectionsUpdated_ThenDataGridViewUpdated() { // Given var failureMechanism = new TestFailureMechanism(); FailureMechanismTestHelper.SetSections(failureMechanism, new[] { CreateFailureMechanismSection("a", 0.0, 0.0, 1.0, 1.0) }); ProbabilityAssessmentInput probabilityAssessmentInput = CreateProbabilityAssessmentInput(); using (FailureMechanismSectionsProbabilityAssessmentView view = ShowFailureMechanismSectionsProbabilityAssessmentView(failureMechanism.Sections, failureMechanism, probabilityAssessmentInput)) { DataGridViewControl sectionsDataGridViewControl = GetSectionsDataGridViewControl(view); // Precondition AssertSectionsDataGridViewControl(failureMechanism.Sections.ToArray(), probabilityAssessmentInput, sectionsDataGridViewControl); // When FailureMechanismTestHelper.SetSections(failureMechanism, new[] { CreateFailureMechanismSection("a", 1.0, 1.0, 2.0, 2.0) }); failureMechanism.NotifyObservers(); // Then AssertSectionsDataGridViewControl(failureMechanism.Sections.ToArray(), probabilityAssessmentInput, sectionsDataGridViewControl); } }
public void GivenViewWithSections_WhenFailureMechanismNotifiesChangeButNothingRelevantChanged_ThenDataGridViewNotUpdated() { // Given var failureMechanism = new TestFailureMechanism(); FailureMechanismTestHelper.SetSections(failureMechanism, new[] { CreateFailureMechanismSection("a", 0.0, 0.0, 1.0, 1.0) }); ProbabilityAssessmentInput probabilityAssessmentInput = CreateProbabilityAssessmentInput(); using (FailureMechanismSectionsProbabilityAssessmentView view = ShowFailureMechanismSectionsProbabilityAssessmentView(failureMechanism.Sections, failureMechanism, probabilityAssessmentInput)) { DataGridView sectionsDataGridView = GetSectionsDataGridView(view); var invalidated = false; sectionsDataGridView.Invalidated += (s, e) => { invalidated = true; }; // When failureMechanism.NotifyObservers(); // Then Assert.IsFalse(invalidated); } }
public void GivenViewWithSections_WhenFailureMechanismNotifiesChangeAndSectionsUpdated_ThenDataGridViewUpdated() { // Given var failureMechanism = new TestFailureMechanism(); FailureMechanismTestHelper.SetSections(failureMechanism, new[] { CreateFailureMechanismSection("a") }); using (FailureMechanismSectionsView view = ShowFailureMechanismSectionsView(failureMechanism.Sections, failureMechanism)) { DataGridViewControl sectionsDataGridViewControl = GetSectionsDataGridViewControl(view); // Precondition AssertSectionsDataGridViewControl(failureMechanism.Sections.ToArray(), sectionsDataGridViewControl); // When FailureMechanismTestHelper.SetSections(failureMechanism, new[] { FailureMechanismSectionTestFactory.CreateFailureMechanismSection() }); failureMechanism.NotifyObservers(); // Then AssertSectionsDataGridViewControl(failureMechanism.Sections.ToArray(), sectionsDataGridViewControl); } }
public void CreateAssemblyGroupFeatures_ValidParameters_ReturnsExpectedFeatures() { // Setup var random = new Random(39); var failureMechanism = new TestFailureMechanism(); FailureMechanismTestHelper.AddSections(failureMechanism, random.Next(0, 10)); var expectedAssemblyResult = new FailureMechanismSectionAssemblyResult( random.NextDouble(), random.NextDouble(), random.NextDouble(), random.NextEnumValue <FailureMechanismSectionAssemblyGroup>()); // Call IEnumerable <MapFeature> features = AssemblyMapDataFeaturesFactory.CreateAssemblyGroupFeatures <FailureMechanismSectionResult>( failureMechanism, sr => expectedAssemblyResult); // Assert Assert.AreEqual(failureMechanism.Sections.Count(), features.Count()); for (var i = 0; i < features.Count(); i++) { FailureMechanismSection section = failureMechanism.Sections.ElementAt(i); MapFeature mapFeature = features.ElementAt(i); AssertAssemblyGroupMapFeature(section, mapFeature, expectedAssemblyResult); } }
public void AssembleFailureMechanism_CalculatorThrowsException_ThrowsAssemblyException() { // Setup var failureMechanism = new TestFailureMechanism { 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() => FailureMechanismAssemblyFactory.AssembleFailureMechanism(failureMechanism, assessmentSection); // Assert var exception = Assert.Throws <AssemblyException>(Call); Exception innerException = exception.InnerException; Assert.IsInstanceOf <FailureMechanismAssemblyCalculatorException>(innerException); Assert.AreEqual(innerException.Message, exception.Message); } }
public void GivenViewWithSections_WhenFailureMechanismNotifiesChangeAndSectionsNotUpdated_ThenDataGridViewNotUpdated() { // Given var failureMechanism = new TestFailureMechanism(); FailureMechanismTestHelper.SetSections(failureMechanism, new[] { CreateFailureMechanismSection("a") }); using (FailureMechanismSectionsView view = ShowFailureMechanismSectionsView(failureMechanism.Sections, failureMechanism)) { DataGridView sectionsDataGridView = GetSectionsDataGridView(view); var invalidated = false; sectionsDataGridView.Invalidated += (s, e) => { invalidated = true; }; // When failureMechanism.NotifyObservers(); // Then Assert.IsFalse(invalidated); } }
public void GivenFailureMechanismResultObserverWithAttachedObserver_WhenFailureMechanismSectionResultNotifiesObservers_ThenAttachedObserverNotified() { // Given var mocks = new MockRepository(); var observer = mocks.StrictMock <IObserver>(); observer.Expect(o => o.UpdateObserver()); mocks.ReplayAll(); var failureMechanism = new TestFailureMechanism(); FailureMechanismTestHelper.SetSections(failureMechanism, new[] { FailureMechanismSectionTestFactory.CreateFailureMechanismSection() }); using (var resultObserver = new FailureMechanismResultObserver <TestFailureMechanism, FailureMechanismSectionResult>( failureMechanism)) { resultObserver.Attach(observer); // When failureMechanism.SectionResults.Single().NotifyObservers(); } // Then mocks.VerifyAll(); }
public void AssembleFailureMechanism_CalculatorRan_ReturnsExpectedOutput() { // Setup var failureMechanism = new TestFailureMechanism { AssemblyResult = { ProbabilityResultType = FailureMechanismAssemblyProbabilityResultType.Automatic } }; var assessmentSection = new AssessmentSectionStub(); using (new AssemblyToolCalculatorFactoryConfig()) { var calculatorFactory = (TestAssemblyToolCalculatorFactory)AssemblyToolCalculatorFactory.Instance; FailureMechanismAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedFailureMechanismAssemblyCalculator; // Call FailureMechanismAssemblyResultWrapper result = FailureMechanismAssemblyFactory.AssembleFailureMechanism(failureMechanism, assessmentSection); // Assert Assert.AreSame(calculator.AssemblyResultOutput, result); } }
public void AssembleFailureMechanism_WithInput_SetsInputOnCalculator() { // Setup var failureMechanism = new TestFailureMechanism { 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 FailureMechanismAssemblyFactory.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 Constructor_InAssemblyTrue_PropertiesHaveExpectedAttributesValues() { // Setup var failureMechanism = new TestFailureMechanism { InAssembly = true }; // Call var properties = new StandAloneFailureMechanismProperties(failureMechanism); // Assert const string generalCategory = "Algemeen"; const string lengthEffectCategory = "Lengte-effect"; PropertyDescriptorCollection dynamicProperties = PropertiesTestHelper.GetAllVisiblePropertyDescriptors(properties); Assert.AreEqual(5, dynamicProperties.Count); PropertyDescriptor nameProperty = dynamicProperties[namePropertyIndex]; PropertiesTestHelper.AssertRequiredPropertyDescriptorProperties(nameProperty, generalCategory, "Naam", "De naam van het faalmechanisme.", true); PropertyDescriptor codeProperty = dynamicProperties[codePropertyIndex]; PropertiesTestHelper.AssertRequiredPropertyDescriptorProperties(codeProperty, generalCategory, "Label", "Het label van het faalmechanisme.", true); PropertyDescriptor inAssemblyProperty = dynamicProperties[inAssemblyPropertyIndex]; PropertiesTestHelper.AssertRequiredPropertyDescriptorProperties(inAssemblyProperty, generalCategory, "In assemblage", "Geeft aan of dit faalmechanisme wordt meegenomen in de assemblage.", true); PropertyDescriptor nProperty = dynamicProperties[nPropertyIndex]; PropertiesTestHelper.AssertRequiredPropertyDescriptorProperties(nProperty, lengthEffectCategory, "N [-]", "De parameter 'N' die gebruikt wordt om het lengte-effect mee te nemen in de beoordeling."); PropertyDescriptor applySectionLengthInSectionProperty = dynamicProperties[applyLengthEffectInSectionPropertyIndex]; PropertiesTestHelper.AssertRequiredPropertyDescriptorProperties(applySectionLengthInSectionProperty, lengthEffectCategory, "Toepassen lengte-effect binnen vak", "Geeft aan of het lengte-effect binnen een vak toegepast wordt."); }
public void DoPostUpdateActions_Always_ReturnsEmptyCollection() { // Setup var failureMechanism = new TestFailureMechanism(); var failureMechanismSectionReplaceStrategy = new FailureMechanismSectionReplaceStrategy(failureMechanism); // Call IEnumerable <IObservable> affectedObjects = failureMechanismSectionReplaceStrategy.DoPostUpdateActions(); // Assert CollectionAssert.IsEmpty(affectedObjects); }
public void AssembleFailureMechanism_AssessmentSectionNull_ThrowsArgumentNullException() { // Setup var failureMechanism = new TestFailureMechanism(); // Call void Call() => FailureMechanismAssemblyFactory.AssembleFailureMechanism(failureMechanism, null); // Assert var exception = Assert.Throws <ArgumentNullException>(Call); Assert.AreEqual("assessmentSection", exception.ParamName); }
public void DoPostImport_AfterImport_CallUpdateStrategyAndObserversNotified() { // Setup var updateSectionsWithImportedDataObservable = new TestObservable(); var doPostUpdateActionsObservable = new TestObservable(); var mocks = new MockRepository(); var updateStrategy = mocks.StrictMock <IFailureMechanismSectionUpdateStrategy>(); updateStrategy.Expect(us => us.UpdateSectionsWithImportedData(null, null)) .IgnoreArguments() .Return(new[] { updateSectionsWithImportedDataObservable }); updateStrategy.Expect(us => us.DoPostUpdateActions()) .Return(new[] { doPostUpdateActionsObservable }); var messageProvider = mocks.Stub <IImporterMessageProvider>(); var updateSectionsWithImportedDataObserver = mocks.StrictMock <IObserver>(); updateSectionsWithImportedDataObserver.Expect(o => o.UpdateObserver()); var doPostUpdateActionsObserver = mocks.StrictMock <IObserver>(); doPostUpdateActionsObserver.Expect(o => o.UpdateObserver()); mocks.ReplayAll(); string referenceLineFilePath = TestHelper.GetTestDataPath(TestDataPath.Riskeer.Common.IO, Path.Combine("ReferenceLine", "traject_1-1.shp")); string sectionsFilePath = TestHelper.GetTestDataPath(TestDataPath.Riskeer.Common.IO, Path.Combine("FailureMechanismSections", "traject_1-1_vakken.shp")); ReferenceLine importReferenceLine = ImportReferenceLine(referenceLineFilePath); var failureMechanism = new TestFailureMechanism(); var importer = new FailureMechanismSectionsImporter(failureMechanism, importReferenceLine, sectionsFilePath, updateStrategy, messageProvider); importer.Import(); updateSectionsWithImportedDataObservable.Attach(updateSectionsWithImportedDataObserver); doPostUpdateActionsObservable.Attach(doPostUpdateActionsObserver); // Call importer.DoPostImport(); // Assert mocks.VerifyAll(); }
public void GivenMapLayerWithFailureMechanismSectionAssemblyResults_WhenChangingFailureMechanismDataAndObserversNotified_ThenMapDataUpdated() { // Given var mocks = new MockRepository(); var observer = mocks.StrictMock <IObserver>(); observer.Expect(o => o.UpdateObserver()); mocks.ReplayAll(); var random = new Random(21); var failureMechanism = new TestFailureMechanism(); failureMechanism.SetSections(new[] { FailureMechanismSectionTestFactory.CreateFailureMechanismSection() }, string.Empty); var assemblyResult = new FailureMechanismSectionAssemblyResult( random.NextDouble(), random.NextDouble(), random.NextDouble(), random.NextEnumValue <FailureMechanismSectionAssemblyGroup>()); using (var mapLayer = new NonCalculatableFailureMechanismSectionResultsMapLayer <TestFailureMechanismSectionResult>( failureMechanism, result => assemblyResult)) { mapLayer.MapData.Attach(observer); // Precondition MapDataTestHelper.AssertAssemblyMapData(failureMechanism, assemblyResult, mapLayer.MapData); // When failureMechanism.SetSections(new[] { FailureMechanismSectionTestFactory.CreateFailureMechanismSection(new[] { new Point2D(0, 0), new Point2D(1, 1) }), FailureMechanismSectionTestFactory.CreateFailureMechanismSection(new[] { new Point2D(1, 1), new Point2D(2, 2) }) }, string.Empty); failureMechanism.NotifyObservers(); // Then MapDataTestHelper.AssertAssemblyMapData(failureMechanism, assemblyResult, mapLayer.MapData); } mocks.VerifyAll(); }
public void Constructor_ExpectedValues() { // Setup var failureMechanism = new TestFailureMechanism(); string sourcePath = TestHelper.GetScratchPadPath(); var random = new Random(39); var probabilityAssessmentInput = new TestProbabilityAssessmentInput(random.NextDouble(), random.NextDouble()); IEnumerable <FailureMechanismSection> sections = new[] { FailureMechanismSectionTestFactory.CreateFailureMechanismSection() }; failureMechanism.SetSections(sections, sourcePath); // Call using (var properties = new FailureMechanismSectionsProbabilityAssessmentProperties( failureMechanism, probabilityAssessmentInput)) { // Assert Assert.IsInstanceOf <ObjectProperties <IFailureMechanism> >(properties); Assert.IsInstanceOf <IDisposable>(properties); Assert.AreSame(failureMechanism, properties.Data); TestHelper.AssertTypeConverter <FailureMechanismSectionsProperties, ExpandableArrayConverter>( nameof(FailureMechanismSectionsProperties.Sections)); Assert.AreEqual(sections.Count(), properties.Sections.Length); double sectionStart = 0; for (var i = 0; i < sections.Count(); i++) { FailureMechanismSection section = sections.ElementAt(i); FailureMechanismSectionProbabilityAssessmentProperties property = properties.Sections[i]; Assert.AreSame(section, property.Data); Assert.AreEqual(1 + probabilityAssessmentInput.A * section.Length / probabilityAssessmentInput.B, property.N, property.N.GetAccuracy()); double sectionEnd = sectionStart + section.Length; Assert.AreEqual(sectionStart, property.SectionStart, property.SectionStart.GetAccuracy()); Assert.AreEqual(sectionEnd, property.SectionEnd, property.SectionEnd.GetAccuracy()); sectionStart = sectionEnd; } Assert.AreEqual(sourcePath, properties.SourcePath); } }
public void AssembleSection_AssessmentSectionNull_ThrowsArgumentNullException() { // Setup FailureMechanismSection section = FailureMechanismSectionTestFactory.CreateFailureMechanismSection(); var sectionResult = new NonAdoptableWithProfileProbabilityFailureMechanismSectionResult(section); var failureMechanism = new TestFailureMechanism(); // Call void Call() => FailureMechanismAssemblyFactory.AssembleSection(sectionResult, failureMechanism, null); // Assert var exception = Assert.Throws <ArgumentNullException>(Call); Assert.AreEqual("assessmentSection", exception.ParamName); }
public void GivenPropertyControlWithData_WhenFailureMechanismUpdated_RefreshRequiredEventRaised() { // Given var failureMechanism = new TestFailureMechanism(); using (var properties = new FailureMechanismSectionsProperties(failureMechanism)) { var refreshRequiredRaised = 0; properties.RefreshRequired += (sender, args) => refreshRequiredRaised++; // When failureMechanism.NotifyObservers(); // Then Assert.AreEqual(1, refreshRequiredRaised); } }
public void GetViewData_Always_ReturnsFailureMechanismSections() { // Setup var mocks = new MockRepository(); var assessmentSection = mocks.Stub <IAssessmentSection>(); mocks.ReplayAll(); var failureMechanism = new TestFailureMechanism(); var failureMechanismSectionsContext = new FailureMechanismSectionsContext(failureMechanism, assessmentSection); // Call object viewData = info.GetViewData(failureMechanismSectionsContext); // Assert Assert.AreSame(failureMechanism.Sections, viewData); mocks.VerifyAll(); }
public void DynamicVisibleValidationMethod_DependingOnInAssembly_ReturnExpectedVisibility(bool inAssembly) { // Setup var failureMechanism = new TestFailureMechanism { InAssembly = inAssembly }; var properties = new StandAloneFailureMechanismProperties(failureMechanism); // Call & Assert Assert.IsTrue(properties.DynamicVisibleValidationMethod(nameof(properties.Name))); Assert.IsTrue(properties.DynamicVisibleValidationMethod(nameof(properties.Code))); Assert.IsTrue(properties.DynamicVisibleValidationMethod(nameof(properties.InAssembly))); Assert.AreEqual(inAssembly, properties.DynamicVisibleValidationMethod(nameof(properties.N))); Assert.AreEqual(inAssembly, properties.DynamicVisibleValidationMethod(nameof(properties.ApplyLengthEffectInSection))); Assert.IsTrue(properties.DynamicVisibleValidationMethod(null)); }
public void Constructor_InAssemblyFalse_PropertiesHaveExpectedAttributesValues() { // Setup var failureMechanism = new TestFailureMechanism { InAssembly = false }; // Call var properties = new StandAloneFailureMechanismProperties(failureMechanism); // Assert PropertyDescriptorCollection dynamicProperties = PropertiesTestHelper.GetAllVisiblePropertyDescriptors(properties); Assert.AreEqual(3, dynamicProperties.Count); const string generalCategory = "Algemeen"; PropertyDescriptor nameProperty = dynamicProperties[namePropertyIndex]; PropertiesTestHelper.AssertRequiredPropertyDescriptorProperties(nameProperty, generalCategory, "Naam", "De naam van het faalmechanisme.", true); PropertyDescriptor labelProperty = dynamicProperties[codePropertyIndex]; PropertiesTestHelper.AssertRequiredPropertyDescriptorProperties(labelProperty, generalCategory, "Label", "Het label van het faalmechanisme.", true); PropertyDescriptor inAssemblyProperty = dynamicProperties[inAssemblyPropertyIndex]; PropertiesTestHelper.AssertRequiredPropertyDescriptorProperties(inAssemblyProperty, generalCategory, "In assemblage", "Geeft aan of dit faalmechanisme wordt meegenomen in de assemblage.", true); }
public void AssembleSection_SectionResultNull_ThrowsArgumentNullException() { // Setup var mocks = new MockRepository(); var assessmentSection = mocks.Stub <IAssessmentSection>(); mocks.ReplayAll(); var failureMechanism = new TestFailureMechanism(); // Call void Call() => FailureMechanismAssemblyFactory.AssembleSection(null, failureMechanism, assessmentSection); // Assert var exception = Assert.Throws <ArgumentNullException>(Call); Assert.AreEqual("sectionResult", exception.ParamName); mocks.VerifyAll(); }
public void GivenPropertyControlWithData_WhenFailureMechanismUpdated_RefreshRequiredEventRaised() { // Given var random = new Random(39); var probabilityAssessmentInput = new TestProbabilityAssessmentInput(random.NextDouble(), random.NextDouble()); var failureMechanism = new TestFailureMechanism(); using (var properties = new FailureMechanismSectionsProbabilityAssessmentProperties( failureMechanism, probabilityAssessmentInput)) { var refreshRequiredRaised = 0; properties.RefreshRequired += (sender, args) => refreshRequiredRaised++; // When failureMechanism.NotifyObservers(); // Then Assert.AreEqual(1, refreshRequiredRaised); } }
public void ReplaceData_Always_CalledWithExpectedFailureMechanism() { // Setup var failureMechanism = new TestFailureMechanism(); var collection = new TestUniqueItemCollection(); var strategy = new ConcreteStrategyClass(failureMechanism, collection); TestUniqueItemCollection[] expectedObservables = { collection }; strategy.ClearDataReturnedList = expectedObservables; // Call IObservable[] affectedObjects = strategy.ConcreteReplaceData(Enumerable.Empty <TestItem>(), "some/source").ToArray(); // Assert Assert.AreSame(failureMechanism, strategy.ClearDataFailureMechanism); CollectionAssert.AreEqual(expectedObservables, affectedObjects); }
public void Create_WithAllData_SetsMetaEntityProperties() { // Setup var random = new Random(); var failureMechanism = new TestFailureMechanism { GeneralInput = { N = random.NextRoundedDouble(1, 20), ApplyLengthEffectInSection = random.NextBoolean() } }; // Call var metaEntity = failureMechanism.Create <TestFailureMechanismMetaEntity>(); // Assert Assert.IsInstanceOf <IStandAloneFailureMechanismMetaEntity>(metaEntity); Assert.AreEqual(failureMechanism.GeneralInput.N, metaEntity.N); Assert.AreEqual(Convert.ToByte(failureMechanism.GeneralInput.ApplyLengthEffectInSection), metaEntity.ApplyLengthEffectInSection); }
public void AssembleSection_WithInput_SetsInputOnCalculator() { // Setup var random = new Random(21); FailureMechanismSection section = FailureMechanismSectionTestFactory.CreateFailureMechanismSection(); var sectionResult = new NonAdoptableWithProfileProbabilityFailureMechanismSectionResult(section) { IsRelevant = random.NextBoolean(), InitialFailureMechanismResultType = NonAdoptableInitialFailureMechanismResultType.Manual, ManualInitialFailureMechanismResultSectionProbability = random.NextDouble(), FurtherAnalysisType = random.NextEnumValue <FailureMechanismSectionResultFurtherAnalysisType>(), RefinedSectionProbability = random.NextDouble() }; var failureMechanism = new TestFailureMechanism(); var assessmentSection = new AssessmentSectionStub(); using (new AssemblyToolCalculatorFactoryConfig()) { var calculatorFactory = (TestAssemblyToolCalculatorFactory)AssemblyToolCalculatorFactory.Instance; FailureMechanismSectionAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator; // Call FailureMechanismAssemblyFactory.AssembleSection(sectionResult, failureMechanism, assessmentSection); // Assert FailureMechanismSectionAssemblyInput calculatorInput = calculator.FailureMechanismSectionAssemblyInput; FailureMechanismContribution failureMechanismContribution = assessmentSection.FailureMechanismContribution; Assert.AreEqual(failureMechanismContribution.SignalFloodingProbability, calculatorInput.SignalFloodingProbability); Assert.AreEqual(failureMechanismContribution.MaximumAllowableFloodingProbability, calculatorInput.MaximumAllowableFloodingProbability); Assert.AreEqual(sectionResult.IsRelevant, calculatorInput.IsRelevant); Assert.IsTrue(calculatorInput.HasProbabilitySpecified); Assert.AreEqual(sectionResult.ManualInitialFailureMechanismResultSectionProbability, calculatorInput.InitialSectionProbability); Assert.AreEqual(sectionResult.FurtherAnalysisType, calculatorInput.FurtherAnalysisType); Assert.AreEqual(sectionResult.RefinedSectionProbability, calculatorInput.RefinedSectionProbability); } }