Index: Ringtoets/Common/test/Ringtoets.Common.Data.Test/Hydraulics/WaveHeightCalculationTest.cs
===================================================================
diff -u -r55e286e8436b5061a9264ec8623b525f3015fe6e -rf27e8e2e7c8d056c76f2f883ae6bdf03edb740fc
--- Ringtoets/Common/test/Ringtoets.Common.Data.Test/Hydraulics/WaveHeightCalculationTest.cs	(.../WaveHeightCalculationTest.cs)	(revision 55e286e8436b5061a9264ec8623b525f3015fe6e)
+++ Ringtoets/Common/test/Ringtoets.Common.Data.Test/Hydraulics/WaveHeightCalculationTest.cs	(.../WaveHeightCalculationTest.cs)	(revision f27e8e2e7c8d056c76f2f883ae6bdf03edb740fc)
@@ -30,30 +30,24 @@
     [TestFixture]
     public class WaveHeightCalculationTest
     {
-        private static IEnumerable<TestCaseData> HydraulicBoundaryLocationsToCalculate
+        private static IEnumerable<TestCaseData> HydraulicBoundaryLocationCalculationsToPerform
         {
             get
             {
-                yield return new TestCaseData(new TestHydraulicBoundaryLocation("WithOutputWithoutIllustrationPoints")
+                yield return new TestCaseData(new HydraulicBoundaryLocationCalculation
                 {
-                    WaveHeightCalculation =
+                    InputParameters =
                     {
-                        InputParameters =
-                        {
-                            ShouldIllustrationPointsBeCalculated = true
-                        },
-                        Output = new TestHydraulicBoundaryLocationOutput(1.0, CalculationConvergence.CalculatedConverged)
-                    }
+                        ShouldIllustrationPointsBeCalculated = true
+                    },
+                    Output = new TestHydraulicBoundaryLocationOutput(1.0, CalculationConvergence.CalculatedConverged)
                 }, true);
 
-                yield return new TestCaseData(new TestHydraulicBoundaryLocation("WithoutOutput"), true);
+                yield return new TestCaseData(new HydraulicBoundaryLocationCalculation(), true);
 
-                yield return new TestCaseData(new TestHydraulicBoundaryLocation("WithValidOutput")
+                yield return new TestCaseData(new HydraulicBoundaryLocationCalculation
                 {
-                    WaveHeightCalculation =
-                    {
-                        Output = new TestHydraulicBoundaryLocationOutput(1.0, CalculationConvergence.CalculatedConverged)
-                    }
+                    Output = new TestHydraulicBoundaryLocationOutput(1.0, CalculationConvergence.CalculatedConverged)
                 }, false);
             }
         }
@@ -62,50 +56,55 @@
         public void Constructor_HydraulicBoundaryLocationNull_ThrowsArgumentNullException()
         {
             // Call
-            TestDelegate call = () => new WaveHeightCalculation(null);
+            TestDelegate call = () => new WaveHeightCalculation(null, new HydraulicBoundaryLocationCalculation());
 
             // Assert
             string paramName = Assert.Throws<ArgumentNullException>(call).ParamName;
             Assert.AreEqual("hydraulicBoundaryLocation", paramName);
         }
 
         [Test]
-        public void Constructor_ValidHydraulicBoundaryLocation_SetsProperties(
-            [Values(true, false)] bool calculateIllustrationPoints)
+        public void Constructor_HydraulicBoundaryLocationCalculationNull_ThrowsArgumentNullException()
         {
+            // Call
+            TestDelegate call = () => new WaveHeightCalculation(new TestHydraulicBoundaryLocation(), null);
+
+            // Assert
+            string paramName = Assert.Throws<ArgumentNullException>(call).ParamName;
+            Assert.AreEqual("hydraulicBoundaryLocationCalculation", paramName);
+        }
+
+        [Test]
+        public void Constructor_ValidInputParameters_SetsProperties([Values(true, false)] bool calculateIllustrationPoints)
+        {
             // Setup
-            var hydraulicBoundaryLocation = new HydraulicBoundaryLocation(1, "name", 1, 1)
+            var hydraulicBoundaryLocation = new TestHydraulicBoundaryLocation();
+            var hydraulicBoundaryLocationCalculation = new HydraulicBoundaryLocationCalculation
             {
-                WaveHeightCalculation =
+                InputParameters =
                 {
-                    InputParameters =
-                    {
-                        ShouldIllustrationPointsBeCalculated = calculateIllustrationPoints
-                    }
+                    ShouldIllustrationPointsBeCalculated = calculateIllustrationPoints
                 }
             };
 
             // Call
-            var calculation = new WaveHeightCalculation(hydraulicBoundaryLocation);
+            var calculation = new WaveHeightCalculation(hydraulicBoundaryLocation, hydraulicBoundaryLocationCalculation);
 
             // Assert
-            Assert.IsInstanceOf<IHydraulicBoundaryWrapperCalculation>(calculation);
+            Assert.IsInstanceOf<IHydraulicBoundaryCalculationWrapper>(calculation);
             Assert.AreEqual(hydraulicBoundaryLocation.Id, calculation.Id);
             Assert.AreSame(hydraulicBoundaryLocation.Name, calculation.Name);
-
-            HydraulicBoundaryLocationCalculation hydraulicBoundaryLocationCalculation = hydraulicBoundaryLocation.WaveHeightCalculation;
             Assert.AreEqual(hydraulicBoundaryLocationCalculation.InputParameters.ShouldIllustrationPointsBeCalculated, calculation.CalculateIllustrationPoints);
-
             Assert.AreSame(hydraulicBoundaryLocation, calculation.ObservableObject);
         }
 
         [Test]
-        [TestCaseSource(nameof(HydraulicBoundaryLocationsToCalculate))]
-        public void IsCalculated_HydraulicBoundaryLocationsToCalculate_ReturnIsCalculated(
-            HydraulicBoundaryLocation hydraulicBoundaryLocation, bool shouldBeCalculated)
+        [TestCaseSource(nameof(HydraulicBoundaryLocationCalculationsToPerform))]
+        public void IsCalculated_NotFullyCalculated_ReturnIsCalculated(HydraulicBoundaryLocationCalculation hydraulicBoundaryLocationCalculation,
+                                                                       bool shouldBeCalculated)
         {
             // Setup
-            var calculation = new WaveHeightCalculation(hydraulicBoundaryLocation);
+            var calculation = new DesignWaterLevelCalculation(new TestHydraulicBoundaryLocation(), hydraulicBoundaryLocationCalculation);
 
             // Call
             bool isCalculated = calculation.IsCalculated();
@@ -119,14 +118,15 @@
         {
             // Setup
             var hydraulicBoundaryLocation = new TestHydraulicBoundaryLocation();
-            var calculation = new WaveHeightCalculation(hydraulicBoundaryLocation);
+            var hydraulicBoundaryLocationCalculation = new HydraulicBoundaryLocationCalculation();
+            var calculation = new WaveHeightCalculation(hydraulicBoundaryLocation, hydraulicBoundaryLocationCalculation);
             var output = new TestHydraulicBoundaryLocationOutput(1);
 
             // Call
             calculation.Output = output;
 
             // Assert
-            Assert.AreSame(hydraulicBoundaryLocation.WaveHeightCalculation.Output, output);
+            Assert.AreSame(hydraulicBoundaryLocationCalculation.Output, output);
         }
     }
 }
\ No newline at end of file