public void UpdateInternalData_Always_UpdatesDataAndFiresEventsAndNotifiesObservers()
{
// Setup
var mocks = new MockRepository();
var observer = mocks.StrictMock <IObserver>();
observer.Expect(o => o.UpdateObserver());
mocks.ReplayAll();
FailureMechanismSectionResult sectionResult = FailureMechanismSectionResultTestFactory.CreateFailureMechanismSectionResult();
sectionResult.Attach(observer);
var row = new TestFailureMechanismSectionResultRow(sectionResult);
var rowUpdated = false;
row.RowUpdated += (sender, args) => rowUpdated = true;
var rowUpdateDone = false;
row.RowUpdateDone += (sender, args) => rowUpdateDone = true;
// Precondition
Assert.IsFalse(row.Updated);
// Call
row.UpdateInternal();
// Assert
Assert.IsTrue(row.Updated);
Assert.IsTrue(rowUpdated);
Assert.IsTrue(rowUpdateDone);
mocks.VerifyAll();
}
private static FailureMechanismSectionResultRowWithCalculatedProbabilityErrorProvider <GrassCoverErosionInwardsCalculationScenario> CreateErrorProvider(
FailureMechanismSectionResult sectionResult, IEnumerable <GrassCoverErosionInwardsCalculationScenario> calculationScenarios)
{
return(new FailureMechanismSectionResultRowWithCalculatedProbabilityErrorProvider <GrassCoverErosionInwardsCalculationScenario>(
sectionResult, calculationScenarios,
(scenario, lineSegments) => scenario.IsDikeProfileIntersectionWithReferenceLineInSection(lineSegments)));
}
private static FailureMechanismSectionResultRowWithCalculatedProbabilityErrorProvider <StructuresCalculationScenario <TStructuresInput> > CreateErrorProvider(
FailureMechanismSectionResult sectionResult, IEnumerable <StructuresCalculationScenario <TStructuresInput> > calculationScenarios)
{
return(new FailureMechanismSectionResultRowWithCalculatedProbabilityErrorProvider <StructuresCalculationScenario <TStructuresInput> >(
sectionResult, calculationScenarios,
(scenario, lineSegments) => scenario.IsStructureIntersectionWithReferenceLineInSection(lineSegments)));
}
private static void SetCommonFailureMechanismSectionResultProperties(this IFailureMechanismSectionResultEntity entity,
FailureMechanismSectionResult result)
{
entity.IsRelevant = Convert.ToByte(result.IsRelevant);
entity.ManualInitialFailureMechanismResultSectionProbability = result.ManualInitialFailureMechanismResultSectionProbability.ToNaNAsNull();
entity.FurtherAnalysisType = Convert.ToByte(result.FurtherAnalysisType);
entity.RefinedSectionProbability = result.RefinedSectionProbability.ToNaNAsNull();
}
private static void SetCommonFailureMechanismSectionResultProperties(this FailureMechanismSectionResult result,
IFailureMechanismSectionResultEntity entity)
{
result.IsRelevant = Convert.ToBoolean(entity.IsRelevant);
result.ManualInitialFailureMechanismResultSectionProbability = entity.ManualInitialFailureMechanismResultSectionProbability.ToNullAsNaN();
result.FurtherAnalysisType = (FailureMechanismSectionResultFurtherAnalysisType)entity.FurtherAnalysisType;
result.RefinedSectionProbability = entity.RefinedSectionProbability.ToNullAsNaN();
}
public void Constructor_ExpectedValues()
{
// Setup
FailureMechanismSectionResult sectionResult = FailureMechanismSectionResultTestFactory.CreateFailureMechanismSectionResult();
// Call
var row = new TestFailureMechanismSectionResultRow(sectionResult);
// Assert
Assert.IsInstanceOf <IHasColumnStateDefinitions>(row);
Assert.AreEqual(sectionResult.Section.Name, row.Name);
CollectionAssert.IsEmpty(row.ColumnStateDefinitions);
}
/// <summary>
/// Gets the <see cref="PipingScenarioConfigurationPerFailureMechanismSection"/> for a given <see cref="FailureMechanismSectionResult"/>.
/// </summary>
/// <param name="failureMechanism">The <see cref="PipingFailureMechanism"/> that contains
/// the <see cref="PipingScenarioConfigurationPerFailureMechanismSection"/>.</param>
/// <param name="sectionResult">The <see cref="FailureMechanismSectionResult"/> to retrieve the
/// <see cref="PipingScenarioConfigurationPerFailureMechanismSection"/> for.</param>
/// <returns>The <see cref="PipingScenarioConfigurationPerFailureMechanismSection"/> belonging to the <paramref name="sectionResult"/>.</returns>
/// <exception cref="ArgumentNullException">Thrown when any argument is <c>null</c>.</exception>
public static PipingScenarioConfigurationPerFailureMechanismSection GetScenarioConfigurationForSection(
this PipingFailureMechanism failureMechanism,
FailureMechanismSectionResult sectionResult)
{
if (failureMechanism == null)
{
throw new ArgumentNullException(nameof(failureMechanism));
}
if (sectionResult == null)
{
throw new ArgumentNullException(nameof(sectionResult));
}
return(failureMechanism.ScenarioConfigurationsPerFailureMechanismSection
.Single(sc => sc.Section.StartPoint.Equals(sectionResult.Section.StartPoint) &&
sc.Section.EndPoint.Equals(sectionResult.Section.EndPoint)));
}
/// <summary>
/// Creates a new instance of <see cref="FailureMechanismSectionResultRowWithCalculatedProbabilityErrorProvider{T}"/>.
/// </summary>
/// <param name="sectionResult">The <see cref="FailureMechanismSectionResult"/> to validate for.</param>
/// <param name="calculationScenarios">The calculation scenarios to validate.</param>
/// <param name="intersectionFunc">The function to determine whether a scenario is belonging
/// to the given <paramref name="sectionResult"/>.</param>
/// <exception cref="ArgumentNullException">Thrown when any parameter is <c>null</c>.</exception>
public FailureMechanismSectionResultRowWithCalculatedProbabilityErrorProvider(FailureMechanismSectionResult sectionResult,
IEnumerable <ICalculationScenario> calculationScenarios,
Func <T, IEnumerable <Segment2D>, bool> intersectionFunc)
{
if (sectionResult == null)
{
throw new ArgumentNullException(nameof(sectionResult));
}
if (calculationScenarios == null)
{
throw new ArgumentNullException(nameof(calculationScenarios));
}
if (intersectionFunc == null)
{
throw new ArgumentNullException(nameof(intersectionFunc));
}
this.sectionResult = sectionResult;
this.calculationScenarios = calculationScenarios;
this.intersectionFunc = intersectionFunc;
}
private IFailureMechanismSectionResultRowWithCalculatedProbabilityErrorProvider CreateErrorProvider(FailureMechanismSectionResult sectionResult)
{
PipingScenarioConfigurationPerFailureMechanismSection scenarioConfigurationForSection = FailureMechanism.GetScenarioConfigurationForSection(sectionResult);
IEnumerable <IPipingCalculationScenario <PipingInput> > calculationScenarios = FailureMechanism.ScenarioConfigurationTypeIsSemiProbabilistic(scenarioConfigurationForSection)
? (IEnumerable <IPipingCalculationScenario <PipingInput> >)FailureMechanism.Calculations.OfType <SemiProbabilisticPipingCalculationScenario>()
: FailureMechanism.Calculations.OfType <ProbabilisticPipingCalculationScenario>();
return(new FailureMechanismSectionResultRowWithCalculatedProbabilityErrorProvider <IPipingCalculationScenario <PipingInput> >(
sectionResult, calculationScenarios,
(scenario, lineSegments) => scenario.IsSurfaceLineIntersectionWithReferenceLineInSection(lineSegments)));
}
public void UpdateSectionsWithImportedData_WithValidData_SetsSectionsToFailureMechanismAndCopiesPropertiesOfEqualSectionsAndReturnsAffectedObjects()
{
// 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(5.0, 5.0),
new Point2D(10.0, 10.0)
});
failureMechanism.SetSections(new[]
{
failureMechanismSection1,
failureMechanismSection2
}, sourcePath);
IObservableEnumerable <FailureMechanismSectionResult> failureMechanismSectionResults = failureMechanism.SectionResults;
FailureMechanismSectionResult oldSectionResult = failureMechanismSectionResults.First();
var sectionResultUpdateStrategy = new TestUpdateFailureMechanismSectionResultUpdateStrategy();
var failureMechanismSectionUpdateStrategy = new FailureMechanismSectionUpdateStrategy <FailureMechanismSectionResult>(failureMechanism, sectionResultUpdateStrategy);
FailureMechanismSection[] sections =
{
FailureMechanismSectionTestFactory.CreateFailureMechanismSection(new[]
{
new Point2D(0.0, 0.0),
new Point2D(5.0, 5.0)
}),
FailureMechanismSectionTestFactory.CreateFailureMechanismSection(new[]
{
new Point2D(5.0, 5.0),
new Point2D(15.0, 15.0)
})
};
// Call
IEnumerable <IObservable> affectedObjects = failureMechanismSectionUpdateStrategy.UpdateSectionsWithImportedData(sections, sourcePath);
// Assert
Assert.AreEqual(sourcePath, failureMechanism.FailureMechanismSectionSourcePath);
IEnumerable <FailureMechanismSection> failureMechanismSections = failureMechanism.Sections;
Assert.AreEqual(2, failureMechanismSections.Count());
CollectionAssert.AreEqual(sections, failureMechanismSections);
Assert.AreSame(oldSectionResult, sectionResultUpdateStrategy.Origin);
Assert.AreSame(failureMechanismSectionResults.First(), sectionResultUpdateStrategy.Target);
CollectionAssert.AreEqual(new IObservable[]
{
failureMechanism,
failureMechanism.SectionResults
}, affectedObjects);
}
