/// <summary>
/// Adds the entity representation of <paramref name="soilProfile"/> to the <paramref name="entity"/>.
/// </summary>
/// <param name="soilProfile">The soil profile to store.</param>
/// <param name="entity">The entity to update.</param>
/// <param name="registry">The registry to use for persisting entities.</param>
/// <exception cref="NotSupportedException">Thrown when <paramref name="soilProfile"/> is
/// not of type <see cref="MacroStabilityInwardsSoilProfile1D"/> or <see cref="MacroStabilityInwardsSoilProfile2D"/>.</exception>
private static void AddEntityForProfile(IMacroStabilityInwardsSoilProfile <IMacroStabilityInwardsSoilLayer> soilProfile,
MacroStabilityInwardsStochasticSoilProfileEntity entity,
PersistenceRegistry registry)
{
var soilProfile1D = soilProfile as MacroStabilityInwardsSoilProfile1D;
if (soilProfile1D != null)
{
entity.MacroStabilityInwardsSoilProfileOneDEntity = soilProfile1D.Create(registry);
return;
}
var soilProfile2D = soilProfile as MacroStabilityInwardsSoilProfile2D;
if (soilProfile2D != null)
{
entity.MacroStabilityInwardsSoilProfileTwoDEntity = soilProfile2D.Create(registry);
return;
}
string exceptionMessage = $"{soilProfile.GetType().Name} is not supported. " +
$"Supported types are: {nameof(MacroStabilityInwardsSoilProfile1D)} and {nameof(MacroStabilityInwardsSoilProfile2D)}.";
throw new NotSupportedException(exceptionMessage);
}
public void Create_WithStochasticSoilProfiles_ReturnsStochasticSoilModelEntityWithPropertiesSet()
{
// Setup
var stochasticSoilProfiles = new[]
{
new MacroStabilityInwardsStochasticSoilProfile(0.1, MacroStabilityInwardsSoilProfile1DTestFactory.CreateMacroStabilityInwardsSoilProfile1D()),
new MacroStabilityInwardsStochasticSoilProfile(0.9, MacroStabilityInwardsSoilProfile2DTestFactory.CreateMacroStabilityInwardsSoilProfile2D())
};
MacroStabilityInwardsStochasticSoilModel stochasticSoilModel =
MacroStabilityInwardsStochasticSoilModelTestFactory.CreateValidStochasticSoilModel("Model", stochasticSoilProfiles);
var registry = new PersistenceRegistry();
// Call
StochasticSoilModelEntity entity = stochasticSoilModel.Create(registry, 0);
// Assert
Assert.IsNotNull(entity);
CollectionAssert.IsEmpty(entity.PipingStochasticSoilProfileEntities);
Assert.AreEqual(stochasticSoilProfiles.Length, entity.MacroStabilityInwardsStochasticSoilProfileEntities.Count);
MacroStabilityInwardsStochasticSoilProfile firstStochasticSoilProfile = stochasticSoilProfiles[0];
MacroStabilityInwardsStochasticSoilProfileEntity firstStochasticSoilProfileEntity = entity.MacroStabilityInwardsStochasticSoilProfileEntities.First();
Assert.AreEqual(firstStochasticSoilProfile.Probability, firstStochasticSoilProfileEntity.Probability);
Assert.IsNotNull(firstStochasticSoilProfileEntity.MacroStabilityInwardsSoilProfileOneDEntity);
Assert.IsNull(firstStochasticSoilProfileEntity.MacroStabilityInwardsSoilProfileTwoDEntity);
MacroStabilityInwardsStochasticSoilProfile secondStochasticSoilProfile = stochasticSoilProfiles[1];
MacroStabilityInwardsStochasticSoilProfileEntity secondStochasticSoilProfileEntity = entity.MacroStabilityInwardsStochasticSoilProfileEntities.ElementAt(1);
Assert.AreEqual(secondStochasticSoilProfile.Probability, secondStochasticSoilProfileEntity.Probability);
Assert.IsNull(secondStochasticSoilProfileEntity.MacroStabilityInwardsSoilProfileOneDEntity);
Assert.IsNotNull(secondStochasticSoilProfileEntity.MacroStabilityInwardsSoilProfileTwoDEntity);
}
/// <summary>
/// Creates a <see cref="MacroStabilityInwardsStochasticSoilProfileEntity"/> based on
/// the information of the <see cref="MacroStabilityInwardsStochasticSoilProfile"/>.
/// </summary>
/// <param name="stochasticSoilProfile">The stochastic soil profile to create a database entity for.</param>
/// <param name="registry">The object keeping track of create operations.</param>
/// <param name="order">Index at which this instance resides inside its parent container.</param>
/// <returns>A new <see cref="MacroStabilityInwardsStochasticSoilProfileEntity"/>.</returns>
/// <exception cref="ArgumentNullException">Thrown when any input parameter is <c>null</c>.</exception>
/// <exception cref="NotSupportedException">Thrown when <see cref="MacroStabilityInwardsStochasticSoilProfile.SoilProfile"/> is
/// not of type <see cref="MacroStabilityInwardsSoilProfile1D"/> or <see cref="MacroStabilityInwardsSoilProfile2D"/>.</exception>
public static MacroStabilityInwardsStochasticSoilProfileEntity Create(this MacroStabilityInwardsStochasticSoilProfile stochasticSoilProfile,
PersistenceRegistry registry,
int order)
{
if (stochasticSoilProfile == null)
{
throw new ArgumentNullException(nameof(stochasticSoilProfile));
}
if (registry == null)
{
throw new ArgumentNullException(nameof(registry));
}
if (registry.Contains(stochasticSoilProfile))
{
return(registry.Get(stochasticSoilProfile));
}
var entity = new MacroStabilityInwardsStochasticSoilProfileEntity
{
Probability = stochasticSoilProfile.Probability,
Order = order
};
AddEntityForProfile(stochasticSoilProfile.SoilProfile, entity, registry);
registry.Register(entity, stochasticSoilProfile);
return(entity);
}
public void Read_WithCollectorAnd2dProfile_ReturnsStochasticSoilProfileWithPropertiesSet()
{
// Setup
var random = new Random(21);
var entity = new MacroStabilityInwardsStochasticSoilProfileEntity
{
Probability = random.NextDouble(),
MacroStabilityInwardsSoilProfileTwoDEntity = new MacroStabilityInwardsSoilProfileTwoDEntity
{
Name = "SoilProfile",
MacroStabilityInwardsSoilLayerTwoDEntities =
{
MacroStabilityInwardsSoilLayerTwoDEntityTestFactory.CreateMacroStabilityInwardsSoilLayerTwoDEntity()
}
}
};
var collector = new ReadConversionCollector();
// Call
MacroStabilityInwardsStochasticSoilProfile stochasticSoilProfile = entity.Read(collector);
// Assert
Assert.IsNotNull(stochasticSoilProfile);
Assert.AreEqual(entity.Probability, stochasticSoilProfile.Probability, 1e-6);
IMacroStabilityInwardsSoilProfile <IMacroStabilityInwardsSoilLayer> profile = stochasticSoilProfile.SoilProfile;
Assert.IsInstanceOf <MacroStabilityInwardsSoilProfile2D>(profile);
Assert.AreEqual(entity.MacroStabilityInwardsSoilProfileTwoDEntity.Name, profile.Name);
}
public void Read_EntityWithStochasticSoilModel_ReturnCalculationScenarioWithInputObjectWithStochasticSoilModelPropertiesSet()
{
// Setup
var random = new Random(21);
MacroStabilityInwardsStochasticSoilModel stochasticSoilModel =
MacroStabilityInwardsStochasticSoilModelTestFactory.CreateValidStochasticSoilModel();
var stochasticSoilModelEntity = new StochasticSoilModelEntity();
var stochasticSoilProfile = new MacroStabilityInwardsStochasticSoilProfile(random.NextDouble(),
MacroStabilityInwardsSoilProfile1DTestFactory.CreateMacroStabilityInwardsSoilProfile1D());
var stochasticSoilProfileEntity = new MacroStabilityInwardsStochasticSoilProfileEntity
{
StochasticSoilModelEntity = stochasticSoilModelEntity
};
var collector = new ReadConversionCollector();
collector.Read(stochasticSoilModelEntity, stochasticSoilModel);
collector.Read(stochasticSoilProfileEntity, stochasticSoilProfile);
MacroStabilityInwardsCalculationEntity entity = CreateValidCalculationEntity();
entity.MacroStabilityInwardsStochasticSoilProfileEntity = stochasticSoilProfileEntity;
// Call
MacroStabilityInwardsCalculationScenario calculation = entity.Read(collector);
// Assert
MacroStabilityInwardsInput inputParameters = calculation.InputParameters;
Assert.AreSame(stochasticSoilModel, inputParameters.StochasticSoilModel);
Assert.AreSame(stochasticSoilProfile, inputParameters.StochasticSoilProfile);
}
public void GivenReadObject_WhenReadCalledOnSameEntity_ThenSameObjectInstanceReturned()
{
// Given
var entity = new MacroStabilityInwardsStochasticSoilProfileEntity
{
MacroStabilityInwardsSoilProfileOneDEntity = new MacroStabilityInwardsSoilProfileOneDEntity
{
Name = "StochasticSoilProfile",
MacroStabilityInwardsSoilLayerOneDEntities =
{
new MacroStabilityInwardsSoilLayerOneDEntity()
}
}
};
var collector = new ReadConversionCollector();
MacroStabilityInwardsStochasticSoilProfile stochasticSoilProfile1 = entity.Read(collector);
// When
MacroStabilityInwardsStochasticSoilProfile stochasticSoilProfile2 = entity.Read(collector);
// Then
Assert.AreSame(stochasticSoilProfile1, stochasticSoilProfile2);
}
public void Read_DifferentStochasticSoilProfileEntitiesWithSame2dProfile_ReturnsStochasticSoilProfilesWithSameSoilProfile()
{
// Setup
var random = new Random(21);
double probability = random.NextDouble();
var soilProfileTwoDEntity = new MacroStabilityInwardsSoilProfileTwoDEntity
{
Name = "SoilProfile",
MacroStabilityInwardsSoilLayerTwoDEntities =
{
MacroStabilityInwardsSoilLayerTwoDEntityTestFactory.CreateMacroStabilityInwardsSoilLayerTwoDEntity()
}
};
var firstEntity = new MacroStabilityInwardsStochasticSoilProfileEntity
{
Probability = probability,
MacroStabilityInwardsSoilProfileTwoDEntity = soilProfileTwoDEntity
};
var secondEntity = new MacroStabilityInwardsStochasticSoilProfileEntity
{
Probability = 1 - probability,
MacroStabilityInwardsSoilProfileTwoDEntity = soilProfileTwoDEntity
};
var collector = new ReadConversionCollector();
MacroStabilityInwardsStochasticSoilProfile firstStochasticSoilProfile = firstEntity.Read(collector);
// Call
MacroStabilityInwardsStochasticSoilProfile secondStochasticSoilProfile = secondEntity.Read(collector);
// Assert
Assert.AreNotSame(firstStochasticSoilProfile, secondStochasticSoilProfile);
Assert.AreSame(firstStochasticSoilProfile.SoilProfile, secondStochasticSoilProfile.SoilProfile);
}
public void Create_CalculationWithAlreadyRegisteredStochasticSoilProfile_ReturnsEntityWithStochasticSoilModelEntity()
{
// Setup
var random = new Random(21);
var stochasticSoilProfile = new MacroStabilityInwardsStochasticSoilProfile(random.NextDouble(),
MacroStabilityInwardsSoilProfile1DTestFactory.CreateMacroStabilityInwardsSoilProfile1D());
var scenario = new MacroStabilityInwardsCalculationScenario
{
InputParameters =
{
StochasticSoilProfile = stochasticSoilProfile
}
};
var registry = new PersistenceRegistry();
var stochasticSoilProfileEntity = new MacroStabilityInwardsStochasticSoilProfileEntity();
registry.Register(stochasticSoilProfileEntity, stochasticSoilProfile);
// Call
MacroStabilityInwardsCalculationEntity entity = scenario.Create(registry, 0);
// Assert
Assert.IsNotNull(entity);
MacroStabilityInwardsStochasticSoilProfileEntity expectedStochasticSoilProfileEntity = registry.Get(stochasticSoilProfile);
Assert.AreSame(expectedStochasticSoilProfileEntity, entity.MacroStabilityInwardsStochasticSoilProfileEntity);
}
public void Read_CollectorNull_ThrowsArgumentNullException()
{
// Setup
var entity = new MacroStabilityInwardsStochasticSoilProfileEntity();
// Call
TestDelegate test = () => entity.Read(null);
// Assert
string parameter = Assert.Throws <ArgumentNullException>(test).ParamName;
Assert.AreEqual("collector", parameter);
}
public void GivenCreatedEntity_WhenCreateCalledOnSameObject_ThenSameEntityInstanceReturned(IMacroStabilityInwardsSoilProfile <IMacroStabilityInwardsSoilLayer> soilProfile)
{
// Given
var stochasticSoilProfile = new MacroStabilityInwardsStochasticSoilProfile(0.4, soilProfile);
var registry = new PersistenceRegistry();
MacroStabilityInwardsStochasticSoilProfileEntity entity1 = stochasticSoilProfile.Create(registry, 0);
// When
MacroStabilityInwardsStochasticSoilProfileEntity entity2 = stochasticSoilProfile.Create(registry, 0);
// Then
Assert.AreSame(entity1, entity2);
}
public void Create_DifferentStochasticSoilProfilesWithSameMacroStabilityInwardsSoilProfile2D_ReturnsEntityWithSameSoilProfileEntitySet()
{
// Setup
var random = new Random(31);
MacroStabilityInwardsSoilProfile2D soilProfile = MacroStabilityInwardsSoilProfile2DTestFactory.CreateMacroStabilityInwardsSoilProfile2D();
var firstStochasticSoilProfile = new MacroStabilityInwardsStochasticSoilProfile(random.NextDouble(), soilProfile);
var secondStochasticSoilProfile = new MacroStabilityInwardsStochasticSoilProfile(random.NextDouble(), soilProfile);
var registry = new PersistenceRegistry();
MacroStabilityInwardsStochasticSoilProfileEntity firstEntity = firstStochasticSoilProfile.Create(registry, 0);
// Call
MacroStabilityInwardsStochasticSoilProfileEntity secondEntity = secondStochasticSoilProfile.Create(registry, 0);
// Assert
Assert.IsNull(firstEntity.MacroStabilityInwardsSoilProfileOneDEntity);
Assert.IsNull(secondEntity.MacroStabilityInwardsSoilProfileOneDEntity);
Assert.AreSame(firstEntity.MacroStabilityInwardsSoilProfileTwoDEntity, secondEntity.MacroStabilityInwardsSoilProfileTwoDEntity);
}
public void Create_WithMacroStabilityInwardsSoilProfile1D_ReturnsStochasticSoilProfileEntityWithPropertiesSet()
{
// Setup
var random = new Random(31);
MacroStabilityInwardsSoilProfile1D soilProfile =
MacroStabilityInwardsSoilProfile1DTestFactory.CreateMacroStabilityInwardsSoilProfile1D(nameof(MacroStabilityInwardsSoilProfile1D));
var stochasticSoilProfile = new MacroStabilityInwardsStochasticSoilProfile(random.NextDouble(), soilProfile);
int order = random.Next();
var registry = new PersistenceRegistry();
// Call
MacroStabilityInwardsStochasticSoilProfileEntity entity = stochasticSoilProfile.Create(registry, order);
// Assert
Assert.IsNotNull(entity);
Assert.AreEqual(stochasticSoilProfile.Probability, entity.Probability);
Assert.AreEqual(soilProfile.Name, entity.MacroStabilityInwardsSoilProfileOneDEntity.Name);
Assert.IsNull(entity.MacroStabilityInwardsSoilProfileTwoDEntity);
Assert.AreEqual(order, entity.Order);
}
/// <summary>
/// Reads the <see cref="MacroStabilityInwardsStochasticSoilProfileEntity"/> and use the information to
/// construct a <see cref="MacroStabilityInwardsStochasticSoilProfile"/>.
/// </summary>
/// <param name="entity">The <see cref="MacroStabilityInwardsStochasticSoilProfileEntity"/> to create
/// <see cref="MacroStabilityInwardsStochasticSoilProfile"/> for.</param>
/// <param name="collector">The object keeping track of read operations.</param>
/// <returns>A new <see cref="MacroStabilityInwardsStochasticSoilProfile"/>.</returns>
/// <exception cref="ArgumentNullException">Thrown when any input parameter is <c>null</c>.</exception>
public static MacroStabilityInwardsStochasticSoilProfile Read(this MacroStabilityInwardsStochasticSoilProfileEntity entity,
ReadConversionCollector collector)
{
if (entity == null)
{
throw new ArgumentNullException(nameof(entity));
}
if (collector == null)
{
throw new ArgumentNullException(nameof(collector));
}
if (collector.Contains(entity))
{
return(collector.Get(entity));
}
var stochasticSoilProfile = new MacroStabilityInwardsStochasticSoilProfile(entity.Probability, entity.ReadSoilProfile(collector));
collector.Read(entity, stochasticSoilProfile);
return(stochasticSoilProfile);
}
private static IMacroStabilityInwardsSoilProfile <MacroStabilityInwardsSoilLayer2D> ReadSoilProfile2D(this MacroStabilityInwardsStochasticSoilProfileEntity entity,
ReadConversionCollector collector)
{
return(entity.MacroStabilityInwardsSoilProfileTwoDEntity.Read(collector));
}
private static IMacroStabilityInwardsSoilProfile <IMacroStabilityInwardsSoilLayer> ReadSoilProfile(this MacroStabilityInwardsStochasticSoilProfileEntity entity,
ReadConversionCollector collector)
{
return(entity.MacroStabilityInwardsSoilProfileOneDEntity != null
? (IMacroStabilityInwardsSoilProfile <IMacroStabilityInwardsSoilLayer>)ReadSoilProfile1D(entity, collector)
: ReadSoilProfile2D(entity, collector));
}
/// <summary>
/// Registers a create operation for <paramref name="model"/> and the <paramref name="entity"/>
/// that was constructed with the information.
/// </summary>
/// <param name="entity">The <see cref="MacroStabilityInwardsStochasticSoilProfileEntity"/> to be registered.</param>
/// <param name="model">The <see cref="MacroStabilityInwardsStochasticSoilProfile"/> to be registered.</param>
/// <exception cref="ArgumentNullException">Thrown when any of the input parameters is <c>null</c>.</exception>
internal void Register(MacroStabilityInwardsStochasticSoilProfileEntity entity, MacroStabilityInwardsStochasticSoilProfile model)
{
Register(macroStabilityInwardsStochasticSoilProfiles, entity, model);
}
