public void Create_StringPropertiesDoNotShareReference()
{
// Setup
const string originalName = "name";
const string originalComments = "comments";
var section = new AssessmentSection(AssessmentSectionComposition.Dike)
{
Name = originalName,
Comments =
{
Body = originalComments
}
};
var registry = new PersistenceRegistry();
// Call
AssessmentSectionEntity entity = section.Create(registry);
// Assert
Assert.AreNotSame(originalName, entity.Name,
"To create stable binary representations/fingerprints, it's really important that strings are not shared.");
Assert.AreNotSame(originalComments, entity.Comments,
"To create stable binary representations/fingerprints, it's really important that strings are not shared.");
Assert.AreEqual(originalName, entity.Name);
Assert.AreEqual(originalComments, entity.Comments);
}
private static void AddEntityForReferenceLine(AssessmentSection section, AssessmentSectionEntity entity)
{
if (section.ReferenceLine.Points.Any())
{
entity.ReferenceLinePointXml = new Point2DCollectionXmlSerializer().ToXml(section.ReferenceLine.Points);
}
}
private static void ReadHydraulicBoundaryLocationCalculations(this AssessmentSectionEntity entity,
IAssessmentSection assessmentSection,
ReadConversionCollector collector)
{
entity.HydraulicLocationCalculationCollectionEntity1.Read(assessmentSection.WaterLevelCalculationsForSignalFloodingProbability, collector);
entity.HydraulicLocationCalculationCollectionEntity.Read(assessmentSection.WaterLevelCalculationsForMaximumAllowableFloodingProbability, collector);
}
private static void AddHydraulicLocationCalculationEntities(AssessmentSection assessmentSection,
AssessmentSectionEntity entity,
PersistenceRegistry registry)
{
entity.HydraulicLocationCalculationCollectionEntity1 = assessmentSection.WaterLevelCalculationsForSignalFloodingProbability.Create(registry);
entity.HydraulicLocationCalculationCollectionEntity = assessmentSection.WaterLevelCalculationsForMaximumAllowableFloodingProbability.Create(registry);
}
private static void ReadReferenceLine(this AssessmentSectionEntity entity, IAssessmentSection assessmentSection)
{
if (entity.ReferenceLinePointXml != null)
{
Point2D[] points = new Point2DCollectionXmlSerializer().FromXml(entity.ReferenceLinePointXml);
assessmentSection.ReferenceLine.SetGeometry(points);
}
}
private static void ReadSpecificFailureMechanisms(this AssessmentSectionEntity entity,
IAssessmentSection assessmentSection,
ReadConversionCollector collector)
{
IEnumerable <SpecificFailureMechanismEntity> specificFailureMechanismEntities =
entity.SpecificFailureMechanismEntities
.OrderBy(e => e.Order);
assessmentSection.SpecificFailureMechanisms.AddRange(specificFailureMechanismEntities.Select(e => e.Read(collector)).ToArray());
}
private static void ReadBackgroundData(this AssessmentSectionEntity entity, IAssessmentSection assessmentSection)
{
BackgroundData readBackgroundData = entity.BackgroundDataEntities.Single().Read();
BackgroundData backgroundData = assessmentSection.BackgroundData;
backgroundData.IsVisible = readBackgroundData.IsVisible;
backgroundData.Transparency = readBackgroundData.Transparency;
backgroundData.Name = readBackgroundData.Name;
backgroundData.Configuration = readBackgroundData.Configuration;
}
private static void AddHydraulicLocationCalculationForTargetProbabilityCollectionEntities(
List <HydraulicBoundaryLocationCalculationsForTargetProbability> hydraulicBoundaryLocationCalculationsForTargetProbabilities,
HydraulicBoundaryLocationCalculationType calculationType,
AssessmentSectionEntity entity,
PersistenceRegistry registry)
{
for (int i = 0; i < hydraulicBoundaryLocationCalculationsForTargetProbabilities.Count; i++)
{
entity.HydraulicLocationCalculationForTargetProbabilityCollectionEntities.Add(
hydraulicBoundaryLocationCalculationsForTargetProbabilities[i].Create(calculationType, i, registry));
}
}
/// <summary>
/// Read the <see cref="AssessmentSectionEntity"/> and use the information to construct a <see cref="AssessmentSection"/>.
/// </summary>
/// <param name="entity">The <see cref="AssessmentSectionEntity"/> to create <see cref="AssessmentSection"/> for.</param>
/// <param name="collector">The object keeping track of read operations.</param>
/// <returns>A new <see cref="AssessmentSection"/>.</returns>
/// <exception cref="ArgumentNullException">Thrown when <paramref name="collector"/> is <c>null</c>.</exception>
internal static AssessmentSection Read(this AssessmentSectionEntity entity, ReadConversionCollector collector)
{
if (collector == null)
{
throw new ArgumentNullException(nameof(collector));
}
var assessmentSection = new AssessmentSection((AssessmentSectionComposition)entity.Composition,
entity.MaximumAllowableFloodingProbability,
entity.SignalFloodingProbability)
{
Id = entity.Id,
Name = entity.Name,
Comments =
{
Body = entity.Comments
},
FailureMechanismContribution =
{
NormativeProbabilityType = (NormativeProbabilityType)entity.NormativeProbabilityType
}
};
entity.ReadBackgroundData(assessmentSection);
entity.ReadHydraulicDatabase(assessmentSection, collector);
entity.ReadHydraulicLocationCalculationsForTargetProbabilities(assessmentSection, collector);
entity.ReadReferenceLine(assessmentSection);
entity.ReadPipingFailureMechanism(assessmentSection, collector);
entity.ReadGrassCoverErosionInwardsFailureMechanism(assessmentSection, collector);
entity.ReadHeightStructuresFailureMechanism(assessmentSection, collector);
entity.ReadWaterPressureAsphaltCoverFailureMechanism(assessmentSection, collector);
entity.ReadClosingStructuresFailureMechanism(assessmentSection, collector);
entity.ReadMacroStabilityInwardsFailureMechanism(assessmentSection, collector);
entity.ReadWaveImpactAsphaltCoverFailureMechanism(assessmentSection, collector);
entity.ReadGrassCoverErosionOutwardsFailureMechanism(assessmentSection, collector);
entity.ReadGrassCoverSlipOffInwardsFailureMechanism(assessmentSection, collector);
entity.ReadGrassCoverSlipOffOutwardsFailureMechanism(assessmentSection, collector);
entity.ReadMicrostabilityFailureMechanism(assessmentSection, collector);
entity.ReadPipingStructureFailureMechanism(assessmentSection, collector);
entity.ReadDuneErosionFailureMechanism(assessmentSection, collector);
entity.ReadStabilityStoneCoverFailureMechanism(assessmentSection, collector);
entity.ReadStabilityPointStructuresFailureMechanism(assessmentSection, collector);
entity.ReadSpecificFailureMechanisms(assessmentSection, collector);
return(assessmentSection);
}
/// <summary>
/// Creates a <see cref="AssessmentSectionEntity"/> based on the information of the <see cref="AssessmentSection"/>.
/// </summary>
/// <param name="section">The section to create a database entity for.</param>
/// <param name="registry">The object keeping track of create operations.</param>
/// <returns>A new <see cref="AssessmentSectionEntity"/>.</returns>
/// <exception cref="ArgumentNullException">Thrown when <paramref name="registry"/> is <c>null</c>.</exception>
internal static AssessmentSectionEntity Create(this AssessmentSection section, PersistenceRegistry registry)
{
if (registry == null)
{
throw new ArgumentNullException(nameof(registry));
}
FailureMechanismContribution contribution = section.FailureMechanismContribution;
var entity = new AssessmentSectionEntity
{
Id = section.Id.DeepClone(),
Name = section.Name.DeepClone(),
Composition = Convert.ToByte(section.Composition),
Comments = section.Comments.Body.DeepClone(),
MaximumAllowableFloodingProbability = contribution.MaximumAllowableFloodingProbability,
SignalFloodingProbability = contribution.SignalFloodingProbability,
NormativeProbabilityType = Convert.ToByte(contribution.NormativeProbabilityType)
};
AddEntityForHydraulicDatabase(section.HydraulicBoundaryDatabase, entity, registry);
AddHydraulicLocationCalculationEntities(section, entity, registry);
AddHydraulicLocationCalculationForTargetProbabilityCollectionEntities(section, entity, registry);
AddEntityForReferenceLine(section, entity);
entity.BackgroundDataEntities.Add(section.BackgroundData.Create());
entity.FailureMechanismEntities.Add(section.Piping.Create(registry));
entity.FailureMechanismEntities.Add(section.GrassCoverErosionInwards.Create(registry));
entity.FailureMechanismEntities.Add(section.HeightStructures.Create(registry));
entity.FailureMechanismEntities.Add(section.WaterPressureAsphaltCover.Create(registry));
entity.FailureMechanismEntities.Add(section.ClosingStructures.Create(registry));
entity.FailureMechanismEntities.Add(section.MacroStabilityInwards.Create(registry));
entity.FailureMechanismEntities.Add(section.WaveImpactAsphaltCover.Create(registry));
entity.FailureMechanismEntities.Add(section.GrassCoverErosionOutwards.Create(registry));
entity.FailureMechanismEntities.Add(section.GrassCoverSlipOffInwards.Create(registry));
entity.FailureMechanismEntities.Add(section.GrassCoverSlipOffOutwards.Create(registry));
entity.FailureMechanismEntities.Add(section.Microstability.Create(registry));
entity.FailureMechanismEntities.Add(section.PipingStructure.Create(registry));
entity.FailureMechanismEntities.Add(section.StabilityStoneCover.Create(registry));
entity.FailureMechanismEntities.Add(section.DuneErosion.Create(registry));
entity.FailureMechanismEntities.Add(section.StabilityPointStructures.Create(registry));
AddSpecificFailureMechanismEntities(section, entity, registry);
return(entity);
}
public void Create_HydraulicBoundaryDatabaseNotLinked_SetsExpectedPropertiesToEntity()
{
// Setup
var assessmentSection = new AssessmentSection(AssessmentSectionComposition.Dike);
assessmentSection.SetHydraulicBoundaryLocationCalculations(assessmentSection.HydraulicBoundaryDatabase.Locations);
var registry = new PersistenceRegistry();
// Call
AssessmentSectionEntity entity = assessmentSection.Create(registry);
// Assert
CollectionAssert.IsEmpty(entity.HydraulicBoundaryDatabaseEntities);
CollectionAssert.IsEmpty(entity.HydraulicLocationEntities);
AssertHydraulicLocationCalculationCollectionEntities(assessmentSection, entity);
}
private static void ReadHydraulicDatabase(this AssessmentSectionEntity entity, AssessmentSection assessmentSection, ReadConversionCollector collector)
{
HydraulicBoundaryDatabaseEntity hydraulicBoundaryDatabaseEntity = entity.HydraulicBoundaryDatabaseEntities.SingleOrDefault();
if (hydraulicBoundaryDatabaseEntity != null)
{
HydraulicBoundaryDatabase hydraulicBoundaryDatabase = assessmentSection.HydraulicBoundaryDatabase;
hydraulicBoundaryDatabaseEntity.Read(hydraulicBoundaryDatabase);
HydraulicBoundaryLocation[] readHydraulicBoundaryLocations = entity.HydraulicLocationEntities
.OrderBy(hl => hl.Order)
.Select(hle => hle.Read(collector))
.ToArray();
hydraulicBoundaryDatabase.Locations.AddRange(readHydraulicBoundaryLocations);
assessmentSection.SetHydraulicBoundaryLocationCalculations(readHydraulicBoundaryLocations);
entity.ReadHydraulicBoundaryLocationCalculations(assessmentSection, collector);
}
}
private static void ReadHydraulicLocationCalculationsForTargetProbabilities(this AssessmentSectionEntity entity,
IAssessmentSection assessmentSection,
ReadConversionCollector collector)
{
IEnumerable <HydraulicLocationCalculationForTargetProbabilityCollectionEntity> waterLevelHydraulicLocationCalculationForTargetProbabilityCollectionEntities =
entity.HydraulicLocationCalculationForTargetProbabilityCollectionEntities
.Where(e => e.HydraulicBoundaryLocationCalculationType == (short)HydraulicBoundaryLocationCalculationType.WaterLevel)
.OrderBy(e => e.Order);
assessmentSection.WaterLevelCalculationsForUserDefinedTargetProbabilities.AddRange(waterLevelHydraulicLocationCalculationForTargetProbabilityCollectionEntities.Select(e => e.Read(collector))
.ToArray());
IEnumerable <HydraulicLocationCalculationForTargetProbabilityCollectionEntity> waveHeightHydraulicLocationCalculationForTargetProbabilityCollectionEntities =
entity.HydraulicLocationCalculationForTargetProbabilityCollectionEntities
.Where(e => e.HydraulicBoundaryLocationCalculationType == (short)HydraulicBoundaryLocationCalculationType.WaveHeight)
.OrderBy(e => e.Order);
assessmentSection.WaveHeightCalculationsForUserDefinedTargetProbabilities.AddRange(waveHeightHydraulicLocationCalculationForTargetProbabilityCollectionEntities.Select(e => e.Read(collector))
.ToArray());
}
public void Read_WithAssessmentSection_ReturnsNewProjectWithAssessmentSection()
{
// Setup
AssessmentSectionEntity assessmentSectionEntity = CreateAssessmentSectionEntity(1);
var entity = new ProjectEntity
{
Description = "testName",
AssessmentSectionEntities =
{
assessmentSectionEntity
}
};
// Call
RiskeerProject project = entity.Read(new ReadConversionCollector());
// Assert
Assert.AreEqual(entity.Description, project.Description);
Assert.AreEqual(assessmentSectionEntity.Name, project.AssessmentSection.Name);
}
public void Create_WithReferenceLine_AddsReferenceLinePointEntities()
{
// Setup
var points = new[]
{
new Point2D(1, 0),
new Point2D(2, 3),
new Point2D(5, 3)
};
var assessmentSection = new AssessmentSection(AssessmentSectionComposition.Dike);
assessmentSection.ReferenceLine.SetGeometry(points);
var registry = new PersistenceRegistry();
// Call
AssessmentSectionEntity entity = assessmentSection.Create(registry);
// Assert
string expectedXml = new Point2DCollectionXmlSerializer().ToXml(points);
Assert.AreEqual(expectedXml, entity.ReferenceLinePointXml);
}
private static void AddEntityForHydraulicDatabase(HydraulicBoundaryDatabase hydraulicBoundaryDatabase, AssessmentSectionEntity entity, PersistenceRegistry registry)
{
if (hydraulicBoundaryDatabase.IsLinked())
{
entity.HydraulicBoundaryDatabaseEntities.Add(hydraulicBoundaryDatabase.Create());
for (var i = 0; i < hydraulicBoundaryDatabase.Locations.Count; i++)
{
HydraulicBoundaryLocation hydraulicBoundaryLocation = hydraulicBoundaryDatabase.Locations[i];
entity.HydraulicLocationEntities.Add(hydraulicBoundaryLocation.Create(registry, i));
}
}
}
private static void ReadMacroStabilityInwardsFailureMechanism(this AssessmentSectionEntity entity, AssessmentSection assessmentSection, ReadConversionCollector collector)
{
FailureMechanismEntity macroStabilityInwardsFailureMechanismEntity = GetFailureMechanismEntityOfType(entity, FailureMechanismType.MacroStabilityInwards);
macroStabilityInwardsFailureMechanismEntity?.ReadAsMacroStabilityInwardsFailureMechanism(assessmentSection.MacroStabilityInwards, collector);
}
private static void AddSpecificFailureMechanismEntities(AssessmentSection section, AssessmentSectionEntity entity, PersistenceRegistry registry)
{
var i = 0;
foreach (SpecificFailureMechanism specificFailureMechanism in section.SpecificFailureMechanisms)
{
entity.SpecificFailureMechanismEntities.Add(specificFailureMechanism.Create(registry, i++));
}
}
public void Create_WithCollector_ReturnsAssessmentSectionEntityWithCompositionAndFailureMechanisms(AssessmentSectionComposition assessmentSectionComposition)
{
// Setup
const string testId = "testId";
const string testName = "testName";
const string comments = "Some text";
const double maximumAllowableFloodingProbability = 0.05;
const double signalFloodingProbability = 0.02;
var random = new Random(65);
const string mapDataName = "map data name";
const double transparency = 0.3;
const bool isVisible = true;
const BackgroundDataType backgroundType = BackgroundDataType.Wmts;
var normativeProbabilityType = random.NextEnumValue <NormativeProbabilityType>();
IEnumerable <SpecificFailureMechanism> specificFailureMechanisms = Enumerable.Repeat(new SpecificFailureMechanism(), random.Next(1, 10))
.ToArray();
var assessmentSection = new AssessmentSection(assessmentSectionComposition)
{
Id = testId,
Name = testName,
Comments =
{
Body = comments
},
FailureMechanismContribution =
{
MaximumAllowableFloodingProbability = maximumAllowableFloodingProbability,
SignalFloodingProbability = signalFloodingProbability,
NormativeProbabilityType = normativeProbabilityType
},
BackgroundData =
{
Name = mapDataName,
Transparency = (RoundedDouble)transparency,
IsVisible = isVisible,
Configuration = new WmtsBackgroundDataConfiguration(false,null, null, null)
}
};
assessmentSection.SpecificFailureMechanisms.AddRange(specificFailureMechanisms);
var registry = new PersistenceRegistry();
// Call
AssessmentSectionEntity entity = assessmentSection.Create(registry);
// Assert
Assert.IsNotNull(entity);
Assert.AreEqual(Convert.ToByte(assessmentSectionComposition), entity.Composition);
Assert.AreEqual(testId, entity.Id);
Assert.AreEqual(testName, entity.Name);
Assert.AreEqual(comments, entity.Comments);
Assert.AreEqual(maximumAllowableFloodingProbability, entity.MaximumAllowableFloodingProbability);
Assert.AreEqual(signalFloodingProbability, entity.SignalFloodingProbability);
Assert.AreEqual(Convert.ToByte(normativeProbabilityType), entity.NormativeProbabilityType);
Assert.AreEqual(15, entity.FailureMechanismEntities.Count);
Assert.IsNotNull(entity.FailureMechanismEntities.SingleOrDefault(fme => fme.FailureMechanismType == (short)FailureMechanismType.Piping));
Assert.IsNotNull(entity.FailureMechanismEntities.SingleOrDefault(fme => fme.FailureMechanismType == (short)FailureMechanismType.GrassRevetmentTopErosionAndInwards));
Assert.IsNotNull(entity.FailureMechanismEntities.SingleOrDefault(fme => fme.FailureMechanismType == (short)FailureMechanismType.MacroStabilityInwards));
Assert.IsNotNull(entity.FailureMechanismEntities.SingleOrDefault(fme => fme.FailureMechanismType == (short)FailureMechanismType.Microstability));
Assert.IsNotNull(entity.FailureMechanismEntities.SingleOrDefault(fme => fme.FailureMechanismType == (short)FailureMechanismType.StabilityStoneRevetment));
Assert.IsNotNull(entity.FailureMechanismEntities.SingleOrDefault(fme => fme.FailureMechanismType == (short)FailureMechanismType.WaveImpactOnAsphaltRevetment));
Assert.IsNotNull(entity.FailureMechanismEntities.SingleOrDefault(fme => fme.FailureMechanismType == (short)FailureMechanismType.WaterOverpressureAsphaltRevetment));
Assert.IsNotNull(entity.FailureMechanismEntities.SingleOrDefault(fme => fme.FailureMechanismType == (short)FailureMechanismType.GrassRevetmentErosionOutwards));
Assert.IsNotNull(entity.FailureMechanismEntities.SingleOrDefault(fme => fme.FailureMechanismType == (short)FailureMechanismType.GrassRevetmentSlidingOutwards));
Assert.IsNotNull(entity.FailureMechanismEntities.SingleOrDefault(fme => fme.FailureMechanismType == (short)FailureMechanismType.GrassRevetmentSlidingInwards));
Assert.IsNotNull(entity.FailureMechanismEntities.SingleOrDefault(fme => fme.FailureMechanismType == (short)FailureMechanismType.StructureHeight));
Assert.IsNotNull(entity.FailureMechanismEntities.SingleOrDefault(fme => fme.FailureMechanismType == (short)FailureMechanismType.ReliabilityClosingOfStructure));
Assert.IsNotNull(entity.FailureMechanismEntities.SingleOrDefault(fme => fme.FailureMechanismType == (short)FailureMechanismType.PipingAtStructure));
Assert.IsNotNull(entity.FailureMechanismEntities.SingleOrDefault(fme => fme.FailureMechanismType == (short)FailureMechanismType.StabilityPointStructures));
Assert.IsNotNull(entity.FailureMechanismEntities.SingleOrDefault(fme => fme.FailureMechanismType == (short)FailureMechanismType.DuneErosion));
Assert.AreEqual(assessmentSection.SpecificFailureMechanisms.Count, entity.SpecificFailureMechanismEntities.Count);
Assert.IsNull(entity.ReferenceLinePointXml);
Assert.AreEqual(1, entity.BackgroundDataEntities.Count);
BackgroundDataEntity backgroundDataEntity = entity.BackgroundDataEntities.Single();
Assert.IsNotNull(backgroundDataEntity);
Assert.AreEqual(mapDataName, backgroundDataEntity.Name);
Assert.AreEqual(transparency, backgroundDataEntity.Transparency);
Assert.AreEqual(Convert.ToByte(isVisible), backgroundDataEntity.IsVisible);
Assert.AreEqual(Convert.ToByte(backgroundType), backgroundDataEntity.BackgroundDataType);
Assert.AreEqual(1, backgroundDataEntity.BackgroundDataMetaEntities.Count);
BackgroundDataMetaEntity isConfiguredMetaEntity = backgroundDataEntity.BackgroundDataMetaEntities.Single();
Assert.AreEqual("IsConfigured", isConfiguredMetaEntity.Key);
Assert.AreEqual("0", isConfiguredMetaEntity.Value);
}
private static void AssertHydraulicLocationCalculationCollectionEntities(AssessmentSection assessmentSection, AssessmentSectionEntity entity)
{
AssertHydraulicLocationCalculationCollectionEntity(assessmentSection.WaterLevelCalculationsForSignalFloodingProbability,
entity.HydraulicLocationCalculationCollectionEntity1.HydraulicLocationCalculationEntities);
AssertHydraulicLocationCalculationCollectionEntity(assessmentSection.WaterLevelCalculationsForMaximumAllowableFloodingProbability,
entity.HydraulicLocationCalculationCollectionEntity.HydraulicLocationCalculationEntities);
AssertHydraulicLocationCalculationForTargetProbabilityCollectionEntity(assessmentSection.WaveHeightCalculationsForUserDefinedTargetProbabilities,
entity.HydraulicLocationCalculationForTargetProbabilityCollectionEntities
.Where(e => e.HydraulicBoundaryLocationCalculationType == (short)HydraulicBoundaryLocationCalculationType.WaveHeight));
AssertHydraulicLocationCalculationForTargetProbabilityCollectionEntity(assessmentSection.WaterLevelCalculationsForUserDefinedTargetProbabilities,
entity.HydraulicLocationCalculationForTargetProbabilityCollectionEntities
.Where(e => e.HydraulicBoundaryLocationCalculationType == (short)HydraulicBoundaryLocationCalculationType.WaterLevel));
}
private static FailureMechanismEntity GetFailureMechanismEntityOfType(AssessmentSectionEntity entity, FailureMechanismType type)
{
return(entity.FailureMechanismEntities.SingleOrDefault(fme => fme.FailureMechanismType == (int)type));
}
private static void ReadDuneErosionFailureMechanism(this AssessmentSectionEntity entity, AssessmentSection assessmentSection, ReadConversionCollector collector)
{
FailureMechanismEntity duneErosionFailureMechanismEntity = GetFailureMechanismEntityOfType(entity, FailureMechanismType.DuneErosion);
duneErosionFailureMechanismEntity?.ReadAsDuneErosionFailureMechanism(assessmentSection.DuneErosion, collector);
}
private static void ReadPipingStructureFailureMechanism(this AssessmentSectionEntity entity, AssessmentSection assessmentSection, ReadConversionCollector collector)
{
FailureMechanismEntity pipingStructureFailureMechanismEntity = GetFailureMechanismEntityOfType(entity, FailureMechanismType.PipingAtStructure);
pipingStructureFailureMechanismEntity?.ReadAsPipingStructureFailureMechanism(assessmentSection.PipingStructure, collector);
}
private static void ReadWaveImpactAsphaltCoverFailureMechanism(this AssessmentSectionEntity entity, AssessmentSection assessmentSection, ReadConversionCollector collector)
{
FailureMechanismEntity waveImpactAsphaltCoverFailureMechanismEntity = GetFailureMechanismEntityOfType(entity, FailureMechanismType.WaveImpactOnAsphaltRevetment);
waveImpactAsphaltCoverFailureMechanismEntity?.ReadAsWaveImpactAsphaltCoverFailureMechanism(assessmentSection.WaveImpactAsphaltCover, collector);
}
private static void ReadStabilityStoneCoverFailureMechanism(this AssessmentSectionEntity entity, AssessmentSection assessmentSection, ReadConversionCollector collector)
{
FailureMechanismEntity stabilityStoneCoverFailureMechanismEntity = GetFailureMechanismEntityOfType(entity, FailureMechanismType.StabilityStoneRevetment);
stabilityStoneCoverFailureMechanismEntity?.ReadAsStabilityStoneCoverFailureMechanism(assessmentSection.StabilityStoneCover, collector);
}
private static void ReadGrassCoverSlipOffOutwardsFailureMechanism(this AssessmentSectionEntity entity, AssessmentSection assessmentSection, ReadConversionCollector collector)
{
FailureMechanismEntity grassCoverSlipOffOutwardsFailureMechanismEntity = GetFailureMechanismEntityOfType(entity, FailureMechanismType.GrassRevetmentSlidingOutwards);
grassCoverSlipOffOutwardsFailureMechanismEntity?.ReadAsGrassCoverSlipOffOutwardsFailureMechanism(assessmentSection.GrassCoverSlipOffOutwards, collector);
}
private static void AddHydraulicLocationCalculationForTargetProbabilityCollectionEntities(AssessmentSection assessmentSection,
AssessmentSectionEntity entity,
PersistenceRegistry registry)
{
AddHydraulicLocationCalculationForTargetProbabilityCollectionEntities(assessmentSection.WaterLevelCalculationsForUserDefinedTargetProbabilities,
HydraulicBoundaryLocationCalculationType.WaterLevel,
entity,
registry);
AddHydraulicLocationCalculationForTargetProbabilityCollectionEntities(assessmentSection.WaveHeightCalculationsForUserDefinedTargetProbabilities,
HydraulicBoundaryLocationCalculationType.WaveHeight,
entity,
registry);
}
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);
}
private static void ReadMicrostabilityFailureMechanism(this AssessmentSectionEntity entity, AssessmentSection assessmentSection, ReadConversionCollector collector)
{
FailureMechanismEntity microstabilityFailureMechanismEntity = GetFailureMechanismEntityOfType(entity, FailureMechanismType.Microstability);
microstabilityFailureMechanismEntity?.ReadAsMicrostabilityFailureMechanism(assessmentSection.Microstability, collector);
}
private static void ReadStabilityPointStructuresFailureMechanism(this AssessmentSectionEntity entity, AssessmentSection assessmentSection, ReadConversionCollector collector)
{
FailureMechanismEntity stabilityPointStructuresFailureMechanismEntity = GetFailureMechanismEntityOfType(entity, FailureMechanismType.StabilityPointStructures);
stabilityPointStructuresFailureMechanismEntity?.ReadAsStabilityPointStructuresFailureMechanism(assessmentSection.StabilityPointStructures, collector);
}
