public void Create_StringPropertiesDoNotShareReference()
{
// Setup
var failureMechanism = new WaveImpactAsphaltCoverFailureMechanism
{
InAssemblyInputComments =
{
Body = "Some input text"
},
InAssemblyOutputComments =
{
Body = "Some output text"
},
NotInAssemblyComments =
{
Body = "Really not in assembly"
},
CalculationsInputComments =
{
Body = "Some calculation text"
}
};
var registry = new PersistenceRegistry();
// Call
FailureMechanismEntity entity = failureMechanism.Create(registry);
// Assert
TestHelper.AssertAreEqualButNotSame(failureMechanism.InAssemblyInputComments.Body, entity.InAssemblyInputComments);
TestHelper.AssertAreEqualButNotSame(failureMechanism.InAssemblyOutputComments.Body, entity.InAssemblyOutputComments);
TestHelper.AssertAreEqualButNotSame(failureMechanism.NotInAssemblyComments.Body, entity.NotInAssemblyComments);
TestHelper.AssertAreEqualButNotSame(failureMechanism.CalculationsInputComments.Body, entity.CalculationsInputComments);
}
public void DynamicVisibleValidationMethod_DependingOnInAssembly_ReturnExpectedVisibility(bool inAssembly)
{
// Setup
var mocks = new MockRepository();
var assessmentSection = mocks.Stub <IAssessmentSection>();
mocks.ReplayAll();
var failureMechanism = new WaveImpactAsphaltCoverFailureMechanism
{
InAssembly = inAssembly
};
var properties = new WaveImpactAsphaltCoverFailureMechanismProperties(failureMechanism, assessmentSection);
// 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.DeltaL)));
Assert.AreEqual(inAssembly, properties.DynamicVisibleValidationMethod(nameof(properties.SectionLength)));
Assert.AreEqual(inAssembly, properties.DynamicVisibleValidationMethod(nameof(properties.N)));
Assert.AreEqual(inAssembly, properties.DynamicVisibleValidationMethod(nameof(properties.ApplyLengthEffectInSection)));
Assert.IsTrue(properties.DynamicVisibleValidationMethod(null));
mocks.VerifyAll();
}
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 WaveImpactAsphaltCoverFailureMechanism CreateWaveImpactAsphaltCoverFailureMechanismWithAllUpdateForeshoreProfileScenarios(
ForeshoreProfile unaffectedForeshoreProfile)
{
WaveImpactAsphaltCoverFailureMechanism waveImpactAsphaltCoverFailureMechanism =
TestDataGenerator.GetWaveImpactAsphaltCoverFailureMechanismWithAllCalculationConfigurations();
waveImpactAsphaltCoverFailureMechanism.ForeshoreProfiles.AddRange(new[]
{
unaffectedForeshoreProfile
}, sourceFilePath);
var unaffectedCalculation = new WaveImpactAsphaltCoverWaveConditionsCalculation
{
InputParameters =
{
ForeshoreProfile = unaffectedForeshoreProfile
},
Output = new WaveImpactAsphaltCoverWaveConditionsOutput(new[]
{
new TestWaveConditionsOutput()
})
};
waveImpactAsphaltCoverFailureMechanism.CalculationsGroup.Children.Add(unaffectedCalculation);
return(waveImpactAsphaltCoverFailureMechanism);
}
public void DeltaL_SetInvalidValue_ThrowsArgumentOutOfRangeExceptionNoNotifications(double newN)
{
// Setup
var mocks = new MockRepository();
var assessmentSection = mocks.Stub <IAssessmentSection>();
var observer = mocks.StrictMock <IObserver>();
mocks.ReplayAll();
var failureMechanism = new WaveImpactAsphaltCoverFailureMechanism();
failureMechanism.Attach(observer);
var properties = new WaveImpactAsphaltCoverFailureMechanismProperties(
failureMechanism,
assessmentSection);
// Call
void Call() => properties.DeltaL = (RoundedDouble)newN;
// Assert
const string expectedMessage = "De waarde voor 'ΔL' moet groter zijn dan 0.";
TestHelper.AssertThrowsArgumentExceptionAndTestMessage <ArgumentOutOfRangeException>(Call, expectedMessage);
mocks.VerifyAll();
}
public void Calculations_MultipleChildrenAdded_ReturnWaveImpactAsphaltCoverCalculations()
{
// Setup
var mocks = new MockRepository();
var failureMechanism = new WaveImpactAsphaltCoverFailureMechanism
{
CalculationsGroup =
{
Children =
{
new CalculationGroup(),
new WaveImpactAsphaltCoverWaveConditionsCalculation(),
mocks.StrictMock <ICalculation>(),
new WaveImpactAsphaltCoverWaveConditionsCalculation()
}
}
};
mocks.ReplayAll();
// Call
List <ICalculation> calculations = failureMechanism.Calculations.ToList();
// Assert
Assert.AreEqual(2, calculations.Count);
Assert.IsTrue(calculations.All(c => c is WaveImpactAsphaltCoverWaveConditionsCalculation));
mocks.VerifyAll();
}
public DerivedWaveImpactAsphaltCoverCalculationGroupContext(CalculationGroup calculationsGroup,
CalculationGroup parent,
WaveImpactAsphaltCoverFailureMechanism failureMechanism,
IAssessmentSection assessmentSection)
: base(calculationsGroup, parent, failureMechanism, assessmentSection)
{
}
public void AssembleFailureMechanism_CalculatorRan_ReturnsExpectedOutput()
{
// Setup
var failureMechanism = new WaveImpactAsphaltCoverFailureMechanism
{
AssemblyResult =
{
ProbabilityResultType = FailureMechanismAssemblyProbabilityResultType.Automatic
}
};
var assessmentSection = new AssessmentSectionStub();
using (new AssemblyToolCalculatorFactoryConfig())
{
var calculatorFactory = (TestAssemblyToolCalculatorFactory)AssemblyToolCalculatorFactory.Instance;
FailureMechanismAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedFailureMechanismAssemblyCalculator;
// Call
FailureMechanismAssemblyResultWrapper result = WaveImpactAsphaltCoverFailureMechanismAssemblyFactory.AssembleFailureMechanism(failureMechanism, assessmentSection);
// Assert
Assert.AreSame(calculator.AssemblyResultOutput, result);
}
}
public void AssembleFailureMechanism_CalculatorThrowsException_ThrowsAssemblyException()
{
// Setup
var failureMechanism = new WaveImpactAsphaltCoverFailureMechanism
{
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() => WaveImpactAsphaltCoverFailureMechanismAssemblyFactory.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 AssembleSection_CalculatorThrowsException_ThrowsAssemblyException()
{
// Setup
FailureMechanismSection section = FailureMechanismSectionTestFactory.CreateFailureMechanismSection();
var sectionResult = new NonAdoptableWithProfileProbabilityFailureMechanismSectionResult(section);
var failureMechanism = new WaveImpactAsphaltCoverFailureMechanism();
var assessmentSection = new AssessmentSectionStub();
using (new AssemblyToolCalculatorFactoryConfig())
{
var calculatorFactory = (TestAssemblyToolCalculatorFactory)AssemblyToolCalculatorFactory.Instance;
FailureMechanismSectionAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator;
calculator.ThrowExceptionOnCalculate = true;
// Call
void Call() => WaveImpactAsphaltCoverFailureMechanismAssemblyFactory.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 AssembleFailureMechanism_WithInput_SetsInputOnCalculator()
{
// Setup
var failureMechanism = new WaveImpactAsphaltCoverFailureMechanism
{
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
WaveImpactAsphaltCoverFailureMechanismAssemblyFactory.AssembleFailureMechanism(failureMechanism, assessmentSection);
// Assert
double expectedN = failureMechanism.GeneralWaveImpactAsphaltCoverInput.GetN(assessmentSection.ReferenceLine.Length);
Assert.AreEqual(expectedN, failureMechanismAssemblyCalculator.FailureMechanismN);
Assert.AreSame(calculator.FailureMechanismSectionAssemblyResultOutput.AssemblyResult, failureMechanismAssemblyCalculator.SectionAssemblyResultsInput.Single());
Assert.AreEqual(failureMechanism.GeneralWaveImpactAsphaltCoverInput.ApplyLengthEffectInSection, failureMechanismAssemblyCalculator.ApplyLengthEffect);
}
}
public void Calculate_WithValidInput_SetsOutput()
{
// Setup
IAssessmentSection assessmentSection = CreateAssessmentSectionWithHydraulicBoundaryOutput();
WaveImpactAsphaltCoverWaveConditionsCalculation calculation = GetValidCalculation(assessmentSection.HydraulicBoundaryDatabase.Locations.First());
var waveImpactAsphaltCoverFailureMechanism = new WaveImpactAsphaltCoverFailureMechanism();
var mockRepository = new MockRepository();
var calculatorFactory = mockRepository.StrictMock <IHydraRingCalculatorFactory>();
calculatorFactory.Expect(cf => cf.CreateWaveConditionsCosineCalculator(null))
.IgnoreArguments()
.Return(new TestWaveConditionsCosineCalculator())
.Repeat
.Times(3);
mockRepository.ReplayAll();
using (new HydraRingCalculatorFactoryConfig(calculatorFactory))
{
// Call
new WaveImpactAsphaltCoverWaveConditionsCalculationService().Calculate(
calculation,
assessmentSection,
waveImpactAsphaltCoverFailureMechanism.GeneralInput);
// Assert
Assert.IsNotNull(calculation.Output);
Assert.AreEqual(3, calculation.Output.Items.Count());
}
mockRepository.VerifyAll();
}
public void Calculate_Canceled_HasNoOutput()
{
// Setup
IAssessmentSection assessmentSection = CreateAssessmentSectionWithHydraulicBoundaryOutput();
WaveImpactAsphaltCoverWaveConditionsCalculation calculation = GetDefaultCalculation(assessmentSection.HydraulicBoundaryDatabase.Locations.First());
var waveImpactAsphaltCoverFailureMechanism = new WaveImpactAsphaltCoverFailureMechanism();
var mockRepository = new MockRepository();
var calculatorFactory = mockRepository.StrictMock <IHydraRingCalculatorFactory>();
mockRepository.ReplayAll();
using (new HydraRingCalculatorFactoryConfig(calculatorFactory))
{
var waveImpactAsphaltCoverWaveConditionsCalculationService = new WaveImpactAsphaltCoverWaveConditionsCalculationService();
waveImpactAsphaltCoverWaveConditionsCalculationService.Cancel();
// Call
waveImpactAsphaltCoverWaveConditionsCalculationService.Calculate(
calculation,
assessmentSection,
waveImpactAsphaltCoverFailureMechanism.GeneralInput);
// Assert
Assert.IsFalse(calculation.HasOutput);
}
mockRepository.VerifyAll();
}
public void Create_WithCalculationGroup_ReturnFailureMechanismEntityWithCalculationGroupEntities()
{
// Setup
var failureMechanism = new WaveImpactAsphaltCoverFailureMechanism();
failureMechanism.CalculationsGroup.Children.Add(new CalculationGroup
{
Name = "A"
});
failureMechanism.CalculationsGroup.Children.Add(new CalculationGroup
{
Name = "B"
});
var registry = new PersistenceRegistry();
// Call
FailureMechanismEntity entity = failureMechanism.Create(registry);
// Assert
Assert.IsNotNull(entity);
Assert.AreEqual(failureMechanism.CalculationsGroup.Name, entity.CalculationGroupEntity.Name);
Assert.AreEqual(0, entity.CalculationGroupEntity.Order);
CalculationGroupEntity[] childGroupEntities = entity.CalculationGroupEntity.CalculationGroupEntity1
.OrderBy(cge => cge.Order)
.ToArray();
Assert.AreEqual(2, childGroupEntities.Length);
Assert.AreEqual("A", childGroupEntities[0].Name);
Assert.AreEqual(0, childGroupEntities[0].Order);
Assert.AreEqual("B", childGroupEntities[1].Name);
Assert.AreEqual(1, childGroupEntities[1].Order);
}
public void ClearReferenceLineDependentData_FullyConfiguredFailureMechanism_RemoveFailureMechanismDependentData()
{
// Setup
WaveImpactAsphaltCoverFailureMechanism failureMechanism = CreateFullyConfiguredFailureMechanism();
object[] expectedRemovedObjects = failureMechanism.Sections.OfType <object>()
.Concat(failureMechanism.SectionResults)
.Concat(failureMechanism.CalculationsGroup.GetAllChildrenRecursive())
.Concat(failureMechanism.ForeshoreProfiles)
.ToArray();
// Call
ClearResults results = WaveImpactAsphaltCoverDataSynchronizationService.ClearReferenceLineDependentData(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:
CollectionAssert.IsEmpty(failureMechanism.Sections);
CollectionAssert.IsEmpty(failureMechanism.SectionResults);
CollectionAssert.IsEmpty(failureMechanism.CalculationsGroup.Children);
CollectionAssert.IsEmpty(failureMechanism.ForeshoreProfiles);
IObservable[] array = results.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.ForeshoreProfiles);
CollectionAssert.AreEquivalent(expectedRemovedObjects, results.RemovedObjects);
}
public DerivedWaveImpactAsphaltCoverWaveConditionsCalculationContext(WaveImpactAsphaltCoverWaveConditionsCalculation calculation,
CalculationGroup parent,
WaveImpactAsphaltCoverFailureMechanism failureMechanism,
IAssessmentSection assessmentSection)
: base(calculation, parent, failureMechanism, assessmentSection)
{
}
public void ClearAllCalculationOutputAndHydraulicBoundaryLocations_WithVariousCalculations_ClearsOutputAndReturnsAffectedObjects()
{
// Setup
WaveImpactAsphaltCoverFailureMechanism failureMechanism = CreateFullyConfiguredFailureMechanism();
WaveImpactAsphaltCoverWaveConditionsCalculation[] calculations = failureMechanism.Calculations.Cast <WaveImpactAsphaltCoverWaveConditionsCalculation>().ToArray();
IObservable[] expectedAffectedCalculations = calculations.Where(c => c.HasOutput)
.Cast <IObservable>()
.ToArray();
IObservable[] expectedAffectedCalculationInputs = calculations.Select(c => c.InputParameters)
.Where(i => i.HydraulicBoundaryLocation != null)
.Cast <IObservable>()
.ToArray();
// Call
IEnumerable <IObservable> affectedItems =
WaveImpactAsphaltCoverDataSynchronizationService.ClearAllWaveConditionsCalculationOutputAndHydraulicBoundaryLocations(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 <WaveImpactAsphaltCoverWaveConditionsCalculation>()
.All(c => c.InputParameters.HydraulicBoundaryLocation == null &&
!c.HasOutput));
CollectionAssert.AreEquivalent(expectedAffectedCalculations.Concat(expectedAffectedCalculationInputs),
affectedItems);
}
public void ChildNodeObjects_WithContext_ReturnChildDataNodes()
{
// Setup
var assessmentSection = new AssessmentSectionStub();
var failureMechanism = new WaveImpactAsphaltCoverFailureMechanism();
var context = new WaveImpactAsphaltCoverFailureMechanismContext(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 profilesContext = (ForeshoreProfilesContext)inputsFolder.Contents.ElementAt(0);
Assert.AreSame(failureMechanism.ForeshoreProfiles, profilesContext.WrappedData);
Assert.AreSame(failureMechanism, profilesContext.ParentFailureMechanism);
Assert.AreSame(assessmentSection, profilesContext.ParentAssessmentSection);
var calculationsInputComments = (Comment)inputsFolder.Contents.ElementAt(1);
Assert.AreSame(failureMechanism.CalculationsInputComments, calculationsInputComments);
var hydraulicBoundariesCalculationGroup = (WaveImpactAsphaltCoverCalculationGroupContext)children[1];
Assert.AreSame(failureMechanism.CalculationsGroup, hydraulicBoundariesCalculationGroup.WrappedData);
Assert.IsNull(hydraulicBoundariesCalculationGroup.Parent);
Assert.AreSame(failureMechanism, hydraulicBoundariesCalculationGroup.FailureMechanism);
Assert.AreSame(assessmentSection, hydraulicBoundariesCalculationGroup.AssessmentSection);
}
public void ChildNodeObjects_FailureMechanismInAssemblyFalse_ReturnChildDataNodes()
{
// Setup
var mocks = new MockRepository();
var assessmentSection = mocks.Stub <IAssessmentSection>();
mocks.ReplayAll();
var failureMechanism = new WaveImpactAsphaltCoverFailureMechanism
{
InAssembly = false
};
var context = new WaveImpactAsphaltCoverFailureMechanismContext(failureMechanism, assessmentSection);
// Call
object[] children = info.ChildNodeObjects(context).ToArray();
// Assert
Assert.AreEqual(1, children.Length);
var comment = (Comment)children[0];
Assert.AreSame(failureMechanism.NotInAssemblyComments, comment);
mocks.VerifyAll();
}
public void ContextMenuStrip_WithContext_AddCustomItems()
{
// Setup
using (var treeView = new TreeViewControl())
{
var assessmentSection = mocks.Stub <IAssessmentSection>();
var failureMechanism = new WaveImpactAsphaltCoverFailureMechanism();
var context = new WaveImpactAsphaltCoverFailureMechanismContext(failureMechanism, assessmentSection);
var menuBuilder = new CustomItemsOnlyContextMenuBuilder();
var gui = mocks.Stub <IGui>();
gui.Stub(cmp => cmp.Get(context, treeView)).Return(menuBuilder);
gui.Stub(g => g.ProjectOpened += null).IgnoreArguments();
gui.Stub(g => g.ProjectOpened -= null).IgnoreArguments();
mocks.ReplayAll();
plugin.Gui = gui;
// Call
using (ContextMenuStrip menu = info.ContextMenuStrip(context, assessmentSection, treeView))
{
// Assert
Assert.AreEqual(8, menu.Items.Count);
TestHelper.AssertContextMenuStripContainsItem(menu, contextMenuCalculateAllIndex,
"Alles be&rekenen",
"Er zijn geen berekeningen om uit te voeren.",
RiskeerCommonFormsResources.CalculateAllIcon,
false);
}
}
}
public void ParameteredConstructor_ExpectedValues(bool hasParent)
{
// Setup
var mockRepository = new MockRepository();
var assessmentSection = mockRepository.Stub <IAssessmentSection>();
mockRepository.ReplayAll();
var calculationGroup = new CalculationGroup();
var failureMechanism = new WaveImpactAsphaltCoverFailureMechanism();
CalculationGroup parent = hasParent ? new CalculationGroup() : null;
// Call
var groupContext = new WaveImpactAsphaltCoverCalculationGroupContext(calculationGroup, parent, failureMechanism, assessmentSection);
// Assert
Assert.IsInstanceOf <WaveImpactAsphaltCoverContext <CalculationGroup> >(groupContext);
Assert.IsInstanceOf <ICalculationContext <CalculationGroup, WaveImpactAsphaltCoverFailureMechanism> >(groupContext);
Assert.AreSame(calculationGroup, groupContext.WrappedData);
Assert.AreSame(parent, groupContext.Parent);
Assert.AreSame(failureMechanism, groupContext.FailureMechanism);
Assert.AreSame(assessmentSection, groupContext.AssessmentSection);
Assert.AreSame(failureMechanism.ForeshoreProfiles, groupContext.ForeshoreProfiles);
mockRepository.VerifyAll();
}
public void ContextMenuStrip_HydraulicBoundaryDatabaseNotLinked_CalculateAllDisabled()
{
// Setup
using (var treeViewControl = new TreeViewControl())
{
var failureMechanism = new WaveImpactAsphaltCoverFailureMechanism();
failureMechanism.CalculationsGroup.Children.Add(new WaveImpactAsphaltCoverWaveConditionsCalculation());
IAssessmentSection assessmentSection = AssessmentSectionTestHelper.CreateAssessmentSectionStub(mocks);
var nodeData = new WaveImpactAsphaltCoverFailureMechanismContext(failureMechanism, assessmentSection);
var menuBuilder = new CustomItemsOnlyContextMenuBuilder();
var gui = mocks.Stub <IGui>();
gui.Stub(g => g.Get(nodeData, treeViewControl)).Return(menuBuilder);
gui.Stub(g => g.MainWindow).Return(mocks.Stub <IMainWindow>());
mocks.ReplayAll();
plugin.Gui = gui;
// Call
using (ContextMenuStrip contextMenu = info.ContextMenuStrip(nodeData, null, treeViewControl))
{
// Assert
ToolStripItem calculateItem = contextMenu.Items[contextMenuCalculateAllIndex];
Assert.IsFalse(calculateItem.Enabled);
Assert.AreEqual("Er is geen hydraulische belastingendatabase geïmporteerd.", calculateItem.ToolTipText);
}
}
}
public void CreateInstance_WithContext_SetsFailureMechanismAsData()
{
// Setup
var mocks = new MockRepository();
var assessmentSection = mocks.Stub <IAssessmentSection>();
mocks.ReplayAll();
var failureMechanism = new WaveImpactAsphaltCoverFailureMechanism();
var context = new WaveImpactAsphaltCoverFailureMechanismContext(failureMechanism, assessmentSection);
using (var plugin = new WaveImpactAsphaltCoverPlugin())
{
PropertyInfo info = GetInfo(plugin);
// Call
IObjectProperties objectProperties = info.CreateInstance(context);
// Assert
Assert.IsInstanceOf <WaveImpactAsphaltCoverFailureMechanismProperties>(objectProperties);
Assert.AreSame(failureMechanism, objectProperties.Data);
}
mocks.VerifyAll();
}
public void CloseForData_ViewNotCorrespondingToRemovedFailureMechanismContext_ReturnsFalse()
{
// Setup
var assessmentSection = mocks.Stub <IAssessmentSection>();
mocks.ReplayAll();
var context = new WaveImpactAsphaltCoverFailureMechanismContext(
new WaveImpactAsphaltCoverFailureMechanism(), assessmentSection);
var failureMechanism = new WaveImpactAsphaltCoverFailureMechanism();
using (var view = new NonAdoptableWithProfileProbabilityFailureMechanismResultView <WaveImpactAsphaltCoverFailureMechanism>(
failureMechanism.SectionResults, failureMechanism, assessmentSection,
(fm, ass) => new FailureMechanismAssemblyResultWrapper(double.NaN, AssemblyMethod.Manual),
fm => true,
sr => FailureMechanismSectionAssemblyResultWrapperTestFactory.Create()))
{
// Call
bool closeForData = info.CloseForData(view, context);
// Assert
Assert.IsFalse(closeForData);
}
mocks.VerifyAll();
}
public void DeltaL_SetValidValue_UpdateDataAndNotifyObservers(double newN)
{
// Setup
var mocks = new MockRepository();
var assessmentSection = mocks.Stub <IAssessmentSection>();
var observer = mocks.StrictMock <IObserver>();
observer.Expect(o => o.UpdateObserver());
mocks.ReplayAll();
var failureMechanism = new WaveImpactAsphaltCoverFailureMechanism();
failureMechanism.Attach(observer);
var properties = new WaveImpactAsphaltCoverFailureMechanismProperties(
failureMechanism,
assessmentSection);
// Call
properties.DeltaL = (RoundedDouble)newN;
// Assert
Assert.AreEqual(newN, failureMechanism.GeneralWaveImpactAsphaltCoverInput.DeltaL);
mocks.VerifyAll();
}
public void CurrentPath_FailureMechanismSectionsSourcePathSet_ReturnsExpectedPath()
{
// Setup
var mocks = new MockRepository();
var assessmentSection = mocks.Stub <IAssessmentSection>();
mocks.ReplayAll();
var failureMechanism = new WaveImpactAsphaltCoverFailureMechanism();
string sourcePath = TestHelper.GetScratchPadPath();
failureMechanism.SetSections(Enumerable.Empty <FailureMechanismSection>(), sourcePath);
var context = new WaveImpactAsphaltCoverFailureMechanismSectionsContext(failureMechanism, assessmentSection);
using (var plugin = new WaveImpactAsphaltCoverPlugin())
{
UpdateInfo updateInfo = GetUpdateInfo(plugin);
// Call
string currentFilePath = updateInfo.CurrentPath(context);
// Assert
Assert.AreEqual(sourcePath, currentFilePath);
mocks.VerifyAll();
}
}
/// <summary>
/// Clears all data dependent, either directly or indirectly, on the parent reference line.
/// </summary>
/// <param name="failureMechanism">The failure mechanism to be cleared.</param>
/// <returns>The results of the clear action.</returns>
/// <exception cref="ArgumentNullException">Thrown when <paramref name="failureMechanism"/> is <c>null</c>.</exception>
public static ClearResults ClearReferenceLineDependentData(WaveImpactAsphaltCoverFailureMechanism failureMechanism)
{
if (failureMechanism == null)
{
throw new ArgumentNullException(nameof(failureMechanism));
}
var changedObjects = new List <IObservable>();
object[] removedObjects = failureMechanism.Sections.OfType <object>()
.Concat(failureMechanism.SectionResults)
.Concat(failureMechanism.CalculationsGroup.GetAllChildrenRecursive())
.Concat(failureMechanism.ForeshoreProfiles)
.ToArray();
failureMechanism.ClearAllSections();
changedObjects.Add(failureMechanism);
changedObjects.Add(failureMechanism.SectionResults);
failureMechanism.CalculationsGroup.Children.Clear();
changedObjects.Add(failureMechanism.CalculationsGroup);
failureMechanism.ForeshoreProfiles.Clear();
changedObjects.Add(failureMechanism.ForeshoreProfiles);
return(new ClearResults(changedObjects, removedObjects));
}
public void IsEnabled_FailureMechanismSectionsSourcePathSet_ReturnTrue()
{
// Setup
var mocks = new MockRepository();
var assessmentSection = mocks.Stub <IAssessmentSection>();
mocks.ReplayAll();
var failureMechanism = new WaveImpactAsphaltCoverFailureMechanism();
string sourcePath = TestHelper.GetScratchPadPath();
failureMechanism.SetSections(Enumerable.Empty <FailureMechanismSection>(), sourcePath);
var context = new WaveImpactAsphaltCoverFailureMechanismSectionsContext(failureMechanism, assessmentSection);
using (var plugin = new WaveImpactAsphaltCoverPlugin())
{
UpdateInfo importInfo = GetUpdateInfo(plugin);
// Call
bool isEnabled = importInfo.IsEnabled(context);
// Assert
Assert.IsTrue(isEnabled);
}
mocks.VerifyAll();
}
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);
}
private FailureMechanismAssemblyResultRow CreateWaveImpactFailureMechanismAssemblyResultRow()
{
WaveImpactAsphaltCoverFailureMechanism waveImpactAsphaltCover = AssessmentSection.WaveImpactAsphaltCover;
return(FailureMechanismAssemblyResultRowFactory.CreateRow(
waveImpactAsphaltCover, () => WaveImpactAsphaltCoverFailureMechanismAssemblyFactory.AssembleFailureMechanism(waveImpactAsphaltCover, AssessmentSection)));
}
