/// <summary>
/// Creates a <see cref="StabilityStoneCoverWaveConditionsCalculationEntity"/> based on the information of the
/// <see cref="StabilityStoneCoverWaveConditionsCalculation"/>.
/// </summary>
/// <param name="calculation">The calculation 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="calculation"/> resides within its parent.</param>
/// <returns>A new <see cref="StabilityStoneCoverWaveConditionsCalculationEntity"/>.</returns>
/// <exception cref="ArgumentNullException">Thrown when any parameter is <c>null</c>.</exception>
internal static StabilityStoneCoverWaveConditionsCalculationEntity Create(this StabilityStoneCoverWaveConditionsCalculation calculation,
PersistenceRegistry registry, int order)
{
if (calculation == null)
{
throw new ArgumentNullException(nameof(calculation));
}
if (registry == null)
{
throw new ArgumentNullException(nameof(registry));
}
var entity = new StabilityStoneCoverWaveConditionsCalculationEntity
{
Order = order,
Name = calculation.Name.DeepClone(),
Comments = calculation.Comments.Body.DeepClone()
};
SetInputParameters(entity, calculation.InputParameters, registry);
SetOutputEntities(entity, calculation);
return(entity);
}
public void Read_EntityWithNullValues_ReturnCalculationWithNaNValues()
{
// Setup
var entity = new StabilityStoneCoverWaveConditionsCalculationEntity();
var collector = new ReadConversionCollector();
// Call
StabilityStoneCoverWaveConditionsCalculation calculation = entity.Read(collector);
// Assert
Assert.IsNull(calculation.Name);
Assert.IsNull(calculation.Comments.Body);
StabilityStoneCoverWaveConditionsInput calculationInput = calculation.InputParameters;
Assert.IsNaN(calculationInput.BreakWater.Height);
Assert.IsNaN(calculationInput.Orientation);
Assert.IsNaN(calculationInput.UpperBoundaryRevetment);
Assert.IsNaN(calculationInput.LowerBoundaryRevetment);
Assert.IsNaN(calculationInput.UpperBoundaryWaterLevels);
Assert.IsNaN(calculationInput.LowerBoundaryWaterLevels);
Assert.IsNull(calculationInput.HydraulicBoundaryLocation);
Assert.IsNull(calculationInput.ForeshoreProfile);
Assert.IsNull(calculation.Output);
}
private static void SetInputParameters(StabilityStoneCoverWaveConditionsCalculationEntity entity,
StabilityStoneCoverWaveConditionsInput calculationInput,
PersistenceRegistry registry)
{
if (calculationInput.HydraulicBoundaryLocation != null)
{
entity.HydraulicLocationEntity = calculationInput.HydraulicBoundaryLocation.Create(registry, 0);
}
if (calculationInput.ForeshoreProfile != null)
{
entity.ForeshoreProfileEntity = calculationInput.ForeshoreProfile.Create(registry, 0);
}
if (calculationInput.CalculationsTargetProbability != null)
{
entity.HydraulicLocationCalculationForTargetProbabilityCollectionEntity =
calculationInput.CalculationsTargetProbability.Create(HydraulicBoundaryLocationCalculationType.WaterLevel, 0, registry);
}
entity.Orientation = calculationInput.Orientation.ToNaNAsNull();
entity.UseBreakWater = Convert.ToByte(calculationInput.UseBreakWater);
entity.BreakWaterType = Convert.ToByte(calculationInput.BreakWater.Type);
entity.BreakWaterHeight = calculationInput.BreakWater.Height.ToNaNAsNull();
entity.UseForeshore = Convert.ToByte(calculationInput.UseForeshore);
entity.UpperBoundaryRevetment = calculationInput.UpperBoundaryRevetment.ToNaNAsNull();
entity.LowerBoundaryRevetment = calculationInput.LowerBoundaryRevetment.ToNaNAsNull();
entity.UpperBoundaryWaterLevels = calculationInput.UpperBoundaryWaterLevels.ToNaNAsNull();
entity.LowerBoundaryWaterLevels = calculationInput.LowerBoundaryWaterLevels.ToNaNAsNull();
entity.StepSize = Convert.ToByte(calculationInput.StepSize);
entity.CalculationType = Convert.ToByte(calculationInput.CalculationType);
entity.WaterLevelType = Convert.ToByte(calculationInput.WaterLevelType);
}
public void Create_HasCalculationOutputWithColumns_EntityHasOrderedCalculationOutputEntity()
{
// Setup
var registry = new PersistenceRegistry();
var calculation = new StabilityStoneCoverWaveConditionsCalculation
{
Output = StabilityStoneCoverWaveConditionsOutputFactory.CreateOutputWithColumns(new[]
{
new TestWaveConditionsOutput(),
new TestWaveConditionsOutput()
})
};
// Call
StabilityStoneCoverWaveConditionsCalculationEntity entity = calculation.Create(registry, 0);
// Assert
ICollection <StabilityStoneCoverWaveConditionsOutputEntity> outputEntities = entity.StabilityStoneCoverWaveConditionsOutputEntities;
Assert.AreEqual(2, outputEntities.Count);
CollectionAssert.AreEqual(new[]
{
0,
1
}, outputEntities.Select(oe => oe.Order));
Assert.IsTrue(outputEntities.All(o => o.OutputType == Convert.ToByte(StabilityStoneCoverWaveConditionsOutputType.Columns)));
}
private static void ReadCalculationOutputs(StabilityStoneCoverWaveConditionsCalculationEntity entity, StabilityStoneCoverWaveConditionsCalculation calculation)
{
if (!entity.StabilityStoneCoverWaveConditionsOutputEntities.Any())
{
return;
}
var columnsOutput = new List <WaveConditionsOutput>();
var blocksOutput = new List <WaveConditionsOutput>();
foreach (StabilityStoneCoverWaveConditionsOutputEntity conditionsOutputEntity in entity.StabilityStoneCoverWaveConditionsOutputEntities.OrderBy(oe => oe.Order))
{
WaveConditionsOutput output = conditionsOutputEntity.Read();
if (conditionsOutputEntity.OutputType == Convert.ToByte(StabilityStoneCoverWaveConditionsOutputType.Columns))
{
columnsOutput.Add(output);
}
else if (conditionsOutputEntity.OutputType == Convert.ToByte(StabilityStoneCoverWaveConditionsOutputType.Blocks))
{
blocksOutput.Add(output);
}
}
calculation.Output = CreateStabilityStoneCoverWaveConditionsOutput(columnsOutput, blocksOutput);
}
public void Create_HasHydraulicLocationCalculationsForTargetProbability_EntityHasHydraulicLocationCalculationForTargetProbabilityCollectionEntity()
{
// Setup
var random = new Random(21);
var hydraulicCalculations = new HydraulicBoundaryLocationCalculationsForTargetProbability(random.NextDouble(0, 0.1));
var hydraulicCalculationsEntity = new HydraulicLocationCalculationForTargetProbabilityCollectionEntity();
var registry = new PersistenceRegistry();
registry.Register(hydraulicCalculationsEntity, hydraulicCalculations);
var calculation = new StabilityStoneCoverWaveConditionsCalculation
{
InputParameters =
{
CalculationsTargetProbability = hydraulicCalculations
}
};
// Call
StabilityStoneCoverWaveConditionsCalculationEntity entity = calculation.Create(registry, 0);
// Assert
Assert.AreSame(hydraulicCalculationsEntity, entity.HydraulicLocationCalculationForTargetProbabilityCollectionEntity);
}
/// <summary>
/// Reads the <see cref="StabilityStoneCoverWaveConditionsCalculationEntity"/> and use the
/// information to update a <see cref="StabilityStoneCoverWaveConditionsCalculation"/>.
/// </summary>
/// <param name="entity">
/// The <see cref="StabilityStoneCoverWaveConditionsCalculationEntity"/>
/// to create <see cref="StabilityStoneCoverWaveConditionsCalculation"/> for.
/// </param>
/// <param name="collector">The object keeping track of read operations.</param>
/// <returns>A new <see cref="StabilityStoneCoverWaveConditionsCalculation"/>.</returns>
/// <exception cref="ArgumentNullException">Thrown when any parameter is <c>null</c>.</exception>
internal static StabilityStoneCoverWaveConditionsCalculation Read(this StabilityStoneCoverWaveConditionsCalculationEntity entity, ReadConversionCollector collector)
{
if (entity == null)
{
throw new ArgumentNullException(nameof(entity));
}
if (collector == null)
{
throw new ArgumentNullException(nameof(collector));
}
var calculation = new StabilityStoneCoverWaveConditionsCalculation
{
Name = entity.Name,
Comments =
{
Body = entity.Comments
}
};
ReadCalculationInputs(calculation.InputParameters, entity, collector);
ReadCalculationOutputs(entity, calculation);
return(calculation);
}
public void Create_CalculationWithNaNProperties_ReturnCalculationEntity()
{
// Setup
var calculation = new StabilityStoneCoverWaveConditionsCalculation
{
InputParameters =
{
Orientation = RoundedDouble.NaN,
UpperBoundaryRevetment = RoundedDouble.NaN,
LowerBoundaryRevetment = RoundedDouble.NaN,
UpperBoundaryWaterLevels = RoundedDouble.NaN,
LowerBoundaryWaterLevels = RoundedDouble.NaN,
BreakWater =
{
Height = RoundedDouble.NaN
}
}
};
var registry = new PersistenceRegistry();
// Call
StabilityStoneCoverWaveConditionsCalculationEntity entity = calculation.Create(registry, 1234);
// Assert
Assert.IsNull(entity.Orientation);
Assert.IsNull(entity.UpperBoundaryRevetment);
Assert.IsNull(entity.LowerBoundaryRevetment);
Assert.IsNull(entity.UpperBoundaryWaterLevels);
Assert.IsNull(entity.LowerBoundaryWaterLevels);
Assert.IsNull(entity.BreakWaterHeight);
}
public void Create_GroupWithChildStabilityStoneCoverWaveConditionsCalculationsAndChildCalculationGroups_CreateEntities()
{
// Setup
var group = new CalculationGroup
{
Children =
{
new CalculationGroup
{
Name = "A"
},
new StabilityStoneCoverWaveConditionsCalculation
{
Name = "B"
},
new CalculationGroup
{
Name = "C"
},
new StabilityStoneCoverWaveConditionsCalculation
{
Name = "D"
}
}
};
var registry = new PersistenceRegistry();
// Call
CalculationGroupEntity entity = group.Create(registry, 0);
// Assert
CalculationGroupEntity[] childGroupEntities = entity.CalculationGroupEntity1.ToArray();
StabilityStoneCoverWaveConditionsCalculationEntity[] childCalculationEntities = entity.StabilityStoneCoverWaveConditionsCalculationEntities.ToArray();
Assert.AreEqual(2, childGroupEntities.Length);
Assert.AreEqual(2, childCalculationEntities.Length);
CalculationGroupEntity childEntity1 = childGroupEntities[0];
Assert.AreEqual("A", childEntity1.Name);
Assert.AreEqual(0, childEntity1.Order);
CollectionAssert.IsEmpty(childEntity1.CalculationGroupEntity1);
StabilityStoneCoverWaveConditionsCalculationEntity childEntity2 = childCalculationEntities[0];
Assert.AreEqual("B", childEntity2.Name);
Assert.AreEqual(1, childEntity2.Order);
CalculationGroupEntity childEntity3 = childGroupEntities[1];
Assert.AreEqual("C", childEntity3.Name);
Assert.AreEqual(2, childEntity3.Order);
CollectionAssert.IsEmpty(childEntity3.CalculationGroupEntity1);
StabilityStoneCoverWaveConditionsCalculationEntity childEntity4 = childCalculationEntities[1];
Assert.AreEqual("D", childEntity4.Name);
Assert.AreEqual(3, childEntity4.Order);
}
public void Read_CollectorIsNull_ThrowArgumentNullException()
{
// Setup
var entity = new StabilityStoneCoverWaveConditionsCalculationEntity();
// Call
TestDelegate call = () => entity.Read(null);
// Assert
string paramName = Assert.Throws <ArgumentNullException>(call).ParamName;
Assert.AreEqual("collector", paramName);
}
public void Read_EntityWithCalculationOutputEntityWithBlocksAndColumns_CalculationWithOutput()
{
// Setup
const double outputALevel = 5.4;
const double outputBLevel = 2.3;
const double outputCLevel = 13.2;
var entity = new StabilityStoneCoverWaveConditionsCalculationEntity
{
StabilityStoneCoverWaveConditionsOutputEntities =
{
new StabilityStoneCoverWaveConditionsOutputEntity
{
CalculationConvergence = Convert.ToByte(CalculationConvergence.NotCalculated),
WaterLevel = outputBLevel,
Order = 1,
OutputType = Convert.ToByte(StabilityStoneCoverWaveConditionsOutputType.Columns)
},
new StabilityStoneCoverWaveConditionsOutputEntity
{
CalculationConvergence = Convert.ToByte(CalculationConvergence.NotCalculated),
WaterLevel = outputCLevel,
Order = 2,
OutputType = Convert.ToByte(StabilityStoneCoverWaveConditionsOutputType.Blocks)
},
new StabilityStoneCoverWaveConditionsOutputEntity
{
CalculationConvergence = Convert.ToByte(CalculationConvergence.NotCalculated),
WaterLevel = outputALevel,
Order = 0,
OutputType = Convert.ToByte(StabilityStoneCoverWaveConditionsOutputType.Columns)
}
}
};
var collector = new ReadConversionCollector();
// Call
StabilityStoneCoverWaveConditionsCalculation calculation = entity.Read(collector);
// Assert
Assert.IsNotNull(calculation.Output);
double accuracy = calculation.Output.ColumnsOutput.ElementAt(0).WaterLevel.GetAccuracy();
Assert.AreEqual(2, calculation.Output.ColumnsOutput.Count());
Assert.AreEqual(outputALevel, calculation.Output.ColumnsOutput.ElementAt(0).WaterLevel, accuracy);
Assert.AreEqual(outputBLevel, calculation.Output.ColumnsOutput.ElementAt(1).WaterLevel, accuracy);
Assert.AreEqual(1, calculation.Output.BlocksOutput.Count());
Assert.AreEqual(outputCLevel, calculation.Output.BlocksOutput.ElementAt(0).WaterLevel, accuracy);
}
public void Create_CalculationWithPropertiesSet_ReturnCalculationEntity()
{
// Setup
var random = new Random(21);
int order = random.Next();
var calculation = new StabilityStoneCoverWaveConditionsCalculation
{
InputParameters =
{
Orientation = random.NextRoundedDouble(0, 360),
UseBreakWater = random.NextBoolean(),
UseForeshore = random.NextBoolean(),
UpperBoundaryRevetment = (RoundedDouble)6.10,
LowerBoundaryRevetment = (RoundedDouble)3.58,
UpperBoundaryWaterLevels = (RoundedDouble)5.88,
LowerBoundaryWaterLevels = (RoundedDouble)3.40,
StepSize = random.NextEnumValue <WaveConditionsInputStepSize>(),
WaterLevelType = random.NextEnumValue <WaveConditionsInputWaterLevelType>(),
CalculationType = random.NextEnumValue <StabilityStoneCoverWaveConditionsCalculationType>()
}
};
var registry = new PersistenceRegistry();
// Call
StabilityStoneCoverWaveConditionsCalculationEntity entity = calculation.Create(registry, order);
// Assert
StabilityStoneCoverWaveConditionsInput input = calculation.InputParameters;
Assert.AreEqual(input.Orientation, entity.Orientation, input.Orientation.GetAccuracy());
Assert.AreEqual(Convert.ToByte(input.UseBreakWater), entity.UseBreakWater);
Assert.AreEqual(Convert.ToByte(input.UseForeshore), entity.UseForeshore);
Assert.AreEqual(input.UpperBoundaryRevetment, entity.UpperBoundaryRevetment, input.UpperBoundaryRevetment.GetAccuracy());
Assert.AreEqual(input.LowerBoundaryRevetment, entity.LowerBoundaryRevetment, input.LowerBoundaryRevetment.GetAccuracy());
Assert.AreEqual(input.UpperBoundaryWaterLevels, entity.UpperBoundaryWaterLevels, input.UpperBoundaryWaterLevels.GetAccuracy());
Assert.AreEqual(input.LowerBoundaryWaterLevels, entity.LowerBoundaryWaterLevels, input.LowerBoundaryWaterLevels.GetAccuracy());
Assert.AreEqual(Convert.ToByte(input.StepSize), entity.StepSize);
Assert.AreEqual(Convert.ToByte(input.CalculationType), entity.CalculationType);
Assert.AreEqual(Convert.ToByte(input.WaterLevelType), entity.WaterLevelType);
Assert.AreEqual(order, entity.Order);
Assert.IsNull(entity.CalculationGroupEntity);
CollectionAssert.IsEmpty(entity.StabilityStoneCoverWaveConditionsOutputEntities);
Assert.IsNull(entity.ForeshoreProfileEntity);
Assert.IsNull(entity.HydraulicLocationEntity);
Assert.IsNull(entity.HydraulicLocationCalculationForTargetProbabilityCollectionEntity);
}
public void Read_EntityWithHydraulicBoundaryLocationNotYetInCollector_CalculationWithCreatedHydraulicBoundaryLocationAndRegisteredNewEntities()
{
// Setup
HydraulicLocationEntity hydraulicLocationEntity = HydraulicLocationEntityTestFactory.CreateHydraulicLocationEntity();
var entity = new StabilityStoneCoverWaveConditionsCalculationEntity
{
HydraulicLocationEntity = hydraulicLocationEntity
};
var collector = new ReadConversionCollector();
// Call
entity.Read(collector);
// Assert
Assert.IsTrue(collector.Contains(hydraulicLocationEntity));
}
public void Create_HasForeshoreProfile_EntityHasForeshoreProfileEntity()
{
// Setup
var registry = new PersistenceRegistry();
var calculation = new StabilityStoneCoverWaveConditionsCalculation
{
InputParameters =
{
ForeshoreProfile = new TestForeshoreProfile()
}
};
// Call
StabilityStoneCoverWaveConditionsCalculationEntity entity = calculation.Create(registry, 0);
// Assert
Assert.IsNotNull(entity.ForeshoreProfileEntity);
}
public void Read_EntityWithHydraulicBoundaryLocationInCollector_CalculationHasAlreadyReadHydraulicBoundaryLocation()
{
// Setup
var hydraulicBoundaryLocation = new HydraulicBoundaryLocation(1, "A", 1.1, 2.2);
var hydraulicLocationEntity = new HydraulicLocationEntity();
var entity = new StabilityStoneCoverWaveConditionsCalculationEntity
{
HydraulicLocationEntity = hydraulicLocationEntity
};
var collector = new ReadConversionCollector();
collector.Read(hydraulicLocationEntity, hydraulicBoundaryLocation);
// Call
StabilityStoneCoverWaveConditionsCalculation calculation = entity.Read(collector);
// Assert
Assert.AreSame(hydraulicBoundaryLocation, calculation.InputParameters.HydraulicBoundaryLocation);
}
public void Read_EntityWithHydraulicBoundaryLocationCalculationsForTargetProbabilityInCollector_CalculationHasAlreadyReadHydraulicBoundaryLocationCalculationsForTargetProbability()
{
// Setup
var hydraulicBoundaryLocationCalculationsForTargetProbability = new HydraulicBoundaryLocationCalculationsForTargetProbability(0.05);
HydraulicLocationCalculationForTargetProbabilityCollectionEntity calculationForTargetProbabilityCollectionEntity =
HydraulicLocationCalculationForTargetProbabilityCollectionEntityTestFactory.CreateHydraulicLocationCalculationForTargetProbabilityCollectionEntity();
var entity = new StabilityStoneCoverWaveConditionsCalculationEntity
{
HydraulicLocationCalculationForTargetProbabilityCollectionEntity = calculationForTargetProbabilityCollectionEntity
};
var collector = new ReadConversionCollector();
collector.Read(calculationForTargetProbabilityCollectionEntity, hydraulicBoundaryLocationCalculationsForTargetProbability);
// Call
StabilityStoneCoverWaveConditionsCalculation calculation = entity.Read(collector);
// Assert
Assert.AreSame(hydraulicBoundaryLocationCalculationsForTargetProbability, calculation.InputParameters.CalculationsTargetProbability);
}
private static void ReadCalculationInputs(StabilityStoneCoverWaveConditionsInput inputParameters,
StabilityStoneCoverWaveConditionsCalculationEntity entity,
ReadConversionCollector collector)
{
inputParameters.ForeshoreProfile = GetDikeProfileValue(entity.ForeshoreProfileEntity, collector);
inputParameters.HydraulicBoundaryLocation = GetHydraulicBoundaryLocationValue(entity.HydraulicLocationEntity, collector);
inputParameters.CalculationsTargetProbability = GetHydraulicBoundaryLocationCalculationsForTargetProbabilityValue(
entity.HydraulicLocationCalculationForTargetProbabilityCollectionEntity, collector);
inputParameters.Orientation = (RoundedDouble)entity.Orientation.ToNullAsNaN();
inputParameters.UseForeshore = Convert.ToBoolean(entity.UseForeshore);
inputParameters.UseBreakWater = Convert.ToBoolean(entity.UseBreakWater);
inputParameters.BreakWater.Height = (RoundedDouble)entity.BreakWaterHeight.ToNullAsNaN();
inputParameters.BreakWater.Type = (BreakWaterType)entity.BreakWaterType;
inputParameters.UpperBoundaryRevetment = (RoundedDouble)entity.UpperBoundaryRevetment.ToNullAsNaN();
inputParameters.LowerBoundaryRevetment = (RoundedDouble)entity.LowerBoundaryRevetment.ToNullAsNaN();
inputParameters.UpperBoundaryWaterLevels = (RoundedDouble)entity.UpperBoundaryWaterLevels.ToNullAsNaN();
inputParameters.LowerBoundaryWaterLevels = (RoundedDouble)entity.LowerBoundaryWaterLevels.ToNullAsNaN();
inputParameters.StepSize = (WaveConditionsInputStepSize)entity.StepSize;
inputParameters.CalculationType = (StabilityStoneCoverWaveConditionsCalculationType)entity.CalculationType;
inputParameters.WaterLevelType = (WaveConditionsInputWaterLevelType)entity.WaterLevelType;
}
public void Create_HasHydraulicBoundaryLocation_EntityHasHydraulicLocationEntity()
{
// Setup
var hydraulicBoundaryLocation = new HydraulicBoundaryLocation(1, "A", 2.3, 4.5);
var registry = new PersistenceRegistry();
HydraulicLocationEntity hydraulicLocationEntity = hydraulicBoundaryLocation.Create(registry, 0);
var calculation = new StabilityStoneCoverWaveConditionsCalculation
{
InputParameters =
{
HydraulicBoundaryLocation = hydraulicBoundaryLocation
}
};
// Call
StabilityStoneCoverWaveConditionsCalculationEntity entity = calculation.Create(registry, 0);
// Assert
Assert.AreSame(hydraulicLocationEntity, entity.HydraulicLocationEntity);
}
private static void SetOutputEntities(StabilityStoneCoverWaveConditionsCalculationEntity entity, StabilityStoneCoverWaveConditionsCalculation calculation)
{
if (calculation.HasOutput)
{
var i = 0;
if (calculation.Output.BlocksOutput != null)
{
foreach (WaveConditionsOutput output in calculation.Output.BlocksOutput)
{
entity.StabilityStoneCoverWaveConditionsOutputEntities.Add(output.CreateStabilityStoneCoverWaveConditionsOutputEntity(StabilityStoneCoverWaveConditionsOutputType.Blocks, i++));
}
}
if (calculation.Output.ColumnsOutput != null)
{
foreach (WaveConditionsOutput output in calculation.Output.ColumnsOutput)
{
entity.StabilityStoneCoverWaveConditionsOutputEntities.Add(output.CreateStabilityStoneCoverWaveConditionsOutputEntity(StabilityStoneCoverWaveConditionsOutputType.Columns, i++));
}
}
}
}
public void Read_EntityWithForeshoreProfileInCollector_CalculationHasAlreadyReadForeshoreProfile()
{
// Setup
var foreshoreProfile = new TestForeshoreProfile();
var foreshoreProfileEntity = new ForeshoreProfileEntity
{
GeometryXml = new Point2DCollectionXmlSerializer().ToXml(Enumerable.Empty <Point2D>())
};
var entity = new StabilityStoneCoverWaveConditionsCalculationEntity
{
ForeshoreProfileEntity = foreshoreProfileEntity
};
var collector = new ReadConversionCollector();
collector.Read(foreshoreProfileEntity, foreshoreProfile);
// Call
StabilityStoneCoverWaveConditionsCalculation calculation = entity.Read(collector);
// Assert
Assert.AreSame(foreshoreProfile, calculation.InputParameters.ForeshoreProfile);
}
public void Create_StringPropertiesDoNotShareReference()
{
// Setup
const string name = "A";
const string comments = "B";
var calculation = new StabilityStoneCoverWaveConditionsCalculation
{
Name = name,
Comments =
{
Body = comments
}
};
var registry = new PersistenceRegistry();
// Call
StabilityStoneCoverWaveConditionsCalculationEntity entity = calculation.Create(registry, 0);
// Assert
TestHelper.AssertAreEqualButNotSame(calculation.Name, entity.Name);
TestHelper.AssertAreEqualButNotSame(calculation.Comments.Body, entity.Comments);
}
public void Read_EntityWithForeshoreProfileNotYetInCollector_CalculationWithCreatedForeshoreProfileAndRegisteredNewEntities()
{
// Setup
const string id = "profile";
var foreshoreProfileEntity = new ForeshoreProfileEntity
{
Id = id,
GeometryXml = new Point2DCollectionXmlSerializer().ToXml(Enumerable.Empty <Point2D>())
};
var entity = new StabilityStoneCoverWaveConditionsCalculationEntity
{
ForeshoreProfileEntity = foreshoreProfileEntity
};
var collector = new ReadConversionCollector();
// Call
StabilityStoneCoverWaveConditionsCalculation calculation = entity.Read(collector);
// Assert
Assert.IsTrue(collector.Contains(foreshoreProfileEntity));
CollectionAssert.AreEqual(id, calculation.InputParameters.ForeshoreProfile.Id);
}
public void Read_ValidEntity_ReturnCalculation()
{
// Setup
const string name = "Calculation Name";
const string comments = "Calculation Comment";
var random = new Random(21);
double orientation = random.NextDouble();
bool useBreakWater = random.NextBoolean();
var breakWaterType = random.NextEnumValue <BreakWaterType>();
double breakWaterHeight = random.NextDouble();
bool useForeshore = random.NextBoolean();
const double lowerBoundaryRevetment = 3.58;
const double upperBoundaryRevetment = 6.10;
const double lowerBoundaryWaterLevels = 3.40;
const double upperBoundaryWaterLevels = 5.88;
var stepSize = random.NextEnumValue <WaveConditionsInputStepSize>();
var calculationType = random.NextEnumValue <StabilityStoneCoverWaveConditionsCalculationType>();
var waterLevelType = random.NextEnumValue <WaveConditionsInputWaterLevelType>();
var entity = new StabilityStoneCoverWaveConditionsCalculationEntity
{
Name = name,
Comments = comments,
UseBreakWater = Convert.ToByte(useBreakWater),
BreakWaterType = Convert.ToByte(breakWaterType),
BreakWaterHeight = breakWaterHeight,
UseForeshore = Convert.ToByte(useForeshore),
Orientation = orientation,
UpperBoundaryRevetment = upperBoundaryRevetment,
LowerBoundaryRevetment = lowerBoundaryRevetment,
UpperBoundaryWaterLevels = upperBoundaryWaterLevels,
LowerBoundaryWaterLevels = lowerBoundaryWaterLevels,
StepSize = Convert.ToByte(stepSize),
CalculationType = Convert.ToByte(calculationType),
WaterLevelType = Convert.ToByte(waterLevelType)
};
var collector = new ReadConversionCollector();
// Call
StabilityStoneCoverWaveConditionsCalculation calculation = entity.Read(collector);
// Assert
Assert.AreEqual(name, calculation.Name);
Assert.AreEqual(comments, calculation.Comments.Body);
StabilityStoneCoverWaveConditionsInput calculationInput = calculation.InputParameters;
Assert.AreEqual(useBreakWater, calculationInput.UseBreakWater);
Assert.AreEqual(breakWaterType, calculationInput.BreakWater.Type);
RoundedDoubleTestHelper.AssertRoundedDouble(breakWaterHeight, calculationInput.BreakWater.Height);
Assert.AreEqual(useForeshore, calculationInput.UseForeshore);
RoundedDoubleTestHelper.AssertRoundedDouble(orientation, calculationInput.Orientation);
RoundedDoubleTestHelper.AssertRoundedDouble(upperBoundaryRevetment, calculationInput.UpperBoundaryRevetment);
RoundedDoubleTestHelper.AssertRoundedDouble(lowerBoundaryRevetment, calculationInput.LowerBoundaryRevetment);
RoundedDoubleTestHelper.AssertRoundedDouble(upperBoundaryWaterLevels, calculationInput.UpperBoundaryWaterLevels);
RoundedDoubleTestHelper.AssertRoundedDouble(lowerBoundaryWaterLevels, calculationInput.LowerBoundaryWaterLevels);
Assert.AreEqual(stepSize, calculationInput.StepSize);
Assert.AreEqual(calculationType, calculationInput.CalculationType);
Assert.AreEqual(waterLevelType, calculationInput.WaterLevelType);
Assert.IsNull(calculationInput.HydraulicBoundaryLocation);
Assert.IsNull(calculationInput.ForeshoreProfile);
Assert.IsNull(calculationInput.CalculationsTargetProbability);
Assert.IsNull(calculation.Output);
}
