Index: DamEngine/trunk/src/Deltares.DamEngine.IntegrationTests/IntegrationTests/MacroStabilityInwardsTests.cs
===================================================================
diff -u -r5307 -r5331
--- DamEngine/trunk/src/Deltares.DamEngine.IntegrationTests/IntegrationTests/MacroStabilityInwardsTests.cs	(.../MacroStabilityInwardsTests.cs)	(revision 5307)
+++ DamEngine/trunk/src/Deltares.DamEngine.IntegrationTests/IntegrationTests/MacroStabilityInwardsTests.cs	(.../MacroStabilityInwardsTests.cs)	(revision 5331)
@@ -217,7 +217,7 @@
         });
     }
 
-    [Test, Category(Categories.Slow), Ignore("This test does not succeed, only UpliftVan result in output.")]
+    [Test, Category(Categories.Slow)]
     [Category(Categories.WorkInProgress)]
     public void TestRunMacroStabilityTutorialDesignBishopUpliftVan_UpliftVanLowest()
     {
@@ -242,28 +242,43 @@
 
         // Bishop
         DesignResult result = output.Results.CalculationResults[0];
-        Assert.That(result.StabilityDesignResults.SafetyFactor, Is.EqualTo(1.309).Within(tolerance));
-        Assert.That(result.StabilityDesignResults.UpliftSituation, Is.Not.Null);
-        Assert.That(result.StabilityDesignResults.UpliftSituation.IsUplift, Is.True);
-        Assert.That(result.StabilityDesignResults.StabilityModelType, Is.EqualTo(DesignResultStabilityDesignResultsStabilityModelType.Bishop));
-        Assert.That(result.BaseFileName, Is.EqualTo("Loc(DWP_1)_Sce(1)_Pro(DWP_1_stix)"));
+        Assert.Multiple(() =>
+        {
+            Assert.That(result.StabilityDesignResults.SafetyFactor, Is.EqualTo(1.309).Within(tolerance));
+            Assert.That(result.StabilityDesignResults.UpliftSituation, Is.Not.Null);
+        });
+        Assert.Multiple(() =>
+        {
+            Assert.That(result.StabilityDesignResults.UpliftSituation.IsUplift, Is.True);
+            Assert.That(result.StabilityDesignResults.StabilityModelType, Is.EqualTo(DesignResultStabilityDesignResultsStabilityModelType.Bishop));
+            Assert.That(result.BaseFileName, Is.EqualTo("Loc(DWP_1)_Sce(1)_Pro(DWP_1_stix)"));
+        });
         // Uplift Van
         result = output.Results.CalculationResults[1];
-        Assert.That(result.StabilityDesignResults.SafetyFactor, Is.EqualTo(1.218).Within(tolerance));
-        Assert.That(result.StabilityDesignResults.UpliftSituation, Is.Not.Null);
-        Assert.That(result.StabilityDesignResults.StabilityModelType, Is.EqualTo(DesignResultStabilityDesignResultsStabilityModelType.UpliftVan));
-        Assert.That(result.BaseFileName, Is.EqualTo("Loc(DWP_1)_Sce(1)_Pro(DWP_1_stix)"));
+        Assert.Multiple(() =>
+        {
+            Assert.That(result.StabilityDesignResults.SafetyFactor, Is.EqualTo(1.218).Within(tolerance));
+            Assert.That(result.StabilityDesignResults.UpliftSituation, Is.Not.Null);
+            Assert.That(result.StabilityDesignResults.StabilityModelType, Is.EqualTo(DesignResultStabilityDesignResultsStabilityModelType.UpliftVan));
+            Assert.That(result.BaseFileName, Is.EqualTo("Loc(DWP_1)_Sce(1)_Pro(DWP_1_stix)"));
+        });
         // Worst of Bishop and Uplift Van 
         result = output.Results.CalculationResults[2];
-        Assert.That(result.StabilityDesignResults.SafetyFactor, Is.EqualTo(1.218).Within(tolerance));
-        Assert.That(result.StabilityDesignResults.UpliftSituation, Is.Not.Null);
-        Assert.That(result.StabilityDesignResults.StabilityModelType, Is.EqualTo(DesignResultStabilityDesignResultsStabilityModelType.BishopUpliftVan));
-        Assert.That(result.BaseFileName, Is.EqualTo("Loc(DWP_1)_Sce(1)_Pro(DWP_1_stix)"));
+        Assert.Multiple(() =>
+        {
+            Assert.That(result.StabilityDesignResults.SafetyFactor, Is.EqualTo(1.218).Within(tolerance));
+            Assert.That(result.StabilityDesignResults.UpliftSituation, Is.Not.Null);
+            Assert.That(result.StabilityDesignResults.StabilityModelType, Is.EqualTo(DesignResultStabilityDesignResultsStabilityModelType.BishopUpliftVan));
+            Assert.That(result.BaseFileName, Is.EqualTo("Loc(DWP_1)_Sce(1)_Pro(DWP_1_stix)"));
 
-        // Calculation Result
-        Assert.That(ConversionHelper.ConvertToCalculationResult(output.Results.CalculationResults[0].CalculationResult), Is.EqualTo(CalculationResult.Succeeded));
-        Assert.That(ConversionHelper.ConvertToCalculationResult(output.Results.CalculationResults[1].CalculationResult), Is.EqualTo(CalculationResult.Succeeded));
-        Assert.That(ConversionHelper.ConvertToCalculationResult(output.Results.CalculationResults[2].CalculationResult), Is.EqualTo(CalculationResult.Succeeded));
+        });
+        Assert.Multiple(() =>
+        {
+            // Calculation Result
+            Assert.That(ConversionHelper.ConvertToCalculationResult(output.Results.CalculationResults[0].CalculationResult), Is.EqualTo(CalculationResult.Succeeded));
+            Assert.That(ConversionHelper.ConvertToCalculationResult(output.Results.CalculationResults[1].CalculationResult), Is.EqualTo(CalculationResult.Succeeded));
+            Assert.That(ConversionHelper.ConvertToCalculationResult(output.Results.CalculationResults[2].CalculationResult), Is.EqualTo(CalculationResult.Succeeded));
+        });
     }
 
     [Test, Category(Categories.Slow), Ignore("Create test where Bishop is lowest. Not anymore for DWP_13")]
