public void GivenFailureMechanismWithDikeProfiles_WhenAddingAndRemovingElements_ThenCollectionIsUpdated() { // Scenario var failureMechanism = new GrassCoverErosionInwardsFailureMechanism(); const string filePath = "path"; DikeProfile dikeProfile1 = DikeProfileTestFactory.CreateDikeProfile(new Point2D(0, 0), "id1"); DikeProfile dikeProfile2 = DikeProfileTestFactory.CreateDikeProfile(new Point2D(1, 1), "id2"); DikeProfile dikeProfile3 = DikeProfileTestFactory.CreateDikeProfile(new Point2D(2, 2), "id3"); failureMechanism.DikeProfiles.AddRange(new[] { dikeProfile1 }, filePath); // Event failureMechanism.DikeProfiles.AddRange(new[] { dikeProfile3, dikeProfile2 }, filePath); failureMechanism.DikeProfiles.Remove(dikeProfile1); // Result DikeProfile[] expectedDikeProfiles = { dikeProfile3, dikeProfile2 }; CollectionAssert.AreEqual(expectedDikeProfiles, failureMechanism.DikeProfiles); }
public void UpdateDikeProfilesWithImportedData_WithCurrentDikeProfilesAndImportedDataHasPartialOverlap_UpdatesTargetCollection() { // Setup const string addedDikeProfileId = "ID A"; const string removedDikeProfileId = "ID B"; const string updatedDikeProfileId = "ID C"; const string commonName = "Just a name for dike profile"; DikeProfile dikeProfileToBeRemoved = DikeProfileTestFactory.CreateDikeProfile(commonName, removedDikeProfileId); DikeProfile dikeProfileToBeUpdated = DikeProfileTestFactory.CreateDikeProfile(commonName, updatedDikeProfileId); var failureMechanism = new GrassCoverErosionInwardsFailureMechanism(); DikeProfileCollection dikeProfiles = failureMechanism.DikeProfiles; dikeProfiles.AddRange(new[] { dikeProfileToBeRemoved, dikeProfileToBeUpdated }, sourceFilePath); DikeProfile dikeProfileToUpdateFrom = DeepCloneAndModify(dikeProfileToBeUpdated); DikeProfile dikeProfileToBeAdded = DikeProfileTestFactory.CreateDikeProfile(commonName, addedDikeProfileId); DikeProfile[] readDikeProfiles = { dikeProfileToBeAdded, dikeProfileToUpdateFrom }; var strategy = new GrassCoverErosionInwardsDikeProfileUpdateDataStrategy(failureMechanism); // Call IEnumerable <IObservable> affectedObjects = strategy.UpdateDikeProfilesWithImportedData(readDikeProfiles, sourceFilePath); // Assert Assert.AreEqual(2, dikeProfiles.Count); DikeProfile[] expectedDikeProfiles = { dikeProfileToBeAdded, dikeProfileToBeUpdated }; CollectionAssert.AreEqual(expectedDikeProfiles, dikeProfiles); DikeProfile addedDikeProfile = dikeProfiles[0]; Assert.AreSame(dikeProfileToBeAdded, addedDikeProfile); AssertDikeProfile(dikeProfileToBeAdded, addedDikeProfile); DikeProfile updatedDikeProfile = dikeProfiles[1]; Assert.AreSame(dikeProfileToBeUpdated, updatedDikeProfile); AssertDikeProfile(dikeProfileToUpdateFrom, updatedDikeProfile); CollectionAssert.AreEquivalent(new IObservable[] { dikeProfileToBeUpdated, dikeProfiles }, affectedObjects); }
public void UpdateDikeProfilesWithImportedData_CollectionAndImportedDataCollectionNotEmpty_ReplacesCurrentWithImportedData() { // Setup DikeProfile targetDikeProfile = DikeProfileTestFactory.CreateDikeProfile("Name A", "Name A ID"); var failureMechanism = new GrassCoverErosionInwardsFailureMechanism(); failureMechanism.DikeProfiles.AddRange(new[] { targetDikeProfile }, sourceFilePath); DikeProfile readDikeProfile = DikeProfileTestFactory.CreateDikeProfile("Name B", "Name B ID"); var strategy = new GrassCoverErosionInwardsDikeProfileReplaceDataStrategy(failureMechanism); // Call IEnumerable <IObservable> affectedObjects = strategy.UpdateDikeProfilesWithImportedData(new[] { readDikeProfile }, sourceFilePath); // Assert CollectionAssert.AreEqual(new[] { failureMechanism.DikeProfiles }, affectedObjects); DikeProfile[] expectedDikeProfiles = { readDikeProfile }; CollectionAssert.AreEqual(expectedDikeProfiles, failureMechanism.DikeProfiles); }
public void Create_StringPropertiesDoNotShareReference() { // Setup const string originalId = "no_breakwater"; const string originalName = "Dike profile without break water."; var dikeProfile = new DikeProfile(new Point2D(1.1, 2.2), new RoughnessPoint[0], new Point2D[0], null, new DikeProfile.ConstructionProperties { Id = originalId, Name = originalName }); var registry = new PersistenceRegistry(); // Call DikeProfileEntity entity = dikeProfile.Create(registry, 0); // Assert Assert.AreNotSame(originalName, entity.Name, "To create stable binary representations/fingerprints, it's really important that strings are not shared."); Assert.AreEqual(originalName, entity.Name); Assert.AreNotSame(originalId, entity.Id, "To create stable binary representations/fingerprints, it's really important that strings are not shared."); Assert.AreEqual(originalId, entity.Id); }
public void ChildNodeObjects_Always_ReturnDikeProfiles() { // Setup var mocks = new MockRepository(); var assessmentSection = mocks.Stub <IAssessmentSection>(); mocks.ReplayAll(); DikeProfile dikeProfile1 = DikeProfileTestFactory.CreateDikeProfile(string.Empty, "id1"); DikeProfile dikeProfile2 = DikeProfileTestFactory.CreateDikeProfile(string.Empty, "id2"); var failureMechanism = new GrassCoverErosionInwardsFailureMechanism(); failureMechanism.DikeProfiles.AddRange(new[] { dikeProfile1, dikeProfile2 }, "path"); var dikeProfilesContext = new DikeProfilesContext(failureMechanism.DikeProfiles, failureMechanism, assessmentSection); // Call object[] children = info.ChildNodeObjects(dikeProfilesContext); // Assert Assert.AreEqual(2, children.Length); Assert.AreSame(dikeProfile1, children.ElementAt(0)); Assert.AreSame(dikeProfile2, children.ElementAt(1)); mocks.VerifyAll(); }
public void Data_SetDikeProfileInstanceWithData_ReturnCorrectPropertyValues() { // Setup DikeProfile dikeProfile = DikeProfileTestFactory.CreateDikeProfile(new[] { new RoughnessPoint(new Point2D(0, 0), 0.6), new RoughnessPoint(new Point2D(1, 1), 0.7) }); var properties = new DikeProfileDikeGeometryProperties(); // Call properties.Data = dikeProfile; // Assert var expectedCoordinates = new[] { new Point2D(0, 0), new Point2D(1, 1) }; CollectionAssert.AreEqual(expectedCoordinates, properties.Coordinates); var expectedRoughness = new[] { new RoundedDouble(2, 0.6) }; CollectionAssert.AreEqual(expectedRoughness, properties.Roughnesses); }
public void UpdateDikeProfilesWithImportedData_CurrentCollectionEmptyAndReadProfilesHaveDuplicateIds_ThrowsUpdateException() { // Setup const string duplicateId = "A duplicated ID"; DikeProfile dikeProfileOne = DikeProfileTestFactory.CreateDikeProfile("name one", duplicateId); DikeProfile dikeProfileTwo = DikeProfileTestFactory.CreateDikeProfile("Another dike profile", duplicateId); var targetCollection = new DikeProfileCollection(); var strategy = new GrassCoverErosionInwardsDikeProfileUpdateDataStrategy(new GrassCoverErosionInwardsFailureMechanism()); // Call void Call() => strategy.UpdateDikeProfilesWithImportedData(new[] { dikeProfileOne, dikeProfileTwo }, sourceFilePath); // Assert var exception = Assert.Throws <UpdateDataException>(Call); const string expectedMessage = "Geïmporteerde data moet unieke elementen bevatten."; Assert.AreEqual(expectedMessage, exception.Message); CollectionAssert.IsEmpty(targetCollection); }
public void NotifyObservers_DataUpdatedNotifyObserversOnOldData_NoUpdateInViewData() { // Setup using (var view = new GrassCoverErosionInwardsInputView()) { DikeProfile dikeProfile = GetDikeProfileWithGeometry(); var calculation1 = new GrassCoverErosionInwardsCalculation { InputParameters = { DikeProfile = dikeProfile } }; var calculation2 = new GrassCoverErosionInwardsCalculation(); view.Data = calculation1; ChartData dataBeforeUpdate = view.Chart.Data; view.Data = calculation2; DikeProfile dikeProfile2 = GetSecondDikeProfileWithGeometry(); calculation1.InputParameters.DikeProfile = dikeProfile2; // Call calculation1.InputParameters.NotifyObservers(); // Assert Assert.AreEqual(dataBeforeUpdate, view.Chart.Data); } }
public void IsDikeProfileIntersectionWithReferenceLineInSection_DikeProfileDoesNotIntersectReferenceLine_ReturnsFalse() { // Setup DikeProfile dikeProfile = DikeProfileTestFactory.CreateDikeProfile(new Point2D(0.0, 0.0)); var referenceLine = new ReferenceLine(); referenceLine.SetGeometry(new[] { new Point2D(10.0, 0.0), new Point2D(20.0, 0.0) }); var calculation = new GrassCoverErosionInwardsCalculationScenario { InputParameters = { DikeProfile = dikeProfile } }; IEnumerable <Segment2D> lineSegments = Math2D.ConvertPointsToLineSegments(referenceLine.Points); // Call bool intersects = calculation.IsDikeProfileIntersectionWithReferenceLineInSection(lineSegments); // Assert Assert.IsFalse(intersects); }
public void Data_SetChartData_ChartDataSet() { // Setup using (var view = new GrassCoverErosionInwardsInputView()) { DikeProfile dikeProfile = GetDikeProfileWithGeometry(); var calculation = new GrassCoverErosionInwardsCalculation { InputParameters = { DikeProfile = dikeProfile } }; // Call view.Data = calculation; // Assert Assert.AreSame(calculation, view.Data); ChartDataCollection chartData = view.Chart.Data; Assert.IsInstanceOf <ChartDataCollection>(chartData); Assert.AreEqual(3, chartData.Collection.Count()); AssertDikeProfileChartData(dikeProfile, chartData.Collection.ElementAt(dikeProfileIndex)); AssertForeshoreChartData(dikeProfile, chartData.Collection.ElementAt(foreshoreIndex)); AssertDikeHeightChartData(dikeProfile, chartData.Collection.ElementAt(dikeHeightIndex)); } }
public void Data_UseForeshoreFalse_SetEmptyForeshoreDataOnChart() { // Setup using (var view = new GrassCoverErosionInwardsInputView()) { DikeProfile dikeProfile = GetDikeProfileWithGeometry(); var calculation = new GrassCoverErosionInwardsCalculation { InputParameters = { DikeProfile = dikeProfile, UseForeshore = false } }; // Call view.Data = calculation; // Assert Assert.AreSame(calculation, view.Data); ChartDataCollection chartData = view.Chart.Data; Assert.IsInstanceOf <ChartDataCollection>(chartData); Assert.AreEqual(3, chartData.Collection.Count()); var dikeGeometryData = (ChartLineData)chartData.Collection.ElementAt(dikeProfileIndex); var foreshoreData = (ChartLineData)chartData.Collection.ElementAt(foreshoreIndex); var dikeHeightData = (ChartLineData)chartData.Collection.ElementAt(dikeHeightIndex); CollectionAssert.IsEmpty(foreshoreData.Points); Assert.AreEqual("Voorlandprofiel", foreshoreData.Name); AssertDikeProfileChartData(dikeProfile, dikeGeometryData); AssertDikeHeightChartData(dikeProfile, dikeHeightData); } }
/// <summary> /// Removes the <see cref="DikeProfile"/> and clears all the data that depends on it, either directly or indirectly. /// </summary> /// <param name="dikeProfileToRemove">The dike profile to remove.</param> /// <param name="calculations">The calculations that may have /// <paramref name="dikeProfileToRemove"/> assigned.</param> /// <param name="dikeProfiles">The collection of <see cref="DikeProfile"/> in /// which <paramref name="dikeProfileToRemove"/> is contained.</param> /// <returns>An <see cref="IEnumerable{T}"/> of all affected objects by this operation.</returns> /// <exception cref="ArgumentNullException">Thrown when any input argument is <c>null</c>.</exception> public static IEnumerable <IObservable> RemoveDikeProfile(DikeProfile dikeProfileToRemove, IEnumerable <GrassCoverErosionInwardsCalculation> calculations, DikeProfileCollection dikeProfiles) { if (dikeProfileToRemove == null) { throw new ArgumentNullException(nameof(dikeProfileToRemove)); } if (calculations == null) { throw new ArgumentNullException(nameof(calculations)); } if (dikeProfiles == null) { throw new ArgumentNullException(nameof(dikeProfiles)); } IEnumerable <GrassCoverErosionInwardsCalculation> affectedCalculations = calculations.Where(calc => ReferenceEquals(dikeProfileToRemove, calc.InputParameters.DikeProfile)); var affectedObjects = new List <IObservable> { dikeProfiles }; affectedObjects.AddRange(ClearDikeProfileDependentData(affectedCalculations)); dikeProfiles.Remove(dikeProfileToRemove); return(affectedObjects); }
/// <summary> /// Creates a <see cref="DikeProfileEntity"/> based on the information of the <see cref="DikeProfile"/>. /// </summary> /// <param name="dikeProfile">The dike profile to create a database entity for.</param> /// <param name="registry">The object keeping track of create operations.</param> /// <param name="order">Index at which this instance resides inside its parent container.</param> /// <returns>A new <see cref="DikeProfileEntity"/>.</returns> /// <exception cref="ArgumentNullException">Thrown when <paramref name="registry"/> is <c>null</c>.</exception> internal static DikeProfileEntity Create(this DikeProfile dikeProfile, PersistenceRegistry registry, int order) { if (registry == null) { throw new ArgumentNullException(nameof(registry)); } if (registry.Contains(dikeProfile)) { return(registry.Get(dikeProfile)); } var sectionResultEntity = new DikeProfileEntity { X = dikeProfile.WorldReferencePoint.X, Y = dikeProfile.WorldReferencePoint.Y, X0 = dikeProfile.X0, DikeGeometryXml = new RoughnessPointCollectionXmlSerializer().ToXml(dikeProfile.DikeGeometry), ForeshoreXml = new Point2DCollectionXmlSerializer().ToXml(dikeProfile.ForeshoreGeometry), Orientation = dikeProfile.Orientation, DikeHeight = dikeProfile.DikeHeight, Id = dikeProfile.Id.DeepClone(), Name = dikeProfile.Name.DeepClone(), Order = order }; if (dikeProfile.HasBreakWater) { sectionResultEntity.BreakWaterHeight = dikeProfile.BreakWater.Height; sectionResultEntity.BreakWaterType = Convert.ToByte(dikeProfile.BreakWater.Type); } registry.Register(sectionResultEntity, dikeProfile); return(sectionResultEntity); }
public void GenerateCalculations_Always_SetsCorrectCalculations() { // Setup var calculationGroup = new CalculationGroup(); DikeProfile dikeProfile1 = DikeProfileTestFactory.CreateDikeProfile(new Point2D(0.0, 0.0), "profiel 1"); DikeProfile dikeProfile2 = DikeProfileTestFactory.CreateDikeProfile(new Point2D(0.0, 0.0), "profiel 2"); var failureMechanismContribution = new FailureMechanismContribution(0.01, 0.001); // Call GrassCoverErosionInwardsCalculationConfigurationHelper.GenerateCalculations( calculationGroup, new[] { dikeProfile1, dikeProfile2 }, failureMechanismContribution); // Assert Assert.AreEqual(2, calculationGroup.Children.Count); var calculation1 = (GrassCoverErosionInwardsCalculationScenario)calculationGroup.Children.First(); Assert.AreEqual("name", calculation1.Name); Assert.AreEqual(dikeProfile1, calculation1.InputParameters.DikeProfile); Assert.AreEqual(failureMechanismContribution.NormativeProbability, calculation1.InputParameters.DikeHeightTargetProbability); Assert.AreEqual(failureMechanismContribution.NormativeProbability, calculation1.InputParameters.OvertoppingRateTargetProbability); var calculation2 = (GrassCoverErosionInwardsCalculationScenario)calculationGroup.Children.Last(); Assert.AreEqual("name (1)", calculation2.Name); Assert.AreEqual(dikeProfile2, calculation2.InputParameters.DikeProfile); Assert.AreEqual(failureMechanismContribution.NormativeProbability, calculation2.InputParameters.DikeHeightTargetProbability); Assert.AreEqual(failureMechanismContribution.NormativeProbability, calculation2.InputParameters.OvertoppingRateTargetProbability); }
public void UpdateDikeProfilesWithImportedData_WithCurrentDikeProfileAndImportedMultipleDikeProfilesWithSameId_ThrowsUpdateException() { // Setup const string duplicateId = "A duplicated ID"; DikeProfile expectedDikeProfile = DikeProfileTestFactory.CreateDikeProfile("expectedName", duplicateId); var targetCollection = new DikeProfileCollection(); DikeProfile[] expectedTargetCollection = { expectedDikeProfile }; targetCollection.AddRange(expectedTargetCollection, sourceFilePath); DikeProfile[] importedTargetCollection = { DeepCloneAndModify(expectedDikeProfile), DeepCloneAndModify(expectedDikeProfile) }; var strategy = new GrassCoverErosionInwardsDikeProfileUpdateDataStrategy(new GrassCoverErosionInwardsFailureMechanism()); // Call void Call() => strategy.UpdateDikeProfilesWithImportedData(importedTargetCollection, sourceFilePath); // Assert var exception = Assert.Throws <UpdateDataException>(Call); const string expectedMessage = "Geïmporteerde data moet unieke elementen bevatten."; Assert.AreEqual(expectedMessage, exception.Message); CollectionAssert.AreEqual(expectedTargetCollection, targetCollection); AssertDikeProfile(expectedDikeProfile, targetCollection[0]); }
public void IsDikeProfileIntersectionWithReferenceLineInSection_EmptySegmentCollection_ThrowsInvalidOperationException() { // Setup DikeProfile dikeProfile = DikeProfileTestFactory.CreateDikeProfile(new Point2D(0.0, 0.0)); var referenceLine = new ReferenceLine(); referenceLine.SetGeometry(new[] { new Point2D(0.0, 0.0), new Point2D(10.0, 0.0) }); var calculation = new GrassCoverErosionInwardsCalculationScenario { InputParameters = { DikeProfile = dikeProfile } }; // Call void Call() => calculation.IsDikeProfileIntersectionWithReferenceLineInSection(Enumerable.Empty <Segment2D>()); // Assert Assert.Throws <InvalidOperationException>(Call); }
public void Import_UseForeshoreButProfileWithoutGeometry_LogMessageAndContinueImport() { // Setup string filePath = Path.Combine(importerPath, "validConfigurationCalculationUseForeshoreWithoutGeometry.xml"); var calculationGroup = new CalculationGroup(); DikeProfile dikeProfile = DikeProfileTestFactory.CreateDikeProfile("Dijkprofiel", "Dijkprofiel ID"); var importer = new GrassCoverErosionInwardsCalculationConfigurationImporter( filePath, calculationGroup, new FailureMechanismContribution(0.01, 0.001), Enumerable.Empty <HydraulicBoundaryLocation>(), new[] { dikeProfile }); // Call var successful = false; void Call() => successful = importer.Import(); // Assert const string expectedMessage = "Het opgegeven dijkprofiel 'Dijkprofiel ID' heeft geen voorlandgeometrie en kan daarom niet gebruikt worden. Berekening 'Berekening 1' is overgeslagen."; TestHelper.AssertLogMessageIsGenerated(Call, expectedMessage, 2); Assert.IsTrue(successful); CollectionAssert.IsEmpty(calculationGroup.Children); }
public void UpdateDikeProfilesWithImportedData_DikeProfilePropertiesChanged_UpdateRelevantProperties() { // Setup DikeProfile dikeProfileToUpdate = DikeProfileTestFactory.CreateDikeProfile("name", "ID A"); DikeProfile dikeProfileToUpdateFrom = DeepCloneAndModify(dikeProfileToUpdate); var failureMechanism = new GrassCoverErosionInwardsFailureMechanism(); DikeProfileCollection targetCollection = failureMechanism.DikeProfiles; targetCollection.AddRange(new[] { dikeProfileToUpdate }, sourceFilePath); var strategy = new GrassCoverErosionInwardsDikeProfileUpdateDataStrategy(failureMechanism); // Call strategy.UpdateDikeProfilesWithImportedData(new[] { dikeProfileToUpdateFrom }, sourceFilePath); // Assert Assert.AreSame(dikeProfileToUpdate, targetCollection[0]); AssertDikeProfile(dikeProfileToUpdateFrom, dikeProfileToUpdate); }
public void Constructor_Always_PropertiesHaveExpectedAttributesValues() { // Setup DikeProfile dikeProfile = DikeProfileTestFactory.CreateDikeProfile(); // Call var properties = new DikeProfileDikeGeometryProperties { Data = dikeProfile }; // Assert PropertyDescriptorCollection dynamicProperties = PropertiesTestHelper.GetAllVisiblePropertyDescriptors(properties); Assert.AreEqual(2, dynamicProperties.Count); PropertyDescriptor coordinatesProperty = dynamicProperties[coordinatesPropertyIndex]; PropertiesTestHelper.AssertRequiredPropertyDescriptorProperties(coordinatesProperty, "Misc", "Coördinaten [m]", "Lijst met punten in lokale coördinaten.", true); PropertyDescriptor roughnessesProperty = dynamicProperties[roughnessesPropertyIndex]; PropertiesTestHelper.AssertRequiredPropertyDescriptorProperties(roughnessesProperty, "Misc", "Ruwheid invloedsfactoren [-]", "Lijst met invloedsfactoren voor ruwheid op het talud van elk onderdeel.", true); }
public void Data_SetNewDikeProfileInstance_ReturnCorrectPropertyValues() { // Setup const string id = "DP"; const string name = "Dijkprofiel"; var dikeProfile = new DikeProfile( new Point2D(12.34, 56.78), Enumerable.Empty <RoughnessPoint>(), Enumerable.Empty <Point2D>(), new BreakWater(BreakWaterType.Caisson, 2), new DikeProfile.ConstructionProperties { Id = id, Name = name }); // Call var properties = new DikeProfileProperties { Data = dikeProfile }; // Assert Assert.AreEqual(new Point2D(12, 57), properties.WorldReferencePoint); Assert.AreEqual(id, properties.Id); Assert.AreEqual(name, properties.Name); Assert.AreEqual(2, properties.Orientation.NumberOfDecimalPlaces); Assert.AreEqual(0.0, properties.Orientation.Value); Assert.AreSame(dikeProfile.ForeshoreProfile, properties.BreakWater.Data); Assert.AreSame(dikeProfile.ForeshoreProfile, properties.Foreshore.Data); Assert.AreSame(dikeProfile, properties.DikeGeometry.Data); Assert.AreEqual(2, properties.DikeHeight.NumberOfDecimalPlaces); Assert.AreEqual(0.0, properties.DikeHeight.Value); }
public void CopyProperties_FromDikeProfileAllPropertiesChanged_PropertiesUpdated() { // Setup DikeProfile dikeProfileToUpdate = CreateFullyDefinedDikeProfile(); const string expectedId = "new_id"; const string expectedName = "new_name"; var random = new Random(21); double expectedX0 = dikeProfileToUpdate.X0 + random.NextDouble(); var expectedOrientation = new RoundedDouble(2, (dikeProfileToUpdate.Orientation + random.NextDouble()) % 360); var expectedDikeHeight = new RoundedDouble(2, dikeProfileToUpdate.DikeHeight + random.NextDouble()); double expectedBreakWaterHeight = dikeProfileToUpdate.BreakWater.Height + random.NextDouble(); var expectedBreakWater = new BreakWater(random.NextEnumValue <BreakWaterType>(), expectedBreakWaterHeight); var expectedForeshoreGeometry = new[] { new Point2D(10, 10), new Point2D(15, 10) }; var expectedDikeGeometry = new[] { new RoughnessPoint(new Point2D(10, 10), 1), new RoughnessPoint(new Point2D(15, 10), 2) }; var expectedWorldReferencePoint = new Point2D(13, 37); var dikeProfileToUpdateFrom = new DikeProfile(expectedWorldReferencePoint, expectedDikeGeometry, expectedForeshoreGeometry, expectedBreakWater, new DikeProfile.ConstructionProperties { Id = expectedId, Name = expectedName, X0 = expectedX0, Orientation = expectedOrientation, DikeHeight = expectedDikeHeight }); // Call dikeProfileToUpdate.CopyProperties(dikeProfileToUpdateFrom); // Assert TestHelper.AssertAreEqualButNotSame(expectedWorldReferencePoint, dikeProfileToUpdate.WorldReferencePoint); CollectionAssert.AreEqual(expectedForeshoreGeometry, dikeProfileToUpdate.ForeshoreGeometry); TestHelper.AssertCollectionAreNotSame(expectedForeshoreGeometry, dikeProfileToUpdate.ForeshoreGeometry); CollectionAssert.AreEqual(expectedDikeGeometry, dikeProfileToUpdate.DikeGeometry); TestHelper.AssertCollectionAreNotSame(expectedDikeGeometry, dikeProfileToUpdate.DikeGeometry); TestHelper.AssertAreEqualButNotSame(expectedBreakWater, dikeProfileToUpdate.BreakWater); Assert.AreEqual(expectedId, dikeProfileToUpdate.Id); Assert.AreEqual(expectedName, dikeProfileToUpdate.Name); Assert.AreEqual(expectedX0, dikeProfileToUpdate.X0); Assert.AreEqual(expectedOrientation, dikeProfileToUpdate.Orientation); Assert.AreEqual(expectedDikeHeight, dikeProfileToUpdate.DikeHeight); }
private static IEnumerable <Point2D> GetWorldPoints(DikeProfile dikeProfile) { return(AdvancedMath2D.FromXToXY( dikeProfile.DikeGeometry.Select(p => - p.Point.X), dikeProfile.WorldReferencePoint, -dikeProfile.X0, dikeProfile.Orientation)); }
/// <summary> /// Updates the name of <paramref name="chartData"/> based on <paramref name="dikeProfile"/>. /// </summary> /// <param name="chartData">The <see cref="ChartLineData"/> to update the name for.</param> /// <param name="dikeProfile">The <see cref="DikeProfile"/> used for obtaining the name.</param> /// <remarks>A default name is set (the same as in <see cref="CreateDikeGeometryChartData"/>) when <paramref name="dikeProfile"/> is <c>null</c>.</remarks> public static void UpdateDikeGeometryChartDataName(ChartLineData chartData, DikeProfile dikeProfile) { chartData.Name = dikeProfile != null ? string.Format(RiskeerCommonFormsResources.ChartDataFactory_Create_DataIdentifier_0_DataTypeDisplayName_1_, dikeProfile.Name, Resources.DikeProfile_DisplayName) : Resources.DikeProfile_DisplayName; }
private static void AddEntitiesForDikeProfiles(GrassCoverErosionInwardsFailureMechanism mechanism, PersistenceRegistry registry, FailureMechanismEntity entity) { for (var i = 0; i < mechanism.DikeProfiles.Count; i++) { DikeProfile dikeProfile = mechanism.DikeProfiles[i]; entity.DikeProfileEntities.Add(dikeProfile.Create(registry, i)); } }
public void Import_AllOkTestData_CorrectDikeProfileProperties() { // Setup var messageProvider = mocks.Stub <IImporterMessageProvider>(); mocks.ReplayAll(); string filePath = TestHelper.GetTestDataPath(TestDataPath.Riskeer.Common.IO, Path.Combine("DikeProfiles", "AllOkTestData", "Voorlanden 12-2.shp")); ReferenceLine referenceLine = CreateMatchingReferenceLine(); var updateDataStrategy = new TestDikeProfileUpdateStrategy(); var dikeProfilesImporter = new DikeProfilesImporter(new DikeProfileCollection(), referenceLine, filePath, updateDataStrategy, messageProvider); // Call dikeProfilesImporter.Import(); // Assert Assert.IsTrue(updateDataStrategy.Updated); DikeProfile[] dikeProfiles = updateDataStrategy.ReadDikeProfiles; DikeProfile dikeProfile1 = dikeProfiles[0]; Assert.AreEqual("profiel001", dikeProfile1.Id); Assert.AreEqual("profiel001", dikeProfile1.Name); DikeProfile dikeProfile2 = dikeProfiles[1]; Assert.AreEqual("profiel002", dikeProfile2.Id); Assert.AreEqual("profiel002", dikeProfile2.Name); DikeProfile dikeProfile3 = dikeProfiles[2]; Assert.AreEqual("profiel003", dikeProfile3.Id); Assert.AreEqual("profiel003", dikeProfile3.Name); DikeProfile dikeProfile4 = dikeProfiles[3]; Assert.AreEqual(new Point2D(136432.12250000238, 538235.26300000318), dikeProfile4.WorldReferencePoint); Assert.AreEqual("profiel004", dikeProfile4.Id); Assert.AreEqual("Valide naam", dikeProfile4.Name); Assert.AreEqual(-17.93475471, dikeProfile4.X0); Assert.AreEqual(330.0, dikeProfile4.Orientation, dikeProfile4.Orientation.GetAccuracy()); Assert.IsFalse(dikeProfile4.HasBreakWater); DikeProfile dikeProfile5 = dikeProfiles[4]; Assert.AreEqual(new Point2D(136039.49100000039, 533920.28050000477), dikeProfile5.WorldReferencePoint); Assert.AreEqual("profiel005", dikeProfile5.Id); Assert.AreEqual("Heeeeeeeeeeeeeeeeeeeeeeeele laaaaaaaaaaaaaaaaaaaange naaaaaaaaaaam", dikeProfile5.Name); Assert.AreEqual(15.56165507, dikeProfile5.X0); Assert.AreEqual(330.0, dikeProfile5.Orientation, dikeProfile5.Orientation.GetAccuracy()); Assert.IsTrue(dikeProfile5.HasBreakWater); Assert.AreEqual(6.0, dikeProfile5.DikeHeight, dikeProfile5.DikeHeight.GetAccuracy()); }
public void DikeProfile_AlwaysOnChange_NotifyObserverAndCalculationPropertyChanged() { // Setup DikeProfile newProfile = DikeProfileTestFactory.CreateDikeProfile(new Point2D(0.0, 0.0)); var newValue = new DataGridViewComboBoxItemWrapper <DikeProfile>(newProfile); var calculation = new GrassCoverErosionInwardsCalculationScenario(); // Call & Assert SetPropertyAndVerifyNotificationsAndOutputForCalculation(row => row.DikeProfile = newValue, calculation); }
public void DikeProfile_SetNewValue_InputSyncedAccordingly(DikeProfile newDikeProfile) { // Setup var input = new GrassCoverErosionInwardsInput(); // Call input.DikeProfile = newDikeProfile; // Assert AssertDikeProfileInput(newDikeProfile, input); }
public void BreakWater_SetToNull_GetsNewlySetNull() { // Call var dikeProfile = new DikeProfile(new Point2D(0, 0), new RoughnessPoint[0], new Point2D[0], null, new DikeProfile.ConstructionProperties { Id = "id" }); // Assert Assert.IsNull(dikeProfile.BreakWater); }
private void SetChartData() { GrassCoverErosionInwardsInput input = data.InputParameters; DikeProfile dikeProfile = input.DikeProfile; GrassCoverErosionInwardsChartDataFactory.UpdateForeshoreGeometryChartDataName(foreshoreChartData, input); GrassCoverErosionInwardsChartDataFactory.UpdateDikeGeometryChartDataName(dikeGeometryChartData, dikeProfile); foreshoreChartData.Points = GrassCoverErosionInwardsChartDataPointsFactory.CreateForeshoreGeometryPoints(input); dikeGeometryChartData.Points = GrassCoverErosionInwardsChartDataPointsFactory.CreateDikeGeometryPoints(dikeProfile); dikeHeightChartData.Points = GrassCoverErosionInwardsChartDataPointsFactory.CreateDikeHeightPoints(input); }
public void Text_Always_ReturnDikeProfileName() { // Setup const string profileName = "Random profile name"; DikeProfile dikeProfile = DikeProfileTestFactory.CreateDikeProfile(profileName); // Call string text = info.Text(dikeProfile); // Assert Assert.AreEqual(profileName, text); }