Index: Riskeer/MacroStabilityInwards/src/Riskeer.MacroStabilityInwards.KernelWrapper/Kernels/Waternet/IWaternetKernel.cs
===================================================================
diff -u -rfe0f11c19023237d7f3629c2206b4fe5eb5e121f -rf9472b2b0e70a6c8e2c9f78cfd622c8a099acaee
--- Riskeer/MacroStabilityInwards/src/Riskeer.MacroStabilityInwards.KernelWrapper/Kernels/Waternet/IWaternetKernel.cs	(.../IWaternetKernel.cs)	(revision fe0f11c19023237d7f3629c2206b4fe5eb5e121f)
+++ Riskeer/MacroStabilityInwards/src/Riskeer.MacroStabilityInwards.KernelWrapper/Kernels/Waternet/IWaternetKernel.cs	(.../IWaternetKernel.cs)	(revision f9472b2b0e70a6c8e2c9f78cfd622c8a099acaee)
@@ -20,11 +20,10 @@
 // All rights reserved.
 
 using System.Collections.Generic;
-using Deltares.MacroStability.CSharpWrapper.Input;
 using Deltares.MacroStability.CSharpWrapper.Output;
 using Deltares.MacroStability.Standard;
 using Riskeer.MacroStabilityInwards.KernelWrapper.Calculators.Waternet;