@@ -292,28 +307,42 @@
 
         // Bishop
         DesignResultStabilityDesignResults result = output.Results.CalculationResults[0].StabilityDesignResults;
-        Assert.That(result.SafetyFactor, Is.EqualTo(0.452).Within(tolerance));
-        Assert.That(result.UpliftSituation, Is.Not.Null);
-        Assert.That(result.UpliftSituation.IsUplift, Is.True);
-        Assert.That(result.StabilityModelType, Is.EqualTo(DesignResultStabilityDesignResultsStabilityModelType.Bishop));
+        Assert.Multiple(() =>
+        {
+            Assert.That(result.SafetyFactor, Is.EqualTo(0.452).Within(tolerance));
+            Assert.That(result.UpliftSituation, Is.Not.Null);
+        });
+        Assert.Multiple(() =>
+        {
+            Assert.That(result.UpliftSituation.IsUplift, Is.True);
+            Assert.That(result.StabilityModelType, Is.EqualTo(DesignResultStabilityDesignResultsStabilityModelType.Bishop));
+        });
         // Uplift Van
         result = output.Results.CalculationResults[1].StabilityDesignResults;
-        Assert.That(result.SafetyFactor, Is.EqualTo(0.574).Within(tolerance));
-        Assert.That(result.UpliftSituation, Is.Not.Null);
-        Assert.That(result.StabilityModelType, Is.EqualTo(DesignResultStabilityDesignResultsStabilityModelType.UpliftVan));
+        Assert.Multiple(() =>
+        {
+            Assert.That(result.SafetyFactor, Is.EqualTo(0.574).Within(tolerance));
+            Assert.That(result.UpliftSituation, Is.Not.Null);
+            Assert.That(result.StabilityModelType, Is.EqualTo(DesignResultStabilityDesignResultsStabilityModelType.UpliftVan));
+        });
         // Worst of Bishop and Uplift Van 
         result = output.Results.CalculationResults[2].StabilityDesignResults;
