public void ClearReferenceLineDependentData_FullyConfiguredFailureMechanism_RemoveFailureMechanismDependentData()
{
// Setup
GrassCoverErosionInwardsFailureMechanism failureMechanism = CreateFullyConfiguredFailureMechanism();
object[] expectedRemovedObjectInstances = failureMechanism.Sections.OfType <object>()
.Concat(failureMechanism.SectionResults)
.Concat(failureMechanism.CalculationsGroup.GetAllChildrenRecursive())
.Concat(failureMechanism.DikeProfiles)
.ToArray();
// Call
ClearResults result = GrassCoverErosionInwardsDataSynchronizationService.ClearReferenceLineDependentData(failureMechanism);
// Assert
CollectionAssert.IsEmpty(failureMechanism.Sections);
CollectionAssert.IsEmpty(failureMechanism.SectionResults);
CollectionAssert.IsEmpty(failureMechanism.CalculationsGroup.Children);
CollectionAssert.IsEmpty(failureMechanism.DikeProfiles);
IObservable[] array = result.ChangedObjects.ToArray();
Assert.AreEqual(4, array.Length);
CollectionAssert.Contains(array, failureMechanism);
CollectionAssert.Contains(array, failureMechanism.SectionResults);
CollectionAssert.Contains(array, failureMechanism.CalculationsGroup);
CollectionAssert.Contains(array, failureMechanism.DikeProfiles);
CollectionAssert.AreEquivalent(expectedRemovedObjectInstances, result.RemovedObjects);
}
public void ClearAllCalculationOutputAndHydraulicBoundaryLocations_WithVariousCalculations_ClearsHydraulicBoundaryLocationAndCalculationsAndReturnsAffectedObjects()
{
// Setup
GrassCoverErosionInwardsFailureMechanism failureMechanism = CreateFullyConfiguredFailureMechanism();
IEnumerable <GrassCoverErosionInwardsCalculation> grassCoverErosionInwardsCalculations =
failureMechanism.Calculations
.Cast <GrassCoverErosionInwardsCalculation>()
.ToArray();
IObservable[] expectedAffectedCalculations = grassCoverErosionInwardsCalculations.Where(c => c.HasOutput)
.Cast <IObservable>()
.ToArray();
IObservable[] expectedAffectedCalculationInputs = grassCoverErosionInwardsCalculations.Select(c => c.InputParameters)
.Where(i => i.HydraulicBoundaryLocation != null)
.Cast <IObservable>()
.ToArray();
// Call
IEnumerable <IObservable> affectedItems =
GrassCoverErosionInwardsDataSynchronizationService.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 <GrassCoverErosionInwardsCalculation>()
.All(c => c.InputParameters.HydraulicBoundaryLocation == null &&
!c.HasOutput));
CollectionAssert.AreEquivalent(expectedAffectedCalculations.Concat(expectedAffectedCalculationInputs),
affectedItems);
}
protected override IEnumerable <IObservable> RemoveObjectAndDependentData(DikeProfile removedObject)
{
return(GrassCoverErosionInwardsDataSynchronizationService.RemoveDikeProfile(
removedObject,
FailureMechanism.Calculations.Cast <GrassCoverErosionInwardsCalculation>(),
FailureMechanism.DikeProfiles));
}
public void ClearAllCalculationOutputAndHydraulicBoundaryLocations_FailureMechanismNull_ThrowsArgumentNullException()
{
// Call
void Call() => GrassCoverErosionInwardsDataSynchronizationService.ClearAllCalculationOutputAndHydraulicBoundaryLocations(null);
// Assert
var exception = Assert.Throws <ArgumentNullException>(Call);
Assert.AreEqual("failureMechanism", exception.ParamName);
}
public void ClearReferenceLineDependentData_FailureMechanismNull_ThrowArgumentNullException()
{
// Call
void Call() => GrassCoverErosionInwardsDataSynchronizationService.ClearReferenceLineDependentData(null);
// Assert
var exception = Assert.Throws <ArgumentNullException>(Call);
Assert.AreEqual("failureMechanism", exception.ParamName);
}
public void ClearIllustrationPoints_CalculationsNull_ThrowsArgumentNullException()
{
// Call
void Call() => GrassCoverErosionInwardsDataSynchronizationService.ClearIllustrationPoints(null);
// Assert
var exception = Assert.Throws <ArgumentNullException>(Call);
Assert.AreEqual("calculations", exception.ParamName);
}
public void RemoveDikeProfile_DikeProfilesNull_ThrowsArgumentNullException()
{
// Call
void Call() => GrassCoverErosionInwardsDataSynchronizationService.RemoveDikeProfile(
DikeProfileTestFactory.CreateDikeProfile(), Enumerable.Empty <GrassCoverErosionInwardsCalculation>(), null);
// Assert
var exception = Assert.Throws <ArgumentNullException>(Call);
Assert.AreEqual("dikeProfiles", exception.ParamName);
}
public void RemoveDikeProfile_CalculationsNull_ThrowsArgumentNullException()
{
// Call
void Call() => GrassCoverErosionInwardsDataSynchronizationService.RemoveDikeProfile(
DikeProfileTestFactory.CreateDikeProfile(), null, new DikeProfileCollection());
// Assert
var exception = Assert.Throws <ArgumentNullException>(Call);
Assert.AreEqual("calculations", exception.ParamName);
}
public void RemoveDikeProfile_DikeProfileToRemove_ThrowsArgumentNullException()
{
// Call
void Call() => GrassCoverErosionInwardsDataSynchronizationService.RemoveDikeProfile(
null, Enumerable.Empty <GrassCoverErosionInwardsCalculation>(), new DikeProfileCollection());
// Assert
var exception = Assert.Throws <ArgumentNullException>(Call);
Assert.AreEqual("dikeProfileToRemove", exception.ParamName);
}
public void RemoveDikeProfile_VariousCalculationConfigurations_ReturnsOnlyAffectedCalculations()
{
// Setup
GrassCoverErosionInwardsFailureMechanism failureMechanism = CreateFullyConfiguredFailureMechanism();
DikeProfile profileToBeCleared = failureMechanism.DikeProfiles[0];
DikeProfile profileToKeep = failureMechanism.DikeProfiles[1];
GrassCoverErosionInwardsCalculation[] affectedCalculationsWithProfile =
failureMechanism.Calculations
.Cast <GrassCoverErosionInwardsCalculation>()
.Where(calc => ReferenceEquals(profileToBeCleared, calc.InputParameters.DikeProfile))
.ToArray();
GrassCoverErosionInwardsCalculation[] affectedCalculationsWithOutput =
affectedCalculationsWithProfile.Where(calc => calc.HasOutput).ToArray();
GrassCoverErosionInwardsCalculation[] unaffectedCalculationsWithProfile =
failureMechanism.Calculations
.Cast <GrassCoverErosionInwardsCalculation>()
.Where(calc => ReferenceEquals(profileToKeep, calc.InputParameters.DikeProfile))
.ToArray();
// Precondition
CollectionAssert.IsNotEmpty(affectedCalculationsWithOutput);
// Call
IEnumerable <IObservable> affectedObjects =
GrassCoverErosionInwardsDataSynchronizationService.RemoveDikeProfile(profileToBeCleared,
failureMechanism.Calculations.Cast <GrassCoverErosionInwardsCalculation>(),
failureMechanism.DikeProfiles);
// Assert
CollectionAssert.DoesNotContain(failureMechanism.DikeProfiles, profileToBeCleared);
Assert.True(affectedCalculationsWithOutput.All(calc => !calc.HasOutput));
Assert.True(unaffectedCalculationsWithProfile.All(calc => calc.InputParameters.DikeProfile != null));
IEnumerable <IObservable> expectedAffectedObjects =
affectedCalculationsWithProfile.Select(calc => calc.InputParameters)
.Cast <IObservable>()
.Concat(affectedCalculationsWithOutput)
.Concat(new IObservable[]
{
failureMechanism.DikeProfiles
});
CollectionAssert.AreEquivalent(expectedAffectedObjects, affectedObjects);
}
public void ClearAllCalculationOutput_WithVariousCalculations_ClearsCalculationsOutputAndReturnsAffectedCalculations()
{
// Setup
GrassCoverErosionInwardsFailureMechanism failureMechanism = CreateFullyConfiguredFailureMechanism();
ICalculation[] expectedAffectedCalculations = failureMechanism.Calculations
.Where(c => c.HasOutput)
.ToArray();
// Call
IEnumerable <IObservable> affectedItems = GrassCoverErosionInwardsDataSynchronizationService.ClearAllCalculationOutput(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.All(c => !c.HasOutput));
CollectionAssert.AreEquivalent(expectedAffectedCalculations, affectedItems);
}
public void RemoveAllDikeProfiles_FullyConfiguredFailureMechanism_RemovesAllDikeProfilesAndDependentData()
{
// Setup
GrassCoverErosionInwardsFailureMechanism failureMechanism = CreateFullyConfiguredFailureMechanism();
GrassCoverErosionInwardsCalculation[] calculationsWithDikeProfiles =
failureMechanism.Calculations
.Cast <GrassCoverErosionInwardsCalculation>()
.Where(calc => calc.InputParameters.DikeProfile != null)
.ToArray();
GrassCoverErosionInwardsCalculation[] calculationsWithDikeProfilesAndOutput =
calculationsWithDikeProfiles.Where(calc => calc.HasOutput).ToArray();
// Precondition
CollectionAssert.IsNotEmpty(calculationsWithDikeProfiles);
// Call
IEnumerable <IObservable> affectedObjects =
GrassCoverErosionInwardsDataSynchronizationService.RemoveAllDikeProfiles(
failureMechanism.Calculations.Cast <GrassCoverErosionInwardsCalculation>(),
failureMechanism.DikeProfiles);
// 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.DikeProfiles);
foreach (GrassCoverErosionInwardsCalculation calculation in calculationsWithDikeProfilesAndOutput)
{
Assert.IsFalse(calculation.HasOutput);
}
IEnumerable <IObservable> expectedAffectedObjects =
calculationsWithDikeProfiles.Select(calc => calc.InputParameters)
.Cast <IObservable>()
.Concat(calculationsWithDikeProfilesAndOutput)
.Concat(new IObservable[]
{
failureMechanism.DikeProfiles
});
CollectionAssert.AreEquivalent(expectedAffectedObjects, affectedObjects);
}
public override IEnumerable <IObservable> ClearIllustrationPoints()
{
return(GrassCoverErosionInwardsDataSynchronizationService.ClearIllustrationPoints(calculations));
}
protected override IEnumerable <IObservable> ClearData()
{
return(GrassCoverErosionInwardsDataSynchronizationService.RemoveAllDikeProfiles(
FailureMechanism.Calculations.Cast <GrassCoverErosionInwardsCalculation>(),
FailureMechanism.DikeProfiles));
}
public void ClearIllustrationPoints_CalculationsWithAndWithoutIllustrationPoints_ReturnsAffectedObjects()
{
// Setup
var random = new Random(21);
var overtoppingOutputWithIllustrationPoints = new GrassCoverErosionInwardsOutput(new TestOvertoppingOutput(new TestGeneralResultFaultTreeIllustrationPoint()),
null,
null);
var calculationWithOverToppingOutputWithIllustrationPoints = new GrassCoverErosionInwardsCalculation
{
Output = overtoppingOutputWithIllustrationPoints
};
var dikeHeightOutputWithIllustrationPoints = new GrassCoverErosionInwardsOutput(new TestOvertoppingOutput(random.NextDouble()),
new TestDikeHeightOutput(new TestGeneralResultFaultTreeIllustrationPoint()),
null);
var calculationWithDikeHeightWithIllustrationPoints = new GrassCoverErosionInwardsCalculation
{
Output = dikeHeightOutputWithIllustrationPoints
};
var overtoppingRateOutputWithIllustrationPoints = new GrassCoverErosionInwardsOutput(new TestOvertoppingOutput(random.NextDouble()),
null,
new TestOvertoppingRateOutput(new TestGeneralResultFaultTreeIllustrationPoint()));
var calculationWithOvertoppingRateWithIllustrationPoints = new GrassCoverErosionInwardsCalculation
{
Output = overtoppingRateOutputWithIllustrationPoints
};
var outputWithNoIllustrationPoints = new GrassCoverErosionInwardsOutput(new TestOvertoppingOutput(random.NextDouble()),
null,
null);
var calculationWitNoIllustrationPoints = new GrassCoverErosionInwardsCalculation
{
Output = outputWithNoIllustrationPoints
};
GrassCoverErosionInwardsCalculation[] calculations =
{
calculationWitNoIllustrationPoints,
calculationWithOverToppingOutputWithIllustrationPoints,
calculationWithOvertoppingRateWithIllustrationPoints,
calculationWithDikeHeightWithIllustrationPoints,
new GrassCoverErosionInwardsCalculation()
};
// Call
IEnumerable <IObservable> affectedObjects = GrassCoverErosionInwardsDataSynchronizationService.ClearIllustrationPoints(calculations);
// Assert
CollectionAssert.AreEquivalent(new[]
{
calculationWithOverToppingOutputWithIllustrationPoints,
calculationWithOvertoppingRateWithIllustrationPoints,
calculationWithDikeHeightWithIllustrationPoints
}, affectedObjects);
GrassCoverErosionInwardsCalculation[] calculationsWithOutput =
{
calculationWitNoIllustrationPoints,
calculationWithOverToppingOutputWithIllustrationPoints,
calculationWithOvertoppingRateWithIllustrationPoints,
calculationWithDikeHeightWithIllustrationPoints
};
Assert.IsTrue(calculationsWithOutput.All(calc => calc.HasOutput));
Assert.IsTrue(calculationsWithOutput.All(calc =>
{
GrassCoverErosionInwardsOutput output = calc.Output;
return(!output.OvertoppingOutput.HasGeneralResult &&
output.DikeHeightOutput?.GeneralResult == null &&
output.OvertoppingRateOutput?.GeneralResult == null);
}));
}
