public void CanDrop_DraggedDataPartOfGroupContext_ReturnsTrue()
{
// Setup
using (var plugin = new DuneErosionPlugin())
{
TreeNodeInfo info = GetInfo(plugin);
var assessmentSectionStub = new AssessmentSectionStub();
var failureMechanism = new DuneErosionFailureMechanism();
var calculationsForTargetProbability = new DuneLocationCalculationsForTargetProbability(0.1);
var targetData = new DuneLocationCalculationsForUserDefinedTargetProbabilitiesGroupContext(
new ObservableList <DuneLocationCalculationsForTargetProbability>
{
calculationsForTargetProbability
},
failureMechanism,
assessmentSectionStub);
var draggedData = new DuneLocationCalculationsForUserDefinedTargetProbabilityContext(
calculationsForTargetProbability,
failureMechanism,
assessmentSectionStub);
// Call
bool canDrop = info.CanDrop(draggedData, targetData);
// Assert
Assert.IsTrue(canDrop);
}
}
public void CreateCalculationActivitiesForCalculationGroup_WithValidCalculations_ReturnsWaveImpactAsphaltCoverWaveConditionsCalculationActivitiesWithParametersSet()
{
// Setup
WaveImpactAsphaltCoverFailureMechanism failureMechanism = new WaveImpactAsphaltCoverFailureMechanism();
AssessmentSectionStub assessmentSection = CreateAssessmentSection();
var hydraulicBoundaryLocation = new TestHydraulicBoundaryLocation();
SetHydraulicBoundaryLocationToAssessmentSection(assessmentSection, hydraulicBoundaryLocation);
WaveImpactAsphaltCoverWaveConditionsCalculation calculation1 = CreateValidCalculation(hydraulicBoundaryLocation);
WaveImpactAsphaltCoverWaveConditionsCalculation calculation2 = CreateValidCalculation(hydraulicBoundaryLocation);
var calculations = new CalculationGroup
{
Children =
{
calculation1,
calculation2
}
};
// Call
IEnumerable <CalculatableActivity> activities = WaveImpactAsphaltCoverWaveConditionsCalculationActivityFactory.CreateCalculationActivities(
calculations, failureMechanism, assessmentSection);
// Assert
CollectionAssert.AllItemsAreInstancesOfType(activities, typeof(WaveImpactAsphaltCoverWaveConditionsCalculationActivity));
Assert.AreEqual(2, activities.Count());
RoundedDouble assessmentLevel = assessmentSection.WaterLevelCalculationsForSignalFloodingProbability.Single().Output.Result;
HydraulicBoundaryDatabase hydraulicBoundaryDatabase = assessmentSection.HydraulicBoundaryDatabase;
AssertWaveImpactAsphaltCoverWaveConditionsCalculationActivity(activities.First(), calculation1, assessmentLevel, hydraulicBoundaryDatabase);
AssertWaveImpactAsphaltCoverWaveConditionsCalculationActivity(activities.ElementAt(1), calculation2, assessmentLevel, hydraulicBoundaryDatabase);
}
private static IEnumerable <TestCaseData> GetAssessmentSectionConfigurations()
{
var assessmentSectionWithTargetProbabilities = new AssessmentSectionStub();
assessmentSectionWithTargetProbabilities.SetHydraulicBoundaryLocationCalculations(new[]
{
new HydraulicBoundaryLocation(123, "aName", 1.1, 2.2)
});
yield return(new TestCaseData(assessmentSectionWithTargetProbabilities, new[]
{
"Waterstanden bij vaste doelkans/Waterstanden_30000.shp",
"Waterstanden bij vaste doelkans/Waterstanden_30000 (1).shp",
"Waterstanden bij vrije doelkans/Waterstanden_10000.shp",
"Waterstanden bij vrije doelkans/Waterstanden_100000.shp",
"Golfhoogten bij vrije doelkans/Golfhoogten_4000.shp",
"Golfhoogten bij vrije doelkans/Golfhoogten_40000.shp"
}).SetName("With UserDefinedTargetProbabilities"));
var assessmentSectionWithoutTargetProbabilities = new AssessmentSectionStub();
assessmentSectionWithoutTargetProbabilities.SetHydraulicBoundaryLocationCalculations(new[]
{
new HydraulicBoundaryLocation(123, "aName", 1.1, 2.2)
});
assessmentSectionWithoutTargetProbabilities.WaterLevelCalculationsForUserDefinedTargetProbabilities.Clear();
assessmentSectionWithoutTargetProbabilities.WaveHeightCalculationsForUserDefinedTargetProbabilities.Clear();
yield return(new TestCaseData(assessmentSectionWithoutTargetProbabilities, new[]
{
"Waterstanden bij vaste doelkans/Waterstanden_30000.shp",
"Waterstanden bij vaste doelkans/Waterstanden_30000 (1).shp"
}).SetName("Without UserDefinedTargetProbabilities"));
}
public void AssembleFailureMechanism_CalculatorThrowsException_ThrowsAssemblyException()
{
// Setup
var failureMechanism = new ClosingStructuresFailureMechanism
{
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() => ClosingStructuresFailureMechanismAssemblyFactory.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 GetViewName_WithContext_ReturnsExpectedViewName(double userDefinedTargetProbability1,
double userDefinedTargetProbability2,
double userDefinedTargetProbability3,
string expectedProbabilityText)
{
// Setup
var calculationsForTargetProbability = new HydraulicBoundaryLocationCalculationsForTargetProbability(userDefinedTargetProbability2);
var assessmentSection = new AssessmentSectionStub
{
WaterLevelCalculationsForUserDefinedTargetProbabilities =
{
new HydraulicBoundaryLocationCalculationsForTargetProbability(userDefinedTargetProbability1),
new HydraulicBoundaryLocationCalculationsForTargetProbability(userDefinedTargetProbability3),
calculationsForTargetProbability
}
};
var context = new WaterLevelCalculationsForUserDefinedTargetProbabilityContext(calculationsForTargetProbability,
assessmentSection);
using (var plugin = new RiskeerPlugin())
{
ViewInfo info = GetViewInfo(plugin);
// Call
string viewName = info.GetViewName(null, context);
// Assert
Assert.AreEqual($"Waterstanden bij vrije doelkans - {expectedProbabilityText}", viewName);
}
}
public void GetAssessmentLevel_ValidInputWithHydraulicBoundaryLocation_ReturnsExpectedValue(
WaveConditionsInputWaterLevelType waterLevelType,
Func <WaveConditionsInput, IAssessmentSection, double> getExpectedAssessmentLevel)
{
// Setup
var assessmentSection = new AssessmentSectionStub();
var hydraulicBoundaryLocation = new TestHydraulicBoundaryLocation();
assessmentSection.SetHydraulicBoundaryLocationCalculations(new[]
{
hydraulicBoundaryLocation
}, true);
var input = new WaveConditionsInput
{
HydraulicBoundaryLocation = hydraulicBoundaryLocation,
WaterLevelType = waterLevelType,
CalculationsTargetProbability = assessmentSection.WaterLevelCalculationsForUserDefinedTargetProbabilities.First()
};
// Call
double assessmentLevel = WaveConditionsInputHelper.GetAssessmentLevel(input, assessmentSection);
// Assert
Assert.AreEqual(getExpectedAssessmentLevel(input, assessmentSection), assessmentLevel);
}
public void AssembleSection_CalculatorThrowsException_ThrowsAssemblyException()
{
// Setup
var failureMechanism = new TestCalculatableFailureMechanism();
FailureMechanismSection section = FailureMechanismSectionTestFactory.CreateFailureMechanismSection();
var sectionResult = new AdoptableFailureMechanismSectionResult(section);
var assessmentSection = new AssessmentSectionStub();
using (new AssemblyToolCalculatorFactoryConfig())
{
var calculatorFactory = (TestAssemblyToolCalculatorFactory)AssemblyToolCalculatorFactory.Instance;
FailureMechanismSectionAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator;
calculator.ThrowExceptionOnCalculate = true;
// Call
void Call() => StructuresFailureMechanismAssemblyFactory.AssembleSection <TestStructuresInput>(
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 AssembleSection_CalculatorThrowsException_ThrowsAssemblyException()
{
// Setup
var failureMechanism = new GrassCoverErosionInwardsFailureMechanism();
failureMechanism.SetSections(new[]
{
FailureMechanismSectionTestFactory.CreateFailureMechanismSection()
}, "APath");
AdoptableWithProfileProbabilityFailureMechanismSectionResult sectionResult = failureMechanism.SectionResults.Single();
var assessmentSection = new AssessmentSectionStub();
using (new AssemblyToolCalculatorFactoryConfig())
{
var calculatorFactory = (TestAssemblyToolCalculatorFactory)AssemblyToolCalculatorFactory.Instance;
FailureMechanismSectionAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator;
calculator.ThrowExceptionOnCalculate = true;
// Call
void Call() => GrassCoverErosionInwardsFailureMechanismAssemblyFactory.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 AssembleSectionAdoptableWithProfileProbability_WithInputAndUseLengthEffectFalse_SetsInputOnCalculator(
AdoptableInitialFailureMechanismResultType initialFailureMechanismResultType, bool expectedHasProbabilitySpecified)
{
// Setup
var random = new Random(21);
bool isRelevant = random.NextBoolean();
double manualInitialSectionProbability = random.NextDouble();
double calculateStrategySectionProbability = random.NextDouble();
var furtherAnalysisType = random.NextEnumValue <FailureMechanismSectionResultFurtherAnalysisType>();
double refinedSectionProbability = random.NextDouble();
var mocks = new MockRepository();
var calculateStrategy = mocks.StrictMock <IFailureMechanismSectionResultCalculateProbabilityStrategy>();
bool isInitialFailureMechanismResultTypeAdopt = IsInitialFailureMechanismResultTypeAdopt(initialFailureMechanismResultType);
if (isInitialFailureMechanismResultTypeAdopt)
{
calculateStrategy.Expect(cs => cs.CalculateSectionProbability())
.Return(calculateStrategySectionProbability);
}
mocks.ReplayAll();
var assessmentSection = new AssessmentSectionStub();
var sectionResult = new AdoptableWithProfileProbabilityFailureMechanismSectionResult(FailureMechanismSectionTestFactory.CreateFailureMechanismSection())
{
IsRelevant = isRelevant,
InitialFailureMechanismResultType = initialFailureMechanismResultType,
ManualInitialFailureMechanismResultSectionProbability = manualInitialSectionProbability,
FurtherAnalysisType = furtherAnalysisType,
RefinedSectionProbability = refinedSectionProbability
};
using (new AssemblyToolCalculatorFactoryConfig())
{
var calculatorFactory = (TestAssemblyToolCalculatorFactory)AssemblyToolCalculatorFactory.Instance;
FailureMechanismSectionAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator;
// Call
FailureMechanismSectionAssemblyResultFactory.AssembleSection(
sectionResult, assessmentSection, calculateStrategy, false, random.NextDouble());
// Assert
FailureMechanismSectionAssemblyInput calculatorInput = calculator.FailureMechanismSectionAssemblyInput;
FailureMechanismContribution failureMechanismContribution = assessmentSection.FailureMechanismContribution;
Assert.AreEqual(failureMechanismContribution.SignalFloodingProbability, calculatorInput.SignalFloodingProbability);
Assert.AreEqual(failureMechanismContribution.MaximumAllowableFloodingProbability, calculatorInput.MaximumAllowableFloodingProbability);
Assert.AreEqual(isRelevant, calculatorInput.IsRelevant);
Assert.AreEqual(expectedHasProbabilitySpecified, calculatorInput.HasProbabilitySpecified);
double expectedInitialSectionProbability = isInitialFailureMechanismResultTypeAdopt
? calculateStrategySectionProbability
: manualInitialSectionProbability;
Assert.AreEqual(expectedInitialSectionProbability, calculatorInput.InitialSectionProbability);
Assert.AreEqual(furtherAnalysisType, calculatorInput.FurtherAnalysisType);
Assert.AreEqual(refinedSectionProbability, calculatorInput.RefinedSectionProbability);
}
}
public void ChildNodeObjects_Always_ReturnsChildrenOfData()
{
// Setup
var assessmentSection = new AssessmentSectionStub();
var calculationsForTargetProbabilities = new ObservableList <HydraulicBoundaryLocationCalculationsForTargetProbability>
{
new HydraulicBoundaryLocationCalculationsForTargetProbability(0.1),
new HydraulicBoundaryLocationCalculationsForTargetProbability(0.01)
};
var calculationsGroupContext = new WaveHeightCalculationsForUserDefinedTargetProbabilitiesGroupContext(calculationsForTargetProbabilities, assessmentSection);
using (var plugin = new RiskeerPlugin())
{
TreeNodeInfo info = GetInfo(plugin);
// Call
object[] childNodeObjects = info.ChildNodeObjects(calculationsGroupContext);
// Assert
Assert.AreEqual(2, childNodeObjects.Length);
WaveHeightCalculationsForUserDefinedTargetProbabilityContext[] calculationsContexts = childNodeObjects.OfType <WaveHeightCalculationsForUserDefinedTargetProbabilityContext>().ToArray();
Assert.AreEqual(2, calculationsContexts.Length);
Assert.AreSame(calculationsForTargetProbabilities[0], calculationsContexts[0].WrappedData);
Assert.AreSame(assessmentSection, calculationsContexts[0].AssessmentSection);
Assert.AreSame(calculationsForTargetProbabilities[1], calculationsContexts[1].WrappedData);
Assert.AreSame(assessmentSection, calculationsContexts[1].AssessmentSection);
}
}
public void CanDrop_DraggedDataPartOfGroupContext_ReturnsTrue()
{
// Setup
using (var plugin = new RiskeerPlugin())
{
TreeNodeInfo info = GetInfo(plugin);
var assessmentSectionStub = new AssessmentSectionStub();
var calculationsForTargetProbability = new HydraulicBoundaryLocationCalculationsForTargetProbability(0.1);
var targetData = new WaveHeightCalculationsForUserDefinedTargetProbabilitiesGroupContext(
new ObservableList <HydraulicBoundaryLocationCalculationsForTargetProbability>
{
calculationsForTargetProbability
},
assessmentSectionStub);
var draggedData = new WaveHeightCalculationsForUserDefinedTargetProbabilityContext(
calculationsForTargetProbability,
assessmentSectionStub);
// Call
bool canDrop = info.CanDrop(draggedData, targetData);
// Assert
Assert.IsTrue(canDrop);
}
}
public void GetViewName_WithContext_ReturnsExpectedViewName(
Func <IAssessmentSection, IObservableEnumerable <HydraulicBoundaryLocationCalculation> > getCalculationsFunc,
double maximumAllowableFloodingProbability, double signalFloodingProbability, string expectedProbabilityText)
{
// Setup
var assessmentSection = new AssessmentSectionStub
{
FailureMechanismContribution =
{
MaximumAllowableFloodingProbability = maximumAllowableFloodingProbability,
SignalFloodingProbability = signalFloodingProbability
}
};
var context = new WaterLevelCalculationsForNormTargetProbabilityContext(getCalculationsFunc(assessmentSection),
assessmentSection,
() => 0.01);
using (var plugin = new RiskeerPlugin())
{
ViewInfo info = GetViewInfo(plugin);
// Call
string viewName = info.GetViewName(null, context);
// Assert
Assert.AreEqual($"Waterstanden bij vaste doelkans - {expectedProbabilityText}", viewName);
}
}
public void GivenContextWithObserverAttached_WhenNotifyingObserversOfDuneLocationCalculationsForUserDefinedTargetProbability_ThenObserverCorrectlyNotified()
{
// Given
var mockRepository = new MockRepository();
var observer = mockRepository.StrictMock <IObserver>();
observer.Expect(o => o.UpdateObserver());
mockRepository.ReplayAll();
var assessmentSection = new AssessmentSectionStub();
var failureMechanism = new DuneErosionFailureMechanism();
var calculationsForTargetProbability = new DuneLocationCalculationsForTargetProbability(0.1);
failureMechanism.DuneLocationCalculationsForUserDefinedTargetProbabilities.Add(calculationsForTargetProbability);
var context = new DuneLocationCalculationsForUserDefinedTargetProbabilityContext(calculationsForTargetProbability,
failureMechanism,
assessmentSection);
context.Attach(observer);
// When
failureMechanism.DuneLocationCalculationsForUserDefinedTargetProbabilities.First().NotifyObservers();
// Then
mockRepository.VerifyAll();
}
private IAssessmentSection CreateAssessmentSectionWithHydraulicBoundaryOutput()
{
var hydraulicBoundaryLocation = new HydraulicBoundaryLocation(1300001, string.Empty, 0, 0);
var assessmentSection = new AssessmentSectionStub
{
HydraulicBoundaryDatabase =
{
FilePath = validFilePath,
Locations =
{
hydraulicBoundaryLocation
}
}
};
HydraulicBoundaryDatabaseTestHelper.SetHydraulicBoundaryLocationConfigurationSettings(assessmentSection.HydraulicBoundaryDatabase);
assessmentSection.SetHydraulicBoundaryLocationCalculations(new[]
{
hydraulicBoundaryLocation
});
assessmentSection.WaterLevelCalculationsForMaximumAllowableFloodingProbability.First().Output = new TestHydraulicBoundaryLocationCalculationOutput(9.3);
return(assessmentSection);
}
public void FailureMechanismResultsView_AllDataSet_SetsCorrectInputOnCalculator()
{
// Setup
FailureMechanismSection section = FailureMechanismSectionTestFactory.CreateFailureMechanismSection();
var failureMechanism = new GrassCoverErosionInwardsFailureMechanism();
FailureMechanismTestHelper.SetSections(failureMechanism, new[]
{
section
});
var assessmentSection = new AssessmentSectionStub();
// Call
using (new AssemblyToolCalculatorFactoryConfig())
using (ShowFailureMechanismResultsView(failureMechanism, assessmentSection))
{
// Assert
var testFactory = (TestAssemblyToolCalculatorFactory)AssemblyToolCalculatorFactory.Instance;
FailureMechanismAssemblyCalculatorStub calculator = testFactory.LastCreatedFailureMechanismAssemblyCalculator;
Assert.AreEqual(failureMechanism.GeneralInput.N, calculator.FailureMechanismN);
}
}
public void AssembleSectionAdoptableSectionWithProfileProbability_CalculatorRan_ReturnsExpectedOutput()
{
// Setup
var random = new Random(21);
var mocks = new MockRepository();
var calculateStrategy = mocks.Stub <IFailureMechanismSectionResultCalculateProbabilityStrategy>();
mocks.ReplayAll();
var assessmentSection = new AssessmentSectionStub();
var sectionResult = new AdoptableWithProfileProbabilityFailureMechanismSectionResult(FailureMechanismSectionTestFactory.CreateFailureMechanismSection());
using (new AssemblyToolCalculatorFactoryConfig())
{
var calculatorFactory = (TestAssemblyToolCalculatorFactory)AssemblyToolCalculatorFactory.Instance;
FailureMechanismSectionAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator;
// Call
FailureMechanismSectionAssemblyResultWrapper result = FailureMechanismSectionAssemblyResultFactory.AssembleSection(
sectionResult, assessmentSection, calculateStrategy, random.NextBoolean(), random.NextDouble());
// Assert
Assert.AreSame(calculator.FailureMechanismSectionAssemblyResultOutput, result);
}
}
public void Cancel_WhenPerformingCalculation_CurrentCalculationForWaterLevelCompletesAndSubsequentCalculationsDidNotRun()
{
// Setup
AssessmentSectionStub assessmentSection = CreateAssessmentSection();
ConfigureAssessmentSectionWithHydraulicBoundaryOutput(assessmentSection);
GrassCoverErosionOutwardsWaveConditionsCalculation calculation = CreateValidCalculation(assessmentSection.HydraulicBoundaryDatabase.Locations.First());
var failureMechanism = new GrassCoverErosionOutwardsFailureMechanism();
CalculatableActivity activity = GrassCoverErosionOutwardsCalculationActivityFactory.CreateWaveConditionsCalculationActivity(calculation,
failureMechanism,
assessmentSection);
var mockRepository = new MockRepository();
var calculatorFactory = mockRepository.StrictMock <IHydraRingCalculatorFactory>();
calculatorFactory.Expect(cf => cf.CreateWaveConditionsCosineCalculator(null))
.IgnoreArguments()
.Return(new TestWaveConditionsCosineCalculator());
mockRepository.ReplayAll();
using (new HydraRingCalculatorFactoryConfig(calculatorFactory))
{
activity.ProgressChanged += (sender, args) =>
{
if (activity.State != ActivityState.Canceled)
{
// Call
activity.Cancel();
}
};
// Assert
TestHelper.AssertLogMessages(() => activity.Run(), messages =>
{
string[] msgs = messages.ToArray();
RoundedDouble firstWaterLevel = GetWaterLevels(calculation, assessmentSection).First();
Assert.AreEqual(10, msgs.Length);
Assert.AreEqual($"Golfcondities berekenen voor '{calculation.Name}' is gestart.", msgs[0]);
CalculationServiceTestHelper.AssertValidationStartMessage(msgs[1]);
CalculationServiceTestHelper.AssertValidationEndMessage(msgs[2]);
CalculationServiceTestHelper.AssertCalculationStartMessage(msgs[3]);
Assert.AreEqual("Berekening voor golfoploop is gestart.", msgs[4]);
Assert.AreEqual($"Berekening voor waterstand '{firstWaterLevel}' is gestart.", msgs[5]);
StringAssert.StartsWith("Golfcondities berekening is uitgevoerd op de tijdelijke locatie", msgs[6]);
Assert.AreEqual($"Berekening voor waterstand '{firstWaterLevel}' is beëindigd.", msgs[7]);
Assert.AreEqual("Berekening voor golfoploop is beëindigd.", msgs[8]);
CalculationServiceTestHelper.AssertCalculationEndMessage(msgs[9]);
});
Assert.AreEqual(ActivityState.Canceled, activity.State);
Assert.IsNull(calculation.Output);
}
mockRepository.VerifyAll();
}
public void AssembleSectionAdoptableSectionWithProfileProbability_CalculatorThrowsException_ThrowsAssemblyException()
{
// Setup
var random = new Random(21);
var mocks = new MockRepository();
var calculateStrategy = mocks.Stub <IFailureMechanismSectionResultCalculateProbabilityStrategy>();
mocks.ReplayAll();
var assessmentSection = new AssessmentSectionStub();
var sectionResult = new AdoptableWithProfileProbabilityFailureMechanismSectionResult(FailureMechanismSectionTestFactory.CreateFailureMechanismSection());
using (new AssemblyToolCalculatorFactoryConfig())
{
var calculatorFactory = (TestAssemblyToolCalculatorFactory)AssemblyToolCalculatorFactory.Instance;
FailureMechanismSectionAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator;
calculator.ThrowExceptionOnCalculate = true;
// Call
void Call() => FailureMechanismSectionAssemblyResultFactory.AssembleSection(
sectionResult, assessmentSection, calculateStrategy, random.NextBoolean(), random.NextDouble());
// Assert
var exception = Assert.Throws <AssemblyException>(Call);
Exception innerException = exception.InnerException;
Assert.IsInstanceOf <FailureMechanismSectionAssemblyCalculatorException>(innerException);
Assert.AreEqual(innerException.Message, exception.Message);
}
}
public void FailureMechanismResultsView_AllDataSet_SetsCorrectInputOnCalculator()
{
// Setup
FailureMechanismSection section = FailureMechanismSectionTestFactory.CreateFailureMechanismSection();
var failureMechanism = new MacroStabilityInwardsFailureMechanism();
FailureMechanismTestHelper.SetSections(failureMechanism, new[]
{
section
});
var assessmentSection = new AssessmentSectionStub();
// Call
using (new AssemblyToolCalculatorFactoryConfig())
using (ShowFailureMechanismResultsView(failureMechanism, assessmentSection))
{
// Assert
var testFactory = (TestAssemblyToolCalculatorFactory)AssemblyToolCalculatorFactory.Instance;
FailureMechanismAssemblyCalculatorStub calculator = testFactory.LastCreatedFailureMechanismAssemblyCalculator;
double expectedN = failureMechanism.MacroStabilityInwardsProbabilityAssessmentInput.GetN(assessmentSection.ReferenceLine.Length);
Assert.AreEqual(expectedN, calculator.FailureMechanismN);
}
}
public void AssembleFailureMechanism_WithInput_SetsInputOnCalculator()
{
// Setup
var failureMechanism = new MacroStabilityInwardsFailureMechanism
{
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
MacroStabilityInwardsFailureMechanismAssemblyFactory.AssembleFailureMechanism(failureMechanism, assessmentSection);
// Assert
double expectedN = failureMechanism.MacroStabilityInwardsProbabilityAssessmentInput.GetN(assessmentSection.ReferenceLine.Length);
Assert.AreEqual(expectedN, failureMechanismAssemblyCalculator.FailureMechanismN);
Assert.AreSame(calculator.FailureMechanismSectionAssemblyResultOutput.AssemblyResult, failureMechanismAssemblyCalculator.SectionAssemblyResultsInput.Single());
Assert.AreEqual(failureMechanism.GeneralInput.ApplyLengthEffectInSection, failureMechanismAssemblyCalculator.ApplyLengthEffect);
}
}
public void AssembleFailureMechanism_CalculatorRan_ReturnsExpectedOutput()
{
// Setup
var failureMechanism = new ClosingStructuresFailureMechanism
{
AssemblyResult =
{
ProbabilityResultType = FailureMechanismAssemblyProbabilityResultType.Automatic
}
};
var assessmentSection = new AssessmentSectionStub();
using (new AssemblyToolCalculatorFactoryConfig())
{
var calculatorFactory = (TestAssemblyToolCalculatorFactory)AssemblyToolCalculatorFactory.Instance;
FailureMechanismAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedFailureMechanismAssemblyCalculator;
// Call
FailureMechanismAssemblyResultWrapper result = ClosingStructuresFailureMechanismAssemblyFactory.AssembleFailureMechanism(failureMechanism, assessmentSection);
// Assert
Assert.AreSame(calculator.AssemblyResultOutput, result);
}
}
public void Constructor_AssemblyRan_InputCorrectlySetOnCalculator()
{
// Setup
var mocks = new MockRepository();
var errorProvider = mocks.Stub <IFailureMechanismSectionResultRowErrorProvider>();
mocks.ReplayAll();
var assessmentSection = new AssessmentSectionStub();
FailureMechanismSection section = FailureMechanismSectionTestFactory.CreateFailureMechanismSection();
var result = new NonAdoptableFailureMechanismSectionResult(section);
using (new AssemblyToolCalculatorFactoryConfig())
{
var calculatorFactory = (TestAssemblyToolCalculatorFactory)AssemblyToolCalculatorFactory.Instance;
FailureMechanismSectionAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator;
// Call
var row = new NonAdoptableFailureMechanismSectionResultRow(result, errorProvider, assessmentSection, ConstructionProperties);
// Assert
FailureMechanismSectionAssemblyInput input = calculator.FailureMechanismSectionAssemblyInput;
Assert.AreEqual(assessmentSection.FailureMechanismContribution.SignalFloodingProbability, input.SignalFloodingProbability);
Assert.AreEqual(assessmentSection.FailureMechanismContribution.MaximumAllowableFloodingProbability, input.MaximumAllowableFloodingProbability);
Assert.AreEqual(row.IsRelevant, input.IsRelevant);
Assert.IsTrue(input.HasProbabilitySpecified);
Assert.AreEqual(row.InitialFailureMechanismResultSectionProbability, input.InitialSectionProbability);
Assert.AreEqual(row.FurtherAnalysisType, input.FurtherAnalysisType);
Assert.AreEqual(row.RefinedSectionProbability, input.RefinedSectionProbability);
}
mocks.VerifyAll();
}
public void AssembleFailureMechanism_WithInput_SetsInputOnCalculator()
{
// Setup
var failureMechanism = new ClosingStructuresFailureMechanism
{
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
ClosingStructuresFailureMechanismAssemblyFactory.AssembleFailureMechanism(failureMechanism, assessmentSection);
// Assert
double expectedN = failureMechanism.GeneralInput.N;
Assert.AreEqual(expectedN, failureMechanismAssemblyCalculator.FailureMechanismN);
Assert.AreSame(calculator.FailureMechanismSectionAssemblyResultOutput.AssemblyResult, failureMechanismAssemblyCalculator.SectionAssemblyResultsInput.Single());
}
}
private static WaveHeightCalculationsView ShowFullyConfiguredWaveHeightCalculationsView(IObservableEnumerable <HydraulicBoundaryLocationCalculation> calculations,
Form form)
{
var assessmentSection = new AssessmentSectionStub();
return(ShowWaveHeightCalculationsView(calculations, assessmentSection, 0.01, "1/100", form));
}
private static IEnumerable <TestCaseData> GetUnequalTestCases()
{
yield return(new TestCaseData(new SelectableTargetProbability(assessmentSection,
assessmentSection.WaterLevelCalculationsForSignalFloodingProbability,
WaveConditionsInputWaterLevelType.SignalFloodingProbability,
0.01)));
yield return(new TestCaseData(new SelectableTargetProbability(assessmentSection,
assessmentSection.WaterLevelCalculationsForSignalFloodingProbability,
WaveConditionsInputWaterLevelType.MaximumAllowableFloodingProbability,
0.1)));
yield return(new TestCaseData(new SelectableTargetProbability(assessmentSection,
assessmentSection.WaterLevelCalculationsForMaximumAllowableFloodingProbability,
WaveConditionsInputWaterLevelType.SignalFloodingProbability,
0.1)));
var otherAssessmentSection = new AssessmentSectionStub();
yield return(new TestCaseData(new SelectableTargetProbability(otherAssessmentSection,
assessmentSection.WaterLevelCalculationsForSignalFloodingProbability,
WaveConditionsInputWaterLevelType.SignalFloodingProbability,
0.1))
.SetName("differentAssessmentSection"));
}
public void ChildNodeObjects_WithContext_ReturnChildDataNodes()
{
// Setup
var assessmentSection = new AssessmentSectionStub();
var failureMechanism = new GrassCoverErosionOutwardsFailureMechanism();
var context = new GrassCoverErosionOutwardsFailureMechanismContext(failureMechanism, assessmentSection);
// Call
object[] children = info.ChildNodeObjects(context).ToArray();
// Assert
Assert.AreEqual(2, children.Length);
var inputsFolder = (CategoryTreeFolder)children[0];
Assert.AreEqual("Invoer", inputsFolder.Name);
Assert.AreEqual(TreeFolderCategory.Input, inputsFolder.Category);
Assert.AreEqual(2, inputsFolder.Contents.Count());
var foreshoreProfilesContext = (ForeshoreProfilesContext)inputsFolder.Contents.ElementAt(0);
Assert.AreSame(failureMechanism.ForeshoreProfiles, foreshoreProfilesContext.WrappedData);
Assert.AreSame(failureMechanism, foreshoreProfilesContext.ParentFailureMechanism);
Assert.AreSame(assessmentSection, foreshoreProfilesContext.ParentAssessmentSection);
var calculationsInputComments = (Comment)inputsFolder.Contents.ElementAt(1);
Assert.AreSame(failureMechanism.CalculationsInputComments, calculationsInputComments);
var calculationGroupContext = (GrassCoverErosionOutwardsCalculationGroupContext)children[1];
Assert.AreSame(failureMechanism.CalculationsGroup, calculationGroupContext.WrappedData);
Assert.IsNull(calculationGroupContext.Parent);
Assert.AreSame(failureMechanism, calculationGroupContext.FailureMechanism);
Assert.AreSame(assessmentSection, calculationGroupContext.AssessmentSection);
}
public void CreateCalculationActivitiesForFailureMechanism_WithValidData_ExpectedInputSetToActivities()
{
// Setup
AssessmentSectionStub assessmentSection = CreateAssessmentSection();
WaveImpactAsphaltCoverFailureMechanism failureMechanism = new WaveImpactAsphaltCoverFailureMechanism();
var hydraulicBoundaryLocation = new TestHydraulicBoundaryLocation("locationName 1");
SetHydraulicBoundaryLocationToAssessmentSection(assessmentSection, hydraulicBoundaryLocation);
WaveImpactAsphaltCoverWaveConditionsCalculation calculation1 = CreateValidCalculation(hydraulicBoundaryLocation);
WaveImpactAsphaltCoverWaveConditionsCalculation calculation2 = CreateValidCalculation(hydraulicBoundaryLocation);
failureMechanism.CalculationsGroup.Children.AddRange(new[]
{
calculation1,
calculation2
});
// Call
IEnumerable <CalculatableActivity> activities =
WaveImpactAsphaltCoverWaveConditionsCalculationActivityFactory.CreateCalculationActivities(
failureMechanism,
assessmentSection);
// Assert
CollectionAssert.AllItemsAreInstancesOfType(activities, typeof(WaveImpactAsphaltCoverWaveConditionsCalculationActivity));
Assert.AreEqual(2, activities.Count());
RoundedDouble assessmentLevel = assessmentSection.WaterLevelCalculationsForSignalFloodingProbability.Single().Output.Result;
HydraulicBoundaryDatabase hydraulicBoundaryDatabase = assessmentSection.HydraulicBoundaryDatabase;
AssertWaveImpactAsphaltCoverWaveConditionsCalculationActivity(activities.ElementAt(0), calculation1, assessmentLevel, hydraulicBoundaryDatabase);
AssertWaveImpactAsphaltCoverWaveConditionsCalculationActivity(activities.ElementAt(1), calculation2, assessmentLevel, hydraulicBoundaryDatabase);
}
public void ContextMenuStrip_HydraulicBoundaryDatabaseNotLinked_ContextMenuItemCalculateAllDisabledAndTooltipSet()
{
// Setup
var failureMechanism = new GrassCoverErosionOutwardsFailureMechanism();
var assessmentSection = new AssessmentSectionStub();
var context = new GrassCoverErosionOutwardsFailureMechanismContext(failureMechanism, assessmentSection);
using (var treeViewControl = new TreeViewControl())
{
var gui = mocks.Stub <IGui>();
gui.Stub(g => g.ProjectOpened += null).IgnoreArguments();
gui.Stub(g => g.ProjectOpened -= null).IgnoreArguments();
gui.Stub(cmp => cmp.Get(context, treeViewControl)).Return(new CustomItemsOnlyContextMenuBuilder());
mocks.ReplayAll();
plugin.Gui = gui;
// Call
using (ContextMenuStrip contextMenu = info.ContextMenuStrip(context, null, treeViewControl))
{
// Assert
ToolStripItem contextMenuItem = contextMenu.Items[contextMenuCalculateAllIndex];
Assert.AreEqual("Alles be&rekenen", contextMenuItem.Text);
StringAssert.Contains("Er is geen hydraulische belastingendatabase geïmporteerd.", contextMenuItem.ToolTipText);
TestHelper.AssertImagesAreEqual(RiskeerCommonFormsResources.CalculateAllIcon, contextMenuItem.Image);
Assert.IsFalse(contextMenuItem.Enabled);
}
}
}
public void Export_WithVariousAssessmentSectionConfigurations_ReturnsTrueAndWritesCorrectData(
AssessmentSectionStub assessmentSection, IEnumerable <string> expectedFiles)
{
// Setup
string directoryPath = TestHelper.GetScratchPadPath(nameof(Export_WithVariousAssessmentSectionConfigurations_ReturnsTrueAndWritesCorrectData));
Directory.CreateDirectory(directoryPath);
string filePath = Path.Combine(directoryPath, "test.zip");
var exporter = new HydraulicBoundaryLocationCalculationsExporter(assessmentSection, filePath);
try
{
// Call
bool isExported = exporter.Export();
// Assert
Assert.IsTrue(isExported);
using (ZipArchive zipArchive = ZipFile.OpenRead(filePath))
{
CollectionAssert.IsSubsetOf(expectedFiles, zipArchive.Entries.Select(e => e.FullName));
}
}
finally
{
DirectoryHelper.TryDelete(directoryPath);
}
}
public void GivenViewWithSpecificFailureMechanismData_WhenFailureMechanismNameUpdatedAndNotified_ThenMapDataUpdatedAndObserversNotified()
{
// Given
var mocks = new MockRepository();
var observer = mocks.StrictMock <IObserver>();
observer.Expect(obs => obs.UpdateObserver());
mocks.ReplayAll();
var assessmentSection = new AssessmentSectionStub();
var failureMechanism = new SpecificFailureMechanism();
SpecificFailureMechanismView view = CreateView(failureMechanism, assessmentSection);
MapDataCollection mapData = view.Map.Data;
mapData.Attach(observer);
// Precondition
Assert.AreEqual(failureMechanism.Name, mapData.Name);
// When
const string newFailureMechanismName = "New Failure Mechanism Name";
failureMechanism.Name = newFailureMechanismName;
failureMechanism.NotifyObservers();
// Then
Assert.AreEqual(newFailureMechanismName, mapData.Name);
mocks.VerifyAll();
}