-        Assert.That(result.SafetyFactor, Is.EqualTo(0.452).Within(tolerance));
-        Assert.That(result.UpliftSituation, Is.Not.Null);
-        Assert.That(result.StabilityModelType, Is.EqualTo(DesignResultStabilityDesignResultsStabilityModelType.BishopUpliftVan));
-
-        // Calculation Result
-        Assert.That(ConversionHelper.ConvertToCalculationResult(output.Results.CalculationResults[0].CalculationResult), Is.EqualTo(CalculationResult.Succeeded));
-        Assert.That(ConversionHelper.ConvertToCalculationResult(output.Results.CalculationResults[1].CalculationResult), Is.EqualTo(CalculationResult.Succeeded));
-        Assert.That(ConversionHelper.ConvertToCalculationResult(output.Results.CalculationResults[2].CalculationResult), Is.EqualTo(CalculationResult.Succeeded));
+        Assert.Multiple(() =>
+        {
+            Assert.That(result.SafetyFactor, Is.EqualTo(0.452).Within(tolerance));
+            Assert.That(result.UpliftSituation, Is.Not.Null);
+            Assert.That(result.StabilityModelType, Is.EqualTo(DesignResultStabilityDesignResultsStabilityModelType.BishopUpliftVan));
+        });
+        Assert.Multiple(() =>
+        {
+            // Calculation Result
+            Assert.That(ConversionHelper.ConvertToCalculationResult(output.Results.CalculationResults[0].CalculationResult), Is.EqualTo(CalculationResult.Succeeded));
+            Assert.That(ConversionHelper.ConvertToCalculationResult(output.Results.CalculationResults[1].CalculationResult), Is.EqualTo(CalculationResult.Succeeded));
+            Assert.That(ConversionHelper.ConvertToCalculationResult(output.Results.CalculationResults[2].CalculationResult), Is.EqualTo(CalculationResult.Succeeded));
+        });
     }
 
