Index: Riskeer/MacroStabilityInwards/src/Riskeer.MacroStabilityInwards.KernelWrapper/Kernels/UpliftVan/UpliftVanKernelWrapper.cs
===================================================================
diff -u -rfe0f11c19023237d7f3629c2206b4fe5eb5e121f -r734930d018da0d76aa02134be1b611c4f3d2e9ae
--- Riskeer/MacroStabilityInwards/src/Riskeer.MacroStabilityInwards.KernelWrapper/Kernels/UpliftVan/UpliftVanKernelWrapper.cs	(.../UpliftVanKernelWrapper.cs)	(revision fe0f11c19023237d7f3629c2206b4fe5eb5e121f)
+++ Riskeer/MacroStabilityInwards/src/Riskeer.MacroStabilityInwards.KernelWrapper/Kernels/UpliftVan/UpliftVanKernelWrapper.cs	(.../UpliftVanKernelWrapper.cs)	(revision 734930d018da0d76aa02134be1b611c4f3d2e9ae)
@@ -38,8 +38,22 @@
         /// <summary>
         /// Creates a new instance of <see cref="UpliftVanKernelWrapper"/>.
         /// </summary>
+        /// <param name="calculator">The <see cref="ICalculator"/> to use.</param>
+        /// <param name="validator">The <see cref="IValidator"/> to use.</param>
+        /// <exception cref="ArgumentNullException">Thrown when any parameter
+        /// is <c>null</c>.</exception>
         public UpliftVanKernelWrapper(ICalculator calculator, IValidator validator)
         {
+            if (calculator == null)
+            {
+                throw new ArgumentNullException(nameof(calculator));
+            }
+
+            if (validator == null)
+            {
+                throw new ArgumentNullException(nameof(validator));
+            }
+
             this.calculator = calculator;
             this.validator = validator;
 
Index: Riskeer/MacroStabilityInwards/test/Riskeer.MacroStabilityInwards.KernelWrapper.Test/Kernels/UpliftVan/UpliftVanKernelWrapperTest.cs
===================================================================
diff -u -rfe0f11c19023237d7f3629c2206b4fe5eb5e121f -r734930d018da0d76aa02134be1b611c4f3d2e9ae
--- Riskeer/MacroStabilityInwards/test/Riskeer.MacroStabilityInwards.KernelWrapper.Test/Kernels/UpliftVan/UpliftVanKernelWrapperTest.cs	(.../UpliftVanKernelWrapperTest.cs)	(revision fe0f11c19023237d7f3629c2206b4fe5eb5e121f)
+++ Riskeer/MacroStabilityInwards/test/Riskeer.MacroStabilityInwards.KernelWrapper.Test/Kernels/UpliftVan/UpliftVanKernelWrapperTest.cs	(.../UpliftVanKernelWrapperTest.cs)	(revision 734930d018da0d76aa02134be1b611c4f3d2e9ae)
@@ -21,512 +21,246 @@
 
 using System;
 using System.Collections.Generic;
-using System.Linq;
-using Core.Common.TestUtil;
-using Core.Common.Util.Reflection;
-using Deltares.MacroStability.CSharpWrapper.Input;
+using Deltares.MacroStability.CSharpWrapper;
 using Deltares.MacroStability.CSharpWrapper.Output;
 using NUnit.Framework;
+using Rhino.Mocks;
 using Riskeer.MacroStabilityInwards.KernelWrapper.Kernels.UpliftVan;
-using WtiStabilityWaternet = Deltares.MacroStability.CSharpWrapper.Waternet;
 
 namespace Riskeer.MacroStabilityInwards.KernelWrapper.Test.Kernels.UpliftVan
 {
     [TestFixture]
     public class UpliftVanKernelWrapperTest
     {
         [Test]
-        public void Constructor_ExpectedValues()
+        public void Constructor_CalculatorNull_ThrowsArgumentNullException()
         {
-            // Call
-            var kernel = new UpliftVanKernelWrapper();
-
-            // Assert
-            Assert.IsInstanceOf<IUpliftVanKernel>(kernel);
-            Assert.IsNaN(kernel.FactorOfStability);
-            Assert.IsNaN(kernel.ForbiddenZonesXEntryMin);
-            Assert.IsNaN(kernel.ForbiddenZonesXEntryMax);
-            Assert.IsNull(kernel.SlidingCurveResult);
-            Assert.IsNull(kernel.UpliftVanCalculationGridResult);
-            Assert.IsNull(kernel.CalculationMessages);
-
-            var input = TypeUtils.GetField<MacroStabilityInput>(kernel, "input");
-
-            AssertConstructorValues(input);
-        }
-
-        [Test]
-        public void Constructor_CompleteInput_InputCorrectlySetToWrappedKernel()
-        {
             // Setup
-            var random = new Random(21);
-            var soilModel = new List<Soil>();
-            var soilProfile2D = new SoilProfile2D();
-            var waternetDaily = new WtiStabilityWaternet();
-            var waternetExtreme = new WtiStabilityWaternet();
-            bool moveGrid = random.NextBoolean();
-            double maximumSliceWidth = random.NextDouble();
-            var slipPlaneUpliftVan = new SlipPlaneUpliftVan();
-            var surfaceLine = new SurfaceLine2();
-            var slipPlaneConstraints = new SlipPlaneConstraints();
-            bool gridAutomaticDetermined = random.NextBoolean();
-            bool tangentLinesAutomaticDetermined = random.NextBoolean();
-            var fixedSoilStresses = new[]
-            {
-                new FixedSoilStress()
-            };
-            var preConsolidationStresses = new[]
-            {
-                new PreConsolidationStress()
-            };
-            bool automaticForbiddenZones = random.NextBoolean();
+            var mocks = new MockRepository();
+            var validator = mocks.Stub<IValidator>();
+            mocks.ReplayAll();
 
             // Call
-            var kernel = new UpliftVanKernelWrapper();
-            kernel.SetSoils(soilModel);
-            kernel.SetSoilProfile(soilProfile2D);
-            kernel.SetMaximumSliceWidth(maximumSliceWidth);
-            kernel.SetUpliftVanCalculationGrid(slipPlaneUpliftVan);
-            kernel.SetSurfaceLine(surfaceLine);
-            kernel.SetMoveGrid(moveGrid);
-            kernel.SetGridAutomaticDetermined(gridAutomaticDetermined);
-            kernel.SetTangentLinesAutomaticDetermined(tangentLinesAutomaticDetermined);
-            kernel.SetSlipPlaneConstraints(slipPlaneConstraints);
-            kernel.SetWaternetDaily(waternetDaily);
-            kernel.SetWaternetExtreme(waternetExtreme);
-            kernel.SetFixedSoilStresses(fixedSoilStresses);
-            kernel.SetPreconsolidationStresses(preConsolidationStresses);
-            kernel.SetAutomaticForbiddenZones(automaticForbiddenZones);
+            void Call() => new UpliftVanKernelWrapper(null, validator);
 
             // Assert
-            var kernelModel = TypeUtils.GetField<KernelModel>(kernel, "kernelModel");
-
-            AssertStabilityOutputModel(kernelModel.StabilityOutputModel);
-            AssertPreProcessingModel(kernelModel.PreprocessingModel);
-
-            StabilityModel stabilityModel = kernelModel.StabilityModel;
-            CollectionAssert.AreEqual(soilModel, kernelModel.StabilityModel.Soils);
-            Assert.AreEqual(moveGrid, stabilityModel.MoveGrid);
-            Assert.AreEqual(maximumSliceWidth, stabilityModel.MaximumSliceWidth);
-            Assert.AreSame(slipPlaneUpliftVan, stabilityModel.SlipPlaneUpliftVan);
-            Assert.AreEqual(slipPlaneUpliftVan.SlipPlaneTangentLine.NumberOfRefinements, stabilityModel.NumberOfRefinementsTangentLines);
-            Assert.AreSame(surfaceLine, kernelModel.PreprocessingModel.LastStage.SurfaceLine);
-            Assert.AreSame(slipPlaneConstraints, stabilityModel.SlipPlaneConstraints);
-            Assert.AreEqual(gridAutomaticDetermined, kernelModel.PreprocessingModel.SearchAreaConditions.AutoSearchArea);
-            Assert.AreEqual(tangentLinesAutomaticDetermined, kernelModel.PreprocessingModel.SearchAreaConditions.AutoTangentLines);
-            Assert.AreEqual(automaticForbiddenZones, kernelModel.PreprocessingModel.SearchAreaConditions.AutomaticForbiddenZones);
-
-            AssertConstructorValues(stabilityModel, kernelModel);
-
-            AssertConstructionStages(stabilityModel.ConstructionStages, soilProfile2D, new[]
-            {
-                waternetDaily,
-                waternetExtreme
-            }, fixedSoilStresses, preConsolidationStresses);
-
-            AssertIrrelevantValues(stabilityModel);
+            var exception = Assert.Throws<ArgumentNullException>(Call);
+            Assert.AreEqual("calculator", exception.ParamName);
+            mocks.VerifyAll();
         }
 
         [Test]
-        public void Calculate_ExceptionInWrappedKernel_ThrowsUpliftVanKernelWrapperException()
+        public void Constructor_ValidatorNull_ThrowsArgumentNullException()
         {
             // Setup
-            var kernel = new UpliftVanKernelWrapper();
+            var mocks = new MockRepository();
+            var calculator = mocks.Stub<ICalculator>();
+            mocks.ReplayAll();
 
             // Call
-            void Call() => kernel.Calculate();
+            void Call() => new UpliftVanKernelWrapper(calculator, null);
 
             // Assert
-            var exception = Assert.Throws<UpliftVanKernelWrapperException>(Call);
-            Assert.IsNotNull(exception.InnerException);
-            Assert.AreEqual(exception.InnerException.Message, exception.Message);
+            var exception = Assert.Throws<ArgumentNullException>(Call);
+            Assert.AreEqual("validator", exception.ParamName);
+            mocks.VerifyAll();
         }
 
         [Test]
-        public void Calculate_ExceptionDuringCalculation_OutputPropertiesNotSet()
+        public void Constructor_ExpectedValues()
         {
             // Setup
-            var kernel = new UpliftVanKernelWrapper();
+            var mocks = new MockRepository();
+            var calculator = mocks.Stub<ICalculator>();
+            var validator = mocks.Stub<IValidator>();
+            mocks.ReplayAll();
 
             // Call
-            void Call() => kernel.Calculate();
+            var kernel = new UpliftVanKernelWrapper(calculator, validator);
 
             // Assert
-            Assert.Throws<UpliftVanKernelWrapperException>(Call);
+            Assert.IsInstanceOf<IUpliftVanKernel>(kernel);
             Assert.IsNaN(kernel.FactorOfStability);
-            Assert.IsNaN(kernel.ForbiddenZonesXEntryMax);
             Assert.IsNaN(kernel.ForbiddenZonesXEntryMin);
+            Assert.IsNaN(kernel.ForbiddenZonesXEntryMax);
             Assert.IsNull(kernel.SlidingCurveResult);
             Assert.IsNull(kernel.UpliftVanCalculationGridResult);
+            Assert.IsNull(kernel.CalculationMessages);
+            mocks.VerifyAll();
         }
 
         [Test]
-        public void Calculate_CompleteInput_ReturnsNoErrors()
+        public void Calculate_SuccessfulCalculation_OutputSet()
         {
             // Setup
-            UpliftVanKernelWrapper kernel = CreateValidKernel(new Soil
-            {
-                ShearStrengthModel = ShearStrengthModel.CPhi,
-                AbovePhreaticLevel = 15.0,
-                BelowPhreaticLevel = 15.0,
-                Cohesion = 10.0,
-                Dilatancy = 10.0,
-                FrictionAngle = 10.0
-            });
+            var calculatorOutput = new MacroStabilityOutput();
 
+            var mocks = new MockRepository();
+            var calculator = mocks.Stub<ICalculator>();
+            calculator.Stub(c => c.Calculate()).Return(calculatorOutput);
+            var validator = mocks.Stub<IValidator>();
+            mocks.ReplayAll();
+
+            var kernel = new UpliftVanKernelWrapper(calculator, validator);
+
             // Call
             kernel.Calculate();
 
             // Assert
-            LogMessage[] errorMessages = kernel.CalculationMessages.Where(m => m.MessageType == LogMessageType.Error ||
-                                                                               m.MessageType == LogMessageType.FatalError).ToArray();
-            Assert.AreEqual(0, errorMessages.Length);
+            Assert.AreEqual(calculatorOutput.StabilityOutput.SafetyFactor, kernel.FactorOfStability);
+            Assert.AreEqual(calculatorOutput.PreprocessingOutputBase.ForbiddenZone.XEntryMin, kernel.ForbiddenZonesXEntryMin);
+            Assert.AreEqual(calculatorOutput.PreprocessingOutputBase.ForbiddenZone.XEntryMax, kernel.ForbiddenZonesXEntryMax);
 
-            Assert.IsFalse(double.IsNaN(kernel.FactorOfStability));
-            Assert.IsFalse(double.IsNaN(kernel.ForbiddenZonesXEntryMin));
-            Assert.IsFalse(double.IsNaN(kernel.ForbiddenZonesXEntryMax));
-            Assert.IsNotNull(kernel.SlidingCurveResult);
-            Assert.IsNotNull(kernel.UpliftVanCalculationGridResult);
+            Assert.AreSame((DualSlidingCircleMinimumSafetyCurve) calculatorOutput.StabilityOutput.MinimumSafetyCurve, kernel.SlidingCurveResult);
+            Assert.AreSame(((UpliftVanPreprocessingOutput) calculatorOutput.PreprocessingOutputBase).UpliftVanCalculationGrid, kernel.UpliftVanCalculationGridResult);
+            mocks.VerifyAll();
         }
 
         [Test]
-        public void Validate_InputComplete_NoValidationMessages()
+        public void Calculate_CalculatorMessagesNull_CalculationMessagesEmpty()
         {
             // Setup
-            UpliftVanKernelWrapper kernel = CreateValidKernel(new Soil
-            {
-                ShearStrengthModel = ShearStrengthModel.CPhi,
-                AbovePhreaticLevel = 15.0,
-                BelowPhreaticLevel = 15.0,
-                Cohesion = 10.0,
-                Dilatancy = 10.0,
-                FrictionAngle = 10.0
-            });
+            var calculatorOutput = new MacroStabilityOutput();
 
+            var mocks = new MockRepository();
+            var calculator = mocks.Stub<ICalculator>();
+            calculator.Stub(c => c.Calculate()).Return(calculatorOutput);
+            var validator = mocks.Stub<IValidator>();
+            mocks.ReplayAll();
+
+            var kernel = new UpliftVanKernelWrapper(calculator, validator);
+
             // Call
-            IEnumerable<IValidationResult> validationMessages = kernel.Validate();
+            kernel.Calculate();
 
             // Assert
-            Assert.IsEmpty(validationMessages);
+            CollectionAssert.IsEmpty(kernel.CalculationMessages);
+            mocks.VerifyAll();
         }
 
         [Test]
-        public void Validate_InputNotComplete_ThrowsUpliftVanKernelWrapperException()
+        public void Calculate_CalculatorHasMessages_CalculationMessagesSet()
         {
             // Setup
-            UpliftVanKernelWrapper kernel = CreateInvalidKernel(null);
+            var calculatorOutput = new MacroStabilityOutput
+            {
+                StabilityOutput =
+                {
+                    Messages = new Message[0]
+                }
+            };
 
+            var mocks = new MockRepository();
+            var calculator = mocks.Stub<ICalculator>();
+            calculator.Stub(c => c.Calculate()).Return(calculatorOutput);
+            var validator = mocks.Stub<IValidator>();
+            mocks.ReplayAll();
+
+            var kernel = new UpliftVanKernelWrapper(calculator, validator);
+
             // Call
-            void Test() => kernel.Validate();
+            kernel.Calculate();
 
             // Assert
-            var exception = Assert.Throws<UpliftVanKernelWrapperException>(Test);
-            Assert.IsInstanceOf<NullReferenceException>(exception.InnerException);
-            Assert.AreEqual(exception.InnerException.Message, exception.Message);
+            Assert.AreSame(calculatorOutput.StabilityOutput.Messages, kernel.CalculationMessages);
+            mocks.VerifyAll();
         }
 
         [Test]
-        public void Validate_InvalidInput_GeneratesValidationMessages()
+        public void Calculate_ExceptionInWrappedKernel_ThrowsUpliftVanKernelWrapperException()
         {
             // Setup
-            UpliftVanKernelWrapper kernel = CreateInvalidKernel(new Soil());
+            var exceptionToThrow = new Exception();
 
+            var mocks = new MockRepository();
+            var calculator = mocks.Stub<ICalculator>();
+            calculator.Stub(c => c.Calculate()).Throw(exceptionToThrow);
+            var validator = mocks.Stub<IValidator>();
+            mocks.ReplayAll();
+
+            var kernel = new UpliftVanKernelWrapper(calculator, validator);
+
             // Call
-            IEnumerable<IValidationResult> validationMessages = kernel.Validate();
+            void Call() => kernel.Calculate();
 
             // Assert
-            Assert.AreEqual(11, validationMessages.Count());
+            var exception = Assert.Throws<UpliftVanKernelWrapperException>(Call);
+            Assert.AreSame(exceptionToThrow, exception.InnerException);
+            Assert.AreEqual(exception.InnerException.Message, exception.Message);
+            mocks.VerifyAll();
         }
 
-        private static void AssertConstructorValues(MacroStabilityInput input)
+        [Test]
+        public void Calculate_ExceptionDuringCalculation_OutputPropertiesNotSet()
         {
-            Assert.AreEqual(Orientation.Inwards, input.StabilityModel.Orientation);
-            Assert.IsNotNull(input.StabilityModel.BishopCalculationCircle);
-            Assert.AreEqual(SearchAlgorithm.Grid, input.StabilityModel.SearchAlgorithm);
-            Assert.AreEqual(StabilityModelOptionType.UpliftVan, input.StabilityModel.ModelOption);
-            
-            Assert.AreEqual(0.8, input.PreprocessingInput.SearchAreaConditions.MaxSpacingBetweenBoundaries);
-            Assert.IsTrue(input.PreprocessingInput.SearchAreaConditions.OnlyAbovePleistoceen);
+            // Setup
+            var mocks = new MockRepository();
+            var calculator = mocks.Stub<ICalculator>();
+            calculator.Stub(c => c.Calculate()).Throw(new Exception());
+            var validator = mocks.Stub<IValidator>();
+            mocks.ReplayAll();
 
-            Assert.AreEqual(2, input.PreprocessingInput.PreConstructionStages.Count);
-            Assert.IsTrue(input.PreprocessingInput.PreConstructionStages.All(stage => stage.WaternetCreationMode == WaternetCreationMode.FillInWaternetValues));
-        }
+            var kernel = new UpliftVanKernelWrapper(calculator, validator);
 
-        private static void AssertConstructionStages(IEnumerable<ConstructionStage> constructionStages, SoilProfile soilProfile2D, IEnumerable<WtiStabilityWaternet> waternets,
-                                                     IEnumerable<FixedSoilStress> fixedSoilStresses, IEnumerable<PreconsolidationStress> preConsolidationStresses)
-        {
-            Assert.AreEqual(2, constructionStages.Count());
+            // Call
+            void Call() => kernel.Calculate();
 
-            for (var i = 0; i < constructionStages.Count(); i++)
-            {
-                ConstructionStage constructionStage = constructionStages.ElementAt(i);
-
-                Assert.AreSame(waternets.ElementAt(i), constructionStage.Waternet);
-                Assert.AreSame(soilProfile2D, constructionStage.SoilProfile);
-                Assert.AreEqual(1, constructionStage.MultiplicationFactorsCPhiForUplift.Count);
-                Assert.AreEqual(1.2, constructionStage.MultiplicationFactorsCPhiForUplift.ElementAt(0).UpliftFactor);
-                Assert.AreEqual(0.0, constructionStage.MultiplicationFactorsCPhiForUplift.ElementAt(0).MultiplicationFactor);
-            }
-
-            CollectionAssert.AreEqual(fixedSoilStresses, constructionStages.First().FixedSoilStresses);
-            CollectionAssert.AreEqual(preConsolidationStresses, constructionStages.First().PreconsolidationStresses);
-            CollectionAssert.IsEmpty(constructionStages.Last().FixedSoilStresses);
-            CollectionAssert.IsEmpty(constructionStages.Last().PreconsolidationStresses);
+            // Assert
+            Assert.Throws<UpliftVanKernelWrapperException>(Call);
+            Assert.IsNaN(kernel.FactorOfStability);
+            Assert.IsNaN(kernel.ForbiddenZonesXEntryMax);
+            Assert.IsNaN(kernel.ForbiddenZonesXEntryMin);
+            Assert.IsNull(kernel.SlidingCurveResult);
+            Assert.IsNull(kernel.UpliftVanCalculationGridResult);
+            mocks.VerifyAll();
         }
 
-        private static UpliftVanKernelWrapper CreateValidKernel(Soil soil)
+        [Test]
+        public void Validate_ValidationCompleted_ReturnsValidationMessages()
         {
-            var point1 = new Point2D(-50, -50);
-            var point2 = new Point2D(100, -50);
-            var point3 = new Point2D(100, 6);
-            var point4 = new Point2D(50, 6);
-            var point5 = new Point2D(0, 10);
-            var point6 = new Point2D(-25, 10);
-            var point7 = new Point2D(-35, 6);
-            var point8 = new Point2D(-50, 6);
-            var curve1 = new GeometryCurve(point1, point2);
-            var curve2 = new GeometryCurve(point2, point3);
-            var curve3 = new GeometryCurve(point3, point4);
-            var curve4 = new GeometryCurve(point4, point5);
-            var curve5 = new GeometryCurve(point5, point6);
-            var curve6 = new GeometryCurve(point6, point7);
-            var curve7 = new GeometryCurve(point7, point8);
-            var curve8 = new GeometryCurve(point8, point1);
-            var loop = new GeometryLoop
+            // Setup
+            var validationOutput = new ValidationOutput
             {
-                CurveList =
-                {
-                    curve1,
-                    curve2,
-                    curve3,
-                    curve4,
-                    curve5,
-                    curve6,
-                    curve7,
-                    curve8
-                }
+                Messages = new Message[0]
             };
-            var geometrySurface = new GeometrySurface
-            {
-                OuterLoop = loop
-            };
-            var kernelWrapper = new UpliftVanKernelWrapper();
-            kernelWrapper.SetSoils(new List<Soil>
-            {
-                soil
-            });
-            kernelWrapper.SetSoilProfile(new SoilProfile2D
-            {
-                Geometry = new GeometryData
-                {
-                    Points =
-                    {
-                        point1,
-                        point2,
-                        point3,
-                        point4,
-                        point5,
-                        point6,
-                        point7,
-                        point8
-                    },
-                    Curves =
-                    {
-                        curve1,
-                        curve2,
-                        curve3,
-                        curve4,
-                        curve5,
-                        curve6,
-                        curve7,
-                        curve8
-                    },
-                    Loops =
-                    {
-                        loop
-                    },
-                    Surfaces =
-                    {
-                        geometrySurface
-                    },
-                    Left = -50,
-                    Right = 100,
-                    Bottom = -50
-                },
-                Surfaces =
-                {
-                    new SoilLayer2D
-                    {
-                        GeometrySurface = geometrySurface,
-                        Soil = soil
-                    }
-                }
-            });
-            kernelWrapper.SetUpliftVanCalculationGrid(new SlipPlaneUpliftVan
-            {
-                SlipPlaneLeftGrid = new SlipCircleGrid
-                {
-                    GridXLeft = -10.0,
-                    GridXRight = 20.0,
-                    GridZBottom = 12.0,
-                    GridZTop = 25.0,
-                    GridXNumber = 5,
-                    GridZNumber = 5
-                },
-                SlipPlaneRightGrid = new SlipCircleGrid
-                {
-                    GridXLeft = 30,
-                    GridXRight = 60,
-                    GridZBottom = 10.0,
-                    GridZTop = 20.0,
-                    GridXNumber = 5,
-                    GridZNumber = 5
-                }
-            });
-            var surfaceLine = new SurfaceLine2
-            {
-                Geometry = new GeometryPointString
-                {
-                    CalcPoints =
-                    {
-                        point8,
-                        point7,
-                        point6,
-                        point5,
-                        point4,
-                        point3
-                    }
-                }
-            };
-            surfaceLine.Geometry.SyncPoints();
-            surfaceLine.CharacteristicPoints.Add(new CharacteristicPoint
-            {
-                CharacteristicPointType = CharacteristicPointType.DikeTopAtPolder,
-                X = 0,
-                Z = 10,
-                GeometryPoint = surfaceLine.Geometry.Points[5]
-            });
 
-            kernelWrapper.SetSurfaceLine(surfaceLine);
-            kernelWrapper.SetGridAutomaticDetermined(false);
-            kernelWrapper.SetMoveGrid(true);
-            kernelWrapper.SetMaximumSliceWidth(100);
-            kernelWrapper.SetSlipPlaneConstraints(new SlipPlaneConstraints
-            {
-                XLeftMin = 0.0,
-                XLeftMax = 100
-            });
+            var mocks = new MockRepository();
+            var calculator = mocks.Stub<ICalculator>();
+            var validator = mocks.Stub<IValidator>();
+            validator.Stub(v => v.Validate()).Return(validationOutput);
+            mocks.ReplayAll();
 
-            return kernelWrapper;
-        }
+            var kernel = new UpliftVanKernelWrapper(calculator, validator);
 
-        private static UpliftVanKernelWrapper CreateInvalidKernel(Soil soil)
-        {
-            var point1 = new Point2D(0, 0);
-            var point2 = new Point2D(1, 1);
-            var point3 = new Point2D(2, 2);
-            var point4 = new Point2D(3, 3);
-            var curve1 = new GeometryCurve(point1, point2);
-            var curve2 = new GeometryCurve(point2, point3);
-            var curve3 = new GeometryCurve(point3, point4);
-            var curve4 = new GeometryCurve(point4, point1);
-            var loop = new GeometryLoop
-            {
-                CurveList =
-                {
-                    curve1,
-                    curve2,
-                    curve3,
-                    curve4
-                }
-            };
-            var geometrySurface = new GeometrySurface
-            {
-                OuterLoop = loop
-            };
-            var kernelWrapper = new UpliftVanKernelWrapper();
-            kernelWrapper.SetSoils(new List<Soil>
-            {
-                soil
-            });
-            kernelWrapper.SetSoilProfile(new SoilProfile2D
-            {
-                Geometry = new GeometryData
-                {
-                    Points =
-                    {
-                        point1,
-                        point2,
-                        point3,
-                        point4
-                    },
-                    Curves =
-                    {
-                        curve1,
-                        curve2,
-                        curve3,
-                        curve4
-                    },
-                    Loops =
-                    {
-                        loop
-                    },
-                    Surfaces =
-                    {
-                        geometrySurface
-                    }
-                },
-                Surfaces =
-                {
-                    new SoilLayer2D
-                    {
-                        GeometrySurface = geometrySurface,
-                        Soil = soil
-                    }
-                }
-            });
-            kernelWrapper.SetUpliftVanCalculationGrid(new SlipPlaneUpliftVan());
-            kernelWrapper.SetMoveGrid(true);
-            kernelWrapper.SetMaximumSliceWidth(0);
-            kernelWrapper.SetSlipPlaneConstraints(new SlipPlaneConstraints());
+            // Call
+            IEnumerable<Message> validationMessages = kernel.Validate();
 
-            return kernelWrapper;
+            // Assert
+            Assert.AreSame(validationOutput.Messages, validationMessages);
+            mocks.VerifyAll();
         }
 
-        private static void AssertIrrelevantValues(StabilityInput stabilityModel)
+        [Test]
+        public void Validate_ExceptionInWrappedKernel_ThrowsUpliftVanKernelWrapperException()
         {
-            Assert.IsNotNull(stabilityModel.BeeswarmOptions);
-            Assert.IsNotNull(stabilityModel.SpencerSlipPlanes);
-            Assert.IsNotNull(stabilityModel.LevenbergMarquardtOptions);
-            Assert.IsNull(stabilityModel.MinimumSafetyCurve); // Output
-            Assert.AreEqual(0.8, stabilityModel.RequiredForcePointsInSlices); // Only for Spencer
-            Assert.AreEqual(60.0, stabilityModel.MaxAllowedAngleBetweenSlices); // Only for Spencer
-            Assert.AreEqual(9.81, stabilityModel.UnitWeightWater);
-            Assert.AreEqual(2, stabilityModel.TraversalGridPoints);
-            Assert.AreEqual(50, stabilityModel.MaxGridMoves);
-            Assert.IsNotNull(stabilityModel.Validator);
-            Assert.AreEqual(0, stabilityModel.TraversalRefinements);
-            Assert.IsFalse(stabilityModel.FinalizeWithLevenbergMarquardt);
-            Assert.IsNotNull(stabilityModel.GeneticAlgorithmOptions); // Only for genetic search algorithm
-            Assert.IsNotNull(stabilityModel.LevenbergMarquardtOptions); // Only for Levenberg Marquardt search algorithm
-        }
+            // Setup
+            var exceptionToThrow = new Exception();
 
-        private static void AssertPreProcessingModel(PreprocessingModel preProcessingModel)
-        {
-            Assert.AreEqual(Enumerable.Empty<LogMessage>(), preProcessingModel.LogMessages);
-            Assert.AreEqual(preProcessingModel.StabilityModel, preProcessingModel.StabilityModel);
-        }
+            var mocks = new MockRepository();
+            var calculator = mocks.Stub<ICalculator>();
+            var validator = mocks.Stub<IValidator>();
+            validator.Stub(v => v.Validate()).Throw(exceptionToThrow);
+            mocks.ReplayAll();
 
-        private static void AssertStabilityOutputModel(StabilityOutputModel stabilityOutputModel)
-        {
-            Assert.AreEqual(Enumerable.Empty<LogMessage>(), stabilityOutputModel.LogMessages);
-            Assert.AreEqual(ModelOptions.Bishop, stabilityOutputModel.ModelOption);
-            Assert.IsFalse(stabilityOutputModel.Succeeded);
-            Assert.AreEqual(0.0, stabilityOutputModel.SafetyFactor);
-            Assert.AreEqual(0.0, stabilityOutputModel.ZValue);
-            Assert.IsNull(stabilityOutputModel.MinimumSlidingCurve);
-            Assert.IsNotNull(stabilityOutputModel.VersionInfo);
-            Assert.IsNotNull(stabilityOutputModel.PreProcessingOutput);
+            var kernel = new UpliftVanKernelWrapper(calculator, validator);
+
+            // Call
+            void Call() => kernel.Validate();
+
+            // Assert
+            var exception = Assert.Throws<UpliftVanKernelWrapperException>(Call);
+            Assert.AreSame(exceptionToThrow, exception.InnerException);
+            Assert.AreEqual(exception.InnerException.Message, exception.Message);
         }
     }
 }
\ No newline at end of file