public void Read_EmptyGeometryBreakWaterTypeAndNullableValuesAreNull_ForeshoreProfileWithoutBreakWaterNaNValues() { // Setup const string name = "testName"; const string id = "testId"; string pointXml = new Point2DCollectionXmlSerializer().ToXml(Enumerable.Empty <Point2D>()); var entity = new ForeshoreProfileEntity { Id = id, Name = name, GeometryXml = pointXml }; var readConversionCollector = new ReadConversionCollector(); // Call ForeshoreProfile foreshoreProfile = entity.Read(readConversionCollector); // Assert Assert.IsNotNull(foreshoreProfile); Assert.AreEqual(id, foreshoreProfile.Id); Assert.AreEqual(name, foreshoreProfile.Name); Assert.IsNaN(foreshoreProfile.Orientation); Assert.IsNaN(foreshoreProfile.X0); Assert.IsNull(foreshoreProfile.BreakWater); Assert.IsFalse(foreshoreProfile.HasBreakWater); CollectionAssert.IsEmpty(foreshoreProfile.Geometry); }
public void UpdateForeshoreProfilesWithImportedData_ForeshoreProfilePropertiesChanged_UpdateRelevantProperties( ForeshoreProfile readForeshoreProfile) { // Setup var profileToBeUpdated = new TestForeshoreProfile(); var targetCollection = new ForeshoreProfileCollection(); targetCollection.AddRange(new[] { profileToBeUpdated }, sourceFilePath); var strategy = new ForeshoreProfileUpdateDataStrategy(new TestCalculatableFailureMechanism(), targetCollection); // Call strategy.UpdateForeshoreProfilesWithImportedData(new[] { readForeshoreProfile }, sourceFilePath); // Assert Assert.AreEqual(1, targetCollection.Count); Assert.AreSame(profileToBeUpdated, targetCollection[0]); AssertForeshoreProfile(readForeshoreProfile, profileToBeUpdated); }
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 Create_WithSimpleProperties_ReturnsForeshoreProfileWithSimplePropertiesSet() { // Setup const string name = "testName"; const string id = "fpid"; var random = new Random(21); int order = random.Next(); double orientation = random.NextDouble(); double x0 = random.NextDouble(); var foreshoreProfile = new ForeshoreProfile(new Point2D(0, 0), Enumerable.Empty <Point2D>(), null, new ForeshoreProfile.ConstructionProperties { Id = id, Name = name, Orientation = orientation, X0 = x0 }); var registry = new PersistenceRegistry(); // Call ForeshoreProfileEntity entity = foreshoreProfile.Create(registry, order); // Assert Assert.IsNotNull(entity); Assert.AreEqual(order, entity.Order); Assert.AreEqual(id, entity.Id); Assert.AreEqual(name, entity.Name); Assert.AreEqual(orientation, entity.Orientation, foreshoreProfile.Orientation.GetAccuracy()); Assert.AreEqual(x0, entity.X0); Assert.IsNull(entity.BreakWaterType); Assert.IsNull(entity.BreakWaterHeight); }
public void Constructor_ValidParameters_ExpectedValues() { // Setup const string validId = "id"; var worldCoordinate = new Point2D(1.1, 2.2); var foreshoreGeometry = new[] { new Point2D(0.0, 1.1), new Point2D(8.0, 9.1) }; // Call var foreshoreProfile = new ForeshoreProfile(worldCoordinate, foreshoreGeometry, null, new ForeshoreProfile.ConstructionProperties { Id = validId }); // Assert Assert.IsInstanceOf <Observable>(foreshoreProfile); Assert.IsInstanceOf <RoundedDouble>(foreshoreProfile.Orientation); Assert.IsInstanceOf <double>(foreshoreProfile.X0); Assert.AreEqual(validId, foreshoreProfile.Id); Assert.AreEqual(validId, foreshoreProfile.Name); Assert.AreSame(worldCoordinate, foreshoreProfile.WorldReferencePoint); Assert.AreEqual(0.0, foreshoreProfile.X0); Assert.AreEqual(0.0, foreshoreProfile.Orientation.Value); Assert.AreEqual(2, foreshoreProfile.Orientation.NumberOfDecimalPlaces); Assert.IsNull(foreshoreProfile.BreakWater); CollectionAssert.AreEqual(foreshoreGeometry, foreshoreProfile.Geometry); Assert.AreEqual(2, foreshoreProfile.Geometry.NumberOfDecimalPlaces); }
/// <summary> /// Makes a deep clone of the foreshore profile and modifies all the properties, /// except the <see cref="ForeshoreProfile.Id"/>. /// </summary> /// <param name="foreshoreProfile">The foreshore profile to deep clone.</param> /// <returns>A deep clone of the <paramref name="foreshoreProfile"/>.</returns> private static ForeshoreProfile DeepCloneAndModify(ForeshoreProfile foreshoreProfile) { var random = new Random(21); Point2D originalWorldCoordinate = foreshoreProfile.WorldReferencePoint; var modifiedWorldCoordinate = new Point2D(originalWorldCoordinate.X + random.NextDouble(), originalWorldCoordinate.Y + random.NextDouble()); List <Point2D> modifiedForeshoreGeometry = foreshoreProfile.Geometry.ToList(); modifiedForeshoreGeometry.Add(new Point2D(1, 2)); RoundedDouble originalBreakWaterHeight = foreshoreProfile.BreakWater?.Height ?? (RoundedDouble)0.0; var modifiedBreakWater = new BreakWater(random.NextEnumValue <BreakWaterType>(), originalBreakWaterHeight + random.NextDouble()); string modifiedName = $"new_name_{foreshoreProfile.Name}"; double modifiedOrientation = foreshoreProfile.Orientation + random.NextDouble(); double modifiedX0 = foreshoreProfile.X0 + random.NextDouble(); return(new ForeshoreProfile(modifiedWorldCoordinate, modifiedForeshoreGeometry, modifiedBreakWater, new ForeshoreProfile.ConstructionProperties { Name = modifiedName, Id = foreshoreProfile.Id, Orientation = modifiedOrientation, X0 = modifiedX0 })); }
public void TryReadForeshoreProfile_WithForeshoreProfileToFindForeshoreProfilesEmpty_LogsErrorReturnsFalse() { // Setup string filePath = Path.Combine(readerPath, "validConfiguration.xml"); var calculationGroup = new CalculationGroup(); var importer = new CalculationConfigurationImporter(filePath, calculationGroup); ForeshoreProfile profile = null; var valid = true; const string profileName = "someName"; const string calculationName = "name"; // Call void Validate() => valid = importer.PublicTryReadForeshoreProfile( profileName, calculationName, Enumerable.Empty<ForeshoreProfile>(), out profile); // Assert var expectedMessage = $"Het voorlandprofiel met ID '{profileName}' bestaat niet. Berekening '{calculationName}' is overgeslagen."; TestHelper.AssertLogMessageWithLevelIsGenerated(Validate, Tuple.Create(expectedMessage, LogLevelConstant.Error)); Assert.IsFalse(valid); Assert.IsNull(profile); }
public void SynchronizeForeshoreProfileInput_ChangedForeshoreProfile_ExpectedValues() { // Setup var differentProfile = new ForeshoreProfile(new Point2D(9, 9), new[] { new Point2D(3.3, 4.4), new Point2D(5.5, 6.6) }, new BreakWater(BreakWaterType.Caisson, 2), new ForeshoreProfile.ConstructionProperties { Id = "id", Name = "Some name", Orientation = 123.0 }); var input = new WaveConditionsInput { ForeshoreProfile = new TestForeshoreProfile() }; input.ForeshoreProfile.CopyProperties(differentProfile); // Precondition AssertForeshoreProfileInputProperties(new TestForeshoreProfile(), input); // Call input.SynchronizeForeshoreProfileInput(); // Assert AssertForeshoreProfileInputProperties(differentProfile, input); }
private static void AssertForeshoreProfilePropertiesOfInput(ForeshoreProfile expectedForeshoreProfile, SimpleStructuresInput input) { var defaultInput = new SimpleStructuresInput(); if (expectedForeshoreProfile == null) { Assert.AreEqual(defaultInput.UseBreakWater, input.UseBreakWater); Assert.AreEqual(defaultInput.UseForeshore, input.UseForeshore); } else { Assert.AreEqual(expectedForeshoreProfile.Geometry.Count() > 1, input.UseForeshore); Assert.AreEqual(expectedForeshoreProfile.HasBreakWater, input.UseBreakWater); } if (expectedForeshoreProfile?.BreakWater == null) { Assert.AreEqual(defaultInput.BreakWater.Type, input.BreakWater.Type); Assert.AreEqual(defaultInput.BreakWater.Height, input.BreakWater.Height); } else { Assert.AreEqual(expectedForeshoreProfile.BreakWater.Type, input.BreakWater.Type); Assert.AreEqual(expectedForeshoreProfile.BreakWater.Height, input.BreakWater.Height); } }
public void Create_StringPropertiesDoNotShareReference() { // Setup const string testName = "original name"; const string testId = "test id"; var foreshoreProfile = new ForeshoreProfile(new Point2D(0, 0), Enumerable.Empty <Point2D>(), null, new ForeshoreProfile.ConstructionProperties { Id = testId, Name = testName }); var registry = new PersistenceRegistry(); // Call ForeshoreProfileEntity entity = foreshoreProfile.Create(registry, 0); // Assert Assert.AreNotSame(testName, entity.Name, "To create stable binary representations/fingerprints, it's really important that strings are not shared."); Assert.AreEqual(testName, entity.Name); Assert.AreNotSame(testId, entity.Id, "To create stable binary representations/fingerprints, it's really important that strings are not shared."); Assert.AreEqual(testId, entity.Id); }
/// <summary> /// Read the <see cref="ForeshoreProfileEntity"/> and use the information to construct a <see cref="ForeshoreProfile"/>. /// </summary> /// <param name="entity">The <see cref="ForeshoreProfileEntity"/> to create <see cref="ForeshoreProfile"/> for.</param> /// <param name="collector">The object keeping track of read operations.</param> /// <returns>A new <see cref="ForeshoreProfile"/>.</returns> /// <exception cref="ArgumentNullException">Thrown when <paramref name="collector"/> is <c>null</c>.</exception> /// <exception cref="ArgumentException">Thrown when <see cref="ForeshoreProfileEntity.GeometryXml"/> /// of <paramref name="entity"/> is <c>null</c> or empty.</exception> internal static ForeshoreProfile Read(this ForeshoreProfileEntity entity, ReadConversionCollector collector) { if (collector == null) { throw new ArgumentNullException(nameof(collector)); } if (collector.Contains(entity)) { return(collector.Get(entity)); } Point2D[] points = new Point2DCollectionXmlSerializer().FromXml(entity.GeometryXml); var foreshoreProfile = new ForeshoreProfile(new Point2D(entity.X.ToNullAsNaN(), entity.Y.ToNullAsNaN()), points, CreateBreakWater(entity.BreakWaterType, entity.BreakWaterHeight), new ForeshoreProfile.ConstructionProperties { Id = entity.Id.DeepClone(), Name = entity.Name.DeepClone(), Orientation = entity.Orientation.ToNullAsNaN(), X0 = entity.X0.ToNullAsNaN() }); collector.Read(entity, foreshoreProfile); return(foreshoreProfile); }
public void Data_SetNewForeshoreProfileInstance_ReturnCorrectPropertyValues() { // Setup const string id = "VP"; const string name = "Voorlandprofiel"; var foreshoreProfile = new ForeshoreProfile(new Point2D(12.34, 56.78), new Point2D[0], null, new ForeshoreProfile.ConstructionProperties { Id = id, Name = name }); // Call var properties = new ForeshoreProfileProperties { Data = foreshoreProfile }; // 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(foreshoreProfile, properties.BreakWater.Data); Assert.AreEqual(foreshoreProfile, properties.Foreshore.Data); }
/// <summary> /// Creates a <see cref="ForeshoreProfileEntity"/> based on the information of the <see cref="ForeshoreProfile"/>. /// </summary> /// <param name="foreshoreProfile">The foreshore profile to create a database entity for.</param> /// <param name="registry">The object keeping track of create operations.</param> /// <param name="order">The index at which <paramref name="foreshoreProfile"/> resides within its parent.</param> /// <returns>A new <see cref="ForeshoreProfileEntity"/>.</returns> /// <exception cref="ArgumentNullException">Thrown when <paramref name="registry"/> is <c>null</c>.</exception> internal static ForeshoreProfileEntity Create(this ForeshoreProfile foreshoreProfile, PersistenceRegistry registry, int order) { if (registry == null) { throw new ArgumentNullException(nameof(registry)); } if (registry.Contains(foreshoreProfile)) { return(registry.Get(foreshoreProfile)); } var foreshoreProfileEntity = new ForeshoreProfileEntity { Id = foreshoreProfile.Id.DeepClone(), Name = foreshoreProfile.Name.DeepClone(), GeometryXml = new Point2DCollectionXmlSerializer().ToXml(foreshoreProfile.Geometry), X = foreshoreProfile.WorldReferencePoint.X, Y = foreshoreProfile.WorldReferencePoint.Y, X0 = foreshoreProfile.X0, Orientation = foreshoreProfile.Orientation, Order = order }; if (foreshoreProfile.HasBreakWater) { foreshoreProfileEntity.BreakWaterHeight = foreshoreProfile.BreakWater.Height; foreshoreProfileEntity.BreakWaterType = Convert.ToByte(foreshoreProfile.BreakWater.Type); } registry.Register(foreshoreProfileEntity, foreshoreProfile); return(foreshoreProfileEntity); }
private static void AssertForeshoreProfileInputProperties(ForeshoreProfile expectedForeshoreProfile, WaveConditionsInput input) { var defaultInput = new WaveConditionsInput(); if (expectedForeshoreProfile == null) { Assert.AreEqual(defaultInput.UseBreakWater, input.UseBreakWater); Assert.AreEqual(defaultInput.UseForeshore, input.UseForeshore); } else { Assert.AreEqual(expectedForeshoreProfile.Orientation, input.Orientation); Assert.AreEqual(expectedForeshoreProfile.Geometry.Count() > 1, input.UseForeshore); Assert.AreEqual(expectedForeshoreProfile.HasBreakWater, input.UseBreakWater); } if (expectedForeshoreProfile?.BreakWater == null) { Assert.AreEqual(defaultInput.BreakWater.Type, input.BreakWater.Type); Assert.AreEqual(defaultInput.BreakWater.Height, input.BreakWater.Height); } else { Assert.AreEqual(expectedForeshoreProfile.BreakWater.Type, input.BreakWater.Type); Assert.AreEqual(expectedForeshoreProfile.BreakWater.Height, input.BreakWater.Height); } }
public void UpdateForeshoreProfilesWithImportedData_MultipleCalculationsWithOutputAndProfile_UpdatesCalculationWithUpdatedProfile() { // Setup var affectedProfile = new TestForeshoreProfile("Name", "Updated ID"); TestCalculationWithForeshoreProfile affectedCalculation = TestCalculationWithForeshoreProfile.CreateCalculationWithOutput(affectedProfile); ForeshoreProfile profileToUpdateFrom = DeepCloneAndModify(affectedProfile); const string unaffectedProfileId = "Unaffected ID"; const string unaffectedProfileName = "Name"; var unaffectedProfile = new TestForeshoreProfile(unaffectedProfileName, unaffectedProfileId); TestCalculationWithForeshoreProfile unaffectedCalculation = TestCalculationWithForeshoreProfile.CreateCalculationWithOutput(unaffectedProfile); var foreshoreProfiles = new ForeshoreProfileCollection(); TestForeshoreProfile[] originalForeshoreProfiles = { affectedProfile, unaffectedProfile }; foreshoreProfiles.AddRange(originalForeshoreProfiles, sourceFilePath); var failureMechanism = new TestCalculatableFailureMechanism(new[] { affectedCalculation, unaffectedCalculation }); var strategy = new ForeshoreProfileUpdateDataStrategy(failureMechanism, foreshoreProfiles); // Call IEnumerable <IObservable> affectedObjects = strategy.UpdateForeshoreProfilesWithImportedData(new[] { new TestForeshoreProfile(unaffectedProfileName, unaffectedProfileId), profileToUpdateFrom }, sourceFilePath); // Assert Assert.IsTrue(unaffectedCalculation.HasOutput); Assert.AreSame(unaffectedProfile, unaffectedCalculation.InputParameters.ForeshoreProfile); Assert.IsFalse(affectedCalculation.HasOutput); Assert.AreSame(affectedProfile, affectedCalculation.InputParameters.ForeshoreProfile); CollectionAssert.AreEquivalent(originalForeshoreProfiles, foreshoreProfiles); CollectionAssert.AreEquivalent(new IObservable[] { affectedCalculation, affectedCalculation.InputParameters, affectedProfile, foreshoreProfiles }, affectedObjects); }
private static IEnumerable <Point2D> GetWorldPoints(ForeshoreProfile foreshoreProfile) { return(AdvancedMath2D.FromXToXY( foreshoreProfile.Geometry.Select(p => - p.X).ToArray(), foreshoreProfile.WorldReferencePoint, -foreshoreProfile.X0, foreshoreProfile.Orientation)); }
public void ForeshoreProfile_SetNewValue_InputSyncedAccordingly( [Values(true, false)] bool withBreakWater, [Values(true, false)] bool withValidForeshore) { // Setup var input = new SimpleStructuresInput(); BreakWaterType originalBreakWaterType = input.BreakWater.Type; RoundedDouble originalBreakWaterHeight = input.BreakWater.Height; HydraulicBoundaryLocation originalHydraulicBoundaryLocation = input.HydraulicBoundaryLocation; var foreshoreGeometry = new List <Point2D> { new Point2D(2.2, 3.3) }; if (withValidForeshore) { foreshoreGeometry.Add(new Point2D(4.4, 5.5)); } BreakWater breakWater = null; if (withBreakWater) { const BreakWaterType nonDefaultBreakWaterType = BreakWaterType.Wall; const double nonDefaultBreakWaterHeight = 5.5; // Precondition Assert.AreNotEqual(nonDefaultBreakWaterType, input.BreakWater.Type); Assert.AreNotEqual(nonDefaultBreakWaterHeight, input.BreakWater.Height); breakWater = new BreakWater(nonDefaultBreakWaterType, nonDefaultBreakWaterHeight); } const double orientation = 96; var foreshoreProfile = new ForeshoreProfile(new Point2D(0, 0), foreshoreGeometry.ToArray(), breakWater, new ForeshoreProfile.ConstructionProperties { Id = "id", Orientation = orientation }); // Call input.ForeshoreProfile = foreshoreProfile; // Assert Assert.AreSame(foreshoreProfile, input.ForeshoreProfile); Assert.AreEqual(withBreakWater, input.UseBreakWater); Assert.AreEqual(withBreakWater ? foreshoreProfile.BreakWater.Type : originalBreakWaterType, input.BreakWater.Type); Assert.AreEqual(withBreakWater ? foreshoreProfile.BreakWater.Height : originalBreakWaterHeight, input.BreakWater.Height); Assert.AreEqual(withValidForeshore, input.UseForeshore); CollectionAssert.AreEqual(foreshoreProfile.Geometry, input.ForeshoreGeometry); Assert.AreSame(originalHydraulicBoundaryLocation, input.HydraulicBoundaryLocation); }
public DerivedForeshoreProfile(ForeshoreProfile profile) : base(profile.WorldReferencePoint, profile.Geometry, profile.BreakWater, new ConstructionProperties { Id = profile.Id, Name = profile.Name, X0 = profile.X0, Orientation = profile.X0 }) { }
private static void AssertForeshoreChartData(ForeshoreProfile foreshoreProfile, ChartData chartData) { Assert.IsInstanceOf <ChartLineData>(chartData); var foreshoreChartData = (ChartLineData)chartData; RoundedPoint2DCollection foreshoreGeometry = foreshoreProfile.Geometry; string expectedName = $"{foreshoreProfile.Name} - Voorlandprofiel"; Assert.AreEqual(expectedName, chartData.Name); CollectionAssert.AreEqual(foreshoreGeometry, foreshoreChartData.Points); }
public void UpdateForeshoreProfilesWithImportedData_WithCurrentCollectionAndImportedCollectionHasPartialOverlap_UpdatesTargetDataCollection() { // Setup var commonName = "Name"; var foreshoreProfileToBeUpdated = new TestForeshoreProfile(commonName, "Updated ID"); var foreshoreProfileToBeRemoved = new TestForeshoreProfile(commonName, "Removed ID"); var foreshoreProfiles = new ForeshoreProfileCollection(); foreshoreProfiles.AddRange(new[] { foreshoreProfileToBeUpdated, foreshoreProfileToBeRemoved }, sourceFilePath); ForeshoreProfile foreshoreProfileToUpdateFrom = DeepCloneAndModify(foreshoreProfileToBeUpdated); var foreshoreProfileToBeAdded = new TestForeshoreProfile(commonName, "Added ID"); ForeshoreProfile[] importedForeshoreProfiles = { foreshoreProfileToUpdateFrom, foreshoreProfileToBeAdded }; var strategy = new ForeshoreProfileUpdateDataStrategy(new TestCalculatableFailureMechanism(), foreshoreProfiles); // Call IEnumerable <IObservable> affectedObjects = strategy.UpdateForeshoreProfilesWithImportedData(importedForeshoreProfiles, sourceFilePath); // Assert Assert.AreEqual(2, foreshoreProfiles.Count); CollectionAssert.AreEqual(new[] { foreshoreProfileToBeUpdated, foreshoreProfileToBeAdded }, foreshoreProfiles); ForeshoreProfile updatedForeshoreProfile = foreshoreProfiles[0]; Assert.AreSame(foreshoreProfileToBeUpdated, updatedForeshoreProfile); AssertForeshoreProfile(foreshoreProfileToUpdateFrom, updatedForeshoreProfile); ForeshoreProfile addedForeshoreProfile = foreshoreProfiles[1]; Assert.AreSame(foreshoreProfileToBeAdded, addedForeshoreProfile); AssertForeshoreProfile(foreshoreProfileToBeAdded, addedForeshoreProfile); CollectionAssert.AreEquivalent(new IObservable[] { foreshoreProfileToBeUpdated, foreshoreProfiles }, affectedObjects); }
public void BreakWater_SetToNull_GetsNewlySetNull() { // Call var foreshoreProfile = new ForeshoreProfile(new Point2D(0, 0), new Point2D[0], null, new ForeshoreProfile.ConstructionProperties { Id = "id" }); // Assert Assert.IsNull(foreshoreProfile.BreakWater); }
private static void AssertForeshoreProfile(ForeshoreProfile expectedForeshoreProfile, ForeshoreProfile actualForeshoreProfile) { Assert.AreEqual(expectedForeshoreProfile.WorldReferencePoint, actualForeshoreProfile.WorldReferencePoint); CollectionAssert.AreEqual(expectedForeshoreProfile.Geometry, actualForeshoreProfile.Geometry); Assert.AreEqual(expectedForeshoreProfile.BreakWater, actualForeshoreProfile.BreakWater); Assert.AreEqual(expectedForeshoreProfile.Id, actualForeshoreProfile.Id); Assert.AreEqual(expectedForeshoreProfile.Name, actualForeshoreProfile.Name); Assert.AreEqual(expectedForeshoreProfile.X0, actualForeshoreProfile.X0); Assert.AreEqual(expectedForeshoreProfile.Orientation, actualForeshoreProfile.Orientation); }
public void Constructor_NonEmptyOrWhitespaceNameDifferentFromId_NameValueSet(string name) { // Call var foreshoreProfile = new ForeshoreProfile(new Point2D(0, 0), new Point2D[0], null, new ForeshoreProfile.ConstructionProperties { Id = "id", Name = name }); // Assert Assert.AreEqual(name, foreshoreProfile.Name); }
public void CopyProperties_FromForeshoreProfileNull_ThrowsArgumentNullException() { // Setup ForeshoreProfile foreshoreProfile = CreateFullyDefinedForeshoreProfile(); // Call TestDelegate call = () => foreshoreProfile.CopyProperties(null); // Assert var exception = Assert.Throws <ArgumentNullException>(call); Assert.AreEqual("fromForeshoreProfile", exception.ParamName); }
public void CopyProperties_FromForeshoreProfileAllPropertiesChanged_PropertiesChanged() { // Setup ForeshoreProfile foreshoreProfileToUpdate = CreateFullyDefinedForeshoreProfile(); const string expectedId = "new_id"; const string expectedName = "new_name"; var random = new Random(21); double expectedX0 = foreshoreProfileToUpdate.X0 + random.NextDouble(); var expectedOrientation = new RoundedDouble(2, (foreshoreProfileToUpdate.Orientation + random.NextDouble()) % 360); double expectedBreakWaterHeight = foreshoreProfileToUpdate.BreakWater.Height + random.NextDouble(); var expectedBreakWater = new BreakWater(random.NextEnumValue <BreakWaterType>(), expectedBreakWaterHeight); Point2D originalPoint = foreshoreProfileToUpdate.WorldReferencePoint; var expectedWorldReferencePoint = new Point2D(originalPoint.X + random.NextDouble(), originalPoint.Y + random.NextDouble()); var expectedForeshoreGeometry = new[] { new Point2D(10, 10), new Point2D(15, 10) }; var foreshoreProfileToUpdateFrom = new ForeshoreProfile(expectedWorldReferencePoint, expectedForeshoreGeometry, expectedBreakWater, new ForeshoreProfile.ConstructionProperties { Id = expectedId, Name = expectedName, Orientation = expectedOrientation, X0 = expectedX0 }); // Call foreshoreProfileToUpdate.CopyProperties(foreshoreProfileToUpdateFrom); // Assert Assert.AreEqual(expectedWorldReferencePoint, foreshoreProfileToUpdate.WorldReferencePoint); Assert.AreNotSame(expectedWorldReferencePoint, foreshoreProfileToUpdate.WorldReferencePoint); CollectionAssert.AreEqual(expectedForeshoreGeometry, foreshoreProfileToUpdate.Geometry); TestHelper.AssertCollectionAreNotSame(expectedForeshoreGeometry, foreshoreProfileToUpdate.Geometry); Assert.AreEqual(expectedBreakWater, foreshoreProfileToUpdate.BreakWater); Assert.AreNotSame(expectedBreakWater, foreshoreProfileToUpdate.BreakWater); Assert.AreEqual(expectedId, foreshoreProfileToUpdate.Id); Assert.AreEqual(expectedName, foreshoreProfileToUpdate.Name); Assert.AreEqual(expectedX0, foreshoreProfileToUpdate.X0); Assert.AreEqual(expectedOrientation, foreshoreProfileToUpdate.Orientation); }
public void Orientation_SetToValueWithTooManyDecimalPlaces_ValueIsRounded() { // Call var foreshoreProfile = new ForeshoreProfile(new Point2D(0, 0), new Point2D[0], null, new ForeshoreProfile.ConstructionProperties { Id = "id", Orientation = 1.23456 }); // Assert Assert.AreEqual(2, foreshoreProfile.Orientation.NumberOfDecimalPlaces); Assert.AreEqual(1.23, foreshoreProfile.Orientation.Value); }
public void HasBreakWater_BreakWaterSetToNull_ReturnFalse() { // Setup var foreshoreProfile = new ForeshoreProfile(new Point2D(0, 0), new Point2D[0], null, new ForeshoreProfile.ConstructionProperties { Id = "id" }); // Call bool hasBreakWater = foreshoreProfile.HasBreakWater; // Assert Assert.IsFalse(hasBreakWater); }
private static ForeshoreProfile CreateForeshoreProfile(ProfileLocation dikeProfileLocation, DikeProfileData dikeProfileData) { var foreshoreProfile = new ForeshoreProfile(dikeProfileLocation.Point, dikeProfileData.ForeshoreGeometry.Select(fg => fg.Point), CreateBreakWater(dikeProfileData), new ForeshoreProfile.ConstructionProperties { Id = dikeProfileData.Id, Name = dikeProfileLocation.Name, X0 = dikeProfileLocation.Offset, Orientation = dikeProfileData.Orientation }); return(foreshoreProfile); }
public void Constructor_NullOrWhitespaceName_NameSetToId(string name) { // Setup const string id = "id"; // Call var foreshoreProfile = new ForeshoreProfile(new Point2D(0, 0), new Point2D[0], null, new ForeshoreProfile.ConstructionProperties { Id = id, Name = name }); // Assert Assert.AreEqual(id, foreshoreProfile.Name); }
public void BreakWater_SetToNewInstance_GetsNewlySetInstance() { // Setup var newBreakWater = new BreakWater(BreakWaterType.Caisson, 1.1); // Call var foreshoreProfile = new ForeshoreProfile(new Point2D(0, 0), new Point2D[0], newBreakWater, new ForeshoreProfile.ConstructionProperties { Id = "id" }); // Assert Assert.AreSame(newBreakWater, foreshoreProfile.BreakWater); }