Index: DamEngine/trunk/src/Deltares.DamEngine.Interface.Tests/FillXmlOutputFromDamTests.cs
===================================================================
diff -u -r4540 -r4624
--- DamEngine/trunk/src/Deltares.DamEngine.Interface.Tests/FillXmlOutputFromDamTests.cs	(.../FillXmlOutputFromDamTests.cs)	(revision 4540)
+++ DamEngine/trunk/src/Deltares.DamEngine.Interface.Tests/FillXmlOutputFromDamTests.cs	(.../FillXmlOutputFromDamTests.cs)	(revision 4624)
@@ -89,7 +89,7 @@
         // Assert
         Io.XmlOutput.DesignResult[] calculationResults = output.Results.CalculationResults;
         int expectedNrOfCalculationResults = project.DesignCalculations.Count;
-        Assert.AreEqual(expectedNrOfCalculationResults, calculationResults.Length);
+        Assert.That(calculationResults.Length, Is.EqualTo(expectedNrOfCalculationResults));
 
         for (var i = 0; i < expectedNrOfCalculationResults; i++)
         {
@@ -453,23 +453,23 @@
     private static void AssertStabilityDesignResults(StabilityDesignResults expected,
                                                      DesignResultStabilityDesignResults actual)
     {
-        Assert.AreEqual(expected.ResultMessage, actual.ResultMessage);
+        Assert.That(actual.ResultMessage, Is.EqualTo(expected.ResultMessage));
         AssertUpliftSituation(expected.UpliftSituation, actual.UpliftSituation);
 
         bool safetyFactorHasValue = expected.SafetyFactor.HasValue;
-        Assert.AreEqual(safetyFactorHasValue, actual.SafetyFactorSpecified);
-        Assert.AreEqual(safetyFactorHasValue ? expected.SafetyFactor : 0, actual.SafetyFactor);
+        Assert.That(actual.SafetyFactorSpecified, Is.EqualTo(safetyFactorHasValue));
+        Assert.That(actual.SafetyFactor, Is.EqualTo(safetyFactorHasValue ? expected.SafetyFactor : 0));
 
         bool numberOfIterationsHasValue = expected.NumberOfIterations.HasValue;
-        Assert.AreEqual(numberOfIterationsHasValue, actual.NumberOfIterationsSpecified);
-        Assert.AreEqual(numberOfIterationsHasValue ? expected.NumberOfIterations : 0, actual.NumberOfIterations);
+        Assert.That(actual.NumberOfIterationsSpecified, Is.EqualTo(numberOfIterationsHasValue));
+        Assert.That(actual.NumberOfIterations, Is.EqualTo(numberOfIterationsHasValue ? expected.NumberOfIterations : 0));
 
         bool mStabModelTypeHasValue = expected.StabilityModelType.HasValue;
-        Assert.AreEqual(mStabModelTypeHasValue, actual.StabilityModelTypeSpecified);
+        Assert.That(actual.StabilityModelTypeSpecified, Is.EqualTo(mStabModelTypeHasValue));
         DesignResultStabilityDesignResultsStabilityModelType? expectedModelType = mStabModelTypeHasValue
                                                                                       ? Convert(expected.StabilityModelType)
                                                                                       : DesignResultStabilityDesignResultsStabilityModelType.Bishop;
-        Assert.AreEqual(expectedModelType, actual.StabilityModelType);
+        Assert.That(actual.StabilityModelType, Is.EqualTo(expectedModelType));
 
         AssertSurfaceLine(expected.RedesignedSurfaceLine, actual.RedesignedSurfaceLine);
     }
@@ -482,13 +482,13 @@
             return;
         }
 
-        Assert.AreEqual(expected.Value.IsUplift, actual.IsUplift);
-        Assert.AreEqual(expected.Value.Pl3MinUplift, actual.Pl3MinUplift);
-        Assert.AreEqual(expected.Value.Pl3HeadAdjusted, actual.Pl3HeadAdjusted);
-        Assert.AreEqual(expected.Value.Pl3LocationXMinUplift, actual.Pl3LocationXMinUplift);
-        Assert.AreEqual(expected.Value.Pl4MinUplift, actual.Pl4MinUplift);
-        Assert.AreEqual(expected.Value.Pl4HeadAdjusted, actual.Pl4HeadAdjusted);
-        Assert.AreEqual(expected.Value.Pl4LocationXMinUplift, actual.Pl4LocationXMinUplift);
+        Assert.That(actual.IsUplift, Is.EqualTo(expected.Value.IsUplift));
+        Assert.That(actual.Pl3MinUplift, Is.EqualTo(expected.Value.Pl3MinUplift));
+        Assert.That(actual.Pl3HeadAdjusted, Is.EqualTo(expected.Value.Pl3HeadAdjusted));
+        Assert.That(actual.Pl3LocationXMinUplift, Is.EqualTo(expected.Value.Pl3LocationXMinUplift));
+        Assert.That(actual.Pl4MinUplift, Is.EqualTo(expected.Value.Pl4MinUplift));
+        Assert.That(actual.Pl4HeadAdjusted, Is.EqualTo(expected.Value.Pl4HeadAdjusted));
+        Assert.That(actual.Pl4LocationXMinUplift, Is.EqualTo(expected.Value.Pl4LocationXMinUplift));
     }
 
     private static void AssertSurfaceLine(SurfaceLine2 expected, SurfaceLine actual)
@@ -499,10 +499,10 @@
             return;
         }
 
-        Assert.AreEqual(expected.Name, actual.Name);
+        Assert.That(actual.Name, Is.EqualTo(expected.Name));
 
         int expectedNrOfCharacteristicPoints = expected.CharacteristicPoints.Count;
-        Assert.AreEqual(expectedNrOfCharacteristicPoints, actual.Points.Length);
+        Assert.That(actual.Points.Length, Is.EqualTo(expectedNrOfCharacteristicPoints));
         for (var i = 0; i < expectedNrOfCharacteristicPoints; i++)
         {
             CharacteristicPoint expectedCharacteristicPoint = expected.CharacteristicPoints[i];
@@ -513,10 +513,10 @@
 
     private static void AssertCharacteristicPoint(CharacteristicPoint expected, SurfaceLinePoint actual)
     {
-        Assert.AreEqual(expected.X, actual.X);
-        Assert.AreEqual(expected.Z, actual.Z);
-        Assert.AreEqual(ConversionHelper.ConvertToInputPointType(expected.CharacteristicPointType),
-                        actual.PointType);
+        Assert.That(actual.X, Is.EqualTo(expected.X));
+        Assert.That(actual.Z, Is.EqualTo(expected.Z));
+        Assert.That(actual.PointType,
+                        Is.EqualTo(ConversionHelper.ConvertToInputPointType(expected.CharacteristicPointType)));
     }
 
     private void CompareDamProjectData(DamProjectData actual, DamProjectData expected)
@@ -538,6 +538,6 @@
             }
         }
 
-        Assert.AreEqual(fakeDiffCount, result.Differences.Count, "Differences found read/write Input object");
+        Assert.That(result.Differences.Count, Is.EqualTo(fakeDiffCount), "Differences found read/write Input object");
     }
 }
\ No newline at end of file