-    [Test, Category(Categories.Slow), Ignore("This test does not succeed, only Bishop result in output.")]
+    [Test, Category(Categories.Slow)]
     [Category(Categories.WorkInProgress)]
     public void TestRunMacroStabilityTutorialDesignBishopUpliftVan_NoUplift()
     {
@@ -338,27 +367,41 @@
 
         // Bishop
         DesignResultStabilityDesignResults result = output.Results.CalculationResults[0].StabilityDesignResults;
-        Assert.That(result.SafetyFactorSpecified, Is.True);
-        Assert.That(result.SafetyFactor, Is.EqualTo(1.450).Within(tolerance));
-        Assert.That(result.UpliftSituation, Is.Not.Null);
-        Assert.That(result.UpliftSituation.IsUplift, Is.False);
-        Assert.That(result.StabilityModelType, Is.EqualTo(DesignResultStabilityDesignResultsStabilityModelType.Bishop));
+        Assert.Multiple(() =>
+        {
+            Assert.That(result.SafetyFactorSpecified, Is.True);
+            Assert.That(result.SafetyFactor, Is.EqualTo(1.450).Within(tolerance));
+            Assert.That(result.UpliftSituation, Is.Not.Null);
+        });
+        Assert.Multiple(() =>
+        {
+            Assert.That(result.UpliftSituation.IsUplift, Is.False);
+            Assert.That(result.StabilityModelType, Is.EqualTo(DesignResultStabilityDesignResultsStabilityModelType.Bishop));
+        });
         // Uplift Van
         result = output.Results.CalculationResults[1].StabilityDesignResults;
-        Assert.That(result.SafetyFactorSpecified, Is.False);
-        Assert.That(result.UpliftSituation, Is.Not.Null);
-        Assert.That(result.StabilityModelType, Is.EqualTo(DesignResultStabilityDesignResultsStabilityModelType.UpliftVan));
+        Assert.Multiple(() =>
+        {
+            Assert.That(result.SafetyFactorSpecified, Is.False);
+            Assert.That(result.UpliftSituation, Is.Not.Null);
+            Assert.That(result.StabilityModelType, Is.EqualTo(DesignResultStabilityDesignResultsStabilityModelType.UpliftVan));
+        });
         // Worst of Bishop and Uplift Van 
         result = output.Results.CalculationResults[2].StabilityDesignResults;
-        Assert.That(result.SafetyFactorSpecified, Is.True);
-        Assert.That(result.SafetyFactor, Is.EqualTo(1.450).Within(tolerance));
-        Assert.That(result.UpliftSituation, Is.Not.Null);
-        Assert.That(result.StabilityModelType, Is.EqualTo(DesignResultStabilityDesignResultsStabilityModelType.BishopUpliftVan));
-
-        // Calculation Result
-        Assert.That(ConversionHelper.ConvertToCalculationResult(output.Results.CalculationResults[0].CalculationResult), Is.EqualTo(CalculationResult.Succeeded));
-        Assert.That(ConversionHelper.ConvertToCalculationResult(output.Results.CalculationResults[1].CalculationResult), Is.EqualTo(CalculationResult.NoRun));
-        Assert.That(ConversionHelper.ConvertToCalculationResult(output.Results.CalculationResults[2].CalculationResult), Is.EqualTo(CalculationResult.Succeeded));
+        Assert.Multiple(() =>
+        {
+            Assert.That(result.SafetyFactorSpecified, Is.True);
+            Assert.That(result.SafetyFactor, Is.EqualTo(1.450).Within(tolerance));
+            Assert.That(result.UpliftSituation, Is.Not.Null);
+            Assert.That(result.StabilityModelType, Is.EqualTo(DesignResultStabilityDesignResultsStabilityModelType.BishopUpliftVan));
+        });
+        Assert.Multiple(() =>
+        {
+            // Calculation Result
+            Assert.That(ConversionHelper.ConvertToCalculationResult(output.Results.CalculationResults[0].CalculationResult), Is.EqualTo(CalculationResult.Succeeded));
+            Assert.That(ConversionHelper.ConvertToCalculationResult(output.Results.CalculationResults[1].CalculationResult), Is.EqualTo(CalculationResult.NoRun));
+            Assert.That(ConversionHelper.ConvertToCalculationResult(output.Results.CalculationResults[2].CalculationResult), Is.EqualTo(CalculationResult.Succeeded));
+        });
     }
 
     [Test, Category(Categories.Slow), Ignore("This test is not yet implemented, waits on stix implementation.")]
Index: DamEngine/trunk/src/Deltares.DamEngine.IntegrationTests/IntegrationTests/IssuesTests.cs
===================================================================
diff -u -r5270 -r5331
--- DamEngine/trunk/src/Deltares.DamEngine.IntegrationTests/IntegrationTests/IssuesTests.cs	(.../IssuesTests.cs)	(revision 5270)
+++ DamEngine/trunk/src/Deltares.DamEngine.IntegrationTests/IntegrationTests/IssuesTests.cs	(.../IssuesTests.cs)	(revision 5331)
@@ -66,7 +66,7 @@
         Assert.Multiple(() =>
         {
             Assert.That(errorCount, Is.EqualTo(0), "There should be no errors during the calculation.");
-            Assert.That(engineInterface.DamProjectData.DesignCalculations.Count, Is.EqualTo(1), "There should be one design calculation.");
+            Assert.That(engineInterface.DamProjectData.DesignCalculations, Has.Count.EqualTo(1), "There should be one design calculation.");
             Assert.That(engineInterface.DamProjectData.DesignCalculations[0].SafetyFactor, Is.EqualTo(1.435).Within(0.001), "The safety factor should be 1.435.");
         });
     }