public void Read_EntityWithOutput_ReturnsCalculationScenarioWithOutput() { // Setup var random = new Random(31); var tangentLines = new RoundedDouble[0]; var slices = new MacroStabilityInwardsSlice[0]; var calculationOutputEntity = new MacroStabilityInwardsCalculationOutputEntity { SlipPlaneTangentLinesXml = new TangentLineCollectionXmlSerializer().ToXml(tangentLines), SlidingCurveSliceXML = new MacroStabilityInwardsSliceCollectionXmlSerializer().ToXml(slices), SlipPlaneLeftGridNrOfHorizontalPoints = random.Next(1, 100), SlipPlaneLeftGridNrOfVerticalPoints = random.Next(1, 100), SlipPlaneRightGridNrOfHorizontalPoints = random.Next(1, 100), SlipPlaneRightGridNrOfVerticalPoints = random.Next(1, 100) }; MacroStabilityInwardsCalculationEntity entity = CreateValidCalculationEntity(); entity.MacroStabilityInwardsCalculationOutputEntities.Add(calculationOutputEntity); var collector = new ReadConversionCollector(); // Call MacroStabilityInwardsCalculationScenario calculation = entity.Read(collector); // Assert MacroStabilityInwardsOutput output = calculation.Output; Assert.IsNotNull(output); MacroStabilityInwardsCalculationOutputEntityTestHelper.AssertOutputPropertyValues(output, calculationOutputEntity); }
/// <summary> /// Creates a new instance of <see cref="MacroStabilityInwardsSliceRow"/>. /// </summary> /// <param name="slice">The <see cref="MacroStabilityInwardsSlice"/> to use.</param> /// <param name="index">The index of the slice.</param> /// <exception cref="ArgumentNullException">Thrown when <paramref name="slice"/> /// is <c>null</c>.</exception> public MacroStabilityInwardsSliceRow(MacroStabilityInwardsSlice slice, int index) { if (slice == null) { throw new ArgumentNullException(nameof(slice)); } Name = string.Format(Resources.MacroStabilityInwardsSlicesTable_Name_Slice_0, index); XCenter = slice.XCenter; ZCenterBottom = slice.ZCenterBottom; Width = slice.Width; ArcLength = slice.ArcLength; BottomAngle = slice.BottomAngle; TopAngle = slice.TopAngle; FrictionAngle = slice.FrictionAngle; Cohesion = slice.Cohesion; EffectiveStress = slice.EffectiveStress; TotalPorePressure = slice.TotalPorePressure; Weight = slice.Weight; PiezometricPorePressure = slice.PiezometricPorePressure; PorePressure = slice.PorePressure; VerticalPorePressure = slice.VerticalPorePressure; HorizontalPorePressure = slice.HorizontalPorePressure; OverConsolidationRatio = slice.OverConsolidationRatio; Pop = slice.Pop; NormalStress = slice.NormalStress; ShearStress = slice.ShearStress; LoadStress = slice.LoadStress; }
public void Constructor_WithSlice_ExpectedValues() { // Setup var slice = new MacroStabilityInwardsSlice( new Point2D(0, 10), new Point2D(10, 8), new Point2D(0, 2), new Point2D(10, 1), new MacroStabilityInwardsSlice.ConstructionProperties { Cohesion = double.NaN, FrictionAngle = 2.0, EffectiveStress = 3.0, TotalPorePressure = 4.0, Weight = 5.0, PiezometricPorePressure = 6.0, DegreeOfConsolidationPorePressureSoil = 7.0, DegreeOfConsolidationPorePressureLoad = 8.0, PorePressure = 9.0, VerticalPorePressure = 10.0, HorizontalPorePressure = 11.0, ExternalLoad = 12.0, OverConsolidationRatio = 13.0, Pop = 14.0, NormalStress = 15.0, ShearStress = 16.0, LoadStress = 17.0 }); // Call var sliceRow = new MacroStabilityInwardsSliceRow(slice, 3); // Assert Assert.AreEqual("Lamel 3", sliceRow.Name); Assert.AreEqual(5.0, sliceRow.XCenter, sliceRow.XCenter.GetAccuracy()); Assert.AreEqual(1.5, sliceRow.ZCenterBottom, sliceRow.ZCenterBottom.GetAccuracy()); Assert.AreEqual(10.0, sliceRow.Width, sliceRow.Width.GetAccuracy()); Assert.AreEqual(10.05, sliceRow.ArcLength, sliceRow.ArcLength.GetAccuracy()); Assert.AreEqual(-5.71, sliceRow.BottomAngle, sliceRow.BottomAngle.GetAccuracy()); Assert.AreEqual(-11.31, sliceRow.TopAngle, sliceRow.TopAngle.GetAccuracy()); Assert.AreEqual(2.0, sliceRow.FrictionAngle, sliceRow.FrictionAngle.GetAccuracy()); Assert.AreEqual(double.NaN, sliceRow.Cohesion, sliceRow.Cohesion.GetAccuracy()); Assert.AreEqual(3.0, sliceRow.EffectiveStress, sliceRow.EffectiveStress.GetAccuracy()); Assert.AreEqual(4.0, sliceRow.TotalPorePressure, sliceRow.TotalPorePressure.GetAccuracy()); Assert.AreEqual(5.0, sliceRow.Weight, sliceRow.Weight.GetAccuracy()); Assert.AreEqual(6.0, sliceRow.PiezometricPorePressure, sliceRow.PiezometricPorePressure.GetAccuracy()); Assert.AreEqual(9.0, sliceRow.PorePressure, sliceRow.PorePressure.GetAccuracy()); Assert.AreEqual(10.0, sliceRow.VerticalPorePressure, sliceRow.VerticalPorePressure.GetAccuracy()); Assert.AreEqual(11.0, sliceRow.HorizontalPorePressure, sliceRow.HorizontalPorePressure.GetAccuracy()); Assert.AreEqual(13.0, sliceRow.OverConsolidationRatio, sliceRow.OverConsolidationRatio.GetAccuracy()); Assert.AreEqual(14.0, sliceRow.Pop, sliceRow.Pop.GetAccuracy()); Assert.AreEqual(15.0, sliceRow.NormalStress, sliceRow.NormalStress.GetAccuracy()); Assert.AreEqual(16.0, sliceRow.ShearStress, sliceRow.ShearStress.GetAccuracy()); Assert.AreEqual(17.0, sliceRow.LoadStress, sliceRow.LoadStress.GetAccuracy()); }
public void Clone_AllPropertiesSet_ReturnNewInstanceWithCopiedValues() { // Setup var random = new Random(21); var properties = new MacroStabilityInwardsSlice.ConstructionProperties { Cohesion = random.NextDouble(), FrictionAngle = random.NextDouble(), CriticalPressure = random.NextDouble(), OverConsolidationRatio = random.NextDouble(), DegreeOfConsolidationPorePressureSoil = random.NextDouble(), DegreeOfConsolidationPorePressureLoad = random.NextDouble(), Pop = random.NextDouble(), Dilatancy = random.NextDouble(), ExternalLoad = random.NextDouble(), HydrostaticPorePressure = random.NextDouble(), LeftForce = random.NextDouble(), LeftForceAngle = random.NextDouble(), LeftForceY = random.NextDouble(), RightForce = random.NextDouble(), RightForceAngle = random.NextDouble(), RightForceY = random.NextDouble(), LoadStress = random.NextDouble(), NormalStress = random.NextDouble(), PorePressure = random.NextDouble(), HorizontalPorePressure = random.NextDouble(), VerticalPorePressure = random.NextDouble(), PiezometricPorePressure = random.NextDouble(), EffectiveStress = random.NextDouble(), ExcessPorePressure = random.NextDouble(), ShearStress = random.NextDouble(), SoilStress = random.NextDouble(), TotalPorePressure = random.NextDouble(), TotalStress = random.NextDouble(), Weight = random.NextDouble() }; var original = new MacroStabilityInwardsSlice(CreateRandomPoint(random), CreateRandomPoint(random), CreateRandomPoint(random), CreateRandomPoint(random), properties); // Call object clone = original.Clone(); // Assert CoreCloneAssert.AreObjectClones(original, clone, MacroStabilityInwardsCloneAssert.AreClones); }
/// <summary> /// Asserts whether <paramref name="actual"/> corresponds to <paramref name="slices"/>. /// </summary> /// <param name="slices">The original slices.</param> /// <param name="actual">The actual <see cref="ChartMultipleAreaData"/>.</param> /// <exception cref="AssertionException">Thrown when <paramref name="actual"/> /// does not correspond to <paramref name="slices"/>.</exception> private static void AssertSlicesChartData(IEnumerable <MacroStabilityInwardsSlice> slices, ChartMultipleAreaData actual) { MacroStabilityInwardsSlice[] macroStabilityInwardsSlices = slices.ToArray(); CollectionAssert.IsNotEmpty(macroStabilityInwardsSlices); for (var i = 0; i < macroStabilityInwardsSlices.Length; i++) { MacroStabilityInwardsSlice slice = macroStabilityInwardsSlices[i]; Point2D[] expectedPoints = { slice.TopLeftPoint, slice.TopRightPoint, slice.BottomRightPoint, slice.BottomLeftPoint }; CollectionAssert.AreEqual(expectedPoints, actual.Areas.ElementAt(i)); } }
/// <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(MacroStabilityInwardsSlice original, MacroStabilityInwardsSlice clone) { CoreCloneAssert.AreObjectClones(original.TopLeftPoint, clone.TopLeftPoint, GeometryCloneAssert.AreClones); CoreCloneAssert.AreObjectClones(original.TopRightPoint, clone.TopRightPoint, GeometryCloneAssert.AreClones); CoreCloneAssert.AreObjectClones(original.BottomLeftPoint, clone.BottomLeftPoint, GeometryCloneAssert.AreClones); CoreCloneAssert.AreObjectClones(original.BottomRightPoint, clone.BottomRightPoint, GeometryCloneAssert.AreClones); Assert.AreEqual(original.XCenter, clone.XCenter); Assert.AreEqual(original.ZCenterBottom, clone.ZCenterBottom); Assert.AreEqual(original.Width, clone.Width); Assert.AreEqual(original.ArcLength, clone.ArcLength); Assert.AreEqual(original.BottomAngle, clone.BottomAngle); Assert.AreEqual(original.TopAngle, clone.TopAngle); Assert.AreEqual(original.Cohesion, clone.Cohesion); Assert.AreEqual(original.FrictionAngle, clone.FrictionAngle); Assert.AreEqual(original.CriticalPressure, clone.CriticalPressure); Assert.AreEqual(original.OverConsolidationRatio, clone.OverConsolidationRatio); Assert.AreEqual(original.Pop, clone.Pop); Assert.AreEqual(original.DegreeOfConsolidationPorePressureSoil, clone.DegreeOfConsolidationPorePressureSoil); Assert.AreEqual(original.DegreeOfConsolidationPorePressureLoad, clone.DegreeOfConsolidationPorePressureLoad); Assert.AreEqual(original.Dilatancy, clone.Dilatancy); Assert.AreEqual(original.ExternalLoad, clone.ExternalLoad); Assert.AreEqual(original.HydrostaticPorePressure, clone.HydrostaticPorePressure); Assert.AreEqual(original.LeftForce, clone.LeftForce); Assert.AreEqual(original.LeftForceAngle, clone.LeftForceAngle); Assert.AreEqual(original.LeftForceY, clone.LeftForceY); Assert.AreEqual(original.RightForce, clone.RightForce); Assert.AreEqual(original.RightForceAngle, clone.RightForceAngle); Assert.AreEqual(original.RightForceY, clone.RightForceY); Assert.AreEqual(original.LoadStress, clone.LoadStress); Assert.AreEqual(original.NormalStress, clone.NormalStress); Assert.AreEqual(original.PorePressure, clone.PorePressure); Assert.AreEqual(original.HorizontalPorePressure, clone.HorizontalPorePressure); Assert.AreEqual(original.VerticalPorePressure, clone.VerticalPorePressure); Assert.AreEqual(original.PiezometricPorePressure, clone.PiezometricPorePressure); Assert.AreEqual(original.EffectiveStress, clone.EffectiveStress); Assert.AreEqual(original.ExcessPorePressure, clone.ExcessPorePressure); Assert.AreEqual(original.ShearStress, clone.ShearStress); Assert.AreEqual(original.SoilStress, clone.SoilStress); Assert.AreEqual(original.TotalPorePressure, clone.TotalPorePressure); Assert.AreEqual(original.TotalStress, clone.TotalStress); Assert.AreEqual(original.Weight, clone.Weight); }
/// <summary> /// Creates a new instance of <see cref="SerializableMacroStabilityInwardsSlice"/>. /// </summary> /// <param name="slice">The <see cref="MacroStabilityInwardsSlice"/> to base the /// <see cref="SerializableMacroStabilityInwardsSlice"/> on.</param> public SerializableMacroStabilityInwardsSlice(MacroStabilityInwardsSlice slice) { topLeftPointX = slice.TopLeftPoint.X; topLeftPointY = slice.TopLeftPoint.Y; topRightPointX = slice.TopRightPoint.X; topRightPointY = slice.TopRightPoint.Y; bottomLeftPointX = slice.BottomLeftPoint.X; bottomLeftPointY = slice.BottomLeftPoint.Y; bottomRightPointX = slice.BottomRightPoint.X; bottomRightPointY = slice.BottomRightPoint.Y; cohesion = slice.Cohesion; frictionAngle = slice.FrictionAngle; criticalPressure = slice.CriticalPressure; overConsolidationRatio = slice.OverConsolidationRatio; pop = slice.Pop; degreeOfConsolidationPorePressureSoil = slice.DegreeOfConsolidationPorePressureSoil; degreeOfConsolidationPorePressureLoad = slice.DegreeOfConsolidationPorePressureLoad; dilatancy = slice.Dilatancy; externalLoad = slice.ExternalLoad; hydrostaticPorePressure = slice.HydrostaticPorePressure; leftForce = slice.LeftForce; leftForceAngle = slice.LeftForceAngle; leftForceY = slice.LeftForceY; rightForce = slice.RightForce; rightForceAngle = slice.RightForceAngle; rightForceY = slice.RightForceY; loadStress = slice.LoadStress; normalStress = slice.NormalStress; porePressure = slice.PorePressure; horizontalPorePressure = slice.HorizontalPorePressure; verticalPorePressure = slice.VerticalPorePressure; piezometricPorePressure = slice.PiezometricPorePressure; effectiveStress = slice.EffectiveStress; excessPorePressure = slice.ExcessPorePressure; shearStress = slice.ShearStress; soilStress = slice.SoilStress; totalPorePressure = slice.TotalPorePressure; totalStress = slice.TotalStress; weight = slice.Weight; }
public void Constructor_WithCoordinates_ExpectedValues() { // Setup var topLeftPoint = new Point2D(0, 5); var topRightPoint = new Point2D(5, 4); var bottomLeftPoint = new Point2D(0, 0); var bottomRightPoint = new Point2D(5, 1); // Call var slice = new MacroStabilityInwardsSlice(topLeftPoint, topRightPoint, bottomLeftPoint, bottomRightPoint, new MacroStabilityInwardsSlice.ConstructionProperties()); // Assert Assert.IsInstanceOf <ICloneable>(slice); Assert.AreSame(topLeftPoint, slice.TopLeftPoint); Assert.AreSame(topRightPoint, slice.TopRightPoint); Assert.AreSame(bottomLeftPoint, slice.BottomLeftPoint); Assert.AreSame(bottomRightPoint, slice.BottomRightPoint); Assert.AreEqual(2, slice.XCenter.NumberOfDecimalPlaces); Assert.AreEqual(2.5, slice.XCenter, slice.XCenter.GetAccuracy()); Assert.AreEqual(2, slice.ZCenterBottom.NumberOfDecimalPlaces); Assert.AreEqual(0.5, slice.ZCenterBottom, slice.ZCenterBottom.GetAccuracy()); Assert.AreEqual(2, slice.Width.NumberOfDecimalPlaces); Assert.AreEqual(5.0, slice.Width, slice.Width.GetAccuracy()); Assert.AreEqual(2, slice.ArcLength.NumberOfDecimalPlaces); Assert.AreEqual(5.1, slice.ArcLength, slice.ArcLength.GetAccuracy()); Assert.AreEqual(2, slice.BottomAngle.NumberOfDecimalPlaces); Assert.AreEqual(11.31, slice.BottomAngle, slice.BottomAngle.GetAccuracy()); Assert.AreEqual(2, slice.TopAngle.NumberOfDecimalPlaces); Assert.AreEqual(-11.31, slice.TopAngle, slice.TopAngle.GetAccuracy()); }
public void Constructor_ConstructionPropertiesEmpty_ExpectedValues() { // Call var slice = new MacroStabilityInwardsSlice(new Point2D(0, 0), new Point2D(0, 0), new Point2D(0, 0), new Point2D(0, 0), new MacroStabilityInwardsSlice.ConstructionProperties()); // Assert Assert.IsNaN(slice.Cohesion); Assert.IsNaN(slice.FrictionAngle); Assert.IsNaN(slice.CriticalPressure); Assert.IsNaN(slice.OverConsolidationRatio); Assert.IsNaN(slice.Pop); Assert.IsNaN(slice.DegreeOfConsolidationPorePressureSoil); Assert.IsNaN(slice.DegreeOfConsolidationPorePressureLoad); Assert.IsNaN(slice.Dilatancy); Assert.IsNaN(slice.ExternalLoad); Assert.IsNaN(slice.HydrostaticPorePressure); Assert.IsNaN(slice.LeftForce); Assert.IsNaN(slice.LeftForceAngle); Assert.IsNaN(slice.LeftForceY); Assert.IsNaN(slice.RightForce); Assert.IsNaN(slice.RightForceAngle); Assert.IsNaN(slice.RightForceY); Assert.IsNaN(slice.LoadStress); Assert.IsNaN(slice.NormalStress); Assert.IsNaN(slice.PorePressure); Assert.IsNaN(slice.HorizontalPorePressure); Assert.IsNaN(slice.VerticalPorePressure); Assert.IsNaN(slice.PiezometricPorePressure); Assert.IsNaN(slice.EffectiveStress); Assert.IsNaN(slice.ExcessPorePressure); Assert.IsNaN(slice.ShearStress); Assert.IsNaN(slice.SoilStress); Assert.IsNaN(slice.TotalPorePressure); Assert.IsNaN(slice.TotalStress); Assert.IsNaN(slice.Weight); }
public void Constructor_ConstructionPropertiesSet_ExpectedValues() { // Setup var random = new Random(21); double cohesion = random.NextDouble(); double frictionAngle = random.NextDouble(); double criticalPressure = random.NextDouble(); double overConsolidationRatio = random.NextDouble(); double pop = random.NextDouble(); double degreeOfConsolidationPorePressureSoil = random.NextDouble(); double degreeOfConsolidationPorePressureLoad = random.NextDouble(); double dilatancy = random.NextDouble(); double externalLoad = random.NextDouble(); double hydrostaticPorePressure = random.NextDouble(); double leftForce = random.NextDouble(); double leftForceAngle = random.NextDouble(); double leftForceY = random.NextDouble(); double rightForce = random.NextDouble(); double rightForceAngle = random.NextDouble(); double rightForceY = random.NextDouble(); double loadStress = random.NextDouble(); double normalStress = random.NextDouble(); double porePressure = random.NextDouble(); double horizontalPorePressure = random.NextDouble(); double verticalPorePressure = random.NextDouble(); double piezometricPorePressure = random.NextDouble(); double effectiveStress = random.NextDouble(); double excessPorePressure = random.NextDouble(); double shearStress = random.NextDouble(); double soilStress = random.NextDouble(); double totalPorePressure = random.NextDouble(); double totalStress = random.NextDouble(); double weight = random.NextDouble(); var properties = new MacroStabilityInwardsSlice.ConstructionProperties { Cohesion = cohesion, FrictionAngle = frictionAngle, CriticalPressure = criticalPressure, OverConsolidationRatio = overConsolidationRatio, DegreeOfConsolidationPorePressureSoil = degreeOfConsolidationPorePressureSoil, DegreeOfConsolidationPorePressureLoad = degreeOfConsolidationPorePressureLoad, Pop = pop, Dilatancy = dilatancy, ExternalLoad = externalLoad, HydrostaticPorePressure = hydrostaticPorePressure, LeftForce = leftForce, LeftForceAngle = leftForceAngle, LeftForceY = leftForceY, RightForce = rightForce, RightForceAngle = rightForceAngle, RightForceY = rightForceY, LoadStress = loadStress, NormalStress = normalStress, PorePressure = porePressure, HorizontalPorePressure = horizontalPorePressure, VerticalPorePressure = verticalPorePressure, PiezometricPorePressure = piezometricPorePressure, EffectiveStress = effectiveStress, ExcessPorePressure = excessPorePressure, ShearStress = shearStress, SoilStress = soilStress, TotalPorePressure = totalPorePressure, TotalStress = totalStress, Weight = weight }; // Call var slice = new MacroStabilityInwardsSlice(new Point2D(0, 0), new Point2D(0, 0), new Point2D(0, 0), new Point2D(0, 0), properties); // Assert Assert.AreEqual(3, slice.Cohesion.NumberOfDecimalPlaces); Assert.AreEqual(cohesion, slice.Cohesion, slice.Cohesion.GetAccuracy()); Assert.AreEqual(3, slice.FrictionAngle.NumberOfDecimalPlaces); Assert.AreEqual(frictionAngle, slice.FrictionAngle, slice.FrictionAngle.GetAccuracy()); Assert.AreEqual(3, slice.CriticalPressure.NumberOfDecimalPlaces); Assert.AreEqual(criticalPressure, slice.CriticalPressure, slice.CriticalPressure.GetAccuracy()); Assert.AreEqual(3, slice.OverConsolidationRatio.NumberOfDecimalPlaces); Assert.AreEqual(overConsolidationRatio, slice.OverConsolidationRatio, slice.OverConsolidationRatio.GetAccuracy()); Assert.AreEqual(3, slice.Pop.NumberOfDecimalPlaces); Assert.AreEqual(pop, slice.Pop, slice.Pop.GetAccuracy()); Assert.AreEqual(3, slice.DegreeOfConsolidationPorePressureSoil.NumberOfDecimalPlaces); Assert.AreEqual(degreeOfConsolidationPorePressureSoil, slice.DegreeOfConsolidationPorePressureSoil, slice.DegreeOfConsolidationPorePressureSoil.GetAccuracy()); Assert.AreEqual(3, slice.DegreeOfConsolidationPorePressureLoad.NumberOfDecimalPlaces); Assert.AreEqual(degreeOfConsolidationPorePressureLoad, slice.DegreeOfConsolidationPorePressureLoad, slice.DegreeOfConsolidationPorePressureLoad.GetAccuracy()); Assert.AreEqual(3, slice.Dilatancy.NumberOfDecimalPlaces); Assert.AreEqual(dilatancy, slice.Dilatancy, slice.Dilatancy.GetAccuracy()); Assert.AreEqual(3, slice.ExternalLoad.NumberOfDecimalPlaces); Assert.AreEqual(externalLoad, slice.ExternalLoad, slice.ExternalLoad.GetAccuracy()); Assert.AreEqual(3, slice.HydrostaticPorePressure.NumberOfDecimalPlaces); Assert.AreEqual(hydrostaticPorePressure, slice.HydrostaticPorePressure, slice.HydrostaticPorePressure.GetAccuracy()); Assert.AreEqual(3, slice.LeftForce.NumberOfDecimalPlaces); Assert.AreEqual(leftForce, slice.LeftForce, slice.LeftForce.GetAccuracy()); Assert.AreEqual(3, slice.LeftForceAngle.NumberOfDecimalPlaces); Assert.AreEqual(leftForceAngle, slice.LeftForceAngle, slice.LeftForceAngle.GetAccuracy()); Assert.AreEqual(3, slice.LeftForceY.NumberOfDecimalPlaces); Assert.AreEqual(leftForceY, slice.LeftForceY, slice.LeftForceY.GetAccuracy()); Assert.AreEqual(3, slice.RightForce.NumberOfDecimalPlaces); Assert.AreEqual(rightForce, slice.RightForce, slice.RightForce.GetAccuracy()); Assert.AreEqual(3, slice.RightForceAngle.NumberOfDecimalPlaces); Assert.AreEqual(rightForceAngle, slice.RightForceAngle, slice.RightForceAngle.GetAccuracy()); Assert.AreEqual(3, slice.RightForceY.NumberOfDecimalPlaces); Assert.AreEqual(rightForceY, slice.RightForceY, slice.RightForceY.GetAccuracy()); Assert.AreEqual(3, slice.LoadStress.NumberOfDecimalPlaces); Assert.AreEqual(loadStress, slice.LoadStress, slice.LoadStress.GetAccuracy()); Assert.AreEqual(3, slice.NormalStress.NumberOfDecimalPlaces); Assert.AreEqual(normalStress, slice.NormalStress, slice.NormalStress.GetAccuracy()); Assert.AreEqual(3, slice.PorePressure.NumberOfDecimalPlaces); Assert.AreEqual(porePressure, slice.PorePressure, slice.PorePressure.GetAccuracy()); Assert.AreEqual(3, slice.HorizontalPorePressure.NumberOfDecimalPlaces); Assert.AreEqual(horizontalPorePressure, slice.HorizontalPorePressure, slice.HorizontalPorePressure.GetAccuracy()); Assert.AreEqual(3, slice.VerticalPorePressure.NumberOfDecimalPlaces); Assert.AreEqual(verticalPorePressure, slice.VerticalPorePressure, slice.VerticalPorePressure.GetAccuracy()); Assert.AreEqual(3, slice.PiezometricPorePressure.NumberOfDecimalPlaces); Assert.AreEqual(piezometricPorePressure, slice.PiezometricPorePressure, slice.PiezometricPorePressure.GetAccuracy()); Assert.AreEqual(3, slice.EffectiveStress.NumberOfDecimalPlaces); Assert.AreEqual(effectiveStress, slice.EffectiveStress, slice.EffectiveStress.GetAccuracy()); Assert.AreEqual(3, slice.ExcessPorePressure.NumberOfDecimalPlaces); Assert.AreEqual(excessPorePressure, slice.ExcessPorePressure, slice.ExcessPorePressure.GetAccuracy()); Assert.AreEqual(3, slice.ShearStress.NumberOfDecimalPlaces); Assert.AreEqual(shearStress, slice.ShearStress, slice.ShearStress.GetAccuracy()); Assert.AreEqual(3, slice.SoilStress.NumberOfDecimalPlaces); Assert.AreEqual(soilStress, slice.SoilStress, slice.SoilStress.GetAccuracy()); Assert.AreEqual(3, slice.TotalPorePressure.NumberOfDecimalPlaces); Assert.AreEqual(totalPorePressure, slice.TotalPorePressure, slice.TotalPorePressure.GetAccuracy()); Assert.AreEqual(3, slice.TotalStress.NumberOfDecimalPlaces); Assert.AreEqual(totalStress, slice.TotalStress, slice.TotalStress.GetAccuracy()); Assert.AreEqual(3, slice.Weight.NumberOfDecimalPlaces); Assert.AreEqual(weight, slice.Weight, slice.Weight.GetAccuracy()); }
public void SetData_WithData_ExpectedValuesInTable() { // Setup using (var table = new MacroStabilityInwardsSlicesTable()) { MacroStabilityInwardsSlice[] slices = { MacroStabilityInwardsSliceTestFactory.CreateSlice(), MacroStabilityInwardsSliceTestFactory.CreateSlice(), MacroStabilityInwardsSliceTestFactory.CreateSlice() }; // Call table.SetData(slices); // Assert Assert.AreEqual(slices.Length, table.Rows.Count); for (var i = 0; i < table.Rows.Count; i++) { MacroStabilityInwardsSlice slice = slices[i]; DataGridViewCellCollection rowCells = table.Rows[i].Cells; Assert.AreEqual("Lamel " + (i + 1), rowCells[nameColumnIndex].Value); var xCenter = (RoundedDouble)rowCells[xCenterColumnIndex].Value; Assert.AreEqual((slice.TopLeftPoint.X + slice.TopRightPoint.X) / 2.0, xCenter, xCenter.GetAccuracy()); var zCenter = (RoundedDouble)rowCells[zCenterBottomColumnIndex].Value; Assert.AreEqual(new Segment2D(slice.BottomLeftPoint, slice.BottomRightPoint).Interpolate(xCenter), zCenter, zCenter.GetAccuracy()); var width = (RoundedDouble)rowCells[widthColumnIndex].Value; Assert.AreEqual(slice.TopRightPoint.X - slice.TopLeftPoint.X, width, width.GetAccuracy()); var arcLength = (RoundedDouble)rowCells[arcLengthColumnIndex].Value; Assert.AreEqual(slice.BottomLeftPoint.GetEuclideanDistanceTo(slice.BottomRightPoint), arcLength, arcLength.GetAccuracy()); var bottomAngle = (RoundedDouble)rowCells[bottomAngleColumnIndex].Value; Assert.AreEqual(Math2D.GetAngleBetween(slice.BottomLeftPoint, slice.BottomRightPoint), bottomAngle, bottomAngle.GetAccuracy()); var topAngle = (RoundedDouble)rowCells[topAngleColumnIndex].Value; Assert.AreEqual(Math2D.GetAngleBetween(slice.TopLeftPoint, slice.TopRightPoint), topAngle, topAngle.GetAccuracy()); var frictionAngle = (RoundedDouble)rowCells[frictionAngleColumnIndex].Value; Assert.AreEqual(slice.FrictionAngle, frictionAngle, frictionAngle.GetAccuracy()); var cohesion = (RoundedDouble)rowCells[cohesionColumnIndex].Value; Assert.AreEqual(slice.Cohesion, cohesion, cohesion.GetAccuracy()); var effectiveStress = (RoundedDouble)rowCells[effectiveStressColumnIndex].Value; Assert.AreEqual(slice.EffectiveStress, effectiveStress, effectiveStress.GetAccuracy()); var totalPorePressure = (RoundedDouble)rowCells[totalPorePressureColumnIndex].Value; Assert.AreEqual(slice.TotalPorePressure, totalPorePressure, totalPorePressure.GetAccuracy()); var weight = (RoundedDouble)rowCells[weightColumnIndex].Value; Assert.AreEqual(slice.Weight, weight, weight.GetAccuracy()); var piezometricPorePressure = (RoundedDouble)rowCells[piezometricPorePressureColumnIndex].Value; Assert.AreEqual(slice.PiezometricPorePressure, piezometricPorePressure, piezometricPorePressure.GetAccuracy()); var porePressure = (RoundedDouble)rowCells[porePressureColumnIndex].Value; Assert.AreEqual(slice.PorePressure, porePressure, porePressure.GetAccuracy()); var verticalPorePressure = (RoundedDouble)rowCells[verticalPorePressureColumnIndex].Value; Assert.AreEqual(slice.VerticalPorePressure, verticalPorePressure, verticalPorePressure.GetAccuracy()); var horizontalPorePressure = (RoundedDouble)rowCells[horizontalPorePressureColumnIndex].Value; Assert.AreEqual(slice.HorizontalPorePressure, horizontalPorePressure, horizontalPorePressure.GetAccuracy()); var ocr = (RoundedDouble)rowCells[overConsolidationRatioColumnIndex].Value; Assert.AreEqual(slice.OverConsolidationRatio, ocr, ocr.GetAccuracy()); var pop = (RoundedDouble)rowCells[popColumnIndex].Value; Assert.AreEqual(slice.Pop, pop, pop.GetAccuracy()); var normalStress = (RoundedDouble)rowCells[normalStressColumnIndex].Value; Assert.AreEqual(slice.NormalStress, normalStress, normalStress.GetAccuracy()); var shearStress = (RoundedDouble)rowCells[shearStressColumnIndex].Value; Assert.AreEqual(slice.ShearStress, shearStress, shearStress.GetAccuracy()); var loadStress = (RoundedDouble)rowCells[loadStressColumnIndex].Value; Assert.AreEqual(slice.LoadStress, loadStress, loadStress.GetAccuracy()); } } }