Index: DamEngine/trunk/src/Deltares.DamEngine.Interface.Tests/FillXmlOutputFromDamTests.cs
===================================================================
diff -u -r2405 -r2874
--- DamEngine/trunk/src/Deltares.DamEngine.Interface.Tests/FillXmlOutputFromDamTests.cs	(.../FillXmlOutputFromDamTests.cs)	(revision 2405)
+++ DamEngine/trunk/src/Deltares.DamEngine.Interface.Tests/FillXmlOutputFromDamTests.cs	(.../FillXmlOutputFromDamTests.cs)	(revision 2874)
@@ -65,6 +65,39 @@
             CompareDamProjectData(actualDamProjectData, expectedDamProjectData);
         }
 
+        [Test]
+        public void CreateOutput_DamProjectDataWithStabilityDesignResults_CreatesOutputWithStabilityResults()
+        {
+            // Setup
+            var random = new Random(21);
+            var project = new DamProjectData
+            {
+                CalculationMessages = new List<LogMessage>(),
+                DesignCalculations = new List<DesignResult>
+                {
+                    CreateStabilityDesignResults(random.Next()),
+                    CreateStabilityDesignResults(random.Next()),
+                    CreateStabilityDesignResults(random.Next()),
+                    CreateStabilityDesignResults(random.Next())
+                }
+            };
+
+            // Call
+            var output = FillXmlOutputFromDam.CreateOutput(project);
+
+            // Assert
+            var calculationResults = output.Results.CalculationResults;
+            int expectedNrOfCalculationResults = project.DesignCalculations.Count;
+            Assert.AreEqual(expectedNrOfCalculationResults, calculationResults.Length);
+
+            for (var i = 0; i < expectedNrOfCalculationResults; i++)
+            {
+                AssertStabilityDesignResults(project.DesignCalculations[i].StabilityDesignResults, 
+                    calculationResults[i].StabilityDesignResults);
+            }
+
+        }
+
         private DamProjectData CreateExampleDamProjectData()
         {
             const int designResultsCount = 3;
@@ -249,6 +282,106 @@
                 }
             }
         }
+
+        private static DesignResult CreateStabilityDesignResults(int seed)
+        {
+            var random = new Random(seed);
+
+            var supportedModelTypeValues = new[]
+            {
+                MStabModelType.Bishop,
+                MStabModelType.UpliftVanWti,
+                MStabModelType.UpliftVan,
+                MStabModelType.BishopUpliftVan
+            };
+            var stabilityDesignResults = new StabilityDesignResults
+            {
+                ResultMessage = "no problemo",
+                SafetyFactor = random.Next(0, 2) == 1 ? random.NextDouble() : (double?) null,
+                NumberOfIterations = random.Next(0, 2) == 1 ? random.Next() : (int?) null,
+                UpliftSituation = random.Next(0, 2) == 1 ? CreateUpliftSituation(seed) : (UpliftSituation?) null,
+                StabilityModelType = random.Next(0, 2) == 1 
+                    ? supportedModelTypeValues[random.Next(supportedModelTypeValues.Length - 1)]
+                    : (MStabModelType?) null
+            };
+            
+            return new DesignResult
+            {
+                StabilityDesignResults = stabilityDesignResults
+            };
+        }
+
+        private static UpliftSituation CreateUpliftSituation(int seed)
+        {
+            var random = new Random(seed);
+            return new UpliftSituation
+            {
+                IsUplift = true,
+                Pl3MinUplift = random.NextDouble(),
+                Pl3HeadAdjusted = random.NextDouble(),
+                Pl3LocationXMinUplift = random.NextDouble(),
+                Pl4MinUplift = random.NextDouble(),
+                Pl4HeadAdjusted = random.NextDouble(),
+                Pl4LocationXMinUplift = random.NextDouble()
+            };
+        }
+
+        private static DesignResultStabilityDesignResultsStabilityModelType? Convert(MStabModelType? stabilityModelType)
+        {
+            switch (stabilityModelType)
+            {
+                case MStabModelType.Bishop:
+                    return DesignResultStabilityDesignResultsStabilityModelType.Bishop;
+                case MStabModelType.UpliftVan:
+                    return DesignResultStabilityDesignResultsStabilityModelType.UpliftVan;
+                case MStabModelType.BishopUpliftVan:
+                    return DesignResultStabilityDesignResultsStabilityModelType.BishopUpliftVan;
+                case MStabModelType.UpliftVanWti:
+                    return DesignResultStabilityDesignResultsStabilityModelType.UpliftVanWti;
+            }
+
+            throw new NotSupportedException();
+        }
+
+        private static void AssertStabilityDesignResults(StabilityDesignResults expected, 
+            DesignResultStabilityDesignResults actual)
+        {
+            Assert.AreEqual(expected.ResultMessage, actual.ResultMessage);
+            AssertUpliftSituation(expected.UpliftSituation, actual.UpliftSituation);
+
+            bool safetyFactorHasValue = expected.SafetyFactor.HasValue;
+            Assert.AreEqual(safetyFactorHasValue, actual.SafetyFactorSpecified);
+            Assert.AreEqual(safetyFactorHasValue ? expected.SafetyFactor : 0, actual.SafetyFactor);
+
+            bool numberOfIterationsHasValue = expected.NumberOfIterations.HasValue;
+            Assert.AreEqual(numberOfIterationsHasValue, actual.NumberOfIterationsSpecified);
+            Assert.AreEqual(numberOfIterationsHasValue ? expected.NumberOfIterations : 0, actual.NumberOfIterations);
+
+            bool mStabModelTypeHasValue = expected.StabilityModelType.HasValue;
+            Assert.AreEqual(mStabModelTypeHasValue, actual.StabilityModelTypeSpecified);
+            var expectedModelType = mStabModelTypeHasValue 
+                ? Convert(expected.StabilityModelType) 
+                : DesignResultStabilityDesignResultsStabilityModelType.Bishop;
+            Assert.AreEqual(expectedModelType, actual.StabilityModelType);
+        }
+
+        private static void AssertUpliftSituation(UpliftSituation? expected, Io.XmlOutput.UpliftSituation actual)
+        {
+            if (!expected.HasValue)
+            {
+                Assert.IsNull(actual);
+                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);
+        }
+
         private void CompareDamProjectData(DamProjectData actual, DamProjectData expected)
         {
             var compare = new CompareLogic { Config = { MaxDifferences = 100 } };