-using WtiStabilityWaternet = Deltares.MacroStability.CSharpWrapper.Waternet;
+using CSharpWrapperWaternet = Deltares.MacroStability.CSharpWrapper.Waternet;
 
 namespace Riskeer.MacroStabilityInwards.KernelWrapper.Kernels.Waternet
 {
@@ -43,7 +42,7 @@
         /// <summary>
         /// Gets the Waternet result.
         /// </summary>
-        WtiStabilityWaternet Waternet { get; }
+        CSharpWrapperWaternet Waternet { get; }
 
         /// <summary>
         /// Performs the Waternet calculation.
Index: Riskeer/MacroStabilityInwards/src/Riskeer.MacroStabilityInwards.KernelWrapper/Kernels/Waternet/WaternetKernelWrapper.cs
===================================================================
diff -u -rfe0f11c19023237d7f3629c2206b4fe5eb5e121f -rf9472b2b0e70a6c8e2c9f78cfd622c8a099acaee
--- Riskeer/MacroStabilityInwards/src/Riskeer.MacroStabilityInwards.KernelWrapper/Kernels/Waternet/WaternetKernelWrapper.cs	(.../WaternetKernelWrapper.cs)	(revision fe0f11c19023237d7f3629c2206b4fe5eb5e121f)
+++ Riskeer/MacroStabilityInwards/src/Riskeer.MacroStabilityInwards.KernelWrapper/Kernels/Waternet/WaternetKernelWrapper.cs	(.../WaternetKernelWrapper.cs)	(revision f9472b2b0e70a6c8e2c9f78cfd622c8a099acaee)
@@ -26,13 +26,12 @@
 using Deltares.MacroStability.CSharpWrapper.Output;
 using Deltares.MacroStability.CSharpWrapper.Output.WaternetCreator;
 using Deltares.MacroStability.Standard;
-using Deltares.MacroStability.WaternetCreator;
-using WtiStabilityWaternet = Deltares.MacroStability.CSharpWrapper.Waternet;
+using CSharpWrapperWaternet = Deltares.MacroStability.CSharpWrapper.Waternet;
 
 namespace Riskeer.MacroStabilityInwards.KernelWrapper.Kernels.Waternet
 {
     /// <summary>
-    /// Class that wraps <see cref="WTIStabilityCalculation"/> for performing a Waternet calculation.
+    /// Class that wraps the <see cref="Deltares.MacroStability.CSharpWrapper"/> for performing a Waternet calculation.
     /// </summary>
     internal class WaternetKernelWrapper : IWaternetKernel
     {
@@ -43,17 +42,29 @@
         /// <summary>
         /// Creates a new instance of <see cref="WaternetKernelWrapper"/>.
         /// </summary>
-        /// <param name="location">The <see cref="Location"/> to use.</param>
+        /// <param name="calculator">The <see cref="ICalculator"/> to use.</param>
+        /// <param name="validator">The <see cref="IValidator"/> to use.</param>
         /// <param name="waternetName">The name of the <see cref="Waternet"/>.</param>
-        /// <param name="waternetCreatorInput"></param>
+        /// <exception cref="ArgumentNullException">Thrown when <paramref name="calculator"/>
+        /// or <paramref name="validator"/> is <c>null</c>.</exception>
         public WaternetKernelWrapper(ICalculator calculator, IValidator validator, string waternetName)
         {
+            if (calculator == null)
+            {
+                throw new ArgumentNullException(nameof(calculator));
+            }
+
+            if (validator == null)
+            {
+                throw new ArgumentNullException(nameof(validator));
+            }
+
             this.calculator = calculator;
             this.validator = validator;
             this.waternetName = waternetName;
         }
 
-        public WtiStabilityWaternet Waternet { get; private set; }
+        public CSharpWrapperWaternet Waternet { get; private set; }
 
         public void Calculate()
         {
Index: Riskeer/MacroStabilityInwards/test/Riskeer.MacroStabilityInwards.KernelWrapper.Test/Kernels/Waternet/WaternetKernelWrapperTest.cs
===================================================================
diff -u -rca9e457de56679e8bdbba7953235b02543cbfac3 -rf9472b2b0e70a6c8e2c9f78cfd622c8a099acaee
--- Riskeer/MacroStabilityInwards/test/Riskeer.MacroStabilityInwards.KernelWrapper.Test/Kernels/Waternet/WaternetKernelWrapperTest.cs	(.../WaternetKernelWrapperTest.cs)	(revision ca9e457de56679e8bdbba7953235b02543cbfac3)
+++ Riskeer/MacroStabilityInwards/test/Riskeer.MacroStabilityInwards.KernelWrapper.Test/Kernels/Waternet/WaternetKernelWrapperTest.cs	(.../WaternetKernelWrapperTest.cs)	(revision f9472b2b0e70a6c8e2c9f78cfd622c8a099acaee)
@@ -19,315 +19,243 @@
 // Stichting Deltares and remain full property of Stichting Deltares at all times.
 // All rights reserved.
 
+using System;
 using System.Collections.Generic;
-using System.Linq;
-using Core.Common.Util.Reflection;
-using Deltares.MacroStability.Geometry;
-using Deltares.MacroStability.Standard;
-using Deltares.MacroStability.WaternetCreator;
+using Deltares.MacroStability.CSharpWrapper;
+using Deltares.MacroStability.CSharpWrapper.Output;
+using Deltares.MacroStability.CSharpWrapper.Output.WaternetCreator;
 using NUnit.Framework;
+using Rhino.Mocks;
 using Riskeer.MacroStabilityInwards.KernelWrapper.Kernels.Waternet;
-using WtiStabilityWaternet = Deltares.MacroStability.Geometry.Waternet;
+using CSharpWrapperWaternet = Deltares.MacroStability.CSharpWrapper.Waternet;
 
 namespace Riskeer.MacroStabilityInwards.KernelWrapper.Test.Kernels.Waternet
 {
     [TestFixture]
     public class WaternetKernelWrapperTest
     {
         [Test]
-        public void Constructor_ExpectedValues()
+        public void Constructor_CalculatorNull_ThrowsArgumentNullException()
         {
             // Setup
-            var location = new Location();
+            var mocks = new MockRepository();
+            var validator = mocks.Stub<IValidator>();
+            mocks.ReplayAll();
 
             // Call
-            var kernel = new WaternetKernelWrapper(location, "Waternet");
+            void Call() => new WaternetKernelWrapper(null, validator, string.Empty);
 
             // Assert
-            Assert.IsInstanceOf<IWaternetKernel>(kernel);
-            Assert.IsNull(location.Surfaceline);
-            Assert.IsNull(location.SoilProfile2D);
+            var exception = Assert.Throws<ArgumentNullException>(Call);
+            Assert.AreEqual("calculator", exception.ParamName);
+            mocks.VerifyAll();
         }
 
         [Test]
-        public void Constructor_CompleteInput_InputCorrectlySetToWrappedKernel()
+        public void Constructor_ValidatorNull_ThrowsArgumentNullException()
         {
             // Setup
-            var location = new Location();
-            var soilProfile2D = new SoilProfile2D();
-            var surfaceLine = new SurfaceLine2();
+            var mocks = new MockRepository();
+            var calculator = mocks.Stub<ICalculator>();
+            mocks.ReplayAll();
 
             // Call
-            var kernel = new WaternetKernelWrapper(location, "Waternet");
-            kernel.SetSoilProfile(soilProfile2D);
-            kernel.SetSurfaceLine(surfaceLine);
+            void Call() => new WaternetKernelWrapper(calculator, null, string.Empty);
 
             // Assert
-            var waternetCreator = TypeUtils.GetField<WaternetCreator>(kernel, "waternetCreator");
+            var exception = Assert.Throws<ArgumentNullException>(Call);
+            Assert.AreEqual("validator", exception.ParamName);
+            mocks.VerifyAll();
+        }
 
-            Assert.AreSame(surfaceLine, location.Surfaceline);
-            Assert.AreSame(soilProfile2D, location.SoilProfile2D);
-            Assert.AreEqual(9.81, kernel.Waternet.UnitWeight);
+        [Test]
+        public void Constructor_ExpectedValues()
+        {
+            // Setup
+            var mocks = new MockRepository();
+            var calculator = mocks.Stub<ICalculator>();
+            var validator = mocks.Stub<IValidator>();
+            mocks.ReplayAll();
 
-            AssertIrrelevantValues(kernel.Waternet, waternetCreator);
+            // Call
+            var kernel = new WaternetKernelWrapper(calculator, validator, "Waternet");
+
+            // Assert
+            Assert.IsInstanceOf<IWaternetKernel>(kernel);
+            Assert.IsNull(kernel.Waternet);
+            mocks.VerifyAll();
         }
 
         [Test]
-        public void Calculate_ExceptionInWrappedKernel_ThrowsWaternetKernelWrapperException()
+        public void Calculate_SuccessfulCalculation_WaternetSet()
         {
             // Setup
-            var kernel = new WaternetKernelWrapper(new Location(), "Waternet");
+            const string name = "Waternet";
 
+            var output = new WaternetCreatorOutput
+            {
+                Waternet = new CSharpWrapperWaternet()
+            };
+
+            var mocks = new MockRepository();
+            var calculator = mocks.Stub<ICalculator>();
+            calculator.Stub(c => c.CalculateWaternet(0)).Return(output);
+            var validator = mocks.Stub<IValidator>();
+            mocks.ReplayAll();
+
+            var kernel = new WaternetKernelWrapper(calculator, validator, name);
+
             // Call
-            void Call() => kernel.Calculate();
+            kernel.Calculate();
 
             // Assert
-            var exception = Assert.Throws<WaternetKernelWrapperException>(Call);
-            Assert.IsNotNull(exception.InnerException);
-            Assert.AreEqual(exception.InnerException.Message, exception.Message);
+            Assert.AreSame(output.Waternet, kernel.Waternet);
+            Assert.AreEqual(name, kernel.Waternet.Name);
+            mocks.VerifyAll();
         }
 
         [Test]
-        public void Validate_CompleteInput_NoValidationMessages()
+        public void Calculate_WaternetCannotBeGenerated_ThrowsWaternetKernelWrapperException()
         {
             // Setup
-            WaternetKernelWrapper kernel = CreateValidKernel(new Soil
+            var mocks = new MockRepository();
+            var calculator = mocks.Stub<ICalculator>();
+            var validator = mocks.Stub<IValidator>();
+            validator.Stub(v => v.ValidateWaternetCreator()).Return(new ValidationOutput
             {
-                ShearStrengthModel = ShearStrengthModel.CPhi,
-                AbovePhreaticLevel = 15.0,
-                BelowPhreaticLevel = 15.0,
-                Cohesion = 10.0,
-                Dilatancy = 10.0,
-                FrictionAngle = 10.0
+                IsValid = false
             });
+            mocks.ReplayAll();
 
+            var kernel = new WaternetKernelWrapper(calculator, validator, string.Empty);
+
             // Call
-            IEnumerable<IValidationResult> validationMessages = kernel.Validate();
+            void Call() => kernel.Calculate();
 
             // Assert
-            CollectionAssert.IsEmpty(validationMessages);
+            Assert.Throws<WaternetKernelWrapperException>(Call);
+            mocks.VerifyAll();
         }
 
         [Test]
-        public void Validate_InputNotComplete_ReturnsValidationMessages()
+        public void Calculate_ExceptionInWrappedKernel_ThrowsWaternetKernelWrapperException()
         {
             // Setup
-            var location = new Location
-            {
-                WaternetCreationMode = WaternetCreationMode.CreateWaternet
-            };
+            var exceptionToThrow = new Exception();
 
-            var kernel = new WaternetKernelWrapper(location, "Waternet");
+            var mocks = new MockRepository();
+            var calculator = mocks.Stub<ICalculator>();
+            calculator.Stub(c => c.CalculateWaternet(0)).Throw(exceptionToThrow);
+            var validator = mocks.Stub<IValidator>();
+            mocks.ReplayAll();
 
+            var kernel = new WaternetKernelWrapper(calculator, validator, string.Empty);
+
             // Call
-            IEnumerable<IValidationResult> validationMessages = kernel.Validate();
+            void Call() => kernel.Calculate();
 
             // Assert
-            CollectionAssert.IsNotEmpty(validationMessages);
+            var exception = Assert.Throws<WaternetKernelWrapperException>(Call);
+            Assert.AreSame(exceptionToThrow, exception.InnerException);
+            Assert.AreEqual(exception.InnerException.Message, exception.Message);
+            mocks.VerifyAll();
         }
 
-        private static WaternetKernelWrapper CreateValidKernel(Soil soil)
+        [Test]
+        public void Calculate_ErrorMessageInCalculationOutput_ThrowsWaternetKernelWrapperException()
         {
-            var location = new Location
-            {
-                WaternetCreationMode = WaternetCreationMode.CreateWaternet,
-                Inwards = true,
-                PenetrationLength = 2,
-                HeadInPlLine2Outwards = 1,
-                WaterLevelPolder = 1,
-                PlLineCreationMethod = PlLineCreationMethod.RingtoetsWti2017,
-                PlLineOffsetBelowDikeToeAtPolder = 1,
-                PlLineOffsetBelowDikeTopAtPolder = 1,
-                PlLineOffsetBelowShoulderBaseInside = 1,
-                MinimumLevelPhreaticLineAtDikeTopRiver = 1,
-                MinimumLevelPhreaticLineAtDikeTopPolder = 1,
-                DikeSoilScenario = DikeSoilScenario.ClayDikeOnSand
-            };
+            // Setup
+            const string message1 = "Message1";
+            const string message2 = "Message2";
+            const string message3 = "Message3";
 
-            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 point9 = new Point2D(100, -100);
-            var point10 = new Point2D(-50, -100);
-            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 curve9 = new GeometryCurve(point2, point9);
-            var curve10 = new GeometryCurve(point9, point10);
-            var curve11 = new GeometryCurve(point10, point1);
-            var loop1 = new GeometryLoop
+            var waternetCreatorOutput = new WaternetCreatorOutput
             {
-                CurveList =
+                Messages = new List<Message>
                 {
-                    curve1,
-                    curve2,
-                    curve3,
-                    curve4,
-                    curve5,
-                    curve6,
-                    curve7,
-                    curve8
-                }
-            };
-            var loop2 = new GeometryLoop
-            {
-                CurveList =
-                {
-                    curve1,
-                    curve9,
-                    curve10,
-                    curve11
-                }
-            };
-            var geometrySurface1 = new GeometrySurface
-            {
-                OuterLoop = loop1
-            };
-            var geometrySurface2 = new GeometrySurface
-            {
-                OuterLoop = loop2
-            };
-            var kernelWrapper = new WaternetKernelWrapper(location, "Waternet");
-            kernelWrapper.SetSoilProfile(new SoilProfile2D
-            {
-                Geometry = new GeometryData
-                {
-                    Points =
+                    new Message
                     {
-                        point1,
-                        point2,
-                        point3,
-                        point4,
-                        point5,
-                        point6,
-                        point7,
-                        point9,
-                        point10
+                        Content = message1,
+                        MessageType = MessageType.Error
                     },
-                    Curves =
+                    new Message
                     {
-                        curve1,
-                        curve2,
-                        curve3,
-                        curve4,
-                        curve5,
-                        curve6,
-                        curve7,
-                        curve8,
-                        curve9,
-                        curve10,
-                        curve11
+                        Content = message2,
+                        MessageType = MessageType.Error
                     },
-                    Loops =
+                    new Message
                     {
-                        loop1,
-                        loop2
-                    },
-                    Surfaces =
-                    {
-                        geometrySurface1,
-                        geometrySurface2
-                    },
-                    Left = -50,
-                    Right = 100,
-                    Bottom = -50
-                },
-                Surfaces =
-                {
-                    new SoilLayer2D
-                    {
-                        GeometrySurface = geometrySurface1,
-                        Soil = soil
-                    },
-                    new SoilLayer2D
-                    {
-                        GeometrySurface = geometrySurface2,
-                        Soil = soil,
-                        IsAquifer = true
+                        Content = message3,
+                        MessageType = MessageType.Warning
                     }
                 }
-            });
-            var surfaceLine = new SurfaceLine2
-            {
-                Geometry = new GeometryPointString
-                {
-                    CalcPoints =
-                    {
-                        point8,
-                        point7,
-                        point6,
-                        point5,
-                        point4,
-                        point3
-                    }
-                }
             };
-            surfaceLine.Geometry.SyncPoints();
-            surfaceLine.CharacteristicPoints.Add(new CharacteristicPoint
+
+            var mocks = new MockRepository();
+            var calculator = mocks.Stub<ICalculator>();
+            calculator.Stub(c => c.CalculateWaternet(0)).Return(waternetCreatorOutput);
+            var validator = mocks.Stub<IValidator>();
+            mocks.ReplayAll();
+
+            var kernel = new WaternetKernelWrapper(calculator, validator, string.Empty);
+
+            // Call
+            void Call() => kernel.Calculate();
+
+            // Assert
+            var exception = Assert.Throws<WaternetKernelWrapperException>(Call);
+            string expectedMessage = $"{message1}{Environment.NewLine}" +
+                                     $"{message2}";
+                                     Assert.AreEqual(expectedMessage, exception.Message);
+            mocks.VerifyAll();
+        }
+
+        [Test]
+        public void Validate_ValidationCompleted_ReturnsValidationMessages()
+        {
+            // Setup
+            var validationOutput = new ValidationOutput
             {
-                CharacteristicPointType = CharacteristicPointType.DikeToeAtPolder,
-                X = -10,
-                Z = 0,
-                GeometryPoint = surfaceLine.Geometry.Points[5]
-            });
-            surfaceLine.CharacteristicPoints.Add(new CharacteristicPoint
-            {
-                CharacteristicPointType = CharacteristicPointType.DikeTopAtPolder,
-                X = 0,
-                Z = 10,
-                GeometryPoint = surfaceLine.Geometry.Points[5]
-            });
-            surfaceLine.CharacteristicPoints.Add(new CharacteristicPoint
-            {
-                CharacteristicPointType = CharacteristicPointType.DikeTopAtRiver,
-                X = 10,
-                Z = 10,
-                GeometryPoint = surfaceLine.Geometry.Points[5]
-            });
-            surfaceLine.CharacteristicPoints.Add(new CharacteristicPoint
-            {
-                CharacteristicPointType = CharacteristicPointType.DikeToeAtRiver,
-                X = 20,
-                Z = 0,
-                GeometryPoint = surfaceLine.Geometry.Points[5]
-            });
-            surfaceLine.CharacteristicPoints.Add(new CharacteristicPoint
-            {
-                CharacteristicPointType = CharacteristicPointType.SurfaceLevelOutside,
-                X = 20,
-                Z = 0,
-                GeometryPoint = surfaceLine.Geometry.Points[5]
-            });
-            surfaceLine.CharacteristicPoints.Add(new CharacteristicPoint
-            {
-                CharacteristicPointType = CharacteristicPointType.SurfaceLevelInside,
-                X = 20,
-                Z = 0,
-                GeometryPoint = surfaceLine.Geometry.Points[5]
-            });
+                Messages = new Message[0]
+            };
 
-            kernelWrapper.SetSurfaceLine(surfaceLine);
+            var mocks = new MockRepository();
+            var calculator = mocks.Stub<ICalculator>();
+            var validator = mocks.Stub<IValidator>();
+            validator.Stub(v => v.ValidateWaternetCreator()).Return(validationOutput);
+            mocks.ReplayAll();
 
-            return kernelWrapper;
+            var kernel = new WaternetKernelWrapper(calculator, validator, string.Empty);
+
+            // Call
+            IEnumerable<Message> validationMessages = kernel.Validate();
+
+            // Assert
+            Assert.AreSame(validationOutput.Messages, validationMessages);
+            mocks.VerifyAll();
         }
 
-        private static void AssertIrrelevantValues(WtiStabilityWaternet waternet, WaternetCreator waternetCreator)
+        [Test]
+        public void Validate_ExceptionInWrappedKernel_ThrowsUpliftVanKernelWrapperException()
         {
-            Assert.AreEqual("Waternet", waternet.Name);
-            Assert.IsFalse(waternet.IsGenerated);
+            // Setup
+            var exceptionToThrow = new Exception();
 
-            Assert.AreEqual(Enumerable.Empty<LogMessage>(), waternetCreator.LogMessages);
-            Assert.AreEqual(LanguageType.Dutch, waternetCreator.Language);
+            var mocks = new MockRepository();
+            var calculator = mocks.Stub<ICalculator>();
+            var validator = mocks.Stub<IValidator>();
+            validator.Stub(v => v.ValidateWaternetCreator()).Throw(exceptionToThrow);
+            mocks.ReplayAll();
+
+            var kernel = new WaternetKernelWrapper(calculator, validator, string.Empty);
+
+            // Call
+            void Call() => kernel.Validate();
+
+            // Assert
+            var exception = Assert.Throws<WaternetKernelWrapperException>(Call);
+            Assert.AreSame(exceptionToThrow, exception.InnerException);
+            Assert.AreEqual(exception.InnerException.Message, exception.Message);
         }
     }
 }
\ No newline at end of file