public void Create_WithCalculationGroup_ReturnFailureMechanismEntityWithCalculationGroupEntities()
{
// Setup
var failureMechanism = new WaveImpactAsphaltCoverFailureMechanism();
failureMechanism.CalculationsGroup.Children.Add(new CalculationGroup
{
Name = "A"
});
failureMechanism.CalculationsGroup.Children.Add(new CalculationGroup
{
Name = "B"
});
var registry = new PersistenceRegistry();
// Call
FailureMechanismEntity entity = failureMechanism.Create(registry);
// Assert
Assert.IsNotNull(entity);
Assert.AreEqual(failureMechanism.CalculationsGroup.Name, entity.CalculationGroupEntity.Name);
Assert.AreEqual(0, entity.CalculationGroupEntity.Order);
CalculationGroupEntity[] childGroupEntities = entity.CalculationGroupEntity.CalculationGroupEntity1
.OrderBy(cge => cge.Order)
.ToArray();
Assert.AreEqual(2, childGroupEntities.Length);
Assert.AreEqual("A", childGroupEntities[0].Name);
Assert.AreEqual(0, childGroupEntities[0].Order);
Assert.AreEqual("B", childGroupEntities[1].Name);
Assert.AreEqual(1, childGroupEntities[1].Order);
}
public void Create_StringPropertiesDoNotShareReference()
{
// Setup
var failureMechanism = new WaveImpactAsphaltCoverFailureMechanism
{
InAssemblyInputComments =
{
Body = "Some input text"
},
InAssemblyOutputComments =
{
Body = "Some output text"
},
NotInAssemblyComments =
{
Body = "Really not in assembly"
},
CalculationsInputComments =
{
Body = "Some calculation text"
}
};
var registry = new PersistenceRegistry();
// Call
FailureMechanismEntity entity = failureMechanism.Create(registry);
// Assert
TestHelper.AssertAreEqualButNotSame(failureMechanism.InAssemblyInputComments.Body, entity.InAssemblyInputComments);
TestHelper.AssertAreEqualButNotSame(failureMechanism.InAssemblyOutputComments.Body, entity.InAssemblyOutputComments);
TestHelper.AssertAreEqualButNotSame(failureMechanism.NotInAssemblyComments.Body, entity.NotInAssemblyComments);
TestHelper.AssertAreEqualButNotSame(failureMechanism.CalculationsInputComments.Body, entity.CalculationsInputComments);
}
/// <summary>
/// Creates a <see cref="FailureMechanismEntity"/> based on the information of the <see cref="WaveImpactAsphaltCoverFailureMechanism"/>.
/// </summary>
/// <param name="mechanism">The failure mechanism to create a database entity for.</param>
/// <param name="registry">The object keeping track of create operations.</param>
/// <returns>A new <see cref="FailureMechanismEntity"/>.</returns>
/// <exception cref="ArgumentNullException">Thrown when <paramref name="registry"/> is <c>null</c>.</exception>
internal static FailureMechanismEntity Create(this WaveImpactAsphaltCoverFailureMechanism mechanism, PersistenceRegistry registry)
{
FailureMechanismEntity entity = mechanism.Create(FailureMechanismType.WaveImpactOnAsphaltRevetment, registry);
AddEntitiesForSectionResults(mechanism.SectionResults, registry);
AddEntitiesForFailureMechanismMeta(mechanism, entity);
AddEntitiesForForeshoreProfiles(mechanism.ForeshoreProfiles, entity, registry);
entity.CalculationGroupEntity = mechanism.CalculationsGroup.Create(registry, 0);
return(entity);
}
public void Create_WithoutSections_EmptyFailureMechanismSectionEntities()
{
// Setup
var failureMechanism = new WaveImpactAsphaltCoverFailureMechanism();
// Call
FailureMechanismEntity entity = failureMechanism.Create(new PersistenceRegistry());
// Assert
CollectionAssert.IsEmpty(entity.FailureMechanismSectionEntities);
Assert.IsNull(entity.FailureMechanismSectionCollectionSourcePath);
}
public void Create_PersistenceRegistryNull_ThrowsArgumentNullException()
{
// Setup
var failureMechanism = new WaveImpactAsphaltCoverFailureMechanism();
// Call
TestDelegate test = () => failureMechanism.Create(null);
// Assert
string paramName = Assert.Throws <ArgumentNullException>(test).ParamName;
Assert.AreEqual("registry", paramName);
}
public void Create_WithCollectorAndPropertiesSet_ReturnsFailureMechanismEntityWithPropertiesSet(bool inAssembly)
{
// Setup
var random = new Random();
var failureMechanism = new WaveImpactAsphaltCoverFailureMechanism
{
InAssembly = inAssembly,
InAssemblyInputComments =
{
Body = "Some input text"
},
InAssemblyOutputComments =
{
Body = "Some output text"
},
NotInAssemblyComments =
{
Body = "Really not in assembly"
},
CalculationsInputComments =
{
Body = "Some calculation text"
},
GeneralWaveImpactAsphaltCoverInput =
{
DeltaL = random.NextRoundedDouble(0.1, 2000.0),
ApplyLengthEffectInSection = random.NextBoolean()
}
};
var registry = new PersistenceRegistry();
// Call
FailureMechanismEntity entity = failureMechanism.Create(registry);
// Assert
Assert.IsNotNull(entity);
Assert.AreEqual((short)FailureMechanismType.WaveImpactOnAsphaltRevetment, entity.FailureMechanismType);
Assert.AreEqual(Convert.ToByte(inAssembly), entity.InAssembly);
Assert.AreEqual(failureMechanism.InAssemblyInputComments.Body, entity.InAssemblyInputComments);
Assert.AreEqual(failureMechanism.InAssemblyOutputComments.Body, entity.InAssemblyOutputComments);
Assert.AreEqual(failureMechanism.NotInAssemblyComments.Body, entity.NotInAssemblyComments);
Assert.AreEqual(failureMechanism.CalculationsInputComments.Body, entity.CalculationsInputComments);
GeneralWaveImpactAsphaltCoverInput generalInput = failureMechanism.GeneralWaveImpactAsphaltCoverInput;
WaveImpactAsphaltCoverFailureMechanismMetaEntity metaEntity = entity.WaveImpactAsphaltCoverFailureMechanismMetaEntities.Single();
Assert.AreEqual(generalInput.DeltaL, metaEntity.DeltaL);
Assert.AreEqual(Convert.ToByte(generalInput.ApplyLengthEffectInSection), metaEntity.ApplyLengthEffectInSection);
}
public void Create_WithoutForeshoreProfiles_EmptyForeshoreProfilesEntities()
{
// Setup
var failureMechanism = new WaveImpactAsphaltCoverFailureMechanism();
// Call
FailureMechanismEntity entity = failureMechanism.Create(new PersistenceRegistry());
// Assert
CollectionAssert.IsEmpty(entity.ForeshoreProfileEntities);
WaveImpactAsphaltCoverFailureMechanismMetaEntity metaEntity =
entity.WaveImpactAsphaltCoverFailureMechanismMetaEntities.Single();
Assert.IsNull(metaEntity.ForeshoreProfileCollectionSourcePath);
}
public void Create_WithSections_FailureMechanismSectionEntitiesCreated()
{
// Setup
const string filePath = "failureMechanismSections/File/Path";
var failureMechanism = new WaveImpactAsphaltCoverFailureMechanism();
failureMechanism.SetSections(new[]
{
FailureMechanismSectionTestFactory.CreateFailureMechanismSection()
}, filePath);
// Call
FailureMechanismEntity entity = failureMechanism.Create(new PersistenceRegistry());
// Assert
Assert.AreEqual(1, entity.FailureMechanismSectionEntities.Count);
Assert.AreEqual(1, entity.FailureMechanismSectionEntities
.SelectMany(fms => fms.NonAdoptableWithProfileProbabilityFailureMechanismSectionResultEntities)
.Count());
TestHelper.AssertAreEqualButNotSame(filePath, entity.FailureMechanismSectionCollectionSourcePath);
}
public void Create_WithForeshoreProfiles_ForeshoreProfilesEntitiesCreated()
{
// Setup
var failureMechanism = new WaveImpactAsphaltCoverFailureMechanism();
const string filePath = "some/path/to/foreshoreProfiles";
failureMechanism.ForeshoreProfiles.AddRange(new[]
{
new TestForeshoreProfile()
}, filePath);
// Call
FailureMechanismEntity entity = failureMechanism.Create(new PersistenceRegistry());
// Assert
Assert.AreEqual(1, entity.ForeshoreProfileEntities.Count);
WaveImpactAsphaltCoverFailureMechanismMetaEntity metaEntity =
entity.WaveImpactAsphaltCoverFailureMechanismMetaEntities.Single();
string metaEntityForeshoreProfileCollectionSourcePath = metaEntity.ForeshoreProfileCollectionSourcePath;
TestHelper.AssertAreEqualButNotSame(filePath, metaEntityForeshoreProfileCollectionSourcePath);
}