public void SetConfigurationForeshoreProfileDependentProperties_WithForeshoreProfileInvalidBreakwaterType_UpdatesConfiguration() { // Setup var random = new Random(6543); var configuration = new SimpleStructuresCalculationConfiguration(); var structureInput = new SimpleStructuresInput { ForeshoreProfile = new TestForeshoreProfile(new BreakWater( (BreakWaterType)999, random.NextDouble())), UseBreakWater = random.NextBoolean(), UseForeshore = random.NextBoolean() }; // Call configuration.SetConfigurationForeshoreProfileDependentProperties(structureInput); // Assert Assert.AreEqual(structureInput.ForeshoreProfile.Id, configuration.ForeshoreProfileId); WaveReductionConfiguration waveReduction = configuration.WaveReduction; Assert.AreEqual(structureInput.UseBreakWater, waveReduction.UseBreakWater); Assert.AreEqual(structureInput.UseForeshore, waveReduction.UseForeshoreProfile); Assert.IsNull(waveReduction.BreakWaterType); Assert.AreEqual(structureInput.BreakWater.Height, waveReduction.BreakWaterHeight); }
/// <summary> /// Validate the defined wave reduction parameters in combination with a given foreshore profile. /// </summary> /// <param name="waveReduction">Configuration possibly containing wave reduction parameters.</param> /// <param name="foreshoreProfile">The foreshore profile currently assigned to the calculation.</param> /// <param name="calculationName">The name of the calculation which is being validated.</param> /// <param name="log">Log used to write out errors.</param> /// <returns><c>false</c> when there is an invalid wave reduction parameter defined, <c>true</c> otherwise.</returns> /// <exception cref="ArgumentNullException">Thrown when <paramref name="calculationName"/> or <paramref name="log"/> /// is <c>null</c>.</exception> public static bool ValidateWaveReduction(this WaveReductionConfiguration waveReduction, ForeshoreProfile foreshoreProfile, string calculationName, ILog log) { if (calculationName == null) { throw new ArgumentNullException(nameof(calculationName)); } if (log == null) { throw new ArgumentNullException(nameof(log)); } if (foreshoreProfile == null) { if (HasParametersDefined(waveReduction)) { log.LogCalculationConversionError(Resources.CalculationConfigurationImporter_ValidateWaveReduction_No_foreshore_profile_provided, calculationName); return(false); } } else if (!foreshoreProfile.Geometry.Any() && waveReduction?.UseForeshoreProfile == true) { log.LogCalculationConversionError(string.Format( Resources.ReadForeshoreProfile_ForeshoreProfile_0_has_no_geometry_and_cannot_be_used, foreshoreProfile.Id), calculationName); return(false); } return(true); }
public void SetConfigurationForeshoreProfileDependentProperties_WithForeshoreProfile_UpdatesConfiguration() { // Setup var random = new Random(6543); var configuration = new SimpleStructuresCalculationConfiguration(); var structureInput = new SimpleStructuresInput { ForeshoreProfile = new ForeshoreProfile(new Point2D(0, 0), Enumerable.Empty <Point2D>(), new BreakWater( BreakWaterType.Dam, random.NextDouble()), new ForeshoreProfile.ConstructionProperties { Id = "id", Name = "profile" }), UseBreakWater = random.NextBoolean(), UseForeshore = random.NextBoolean() }; // Call configuration.SetConfigurationForeshoreProfileDependentProperties(structureInput); // Assert Assert.AreEqual("id", configuration.ForeshoreProfileId); WaveReductionConfiguration waveReduction = configuration.WaveReduction; Assert.AreEqual(structureInput.UseBreakWater, waveReduction.UseBreakWater); Assert.AreEqual(structureInput.UseForeshore, waveReduction.UseForeshoreProfile); Assert.AreEqual(ConfigurationBreakWaterType.Dam, waveReduction.BreakWaterType); Assert.AreEqual(structureInput.BreakWater.Height, waveReduction.BreakWaterHeight); }
public void WriteWaveReduction_InvalidBreakWaterType_ThrowsInvalidEnumArgumentException() { // Setup string filePath = TestHelper.GetScratchPadPath(nameof(WriteWaveReduction_WithoutWaveReduction_ThrowsArgumentNullException)); var configuration = new WaveReductionConfiguration { BreakWaterType = (ConfigurationBreakWaterType?)9000 }; try { using (XmlWriter xmlWriter = CreateXmlWriter(filePath)) { // Call TestDelegate testDelegate = () => xmlWriter.WriteWaveReduction(configuration); // Assert Assert.Throws <InvalidEnumArgumentException>(testDelegate); } } finally { File.Delete(filePath); } }
public void ReadWaveReduction_DifferentScenarios_CorrectParametersSet(bool useForeshoreProfile, bool useBreakWater, double height, ConfigurationBreakWaterType type, BreakWaterType expectedType) { // Setup var testInput = new TestInputWithForeshoreProfileAndBreakWater(new BreakWater(BreakWaterType.Caisson, 0.0)); string filePath = Path.Combine(readerPath, "validConfiguration.xml"); var calculationGroup = new CalculationGroup(); var importer = new CalculationConfigurationImporter(filePath, calculationGroup); var waveReductionConfiguration = new WaveReductionConfiguration { UseForeshoreProfile = useForeshoreProfile, UseBreakWater = useBreakWater, BreakWaterHeight = height, BreakWaterType = type }; // Call importer.PublicReadWaveReductionParameters(waveReductionConfiguration, testInput); // Assert Assert.AreEqual(testInput.UseForeshore, useForeshoreProfile); Assert.AreEqual(testInput.UseBreakWater, useBreakWater); Assert.AreEqual(testInput.BreakWater.Height, height, testInput.BreakWater.Height.GetAccuracy()); Assert.AreEqual(testInput.BreakWater.Type, expectedType); }
public void ValidateWaveReduction_ForeshoreProfileWithGeometryForeshoreProfileUsed_ReturnsTrue() { // Setup const string calculationName = "calculation"; var mocks = new MockRepository(); var log = mocks.StrictMock <ILog>(); mocks.ReplayAll(); var waveReductionConfiguration = new WaveReductionConfiguration { UseForeshoreProfile = true }; // Call bool valid = waveReductionConfiguration.ValidateWaveReduction(new TestForeshoreProfile("voorland", new[] { new Point2D(0, 2) }), calculationName, log); // Assert Assert.IsTrue(valid); mocks.VerifyAll(); }
/// <summary> /// Validation to check if the defined wave reduction parameters are valid. /// </summary> /// <param name="calculationConfiguration">The calculation read from the imported file.</param> /// <param name="calculation">The calculation to configure.</param> /// <returns><c>false</c> when there is an invalid wave reduction parameter defined, <c>true</c> otherwise.</returns> private bool ValidateWaveReduction(GrassCoverErosionInwardsCalculationConfiguration calculationConfiguration, GrassCoverErosionInwardsCalculation calculation) { WaveReductionConfiguration waveReductionConfiguration = calculationConfiguration.WaveReduction; if (calculation.InputParameters.DikeProfile == null) { if (waveReductionConfiguration != null && (waveReductionConfiguration.UseBreakWater.HasValue || waveReductionConfiguration.UseForeshoreProfile.HasValue || waveReductionConfiguration.BreakWaterHeight != null || waveReductionConfiguration.BreakWaterType != null)) { Log.LogCalculationConversionError(Resources.GrassCoverErosionInwardsCalculationConfigurationImporter_ValidateWaveReduction_No_DikeProfile_provided_for_BreakWater_parameters, calculation.Name); return(false); } } else if (!calculation.InputParameters.ForeshoreGeometry.Any() && waveReductionConfiguration?.UseForeshoreProfile != null && waveReductionConfiguration.UseForeshoreProfile.Value) { Log.LogCalculationConversionError(string.Format( Resources.GrassCoverErosionInwardsCalculationConfigurationImporter_ValidateWaveReduction_DikeProfile_0_has_no_geometry_and_cannot_be_used, calculationConfiguration.DikeProfileId), calculation.Name); return(false); } return(true); }
public void ValidateWaveReduction_ForeshoreProfileWithoutGeometryForeshoreProfileUsed_LogsErrorReturnsFalse() { // Setup const string profileName = "voorland"; const string calculationName = "calculation"; const string expectedMessage = "{0} Berekening '{1}' is overgeslagen."; string error = $"Het opgegeven voorlandprofiel '{profileName}' heeft geen voorlandgeometrie en kan daarom niet gebruikt worden."; var mocks = new MockRepository(); var log = mocks.StrictMock <ILog>(); log.Expect(l => l.ErrorFormat(expectedMessage, error, calculationName)); mocks.ReplayAll(); var waveReductionConfiguration = new WaveReductionConfiguration { UseForeshoreProfile = true }; // Call bool valid = waveReductionConfiguration.ValidateWaveReduction(new TestForeshoreProfile(profileName), calculationName, log); // Assert Assert.IsFalse(valid); mocks.VerifyAll(); }
public void GetWaveReductionParameters_WithAllParameters_ReturnsConfiguration() { // Setup const double height = 2.1; const string type = "havendam"; const string useForeshoreProfile = "true"; const string useBreakWater = "true"; var breakWaterHeightElement = new XElement("damhoogte", height); var breakWaterTypeElement = new XElement("damtype", type); var useForeshoreProfileElement = new XElement("voorlandgebruiken", useForeshoreProfile); var useBreakWaterElement = new XElement("damgebruiken", useBreakWater); var waveReductionElement = new XElement("golfreductie", breakWaterHeightElement, breakWaterTypeElement, useForeshoreProfileElement, useBreakWaterElement); var xElement = new XElement("root", new XElement("root", waveReductionElement)); // Call WaveReductionConfiguration waveReduction = xElement.GetWaveReductionParameters(); // Assert Assert.AreEqual(height, waveReduction.BreakWaterHeight); Assert.AreEqual(ConfigurationBreakWaterType.Dam, waveReduction.BreakWaterType); Assert.IsTrue(waveReduction.UseForeshoreProfile); Assert.IsTrue(waveReduction.UseBreakWater); }
/// <summary> /// Assigns the <paramref name="waveReduction"/> parameters to the <paramref name="input"/>. /// </summary> /// <typeparam name="T">Type of the input for which values are assigned from the configuration.</typeparam> /// <param name="waveReduction">The wave reduction configuration containing values for the parameters.</param> /// <param name="input">The input to assign the values to.</param> protected static void SetWaveReductionParameters <T>(WaveReductionConfiguration waveReduction, T input) where T : IUseBreakWater, IUseForeshore { if (waveReduction != null) { if (waveReduction.UseForeshoreProfile.HasValue) { input.UseForeshore = waveReduction.UseForeshoreProfile.Value; } if (waveReduction.UseBreakWater.HasValue) { input.UseBreakWater = waveReduction.UseBreakWater.Value; } if (waveReduction.BreakWaterType.HasValue) { input.BreakWater.Type = (BreakWaterType) new ConfigurationBreakWaterTypeConverter().ConvertTo(waveReduction.BreakWaterType.Value, typeof(BreakWaterType)); } if (waveReduction.BreakWaterHeight.HasValue) { input.BreakWater.Height = (RoundedDouble)waveReduction.BreakWaterHeight.Value; } } }
private static bool HasParametersDefined(WaveReductionConfiguration waveReduction) { return(waveReduction != null && (waveReduction.UseBreakWater.HasValue || waveReduction.UseForeshoreProfile.HasValue || waveReduction.BreakWaterHeight.HasValue || waveReduction.BreakWaterType.HasValue)); }
public void ReadWaveReduction_WithConfigurationWithMissingParameter_MissingParameterUnchanged( [Values(0, 1, 2, 3)] int parameterNotSet) { // Setup const bool useForeshoreProfile = false; const bool useBreakWater = false; const double height = 2.55; const BreakWaterType breakWaterType = BreakWaterType.Dam; const bool newUseForeshoreProfile = true; const bool newUseBreakWater = true; const double newHeight = 11.1; const ConfigurationBreakWaterType newBreakWaterType = ConfigurationBreakWaterType.Wall; const BreakWaterType expectedNewBreakWaterType = BreakWaterType.Wall; var testInput = new TestInputWithForeshoreProfileAndBreakWater(new BreakWater(breakWaterType, height)) { UseBreakWater = useBreakWater, UseForeshore = useForeshoreProfile }; var waveReductionConfiguration = new WaveReductionConfiguration(); if (parameterNotSet != 0) { waveReductionConfiguration.UseForeshoreProfile = newUseForeshoreProfile; } if (parameterNotSet != 1) { waveReductionConfiguration.UseBreakWater = newUseBreakWater; } if (parameterNotSet != 2) { waveReductionConfiguration.BreakWaterHeight = newHeight; } if (parameterNotSet != 3) { waveReductionConfiguration.BreakWaterType = newBreakWaterType; } string filePath = Path.Combine(readerPath, "validConfiguration.xml"); var calculationGroup = new CalculationGroup(); var importer = new CalculationConfigurationImporter(filePath, calculationGroup); // Call importer.PublicReadWaveReductionParameters(waveReductionConfiguration, testInput); // Assert Assert.AreEqual(testInput.UseForeshore, parameterNotSet == 0 ? useForeshoreProfile : newUseForeshoreProfile); Assert.AreEqual(testInput.UseBreakWater, parameterNotSet == 1 ? useBreakWater : newUseBreakWater); Assert.AreEqual(testInput.BreakWater.Height, parameterNotSet == 2 ? height : newHeight, testInput.BreakWater.Height.GetAccuracy()); Assert.AreEqual(testInput.BreakWater.Type, parameterNotSet == 3 ? breakWaterType : expectedNewBreakWaterType); }
public void Constructor_ExpectedValues() { // Call var configuration = new WaveReductionConfiguration(); // Assert Assert.IsNull(configuration.UseBreakWater); Assert.IsNull(configuration.BreakWaterType); Assert.IsNull(configuration.BreakWaterHeight); Assert.IsNull(configuration.UseForeshoreProfile); }
public void GetWaveReductionParameters_OtherDescendantElement_ReturnsNull() { // Setup var xElement = new XElement("root", new XElement("root", new XElement("OtherDescendantElement"))); // Call WaveReductionConfiguration waveReduction = xElement.GetWaveReductionParameters(); // Assert Assert.IsNull(waveReduction); }
/// <summary> /// Writes a wave reduction configuration when it has a value. /// </summary> /// <param name="writer">The writer to use for writing.</param> /// <param name="configuration">The configuration for the wave reduction that can be <c>null</c>.</param> /// <exception cref="ArgumentNullException">Thrown when <paramref name="writer"/> is <c>null</c>.</exception> /// <exception cref="InvalidOperationException">Thrown when the <paramref name="writer"/> /// is closed.</exception> protected static void WriteWaveReductionWhenAvailable(XmlWriter writer, WaveReductionConfiguration configuration) { if (writer == null) { throw new ArgumentNullException(nameof(writer)); } if (configuration != null) { writer.WriteWaveReduction(configuration); } }
public void ValidateWaveReduction_NoForeshoreProfileWaveReductionWithoutParameters_ReturnsTrue() { // Setup const string calculationName = "calculation"; var mocks = new MockRepository(); var log = mocks.StrictMock <ILog>(); mocks.ReplayAll(); // Call bool valid = new WaveReductionConfiguration().ValidateWaveReduction(null, calculationName, log); // Assert Assert.IsTrue(valid); mocks.VerifyAll(); }
public void GetWaveReductionParameters_WithUseForeshoreProfile_ReturnsConfiguration() { // Setup const string useForeshoreProfile = "true"; var useForeshoreProfileElement = new XElement("voorlandgebruiken", useForeshoreProfile); var waveReductionElement = new XElement("golfreductie", useForeshoreProfileElement); var xElement = new XElement("root", new XElement("root", waveReductionElement)); // Call WaveReductionConfiguration waveReduction = xElement.GetWaveReductionParameters(); // Assert Assert.IsTrue(waveReduction.UseForeshoreProfile); Assert.IsNull(waveReduction.BreakWaterHeight); Assert.IsNull(waveReduction.BreakWaterType); Assert.IsNull(waveReduction.UseBreakWater); }
public void GetWaveReductionParameters_WithBreakWaterType_ReturnsConfiguration() { // Setup const string type = "havendam"; var breakWaterTypeElement = new XElement("damtype", type); var waveReductionElement = new XElement("golfreductie", breakWaterTypeElement); var xElement = new XElement("root", new XElement("root", waveReductionElement)); // Call WaveReductionConfiguration waveReduction = xElement.GetWaveReductionParameters(); // Assert Assert.AreEqual(ConfigurationBreakWaterType.Dam, waveReduction.BreakWaterType); Assert.IsNull(waveReduction.BreakWaterHeight); Assert.IsNull(waveReduction.UseForeshoreProfile); Assert.IsNull(waveReduction.UseBreakWater); }
public void GetWaveReductionParameters_WithBreakWaterHeight_ReturnsConfiguration() { // Setup const double height = 2.1; var breakWaterHeightElement = new XElement("damhoogte", height); var waveReductionElement = new XElement("golfreductie", breakWaterHeightElement); var xElement = new XElement("root", new XElement("root", waveReductionElement)); // Call WaveReductionConfiguration waveReduction = xElement.GetWaveReductionParameters(); // Assert Assert.AreEqual(height, waveReduction.BreakWaterHeight); Assert.IsNull(waveReduction.BreakWaterType); Assert.IsNull(waveReduction.UseForeshoreProfile); Assert.IsNull(waveReduction.UseBreakWater); }
public void WriteWaveReductionWhenAvailable_WaveReductionConfigurationSet_WriterCalledWithExpectedParameters() { // Setup var configuration = new WaveReductionConfiguration(); var mocks = new MockRepository(); var xmlWriter = mocks.StrictMock <XmlWriter>(); xmlWriter.Expect(w => w.WriteWaveReduction(configuration)); mocks.ReplayAll(); // Call ExposedCalculationConfigurationWriter.PublicWriteWaveReductionWhenAvailable( xmlWriter, configuration); // Assert mocks.VerifyAll(); }
public void ValidateWaveReduction_NoForeshoreProfileWaveReductionWithParameter_LogsErrorReturnsFalse([Values(0, 1, 2, 3)] int propertyToSet) { // Setup const string calculationName = "calculation"; const string error = "Er is geen voorlandprofiel opgegeven om golfreductie parameters aan toe te voegen."; const string expectedMessage = "{0} Berekening '{1}' is overgeslagen."; var mocks = new MockRepository(); var log = mocks.StrictMock <ILog>(); log.Expect(l => l.ErrorFormat(expectedMessage, error, calculationName)); mocks.ReplayAll(); var waveReductionConfiguration = new WaveReductionConfiguration(); var random = new Random(21); switch (propertyToSet) { case 0: waveReductionConfiguration.BreakWaterType = random.NextEnumValue <ConfigurationBreakWaterType>(); break; case 1: waveReductionConfiguration.BreakWaterHeight = random.NextDouble(); break; case 2: waveReductionConfiguration.UseBreakWater = random.NextBoolean(); break; case 3: waveReductionConfiguration.UseForeshoreProfile = random.NextBoolean(); break; } // Call bool valid = waveReductionConfiguration.ValidateWaveReduction(null, calculationName, log); // Assert Assert.IsFalse(valid); mocks.VerifyAll(); }
/// <summary> /// Writes a single <see cref="WaveReductionConfiguration"/> as a wave reduction element in file. /// </summary> /// <param name="writer">The writer to use to write the wave reduction.</param> /// <param name="waveReduction">The wave reduction to write.</param> /// <exception cref="ArgumentNullException">Thrown when any of the input parameters is <c>null</c>.</exception> /// <exception cref="InvalidOperationException">Thrown when the <paramref name="writer"/> /// is closed.</exception> /// <exception cref="InvalidEnumArgumentException">Thrown when the conversion of <paramref name="waveReduction"/> /// cannot be performed.</exception> /// <exception cref="NotSupportedException">Thrown when the conversion of <paramref name="waveReduction"/> /// cannot be performed.</exception> public static void WriteWaveReduction(this XmlWriter writer, WaveReductionConfiguration waveReduction) { if (writer == null) { throw new ArgumentNullException(nameof(writer)); } if (waveReduction == null) { throw new ArgumentNullException(nameof(waveReduction)); } writer.WriteStartElement(ConfigurationSchemaIdentifiers.WaveReduction); if (waveReduction.UseBreakWater.HasValue) { writer.WriteElementString(ConfigurationSchemaIdentifiers.UseBreakWater, XmlConvert.ToString(waveReduction.UseBreakWater.Value)); } if (waveReduction.BreakWaterType.HasValue) { writer.WriteElementString(ConfigurationSchemaIdentifiers.BreakWaterType, new ConfigurationBreakWaterTypeConverter().ConvertToInvariantString(waveReduction.BreakWaterType.Value)); } if (waveReduction.BreakWaterHeight.HasValue) { writer.WriteElementString(ConfigurationSchemaIdentifiers.BreakWaterHeight, XmlConvert.ToString(waveReduction.BreakWaterHeight.Value)); } if (waveReduction.UseForeshoreProfile.HasValue) { writer.WriteElementString(ConfigurationSchemaIdentifiers.UseForeshore, XmlConvert.ToString(waveReduction.UseForeshoreProfile.Value)); } writer.WriteEndElement(); }
public void SimpleProperties_SetNewValue_GetsNewlySetValue() { // Setup var configuration = new WaveReductionConfiguration(); var random = new Random(21); bool useBreakWater = random.NextBoolean(); var breakWaterType = random.NextEnumValue <ConfigurationBreakWaterType>(); double breakWaterHeight = random.NextDouble(); bool useForeshore = random.NextBoolean(); // Call configuration.UseBreakWater = useBreakWater; configuration.BreakWaterType = breakWaterType; configuration.BreakWaterHeight = breakWaterHeight; configuration.UseForeshoreProfile = useForeshore; // Assert Assert.AreEqual(useBreakWater, configuration.UseBreakWater); Assert.AreEqual(breakWaterType, configuration.BreakWaterType); Assert.AreEqual(breakWaterHeight, configuration.BreakWaterHeight); Assert.AreEqual(useForeshore, configuration.UseForeshoreProfile); }
public void PublicReadWaveReductionParameters<T>(WaveReductionConfiguration waveReduction, T input) where T : IUseBreakWater, IUseForeshore { SetWaveReductionParameters(waveReduction, input); }
public void WriteWaveReduction_WithoutDifferentSetParameters_WritesStochastWithSetParameters(WaveReductionConfiguration waveReduction, string fileName) { // Setup string filePath = TestHelper.GetScratchPadPath( $"{nameof(WriteWaveReduction_WithoutDifferentSetParameters_WritesStochastWithSetParameters)}.{fileName}"); try { using (XmlWriter xmlWriter = CreateXmlWriter(filePath)) { // Call xmlWriter.WriteWaveReduction(waveReduction); } // Assert string actualXml = File.ReadAllText(filePath); string expectedXml = GetTestFileContent(fileName); Assert.AreEqual(expectedXml, actualXml); } finally { File.Delete(filePath); } }
public static void PublicWriteWaveReductionWhenAvailable(XmlWriter writer, WaveReductionConfiguration configuration) { WriteWaveReductionWhenAvailable(writer, configuration); }