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