public void Create_CalculationWithoutOutput_ReturnsHydraulicLocationCalculationEntity()
{
// Setup
var random = new Random(33);
bool shouldIllustrationPointsBeCalculated = random.NextBoolean();
var hydraulicBoundaryLocation = new TestHydraulicBoundaryLocation();
var calculation = new HydraulicBoundaryLocationCalculation(hydraulicBoundaryLocation)
{
InputParameters =
{
ShouldIllustrationPointsBeCalculated = shouldIllustrationPointsBeCalculated
},
Output = null
};
var registry = new PersistenceRegistry();
var hydraulicLocationEntity = new HydraulicLocationEntity();
registry.Register(hydraulicLocationEntity, hydraulicBoundaryLocation);
// Call
HydraulicLocationCalculationEntity entity = calculation.Create(registry);
// Assert
Assert.IsNotNull(entity);
Assert.AreEqual(Convert.ToByte(shouldIllustrationPointsBeCalculated), entity.ShouldIllustrationPointsBeCalculated);
Assert.IsEmpty(entity.HydraulicLocationOutputEntities);
}
private static HydraulicLocationCalculationEntity CreateCalculationEntityWithOutputEntity(int seed)
{
HydraulicLocationCalculationEntity calculationEntity = CreateCalculationEntity(seed);
calculationEntity.HydraulicLocationOutputEntities.Add(CreateHydraulicOutputEntity(seed));
return(calculationEntity);
}
private static void CreateHydraulicBoundaryLocationCalculationOutput(HydraulicLocationCalculationEntity hydraulicLocationCalculationEntity,
HydraulicBoundaryLocationCalculationOutput output)
{
if (output != null)
{
hydraulicLocationCalculationEntity.HydraulicLocationOutputEntities.Add(output.CreateHydraulicLocationOutputEntity());
}
}
public void Read_EntityWithValidValues_SetsCalculationsWithExpectedValues()
{
// Setup
var random = new Random(21);
HydraulicLocationEntity hydraulicLocationEntityOne = HydraulicLocationEntityTestFactory.CreateHydraulicLocationEntity();
var calculationEntityWithoutOutput = new HydraulicLocationCalculationEntity
{
HydraulicLocationEntity = hydraulicLocationEntityOne,
ShouldIllustrationPointsBeCalculated = Convert.ToByte(random.NextBoolean())
};
HydraulicLocationEntity hydraulicLocationEntityTwo = HydraulicLocationEntityTestFactory.CreateHydraulicLocationEntity();
var calculationEntityWithOutput = new HydraulicLocationCalculationEntity
{
HydraulicLocationEntity = hydraulicLocationEntityTwo,
ShouldIllustrationPointsBeCalculated = Convert.ToByte(random.NextBoolean()),
HydraulicLocationOutputEntities =
{
new HydraulicLocationOutputEntity()
}
};
var collectionEntity = new HydraulicLocationCalculationCollectionEntity
{
HydraulicLocationCalculationEntities =
{
calculationEntityWithoutOutput,
calculationEntityWithOutput
}
};
var hydraulicBoundaryLocationOne = new TestHydraulicBoundaryLocation("1");
var hydraulicBoundaryLocationTwo = new TestHydraulicBoundaryLocation("2");
var collector = new ReadConversionCollector();
collector.Read(hydraulicLocationEntityOne, hydraulicBoundaryLocationOne);
collector.Read(hydraulicLocationEntityTwo, hydraulicBoundaryLocationTwo);
var calculationOne = new HydraulicBoundaryLocationCalculation(hydraulicBoundaryLocationOne);
var calculationTwo = new HydraulicBoundaryLocationCalculation(hydraulicBoundaryLocationTwo);
// Call
collectionEntity.Read(new[]
{
calculationOne,
calculationTwo
}, collector);
// Assert
Assert.AreEqual(Convert.ToBoolean(calculationEntityWithoutOutput.ShouldIllustrationPointsBeCalculated),
calculationOne.InputParameters.ShouldIllustrationPointsBeCalculated);
Assert.IsNull(calculationOne.Output);
Assert.AreEqual(Convert.ToBoolean(calculationEntityWithOutput.ShouldIllustrationPointsBeCalculated),
calculationTwo.InputParameters.ShouldIllustrationPointsBeCalculated);
Assert.IsNotNull(calculationTwo.Output);
}
private static void AssertHydraulicBoundaryLocationCalculation(HydraulicLocationCalculationEntity expected,
HydraulicBoundaryLocationCalculation actual)
{
Assert.AreEqual(Convert.ToBoolean(expected.ShouldIllustrationPointsBeCalculated),
actual.InputParameters.ShouldIllustrationPointsBeCalculated);
AssertHydraulicBoundaryLocationCalculationOutput(expected.HydraulicLocationOutputEntities.SingleOrDefault(),
actual.Output);
}
public void Read_CalculationWithoutOutput_HydraulicBoundaryLocationCalculationWithExpectedValues()
{
// Setup
HydraulicLocationCalculationEntity entity = CreateCalculationEntity(21);
var calculation = new HydraulicBoundaryLocationCalculation(new TestHydraulicBoundaryLocation());
// Call
entity.Read(calculation);
// Assert
AssertHydraulicBoundaryLocationCalculation(entity, calculation);
}
public void Read_CalculationWithOutputAndIllustrationPoints_HydraulicBoundaryLocationCalculationWithExpectedValues()
{
// Setup
HydraulicLocationCalculationEntity entity = CreateCalculationEntityWithOutputAndGeneralResultEntity(21);
var calculation = new HydraulicBoundaryLocationCalculation(new TestHydraulicBoundaryLocation());
// Call
entity.Read(calculation);
// Assert
AssertHydraulicBoundaryLocationCalculation(entity, calculation);
}
public void Read_HydraulicBoundaryLocationCalculationNull_ThrowsArgumentNullException()
{
// Setup
var entity = new HydraulicLocationCalculationEntity();
// Call
TestDelegate call = () => entity.Read(null);
// Assert
var exception = Assert.Throws <ArgumentNullException>(call);
Assert.AreEqual("calculation", exception.ParamName);
}
public void Create_WithValidCollection_ReturnsEntityWithExpectedResults()
{
// Setup
var random = new Random(21);
int order = random.Next();
var calculationType = random.NextEnumValue <HydraulicBoundaryLocationCalculationType>();
var hydraulicBoundaryLocation = new TestHydraulicBoundaryLocation();
var calculation = new HydraulicBoundaryLocationCalculation(hydraulicBoundaryLocation)
{
InputParameters =
{
ShouldIllustrationPointsBeCalculated = random.NextBoolean()
}
};
var calculations = new HydraulicBoundaryLocationCalculationsForTargetProbability(random.NextDouble(0, 0.1))
{
HydraulicBoundaryLocationCalculations =
{
calculation
}
};
var hydraulicLocationEntity = new HydraulicLocationEntity();
var registry = new PersistenceRegistry();
registry.Register(hydraulicLocationEntity, hydraulicBoundaryLocation);
// Call
HydraulicLocationCalculationForTargetProbabilityCollectionEntity entity = calculations.Create(calculationType, order, registry);
// Assert
Assert.IsNotNull(entity);
Assert.AreEqual(order, entity.Order);
Assert.AreEqual(calculations.TargetProbability, entity.TargetProbability);
Assert.AreEqual(Convert.ToByte(calculationType), entity.HydraulicBoundaryLocationCalculationType);
HydraulicLocationCalculationEntity hydraulicLocationCalculationEntity = entity.HydraulicLocationCalculationEntities.Single();
Assert.AreSame(hydraulicLocationEntity, hydraulicLocationCalculationEntity.HydraulicLocationEntity);
Assert.AreEqual(Convert.ToByte(calculation.InputParameters.ShouldIllustrationPointsBeCalculated),
hydraulicLocationCalculationEntity.ShouldIllustrationPointsBeCalculated);
CollectionAssert.IsEmpty(hydraulicLocationCalculationEntity.HydraulicLocationOutputEntities);
}
public void Create_CalculationWithAlreadyCreatedHydraulicBoundaryLocation_ReturnsEntityWithHydraulicBoundaryLocationEntity()
{
// Setup
var hydraulicLocation = new TestHydraulicBoundaryLocation();
var registry = new PersistenceRegistry();
var hydraulicLocationEntity = new HydraulicLocationEntity();
registry.Register(hydraulicLocationEntity, hydraulicLocation);
var calculation = new HydraulicBoundaryLocationCalculation(hydraulicLocation);
// Call
HydraulicLocationCalculationEntity entity = calculation.Create(registry);
// Assert
Assert.IsNotNull(entity);
Assert.AreSame(hydraulicLocationEntity, entity.HydraulicLocationEntity);
}
private static HydraulicLocationCalculationEntity CreateCalculationEntityWithOutputAndGeneralResultEntity(int seed)
{
var random = new Random(seed);
var generalResultEntity = new GeneralResultSubMechanismIllustrationPointEntity
{
GoverningWindDirectionName = "A wind direction",
GoverningWindDirectionAngle = random.NextDouble()
};
HydraulicLocationOutputEntity hydraulicLocationOutputEntity = CreateHydraulicOutputEntity(seed);
hydraulicLocationOutputEntity.GeneralResultSubMechanismIllustrationPointEntity = generalResultEntity;
HydraulicLocationCalculationEntity calculationEntity = CreateCalculationEntity(seed);
calculationEntity.HydraulicLocationOutputEntities.Add(hydraulicLocationOutputEntity);
return(calculationEntity);
}
public void Create_CalculationWithOutput_ReturnsHydraulicLocationCalculationEntityWithOutput()
{
// Setup
var random = new Random(33);
bool shouldIllustrationPointsBeCalculated = random.NextBoolean();
var hydraulicBoundaryLocation = new TestHydraulicBoundaryLocation();
var calculation = new HydraulicBoundaryLocationCalculation(hydraulicBoundaryLocation)
{
InputParameters =
{
ShouldIllustrationPointsBeCalculated = shouldIllustrationPointsBeCalculated
},
Output = new HydraulicBoundaryLocationCalculationOutput(
random.NextDouble(), random.NextDouble(), random.NextDouble(), random.NextDouble(),
random.NextDouble(), random.NextEnumValue <CalculationConvergence>(),
null)
};
var registry = new PersistenceRegistry();
var hydraulicLocationEntity = new HydraulicLocationEntity();
registry.Register(hydraulicLocationEntity, hydraulicBoundaryLocation);
// Call
HydraulicLocationCalculationEntity entity = calculation.Create(registry);
// Assert
Assert.IsNotNull(entity);
Assert.AreEqual(Convert.ToByte(shouldIllustrationPointsBeCalculated), entity.ShouldIllustrationPointsBeCalculated);
HydraulicLocationOutputEntity outputEntity = entity.HydraulicLocationOutputEntities.Single();
HydraulicBoundaryLocationCalculationOutput expectedOutput = calculation.Output;
Assert.AreEqual(expectedOutput.CalculatedProbability, outputEntity.CalculatedProbability);
Assert.AreEqual(expectedOutput.CalculatedReliability, outputEntity.CalculatedReliability);
Assert.AreEqual(expectedOutput.TargetReliability, outputEntity.TargetReliability);
Assert.AreEqual(expectedOutput.TargetProbability, outputEntity.TargetProbability);
Assert.IsNull(outputEntity.GeneralResultSubMechanismIllustrationPointEntity);
Assert.AreEqual(Convert.ToByte(expectedOutput.CalculationConvergence), outputEntity.CalculationConvergence);
}
/// <summary>
/// Reads the <see cref="HydraulicLocationCalculationEntity"/> and uses the information to update a
/// <see cref="HydraulicBoundaryLocationCalculation"/>.
/// </summary>
/// <param name="entity">The <see cref="HydraulicLocationCalculationEntity"/> to update the
/// <see cref="HydraulicBoundaryLocationCalculation"/>.</param>
/// <param name="calculation">The target of the read operation.</param>
/// <exception cref="ArgumentNullException">Thrown when any parameter is <c>null</c>.</exception>
internal static void Read(this HydraulicLocationCalculationEntity entity,
HydraulicBoundaryLocationCalculation calculation)
{
if (entity == null)
{
throw new ArgumentNullException(nameof(entity));
}
if (calculation == null)
{
throw new ArgumentNullException(nameof(calculation));
}
calculation.InputParameters.ShouldIllustrationPointsBeCalculated = Convert.ToBoolean(entity.ShouldIllustrationPointsBeCalculated);
HydraulicLocationOutputEntity outputEntity = entity.HydraulicLocationOutputEntities.SingleOrDefault();
if (outputEntity != null)
{
calculation.Output = outputEntity.Read();
}
}
/// <summary>
/// Creates a <see cref="HydraulicLocationCalculationEntity"/> based on the information of
/// <see cref="HydraulicBoundaryLocationCalculation"/>.
/// </summary>
/// <param name="calculation">The calculation to create a database entity for.</param>
/// <param name="registry">The object keeping track of create operations.</param>
/// <returns>A new <see cref="HydraulicLocationCalculationEntity"/>.</returns>
/// <exception cref="ArgumentNullException">Thrown when any parameter is <c>null</c>.</exception>
internal static HydraulicLocationCalculationEntity Create(this HydraulicBoundaryLocationCalculation calculation,
PersistenceRegistry registry)
{
if (calculation == null)
{
throw new ArgumentNullException(nameof(calculation));
}
if (registry == null)
{
throw new ArgumentNullException(nameof(registry));
}
var hydraulicLocationCalculationEntity = new HydraulicLocationCalculationEntity
{
ShouldIllustrationPointsBeCalculated = Convert.ToByte(calculation.InputParameters.ShouldIllustrationPointsBeCalculated),
HydraulicLocationEntity = registry.Get(calculation.HydraulicBoundaryLocation)
};
CreateHydraulicBoundaryLocationCalculationOutput(hydraulicLocationCalculationEntity, calculation.Output);
return(hydraulicLocationCalculationEntity);
}
public void Create_WithValidCollection_ReturnsEntityWithExpectedResults()
{
// Setup
var random = new Random(21);
var hydraulicBoundaryLocation = new TestHydraulicBoundaryLocation();
var calculation = new HydraulicBoundaryLocationCalculation(hydraulicBoundaryLocation)
{
InputParameters =
{
ShouldIllustrationPointsBeCalculated = random.NextBoolean()
}
};
var calculationCollection = new ObservableList <HydraulicBoundaryLocationCalculation>
{
calculation
};
var hydraulicLocationEntity = new HydraulicLocationEntity();
var registry = new PersistenceRegistry();
registry.Register(hydraulicLocationEntity, hydraulicBoundaryLocation);
// Call
HydraulicLocationCalculationCollectionEntity entity = calculationCollection.Create(registry);
// Assert
Assert.IsNotNull(entity);
HydraulicLocationCalculationEntity hydraulicLocationCalculationEntity = entity.HydraulicLocationCalculationEntities.Single();
Assert.AreSame(hydraulicLocationEntity, hydraulicLocationCalculationEntity.HydraulicLocationEntity);
Assert.AreEqual(Convert.ToByte(calculation.InputParameters.ShouldIllustrationPointsBeCalculated),
hydraulicLocationCalculationEntity.ShouldIllustrationPointsBeCalculated);
CollectionAssert.IsEmpty(hydraulicLocationCalculationEntity.HydraulicLocationOutputEntities);
}
public void Read_EntityWithValidValues_SetsCalculationsWithExpectedValues()
{
// Setup
var random = new Random(21);
HydraulicLocationEntity hydraulicLocationEntityOne = HydraulicLocationEntityTestFactory.CreateHydraulicLocationEntity();
var calculationEntityWithoutOutput = new HydraulicLocationCalculationEntity
{
HydraulicLocationEntity = hydraulicLocationEntityOne,
ShouldIllustrationPointsBeCalculated = Convert.ToByte(random.NextBoolean())
};
HydraulicLocationEntity hydraulicLocationEntityTwo = HydraulicLocationEntityTestFactory.CreateHydraulicLocationEntity();
var calculationEntityWithOutput = new HydraulicLocationCalculationEntity
{
HydraulicLocationEntity = hydraulicLocationEntityTwo,
ShouldIllustrationPointsBeCalculated = Convert.ToByte(random.NextBoolean()),
HydraulicLocationOutputEntities =
{
new HydraulicLocationOutputEntity()
}
};
var collectionEntity = new HydraulicLocationCalculationForTargetProbabilityCollectionEntity
{
TargetProbability = random.NextDouble(0, 0.1),
HydraulicLocationCalculationEntities =
{
calculationEntityWithoutOutput,
calculationEntityWithOutput
}
};
var hydraulicBoundaryLocationOne = new TestHydraulicBoundaryLocation("1");
var hydraulicBoundaryLocationTwo = new TestHydraulicBoundaryLocation("2");
var collector = new ReadConversionCollector();
collector.Read(hydraulicLocationEntityOne, hydraulicBoundaryLocationOne);
collector.Read(hydraulicLocationEntityTwo, hydraulicBoundaryLocationTwo);
// Call
HydraulicBoundaryLocationCalculationsForTargetProbability calculations = collectionEntity.Read(collector);
// Assert
Assert.AreEqual(collectionEntity.TargetProbability, calculations.TargetProbability);
IEnumerable <HydraulicBoundaryLocationCalculation> hydraulicBoundaryLocationCalculations = calculations.HydraulicBoundaryLocationCalculations;
Assert.AreEqual(collectionEntity.HydraulicLocationCalculationEntities.Count, hydraulicBoundaryLocationCalculations.Count());
HydraulicBoundaryLocationCalculation calculationOne = hydraulicBoundaryLocationCalculations.ElementAt(0);
Assert.AreEqual(Convert.ToBoolean(calculationEntityWithoutOutput.ShouldIllustrationPointsBeCalculated),
calculationOne.InputParameters.ShouldIllustrationPointsBeCalculated);
Assert.AreSame(hydraulicBoundaryLocationOne, calculationOne.HydraulicBoundaryLocation);
Assert.IsNull(calculationOne.Output);
HydraulicBoundaryLocationCalculation calculationTwo = hydraulicBoundaryLocationCalculations.ElementAt(1);
Assert.AreEqual(Convert.ToBoolean(calculationEntityWithOutput.ShouldIllustrationPointsBeCalculated),
calculationTwo.InputParameters.ShouldIllustrationPointsBeCalculated);
Assert.AreSame(hydraulicBoundaryLocationTwo, calculationTwo.HydraulicBoundaryLocation);
Assert.IsNotNull(calculationTwo.Output);
}
private static HydraulicBoundaryLocationCalculation CreateHydraulicBoundaryLocationCalculation(HydraulicLocationCalculationEntity calculationEntity,
ReadConversionCollector collector)
{
var calculation = new HydraulicBoundaryLocationCalculation(collector.Get(calculationEntity.HydraulicLocationEntity));
calculationEntity.Read(calculation);
return(calculation);
}
