Index: DamClients/DamUI/trunk/src/Dam/Tests/DamPipingBenchmarkTest.cs =================================================================== diff -u -r3527 -r3826 --- DamClients/DamUI/trunk/src/Dam/Tests/DamPipingBenchmarkTest.cs (.../DamPipingBenchmarkTest.cs) (revision 3527) +++ DamClients/DamUI/trunk/src/Dam/Tests/DamPipingBenchmarkTest.cs (.../DamPipingBenchmarkTest.cs) (revision 3826) @@ -135,24 +135,24 @@ var expectedGradient = 1.9; var expectedSafetyFactorOverall = expectedPipingFactor; var expectedHcriticalOverall = expectedHCritical; - Assert.AreEqual(expectedPipingFactor, allCalculationresults[0].Wti2017BackwardErosionSafetyFactor.Value, cTolerance); - Assert.AreEqual(expectedHCritical, allCalculationresults[0].Wti2017BackwardErosionHcritical.Value, cTolerance); - Assert.AreEqual(true, allCalculationresults[0].IsUplift.Value); - Assert.AreEqual(expectedLocalPipingExitPointX, allCalculationresults[0].LocalPipingExitPointX.Value, cTolerance); - Assert.AreEqual(expectedPl3HeadAdjusted, allCalculationresults[0].Pl3HeadAdjusted.Value, cTolerance); - Assert.AreEqual(expectedPl4HeadAdjusted, allCalculationresults[0].Pl4HeadAdjusted.Value, cTolerance); - Assert.AreEqual(expectedCCreep, allCalculationresults[0].Wti2017CCreep, cTolerance); - Assert.AreEqual(expectedEffectiveStress, allCalculationresults[0].Wti2017EffectiveStress, cTolerance); - Assert.AreEqual(expectedBackwardErosionDeltaPhiReduced, allCalculationresults[0].Wti2017BackwardErosionDeltaPhiReduced, cTolerance); - Assert.AreEqual(expectedBackwardErosionDeltaPhiC, allCalculationresults[0].Wti2017BackwardErosionDeltaPhiC, cTolerance); - Assert.AreEqual(expectedUpliftSafetyFactor, allCalculationresults[0].Wti2017UpliftSafetyFactor, cTolerance); - Assert.AreEqual(expectedUpliftHcritical, allCalculationresults[0].Wti2017UpliftHcritical, cTolerance); - Assert.AreEqual(expectedUpliftDeltaPhiC, allCalculationresults[0].Wti2017UpliftDeltaPhiC, cTolerance); - Assert.AreEqual(expectedHeaveSafetyFactor, allCalculationresults[0].Wti2017HeaveSafetyFactor, cTolerance); - Assert.AreEqual(expectedHeaveHcritical, allCalculationresults[0].Wti2017HeaveHcritical, cTolerance); - Assert.AreEqual(expectedGradient, allCalculationresults[0].Wti2017Gradient, cTolerance); - Assert.AreEqual(expectedSafetyFactorOverall, allCalculationresults[0].Wti2017SafetyFactorOverall, cTolerance); - Assert.AreEqual(expectedHcriticalOverall, allCalculationresults[0].Wti2017HcriticalOverall, cTolerance); + Assert.That(allCalculationresults[0].Wti2017BackwardErosionSafetyFactor.Value, Is.EqualTo(expectedPipingFactor).Within(cTolerance)); + Assert.That(allCalculationresults[0].Wti2017BackwardErosionHcritical.Value, Is.EqualTo(expectedHCritical).Within(cTolerance)); + Assert.That(allCalculationresults[0].IsUplift.Value, Is.True); + Assert.That(allCalculationresults[0].LocalPipingExitPointX.Value, Is.EqualTo(expectedLocalPipingExitPointX).Within(cTolerance)); + Assert.That(allCalculationresults[0].Pl3HeadAdjusted.Value, Is.EqualTo(expectedPl3HeadAdjusted).Within(cTolerance)); + Assert.That(allCalculationresults[0].Pl4HeadAdjusted.Value, Is.EqualTo(expectedPl4HeadAdjusted).Within(cTolerance)); + Assert.That(allCalculationresults[0].Wti2017CCreep, Is.EqualTo(expectedCCreep).Within(cTolerance)); + Assert.That(allCalculationresults[0].Wti2017EffectiveStress, Is.EqualTo(expectedEffectiveStress).Within(cTolerance)); + Assert.That(allCalculationresults[0].Wti2017BackwardErosionDeltaPhiReduced, Is.EqualTo(expectedBackwardErosionDeltaPhiReduced).Within(cTolerance)); + Assert.That(allCalculationresults[0].Wti2017BackwardErosionDeltaPhiC, Is.EqualTo(expectedBackwardErosionDeltaPhiC).Within(cTolerance)); + Assert.That(allCalculationresults[0].Wti2017UpliftSafetyFactor, Is.EqualTo(expectedUpliftSafetyFactor).Within(cTolerance)); + Assert.That(allCalculationresults[0].Wti2017UpliftHcritical, Is.EqualTo(expectedUpliftHcritical).Within(cTolerance)); + Assert.That(allCalculationresults[0].Wti2017UpliftDeltaPhiC, Is.EqualTo(expectedUpliftDeltaPhiC).Within(cTolerance)); + Assert.That(allCalculationresults[0].Wti2017HeaveSafetyFactor, Is.EqualTo(expectedHeaveSafetyFactor).Within(cTolerance)); + Assert.That(allCalculationresults[0].Wti2017HeaveHcritical, Is.EqualTo(expectedHeaveHcritical).Within(cTolerance)); + Assert.That(allCalculationresults[0].Wti2017Gradient, Is.EqualTo(expectedGradient).Within(cTolerance)); + Assert.That(allCalculationresults[0].Wti2017SafetyFactorOverall, Is.EqualTo(expectedSafetyFactorOverall).Within(cTolerance)); + Assert.That(allCalculationresults[0].Wti2017HcriticalOverall, Is.EqualTo(expectedHcriticalOverall).Within(cTolerance)); } /// @@ -277,10 +277,10 @@ // Wti2017 is not supported for now allCalculationresults.Clear(); allCalculationresults = ComputeProject(projectFilename, PipingModelType.Wti2017, distanceToEntryPoint); - Assert.AreEqual(expectedWtiPipingFactor, allCalculationresults[0].Wti2017BackwardErosionSafetyFactor.Value, cTolerance); - Assert.AreEqual(expectedSeepageLength, allCalculationresults[0].SeepageLength.Value, cTolerance); - Assert.AreEqual(expectedHc, allCalculationresults[0].HCritical.Value, cTolerance); - Assert.AreEqual(expectedCCreep, allCalculationresults[0].Wti2017CCreep, cTolerance); + Assert.That(allCalculationresults[0].Wti2017BackwardErosionSafetyFactor.Value, Is.EqualTo(expectedWtiPipingFactor).Within(cTolerance)); + Assert.That(allCalculationresults[0].SeepageLength.Value, Is.EqualTo(expectedSeepageLength).Within(cTolerance)); + Assert.That(allCalculationresults[0].HCritical.Value, Is.EqualTo(expectedHc).Within(cTolerance)); + Assert.That(allCalculationresults[0].Wti2017CCreep, Is.EqualTo(expectedCCreep).Within(cTolerance)); } } } Index: DamClients/DamUI/trunk/src/Dam/Tests/CsvImporterTestsNew.cs =================================================================== diff -u -r3825 -r3826 --- DamClients/DamUI/trunk/src/Dam/Tests/CsvImporterTestsNew.cs (.../CsvImporterTestsNew.cs) (revision 3825) +++ DamClients/DamUI/trunk/src/Dam/Tests/CsvImporterTestsNew.cs (.../CsvImporterTestsNew.cs) (revision 3826) @@ -738,68 +738,68 @@ Assert.That(locationRecords[1].SlopeDampingPiezometricHeightPolderSide, Is.EqualTo(0.2).Within(tolerance)); Assert.That(locationRecords[0].StabilityDesignMethod, Is.EqualTo(StabilityDesignMethod.OptimizedSlopeAndShoulderAdaption)); Assert.That(locationRecords[1].StabilityDesignMethod, Is.EqualTo(StabilityDesignMethod.SlopeAdaptionBeforeShoulderAdaption)); - Assert.AreEqual(3.0, locationRecords[0].SlopeAdaptionStartCotangent, tolerance); - Assert.AreEqual(6.0, locationRecords[0].SlopeAdaptionEndCotangent, tolerance); - Assert.AreEqual(0.5, locationRecords[0].SlopeAdaptionStepCotangent, tolerance); - Assert.AreEqual(4.5, locationRecords[1].SlopeAdaptionStartCotangent, tolerance); - Assert.AreEqual(6.5, locationRecords[1].SlopeAdaptionEndCotangent, tolerance); - Assert.AreEqual(0.25, locationRecords[1].SlopeAdaptionStepCotangent, tolerance); - Assert.AreEqual(true, locationRecords[0].UseNewDikeTopWidth); - Assert.AreEqual(1.8, locationRecords[0].NewDikeTopWidth, tolerance); - Assert.AreEqual(false, locationRecords[1].UseNewDikeTopWidth); - Assert.AreEqual(0.8, locationRecords[1].NewDikeTopWidth, tolerance); - Assert.AreEqual(true, locationRecords[0].UseNewDikeSlopeInside); - Assert.AreEqual(1.9, locationRecords[0].NewDikeSlopeInside, tolerance); - Assert.AreEqual(false, locationRecords[1].UseNewDikeSlopeInside); - Assert.AreEqual(0.9, locationRecords[1].NewDikeSlopeInside, tolerance); - Assert.AreEqual(true, locationRecords[0].UseNewDikeSlopeOutside); - Assert.AreEqual(2.9, locationRecords[0].NewDikeSlopeOutside, tolerance); - Assert.AreEqual(false, locationRecords[1].UseNewDikeSlopeOutside); - Assert.AreEqual(1.9, locationRecords[1].NewDikeSlopeOutside, tolerance); - Assert.AreEqual(true, locationRecords[0].UseNewShoulderTopSlope); - Assert.AreEqual(2.8, locationRecords[0].NewShoulderTopSlope, tolerance); - Assert.AreEqual(false, locationRecords[1].UseNewShoulderTopSlope); - Assert.AreEqual(1.8, locationRecords[1].NewShoulderTopSlope, tolerance); - Assert.AreEqual(true, locationRecords[0].UseNewShoulderBaseSlope); - Assert.AreEqual(2.7, locationRecords[0].NewShoulderBaseSlope, tolerance); - Assert.AreEqual(false, locationRecords[1].UseNewShoulderBaseSlope); - Assert.AreEqual(1.7, locationRecords[1].NewShoulderBaseSlope, tolerance); - Assert.AreEqual(true, locationRecords[0].UseNewMaxHeightShoulderAsFraction); - Assert.AreEqual(0.6, locationRecords[0].NewMaxHeightShoulderAsFraction, tolerance); - Assert.AreEqual(false, locationRecords[1].UseNewMaxHeightShoulderAsFraction); - Assert.AreEqual(0.7, locationRecords[1].NewMaxHeightShoulderAsFraction, tolerance); - Assert.AreEqual(true, locationRecords[0].UseNewMinDistanceDikeToeStartDitch); - Assert.AreEqual(2.6, locationRecords[0].NewMinDistanceDikeToeStartDitch, tolerance); - Assert.AreEqual(false, locationRecords[1].UseNewMinDistanceDikeToeStartDitch); - Assert.AreEqual(1.6, locationRecords[1].NewMinDistanceDikeToeStartDitch, tolerance); - Assert.AreEqual(true, locationRecords[0].UseNewDitchDefinition); - Assert.AreEqual(1.1, locationRecords[0].NewWidthDitchBottom, tolerance); - Assert.AreEqual(1.2, locationRecords[0].NewSlopeAngleDitch, tolerance); - Assert.AreEqual(1.3, locationRecords[0].NewDepthDitch, tolerance); - Assert.AreEqual(false, locationRecords[1].UseNewDitchDefinition); - Assert.AreEqual(1.4, locationRecords[1].NewWidthDitchBottom, tolerance); - Assert.AreEqual(1.5, locationRecords[1].NewSlopeAngleDitch, tolerance); - Assert.AreEqual(1.6, locationRecords[1].NewDepthDitch, tolerance); - Assert.AreEqual(MStabZonesType.NoZones, locationRecords[0].StabilityZoneType); - Assert.AreEqual(MStabZonesType.ForbiddenZone, locationRecords[1].StabilityZoneType); - Assert.AreEqual(0.5, locationRecords[0].ForbiddenZoneFactor, tolerance); - Assert.AreEqual(0.9, locationRecords[1].ForbiddenZoneFactor, tolerance); - Assert.AreEqual(1.0, locationRecords[0].PlLineOffsetBelowDikeCrestMiddle, tolerance); - Assert.AreEqual(1.1, locationRecords[1].PlLineOffsetBelowDikeCrestMiddle, tolerance); - Assert.AreEqual(null, locationRecords[0].UsePlLineOffsetBelowDikeCrestMiddle); - Assert.AreEqual(null, locationRecords[1].UsePlLineOffsetBelowDikeCrestMiddle); - Assert.AreEqual(0.1, locationRecords[0].PlLineOffsetFactorBelowShoulderCrest, tolerance); - Assert.AreEqual(0.11, locationRecords[1].PlLineOffsetFactorBelowShoulderCrest, tolerance); - Assert.AreEqual(null, locationRecords[0].UsePlLineOffsetFactorBelowShoulderCrest); - Assert.AreEqual(null, locationRecords[1].UsePlLineOffsetFactorBelowShoulderCrest); - Assert.AreEqual(IntrusionVerticalWaterPressureType.Standard, locationRecords[0].IntrusionVerticalWaterPressure); - Assert.AreEqual(IntrusionVerticalWaterPressureType.SemiTimeDependent, locationRecords[1].IntrusionVerticalWaterPressure); - Assert.AreEqual(3.5, locationRecords[0].DikeTableHeight, tolerance); - Assert.AreEqual(3.5, locationRecords[1].DikeTableHeight, tolerance); - Assert.AreEqual(1.2, locationRecords[0].RiverLevel, tolerance); - Assert.AreEqual(2.2, locationRecords[1].RiverLevel, tolerance); - Assert.AreEqual(1.3, locationRecords[0].RiverLevelLow, tolerance); - Assert.AreEqual(2.3, locationRecords[1].RiverLevelLow, tolerance); + Assert.That(locationRecords[0].SlopeAdaptionStartCotangent, Is.EqualTo(3.0).Within(tolerance)); + Assert.That(locationRecords[0].SlopeAdaptionEndCotangent, Is.EqualTo(6.0).Within(tolerance)); + Assert.That(locationRecords[0].SlopeAdaptionStepCotangent, Is.EqualTo(0.5).Within(tolerance)); + Assert.That(locationRecords[1].SlopeAdaptionStartCotangent, Is.EqualTo(4.5).Within(tolerance)); + Assert.That(locationRecords[1].SlopeAdaptionEndCotangent, Is.EqualTo(6.5).Within(tolerance)); + Assert.That(locationRecords[1].SlopeAdaptionStepCotangent, Is.EqualTo(0.25).Within(tolerance)); + Assert.That(locationRecords[0].UseNewDikeTopWidth, Is.True); + Assert.That(locationRecords[0].NewDikeTopWidth, Is.EqualTo(1.8).Within(tolerance)); + Assert.That(locationRecords[1].UseNewDikeTopWidth, Is.False); + Assert.That(locationRecords[1].NewDikeTopWidth, Is.EqualTo(0.8).Within(tolerance)); + Assert.That(locationRecords[0].UseNewDikeSlopeInside, Is.True); + Assert.That(locationRecords[0].NewDikeSlopeInside, Is.EqualTo(1.9).Within(tolerance)); + Assert.That(locationRecords[1].UseNewDikeSlopeInside, Is.False); + Assert.That(locationRecords[1].NewDikeSlopeInside, Is.EqualTo(0.9).Within(tolerance)); + Assert.That(locationRecords[0].UseNewDikeSlopeOutside, Is.True); + Assert.That(locationRecords[0].NewDikeSlopeOutside, Is.EqualTo(2.9).Within(tolerance)); + Assert.That(locationRecords[1].UseNewDikeSlopeOutside, Is.False); + Assert.That(locationRecords[1].NewDikeSlopeOutside, Is.EqualTo(1.9).Within(tolerance)); + Assert.That(locationRecords[0].UseNewShoulderTopSlope, Is.True); + Assert.That(locationRecords[0].NewShoulderTopSlope, Is.EqualTo(2.8).Within(tolerance)); + Assert.That(locationRecords[1].UseNewShoulderTopSlope, Is.False); + Assert.That(locationRecords[1].NewShoulderTopSlope, Is.EqualTo(1.8).Within(tolerance)); + Assert.That(locationRecords[0].UseNewShoulderBaseSlope, Is.True); + Assert.That(locationRecords[0].NewShoulderBaseSlope, Is.EqualTo(2.7).Within(tolerance)); + Assert.That(locationRecords[1].UseNewShoulderBaseSlope, Is.False); + Assert.That(locationRecords[1].NewShoulderBaseSlope, Is.EqualTo(1.7).Within(tolerance)); + Assert.That(locationRecords[0].UseNewMaxHeightShoulderAsFraction, Is.True); + Assert.That(locationRecords[0].NewMaxHeightShoulderAsFraction, Is.EqualTo(0.6).Within(tolerance)); + Assert.That(locationRecords[1].UseNewMaxHeightShoulderAsFraction, Is.False); + Assert.That(locationRecords[1].NewMaxHeightShoulderAsFraction, Is.EqualTo(0.7).Within(tolerance)); + Assert.That(locationRecords[0].UseNewMinDistanceDikeToeStartDitch, Is.True); + Assert.That(locationRecords[0].NewMinDistanceDikeToeStartDitch, Is.EqualTo(2.6).Within(tolerance)); + Assert.That(locationRecords[1].UseNewMinDistanceDikeToeStartDitch, Is.False); + Assert.That(locationRecords[1].NewMinDistanceDikeToeStartDitch, Is.EqualTo(1.6).Within(tolerance)); + Assert.That(locationRecords[0].UseNewDitchDefinition, Is.True); + Assert.That(locationRecords[0].NewWidthDitchBottom, Is.EqualTo(1.1).Within(tolerance)); + Assert.That(locationRecords[0].NewSlopeAngleDitch, Is.EqualTo(1.2).Within(tolerance)); + Assert.That(locationRecords[0].NewDepthDitch, Is.EqualTo(1.3).Within(tolerance)); + Assert.That(locationRecords[1].UseNewDitchDefinition, Is.False); + Assert.That(locationRecords[1].NewWidthDitchBottom, Is.EqualTo(1.4).Within(tolerance)); + Assert.That(locationRecords[1].NewSlopeAngleDitch, Is.EqualTo(1.5).Within(tolerance)); + Assert.That(locationRecords[1].NewDepthDitch, Is.EqualTo(1.6).Within(tolerance)); + Assert.That(locationRecords[0].StabilityZoneType, Is.EqualTo(MStabZonesType.NoZones)); + Assert.That(locationRecords[1].StabilityZoneType, Is.EqualTo(MStabZonesType.ForbiddenZone)); + Assert.That(locationRecords[0].ForbiddenZoneFactor, Is.EqualTo(0.5).Within(tolerance)); + Assert.That(locationRecords[1].ForbiddenZoneFactor, Is.EqualTo(0.9).Within(tolerance)); + Assert.That(locationRecords[0].PlLineOffsetBelowDikeCrestMiddle, Is.EqualTo(1.0).Within(tolerance)); + Assert.That(locationRecords[1].PlLineOffsetBelowDikeCrestMiddle, Is.EqualTo(1.0).Within(tolerance)); + Assert.That(locationRecords[0].UsePlLineOffsetBelowDikeCrestMiddle, Is.Null); + Assert.That(locationRecords[1].UsePlLineOffsetBelowDikeCrestMiddle, Is.Null); + Assert.That(locationRecords[0].PlLineOffsetFactorBelowShoulderCrest, Is.EqualTo(0.1).Within(tolerance)); + Assert.That(locationRecords[1].PlLineOffsetFactorBelowShoulderCrest, Is.EqualTo(0.11).Within(tolerance)); + Assert.That(locationRecords[0].UsePlLineOffsetFactorBelowShoulderCrest, Is.Null); + Assert.That(locationRecords[1].UsePlLineOffsetFactorBelowShoulderCrest, Is.Null); + Assert.That(locationRecords[0].IntrusionVerticalWaterPressure, Is.EqualTo(IntrusionVerticalWaterPressureType.Standard)); + Assert.That(locationRecords[1].IntrusionVerticalWaterPressure, Is.EqualTo(IntrusionVerticalWaterPressureType.SemiTimeDependent)); + Assert.That(locationRecords[0].DikeTableHeight, Is.EqualTo(3.5).Within(tolerance)); + Assert.That(locationRecords[1].DikeTableHeight, Is.EqualTo(3.5).Within(tolerance)); + Assert.That(locationRecords[0].RiverLevel, Is.EqualTo(1.2).Within(tolerance)); + Assert.That(locationRecords[1].RiverLevel, Is.EqualTo(2.2).Within(tolerance)); + Assert.That(locationRecords[0].RiverLevelLow, Is.EqualTo(1.3).Within(tolerance)); + Assert.That(locationRecords[1].RiverLevelLow, Is.EqualTo(2.3).Within(tolerance)); } [Test] Index: DamClients/DamUI/trunk/src/Dam/Tests/FailureMechanismTests.cs =================================================================== diff -u -r3822 -r3826 --- DamClients/DamUI/trunk/src/Dam/Tests/FailureMechanismTests.cs (.../FailureMechanismTests.cs) (revision 3822) +++ DamClients/DamUI/trunk/src/Dam/Tests/FailureMechanismTests.cs (.../FailureMechanismTests.cs) (revision 3826) @@ -90,28 +90,28 @@ Assert.AreEqual("DWP_1.sti", allCalculationresults[0].ProfileName); Assert.AreEqual(100, allCalculationresults[0].ProfileProbability); Assert.AreEqual(MStabModelType.Bishop, allCalculationresults[0].StabilityModel); - Assert.AreEqual(1.545, allCalculationresults[0].SafetyFactor, diff); - Assert.AreEqual(null, allCalculationresults[0].ShoulderHeight); - Assert.AreEqual(null, allCalculationresults[0].ToeAtPolderX); - Assert.AreEqual(null, allCalculationresults[0].ToeAtPolderZ); + Assert.That(allCalculationresults[0].SafetyFactor, Is.EqualTo(1.545).Within(diff)); + Assert.That(allCalculationresults[0].ShoulderHeight, Is.Null); + Assert.That(allCalculationresults[0].ToeAtPolderX, Is.Null); + Assert.That(allCalculationresults[0].ToeAtPolderZ, Is.Null); Assert.AreEqual(1.170, allCalculationresults[0].RequiredSafetyFactor); Assert.AreEqual(4.4, allCalculationresults[0].RiverLevel); Assert.AreEqual(0.63, allCalculationresults[0].RiverLevelLow); Assert.AreEqual(4.900, allCalculationresults[0].DikeTableHeight); Assert.AreEqual(0.000, allCalculationresults[0].SlopeDampingPiezometricHeightPolderSide); Assert.AreEqual(36.150, allCalculationresults[0].DikeLength); - Assert.AreEqual(1.837, allCalculationresults[0].Pl3MinUplift, diff); + Assert.That(allCalculationresults[0].Pl3MinUplift, Is.EqualTo(1.837).Within(diff)); Assert.AreEqual(1.60, allCalculationresults[0].Pl3HeadAdjusted); - Assert.AreEqual(106, allCalculationresults[0].Pl3LocalLocationXMinUplift, diff); - Assert.AreEqual(114.42, allCalculationresults[0].Pl3LocationXMinUplift, diff); + Assert.That(allCalculationresults[0].Pl3LocalLocationXMinUplift, Is.EqualTo(106).Within(diff)); + Assert.That(allCalculationresults[0].Pl3LocationXMinUplift, Is.EqualTo(114.42).Within(diff)); Assert.AreEqual(0.000, allCalculationresults[0].Pl3LocationYMinUplift); Assert.AreEqual(0.000, allCalculationresults[0].Pl4MinUplift); Assert.AreEqual(0.000, allCalculationresults[0].Pl4HeadAdjusted); Assert.AreEqual(0.000, allCalculationresults[0].Pl4LocalLocationXMinUplift); Assert.AreEqual(8.420, allCalculationresults[0].Pl4LocationXMinUplift); Assert.AreEqual(0.000, allCalculationresults[0].Pl4LocationYMinUplift); - Assert.AreEqual(16.190, allCalculationresults[0].LocalPipingEntryPointX, diff); - Assert.AreEqual(24.610, allCalculationresults[0].PipingEntryPointX, diff); + Assert.That(allCalculationresults[0].LocalPipingEntryPointX, Is.EqualTo(16.190).Within(diff)); + Assert.That(allCalculationresults[0].PipingEntryPointX, Is.EqualTo(24.610).Within(diff)); Assert.AreEqual(0.000, allCalculationresults[0].PipingEntryPointY); Assert.AreEqual(null, allCalculationresults[0].LocalPipingExitPointX); Assert.AreEqual(null, allCalculationresults[0].PipingExitPointX); @@ -148,16 +148,16 @@ Assert.AreEqual("Segment_1_1D2", allCalculationresults[1].ProfileName); Assert.AreEqual(2.43, allCalculationresults[1].ProfileProbability); Assert.AreEqual(MStabModelType.Bishop, allCalculationresults[1].StabilityModel); - Assert.AreEqual(1.079, allCalculationresults[1].SafetyFactor, diff); + Assert.That(allCalculationresults[1].SafetyFactor, Is.EqualTo(1.079).Within(diff)); Assert.AreEqual(null, allCalculationresults[1].ShoulderHeight); Assert.AreEqual(null, allCalculationresults[1].ToeAtPolderX); Assert.AreEqual(null, allCalculationresults[1].ToeAtPolderZ); Assert.AreEqual(0.900, allCalculationresults[1].RequiredSafetyFactor); Assert.AreEqual(-2.090, allCalculationresults[1].RiverLevel); Assert.AreEqual(-2.520, allCalculationresults[1].RiverLevelLow); - Assert.AreEqual(-2.000, allCalculationresults[1].DikeTableHeight, diff); + Assert.That(allCalculationresults[1].DikeTableHeight, Is.EqualTo(-2.000).Within(diff)); Assert.AreEqual(0.000, allCalculationresults[1].SlopeDampingPiezometricHeightPolderSide); - Assert.AreEqual(14.12, allCalculationresults[1].DikeLength, diff * 10); + Assert.That(allCalculationresults[1].DikeLength, Is.EqualTo(14.12).Within(diff * 10)); // * PL3 Min uplift = null Assert.AreEqual(null, allCalculationresults[1].Pl3MinUplift); @@ -181,9 +181,9 @@ Assert.AreEqual(null, allCalculationresults[1].Pl4LocationYMinUplift); - Assert.AreEqual(9.798, allCalculationresults[1].LocalPipingEntryPointX, diff); - Assert.AreEqual(88216.844, allCalculationresults[1].PipingEntryPointX, diff); - Assert.AreEqual(448870.287, allCalculationresults[1].PipingEntryPointY, diff); + Assert.That(allCalculationresults[1].LocalPipingEntryPointX, Is.EqualTo(9.798).Within(diff)); + Assert.That(allCalculationresults[1].PipingEntryPointX, Is.EqualTo(88216.844).Within(diff)); + Assert.That(allCalculationresults[1].PipingEntryPointY, Is.EqualTo(448870.287).Within(diff)); Assert.AreEqual(null, allCalculationresults[1].LocalPipingExitPointX); Assert.AreEqual(null, allCalculationresults[1].PipingExitPointX); Assert.AreEqual(null, allCalculationresults[1].PipingExitPointY); Index: DamClients/DamUI/trunk/src/Dam/Tests/IO/CombineImportedDataTest.cs =================================================================== diff -u -r3822 -r3826 --- DamClients/DamUI/trunk/src/Dam/Tests/IO/CombineImportedDataTest.cs (.../CombineImportedDataTest.cs) (revision 3822) +++ DamClients/DamUI/trunk/src/Dam/Tests/IO/CombineImportedDataTest.cs (.../CombineImportedDataTest.cs) (revision 3826) @@ -221,7 +221,7 @@ Assert.AreEqual("klei2", location.ShoulderEmbankmentMaterial); Assert.AreEqual(1.3, location.PenetrationLength, tolerance); Assert.AreEqual(10, location.TrafficLoad, tolerance); - Assert.AreEqual(22.44, location.TL_DegreeOfConsolidation, tolerance); + Assert.That(location.TL_DegreeOfConsolidation, Is.EqualTo(22.44).Within(tolerance)); Assert.AreEqual(1.5, location.MinimalCircleDepth, tolerance); Assert.AreEqual(0.3, location.DampingFactorPL3, tolerance); Assert.AreEqual(0.4, location.DampingFactorPL4, tolerance); @@ -259,9 +259,7 @@ { var surfaceLine = CreateValidSurfaceLine(); var combineImportedData = new CombineImportedData(); - CharacteristicPointType point1; - CharacteristicPointType point2; - var doNotCoincide = combineImportedData.CheckCharacteristicPointsForCoincidingLocations(surfaceLine, out point1, out point2); + var doNotCoincide = combineImportedData.CheckCharacteristicPointsForCoincidingLocations(surfaceLine, out _, out _); Assert.IsTrue(doNotCoincide); } @@ -283,9 +281,7 @@ { var surfaceLine = CreateValidSurfaceLineTrafficLoad(); var combineImportedData = new CombineImportedData(); - CharacteristicPointType point1; - CharacteristicPointType point2; - var doNotCoincide = combineImportedData.CheckCharacteristicPointsForCoincidingLocations(surfaceLine, out point1, out point2); + var doNotCoincide = combineImportedData.CheckCharacteristicPointsForCoincidingLocations(surfaceLine, out _, out _); Assert.IsTrue(doNotCoincide); }