public void SetValues_ScopeNull_ThrowsArgumentNullException()
{
// Setup
var random = new Random(21);
const string filePath = "FilePath";
const string scenarioName = "ScenarioName";
int year = random.Next();
const string seaLevel = "SeaLevel";
const string riverDischarge = "RiverDischarge";
const string lakeLevel = "LakeLevel";
const string windDirection = "WindDirection";
const string windSpeed = "WindSpeed";
const string comment = "Comment";
var settings = new HydraulicLocationConfigurationSettings();
// Call
TestDelegate call = () => settings.SetValues(filePath, scenarioName, year, null, false,
seaLevel, riverDischarge, lakeLevel,
windDirection, windSpeed, comment);
// Assert
var exception = Assert.Throws <ArgumentNullException>(call);
Assert.AreEqual("scope", exception.ParamName);
}
public void SetValues_InvalidFilePathNull_ThrowsArgumentException(string invalidFilePath)
{
// Setup
var random = new Random(21);
const string scenarioName = "FilePath";
int year = random.Next();
const string scope = "Scope";
const string seaLevel = "SeaLevel";
const string riverDischarge = "RiverDischarge";
const string lakeLevel = "LakeLevel";
const string windDirection = "WindDirection";
const string windSpeed = "WindSpeed";
const string comment = "Comment";
var settings = new HydraulicLocationConfigurationSettings();
// Call
TestDelegate call = () => settings.SetValues(null, scenarioName, year, scope, false,
seaLevel, riverDischarge, lakeLevel,
windDirection, windSpeed, comment);
// Assert
const string expectedMessage = "'filePath' is null, empty or consists of whitespace.";
TestHelper.AssertThrowsArgumentExceptionAndTestMessage <ArgumentException>(call, expectedMessage);
}
public void GetProperties_WithLinkedDatabase_ReturnsExpectedValues()
{
// Setup
var mocks = new MockRepository();
var importHandler = mocks.Stub <IHydraulicLocationConfigurationDatabaseImportHandler>();
mocks.ReplayAll();
HydraulicBoundaryDatabase hydraulicBoundaryDatabase = CreateLinkedHydraulicBoundaryDatabase();
// Precondition
Assert.IsTrue(hydraulicBoundaryDatabase.IsLinked());
// Call
var properties = new HydraulicBoundaryDatabaseProperties(hydraulicBoundaryDatabase, importHandler);
// Assert
Assert.AreEqual(hydraulicBoundaryDatabase.FilePath, properties.HrdFilePath);
HydraulicLocationConfigurationSettings configurationSettings = hydraulicBoundaryDatabase.HydraulicLocationConfigurationSettings;
Assert.AreEqual(configurationSettings.FilePath, properties.HlcdFilePath);
Assert.AreEqual(configurationSettings.FilePath, properties.HlcdFilePathReadOnly);
Assert.AreEqual(configurationSettings.UsePreprocessorClosure, properties.UsePreprocessorClosure);
Assert.AreEqual(configurationSettings.ScenarioName, properties.ScenarioName);
Assert.AreEqual(configurationSettings.Year.ToString(), properties.Year);
Assert.AreEqual(configurationSettings.Scope, properties.Scope);
Assert.AreEqual(configurationSettings.SeaLevel, properties.SeaLevel);
Assert.AreEqual(configurationSettings.RiverDischarge, properties.RiverDischarge);
Assert.AreEqual(configurationSettings.LakeLevel, properties.LakeLevel);
Assert.AreEqual(configurationSettings.WindDirection, properties.WindDirection);
Assert.AreEqual(configurationSettings.WindSpeed, properties.WindSpeed);
Assert.AreEqual(configurationSettings.Comment, properties.Comment);
mocks.VerifyAll();
}
public void SetValues_OptionalArgumentsNull_SetsExpectedValues()
{
// Setup
var random = new Random(21);
const string filePath = "FilePath";
const string scenarioName = "ScenarioName";
int year = random.Next();
const string scope = "Scope";
bool usePreprocessorClosure = random.NextBoolean();
var settings = new HydraulicLocationConfigurationSettings();
// Call
settings.SetValues(filePath, scenarioName, year, scope,
usePreprocessorClosure,
null, null, null, null, null, null);
// Assert
Assert.AreEqual(filePath, settings.FilePath);
Assert.AreEqual(scenarioName, settings.ScenarioName);
Assert.AreEqual(year, settings.Year);
Assert.AreEqual(scope, settings.Scope);
Assert.AreEqual(usePreprocessorClosure, settings.UsePreprocessorClosure);
Assert.IsNull(settings.SeaLevel);
Assert.IsNull(settings.RiverDischarge);
Assert.IsNull(settings.LakeLevel);
Assert.IsNull(settings.WindDirection);
Assert.IsNull(settings.WindSpeed);
Assert.IsNull(settings.Comment);
}
/// <summary>
/// Creates a <see cref="HydraulicBoundaryDatabaseEntity"/> based on the information of the
/// <see cref="HydraulicBoundaryDatabase"/>.
/// </summary>
/// <param name="hydraulicBoundaryDatabase">The <see cref="HydraulicBoundaryDatabase"/> to create a
/// <see cref="HydraulicBoundaryDatabaseEntity"/> for.</param>
/// <returns>A new <see cref="HydraulicBoundaryDatabaseEntity"/>.</returns>
/// <exception cref="ArgumentNullException">Thrown when <paramref name="hydraulicBoundaryDatabase"/>
/// is <c>null</c>.</exception>
internal static HydraulicBoundaryDatabaseEntity Create(this HydraulicBoundaryDatabase hydraulicBoundaryDatabase)
{
if (hydraulicBoundaryDatabase == null)
{
throw new ArgumentNullException(nameof(hydraulicBoundaryDatabase));
}
HydraulicLocationConfigurationSettings settings = hydraulicBoundaryDatabase.HydraulicLocationConfigurationSettings;
return(new HydraulicBoundaryDatabaseEntity
{
FilePath = hydraulicBoundaryDatabase.FilePath.DeepClone(),
Version = hydraulicBoundaryDatabase.Version.DeepClone(),
HydraulicLocationConfigurationSettingsFilePath = settings.FilePath.DeepClone(),
HydraulicLocationConfigurationSettingsUsePreprocessorClosure = Convert.ToByte(settings.UsePreprocessorClosure),
HydraulicLocationConfigurationSettingsScenarioName = settings.ScenarioName.DeepClone(),
HydraulicLocationConfigurationSettingsYear = settings.Year,
HydraulicLocationConfigurationSettingsScope = settings.Scope.DeepClone(),
HydraulicLocationConfigurationSettingsSeaLevel = settings.SeaLevel.DeepClone(),
HydraulicLocationConfigurationSettingsRiverDischarge = settings.RiverDischarge.DeepClone(),
HydraulicLocationConfigurationSettingsLakeLevel = settings.LakeLevel.DeepClone(),
HydraulicLocationConfigurationSettingsWindDirection = settings.WindDirection.DeepClone(),
HydraulicLocationConfigurationSettingsWindSpeed = settings.WindSpeed.DeepClone(),
HydraulicLocationConfigurationSettingsComment = settings.Comment.DeepClone()
});
}
public void SetHydraulicLocationConfigurationSettings_ReadHydraulicLocationConfigurationDatabaseSettingsNotNull_SetExpectedValuesAndDoesNotLog()
{
// Setup
const string filePath = "some/file/path";
var settings = new HydraulicLocationConfigurationSettings();
ReadHydraulicLocationConfigurationDatabaseSettings readSettings = ReadHydraulicLocationConfigurationDatabaseSettingsTestFactory.Create();
bool usePreprocessorClosure = new Random(21).NextBoolean();
// Call
Action call = () => HydraulicLocationConfigurationSettingsUpdateHelper.SetHydraulicLocationConfigurationSettings(
settings, readSettings, usePreprocessorClosure, filePath);
// Assert
TestHelper.AssertLogMessagesCount(call, 0);
Assert.AreEqual(filePath, settings.FilePath);
Assert.AreEqual(readSettings.ScenarioName, settings.ScenarioName);
Assert.AreEqual(readSettings.Year, settings.Year);
Assert.AreEqual(readSettings.Scope, settings.Scope);
Assert.AreEqual(usePreprocessorClosure, settings.UsePreprocessorClosure);
Assert.AreEqual(readSettings.SeaLevel, settings.SeaLevel);
Assert.AreEqual(readSettings.RiverDischarge, settings.RiverDischarge);
Assert.AreEqual(readSettings.LakeLevel, settings.LakeLevel);
Assert.AreEqual(readSettings.WindDirection, settings.WindDirection);
Assert.AreEqual(readSettings.WindSpeed, settings.WindSpeed);
Assert.AreEqual(readSettings.Comment, settings.Comment);
}
public void Update_ReadHydraulicLocationConfigurationDatabaseSettingsNull_SetsDefaultValuesAndLogsWarning()
{
// Setup
const string hlcdFilePath = "some/file/path";
var handler = new HydraulicLocationConfigurationDatabaseUpdateHandler(CreateAssessmentSection());
var hydraulicBoundaryDatabase = new HydraulicBoundaryDatabase();
bool usePreprocessorClosure = new Random(21).NextBoolean();
// Call
void Call() => handler.Update(hydraulicBoundaryDatabase, null, usePreprocessorClosure, hlcdFilePath);
// Assert
const string expectedMessage = "De tabel 'ScenarioInformation' in het HLCD bestand is niet aanwezig. Er worden standaardwaarden " +
"conform WBI2017 gebruikt voor de HLCD bestandsinformatie.";
TestHelper.AssertLogMessageWithLevelIsGenerated(Call, Tuple.Create(expectedMessage, LogLevelConstant.Warn), 1);
HydraulicLocationConfigurationSettings settings = hydraulicBoundaryDatabase.HydraulicLocationConfigurationSettings;
Assert.AreEqual(hlcdFilePath, settings.FilePath);
Assert.AreEqual("WBI2017", settings.ScenarioName);
Assert.AreEqual(2023, settings.Year);
Assert.AreEqual("WBI2017", settings.Scope);
Assert.AreEqual(usePreprocessorClosure, settings.UsePreprocessorClosure);
Assert.AreEqual("Conform WBI2017", settings.SeaLevel);
Assert.AreEqual("Conform WBI2017", settings.RiverDischarge);
Assert.AreEqual("Conform WBI2017", settings.LakeLevel);
Assert.AreEqual("Conform WBI2017", settings.WindDirection);
Assert.AreEqual("Conform WBI2017", settings.WindSpeed);
Assert.AreEqual("Gegenereerd door Riskeer (conform WBI2017)", settings.Comment);
}
public void Update_WithReadHydraulicLocationConfigurationDatabaseSettings_SetsExpectedValuesAndDoesNotLog()
{
// Setup
const string hlcdFilePath = "some/file/path";
var handler = new HydraulicLocationConfigurationDatabaseUpdateHandler(CreateAssessmentSection());
var hydraulicBoundaryDatabase = new HydraulicBoundaryDatabase();
ReadHydraulicLocationConfigurationDatabaseSettings readSettings = ReadHydraulicLocationConfigurationDatabaseSettingsTestFactory.Create();
bool usePreprocessorClosure = new Random(21).NextBoolean();
// Call
void Call() => handler.Update(hydraulicBoundaryDatabase, readSettings, usePreprocessorClosure, hlcdFilePath);
// Assert
TestHelper.AssertLogMessagesCount(Call, 0);
HydraulicLocationConfigurationSettings settings = hydraulicBoundaryDatabase.HydraulicLocationConfigurationSettings;
Assert.AreEqual(hlcdFilePath, settings.FilePath);
Assert.AreEqual(readSettings.ScenarioName, settings.ScenarioName);
Assert.AreEqual(readSettings.Year, settings.Year);
Assert.AreEqual(readSettings.Scope, settings.Scope);
Assert.AreEqual(usePreprocessorClosure, settings.UsePreprocessorClosure);
Assert.AreEqual(readSettings.SeaLevel, settings.SeaLevel);
Assert.AreEqual(readSettings.RiverDischarge, settings.RiverDischarge);
Assert.AreEqual(readSettings.LakeLevel, settings.LakeLevel);
Assert.AreEqual(readSettings.WindDirection, settings.WindDirection);
Assert.AreEqual(readSettings.WindSpeed, settings.WindSpeed);
Assert.AreEqual(readSettings.Comment, settings.Comment);
}
public void PreprocessorDirectory_SetValidValueWithCanUsePreprocessorFalse_ThrowsInvalidOperationException()
{
// Setup
var settings = new HydraulicLocationConfigurationSettings();
// Call
TestDelegate test = () => settings.PreprocessorDirectory = "Preprocessor";
// Assert
string message = Assert.Throws <InvalidOperationException>(test).Message;
Assert.AreEqual($"{nameof(HydraulicLocationConfigurationSettings.CanUsePreprocessor)} is false.", message);
}
public void CanUsePreprocessor_Always_ExpectedValuesSet(bool canUsePreprocessor)
{
// Setup
var settings = new HydraulicLocationConfigurationSettings();
// Call
settings.CanUsePreprocessor = canUsePreprocessor;
// Assert
Assert.AreEqual(canUsePreprocessor, settings.CanUsePreprocessor);
Assert.IsFalse(settings.UsePreprocessor);
Assert.IsNull(settings.PreprocessorDirectory);
}
public void UsePreprocessor_SetValueWithCanUsePreprocessorFalse_ThrowsInvalidOperationException()
{
// Setup
bool usePreprocessor = new Random(11).NextBoolean();
var settings = new HydraulicLocationConfigurationSettings();
// Call
TestDelegate test = () => settings.UsePreprocessor = usePreprocessor;
// Assert
string message = Assert.Throws <InvalidOperationException>(test).Message;
Assert.AreEqual($"{nameof(HydraulicLocationConfigurationSettings.CanUsePreprocessor)} is false.", message);
}
public void PreprocessorDirectory_SetValidValueWithCanUsePreprocessorTrue_ExpectedValueSet()
{
// Setup
const string preprocessorDirectory = "OtherPreprocessor";
var settings = new HydraulicLocationConfigurationSettings
{
CanUsePreprocessor = true
};
// Call
settings.PreprocessorDirectory = preprocessorDirectory;
// Assert
Assert.AreEqual(preprocessorDirectory, settings.PreprocessorDirectory);
}
public void UsePreprocessor_SetValueWithCanUsePreprocessorTrue_ExpectedValueSet()
{
// Setup
bool usePreprocessor = new Random(11).NextBoolean();
var settings = new HydraulicLocationConfigurationSettings
{
CanUsePreprocessor = true
};
// Call
settings.UsePreprocessor = usePreprocessor;
// Assert
Assert.AreEqual(usePreprocessor, settings.UsePreprocessor);
}
/// <summary>
/// Sets the hydraulic location configuration settings.
/// </summary>
/// <param name="hydraulicLocationConfigurationSettings">The hydraulic location configuration settings to set on.</param>
/// <param name="readHydraulicLocationConfigurationDatabaseSettings">The read settings to set.</param>
/// <param name="usePreprocessorClosure">Indicator whether to use the preprocessor closure.</param>
/// <param name="hlcdFilePath">The hlcd file path.</param>
/// <exception cref="ArgumentNullException">Thrown when <paramref name="hydraulicLocationConfigurationSettings"/>
/// or <paramref name="hlcdFilePath"/> is <c>null</c>.</exception>
public static void SetHydraulicLocationConfigurationSettings(HydraulicLocationConfigurationSettings hydraulicLocationConfigurationSettings,
ReadHydraulicLocationConfigurationDatabaseSettings readHydraulicLocationConfigurationDatabaseSettings,
bool usePreprocessorClosure,
string hlcdFilePath)
{
if (hydraulicLocationConfigurationSettings == null)
{
throw new ArgumentNullException(nameof(hydraulicLocationConfigurationSettings));
}
if (hlcdFilePath == null)
{
throw new ArgumentNullException(nameof(hlcdFilePath));
}
if (readHydraulicLocationConfigurationDatabaseSettings != null)
{
hydraulicLocationConfigurationSettings.SetValues(
hlcdFilePath,
readHydraulicLocationConfigurationDatabaseSettings.ScenarioName,
readHydraulicLocationConfigurationDatabaseSettings.Year,
readHydraulicLocationConfigurationDatabaseSettings.Scope,
usePreprocessorClosure,
readHydraulicLocationConfigurationDatabaseSettings.SeaLevel,
readHydraulicLocationConfigurationDatabaseSettings.RiverDischarge,
readHydraulicLocationConfigurationDatabaseSettings.LakeLevel,
readHydraulicLocationConfigurationDatabaseSettings.WindDirection,
readHydraulicLocationConfigurationDatabaseSettings.WindSpeed,
readHydraulicLocationConfigurationDatabaseSettings.Comment);
}
else
{
log.Warn(Resources.HydraulicLocationConfigurationSettingsUpdateHelper_ReadHydraulicLocationConfigurationDatabaseSettings_No_ScenarioInformation_entries_present);
hydraulicLocationConfigurationSettings.SetValues(
hlcdFilePath,
HydraulicLocationConfigurationSettingsConstants.MandatoryConfigurationPropertyDefaultValue,
HydraulicLocationConfigurationSettingsConstants.YearDefaultValue,
HydraulicLocationConfigurationSettingsConstants.MandatoryConfigurationPropertyDefaultValue,
usePreprocessorClosure,
HydraulicLocationConfigurationSettingsConstants.OptionalConfigurationPropertyDefaultValue,
HydraulicLocationConfigurationSettingsConstants.OptionalConfigurationPropertyDefaultValue,
HydraulicLocationConfigurationSettingsConstants.OptionalConfigurationPropertyDefaultValue,
HydraulicLocationConfigurationSettingsConstants.OptionalConfigurationPropertyDefaultValue,
HydraulicLocationConfigurationSettingsConstants.OptionalConfigurationPropertyDefaultValue,
HydraulicLocationConfigurationSettingsConstants.AdditionalInformationConfigurationPropertyValue);
}
}
public void PreprocessorDirectory_SetInvalidValueWithCanUsePreprocessorTrue_ThrowsArgumentException(string preprocessorDirectory)
{
// Setup
var settings = new HydraulicLocationConfigurationSettings
{
CanUsePreprocessor = true
};
// Call
TestDelegate test = () => settings.PreprocessorDirectory = preprocessorDirectory;
// Assert
string message = Assert.Throws <ArgumentException>(test).Message;
Assert.AreEqual("De bestandsmap waar de preprocessor bestanden opslaat moet een waarde hebben.", message);
}
public void Read_WithValidEntity_UpdatesHydraulicBoundaryDatabase()
{
// Setup
var random = new Random(21);
bool usePreprocessorClosure = random.NextBoolean();
var entity = new HydraulicBoundaryDatabaseEntity
{
FilePath = "hydraulicBoundaryDatabaseFilePath",
Version = "hydraulicBoundaryDatabaseVersion",
HydraulicLocationConfigurationSettingsFilePath = "hlcdFilePath",
HydraulicLocationConfigurationSettingsUsePreprocessorClosure = Convert.ToByte(usePreprocessorClosure),
HydraulicLocationConfigurationSettingsScenarioName = "ScenarioName",
HydraulicLocationConfigurationSettingsYear = random.Next(),
HydraulicLocationConfigurationSettingsScope = "Scope",
HydraulicLocationConfigurationSettingsSeaLevel = "SeaLevel",
HydraulicLocationConfigurationSettingsRiverDischarge = "RiverDischarge",
HydraulicLocationConfigurationSettingsLakeLevel = "LakeLevel",
HydraulicLocationConfigurationSettingsWindDirection = "WindDirection",
HydraulicLocationConfigurationSettingsWindSpeed = "WindSpeed",
HydraulicLocationConfigurationSettingsComment = "Comment"
};
var hydraulicBoundaryDatabase = new HydraulicBoundaryDatabase();
// Call
entity.Read(hydraulicBoundaryDatabase);
// Assert
Assert.AreEqual(entity.FilePath, hydraulicBoundaryDatabase.FilePath);
Assert.AreEqual(entity.Version, hydraulicBoundaryDatabase.Version);
HydraulicLocationConfigurationSettings settings = hydraulicBoundaryDatabase.HydraulicLocationConfigurationSettings;
Assert.AreEqual(entity.HydraulicLocationConfigurationSettingsFilePath, settings.FilePath);
Assert.AreEqual(entity.HydraulicLocationConfigurationSettingsScenarioName, settings.ScenarioName);
Assert.AreEqual(entity.HydraulicLocationConfigurationSettingsYear, settings.Year);
Assert.AreEqual(entity.HydraulicLocationConfigurationSettingsScope, settings.Scope);
Assert.AreEqual(usePreprocessorClosure, settings.UsePreprocessorClosure);
Assert.AreEqual(entity.HydraulicLocationConfigurationSettingsSeaLevel, settings.SeaLevel);
Assert.AreEqual(entity.HydraulicLocationConfigurationSettingsRiverDischarge, settings.RiverDischarge);
Assert.AreEqual(entity.HydraulicLocationConfigurationSettingsLakeLevel, settings.LakeLevel);
Assert.AreEqual(entity.HydraulicLocationConfigurationSettingsWindDirection, settings.WindDirection);
Assert.AreEqual(entity.HydraulicLocationConfigurationSettingsWindSpeed, settings.WindSpeed);
Assert.AreEqual(entity.HydraulicLocationConfigurationSettingsComment, settings.Comment);
}
public void GivenSettingsWithPreprocessorSettings_WhenSettingCanUsePreprocessorFalse_ThenPreprocessorSettingsReset()
{
// Given
var settings = new HydraulicLocationConfigurationSettings
{
CanUsePreprocessor = true,
UsePreprocessor = true,
PreprocessorDirectory = "PreprocessorDirectory"
};
// When
settings.CanUsePreprocessor = false;
// Then
Assert.IsFalse(settings.CanUsePreprocessor);
Assert.IsFalse(settings.UsePreprocessor);
Assert.IsNull(settings.PreprocessorDirectory);
}
private static void SetHydraulicLocationConfigurationValues(HydraulicLocationConfigurationSettings settings,
string hlcdFilePath = "filePath")
{
const string scenarioName = "ScenarioName";
const int year = 2017;
const string scope = "Scope";
const bool usePreprocessorClosure = false;
const string seaLevel = "SeaLevel";
const string riverDischarge = "RiverDischarge";
const string lakeLevel = "LakeLevel";
const string windDirection = "WindDirection";
const string windSpeed = "WindSpeed";
const string comment = "Comment";
settings.SetValues(hlcdFilePath, scenarioName, year, scope,
usePreprocessorClosure, seaLevel, riverDischarge,
lakeLevel, windDirection, windSpeed, comment);
}
public void Create_ValidHydraulicBoundaryDatabase_ReturnsHydraulicBoundaryDatabaseEntity()
{
// Setup
var random = new Random(21);
var hydraulicBoundaryDatabase = new HydraulicBoundaryDatabase
{
FilePath = "hydraulicBoundaryDatabasefilePath",
Version = "Version"
};
hydraulicBoundaryDatabase.HydraulicLocationConfigurationSettings.SetValues("hlcdFilePath",
"ScenarioName",
random.Next(),
"Scope",
random.NextBoolean(),
"SeaLevel",
"RiverDischarge",
"LakeLevel",
"WindDirection",
"WindSpeed",
"Comment");
// Call
HydraulicBoundaryDatabaseEntity entity = hydraulicBoundaryDatabase.Create();
// Assert
TestHelper.AssertAreEqualButNotSame(hydraulicBoundaryDatabase.FilePath, entity.FilePath);
TestHelper.AssertAreEqualButNotSame(hydraulicBoundaryDatabase.Version, entity.Version);
HydraulicLocationConfigurationSettings settings = hydraulicBoundaryDatabase.HydraulicLocationConfigurationSettings;
TestHelper.AssertAreEqualButNotSame(settings.FilePath, entity.HydraulicLocationConfigurationSettingsFilePath);
Assert.AreEqual(Convert.ToByte(settings.UsePreprocessorClosure), entity.HydraulicLocationConfigurationSettingsUsePreprocessorClosure);
TestHelper.AssertAreEqualButNotSame(settings.ScenarioName, entity.HydraulicLocationConfigurationSettingsScenarioName);
TestHelper.AssertAreEqualButNotSame(settings.Year, entity.HydraulicLocationConfigurationSettingsYear);
TestHelper.AssertAreEqualButNotSame(settings.Scope, entity.HydraulicLocationConfigurationSettingsScope);
TestHelper.AssertAreEqualButNotSame(settings.SeaLevel, entity.HydraulicLocationConfigurationSettingsSeaLevel);
TestHelper.AssertAreEqualButNotSame(settings.RiverDischarge, entity.HydraulicLocationConfigurationSettingsRiverDischarge);
TestHelper.AssertAreEqualButNotSame(settings.LakeLevel, entity.HydraulicLocationConfigurationSettingsLakeLevel);
TestHelper.AssertAreEqualButNotSame(settings.WindDirection, entity.HydraulicLocationConfigurationSettingsWindDirection);
TestHelper.AssertAreEqualButNotSame(settings.WindSpeed, entity.HydraulicLocationConfigurationSettingsWindSpeed);
TestHelper.AssertAreEqualButNotSame(settings.Comment, entity.HydraulicLocationConfigurationSettingsComment);
}
public void ImportHydraulicLocationConfigurationSettings(HydraulicLocationConfigurationSettings hydraulicLocationConfigurationSettings, string hlcdFilePath)
{
if (hydraulicLocationConfigurationSettings == null)
{
throw new ArgumentNullException(nameof(hydraulicLocationConfigurationSettings));
}
if (hlcdFilePath == null)
{
throw new ArgumentNullException(nameof(hlcdFilePath));
}
var importSettingsActivity = new FileImportActivity(
new HydraulicLocationConfigurationDatabaseImporter(hydraulicLocationConfigurationSettings,
updateHandler,
hydraulicBoundaryDatabase,
hlcdFilePath),
Resources.HydraulicLocationConfigurationDatabaseImportHandler_ImportHydraulicLocationConfigurationSettings_Description);
ActivityProgressDialogRunner.Run(viewParent, importSettingsActivity);
}
public void Constructor_ExpectedValues()
{
// Call
var settings = new HydraulicLocationConfigurationSettings();
// Assert
Assert.IsNull(settings.FilePath);
Assert.IsNull(settings.ScenarioName);
Assert.AreEqual(0, settings.Year);
Assert.IsNull(settings.Scope);
Assert.IsNull(settings.SeaLevel);
Assert.IsNull(settings.RiverDischarge);
Assert.IsNull(settings.LakeLevel);
Assert.IsNull(settings.WindDirection);
Assert.IsNull(settings.WindSpeed);
Assert.IsNull(settings.Comment);
Assert.IsFalse(settings.UsePreprocessorClosure);
Assert.IsFalse(settings.CanUsePreprocessor);
Assert.IsFalse(settings.UsePreprocessor);
Assert.IsNull(settings.PreprocessorDirectory);
}
/// <summary>
/// Performs all <paramref name="calculations"/>.
/// </summary>
/// <param name="calculations">The collection of <see cref="DuneLocationCalculation"/> to perform.</param>
/// <param name="assessmentSection">The assessment section the calculations belong to.</param>
/// <param name="targetProbability">The target probability to use during the calculations.</param>
/// <param name="calculationIdentifier">The calculation identifier to use in all messages.</param>
/// <exception cref="ArgumentNullException">Thrown when <paramref name="calculations"/> or
/// <paramref name="assessmentSection"/> is <c>null</c>.</exception>
/// <exception cref="ArgumentException">Thrown when <paramref name="calculationIdentifier"/> is <c>null</c> or empty.</exception>
public void Calculate(IEnumerable <DuneLocationCalculation> calculations,
IAssessmentSection assessmentSection,
double targetProbability,
string calculationIdentifier)
{
if (calculations == null)
{
throw new ArgumentNullException(nameof(calculations));
}
if (assessmentSection == null)
{
throw new ArgumentNullException(nameof(assessmentSection));
}
string hydraulicBoundaryDatabaseFilePath = assessmentSection.HydraulicBoundaryDatabase.FilePath;
string preprocessorDirectory = assessmentSection.HydraulicBoundaryDatabase.EffectivePreprocessorDirectory();
HydraulicLocationConfigurationSettings hydraulicLocationConfigurationSettings = assessmentSection.HydraulicBoundaryDatabase.HydraulicLocationConfigurationSettings;
string validationProblem = HydraulicBoundaryDatabaseHelper.ValidateFilesForCalculation(hydraulicBoundaryDatabaseFilePath,
hydraulicLocationConfigurationSettings.FilePath,
preprocessorDirectory,
hydraulicLocationConfigurationSettings.UsePreprocessorClosure);
if (!string.IsNullOrEmpty(validationProblem))
{
log.ErrorFormat(RiskeerCommonFormsResources.CalculateHydraulicBoundaryLocation_Start_calculation_failed_0_,
validationProblem);
return;
}
ActivityProgressDialogRunner.Run(viewParent,
DuneLocationCalculationActivityFactory.CreateCalculationActivities(calculations,
assessmentSection,
targetProbability,
calculationIdentifier));
}
public void SetValues_WithArguments_SetsExpectedValues()
{
// Setup
var random = new Random(21);
const string filePath = "FilePath";
const string scenarioName = "ScenarioName";
int year = random.Next();
const string scope = "Scope";
bool usePreprocessorClosure = random.NextBoolean();
const string seaLevel = "SeaLevel";
const string riverDischarge = "RiverDischarge";
const string lakeLevel = "LakeLevel";
const string windDirection = "WindDirection";
const string windSpeed = "WindSpeed";
const string comment = "Comment";
var settings = new HydraulicLocationConfigurationSettings();
// Call
settings.SetValues(filePath, scenarioName, year, scope,
usePreprocessorClosure, seaLevel, riverDischarge,
lakeLevel, windDirection, windSpeed, comment);
// Assert
Assert.AreEqual(filePath, settings.FilePath);
Assert.AreEqual(scenarioName, settings.ScenarioName);
Assert.AreEqual(year, settings.Year);
Assert.AreEqual(scope, settings.Scope);
Assert.AreEqual(usePreprocessorClosure, settings.UsePreprocessorClosure);
Assert.AreEqual(seaLevel, settings.SeaLevel);
Assert.AreEqual(riverDischarge, settings.RiverDischarge);
Assert.AreEqual(lakeLevel, settings.LakeLevel);
Assert.AreEqual(windDirection, settings.WindDirection);
Assert.AreEqual(windSpeed, settings.WindSpeed);
Assert.AreEqual(comment, settings.Comment);
}
private static bool AreHydraulicBoundaryLocationConfigurationSettingsEquivalent(HydraulicLocationConfigurationSettings hydraulicLocationConfigurationSettings,
HydraulicLocationConfigurationSettings otherHydraulicLocationConfigurationSettings)
{
return(hydraulicLocationConfigurationSettings.ScenarioName == otherHydraulicLocationConfigurationSettings.ScenarioName &&
hydraulicLocationConfigurationSettings.Year == otherHydraulicLocationConfigurationSettings.Year &&
hydraulicLocationConfigurationSettings.Scope == otherHydraulicLocationConfigurationSettings.Scope &&
hydraulicLocationConfigurationSettings.UsePreprocessorClosure == otherHydraulicLocationConfigurationSettings.UsePreprocessorClosure &&
hydraulicLocationConfigurationSettings.SeaLevel == otherHydraulicLocationConfigurationSettings.SeaLevel &&
hydraulicLocationConfigurationSettings.RiverDischarge == otherHydraulicLocationConfigurationSettings.RiverDischarge &&
hydraulicLocationConfigurationSettings.LakeLevel == otherHydraulicLocationConfigurationSettings.LakeLevel &&
hydraulicLocationConfigurationSettings.WindDirection == otherHydraulicLocationConfigurationSettings.WindDirection &&
hydraulicLocationConfigurationSettings.WindSpeed == otherHydraulicLocationConfigurationSettings.WindSpeed &&
hydraulicLocationConfigurationSettings.Comment == otherHydraulicLocationConfigurationSettings.Comment);
}
public void Create_HydraulicBoundaryDatabaseLinked_SetsExpectedPropertiesToEntity()
{
// Setup
var random = new Random(21);
const string testFilePath = "path";
const string testVersion = "1";
var assessmentSection = new AssessmentSection(AssessmentSectionComposition.Dike)
{
HydraulicBoundaryDatabase =
{
FilePath = testFilePath,
Version = testVersion,
Locations =
{
new HydraulicBoundaryLocation(-1, "name", 1, 2)
}
},
WaveHeightCalculationsForUserDefinedTargetProbabilities =
{
new HydraulicBoundaryLocationCalculationsForTargetProbability(random.NextDouble(0, 0.1)),
new HydraulicBoundaryLocationCalculationsForTargetProbability(random.NextDouble(0, 0.1)),
new HydraulicBoundaryLocationCalculationsForTargetProbability(random.NextDouble(0, 0.1))
},
WaterLevelCalculationsForUserDefinedTargetProbabilities =
{
new HydraulicBoundaryLocationCalculationsForTargetProbability(random.NextDouble(0, 0.1)),
new HydraulicBoundaryLocationCalculationsForTargetProbability(random.NextDouble(0, 0.1))
}
};
assessmentSection.SetHydraulicBoundaryLocationCalculations(assessmentSection.HydraulicBoundaryDatabase.Locations);
SetHydraulicBoundaryLocationCalculationInputsOfAssessmentSection(assessmentSection);
var registry = new PersistenceRegistry();
// Call
AssessmentSectionEntity entity = assessmentSection.Create(registry);
// Assert
HydraulicBoundaryDatabaseEntity hydraulicBoundaryDatabaseEntity = entity.HydraulicBoundaryDatabaseEntities.Single();
HydraulicBoundaryDatabase hydraulicBoundaryDatabase = assessmentSection.HydraulicBoundaryDatabase;
Assert.AreEqual(hydraulicBoundaryDatabase.FilePath, hydraulicBoundaryDatabaseEntity.FilePath);
Assert.AreEqual(hydraulicBoundaryDatabase.Version, hydraulicBoundaryDatabaseEntity.Version);
HydraulicLocationConfigurationSettings settings = hydraulicBoundaryDatabase.HydraulicLocationConfigurationSettings;
Assert.AreEqual(settings.FilePath, hydraulicBoundaryDatabaseEntity.HydraulicLocationConfigurationSettingsFilePath);
Assert.AreEqual(settings.ScenarioName, hydraulicBoundaryDatabaseEntity.HydraulicLocationConfigurationSettingsScenarioName);
Assert.AreEqual(settings.Year, hydraulicBoundaryDatabaseEntity.HydraulicLocationConfigurationSettingsYear);
Assert.AreEqual(settings.Scope, hydraulicBoundaryDatabaseEntity.HydraulicLocationConfigurationSettingsScope);
Assert.AreEqual(settings.SeaLevel, hydraulicBoundaryDatabaseEntity.HydraulicLocationConfigurationSettingsSeaLevel);
Assert.AreEqual(settings.RiverDischarge, hydraulicBoundaryDatabaseEntity.HydraulicLocationConfigurationSettingsRiverDischarge);
Assert.AreEqual(settings.LakeLevel, hydraulicBoundaryDatabaseEntity.HydraulicLocationConfigurationSettingsLakeLevel);
Assert.AreEqual(settings.WindDirection, hydraulicBoundaryDatabaseEntity.HydraulicLocationConfigurationSettingsWindDirection);
Assert.AreEqual(settings.WindSpeed, hydraulicBoundaryDatabaseEntity.HydraulicLocationConfigurationSettingsWindSpeed);
Assert.AreEqual(settings.Comment, hydraulicBoundaryDatabaseEntity.HydraulicLocationConfigurationSettingsComment);
int expectedNrOfHydraulicBoundaryLocations = hydraulicBoundaryDatabase.Locations.Count;
Assert.AreEqual(expectedNrOfHydraulicBoundaryLocations, entity.HydraulicLocationEntities.Count);
AssertHydraulicLocationCalculationCollectionEntities(assessmentSection, entity);
}