public void Convert_ValidArguments_ExpectedProperties()
{
// Setup
var random = new Random(21);
var hydraRingWindDirection = new HydraRingWindDirection("Name", random.NextDouble());
var hydraRingWindDirectionClosingSituation = new HydraRingWindDirectionClosingSituation(hydraRingWindDirection,
"closing scenario");
var hydraRingIllustrationPointResult = new HydraRingIllustrationPointResult("HydraIllustrationPointResult",
"-",
random.NextDouble());
var hydraRingSubMechanismIllustrationPointStochast =
new HydraRingSubMechanismIllustrationPointStochast("HydraSubMechanismIllustrationPointStochast",
"-",
random.NextDouble(),
random.NextDouble(),
random.NextDouble());
var hydraRingSubMechanismIllustrationPoint = new HydraRingSubMechanismIllustrationPoint("name", new[]
{
hydraRingSubMechanismIllustrationPointStochast
}, new[]
{
hydraRingIllustrationPointResult
}, random.NextDouble());
// Call
TopLevelSubMechanismIllustrationPoint combination =
TopLevelSubMechanismIllustrationPointConverter.Convert(
hydraRingWindDirectionClosingSituation, hydraRingSubMechanismIllustrationPoint);
// Assert
WindDirection windDirection = combination.WindDirection;
Assert.AreEqual(hydraRingWindDirection.Angle, windDirection.Angle, windDirection.Angle.GetAccuracy());
Assert.AreEqual(hydraRingWindDirection.Name, windDirection.Name);
Assert.AreEqual(hydraRingWindDirectionClosingSituation.ClosingSituation, combination.ClosingSituation);
SubMechanismIllustrationPoint subMechanismIllustrationPoint = combination.SubMechanismIllustrationPoint;
Assert.AreEqual(hydraRingSubMechanismIllustrationPoint.Beta, subMechanismIllustrationPoint.Beta, subMechanismIllustrationPoint.Beta.GetAccuracy());
Assert.AreEqual(hydraRingSubMechanismIllustrationPoint.Name, subMechanismIllustrationPoint.Name);
IllustrationPointResult illustrationPointResult = subMechanismIllustrationPoint.IllustrationPointResults.Single();
Assert.AreEqual(hydraRingIllustrationPointResult.Description, illustrationPointResult.Description);
Assert.AreEqual(hydraRingIllustrationPointResult.Value, illustrationPointResult.Value, illustrationPointResult.Value.GetAccuracy());
SubMechanismIllustrationPointStochast stochast = subMechanismIllustrationPoint.Stochasts.Single();
Assert.AreEqual(hydraRingSubMechanismIllustrationPointStochast.Alpha, stochast.Alpha, stochast.Alpha.GetAccuracy());
Assert.AreEqual(hydraRingSubMechanismIllustrationPointStochast.Duration, stochast.Duration, stochast.Duration.GetAccuracy());
Assert.AreEqual(hydraRingSubMechanismIllustrationPointStochast.Name, stochast.Name);
Assert.AreEqual(hydraRingSubMechanismIllustrationPointStochast.Unit, stochast.Unit);
Assert.AreEqual(hydraRingSubMechanismIllustrationPointStochast.Realization, stochast.Realization, stochast.Realization.GetAccuracy());
}
private static void AssertReadIllustrationPointResult(IllustrationPointResultEntity illustrationPointResultEntity,
IllustrationPointResult readIllustrationPointResult)
{
Assert.AreEqual(illustrationPointResultEntity.Description, readIllustrationPointResult.Description);
Assert.AreEqual(illustrationPointResultEntity.Unit, readIllustrationPointResult.Unit);
Assert.AreEqual(illustrationPointResultEntity.Value, readIllustrationPointResult.Value,
readIllustrationPointResult.Value.GetAccuracy());
}
public void Clone_Always_ReturnNewInstanceWithCopiedValues()
{
// Setup
var random = new Random(21);
var original = new IllustrationPointResult("Random description", "-", random.NextDouble());
// Call
object clone = original.Clone();
// Assert
CoreCloneAssert.AreObjectClones(original, clone, CommonCloneAssert.AreClones);
}
public void Constructor_Always_ReturnsNewInstance()
{
// Setup
const string description = "some description";
const string unit = "-";
const double value = 123;
// Call
var result = new IllustrationPointResult(description, unit, value);
// Assert
Assert.AreEqual(description, result.Description);
Assert.AreEqual(unit, result.Unit);
Assert.AreEqual(value, result.Value);
}
public void Convert_ValidArguments_ExpectedProperties()
{
// Setup
var random = new Random(21);
var hydraRingIllustrationPointResult = new HydraRingIllustrationPointResult("Description",
"-",
random.NextDouble());
// Call
IllustrationPointResult illustrationPointResult = IllustrationPointResultConverter.Convert(hydraRingIllustrationPointResult);
// Assert
Assert.AreEqual(illustrationPointResult.Description, illustrationPointResult.Description);
Assert.AreEqual(illustrationPointResult.Unit, illustrationPointResult.Unit);
Assert.AreEqual(illustrationPointResult.Value, illustrationPointResult.Value, illustrationPointResult.Value.GetAccuracy());
}
public void Convert_ValidArguments_ExpectedProperties()
{
// Setup
var random = new Random(21);
var hydraIllustrationPointResult = new HydraRingIllustrationPointResult("HydraIllustrationPointResult",
"-",
random.NextDouble());
const string name = "hydraRingSubMechanismIllustrationPointStochast";
const string unit = "-";
double alpha = random.NextDouble();
double duration = random.NextDouble();
double realization = random.NextDouble();
var hydraRingSubMechanismIllustrationPointStochast =
new HydraRingSubMechanismIllustrationPointStochast(name, unit, duration, alpha, realization);
double beta = random.NextDouble();
var hydraSubMechanismIllustrationPoint = new HydraRingSubMechanismIllustrationPoint("name", new[]
{
hydraRingSubMechanismIllustrationPointStochast
}, new[]
{
hydraIllustrationPointResult
}, beta);
// Call
SubMechanismIllustrationPoint subMechanismIllustrationPoint =
SubMechanismIllustrationPointConverter.Convert(hydraSubMechanismIllustrationPoint);
// Assert
Assert.AreEqual(subMechanismIllustrationPoint.Beta, subMechanismIllustrationPoint.Beta, subMechanismIllustrationPoint.Beta.GetAccuracy());
Assert.AreEqual(subMechanismIllustrationPoint.Name, subMechanismIllustrationPoint.Name);
IllustrationPointResult illustrationPointResult = subMechanismIllustrationPoint.IllustrationPointResults.Single();
Assert.AreEqual(hydraIllustrationPointResult.Description, illustrationPointResult.Description);
Assert.AreEqual(hydraIllustrationPointResult.Value, illustrationPointResult.Value, illustrationPointResult.Value.GetAccuracy());
SubMechanismIllustrationPointStochast stochast = subMechanismIllustrationPoint.Stochasts.Single();
Assert.AreEqual(hydraRingSubMechanismIllustrationPointStochast.Alpha, stochast.Alpha, stochast.Alpha.GetAccuracy());
Assert.AreEqual(hydraRingSubMechanismIllustrationPointStochast.Duration, stochast.Duration, stochast.Duration.GetAccuracy());
Assert.AreEqual(hydraRingSubMechanismIllustrationPointStochast.Name, stochast.Name);
Assert.AreEqual(hydraRingSubMechanismIllustrationPointStochast.Unit, stochast.Unit);
Assert.AreEqual(hydraRingSubMechanismIllustrationPointStochast.Realization, stochast.Realization, stochast.Realization.GetAccuracy());
}
/// <summary>
/// Creates a <see cref="IllustrationPointResult"/> based on the
/// information of the <paramref name="illustrationPointResult"/>.
/// </summary>
/// <param name="illustrationPointResult">The illustration point result to create a database
/// entity for.</param>
/// <param name="order">The index at which <paramref name="illustrationPointResult"/>
/// resides within its parent.</param>
/// <returns>A new <see cref="IllustrationPointResult"/>.</returns>
/// <exception cref="ArgumentNullException">Thrown when <paramref name="illustrationPointResult"/>
/// is <c>null</c>.</exception>
internal static IllustrationPointResultEntity Create(
this IllustrationPointResult illustrationPointResult, int order)
{
if (illustrationPointResult == null)
{
throw new ArgumentNullException(nameof(illustrationPointResult));
}
var entity = new IllustrationPointResultEntity
{
Description = illustrationPointResult.Description.DeepClone(),
Unit = illustrationPointResult.Unit.DeepClone(),
Value = illustrationPointResult.Value,
Order = order
};
return(entity);
}
public void Read_ValidEntity_ReturnIllustrationPointResult()
{
// Setup
var random = new Random(123);
var entity = new IllustrationPointResultEntity
{
Description = "Description",
Unit = "-",
Value = random.NextDouble()
};
// Call
IllustrationPointResult illustrationPointResult = entity.Read();
// Assert
Assert.AreEqual(entity.Description, illustrationPointResult.Description);
Assert.AreEqual(entity.Unit, illustrationPointResult.Unit);
Assert.AreEqual(entity.Value, illustrationPointResult.Value, illustrationPointResult.Value.GetAccuracy());
}
public void Create_ValidIllustrationPointResult_ReturnIllustrationPointResultEntity()
{
// Setup
var random = new Random(123);
var illustrationPointResult = new IllustrationPointResult("Some description",
"-",
random.NextDouble());
int order = random.Next();
// Call
IllustrationPointResultEntity entity =
illustrationPointResult.Create(order);
// Assert
TestHelper.AssertAreEqualButNotSame(illustrationPointResult.Description, entity.Description);
TestHelper.AssertAreEqualButNotSame(illustrationPointResult.Unit, entity.Unit);
Assert.AreEqual(illustrationPointResult.Value, entity.Value, illustrationPointResult.Value.GetAccuracy());
Assert.AreEqual(order, entity.Order);
}
public void Create_MultipleResultsAndValidIllustrationPoint_ReturnSubMechanismIllustrationPointEntityWithResultEntities()
{
// Setup
var random = new Random(21);
var illustrationPointResultOne = new IllustrationPointResult("result description", "-", random.NextDouble());
var illustrationPointResultTwo = new IllustrationPointResult("result description two", "kN", random.NextDouble());
IllustrationPointResult[] illustrationPointResults =
{
illustrationPointResultOne,
illustrationPointResultTwo
};
var illustrationPoint = new SubMechanismIllustrationPoint("Illustration point name",
random.NextDouble(),
Enumerable.Empty <SubMechanismIllustrationPointStochast>(),
illustrationPointResults);
int order = random.Next();
// Call
SubMechanismIllustrationPointEntity entity = illustrationPoint.Create(order);
// Assert
AssertCommonProperties(illustrationPoint, entity);
Assert.AreEqual(order, entity.Order);
IllustrationPointResultEntity[] resultEntities = entity.IllustrationPointResultEntities.ToArray();
int expectedNrOfIllustrationPoints = illustrationPointResults.Length;
Assert.AreEqual(expectedNrOfIllustrationPoints, resultEntities.Length);
for (var i = 0; i < expectedNrOfIllustrationPoints; i++)
{
IllustrationPointResult illustrationPointResult = illustrationPointResults[i];
IllustrationPointResultEntity illustrationPointResultEntity = resultEntities[i];
TestHelper.AssertAreEqualButNotSame(illustrationPointResult.Description, illustrationPointResultEntity.Description);
TestHelper.AssertAreEqualButNotSame(illustrationPointResult.Unit, illustrationPointResultEntity.Unit);
Assert.AreEqual(illustrationPointResult.Value, illustrationPointResultEntity.Value,
illustrationPointResult.Value.GetAccuracy());
Assert.AreEqual(i, illustrationPointResultEntity.Order);
}
}
public void Constructor_ValidArguments_ReturnExpectedValues()
{
// Setup
const string description = "illustration point";
const string unit = "-";
var random = new Random(21);
double value = random.NextDouble();
// Call
var illustrationPointResult = new IllustrationPointResult(description, unit, value);
// Assert
Assert.IsInstanceOf <ICloneable>(illustrationPointResult);
Assert.AreEqual(description, illustrationPointResult.Description);
Assert.AreEqual(unit, illustrationPointResult.Unit);
Assert.AreEqual(value, illustrationPointResult.Value,
illustrationPointResult.Value.GetAccuracy());
Assert.AreEqual(5, illustrationPointResult.Value.NumberOfDecimalPlaces);
}
/// <summary>
/// Method that asserts whether <paramref name="original"/> and <paramref name="clone"/>
/// are clones.
/// </summary>
/// <param name="original">The original object.</param>
/// <param name="clone">The cloned object.</param>
/// <exception cref="AssertionException">Thrown when <paramref name="original"/> and
/// <paramref name="clone"/> are not clones.</exception>
public static void AreClones(IllustrationPointResult original, IllustrationPointResult clone)
{
Assert.AreEqual(original.Description, clone.Description);
Assert.AreEqual(original.Unit, clone.Unit);
Assert.AreEqual(original.Value, clone.Value);
}
