public void CreateDuneLocationFeatures_WithLocations_ReturnsLocationFeaturesCollection(bool withOutput)
{
// Setup
DuneLocation[] duneLocations =
{
CreateDuneLocation(1),
CreateDuneLocation(2)
};
var failureMechanism = new DuneErosionFailureMechanism();
failureMechanism.DuneLocationCalculationsForUserDefinedTargetProbabilities.AddRange(new[]
{
new DuneLocationCalculationsForTargetProbability(0.1),
new DuneLocationCalculationsForTargetProbability(0.001)
});
failureMechanism.SetDuneLocations(duneLocations);
if (withOutput)
{
DuneLocationsTestHelper.SetDuneLocationCalculationOutput(failureMechanism);
}
IEnumerable <AggregatedDuneLocation> aggregatedLocations = AggregatedDuneLocationFactory.CreateAggregatedDuneLocations(
failureMechanism.DuneLocations,
failureMechanism.DuneLocationCalculationsForUserDefinedTargetProbabilities);
// Call
IEnumerable <MapFeature> features = DuneErosionMapDataFeaturesFactory.CreateDuneLocationFeatures(aggregatedLocations);
// Assert
DuneErosionMapFeaturesTestHelper.AssertDuneLocationFeaturesData(failureMechanism, features);
}
public void CreateInstance_WithContext_SetsExpectedProperties()
{
// Setup
var mocks = new MockRepository();
var assessmentSection = mocks.Stub <IAssessmentSection>();
var window = mocks.Stub <IMainWindow>();
var gui = mocks.Stub <IGui>();
gui.Stub(g => g.MainWindow).Return(window);
gui.Stub(g => g.ViewHost).Return(mocks.Stub <IViewHost>());
mocks.ReplayAll();
var failureMechanism = new DuneErosionFailureMechanism();
var context = new DuneLocationCalculationsForUserDefinedTargetProbabilityContext(new DuneLocationCalculationsForTargetProbability(0.1),
failureMechanism,
assessmentSection);
using (var plugin = new DuneErosionPlugin())
{
ViewInfo info = GetInfo(plugin);
plugin.Gui = gui;
plugin.Activate();
// Call
using (var view = info.CreateInstance(context) as DuneLocationCalculationsView)
{
// Assert
Assert.AreSame(assessmentSection, view.AssessmentSection);
Assert.AreSame(failureMechanism, view.FailureMechanism);
}
}
mocks.VerifyAll();
}
public void AssembleFailureMechanism_CalculatorRan_ReturnsExpectedOutput()
{
// Setup
var failureMechanism = new DuneErosionFailureMechanism
{
AssemblyResult =
{
ProbabilityResultType = FailureMechanismAssemblyProbabilityResultType.Automatic
}
};
var assessmentSection = new AssessmentSectionStub();
using (new AssemblyToolCalculatorFactoryConfig())
{
var calculatorFactory = (TestAssemblyToolCalculatorFactory)AssemblyToolCalculatorFactory.Instance;
FailureMechanismAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedFailureMechanismAssemblyCalculator;
// Call
FailureMechanismAssemblyResultWrapper result = DuneErosionFailureMechanismAssemblyFactory.AssembleFailureMechanism(failureMechanism, assessmentSection);
// Assert
Assert.AreSame(calculator.AssemblyResultOutput, result);
}
}
public void AssembleFailureMechanism_WithInput_SetsInputOnCalculator()
{
// Setup
var failureMechanism = new DuneErosionFailureMechanism
{
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
DuneErosionFailureMechanismAssemblyFactory.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 ForeColor_DuneLocationsPresent_ReturnControlText()
{
// Setup
var failureMechanism = new DuneErosionFailureMechanism();
failureMechanism.SetDuneLocations(new[]
{
new TestDuneLocation()
});
var calculationsGroupContext = new DuneLocationCalculationsForUserDefinedTargetProbabilitiesGroupContext(
new ObservableList <DuneLocationCalculationsForTargetProbability>(),
failureMechanism,
new AssessmentSectionStub());
using (var plugin = new DuneErosionPlugin())
{
TreeNodeInfo info = GetInfo(plugin);
// Call
Color textColor = info.ForeColor(calculationsGroupContext);
// Assert
Assert.AreEqual(Color.FromKnownColor(KnownColor.ControlText), textColor);
}
}
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();
}
public void IsEnabled_FailureMechanismSectionsSourcePathSet_ReturnTrue()
{
// Setup
var mocks = new MockRepository();
var assessmentSection = mocks.Stub <IAssessmentSection>();
mocks.ReplayAll();
var failureMechanism = new DuneErosionFailureMechanism();
string sourcePath = TestHelper.GetScratchPadPath();
failureMechanism.SetSections(Enumerable.Empty <FailureMechanismSection>(), sourcePath);
var context = new DuneErosionFailureMechanismSectionsContext(failureMechanism, assessmentSection);
using (var plugin = new DuneErosionPlugin())
{
UpdateInfo importInfo = GetUpdateInfo(plugin);
// Call
bool isEnabled = importInfo.IsEnabled(context);
// Assert
Assert.IsTrue(isEnabled);
}
mocks.VerifyAll();
}
public void DoPostReplacementUpdates_DuneLocationsAdded_DoNothing()
{
// Setup
var mocks = new MockRepository();
var viewCommands = mocks.StrictMock <IViewCommands>();
mocks.ReplayAll();
var failureMechanism = new DuneErosionFailureMechanism();
failureMechanism.SetDuneLocations(new[]
{
new TestDuneLocation(),
new TestDuneLocation()
});
var handler = new DuneLocationsReplacementHandler(viewCommands, failureMechanism);
handler.Replace(new[]
{
new HydraulicBoundaryLocation(1, "Locatie_1_100", 205354, 609735)
});
// Precondition
Assert.AreEqual(1, failureMechanism.DuneLocations.Count());
// Call
handler.DoPostReplacementUpdates();
// Assert
mocks.VerifyAll(); // Expect no calls in 'viewCommands'
}
public void ContextMenuStrip_HydraulicBoundaryDatabaseNotLinked_ContextMenuItemCalculateAllDisabledAndTooltipSet()
{
// Setup
var duneLocation = new TestDuneLocation("Test");
var failureMechanism = new DuneErosionFailureMechanism();
var assessmentSection = new AssessmentSectionStub();
failureMechanism.SetDuneLocations(new[]
{
duneLocation
});
var context = new DuneErosionFailureMechanismContext(failureMechanism, assessmentSection);
using (var treeViewControl = new TreeViewControl())
{
var gui = mocksRepository.Stub <IGui>();
gui.Stub(cmp => cmp.Get(context, treeViewControl)).Return(new CustomItemsOnlyContextMenuBuilder());
gui.Stub(g => g.ViewHost).Return(mocksRepository.Stub <IViewHost>());
mocksRepository.ReplayAll();
plugin.Gui = gui;
// Call
using (ContextMenuStrip contextMenu = info.ContextMenuStrip(context, null, treeViewControl))
{
// Assert
TestHelper.AssertContextMenuStripContainsItem(contextMenu, contextMenuCalculateAllIndex,
"Alles be&rekenen",
"Er is geen hydraulische belastingendatabase geïmporteerd.",
RiskeerCommonFormsResources.CalculateAllIcon,
false);
}
}
}
public void CurrentPath_FailureMechanismSectionsSourcePathSet_ReturnsExpectedPath()
{
// Setup
var mocks = new MockRepository();
var assessmentSection = mocks.Stub <IAssessmentSection>();
mocks.ReplayAll();
var failureMechanism = new DuneErosionFailureMechanism();
string sourcePath = TestHelper.GetScratchPadPath();
failureMechanism.SetSections(Enumerable.Empty <FailureMechanismSection>(), sourcePath);
var context = new DuneErosionFailureMechanismSectionsContext(failureMechanism, assessmentSection);
using (var plugin = new DuneErosionPlugin())
{
UpdateInfo updateInfo = GetUpdateInfo(plugin);
// Call
string currentFilePath = updateInfo.CurrentPath(context);
// Assert
Assert.AreEqual(sourcePath, currentFilePath);
mocks.VerifyAll();
}
}
public void ChildNodeObjects_WithContext_ReturnChildDataNodes()
{
// Setup
var assessmentSection = new AssessmentSectionStub();
var failureMechanism = new DuneErosionFailureMechanism();
var context = new DuneErosionFailureMechanismContext(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(1, inputsFolder.Contents.Count());
var calculationsInputComments = (Comment)inputsFolder.Contents.ElementAt(0);
Assert.AreSame(failureMechanism.CalculationsInputComments, calculationsInputComments);
var targetProbabilitiesGroupContext = (DuneLocationCalculationsForUserDefinedTargetProbabilitiesGroupContext)children[1];
Assert.AreSame(failureMechanism.DuneLocationCalculationsForUserDefinedTargetProbabilities, targetProbabilitiesGroupContext.WrappedData);
Assert.AreSame(failureMechanism, targetProbabilitiesGroupContext.FailureMechanism);
Assert.AreSame(assessmentSection, targetProbabilitiesGroupContext.AssessmentSection);
}
public void SetDuneLocations_Always_PreviousLocationsAndCalculationsCleared()
{
// Setup
var calculationsForTargetProbability1 = new DuneLocationCalculationsForTargetProbability(0.1);
var calculationsForTargetProbability2 = new DuneLocationCalculationsForTargetProbability(0.01);
var failureMechanism = new DuneErosionFailureMechanism
{
DuneLocationCalculationsForUserDefinedTargetProbabilities =
{
calculationsForTargetProbability1,
calculationsForTargetProbability2
}
};
failureMechanism.SetDuneLocations(new DuneLocation[]
{
new TestDuneLocation()
});
// Precondition
CollectionAssert.IsNotEmpty(failureMechanism.DuneLocations);
CollectionAssert.IsNotEmpty(calculationsForTargetProbability1.DuneLocationCalculations);
CollectionAssert.IsNotEmpty(calculationsForTargetProbability2.DuneLocationCalculations);
// Call
failureMechanism.SetDuneLocations(Enumerable.Empty <DuneLocation>());
// Assert
CollectionAssert.IsEmpty(failureMechanism.DuneLocations);
CollectionAssert.IsEmpty(calculationsForTargetProbability1.DuneLocationCalculations);
CollectionAssert.IsEmpty(calculationsForTargetProbability2.DuneLocationCalculations);
}
public void ChildNodeObjects_FailureMechanismInAssemblyFalse_ReturnChildDataNodes()
{
// Setup
var mocks = new MockRepository();
var assessmentSection = mocks.Stub <IAssessmentSection>();
mocks.ReplayAll();
var failureMechanism = new DuneErosionFailureMechanism
{
InAssembly = false
};
var context = new DuneErosionFailureMechanismContext(failureMechanism, assessmentSection);
using (var plugin = new DuneErosionPlugin())
{
TreeNodeInfo info = GetInfo(plugin);
// 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 CloseForData_ViewCorrespondingToRemovedAssessmentSection_ReturnsTrue()
{
// Setup
var assessmentSection = mocks.Stub <IAssessmentSection>();
var failureMechanism = new DuneErosionFailureMechanism();
assessmentSection.Stub(asm => asm.GetFailureMechanisms()).Return(new IFailureMechanism[]
{
failureMechanism
});
mocks.ReplayAll();
using (var view = new NonAdoptableFailureMechanismResultView <DuneErosionFailureMechanism>(
failureMechanism.SectionResults, failureMechanism, assessmentSection,
(fm, ass) => new FailureMechanismAssemblyResultWrapper(double.NaN, AssemblyMethod.Manual)))
{
// Call
bool closeForData = info.CloseForData(view, assessmentSection);
// Assert
Assert.IsTrue(closeForData);
mocks.VerifyAll();
}
}
public void Create_StringPropertiesDoNotShareReference()
{
// Setup
var failureMechanism = new DuneErosionFailureMechanism
{
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 DoPostReplacementUpdates_NoDuneLocationsAdded_CloseAllViewsForFailureMechanism()
{
// Setup
var failureMechanism = new DuneErosionFailureMechanism();
failureMechanism.SetDuneLocations(new[]
{
new TestDuneLocation(),
new TestDuneLocation()
});
var mocks = new MockRepository();
var viewCommands = mocks.StrictMock <IViewCommands>();
viewCommands.Expect(vc => vc.RemoveAllViewsForItem(failureMechanism));
mocks.ReplayAll();
var handler = new DuneLocationsReplacementHandler(viewCommands, failureMechanism);
handler.Replace(new HydraulicBoundaryLocation[]
{
new TestHydraulicBoundaryLocation()
});
// Precondition
CollectionAssert.IsEmpty(failureMechanism.DuneLocations);
// Call
handler.DoPostReplacementUpdates();
// Assert
mocks.VerifyAll();
}
public void Create_WithDuneLocations_ReturnsEntityWithDuneLocations()
{
// Setup
var duneLocation = new TestDuneLocation();
var failureMechanism = new DuneErosionFailureMechanism
{
DuneLocationCalculationsForUserDefinedTargetProbabilities =
{
new DuneLocationCalculationsForTargetProbability(0.1),
new DuneLocationCalculationsForTargetProbability(0.01)
}
};
failureMechanism.SetDuneLocations(new[]
{
duneLocation
});
var duneLocationEntity = new DuneLocationEntity();
var registry = new PersistenceRegistry();
registry.Register(duneLocationEntity, duneLocation);
// Call
FailureMechanismEntity entity = failureMechanism.Create(registry);
// Assert
DuneLocationEntity actualDuneLocationEntity = entity.DuneLocationEntities.Single();
Assert.AreSame(duneLocationEntity, actualDuneLocationEntity);
DuneErosionFailureMechanismMetaEntity metaEntity = entity.DuneErosionFailureMechanismMetaEntities.Single();
AssertDuneLocationCalculationCollectionEntities(failureMechanism, metaEntity);
}
public void IsEnabled_CalculationsWithoutOutput_ReturnFalse()
{
// Setup
var mocks = new MockRepository();
var assessmentSection = mocks.Stub <IAssessmentSection>();
mocks.ReplayAll();
var failureMechanism = new DuneErosionFailureMechanism();
failureMechanism.SetDuneLocations(new[]
{
new TestDuneLocation()
});
var context = new DuneLocationCalculationsForUserDefinedTargetProbabilitiesGroupContext(new ObservableList <DuneLocationCalculationsForTargetProbability>(),
failureMechanism,
assessmentSection);
using (var plugin = new DuneErosionPlugin())
{
ExportInfo info = GetExportInfo(plugin);
// Call
bool isEnabled = info.IsEnabled(context);
// Assert
Assert.IsFalse(isEnabled);
}
mocks.VerifyAll();
}
private FailureMechanismAssemblyResultRow CreateDuneErosionFailureMechanismAssemblyResultRow()
{
DuneErosionFailureMechanism duneErosion = AssessmentSection.DuneErosion;
return(FailureMechanismAssemblyResultRowFactory.CreateRow(
duneErosion, () => DuneErosionFailureMechanismAssemblyFactory.AssembleFailureMechanism(duneErosion, AssessmentSection)));
}
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 SetDuneLocations_Always_PreviousDuneLocationsCleared()
{
// Setup
var duneLocation = new TestDuneLocation();
var failureMechanism = new DuneErosionFailureMechanism();
failureMechanism.SetDuneLocations(new[]
{
duneLocation
});
// Precondition
CollectionAssert.AreEqual(
new[]
{
duneLocation
}, failureMechanism.DuneLocations);
// Call
DuneErosionDataSynchronizationService.SetDuneLocations(failureMechanism,
new HydraulicBoundaryLocation[0],
new ReadDuneLocation[0]);
// Assert
CollectionAssert.IsEmpty(failureMechanism.DuneLocations);
}
public void Text_WithContext_ReturnsUniquelyFormattedTargetProbability(double userDefinedTargetProbability1,
double userDefinedTargetProbability2,
double userDefinedTargetProbability3,
string expectedText)
{
// Setup
var failureMechanism = new DuneErosionFailureMechanism();
var calculationsForTargetProbability = new DuneLocationCalculationsForTargetProbability(userDefinedTargetProbability2);
failureMechanism.DuneLocationCalculationsForUserDefinedTargetProbabilities.AddRange(new[]
{
new DuneLocationCalculationsForTargetProbability(userDefinedTargetProbability1),
new DuneLocationCalculationsForTargetProbability(userDefinedTargetProbability3),
calculationsForTargetProbability
});
var context = new DuneLocationCalculationsForUserDefinedTargetProbabilityContext(calculationsForTargetProbability,
failureMechanism,
new AssessmentSectionStub(new[]
{
failureMechanism
}));
// Call
string text = info.Text(context);
// Assert
Assert.AreEqual(expectedText, text);
}
public void SetDuneLocations_DuneLocationOffsetMatchesWithHydraulicBoundaryLocationName_DuneLocationAddedToFailureMechanism()
{
// Setup
var failureMechanism = new DuneErosionFailureMechanism();
var readDuneLocation = new ReadDuneLocation("dune location 1", new Point2D(1.0, 5.3), 8, 1.1, 2.2, 3.3);
var hydraulicBoundaryLocation = new HydraulicBoundaryLocation(1, "Location_2_1.1", 1.0, 5.3);
// Precondition
CollectionAssert.IsEmpty(failureMechanism.DuneLocations);
// Call
DuneErosionDataSynchronizationService.SetDuneLocations(
failureMechanism,
new[]
{
hydraulicBoundaryLocation
}, new[]
{
readDuneLocation
});
// Assert
Assert.AreEqual(1, failureMechanism.DuneLocations.Count());
DuneLocation duneLocation = failureMechanism.DuneLocations.First();
Assert.AreEqual(hydraulicBoundaryLocation.Id, duneLocation.Id);
Assert.AreEqual(readDuneLocation.Name, duneLocation.Name);
Assert.AreEqual(readDuneLocation.Location, duneLocation.Location);
Assert.AreEqual(readDuneLocation.Offset, duneLocation.Offset);
Assert.AreEqual(readDuneLocation.Orientation, duneLocation.Orientation);
Assert.AreEqual(readDuneLocation.D50, duneLocation.D50);
}
public void AssembleFailureMechanism_CalculatorThrowsException_ThrowsAssemblyException()
{
// Setup
var failureMechanism = new DuneErosionFailureMechanism
{
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() => DuneErosionFailureMechanismAssemblyFactory.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 SetDuneLocations_DuneLocationsMatchNameNotAccordingFormat_DuneLocationNotAddedLogMessage(double offset)
{
// Setup
var locationName = $"Location_{offset}";
var failureMechanism = new DuneErosionFailureMechanism();
var readDuneLocation = new ReadDuneLocation("dune location 1", new Point2D(1.0, 5.3), 8, offset, 2.2, 3.3);
var hydraulicBoundaryLocation = new HydraulicBoundaryLocation(1, locationName, 1.0, 5.3);
// Precondition
CollectionAssert.IsEmpty(failureMechanism.DuneLocations);
// Call
void Call() =>
DuneErosionDataSynchronizationService.SetDuneLocations(failureMechanism, new[]
{
hydraulicBoundaryLocation
}, new[]
{
readDuneLocation
});
// Assert
string expectedMessage = $"Locatie '{locationName}' moet voldoen aan het formaat 'Naam_Vaknummer_Metrering'. " +
"Deze locatie is niet toegevoegd aan de hydraulische belastingen voor het faalmechanisme duinen.";
TestHelper.AssertLogMessageIsGenerated(Call, expectedMessage, 1);
CollectionAssert.IsEmpty(failureMechanism.DuneLocations);
}
public void CreateInstance_WithContext_SetsFailureMechanismAsData()
{
// Setup
var mocks = new MockRepository();
var assessmentSection = mocks.Stub <IAssessmentSection>();
mocks.ReplayAll();
var failureMechanism = new DuneErosionFailureMechanism();
var context = new DuneErosionFailureMechanismContext(failureMechanism, assessmentSection);
using (var plugin = new DuneErosionPlugin())
{
PropertyInfo info = GetInfo(plugin);
// Call
IObjectProperties objectProperties = info.CreateInstance(context);
// Assert
Assert.IsInstanceOf <DuneErosionFailureMechanismProperties>(objectProperties);
Assert.AreSame(failureMechanism, objectProperties.Data);
}
mocks.VerifyAll();
}
public void CloseViewForData_ForMatchingAssessmentSection_ReturnsTrue()
{
// Setup
var failureMechanism = new DuneErosionFailureMechanism();
var mocks = new MockRepository();
var assessmentSection = mocks.Stub <IAssessmentSection>();
assessmentSection.Stub(a => a.GetFailureMechanisms()).Return(new[]
{
failureMechanism
});
assessmentSection.Stub(a => a.Attach(null)).IgnoreArguments();
assessmentSection.Stub(a => a.Detach(null)).IgnoreArguments();
mocks.ReplayAll();
using (var plugin = new DuneErosionPlugin())
using (var view = new DuneLocationCalculationsView(new ObservableList <DuneLocationCalculation>(),
failureMechanism,
assessmentSection,
() => 0.01,
() => "1/100"))
{
ViewInfo info = GetInfo(plugin);
// Call
bool closeForData = info.CloseForData(view, assessmentSection);
// Assert
Assert.IsTrue(closeForData);
}
mocks.VerifyAll();
}
public void Constructor_Always_PropertiesHaveExpectedAttributeValues()
{
// Setup
var failureMechanism = new DuneErosionFailureMechanism();
// Call
var properties = new DuneErosionFailureMechanismProperties(failureMechanism);
// Assert
PropertyDescriptorCollection dynamicProperties = PropertiesTestHelper.GetAllVisiblePropertyDescriptors(properties);
Assert.AreEqual(2, dynamicProperties.Count);
const string generalCategory = "Algemeen";
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);
}
public void CreateCalculationActivitiesForFailureMechanism_WithValidDataAndUsePreprocessorStates_ReturnsExpectedActivities(bool usePreprocessor)
{
// Setup
AssessmentSectionStub assessmentSection = CreateAssessmentSection(usePreprocessor);
var duneLocationCalculationsForTargetProbability1 = new DuneLocationCalculationsForTargetProbability(0.1);
var duneLocationCalculationsForTargetProbability2 = new DuneLocationCalculationsForTargetProbability(0.01);
var failureMechanism = new DuneErosionFailureMechanism
{
DuneLocationCalculationsForUserDefinedTargetProbabilities =
{
duneLocationCalculationsForTargetProbability1,
duneLocationCalculationsForTargetProbability2
}
};
var duneLocation1 = new DuneLocation(1, "locationName1", new Point2D(1, 1), new DuneLocation.ConstructionProperties());
var duneLocation2 = new DuneLocation(2, "locationName2", new Point2D(2, 2), new DuneLocation.ConstructionProperties());
failureMechanism.SetDuneLocations(new[]
{
duneLocation1,
duneLocation2
});
// Call
CalculatableActivity[] activities = DuneLocationCalculationActivityFactory.CreateCalculationActivities(failureMechanism, assessmentSection).ToArray();
// Assert
Assert.AreEqual(4, activities.Length);
HydraulicBoundaryDatabase hydraulicBoundaryDatabase = assessmentSection.HydraulicBoundaryDatabase;
AssertDuneLocationCalculationActivity(activities[0],
"1/10",
duneLocation1.Name,
duneLocation1.Id,
duneLocationCalculationsForTargetProbability1.TargetProbability,
hydraulicBoundaryDatabase);
AssertDuneLocationCalculationActivity(activities[1],
"1/10",
duneLocation2.Name,
duneLocation2.Id,
duneLocationCalculationsForTargetProbability1.TargetProbability,
hydraulicBoundaryDatabase);
AssertDuneLocationCalculationActivity(activities[2],
"1/100",
duneLocation1.Name,
duneLocation1.Id,
duneLocationCalculationsForTargetProbability2.TargetProbability,
hydraulicBoundaryDatabase);
AssertDuneLocationCalculationActivity(activities[3],
"1/100",
duneLocation2.Name,
duneLocation2.Id,
duneLocationCalculationsForTargetProbability2.TargetProbability,
hydraulicBoundaryDatabase);
}
public void CalculateForSelectedButton_OneCalculationSelected_CalculateForSelectedCalculationAndKeepOriginalSelection()
{
// Setup
var hydraulicBoundaryDatabase = new HydraulicBoundaryDatabase
{
FilePath = hydraulicBoundaryDatabaseFilePath
};
HydraulicBoundaryDatabaseTestHelper.SetHydraulicBoundaryLocationConfigurationSettings(hydraulicBoundaryDatabase);
var assessmentSection = mocks.Stub <IAssessmentSection>();
assessmentSection.Stub(a => a.Id).Return("1");
assessmentSection.Stub(a => a.FailureMechanismContribution).Return(FailureMechanismContributionTestFactory.CreateFailureMechanismContribution());
assessmentSection.Stub(a => a.HydraulicBoundaryDatabase).Return(hydraulicBoundaryDatabase);
assessmentSection.Stub(a => a.Attach(null)).IgnoreArguments();
assessmentSection.Stub(a => a.Detach(null)).IgnoreArguments();
var calculationsObserver = mocks.StrictMock <IObserver>();
var calculatorFactory = mocks.StrictMock <IHydraRingCalculatorFactory>();
calculatorFactory.Expect(cf => cf.CreateDunesBoundaryConditionsCalculator(null))
.IgnoreArguments()
.Return(new TestDunesBoundaryConditionsCalculator());
mocks.ReplayAll();
IObservableEnumerable <DuneLocationCalculation> calculations = GenerateDuneLocationCalculations();
var failureMechanism = new DuneErosionFailureMechanism();
using (DuneLocationCalculationsView view = ShowDuneLocationCalculationsView(calculations,
failureMechanism,
assessmentSection))
{
var dataGridView = (DataGridView)view.Controls.Find("dataGridView", true)[0];
object originalDataSource = dataGridView.DataSource;
DataGridViewRowCollection rows = dataGridView.Rows;
rows[0].Cells[calculateColumnIndex].Value = true;
calculations.Attach(calculationsObserver);
var buttonTester = new ButtonTester("CalculateForSelectedButton", testForm);
using (var viewParent = new TestViewParentForm())
using (new HydraRingCalculatorFactoryConfig(calculatorFactory))
{
view.CalculationGuiService = new DuneLocationCalculationGuiService(viewParent);
// Call
buttonTester.Click();
// Assert
Assert.AreSame(originalDataSource, dataGridView.DataSource);
Assert.IsTrue((bool)rows[0].Cells[calculateColumnIndex].Value);
Assert.IsFalse((bool)rows[1].Cells[calculateColumnIndex].Value);
}
}
}
