public void Constructor_ExpectedValues()
{
// Setup
var random = new Random(21);
MacroStabilityInwardsSlidingCircle rightCircle = MacroStabilityInwardsSlidingCircleTestFactory.Create();
MacroStabilityInwardsSlidingCircle leftCircle = MacroStabilityInwardsSlidingCircleTestFactory.Create();
MacroStabilityInwardsSlice[] slices =
{
MacroStabilityInwardsSliceTestFactory.CreateSlice()
};
double nonIteratedHorizontalForce = random.NextDouble();
double iteratedHorizontalForce = random.NextDouble();
// Call
var curve = new MacroStabilityInwardsSlidingCurve(leftCircle, rightCircle, slices, nonIteratedHorizontalForce, iteratedHorizontalForce);
// Assert
Assert.IsInstanceOf <ICloneable>(curve);
Assert.AreSame(leftCircle, curve.LeftCircle);
Assert.AreSame(rightCircle, curve.RightCircle);
Assert.AreEqual(nonIteratedHorizontalForce, curve.NonIteratedHorizontalForce);
Assert.AreEqual(iteratedHorizontalForce, curve.IteratedHorizontalForce);
Assert.AreSame(slices, curve.Slices);
}
private static void SetSlidingCurveParametersToEntity(MacroStabilityInwardsCalculationOutputEntity entity,
MacroStabilityInwardsSlidingCurve slidingCurve)
{
entity.SlidingCurveSliceXML = new MacroStabilityInwardsSliceCollectionXmlSerializer().ToXml(slidingCurve.Slices);
entity.SlidingCurveNonIteratedHorizontalForce = slidingCurve.NonIteratedHorizontalForce.ToNaNAsNull();
entity.SlidingCurveIteratedHorizontalForce = slidingCurve.IteratedHorizontalForce.ToNaNAsNull();
MacroStabilityInwardsSlidingCircle leftCircle = slidingCurve.LeftCircle;
entity.SlidingCurveLeftSlidingCircleCenterX = leftCircle.Center.X.ToNaNAsNull();
entity.SlidingCurveLeftSlidingCircleCenterY = leftCircle.Center.Y.ToNaNAsNull();
entity.SlidingCurveLeftSlidingCircleRadius = leftCircle.Radius.ToNaNAsNull();
entity.SlidingCurveLeftSlidingCircleIsActive = Convert.ToByte(leftCircle.IsActive);
entity.SlidingCurveLeftSlidingCircleNonIteratedForce = leftCircle.NonIteratedForce.ToNaNAsNull();
entity.SlidingCurveLeftSlidingCircleIteratedForce = leftCircle.IteratedForce.ToNaNAsNull();
entity.SlidingCurveLeftSlidingCircleDrivingMoment = leftCircle.DrivingMoment.ToNaNAsNull();
entity.SlidingCurveLeftSlidingCircleResistingMoment = leftCircle.ResistingMoment.ToNaNAsNull();
MacroStabilityInwardsSlidingCircle rightCircle = slidingCurve.RightCircle;
entity.SlidingCurveRightSlidingCircleCenterX = rightCircle.Center.X.ToNaNAsNull();
entity.SlidingCurveRightSlidingCircleCenterY = rightCircle.Center.Y.ToNaNAsNull();
entity.SlidingCurveRightSlidingCircleRadius = rightCircle.Radius.ToNaNAsNull();
entity.SlidingCurveRightSlidingCircleIsActive = Convert.ToByte(rightCircle.IsActive);
entity.SlidingCurveRightSlidingCircleNonIteratedForce = rightCircle.NonIteratedForce.ToNaNAsNull();
entity.SlidingCurveRightSlidingCircleIteratedForce = rightCircle.IteratedForce.ToNaNAsNull();
entity.SlidingCurveRightSlidingCircleDrivingMoment = rightCircle.DrivingMoment.ToNaNAsNull();
entity.SlidingCurveRightSlidingCircleResistingMoment = rightCircle.ResistingMoment.ToNaNAsNull();
}
private static MacroStabilityInwardsSlidingCurve ReadSlidingCurve(MacroStabilityInwardsCalculationOutputEntity entity)
{
var leftCircle = new MacroStabilityInwardsSlidingCircle(new Point2D(entity.SlidingCurveLeftSlidingCircleCenterX.ToNullAsNaN(),
entity.SlidingCurveLeftSlidingCircleCenterY.ToNullAsNaN()),
entity.SlidingCurveLeftSlidingCircleRadius.ToNullAsNaN(),
Convert.ToBoolean(entity.SlidingCurveLeftSlidingCircleIsActive),
entity.SlidingCurveLeftSlidingCircleNonIteratedForce.ToNullAsNaN(),
entity.SlidingCurveLeftSlidingCircleIteratedForce.ToNullAsNaN(),
entity.SlidingCurveLeftSlidingCircleDrivingMoment.ToNullAsNaN(),
entity.SlidingCurveLeftSlidingCircleResistingMoment.ToNullAsNaN());
var rightCircle = new MacroStabilityInwardsSlidingCircle(new Point2D(entity.SlidingCurveRightSlidingCircleCenterX.ToNullAsNaN(),
entity.SlidingCurveRightSlidingCircleCenterY.ToNullAsNaN()),
entity.SlidingCurveRightSlidingCircleRadius.ToNullAsNaN(),
Convert.ToBoolean(entity.SlidingCurveRightSlidingCircleIsActive),
entity.SlidingCurveRightSlidingCircleNonIteratedForce.ToNullAsNaN(),
entity.SlidingCurveRightSlidingCircleIteratedForce.ToNullAsNaN(),
entity.SlidingCurveRightSlidingCircleDrivingMoment.ToNullAsNaN(),
entity.SlidingCurveRightSlidingCircleResistingMoment.ToNullAsNaN());
MacroStabilityInwardsSlice[] slices = new MacroStabilityInwardsSliceCollectionXmlSerializer().FromXml(entity.SlidingCurveSliceXML);
return(new MacroStabilityInwardsSlidingCurve(leftCircle,
rightCircle,
slices,
entity.SlidingCurveNonIteratedHorizontalForce.ToNullAsNaN(),
entity.SlidingCurveIteratedHorizontalForce.ToNullAsNaN()));
}
public void Constructor_ExpectedValues()
{
// Setup
var random = new Random(11);
var center = new Point2D(random.NextDouble(), random.NextDouble());
double radius = random.NextDouble();
bool isActive = random.NextBoolean();
double nonIteratedForce = random.NextDouble();
double iteratedForce = random.NextDouble();
double drivingMoment = random.NextDouble();
double resistingMoment = random.NextDouble();
// Call
var circle = new MacroStabilityInwardsSlidingCircle(center, radius, isActive, nonIteratedForce, iteratedForce, drivingMoment, resistingMoment);
// Assert
Assert.IsInstanceOf <ICloneable>(circle);
Assert.AreEqual(center, circle.Center);
Assert.AreEqual(radius, circle.Radius);
Assert.AreEqual(isActive, circle.IsActive);
Assert.AreEqual(nonIteratedForce, circle.NonIteratedForce);
Assert.AreEqual(iteratedForce, circle.IteratedForce);
Assert.AreEqual(drivingMoment, circle.DrivingMoment);
Assert.AreEqual(resistingMoment, circle.ResistingMoment);
}
private static void AssertSlidingCurveProperties(MacroStabilityInwardsSlidingCurve slidingCurve,
MacroStabilityInwardsCalculationOutputEntity entity)
{
string expectedSlicesXml = new MacroStabilityInwardsSliceCollectionXmlSerializer().ToXml(slidingCurve.Slices);
Assert.AreEqual(expectedSlicesXml, entity.SlidingCurveSliceXML);
AssertAreEqual(slidingCurve.IteratedHorizontalForce, entity.SlidingCurveIteratedHorizontalForce);
AssertAreEqual(slidingCurve.NonIteratedHorizontalForce, entity.SlidingCurveNonIteratedHorizontalForce);
MacroStabilityInwardsSlidingCircle leftCircle = slidingCurve.LeftCircle;
AssertAreEqual(leftCircle.Center.X, entity.SlidingCurveLeftSlidingCircleCenterX);
AssertAreEqual(leftCircle.Center.Y, entity.SlidingCurveLeftSlidingCircleCenterY);
AssertAreEqual(leftCircle.Radius, entity.SlidingCurveLeftSlidingCircleRadius);
Assert.AreEqual(Convert.ToByte(leftCircle.IsActive), entity.SlidingCurveLeftSlidingCircleIsActive);
AssertAreEqual(leftCircle.IteratedForce, entity.SlidingCurveLeftSlidingCircleIteratedForce);
AssertAreEqual(leftCircle.NonIteratedForce, entity.SlidingCurveLeftSlidingCircleNonIteratedForce);
AssertAreEqual(leftCircle.DrivingMoment, entity.SlidingCurveLeftSlidingCircleDrivingMoment);
AssertAreEqual(leftCircle.ResistingMoment, entity.SlidingCurveLeftSlidingCircleResistingMoment);
MacroStabilityInwardsSlidingCircle rightCircle = slidingCurve.RightCircle;
AssertAreEqual(rightCircle.Center.X, entity.SlidingCurveRightSlidingCircleCenterX);
AssertAreEqual(rightCircle.Center.Y, entity.SlidingCurveRightSlidingCircleCenterY);
AssertAreEqual(rightCircle.Radius, entity.SlidingCurveRightSlidingCircleRadius);
Assert.AreEqual(Convert.ToByte(rightCircle.IsActive), entity.SlidingCurveRightSlidingCircleIsActive);
AssertAreEqual(rightCircle.IteratedForce, entity.SlidingCurveRightSlidingCircleIteratedForce);
AssertAreEqual(rightCircle.NonIteratedForce, entity.SlidingCurveRightSlidingCircleNonIteratedForce);
AssertAreEqual(rightCircle.DrivingMoment, entity.SlidingCurveRightSlidingCircleDrivingMoment);
AssertAreEqual(rightCircle.ResistingMoment, entity.SlidingCurveRightSlidingCircleResistingMoment);
}
private static void AssertCircle(UpliftVanSlidingCircleResult circleResult, MacroStabilityInwardsSlidingCircle circleOutput)
{
Assert.AreEqual(circleResult.Center, circleOutput.Center);
Assert.AreEqual(circleResult.IsActive, circleOutput.IsActive);
Assert.AreEqual(circleResult.Radius, circleOutput.Radius);
Assert.AreEqual(circleResult.DrivingMoment, circleOutput.DrivingMoment);
Assert.AreEqual(circleResult.ResistingMoment, circleOutput.ResistingMoment);
Assert.AreEqual(circleResult.IteratedForce, circleOutput.IteratedForce);
Assert.AreEqual(circleResult.NonIteratedForce, circleOutput.NonIteratedForce);
}
public void Create_WithNaNValues_ReturnsPropertyWithExpectedPropertiesSet()
{
// Setup
MacroStabilityInwardsSlidingCircle leftCircle = CreateSlidingCircleWithNaNValues();
MacroStabilityInwardsSlidingCircle rightCircle = CreateSlidingCircleWithNaNValues();
var slidingCurve = new MacroStabilityInwardsSlidingCurve(leftCircle,
rightCircle,
new MacroStabilityInwardsSlice[0],
double.NaN,
double.NaN);
var slipPlane = new MacroStabilityInwardsSlipPlaneUpliftVan(CreateGridWithNaNValues(),
CreateGridWithNaNValues(),
new RoundedDouble[0]);
var output = new MacroStabilityInwardsOutput(slidingCurve, slipPlane, new MacroStabilityInwardsOutput.ConstructionProperties());
// Call
MacroStabilityInwardsCalculationOutputEntity entity = output.Create();
// Assert
Assert.IsNotNull(entity);
Assert.IsNull(entity.FactorOfStability);
Assert.IsNull(entity.ForbiddenZonesXEntryMin);
Assert.IsNull(entity.ForbiddenZonesXEntryMax);
Assert.IsNull(entity.SlipPlaneLeftGridXLeft);
Assert.IsNull(entity.SlipPlaneLeftGridXRight);
Assert.IsNull(entity.SlipPlaneLeftGridZTop);
Assert.IsNull(entity.SlipPlaneLeftGridZBottom);
Assert.IsNull(entity.SlipPlaneRightGridXLeft);
Assert.IsNull(entity.SlipPlaneRightGridXRight);
Assert.IsNull(entity.SlipPlaneRightGridZTop);
Assert.IsNull(entity.SlipPlaneRightGridZBottom);
Assert.IsNull(entity.SlidingCurveIteratedHorizontalForce);
Assert.IsNull(entity.SlidingCurveNonIteratedHorizontalForce);
Assert.IsNull(entity.SlidingCurveLeftSlidingCircleCenterX);
Assert.IsNull(entity.SlidingCurveLeftSlidingCircleCenterY);
Assert.IsNull(entity.SlidingCurveLeftSlidingCircleRadius);
Assert.IsNull(entity.SlidingCurveLeftSlidingCircleIteratedForce);
Assert.IsNull(entity.SlidingCurveLeftSlidingCircleNonIteratedForce);
Assert.IsNull(entity.SlidingCurveLeftSlidingCircleDrivingMoment);
Assert.IsNull(entity.SlidingCurveLeftSlidingCircleResistingMoment);
Assert.IsNull(entity.SlidingCurveRightSlidingCircleCenterX);
Assert.IsNull(entity.SlidingCurveRightSlidingCircleCenterY);
Assert.IsNull(entity.SlidingCurveRightSlidingCircleRadius);
Assert.IsNull(entity.SlidingCurveRightSlidingCircleIteratedForce);
Assert.IsNull(entity.SlidingCurveRightSlidingCircleNonIteratedForce);
Assert.IsNull(entity.SlidingCurveRightSlidingCircleDrivingMoment);
Assert.IsNull(entity.SlidingCurveRightSlidingCircleResistingMoment);
}
/// <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(MacroStabilityInwardsSlidingCircle original,
MacroStabilityInwardsSlidingCircle clone)
{
CoreCloneAssert.AreObjectClones(original.Center, clone.Center, GeometryCloneAssert.AreClones);
Assert.AreEqual(original.Radius, clone.Radius);
Assert.AreEqual(original.IsActive, clone.IsActive);
Assert.AreEqual(original.NonIteratedForce, clone.NonIteratedForce);
Assert.AreEqual(original.IteratedForce, clone.IteratedForce);
Assert.AreEqual(original.DrivingMoment, clone.DrivingMoment);
Assert.AreEqual(original.ResistingMoment, clone.ResistingMoment);
}
/// <summary>
/// Asserts whether <paramref name="actual"/> corresponds to <paramref name="startingPoint"/>
/// and <paramref name="slidingCircle"/>.
/// </summary>
/// <param name="startingPoint">The point to use for the start of the line</param>
/// <param name="slidingCircle">The circle to use for the end of the line.</param>
/// <param name="actual">The actual <see cref="ChartLineData"/>.</param>
/// <exception cref="AssertionException">Thrown when <paramref name="actual"/>
/// does not correspond to the specified start and end points.</exception>
private static void AssertCircleRadiusChartData(Point2D startingPoint,
MacroStabilityInwardsSlidingCircle slidingCircle,
ChartLineData actual)
{
Point2D[] points =
{
slidingCircle.Center,
startingPoint
};
CollectionAssert.AreEqual(points, actual.Points);
}
/// <summary>
/// Converts <see cref="UpliftVanSlidingCurveResult"/>
/// into <see cref="MacroStabilityInwardsSlidingCurve"/>.
/// </summary>
/// <param name="result">The result to convert.</param>
/// <returns>The converted <see cref="MacroStabilityInwardsSlidingCurve"/>.</returns>
/// <exception cref="ArgumentNullException">Thrown when <paramref name="result"/>
/// is <c>null</c>.</exception>
public static MacroStabilityInwardsSlidingCurve Convert(UpliftVanSlidingCurveResult result)
{
if (result == null)
{
throw new ArgumentNullException(nameof(result));
}
MacroStabilityInwardsSlidingCircle leftCircle = ConvertCircle(result.LeftCircle);
MacroStabilityInwardsSlidingCircle rightCircle = ConvertCircle(result.RightCircle);
IEnumerable <MacroStabilityInwardsSlice> slices = ConvertSlices(result.Slices);
return(new MacroStabilityInwardsSlidingCurve(leftCircle, rightCircle, slices, result.NonIteratedHorizontalForce, result.IteratedHorizontalForce));
}
public void Constructor_SlicesNull_ThrowsArgumentNullException()
{
// Setup
MacroStabilityInwardsSlidingCircle circle = MacroStabilityInwardsSlidingCircleTestFactory.Create();
// Call
TestDelegate call = () => new MacroStabilityInwardsSlidingCurve(circle, circle, null, 0, 0);
// Assert
var exception = Assert.Throws <ArgumentNullException>(call);
Assert.AreEqual("slices", exception.ParamName);
}
public void Constructor_RightCircleNull_ThrowsArgumentNullException()
{
// Setup
MacroStabilityInwardsSlidingCircle leftCircle = MacroStabilityInwardsSlidingCircleTestFactory.Create();
// Call
TestDelegate call = () => new MacroStabilityInwardsSlidingCurve(leftCircle, null, Enumerable.Empty <MacroStabilityInwardsSlice>(), 0, 0);
// Assert
var exception = Assert.Throws <ArgumentNullException>(call);
Assert.AreEqual("rightCircle", exception.ParamName);
}
public void Clone_Always_ReturnNewInstanceWithCopiedValues()
{
// Setup
var random = new Random(21);
MacroStabilityInwardsSlidingCircle rightCircle = MacroStabilityInwardsSlidingCircleTestFactory.Create();
MacroStabilityInwardsSlidingCircle leftCircle = MacroStabilityInwardsSlidingCircleTestFactory.Create();
MacroStabilityInwardsSlice[] slices =
{
MacroStabilityInwardsSliceTestFactory.CreateSlice()
};
var original = new MacroStabilityInwardsSlidingCurve(leftCircle, rightCircle, slices, random.NextDouble(), random.NextDouble());
// Call
object clone = original.Clone();
// Assert
CoreCloneAssert.AreObjectClones(original, clone, MacroStabilityInwardsCloneAssert.AreClones);
}
public void Clone_Always_ReturnNewInstanceWithCopiedValues()
{
// Setup
var random = new Random(11);
var center = new Point2D(random.NextDouble(), random.NextDouble());
var original = new MacroStabilityInwardsSlidingCircle(center,
random.NextDouble(),
random.NextBoolean(),
random.NextDouble(),
random.NextDouble(),
random.NextDouble(),
random.NextDouble());
// Call
object clone = original.Clone();
// Assert
CoreCloneAssert.AreObjectClones(original, clone, MacroStabilityInwardsCloneAssert.AreClones);
}
public void Create_WithValidValues_ReturnsEntityWithExpectedPropertiesSet()
{
// Setup
var random = new Random(21);
MacroStabilityInwardsSlidingCircle leftCircle = CreateSlidingCircle(13);
MacroStabilityInwardsSlidingCircle rightCircle = CreateSlidingCircle(34);
IEnumerable<MacroStabilityInwardsSlice> slices = new[]
{
MacroStabilityInwardsSliceTestFactory.CreateSlice()
};
var slidingCurve = new MacroStabilityInwardsSlidingCurve(leftCircle,
rightCircle,
slices,
random.NextDouble(),
random.NextDouble());
MacroStabilityInwardsGrid leftGrid = MacroStabilityInwardsGridTestFactory.Create();
MacroStabilityInwardsGrid rightGrid = MacroStabilityInwardsGridTestFactory.Create();
RoundedDouble[] tangentLines =
{
random.NextRoundedDouble()
};
var slipPlane = new MacroStabilityInwardsSlipPlaneUpliftVan(leftGrid, rightGrid, tangentLines);
var output = new MacroStabilityInwardsOutput(slidingCurve, slipPlane, new MacroStabilityInwardsOutput.ConstructionProperties
{
FactorOfStability = random.NextDouble(),
ForbiddenZonesXEntryMax = random.NextDouble(),
ForbiddenZonesXEntryMin = random.NextDouble()
});
// Call
MacroStabilityInwardsCalculationOutputEntity entity = output.Create();
// Assert
Assert.IsNotNull(entity);
MacroStabilityInwardsCalculationOutputEntityTestHelper.AssertOutputPropertyValues(output, entity);
}
